예제 #1
0
파일: Rule.java 프로젝트: damc-dev/byteman
  /**
   * type check this rule
   *
   * @throws TypeException if the ruele contains type errors
   */
  public void typeCheck() throws TypeException {
    String helperName = ruleScript.getTargetHelper();

    // ensure that we have a valid helper class
    if (helperName != null) {
      try {
        helperClass = loader.loadClass(helperName);
      } catch (ClassNotFoundException e) {
        throw new TypeException(
            "Rule.typecheck : unknown helper class " + helperName + " for rule " + getName());
      }
    } else {
      helperClass = Helper.class;
    }
    if (triggerExceptions != null) {
      // ensure that the type group includes the exception types
      typeGroup.addExceptionTypes(triggerExceptions);
    }

    // try to resolve all types in the type group to classes

    typeGroup.resolveTypes();

    // use the descriptor to derive the method argument types and type any bindings for them
    // that are located in the bindings list

    installParameters((triggerAccess & Opcodes.ACC_STATIC) != 0, triggerClass);

    event.typeCheck(Type.VOID);
    condition.typeCheck(Type.Z);
    action.typeCheck(Type.VOID);
  }
예제 #2
0
파일: Rule.java 프로젝트: damc-dev/byteman
  private Rule(RuleScript ruleScript, ClassLoader loader, HelperManager helperManager)
      throws ParseException, TypeException, CompileException {
    ParseNode ruleTree;

    this.ruleScript = ruleScript;
    this.helperClass = null;
    this.loader = loader;

    typeGroup = new TypeGroup(loader);
    bindings = new Bindings();
    checked = false;
    triggerClass = null;
    triggerMethod = null;
    triggerDescriptor = null;
    triggerAccess = 0;
    returnType = null;
    accessibleFields = null;
    accessibleMethods = null;
    // this is only set when the rule is created via a real installed transformer
    this.helperManager = helperManager;
    ECAGrammarParser parser = null;
    try {
      String file = getFile();
      ECATokenLexer lexer = new ECATokenLexer(new StringReader(ruleScript.getRuleText()));
      lexer.setStartLine(getLine());
      lexer.setFile(file);
      parser = new ECAGrammarParser(lexer);
      parser.setFile(file);
      Symbol parse = (debugParse ? parser.debug_parse() : parser.parse());
      if (parser.getErrorCount() != 0) {
        String message = "rule " + ruleScript.getName();
        message += parser.getErrors();
        throw new ParseException(message);
      }
      ruleTree = (ParseNode) parse.value;
    } catch (ParseException pe) {
      throw pe;
    } catch (Throwable th) {
      String message = "rule " + ruleScript.getName();
      if (parser != null && parser.getErrorCount() != 0) {
        message += parser.getErrors();
      }
      message += "\n" + th.getMessage();
      throw new ParseException(message);
    }

    ParseNode eventTree = (ParseNode) ruleTree.getChild(0);
    ParseNode conditionTree = (ParseNode) ruleTree.getChild(1);
    ParseNode actionTree = (ParseNode) ruleTree.getChild(2);

    event = Event.create(this, eventTree);
    condition = Condition.create(this, conditionTree);
    action = Action.create(this, actionTree);
    key = null;
  }
예제 #3
0
파일: Rule.java 프로젝트: damc-dev/byteman
  /**
   * generate a string representation of the rule
   *
   * @return a string representation of the rule
   */
  public String toString() {
    StringWriter stringWriter = new StringWriter();
    stringWriter.write("RULE ");
    stringWriter.write(getName());
    stringWriter.write("\n");
    if (isInterface()) {
      stringWriter.write("INTERFACE ");
    } else {
      stringWriter.write("CLASS ");
    }
    if (isOverride()) {
      stringWriter.write("^");
    }
    stringWriter.write(getTargetClass());
    stringWriter.write('\n');
    stringWriter.write("METHOD ");
    stringWriter.write(getTargetMethod());
    stringWriter.write('\n');
    stringWriter.write(getTargetLocation().toString());
    stringWriter.write('\n');
    if (event != null) {
      event.writeTo(stringWriter);
    } else {
      stringWriter.write("BIND NOTHING\n");
    }
    if (condition != null) {
      condition.writeTo(stringWriter);
    } else {
      stringWriter.write("COND   TRUE\n");
    }
    if (action != null) {
      action.writeTo(stringWriter);
    } else {
      stringWriter.write("DO   NOTHING\n");
    }

    return stringWriter.toString();
  }
예제 #4
0
파일: Rule.java 프로젝트: damc-dev/byteman
 public void setEvent(String eventSpec) throws ParseException, TypeException {
   if (event == null) {
     event = Event.create(this, eventSpec);
   }
 }