java.lang.Object

cruise.umple.parser.analysis.GrammarAnalyzer

public class GrammarAnalyzer
extends java.lang.Object

The grammar analayzer deals with first analyzing the root token of the grammar files, and constructing the rule graph for the grammar then it has a execute function which will use the rule graph in the parsing of the umple file.

Nested Class Summary

Nested Classes

Modifier and Type Class Description

class GrammarAnalyzer.Getter<T>
Constructor Summary

Constructors

Constructor Description

GrammarAnalyzer()

Method Summary

Modifier and Type	Method	Description
`boolean`	`addAnalyzer(Analyzer aAnalyzer)`
`void`	`addAnalyzerFromStack()`
`boolean`	`addAnalyzerRule(ChoiceRule aAnalyzerRule)`
`boolean`	`addCloseTerminal(Terminal aCloseTerminal)`
`boolean`	`addOpenTerminal(Terminal aOpenTerminal)`
`void`	`addParserAction(java.lang.String name, ParserAction action)`	Adds a parser action to operate on an action token of the specified name
`boolean`	`addThread(RuleBasedParserThread aThread)`
`void`	`analyze(Token tokens)`
`void`	`anonymousRule(Token token)`	These are rules that are specified within brackets, and are therefore not Tokenized.
`void`	`braced(Token token)`	{} and "" are special couple characters and are handled by making a BalancedRule which will ensure that the { is paired with the proper } and so on
`void`	`definition(Token token)`	The definition token is used both for the rule definition, and anonymous rules(rules containsed within paratheses).
`void`	`delete()`
`void`	`execute()`	Performs the parsing on the umple file.
`java.util.HashMap<java.lang.String,ParserAction>`	`getActionedTokens()`	currently only implemented with useStatement as the only element of this hashmap, but it is extendable, should the need arise.
`Analyzer`	`getAnalyzer(int index)`
`AnalyzerGeneratorHandler`	`getAnalyzerGenerator()`	The handler to control generation of Analyzer objects at runtime
`java.util.Map<java.lang.String,Analyzer>`	`getAnalyzerMap()`
`ChoiceRule`	`getAnalyzerRule(int index)`
`ChoiceRule[]`	`getAnalyzerRules()`
`Analyzer[]`	`getAnalyzers()`
`java.util.Stack<Analyzer>`	`getAnalyzerStack()`
`Terminal[]`	`getCloseTerminal()`
`Terminal`	`getCloseTerminal(int index)`
`ParserDataPackage`	`getData()`	the data package used during the parsing.
`boolean`	`getDone()`
`Position`	`getFailedPosition()`	the failed position, if there was one, it will remain null if the parse was successful
`java.io.File`	`getFile()`	Umple file that will be parsed(like Master.ump)
`boolean`	`getFirst()`
`java.util.HashMap<java.lang.String,java.lang.Object>`	`getGlobal()`	hashmap of global variables(local to the class, not local to methods)
`java.lang.String`	`getInput()`	filename of the file to be parsed
`GrammarAnalyzer.Getter<java.lang.Integer>`	`getInts()`
`java.util.HashMap<java.lang.String,java.lang.String[]>`	`getKeys()`	The keys that will be used by the couples of this hash map
`LinkedFileHandler`	`getLinkedFileHandler()`	The handler for dealing with linked files
`boolean`	`getMustSetupAnalyzers()`
`boolean`	`getNoSpaces()`	if a balanced rule is created, it needs to know if the current context is nospaces or not
`Terminal[]`	`getOpenTerminal()`
`Terminal`	`getOpenTerminal(int index)`
`ParseResult`	`getParseResult()`	resulting parse result from the parse
`Token`	`getRootToken()`	rootToken which will be the result of the parsing of the umple file passed
`GrammarAnalyzer.Getter<ChoiceRule>`	`getRules()`	Global variable getters and setters
`GrammarAnalyzer.Getter<java.util.Stack<ChoiceRule>>`	`getStacks()`
`GrammarAnalyzer.Getter<java.lang.String>`	`getStrings()`
`RuleBasedParserThread`	`getThread(int index)`
`RuleBasedParserThread[]`	`getThreads()`
`java.lang.String`	`getValue(Token token, java.lang.String name)`	Simple method to handle token values.
`boolean`	`hasAnalyzerRules()`
`boolean`	`hasAnalyzers()`
`boolean`	`hasCloseTerminal()`
`boolean`	`hasOpenTerminal()`
`boolean`	`hasThreads()`
`int`	`indexOfAnalyzer(Analyzer aAnalyzer)`
`int`	`indexOfAnalyzerRule(ChoiceRule aAnalyzerRule)`
`int`	`indexOfCloseTerminal(Terminal aCloseTerminal)`
`int`	`indexOfOpenTerminal(Terminal aOpenTerminal)`
`int`	`indexOfThread(RuleBasedParserThread aThread)`
`void`	`init(java.io.File file, java.io.File[] linkedFiles)`	Must be called before use with the execute function, this function sets up the file for parsing
`void`	`init(java.lang.String ruleName, java.lang.String input)`
`void`	`init(java.lang.String ruleName, java.lang.String input, java.lang.String fileName, Position usePosition, int lineNumber, int offset)`
`boolean`	`isNoSpaces()`
`boolean`	`makeAnalyzer(java.lang.String name)`
`int`	`numberOfAnalyzerRules()`
`int`	`numberOfAnalyzers()`
`int`	`numberOfCloseTerminal()`
`int`	`numberOfOpenTerminal()`
`int`	`numberOfThreads()`
`void`	`otherrule(Token token)`	Otherrule tokens are for rule names within a definition, where the otherrule is defined elsewhere.
`boolean`	`removeAnalyzer(Analyzer aAnalyzer)`
`boolean`	`removeAnalyzerRule(ChoiceRule aAnalyzerRule)`
`boolean`	`removeCloseTerminal(Terminal aCloseTerminal)`
`boolean`	`removeOpenTerminal(Terminal aOpenTerminal)`
`boolean`	`removeThread(RuleBasedParserThread aThread)`
`void`	`rule(Token token)`	The rule token denotes the beginning of a rule definition.
`void`	`rules(Token token)`	--Analyze Rule Methods The rules token contains all the rules in a grammar file.
`void`	`separator(Token token)`	The separator token denotes the \| in a rule.
`protected void`	`set(java.lang.String string, java.lang.Object object)`	This funciton is used for putting things into the global hashmap that contains all objects
`boolean`	`setActionedTokens(java.util.HashMap<java.lang.String,ParserAction> aActionedTokens)`
`boolean`	`setAnalyzerGenerator(AnalyzerGeneratorHandler aAnalyzerGenerator)`
`boolean`	`setAnalyzerMap(java.util.Map<java.lang.String,Analyzer> aAnalyzerMap)`
`boolean`	`setAnalyzerStack(java.util.Stack<Analyzer> aAnalyzerStack)`
`boolean`	`setData(ParserDataPackage aData)`
`boolean`	`setDone(boolean aDone)`
`boolean`	`setFailedPosition(Position aFailedPosition)`
`boolean`	`setFile(java.io.File aFile)`
`boolean`	`setFirst(boolean aFirst)`
`boolean`	`setGlobal(java.util.HashMap<java.lang.String,java.lang.Object> aGlobal)`
`boolean`	`setInput(java.lang.String aInput)`
`boolean`	`setInts(GrammarAnalyzer.Getter<java.lang.Integer> aInts)`
`boolean`	`setKeys(java.util.HashMap<java.lang.String,java.lang.String[]> aKeys)`
`boolean`	`setLinkedFileHandler(LinkedFileHandler aLinkedFileHandler)`
`boolean`	`setMustSetupAnalyzers(boolean aMustSetupAnalyzers)`
`boolean`	`setNoSpaces(boolean aNoSpaces)`
`boolean`	`setParseResult(ParseResult aParseResult)`
`boolean`	`setRootToken(Token aRootToken)`
`boolean`	`setRules(GrammarAnalyzer.Getter<ChoiceRule> aRules)`
`boolean`	`setStacks(GrammarAnalyzer.Getter<java.util.Stack<ChoiceRule>> aStacks)`
`boolean`	`setStrings(GrammarAnalyzer.Getter<java.lang.String> aStrings)`
`void`	`setupAlphanumericTerminal(Terminal terminal)`	Similar to the setupTerminal function this function makes sure that an alphanumeric does not take a value that is the value of then next terminal for instance if an association looks like * -- 1 Student sorted { }; the rolename is student not sorted.
`java.util.List<Analyzer>`	`setupAnalyzers()`
`java.util.List<Analyzer>`	`setupAnalyzers(Analyzer analyzer, ChoiceRule parent, java.util.List<ChoiceRule> checked)`
`void`	`setupTerminal(Terminal terminal)`	Sets up the tokens with no premodifier to make sure they stop at the right place, for instance [type] [=list[]]? should stop before the [], so the type only contains String, instead of String[]
`void`	`setupTerminals()`	There are some terminals that need to use their surroundings to determine what they can and cannot take on as values this function iterates through all such terminals
`void`	`terminal(Token token)`	Terminals are keywords or syntax.
`void`	`token(Token token)`	Tokens are of the form [{premodifier}tokenname{:value}] and denote a Terminal rule where the a Token is created with the value specified by some premodifier
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object

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

