javacc.jj

java 编译器java复杂编译器,可以编译java文件的类库

      "," Name(excName)
	{
	  p.throws_list.addElement(excName);
	}
    )*
  ]
  ":"
  Block(p.declaration_tokens)
  "{" expansion_choices(c) t="}"
	{
	  p.lastToken = t;
	  p.jumpPatched = jumpPatched;
	  production_addexpansion(p, (Expansion)(c.member));
	  addproduction(p);
	}
}

void regular_expr_production() :
	{
	  TokenProduction p = new TokenProduction();
	  java.util.Vector states;
	  Token t = p.firstToken = getToken(1);
	  p.line = t.beginLine;
	  p.column = t.beginColumn;
	}
{
	{
	  // set p.lexStates assuming there is no state spec.
	  // and then override if necessary.
	  p.lexStates = new String[1];
	  p.lexStates[0] = "DEFAULT";
	}
  [
    LOOKAHEAD(2) "<" "*" ">"
	{
	  p.lexStates = null;
	}
  |
    "<"
	{
	  states = new java.util.Vector();
	}
      t=<IDENTIFIER>
	{
	  states.addElement(t.image);
	}
      ( "," t=<IDENTIFIER>
	{
	  states.addElement(t.image);
	}
      )*
    ">"
	{
	  p.lexStates = new String[states.size()];
	  for (int i = 0; i < states.size(); i++) {
	    p.lexStates[i] = (String)states.elementAt(i);
	  }
	}
  ]
  regexpr_kind(p)
	{
	  if (p.kind != TokenProduction.TOKEN && Options.B("USER_TOKEN_MANAGER")) {
	    JavaCCErrors.warning(getToken(0), "Regular expression is being treated as if it were a TOKEN since option USER_TOKEN_MANAGER has been set to true.");
	  }
	}
  [
    "[" t="IGNORE_CASE" "]"
	{
	  p.ignoreCase = true;
	  if (Options.B("USER_TOKEN_MANAGER")) {
	    JavaCCErrors.warning(t, "Ignoring \"IGNORE_CASE\" specification since option USER_TOKEN_MANAGER has been set to true.");
	  }
	}
  ]
  ":"
  "{" regexpr_spec(p) ( "|" regexpr_spec(p) )* t="}"
	{
	  p.lastToken = t;
	  addregexpr(p);
	}
}

void token_manager_decls() :
	{
	  java.util.Vector decls = new java.util.Vector();
	  Token t;
	}
{
  t="TOKEN_MGR_DECLS" ":"
  ClassBody(decls)
	{
	  add_token_manager_decls(t, decls);
	}
}

void regexpr_kind(TokenProduction p) :
{}
{
  "TOKEN"
	{
	  p.kind = TokenProduction.TOKEN;
	}
|
  "SPECIAL_TOKEN"
	{
	  p.kind = TokenProduction.SPECIAL;
	}
|
  "SKIP"
	{
	  p.kind = TokenProduction.SKIP;
	}
|
  "MORE"
	{
	  p.kind = TokenProduction.MORE;
	}
}

void regexpr_spec(TokenProduction p) :
	{
	  Container c = new Container();
	  Action act = new Action();
	  Token t = null;
	  RegExprSpec res = new RegExprSpec();
	}
{
  regular_expression(c)
	{
	  res.rexp = (RegularExpression)c.member;
	  res.rexp.tpContext = p;
	}
  [
	{
	  t = getToken(1);
	}
    Block(act.action_tokens)
	{
	  if (Options.B("USER_TOKEN_MANAGER")) {
	    JavaCCErrors.warning(t, "Ignoring action in regular expression specification since option USER_TOKEN_MANAGER has been set to true.");
	  }
	  if (res.rexp.private_rexp) {
	    JavaCCErrors.parse_error(t, "Actions are not permitted on private (#) regular expressions.");
	  }
	}
  ]
  [ ":" t=<IDENTIFIER>
	{
	  res.nextState = t.image;
	  if (res.rexp.private_rexp) {
	    JavaCCErrors.parse_error(t, "Lexical state changes are not permitted after private (#) regular expressions.");
	  }
	}
  ]
	{
	  res.act = act;
	  res.nsTok = t;
	  p.respecs.addElement(res);
	}
}

