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 com.hughes.android.dictionary.engine.EntryTypeName;
  18 import com.hughes.android.dictionary.engine.IndexBuilder;
  19 import com.hughes.android.dictionary.parser.WikiTokenizer;
  20 import com.hughes.android.dictionary.parser.wiktionary.AbstractWiktionaryParser.AppendAndIndexWikiCallback;
  21 import com.hughes.android.dictionary.parser.wiktionary.AbstractWiktionaryParser.NameAndArgs;
  22 import com.hughes.util.ListUtil;
  23 import com.hughes.util.MapUtil;
  24
  25 import java.util.Arrays;
  26 import java.util.LinkedHashMap;
  27 import java.util.LinkedHashSet;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Set;
  31 import java.util.concurrent.atomic.AtomicInteger;
  32
  33 class EnFunctionCallbacks {
  34
  35   static final Map<String,FunctionCallback<EnParser>> DEFAULT = new LinkedHashMap<String, FunctionCallback<EnParser>>();
  36
  37   static <T extends AbstractWiktionaryParser> void addGenericCallbacks(Map<String, FunctionCallback<T>> callbacks) {
  38       FunctionCallback<T> callback = new Gender<T>();
  39       callbacks.put("m", callback);
  40       callbacks.put("f", callback);
  41       callbacks.put("n", callback);
  42       callbacks.put("p", callback);
  43       callbacks.put("g", callback);
  44
  45       callback = new EncodingCallback<T>();
  46       Set<String> encodings = new LinkedHashSet<String>(Arrays.asList(
  47           "IPA", "IPAchar",  // Not really encodings, but it works.
  48           "zh-ts", "zh-tsp",
  49           "sd-Arab", "ku-Arab", "Arab", "unicode", "Laoo", "ur-Arab", "Thai",
  50           "fa-Arab", "Khmr", "Cyrl", "ug-Arab", "ko-inline",
  51           "Jpan", "Kore", "Hebr", "rfscript", "Beng", "Mong", "Knda", "Cyrs",
  52           "yue-tsj", "Mlym", "Tfng", "Grek", "yue-yue-j"));
  53       for (final String encoding : encodings) {
  54           callbacks.put(encoding, callback);
  55       }
  56
  57       callback = new Ignore<T>();
  58       callbacks.put("trreq", callback);
  59       callbacks.put("t-image", callback);
  60       callbacks.put("defn", callback);
  61       callbacks.put("rfdef", callback);
  62       callbacks.put("rfdate", callback);
  63       callbacks.put("rfex", callback);
  64       callbacks.put("rfquote", callback);
  65       callbacks.put("attention", callback);
  66       callbacks.put("zh-attention", callback);
  67
  68       callback = new AppendName<T>();
  69       callbacks.put("...", callback);
  70
  71       callbacks.put("qualifier", new QualifierCallback<T>());
  72       callbacks.put("italbrac", new italbrac<T>());
  73       callbacks.put("gloss", new gloss<T>());
  74       callbacks.put("not used", new not_used<T>());
  75       callbacks.put("wikipedia", new wikipedia<T>());
  76
  77       final it_conj<T> it_conj_cb = new it_conj<T>();
  78       callbacks.put("it-conj", it_conj_cb);
  79       callbacks.put("it-conj-are", new it_conj_are<T>(it_conj_cb));
  80       callbacks.put("it-conj-arsi", new it_conj_are<T>(it_conj_cb));
  81       callbacks.put("it-conj-care", new it_conj_are<T>(it_conj_cb));
  82       callbacks.put("it-conj-carsi", new it_conj_are<T>(it_conj_cb));
  83       callbacks.put("it-conj-ciare", new it_conj_are<T>(it_conj_cb));
  84       callbacks.put("it-conj-ciarsi", new it_conj_are<T>(it_conj_cb));
  85       callbacks.put("it-conj-iare", new it_conj_are<T>(it_conj_cb));
  86       callbacks.put("it-conj-iarsi", new it_conj_are<T>(it_conj_cb));
  87       callbacks.put("it-conj-iare-b", new it_conj_are<T>(it_conj_cb));
  88       callbacks.put("it-conj-iarsi-b", new it_conj_are<T>(it_conj_cb));
  89       callbacks.put("it-conj-ire", new it_conj_ire<T>(it_conj_cb));
  90       callbacks.put("it-conj-irsi", new it_conj_ire<T>(it_conj_cb));
  91       callbacks.put("it-conj-ire-b", new it_conj_ire<T>(it_conj_cb));
  92       callbacks.put("it-conj-irsi-b", new it_conj_ire<T>(it_conj_cb));
  93       callbacks.put("it-conj-cire", new it_conj_ire<T>(it_conj_cb));
  94       callbacks.put("it-conj-cirsi", new it_conj_ire<T>(it_conj_cb));
  95       callbacks.put("it-conj-ire", new it_conj_ire<T>(it_conj_cb));
  96       callbacks.put("it-conj-ere", new it_conj_ere<T>(it_conj_cb));
  97       callbacks.put("it-conj-ersi", new it_conj_ere<T>(it_conj_cb));
  98       callbacks.put("it-conj-urre", new it_conj_urre<T>(it_conj_cb));
  99       callbacks.put("it-conj-ursi", new it_conj_urre<T>(it_conj_cb));
 100       callbacks.put("it-conj-fare", new it_conj_fare<T>(it_conj_cb));
 101
 102
 103       //"{{it-conj-fare|putre|avere}}\n" +
 104
 105
 106   }
 107
 108   static {
 109     addGenericCallbacks(DEFAULT);
 110
 111     FunctionCallback<EnParser> callback = new TranslationCallback<EnParser>();
 112     DEFAULT.put("t", callback);
 113     DEFAULT.put("t+", callback);
 114     DEFAULT.put("t-", callback);
 115     DEFAULT.put("tø", callback);
 116     DEFAULT.put("apdx-t", callback);
 117
 118     callback = new l_term();
 119     DEFAULT.put("l", callback);
 120     DEFAULT.put("term", callback);
 121
 122     //callback = new AppendArg0();
 123
 124     callback = new FormOf();
 125     DEFAULT.put("form of", callback);
 126     DEFAULT.put("conjugation of", callback);
 127     DEFAULT.put("participle of", callback);
 128     DEFAULT.put("present participle of", callback);
 129     DEFAULT.put("past participle of", callback);
 130     DEFAULT.put("feminine past participle of", callback);
 131     DEFAULT.put("gerund of", callback);
 132     DEFAULT.put("feminine of", callback);
 133     DEFAULT.put("plural of", callback);
 134     DEFAULT.put("feminine plural of", callback);
 135     DEFAULT.put("inflected form of", callback);
 136     DEFAULT.put("alternative form of", callback);
 137     DEFAULT.put("dated form of", callback);
 138     DEFAULT.put("apocopic form of", callback);
 139
 140     callback = new InflOrHead();
 141     DEFAULT.put("infl", callback);
 142     DEFAULT.put("head", callback);
 143   }
 144
 145   static final NameAndArgs<EnParser> NAME_AND_ARGS = new NameAndArgs<EnParser>();
 146
 147   // ------------------------------------------------------------------
 148
 149   static final class TranslationCallback<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 150     @Override
 151     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 152         final Map<String, String> namedArgs, final T parser,
 153         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 154
 155       final String transliteration = namedArgs.remove("tr");
 156       final String alt = namedArgs.remove("alt");
 157       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 158       if (args.size() < 2) {
 159         if (!name.equals("ttbc")) {
 160           EnParser.LOG.warning("{{t...}} with wrong args: title=" + parser.title + ", " + wikiTokenizer.token());
 161         }
 162         return false;
 163       }
 164       final String langCode = ListUtil.get(args, 0);
 165       if (!appendAndIndexWikiCallback.langCodeToTCount.containsKey(langCode)) {
 166         appendAndIndexWikiCallback.langCodeToTCount.put(langCode, new AtomicInteger());
 167       }
 168       appendAndIndexWikiCallback.langCodeToTCount.get(langCode).incrementAndGet();
 169       final String word = ListUtil.get(args, 1);
 170       appendAndIndexWikiCallback.dispatch(alt != null ? alt : word, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 171
 172       // Genders...
 173       if (args.size() > 2) {
 174         appendAndIndexWikiCallback.builder.append(" {");
 175         for (int i = 2; i < args.size(); ++i) {
 176           if (i > 2) {
 177             appendAndIndexWikiCallback.builder.append("|");
 178           }
 179           appendAndIndexWikiCallback.builder.append(args.get(i));
 180         }
 181         appendAndIndexWikiCallback.builder.append("}");
 182       }
 183
 184       if (transliteration != null) {
 185         appendAndIndexWikiCallback.builder.append(" (");
 186         appendAndIndexWikiCallback.dispatch(transliteration, EntryTypeName.WIKTIONARY_TRANSLITERATION);
 187         appendAndIndexWikiCallback.builder.append(")");
 188       }
 189
 190       if (alt != null) {
 191         // If alt wasn't null, we appended alt instead of the actual word
 192         // we're filing under..
 193         appendAndIndexWikiCallback.builder.append(" (");
 194         appendAndIndexWikiCallback.dispatch(word, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 195         appendAndIndexWikiCallback.builder.append(")");
 196       }
 197
 198       // Catch-all for anything else...
 199       if (!namedArgs.isEmpty()) {
 200         appendAndIndexWikiCallback.builder.append(" {");
 201         EnParser.appendNamedArgs(namedArgs, appendAndIndexWikiCallback);
 202         appendAndIndexWikiCallback.builder.append("}");
 203       }
 204
 205       return true;
 206     }
 207   }
 208
 209   // ------------------------------------------------------------------
 210
 211   static final class QualifierCallback<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 212     @Override
 213     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 214         final Map<String, String> namedArgs,
 215         final T parser,
 216         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 217       if (args.size() != 1 || !namedArgs.isEmpty()) {
 218         EnParser.LOG.warning("weird qualifier: ");
 219         return false;
 220       }
 221       String qualifier = args.get(0);
 222       appendAndIndexWikiCallback.builder.append("(");
 223       appendAndIndexWikiCallback.dispatch(qualifier, null);
 224       appendAndIndexWikiCallback.builder.append(")");
 225       return true;
 226     }
 227   }
 228
 229   // ------------------------------------------------------------------
 230
 231   static final class EncodingCallback<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 232     @Override
 233     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 234         final Map<String, String> namedArgs,
 235         final T parser,
 236         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 237       if (!namedArgs.isEmpty()) {
 238         EnParser.LOG.warning("weird encoding: " + wikiTokenizer.token());
 239         return false;
 240       }
 241       if (args.size() == 0) {
 242         // Things like "{{Jpan}}" exist.
 243         return true;
 244       }
 245
 246       if (name.equals("IPA")) {
 247           appendAndIndexWikiCallback.dispatch("IPA: ", null);
 248       }
 249
 250       for (int i = 0; i < args.size(); ++i) {
 251         if (i > 0) {
 252           appendAndIndexWikiCallback.builder.append(", ");
 253         }
 254         final String arg = args.get(i);
 255 //        if (arg.equals(parser.title)) {
 256 //          parser.titleAppended = true;
 257 //        }
 258         appendAndIndexWikiCallback.dispatch(arg, appendAndIndexWikiCallback.entryTypeName);
 259       }
 260
 261       return true;
 262     }
 263   }
 264
 265   // ------------------------------------------------------------------
 266
 267   static final class Gender<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 268     @Override
 269     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 270         final Map<String, String> namedArgs,
 271         final T parser,
 272         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 273       if (!namedArgs.isEmpty()) {
 274         return false;
 275       }
 276       appendAndIndexWikiCallback.builder.append("{");
 277       appendAndIndexWikiCallback.builder.append(name);
 278       for (int i = 0; i < args.size(); ++i) {
 279         appendAndIndexWikiCallback.builder.append("|").append(args.get(i));
 280       }
 281       appendAndIndexWikiCallback.builder.append("}");
 282       return true;
 283     }
 284   }
 285
 286   // ------------------------------------------------------------------
 287
 288   static final class l_term implements FunctionCallback<EnParser> {
 289     @Override
 290     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 291         final Map<String, String> namedArgs,
 292         final EnParser parser,
 293         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 294
 295       // for {{l}}, lang is arg 0, but not for {{term}}
 296       if (name.equals("term")) {
 297         args.add(0, "");
 298       }
 299
 300       final EntryTypeName entryTypeName;
 301       switch (parser.state) {
 302       case TRANSLATION_LINE: entryTypeName = EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT; break;
 303       case ENGLISH_DEF_OF_FOREIGN: entryTypeName = EntryTypeName.WIKTIONARY_ENGLISH_DEF_WIKI_LINK; break;
 304       default: throw new IllegalStateException("Invalid enum value: " + parser.state);
 305       }
 306
 307       final String langCode = args.get(0);
 308       final IndexBuilder indexBuilder;
 309       if ("".equals(langCode)) {
 310         indexBuilder = parser.foreignIndexBuilder;
 311       } else if ("en".equals(langCode)) {
 312         indexBuilder = parser.enIndexBuilder;
 313       } else {
 314         indexBuilder = parser.foreignIndexBuilder;
 315       }
 316
 317       String displayText = ListUtil.get(args, 2, "");
 318       if (displayText.equals("")) {
 319         displayText = ListUtil.get(args, 1, null);
 320       }
 321
 322       if (displayText != null) {
 323         appendAndIndexWikiCallback.dispatch(displayText, indexBuilder, entryTypeName);
 324       } else {
 325         EnParser.LOG.warning("no display text: " + wikiTokenizer.token());
 326       }
 327
 328       final String tr = namedArgs.remove("tr");
 329       if (tr != null) {
 330         appendAndIndexWikiCallback.builder.append(" (");
 331         appendAndIndexWikiCallback.dispatch(tr, indexBuilder, EntryTypeName.WIKTIONARY_TRANSLITERATION);
 332         appendAndIndexWikiCallback.builder.append(")");
 333       }
 334
 335       final String gloss = ListUtil.get(args, 3, "");
 336       if (!gloss.equals("")) {
 337         appendAndIndexWikiCallback.builder.append(" (");
 338         appendAndIndexWikiCallback.dispatch(gloss, parser.enIndexBuilder, EntryTypeName.WIKTIONARY_ENGLISH_DEF);
 339         appendAndIndexWikiCallback.builder.append(")");
 340       }
 341
 342       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 343       if (!namedArgs.isEmpty()) {
 344         appendAndIndexWikiCallback.builder.append(" {").append(name);
 345         EnParser.appendNamedArgs(namedArgs, appendAndIndexWikiCallback);
 346         appendAndIndexWikiCallback.builder.append("}");
 347       }
 348
 349       return true;
 350     }
 351   }
 352
 353   // ------------------------------------------------------------------
 354
 355   static final class AppendArg0<T extends AbstractWiktionaryParser> implements FunctionCallback<EnParser> {
 356     @Override
 357     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 358         final Map<String, String> namedArgs,
 359         final EnParser parser,
 360         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 361       if (args.size() != 1 || !namedArgs.isEmpty()) {
 362         return false;
 363       }
 364       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 365
 366       final String tr = namedArgs.remove("tr");
 367       if (tr != null) {
 368         appendAndIndexWikiCallback.builder.append(" (");
 369         appendAndIndexWikiCallback.dispatch(tr, EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 370         appendAndIndexWikiCallback.builder.append(")");
 371         parser.wordForms.add(tr);
 372       }
 373
 374       return true;
 375     }
 376   }
 377
 378   // ------------------------------------------------------------------
 379
 380   static final class italbrac<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 381     @Override
 382     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 383         final Map<String, String> namedArgs,
 384         final T parser,
 385         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 386       if (args.size() != 1 || !namedArgs.isEmpty()) {
 387         return false;
 388       }
 389       appendAndIndexWikiCallback.builder.append("(");
 390       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 391       appendAndIndexWikiCallback.builder.append(")");
 392       return true;
 393     }
 394   }
 395
 396   // ------------------------------------------------------------------
 397
 398   static final class gloss<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 399     @Override
 400     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 401         final Map<String, String> namedArgs,
 402         final T parser,
 403         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 404       if (args.size() != 1 || !namedArgs.isEmpty()) {
 405         return false;
 406       }
 407       appendAndIndexWikiCallback.builder.append("(");
 408       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 409       appendAndIndexWikiCallback.builder.append(")");
 410       return true;
 411     }
 412   }
 413
 414   // ------------------------------------------------------------------
 415
 416   static final class Ignore<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 417     @Override
 418     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 419         final Map<String, String> namedArgs,
 420         final T parser,
 421         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 422       return true;
 423     }
 424   }
 425
 426   // ------------------------------------------------------------------
 427
 428   static final class not_used<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 429     @Override
 430     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 431         final Map<String, String> namedArgs,
 432         final T parser,
 433         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 434       appendAndIndexWikiCallback.builder.append("(not used)");
 435       return true;
 436     }
 437   }
 438
 439
 440   // ------------------------------------------------------------------
 441
 442   static final class AppendName<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 443     @Override
 444     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 445         final Map<String, String> namedArgs,
 446         final T parser,
 447         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 448       if (!args.isEmpty() || !namedArgs.isEmpty()) {
 449         return false;
 450       }
 451       appendAndIndexWikiCallback.builder.append(name);
 452       return true;
 453     }
 454   }
 455
 456   // --------------------------------------------------------------------
 457   // --------------------------------------------------------------------
 458
 459
 460   static final class FormOf implements FunctionCallback<EnParser> {
 461     @Override
 462     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 463         final Map<String, String> namedArgs,
 464         final EnParser parser,
 465         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 466       parser.entryIsFormOfSomething = true;
 467       String formName = name;
 468       if (name.equals("form of")) {
 469         formName = ListUtil.remove(args, 0, null);
 470       }
 471       if (formName == null) {
 472         EnParser.LOG.warning("Missing form name: " + parser.title);
 473         formName = "form of";
 474       }
 475       String baseForm = ListUtil.get(args, 1, "");
 476       if ("".equals(baseForm)) {
 477         baseForm = ListUtil.get(args, 0, null);
 478         ListUtil.remove(args, 1, "");
 479       } else {
 480         ListUtil.remove(args, 0, null);
 481       }
 482       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 483
 484       appendAndIndexWikiCallback.builder.append("{");
 485       NAME_AND_ARGS.onWikiFunction(wikiTokenizer, formName, args, namedArgs, parser, appendAndIndexWikiCallback);
 486       appendAndIndexWikiCallback.builder.append("}");
 487       if (baseForm != null && appendAndIndexWikiCallback.indexedEntry != null) {
 488         parser.foreignIndexBuilder.addEntryWithString(appendAndIndexWikiCallback.indexedEntry, baseForm, EntryTypeName.WIKTIONARY_BASE_FORM_MULTI);
 489       } else {
 490         // null baseForm happens in Danish.
 491         EnParser.LOG.warning("Null baseform: " + parser.title);
 492       }
 493       return true;
 494     }
 495   }
 496
 497   static final EnFunctionCallbacks.FormOf FORM_OF = new FormOf();
 498
 499
 500   // --------------------------------------------------------------------
 501   // --------------------------------------------------------------------
 502
 503   static final class wikipedia<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 504     @Override
 505     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 506         final Map<String, String> namedArgs,
 507         final T parser,
 508         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 509       namedArgs.remove("lang");
 510       if (args.size() > 1 || !namedArgs.isEmpty()) {
 511         // Unindexed!
 512         return false;
 513       } else if (args.size() == 1) {
 514         return false;
 515       } else {
 516         return true;
 517       }
 518     }
 519   }
 520
 521   static final class InflOrHead implements FunctionCallback<EnParser> {
 522     @Override
 523     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 524         final Map<String, String> namedArgs,
 525         final EnParser parser,
 526         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 527       // See: http://en.wiktionary.org/wiki/Template:infl
 528       // TODO: Actually these functions should start a new WordPOS:
 529       // See: http://en.wiktionary.org/wiki/quattro
 530       final String langCode = ListUtil.get(args, 0);
 531       String head = namedArgs.remove("head");
 532       if (head == null) {
 533         head = namedArgs.remove("title"); // Bug
 534       }
 535       if (head == null) {
 536         head = parser.title;
 537       }
 538
 539       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 540
 541       final String tr = namedArgs.remove("tr");
 542       String g = namedArgs.remove("g");
 543       if (g == null) {
 544         g = namedArgs.remove("gender");
 545       }
 546       final String g2 = namedArgs.remove("g2");
 547       final String g3 = namedArgs.remove("g3");
 548
 549       // We might have already taken care of this in a generic way...
 550       if (!parser.titleAppended) {
 551         appendAndIndexWikiCallback.dispatch(head, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 552         parser.titleAppended = true;
 553       }
 554
 555       if (g != null) {
 556         appendAndIndexWikiCallback.builder.append(" {").append(g);
 557         if (g2 != null) {
 558           appendAndIndexWikiCallback.builder.append("|").append(g2);
 559         }
 560         if (g3 != null) {
 561           appendAndIndexWikiCallback.builder.append("|").append(g3);
 562         }
 563         appendAndIndexWikiCallback.builder.append("}");
 564       }
 565
 566       if (tr != null) {
 567         appendAndIndexWikiCallback.builder.append(" (");
 568         appendAndIndexWikiCallback.dispatch(tr, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 569         appendAndIndexWikiCallback.builder.append(")");
 570         parser.wordForms.add(tr);
 571       }
 572
 573       final String pos = ListUtil.get(args, 1);
 574       if (pos != null) {
 575         appendAndIndexWikiCallback.builder.append(" (").append(pos).append(")");
 576       }
 577       for (int i = 2; i < args.size(); i += 2) {
 578         final String inflName = ListUtil.get(args, i);
 579         final String inflValue = ListUtil.get(args, i + 1);
 580         appendAndIndexWikiCallback.builder.append(", ");
 581         appendAndIndexWikiCallback.dispatch(inflName, null, null);
 582         if (inflValue != null && inflValue.length() > 0) {
 583           appendAndIndexWikiCallback.builder.append(": ");
 584           appendAndIndexWikiCallback.dispatch(inflValue, null, null);
 585           parser.wordForms.add(inflValue);
 586         }
 587       }
 588       for (final String key : namedArgs.keySet()) {
 589         final String value = WikiTokenizer.toPlainText(namedArgs.get(key));
 590         appendAndIndexWikiCallback.builder.append(" ");
 591         appendAndIndexWikiCallback.dispatch(key, null, null);
 592         appendAndIndexWikiCallback.builder.append("=");
 593         appendAndIndexWikiCallback.dispatch(value, null, null);
 594         parser.wordForms.add(value);
 595       }
 596       return true;
 597     }
 598   }
 599
 600
 601   static {
 602     DEFAULT.put("it-noun", new it_noun());
 603   }
 604   static final class it_noun implements FunctionCallback<EnParser> {
 605     @Override
 606     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 607         final Map<String, String> namedArgs,
 608         final EnParser parser,
 609         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 610       parser.titleAppended = true;
 611       final String base = ListUtil.get(args, 0);
 612       final String gender = ListUtil.get(args, 1);
 613       final String singular = base + ListUtil.get(args, 2, null);
 614       final String plural = base + ListUtil.get(args, 3, null);
 615       appendAndIndexWikiCallback.builder.append(" ");
 616       appendAndIndexWikiCallback.dispatch(singular, null, null);
 617       appendAndIndexWikiCallback.builder.append(" {").append(gender).append("}, ");
 618       appendAndIndexWikiCallback.dispatch(plural, null, null);
 619       appendAndIndexWikiCallback.builder.append(" {pl}");
 620       parser.wordForms.add(singular);
 621       parser.wordForms.add(plural);
 622       if (!namedArgs.isEmpty() || args.size() > 4) {
 623         EnParser.LOG.warning("Invalid it-noun: " + wikiTokenizer.token());
 624       }
 625       return true;
 626     }
 627   }
 628
 629   static {
 630     DEFAULT.put("it-proper noun", new it_proper_noun<EnParser>());
 631   }
 632   static final class it_proper_noun<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 633     @Override
 634     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 635         final Map<String, String> namedArgs,
 636         final T parser,
 637         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 638       return false;
 639     }
 640   }
 641
 642   // -----------------------------------------------------------------------
 643   // Italian stuff
 644   // -----------------------------------------------------------------------
 645
 646   static void passThroughOrFillIn(final Map<String,String> namedArgs, final String key, final String fillIn, final boolean quoteToEmpty) {
 647       final String value = namedArgs.get(key);
 648       if (quoteToEmpty && "''".equals(value)) {
 649           namedArgs.put(key, "");
 650           return;
 651       }
 652       if (value == null || value.equals("")) {
 653           namedArgs.put(key, fillIn);
 654       }
 655   }
 656
 657   static final List<String> it_number_s_p = Arrays.asList("s", "p");
 658   static final List<String> it_person_1_2_3 = Arrays.asList("1", "2", "3");
 659   static final List<String> it_reflexive_pronouns = Arrays.asList("mi ", "ti ", "si ", "ci ", "vi ", "si ");
 660   static final List<String> it_empty = Arrays.asList("", "", "", "", "", "");
 661   static void it_conj_passMood(final Map<String,String> namedArgs, final String moodName, final boolean quoteToEmpty, final String root, final List<String> suffixes) {
 662       assert suffixes.size() == 6;
 663       int i = 0;
 664       for (final String number : it_number_s_p) {
 665           for (final String person : it_person_1_2_3) {
 666               passThroughOrFillIn(namedArgs, String.format("%s%s%s", moodName, person, number), root + suffixes.get(i), quoteToEmpty);
 667               ++i;
 668           }
 669       }
 670   }
 671
 672   private static <T extends AbstractWiktionaryParser> void outputKeyVariations(AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback,
 673         final StringBuilder builder, final String keyBase, Map<String, String> namedArgs) {
 674     for (int suffix = 0; suffix <= 4; ++suffix) {
 675         final String key = suffix == 0 ? keyBase : keyBase + suffix;
 676         final String val = namedArgs.remove(key);
 677         if (val != null) {
 678             if (suffix > 0) {
 679                 builder.append(", ");
 680             }
 681             appendAndIndexWikiCallback.dispatch(val, null);
 682         }
 683     }
 684   }
 685
 686 static final class it_conj_are<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 687     final it_conj<T> dest;
 688     it_conj_are(it_conj<T> dest) {
 689       this.dest = dest;
 690     }
 691     @Override
 692       public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 693           final Map<String, String> namedArgs,
 694           final T parser,
 695           final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 696         final String h = name.equals("it-conj-care") || name.equals("it-conj-carsi") ? "h" : "";
 697         final String i = name.equals("it-conj-ciare") || name.equals("it-conj-ciarsi") ? "i" : "";
 698         final String i2 = name.equals("it-conj-iare") || name.equals("it-conj-iarsi") ? "" : "i";
 699         final boolean si = name.equals("it-conj-arsi") || name.equals("it-conj-iarsi") || name.equals("it-conj-iarsi-b") || name.equals("it-conj-carsi") || name.equals("it-conj-ciarsi");
 700         final String root = args.get(0);
 701         passThroughOrFillIn(namedArgs, "inf", root + i + (si ? "arsi" : "are"), false);
 702         namedArgs.put("aux", ListUtil.get(args, 1, ""));
 703         passThroughOrFillIn(namedArgs, "ger", root + i + "ando" + (si ? "si" : ""), true);
 704         passThroughOrFillIn(namedArgs, "presp", root + i + "ante"+ (si ? "si" : ""), true);
 705         passThroughOrFillIn(namedArgs, "pastp", root + i + "ato", true);
 706         if (si) {
 707             passThroughOrFillIn(namedArgs, "pastp2", root + i + "atosi", true);
 708         }
 709         final String i2b = (name.equals("it-conj-iare-b") || name.equals("it-conj-iarsi-b")) ? "" : i2;
 710
 711         it_conj_passMood(namedArgs, "pres", false, root, Arrays.asList(i + "o", h + i2, i + "a", h + i2 + "amo", i + "ate", i + "ano"));
 712         it_conj_passMood(namedArgs, "imperf", false, root, Arrays.asList(i + "avo", i + "avi", i + "ava", i + "avamo", i + "avate", i + "avano"));
 713         it_conj_passMood(namedArgs, "prem", false, root, Arrays.asList(i + "ai", i + "asti", i + "ò", i + "ammo", i + "aste", i + "arono"));
 714         it_conj_passMood(namedArgs, "fut", true, root, Arrays.asList(h + "erò", h + "erai", h + "erà", h + "eremo", h + "erete", h + "eranno"));
 715         it_conj_passMood(namedArgs, "cond", true, root, Arrays.asList(h + "erei", h + "eresti", h + "erebbe", h + "eremmo", h + "ereste", h + "erebbero"));
 716
 717         passThroughOrFillIn(namedArgs, "sub123s", root + h + i2, false);
 718         passThroughOrFillIn(namedArgs, "sub1p", root + h + i2b + "amo", false);
 719         passThroughOrFillIn(namedArgs, "sub2p", root + h + i2b + "ate", false);
 720         passThroughOrFillIn(namedArgs, "sub3p", root + h + i2 + "no", false);
 721
 722         passThroughOrFillIn(namedArgs, "impsub12s", root + i + "assi", false);
 723         passThroughOrFillIn(namedArgs, "impsub3s", root + i + "asse", false);
 724         passThroughOrFillIn(namedArgs, "impsub1p", root + i + "assimo", false);
 725         passThroughOrFillIn(namedArgs, "impsub2p", root + i + "aste", false);
 726         passThroughOrFillIn(namedArgs, "impsub3p", root + i + "assero", false);
 727
 728         passThroughOrFillIn(namedArgs, "imp2s", root + i + "a" + (si ? "ti" : ""), true);
 729         passThroughOrFillIn(namedArgs, "imp3s", (si ? "si " : "") + root + h + i2, true);
 730         passThroughOrFillIn(namedArgs, "imp1p", root + h + i2b + "amo" + (si ? "ci" : ""), true);
 731         passThroughOrFillIn(namedArgs, "imp2p", root + i + "ate" + (si ? "vi" : ""), true);
 732         passThroughOrFillIn(namedArgs, "imp3p", (si ? "si " : "") + root + h + i2 + "no", true);
 733
 734         return dest.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, appendAndIndexWikiCallback);
 735       }
 736     }
 737
 738   static final class it_conj_ire<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 739     final it_conj<T> dest;
 740     it_conj_ire(it_conj<T> dest) {
 741       this.dest = dest;
 742     }
 743     @Override
 744       public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 745           final Map<String, String> namedArgs,
 746           final T parser,
 747           final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 748         final String root = args.get(0);
 749         final String i = name.equals("it-conj-cire") || name.equals("it-conj-cirsi") ? "i" : "";
 750         final boolean si = name.equals("it-conj-irsi") || name.equals("it-conj-irsi-b") || name.equals("it-conj-cirsi");
 751
 752         passThroughOrFillIn(namedArgs, "inf", root + (si ? "irsi" : "ire"), false);
 753         namedArgs.put("aux", ListUtil.get(args, 1, ""));
 754         passThroughOrFillIn(namedArgs, "ger", root + "endo" + (si ? "si" : ""), true);
 755         passThroughOrFillIn(namedArgs, "presp", root + "ente" + (si ? "si" : ""), true);
 756         passThroughOrFillIn(namedArgs, "pastp", root + "ito", true);
 757         if (si) {
 758             passThroughOrFillIn(namedArgs, "pastp2", root + "itosi", true);
 759         }
 760         if (!name.endsWith("-b")) {
 761             it_conj_passMood(namedArgs, "pres", false, root, Arrays.asList(i + "o", "i", "e", "iamo", "ite", i + "ono"));
 762         } else {
 763             it_conj_passMood(namedArgs, "pres", false, root, Arrays.asList("isco", "isci", "isce", "iamo", "ite", "iscono"));
 764         }
 765         it_conj_passMood(namedArgs, "imperf", false, root, Arrays.asList("ivo", "ivi", "iva", "ivamo", "ivate", "ivano"));
 766         it_conj_passMood(namedArgs, "prem", false, root, Arrays.asList("ii", "isti", "ì", "immo", "iste", "irono"));
 767         // Regular past historic synonyms:
 768         passThroughOrFillIn(namedArgs, "prem3s2", root + "é", true);
 769         passThroughOrFillIn(namedArgs, "prem3p2", root + "erono", true);
 770         it_conj_passMood(namedArgs, "fut", true, root, Arrays.asList("irò", "irai", "irà", "iremo", "irete", "iranno"));
 771         it_conj_passMood(namedArgs, "cond", true, root, Arrays.asList("irei", "iresti", "irebbe", "iremmo", "ireste", "irebbero"));
 772
 773         if (!name.endsWith("-b")) {
 774             passThroughOrFillIn(namedArgs, "sub123s", root + i + "a", false);
 775             passThroughOrFillIn(namedArgs, "sub3p", root + i + "ano", false);
 776         } else {
 777             passThroughOrFillIn(namedArgs, "sub123s", root + "isca", false);
 778             passThroughOrFillIn(namedArgs, "sub3p", root + "iscano", false);
 779         }
 780         passThroughOrFillIn(namedArgs, "sub1p", root + "iamo", false);
 781         passThroughOrFillIn(namedArgs, "sub2p", root + "iate", false);
 782
 783         passThroughOrFillIn(namedArgs, "impsub12s", root + "issi", false);
 784         passThroughOrFillIn(namedArgs, "impsub3s", root + "isse", false);
 785         passThroughOrFillIn(namedArgs, "impsub1p", root + "issimo", false);
 786         passThroughOrFillIn(namedArgs, "impsub2p", root + "iste", false);
 787         passThroughOrFillIn(namedArgs, "impsub3p", root + "issero", false);
 788
 789         if (!name.endsWith("-b")) {
 790             passThroughOrFillIn(namedArgs, "imp2s", root + "i" + (si ? "ti" : ""), true);
 791             passThroughOrFillIn(namedArgs, "imp3s", (si ? "si " : "") + root + i + "a", true);
 792             passThroughOrFillIn(namedArgs, "imp3p", (si ? "si " : "") + root + i + "ano", true);
 793         } else {
 794             passThroughOrFillIn(namedArgs, "imp2s", root + "isci" + (si ? "ti" : ""), true);
 795             passThroughOrFillIn(namedArgs, "imp3s", (si ? "si " : "") + root + "isca", true);
 796             passThroughOrFillIn(namedArgs, "imp3p", (si ? "si " : "") + root + "iscano", true);
 797         }
 798         passThroughOrFillIn(namedArgs, "imp1p", root + "iamo" + (si ? "ci" : ""), true);
 799         passThroughOrFillIn(namedArgs, "imp2p", root + "ite" + (si ? "vi" : ""), true);
 800
 801         return dest.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, appendAndIndexWikiCallback);
 802       }
 803     }
 804
 805
 806   static final class it_conj_ere<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 807       final it_conj<T> dest;
 808       it_conj_ere(it_conj<T> dest) {
 809         this.dest = dest;
 810       }
 811       @Override
 812         public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 813             final Map<String, String> namedArgs,
 814             final T parser,
 815             final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 816           final String root = args.get(0);
 817           final boolean si = name.equals("it-conj-ersi");
 818
 819           passThroughOrFillIn(namedArgs, "inf", root + (si ? "ersi" : "ere"), false);
 820           namedArgs.put("aux", ListUtil.get(args, 1, ""));
 821           passThroughOrFillIn(namedArgs, "ger", root + "endo" + (si ? "si" : ""), true);
 822           passThroughOrFillIn(namedArgs, "presp", root + "ente" + (si ? "si" : ""), true);
 823           passThroughOrFillIn(namedArgs, "pastp", root + "uto", true);
 824           if (si) {
 825               passThroughOrFillIn(namedArgs, "pastp2", root + "utosi", true);
 826           }
 827           it_conj_passMood(namedArgs, "pres", false, root, Arrays.asList("o", "i", "e", "iamo", "ete", "ono"));
 828           it_conj_passMood(namedArgs, "imperf", false, root, Arrays.asList("evo", "evi", "eva", "evamo", "evate", "evano"));
 829           it_conj_passMood(namedArgs, "prem", false, root, Arrays.asList("ei", "esti", "ette", "emmo", "este", "ettero"));
 830           // Regular past historic synonyms:
 831           passThroughOrFillIn(namedArgs, "prem3s2", root + "é", true);
 832           passThroughOrFillIn(namedArgs, "prem3p2", root + "erono", true);
 833           it_conj_passMood(namedArgs, "fut", true, root, Arrays.asList("erò", "erai", "erà", "eremo", "erete", "eranno"));
 834           it_conj_passMood(namedArgs, "cond", true, root, Arrays.asList("erei", "eresti", "erebbe", "eremmo", "ereste", "erebbero"));
 835
 836           passThroughOrFillIn(namedArgs, "sub123s", root + "a", false);
 837           passThroughOrFillIn(namedArgs, "sub1p", root + "iamo", false);
 838           passThroughOrFillIn(namedArgs, "sub2p", root + "iate", false);
 839           passThroughOrFillIn(namedArgs, "sub3p", root + "ano", false);
 840
 841           passThroughOrFillIn(namedArgs, "impsub12s", root + "essi", false);
 842           passThroughOrFillIn(namedArgs, "impsub3s", root + "esse", false);
 843           passThroughOrFillIn(namedArgs, "impsub1p", root + "essimo", false);
 844           passThroughOrFillIn(namedArgs, "impsub2p", root + "este", false);
 845           passThroughOrFillIn(namedArgs, "impsub3p", root + "essero", false);
 846
 847           passThroughOrFillIn(namedArgs, "imp2s", root + "i" + (si ? "ti" : ""), true);
 848           passThroughOrFillIn(namedArgs, "imp3s", (si ? "si " : "") + root + "a", true);
 849           passThroughOrFillIn(namedArgs, "imp1p", root + "iamo" + (si ? "ci" : ""), true);
 850           passThroughOrFillIn(namedArgs, "imp2p", root + "ete" + (si ? "vi" : ""), true);
 851           passThroughOrFillIn(namedArgs, "imp3p", (si ? "si " : "") + root + "ano", true);
 852
 853           return dest.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, appendAndIndexWikiCallback);
 854         }
 855       }
 856
 857   static final class it_conj_urre<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 858       final it_conj<T> dest;
 859       it_conj_urre(it_conj<T> dest) {
 860         this.dest = dest;
 861       }
 862       @Override
 863         public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 864             final Map<String, String> namedArgs,
 865             final T parser,
 866             final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 867           final String root = args.get(0);
 868           final boolean si = name.equals("it-conj-ursi");
 869
 870           passThroughOrFillIn(namedArgs, "inf", root + (si ? "ursi" : "urre"), false);
 871           namedArgs.put("aux", ListUtil.get(args, 1, ""));
 872           passThroughOrFillIn(namedArgs, "ger", root + "ucendo" + (si ? "si" : ""), true);
 873           passThroughOrFillIn(namedArgs, "presp", root + "ucente" + (si ? "si" : ""), true);
 874           passThroughOrFillIn(namedArgs, "pastp", root + "otto", true);
 875           if (si) {
 876               passThroughOrFillIn(namedArgs, "pastp2", root + "ottosi", true);
 877           }
 878           it_conj_passMood(namedArgs, "pres", false, root, Arrays.asList("uco", "uci", "uce", "uciamo", "ucete", "ucono"));
 879           it_conj_passMood(namedArgs, "imperf", false, root, Arrays.asList("ucevo", "ucevi", "uceva", "ucevamo", "ucevate", "ucevano"));
 880           it_conj_passMood(namedArgs, "prem", false, root, Arrays.asList("ussi", "ucesti", "usse", "ucemmo", "uceste", "ussero"));
 881           it_conj_passMood(namedArgs, "fut", true, root, Arrays.asList("urrò", "urrai", "urrà", "urremo", "urrete", "urranno"));
 882           it_conj_passMood(namedArgs, "cond", true, root, Arrays.asList("urrei", "urresti", "urrebbe", "urremmo", "urreste", "urrebbero"));
 883
 884           passThroughOrFillIn(namedArgs, "sub123s", root + "uca", false);
 885           passThroughOrFillIn(namedArgs, "sub1p", root + "uciamo", false);
 886           passThroughOrFillIn(namedArgs, "sub2p", root + "uciate", false);
 887           passThroughOrFillIn(namedArgs, "sub3p", root + "ucano", false);
 888
 889           passThroughOrFillIn(namedArgs, "impsub12s", root + "ucessi", false);
 890           passThroughOrFillIn(namedArgs, "impsub3s", root + "ucesse", false);
 891           passThroughOrFillIn(namedArgs, "impsub1p", root + "ucessimo", false);
 892           passThroughOrFillIn(namedArgs, "impsub2p", root + "uceste", false);
 893           passThroughOrFillIn(namedArgs, "impsub3p", root + "ucessero", false);
 894
 895           passThroughOrFillIn(namedArgs, "imp2s", root + "uci" + (si ? "ti" : ""), true);
 896           passThroughOrFillIn(namedArgs, "imp3s", (si ? "si" : "") + root + "uca", true);
 897           passThroughOrFillIn(namedArgs, "imp1p", root + "uciamo" + (si ? "ci" : ""), true);
 898           passThroughOrFillIn(namedArgs, "imp2p", root + "ucete" + (si ? "vi" : ""), true);
 899           passThroughOrFillIn(namedArgs, "imp3p", (si ? "si" : "") + root + "ucano", true);
 900
 901           return dest.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, appendAndIndexWikiCallback);
 902         }
 903       }
 904
 905   static final class it_conj_fare<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 906       final it_conj<T> dest;
 907       it_conj_fare(it_conj<T> dest) {
 908         this.dest = dest;
 909       }
 910       @Override
 911         public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 912             final Map<String, String> namedArgs,
 913             final T parser,
 914             final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 915           final String root = args.get(0);
 916           passThroughOrFillIn(namedArgs, "inf", root + "fare", false);
 917           namedArgs.put("aux", ListUtil.get(args, 1, ""));
 918           passThroughOrFillIn(namedArgs, "ger", root + "facendo", true);
 919           passThroughOrFillIn(namedArgs, "presp", root + "facente", true);
 920           passThroughOrFillIn(namedArgs, "pastp", root + "fatto", true);
 921           it_conj_passMood(namedArgs, "pres", false, root, Arrays.asList("faccio", "fai", "fà", "facciamo", "fate", "fanno"));
 922           passThroughOrFillIn(namedArgs, "pres1s2", root + "fò", true);
 923           it_conj_passMood(namedArgs, "imperf", false, root, Arrays.asList("facevo", "facevi", "faceva", "facevamo", "facevate", "facevano"));
 924           it_conj_passMood(namedArgs, "prem", false, root, Arrays.asList("feci", "facesti", "fece", "facemmo", "faceste", "fecero"));
 925           it_conj_passMood(namedArgs, "fut", true, root, Arrays.asList("farò", "farai", "farà", "faremo", "farete", "faranno"));
 926           it_conj_passMood(namedArgs, "cond", true, root, Arrays.asList("farei", "faresti", "farebbe", "faremmo", "fareste", "farebbero"));
 927
 928           passThroughOrFillIn(namedArgs, "sub123s", root + "faccia", false);
 929           passThroughOrFillIn(namedArgs, "sub1p", root + "facciamo", false);
 930           passThroughOrFillIn(namedArgs, "sub2p", root + "facciate", false);
 931           passThroughOrFillIn(namedArgs, "sub3p", root + "facciano", false);
 932
 933           passThroughOrFillIn(namedArgs, "impsub12s", root + "facessi", false);
 934           passThroughOrFillIn(namedArgs, "impsub3s", root + "facesse", false);
 935           passThroughOrFillIn(namedArgs, "impsub1p", root + "facessimo", false);
 936           passThroughOrFillIn(namedArgs, "impsub2p", root + "faceste", false);
 937           passThroughOrFillIn(namedArgs, "impsub3p", root + "facessero", false);
 938
 939           passThroughOrFillIn(namedArgs, "imp2s", root + "fa", true);
 940           passThroughOrFillIn(namedArgs, "imp3s", root + "faccia", true);
 941           passThroughOrFillIn(namedArgs, "imp1p", root + "facciamo", true);
 942           passThroughOrFillIn(namedArgs, "imp2p", root + "fate", true);
 943           passThroughOrFillIn(namedArgs, "imp3p", root + "facciano", true);
 944
 945           return dest.onWikiFunction(wikiTokenizer, name, args, namedArgs, parser, appendAndIndexWikiCallback);
 946         }
 947       }
 948
 949   static final Map<String,String> it_indicativePronouns = new LinkedHashMap<String, String>();
 950   static {
 951       it_indicativePronouns.put("1s", "io");
 952       it_indicativePronouns.put("2s", "tu");
 953       it_indicativePronouns.put("3s", "lui/lei");
 954       it_indicativePronouns.put("1p", "noi");
 955       it_indicativePronouns.put("2p", "voi");
 956       it_indicativePronouns.put("3p", "essi/esse");
 957   }
 958
 959   static final Map<String,String> it_subjunctivePronouns = new LinkedHashMap<String, String>();
 960   static {
 961       it_subjunctivePronouns.put("1s", "che io");
 962       it_subjunctivePronouns.put("2s", "che tu");
 963       it_subjunctivePronouns.put("3s", "che lui/lei");
 964       it_subjunctivePronouns.put("1p", "che noi");
 965       it_subjunctivePronouns.put("2p", "che voi");
 966       it_subjunctivePronouns.put("3p", "che essi/esse");
 967   }
 968
 969   static final Map<String,String> it_imperativePronouns = new LinkedHashMap<String, String>();
 970   static {
 971       it_imperativePronouns.put("1s", "-");
 972       it_imperativePronouns.put("2s", "tu");
 973       it_imperativePronouns.put("3s", "lui/lei");
 974       it_imperativePronouns.put("1p", "noi");
 975       it_imperativePronouns.put("2p", "voi");
 976       it_imperativePronouns.put("3p", "essi/esse");
 977   }
 978
 979
 980   static final class it_conj<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 981       @Override
 982       public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 983           final Map<String, String> namedArgs,
 984           final T parser,
 985           final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 986
 987         final StringBuilder builder = appendAndIndexWikiCallback.builder;
 988
 989         final String inf = namedArgs.get("inf");
 990
 991         // TODO: center everything horizontally.
 992         builder.append("<table style=\"background:#F0F0F0;border-collapse:separate;border-spacing:2px\">");
 993
 994         builder.append("<tr>");
 995         builder.append("<th colspan=\"1\" style=\"background:#e2e4c0\">infinitive</th>");
 996         builder.append("<td colspan=\"1\">");
 997         appendAndIndexWikiCallback.dispatch(MapUtil.safeRemove(namedArgs, "inf", "-"), null);
 998         builder.append("</td>");
 999         builder.append("</tr>\n");
