/**
* rdcheck.cpp: Don't generate syntax tree
* author: Justin Han
* time: 2019/11/22
*/

#include <stdio.h>
#include <string.h>
/**
* define the VN
*/
#define A program
#define A1 A1
#define B external_declaration
#define C decl_or_stmt
#define C1 C1
#define D declarator_list
#define D1 D1
#define E intstr_list
#define E1 E1
#define F initializer
#define G declarator
#define G1 G1
#define G2 G2
#define G3 G3
#define G4 G4
#define H parameter_list
#define H1 H1
#define I parameter
#define J Type
#define K statement
#define K1 K1
#define K2 K2
#define K3 K3
#define L statement_list
#define L1 L1
#define M expression_statement
#define N expr
#define O cmp_expr
#define O1 O1
#define P add_expr
#define P1 P1
#define P2 P2
#define Q mul_expr
#define Q1 Q1
#define Q2 Q2
#define R primary_expr
#define R1 R1
#define R2 R2
#define R3 R3
#define S expr_list
#define S1 S1
#define T id_list
#define T1 T1

/**
* define class-numbers of symbols
*/
#define ALPHABET 0
#define DEGIT 1
#define WHITESPACE 2
#define SEPCHAR 3
#define MATHCHAR 4
#define STRING 5

/**
* define classes of symbols
*/
const char alphabet[52] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 
'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 
'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 
'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
const char degit[10] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
const char whitespace[3] = { ' ', '\n', '\t' };
const char sepchar[10] = { '{', '}', ';', ',', '.', '(', ')' ,'"', '[', ']' };
const char mathchar[9] = { '>', '<', '=', '+', '-', '|', '/', '*', '%' };

/*define class-numbers of words
* INT 19
* FLOAT 20
* STRING 21
* SPECIAL_WORD sepchar_subscript_index+30
* MATHCHAR mathchar_subscript_index+40
* ID 22
* annotation 23
*/

/**
* define IDs and mathwords 
*/
const char* tokens[19] = { "args", "class", "else", "for", "if", "int", "main", "new", "out", "package", "private", "public", "print", "println", "return", "static", "String", "System", "void" };
const char* mathWords[17] = { ">", "<", "=", "+", "-", "|", "/", "*", "%", ">=", "<=", "++", "--", "==" ,"||", "-=", "+=" };

/**
* define the VT
* n NUMBER
* s STRING
* i ID
* a INT
* b STR
* c VOID
* d IF
* e ELSE
* f WHILE
* g RETURN
* h PRINT
* j SCAN
* k CMP
* l ASSIGN
*/

/**
* Define the FIRST set
*/
const char FIRST_A[3] = { 'a','b','c' };
const char FIRST_A1[4] = { 'a','b','c','\n' };
const char FIRST_B[3] = { 'a','b','c' };
const char FIRST_C[3] = { '{',',',';' };
const char FIRST_C1[16] = { 'a','b','c','{',';','i','(','n','s','-','d','f','g','h','j','}' };
const char FIRST_D[1] = { 'i' };
const char FIRST_D1[2] = { ',','\n' };
const char FIRST_E[2] = { 'n','s' };
const char FIRST_E1[2] = { ',', '\n' };
const char FIRST_F[2] = { 'n','s' };
const char FIRST_G[1] = { 'i' };
const char FIRST_G1[4] = { '=','(','[','\n' };
const char FIRST_G2[4] = { ')','a','b','c' };
const char FIRST_G3[6] = { ']','i','(','n','s','-' };
const char FIRST_G4[2] = { '{','\n' };
const char FIRST_H[3] = { 'a','b','c' };
const char FIRST_H1[2] = { ',','\n' };
const char FIRST_I[3] = {'a','b','c'};
const char FIRST_J[3] = { 'a','b','c' };
const char FIRST_K[15] = { 'a','b','c','{',';','i','(','n','s','-','d','f','g','h','j' };
const char FIRST_K1[2] = { 'e','\n' };
const char FIRST_K2[] = { ';','i','(','n','s','-' };
const char FIRST_K3[] = { ';','i','(','n','s','-' };
const char FIRST_L[] = { 'a','b','c','{',';','i','(','n','s','-','d','f','g','h','j' };
const char FIRST_L1[] = { 'a','b','c','{',';','i','(','n','s','-','d','f','g','h','j' ,'\n' };
const char FIRST_M[] = { ';','i','(','n','s','-' };
const char FIRST_N[] = { 'i','(','n','s','-' };
const char FIRST_O[] = { 'i','(','n','s','-' };
const char FIRST_O1[] = { 'k','\n' };
const char FIRST_P[] = { 'i','(','n','s','-' };
const char FIRST_P1[] = { '+','-' };
const char FIRST_P2[] = { 'i','(','n','s','-','+'};
const char FIRST_Q[] = { 'i','(','n','s','-' };
const char FIRST_Q1[] = { '*','/','%' };
const char FIRST_Q2[] = { '*','/','%','\n' };
const char FIRST_R[] = { 'i','(','n','s' };
const char FIRST_R1[] = { '(','l','=','[','\n' };
const char FIRST_R2[] = { 'i','(',')','n','s','-' };
const char FIRST_R3[] = { '=','\n' };
const char FIRST_S[] = { 'i','(','n','s','-' };
const char FIRST_S1[] = { ',','\n' };
const char FIRST_T[] = { 'i' };
const char FIRST_T1[] = { ',','\n' };