Constructor Details
- GrammarAnalyzer
  
  public GrammarAnalyzer()
Method Details
- setDone
  
  public boolean setDone(boolean aDone)
- setFirst
  
  public boolean setFirst(boolean aFirst)
- setLinkedFileHandler
  
  public boolean setLinkedFileHandler(LinkedFileHandler aLinkedFileHandler)
- setAnalyzerGenerator
  
  public boolean setAnalyzerGenerator(AnalyzerGeneratorHandler aAnalyzerGenerator)
- setGlobal
  
  public boolean setGlobal(java.util.HashMap<java.lang.String,java.lang.Object> aGlobal)
- setRootToken
  
  public boolean setRootToken(Token aRootToken)
- setData
  
  public boolean setData(ParserDataPackage aData)
- setFailedPosition
  
  public boolean setFailedPosition(Position aFailedPosition)
- setRules
  
  public boolean setRules(GrammarAnalyzer.Getter<ChoiceRule> aRules)
- setStacks
  
  public boolean setStacks(GrammarAnalyzer.Getter<java.util.Stack<ChoiceRule>> aStacks)
- setStrings
  
  public boolean setStrings(GrammarAnalyzer.Getter<java.lang.String> aStrings)
- setInts
  
  public boolean setInts(GrammarAnalyzer.Getter<java.lang.Integer> aInts)
