c语言检查错误，检查错误

运行不了，有会的吗？

#include
#include
#include
#define _KEY_WORD_END "waiting for your expanding"
typedef struct{
    int typenum;
    char * word;
}WORD;
char input[255];
char token[255]="";
int p_input;
int p_token;
char ch;
int kk=0;
char * rwtab[]={"begin","if","then","while","do","end",_KEY_WORD_END};
WORD *scaner();
int main(){
    int over=1;
    WORD* oneword=new WORD;
    printf("Enter Your words (end with #):");
    scanf("%[^#]s",input);
    p_input=0;
    printf("Your words:\n%s\n",input);
        
    while(over<1000&&over!=-1){
        oneword=scaner();
        if(oneword->typenum<1000)
        printf("(%d,%s)",oneword->typenum,oneword->word);
        over =oneword->typenum;
    }
    printf("\npress # to exit:");
    scanf("%[^#]s",input);
}
char m_getch(){
    ch=input[p_input];
    p_input=p_input+1;
    return(ch);
}
void getbc(){
    while(ch==' '||ch==10){
        ch=input[p_input];
        p_input=p_input+1;
    }
}
void concat(){
    token[p_token]=ch;
    p_token=p_token+1;
    token[p_token]='\0';
}
int letter(){
    if(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z')return 1;
    else return 0;
}
int digit(){
    if(ch>='0'&&ch<='9')return 1;
    else return 0;
}
int reserve(){
    int i=0;
    while(strcmp(rwtab[i],_KEY_WORD_END)){
        if(!strcmp(rwtab[i],token)){
            return i+1;
        }
        i=i+1;
    }
    return 10;
}
void retract(){
        p_input=p_input-1;
}

char* dtb(char* bstr)
{
    itoa(atoi(bstr), bstr, 2);
    return  bstr;
} 

WORD *scaner(){
        WORD* myword=new WORD;
        myword->typenum=10;
        myword->word="";
        p_token=0;
        m_getch();
        getbc();
        if(letter()){
            while(letter()||digit()){
                concat();
                m_getch();
            }
            retract();
                myword->typenum=reserve();
                myword->word=token;
                return(myword);
        } else if(digit()){
            while(digit()){
                concat();
                m_getch();
            }
                retract();
                myword->typenum=11;
                myword->word =(char *)malloc(16); 
                myword->word=dtb(token);
    
                return(myword);
        }else switch(ch){
            case '=': m_getch();
            if(ch=='='){
                myword->typenum=39;
                myword->word="==";
                return(myword);
            }
                retract();
                myword->typenum=21;
                myword->word="=";
                return(myword);
                break;
            case '+':    myword->typenum=22;
                        myword->word="+";
                        return(myword);
                break;
            case '-':    myword->typenum=23;
                        myword->word="-";
                        return(myword);
                break;
            case '*':    myword->typenum=24;
                        myword->word="*";
                        return(myword);
                break;
            case '/':    myword->typenum=25;
                        myword->word="/";
                        return(myword);
                break;
            case '(':    myword->typenum=26;
                        myword->word="(";
                        return(myword);
                break;
            case ')':    myword->typenum=27;
                        myword->word=")";
                        return(myword);
                break;
            case '[':    myword->typenum=28;
                        myword->word="[";
                        return(myword);
                break;
            case ']':    myword->typenum=29;
                        myword->word="]";
                        return(myword);
                break;
            case '{':    myword->typenum=30;
                        myword->word="{";
                        return(myword);
                break;
            case '}':    myword->typenum=31;
                        myword->word="}";
                        return(myword);
                break;
            case ',':    myword->typenum=32;
                        myword->word=",";
                        return(myword);
                break;
            case ':':    myword->typenum=33;
                        myword->word=":";
                        return(myword);
                break;
            case ';':    myword->typenum=34;
                        myword->word=";";
                        return(myword);
                break;
            case '>': m_getch();
            if(ch=='='){
                    myword->typenum=37;
                        myword->word=">=";
                        return(myword);
            }
                retract();
                myword->typenum=35;
                myword->word=">";
                return(myword);
                break;
            case '<': m_getch();
            if(ch=='='){
                    myword->typenum=38;
                        myword->word="<=";
                        return(myword);
            }
                retract();
                myword->typenum=36;
                myword->word="<";
                return(myword);
                break;    
            case '!': m_getch();
            if(ch=='='){
                    myword->typenum=40;
                        myword->word="!=";
                        return(myword);
            }
                retract();
                myword->typenum=-1;
                myword->word="ERROR";
                return(myword);
                break;
            case '\0': myword->typenum=1000;
                        myword->word="OVER";
                        return(myword);
            break;
            default: 
                myword->typenum=-1;
                myword->word="ERROR";
                return(myword);
            
                
        }
}
void lrparser(WORD* word){
        WORD* w; 
        if(word->typenum==1){
            w=scaner();
            w=yucu(w);
            if(w->typenum==6){
                w=scaner();
                if(w->typenum==0&&(kk==0)){
                    free(w);
                    printf("success\n");
                }
            }else{
                if(kk!=1){
                    printf("lack of end error!\n");
                    kk=1;
                }
            }
        
        
        }
            else{
                free(word);
                printf("begin error!\n");
                kk=1;
            }
                return;
} 
WORD* yucu(WORD* word){
WORD* w;
w= statement();
    while(w->typenum==26){
        w=scaner();
    w=statement(w);
    }
    return w;
}

WORD* statement(WORD* word){
    WORD* w;
    if(word->typenum==10){
        w=scaner();
        if(word->typenum==18){
            w=scaner();
            w=expression(w);
        }else{
            printf("fuzhi error!\n");
            kk=1;
        }
    }
    else{
        printf("yuju error!\n");
        kk=1;
    }
    return w; 
}

WORD* expression(WORD* word){
    WORD* w;
w=    term();
    while(w->typenum==13||w->typenum==14){
        w=scaner();
        w=term(w); 
    }
    return w;
}
WORD* item(WORD* word){
    WORD* w;
   w= factor();
    while(w->typenum==15||w->typenum==16){
      w=scaner();
        w=factor(w); }
            return w;
}
WORD* factor(WORD* word){
      WORD* w;
    if(word->typenum==10||word->typenum==11)
         w=scaner();
    else if(w->typenum==27)
    {
    w=scaner();
    w=expression(w);
    if(w->typenum==28)
        w=scaner();
        else{
            printf("error!\n");
            kk=1;
        }    
        
    }
    else{
            printf("biaoda error!\n");
            kk=1;
    }
    return w;
}

代码里第183 187行是什么意思？2022.10.13 整体修改如下，供参考：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _KEY_WORD_END "waiting for your expanding"
typedef struct
{
    int typenum;
    char* word;
} WORD;
typedef struct node{    //修改
    WORD  *data;
    struct node* next;
}Node;
char input[255];
char token[255] = "";
int p_input;
int p_token;
char ch;
int kk = 0;
char* rwtab[] = { "begin", "if", "then", "while", "do", "end", _KEY_WORD_END };
WORD* scaner();
Node* yucu(Node* word);
Node* expression(Node* word);
Node* factor(Node* word);
void lrparser(Node* word);   //(WORD* word);
int main()
{
    int over = 1;
    Node* oneword = NULL, * pt = NULL, * p;     //= (WORD*)malloc(sizeof(WORD));
                                                //memset(oneword, 0, sizeof(WORD));
    printf("Enter Your words (end with #):");
    scanf("%[^#]", input);
    p_input = 0;
    printf("Your words:\n%s\n", input);
    while (over < 1000)  //(over < 1000 && over != -1)
    {
        pt = (Node*)malloc(sizeof(Node));
        pt->data = scaner();
        pt->next = NULL;
        if (oneword == NULL) 
            oneword = pt;
        else
            p->next = pt;
        p = pt;
        over = p->data->typenum;
    }
    p = oneword;
    while (p) {
        printf("(%d,%s)", p->data->typenum, p->data->word);
        p = p->next;
    }
    lrparser(oneword);
    //printf("\npress # to exit:");
    //scanf("%[^#]", input);
    return 0;
}
char m_getch()
{
    ch = input[p_input];
    p_input = p_input + 1;
    return (ch);
}
void getbc()
{
    while (ch == ' ' || ch == 10)
    {
        ch = input[p_input];
        p_input = p_input + 1;
    }
}
void concat()
{
    token[p_token] = ch;
    p_token = p_token + 1;
    token[p_token] = '\0';
}
int letter()
{
    if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z')
        return 1;
    else
        return 0;
}
int digit()
{
    if (ch >= '0' && ch <= '9')
        return 1;
    else
        return 0;
}
int reserve()
{
    int i = 0;
    while (strcmp(rwtab[i], _KEY_WORD_END))
    {
        if (!strcmp(rwtab[i], token))
        {
            return i + 1;
        }
        i = i + 1;
    }
    return 10;
}
void retract()
{
    p_input = p_input - 1;
}

char* dtb(char* bstr)
{
    itoa(atoi(bstr), bstr, 2);
    return bstr;
}

WORD* scaner()
{
    WORD* myword = (WORD*)malloc(sizeof(WORD));
    memset(myword, 0, sizeof(WORD));
    myword->typenum = 10;
    myword->word = " ";
    p_token = 0;
    m_getch();
    getbc();
    if (letter())
    {
        while (letter() || digit())
        {
            concat();
            m_getch();
        }
        retract();
        myword->typenum = reserve();
        myword->word = (char*)malloc(33);
        strcpy(myword->word, token); 
        //myword->word = token;
        return (myword);
    }
    else if (digit())
    {
        while (digit())
        {
            concat();
            m_getch();
        }
        retract();
        myword->typenum = 11;
        myword->word = (char*)malloc(33);
        strcpy(myword->word, dtb(token));
        //myword->word = dtb(token);
        //lrparser(myword);
        return (myword);
    }
    else
        switch (ch)
        {
        case '=':
            m_getch();
            if (ch == '=')
            {
                myword->typenum = 39;
                myword->word = (char*)"==";
                return (myword);
            }
            retract();
            myword->typenum = 21;
            myword->word = (char*)"=";
            return (myword);
            break;
        case '+':
            myword->typenum = 22;
            myword->word = (char*)"+";
            return (myword);
            break;
        case '-':
            myword->typenum = 23;
            myword->word = (char*)"-";
            return (myword);
            break;
        case '*':
            myword->typenum = 24;
            myword->word = (char*)"*";
            return (myword);
            break;
        case '/':
            myword->typenum = 25;
            myword->word = (char*)"/";
            return (myword);
            break;
        case '(':
            myword->typenum = 26;
            myword->word = (char*)"(";
            return (myword);
            break;
        case ')':
            myword->typenum = 27;
            myword->word = (char*)")";
            return (myword);
            break;
        case '[':
            myword->typenum = 28;
            myword->word = (char*)"[";
            return (myword);
            break;
        case ']':
            myword->typenum = 29;
            myword->word = (char*)"]";
            return (myword);
            break;
        case '{':
            myword->typenum = 30;
            myword->word = (char*)"{";
            return (myword);
            break;
        case '}':
            myword->typenum = 31;
            myword->word = (char*)"}";
            return (myword);
            break;
        case ',':
            myword->typenum = 32;
            myword->word = (char*)",";
            return (myword);
            break;
        case ':':
            myword->typenum = 33;
            myword->word = (char*)":";
            return (myword);
            break;
        case ';':
            myword->typenum = 34;
            myword->word = (char*)";";
            return (myword);
            break;
        case '>':
            m_getch();
            if (ch == '=')
            {
                myword->typenum = 37;
                myword->word = (char*)">=";
                return (myword);
            }
            retract();
            myword->typenum = 35;
            myword->word = (char*)">";
            return (myword);
            break;
        case '<':
            m_getch();
            if (ch == '=')
            {
                myword->typenum = 38;
                myword->word = (char*)"<=";
                return (myword);
            }
            retract();
            myword->typenum = 36;
            myword->word = (char*)"<";
            return (myword);
            break;
        case '!':
            m_getch();
            if (ch == '=')
            {
                myword->typenum = 40;
                myword->word = (char*)"!=";
                return (myword);
            }
            retract();
            myword->typenum = 41;
            myword->word = (char*)"!";
            //myword->typenum = -1;
            //myword->word = (char*)"ERROR";
            return (myword);
            break;
        case '\0':
            myword->typenum = 1000;
            myword->word = (char*)"OVER";
            return (myword);
            break;
        default:
            myword->typenum = 0;
            //myword->typenum = -1;
            myword->word = (char*)"ERROR";
            return (myword);
        }
}
void lrparser(Node* word)
{
    Node* w = word;
    if (w->data->typenum == 1) //begin
    {
        w = w->next;
        w = yucu(w);
        if (w->data->typenum == 6) //end
        {
            printf("success\n");
        }
        else if (w->data->typenum == 0) 
        {
            printf("中文符号错误\n");
        }
        else //缺end
        {
            if (kk != 1)
            {
                printf("缺end错误\n");
                kk = 1;
            }
        }
    }
    else
    {
        printf("begin错误\n");
        kk = 1;
    }
}

Node* statement(Node* word)
{
    Node* w = word;
    if (w->data->typenum == 10)
    {
        
        w = w->next;
        if (w->data->typenum == 21) 
            //(word->typenum == 18)
        {
            w = w->next;
            w = expression(w);
        }
        else{
            printf("fuzhi error!\n");
            kk = 1;
        }
    }else{
        printf("yuju error!\n");
        kk = 1;
    }
    return w;
}

Node* yucu(Node* word)
{
    Node* w = word;
    w = statement(w);
    while (w->data->typenum == 34) 
        //(w->data->typenum == 26)
    {
        w = w->next;
        w = statement(w);
    }
    return w;
}
Node* term(Node* word)
{
    Node* w = word;
    w = factor(w);
    while (w->data->typenum == 23 || w->data->typenum == 24) {
        w = w->next;
        w = factor(w);
    }
    return w;
}
Node* expression(Node* word)
{
    Node* w = word;
    w = term(w);
    while (w->data->typenum == 22 || w->data->typenum == 23)
        //(w->data->typenum == 13 || w->data->typenum == 14)
    {
        w = w->next;
        w = term(w);
    }
    return w;
}

Node* factor(Node* word)
{
    Node* w = word;
    if (w->data->typenum == 10 || w->data->typenum == 11)
        w = w->next;
    else if (w->data->typenum == 26){
        w = w->next;
        w = expression(w);
        if (w->data->typenum == 27)
            w = w->next;
        else
        {
            printf("error!\n");
            kk = 1;
        }
    }
    else{
        printf("biaoda error!\n");
        kk = 1;
    }
    return w;
}

//输入示例1：
//begin a = 9; x = (23+3)； b = a + x end #
//输出示例：
//(1,begin)(10,a)(21,=)(11,1001)(34,;)(10,x)(21,=)(26,()(11,10111)(22,+)(11,11)(27,))(0,ERROR)(0,ERROR)(10,b)(21,=)(10,a)(22,+)(10,x)(6,end)(1000,OVER)中文符号错误

//输入示例2：
//begin a: = 9; x = (23+3); b = a + x end #
//输出示例：
//(1,begin)(10,a)(33,:)(21,=)(11,1001)(34,;)(10,x)(21,=)(26,()(11,10111)(22,+)(11,11)(27,))(34,;)(10,b)(21,=)(10,a)(22,+)(10,x)(6,end)(1000,OVER)fuzhi error!

//输入示例3：
//begin a = 9; x = (23+3); b = a + x end #
//输出示例：
//(1,begin)(10,a)(21,=)(11,1001)(34,;)(10,x)(21,=)(26,()(11,10111)(22,+)(11,11)(27,))(34,;)(10,b)(21,=)(10,a)(22,+)(10,x)(6,end)(1000,OVER)success

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define _KEY_WORD_END "waiting for your expanding"
typedef struct
{
    int typenum;
    char *word;
} WORD;
char input[255];
char token[255] = "";
int p_input;
int p_token;
char ch;
int kk = 0;
char *rwtab[] = {"begin", "if", "then", "while", "do", "end", _KEY_WORD_END};
WORD *scaner();
WORD *yucu(WORD *word);
WORD *expression(WORD *word);
WORD *factor(WORD *word);
int main()
{
    int over = 1;
    WORD *oneword = (WORD *)malloc(sizeof(WORD));
    memset(oneword, 0, sizeof(WORD));
    printf("Enter Your words (end with #):");
    scanf("%[^#]s", input);
    p_input = 0;
    printf("Your words:\n%s\n", input);

    while (over < 1000 && over != -1)
    {
        oneword = scaner();
        if (oneword->typenum < 1000)
            printf("(%d,%s)", oneword->typenum, oneword->word);
        over = oneword->typenum;
    }
    printf("\npress # to exit:");
    scanf("%[^#]s", input);
}
char m_getch()
{
    ch = input[p_input];
    p_input = p_input + 1;
    return (ch);
}
void getbc()
{
    while (ch == ' ' || ch == 10)
    {
        ch = input[p_input];
        p_input = p_input + 1;
    }
}
void concat()
{
    token[p_token] = ch;
    p_token = p_token + 1;
    token[p_token] = '\0';
}
int letter()
{
    if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z')
        return 1;
    else
        return 0;
}
int digit()
{
    if (ch >= '0' && ch <= '9')
        return 1;
    else
        return 0;
}
int reserve()
{
    int i = 0;
    while (strcmp(rwtab[i], _KEY_WORD_END))
    {
        if (!strcmp(rwtab[i], token))
        {
            return i + 1;
        }
        i = i + 1;
    }
    return 10;
}
void retract()
{
    p_input = p_input - 1;
}

char *dtb(char *bstr)
{
    itoa(atoi(bstr), bstr, 2);
    return bstr;
}

WORD *scaner()
{
    WORD *myword = (WORD *)malloc(sizeof(WORD));
    memset(myword, 0, sizeof(WORD));
    myword->typenum = 10;
    myword->word = "";
    p_token = 0;
    m_getch();
    getbc();
    if (letter())
    {
        while (letter() || digit())
        {
            concat();
            m_getch();
        }
        retract();
        myword->typenum = reserve();
        myword->word = token;
        return (myword);
    }
    else if (digit())
    {
        while (digit())
        {
            concat();
            m_getch();
        }
        retract();
        myword->typenum = 11;
        myword->word = (char *)malloc(16);
        myword->word = dtb(token);

        return (myword);
    }
    else
        switch (ch)
        {
        case '=':
            m_getch();
            if (ch == '=')
            {
                myword->typenum = 39;
                myword->word = "==";
                return (myword);
            }
            retract();
            myword->typenum = 21;
            myword->word = "=";
            return (myword);
            break;
        case '+':
            myword->typenum = 22;
            myword->word = "+";
            return (myword);
            break;
        case '-':
            myword->typenum = 23;
            myword->word = "-";
            return (myword);
            break;
        case '*':
            myword->typenum = 24;
            myword->word = "*";
            return (myword);
            break;
        case '/':
            myword->typenum = 25;
            myword->word = "/";
            return (myword);
            break;
        case '(':
            myword->typenum = 26;
            myword->word = "(";
            return (myword);
            break;
        case ')':
            myword->typenum = 27;
            myword->word = ")";
            return (myword);
            break;
        case '[':
            myword->typenum = 28;
            myword->word = "[";
            return (myword);
            break;
        case ']':
            myword->typenum = 29;
            myword->word = "]";
            return (myword);
            break;
        case '{':
            myword->typenum = 30;
            myword->word = "{";
            return (myword);
            break;
        case '}':
            myword->typenum = 31;
            myword->word = "}";
            return (myword);
            break;
        case ',':
            myword->typenum = 32;
            myword->word = ",";
            return (myword);
            break;
        case ':':
            myword->typenum = 33;
            myword->word = ":";
            return (myword);
            break;
        case ';':
            myword->typenum = 34;
            myword->word = ";";
            return (myword);
            break;
        case '>':
            m_getch();
            if (ch == '=')
            {
                myword->typenum = 37;
                myword->word = ">=";
                return (myword);
            }
            retract();
            myword->typenum = 35;
            myword->word = ">";
            return (myword);
            break;
        case '<':
            m_getch();
            if (ch == '=')
            {
                myword->typenum = 38;
                myword->word = "<=";
                return (myword);
            }
            retract();
            myword->typenum = 36;
            myword->word = "<";
            return (myword);
            break;
        case '!':
            m_getch();
            if (ch == '=')
            {
                myword->typenum = 40;
                myword->word = "!=";
                return (myword);
            }
            retract();
            myword->typenum = -1;
            myword->word = "ERROR";
            return (myword);
            break;
        case '\0':
            myword->typenum = 1000;
            myword->word = "OVER";
            return (myword);
            break;
        default:
            myword->typenum = -1;
            myword->word = "ERROR";
            return (myword);
        }
}
void lrparser(WORD *word)
{
    WORD *w;
    if (word->typenum == 1)
    {
        w = scaner();
        w = yucu(w);
        if (w->typenum == 6)
        {
            w = scaner();
            if (w->typenum == 0 && (kk == 0))
            {
                free(w);
                printf("success\n");
            }
        }
        else
        {
            if (kk != 1)
            {
                printf("lack of end error!\n");
                kk = 1;
            }
        }
    }
    else
    {
        free(word);
        printf("begin error!\n");
        kk = 1;
    }
    return;
}

WORD *statement(WORD *word)
{
    WORD *w;
    if (word->typenum == 10)
    {
        w = scaner();
        if (word->typenum == 18)
        {
            w = scaner();
            w = expression(w);
        }
        else
        {
            printf("fuzhi error!\n");
            kk = 1;
        }
    }
    else
    {
        printf("yuju error!\n");
        kk = 1;
    }
    return w;
}

WORD *yucu(WORD *word)
{
    WORD *w;
    w = statement(w);
    while (w->typenum == 26)
    {
        w = scaner();
        w = statement(w);
    }
    return w;
}
WORD *term(WORD *word)
{
    WORD *w;
    return w;
}
WORD *expression(WORD *word)
{
    WORD *w;
    w = term(w);
    while (w->typenum == 13 || w->typenum == 14)
    {
        w = scaner();
        w = term(w);
    }
    return w;
}
WORD *item(WORD *word)
{
    WORD *w;
    w = factor(w);
    while (w->typenum == 15 || w->typenum == 16)
    {
        w = scaner();
        w = factor(w);
    }
    return w;
}
WORD *factor(WORD *word)
{
    WORD *w;
    if (word->typenum == 10 || word->typenum == 11)
        w = scaner();
    else if (w->typenum == 27)
    {
        w = scaner();
        w = expression(w);
        if (w->typenum == 28)
            w = scaner();
        else
        {
            printf("error!\n");
            kk = 1;
        }
    }
    else
    {
        printf("biaoda error!\n");
        kk = 1;
    }
    return w;
}

你这个问题也太多了，改了半天。WORD *term(WORD *word)这个函数没有实现。我给你放了个框架在那

• 可以查看手册：检查文件错误-ferror 中的内容