/**
* Define the FOLLOW set
*/
const char FOLLOW_A[] = { '#' };
const char FOLLOW_A1[] = { '#' };
const char FOLLOW_B[] = { 'a','b','c','#' };
const char FOLLOW_C[] = { 'a','b','c','#' };
const char FOLLOW_C1[] = { 'a','b','c','#' };
const char FOLLOW_D[] = { ';' };
const char FOLLOW_D1[] = { ';' };
const char FOLLOW_E[] = { '}' };
const char FOLLOW_E1[] = { '}' };
const char FOLLOW_F[] = { '}',',' };
const char FOLLOW_G[] = { ';','{',',' };
const char FOLLOW_G1[] = { ';','{',',' };
const char FOLLOW_G2[] = { ';','{',',' };
const char FOLLOW_G3[] = { ';','{',',' };
const char FOLLOW_G4[] = { ';','{',',' };
const char FOLLOW_H[] = { ')' };
const char FOLLOW_H1[] = { ')' };
const char FOLLOW_I[] = { ',',')' };
const char FOLLOW_J[] = { 'i' };
const char FOLLOW_K[] = { '}','e','a','b','c','{',';','i','(','n','s','-','d','f','g','h','j' };
const char FOLLOW_K1[] = { '}','e','a','b','c','{',';','i','(','n','s','-','d','f','g','h','j' };
const char FOLLOW_K2[] = { '}','e','a','b','c','{',';','i','(','n','s','-','d','f','g','h','j' };
const char FOLLOW_K3[] = { '}','e','a','b','c','{',';','i','(','n','s','-','d','f','g','h','j' };
const char FOLLOw_L[] = { '}' };
const char FOLLOW_L1[] = { '}' };
const char FOLLOW_M[] = { '}','e','a','b','c','{',';','i','(','n','s','-','d','f','g','h','j' };
const char FOLLOW_N[] = { ']',')',';','{',',','*','/','%','i','(','n','s','-','k' ,'+' };
const char FOLLOW_O[] = { ']',')',';','{',',','*','/','%','i','(','n','s','-','k' ,'+' };
const char FOLLOW_O1[] = { ']',')',';','{',',','*','/','%','i','(','n','s','-','k' ,'+' };
const char FOLLOW_P[] = { ']',')',';','{',',','*','/','%','i','(','n','s','-','k' ,'+' };
const char FOLLOW_P1[] = { ']',')',';','{',',','*','/','%','i','(','n','s','-','k' ,'+' };
const char FOLLOW_P2[] = { ']',')',';','{',',','*','/','%','i','(','n','s','-','k' ,'+' };
const char FOLLOW_Q[] = { ']',')',';','i','(','n','s','-','k','{',',','+','*','/','%' };
const char FOLLOW_Q1[] = { ']',')',';','*','/','%','i','(','n','s','-','k','{',',','+' };
const char FOLLOW_Q2[] = { ']',')',';','i','(','n','s','-','k','{',',','+','*','/','%' };
const char FOLLOW_R[] = { ']',')',';','*','/','%','i','(','n','s','-','k','{',',' ,'+'};
const char FOLLOW_R1[] = { ']',')',';','*','/','%','i','(','n','s','-','k','{',',' ,'+'};
const char FOLLOW_R2[] = { ']',')',';','*','/','%','i','(','n','s','-','k','{',',' ,'+'};
const char FOLLOW_R3[] = { ']',')',';','*','/','%','i','(','n','s','-','k','{',',' ,'+'};
const char FOLLOW_S[] = { ';',')' };
const char FOLLOW_S1[] = { ';',')' };
const char FOLLOW_T[] = { ';' };
const char FOLLOW_T1[] = { ';' };