void expansion_choices(Container c1) :
	{
	  boolean morethanone = false;
	  Choice ch = null; // unnecessary initialization to make Java compiler happy!
	  Container c2 = new Container();
	}
{
  expansion(c1)
  ( "|" expansion(c2)
	{
	  if (morethanone) {
	    ch.choices.addElement(c2.member);
	    ((Expansion)c2.member).parent = ch;
	  } else {
	    morethanone = true;
	    ch = new Choice();
	    ch.line = ((Expansion)c1.member).line;
	    ch.column = ((Expansion)c1.member).column;
	    ch.choices.addElement(c1.member);
	    ((Expansion)c1.member).parent = ch;
	    ch.choices.addElement(c2.member);
	    ((Expansion)c2.member).parent = ch;
	  }
	}
  )*
	{
	  if (morethanone) {
	    c1.member = ch;
	  }
	}
}

void expansion(Container c1) :
	{
	  Sequence seq = new Sequence();
	  Container c2 = new Container();
	  Lookahead la = new Lookahead();
	  Token t = getToken(1);
	  seq.line = t.beginLine;
	  seq.column = t.beginColumn;
	  la.line = t.beginLine;
	  la.column = t.beginColumn;
	}
{
	{
	  la.amount = Options.I("LOOKAHEAD");
	  la.la_expansion = null;
	  la.isExplicit = false;
	}
  ( LOOKAHEAD(1)
    t="LOOKAHEAD" "(" la=local_lookahead() ")"
	{
	  if (inLocalLA != 0 && la.amount != 0) {
	    JavaCCErrors.warning(t, "Only semantic lookahead specifications within other lookahead specifications is considered.  Syntactic lookahead is ignored.");
	  }
	}
  )?
	{
	  seq.units.addElement(la);
	}
  ( LOOKAHEAD(0, { notTailOfExpansionUnit() } )
    expansion_unit(c2)
	{
	  seq.units.addElement(c2.member);
	  ((Expansion)c2.member).parent = seq;
	  ((Expansion)c2.member).ordinal = seq.units.size()-1;
	}
  )+
	{
	  if (la.la_expansion == null) {
	    la.la_expansion = seq;
	  }
	  c1.member = seq;
	}
}

Lookahead local_lookahead() :
	{
	  Lookahead la = new Lookahead();
	  la.isExplicit = true;
	  Token t = getToken(1);
	  la.line = t.beginLine;
	  la.column = t.beginColumn;
	  la.la_expansion = null;
	  Container c = new Container();
	  boolean commaAtEnd = false, emptyLA = true;
	  inLocalLA++;
	}
{
  [
    /*
     * The lookahead of 1 is to turn off the warning message that lets
     * us know that an expansion choice can also start with an integer
     * literal because a primary expression can do the same.  But we
     * know that this is what we want.
     */
    LOOKAHEAD(1)
    la.amount = IntegerLiteral()
	{
	  emptyLA = false;
	}
  ]
  [ LOOKAHEAD(0, { !emptyLA && (getToken(1).kind != RPAREN) } )
    ","
	{
	  commaAtEnd = true;
	}
  ]
  [ LOOKAHEAD(0, { getToken(1).kind != RPAREN && getToken(1).kind != LBRACE } )
    expansion_choices(c)
	{
	  emptyLA = false; commaAtEnd = false;
	  la.la_expansion = (Expansion)c.member;
	}
  ]
  [ LOOKAHEAD(0, { !emptyLA && !commaAtEnd && (getToken(1).kind != RPAREN) } )
    ","
	{
	  commaAtEnd = true;
	}
  ]
  [ LOOKAHEAD(0, { emptyLA || commaAtEnd } )
    "{" Expression(la.action_tokens) "}"
	{
	  if (emptyLA) {
	    la.amount = 0;
	  }
	}
  ]
	{
	  inLocalLA--;
	  return la;
	}
}

