src/edu/berkeley/sbp/meta/AnnotationGrammarBindingResolver.java

   1 package edu.berkeley.sbp.meta;
   2 import edu.berkeley.sbp.util.*;
   3 import edu.berkeley.sbp.*;
   4 import edu.berkeley.sbp.chr.*;
   5 import edu.berkeley.sbp.misc.*;
   6 import edu.berkeley.sbp.bind.*;
   7 import java.util.*;
   8 import java.lang.annotation.*;
   9 import java.lang.reflect.*;
  10 import java.io.*;
  11
  12 // FIXME: non-static methods
  13 public class AnnotationGrammarBindingResolver extends GrammarBindingResolver {
  14
  15     private static boolean harsh = true;
  16
  17     private final Class _cl;
  18     private HashMap<String,Class[]> _inner = new HashMap<String,Class[]>();
  19     private HashMap<String,Method[]> _allMethods = new HashMap<String,Method[]>();
  20
  21     public AnnotationGrammarBindingResolver(Class c) {
  22         this._cl = c;
  23         add(c, "");
  24     }
  25
  26     public void add(Class c, String prefix) {
  27
  28         ArrayList<Class> alc = new ArrayList<Class>();
  29         if (_inner.get(prefix) != null)
  30             for(Class cc : _inner.get(prefix))
  31                 alc.add(cc);
  32
  33         ArrayList<Method> alm = new ArrayList<Method>();
  34         if (_allMethods.get(prefix) != null)
  35             for(Method m : _allMethods.get(prefix))
  36                 alm.add(m);
  37
  38         add(c, alc, alm, prefix);
  39         this._inner.put(prefix, (Class[])alc.toArray(new Class[0]));
  40         this._allMethods.put(prefix, (Method[])alm.toArray(new Method[0]));
  41     }
  42
  43     public Object repeatTag() { return new Tree.ArrayBuildingTreeFunctor<Object>(); }
  44
  45     public Sequence tryResolveTag(String tag, String nonTerminalName, Element[] els, boolean[] drops) {
  46
  47         String key = tag==null?nonTerminalName:tag;
  48         if (key==null) return null;
  49
  50         String prefix = key.indexOf('.')==-1 ? "" : key.substring(0, key.lastIndexOf('.'));
  51         String suffix = key.indexOf('.')==-1 ? key : key.substring(key.lastIndexOf('.')+1);
  52
  53         //System.err.println("suffix = " + suffix);
  54         MetaGrammar.Production p = new MetaGrammar.Production(tag, nonTerminalName, els, drops);
  55         for(Method m : _allMethods.get(prefix))
  56             if (new MetaGrammar.Target(m).isCompatible(p))
  57                 return new MetaGrammar.Target(m).makeSequence(p);
  58         for(Class c : _inner.get(prefix))
  59             for(Constructor con : c.getConstructors())
  60                 if (new MetaGrammar.Target(con).isCompatible(p))
  61                     return new MetaGrammar.Target(con).makeSequence(p);
  62         for(Class c : _inner.get(prefix))
  63             if (new MetaGrammar.Target(c).isCompatible(p))
  64                 return new MetaGrammar.Target(c).makeSequence(p);
  65
  66         return null;
  67
  68     }
  69
  70     public Sequence resolveTag(String tag, String nonTerminalName, Element[] els, boolean[] drops) {
  71         MetaGrammar.Production p = new MetaGrammar.Production(tag, nonTerminalName, els, drops);
  72         Sequence ret = tryResolveTag(tag, nonTerminalName, els, drops);
  73         if (ret != null) return ret;
  74         String message = "could not find a Java method/class/ctor matching tag \""+tag+
  75             "\", nonterminal \""+nonTerminalName+"\" with " + els.length + " arguments";
  76         if (harsh) {
  77             throw new RuntimeException(message);
  78         } else {
  79             return Sequence.rewritingSequence(tag, els, drops);
  80         }
  81     }
  82
  83     // helper
  84
  85     private static void add(Class cl, ArrayList<Class> alc, ArrayList<Method> alm, String prefix) {
  86         if (cl==null) return;
  87         for(Method m : cl.getDeclaredMethods())
  88             alm.add(m);
  89         for(Class c : cl.getDeclaredClasses()) {
  90             alc.add(c);
  91             add(c, alc, alm, prefix);
  92         }
  93         if (cl.getSuperclass() != Object.class)
  94             add(cl.getSuperclass(), alc, alm, prefix);
  95     }
  96
  97 }