//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 (); }