src/edu/berkeley/sbp/misc/ReflectiveWalker.java

   1 package edu.berkeley.sbp.misc;
   2 import edu.berkeley.sbp.*;
   3 import edu.berkeley.sbp.util.*;
   4 import java.io.*;
   5 import java.util.*;
   6 import java.lang.reflect.*;
   7
   8 /** use of this class is not recommended; it can handle only S-attributed grammars */
   9 public class ReflectiveWalker extends StringWalker {
  10     public ReflectiveWalker()              { this.target = this; }
  11     public ReflectiveWalker(Object target) { this.target = target; }
  12     private final Object target;
  13     private String normalize(String s) {
  14         StringBuffer ret = new StringBuffer();
  15         for(int i=0; i<s.length(); i++) {
  16             char c = s.charAt(i);
  17             if (i==0 && c >= '0' && c <= '9') { ret.append('_'); ret.append(c); continue; }
  18             switch(c) {
  19                 case ' ':  ret.append("_space_"); break;
  20                 case '~':  ret.append("_tilde_"); break;
  21                 case ';':  ret.append("_semicolon_"); break;
  22                 case '=':  ret.append("_equals_"); break;
  23                 case '-':  ret.append("_minus_"); break;
  24                 case ')':  ret.append("_rightparen_"); break;
  25                 case '(':  ret.append("_leftparen_"); break;
  26                 case '!':  ret.append("_bang_"); break;
  27                 case '`':  ret.append("_backtick_"); break;
  28                 case '\"': ret.append("_quotes_"); break;
  29                 case '\'': ret.append("_quote_"); break;
  30                 case ',':  ret.append("_comma_"); break;
  31                 case '.':  ret.append("_dot_"); break;
  32                 case '>':  ret.append("_greater_"); break;
  33                 case '<':  ret.append("_less_"); break;
  34                 case '&':  ret.append("_amp_"); break;
  35                 case '@':  ret.append("_at_"); break;
  36                 case '#':  ret.append("_hash_"); break;
  37                 case '|':  ret.append("_pipe_"); break;
  38                 case '^':  ret.append("_caret_"); break;
  39                 case '%':  ret.append("_percent_"); break;
  40                 case '$':  ret.append("_dollar_"); break;
  41                 case ':':  ret.append("_colon_"); break;
  42                 case '?':  ret.append("_question_"); break;
  43                 case '/':  ret.append("_slash_"); break;
  44                 case '\\': ret.append("_backslash_"); break;
  45                 case '*':  ret.append("_star_"); break;
  46                 case '+':  ret.append("_plus_"); break;
  47                 case '_':  ret.append("_underscore_"); break;
  48                 case '[':  ret.append("_leftbracket_"); break;
  49                 case ']':  ret.append("_rightbracket_"); break;
  50                 case '{':  ret.append("_leftbrace_"); break;
  51                 case '}':  ret.append("_rightbrace_"); break;
  52                 default:   ret.append(c); break;
  53             }
  54         }
  55         return ret.toString();
  56     }
  57     /*
  58     public Object walk(Tree<String> tree) {
  59         if (tree.head()!=null) {
  60             Member m = member("$"+normalize(tree.head()), 0, false);
  61             if (m!=null) {
  62                 if ((m instanceof Method) && ((Method)m).getReturnType()==Void.TYPE) {
  63                     Reflection.fuzzyInvoke(target, m, new Object[0]);
  64                 }
  65             }
  66         }
  67         return super.walk(tree);
  68     }
  69     */
  70     public Object walk(String tag, Object[] argo) {
  71         if (argo.length==0) return super.walk(tag, argo);
  72         if (argo==null) return tag;
  73         if (tag==null || "".equals(tag)) return argo;
  74         Member m = member(normalize(tag), argo.length, argo.length>0);
  75         if (m==null) return super.walk(tag, argo);
  76         //System.out.println("preparing to invoke method " + (m==null ? "null" : (m.toString())) + " for sequence " + (owner()+"."+tag));
  77         if (m != null) return Reflection.fuzzyInvoke(target, m, argo);
  78         if (argo.length==0) return null;
  79         if (argo.length==1) return argo[0];
  80         Class c = argo[0].getClass();
  81         for(Object o : argo) c = Reflection.lub(c, o.getClass());
  82         Object[] ret = Reflection.newArray(c, argo.length);
  83         System.arraycopy(argo, 0, ret, 0, argo.length);
  84         return ret;
  85     }
  86
  87     public Member member(String methodName, int nonVoid, boolean complain) {
  88         Class target = this.target.getClass();
  89         if (methodName == null || methodName.equals("")) return null;
  90         Member ret = null;
  91         for (Method m : target.getMethods()) {
  92             if (!m.getName().equals(methodName)) continue;
  93             if (m.getParameterTypes().length != nonVoid) continue;
  94             if (ret != null) {
  95                 if (!complain) return null;
  96                 throw new Error("two methods with " + nonVoid + " parameters: " + target.getName() + "." + methodName);
  97             }
  98             ret = m;
  99         }
 100         if (ret != null) return ret;
 101         Class t = target;
 102         while(t != null) {
 103             Class c = Reflection.forNameOrNull(t.getName() + "$" + methodName);
 104             if (c != null) {
 105                 for (Constructor m : c.getConstructors()) {
 106                     if (m.getParameterTypes().length != nonVoid) continue;
 107                     if (ret != null) {
 108                         if (!complain) return null;
 109                         throw new Error("two constructors with " + nonVoid + " parameters: " + c.getName() + ".<init>()");
 110                     }
 111                     ret = m;
 112                 }
 113                 if (ret != null) return ret;
 114             }
 115             t = t.getSuperclass();
 116         }
 117         if (ret != null) return ret;
 118         if (!complain) return null;
 119         throw new Error("while computing return type of " +methodName+ " could not find method with name " + methodName +
 120                         " and " + nonVoid + " arguments");
 121     }
 122 }