src/com/hughes/android/dictionary/parser/wiktionary/EnFunctionCallbacks.java

   1 // Copyright 2012 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 package com.hughes.android.dictionary.parser.wiktionary;
  16
  17 import java.util.Arrays;
  18 import java.util.LinkedHashMap;
  19 import java.util.LinkedHashSet;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Set;
  23 import java.util.concurrent.atomic.AtomicInteger;
  24
  25 import com.hughes.android.dictionary.engine.EntryTypeName;
  26 import com.hughes.android.dictionary.engine.IndexBuilder;
  27 import com.hughes.android.dictionary.parser.WikiTokenizer;
  28 import com.hughes.android.dictionary.parser.wiktionary.AbstractWiktionaryParser.AppendAndIndexWikiCallback;
  29 import com.hughes.android.dictionary.parser.wiktionary.AbstractWiktionaryParser.NameAndArgs;
  30 import com.hughes.util.ListUtil;
  31
  32 class EnFunctionCallbacks {
  33
  34   static final Map<String,FunctionCallback<EnParser>> DEFAULT = new LinkedHashMap<String, FunctionCallback<EnParser>>();
  35
  36   static {
  37     FunctionCallback<EnParser> callback = new TranslationCallback();
  38     DEFAULT.put("t", callback);
  39     DEFAULT.put("t+", callback);
  40     DEFAULT.put("t-", callback);
  41     DEFAULT.put("tø", callback);
  42     DEFAULT.put("apdx-t", callback);
  43
  44     callback = new EncodingCallback();
  45     Set<String> encodings = new LinkedHashSet<String>(Arrays.asList(
  46         "zh-ts", "zh-tsp",
  47         "sd-Arab", "ku-Arab", "Arab", "unicode", "Laoo", "ur-Arab", "Thai",
  48         "fa-Arab", "Khmr", "Cyrl", "IPAchar", "ug-Arab", "ko-inline",
  49         "Jpan", "Kore", "Hebr", "rfscript", "Beng", "Mong", "Knda", "Cyrs",
  50         "yue-tsj", "Mlym", "Tfng", "Grek", "yue-yue-j"));
  51     for (final String encoding : encodings) {
  52       DEFAULT.put(encoding, callback);
  53     }
  54
  55     callback = new l_term();
  56     DEFAULT.put("l", callback);
  57     DEFAULT.put("term", callback);
  58
  59     callback = new Gender();
  60     DEFAULT.put("m", callback);
  61     DEFAULT.put("f", callback);
  62     DEFAULT.put("n", callback);
  63     DEFAULT.put("p", callback);
  64     DEFAULT.put("g", callback);
  65
  66     callback = new AppendArg0();
  67
  68     callback = new Ignore();
  69     DEFAULT.put("trreq", callback);
  70     DEFAULT.put("t-image", callback);
  71     DEFAULT.put("defn", callback);
  72     DEFAULT.put("rfdef", callback);
  73     DEFAULT.put("rfdate", callback);
  74     DEFAULT.put("rfex", callback);
  75     DEFAULT.put("rfquote", callback);
  76     DEFAULT.put("attention", callback);
  77     DEFAULT.put("zh-attention", callback);
  78
  79
  80     callback = new FormOf();
  81     DEFAULT.put("form of", callback);
  82     DEFAULT.put("conjugation of", callback);
  83     DEFAULT.put("participle of", callback);
  84     DEFAULT.put("present participle of", callback);
  85     DEFAULT.put("past participle of", callback);
  86     DEFAULT.put("feminine past participle of", callback);
  87     DEFAULT.put("gerund of", callback);
  88     DEFAULT.put("feminine of", callback);
  89     DEFAULT.put("plural of", callback);
  90     DEFAULT.put("feminine plural of", callback);
  91     DEFAULT.put("inflected form of", callback);
  92     DEFAULT.put("alternative form of", callback);
  93     DEFAULT.put("dated form of", callback);
  94     DEFAULT.put("apocopic form of", callback);
  95
  96     callback = new InflOrHead();
  97     DEFAULT.put("infl", callback);
  98     DEFAULT.put("head", callback);
  99
 100     callback = new AppendName();
 101     DEFAULT.put("...", callback);
 102
 103     DEFAULT.put("qualifier", new QualifierCallback());
 104     DEFAULT.put("italbrac", new italbrac());
 105     DEFAULT.put("gloss", new gloss());
 106     DEFAULT.put("not used", new not_used());
 107     DEFAULT.put("wikipedia", new wikipedia());
 108   }
 109
 110   static final NameAndArgs<EnParser> NAME_AND_ARGS = new NameAndArgs<EnParser>();
 111
 112   // ------------------------------------------------------------------
 113
 114   static final class TranslationCallback implements FunctionCallback<EnParser> {
 115     @Override
 116     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 117         final Map<String, String> namedArgs, final EnParser parser,
 118         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 119
 120       final String transliteration = namedArgs.remove("tr");
 121       final String alt = namedArgs.remove("alt");
 122       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 123       if (args.size() < 2) {
 124         EnParser.LOG.warning("{{t...}} with wrong args: title=" + parser.title);
 125         return false;
 126       }
 127       final String langCode = ListUtil.get(args, 0);
 128       if (!appendAndIndexWikiCallback.langCodeToTCount.containsKey(langCode)) {
 129         appendAndIndexWikiCallback.langCodeToTCount.put(langCode, new AtomicInteger());
 130       }
 131       appendAndIndexWikiCallback.langCodeToTCount.get(langCode).incrementAndGet();
 132       final String word = ListUtil.get(args, 1);
 133       appendAndIndexWikiCallback.dispatch(alt != null ? alt : word, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 134
 135       // Genders...
 136       if (args.size() > 2) {
 137         appendAndIndexWikiCallback.builder.append(" {");
 138         for (int i = 2; i < args.size(); ++i) {
 139           if (i > 2) {
 140             appendAndIndexWikiCallback.builder.append("|");
 141           }
 142           appendAndIndexWikiCallback.builder.append(args.get(i));
 143         }
 144         appendAndIndexWikiCallback.builder.append("}");
 145       }
 146
 147       if (transliteration != null) {
 148         appendAndIndexWikiCallback.builder.append(" (");
 149         appendAndIndexWikiCallback.dispatch(transliteration, EntryTypeName.WIKTIONARY_TRANSLITERATION);
 150         appendAndIndexWikiCallback.builder.append(")");
 151       }
 152
 153       if (alt != null) {
 154         // If alt wasn't null, we appended alt instead of the actual word
 155         // we're filing under..
 156         appendAndIndexWikiCallback.builder.append(" (");
 157         appendAndIndexWikiCallback.dispatch(word, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 158         appendAndIndexWikiCallback.builder.append(")");
 159       }
 160
 161       // Catch-all for anything else...
 162       if (!namedArgs.isEmpty()) {
 163         appendAndIndexWikiCallback.builder.append(" {");
 164         EnParser.appendNamedArgs(namedArgs, appendAndIndexWikiCallback);
 165         appendAndIndexWikiCallback.builder.append("}");
 166       }
 167
 168       return true;
 169     }
 170   }
 171
 172   // ------------------------------------------------------------------
 173
 174   static final class QualifierCallback implements FunctionCallback<EnParser> {
 175     @Override
 176     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 177         final Map<String, String> namedArgs,
 178         final EnParser parser,
 179         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 180       if (args.size() != 1 || !namedArgs.isEmpty()) {
 181         EnParser.LOG.warning("weird qualifier: ");
 182         return false;
 183       }
 184       String qualifier = args.get(0);
 185       appendAndIndexWikiCallback.builder.append("(");
 186       appendAndIndexWikiCallback.dispatch(qualifier, null);
 187       appendAndIndexWikiCallback.builder.append(")");
 188       return true;
 189     }
 190   }
 191
 192   // ------------------------------------------------------------------
 193
 194   static final class EncodingCallback implements FunctionCallback<EnParser> {
 195     @Override
 196     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 197         final Map<String, String> namedArgs,
 198         final EnParser parser,
 199         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 200       if (!namedArgs.isEmpty()) {
 201         EnParser.LOG.warning("weird encoding: " + wikiTokenizer.token());
 202       }
 203       if (args.size() == 0) {
 204         // Things like "{{Jpan}}" exist.
 205         return true;
 206       }
 207
 208       for (int i = 0; i < args.size(); ++i) {
 209         if (i > 0) {
 210           appendAndIndexWikiCallback.builder.append(", ");
 211         }
 212         final String arg = args.get(i);
 213 //        if (arg.equals(parser.title)) {
 214 //          parser.titleAppended = true;
 215 //        }
 216         appendAndIndexWikiCallback.dispatch(arg, appendAndIndexWikiCallback.entryTypeName);
 217       }
 218
 219       return true;
 220     }
 221   }
 222
 223   // ------------------------------------------------------------------
 224
 225   static final class Gender implements FunctionCallback<EnParser> {
 226     @Override
 227     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 228         final Map<String, String> namedArgs,
 229         final EnParser parser,
 230         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 231       if (!namedArgs.isEmpty()) {
 232         return false;
 233       }
 234       appendAndIndexWikiCallback.builder.append("{");
 235       appendAndIndexWikiCallback.builder.append(name);
 236       for (int i = 0; i < args.size(); ++i) {
 237         appendAndIndexWikiCallback.builder.append("|").append(args.get(i));
 238       }
 239       appendAndIndexWikiCallback.builder.append("}");
 240       return true;
 241     }
 242   }
 243
 244   // ------------------------------------------------------------------
 245
 246   static final class l_term implements FunctionCallback<EnParser> {
 247     @Override
 248     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 249         final Map<String, String> namedArgs,
 250         final EnParser parser,
 251         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 252
 253       // for {{l}}, lang is arg 0, but not for {{term}}
 254       if (name.equals("term")) {
 255         args.add(0, "");
 256       }
 257
 258       final EntryTypeName entryTypeName;
 259       switch (parser.state) {
 260       case TRANSLATION_LINE: entryTypeName = EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT; break;
 261       case ENGLISH_DEF_OF_FOREIGN: entryTypeName = EntryTypeName.WIKTIONARY_ENGLISH_DEF_WIKI_LINK; break;
 262       default: throw new IllegalStateException("Invalid enum value: " + parser.state);
 263       }
 264
 265       final String langCode = args.get(0);
 266       final IndexBuilder indexBuilder;
 267       if ("".equals(langCode)) {
 268         indexBuilder = parser.foreignIndexBuilder;
 269       } else if ("en".equals(langCode)) {
 270         indexBuilder = parser.enIndexBuilder;
 271       } else {
 272         indexBuilder = parser.foreignIndexBuilder;
 273       }
 274
 275       String displayText = ListUtil.get(args, 2, "");
 276       if (displayText.equals("")) {
 277         displayText = ListUtil.get(args, 1, null);
 278       }
 279
 280       if (displayText != null) {
 281         appendAndIndexWikiCallback.dispatch(displayText, indexBuilder, entryTypeName);
 282       } else {
 283         EnParser.LOG.warning("no display text: " + wikiTokenizer.token());
 284       }
 285
 286       final String tr = namedArgs.remove("tr");
 287       if (tr != null) {
 288         appendAndIndexWikiCallback.builder.append(" (");
 289         appendAndIndexWikiCallback.dispatch(tr, indexBuilder, EntryTypeName.WIKTIONARY_TRANSLITERATION);
 290         appendAndIndexWikiCallback.builder.append(")");
 291       }
 292
 293       final String gloss = ListUtil.get(args, 3, "");
 294       if (!gloss.equals("")) {
 295         appendAndIndexWikiCallback.builder.append(" (");
 296         appendAndIndexWikiCallback.dispatch(gloss, parser.enIndexBuilder, EntryTypeName.WIKTIONARY_ENGLISH_DEF);
 297         appendAndIndexWikiCallback.builder.append(")");
 298       }
 299
 300       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 301       if (!namedArgs.isEmpty()) {
 302         appendAndIndexWikiCallback.builder.append(" {").append(name);
 303         EnParser.appendNamedArgs(namedArgs, appendAndIndexWikiCallback);
 304         appendAndIndexWikiCallback.builder.append("}");
 305       }
 306
 307       return true;
 308     }
 309   }
 310
 311   // ------------------------------------------------------------------
 312
 313   static final class AppendArg0 implements FunctionCallback<EnParser> {
 314     @Override
 315     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 316         final Map<String, String> namedArgs,
 317         final EnParser parser,
 318         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 319       if (args.size() != 1 || !namedArgs.isEmpty()) {
 320         return false;
 321       }
 322       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 323
 324       final String tr = namedArgs.remove("tr");
 325       if (tr != null) {
 326         appendAndIndexWikiCallback.builder.append(" (");
 327         appendAndIndexWikiCallback.dispatch(tr, EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 328         appendAndIndexWikiCallback.builder.append(")");
 329         parser.wordForms.add(tr);
 330       }
 331
 332       return true;
 333     }
 334   }
 335
 336   // ------------------------------------------------------------------
 337
 338   static final class italbrac implements FunctionCallback<EnParser> {
 339     @Override
 340     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 341         final Map<String, String> namedArgs,
 342         final EnParser parser,
 343         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 344       if (args.size() != 1 || !namedArgs.isEmpty()) {
 345         return false;
 346       }
 347       appendAndIndexWikiCallback.builder.append("(");
 348       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 349       appendAndIndexWikiCallback.builder.append(")");
 350       return true;
 351     }
 352   }
 353
 354   // ------------------------------------------------------------------
 355
 356   static final class gloss implements FunctionCallback<EnParser> {
 357     @Override
 358     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 359         final Map<String, String> namedArgs,
 360         final EnParser parser,
 361         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 362       if (args.size() != 1 || !namedArgs.isEmpty()) {
 363         return false;
 364       }
 365       appendAndIndexWikiCallback.builder.append("(");
 366       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 367       appendAndIndexWikiCallback.builder.append(")");
 368       return true;
 369     }
 370   }
 371
 372   // ------------------------------------------------------------------
 373
 374   static final class Ignore implements FunctionCallback<EnParser> {
 375     @Override
 376     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 377         final Map<String, String> namedArgs,
 378         final EnParser parser,
 379         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 380       return true;
 381     }
 382   }
 383
 384   // ------------------------------------------------------------------
 385
 386   static final class not_used implements FunctionCallback<EnParser> {
 387     @Override
 388     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 389         final Map<String, String> namedArgs,
 390         final EnParser parser,
 391         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 392       appendAndIndexWikiCallback.builder.append("(not used)");
 393       return true;
 394     }
 395   }
 396
 397
 398   // ------------------------------------------------------------------
 399
 400   static final class AppendName implements FunctionCallback<EnParser> {
 401     @Override
 402     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 403         final Map<String, String> namedArgs,
 404         final EnParser parser,
 405         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 406       if (!args.isEmpty() || !namedArgs.isEmpty()) {
 407         return false;
 408       }
 409       appendAndIndexWikiCallback.builder.append(name);
 410       return true;
 411     }
 412   }
 413
 414   // --------------------------------------------------------------------
 415   // --------------------------------------------------------------------
 416
 417
 418   static final class FormOf implements FunctionCallback<EnParser> {
 419     @Override
 420     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 421         final Map<String, String> namedArgs,
 422         final EnParser parser,
 423         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 424       parser.entryIsFormOfSomething = true;
 425       String formName = name;
 426       if (name.equals("form of")) {
 427         formName = ListUtil.remove(args, 0, null);
 428       }
 429       if (formName == null) {
 430         EnParser.LOG.warning("Missing form name: " + parser.title);
 431         formName = "form of";
 432       }
 433       String baseForm = ListUtil.get(args, 1, "");
 434       if ("".equals(baseForm)) {
 435         baseForm = ListUtil.get(args, 0, null);
 436         ListUtil.remove(args, 1, "");
 437       } else {
 438         ListUtil.remove(args, 0, null);
 439       }
 440       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 441
 442       appendAndIndexWikiCallback.builder.append("{");
 443       NAME_AND_ARGS.onWikiFunction(wikiTokenizer, formName, args, namedArgs, parser, appendAndIndexWikiCallback);
 444       appendAndIndexWikiCallback.builder.append("}");
 445       if (baseForm != null && appendAndIndexWikiCallback.indexedEntry != null) {
 446         parser.foreignIndexBuilder.addEntryWithString(appendAndIndexWikiCallback.indexedEntry, baseForm, EntryTypeName.WIKTIONARY_BASE_FORM_MULTI);
 447       } else {
 448         // null baseForm happens in Danish.
 449         EnParser.LOG.warning("Null baseform: " + parser.title);
 450       }
 451       return true;
 452     }
 453   }
 454
 455   static final EnFunctionCallbacks.FormOf FORM_OF = new FormOf();
 456
 457
 458   // --------------------------------------------------------------------
 459   // --------------------------------------------------------------------
 460
 461   static final class wikipedia implements FunctionCallback<EnParser> {
 462     @Override
 463     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 464         final Map<String, String> namedArgs,
 465         final EnParser parser,
 466         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 467       namedArgs.remove("lang");
 468       if (args.size() > 1 || !namedArgs.isEmpty()) {
 469         // Unindexed!
 470         return false;
 471       } else if (args.size() == 1) {
 472         return false;
 473       } else {
 474         return true;
 475       }
 476     }
 477   }
 478
 479   static final class InflOrHead implements FunctionCallback<EnParser> {
 480     @Override
 481     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 482         final Map<String, String> namedArgs,
 483         final EnParser parser,
 484         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 485       // See: http://en.wiktionary.org/wiki/Template:infl
 486       final String langCode = ListUtil.get(args, 0);
 487       String head = namedArgs.remove("head");
 488       if (head == null) {
 489         head = namedArgs.remove("title"); // Bug
 490       }
 491       if (head == null) {
 492         head = parser.title;
 493       }
 494       parser.titleAppended = true;
 495
 496       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 497
 498       final String tr = namedArgs.remove("tr");
 499       String g = namedArgs.remove("g");
 500       if (g == null) {
 501         g = namedArgs.remove("gender");
 502       }
 503       final String g2 = namedArgs.remove("g2");
 504       final String g3 = namedArgs.remove("g3");
 505
 506       appendAndIndexWikiCallback.dispatch(head, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 507
 508       if (g != null) {
 509         appendAndIndexWikiCallback.builder.append(" {").append(g);
 510         if (g2 != null) {
 511           appendAndIndexWikiCallback.builder.append("|").append(g2);
 512         }
 513         if (g3 != null) {
 514           appendAndIndexWikiCallback.builder.append("|").append(g3);
 515         }
 516         appendAndIndexWikiCallback.builder.append("}");
 517       }
 518
 519       if (tr != null) {
 520         appendAndIndexWikiCallback.builder.append(" (");
 521         appendAndIndexWikiCallback.dispatch(tr, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 522         appendAndIndexWikiCallback.builder.append(")");
 523         parser.wordForms.add(tr);
 524       }
 525
 526       final String pos = ListUtil.get(args, 1);
 527       if (pos != null) {
 528         appendAndIndexWikiCallback.builder.append(" (").append(pos).append(")");
 529       }
 530       for (int i = 2; i < args.size(); i += 2) {
 531         final String inflName = ListUtil.get(args, i);
 532         final String inflValue = ListUtil.get(args, i + 1);
 533         appendAndIndexWikiCallback.builder.append(", ");
 534         appendAndIndexWikiCallback.dispatch(inflName, null, null);
 535         if (inflValue != null && inflValue.length() > 0) {
 536           appendAndIndexWikiCallback.builder.append(": ");
 537           appendAndIndexWikiCallback.dispatch(inflValue, null, null);
 538           parser.wordForms.add(inflValue);
 539         }
 540       }
 541       for (final String key : namedArgs.keySet()) {
 542         final String value = WikiTokenizer.toPlainText(namedArgs.get(key));
 543         appendAndIndexWikiCallback.builder.append(" ");
 544         appendAndIndexWikiCallback.dispatch(key, null, null);
 545         appendAndIndexWikiCallback.builder.append("=");
 546         appendAndIndexWikiCallback.dispatch(value, null, null);
 547         parser.wordForms.add(value);
 548       }
 549       return true;
 550     }
 551   }
 552
 553
 554   static {
 555     DEFAULT.put("it-noun", new it_noun());
 556   }
 557   static final class it_noun implements FunctionCallback<EnParser> {
 558     @Override
 559     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 560         final Map<String, String> namedArgs,
 561         final EnParser parser,
 562         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 563       parser.titleAppended = true;
 564       final String base = ListUtil.get(args, 0);
 565       final String gender = ListUtil.get(args, 1);
 566       final String singular = base + ListUtil.get(args, 2, null);
 567       final String plural = base + ListUtil.get(args, 3, null);
 568       appendAndIndexWikiCallback.builder.append(" ");
 569       appendAndIndexWikiCallback.dispatch(singular, null, null);
 570       appendAndIndexWikiCallback.builder.append(" {").append(gender).append("}, ");
 571       appendAndIndexWikiCallback.dispatch(plural, null, null);
 572       appendAndIndexWikiCallback.builder.append(" {pl}");
 573       parser.wordForms.add(singular);
 574       parser.wordForms.add(plural);
 575       if (!namedArgs.isEmpty() || args.size() > 4) {
 576         EnParser.LOG.warning("Invalid it-noun: " + wikiTokenizer.token());
 577       }
 578       return true;
 579     }
 580   }
 581
 582   static {
 583     DEFAULT.put("it-proper noun", new it_proper_noun());
 584   }
 585   static final class it_proper_noun implements FunctionCallback<EnParser> {
 586     @Override
 587     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 588         final Map<String, String> namedArgs,
 589         final EnParser parser,
 590         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 591       return false;
 592     }
 593   }
 594
 595   }