//private static 表达式 Parse_函数指针调用(char[] chars, List<表达式段> list)
        //{
        //    if (list.Count < 2)
        //        return null;

        //    表达式段 段 = list[list.Count - 1];

        //    if (段.type != 表达式段_Type.小括号段)
        //        return null;

        //    表达式 express = Parse(chars, list[0].iLeft, 段.iLeft - 1);

        //    //指针取值 指针取值 = express as 指针取值;

        //    //if (指针取值 == null)
        //    //    return null;

        //    List<表达式> list实参 = Parse_实参(chars, 段);

        //    //return new 函数指针调用(指针取值, list实参);
        //    return new 函数指针调用(express, list实参);
        //}

        private static List <表达式> Parse_实参(char[] chars, 表达式段 段)
        {
            List <表达式> list实参 = new List <表达式>();

            List <StrSpan> list = 在_小括号中括号单引号双引号_之外用逗号_Split(chars, 段.iLeft + 1, 段.iRight - 1);

            if (list.Count == 1 && list[0].isEmpty)
            {
                return(list实参);
            }

            StrSpan span;

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

                if (span.isEmpty)
                {
                    throw new 语法错误_Exception("缺少参数 。", chars, span.iLeft);
                }
            }

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

                list实参.Add(表达式_Parser.Parse(chars, span.iLeft, span.iRight));
            }

            return(list实参);
        }
        private static 表达式 Parse_变量(char[] chars, List <表达式段> list)
        {
            if (list.Count > 1)
            {
                return(null);
            }

            表达式段 段 = list[0];

            if (段.type != 表达式段_Type.普通段)
            {
                return(null);
            }

            if (!Util.Check_是否_下划线字母数字_且以_下划线字母_开头(chars, 段.iLeft, 段.iRight))
            {
                return(null);
            }

            string name = new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1);

            变量 变量 = new 变量(name, chars, 段.iLeft);

            //变量.参考位置_iLeft = 段.iLeft;

            return(变量);
        }
Пример #3
0
        private static 运算符 Get_运算符(char[] chars, List <表达式段> list, int i)
        {
            表达式段 段 = list[i];

            string op = new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1);

            if (op == "*")
            {
                if (i == 0 || list[i - 1].type == 表达式段_Type.运算符段)
                {
                    return(new 运算符(op, 运算符_Type.指针取值, 6, null, 段.iLeft, 段.iRight));
                }
            }

            if (op == "&")
            {
                if (i == 0 || list[i - 1].type == 表达式段_Type.运算符段)
                {
                    return(new 运算符(op, 运算符_Type.取地址, 6, null, 段.iLeft, 段.iRight));
                }
            }

            if (op == "==" || op == ">=" || op == "<=" || op == "!=" || op == ">" || op == "<")
            {
                return(new 运算符(op, 3, 段.iLeft, 段.iRight));
            }
            if (op == "&&")
            {
                return(new 运算符(op, 2, 段.iLeft, 段.iRight));
            }
            if (op == "||")
            {
                return(new 运算符(op, 1, 段.iLeft, 段.iRight));
            }
            if (op == "!")
            {
                return(new 运算符(op, 6, 段.iLeft, 段.iRight));
            }
            if (op == "*" || op == "/")
            {
                return(new 运算符(op, 5, 段.iLeft, 段.iRight));
            }
            if (op == "+" || op == "-")
            {
                return(new 运算符(op, 4, 段.iLeft, 段.iRight));
            }



            if (op == "=")
            {
                return(new 运算符(op, 0, 段.iLeft, 段.iRight));
            }

            throw new InnerCException("未知的运算符 : \"" + new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1) + "\" 。", chars, 段.iLeft);
        }
        private static 表达式 Parse_指针字段(char[] chars, List <表达式段> list)
        {
            表达式段 段 = list[list.Count - 1];

            if (段.type != 表达式段_Type.普通段)
            {
                return(null);
            }

            string 点或箭头;

            int 点或箭头的位置 = 寻找最右边的点或箭头的位置(chars, 段.iLeft, 段.iRight, out 点或箭头);

            if (点或箭头的位置 == -1)
            {
                return(null);
            }

            if (点或箭头 != "->")
            {
                return(null);
            }

            StrSpan 右边的部分 = StrUtil.Trim(chars, 点或箭头的位置 + 2, 段.iRight, Parser._whiteSpaces);

            if (右边的部分.isEmpty)
            {
                throw new 语法错误_Exception("\".\" 后面缺少 字段名 。", chars, 点或箭头的位置);
            }

            StrSpan 左边的部分 = StrUtil.Trim(chars, 段.iLeft, 点或箭头的位置 - 1, Parser._whiteSpaces);

            if (左边的部分.isEmpty)
            {
                throw new 语法错误_Exception("\".\" 前面缺少 变量 或者 表达式 。", chars, 点或箭头的位置);
            }

            表达式 express = Parse(chars, 左边的部分.iLeft, 左边的部分.iRight);

            //if (!(express is 变量 || express is 指针取值))
            //    throw new InnerCException("\".\" 前面应该是 变量 或者 指针取值 表达式 。", chars, 左边的部分.iRight);

            if (!Util.Check_是否_下划线字母数字_且以_下划线字母_开头(chars, 右边的部分.iLeft, 右边的部分.iRight))
            {
                throw new 语法错误_Exception("无效的字段名 。", chars, 右边的部分.iLeft);
            }

            return(new 指针字段(express, new string(chars, 右边的部分.iLeft, 右边的部分.iRight - 右边的部分.iLeft + 1), chars, 点或箭头的位置));
        }
        private static 表达式 Parse_常量(char[] chars, List <表达式段> list)
        {
            if (list.Count > 1)
            {
                return(null);
            }

            表达式段 段 = list[0];

            if (段.type == 表达式段_Type.单引号段)
            {
                return(new 常量(常量_Type._char, new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1), chars, 段.iLeft));
            }

            if (段.type == 表达式段_Type.双引号段)
            {
                return(new 常量(常量_Type._String, new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1), chars, 段.iLeft));
            }

            if (段.type == 表达式段_Type.中括号段)
            {
                return(new 常量(常量_Type.中括号数组常量, new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1), chars, 段.iLeft));
            }

            if (段.type != 表达式段_Type.普通段)
            {
                return(null);
            }

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

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

            if (Util.Check_int(chars, span.iLeft, span.iRight))
            {
                return(new 常量(常量_Type._int, new string(chars, span.iLeft, span.iRight - span.iLeft + 1), chars, span.iLeft));
            }

            if (Util.Check_float(chars, span.iLeft, span.iRight))
            {
                return(new 常量(常量_Type._float, new string(chars, span.iLeft, span.iRight - span.iLeft + 1), chars, span.iLeft));
            }

            return(null);
        }
        private static 表达式 Parse_小括号表达式(char[] chars, List <表达式段> list)
        {
            if (list.Count > 1)
            {
                return(null);
            }

            表达式段 段 = list[0];

            if (段.type != 表达式段_Type.小括号段)
            {
                return(null);
            }

            return(表达式_Parser.Parse(chars, 段.iLeft + 1, 段.iRight - 1));
        }
