簡單的C++解釋器1.02

承接上一篇日志, 我對原來的解釋器做一點小小的改動.

大致增加了如下特性:

1, 允許for(int i = 0; i < 23; i++) 這樣使用for循環, 即在for的括號內部定義循環控制變量.

2,增加了continue關鍵字.

3, 增加了對一些新的數據類型的支持, bool, char, short, int, long, float, double都給予了支持.

4, 增加了true/false關鍵字, 直接對bool變量賦值.

關於增加新的數據類型這件事, 一開始我的想法是:

定義一個結構體, 用來表達上面支持的所有類型, 該結構體會根據實際的類型返回正確的值.

struct var
{
    int type;
    union
    {
        char char_val;
        bool bool_val;
        int int_val;
        double double_val;
        float float_val;
        long long_val;
    }value;
};

當做加法運算的時候, c = a + b; 這里a 和b可以利用某種運算直接返回正確的值, 這樣就可以依賴C++語言自身來處理這個加法了.

不過至於如何能讓一個結構體根據實際類型返回正確的值這個問題, 其實就是在構造一種動態類型, 仔細想想python里面的動態類型應該就是用C這樣寫出來的.

關於如何實現動態語言類型, 可以看看<python源碼剖析>的吧, 不過這里就不搞這件事了, 我直接用一些判斷擼過了~

//這是個匿名的var結構體, 存儲了變量的類型和值, 但是是個匿名的,
//類似python里面的變量的引用的概念
struct anonymous_var
{
    token_ireps var_type; // data type
    long int_value;
    double float_value;
};
// This structure encapsulates the info
// associated with variables.
struct var
{
    char var_name[MAX_ID_LEN + 1]; // name
    anonymous_var value;
};

上面就是我現在使用的結構體的代碼, 用long值存儲所有的整型數據, double值存儲所有的浮點數.

做各種運算的時候, 會將低級別的統一成高級別的來操作, 就是做了一下算數轉換, 這樣實現起來比較簡單.

所有的整型之間運算使用long值來結算, 所有浮點使用double值類結算, 整型和浮點之間運算會把整型數據先轉化成浮點的.

結構體里面只存了long和double, 而在需要使用相應的值的時候(比如要打印一個char)會再把對應的高級類型轉化回去, 可以參看exec_cout函數體.

下面是我改進后的代碼:

敬告, 代碼依然很脆弱, 請使用簡單而且語法正確的程序測試, 而且可能我的改動會引入更多的bug, 所以僅供參考.

/************************************************************************/
/* mccommon.h, 頭文件里面聲明了Minicpp使用的函數, 聲明主要使用的
 * 最新修改時間2012-9-15, 主要增加了var.cpp里面函數的聲明                */
/************************************************************************/

const int MAX_T_LEN  = 128;   // max token length
const int MAX_ID_LEN = 31;    // max identifier length
const int PROG_SIZE  = 10000; // max program size
const int NUM_PARAMS = 31;    // max number of parameters

// Enumeration of token types.
enum tok_types { UNDEFTT, DELIMITER, IDENTIFIER,
                 NUMBER, KEYWORD, TEMP, STRING, BLOCK, TYPE
               };

// Enumeration of internal representation of tokens.
//大部分指定的是C++里面的關鍵字, 當然cout和cin也被加進來了
enum token_ireps { UNDEFTOK, ARG, BOOL, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE, FALSE, TRUE, SWITCH,
                   CASE, IF, ELSE, FOR, DO, WHILE, BREAK,
                   RETURN, COUT, CIN, END, ENDL, DEFAULT, CONTINUE, NONE
                 };


//上面兩個枚舉的區別是上面的比較廣義,指代各種token的類型, 比如block, 這個是不會是關鍵字的,
//下面的可以理解成就是關鍵字

//這是個匿名的var結構體, 存儲了變量的類型和值, 但是是個匿名的,
//類似python里面的變量的引用的概念
struct anonymous_var
{
    token_ireps var_type; // data type
    long int_value;
    double float_value;
};
// This structure encapsulates the info
// associated with variables.
struct var
{
    char var_name[MAX_ID_LEN + 1]; // name
    anonymous_var value;
};


// This structure encapsulates function info.
struct func_type
{
    char func_name[MAX_ID_LEN + 1]; // name
    token_ireps ret_type; // return type
    char *loc; // location of entry point in program
};

// Enumeration of two-character operators, such as <=.
//這里注意從1開始, 以免用到0出現誤解.
enum double_ops { LT = 1, LE, GT, GE, EQ, NE, LS, RS, INC, DEC };

// These are the constants used when throwing a
// syntax error exception.
//
// NOTE: SYNTAX is a generic error message used when
// nothing else seems appropriate.
enum error_msg
{
    SYNTAX, NO_EXP, NOT_VAR, DUP_VAR, DUP_FUNC,
    SEMI_EXPECTED, UNBAL_BRACES, FUNC_UNDEF,
    TYPE_EXPECTED, RET_NOCALL, PAREN_EXPECTED,
    WHILE_EXPECTED, QUOTE_EXPECTED, DIV_BY_ZERO,
    BRACE_EXPECTED, COLON_EXPECTED, UNSUPPORTED_TYPE
    //最后加了一個UNSUPPORTED_TYPE, 是因為最近只支持一些簡單的內建類型
};





//下面這些是全局變量, 用來控制解析的, 估計以后如果重構的話就是parser類的主要成員變量.
extern char *prog;  // current location in source code
extern char *p_buf; // points to start of program buffer

extern char token[MAX_T_LEN + 1]; // string version of token
extern tok_types token_type; // contains type of token
extern token_ireps tok; // internal representation of token

extern anonymous_var ret_value; // function return value

extern bool breakfound; // true if break encountered
extern bool continuefound;//true if continue encountered

// Exception class for Mini C++.
class InterpExc
{
    error_msg err;
public:
    InterpExc(error_msg e)
    {
        err = e;
    }
    error_msg get_err()
    {
        return err;
    }
};

// Interpreter prototypes.
void prescan();
void decl_global();
void call();
void putback();
void decl_local();
void exec_if();
void find_eob();
void exec_for();
void exec_switch();
void get_params();
void get_args();
void exec_while();
void exec_do();
void exec_cout();
void exec_cin();
void assign_var(char *var_name, anonymous_var value);
bool load_program(char *p, char *fname);
anonymous_var find_var(char *s);
void interp();
void func_ret();
char *find_func(char *name);
bool is_var(char *s);
token_ireps find_var_type(char *s);
void find_eol();


// Parser prototypes, 這些函數主要用來parse表達式.
void eval_exp(anonymous_var &value);
void eval_exp0(anonymous_var &value);
void eval_exp1(anonymous_var &value);
void eval_exp2(anonymous_var &value);
void eval_exp3(anonymous_var &value);
void eval_exp4(anonymous_var &value);
void eval_exp5(anonymous_var &value);
void atom(anonymous_var &value);
void sntx_err(error_msg error);
void putback();
bool isdelim(char c);
token_ireps look_up(char *s);
anonymous_var find_var(char *s);
tok_types get_token();
int internal_func(char *s);
bool is_var(char *s);

// "Standard library" prototypes, 這幾個函數里面是調用了一下C++的庫函數, 封裝了一下.
anonymous_var call_getchar();
anonymous_var call_putchar();
anonymous_var call_abs();
anonymous_var call_rand();



