Ejemplo n.º 1
0
 //------------------------------------------------------------
 // 展開命令。
 public void SymbolExpand(SymbolExpandCmdKind aCmd)
 {
     foreach (ISymbolNode node in mNodeList)
     {
         node.SymbolExpand(aCmd);
     }
 }
Ejemplo n.º 2
0
 //------------------------------------------------------------
 // 子ノードの展開。
 private void expandChilds(SymbolExpandCmdKind aCmd)
 {
     foreach (var node in mNodeList)
     {
         // 展開
         node.SymbolExpand(aCmd);
     }
 }
Ejemplo n.º 3
0
 //------------------------------------------------------------
 // 展開命令。
 public bool SymbolExpand(SymbolTree.ErrorInfoHolder aHolder, SymbolExpandCmdKind aCmd)
 {
     foreach (ISymbolNode node in mNodeList)
     {
         if (!node.SymbolExpand(aHolder, aCmd))
         {
             return(false);
         }
     }
     return(true);
 }
Ejemplo n.º 4
0
        //------------------------------------------------------------
        // 展開命令。
        public bool SymbolExpand(SymbolTree.ErrorInfoHolder aErrorHolder, SymbolExpandCmdKind aCmd)
        {
            switch (aCmd)
            {
            case SymbolExpandCmdKind.TypeNode:
                return(expandTypeNode(aErrorHolder));

            case SymbolExpandCmdKind.FunctionNodeDecl:
                return(expandFunctionNodeDecl(aErrorHolder));

            default:
                return(true);
            }
        }
Ejemplo n.º 5
0
        //------------------------------------------------------------
        // シンボルを展開する。
        public bool SymbolExpand(SymbolTree.ErrorInfoHolder aHolder, SymbolExpandCmdKind aCmdKind)
        {
            if (aCmdKind != SymbolExpandCmdKind.FunctionNodeImpl)
            {// 関数実装以外なら何もしない
                return(true);
            }

            mLocalVariableSymbolNodes = new List <VariableSymbolNode>();
            ISymbolNode prevNode = this;

            {// 引数
                foreach (ArgTypeInfo argTypeInfo in mArgTypeInfos)
                {
                    VariableSymbolNode node = new VariableSymbolNode(
                        prevNode
                        , argTypeInfo.Ident
                        , argTypeInfo.TypeInfo
                        );
                    prevNode = node;
                    mLocalVariableSymbolNodes.Add(node);
                }
            }

            {// Statement解析
                SemanticAnalyzeComponent comp = new SemanticAnalyzeComponent(
                    aHolder
                    , mModuleContext
                    , mParent
                    , new SemanticAnalyzeComponent.OnSymbolNodeCreate(onSymbolNodeCreate)
                    , prevNode
                    );
                if (!mFunctionDecl.Statement().SemanticAnalyze(comp))
                {
                    return(false);
                }
            }

            return(true);
        }
Ejemplo n.º 6
0
        //------------------------------------------------------------
        // 展開命令。
        public void SymbolExpand(SymbolExpandCmdKind aCmd)
        {
            switch (aCmd)
            {
            case SymbolExpandCmdKind.TypeNode:
                expandTypeNode();
                break;

            case SymbolExpandCmdKind.FunctionNodeDecl:
                expandFunctionNodeDecl();
                break;

            case SymbolExpandCmdKind.VariableNode:
                expandVariableNode();
                break;

            case SymbolExpandCmdKind.FunctionNodeImpl:
                expandChilds(SymbolExpandCmdKind.FunctionNodeImpl);
                break;

            default:
                break;
            }
        }
Ejemplo n.º 7
0
 //------------------------------------------------------------
 // シンボルを展開する。
 public bool SymbolExpand(SymbolTree.ErrorInfoHolder aHolder, SymbolExpandCmdKind aCmdKind)
 {
     // todo:impl
     return(true);
 }
