请问个gcc编译器的问题

silvergarden

本人转个模式，在安装过程中出现问题，但是同样在别人的机器上却没有这样的问题，编译过程中需要调用gcc，
我想问下是不是gcc版本不一样，就会造成编译过程的错误

eveson

不一定，软件不是都想下兼容的吗

albcamus

打个电话给上帝，看看他老人家能否听懂您的问题？

nikang0524

silvergarden

configure_kpp, settings:
location of flex library: /usr/lib64/libfl.a

SCC = gcc DM_CC = mpicc -cc=$(SCC) CC = $(SCC) -DFSEEKO64_OK CC_TOOLS = $(SCC) CC="$(SCC)" CFLAGS="$(CFLAGS)" \
writing chem/KPP/configure.kpp
/home/zcm/WRF/WRFV3
-----------------------------------------
compile kpp
make[1]: Entering directory `/home/zcm/WRF/WRFV3/chem/KPP/kpp/kpp-2.1/src'
  yacc -d scan.y
  gcc -O -c y.tab.c
  flex scan.l
  gcc -O -c lex.yy.c
scan.l:80: 错误：‘INC_STATE’ 未声明 (不在函数内)
scan.l:81: 错误：‘MOD_STATE’ 未声明 (不在函数内)
scan.l:82: 错误：‘INT_STATE’ 未声明 (不在函数内)
scan.l:83: 错误：‘PRM_STATE’ 未声明 (不在函数内)  
……  ……

scan.l:348: 错误：(即使在一个函数内多次出现，每个未声明的标识符在其
scan.l:348: 错误：所在的函数内只报告一次。)
scan.l:348: 警告：从不兼容的指针类型赋值
scan.l: 在函数 ‘EndInclude’ 中：
scan.l:372: 错误：‘yy_current_buffer’ 未声明 (在此函数内第一次使用)
scan.l:372: 警告：从不兼容的指针类型赋值
make[1]: *** [lex.yy.o] 错误 1
make[1]: Leaving directory `/home/zcm/WRF/WRFV3/chem/KPP/kpp/kpp-2.1/src'

sorry，说得不清楚，贴个错误提示出来，compile时候出现的错误

cjaizss

把scan.l和scan.y贴一下

silvergarden

把我的scan.l 、scan.h 、scan.y都发上来，谢谢帮忙

prolj

弱问一下，lz在干啥？

cjaizss

这个gdata.h在哪里?

cjaizss

我知道了,是在于不同LEX编译器的差别问题.
里面的宏在哪里define的问题,我帮你把scan.l改了一下,你再试下.

1. 
   
2. /******************************************************************************
   
3. 
   
4.   KPP - The Kinetic PreProcessor
   
5.         Builds simulation code for chemical kinetic systems
   
6. 
   
7.   Copyright (C) 1995-1996 Valeriu Damian and Adrian Sandu
   
8.   Copyright (C) 1997-2005 Adrian Sandu
   
9. 
   
10.   KPP is free software; you can redistribute it and/or modify it under the
    
11.   terms of the GNU General Public License as published by the Free Software
    
12.   Foundation ([url]http://www.gnu.org/copyleft/gpl.html[/url]); either version 2 of the
    
13.   License, or (at your option) any later version.
    
14. 
    
15.   KPP is distributed in the hope that it will be useful, but WITHOUT ANY
    
16.   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    
17.   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    
18.   details.
    
19. 
    
20.   You should have received a copy of the GNU General Public License along
    
21.   with this program; if not, consult [url]http://www.gnu.org/copyleft/gpl.html[/url] or
    
22.   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    
23.   Boston, MA  02111-1307,  USA.
    
24. 
    
25.   Adrian Sandu
    
26.   Computer Science Department
    
27.   Virginia Polytechnic Institute and State University
    
28.   Blacksburg, VA 24060
    
29.   E-mail: [email]sandu@cs.vt.edu[/email]
    
30. 
    
31. ******************************************************************************/
    
32. 
    
33. 
    
34. 
    
35. %s CMD_STATE INC_STATE MOD_STATE INT_STATE
    
36. %s PRM_STATE DSP_STATE SSP_STATE INI_STATE EQN_STATE EQNTAG_STATE
    
37. %s RATE_STATE LMP_STATE CR_IGNORE SC_IGNORE ATM_STATE LKT_STATE INL_STATE
    