//下面這些是為了支持多種類型二增加的一些函數.
//在var.cpp里面實現.
anonymous_var add(anonymous_var &a, anonymous_var &b);
anonymous_var sub(anonymous_var &a, anonymous_var &b);
anonymous_var mul(anonymous_var &a, anonymous_var &b);
anonymous_var div(anonymous_var &a, anonymous_var &b);
void cin_var(anonymous_var &v);
void cout_var(anonymous_var &v);
bool is_valid_type(token_ireps ti);
void init_var(anonymous_var &v);
void neg_var(anonymous_var &v);
bool zero(double x);
void abs_var(anonymous_var &v);
int cmp(anonymous_var &a, anonymous_var &b);
bool is_float_type(token_ireps type);
bool is_int_type(token_ireps type);
bool get_bool_val(anonymous_var &v);
void adaptive_assign_var(anonymous_var &a, anonymous_var &b);


/********************************************************************
var.cpp, 主要是為了增加對多種數值類型的支持而添加的
目前支持bool, char, short, int, long, float, double
基本只使用long和double進行結算.
**********************************************************************/

#include <iostream>
#include <cmath>
#include "mccommon.h"
using namespace std;

inline bool zero(double x)
{
    const double EPS = 1e-9;
    return abs(x) < EPS;
}
bool is_int_type(token_ireps type)
{
    if(type >= BOOL && type <= LONG) return true;
    return false;
}
bool is_float_type(token_ireps type)
{
    if(type >= FLOAT && type <= DOUBLE) return true;
    else return false;
}
bool check_valid_type(anonymous_var &val)
{
    if(!(is_int_type(val.var_type) || is_float_type(val.var_type))) return false;
    return true;
}
anonymous_var add(anonymous_var &a, anonymous_var &b)
{
    if(!check_valid_type(a) || !check_valid_type(b)) throw InterpExc(UNSUPPORTED_TYPE);
    anonymous_var res;
    if(a.var_type > b.var_type) res.var_type = a.var_type;
    else res.var_type = b.var_type;

    if(is_int_type(res.var_type))
    {
        res.int_value = a.int_value + b.int_value;
    }
    else
    {
        if(is_int_type(a.var_type))
        {
            res.float_value = double(a.int_value) + b.float_value;
        }
        else if(is_int_type(b.var_type))
        {
            res.float_value = a.float_value + double(b.int_value);
        }
        else
        {
            res.float_value = a.float_value + b.float_value;
        }
    }
    return res;
}

anonymous_var sub(anonymous_var &a, anonymous_var &b)
{
    if(!check_valid_type(a) || !check_valid_type(b)) throw InterpExc(UNSUPPORTED_TYPE);
    anonymous_var res;
    if(a.var_type > b.var_type) res.var_type = a.var_type;
    else res.var_type = b.var_type;

    if(is_int_type(res.var_type))
    {
        res.int_value = a.int_value - b.int_value;
    }
    else
    {
        if(is_int_type(a.var_type))
        {
            res.float_value = double(a.int_value) - b.float_value;
        }
        else if(is_int_type(b.var_type))
        {
            res.float_value = a.float_value - double(b.int_value);
        }
        else
        {
            res.float_value = a.float_value - b.float_value;
        }
    }
    return res;

}

anonymous_var mul(anonymous_var &a, anonymous_var &b)
{
    if(!check_valid_type(a) || !check_valid_type(b)) throw InterpExc(UNSUPPORTED_TYPE);
    anonymous_var res;

    if(a.var_type > b.var_type) res.var_type = a.var_type;
    else res.var_type = b.var_type;

    if(is_int_type(res.var_type))
    {
        res.int_value = a.int_value * b.int_value;
    }
    else
    {
        if(is_int_type(a.var_type))
        {
            res.float_value = double(a.int_value) * b.float_value;
        }
        else if(is_int_type(b.var_type))
        {
            res.float_value = a.float_value * double(b.int_value);
        }
        else
        {
            res.float_value = a.float_value * b.float_value;
        }
    }
    return res;
}

anonymous_var div(anonymous_var &a, anonymous_var &b)
{
    if(!check_valid_type(a) || !check_valid_type(b)) throw InterpExc(UNSUPPORTED_TYPE);
    anonymous_var res;
    if(a.var_type > b.var_type) res.var_type = a.var_type;
    else res.var_type = b.var_type;

    if(is_int_type(b.var_type))
    {
        if(0 == a.int_value) throw InterpExc(DIV_BY_ZERO);
    }
    else
    {
        if(zero(b.float_value)) throw InterpExc(DIV_BY_ZERO);
    }

    if(is_int_type(res.var_type))
    {
        res.int_value = a.int_value / b.int_value;
    }
    else
    {
        if(is_int_type(a.var_type))
        {
            res.float_value = double(a.int_value) / b.float_value;
        }
        else if(is_int_type(b.var_type))
        {
            res.float_value = a.float_value / double(b.int_value);
        }
        else
        {
            res.float_value = a.float_value / b.float_value;
        }
    }
    return res;
}


//因為現在我只用long 和double來存儲表示所有的數值類型,
//在從控制台讀取內容的時候會不方便, 現在先用
void cin_var(anonymous_var &v)
{
    switch (v.var_type)
    {
    case BOOL:
    {
        bool tmp_var;
        cin >> tmp_var;
        v.int_value = tmp_var;
        break;
    }
    case CHAR:
    {
        char tmp_var;
        cin >> tmp_var;
        v.int_value = tmp_var;
        break;
    }
    case SHORT:
    {
        short tmp_var;
        cin >> tmp_var;
        v.int_value = tmp_var;
        break;
    }
    case INT:
    {
        int tmp_var;
        cin >> tmp_var;
        v.int_value = tmp_var;
        break;
    }
    case LONG:
    {
        long tmp_var;
        cin >> tmp_var;
        v.int_value = tmp_var;
        break;
    }
    case FLOAT:
    {
        float tmp_var;
        cin >> tmp_var;
        v.float_value = tmp_var;
        break;
    }
    case DOUBLE:
    {
        double tmp_var;
        cin >> tmp_var;
        v.float_value = tmp_var;
        break;
    }
    default:
        throw InterpExc(UNSUPPORTED_TYPE);
        break;
    }
}


//輸出的時候, 要先轉化成相應的類型, 然后再打印
void cout_var(anonymous_var &v)
{
    switch(v.var_type)
    {
    case BOOL:
        cout << bool(v.int_value != 0);
        break;
    case CHAR:
        cout << char(v.int_value);
        break;
    case SHORT:
        cout << short(v.int_value);
        break;
    case INT:
        cout << int(v.int_value);
        break;
    case LONG:
        cout << long(v.int_value);
        break;
    case FLOAT:
        cout << float(v.float_value);
        break;
    case DOUBLE:
        cout << double(v.float_value);
        break;
    default:
        throw InterpExc(UNSUPPORTED_TYPE);
        break;
    }
}

bool is_valid_type(token_ireps ti)
{
    return ti >= BOOL && ti <= DOUBLE;
}

void init_var(anonymous_var &v)
{
    v.int_value = 0;
    v.float_value = 0.0;
}

void neg_var(anonymous_var &v)
{
    if(is_int_type(v.var_type))
    {
        v.int_value = -v.int_value;
    }
    else if(is_float_type(v.var_type))
    {
        v.float_value = v.float_value;
    }
    else
    {
        throw InterpExc(UNSUPPORTED_TYPE);
    }
}

