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 Class[] _inner = new Class[0];
  19     private Method[] _allMethods = new Method[0];
  20
  21     public AnnotationGrammarBindingResolver(Class c) {
  22         this._cl = c;
  23         add(c, "");
  24     }
  25
  26     public void add(Class c, String prefix) {
  27         ArrayList<Class> alc = new ArrayList<Class>();
  28         for(Class cc : _inner) alc.add(cc);
  29         ArrayList<Method> alm = new ArrayList<Method>();
  30         for(Method m : _allMethods) alm.add(m);
  31         add(c, alc, alm, "");
  32         this._inner = (Class[])alc.toArray(new Class[0]);
  33         this._allMethods = (Method[])alm.toArray(new Method[0]);
  34     }
  35
  36     public Object repeatTag() { return new Tree.ArrayBuildingTreeFunctor<Object>(); }
  37
  38     public Sequence tryResolveTag(String tag, String nonTerminalName, Element[] els, boolean[] drops) {
  39         MetaGrammar.Production p = new MetaGrammar.Production(tag, nonTerminalName, els, drops);
  40         for(Method m : _allMethods)
  41             if (new MetaGrammar.Target(m).isCompatible(p))
  42                 return new MetaGrammar.Target(m).makeSequence(p);
  43         for(Class c : _inner)
  44             for(Constructor con : c.getConstructors())
  45                 if (new MetaGrammar.Target(con).isCompatible(p))
  46                     return new MetaGrammar.Target(con).makeSequence(p);
  47         for(Class c : _inner)
  48             if (new MetaGrammar.Target(c).isCompatible(p))
  49                 return new MetaGrammar.Target(c).makeSequence(p);
  50         return null;
  51     }
  52     public Sequence resolveTag(String tag, String nonTerminalName, Element[] els, boolean[] drops) {
  53         MetaGrammar.Production p = new MetaGrammar.Production(tag, nonTerminalName, els, drops);
  54         Sequence ret = tryResolveTag(tag, nonTerminalName, els, drops);
  55         if (ret != null) return ret;
  56         String message = "could not find a Java method/class/ctor matching tag \""+tag+
  57             "\", nonterminal \""+nonTerminalName+"\" with " + els.length + " arguments";
  58         if (harsh) {
  59             throw new RuntimeException(message);
  60         } else {
  61             return Sequence.rewritingSequence(tag, els, drops);
  62         }
  63     }
  64
  65     // helper
  66
  67     private static void add(Class cl, ArrayList<Class> alc, ArrayList<Method> alm, String prefix) {
  68         if (cl==null) return;
  69         for(Method m : cl.getDeclaredMethods())
  70             alm.add(m);
  71         for(Class c : cl.getDeclaredClasses()) {
  72             alc.add(c);
  73             add(c, alc, alm, prefix);
  74         }
  75         if (cl.getSuperclass() != Object.class)
  76             add(cl.getSuperclass(), alc, alm, prefix);
  77     }
  78
  79 }