OpenXM_contrib2/asir2000/builtin/strobj.c - diff

Return to strobj.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/strobj.c between version 1.16 and 1.26

-version 1.16, 2004/03/04 03:31:28
+version 1.26, 2004/03/05 01:47:19
 Line 45
 Line 45
 Line 45
   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
   *
-  * $OpenXM: OpenXM_contrib2/asir2000/builtin/strobj.c,v 1.15 2004/03/04 01:41:32 noro Exp $
+  * $OpenXM: OpenXM_contrib2/asir2000/builtin/strobj.c,v 1.25 2004/03/05 01:34:24 noro Exp $
  */
  #include "ca.h"
  #include "parse.h"
 Line 58  extern jmp_buf environnement;
 Line 58  extern jmp_buf environnement;
 Line 58  extern jmp_buf environnement;
  #endif
  #include <string.h>
+ struct TeXSymbol {
+         char *text;
+         char *symbol;
+ };
  extern char *parse_strp;
  void Prtostr(), Pstrtov(), Peval_str();
-Line 69  void Pclear_tb();
+Line 74  void Pclear_tb();
 Line 69  void Pclear_tb();
 Line 74  void Pclear_tb();
  void Pstring_to_tb();
  void Pquotetotex_tb();
  void Pquotetotex();
- void Ptrim_tb();
+ void Pquotetotex_env();
  void fnodetotex_tb(FNODE f,TB tb);
  char *symbol_name(char *name);
  void tb_to_string(TB tb,STRING *rp);
  void fnodenodetotex_tb(NODE n,TB tb);
  void fargstotex_tb(char *opname,FNODE f,TB tb);
