Beispiel #1
0
 /// <summary>
 /// 更新某个节点的子树的信息
 /// </summary>
 /// <param name="subTreeRoot">子树根节点</param>
 /// <param name="disposeFlag">操作标记:true - 删除操作; false - 更新操作</param>
 private void update(KagaNode subTreeRoot, bool disposeFlag)
 {
     this.DFS(
         match:
         (x) =>
     {
         // 删除子树时
         if (disposeFlag == true)
         {
             return(x.isNewBlock == true);
         }
         // 更新信息时
         else
         {
             return(x != null);
         }
     },
         func:
         (x) =>
     {
         // 消除符号表
         if (disposeFlag == true)
         {
             return(this.disposeChildrenSymbolTable(x));
         }
         // 更新信息
         else
         {
             return(this.updateChildrenInfo(x));
         }
     },
         unique: false,
         startNode: subTreeRoot
         );
 }
Beispiel #2
0
 /// <summary>
 /// 在指定的深度和广度处插入一个节点,并生成一个语句块
 /// </summary>
 /// <param name="dep">插入深度</param>
 /// <param name="bre">插入广度</param>
 /// <param name="obj">待插入节点</param>
 /// <returns>插入是否成功</returns>
 public bool insertBlockNode(int dep, int bre, KagaNode obj)
 {
     // 生成它的孩子节点,追加代码块光标节点、代码块右边界
     obj.children.Add(new KagaNode(obj.anodeName + "___PADDING_CURSOR", NodeType.PILE__PADDING_CURSOR, dep + 1, 0, obj));
     obj.children.Add(new KagaNode(obj.anodeName + "___BRIGHT_BRUCKET", NodeType.PILE__BRIGHT_BRUCKET, dep + 1, 1, obj));
     // 插入到代码树
     return(this.insertNode(dep, bre, obj));
 }
Beispiel #3
0
 /// <summary>
 /// 层次符号表的构造器
 /// </summary>
 /// <param name="tableDepth">符号表深度</param>
 /// <param name="belonging">符号表的属节点</param>
 public KagaTable(int tableDepth, KagaNode belonging)
 {
     this.depth = tableDepth;
     this.belong = belonging;
     this.symbols = new List<KagaVar>();
     this.prefix = String.Format("{0}_{1}_{2}", Consta.prefix_var, this.depth, this.belong.index);
     // 把自己追加到符号表里
     this.symbolMana = SymbolManager.getInstance();
     this.symbolMana.addSymbolTable(this);
 }
Beispiel #4
0
 /// <summary>
 /// 层次符号表的构造器
 /// </summary>
 /// <param name="tableDepth">符号表深度</param>
 /// <param name="belonging">符号表的属节点</param>
 public KagaTable(int tableDepth, KagaNode belonging)
 {
     this.depth   = tableDepth;
     this.belong  = belonging;
     this.symbols = new List <KagaVar>();
     this.prefix  = String.Format("{0}_{1}_{2}", Consta.prefix_var, this.depth, this.belong.index);
     // 把自己追加到符号表里
     this.symbolMana = SymbolManager.getInstance();
     this.symbolMana.addSymbolTable(this);
 }
Beispiel #5
0
        /// <summary>
        /// 删除一张符号表
        /// </summary>
        /// <param name="belonging">待删除符号表的属节点</param>
        /// <returns>操作成功与否</returns>
        public bool deleteSymbolTable(KagaNode belonging)
        {
            KagaTable kt;

            if ((kt = this.tableContainer.Find((x) => x.belong == belonging)) != null)
            {
                this.tableContainer.Remove(kt);
                return(true);
            }
            return(false);
        }
Beispiel #6
0
 /// <summary>
 /// 更新某节点所有直接孩子的符号表
 /// </summary>
 /// <param name="father">待处理节点</param>
 /// <returns>返回参数自身</returns>
 private KagaNode disposeChildrenSymbolTable(KagaNode father)
 {
     for (int i = 0; i < father.children.Count; i++)
     {
         if (father.children[i].symbolTable != null)
         {
             symbolMana.deleteSymbolTable(father.children[i]);
             father.children[i].symbolTable = null;
         }
     }
     return(father);
 }
