protected virtual void VisitConstArrayDefinition(ConstArrayDefinitionNode node)
 {
     Visit(node.TypeNameNode);
     Visit(node.NameNode);
     Visit(node.ArraySizeNode);
     Visit(node.ElementNodes);
 }
コード例 #2
0
 protected virtual T VisitConstArrayDefinition(ConstArrayDefinitionNode node)
 {
     Visit(node.TypeNameNode);
     Visit(node.NameNode);
     Visit(node.ArraySizeNode);
     Visit(node.ElementNodes);
     return(DefaultResult);
 }
コード例 #3
0
        protected override NodeValue VisitConstArrayDefinition(ConstArrayDefinitionNode node)
        {
            if (node.ArraySizeValue is UndefinedValue)
            {
                return(new UndefinedValue());
            }
            node.ArraySizeValue = Visit(node.ArraySizeNode);


            SymbolType builtinType = node.Symbol.BuiltinType;

            foreach (var elementNode in node.ElementNodes)
            {
                NodeValue elementValue = Visit(elementNode);
                node.ElementValues.Add(elementValue);

                if (elementValue is UndefinedValue)
                {
                    continue;
                }
                SymbolType elementType = NodeValueToBuiltinType(elementValue);
                CheckArrayElementType(builtinType, elementType, elementNode);
            }


            switch (node.ArraySizeValue)
            {
            case UndefinedValue _:
                break;

            case IntValue intValue:
                if (intValue.Value == 0)
                {
                    node.ArraySizeNode.Annotations.Add(new ArraySizeEqualsZeroError(node.NameNode.Value));    //+
                }
                else if (intValue.Value > 4095)
                {
                    node.ArraySizeNode.Annotations.Add(new TooBigArraySizeError());
                }
                else if (intValue.Value != node.ElementNodes.Count)
                {
                    node.ArraySizeNode.Annotations.Add(new InconsistentArraySizeError(node.NameNode.Value, (int)intValue.Value, node.ElementNodes.Count));     //+
                }

                ((IArraySymbol)node.Symbol).Size = Convert.ToInt32(intValue.Value);
                break;

            default:
                node.ArraySizeNode.Annotations.Add(new ArraySizeNotConstIntegerError());
                break;
            }

            return(null);
        }
コード例 #4
0
        private ConstDefinitionsTemporaryNode GetConstDefinitionsTemporaryNode(DaedalusParser.ConstDefContext constDefContext)
        {
            NameNode typeNameNode = new NameNode(GetLocation(constDefContext.dataType()), constDefContext.dataType().GetText());

            List <DeclarationNode> constDefinitionNodes = new List <DeclarationNode>();

            foreach (IParseTree childContext in constDefContext.children)
            {
                if (childContext is DaedalusParser.ConstValueDefContext constValueDefContext)
                {
                    DaedalusParser.NameNodeContext nameNodeContext = constValueDefContext.nameNode();
                    NameNode            nameNode            = new NameNode(GetLocation(nameNodeContext), nameNodeContext.GetText());
                    ExpressionNode      rightSideNode       = (ExpressionNode)Visit(constValueDefContext.constValueAssignment().expression());
                    ConstDefinitionNode constDefinitionNode = new ConstDefinitionNode(GetLocation(constValueDefContext),
                                                                                      typeNameNode, nameNode, rightSideNode);
                    _constDefinitionNodes.Add(constDefinitionNode);
                    constDefinitionNodes.Add(constDefinitionNode);
                }
                else if (childContext is DaedalusParser.ConstArrayDefContext constArrayDefContext)
                {
                    DaedalusParser.NameNodeContext nameNodeContext = constArrayDefContext.nameNode();
                    NameNode       nameNode      = new NameNode(GetLocation(nameNodeContext), nameNodeContext.GetText());
                    ExpressionNode arraySizeNode = (ExpressionNode)VisitArraySize(constArrayDefContext.arraySize());

                    List <ExpressionNode> elementNodes = new List <ExpressionNode>();
                    foreach (DaedalusParser.ExpressionContext expressionContext in constArrayDefContext.constArrayAssignment().expression())
                    {
                        elementNodes.Add((ExpressionNode)Visit(expressionContext));
                    }

                    ConstArrayDefinitionNode constArrayDefinitionNode =
                        new ConstArrayDefinitionNode(GetLocation(nameNodeContext), typeNameNode, nameNode, arraySizeNode,
                                                     elementNodes);
                    _arrayDeclarationNodes.Add(constArrayDefinitionNode);
                    constDefinitionNodes.Add(constArrayDefinitionNode);
                }
            }
            return(new ConstDefinitionsTemporaryNode(GetLocation(constDefContext), constDefinitionNodes));
        }
コード例 #5
0
 protected override void VisitConstArrayDefinition(ConstArrayDefinitionNode node)
 {
 }
コード例 #6
0
 protected override void VisitConstArrayDefinition(ConstArrayDefinitionNode constArrayDefinitionNode)
 {
     BuildConst(constArrayDefinitionNode, true);
 }