临时写了个语法分析的代码,可以顺便输出语法树,以后有时间慢慢解释具体结构吧~

代码:

#include<bits/stdc++.h>
#define xcx(x) printf("ojbk %d\n",(x))
using namespace std;
const int KEY_WORD_NUM = 13 ;
const int OPERATOR_WORD_NUM = 19;
const int DELIMITER_WORD_NUM = 6 ;
const int row_limit = 130;

//词法分析常量
const string _data_type = "data type" ;
const string _statement_keyword = "statement keyword" ;
const string _identifier = "identifier" ;
const string _single_arithmetic_operator = "single arithmetic operator" ;
const string _compare_operator = "compare operator" ;
const string _double_arithmetic_operator = "double arithmetic operator" ;
const string _delimiter = "delimiter" ;
const string _unsigned_number = "unsigned number" ;
const string _const_string  = "const string" ;
const string _const_character = "const character";
const string ANNOTATIONL1 = "//" ;
const string ANNOTATIONL2 = "/*" ;
const string key_word [ KEY_WORD_NUM ] = { "break", "if", "else", "for", "while", "do", "int", "double", "char", "read", "write", "bool", "string" } ;
const string operator_word [ OPERATOR_WORD_NUM ]= { "+=", "-=", "*=", "\=", "+", "-", "*", "/", "=", "++", "--", "<", ">", "<=", ">=", "!=", "==", "//", "/*" } ;
const string delimiter_word [ DELIMITER_WORD_NUM ] = { "(", ")", "{", "}", ",", ";"};

//语法分析常量
const string _program = "program" ;
const string _declaration = "declaration" ;
const string _expression = "expression" ;
const string _expression_bool = "expression bool" ;
const string _expression_cal = "expression cal" ;
const string _term = "term" ;
const string _factor = "factor" ;
const string _statement = "statement" ;
const string _statement_if = "if - statement";
const string _statement_while = "while - statement" ;
const string _statement_do_while = "do-while - statement";
const string _statement_for = "for - statement" ;
const string _statement_write = "write - statement" ;
const string _statement_read = "read - statement" ;
const string _statement_compound = "compound statement" ;
const string _statement_expression = "expression statement" ;
const string _constant = "constant" ;
const string _number = "number" ;
struct Node_operator {
    string str;
    bool is_terminator;
    map < char, int > next;
    Node_operator(){
        str.clear();
        is_terminator = false;
        next.clear();
    }
    Node_operator( const string &str ){
        this -> next.clear();
        this -> str = str;
        this -> is_terminator = false;
    }
};
struct Word {
    string type;
    string val;
    Word(){
        type.clear();
        val.clear();
    }
    Word( const string &str , const string &val ){
        this -> type = str;
        this -> val = val;
    }
    void print(){
        printf( " %s %s\n", this -> type.c_str(), this -> val.c_str() );
    }
    bool operator != (const Word &other) const {
        return other.type != this->type || other.val != this->val ;
    }
    bool operator == (const Word &other) const {
        return other.type == this->type && other.val == this->val ;
    }
};
struct Unit {
    vector< Unit > u ;
    string val ;
    string type;
    bool is_error;
    Unit(){
        is_error = false ;
    }
    Unit ( const string type ) {
        this -> is_error = false ;
        this -> type = type;
    }
    Unit ( const Word &w ) {
        this -> is_error = false ;
        this -> type = w.type ;
        this -> val = w.val ;
        u.clear();
    }
    inline void print() {
        printf( " %s ( %s ) " , val.c_str() , type.c_str() ) ;
    }
    inline void println() {
        print();
        printf("\n");
    }
    void push( const Unit &ut ) {
        this -> val += ut.val;
        this -> u.push_back( ut ) ;
    }
    void push( const Word &w ) {
        this -> val += w.val;
        this -> u.push_back( Unit(w) ) ;
    }
    void clear() {
        this -> val.clear();
        this -> u.clear();
    }
};
struct Node {
    Unit x ;
    int deep , vl , vr , mid , tl , tr , fa , id;
    bool is_level , is_enough_v , is_enough_t ;
    Node () {};
    Node ( Unit u , int deep , int fa ) {
        this -> deep = deep ;
        this -> x = u;
        if ( u.u.size() == 0 ) this -> is_level = true;
        else this -> is_level = false ;
        this -> fa = fa ;
        this -> x.type = "[" + u.type + "]";
    }
    int TypeLength() {
        return x.type.length();
    }
    int ValLength() {
        return x.val.length();
    }
};
int now_line = 1 , error_type = 0;
char ch = 0;
FILE *fp ;
map < string, int > key_word_id;
map < char, int > operator_word_head;
vector < Node_operator > state_graph;
vector < Word > ans ;
string error_information , fin_name , fout_name ;
Word finish , error_word, wd;
Unit error_unit;
char tree_map[300][row_limit+5];


