[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.10 and 1.21

version 1.10, 2003/05/16 07:56:16 version 1.21, 2015/08/08 14:19:42
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.9 2003/05/14 09:18:38 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/parse/pvar.c,v 1.20 2015/08/06 10:01:53 fujimoto Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
   
 NODE PVSS;  NODE PVSS;
 extern char *CUR_FUNC;  extern char *CUR_FUNC;
   int gdef,mgdef,ldef;
   
   
 void mkpvs(char *fname)  void mkpvs(char *fname)
 {  {
         VS pvs;          VS pvs;
           char *fullname,*buf;
           FUNC f;
   
           if ( CUR_MODULE ) {
                   /* function must be declared in advance */
                   searchf(CUR_MODULE->usrf_list,fname,&f);
                   if ( !f ) {
                           buf = ALLOCA(strlen("undeclared function "+strlen(fname)+10));
                           sprintf(buf,"undeclared function `%s'",fname);
                           yyerror(buf);
                           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;
Line 64  void mkpvs(char *fname)
Line 78  void mkpvs(char *fname)
         CPVS = pvs;          CPVS = pvs;
   
         /* XXX */          /* XXX */
         CUR_FUNC = fname;          if ( CUR_MODULE ) {
                   fullname =
                           (char *)MALLOC_ATOMIC(strlen(CUR_MODULE->name)+strlen(fname)+1);
                   sprintf(fullname,"%s.%s",CUR_MODULE->name,fname);
                   CUR_FUNC = fullname;
           } else
                   CUR_FUNC = fname;
 }  }
   
 void pushpvs(FUNC f)  void pushpvs(FUNC f)
Line 104  void poppvs() {
Line 124  void poppvs() {
                 nextbplevel--;                  nextbplevel--;
 }  }
   
 int gdef,mgdef;  
   
 #define IS_LOCAL 0  #define IS_LOCAL 0
 #define IS_GLOBAL 1  #define IS_GLOBAL 1
 #define IS_MGLOBAL 2  #define IS_MGLOBAL 2
   #define IS_PATTERN 3
   
   
 unsigned int makepvar(char *str)  unsigned int makepvar(char *str)
 {  {
         int c,c1;          int c,c1,created;
           char *buf;
   
         /* EPVS : global list of the current file */          if ( str[0] == '_' ) {
         /* add to the local variable list */                  /* pattern variable */
         if ( gdef ) {                  c1 = getpvar(PPVS,str,0);
                 /* add to the external variable list */                  c = PVPATTERN((unsigned int)c1);
                   PPVS->va[c1].attr = IS_PATTERN;
           } else if ( gdef ) {
                   /* EPVS : global list of the current file */
                   /* add to the local 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 ) {                          if ( c1 >= 0 ) goto CONFLICTION;
                                 fprintf(stderr,"\"%s\", near line %d: conflicting declarations for `%s'",  
                                         asir_infile->name,asir_infile->ln,str);  
                                 error("");  
                         }  
                 }                  }
                 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 */
Line 138  unsigned int makepvar(char *str)
Line 159  unsigned int makepvar(char *str)
                 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 ) {                  if ( c1 >= 0 ) goto CONFLICTION;
                         fprintf(stderr,"\"%s\", near line %d: conflicting declarations for `%s'",  
                                 asir_infile->name,asir_infile->ln,str);  
                         error("");  
                 }  
                 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 ) {
                   /* if ldef > 0, then local variables are being declared */
                   c = getpvar(CPVS,str,0);
                   c1 = getpvar(EPVS,str,1);
                   if ( c1 >= 0 ) {
                           if ( CUR_MODULE )
                                   goto CONFLICTION;
                           else {
                                   fprintf(stderr,"Warning: \"%s\", near line %d: conflicting declarations for `%s'\n",
                                           asir_infile->name,asir_infile->ln,str);
                                   fprintf(stderr,"         `%s' is bound to the global variable\n",str);
                                   CPVS->va[c].attr = IS_GLOBAL;
                                   c1 = getpvar(GPVS,str,1); c = PVGLOBAL((unsigned int)c1);
   #if defined(__MINGW32__) || defined(__MINGW64__)
                                   fflush(stderr);
   #endif
                           }
                   } else {
                           if ( CUR_MODULE ) {
                                   c1 = getpvar(CUR_MODULE->pvs,str,1);
                           }
                           if ( c1 >= 0 ) goto CONFLICTION;
                           CPVS->va[c].attr = IS_LOCAL;
                   }
         } else if ( CPVS != GPVS ) {          } else if ( CPVS != GPVS ) {
                 /* inside function */                  /* inside function */
                 c = getpvar(CPVS,str,0);                  if ( CUR_MODULE ) {
                           /* search only */
                           c = getpvar(CPVS,str,1);
                           if ( c < 0 ) {
                                   c = getpvar(CPVS,str,0);
                                   created = 1;
                           } else
                                   created = 0;
                   } else {
                           /* may be created */
                           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);
Line 166  unsigned int makepvar(char *str)
Line 218  unsigned int makepvar(char *str)
                                 } 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) ) {
                                           /* not declared */
                                           /* if ldef == 0, at least one local variables has been
                                              declared */
                                           fprintf(stderr,
                                                   "Warning: \"%s\", near line %d: undeclared local variable `%s'\n",
                                                   asir_infile->name,asir_infile->ln,str);
   #if defined(__MINGW32__) || defined(__MINGW64__)
                                           fflush(stderr);
   #endif
                                 }                                  }
                                 break;                                  break;
                 }                  }