void abs_var(anonymous_var &v)
{
    if(is_int_type(v.var_type))
    {
        v.int_value = abs(v.int_value);
    }
    else if(is_float_type(v.var_type))
    {
        v.float_value = abs(v.float_value);
    }
    else
    {
        throw InterpExc(UNSUPPORTED_TYPE);
    }
}



int cmp(anonymous_var &a, anonymous_var &b)
{
    if(!check_valid_type(a) || !check_valid_type(b)) throw InterpExc(UNSUPPORTED_TYPE);
    if(is_int_type(a.var_type))
    {
        if(is_int_type(b.var_type))
        {
            if(a.int_value == b.int_value) return 0;
            if(a.int_value < b.int_value) return -1;
            return 1;
        }
        else if(is_float_type(a.var_type))
        {
            if(zero(a.int_value - b.float_value)) return 0;
            if(a.int_value < b.float_value) return -1;
            return 1;
        }
    }
    else
    {
        if(is_int_type(b.var_type))
        {
            if(zero(a.float_value - b.int_value)) return 0;
            if(a.float_value < b.int_value) return -1;
            return 1;
        }
        else
        {
            if(zero(a.float_value - b.float_value)) return 0;
            if(a.float_value < b.float_value) return -1;
            return 1;
        }
    }
}

bool get_bool_val(anonymous_var &v)
{
    bool bool_val = false;
    if(is_int_type(v.var_type))
    {
        bool_val = v.int_value != 0;
    }
    else if(is_float_type(v.var_type))
    {
        bool_val = !zero(v.float_value);
    }
    else
    {
        throw InterpExc(UNSUPPORTED_TYPE);
    }
    return bool_val;
}


//這個函數適配性地進行了賦值.
void adaptive_assign_var(anonymous_var &a, anonymous_var &b)
{
    if(!check_valid_type(a) || !check_valid_type(b)) throw InterpExc(UNSUPPORTED_TYPE);

    if(is_int_type(a.var_type))
    {
        if(is_int_type(b.var_type))
        {
            a.int_value = b.int_value;
        }
        else
        {
            a.int_value = int(b.float_value);
        }
    }
    else
    {
        if(is_int_type(b.var_type))
        {
            a.float_value = double(b.int_value);
        }
        else
        {
            a.float_value = b.float_value;
        }
    }
}



/*********************************************************************
 parser.cpp 用來遞歸下降地解析表達式, 使用anonymous_var類型傳遞中間結果
*********************************************************************/


// Recursive descent parser for integer expressions.
//
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include "mccommon.h"

using namespace std;

// This structure links a library function name
// with a pointer to that function.
struct intern_func_type
{
    char *f_name; // function name
    anonymous_var (*p)();   // pointer to the function
} intern_func[] =
{
    "getchar", call_getchar,
    "putchar", call_putchar,
    "abs", call_abs,
    "rand", call_rand,
    "", 0  // null terminate the list
};

// Keyword lookup table.
// Keywords must be entered lowercase.
// 定義關鍵字, 對應一個tok的id, 能提高些效率
struct commands
{
    char command[20];
    token_ireps tok;
} com_table[] =
{
    "if", IF,
    "else", ELSE,
    "for", FOR,
    "do", DO,
    "while", WHILE,
    "bool", BOOL,
    "char", CHAR,
    "short", SHORT,
    "int", INT,
    "long", LONG,
    "float", FLOAT,
    "double", DOUBLE,
    "return", RETURN,
    "switch", SWITCH,
    "break", BREAK,
    "case", CASE,
    "cout", COUT,
    "cin", CIN,
    "endl", ENDL,
    "default", DEFAULT,
    "continue", CONTINUE,
    "true", TRUE,
    "false", FALSE,
    "", END  // mark end of table
};

//eval_exp不根據之前讀到的信息來操作, 是在eval_exp函數里面, 讀到什么就調用相應的處理過程.
// Entry point into parser.
void eval_exp(anonymous_var &value)
{
    get_token();

    if(!*token)
    {
        throw InterpExc(NO_EXP);
    }

    //對於空語句給予一個默認的設置.
    if(*token == ';')
    {
        value.var_type = BOOL; // empty expression
        value.int_value = false;
        return;
    }

    eval_exp0(value);


    //這里會把處理完之后讀出來的token再返回去.
    putback(); // return last token read to input stream
}


// Process an assignment expression.
void eval_exp0(anonymous_var &value)
{
    // temp holds name of var receiving the assignment.
    char temp[MAX_ID_LEN + 1];

    tok_types temp_tok;

    if(token_type == IDENTIFIER)
    {
        if(is_var(token))   // if a var, see if assignment
        {
            strcpy(temp, token);
            temp_tok = token_type;
            get_token();
            if(*token == '=')   // is an assignment
            {
                get_token();
                eval_exp0(value); // get value to assign

                assign_var(temp, value); // assign the value

                return;
            }
            else   // not an assignment
            {
                putback(); // restore original token
                strcpy(token, temp);
                token_type = temp_tok;
            }
        }
    }
    eval_exp1(value);
}

// Process relational operators.
void eval_exp1(anonymous_var &value)
{
    anonymous_var partial_value;
    char op;
    char relops[] =
    {
        LT, LE, GT, GE, EQ, NE, 0
    };

    eval_exp2(value);

    op = *token;
    if(strchr(relops, op))
    {
        get_token();
        eval_exp2(partial_value);

        switch(op)   // perform the relational operation
        {
        case LT:
        {
            int res = cmp(value, partial_value);
            value.var_type = BOOL;
            value.int_value = res < 0;
            break;
        }
        case LE:
        {
            int res = cmp(value, partial_value);
            value.var_type = BOOL;
            value.int_value = res <= 0;
            break;
        }
        case GT:
        {
            int res = cmp(value, partial_value);
            value.var_type = BOOL;
            value.int_value = res > 0;
            break;
        }
        case GE:
        {
            int res = cmp(value, partial_value);
            value.var_type = BOOL;
            value.int_value = res >= 0;
            break;
        }
        case EQ:
        {
            int res = cmp(value, partial_value);

            value.var_type = BOOL;
            value.int_value = (res == 0);
            break;
        }
        case NE:
        {
            int res = cmp(value, partial_value);
            value.var_type = BOOL;
            value.int_value = !(res == 0);
            break;
        }
        }
    }
}

// Add or subtract two terms.
void eval_exp2(anonymous_var &value)
{
    char  op;
    anonymous_var partial_value;
    char okops[] =
    {
        '(', INC, DEC, '-', '+', 0
    };

    eval_exp3(value);

    while((op = *token) == '+' || op == '-')
    {
        get_token();

        if(token_type == DELIMITER &&
                !strchr(okops, *token))
            throw InterpExc(SYNTAX);

        eval_exp3(partial_value);



        switch(op)   // add or subtract
        {
        case '-':
        {
            value = sub(value, partial_value);
            break;
        }
        case '+':
        {
            value = add(value, partial_value);
            break;
        }
        }
    }
}

// Multiply or divide two factors.
void eval_exp3(anonymous_var &value)
{
    char  op;
    anonymous_var partial_value;
    char okops[] =
    {
        '(', INC, DEC, '-', '+', 0
    };

    eval_exp4(value);

    while((op = *token) == '*' || op == '/'
            || op == '%')
    {
        get_token();

        if(token_type == DELIMITER &&
                !strchr(okops, *token))
            throw InterpExc(SYNTAX);

        eval_exp4(partial_value);

        switch(op)   // mul, div, or modulus
        {
        case '*':
        {
            value = mul(value, partial_value);
            break;
        }

        case '/':
        {
            //判斷除零異常在程序里面做了
            value = div(value, partial_value);
            break;
        }
        case '%':
        {
            anonymous_var tmp = div(value, partial_value);
            tmp = mul(partial_value, tmp);
            value = sub(value, tmp);
            break;
        }
        }
    }
}

