예제 #1
0
        public override void Set_作用域(作用域 作用域)
        {
            base.Set_作用域(作用域);

            作用域 小括号作用域 = new 作用域();

            for (int i = 0; i < this.小括号表达式s.Length; i++)
            {
                表达式 express = this.小括号表达式s[i];

                if (express == null)
                {
                    continue;
                }

                变量声明和初始化 变量声明 = express as 变量声明和初始化;

                if (变量声明 != null)
                {
                    小括号作用域.Add_变量定义(变量声明, 变量声明.chars);
                }

                express.Set_作用域(小括号作用域);
            }

            小括号作用域.Set_作用域(作用域);
            this.子句.Set_作用域(小括号作用域);
        }
예제 #2
0
        private static 变量声明和初始化语句 Parse_变量声明和初始化_语句(char[] chars, int beginIndex, int endIndex, out int 语句结束位置)
        {
            语句结束位置 = -1;

            StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);

            if (span.isEmpty)
            {
                return(null);
            }

            语句结束位置 = Parser.Find_单引号对双引号对以外的内容(chars, span.iLeft, span.iRight, ';');

            if (语句结束位置 == -1)
            {
                return(null);
            }

            变量声明和初始化 变量声明 = Parse_变量声明(chars, span.iLeft, 语句结束位置 - 1);

            if (变量声明 == null)
            {
                return(null);
            }

            return(new 变量声明和初始化语句(变量声明));
            //变量 变量 = 表达式 as 变量;

            //if (变量 != null)
            //{
            //    return new 变量声明语句(new string(chars, beginIndex, 类型结束的位置的下一个字符位置 - beginIndex), 变量.name, 星号Count, null);
            //}

            //赋值 赋值 = 表达式 as 赋值;

            //if (赋值 != null)
            //{
            //    变量 = 赋值.等号左边的表达式 as 变量;

            //    if (变量 != null)
            //    {
            //        赋值语句 = new 赋值语句(赋值);
            //        return new 变量声明语句(new string(chars, beginIndex, 类型结束的位置的下一个字符位置 - beginIndex), 变量.name, 星号Count, null);
            //    }

            //    数组元素 数组元素 = 赋值.等号左边的表达式 as 数组元素;

            //    if (数组元素 != null)
            //    {
            //        变量 = 数组元素.左边的表达式 as 变量;

            //        if (变量 != null)
            //        赋值语句 = new 赋值语句(new 赋值());
            //        return new 变量声明语句(new string(chars, beginIndex, 类型结束的位置的下一个字符位置 - beginIndex), 变量.name, 星号Count, null);
            //    }
            //}
        }
예제 #3
0
        public void Add_变量定义(变量声明和初始化 变量声明, char[] chars)
        {
            if (this.dic变量声明.ContainsKey(变量声明.name))
            {
                throw new 语法错误_Exception("在当前作用域内已定义了名为 \"" + 变量声明.name + "\" 的变量 。", chars, 变量声明.变量名位置);
            }
            //throw new 语法错误_Exception("参数名 \"" + 变量声明.name + "\" 重复 。", chars, 变量声明.变量名位置);

            变量声明.Set_作用域(this);

            this.dic变量声明.Add(变量声明.name, 变量声明);
        }
예제 #4
0
        private static 表达式[] Parse_小括号(char[] chars, int 左小括号位置, int 右小括号位置)
        {
            //作用域 形参列表 = new 作用域();

            表达式[] 小括号表达式s = new 表达式[3];

            StrSpan span = StrUtil.Trim(chars, 左小括号位置 + 1, 右小括号位置 - 1, Parser._whiteSpaces);

            if (span.isEmpty)
            {
                throw new 语法错误_Exception("for() 小括号内应是两个分号 。", chars, 左小括号位置);
            }
            //return exppressArr;

            List <StrSpan> list = Parser.在_单引号双引号_以外_Split(chars, span.iLeft, span.iRight, ';');

            if (list.Count != 3)
            {
                throw new 语法错误_Exception("for() 小括号内应是两个分号 。", chars, 左小括号位置);
            }

            StrSpan spanExpress;

            for (int i = 0; i < list.Count; i++)
            {
                spanExpress = list[i];

                变量声明和初始化 变量声明 = 语句_Parser.Parse_变量声明(chars, spanExpress.iLeft, spanExpress.iRight);

                if (变量声明 != null)
                {
                    小括号表达式s[i] = 变量声明;
                    continue;
                }

                表达式 表达式 = 表达式_Parser.Parse(chars, spanExpress.iLeft, spanExpress.iRight);

                小括号表达式s[i] = 表达式;
            }

            return(小括号表达式s);
        }