Beispiel #7
0
 /// <summary>
 /// 更新某节点所有直接孩子的深度和广度信息
 /// </summary>
 /// <param name="father">待处理节点</param>
 /// <returns>返回参数自身</returns>
 private KagaNode updateChildrenInfo(KagaNode father)
 {
     for (int i = 0; i < father.children.Count; i++)
     {
         father.children[i].index = i;
         father.children[i].depth = father.depth + 1;
         if (father.children[i].isNewBlock == true)
         {
             father.children[i].symbolTable.depth = father.depth + 1;
         }
     }
     return(father);
 }
Beispiel #8
0
        /// <summary>
        /// 获得指定函数的子树根节点
        /// </summary>
        /// <param name="callname">函数名称</param>
        /// <returns>函数子树的根节点</returns>
        public KagaNode getFunRoot(string callname)
        {
            KagaNode rootNode = this.parseTree;

            foreach (KagaNode kn in rootNode.children)
            {
                if (kn.anodeName == callname)
                {
                    return(kn);
                }
            }
            return(null);
        }
Beispiel #9
0
        /// <summary>
        /// 深度优先遍历语法树,对满足条件的节点执行委托func,并返回他们
        /// </summary>
        /// <param name="match">节点匹配条件</param>
        /// <param name="startNode">搜索开始的节点</param>
        /// <param name="func">满足条件的节点处理函数</param>
        /// <param name="unique">是否命中一个节点就结束</param>
        /// <returns>符合要求的节点向量,若没有符合的节点就返回null</returns>
        public List <KagaNode> DFS(
            Predicate <KagaNode> match,
            KagaNode startNode,
            Func <KagaNode, KagaNode> func = null,
            bool unique = true)
        {
            // 如果节点为空就直接退出
            if (startNode == null)
            {
                return(null);
            }
            List <KagaNode>  resultContainer = new List <KagaNode>();
            Stack <KagaNode> iStack          = new Stack <KagaNode>();

            iStack.Push(startNode);
            KagaNode currentNode;

            while (iStack.Count > 0)
            {
                currentNode = iStack.Pop();
                // 测试当前节点
                if (match(currentNode) == true)
                {
                    // 如果有func,就进行
                    if (func != null)
                    {
                        currentNode = func(currentNode);
                    }
                    // 添加到输出缓冲
                    resultContainer.Add(currentNode);
                    // 如果保证唯一就退出
                    if (unique == true)
                    {
                        break;
                    }
                }
                // 反向追加孩子节点到栈里
                if (currentNode.children != null)
                {
                    for (int i = currentNode.children.Count - 1; i >= 0; i--)
                    {
                        iStack.Push(currentNode.children[i]);
                    }
                }
            }
            // 没有匹配项就返回null
            return(resultContainer.Count > 0 ? resultContainer : null);
        }
Beispiel #10
0
        /// <summary>
        /// 把指定的深度和广度处的节点移除掉,并销毁掉它的符号表
        /// </summary>
        /// <param name="dnode">待删除节点</param>
        /// <returns>删除是否成功</returns>
        public bool deleteNode(KagaNode dnode)
        {
            // 找到双亲
            KagaNode pNode = dnode.parent;

            if (pNode == null)
            {
                return(false);
            }
            // 移除自己和子代的符号表
            this.update(dnode, true);
            pNode.children.Remove(dnode);
            // 更新姐妹和姐妹后代的信息
            this.updateChildrenInfo(pNode);
            return(true);
        }