// Is a unary +, -, ++, or --.
void eval_exp4(anonymous_var &value)
{
    char  op;
    char temp;

    op = '\0';
    if(*token == '+' || *token == '-' ||
            *token == INC || *token == DEC)
    {
        temp = *token;
        op = *token;
        get_token();
        value = find_var(token);
        //處理前綴++, --要把變化反應到變量身上.
        if(temp == INC)
        {
            anonymous_var tmp_var;
            tmp_var.int_value = 1;
            tmp_var.var_type = value.var_type;
            value = add(value, tmp_var);
            assign_var(token, value);
            get_token();
            return;
        }
        if(temp == DEC)
        {
            anonymous_var tmp_var;
            tmp_var.int_value = 1;
            tmp_var.var_type = value.var_type;
            value = add(value, tmp_var);
            assign_var(token, value);
            get_token();
            return;
        }
    }

    eval_exp5(value);
    if(op == '-')
    {
        neg_var(value);
    }
}

// Process parenthesized expression.
void eval_exp5(anonymous_var &value)
{
    if((*token == '('))
    {
        get_token();

        eval_exp0(value); // get subexpression

        if(*token != ')')
            throw InterpExc(PAREN_EXPECTED);
        get_token();
    }
    else
        atom(value);
}

// Find value of number, variable, or function.
//增加一個處理功能, 處理浮點數, 但目前只允許***.***的形式, 不允許科學技術法.
void atom(anonymous_var &value)
{
    int i;
    char temp[MAX_ID_LEN + 1];

    switch(token_type)
    {
    case IDENTIFIER:
        i = internal_func(token);
        if(i != -1)
        {
            // Call "standard library" function.
            value = ((*intern_func[i].p)());
        }
        else if(find_func(token))
        {
            // Call programmer-created function.
            call();
            value = ret_value;//目前函數還只支持int返回值
        }
        else
        {

            //在這里處理了后綴++, --
            value = find_var(token); // get var's value
            strcpy(temp, token); // save variable name

            // Check for ++ or --.
            get_token();
            if(*token == INC || *token == DEC)
            {
                anonymous_var tmp_val = find_var(temp);
                value = tmp_val;
                if(*token == INC)
                {
                    anonymous_var one;
                    one.int_value = 1;
                    one.var_type = tmp_val.var_type;
                    tmp_val = add(tmp_val, one);
                    assign_var(temp, tmp_val);
                }
                else
                {
                    anonymous_var one;
                    one.int_value = 1;
                    one.var_type = tmp_val.var_type;
                    tmp_val = sub(tmp_val, one);
                    assign_var(temp, tmp_val);
                }

            }
            else putback();
        }

        get_token();
        return;
    case NUMBER: // is numeric constant
        //這里對浮點和整型類型做個判斷
        if(strchr(token, '.'))
        {

            value.var_type = DOUBLE;
            value.float_value = atof(token);
        }
        else
        {
            value.var_type = INT;
            value.int_value = atoi(token);
        }
        get_token();

        return;

        //char constant
    case DELIMITER: // see if character constant
        if(*token == '\'')
        {
            value.var_type = CHAR;
            value.int_value = *prog;
            prog++;
            if(*prog != '\'')
                throw InterpExc(QUOTE_EXPECTED);

            prog++;
            get_token();

            return ;
        }
        if(*token == ')') return; // process empty expression
        else throw InterpExc(SYNTAX);  // otherwise, syntax error
    case KEYWORD:
    {
        if(0 == strcmp(token, "true"))
        {
            //cout << "jackieddddd" << endl;
            value.var_type = BOOL;
            value.int_value = 1;
        }
        else if(0 == strcmp(token, "false"))
        {
            value.var_type = BOOL;
            value.int_value = 0;
        }
        else
        {
            throw InterpExc(SYNTAX);
        }
        get_token();
        break;
    }
    default:
        throw InterpExc(SYNTAX); // syntax error
    }
}

// Display an error message.
void sntx_err(error_msg error)
{
    char *p, *temp;
    int linecount = 0;

    static char *e[] = //這里的顯示信息, 是跟頭文件里面定義的錯誤flag順序一致的
    {
        "Syntax error",
        "No expression present",
        "Not a variable",
        "Duplicate variable name",
        "Duplicate function name",
        "Semicolon expected",
        "Unbalanced braces",
        "Function undefined",
        "Type specifier expected",
        "Return without call",
        "Parentheses expected",
        "While expected",
        "Closing quote expected",
        "Division by zero",
        "{ expected (control statements must use blocks)",
        "Colon expected",
        "Unsupported type yet",
    };

    // Display error and line number.
    cout << "\n" << e[error];
    p = p_buf;
    while(p != prog)   // find line number of error
    {
        p++;
        if(*p == '\r')
        {
            linecount++;
        }
    }
    cout << " in line " << linecount << endl;

    temp = p;
    while(p > p_buf && *p != '\n') p--;

    // Display offending line.
    while(p <= temp)
        cout << *p++;

    cout << endl;
}