void read(char &c){
    if( fscanf( fp , "%c" , &c ) == EOF ) c = EOF;
    if( c == '\n' ) now_line++ ;
}

///词法分析识别函数
inline bool Is_Character ( const char &c ) {
    return c>='A'&&c<='Z' || c>='a'&&c<='z' || c=='_';
}
inline bool Is_Number( const char &c ) {
    return c>='0'&&c<='9' ;
}
inline bool Is_Operator_head ( const char &c ) {
    return operator_word_head.count(c) > 0 ;
}
inline bool Is_Data_type ( const string &s ){
    return s=="int" || s=="double" || s=="char" || s=="string" || s=="bool" ;
}
inline bool Is_Blank ( const char &c ) {
    return c == ' ' || c == '\t' || c == '\n' ;
}
inline bool Is_Delimiter ( const char &c ) {
    return c=='(' || c==')' || c=='{' || c=='}' || c==';' || c==',' ;
}
inline bool Is_Compare_operator ( const string &s ) {
    return s=="<" || s==">" || s=="<=" || s==">=" || s=="==" || s=="!=" ;
}

void InitTestScan(){
//读取标识符
    key_word_id.clear();
    for( int i=0; i<KEY_WORD_NUM; i++ ) {
        key_word_id[ key_word[i] ] = i;
    }
//读取运算符头字母
    operator_word_head.clear();
    for( int i=0; i<OPERATOR_WORD_NUM; i++ ) {
        operator_word_head[ operator_word[i][0] ] = i;
    }
//运算符建图
    state_graph.clear();
    state_graph.push_back( Node_operator() );
    for( int i=0; i<OPERATOR_WORD_NUM; i++ ) {
        const string &temp = operator_word[i];
        int node_index = 0;
        for( int j=0; j<(int)temp.length(); j++ ) {
            Node_operator &now_node = state_graph[node_index];
            if( now_node.next.count( temp[j] ) == 0 ) {
                now_node.next[ temp[j] ] = state_graph.size();
                state_graph.push_back( Node_operator( now_node.str +temp[j] ) );
                node_index = state_graph.size() -1 ;
            }
            else{
                node_index = now_node.next[ temp[j] ];
            }
        }
        state_graph[node_index].is_terminator = true ;
    }
//vector<> 清空
    ans.clear();
//当前行起点为1
    now_line = 1;
//常量终止Word赋值
    finish.type.clear();    finish.val.clear();
//error处理信息
    error_type = 0 ;
    error_information.clear() ;
    error_word = Word( string("error"), string("?") );
    error_unit.is_error =true; error_unit.type.clear(); error_unit.val.clear();
}
void PrintError( int op );
int InputTestScan(){
    printf( "input the name of the source program...\n" );
    cin >> fin_name ;
    fp = fopen( fin_name.c_str(), "r" );
    if( fp == NULL ) return 1;
    //else fclose( fp );
    //printf( "input the name of the output file...\n" );
    //cin >> fout_name ;
    //freopen( fin_name.c_str(), "r", stdin ) ;
    return 0;
}
void InitGetWord(){
    InitTestScan();
    read( ch );
}

