// returns a macro adder for the given morph item
private MacroAdder getMacAdder(MorphItem mi) {
// check map
MacroAdder retval = macAdderMap.get(mi);
if (retval != null) return retval;
// set up macro adder
IntHashSetMap macrosFromLex = new IntHashSetMap();
String[] newMacroNames = mi.getMacros();
List<MacroItem> macroItems = new ArrayList<MacroItem>();
for (int i = 0; i < newMacroNames.length; i++) {
Set<FeatureStructure> featStrucs = (Set<FeatureStructure>) _macros.get(newMacroNames[i]);
if (featStrucs != null) {
for (Iterator<FeatureStructure> fsIt = featStrucs.iterator(); fsIt.hasNext(); ) {
FeatureStructure fs = fsIt.next();
macrosFromLex.put(fs.getIndex(), fs);
}
}
MacroItem macroItem = _macroItems.get(newMacroNames[i]);
if (macroItem != null) {
macroItems.add(macroItem);
} else {
// should be checked earlier too
System.err.println(
"Warning: macro " + newMacroNames[i] + " not found for word '" + mi.getWord() + "'");
}
}
retval = new MacroAdder(macrosFromLex, macroItems);
// update map and return
macAdderMap.put(mi, retval);
return retval;
}
public void modify(Mutable m) {
if (m instanceof NominalVar) {
NominalVar nv = (NominalVar) m;
SimpleType st = nv.getType();
SimpleType st0 = nomvarMap.get(nv);
// add type to map if no type found
if (st0 == null) {
nomvarMap.put(nv, st);
return;
}
// check equality
if (st.equals(st0)) return;
// otherwise unify types, update nv and map
try {
SimpleType stU = (SimpleType) st.unify(st0, null);
nv.setType(stU);
nomvarMap.put(nv, stU);
} catch (UnifyFailure uf) {
throw new TypePropagationException(st, st0);
}
}
}
// given EntriesItem
private void getWithEntriesItem(
Word w,
MorphItem mi,
String stem,
String pred,
String targetPred,
String targetRel,
EntriesItem item,
MacroAdder macAdder,
Map<String, Double> supertags,
Set<String> supertagsFound,
SignHash result) {
// ensure apropos
if (targetPred != null && !targetPred.equals(pred)) return;
if (targetRel != null
&& !targetRel.equals(item.getIndexRel())
&& !targetRel.equals(item.getCoartRel())) return;
if (!item.getActive().booleanValue()) return;
if (mi.excluded(item)) return;
try {
// copy and add macros
Category cat = item.getCat().copy();
macAdder.addMacros(cat);
// replace DEFAULT_VAL with pred, after first
// unifying type of associated nom var(s) with sem class
unifySemClass(cat, mi.getWord().getSemClass());
REPLACEMENT = pred;
cat.deepMap(defaultReplacer);
// check supertag
// TODO: think about earlier checks for efficiency, for grammars where macros and preds don't
// matter
// Double lexprob = null; // nb: skipping lex log probs, don't seem to be helpful
if (supertags != null) {
// skip if not found
String stag = cat.getSupertag();
if (!supertags.containsKey(stag)) return;
// otherwise update found supertags
supertagsFound.add(stag);
// get lex prob
// lexprob = supertags.get(stag);
}
// propagate types of nom vars
propagateTypes(cat);
// handle distrib attrs and inherits-from
propagateDistributiveAttrs(cat);
expandInheritsFrom(cat);
// merge stem, pos, sem class from morph item, plus supertag from cat
Word word = Word.createFullWord(w, mi.getWord(), cat.getSupertag());
// set origin and lexprob
Sign sign = new Sign(word, cat);
sign.setOrigin();
// if (lexprob != null) {
// sign.addData(new SupertaggerAdapter.LexLogProb((float) Math.log10(lexprob)));
// }
// return sign
result.insert(sign);
} catch (RuntimeException exc) {
System.err.println(
"Warning: ignoring entry: "
+ item.getName()
+ " of family: "
+ item.getFamilyName()
+ " for stem: "
+ stem
+ " b/c: "
+ exc.toString());
}
}
// given MorphItem
private void getWithMorphItem(
Word w, MorphItem mi, String targetPred, String targetRel, SignHash result)
throws LexException {
// get supertags for filtering, if a supertagger is installed
Map<String, Double> supertags = null;
Set<String> supertagsFound = null;
if (_supertagger != null) {
supertags = _supertagger.getSupertags();
if (supertags != null) supertagsFound = new HashSet<String>(supertags.size());
}
// get macro adder
MacroAdder macAdder = getMacAdder(mi);
// if we have this stem in our lexicon
String stem = mi.getWord().getStem();
String pos = mi.getWord().getPOS();
Set<EntriesItem[]> explicitEntries =
null; // for storing entries from explicitly listed family members
if (_stems.containsKey(stem + pos)) {
explicitEntries = new HashSet<EntriesItem[]>();
Collection<Object> stemItems = (Collection<Object>) _stems.get(stem + pos);
for (Iterator<Object> I = stemItems.iterator(); I.hasNext(); ) {
Object item = I.next();
// see if it's an EntriesItem
if (item instanceof EntriesItem) {
EntriesItem entry = (EntriesItem) item;
// do lookup
getWithEntriesItem(
w,
mi,
stem,
stem,
targetPred,
targetRel,
entry,
macAdder,
supertags,
supertagsFound,
result);
}
// otherwise it has to be a Pair containing a DataItem and
// an EntriesItem[]
else {
@SuppressWarnings("rawtypes")
DataItem dItem = (DataItem) ((Pair) item).a;
@SuppressWarnings("rawtypes")
EntriesItem[] entries = (EntriesItem[]) ((Pair) item).b;
// store entries
explicitEntries.add(entries);
// do lookup
getWithDataItem(
w,
mi,
dItem,
entries,
targetPred,
targetRel,
macAdder,
supertags,
supertagsFound,
result);
}
}
}
// for entries that are not explicitly in the lexicon file, we have to create
// Signs from the open class entries with the appropriate part-of-speech
Collection<EntriesItem[]> entrySets = (Collection<EntriesItem[]>) _posToEntries.get(pos);
if (entrySets != null) {
for (Iterator<EntriesItem[]> E = entrySets.iterator(); E.hasNext(); ) {
EntriesItem[] entries = E.next();
// skip if entries explicitly listed
if (explicitEntries != null && explicitEntries.contains(entries)) continue;
// otherwise get entries with pred = targetPred, or stem if null
String pred = (targetPred != null) ? targetPred : stem;
getWithDataItem(
w,
mi,
new DataItem(stem, pred),
entries,
targetPred,
targetRel,
macAdder,
supertags,
supertagsFound,
result);
}
}
// finally do entries for any remaining supertags
if (supertags != null) {
for (String supertag : supertags.keySet()) {
if (supertagsFound.contains(supertag)) continue;
Set<EntriesItem> entries = _stagToEntries.get(supertag + pos);
if (entries == null) continue; // nb: could be a POS mismatch
// get entries with pred = targetPred, or stem if null
String pred = (targetPred != null) ? targetPred : stem;
for (EntriesItem entry : entries) {
if (!entry.getStem().equals(DEFAULT_VAL)) continue;
getWithEntriesItem(
w,
mi,
stem,
pred,
targetPred,
targetRel,
entry,
macAdder,
supertags,
supertagsFound,
result);
}
}
}
}