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