public static void Initialize(ref Grammar grammar)
{
grammar.Add(new Production(ParserConstants.Declaration,
new SubProduction
(
new List <ExpressionDefinition>
{
new TerminalExpressionDefinition {
TokenType = TokenType.TypeDeclaration
},
new TerminalExpressionDefinition {
TokenType = TokenType.Identifier
},
new SemanticActionDefinition((ParsingNode node) =>
{
string type = node.GetAttributeForKey <WordToken>(ParserConstants.TypeDeclaration, ParserConstants.Token).Lexeme;
SymbolTable symbolTable = node.FirstParentWithAttribute(ParserConstants.SymTable).GetAttribute <SymbolTable>(ParserConstants.SymTable);
string key = node.GetAttributeForKey <WordToken>("Identifier", ParserConstants.Token).Lexeme;
SymbolTableEntryType symbolEntryType = SymbolTable.StringToSymbolTableEntryType(type);
SymbolTableEntry entry = symbolTable.Create(key, symbolEntryType);
DeclarationASTNode syntaxTreeNode = new DeclarationASTNode();
syntaxTreeNode.SymbolTableEntry = entry;
node.Attributes.Add(ParserConstants.SyntaxTreeNode, syntaxTreeNode);
})
}
)
));;
}
public void Add(string key, PinDataType type)
{
SymbolTableEntry entry;
switch (type)
{
default:
case PinDataType.Integer:
entry = new SymbolTableEntry <int>();
break;
case PinDataType.Number:
entry = new SymbolTableEntry <float>();
break;
case PinDataType.String:
entry = new SymbolTableEntry <string>();
break;
case PinDataType.Vector:
entry = new SymbolTableEntry <Vector3>();
break;
}
symbolTable[key] = entry;
}
private static SubProduction GetIdentifierRule()
{
return(new SubProduction
(
new List <ExpressionDefinition>
{
new TerminalExpressionDefinition {
TokenType = TokenType.Identifier
},
new SemanticActionDefinition((ParsingNode node) =>
{
SymbolTable symbolTable = node.CurrentSymbolTable;
string key = node.GetAttributeForKey <WordToken>(ParserConstants.Identifier, ParserConstants.Token).Lexeme;
SymbolTableEntry entry = symbolTable.GetOrThrow(key);
node.Attributes.Add(ParserConstants.SymbolTableEntry, entry);
node.Attributes.Add(ParserConstants.Token, node.GetAttributeForKey <WordToken>(ParserConstants.Identifier, ParserConstants.Token));
node.Attributes.Add(ParserConstants.SyntaxTreeNode, new IdentifierASTNode()
{
SymbolTableEntry = entry
});
})
}
));
}
public SymbolTableEntry GetEntryFromSymbol(string symbol)
{
string tmpname = symbol.Trim().ToUpper();
SymbolTableEntry retval = null;
symbolIndexList.TryGetValue(tmpname, out retval);
return(retval);
}
public SymbolTableEntry GetEntryFromOperand(string operand)
{
string tmpname = operand.Replace(" ", "");
SymbolTableEntry retval = null;
operandIndexList.TryGetValue(tmpname, out retval);
return(retval);
}
public void CanLookupEntry()
{
sut.Enter("ABC");
SymbolTableEntry entry = sut.Lookup("ABC");
Assert.AreEqual("ABC", entry.Name);
Assert.AreEqual(SymbolTableEntry.None, sut.Lookup("ABE"));
}
public void CanEnterEntry()
{
SymbolTableEntry entry = sut.Enter("ABC");
Assert.IsNotNull(entry);
Assert.AreEqual("ABC", entry.Name);
Assert.AreEqual(1, sut.NumberOfEntries);
}
public void Add <T>(string key)
{
createST();
SymbolTableEntry entry;
entry = new SymbolTableEntry <T>();
symbolTable[key] = entry;
}
public void CanHandleExistingEntry()
{
SymbolTableEntry entry1 = sut.Enter("ABC");
SymbolTableEntry entry2 = sut.Enter("ABC");
Assert.AreEqual("ABC", entry1.Name);
Assert.AreEqual("ABC", entry2.Name);
Assert.AreEqual(1, sut.NumberOfEntries);
Assert.AreSame(entry1, sut.Lookup("ABC"));
}
public SymbolTableEntry GetEntryFromOperand(string operand)
{
if (_step7SymbolTableEntrys == null)
{
LoadSymboltable();
}
string tmpname = operand.Replace(" ", "");
SymbolTableEntry retval = null;
operandIndexList.TryGetValue(tmpname, out retval);
return(retval);
}
public bool GetInt(string key, out int value)
{
SymbolTableEntry <int> entry = ((SymbolTableEntry <int>)searchTable(key));
if (entry != null)
{
value = entry.value;
return(true);
}
value = 0;
return(false);
}
public bool GetFloat(string key, out float value)
{
SymbolTableEntry <float> entry = ((SymbolTableEntry <float>)searchTable(key));
if (entry != null)
{
value = entry.value;
return(true);
}
value = 0.0f;
return(false);
}
public bool GetString(string key, out string value)
{
SymbolTableEntry <string> entry = ((SymbolTableEntry <string>)searchTable(key));
if (entry != null)
{
value = entry.value;
return(true);
}
value = "";
return(false);
}
public bool GetVector(string key, out Vector3 value)
{
SymbolTableEntry <Vector3> entry = ((SymbolTableEntry <Vector3>)searchTable(key));
if (entry != null)
{
value = entry.value;
return(true);
}
value = new Vector3();
return(false);
}
public void Set <T>(string key, T value)
{
SymbolTableEntry ste = searchTable(key);
if (ste == null)
{
Debug.Log("Key " + key + " not found.");
}
else
{
((SymbolTableEntry <T>)ste).value = value;
}
}
public bool Get <T>(string key, out dynamic value)
{
SymbolTableEntry <T> entry = ((SymbolTableEntry <T>)searchTable(key));
if (entry != null)
{
value = entry.value;
return(true);
}
value = 0;
return(false);
}
internal void LoadSymboltable()
{
_step7SymbolTableEntrys = new List <SymbolTableEntry>();
if (!string.IsNullOrEmpty(Folder))
{
try
{
var dbfTbl = DBF.ParseDBF.ReadDBF(Folder + "SYMLIST.DBF", ((Step7ProjectV5)Project)._ziphelper, ((Step7ProjectV5)Project)._DirSeperator);
// Update timestamp based on the file timestamp for now
// TODO: Read timestamo from the SYMLISTS.DBF?
LastChange = ((Step7ProjectV5)Project)._ziphelper.FileModDateTime(Folder + "SYMLIST.DBF");
// Parse all symbols
foreach (DataRow row in dbfTbl.Rows)
{
if (!(bool)row["DELETED_FLAG"] || showDeleted)
{
SymbolTableEntry sym = new SymbolTableEntry();
sym.Symbol = (string)row["_SKZ"];
sym.Operand = (string)row["_OPHIST"];
sym.OperandIEC = (string)row["_OPIEC"];
sym.DataType = (string)row["_DATATYP"];
sym.Comment = (string)row["_COMMENT"];
if ((bool)row["DELETED_FLAG"])
{
sym.Comment = "(deleted) " + sym.Comment;
}
_step7SymbolTableEntrys.Add(sym);
string oper = sym.Operand.Replace(" ", "");
string addSym = sym.Symbol.ToUpper().Trim();
if (!string.IsNullOrEmpty(addSym))
{
if (!operandIndexList.ContainsKey(oper))
{
operandIndexList.Add(oper, sym);
}
if (!symbolIndexList.ContainsKey(addSym))
{
symbolIndexList.Add(addSym, sym);
}
}
}
}
}
catch (Exception ex)
{
}
}
}
public void CanCreateLogoRoutine()
{
LogoController.CreateAndParse("TO RECTANGLE REPEAT 4 [ FORWARD 100 LEFT 90 ] END");
SymbolTableEntry routine = LogoController.LookupRoutine("RECTANGLE");
Assert.IsNotNull(routine);
Assert.AreEqual("RECTANGLE", routine.Name);
var routineAttribute = routine.Attributes[0] as SymbolTableRoutineAttribute;
Assert.IsNotNull(routineAttribute);
var firstCommand = routineAttribute.Commands[0] as LogoRepeatCommand;
Assert.IsNotNull(firstCommand);
Assert.AreEqual(4, firstCommand.Repeat);
Assert.AreEqual(2, firstCommand.Commands.Count());
}
private static SubProduction FunctionCall()
{
return(new SubProduction
(
new List <ExpressionDefinition>
{
new TerminalExpressionDefinition {
TokenType = TokenType.Identifier
},
new SemanticActionDefinition((ParsingNode node) =>
{
SymbolTable symbolTable = node.CurrentSymbolTable;
string key = node.GetAttributeForKey <WordToken>(ParserConstants.Identifier, ParserConstants.Token).Lexeme;
SymbolTableEntry entry = symbolTable.GetOrThrow(key);
node.GetNodeForKey("Identifier").Attributes.Add(ParserConstants.SymbolTableEntry, entry);
node.GetNodeForKey("Identifier").Attributes.Add(ParserConstants.SyntaxTreeNode, new IdentifierASTNode()
{
SymbolTableEntry = entry
});
}),
new TerminalExpressionDefinition {
TokenType = TokenType.ParenthesisOpen
},
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.Factors
},
new TerminalExpressionDefinition {
TokenType = TokenType.ParenthesisClose
},
new SemanticActionDefinition((ParsingNode node) =>
{
FunctionCallASTNode syntaxTreeNode = new FunctionCallASTNode();
syntaxTreeNode.Target = node.GetAttributeForKey <SymbolTableEntry>(ParserConstants.Identifier, ParserConstants.SymbolTableEntry);
syntaxTreeNode.Arguments = node.GetAttributeForKey <List <FactorASTNode> >(ParserConstants.Factors, Factors);
FunctionASTNode functionASTNode = syntaxTreeNode.Target.GetMetadata <FunctionASTNode>("FunctionASTNode");
syntaxTreeNode.FunctionASTNode = functionASTNode;
node.Attributes[ParserConstants.SyntaxTreeNode] = syntaxTreeNode;
})
}
));
}
internal void LoadSymboltable(Stream symTabStream)
{
_SymbolTableEntrys = new List <SymbolTableEntry>();
StreamReader symTab = new StreamReader(symTabStream);
while (!symTab.EndOfStream)
{
string line = symTab.ReadLine();
if (line.Trim() != "" && !symTab.EndOfStream)
{
string[] wrt = line.Split('\t');
SymbolTableEntry sym = new SymbolTableEntry();
if (wrt.Length > 2)
{
sym.Symbol = wrt[2];
sym.Operand = wrt[1];
sym.OperandIEC = wrt[1];
//sym.DataType =
if (wrt.Length > 3)
{
sym.Comment = wrt[3];
}
_SymbolTableEntrys.Add(sym);
try
{
operandIndexList.Add(sym.Operand.Replace(" ", ""), sym);
if (sym.Symbol.Trim() != "")
{
symbolIndexList.Add(sym.Symbol.ToUpper().Trim(), sym);
}
}
catch (Exception ex)
{ }
}
}
}
}
public SymbolTableEntry GetEntryFromOperand(string operand)
{
if (operand == null)
{
return(null);
}
if (_step7SymbolTableEntrys == null)
{
LoadSymboltable();
}
string tmpname = operand.Replace(" ", "");
SymbolTableEntry retval = null;
operandIndexList.TryGetValue(tmpname, out retval);
if (retval != null)
{
return(retval);
}
if (tmpname.StartsWith("E"))
{
operandIndexList.TryGetValue("I" + tmpname.Substring(1), out retval);
}
else if (tmpname.StartsWith("I"))
{
operandIndexList.TryGetValue("E" + tmpname.Substring(1), out retval);
}
else if (tmpname.StartsWith("A"))
{
operandIndexList.TryGetValue("Q" + tmpname.Substring(1), out retval);
}
else if (tmpname.StartsWith("Q"))
{
operandIndexList.TryGetValue("A" + tmpname.Substring(1), out retval);
}
return(retval);
}
internal void LoadSymboltable()
{
_step7SymbolTableEntrys = new List<SymbolTableEntry>();
if (!string.IsNullOrEmpty(Folder))
{
try
{
var dbfTbl = DBF.ParseDBF.ReadDBF(Folder + "SYMLIST.DBF", ((Step7ProjectV5)Project)._ziphelper, ((Step7ProjectV5)Project)._DirSeperator, Project.ProjectEncoding);
foreach (DataRow row in dbfTbl.Rows)
{
if (!(bool)row["DELETED_FLAG"] || showDeleted)
{
SymbolTableEntry sym = new SymbolTableEntry();
sym.Symbol = (string)row["_SKZ"];
sym.Operand = (string)row["_OPHIST"];
sym.OperandIEC = (string)row["_OPIEC"];
sym.DataType = (string)row["_DATATYP"];
sym.Comment = (string)row["_COMMENT"];
if ((bool)row["DELETED_FLAG"]) sym.Comment = "(deleted) " + sym.Comment;
_step7SymbolTableEntrys.Add(sym);
string oper = sym.Operand.Replace(" ", "");
string addSym = sym.Symbol.ToUpper().Trim();
if (!string.IsNullOrEmpty(addSym))
{
if (!operandIndexList.ContainsKey(oper))
operandIndexList.Add(oper, sym);
if (!symbolIndexList.ContainsKey(addSym))
symbolIndexList.Add(addSym, sym);
}
}
}
}
catch (Exception ex)
{
}
}
}
internal void LoadSymboltable(Stream symTabStream)
{
_SymbolTableEntrys = new List<SymbolTableEntry>();
StreamReader symTab = new StreamReader(symTabStream);
while (!symTab.EndOfStream)
{
string line = symTab.ReadLine();
if (line.Trim() != "" && !symTab.EndOfStream)
{
string[] wrt = line.Split('\t');
SymbolTableEntry sym = new SymbolTableEntry();
if (wrt.Length > 2)
{
sym.Symbol = wrt[2];
sym.Operand = wrt[1];
sym.OperandIEC = wrt[1];
//sym.DataType =
if (wrt.Length > 3)
sym.Comment = wrt[3];
_SymbolTableEntrys.Add(sym);
try
{
operandIndexList.Add(sym.Operand.Replace(" ", ""), sym);
if (sym.Symbol.Trim() != "")
symbolIndexList.Add(sym.Symbol.ToUpper().Trim(), sym);
}
catch (Exception ex)
{ }
}
}
}
}
public override ICodeNode Parse(Token token)
{
// Create the ASSIGN node.
ICodeNode assignNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.ASSIGN);
string targetName = token.text.ToLower();
SymbolTableEntry targetID = symbolTableStack.Lookup(targetName);
if (targetID == null)
{
targetID = symbolTableStack.EnterLocal(targetName);
}
targetID.AppendLineNumber(token.lineNumber);
token = NextToken();
ICodeNode variableNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.VARIABLE);
variableNode.SetAttribute(ICodeKeyImplementation.ID, targetID);
assignNode.AddChild(variableNode);
if (token.type == PascalTokenType.COLON_EQUALS)
{
token = NextToken();
}
else
{
errorHandler.flag(token, PascalErrorCode.MISSING_COLON_EQUALS, this);
}
ExpressionParser expressionParser = new ExpressionParser(this);
assignNode.AddChild(expressionParser.Parse(token));
return(assignNode);
}
private ISuperBlock ParseV0orV1(SuperBlockObj aContainer, bool aIsV1)
{
using (Stream fStream = mrStreamProvider.GetReadonlyStream())
{
fStream.Seek(
(long)(ulong)aContainer.LocationAddress + FormatSignatureAndVersionInfo.Length,
SeekOrigin.Begin);
const byte
fcHeaderBytes = 15;
byte[]
fHeadbuffer = new byte[fcHeaderBytes];
if (fcHeaderBytes != fStream.Read(fHeadbuffer, 0, fcHeaderBytes))
{
throw new EndOfStreamException("Could not read Superblock");
}
aContainer.FreeSpaceStorageVersion = fHeadbuffer[0];
aContainer.RootGroupSymbolTableVersion = fHeadbuffer[1];
if (fHeadbuffer[2] != 0)
{
throw new InvalidDataException("Reserved byte expected to be zero");
}
aContainer.SharedHeaderMessageFormatVersion = fHeadbuffer[3];
aContainer.SizeOfOffsets = fHeadbuffer[4];
aContainer.SizeOfLengths = fHeadbuffer[5];
if (fHeadbuffer[6] != 0)
{
throw new InvalidDataException("Reserved byte expected to be zero");
}
aContainer.GroupLeafNodeK = (ushort)(fHeadbuffer[7] | (fHeadbuffer[8] << 8));
aContainer.GroupInternalNodeK = (ushort)(fHeadbuffer[9] | (fHeadbuffer[10] << 8));
if (aIsV1)
{
const int
fcV1FeildBytes = 4;
byte[]
fV1Buffer = new byte[fcV1FeildBytes];
if (fcV1FeildBytes != fStream.Read(fV1Buffer, 0, fcV1FeildBytes))
{
throw new EndOfStreamException("Could not read Superblock");
}
aContainer.IndexedStorageInternalNodeK = (ushort)(fV1Buffer[0] + (fV1Buffer[1] << 8));
if (!(fV1Buffer[2] == 0 || fV1Buffer[3] == 0))
{
throw new InvalidDataException("Reserved bytes expected to be zero");
}
}
aContainer.BaseAddress = aContainer.LocationAddress;
using (Hdf5Reader fReader = new Hdf5Reader(fStream, aContainer, false))
{
Offset
fBaseAddress = fReader.ReadOffset(),
fFreeSpaceAddress = fReader.ReadOffset(),
fEndOfFileAddress = fReader.ReadOffset(),
fDirverInformationBlockAddress = fReader.ReadOffset();
SymbolTableEntry
fRootGroupEntry = SymbolTableEntry.Read(fReader);
if (fBaseAddress.IsNull())
{
throw new InvalidDataException("No base adddress Specified");
}
aContainer.BaseAddress = fBaseAddress;
aContainer.FileFreespaceInfoAddress = fFreeSpaceAddress;
if (fEndOfFileAddress.IsNull())
{
throw new InvalidDataException("No End Of file Adddress Specified");
}
aContainer.EndOfFileAddress = fEndOfFileAddress;
aContainer.DriverInformationBlockAddress = fDirverInformationBlockAddress;
aContainer.RootGroupSymbolTableEntry = fRootGroupEntry;
aContainer.RootGroupAddress = fRootGroupEntry.ObjectHeaderAddress;
}
}
return(aContainer);
}
private ICodeNode ParseFactor(Token token)
{
TokenType tokenType = token.type;
ICodeNode rootNode = null;
switch (tokenType.ToString())
{
case "IDENTIFIER":
{
// Look up the identifier in the symbol table stack.
// Flag the identifier as undefined if it's not found.
String name = token.text.ToLower();
SymbolTableEntry id = symbolTableStack.Lookup(name);
if (id == null)
{
errorHandler.flag(token, PascalErrorCode.IDENTIFIER_UNDEFINED, this);
id = symbolTableStack.EnterLocal(name);
}
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.VARIABLE);
rootNode.SetAttribute(ICodeKeyImplementation.ID, id);
id.AppendLineNumber(token.lineNumber);
token = NextToken(); // consume the identifier
break;
}
case "INTEGER":
{
// Create an INTEGER_CONSTANT node as the root node.
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.INTEGER_CONSTANT);
rootNode.SetAttribute(ICodeKeyImplementation.VALUE, token.value);
token = NextToken(); // consume the number
break;
}
case "REAL":
{
// Create an REAL_CONSTANT node as the root node.
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.REAL_CONSTANT);
rootNode.SetAttribute(ICodeKeyImplementation.VALUE, token.value);
token = NextToken(); // consume the number
break;
}
case "STRING":
{
String value = (String)token.value;
// Create a STRING_CONSTANT node as the root node.
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.STRING_CONSTANT);
rootNode.SetAttribute(ICodeKeyImplementation.VALUE, value);
token = NextToken(); // consume the string
break;
}
case "NOT":
{
token = NextToken(); // consume the NOT
// Create a NOT node as the root node.
rootNode = ICodeFactory.CreateICodeNode(ICodeNodeTypeImplementation.NOT);
// Parse the factor. The NOT node adopts the
// factor node as its child.
rootNode.AddChild(ParseFactor(token));
break;
}
case "LEFT_PAREN":
{
token = NextToken(); // consume the (
// Parse an expression and make its node the root node.
rootNode = ParseExpression(token);
// Look for the matching ) token.
token = CurrentToken();
if (token.type == PascalTokenType.RIGHT_PAREN)
{
token = NextToken(); // consume the )
}
else
{
errorHandler.flag(token, PascalErrorCode.MISSING_RIGHT_PAREN, this);
}
break;
}
default:
{
errorHandler.flag(token, PascalErrorCode.UNEXPECTED_TOKEN, this);
break;
}
}
return(rootNode);
}
public override string ToString()
{
return($"{SymbolTableEntry.ToString()} =");
}
void DumpSymbolEntry(StringBuilder buffer, SymbolTableEntry entry)
{
buffer.AppendFormat("{0,-30}", entry.symbol);
buffer.AppendFormat("{0,-8}", (entry.bIsFixEntry ? "Fixed" : "User"));
buffer.AppendFormat("{0,-12}", (entry.bIsBreakingCharSeq ? "IsBreakSeq" : ""));
switch (entry.type)
{
case SymbolType.ReservedWordSymbolType:
buffer.AppendFormat("{0,-12}", "ResWord");
break;
case SymbolType.IdentifierSymbolType:
buffer.AppendFormat("{0,-12}", "Identifier");
break;
case SymbolType.NumberSymbolType:
buffer.AppendFormat("{0,-12}", "Number");
break;
case SymbolType.BooleanSymbolType:
buffer.AppendFormat("{0,-12}", "Boolean");
break;
}
buffer.Append("NodeLink: ");
if (entry.nodeLink != null)
{
buffer.AppendFormat("{0, -25}", entry.nodeLink.GetType().Name);
}
else
{
buffer.AppendFormat("{0, -25}", "null");
}
buffer.AppendFormat(" -- {0}", entry.sRepresentation);
buffer.AppendLine();
}
public PLCDataPoint(SymbolTableEntry entry) : this()
{
Address = entry.OperandIEC;
DataType = entry.DataType;
Symbol = entry.Symbol;
}
Symbol AddSymbol(SymbolTableEntry entry)
{
var currentSymbolTable = this._symbolTableStack.Peek();
currentSymbolTable.Add(entry);
return entry.symbol;
}
public Symbol AddUserSymbol(string token)
{
foreach (var e in this._symbolTableStack.Peek())
{
if (token == e.sRepresentation)
{
return e.symbol;
}
}
SymbolTableEntry entry = new SymbolTableEntry();
entry.symbol = (Symbol)this._nextSymbol++;
entry.bIsFixEntry = false;
entry.bIsBreakingCharSeq = false;
entry.nodeLink = null;
entry.sRepresentation = token;
int number;
if (int.TryParse(token, out number))
{
entry.type = SymbolType.NumberSymbolType;
entry.iYielding = number;
}
else
{
entry.type = SymbolType.IdentifierSymbolType;
}
return AddSymbol(entry);
}
private void LoadReferenceData()
{
ReferenceDataLoaded = false;
Step5ProgrammFolder prgFld = (Step5ProgrammFolder)this.Parent;
Step5BlocksFolder blkFld = (Step5BlocksFolder)prgFld.BlocksFolder;
SymbolTable smyTab = (SymbolTable)prgFld.SymbolTable;
//try
{
foreach (ProjectBlockInfo projectBlockInfo in blkFld.readPlcBlocksList())
{
if (projectBlockInfo.BlockType == PLCBlockType.S5_PB || projectBlockInfo.BlockType == PLCBlockType.S5_FB || projectBlockInfo.BlockType == PLCBlockType.S5_FX || projectBlockInfo.BlockType == PLCBlockType.S5_OB || projectBlockInfo.BlockType == PLCBlockType.S5_SB)
{
S5FunctionBlock blk = (S5FunctionBlock)projectBlockInfo.GetBlock();
int networkNR = 0;
foreach (Blocks.Network network in blk.Networks)
{
int rowNR = 0;
networkNR++;
string akdb = "";
foreach (S5FunctionBlockRow functionBlockRow in network.AWLCode)
{
if (!string.IsNullOrEmpty(functionBlockRow.Label))
{
akdb = "";
}
if (functionBlockRow.Command == "A" || functionBlockRow.Command == "AX")
{
if (functionBlockRow.Parameter == "DB 0" || functionBlockRow.Parameter == "DX 0")
{
akdb = "";
}
else
{
akdb = functionBlockRow.Parameter;
}
}
rowNR++;
if (functionBlockRow.MC5LIB_SYMTAB_Row != null && ((ReferenceDataAccessMode)functionBlockRow.MC5LIB_SYMTAB_Row[9]) != ReferenceDataAccessMode.None)
{
//Normal reference...
string operand = functionBlockRow.Parameter;
if (operand == "DB 0")
{
operand = "DB ??";
}
ReferenceDataEntry entr;
operandIndexList.TryGetValue(operand, out entr);
if (entr == null)
{
SymbolTableEntry symb = null;
if (smyTab != null)
{
symb = smyTab.GetEntryFromOperand(operand);
}
entr = new ReferenceDataEntry()
{
Operand = operand, SymbolTableEntry = symb
};
operandIndexList.Add(operand, entr);
_ReferenceDataEntrys.Add(entr);
}
entr.ReferencePoints.Add(new ReferencePoint()
{
Block = blk, Network = network, NetworkNumber = networkNR, LineNumber = rowNR, BlockRow = functionBlockRow, AccessMode = (ReferenceDataAccessMode)functionBlockRow.MC5LIB_SYMTAB_Row[9]
});
//Reference to DB
if (akdb != "")
{
if (functionBlockRow.Parameter.StartsWith("D ") || functionBlockRow.Parameter.StartsWith("DW") || functionBlockRow.Parameter.StartsWith("DL") || functionBlockRow.Parameter.StartsWith("DR") || functionBlockRow.Parameter.StartsWith("DX"))
{
//Normal reference...
operand = akdb + "." + functionBlockRow.Parameter;
entr = null;
operandIndexList.TryGetValue(operand, out entr);
if (entr == null)
{
SymbolTableEntry symb = null;
if (smyTab != null)
{
symb = smyTab.GetEntryFromOperand(operand);
}
entr = new ReferenceDataEntry()
{
Operand = operand, SymbolTableEntry = symb
};
operandIndexList.Add(operand, entr);
_ReferenceDataEntrys.Add(entr);
}
entr.ReferencePoints.Add(new ReferencePoint()
{
Block = blk, Network = network, NetworkNumber = networkNR, LineNumber = rowNR, BlockRow = functionBlockRow, AccessMode = (ReferenceDataAccessMode)functionBlockRow.MC5LIB_SYMTAB_Row[9]
});
}
}
}
}
}
}
}
}
/*catch (Exception ex)
* {
* MessageBox.Show("There was an error generating the Reference Data! Maybe the Step5 project is broken? \n" + ex.Message);
* }*/
ReferenceDataLoaded = true;
}
public static void Initialize(ref Grammar grammar)
{
grammar.Add(new Production(ParserConstants.ClassMembers,
new List <SubProduction>
{
new SubProduction(new List <ExpressionDefinition>()
{
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.ClassMembers
},
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.ClassMember
},
new SemanticActionDefinition((ParsingNode node) =>
{
List <SyntaxTreeNode> nodes = new List <SyntaxTreeNode>();
nodes.AddRange(node.GetAttributeForKey <List <SyntaxTreeNode> >(ParserConstants.ClassMembers, ParserConstants.SyntaxTreeNodes));
nodes.Add(node.GetAttributeForKey <SyntaxTreeNode>(ParserConstants.ClassMember, ParserConstants.SyntaxTreeNode));
node.Attributes.Add(ParserConstants.SyntaxTreeNodes, nodes);
})
}),
new SubProduction
(
new List <ExpressionDefinition>
{
new TerminalExpressionDefinition {
TokenType = TokenType.EmptyString
},
new SemanticActionDefinition((ParsingNode node) =>
{
node.Attributes.Add(ParserConstants.SyntaxTreeNodes, new List <SyntaxTreeNode> {
});
})
}
)
}
));
grammar.Add(new Production(ParserConstants.ClassMember,
new SubProduction
(
new List <ExpressionDefinition>
{
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.Function
},
new SemanticActionDefinition((ParsingNode node) =>
{
node.Attributes.Add(ParserConstants.SyntaxTreeNode, node.GetAttributeForKey <SyntaxTreeNode>(ParserConstants.Function, ParserConstants.SyntaxTreeNode));
})
}
)
));
grammar.Add(new Production(ParserConstants.Function,
new SubProduction
(
new List <ExpressionDefinition>
{
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.Type
},
new TerminalExpressionDefinition {
TokenType = TokenType.Identifier
},
new SemanticActionDefinition((ParsingNode node) =>
{
SymbolTable symbolTable = node.CurrentSymbolTable;
string key = node.GetAttributeForKey <WordToken>(ParserConstants.Identifier, ParserConstants.Token).Lexeme;
SymbolTableEntry entry = symbolTable.Create(key, SymbolTableEntryType.Function);
symbolTable = symbolTable.CreateChild();
node.Attributes[ParserConstants.SymTable] = symbolTable;
node.Attributes.Add(ParserConstants.SymbolTableEntry, entry);
node.GetNodeForKey(ParserConstants.Identifier).Attributes.Add(ParserConstants.SymbolTableEntry, entry);
node.GetNodeForKey(ParserConstants.Identifier).Attributes.Add(ParserConstants.SyntaxTreeNode, new IdentifierASTNode()
{
SymbolTableEntry = entry
});
}),
new TerminalExpressionDefinition {
TokenType = TokenType.ParenthesisOpen
},
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.FunctionDeclarationArguments
},
new TerminalExpressionDefinition {
TokenType = TokenType.ParenthesisClose
},
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.Codeblock
},
new SemanticActionDefinition((ParsingNode node) =>
{
FunctionASTNode syntaxTreeNode = new FunctionASTNode();
syntaxTreeNode.Arguments = node.GetAttributeForKey <List <SymbolTableEntry> >(ParserConstants.FunctionDeclarationArguments, Entries);
syntaxTreeNode.ReturnType = node.GetAttributeForKey <TypeASTNode>(ParserConstants.Type, ParserConstants.SyntaxTreeNode);
syntaxTreeNode.Body = node.GetAttributeForKey <SyntaxTreeNode>(ParserConstants.Codeblock, ParserConstants.SyntaxTreeNode);
syntaxTreeNode.FunctionName = node.GetAttributeForKey <SymbolTableEntry>(ParserConstants.Identifier, ParserConstants.SymbolTableEntry);
SymbolTableEntry entry = node.GetAttribute <SymbolTableEntry>(ParserConstants.SymbolTableEntry);
entry.Metadata.Add("FunctionASTNode", syntaxTreeNode);
node.Attributes[ParserConstants.SyntaxTreeNode] = syntaxTreeNode;
})
}
)
));
grammar.Add(new Production(ParserConstants.FunctionDeclarationArguments,
new List <SubProduction>()
{
new SubProduction
(
new List <ExpressionDefinition>
{
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.FunctionDeclarationArguments
},
new TerminalExpressionDefinition {
TokenType = TokenType.Comma
},
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.FunctionDeclarationArgument
},
new SemanticActionDefinition((ParsingNode node) =>
{
List <SymbolTableEntry> result = new List <SymbolTableEntry>();
List <SymbolTableEntry> entries = node.GetAttributeForKey <List <SymbolTableEntry> >(ParserConstants.FunctionDeclarationArguments, Entries);
SymbolTableEntry entry = node.GetAttributeForKey <SymbolTableEntry>(ParserConstants.FunctionDeclarationArgument, Entry);
result.AddRange(entries);
result.Add(entry);
node.Attributes.Add(Entries, result);
})
}
),
new SubProduction
(
new List <ExpressionDefinition>
{
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.FunctionDeclarationArgument
},
new SemanticActionDefinition((ParsingNode node) =>
{
List <SymbolTableEntry> entries = new List <SymbolTableEntry>();
SymbolTableEntry entry = node.GetAttributeForKey <SymbolTableEntry>(ParserConstants.FunctionDeclarationArgument, Entry);
entries.Add(entry);
node.Attributes.Add(Entries, entries);
})
}
),
new SubProduction
(
new List <ExpressionDefinition>
{
new TerminalExpressionDefinition {
TokenType = TokenType.EmptyString
},
new SemanticActionDefinition((ParsingNode node) =>
{
node.Attributes.Add(Entries, new List <SymbolTableEntry>());
})
}
)
}
));
grammar.Add(new Production(ParserConstants.FunctionDeclarationArgument,
new List <SubProduction>()
{
new SubProduction
(
new List <ExpressionDefinition>
{
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.Type
},
new TerminalExpressionDefinition {
TokenType = TokenType.Identifier
},
new SemanticActionDefinition((ParsingNode node) =>
{
SymbolTable symbolTable = node.CurrentSymbolTable;
TypeASTNode type = node.GetAttributeForKey <TypeASTNode>(ParserConstants.Type, ParserConstants.SyntaxTreeNode);
string key = node.GetAttributeForKey <WordToken>("Identifier", ParserConstants.Token).Lexeme;
SymbolTableEntry entry = null;
if (type is DynamicTypeASTNode dynASTNode)
{
entry = symbolTable.Create(key, SymbolTableEntryType.Class);
entry.SpecificType = dynASTNode.SymbolTableEntry;
}
else if (type is StaticTypeASTNode staticTypeASTNode)
{
entry = symbolTable.Create(key, staticTypeASTNode.SymbolTableEntryType);
}
node.Attributes.Add(Entry, entry);
})
}
)
}
public static void Initialize(ref Grammar grammar)
{
grammar.Add(new Production(ParserConstants.Classes,
new List <SubProduction>
{
new SubProduction(new List <ExpressionDefinition>()
{
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.Class
},
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.Classes
},
new SemanticActionDefinition((ParsingNode node) =>
{
ClassesASTNode astNode = new ClassesASTNode();
astNode.Classes.Add(node.GetAttributeForKey <ClassASTNode>(ParserConstants.Class, ParserConstants.SyntaxTreeNode));
astNode.Classes.AddRange(node.GetAttributeForKey <ClassesASTNode>(ParserConstants.Classes, ParserConstants.SyntaxTreeNode).Classes);
node.Attributes.Add(ParserConstants.SyntaxTreeNode, astNode);
})
}),
//new SubProduction(new List<ExpressionDefinition>()
//{
// new NonTerminalExpressionDefinition { Identifier = ParserConstants.Class },
// new SemanticActionDefinition((ParsingNode node) =>
// {
// ClassesASTNode astNode = new ClassesASTNode();
// astNode.Classes.Add(node.GetAttributeForKey<ClassASTNode>(ParserConstants.Class, ParserConstants.SyntaxTreeNode));
// node.Attributes.Add(ParserConstants.SyntaxTreeNode, astNode);
// })
//}),
new SubProduction
(
new List <ExpressionDefinition>
{
new TerminalExpressionDefinition {
TokenType = TokenType.EmptyString
},
new SemanticActionDefinition((ParsingNode node) =>
{
node.Attributes.Add(ParserConstants.SyntaxTreeNode, new ClassesASTNode());
})
}
)
}
));
grammar.Add(new Production("Class",
new SubProduction(new List <ExpressionDefinition>()
{
new TerminalExpressionDefinition {
TokenType = TokenType.Class
},
new TerminalExpressionDefinition {
TokenType = TokenType.Identifier
},
new SemanticActionDefinition((ParsingNode node) =>
{
node.Attributes[ParserConstants.SymTable] = node.ChildSymbolTable;
string key = node.GetAttributeForKey <WordToken>(ParserConstants.Identifier, ParserConstants.Token).Lexeme;
SymbolTableEntry entry = node.ChildSymbolTable.Create(key, SymbolTableEntryType.Class);
node.GetNodeForKey("Identifier").Attributes.Add(ParserConstants.SymbolTableEntry, entry);
node.GetNodeForKey("Identifier").Attributes.Add(ParserConstants.SyntaxTreeNode, new IdentifierASTNode()
{
SymbolTableEntry = entry
});
}),
new TerminalExpressionDefinition {
TokenType = TokenType.BracketOpen
},
new NonTerminalExpressionDefinition {
Identifier = ParserConstants.ClassMembers
},
new TerminalExpressionDefinition {
TokenType = TokenType.BracketClose
},
new SemanticActionDefinition((ParsingNode node) =>
{
ClassASTNode classASTNode = new ClassASTNode();
classASTNode.ClassName = node.GetAttributeForKey <SymbolTableEntry>(ParserConstants.Identifier, ParserConstants.SymbolTableEntry);
classASTNode.Children = node.GetAttributeForKey <List <SyntaxTreeNode> >(ParserConstants.ClassMembers, ParserConstants.SyntaxTreeNodes);
node.Attributes.Add(ParserConstants.SyntaxTreeNode, classASTNode);
})
})
));
}
