AbstractCodeParser (Syntax Compiler-Compiler 4.2.0 API)

java.lang.Object
- me.jaimegarza.syntax.generator.AbstractPhase
- - me.jaimegarza.syntax.generator.AbstractCodeParser

All Implemented Interfaces:

EmbeddedCodeProcessor, Lexer

Direct Known Subclasses:

SyntaxCodeParser
```
public abstract class AbstractCodeParser
extends AbstractPhase
implements Lexer, EmbeddedCodeProcessor
```
This class contains the "non-parser" code, or supporting code for the syntax parser.
This is done so that the CodeParser can be generated from a syntaxt file

Author:

jgarza

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`actLine`
`protected boolean`	`bActionDone`
`char`	`currentChar`
`protected String`	`currentNonTerminalName`
`protected int`	`currentRuleIndex`
`protected Type`	`currentType`
`protected static String`	`DISTINGUISHED_SYMBOL_NAME`
`protected boolean`	`finalActions`
`protected Stack<Character>`	`inputChars`
`protected boolean`	`isCurlyBrace`
`protected boolean`	`isEqual`
`protected boolean`	`isError`
`protected boolean`	`isErrorToken`
`protected boolean`	`isFirstToken`
`protected boolean`	`isRegexSlash`
`protected int`	`markers`
`protected boolean`	`mustClose`
`protected int`	`numberOfErrorTokens`
`String`	`recognized`
`protected Associativity`	`ruleAssociativity`
`protected int`	`rulePrecedence`
`protected int`	`tokenActionCount`
`protected int`	`tokenNumber`

Fields inherited from class me.jaimegarza.syntax.generator.AbstractPhase
environment, runtimeData

Constructor Summary

Constructors
Constructor and Description

AbstractCodeParser(Environment environment)
Default Constructor