Пример #7
0
        private static 运算符 Check_IsCast(char[] chars, 表达式段 段)
        {
            StrSpan span = StrUtil.Trim(chars, 段.iLeft + 1, 段.iRight - 1, Parser._whiteSpaces);

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

            if (!Util.Check_是否_下划线字母数字_且以_下划线字母_开头(chars, span.iLeft, span.iRight))
            {
                return(null);
            }

            string op       = new string(chars, 段.iLeft, 段.iRight - 段.iLeft + 1);
            string castType = new string(chars, span.iLeft, span.iRight - span.iLeft + 1);

            return(new 运算符(op, 运算符_Type.Cast, 6, castType, 段.iLeft, 段.iRight));
        }
        private static 表达式 Parse_函数调用(char[] chars, List <表达式段> list)
        {
            if (list.Count < 2)
            {
                return(null);
            }

            表达式段 段 = list[list.Count - 1];

            if (段.type != 表达式段_Type.小括号段)
            {
                return(null);
            }

            表达式 左边的表达式 = Parse(chars, list[0].iLeft, 段.iLeft - 1);

            变量 函数名 = 左边的表达式 as 变量;

            if (函数名 != null)
            {
                List <表达式> list实参 = Parse_实参(chars, 段);

                return(new 函数调用(函数名.name, list实参, chars, 段.iLeft));
            }

            指针取值 指针取值 = 左边的表达式 as 指针取值;

            if (指针取值 != null)
            {
                List <表达式> list实参 = Parse_实参(chars, 段);

                return(new 函数指针调用(指针取值, list实参, chars, 段.iLeft));
            }

            throw new 语法错误_Exception("函数调用 左边应该是 函数名 或者 指针取值 表达式 如 (* p) 。", chars, 段.iLeft);
            //if (指针取值 == null)
            //    return null;


            //return new 函数调用(左边的表达式, list实参);
        }
Пример #9
0
        public static void 把普通段分为运算符段和普通段(char[] chars, 表达式段 表达式段, List <表达式段> listNew)
        {
            char c1, c2;

            int p = 表达式段.iLeft;

            for (int i = 表达式段.iLeft; i <= 表达式段.iRight; i++)
            {
                c1 = chars[i];

                if (i < 表达式段.iRight)
                {
                    c2 = chars[i + 1];


                    if (c1 == '-' && c2 == '>')
                    {
                        i = i + 2;
                        p = 2;
                        continue;
                    }

                    if (c1 == '=' && c2 == '=' || c1 == '>' && c2 == '=' || c1 == '<' && c2 == '=' ||
                        c1 == '!' && c2 == '=' || c1 == '&' && c2 == '&' || c1 == '|' && c2 == '|')
                    {
                        if (p <= i - 1)
                        {
                            listNew.Add(new 表达式段(p, i - 1, 表达式段_Type.普通段));
                        }

                        listNew.Add(new 表达式段(i, i + 1, 表达式段_Type.运算符段));

                        i = i + 2;

                        p = i;

                        continue;
                    }
                }


                if (c1 == '+' || c1 == '-' || c1 == '*' || c1 == '/' || c1 == '>' || c1 == '<' || c1 == '!' ||
                    c1 == '=' || c1 == '&')
                {
                    if (p <= i - 1)
                    {
                        listNew.Add(new 表达式段(p, i - 1, 表达式段_Type.普通段));
                    }

                    listNew.Add(new 表达式段(i, i, 表达式段_Type.运算符段));

                    i = i + 1;

                    p = i;
                }
            }

            if (p <= 表达式段.iRight)
            {
                listNew.Add(new 表达式段(p, 表达式段.iRight, 表达式段_Type.普通段));
            }
        }