Pascal (Syntax Compiler-Compiler 4.2.0 API)

java.lang.Object
- me.jaimegarza.syntax.language.BaseLanguageSupport
- - me.jaimegarza.syntax.language.Pascal

All Implemented Interfaces:

LanguageSupport
```
public class Pascal
extends BaseLanguageSupport
```
Routines for supporting the pascal language

Author:

jaimegarza@gmail.com

Field Summary
- Fields inherited from class me.jaimegarza.syntax.language.BaseLanguageSupport
  environment, runtime

Constructor Summary

Constructors
Constructor and Description

Pascal()

Constructors
Constructor and Description
`Pascal()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected String`	`escapeDoubleQuotes(String error)`
`void`	`generateCaseEnd()` emit a case end statement
`int`	`generateCaseStart(int lineNumber, String label, String comment)` emit a case start
`void`	`generateCodeGeneratorFooter()` Generate the ending portion of the code generation
`void`	`generateCodeGeneratorHeader()` Output the top of the rules if needed
`void`	`generateEdgeHeader(int size)` Generate the code for the edge table beginning
`void`	`generateErrorToken(int recoveryToken, ErrorToken id, boolean isLast)` Generates one entry for an error token
`void`	`generateIntArrayComment(String comment)` Output a comment in an array
`void`	`generateIntArrayFooter()` Output the end of an int array
`void`	`generateIntArrayRow(int i, String comment, int index, int maxSize)` Output a row in an integer array
`boolean`	`generateLexerCode(FormattingPrintStream output, String lexerMode, Lexer lexer, Terminal token, int additionalIndent)` Emit the code for the lexical part of the grammar
`void`	`generateLexerFooter()` Generate the bottom of the lexer
`void`	`generateLexerHeader(List<String> modes)` Emit the header of the lexer as needed.
`void`	`generateLexerModeCase(String lexerMode, int index)` Generate the constant or 'define" for a given lexer mode
`void`	`generateLexerModeDefinition(String lexerMode, int index)` Generate the constant or 'define" for a given lexer mode
`void`	`generateLexerModeFooter(String lexerMode)` Emit a lexer function footer by mode
`void`	`generateLexerModeHeader(String lexerMode)` Emit a lexer function header by mode
`void`	`generateRecoveryTableHeader(int numberOfErrorTokens)` The recovery table deals with tokens that can be used to recognize syntax context and can recover from errors.
`void`	`generateRegexEnd(FormattingPrintStream output)` Generate the bottom of a regex match in the scanner
`void`	`generateRegexMatch(FormattingPrintStream output, int dfaNode)` Generate if statement for a regular expression match
`void`	`generateRegexReturn(FormattingPrintStream output, Terminal token)` Generate the default return token for a regexp
`boolean`	`generateRuleCode(Lexer lexer, EmbeddedCodeProcessor processor, int elementCount, String nonTerminalId, int sourceColumn)` Parsing logic Scan the input stream until a rule set of actions end.
`boolean`	`generateStructure(Lexer lexer)` For yacc compatibility this is called the union, but it is really a structure
`void`	`generateToken(Terminal id, boolean isLast)` Generate the code for a given token
`void`	`generateTokenDefinitions()` Declare all the tokens
`void`	`generateTokensHeader(int terminals)` Generates the top part of the token definition
`void`	`generateVertexHeader(int size)` Generate the vertex header
`void`	`generateVoidCodeGenerator()` there was no code generated.
`boolean`	`getDefaultIncludeFlag()` tells me the default value for include file generation
`String`	`getExtensionSuffix()` get the source extension
`String`	`getId()` get the short, one-letter, or two-letter identifier for this language.
`String`	`getIncludeExtensionSuffix()`
`String`	`getLanguageCode()` get the string that identifies the language.
`String`	`getLexerModeRoutine(String lexerMode)` Given a lexer mode, return the routine definition
`protected boolean`	`lexerDollar(FormattingPrintStream output, String lexerMode, Lexer lexer, Terminal token)`
`protected void`	`lexerReturnValue(FormattingPrintStream output, String lexerMode, Lexer lexer)`
`void`	`printAction(int action, Action anAction)` Emit one action
`void`	`printActionHeader()` emit the header of the action table
`void`	`printCodeHeader()` print the declarations for the rest of the code
`void`	`printErrorEntry(int error)` Add errors to the table
`void`	`printErrorFooter()` Close the error table
`void`	`printErrorTableHeader()` declare the error table
`void`	`printGoTo(int gotoIndex, GoTo pGoto)` Emit one go to
`void`	`printGoToTableHeader()` emit the goto table header
`void`	`printGrammarTable()` Output the whole grammar table
`void`	`printMissingSkeleton(String filename)` The skeleton was not found, say so.
`void`	`printPackedState(int stateNumber)` print a state in packed fashion
`void`	`printParserErrors()` Display the errors of the parser
`void`	`printParsingTableHeader()` Declare the parsing table
`void`	`printTableRow(int symbolCounter, int[] parserLine, int stateNumber)` print one row of the parsing table

