public CodePart Compile(ParseTree tree, Context context, CompilerOptions options)
{
_part = new CodePart();
_context = context;
_options = options;
try
{
if (tree.Nodes.Count > 0)
{
PreProcess(tree);
CompileProgram(tree);
}
}
catch (Exception e)
{
if (_lastNode != null)
{
throw new Exception(string.Format("Error parsing {0}: {1}", ConcatenateNodes(_lastNode), e.Message));
}
else
{
throw;
}
}
return _part;
}
public CodePart Compile(int startLineNum, ParseTree tree, Context context, CompilerOptions options)
{
InitCompileFlags();
part = new CodePart();
this.context = context;
this.options = options;
this.startLineNum = startLineNum;
++context.NumCompilesSoFar;
try
{
if (tree.Nodes.Count > 0)
{
PreProcess(tree);
CompileProgram(tree);
}
}
catch (KOSException kosException)
{
if (lastNode != null)
{
throw; // TODO something more sophisticated will go here that will
// attach source/line information to the exception before throwing it upward.
// that's why this seemingly pointless "catch and then throw again" is here.
}
SafeHouse.Logger.Log("Exception in Compiler: " + kosException.Message);
SafeHouse.Logger.Log(kosException.StackTrace);
throw; // throw it up in addition to logging the stack trace, so the kOS terminal will also give the user some message.
}
return part;
}
protected override void TranslateAssignment(List<string> output, ParseTree.Assignment assignment)
{
output.Add(this.CurrentTabIndention);
Expression target = assignment.Target;
if (target is Variable && ((Variable)target).IsStatic)
{
output.Add("public static ");
}
Annotation typeAnnotation = target.GetAnnotation("type");
if (typeAnnotation != null)
{
string type = this.JavaPlatform.GetTypeStringFromAnnotation(
typeAnnotation.FirstToken,
typeAnnotation.GetSingleArgAsString(null),
false, false);
output.Add(type);
output.Add(" ");
}
this.TranslateExpression(output, target);
output.Add(" ");
output.Add(assignment.AssignmentOp);
output.Add(" ");
this.TranslateExpression(output, assignment.Value);
output.Add(";");
output.Add(this.NL);
}
protected override object EvalAttribute(ParseTree tree, params object[] paramlist)
{
Grammar grammar = (Grammar)paramlist[0];
Symbol symbol = (Symbol)paramlist[1];
GrammarNode node = (GrammarNode)paramlist[2];
if (symbol.Attributes.ContainsKey(node.Nodes[1].Token.Text))
{
tree.Errors.Add(new ParseError("Attribute already defined for this symbol: " + node.Nodes[1].Token.Text, 0x1039, node.Nodes[1]));
return null;
}
symbol.Attributes.Add(node.Nodes[1].Token.Text, (object[])EvalParams(tree, new object[] { node }));
switch (node.Nodes[1].Token.Text)
{
case "Skip":
if (symbol is TerminalSymbol)
grammar.SkipSymbols.Add(symbol);
else
tree.Errors.Add(new ParseError("Attribute for non-terminal rule not allowed: " + node.Nodes[1].Token.Text, 0x1035, node));
break;
case "Color":
if (symbol is NonTerminalSymbol)
tree.Errors.Add(new ParseError("Attribute for non-terminal rule not allowed: " + node.Nodes[1].Token.Text, 0x1035, node));
if (symbol.Attributes["Color"].Length != 1 && symbol.Attributes["Color"].Length != 3)
tree.Errors.Add(new ParseError("Attribute " + node.Nodes[1].Token.Text + " has too many or missing parameters", 0x103A, node.Nodes[1]));
for (int i = 0; i < symbol.Attributes["Color"].Length; i++)
{
if (symbol.Attributes["Color"][i] is string)
{
tree.Errors.Add(new ParseError("Parameter " + node.Nodes[3].Nodes[i * 2].Nodes[0].Token.Text + " is of incorrect type", 0x103A, node.Nodes[3].Nodes[i * 2].Nodes[0]));
break;
}
}
break;
case "IgnoreCase":
if (!(symbol is TerminalSymbol))
tree.Errors.Add(new ParseError("Attribute for non-terminal rule not allowed: " + node.Nodes[1].Token.Text, 0x1035, node));
break;
case "FileAndLine":
if (symbol is TerminalSymbol)
{
grammar.SkipSymbols.Add(symbol);
grammar.FileAndLine = symbol;
}
else
tree.Errors.Add(new ParseError("Attribute for non-terminal rule not allowed: " + node.Nodes[1].Token.Text, 0x1035, node));
break;
default:
tree.Errors.Add(new ParseError("Attribute not supported: " + node.Nodes[1].Token.Text, 0x1036, node.Nodes[1]));
break;
}
return symbol;
}
protected override void X_ImageBlit(List<string> output, ParseTree.Expression screen, ParseTree.Expression image, ParseTree.Expression x, ParseTree.Expression y)
{
output.Add("$gfx_blit_image(");
SerializeExpression(output, image);
output.Add(", $floor(");
SerializeExpression(output, x);
output.Add("), $floor(");
SerializeExpression(output, y);
output.Add("))");
}
public ParseTree Parse(string input, string fileName, ParseTree tree)
{
scanner.Init(input, fileName);
this.tree = tree;
ParseStart(tree);
tree.Skipped = scanner.Skipped;
return tree;
}
private void CompileProgram(ParseTree tree)
{
_currentCodeSection = _part.MainCode;
PushProgramParameters();
VisitNode(tree.Nodes[0]);
if (_addBranchDestination)
{
AddOpcode(new OpcodeNOP());
}
}
protected override void TranslateFunctionDefinition(List<string> output, ParseTree.FunctionDefinition functionDef)
{
output.Add(this.CurrentTabIndention);
string returnType = "void*";
Annotation returnTypeAnnotation = functionDef.GetAnnotation("type");
if (returnTypeAnnotation != null)
{
returnType = this.CPlatform.GetTypeStringFromAnnotation(new AnnotatedType(returnTypeAnnotation), false, true);
}
output.Add(returnType);
output.Add(" ");
output.Add("v_" + functionDef.NameToken.Value);
output.Add("(");
for (int i = 0; i < functionDef.ArgNames.Length; ++i)
{
if (i > 0) output.Add(", ");
if (functionDef.ArgAnnotations[i] == null)
{
output.Add("object ");
}
else
{
string argType = functionDef.ArgAnnotations[i].GetSingleArgAsString(null);
string type = this.CPlatform.GetTypeStringFromAnnotation(functionDef.ArgAnnotations[i].FirstToken, argType, false, true);
output.Add(type);
output.Add(" ");
}
output.Add("v_" + functionDef.ArgNames[i].Value);
}
output.Add(")");
output.Add(this.NL);
output.Add(this.CurrentTabIndention);
output.Add("{");
output.Add(this.NL);
this.CurrentIndention++;
Executable[] code = functionDef.Code;
if (functionDef.GetAnnotation("omitReturn") != null)
{
Executable[] newCode = new Executable[code.Length - 1];
Array.Copy(code, newCode, newCode.Length);
code = newCode;
}
this.Translate(output, code);
this.CurrentIndention--;
output.Add(this.CurrentTabIndention);
output.Add("}");
//*/
output.Add(this.NL);
}
public override ParseTree Parse(Lexer lexer, ParserState state)
{
ParseTree bodyTree = body.Parse(lexer, state);
if (bodyTree == ParseTree.No)
return ParseTree.No;
ParseTree labelledTree = new ParseTree();
labelledTree = labelledTree.ExtendFields(bodyTree);
labelledTree.Fields[label] = bodyTree.Value;
return labelledTree;
}
private void AssembleGraph(BidirectionalGraph<ParseTree, Edge<ParseTree>> graph, ParseTree parent)
{
if (parent.Children == null)
{
return;
}
foreach (var child in parent.Children)
{
graph.AddVertex(child);
graph.AddEdge(new Edge<ParseTree>(parent, child));
AssembleGraph(graph, child);
}
}
protected override object EvalAssignmentExpression(ParseTree tree, params object[] paramlist)
{
object result = this.GetValue(tree, TokenType.ConditionalOrExpression, 0);
if (nodes.Count >= 5 && result is bool
&& nodes[1].Token.Type == TokenType.QUESTIONMARK
&& nodes[3].Token.Type == TokenType.COLON)
{
if (Convert.ToBoolean(result))
result = nodes[2].Eval(tree, paramlist); // return 1st argument
else
result = nodes[4].Eval(tree, paramlist); // return 2nd argumen
}
return result;
}
protected override object EvalAdditiveExpression(ParseTree tree, params object[] paramlist)
{
object result = this.GetValue(tree, TokenType.MultiplicativeExpression, 0);
for (int i = 1; i < nodes.Count; i += 2)
{
Token token = nodes[i].Token;
object val = nodes[i + 1].Eval(tree, paramlist);
if (token.Type == TokenType.PLUS)
result = Convert.ToDouble(result) + Convert.ToDouble(val);
else if (token.Type == TokenType.MINUS)
result = Convert.ToDouble(result) - Convert.ToDouble(val);
}
return result;
}
public void AllowNestedOutputAtEachLevel()
{
var tree = new ParseTree("<system goal>");
tree.AddTerminalChild("begin");
tree.AddChildNode(BuildStatementNode());
tree.AddTerminalChild("end");
tree.BuildLinesDifferently();
Assert.AreEqual("<system goal>", tree.Lines[0]);
Assert.AreEqual("begin <statement> end ", tree.Lines[1]);
Assert.AreEqual("begin Id := <expression> ; end ", tree.Lines[2]);
Assert.AreEqual("begin Id := <primary> <add op> <expression> ; end ", tree.Lines[3]);
Assert.AreEqual("begin Id := Id <add op> <expression> ; end ", tree.Lines[4]);
Assert.AreEqual("begin Id := Id PlusOp <expression> ; end ", tree.Lines[5]);
Assert.AreEqual("begin Id := Id PlusOp <primary> ; end ", tree.Lines[6]);
Assert.AreEqual("begin Id := Id PlusOp IdX ; end ", tree.Lines[7]);
}
public CodePart Compile(int startLineNum, ParseTree tree, Context context, CompilerOptions options)
{
InitCompileFlags();
part = new CodePart();
this.context = context;
this.options = options;
this.startLineNum = startLineNum;
++context.NumCompilesSoFar;
if (tree.Nodes.Count > 0)
{
PreProcess(tree);
CompileProgram(tree);
}
return part;
}
public static void Populate(TreeView treeview, ParseTree parsetree)
{
treeview.Visible = false;
treeview.SuspendLayout();
treeview.Nodes.Clear();
treeview.Tag = parsetree;
ParseNode start = parsetree.Nodes[0];
TreeNode node = new TreeNode(start.Text);
node.Tag = start;
node.ForeColor = Color.SteelBlue;
treeview.Nodes.Add(node);
PopulateNode(node, start);
treeview.ExpandAll();
treeview.ResumeLayout();
treeview.Visible = true;
}
protected override void X_DrawRectangle(List<string> output, ParseTree.Expression screen, ParseTree.Expression left, ParseTree.Expression top, ParseTree.Expression width, ParseTree.Expression height, ParseTree.Expression red, ParseTree.Expression green, ParseTree.Expression blue)
{
output.Add("$gfx_draw_rectangle(");
SerializeExpression(output, left);
output.Add(", ");
SerializeExpression(output, top);
output.Add(", ");
SerializeExpression(output, width);
output.Add(", ");
SerializeExpression(output, height);
output.Add(", ");
SerializeExpression(output, red);
output.Add(", ");
SerializeExpression(output, green);
output.Add(", ");
SerializeExpression(output, blue);
output.Add(", 255)");
}
public void ExtendingFields()
{
ParseTree a = new ParseTree();
a.Fields["a"] = "A";
a.Fields["b"] = "B";
a.Fields["c"] = "C";
Assert.IsTrue(a.Fields.ContainsKey("a"));
Assert.IsTrue(a.Fields.ContainsKey("b"));
Assert.IsTrue(a.Fields.ContainsKey("c"));
ParseTree b = new ParseTree();
b.ExtendFields(a);
b.Fields["d"] = "D";
Assert.IsTrue(b.Fields.ContainsKey("a"));
Assert.IsTrue(b.Fields.ContainsKey("b"));
Assert.IsTrue(b.Fields.ContainsKey("c"));
Assert.IsTrue(b.Fields.ContainsKey("d"));
}
protected override void X_DrawRectangle(List<string> output, ParseTree.Expression screen, ParseTree.Expression left, ParseTree.Expression top, ParseTree.Expression width, ParseTree.Expression height, ParseTree.Expression red, ParseTree.Expression green, ParseTree.Expression blue)
{
// TODO: need to run this through a helper function to avoid 1-height bugs
output.Add("pygame.draw.rect(");
SerializeExpression(output, screen);
output.Add(", (");
SerializeExpression(output, red);
output.Add(", ");
SerializeExpression(output, green);
output.Add(", ");
SerializeExpression(output, blue);
output.Add("), pygame.Rect(");
SerializeExpression(output, left);
output.Add(", ");
SerializeExpression(output, top);
output.Add(", ");
SerializeExpression(output, width);
output.Add(", ");
SerializeExpression(output, height);
output.Add("))");
}
protected override void TranslateFunctionDefinition(List<string> output, ParseTree.FunctionDefinition functionDef)
{
Annotation returnType = functionDef.GetAnnotation("type");
string type = returnType == null ? "Object" : this.JavaPlatform.GetTypeStringFromString(returnType.GetSingleArgAsString(null), false, false);
output.Add(this.CurrentTabIndention);
output.Add("public static ");
output.Add(type);
output.Add(" v_");
output.Add(functionDef.NameToken.Value);
output.Add("(");
for (int i = 0; i < functionDef.ArgNames.Length; ++i)
{
if (i > 0) {
output.Add(", ");
}
Annotation annotation = functionDef.ArgAnnotations[i];
string argType = annotation == null ? "Object" : annotation.GetSingleArgAsString(null);
output.Add(this.JavaPlatform.GetTypeStringFromString(argType, false, false));
output.Add(" v_");
output.Add(functionDef.ArgNames[i].Value);
}
output.Add(") {");
output.Add(this.NL);
this.CurrentIndention++;
Executable[] code = functionDef.Code;
if (functionDef.GetAnnotation("omitReturn") != null)
{
Executable[] newCode = new Executable[code.Length - 1];
Array.Copy(code, newCode, newCode.Length);
code = newCode;
}
this.Translate(output, code);
this.CurrentIndention--;
output.Add(this.CurrentTabIndention);
output.Add("}");
output.Add(this.NL);
}
public override ParseTree Parse(Lexer lexer, ParserState state)
{
state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), "token");
int start = lexer.Position;
ParseTree bodyTree = body.Parse(lexer, state);
if (bodyTree == ParseTree.No)
{
state.RuntimeState.Runtime.ParseTrace.No(this, lexer.SourceFrom(start));
return ParseTree.No;
}
state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start));
ParseTree tokenTree = new ParseTree(
lexer.Text.Substring(start, lexer.Position - start));
tokenTree = tokenTree.ExtendFields(bodyTree);
return tokenTree;
}
public ViewData(ParseTree tree)
{
this.Tree = tree;
NotColoredTokens.AddRange(tree.Tokens);
}
public void Initialize()
{
tree = new ParseTree();
}
public Additive(ParseTree term, ParseTree prime)
{
this.Term = term;
this.Prime = prime;
}
private void PreProcess(ParseTree tree)
{
ParseNode rootNode = tree.Nodes[0];
LowercaseConversions(rootNode);
RearrangeParseNodes(rootNode);
TraverseScopeBranch(rootNode);
IterateUserFunctions(rootNode, IdentifyUserFunctions);
PreProcessStatements(rootNode);
IterateUserFunctions(rootNode, PreProcessUserFunctionStatement);
}
public void Analizar(String entrada)
{
GramaticaCQL gramatica = new GramaticaCQL();
LanguageData lenguaje = new LanguageData(gramatica);
Parser parser = new Parser(lenguaje);
ParseTree arbol = parser.Parse(entrada);
ParseTreeNode raiz = arbol.Root;
Estatico.errores = new List <ErrorCQL>();
Estatico.mensajes = new List <String>();
Estatico.servidor = new Servidor();
obteErroes(arbol);
if (raiz != null)
{
Graficador.Graficador grafo = new Graficador.Graficador();
grafo.graficar(raiz);
ConstruirAST constructor = new ConstruirAST(raiz);
AST arbolAst = constructor.generarAst();
Entorno ent = new Entorno(null);
//-------- Prueba;
BaseDatos prueba = new BaseDatos("prueba");
Estatico.servidor.nuevaBase("prueba", prueba);
Usuario admin = new Usuario("admin", "admin");
Estatico.actualUsuario = admin;
foreach (NodoAST sentencia in arbolAst.arbol)
{
if (sentencia is Instruccion)
{
if (sentencia is Funcion)
{
Funcion fun = (Funcion)sentencia;
ent.agregar(fun.identificador, fun);
}
}
else if (sentencia is Expresion)
{
}
}
foreach (NodoAST sentencia in arbolAst.arbol)
{
if (sentencia is Instruccion)
{
if (!(sentencia is Funcion))
{
Instruccion ins = (Instruccion)sentencia;
object valor = ins.ejecutar(ent);
}
}
else if (sentencia is Expresion)
{
Expresion exp = (Expresion)sentencia;
object valor = exp.getValor(ent);
}
}
//por el momento modificar al final
ReporteErrores reporte = new ReporteErrores(Estatico.errores);
reporte.writeReport();
}
else
{
Estatico.agregarMensaje("[+MESSAGE]raiz nula[-MESSAGE]");
//MessageBox.Show("raiznula");
}
}
private void runButton_Click(object sender, EventArgs e)
{
resultadoAnalisis = null;
resultadoAnalisis = SintacticoInterprete.Analizar(code_textbox.Text);
error_table.Rows.Clear();
symbol_table.Rows.Clear();
console_textbox.Text = "";
if (resultadoAnalisis != null)
{
if (resultadoAnalisis.ParserMessages.Count == 0)
{
SemanticoInterprete semanticoInterprete = new SemanticoInterprete();
semanticoInterprete.iniciarAnalisisSintactico(resultadoAnalisis.Root);
Simbolo sim;
String valorTabla = "";
if (semanticoInterprete.errores.Count != 0)
{
table_label.Text = "Error Table";
symbol_table.Visible = false;
error_table.Visible = true;
foreach (Error error in semanticoInterprete.errores)
{
error_table.Rows.Add("Semantico", error.error, error.fila + 1, error.columna + 1);
}
}
else
{
table_label.Text = "Symbol Table";
symbol_table.Visible = true;
error_table.Visible = false;
foreach (Entorno entorno in semanticoInterprete.entornos)
{
foreach (KeyValuePair <string, Simbolo> variable in entorno.tabla)
{
if (typeof(Objeto).IsInstanceOfType(variable.Value.valor))
{
string valor = "";
if (((Objeto)variable.Value.valor).arreglo is null)
{
foreach (KeyValuePair <string, Simbolo> parametro in ((Objeto)variable.Value.valor).parametros)
{
sim = parametro.Value;
if (sim.valor.ToString().Contains("Proyecto1_Compiladores2"))
{
valorTabla = ((Objeto)sim.valor).nombre;
if (valor == "")
{
valor = parametro.Key + ": " + valorTabla;
}
else
{
valor += ", " + parametro.Key + ": " + valorTabla;
}
}
else
{
if (valor == "")
{
valor = parametro.Key + ": " + sim.valor;
}
else
{
valor += ", " + parametro.Key + ": " + sim.valor;
}
}
}
}
else
{
Objeto tmp = (Objeto)variable.Value.valor;
if (tmp.tipo != Simbolo.EnumTipo.objeto)
{
valor = tmp.tipo + "[" + tmp.arreglo.GetLength(0);
}
else
{
valor = tmp.nombreTipo + "[" + tmp.arreglo.GetLength(0);
}
for (int i = 1; i < tmp.arreglo.Rank; i++)
{
valor += ", " + tmp.arreglo.GetLength(i);
}
valor += "]";
}
symbol_table.Rows.Add(variable.Key, variable.Value.tipo, entorno.nombreEntorno, variable.Value.fila, variable.Value.columna, valor);
}
else
{
if (variable.Value.tipo == Simbolo.EnumTipo.funcion || variable.Value.tipo == Simbolo.EnumTipo.procedimiento)
{
SubPrograma sp = (SubPrograma)variable.Value.valor;
string valor = "";
if (sp.ordenParametros.Count != 0)
{
foreach (string cadena in sp.ordenParametros)
{
if (valor == "")
{
valor = "; {" + cadena;
}
else
{
valor += ", " + cadena;
}
}
valor += "}";
}
symbol_table.Rows.Add(variable.Key, variable.Value.tipo, entorno.nombreEntorno, variable.Value.fila, variable.Value.columna, sp.tipo + valor);
}
else
{
symbol_table.Rows.Add(variable.Key, variable.Value.tipo, entorno.nombreEntorno, variable.Value.fila, variable.Value.columna, variable.Value.valor.ToString());
}
}
}
}
}
foreach (string texto in semanticoInterprete.consola)
{
if (texto.Contains("\n"))
{
console_textbox.Text += texto.Replace("\n", "") + Environment.NewLine;
}
else
{
console_textbox.Text += texto;
}
}
//Graficar Arbol Irony
SintacticoInterprete.crearImagen(resultadoAnalisis.Root, null, 0);
/*Thread.Sleep(1000);
* var p = new Process();
*
* //Abrir imagen Irony
* p.StartInfo = new ProcessStartInfo(@"C:\compiladores2\ArbolIrony.png")
* {
* UseShellExecute = true
* };
* p.Start();*/
}
else
{
table_label.Text = "Error Table";
symbol_table.Visible = false;
error_table.Visible = true;
string mensajeTraducido = "";
foreach (Irony.LogMessage error in resultadoAnalisis.ParserMessages)
{
if (error.Message.Contains("expected"))
{
mensajeTraducido = error.Message.Replace("Syntax error, expected: ", "Se esperaba el token: ");
}
else
{
mensajeTraducido = "No se encontro simbolo para finalizar la cadena";
}
error_table.Rows.Add("Sintactico", mensajeTraducido, error.Location.Line + 1, error.Location.Column + 1);
}
}
}
else
{
}
}
public void ParseTreeCreateArgumentExceptioNumberInsteadOfOperatorTest()
{
var tree = new ParseTree("( 4 ( + 4 4 ) 4");
tree.Result();
}
public void ParseTreeResultBigTest()
{
var tree = new ParseTree("( ^ ( * ( + ( - 8 6 ) ( * 3 ( / 120 10 ) ) 4 ) 2 )");
Assert.AreEqual(23104, tree.Result());
}
public GeneradorAST(ParseTree arbol)
{
arbolirony = arbol;
generar(arbolirony.Root);
}
public void ParseTreeNegativeErectionTest()
{
var tree = new ParseTree("( ^ ( + 7 8 ) ( - 3 5 )");
tree.Result();
}
public void ParseTreeMoreNumberWithoutOperandTest()
{
var tree = new ParseTree("( * ( + 1 1 2 ) 2 )");
tree.Result();
}
public void ParseTreeForgettingSpaceTest()
{
var tree = new ParseTree("( * (+ 7 8 ) 8 )");
}
public void ParseTreeBadSymbolsInStringInOperandTest()
{
var tree = new ParseTree("( * ( * o 8 ) 8 )");
}
public void ParseTreeBadSymbolsInStringInOperatorTest()
{
var tree = new ParseTree("( * ( i 7 8 ) 8 )");
tree.Result();
}
public void ParseTreeResultTest()
{
var tree = new ParseTree("( * ( + 1 1 ) 2 )");
Assert.AreEqual(4, tree.Result());
}
private void ProcessCompoundKeywordWithError(ITokenList tokenList, ParseTree sqlTree, XmlElement currentContainerElement, ref int tokenID, List<int> significantTokenPositions, int keywordCount)
{
ProcessCompoundKeyword(tokenList, sqlTree, currentContainerElement, ref tokenID, significantTokenPositions, keywordCount);
sqlTree.ErrorFound = true;
}
public Unparser(ParseTree tree) => Tree = tree ?? throw new ArgumentNullException(nameof(tree));
private void CompileProgram(ParseTree tree)
{
currentCodeSection = part.MainCode;
PushReversedParameters();
VisitNode(tree.Nodes[0]);
if (addBranchDestination || currentCodeSection.Count == 0)
{
AddOpcode(new OpcodeNOP());
}
}
public AdditivePrime(string op, ParseTree term, ParseTree prime)
{
this.Operator = op;
this.Term = term;
this.Prime = prime;
}
public void ParseTreeResultDivideByZeroTest()
{
var tree = new ParseTree("( / ( * 2 4 ) ( - 2 2 ) )");
tree.Result();
}
public JavaPackage?TryParse(string text, out ParseTree parseTree)
{
return(TryParse(text, null, out parseTree));
}
public ParseTree Parse(string input)
{
tree = new ParseTree();
return Parse(input, tree);
}
/*
* { StatementList }
* or
* { }
* returns List<MoccaSuite>
*/
public virtual object EvalBlock(ParseTree tree, params object[] paramlist)
{
List <MoccaSuite> ret = (List <MoccaSuite>) this.GetValue(tree, TokenType.StatementList, 0);
return(ret);
}
/*
* ( Param )
* returns List<object>
*/
public virtual object EvalParams(ParseTree tree, params object[] paramlist)
{
return(this.GetValue(tree, TokenType.Param, 0));
}
public XmlDocument ParseSQL(ITokenList tokenList)
{
ParseTree sqlTree = new ParseTree(SqlXmlConstants.ENAME_SQL_ROOT);
sqlTree.ErrorFound = tokenList.HasErrors;
sqlTree.StartNewStatement();
int tokenCount = tokenList.Count;
int tokenID = 0;
while (tokenID < tokenCount)
{
IToken token = tokenList[tokenID];
switch (token.Type)
{
case SqlTokenType.OpenParens:
XmlElement firstNonCommentParensSibling = sqlTree.GetFirstNonWhitespaceNonCommentChildElement(sqlTree.CurrentContainer);
bool isInsertOrValuesClause = (
firstNonCommentParensSibling != null
&& (
(firstNonCommentParensSibling.Name.Equals(SqlXmlConstants.ENAME_OTHERKEYWORD)
&& firstNonCommentParensSibling.InnerText.ToUpperInvariant().StartsWith("INSERT")
)
||
(firstNonCommentParensSibling.Name.Equals(SqlXmlConstants.ENAME_COMPOUNDKEYWORD)
&& firstNonCommentParensSibling.GetAttribute(SqlXmlConstants.ANAME_SIMPLETEXT).ToUpperInvariant().StartsWith("INSERT ")
)
||
(firstNonCommentParensSibling.Name.Equals(SqlXmlConstants.ENAME_OTHERKEYWORD)
&& firstNonCommentParensSibling.InnerText.ToUpperInvariant().StartsWith("VALUES")
)
)
);
if (sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_CTE_ALIAS)
&& sqlTree.CurrentContainer.ParentNode.Name.Equals(SqlXmlConstants.ENAME_CTE_WITH_CLAUSE)
)
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_DDL_PARENS, "");
else if (sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.CurrentContainer.ParentNode.Name.Equals(SqlXmlConstants.ENAME_CTE_AS_BLOCK)
)
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SELECTIONTARGET_PARENS, "");
else if (firstNonCommentParensSibling == null
&& sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_SELECTIONTARGET)
)
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SELECTIONTARGET_PARENS, "");
else if (firstNonCommentParensSibling != null
&& firstNonCommentParensSibling.Name.Equals(SqlXmlConstants.ENAME_SET_OPERATOR_CLAUSE)
)
{
sqlTree.ConsiderStartingNewClause();
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SELECTIONTARGET_PARENS, "");
}
else if (IsLatestTokenADDLDetailValue(sqlTree))
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_DDLDETAIL_PARENS, "");
else if (sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK)
|| sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_DDL_OTHER_BLOCK)
|| isInsertOrValuesClause
)
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_DDL_PARENS, "");
else if (IsLatestTokenAMiscName(sqlTree.CurrentContainer))
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_FUNCTION_PARENS, "");
else
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_EXPRESSION_PARENS, "");
break;
case SqlTokenType.CloseParens:
//we're not likely to actually have a "SingleStatement" in parens, but
// we definitely want the side-effects (all the lower-level escapes)
sqlTree.EscapeAnySingleOrPartialStatementContainers();
//check whether we expected to end the parens...
if (sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_DDLDETAIL_PARENS)
|| sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_DDL_PARENS)
|| sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_FUNCTION_PARENS)
|| sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_EXPRESSION_PARENS)
|| sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_SELECTIONTARGET_PARENS)
)
{
sqlTree.MoveToAncestorContainer(1); //unspecified parent node...
}
else if (sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.CurrentContainer.ParentNode.Name.Equals(SqlXmlConstants.ENAME_SELECTIONTARGET_PARENS)
&& sqlTree.CurrentContainer.ParentNode.ParentNode.Name.Equals(SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.CurrentContainer.ParentNode.ParentNode.ParentNode.Name.Equals(SqlXmlConstants.ENAME_CTE_AS_BLOCK)
)
{
sqlTree.MoveToAncestorContainer(4, SqlXmlConstants.ENAME_CTE_WITH_CLAUSE);
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT, "");
}
else if (sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_SQL_CLAUSE)
&& (
sqlTree.CurrentContainer.ParentNode.Name.Equals(SqlXmlConstants.ENAME_EXPRESSION_PARENS)
|| sqlTree.CurrentContainer.ParentNode.Name.Equals(SqlXmlConstants.ENAME_SELECTIONTARGET_PARENS)
)
)
{
sqlTree.MoveToAncestorContainer(2); //unspecified grandfather node.
}
else
{
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHERNODE, ")");
}
break;
case SqlTokenType.OtherNode:
//prepare multi-keyword detection by "peeking" up to 7 keywords ahead
List<int> significantTokenPositions = GetSignificantTokenPositions(tokenList, tokenID, 7);
string significantTokensString = ExtractTokensString(tokenList, significantTokenPositions);
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_PERMISSIONS_DETAIL))
{
//if we're in a permissions detail clause, we can expect all sorts of statements
// starters and should ignore them all; the only possible keywords to escape are
// "ON" and "TO".
if (significantTokensString.StartsWith("ON "))
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_PERMISSIONS_BLOCK);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_PERMISSIONS_TARGET, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else if (significantTokensString.StartsWith("TO ")
|| significantTokensString.StartsWith("FROM ")
)
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_PERMISSIONS_BLOCK);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_PERMISSIONS_RECIPIENT, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else
{
//default to "some classification of permission"
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
else if (significantTokensString.StartsWith("CREATE PROC")
|| significantTokensString.StartsWith("CREATE FUNC")
|| significantTokensString.StartsWith("CREATE TRIGGER ")
|| significantTokensString.StartsWith("CREATE VIEW ")
|| significantTokensString.StartsWith("ALTER PROC")
|| significantTokensString.StartsWith("ALTER FUNC")
|| significantTokensString.StartsWith("ALTER TRIGGER ")
|| significantTokensString.StartsWith("ALTER VIEW ")
)
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK, "");
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (_CursorDetector.IsMatch(significantTokensString))
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CURSOR_DECLARATION, "");
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK)
&& _TriggerConditionDetector.IsMatch(significantTokensString)
)
{
//horrible complicated forward-search, to avoid having to keep a different "Trigger Condition" state for Update, Insert and Delete statement-starting keywords
Match triggerConditions = _TriggerConditionDetector.Match(significantTokensString);
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_TRIGGER_CONDITION, "");
XmlElement triggerConditionType = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_COMPOUNDKEYWORD, "");
//first set the "trigger condition type": FOR, INSTEAD OF, AFTER
string triggerConditionTypeSimpleText = triggerConditions.Groups[1].Value;
triggerConditionType.SetAttribute(SqlXmlConstants.ANAME_SIMPLETEXT, triggerConditionTypeSimpleText);
int triggerConditionTypeNodeCount = triggerConditionTypeSimpleText.Split(new char[] { ' ' }).Length; //there's probably a better way of counting words...
AppendNodesWithMapping(sqlTree, tokenList.GetRangeByIndex(significantTokenPositions[0], significantTokenPositions[triggerConditionTypeNodeCount - 1]), SqlXmlConstants.ENAME_OTHERKEYWORD, triggerConditionType);
//then get the count of conditions (INSERT, UPDATE, DELETE) and add those too...
int triggerConditionNodeCount = triggerConditions.Groups[2].Value.Split(new char[] { ' ' }).Length - 2; //there's probably a better way of counting words...
AppendNodesWithMapping(sqlTree, tokenList.GetRangeByIndex(significantTokenPositions[triggerConditionTypeNodeCount - 1] + 1, significantTokenPositions[triggerConditionTypeNodeCount + triggerConditionNodeCount - 1]), SqlXmlConstants.ENAME_OTHERKEYWORD, sqlTree.CurrentContainer);
tokenID = significantTokenPositions[triggerConditionTypeNodeCount + triggerConditionNodeCount - 1];
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK);
}
else if (significantTokensString.StartsWith("FOR "))
{
sqlTree.EscapeAnyBetweenConditions();
sqlTree.EscapeAnySelectionTarget();
sqlTree.EscapeJoinCondition();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CURSOR_DECLARATION))
{
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_CURSOR_FOR_BLOCK, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
sqlTree.StartNewStatement();
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& sqlTree.PathNameMatches(2, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(3, SqlXmlConstants.ENAME_CURSOR_FOR_BLOCK)
)
{
sqlTree.MoveToAncestorContainer(4, SqlXmlConstants.ENAME_CURSOR_DECLARATION);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_CURSOR_FOR_OPTIONS, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else
{
//Assume FOR clause if we're at clause level
// (otherwise, eg in OPTIMIZE FOR UNKNOWN, this will just not do anything)
sqlTree.ConsiderStartingNewClause();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
else if (significantTokensString.StartsWith("CREATE ")
|| significantTokensString.StartsWith("ALTER ")
|| significantTokensString.StartsWith("DECLARE ")
)
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_DDL_OTHER_BLOCK, "");
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (significantTokensString.StartsWith("GRANT ")
|| significantTokensString.StartsWith("DENY ")
|| significantTokensString.StartsWith("REVOKE ")
)
{
if (significantTokensString.StartsWith("GRANT ")
&& sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_DDL_WITH_CLAUSE)
&& sqlTree.PathNameMatches(2, SqlXmlConstants.ENAME_PERMISSIONS_BLOCK)
&& sqlTree.GetFirstNonWhitespaceNonCommentChildElement(sqlTree.CurrentContainer) == null
)
{
//this MUST be a "WITH GRANT OPTION" option...
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_PERMISSIONS_BLOCK, token.Value, SqlXmlConstants.ENAME_PERMISSIONS_DETAIL);
}
}
else if (sqlTree.CurrentContainer.Name.Equals(SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK)
&& significantTokensString.StartsWith("RETURNS ")
)
{
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_DDL_RETURNS, ""));
}
else if (significantTokensString.StartsWith("AS "))
{
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK))
{
KeywordType nextKeywordType;
bool isDataTypeDefinition = false;
if (significantTokenPositions.Count > 1
&& KeywordList.TryGetValue(tokenList[significantTokenPositions[1]].Value, out nextKeywordType)
)
if (nextKeywordType == KeywordType.DataTypeKeyword)
isDataTypeDefinition = true;
if (isDataTypeDefinition)
{
//this is actually a data type declaration (redundant "AS"...), save as regular token.
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else
{
//this is the start of the object content definition
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_DDL_AS_BLOCK, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
sqlTree.StartNewStatement();
}
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_DDL_WITH_CLAUSE)
&& sqlTree.PathNameMatches(2, SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK)
)
{
sqlTree.MoveToAncestorContainer(2, SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_DDL_AS_BLOCK, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
sqlTree.StartNewStatement();
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CTE_ALIAS)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_CTE_WITH_CLAUSE)
)
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_CTE_WITH_CLAUSE);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_CTE_AS_BLOCK, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else
{
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
else if (significantTokensString.StartsWith("BEGIN DISTRIBUTED TRANSACTION ")
|| significantTokensString.StartsWith("BEGIN DISTRIBUTED TRAN ")
)
{
sqlTree.ConsiderStartingNewStatement();
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_BEGIN_TRANSACTION, ""), ref tokenID, significantTokenPositions, 3);
}
else if (significantTokensString.StartsWith("BEGIN TRANSACTION ")
|| significantTokensString.StartsWith("BEGIN TRAN ")
)
{
sqlTree.ConsiderStartingNewStatement();
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_BEGIN_TRANSACTION, ""), ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("SAVE TRANSACTION ")
|| significantTokensString.StartsWith("SAVE TRAN ")
)
{
sqlTree.ConsiderStartingNewStatement();
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SAVE_TRANSACTION, ""), ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("COMMIT TRANSACTION ")
|| significantTokensString.StartsWith("COMMIT TRAN ")
|| significantTokensString.StartsWith("COMMIT WORK ")
)
{
sqlTree.ConsiderStartingNewStatement();
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_COMMIT_TRANSACTION, ""), ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("COMMIT "))
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_COMMIT_TRANSACTION, token.Value));
}
else if (significantTokensString.StartsWith("ROLLBACK TRANSACTION ")
|| significantTokensString.StartsWith("ROLLBACK TRAN ")
|| significantTokensString.StartsWith("ROLLBACK WORK ")
)
{
sqlTree.ConsiderStartingNewStatement();
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_ROLLBACK_TRANSACTION, ""), ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("ROLLBACK "))
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_ROLLBACK_TRANSACTION, token.Value));
}
else if (significantTokensString.StartsWith("BEGIN TRY "))
{
sqlTree.ConsiderStartingNewStatement();
XmlElement newTryBlock = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_TRY_BLOCK, "");
XmlElement tryContainerOpen = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_OPEN, "", newTryBlock);
ProcessCompoundKeyword(tokenList, sqlTree, tryContainerOpen, ref tokenID, significantTokenPositions, 2);
XmlElement tryMultiContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_MULTISTATEMENT, "", newTryBlock);
sqlTree.StartNewStatement(tryMultiContainer);
}
else if (significantTokensString.StartsWith("BEGIN CATCH "))
{
sqlTree.ConsiderStartingNewStatement();
XmlElement newCatchBlock = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CATCH_BLOCK, "");
XmlElement catchContainerOpen = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_OPEN, "", newCatchBlock);
ProcessCompoundKeyword(tokenList, sqlTree, catchContainerOpen, ref tokenID, significantTokenPositions, 2);
XmlElement catchMultiContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_MULTISTATEMENT, "", newCatchBlock);
sqlTree.StartNewStatement(catchMultiContainer);
}
else if (significantTokensString.StartsWith("BEGIN "))
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_BEGIN_END_BLOCK, token.Value, SqlXmlConstants.ENAME_CONTAINER_MULTISTATEMENT);
sqlTree.StartNewStatement();
}
else if (significantTokensString.StartsWith("MERGE "))
{
//According to BOL, MERGE is a fully reserved keyword from compat 100 onwards, for the MERGE statement only.
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_MERGE_CLAUSE, token.Value, SqlXmlConstants.ENAME_MERGE_TARGET);
}
else if (significantTokensString.StartsWith("USING "))
{
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_MERGE_TARGET))
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_MERGE_CLAUSE);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_MERGE_USING, token.Value, SqlXmlConstants.ENAME_SELECTIONTARGET);
}
else
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHERNODE, token.Value);
}
else if (significantTokensString.StartsWith("ON "))
{
sqlTree.EscapeAnySelectionTarget();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_MERGE_USING))
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_MERGE_CLAUSE);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_MERGE_CONDITION, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else if (!sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK)
&& !sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_DDL_OTHER_BLOCK)
&& !sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_DDL_WITH_CLAUSE)
&& !sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_EXPRESSION_PARENS)
&& !ContentStartsWithKeyword(sqlTree.CurrentContainer, "SET")
)
{
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_JOIN_ON_SECTION, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else
{
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
else if (significantTokensString.StartsWith("CASE "))
{
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_CASE_STATEMENT, token.Value, SqlXmlConstants.ENAME_CASE_INPUT);
}
else if (significantTokensString.StartsWith("WHEN "))
{
sqlTree.EscapeMergeAction();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CASE_INPUT)
|| (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_CASE_THEN)
)
)
{
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CASE_INPUT))
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_CASE_STATEMENT);
else
sqlTree.MoveToAncestorContainer(3, SqlXmlConstants.ENAME_CASE_STATEMENT);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_CASE_WHEN, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else if ((sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_MERGE_CONDITION)
)
|| sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_MERGE_WHEN)
)
{
if (sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_MERGE_CONDITION))
sqlTree.MoveToAncestorContainer(2, SqlXmlConstants.ENAME_MERGE_CLAUSE);
else
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_MERGE_CLAUSE);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_MERGE_WHEN, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHERNODE, token.Value);
}
else if (significantTokensString.StartsWith("THEN "))
{
sqlTree.EscapeAnyBetweenConditions();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_CASE_WHEN)
)
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_CASE_WHEN);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_CASE_THEN, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_MERGE_WHEN)
)
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_MERGE_WHEN);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_MERGE_THEN, token.Value, SqlXmlConstants.ENAME_MERGE_ACTION);
sqlTree.StartNewStatement();
}
else
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHERNODE, token.Value);
}
else if (significantTokensString.StartsWith("OUTPUT "))
{
bool isSprocArgument = false;
//We're looking for sproc calls - they can't be nested inside anything else (as far as I know)
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& (ContentStartsWithKeyword(sqlTree.CurrentContainer, "EXEC")
|| ContentStartsWithKeyword(sqlTree.CurrentContainer, "EXECUTE")
|| ContentStartsWithKeyword(sqlTree.CurrentContainer, null)
)
)
{
isSprocArgument = true;
}
if (!isSprocArgument)
{
sqlTree.EscapeMergeAction();
sqlTree.ConsiderStartingNewClause();
}
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (significantTokensString.StartsWith("OPTION "))
{
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_DDL_WITH_CLAUSE)
)
{
//"OPTION" keyword here is NOT indicative of a new clause.
}
else
{
sqlTree.EscapeMergeAction();
sqlTree.ConsiderStartingNewClause();
}
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (significantTokensString.StartsWith("END TRY "))
{
sqlTree.EscapeAnySingleOrPartialStatementContainers();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& sqlTree.PathNameMatches(2, SqlXmlConstants.ENAME_CONTAINER_MULTISTATEMENT)
&& sqlTree.PathNameMatches(3, SqlXmlConstants.ENAME_TRY_BLOCK)
)
{
//clause.statement.multicontainer.try
XmlElement tryBlock = (XmlElement)sqlTree.CurrentContainer.ParentNode.ParentNode.ParentNode;
XmlElement tryContainerClose = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_CLOSE, "", tryBlock);
ProcessCompoundKeyword(tokenList, sqlTree, tryContainerClose, ref tokenID, significantTokenPositions, 2);
sqlTree.CurrentContainer = (XmlElement)tryBlock.ParentNode;
}
else
{
ProcessCompoundKeywordWithError(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
}
else if (significantTokensString.StartsWith("END CATCH "))
{
sqlTree.EscapeAnySingleOrPartialStatementContainers();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& sqlTree.PathNameMatches(2, SqlXmlConstants.ENAME_CONTAINER_MULTISTATEMENT)
&& sqlTree.PathNameMatches(3, SqlXmlConstants.ENAME_CATCH_BLOCK)
)
{
//clause.statement.multicontainer.catch
XmlElement catchBlock = (XmlElement)sqlTree.CurrentContainer.ParentNode.ParentNode.ParentNode;
XmlElement catchContainerClose = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_CLOSE, "", catchBlock);
ProcessCompoundKeyword(tokenList, sqlTree, catchContainerClose, ref tokenID, significantTokenPositions, 2);
sqlTree.CurrentContainer = (XmlElement)catchBlock.ParentNode;
}
else
{
ProcessCompoundKeywordWithError(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
}
else if (significantTokensString.StartsWith("END "))
{
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_CASE_THEN)
)
{
sqlTree.MoveToAncestorContainer(3, SqlXmlConstants.ENAME_CASE_STATEMENT);
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_CLOSE, ""));
sqlTree.MoveToAncestorContainer(1); //unnamed container
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_CASE_ELSE)
)
{
sqlTree.MoveToAncestorContainer(2, SqlXmlConstants.ENAME_CASE_STATEMENT);
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_CLOSE, ""));
sqlTree.MoveToAncestorContainer(1); //unnamed container
}
else
{
//Begin/End block handling
sqlTree.EscapeAnySingleOrPartialStatementContainers();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& sqlTree.PathNameMatches(2, SqlXmlConstants.ENAME_CONTAINER_MULTISTATEMENT)
&& sqlTree.PathNameMatches(3, SqlXmlConstants.ENAME_BEGIN_END_BLOCK)
)
{
XmlElement beginBlock = (XmlElement)sqlTree.CurrentContainer.ParentNode.ParentNode.ParentNode;
XmlElement beginContainerClose = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_CLOSE, "", beginBlock);
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, beginContainerClose);
sqlTree.CurrentContainer = (XmlElement)beginBlock.ParentNode;
}
else
{
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
}
else if (significantTokensString.StartsWith("GO "))
{
sqlTree.EscapeAnySingleOrPartialStatementContainers();
if ((tokenID == 0 || IsLineBreakingWhiteSpaceOrComment(tokenList[tokenID - 1]))
&& IsFollowedByLineBreakingWhiteSpaceOrSingleLineCommentOrEnd(tokenList, tokenID)
)
{
// we found a batch separator - were we supposed to?
if (sqlTree.FindValidBatchEnd())
{
XmlElement sqlRoot = sqlTree.DocumentElement;
XmlElement batchSeparator = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_BATCH_SEPARATOR, "", sqlRoot);
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, batchSeparator);
sqlTree.StartNewStatement(sqlRoot);
}
else
{
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
else
{
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
else if (significantTokensString.StartsWith("EXECUTE AS "))
{
bool executeAsInWithOptions = false;
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_DDL_WITH_CLAUSE)
&& (IsLatestTokenAComma(sqlTree)
|| !sqlTree.HasNonWhiteSpaceNonCommentContent(sqlTree.CurrentContainer)
)
)
executeAsInWithOptions = true;
if (!executeAsInWithOptions)
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
}
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("EXEC ")
|| significantTokensString.StartsWith("EXECUTE ")
)
{
bool execShouldntTryToStartNewStatement = false;
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& (ContentStartsWithKeyword(sqlTree.CurrentContainer, "INSERT")
|| ContentStartsWithKeyword(sqlTree.CurrentContainer, "INSERT INTO")
)
)
{
int existingClauseCount = sqlTree.CurrentContainer.SelectNodes(string.Format("../{0}", SqlXmlConstants.ENAME_SQL_CLAUSE)).Count;
if (existingClauseCount == 1)
execShouldntTryToStartNewStatement = true;
}
if (!execShouldntTryToStartNewStatement)
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (_JoinDetector.IsMatch(significantTokensString))
{
sqlTree.ConsiderStartingNewClause();
string joinText = _JoinDetector.Match(significantTokensString).Value;
int targetKeywordCount = joinText.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, targetKeywordCount);
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SELECTIONTARGET, "");
}
else if (significantTokensString.StartsWith("UNION ALL "))
{
sqlTree.ConsiderStartingNewClause();
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SET_OPERATOR_CLAUSE, ""), ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("UNION ")
|| significantTokensString.StartsWith("INTERSECT ")
|| significantTokensString.StartsWith("EXCEPT ")
)
{
sqlTree.ConsiderStartingNewClause();
XmlElement unionClause = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SET_OPERATOR_CLAUSE, "");
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, unionClause);
}
else if (significantTokensString.StartsWith("WHILE "))
{
sqlTree.ConsiderStartingNewStatement();
XmlElement newWhileLoop = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_WHILE_LOOP, "");
XmlElement whileContainerOpen = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_OPEN, "", newWhileLoop);
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, whileContainerOpen);
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_BOOLEAN_EXPRESSION, "", newWhileLoop);
}
else if (significantTokensString.StartsWith("IF "))
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_IF_STATEMENT, token.Value, SqlXmlConstants.ENAME_BOOLEAN_EXPRESSION);
}
else if (significantTokensString.StartsWith("ELSE "))
{
sqlTree.EscapeAnyBetweenConditions();
sqlTree.EscapeAnySelectionTarget();
sqlTree.EscapeJoinCondition();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_CASE_THEN)
)
{
sqlTree.MoveToAncestorContainer(3, SqlXmlConstants.ENAME_CASE_STATEMENT);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_CASE_ELSE, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else
{
sqlTree.EscapePartialStatementContainers();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& sqlTree.PathNameMatches(2, SqlXmlConstants.ENAME_CONTAINER_SINGLESTATEMENT)
)
{
//we need to pop up the single-statement containers stack to the next "if" that doesn't have an "else" (if any; else error).
// LOCAL SEARCH - we're not actually changing the "CurrentContainer" until we decide to start a statement.
XmlElement currentNode = (XmlElement)sqlTree.CurrentContainer.ParentNode.ParentNode;
bool stopSearching = false;
while (!stopSearching)
{
if (sqlTree.PathNameMatches(currentNode, 1, SqlXmlConstants.ENAME_IF_STATEMENT))
{
//if this is in an "If", then the "Else" must still be available - yay!
sqlTree.CurrentContainer = (XmlElement)currentNode.ParentNode;
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_ELSE_CLAUSE, token.Value, SqlXmlConstants.ENAME_CONTAINER_SINGLESTATEMENT);
sqlTree.StartNewStatement();
stopSearching = true;
}
else if (sqlTree.PathNameMatches(currentNode, 1, SqlXmlConstants.ENAME_ELSE_CLAUSE))
{
//If this is in an "Else", we should skip its parent "IF" altogether, and go to the next singlestatementcontainer candidate.
//singlestatementcontainer.else.if.clause.statement.NEWCANDIDATE
currentNode = (XmlElement)currentNode.ParentNode.ParentNode.ParentNode.ParentNode.ParentNode;
}
else if (sqlTree.PathNameMatches(currentNode, 1, SqlXmlConstants.ENAME_WHILE_LOOP))
{
//If this is in a "While", we should skip to the next singlestatementcontainer candidate.
//singlestatementcontainer.while.clause.statement.NEWCANDIDATE
currentNode = (XmlElement)currentNode.ParentNode.ParentNode.ParentNode.ParentNode;
}
else
{
//if this isn't a known single-statement container, then we're lost.
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
stopSearching = true;
}
}
}
else
{
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
}
else if (significantTokensString.StartsWith("INSERT INTO "))
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("NATIONAL CHARACTER VARYING "))
{
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 3);
}
else if (significantTokensString.StartsWith("NATIONAL CHAR VARYING "))
{
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 3);
}
else if (significantTokensString.StartsWith("BINARY VARYING "))
{
//TODO: Figure out how to handle "Compound Keyword Datatypes" so they are still correctly highlighted
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("CHAR VARYING "))
{
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("CHARACTER VARYING "))
{
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("DOUBLE PRECISION "))
{
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("NATIONAL CHARACTER "))
{
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("NATIONAL CHAR "))
{
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("NATIONAL TEXT "))
{
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("INSERT "))
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (significantTokensString.StartsWith("BULK INSERT "))
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
ProcessCompoundKeyword(tokenList, sqlTree, sqlTree.CurrentContainer, ref tokenID, significantTokenPositions, 2);
}
else if (significantTokensString.StartsWith("SELECT "))
{
if (sqlTree.NewStatementDue)
sqlTree.ConsiderStartingNewStatement();
bool selectShouldntTryToStartNewStatement = false;
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE))
{
XmlElement firstStatementClause = sqlTree.GetFirstNonWhitespaceNonCommentChildElement(sqlTree.CurrentContainer.ParentNode);
bool isPrecededByInsertStatement = false;
foreach (XmlElement clause in sqlTree.CurrentContainer.ParentNode.SelectNodes(SqlXmlConstants.ENAME_SQL_CLAUSE))
if (ContentStartsWithKeyword(clause, "INSERT"))
isPrecededByInsertStatement = true;
if (isPrecededByInsertStatement)
{
bool existingSelectClauseFound = false;
foreach (XmlElement clause in sqlTree.CurrentContainer.ParentNode.SelectNodes(SqlXmlConstants.ENAME_SQL_CLAUSE))
if (ContentStartsWithKeyword(clause, "SELECT"))
existingSelectClauseFound = true;
bool existingValuesClauseFound = false;
foreach (XmlElement clause in sqlTree.CurrentContainer.ParentNode.SelectNodes(SqlXmlConstants.ENAME_SQL_CLAUSE))
if (ContentStartsWithKeyword(clause, "VALUES"))
existingValuesClauseFound = true;
bool existingExecClauseFound = false;
foreach (XmlElement clause in sqlTree.CurrentContainer.ParentNode.SelectNodes(SqlXmlConstants.ENAME_SQL_CLAUSE))
if (ContentStartsWithKeyword(clause, "EXEC")
|| ContentStartsWithKeyword(clause, "EXECUTE"))
existingExecClauseFound = true;
if (!existingSelectClauseFound
&& !existingValuesClauseFound
&& !existingExecClauseFound
)
selectShouldntTryToStartNewStatement = true;
}
XmlElement firstEntryOfThisClause = sqlTree.GetFirstNonWhitespaceNonCommentChildElement(sqlTree.CurrentContainer);
if (firstEntryOfThisClause != null && firstEntryOfThisClause.Name.Equals(SqlXmlConstants.ENAME_SET_OPERATOR_CLAUSE))
selectShouldntTryToStartNewStatement = true;
}
if (!selectShouldntTryToStartNewStatement)
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (significantTokensString.StartsWith("UPDATE "))
{
if (sqlTree.NewStatementDue)
sqlTree.ConsiderStartingNewStatement();
if (!(sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_CURSOR_FOR_OPTIONS)
)
)
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
}
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (significantTokensString.StartsWith("TO "))
{
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_PERMISSIONS_TARGET)
)
{
sqlTree.MoveToAncestorContainer(2, SqlXmlConstants.ENAME_PERMISSIONS_BLOCK);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_PERMISSIONS_RECIPIENT, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else
{
//I don't currently know whether there is any other place where "TO" can be used in T-SQL...
// TODO: look into that.
// -> for now, we'll just save as a random keyword without raising an error.
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
else if (significantTokensString.StartsWith("FROM "))
{
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_PERMISSIONS_TARGET)
)
{
sqlTree.MoveToAncestorContainer(2, SqlXmlConstants.ENAME_PERMISSIONS_BLOCK);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_PERMISSIONS_RECIPIENT, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else
{
sqlTree.ConsiderStartingNewClause();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SELECTIONTARGET, "");
}
}
else if (significantTokensString.StartsWith("CASCADE ")
&& sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_PERMISSIONS_RECIPIENT)
)
{
sqlTree.MoveToAncestorContainer(2, SqlXmlConstants.ENAME_PERMISSIONS_BLOCK);
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT, "", sqlTree.SaveNewElement(SqlXmlConstants.ENAME_DDL_WITH_CLAUSE, ""));
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (significantTokensString.StartsWith("SET "))
{
XmlElement firstNonCommentSibling2 = sqlTree.GetFirstNonWhitespaceNonCommentChildElement(sqlTree.CurrentContainer);
if (!(
firstNonCommentSibling2 != null
&& firstNonCommentSibling2.Name.Equals(SqlXmlConstants.ENAME_OTHERKEYWORD)
&& firstNonCommentSibling2.InnerText.ToUpperInvariant().StartsWith("UPDATE")
)
)
sqlTree.ConsiderStartingNewStatement();
sqlTree.ConsiderStartingNewClause();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else if (significantTokensString.StartsWith("BETWEEN "))
{
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_BETWEEN_CONDITION, "");
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_OPEN, ""));
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_BETWEEN_LOWERBOUND, "");
}
else if (significantTokensString.StartsWith("AND "))
{
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_BETWEEN_LOWERBOUND))
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_BETWEEN_CONDITION);
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_CLOSE, ""));
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_BETWEEN_UPPERBOUND, "");
}
else
{
sqlTree.EscapeAnyBetweenConditions();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_AND_OPERATOR, ""));
}
}
else if (significantTokensString.StartsWith("OR "))
{
sqlTree.EscapeAnyBetweenConditions();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OR_OPERATOR, ""));
}
else if (significantTokensString.StartsWith("WITH "))
{
if (sqlTree.NewStatementDue)
sqlTree.ConsiderStartingNewStatement();
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& !sqlTree.HasNonWhiteSpaceNonCommentContent(sqlTree.CurrentContainer)
)
{
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CTE_WITH_CLAUSE, "");
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value, sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CONTAINER_OPEN, ""));
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CTE_ALIAS, "");
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_PERMISSIONS_RECIPIENT)
)
{
sqlTree.MoveToAncestorContainer(2, SqlXmlConstants.ENAME_PERMISSIONS_BLOCK);
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_DDL_WITH_CLAUSE, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_DDL_PROCEDURAL_BLOCK)
|| sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_DDL_OTHER_BLOCK)
)
{
sqlTree.StartNewContainer(SqlXmlConstants.ENAME_DDL_WITH_CLAUSE, token.Value, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT);
}
else if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SELECTIONTARGET))
{
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
else
{
sqlTree.ConsiderStartingNewClause();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_OTHERKEYWORD, token.Value);
}
}
else if (tokenList.Count > tokenID + 1
&& tokenList[tokenID + 1].Type == SqlTokenType.Colon
&& !(tokenList.Count > tokenID + 2
&& tokenList[tokenID + 2].Type == SqlTokenType.Colon
)
)
{
sqlTree.ConsiderStartingNewStatement();
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_LABEL, token.Value + tokenList[tokenID + 1].Value);
tokenID++;
}
else
{
//miscellaneous single-word tokens, which may or may not be statement starters and/or clause starters
//check for statements starting...
if (IsStatementStarter(token) || sqlTree.NewStatementDue)
{
sqlTree.ConsiderStartingNewStatement();
}
//check for statements starting...
if (IsClauseStarter(token))
{
sqlTree.ConsiderStartingNewClause();
}
string newNodeName = SqlXmlConstants.ENAME_OTHERNODE;
KeywordType matchedKeywordType;
if (KeywordList.TryGetValue(token.Value, out matchedKeywordType))
{
switch (matchedKeywordType)
{
case KeywordType.OperatorKeyword:
newNodeName = SqlXmlConstants.ENAME_ALPHAOPERATOR;
break;
case KeywordType.FunctionKeyword:
newNodeName = SqlXmlConstants.ENAME_FUNCTION_KEYWORD;
break;
case KeywordType.DataTypeKeyword:
newNodeName = SqlXmlConstants.ENAME_DATATYPE_KEYWORD;
break;
case KeywordType.OtherKeyword:
sqlTree.EscapeAnySelectionTarget();
newNodeName = SqlXmlConstants.ENAME_OTHERKEYWORD;
break;
default:
throw new Exception("Unrecognized Keyword Type!");
}
}
sqlTree.SaveNewElement(newNodeName, token.Value);
}
break;
case SqlTokenType.Semicolon:
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SEMICOLON, token.Value);
sqlTree.NewStatementDue = true;
break;
case SqlTokenType.Colon:
if (tokenList.Count > tokenID + 1
&& tokenList[tokenID + 1].Type == SqlTokenType.Colon
)
{
sqlTree.SaveNewElement(SqlXmlConstants.ENAME_SCOPERESOLUTIONOPERATOR, token.Value + tokenList[tokenID + 1].Value);
tokenID++;
}
else
{
sqlTree.SaveNewElementWithError(SqlXmlConstants.ENAME_OTHEROPERATOR, token.Value);
}
break;
case SqlTokenType.Comma:
bool isCTESplitter = (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_CONTAINER_GENERALCONTENT)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_CTE_WITH_CLAUSE)
);
sqlTree.SaveNewElement(GetEquivalentSqlNodeName(token.Type), token.Value);
if (isCTESplitter)
{
sqlTree.MoveToAncestorContainer(1, SqlXmlConstants.ENAME_CTE_WITH_CLAUSE);
sqlTree.CurrentContainer = sqlTree.SaveNewElement(SqlXmlConstants.ENAME_CTE_ALIAS, "");
}
break;
case SqlTokenType.MultiLineComment:
case SqlTokenType.SingleLineComment:
case SqlTokenType.WhiteSpace:
//create in statement rather than clause if there are no siblings yet
if (sqlTree.PathNameMatches(0, SqlXmlConstants.ENAME_SQL_CLAUSE)
&& sqlTree.PathNameMatches(1, SqlXmlConstants.ENAME_SQL_STATEMENT)
&& sqlTree.CurrentContainer.SelectSingleNode("*") == null
)
sqlTree.SaveNewElementAsPriorSibling(GetEquivalentSqlNodeName(token.Type), token.Value, sqlTree.CurrentContainer);
else
sqlTree.SaveNewElement(GetEquivalentSqlNodeName(token.Type), token.Value);
break;
case SqlTokenType.BracketQuotedName:
case SqlTokenType.Asterisk:
case SqlTokenType.Period:
case SqlTokenType.NationalString:
case SqlTokenType.String:
case SqlTokenType.QuotedString:
case SqlTokenType.OtherOperator:
case SqlTokenType.Number:
case SqlTokenType.BinaryValue:
case SqlTokenType.MonetaryValue:
case SqlTokenType.PseudoName:
sqlTree.SaveNewElement(GetEquivalentSqlNodeName(token.Type), token.Value);
break;
default:
throw new Exception("Unrecognized element encountered!");
}
tokenID++;
}
if (!sqlTree.FindValidBatchEnd())
sqlTree.ErrorFound = true;
return sqlTree;
}
private void ProcessFile(string fileName, Task convertPatternsTask, WorkflowResult workflowResult, CancellationToken cancellationToken = default(CancellationToken))
{
ParseTree parseTree = null;
try
{
Logger.LogInfo(new MessageEventArgs(MessageType.ProcessingStarted, fileName));
parseTree = ReadAndParse(fileName, workflowResult);
if (parseTree != null)
{
workflowResult.AddResultEntity(parseTree);
if (Stage >= Stage.Convert)
{
var stopwatch = Stopwatch.StartNew();
IParseTreeToUstConverter converter = ParserConverterSets[parseTree.SourceLanguage].Converter;
Ust ust = converter.Convert(parseTree);
stopwatch.Stop();
Logger.LogInfo($"File {fileName} has been converted (Elapsed: {stopwatch.Elapsed}).");
workflowResult.AddConvertTime(stopwatch.ElapsedTicks);
workflowResult.AddResultEntity(ust, true);
cancellationToken.ThrowIfCancellationRequested();
if (Stage >= Stage.Preprocess)
{
if (IsIncludePreprocessing)
{
var ustPreprocessor = new UstPreprocessor()
{
Logger = logger
};
stopwatch.Restart();
ust = ustPreprocessor.Preprocess(ust);
stopwatch.Stop();
Logger.LogInfo($"Ust of file {fileName} has been preprocessed (Elapsed: {stopwatch.Elapsed}).");
workflowResult.AddPreprocessTime(stopwatch.ElapsedTicks);
workflowResult.AddResultEntity(ust, false);
cancellationToken.ThrowIfCancellationRequested();
}
if (Stage >= Stage.Match)
{
if (!convertPatternsTask.IsCompleted)
{
convertPatternsTask.Wait();
}
stopwatch.Restart();
IEnumerable <MatchingResult> matchingResults = UstPatternMatcher.Match(ust);
stopwatch.Stop();
Logger.LogInfo($"File {fileName} has been matched with patterns (Elapsed: {stopwatch.Elapsed}).");
workflowResult.AddMatchTime(stopwatch.ElapsedTicks);
workflowResult.AddResultEntity(matchingResults);
cancellationToken.ThrowIfCancellationRequested();
}
}
}
}
}
catch (OperationCanceledException)
{
}
catch (Exception ex)
{
Logger.LogError(ex);
}
finally
{
workflowResult.AddProcessedFilesCount(1);
double progress = workflowResult.TotalFilesCount == 0
? 1
: (double)workflowResult.TotalProcessedFilesCount / workflowResult.TotalFilesCount;
Logger.LogInfo(new ProgressEventArgs(progress, fileName));
Logger.LogInfo(new MessageEventArgs(MessageType.ProcessingCompleted, fileName));
if (parseTree == null)
{
Logger.LogInfo(new MessageEventArgs(MessageType.ProcessingIgnored, fileName));
}
cancellationToken.ThrowIfCancellationRequested();
}
}
public JavaPackage?TryLoad(string uri, out ParseTree parseTree)
{
return(TryParse(File.ReadAllText(uri), uri, out parseTree));
}
private void btnCompilar_Click(object sender, EventArgs e)
{
try
{
limpiar();
if (textoCodigo.TextLength == 0)
{
MessageBox.Show("No se puede compilar esta vacío", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (load == true)
{
AnalizeCode();
}
bool resultado = Sintactico.analizar(textoCodigo.Text);
dtgSemantico.Rows.Clear();
ParseTree arbol = Sintactico.retornoArbol(textoCodigo.Text);
RecorridoParseTree recorrido = new RecorridoParseTree(arbol);
var nodos = recorrido.Recorrer();
int con = 0;
int menor = 0, mayor = 0;
foreach (var item in nodos)
{
#region Imprime los valores del arbol
//MessageBox.Show("#" + con.ToString()
//+ " *ITEM: " + item.ToString()
//+ " *associativity: " + item.Associativity.ToString()
//+ " *Span End position: " + item.Span.EndPosition
//+ " *Span Length: " + item.Span.Length
//+ " *Span : Location" + item.Span.Location
//+ " *Term: " + item.Term.ToString()
//+ " *TermErrorAlias: " + item.Term.ErrorAlias
//+ " *itemtermName: " + item.Term.Name);
#endregion
#region Agregado de variables declaradas
if (item.Term.Name.Equals("Declaracion"))
{
String tipodedato = null, variable = null, valor = null;
menor = item.Span.EndPosition - item.Span.Length;
mayor = item.Span.EndPosition;
int totalDeclaradas = 0, priTLD = 3;
foreach (var item1 in nodos)
{
if ((item1.Term.Name.Equals("tipodedato") ||
item1.Term.Name.Equals("id") ||
item1.Term.Name.Equals("numero") ||
item1.Term.Name.Equals("numero-decimal") ||
item1.Term.Name.Equals("cualquier") ||
item1.Term.Name.Equals("cualquiercar") ||
item1.Term.Name.Equals("<>in")) &&
(item1.Span.EndPosition <= mayor &&
(item1.Span.EndPosition - item1.Span.Length) >= menor))
{
if (item1.Term.Name.Equals("tipodedato"))
{
tipodedato = item1.ToString().Split(' ').ElementAt(0);
}
if (item1.Term.Name.Equals("id"))
{
variable = item1.ToString().Split(' ').ElementAt(0);
}
if (item1.Term.Name.Equals("numero") ||
item1.Term.Name.Equals("numero-decimal") ||
item1.Term.Name.Equals("cualquier") ||
item1.Term.Name.Equals("cualquiercar") ||
item1.Term.Name.Equals("tipodedato"))
{
if (item1.Term.Name.Equals("tipodedato"))
{
valor = null;
}
else if (item1.Term.Name.Equals("cualquier"))
{
valor = item1.ToString().Split('"').ElementAt(1);
}
else
{
valor = item1.ToString().Split(' ').ElementAt(0);
}
}
if (item1.Term.Name.Equals("<>in") && tipodedato.Equals("entero"))
{
int ejem = 0;
valor = Interaction.InputBox("Leer por teclado", "Ingrese el valor de \"" + variable + "\" que es de tipo " + tipodedato, "0");
if (!int.TryParse(valor, out ejem))
{
tbConsola.SelectionColor = Color.Red;
tbConsola.Text += "Error la variable es de tipo entero, no puede asignar un valor distinto a este";
MessageBox.Show("Error de compilación", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
else if (item1.Term.Name.Equals("<>in") && tipodedato.Equals("doble"))
{
double ejem = 0;
valor = Interaction.InputBox("Leer por teclado", "Ingrese el valor de \"" + variable + "\" que es de tipo " + tipodedato, "0");
if (!double.TryParse(valor, out ejem))
{
tbConsola.SelectionColor = Color.Red;
tbConsola.Text += "Error la variable es de tipo doble, no puede asignar un valor distinto a este";
MessageBox.Show("Error de compilación", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
else if (item1.Term.Name.Equals("<>in") && tipodedato.Equals("flotante"))
{
float ejem = 0;
valor = Interaction.InputBox("Leer por teclado", "Ingrese el valor de \"" + variable + "\" que es de tipo " + tipodedato, "0");
if (!float.TryParse(valor, out ejem))
{
tbConsola.SelectionColor = Color.Red;
tbConsola.Text += "Error la variable es de tipo flotante, no puede asignar un valor distinto a este";
MessageBox.Show("Error de compilación", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
else if (item1.Term.Name.Equals("<>in") && tipodedato.Equals("cadena"))
{
valor = Interaction.InputBox("Leer por teclado", "Ingrese el valor de \"" + variable + "\" que es de tipo " + tipodedato, "");
}
totalDeclaradas++;
if (totalDeclaradas == priTLD)
{
#region Detecta si ya hay una variable declarada
Boolean declarada = false;
foreach (var itemTablaSimbolos in ts)
{
if (variable.Equals(itemTablaSimbolos.variable) && itemTablaSimbolos.tipo.Equals("Declaracion"))
{
declarada = true;
break;
}
else
{
declarada = false;
}
}
if (declarada == true)
{
resultado = false;
tbConsola.SelectionStart = tbConsola.TextLength;
tbConsola.SelectionLength = 0;
tbConsola.SelectionColor = Color.Red;
tbConsola.Text += ("Error está declarando dos o mas veces la variable \"" + variable + "\", ya se encuentra declarada") + Environment.NewLine;
}
else
{
ts.Add(new TablaSimbolos("Declaracion", tipodedato, variable, valor));
}
priTLD = 2;
totalDeclaradas = 0;
#endregion
}
}
}
#region Si se declara una variable sin valor
if (totalDeclaradas == 2)
{
#region Detecta si ya hay una variable declarada
Boolean declarada = false;
foreach (var itemTablaSimbolos in ts)
{
if (variable.Equals(itemTablaSimbolos.variable) && itemTablaSimbolos.tipo.Equals("Declaracion"))
{
declarada = true;
break;
}
else
{
declarada = false;
}
}
if (declarada == true)
{
resultado = false;
tbConsola.SelectionStart = tbConsola.TextLength;
tbConsola.SelectionLength = 0;
tbConsola.SelectionColor = Color.Red;
tbConsola.Text += ("Error está declarando dos o mas veces la variable \"" + variable + "\", ya se encuentra declarada") + Environment.NewLine;
}
else
{
ts.Add(new TablaSimbolos("Declaracion", tipodedato, variable, valor));
}
#endregion
}
#endregion
}
#endregion
#region Detecta si no se ha declarado alguna variable
if (item.ToString().Contains("(id)"))
{
String var = item.ToString().Split(' ').ElementAt(0);
Boolean encontrada = false;
foreach (var item1 in ts)
{
if (var.Equals(item1.variable) && item1.tipo.Equals("Declaracion"))
{
encontrada = true;
break;
}
else
{
encontrada = false;
}
}
if (encontrada == true)
{
if (resultado == true)
{
resultado = true;
}
else
{
resultado = false;
}
}
else
{
resultado = false;
tbConsola.SelectionColor = Color.Red;
tbConsola.Text += ("No se ha declarado la variable: " + var + " en la linea: " + item.Span.Location) + Environment.NewLine;
}
}
#endregion
}
#region Error semantico no se pueden declarar variables que son palabras reservadas
foreach (var item in nodos)
{
if (item.ToString().Contains("(id)"))
{
String[] var = item.ToString().Split(' ');
foreach (var item1 in ts)
{
if (var[0].Equals(item1.variable) && item1.tipo.Equals("Reservada"))
{
tbConsola.SelectionColor = Color.Red;
tbConsola.Text += ("Error no puede utilizar \"" + var[0] + "\" es una palabra reservada en la linea: " + item.Span.Location) + Environment.NewLine;
resultado = false;
}
}
}
}
#endregion
#region Añade las variables declaradas al DataGridView desde la lista
foreach (var item in ts)
{
dtgSemantico.Rows.Add(item.tipo, item.tipoDato, item.variable, item.valor);
}
#endregion
#region Ejecución asignaciones, operaciones e impresiones
if (resultado)
{
#region Asigna valores a las variables previamente declaradas
int mayorope = 0, menorope = 0;
String cadenaOperacion = null, recorridoope = null, variableasignacion = null, tipoDeclaracion = null;
Boolean tipoIgual;
int vueltas = 0;
foreach (var item in nodos)
{
con++;
#region Asigna valores a las variables con valor numérico
if (item.Term.Name.Equals("asignacion"))
{
int primerif = 0;
menor = item.Span.EndPosition - item.Span.Length;
mayor = item.Span.EndPosition;
String tipoVariableAsignacion = null, tipoOtrasId = null, otrasId = null;
foreach (var itemTodo in nodos)
{
if (itemTodo.Span.EndPosition <= mayor &&
itemTodo.Span.EndPosition - itemTodo.Span.Length >= menor)
{
if (itemTodo.Term.Name.Equals("id") ||
itemTodo.Term.Name.Equals("numero") ||
itemTodo.Term.Name.Equals("numero-decimal") ||
itemTodo.Term.Name.Equals("+") ||
itemTodo.Term.Name.Equals("-") ||
itemTodo.Term.Name.Equals("*") ||
itemTodo.Term.Name.Equals("/") ||
itemTodo.Term.Name.Equals("^") ||
itemTodo.Term.Name.Equals("√") ||
itemTodo.Term.Name.Equals("(") ||
itemTodo.Term.Name.Equals(")"))
{
if (primerif != 0)
{
otrasId = itemTodo.ToString().Split(' ').ElementAt(0);
cadenaOperacion += otrasId;
if (itemTodo.Term.Name.Equals("id"))
{
foreach (DataGridViewRow variablesId in dtgSemantico.Rows)
{
if (otrasId.Equals(variablesId.Cells["Variable"].Value))
{
tipoOtrasId = variablesId.Cells["TipoDeDato"].Value.ToString();
if (!tipoVariableAsignacion.Equals(tipoOtrasId))
{
tbConsola.Text += "Error en las asignaciones los tipo de dato no pueden ser distintos";
MessageBox.Show("Error de compilación", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
}
}
}
else
{
variableasignacion = itemTodo.ToString().Split(' ').ElementAt(0);
foreach (DataGridViewRow variableAsign in dtgSemantico.Rows)
{
if (variableasignacion.Equals(variableAsign.Cells["Variable"].Value))
{
tipoVariableAsignacion = variableAsign.Cells["TipoDeDato"].Value.ToString();
}
}
}
primerif++;
}
}
}
String car, car2;
//MessageBox.Show(cadenaOperacion);
foreach (DataGridViewRow itemOpe in dtgSemantico.Rows)
{
car = Convert.ToString(itemOpe.Cells["Variable"].Value);
car2 = Convert.ToString(itemOpe.Cells["Valor"].Value);
if (car != "")
{
cadenaOperacion = cadenaOperacion.Replace(car, car2);
}
}
ParseTreeNode resultadoOpe = Sintactico.operaciones(cadenaOperacion);
recorridoope = RecorridoOperacion.resolverOperacion(resultadoOpe);
foreach (DataGridViewRow itemTablaSimbolos in dtgSemantico.Rows)
{
if (variableasignacion.Equals(itemTablaSimbolos.Cells["Variable"].Value) &&
itemTablaSimbolos.Cells["Tipo"].Value.Equals("Declaracion"))
{
itemTablaSimbolos.Cells["Valor"].Value = recorridoope;
}
}
cadenaOperacion = null;
}
#endregion
#region Asigna valores a las variables con cualquier tipo de valor
else if (item.Term.Name.Equals("asignacionCadena"))
{
String valor = null;
menor = item.Span.EndPosition - item.Span.Length;
mayor = item.Span.EndPosition;
bool entro = false;
foreach (var item1 in nodos)
{
if (item1.Span.EndPosition <= mayor &&
item1.Span.EndPosition - item1.Span.Length >= menor)
{
if (item1.Term.Name.Equals("id") && entro == false)
{
variableasignacion = item1.ToString().Split(' ').ElementAt(0);
}
if (item1.Term.Name.Equals("="))
{
entro = true;
}
if (item1.Term.Name.Equals("cualquier") && entro == true)
{
valor += item1.ToString().Split('"').ElementAt(1);
}
if (item1.Term.Name.Equals("id") && entro == true)
{
foreach (DataGridViewRow valorId in dtgSemantico.Rows)
{
if (item1.ToString().Split(' ').ElementAt(0).Equals(valorId.Cells["Variable"].Value) &&
valorId.Cells["Tipo"].Value.Equals("Declaracion") &&
valorId.Cells["TipoDeDato"].Value.Equals("cadena"))
{
valor += valorId.Cells["Valor"].Value;
}
else if ((item1.ToString().Split(' ').ElementAt(0).Equals(valorId.Cells["Variable"].Value) &&
valorId.Cells["Tipo"].Value.Equals("Declaracion") &&
!valorId.Cells["TipoDeDato"].Value.Equals("cadena")))
{
resultado = false;
tbConsola.SelectionColor = Color.Red;
tbConsola.Text = "Error no se puede concatenar un entero con una cadena";
MessageBox.Show("Error de compilación", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
}
}
}
foreach (DataGridViewRow itemTablaSimbolos in dtgSemantico.Rows)
{
if (variableasignacion.Equals(itemTablaSimbolos.Cells["Variable"].Value) &&
itemTablaSimbolos.Cells["Tipo"].Value.Equals("Declaracion"))
{
itemTablaSimbolos.Cells["Valor"].Value = valor;
}
}
}
#endregion
}
#endregion
#region Imprime valores de variables, impresiones complejas, numeros etc.
foreach (var item in nodos)
{
#region Imprime valores individuales
if (item.Term.Name.Equals("impresion"))
{
menor = item.Span.EndPosition - item.Span.Length;
mayor = item.Span.EndPosition;
foreach (var item1 in nodos)
{
if ((item1.Term.Name.Equals("id")) &&
(item1.Span.EndPosition <= mayor &&
(item1.Span.EndPosition - item1.Span.Length) >= menor))
{
foreach (DataGridViewRow itemTablaSimbolos in dtgSemantico.Rows)
{
if (item1.ToString().Split(' ').ElementAt(0).Equals(itemTablaSimbolos.Cells["Variable"].Value))
{
if (itemTablaSimbolos.Cells["Valor"].Value == null)
{
tbConsola.Text += (itemTablaSimbolos.Cells["Variable"].Value + " Variable sin valor asignado") + Environment.NewLine;
}
else
{
tbConsola.Text += (itemTablaSimbolos.Cells["Valor"].Value.ToString() + Environment.NewLine);
}
}
}
}
else if ((item1.Term.Name.Equals("cualquier")) &&
(item1.Span.EndPosition <= mayor &&
(item1.Span.EndPosition - item1.Span.Length) >= menor))
{
tbConsola.Text += (item1.ToString().Split('"').ElementAt(1)) + Environment.NewLine;
}
else if ((item1.Term.Name.Equals("numero") || (item1.Term.Name.Equals("numero-decimal"))) &&
(item1.Span.EndPosition <= mayor &&
(item1.Span.EndPosition - item1.Span.Length) >= menor))
{
tbConsola.Text += (item1.ToString().Split(' ').ElementAt(0)) + Environment.NewLine;
}
}
}
#endregion
#region Imprime valores Complejos
if (item.Term.Name.Equals("impresionCompleja"))
{
menor = item.Span.EndPosition - item.Span.Length;
mayor = item.Span.EndPosition;
foreach (var item1 in nodos)
{
if ((item1.Term.Name.Equals("cualquier")) &&
(item1.Span.EndPosition <= mayor &&
(item1.Span.EndPosition - item1.Span.Length) >= menor))
{
tbConsola.Text += (item1.ToString().Split('"').ElementAt(1));
}
if ((item1.Term.Name.Equals("id")) &&
(item1.Span.EndPosition <= mayor &&
(item1.Span.EndPosition - item1.Span.Length) >= menor))
{
foreach (DataGridViewRow itemTablaSimbolos in dtgSemantico.Rows)
{
if (item1.ToString().Split(' ').ElementAt(0).Equals(itemTablaSimbolos.Cells["Variable"].Value))
{
if (itemTablaSimbolos.Cells["Valor"].Value == null)
{
tbConsola.Text += (itemTablaSimbolos.Cells["Variable"].Value + " Variable sin valor asignado");
}
else
{
tbConsola.Text += (itemTablaSimbolos.Cells["Valor"].Value.ToString());
}
}
}
}
else if ((item1.Term.Name.Equals("numero") || (item1.Term.Name.Equals("numero-decimal"))) &&
(item1.Span.EndPosition <= mayor &&
(item1.Span.EndPosition - item1.Span.Length) >= menor))
{
tbConsola.Text += (item1.ToString().Split(' ').ElementAt(0)) + Environment.NewLine;
}
}
tbConsola.Text += Environment.NewLine;
}
#endregion
#endregion
if (item.Term.Name.Equals("condicional"))
{
menor = item.Span.EndPosition - item.Span.Length;
mayor = item.Span.EndPosition;
foreach (var item1 in nodos)
{
if ((item1.Span.EndPosition <= mayor &&
(item1.Span.EndPosition - item1.Span.Length) >= menor))
{
//Si quiero hacer el if, aquí está la magia
nodos.Remove(item1);
}
}
}
}
tbConsola.Text += ("Compilación correcta") + Environment.NewLine;
}
else
{
tbConsola.SelectionColor = Color.Red;
MessageBox.Show("Error de compilación", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
ts.Clear();
LlenadoTablaSimbolos();
#endregion
}
catch (NullReferenceException ex)
{
MessageBox.Show("Excepción " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void PreProcess(ParseTree tree)
{
ParseNode rootNode = tree.Nodes[0];
PreProcessLocks(rootNode);
PreProcessStatements(rootNode);
}
public object GetValue(ParseTree tree, TokenType type, int index)
{
return(GetValue(tree, type, ref index));
}
public ParseTree Parse(string input)
{
tree = new ParseTree();
return(Parse(input, tree));
}
private void txtSource_TextChanged(object sender, EventArgs e) {
_parseTree = null; //force it to recompile on run
}
public void ParseTreeExtraLeftBracketTwoTest()
{
var tree = new ParseTree("( * ( + 1 ( 2 ) 2 )");
tree.Result();
}
/*
* IDENTIFIER Params SEMICOLON
* or
* IDENTIFIER Params Block
* * SEMICOLON after Block will be allowed
* returns MoccaSuite::Something
*/
public virtual object EvalStatement(ParseTree tree, params object[] paramlist)
{
string identifier = (string)this.GetValue(tree, TokenType.IDENTIFIER, 0);
List <object> param = (List <object>) this.GetValue(tree, TokenType.Params, 0);
List <MoccaSuite> block = null;
if (this.GetValue(tree, TokenType.Block, 0) != null)
{
block = (List <MoccaSuite>) this.GetValue(tree, TokenType.Block, 0);
}
switch (identifier)
{
case "if":
MoccaLogic a = new MoccaLogic();
a.keyword = "if";
if (param[0].ToString().Equals("true"))
{
a.expression = new MoccaExpression("True");
}
else if (param[0].ToString().Equals("false"))
{
a.expression = new MoccaExpression("False");
}
else
{
a.expression = (MoccaExpression)param[0];
}
a.cmd_list = block;
return(a);
case "elif":
MoccaLogic b = new MoccaLogic();
b.keyword = "elif";
if (param[0].ToString().Equals("true"))
{
b.expression = new MoccaExpression("True");
}
else if (param[0].ToString().Equals("false"))
{
b.expression = new MoccaExpression("False");
}
else
{
b.expression = (MoccaExpression)param[0];
}
b.cmd_list = block;
return(b);
case "else":
MoccaLogic c = new MoccaLogic();
c.keyword = "else";
c.cmd_list = block;
return(c);
case "while":
MoccaWhile d = new MoccaWhile();
if (param[0].ToString().Equals("true"))
{
d.expression = new MoccaExpression("True");
}
else if (param[0].ToString().Equals("false"))
{
d.expression = new MoccaExpression("False");
}
else
{
d.expression = (MoccaExpression)param[0];
}
d.cmd_list = block;
return(d);
case "for":
MoccaFor e = new MoccaFor();
e.iter = param[0];
e.cmd_list = block;
return(e);
case "event":
if (param.Count == 1)
{
return(new MoccaEvent(MoccaEvent.recognizeType(param[0].ToString()), null));
}
else
{
return(new MoccaEvent(MoccaEvent.recognizeType(param[0].ToString()), param[1].ToString()));
}
default:
MoccaCommand f = new MoccaCommand(identifier, param);
return(f);
}
}
protected override void TranslateStructInstance(List<string> output, ParseTree.StructInstance structInstance)
{
output.Add("new ");
output.Add(structInstance.NameToken.Value);
output.Add("(");
for (int i = 0; i < structInstance.Args.Length; ++i)
{
if (i > 0) output.Add(", ");
this.TranslateExpression(output, structInstance.Args[i]);
}
output.Add(")");
}
void takeItem(ParseTree tokens)
{
Player player = GameObject.GetComponent <Player>("player");
Room currentLocation = player.PlayerLocation;
if (LocationKey != player.LocationKey)
{
if (LocationKey == "inventory")
{
GameController.InputResponse.AppendFormat($"You already have the item {Name}.\n");
return;
}
//if the item is inside an open container at the players current location
foreach (StoryItem item in currentLocation.RoomItems)
{
if (item is Container && this.LocationKey == item.KeyValue && (item as Container).IsOpen)
{
Container chest = (Container)item;
if (player.BackPack.ItemCount < player.BackPack.Slots)
{
chest.RemoveItem(this);
LocationKey = "inventory";
GameController.InputResponse.AppendFormat($"{Name} taken.\n");
player.BackPack.ItemCount += 1;
}
else
{
GameController.InputResponse.AppendFormat($"You don't have any space for {Name} in your inventory! Try dropping something you don't need.\n");
}
return;
}
}
GameController.InputResponse.AppendFormat($"There is no {Name} here to take.\n");
return;
}
if (IsPortable)
{
if (player.BackPack.ItemCount < player.BackPack.Slots)
{
LocationKey = "inventory";
GameController.InputResponse.AppendFormat($"{Name} taken.\n");
player.BackPack.ItemCount += 1;
}
else
{
GameController.InputResponse.AppendFormat($"You don't have any space for {Name} in your inventory! Try dropping something you don't need.\n");
}
}
else
{
GameController.InputResponse.AppendFormat($"You try to take {Name} but it won't budge!\n");
}
}
private void AutoHighlightStart()
{
ParseTree _tree;
string _currenttext = "";
while (!isDisposing)
{
bool _textchanged;
lock (treelock)
{
_textchanged = textChanged;
if (textChanged)
{
textChanged = false;
_currenttext = currentText;
}
}
if (!_textchanged)
{
Thread.Sleep(200);
continue;
}
_tree = (ParseTree)Parser.Parse(_currenttext);
lock (treelock)
{
if (textChanged)
continue;
else
Tree = _tree; // assign new tree
}
Textbox.Invoke(new MethodInvoker(HighlightTextInternal));
}
}
public CodeConverter(ParseTree programTree)
{
_programTree = programTree;
}
protected static void ManageParseError(ParseTree tree, StringBuilder output)
{
foreach (ParseError error in tree.Errors)
output.AppendLine(string.Format("({0},{1}): {2}", error.Line, error.Column, error.Message));
output.AppendLine("Semantic errors in grammar found.");
}
IEnumerable <OverlayShapeVM> CreateOverlayShapesFromItem(TikzParseItem tpi)
{
var ret = new List <OverlayShapeVM>();
if (tpi is Tikz_Scope)
{
OverlayScope os = new OverlayScope();
//os.pol = this;
os.tikzitem = tpi as Tikz_Scope;
// add child shapes
os.children.AddRange((tpi as TikzContainerParseItem).Children.SelectMany(child => CreateOverlayShapesFromItem(child)));
//foreach (TikzParseItem t in (tpi as TikzContainerParseItem).Children)
// DrawObject(t, os.children);
// don't draw scopes with no drawable children
// (we don't know where to render them)
if (os.children.Count > 0)
{
ret.Add(os);
os.AdjustPosition(TikzToScreen);
}
}
else if (tpi is TikzContainerParseItem)
{
ret.AddRange((tpi as TikzContainerParseItem).Children.SelectMany(child => CreateOverlayShapesFromItem(child)));
}
else if (tpi is Tikz_XYItem)
{
if ((tpi as Tikz_XYItem).HasEditableCoordinate())
{
OverlayNode el;
if (tpi.parent is Tikz_Controls)
{
el = new OverlayControlPoint(); // control points for Bezier curves
}
else
{
el = new OverlayNode();
}
//el.pol = this;
el.tikzitem = tpi as Tikz_XYItem;
el.AdjustPosition(TikzToScreen);
// add tooltip
if (ParseTree != null)
{
Tikz_Node nref = TikzParseTreeHelper.GetReferenceableNode(tpi as Tikz_XYItem, ParseTree.GetTikzPicture());
if (nref != null && !String.IsNullOrWhiteSpace(nref.name))
{
el.ToolTip = nref.name;
}
}
////canvas1.Children.Add(el);
ret.Add(el);
//bbg.Add(new Rect(Canvas.GetLeft(el), Canvas.GetTop(el), el.Width, el.Height));
}
}
else if (tpi is Tikz_Path)
{
}
return(ret);
}