Uses of Class
eu.bandm.tools.ramus.runtime2.Expression

Packages that use Expression

Package	Description
eu.bandm.tools.d2d2.parser2
eu.bandm.tools.lljava.codec
eu.bandm.tools.lljava.parser
eu.bandm.tools.ramus.runtime2
eu.bandm.tools.tpath.parser2

Uses of Expression in eu.bandm.tools.d2d2.parser2

Fields in eu.bandm.tools.d2d2.parser2 declared as Expression

Modifier and Type	Field	Description
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,CharSetConst>	Parser2.charset	Accepts and decodes char set constants given as text in single quotes.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,CharSetConst>	Parser2.charset_dez	Accepts and decodes char set constants given as decimal number.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,CharSetConst>	Parser2.charset_hex	Accepts and decodes char set constants given as hex number.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,String>	Parser2.charStringContents	Accepts and decodes string constants, which is the contents between double quotes.
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.defaultDef
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.defaultGroup
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>>	Parser2.definitionBody
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.documentation
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Unit>	Parser2.editspec
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>>	Parser2.enumDecl
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Boolean>	Parser2.globaltrimming
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.grammarExpr	Accepts and decodes top level grammar expressions.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,String>	Parser2.identifier	Accepts and decodes identifiers, which includes keywords and identifiers from the lexer world.
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.importcmd
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<XRegExp>>	Parser2.inputspec
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Object>	Parser2.manglingRule
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.modline
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.module
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.namespacedecl	NamespaceDecls are stored only in the "Module" model element.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<XRegExp>>	Parser2.postprocessor
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Reference>	Parser2.reference	Accepts and decodes references, which are identifiers separated by dots.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,StringConst>	Parser2.stringconst	Accepts and decodes string constants, which is the contents between double quotes.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,StringConst>	Parser2.stringconstChecked	Accepts and decodes string constants not containing newline and tab characters.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.top
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.x_defaultDef
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.x_reference	Accepts and constructs model element for identifier plus an "implicit" prefix.
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Parser2.XmlSpecConsumer>	Parser2.xmlspec	Parse, accept and set the corresponding fields of a model element Definition according to '[with ..] xmlrep (trimmed|untrimmed)? (data)? (el|att)? (= "nspref:tag" "value"?)? '

Methods in eu.bandm.tools.d2d2.parser2 that return Expression