Methods inherited from class me.jaimegarza.syntax.language.BaseLanguageSupport
computeModeName, emitLine, emitLine, getDefaultIndent, getEnvironment, getErrorMessage, getLexerCodeOffsetIndent, getNumberOfSpacesPerIndent, getRuntime, getShortSymbolName, indent, indent, lexerComment, lexerString, manageDollar, setEnvironment, setRuntime

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

- Constructor Detail
  - Pascal
```
public Pascal()
```
- Method Detail
  - getLanguageCode
```
public String getLanguageCode()
```
    Description copied from interface: LanguageSupport
    
    get the string that identifies the language. Used for bundling and perhaps other stuff (i.e. titles, etc.)
    
    Returns:
    
    the language code as a string
  - getId
```
public String getId()
```
    Description copied from interface: LanguageSupport
    
    get the short, one-letter, or two-letter identifier for this language. Used in cmd line options.
    
    Returns:
    
    the id of the language
  - getExtensionSuffix
```
public String getExtensionSuffix()
```
    Description copied from interface: LanguageSupport
    
    get the source extension
    
    Returns:
    
    the extension suffix for the language
  - getIncludeExtensionSuffix
```
public String getIncludeExtensionSuffix()
```
    Returns:
    
    include file extension
  - getDefaultIncludeFlag
```
public boolean getDefaultIncludeFlag()
```
    Description copied from interface: LanguageSupport
    
    tells me the default value for include file generation
    
    Specified by:
    
    getDefaultIncludeFlag in interface LanguageSupport
    
    Overrides:
    
    getDefaultIncludeFlag in class BaseLanguageSupport
    
    Returns:
    
    the default setting
  - generateCaseStart
```
public int generateCaseStart(int lineNumber,
                             String label,
                             String comment)
```
    Description copied from interface: LanguageSupport
    
    emit a case start
    
    Parameters:
    
    lineNumber - the line number on the source
    
    label - the label of the case statement
    
    comment - is the comment of the case
    
    Returns:
    
    for indentation purposes the column where the case ended
  - generateCaseEnd
```
public void generateCaseEnd()
```
    Description copied from interface: LanguageSupport
    
    emit a case end statement
  - generateRuleCode
```
public boolean generateRuleCode(Lexer lexer,
                                EmbeddedCodeProcessor processor,
                                int elementCount,
                                String nonTerminalId,
                                int sourceColumn)
```
    Description copied from interface: LanguageSupport
    
    Parsing logic Scan the input stream until a rule set of actions end. The format for ending rules is language dependent
    
    Specified by:
    
    generateRuleCode in interface LanguageSupport
    
    Overrides:
    
    generateRuleCode in class BaseLanguageSupport
    
    Parameters:
    
    lexer - the element that will give me the lexical logic
    
    processor - is the processor for rules
    
    elementCount - the number of elements in the rule
    
    nonTerminalId - the non terminal id for the rule
    
    sourceColumn - is the column number
    
    Returns:
    
    true if OK
  - generateLexerHeader
