public Construct VisitVarDeclare(VarDeclare node) { // Create the variable. LlvmValue variable = LLVM.BuildAlloca(context.Target, this.ValueType.Emit(), node.Identifier); // Assign value if applicable. if (node.Value != null) { // Create the store instruction. LLVM.BuildStore(context.Target, node.Value.Emit(context), variable); // Register on symbol table. context.SymbolTable.localScope.Add(node.Identifier, variable); } // Append the value onto the stack. this.valueStack.Push(variable); // Return the node. return(node); }
public FindVarResult(VarDeclare varDeclare, bool isUpvalue) { VarDeclare = varDeclare; IsUpvalue = isUpvalue; }
public List <Step> ParseTokens() // Due to the size of this method I am not using IEnumerable 'yield return' as it is hard to track nested return statements. { List <Step> EvaluationSteps = new List <Step>(); while (tokQueue.More()) // While more tokens in queue (returns bool) { Token nextTok = tokQueue.MoveNext(); // pop next out of TokenQueue if (nextTok.Type().Equals("identifier")) // All statements in our language begin with identifiers. // We do not know what we have at this point, so let's check the identifier to see which tokens should follow after. { if (Syntax.IsType(nextTok.Value())) // If it is a var type, e.g "int", "string" - if it is, this is a variable declaration ("int x = 0;") { /* * EXPECTED PATTERN: varType varName = expr; * e.g int x = 2 + y*10; * e.g string testing = "Hello World!"; */ VarDeclare varDeclare = CaptureVarDeclare(nextTok.Value()); // Call method with argument storing the type of var being declared, e.g 'string' EvaluationSteps.Add(varDeclare); // Add Event object to the overall list of 'Steps' for the Evaluator module } else if (nextTok.Value().ToLower().Equals("if")) // Start of an if statement { /* * EXPECTED PATTERN: if(operands) { codeblock } * e.g if (x > 0) { * output(x); * x = 0; * } */ IfStatement ifState = CaptureIfStatement(); // Capture all useful information of the following if statements // We COULD have an else statement, so let's check the next token // First check there are still MORE tokens to check to avoid out of range errors // Then check it's an IDENTIFIER ('else') if (tokQueue.More() && tokQueue.Next().Type().Equals("identifier") && tokQueue.Next().Value().Equals("else")) { // If next token is 'else' and an identifier ElseStatement elseState = CaptureElseStatement(); EvaluationSteps.Add(ifState); EvaluationSteps.Add(elseState); // Add if state then else directly after (ordered list!) } else { EvaluationSteps.Add(ifState); // if no 'else' statement exists just add the if statement } } else if (nextTok.Value().ToLower().Equals("while")) { IfStatement template = CaptureIfStatement(); // Trick the program to think it's capturing an if statement WhileLoop whileLoop = new WhileLoop(template.GetCBContents(), template.GetOp1(), template.GetOp2(), template.GetComparator()); // Reuse code from the if statement because while & if follow the exact same structure: // while (condition) { codeblock } // if (condition) { codeblock } // We just captured an if statement 'template' then used the information it collected to create a while loop instead EvaluationSteps.Add(whileLoop); } else if (GrammarTokenCheck(tokQueue.Next(), "(")) // This condition will also return true if it finds an if/while statement, so it is AFTER the check for those. // As we're using else if, if the program didn't recognise a 'while' or 'if' statement, we will reach this check // We can GUARANTEE now that this must be a function call as 'if(){}' and 'while(){}' have been ruled out { /* * EXPECTED PATTERN: funcName(expr); // Can take any expression! * e.g output("Testing"); * e.g output(1 + 23); * e.g output(x); */ tokQueue.MoveNext(); // Skip the '(' token // Remember, nextTok still holds the value of the token before '(' // This is the name of our function ('funcName') FuncCall funcCall = CaptureFunctionCall(nextTok.Value()); // Pass the function name, e.g 'output' EvaluationSteps.Add(funcCall); } else if (GrammarTokenCheck(tokQueue.Next(), "=")) // .Next() is PEEK not POP. // Check if the token AFTER this one is "=" { /* * EXPECTED PATTERN: varName = expr; * e.g x = 2 + y*10; * e.g testing = "Hello World!"; */ tokQueue.MoveNext(); // Skip the '=' token // Remember, nextTok still holds the value of the token before the '=' // This is the name of our variable to change ('varName') VarChange varChan = CaptureVarChange(nextTok.Value()); EvaluationSteps.Add(varChan); } else { throw new SyntaxError(); } // If there is a rogue 'else' statement it will be caught in this // Else statements are not 'looked' for on there own, they are only recognised when an if statement is found } else { throw new SyntaxError(); // Statement doesn't begin with identifier - throw error. } } return(EvaluationSteps); }
public VarDeclare[] GetMemberDecls() { var list = new ArrayList(); var st = GetBaseStruct(); if (st != null) { var stmd = st.GetMemberDecls(); for (int i = 0; i < stmd.Length; i++) list.Add(stmd[i]); } ForEachMembers(delegate(VarDeclare p, int pos) { list.Add(p); return false; }, null); var ret = new VarDeclare[list.Count]; for (int i = 0; i < ret.Length; i++) ret[i] = list[i] as VarDeclare; return ret; }
public override void AddDestructors(OpModule codes, VarDeclare[] ptrs) { }
public void Evaluate(List <Step> evaluationSteps) { for (int index = 0; index < evaluationSteps.Count; index++) { Step evalStep = evaluationSteps[index]; // .Type() can only be "VAR_DECLARE", "VAR_CHANGE", "FUNC_CALL", "IF_STATEMENT", "WHILE_LOOP" // It could also be "ELSE_STATEMENT", but we should only check for that DIRECTLY after an IF_STATEMENT if (evalStep.Type().Equals("IF_STATEMENT")) { // Evaluate if statement - contains OPERAND1, OPERAND2, COMPARISON, codeBlockContents IfStatement ifState = (IfStatement)evalStep; // Cast as we know it is now an IfStatement obj bool conditionResult = CompareExpressions(ifState.GetOp1(), ifState.GetOp2(), ifState.GetComparator()); bool hasElse = index + 1 < evaluationSteps.Count && evaluationSteps[index + 1].Type().Equals("ELSE_STATEMENT"); // No chance of index out of range error as set to False before reaching it if (conditionResult) // If the 'IfStatement' condition is TRUE { Evaluate(ifState.GetCBContents()); // 'run' the contents of the if statement - this is RECURSIVE if (hasElse) { evaluationSteps.RemoveAt(index + 1); } // If we have an ELSE_STATEMENT after this, we need to remove it as the IF_STATEMENT has triggered (therefore the ELSE will not be triggered). } else if (hasElse) { // If the CONDITION is FALSE and the next Step obj is an ELSE_STATEMENT type ElseStatement elseState = (ElseStatement)evaluationSteps[index + 1]; // Cast to else Evaluate(elseState.GetCBContents()); // 'run' the contents of the else (RECURSION) evaluationSteps.RemoveAt(index + 1); // Remove ELSE_STATEMENT as we have used it and do not want to go over it again. } } else if (evalStep.Type().Equals("WHILE_LOOP")) { WhileLoop whileLoop = (WhileLoop)evalStep; // Similar to if statement evaluation though no need to set a 'condition' variable because that condition may change // Basically just reusing the C# while loop with the template of the Interpreted one while (CompareExpressions(whileLoop.GetOp1(), whileLoop.GetOp2(), whileLoop.GetComparator())) { // While the condition is true, evaluate code inside Evaluate(whileLoop.GetCBContents()); } } else if (evalStep.Type().Equals("VAR_DECLARE")) // Declare a variable in the variableScope { VarDeclare varDecl = (VarDeclare)evalStep; // Cast as we know it's a VarDeclare obj if (variableScope.ContainsKey(varDecl.GetName())) { throw new DeclareError(); } // If scope already has a variable that name, you cannot redeclare it as it already exists. // Potential endpoint if variable exists - entire program will stop (crash). Token varExpr = ResolveExpression(varDecl.Value()); if (!varExpr.Type().Equals(varDecl.GetVarType())) { throw new TypeError(); } // Value of variable does not match type with declared one. e.g 'int x = "Hello";' variableScope.Add(varDecl.GetName(), varExpr); // Type of variable can be found out by the .Type() of the key's Token. // e.g 'int x = 1 + 2;' // if we want to find variable 'x' type, we find variableScope[x].Type() which will return 'number', with variableScope[x].Value() being '3' } else if (evalStep.Type().Equals("VAR_CHANGE")) // Change a pre-existing variable { VarChange varChan = (VarChange)evalStep; // Cast as we know it is a VarChange obj if (!variableScope.ContainsKey(varChan.GetName())) { throw new ReferenceError(); } // If variable is NOT in the variableScope then we cannot change it as it doesn't exist. // Potential endpoint for program crash string varType = variableScope[varChan.GetName()].Type(); Token newValue = ResolveExpression(varChan.Value()); if (!varType.Equals(newValue.Type())) { throw new TypeError(); } // If the new value of the variable is not the right type, then crash. // Potential endpoint // e.g int x = 0; x = "hi"; will cause this error variableScope[varChan.GetName()] = newValue; // Assign new value (Token) } else if (evalStep.Type().Equals("FUNC_CALL")) // Call a function { FuncCall functionCall = (FuncCall)evalStep; // Cast as we know it is a FuncCall obj now if (!functionCall.GetName().Equals("inputstr") && !functionCall.GetName().Equals("inputint")) // If NOT calling 'input' function { CallFunction(functionCall.GetName(), ResolveExpression(functionCall.GetArguments())); // Call function with name and *resolved* list of arguments // Resolve function always outputs a single token which is the result of an expression (list of tokens) being evaluated } else // SPECIAL CASE: Calling inputStr or inputInt functions indicates that the 'argument' is NOT an expression to be resolved, but rather a variable name to store input value in. // This means functionCall.Argumnets() will only have 1 token: { CallFunction(functionCall.GetName(), functionCall.GetArguments()[0]); // Pass in first value in Arguments as there only should be one - the variable to be input to } } else { throw new SyntaxError(); // Unrecognised Step, crash program. } } }