Class Parser

java.lang.Object

org.openjdk.asmtools.jasm.ParseBase

org.openjdk.asmtools.jasm.Parser

class Parser
extends ParseBase

This class is used to parse Jasm statements and expressions. The result is a parse tree.

This class implements an operator precedence parser. Errors are reported to the Environment object, if the error can't be resolved immediately, a SyntaxError exception is thrown.

Error recovery is implemented by catching Scanner.SyntaxError exceptions and discarding input scanner.tokens until an input token is reached that is possibly a legal continuation.

The parse tree that is constructed represents the input exactly (no rewrites to simpler forms). This is important if the resulting tree is to be used for code formatting in a programming environment. Currently only documentation comments are retained.

A parser owns several components (scanner, constant-parser, instruction-parser, annotations-parser) to which it delegates certain parsing responsibilities. This parser contains functions to parse the overall form of a class, and any members (fields, methods, inner-classes).

Syntax errors, should always be caught inside the parser for error recovery.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	Parser.CompilerError	The main compile error for the parser
(package private) static interface	Parser.Method
(package private) static interface	Parser.NameSupplier

Field Summary

Fields

Modifier and Type	Field	Description
private ParserAnnotation	annotParser	other parser components
(package private) ClassData	cd
private ArrayList<AnnotationData>	clsAnnttns
private ArrayList<ClassData>	clsDataList
private ParserCP	cpParser
(package private) CodeAttr	curCode
private CFVersion	currentCFV
private boolean	explicitcp
private ParserInstr	instrParser
private ArrayList<AnnotationData>	memberAnnttns
private ModuleAttr	moduleAttribute
private String	pkg
private ArrayList<AnnotationData>	pkgAnnttns
private String	pkgPrefix
protected ConstantPool	pool

Fields inherited from class ParseBase

debugFlag, env, parser, scanner

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Parser(Environment sf, CFVersion cfVersion)	Create a parser

Method Summary

