[BACK]Return to pvar.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / parse

Diff for /OpenXM_contrib2/asir2000/parse/pvar.c between version 1.20 and 1.24

version 1.20, 2015/08/06 10:01:53 version 1.24, 2018/03/29 01:32:54
Line 45 
Line 45 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *   *
  * $OpenXM: OpenXM_contrib2/asir2000/parse/pvar.c,v 1.19 2014/08/09 06:08:11 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/parse/pvar.c,v 1.23 2017/02/07 08:30:31 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 57  int gdef,mgdef,ldef;
Line 57  int gdef,mgdef,ldef;
   
 void mkpvs(char *fname)  void mkpvs(char *fname)
 {  {
         VS pvs;    VS pvs;
         char *fullname,*buf;    char *fullname,*buf;
         FUNC f;    FUNC f;
   
         if ( CUR_MODULE ) {    if ( CUR_MODULE ) {
                 /* function must be declared in advance */      /* function must be declared in advance */
                 searchf(CUR_MODULE->usrf_list,fname,&f);      searchf(CUR_MODULE->usrf_list,fname,&f);
                 if ( !f ) {      if ( !f ) {
                         buf = ALLOCA(strlen("undeclared function "+strlen(fname)+10));        buf = ALLOCA(strlen("undeclared function "+strlen(fname)+10));
                         sprintf(buf,"undeclared function `%s'",fname);        sprintf(buf,"undeclared function `%s'",fname);
                         yyerror(buf);        yyerror(buf);
                         error("cannot continue to read inputs");        error("cannot continue to read inputs");
                 }      }
         }    }
         pvs = (VS)MALLOC(sizeof(struct oVS));    pvs = (VS)MALLOC(sizeof(struct oVS));
         pvs->va = (struct oPV *)MALLOC(DEFSIZE*sizeof(struct oPV));    pvs->va = (struct oPV *)MALLOC(DEFSIZE*sizeof(struct oPV));
         pvs->n = 0;    pvs->n = 0;
         pvs->asize=DEFSIZE;    pvs->asize=DEFSIZE;
         CPVS = pvs;    CPVS = pvs;
   
         /* XXX */    /* XXX */
         if ( CUR_MODULE ) {    if ( CUR_MODULE ) {
                 fullname =      fullname =
                         (char *)MALLOC_ATOMIC(strlen(CUR_MODULE->name)+strlen(fname)+1);        (char *)MALLOC_ATOMIC(strlen(CUR_MODULE->name)+strlen(fname)+1);
                 sprintf(fullname,"%s.%s",CUR_MODULE->name,fname);      sprintf(fullname,"%s.%s",CUR_MODULE->name,fname);
                 CUR_FUNC = fullname;      CUR_FUNC = fullname;
         } else    } else
                 CUR_FUNC = fname;      CUR_FUNC = fname;
 }  }
   
 void pushpvs(FUNC f)  void pushpvs(FUNC f)
 {  {
         VS pvs;    VS pvs;
         NODE node;    NODE node;
         int level;    int level;
         extern int evalstatline;    extern int evalstatline;
   
         pvs = f->f.usrf->pvs;    pvs = f->f.usrf->pvs;
         if ( PVSS ) {    if ( PVSS ) {
                 ((VS)BDY(PVSS))->at = evalstatline;      ((VS)BDY(PVSS))->at = evalstatline;
                 level = ((VS)BDY(PVSS))->level+1;      level = ((VS)BDY(PVSS))->level+1;
         } else    } else
                 level = 1;      level = 1;
         MKNODE(node,pvs,PVSS);    MKNODE(node,pvs,PVSS);
         PVSS = node;    PVSS = node;
         CPVS = (VS)MALLOC(sizeof(struct oVS)); BDY(PVSS) = (pointer)CPVS;    CPVS = (VS)MALLOC(sizeof(struct oVS)); BDY(PVSS) = (pointer)CPVS;
         CPVS->usrf = f;    CPVS->usrf = f;
         CPVS->n = CPVS->asize = pvs->n;    CPVS->n = CPVS->asize = pvs->n;
         CPVS->level = level;    CPVS->level = level;
         if ( CPVS->n ) {    if ( CPVS->n ) {
                 CPVS->va = (struct oPV *)MALLOC(CPVS->n*sizeof(struct oPV));      CPVS->va = (struct oPV *)MALLOC(CPVS->n*sizeof(struct oPV));
                 bcopy((char *)pvs->va,(char *)CPVS->va,(int)(pvs->n*sizeof(struct oPV)));      bcopy((char *)pvs->va,(char *)CPVS->va,(int)(pvs->n*sizeof(struct oPV)));
         }    }
         if ( nextbp )    if ( nextbp )
                 nextbplevel++;      nextbplevel++;
 }  }
   
 void poppvs() {  void poppvs() {
         PVSS = NEXT(PVSS);    PVSS = NEXT(PVSS);
         if ( PVSS )    if ( PVSS )
                 CPVS = (VS)BDY(PVSS);      CPVS = (VS)BDY(PVSS);
         else    else
                 CPVS = GPVS;      CPVS = GPVS;
         if ( nextbp )    if ( nextbp )
                 nextbplevel--;      nextbplevel--;
 }  }
   
 #define IS_LOCAL 0  #define IS_LOCAL 0
