public override void Parse(TokensStack sTokens)
{
Globals = new List <VarDeclaration>();
while ((sTokens.Peek() is Statement) && ((Statement)sTokens.Peek()).Name == "var")
{
VarDeclaration global = new VarDeclaration();
global.Parse(sTokens);
Globals.Add(global);
}
Functions = new List <Function>();
while (sTokens.Count > 0)
{
if (!(sTokens.Peek() is Statement) || ((Statement)sTokens.Peek()).Name != "function")
{
throw new SyntaxErrorException("Expected function", sTokens.Peek());
}
Function f = new Function();
f.Parse(sTokens);
Functions.Add(f);
}
if (Functions.Count > 0)
{
Function f = Functions[Functions.Count - 1];
Functions.RemoveAt(Functions.Count - 1);
Main = f;
}
else
{
throw new Exception("Missing main method");
}
}
public override void Parse(TokensStack sTokens)
{
Globals = new List <VarDeclaration>();
while ((sTokens.Peek() is Statement) && ((Statement)sTokens.Peek()).Name == "var")
{
VarDeclaration global = new VarDeclaration();
global.Parse(sTokens);
Globals.Add(global);
}
Main = new Function();
Main.Parse(sTokens);
Functions = new List <Function>();
while (sTokens.Count > 0)
{
if (!(sTokens.Peek() is Statement) || ((Statement)sTokens.Peek()).Name != "function")
{
throw new SyntaxErrorException("Expected function", sTokens.Peek());
}
Function f = new Function();
f.Parse(sTokens);
Functions.Add(f);
throw new Exception(string.Join("\n", f.ToString()));
}
// throw new Exception(string.Join("\n", Functions.ToArray().ToString()));
}
public override void Parse(TokensStack sTokens)
{
Token tFunc = sTokens.Pop();
if (!(tFunc is Statement) || ((Statement)tFunc).Name != "function")
{
throw new SyntaxErrorException("Expected function received: " + tFunc, tFunc);
}
Token tType = sTokens.Pop();
if (!(tType is VarType))
{
throw new SyntaxErrorException("Expected var type, received " + tType, tType);
}
ReturnType = VarDeclaration.GetVarType(tType);
Token tName = sTokens.Pop();
if (!(tName is Identifier))
{
throw new SyntaxErrorException("Expected function name, received " + tType, tType);
}
Name = ((Identifier)tName).Name;
Token t = sTokens.Pop(); //(
while (sTokens.Count > 0 && !(sTokens.Peek() is Parentheses)) //)
{
if (sTokens.Count < 3)
{
throw new SyntaxErrorException("Early termination ", t);
}
Token tArgType = sTokens.Pop();
Token tArgName = sTokens.Pop();
VarDeclaration vc = new VarDeclaration(tArgType, tArgName);
Args.Add(vc);
if (sTokens.Count > 0 && sTokens.Peek() is Separator)//,
{
sTokens.Pop();
}
}
t = sTokens.Pop(); //)
t = sTokens.Pop(); //{
while (sTokens.Count > 0 && (sTokens.Peek() is Statement) && (((Statement)sTokens.Peek()).Name == "var"))
{
VarDeclaration local = new VarDeclaration();
local.Parse(sTokens);
Locals.Add(local);
}
while (sTokens.Count > 0 && !(sTokens.Peek() is Parentheses))
{
StatetmentBase s = StatetmentBase.Create(sTokens.Peek());
s.Parse(sTokens);
Body.Add(s);
}
Token tEnd = sTokens.Pop();//}
}
public List <VarDeclaration> ParseVarDeclarations(List <string> lVarLines)
{
List <VarDeclaration> lVars = new List <VarDeclaration>();
for (int i = 0; i < lVarLines.Count; i++)
{
List <Token> lTokens = Tokenize(lVarLines[i], i);
TokensStack stack = new TokensStack(lTokens);
VarDeclaration var = new VarDeclaration();
var.Parse(stack);
lVars.Add(var);
}
return(lVars);
}
public override void Parse(TokensStack sTokens)
{
Globals = new List <VarDeclaration>();
while ((sTokens.Peek() is Statement) && ((Statement)sTokens.Peek()).Name == "var")
{
VarDeclaration global = new VarDeclaration();
global.Parse(sTokens);
Globals.Add(global);
}
/*
* function int main(){
* varDecl
* Statment*
* Return Statment
* }
*/
Main = new Function();
Main.Parse(sTokens);
Functions = new List <Function>();
if (Main.Name != "main")
{
throw new Exception("The first func must be main");
}
if (Main.Args.Count() > 0)
{
throw new Exception("the main func recieves no Arguments");
}
while (sTokens.Count > 0)
{
if (!(sTokens.Peek() is Statement) || ((Statement)sTokens.Peek()).Name != "function")
{
throw new SyntaxErrorException("Expected function", sTokens.Peek());
}
Function f = new Function();
f.Parse(sTokens);
Functions.Add(f);
}
}
//This is an example of the implementation of the Parse method
public override void Parse(TokensStack sTokens)
{
//We check that the first token is "function"
Token tFunc = sTokens.Pop();
if (!(tFunc is Statement) || ((Statement)tFunc).Name != "function")
{
throw new SyntaxErrorException("Expected function received: " + tFunc, tFunc);
}
//Now there should be the return type. We pop it from the stack, check for errors, and then set the field
Token tType = sTokens.Pop();
if (!(tType is VarType))
{
throw new SyntaxErrorException("Expected var type, received " + tType, tType);
}
ReturnType = VarDeclaration.GetVarType(tType);
//Next is the function name
Token tName = sTokens.Pop();
if (!(tName is Identifier))
{
throw new SyntaxErrorException("Expected function name, received " + tType, tType);
}
Name = ((Identifier)tName).Name;
//After the name there should be opening paranthesis for the arguments
Token t = sTokens.Pop(); //(
if (!(t is Parentheses) || ((Parentheses)t).Name != '(')
{
throw new SyntaxErrorException($"Expected a '(' but saw '{t}'", t);
}
//Now we extract the arguments from the stack until we see a closing parathesis
while (sTokens.Count > 0 && !(sTokens.Peek() is Parentheses))//)
{
//For each argument there should be a type, and a name
if (sTokens.Count < 3)
{
throw new SyntaxErrorException("Early termination ", t);
}
Token tArgType = sTokens.Pop();
Token tArgName = sTokens.Pop();
VarDeclaration vc = new VarDeclaration(tArgType, tArgName);
Args.Add(vc);
//If there is a comma, then there is another argument
if (sTokens.Count > 0 && sTokens.Peek() is Separator) //,
{
t = sTokens.Pop();
if (!(t is Separator) || ((Separator)t).Name != ',')
{
throw new SyntaxErrorException($"Expected a ',' but saw '{t}'", t);
}
}
}
//Now we pop out the ) and the {. Note that you need to check that the stack contains the correct symbols here.
t = sTokens.Pop();//)
if (!(t is Parentheses) || ((Parentheses)t).Name != ')')
{
throw new SyntaxErrorException($"Expected a ')' but saw '{t}'", t);
}
t = sTokens.Pop();//{
if (!(t is Parentheses) || ((Parentheses)t).Name != '{')
{
throw new SyntaxErrorException($"Expected a '{{' but saw '{t}'", t);
}
//Now we parse the list of local variable declarations
while (sTokens.Count > 0 && (sTokens.Peek() is Statement) && (((Statement)sTokens.Peek()).Name == "var"))
{
VarDeclaration local = new VarDeclaration();
//We call the Parse method of the VarDeclaration, which is responsible to parsing the elements of the variable declaration
local.Parse(sTokens);
Locals.Add(local);
}
//Now we parse the list of statements
while (sTokens.Count > 0 && !(sTokens.Peek() is Parentheses))
{
//We create the correct Statement type (if, while, return, let) based on the top token in the stack
StatetmentBase s = StatetmentBase.Create(sTokens.Peek());
//And call the Parse method of the statement to parse the different parts of the statement
s.Parse(sTokens);
Body.Add(s);
}
bool hasReturn = false;
if (Body.Count > 0)
{
StatetmentBase lastStatetment = Body[Body.Count - 1];
Body.RemoveAt(Body.Count - 1);
if (lastStatetment is ReturnStatement)
{
Return = (ReturnStatement)lastStatetment;
hasReturn = true;
}
else
{
hasReturn = false;
}
}
//Need to check here that the last statement is a return statement
//Finally, the function should end with }
Token tEnd = sTokens.Pop();//}
if (!hasReturn)
{
throw new SyntaxErrorException("Missing a return statement.", tEnd);
}
if (!(tEnd is Parentheses) || ((Parentheses)tEnd).Name != '}')
{
throw new SyntaxErrorException($"Expected a '}}' but saw '{t}'", t);
}
}
public override void Parse(TokensStack sTokens)
{
/*
* Function Type ID( args ){
* varDec*
* Statments*
* Return Statment
* }
*
* check more errors
*/
Token t;
StackIsNotEmpty(sTokens);
Token tFunc = sTokens.Pop();
if (!(tFunc is Statement) || ((Statement)tFunc).Name != "function")
{
throw new SyntaxErrorException("Expected function received: " + tFunc, tFunc);
}
StackIsNotEmpty(sTokens);
Token tType = sTokens.Pop();
if (!(tType is VarType))
{
throw new SyntaxErrorException("Expected var type, received " + tType, tType);
}
ReturnType = VarDeclaration.GetVarType(tType);
StackIsNotEmpty(sTokens);
Token tName = sTokens.Pop();
if (!(tName is Identifier))
{
throw new SyntaxErrorException("Expected function name, received " + tType, tType);
}
Name = ((Identifier)tName).Name;
StackIsNotEmpty(sTokens);
if (sTokens.Peek() is Parentheses && sTokens.Peek().ToString() == "(")
{
t = sTokens.Pop(); //(
}
else
{
throw new SyntaxErrorException("Expected ( Parentheses received: " + sTokens.Peek().ToString(), sTokens.Peek());
}
StackIsNotEmpty(sTokens);
while (sTokens.Count > 0 && !(sTokens.Peek() is Parentheses))
{
if (sTokens.Count < 3)
{
throw new SyntaxErrorException("Early termination ", t);
}
Token tArgType = sTokens.Pop();
Token tArgName = sTokens.Pop();
VarDeclaration vc = new VarDeclaration(tArgType, tArgName);
Args.Add(vc);
if (sTokens.Count > 0 && sTokens.Peek() is Separator)//,
{
sTokens.Pop();
}
}
StackIsNotEmpty(sTokens);
if (sTokens.Peek() is Parentheses && sTokens.Peek().ToString() == ")")
{
t = sTokens.Pop(); //)
}
else
{
throw new SyntaxErrorException("Expected ) Parentheses received: " + sTokens.Peek().ToString(), sTokens.Peek());
}
StackIsNotEmpty(sTokens);
if (sTokens.Peek() is Parentheses && sTokens.Peek().ToString() == "{")
{
t = sTokens.Pop(); //{
}
else
{
throw new SyntaxErrorException("Expected { Parentheses received: " + sTokens.Peek().ToString(), sTokens.Peek());
}
StackIsNotEmpty(sTokens);
while (sTokens.Count > 0 && (sTokens.Peek() is Statement) && (((Statement)sTokens.Peek()).Name == "var"))
{
VarDeclaration local = new VarDeclaration();
local.Parse(sTokens);
Locals.Add(local);
}
StackIsNotEmpty(sTokens);
while (sTokens.Count > 0 && !(sTokens.Peek() is Parentheses))
{
StatetmentBase s = StatetmentBase.Create(sTokens.Peek());
s.Parse(sTokens);
Body.Add(s);
}
StackIsNotEmpty(sTokens);
if (sTokens.Peek() is Parentheses && sTokens.Peek().ToString() == "}")
{
t = sTokens.Pop(); //}
}
else
{
throw new SyntaxErrorException("Expected } Parentheses received: " + sTokens.Peek().ToString(), sTokens.Peek());
}
}