version 1.1.1.1, 1999/12/03 07:39:12 |
version 1.4, 2000/09/21 09:19:27 |
|
|
/* $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.3 2000/08/22 05:04:28 noro Exp $ |
|
*/ |
#include "ca.h" |
#include "ca.h" |
#include "parse.h" |
#include "parse.h" |
#include "comp.h" |
#include "comp.h" |
|
|
struct oSS oLSS; |
struct oSS oLSS; |
SS LSS = &oLSS; |
SS LSS = &oLSS; |
|
|
void structdef(name,member) |
int structdef(name,member) |
char *name; |
char *name; |
NODE member; |
NODE member; |
{ |
{ |
|
|
NODE n,ms; |
NODE n,ms; |
char *mname,*sname; |
char *mname,*sname; |
|
|
|
/* 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) |
|
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) |
void newstruct(type,rp) |
int type; |
int type; |
COMP *rp; |
COMP *rp; |
|
|
char *name; |
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 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 getcompsize(type) |
int type; |
int type; |
{ |
{ |
return LSS->sa[type].n; |
return LSS->sa[type].n; |
} |
} |
|
|
|
#if 0 |
void getmember(expr,memp) |
void getmember(expr,memp) |
FNODE expr; |
FNODE expr; |
Obj *memp; |
Obj *memp; |
|
|
} |
} |
*addrp = addr; |
*addrp = addr; |
} |
} |
|
#endif |
|
|
void memberofstruct(pexpr,name,exprp) |
Obj memberofstruct(a,name) |
FNODE pexpr; |
COMP a; |
char *name; |
char *name; |
FNODE *exprp; |
|
{ |
{ |
NODE2 n,*np; |
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 |
ind = membertoindex(type,name); |
error("memberofstruct : ???"); |
if ( ind < 0 ) { |
} |
sprintf(buf,"structure has no member named `%s'",name); |
if ( !pexpr->arg[2] ) { |
error(buf); |
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); |
|
} |
} |
|
return (Obj)a->member[ind]; |
|
} |
|
|
|
void assign_to_member(a,name,obj) |
|
COMP a; |
|
char *name; |
|
Obj obj; |
|
{ |
|
NODE2 n,*np; |
|
int type,ind; |
|
char buf[BUFSIZ]; |
|
|
|
if ( !a || OID(a) != O_COMP ) |
|
error("object is not a structure"); |
|
type = a->type; |
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; |
} |
} |