void FieldOrMethodFactorized(Token encap, Token modifier, Token type, ref ClassNode clase) { printDebug("Field Or Method Factorized"); //retType or FieldType var identifier = new List <Token>(); identifier.Add(type); IdentifierAttribute(ref identifier); var arr = new ArrayType(); OptionalRankSpecifierList(ref arr); TypeDeclarationNode retOrFieldType = TypeDetector(type.type, new IdentifierNode(identifier)); if (arr.arrayOfArrays > 0 || arr.dimensions > 0) { arr.baseType = retOrFieldType; retOrFieldType = arr; } if (Match(TokenType.ID)) { var name = MatchExactly(TokenType.ID); FieldOrMethod(encap, modifier, retOrFieldType, name, ref clase); } }
// private StatementNode StatementExpressionPrime(ref ExpressionNode left) // { // if (ConsumeOnMatch(TokenType.PAREN_OPEN)) // { // var args = ArgumentList(); // MatchExactly(TokenType.PAREN_CLOSE); // } // else if (MatchAny(increment_decrement_operators)) // { // IncrementDecrement(); // } // else // { // return null; // } // } private StatementNode LocalVariableDeclaration() { printDebug("Local Variable Declaration"); if (!MatchAny(this.types.Concat(new TokenType[] { TokenType.VAR_KEYWORD }).ToArray())) { ThrowSyntaxException("Type or Var expected"); } TypeDeclarationNode type = null; if (Match(TokenType.VAR_KEYWORD)) { var token = ConsumeToken(); type = TypeDetector(token.type, new IdentifierNode(token)); } else { type = Type(); } var variables = VariableDeclaratorList(null, null, type); var variablesNodes = new List <LocalVariableNode>(); foreach (var x in variables) { var y = new LocalVariableNode(x.type, x.identifier, x.assignment); variablesNodes.Add(y); } return(new LocalVariablesNode(variablesNodes)); }
private InstanceInitilizerExpressionNode InstanceExpressionFactorized(ref TypeDeclarationNode type) { printDebug("Instance Expression Factorized"); // MatchExactly(TokenType.PAREN_OPEN); // ArgumentList(); // MatchExactly(TokenType.PAREN_CLOSE); if (Match(TokenType.BRACKET_OPEN)) { MatchExactly(TokenType.BRACKET_OPEN); return(InstanceExpressionFactorizedPrime(ref type)); } else if (Match(TokenType.PAREN_OPEN)) { MatchExactly(TokenType.PAREN_OPEN); var args = ArgumentList(); MatchExactly(TokenType.PAREN_CLOSE); return(new ConstructorCallExpressionNode(type, args)); } else { ThrowSyntaxException("Open bracket or Open brace expected"); return(null); } }
/// <inheritdoc/> public override void VisitTypeDeclarationNode(TypeDeclarationNode node) { _nodes.Add(node); for (MemberDeclarationNode node2 = node.MemberDeclarations; node2 != null; node2 = node2.Next) { Visit(node2); } }
public void AddVariableToCurrentContext(string var_name, TypeDeclarationNode type, bool AddBase = false) { if (this.contexts.Count == 0) { Console.WriteLine("No contexts added"); return; } this.contexts[this.contexts.Count - 1].AddVariable(var_name, type, AddBase); }
private void FieldOrMethod(Token encap, Token modifier, TypeDeclarationNode type, Token name, ref ClassNode clase) { printDebug("Field Or Method"); if (Match(TokenType.PAREN_OPEN)) { MethodDeclaration(encap, modifier, type, name, ref clase); } else { FieldDeclaration(encap, modifier, type, name, ref clase); } }
List <FieldNode> VariableDeclaratorList(Token encap, Token modifier, TypeDeclarationNode type) { printDebug("Variable Declarator List"); var token = MatchExactly(TokenType.ID); var field = new FieldNode(type, new IdentifierNode(token), new EncapsulationNode(encap), modifier); field.assignment = VariableAssigner(); var fields = VariableDeclaratorListPrime(encap, modifier, type); fields.Insert(0, field); return(fields); }
public static Either <ParseException, ProgramNode> Parse(List <IToken> tokens) { Console.WriteLine("ProgramNode"); var declarations = new List <IDeclarationNode>(); var typeTable = new Dictionary <string, IEntityType>(); var symT = new SymT(); var result = new ProgramNode(declarations, symT, typeTable); while (tokens.Count > 0) { var maybeRoutineDeclaration = RoutineDeclarationNode.Parse(tokens, symT, result); if (maybeRoutineDeclaration.IsRight) { tokens = maybeRoutineDeclaration.RightToList()[0].First; var routineDeclaration = maybeRoutineDeclaration.RightToList()[0].Second; declarations.Add(routineDeclaration); typeTable.TryAdd(routineDeclaration.Identifier.Lexeme, routineDeclaration.ToRoutineType()); continue; } var maybeVariableDeclaration = VariableDeclarationNode.Parse(tokens, symT, result); if (maybeVariableDeclaration.IsRight) { tokens = maybeVariableDeclaration.RightToList()[0].First; var varDecl = maybeVariableDeclaration.RightToList()[0].Second; declarations.Add(varDecl); typeTable.TryAdd(varDecl.Identifier.Lexeme, varDecl.ToVariableType()); continue; } var maybeTypeDeclaration = TypeDeclarationNode.Parse(tokens, symT, result); if (maybeTypeDeclaration.IsRight) { tokens = maybeTypeDeclaration.RightToList()[0].First; var typeDecl = maybeTypeDeclaration.RightToList()[0].Second; declarations.Add(typeDecl); typeTable.TryAdd(typeDecl.Identifier.Lexeme, typeDecl.ToTypeAliasType()); continue; } return(maybeTypeDeclaration.LeftToList()[0]); } Console.WriteLine("Program is interprited Successfully"); return(new ProgramNode(declarations, symT, typeTable)); //return Either<ParseException, ProgramNode>.Bottom; }
void FieldDeclaration(Token encap, Token modifier, TypeDeclarationNode type, Token name, ref ClassNode clase) { printDebug("Field Declaration"); var field = new FieldNode(type, new IdentifierNode(name), new EncapsulationNode(encap), modifier); field.assignment = VariableAssigner(); var fields = VariableDeclaratorListPrime(encap, modifier, type); fields.Insert(0, field); MatchExactly(new TokenType[] { TokenType.END_STATEMENT }); clase.fields.AddRange(fields); }
List <FieldNode> VariableDeclaratorListPrime(Token encap, Token modifier, TypeDeclarationNode type) { printDebug("Variable Declarator List Prime"); if (Match(TokenType.COMMA)) { ConsumeToken(); return(VariableDeclaratorList(encap, modifier, type)); } else { //EPSILON return(new List <FieldNode>()); } }
public void AddMethod(string method_name, TypeDeclarationNode return_type, bool AddBase = false) { if (VariableExists(method_name)) { throw new SemanticException($"Double declaration of method. Method Name: {method_name}", return_type.identifier.identifiers[0]); } methods[method_name] = return_type; if (this.type == ContextType.CLASS_CONTEXT) { methods[$"this.{method_name}"] = return_type; if (AddBase) { methods[$"base.{method_name}"] = return_type; } } }
public void AddVariable(string var_name, TypeDeclarationNode type, bool AddBase = false) { if (VariableExists(var_name)) { throw new SemanticException($"Double declaration of variable. Varriable Name: {var_name}", type.identifier.identifiers[0]); } variables[var_name] = type; if (this.type == ContextType.CLASS_CONTEXT) { variables[$"this.{var_name}"] = type; if (AddBase) { variables[$"base.{var_name}"] = type; } } }
public void AddMethodToCurentContext(string name, TypeDeclarationNode return_type, bool AddBase = false) { if (this.contexts.Count == 0) { Console.WriteLine("No contexts added"); return; } var expected_contexts_types = new List <ContextType> { ContextType.CLASS_CONTEXT /*, ContextType.INTERFACE_CONTEXT*/ }; if (!expected_contexts_types.Contains(this.contexts[this.contexts.Count - 1].type)) { throw new SemanticException("Method only can be added to Class or Interface Context", return_type.identifier.identifiers[0]); } this.contexts[this.contexts.Count - 1].AddMethod(name, return_type, AddBase); }
void MethodDeclaration(Token encap, Token modifier, TypeDeclarationNode type, Token name, ref ClassNode clase) { printDebug("Method Declaration"); var method = new MethodNode(new IdentifierNode(name), type, new EncapsulationNode(encap), modifier); MatchExactly(new TokenType[] { TokenType.PAREN_OPEN }); var parameters = FixedParameters(); method.parameters = parameters; MatchExactly(new TokenType[] { TokenType.PAREN_CLOSE }); var body = MaybeEmptyBlock(); method.body = body as BlockStatementNode; clase.methods.Add(method); }
private InstanceInitilizerExpressionNode InstanceExpressionFactorizedPrime(ref TypeDeclarationNode type) { printDebug("Instance Expression Factorized Prime"); var nuevo = new TokenType[] { TokenType.OP_TERNARY, TokenType.OP_HIERARCHY, TokenType.OP_NULL_COALESCING, TokenType.OP_CONDITIONAL_OR, TokenType.OP_CONDITIONAL_OR, TokenType.OP_BITS_OR, TokenType.OP_BITS_XOR, TokenType.OP_BITS_AND, TokenType.PAREN_OPEN, TokenType.NEW_KEYWORD, TokenType.ID, TokenType.THIS_KEYWORD }; if (MatchAny(this.expression_operators)) { var exprs = ExpressionList(); MatchExactly(TokenType.BRACKET_CLOSE); var arr = new ArrayType(); arr.baseType = type; OptionalRankSpecifierList(ref arr); var initializer = OptionalArrayInitializer(); return(new ArrayInitializerExpressionNode(arr, initializer)); } else if (Match(TokenType.BRACKET_CLOSE) || Match(TokenType.COMMA)) { var arr = new ArrayType(); arr.baseType = type; RankSpecifierList(ref arr); var initializer = ArrayInitializer(); return(new ArrayInitializerExpressionNode(arr, initializer)); } else { ThrowSyntaxException("Expression or rank specifier expected"); return(null); } }
static bool TryGetIheritedFromMember(CSharpMember semanticMember, TypeDeclarationNode syntacticParentType, out CSharpMember inheritedFromMember) { Contract.Requires(semanticMember != null); Contract.Requires(semanticMember.IsMethod); Contract.Ensures(!Contract.Result<bool>() || Contract.ValueAtReturn(out inheritedFromMember) != null && Contract.ValueAtReturn(out inheritedFromMember).IsMethod); inheritedFromMember = null; #region If member is from struct, ignore it if (semanticMember.ContainingType.IsValueType || semanticMember.ContainingType.IsStruct) { ContractsPackageAccessor.Current.Logger.WriteToLog("Member is struct or value type, skipping member..."); return false; } #endregion #region If member is from a contract class, ignore it //TODO: Get proper attributes from semantic model! Bug in semantic model, custom attributes don't seem to work right. bool ignoreIt = false; var containingType = semanticMember.ContainingType; if (containingType.IsClass) { if (syntacticParentType != null) { foreach (var attributeSection in syntacticParentType.Attributes) { foreach (var attribute in attributeSection.AttributeList) { var attributeName = attribute.AttributeName as IdentifierNode; if (attributeName != null) { if (attributeName.Name.Text.Contains("ContractClassFor")) ignoreIt = true; } } } } } if (ignoreIt) { ContractsPackageAccessor.Current.Logger.WriteToLog("Member has 'ContractClassForAttribute', skipping member..."); return false; } #endregion // If member is override, get base member if (semanticMember.IsOverride) { if (!CSharpToCCIHelper.TryGetBaseMember(semanticMember, out inheritedFromMember)) { ContractsPackageAccessor.Current.Logger.WriteToLog("Member is an override but we can't get its base member, skipping member..."); return false; //If we can't get the base member, we don't want to keep going with this member. } } else if (semanticMember.ContainingType.IsInterface || semanticMember.IsAbstract) { inheritedFromMember = semanticMember; } #region Else member implements an interface or it doesn't have inherited contracts, get interface member else { if (!CSharpToCCIHelper.TryGetInterfaceMember(semanticMember, out inheritedFromMember)) { ContractsPackageAccessor.Current.Logger.WriteToLog("Member isn't override, abstract, in an interface or an interface member, skipping member..."); return false; //If we can't get the interface member, we don't want to keep going with this member. } } #endregion return inheritedFromMember != null; }
public LocalVariableNode(TypeDeclarationNode type, IdentifierNode identifier) { this.identifier = identifier; this.type = type; }
static bool TryGetIheritedFromMember(CSharpMember semanticMember, TypeDeclarationNode syntacticParentType, out CSharpMember inheritedFromMember) { Contract.Requires(semanticMember != null); Contract.Requires(semanticMember.IsMethod); Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out inheritedFromMember) != null && Contract.ValueAtReturn(out inheritedFromMember).IsMethod); inheritedFromMember = null; #region If member is from struct, ignore it if (semanticMember.ContainingType.IsValueType || semanticMember.ContainingType.IsStruct) { ContractsPackageAccessor.Current.Logger.WriteToLog("Member is struct or value type, skipping member..."); return(false); } #endregion #region If member is from a contract class, ignore it //TODO: Get proper attributes from semantic model! Bug in semantic model, custom attributes don't seem to work right. bool ignoreIt = false; var containingType = semanticMember.ContainingType; if (containingType.IsClass) { if (syntacticParentType != null) { foreach (var attributeSection in syntacticParentType.Attributes) { foreach (var attribute in attributeSection.AttributeList) { var attributeName = attribute.AttributeName as IdentifierNode; if (attributeName != null) { if (attributeName.Name.Text.Contains("ContractClassFor")) { ignoreIt = true; } } } } } } if (ignoreIt) { ContractsPackageAccessor.Current.Logger.WriteToLog("Member has 'ContractClassForAttribute', skipping member..."); return(false); } #endregion // If member is override, get base member if (semanticMember.IsOverride) { if (!CSharpToCCIHelper.TryGetBaseMember(semanticMember, out inheritedFromMember)) { ContractsPackageAccessor.Current.Logger.WriteToLog("Member is an override but we can't get its base member, skipping member..."); return(false); //If we can't get the base member, we don't want to keep going with this member. } } else if (semanticMember.ContainingType.IsInterface || semanticMember.IsAbstract) { inheritedFromMember = semanticMember; } #region Else member implements an interface or it doesn't have inherited contracts, get interface member else { if (!CSharpToCCIHelper.TryGetInterfaceMember(semanticMember, out inheritedFromMember)) { ContractsPackageAccessor.Current.Logger.WriteToLog("Member isn't override, abstract, in an interface or an interface member, skipping member..."); return(false); //If we can't get the interface member, we don't want to keep going with this member. } } #endregion return(inheritedFromMember != null); }
public override void VisitTypeDeclarationNode(TypeDeclarationNode node) { _nodes.Add(node); base.VisitTypeDeclarationNode(node); }
public ParameterNode(TypeDeclarationNode type, IdentifierNode identifier) { this.type = type; this.identifier = identifier; }
public static Either <ParseException, Pair <List <IToken>, BodyNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("BodyNode"); ImmutableArray <IAstNode> elements = ImmutableArray <IAstNode> .Empty; var typeTable = new Dictionary <string, IEntityType>(); var result = new BodyNode(ImmutableArray <IAstNode> .Empty, typeTable, parentTypeTable); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } while (true) { var maybeSimpleDeclaration1 = VariableDeclarationNode.Parse(tokens, symT, result); if (maybeSimpleDeclaration1.IsRight) { tokens = maybeSimpleDeclaration1.RightToList()[0].First; var varDecl = maybeSimpleDeclaration1.RightToList()[0].Second; elements = elements.Add(varDecl); typeTable.TryAdd(varDecl.Identifier.Lexeme, varDecl.ToVariableType()); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeSimpleDeclaration2 = TypeDeclarationNode.Parse(tokens, symT, result); if (maybeSimpleDeclaration2.IsRight) { tokens = maybeSimpleDeclaration2.RightToList()[0].First; var typeDecl = maybeSimpleDeclaration2.RightToList()[0].Second; elements = elements.Add(typeDecl); typeTable.TryAdd(typeDecl.Identifier.Lexeme, typeDecl.ToTypeAliasType()); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeStatement = StatementNode.Parse(tokens, symT, result); if (maybeStatement.IsRight) { tokens = maybeStatement.RightToList()[0].First; elements = elements.Add(maybeStatement.RightToList()[0].Second); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeExpression = StatementNode.Parse(tokens, symT, result); if (maybeExpression.IsRight) { tokens = maybeExpression.RightToList()[0].First; elements = elements.Add(maybeExpression.RightToList()[0].Second); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } break; } if (tokens.Count < 1) { return(NotABodyException); } if (!(tokens[0] is ReturnKeywordToken)) { return(NotABodyException); } tokens = tokens.Skip(1).ToList(); var maybeExpression1 = ExpressionNode.Parse(tokens, result); if (maybeExpression1.IsRight) { while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } tokens = maybeExpression1.RightToList()[0].First; result.Elements = elements; result.ReturnExpressionNode = maybeExpression1.RightToList()[0].Second; var res = new Pair <List <IToken>, BodyNode>(tokens, result); return(res); } result.Elements = elements; return(new Pair <List <IToken>, BodyNode>(tokens, result)); }
public LocalVariableNode(TypeDeclarationNode type, IdentifierNode identifier, VariableInitializer assignation) : this(type, identifier) { this.assignation = assignation; }
public static TypeAliasType ToTypeAliasType(this TypeDeclarationNode node) => new TypeAliasType(node.Type.ToTypeRepresentation());
/// <inheritdoc/> public override void VisitTypeDeclarationNode(TypeDeclarationNode node) { _nodes.Add(node); base.VisitTypeDeclarationNode(node); }