lucene-java-3.5.0/lucene/contrib/analyzers/common/src/java/org/tartarus/snowball/ext/DanishStemmer.java

   1 // This file was generated automatically by the Snowball to Java compiler
   2
   3 package org.tartarus.snowball.ext;
   4 import org.tartarus.snowball.SnowballProgram;
   5 import org.tartarus.snowball.Among;
   6
   7 /**
   8  * Generated class implementing code defined by a snowball script.
   9  */
  10 public class DanishStemmer extends SnowballProgram {
  11
  12         private Among a_0[] = {
  13             new Among ( "hed", -1, 1, "", this),
  14             new Among ( "ethed", 0, 1, "", this),
  15             new Among ( "ered", -1, 1, "", this),
  16             new Among ( "e", -1, 1, "", this),
  17             new Among ( "erede", 3, 1, "", this),
  18             new Among ( "ende", 3, 1, "", this),
  19             new Among ( "erende", 5, 1, "", this),
  20             new Among ( "ene", 3, 1, "", this),
  21             new Among ( "erne", 3, 1, "", this),
  22             new Among ( "ere", 3, 1, "", this),
  23             new Among ( "en", -1, 1, "", this),
  24             new Among ( "heden", 10, 1, "", this),
  25             new Among ( "eren", 10, 1, "", this),
  26             new Among ( "er", -1, 1, "", this),
  27             new Among ( "heder", 13, 1, "", this),
  28             new Among ( "erer", 13, 1, "", this),
  29             new Among ( "s", -1, 2, "", this),
  30             new Among ( "heds", 16, 1, "", this),
  31             new Among ( "es", 16, 1, "", this),
  32             new Among ( "endes", 18, 1, "", this),
  33             new Among ( "erendes", 19, 1, "", this),
  34             new Among ( "enes", 18, 1, "", this),
  35             new Among ( "ernes", 18, 1, "", this),
  36             new Among ( "eres", 18, 1, "", this),
  37             new Among ( "ens", 16, 1, "", this),
  38             new Among ( "hedens", 24, 1, "", this),
  39             new Among ( "erens", 24, 1, "", this),
  40             new Among ( "ers", 16, 1, "", this),
  41             new Among ( "ets", 16, 1, "", this),
  42             new Among ( "erets", 28, 1, "", this),
  43             new Among ( "et", -1, 1, "", this),
  44             new Among ( "eret", 30, 1, "", this)
  45         };
  46
  47         private Among a_1[] = {
  48             new Among ( "gd", -1, -1, "", this),
  49             new Among ( "dt", -1, -1, "", this),
  50             new Among ( "gt", -1, -1, "", this),
  51             new Among ( "kt", -1, -1, "", this)
  52         };
  53
  54         private Among a_2[] = {
  55             new Among ( "ig", -1, 1, "", this),
  56             new Among ( "lig", 0, 1, "", this),
  57             new Among ( "elig", 1, 1, "", this),
  58             new Among ( "els", -1, 1, "", this),
  59             new Among ( "l\u00F8st", -1, 2, "", this)
  60         };
  61
  62         private static final char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 128 };
  63
  64         private static final char g_s_ending[] = {239, 254, 42, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16 };
  65
  66         private int I_x;
  67         private int I_p1;
  68         private StringBuilder S_ch = new StringBuilder();
  69
  70         private void copy_from(DanishStemmer other) {
  71             I_x = other.I_x;
  72             I_p1 = other.I_p1;
  73             S_ch = other.S_ch;
  74             super.copy_from(other);
  75         }
  76
  77         private boolean r_mark_regions() {
  78             int v_1;
  79             int v_2;
  80             // (, line 29
  81             I_p1 = limit;
  82             // test, line 33
  83             v_1 = cursor;
  84             // (, line 33
  85             // hop, line 33
  86             {
  87                 int c = cursor + 3;
  88                 if (0 > c || c > limit)
  89                 {
  90                     return false;
  91                 }
  92                 cursor = c;
  93             }
  94             // setmark x, line 33
  95             I_x = cursor;
  96             cursor = v_1;
  97             // goto, line 34
  98             golab0: while(true)
  99             {
 100                 v_2 = cursor;
 101                 lab1: do {
 102                     if (!(in_grouping(g_v, 97, 248)))
 103                     {
 104                         break lab1;
 105                     }
 106                     cursor = v_2;
 107                     break golab0;
 108                 } while (false);
 109                 cursor = v_2;
 110                 if (cursor >= limit)
 111                 {
 112                     return false;
 113                 }
 114                 cursor++;
 115             }
 116             // gopast, line 34
 117             golab2: while(true)
 118             {
 119                 lab3: do {
 120                     if (!(out_grouping(g_v, 97, 248)))
 121                     {
 122                         break lab3;
 123                     }
 124                     break golab2;
 125                 } while (false);
 126                 if (cursor >= limit)
 127                 {
 128                     return false;
 129                 }
 130                 cursor++;
 131             }
 132             // setmark p1, line 34
 133             I_p1 = cursor;
 134             // try, line 35
 135             lab4: do {
 136                 // (, line 35
 137                 if (!(I_p1 < I_x))
 138                 {
 139                     break lab4;
 140                 }
 141                 I_p1 = I_x;
 142             } while (false);
 143             return true;
 144         }
 145
 146         private boolean r_main_suffix() {
 147             int among_var;
 148             int v_1;
 149             int v_2;
 150             // (, line 40
 151             // setlimit, line 41
 152             v_1 = limit - cursor;
 153             // tomark, line 41
 154             if (cursor < I_p1)
 155             {
 156                 return false;
 157             }
 158             cursor = I_p1;
 159             v_2 = limit_backward;
 160             limit_backward = cursor;
 161             cursor = limit - v_1;
 162             // (, line 41
 163             // [, line 41
 164             ket = cursor;
 165             // substring, line 41
 166             among_var = find_among_b(a_0, 32);
 167             if (among_var == 0)
 168             {
 169                 limit_backward = v_2;
 170                 return false;
 171             }
 172             // ], line 41
 173             bra = cursor;
 174             limit_backward = v_2;
 175             switch(among_var) {
 176                 case 0:
 177                     return false;
 178                 case 1:
 179                     // (, line 48
 180                     // delete, line 48
 181                     slice_del();
 182                     break;
 183                 case 2:
 184                     // (, line 50
 185                     if (!(in_grouping_b(g_s_ending, 97, 229)))
 186                     {
 187                         return false;
 188                     }
 189                     // delete, line 50
 190                     slice_del();
 191                     break;
 192             }
 193             return true;
 194         }
 195
 196         private boolean r_consonant_pair() {
 197             int v_1;
 198             int v_2;
 199             int v_3;
 200             // (, line 54
 201             // test, line 55
 202             v_1 = limit - cursor;
 203             // (, line 55
 204             // setlimit, line 56
 205             v_2 = limit - cursor;
 206             // tomark, line 56
 207             if (cursor < I_p1)
 208             {
 209                 return false;
 210             }
 211             cursor = I_p1;
 212             v_3 = limit_backward;
 213             limit_backward = cursor;
 214             cursor = limit - v_2;
 215             // (, line 56
 216             // [, line 56
 217             ket = cursor;
 218             // substring, line 56
 219             if (find_among_b(a_1, 4) == 0)
 220             {
 221                 limit_backward = v_3;
 222                 return false;
 223             }
 224             // ], line 56
 225             bra = cursor;
 226             limit_backward = v_3;
 227             cursor = limit - v_1;
 228             // next, line 62
 229             if (cursor <= limit_backward)
 230             {
 231                 return false;
 232             }
 233             cursor--;
 234             // ], line 62
 235             bra = cursor;
 236             // delete, line 62
 237             slice_del();
 238             return true;
 239         }
 240
 241         private boolean r_other_suffix() {
 242             int among_var;
 243             int v_1;
 244             int v_2;
 245             int v_3;
 246             int v_4;
 247             // (, line 65
 248             // do, line 66
 249             v_1 = limit - cursor;
 250             lab0: do {
 251                 // (, line 66
 252                 // [, line 66
 253                 ket = cursor;
 254                 // literal, line 66
 255                 if (!(eq_s_b(2, "st")))
 256                 {
 257                     break lab0;
 258                 }
 259                 // ], line 66
 260                 bra = cursor;
 261                 // literal, line 66
 262                 if (!(eq_s_b(2, "ig")))
 263                 {
 264                     break lab0;
 265                 }
 266                 // delete, line 66
 267                 slice_del();
 268             } while (false);
 269             cursor = limit - v_1;
 270             // setlimit, line 67
 271             v_2 = limit - cursor;
 272             // tomark, line 67
 273             if (cursor < I_p1)
 274             {
 275                 return false;
 276             }
 277             cursor = I_p1;
 278             v_3 = limit_backward;
 279             limit_backward = cursor;
 280             cursor = limit - v_2;
 281             // (, line 67
 282             // [, line 67
 283             ket = cursor;
 284             // substring, line 67
 285             among_var = find_among_b(a_2, 5);
 286             if (among_var == 0)
 287             {
 288                 limit_backward = v_3;
 289                 return false;
 290             }
 291             // ], line 67
 292             bra = cursor;
 293             limit_backward = v_3;
 294             switch(among_var) {
 295                 case 0:
 296                     return false;
 297                 case 1:
 298                     // (, line 70
 299                     // delete, line 70
 300                     slice_del();
 301                     // do, line 70
 302                     v_4 = limit - cursor;
 303                     lab1: do {
 304                         // call consonant_pair, line 70
 305                         if (!r_consonant_pair())
 306                         {
 307                             break lab1;
 308                         }
 309                     } while (false);
 310                     cursor = limit - v_4;
 311                     break;
 312                 case 2:
 313                     // (, line 72
 314                     // <-, line 72
 315                     slice_from("l\u00F8s");
 316                     break;
 317             }
 318             return true;
 319         }
 320
 321         private boolean r_undouble() {
 322             int v_1;
 323             int v_2;
 324             // (, line 75
 325             // setlimit, line 76
 326             v_1 = limit - cursor;
 327             // tomark, line 76
 328             if (cursor < I_p1)
 329             {
 330                 return false;
 331             }
 332             cursor = I_p1;
 333             v_2 = limit_backward;
 334             limit_backward = cursor;
 335             cursor = limit - v_1;
 336             // (, line 76
 337             // [, line 76
 338             ket = cursor;
 339             if (!(out_grouping_b(g_v, 97, 248)))
 340             {
 341                 limit_backward = v_2;
 342                 return false;
 343             }
 344             // ], line 76
 345             bra = cursor;
 346             // -> ch, line 76
 347             S_ch = slice_to(S_ch);
 348             limit_backward = v_2;
 349             // name ch, line 77
 350             if (!(eq_v_b(S_ch)))
 351             {
 352                 return false;
 353             }
 354             // delete, line 78
 355             slice_del();
 356             return true;
 357         }
 358
 359         public boolean stem() {
 360             int v_1;
 361             int v_2;
 362             int v_3;
 363             int v_4;
 364             int v_5;
 365             // (, line 82
 366             // do, line 84
 367             v_1 = cursor;
 368             lab0: do {
 369                 // call mark_regions, line 84
 370                 if (!r_mark_regions())
 371                 {
 372                     break lab0;
 373                 }
 374             } while (false);
 375             cursor = v_1;
 376             // backwards, line 85
 377             limit_backward = cursor; cursor = limit;
 378             // (, line 85
 379             // do, line 86
 380             v_2 = limit - cursor;
 381             lab1: do {
 382                 // call main_suffix, line 86
 383                 if (!r_main_suffix())
 384                 {
 385                     break lab1;
 386                 }
 387             } while (false);
 388             cursor = limit - v_2;
 389             // do, line 87
 390             v_3 = limit - cursor;
 391             lab2: do {
 392                 // call consonant_pair, line 87
 393                 if (!r_consonant_pair())
 394                 {
 395                     break lab2;
 396                 }
 397             } while (false);
 398             cursor = limit - v_3;
 399             // do, line 88
 400             v_4 = limit - cursor;
 401             lab3: do {
 402                 // call other_suffix, line 88
 403                 if (!r_other_suffix())
 404                 {
 405                     break lab3;
 406                 }
 407             } while (false);
 408             cursor = limit - v_4;
 409             // do, line 89
 410             v_5 = limit - cursor;
 411             lab4: do {
 412                 // call undouble, line 89
 413                 if (!r_undouble())
 414                 {
 415                     break lab4;
 416                 }
 417             } while (false);
 418             cursor = limit - v_5;
 419             cursor = limit_backward;            return true;
 420         }
 421
 422 }
 423