// Get a token.
tok_types get_token()
{
    char *temp;

    token_type = UNDEFTT;
    tok = UNDEFTOK;

    temp = token;
    *temp = '\0';

    // Skip over white space.
    while(isspace(*prog) && *prog) ++prog;

    // Skip over newline.
    while(*prog == '\r')
    {
        ++prog;
        ++prog;
        // Again, skip over white space.
        while(*prog && isspace(*prog)) ++prog;
    }

    // Check for end of program.
    if(*prog == '\0')
    {
        *token = '\0';
        tok = END;
        return (token_type = DELIMITER);
    }

    // Check for block delimiters.
    if(strchr("{}", *prog))
    {
        *temp = *prog;
        temp++;
        *temp = '\0';
        prog++;
        return (token_type = BLOCK);
    }

    // Look for comments.
    if(*prog == '/')
        if(*(prog + 1) == '*') // is a /* comment
        {
            prog += 2;

            //這個循環很給力
            do   // find end of comment
            {
                while(*prog != '*') prog++;
                prog++;
            }
            while (*prog != '/');
            prog++;
            return (token_type = DELIMITER);
        }
        else if(*(prog + 1) == '/')   // is a // comment
        {
            prog += 2;
            // Find end of comment.
            while(*prog != '\r' && *prog != '\0') prog++;
            if(*prog == '\r') prog += 2;
            return (token_type = DELIMITER);
        }

    // Check for double-ops.
    if(strchr("!<>=+-", *prog))
    {
        switch(*prog)
        {
        case '=':
            if(*(prog + 1) == '=')
            {
                prog++;
                prog++;
                *temp = EQ;
                temp++;
                *temp = EQ;
                temp++;
                *temp = '\0';
            }
            break;
        case '!':
            if(*(prog + 1) == '=')
            {
                prog++;
                prog++;
                *temp = NE;
                temp++;
                *temp = NE;
                temp++;
                *temp = '\0';
            }
            break;
        case '<':
            if(*(prog + 1) == '=')
            {
                prog++;
                prog++;
                *temp = LE;
                temp++;
                *temp = LE;
            }
            else if(*(prog + 1) == '<')
            {
                prog++;
                prog++;
                *temp = LS;
                temp++;
                *temp = LS;
            }
            else
            {
                prog++;
                *temp = LT;
            }
            temp++;
            *temp = '\0';
            break;
        case '>':
            if(*(prog + 1) == '=')
            {
                prog++;
                prog++;
                *temp = GE;
                temp++;
                *temp = GE;
            }
            else if(*(prog + 1) == '>')
            {
                prog++;
                prog++;
                *temp = RS;
                temp++;
                *temp = RS;
            }
            else
            {
                prog++;
                *temp = GT;
            }
            temp++;
            *temp = '\0';
            break;
        case '+':
            if(*(prog + 1) == '+')
            {
                prog++;
                prog++;
                *temp = INC;
                temp++;
                *temp = INC;
                temp++;
                *temp = '\0';
            }
            break;
        case '-':
            if(*(prog + 1) == '-')
            {
                prog++;
                prog++;
                *temp = DEC;
                temp++;
                *temp = DEC;
                temp++;
                *temp = '\0';
            }
            break;
        }

        if(*token) return(token_type = DELIMITER);
    }

    // Check for other delimiters.
    if(strchr("+-*^/%=;:(),'", *prog))
    {
        *temp = *prog;
        prog++;
        temp++;
        *temp = '\0';
        return (token_type = DELIMITER);
    }

    // Read a quoted string.
    if(*prog == '"')
    {
        prog++;
        while(*prog != '"' && *prog != '\r' && *prog)
        {
            // Check for \n escape sequence.
            if(*prog == '\\')
            {
                if(*(prog + 1) == 'n')
                {
                    prog++;
                    *temp++ = '\n';
                }
            }
            else if((temp - token) < MAX_T_LEN)
                *temp++ = *prog;

            prog++;
        }
        if(*prog == '\r' || *prog == 0)
            throw InterpExc(SYNTAX);
        prog++;
        *temp = '\0';
        return (token_type = STRING);
    }

    // Read an integer number, or float
    //由於現在還沒加入結構體和類, 所以直接這樣判斷'.'還是可以的, 不過會有隱患, 要記得~
    if(isdigit(*prog) || *prog == '.')
    {
        while(!isdelim(*prog)) //這樣判斷安全嗎?
        {
            if((temp - token) < MAX_ID_LEN)
                *temp++ = *prog;
            prog++;
        }
        *temp = '\0';
        return (token_type = NUMBER);
    }

    // Read identifier or keyword.
    if(isalpha(*prog))
    {
        while(!isdelim(*prog))
        {
            if((temp - token) < MAX_ID_LEN)
                *temp++ = *prog;
            prog++;
        }
        token_type = TEMP;
    }

    *temp = '\0';

    // Determine if token is a keyword or identifier.
    if(token_type == TEMP)
    {
        tok = look_up(token); // convert to internal form
        if(tok) token_type = KEYWORD; // is a keyword
        else token_type = IDENTIFIER;
    }

    // Check for unidentified character in file.
    if(token_type == UNDEFTT)
        throw InterpExc(SYNTAX);

    return token_type;
}

// Return a token to input stream.
void putback()
{
    char *t;

    t = token;
    for(; *t; t++) prog--;
}

// Look up a token's internal representation in the
// token table.
token_ireps look_up(char *s)
{
    int i;

    //C++本來就區分大小寫的, 為什么還給程序轉化..
    //char *p;

    //// Convert to lowercase.
    //p = s;
    //while(*p)
    //{
    //    *p = tolower(*p);
    //    p++;
    //}

    // See if token is in table.
    for(i = 0; *com_table[i].command; i++)
    {
        if(!strcmp(com_table[i].command, s))
            return com_table[i].tok;
    }

    return UNDEFTOK; // unknown command
}

// Return index of internal library function or -1 if
// not found.
int internal_func(char *s)
{
    int i;

    for(i = 0; intern_func[i].f_name[0]; i++)
    {
        if(!strcmp(intern_func[i].f_name, s))  return i;
    }
    return -1;
}

// Return true if c is a delimiter.
bool isdelim(char c)
{
    if(strchr(" !:;,+-<>'/*%^=()", c) || c == 9 ||
            c == '\r' || c == 0) return true;
    return false;
}




/***********************************************************************
minicpp.cpp 主函數在這里, 對於for, if while switch等的實現也寫在了這里.
************************************************************************/
#include <iostream>
#include <fstream>
#include <new>
#include <stack>
#include <vector>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include "mccommon.h"

using namespace std;

char *prog;  // current execution point in source code
char *p_buf; // points to start of program buffer

// This vector holds info for global variables.
vector<var> global_vars;

// This vector holds info for local variables
// and parameters.
vector<var> local_var_stack;

// This vector holds info about functions.
vector<func_type> func_table;

// Stack for managing function scope.

stack<int> func_call_stack;

// Stack for managing nested scopes.
//整形的棧, 存儲的是本函數壓棧之前棧的大小.
stack<int> nest_scope_stack;

char token[MAX_T_LEN + 1]; // current token
tok_types token_type; // token type
token_ireps tok; // internal representation

anonymous_var ret_value; // function return value

bool breakfound = false; // true if break encountered
bool continuefound = false;




int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        cout << "Usage: minicpp <filename>\n";
        return 1;
    }

    // Allocate memory for the program.
    try
    {
        p_buf = new char[PROG_SIZE];
    }
    catch (bad_alloc exc)
    {
        cout << "Could Not Allocate Program Buffer\n";
        return 1;
    }

    // Load the program to execute.
    if(!load_program(p_buf, argv[1])) return 1;

    // Set program pointer to start of program buffer.
    prog = p_buf;

    try
    {
        // Find the location of all functions
        // and global variables in the program.
        prescan();

        // Next, set up the call to main().

        // Find program starting point.
        prog = find_func("main");

        // Check for incorrect or missing main() function.
        if(!prog)
        {
            cout << "main() Not Found\n";
            return 1;
        }

        // Back up to opening (.
        prog--;

        // Set the first token to main
        strcpy(token, "main");

        // Call main() to start interpreting.
        call();
    }
    catch(InterpExc exc)
    {
        sntx_err(exc.get_err());
        return 1;
    }
    catch(bad_alloc exc)
    {
        cout << "Out Of Memory\n";
        return 1;
    }

    return ret_value.int_value;
}

// Load a program.
bool load_program(char *p, char *fname)
{
    int i = 0;

    ifstream in(fname, ios::in | ios::binary);
    if(!in)
    {
        cout << "Cannot Open file.\n";
        return false;
    }

    do
    {
        *p = in.get();
        p++;
        i++;
    }
    while(!in.eof() && i < PROG_SIZE);

    if(i == PROG_SIZE)
    {
        cout << "Program Too Big\n";
        return false;
    }

    // Null terminate the program. Skip any EOF
    // mark if present in the file.
    if(*(p - 2) == 0x1a) *(p - 2) = '\0';
    else *(p - 1) = '\0';

    in.close();

    return true;
}