void expansion_unit(Container c) :
	{
	  String name;
	  java.util.Vector lhsTokens = new java.util.Vector();
	  NonTerminal nt;
	  Action act;
	  Token t;
	  Lookahead la;
	}
{
  LOOKAHEAD(1)
  /*
   * We give this priority over primary expressions which use LOOKAHEAD as the
   * name of its identifier.
   */
  t="LOOKAHEAD" "(" la=local_lookahead() ")"
	{
	  // Now set the la_expansion field of la with a dummy
	  // expansion (we use EOF).
	  la.la_expansion = new REndOfFile();
	  // Create a singleton choice with an empty action.
	  Choice ch = new Choice();
	  ch.line = t.beginLine; ch.column = t.beginColumn;
	  Sequence seq = new Sequence();
	  seq.line = t.beginLine; seq.column = t.beginColumn;
	  seq.units.addElement(la);
	  la.parent = seq; la.ordinal = 0;
	  act = new Action();
	  act.line = t.beginLine; act.column = t.beginColumn;
	  seq.units.addElement(act);
	  act.parent = seq; act.ordinal = 1;
	  ch.choices.addElement(seq);
	  seq.parent = ch; seq.ordinal = 0;
	  if (la.amount != 0) {
	    if (la.action_tokens.size() != 0) {
	      JavaCCErrors.warning(t, "Encountered LOOKAHEAD(...) at a non-choice location.  Only semantic lookahead will be considered here.");
	    } else {
	      JavaCCErrors.warning(t, "Encountered LOOKAHEAD(...) at a non-choice location.  This will be ignored.");
	    }
	  }
	  c.member = ch;
	}
|
	{
	  act = new Action();
	  t = getToken(1);
	  act.line = t.beginLine;
	  act.column = t.beginColumn;
	  inAction = true;
	}
  Block(act.action_tokens)
	{
	  inAction = false;
	  if (inLocalLA != 0) {
	    JavaCCErrors.warning(t, "Action within lookahead specification will be ignored.");
	  }
	  c.member = act;
	}
|
  t="[" expansion_choices(c) "]"
	{
	  ZeroOrOne exp = new ZeroOrOne();
	  exp.line = t.beginLine;
	  exp.column = t.beginColumn;
	  exp.expansion = (Expansion)c.member;
	  ((Expansion)c.member).parent = exp;
	  c.member = exp;
	}
|
	{
	  Container expch = new Container();
	  java.util.Vector types = new java.util.Vector();
	  java.util.Vector ids = new java.util.Vector();
	  java.util.Vector catchblks = new java.util.Vector();
	  java.util.Vector finallyblk = null;
	  java.util.Vector vec = new java.util.Vector();
	  Token t0;
	}
  t0="try" "{" expansion_choices(expch) "}"
  ( "catch" "(" Name(vec) t=<IDENTIFIER> ")"
	{
	  types.addElement(vec);
	  ids.addElement(t);
	  vec = new java.util.Vector();
	  inAction = true;
	}
    Block(vec)
	{
	  inAction = false;
	  catchblks.addElement(vec);
	  vec = new java.util.Vector();
	}
  )*
  [
	{
	  inAction = true;
	}
    "finally" Block(vec)
	{
	  inAction = false;
	  finallyblk = vec;
	}
  ]
	{
	  makeTryBlock(t0, c, expch, types, ids, catchblks, finallyblk);
	}
|
  LOOKAHEAD(
    identifier()
  |
    StringLiteral()
  |
    "<"
  |
    PrimaryExpression() "="
  )
  [
    LOOKAHEAD(PrimaryExpression() "=")
	{
	  Token first = getToken(1);
	}
    PrimaryExpression()
	{
	  Token last = getToken(0);
	}
    "="
	{
	  t = first;
	  while (true) {
	    lhsTokens.addElement(t);
	    if (t == last) break;
	    t = t.next;
	  }
	}
  ]
  (
    regular_expression(c)
	{
	  ((RegularExpression)(c.member)).lhsTokens = lhsTokens;
	  add_inline_regexpr((RegularExpression)(c.member));
	}
  |
	{
	  nt = new NonTerminal();
	  t = getToken(1);
	  nt.line = t.beginLine;
	  nt.column = t.beginColumn;
	  nt.lhsTokens = lhsTokens;
	}
    name=identifier() Arguments(nt.argument_tokens)
	{
	  nt.name = name;
	  c.member = nt;
	}
  )
|
  t="(" expansion_choices(c) ")"
  (  "+"
	{
	  OneOrMore omexp = new OneOrMore();
	  omexp.line = t.beginLine;
	  omexp.column = t.beginColumn;
	  omexp.expansion = (Expansion)c.member;
	  ((Expansion)c.member).parent = omexp;
	  c.member = omexp;
	}
   | "*"
	{
	  ZeroOrMore zmexp = new ZeroOrMore();
	  zmexp.line = t.beginLine;
	  zmexp.column = t.beginColumn;
	  zmexp.expansion = (Expansion)c.member;
	  ((Expansion)c.member).parent = zmexp;
	  c.member = zmexp;
	}
   | "?"
	{
	  ZeroOrOne zoexp = new ZeroOrOne();
	  zoexp.line = t.beginLine;
	  zoexp.column = t.beginColumn;
	  zoexp.expansion = (Expansion)c.member;
	  ((Expansion)c.member).parent = zoexp;
	  c.member = zoexp;
	}
  )?
}