예제 #5
0
        private static 字段声明 Parse_字段(char[] chars, StrSpan span)
        {
            if (span.isEmpty)
            {
                throw new InnerCException("缺少字段定义 。", chars, span.iLeft);
            }

            //span = StrUtil.Trim(chars, span.iLeft, span.iRight, Parser._whiteSpaces);

            //if (span.isEmpty)
            //    throw new InnerCException("缺少字段定义 。", chars, span.iLeft);

            变量声明和初始化 变量声明 = 语句_Parser.Parse_变量声明(chars, span.iLeft, span.iRight);

            if (变量声明 == null)
            {
                throw new InnerCException("错误的字段定义 。", chars, span.iLeft);
            }

            return(变量声明.To_字段声明());
        }
예제 #6
0
        private static void Parse_全局变量(ParseResult r, char[] chars, 第一层_代码块 代码块)
        {
            //块作用域 块 = 语句_Parser.Parse_块作用域(chars, 代码块.iLeft, 代码块.iRight);

            List <StrSpan> list = Parser.在_单引号双引号_以外_Split(chars, 代码块.iLeft, 代码块.iRight, ';');

            StrSpan span;

            for (int i = 0; i < list.Count; i++)
            {
                span = list[i];

                if (span.isEmpty)
                {
                    continue;
                }

                if (i == list.Count - 1)
                {
                    throw new 语法错误_Exception("未结束的语句,缺少分号 \";\" 。", chars, span.iRight);
                }


                变量声明和初始化 变量声明 = 语句_Parser.Parse_变量声明(chars, span.iLeft, span.iRight);

                if (变量声明 == null)
                {
                    throw new 语法错误_Exception("无效的表达式 。", chars, span.iLeft);
                }

                r.全局变量.Add_变量定义(变量声明, chars);
                //if (r.dic全局变量.ContainsKey(变量声明.name))
                //if (r.全局变量.dic变量声明.ContainsKey(变量声明.name))
                //    throw new 语法错误_Exception("已定义了名为 \"" + 变量声明.name + "\" 的 全局变量 。", chars, 变量声明.变量名位置);

                //r.全局变量.dic变量声明.Add(变量声明.name, 变量声明.To_全局变量());
                //r.dic全局变量.Add(变量声明.name, 变量声明.To_全局变量());
            }
        }
 public 变量声明和初始化语句(变量声明和初始化 变量声明)
 {
     this.变量声明 = 变量声明;
 }