38. %s MNI_STATE TPT_STATE USE_STATE
    
39. %s COMMENT COMMENT2 EQN_ID
    
40. %x INL_CODE
    
41. 
    
42. %{
    
43.   #include "gdata.h"
    
44.   #include "scan.h"
    
45.   #include "y.tab.h"
    
46. 
    
47.   void*malloc() ;
    
48.   void Include ( char * filename );
    
49.   int EndInclude();
    
50. 
    
51.   int crt_line_no = 1;
    
52.   char *crt_filename;
    
53. 
    
54.   #define MAX_INCLUDE 10
    
55.   
    
56.   YY_BUFFER_STATE yy_buffers[ MAX_INCLUDE ];
    
57.   int yy_line_no[ MAX_INCLUDE ];
    
58.   char *yy_filename[ MAX_INCLUDE ];
    
59.   int yy_buf_level = 0;
    
60.   
    
61.   char crtToken[100];
    
62.   char nextToken[100];
    
63.   int crtTokType;
    
64.   int nextTokType;
    
65.   int crtLine;
    
66.   char crtFile[MAX_PATH];
    
67.   char crt_rate[100];
    
68. 
    
69.   int oldnErr = 0;
    
70. 
    
71.   int idx;
    
72.   int oldstate;
    
73.   extern int yyerrflag;
    
74. 
    
75.   typedef struct {
    
76.                    char *name;
    
77.                    int next;
    
78.                    int cmd;
    
79.                  } KEYWORD;
    
80. 
    
81. 
    
82.   KEYWORD keywords[] ;
    
83.   int CheckKeyword( char *cmd );
    
84. 
    
85. #define RETURN( x ) \
    
86.         if(1) { \
    
87.           if ( yyerrflag == 0) { \
    
88.             strcpy( crtToken, nextToken ); \
    
89.             crtTokType = nextTokType; \
    
90.             crtLine = crt_line_no; \
    
91.             strcpy( crtFile, crt_filename ); \
    
92.           } \
    
93.           strcpy( nextToken, yytext); \
    
94.           nextTokType = x; \
    
95.           return (x); \
    
96.         }
    
97. %}
    
98. 
    
99. 
    
100. BT            [ \t]
     
101. SPACE         [ \t]
     
102. CR      [\n]
     
103. TAG     [a-zA-Z_0-9]+
     
104. STRING         [^ \t\n{}#;]+
     
105. 
     
106. LIT           [a-zA-Z_]
     
107. CIF           [0-9]
     
108. 
     
109. IDSPC   {LIT}[a-zA-Z_0-9]*
     
110. 
     
111. NR          {CIF}*
     
112. NRS         [+-]?{CIF}+
     
113. REAL          {NRS}?"."?{NR}
     
114. UREAL          {NR}?"."?{NR}
     
115. FLOAT   {REAL}([eE]{NRS})?
     
116. UFLOAT  {UREAL}([eE]{NRS})?
     
117. 
     
118. %%
     
119. {SPACE}+                {
     
120.                         }  
     
121. #                        { BEGIN CMD_STATE;
     
122.                         }
     
123. \{                      { oldstate = (yy_start - 1) / 2;
     
124.                           BEGIN COMMENT;
     
125.                         }
     
126. \/\/                    { oldstate = (yy_start - 1) / 2;
     
127.                           BEGIN COMMENT2;
     
128.                         }
     
129. <COMMENT>[^\}\n]*       {
     
130.                         }
     
131. <COMMENT>\}             { BEGIN oldstate;
     
132.                         }   
     
133. <COMMENT2>[^\n]*        {
     
134.                         }
     
135. <COMMENT2>{CR}          { crt_line_no++;
     
136.                           BEGIN oldstate;
     
137.                         }   
     
138. {CR}                        { crt_line_no++;
     
139.                         }
     
140. <CMD_STATE>{STRING}     { idx = CheckKeyword( yytext );
     
141.                           if ( idx < 0 ) {
     
142.                             BEGIN CR_IGNORE;
     
143.                             break;
     
144.                           }
     
145.                           BEGIN keywords[idx].next;
     
146.                           if ( keywords[idx].cmd ) {
     
147.                             crt_section = keywords[idx].cmd;
     
148.                             RETURN( keywords[idx].cmd );
     
149.                           }
     
150.                         }
     
