[编译原理]词法分析器（请教一个问题）

bluespirit

最近在学编译原理，用的编译原理与实践这本书，为了能更好的学习，所以把书中tiny compiler的词法分析器给分出来了，编成一个独立的程序，在改的时候出现了一个问题，就是如果把scan.c中一些函数用到的变量
int lineno=0;
FILE *source,*listing,*fp;
放在scan.h中，就编译不了，出现变量未定义的错误，而放在
scan.c中就可以编译通过。

　　一直不能理解这是为什么，难道在预处理时，不是把scan.h与scan.c合在一起的吗？

1. 
   
2. /****************************************************/
   
3. /* File: scan.h                                     */
   
4. /* The scanner interface for the TINY compiler      */
   
5. /* Compiler Construction: Principles and Practice   */
   
6. /* Kenneth C. Louden                                */
   
7. /****************************************************/
   
8. 
   
9. #include <stdio.h>
   
10. #include <stdlib.h>
    
11. #include <ctype.h>
    
12. #include <string.h>
    
13. 
    
14. /* MAXTOKENLEN is the maximum size of a token */
    
15. #define MAXTOKENLEN 40
    
16. #define FALSE 0
    
17. #define TRUE 1
    
18. #define MAXRESERVED 8
    
19. 
    
20. 
    
21. typedef enum
    
22.     /* book-keeping tokens */
    
23.    {ENDFILE,ERROR,
    
24.     /* reserved words */
    
25.     IF,THEN,ELSE,END,REPEAT,UNTIL,READ,WRITE,
    
26.     /* multicharacter tokens */
    
27.     ID,NUM,
    
28.     /* special symbols */
    
29.     ASSIGN,EQ,LT,PLUS,MINUS,TIMES,OVER,LPAREN,RPAREN,SEMI
    
30.    } TokenType;
    
31. 
    
32. /* states in scanner DFA */
    
33. typedef enum
    
34.    { START,INASSIGN,INCOMMENT,INNUM,INID,DONE }
    
35.    StateType;
    
36. 
    
37. /* lexeme of identifier or reserved word */
    
38. char tokenString[MAXTOKENLEN+1];
    
39. 
    
40. /* BUFLEN = length of the input buffer for
    
41.    source code lines */
    
42. #define BUFLEN 256
    
43. 
    
44. static char lineBuf[BUFLEN]; /* holds the current line */
    
45. static int linepos = 0; /* current position in LineBuf */
    
46. static int bufsize = 0; /* current size of buffer string */
    
47. static int EOF_flag = FALSE; /* corrects ungetNextChar behavior on EOF
    
48. 
    
49. 
    
50. /* functions */
    
51. 
    
52. TokenType getToken(void);
    
53. static int getNextChar(void);
    
54. static void ungetNextChar(void);
    
55. static TokenType reservedLookup (char * s);
    
56. void printToken( TokenType token, const char* tokenString ,FILE *listing);
    
57. 
    

复制代码

1. 
   
2. 
   
3. /****************************************************/
   
4. /* File: scan.c                                     */
   
5. /* The scanner implementation for the TINY compiler */
   
6. /* Compiler Construction: Principles and Practice   */
   
7. /* Kenneth C. Louden                                */
   
8. /****************************************************/
   
9. 
   
10. 
    
11. #include "scan.h"
    
12. FILE *source,*listing,*fp;
    
13. int lineno=0;
    
14. 
    
15. /* getNextChar fetches the next non-blank character
    
16.    from lineBuf, reading in a new line if lineBuf is
    
17.    exhausted */
    
18. static int getNextChar(void)
    
19. { if (!(linepos < bufsize))
    
20.   { lineno++;
    
21.     if (fgets(lineBuf,BUFLEN-1,source))
    
22.     {
    
23.       bufsize = strlen(lineBuf);
    
24.       linepos = 0;
    
25.       return lineBuf[linepos++];
    
26.     }
    
27.     else
    
28.     { EOF_flag = TRUE;
    
29.       return EOF;
    
30.     }
    
31.   }
    
32.   else return lineBuf[linepos++];
    
33. }
    