///语法分析识别函数
Word GetWord(){ //读取一个标识
    Word ret = finish ;
    while( ch != EOF ){
        while( Is_Blank(ch) ){
            read( ch );
            if( ch == EOF ) return ret;
        }
        if( Is_Character(ch) == true ) { //处理标识符
            string str;
            while( Is_Character(ch) == true || Is_Number(ch) == true ) {
                str += ch;
                read( ch );
            }
            if( key_word_id.count(str) > 0 ) {
                if( Is_Data_type( str ) == true ) {
                    ret = Word(_data_type, str);
                }
                else {
                    ret = Word(_statement_keyword, str);
                }
            }
            else {
                ret = Word(_identifier, str) ;
            }
        }
        else if( Is_Number(ch) == true ) { //处理数字常量
            string str;
            bool is_decimal = false;
            while( Is_Number(ch) == true ) {
                str +=ch;
                read( ch );
            }
            if( ch == '.' ) {
                is_decimal = true;
                str +=ch;
                read( ch );
                while( Is_Number(ch) == true ) {
                    str +=ch;
                    read( ch );
                }
                if( Is_Character(ch) || ch == '.' ){
                    error_type = 3;
                    while( !Is_Blank(ch) && !Is_Delimiter(ch) ) {
                        str += ch;
                        read( ch );
                    }
                    if ( ch == '\n' ) now_line-- ;
                    error_information = str;
                    return error_word;
                }
            }
            if( is_decimal == true ) {
                if( str.back() == '.' ) {
                    error_information = str ;
                    error_type = 4;
                    return error_word;
                }
            }
            ret = Word( _unsigned_number, str ) ;
        }
        else if ( ch == '\'' ) { //处理单引号
            string str;
            str +=ch;
            read( ch );
            while( ch!='\'' && ch!='\n' ) {
                if( ch == '\\' ) {
                    str +=ch;
                    read( ch );
                }
                str +=ch;
                read( ch );
            }
            if( ch != '\'' ) {
                error_type = 5;
                error_information = str;
                return error_word;
            }
            str +=ch;
            ret = Word(_const_character, str) ;
            read( ch );
            if( ret.val.length() > 3 && ret.val[1] !='\\' ) {
                error_type = 6;
                error_information = str;
                return error_word;
            }
        }
        else if ( ch == '"' ) { //处理双引号
            string str;
            str +=ch;
            read( ch );
            while( ch!='"' && ch!='\n' ) {
                if( ch == '\\' ) {
                    str +=ch;
                    read( ch );
                }
                str +=ch;
                read( ch );
            }
            if( ch != '"' ) {
                error_type = 7;
                error_information = str;
                return error_word;
            }
            str +=ch;
            ret = Word( _const_string, str ) ;
            read( ch );
        }
        else if ( Is_Operator_head(ch) == true ) { //处理运算符
            string str ;
            int node_index = 0;
            while( state_graph[node_index].next.count(ch) > 0 ) {
                node_index = state_graph[node_index].next[ch] ;
                read( ch );
                while( Is_Blank(ch) == true ) read( ch ) ;
            }
            Node_operator &now_node = state_graph[node_index];
            if( now_node.str == ANNOTATIONL1 ) { //处理注释1
                while( ch != '\n' ) read( ch );
                read( ch );
            }
            else if( now_node.str == ANNOTATIONL2 ) { //处理注释2
                char pre_ch = ch;
                read( ch );
                while( !(pre_ch == '*' && ch == '/') ) {
                    pre_ch = ch;
                    read( ch );
                }
                read( ch );
            }
            else if( state_graph[node_index].is_terminator == false ) { //运算符不合法
                error_information = state_graph[node_index].str ;
                error_type = 8 ;
                return error_word;
            }
            else { //合法运算符
                str = now_node.str;
                if( str == "++" || str == "--" ) {
                    ret = Word( _single_arithmetic_operator , str) ;
                }
                else if( Is_Compare_operator(str) == true ) {
                    ret = Word( _compare_operator , str) ;
                }
                else {
                    ret = Word( _double_arithmetic_operator , str ) ;
                }
            }
        }
        else if( Is_Delimiter(ch) == true ) { //处理分界符
            string str ;
            str = ch;
            read( ch ) ;
            ret = Word (_delimiter , str );
        }
        else{ //不合法字符
            error_information = ch;
            while( Is_Blank(ch) == false ) {
                error_information += ch ;
                read( ch );
            }
            error_type = 9;
            return error_word;
        }
        if( error_type != 0 || ( ret.type.length() != 0 || ret.val.length() != 0 ) ) return ret;
    }
}

Unit GetProgram() ;
Unit GetDeclaration() ;
Unit GetExpression() ;
Unit GetExpressionBool() ;
Unit GetExpressionCal() ;
Unit GetTerm() ;
Unit GetFactor() ;
Unit GetStatement() ;
Unit GetStatementIf() ;
Unit GetStatementWhile() ;
Unit GetStatementDoWhile() ;
Unit GetStatementFor() ;
Unit GetStatementWrite() ;
Unit GetStatementRead() ;
Unit GetStatementCompound() ;
Unit GetStatementExpression() ;
Unit GetConstant() ;
Unit GetNumber() ;

void PrintTree ( Unit &root ) ; // 想不想看看怎么秀操作
vector < Node > Bfs( Unit &s );