// Find the location of all functions in the program
// and store global variables.
void prescan()
{
    char *p, *tp;
    char temp[MAX_ID_LEN + 1];
    token_ireps datatype;
    func_type ft;

    // When brace is 0, the current source position
    // is outside of any function.
    int brace = 0;

    p = prog;

    do
    {
        // Bypass code inside functions, brace==0, 保證了現在是在全局作用域
        while(brace)
        {
            get_token();
            if(tok == END) throw InterpExc(UNBAL_BRACES);
            if(*token == '{') brace++;
            if(*token == '}') brace--;
        }

        tp = prog; // save current position
        get_token();

        // See if global var type or function return type.
        if(is_valid_type(tok))
        {
            datatype = tok; // save data type
            get_token();

            if(token_type == IDENTIFIER)
            {
                strcpy(temp, token);
                get_token();

                if(*token != '(')   // must be global var
                {
                    prog = tp; // return to start of declaration
                    decl_global();
                }
                else if(*token == '(')   // must be a function
                {

                    // See if function already defined.
                    for(unsigned i = 0; i < func_table.size(); i++)
                        if(!strcmp(func_table[i].func_name, temp))
                            throw InterpExc(DUP_FUNC);

                    ft.loc = prog;
                    ft.ret_type = datatype;
                    strcpy(ft.func_name, temp);
                    func_table.push_back(ft);

                    do
                    {
                        get_token();
                    }
                    while(*token != ')');
                    // Next token will now be opening curly
                    // brace of function.
                }
                else putback();
            }
        }
        else
        {
            if(*token == '{') brace++;
            if(*token == '}') brace--;
        }
    }
    while(tok != END);
    if(brace) throw InterpExc(UNBAL_BRACES);
    prog = p;
}

// Interpret a single statement or block of code. When
// interp() returns from its initial call, the final
// brace (or a return) in main() has been encountered.

//對於interp我做了一個小改動, 如果執行語句里面有break, 那么就在推出interp之前讓程序把整個block的代碼都走一遍, 但是不執行了
//這樣, 以后調用interp的程序就不用再為break后面的語句做清理工作了.
//在interp里面, 遇到{}會產生一個新的名字空間, 遇到int 和char還會declare一個local變量
void interp()
{
    anonymous_var value;
    int block = 0;
    char *tmp_prog = NULL;
    //break語句會對外面的控制流程造成影響, 但是continue不會, 它只會不讓本次循環后面的語句不執行.
    //但是還是要維護一個全局的continue, 因為本block需要知道子block里面是不是有continue;
    do
    {
        if(breakfound || continuefound)
        {

            //如果這是個{}包含的塊, 那么就用find_eob把整個塊吃掉
            if(block && tmp_prog)
            {

                prog = tmp_prog;
                find_eob();
            }
            else
            {
                //對於知識一條語句的塊, 在break跳出之前吃掉這個分號
                get_token();

            }
            return;
        }

        token_type = get_token();
        //對於那些exec_while, exec_while那個向前看的token是在這里讀出來的
        //跟eval_exp沒有關系.

        // See what kind of token is up.
        if(token_type == IDENTIFIER ||
                *token == INC || *token == DEC)
        {
            // Not a keyword, so process expression.
            putback();  // restore token to input stream for
            // further processing by eval_exp()
            eval_exp(value); // process the expression
            //eval_exp和exec_while是相同的層次, 在interp看到向前看字符的時候, 就會遞歸調用相應的過程.
            if(*token != ';') throw InterpExc(SEMI_EXPECTED);
        }
        else if(token_type == BLOCK) // block delimiter?
        {
            if(*token == '{')   // is a block
            {
                putback();
                tmp_prog = prog;
                get_token();
                block = 1; // interpreting block, not statement
                // Record nested scope.
                nest_scope_stack.push(local_var_stack.size());
                //nest_scope_stack里面存的是上一個block的stack的位置,
                //用戶恢復棧.
            }
            else   // is a }, so reset scope and return
            {
                // Reset nested scope.
                local_var_stack.resize(nest_scope_stack.top());
                nest_scope_stack.pop();
                return;
            }
        }
        else if(is_valid_type(tok))
        {
            putback();
            decl_local();
        }
        else // is keyword
            switch(tok)
            {
            case RETURN:  // return from function call, 不要在這里清理局部作用域了, call里面做了處理.
                /*if(block)
                {
                    local_var_stack.resize(nest_scope_stack.top());
                    nest_scope_stack.pop();
                }*/
                func_ret();
                return;
            case IF:      // process an if statement
                exec_if();
                break;
            case ELSE:    // process an else statement
                find_eob(); // find end of else block
                // and continue execution
                break;
            case WHILE:   // process a while loop
                exec_while();
                break;
            case DO:      // process a do-while loop
                exec_do();
                break;
            case FOR:     // process a for loop
                exec_for();

                break;
            case BREAK:   // handle break
                breakfound = true;
                // Reset nested scope.
                //這里要特判一下是不是從一個block里面的break, 因為在我修改之后, for while的循環體現在可以是
                //一個單個的語句了
                if(block)
                {
                    local_var_stack.resize(nest_scope_stack.top());
                    nest_scope_stack.pop();
                }
                break;
            case CONTINUE:
            {
                continuefound = true;
                if(block)
                {
                    local_var_stack.resize(nest_scope_stack.top());
                    nest_scope_stack.pop();
                }
                break;
            }
            case SWITCH:  // handle a switch statement
                exec_switch();
                break;
            case COUT:    // handle console output
                exec_cout();
                //cout << "breakfuond :" << breakfound << endl;
                break;
            case CIN:     // handle console input
                exec_cin();
                break;
            case END:
                exit(0);

            }
    }
    while (tok != END && block);
    return;
}


//可以使用map優化.
// Return the entry point of the specified function.
// Return NULL if not found.
char *find_func(char *name)
{
    unsigned i;

    for(i = 0; i < func_table.size(); i++)
        if(!strcmp(name, func_table[i].func_name))
            return func_table[i].loc;

    return NULL;
}

// Declare a global variable.
void decl_global()
{
    token_ireps vartype;
    var v;

    get_token(); // get type

    vartype = tok; // save var type

    anonymous_var value;

    // Process comma-separated list.
    do
    {
        v.value.var_type = vartype;
        init_var(v.value); // init to 0
        get_token(); // get name

        // See if variable is a duplicate.
        for(unsigned i = 0; i < global_vars.size(); i++)
            if(!strcmp(global_vars[i].var_name, token))
                throw InterpExc(DUP_VAR);

        strcpy(v.var_name, token);
        global_vars.push_back(v);

        putback();
        eval_exp(value); //這個eval_exp會實現賦值, 這里value只是個啞元, 我們不用

        get_token();

    }
    while(*token == ',');

    if(*token != ';') throw InterpExc(SEMI_EXPECTED);
}

// Declare a local variable.
void decl_local()
{
    var v;

    get_token(); // get var type
    v.value.var_type = tok; // store type

    init_var(v.value); // init var to 0, 對局部變量也直接初始化成0了..
    anonymous_var value;

    // Process comma-separated list.
    do
    {
        get_token(); // get var name

        // See if variable is already the name
        // of a local variable in this scope.
        if(!local_var_stack.empty())
            for(int i = local_var_stack.size() - 1;
                    i >= nest_scope_stack.top(); i--)
            {
                if(!strcmp(local_var_stack[i].var_name, token))
                    throw InterpExc(DUP_VAR);
            }

        strcpy(v.var_name, token);
        local_var_stack.push_back(v);
        putback();
        eval_exp(value);//這個eval_exp會實現賦值, 這里value只是個啞元, 我們不用
        get_token();
    }
    while(*token == ',');

    if(*token != ';') throw InterpExc(SEMI_EXPECTED);
}