34. 
    
35. 
    
36. /* ungetNextChar backtracks one character
    
37.    in lineBuf */
    
38. static void ungetNextChar(void)
    
39. { if (!EOF_flag) linepos-- ;}
    
40. 
    
41. /* lookup table of reserved words */
    
42. static struct
    
43.     { char* str;
    
44.       TokenType tok;
    
45.     } reservedWords[MAXRESERVED]
    
46.    = {{"if",IF},{"then",THEN},{"else",ELSE},{"end",END},
    
47.       {"repeat",REPEAT},{"until",UNTIL},{"read",READ},
    
48.       {"write",WRITE}};
    
49. 
    
50. /* lookup an identifier to see if it is a reserved word */
    
51. /* uses linear search */
    
52. 
    
53. static TokenType reservedLookup (char * s)
    
54. { int i;
    
55.   for (i=0;i<MAXRESERVED;i++)
    
56.     if (!strcmp(s,reservedWords[i].str))
    
57.       return reservedWords[i].tok;
    
58.   return ID;
    
59. }
    
60. 
    
61. /*print tokens and save them in a file */
    
62. void printToken( TokenType token, const char* tokenString ,FILE *listing)
    
63. { switch (token)
    
64.   { case IF:
    
65.     case THEN:
    
66.     case ELSE:
    
67.     case END:
    
68.     case REPEAT:
    
69.     case UNTIL:
    
70.     case READ:
    
71.     case WRITE:
    
72.       fprintf(listing,
    
73.          "reserved word: %s\n",tokenString);
    
74.       break;
    
75.     case ASSIGN: fprintf(listing,":=\n"); break;
    
76.     case LT: fprintf(listing,"<\n"); break;
    
77.     case EQ: fprintf(listing,"=\n"); break;
    
78.     case LPAREN: fprintf(listing,"(\n"); break;
    
79.     case RPAREN: fprintf(listing,")\n"); break;
    
80.     case SEMI: fprintf(listing,";\n"); break;
    
81.     case PLUS: fprintf(listing,"+\n"); break;
    
82.     case MINUS: fprintf(listing,"-\n"); break;
    
83.     case TIMES: fprintf(listing,"*\n"); break;
    
84.     case OVER: fprintf(listing,"/\n"); break;
    
85.     case ENDFILE: fprintf(listing,"EOF\n"); break;
    
86.     case NUM:
    
87.       fprintf(listing,
    
88.           "NUM, val= %s\n",tokenString);
    
89.       break;
    
90.     case ID:
    
91.       fprintf(listing,
    
92.           "ID, name= %s\n",tokenString);
    
93.       break;
    
94.     case ERROR:
    
95.       fprintf(listing,
    
96.           "ERROR: %s\n",tokenString);
    
97.       break;
    
98.     default: /* should never happen */
    
99.       fprintf(listing,"Unknown token: %d\n",token);
    
100.   }
     
101. }
     
102. 
     
103. /****************************************/
     
104. /* the primary function of the scanner  */
     
105. /****************************************/
     
106. /* function getToken returns the
     
107. * next token in source file
     
108. */
     
109. TokenType getToken(void)
     
