001 package ch.uzh.ifi.attempto.aceeditor.grammar; 002 003 import java.util.ArrayList; 004 import java.util.HashMap; 005 006 import ch.uzh.ifi.attempto.chartparser.Nonterminal; 007 import ch.uzh.ifi.attempto.chartparser.Rule; 008 import ch.uzh.ifi.attempto.chartparser.StringRef; 009 import ch.uzh.ifi.attempto.chartparser.Terminal; 010 import ch.uzh.ifi.attempto.chartparser.Category; 011 import ch.uzh.ifi.attempto.chartparser.FeatureMap; 012 013 /** 014 * This grammar class is automatically generated by the SWI Prolog program "generate_java.pl". 015 */ 016 @SuppressWarnings("all") 017 public class ACEGrammar extends ch.uzh.ifi.attempto.chartparser.Grammar { 018 019 /** 020 * Creates a new grammar object. 021 */ 022 public ACEGrammar() { 023 super("text"); 024 ArrayList<Category> l = new ArrayList<Category>(); 025 Category c; 026 HashMap<Integer, StringRef> featureHash = new HashMap<Integer, StringRef>(); 027 028 // test=>declaration, fill 029 l.clear(); 030 featureHash.clear(); 031 c = new Nonterminal("test"); 032 l.add(c); 033 c = new Nonterminal("declaration"); 034 l.add(c); 035 c = new Nonterminal("fill"); 036 l.add(c); 037 addRule(new Rule(l, true)); 038 039 // test=>question, fill 040 l.clear(); 041 featureHash.clear(); 042 c = new Nonterminal("test"); 043 l.add(c); 044 c = new Nonterminal("question"); 045 l.add(c); 046 c = new Nonterminal("fill"); 047 l.add(c); 048 addRule(new Rule(l, true)); 049 050 // fill=>[] 051 l.clear(); 052 featureHash.clear(); 053 c = new Nonterminal("fill"); 054 l.add(c); 055 addRule(new Rule(l, true)); 056 057 // fill=>[-], fill 058 l.clear(); 059 featureHash.clear(); 060 c = new Nonterminal("fill"); 061 l.add(c); 062 c = new Terminal("-"); 063 l.add(c); 064 c = new Nonterminal("fill"); 065 l.add(c); 066 addRule(new Rule(l, true)); 067 068 // text=>[] 069 l.clear(); 070 featureHash.clear(); 071 c = new Nonterminal("text"); 072 l.add(c); 073 addRule(new Rule(l, true)); 074 075 // text=>declaration, text 076 l.clear(); 077 featureHash.clear(); 078 c = new Nonterminal("text"); 079 l.add(c); 080 c = new Nonterminal("declaration"); 081 l.add(c); 082 c = new Nonterminal("text"); 083 l.add(c); 084 addRule(new Rule(l, true)); 085 086 // text=>question 087 l.clear(); 088 featureHash.clear(); 089 c = new Nonterminal("text"); 090 l.add(c); 091 c = new Nonterminal("question"); 092 l.add(c); 093 addRule(new Rule(l, true)); 094 095 // declaration=>sentence, ['.'] 096 l.clear(); 097 featureHash.clear(); 098 c = new Nonterminal("declaration"); 099 l.add(c); 100 c = new Nonterminal("sentence"); 101 l.add(c); 102 c = new Terminal("."); 103 l.add(c); 104 addRule(new Rule(l, true)); 105 106 // question=>simple_sentence_2(whin:minus, whout:plus), [?] 107 l.clear(); 108 featureHash.clear(); 109 c = new Nonterminal("question"); 110 l.add(c); 111 c = new Nonterminal("simple_sentence_2"); 112 c.setFeature("whin", new StringRef("minus")); 113 c.setFeature("whout", new StringRef("plus")); 114 l.add(c); 115 c = new Terminal("?"); 116 l.add(c); 117 addRule(new Rule(l, true)); 118 119 // sentence=>sentence_coord_1 120 l.clear(); 121 featureHash.clear(); 122 c = new Nonterminal("sentence"); 123 l.add(c); 124 c = new Nonterminal("sentence_coord_1"); 125 l.add(c); 126 addRule(new Rule(l, true)); 127 128 // sentence~>['for every'], noun_constr, sentence_coord_1 129 l.clear(); 130 featureHash.clear(); 131 c = new Nonterminal("sentence"); 132 l.add(c); 133 c = new Terminal("for every"); 134 l.add(c); 135 c = new Nonterminal("noun_constr"); 136 l.add(c); 137 c = new Nonterminal("sentence_coord_1"); 138 l.add(c); 139 addRule(new Rule(l, false)); 140 141 // sentence~>[if], sentence_coord_1, [then], sentence_coord_1 142 l.clear(); 143 featureHash.clear(); 144 c = new Nonterminal("sentence"); 145 l.add(c); 146 c = new Terminal("if"); 147 l.add(c); 148 c = new Nonterminal("sentence_coord_1"); 149 l.add(c); 150 c = new Terminal("then"); 151 l.add(c); 152 c = new Nonterminal("sentence_coord_1"); 153 l.add(c); 154 addRule(new Rule(l, false)); 155 156 // sentence_coord_1=>sentence_coord_2 157 l.clear(); 158 featureHash.clear(); 159 c = new Nonterminal("sentence_coord_1"); 160 l.add(c); 161 c = new Nonterminal("sentence_coord_2"); 162 l.add(c); 163 addRule(new Rule(l, true)); 164 165 // sentence_coord_1~>sentence_coord_2, [or], sentence_coord_1 166 l.clear(); 167 featureHash.clear(); 168 c = new Nonterminal("sentence_coord_1"); 169 l.add(c); 170 c = new Nonterminal("sentence_coord_2"); 171 l.add(c); 172 c = new Terminal("or"); 173 l.add(c); 174 c = new Nonterminal("sentence_coord_1"); 175 l.add(c); 176 addRule(new Rule(l, false)); 177 178 // sentence_coord_2=>simple_sentence 179 l.clear(); 180 featureHash.clear(); 181 c = new Nonterminal("sentence_coord_2"); 182 l.add(c); 183 c = new Nonterminal("simple_sentence"); 184 l.add(c); 185 addRule(new Rule(l, true)); 186 187 // sentence_coord_2=>simple_sentence, [and], sentence_coord_2 188 l.clear(); 189 featureHash.clear(); 190 c = new Nonterminal("sentence_coord_2"); 191 l.add(c); 192 c = new Nonterminal("simple_sentence"); 193 l.add(c); 194 c = new Terminal("and"); 195 l.add(c); 196 c = new Nonterminal("sentence_coord_2"); 197 l.add(c); 198 addRule(new Rule(l, true)); 199 200 // simple_sentence~>['it is false that'], simple_sentence_2(whin:minus, whout:minus) 201 l.clear(); 202 featureHash.clear(); 203 c = new Nonterminal("simple_sentence"); 204 l.add(c); 205 c = new Terminal("it is false that"); 206 l.add(c); 207 c = new Nonterminal("simple_sentence_2"); 208 c.setFeature("whin", new StringRef("minus")); 209 c.setFeature("whout", new StringRef("minus")); 210 l.add(c); 211 addRule(new Rule(l, false)); 212 213 // simple_sentence=>['there is'], nounphrase(exist:plus, def:minus, pl:minus, whin:minus, whout:minus) 214 l.clear(); 215 featureHash.clear(); 216 c = new Nonterminal("simple_sentence"); 217 l.add(c); 218 c = new Terminal("there is"); 219 l.add(c); 220 c = new Nonterminal("nounphrase"); 221 c.setFeature("exist", new StringRef("plus")); 222 c.setFeature("def", new StringRef("minus")); 223 c.setFeature("pl", new StringRef("minus")); 224 c.setFeature("whin", new StringRef("minus")); 225 c.setFeature("whout", new StringRef("minus")); 226 l.add(c); 227 addRule(new Rule(l, true)); 228 229 // simple_sentence=>['there is'], nounphrase(exist:plus, def:minus, pl:minus, whin:minus, whout:minus), ['such that'], simple_sentence 230 l.clear(); 231 featureHash.clear(); 232 c = new Nonterminal("simple_sentence"); 233 l.add(c); 234 c = new Terminal("there is"); 235 l.add(c); 236 c = new Nonterminal("nounphrase"); 237 c.setFeature("exist", new StringRef("plus")); 238 c.setFeature("def", new StringRef("minus")); 239 c.setFeature("pl", new StringRef("minus")); 240 c.setFeature("whin", new StringRef("minus")); 241 c.setFeature("whout", new StringRef("minus")); 242 l.add(c); 243 c = new Terminal("such that"); 244 l.add(c); 245 c = new Nonterminal("simple_sentence"); 246 l.add(c); 247 addRule(new Rule(l, true)); 248 249 // simple_sentence=>['there are'], nounphrase(exist:plus, def:minus, pl:plus, whin:minus, whout:minus) 250 l.clear(); 251 featureHash.clear(); 252 c = new Nonterminal("simple_sentence"); 253 l.add(c); 254 c = new Terminal("there are"); 255 l.add(c); 256 c = new Nonterminal("nounphrase"); 257 c.setFeature("exist", new StringRef("plus")); 258 c.setFeature("def", new StringRef("minus")); 259 c.setFeature("pl", new StringRef("plus")); 260 c.setFeature("whin", new StringRef("minus")); 261 c.setFeature("whout", new StringRef("minus")); 262 l.add(c); 263 addRule(new Rule(l, true)); 264 265 // simple_sentence=>simple_sentence_2(whin:minus, whout:minus) 266 l.clear(); 267 featureHash.clear(); 268 c = new Nonterminal("simple_sentence"); 269 l.add(c); 270 c = new Nonterminal("simple_sentence_2"); 271 c.setFeature("whin", new StringRef("minus")); 272 c.setFeature("whout", new StringRef("minus")); 273 l.add(c); 274 addRule(new Rule(l, true)); 275 276 // simple_sentence_2(whin:A, whout:B)=>nounphrase(exist:plus, pl:C, whin:A, whout:D), verbphrase_coord_1(pl:C, whin:D, whout:B) 277 l.clear(); 278 featureHash.clear(); 279 c = new Nonterminal("simple_sentence_2"); 280 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 281 setFeature(c.getFeatureMap(), "whout", 1, featureHash); 282 l.add(c); 283 c = new Nonterminal("nounphrase"); 284 c.setFeature("exist", new StringRef("plus")); 285 setFeature(c.getFeatureMap(), "pl", 2, featureHash); 286 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 287 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 288 l.add(c); 289 c = new Nonterminal("verbphrase_coord_1"); 290 setFeature(c.getFeatureMap(), "pl", 2, featureHash); 291 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 292 setFeature(c.getFeatureMap(), "whout", 1, featureHash); 293 l.add(c); 294 addRule(new Rule(l, true)); 295 296 // simple_sentence_2(whin:A, whout:B)~>nounphrase(exist:minus, whin:A, whout:C), verbphrase_coord_1(pl:minus, whin:C, whout:B) 297 l.clear(); 298 featureHash.clear(); 299 c = new Nonterminal("simple_sentence_2"); 300 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 301 setFeature(c.getFeatureMap(), "whout", 1, featureHash); 302 l.add(c); 303 c = new Nonterminal("nounphrase"); 304 c.setFeature("exist", new StringRef("minus")); 305 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 306 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 307 l.add(c); 308 c = new Nonterminal("verbphrase_coord_1"); 309 c.setFeature("pl", new StringRef("minus")); 310 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 311 setFeature(c.getFeatureMap(), "whout", 1, featureHash); 312 l.add(c); 313 addRule(new Rule(l, false)); 314 315 // verbphrase_coord_1(pl:A, whin:B, whout:C)=>verbphrase_coord_2(pl:A, whin:B, whout:C) 316 l.clear(); 317 featureHash.clear(); 318 c = new Nonterminal("verbphrase_coord_1"); 319 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 320 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 321 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 322 l.add(c); 323 c = new Nonterminal("verbphrase_coord_2"); 324 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 325 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 326 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 327 l.add(c); 328 addRule(new Rule(l, true)); 329 330 // verbphrase_coord_1(pl:A, whin:B, whout:C)~>verbphrase_coord_2(pl:A, whin:B, whout:D), [or], verbphrase_coord_1(pl:A, whin:D, whout:C) 331 l.clear(); 332 featureHash.clear(); 333 c = new Nonterminal("verbphrase_coord_1"); 334 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 335 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 336 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 337 l.add(c); 338 c = new Nonterminal("verbphrase_coord_2"); 339 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 340 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 341 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 342 l.add(c); 343 c = new Terminal("or"); 344 l.add(c); 345 c = new Nonterminal("verbphrase_coord_1"); 346 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 347 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 348 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 349 l.add(c); 350 addRule(new Rule(l, false)); 351 352 // verbphrase_coord_2(pl:A, whin:B, whout:C)=>vp_cut(pl:A, whin:B, whout:C) 353 l.clear(); 354 featureHash.clear(); 355 c = new Nonterminal("verbphrase_coord_2"); 356 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 357 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 358 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 359 l.add(c); 360 c = new Nonterminal("vp_cut"); 361 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 362 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 363 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 364 l.add(c); 365 addRule(new Rule(l, true)); 366 367 // verbphrase_coord_2(pl:A, whin:B, whout:C)=>vp_cut(pl:A, whin:B, whout:D), [and], verbphrase_coord_2(pl:A, whin:D, whout:C) 368 l.clear(); 369 featureHash.clear(); 370 c = new Nonterminal("verbphrase_coord_2"); 371 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 372 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 373 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 374 l.add(c); 375 c = new Nonterminal("vp_cut"); 376 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 377 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 378 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 379 l.add(c); 380 c = new Terminal("and"); 381 l.add(c); 382 c = new Nonterminal("verbphrase_coord_2"); 383 setFeature(c.getFeatureMap(), "pl", 0, featureHash); 384 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 385 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 386 l.add(c); 387 addRule(new Rule(l, true)); 388 389 // vp_cut(rel:A, pl:B, whin:C, whout:D)=>vp(exists:plus, rel:A, pl:B, whin:C, whout:D) 390 l.clear(); 391 featureHash.clear(); 392 c = new Nonterminal("vp_cut"); 393 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 394 setFeature(c.getFeatureMap(), "pl", 1, featureHash); 395 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 396 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 397 l.add(c); 398 c = new Nonterminal("vp"); 399 c.setFeature("exists", new StringRef("plus")); 400 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 401 setFeature(c.getFeatureMap(), "pl", 1, featureHash); 402 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 403 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 404 l.add(c); 405 addRule(new Rule(l, true)); 406 407 // vp_cut(rel:A, pl:B, whin:C, whout:D)~>vp(exists:minus, rel:A, pl:B, whin:C, whout:D) 408 l.clear(); 409 featureHash.clear(); 410 c = new Nonterminal("vp_cut"); 411 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 412 setFeature(c.getFeatureMap(), "pl", 1, featureHash); 413 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 414 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 415 l.add(c); 416 c = new Nonterminal("vp"); 417 c.setFeature("exists", new StringRef("minus")); 418 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 419 setFeature(c.getFeatureMap(), "pl", 1, featureHash); 420 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 421 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 422 l.add(c); 423 addRule(new Rule(l, false)); 424 425 // vp(exists:A, rel:B, pl:C, whin:D, whout:E)=>auxiliary(be:F, exists:A, pl:C), vbar(be:F, exists:A, pl:C, rel:B, vform:inf, embv:G, copula:H, whin:D, whout:I), v_modifiers(embv:G, copula:H, whin:I, whout:E) 426 l.clear(); 427 featureHash.clear(); 428 c = new Nonterminal("vp"); 429 setFeature(c.getFeatureMap(), "exists", 0, featureHash); 430 setFeature(c.getFeatureMap(), "rel", 1, featureHash); 431 setFeature(c.getFeatureMap(), "pl", 2, featureHash); 432 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 433 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 434 l.add(c); 435 c = new Nonterminal("auxiliary"); 436 setFeature(c.getFeatureMap(), "be", 5, featureHash); 437 setFeature(c.getFeatureMap(), "exists", 0, featureHash); 438 setFeature(c.getFeatureMap(), "pl", 2, featureHash); 439 l.add(c); 440 c = new Nonterminal("vbar"); 441 setFeature(c.getFeatureMap(), "be", 5, featureHash); 442 setFeature(c.getFeatureMap(), "exists", 0, featureHash); 443 setFeature(c.getFeatureMap(), "pl", 2, featureHash); 444 setFeature(c.getFeatureMap(), "rel", 1, featureHash); 445 c.setFeature("vform", new StringRef("inf")); 446 setFeature(c.getFeatureMap(), "embv", 6, featureHash); 447 setFeature(c.getFeatureMap(), "copula", 7, featureHash); 448 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 449 setFeature(c.getFeatureMap(), "whout", 8, featureHash); 450 l.add(c); 451 c = new Nonterminal("v_modifiers"); 452 setFeature(c.getFeatureMap(), "embv", 6, featureHash); 453 setFeature(c.getFeatureMap(), "copula", 7, featureHash); 454 setFeature(c.getFeatureMap(), "whin", 8, featureHash); 455 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 456 l.add(c); 457 addRule(new Rule(l, true)); 458 459 // vp(exists:plus, rel:A, pl:B, whin:C, whout:D)=>vbar(be:minus, exists:plus, pl:B, rel:A, vform:fin, embv:E, copula:F, whin:C, whout:G), v_modifiers(embv:E, copula:F, whin:G, whout:D) 460 l.clear(); 461 featureHash.clear(); 462 c = new Nonterminal("vp"); 463 c.setFeature("exists", new StringRef("plus")); 464 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 465 setFeature(c.getFeatureMap(), "pl", 1, featureHash); 466 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 467 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 468 l.add(c); 469 c = new Nonterminal("vbar"); 470 c.setFeature("be", new StringRef("minus")); 471 c.setFeature("exists", new StringRef("plus")); 472 setFeature(c.getFeatureMap(), "pl", 1, featureHash); 473 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 474 c.setFeature("vform", new StringRef("fin")); 475 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 476 setFeature(c.getFeatureMap(), "copula", 5, featureHash); 477 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 478 setFeature(c.getFeatureMap(), "whout", 6, featureHash); 479 l.add(c); 480 c = new Nonterminal("v_modifiers"); 481 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 482 setFeature(c.getFeatureMap(), "copula", 5, featureHash); 483 setFeature(c.getFeatureMap(), "whin", 6, featureHash); 484 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 485 l.add(c); 486 addRule(new Rule(l, true)); 487 488 // vbar(be:minus, exists:A, pl:B, vform:C, copula:minus, whin:D, whout:D)=>verb(vsubcat:itr, be:minus, pl:B, exists:A, vform:C) 489 l.clear(); 490 featureHash.clear(); 491 c = new Nonterminal("vbar"); 492 c.setFeature("be", new StringRef("minus")); 493 setFeature(c.getFeatureMap(), "exists", 0, featureHash); 494 setFeature(c.getFeatureMap(), "pl", 1, featureHash); 495 setFeature(c.getFeatureMap(), "vform", 2, featureHash); 496 c.setFeature("copula", new StringRef("minus")); 497 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 498 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 499 l.add(c); 500 c = new Nonterminal("verb"); 501 c.setFeature("vsubcat", new StringRef("itr")); 502 c.setFeature("be", new StringRef("minus")); 503 setFeature(c.getFeatureMap(), "pl", 1, featureHash); 504 setFeature(c.getFeatureMap(), "exists", 0, featureHash); 505 setFeature(c.getFeatureMap(), "vform", 2, featureHash); 506 l.add(c); 507 addRule(new Rule(l, true)); 508 509 // vbar(be:minus, exists:A, rel:B, pl:C, vform:D, embv:E, copula:minus, whin:F, whout:G)=>verb(vsubcat:tr, be:minus, pl:C, exists:A, vform:D), nounphrase_cut(rel:B, vsubcat:tr, embv:E, whin:F, whout:G) 510 l.clear(); 511 featureHash.clear(); 512 c = new Nonterminal("vbar"); 513 c.setFeature("be", new StringRef("minus")); 514 setFeature(c.getFeatureMap(), "exists", 0, featureHash); 515 setFeature(c.getFeatureMap(), "rel", 1, featureHash); 516 setFeature(c.getFeatureMap(), "pl", 2, featureHash); 517 setFeature(c.getFeatureMap(), "vform", 3, featureHash); 518 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 519 c.setFeature("copula", new StringRef("minus")); 520 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 521 setFeature(c.getFeatureMap(), "whout", 6, featureHash); 522 l.add(c); 523 c = new Nonterminal("verb"); 524 c.setFeature("vsubcat", new StringRef("tr")); 525 c.setFeature("be", new StringRef("minus")); 526 setFeature(c.getFeatureMap(), "pl", 2, featureHash); 527 setFeature(c.getFeatureMap(), "exists", 0, featureHash); 528 setFeature(c.getFeatureMap(), "vform", 3, featureHash); 529 l.add(c); 530 c = new Nonterminal("nounphrase_cut"); 531 setFeature(c.getFeatureMap(), "rel", 1, featureHash); 532 c.setFeature("vsubcat", new StringRef("tr")); 533 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 534 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 535 setFeature(c.getFeatureMap(), "whout", 6, featureHash); 536 l.add(c); 537 addRule(new Rule(l, true)); 538 539 // vbar(be:plus, rel:A, embv:B, copula:minus, whin:C, whout:D)=>verb(vsubcat:tr, be:plus, pl:E, exists:F, vform:G), [by], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D) 540 l.clear(); 541 featureHash.clear(); 542 c = new Nonterminal("vbar"); 543 c.setFeature("be", new StringRef("plus")); 544 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 545 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 546 c.setFeature("copula", new StringRef("minus")); 547 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 548 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 549 l.add(c); 550 c = new Nonterminal("verb"); 551 c.setFeature("vsubcat", new StringRef("tr")); 552 c.setFeature("be", new StringRef("plus")); 553 setFeature(c.getFeatureMap(), "pl", 4, featureHash); 554 setFeature(c.getFeatureMap(), "exists", 5, featureHash); 555 setFeature(c.getFeatureMap(), "vform", 6, featureHash); 556 l.add(c); 557 c = new Terminal("by"); 558 l.add(c); 559 c = new Nonterminal("nounphrase_cut"); 560 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 561 c.setFeature("copula", new StringRef("minus")); 562 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 563 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 564 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 565 l.add(c); 566 addRule(new Rule(l, true)); 567 568 // vbar(be:plus, rel:A, embv:B, copula:plus, whin:C, whout:D)=>nounphrase_cut(of:plus, rel:A, pl:minus, copula:plus, embv:B, whin:C, whout:D) 569 l.clear(); 570 featureHash.clear(); 571 c = new Nonterminal("vbar"); 572 c.setFeature("be", new StringRef("plus")); 573 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 574 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 575 c.setFeature("copula", new StringRef("plus")); 576 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 577 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 578 l.add(c); 579 c = new Nonterminal("nounphrase_cut"); 580 c.setFeature("of", new StringRef("plus")); 581 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 582 c.setFeature("pl", new StringRef("minus")); 583 c.setFeature("copula", new StringRef("plus")); 584 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 585 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 586 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 587 l.add(c); 588 addRule(new Rule(l, true)); 589 590 // vbar(be:plus, rel:A, pl:minus, embv:B, copula:plus, whin:C, whout:D)=>nounphrase_cut(of:minus, rel:A, pl:minus, copula:plus, embv:B, whin:C, whout:D) 591 l.clear(); 592 featureHash.clear(); 593 c = new Nonterminal("vbar"); 594 c.setFeature("be", new StringRef("plus")); 595 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 596 c.setFeature("pl", new StringRef("minus")); 597 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 598 c.setFeature("copula", new StringRef("plus")); 599 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 600 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 601 l.add(c); 602 c = new Nonterminal("nounphrase_cut"); 603 c.setFeature("of", new StringRef("minus")); 604 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 605 c.setFeature("pl", new StringRef("minus")); 606 c.setFeature("copula", new StringRef("plus")); 607 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 608 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 609 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 610 l.add(c); 611 addRule(new Rule(l, true)); 612 613 // vbar(be:plus, rel:A, copula:plus, whin:B, whout:B)=>adj_coord 614 l.clear(); 615 featureHash.clear(); 616 c = new Nonterminal("vbar"); 617 c.setFeature("be", new StringRef("plus")); 618 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 619 c.setFeature("copula", new StringRef("plus")); 620 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 621 setFeature(c.getFeatureMap(), "whout", 1, featureHash); 622 l.add(c); 623 c = new Nonterminal("adj_coord"); 624 l.add(c); 625 addRule(new Rule(l, true)); 626 627 // vbar(be:plus, rel:A, embv:B, copula:plus, whin:C, whout:D)=>compl_adj(rel:A, embv:B, whin:C, whout:D) 628 l.clear(); 629 featureHash.clear(); 630 c = new Nonterminal("vbar"); 631 c.setFeature("be", new StringRef("plus")); 632 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 633 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 634 c.setFeature("copula", new StringRef("plus")); 635 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 636 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 637 l.add(c); 638 c = new Nonterminal("compl_adj"); 639 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 640 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 641 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 642 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 643 l.add(c); 644 addRule(new Rule(l, true)); 645 646 // nounphrase_cut(exist:plus, rel:A, of:B, def:C, pl:D, copula:E, embv:F, whin:G, whout:H)=>nounphrase(exist:plus, rel:A, of:B, def:C, pl:D, copula:E, embv:F, whin:G, whout:H) 647 l.clear(); 648 featureHash.clear(); 649 c = new Nonterminal("nounphrase_cut"); 650 c.setFeature("exist", new StringRef("plus")); 651 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 652 setFeature(c.getFeatureMap(), "of", 1, featureHash); 653 setFeature(c.getFeatureMap(), "def", 2, featureHash); 654 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 655 setFeature(c.getFeatureMap(), "copula", 4, featureHash); 656 setFeature(c.getFeatureMap(), "embv", 5, featureHash); 657 setFeature(c.getFeatureMap(), "whin", 6, featureHash); 658 setFeature(c.getFeatureMap(), "whout", 7, featureHash); 659 l.add(c); 660 c = new Nonterminal("nounphrase"); 661 c.setFeature("exist", new StringRef("plus")); 662 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 663 setFeature(c.getFeatureMap(), "of", 1, featureHash); 664 setFeature(c.getFeatureMap(), "def", 2, featureHash); 665 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 666 setFeature(c.getFeatureMap(), "copula", 4, featureHash); 667 setFeature(c.getFeatureMap(), "embv", 5, featureHash); 668 setFeature(c.getFeatureMap(), "whin", 6, featureHash); 669 setFeature(c.getFeatureMap(), "whout", 7, featureHash); 670 l.add(c); 671 addRule(new Rule(l, true)); 672 673 // nounphrase_cut(exist:minus, rel:A, of:B, def:C, pl:D, copula:E, embv:F, whin:G, whout:H)~>nounphrase(exist:minus, rel:A, of:B, def:C, pl:D, copula:E, embv:F, whin:G, whout:H) 674 l.clear(); 675 featureHash.clear(); 676 c = new Nonterminal("nounphrase_cut"); 677 c.setFeature("exist", new StringRef("minus")); 678 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 679 setFeature(c.getFeatureMap(), "of", 1, featureHash); 680 setFeature(c.getFeatureMap(), "def", 2, featureHash); 681 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 682 setFeature(c.getFeatureMap(), "copula", 4, featureHash); 683 setFeature(c.getFeatureMap(), "embv", 5, featureHash); 684 setFeature(c.getFeatureMap(), "whin", 6, featureHash); 685 setFeature(c.getFeatureMap(), "whout", 7, featureHash); 686 l.add(c); 687 c = new Nonterminal("nounphrase"); 688 c.setFeature("exist", new StringRef("minus")); 689 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 690 setFeature(c.getFeatureMap(), "of", 1, featureHash); 691 setFeature(c.getFeatureMap(), "def", 2, featureHash); 692 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 693 setFeature(c.getFeatureMap(), "copula", 4, featureHash); 694 setFeature(c.getFeatureMap(), "embv", 5, featureHash); 695 setFeature(c.getFeatureMap(), "whin", 6, featureHash); 696 setFeature(c.getFeatureMap(), "whout", 7, featureHash); 697 l.add(c); 698 addRule(new Rule(l, false)); 699 700 // nounphrase(exist:plus, rel:A, of:minus, def:plus, pl:minus, embv:B, whin:C, whout:D)=>propername(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D) 701 l.clear(); 702 featureHash.clear(); 703 c = new Nonterminal("nounphrase"); 704 c.setFeature("exist", new StringRef("plus")); 705 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 706 c.setFeature("of", new StringRef("minus")); 707 c.setFeature("def", new StringRef("plus")); 708 c.setFeature("pl", new StringRef("minus")); 709 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 710 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 711 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 712 l.add(c); 713 c = new Nonterminal("propername"); 714 setFeature(c.getFeatureMap(), "human", 4, featureHash); 715 l.add(c); 716 c = new Nonterminal("rel_phrase"); 717 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 718 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 719 setFeature(c.getFeatureMap(), "human", 4, featureHash); 720 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 721 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 722 l.add(c); 723 addRule(new Rule(l, true)); 724 725 // nounphrase(exist:plus, of:minus, def:plus, pl:minus, whin:A, whout:A)=>var_ante 726 l.clear(); 727 featureHash.clear(); 728 c = new Nonterminal("nounphrase"); 729 c.setFeature("exist", new StringRef("plus")); 730 c.setFeature("of", new StringRef("minus")); 731 c.setFeature("def", new StringRef("plus")); 732 c.setFeature("pl", new StringRef("minus")); 733 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 734 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 735 l.add(c); 736 c = new Nonterminal("var_ante"); 737 l.add(c); 738 addRule(new Rule(l, true)); 739 740 // nounphrase(exist:plus, of:minus, def:plus, pl:minus, whin:A, whout:A)~>['DEF_NOUN_SG'(noun:B), 'REF'(text:C)], <<<(type:noun, hasvar:plus, noun:B, var:C) 741 l.clear(); 742 featureHash.clear(); 743 c = new Nonterminal("nounphrase"); 744 c.setFeature("exist", new StringRef("plus")); 745 c.setFeature("of", new StringRef("minus")); 746 c.setFeature("def", new StringRef("plus")); 747 c.setFeature("pl", new StringRef("minus")); 748 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 749 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 750 l.add(c); 751 c = new Terminal("DEF_NOUN_SG"); 752 setFeature(c.getFeatureMap(), "noun", 1, featureHash); 753 l.add(c); 754 c = new Terminal("REF"); 755 setFeature(c.getFeatureMap(), "text", 2, featureHash); 756 l.add(c); 757 c = new Nonterminal("<<<"); 758 c.setFeature("type", new StringRef("noun")); 759 c.setFeature("hasvar", new StringRef("plus")); 760 setFeature(c.getFeatureMap(), "noun", 1, featureHash); 761 setFeature(c.getFeatureMap(), "var", 2, featureHash); 762 l.add(c); 763 addRule(new Rule(l, false)); 764 765 // nounphrase(exist:plus, of:minus, def:plus, pl:minus, whin:A, whout:A)~>['DEF_NOUN_SG'(noun:B)], <<<(type:noun, noun:B) 766 l.clear(); 767 featureHash.clear(); 768 c = new Nonterminal("nounphrase"); 769 c.setFeature("exist", new StringRef("plus")); 770 c.setFeature("of", new StringRef("minus")); 771 c.setFeature("def", new StringRef("plus")); 772 c.setFeature("pl", new StringRef("minus")); 773 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 774 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 775 l.add(c); 776 c = new Terminal("DEF_NOUN_SG"); 777 setFeature(c.getFeatureMap(), "noun", 1, featureHash); 778 l.add(c); 779 c = new Nonterminal("<<<"); 780 c.setFeature("type", new StringRef("noun")); 781 setFeature(c.getFeatureMap(), "noun", 1, featureHash); 782 l.add(c); 783 addRule(new Rule(l, false)); 784 785 // nounphrase(exist:plus, of:minus, def:plus, pl:minus, whin:A, whout:A)~>['REF'(text:B)], <<<(hasvar:plus, var:B) 786 l.clear(); 787 featureHash.clear(); 788 c = new Nonterminal("nounphrase"); 789 c.setFeature("exist", new StringRef("plus")); 790 c.setFeature("of", new StringRef("minus")); 791 c.setFeature("def", new StringRef("plus")); 792 c.setFeature("pl", new StringRef("minus")); 793 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 794 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 795 l.add(c); 796 c = new Terminal("REF"); 797 setFeature(c.getFeatureMap(), "text", 1, featureHash); 798 l.add(c); 799 c = new Nonterminal("<<<"); 800 c.setFeature("hasvar", new StringRef("plus")); 801 setFeature(c.getFeatureMap(), "var", 1, featureHash); 802 l.add(c); 803 addRule(new Rule(l, false)); 804 805 // nounphrase(exist:plus, rel:A, of:B, pl:minus, embv:C, whin:D, whout:E)=>[a], noun_constr(rel:A, of:B, embv:C, whin:D, whout:E) 806 l.clear(); 807 featureHash.clear(); 808 c = new Nonterminal("nounphrase"); 809 c.setFeature("exist", new StringRef("plus")); 810 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 811 setFeature(c.getFeatureMap(), "of", 1, featureHash); 812 c.setFeature("pl", new StringRef("minus")); 813 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 814 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 815 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 816 l.add(c); 817 c = new Terminal("a"); 818 l.add(c); 819 c = new Nonterminal("noun_constr"); 820 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 821 setFeature(c.getFeatureMap(), "of", 1, featureHash); 822 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 823 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 824 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 825 l.add(c); 826 addRule(new Rule(l, true)); 827 828 // nounphrase(exist:plus, rel:A, of:B, pl:minus, embv:C, whin:D, whout:E)=>[an], noun_constr(rel:A, of:B, embv:C, whin:D, whout:E) 829 l.clear(); 830 featureHash.clear(); 831 c = new Nonterminal("nounphrase"); 832 c.setFeature("exist", new StringRef("plus")); 833 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 834 setFeature(c.getFeatureMap(), "of", 1, featureHash); 835 c.setFeature("pl", new StringRef("minus")); 836 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 837 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 838 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 839 l.add(c); 840 c = new Terminal("an"); 841 l.add(c); 842 c = new Nonterminal("noun_constr"); 843 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 844 setFeature(c.getFeatureMap(), "of", 1, featureHash); 845 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 846 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 847 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 848 l.add(c); 849 addRule(new Rule(l, true)); 850 851 // nounphrase(exist:plus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>exist_anon(human:E), var_ante, rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D) 852 l.clear(); 853 featureHash.clear(); 854 c = new Nonterminal("nounphrase"); 855 c.setFeature("exist", new StringRef("plus")); 856 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 857 c.setFeature("of", new StringRef("minus")); 858 c.setFeature("pl", new StringRef("minus")); 859 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 860 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 861 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 862 l.add(c); 863 c = new Nonterminal("exist_anon"); 864 setFeature(c.getFeatureMap(), "human", 4, featureHash); 865 l.add(c); 866 c = new Nonterminal("var_ante"); 867 l.add(c); 868 c = new Nonterminal("rel_phrase"); 869 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 870 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 871 setFeature(c.getFeatureMap(), "human", 4, featureHash); 872 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 873 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 874 l.add(c); 875 addRule(new Rule(l, true)); 876 877 // nounphrase(exist:plus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>exist_anon(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D) 878 l.clear(); 879 featureHash.clear(); 880 c = new Nonterminal("nounphrase"); 881 c.setFeature("exist", new StringRef("plus")); 882 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 883 c.setFeature("of", new StringRef("minus")); 884 c.setFeature("pl", new StringRef("minus")); 885 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 886 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 887 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 888 l.add(c); 889 c = new Nonterminal("exist_anon"); 890 setFeature(c.getFeatureMap(), "human", 4, featureHash); 891 l.add(c); 892 c = new Nonterminal("rel_phrase"); 893 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 894 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 895 setFeature(c.getFeatureMap(), "human", 4, featureHash); 896 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 897 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 898 l.add(c); 899 addRule(new Rule(l, true)); 900 901 // nounphrase(exist:plus, of:minus, pl:plus, copula:minus, whin:A, whout:A)=>num_quant, ['NUM'], opt_adj_coord, ['NOUN_PL'] 902 l.clear(); 903 featureHash.clear(); 904 c = new Nonterminal("nounphrase"); 905 c.setFeature("exist", new StringRef("plus")); 906 c.setFeature("of", new StringRef("minus")); 907 c.setFeature("pl", new StringRef("plus")); 908 c.setFeature("copula", new StringRef("minus")); 909 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 910 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 911 l.add(c); 912 c = new Nonterminal("num_quant"); 913 l.add(c); 914 c = new Terminal("NUM"); 915 l.add(c); 916 c = new Nonterminal("opt_adj_coord"); 917 l.add(c); 918 c = new Terminal("NOUN_PL"); 919 l.add(c); 920 addRule(new Rule(l, true)); 921 922 // nounphrase(exist:plus, of:minus, pl:minus, copula:minus, whin:A, whout:A)=>num_quant, [1], opt_adj_coord, ['NOUN_SG'] 923 l.clear(); 924 featureHash.clear(); 925 c = new Nonterminal("nounphrase"); 926 c.setFeature("exist", new StringRef("plus")); 927 c.setFeature("of", new StringRef("minus")); 928 c.setFeature("pl", new StringRef("minus")); 929 c.setFeature("copula", new StringRef("minus")); 930 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 931 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 932 l.add(c); 933 c = new Nonterminal("num_quant"); 934 l.add(c); 935 c = new Terminal("1"); 936 l.add(c); 937 c = new Nonterminal("opt_adj_coord"); 938 l.add(c); 939 c = new Terminal("NOUN_SG"); 940 l.add(c); 941 addRule(new Rule(l, true)); 942 943 // nounphrase(exist:plus, of:minus, pl:minus, whout:plus)=>[what] 944 l.clear(); 945 featureHash.clear(); 946 c = new Nonterminal("nounphrase"); 947 c.setFeature("exist", new StringRef("plus")); 948 c.setFeature("of", new StringRef("minus")); 949 c.setFeature("pl", new StringRef("minus")); 950 c.setFeature("whout", new StringRef("plus")); 951 l.add(c); 952 c = new Terminal("what"); 953 l.add(c); 954 addRule(new Rule(l, true)); 955 956 // nounphrase(exist:plus, of:minus, pl:minus, whout:plus)=>[who] 957 l.clear(); 958 featureHash.clear(); 959 c = new Nonterminal("nounphrase"); 960 c.setFeature("exist", new StringRef("plus")); 961 c.setFeature("of", new StringRef("minus")); 962 c.setFeature("pl", new StringRef("minus")); 963 c.setFeature("whout", new StringRef("plus")); 964 l.add(c); 965 c = new Terminal("who"); 966 l.add(c); 967 addRule(new Rule(l, true)); 968 969 // nounphrase(exist:plus, rel:A, of:B, embv:C, pl:minus, whout:plus)=>[which], noun_constr(rel:A, of:B, embv:C, whin:plus, whout:plus) 970 l.clear(); 971 featureHash.clear(); 972 c = new Nonterminal("nounphrase"); 973 c.setFeature("exist", new StringRef("plus")); 974 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 975 setFeature(c.getFeatureMap(), "of", 1, featureHash); 976 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 977 c.setFeature("pl", new StringRef("minus")); 978 c.setFeature("whout", new StringRef("plus")); 979 l.add(c); 980 c = new Terminal("which"); 981 l.add(c); 982 c = new Nonterminal("noun_constr"); 983 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 984 setFeature(c.getFeatureMap(), "of", 1, featureHash); 985 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 986 c.setFeature("whin", new StringRef("plus")); 987 c.setFeature("whout", new StringRef("plus")); 988 l.add(c); 989 addRule(new Rule(l, true)); 990 991 // nounphrase(exist:plus, of:minus, pl:plus, whout:plus)=>[which], opt_adj_coord, ['NOUN_PL'] 992 l.clear(); 993 featureHash.clear(); 994 c = new Nonterminal("nounphrase"); 995 c.setFeature("exist", new StringRef("plus")); 996 c.setFeature("of", new StringRef("minus")); 997 c.setFeature("pl", new StringRef("plus")); 998 c.setFeature("whout", new StringRef("plus")); 999 l.add(c); 1000 c = new Terminal("which"); 1001 l.add(c); 1002 c = new Nonterminal("opt_adj_coord"); 1003 l.add(c); 1004 c = new Terminal("NOUN_PL"); 1005 l.add(c); 1006 addRule(new Rule(l, true)); 1007 1008 // nounphrase(exist:minus, rel:A, of:B, pl:minus, embv:C, whin:D, whout:E)=>[every], noun_constr(rel:A, of:B, embv:C, whin:D, whout:E) 1009 l.clear(); 1010 featureHash.clear(); 1011 c = new Nonterminal("nounphrase"); 1012 c.setFeature("exist", new StringRef("minus")); 1013 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1014 setFeature(c.getFeatureMap(), "of", 1, featureHash); 1015 c.setFeature("pl", new StringRef("minus")); 1016 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 1017 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 1018 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 1019 l.add(c); 1020 c = new Terminal("every"); 1021 l.add(c); 1022 c = new Nonterminal("noun_constr"); 1023 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1024 setFeature(c.getFeatureMap(), "of", 1, featureHash); 1025 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 1026 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 1027 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 1028 l.add(c); 1029 addRule(new Rule(l, true)); 1030 1031 // nounphrase(exist:minus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>univ_anon(human:E), var_ante, rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D) 1032 l.clear(); 1033 featureHash.clear(); 1034 c = new Nonterminal("nounphrase"); 1035 c.setFeature("exist", new StringRef("minus")); 1036 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1037 c.setFeature("of", new StringRef("minus")); 1038 c.setFeature("pl", new StringRef("minus")); 1039 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1040 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1041 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1042 l.add(c); 1043 c = new Nonterminal("univ_anon"); 1044 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1045 l.add(c); 1046 c = new Nonterminal("var_ante"); 1047 l.add(c); 1048 c = new Nonterminal("rel_phrase"); 1049 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1050 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1051 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1052 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1053 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1054 l.add(c); 1055 addRule(new Rule(l, true)); 1056 1057 // nounphrase(exist:minus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>univ_anon(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D) 1058 l.clear(); 1059 featureHash.clear(); 1060 c = new Nonterminal("nounphrase"); 1061 c.setFeature("exist", new StringRef("minus")); 1062 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1063 c.setFeature("of", new StringRef("minus")); 1064 c.setFeature("pl", new StringRef("minus")); 1065 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1066 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1067 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1068 l.add(c); 1069 c = new Nonterminal("univ_anon"); 1070 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1071 l.add(c); 1072 c = new Nonterminal("rel_phrase"); 1073 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1074 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1075 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1076 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1077 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1078 l.add(c); 1079 addRule(new Rule(l, true)); 1080 1081 // nounphrase(exist:minus, rel:A, of:B, pl:minus, embv:C, whin:D, whout:E)=>[no], noun_constr(rel:A, of:B, embv:C, whin:D, whout:E) 1082 l.clear(); 1083 featureHash.clear(); 1084 c = new Nonterminal("nounphrase"); 1085 c.setFeature("exist", new StringRef("minus")); 1086 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1087 setFeature(c.getFeatureMap(), "of", 1, featureHash); 1088 c.setFeature("pl", new StringRef("minus")); 1089 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 1090 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 1091 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 1092 l.add(c); 1093 c = new Terminal("no"); 1094 l.add(c); 1095 c = new Nonterminal("noun_constr"); 1096 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1097 setFeature(c.getFeatureMap(), "of", 1, featureHash); 1098 setFeature(c.getFeatureMap(), "embv", 2, featureHash); 1099 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 1100 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 1101 l.add(c); 1102 addRule(new Rule(l, true)); 1103 1104 // nounphrase(exist:minus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>neg_anon(human:E), var_ante, rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D) 1105 l.clear(); 1106 featureHash.clear(); 1107 c = new Nonterminal("nounphrase"); 1108 c.setFeature("exist", new StringRef("minus")); 1109 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1110 c.setFeature("of", new StringRef("minus")); 1111 c.setFeature("pl", new StringRef("minus")); 1112 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1113 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1114 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1115 l.add(c); 1116 c = new Nonterminal("neg_anon"); 1117 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1118 l.add(c); 1119 c = new Nonterminal("var_ante"); 1120 l.add(c); 1121 c = new Nonterminal("rel_phrase"); 1122 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1123 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1124 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1125 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1126 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1127 l.add(c); 1128 addRule(new Rule(l, true)); 1129 1130 // nounphrase(exist:minus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>neg_anon(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D) 1131 l.clear(); 1132 featureHash.clear(); 1133 c = new Nonterminal("nounphrase"); 1134 c.setFeature("exist", new StringRef("minus")); 1135 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1136 c.setFeature("of", new StringRef("minus")); 1137 c.setFeature("pl", new StringRef("minus")); 1138 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1139 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1140 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1141 l.add(c); 1142 c = new Nonterminal("neg_anon"); 1143 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1144 l.add(c); 1145 c = new Nonterminal("rel_phrase"); 1146 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1147 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1148 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1149 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1150 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1151 l.add(c); 1152 addRule(new Rule(l, true)); 1153 1154 // noun_constr(rel:A, of:minus, embv:B, whin:C, whout:D)=>opt_adj_coord, noun_ante(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D) 1155 l.clear(); 1156 featureHash.clear(); 1157 c = new Nonterminal("noun_constr"); 1158 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1159 c.setFeature("of", new StringRef("minus")); 1160 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1161 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1162 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1163 l.add(c); 1164 c = new Nonterminal("opt_adj_coord"); 1165 l.add(c); 1166 c = new Nonterminal("noun_ante"); 1167 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1168 l.add(c); 1169 c = new Nonterminal("rel_phrase"); 1170 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1171 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1172 setFeature(c.getFeatureMap(), "human", 4, featureHash); 1173 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1174 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1175 l.add(c); 1176 addRule(new Rule(l, true)); 1177 1178 // noun_constr(rel:A, of:plus, embv:B, whin:C, whout:D)=>opt_adj_coord, ['NOUN_SG', of], nounphrase_cut(rel:A, embv:B, whin:C, whout:D) 1179 l.clear(); 1180 featureHash.clear(); 1181 c = new Nonterminal("noun_constr"); 1182 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1183 c.setFeature("of", new StringRef("plus")); 1184 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1185 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1186 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1187 l.add(c); 1188 c = new Nonterminal("opt_adj_coord"); 1189 l.add(c); 1190 c = new Terminal("NOUN_SG"); 1191 l.add(c); 1192 c = new Terminal("of"); 1193 l.add(c); 1194 c = new Nonterminal("nounphrase_cut"); 1195 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1196 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 1197 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1198 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1199 l.add(c); 1200 addRule(new Rule(l, true)); 1201 1202 // noun_ante(human:A)=>['NOUN_SG'(human:A, text:B, id:C)], newvar(var:D), >>>(type:noun, hasvar:plus, noun:B, var:D, id:C) 1203 l.clear(); 1204 featureHash.clear(); 1205 c = new Nonterminal("noun_ante"); 1206 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1207 l.add(c); 1208 c = new Terminal("NOUN_SG"); 1209 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1210 setFeature(c.getFeatureMap(), "text", 1, featureHash); 1211 setFeature(c.getFeatureMap(), "id", 2, featureHash); 1212 l.add(c); 1213 c = new Nonterminal("newvar"); 1214 setFeature(c.getFeatureMap(), "var", 3, featureHash); 1215 l.add(c); 1216 c = new Nonterminal(">>>"); 1217 c.setFeature("type", new StringRef("noun")); 1218 c.setFeature("hasvar", new StringRef("plus")); 1219 setFeature(c.getFeatureMap(), "noun", 1, featureHash); 1220 setFeature(c.getFeatureMap(), "var", 3, featureHash); 1221 setFeature(c.getFeatureMap(), "id", 2, featureHash); 1222 l.add(c); 1223 addRule(new Rule(l, true)); 1224 1225 // noun_ante(human:A)=>['NOUN_SG'(human:A, text:B, id:C)], >>>(type:noun, hasvar:minus, noun:B, id:C) 1226 l.clear(); 1227 featureHash.clear(); 1228 c = new Nonterminal("noun_ante"); 1229 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1230 l.add(c); 1231 c = new Terminal("NOUN_SG"); 1232 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1233 setFeature(c.getFeatureMap(), "text", 1, featureHash); 1234 setFeature(c.getFeatureMap(), "id", 2, featureHash); 1235 l.add(c); 1236 c = new Nonterminal(">>>"); 1237 c.setFeature("type", new StringRef("noun")); 1238 c.setFeature("hasvar", new StringRef("minus")); 1239 setFeature(c.getFeatureMap(), "noun", 1, featureHash); 1240 setFeature(c.getFeatureMap(), "id", 2, featureHash); 1241 l.add(c); 1242 addRule(new Rule(l, true)); 1243 1244 // var_ante=>newvar(var:A, id:B), >>>(type:var, hasvar:plus, var:A, id:B) 1245 l.clear(); 1246 featureHash.clear(); 1247 c = new Nonterminal("var_ante"); 1248 l.add(c); 1249 c = new Nonterminal("newvar"); 1250 setFeature(c.getFeatureMap(), "var", 0, featureHash); 1251 setFeature(c.getFeatureMap(), "id", 1, featureHash); 1252 l.add(c); 1253 c = new Nonterminal(">>>"); 1254 c.setFeature("type", new StringRef("var")); 1255 c.setFeature("hasvar", new StringRef("plus")); 1256 setFeature(c.getFeatureMap(), "var", 0, featureHash); 1257 setFeature(c.getFeatureMap(), "id", 1, featureHash); 1258 l.add(c); 1259 addRule(new Rule(l, true)); 1260 1261 // newvar(var:A)=>['VAR'(text:A)], </<(hasvar:plus, var:A) 1262 l.clear(); 1263 featureHash.clear(); 1264 c = new Nonterminal("newvar"); 1265 setFeature(c.getFeatureMap(), "var", 0, featureHash); 1266 l.add(c); 1267 c = new Terminal("VAR"); 1268 setFeature(c.getFeatureMap(), "text", 0, featureHash); 1269 l.add(c); 1270 c = new Nonterminal("</<"); 1271 c.setFeature("hasvar", new StringRef("plus")); 1272 setFeature(c.getFeatureMap(), "var", 0, featureHash); 1273 l.add(c); 1274 addRule(new Rule(l, true)); 1275 1276 // auxiliary(be:minus, exists:minus, pl:minus)=>['has to'] 1277 l.clear(); 1278 featureHash.clear(); 1279 c = new Nonterminal("auxiliary"); 1280 c.setFeature("be", new StringRef("minus")); 1281 c.setFeature("exists", new StringRef("minus")); 1282 c.setFeature("pl", new StringRef("minus")); 1283 l.add(c); 1284 c = new Terminal("has to"); 1285 l.add(c); 1286 addRule(new Rule(l, true)); 1287 1288 // auxiliary(be:minus, exists:minus, pl:plus)=>['have to'] 1289 l.clear(); 1290 featureHash.clear(); 1291 c = new Nonterminal("auxiliary"); 1292 c.setFeature("be", new StringRef("minus")); 1293 c.setFeature("exists", new StringRef("minus")); 1294 c.setFeature("pl", new StringRef("plus")); 1295 l.add(c); 1296 c = new Terminal("have to"); 1297 l.add(c); 1298 addRule(new Rule(l, true)); 1299 1300 // auxiliary(be:plus, exists:plus, pl:minus)=>[is] 1301 l.clear(); 1302 featureHash.clear(); 1303 c = new Nonterminal("auxiliary"); 1304 c.setFeature("be", new StringRef("plus")); 1305 c.setFeature("exists", new StringRef("plus")); 1306 c.setFeature("pl", new StringRef("minus")); 1307 l.add(c); 1308 c = new Terminal("is"); 1309 l.add(c); 1310 addRule(new Rule(l, true)); 1311 1312 // auxiliary(be:plus, exists:minus, pl:minus)=>['is not'] 1313 l.clear(); 1314 featureHash.clear(); 1315 c = new Nonterminal("auxiliary"); 1316 c.setFeature("be", new StringRef("plus")); 1317 c.setFeature("exists", new StringRef("minus")); 1318 c.setFeature("pl", new StringRef("minus")); 1319 l.add(c); 1320 c = new Terminal("is not"); 1321 l.add(c); 1322 addRule(new Rule(l, true)); 1323 1324 // auxiliary(be:plus, exists:minus, pl:minus)=>[is, not] 1325 l.clear(); 1326 featureHash.clear(); 1327 c = new Nonterminal("auxiliary"); 1328 c.setFeature("be", new StringRef("plus")); 1329 c.setFeature("exists", new StringRef("minus")); 1330 c.setFeature("pl", new StringRef("minus")); 1331 l.add(c); 1332 c = new Terminal("is"); 1333 l.add(c); 1334 c = new Terminal("not"); 1335 l.add(c); 1336 addRule(new Rule(l, true)); 1337 1338 // auxiliary(be:plus, exists:plus, pl:plus)=>[are] 1339 l.clear(); 1340 featureHash.clear(); 1341 c = new Nonterminal("auxiliary"); 1342 c.setFeature("be", new StringRef("plus")); 1343 c.setFeature("exists", new StringRef("plus")); 1344 c.setFeature("pl", new StringRef("plus")); 1345 l.add(c); 1346 c = new Terminal("are"); 1347 l.add(c); 1348 addRule(new Rule(l, true)); 1349 1350 // auxiliary(be:plus, exists:minus, pl:plus)=>['are not'] 1351 l.clear(); 1352 featureHash.clear(); 1353 c = new Nonterminal("auxiliary"); 1354 c.setFeature("be", new StringRef("plus")); 1355 c.setFeature("exists", new StringRef("minus")); 1356 c.setFeature("pl", new StringRef("plus")); 1357 l.add(c); 1358 c = new Terminal("are not"); 1359 l.add(c); 1360 addRule(new Rule(l, true)); 1361 1362 // auxiliary(be:plus, exists:minus, pl:plus)=>[are, not] 1363 l.clear(); 1364 featureHash.clear(); 1365 c = new Nonterminal("auxiliary"); 1366 c.setFeature("be", new StringRef("plus")); 1367 c.setFeature("exists", new StringRef("minus")); 1368 c.setFeature("pl", new StringRef("plus")); 1369 l.add(c); 1370 c = new Terminal("are"); 1371 l.add(c); 1372 c = new Terminal("not"); 1373 l.add(c); 1374 addRule(new Rule(l, true)); 1375 1376 // auxiliary(be:minus, exists:minus, pl:minus)=>['does not'] 1377 l.clear(); 1378 featureHash.clear(); 1379 c = new Nonterminal("auxiliary"); 1380 c.setFeature("be", new StringRef("minus")); 1381 c.setFeature("exists", new StringRef("minus")); 1382 c.setFeature("pl", new StringRef("minus")); 1383 l.add(c); 1384 c = new Terminal("does not"); 1385 l.add(c); 1386 addRule(new Rule(l, true)); 1387 1388 // auxiliary(be:minus, exists:minus, pl:plus)=>['do not'] 1389 l.clear(); 1390 featureHash.clear(); 1391 c = new Nonterminal("auxiliary"); 1392 c.setFeature("be", new StringRef("minus")); 1393 c.setFeature("exists", new StringRef("minus")); 1394 c.setFeature("pl", new StringRef("plus")); 1395 l.add(c); 1396 c = new Terminal("do not"); 1397 l.add(c); 1398 addRule(new Rule(l, true)); 1399 1400 // auxiliary(be:minus, exists:minus)=>[can] 1401 l.clear(); 1402 featureHash.clear(); 1403 c = new Nonterminal("auxiliary"); 1404 c.setFeature("be", new StringRef("minus")); 1405 c.setFeature("exists", new StringRef("minus")); 1406 l.add(c); 1407 c = new Terminal("can"); 1408 l.add(c); 1409 addRule(new Rule(l, true)); 1410 1411 // auxiliary(be:minus, exists:minus)=>[should] 1412 l.clear(); 1413 featureHash.clear(); 1414 c = new Nonterminal("auxiliary"); 1415 c.setFeature("be", new StringRef("minus")); 1416 c.setFeature("exists", new StringRef("minus")); 1417 l.add(c); 1418 c = new Terminal("should"); 1419 l.add(c); 1420 addRule(new Rule(l, true)); 1421 1422 // auxiliary(be:minus, exists:minus)=>[must] 1423 l.clear(); 1424 featureHash.clear(); 1425 c = new Nonterminal("auxiliary"); 1426 c.setFeature("be", new StringRef("minus")); 1427 c.setFeature("exists", new StringRef("minus")); 1428 l.add(c); 1429 c = new Terminal("must"); 1430 l.add(c); 1431 addRule(new Rule(l, true)); 1432 1433 // auxiliary(be:plus, exists:minus)=>[can, be] 1434 l.clear(); 1435 featureHash.clear(); 1436 c = new Nonterminal("auxiliary"); 1437 c.setFeature("be", new StringRef("plus")); 1438 c.setFeature("exists", new StringRef("minus")); 1439 l.add(c); 1440 c = new Terminal("can"); 1441 l.add(c); 1442 c = new Terminal("be"); 1443 l.add(c); 1444 addRule(new Rule(l, true)); 1445 1446 // auxiliary(be:plus, exists:minus)=>[should, be] 1447 l.clear(); 1448 featureHash.clear(); 1449 c = new Nonterminal("auxiliary"); 1450 c.setFeature("be", new StringRef("plus")); 1451 c.setFeature("exists", new StringRef("minus")); 1452 l.add(c); 1453 c = new Terminal("should"); 1454 l.add(c); 1455 c = new Terminal("be"); 1456 l.add(c); 1457 addRule(new Rule(l, true)); 1458 1459 // auxiliary(be:plus, exists:minus)=>[must, be] 1460 l.clear(); 1461 featureHash.clear(); 1462 c = new Nonterminal("auxiliary"); 1463 c.setFeature("be", new StringRef("plus")); 1464 c.setFeature("exists", new StringRef("minus")); 1465 l.add(c); 1466 c = new Terminal("must"); 1467 l.add(c); 1468 c = new Terminal("be"); 1469 l.add(c); 1470 addRule(new Rule(l, true)); 1471 1472 // auxiliary(be:plus, exists:minus, pl:minus)=>['has to', be] 1473 l.clear(); 1474 featureHash.clear(); 1475 c = new Nonterminal("auxiliary"); 1476 c.setFeature("be", new StringRef("plus")); 1477 c.setFeature("exists", new StringRef("minus")); 1478 c.setFeature("pl", new StringRef("minus")); 1479 l.add(c); 1480 c = new Terminal("has to"); 1481 l.add(c); 1482 c = new Terminal("be"); 1483 l.add(c); 1484 addRule(new Rule(l, true)); 1485 1486 // auxiliary(be:plus, exists:minus, pl:plus)=>['have to', be] 1487 l.clear(); 1488 featureHash.clear(); 1489 c = new Nonterminal("auxiliary"); 1490 c.setFeature("be", new StringRef("plus")); 1491 c.setFeature("exists", new StringRef("minus")); 1492 c.setFeature("pl", new StringRef("plus")); 1493 l.add(c); 1494 c = new Terminal("have to"); 1495 l.add(c); 1496 c = new Terminal("be"); 1497 l.add(c); 1498 addRule(new Rule(l, true)); 1499 1500 // auxiliary(be:plus, exists:minus)=>[cannot, be] 1501 l.clear(); 1502 featureHash.clear(); 1503 c = new Nonterminal("auxiliary"); 1504 c.setFeature("be", new StringRef("plus")); 1505 c.setFeature("exists", new StringRef("minus")); 1506 l.add(c); 1507 c = new Terminal("cannot"); 1508 l.add(c); 1509 c = new Terminal("be"); 1510 l.add(c); 1511 addRule(new Rule(l, true)); 1512 1513 // auxiliary(be:plus, exists:minus)=>[can, not, be] 1514 l.clear(); 1515 featureHash.clear(); 1516 c = new Nonterminal("auxiliary"); 1517 c.setFeature("be", new StringRef("plus")); 1518 c.setFeature("exists", new StringRef("minus")); 1519 l.add(c); 1520 c = new Terminal("can"); 1521 l.add(c); 1522 c = new Terminal("not"); 1523 l.add(c); 1524 c = new Terminal("be"); 1525 l.add(c); 1526 addRule(new Rule(l, true)); 1527 1528 // auxiliary(be:plus, exists:minus)=>[should, not, be] 1529 l.clear(); 1530 featureHash.clear(); 1531 c = new Nonterminal("auxiliary"); 1532 c.setFeature("be", new StringRef("plus")); 1533 c.setFeature("exists", new StringRef("minus")); 1534 l.add(c); 1535 c = new Terminal("should"); 1536 l.add(c); 1537 c = new Terminal("not"); 1538 l.add(c); 1539 c = new Terminal("be"); 1540 l.add(c); 1541 addRule(new Rule(l, true)); 1542 1543 // auxiliary(be:plus, exists:minus, pl:minus)=>['does not', 'have to', be] 1544 l.clear(); 1545 featureHash.clear(); 1546 c = new Nonterminal("auxiliary"); 1547 c.setFeature("be", new StringRef("plus")); 1548 c.setFeature("exists", new StringRef("minus")); 1549 c.setFeature("pl", new StringRef("minus")); 1550 l.add(c); 1551 c = new Terminal("does not"); 1552 l.add(c); 1553 c = new Terminal("have to"); 1554 l.add(c); 1555 c = new Terminal("be"); 1556 l.add(c); 1557 addRule(new Rule(l, true)); 1558 1559 // auxiliary(be:plus, exists:minus, pl:plus)=>['do not', 'have to', be] 1560 l.clear(); 1561 featureHash.clear(); 1562 c = new Nonterminal("auxiliary"); 1563 c.setFeature("be", new StringRef("plus")); 1564 c.setFeature("exists", new StringRef("minus")); 1565 c.setFeature("pl", new StringRef("plus")); 1566 l.add(c); 1567 c = new Terminal("do not"); 1568 l.add(c); 1569 c = new Terminal("have to"); 1570 l.add(c); 1571 c = new Terminal("be"); 1572 l.add(c); 1573 addRule(new Rule(l, true)); 1574 1575 // auxiliary(be:minus, exists:minus, pl:minus)=>[cannot] 1576 l.clear(); 1577 featureHash.clear(); 1578 c = new Nonterminal("auxiliary"); 1579 c.setFeature("be", new StringRef("minus")); 1580 c.setFeature("exists", new StringRef("minus")); 1581 c.setFeature("pl", new StringRef("minus")); 1582 l.add(c); 1583 c = new Terminal("cannot"); 1584 l.add(c); 1585 addRule(new Rule(l, true)); 1586 1587 // auxiliary(be:minus, exists:minus, pl:minus)=>[can, not] 1588 l.clear(); 1589 featureHash.clear(); 1590 c = new Nonterminal("auxiliary"); 1591 c.setFeature("be", new StringRef("minus")); 1592 c.setFeature("exists", new StringRef("minus")); 1593 c.setFeature("pl", new StringRef("minus")); 1594 l.add(c); 1595 c = new Terminal("can"); 1596 l.add(c); 1597 c = new Terminal("not"); 1598 l.add(c); 1599 addRule(new Rule(l, true)); 1600 1601 // auxiliary(be:minus, exists:minus, pl:minus)=>[should, not] 1602 l.clear(); 1603 featureHash.clear(); 1604 c = new Nonterminal("auxiliary"); 1605 c.setFeature("be", new StringRef("minus")); 1606 c.setFeature("exists", new StringRef("minus")); 1607 c.setFeature("pl", new StringRef("minus")); 1608 l.add(c); 1609 c = new Terminal("should"); 1610 l.add(c); 1611 c = new Terminal("not"); 1612 l.add(c); 1613 addRule(new Rule(l, true)); 1614 1615 // auxiliary(be:minus, exists:minus, pl:minus)=>['does not', 'have to'] 1616 l.clear(); 1617 featureHash.clear(); 1618 c = new Nonterminal("auxiliary"); 1619 c.setFeature("be", new StringRef("minus")); 1620 c.setFeature("exists", new StringRef("minus")); 1621 c.setFeature("pl", new StringRef("minus")); 1622 l.add(c); 1623 c = new Terminal("does not"); 1624 l.add(c); 1625 c = new Terminal("have to"); 1626 l.add(c); 1627 addRule(new Rule(l, true)); 1628 1629 // auxiliary(be:minus, exists:minus, pl:plus)=>['do not', 'have to'] 1630 l.clear(); 1631 featureHash.clear(); 1632 c = new Nonterminal("auxiliary"); 1633 c.setFeature("be", new StringRef("minus")); 1634 c.setFeature("exists", new StringRef("minus")); 1635 c.setFeature("pl", new StringRef("plus")); 1636 l.add(c); 1637 c = new Terminal("do not"); 1638 l.add(c); 1639 c = new Terminal("have to"); 1640 l.add(c); 1641 addRule(new Rule(l, true)); 1642 1643 // verb(be:minus, vsubcat:itr, pl:minus, vform:fin)=>['IV_FINSG'] 1644 l.clear(); 1645 featureHash.clear(); 1646 c = new Nonterminal("verb"); 1647 c.setFeature("be", new StringRef("minus")); 1648 c.setFeature("vsubcat", new StringRef("itr")); 1649 c.setFeature("pl", new StringRef("minus")); 1650 c.setFeature("vform", new StringRef("fin")); 1651 l.add(c); 1652 c = new Terminal("IV_FINSG"); 1653 l.add(c); 1654 addRule(new Rule(l, true)); 1655 1656 // verb(be:minus, vsubcat:itr, pl:plus, vform:fin)=>['IV_INFPL'] 1657 l.clear(); 1658 featureHash.clear(); 1659 c = new Nonterminal("verb"); 1660 c.setFeature("be", new StringRef("minus")); 1661 c.setFeature("vsubcat", new StringRef("itr")); 1662 c.setFeature("pl", new StringRef("plus")); 1663 c.setFeature("vform", new StringRef("fin")); 1664 l.add(c); 1665 c = new Terminal("IV_INFPL"); 1666 l.add(c); 1667 addRule(new Rule(l, true)); 1668 1669 // verb(be:minus, vsubcat:itr, vform:inf)=>['IV_INFPL'] 1670 l.clear(); 1671 featureHash.clear(); 1672 c = new Nonterminal("verb"); 1673 c.setFeature("be", new StringRef("minus")); 1674 c.setFeature("vsubcat", new StringRef("itr")); 1675 c.setFeature("vform", new StringRef("inf")); 1676 l.add(c); 1677 c = new Terminal("IV_INFPL"); 1678 l.add(c); 1679 addRule(new Rule(l, true)); 1680 1681 // verb(be:minus, vsubcat:tr, pl:minus, vform:fin)=>['TV_FINSG'] 1682 l.clear(); 1683 featureHash.clear(); 1684 c = new Nonterminal("verb"); 1685 c.setFeature("be", new StringRef("minus")); 1686 c.setFeature("vsubcat", new StringRef("tr")); 1687 c.setFeature("pl", new StringRef("minus")); 1688 c.setFeature("vform", new StringRef("fin")); 1689 l.add(c); 1690 c = new Terminal("TV_FINSG"); 1691 l.add(c); 1692 addRule(new Rule(l, true)); 1693 1694 // verb(be:minus, vsubcat:tr, pl:plus, vform:fin)=>['TV_INFPL'] 1695 l.clear(); 1696 featureHash.clear(); 1697 c = new Nonterminal("verb"); 1698 c.setFeature("be", new StringRef("minus")); 1699 c.setFeature("vsubcat", new StringRef("tr")); 1700 c.setFeature("pl", new StringRef("plus")); 1701 c.setFeature("vform", new StringRef("fin")); 1702 l.add(c); 1703 c = new Terminal("TV_INFPL"); 1704 l.add(c); 1705 addRule(new Rule(l, true)); 1706 1707 // verb(be:minus, vsubcat:tr, vform:inf)=>['TV_INFPL'] 1708 l.clear(); 1709 featureHash.clear(); 1710 c = new Nonterminal("verb"); 1711 c.setFeature("be", new StringRef("minus")); 1712 c.setFeature("vsubcat", new StringRef("tr")); 1713 c.setFeature("vform", new StringRef("inf")); 1714 l.add(c); 1715 c = new Terminal("TV_INFPL"); 1716 l.add(c); 1717 addRule(new Rule(l, true)); 1718 1719 // verb(be:plus, vsubcat:tr)=>['TV_PP'] 1720 l.clear(); 1721 featureHash.clear(); 1722 c = new Nonterminal("verb"); 1723 c.setFeature("be", new StringRef("plus")); 1724 c.setFeature("vsubcat", new StringRef("tr")); 1725 l.add(c); 1726 c = new Terminal("TV_PP"); 1727 l.add(c); 1728 addRule(new Rule(l, true)); 1729 1730 // rel_phrase(whin:A, whout:A)=>[] 1731 l.clear(); 1732 featureHash.clear(); 1733 c = new Nonterminal("rel_phrase"); 1734 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 1735 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 1736 l.add(c); 1737 addRule(new Rule(l, true)); 1738 1739 // rel_phrase(rel:plus, embv:plus, human:A, whin:B, whout:C)=>rel_pron(human:A, relpron:D), rel_phrase_1(human:A, relpron:D, whin:B, whout:C) 1740 l.clear(); 1741 featureHash.clear(); 1742 c = new Nonterminal("rel_phrase"); 1743 c.setFeature("rel", new StringRef("plus")); 1744 c.setFeature("embv", new StringRef("plus")); 1745 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1746 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 1747 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 1748 l.add(c); 1749 c = new Nonterminal("rel_pron"); 1750 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1751 setFeature(c.getFeatureMap(), "relpron", 3, featureHash); 1752 l.add(c); 1753 c = new Nonterminal("rel_phrase_1"); 1754 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1755 setFeature(c.getFeatureMap(), "relpron", 3, featureHash); 1756 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 1757 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 1758 l.add(c); 1759 addRule(new Rule(l, true)); 1760 1761 // rel_phrase_1(human:A, relpron:B, whin:C, whout:D)~>rel_phrase_2(human:A, rel:minus, relpron:B, whin:C, whout:E), or_rel_pron(human:A, relpron:B), rel_phrase_1(human:A, relpron:B, whin:E, whout:D) 1762 l.clear(); 1763 featureHash.clear(); 1764 c = new Nonterminal("rel_phrase_1"); 1765 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1766 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1767 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1768 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1769 l.add(c); 1770 c = new Nonterminal("rel_phrase_2"); 1771 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1772 c.setFeature("rel", new StringRef("minus")); 1773 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1774 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1775 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 1776 l.add(c); 1777 c = new Nonterminal("or_rel_pron"); 1778 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1779 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1780 l.add(c); 1781 c = new Nonterminal("rel_phrase_1"); 1782 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1783 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1784 setFeature(c.getFeatureMap(), "whin", 4, featureHash); 1785 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1786 l.add(c); 1787 addRule(new Rule(l, false)); 1788 1789 // rel_phrase_1(human:A, relpron:B, whin:C, whout:D)=>rel_phrase_2(human:A, relpron:B, whin:C, whout:D) 1790 l.clear(); 1791 featureHash.clear(); 1792 c = new Nonterminal("rel_phrase_1"); 1793 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1794 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1795 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1796 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1797 l.add(c); 1798 c = new Nonterminal("rel_phrase_2"); 1799 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1800 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1801 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 1802 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 1803 l.add(c); 1804 addRule(new Rule(l, true)); 1805 1806 // rel_phrase_2(rel:A, relpron:B, human:C, whin:D, whout:E)=>vp_cut(rel:minus, pl:minus, whin:D, whout:F), and_rel_pron(human:C, relpron:B), rel_phrase_2(rel:A, relpron:B, human:C, whin:F, whout:E) 1807 l.clear(); 1808 featureHash.clear(); 1809 c = new Nonterminal("rel_phrase_2"); 1810 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1811 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1812 setFeature(c.getFeatureMap(), "human", 2, featureHash); 1813 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 1814 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 1815 l.add(c); 1816 c = new Nonterminal("vp_cut"); 1817 c.setFeature("rel", new StringRef("minus")); 1818 c.setFeature("pl", new StringRef("minus")); 1819 setFeature(c.getFeatureMap(), "whin", 3, featureHash); 1820 setFeature(c.getFeatureMap(), "whout", 5, featureHash); 1821 l.add(c); 1822 c = new Nonterminal("and_rel_pron"); 1823 setFeature(c.getFeatureMap(), "human", 2, featureHash); 1824 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1825 l.add(c); 1826 c = new Nonterminal("rel_phrase_2"); 1827 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1828 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1829 setFeature(c.getFeatureMap(), "human", 2, featureHash); 1830 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 1831 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 1832 l.add(c); 1833 addRule(new Rule(l, true)); 1834 1835 // rel_phrase_2(rel:A, whin:B, whout:C)=>vp_cut(rel:A, pl:minus, whin:B, whout:C) 1836 l.clear(); 1837 featureHash.clear(); 1838 c = new Nonterminal("rel_phrase_2"); 1839 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1840 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 1841 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 1842 l.add(c); 1843 c = new Nonterminal("vp_cut"); 1844 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1845 c.setFeature("pl", new StringRef("minus")); 1846 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 1847 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 1848 l.add(c); 1849 addRule(new Rule(l, true)); 1850 1851 // rel_phrase_2(rel:A, whin:B, whout:C)=>nounphrase_cut(rel:minus, copula:minus, pl:D, embv:E, whin:B, whout:F), auxiliary(be:minus, exists:G, pl:D), verb(vsubcat:tr, be:minus, exists:G, pl:D, vform:inf), v_modifiers(rel:A, embv:E, copula:minus, whin:F, whout:C) 1852 l.clear(); 1853 featureHash.clear(); 1854 c = new Nonterminal("rel_phrase_2"); 1855 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1856 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 1857 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 1858 l.add(c); 1859 c = new Nonterminal("nounphrase_cut"); 1860 c.setFeature("rel", new StringRef("minus")); 1861 c.setFeature("copula", new StringRef("minus")); 1862 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 1863 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 1864 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 1865 setFeature(c.getFeatureMap(), "whout", 5, featureHash); 1866 l.add(c); 1867 c = new Nonterminal("auxiliary"); 1868 c.setFeature("be", new StringRef("minus")); 1869 setFeature(c.getFeatureMap(), "exists", 6, featureHash); 1870 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 1871 l.add(c); 1872 c = new Nonterminal("verb"); 1873 c.setFeature("vsubcat", new StringRef("tr")); 1874 c.setFeature("be", new StringRef("minus")); 1875 setFeature(c.getFeatureMap(), "exists", 6, featureHash); 1876 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 1877 c.setFeature("vform", new StringRef("inf")); 1878 l.add(c); 1879 c = new Nonterminal("v_modifiers"); 1880 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1881 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 1882 c.setFeature("copula", new StringRef("minus")); 1883 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 1884 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 1885 l.add(c); 1886 addRule(new Rule(l, true)); 1887 1888 // rel_phrase_2(rel:A, whin:B, whout:C)=>nounphrase_cut(rel:minus, copula:minus, pl:D, embv:E, whin:B, whout:F), verb(vsubcat:tr, be:minus, exists:plus, pl:D, vform:fin), v_modifiers(rel:A, embv:E, copula:minus, whin:F, whout:C) 1889 l.clear(); 1890 featureHash.clear(); 1891 c = new Nonterminal("rel_phrase_2"); 1892 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1893 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 1894 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 1895 l.add(c); 1896 c = new Nonterminal("nounphrase_cut"); 1897 c.setFeature("rel", new StringRef("minus")); 1898 c.setFeature("copula", new StringRef("minus")); 1899 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 1900 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 1901 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 1902 setFeature(c.getFeatureMap(), "whout", 5, featureHash); 1903 l.add(c); 1904 c = new Nonterminal("verb"); 1905 c.setFeature("vsubcat", new StringRef("tr")); 1906 c.setFeature("be", new StringRef("minus")); 1907 c.setFeature("exists", new StringRef("plus")); 1908 setFeature(c.getFeatureMap(), "pl", 3, featureHash); 1909 c.setFeature("vform", new StringRef("fin")); 1910 l.add(c); 1911 c = new Nonterminal("v_modifiers"); 1912 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 1913 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 1914 c.setFeature("copula", new StringRef("minus")); 1915 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 1916 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 1917 l.add(c); 1918 addRule(new Rule(l, true)); 1919 1920 // rel_pron(relpron:that)=>[that] 1921 l.clear(); 1922 featureHash.clear(); 1923 c = new Nonterminal("rel_pron"); 1924 c.setFeature("relpron", new StringRef("that")); 1925 l.add(c); 1926 c = new Terminal("that"); 1927 l.add(c); 1928 addRule(new Rule(l, true)); 1929 1930 // rel_pron(human:plus, relpron:who)=>[who] 1931 l.clear(); 1932 featureHash.clear(); 1933 c = new Nonterminal("rel_pron"); 1934 c.setFeature("human", new StringRef("plus")); 1935 c.setFeature("relpron", new StringRef("who")); 1936 l.add(c); 1937 c = new Terminal("who"); 1938 l.add(c); 1939 addRule(new Rule(l, true)); 1940 1941 // rel_pron(human:minus, relpron:which)=>[which] 1942 l.clear(); 1943 featureHash.clear(); 1944 c = new Nonterminal("rel_pron"); 1945 c.setFeature("human", new StringRef("minus")); 1946 c.setFeature("relpron", new StringRef("which")); 1947 l.add(c); 1948 c = new Terminal("which"); 1949 l.add(c); 1950 addRule(new Rule(l, true)); 1951 1952 // or_rel_pron(human:A, relpron:B)=>[or], rel_pron(human:A, relpron:B) 1953 l.clear(); 1954 featureHash.clear(); 1955 c = new Nonterminal("or_rel_pron"); 1956 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1957 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1958 l.add(c); 1959 c = new Terminal("or"); 1960 l.add(c); 1961 c = new Nonterminal("rel_pron"); 1962 setFeature(c.getFeatureMap(), "human", 0, featureHash); 1963 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 1964 l.add(c); 1965 addRule(new Rule(l, true)); 1966 1967 // or_rel_pron(relpron:that)=>['or that'] 1968 l.clear(); 1969 featureHash.clear(); 1970 c = new Nonterminal("or_rel_pron"); 1971 c.setFeature("relpron", new StringRef("that")); 1972 l.add(c); 1973 c = new Terminal("or that"); 1974 l.add(c); 1975 addRule(new Rule(l, true)); 1976 1977 // or_rel_pron(human:plus, relpron:who)=>['or who'] 1978 l.clear(); 1979 featureHash.clear(); 1980 c = new Nonterminal("or_rel_pron"); 1981 c.setFeature("human", new StringRef("plus")); 1982 c.setFeature("relpron", new StringRef("who")); 1983 l.add(c); 1984 c = new Terminal("or who"); 1985 l.add(c); 1986 addRule(new Rule(l, true)); 1987 1988 // or_rel_pron(human:minus, relpron:which)=>['or which'] 1989 l.clear(); 1990 featureHash.clear(); 1991 c = new Nonterminal("or_rel_pron"); 1992 c.setFeature("human", new StringRef("minus")); 1993 c.setFeature("relpron", new StringRef("which")); 1994 l.add(c); 1995 c = new Terminal("or which"); 1996 l.add(c); 1997 addRule(new Rule(l, true)); 1998 1999 // and_rel_pron(human:A, relpron:B)=>[and], rel_pron(human:A, relpron:B) 2000 l.clear(); 2001 featureHash.clear(); 2002 c = new Nonterminal("and_rel_pron"); 2003 setFeature(c.getFeatureMap(), "human", 0, featureHash); 2004 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 2005 l.add(c); 2006 c = new Terminal("and"); 2007 l.add(c); 2008 c = new Nonterminal("rel_pron"); 2009 setFeature(c.getFeatureMap(), "human", 0, featureHash); 2010 setFeature(c.getFeatureMap(), "relpron", 1, featureHash); 2011 l.add(c); 2012 addRule(new Rule(l, true)); 2013 2014 // and_rel_pron(relpron:that)=>['and that'] 2015 l.clear(); 2016 featureHash.clear(); 2017 c = new Nonterminal("and_rel_pron"); 2018 c.setFeature("relpron", new StringRef("that")); 2019 l.add(c); 2020 c = new Terminal("and that"); 2021 l.add(c); 2022 addRule(new Rule(l, true)); 2023 2024 // and_rel_pron(human:plus, relpron:who)=>['and who'] 2025 l.clear(); 2026 featureHash.clear(); 2027 c = new Nonterminal("and_rel_pron"); 2028 c.setFeature("human", new StringRef("plus")); 2029 c.setFeature("relpron", new StringRef("who")); 2030 l.add(c); 2031 c = new Terminal("and who"); 2032 l.add(c); 2033 addRule(new Rule(l, true)); 2034 2035 // and_rel_pron(human:minus, relpron:which)=>['and which'] 2036 l.clear(); 2037 featureHash.clear(); 2038 c = new Nonterminal("and_rel_pron"); 2039 c.setFeature("human", new StringRef("minus")); 2040 c.setFeature("relpron", new StringRef("which")); 2041 l.add(c); 2042 c = new Terminal("and which"); 2043 l.add(c); 2044 addRule(new Rule(l, true)); 2045 2046 // opt_adj_coord=>[] 2047 l.clear(); 2048 featureHash.clear(); 2049 c = new Nonterminal("opt_adj_coord"); 2050 l.add(c); 2051 addRule(new Rule(l, true)); 2052 2053 // opt_adj_coord=>adj_coord 2054 l.clear(); 2055 featureHash.clear(); 2056 c = new Nonterminal("opt_adj_coord"); 2057 l.add(c); 2058 c = new Nonterminal("adj_coord"); 2059 l.add(c); 2060 addRule(new Rule(l, true)); 2061 2062 // adj_coord=>adj_itr 2063 l.clear(); 2064 featureHash.clear(); 2065 c = new Nonterminal("adj_coord"); 2066 l.add(c); 2067 c = new Nonterminal("adj_itr"); 2068 l.add(c); 2069 addRule(new Rule(l, true)); 2070 2071 // adj_coord=>adj_itr, [and], adj_coord 2072 l.clear(); 2073 featureHash.clear(); 2074 c = new Nonterminal("adj_coord"); 2075 l.add(c); 2076 c = new Nonterminal("adj_itr"); 2077 l.add(c); 2078 c = new Terminal("and"); 2079 l.add(c); 2080 c = new Nonterminal("adj_coord"); 2081 l.add(c); 2082 addRule(new Rule(l, true)); 2083 2084 // adj_itr=>['ADJ_ITR'] 2085 l.clear(); 2086 featureHash.clear(); 2087 c = new Nonterminal("adj_itr"); 2088 l.add(c); 2089 c = new Terminal("ADJ_ITR"); 2090 l.add(c); 2091 addRule(new Rule(l, true)); 2092 2093 // adj_itr=>[more, 'ADJ_ITR'] 2094 l.clear(); 2095 featureHash.clear(); 2096 c = new Nonterminal("adj_itr"); 2097 l.add(c); 2098 c = new Terminal("more"); 2099 l.add(c); 2100 c = new Terminal("ADJ_ITR"); 2101 l.add(c); 2102 addRule(new Rule(l, true)); 2103 2104 // adj_itr=>['ADJ_ITR_COMP'] 2105 l.clear(); 2106 featureHash.clear(); 2107 c = new Nonterminal("adj_itr"); 2108 l.add(c); 2109 c = new Terminal("ADJ_ITR_COMP"); 2110 l.add(c); 2111 addRule(new Rule(l, true)); 2112 2113 // adj_itr=>[most, 'ADJ_ITR'] 2114 l.clear(); 2115 featureHash.clear(); 2116 c = new Nonterminal("adj_itr"); 2117 l.add(c); 2118 c = new Terminal("most"); 2119 l.add(c); 2120 c = new Terminal("ADJ_ITR"); 2121 l.add(c); 2122 addRule(new Rule(l, true)); 2123 2124 // adj_itr=>['ADJ_ITR_SUP'] 2125 l.clear(); 2126 featureHash.clear(); 2127 c = new Nonterminal("adj_itr"); 2128 l.add(c); 2129 c = new Terminal("ADJ_ITR_SUP"); 2130 l.add(c); 2131 addRule(new Rule(l, true)); 2132 2133 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[as, 'ADJ_ITR', as], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D) 2134 l.clear(); 2135 featureHash.clear(); 2136 c = new Nonterminal("compl_adj"); 2137 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2138 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2139 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2140 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2141 l.add(c); 2142 c = new Terminal("as"); 2143 l.add(c); 2144 c = new Terminal("ADJ_ITR"); 2145 l.add(c); 2146 c = new Terminal("as"); 2147 l.add(c); 2148 c = new Nonterminal("nounphrase_cut"); 2149 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2150 c.setFeature("copula", new StringRef("minus")); 2151 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2152 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2153 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2154 l.add(c); 2155 addRule(new Rule(l, true)); 2156 2157 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>['ADJ_ITR_COMP', than], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D) 2158 l.clear(); 2159 featureHash.clear(); 2160 c = new Nonterminal("compl_adj"); 2161 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2162 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2163 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2164 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2165 l.add(c); 2166 c = new Terminal("ADJ_ITR_COMP"); 2167 l.add(c); 2168 c = new Terminal("than"); 2169 l.add(c); 2170 c = new Nonterminal("nounphrase_cut"); 2171 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2172 c.setFeature("copula", new StringRef("minus")); 2173 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2174 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2175 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2176 l.add(c); 2177 addRule(new Rule(l, true)); 2178 2179 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[more, 'ADJ_ITR', than], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D) 2180 l.clear(); 2181 featureHash.clear(); 2182 c = new Nonterminal("compl_adj"); 2183 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2184 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2185 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2186 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2187 l.add(c); 2188 c = new Terminal("more"); 2189 l.add(c); 2190 c = new Terminal("ADJ_ITR"); 2191 l.add(c); 2192 c = new Terminal("than"); 2193 l.add(c); 2194 c = new Nonterminal("nounphrase_cut"); 2195 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2196 c.setFeature("copula", new StringRef("minus")); 2197 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2198 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2199 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2200 l.add(c); 2201 addRule(new Rule(l, true)); 2202 2203 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>['ADJ_TR'], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D) 2204 l.clear(); 2205 featureHash.clear(); 2206 c = new Nonterminal("compl_adj"); 2207 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2208 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2209 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2210 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2211 l.add(c); 2212 c = new Terminal("ADJ_TR"); 2213 l.add(c); 2214 c = new Nonterminal("nounphrase_cut"); 2215 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2216 c.setFeature("copula", new StringRef("minus")); 2217 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2218 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2219 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2220 l.add(c); 2221 addRule(new Rule(l, true)); 2222 2223 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[more, 'ADJ_TR'], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:E) 2224 l.clear(); 2225 featureHash.clear(); 2226 c = new Nonterminal("compl_adj"); 2227 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2228 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2229 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2230 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2231 l.add(c); 2232 c = new Terminal("more"); 2233 l.add(c); 2234 c = new Terminal("ADJ_TR"); 2235 l.add(c); 2236 c = new Nonterminal("nounphrase_cut"); 2237 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2238 c.setFeature("copula", new StringRef("minus")); 2239 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2240 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2241 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 2242 l.add(c); 2243 addRule(new Rule(l, true)); 2244 2245 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[most, 'ADJ_TR'], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:E) 2246 l.clear(); 2247 featureHash.clear(); 2248 c = new Nonterminal("compl_adj"); 2249 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2250 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2251 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2252 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2253 l.add(c); 2254 c = new Terminal("most"); 2255 l.add(c); 2256 c = new Terminal("ADJ_TR"); 2257 l.add(c); 2258 c = new Nonterminal("nounphrase_cut"); 2259 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2260 c.setFeature("copula", new StringRef("minus")); 2261 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2262 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2263 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 2264 l.add(c); 2265 addRule(new Rule(l, true)); 2266 2267 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[as, 'ADJ_TR'], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:E), [as], nounphrase_cut(rel:A, copula:minus, embv:B, whin:E, whout:D) 2268 l.clear(); 2269 featureHash.clear(); 2270 c = new Nonterminal("compl_adj"); 2271 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2272 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2273 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2274 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2275 l.add(c); 2276 c = new Terminal("as"); 2277 l.add(c); 2278 c = new Terminal("ADJ_TR"); 2279 l.add(c); 2280 c = new Nonterminal("nounphrase_cut"); 2281 c.setFeature("rel", new StringRef("minus")); 2282 c.setFeature("copula", new StringRef("minus")); 2283 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2284 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2285 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 2286 l.add(c); 2287 c = new Terminal("as"); 2288 l.add(c); 2289 c = new Nonterminal("nounphrase_cut"); 2290 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2291 c.setFeature("copula", new StringRef("minus")); 2292 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2293 setFeature(c.getFeatureMap(), "whin", 4, featureHash); 2294 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2295 l.add(c); 2296 addRule(new Rule(l, true)); 2297 2298 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[as, 'ADJ_TR'(prep:E)], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:F), [as, 'ADJ_TR_PREP'(prep:E)], nounphrase_cut(rel:A, copula:minus, embv:B, whin:F, whout:D) 2299 l.clear(); 2300 featureHash.clear(); 2301 c = new Nonterminal("compl_adj"); 2302 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2303 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2304 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2305 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2306 l.add(c); 2307 c = new Terminal("as"); 2308 l.add(c); 2309 c = new Terminal("ADJ_TR"); 2310 setFeature(c.getFeatureMap(), "prep", 4, featureHash); 2311 l.add(c); 2312 c = new Nonterminal("nounphrase_cut"); 2313 c.setFeature("rel", new StringRef("minus")); 2314 c.setFeature("copula", new StringRef("minus")); 2315 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2316 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2317 setFeature(c.getFeatureMap(), "whout", 5, featureHash); 2318 l.add(c); 2319 c = new Terminal("as"); 2320 l.add(c); 2321 c = new Terminal("ADJ_TR_PREP"); 2322 setFeature(c.getFeatureMap(), "prep", 4, featureHash); 2323 l.add(c); 2324 c = new Nonterminal("nounphrase_cut"); 2325 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2326 c.setFeature("copula", new StringRef("minus")); 2327 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2328 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 2329 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2330 l.add(c); 2331 addRule(new Rule(l, true)); 2332 2333 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[more, 'ADJ_TR'], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:E), [than], nounphrase_cut(rel:A, copula:minus, embv:B, whin:E, whout:D) 2334 l.clear(); 2335 featureHash.clear(); 2336 c = new Nonterminal("compl_adj"); 2337 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2338 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2339 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2340 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2341 l.add(c); 2342 c = new Terminal("more"); 2343 l.add(c); 2344 c = new Terminal("ADJ_TR"); 2345 l.add(c); 2346 c = new Nonterminal("nounphrase_cut"); 2347 c.setFeature("rel", new StringRef("minus")); 2348 c.setFeature("copula", new StringRef("minus")); 2349 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2350 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2351 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 2352 l.add(c); 2353 c = new Terminal("than"); 2354 l.add(c); 2355 c = new Nonterminal("nounphrase_cut"); 2356 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2357 c.setFeature("copula", new StringRef("minus")); 2358 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2359 setFeature(c.getFeatureMap(), "whin", 4, featureHash); 2360 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2361 l.add(c); 2362 addRule(new Rule(l, true)); 2363 2364 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>['ADJ_TR_COMP'], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:E), [than], nounphrase_cut(rel:A, copula:minus, embv:B, whin:E, whout:D) 2365 l.clear(); 2366 featureHash.clear(); 2367 c = new Nonterminal("compl_adj"); 2368 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2369 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2370 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2371 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2372 l.add(c); 2373 c = new Terminal("ADJ_TR_COMP"); 2374 l.add(c); 2375 c = new Nonterminal("nounphrase_cut"); 2376 c.setFeature("rel", new StringRef("minus")); 2377 c.setFeature("copula", new StringRef("minus")); 2378 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2379 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2380 setFeature(c.getFeatureMap(), "whout", 4, featureHash); 2381 l.add(c); 2382 c = new Terminal("than"); 2383 l.add(c); 2384 c = new Nonterminal("nounphrase_cut"); 2385 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2386 c.setFeature("copula", new StringRef("minus")); 2387 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2388 setFeature(c.getFeatureMap(), "whin", 4, featureHash); 2389 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2390 l.add(c); 2391 addRule(new Rule(l, true)); 2392 2393 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[more, 'ADJ_TR'(prep:E)], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:F), [than, 'ADJ_TR_PREP'(prep:E)], nounphrase_cut(rel:A, copula:minus, embv:B, whin:F, whout:D) 2394 l.clear(); 2395 featureHash.clear(); 2396 c = new Nonterminal("compl_adj"); 2397 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2398 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2399 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2400 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2401 l.add(c); 2402 c = new Terminal("more"); 2403 l.add(c); 2404 c = new Terminal("ADJ_TR"); 2405 setFeature(c.getFeatureMap(), "prep", 4, featureHash); 2406 l.add(c); 2407 c = new Nonterminal("nounphrase_cut"); 2408 c.setFeature("rel", new StringRef("minus")); 2409 c.setFeature("copula", new StringRef("minus")); 2410 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2411 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2412 setFeature(c.getFeatureMap(), "whout", 5, featureHash); 2413 l.add(c); 2414 c = new Terminal("than"); 2415 l.add(c); 2416 c = new Terminal("ADJ_TR_PREP"); 2417 setFeature(c.getFeatureMap(), "prep", 4, featureHash); 2418 l.add(c); 2419 c = new Nonterminal("nounphrase_cut"); 2420 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2421 c.setFeature("copula", new StringRef("minus")); 2422 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2423 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 2424 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2425 l.add(c); 2426 addRule(new Rule(l, true)); 2427 2428 // compl_adj(rel:A, embv:B, whin:C, whout:D)=>['ADJ_TR_COMP'(prep:E)], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:F), [than, 'ADJ_TR_PREP'(prep:E)], nounphrase_cut(rel:A, copula:minus, embv:B, whin:F, whout:D) 2429 l.clear(); 2430 featureHash.clear(); 2431 c = new Nonterminal("compl_adj"); 2432 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2433 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2434 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2435 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2436 l.add(c); 2437 c = new Terminal("ADJ_TR_COMP"); 2438 setFeature(c.getFeatureMap(), "prep", 4, featureHash); 2439 l.add(c); 2440 c = new Nonterminal("nounphrase_cut"); 2441 c.setFeature("rel", new StringRef("minus")); 2442 c.setFeature("copula", new StringRef("minus")); 2443 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2444 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2445 setFeature(c.getFeatureMap(), "whout", 5, featureHash); 2446 l.add(c); 2447 c = new Terminal("than"); 2448 l.add(c); 2449 c = new Terminal("ADJ_TR_PREP"); 2450 setFeature(c.getFeatureMap(), "prep", 4, featureHash); 2451 l.add(c); 2452 c = new Nonterminal("nounphrase_cut"); 2453 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2454 c.setFeature("copula", new StringRef("minus")); 2455 setFeature(c.getFeatureMap(), "embv", 1, featureHash); 2456 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 2457 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2458 l.add(c); 2459 addRule(new Rule(l, true)); 2460 2461 // v_modifiers(whin:A, whout:A)=>[] 2462 l.clear(); 2463 featureHash.clear(); 2464 c = new Nonterminal("v_modifiers"); 2465 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 2466 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 2467 l.add(c); 2468 addRule(new Rule(l, true)); 2469 2470 // v_modifiers(rel:A, embv:minus, copula:B, whin:C, whout:D)=>adv_coord(copula:B), v_modifiers_x(rel:A, copula:B, whin:C, whout:D) 2471 l.clear(); 2472 featureHash.clear(); 2473 c = new Nonterminal("v_modifiers"); 2474 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2475 c.setFeature("embv", new StringRef("minus")); 2476 setFeature(c.getFeatureMap(), "copula", 1, featureHash); 2477 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2478 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2479 l.add(c); 2480 c = new Nonterminal("adv_coord"); 2481 setFeature(c.getFeatureMap(), "copula", 1, featureHash); 2482 l.add(c); 2483 c = new Nonterminal("v_modifiers_x"); 2484 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2485 setFeature(c.getFeatureMap(), "copula", 1, featureHash); 2486 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2487 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2488 l.add(c); 2489 addRule(new Rule(l, true)); 2490 2491 // v_modifiers(rel:A, embv:minus, copula:B, whin:C, whout:D)=>pp(rel:A, embv:E, whin:C, whout:F), v_modifiers(rel:A, embv:E, copula:B, whin:F, whout:D) 2492 l.clear(); 2493 featureHash.clear(); 2494 c = new Nonterminal("v_modifiers"); 2495 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2496 c.setFeature("embv", new StringRef("minus")); 2497 setFeature(c.getFeatureMap(), "copula", 1, featureHash); 2498 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2499 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2500 l.add(c); 2501 c = new Nonterminal("pp"); 2502 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2503 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 2504 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2505 setFeature(c.getFeatureMap(), "whout", 5, featureHash); 2506 l.add(c); 2507 c = new Nonterminal("v_modifiers"); 2508 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2509 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 2510 setFeature(c.getFeatureMap(), "copula", 1, featureHash); 2511 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 2512 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2513 l.add(c); 2514 addRule(new Rule(l, true)); 2515 2516 // v_modifiers_x(whin:A, whout:A)=>[] 2517 l.clear(); 2518 featureHash.clear(); 2519 c = new Nonterminal("v_modifiers_x"); 2520 setFeature(c.getFeatureMap(), "whin", 0, featureHash); 2521 setFeature(c.getFeatureMap(), "whout", 0, featureHash); 2522 l.add(c); 2523 addRule(new Rule(l, true)); 2524 2525 // v_modifiers_x(rel:A, copula:B, whin:C, whout:D)=>pp(rel:A, embv:E, whin:C, whout:F), v_modifiers(rel:A, embv:E, copula:B, whin:F, whout:D) 2526 l.clear(); 2527 featureHash.clear(); 2528 c = new Nonterminal("v_modifiers_x"); 2529 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2530 setFeature(c.getFeatureMap(), "copula", 1, featureHash); 2531 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2532 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2533 l.add(c); 2534 c = new Nonterminal("pp"); 2535 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2536 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 2537 setFeature(c.getFeatureMap(), "whin", 2, featureHash); 2538 setFeature(c.getFeatureMap(), "whout", 5, featureHash); 2539 l.add(c); 2540 c = new Nonterminal("v_modifiers"); 2541 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2542 setFeature(c.getFeatureMap(), "embv", 4, featureHash); 2543 setFeature(c.getFeatureMap(), "copula", 1, featureHash); 2544 setFeature(c.getFeatureMap(), "whin", 5, featureHash); 2545 setFeature(c.getFeatureMap(), "whout", 3, featureHash); 2546 l.add(c); 2547 addRule(new Rule(l, true)); 2548 2549 // pp(rel:A, whin:B, whout:C)=>['PREP'], nounphrase_cut(rel:A, whin:B, whout:C) 2550 l.clear(); 2551 featureHash.clear(); 2552 c = new Nonterminal("pp"); 2553 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2554 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 2555 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 2556 l.add(c); 2557 c = new Terminal("PREP"); 2558 l.add(c); 2559 c = new Nonterminal("nounphrase_cut"); 2560 setFeature(c.getFeatureMap(), "rel", 0, featureHash); 2561 setFeature(c.getFeatureMap(), "whin", 1, featureHash); 2562 setFeature(c.getFeatureMap(), "whout", 2, featureHash); 2563 l.add(c); 2564 addRule(new Rule(l, true)); 2565 2566 // adv_coord(copula:minus)=>adv 2567 l.clear(); 2568 featureHash.clear(); 2569 c = new Nonterminal("adv_coord"); 2570 c.setFeature("copula", new StringRef("minus")); 2571 l.add(c); 2572 c = new Nonterminal("adv"); 2573 l.add(c); 2574 addRule(new Rule(l, true)); 2575 2576 // adv_coord(copula:minus)=>adv, [and], adv_coord 2577 l.clear(); 2578 featureHash.clear(); 2579 c = new Nonterminal("adv_coord"); 2580 c.setFeature("copula", new StringRef("minus")); 2581 l.add(c); 2582 c = new Nonterminal("adv"); 2583 l.add(c); 2584 c = new Terminal("and"); 2585 l.add(c); 2586 c = new Nonterminal("adv_coord"); 2587 l.add(c); 2588 addRule(new Rule(l, true)); 2589 2590 // adv=>['ADV'] 2591 l.clear(); 2592 featureHash.clear(); 2593 c = new Nonterminal("adv"); 2594 l.add(c); 2595 c = new Terminal("ADV"); 2596 l.add(c); 2597 addRule(new Rule(l, true)); 2598 2599 // adv=>[more, 'ADV'] 2600 l.clear(); 2601 featureHash.clear(); 2602 c = new Nonterminal("adv"); 2603 l.add(c); 2604 c = new Terminal("more"); 2605 l.add(c); 2606 c = new Terminal("ADV"); 2607 l.add(c); 2608 addRule(new Rule(l, true)); 2609 2610 // adv=>['ADV_COMP'] 2611 l.clear(); 2612 featureHash.clear(); 2613 c = new Nonterminal("adv"); 2614 l.add(c); 2615 c = new Terminal("ADV_COMP"); 2616 l.add(c); 2617 addRule(new Rule(l, true)); 2618 2619 // adv=>[most, 'ADV'] 2620 l.clear(); 2621 featureHash.clear(); 2622 c = new Nonterminal("adv"); 2623 l.add(c); 2624 c = new Terminal("most"); 2625 l.add(c); 2626 c = new Terminal("ADV"); 2627 l.add(c); 2628 addRule(new Rule(l, true)); 2629 2630 // adv=>['ADV_SUP'] 2631 l.clear(); 2632 featureHash.clear(); 2633 c = new Nonterminal("adv"); 2634 l.add(c); 2635 c = new Terminal("ADV_SUP"); 2636 l.add(c); 2637 addRule(new Rule(l, true)); 2638 2639 // exist_anon(human:minus)=>[something] 2640 l.clear(); 2641 featureHash.clear(); 2642 c = new Nonterminal("exist_anon"); 2643 c.setFeature("human", new StringRef("minus")); 2644 l.add(c); 2645 c = new Terminal("something"); 2646 l.add(c); 2647 addRule(new Rule(l, true)); 2648 2649 // exist_anon(human:plus)=>[somebody] 2650 l.clear(); 2651 featureHash.clear(); 2652 c = new Nonterminal("exist_anon"); 2653 c.setFeature("human", new StringRef("plus")); 2654 l.add(c); 2655 c = new Terminal("somebody"); 2656 l.add(c); 2657 addRule(new Rule(l, true)); 2658 2659 // univ_anon(human:minus)=>[everything] 2660 l.clear(); 2661 featureHash.clear(); 2662 c = new Nonterminal("univ_anon"); 2663 c.setFeature("human", new StringRef("minus")); 2664 l.add(c); 2665 c = new Terminal("everything"); 2666 l.add(c); 2667 addRule(new Rule(l, true)); 2668 2669 // univ_anon(human:plus)=>[everybody] 2670 l.clear(); 2671 featureHash.clear(); 2672 c = new Nonterminal("univ_anon"); 2673 c.setFeature("human", new StringRef("plus")); 2674 l.add(c); 2675 c = new Terminal("everybody"); 2676 l.add(c); 2677 addRule(new Rule(l, true)); 2678 2679 // neg_anon(human:minus)=>[nothing] 2680 l.clear(); 2681 featureHash.clear(); 2682 c = new Nonterminal("neg_anon"); 2683 c.setFeature("human", new StringRef("minus")); 2684 l.add(c); 2685 c = new Terminal("nothing"); 2686 l.add(c); 2687 addRule(new Rule(l, true)); 2688 2689 // neg_anon(human:plus)=>[nobody] 2690 l.clear(); 2691 featureHash.clear(); 2692 c = new Nonterminal("neg_anon"); 2693 c.setFeature("human", new StringRef("plus")); 2694 l.add(c); 2695 c = new Terminal("nobody"); 2696 l.add(c); 2697 addRule(new Rule(l, true)); 2698 2699 // num_quant=>['at least'] 2700 l.clear(); 2701 featureHash.clear(); 2702 c = new Nonterminal("num_quant"); 2703 l.add(c); 2704 c = new Terminal("at least"); 2705 l.add(c); 2706 addRule(new Rule(l, true)); 2707 2708 // num_quant=>['at most'] 2709 l.clear(); 2710 featureHash.clear(); 2711 c = new Nonterminal("num_quant"); 2712 l.add(c); 2713 c = new Terminal("at most"); 2714 l.add(c); 2715 addRule(new Rule(l, true)); 2716 2717 // num_quant=>['less than'] 2718 l.clear(); 2719 featureHash.clear(); 2720 c = new Nonterminal("num_quant"); 2721 l.add(c); 2722 c = new Terminal("less than"); 2723 l.add(c); 2724 addRule(new Rule(l, true)); 2725 2726 // num_quant=>['more than'] 2727 l.clear(); 2728 featureHash.clear(); 2729 c = new Nonterminal("num_quant"); 2730 l.add(c); 2731 c = new Terminal("more than"); 2732 l.add(c); 2733 addRule(new Rule(l, true)); 2734 2735 // num_quant=>[exactly] 2736 l.clear(); 2737 featureHash.clear(); 2738 c = new Nonterminal("num_quant"); 2739 l.add(c); 2740 c = new Terminal("exactly"); 2741 l.add(c); 2742 addRule(new Rule(l, true)); 2743 2744 // propername(human:A)=>['PN_SG'(human:A)] 2745 l.clear(); 2746 featureHash.clear(); 2747 c = new Nonterminal("propername"); 2748 setFeature(c.getFeatureMap(), "human", 0, featureHash); 2749 l.add(c); 2750 c = new Terminal("PN_SG"); 2751 setFeature(c.getFeatureMap(), "human", 0, featureHash); 2752 l.add(c); 2753 addRule(new Rule(l, true)); 2754 2755 // propername(human:A)=>['PNDEF_SG'(human:A)] 2756 l.clear(); 2757 featureHash.clear(); 2758 c = new Nonterminal("propername"); 2759 setFeature(c.getFeatureMap(), "human", 0, featureHash); 2760 l.add(c); 2761 c = new Terminal("PNDEF_SG"); 2762 setFeature(c.getFeatureMap(), "human", 0, featureHash); 2763 l.add(c); 2764 addRule(new Rule(l, true)); 2765 2766 } 2767 2768 private void setFeature(FeatureMap fm, String featureName, int varID, HashMap<Integer, StringRef> featureHash) { 2769 if (featureHash.get(varID) == null) { 2770 StringRef stringRef = new StringRef(); 2771 fm.setFeature(featureName, stringRef); 2772 featureHash.put(varID, stringRef); 2773 } else { 2774 fm.setFeature(featureName, featureHash.get(varID)); 2775 } 2776 } 2777 2778 }