- setActionedTokens
  
  public boolean setActionedTokens(java.util.HashMap<java.lang.String,ParserAction> aActionedTokens)
- setKeys
  
  public boolean setKeys(java.util.HashMap<java.lang.String,java.lang.String[]> aKeys)
- addThread
  
  public boolean addThread(RuleBasedParserThread aThread)
- removeThread
  
  public boolean removeThread(RuleBasedParserThread aThread)
- setFile
  
  public boolean setFile(java.io.File aFile)
- setInput
  
  public boolean setInput(java.lang.String aInput)
- setNoSpaces
  
  public boolean setNoSpaces(boolean aNoSpaces)
- setAnalyzerStack
  
  public boolean setAnalyzerStack(java.util.Stack<Analyzer> aAnalyzerStack)
- setAnalyzerMap
  
  public boolean setAnalyzerMap(java.util.Map<java.lang.String,Analyzer> aAnalyzerMap)
- setParseResult
  
  public boolean setParseResult(ParseResult aParseResult)
- addOpenTerminal
  
  public boolean addOpenTerminal(Terminal aOpenTerminal)
- removeOpenTerminal
  
  public boolean removeOpenTerminal(Terminal aOpenTerminal)
- addCloseTerminal
  
  public boolean addCloseTerminal(Terminal aCloseTerminal)
- removeCloseTerminal
  
  public boolean removeCloseTerminal(Terminal aCloseTerminal)
- addAnalyzerRule
  
  public boolean addAnalyzerRule(ChoiceRule aAnalyzerRule)
- removeAnalyzerRule
  
  public boolean removeAnalyzerRule(ChoiceRule aAnalyzerRule)
- addAnalyzer
  
  public boolean addAnalyzer(Analyzer aAnalyzer)
- removeAnalyzer
  
  public boolean removeAnalyzer(Analyzer aAnalyzer)