// Call a function.
void call()
{
    char *loc, *temp;
    int lvartemp;

    // First, find entry point of function.
    loc = find_func(token);

    if(loc == NULL)
        throw InterpExc(FUNC_UNDEF); // function not defined
    else
    {
        // Save local var stack index.
        lvartemp = local_var_stack.size();

        //get_args 和get_params先后調用 , 進行了一下替換
        get_args(); // get function arguments
        temp = prog; // save return location

        func_call_stack.push(lvartemp); // push local var index

        prog = loc; // reset prog to start of function
        get_params(); // load the function's parameters with
        // the values of the arguments

        interp(); // interpret the function

        prog = temp; // reset the program pointer

        if(func_call_stack.empty()) throw InterpExc(RET_NOCALL);

        // Reset local_var_stack to its previous state.

        //這里的resize會把后面的剛剛壓入棧的變量刪掉.
        local_var_stack.resize(func_call_stack.top());
        func_call_stack.pop();
    }
}

// Push the arguments to a function onto the local
// variable stack.
void get_args()
{
    anonymous_var value, temp[NUM_PARAMS];
    int count = 0;
    var vt;

    count = 0;
    get_token();
    if(*token != '(') throw InterpExc(PAREN_EXPECTED);

    // Process a comma-separated list of values.
    do
    {
        eval_exp(value);
        temp[count] = value; // save temporarily
        get_token();
        count++;
    }
    while(*token == ',');
    count--;

    // Now, push on local_var_stack in reverse order.
    for(; count >= 0; count--)
    {
        vt.value = temp[count];
        local_var_stack.push_back(vt);
    }
}

// Get function parameters.

//在這個函數里面實現了從實參到形參的轉化工作, 不錯.
void get_params()
{
    var *p;
    int i;

    i = local_var_stack.size() - 1;

    // Process comma-separated list of parameters.
    do
    {
        get_token();
        p = &local_var_stack[i];
        if(*token != ')' )
        {
            if(is_valid_type(tok))
                throw InterpExc(TYPE_EXPECTED);

            p->value.var_type = tok;
            get_token();

            // Link parameter name with argument already on
            // local var stack.
            strcpy(p->var_name, token);
            get_token();
            i--;
        }
        else break;
    }
    while(*token == ',');

    //在這里判了一下, 看最后一個讀到的是不是')'
    if(*token != ')') throw InterpExc(PAREN_EXPECTED);
}

// Return from a function.
void func_ret()
{
    anonymous_var value;

    //value = 0;

    // Get return value, if any.
    //目前設定是只支持int返回值.
    eval_exp(value);

    ret_value = value;
}

// Assign a value to a variable.
void assign_var(char *vname, anonymous_var value)
{
    //cout << "assign_var" << endl;
    // First, see if it's a local variable.
    if(!local_var_stack.empty())
        for(int i = local_var_stack.size() - 1;
                i >= func_call_stack.top(); i--)
        {
            if(!strcmp(local_var_stack[i].var_name,
                       vname))
            {
                adaptive_assign_var(local_var_stack[i].value, value);
                return;
            }
        }

    // Otherwise, try global vars.
    for(unsigned i = 0; i < global_vars.size(); i++)
        if(!strcmp(global_vars[i].var_name, vname))
        {
            adaptive_assign_var(global_vars[i].value, value);
            //cout << value.float_value << " >>>" << endl;
            return;
        }

    throw InterpExc(NOT_VAR); // variable not found
}

// Find the value of a variable.
anonymous_var find_var(char *vname)
{
    // First, see if it's a local variable.
    if(!local_var_stack.empty())
        for(int i = local_var_stack.size() - 1;
                i >= func_call_stack.top(); i--)
        {
            if(!strcmp(local_var_stack[i].var_name, vname))
                return local_var_stack[i].value;
        }

    // Otherwise, try global vars.
    for(unsigned i = 0; i < global_vars.size(); i++)
        if(!strcmp(global_vars[i].var_name, vname))
            return global_vars[i].value;

    throw InterpExc(NOT_VAR); // variable not found
}


//在處理if的時候也處理了else的模塊
// Execute an if statement.
void exec_if()
{
    anonymous_var cond;

    eval_exp(cond); // get if expression.

    if(get_bool_val(cond))   // if true, process target of IF
    {
        // Confirm start of block.

        interp();
    }
    else
    {
        // Otherwise skip around IF block and
        // process the ELSE, if present.

        find_eob(); // find start of next line
        get_token();

        if(tok != ELSE)
        {
            // Restore token if no ELSE is present.
            putback();
            return;
        }
        // Confirm start of block.
        get_token();

        if(tok == IF)
        {
            exec_if();
            return;
        }
        putback();
        interp();
    }
}

// Execute a switch statement.
void exec_switch()
{
    anonymous_var sval, cval;
    int brace;

    eval_exp(sval); // Get switch expression.

    // Check for start of block.
    if(*token != '{')
        throw InterpExc(BRACE_EXPECTED);

    // Record new scope.
    nest_scope_stack.push(local_var_stack.size());

    // Now, check case statements.
    for(;;)
    {
        brace = 1;
        // Find a case statement.
        do
        {
            get_token();
            if(*token == '{') brace++;
            else if(*token == '}') brace--;
        }
        while(tok != CASE && tok != END && brace && tok != DEFAULT);

        // If no matching case found, then skip.
        if(!brace) break;


        if(tok == END) throw InterpExc(SYNTAX);
        if(tok == DEFAULT)
        {
            get_token();
            if(*token != ':')
                throw InterpExc(COLON_EXPECTED);
            do
            {
                interp();
                get_token();
                if(*token == '}')
                {
                    putback();
                    break;
                }
                putback();
                //if(*token == '{') brace++;
                //else if(*token == '}') brace--;
            }
            while(!breakfound && tok != END);

            brace = 1;

            // Find end of switch statement.
            while(brace)
            {
                get_token();
                if(*token == '{') brace++;
                else if(*token == '}') brace--;
            }
            breakfound = false;

            break;

        }

        // Get value of the case statement.
        eval_exp(cval);

        // Read and discard the :
        get_token();

        if(*token != ':')
            throw InterpExc(COLON_EXPECTED);

        // If values match, then interpret.
        if(0 == cmp(cval, sval))
        {

            do
            {
                interp();

                get_token();
                if(*token == '}')
                {
                    putback();
                    break;
                }
                putback();
            }
            while(!breakfound && tok != END && brace);

            brace = 1;

            // Find end of switch statement.
            while(brace)
            {
                get_token();
                if(*token == '{') brace++;
                else if(*token == '}') brace--;
            }
            breakfound = false;

            break;
        }
    }
}

// Execute a while loop.
//同下面的do while, 這個也會putback while
void exec_while()
{
    anonymous_var cond;
    char *temp;

    putback(); // put back the while
    temp = prog; // save location of top of while loop

    get_token();
    eval_exp(cond); // check the conditional expression

    if(get_bool_val(cond))
        interp(); // if true, interpret
    else   // otherwise, skip to end of loop
    {
        find_eob();
        return;
    }
    continuefound = false;
    if(!breakfound)
        prog = temp; // loop back to top
    else
    {
        breakfound = false;
        return;
    }
}

// Execute a do loop.