Ejemplo n.º 8
0
        //------------------------------------------------------------
        // シンボルを展開する。
        public void SymbolExpand(SymbolExpandCmdKind aCmdKind)
        {
            if (aCmdKind != SymbolExpandCmdKind.FunctionNodeImpl)
            {// 関数実装以外なら何もしない
                return;
            }

            // BCFunction作成
            mBCFunction = mBCObjectType.GenerateFunction(this);

            // コンポーネント
            SemanticAnalyzeComponent comp = new SemanticAnalyzeComponent(
                mBCFunction
                , mParent
                , this
                );

            // コピーするレジスタの数をメモする変数
            byte copyRegCount = 0;

            {// 関数内部のスコープ
                // スコープ追加
                comp.ScopeEnter();

                // 戻り値対応
                if (mReturnTypeInfo.Symbol.GetKind() != TypeInfo.TypeSymbol.Kind.BuiltIn ||
                    mReturnTypeInfo.Symbol.GetBuiltInType() != BuiltInType.Void
                    )
                {// void以外なら。
                    // todo: いろんな型の対応
                    // 組み込み型のint,boolしか対応していません。
                    if (mReturnTypeInfo.Symbol.GetKind() != TypeInfo.TypeSymbol.Kind.BuiltIn ||
                        (mReturnTypeInfo.Symbol.GetBuiltInType() != BuiltInType.SInt32 && mReturnTypeInfo.Symbol.GetBuiltInType() != BuiltInType.Bool)
                        )
                    {
                        comp.ThrowErrorException(SymbolTree.ErrorKind.NOT_SUPPORTED_TYPENAME, mReturnTypeInfo.Symbol.GetToken());
                    }

                    // EI作成
                    var returnEI = EvaluateInfo.CreateAsValue(mReturnTypeInfo);

                    // SRを確保
                    returnEI.SR = comp.SRReserve();

                    // 戻り値として登録 
                    comp.ReturnEvaluateInfoSet(returnEI);

                    // コピーするレジスタカウントアップ
                    ++copyRegCount;
                }

                // this
                if (!mFunctionDecl.IsStatic())
                {
                    // TypeInfo作成
                    var ti = comp.CreateTypeInfo(
                        new TypePath(new IdentPath(mParent))
                        , mFunctionDecl.IsConst()
                        , true
                        );

                    // ダミートークンを作成
                    var token = new Token();
                    token.Value     = Token.Kind.KeyThis;
                    token.pos       = GetIdentifier().Token.pos;
                    token.posColumn = GetIdentifier().Token.posColumn;
                    token.posLine   = GetIdentifier().Token.posLine;

                    // シンボルノードを作成
                    VariableSymbolNode symbolNode = new VariableSymbolNode(
                        comp.PrevSymbolNode()
                        , new Identifier(token)
                        , ti
                        );

                    // ノードを追加
                    comp.AddSymbolNode(symbolNode);

                    // 評価ノードを作成
                    var evaluateNode = new EvaluateNode(symbolNode);

                    // 評価イベント送信
                    evaluateNode.SendEvent(comp, EvaluateNodeEventKind.Analyze);
                    evaluateNode.SendEvent(comp, EvaluateNodeEventKind.Evaluate);

                    // 追加
                    comp.AddEvaluatedSymbolNode(new EvaluatedSymbolNode(symbolNode, evaluateNode));

                    // コピーするレジスタカウントアップ
                    ++copyRegCount;
                }

                // 引数
                foreach (var arg in mArgTypeInfos)
                {
                    // シンボルノードを作成
                    VariableSymbolNode symbolNode = new VariableSymbolNode(
                        comp.PrevSymbolNode()
                        , arg.Ident
                        , arg.TypeInfo
                        );

                    // ノードを追加
                    comp.AddSymbolNode(symbolNode);

                    // 評価ノードを作成
                    var evaluateNode = new EvaluateNode(symbolNode);

                    // 評価イベント送信
                    evaluateNode.SendEvent(comp, EvaluateNodeEventKind.Analyze);
                    evaluateNode.SendEvent(comp, EvaluateNodeEventKind.Evaluate);

                    // 追加
                    comp.AddEvaluatedSymbolNode(new EvaluatedSymbolNode(symbolNode, evaluateNode));

                    // コピーするレジスタカウントアップ
                    ++copyRegCount;
                }

                {// Statement
                    // スコープに入る
                    comp.ScopeEnter();

                    // Returnラベル確保・登録
                    BCLabel labelReturn = comp.BCFunction.LabelCreate();
                    comp.RegisterLabelReturn(labelReturn);

                    // 解析
                    mFunctionDecl.Statement().SemanticAnalyze(comp);

                    // スコープから出る
                    comp.ScopeLeave();

                    // Returnラベル挿入
                    comp.BCFunction.LabelInsert(labelReturn);
                }

                // スコープ終了
                comp.ScopeLeave();
            }

            // 関数命令を追加
            // todo: レジスタ使いすぎチェック
            mBCFunction.PushFrontOPCode_CU1_CU1(BCOpCode.OpType.FENTER, (byte)comp.SRPeakCount(), copyRegCount);
            mBCFunction.AddOPCode_CU1(BCOpCode.OpType.FLEAVE, (byte)comp.SRPeakCount());

            // ラベル解決
            mBCFunction.LabelResolve();
        }
Ejemplo n.º 9
0
 //------------------------------------------------------------
 // 展開命令
 public void SymbolExpand(SymbolExpandCmdKind cmd)
 {
     mTypeNode.SymbolExpand(cmd);
 }
Ejemplo n.º 10
0
 //------------------------------------------------------------
 // 展開命令
 public bool SymbolExpand(SymbolTree.ErrorInfoHolder holder, SymbolExpandCmdKind cmd)
 {
     return(mTypeNode.SymbolExpand(holder, cmd));
 }
Ejemplo n.º 11
0
 //------------------------------------------------------------
 // シンボルを展開する。
 public void SymbolExpand(SymbolExpandCmdKind aCmdKind)
 {
     // todo: impl
 }