- setMustSetupAnalyzers
  
  public boolean setMustSetupAnalyzers(boolean aMustSetupAnalyzers)
- getDone
  
  public boolean getDone()
- getFirst
  
  public boolean getFirst()
- getLinkedFileHandler
  
  public LinkedFileHandler getLinkedFileHandler()
  
  The handler for dealing with linked files
- getAnalyzerGenerator
  
  public AnalyzerGeneratorHandler getAnalyzerGenerator()
  
  The handler to control generation of Analyzer objects at runtime
- getGlobal
  
  public java.util.HashMap<java.lang.String,java.lang.Object> getGlobal()
  
  hashmap of global variables(local to the class, not local to methods)
- getRootToken
  
  public Token getRootToken()
  
  rootToken which will be the result of the parsing of the umple file passed
- getData
  
  public ParserDataPackage getData()
  
  the data package used during the parsing.
- getFailedPosition
  
  public Position getFailedPosition()
  
  the failed position, if there was one, it will remain null if the parse was successful
- getRules
  
  public GrammarAnalyzer.Getter<ChoiceRule> getRules()
  
  Global variable getters and setters
- getStacks
  
  public GrammarAnalyzer.Getter<java.util.Stack<ChoiceRule>> getStacks()
- getStrings
  
  public GrammarAnalyzer.Getter<java.lang.String> getStrings()
- getInts
  
  public GrammarAnalyzer.Getter<java.lang.Integer> getInts()
- getActionedTokens
  
  public java.util.HashMap<java.lang.String,ParserAction> getActionedTokens()
  
  currently only implemented with useStatement as the only element of this hashmap, but it is extendable, should the need arise.
- getKeys
  
  public java.util.HashMap<java.lang.String,java.lang.String[]> getKeys()
  
  The keys that will be used by the couples of this hash map
- getThread
  
  public RuleBasedParserThread getThread(int index)
- getThreads
  
  public RuleBasedParserThread[] getThreads()
- numberOfThreads
  
  public int numberOfThreads()
- hasThreads
  
  public boolean hasThreads()
- indexOfThread
  
  public int indexOfThread(RuleBasedParserThread aThread)
- getFile
  
  public java.io.File getFile()
  
  Umple file that will be parsed(like Master.ump)
- getInput
  
  public java.lang.String getInput()
  
  filename of the file to be parsed
- getNoSpaces
  
  public boolean getNoSpaces()
  
  if a balanced rule is created, it needs to know if the current context is nospaces or not
- getAnalyzerStack
  
  public java.util.Stack<Analyzer> getAnalyzerStack()
- getAnalyzerMap
  
  public java.util.Map<java.lang.String,Analyzer> getAnalyzerMap()
- getParseResult
  
  public ParseResult getParseResult()
  
  resulting parse result from the parse
- getOpenTerminal
  
  public Terminal getOpenTerminal(int index)
- getOpenTerminal
  
  public Terminal[] getOpenTerminal()
- numberOfOpenTerminal
  
  public int numberOfOpenTerminal()
- hasOpenTerminal
  
  public boolean hasOpenTerminal()
- indexOfOpenTerminal
  
  public int indexOfOpenTerminal(Terminal aOpenTerminal)
- getCloseTerminal
  
  public Terminal getCloseTerminal(int index)
- getCloseTerminal
  
  public Terminal[] getCloseTerminal()
- numberOfCloseTerminal
  
  public int numberOfCloseTerminal()
- hasCloseTerminal
  
  public boolean hasCloseTerminal()
- indexOfCloseTerminal
  
  public int indexOfCloseTerminal(Terminal aCloseTerminal)
- getAnalyzerRule
  
  public ChoiceRule getAnalyzerRule(int index)
- getAnalyzerRules
  
  public ChoiceRule[] getAnalyzerRules()
- numberOfAnalyzerRules
  
  public int numberOfAnalyzerRules()
- hasAnalyzerRules
  
  public boolean hasAnalyzerRules()
- indexOfAnalyzerRule
  
  public int indexOfAnalyzerRule(ChoiceRule aAnalyzerRule)
- getAnalyzer
  
  public Analyzer getAnalyzer(int index)
- getAnalyzers
  
  public Analyzer[] getAnalyzers()
