程序有问题，大神看看

xxzj01

这个程序没有实际意义，目的在于删除程序中自带的一些注释和宏定义，但是编译会报错，请看看哪里不对。

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <ctype.h>               
   
4. 
   
5. #define debug(fmt,args,...)                fprintf(stderr,fmt,##args)
   
6. 
   
7. int get_input_type(char * word)
   
8. {
   
9.         if(strcmp(word," ") == 0)
   
10.                 return 0;
    
11.                
    
12.         if(strcmp(word,"\t") == 0)
    
13.                 return 0;
    
14.                
    
15.         if(strcmp(word,"#") == 0)
    
16.                 return 1;
    
17.                
    
18.         if(strcmp(word,"define") == 0)
    
19.                 return 2;
    
20.                
    
21.         if(strcmp(word,"\n") == 0)
    
22.                 return 4;
    
23. 
    
24.         return 3;
    
25. }
    
26. 
    
27. char c;
    
28. char word[64];
    
29. char word_buf[64];
    
30. char buf[128];
    
31. 
    
32. struct macro
    
33. {
    
34.         char name[64];
    
35.         char value[64];
    
36. } macros[16];
    
37. 
    
38. int macro_counter = 0;
    
39. 
    
40. void act_print_word(void)
    
41. {
    
42.         int i = 0;
    
43.         for(i=0;i<macro_counter;i++)
    
44.         {
    
45.                 if(strcmp(word,macros[i].name) == 0)
    
46.                 {
    
47.                         printf("%s",macros[i].value);
    
48.                         return;
    
49.                 }
    
50.                         
    
51.                 break;
    
52.         }
    
53.         
    
54.         if(i == macro_counter)
    
55.                 printf("%s",word);
    
56.         
    
57.         return;
    
58. }
    
59. 
    
60. void act_save_to_buf(void)
    
61. {
    
62.         strcat(buf,word);
    
63.         
    
64.         return;
    
65. }
    
66. 
    
67. void act_print_buf_and_word(void)
    
68. {
    
69.         printf("%s",buf);
    
70.         printf("%s",word);
    
71.         
    
72.         return;
    
73. }
    
74. 
    
75. void act_save_word(void)
    
76. {
    
77.         strcat(word_buf,word);
    
78.         
    
79.         return;
    
80. }
    
81. 
    
82. 
    
83. void act_get_macro_name(void)
    
84. {
    
85.         printf("name = <%s>\n",word_buf);
    
86.         
    
87.         strcpy(macros[macro_counter].name,word_buf);
    
88.         strcpy(word_buf,"");
    
89. 
    
90.         return;
    
91. }
    
92. 
    
93. void act_get_macro_value(void)
    
94. {
    
95.         printf("value = <%s>\n",word_buf);                        
    
96.         
    
97.         strcpy(macros[macro_counter].value,word_buf);
    
98.         strcpy(word_buf,"");
    
99.         
    
100.         macro_counter++;
     
101.         
     
102.         return;
     
103. }
     
104. 
     
105. void act_null(void)
     
106. {
     
107.         return;
     
108. }
     
109. 
     
110. enum {s0 = 0,s1,s2,s3,s4,s5,s6};
     
111. int state_transition[7][5] =
     
112.                 {
     
113.                         s0,                s1,                s0,                s0,                s0,
     
114. 
     
115.                         s1,                s0,                s2,                s0,                s0,
     
116.                         
     
117.                         s3,                s0,                s0,                s0,                s0,
     
118.                         
     
119.                         s3,                s4,                s4,                s4,                s0,
     
120.                         
     
121.                         s5,                s5,                s4,                s4,                s0,
     
122.                
     
123.                         s5,                s6,                s6,                s6,                s0,
     
124.                         
     
125.                         s6,                s6,                s6,                s6,                s0,
     
126.                 };
     
127. 
     
128. #define a0 act_print_word
     
129. #define a1 act_save_to_buf
     
130. #define a2 act_print_buf_and_word
     
131. #define a3 act_save_word
     
132. #define a4 act_get_macro_name
     
133. #define a5 act_get_macro_value
     
134. #define a6 act_null
     
135. 
     
136. #if 1        
     
137. typedef void (*PF)(void);
     
138. PF act_table[7][5] =
     
139. {
     
140.         a0,                a1,                a0,                a0,                a0,
     
141.         a1,                a2,                a1,                a2,                a2,
     
142.         a1,                a2,                a2,                a2,                a2,
     
143.         a1,                a3,                a3,                a3,                a2,
     
144.         a4,                a4,                a3,                a3,                a5,
     
145.         a6,                a3,                a3,                a3,                a5,               
     
146.         a3,                a3,                a3,                a3,                a5,
     
147. };
     
148. #endif
     
149. 
     
150. void getword(char * word)
     
151. {
     
152.         char c;
     
153.         
     
154.         c = getchar();
     
155.         
     
156.         if(c == EOF)
     
157.         {
     
158.                 *word = '\0';
     
159.                 return;
     
160.         }
     
161.         
     
162.         // if c is not a alpha
     
163.         if(isalpha(c) == 0) // or  if(!isalpha(c))
     
164.         {
     
165.                 *word = c;
     
166.                 word ++;
     
167.                 *word = '\0';
     
168.                 return;
     
169.         }
     
170.         
     
171.         do
     
172.         {
     
173.                 *word++ = c;
     
174.                 c = getchar();
     
175.         }while(isalnum(c) || c == '_');
     
176.         
     
177.         // current c is $ or anything else
     
178.         ungetc(c,stdin);
     
179.         *word = '\0';
     
180.         
     
181.         return;
     
182. }
     
183.         
     
184. int main(void)
     
185. {        
     
186.         int state = 0;
     
187.         
     
188.         while(1)
     
189.         {
     
190.                
     
191.                 int input = 0;
     
192.                 void (*pf)(void);
     
193.                 //char word[64];
     
194.                
     
195.                 //c = getchar();
     
196.                 //input = get_input_type(c);
     
197.                 getword(word);
     
198.                 input = get_input_type(word);
     
199.                
     
200.                 //printf("c = %c,input = %d\n",c,input);  it's debug sentence.
     
201.                
     
202.                 //if(c == EOF)   
     
203.                 //        break;
     
204.                 if(strcmp(word,"") == 0)
     
205.                         break;
     
206.                
     
207.                 pf = act_table[state][input];
     
208.                 pf();
     
209.                
     
210.                 state = state_transition[state][input];
     
211.                
     
212.                 debug("word = <%s>,input = %d,state = %d\n",word,input,state);
     
213.         }
     
214. 
     
215.         return 0;
     
216. }

复制代码

xxzj01

五天了，没人懂？还是没人理。这人缘~~~~~:cry

haiouda

我是菜鸟，看着有点乱；
哥们，给你提点意见（可能是我水平实在太差）：
哥们，要不你就把你这程序是怎么实现的，说一说(思路)；
再不，你就多加些注释，这样一来，也好读懂；

xxzj01

haiouda 发表于 2015-4-5 20:46
我是菜鸟，看着有点乱；
哥们，给你提点意见（可能是我水平实在太差）：
哥们，要不你就把你这程序是怎么 ...

这个程序没有实际意义，目的在于删除程序中自带的一些注释和宏定义.程序来自李明新概念C语言（git-hub）.报错如下：pasting "," and "word" does not give a valid preprocessing token