Beispiel #11
0
        /// <summary>
        /// 初始化代码管理器,获得一棵带有root和main函数块的树
        /// </summary>
        public void initCodeTree()
        {
            // 建立一个根节点
            this.parseTree = new KagaNode("TreeRoot", NodeType.PILE__BLOCK__ROOT, 0, 0, null);
            // 为根节点追加一个main函数节点
            KagaNode     mainFunNode = new KagaNode("main", NodeType.PILE__BLOCK__FUNCTION, 1, 0, this.parseTree);
            FunctionCell mainFunCell = new FunctionCell("main", null, VarType.VOID);

            mainFunNode.funBinding = mainFunCell;
            this.parseTree.children.Add(mainFunNode);
            // 为main函数节点追加代码块光标节点、代码块右边界
            mainFunNode.children.Add(new KagaNode("main___PADDING_CURSOR", NodeType.PILE__PADDING_CURSOR, 2, 0, mainFunNode));
            mainFunNode.children.Add(new KagaNode("main___BRIGHT_BRUCKET", NodeType.PILE__BRIGHT_BRUCKET, 2, 1, mainFunNode));
            // 追加main函数到符号管理器
            symbolMana.addFunction(mainFunCell);
        }
Beispiel #12
0
        /// <summary>
        /// 广度优先遍历语法树,对满足条件的节点执行委托func,并返回他们
        /// </summary>
        /// <param name="match">节点匹配条件</param>
        /// <param name="startNode">搜索开始的节点</param>
        /// <param name="func">满足条件的节点处理函数</param>
        /// <param name="unique">是否命中一个节点就结束</param>
        /// <returns>符合要求的节点向量,若没有符合的节点就返回null</returns>
        public List <KagaNode> BFS(
            Predicate <KagaNode> match,
            KagaNode startNode,
            Func <KagaNode, KagaNode> func = null,
            bool unique = true)
        {
            // 如果节点为空就直接退出
            if (startNode == null)
            {
                return(null);
            }
            List <KagaNode>  resultContainer = new List <KagaNode>();
            Queue <KagaNode> pendingList     = new Queue <KagaNode>();

            pendingList.Enqueue(startNode);
            while (pendingList.Count > 0)
            {
                KagaNode currentNode = pendingList.Dequeue();
                // 判断当前节点的条件
                if (match(currentNode) == true)
                {
                    // 如果有func,就进行
                    if (func != null)
                    {
                        currentNode = func(currentNode);
                    }
                    // 添加到输出缓冲
                    resultContainer.Add(currentNode);
                    // 如果条件保证唯一就返回
                    if (unique == true)
                    {
                        break;
                    }
                }
                // 节点没有后继结点就迭代
                if (currentNode.children != null)
                {
                    // 把后继节点放到队列里
                    foreach (KagaNode kn in currentNode.children)
                    {
                        pendingList.Enqueue(kn);
                    }
                }
            }
            // 如果没有满足条件的节点就返回null
            return(resultContainer.Count > 0 ? resultContainer : null);
        }
Beispiel #13
0
 /// <summary>
 /// 广度优先遍历语法树,对满足条件的节点执行委托func,并返回他们
 /// </summary>
 /// <param name="match">节点匹配条件</param>
 /// <param name="startNode">搜索开始的节点</param>
 /// <param name="func">满足条件的节点处理函数</param>
 /// <param name="unique">是否命中一个节点就结束</param>
 /// <returns>符合要求的节点向量,若没有符合的节点就返回null</returns>
 public List<KagaNode> BFS(
     Predicate<KagaNode> match,
     KagaNode startNode,
     Func<KagaNode, KagaNode> func = null,
     bool unique = true)
 {
     // 如果节点为空就直接退出
     if (startNode == null)
     {
         return null;
     }
     List<KagaNode> resultContainer = new List<KagaNode>();
     Queue<KagaNode> pendingList = new Queue<KagaNode>();
     pendingList.Enqueue(startNode);
     while (pendingList.Count > 0)
     {
         KagaNode currentNode = pendingList.Dequeue();
         // 判断当前节点的条件
         if (match(currentNode) == true)
         {
             // 如果有func,就进行
             if (func != null)
             {
                 currentNode = func(currentNode);
             }
             // 添加到输出缓冲
             resultContainer.Add(currentNode);
             // 如果条件保证唯一就返回
             if (unique == true)
             {
                 break;
             }
         }
         // 节点没有后继结点就迭代
         if (currentNode.children != null)
         {
             // 把后继节点放到队列里
             foreach (KagaNode kn in currentNode.children)
             {
                 pendingList.Enqueue(kn);
             }
         }
     }
     // 如果没有满足条件的节点就返回null
     return resultContainer.Count > 0 ? resultContainer : null;
 }
