src/com/hughes/android/dictionary/engine/DictFileParser.java

   1 package com.hughes.android.dictionary.engine;
   2
   3 import java.io.BufferedReader;
   4 import java.io.File;
   5 import java.io.FileInputStream;
   6 import java.io.IOException;
   7 import java.io.InputStreamReader;
   8 import java.nio.charset.Charset;
   9 import java.util.HashSet;
  10 import java.util.List;
  11 import java.util.Set;
  12 import java.util.logging.Logger;
  13 import java.util.regex.Matcher;
  14 import java.util.regex.Pattern;
  15
  16 import com.hughes.android.dictionary.Language;
  17 import com.hughes.android.dictionary.engine.PairEntry.Pair;
  18
  19 public class DictFileParser {
  20
  21   static final Logger logger = Logger.getLogger(DictFileParser.class.getName());
  22
  23   // Dictcc
  24   static final Pattern TAB = Pattern.compile("\\t");
  25
  26   // Chemnitz
  27   static final Pattern DOUBLE_COLON = Pattern.compile(" :: ");
  28   static final Pattern PIPE = Pattern.compile(" \\| ");
  29
  30   static final Pattern SPACES = Pattern.compile("\\s+");
  31   static final Pattern DE_NOUN = Pattern.compile("([^ ]+) *\\{(m|f|n|pl)\\}");
  32   static final Pattern EN_VERB = Pattern.compile("^to ([^ ]+)");
  33
  34   static final Pattern BRACKETED = Pattern.compile("\\[([^]]+)\\]");
  35   static final Pattern PARENTHESIZED = Pattern.compile("\\(([^)]+)\\]");
  36
  37   static final Pattern NON_CHAR_DASH = Pattern.compile("[^-'\\p{L}0-9]+");
  38   static final Pattern NON_CHAR = Pattern.compile("[^\\p{L}0-9]+");
  39
  40   static final Pattern TRIM_PUNC = Pattern.compile("^[^\\p{L}0-9]+|[^\\p{L}0-9]+$");
  41
  42   final Charset charset;
  43   final boolean flipCols;
  44
  45   final Pattern fieldSplit;
  46   final Pattern subfieldSplit;
  47
  48   final DictionaryBuilder dictBuilder;
  49   final IndexBuilder[] langIndexBuilders;
  50   final IndexBuilder bothIndexBuilder;
  51
  52   final Set<String> alreadyDone = new HashSet<String>();
  53
  54   public DictFileParser(final Charset charset, boolean flipCols,
  55       final Pattern fieldSplit, final Pattern subfieldSplit,
  56       final DictionaryBuilder dictBuilder, final IndexBuilder[] langIndexBuilders,
  57       final IndexBuilder bothIndexBuilder) {
  58     this.charset = charset;
  59     this.flipCols = flipCols;
  60     this.fieldSplit = fieldSplit;
  61     this.subfieldSplit = subfieldSplit;
  62     this.dictBuilder = dictBuilder;
  63     this.langIndexBuilders = langIndexBuilders;
  64     this.bothIndexBuilder = bothIndexBuilder;
  65   }
  66
  67   public void parseFile(final File file) throws IOException {
  68     final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), charset));
  69     String line;
  70     while ((line = reader.readLine()) != null) {
  71       parseLine(line);
  72     }
  73   }
  74
  75   private void parseLine(final String line) {
  76     if (line.startsWith("#") || line.length() == 0) {
  77       logger.info("Skipping comment line: " + line);
  78       return;
  79     }
  80     final String[] fields = fieldSplit.split(line);
  81     if (fields.length != 2) {
  82       logger.warning("Malformed line: " + line);
  83       return;
  84     }
  85
  86     fields[0] = SPACES.matcher(fields[0]).replaceAll(" ").trim();
  87     fields[1] = SPACES.matcher(fields[1]).replaceAll(" ").trim();
  88     if (flipCols) {
  89       final String temp = fields[0];
  90       fields[0] = fields[1];
  91       fields[1] = temp;
  92     }
  93
  94     final String[][] subfields = new String[2][];
  95       if (subfieldSplit != null) {
  96       subfields[0] = subfieldSplit.split(fields[0]);
  97       subfields[1] = subfieldSplit.split(fields[1]);
  98       if (subfields[0].length != subfields[1].length) {
  99         logger.warning("Number of subfields doesn't match: " + line);
 100         return;
 101       }
 102     } else {
 103       subfields[0] = new String[] { fields[0] };
 104       subfields[1] = new String[] { fields[1] };
 105     }
 106
 107     final Pair[] pairs = new Pair[subfields[0].length];
 108     for (int i = 0; i < pairs.length; ++i) {
 109       pairs[i] = new Pair(subfields[0][i], subfields[1][i]);
 110     }
 111     final PairEntry pairEntry = new PairEntry(pairs);
 112     final EntryData entryData = new EntryData(dictBuilder.dictionary.pairEntries.size(), pairEntry);
 113     dictBuilder.dictionary.pairEntries.add(pairEntry);
 114     dictBuilder.entryDatas.add(entryData);  // TODO: delete me.
 115
 116     for (int l = 0; l < 2; ++l) {
 117       alreadyDone.clear();
 118
 119       for (int j = 0; j < subfields[l].length; ++j) {
 120         String subfield = subfields[l][j];
 121         final IndexBuilder indexBuilder = langIndexBuilders[l];
 122         if (indexBuilder.index.sortLanguage == Language.de) {
 123           subfield = parseField_DE(indexBuilder, subfield, entryData, j);
 124         } else if (indexBuilder.index.sortLanguage == Language.en) {
 125           subfield = parseField_EN(indexBuilder, subfield, entryData, j);
 126         }
 127         parseFieldGeneric(indexBuilder, subfield, entryData, j, subfields.length);
 128       }
 129     }
 130   }
 131
 132   private void parseFieldGeneric(final IndexBuilder indexBuilder, String field,
 133       final EntryData entryData, final int subfieldIdx, final int numSubFields) {
 134     // remove bracketed and parenthesized stuff.
 135     final StringBuilder bracketed = new StringBuilder();
 136     final StringBuilder parenthesized = new StringBuilder();
 137
 138     Matcher matcher;
 139     while ((matcher = BRACKETED.matcher(field)).matches()) {
 140       bracketed.append(matcher.group(1)).append(" ");
 141       field = matcher.replaceFirst(" ");
 142     }
 143
 144     while ((matcher = PARENTHESIZED.matcher(field)).matches()) {
 145       parenthesized.append(matcher.group(1)).append(" ");
 146       field = matcher.replaceFirst(" ");
 147     }
 148
 149     field = SPACES.matcher(field).replaceAll(" ").trim();
 150
 151     // split words on non -A-z0-9, do them.
 152     final String[] tokens = NON_CHAR_DASH.split(field);
 153
 154     final EntryTypeName entryTypeName;
 155     if (numSubFields == 1) {
 156       assert subfieldIdx == 0;
 157       if (tokens.length == 1) {
 158         entryTypeName = EntryTypeName.ONE_WORD;
 159       } else if (tokens.length == 2) {
 160         entryTypeName = EntryTypeName.TWO_WORDS;
 161       } else if (tokens.length == 3) {
 162         entryTypeName = EntryTypeName.THREE_WORDS;
 163       } else if (tokens.length == 4) {
 164         entryTypeName = EntryTypeName.FOUR_WORDS;
 165       } else {
 166         entryTypeName = EntryTypeName.FIVE_OR_MORE_WORDS;
 167       }
 168     } else {
 169       assert numSubFields > 1;
 170       if (subfieldIdx == 0) {
 171         if (tokens.length == 1) {
 172           entryTypeName = EntryTypeName.MULTIROW_HEAD_ONE_WORD;
 173         } else {
 174           entryTypeName = EntryTypeName.MULTIROW_HEAD_MANY_WORDS;
 175         }
 176       } else {
 177         assert subfieldIdx > 0;
 178         if (tokens.length == 1) {
 179           entryTypeName = EntryTypeName.MULTIROW_TAIL_ONE_WORD;
 180         } else {
 181           entryTypeName = EntryTypeName.MULTIROW_TAIL_MANY_WORDS;
 182         }
 183       }
 184     }
 185
 186     for (String token : tokens) {
 187       token = TRIM_PUNC.matcher(token).replaceAll("");
 188       if (!alreadyDone.contains(token) && token.length() > 0) {
 189         final List<EntryData> entries = indexBuilder.getOrCreateEntries(token, entryTypeName);
 190         entries.add(entryData);
 191         alreadyDone.add(token);
 192
 193         // also split words on dashes, do them, too.
 194         if (token.contains("-")) {
 195           final String[] dashed = token.split("-");
 196           for (final String dashedToken : dashed) {
 197             if (!alreadyDone.contains(dashedToken) && dashedToken.length() > 0) {
 198               final List<EntryData> dashEntries = indexBuilder.getOrCreateEntries(dashedToken, EntryTypeName.PART_OF_HYPHENATED);
 199               dashEntries.add(entryData);
 200             }
 201           }
 202         }
 203
 204       }  // if (!alreadyDone.contains(token)) {
 205     }  // for (final String token : tokens) {
 206
 207     // process bracketed stuff (split on spaces and dashes always)
 208     final String[] bracketedTokens = NON_CHAR.split(bracketed.toString());
 209     for (final String token : bracketedTokens) {
 210       assert !token.contains("-");
 211       if (!alreadyDone.contains(token) && token.length() > 0) {
 212         final List<EntryData> entries = indexBuilder.getOrCreateEntries(token, EntryTypeName.BRACKETED);
 213         entries.add(entryData);
 214       }
 215     }
 216
 217     // process paren stuff
 218     final String[] parenTokens = NON_CHAR.split(bracketed.toString());
 219     for (final String token : parenTokens) {
 220       assert !token.contains("-");
 221       if (!alreadyDone.contains(token) && token.length() > 0) {
 222         final List<EntryData> entries = indexBuilder.getOrCreateEntries(token, EntryTypeName.PARENTHESIZED);
 223         entries.add(entryData);
 224       }
 225     }
 226
 227   }
 228
 229   private String parseField_DE(final IndexBuilder indexBuilder, String field,
 230       final EntryData entryData, final int subfieldIdx) {
 231     final Matcher matcher = DE_NOUN.matcher(field);
 232     while (matcher.find()) {
 233       final String noun = matcher.group(1);
 234       //final String gender = matcher.group(2);
 235       if (alreadyDone.add(noun)) {
 236         // System.out.println("Found DE noun " + noun + ", " + gender);
 237         final List<EntryData> entries = indexBuilder.getOrCreateEntries(noun, EntryTypeName.NOUN);
 238         entries.add(entryData);
 239       }
 240     }
 241     return field;
 242   }
 243
 244   private String parseField_EN(final IndexBuilder indexBuilder, String field,
 245       final EntryData entryData, final int subfieldIdx) {
 246     if (field.startsWith("to ")) {
 247       field = field.substring(3);
 248     }
 249     return field;
 250   }
 251
 252
 253 }