```
public void generateLexerHeader(List<String> modes)
```
    Description copied from interface: LanguageSupport
    
    Emit the header of the lexer as needed.
    
    Parameters:
    
    modes - is the list of forward modes
  - generateLexerModeHeader
```
public void generateLexerModeHeader(String lexerMode)
```
    Description copied from interface: LanguageSupport
    
    Emit a lexer function header by mode
    
    Parameters:
    
    lexerMode - for the lexer mode
  - getLexerModeRoutine
```
public String getLexerModeRoutine(String lexerMode)
```
    Description copied from interface: LanguageSupport
    
    Given a lexer mode, return the routine definition
    
    Parameters:
    
    lexerMode - is the desired lexer mode
    
    Returns:
    
    the routine definition
  - generateLexerModeFooter
```
public void generateLexerModeFooter(String lexerMode)
```
    Description copied from interface: LanguageSupport
    
    Emit a lexer function footer by mode
    
    Parameters:
    
    lexerMode - for the lexer mode
  - generateLexerFooter
```
public void generateLexerFooter()
```
    Description copied from interface: LanguageSupport
    
    Generate the bottom of the lexer
  - generateLexerModeDefinition
```
public void generateLexerModeDefinition(String lexerMode,
                                        int index)
```
    Description copied from interface: LanguageSupport
    
    Generate the constant or 'define" for a given lexer mode
    
    Parameters:
    
    lexerMode - is the mode of the lexer
    
    index - is the index of the definition
  - generateLexerModeCase
```
public void generateLexerModeCase(String lexerMode,
                                  int index)
```
    Description copied from interface: LanguageSupport
    
    Generate the constant or 'define" for a given lexer mode
    
    Parameters:
    
    lexerMode - is the mode of the lexer
    
    index - is the index of the definition
  - generateCodeGeneratorHeader
```
public void generateCodeGeneratorHeader()
```
    Description copied from interface: LanguageSupport
    
    Output the top of the rules if needed
  - generateCodeGeneratorFooter
```
public void generateCodeGeneratorFooter()
```
    Description copied from interface: LanguageSupport
    
    Generate the ending portion of the code generation
  - generateVoidCodeGenerator
```
public void generateVoidCodeGenerator()
```
    Description copied from interface: LanguageSupport
    
    there was no code generated. Generate a good-for-nothing code generator routine.
  - generateRecoveryTableHeader
```
public void generateRecoveryTableHeader(int numberOfErrorTokens)
```
    Description copied from interface: LanguageSupport
    
    The recovery table deals with tokens that can be used to recognize syntax context and can recover from errors.
    
    Parameters:
    
    numberOfErrorTokens - is the number of errors
  - generateStructure
```
public boolean generateStructure(Lexer lexer)
```
    Description copied from interface: LanguageSupport
    
    For yacc compatibility this is called the union, but it is really a structure
    
    Parameters:
    
    lexer - is the lexical analyzer
    
    Returns:
    
    true if OK
  - generateErrorToken
```
public void generateErrorToken(int recoveryToken,
                               ErrorToken id,
                               boolean isLast)
```
    Description copied from interface: LanguageSupport
    
    Generates one entry for an error token
    
    Parameters:
    
    recoveryToken - the recovery id
    
    id - the ErrorToken
    
    isLast - to check if this is the last
  - generateTokensHeader
```
public void generateTokensHeader(int terminals)
```
    Description copied from interface: LanguageSupport
    
    Generates the top part of the token definition
    
    Parameters:
    
    terminals - is the number of terminal symbols
  - generateToken