Beispiel #14
0
 /// <summary>
 /// 在指定的深度和广度处插入一个节点
 /// </summary>
 /// <param name="dep">插入深度</param>
 /// <param name="bre">插入广度</param>
 /// <param name="obj">待插入节点</param>
 /// <returns>插入是否成功</returns>
 public bool insertNode(int dep, int bre, KagaNode obj)
 {
     // 插入深度必须大于0
     if (dep < 1)
     {
         return(false);
     }
     if (obj.parent == null || obj.parent.children.Count < bre)
     {
         return(false);
     }
     // 更新自己的信息
     obj.depth = dep;
     obj.index = bre;
     // 接下来找姐妹中自己的排位并插入
     obj.parent.children.Insert(bre, obj);
     // 更新子树信息
     this.update(obj.parent, false);
     return(true);
 }
Beispiel #15
0
 /// <summary>
 /// 删除一张符号表
 /// </summary>
 /// <param name="belonging">待删除符号表的属节点</param>
 /// <returns>操作成功与否</returns>
 public bool deleteSymbolTable(KagaNode belonging)
 {
     KagaTable kt;
     if ((kt = this.tableContainer.Find((x) => x.belong == belonging)) != null)
     {
         this.tableContainer.Remove(kt);
         return true;
     }
     return false;
 }
Beispiel #16
0
        /// <summary>
        /// 获得满足指定条件的广度优先遍历得到的第一个根节点的子树
        /// </summary>
        /// <param name="match">匹配条件</param>
        /// <param name="startNode">开始搜索的节点</param>
        /// <returns>满足条件的子树根节点</returns>
        public KagaNode getSubTree(Predicate <KagaNode> match, KagaNode startNode)
        {
            List <KagaNode> res = this.BFS(match, startNode, null, true);

            return(res != null ? res[0] : null);
        }
Beispiel #17
0
 /// <summary>
 /// 获得指定节点下满足指定条件的第一个直接子节点
 /// </summary>
 /// <param name="match">匹配条件</param>
 /// <param name="startNode">开始搜索的节点</param>
 /// <returns>满足条件的第一个节点</returns>
 public KagaNode getChild(Predicate <KagaNode> match, KagaNode startNode)
 {
     return(startNode.children.Find(match));
 }
Beispiel #18
0
 /// <summary>
 /// 获得指定节点下满足指定条件的第一个直接子节点
 /// </summary>
 /// <param name="match">匹配条件</param>
 /// <param name="startNode">开始搜索的节点</param>
 /// <returns>满足条件的第一个节点</returns>
 public KagaNode getChild(Predicate<KagaNode> match, KagaNode startNode)
 {
     return startNode.children.Find(match);
 }