110. {  /* index for storing into tokenString */
     
111.    int tokenStringIndex = 0;
     
112.    /* holds current token to be returned */
     
113.    TokenType currentToken;
     
114.    /* current state - always begins at START */
     
115.    StateType state = START;
     
116.    /* flag to indicate save to tokenString */
     
117.    int save;
     
118.    while (state != DONE)
     
119.    { int c = getNextChar();
     
120.      save = TRUE;
     
121.      switch (state)
     
122.      { case START:
     
123.          if (isdigit(c))
     
124.            state = INNUM;
     
125.          else if (isalpha(c))
     
126.            state = INID;
     
127.          else if (c == ':')
     
128.            state = INASSIGN;
     
129.          else if ((c == ' ') || (c == '\t') || (c == '\n'))
     
130.            save = FALSE;
     
131.          else if (c == '{')
     
132.          { save = FALSE;
     
133.            state = INCOMMENT;
     
134.          }
     
135.          else
     
136.          { state = DONE;
     
137.            switch (c)
     
138.            { case EOF:
     
139.                save = FALSE;
     
140.                currentToken = ENDFILE;
     
141.                break;
     
142.              case '=':
     
143.                currentToken = EQ;
     
144.                break;
     
145.              case '<':
     
146.                currentToken = LT;
     
147.                break;
     
148.              case '+':
     
149.                currentToken = PLUS;
     
150.                break;
     
151.              case '-':
     
152.                currentToken = MINUS;
     
153.                break;
     
154.              case '*':
     
155.                currentToken = TIMES;
     
156.                break;
     
157.              case '/':
     
158.                currentToken = OVER;
     
159.                break;
     
160.              case '(':
     
161.                currentToken = LPAREN;
     
162.                break;
     
163.              case ')':
     
164.                currentToken = RPAREN;
     
165.                break;
     
166.              case ';':
     
167.                currentToken = SEMI;
     
168.                break;
     
169.              default:
     
170.                currentToken = ERROR;
     
171.                break;
     
172.            }
     
173.          }
     
174.          break;
     
175.        case INCOMMENT:
     
176.          save = FALSE;
     
177.          if (c == EOF)
     
178.          { state = DONE;
     
179.            currentToken = ENDFILE;
     
180.          }
     
181.          else if (c == '}') state = START;
     
182.          break;
     
183.        case INASSIGN:
     
184.          state = DONE;
     
185.          if (c == '=')
     
186.            currentToken = ASSIGN;
     
187.          else
     
188.          { /* backup in the input */
     
189.            ungetNextChar();
     
190.            save = FALSE;
     
191.            currentToken = ERROR;
     
192.          }
     
193.          break;
     
194.        case INNUM:
     
195.          if (!isdigit(c))
     
196.          { /* backup in the input */
     
197.            ungetNextChar();
     
198.            save = FALSE;
     
199.            state = DONE;
     
200.            currentToken = NUM;
     
201.          }
     
202.          break;
     
203.        case INID:
     
204.          if (!isalpha(c))
     
205.          { /* backup in the input */
     
206.            ungetNextChar();
     
207.            save = FALSE;
     
208.            state = DONE;
     
209.            currentToken = ID;
     
210.          }
     
211.          break;
     
212.        case DONE:
     
213.        default: /* should never happen */
     
214.          fprintf(listing,"Scanner Bug: state= %d\n",state);
     
215.          state = DONE;
     
216.          currentToken = ERROR;
     
217.          break;
     
218.      }
     
219.      if ((save) && (tokenStringIndex <= MAXTOKENLEN))
     
220.        tokenString[tokenStringIndex++] = (char) c;
     
221.      if (state == DONE)
     
222.      { tokenString[tokenStringIndex] = '\0';
     
223.        if (currentToken == ID)
     
224.          currentToken = reservedLookup(tokenString);
     
225.      }
     
226.    }
     
227. 
     
228.      fprintf(listing,"\t%d: ",lineno);
     
229.      printToken(currentToken,tokenString,listing);
     
230.      printToken(currentToken,tokenString,fp);
     
231. 
     
232.    return currentToken;
     
233. } /* end getToken */
     
234. 
     
235. 
     
236. 
     
237. main( int argc, char * argv[] )
     
