/// <summary>
/// Analyzes ariphmetic expression.
/// </summary>
/// <param name="startPos">Start position of an expression.</param>
/// <param name="finishPos">End position of an expression.</param>
/// <param name="parentNode">Tree parent node of an expression.</param>
private void processor_ariphmetic(int startPos, int finishPos, DTreeNode <string> parentNode)
{
// Check for minus
int type = 0, value = 0;
token.token(startPos, ref type, ref value);
if (value == 1)
{
DTreeNode <string> node = parentNode.Nodes.Add(LexemTypeHelper.getTypedValue(1, valueOf(startPos)));
if (finishPos > startPos)
{
processor_ariphmetic(startPos + 1, finishPos, node);
}
return;
}
// Search for (...)+(...) not only +, but + - *
int pos = findAriphmeticOutsideBraces(startPos, finishPos);
if (pos != -1)
{
DTreeNode <string> node = parentNode.Nodes.Add(LexemTypeHelper.getTypedValue(1, valueOf(pos)));
processor_ariphmetic(startPos, pos - 1, node);
processor_ariphmetic(pos + 1, finishPos, node);
return;
}
// Search for (...)
int openPos, closePos = 0;
openPos = findMatchingBraces(startPos, 2, ref closePos);
if (openPos == startPos && closePos == finishPos)
{
processor_ariphmetic(startPos + 1, finishPos - 1, parentNode);
return;
}
if (startPos + 2 == finishPos)
{
token.token(startPos + 1, ref type, ref value);
DTreeNode <string> t = parentNode.Nodes.Add(lAnalyzer.tokenStringBuilder(type, value));
token.token(startPos, ref type, ref value);
t.Nodes.Add(lAnalyzer.tokenStringBuilder(type, value));
token.token(startPos + 2, ref type, ref value);
t.Nodes.Add(lAnalyzer.tokenStringBuilder(type, value));
return;
}
// Search for identifiers
token.token(startPos, ref type, ref value);
if (startPos == finishPos && type > 2)
{
parentNode.Nodes.Add(lAnalyzer.tokenStringBuilder(type, value));
return;
}
else
{
error(startPos);
}
}
/// <summary>
/// Gets double value from node.
/// </summary>
/// <param name="node">SyntaxTree node.</param>
protected void getDoubleValue(DTreeNode <string> node)
{
double value;
Double.TryParse(LexemTypeHelper.getParsedValue(node.Value), out value);
ilg.Emit(OpCodes.Ldc_R4, value);
}
public override void resetProperty()
{
base.resetProperty();
mNodeList.Clear();
mRootNode = null;
mTimer.stop();
}
public override void execute()
{
LIST(out List <DTreeNode> availableChildList);
LIST(out List <float> oddsList);
// 按子节点顺序查看子节点是否满足条件
int count = mChildList.Count;
for (int i = 0; i < count; ++i)
{
DTreeNode node = mChildList[i];
// 找出可以执行的节点
if (node.isActive() && node.condition())
{
availableChildList.Add(node);
oddsList.Add(node.getRandomWeight());
}
}
// 按照权重随机选择其中一个节点
int index = randomHit(oddsList);
if (inRange(index, 0, availableChildList.Count - 1, true))
{
availableChildList[index].execute();
}
UN_LIST(availableChildList);
UN_LIST(oddsList);
}
/// <summary>
/// Process the code segment belongs to class.
/// </summary>
/// <param name="start">Number of the first token, that belongs to class.</param>
/// <param name="pos"></param>
private void processor_Class(int pos)
{
int curlyStart = 0, curlyFinish = 0;
int finded = 0;
int type = 0, value = 0;
int currentPos = pos;
// finding open curly brace of a class
finded = findFirstOccurence(1, 11, currentPos);
if (finded == -1)
{
error(currentPos);
}
else
{
curlyStart = finded;
currentPos++;
}
// finding closing curly brace
findMatchingBraces(curlyStart, 1, ref curlyFinish);
// adding class occurence in the tree
DTreeNode <string> node = tree.getRootNode();
token.token(pos + 1, ref type, ref value);
node = node.Nodes.Add(LexemTypeHelper.getTypedValue(3, ident.identifier(value)));
// go to class content handler
processor_findMethodsInClass(curlyStart, curlyFinish, node);
}
/// <summary>
/// Generates fields for a type. TODO (Now does nothing).
/// </summary>
/// <param name="node">SyntaxTree node that declares fields.</param>
/// <param name="tBuilder">TypeBuilder of the type.</param>
protected void generateFields(DTreeNode <string> node, TypeBuilder tBuilder)
{
foreach (DTreeNode <string> childNode in node.Nodes)
{
//new GeneratorMethods(ab, childNode, tBuilder).generate();
}
}
//------------------------------------------------------------------------------------------
protected override void notifyAttachParent(DTreeNode parent)
{
if (parent is DTreeDecision)
{
logError("决策节点不能挂接到决策节点类型下");
}
}
public CecilAssemblyData()
{
_rootNode = _assemblyTree.Nodes.Add(new DTreeItem("...", SelectionType.NONE));
// add a default entry into the graph HT
graphData.Add("", null);
AssemblyStats = new AssemblyStats();
}
/*private int printItselfToTheFile(DTreeNode<string> node, int depth = 0)
* {
* DTreeNode<string> curr = root;
* int currOffset, offset = 0, counter = 0;
*
* if (depth > 0 && array[depth - 1] > array[depth]) array[depth] = array[depth - 1];
* foreach (DTreeNode<string> dNode in node.Nodes)
* {
* offset = findMaxOffset(depth);
* counter++;
* currOffset = printItselfToTheFile(dNode, depth + 1);
* if (counter == 1) offset = currOffset;
* }
*
* if (depth == 0)
* {
* return 0;
* }
*
* //Console.SetCursorPosition(array[depth], depth);
* strings[depth]. Insert(array[depth], node.Value);
* array[depth] += node.Value.Length + 1;
* if (offset > array[depth]) array[depth] = offset;
* //Console.Write(node.Value);
* if (counter == 0) return array[depth] - node.Value.Length - 1;
* else return offset;
* }*/
private void printItselfToTheFile(DTreeNode <string> node, int depth, int offset)
{
DTreeNode <string> curr = root;
int currOffset, counter = 0;
if (depth > 0 && array[depth - 1] > array[depth])
{
array[depth] = array[depth - 1];
}
foreach (DTreeNode <string> dNode in node.Nodes)
{
//offset = findMaxOffset(depth);
printItselfToTheFile(dNode, depth + 1, findMaxOffset(depth));
}
if (array[depth] < offset)
{
array[depth] = offset;
}
strings[depth].Insert(array[depth], node.Value);
if (depth == 0)
{
return;
}
array[depth] += node.Value.Length + 1;
}
/// <summary>
/// Analyzes a single syntaxTree node to decide what to do next.
/// </summary>
/// <param name="parentNode">Current syntaxTree node to precess.</param>
protected void analyzeNode(DTreeNode <string> parentNode)
{
int type = 0;
string s = LexemTypeHelper.parse(ref type, parentNode.Value);
string identType;
switch (type)
{
case 1:
if (s == "=" || s == "+")
{
checkAssignment(parentNode);
}
break;
case 3:
if (identifiers.TryGetValue(s, out identType))
{
checkDeclaring(parentNode);
}
else
{
identifiers.Add(s, LexemTypeHelper.getParsedValue(parentNode.Nodes[0].Value));
}
break;
}
foreach (DTreeNode <string> node in parentNode.Nodes)
{
analyzeNode(node);
}
}
/// <summary>
/// Gets value after a single mathematic operation or identifier.
/// </summary>
/// <param name="node">SyntaxTree node of operation or identifier.</param>
protected void getValue(DTreeNode <string> node)
{
switch (LexemTypeHelper.getParsedType(node.Value))
{
case 1:
switch (LexemTypeHelper.getParsedValue(node.Value))
{
case "+": handlePlus(node); break;
case "-": handleMinus(node); break;
case "*": handleMultiply(node); break;
}
break;
case 3:
getIdentifierValue(node);
break;
case 4:
getDoubleValue(node);
break;
case 5:
getIntValue(node);
break;
}
}
/// <summary>
/// Gets int value from node.
/// </summary>
/// <param name="node">SyntaxTree node.</param>
protected void getIntValue(DTreeNode <string> node)
{
int value;
Int32.TryParse(LexemTypeHelper.getParsedValue(node.Value), out value);
ilg.Emit(OpCodes.Ldc_I4, value);
}
private void RefreshTreeNode()
{
if (!tree.SelectedNode.Equals(tree.TopNode))
{
tree.BeginUpdate();
int nodeIndex = tree.SelectedNode.Index;
removedNodeID = tree.SelectedNode.ID;
tree.TopNode.Nodes.Remove(tree.SelectedNode);
DataTable dt = GetCompanies(true);
if (dt != null)
{
var node = new DTreeNode(
(int)dt.Rows[0]["КодЛица"],
(dt.Rows[0]["Лицо"].ToString() != "") ? dt.Rows[0]["Лицо"].ToString() : dt.Rows[0]["Кличка"].ToString());
tree.TopNode.Nodes.Insert(nodeIndex, node);
tree.SelectedNode = node;
}
tree.SelectedNode.ExpandAll();
tree.EndUpdate();
FillList(false);
}
else
{
FillTree();
}
}
/// <summary>
/// Handles if expression.
/// </summary>
/// <param name="node">SyntaxTree node of the if statement.</param>
protected void handleIf(DTreeNode <string> node)
{
// Prepare needed lables.
Label tempAfterLabel = lastAfterLabel;
Label afterLabel = ilg.DefineLabel();
lastAfterLabel = afterLabel;
Label ifLabel = ilg.DefineLabel();
Label elseLabel = ilg.DefineLabel();
bool isElse = node.Nodes.Count == 4 ? true : false;
// Make statement comparison, write jumps.
handleComparison(node.Nodes[0], ifLabel, elseLabel, isElse);
// Set the label of the main if body.
if (node.Nodes.Count > 2)
{
ilg.MarkLabel(ifLabel);
next(node.Nodes[1]);
}
// Set the label of the else if body.
if (node.Nodes.Count > 3)
{
ilg.MarkLabel(elseLabel);
next(node.Nodes[2]);
}
// Set the exit point of the if statement.
else
{
ilg.MarkLabel(afterLabel);
next(node.Nodes[2]);
}
lastAfterLabel = tempAfterLabel;
}
private void SaveID()
{
if (OptionFolder == null)
{
return;
}
DTreeNode node = tree.SelectedNode;
if (node == null)
{
return;
}
int id = node.ID;
if (oldPlaces)
{
unitID = id;
OptionFolder.OptionForced <int>("UnitID").Value = id;
}
else
{
companyID = id;
OptionFolder.OptionForced <int>("CompanyID").Value = id;
}
}
/// <summary>
/// Duplicate identifier error occured.
/// </summary>
/// <param name="node">SyntaxTree node with duplicated identifier.</param>
protected void identifierError(DTreeNode <string> node)
{
Console.WriteLine("Error - duplicate identifier: " +
LexemTypeHelper.getParsedValue(node.Value) + ".");
Console.ReadLine();
Environment.Exit(-2);
}
/// <summary>
/// Gets type of parts of math expression or assignment from a
/// single child node.
/// </summary>
/// <param name="parentNode">Curent syntaxTree node to process.</param>
/// <returns>Type of child node.</returns>
protected Type getChildType(DTreeNode <string> parentNode)
{
int type = 0;
string s = LexemTypeHelper.parse(ref type, parentNode.Value);
switch (type)
{
case 1:
if (s == "=" || s == "+" || s == "*" || (s == "-" && parentNode.Nodes.Count != 1))
{
return(checkAssignment(parentNode));
}
else
{
return(getChildType(parentNode.Nodes[0]));
}
case 3:
return(getIdentifierType(parentNode, s));
case 4:
return(typeof(double));
case 5:
return(typeof(int));
default:
undefError();
return(typeof(int));
}
}
/// <summary>
/// Calls method generation for every method's declaration.
/// </summary>
/// <param name="node">Node that declares methods.</param>
/// <param name="tBuilder">TypeBuilder of the type.</param>
protected void generateMethods(DTreeNode<string> node, TypeBuilder tBuilder)
{
foreach (DTreeNode<string> childNode in node.Nodes)
{
new GeneratorMethods(ab, childNode, tBuilder).generate();
}
}
public static void Traverse <T>(DTreeNode <T> node, Action <DTreeNode <T> > visitor)
{
foreach (DTreeNode <T> kid in node.Nodes)
{
Traverse(kid, visitor);
}
visitor(node);
}
/// <summary>
/// Analyzes expression.
/// </summary>
/// <param name="startPos">Position, where expression starts.</param>
/// <param name="assigmentPos">Position, where assigment sign is.</param>
/// <param name="finishPos">Position, were expression ends.</param>
private DTreeNode <string> processor_expression(int startPos, int assigmentPos, int finishPos, DTreeNode <string> parentNode)
{
DTreeNode <string> node = parentNode.Nodes.Add(LexemTypeHelper.getTypedValue(1, valueOf(assigmentPos)));
processor_variable(startPos, assigmentPos - 1, node);
processor_ariphmetic(assigmentPos + 1, finishPos - 1, node);
return(node);
}
/// <summary>
/// Gets array of arguments of method.
/// </summary>
/// <param name="node">SyntaxTree node of first method's argument.</param>
/// <returns>Array of arguments.</returns>
protected Type[] getArguments(DTreeNode <string> node)
{
Type[] array = new Type[node.Nodes.Count];
for (int i = 0; i < node.Nodes.Count; i++)
{
array[i] = getArgType(node.Nodes[i]);
}
return(array);
}
public DTreeNode addNode(Type nodeType, DTreeNode parent)
{
DTreeNode node = createInstance <DTreeNode>(nodeType);
node.setCharacter(mComponentOwner as Character);
node.setID(generateGUID());
addNode(parent, node);
return(node);
}
/// <summary>
/// Type mismatch error has occured.
/// </summary>
/// <param name="node">SyntaxTree node, near that error has occured.</param>
protected void typeError(DTreeNode <string> node)
{
Console.WriteLine("Error - type mismatch, near:");
int numberNodesToPrint = 3;
tree.printSomeNodes(node, ref numberNodesToPrint);
Console.ReadLine();
Environment.Exit(-3);
}
public MainForm(MainFormController controller)
{
InitializeComponent();
this.elementHost.Child = new DiagramViewer();
mainController = controller;
mainController.Initialize(this);
AssemblyTree = new DTreeNode<DTreeItem>();
}
/// <summary>
/// Gets identifier value.
/// </summary>
/// <param name="node">SyntaxTree node of identifier.</param>
protected void getIdentifierValue(DTreeNode <string> node)
{
string name = LexemTypeHelper.getParsedValue(node.Value);
LocalBuilder lBuilder;
if (locals.TryGetValue(name, out lBuilder))
{
ilg.Emit(OpCodes.Ldloc, lBuilder);
}
}
public bool setParent(DTreeNode parent)
{
if (mParent != null && parent != null)
{
logError("当前父节点不为空,不能挂接到其他父节点");
return(false);
}
mParent = parent;
return(true);
}
/// <summary>
/// Checks if in math expression or assignment types match each other.
/// </summary>
/// <param name="parentNode">Current syntaxTree node to analyze.</param>
/// <returns>Type of used expression in all childNodes.</returns>
protected Type checkAssignment(DTreeNode<string> parentNode)
{
Type type1 = getChildType(parentNode.Nodes[0]);
Type type2 = getChildType(parentNode.Nodes[1]);
if (type1 != type2)
{
typeError(parentNode);
}
return type1;
}
public bool addChild(DTreeNode child)
{
if (mChildMap.ContainsKey(child.getID()))
{
logError("不能再次添加同一个子节点");
return(false);
}
mChildList.Add(child);
mChildMap.Add(child.getID(), child);
return(true);
}
public void PrintDTree(DTreeNode curr)
{
Debug.Log("QUESTION:" + curr.GetQuestion());
if (curr.IsLeaf())
{
Debug.Log("DONE");
return;
}
PrintDTree(curr.GetGoodOptionNode());
PrintDTree(curr.GetBadOptionNode());
}
/// <summary>
/// Analyzes basic statement (1 compare sign).
/// </summary>
/// <param name="startPos">Start position of a statement.</param>
/// <param name="finishPos">End position of a statement.</param>
/// <param name="parentNode">Tree parent node of a statement.</param>
/// <returns></returns>
private DTreeNode <string> processor_statement(int startPos, int finishPos, DTreeNode <string> parentNode)
{
DTreeNode <string> node = parentNode.Nodes.Add(LexemTypeHelper.getTypedValue(1, valueOf(startPos + 1)));
int type = 0, value = 0;
token.token(startPos, ref type, ref value);
node.Nodes.Add(lAnalyzer.tokenStringBuilder(type, value));
token.token(finishPos, ref type, ref value);
node.Nodes.Add(lAnalyzer.tokenStringBuilder(type, value));
return(node);
}
public bool removeChild(DTreeNode child)
{
if (!mChildMap.ContainsKey(child.getID()))
{
logError("找不到子节点,无法移除");
return(false);
}
mChildList.Remove(child);
mChildMap.Remove(child.getID());
return(true);
}
/// <summary>
/// Checks if in math expression or assignment types match each other.
/// </summary>
/// <param name="parentNode">Current syntaxTree node to analyze.</param>
/// <returns>Type of used expression in all childNodes.</returns>
protected Type checkAssignment(DTreeNode <string> parentNode)
{
Type type1 = getChildType(parentNode.Nodes[0]);
Type type2 = getChildType(parentNode.Nodes[1]);
if (type1 != type2)
{
typeError(parentNode);
}
return(type1);
}
public void SetFlowchart(DTreeNode currq, List <Fungus.Command> qCommands)
{
Fungus.Say question = (Fungus.Say)qCommands[0];
question.SetStandardText(currq.GetQuestion());
Fungus.Menu goodopt = (Fungus.Menu)qCommands [2];
goodopt.SetStandardText(currq.GetGoodOption());
Fungus.Menu badopt = (Fungus.Menu)qCommands [3];
badopt.SetStandardText(currq.GetBadOption());
}
/// <summary>
/// Finds all methods within a class.
/// </summary>
/// <param name="start">Open curly brace of a class.</param>
/// <param name="finish">Close curly brace of a class.</param>
/// <param name="parentNode">Tree node of the wrapping class.</param>
private void processor_findMethodsInClass(int start, int finish, DTreeNode <string> parentNode)
{
int curlyFinish = 0, curPos = start;
DTreeNode <string> curNode = tree.addNode(parentNode, LexemTypeHelper.getTypedValue(6, "methods"));
while ((curPos = findFirstIdentOccurence(curPos)) != -1)
{
findMatchingBraces(curPos + 1, 1, ref curlyFinish);
processor_method(start + 1, curPos, curlyFinish, curNode);
curPos = curlyFinish;
}
}
/// <summary>
/// Analyzes a single syntaxTree node to decide what to do next.
/// </summary>
/// <param name="parentNode">Current syntaxTree node to precess.</param>
protected void analyzeNode(DTreeNode<string> parentNode)
{
int type = 0;
string s = LexemTypeHelper.parse(ref type, parentNode.Value);
string identType;
switch(type) {
case 1:
if (s == "=" || s == "+")
checkAssignment(parentNode);
break;
case 3:
if (identifiers.TryGetValue(s, out identType))
checkDeclaring(parentNode);
else
identifiers.Add(s, LexemTypeHelper.getParsedValue(parentNode.Nodes[0].Value));
break;
}
foreach (DTreeNode<string> node in parentNode.Nodes)
{
analyzeNode(node);
}
}
/// <summary>
/// Handles the operator as the next command.
/// </summary>
/// <param name="node">SyntaxTree node of the operator.</param>
protected void handeOperator(DTreeNode<string> node)
{
switch (LexemTypeHelper.getParsedValue(node.Value))
{
case "=": handleAssignment(node); break;
/*case "+": handlePlus(node); break;
case "-": handleMinus(node); break;
case "*": handleMultiply(node); break;
case "<": handleLess(node); break;
case ">": handleBigger(node);break;
case "==": handleEqual(node); break;
case "!=": handleNotEqual(node); break;*/
default: break;
}
}
/// <summary>
/// Gets value after a single mathematic operation or identifier.
/// </summary>
/// <param name="node">SyntaxTree node of operation or identifier.</param>
protected void getValue(DTreeNode<string> node)
{
switch (LexemTypeHelper.getParsedType(node.Value))
{
case 1:
switch (LexemTypeHelper.getParsedValue(node.Value))
{
case "+": handlePlus(node); break;
case "-": handleMinus(node); break;
case "*": handleMultiply(node); break;
}
break;
case 3:
getIdentifierValue(node);
break;
case 4:
getDoubleValue(node);
break;
case 5:
getIntValue(node);
break;
}
}
internal void AddNewNamespace(string namespaceText)
{
currentNamespaceNode = currentAssemblyNode.Nodes.Add(new DTreeItem(namespaceText, SelectionType.NAMESPACE));
}
/// <summary>
/// Handles the multiply operation.
/// </summary>
/// <param name="node">SyntaxTree node of multiply operation.</param>
protected void handleMultiply(DTreeNode<string> node)
{
getValue(node.Nodes[0]);
getValue(node.Nodes[1]);
ilg.Emit(OpCodes.Mul);
}
public void setEntryPoint(DTreeNode<string> entryPointNode)
{
code = entryPointNode;
}
public int compile(String equation)
{
_inputEquation = equation;
Console.WriteLine("Analizing... \n\r \tEquation=[" + _inputEquation + "]");
_curStackValue = new nodeValue();
// Creating root
DTreeNode<String> root = new DTreeNode<String>();
//DTreeBuilder<nodeValue> trB = new DTreeBuilder<nodeValue>();
// Initing root
root.Value = "Root";//_operatorStack.Peek();
// Position to add next Node
DTreeNode<String> curNode = null;
// Position where were added last Node
DTreeNode<String> lastNode = null;
// Temporary data storage
DTreeNode<String> tempNode = null;
// Temporary data storage
DTreeNode<String>[] tempNodeArray = null;
// DEBUG Operators position and index
if (verifyAlpha())
{
}
while (_operatorStack.Count > 0)
{
_curStackValue.ind = _operatorStack.Peek().ind;
_curStackValue.pos = _operatorStack.Peek().pos;
_curStackValue.priority = _operatorStack.Pop().priority;
Console.WriteLine("Ind= " + _curStackValue.ind + " Pos= " + _curStackValue.pos + " Prior= " + _curStackValue.priority);
}
Console.WriteLine("_________________________________________");
if (verifyParentheses())
{
if (verifyParenthesesExp())
{
// Verify all brackets
nodeValue[] allOperators = _operatorsStackCopy.ToArray();
_tempOperStack = new Stack<nodeValue>();
// DEBUG Operators nesting
for (int i = 0; i < allOperators.Length; i++)
{
allOperators[i].nested = getPriorForOperator(allOperators[i].pos);
_tempOperStack.Push(allOperators[i]);
Console.WriteLine("Nesting= " + allOperators[i].nested + " Op" + allOperators[i].operatorSym);
}
Console.WriteLine("_________________________________________");
int curPos, operBeginPos, operEndPos;
bool foundBegin;
char[] sym = { '-', '/', '*', '+', ')', '(' };
// Setting operators operands
for (int i = 0; i < allOperators.Length; i++)
{
foundBegin = false;
// Find left operand
if (_inputEquation[allOperators[i].pos - 1] != ')')
{
operBeginPos = operEndPos = allOperators[i].pos - 1;
while (operBeginPos > 0 && !foundBegin)
{
if (_inputEquation.IndexOfAny(sym, operBeginPos - 1, 1) != -1)
foundBegin = true;
else
operBeginPos--;
}
allOperators[i].operandLeft = _inputEquation.Substring(operBeginPos, operEndPos - operBeginPos + 1);
}
else
{
// Find nested
}
foundBegin = false;
// Find right operand
if (_inputEquation[allOperators[i].pos + 1] != '(')
{
operBeginPos = operEndPos = allOperators[i].pos + 1;
while (operEndPos < _inputEquation.Length - 1 && !foundBegin)
{
if (_inputEquation.IndexOfAny(sym, operEndPos + 1, 1) != -1)
foundBegin = true;
else
operEndPos++;
}
allOperators[i].operandRight = _inputEquation.Substring(operBeginPos, operEndPos - operBeginPos + 1);
}
}
/*
// DEBUG Tree
MainForm testForm = new MainForm();
TreeView testTV = new TreeView();
testForm.Controls.Add(testTV);
testForm.Controls[0].Width = 500;
testForm.Controls[0].Height = 1500;
testTV.Width = 500;
testTV.Height = 1500;
bool first = false;
int lastNested = 0;
int lastPrior = 0;
int curNested = 0;
int curPrior = 0;
string tempString;
TreeViewController<String> treeViewController = new TreeViewController<String>((TreeView)testForm.Controls[0], root);
while (_tempOperStack.Count > 0)
{
curStackValue = _tempOperStack.Pop();
if (!first)
{
// Lowest priority, means last in evaluation
if (curNode != null)
lastNode = curNode.Nodes.Add(curStackValue.toString());
else
curNode = lastNode = root.Nodes.Add(curStackValue.toString());
first = true;
}
else
{
// Lowest priority, means last in evaluation
// The same nesting, adding to to this leave
if (lastNested == curStackValue.nested)
{
if (lastPrior <= curStackValue.priority)
{
lastNode = curNode.Nodes.Add(curStackValue.toString());
//CopyNodeToNode(lastNode, curNode);
//lastNode.Remove();
//lastNode = curNode;
}
else
{
//curNode = root.Nodes.InsertBefore(lastNode, curStackValue.toString());
//CopyNodeToNode(curNode, lastNode);
lastNode = curNode.Nodes.Add(curStackValue.toString());//tempString
}
}
else
{
if (lastNested > curStackValue.nested)
{
if (curNode.Nodes.Count < 2)
{
curNode = curNode.Nodes.Add(curStackValue.toString());
curNested = curStackValue.nested;
curPrior = curStackValue.priority;
tempString = lastNode.Value;
lastNode.Remove();
curNode.Nodes.Add(tempString);
}
else
{
if (curNode.Parent.Parent == null)
{
lastNode = root.Nodes.InsertBefore(curNode, curStackValue.toString());
CopyNodeToNode(curNode, lastNode);
curNode.Remove();
curNode = lastNode;
}
else
{
lastNode = curNode.Parent.Nodes.Add(curStackValue.toString());
curNode = curNode.Parent;
}
}
}
else
{
lastNode = curNode.Nodes.Add(curStackValue.toString());
}
}
}
lastNested = curStackValue.nested;
lastPrior = curStackValue.priority;
}
testForm.ShowDialog();
*/
}
else
{
Console.WriteLine("validation Error! Operator Missing!");
return -1;
}
}
else
{
Console.WriteLine("validation Error! Parentheses Missing!");
return -1;
}
return 0;
}
/// <summary>
/// Gets double value from node.
/// </summary>
/// <param name="node">SyntaxTree node.</param>
protected void getDoubleValue(DTreeNode<string> node)
{
double value;
Double.TryParse(LexemTypeHelper.getParsedValue(node.Value), out value);
ilg.Emit(OpCodes.Ldc_R4, value);
}
public DTreeNode<string> addNode(DTreeNode<string> parentNode, string value)
{
return parentNode.Nodes.Add(value);
}
/// <summary>
/// Handles while loop.
/// </summary>
/// <param name="node">SyntaxTree node of the while loop.</param>
protected void handleWhile(DTreeNode<string> node)
{
// Prepare needed labels.
Label tempAfterLabel = lastAfterLabel;
Label afterLabel = ilg.DefineLabel();
lastAfterLabel = afterLabel;
Label whileLabel = ilg.DefineLabel();
Label bodyLabel = ilg.DefineLabel();
bool isElse = node.Nodes.Count == 4 ? true : false;
// Mark statement label.
ilg.MarkLabel(whileLabel);
handleComparison(node.Nodes[0], bodyLabel, afterLabel, false);
// Mark loop body label.
ilg.MarkLabel(bodyLabel);
next(node.Nodes[1]);
ilg.Emit(OpCodes.Br, whileLabel);
// Mark loop exit label.
ilg.MarkLabel(afterLabel);
next(node.Nodes[2]);
lastAfterLabel = tempAfterLabel;
}
/// <summary>
/// Processes the next independent command in the code.
/// </summary>
/// <param name="node">SyntaxTree node of the command.</param>
protected void next(DTreeNode<string> node)
{
int type = 0;
string value = LexemTypeHelper.parse(ref type, node.Value);
switch (type)
{
case 1: handeOperator(node); break;
case 2: handleKeyword(node); break;
case 3: handleIdentifier(node); break;
default: break;
}
}
/// <summary>
/// Constructor of generator.
/// </summary>
/// <param name="node">Entry node of the method.</param>
/// <param name="ilg">ILGenerator, used in the assembly.</param>
public GeneratorCode(DTreeNode<string> node, ILGenerator ilg)
{
this.node = node;
this.ilg = ilg;
}
/// <summary>
/// Handles System keyword. !!!On any System... calls
/// System.Console.WriteLine(...);
/// </summary>
/// <param name="node">SyntaxTree node of System keyword.</param>
protected void handleSystem(DTreeNode<string> node)
{
if (node.Nodes.Count > 0)
{
handleSystem(node.Nodes[0]);
}
else
{
ilg.EmitWriteLine(handleIdentifier(node));
}
if (LexemTypeHelper.getParsedValue(node.Value) == "System" &&
node.Nodes.Count > 1)
next(node.Nodes[1]);
}
/// <summary>
/// Handles the plus operation.
/// </summary>
/// <param name="node">SyntaxTree node of plus operation.</param>
protected void handlePlus(DTreeNode<string> node)
{
getValue(node.Nodes[0]);
getValue(node.Nodes[1]);
ilg.Emit(OpCodes.Add);
}
/// <summary>
/// Gets int value from node.
/// </summary>
/// <param name="node">SyntaxTree node.</param>
protected void getIntValue(DTreeNode<string> node)
{
int value;
Int32.TryParse(LexemTypeHelper.getParsedValue(node.Value), out value);
ilg.Emit(OpCodes.Ldc_I4, value);
}
/// <summary>
/// Gets identifier value.
/// </summary>
/// <param name="node">SyntaxTree node of identifier.</param>
protected void getIdentifierValue(DTreeNode<string> node)
{
string name = LexemTypeHelper.getParsedValue(node.Value);
LocalBuilder lBuilder;
if (locals.TryGetValue(name, out lBuilder))
{
ilg.Emit(OpCodes.Ldloc, lBuilder);
}
}
public void printSomeNodes(DTreeNode<string> node, ref int toPrint)
{
if (node.Nodes.Count > 0)
{
printSomeNodes(node.Nodes[0], ref toPrint);
}
Console.WriteLine(LexemTypeHelper.getParsedValue(node.Value));
if (toPrint < 1) return;
toPrint--;
if (toPrint < 1) return;
if (node.Nodes.Count > 0)
{
printSomeNodes(node.Nodes[1], ref toPrint);
}
}
/// <summary>
/// Handles the keyword as the next command.
/// </summary>
/// <param name="node">SyntaxTree node of the keyword.</param>
protected void handleKeyword(DTreeNode<string> node)
{
string name = LexemTypeHelper.getParsedValue(node.Value);
switch (name)
{
case "while":
handleWhile(node);
break;
case "if":
handleIf(node);
break;
case "System":
handleSystem(node);
break;
}
}
/*private int printItselfToTheFile(DTreeNode<string> node, int depth = 0)
{
DTreeNode<string> curr = root;
int currOffset, offset = 0, counter = 0;
if (depth > 0 && array[depth - 1] > array[depth]) array[depth] = array[depth - 1];
foreach (DTreeNode<string> dNode in node.Nodes)
{
offset = findMaxOffset(depth);
counter++;
currOffset = printItselfToTheFile(dNode, depth + 1);
if (counter == 1) offset = currOffset;
}
if (depth == 0)
{
return 0;
}
//Console.SetCursorPosition(array[depth], depth);
strings[depth]. Insert(array[depth], node.Value);
array[depth] += node.Value.Length + 1;
if (offset > array[depth]) array[depth] = offset;
//Console.Write(node.Value);
if (counter == 0) return array[depth] - node.Value.Length - 1;
else return offset;
}*/
private void printItselfToTheFile(DTreeNode<string> node, int depth, int offset)
{
DTreeNode<string> curr = root;
int currOffset, counter = 0;
if (depth > 0 && array[depth - 1] > array[depth]) array[depth] = array[depth - 1];
foreach (DTreeNode<string> dNode in node.Nodes)
{
//offset = findMaxOffset(depth);
printItselfToTheFile(dNode, depth + 1, findMaxOffset(depth));
}
if (array[depth] < offset) array[depth] = offset;
strings[depth].Insert(array[depth], node.Value);
if (depth == 0) return;
array[depth] += node.Value.Length + 1;
}
/// <summary>
/// Handles if expression.
/// </summary>
/// <param name="node">SyntaxTree node of the if statement.</param>
protected void handleIf(DTreeNode<string> node)
{
// Prepare needed lables.
Label tempAfterLabel = lastAfterLabel;
Label afterLabel = ilg.DefineLabel();
lastAfterLabel = afterLabel;
Label ifLabel = ilg.DefineLabel();
Label elseLabel = ilg.DefineLabel();
bool isElse = node.Nodes.Count == 4 ? true : false;
// Make statement comparison, write jumps.
handleComparison(node.Nodes[0], ifLabel, elseLabel, isElse);
// Set the label of the main if body.
if (node.Nodes.Count > 2)
{
ilg.MarkLabel(ifLabel);
next(node.Nodes[1]);
}
// Set the label of the else if body.
if (node.Nodes.Count > 3)
{
ilg.MarkLabel(elseLabel);
next(node.Nodes[2]);
}
// Set the exit point of the if statement.
else
{
ilg.MarkLabel(afterLabel);
next(node.Nodes[2]);
}
lastAfterLabel = tempAfterLabel;
}
/// <summary>
/// Copies Src Node to Dest Node, and copies all nodes also.
/// </summary>
/// <param name="src">Source to copy from.</param>
/// <param name="dest">Destenation node to copy to.</param>
public void CopyNodeToNode(DTreeNode<String> src, DTreeNode<String> dest)
{
DTreeNode<String> retNode = new DTreeNode<string>(src.Value);
for (int i = 0; i < src.Nodes.Count; i++)
{
CopyNodeToNode(src.Nodes[i], retNode);
}
dest.Nodes.Add(retNode);
}
/// <summary>
/// Handles identifier. Get LocalBuilder or creates it.
/// </summary>
/// <param name="node">SyntaxTree node of identifier.</param>
/// <returns>LocalBUilder instance that represents the identifier.</returns>
protected LocalBuilder handleIdentifier(DTreeNode<string> node)
{
int type = 0;
string s = LexemTypeHelper.parse(ref type, node.Value);
LocalBuilder lBuilder;
if (!locals.TryGetValue(s, out lBuilder))
{
if (node.Nodes.Count == 0)
{
// ERROR! TODO
}
lBuilder = ilg.DeclareLocal(ILHelper.getILType(LexemTypeHelper.getParsedValue(node.Nodes[0].Value)));
locals.Add(s, lBuilder);
}
return lBuilder;
}
internal void AddNewAssembly(AssemblyDefinition asmDef)
{
currentAssemblyNode = _rootNode.Nodes.Add(new DTreeItem(asmDef.Name.Name, SelectionType.ASSEMBLY));
DTreeNode<DependencyGraphData> asmRootNode = GetDependencyGraphNode(
new DTreeItem(asmDef.Name.Name, SelectionType.ASSEMBLY), GraphDataArrow.NONE, "");
// build graph data for assembly
// reqd. Assembly References
foreach (AssemblyNameReference asmRef in asmDef.MainModule.AssemblyReferences)
{
asmRootNode.Nodes.Add(GetDependencyGraphNode(
new DTreeItem(asmRef.Name, SelectionType.ASSEMBLY), GraphDataArrow.TO,
"references"));
}
graphData.Add(asmDef.Name.Name, asmRootNode);
}
/// <summary>
/// Gets the values of compare statement into the stack
/// and compares them.
/// </summary>
/// <param name="node">SyntaxTree node of compare operator.</param>
/// <param name="ifLabel">Label that will be executed, if statement
/// is true.</param>
/// <param name="elseLabel">Label that will be executed if statement
/// is false.</param>
/// <param name="isElse">Only for if statement. Is there the else
/// code branch. Otherwise, shoud be false.</param>
protected void handleComparison(DTreeNode<string> node, Label ifLabel, Label elseLabel, bool isElse)
{
getValue(node.Nodes[0]);
getValue(node.Nodes[1]);
//ilg.EmitWriteLine(handleIdentifier(node.Nodes[1]));
//ilg.EmitWriteLine(handleIdentifier(node.Nodes[0]));
switch (LexemTypeHelper.getParsedValue(node.Value))
{
case "==": handleEqual(ifLabel, elseLabel, isElse); break;
case "!=": handleNotEqual(ifLabel, elseLabel, isElse); break;
case ">": handleBigger(ifLabel, elseLabel, isElse); break;
case "<": handleLess(ifLabel, elseLabel, isElse); break;
}
}
/// <summary>
/// Handles assignment operator.
/// </summary>
/// <param name="node">SyntaxTree node of operator.</param>
protected void handleAssignment(DTreeNode<string> node)
{
int type = 0;
string name = LexemTypeHelper.parse(ref type, node.Nodes[0].Value);
getValue(node.Nodes[1]);
ilg.Emit(OpCodes.Stloc, handleIdentifier(node.Nodes[0]));
if (node.Nodes.Count > 2)
{
next(node.Nodes[2]);
}
}
/// <summary>
/// Handles the minus operation.
/// </summary>
/// <param name="node">SyntaxTree node of minus operation.</param>
protected void handleMinus(DTreeNode<string> node)
{
if (node.Nodes.Count == 1)
{
getValue(node.Nodes[0]);
ilg.Emit(OpCodes.Ldc_I4, (int)-1);
ilg.Emit(OpCodes.Mul);
}
else
{
getValue(node.Nodes[0]);
getValue(node.Nodes[1]);
ilg.Emit(OpCodes.Sub);
}
}
