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

Diff for /OpenXM_contrib2/asir2000/parse/struct.c between version 1.1.1.1 and 1.6

version 1.1.1.1, 1999/12/03 07:39:12 version 1.6, 2003/05/14 06:20:13
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/asir99/parse/struct.c,v 1.1.1.1 1999/11/10 08:12:34 noro Exp $ */  /*
    * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
    * All rights reserved.
    *
    * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
    * non-exclusive and royalty-free license to use, copy, modify and
    * redistribute, solely for non-commercial and non-profit purposes, the
    * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
    * conditions of this Agreement. For the avoidance of doubt, you acquire
    * only a limited right to use the SOFTWARE hereunder, and FLL or any
    * third party developer retains all rights, including but not limited to
    * copyrights, in and to the SOFTWARE.
    *
    * (1) FLL does not grant you a license in any way for commercial
    * purposes. You may use the SOFTWARE only for non-commercial and
    * non-profit purposes only, such as academic, research and internal
    * business use.
    * (2) The SOFTWARE is protected by the Copyright Law of Japan and
    * international copyright treaties. If you make copies of the SOFTWARE,
    * with or without modification, as permitted hereunder, you shall affix
    * to all such copies of the SOFTWARE the above copyright notice.
    * (3) An explicit reference to this SOFTWARE and its copyright owner
    * shall be made on your publication or presentation in any form of the
    * results obtained by use of the SOFTWARE.
    * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
    * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
    * for such modification or the source code of the modified part of the
    * SOFTWARE.
    *
    * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
    * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
    * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
    * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
    * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
    * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
    * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
    * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
    * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
    * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
    * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
    * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
    * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
    * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
    * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
    * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
    * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
    *
    * $OpenXM: OpenXM_contrib2/asir2000/parse/struct.c,v 1.5 2001/10/09 01:36:25 noro Exp $
   */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
 #include "comp.h"  #include "comp.h"