/**
* The symbolList, symbol to be matched and its index
*/
char sym = '0';
int i = 0;
char result[5000];

/**
* transform char to string
*/
char* toString(char ch)
{
    char str[2];
    str[0] = ch;
    str[1] = 0;
    return str;
}

/**
* generate symbols
*/
char* token(char* symbol, int charClass)
{
    char ch = '0';

    if (charClass == 0)
        if (strcmp(symbol, "int") == 0)
            ch = 'a';
        else if (strcmp(symbol, "str") == 0)
            ch = 'b';
        else if (strcmp(symbol, "void") == 0)
            ch = 'c';
        else if (strcmp(symbol, "if") == 0)
            ch = 'd';
        else if (strcmp(symbol, "else") == 0)
            ch = 'e';
        else if (strcmp(symbol, "while") == 0)
            ch = 'f';
        else if (strcmp(symbol, "return") == 0)
            ch = 'g';
        else if (strcmp(symbol, "print") == 0)
            ch = 'h';
        else if (strcmp(symbol, "scan") == 0)
            ch = 'j';
        else
            ch = 'i';

    else if (charClass == 11 || charClass == 12)
        ch = 'n';

    else if (charClass == 3)
    {
        for (int i = 0; i < 10; i++)
            if (strcmp(symbol, toString(sepchar[i])) == 0)
            {
                ch = sepchar[i];
            }
    }

    else if (charClass == 4)
    {
        for (int i = 0; i < 17; i++)
            if (strcmp(symbol, ">") == 0 || strcmp(symbol, "<") == 0 || strcmp(symbol, ">=") == 0 || strcmp(symbol, "<=") == 0 || strcmp(symbol, "==") == 0)
                ch = 'k';
            else if (strcmp(symbol, mathWords[i]) == 0)
            {
                ch = mathWords[i][0];
                break;
            }
                
    }

    else if (charClass == 5)
        ch = 's';

    return toString(ch);
}

// Judge class-names of symbols
int type(char ch)
{
    for (int i = 0; i < 52; i++)
        if (ch == alphabet[i])
            return ALPHABET;

    for (int i = 0; i < 10; i++)
        if (ch == degit[i])
            return DEGIT;

    for (int i = 0; i < 3; i++)
        if (ch == whitespace[i])
            return WHITESPACE;

    for (int i = 0; i < 10; i++)
        if (ch == sepchar[i])
            if (ch == '"') 
                return STRING;
            else
                return SEPCHAR;

    for (int i = 0; i < 9; i++)
        if (ch == mathchar[i])
            return MATHCHAR;
}