151. <INC_STATE>{STRING}     { Include( IncName(yytext) );
     
152.                           BEGIN CR_IGNORE;
     
153.                         }
     
154. <MOD_STATE>{STRING}     { Include( ModelName(yytext) );
     
155.                           BEGIN CR_IGNORE;
     
156.                         }
     
157. <INT_STATE>{STRING}     { Include( IntegName(yytext) );
     
158.                           BEGIN CR_IGNORE;
     
159.                         }
     
160. <PRM_STATE>{STRING}     { strcpy( yylval.str, yytext );
     
161.                           BEGIN CR_IGNORE;                        
     
162.                           RETURN( PARAMETER );
     
163.                         }
     
164. <CR_IGNORE>{STRING}     { ScanError("Extra parameter on command line '%s'", yytext);
     
165.                         }
     
166. <ATM_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
167.                           RETURN( ATOMID );
     
168.                         }
     
169. <ATM_STATE>;            { RETURN( yytext[0] );
     
170.                         }
     
171. <DSP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
172.                           RETURN( SPCSPC );
     
173.                         }
     
174. <DSP_STATE>{NR}         { strcpy( yylval.str, yytext );
     
175.                           RETURN( SPCNR );
     
176.                         }
     
177. <DSP_STATE>[=]          { RETURN( SPCEQUAL );
     
178.                         }
     
179. <DSP_STATE>[+]          { RETURN( SPCPLUS );
     
180.                         }
     
181. <DSP_STATE>;            { RETURN( yytext[0] );
     
182.                         }
     
183. <DSP_STATE>[^;#]        { ScanError("Invalid character '%c' in species definition", yytext[0] );
     
184.                         }
     
185. <SSP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
186.                           RETURN( SSPID );
     
187.                         }
     
188. <SSP_STATE>;            { RETURN( yytext[0] );
     
189.                         }
     
190. <INI_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
191.                           RETURN( INISPC );
     
192.                         }
     
193. <INI_STATE>[=]          { RETURN( INIEQUAL );
     
194.                         }
     
195. <INI_STATE>;            { RETURN( yytext[0] );
     
196.                         }
     
197. <INI_STATE>{FLOAT}      { strcpy( yylval.str, yytext );
     
198.                           RETURN( INIVALUE );
     
199.                         }
     
200. <INI_STATE>[^=;#]       { ScanError("Invalid character '%c' in initial values", yytext[0] );
     
201.                         }
     
202. <EQN_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
203.                           RETURN( EQNSPC );
     
204.                         }
     
205. <EQN_STATE>[=]          { RETURN( EQNEQUAL );
     
206.                         }
     
207. <EQN_STATE>{UFLOAT}     { strcpy( yylval.str, yytext );
     
208.                           RETURN( EQNCOEF );
     
209.                         }
     
210. <EQN_STATE>[:]          { BEGIN RATE_STATE;
     
211.                           *crt_rate = 0;
     
212.                           RETURN( EQNCOLON );
     
213.                         }
     
214. <EQN_STATE>[+-]         { strcpy( yylval.str, yytext );
     
215.                           RETURN( EQNSIGN );
     
216.                         }
     
217. <EQN_STATE>[<]          { BEGIN EQNTAG_STATE;
     
218.                           RETURN( EQNLESS );
     
219.                         }
     
220. <EQNTAG_STATE>{TAG}     { strcpy( yylval.str, yytext );
     
221.                           RETURN( EQNTAG );
     
222.                         }
     
223. <EQNTAG_STATE>[>]       { BEGIN EQN_STATE;
     
224.                           RETURN( EQNGREATER );
     
225.                         }   
     
226. <RATE_STATE>{STRING}    { strcpy( yylval.str, yytext );
     
227.                           RETURN( RATE );
     
228.                         }
     
229. <RATE_STATE>;           { BEGIN EQN_STATE;
     
230.                           RETURN( yytext[0] );
     
231.                         }
     
232. <LMP_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
233.                           RETURN( LMPSPC );
     
234.                         }
     
235. <LMP_STATE>[+]          { RETURN( LMPPLUS );
     
236.                         }
     
237. <LMP_STATE>[:]          { RETURN( LMPCOLON );
     
238.                         }
     
239. <LMP_STATE>;            { RETURN( yytext[0] );
     
240.                         }
     