Line 132  void poppvs() {
Line 132  void poppvs() {
   
 unsigned int makepvar(char *str)  unsigned int makepvar(char *str)
 {  {
         int c,c1,created;    int c,c1,created;
         char *buf;    char *buf;
   
         if ( str[0] == '_' ) {    if ( str[0] == '_' ) {
                 /* pattern variable */      /* pattern variable */
                 c1 = getpvar(PPVS,str,0);      c1 = getpvar(PPVS,str,0);
                 c = PVPATTERN((unsigned int)c1);      c = PVPATTERN((unsigned int)c1);
                 PPVS->va[c1].attr = IS_PATTERN;      PPVS->va[c1].attr = IS_PATTERN;
         } else if ( gdef ) {    } else if ( gdef ) {
                 /* EPVS : global list of the current file */      /* EPVS : global list of the current file */
                 /* add to the local variable list */      /* add to the local variable list */
                 /* also add to the external variable list */      /* also add to the external variable list */
                 c = getpvar(CPVS,str,0);      c = getpvar(CPVS,str,0);
                 getpvar(EPVS,str,0);      getpvar(EPVS,str,0);
                 if ( CUR_MODULE ) {      if ( CUR_MODULE ) {
                         c1 = getpvar(CUR_MODULE->pvs,str,1);        c1 = getpvar(CUR_MODULE->pvs,str,1);
                         if ( c1 >= 0 ) goto CONFLICTION;        if ( c1 >= 0 ) goto CONFLICTION;
                 }      }
                 if ( CPVS != GPVS ) {      if ( CPVS != GPVS ) {
                         /* inside function : we add the name to the global list */        /* inside function : we add the name to the global list */
                         getpvar(GPVS,str,0);        getpvar(GPVS,str,0);
                         CPVS->va[c].attr = IS_GLOBAL;        CPVS->va[c].attr = IS_GLOBAL;
                 }      }
         } else if ( mgdef ) {    } else if ( mgdef ) {
                 c = getpvar(CPVS,str,0);      c = getpvar(CPVS,str,0);
                 getpvar(CUR_MODULE->pvs,str,0);      getpvar(CUR_MODULE->pvs,str,0);
                 c1 = getpvar(EPVS,str,1);      c1 = getpvar(EPVS,str,1);
                 if ( c1 >= 0 ) goto CONFLICTION;      if ( c1 >= 0 ) goto CONFLICTION;
                 if ( CPVS != GPVS ) {      if ( CPVS != GPVS ) {
                         /* inside function */        /* inside function */
                         CPVS->va[c].attr = IS_MGLOBAL;        CPVS->va[c].attr = IS_MGLOBAL;
                 }      }
         } else if ( ldef > 0 ) {    } else if ( ldef > 0 ) {
                 /* if ldef > 0, then local variables are being declared */      /* if ldef > 0, then local variables are being declared */
                 c = getpvar(CPVS,str,0);      c = getpvar(CPVS,str,0);
                 c1 = getpvar(EPVS,str,1);      c1 = getpvar(EPVS,str,1);
                 if ( c1 >= 0 ) {      if ( c1 >= 0 ) {
                         if ( CUR_MODULE )        if ( CUR_MODULE )
                                 goto CONFLICTION;          goto CONFLICTION;
                         else {        else {
                                 fprintf(stderr,"Warning: \"%s\", near line %d: conflicting declarations for `%s'\n",          fprintf(stderr,"Warning: \"%s\", near line %d: conflicting declarations for `%s'\n",
                                         asir_infile->name,asir_infile->ln,str);            asir_infile->name,asir_infile->ln,str);
                                 fprintf(stderr,"         `%s' is bound to the global variable\n",str);          fprintf(stderr,"         `%s' is bound to the global variable\n",str);
                                 CPVS->va[c].attr = IS_GLOBAL;          CPVS->va[c].attr = IS_GLOBAL;
                                 c1 = getpvar(GPVS,str,1); c = PVGLOBAL((unsigned int)c1);          c1 = getpvar(GPVS,str,1); c = PVGLOBAL((unsigned int)c1);
                         }        }
                 } else {      } else {
                         if ( CUR_MODULE ) {        if ( CUR_MODULE ) {
                                 c1 = getpvar(CUR_MODULE->pvs,str,1);          c1 = getpvar(CUR_MODULE->pvs,str,1);
                         }        }
                         if ( c1 >= 0 ) goto CONFLICTION;        if ( c1 >= 0 ) goto CONFLICTION;
                         CPVS->va[c].attr = IS_LOCAL;        CPVS->va[c].attr = IS_LOCAL;
                 }      }
         } else if ( CPVS != GPVS ) {    } else if ( CPVS != GPVS ) {
                 /* inside function */      /* inside function */
                 if ( CUR_MODULE ) {      if ( CUR_MODULE ) {
                         /* search only */        /* search only */
                         c = getpvar(CPVS,str,1);        c = getpvar(CPVS,str,1);
                         if ( c < 0 ) {        if ( c < 0 ) {
                                 c = getpvar(CPVS,str,0);          c = getpvar(CPVS,str,0);
                                 created = 1;          created = 1;
                         } else        } else
                                 created = 0;          created = 0;
                 } else {      } else {
                         /* may be created */        /* may be created */
                         c = getpvar(CPVS,str,0);        c = getpvar(CPVS,str,0);
                 }      }
                 switch ( CPVS->va[c].attr ) {      switch ( CPVS->va[c].attr ) {
                         case IS_GLOBAL:        case IS_GLOBAL:
                                 c1 = getpvar(GPVS,str,1); c = PVGLOBAL((unsigned int)c1);          c1 = getpvar(GPVS,str,1); c = PVGLOBAL((unsigned int)c1);
                                 break;          break;
                         case IS_MGLOBAL:        case IS_MGLOBAL:
                                 c1 = getpvar(CUR_MODULE->pvs,str,1); c = PVMGLOBAL((unsigned int)c1);          c1 = getpvar(CUR_MODULE->pvs,str,1); c = PVMGLOBAL((unsigned int)c1);
                                 break;          break;
                         case IS_LOCAL:        case IS_LOCAL:
                         default:        default:
                                 if ( CUR_MODULE &&          if ( CUR_MODULE &&
                                         ((c1 = getpvar(CUR_MODULE->pvs,str,1)) >= 0) ) {            ((c1 = getpvar(CUR_MODULE->pvs,str,1)) >= 0) ) {
                                         CPVS->va[c].attr = IS_MGLOBAL;            CPVS->va[c].attr = IS_MGLOBAL;
                                         c = PVMGLOBAL((unsigned int)c1);            c = PVMGLOBAL((unsigned int)c1);
                                 } else if ( getpvar(EPVS,str,1) >= 0 ) {          } else if ( getpvar(EPVS,str,1) >= 0 ) {
                                         CPVS->va[c].attr = IS_GLOBAL;            CPVS->va[c].attr = IS_GLOBAL;
                                         c1 = getpvar(GPVS,str,1); c = PVGLOBAL((unsigned int)c1);            c1 = getpvar(GPVS,str,1); c = PVGLOBAL((unsigned int)c1);
                                 } else if ( CUR_MODULE && created && (ldef == 0) ) {          } else if ( CUR_MODULE && created && (ldef == 0) ) {
                                         /* not declared */            /* not declared */
                                         /* if ldef == 0, at least one local variables has been            /* if ldef == 0, at least one local variables has been
                                            declared */               declared */
                                         fprintf(stderr,            fprintf(stderr,
                                                 "Warning: \"%s\", near line %d: undeclared local variable `%s'\n",              "Warning: \"%s\", near line %d: undeclared local variable `%s'\n",
                                                 asir_infile->name,asir_infile->ln,str);              asir_infile->name,asir_infile->ln,str);
                                 }          }
                                 break;          break;
                 }      }
         } else if ( CUR_MODULE ) {    } else if ( CUR_MODULE ) {
                 /* outside function, inside module */      /* outside function, inside module */
                 if ( (c = getpvar(CUR_MODULE->pvs,str,1)) >= 0 )      if ( (c = getpvar(CUR_MODULE->pvs,str,1)) >= 0 )
                         c = PVMGLOBAL((unsigned int)c);        c = PVMGLOBAL((unsigned int)c);
                 else if ( getpvar(EPVS,str,1) >= 0 ) {      else if ( getpvar(EPVS,str,1) >= 0 ) {
                         c = getpvar(GPVS,str,1);        c = getpvar(GPVS,str,1);
                         c = PVGLOBAL((unsigned int)c);        c = PVGLOBAL((unsigned int)c);
                 } else {      } else {
                         /* not declared as static or extern */        /* not declared as static or extern */
                         buf = ALLOCA(strlen("undeclared variable"+strlen(str)+10));        buf = ALLOCA(strlen("undeclared variable"+strlen(str)+10));
                         sprintf(buf,"undeclared variable `%s'",str);        sprintf(buf,"undeclared variable `%s'",str);
                         yyerror(buf);        yyerror(buf);
                 }      }
         } else {    } else {
                 /* outside function, outside module */      /* outside function, outside module */
                 c = getpvar(GPVS,str,0);      c = getpvar(GPVS,str,0);
         }    }
         return c;    return c;
   
 CONFLICTION:  CONFLICTION:
         buf = ALLOCA(strlen("conflicting declarations for "+strlen(str)+10));    buf = ALLOCA(strlen("conflicting declarations for "+strlen(str)+10));
         sprintf(buf,"conflicting declarations for `%s'",str);    sprintf(buf,"conflicting declarations for `%s'",str);
         yyerror(buf);    yyerror(buf);
 }  }
   
 extern FUNC parse_targetf;  extern FUNC parse_targetf;
   
 int searchpvar(char *str)  int searchpvar(char *str)
 {  {
         VS pvs;    VS pvs;
         MODULE mod;    MODULE mod;
         int c;    int c;
   
         if ( parse_targetf && parse_targetf->id != A_USR )    if ( parse_targetf && parse_targetf->id != A_USR )
                 c = -1;      c = -1;
         else if ( parse_targetf ) {    else if ( parse_targetf ) {
                 pvs = parse_targetf->f.usrf->pvs;      pvs = parse_targetf->f.usrf->pvs;
                 mod = parse_targetf->f.usrf->module;      mod = parse_targetf->f.usrf->module;
                 if ( (c = getpvar(pvs,str,1)) >= 0 ) {      if ( (c = getpvar(pvs,str,1)) >= 0 ) {
                         switch ( pvs->va[c].attr ) {        switch ( pvs->va[c].attr ) {
                                 case IS_GLOBAL:          case IS_GLOBAL:
                                         c = getpvar(GPVS,str,1);            c = getpvar(GPVS,str,1);
                                         c = PVGLOBAL((unsigned int)c);            c = PVGLOBAL((unsigned int)c);
                                         break;            break;
                                 case IS_MGLOBAL:          case IS_MGLOBAL:
                                         c = getpvar(mod->pvs,str,1);            c = getpvar(mod->pvs,str,1);
                                         c = PVMGLOBAL((unsigned int)c);            c = PVMGLOBAL((unsigned int)c);
                                         break;            break;
                                 default:          default:
                                         break;            break;
                         }        }
                 } else if ( mod && (c = getpvar(mod->pvs,str,1)) >= 0 )      } else if ( mod && (c = getpvar(mod->pvs,str,1)) >= 0 )
                         c = PVMGLOBAL((unsigned int)c);        c = PVMGLOBAL((unsigned int)c);
                 else if ( (c = getpvar(GPVS,str,1)) >= 0 )      else if ( (c = getpvar(GPVS,str,1)) >= 0 )
                         c = PVGLOBAL((unsigned int)c);        c = PVGLOBAL((unsigned int)c);
                 else      else
                         c = -1;        c = -1;
         }    }
         return c;    return c;
 }  }
   
 int getpvar(VS pvs,char *str,int searchonly)  int getpvar(VS pvs,char *str,int searchonly)
 {  {
         struct oPV *va;    struct oPV *va;
         PV v;    PV v;
         int i;    int i;
   
         for ( va = pvs->va, i = 0; i < (int)pvs->n; i++ )    for ( va = pvs->va, i = 0; i < (int)pvs->n; i++ )
                 if ( va[i].name && !strcmp(va[i].name,str) )      if ( va[i].name && !strcmp(va[i].name,str) )
                         return i;        return i;
         if ( searchonly )    if ( searchonly )
                 return -1;      return -1;
         if ( pvs->asize == pvs->n )    if ( pvs->asize == pvs->n )
                 reallocarray((char **)&pvs->va,(int *)&pvs->asize,(int *)&pvs->n,(int)sizeof(struct oPV));      asir_reallocarray((char **)&pvs->va,(int *)&pvs->asize,(int *)&pvs->n,(int)sizeof(struct oPV));
         v = &pvs->va[pvs->n];    v = &pvs->va[pvs->n];
         NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));    NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
         strcpy(NAME(v),str); v->priv = 0;    strcpy(NAME(v),str); v->priv = 0;
         v->attr= IS_LOCAL; v->type = -1; i = pvs->n; pvs->n++;    v->attr= IS_LOCAL; v->type = -1; i = pvs->n; pvs->n++;
         return i;    return i;
 }  }
   
 #if defined(VISUAL) || defined(__MINGW32__) || defined(__MINGW64__)  #if defined(VISUAL) || defined(__MINGW32__)
 #define PCLOSE _pclose  #define PCLOSE _pclose
 #else  #else
 #define PCLOSE pclose  #define PCLOSE pclose