Constructors
Constructor and Description
`AbstractCodeParser(Environment environment)` Default Constructor

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`computeAssociativityAndPrecedence(String tokenName)` A %prec was given, and as such I need to load its context globally
`protected void`	`computeRootSymbol()` Find out my root symbol
`boolean`	`declareOneItem(String symbolName, int value, boolean mustClose)` Adds one rule item to the current list of items
`protected boolean`	`declareOneNonTerminal(String typeName, String name)` Declare one non terminal in the symbol table
`protected Terminal`	`declareOneTerminal(String id, boolean isErrorToken, Associativity associativity, int precedence, Type type, int tokenNumber, String fullName)` Declare a token
`protected boolean`	`declareOneType(String typeName)` Declare one given type
`protected boolean`	`declareStart(String id)`
`protected char`	`decodeControlChar()` Use the character stream to decode a control char
`protected char`	`decodeEscape()` Use the character stream to decode the next escaped character (i.e.
`protected char`	`decodeHex()` Use the character stream to decode a character entered with hex codes
`protected char`	`decodeOctal()` Use the character stream to decode one character from octal
`abstract void`	`dumpTokens()`
`abstract void`	`execute()`
`protected void`	`finalizeRules()` set rule numbers and print
`protected void`	`finalizeSymbols()` Assign ids, numbers, and print them.
`protected void`	`generateCaseEnd()` A statement for code generation was found.
`protected int`	`generateCaseStatement(int ruleNumber, String comment)` Output the case for a given rule
`protected void`	`generateCodeGeneratorFooter()` Generate the ending portion of the code generation
`protected void`	`generateCodeGeneratorHeader()` Output the top of the rules if needed
`boolean`	`generateConstant(Lexer lexer, char characterType)` Scan the stream unti a string that starts with the given character ends
`protected boolean`	`generateDeclaration()` During a declaration, emit the accompanying code
`protected boolean`	`generateDefaultRegexCode(int dfaNode, Terminal token)` Produce the if statement that will match the regex symbol and the default return code
`boolean`	`generateDollarDollar(Lexer lexer, int elementCount, String nonTerminalId, Type type)` $$ detected.
`boolean`	`generateDollarLetter(Lexer lexer, int elementCount, Type type, String nonTerminalId)` $Letter was detected.
`boolean`	`generateDollarNumber(Lexer lexer, int elementCount, Type type, int sign)` $1, $2, $-3, etc detected.
`protected boolean`	`generateLexerCode(String lexerMode, Terminal token)` copy action until the next ';' or '}' that actually closes
`protected void`	`generateLexerFooter()` Generate the bottom of the lexer
`protected boolean`	`generateRegexCode(String lexerMode, int dfaNode, Terminal token)` Produce the if statement that will match the regex symbol and include additional code
`protected boolean`	`generateStructure()` For yacc compatibility this is called the union, but it is really a structure
`protected void`	`generateTokenDefinitions()` token definitions are declared as static or #define
`protected void`	`generateTopRecoveryTable()` The recovery table deals with tokens that can be used to recognize syntax context and can recover from errors.
`char`	`getCurrentCharacter()` Do not get the next character character.
`protected int`	`getDollarTextIndexFromStream()` Find the $Letter[<digits>] digits.
`char`	`getNextCharacter()` Get one character.
`protected Symbol`	`getSymbolWithName(String name)` Obtain a symbol, either terminal or non terminal, with the given name.
`Type`	`getTypeFromStream(Lexer lexer)` EMBEDDED CODE PROCESSOR
`boolean`	`groupTokens(List<String> tokens, String groupName, String displayName)` group a list of tokens
`protected int`	`lineNumber(Rule rule)`
`protected Rule`	`locateRuleWithId(int id)` Locate a rule whose left hand if is the given id
`protected boolean`	`nameOneNonTerminal(String name, String fullName)` Change the display name of a non terminal
`protected Rule`	`newEmptyRule()` new rule with no elements
`protected RuleItem`	`newItem(Symbol elem)` new rule item with the given symbol
`protected Rule`	`newRootRule(NonTerminal root)` Starting rule.
`protected Rule`	`newRule()` new rule with the currently recognized items
`protected void`	`reviewDeclarations()` Check non terminals whose precedence is zero, and make them terminals.
`protected boolean`	`ruleAction(int ruleNumber, int elementCount, String nonTerminalName)` Found a rule action.
`protected boolean`	`setLeftHandOfLastRule(String name)` This routine places the non terminal left hand of a rule
`boolean`	`skipAndOutputCompositeComment(Lexer lexer, char secondaryCharacter, char characterToFind)` Skip a comment, and copying it to the output
`void`	`ungetChar(char c)` Reverse one character.

Methods inherited from class me.jaimegarza.syntax.generator.AbstractPhase
indent, left, right, span, span

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface me.jaimegarza.syntax.Lexer
getNormalSymbol

- Field Detail
  - DISTINGUISHED_SYMBOL_NAME
```
protected static final String DISTINGUISHED_SYMBOL_NAME
```
    See Also:
    
    Constant Field Values
  - inputChars
```
protected Stack<Character> inputChars
```
  - bActionDone
```
protected boolean bActionDone
```
  - currentRuleIndex
```
protected int currentRuleIndex
```
  - currentType
```
protected Type currentType
```
  - markers
```
protected int markers
```
  - isCurlyBrace
```
protected boolean isCurlyBrace
```
  - isEqual
```
protected boolean isEqual
```
  - isRegexSlash
```
protected boolean isRegexSlash
```
  - isError
```
protected boolean isError
```
  - tokenNumber
```
protected int tokenNumber
```
  - currentNonTerminalName
```
protected String currentNonTerminalName
```
  - mustClose
```
protected boolean mustClose
```
  - finalActions
```
protected boolean finalActions
```
  - isErrorToken
```
protected boolean isErrorToken
```
  - ruleAssociativity
```
protected Associativity ruleAssociativity
```
  - rulePrecedence
```
protected int rulePrecedence
```
  - tokenActionCount
```
protected int tokenActionCount
```
  - actLine
```
protected int actLine
```
  - isFirstToken
```
protected boolean isFirstToken
```
  - numberOfErrorTokens
```
protected int numberOfErrorTokens
```
  - currentChar
```
public char currentChar
```
  - recognized
```
public String recognized
```
- Constructor Detail
  - AbstractCodeParser
```
public AbstractCodeParser(Environment environment)
```
    Default Constructor
    
    Parameters:
    
    environment - is the syntax environment
- Method Detail
  - declareOneTerminal
```
protected Terminal declareOneTerminal(String id,
                                      boolean isErrorToken,
                                      Associativity associativity,
                                      int precedence,
                                      Type type,
                                      int tokenNumber,
                                      String fullName)
```
    Declare a token
    
    Parameters:
    
    id - is the short name of the token
    
    isErrorToken - specifies if this token was declared with %error
    
    associativity - defines if a token is defined with %left, %right, etc.
    
    precedence - is the numeric precedence of the token
    
    type - is the type of the non-terminal
    
    tokenNumber - is the number of the token, or its value
    
    fullName - is the fullname, if given, of the token
    
    Returns:
    
    true if OK
  - declareOneNonTerminal
```
protected boolean declareOneNonTerminal(String typeName,
                                        String name)
```
    Declare one non terminal in the symbol table
    
    Parameters:
    
    typeName - the desired type
    
    name - the name of the symbol
    
    Returns:
    
    true if OK
  - declareOneType
```
protected boolean declareOneType(String typeName)
```
    Declare one given type
    
    Parameters:
    
    typeName - the desired type
    
    Returns:
    
    true if OK
  - declareOneItem
```
public boolean declareOneItem(String symbolName,
                              int value,
                              boolean mustClose)
```
    Adds one rule item to the current list of items
    
    Parameters:
    
    symbolName - the name of the symbol being used
    
    value - the integer value of the symbol
    
    mustClose - whether this token must close
    
    Returns:
    
    true if OK
  - groupTokens
```
public boolean groupTokens(List<String> tokens,
                           String groupName,
                           String displayName)
```
    group a list of tokens
    
    Parameters:
    
    tokens - the list of tokens
    
    groupName - the name of the group
    
    displayName - the display name of the group
    
    Returns:
    
    true if OK
  - computeAssociativityAndPrecedence
```
public boolean computeAssociativityAndPrecedence(String tokenName)
```
    A %prec was given, and as such I need to load its context globally
    
    Parameters:
    
    tokenName - is the name of the token given in the %prec
    
    Returns:
    
    true on success
  - nameOneNonTerminal
```
protected boolean nameOneNonTerminal(String name,
                                     String fullName)
```
    Change the display name of a non terminal
    
    Parameters:
    
    name - is the short name of the non terminal
    
    fullName - is its full name
    
    Returns:
    
    true if OK
  - setLeftHandOfLastRule
```
protected boolean setLeftHandOfLastRule(String name)
```
    This routine places the non terminal left hand of a rule
    
    Parameters:
    
    name - is the non terminal's name
    
    Returns:
    
    true if OK
  - decodeOctal
```
protected char decodeOctal()
```
    Use the character stream to decode one character from octal
    for instance '\017'
    
    Returns:
    
    the octal entered character
  - decodeControlChar
```
protected char decodeControlChar()
```
    Use the character stream to decode a control char
    \a - \z
    
    Returns:
    
    the control char
  - decodeHex
```
protected char decodeHex()
```
    Use the character stream to decode a character entered with hex codes
    for instance \x1f
    
    Returns:
    
    the character
  - decodeEscape
```
protected char decodeEscape()
```
    Use the character stream to decode the next escaped character (i.e. hex, octal, control)
    
    Returns:
    
    the encoded character
  - getNextCharacter
```
public char getNextCharacter()
```
    Description copied from interface: Lexer
    
    Get one character. Place it in currentChar
    
    Specified by:
    
    getNextCharacter in interface Lexer
    
    Returns:
    
    the character
  - ungetChar
```
public void ungetChar(char c)
```
    Description copied from interface: Lexer
    
    Reverse one character. Place it in RuntimeData.currentCharacter
    
    Specified by:
    
    ungetChar in interface Lexer
    
    Parameters:
    
    c - is the character to unget
  - getCurrentCharacter
```
public char getCurrentCharacter()
```
    Description copied from interface: Lexer
    
    Do not get the next character character. Just return the current char
    
    Specified by:
    
    getCurrentCharacter in interface Lexer
    
    Returns:
    
    the character
  - getTypeFromStream
```
public Type getTypeFromStream(Lexer lexer)
```
    EMBEDDED CODE PROCESSOR
    
    Specified by:
    
    getTypeFromStream in interface EmbeddedCodeProcessor
    
    Parameters:
    
    lexer - the element that will give me the lexical logic
    
    Returns:
    
    the type from the scanner
  - generateDollarLetter
```
public boolean generateDollarLetter(Lexer lexer,
                                    int elementCount,
                                    Type type,
                                    String nonTerminalId)
```
    $Letter was detected. The idea is to transform such occurrences into $$ or $digit occurrences by looking at the symbol whose name is given by the identifier.
    When two rule items have the same symbol, a disambiguating index like $Symbol[1], $Symbol[2], etc. can be used. The Left hand symbol is only used when non indexed;
    
    Specified by:
    
    generateDollarLetter in interface EmbeddedCodeProcessor
    
    Parameters:
    
    lexer - the element that will give me the lexical logic
    
    elementCount - the number of elements in the rule
    
    nonTerminalId - the non terminal id for the rule
    
    type - the type of the element
    
    Returns:
    
    true if everything is OK
  - getSymbolWithName
```
protected Symbol getSymbolWithName(String name)
```
    Obtain a symbol, either terminal or non terminal, with the given name.
    
    Parameters:
    
    name - the name of the symbol
    
    Returns:
    
    the symbol
  - getDollarTextIndexFromStream
```
protected int getDollarTextIndexFromStream()
```
    Find the $Letter[<digits>] digits. If <digits> start with a zero, octal radix is assumed.
    
    Returns:
    
    the index.
  - generateDollarNumber
```
public boolean generateDollarNumber(Lexer lexer,
                                    int elementCount,
                                    Type type,
                                    int sign)
```
    $1, $2, $-3, etc detected. Proceed with the code generation
    
    Specified by:
    
    generateDollarNumber in interface EmbeddedCodeProcessor
    
    Parameters:
    
    lexer - the element that will give me the lexical logic
    
    elementCount - the number of elements in the rule
    
    type - the type of the element
    
    sign, - 1 for possitive, -1 for negative
    
    Returns:
    
    true if everything is OK
  - generateDollarDollar
```
public boolean generateDollarDollar(Lexer lexer,
                                    int elementCount,
                                    String nonTerminalId,
                                    Type type)
```
    $$ detected. Proceed with the code generation
    
    Specified by:
    
    generateDollarDollar in interface EmbeddedCodeProcessor
    
    Parameters:
    
    lexer - the element that will give me the lexical logic
    
    elementCount - the number of elements in the rule
    
    nonTerminalId - the non terminal id for the rule
    
    type - the type of the element
    
    Returns:
    
    true if everything is OK
  - generateConstant
```
public boolean generateConstant(Lexer lexer,
                                char characterType)
```
    Description copied from interface: EmbeddedCodeProcessor
    
    Scan the stream unti a string that starts with the given character ends
    
    Specified by:
    
    generateConstant in interface EmbeddedCodeProcessor
    
    Parameters:
    
    lexer - the object in charge of managing the input stream
    
    Returns:
    
    true on success
  - skipAndOutputCompositeComment
```
public boolean skipAndOutputCompositeComment(Lexer lexer,
                                             char secondaryCharacter,
                                             char characterToFind)
```
    Description copied from interface: EmbeddedCodeProcessor
    
    Skip a comment, and copying it to the output
    
    Specified by:
    
    skipAndOutputCompositeComment in interface EmbeddedCodeProcessor
    
    Parameters:
    
    lexer - the element that will give me the lexical logic
    
    Returns:
    
    true on success
  - generateCaseEnd
```
protected void generateCaseEnd()
```
    A statement for code generation was found. Finish it.
  - generateCaseStatement
```
protected int generateCaseStatement(int ruleNumber,
                                    String comment)
```
    Output the case for a given rule
    
    Parameters:
    
    ruleNumber - is the rule number to be emitted in the case statement
    
    comment - is the comment
    
    Returns:
    
    for indentation purposes the column where the case ended
  - generateCodeGeneratorHeader
```
protected void generateCodeGeneratorHeader()
```
    Output the top of the rules if needed
  - generateLexerCode
```
protected boolean generateLexerCode(String lexerMode,
                                    Terminal token)
```
    copy action until the next ';' or '}' that actually closes
    
    Parameters:
    
    lexerMode - is the mode of the lexer
    
    token - is the token related to the generation. Used in $t
    
    Returns:
    
    true if OK
  - generateDefaultRegexCode
```
protected boolean generateDefaultRegexCode(int dfaNode,
                                           Terminal token)
```
    Produce the if statement that will match the regex symbol and the default return code
    
    Parameters:
    
    dfaNode - is the index of the dfa vertex
    
    token - is the token related to the generation. Used in $t
    
    Returns:
    
    true if successful
  - generateRegexCode
```
protected boolean generateRegexCode(String lexerMode,
                                    int dfaNode,
                                    Terminal token)
```
    Produce the if statement that will match the regex symbol and include additional code
    
    Parameters:
    
    lexerMode - is the mode of the scanner
    
    dfaNode - is the index of the dfa vertex
    
    token - is the token related to the generation. Used in $t
    
    Returns:
    
    true if successful
  - generateCodeGeneratorFooter
```
protected void generateCodeGeneratorFooter()
```
    Generate the ending portion of the code generation
  - generateLexerFooter
```
protected void generateLexerFooter()
```
    Generate the bottom of the lexer
  - generateDeclaration
```
protected boolean generateDeclaration()
```
    During a declaration, emit the accompanying code
    
    Returns:
    
    true if OK
  - generateStructure
```
protected boolean generateStructure()
```
    For yacc compatibility this is called the union, but it is really a structure
    
    Returns:
    
    true if OK
  - newItem
```
protected RuleItem newItem(Symbol elem)
```
    new rule item with the given symbol
    
    Parameters:
    
    elem - is the symbol associated to the rule
    
    Returns:
    
    the new rule item
  - newEmptyRule
```
protected Rule newEmptyRule()
```
    new rule with no elements
    
    Returns:
    
    the new rule
  - newRule
```
protected Rule newRule()
```
    new rule with the currently recognized items
    
    Returns:
    
    a new rule
  - newRootRule
```
protected Rule newRootRule(NonTerminal root)
```
    Starting rule. Add it at the top.
    
    Parameters:
    
    root - is the root symbol
    
    Returns:
    
    the new rule
  - reviewDeclarations
```
protected void reviewDeclarations()
```
    Check non terminals whose precedence is zero, and make them terminals.
  - computeRootSymbol
```
protected void computeRootSymbol()
```
    Find out my root symbol
  - generateTopRecoveryTable
```
protected void generateTopRecoveryTable()
```
    The recovery table deals with tokens that can be used to recognize syntax context and can recover from errors.
  - finalizeSymbols
```
protected void finalizeSymbols()
```
    Assign ids, numbers, and print them.
  - finalizeRules
```
protected void finalizeRules()
```
    set rule numbers and print
  - generateTokenDefinitions
```
protected void generateTokenDefinitions()
```
    token definitions are declared as static or #define
  - locateRuleWithId
```
protected Rule locateRuleWithId(int id)
```
    Locate a rule whose left hand if is the given id
    
    Parameters:
    
    id - is the id of the non terminal on the left hand side
    
    Returns:
    
    the rule, or null if not found
  - lineNumber
```
protected int lineNumber(Rule rule)
```
    Parameters:
    
    rule - is the rule's line number
    
    Returns:
    
    the line number of a given rule
  - ruleAction
```
protected boolean ruleAction(int ruleNumber,
                             int elementCount,
                             String nonTerminalName)
```
    Found a rule action. Copy it to the output stream as-is
    
    Parameters:
    
    ruleNumber - the rule index
    
    elementCount - the elements in the rule
    
    nonTerminalName - the left hand symbol of the rule
    
    Returns:
    
    true if OK
  - declareStart
```
protected boolean declareStart(String id)
```
  - execute
```
public abstract void execute()
                      throws ParsingException
```
    Throws:
    
    ParsingException
  - dumpTokens
```
public abstract void dumpTokens()
                         throws ParsingException
```
    Throws:
    
    ParsingException

Class AbstractCodeParser

Field Summary

Fields inherited from class me.jaimegarza.syntax.generator.AbstractPhase

Constructor Summary

Method Summary

Methods inherited from class me.jaimegarza.syntax.generator.AbstractPhase

Methods inherited from class java.lang.Object

Methods inherited from interface me.jaimegarza.syntax.Lexer

Field Detail

DISTINGUISHED_SYMBOL_NAME

inputChars

bActionDone

currentRuleIndex

currentType

markers

isCurlyBrace

isEqual

isRegexSlash

isError

tokenNumber

currentNonTerminalName

mustClose

finalActions

isErrorToken

ruleAssociativity

rulePrecedence

tokenActionCount

actLine

isFirstToken

numberOfErrorTokens

currentChar

recognized

Constructor Detail

AbstractCodeParser

Method Detail

declareOneTerminal

declareOneNonTerminal

declareOneType

declareOneItem

groupTokens

computeAssociativityAndPrecedence

nameOneNonTerminal

setLeftHandOfLastRule

decodeOctal

decodeControlChar

decodeHex

decodeEscape

getNextCharacter

ungetChar

getCurrentCharacter

getTypeFromStream

generateDollarLetter

getSymbolWithName

getDollarTextIndexFromStream

generateDollarNumber

generateDollarDollar

generateConstant

skipAndOutputCompositeComment

generateCaseEnd

generateCaseStatement

generateCodeGeneratorHeader

generateLexerCode

generateDefaultRegexCode

generateRegexCode

generateCodeGeneratorFooter

generateLexerFooter

generateDeclaration

generateStructure

newItem

newEmptyRule

newRule

newRootRule

reviewDeclarations

computeRootSymbol

generateTopRecoveryTable

finalizeSymbols

finalizeRules

generateTokenDefinitions

locateRuleWithId

lineNumber