void test(){
    fin_name = "in.txt" ;
    fp = fopen( fin_name.c_str(), "r" );
    InitGetWord();
    Unit ans = GetProgram();
    PrintError( error_type );
    PrintTree ( ans );
    /*while( ch != EOF ){
        ans.push_back( GetWord() );
        ans[ans.size()-1].print();
        if( error_type != 0 ) {
            printf("error!");
            //PrintError( error_type );
            error_type = 0;
            error_information.clear();
        }
    }*/
}
int TestScan(){
    //int ret = InputTestScan();
    //if( ret != 0 ) return ret;
    InitGetWord();
    while( ch != EOF ){
        ans.push_back( GetWord() );
        if( error_type != 0 ) {
            //PrintError( error_type );
            error_type = 0;
            error_information.clear();
        }
    }
    return 0;
}
void OutPut(){
    freopen( fout_name.c_str(), "w", stdout );
    for( int i=0; i<ans.size(); i++ ) {
        ans[i].print();
    }
    /*printf( "----------------------------------------------------------------\n" );*/
}

int main()
{
    test(); return 0;
    int flag = TestScan();
    if( flag == 0 ) {
        OutPut();
        freopen( "CON", "w", stdout );
        printf( "\nLexical analysis completed, the results have been saved in the \"%s\" file !\n", fout_name.c_str() );
    }
    else {
        freopen( "CON", "w", stdout );
    }
    return 0;
}