Modifier and Type	Method	Description
private void	checkReferenceIndex(int position, Tables.ConstType defaultTag, Tables.ConstType default2Tag)	Check the pair reference_kind:reference_index where reference_kind is any from: REF_invokeVirtual, REF_newInvokeSpecial, REF_invokeStatic, REF_invokeSpecial, REF_invokeInterface and reference_index is one of [Empty], Method or InterfaceMethod There are possible entries: ldc Dynamic REF_newInvokeSpecial:InterfaceMethod LdcConDyTwice."": ldc Dynamic REF_invokeInterface:LdcConDyTwice."": ldc Dynamic REF_newInvokeSpecial:Method LdcConDyTwice."": ldc MethodHandle REF_newInvokeSpecial:InterfaceMethod LdcConDyTwice."": ldc MethodHandle REF_invokeInterface:LdcConDyTwice."": ldc MethodHandle REF_newInvokeSpecial:Method LdcConDyTwice."": invokedynamic MethodHandle REF_invokeStatic:Method java/lang/invoke/StringConcatFactory.makeConcatWithConstants: invokedynamic MethodHandle REF_invokeStatic:java/lang/invoke/StringConcatFactory.makeConcatWithConstants ....
private int	countParams(ConstantPool.ConstCell sigCell)	Scan method's signature to determine size of parameters.
(package private) String	encodeClassString(String classname)
private void	endClass()	End class
private void	endModule()	End module
(package private) final ClassData[]	getClassesData()
private void	match(JasmTokens.Token open, JasmTokens.Token close)	The match() method is used to quickly match opening brackets (ie: '(', '{', or '[') with their closing counter part.
private void	parseClass(int mod)	Parse a class or interface declaration.
private void	parseClasses(Consumer<ArrayList<ConstantPool.ConstCell>> classesConsumer)	Parse a list of classes belonging to the [NestMembers | PermittedSubclasses] entry
private void	parseClassMembers()
(package private) ConstantPool.ConstCell	parseClassName(boolean uncond)
private void	parseConstDef()	Parse constant declaration
private void	parseCPXBootstrapMethod()	Parse a (CPX based) BootstrapMethod entry.
private void	parseField(int mod)	Parse a field.
(package private) void	parseFile()	Parse an Jasm file.
(package private) String	parseIdent()	Parse an internal name: identifier.
private void	parseInnerClass(int mod)	Parse an inner class.
private void	parseInnerClass_s1(int mod, ConstantPool.ConstCell nameCell, ConstantPool.ConstCell innerClass, ConstantPool.ConstCell outerClass)
private void	parseInnerClass_s2(int mod, ConstantPool.ConstCell nameCell, ConstantPool.ConstCell innerClass, ConstantPool.ConstCell outerClass)
private void	parseInnerClass_s3(int mod, ConstantPool.ConstCell nameCell, ConstantPool.ConstCell innerClass, ConstantPool.ConstCell outerClass)
(package private) Argument	parseInt(int size)	Parse a signed integer of size bytes long.
private void	parseJasmPackages()	Determines whether the JASM file is for a package-info class or for a module-info class.
(package private) void	parseLocVarDef()	Parse a local variable
(package private) void	parseLocVarEnd()
(package private) Argument	parseLocVarRef()
(package private) void	parseMapItem(DataVector map)
private void	parseMethod(int mod)	Parse a method.
(package private) ConstantPool.ConstCell	parseMethodHandle(Tables.SubTag subtag)	Parses a field or method reference for method handle.
private void	parseModule()	Parse a module declaration.
private String	parseModuleName()	Parses a module name in a module statement(s)
(package private) ConstantPool.ConstCell	parseName()	Parse an external name: CPINDEX, string, or identifier.
private void	parseNestHost()	Parse a NestHost entry
private void	parseRecord()	Parse the Record entry
(package private) Tables.SubTag	parseSubtag()	Parses a sub-tag value in method handle.
private String	parseTypeName()	Parses a package or type name in a module statement(s)
(package private) Argument	parseUInt(int size)	Parse an unsigned integer of size bytes long.
private void	parseVersion()
private void	parseVersionPkg()	Parses version in package statements
private void	pic_error()
private void	pic_tracecreate(int mod, ConstantPool.ConstCell nameCell, ConstantPool.ConstCell innerClass, ConstantPool.ConstCell outerClass)
private String	prependPackage(String className, boolean uncond)
private void	recoverField()	Recover after a syntax error in a field.
private void	recoverFile()	Recover after a syntax error in the file.
private HashSet<String>	scanList(Parser.Method scanMethod, Parser.NameSupplier target, String err, boolean onlyOneElement)	Scans the "to" or "with" part of ModuleStatement: exports PackageName [to ModuleName {, ModuleName}] ;, opens packageName [to ModuleName {, ModuleName}] ; provides TypeName with TypeName [,typeName] ; uses TypeName; : [ModuleName {, ModuleName}]; , [TypeName [,typeName]]; or TypeName;
private int	scanModifier(int mod)	Parse the modifiers
(package private) int	scanModifiers()
private void	scanRequires(BiConsumer<String,Integer> action)	Scans ModuleStatement: requires [transitive] [static] ModuleName ;
private void	scanStatement(BiConsumer<String, Set<String>> action, Parser.NameSupplier source, Parser.NameSupplier target, JasmTokens.Token startList, boolean emptyListAllowed, String err)	Scans Module Statement(s): exports packageName [to ModuleName {, ModuleName}] ; opens packageName [to ModuleName {, ModuleName}] ; provides TypeName with TypeName [,typeName] ;
private void	scanStatement(Consumer<Set<String>> action, String err)	Scans ModuleStatement: uses TypeName;
(package private) void	setDebugFlags(boolean debugScanner, boolean debugMembers, boolean debugCP, boolean debugAnnot, boolean debugInstr)

Methods inherited from class ParseBase

debugScan, debugStr, enableDebug, init

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

pool

protected ConstantPool pool

cd

ClassData cd

curCode

CodeAttr curCode

clsDataList

private ArrayList<ClassData> clsDataList

pkg

private String pkg

pkgPrefix

private String pkgPrefix

pkgAnnttns

private ArrayList<AnnotationData> pkgAnnttns

clsAnnttns

private ArrayList<AnnotationData> clsAnnttns

memberAnnttns

private ArrayList<AnnotationData> memberAnnttns

explicitcp

private boolean explicitcp

moduleAttribute

private ModuleAttr moduleAttribute

currentCFV

private CFVersion currentCFV

annotParser

private ParserAnnotation annotParser

other parser components

cpParser

private ParserCP cpParser

instrParser

private ParserInstr instrParser

Constructor Details

Parser

protected Parser(Environment sf,
 CFVersion cfVersion)
          throws IOException

Create a parser

Throws:

IOException

Method Details

setDebugFlags

void setDebugFlags(boolean debugScanner,
 boolean debugMembers,
 boolean debugCP,
 boolean debugAnnot,
 boolean debugInstr)

encodeClassString

String encodeClassString(String classname)

parseVersionPkg

private void parseVersionPkg()
                      throws IOException

Parses version in package statements

Throws:

IOException

parseVersion

private void parseVersion()
                   throws IOException

Throws:

IOException

parseIdent

String parseIdent()
           throws Scanner.SyntaxError,
IOException

Parse an internal name: identifier.

Throws:

Scanner.SyntaxError

IOException

parseLocVarDef

