请问个gcc编译器的问题

Question

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

Answer 1

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

Answer 2

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

Answer 3

Answer 4

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时候出现的错误

Answer 5

把scan.l和scan.y贴一下

Answer 6

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

Answer 7

弱问一下，lz在干啥？

Answer 8

这个gdata.h在哪里?

Answer 9

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

2. /******************************************************************************
4.   KPP - The Kinetic PreProcessor
5.         Builds simulation code for chemical kinetic systems
7.   Copyright (C) 1995-1996 Valeriu Damian and Adrian Sandu
8.   Copyright (C) 1997-2005 Adrian Sandu
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.
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.
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.
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]
31. ******************************************************************************/
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
42. %{
43.   #include "gdata.h"
44.   #include "scan.h"
45.   #include "y.tab.h"
47.   void*malloc() ;
48.   void Include ( char * filename );
49.   int EndInclude();
51.   int crt_line_no = 1;
52.   char *crt_filename;
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];
69.   int oldnErr = 0;
71.   int idx;
72.   int oldstate;
73.   extern int yyerrflag;
75.   typedef struct {
76.                    char *name;
77.                    int next;
78.                    int cmd;
79.                  } KEYWORD;
82.   KEYWORD keywords[] ;
83.   int CheckKeyword( char *cmd );
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. %}
100. BT            [ \t]
101. SPACE         [ \t]
102. CR      [\n]
103. TAG     [a-zA-Z_0-9]+
104. STRING         [^ \t\n{}#;]+
106. LIT           [a-zA-Z_]
107. CIF           [0-9]
109. IDSPC   {LIT}[a-zA-Z_0-9]*
111. NR          {CIF}*
112. NRS         [+-]?{CIF}+
113. REAL          {NRS}?"."?{NR}
114. UREAL          {NR}?"."?{NR}
115. FLOAT   {REAL}([eE]{NRS})?
116. UFLOAT  {UREAL}([eE]{NRS})?
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. %%
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;
344.   if ( yy_buf_level == MAX_INCLUDE ) {
345.     printf("\nInclude nested too deep. Include %s ignored", name);
346.     return;
347.   }
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;  
356.   crt_filename = (char *) malloc( 1 + strlen( name ) );
357.   strcpy( crt_filename, name );
359.   f = fopen( name, "r" );
360.   if( f == NULL )
361.     FatalError(3,"%s: Can't read file", name );
363.   newb = yy_create_buffer(f, YY_BUF_SIZE);
364.   yy_switch_to_buffer( newb );
365. }
367. int EndInclude()
368. {
369. YY_BUFFER_STATE oldb;
370. char * oldn;
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. }
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. }
394. int CheckKeyword( char *cmd )
395. {
396. int i;
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. }

复制代码