```
public void generateToken(Terminal id,
                          boolean isLast)
```
    Description copied from interface: LanguageSupport
    
    Generate the code for a given token
    
    Parameters:
    
    id - is the token itself
    
    isLast - to determine the way to emit the last token
  - generateTokenDefinitions
```
public void generateTokenDefinitions()
```
    Description copied from interface: LanguageSupport
    
    Declare all the tokens
  - escapeDoubleQuotes
```
protected String escapeDoubleQuotes(String error)
```
    Overrides:
    
    escapeDoubleQuotes in class BaseLanguageSupport
  - lexerDollar
```
protected boolean lexerDollar(FormattingPrintStream output,
                              String lexerMode,
                              Lexer lexer,
                              Terminal token)
```
    Overrides:
    
    lexerDollar in class BaseLanguageSupport
  - lexerReturnValue
```
protected void lexerReturnValue(FormattingPrintStream output,
                                String lexerMode,
                                Lexer lexer)
```
  - generateLexerCode
```
public boolean generateLexerCode(FormattingPrintStream output,
                                 String lexerMode,
                                 Lexer lexer,
                                 Terminal token,
                                 int additionalIndent)
```
    Description copied from interface: LanguageSupport
    
    Emit the code for the lexical part of the grammar
    
    Specified by:
    
    generateLexerCode in interface LanguageSupport
    
    Overrides:
    
    generateLexerCode in class BaseLanguageSupport
    
    Parameters:
    
    output - is the stream to write to
    
    lexerMode - is the string representing the desired mode
    
    lexer - is the lexer to obtain more characters
    
    token - is the current token for which generation is attempted
    
    additionalIndent - is the wanted indentation delta
    
    Returns:
    
    true if OK
  - printCodeHeader
```
public void printCodeHeader()
```
    Description copied from interface: LanguageSupport
    
    print the declarations for the rest of the code
  - printTableRow
```
public void printTableRow(int symbolCounter,
                          int[] parserLine,
                          int stateNumber)
```
    Description copied from interface: LanguageSupport
    
    print one row of the parsing table
    
    Parameters:
    
    symbolCounter - is the number of symbols
    
    parserLine - is the array of lines
    
    stateNumber - is the state number
  - printParserErrors
```
public void printParserErrors()
```
    Description copied from interface: LanguageSupport
    
    Display the errors of the parser
  - printParsingTableHeader
```
public void printParsingTableHeader()
```
    Description copied from interface: LanguageSupport
    
    Declare the parsing table
  - printPackedState
```
public void printPackedState(int stateNumber)
```
    Description copied from interface: LanguageSupport
    
    print a state in packed fashion
    
    Parameters:
    
    stateNumber - is the id of the state
  - printErrorTableHeader
```
public void printErrorTableHeader()
```
    Description copied from interface: LanguageSupport
    
    declare the error table
  - printErrorEntry
```
public void printErrorEntry(int error)
```
    Description copied from interface: LanguageSupport
    
    Add errors to the table
    
    Parameters:
    
    error - is the error number
  - printErrorFooter
```
public void printErrorFooter()
```
    Description copied from interface: LanguageSupport
    
    Close the error table
  - printActionHeader
```
public void printActionHeader()
```
    Description copied from interface: LanguageSupport
    
    emit the header of the action table
  - printAction
```
public void printAction(int action,
                        Action anAction)
```
    Description copied from interface: LanguageSupport
    
    Emit one action
    
    Parameters:
    
    action - the action id
    
    anAction - the actual action
  - printGoToTableHeader
```
public void printGoToTableHeader()
```
    Description copied from interface: LanguageSupport
    
    emit the goto table header
  - printGoTo
```
public void printGoTo(int gotoIndex,
                      GoTo pGoto)
```
    Description copied from interface: LanguageSupport
    
    Emit one go to
    
    Parameters:
    
    gotoIndex - the number of gotos
    
    pGoto - the actual goto
  - printMissingSkeleton