Beispiel #19
0
 /// <summary>
 /// 深度优先遍历语法树,对满足条件的节点执行委托func,并返回他们
 /// </summary>
 /// <param name="match">节点匹配条件</param>
 /// <param name="startNode">搜索开始的节点</param>
 /// <param name="func">满足条件的节点处理函数</param>
 /// <param name="unique">是否命中一个节点就结束</param>
 /// <returns>符合要求的节点向量,若没有符合的节点就返回null</returns>
 public List<KagaNode> DFS(
     Predicate<KagaNode> match,
     KagaNode startNode,
     Func<KagaNode, KagaNode> func = null,
     bool unique = true)
 {
     // 如果节点为空就直接退出
     if (startNode == null)
     {
         return null;
     }
     List<KagaNode> resultContainer = new List<KagaNode>();
     Stack<KagaNode> iStack = new Stack<KagaNode>();
     iStack.Push(startNode);
     KagaNode currentNode;
     while (iStack.Count > 0)
     {
         currentNode = iStack.Pop();
         // 测试当前节点
         if (match(currentNode) == true)
         {
             // 如果有func,就进行
             if (func != null)
             {
                 currentNode = func(currentNode);
             }
             // 添加到输出缓冲
             resultContainer.Add(currentNode);
             // 如果保证唯一就退出
             if (unique == true)
             {
                 break;
             }
         }
         // 反向追加孩子节点到栈里
         if (currentNode.children != null)
         {
             for (int i = currentNode.children.Count - 1; i >= 0; i--)
             {
                 iStack.Push(currentNode.children[i]);
             }
         }
     }
     // 没有匹配项就返回null
     return resultContainer.Count > 0 ? resultContainer : null;
 }
Beispiel #20
0
 /// <summary>
 /// 初始化代码管理器,获得一棵带有root和main函数块的树
 /// </summary>
 public void initCodeTree()
 {
     // 建立一个根节点
     this.parseTree = new KagaNode("TreeRoot", NodeType.PILE__BLOCK__ROOT, 0, 0, null);
     // 为根节点追加一个main函数节点
     KagaNode mainFunNode = new KagaNode("main", NodeType.PILE__BLOCK__FUNCTION, 1, 0, this.parseTree);
     FunctionCell mainFunCell = new FunctionCell("main", null, VarType.VOID);
     mainFunNode.funBinding = mainFunCell;
     this.parseTree.children.Add(mainFunNode);
     // 为main函数节点追加代码块光标节点、代码块右边界
     mainFunNode.children.Add(new KagaNode("main___PADDING_CURSOR", NodeType.PILE__PADDING_CURSOR, 2, 0, mainFunNode));
     mainFunNode.children.Add(new KagaNode("main___BRIGHT_BRUCKET", NodeType.PILE__BRIGHT_BRUCKET, 2, 1, mainFunNode));
     // 追加main函数到符号管理器
     symbolMana.addFunction(mainFunCell);
 }
Beispiel #21
0
 /// <summary>
 /// 获得满足指定条件的广度优先遍历得到的第一个根节点的子树
 /// </summary>
 /// <param name="match">匹配条件</param>
 /// <param name="startNode">开始搜索的节点</param>
 /// <returns>满足条件的子树根节点</returns>
 public KagaNode getSubTree(Predicate<KagaNode> match, KagaNode startNode)
 {
     List<KagaNode> res = this.BFS(match, startNode, null, true);
     return res != null ? res[0] : null;
 }
Beispiel #22
0
 /// <summary>
 /// 在指定的深度和广度处插入一个节点
 /// </summary>
 /// <param name="dep">插入深度</param>
 /// <param name="bre">插入广度</param>
 /// <param name="obj">待插入节点</param>
 /// <returns>插入是否成功</returns>
 public bool insertNode(int dep, int bre, KagaNode obj)
 {
     // 插入深度必须大于0
     if (dep < 1)
     {
         return false;
     }
     if (obj.parent == null || obj.parent.children.Count < bre)
     {
         return false;
     }
     // 更新自己的信息
     obj.depth = dep;
     obj.index = bre;
     // 接下来找姐妹中自己的排位并插入
     obj.parent.children.Insert(bre, obj);
     // 更新子树信息
     this.update(obj.parent, false);
     return true;
 }
Beispiel #23
0
 /// <summary>
 /// 在指定的深度和广度处插入一个节点,并生成一个语句块
 /// </summary>
 /// <param name="dep">插入深度</param>
 /// <param name="bre">插入广度</param>
 /// <param name="obj">待插入节点</param>
 /// <returns>插入是否成功</returns>
 public bool insertBlockNode(int dep, int bre, KagaNode obj)
 {
     // 生成它的孩子节点,追加代码块光标节点、代码块右边界
     obj.children.Add(new KagaNode(obj.anodeName + "___PADDING_CURSOR", NodeType.PILE__PADDING_CURSOR, dep + 1, 0, obj));
     obj.children.Add(new KagaNode(obj.anodeName + "___BRIGHT_BRUCKET", NodeType.PILE__BRIGHT_BRUCKET, dep + 1, 1, obj));
     // 插入到代码树
     return this.insertNode(dep, bre, obj);
 }