241. <LMP_STATE>[^;#]        { ScanError("Invalid character '%c' in species definition", yytext[0] );
     
242.                         }
     
243. <LKT_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
244.                           RETURN( LKTID );
     
245.                         }
     
246. <LKT_STATE>;            { RETURN( yytext[0] );
     
247.                         }
     
248. <TPT_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
249.                           RETURN( TPTID );
     
250.                         }
     
251. <TPT_STATE>;            { RETURN( yytext[0] );
     
252.                         }
     
253. <USE_STATE>{STRING}     { strcpy( yylval.str, yytext );
     
254.                           RETURN( USEID );
     
255.                         }
     
256. <USE_STATE>;            { RETURN( yytext[0] );
     
257.                         }
     
258. <MNI_STATE>{IDSPC}      { strcpy( yylval.str, yytext );
     
259.                           RETURN( MNIID );
     
260.                         }
     
261. <MNI_STATE>;            { RETURN( yytext[0] );
     
262.                         }
     
263. <INL_STATE>{STRING}        { strcpy( yylval.str, yytext );
     
264.                           BEGIN INL_CODE;
     
265.                           RETURN( INLCTX );
     
266.                         }
     
267. <INL_CODE>#[^ \t\n]*    { if ( EqNoCase( yytext+1, "ENDINLINE" ) ){
     
268.                             BEGIN INITIAL;
     
269.                             RETURN( ENDINLINE );
     
270.                           }
     
271.                           else {
     
272.                             strcpy( yylval.str, yytext );
     
273.                             RETURN( INCODE );
     
274.                           }
     
275.                         }
     
276. <INL_CODE>\n                { crt_line_no++;
     
277.                           strcpy( yylval.str,yytext );
     
278.                           RETURN( INCODE );
     
279.                         }
     
280. <INL_CODE>[^#\n]*        { strcpy( yylval.str,yytext );
     
281.                           RETURN( INCODE );
     
282.                         }
     
283. <<EOF>>                        { if ( ! EndInclude() ) {
     
284.                             RETURN( INITIAL );
     
285.                           }
     
286.                         }  
     
287. %%
     
288. 
     
289.   KEYWORD keywords[] = { { "INCLUDE",    INC_STATE, 0 },
     
290.                          { "MODEL",      MOD_STATE, 0 },
     
291.                          { "INTEGRATOR", INT_STATE, 0 },
     
292.                          { "JACOBIAN",   PRM_STATE, JACOBIAN },
     
293.                          { "HESSIAN",    PRM_STATE, HESSIAN },
     
294.                          { "STOICMAT",   PRM_STATE, STOICMAT },
     
295.                          { "STOCHASTIC", PRM_STATE, STOCHASTIC },
     
296.                          { "DOUBLE",     PRM_STATE, DOUBLE },
     
297.                          { "REORDER",    PRM_STATE, REORDER },
     
298.                          { "MEX",        PRM_STATE, MEX },
     
299.                          { "DUMMYINDEX", PRM_STATE, DUMMYINDEX},
     
300.                          { "EQNTAGS",    PRM_STATE, EQNTAGS},
     
301.                          { "FUNCTION",   PRM_STATE, FUNCTION },
     
302.                          { "ATOMS",      ATM_STATE, ATOMDECL },   
     
303.                          { "CHECK",      ATM_STATE, CHECK },
     
304.                          { "CHECKALL",   INITIAL,   CHECKALL },
     
305.                          { "DEFVAR",     DSP_STATE, DEFVAR },
     
306.                          { "DEFRAD",     DSP_STATE, DEFRAD },
     
307.                          { "DEFFIX",     DSP_STATE, DEFFIX },
     
308.                          { "SETVAR",     SSP_STATE, SETVAR },
     
309.                          { "SETRAD",     SSP_STATE, SETRAD },
     
310.                          { "SETFIX",     SSP_STATE, SETFIX },
     
311.                          { "INITVALUES", INI_STATE, INITVALUES },
     
312.                          { "EQUATIONS",  EQN_STATE, EQUATIONS },
     
313.                          { "LUMP",       LMP_STATE, LUMP },
     
314.                          { "LOOKAT",          LKT_STATE, LOOKAT },
     
315.                          { "LOOKATALL",  INITIAL,   LOOKATALL },
     
316.                          { "TRANSPORT",  TPT_STATE, TRANSPORT },
     
317.                          { "TRANSPORTALL", INITIAL,   TRANSPORTALL },
     
318.                          { "INITIALIZE", PRM_STATE, INITIALIZE },
     
319.                          { "XGRID",           PRM_STATE, XGRID },
     
320.                          { "YGRID",           PRM_STATE, YGRID },
     
321.                          { "ZGRID",           PRM_STATE, ZGRID },
     
322.                          { "MONITOR",          MNI_STATE, MONITOR },
     
323.                          { "WRITE_ATM",  INITIAL,   WRITE_ATM },
     
324.                          { "WRITE_SPC",  INITIAL,   WRITE_SPC },
     
325.                          { "WRITE_MAT",  INITIAL,   WRITE_MAT },
     
326.                          { "WRITE_OPT",  INITIAL,   WRITE_OPT },
     
327.                          { "USE",        PRM_STATE, USE },
     
328.                          { "LANGUAGE",   PRM_STATE, LANGUAGE },
     
329.                          { "INLINE",     INL_STATE, INLINE },
     
330.                          { "ENDINLINE",  INITIAL,   ENDINLINE },
     
331.                          { "INTFILE",    PRM_STATE, INTFILE },
     
332.                          { "DRIVER",     PRM_STATE, DRIVER },
     
333.                          { "RUN",        PRM_STATE, RUN },
     
334.                          { "USES",       USE_STATE, USES },
     
335.                          { "SPARSEDATA", PRM_STATE, SPARSEDATA },
     
336.                          { "WRFCONFORM",   INITIAL,   WRFCONFORM },
     
337.                          { 0, 0, 0 }
     
338.                        };
     
