//Arithmetic
public IDPacket MATH_OP(IDPacket OP1, IDPacket OP2, Token Operator)
{
if (Operator.Type == Type.Plus)
{
return(MATH_PLUS(OP1, OP2));
}
else if (Operator.Type == Type.Minus)
{
return(MATH_MINUS(OP1, OP2));
}
else if (Operator.Type == Type.Asterisk)
{
return(MATH_MUL(OP1, OP2));
}
else if (Operator.Type == Type.Slash)
{
return(MATH_DIV(OP1, OP2));
}
else if (Operator.Type == Type.Percentage)
{
return(MATH_MOD(OP1, OP2));
}
else
{
Error("Operator not recognized");
return(null);
}
}
public IdentityType ResolveIdentityType(Token token)
{
string name = token.Content;
if (current_scope.Primitives.Numbers.ContainsKey(name))
{
return(IdentityType.Number);
}
if (current_scope.Primitives.Text.ContainsKey(name))
{
return(IdentityType.Text);
}
if (current_scope.Primitives.Booleans.ContainsKey(name))
{
return(IdentityType.Boolean);
}
if (current_scope.Functions.ContainsKey(name))
{
return(IdentityType.Function);
}
if (current_scope.Generics.ContainsKey(name))
{
return(IdentityType.Structure);
}
Debug("Cannot resolve identity type of identity " + name);
return(IdentityType.Unknown);
}
//Comparisions
public IDPacket COMP_OP(IDPacket OP1, IDPacket OP2, Token Operator)
{
if (Operator.Type == Type.GreaterThan)
{
return(COMP_GT(OP1, OP2));
}
else if (Operator.Type == Type.LessThan)
{
return(COMP_LT(OP1, OP2));
}
else if (Operator.Type == Type.Equals)
{
return(COMP_EQ(OP1, OP2));
}
else if (Operator.Type == Type.GreaterThanEqual)
{
return(LOGICAL_OR(COMP_GT(OP1, OP2), COMP_EQ(OP1, OP2)));
}
else if (Operator.Type == Type.LessThanEqual)
{
return(LOGICAL_OR(COMP_LT(OP1, OP2), COMP_EQ(OP1, OP2)));
}
else
{
Error("Operator not recognized");
return(null);
}
}
IDPacket ExpressionLogic(YSParseNode ExpressionLogicNode)
{
Debug("ExpressionLogic Resolving...");
Current = ExpressionLogicNode;
int CCNT = 0;
if (ExpressionLogicNode.Children [CCNT].Type == NType.Terminal)
{
CCNT++;
}
IDPacket LOG1 = ExpressionBoolean(ExpressionLogicNode.Children[CCNT]);
if (CCNT == 1)
{
LOG1 = STATE.LOGICAL_NOT(LOG1);
}
CCNT++;
while (CCNT < ExpressionLogicNode.Children.Count)
{
YSToken LogicalOperator = ExpressionLogicNode.Children [CCNT++].Token;
IDPacket LOG2 = ExpressionBoolean(ExpressionLogicNode.Children[CCNT++]);
LOG1 = STATE.LOGICAL_OP(LOG1, LOG2, LogicalOperator);
}
Debug("Exit ExpressionLogic, final type: " + LOG1.Type);
return(LOG1);
}
IDPacket ExpressionTerm(YSParseNode ExpressionTermNode)
{
Debug("ExpressionTerm Resolving...");
Current = ExpressionTermNode;
IDPacket FAC1 = ExpressionFactor(ExpressionTermNode.Children [0]);
int CCNT = 1;
while (CCNT < ExpressionTermNode.Children.Count)
{
/*
* YSToken TermOperator = ExpressionTermNode.Children [CCNT++];
* ExpressionFactor (ExpressionTermNode.Children [CCNT++]);
*/
YSToken FacOperator = ExpressionTermNode.Children [CCNT++].Token;
IDPacket FAC2 = ExpressionFactor(ExpressionTermNode.Children [CCNT++]);
FAC1 = STATE.MATH_OP(FAC1, FAC2, FacOperator);
//Debug ("Address " + FAC1.Name);
}
//Debug ("Address " + FAC1.Name);
if (FAC1.Type == IdentityType.Unknown)
{
Error("Expression Factor Type is unresolved");
}
Debug("Exit ExpressionBoolean, final type: " + FAC1.Type);
return(FAC1);
}
//identity expression
void VarPrimitive(YSParseNode VarPrimitiveNode, IdentityType IType)
{
Current = VarPrimitiveNode;
YSToken NameToken = VarPrimitiveNode.Children[0].Children[0].Token;
ExpectNonExistance(NameToken.Content);
IDPacket primitive = IDPacket.CreateIDPacket(STATE, NameToken.Content, IType);
Debug("Creating variable " + NameToken.Content + " of type " + IType);
if (VarPrimitiveNode.Children.Count > 1)
{
IDPacket PEXP = Expression(VarPrimitiveNode.Children [1]);
ExpectType(primitive.Type, PEXP.Type);
STATE.COPY(primitive, PEXP);
Debug("Assignment complete");
}
else
{
switch (IType)
{
case IdentityType.Number:
STATE.PutNumber(primitive, 0);
break;
case IdentityType.Boolean:
STATE.PutBoolean(primitive, false);
break;
case IdentityType.Text:
STATE.PutText(primitive, "");
break;
}
}
Debug("Exit VarPrimitive");
}
public void RegisterPrimitive(Token identity, Token value)
{
switch (value.Type)
{
case Type.NumberData:
double insert_double;
Double.TryParse(value.Content, out insert_double);
current_scope.Primitives.Numbers.Add(identity.Content, insert_double);
break;
case Type.TextData:
current_scope.Primitives.Text.Add(identity.Content, value.Content);
break;
case Type.Boolean:
bool insert_bool;
Boolean.TryParse(value.Content, out insert_bool);
current_scope.Primitives.Booleans.Add(identity.Content, insert_bool);
break;
default:
Debug("Cannot resolve the datatype of token " + value.Content);
break;
}
}
void IdentityPrimitive(YSToken identityToken)
{
//Identity Simple
PushParseNode(ParseNodeType.Identity);
PushGlobalAndParentKW();
CreateTerminalChild(identityToken);
PopAndInsertParseNode();
}
bool Identity(bool Expect_Sub, bool dataType)
{
Debug("Identity - token: " + current.Content);
//Reset Global and Parent Nodes
GlobalIdentity = null;
ParentIdentity = new List <Token> ();
Token identityToken = null;
if (Accept(Type.Global))
{
GlobalIdentity = previous;
Expect(Type.Period);
} /* else if (Accept (Type.Parent)) {
* ParentIdentity.Add (previous);
* while (Accept (Type.Period))
* if (Accept (Type.Parent)) {
* ParentIdentity.Add (previous);
* } else if (Accept (Type.Identity)) {
* identityToken = previous;
* break;
* } else {
* Error ("Parent keyword must be followed by another parent keyword or identity");
* }
* }*/
if (identityToken != null || Accept(Type.Identity))
{
identityToken = previous;
if (Accept(Type.LParen))
{
if (dataType)
{
Error("Expecting a data type, not a function");
}
IdentityFunction(identityToken);
}
else if (Accept(Type.LSBraket))
{
IdentityArray(identityToken);
}
else if (Accept(Type.Period))
{
IdentityStructure(identityToken);
}
else
{
IdentityPrimitive(identityToken);
}
return(true);
}
else
{
if (Expect_Sub)
{
Error("Expecting a resolvable identity/variable");
}
return(false);
}
}
void IdentityArray(YSToken identityToken)
{
PushParseNode(ParseNodeType.IdentityArray);
PushGlobalAndParentKW();
CreateTerminalChild(identityToken);
Expression();
Expect(Type.RSBraket);
PopAndInsertParseNode();
}
void IdentityStructure(YSToken identityToken)
{
//Identity Structure
PushParseNode(ParseNodeType.IdentityStructure);
PushGlobalAndParentKW();
CreateTerminalChild(identityToken);
Identity(true);
while (Accept(Type.Period))
{
Identity(true);
}
PopAndInsertParseNode();
}
//Logical Operations
public IDPacket LOGICAL_OP(IDPacket OP1, IDPacket OP2, Token Operator)
{
if (Operator.Type == Type.And)
{
return(LOGICAL_AND(OP1, OP2));
}
else if (Operator.Type == Type.Or)
{
return(LOGICAL_OR(OP1, OP2));
}
else
{
Error("Operator not recognized");
return(null);
}
}
//type VarPrimitive(identity expression) { VarPrimitive(identity expression) }
void VarCreate(YSParseNode VarCreateNode)
{
Current = VarCreateNode;
List <int> Dimensions;
IdentityType _DataType;
DataType(VarCreateNode.Children [0], out _DataType, out Dimensions);
if (Dimensions != null)
{
YSToken NameToken = VarCreateNode.Children [1].Token;
if (VarCreateNode.Children [2].Type == NType.ExpressionList)
{
IdentityType ResolvedType = IdentityType.Unknown;
List <int> ReversedDimensions = new List <int> ();
IDPacket exp_list = ExpressionList(VarCreateNode.Children [2], ref ReversedDimensions, ref ResolvedType);
IDPacket put = IDPacket.CreateIDPacket(STATE, NameToken.Content, IdentityType.Structure);
put.ArrayType = ResolvedType;
ReversedDimensions.Reverse();
ArrayFrame AF = new ArrayFrame(put.ArrayType, ReversedDimensions.ToArray());
STATE.PutGeneric(put, AF);
GenericFrame CastedGeneric;
ArrayFrame AF_Casted;
STATE.TryGetGeneric(put, out CastedGeneric);
AF_Casted = (ArrayFrame)CastedGeneric;
STATE.COPY(put, exp_list);
Debug("T");
}
else if (VarCreateNode.Children [2].Type == NType.ArrayInit)
{
//TODO array initializer
}
else
{
Error("Arrays must be initialized with an expression list or array initializer");
}
}
else
{
for (int i = 1; i < VarCreateNode.Children.Count; i++)
{
VarPrimitive(VarCreateNode.Children [i], _DataType);
}
}
Debug("Exit VarCreate");
}
IDPacket ExpressionBoolean(YSParseNode ExpressionBooleanNode)
{
Debug("ExpressionBoolean Resolving...");
Current = ExpressionBooleanNode;
int CCNT = 0;
IDPacket NUM1 = ExpressionNumber(ExpressionBooleanNode.Children [CCNT++]);
while (CCNT < ExpressionBooleanNode.Children.Count)
{
YSToken CompOperator = ExpressionBooleanNode.Children [CCNT++].Token;
IDPacket NUM2 = ExpressionNumber(ExpressionBooleanNode.Children [CCNT++]);
NUM1 = STATE.COMP_OP(NUM1, NUM2, CompOperator);
}
Debug("Exit ExpressionBoolean, final type: " + NUM1.Type);
//TODO Operation
return(NUM1);
}
IDPacket ExpressionNumber(YSParseNode ExpressionNumberNode)
{
/*
* ExpressionTerm (ExpressionNumberNode.Children [0], ref id);
* int CCNT = 1;
* while (CCNT < ExpressionNumberNode.Children.Count) {
* YSToken NumOperator = ExpressionNumberNode.Children [CCNT++];
* ExpressionTerm (ExpressionNumberNode.Children [CCNT++]);
*/
Debug("ExpressionNumber Resolving...");
Current = ExpressionNumberNode;
int CCNT = 0;
if (ExpressionNumberNode.Children [CCNT].Type == NType.Terminal)
{
CCNT++;
}
IDPacket TERM1 = ExpressionTerm(ExpressionNumberNode.Children [CCNT]);
if (CCNT == 1)
{
IDPacket TEMP = IDPacket.CreateSystemPacket("TEMP_ZERO", IdentityType.Number);
STATE.PutNumber(TEMP, 0);
TERM1 = STATE.MATH_MINUS(TEMP, TERM1);
}
CCNT++;
while (CCNT < ExpressionNumberNode.Children.Count)
{
YSToken NumOperator = ExpressionNumberNode.Children [CCNT++].Token;
IDPacket TERM2 = ExpressionTerm(ExpressionNumberNode.Children [CCNT++]);
//TODO Plus Operation
if (TERM1.Type == IdentityType.Text && TERM2.Type == IdentityType.Text && NumOperator.Type == YSToken.TokenType.Plus)
{
TERM1 = STATE.STR_CONCAT(TERM1, TERM2);
}
else
{
TERM1 = STATE.MATH_OP(TERM1, TERM2, NumOperator);
}
}
Debug("Exit ExpressionTerm, final type: " + TERM1.Type);
return(TERM1);
}
public YSLexer(string source)
{
Tokens = new List <YSToken> ();
Tokenizer = new YSTokenizer(() => source.ToCharArray().Select(i => i.ToString()).ToList());
Matchers = new List <YSMatcherBase> ();
Matchers.Add(new YSQuotedStringMatcher());
Matchers.Add(new YSCommentMatcher());
Matchers.AddRange(YSToken.SpecialCharacters);
Matchers.AddRange(YSToken.KeywordCharacters);
Matchers.Add(new YSNumberMatcher());
Matchers.Add(new YSWhiteSpaceMatcher());
Matchers.Add(new YSIdentityMatcher());
Debug(((YSMatcherBase)Matchers[0]).Identifier());
int safety = 0;
while (!Tokenizer.End() && ++safety < 1000)
{
int location = Tokenizer.Location;
foreach (YSMatcherBase Matcher in Matchers)
{
YSToken token = Matcher.IsMatch(Tokenizer);
if (token != null)
{
Debug(token.Type + " @ " + token.Position + " Content: " + token.Content);
if (token.Type != YSToken.TokenType.WhiteSpace && token.Type != YSToken.TokenType.Newline)
{
Tokens.Add(token);
}
break;
}
}
if (Tokenizer.Location == location)
{
Debug("Unrecognized character " + Tokenizer.Current + " @ " + Tokenizer.Location);
break;
}
}
Debug("Finished lexing");
}
void IdentityFunction(YSToken identityToken)
{
//Identity Function
PushParseNode(ParseNodeType.IdentityFunction);
PushGlobalAndParentKW();
CreateTerminalChild(identityToken);
if (Accept(Type.RParen))
{
PopAndInsertParseNode();
return;
}
PushParseNode(ParseNodeType.FunctionParamList);
Expression();
while (Accept(Type.Comma))
{
Expression();
}
Expect(Type.RParen);
PopAndInsertParseNode();
PopAndInsertParseNode();
}
void IdentityArray(YSToken identityToken)
{
PushParseNode (ParseNodeType.IdentityArray);
PushGlobalAndParentKW ();
CreateTerminalChild (identityToken);
Expression ();
Expect (Type.RSBraket);
PopAndInsertParseNode ();
}
public YSParseNode(NodeType Type, YSToken Token)
{
this.Type = Type;
this.Token = Token;
Children = new List<YSParseNode> ();
}
public YSParseNode(YSToken Token)
{
this.Token = Token;
this.Type = NodeType.Terminal;
Children = new List<YSParseNode> ();
}
//Logical Operations
public IDPacket LOGICAL_OP(IDPacket OP1, IDPacket OP2, Token Operator)
{
if (Operator.Type == Type.And) {
return LOGICAL_AND (OP1, OP2);
} else if (Operator.Type == Type.Or) {
return LOGICAL_OR (OP1, OP2);
} else {
Error ("Operator not recognized");
return null;
}
}
//Arithmetic
public IDPacket MATH_OP(IDPacket OP1, IDPacket OP2, Token Operator)
{
if (Operator.Type == Type.Plus) {
return MATH_PLUS (OP1, OP2);
} else if (Operator.Type == Type.Minus) {
return MATH_MINUS (OP1, OP2);
} else if (Operator.Type == Type.Asterisk) {
return MATH_MUL (OP1, OP2);
} else if (Operator.Type == Type.Slash) {
return MATH_DIV (OP1, OP2);
} else if (Operator.Type == Type.Percentage) {
return MATH_MOD (OP1, OP2);
} else {
Error ("Operator not recognized");
return null;
}
}
public YSWordMatcher(YSToken.TokenType t, String w)
{
Type = t;
Word = w;
}
public void RegisterPrimitive(Token identity, Token value)
{
switch (value.Type) {
case Type.NumberData:
double insert_double;
Double.TryParse (value.Content, out insert_double);
current_scope.Primitives.Numbers.Add (identity.Content, insert_double);
break;
case Type.TextData:
current_scope.Primitives.Text.Add (identity.Content, value.Content);
break;
case Type.Boolean:
bool insert_bool;
Boolean.TryParse (value.Content, out insert_bool);
current_scope.Primitives.Booleans.Add (identity.Content, insert_bool);
break;
default:
Debug ("Cannot resolve the datatype of token " + value.Content);
break;
}
}
public IdentityType ResolveIdentityType(Token token)
{
string name = token.Content;
if (current_scope.Primitives.Numbers.ContainsKey (name)) {
return IdentityType.Number;
}
if (current_scope.Primitives.Text.ContainsKey (name)) {
return IdentityType.Text;
}
if (current_scope.Primitives.Booleans.ContainsKey (name)) {
return IdentityType.Boolean;
}
if (current_scope.Functions.ContainsKey (name)) {
return IdentityType.Function;
}
if (current_scope.Generics.ContainsKey (name)) {
return IdentityType.Structure;
}
Debug ("Cannot resolve identity type of identity " + name);
return IdentityType.Unknown;
}
//Comparisions
public IDPacket COMP_OP(IDPacket OP1, IDPacket OP2, Token Operator)
{
if (Operator.Type == Type.GreaterThan) {
return COMP_GT (OP1, OP2);
} else if (Operator.Type == Type.LessThan) {
return COMP_LT (OP1, OP2);
} else if (Operator.Type == Type.Equals) {
return COMP_EQ (OP1, OP2);
} else if (Operator.Type == Type.GreaterThanEqual) {
return LOGICAL_OR(COMP_GT (OP1, OP2), COMP_EQ(OP1, OP2));
} else if (Operator.Type == Type.LessThanEqual) {
return LOGICAL_OR(COMP_LT (OP1, OP2), COMP_EQ(OP1, OP2));
} else {
Error ("Operator not recognized");
return null;
}
}
void CreateTerminalChild(YSToken Token)
{
YSParseNode t = new YSParseNode(Token);
current_node.Children.Add(t);
}
void CreateTerminalChild(YSToken Token)
{
YSParseNode t = new YSParseNode (Token);
current_node.Children.Add (t);
}
void IdentityStructure(YSToken identityToken)
{
//Identity Structure
PushParseNode (ParseNodeType.IdentityStructure);
PushGlobalAndParentKW ();
CreateTerminalChild (identityToken);
Identity (true);
while (Accept (Type.Period))
Identity (true);
PopAndInsertParseNode ();
}
void IdentityPrimitive(YSToken identityToken)
{
//Identity Simple
PushParseNode (ParseNodeType.Identity);
PushGlobalAndParentKW ();
CreateTerminalChild (identityToken);
PopAndInsertParseNode ();
}
bool Identity(bool Expect_Sub, bool dataType)
{
Debug ("Identity - token: " + current.Content);
//Reset Global and Parent Nodes
GlobalIdentity = null;
ParentIdentity = new List<Token> ();
Token identityToken = null;
if (Accept (Type.Global)) {
GlobalIdentity = previous;
Expect (Type.Period);
}/* else if (Accept (Type.Parent)) {
ParentIdentity.Add (previous);
while (Accept (Type.Period))
if (Accept (Type.Parent)) {
ParentIdentity.Add (previous);
} else if (Accept (Type.Identity)) {
identityToken = previous;
break;
} else {
Error ("Parent keyword must be followed by another parent keyword or identity");
}
}*/
if (identityToken != null || Accept (Type.Identity)) {
identityToken = previous;
if (Accept (Type.LParen)) {
if (dataType)
Error ("Expecting a data type, not a function");
IdentityFunction (identityToken);
} else if(Accept(Type.LSBraket)){
IdentityArray (identityToken);
} else if (Accept (Type.Period)) {
IdentityStructure (identityToken);
} else {
IdentityPrimitive (identityToken);
}
return true;
} else {
if (Expect_Sub)
Error ("Expecting a resolvable identity/variable");
return false;
}
}
public YSParseNode(NodeType Type, YSToken Token)
{
this.Type = Type;
this.Token = Token;
Children = new List <YSParseNode> ();
}
public YSParseNode(YSToken Token)
{
this.Token = Token;
this.Type = NodeType.Terminal;
Children = new List <YSParseNode> ();
}
void IdentityFunction(YSToken identityToken)
{
//Identity Function
PushParseNode (ParseNodeType.IdentityFunction);
PushGlobalAndParentKW ();
CreateTerminalChild (identityToken);
if (Accept (Type.RParen)) {
PopAndInsertParseNode ();
return;
}
PushParseNode (ParseNodeType.FunctionParamList);
Expression ();
while (Accept(Type.Comma))
Expression ();
Expect (Type.RParen);
PopAndInsertParseNode ();
PopAndInsertParseNode ();
}
