source: palm/trunk/UTIL/chemistry/gasphase_preproc/kpp/src/code_c.c @ 4072

Last change on this file since 4072 was 2696, checked in by kanani, 7 years ago

Merge of branch palm4u into trunk

File size: 15.2 KB
Line 
1/******************************************************************************
2
3  KPP - The Kinetic PreProcessor
4        Builds simulation code for chemical kinetic systems
5
6  Copyright (C) 1995-1996 Valeriu Damian and Adrian Sandu
7  Copyright (C) 1997-2005 Adrian Sandu
8
9  KPP is free software; you can redistribute it and/or modify it under the
10  terms of the GNU General Public License as published by the Free Software
11  Foundation (http://www.gnu.org/copyleft/gpl.html); either version 2 of the
12  License, or (at your option) any later version.
13
14  KPP is distributed in the hope that it will be useful, but WITHOUT ANY
15  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
16  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
17  details.
18
19  You should have received a copy of the GNU General Public License along
20  with this program; if not, consult http://www.gnu.org/copyleft/gpl.html or
21  write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22  Boston, MA  02111-1307,  USA.
23
24  Adrian Sandu
25  Computer Science Department
26  Virginia Polytechnic Institute and State University
27  Blacksburg, VA 24060
28  E-mail: sandu@cs.vt.edu
29
30******************************************************************************/
31
32
33#include "gdata.h"
34#include "code.h"
35#include <string.h>
36
37#define MAX_LINE  120
38#define LINE_LENGTH 70
39
40int fncPrototipe = 0;
41
42char *C_types[] = { "void",     /* VOID */ 
43                    "int",    /* INT */
44                    "float",  /* FLOAT */
45                    "double", /* DOUBLE */
46                    "char *", /* STRING */
47                    "char *"  /* DOUBLESTRING */
48                  }; 
49
50void C_WriteElm( NODE * n )
51{
52ELEMENT *elm;
53char * name;
54char maxi[20];
55char maxj[20];
56
57  elm = n->elm;
58  name = varTable[ elm->var ]->name;
59
60  switch( n->type ) {
61    case CONST: bprintf("%g", elm->val.cnst);
62                break;
63    case ELM:   bprintf("%s", name);
64                break;
65    case VELM:  if( elm->val.idx.i >= 0 ) sprintf( maxi, "%d", elm->val.idx.i );
66                  else sprintf( maxi, "%s", varTable[ -elm->val.idx.i ]->name );
67                bprintf("%s[%s]", name, maxi );
68                break;
69    case MELM:  if( elm->val.idx.i >= 0 ) sprintf( maxi, "%d", elm->val.idx.i );
70                  else sprintf( maxi, "%s", varTable[ -elm->val.idx.i ]->name );
71                if( elm->val.idx.j >= 0 ) sprintf( maxj, "%d", elm->val.idx.j );
72                  else sprintf( maxj, "%s", varTable[ -elm->val.idx.j ]->name );
73                bprintf("%s[%s][%s]", name, maxi, maxj );
74                break;
75    case EELM:  bprintf("(%s)", elm->val.expr );
76                break;
77  }
78}
79
80void C_WriteSymbol( int op )
81{
82  switch( op ) {
83    case ADD:   bprintf("+");
84                AllowBreak(); 
85                break;
86    case SUB:   bprintf("-"); 
87                AllowBreak(); 
88                break;
89    case MUL:   bprintf("*"); 
90                AllowBreak(); 
91                break;
92    case DIV:   bprintf("/"); 
93                AllowBreak(); 
94                break;
95    case POW:   bprintf("power");
96                break;         
97    case O_PAREN: bprintf("(");
98                AllowBreak(); 
99                break;           
100    case C_PAREN: bprintf(")");
101                break;           
102    case NONE:
103                break;           
104  }
105}
106
107void C_WriteAssign( char *ls, char *rs )
108{
109int start;
110int crtident;
111int linelg;
112int i,j;
113char c;
114int first;
115int number_of_lines = 1, MAX_NO_OF_LINES = 99;
116int ifound, jfound;
117
118/*  Operator Mapping: 0xaa = '*' | 0xab = '+' | 0xac = ','
119                      0xad = '-' | 0xae ='.' | 0xaf = '/' */                 
120/* char op_mult=0xaa, op_plus=0xab, op_minus=0xad, op_dot=0xae, op_div=0xaf; */               
121char op_mult='*', op_plus='+', op_minus='-', op_dot='.', op_div='/';                 
122
123  crtident = 2 + ident * 2;
124  bprintf("%*s%s = ", crtident, "", ls);
125  start = strlen( ls ) + crtident + 2;
126  linelg = LINE_LENGTH - start;
127
128  first = 1;
129  while( strlen(rs) > linelg ) {
130    ifound = 0; jfound = 0;
131    if ( number_of_lines >= MAX_NO_OF_LINES ) {/* if a new line needs to be started */
132     for( j=linelg; j>5; j-- ) /* split row here if +, -, or comma */
133       if ( ( rs[j] == op_plus )||( rs[j] == op_minus )||( rs[j]==',' ) ) { 
134        jfound = 1; i=j; break;
135        }
136    }
137    if ( ( number_of_lines < MAX_NO_OF_LINES )||( !jfound ) ) {
138     for( i=linelg; i>10; i-- ) /* split row here if operator or comma */
139       if ( ( rs[i] & 0x80 )||( rs[i]==',' ) ) {
140        ifound = 1; break;
141        }
142     if( i <= 10 ) {
143      printf("\n Warning: possible error in continuation lines for %s = ...",ls);
144      i = linelg;
145     }
146    } 
147    while ( rs[i-1] & 0x80 ) i--; /* put all operators on the next row */
148    while ( rs[i] == ',' ) i++; /* put commas on the current row */
149   
150    /*for( i=linelg; i>10; i-- )
151      if( ( rs[i] & 0x80 ) || ( rs[i] == ',' ) )
152        break;
153    if( i < 10 ) {
154      printf("\nPossible error when cutting lines");
155      i = linelg;
156    }*/
157   
158    c = rs[i]; 
159    rs[i] = 0;
160    if ( first ) { 
161      bprintf("%s", rs );
162      linelg++;
163      first = 0;
164    } else {
165      bprintf("\n%*s%s", start, "", rs );     
166      if ( jfound ) {
167         bprintf(";\n%*s%s = %s", crtident, "", ls, ls);
168         number_of_lines = 1;
169         }
170    } 
171    rs[i] = c;
172    rs += i;
173    number_of_lines++;
174  }
175
176  if ( number_of_lines > MAX_NO_OF_LINES )
177     printf("\n Warning: many continuation lines (%d) for %s = ...",number_of_lines,ls);
178 
179  if ( first ) bprintf("%s;\n", rs );
180          else bprintf("\n%*s%s;\n", start, "", rs );
181
182  FlushBuf();
183}
184
185void C_WriteComment( char *fmt, ... )
186{
187Va_list args;
188char buf[ MAX_LINE ];
189
190  Va_start( args, fmt );
191  vsprintf( buf, fmt, args );
192  va_end( args );
193
194  bprintf( "/* %-*s */\n", LINE_LENGTH - 6, buf );
195
196  FlushBuf();
197}
198
199
200char * C_Decl( int v )
201{ 
202static char buf[120];
203VARIABLE *var;
204char *baseType;
205char maxi[20];
206char maxj[20];
207
208  var = varTable[ v ];
209  baseType = C_types[ var->baseType ];
210 
211  *buf = 0;
212 
213  switch( var->type ) {
214    case ELM:   
215              sprintf( buf, "%s %s", baseType, var->name );
216                break;
217    case VELM: 
218              if( var->maxi > 0 ) sprintf( maxi, "%d", var->maxi );
219              if( var->maxi == 0 ) sprintf( maxi, "%d", 1 );
220                /*  else sprintf( maxi, "%s", varTable[ -var->maxi ]->name);  */
221              if ( var->maxi < 0 ) {
222                    if (varTable[ -var->maxi ]->value < 0) 
223                      sprintf( maxi, "%s", varTable[ -var->maxi ]->name );
224                    else 
225                      sprintf( maxi, "%d", (varTable[-var->maxi]->value)==0?
226                           1:varTable[-var->maxi]->value );
227              } 
228                /*if( (var->maxi == 0) ||
229                    ((var->maxi < 0) && (varTable[ -var->maxi ]->maxi == 0)) )
230                  sprintf( maxi, "%s+1", maxi );*/
231              if( fncPrototipe ) 
232                  sprintf( buf, "%s %s[]", baseType, var->name );
233              else 
234                  sprintf( buf, "%s %s[%s]", baseType, var->name, maxi );
235              break;
236    case MELM: 
237              if( var->maxi > 0 ) sprintf( maxi, "%d", var->maxi );
238              else { 
239                 if (varTable[ -var->maxi ]->value < 0)
240                    sprintf( maxi, "%s", varTable[ -var->maxi ]->name );
241                 else 
242                    sprintf( maxi, "%d", (varTable[-var->maxi]->value)==0?
243                           1:varTable[-var->maxi]->value );
244              } 
245                /* if( (var->maxi == 0) ||
246                    ((var->maxi < 0) && (varTable[ -var->maxi ]->maxi == 0)) )
247                  strcat( maxi, "+1"); */
248              if( var->maxj > 0 ) sprintf( maxj, "%d", var->maxj );
249              else {
250                  if (varTable[ -var->maxj ]->value < 0)
251                     sprintf( maxj, "%s", varTable[ -var->maxj ]->name );
252                  else 
253                     sprintf( maxj, "%d", (varTable[-var->maxj]->value)==0?
254                           1:varTable[-var->maxj]->value );
255              }
256              if( fncPrototipe ) 
257                  sprintf( buf, "%s %s[][]", baseType, var->name );
258              else 
259                  sprintf( buf, "%s %s[%s][%s]",
260                        baseType, var->name, maxi, maxj ); 
261                break;
262    default:
263                Message( "Can not declare type %d", var->type );
264                Message( "v = %d", v );
265                break;
266  }
267  return buf;
268}
269
270void C_Declare( int v )
271{
272  bprintf("%-40s", strcat( C_Decl(v), ";" ) ); 
273  if( varTable[ v ]->comment )
274    bprintf(" /* %s */\n", varTable[ v ]->comment );
275  else 
276    bprintf("\n");   
277
278  FlushBuf();
279}
280
281void C_ExternDeclare( int v )
282{
283  bprintf("extern %-40s", strcat( C_Decl(v), ";" ) ); 
284  if( varTable[ v ]->comment )
285    bprintf(" /* %s */\n", varTable[ v ]->comment );
286  else 
287    bprintf("\n");   
288
289  FlushBuf();
290}
291
292void C_GlobalDeclare( int v )
293{
294  C_Declare( v );
295}
296
297void C_InitDeclare( int v, int n, void * values )
298{
299int i;
300VARIABLE *var;
301int * ival;
302double * dval;
303char ** cval;
304int maxCols = MAX_COLS;
305
306  var = varTable[ v ];
307  ival = (int*) values;
308  dval = (double*) values;
309  cval = (char**) values;
310 
311  if( var->comment )
312      bprintf(" /* %s */\n\n", var->comment );
313       
314  switch( var->type ) {
315    case VELM: bprintf( "  %s  %s[] = {\n%5s", C_types[var->baseType], var->name, " " );
316               for( i = 0; i < n; i++ ) {
317                 switch( var->baseType ) {
318                   case INT: bprintf( "%3d",  ival[i] ); maxCols=12; break;
319                   case DOUBLE:
320                   case REAL:bprintf( "%5lg", dval[i] ); maxCols=8; break;
321                   case STRING:bprintf( "\"%s\"", cval[i] ); maxCols=8; break;
322                   case DOUBLESTRING:bprintf( "\"%s\"", cval[i] ); maxCols=1; break;
323                 }
324                 if( i < n-1 ) bprintf( "," );
325                 if( (i+1) % maxCols == 0 ) bprintf( "\n%5s", " " );
326               } 
327               if( n == 0 ) bprintf( "0" );
328               bprintf( " }; \n\n" );
329               break;
330               
331    case ELM:  bprintf( "  %s %s = ", C_types[var->baseType], var->name );
332               switch( var->baseType ) {
333                 case INT: bprintf( "%d",  *ival ); break;
334                 case DOUBLE:
335                 case REAL:bprintf( "%lg", *dval ); break;
336                 case STRING:bprintf( "\"%s\"", *cval ); break;
337                 case DOUBLESTRING:bprintf( "\"%s\"", *cval ); break;
338               }
339               bprintf( ";\n\n" );
340               break;
341               
342    default:   printf( "\n Function not defined !\n" );
343               break;
344  }
345
346  FlushBuf();
347}
348
349void C_DeclareConstant( int v, char *val ) 
350{
351VARIABLE *var;
352int ival;
353char dummy_val[100];           /* used just to avoid strange behaviour of
354                                  sscanf when compiled with gcc */
355                                 
356  strcpy(dummy_val,val);val = dummy_val;
357 
358  var = varTable[ v ];
359
360  if( sscanf(val, "%d", &ival) == 1 ) 
361    if( ival == 0 ) var->maxi = 0;
362               else var->maxi = 1;
363  else
364    var->maxi = -1;       
365
366  switch( var->type ) {
367    case CONST: bprintf("#define %-20s %-10s ", var->name, val );
368                break;       
369    default:
370                printf( "Invalid constant", var->type );
371                break;
372  }
373  if( varTable[ v ]->comment )
374    bprintf(" /* %s */\n", varTable[ v ]->comment );
375  else 
376    bprintf("\n");   
377
378  FlushBuf();
379}
380
381void C_FunctionStart( int f, int *vars )
382{
383int i;
384int v;
385char * name;
386int narg;
387
388  name = varTable[ f ]->name;
389  narg = varTable[ f ]->maxi;
390
391  fncPrototipe = 1;
392
393  bprintf("void %s( \n", name );
394  for( i = 0; i < narg-1; i++ ) {
395    v = vars[ i ];
396    bprintf("  %-38s", strcat( C_Decl(v), "," ) ); 
397    if( varTable[ v ]->comment )
398      bprintf(" /* %s */\n", varTable[ v ]->comment );
399    else 
400      bprintf("\n");   
401  }
402  if( narg >= 1 ) {
403    v = vars[ i ];
404    bprintf("  %-38s", C_Decl(v) );
405    if( varTable[ v ]->comment )
406      bprintf(" /* %s */\n", varTable[ v ]->comment );
407    else 
408      bprintf("\n");   
409  }
410  bprintf(")");
411
412  fncPrototipe = 0;
413 
414  FlushBuf();
415}
416
417void C_FunctionPrototipe( int f, ... )
418{
419Va_list args;
420int i;
421int vars[20];
422char * name;
423int narg;
424
425  name = varTable[ f ]->name;
426  narg = varTable[ f ]->maxi;
427
428  Va_start( args, f ); 
429  for( i = 0; i < narg; i++ ) 
430    vars[i] = va_arg( args, int );
431  va_end( args );
432  C_FunctionStart( f, vars );
433  bprintf(";\n");
434
435  FlushBuf();
436}
437
438void C_FunctionBegin( int f, ... )
439{
440Va_list args;
441int i;
442int vars[20];
443char * name;
444int narg;
445
446  name = varTable[ f ]->name;
447  narg = varTable[ f ]->maxi;
448
449  Va_start( args, f ); 
450  for( i = 0; i < narg; i++ ) 
451    vars[i] = va_arg( args, int );
452  va_end( args );
453 
454  CommentFncBegin( f, vars );
455  C_FunctionStart( f, vars );
456  bprintf("\n");
457  bprintf("{\n");
458 
459  FlushBuf();
460
461  MapFunctionComment( f, vars );
462}
463
464void C_FunctionEnd( int f )
465{
466  bprintf("}\n\n");
467
468  FlushBuf();
469
470  CommentFunctionEnd( f );
471}
472
473void C_Inline( char *fmt, ... )
474{
475Va_list args;
476char buf[ 1000 ];
477
478  if( useLang != C_LANG ) return;
479 
480  Va_start( args, fmt );
481  vsprintf( buf, fmt, args );
482  va_end( args );
483  bprintf( "%s\n",buf );
484 
485  FlushBuf();
486}
487
488void Use_C()
489{ 
490  WriteElm          = C_WriteElm;
491  WriteSymbol       = C_WriteSymbol; 
492  WriteAssign       = C_WriteAssign;
493  WriteComment      = C_WriteComment;
494  DeclareConstant   = C_DeclareConstant;
495  Declare           = C_Declare;
496  ExternDeclare     = C_ExternDeclare;
497  GlobalDeclare     = C_GlobalDeclare;
498  InitDeclare       = C_InitDeclare;
499 
500  FunctionStart     = C_FunctionStart;
501  FunctionPrototipe = C_FunctionPrototipe;
502  FunctionBegin     = C_FunctionBegin;
503  FunctionEnd       = C_FunctionEnd;
504
505  OpenFile( &param_headerFile,   rootFileName, "_Parameters.h", "Parameter Header File" );
506  OpenFile( &initFile, rootFileName, "_Initialize.c", "Initialization File" );
507  OpenFile( &driverFile, rootFileName, "_Main.c", "Main Program File" );
508  OpenFile( &integratorFile, rootFileName, "_Integrator.c", 
509                   "Numerical Integrator (Time-Stepping) File" );
510  OpenFile( &linalgFile, rootFileName, "_LinearAlgebra.c", 
511                   "Linear Algebra Data and Routines File" );
512  OpenFile( &functionFile, rootFileName, "_Function.c", 
513                   "The ODE Function of Chemical Model File" );
514  OpenFile( &jacobianFile, rootFileName, "_Jacobian.c", 
515                   "The ODE Jacobian of Chemical Model File" );
516  OpenFile( &rateFile, rootFileName, "_Rates.c", 
517                   "The Reaction Rates File" );
518  if ( useStochastic )
519    OpenFile( &stochasticFile, rootFileName, "_Stochastic.c", 
520                   "The Stochastic Chemical Model File" );
521  if ( useStoicmat ) {
522    OpenFile( &stoichiomFile, rootFileName, "_Stoichiom.c", 
523                   "The Stoichiometric Chemical Model File" );
524    OpenFile( &sparse_stoicmFile, rootFileName, "_StoichiomSP.c", 
525                   "Sparse Stoichiometric Data Structures File" );
526  }               
527  OpenFile( &utilFile, rootFileName, "_Util.c", 
528                   "Auxiliary Routines File" );
529  OpenFile( &sparse_dataFile, rootFileName, "_Sparse.h", "Sparse Data Header File" );
530  OpenFile( &global_dataFile, rootFileName, "_Global.h", "Global Data Header File" );
531  if ( useJacSparse ) {
532     OpenFile( &sparse_jacFile, rootFileName, "_JacobianSP.c",
533        "Sparse Jacobian Data Structures File" ); 
534  }
535  if ( useHessian ) {
536     OpenFile( &hessianFile, rootFileName, "_Hessian.c", "Hessian File" );
537     OpenFile( &sparse_hessFile, rootFileName, "_HessianSP.c",
538         "Sparse Hessian Data Structures File" );
539  }   
540  OpenFile( &mapFile, rootFileName, ".map", 
541                   "Map File with Human-Readable Information" );
542  OpenFile( &monitorFile, rootFileName, "_Monitor.c", 
543                   "Utility Data Initialization" );
544} 
Note: See TracBrowser for help on using the repository browser.