1000
1001         builder.append("<tr>");
1002         builder.append("<th colspan=\"1\" style=\"background:#e2e4c0\">auxiliary verb</th>");
1003         builder.append("<td colspan=\"1\">");
1004         appendAndIndexWikiCallback.dispatch(MapUtil.safeRemove(namedArgs, "aux", "-"), null);
1005         builder.append("</td>");
1006         builder.append("<th colspan=\"1\" style=\"background:#e2e4c0\">gerund</th>");
1007         builder.append("<td colspan=\"1\">");
1008         outputKeyVariations(appendAndIndexWikiCallback, builder, "ger", namedArgs);
1009         builder.append("</td>");
1010         builder.append("</tr>\n");
1011
1012         builder.append("<tr>");
1013         builder.append("<th colspan=\"1\" style=\"background:#e2e4c0\">present participle</th>");
1014         builder.append("<td colspan=\"1\">");
1015         outputKeyVariations(appendAndIndexWikiCallback, builder, "presp", namedArgs);
1016         builder.append("</td>");
1017         builder.append("<th colspan=\"1\" style=\"background:#e2e4c0\">past participle</th>");
1018         builder.append("<td colspan=\"1\">");
1019         outputKeyVariations(appendAndIndexWikiCallback, builder, "pastp", namedArgs);
1020         builder.append("</td>");
1021         builder.append("</tr>\n");
1022
1023         final List<String> prefixes = (inf != null && inf.endsWith("si")) ? it_reflexive_pronouns : it_empty;
1024
1025         String style = " style=\"background:#c0cfe4\"";
1026         outputDataRow(appendAndIndexWikiCallback, style, "indicative", style, "th", "", new LinkedHashMap<String, String>(it_indicativePronouns), it_empty);
1027         outputDataRow(appendAndIndexWikiCallback, style, "present", "", "td", "pres", namedArgs, prefixes);
1028         outputDataRow(appendAndIndexWikiCallback, style, "imperfect", "", "td", "imperf", namedArgs, prefixes);
1029         outputDataRow(appendAndIndexWikiCallback, style, "past historic", "", "td", "prem", namedArgs, prefixes);
1030         outputDataRow(appendAndIndexWikiCallback, style, "future", "", "td", "fut", namedArgs, prefixes);
1031
1032         style = " style=\"background:#c0d8e4\"";
1033         outputDataRow(appendAndIndexWikiCallback, style, "conditional", style, "th", "", new LinkedHashMap<String, String>(it_indicativePronouns), it_empty);
1034         outputDataRow(appendAndIndexWikiCallback, style, "present", "", "td", "cond", namedArgs, prefixes);
1035
1036         style = " style=\"background:#c0e4c0\"";
1037         outputDataRow(appendAndIndexWikiCallback, style, "subjuntive", style, "th", "", new LinkedHashMap<String, String>(it_subjunctivePronouns), it_empty);
1038         namedArgs.put("sub3s2", namedArgs.remove("sub3s"));
1039         namedArgs.put("sub1s", namedArgs.get("sub123s"));
1040         namedArgs.put("sub2s", namedArgs.get("sub123s"));
1041         namedArgs.put("sub3s", namedArgs.remove("sub123s"));
1042         namedArgs.put("sub1s2", namedArgs.get("sub123s2"));
1043         namedArgs.put("sub2s2", namedArgs.get("sub123s2"));
1044         namedArgs.put("sub3s2", namedArgs.remove("sub123s2"));
1045         outputDataRow(appendAndIndexWikiCallback, style, "present", "", "td", "sub", namedArgs, prefixes);
1046         namedArgs.put("impsub1s", namedArgs.get("impsub12s"));
1047         namedArgs.put("impsub2s", namedArgs.remove("impsub12s"));
1048         namedArgs.put("impsub1s2", namedArgs.get("impsub12s2"));
1049         namedArgs.put("impsub2s2", namedArgs.remove("impsub12s2"));
1050         outputDataRow(appendAndIndexWikiCallback, style, "imperfect", "", "td", "impsub", namedArgs, prefixes);
1051
1052         style = " style=\"background:#e4d4c0\"";
1053         outputDataRow(appendAndIndexWikiCallback, style, "imperative", style, "th", "", new LinkedHashMap<String, String>(it_imperativePronouns), it_empty);
1054         outputDataRow(appendAndIndexWikiCallback, style, "", "", "td", "imp", namedArgs, it_empty);  // these are attached to the stem.
1055
1056         builder.append("</table>\n");
1057
1058         if (!namedArgs.isEmpty()) {
1059             System.err.println("NON-EMPTY namedArgs: " + namedArgs);
1060             assert false;
1061             return false;
1062         }
1063
1064         return true;
1065       }
1066
1067         private void outputDataRow(AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback,
1068                 String col1Style, String headerName,
1069                 String col2Style, final String type2,
1070                 String moodName, Map<String, String> namedArgs, final List<String> prefixes) {
1071             final StringBuilder builder = appendAndIndexWikiCallback.builder;
1072             builder.append("<tr>");
1073             builder.append("<th colspan=\"1\"").append(col1Style).append(">").append(headerName).append("</th>");
1074             int i = 0;
1075             for (final String number : it_number_s_p) {
1076                 for (final String person : it_person_1_2_3) {
1077                     // Output <td> or <th>
1078                     builder.append("<").append(type2).append("").append(col2Style).append(">");
1079                     final String keyBase = String.format("%s%s%s", moodName, person, number);
1080                     appendAndIndexWikiCallback.dispatch(prefixes.get(i++), null);
1081                     outputKeyVariations(appendAndIndexWikiCallback, builder, keyBase, namedArgs);
1082                     // Output <td> or <th>
1083                     builder.append("</").append(type2).append(">");
1084                 }
1085             }
1086             builder.append("</tr>\n");
1087         }
1088     }
1089 }