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