Unit GetProgram() {
    Unit ret = Unit( _program ) , add ;
    wd = GetWord();
    if ( wd == error_word ) return error_unit;
    while( wd != finish ) {
        if( wd.type == _data_type ) { // 声明语句
            add = GetDeclaration();
        }
        else { // 语句
            add = GetStatement() ;
        }
        if ( add.is_error == true ) {
            return error_unit ;
        }
        else {
            ret.push ( add ) ;
        }
    }
    return ret;
}
Unit GetDeclaration() {
    Unit ret = Unit( _declaration ) , add ;
    ret.push ( wd ) ;
    wd = GetWord();
    if ( wd == error_word ) return error_unit ;
    if ( wd.type != _identifier ) { // <标识符>
        error_type = 10 ;
        error_information = ret.val ;
        return error_unit ;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord();
        if ( wd == error_word ) return error_unit ;
    }

    if ( wd.val == "=" ) { // = <表达式>
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
        add = GetExpression();
        if( add.is_error == true ){
            return error_unit ;
        }
        else {
            ret.push ( add ) ;
        }
    }
    while( wd.val == "," ) { // 循环添加 , <标识符>
        ret.push ( wd ) ;
        wd = GetWord();
        if ( wd == error_word ) return error_unit ;
        if ( wd.type != _identifier ) {
            error_type = 10 ;
            error_information = "," ;
            return error_unit ;
        }
        else {
            ret.push ( wd ) ;
            wd = GetWord();
            if ( wd == error_word ) return error_unit ;
        }
        if( wd.val == "=" ) {
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
            add = GetExpression();
            if( add.is_error == true ){
                return error_unit;
            }
            else {
                ret.push ( add ) ;
            }
        }
    }
    if( wd.val != ";" ){ // 处理分号
        error_type = 11 ;
        error_information = ret.val ;
        return error_unit;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    return ret;
}
Unit GetExpression() {
    Unit ret = Unit ( _expression ) , add ;
    if ( wd.type != _identifier ) { // bool表达式
        add = GetExpressionBool();
        if ( add.is_error == true ) {
            return error_unit ;
        }
        else {
            ret.push ( add ) ;
        }
    }
    else{
        long fileadd = ftell( fp ) ; // 记录当前位置
        char rem_ch = ch ; // 记录当前ch
        Word rem_wd = wd; // 记录当前wd
        int rem_now_line = now_line ; // 记录当前行数
        //printf("rem: %c",ch); wd.print();

        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
        if ( wd.val == "=" || wd.val == "+=" || wd.val == "-=" || wd.val == "\=" || wd.val == "*=" ) { // 赋值表达式
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
            add = GetExpressionBool();
            if ( add.is_error == true ){
                return error_unit;
            }
            else{
                ret.push ( add ) ;
            }
        }
        else { //bool 表达式
            fseek( fp , fileadd , 0 );// 返回记录文件位置
            ch = rem_ch ;
            wd = rem_wd;
            ret.clear();
            now_line = rem_now_line ;
            //printf("back : %c",ch); wd.print();

            add = GetExpressionBool();
            if ( add.is_error == true ) {
                return error_unit ;
            }
            else {
                ret.push ( add ) ;
            }
        }
    }
    return ret;
}
Unit GetExpressionBool() {
    Unit ret = Unit ( _expression_bool ) , add ;
    add = GetExpressionCal() ;
    if ( add.is_error == true ) {
        return error_unit;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.type == _compare_operator ){
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
        add = GetExpressionCal() ;
        if ( add.is_error == true ) {
            return error_unit;
        }
        else {
            ret.push ( add ) ;
        }
    }
    return ret;
}
Unit GetExpressionCal() {
    Unit ret = Unit ( _expression_cal ) , add ;
    add = GetTerm() ;
    if ( add.is_error == true ) {
        return error_unit;
    }
    else {
        ret.push ( add ) ;
        if ( wd.val == "+" || wd.val == "-" ) {
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
            add = GetTerm() ;
            if ( add.is_error == true ) {
                return error_unit;
            }
            else {
                ret.push ( add ) ;
            }
        }
    }

    return ret;
}
Unit GetTerm() {
    Unit ret = Unit( _term ) , add ;
    add = GetFactor() ;
    if ( add.is_error == true ) {
        return error_unit ;
    }
    else {
        ret.push ( add ) ;
        if ( wd.val == "*" || wd.val == "/" ) {
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
            add = GetTerm() ;
            if ( add.is_error == true ) {
                return error_unit;
            }
            else {
                ret.push ( add ) ;
            }
        }
    }
    return ret;
}
Unit GetFactor() {
    Unit ret = Unit ( _factor ) , add ;
    if ( wd.val == "(" ) { //表达式
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
        add = GetExpression() ;
        if ( add.is_error == true ) {
            ret.is_error = true ;
            return ret;
        }
        else {
            ret.push( add ) ;
        }
        if ( wd.val != ")" ) {
            error_type = 13 ;
            error_information = ret.val;
            ret.is_error = true ;
            return ret;
        }
        else {
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
        }
    }
    else if ( wd.type == _identifier ) { //标识符
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
        if ( wd.type == _single_arithmetic_operator ) { // 自运算
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
        }
    }
    else if ( wd.val == "-" || wd.type == _unsigned_number ) { //数字常量
        if( wd.type == _unsigned_number ) {
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
        }
        else {
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
            if ( wd.type == _unsigned_number ) {
                ret.push ( wd ) ;
                wd = GetWord() ;
                if ( wd == error_word ) return error_unit ;
            }
            else {
                error_type = 13 ;
                error_information = ret.val ;
                ret.is_error = true ;
                return ret;
            }
        }
    }
    else if ( wd.type == _const_character || wd.type == _const_string ) { //字符或字符串常量
        ret.push ( wd ) ;
        wd = GetWord();
        if ( wd == error_word ) return error_unit ;
    }
    else { //不合法factor
        error_type = 13 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    return ret;
}
Unit GetStatement() {
    Unit ret = Unit( _statement ) , add ;
    if ( wd.type == _statement_keyword ) {
        if( wd.val == "if" ) { // if-statement
            add = GetStatementIf() ;
        }
        else if( wd.val == "while" ) { // while-statement
            add = GetStatementWhile() ;
        }
        else if( wd.val == "do" ) { // do_while-statement
            add = GetStatementDoWhile() ;
        }
        else if( wd.val == "for" ) { // for-statement
            add = GetStatementFor() ;
        }
        else if( wd.val == "write" ) { // write-statement
            add = GetStatementWrite() ;
        }
        else if( wd.val == "read" ) { // read-statement
            add = GetStatementRead() ;
        }
        else { // break 语句
            ret.push ( wd ) ;
            wd = GetWord() ;
            if ( wd == error_word ) return error_unit ;
            if ( wd.val != ";" ) {
                error_type = 11 ;
                error_information = ret.val ;
                return error_unit ;
            }
            else {
                ret.push ( wd ) ;
                wd = GetWord();
                if ( wd == error_word ) return error_unit ;
            }
            return ret;
        }
    }
    else {
         if( wd.val == "{" ) { //复合语句
            add = GetStatementCompound() ;
        }
        else { //表达式语句
            add = GetStatementExpression() ;
        }
    }
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( add ) ;
    }
    return ret;
}
Unit GetStatementIf() {
    Unit ret = Unit( _statement_if ) , add ;
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    if ( wd.val != "(" ) {
        error_type = 15 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetExpression() ;
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.val != ")" ) {
        error_type = 13 ;
        error_information = add.val ;
        ret.is_error = true;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetStatement();
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.val == "else" ) { //else 语句
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
        add = GetStatement() ;
        if ( add.is_error == true ) {
            ret.is_error = true ;
            return ret;
        }
        else {
            ret.push ( add ) ;
        }
    }
    return ret;
}
Unit GetStatementWhile() {
    Unit ret = Unit( _statement_while ) , add ;
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    if ( wd.val != "(" ) {
        error_type = 13 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetExpression() ;
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.val != ")" ) {
        error_type = 15 ;
        error_information = add.val ;
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetStatement() ;
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( add ) ;
    }
    return ret;
}
Unit GetStatementDoWhile() {
    Unit ret = Unit( _statement_do_while ) , add ;
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    add = GetStatement() ;
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.val != "while" ) {
        error_type = 18 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    if( wd.val != "(" ) { // 左括号
        error_type = 15;
        error_information = ret.val;
        return error_unit ;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit;
    }
    add = GetExpressionBool() ;
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( add ) ;
    }
    if( wd.val != ")" ) { // 右括号
        error_type = 13;
        error_information = ret.val;
        return error_unit ;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit;
    }
    if ( wd.val != ";" ) {
        error_type = 11 ;
        error_information = add.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    return ret;
}
Unit GetStatementFor() {
    Unit ret = Unit( _statement_for ), add ;
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    if ( wd.val != "(" ) {
        error_type = 15 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetExpression() ; // 表达式一
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.val != ";" ) { // 分号一
        error_type = 11;
        error_information = add.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetExpression() ; // 表达式二
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.val != ";" ) { //分号二
        error_type = 11;
        error_information = add.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetExpression() ; // 表达式三
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.val != ")" ) { // 右括号
        error_type = 13 ;
        error_information = add.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetStatement() ; // 循环语句
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( add ) ;
    }
    return ret ;
}
Unit GetStatementWrite() {
    Unit ret = Unit( _statement_write ) , add ;
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    if ( wd.val != "(" ) {
        error_type = 15 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    add = GetExpressionCal() ;//算术表达式
    if ( add.is_error == true ) {
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( add ) ;
    }
    if ( wd.val != ")" ) {
        error_type = 13 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    if ( wd.val != ";" ) {
        error_type = 11 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    return ret;
}
Unit GetStatementRead() {
    Unit ret = Unit( _statement_read ) , add ;
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    if ( wd.val != "(" ) {
        error_type = 15 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret ;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    if ( wd.type != _identifier ) {
        error_type = 17 ;
        error_information = wd.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    if ( wd.val != ")" ) {
        error_type = 13 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    if ( wd.val != ";" ) {
        error_type = 11 ;
        error_information = ret.val ;
        ret.is_error = true ;
        return ret;
    }
    else {
        ret.push ( wd ) ;
        wd = GetWord() ;
        if ( wd == error_word ) return error_unit ;
    }
    return ret;
}
Unit GetStatementCompound() {
    Unit ret = Unit( _statement_compound ), add ;
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    while( wd.val != "}" ) {
        add = GetStatement();
        if ( add.is_error == true ) {
            ret.is_error = true ;
            return ret;
        }
        else {
            ret.push ( add ) ;
        }
    }
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    return ret ;
}
Unit GetStatementExpression() {
    Unit ret = Unit( _statement_expression ) , add ;
    while( wd.val != ";" ) {
        add = GetExpression();
        if ( add.is_error == true ) {
            ret.is_error = true ;
            return ret;
        }
        else {
            ret.push ( add ) ;
        }
    }
    ret.push ( wd ) ;
    wd = GetWord() ;
    if ( wd == error_word ) return error_unit ;
    return ret;
}



void PrintError( int op ){
///文件操作相关
    if( op == 1 ) { //输入文件打开失败
        printf( "return = %d ERROR: fail to open the source program !\n" , op );
    }
    if( op == 2 ) { //输出文件不存在, 理论不可能发生
        printf( "return = %d ERROR: fail to open the output file !\n" , op );
    }
///词法分析相关
    if( op == 3 ) { //数字常量不合法
        printf( "return = %d ERROR: %s is not a number in line %d !\n" , op , error_information.c_str() , now_line );
    }
    if( op == 4 ) { //小数点后缺少数字
        printf( "return = %d ERROR: Missing Numbers behind the decimal point in line %d !\n" , op , now_line );
    }
    if( op == 5 ) { //单引号不匹配
        printf( "return = %d ERROR: missing terminating \' behind %s character in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 6 ) { // 字符常量超长
        printf( "return = %d ERROR: Character constants %s are excessively long in line %d !\n", error_information.c_str() , now_line );
    }
    if( op == 7 ) { //双引号不匹配
        printf( "return = %d ERROR: missing terminating \" behind %s character in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 8 ) { //运算符不合法
        printf( "return = %d ERROR: the operator %s is not valid in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 9 ) { //非合法字符
        printf( "return = %d ERROR: %s was not legal character in line %d !\n", op , error_information.c_str() , now_line );
    }

///语法分析相关
    if( op == 10 ) { //缺少标识符
        printf( "return = %d ERROR: miss declaration after %s in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 11 ) { //缺少分号
        printf( "return = %d ERROR: miss ';' after %s in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 12 ) { //不是合法表达式
        printf( "return = %d ERROR: %s is not a expression in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 13 ) { //缺少右括号
        printf( "return = %d ERROR: miss ')' after %s in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 14 ) { //不是因子
        printf( "return = %d ERROR: %s is not a factor in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 15 ) { //缺少左括号
        printf( "return = %d ERROR: miss '(' before %s in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 16 ) { //write括号中信息不合法
        printf( "return = %d ERROR: %s is not a declaration in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 17 ) { //read括号中信息不合法
        printf( "return = %d ERROR: %s is not a expression in line %d !\n", op , error_information.c_str() , now_line );
    }
    if( op == 18 ) { //缺少while
        printf( "return = %d ERROR: miss while after 'do' in line %d !\n", op , now_line );
    }
}
vector < Node > Bfs( Unit &s ) {
    queue < Node > q ;
    vector < Node > ret ;
    q.push( Node( s , 0 , -1 ) ) ;
    while( !q.empty() ) {
        Node now = q.front() ;
        ret.push_back( now ) ;
        q.pop();
        for ( int i=0; i<now.x.u.size(); i++ ) {
            q.push ( Node( now.x.u[i] , now.deep+1 , ret.size()-1 ) ) ;
        }
    }
    /*for ( int i=0; i<ret.size(); i++ ) { printf("%d ",ret[i].deep); ret[i].x.println(); }*/
    return ret;
}
void draw( int row_num = 100 ) {
    for ( int i=0; i<row_num; i++ ) {
        for ( int j=0; j<row_limit; j++ ) {
            if ( tree_map[i][j] != 0 )
                printf( "%c" , tree_map[i][j] ) ;
            else {
                printf(" ");
            }
        }
        printf("\n");
    }
}
void PrintTree ( Unit &root ) {
    ///build tree sequence
    vector < Node > temp = Bfs ( root );
    vector < Node > e_vector ;
    vector< vector < Node > > a ;
    for ( int i=0; i<temp.size(); i++ ) {
        temp[i].id = i;
        if ( temp[i].deep >= a.size() ) {
            a.push_back( e_vector );
        }
        a[ temp[i].deep ].push_back( temp[i] ) ;
    }
    for ( int i=0; i<a.size(); i++ ){
        int len = row_limit / a[i].size();
        int limit = len - 2;
        for( int j=0; j<a[i].size(); j++ ) {
            Node &now = a[i][j] ;
            now.mid = j*len + len/2 ;
            if ( now.TypeLength() > limit ) {
                now.tl = j*len +1;
                now.tr = now.tl + limit -1 ;
                now.is_enough_t = false ;
            }
            else {
                now.tl = now.mid - now.TypeLength()/2 ;
                now.tr = now.tl + now.TypeLength() - 1 ;
                now.is_enough_t = true ;
            }
            if ( now.ValLength() > limit ) {
                now.vl = j*len +1;
                now.vr = now.vl + limit -1 ;
                now.is_enough_v = false ;
            }
            else {
                now.vl = now.mid - now.ValLength()/2 ;
                now.vr = now.vl + now.ValLength() - 1 ;
                now.is_enough_v = true ;
            }
        }
    }
    for ( int i=0; i<a.size(); i++ ) {
        for ( int j=0; j<a[i].size(); j++ ) {
            temp[ a[i][j].id ] = a[i][j];
            //printf("%d %d %d \n",i,a[i][j].id ,temp[a[i][j].id].mid);
        }
    }
    ///paint tree map
    memset ( tree_map, 0, sizeof(tree_map) ) ;
    int line_pos = 0 , pre_l = row_limit , pre_r = -1 ;
    for( int i=0; i<a.size(); i++ ) {
        if ( i!=0 ) {
            for ( int j=0; j<a[i].size(); j++ ) {// 划横线
                if ( j==0 || a[i][j].fa!=a[i][j-1].fa ) {
                    pre_l = min( a[i][j].mid , temp[a[i][j].fa].mid ) ;
                }
                if ( j==a[i].size()-1 || a[i][j].fa!=a[i][j+1].fa ) {
                    pre_r = max( a[i][j].mid , temp[a[i][j].fa].mid ) ;
                //printf("%d %d \n",pre_l,pre_r);
                    for ( int k=pre_l; k<=pre_r; k++ ) {
                        tree_map [ line_pos ] [ k ] = '-' ;
                    }
                }
            }
            line_pos++ ;
            for ( int j=0; j<a[i].size(); j++ ) { // 划竖线
                tree_map [ line_pos ] [ a[i][j].mid ] = '|';
            }
            line_pos++ ;
        }
        for ( int j=0; j<a[i].size(); j++ ) {// 输出 Val
            Node &now = a[i][j] ;
            if ( now.is_enough_v == false ) {
                for ( int k=now.vl, p=0; k<=now.vr; k++, p++ ) {
                    tree_map[line_pos][k] = now.x.val[p] ;
                }
                for ( int k=now.vr+1; k<=now.vr+3; k++ ) {
                    tree_map[line_pos][k] = '.' ;
                }
            }
            else {
                for ( int k=now.vl, p=0 ; p<now.x.val.length(); k++, p++ ) {
                    tree_map[line_pos][k] = now.x.val[p] ;
                }
            }
        }
        line_pos++ ;
        for ( int j=0; j<a[i].size(); j++ ) {// 输出 Type
            Node &now = a[i][j] ;
            if ( now.is_enough_t == false ) {
                for ( int k=now.tl, p=0; k<=now.tr; k++, p++ ) {
                    tree_map[line_pos][k] = now.x.type[p] ;
                }
                for ( int k=now.tr+1; k<=now.tr+3; k++ ) {
                    tree_map[line_pos][k] = '.' ;
                }
            }
            else {
                for ( int k=now.tl, p=0 ; p<now.x.type.length(); k++, p++ ) {
                    tree_map[line_pos][k] = now.x.type[p] ;
                }
            }
        }
        line_pos++ ;
        for ( int j=0; j<a[i].size(); j++ ) { // 划竖线(后)
            if ( a[i][j].is_level == false )
                tree_map [ line_pos ] [ a[i][j].mid ] = '|';
        }
        line_pos++ ;

    }
    draw ( line_pos ) ;
}


测试数据

//合法输入:
//www*= a++;
k += c++ -2*x*-3.4;
/*
write(-3.2*(i-3)*(j-4));
int a , b , c = 12 , d = "sadas" ;
*/
/*
while(t--){
    if(3==5-2) write(-3.0*x*y+w*2);
}
*/

/*k = c++ ;

write(-3*i*(j-4));
9.0.0.2.

double c = -6.2;
for( i=-2 ; i<=w ; i++ ) {
    for( j = 3.8; j<i ;j ++) {
        read(d);
        write(-3*i*(j-4));
    }
}

c++;
b = a++;
int a , b , c = 12 , d = "sadas" ;
int a;
b = a++;

if( c == d ) {
    c = w;
}
while( w-- != k*2.2 );
while ( T-- < = 2 ) {
    t=t+1;
}

read(w);
write(432);
write("sds");
write(4/sd+sd*4);
do{
    i++;
    if(k!=2) break;
}while(23+3==s);
*/

运行截图:

                                                         k+=c++-2*x*-3.4;
                                                             [program]
                                                                 |
                                                                 -
                                                                 |
                                                         k+=c++-2*x*-3.4;
                                                            [statement]
                                                                 |
                                                                 -
                                                                 |
                                                         k+=c++-2*x*-3.4;
                                                      [expression statement]
                                                                 |
                                ------------------------------------------------------------------
                                |                                                                |
                         k+=c++-2*x*-3.4                                                         ;
                          [expression]                                                      [delimiter]
                                |
                     ---------------------------------------------------------------------------------------
                     |                                          |                                          |
                     k                                         +=                                    c++-2*x*-3.4
               [identifier]                       [double arithmetic operator]                     [expression bool]
                                                                                                           |
                                                                 -------------------------------------------
                                                                 |
                                                           c++-2*x*-3.4
                                                         [expression cal]
                                                                 |
                     ---------------------------------------------------------------------------------------
                     |                                          |                                          |
                    c++                                         -                                      2*x*-3.4
                  [term]                          [double arithmetic operator]                          [term]
                     |                                                                                     |
                ------                          -----------------------------------------------------------------
                |                               |                               |                               |
               c++                              2                               *                            x*-3.4
            [factor]                        [factor]              [double arithmetic operator]               [term]
                |                               |                                                               |
          ----------------------                -----                    -------------------------------------------
          |                    |                    |                    |                    |                    |
          c                   ++                    2                    x                    *                  -3.4
    [identifier]      [single arithmetic ...[unsigned number]        [factor]        [double arithmetic ...     [term]
                                                                         |                                         |
                                ------------------------------------------                       -------------------
                                |                                                                |
                                x                                                              -3.4
                          [identifier]                                                       [factor]
                                                                                                 |
                                ------------------------------------------------------------------
                                |                                                                |
                                -                                                               3.4
                  [double arithmetic operator]                                           [unsigned number]