Beispiel #24
0
 /// <summary>
 /// 更新某节点所有直接孩子的符号表
 /// </summary>
 /// <param name="father">待处理节点</param>
 /// <returns>返回参数自身</returns>
 private KagaNode disposeChildrenSymbolTable(KagaNode father)
 {
     for (int i = 0; i < father.children.Count; i++)
     {
         if (father.children[i].symbolTable != null)
         {
             symbolMana.deleteSymbolTable(father.children[i]);
             father.children[i].symbolTable = null;
         }
     }
     return father;
 }
Beispiel #25
0
 /// <summary>
 /// 更新某个节点的子树的信息
 /// </summary>
 /// <param name="subTreeRoot">子树根节点</param>
 /// <param name="disposeFlag">操作标记:true - 删除操作; false - 更新操作</param>
 private void update(KagaNode subTreeRoot, bool disposeFlag)
 {
     this.DFS(
         match:
         (x) =>
         {
             // 删除子树时
             if (disposeFlag == true)
             {
                 return x.isNewBlock == true;
             }
             // 更新信息时
             else
             {
                 return x != null;
             }
         },
         func:
         (x) =>
         {
             // 消除符号表
             if (disposeFlag == true)
             {
                 return this.disposeChildrenSymbolTable(x);
             }
             // 更新信息
             else
             {
                 return this.updateChildrenInfo(x);
             }
         },
         unique: false,
         startNode: subTreeRoot
     );
 }
Beispiel #26
0
 /// <summary>
 /// 更新某节点所有直接孩子的深度和广度信息
 /// </summary>
 /// <param name="father">待处理节点</param>
 /// <returns>返回参数自身</returns>
 private KagaNode updateChildrenInfo(KagaNode father)
 {
     for (int i = 0; i < father.children.Count; i++)
     {
         father.children[i].index = i;
         father.children[i].depth = father.depth + 1;
         if (father.children[i].isNewBlock == true)
         {
             father.children[i].symbolTable.depth = father.depth + 1;
         }
     }
     return father;
 }
