ESC/Java2
© 2003,2004,2005 David Cok and Joseph Kiniry
© 2005 UCD Dublin
© 2003,2004 Radboud University Nijmegen
© 1999,2000 Compaq Computer Corporation
© 1997,1998,1999 Digital Equipment Corporation
All Rights Reserved

Uses of Class
javafe.parser.Lex

Packages that use Lex
escjava.parser   
javafe.parser   
javafe.reader   
 

Uses of Lex in escjava.parser
 

Subclasses of Lex in escjava.parser
 class EscPragmaLex
          This lexer overrides scanJavaExtensions(int) to support "informal predicates".
 

Methods in escjava.parser with parameters of type Lex
protected  Expr EscPragmaParser.parsePrimaryExpression(Lex l)
          Parse a "primary expression" from l.
protected  Expr EscPragmaParser.parsePrimarySuffix(Lex l, Expr primary)
          Parse the suffix of a "primary expression" from l, given the prefix primary expression primary.
private  GCExpr EscPragmaParser.parseQuantifierRemainder(Lex l, int tag, Type type, int loc)
          Parse the balance (everything after the quantifier to the end of the current quantified scope) of a quantifier expression from l.
 PrimitiveType EscPragmaParser.parsePrimitiveType(Lex l)
          Parses a PrimitiveType.
 FormalParaDeclVec EscPragmaParser.parseFormalParameterList(Lex l)
           
protected  void EscPragmaParser.addStmt(Lex l)
           
protected  TypeDeclElem EscPragmaParser.parseTypeDeclElemIntoSeqTDE(Lex l, int keyword, Identifier containerId, boolean specOnly)
           
protected  TypeDecl EscPragmaParser.parseTypeDeclTail(Lex l, boolean specOnly, int loc, int modifiers, ModifierPragmaVec modifierPragmas)
           
 Expr EscPragmaParser.parseMapsMemberFieldRef(Lex scanner)
           
 

Uses of Lex in javafe.parser
 

Fields in javafe.parser declared as Lex
private  Lex Parse.parseStreamLexer
           
 

Methods in javafe.parser with parameters of type Lex
 void ParseUtil.expect(Lex l, int expected)
          Takes an expected token from the input stream, calls fail on error.
 ModifierPragmaVec ParseUtil.parseModifierPragmas(Lex l)
          Parse a list of modifier pragmas.
 ModifierPragmaVec ParseUtil.parseMoreModifierPragmas(Lex l, ModifierPragmaVec orig)
          Parse a list of modifier pragmas and adds them to an existing ModifierPragmaVec.
 int ParseUtil.parseModifiers(Lex l)
          Parse a list of modifiers.
 int ParseUtil.getJavaModifier(Lex l, int modifiers)
          Checks if the next token is a Java modifier.
 Identifier ParseType.parseIdentifier(Lex l)
          Parse an Identifier.
 Name ParseType.parseName(Lex l)
          Parse a Name.
 TypeName ParseType.parseTypeName(Lex l)
          Parse a TypeName.
 Type ParseType.parseBracketPairs(Lex l, Type type)
          Parse square bracket pairs.
 TypeModifierPragmaVec ParseType.parseTypeModifierPragmas(Lex l)
           
 PrimitiveType ParseType.parsePrimitiveType(Lex l)
          Parses a PrimitiveType.
 Type ParseType.parsePrimitiveTypeOrTypeName(Lex l)
          Parse a type, either a primitive type, a type name, but not an array type.
 Type ParseType.parseType(Lex l)
          Parse a Type, either a primitive type, a type name, or an array type.
(package private) abstract  TypeDecl ParseStmt.parseTypeDeclTail(Lex l, boolean specOnly, int loc, int modifiers, ModifierPragmaVec modifierPragmas)
          Parse a type declaration stating at the class/interface keyword.
 Stmt ParseStmt.parseStatement(Lex l)
          Method for parsing a Stmt.
protected  void ParseStmt.addStmt(Lex l)
          Internal method for parsing a Stmt.
 BlockStmt ParseStmt.parseConstructorBody(Lex l)
          Method for parsing a ConstructorBody.
 BlockStmt ParseStmt.parseBlock(Lex l, boolean specOnly)
          Method for parsing a Block.