Modifier and Type	Method	Description
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_000(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes lowest level grammar expressions.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_002(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Parse greedy and insert prefix sequence as in "@ @ > > (a, b)".
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_004(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes char set cut expression "e1 A e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_006(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes char set join expression "e1 U e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_008(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes char set minus expression "e1 - e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.charParserWrapper(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)
protected static <A> Expression<XMLDocumentIdentifier,D2dLexer.TokenType,A>	Parser2.constant(D2dLexer.TokenType type, A value)	Delivers an Expression, which accepts the given token type, and reduces to the given value (the location is preserved).
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Optional<List<eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<XRegExp>>>>	Parser2.declModifiers(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>> p_definitionBody)
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decor_002(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes tight sequence "e1 ~ e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decor_004(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes permutation "e1 & e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decor_006(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes non-tight sequence "e1 , e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decor_008(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes alternative "e1 | e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decorated(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes decorated expression "e1? / + / * / +~ / *~"
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.defaultGroup(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>> p_defaultGroup)
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>>	Parser2.definitionBody(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>> p_definitionBody)	DOCME
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.grammarExpr(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> p_grammarExpr)	Accepts and decodes top level grammar expressions.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<XRegExp>>	Parser2.localnodes(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>> p_definitionBody)
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.module(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>> p_module)	Accepts and decodes a "module" declaration.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.postGreedy(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes decorated expression "e1? / + / * / +~ / *~"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.range(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes next-to-lowest level grammar expressions.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.substituted(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes substituted expression "e1 ^(e2/i2) ^(e3/i3).."
protected static Expression<XMLDocumentIdentifier,D2dLexer.TokenType,D2dLexer.TokenType>	Parser2.tokenType(D2dLexer.TokenType... types)	DOCME
protected static Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Content<XMLDocumentIdentifier,D2dLexer.TokenType>>	Parser2.unparsedLiteral(D2dLexer.TokenType... types)	Auxiliary function, gives necessary constraints to type inference.
protected static Expression<XMLDocumentIdentifier,D2dLexer.TokenType,String>	Parser2.unparsedLiteralText(D2dLexer.TokenType... types)

Methods in eu.bandm.tools.d2d2.parser2 with parameters of type Expression

Modifier and Type	Method	Description
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_000(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes lowest level grammar expressions.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_002(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Parse greedy and insert prefix sequence as in "@ @ > > (a, b)".
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_004(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes char set cut expression "e1 A e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_006(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes char set join expression "e1 U e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.atom_008(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes char set minus expression "e1 - e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.charParserWrapper(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Optional<List<eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<XRegExp>>>>	Parser2.declModifiers(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>> p_definitionBody)
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decor_002(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes tight sequence "e1 ~ e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decor_004(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes permutation "e1 & e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decor_006(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes non-tight sequence "e1 , e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decor_008(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes alternative "e1 | e2"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.decorated(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes decorated expression "e1? / + / * / +~ / *~"
(package private) static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.defaultGroup(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>> p_defaultGroup)
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>>	Parser2.definitionBody(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>> p_definitionBody)	DOCME
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.grammarExpr(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> p_grammarExpr)	Accepts and decodes top level grammar expressions.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<XRegExp>>	Parser2.localnodes(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<SourceItem>> p_definitionBody)
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>>	Parser2.module(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,eu.bandm.tools.d2d2.parser2.Parser2.XConsumer<Module>> p_module)	Accepts and decodes a "module" declaration.
static <R> R	Parser2.parse_nonterminal(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,R> nonterminal, Reader reader, MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg, int tracelevel, String sourceIndication)	Service Access Point for parsing a particular non-terminal.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.postGreedy(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes decorated expression "e1? / + / * / +~ / *~"
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.range(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes next-to-lowest level grammar expressions.
static final Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression>	Parser2.substituted(Expression<XMLDocumentIdentifier,D2dLexer.TokenType,Expression> grammarExpr)	Accepts and decodes substituted expression "e1 ^(e2/i2) ^(e3/i3).."

Uses of Expression in eu.bandm.tools.lljava.codec

Fields in eu.bandm.tools.lljava.codec declared as Expression

Modifier and Type	Field	Description
static final Expression<SourceId,SignatureParser.TokenType,LLJava.PrimitiveTypeExpr>	SignatureParser.baseType
final Expression<SourceId,SignatureParser.TokenType,Consumer<LLJava.Class>>	SignatureParser.classSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.classTypeSignature
final Expression<SourceId,SignatureParser.TokenType,Consumer<LLJava.Field>>	SignatureParser.fieldSignature
final Expression<SourceId,SignatureParser.TokenType,String>	SignatureParser.identifier
final Expression<SourceId,SignatureParser.TokenType,LLJava.TypeExpr>	SignatureParser.javaTypeSignature
final Expression<SourceId,SignatureParser.TokenType,Consumer<LLJava.Method>>	SignatureParser.methodSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr>	SignatureParser.referenceTypeSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.ResultExpr>	SignatureParser.resultSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.throwsSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.TypeParameter>	SignatureParser.typeParameter
final Expression<SourceId,SignatureParser.TokenType,List<LLJava.TypeParameter>>	SignatureParser.typeParameters
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.typeVariableSignature
final Expression<SourceId,SignatureParser.TokenType,LLJava.VoidExpr>	SignatureParser.voidSignature

Methods in eu.bandm.tools.lljava.codec that return Expression

Modifier and Type	Method	Description
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.classTypeSignature(Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr> referenceTypeSignature)
final Expression<SourceId,SignatureParser.TokenType,List<LLJava.TypeArgument>>	SignatureParser.typeArguments(Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr> referenceTypeSignature)

Methods in eu.bandm.tools.lljava.codec with parameters of type Expression

Modifier and Type	Method	Description
final Expression<SourceId,SignatureParser.TokenType,LLJava.ClassTypeExpr>	SignatureParser.classTypeSignature(Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr> referenceTypeSignature)
protected <A> void	SignatureParser.parseSignature(String signature, Expression<SourceId,SignatureParser.TokenType,Consumer<A>> expr, A target)
final Expression<SourceId,SignatureParser.TokenType,List<LLJava.TypeArgument>>	SignatureParser.typeArguments(Expression<SourceId,SignatureParser.TokenType,LLJava.ReferenceTypeExpr> referenceTypeSignature)

Uses of Expression in eu.bandm.tools.lljava.parser

Fields in eu.bandm.tools.lljava.parser declared as Expression

Modifier and Type	Field	Description
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AbstractMethodBody>	LLJavaGrammar.abstractMethodBody
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation>	LLJavaGrammar.annotation
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ArrayAccess>	LLJavaGrammar.arrayExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeExpr>	LLJavaGrammar.baseType
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block>	LLJavaGrammar.block
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.BooleanLiteral>	LLJavaGrammar.booleanLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Cast>	LLJavaGrammar.castInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CharLiteral>	LLJavaGrammar.charLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassAnnotationValue>	LLJavaGrammar.classAnnotationValue
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Class>	LLJavaGrammar.classDefinition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassExpr>	LLJavaGrammar.classLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassReference>	LLJavaGrammar.classReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr>	LLJavaGrammar.classType
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Cmp>	LLJavaGrammar.cmpInstruction
final Expression<SourceId,LLJavaLexer.TokenType,Boolean>	LLJavaGrammar.cmpOperator
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodeMethodBody>	LLJavaGrammar.codeMethodBody
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Condition>	LLJavaGrammar.condition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ConstantAnnotationValue>	LLJavaGrammar.constantAnnotationValue
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DefaultMethodBody>	LLJavaGrammar.defaultMethodBody
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DimensionExpr>	LLJavaGrammar.dimensionExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DoubleLiteral>	LLJavaGrammar.doubleLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.EnumAnnotationValue>	LLJavaGrammar.enumAnnotationValue
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.ClassReference>>	LLJavaGrammar.exceptions
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Field>	LLJavaGrammar.fieldDefinition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.FieldReference>	LLJavaGrammar.fieldReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.FloatLiteral>	LLJavaGrammar.floatLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Get>	LLJavaGrammar.getInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Goto>	LLJavaGrammar.gotoInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.GotoInterval>	LLJavaGrammar.gotoInterval
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.GotoPoint>	LLJavaGrammar.gotoReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Id>	LLJavaGrammar.id
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Inc>	LLJavaGrammar.incInstruction
final Expression<SourceId,LLJavaLexer.TokenType,Optional<LLJava.Literal>>	LLJavaGrammar.initializer
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Instanceof>	LLJavaGrammar.instanceofInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.IntLiteral>	LLJavaGrammar.intLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation>	LLJavaGrammar.invisibleAnnotation
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Invoke>	LLJavaGrammar.invokeInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Invoke>	LLJavaGrammar.invokeInstructionNonrecursive
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Label>	LLJavaGrammar.label
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Literal>	LLJavaGrammar.literal
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr>	LLJavaGrammar.loadable
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadArgument>	LLJavaGrammar.loadArgument
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Load>	LLJavaGrammar.loadInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Name>	LLJavaGrammar.localName
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Local>	LLJavaGrammar.localVariable
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LongLiteral>	LLJavaGrammar.longLiteral
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.Class>>	LLJavaGrammar.main
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Member>	LLJavaGrammar.memberDefinition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberDynamicName>	LLJavaGrammar.memberDynamicName
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberFullName>	LLJavaGrammar.memberFullName
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberStaticName>	LLJavaGrammar.memberStaticName
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodBody>	LLJavaGrammar.methodBody
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Method>	LLJavaGrammar.methodDefinition
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodHandleExpr>	LLJavaGrammar.methodHandle
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodHandleTarget>	LLJavaGrammar.methodHandleTarget
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Parameter>	LLJavaGrammar.methodParameter
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.Parameter>>	LLJavaGrammar.methodParameters
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodReference>	LLJavaGrammar.methodReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodReference>	LLJavaGrammar.methodReferenceNonrecursive
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodReferenceParameter>	LLJavaGrammar.methodReferenceParameter
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MethodTypeExpr>	LLJavaGrammar.methodType
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Modifier>	LLJavaGrammar.modifier
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ModifierExpr>	LLJavaGrammar.modifierExpr
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.ModifierExpr>>	LLJavaGrammar.modifiers
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.New>	LLJavaGrammar.newInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.NullLiteral>	LLJavaGrammar.nullLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJavaLexer.TokenType>	LLJavaGrammar.operator
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.PrimitiveType>	LLJavaGrammar.primitiveType
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.PrimitiveTypeExpr>	LLJavaGrammar.primitiveTypeExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Put>	LLJavaGrammar.putInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.QualId>	LLJavaGrammar.qualId
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.QualId>	LLJavaGrammar.qualifier
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ResultExpr>	LLJavaGrammar.result
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ReturnsExpr>	LLJavaGrammar.returnsResult
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.SimpleModifierExpr>	LLJavaGrammar.simpleModifierExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.StoreArgument>	LLJavaGrammar.storeArgument
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Store>	LLJavaGrammar.storeInstruction
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.StringLiteral>	LLJavaGrammar.stringLiteral
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassReference>	LLJavaGrammar.superclass
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.ClassReference>>	LLJavaGrammar.superinterfaces
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.This>	LLJavaGrammar.thisExpr
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeExpr>	LLJavaGrammar.type
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeParameter>	LLJavaGrammar.typeParameter
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.TypeParameter>>	LLJavaGrammar.typeParameters
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.VariableRef>	LLJavaGrammar.variableReference
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.VoidExpr>	LLJavaGrammar.voidResult

Methods in eu.bandm.tools.lljava.parser that return Expression

Modifier and Type	Method	Description
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.angle(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation>	LLJavaGrammar.annotation(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation, Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue> annotationValue)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ArrayAnnotationValue>	LLJavaGrammar.arrayAnnotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue> annotationValue)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block>	LLJavaGrammar.block(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.brace(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.bracket(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Handler>	LLJavaGrammar.catchHandler(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr>	LLJavaGrammar.classType(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodeInterval>	LLJavaGrammar.codeInterval(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodePoint>	LLJavaGrammar.codeReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,List<A>>	LLJavaGrammar.comma(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected Expression<SourceId,LLJavaLexer.TokenType,Void>	LLJavaGrammar.command(LLJavaLexer.TokenType type)
protected <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.command(LLJavaLexer.TokenType type, Expression<SourceId,LLJavaLexer.TokenType,A> operand)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.constant(LLJavaLexer.TokenType type, A value)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DynamicExpr>	LLJavaGrammar.dynamicReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,Map.Entry<LLJava.Id,LLJava.AnnotationValue>>	LLJavaGrammar.elementValuePair(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,List<Map.Entry<LLJava.Id,LLJava.AnnotationValue>>>	LLJavaGrammar.elementValuePairs(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
protected Expression<SourceId,LLJavaLexer.TokenType,Boolean>	LLJavaGrammar.flag(LLJavaLexer.TokenType type, Parser.Pragma... pragmas)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.If>	LLJavaGrammar.ifInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.InlineInterval>	LLJavaGrammar.inlineInterval(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.InlinePoint>	LLJavaGrammar.inlineReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Instruction>	LLJavaGrammar.instruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr>	LLJavaGrammar.loadable(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LowerTypeBound>	LLJavaGrammar.lowerTypeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberDynamicName>	LLJavaGrammar.memberDynamicName(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.NestedAnnotationValue>	LLJavaGrammar.nestedAnnotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.paren(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected <A1, A2, R extends LLJava.Node> Expression<SourceId,LLJavaLexer.TokenType,R>	LLJavaGrammar.simple(BiFunction<? super A1,? super A2,? extends R> constructor, AbstractExpression<SourceId,LLJavaLexer.TokenType,A1> arg1, AbstractExpression<SourceId,LLJavaLexer.TokenType,A2> arg2)
protected <A, R extends LLJava.Node> Expression<SourceId,LLJavaLexer.TokenType,R>	LLJavaGrammar.simple(Function<? super A,? extends R> constructor, AbstractExpression<SourceId,LLJavaLexer.TokenType,A> arg1)
protected <R extends LLJava.Node> Expression<SourceId,LLJavaLexer.TokenType,R>	LLJavaGrammar.simple(Supplier<? extends R> constructor, LLJavaLexer.TokenType... types)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Statement>	LLJavaGrammar.statement(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Case>	LLJavaGrammar.switchCase(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Switch>	LLJavaGrammar.switchInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Try>	LLJavaGrammar.tryInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeArgument>	LLJavaGrammar.typeArgument(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.TypeArgument>>	LLJavaGrammar.typeArguments(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeBound>	LLJavaGrammar.typeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
protected static Expression<SourceId,LLJavaLexer.TokenType,Content<SourceId,LLJavaLexer.TokenType>>	LLJavaGrammar.unparsedLiteral(LLJavaLexer.TokenType... types)
protected static Expression<SourceId,LLJavaLexer.TokenType,String>	LLJavaGrammar.unparsedLiteralText(LLJavaLexer.TokenType... types)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.UpperTypeBound>	LLJavaGrammar.upperTypeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Wildcard>	LLJavaGrammar.wildcard(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)

Methods in eu.bandm.tools.lljava.parser with parameters of type Expression

Modifier and Type	Method	Description
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.angle(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation>	LLJavaGrammar.annotation(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue>	LLJavaGrammar.annotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation, Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue> annotationValue)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ArrayAnnotationValue>	LLJavaGrammar.arrayAnnotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.AnnotationValue> annotationValue)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block>	LLJavaGrammar.block(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.brace(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.bracket(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Handler>	LLJavaGrammar.catchHandler(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr>	LLJavaGrammar.classType(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodeInterval>	LLJavaGrammar.codeInterval(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.CodePoint>	LLJavaGrammar.codeReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,List<A>>	LLJavaGrammar.comma(Expression<SourceId,LLJavaLexer.TokenType,A> body)
protected <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.command(LLJavaLexer.TokenType type, Expression<SourceId,LLJavaLexer.TokenType,A> operand)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.DynamicExpr>	LLJavaGrammar.dynamicReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,Map.Entry<LLJava.Id,LLJava.AnnotationValue>>	LLJavaGrammar.elementValuePair(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,List<Map.Entry<LLJava.Id,LLJava.AnnotationValue>>>	LLJavaGrammar.elementValuePairs(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.If>	LLJavaGrammar.ifInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.InlineInterval>	LLJavaGrammar.inlineInterval(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.InlinePoint>	LLJavaGrammar.inlineReference(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Instruction>	LLJavaGrammar.instruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr>	LLJavaGrammar.loadable(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.LowerTypeBound>	LLJavaGrammar.lowerTypeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.MemberDynamicName>	LLJavaGrammar.memberDynamicName(Expression<SourceId,LLJavaLexer.TokenType,LLJava.LoadableExpr> loadable)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.NestedAnnotationValue>	LLJavaGrammar.nestedAnnotationValue(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Annotation> annotation)
protected static <A> Expression<SourceId,LLJavaLexer.TokenType,A>	LLJavaGrammar.paren(Expression<SourceId,LLJavaLexer.TokenType,A> body)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Statement>	LLJavaGrammar.statement(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Case>	LLJavaGrammar.switchCase(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Switch>	LLJavaGrammar.switchInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Try>	LLJavaGrammar.tryInstruction(Expression<SourceId,LLJavaLexer.TokenType,LLJava.Block> block)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeArgument>	LLJavaGrammar.typeArgument(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,List<LLJava.TypeArgument>>	LLJavaGrammar.typeArguments(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.TypeBound>	LLJavaGrammar.typeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.UpperTypeBound>	LLJavaGrammar.upperTypeBound(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)
final Expression<SourceId,LLJavaLexer.TokenType,LLJava.Wildcard>	LLJavaGrammar.wildcard(Expression<SourceId,LLJavaLexer.TokenType,LLJava.ClassTypeExpr> classType)

Uses of Expression in eu.bandm.tools.ramus.runtime2

Fields in eu.bandm.tools.ramus.runtime2 declared as Expression

Modifier and Type	Field	Description
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr>	HonnefDemo.main
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr>	HonnefDemo.sexpr
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.Symbol>	HonnefDemo.symbol
(package private) static final Expression<Void,HonnefDemo.TokenType,Content<Void,HonnefDemo.TokenType>>	HonnefDemo.symbol0

Methods in eu.bandm.tools.ramus.runtime2 that return Expression

Modifier and Type	Method	Description
static <D, T, A> Expression<D,T,A>	Expression.access(Class<A> type, Object key)	Retrieve the value assigned to a given key as the semantic interpretation.
<B, C> Expression<D,T,C>	Expression.andThenCombining(Expression<D,T,B> other, BiFunction<? super A,? super B,? extends C> pair)	Match the syntax of this expression followed by that of another, combining the semantic interpretations with a function.
<B> Expression<D,T,B>	Expression.andThenDependent(Expression<D,T,Function<? super A,? extends B>> other)	Match the syntax of this expression followed by that of another, combining the semantic interpretations.
Expression<D,T,A>	Expression.append(Parser<D,T> suffix)	Match the syntax of this token with a suffix, with the same semantic interpretation.
Expression<D,T,A>	Expression.append(T suffix)	Match the syntax of this token with a suffix, with the same semantic interpretation.
final Expression<D,T,A>	Expression.append(T... prefix)	Match the syntax of this token with a suffix, with the same semantic interpretation.
Expression<D,T,A>	Expression.assigning(Object key)	Match the same syntax as this expression, and assign the semantic interpretation to a given key.
static <D, T, A> Expression<D,T,A>	Expression.choice(Expression<D,T,? extends A>... alts)
static <D, T, A1> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector1<D,A1> coll, AbstractExpression<D,T,? extends A1> arg1)
static <D, T, A1, A2> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector2<D,A1,A2> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2)
static <D, T, A1, A2, A3> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector3<D,A1,A2,A3> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3)
static <D, T, A1, A2, A3, A4> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector4<D,A1,A2,A3,A4> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4)
static <D, T, A1, A2, A3, A4, A5> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector5<D,A1,A2,A3,A4,A5> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5)
static <D, T, A1, A2, A3, A4, A5, A6> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector6<D,A1,A2,A3,A4,A5,A6> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6)
static <D, T, A1, A2, A3, A4, A5, A6, A7> Expression<D,T,Unit>	Reducer.collect(Reducer.Collector7<D,A1,A2,A3,A4,A5,A6,A7> coll, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6, AbstractExpression<D,T,? extends A7> arg7)
static <D, T, A> Expression<D,T,A>	Expression.constant(Parser<D,T> syntax, A value)	Match the given syntax with a constant semantic interpretation.
static <D, T, A> Expression<D,T,A>	Expression.constant(T type, A value)	Match the given syntax with a constant semantic interpretation.
static <D, T, A> Expression<D,T,A>	Expression.constant(T type, String text, A value)	Match the given syntax with a constant semantic interpretation.
static <D, T, A> Expression<D,T,A>	Expression.constantEpsilon(A value)	Match no input with a constant semantic interpretation.
static <D, T> Expression<D,T,Content<D,T>>	Expression.content(Parser<D,T> syntax)
static <D, T> Expression<D,T,Content<D,T>>	Expression.content(T... types)	Match a token of any of the given token types and interpret as its content.
static <D, T, A> Expression<D,T,A>	Expression.counit(A value)
(package private) static final Expression<Void,HonnefDemo.TokenType,List<HonnefDemo.SExpr>>	HonnefDemo.elems(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
static <D, T, A> Expression<D,T,A>	Expression.fix(Function<Expression<D,T,A>,Expression<D,T,A>> loop)	Make a recursive expression.
Expression<D,T,A>	Expression.guard(Predicate<? super A> condition, Function<? super A,List<SimpleMessage<D>>> error)
static <D, T, A> Expression<D,T,A>	Expression.ifThenElse(T type, Expression<D,T,? extends A> thenBranch, Expression<D,T,? extends A> elseBranch)	Choose between two expression depending on the type of the next token.
static <D, T, A> Expression<D,T,A>	Expression.leftAssoc(Expression.OperatorFactory<D,T,A> operator, Expression<D,T,A> operand, T... operatorTypes)	Tactic for left-associative operators.
static <D, T, A> Expression<D,T,A>	Expression.leftAssoc(Expression<D,T,A> headOperand, Expression.OperatorFactory<D,T,A> operator, Expression<D,T,A> tailOperand, T... operatorTypes)
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.LList>	HonnefDemo.list(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
static <D, T, A> Expression<D,T,A>	Expression.lookahead(Map<T,Expression<D,T,? extends A>> map)
static <D, T, A> Expression<D,T,A>	Expression.lookup(Class<A> type, Map<T,? extends A> model)
static <D, T, A> Expression<D,T,A>	Expression.lookup(Map<T,? extends A> model)
<B> Expression<D,T,B>	Expression.map(Function<? super A,? extends B> fun)	Match the same syntax as this expression, and apply a function to the result of semantic interpretation.
<B> Expression<D,T,Map.Entry<A,B>>	Expression.mapsTo(Expression<D,T,B> other)	Match the syntax of this expression followed by that of another, combining the semantic interpretations as a Map.Entry.
static <D, T, A> Expression<D,T,A>	Expression.nonAssoc(Expression.OperatorFactory<D,T,A> operator, Expression<D,T,A> operand, T... operatorTypes)	Tactic for non-associative operators.
Expression<D,T,Optional<A>>	Expression.optional(Parser.Pragma... pragmas)	Match the syntax of this token with the same interpretation, or otherwise match no input.
Expression<D,T,Optional<A>>	Expression.optional(T defaultType)	Match the syntax of this token with the same interpretation, or otherwise match no input.
Expression<D,T,A>	Expression.orElse(A defaultValue, Parser.Pragma... pragmas)	Match the syntax of this token with the same interpretation, or otherwise match no input with the given default interpretation.
Expression<D,T,A>	Expression.orElse(Expression<D,T,A> other)
Expression<D,T,A>	Expression.orElseGet(Supplier<? extends A> defaultValue, Parser.Pragma... pragmas)	Match the syntax of this token with the same interpretation, or otherwise match no input with the given default interpretation.
Expression<D,T,List<A>>	Expression.plus(Parser.Pragma... pragmas)	Match one or more repetitions of this expression.
Expression<D,T,List<A>>	Expression.plus(Parser<D,T> sep, Parser.Pragma... pragmas)	Match one or more repetitions of this expression with intervening separator syntax.
Expression<D,T,List<A>>	Expression.plus(T sep, Parser.Pragma... pragmas)	Match one or more repetitions of this expression with intervening separator syntax.
Expression<D,T,A>	Expression.prepend(Parser<D,T> prefix)	Match the syntax of this token with a prefix, with the same semantic interpretation.
Expression<D,T,A>	Expression.prepend(T prefix)	Match the syntax of this token with a prefix, with the same semantic interpretation.
final Expression<D,T,A>	Expression.prepend(T... suffix)	Match the syntax of this token with a prefix, with the same semantic interpretation.
static <D, T, A1, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor1<D,A1,? extends R> cons, AbstractExpression<D,T,? extends A1> arg1)	Creates a compound expression for AST nodes with one parsed argument.
static <D, T, A1, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor1<D,A1,? extends R> cons, Fragment<D,T,? extends A1> arg1)	Creates a compound expression for AST nodes with one parsed argument.
static <D, T, A1, A2, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor2<D,A1,A2,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2)
static <D, T, A1, A2, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor2<D,A1,A2,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2)
static <D, T, A1, A2, A3, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor3<D,A1,A2,A3,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3)
static <D, T, A1, A2, A3, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor3<D,A1,A2,A3,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3)
static <D, T, A1, A2, A3, A4, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor4<D,A1,A2,A3,A4,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4)
static <D, T, A1, A2, A3, A4, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor4<D,A1,A2,A3,A4,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3, Fragment<D,T,? extends A4> arg4)
static <D, T, A1, A2, A3, A4, A5, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor5<D,A1,A2,A3,A4,A5,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5)
static <D, T, A1, A2, A3, A4, A5, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor5<D,A1,A2,A3,A4,A5,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3, Fragment<D,T,? extends A4> arg4, Fragment<D,T,? extends A5> arg5)
static <D, T, A1, A2, A3, A4, A5, A6, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor6<D,A1,A2,A3,A4,A5,A6,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6)
static <D, T, A1, A2, A3, A4, A5, A6, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor6<D,A1,A2,A3,A4,A5,A6,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3, Fragment<D,T,? extends A4> arg4, Fragment<D,T,? extends A5> arg5, Fragment<D,T,? extends A6> arg6)
static <D, T, A1, A2, A3, A4, A5, A6, A7, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor7<D,A1,A2,A3,A4,A5,A6,A7,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6, AbstractExpression<D,T,? extends A7> arg7)
static <D, T, A1, A2, A3, A4, A5, A6, A7, R> Expression<D,T,R>	Reducer.reduce(@Opt Class<R> type, Reducer.Constructor7<D,A1,A2,A3,A4,A5,A6,A7,R> cons, Fragment<D,T,? extends A1> arg1, Fragment<D,T,? extends A2> arg2, Fragment<D,T,? extends A3> arg3, Fragment<D,T,? extends A4> arg4, Fragment<D,T,? extends A5> arg5, Fragment<D,T,? extends A6> arg6, Fragment<D,T,? extends A7> arg7)
static <D, T, A1, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor1<D,A1,? extends R> cons, AbstractExpression<D,T,? extends A1> arg1)	Creates a compound expression for AST nodes with one parsed argument.
static <D, T, A1, A2, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor2<D,A1,A2,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2)
static <D, T, A1, A2, A3, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor3<D,A1,A2,A3,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3)
static <D, T, A1, A2, A3, A4, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor4<D,A1,A2,A3,A4,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4)
static <D, T, A1, A2, A3, A4, A5, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor5<D,A1,A2,A3,A4,A5,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5)
static <D, T, A1, A2, A3, A4, A5, A6, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor6<D,A1,A2,A3,A4,A5,A6,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6)
static <D, T, A1, A2, A3, A4, A5, A6, A7, R> Expression<D,T,R>	Reducer.reduce(Reducer.Constructor7<D,A1,A2,A3,A4,A5,A6,A7,R> cons, AbstractExpression<D,T,? extends A1> arg1, AbstractExpression<D,T,? extends A2> arg2, AbstractExpression<D,T,? extends A3> arg3, AbstractExpression<D,T,? extends A4> arg4, AbstractExpression<D,T,? extends A5> arg5, AbstractExpression<D,T,? extends A6> arg6, AbstractExpression<D,T,? extends A7> arg7)
static <D, T, A> Expression<D,T,A>	Expression.rightAssoc(Expression.OperatorFactory<D,T,A> operator, Expression<D,T,A> operand, T... operatorTypes)	Tactic for right-associative operators.
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr>	HonnefDemo.sexpr(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
Expression<D,T,List<A>>	Expression.star(Parser.Pragma... pragmas)	Match zero or more repetitions of this expression.
Expression<D,T,List<A>>	Expression.star(Parser<D,T> sep, Parser.Pragma... pragmas)	Match zero or more repetitions of this expression with intervening separator syntax.
Expression<D,T,List<A>>	Expression.star(T sep, Parser.Pragma... pragmas)	Match zero or more repetitions of this expression with intervening separator syntax.
static <D, T> Expression<D,T,String>	Expression.text(T... types)	Match a token of any of the given token types and interpret as its text.
static <D, T> Expression<D,T,T>	Expression.type(T... types)	Match a token of any of the given token types and interpret as its type.
static <D, T> Expression<D,T,Void>	Expression.unit()	Match no input with no semantic interpretation.
static <D, T> Expression<D,T,Void>	Expression.unit(Parser<D,T> syntax)	Match the given syntax with no semantic interpretation.
static <D, T> Expression<D,T,Void>	Expression.unit(T... types)	Match the given syntax with no semantic interpretation.
<K, L> Expression<D,T,A>	Expression.withOtherTokenSource(LookaheadTokenMultiplexer<K,D,T,L> multi, K newKey)
Expression<D,T,A>	Expression.withScope(Map<Object,? extends Data> initializers)	Match the same syntax as this expression, but perform semantic interpretation in a local scope.
Expression<D,T,A>	Expression.wrap(Parser<D,T> prefix, Parser<D,T> suffix)	Match the syntax of this token with a prefix and a suffix, with the same semantic interpretation.
Expression<D,T,A>	Expression.wrap(T prefix, T suffix)	Match the syntax of this token with a prefix and a suffix, with the same semantic interpretation.

Methods in eu.bandm.tools.ramus.runtime2 with parameters of type Expression

Modifier and Type	Method	Description
<B, C> Expression<D,T,C>	Expression.andThenCombining(Expression<D,T,B> other, BiFunction<? super A,? super B,? extends C> pair)	Match the syntax of this expression followed by that of another, combining the semantic interpretations with a function.
<B> Expression<D,T,B>	Expression.andThenDependent(Expression<D,T,Function<? super A,? extends B>> other)	Match the syntax of this expression followed by that of another, combining the semantic interpretations.
static <D, T, A> Expression<D,T,A>	Expression.choice(Expression<D,T,? extends A>... alts)
(package private) static final Expression<Void,HonnefDemo.TokenType,List<HonnefDemo.SExpr>>	HonnefDemo.elems(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
static <D, T, A> Expression<D,T,A>	Expression.ifThenElse(T type, Expression<D,T,? extends A> thenBranch, Expression<D,T,? extends A> elseBranch)	Choose between two expression depending on the type of the next token.
static <D, T, A> Expression<D,T,A>	Expression.leftAssoc(Expression.OperatorFactory<D,T,A> operator, Expression<D,T,A> operand, T... operatorTypes)	Tactic for left-associative operators.
static <D, T, A> Expression<D,T,A>	Expression.leftAssoc(Expression<D,T,A> headOperand, Expression.OperatorFactory<D,T,A> operator, Expression<D,T,A> tailOperand, T... operatorTypes)
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.LList>	HonnefDemo.list(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
<B> Expression<D,T,Map.Entry<A,B>>	Expression.mapsTo(Expression<D,T,B> other)	Match the syntax of this expression followed by that of another, combining the semantic interpretations as a Map.Entry.
static <D, T, A> Expression<D,T,A>	Expression.nonAssoc(Expression.OperatorFactory<D,T,A> operator, Expression<D,T,A> operand, T... operatorTypes)	Tactic for non-associative operators.
Expression<D,T,A>	Expression.orElse(Expression<D,T,A> other)
static <D, T, A> Expression<D,T,A>	Expression.rightAssoc(Expression.OperatorFactory<D,T,A> operator, Expression<D,T,A> operand, T... operatorTypes)	Tactic for right-associative operators.
(package private) static final Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr>	HonnefDemo.sexpr(Expression<Void,HonnefDemo.TokenType,HonnefDemo.SExpr> sexpr)
(package private) static <A> List<A>	Parser.Test.test(Expression<Void,Parser.Test.TokenType,A> expr, Parser.Test.TokenType... input)

Method parameters in eu.bandm.tools.ramus.runtime2 with type arguments of type Expression

Modifier and Type	Method	Description
static <D, T, A> Expression<D,T,A>	Expression.fix(Function<Expression<D,T,A>,Expression<D,T,A>> loop)	Make a recursive expression.
static <D, T, A> Expression<D,T,A>	Expression.fix(Function<Expression<D,T,A>,Expression<D,T,A>> loop)	Make a recursive expression.
static <D, T, A> Expression<D,T,A>	Expression.lookahead(Map<T,Expression<D,T,? extends A>> map)

Uses of Expression in eu.bandm.tools.tpath.parser2

Fields in eu.bandm.tools.tpath.parser2 declared as Expression

Modifier and Type	Field	Description
final Expression<D,TokenType,TPath.Expr>	Parser.expr
final Expression<D,TokenType,TPath.Literal>	Parser.non_braced	Longest sequence of characters up to the first single opening brace.

Methods in eu.bandm.tools.tpath.parser2 that return Expression

Modifier and Type	Method	Description
Expression<D,TokenType,TPath.Expr>	Parser.attributeValueTemplate(LookaheadTokenMultiplexer<Boolean,D,TokenType,int[]> mux)
Expression<D,TokenType,TPath.FunctionCall>	Parser.bracedExpr(LookaheadTokenMultiplexer<Boolean,D,TokenType,int[]> mux)
Expression<D,TokenType,TPath.Expr>	Parser.parse_embed(LookaheadTokenMultiplexer<Boolean,D,TokenType,int[]> mux)
protected Expression<D,TokenType,String>	Parser.unparsedLiteralText(TokenType... types)

Methods in eu.bandm.tools.tpath.parser2 with parameters of type Expression

Modifier and Type	Method	Description
<R> R	Parser.parse_nonterminal(Expression<D,TokenType,R> nonterminal, LookaheadTokenSource<D,TokenType,int[]> tokenSource, MessageReceiver<SimpleMessage<D>> msg)
<R> R	Parser.parse_nonterminal(Expression<D,TokenType,R> nonterminal, Reader reader, MessageReceiver<SimpleMessage<D>> msg, D sourceIndication)	Service Access Point for parsing a particular non-terminal.