Line 178  unsigned int makepvar(char *str)
Line 240  unsigned int makepvar(char *str)
                         c = PVGLOBAL((unsigned int)c);                          c = PVGLOBAL((unsigned int)c);
                 } else {                  } else {
                         /* not declared as static or extern */                          /* not declared as static or extern */
                         fprintf(stderr,"\"%s\", near line %d: undeclared variable `%s'",                          buf = ALLOCA(strlen("undeclared variable"+strlen(str)+10));
                                 asir_infile->name,asir_infile->ln,str);                          sprintf(buf,"undeclared variable `%s'",str);
                         error("");                          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:
           buf = ALLOCA(strlen("conflicting declarations for "+strlen(str)+10));
           sprintf(buf,"conflicting declarations for `%s'",str);
           yyerror(buf);
 }  }
   
 extern FUNC parse_targetf;  extern FUNC parse_targetf;
Line 245  int getpvar(VS pvs,char *str,int searchonly)
Line 312  int getpvar(VS pvs,char *str,int searchonly)
         return i;          return i;
 }  }
   
 #if defined(VISUAL)  #if defined(VISUAL) || defined(__MINGW32__) || defined(__MINGW64__)
 #define PCLOSE _pclose  #define PCLOSE _pclose
 #else  #else
 #define PCLOSE pclose  #define PCLOSE pclose
Line 256  void closecurrentinput()
Line 323  void closecurrentinput()
         if ( asir_infile && !asir_infile->fp )          if ( asir_infile && !asir_infile->fp )
                 return;                  return;
   
 #if defined(VISUAL)  #if defined(VISUAL) || defined(__MINGW32__) || defined(__MINGW64__)
         fclose(asir_infile->fp);          fclose(asir_infile->fp);
         unlink(asir_infile->tname);          unlink(asir_infile->tname);
 #else  #else
         PCLOSE(asir_infile->fp);          if ( asir_infile->fp != stdin )
                   PCLOSE(asir_infile->fp);
 #endif  #endif
         asir_infile = NEXT(asir_infile);          asir_infile = NEXT(asir_infile);
         resetpvs();  
 }  }
   
 void resetpvs()  void resetpvs()
 {  {
         if ( !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;
                 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;
                 }                  }
Legend:
Removed from v.1.10  
changed lines
  Added in v.1.21
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>