Changeset 4e859f5 in git for modules/tools/misc.cc


Ignore:
Timestamp:
Mar 24, 1999, 2:04:21 PM (25 years ago)
Author:
Kai Krüger <krueger@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
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
File:
1 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");
Note: See TracChangeset for help on using the changeset viewer.