Line 314  int getpvar(VS pvs,char *str,int searchonly)
Line 314  int getpvar(VS pvs,char *str,int searchonly)
   
 void closecurrentinput()  void closecurrentinput()
 {  {
         if ( asir_infile && !asir_infile->fp )    if ( asir_infile && !asir_infile->fp )
                 return;      return;
   
 #if defined(VISUAL) || defined(__MINGW32__) || defined(__MINGW64__)  #if defined(VISUAL) || defined(__MINGW32__)
         fclose(asir_infile->fp);    fclose(asir_infile->fp);
         unlink(asir_infile->tname);    unlink(asir_infile->tname);
 #else  #else
         if ( asir_infile->fp != stdin )    if ( asir_infile->fp != stdin )
                 PCLOSE(asir_infile->fp);      PCLOSE(asir_infile->fp);
 #endif  #endif
         asir_infile = NEXT(asir_infile);    asir_infile = NEXT(asir_infile);
 }  }
   
 void resetpvs()  void resetpvs()
 {  {
         if ( asir_infile && !NEXT(asir_infile) ) {    if ( asir_infile && !NEXT(asir_infile) ) {
                 PVSS = 0; CPVS = GPVS; MPVS = 0; CUR_MODULE = 0; nextbp = 0;      PVSS = 0; CPVS = GPVS; MPVS = 0; CUR_MODULE = 0; nextbp = 0;
                 gdef = mgdef = ldef = 0;      gdef = mgdef = ldef = 0;
                 if ( EPVS->va ) {      if ( EPVS->va ) {
                         bzero((char *)EPVS->va,(int)(EPVS->asize*sizeof(struct oPV))); EPVS->n = 0;        bzero((char *)EPVS->va,(int)(EPVS->asize*sizeof(struct oPV))); EPVS->n = 0;
                 }      }
         }    }
 }  }
   
 static NODE saved_PVSS;  static NODE saved_PVSS;