339. void Include ( char * name )
     
340. {
     
341. FILE *f;
     
342. YY_BUFFER_STATE newb;
     
343. 
     
344.   if ( yy_buf_level == MAX_INCLUDE ) {
     
345.     printf("\nInclude nested too deep. Include %s ignored", name);
     
346.     return;
     
347.   }
     
348. 
     
349.   yy_buffers[ yy_buf_level ]  = yy_current_buffer;
     
350.   yy_line_no[ yy_buf_level ]  = crt_line_no;
     
351.   yy_filename[ yy_buf_level ] = crt_filename;
     
352.   yy_buf_level++;
     
353.   
     
354.   crt_line_no = 1;  
     
355. 
     
356.   crt_filename = (char *) malloc( 1 + strlen( name ) );
     
357.   strcpy( crt_filename, name );
     
358. 
     
359.   f = fopen( name, "r" );
     
360.   if( f == NULL )
     
361.     FatalError(3,"%s: Can't read file", name );
     
362. 
     
363.   newb = yy_create_buffer(f, YY_BUF_SIZE);
     
364.   yy_switch_to_buffer( newb );
     
365. }
     
366. 
     
367. int EndInclude()
     
368. {
     
369. YY_BUFFER_STATE oldb;
     
370. char * oldn;
     
371. 
     
372.   if ( yy_buf_level > 0 ) {
     
373.     oldb = yy_current_buffer;
     
374.     oldn = crt_filename;
     
375.     yy_buf_level--;
     
376.     yy_switch_to_buffer( yy_buffers[yy_buf_level] );
     
377.     crt_line_no = yy_line_no[ yy_buf_level ];
     
378.     crt_filename = yy_filename[ yy_buf_level ];
     
379.     yy_delete_buffer( oldb );
     
380.     free( oldn );
     
381.     return 1;
     
382.   }
     
383.   return 0;
     
384. }
     
385. 
     
386. int EqNoCase( char *s1, char *s2 )
     
387. {
     
388.   while( *s1 ) {
     
389.     if ( toupper(*s1++) != toupper(*s2++) ) return 0;
     
390.   }
     
391.   return *s1 == *s2;
     
392. }
     
393. 
     
394. int CheckKeyword( char *cmd )
     
395. {
     
396. int i;
     
397. 
     
398.   i = 0;
     
399.   while( 1 ) {
     
400.     if( keywords[i].name == 0 ) {
     
401.       ScanError( "'%s': Unknown command (ignored)", cmd);
     
402.       return -1;
     
403.     }
     
404.     if( EqNoCase( cmd, keywords[i].name ) ) {
     
405.       return i;
     
406.     }
     
407.     i++;
     
408.   }
     
409. }
     
410. 
     
411. 
     

复制代码