예제 #8
0
        public static 块作用域 Parse_块作用域(char[] chars, int beginIndex, int endIndex, ParseOptions option, out int j)
        {
            j = -1;

            块作用域 块 = new 块作用域();

            StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);

            if (span.isEmpty)
            {
                return(块);
            }

            //int j;

            //List<语句> list语句 = new List<语句>();


            for (int i = span.iLeft; ; i = j + 1)
            {
                span = StrUtil.Trim(chars, i, span.iRight, Parser._whiteSpaces);

                if (span.isEmpty)
                {
                    break;
                }
                //if (Check_变量类型_KeyWord(chars, i, 代码段.iRight, "int"))
                //{
                //    语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, "int", out j, list变量声明);
                //}
                //else if (Check_变量类型_KeyWord(chars, i, 代码段.iRight, "float"))
                //{
                //    语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, "float", out j, list变量声明);
                //}
                //else if (Check_变量类型_KeyWord(chars, i, 代码段.iRight, "double"))
                //{
                //    语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, "double", out j, list变量声明);
                //}
                //else if (Check_变量类型_KeyWord(chars, i, 代码段.iRight, "char"))
                //{
                //    语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, "char", out j, list变量声明);
                //}
                //if (Check_if_while_KeyWord(chars, i, 代码段.iRight, "if"))
                //{
                //    语句 = Parse_if_语句(chars, i, 代码段.iRight, out j, list变量声明);
                //}
                //else if (Check_if_while_KeyWord(chars, i, 代码段.iRight, "while"))
                //{
                //    语句 = Parse_while_语句(chars, i, 代码段.iRight, out j, list变量声明);
                //}
                //else if (Check_return_KeyWord(chars, i, 代码段.iRight))
                //{
                //    语句 = Parse_return_语句(chars, i, 代码段.iRight, out j, list变量声明);
                //}
                //else if (Check_变量声明(chars, i, 代码段.iRight, out 变量类型))
                //{
                //    语句 = Parse_变量声明和赋值_语句(chars, i, 代码段.iRight, 变量类型, out j, list变量声明);
                //}
                //else
                //{
                //    语句 = Parse_表达式_语句(chars, i, 代码段.iRight, out j, list变量声明);
                //}

                if_语句 if_语句 = if_语句_Parser.Parse(chars, span.iLeft, span.iRight, out j);

                if (if_语句 != null)
                {
                    if_语句.Set_作用域(块);

                    块.list语句.Add(if_语句);

                    continue;
                }

                while_语句 while_语句 = while_语句_Parser.Parse(chars, span.iLeft, span.iRight, out j);

                if (while_语句 != null)
                {
                    while_语句.Set_作用域(块);

                    块.list语句.Add(while_语句);

                    continue;
                }

                break_语句 break_语句 = Parse_break_语句(chars, span.iLeft, span.iRight, out j);

                if (break_语句 != null)
                {
                    break_语句.Set_作用域(块);

                    块.list语句.Add(break_语句);

                    continue;
                }

                return_语句 return_语句 = Parse_return_语句(chars, span.iLeft, span.iRight, out j);

                if (return_语句 != null)
                {
                    return_语句.Set_作用域(块);

                    块.list语句.Add(return_语句);

                    continue;
                }


                变量声明和初始化语句 变量声明语句 = Parse_变量声明和初始化_语句(chars, span.iLeft, span.iRight, out j);

                if (变量声明语句 != null)
                {
                    变量声明和初始化 变量声明 = 变量声明语句.变量声明;

                    if (块.dic变量声明.ContainsKey(变量声明.name))
                    {
                        throw new InnerCException("在当前作用域范围内已定义了名为 \"" + 变量声明.name + "\" 的变量 。", chars, 变量声明.变量位置_iLeft);
                    }

                    变量声明语句.Set_作用域(块);

                    块.dic变量声明.Add(变量声明.name, 变量声明);

                    块.list语句.Add(变量声明语句);

                    continue;
                }


                表达式语句 表达式语句 = Parse_表达式语句(chars, span.iLeft, span.iRight, out j);

                if (表达式语句 != null)
                {
                    表达式语句.Set_作用域(块);

                    块.list语句.Add(表达式语句);
                }



                if (option == ParseOptions.Parse_第一个语句)
                {
                    break;
                }
            }

            return(块);
        }
예제 #9
0
        public static 变量声明和初始化 Parse_变量声明(char[] chars, int beginIndex, int endIndex)
        {
            StrSpan span = StrUtil.Trim(chars, beginIndex, endIndex, Parser._whiteSpaces);

            if (span.isEmpty)
            {
                return(null);
            }

            char c = chars[span.iLeft];

            if (!(c == '_' || StrUtil.IsLetter(c)))
            {
                return(null);
            }

            int 类型结束的位置的下一个字符位置 = Parser.向右寻找_不是_下划线字母数字_的字符(chars, span.iLeft + 1, span.iRight);

            if (类型结束的位置的下一个字符位置 == -1)
            {
                return(null);
            }

            c = chars[类型结束的位置的下一个字符位置];

            if (!(StrUtil.IsOneOf(c, Parser._whiteSpaces)) || c == '*')
            {
                return(null);
            }

            int 类型后不是空白和星号的位置 = StrUtil.FindForwardUntilNot(chars, 类型结束的位置的下一个字符位置, span.iRight, Parser._whiteSpaces和星号);

            if (类型后不是空白和星号的位置 == -1)
            {
                return(null);
            }

            c = chars[类型后不是空白和星号的位置];

            if (!(c == '_' || StrUtil.IsLetter(c)))
            {
                return(null);
            }

            int 星号Count = 0;

            for (int i = 类型结束的位置的下一个字符位置; i < 类型后不是空白和星号的位置; i++)
            {
                if (chars[i] == '*')
                {
                    星号Count++;
                }
            }

            表达式 表达式 = 表达式_Parser.Parse(chars, 类型后不是空白和星号的位置, span.iRight);

            int 类型字符串长度 = 类型结束的位置的下一个字符位置 - span.iLeft;

            变量声明和初始化 变量声明 = Parse_普通变量声明(chars, 表达式, span.iLeft, 类型字符串长度, 星号Count);

            if (变量声明 != null)
            {
                return(变量声明);
            }

            变量声明 = Parse_数组变量声明(chars, 表达式, span.iLeft, 类型字符串长度, 星号Count);

            if (变量声明 != null)
            {
                return(变量声明);
            }

            return(null);
        }