238. {
     
239.   char pgm[120]; /* source code file name */
     
240.   if (argc != 2)
     
241.     { fprintf(stderr,"usage: %s <filename>\n",argv[0]);
     
242.       exit(1);
     
243.     }
     
244.   strcpy(pgm,argv[1]) ;
     
245.   if (strchr (pgm, '.') == NULL)
     
246.      strcat(pgm,".tny");
     
247.   source = fopen(pgm,"r");
     
248.   if (source==NULL)
     
249.   { fprintf(stderr,"File %s not found\n",pgm);
     
250.     exit(1);
     
251.   }
     
252.   listing = stdout; /* send listing to screen */
     
253.   fprintf(listing,"\nTINY COMPILATION: %s\n",pgm);
     
254. 
     
255. if((fp=fopen("string.txt","wt"))==NULL)
     
256. {
     
257. printf("Cannot open file strike any key exit!");
     
258. getch();
     
259. exit(1);
     
260. }
     
261. 
     
262. 
     
263. fprintf(fp,"\nTINY COMPILATION: %s\n",pgm);
     
264. 
     
265.    while (getToken()!=ENDFILE);
     
266.   }
     

复制代码

soloforce

放在scan.h时要用extern修饰吧？

bluespirit

thanks
以前还真没注意这个关键字。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－


C语言之extern声明辨析-
                                          
1 基本解释

　　extern可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。

　　另外，extern也可用来进行链接指定。


　　2 问题：extern 变量

　　在一个源文件里定义了一个数组：

char a[6];

　　在另外一个文件里用下列语句进行了声明：

extern char *a；


　　请问，这样可以吗？

　　答案与分析：

　　1)、不可以，程序运行时会告诉你非法访问。原因在于，指向类型T的指针并不等价于类型T的数组。extern char *a声明的是一个指针变量而不是字符数组，因此与实际的定义不同，从而造成运行时非法访问。应该将声明改为extern char a[ ]。

　　2)、例子分析如下，如果a[] = "abcd",则外部变量a=0x61626364 (abcd的ASCII码值)，*a显然没有意义，如下图：


　　显然a指向的空间（0x61626364）没有意义，易出现非法内存访问。

　　3)、这提示我们，在使用extern时候要严格对应声明时的格式，在实际编程中，这样的错误屡见不鲜。

　　4)、extern用在变量声明中常常有这样一个作用，你在*.c文件中声明了一个全局的变量，这个全局的变量如果要被引用，就放在*.h中并用extern来声明。

　　3 问题：extern 函数1

　　常常见extern放在函数的前面成为函数声明的一部分，那么，C语言的关键字extern在函数的声明中起什么作用？

　　答案与分析：

　　如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别：



extern int f(); 和int f();



　　当然，这样的用处还是有的，就是在程序中取代include “*.h”来声明函数，在一些复杂的项目中，我比较习惯在所有的函数声明前添加extern修饰。

　　4 问题：extern 函数2

　　当函数提供方单方面修改函数原型时，如果使用方不知情继续沿用原来的extern申明，这样编译时编译器不会报错。但是在运行过程中，因为少了或者多了输入参数，往往会照成系统错误，这种情况应该如何解决？

　　答案与分析：

　　目前业界针对这种情况的处理没有一个很完美的方案，通常的做法是提供方在自己的xxx_pub.h中提供对外部接口的声明，然后调用方include该头文件，从而省去extern这一步。以避免这种错误。

　　宝剑有双锋，对extern的应用，不同的场合应该选择不同的做法。

　　5 问题：extern “C”

　　在C++环境下使用C函数的时候，常常会出现编译器无法找到obj模块中的C函数定义，从而导致链接失败的情况，应该如何解决这种情况呢？

　　答案与分析：

　　C++语言在编译的时候为了解决函数的多态问题，会将函数名和参数联合起来生成一个中间的函数名称，而C语言则不会，因此会造成链接时找不到对应函数的情况，此时C函数就需要用extern “C”进行链接指定，这告诉编译器，请保持我的名称，不要给我生成用于链接的中间函数名。

　　下面是一个标准的写法：



//在.h文件的头上
#ifdef __cplusplus
#if __cplusplus
extern "C"{
　#endif
　#endif /* __cplusplus */
　…
　…
　//.h文件结束的地方
　#ifdef __cplusplus
　#if __cplusplus
}
#endif
#endif /* __cplusplus */

Anakin

哦，tiny, 当初我们学编译原理也是用这本书