Beispiel #27
0
        /// <summary>
        /// 控制代码演绎的方法
        /// </summary>
        /// <param name="dashNode">待处理节点</param>
        /// <returns>返回参数自身</returns>
        private KagaNode pile(KagaNode dashNode)
        {
            // 跳跃掉不需要处理的节点
            if (dashNode.atype == NodeType.PILE__BLOCK__ROOT ||
                dashNode.atype == NodeType.PILE__IF ||
                dashNode.atype == NodeType.PILE__ENDIF ||
                dashNode.atype == NodeType.NOP ||
                dashNode.atype == NodeType.PILE__PADDING_CURSOR)
            {
                return(dashNode);
            }
            // 处理缩进
            if (dashNode.atype != NodeType.PILE__BRIGHT_BRUCKET)
            {
                for (int i = 0; i < this.indentCount; i++)
                {
                    pileBuilder.Append(" ");
                }
            }
            else
            {
                for (int i = 0; i < this.indentCount - 2; i++)
                {
                    pileBuilder.Append(" ");
                }
            }
            // 翻译
            switch (dashNode.atype)
            {
            // 语句块:函数
            case NodeType.PILE__BLOCK__FUNCTION:
                // 头部
                pileBuilder.Append(dashNode.funBinding.getSign(containLeftBrucket: true));
                pileBuilder.Append(Environment.NewLine);
                // 进
                indWait();
                break;

            // 语句块:条件真分支
            case NodeType.BLOCK__IF_TRUE:
                pileBuilder.Append("if (");
                if (dashNode.isConditionEx == true)
                {
                    pileBuilder.Append(dashNode.conditionEx);
                }
                else
                {
                    switch (dashNode.LopType)
                    {
                    case OperandType.VO_Switch:
                        pileBuilder.Append(Consta.switch_name + "[" + dashNode.operand1 + "]");
                        break;

                    default:
                        pileBuilder.Append(dashNode.operand1);
                        break;
                    }
                    switch (dashNode.condOperateType)
                    {
                    case CondOperatorType.等于:
                        pileBuilder.Append(" == ");
                        break;

                    case CondOperatorType.等于:
                        pileBuilder.Append(" != ");
                        break;

                    case CondOperatorType.大于:
                        pileBuilder.Append(" > ");
                        break;

                    case CondOperatorType.大于等于:
                        pileBuilder.Append(" >= ");
                        break;

                    case CondOperatorType.小于:
                        pileBuilder.Append(" < ");
                        break;

                    case CondOperatorType.小于等于:
                        pileBuilder.Append(" <= ");
                        break;

                    default:
                        pileBuilder.Append(" == ");
                        break;
                    }
                    switch (dashNode.RopType)
                    {
                    case OperandType.VO_Switch:
                        pileBuilder.Append(dashNode.operand2 == "关闭" ? "0" : "1");
                        break;

                    default:
                        pileBuilder.Append(dashNode.operand2);
                        break;
                    }
                }
                pileBuilder.Append(") {" + Environment.NewLine);
                // 进
                indWait();
                break;

            // 语句块:条件假分支
            case NodeType.BLOCK__IF_FALSE:
                pileBuilder.Append("else {" + Environment.NewLine);
                // 进
                indWait();
                break;

            // 语句块:条件循环
            case NodeType.BLOCK__WHILE:
                if (dashNode.isCondPostCheck == true)
                {
                    pileBuilder.Append("do {" + Environment.NewLine);
                    // 这里 while-end 有问题
                }
                else
                {
                    pileBuilder.Append("while (");
                    switch (dashNode.condLoopType)
                    {
                    case CondLoopType.CLT_EXPRESSION:
                        pileBuilder.Append(dashNode.conditionEx);
                        break;

                    case CondLoopType.CLT_SWITCH:
                        pileBuilder.Append(Consta.switch_name + "[");
                        pileBuilder.Append(dashNode.conditionEx + "]");
                        break;

                    case CondLoopType.CLT_FOREVER:
                    default:
                        pileBuilder.Append("true");
                        break;
                    }
                    pileBuilder.Append(") {" + Environment.NewLine);
                }
                // 进
                indWait();
                break;

            // 语句块:次数循环
            case NodeType.BLOCK__FOR:
                pileBuilder.Append("for (int __KAGA_FOR_ITER = ");
                pileBuilder.Append(dashNode.forBeginIter);
                pileBuilder.Append("; __KAGA_FOR_ITER < ");
                pileBuilder.Append(dashNode.forEndIter);
                pileBuilder.Append("; __KAGA_FOR_ITER += ");
                pileBuilder.Append(dashNode.forStep);
                pileBuilder.Append(") {" + Environment.NewLine);
                // 进
                indWait();
                break;

            // 指令:注释
            case NodeType.NOTE:
                pileBuilder.Append("/*" + Environment.NewLine);
                string[] notationCollection = dashNode.notation.Split('\n');
                foreach (string ncs in notationCollection)
                {
                    for (int i = 0; i < this.indentCount; i++)
                    {
                        pileBuilder.Append(" ");
                    }
                    pileBuilder.Append(ncs);
                }
                pileBuilder.Append(Environment.NewLine);
                for (int i = 0; i < this.indentCount; i++)
                {
                    pileBuilder.Append(" ");
                }
                pileBuilder.Append("*/" + Environment.NewLine);
                break;

            // 指令:代码片段
            case NodeType.CODEBLOCK:
                pileBuilder.Append("// __CODEBLOCK_BEGIN_" + Environment.NewLine);
                string[] myCodeCollection = dashNode.myCode.Split('\n');
                foreach (string mcs in myCodeCollection)
                {
                    for (int i = 0; i < this.indentCount; i++)
                    {
                        pileBuilder.Append(" ");
                    }
                    pileBuilder.Append(mcs);
                }
                pileBuilder.Append(Environment.NewLine);
                for (int i = 0; i < this.indentCount; i++)
                {
                    pileBuilder.Append(" ");
                }
                pileBuilder.Append("// __CODEBLOCK_END_" + Environment.NewLine);
                break;

            // 指令:中断循环
            case NodeType.BREAK:
                pileBuilder.Append("break;" + Environment.NewLine);
                break;

            // 指令:函数退出
            case NodeType.RETURN:
                switch (dashNode.funretType)
                {
                case OperandType.VO_Constant:
                case OperandType.VO_DefVar:
                case OperandType.VO_GlobalVar:
                    pileBuilder.Append("return " + dashNode.funretOperand + Consta.pile_statend + Environment.NewLine);
                    break;

                default:
                    pileBuilder.Append("return;" + Environment.NewLine);
                    break;
                }
                break;

            // 指令:变量定义
            case NodeType.DEFINE_VARIABLE:
                pileBuilder.Append(Consta.parseVarTypeToCType(dashNode.defineVarType));
                pileBuilder.Append(" " + dashNode.defineVarName + Consta.pile_statend + Environment.NewLine);
                break;

            // 指令:变量操作
            case NodeType.EXPRESSION:
                pileBuilder.Append(dashNode.operand1);
                switch (dashNode.varOperateType)
                {
                case VarOperateType.赋值为:
                    pileBuilder.Append(" = ");
                    break;

                case VarOperateType.加上:
                    pileBuilder.Append(" += ");
                    break;

                case VarOperateType.减去:
                    pileBuilder.Append(" -= ");
                    break;

                case VarOperateType.乘以:
                    pileBuilder.Append(" *= ");
                    break;

                case VarOperateType.除以:
                    pileBuilder.Append(" /= ");
                    break;

                case VarOperateType.取余:
                    pileBuilder.Append(" %= ");
                    break;

                default:
                    pileBuilder.Append(" = ");
                    break;
                }
                switch (dashNode.RopType)
                {
                case OperandType.VO_Random:
                    break;

                default:
                    pileBuilder.Append(dashNode.operand2);
                    break;
                }
                pileBuilder.Append(Consta.pile_statend + Environment.NewLine);
                break;

            // 指令:开关操作
            case NodeType.USING_SWITCHES:
                pileBuilder.Append(Consta.switch_name + "[" + dashNode.switchId + "]");
                pileBuilder.Append(" = ");
                pileBuilder.Append(dashNode.switchFlag == true ? "1" : "0");
                pileBuilder.Append(";" + Environment.NewLine);
                break;

            // 编译控制:右括弧
            case NodeType.PILE__BRIGHT_BRUCKET:
                // 缩
                indSignal();
                // 右括
                pileBuilder.Append("}" + Environment.NewLine);
                break;

            // 编译控制:插入节点
            case NodeType.PILE__PADDING_CURSOR:
                break;

            // 编译控制:条件语句体
            case NodeType.PILE__IF:
            case NodeType.PILE__ENDIF:
                break;

            default:
                break;
            }
            return(dashNode);
        }
Beispiel #28
0
 /// <summary>
 /// 把指定的深度和广度处的节点移除掉,并销毁掉它的符号表
 /// </summary>
 /// <param name="dnode">待删除节点</param>
 /// <returns>删除是否成功</returns>
 public bool deleteNode(KagaNode dnode)
 {
     // 找到双亲
     KagaNode pNode = dnode.parent;
     if (pNode == null)
     {
         return false;
     }
     // 移除自己和子代的符号表
     this.update(dnode, true);
     pNode.children.Remove(dnode);
     // 更新姐妹和姐妹后代的信息
     this.updateChildrenInfo(pNode);
     return true;
 }