Пример #1
0
        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);
            }
        }
Пример #2
0
        // 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));
        }
Пример #3
0
        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);
            }
        }
Пример #4
0
        /// <inheritdoc/>
        public override void VisitTypeDeclarationNode(TypeDeclarationNode node)
        {
            _nodes.Add(node);

            for (MemberDeclarationNode node2 = node.MemberDeclarations; node2 != null; node2 = node2.Next)
            {
                Visit(node2);
            }
        }
Пример #5
0
 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);
 }
Пример #6
0
 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);
     }
 }
Пример #7
0
        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);
        }
Пример #8
0
        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;
        }
Пример #9
0
        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);
        }
Пример #10
0
 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>());
     }
 }
Пример #11
0
 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;
         }
     }
 }
Пример #12
0
 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;
         }
     }
 }
Пример #13
0
        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);
        }
Пример #14
0
        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);
        }
Пример #15
0
        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;
    }
Пример #17
0
 public LocalVariableNode(TypeDeclarationNode type, IdentifierNode identifier)
 {
     this.identifier = identifier;
     this.type       = type;
 }
Пример #18
0
        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);
 }
Пример #20
0
 public ParameterNode(TypeDeclarationNode type, IdentifierNode identifier)
 {
     this.type       = type;
     this.identifier = identifier;
 }
Пример #21
0
        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));
        }
Пример #22
0
 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());
Пример #24
0
 /// <inheritdoc/>
 public override void VisitTypeDeclarationNode(TypeDeclarationNode node)
 {
     _nodes.Add(node);
     base.VisitTypeDeclarationNode(node);
 }