Line 344  static int saved_nextbp, saved_nextbplevel;
Line 344  static int saved_nextbp, saved_nextbplevel;
   
 void savepvs()  void savepvs()
 {  {
         saved_PVSS = PVSS;    saved_PVSS = PVSS;
         saved_CPVS = CPVS;    saved_CPVS = CPVS;
         saved_nextbp = nextbp;    saved_nextbp = nextbp;
         saved_nextbplevel = nextbplevel;    saved_nextbplevel = nextbplevel;
 }  }
   
 void restorepvs()  void restorepvs()
 {  {
         PVSS = saved_PVSS;    PVSS = saved_PVSS;
         CPVS = saved_CPVS;    CPVS = saved_CPVS;
         nextbp = saved_nextbp;    nextbp = saved_nextbp;
         nextbplevel = saved_nextbplevel;    nextbplevel = saved_nextbplevel;
 }  }
   
 void storeans(pointer p)  void storeans(pointer p)
 {  {
         if ( APVS->asize == APVS->n )    if ( APVS->asize == APVS->n )
                 reallocarray((char **)&APVS->va,(int *)&APVS->asize,(int *)&APVS->n,(int)sizeof(struct oPV));      asir_reallocarray((char **)&APVS->va,(int *)&APVS->asize,(int *)&APVS->n,(int)sizeof(struct oPV));
         APVS->va[APVS->n++].priv = p;    APVS->va[APVS->n++].priv = p;
 }  }
Legend:
Removed from v.1.20  
changed lines
  Added in v.1.24
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>