arthmexp.cs

关于CMM语言的解释器

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Text.RegularExpressions;

namespace CmmInterpretor
{
    //类 算术表达式
    class ArthmExp
    {
        //定义类型
        private int type;

        //定义内容
        private string con;


        public ArthmExp()
        {
            con = "";
        }

        public ArthmExp(string initCon)
        {
            con = initCon;
        }

        public int Type
        {
            get { return type; }
            set { type = value; }
        }

        public string Con
        {
            get { return con; }
            set { con = value; }
        }




        //获得 表达式的类型
        public int GetExpType(ArrayList IDLst)
        {
            con = con.Trim();
            if (con.Length == 0)
                return ERROR;

            if (IsArthmExp(con))
            {
                string[] expWords = wordAnalysis.GetWords(con);


                //判断方法，遍历，若该表达式有效，如果含有real类型的单词或者变量，就是real类型，否则是int类型
                foreach (string expWord in expWords)
                {
                    if (wordAnalysis.GetWordType(expWord) == REAL)
                        return REAL;
                    if (wordAnalysis.GetWordType(expWord) == ID)
                    {
                        bool isDeclareID = false;
                        foreach (Variable var in IDLst)
                        {
                            if (var.VID.Equals(expWord))
                            {
                                isDeclareID = true;
                                if (var.VType == REAL)
                                    return REAL;
                            }
                        }

                        if (!isDeclareID)
                            return ERROR; //未声明的ID，报错
                    }
                }
                return INTG;
            }
            else return ERROR;
        }

        public bool IsArthmExp()
        {
            return ArthmExp.IsArthmExp(con);
        }

        //判断是否为算术表达式
        public static bool IsArthmExp(string exp)
        {
            string athExp = exp;

            //规约括号部分为因子。若括号内为表达式，则括号及其内部的整个部分视为因子。
            while (athExp.Contains("("))
            {
                string exp_inbracket = "";
                string tmpstr = athExp.Remove(0, athExp.IndexOf("("));
                if (!grammerAnalysis.GetBracketContent(ref tmpstr, ref exp_inbracket))
                    return false;
                //括号内含非法算术表达式则整个语句也是非法算术表达式
                if (!IsArthmExp(exp_inbracket)) return false;
                athExp = athExp.Replace("(" + exp_inbracket + ")", FACTOR);
            }

            //规约数组下标
            while (athExp.Contains("["))
            {
                string exp_inbracket = ""; //下标内的表达式
                string tmpstr = athExp.Remove(0, athExp.IndexOf("["));
                if (!grammerAnalysis.GetBracketContent(ref tmpstr, ref exp_inbracket))
                    return false;
                //括号内含有非法算术表达式则整个语句也是非法算术表达式
                if (!IsArthmExp(exp_inbracket)) return false;
                athExp = athExp.Replace("[" + exp_inbracket + "]", " " + ARR_IDX + " ");
            }

            //规约整数，实数，标识符，数组为因子
            ArrayList expWords = wordAnalysis.GetWordLst(athExp);
            for (int i = 0; i < expWords.Count; i++)
            {
                int wordType = wordAnalysis.GetWordType((string)expWords[i]);

                //单个变量是因子
                if (wordType == ID)
                {
                    expWords[i] = FACTOR;
                    if (i < expWords.Count - 1 && expWords[i + 1].Equals(ARR_IDX))
                        expWords.RemoveAt(i + 1);
                }

                //单个整数，实数，已声明标识符均为因子
                if (wordType == INTG || wordType == REAL)
                    expWords[i] = FACTOR;
            }

            athExp = string.Join("", (string[])expWords.ToArray(typeof(string)));

            //定义标识符的正则表达式
            Regex rg = new Regex(@"^(\+|\-)?:factor((\+|\-|\*|/):factor)*$");
            if (rg.IsMatch(athExp))
                return true;
            else
                return false;
        }

        public Term[] GetTerm()
        {
            return ArthmExp.GetTerm(this);
        }

        //获得实数类型的表达式的值
        public bool GetValue(ArrayList IDLst, ArrayList ValueLst, ref double Value)
        {
            if (GetExpType(IDLst) != REAL)
                return false;

            double result = 0.0;
            Term[] terms = GetTerm();

            foreach (Term term in terms)
            {
                double tValue = 0.0;
                if (!term.GetValue(IDLst, ValueLst, ref tValue))
                {
                    int tIValue = 0;
                    if (!term.GetValue(IDLst, ValueLst, ref tIValue)) //实型表达式也可能含整型项
                        tValue = (double)tIValue;
                    else
                        return false;
                }

                if (term.Sign.Equals("+"))
                    result = result + tValue;
                else if (term.Sign.Equals("-"))
                    result = result - tValue;
                else
                    return false; //错误的符号
            }

            Value = result;
            return true;
        }
        //获得整数类型的表达式的值
        public bool GetValue(ArrayList IDLst, ArrayList ValueLst, ref int Value)
        {
            if (GetExpType(IDLst) != INTG)
                return false;

            int result = 0;
            Term[] terms = GetTerm();

            foreach (Term term in terms)
            {
                int tValue = 0;
                if (!term.GetValue(IDLst, ValueLst, ref tValue))
                    return false;

                if (term.Sign.Equals("+"))
                    result = result + tValue;
                else if (term.Sign.Equals("-"))
                    result = result - tValue;
                else
                    return false; //错误的符号
            }

            Value = result;
            return true;
        }