//解釋: exec_do是在主函數讀到了do的時候才會調用, 因此
//在exec_do調用的時候, do這個token已經被讀出來了,
//而exec_do還想要在需要繼續執行的時候是prog復位到do, 那么就得在程序開始putback一下.
void exec_do()
{
    anonymous_var cond;
    char *temp;

    // Save location of top of do loop.
    putback(); // put back do
    temp = prog;

    get_token(); // get start of loop block

    // Confirm start of block.
    get_token();
    if(*token != '{')
        throw InterpExc(BRACE_EXPECTED);
    putback();

    interp(); // interpret loop

    // Check for break in loop.
    if(breakfound)
    {
        breakfound = false;
        get_token();
        if(tok != WHILE) throw InterpExc(WHILE_EXPECTED);
        eval_exp(cond); // check the loop condition
        return;
    }
    if(continuefound)
    {
        continuefound = false;
        prog = temp;
        return;
    }

    get_token();
    if(tok != WHILE) throw InterpExc(WHILE_EXPECTED);

    eval_exp(cond); // check the loop condition

    // If true loop; otherwise, continue on.

    if(get_bool_val(cond)) prog = temp;
}

// Execute a for loop.
//但是for就不能像while和do while那樣, 在需要繼續循環的時候復位prog指針了, 因為for
//復位的話, 初始點也跟着復位了, 就是for(int i= 0; i< 12; i++)里面的i也會變成0
void exec_for()
{
    anonymous_var cond;
    char *temp, *temp2;
    int paren ;

    //for_local用來標記是不是在for()內部定義了新變量, 如果是, 就會產生新的作用域
    bool for_local = false;

    get_token(); // skip opening (
    get_token();

    if(is_valid_type(tok))//當前讀入的token是個類型關鍵字, 這樣就會觸發一個局部作用域
    {
        putback();
        nest_scope_stack.push(local_var_stack.size());
        for_local = true;
        decl_local();

    }
    else
    {
        eval_exp(cond); // initialization expression
    }

    //這個是decl_local和eval_exp最后讀到的token, 已經被讀出來了
    if(*token != ';') throw InterpExc(SEMI_EXPECTED);

    prog++; // get past the ;
    temp = prog;

    for(;;)
    {
        // Get the value of the conditional expression.
        eval_exp(cond);

        if(*token != ';') throw InterpExc(SEMI_EXPECTED);
        prog++; // get past the ;
        temp2 = prog;

        // Find start of for block.
        paren = 1;
        while(paren)
        {
            get_token();
            if(*token == '(') paren++;
            if(*token == ')') paren--;
        }


        // If condition is true, interpret
        //現在從for()后面開始interpret
        //
        if(get_bool_val(cond))
        {
            //continue只對interp里面的執行起作用, 不會對外面有影響.
            interp();
            //cout << prog << endl;

        }
        else   // otherwise, skip to end of loop
        {
            find_eob();
            if(for_local)
            {
                local_var_stack.resize(nest_scope_stack.top());
                nest_scope_stack.pop();
            }
            return;
        }
        if(breakfound)
        {
            breakfound = false;
            if(for_local)
            {
                local_var_stack.resize(nest_scope_stack.top());
                nest_scope_stack.pop();
            }
            return;
        }
        if(continuefound)
        {
            continuefound = false;
        }


        prog = temp2; // go to increment expression

        // Check for break in loop.



        // Evaluate the increment expression.
        eval_exp(cond);

        prog = temp; // loop back to top
    }

}

// Execute a cout statement.
void exec_cout()
{
    anonymous_var val;

    get_token();
    if(*token != LS) throw InterpExc(SYNTAX);
    do
    {
        get_token();

        if(token_type == STRING)
        {
            // Output a string.
            cout << token;
        }
        else if(tok == ENDL)
        {
            cout << endl;
        }
        else
        {
            //cout << token << " :---" << endl;
            putback();
            eval_exp(val);
            //cout << val.float_value << "<<<" << endl;
            cout_var(val);
        }

        get_token();
    }
    while(*token == LS); //<<

    if(*token != ';') throw InterpExc(SEMI_EXPECTED);
}

// Execute a cin statement.
void exec_cin()
{
    token_ireps vtype;

    get_token();
    if(*token != RS) throw InterpExc(SYNTAX);

    do
    {
        get_token();
        if(token_type != IDENTIFIER)
            throw InterpExc(NOT_VAR);

        vtype = find_var_type(token);
        anonymous_var tmp;
        tmp.var_type = vtype;

        cin_var(tmp);
        assign_var(token, tmp);
        get_token();
    }
    while(*token == RS); //RS 是>>

    if(*token != ';') throw InterpExc(SEMI_EXPECTED);
}


// Find the end of a block.
//#這里find_eob在邏輯上做了一點修改, 由外部保證調用的正確
//如果開始的是{, 那么就處理一個block, 否則就調用find_eol處理一個;語句.
void find_eob()
{
    int brace;

    get_token();
    //cout << token <<  " find_eob" <<endl;
    if(*token != '{')
    {
        putback();
        find_eol();
        return ;
    }

    brace = 1;

    do
    {
        get_token();
        //cout << token <<  " find_eob" <<endl;
        if(*token == '{') brace++;
        else if(*token == '}') brace--;
    }
    while(brace && tok != END);

    if(tok == END) throw InterpExc(UNBAL_BRACES);
}

void find_eol()
{
    do
    {
        get_token();
    }
    while (*token != ';' && tok != END);

    if(tok == END) throw InterpExc(SYNTAX);
}

// Determine if an identifier is a variable. Return
// true if variable is found; false otherwise.
bool is_var(char *vname)
{
    // See if vname a local variable.
    if(!local_var_stack.empty())
        for(int i = local_var_stack.size() - 1;
                i >= func_call_stack.top(); i--)
        {
            if(!strcmp(local_var_stack[i].var_name, vname))
                return true;
        }

    // See if vname is a global variable.
    for(unsigned i = 0; i < global_vars.size(); i++)
        if(!strcmp(global_vars[i].var_name, vname))
            return true;

    return false;
}

// Return the type of variable.
token_ireps find_var_type(char *vname)
{
    // First, see if it's a local variable.
    if(!local_var_stack.empty())
        for(int i = local_var_stack.size() - 1;
                i >= func_call_stack.top(); i--)
        {
            if(!strcmp(local_var_stack[i].var_name, vname))
                return local_var_stack[i].value.var_type;
        }

    // Otherwise, try global vars.
    for(unsigned i = 0; i < global_vars.size(); i++)
        if(!strcmp(global_vars[i].var_name, vname))
            return local_var_stack[i].value.var_type;

    return UNDEFTOK;
}


/***********************************************************************
 libcpp.cpp, 主要是對庫函數的封裝
************************************************************************/

// Add more of your own, here.

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include "mccommon.h"

using namespace std;

// Read a character from the console.
// If your compiler supplies an unbuffered
// character intput function, feel free to
// substitute it for the call to cin.get().
anonymous_var call_getchar()
{
    char ch;

    ch = getchar();

    // Advance past ()
    get_token();
    if(*token != '(')
        throw InterpExc(PAREN_EXPECTED);

    get_token();
    if(*token != ')')
        throw InterpExc(PAREN_EXPECTED);
    anonymous_var val;
    val.var_type = CHAR;
    val.int_value = ch;
    return val;
}

// Write a character to the display.
anonymous_var call_putchar()
{
    anonymous_var value;

    eval_exp(value);

    putchar(char(value.int_value));

    return value;
}

// Return absolute value.
anonymous_var call_abs()
{
    anonymous_var val;

    eval_exp(val);
    abs_var(val);
    return val;
}

// Return a randome integer.
anonymous_var call_rand()
{

    // Advance past ()
    get_token();
    if(*token != '(')
        throw InterpExc(PAREN_EXPECTED);

    get_token();
    if(*token != ')')
        throw InterpExc(PAREN_EXPECTED);

    anonymous_var val;
    val.var_type = INT;
    val.int_value = rand();
    return val;
}

~~