Line 6 
Line 54 
 struct oSS oLSS;  struct oSS oLSS;
 SS LSS = &oLSS;  SS LSS = &oLSS;
   
 void structdef(name,member)  int structdef(char *name,NODE member)
 char *name;  
 NODE member;  
 {  {
         int i,j,k,type;          int i,j;
         SDEF sdef,s;          SDEF sdef,s;
         NODE n,ms;          NODE n;
         char *mname,*sname;          char *mname;
   
           /* search the predefined structure */
         for ( s = LSS->sa, i = 0; i < LSS->n; i++ )          for ( s = LSS->sa, i = 0; i < LSS->n; i++ )
                 if ( !strcmp(s[i].name,name) ) {                  if ( !strcmp(s[i].name,name) ) {
                         fprintf(stderr,"redeclaration of %s\n",name); break;                          fprintf(stderr,"redeclaration of %s\n",name); break;
                 }                  }
         if ( !LSS->sa || ((i == LSS->n)&&(LSS->n==LSS->asize)) )          if ( !LSS->sa || ((i == LSS->n)&&(LSS->n==LSS->asize)) )
                 reallocarray((char **)&LSS->sa,(int *)&LSS->asize,(int *)&LSS->n,(int)sizeof(struct oSDEF));                  reallocarray((char **)&LSS->sa,(int *)&LSS->asize,(int *)&LSS->n,(int)sizeof(struct oSDEF));
           /* sdef = room for new structure definition */
         sdef = &LSS->sa[i];          sdef = &LSS->sa[i];
         if ( i == LSS->n )          if ( i == LSS->n )
                 LSS->n++;                  LSS->n++;
         for ( i = 0, n = member; n; n = NEXT(n), i++ );          /* set the name of structure */
         sdef->name = (char *)MALLOC(strlen(name)+1);          sdef->name = (char *)MALLOC(strlen(name)+1);
         bcopy(name,sdef->name,strlen(name)+1);          bcopy(name,sdef->name,strlen(name)+1);
         for ( j = 0, n = member; n; n = NEXT(n) )          /* count the total number of members */
                 for ( ms = NEXT((NODE)BDY(n)); ms; ms = NEXT(ms), j++ );          for ( j = 0, n = member; n; n = NEXT(n), j++ );
         sdef->n = j;          sdef->n = j;
         sdef->f = (struct oFIELD *)MALLOC(sdef->n*sizeof(struct oFIELD));          sdef->member = (char **)MALLOC(sdef->n*sizeof(char *));
         for ( j = 0, n = member; n; n = NEXT(n) ) {          /* set the names of members */
                 ms = (NODE)BDY(n);          for ( j = 0, n = member; n; n = NEXT(n), j++ ) {
                 if ( sname = (char *)BDY(ms) ) {                  mname = (char *)MALLOC(strlen((char *)BDY(n))+1);
                         for ( s = LSS->sa, k = 0; k < LSS->n; k++ )                  bcopy((char *)BDY(n),mname,strlen((char *)BDY(n))+1);
                                 if ( !strcmp(s[k].name,sname) )                  sdef->member[j] = mname;
                                         break;  
                         if ( k == LSS->n ) {  
                                 fprintf(stderr,"%s: undefined structure\n",sname); return;  
                         } else  
                                 type = k;  
                 } else  
                         type = -1;  
                 for ( ms = NEXT(ms); ms; ms = NEXT(ms), j++ ) {  
                         mname = (char *)MALLOC(strlen(BDY(ms))+1);  
                         bcopy(BDY(ms),mname,strlen(BDY(ms))+1);  
                         sdef->f[j].name = mname; sdef->f[j].type = type;  
                 }  
         }          }
           return i;
 }  }
   
 void setstruct(name,vars)  void newstruct(int type,COMP *rp)
 char *name;  
 NODE vars;  
 {  {
         SDEF s;  
         int i;  
         NODE n;  
   
         for ( s = LSS->sa, i = 0; i < LSS->n; i++ )  
                 if ( !strcmp(s[i].name,name) )  
                         break;  
         if ( i == LSS->n ) {  
                 fprintf(stderr,"%s: undefined structure\n",name); return;  
         }  
         s = &LSS->sa[i];  
         for ( n = vars; n; n = NEXT(n) )  
                 CPVS->va[(int)BDY(n)].type = i;  
 }  
   
 void newstruct(type,rp)  
 int type;  
 COMP *rp;  
 {  
         NEWCOMP(*rp,LSS->sa[type].n); (*rp)->type = type;          NEWCOMP(*rp,LSS->sa[type].n); (*rp)->type = type;
 }  }
   
 int structtoindex(name)  int structtoindex(char *name)
 char *name;  
 {  {
         SDEF s;          SDEF s;
         int i;          int i;
Line 92  char *name;
Line 107  char *name;
                 return i;                  return i;
 }  }
   
 int membertoindex(type,name)  int membertoindex(int type,char *name)
 int type;  
 char *name;  
 {  {
         SDEF s;          SDEF s;
         FIELD f;          char **member;
         int i;          int i;
   
         s = &LSS->sa[type];          s = &LSS->sa[type];
         for ( f = s->f, i = 0; i < s->n; i++ )          for ( member = s->member, i = 0; i < s->n; i++ )
                 if ( !strcmp(f[i].name,name) )                  if ( !strcmp(member[i],name) )
                         break;                          break;
         if ( i == s->n ) {          if ( i == s->n )
                 fprintf(stderr,"structure has no member named `%s'\n",name);  
                 return -1;                  return -1;
         } else          else
                 return i;                  return i;
 }  }
   
 int indextotype(type,index)  int getcompsize(int type)
 int type,index;  
 {  {
         return LSS->sa[type].f[index].type;  
 }  
   
 int gettype(index)  
 unsigned int index;  
 {  
         if ( MSB & index )  
                 return (int)GPVS->va[index&~MSB].type;  
         else  
                 return (int)CPVS->va[index].type;  
 }  
   
 int getcompsize(type)  
 int type;  
 {  
         return LSS->sa[type].n;          return LSS->sa[type].n;
 }  }
   
 void getmember(expr,memp)  Obj memberofstruct(COMP a,char *name)
 FNODE expr;  
 Obj *memp;  
 {  {
         int i;          int type,ind;
         FNODE root;          char buf[BUFSIZ];
         COMP t;  
         PV v0;  
         NODE2 mchain;  
   
         root = (FNODE)FA1(expr); mchain = (NODE2)FA2(expr);          if ( !a || OID(a) != O_COMP )
         if ( ID(root) == I_PVAR ) {                  error("object is not a structure");
                 i = (int)FA0(root);          type = a->type;
                 v0 = i>=0?&CPVS->va[(unsigned int)i]:&GPVS->va[((unsigned int)i)&~MSB];          ind = membertoindex(type,name);
                 t = (COMP)v0->priv;          if ( ind < 0 ) {
         } else                  sprintf(buf,"structure has no member named `%s'",name);
                 t = (COMP)eval(root);                  error(buf);
         for ( ; mchain; mchain = NEXT(mchain) )  
                 t = (COMP)(t->member[(int)BDY1(mchain)]);  
         *memp = (Obj)t;  
 }  
   
 void getmemberp(expr,addrp)  
 FNODE expr;  
 Obj **addrp;  
 {  
         int i;  
         FNODE root;  
         COMP t;  
         PV v0;  
         COMP *addr;  
         NODE2 mchain;  
   
         root = (FNODE)FA1(expr); mchain = (NODE2)FA2(expr);  
         if ( ID(root) == I_PVAR ) {  
                 i = (int)FA0(root);  
                 v0 = i>=0?&CPVS->va[(unsigned int)i]:&GPVS->va[((unsigned int)i)&~MSB];  
                 addr = (COMP *)&v0->priv;  
         } else {  
                 t = (COMP)eval(root);  
                 addr = (COMP *)&t;  
         }          }
         for ( ; mchain; mchain = NEXT(mchain) )          return (Obj)a->member[ind];
                 addr = (COMP *)&((*addr)->member[(int)BDY1(mchain)]);  
         *addrp = (Obj *)addr;  
 }  }
   
 void getarrayp(a,ind,addrp)  void assign_to_member(COMP a,char *name,Obj obj)
 Obj a;  
 NODE ind;  
 Obj **addrp;  
 {  {
         Obj len,row,col;  
         Obj *addr;  
   
         switch ( OID(a) ) {  
                 case O_VECT:  
                         len = (Obj)BDY(ind);  
                         if ( !rangecheck(len,((VECT)a)->len) )  
                                 error("getarrayp : Out of range");  
                         else  
                                 addr = (Obj *)&(BDY((VECT)a)[QTOS((Q)len)]);  
                         break;  
                 case O_MAT:  
                         row = (Obj)BDY(ind); col = (Obj)BDY(NEXT(ind));  
                         if ( !rangecheck(row,((MAT)a)->row)  
                                 || !rangecheck(col,((MAT)a)->col) )  
                                 error("getarrayp : Out of range");  
                         else  
                                 addr = (Obj *)&(BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)]);  
                         break;  
                 default:  
                                 addr = 0;  
                         break;  
         }  
         *addrp = addr;  
 }  
   
 void memberofstruct(pexpr,name,exprp)  
 FNODE pexpr;  
 char *name;  
 FNODE *exprp;  
 {  
         NODE2 n,*np;  
         int type,ind;          int type,ind;
           char buf[BUFSIZ];
   
         if ( pexpr->id != I_CAST ) {          if ( !a || OID(a) != O_COMP )
                 if ( pexpr->id == I_PVAR )                  error("object is not a structure");
                         pexpr = (FNODE)mkfnode(3,I_CAST,gettype((unsigned int)pexpr->arg[0]),pexpr,0);          type = a->type;
                 else  
                         error("memberofstruct : ???");  
         }  
         if ( !pexpr->arg[2] ) {  
                 np = (NODE2 *)&(pexpr->arg[2]); type = (int)pexpr->arg[0];  
         } else {  
                 for ( n = (NODE2)pexpr->arg[2]; NEXT(n); n = NEXT(n) );  
                 np = &NEXT(n); type = (int)BDY2(n);  
         }  
         ind = membertoindex(type,name);          ind = membertoindex(type,name);
         MKNODE2(*np,ind,indextotype(type,ind),0);          if ( ind < 0 ) {
         *exprp = pexpr;                  sprintf(buf,"structure has no member named `%s'",name);
                   error(buf);
           }
           a->member[ind] = obj;
 }  }
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.6
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>