        //获得项
        public static Term[] GetTerm(ArthmExp exp)
        {
            string expStr = exp.Con.Trim();
            char[] pl = { '+' };
            char[] mn = { '-' };
            ArrayList bracketExps = new ArrayList(); //保存括号内表达式
            ArrayList arrExps = new ArrayList(); //保存数组中括号内表达式
            ArrayList termLst = new ArrayList();

            CodeBracket(ref expStr, ref bracketExps, "(", BRC);
            CodeBracket(ref expStr, ref arrExps, "[", ARR_IDX);

            string[] plTerms = expStr.Split(pl, StringSplitOptions.RemoveEmptyEntries);
            foreach (string plTerm in plTerms)
            {
                if (plTerm.Contains("-"))
                {
                    string termStr = plTerm;

                    if (!termStr.StartsWith("-"))
                    {
                        Term firstTerm = new Term();
                        string termCon = termStr.Substring(0, termStr.IndexOf("-"));
                        DecodeBracket(ref termCon, arrExps, "[", ARR_IDX);
                        DecodeBracket(ref termCon, bracketExps, "(", BRC);
                        firstTerm.Con = termCon;
                        firstTerm.Sign = "+";
                        termLst.Add(firstTerm);
                        termStr = termStr.Substring(termStr.IndexOf("-"));
                    }

                    string[] mnTerms = termStr.Split(mn, StringSplitOptions.RemoveEmptyEntries);
                    foreach (string mnTerm in mnTerms)
                    {
                        Term term = new Term();
                        string termCon = mnTerm;
                        DecodeBracket(ref termCon, arrExps, "[", ARR_IDX);
                        DecodeBracket(ref termCon, bracketExps, "(", BRC);
                        term.Con = termCon;
                        term.Sign = "-";
                        termLst.Add(term);
                    }
                }
                else
                {
                    Term term = new Term();
                    string termCon = plTerm;
                    DecodeBracket(ref termCon, arrExps, "[", ARR_IDX);
                    DecodeBracket(ref termCon, bracketExps, "(", BRC);
                    term.Con = termCon;
                    term.Sign = "+";
                    termLst.Add(term);
                }
            }
            return (Term[])termLst.ToArray(typeof(Term));
        }

        //获得因子
        public static Factor[] GetFactor(Term term)
        {
            string termStr = term.Con.Trim();
            char[] ti = { '*' };
            char[] de = { '/' };
            ArrayList bracketExps = new ArrayList(); //保存括号内表达式
            ArrayList arrExps = new ArrayList(); //保存数组中括号内表达式
            ArrayList factorLst = new ArrayList();

            CodeBracket(ref termStr, ref bracketExps, "(", BRC);
            CodeBracket(ref termStr, ref arrExps, "[", ARR_IDX);

            string[] tiFactors = termStr.Split(ti, StringSplitOptions.RemoveEmptyEntries);
            foreach (string tiFactor in tiFactors)
            {
                if (tiFactor.Contains("/"))
                {
                    string factorStr = tiFactor;


                    Factor firstFactor = new Factor();  //首字符肯定不为'/'
                    string fFactorCon = factorStr.Substring(0, factorStr.IndexOf("/"));
                    DecodeBracket(ref fFactorCon, arrExps, "[", ARR_IDX);
                    DecodeBracket(ref fFactorCon, bracketExps, "(", BRC);
                    firstFactor.Con = fFactorCon;
                    firstFactor.Sign = "*";
                    factorLst.Add(firstFactor);
                    factorStr = factorStr.Substring(factorStr.IndexOf("/"));

                    string[] deFactors = factorStr.Split(de, StringSplitOptions.RemoveEmptyEntries);
                    foreach (string deFactor in deFactors)
                    {
                        Factor factor = new Factor();
                        string factorCon = deFactor;
                        DecodeBracket(ref factorCon, arrExps, "[", ARR_IDX);
                        DecodeBracket(ref factorCon, bracketExps, "(", BRC);
                        factor.Con = factorCon;
                        factor.Sign = "/";
                        factorLst.Add(factor);
                    }
                }
                else
                {
                    Factor factor = new Factor();
                    string factorCon = tiFactor;
                    DecodeBracket(ref factorCon, arrExps, "[", ARR_IDX);
                    DecodeBracket(ref factorCon, bracketExps, "(", BRC);
                    factor.Con = factorCon;
                    factor.Sign = "*";
                    factorLst.Add(factor);
                }
            }
            return (Factor[])factorLst.ToArray(typeof(Factor));
        }


        //替换括号部分。参数leftBracket只能是'('或者'['(辅助方法)
        private static void CodeBracket(ref string exp, ref ArrayList codeArray,
            string leftBracket, string replaceStr)
        {
            string rightBracket;
            if (leftBracket.Equals("(")) rightBracket = ")";
            else if (leftBracket.Equals("[")) rightBracket = "]";
            else return;