- void dp_trim_tb(TB tb);
  struct ftab str_tab[] = {
          {"rtostr",Prtostr,1},
-Line 90  struct ftab str_tab[] = {
+Line 94  struct ftab str_tab[] = {
 Line 90  struct ftab str_tab[] = {
 Line 94  struct ftab str_tab[] = {
          {"clear_tb",Pclear_tb,1},
          {"tb_to_string",Ptb_to_string,1},
          {"string_to_tb",Pstring_to_tb,1},
-         {"trim_tb",Ptrim_tb,2},
          {"quotetotex_tb",Pquotetotex_tb,2},
          {"quotetotex",Pquotetotex,1},
+         {"quotetotex_env",Pquotetotex_env,-99999999},
          {0,0,0},
  };
-Line 106  void write_tb(char *s,TB tb)
+Line 110  void write_tb(char *s,TB tb)
 Line 106  void write_tb(char *s,TB tb)
 Line 110  void write_tb(char *s,TB tb)
          tb->next++;
  }
- void dp_trim_tb(TB tb)
+ 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);
+ static struct TeXSymbol *user_texsymbol;
+ static char *(*conv_rule)(char *);
+ static char **dp_vars;
+ static int dp_vars_len;
+ static char *dp_vars_prefix;
+ static FUNC convfunc;
+ 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},
+         {0,0,0},
+ };
+ #define PARTIAL "\\partial"
+ char *conv_rule_d(char *name)
  {
-         int i,j,l,onei,onej;
+         int l,i,j,alpha,start;
-         char *p;
+         char *b,*r;
+         l = strlen(name);
-         if ( !tb->next ) return;
+         if ( name[0] == 'd' ) {
-         /* number    1 =>  number */
+                 /* 3 : _{} */
-         onei = -1; onej = -1;
+                 b = (char *)ALLOCA((2*l+1+strlen(PARTIAL)+3)*sizeof(char));
-         for ( i = tb->next-1; i >= 0; i-- ) {
+                 sprintf(b,"%s_{",PARTIAL);
-                 p = tb->body[i];
+                 i = 1;
-                 l = strlen(p);
+                 j = strlen(b);
-                 if ( onei < 0 ) {
+         } else {
-                         for ( j = l-1; j >= 0 && isspace(p[j]); j-- );
+                 b = (char *)ALLOCA((2*l+1)*sizeof(char));
-                         if ( j < 0 ) continue;
+                 i = j = 0;
-                         if ( p[j] != '1' ) return;
-                         /* we found 1 */
-                         onei = i; onej = j; j--;
-                 } else
-                         j = l-1;
-                 /* we search the previous non-space character */
-                 for ( ; j >= 0 && isspace(p[j]); j-- );
-                 if ( j < 0 ) continue;
-                 if ( p[j] == '+' || p[j] == '-' ) return;
-                 else break;
          }
-         if ( i < 0 ) return;
+         for ( ; i < l && name[i] == '_'; i++);
-         /* the previous character is a number */
+         for ( ; i < l; ) {
-         l = strlen(tb->body[onei]);
+                 if ( !isalpha(name[i]) )
-         p = (char *)MALLOC_ATOMIC(l+1);
+                         break;
-         strcpy(p,tb->body[onei]);
+                 else
-         p[onej] = ' ';
+                         b[j++] = name[i++];
-         tb->body[onei] = p;
+         }
+         if ( i == l )
+                 if ( name[0] == 'd' )
+                         goto END;
+                 else
+                         return name;
+         /* we found a digit or '_' */
+         b[j++] = '_'; b[j++] = '{';
+         if ( name[i] == '_' ) i++;
+         for ( start = 1; i < l; ) {
+                 if ( name[i] == '{' || name[i] == '}' || name[i] == ' ' )
+                         b[j++] = name[i++];
+                 else if ( name[i] == '_' ) {
+                         i++;
+                         start = 1;
+                         b[j++] = ',';
+                 } else if ( start ) {
+                         alpha = isalpha(name[i])?1:0;
+                         b[j++] = name[i++];
+                         start = 0;
+                 } else if ( alpha ) {
+                         if ( isalpha(name[i]) )
+                                 b[j++] = name[i++];
+                         else {
+                                 alpha = 0;
+                                 start = 1;
+                                 b[j++] = ',';
+                         }
+                 } else {
+                         if ( isdigit(name[i]) )
+                                 b[j++] = name[i++];
+                         else {
+                                 alpha = 1;
+                                 start = 1;
+                                 b[j++] = ',';
+                         }
+                 }
+         }
+         b[j++] = '}';
+ END:
+         if ( name[0] == 'd' ) b[j++] = '}';
+         b[j++] = 0;
+         r = (char *)MALLOC_ATOMIC((j+1)*sizeof(char));
+         strcpy(r,b);
+         return r;
  }
- void Ptrim_tb(NODE arg,Q *rp)
+ char *call_convfunc(char *name)
  {
-         asir_assert(ARG0(arg),O_TB,"trim_tb");
+         STRING str,r;
-         if ( !INT(ARG1(arg)) ) error("trim_tb : invalid argument");
+         NODE arg;
-         switch ( QTOS((Q)ARG1(arg)) ) {
-                 case O_DP:
+         MKSTR(str,name);
-                         dp_trim_tb((TB)ARG0(arg));
+         arg = mknode(1,str);
-                         break;
+         r = (STRING)bevalf(convfunc,arg);
-                 default:
+         if ( !r || OID(r) != O_STR )
-                         break;
+                 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;
          }
-         *rp = 0;
+         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_conv_rule(Obj arg)
+ {
+         if ( INT(arg) ) {
+                 switch ( QTOS((Q)arg) ) {
+                         case 0:
+                                 conv_rule = 0;
+                                 return 1;
+                                 break;
+                         case 1:
+                                 conv_rule = conv_rule_d;
+                                 return 1;
+                                 break;
+                         default:
+                                 return 0;
+                                 break;
+                 }
+         } else if ( OID(arg) == O_P &&
+                 (int)(VR((P)arg))->attr == V_SR ) {
+                 convfunc = (FUNC)(VR((P)arg)->priv);
+                 /* f must be a function which takes single argument */
+                 conv_rule = call_convfunc;
+                 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)
  {
          int i;
-Line 429  P *rp;
+Line 647  P *rp;
 Line 429  P *rp;
 Line 647  P *rp;
  #endif
  }
- struct TeXSymbol {
-         char *text;
-         char *symbol;
- };
  static struct TeXSymbol texsymbol[] = {
   {"sin","\\sin"},
   {"cos","\\cos"},
-Line 494  static struct TeXSymbol texsymbol[] = {
+Line 707  static struct TeXSymbol texsymbol[] = {
 Line 494  static struct TeXSymbol texsymbol[] = {
 Line 707  static struct TeXSymbol texsymbol[] = {
   {"c_i","\\sqrt{-1}"},
   /* Temporary  */
-  {"dx","\\partial"},
   {0,0}
  };
-Line 502  char *symbol_name(char *name)
+Line 714  char *symbol_name(char *name)
 Line 502  char *symbol_name(char *name)
 Line 714  char *symbol_name(char *name)
  {
          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++ )
                  if ( !strcmp(texsymbol[i].text,name) )
                          return texsymbol[i].symbol;
-         return name;
+         if ( conv_rule )
+                 return (*conv_rule)(name);
+         else
+                 return name;
  }
  void fnodetotex_tb(FNODE f,TB tb)
  {
          NODE n,t,t0;
          char vname[BUFSIZ];
-         char *opname;
+         char *opname,*vname_conv;
          Obj obj;
          int i,len,allzero;
-         FNODE fi;
+         FNODE fi,f2;
          write_tb(" ",tb);
          if ( !f ) {
-Line 524  void fnodetotex_tb(FNODE f,TB tb)
+Line 743  void fnodetotex_tb(FNODE f,TB tb)
 Line 524  void fnodetotex_tb(FNODE f,TB tb)
 Line 743  void fnodetotex_tb(FNODE f,TB tb)
          }
          switch ( f->id ) {
                  /* 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;
+                 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 */
-                 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);
-                                                 fnodetotex_tb((FNODE)FA2(f),tb);
+                                         for ( i = 0; n; n = NEXT(n), i++ ) {
-                                         } else if ( !strcmp(opname,"/") ) {
+                                                 fi = (FNODE)BDY(n);
-                                                 write_tb("\\frac{",tb);
+                                                 if ( fi->id != I_FORMULA || FA0(fi) )
-                                                 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;
-                                                 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;
+                                 case C_NE:
-                                 case I_AND:
-                                         fnodetotex_tb((FNODE)FA0(f),tb);
-                                         write_tb(" {\\rm \\ and\\ } ",tb);
                                          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;
-                                 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);
+                                         write_tb(" = ",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;
+                 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 */
                  case I_CE:
                          error("fnodetotex_tb : not implemented yet");
-Line 697  void fnodetotex_tb(FNODE f,TB tb)
+Line 919  void fnodetotex_tb(FNODE f,TB tb)
 Line 697  void fnodetotex_tb(FNODE f,TB tb)
 Line 919  void fnodetotex_tb(FNODE f,TB tb)
                          break;
                  /* function */
-                 case I_FUNC: case I_CAR: case I_CDR: case I_EV:
+                 case I_FUNC:
-                         switch ( f->id ) {
+                         opname = symbol_name(((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 = symbol_name("car");
+                         write_tb(opname,tb);
+                         write_tb("(",tb);
+                         fargstotex_tb(opname,FA0(f),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;
+                 /* exponent vector */
+                 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 ( 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 = symbol_name(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("(",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("(",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);
                          break;
+                 /* string */
                  case I_STR:
                          write_tb((char *)FA0(f),tb);
                          break;
+                 /* internal object */
                  case I_FORMULA:
                          obj = (Obj)FA0(f);
                          if ( obj && OID(obj) == O_P ) {
-Line 767  void fnodetotex_tb(FNODE f,TB tb)
+Line 998  void fnodetotex_tb(FNODE f,TB tb)
 Line 767  void fnodetotex_tb(FNODE f,TB tb)
 Line 998  void fnodetotex_tb(FNODE f,TB tb)
                          write_tb(opname,tb);
                          break;
+                 /* program variable */
                  case I_PVAR:
                          if ( FA1(f) )
                                  error("fnodetotex_tb : not implemented yet");

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>