/**
* generate symbolList
*/
char* tokenise(char* symbolList, char* symbol, char* fileName)
{
    FILE* fp;
    char ch;

    //如果没有找到文件，给出提升并退出
    if ((fp = fopen(fileName, "rt")) == NULL)
    {
        printf("没有找到文件，按任意键退出");
        getchar();
        exit(1);
    }

    ch = fgetc(fp);
    while (ch != EOF)
    {
        switch (type(ch))
        {

        case WHITESPACE:
            ch = fgetc(fp);
            break;

        case ALPHABET:
            strcat(symbol, toString(ch));
            ch = fgetc(fp);
            while (type(ch) == 0 || type(ch) == 1)
            {
                strcat(symbol, toString(ch));
                ch = fgetc(fp);
            }
            strcat(symbolList, token(symbol, ALPHABET));
            symbol[0] = '\0';
            break;

        case DEGIT:
            strcat(symbol, toString(ch));
            ch = fgetc(fp);
            int isFloat = 11;
            while (type(ch) == 1)
            {
                strcat(symbol, toString(ch));
                ch = fgetc(fp);
            }
            if (ch == '.')
            {
                isFloat = 12;
                strcat(symbol, toString(ch));
                ch = fgetc(fp);
                while (type(ch) == 1)
                {
                    strcat(symbol, toString(ch));
                    ch = fgetc(fp);
                }
            }
            strcat(symbolList, token(symbol, isFloat));
            symbol[0] = '\0';
            break;

        case MATHCHAR:
            strcat(symbol, toString(ch));
            ch = fgetc(fp);
            if (type(ch) == 4)
            {
                strcat(symbol, toString(ch));
                ch = fgetc(fp);
            }
            if (strcmp(symbol, "//") == 0)
                while (ch != '\n')
                    ch = fgetc(fp);
            else
                strcat(symbolList, token(symbol, MATHCHAR));
            symbol[0] = '\0';
            break;

        case SEPCHAR:
            strcat(symbol, toString(ch));
            ch = fgetc(fp);
            strcat(symbolList, token(symbol, SEPCHAR));
            symbol[0] = '\0';
            break;

        case STRING:
            ch = fgetc(fp);
            while (ch != '"')
            {
                strcat(symbol, toString(ch));
                ch = fgetc(fp);
            }
            strcat(symbolList, token(symbol, STRING));
            ch = fgetc(fp);
            symbol[0] = '\0';
            break;

        default:
            printf("ERROR: Unknown Char: %c\n", ch);
            ch = fgetc(fp);
            break;
        }
    }

    fclose(fp);
    strcat(symbolList, "#");

    return symbolList;
}

/**
* Judge if an atom in an array
*/
int isIn(char ch, char array[], int len)
{
    for (int i = 0; i < len; i++)
    {
        if (ch == array[i])
            return 1;
    }
    return 0;
}

/**
* take the next symbol
*/
void advance()
{
    sym = result[i];
    printf("%c", sym);
    i++;
}

/**
* error function
*/
void error()
{
    printf("error");
    exit(0);
}

/**
* define the generation functions
*/

void A();
void A1();
void B();
void C();
void C1();
void D();
void D1();
void E();
void E1();
void F();
void G();
void G1();
void G2();
void G3();
void G4();
void H();
void H1();
void I();
void J();
void K();
void K1();
void K2();
void K3();
void L();
void L1();
void M();
void N();
void O();
void O1();
void P();
void P1();
void P2();
void Q();
void Q1();
void Q2();
void R();
void R1();
void R2();
void R3();
void S();
void S1();
void T();
void T1();

void J()
{
    if (sym == 'a')
        advance();
    else if (sym == 'b')
        advance();
    else if (sym == 'c')
        advance();
    else
        error();
}

void I()
{
    J();
    if (sym == 'i')
        advance();
    else
        error();
}

void H1()
{
    if (sym == ',')
    {
        advance();
        I();
        H1();
    }
    else if (isIn(sym, FOLLOW_H1, sizeof(FOLLOW_H1)/sizeof(FOLLOW_H1[0])))
        ;
    else
        error();
}

void H()
{
    I();
    H1();
}

void G4()
{
    if (sym == '=')
    {
        advance();
        if (sym == '{')
            advance();
        else
            error();
        E();
        if (sym == '}')
            advance();
        else
            error();
    }
    else if (isIn(sym, FOLLOW_G4, sizeof(FOLLOW_G4)/sizeof(FOLLOW_G4[0])))
        ;
    else
        error();
}

void G3()
{
    if (isIn(sym, FIRST_N, sizeof(FIRST_N)/sizeof(FIRST_N[0])))
    {
        N();
        if (sym == ']')
            advance();
        else
            error();
        G4();
    }
    else if (sym == ']')
    {
        advance();
        G4();
    }
    else
        error();
}

void G2()
{
    if (isIn(sym, FIRST_H, sizeof(FIRST_H)/sizeof(FIRST_H[1])))
    {
        H();
        if (sym == ')')
            advance();
        else
            error();
    }
    else if (sym == ')')
        advance();
    else
        error();
}

void G1()
{
    if (sym == '=')
    {
        advance();
        N();
    }
    else if (sym == '(')
    {
        advance();
        G2();
    }
    else if (sym == '[')
    {
        advance();
        G3();
    }
    else if (isIn(sym, FOLLOW_G1, sizeof(FOLLOW_G1)/sizeof(FOLLOW_G1[0])))
        ;
    else
        error();
}

void G()
{
    if (sym == 'i')
    {
        advance();
        G1();
    }
    else
        error();
}


