Return to strobj.c CVS log | Up to [local] / OpenXM_contrib2 / asir2000 / builtin |
version 1.17, 2004/03/04 05:16:42 | version 1.32, 2004/03/09 07:18:26 | ||
---|---|---|---|
|
|
||
* 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/builtin/strobj.c,v 1.16 2004/03/04 03:31:28 noro Exp $ | * $OpenXM: OpenXM_contrib2/asir2000/builtin/strobj.c,v 1.31 2004/03/09 06:12:47 noro Exp $ | ||
*/ | */ | ||
#include "ca.h" | #include "ca.h" | ||
#include "parse.h" | #include "parse.h" | ||
|
|
||
#endif | #endif | ||
#include <string.h> | #include <string.h> | ||
struct TeXSymbol { | |||
char *text; | |||
char *symbol; | |||
}; | |||
extern char *parse_strp; | extern char *parse_strp; | ||
void Prtostr(), Pstrtov(), Peval_str(); | void Prtostr(), Pstrtov(), Peval_str(); | ||
|
|
||
void Pstring_to_tb(); | void Pstring_to_tb(); | ||
void Pquotetotex_tb(); | void Pquotetotex_tb(); | ||
void Pquotetotex(); | void Pquotetotex(); | ||
void Pquotetotex_env(); | |||
void fnodetotex_tb(FNODE f,TB tb); | void fnodetotex_tb(FNODE f,TB tb); | ||
char *symbol_name(char *name); | char *symbol_name(char *name); | ||
char *conv_rule(char *name); | |||
char *conv_subscript(char *name); | |||
char *call_convfunc(char *name); | |||
void tb_to_string(TB tb,STRING *rp); | void tb_to_string(TB tb,STRING *rp); | ||
void fnodenodetotex_tb(NODE n,TB tb); | void fnodenodetotex_tb(NODE n,TB tb); | ||
void fargstotex_tb(char *opname,FNODE f,TB tb); | void fargstotex_tb(char *opname,FNODE f,TB tb); | ||
|
|
||
{"string_to_tb",Pstring_to_tb,1}, | {"string_to_tb",Pstring_to_tb,1}, | ||
{"quotetotex_tb",Pquotetotex_tb,2}, | {"quotetotex_tb",Pquotetotex_tb,2}, | ||
{"quotetotex",Pquotetotex,1}, | {"quotetotex",Pquotetotex,1}, | ||
{"quotetotex_env",Pquotetotex_env,-99999999}, | |||
{0,0,0}, | {0,0,0}, | ||
}; | }; | ||
|
|
||
tb->next++; | tb->next++; | ||
} | } | ||
int register_symbol_table(Obj arg); | |||
int register_conv_rule(Obj arg); | |||
int register_dp_vars(Obj arg); | |||
int register_dp_vars_prefix(Obj arg); | |||
int register_dp_vars_hweyl(Obj arg); | |||
int register_show_lt(Obj arg); | |||
static struct TeXSymbol *user_texsymbol; | |||
static char **dp_vars; | |||
static int dp_vars_len; | |||
static char *dp_vars_prefix; | |||
static int show_lt; | |||
static FUNC convfunc; | |||
static int is_lt; | |||
static int conv_flag; | |||
static int dp_vars_hweyl; | |||
#define CONV_SUBSCRIPT (1U<<0) | |||
#define CONV_DMODE (1U<<1) | |||
#define CONV_USERFUNC (1U<<31) | |||
static struct { | |||
char *name; | |||
Obj value; | |||
int (*reg)(); | |||
} qtot_env[] = { | |||
{"symbol_table",0,register_symbol_table}, | |||
{"conv_rule",0,register_conv_rule}, | |||
{"dp_vars",0,register_dp_vars}, | |||
{"dp_vars_prefix",0,register_dp_vars_prefix}, | |||
{"dp_vars_hweyl",0,register_dp_vars_hweyl}, | |||
{"show_lt",0,register_show_lt}, | |||
{0,0,0}, | |||
}; | |||
#define PARTIAL "\\partial" | |||
char *conv_rule(char *name) | |||
{ | |||
char *body,*r; | |||
if ( conv_flag & CONV_DMODE ) { | |||
if ( *name == 'd' ) { | |||
if ( conv_flag & CONV_SUBSCRIPT ) | |||
body = conv_subscript(name+1); | |||
else | |||
body = name+1; | |||
r = MALLOC_ATOMIC((strlen(PARTIAL)+strlen(body)+5)*sizeof(char)); | |||
sprintf(r,"{%s}_{%s}",PARTIAL,body); | |||
return r; | |||
} else { | |||
if ( conv_flag & CONV_SUBSCRIPT ) | |||
body = conv_subscript(name); | |||
else | |||
body = name; | |||
} | |||
} else if ( conv_flag & CONV_SUBSCRIPT ) | |||
return conv_subscript(name); | |||
else if ( conv_flag & CONV_USERFUNC && convfunc ) | |||
return call_convfunc(name); | |||
else | |||
return name; | |||
} | |||
char *conv_subscript(char *name) | |||
{ | |||
int i,j,k,len,clen,slen,start,level; | |||
char *buf,*head,*r,*h,*brace; | |||
char **subs; | |||
len = strlen(name); | |||
subs = (char **)ALLOCA(len*sizeof(char* )); | |||
for ( i = 0, j = 0, start = i; ; j++ ) { | |||
while ( (i < len) && (name[i] == '_' || name[i] == ',') ) i++; | |||
start = i; | |||
if ( i == len ) break; | |||
if ( name[i] == '{' ) { | |||
for ( level = 1, i++; i < len && level; i++ ) { | |||
if ( name[i] == '{' ) level++; | |||
else if ( name[i] == '}' ) level--; | |||
} | |||
slen = i-start; | |||
brace = (char *)ALLOCA((slen+1)*sizeof(char)); | |||
strncpy(brace,name+start+1,slen-2); | |||
brace[slen-2] = 0; | |||
buf = conv_subscript(brace); | |||
subs[j] = (char *)ALLOCA((strlen(buf)+3)*sizeof(char)); | |||
sprintf(subs[j],"{%s}",buf); | |||
} else { | |||
if ( isdigit(name[i]) ) | |||
while ( i < len && isdigit(name[i]) ) i++; | |||
else | |||
while ( i < len && (isalpha(name[i]) || name[i] == '\\') ) i++; | |||
slen = i-start; | |||
buf = (char *)ALLOCA((slen+1)*sizeof(char)); | |||
strncpy(buf,name+start,slen); buf[slen] = 0; | |||
subs[j] = symbol_name(buf); | |||
} | |||
} | |||
for ( k = 0, clen = 0; k < j; k++ ) clen += strlen(subs[k]); | |||
/* {subs(0)}_{{subs(1)},...,{subs(j-1)}} => {}:j+1 _:1 ,:j-2 */ | |||
h = r = MALLOC_ATOMIC((clen+(j+1)*2+1+(j-2)+1)*sizeof(char)); | |||
if ( j == 1 ) | |||
sprintf(h,"{%s}",subs[0]); | |||
else { | |||
sprintf(h,"{%s}_{{%s}",subs[0],subs[1]); | |||
h += strlen(h); | |||
for ( k = 2; k < j; k++ ) { | |||
sprintf(h,",{%s}",subs[k]); | |||
h += strlen(h); | |||
} | |||
strcpy(h,"}"); | |||
} | |||
return r; | |||
} | |||
char *call_convfunc(char *name) | |||
{ | |||
STRING str,r; | |||
NODE arg; | |||
MKSTR(str,name); | |||
arg = mknode(1,str); | |||
r = (STRING)bevalf(convfunc,arg); | |||
if ( !r || OID(r) != O_STR ) | |||
error("call_convfunc : invalid result"); | |||
return BDY(r); | |||
} | |||
int register_symbol_table(Obj arg) | |||
{ | |||
NODE n,t; | |||
Obj b; | |||
STRING a0,a1; | |||
struct TeXSymbol *uts; | |||
int i,len; | |||
/* check */ | |||
if ( !arg ) { | |||
user_texsymbol = 0; | |||
return 1; | |||
} | |||
if ( OID(arg) != O_LIST ) return 0; | |||
n = BDY((LIST)arg); | |||
len = length(n); | |||
uts = (struct TeXSymbol *)MALLOC((len+1)*sizeof(struct TeXSymbol)); | |||
for ( i = 0; n; n = NEXT(n), i++ ) { | |||
b = (Obj)BDY(n); | |||
if ( !b || OID(b) != O_LIST ) return 0; | |||
t = BDY((LIST)b); | |||
if ( !t || !NEXT(t) ) return 0; | |||
a0 = (STRING)BDY(t); | |||
a1 = (STRING)BDY(NEXT(t)); | |||
if ( !a0 ) return 0; | |||
if ( OID(a0) == O_STR ) | |||
uts[i].text = BDY(a0); | |||
else if ( OID(a0) == O_P ) | |||
uts[i].text = NAME(VR((P)a0)); | |||
else | |||
return 0; | |||
if ( !a1 ) return 0; | |||
if ( OID(a1) == O_STR ) | |||
uts[i].symbol = BDY(a1); | |||
else if ( OID(a1) == O_P ) | |||
uts[i].symbol = NAME(VR((P)a1)); | |||
else | |||
return 0; | |||
} | |||
uts[i].text = 0; | |||
uts[i].symbol = 0; | |||
user_texsymbol = uts; | |||
return 1; | |||
} | |||
int register_dp_vars_hweyl(Obj arg) | |||
{ | |||
if ( INT(arg) ) { | |||
dp_vars_hweyl = QTOS((Q)arg); | |||
return 1; | |||
} else return 0; | |||
} | |||
int register_show_lt(Obj arg) | |||
{ | |||
if ( INT(arg) ) { | |||
show_lt = QTOS((Q)arg); | |||
return 1; | |||
} else return 0; | |||
} | |||
int register_conv_rule(Obj arg) | |||
{ | |||
if ( INT(arg) ) { | |||
conv_flag = QTOS((Q)arg); | |||
convfunc = 0; | |||
return 1; | |||
} else if ( OID(arg) == O_P && | |||
(int)(VR((P)arg))->attr == V_SR ) { | |||
conv_flag = CONV_USERFUNC; | |||
convfunc = (FUNC)(VR((P)arg)->priv); | |||
/* f must be a function which takes single argument */ | |||
return 1; | |||
} else return 0; | |||
} | |||
int register_dp_vars(Obj arg) | |||
{ | |||
int l,i; | |||
char **r; | |||
NODE n; | |||
STRING a; | |||
if ( !arg ) { | |||
dp_vars = 0; | |||
dp_vars_len = 0; | |||
return 1; | |||
} else if ( OID(arg) != O_LIST ) | |||
return 0; | |||
else { | |||
n = BDY((LIST)arg); | |||
l = length(n); | |||
r = (char **)MALLOC_ATOMIC(l*sizeof(char *)); | |||
for ( i = 0; i < l; i++, n = NEXT(n) ) { | |||
a = (STRING)BDY(n); | |||
if ( !a ) return 0; | |||
if ( OID(a) == O_STR ) | |||
r[i] = BDY(a); | |||
else if ( OID(a) == O_P ) | |||
r[i] = NAME(VR((P)a)); | |||
else | |||
return 0; | |||
} | |||
dp_vars = r; | |||
dp_vars_len = l; | |||
return 1; | |||
} | |||
} | |||
int register_dp_vars_prefix(Obj arg) | |||
{ | |||
if ( !arg ) { | |||
dp_vars_prefix = 0; | |||
return 1; | |||
} else if ( OID(arg) == O_STR ) { | |||
dp_vars_prefix = BDY((STRING)arg); | |||
return 1; | |||
} else if ( OID(arg) == O_P ) { | |||
dp_vars_prefix = NAME(VR((P)arg)); | |||
return 1; | |||
} else return 0; | |||
} | |||
void Pquotetotex_env(NODE arg,Obj *rp) | |||
{ | |||
int ac,i; | |||
char *name; | |||
NODE n,n0; | |||
STRING s; | |||
LIST l; | |||
ac = argc(arg); | |||
if ( !ac ) { | |||
n0 = 0; | |||
for ( i = 0; qtot_env[i].name; i++ ) { | |||
NEXTNODE(n0,n); MKSTR(s,qtot_env[i].name); BDY(n) = (pointer)s; | |||
NEXTNODE(n0,n); BDY(n) = (Q)qtot_env[i].value; | |||
} | |||
NEXT(n) = 0; | |||
MKLIST(l,n0); | |||
*rp = (Obj)l; | |||
} else if ( ac == 1 || ac == 2 ) { | |||
asir_assert(ARG0(arg),O_STR,"quotetotex_env"); | |||
name = BDY((STRING)ARG0(arg)); | |||
for ( i = 0; qtot_env[i].name; i++ ) | |||
if ( !strcmp(qtot_env[i].name,name) ) { | |||
if ( ac == 2 ) { | |||
if ( (qtot_env[i].reg)((Obj)ARG1(arg)) ) | |||
qtot_env[i].value = (Obj)ARG1(arg); | |||
else | |||
error("quotetotex_env : invalid argument"); | |||
} | |||
*rp = qtot_env[i].value; | |||
return; | |||
} | |||
*rp = 0; | |||
} else | |||
*rp = 0; | |||
} | |||
void Pwrite_to_tb(NODE arg,Q *rp) | void Pwrite_to_tb(NODE arg,Q *rp) | ||
{ | { | ||
int i; | int i; | ||
|
|
||
TB tb; | TB tb; | ||
NEWTB(tb); | NEWTB(tb); | ||
/* XXX for DP */ | |||
is_lt = 1; | |||
fnodetotex_tb(BDY((QUOTE)ARG0(arg)),tb); | fnodetotex_tb(BDY((QUOTE)ARG0(arg)),tb); | ||
tb_to_string(tb,rp); | tb_to_string(tb,rp); | ||
} | } | ||
|
|
||
TB tb; | TB tb; | ||
asir_assert(ARG1(arg),O_TB,"quotetotex_tb"); | asir_assert(ARG1(arg),O_TB,"quotetotex_tb"); | ||
/* XXX for DP */ | |||
is_lt = 1; | |||
fnodetotex_tb(BDY((QUOTE)ARG0(arg)),ARG1(arg)); | fnodetotex_tb(BDY((QUOTE)ARG0(arg)),ARG1(arg)); | ||
*rp = 0; | *rp = 0; | ||
} | } | ||
|
|
||
#endif | #endif | ||
} | } | ||
struct TeXSymbol { | |||
char *text; | |||
char *symbol; | |||
}; | |||
static struct TeXSymbol texsymbol[] = { | static struct TeXSymbol texsymbol[] = { | ||
{"sin","\\sin"}, | {"sin","\\sin"}, | ||
{"cos","\\cos"}, | {"cos","\\cos"}, | ||
|
|
||
{"c_i","\\sqrt{-1}"}, | {"c_i","\\sqrt{-1}"}, | ||
/* Temporary */ | /* Temporary */ | ||
{"dx","\\partial"}, | |||
{0,0} | {0,0} | ||
}; | }; | ||
|
|
||
{ | { | ||
int i; | int i; | ||
if ( user_texsymbol ) | |||
for ( i = 0; user_texsymbol[i].text; i++ ) | |||
if ( !strcmp(user_texsymbol[i].text,name) ) | |||
return user_texsymbol[i].symbol; | |||
for ( i = 0; texsymbol[i].text; i++ ) | for ( i = 0; texsymbol[i].text; i++ ) | ||
if ( !strcmp(texsymbol[i].text,name) ) | if ( !strcmp(texsymbol[i].text,name) ) | ||
return texsymbol[i].symbol; | return texsymbol[i].symbol; | ||
|
|
||
{ | { | ||
NODE n,t,t0; | NODE n,t,t0; | ||
char vname[BUFSIZ]; | char vname[BUFSIZ]; | ||
char *opname; | char *opname,*vname_conv; | ||
Obj obj; | Obj obj; | ||
int i,len,allzero; | int i,len,allzero,elen,elen2; | ||
FNODE fi,f2; | FNODE fi,f2; | ||
write_tb(" ",tb); | write_tb(" ",tb); | ||
|
|
||
} | } | ||
switch ( f->id ) { | switch ( f->id ) { | ||
/* unary operators */ | /* unary operators */ | ||
case I_NOT: case I_PAREN: case I_MINUS: | case I_NOT: | ||
switch ( f->id ) { | write_tb("\\neg (",tb); | ||
case I_NOT: | fnodetotex_tb((FNODE)FA0(f),tb); | ||
write_tb("\\neg (",tb); | write_tb(")",tb); | ||
fnodetotex_tb((FNODE)FA0(f),tb); | |||
write_tb(")",tb); | |||
break; | |||
case I_PAREN: | |||
write_tb("(",tb); | |||
fnodetotex_tb((FNODE)FA0(f),tb); | |||
write_tb(")",tb); | |||
break; | |||
case I_MINUS: | |||
write_tb("-",tb); | |||
fnodetotex_tb((FNODE)FA0(f),tb); | |||
break; | |||
} | |||
break; | break; | ||
case I_PAREN: | |||
write_tb("(",tb); | |||
fnodetotex_tb((FNODE)FA0(f),tb); | |||
write_tb(")",tb); | |||
break; | |||
case I_MINUS: | |||
write_tb("-",tb); | |||
fnodetotex_tb((FNODE)FA0(f),tb); | |||
break; | |||
/* binary operators */ | /* binary operators */ | ||
case I_BOP: case I_COP: case I_LOP: case I_AND: case I_OR: | /* arg list */ | ||
/* arg list */ | /* I_AND, I_OR => FA0(f), FA1(f) */ | ||
/* I_AND, I_OR => FA0(f), FA1(f) */ | /* otherwise => FA1(f), FA2(f) */ | ||
/* otherwise => FA1(f), FA2(f) */ | case I_BOP: | ||
opname = ((ARF)FA0(f))->name; | |||
/* op */ | if ( !strcmp(opname,"+") ) { | ||
switch ( f->id ) { | fnodetotex_tb((FNODE)FA1(f),tb); | ||
case I_BOP: | write_tb(opname,tb); | ||
opname = ((ARF)FA0(f))->name; | fnodetotex_tb((FNODE)FA2(f),tb); | ||
if ( !strcmp(opname,"+") ) { | } else if ( !strcmp(opname,"-") ) { | ||
fnodetotex_tb((FNODE)FA1(f),tb); | if ( FA1(f) ) fnodetotex_tb((FNODE)FA1(f),tb); | ||
write_tb(opname,tb); | write_tb(opname,tb); | ||
fnodetotex_tb((FNODE)FA2(f),tb); | fnodetotex_tb((FNODE)FA2(f),tb); | ||
} else if ( !strcmp(opname,"-") ) { | } else if ( !strcmp(opname,"*") ) { | ||
if ( FA1(f) ) fnodetotex_tb((FNODE)FA1(f),tb); | fnodetotex_tb((FNODE)FA1(f),tb); | ||
write_tb(opname,tb); | write_tb(" ",tb); | ||
fnodetotex_tb((FNODE)FA2(f),tb); | /* XXX special care for DP */ | ||
} else if ( !strcmp(opname,"*") ) { | f2 = (FNODE)FA2(f); | ||
fnodetotex_tb((FNODE)FA1(f),tb); | if ( f2->id == I_EV ) { | ||
write_tb(" ",tb); | n = (NODE)FA0(f2); | ||
/* XXX special care for DP */ | for ( i = 0; n; n = NEXT(n), i++ ) { | ||
f2 = (FNODE)FA2(f); | fi = (FNODE)BDY(n); | ||
if ( f2->id == I_EV ) { | if ( fi->id != I_FORMULA || FA0(fi) ) | ||
n = (NODE)FA0(f2); | |||
for ( i = 0; n; n = NEXT(n), i++ ) { | |||
fi = (FNODE)BDY(n); | |||
if ( fi->id != I_FORMULA || FA0(fi) ) | |||
break; | |||
} | |||
if ( n ) | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
} else | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
} else if ( !strcmp(opname,"/") ) { | |||
write_tb("\\frac{",tb); | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb("} {",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
write_tb("}",tb); | |||
} else if ( !strcmp(opname,"^") ) { | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb("^{",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
write_tb("} ",tb); | |||
} else if ( !strcmp(opname,"%") ) { | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" {\\rm mod}\\, ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
} else | |||
error("invalid binary operator"); | |||
case I_COP: | |||
switch( (cid)FA0(f) ) { | |||
case C_EQ: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" = ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | break; | ||
case C_NE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\neq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case C_GT: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\gt ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case C_LT: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\lt ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case C_GE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\geq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case C_LE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\leq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
} | } | ||
break; | if ( n ) | ||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
} else | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
} else if ( !strcmp(opname,"/") ) { | |||
write_tb("\\frac{",tb); | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb("} {",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
write_tb("}",tb); | |||
} else if ( !strcmp(opname,"^") ) { | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb("^{",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
write_tb("} ",tb); | |||
} else if ( !strcmp(opname,"%") ) { | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" {\\rm mod}\\, ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
} else | |||
error("invalid binary operator"); | |||
break; | |||
case I_LOP: | case I_COP: | ||
switch( (lid)FA0(f) ) { | switch( (cid)FA0(f) ) { | ||
case L_EQ: | case C_EQ: | ||
fnodetotex_tb((FNODE)FA1(f),tb); | fnodetotex_tb((FNODE)FA1(f),tb); | ||
write_tb(" = ",tb); | write_tb(" = ",tb); | ||
fnodetotex_tb((FNODE)FA2(f),tb); | fnodetotex_tb((FNODE)FA2(f),tb); | ||
break; | |||
case L_NE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\neq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_GT: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\gt ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_LT: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\lt ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_GE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\geq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_LE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\leq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_AND: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" {\\rm \\ and\\ } ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_OR: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" {\\rm \\ or\\ } ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_NOT: | |||
/* XXX : L_NOT is a unary operator */ | |||
write_tb("\\neg (",tb); | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(")",tb); | |||
return; | |||
} | |||
break; | break; | ||
case C_NE: | |||
case I_AND: | |||
fnodetotex_tb((FNODE)FA0(f),tb); | |||
write_tb(" {\\rm \\ and\\ } ",tb); | |||
fnodetotex_tb((FNODE)FA1(f),tb); | fnodetotex_tb((FNODE)FA1(f),tb); | ||
write_tb(" \\neq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | break; | ||
case C_GT: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\gt ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case C_LT: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\lt ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case C_GE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\geq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case C_LE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\leq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
} | |||
break; | |||
case I_OR: | case I_LOP: | ||
fnodetotex_tb((FNODE)FA0(f),tb); | switch( (lid)FA0(f) ) { | ||
write_tb(" {\\rm \\ or\\ } ",tb); | case L_EQ: | ||
fnodetotex_tb((FNODE)FA1(f),tb); | fnodetotex_tb((FNODE)FA1(f),tb); | ||
write_tb(" = ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | break; | ||
case L_NE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\neq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_GT: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\gt ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_LT: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\lt ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_GE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\geq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_LE: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" \\leq ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_AND: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" {\\rm \\ and\\ } ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_OR: | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(" {\\rm \\ or\\ } ",tb); | |||
fnodetotex_tb((FNODE)FA2(f),tb); | |||
break; | |||
case L_NOT: | |||
/* XXX : L_NOT is a unary operator */ | |||
write_tb("\\neg (",tb); | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
write_tb(")",tb); | |||
return; | |||
} | } | ||
break; | break; | ||
case I_AND: | |||
fnodetotex_tb((FNODE)FA0(f),tb); | |||
write_tb(" {\\rm \\ and\\ } ",tb); | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
break; | |||
case I_OR: | |||
fnodetotex_tb((FNODE)FA0(f),tb); | |||
write_tb(" {\\rm \\ or\\ } ",tb); | |||
fnodetotex_tb((FNODE)FA1(f),tb); | |||
break; | |||
/* ternary operators */ | /* ternary operators */ | ||
case I_CE: | case I_CE: | ||
error("fnodetotex_tb : not implemented yet"); | error("fnodetotex_tb : not implemented yet"); | ||
|
|
||
break; | break; | ||
/* function */ | /* function */ | ||
case I_FUNC: case I_CAR: case I_CDR: case I_EV: | case I_FUNC: | ||
switch ( f->id ) { | opname = conv_rule(((FUNC)FA0(f))->name); | ||
case I_FUNC: | write_tb(opname,tb); | ||
opname = symbol_name(((FUNC)FA0(f))->name); | write_tb("(",tb); | ||
fargstotex_tb(opname,FA1(f),tb); | |||
write_tb(")",tb); | |||
break; | |||
/* XXX */ | |||
case I_CAR: | |||
opname = conv_rule("car"); | |||
write_tb(opname,tb); | |||
write_tb("(",tb); | |||
fargstotex_tb(opname,FA0(f),tb); | |||
write_tb(")",tb); | |||
break; | |||
case I_CDR: | |||
opname = conv_rule("cdr"); | |||
write_tb(opname,tb); | |||
write_tb("(",tb); | |||
fargstotex_tb(opname,FA0(f),tb); | |||
write_tb(")",tb); | |||
break; | |||
/* exponent vector */ | |||
case I_EV: | |||
n = (NODE)FA0(f); | |||
if ( dp_vars_hweyl ) { | |||
elen = length(n); | |||
elen2 = elen>>1; | |||
elen = elen2<<1; | |||
} | |||
allzero = 1; | |||
if ( show_lt && is_lt ) | |||
write_tb("\\underline{",tb); | |||
for ( t0 = 0, i = 0; n; n = NEXT(n), i++ ) { | |||
fi = (FNODE)BDY(n); | |||
if ( fi->id == I_FORMULA && !FA0(fi) ) continue; | |||
allzero = 0; | |||
if ( dp_vars_hweyl ) { | |||
if ( i < elen2 ) | |||
if ( dp_vars_prefix ) | |||
sprintf(vname,"%s_{%d}",dp_vars_prefix,i); | |||
else | |||
sprintf(vname,"x_{%d}",i); | |||
else if ( i < elen ) | |||
sprintf(vname,"{\\partial}_{%d}",i-elen2); | |||
else | |||
strcpy(vname,"h"); | |||
} else if ( dp_vars && i < dp_vars_len ) | |||
strcpy(vname,dp_vars[i]); | |||
else if ( dp_vars_prefix ) | |||
sprintf(vname,"%s_{%d}",dp_vars_prefix,i); | |||
else | |||
sprintf(vname,"x_{%d}",i); | |||
vname_conv = conv_rule(vname); | |||
if ( fi->id == I_FORMULA && UNIQ(FA0(fi)) ) { | |||
len = strlen(vname_conv); | |||
opname = MALLOC_ATOMIC(len+2); | |||
sprintf(opname,"%s ",vname_conv); | |||
write_tb(opname,tb); | write_tb(opname,tb); | ||
write_tb("(",tb); | } else { | ||
fargstotex_tb(opname,FA1(f),tb); | len = strlen(vname_conv); | ||
write_tb(")",tb); | /* 2: ^{ */ | ||
break; | opname = MALLOC_ATOMIC(len+1+2); | ||
case I_CAR: | sprintf(opname,"%s^{",vname_conv); | ||
opname = symbol_name("car"); | |||
write_tb(opname,tb); | write_tb(opname,tb); | ||
write_tb("(",tb); | fnodetotex_tb((FNODE)BDY(n),tb); | ||
fargstotex_tb(opname,FA0(f),tb); | write_tb("} ",tb); | ||
write_tb(")",tb); | } | ||
break; | |||
case I_CDR: | |||
opname = symbol_name("cdr"); | |||
write_tb(opname,tb); | |||
write_tb("(",tb); | |||
fargstotex_tb(opname,FA0(f),tb); | |||
write_tb(")",tb); | |||
break; | |||
case I_EV: | |||
n = (NODE)FA0(f); | |||
allzero = 1; | |||
for ( t0 = 0, i = 0; n; n = NEXT(n), i++ ) { | |||
fi = (FNODE)BDY(n); | |||
if ( fi->id == I_FORMULA && !FA0(fi) ) continue; | |||
allzero = 0; | |||
if ( fi->id == I_FORMULA && UNIQ(FA0(fi)) ) { | |||
sprintf(vname,"x_{%d}",i); | |||
len = strlen(vname); | |||
opname = MALLOC_ATOMIC(len+1); | |||
strcpy(opname,vname); | |||
write_tb(opname,tb); | |||
} else { | |||
sprintf(vname,"x_{%d}^{",i); | |||
len = strlen(vname); | |||
opname = MALLOC_ATOMIC(len+1); | |||
strcpy(opname,vname); | |||
write_tb(opname,tb); | |||
fnodetotex_tb((FNODE)BDY(n),tb); | |||
write_tb("} ",tb); | |||
} | |||
} | |||
/* XXX */ | |||
if ( allzero ) | |||
write_tb(" 1 ",tb); | |||
break; | |||
} | } | ||
/* XXX */ | |||
if ( allzero ) | |||
write_tb(" 1 ",tb); | |||
if ( show_lt && is_lt ) { | |||
write_tb("}",tb); | |||
is_lt = 0; | |||
} | |||
break; | break; | ||
/* string */ | |||
case I_STR: | case I_STR: | ||
write_tb((char *)FA0(f),tb); | write_tb((char *)FA0(f),tb); | ||
break; | break; | ||
/* internal object */ | |||
case I_FORMULA: | case I_FORMULA: | ||
obj = (Obj)FA0(f); | obj = (Obj)FA0(f); | ||
if ( obj && OID(obj) == O_P ) { | if ( obj && OID(obj) == O_P ) { | ||
opname = symbol_name(VR((P)obj)->name); | opname = conv_rule(VR((P)obj)->name); | ||
} else { | } else { | ||
len = estimate_length(CO,obj); | len = estimate_length(CO,obj); | ||
opname = (char *)MALLOC_ATOMIC(len+1); | opname = (char *)MALLOC_ATOMIC(len+1); | ||
|
|
||
write_tb(opname,tb); | write_tb(opname,tb); | ||
break; | break; | ||
/* program variable */ | |||
case I_PVAR: | case I_PVAR: | ||
if ( FA1(f) ) | if ( FA1(f) ) | ||
error("fnodetotex_tb : not implemented yet"); | error("fnodetotex_tb : not implemented yet"); | ||
|
|
||
void fnodenodetotex_tb(NODE n,TB tb) | void fnodenodetotex_tb(NODE n,TB tb) | ||
{ | { | ||
for ( ; n; n = NEXT(n) ) { | for ( ; n; n = NEXT(n) ) { | ||
is_lt = 1; | |||
fnodetotex_tb((FNODE)BDY(n),tb); | fnodetotex_tb((FNODE)BDY(n),tb); | ||
if ( NEXT(n) ) write_tb(", ",tb); | if ( NEXT(n) ) write_tb(", ",tb); | ||
} | } |