void regular_expression(Container c) :
	{
	  RStringLiteral strlit;
	  REndOfFile ef;
	  RJustName jn;
	  String image;
	  boolean private_rexp = false;
	  Token t = getToken(1);
	}
{
  image=StringLiteral()
	{
	  strlit = new RStringLiteral();
	  strlit.line = t.beginLine;
	  strlit.column = t.beginColumn;
	  strlit.image = image;
	  c.member = strlit;
	}
|
  LOOKAHEAD(3)
	{
	  image = "";
	}
  < LANGLE: "<" >
  [
    [ "#"
	{
	  private_rexp = true;
	}
    ]
    image=identifier() ":"
  ]
  complex_regular_expression_choices(c) < RANGLE: ">" >
	{
	  RegularExpression re;
	  if (c.member instanceof RJustName) {
	    RSequence seq = new RSequence();
	    seq.units.addElement(c.member);
	    re = seq;
	  } else {
	    re = (RegularExpression)c.member;
	  }
	  re.label = image;
	  re.private_rexp = private_rexp;
	  re.line = t.beginLine;
	  re.column = t.beginColumn;
	  c.member = re;
	}
|
  LOOKAHEAD(2)
  "<" image=identifier() ">"
	{
	  jn = new RJustName();
	  jn.line = t.beginLine;
	  jn.column = t.beginColumn;
	  jn.label = image;
	  c.member = jn;
	}
|
  "<" "EOF" ">"
	{
	  ef = new REndOfFile();
	  ef.line = t.beginLine;
	  ef.column = t.beginColumn;
	  ef.ordinal = 0;
	  c.member = ef;
	}
}

void complex_regular_expression_choices(Container c1) :
	{
	  boolean morethanone = false;
	  RChoice ch = null; // unnecessary initialization to make Java compiler happy!
	  Container c2 = new Container();
	}
{
  complex_regular_expression(c1)
  ( "|" complex_regular_expression(c2)
	{
	  if (morethanone) {
	    ch.choices.addElement(c2.member);
	  } else {
	    morethanone = true;
	    ch = new RChoice();
	    ch.line = ((RegularExpression)c1.member).line;
	    ch.column = ((RegularExpression)c1.member).column;
	    ch.choices.addElement(c1.member);
	    ch.choices.addElement(c2.member);
	  }
	}
  )*
	{
	  if (morethanone) {
	    c1.member = ch;
	  }
	}
}

void complex_regular_expression(Container c1) :
	{
	  int count = 0;
	  RSequence seq = null; // unnecessary initialization to make Java compiler happy!
	  Container c2 = new Container();
	}
{
  ( complex_regular_expression_unit(c2)
	{
	  count++;
	  if (count == 1) {
	    c1.member = c2.member; // if count does not go beyond 1, we are done.
	  } else if (count == 2) { // more than 1, so create a sequence.
	    seq = new RSequence();
	    seq.line = ((RegularExpression)c1.member).line;
	    seq.column = ((RegularExpression)c1.member).column;
	    seq.units.addElement(c1.member);
	    seq.units.addElement(c2.member);
	  } else {
	    seq.units.addElement(c2.member);
	  }
	}
  )+