void D1()
{
    if (sym == ',')
    {
        advance();
        G();
        D1();
    }
    else if (isIn(sym, FOLLOW_D1, sizeof(FOLLOW_D1)/sizeof(FOLLOW_D1[0])))
        ;
    else
        error();
}

void D()
{
    G();
    D1();
}

void K3()
{
    if (sym == ';')
        advance();
    else if (isIn(sym, FIRST_S, sizeof(FIRST_S)/sizeof(FIRST_S[0])))
    {
        S();
        if (sym == ';')
            advance();
        else
            error();
    }
    else
        error();
}


void K2()
{
    if (sym == ';')
        advance();
    else if (isIn(sym, FIRST_N, sizeof(FIRST_N)/sizeof(FIRST_N[0])))
    {
        N();
        if (sym == ';')
            advance();
        else
            error();
    }
    else
        error();
}

void K()
{
    if (isIn(sym, FIRST_J, sizeof(FIRST_J)/sizeof(FIRST_J[0])))
    {
        J();
        D();
        if (sym == ';')
            advance();
        else
            error();
    }
    else if (sym == '{')
    {
        advance();
        L();
        if (sym == '}')
            advance();
        else
            error();
    }
    else if (isIn(sym, FIRST_M, sizeof(FIRST_M)/sizeof(FIRST_M[0])))
        M();
    else if (sym == 'd')
    {
        advance();
        if (sym == '(')
            advance();
        else
            error();
        N();
        if (sym == ')')
            advance();
        else
            error();
        K();
        K1();
    }
    else if (sym == 'f')
    {
        advance();
        if (sym == '(')
            advance();
        else
            error();
        N();
        if (sym == ')')
            advance();
        else
            error();
        K();
    }
    else if (sym == 'g')
    {
        advance();
        K2();
    }
    else if (sym == 'h')
    {
        advance();
        K3();
    }
    else if (sym == 'j')
    {
        advance();
        T();
        if (sym == ';')
            advance();
        else
            error();
    }
    else
        error();
}

void K1()
{
    if (sym == 'e')
    {
        advance();
        K();
    }
    else if (isIn(sym, FOLLOW_K1, sizeof(FOLLOW_K1)/sizeof(FOLLOW_K1[0])))
        ;
    else
        error();
}

void L1()
{
    if (isIn(sym, FIRST_K, sizeof(FIRST_K)/sizeof(FIRST_K[0])))
    {
        K();
        L1();
    }
    else if (isIn(sym, FOLLOW_L1, sizeof(FOLLOW_L1)/sizeof(FOLLOW_L1[0])))
        ;
    else
        error();
}

void L()
{
    K();
    L1();
}

void F()
{
    if (sym == 'n')
        advance();
    else if (sym == 's')
        advance();
    else
        error();
}

void E1()
{
    if (sym == ',')
    {
        advance();
        F();
        E1();
    }
    else if (isIn(sym, FOLLOW_E1, sizeof(FOLLOW_E1)/sizeof(FOLLOW_E1[0])))
        ;
    else
        error();
}

void E()
{
    F();
    E1();
}



void C1()
{
    if (isIn(sym, FIRST_L, sizeof(FIRST_L)/sizeof(FIRST_L[0])))
    {
        L();
        if (sym == '}')
            advance();
        else
            error();
    }
    else if (sym == '}')
        advance();
    else
        error();
}

void C()
{
    if (sym == '{')
    {
        advance();
        C1();
    }
    else if (sym == ',')
    {
        advance();
        D();
        if (sym == ';')
            advance();
        else
            error();
    }
    else if (sym == ';')
        advance();
    else
        error();
}

void B()
{
    J();
    G();
    C();
}

void A1()
{
    if (isIn(sym, FIRST_B, sizeof(FIRST_B)/sizeof(FIRST_B[0])))
    {
        B();
        A1();
    }
    else if (isIn(sym, FOLLOW_A1, sizeof(FOLLOW_A1)/sizeof(FOLLOW_A1[0])))
        ;
    else
        error();
}

void A()
{
    B();
    A1();
}

void M()
{
    if (sym == ';')
        advance();
    else if (isIn(sym, FIRST_N, sizeof(FIRST_N)/sizeof(FIRST_N[0])))
    {
        N();
        if (sym == ';')
            advance();
        else
            error();
    }
    else
        error();
}

