version 1.7, 2001/08/03 08:50:19 |
version 1.10, 2001/08/31 09:17:13 |
|
|
* OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY |
* OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY |
* 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/io/cio.c,v 1.6 2000/11/08 08:02:51 noro Exp $ |
* $OpenXM: OpenXM_contrib2/asir2000/io/cio.c,v 1.9 2001/08/06 04:25:43 noro Exp $ |
*/ |
*/ |
#include "ca.h" |
#include "ca.h" |
#include "parse.h" |
#include "parse.h" |
|
|
{ |
{ |
int r; |
int r; |
char errmsg[BUFSIZ]; |
char errmsg[BUFSIZ]; |
|
LIST l; |
|
|
if ( !obj ) { |
if ( !obj ) { |
r = CMO_NULL; write_int(s,&r); |
r = CMO_NULL; write_int(s,&r); |
|
|
r = ((USINT)obj)->body; write_int(s,&r); |
r = ((USINT)obj)->body; write_int(s,&r); |
break; |
break; |
case O_QUOTE: |
case O_QUOTE: |
write_cmo_tree(s,(FNODE)(((QUOTE)obj)->body)); |
fnodetotree(BDY((QUOTE)obj),&l); |
|
write_cmo_tree(s,l); |
break; |
break; |
default: |
default: |
sprintf(errmsg, "write_cmo : id=%d not implemented.",OID(obj)); |
sprintf(errmsg, "write_cmo : id=%d not implemented.",OID(obj)); |
|
|
|
|
/* XXX */ |
/* XXX */ |
|
|
write_cmo_tree(s,f) |
/* |
|
* BDY(l) = treenode |
|
* treenode = [property,(name,)arglist] |
|
* arglist = list of treenode |
|
*/ |
|
|
|
write_cmo_tree(s,l) |
FILE *s; |
FILE *s; |
FNODE f; |
LIST l; |
{ |
{ |
int r,i,n; |
NODE n; |
char opname[BUFSIZ]; |
int r; |
NODE args,t; |
STRING prop,name,key; |
FUNC fspec; |
|
struct oSTRING str,nullstr; |
|
|
|
/* null string */ |
/* (CMO_TREE (CMO_LIST,n,key1,attr1,...,keyn,attn),(CMO_LIST,m,arg1,...,argm)) */ |
nullstr.id = O_STR; |
n = BDY(l); |
nullstr.body = 0; |
prop = (STRING)BDY(n); n = NEXT(n); |
|
if ( !strcmp(BDY(prop),"internal") ) { |
/* name string */ |
write_cmo(s,(Obj)BDY(n)); |
str.id = O_STR; |
} else { |
str.body = opname; |
if ( strcmp(BDY(prop),"list") ) { |
|
|
switch ( f->id ) { |
|
case I_BOP: case I_COP: |
|
case I_AND: case I_OR: |
|
/* |
|
* (CMO_TREE (CMO_STRING,op),(CMO_STRING,0)(CMO_LIST,2,arg1,arg2)) |
|
*/ |
|
switch ( f->id ) { |
|
case I_BOP: |
|
strcpy(opname,((ARF)FA0(f))->name); break; |
|
case I_COP: |
|
switch( (cid)FA0(f) ) { |
|
case C_EQ: strcpy(opname,"=="); break; |
|
case C_NE: strcpy(opname,"!="); break; |
|
case C_GT: strcpy(opname,">"); break; |
|
case C_LT: strcpy(opname,"<"); break; |
|
case C_GE: strcpy(opname,">="); break; |
|
case C_LE: strcpy(opname,"<="); break; |
|
} |
|
break; |
|
case I_AND: |
|
strcpy(opname,"&&"); break; |
|
case I_OR: |
|
strcpy(opname,"||"); break; |
|
} |
|
r = CMO_TREE; write_int(s,&r); |
r = CMO_TREE; write_int(s,&r); |
write_cmo_string(s,&str); |
name = (STRING)BDY(n); |
write_cmo_string(s,&nullstr); |
n = NEXT(n); |
|
/* function name */ |
|
write_cmo(s,name); |
|
|
|
/* attribute list */ |
r = CMO_LIST; write_int(s,&r); |
r = CMO_LIST; write_int(s,&r); |
n = 2; write_int(s,&n); |
r = 2; write_int(s,&r); |
write_cmo_tree(s,(FNODE)FA1(f)); |
MKSTR(key,"asir"); |
write_cmo_tree(s,(FNODE)FA2(f)); |
write_cmo(s,key); |
break; |
write_cmo(s,prop); |
break; |
} |
case I_NOT: |
|
r = CMO_TREE; write_int(s,&r); |
/* argument list */ |
strcpy(opname,"!"); |
r = CMO_LIST; write_int(s,&r); |
write_cmo_string(s,&str);; |
/* len = number of arguments */ |
write_cmo_string(s,&nullstr); |
r = length(n); write_int(s,&r); |
r = CMO_LIST; write_int(s,&r); |
while ( n ) { |
n = 1; write_int(s,&n); |
write_cmo_tree(s,BDY(n)); |
write_cmo_tree(s,(FNODE)FA1(f)); |
n = NEXT(n); |
break; |
} |
case I_FUNC: |
|
fspec = (FUNC)FA0(f); |
|
strcpy(opname,fspec->name); |
|
write_cmo_string(s,&str); |
|
write_cmo_string(s,&nullstr); |
|
args = (NODE)FA0((FNODE)FA1(f)); |
|
r = CMO_LIST; write_int(s,&r); |
|
for ( n = 0, t = args; t; t = NEXT(t), n++ ); |
|
write_int(s,&n); |
|
for ( i = 0, t = args; i < n; t = NEXT(t), i++ ) |
|
write_cmo_tree(s,BDY(t)); |
|
break; |
|
case I_FORMULA: |
|
write_cmo(s,FA0(f)); |
|
break; |
|
default: |
|
break; /* XXX */ |
|
} |
} |
} |
} |
|
|
|
|
ERR e; |
ERR e; |
MATHCAP mc; |
MATHCAP mc; |
BYTEARRAY array; |
BYTEARRAY array; |
|
QUOTE quote; |
|
FNODE fn; |
|
LIST list; |
|
|
read_int(s,&id); |
read_int(s,&id); |
switch ( id ) { |
switch ( id ) { |
|
|
read_cmo(s,rp); |
read_cmo(s,rp); |
break; |
break; |
case CMO_TREE: |
case CMO_TREE: |
read_cmo_tree(s,rp); |
read_cmo_tree_as_list(s,&list); |
|
#if 0 |
|
treetofnode(list,&fn); |
|
MKQUOTE(quote,fn); |
|
*rp = (Obj)quote; |
|
#else |
|
*rp = list; |
|
#endif |
break; |
break; |
default: |
default: |
MKUSINT(t,id); |
MKUSINT(t,id); |
Line 829 static struct operator_tab optab[] = { |
|
Line 807 static struct operator_tab optab[] = { |
|
|
|
static int optab_len = sizeof(optab)/sizeof(struct operator_tab); |
static int optab_len = sizeof(optab)/sizeof(struct operator_tab); |
|
|
|
#if 0 |
|
/* old code */ |
read_cmo_tree(s,rp) |
read_cmo_tree(s,rp) |
FILE *s; |
FILE *s; |
QUOTE *rp; |
FNODE *rp; |
{ |
{ |
int r,i,n; |
int r,i,n; |
char *opname; |
char *opname; |
STRING name,cd; |
STRING name,cd; |
int op; |
int op; |
LIST alist; |
pointer *arg; |
NODE arg; |
|
QUOTE quote; |
QUOTE quote; |
FNODE fn; |
FNODE fn; |
|
NODE t,t1; |
fid id; |
fid id; |
|
Obj expr; |
|
FUNC func; |
|
|
read_cmo(s,&name); |
read_cmo(s,&name); |
read_cmo(s,&cd); /* XXX: currently not used */ |
read_cmo(s,&attr); |
for ( i = 0; i < optab_len; i++ ) |
for ( i = 0; i < optab_len; i++ ) |
if ( !strcmp(optab[i].name,BDY(name)) ) |
if ( !strcmp(optab[i].name,BDY(name)) ) |
break; |
break; |
if ( i == optab_len ) { |
if ( i == optab_len ) { |
/* may be a function name */ |
/* may be a function name */ |
|
n = read_cmo_tree_arg(s,&arg); |
|
for ( i = n-1, t = 0; i >= 0; i-- ) { |
|
MKNODE(t1,arg[i],t); t = t1; |
|
} |
|
searchf(sysf,BDY(name),&func); |
|
if ( !func ) |
|
searchf(ubinf,BDY(name),&func); |
|
if ( !func ) |
|
searchpf(BDY(name),&func); |
|
if ( !func ) |
|
searchf(usrf,BDY(name),&func); |
|
if ( !func ) |
|
appenduf(BDY(name),&func); |
|
*rp = mkfnode(2,I_FUNC,func,mkfnode(1,I_LIST,t)); |
} else { |
} else { |
opname = optab[i].name; |
opname = optab[i].name; |
id = optab[i].id; |
id = optab[i].id; |
switch ( id ) { |
switch ( id ) { |
case I_BOP: |
case I_BOP: |
op = opname[0]; |
read_cmo_tree_arg(s,&arg); |
read_cmo(s,&alist); |
*rp = mkfnode(3,I_BOP,optab[i].arf,arg[0],arg[1]); |
arg = BDY(alist); |
return; |
fn = mkfnode(3,I_BOP,optab[i].arf,ARG0(arg),ARG1(arg)); |
|
MKQUOTE(quote,fn); |
|
break; |
|
case I_COP: |
case I_COP: |
read_cmo(s,&alist); |
read_cmo_tree_arg(s,&arg); |
arg = BDY(alist); |
*rp = mkfnode(3,I_COP,optab[i].cid,arg[0],arg[0]); |
fn = mkfnode(3,I_COP,optab[i].cid,ARG0(arg),ARG1(arg)); |
return; |
MKQUOTE(quote,fn); |
|
break; |
|
case I_AND: |
case I_AND: |
read_cmo(s,&alist); |
read_cmo_tree_arg(s,&arg); |
arg = BDY(alist); |
*rp = mkfnode(2,I_AND,arg[0],arg[1]); |
fn = mkfnode(2,I_AND,ARG0(arg),ARG1(arg)); |
return; |
MKQUOTE(quote,fn); |
|
break; |
|
case I_OR: |
case I_OR: |
read_cmo(s,&alist); |
read_cmo_tree_arg(s,&arg); |
arg = BDY(alist); |
*rp = mkfnode(2,I_OR,arg[0],arg[1]); |
fn = mkfnode(2,I_OR,ARG0(arg),ARG1(arg)); |
return; |
MKQUOTE(quote,fn); |
|
break; |
|
case I_NOT: |
case I_NOT: |
read_cmo(s,&alist); |
read_cmo_tree_arg(s,&arg); |
arg = BDY(alist); |
*rp = mkfnode(1,I_OR,arg[0]); |
fn = mkfnode(1,I_OR,ARG0(arg)); |
return; |
MKQUOTE(quote,fn); |
|
break; |
|
} |
} |
*rp = quote; |
|
} |
} |
} |
} |
|
|
|
int read_cmo_tree_arg(s,argp) |
|
FILE *s; |
|
pointer **argp; |
|
{ |
|
int id,n,i; |
|
pointer *ap; |
|
Obj t; |
|
|
|
read_int(s,&id); /* id = CMO_LIST */ |
|
read_int(s,&n); /* n = the number of args */ |
|
*argp = ap = (pointer *) MALLOC(n*sizeof(pointer)); |
|
for ( i = 0; i < n; i++ ) { |
|
read_cmo(s,&t); |
|
if ( !t || (OID(t) != O_QUOTE) ) |
|
ap[i] = mkfnode(1,I_FORMULA,t); |
|
else |
|
ap[i] = BDY((QUOTE)t); |
|
} |
|
return n; |
|
} |
|
#else |
|
read_cmo_tree_as_list(s,rp) |
|
FILE *s; |
|
LIST *rp; |
|
{ |
|
STRING name; |
|
LIST attr,args; |
|
NODE t0,t1; |
|
|
|
read_cmo(s,&name); |
|
read_cmo(s,&attr); |
|
read_cmo(s,&args); |
|
MKNODE(t1,name,BDY(args)); |
|
MKNODE(t0,attr,t1); |
|
MKLIST(*rp,t0); |
|
} |
|
#endif |
|
|
localname_to_cmoname(a,b) |
localname_to_cmoname(a,b) |
char *a; |
char *a; |