void parseLocVarDef()
             throws Scanner.SyntaxError,
IOException

Parse a local variable

Throws:

Scanner.SyntaxError

IOException

parseLocVarRef

Argument parseLocVarRef()
                 throws Scanner.SyntaxError,
IOException

Throws:

Scanner.SyntaxError

IOException

parseLocVarEnd

void parseLocVarEnd()
             throws Scanner.SyntaxError,
IOException

Throws:

Scanner.SyntaxError

IOException

parseMapItem

void parseMapItem(DataVector map)
           throws Scanner.SyntaxError,
IOException

Throws:

Scanner.SyntaxError

IOException

parseName

ConstantPool.ConstCell parseName()
                          throws Scanner.SyntaxError,
IOException

Parse an external name: CPINDEX, string, or identifier.

Throws:

Scanner.SyntaxError

IOException

parseMethodHandle

ConstantPool.ConstCell parseMethodHandle(Tables.SubTag subtag)
                                  throws Scanner.SyntaxError,
IOException

Parses a field or method reference for method handle.

Throws:

Scanner.SyntaxError

IOException

checkReferenceIndex

private void checkReferenceIndex(int position,
 Tables.ConstType defaultTag,
 Tables.ConstType default2Tag)

Check the pair reference_kind:reference_index where reference_kind is any from: REF_invokeVirtual, REF_newInvokeSpecial, REF_invokeStatic, REF_invokeSpecial, REF_invokeInterface and reference_index is one of [Empty], Method or InterfaceMethod There are possible entries: ldc Dynamic REF_newInvokeSpecial:InterfaceMethod LdcConDyTwice."": ldc Dynamic REF_invokeInterface:LdcConDyTwice."": ldc Dynamic REF_newInvokeSpecial:Method LdcConDyTwice."": ldc MethodHandle REF_newInvokeSpecial:InterfaceMethod LdcConDyTwice."": ldc MethodHandle REF_invokeInterface:LdcConDyTwice."": ldc MethodHandle REF_newInvokeSpecial:Method LdcConDyTwice."": invokedynamic MethodHandle REF_invokeStatic:Method java/lang/invoke/StringConcatFactory.makeConcatWithConstants: invokedynamic MethodHandle REF_invokeStatic:java/lang/invoke/StringConcatFactory.makeConcatWithConstants ....

Parameters:

position - the position in a source file

defaultTag - expected reference_index tag (Method or InterfaceMethod)

defaultTag - 2nd expected reference_index tag (Method or InterfaceMethod)

parseSubtag

Tables.SubTag parseSubtag()
                   throws Scanner.SyntaxError,
IOException

Parses a sub-tag value in method handle.

Throws:

Scanner.SyntaxError

IOException

parseClassName

ConstantPool.ConstCell parseClassName(boolean uncond)
                               throws Scanner.SyntaxError,
IOException

Throws:

Scanner.SyntaxError

IOException

prependPackage

private String prependPackage(String className,
 boolean uncond)

parseInt

Argument parseInt(int size)
           throws Scanner.SyntaxError,
IOException

Parse a signed integer of size bytes long. size = 1 or 2

Throws:

Scanner.SyntaxError

IOException

parseUInt

Argument parseUInt(int size)
            throws Scanner.SyntaxError,
IOException

Parse an unsigned integer of size bytes long. size = 1 or 2

Throws:

Scanner.SyntaxError

IOException

parseConstDef

private void parseConstDef()
                    throws IOException

Parse constant declaration

Throws:

IOException

scanModifier

private int scanModifier(int mod)
                  throws IOException

Parse the modifiers

Throws:

IOException

scanModifiers

int scanModifiers()
           throws IOException

Throws:

IOException

parseField

private void parseField(int mod)
                 throws Scanner.SyntaxError,
IOException

Parse a field.

Throws:

Scanner.SyntaxError

IOException

countParams

private int countParams(ConstantPool.ConstCell sigCell)
                 throws Scanner.SyntaxError

Scan method's signature to determine size of parameters.

Throws:

Scanner.SyntaxError

parseMethod

private void parseMethod(int mod)
                  throws Scanner.SyntaxError,
IOException

Parse a method.

Throws:

Scanner.SyntaxError

IOException

parseCPXBootstrapMethod

private void parseCPXBootstrapMethod()
                              throws Scanner.SyntaxError,
IOException

Parse a (CPX based) BootstrapMethod entry.

Throws:

Scanner.SyntaxError

IOException

parseNestHost

private void parseNestHost()
                    throws Scanner.SyntaxError,
IOException

Parse a NestHost entry

Throws:

Scanner.SyntaxError

IOException

parseClasses