void N()
{
    O();
}

void O()
{
    P();
    O1();
}

void O1()
{
    if (sym == 'k')
    {
        advance();
        P();
        O1();
    }
    else if (isIn(sym, FOLLOW_O1, sizeof(FOLLOW_O1)/sizeof(FOLLOW_O1[0])))
        ;
    else
        error();
}

void P()
{
    Q();
    P2();
}

void P1()
{
    if (sym == '+')
    {
        advance();
        Q();
    }
    else if (sym == '-')
    {
        advance();
        Q();
    }
    else
        error();
}

void P2()
{
    if (isIn(sym, FIRST_P1, sizeof(FIRST_P1)/sizeof(FIRST_P1[0])))
    {
        P1();
        P2();
    }
    else if (isIn(sym, FOLLOW_P2, sizeof(FOLLOW_P2)/sizeof(FOLLOW_P2[0])))
        ;
    else
        error;
}

void Q()
{
    if (isIn(sym, FIRST_R, sizeof(FIRST_R) / sizeof(FIRST_R[0])))
    {
        R();
        Q2();
    }
    else if (sym == '-')
    {
        advance();
        R();
        Q2();
    }
    else
        error();
}

void Q1()
{
    if (sym == '*')
    {
        advance();
        R();
    }
    else if (sym == '/')
    {
        advance();
        R();
    }
    else if (sym == '%')
    {
        advance();
        R();
    }
    else
        error();
}

void Q2()
{
    if (isIn(sym, FIRST_Q1, sizeof(FIRST_Q1) / sizeof(FIRST_Q1[0])))
    {
        Q1();
        Q2();
    }
    else if (isIn(sym, FOLLOW_Q2, sizeof(FOLLOW_Q2) / sizeof(FOLLOW_Q2[0])))
        ;
    else
        error();
}

void R()
{
    if (sym == 'i')
    {
        advance();
        R1();
    }
    else if (sym == '(')
    {
        advance();
        N();
    }
    else if (sym == 'n')
        advance();
    else if (sym == 's')
        advance();
    else
        error();
}

void R1()
{
    if (sym == '(')
    {
        advance();
        R2();
    }
    else if (sym == 'l')
        advance();
    else if (sym == '=')
    {
        advance();
        N();
    }
    else if (sym == '[')
    {
        advance();
        N();
        if (sym == ']')
            advance();
        else
            error();
        R3();
    }
    else if (isIn(sym, FOLLOW_R1, sizeof(FOLLOW_R1) / sizeof(FOLLOW_R1[0])))
        ;
    else
        error();
}

void R2()
{
    if (isIn(sym, FIRST_S, sizeof(FIRST_S) / sizeof(FIRST_S[0])))
    {
        S();
        if (sym == ')')
            advance();
        else
            error();
    }
    else if (sym == ')')
        advance();
    else
        error();
}

void R3()
{
    if (sym == '=')
    {
        advance();
        N();
    }
    else if (isIn(sym, FOLLOW_R3, sizeof(FOLLOW_R3) / sizeof(FOLLOW_R3[0])))
        ;
    else
        error();
}

void S()
{
    N();
    S1();
}

void S1()
{
    if (sym == ',')
    {
        advance();
        N();
        S1();
    }
    else if (isIn(sym, FOLLOW_S1, sizeof(FOLLOW_S1) / sizeof(FOLLOW_S1[0])))
        ;
    else
        error();
}

void T()
{
    if (sym == 'i')
    {
        advance();
        T1();
    }
    else
        error;
}

void T1()
{
    if (sym == ',')
    {
        advance();
        if (sym == 'i')
            advance();
        else
            error();
        T1();
    }
    else if (isIn(sym, FOLLOW_T1, sizeof(FOLLOW_T1) / sizeof(FOLLOW_T1[0])))
        ;
    else
        error();
}

int main()
{
    char* symbolList[6200];
    symbolList[0] = '\0';
    result[0] = '\0';

    //char fileName[40];
    char* symbol[20];
    symbol[0] = '\0';
    
    //printf("请输入源文件路径(不超过40个字符)：");
    //scanf("%s", &fileName);
    char* fileName = "F:\\编译技术实验\\实验2\\test.c";
    strcat(result, tokenise(symbolList, symbol, fileName));

    advance();
    A();
    if (sym != '#')
        error();

    return 0;
}