- numberOfAnalyzers
  
  public int numberOfAnalyzers()
- hasAnalyzers
  
  public boolean hasAnalyzers()
- indexOfAnalyzer
  
  public int indexOfAnalyzer(Analyzer aAnalyzer)
- getMustSetupAnalyzers
  
  public boolean getMustSetupAnalyzers()
- isNoSpaces
  
  public boolean isNoSpaces()
- delete
  
  public void delete()
- set
  
  protected void set(java.lang.String string, java.lang.Object object)
  
  This funciton is used for putting things into the global hashmap that contains all objects
- addParserAction
  
  public void addParserAction(java.lang.String name, ParserAction action)
  
  Adds a parser action to operate on an action token of the specified name
  
  Parameters:
  
  name - the name of the token to perform the action
  
  action - the ParserAction to perform
- init
  
  public void init(java.io.File file, java.io.File[] linkedFiles)
  
  Must be called before use with the execute function, this function sets up the file for parsing
- init
  
  public void init(java.lang.String ruleName, java.lang.String input)
- init
  
  public void init(java.lang.String ruleName, java.lang.String input, java.lang.String fileName, Position usePosition, int lineNumber, int offset)
- execute
  
  public void execute()
  
  Performs the parsing on the umple file.
- rules
  
  public void rules(Token token)
  
  --Analyze Rule Methods The rules token contains all the rules in a grammar file.
- makeAnalyzer
  
  public boolean makeAnalyzer(java.lang.String name)
- rule
  
  public void rule(Token token)
  
  The rule token denotes the beginning of a rule definition.
- addAnalyzerFromStack
  
  public void addAnalyzerFromStack()
- definition
  
  public void definition(Token token)
  
  The definition token is used both for the rule definition, and anonymous rules(rules containsed within paratheses).
- otherrule
  
  public void otherrule(Token token)
  
  Otherrule tokens are for rule names within a definition, where the otherrule is defined elsewhere.
- getValue
  
  public java.lang.String getValue(Token token, java.lang.String name)
  
  Simple method to handle token values.
- terminal
  
  public void terminal(Token token)
  
  Terminals are keywords or syntax.
- token
  
  public void token(Token token)
  
  Tokens are of the form [{premodifier}tokenname{:value}] and denote a Terminal rule where the a Token is created with the value specified by some premodifier
- anonymousRule
  
  public void anonymousRule(Token token)
  
  These are rules that are specified within brackets, and are therefore not Tokenized.
- braced
  
  public void braced(Token token)
  
  {} and "" are special couple characters and are handled by making a BalancedRule which will ensure that the { is paired with the proper } and so on
- separator
  
  public void separator(Token token)
  
  The separator token denotes the | in a rule. It means that everything before a separator is contained within one Rule and everything after the | is contained in a separate Rule. The parent to both of these rules is a ChoiceRule, meaning that each of the rules created will be tried.
- setupTerminals
  
  public void setupTerminals()
  
  There are some terminals that need to use their surroundings to determine what they can and cannot take on as values this function iterates through all such terminals
- setupAlphanumericTerminal
  
  public void setupAlphanumericTerminal(Terminal terminal)
  
  Similar to the setupTerminal function this function makes sure that an alphanumeric does not take a value that is the value of then next terminal for instance if an association looks like * -- 1 Student sorted { }; the rolename is student not sorted. This works also for having * -- 1 Student sorted sorted { }; which will be a sorted list of students called sorted. (i.e. if the next one is accounted for then everything proceeds as normal)
- setupTerminal
  
  public void setupTerminal(Terminal terminal)
  
  Sets up the tokens with no premodifier to make sure they stop at the right place, for instance [type] [=list[]]? should stop before the [], so the type only contains String, instead of String[]
- analyze
  
  public void analyze(Token tokens)
- setupAnalyzers
  
  public java.util.List<Analyzer> setupAnalyzers()
- setupAnalyzers
  
  public java.util.List<Analyzer> setupAnalyzers(Analyzer analyzer, ChoiceRule parent, java.util.List<ChoiceRule> checked)
- toString
  
  public java.lang.String toString()
  
  Overrides:
  
  toString in class java.lang.Object

Class GrammarAnalyzer

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Details

Method Details