private  ForStmt ParseStmt.parseForStmt(Lex l, int keywordloc)
          Internal method for parsing a switch statement.
private  SwitchStmt ParseStmt.parseSwitchStmt(Lex l, int keywordloc)
          Internal method for parsing a switch statement.
private  CatchClauseVec ParseStmt.parseCatches(Lex l)
          Internal routine for parsing zero or more catch clauses.
private  void ParseStmt.addVarDeclStmts(Lex l, int modifiers, ModifierPragmaVec modifierPragmas, Type basetype)
          Internal routine for parsing variable declarations after the leading type has been parsed.
 FormalParaDecl ParseStmt.parseFormalParaDecl(Lex l)
          Routine for parsing a single formal parameter declarations.
(package private) abstract  TypeDeclElem ParseExpr.parseTypeDeclElemIntoSeqTDE(Lex l, int keyword, Identifier containerId, boolean specOnly)
          Parse an element of a type declaration into "seq".
 Expr ParseExpr.parseExpression(Lex l)
          Parse an Expression.
 Expr ParseExpr.parseUnaryExpression(Lex l)
          Parse a UnaryExpression.
 Expr ParseExpr.parseCastExpression(Lex l)
          Parse a CastExpression.
protected  Expr ParseExpr.parsePrimaryExpression(Lex l)
          Parse a PrimaryExpression.
protected  Expr ParseExpr.parseClassLiteralSuffix(Lex l, Type t)
          parses '. class', then produces a class literal expression using Type t.
protected  Expr ParseExpr.parsePrimarySuffix(Lex l, Expr primary)
           
 Expr ParseExpr.parseNewExpression(Lex l)
          Parse a NewExpression.
 Expr ParseExpr.parseNewExpressionTail(Lex l, Type type, int locNew)
           
 ExprVec ParseExpr.parseArgumentList(Lex l)
          Parse an ArgumentList, which includes enclosing parens.
 ExprVec ParseExpr.parseExpressionList(Lex l, int terminator)
          Parse an ExpressionList.
 Name ParseExpr.parseSuper(Lex l)
          Parse super.
 VarInit ParseExpr.parseVariableInitializer(Lex l, boolean specOnly)
          Parse VariableInitializer.
 ArrayInit ParseExpr.parseArrayInitializer(Lex l)
           
 CompilationUnit Parse.parseCompilationUnit(Lex l, boolean specOnly)
          Parse a CompilationUnit.
protected  ImportDecl Parse.parseImportDeclaration(Lex l)
          Parse an ImportDeclaration.
protected  TypeDecl Parse.parseTypeDeclaration(Lex l, boolean specOnly)
          Parse a TypeDeclaration (ie a class or interface declaration).
protected  TypeDecl Parse.parseTypeDeclaration(Lex l, boolean specOnly, int modifiers, ModifierPragmaVec modifierPragmas, int loc)
           
protected  TypeDecl Parse.parseTypeDeclTail(Lex l, boolean specOnly, int loc, int modifiers, ModifierPragmaVec modifierPragmas)
          Parse a TypeDeclTail (ie a class or interface declaration starting at the keyword 'class' or 'interface').
private  boolean Parse.atStartOfConstructorOrMethod(Lex l)
          checks for X TypeModifierPragma* ( in the input stream.
protected  TypeNameVec Parse.parseTypeNames(Lex l, int keyword)
          Parse a keyword, followed by a comma-separated list of TypeNames.
protected  TypeDeclElem Parse.parseTypeDeclElemIntoSeqTDE(Lex l, int keyword, Identifier containerId, boolean specOnly)
          Parse a TypeDeclElem, which is either a field, method, or constructor declaration, a static block, or a TypeDecl [1.1].
 FormalParaDeclVec Parse.parseFormalParameterList(Lex l)
          Parse a FormalParameterList, which includes enclosing parens.
 

Uses of Lex in javafe.reader
 

Fields in javafe.reader declared as Lex
private  Lex SrcReader.readLex
          * Creation: * *
 


ESC/Java2
© 2003,2004,2005 David Cok and Joseph Kiniry
© 2005 UCD Dublin
© 2003,2004 Radboud University Nijmegen
© 1999,2000 Compaq Computer Corporation
© 1997,1998,1999 Digital Equipment Corporation
All Rights Reserved

The ESC/Java2 Project Homepage