编译原理实验（三）之语义分析

版权声明：本文为博主原创文章，纯粹自娱。 https://blog.csdn.net/moakun/article/details/86413062

采用实验1的简单语言，设计并实现含多条简单赋值语句的语法语义分析程序，要求采用递归下降翻译法。

注意与实验1、2的衔接。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SemanticsAnalysis {
 
    /// <summary>
    /// 四元式
    /// </summary>
    class FourFormula {
        public Word result;
        public Word arg1;
        public Word operate;
        public Word arg2;
        public override string ToString() {
           string s = result.word+ " = " + arg1.word;
           
            if(operate != null) {
                s +=" "+ operate.word;
            }
          
            if(arg2 != null) {
                s += " " + arg2.word;
            }
           
            return s;         
        }
    }

    class SemanticsAnalysis {
        WordStream wordStream = new WordStream("text.txt");
       
       // List<Error> errors = new List<Error>();

        static void Main(string[] args) {
            SemanticsAnalysis syntax = new SemanticsAnalysis();
            syntax.SemanticsParser();
            Console.ReadKey();
        }

        /// <summary>
        /// 语义分析
        /// </summary>
        public void SemanticsParser() {
            do {
                functionParser();
            } while(wordStream.ReadNextWord().typeNum != WordPicker.endTypeNumber);
            if(success) {
                // Console.WriteLine("成功");
                foreach(FourFormula f in list) {
                    Console.WriteLine(f);
                }
                Console.WriteLine("---finish---");            
            }

        }
        /// <summary>
        /// 函数
        /// </summary>
        private void functionParser() {

            Word word = wordStream.ReadNextWord();
            //返回类型
            if(!KeyWords.isReturnType(word)) {
                addError(word, "返回值错误");
            }
            word = wordStream.ReadNextWord();
            //函数名
            if(!isIdentifier(word)) {
                addError(word, "函数名错误");
            }
            //（参数）{
            word = wordStream.ReadNextWord();
            if(word.typeNum != Symbols.left_bracket.typeNum) {
                addError(word, "(缺失");
            }
            arguments();
            word = wordStream.ReadNextWord();
            if(word.typeNum != Symbols.right_bracket.typeNum) {
                addError(word, ")缺失");
            }
            word = wordStream.ReadNextWord();
            if(word.typeNum != Symbols.left_curly_bracket.typeNum) {
                addError(word, "{缺失");
            }
            //语句串
            statementSequence();
            //}
            word = wordStream.ReadNextWord();
            if(word.typeNum != Symbols.right_curly_bracket.typeNum) {
                addError(word, "}缺失");
                wordStream.retractWord();
            }

        }
       
        /// <summary>
        /// 参数
        /// </summary>
        private void arguments() {
            Word word = wordStream.ReadNextWord();
            if(!KeyWords.isType(word)) {
                if(isIdentifier(word))
                    addBeforeError(word, "参数类型缺失");
                else {
                    if(wordStream.LastWord().typeNum == Symbols.comma.typeNum)
                        addBeforeError(word, ",多余");
                    wordStream.retractWord();
                    return;
                }
            }
            word = wordStream.ReadNextWord();
            if(!isIdentifier(word)) {
                addBeforeError(word, "参数标识符错误");
                if(word.typeNum == Symbols.right_bracket.typeNum) {
                    wordStream.retractWord();
                    return;
                }
            }
            //逗号
            word = wordStream.ReadNextWord();
            if(word.typeNum == Symbols.comma.typeNum) {
                arguments();
            }
            else if(word.typeNum == Symbols.right_bracket.typeNum) {
                wordStream.retractWord();
                return;
            }

        }
        /// <summary>
        /// 判断是否是标识符
        /// </summary>
        /// <param name="word"></param>
        /// <returns></returns>
        private bool isIdentifier(Word word) {
            return word.typeNum == WordPicker.identifierTypeNumber;
        }


        /// <summary>
        /// 语串
        /// </summary>
        private void statementSequence() {
            Word word = wordStream.ReadNextWord();
            while(word.typeNum != Symbols.right_curly_bracket.typeNum && word.typeNum != WordPicker.endTypeNumber) {

                if(KeyWords.isType(word)) {
                    defineStatement();
                }
                else if(isIdentifier(word)) {
                    assignStatement();
                }
                else {
                    addError(word, "多余");
                }
                /*  else if(KeyWords.isCondition(word)) {

                   }
                   else if(KeyWords.isFORLoop(word)) {

                   }
                   else {
                      // addError(word, "多余");
                   }*/
                word = wordStream.ReadNextWord();
            }
            wordStream.retractWord();
        }
        /// <summary>
        /// 定义语句
        /// </summary>
        private void defineStatement() {
            Word word = wordStream.ReadNextWord();
            if(!isIdentifier(word)) {
                addBeforeError(word, "变量名缺失");
                wordStream.retractWord();
            }
            word = wordStream.ReadNextWord();
            if(word.typeNum == Symbols.assign.typeNum) {
                FourFormula fourFormula = new FourFormula();
                fourFormula.result = wordStream.LastWord();               
                fourFormula.arg1 = expressStatement();
                addFourFormula(fourFormula);
                word = wordStream.ReadNextWord();              
            }
           
            if(word.typeNum == Symbols.comma.typeNum) {
                defineStatement();
            }
            else if(word.typeNum != Symbols.semicolon.typeNum) {
                addBeforeError(word, ";缺失");
                wordStream.retractWord();
            }

        }
        /// <summary>
        /// 赋值语句
        /// </summary>
        private void assignStatement() {
            FourFormula fourFormula = new FourFormula();
            fourFormula.result = wordStream.NowWord();
            Word word = wordStream.ReadNextWord();
            if(word.typeNum != Symbols.assign.typeNum) {
                addBeforeError(word, "=缺失");
                wordStream.retractWord();
            }
            fourFormula.arg1=expressStatement();
            addFourFormula(fourFormula);
            word = wordStream.ReadNextWord();
            if(word.typeNum != Symbols.semicolon.typeNum) {
                addBeforeError(word, ";缺失");
                wordStream.retractWord();
            }
           
        }

        #region 表达式解析
        /// <summary>
        /// 表达式
        /// </summary>
        private Word expressStatement() {
            Word express;
            FourFormula fourFormula = new FourFormula();
            express = term();
            fourFormula.arg1 = express;          
            Word word = wordStream.ReadNextWord();
            while(word.typeNum == Symbols.add.typeNum || word.typeNum == Symbols.sub.typeNum) {
                fourFormula.operate = word;
                fourFormula.arg2 = term();
                express = createTempVar();
                fourFormula.result = express;
                addFourFormula(fourFormula);
                fourFormula = new FourFormula();
                fourFormula.arg1 = express;               
                word = wordStream.ReadNextWord();
            }
            wordStream.retractWord();
            return express;
        }
        /// <summary>
        /// 项
        /// </summary>
        /// <returns></returns>
        private Word term() {
            Word term;
            FourFormula fourFormula = new FourFormula();
            term = factor();
            fourFormula.arg1 = term;
            Word word = wordStream.ReadNextWord();
            while(word.typeNum == Symbols.mul.typeNum || word.typeNum == Symbols.except.typeNum || word.typeNum == Symbols.remain.typeNum) {
                fourFormula.operate = word;
                fourFormula.arg2=factor();
                term = createTempVar();
                fourFormula.result = term;
                addFourFormula(fourFormula);
                fourFormula = new FourFormula();
                fourFormula.arg1 = term;
                word = wordStream.ReadNextWord();
            }
            wordStream.retractWord();
            return term;
        }

        /// <summary>
        /// 表达式因子
        /// </summary>
        private Word factor() {
            Word factor=null;
            Word word = wordStream.ReadNextWord();
            if(isValue(word)) {
                factor = word;
            }
            else if(word.typeNum == Symbols.left_bracket.typeNum) {
                factor= expressStatement();
                word = wordStream.ReadNextWord();
                if(word.typeNum != Symbols.right_bracket.typeNum) {
                    addBeforeError(word, ")缺失");
                    wordStream.retractWord();
                }
            }
            else {
                addBeforeError(word, "表达式错误");
                wordStream.retractWord();
            }

            return factor;
        }
        #endregion

        /// <summary>
        /// 判断是否是数值变量类型
        /// </summary>
        /// <param name="word"></param>
        /// <returns></returns>
        private bool isValue(Word word) {
            return word.typeNum == WordPicker.numberTypeNumber
                || word.typeNum == WordPicker.charTypeNumber
                || word.typeNum == WordPicker.stringTypeNumber
                || word.typeNum == WordPicker.identifierTypeNumber;
        }

        #region 添加四元式
        List<FourFormula> list = new List<FourFormula>();
        /// <summary>
        /// 保存四元式
        /// </summary>
        /// <param name="fourFormula"></param>
        private void addFourFormula(FourFormula fourFormula) {
            list.Add(fourFormula);
        }

        int idNameCount = 0;
        /// <summary>
        /// 创建临时变量
        /// </summary>
        /// <returns></returns>
        public Word createTempVar() {
            Word word = new Word();
            word.word = "$t" + idNameCount++;
            word.typeNum = 0;
            return word;
        }
        #endregion      

        #region 输出错误
        bool success = true;//语法解析结果
        /// <summary>
        /// 输出在特定之前的错误
        /// </summary>
        /// <param name="word"></param>
        /// <param name="v"></param>
        private void addBeforeError(Word word, string v) {
            success = false;
            Console.WriteLine(word.ToPositionInfo() + "\t之前" + v);
        }
        /// <summary>
        /// 输出错误
        /// </summary>
        /// <param name="word"></param>
        /// <param name="v"></param>
        private void addError(Word word, string v) {
            success = false;
            Console.WriteLine(word.ToPositionInfo() + "\t" + v);
        }
        #endregion

    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace SemanticsAnalysis {
    /// <summary>
    /// 词
    /// </summary>
    class Word {
        public int typeNum = 0;
        public string word;
        public int col = 0;
        public int row = 0;
        public override string ToString() {
            return "(" + typeNum + "," + word + ")";
        }
        public string ToPositionInfo() {
            return "行:" + ( row + 1 ) + "\t列:" + col + "\t码:" + typeNum + "\t字:" + word;
        }
    }


    class WordPicker {

        string[] input;
        //int input_index = 0;
        int row = 0;
        int col = 0;
        char character;

        /// <summary>
        /// 操作符表
        /// </summary>    
        string[] operatorSort = null;

        public static int identifierTypeNumber;    //变量名类型
        public static int numberTypeNumber;        //数值类型
        public static int charTypeNumber;          //字符类型
        public static int stringTypeNumber;        //字符串类型
        public static int endTypeNumber = -1;      //结束符类型
        public static int errorTypeNumber = -2;    //出错类型
        public static int noDefine = -3;           //未定义类型
        public static char nullChar = '\0';

        public WordPicker(string file) {
            input = File.ReadAllLines(file);
            identifierTypeNumber = KeyWords.keyWordTable.Length + 1;
            numberTypeNumber = KeyWords.keyWordTable.Length + 2;
            charTypeNumber = KeyWords.keyWordTable.Length + 3;
            stringTypeNumber = KeyWords.keyWordTable.Length + 4;

            operatorSort = new string[Symbols.operatorTable.Length];
            Array.Copy(Symbols.operatorTable, operatorSort, Symbols.operatorTable.Length);
            Array.Sort(operatorSort);
            Array.Reverse(operatorSort);
        }



        /// <summary>
        /// 读词
        /// </summary>
        /// <returns></returns>
        public Word Scanner() {
            Word myWord;
            read();
            readValidChar();
            //标识符
            if(char.IsLetter(character)) {
                myWord = readWord();
            }//数值
            else if(char.IsDigit(character)) {
                myWord = readDigit();
            }//字符常量
            else if(character == '\'') {
                myWord = readConstChar();
            }//字符串
            else if(character == '\"') {
                myWord = readConstString();
            }/*//结束符
            else if(character == endChar) {
                myWord.word = "" + endChar;
                myWord.typeNum = endTypeNumber;
            }*///空值
            else if(character == nullChar) {
                myWord = new Word();
                myWord.row = row;
                myWord.col = col;
                myWord.word = "Ending";
                myWord.typeNum = endTypeNumber;
            }//其他字符
            else {
                myWord = readOtherChar();
            }
            return myWord;

        }

        /// <summary>
        /// 标识符
        /// </summary>
        /// <param name="myWord"></param>
        private Word readWord() {
            Word myWord = new Word();
            myWord.row = row;
            myWord.col = col;
            while(char.IsLetter(character) || char.IsDigit(character)) {
                myWord.word += character;
                read();
            }
            retract();
            myWord.typeNum = KeyWords.getTypeNumber(myWord.word);
            return myWord;
        }

        /// <summary>
        /// 其他字符
        /// </summary>
        /// <param name="myWord"></param>
        private Word readOtherChar() {
            Word myWord = new Word();
            myWord.row = row;
            myWord.col = col;
            string s = "" + character;
            for(int i = 0; i < 2; i++) {
                read();
                if(character == nullChar) {
                    break;
                }
                s += character;
            }
            foreach(string op in operatorSort) {
                if(s.StartsWith(op)) {
                    retract(s.Length - op.Length);
                    s = op;
                    break;
                }
            }
            myWord.word = s;
            myWord.typeNum = Symbols.getTypeNumber(myWord.word);
            return myWord;
        }

        /// <summary>
        /// 识别数字常量
        /// </summary>
        /// <param name="myWord"></param>
        private Word readDigit() {
            Word myWord = new Word();
            myWord.row = row;
            myWord.col = col;
            while(char.IsDigit(character)) {
                myWord.word += character;
                read();
            }
            if(character == '.') {
                myWord.word += character;
                read();
                while(char.IsDigit(character)) {
                    myWord.word += character;
                    read();
                }
            }
            retract();
            myWord.typeNum = numberTypeNumber;
            return myWord;
        }

        /// <summary>
        /// 识别字符常量
        /// </summary>
        /// <param name="myWord"></param>
        private Word readConstChar() {
            Word myWord = new Word();
            myWord.row = row;
            myWord.col = col;
            // myWord.word = "" + character;
            read();
            //读取直到'\''结束
            while(character != '\'') {
                myWord.word += character;
                read();
                //读到空字符或结束字符
                if(character == nullChar /*|| character == endChar*/|| char.IsControl(character)) {
                    /* if(character == endChar) {
                         myWord.word +=endChar;
                     } */
                    myWord.typeNum = errorTypeNumber;
                    return myWord;
                }
            }
            // myWord.word += character;
            Match r = Regex.Match(myWord.word, "^(\\\\([0-7]{1,3}|x[0-9a-fA-F]+|[abfnrtv\\\\\'\"?])|[^\\\\])$");
            //转义字符模式匹配
            if(!r.Success) {
                myWord.typeNum = errorTypeNumber;
                return myWord;
            }
            myWord.typeNum = charTypeNumber;
            return myWord;

        }
        /// <summary>
        /// 识别常量字符串
        /// </summary>
        /// <param name="myWord"></param>
        private Word readConstString() {
            Word myWord = new Word();
            myWord.row = row;
            myWord.col = col;
            // myWord.word = "" + character;
            read();
            while(character != '\"') {
                myWord.word += character;
                read();
                //读到空字符或结束字符
                if(character == nullChar || char.IsControl(character)) {
                    // myWord.word += "0";
                    myWord.typeNum = errorTypeNumber;
                    return myWord;
                }
            }
            // myWord.word += character;

            //转义字符模式匹配
            if(!isLegalString(myWord.word)) {
                myWord.typeNum = errorTypeNumber;
                return myWord;
            }
            myWord.typeNum = stringTypeNumber;
            return myWord;
        }

        /// <summary>
        /// 合法字符串书写
        /// </summary>
        /// <param name="word"></param>
        /// <returns></returns>
        private bool isLegalString(string word) {

            int i = 0;
            while(i < word.Length) {
                if(word[i] == '\\') {
                    if(++i == word.Length)
                        return false;
                    foreach(char c in translateChar) {
                        if(c == word[i]) {
                            goto aLabel;
                        }
                    }
                    return false;
                }
            aLabel:
                i++;
            }

            return true;
        }

        const string translateChar = "abfnrtv\\\'\"?";
        const string realChar = "\a\b\f\n\r\t\v\\\'\"?";



        /// <summary>
        /// 转换为真实字符串
        /// </summary>
        /// <param name="word"></param>
        /// <returns></returns>
        private string toRealString(string word) {
            string res = "";
            int index;
            for(int i = 0; i < word.Length; i++) {
                if(word[i] == '\\') {
                    if(++i == word.Length)
                        throw new Exception("字符串以\\结尾异常");

                    index = translateChar.IndexOf(word[i]);
                    if(index == -1)
                        throw new Exception("\\" + word[i] + "解析异常");
                    res += realChar[index];
                }
                else {
                    res += word[i];
                }
            }
            return res;
        }

        /// <summary>
        /// 读一个字符
        /// </summary>
        void read() {
            if(input.Length <= row || input.Length == row + 1 && input[input.Length - 1].Length <= col) {
                character = '\0';
            }
            else {
                if(col >= input[row].Length) {
                    col = 0;
                    row++;
                }
                character = input[row][col];
                col++;
            }

        }

        /// <summary>
        /// 去除无效字符
        /// </summary>
        void readValidChar() {

            while(char.IsWhiteSpace(character)) {
                if(character == '\0') {
                    return;
                }
                read();
            }
            //判断注释
            if(character == '/' && input[row].Length > col) {
                ignoreNote();
            }
        }

        /// <summary>
        /// 忽视注解
        /// </summary>
        private void ignoreNote() {
            read();
            //注释‘//’
            if(character == '/') {
                row++;
                col = 0;
                read();
                readValidChar();
            }//注释‘/*。。。*/’
            else if(character == '*') {

                read();
                if(character == '\0') {
                    return;
                }
                char c;
                while(true) {

                    c = character;
                    read();
                    if('*' == c && '/' == character) {
                        read();
                        readValidChar();
                        return;
                    }
                    if(character == '\0') {
                        return;
                    }
                }
            }
            else {
                retract();
            }
        }

        /// <summary>
        /// 回退一个字符
        /// </summary>
        void retract() {
            col = col - 2;
            checkCol();
            read();
        }

        /// <summary>
        /// 回退v个字符
        /// </summary>
        /// <param name="v"></param>
        private void retract(int v) {
            if(v == 0)
                return;
            col = col - v - 1;
            checkCol();
            read();
        }

        /// <summary>
        /// 检查col是否合法
        /// </summary>
        void checkCol() {
            if(col < 0) {
                row--;
                col = input[row].Length + col;
                checkCol();
            }
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace SemanticsAnalysis {
    class KeyWords {
        /// <summary>
        /// 关键字表
        /// </summary>
        public static string[] keyWordTable = {
            "auto","break","case", "char","const",
            "continue","default","do","double",
            "else","enum","extern","float","for",
            "goto","if", "int","long", "register",
            "return","short","signed","sizeof","static",
            "struct","switch","typedef","union","unsigned",
            "void","volatile","while"};

        public static Word AUTO, BREAK, CASE, CHAR, CONST,
        CONTINUE, DEFAULT, DO, DOUBLE,
        ELSE, ENUM, EXTERN, FLOAT, FOR,
        GOTO, IF, INT, LONG, REGISTER,
        RETURN, SHORT, SIGNED, SIZEOF, STATIC,
        STRUCT, SWITCH, TYPEDEF, UNION, UNSIGNED,
        VOID, VOLATILE, WHILE;

        static KeyWords() {
            Type t = typeof(KeyWords);

            FieldInfo[] fields = t.GetFields();
            Word word;
            foreach(FieldInfo f in fields)
                if(f.FieldType.Equals(typeof(Word))) {
                    word = new Word();
                    word.word = f.Name.ToLower();
                    word.typeNum = getTypeNumber(word.word);
                    f.SetValue(t, word);
                }
        }
        /// <summary>
        /// 获取关键字编码
        /// </summary>
        /// <returns></returns>
        public static int getTypeNumber(string s) {
            for(int i = 0; i < keyWordTable.Length; i++) {
                if(keyWordTable[i] == s) {
                    return i+1;
                }
            }

            return WordPicker.identifierTypeNumber;
        }
        public static bool isPrefType(Word w) {
            return SIGNED.typeNum == w.typeNum
               || UNSIGNED.typeNum == w.typeNum;
        }
        public static bool isType(Word w) {
            return INT.typeNum == w.typeNum
                || CHAR.typeNum == w.typeNum
                || DOUBLE.typeNum == w.typeNum
                || FLOAT.typeNum == w.typeNum
                || SHORT.typeNum == w.typeNum;               
        }

        public static bool isReturnType(Word w) {
            return isType(w) || VOID.typeNum == w.typeNum;
        }

        internal static bool isCondition(Word word) {
            return word.typeNum == IF.typeNum;
        }

        internal static bool isFORLoop(Word word) {
            return word.typeNum == FOR.typeNum|| word.typeNum == WHILE.typeNum;
        }
        internal static bool isWhileLoop(Word word) {
            return word.typeNum == WHILE.typeNum;
        }
        internal static bool isDoLoop(Word word) {
            return  word.typeNum == DO.typeNum;
        }

        internal static bool isKeyWord(Word word) {
            return word.typeNum > 0 && word.typeNum <= keyWordTable.Length;
        }
    }
    class Symbols {
        public static string[] operatorTable = {
            "{","}","[","]","(",")","->",".",
            "++","--",
            "!","&&","||",
            "~","&","|","^",
            "+","-","*","/","%",
            "<<",">>",
            "<",">",">=","<=",
            "==","!=","?",":",",",";",
            "=","+=","-=","*=","/=","%=",
            "&=","^=","|=","<<=",">>="
        };

        public static Word left_curly_bracket, right_curly_bracket,
            left_square_bracket, right_square_bracket,
            left_bracket, right_bracket,
            arrow, point, two_add, two_sub,
            logic_not, logic_and, logic_or,
            bitwise_not, bitwise_and, bitwise_or, bitwise_xor,
            add, sub, mul, except, remain,
            left_move, right_move,
            less, greater, greater_equal, less_equal,
            equal, not_equal, question_mark, colon, comma, semicolon,
            assign, add_assign, sub_assign, mul_assign, except_assign, remain_assign,
            and_assign, xor_assign, or_assign, left_move_assign, right_move_assign;

        internal static bool isSemicolo(Word word) {
            return word .typeNum == semicolon.typeNum;
        }

        static Symbols() {
            Type t = typeof(Symbols);

            FieldInfo[] fields = t.GetFields();
            Word word;
            int index = 0;
            foreach(FieldInfo f in fields)
                if(f.FieldType.Equals(typeof(Word))) {
                    word = new Word();
                    word.word = operatorTable[index++];
                    word.typeNum = getTypeNumber(word.word);
                    f.SetValue(t, word);
                }
        }

        public static int getTypeNumber(string s) {
            int start = 100;
            for(int i = 0; i < operatorTable.Length; i++) {
                if(operatorTable[i] == s) {
                    return start + i;
                }
            }
            return WordPicker.noDefine;
        }

       
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SemanticsAnalysis {
    /// <summary>
    /// 读词缓存流
    /// </summary>
    class WordStream {
        WordPicker wordPicker;
        List<Word> words = new List<Word>();
        int index = -1;

        public WordStream(string file) {
            wordPicker = new WordPicker(file);
        }

        /// <summary>
        /// 读取下一个词
        /// </summary>
        /// <returns></returns>
        public Word ReadNextWord() {
            index++;
            if(words.Count <= index) {
                Word w = wordPicker.Scanner();
                if(words.Count == 0 || words[words.Count - 1].typeNum != WordPicker.endTypeNumber)
                    words.Add(w);
                index = words.Count - 1;
            }
            return words[index];
        }
        /// <summary>
        /// 现在的词
        /// </summary>
        /// <returns></returns>
        public Word NowWord() {

            if(words.Count > index && index >= 0) {
                return words[index];
            }
            return null;
        }
        /// <summary>
        /// 上一个词
        /// </summary>
        /// <returns></returns>
        public Word LastWord() {

            if(index > 0) {

                return words[index - 1];
            }
            else {
                return null;
            }

        }
        /// <summary>
        /// 回退一个词
        /// </summary>
        public void retractWord() {

            if(index >= 0) {
                index--;
            }

        }
    }
}

输入：

void main(int a,int b){	
   //int a=4-2;
  //int a=a,b=a*82,c= a;
   bin=12-12* xa;
   int sout=10-2.23;
   mess= ok*(6-as);
}

输出：