private void parseClasses(Consumer<ArrayList<ConstantPool.ConstCell>> classesConsumer)
                   throws Scanner.SyntaxError,
IOException

Parse a list of classes belonging to the [NestMembers | PermittedSubclasses] entry

Throws:

Scanner.SyntaxError

IOException

parseRecord

private void parseRecord()
                  throws Scanner.SyntaxError,
IOException

Parse the Record entry

Throws:

Scanner.SyntaxError

IOException

parseInnerClass

private void parseInnerClass(int mod)
                      throws Scanner.SyntaxError,
IOException

Parse an inner class.

Throws:

Scanner.SyntaxError

IOException

parseInnerClass_s1

private void parseInnerClass_s1(int mod,
 ConstantPool.ConstCell nameCell,
 ConstantPool.ConstCell innerClass,
 ConstantPool.ConstCell outerClass)
                         throws IOException

Throws:

IOException

parseInnerClass_s2

private void parseInnerClass_s2(int mod,
 ConstantPool.ConstCell nameCell,
 ConstantPool.ConstCell innerClass,
 ConstantPool.ConstCell outerClass)
                         throws IOException

Throws:

IOException

parseInnerClass_s3

private void parseInnerClass_s3(int mod,
 ConstantPool.ConstCell nameCell,
 ConstantPool.ConstCell innerClass,
 ConstantPool.ConstCell outerClass)
                         throws IOException

Throws:

IOException

pic_tracecreate

private void pic_tracecreate(int mod,
 ConstantPool.ConstCell nameCell,
 ConstantPool.ConstCell innerClass,
 ConstantPool.ConstCell outerClass)

pic_error

private void pic_error()

match

private void match(JasmTokens.Token open,
 JasmTokens.Token close)
            throws IOException

The match() method is used to quickly match opening brackets (ie: '(', '{', or '[') with their closing counter part. This is useful during error recovery.

Scan to a matching '}', ']' or ')'. The current scanner.token must be a '{', '[' or '(';

Throws:

IOException

recoverField

private void recoverField()
                   throws Scanner.SyntaxError,
IOException

Recover after a syntax error in a field. This involves discarding scanner.tokens until an EOF or a possible legal continuation is encountered.

Throws:

Scanner.SyntaxError

IOException

parseClass

private void parseClass(int mod)
                 throws IOException

Parse a class or interface declaration.

Throws:

IOException

parseTypeName

private String parseTypeName()
                      throws IOException

Parses a package or type name in a module statement(s)

Throws:

IOException

parseModuleName

private String parseModuleName()
                        throws IOException

Parses a module name in a module statement(s)

Throws:

IOException

parseModule

private void parseModule()
                  throws IOException

Parse a module declaration.

Throws:

IOException

scanRequires

private void scanRequires(BiConsumer<String,Integer> action)
                   throws IOException

Scans ModuleStatement: requires [transitive] [static] ModuleName ;

Throws:

IOException

scanStatement

private void scanStatement(Consumer<Set<String>> action,
 String err)
                    throws IOException

Scans ModuleStatement: uses TypeName;

Throws:

IOException

scanStatement

private void scanStatement(BiConsumer<String, Set<String>> action,
 Parser.NameSupplier source,
 Parser.NameSupplier target,
 JasmTokens.Token startList,
 boolean emptyListAllowed,
 String err)
                    throws IOException

Scans Module Statement(s): exports packageName [to ModuleName {, ModuleName}] ; opens packageName [to ModuleName {, ModuleName}] ; provides TypeName with TypeName [,typeName] ;

Throws:

IOException

scanList

private HashSet<String> scanList(Parser.Method scanMethod,
 Parser.NameSupplier target,
 String err,
 boolean onlyOneElement)
                          throws IOException

Scans the "to" or "with" part of ModuleStatement: exports PackageName [to ModuleName {, ModuleName}] ;, opens packageName [to ModuleName {, ModuleName}] ; provides TypeName with TypeName [,typeName] ; uses TypeName; : [ModuleName {, ModuleName}]; , [TypeName [,typeName]]; or TypeName;

Throws:

IOException

parseClassMembers

private void parseClassMembers()
                        throws IOException

Throws:

IOException

recoverFile

private void recoverFile()
                  throws IOException

Recover after a syntax error in the file. This involves discarding scanner.tokens until an EOF or a possible legal continuation is encountered.

Throws:

IOException

endClass

private void endClass()

End class

endModule

private void endModule()

End module

getClassesData

final ClassData[] getClassesData()

parseJasmPackages

private void parseJasmPackages()
                        throws IOException

Determines whether the JASM file is for a package-info class or for a module-info class.

creates the correct kind of ClassData accordingly.

Throws:

IOException

parseFile

void parseFile()

Parse an Jasm file.