Changeset 4e859f5 in git


Ignore:
Timestamp:
Mar 24, 1999, 2:04:21 PM (24 years ago)
Author:
Kai Krüger <krueger@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
c84d051818fc5b23bd500c3462fa3e1ea7a135a2
Parents:
2efb0e4a1f16840557ae3ada88076edccb960534
Message:
major internal changes of handling definition


git-svn-id: file:///usr/local/Singular/svn/trunk@2968 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
modules/tools
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • modules/tools/misc.cc

    r2efb0e r4e859f5  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: misc.cc,v 1.3 1999-03-19 14:12:08 krueger Exp $ */
     4/* $Id: misc.cc,v 1.4 1999-03-24 13:04:20 krueger Exp $ */
    55/*
    66* ABSTRACT: lib parsing
    … …  
    2727#define SYSTYP_HPUX9  2
    2828#define SYSTYP_HPUX10 3
     29
     30#if 0
     31#  define logx printf
     32#else
     33#  define logx
     34#endif
    2935
    3036char *DYNAinclude[] = {
    … …  
    134140  }
    135141#endif
    136   printf("IsCmd: [%d] %s\n", tok, n);
     142  logx("IsCmd: [%d] %s\n", tok, n);
    137143 
    138144  if( (cmds[i].toktype==ROOT_DECL) ||
    … …  
    181187
    182188/*========================================================================*/
     189void PrintProc(
     190  procdef pi
     191  )
     192{
     193  int i;
     194 
     195  printf("proc: %s(", pi.procname);
     196 
     197  for(i=0; i<pi.paramcnt; i++) {
     198    printf("%s", pi.param[i].name);
     199    if(i < (pi.paramcnt-1)) printf(",");
     200  }
     201  printf(")\n");
     202}
     203
     204/*========================================================================*/
    183205void make_version(char *p, moddefv module)
    184206{
    … …  
    207229
    208230/*========================================================================*/
    209 cfilesv Add2files(cfilesv cf, char *name)
    210 {
    211   cfilesv cfnew = (cfilesv)malloc(sizeof(cfiles));
    212   cfnew->filename = (char *)malloc(strlen(name+1));
    213   cfnew->next = NULL;
    214   strcpy(cfnew->filename, name);
    215   if(cf == NULL) cf = cfnew;
    216   else cfnew->next = cf;
    217   return(cfnew);
    218 }
    219 
    220 /*========================================================================*/
    221 procdefv Add2proclist(procdefv pi, char *name)
    222 {
    223   procdefv pnew = (procdefv)malloc(sizeof(procdef));
    224   pnew->procname = (char *)malloc(strlen(name+1));
    225   pnew->funcname = (char *)malloc(strlen(name+1));
    226   pnew->param = NULL;
    227   pnew->next = NULL;
    228   pnew->is_static = 0;
    229   pnew->paramcnt = 0;
    230   strcpy(pnew->procname, name);
    231   strcpy(pnew->funcname, name);
    232   if(pi==NULL) pi = pnew;
    233   else pnew->next = pi;
    234   return(pnew);
    235 }
    236 
    237 /*========================================================================*/
    238 void AddParam(procdefv pi, char *name, char *typname, int typ)
    239 {
    240 
    241 #ifdef NEW_PARAM
     231void Add2files(
     232  moddefv module,
     233  char *name
     234  )
     235{
     236  cfiles cfnew;
     237  memset((void *)&cfnew, '\0', sizeof(cfiles));
     238
     239  cfnew.filename = (char *)malloc(strlen(name)+1);
     240  memset(cfnew.filename, '\0', strlen(name)+1);
     241  memcpy(cfnew.filename, name, strlen(name));
     242
     243  if(module->filecnt==0) {
     244    module->files = (cfilesv)malloc(sizeof(cfiles)+1);
     245  }
     246  else {
     247    module->files = (cfilesv)realloc(module->files,
     248                                   (module->filecnt+1)*sizeof(cfiles));
     249  }
     250  if(module->files == NULL) { printf("ERROR\n"); return; }
     251 
     252  memset((void *) &module->files[module->filecnt], '\0', sizeof(cfiles));
     253  memcpy((void *)(&(module->files[module->filecnt])),
     254         (void *)&cfnew, sizeof(cfiles));
     255  (module->filecnt)++;
     256}
     257
     258/*========================================================================*/
     259/*  procdefv Add2proclist(procdefv pi, char *name)*/
     260void Add2proclist(
     261  moddefv module,
     262  char *name,
     263  char *ret_val,
     264  char *ret_typname,
     265  int ret_typ
     266  )
     267{
     268  procdef pnew;
     269  logx("Add2proclist(%s, %s)\n", name, ret_val);
     270 
     271  memset((void *)&pnew, '\0', sizeof(procdef));
     272  pnew.procname = (char *)malloc(strlen(name)+1);
     273  if(pnew.procname==NULL) printf("Error 1\n");
     274  pnew.funcname = (char *)malloc(strlen(name)+1);
     275  memset(pnew.funcname, '\0', strlen(name)+1);
     276  memset(pnew.procname, '\0', strlen(name)+1);
     277  pnew.param = NULL;
     278  (pnew).is_static = 0;
     279  (pnew).paramcnt = 0;
     280  strcpy(pnew.procname, name);
     281  strcpy(pnew.funcname, name);
     282
     283  pnew.return_val.name = (char *)malloc(strlen(ret_val)+1);
     284  memset(pnew.return_val.name, '\0', strlen(ret_val)+1);
     285  memcpy(pnew.return_val.name, ret_val, strlen(ret_val));
     286 
     287  pnew.return_val.typname = (char *)malloc(strlen(ret_typname)+1);
     288  memset(pnew.return_val.typname, '\0', strlen(ret_typname)+1);
     289  memcpy(pnew.return_val.typname, ret_typname, strlen(ret_typname));
     290  pnew.return_val.typ = ret_typ;
     291 
     292  if(module->proccnt==0) {
     293    module->procs = (procdefv)malloc(sizeof(procdef)+1);
     294  }
     295  else {
     296    module->procs = (procdefv)realloc(module->procs,
     297                                   (module->proccnt+1)*sizeof(procdef));
     298  }
     299  if(module->procs == NULL) { printf("ERROR\n"); return; }
     300 
     301  memset((void *) &module->procs[module->proccnt], '\0', sizeof(procdef));
     302  memcpy((void *)(&(module->procs[module->proccnt])),
     303         (void *)&pnew, sizeof(procdef));
     304  (module->proccnt)++;
     305}
     306
     307/*========================================================================*/
     308void AddParam(
     309  moddefv module,
     310  char *name,
     311  char *typname,
     312  int typ
     313  )
     314{
    242315  paramdef pnew;
    243   pnew.name = (char *)malloc(strlen(name+1));
     316  int proccnt = module->proccnt-1;
     317  int paramcnt = 0;
     318
     319  logx("AddParam(%d, %s, %s, %d)\n", module->procs[proccnt].paramcnt,
     320       module->procs[proccnt].procname,
     321       typname, typ);
     322  memset((void *)&pnew, '\0', sizeof(paramdef));
     323  pnew.name = (char *)malloc(strlen(name)+1);
     324  memset(pnew.name, '\0', strlen(name)+1);
    244325  pnew.next = NULL;
    245   strcpy(pnew.name, name);
    246   pnew.typname = (char *)malloc(strlen(typname+1));
    247   strcpy(pnew.typname, typname);
     326  memcpy(pnew.name, name, strlen(name));
     327  pnew.typname = (char *)malloc(strlen(typname)+1);
     328  memset(pnew.typname, '\0', strlen(typname)+1);
     329  memcpy(pnew.typname, typname, strlen(typname));
    248330  pnew.typ = typ;
    249331
    250   if(pi->paramcnt==0) {
    251     pi->param = (paramdefv)malloc(sizeof(paramdef));
    252   }
     332  paramcnt = module->procs[proccnt].paramcnt;
     333 if(module->procs[proccnt].paramcnt==0) {
     334    module->procs[proccnt].param = (paramdefv)malloc(sizeof(paramdef));
     335 }
    253336  else {
    254     pi->param = (paramdefv)realloc(pi->param,
    255                                    (pi->paramcnt+1)*sizeof(paramdef));
    256   }
    257   memcpy((void *)(&pi->param[pi->paramcnt]), (void *)&pnew, sizeof(paramdef));
    258 #else
    259   paramdefv pnew = (paramdefv)malloc(sizeof(paramdef));
    260   pnew->name = (char *)malloc(strlen(name+1));
    261   pnew->next = NULL;
    262   strcpy(pnew->name, name);
    263   pnew->typname = (char *)malloc(strlen(typname+1));
    264   strcpy(pnew->typname, typname);
    265   pnew->typ = typ;
    266 
    267   if(pi->param==NULL) pi->param = pnew;
    268   else {
    269     paramdefv pp = pi->param;
    270     while(pp->next != NULL) pp = pp->next;
    271     pp->next = pnew;
    272   }
    273 #endif
    274   (pi->paramcnt)++;
    275 }
    276 
    277 /*========================================================================*/
    278 void PrintProclist(procdefv pi)
    279 {
    280   procdefv v = pi;
    281 #ifdef NEW_PARAM
    282   int i;
    283   for(v=pi; v!=NULL; v = v->next) {
    284     printf("proc: %s(", v->procname);
    285     for(i=0; i<v->paramcnt; i++) {
    286       printf("%s", v->param[i].name);
    287       if(i < (v->paramcnt-1)) printf(",");
    288     }
    289    
    290     printf(")\n");
    291   }
    292 #else
    293   paramdefv pp;
    294   for(v=pi; v!=NULL; v = v->next) {
    295 //  while(v!=NULL) {
    296     pp = v->param;
    297     printf("proc: %s(", v->procname);
    298     if(pp!= NULL) {
    299       printf("%s", pp->name);
    300       while(pp->next!= NULL) {
    301         pp = pp->next;
    302         printf(",%s", pp->name);
    303       }
    304     }
    305     printf(")\n");
    306 //    v =v ->next;
    307   }
    308 #endif
     337    module->procs[proccnt].param =
     338      (paramdefv)realloc(module->procs[proccnt].param,
     339                         (paramcnt+1)*sizeof(paramdef));
     340  }
     341 
     342  memcpy((void *)(&module->procs[proccnt].param[paramcnt]),
     343         (void *)&pnew, sizeof(paramdef));
     344  (module->procs[proccnt].paramcnt)++;
     345  logx("AddParam() done\n");
     346}
     347
     348/*========================================================================*/
     349void PrintProclist(
     350  moddefv module
     351  )
     352{
     353  logx("PrintProclist()\n");
     354  int j;
     355  for(j=0; j<module->proccnt; j++) {
     356    PrintProc(module->procs[j]);
     357  }
    309358}
    310359
    311360/*========================================================================*/
    312361void generate_mod(
    313   procdefv pi,
    314   moddefv module,
    315   cfilesv c_filelist
     362  moddefv module
    316363  )
    317364{
    318365  procdefv v = NULL;
     366  cfilesv c_filelist = NULL;
     367  int proccnt;
    319368  FILE *fp_c, *fp_h;
    320369  char *filename;
    … …  
    350399  if(module->info != NULL) enter_id(fp_c, "info", module->info);
    351400  if(module->helpfile != NULL) enter_id(fp_c, "helpfile", module->helpfile);
    352   for(v=pi; v!=NULL; v = v->next) {
    353 //  while(v!=NULL) {
    354     printf("->%s, %s\n", v->procname, v->funcname);
     401 
     402  for(proccnt=0; proccnt<module->proccnt; proccnt++) {
     403    printf("->%s, %s\n", module->procs[proccnt].procname,
     404           module->procs[proccnt].funcname);
    355405    fprintf(fp_c, "  iiAddCproc(\"%s\",\"%s\",%s, mod_%s);\n",
    356             module->name, v->procname,
    357             v->is_static ? "TRUE" : "FALSE", v->funcname);
    358 //    v =v ->next;
     406            module->name, module->procs[proccnt].procname,
     407            module->procs[proccnt].is_static ? "TRUE" : "FALSE",
     408            module->procs[proccnt].funcname);
    359409  }
    360410  fprintf(fp_c, "  return 0;\n}\n\n");
    361   v = pi;
    362411
    363412  /* building entry-functions */
    364   for(v=pi; v!=NULL; v = v->next) {
    365     generate_function(v, fp_c);
    366     generate_header(v, fp_h);
     413  for(proccnt=0; proccnt<module->proccnt; proccnt++) {
     414    generate_function(&module->procs[proccnt], fp_c);
     415    generate_header(&module->procs[proccnt], fp_h);
    367416  }
    368417  printf("  done.\n");fflush(stdout);
    … …  
    377426 
    378427  fprintf(fp, "BOOLEAN mod_%s(leftv res, leftv h);\n", pi->funcname);
    379 #if 1
    380   fprintf(fp, "BOOLEAN %s(leftv res", pi->funcname);
    381   for (i=0;i<pi->paramcnt; i++)
    382     fprintf(fp, ", %s res%d", type_conv[pi->param[i].typ], i);
     428  switch( pi->return_val.typ) {
     429      case SELF_CMD:
     430        fprintf(fp, "BOOLEAN %s(res, ", pi->funcname);
     431        break;
     432
     433      default:
     434        fprintf(fp, "%s %s(", type_conv[pi->return_val.typ],
     435                pi->funcname);
     436  }
     437  for (i=0;i<pi->paramcnt; i++) {
     438    fprintf(fp, "%s res%d", type_conv[pi->param[i].typ], i);
     439    if(i<pi->paramcnt-1) fprintf(fp, ", ");
     440  }
    383441  fprintf(fp, ");\n\n");
    384 #else
    385   fprintf(fp, "BOOLEAN %s(leftv res, leftv h);\n\n", pi->funcname);
    386 #endif
    387442}
    388443
    … …  
    392447  printf("%s has %d paramters\n", pi->funcname, pi->paramcnt);
    393448 
    394   paramdefv pp = pi->param;
    395449  fprintf(fp, "BOOLEAN mod_%s(leftv res, leftv h)\n{\n", pi->funcname);
    396 #if 1
    397450  if(pi->paramcnt>0) {
    398451    if(pi->param[0].typ==SELF_CMD) {
    … …  
    414467        fprintf(fp, "  if((index=iiTestConvert(tok, %s))==0)\n",
    415468                pi->param[i].typname);
     469        logx("==>'%s'\n", pi->param[i].typname);
    416470        fprintf(fp, "     goto mod_%s_error;\n", pi->funcname);
    417471        fprintf(fp, "  printf(\"test %d.2\\n\");\n", i);
    … …  
    427481
    428482      fprintf(fp, "\n");
    429       fprintf(fp, "    return(%s(res", pi->funcname);
    430       for (i=0;i<pi->paramcnt; i++)
    431         fprintf(fp, ", (%s) res%d->Data()", type_conv[pi->param[i].typ], i);
    432       fprintf(fp, "));\n\n");
     483      switch( pi->return_val.typ) {
     484          case SELF_CMD:
     485            fprintf(fp, "    return(%s(res", pi->funcname);
     486            for (i=0;i<pi->paramcnt; i++)
     487              fprintf(fp, ", (%s) res%d->Data()",
     488                      type_conv[pi->param[i].typ], i);
     489            fprintf(fp, "));\n\n");
     490           break;
     491
     492          default:
     493            fprintf(fp, "  res->rtyp = %s;\n", pi->return_val.typname);
     494            fprintf(fp, "  res->data = (void *)%s(", pi->funcname);
     495            for (i=0;i<pi->paramcnt; i++) {
     496              fprintf(fp, "(%s) res%d->Data()",
     497                      type_conv[pi->param[i].typ], i);
     498              if(i<pi->paramcnt-1) fprintf(fp, ", ");
     499            }
     500            fprintf(fp, ");\n  return FALSE;\n\n");
     501      }
     502     
    433503      fprintf(fp, "  mod_%s_error:\n", pi->funcname);
    434504      fprintf(fp, "    Werror(\"%s(`%%s`) is not supported\", Tok2Cmdname(tok));\n",
    … …  
    446516  }
    447517     
    448 #else
    449   if(pp!= NULL && pp->typ!=SELF_CMD) {
    450     fprintf(fp, "  leftv v = h;\n");
    451     fprintf(fp, "  int tok = NONE, index = 0;\n");
    452     for (i=0;i<pi->paramcnt; i++)
    453       fprintf(fp, "  leftv res%d = (leftv)Alloc0(sizeof(sleftv));\n", i);
    454 
    455     fprintf(fp, "\n");
    456    
    457     while(pp!=NULL) {
    458       fprintf(fp, "  if(v==NULL) goto mod_%s_error;\n", pi->funcname);
    459       fprintf(fp, "  tok = v->Typ();\n");
    460       fprintf(fp, "  printf(\"test %d.1\\n\");\n", cnt);
    461       fprintf(fp, "  if((index=iiTestConvert(tok, %s))==0)\n", pp->typname);
    462       fprintf(fp, "     goto mod_%s_error;\n", pi->funcname);
    463       fprintf(fp, "  printf(\"test %d.2\\n\");\n", cnt);
    464       fprintf(fp, "  if(iiConvert(tok, %s, index, v, res%d))\n",
    465               pp->typname, cnt);
    466       fprintf(fp, "     goto mod_%s_error;\n", pi->funcname);
    467       fprintf(fp, "  printf(\"test %d.3\\n\");\n", cnt);
    468       fprintf(fp, "  v = v->next;\n");
    469       pp = pp->next;
    470       cnt++;
    471     }
    472     fprintf(fp, "  if(v!=NULL) { tok = v->Typ(); goto mod_%s_error; }\n", pi->funcname);
    473     fprintf(fp, "  printf(\"test before return\\n\");\n");
    474 
    475     fprintf(fp, "\n");
    476     fprintf(fp, "    return(%s(res", pi->funcname);
    477     for (i=0;i<pi->paramcnt; i++)
    478       fprintf(fp, ", res%d", i);
    479     fprintf(fp, "));\n\n");
    480     fprintf(fp, "  mod_%s_error:\n", pi->funcname);
    481     fprintf(fp, "    Werror(\"%s(`%%s`) is not supported\", Tok2Cmdname(tok));\n",
    482             pi->procname);
    483     fprintf(fp, "    Werror(\"expected %s(", pi->procname);
    484     for(pp = pi->param; pp != NULL; pp = pp->next) {
    485       fprintf(fp, "'%s'", pp->name);
    486       if(pp->next != NULL) fprintf(fp, ",");
    487     }
    488     fprintf(fp, ")\");\n");
    489     fprintf(fp, "    return TRUE;\n}\n\n");
    490   }
    491   else {
    492     fprintf(fp, "  return(%s(res,h));\n", pi->funcname);
    493     fprintf(fp, "}\n\n");
    494   }
    495 #endif
    496518     
    497519}
    … …  
    580602
    581603/*========================================================================*/
    582 void mod_create_makefile(moddefv module, cfilesv c_filelist)
     604void mod_create_makefile(moddefv module)
    583605{
    584606  FILE *fp;
    585607  fp = fopen("Makefile", "w");
    586   cfilesv cf = c_filelist;
     608  cfilesv cf = module->files;
     609  int i;
    587610 
    588611  printf("Creating Makefile  ...");fflush(stdout);
    … …  
    594617  fprintf(fp, "\n");
    595618  fprintf(fp, "SRCS\t= ");
    596   for(cf = c_filelist; cf != NULL; cf = cf->next)
    597     fprintf(fp, "%s ", cf->filename);
     619 
     620  for(i=0; i<module->filecnt; i++)
     621    fprintf(fp, "%s ", cf[i].filename);
    598622
    599623  fprintf(fp, "\nOBJS\t= ");
    600   for(cf = c_filelist; cf != NULL; cf = cf->next)
    601     fprintf(fp, "%s ", object_name(cf->filename));
     624  for(i=0; i<module->filecnt; i++)
     625    fprintf(fp, "%s ", object_name(cf[i].filename));
    602626
    603627  fprintf(fp, "\n\n");

  • modules/tools/modgen.h

    r2efb0e r4e859f5  
    11/*
    2  *  $Id: modgen.h,v 1.2 1999-03-17 12:41:31 krueger Exp $
     2 *  $Id: modgen.h,v 1.3 1999-03-24 13:04:21 krueger Exp $
    33 *
    44 */
    … …  
    3434  char *funcname;
    3535  int is_static;
     36  paramdef  return_val;
    3637  paramdefv param;
    37   int paramcnt;
     38  int       paramcnt;
    3839};
    3940
    … …  
    5253  char * info;
    5354  char * helpfile;
     55  procdefv procs;
     56  int      proccnt;
     57  cfilesv  files;
     58  int      filecnt;
    5459};
    5560
    … …  
    6065extern char * decl2str(int n, char *name);
    6166
    62 extern procdefv Add2proclist(procdefv pi, char *name);
    63 extern void AddParam(procdefv pi, char *name, char *typname, int typ);
    64 extern void generate_mod(procdefv pi, moddefv module, cfilesv c_filelist);
     67extern void PrintProclist(moddefv module);
     68extern void Add2proclist(moddefv module, char *name, char *ret_val,
     69                           char *ret_typname, int ret_typ);
     70extern void generate_mod(moddefv module);
     71extern void AddParam(moddefv module, char *name, char *typname, int typ);
     72extern void mod_create_makefile(moddefv module);
     73extern void Add2files(moddefv module, char *buff);
     74
    6575extern void generate_function(procdefv pi, FILE *fp);
    6676extern void mod_write_header(FILE *fp, char *module);
    6777extern void generate_header(procdefv pi, FILE *fp);
    6878extern void write_header(FILE *fp, char *module, char *comment="");
    69 extern void mod_create_makefile(moddefv module, cfilesv c_filelist);
    7079extern void make_version(char *p, moddefv module);
    71 extern cfilesv Add2files(cfilesv cf, char *buff);
    72 extern void PrintProclist(procdefv pi);
    7380

  • modules/tools/scanner.l

    r2efb0e r4e859f5  
    33*  Computer Algebra System SINGULAR     *
    44****************************************/
    5 /* $Id: scanner.l,v 1.2 1999-03-17 12:41:31 krueger Exp $ */
     5/* $Id: scanner.l,v 1.3 1999-03-24 13:04:21 krueger Exp $ */
    66#include <stdio.h>
    77#include <string.h>
    … …  
    2727int  myynest = -1;
    2828int  traceit = 0;
    29 procdefv proclist = NULL;
    3029moddef module_def;
    31 cfilesv c_filelist = NULL;
    3230
    3331extern "C"
    … …  
    7068             strcpy(module_def.name, buff);
    7169             strcat(buff, ".cc");
    72              c_filelist = Add2files(c_filelist,buff);
     70             Add2files(&module_def,buff);
    7371             free(buff);
    7472           }
    … …  
    9492             char *buff = (char *)malloc(yyleng);
    9593             sscanf( yytext, "%*[^=]=%s", buff);
    96              c_filelist = Add2files(c_filelist,buff);
     94             Add2files(&module_def,buff);
    9795             free(buff);
    9896           }
    … …  
    106104           }
    107105
     106
     107(proc+{tos}+{name}+{tos}+{name})|({tos}+proc+{tos}+{name}+{tos}+{name}) {
     108             char proc[256], ret_val[256], n2[32];
     109             int cmd;
     110             memset(proc, '\0', 256);
     111             memset(ret_val, '\0', 256);
     112             memset(n2, '\0', 32);
     113             old_state = YYSTATE;
     114             BEGIN(pdef);
     115             sscanf( yytext, "%*[^p]proc %s %s", ret_val, proc);
     116             if(strlen(proc)<1) sscanf( yytext, "proc %s %s", ret_val, proc);
     117             printf("'%s'\n", yytext);
     118             printf("R: proc '%s' '%s'\n", ret_val, proc);
     119             cmd = IsCmd(ret_val, tok);
     120             if(cmd!=0)
     121                Add2proclist(&module_def, proc, ret_val,
     122                                          decl2str(tok,n2), tok);
     123             else printf("proc '%s': Invalid return parameter %s.\n",
     124                         module_def.procs[module_def.proccnt-1].procname,
     125                         ret_val);
     126           }
    108127
    109128(proc+{tos}+{name})|({tos}+proc+{tos}+{name}) {
    … …  
    114133             sscanf( yytext, "%*[^p]proc %s", proc);
    115134             if(strlen(proc)<1) sscanf( yytext, "proc %s", proc);
    116              proclist = Add2proclist(proclist, proc);
    117              //printf("proc: %s\n", proc);
     135             Add2proclist(&module_def, proc, "none", "NONE", 0);
    118136           }
    119137
    … …  
    124142             char param[256], n2[32];
    125143             int cmd;
    126              param[0]='\0';
     144             memset(n2, '\0', 32);
     145             memset(param, '\0', 256);
    127146             sscanf( yytext, "%[^,],", param);
    128147             cmd = IsCmd(param, tok);
    129              if(cmd!=0)AddParam(proclist, param, decl2str(tok,n2), tok);
     148             if(cmd!=0)AddParam(&module_def,
     149                                param, decl2str(tok,n2), tok);
    130150             else printf("proc '%s': Invalid parameter %s.\n",
    131                          proclist->procname, param);
     151                         module_def.procs[module_def.proccnt-1].procname,
     152                         param);
    132153           }
    133154<pdef>{name}+\)+{eq}+{name} {
    … …  
    135156             int cmd;
    136157             BEGIN(old_state);
     158             memset(param, '\0', 256);
     159             memset(n2, '\0', 32);
    137160             memset(funcname, '\0', 256);
    138              param[0]='\0';
    139161             sscanf( yytext, "%[^)])%*[^=]=%s", param, funcname);
    140162             if(strlen(funcname)<=0)
    141163                sscanf( yytext, "%[^)])=%s", param, funcname);
    142              proclist->funcname = (char *)malloc(strlen(funcname)+1);
    143              strcpy(proclist->funcname, funcname);
     164             free(module_def.procs[module_def.proccnt-1].funcname);
     165             module_def.procs[module_def.proccnt-1].funcname =
     166                (char *)malloc(strlen(funcname)+1);
     167             memset(module_def.procs[module_def.proccnt-1].funcname,
     168                    '\0', strlen(funcname)+1);
     169             memcpy(module_def.procs[module_def.proccnt-1].funcname,
     170                    funcname, strlen(funcname));
    144171             cmd = IsCmd(param, tok);
    145              if(cmd!=0)AddParam(proclist, param, decl2str(tok,n2), tok);
     172             if(cmd!=0)AddParam(&module_def,
     173                                param, decl2str(tok,n2), tok);
    146174             else printf("proc '%s': Invalid parameter %s.\n",
    147                          proclist->procname, param);
     175                         module_def.procs[module_def.proccnt-1].procname, param);
    148176           }
    149177<pdef>\)+{eq}+{name}|{eq}+{tos}+{name} {
    … …  
    153181             if(strlen(funcname)<=0)
    154182                sscanf( yytext, "=%s", funcname);
    155              proclist->funcname = (char *)malloc(strlen(funcname)+1);
    156              strcpy(proclist->funcname, funcname);
     183             free(module_def.procs[module_def.proccnt-1].funcname);
     184             module_def.procs[module_def.proccnt-1].funcname =
     185                (char *)malloc(strlen(funcname)+1);
     186             memset(module_def.procs[module_def.proccnt-1].funcname,
     187                    '\0', strlen(funcname)+1);
     188             memcpy(module_def.procs[module_def.proccnt-1].funcname,
     189                    funcname, strlen(funcname));
    157190           }
    158191
    … …  
    188221  module_def.info=NULL;
    189222  module_def.helpfile=NULL;
     223  module_def.procs=NULL;
     224  module_def.proccnt = 0;
     225  module_def.files = NULL;
     226  module_def.filecnt = 0;
    190227  yylex();
    191   PrintProclist(proclist);
    192   generate_mod(proclist, &module_def, c_filelist);
    193   mod_create_makefile(&module_def, c_filelist);
     228  PrintProclist(&module_def);
     229  generate_mod(&module_def);
     230  mod_create_makefile(&module_def);
    194231
    195232}
Note: See TracChangeset for help on using the changeset viewer.