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

   1 // Copyright 2006 all rights reserved; see LICENSE file for BSD-style license
   2
   3 package edu.berkeley.sbp.meta;
   4 import edu.berkeley.sbp.util.*;
   5 import edu.berkeley.sbp.*;
   6 import edu.berkeley.sbp.chr.*;
   7 import edu.berkeley.sbp.misc.*;
   8 import edu.berkeley.sbp.bind.*;
   9 import java.util.*;
  10 import java.lang.annotation.*;
  11 import java.lang.reflect.*;
  12 import java.io.*;
  13
  14 // FIXME: non-static methods
  15 public class AnnotationGrammarBindings extends Grammar.Bindings {
  16
  17     private static boolean harsh = true;
  18
  19     private final Class _cl;
  20     private HashMap<String,Class[]> _inner = new HashMap<String,Class[]>();
  21     private HashMap<String,Method[]> _allMethods = new HashMap<String,Method[]>();
  22
  23     public AnnotationGrammarBindings(Class c) {
  24         this._cl = c;
  25         add(c, "");
  26     }
  27
  28     public void add(Class c, String prefix) {
  29
  30         ArrayList<Class> alc = new ArrayList<Class>();
  31         if (_inner.get(prefix) != null)
  32             for(Class cc : _inner.get(prefix))
  33                 alc.add(cc);
  34
  35         ArrayList<Method> alm = new ArrayList<Method>();
  36         if (_allMethods.get(prefix) != null)
  37             for(Method m : _allMethods.get(prefix))
  38                 alm.add(m);
  39
  40         add(c, alc, alm, prefix);
  41         this._inner.put(prefix, (Class[])alc.toArray(new Class[0]));
  42         this._allMethods.put(prefix, (Method[])alm.toArray(new Method[0]));
  43     }
  44
  45     public Object repeatTag() { return new ArrayBuildingTreeFunctor<Object>(); }
  46
  47     public Sequence createSequence(Production p) {
  48
  49         String key = p.tag==null?p.nonTerminal:p.tag;
  50         if (key==null) return null;
  51
  52         String prefix = key.indexOf('.')==-1 ? "" : key.substring(0, key.lastIndexOf('.'));
  53         String suffix = key.indexOf('.')==-1 ? key : key.substring(key.lastIndexOf('.')+1);
  54
  55         p = new Production(suffix, p.elements, p.drops);
  56         for(Method m : _allMethods.get(prefix))
  57             if (p.isCompatible(m))
  58                 return p.makeSequence(m);
  59         for(Class c : _inner.get(prefix))
  60             for(Constructor con : c.getConstructors())
  61                 if (p.isCompatible(con))
  62                     return p.makeSequence(con);
  63         for(Class c : _inner.get(prefix))
  64             if (p.isCompatible(c))
  65                 return p.makeSequence(c);
  66
  67         return null;
  68
  69     }
  70
  71
  72     // helper
  73
  74     private static void add(Class cl, ArrayList<Class> alc, ArrayList<Method> alm, String prefix) {
  75         if (cl==null) return;
  76         for(Method m : cl.getDeclaredMethods())
  77             alm.add(m);
  78         for(Class c : cl.getDeclaredClasses()) {
  79             alc.add(c);
  80             add(c, alc, alm, prefix);
  81         }
  82         if (cl.getSuperclass() != Object.class)
  83             add(cl.getSuperclass(), alc, alm, prefix);
  84     }
  85
  86 }