```
public void printMissingSkeleton(String filename)
```
    Description copied from interface: LanguageSupport
    
    The skeleton was not found, say so.
    
    Parameters:
    
    filename - the missing skeleton
  - printGrammarTable
```
public void printGrammarTable()
```
    Description copied from interface: LanguageSupport
    
    Output the whole grammar table
  - generateEdgeHeader
```
public void generateEdgeHeader(int size)
```
    Description copied from interface: LanguageSupport
    
    Generate the code for the edge table beginning
    
    Parameters:
    
    size - is the size of the table
  - generateVertexHeader
```
public void generateVertexHeader(int size)
```
    Description copied from interface: LanguageSupport
    
    Generate the vertex header
    
    Parameters:
    
    size - is the number of nodes
  - generateIntArrayRow
```
public void generateIntArrayRow(int i,
                                String comment,
                                int index,
                                int maxSize)
```
    Description copied from interface: LanguageSupport
    
    Output a row in an integer array
    
    Parameters:
    
    i - is the integer to output
    
    index - is the row of this item
    
    maxSize - is the size of the array. Used to determine commas, etc.
  - generateIntArrayComment
```
public void generateIntArrayComment(String comment)
```
    Description copied from interface: LanguageSupport
    
    Output a comment in an array
    
    Parameters:
    
    comment - is the comment to output
  - generateIntArrayFooter
```
public void generateIntArrayFooter()
```
    Description copied from interface: LanguageSupport
    
    Output the end of an int array
  - generateRegexMatch
```
public void generateRegexMatch(FormattingPrintStream output,
                               int dfaNode)
```
    Description copied from interface: LanguageSupport
    
    Generate if statement for a regular expression match
    
    Parameters:
    
    output - is the code stream
    
    dfaNode - is the starting dfa node to begin the match
  - generateRegexReturn
```
public void generateRegexReturn(FormattingPrintStream output,
                                Terminal token)
```
    Description copied from interface: LanguageSupport
    
    Generate the default return token for a regexp
    
    Parameters:
    
    output - is the code stream
    
    token - is the token that it returns
  - generateRegexEnd
```
public void generateRegexEnd(FormattingPrintStream output)
```
    Description copied from interface: LanguageSupport
    
    Generate the bottom of a regex match in the scanner
    
    Parameters:
    
    output - is the code stream

Class Pascal

Field Summary

Fields inherited from class me.jaimegarza.syntax.language.BaseLanguageSupport

Constructor Summary

Method Summary

Methods inherited from class me.jaimegarza.syntax.language.BaseLanguageSupport

Methods inherited from class java.lang.Object

Constructor Detail

Pascal

Method Detail

getLanguageCode

getId

getExtensionSuffix

getIncludeExtensionSuffix

getDefaultIncludeFlag

generateCaseStart

generateCaseEnd

generateRuleCode

generateLexerHeader

generateLexerModeHeader

getLexerModeRoutine

generateLexerModeFooter

generateLexerFooter

generateLexerModeDefinition

generateLexerModeCase

generateCodeGeneratorHeader

generateCodeGeneratorFooter

generateVoidCodeGenerator

generateRecoveryTableHeader

generateStructure

generateErrorToken

generateTokensHeader

generateToken

generateTokenDefinitions

escapeDoubleQuotes

lexerDollar

lexerReturnValue

generateLexerCode

printCodeHeader

printTableRow

printParserErrors

printParsingTableHeader

printPackedState

printErrorTableHeader

printErrorEntry

printErrorFooter

printActionHeader

printAction

printGoToTableHeader

printGoTo

printMissingSkeleton

printGrammarTable

generateEdgeHeader

generateVertexHeader

generateIntArrayRow

generateIntArrayComment

generateIntArrayFooter

generateRegexMatch

generateRegexReturn

generateRegexEnd