| version 1.8, 2000/12/16 06:16:10 | 
version 1.19, 2002/09/02 05:16:07 | 
 | 
 | 
|   * 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/spexpr.c,v 1.7 2000/12/15 05:30:08 noro Exp $ | 
  * $OpenXM: OpenXM_contrib2/asir2000/io/spexpr.c,v 1.18 2002/01/08 04:14:39 kondoh Exp $ | 
|  */ | 
 */ | 
|  #include "ca.h" | 
 #include "ca.h" | 
|  #include "al.h" | 
 #include "al.h" | 
 | 
 | 
|  char DFORMAT[BUFSIZ]; | 
 char DFORMAT[BUFSIZ]; | 
|  int hex_output; | 
 int hex_output; | 
|  int fortran_output; | 
 int fortran_output; | 
|   | 
 int double_output; | 
|   | 
 int real_digit; | 
|   | 
 int print_quote; | 
|   | 
  | 
|  #define TAIL | 
 #define TAIL | 
|  #define PUTS(s) fputs(s,OUT) | 
 #define PUTS(s) fputs(s,OUT) | 
| Line 88  int fortran_output; | 
 
  | 
| Line 91  int fortran_output; | 
 
 
 | 
|  #define PRINTGF2MAT printgf2mat | 
 #define PRINTGF2MAT printgf2mat | 
|  #define PRINTGFMMAT printgfmmat | 
 #define PRINTGFMMAT printgfmmat | 
|  #define PRINTBYTEARRAY printbytearray | 
 #define PRINTBYTEARRAY printbytearray | 
|   | 
 #define PRINTQUOTE printquote | 
|  #define PRINTERR printerr | 
 #define PRINTERR printerr | 
|  #define PRINTLF printlf | 
 #define PRINTLF printlf | 
|  #define PRINTLOP printlop | 
 #define PRINTLOP printlop | 
| Line 95  int fortran_output; | 
 
  | 
| Line 99  int fortran_output; | 
 
 
 | 
|  #define PRINTEOP printeop | 
 #define PRINTEOP printeop | 
|  #define PRINTQOP printqop | 
 #define PRINTQOP printqop | 
|  #define PRINTUP printup | 
 #define PRINTUP printup | 
|   | 
 #define PRINTUM printum | 
|   | 
 #define PRINTSF printsf | 
|  #endif | 
 #endif | 
|   | 
  | 
|  #ifdef SPRINT | 
 #ifdef SPRINT | 
| Line 104  extern char DFORMAT[BUFSIZ]; | 
 
  | 
| Line 110  extern char DFORMAT[BUFSIZ]; | 
 
 
 | 
|  extern int hex_output; | 
 extern int hex_output; | 
|  extern int fortran_output; | 
 extern int fortran_output; | 
|  extern int double_output; | 
 extern int double_output; | 
|   | 
 extern int real_digit; | 
|   | 
 extern int print_quote; | 
|   | 
  | 
|  #define TAIL while ( *OUT ) OUT++; | 
 #define TAIL while ( *OUT ) OUT++; | 
|  #define PUTS(s) strcat(OUT,s) | 
 #define PUTS(s) strcat(OUT,s) | 
| Line 128  extern int double_output; | 
 
  | 
| Line 136  extern int double_output; | 
 
 
 | 
|  #define PRINTGF2MAT sprintgf2mat | 
 #define PRINTGF2MAT sprintgf2mat | 
|  #define PRINTGFMMAT sprintgfmmat | 
 #define PRINTGFMMAT sprintgfmmat | 
|  #define PRINTBYTEARRAY sprintbytearray | 
 #define PRINTBYTEARRAY sprintbytearray | 
|   | 
 #define PRINTQUOTE sprintquote | 
|  #define PRINTERR sprinterr | 
 #define PRINTERR sprinterr | 
|  #define PRINTLF sprintlf | 
 #define PRINTLF sprintlf | 
|  #define PRINTLOP sprintlop | 
 #define PRINTLOP sprintlop | 
| Line 135  extern int double_output; | 
 
  | 
| Line 144  extern int double_output; | 
 
 
 | 
|  #define PRINTEOP sprinteop | 
 #define PRINTEOP sprinteop | 
|  #define PRINTQOP sprintqop | 
 #define PRINTQOP sprintqop | 
|  #define PRINTUP sprintup | 
 #define PRINTUP sprintup | 
|   | 
 #define PRINTUM sprintum | 
|   | 
 #define PRINTSF sprintsf | 
|  #endif | 
 #endif | 
|   | 
  | 
|  void PRINTEXPR(); | 
 void PRINTEXPR(); | 
 | 
 | 
|  void PRINTGF2MAT(); | 
 void PRINTGF2MAT(); | 
|  void PRINTGFMMAT(); | 
 void PRINTGFMMAT(); | 
|  void PRINTBYTEARRAY(); | 
 void PRINTBYTEARRAY(); | 
|   | 
 void PRINTQUOTE(); | 
|  void PRINTERR(); | 
 void PRINTERR(); | 
|  void PRINTCPLX(); | 
 void PRINTCPLX(); | 
|  void PRINTLM(); | 
 void PRINTLM(); | 
|  void PRINTLF(); | 
 void PRINTLF(); | 
|  void PRINTUP2(); | 
 void PRINTUP2(); | 
|   | 
 void PRINTUP(); | 
|   | 
 void PRINTUM(); | 
|   | 
 void PRINTFOP(); | 
|   | 
 void PRINTEOP(); | 
|   | 
 void PRINTLOP(); | 
|   | 
 void PRINTQOP(); | 
|   | 
 void PRINTSF(); | 
|   | 
  | 
|  #ifdef FPRINT | 
 #ifdef FPRINT | 
|  void output_init() { | 
 void output_init() { | 
 | 
 | 
|  P p; | 
 P p; | 
|  { | 
 { | 
|          if ( NUM(p) ) | 
         if ( NUM(p) ) | 
|   | 
 #if defined(INTERVAL) | 
|   | 
                 if ( NID(p) != N_IP && NID(p) != N_IntervalDouble && NID(p) != N_IntervalQuad && NID(p) != N_IntervalBigFloat | 
|   | 
                         && compnum(CO,(Num)p,0) < 0 ) | 
|   | 
 #else | 
|                  if ( compnum(CO,(Num)p,0) < 0 ) | 
                 if ( compnum(CO,(Num)p,0) < 0 ) | 
|   | 
 #endif | 
|                          return ( 1 ); | 
                         return ( 1 ); | 
|                  else | 
                 else | 
|                          return ( 0 ); | 
                         return ( 0 ); | 
 | 
 | 
|  void printbf(a) | 
 void printbf(a) | 
|  BF a; | 
 BF a; | 
|  { | 
 { | 
|   | 
         void sor(); | 
|   | 
  | 
|          sor(a->body,double_output ? 'f' : 'g',-1,0); | 
         sor(a->body,double_output ? 'f' : 'g',-1,0); | 
|  } | 
 } | 
|  #endif | 
 #endif | 
 | 
 | 
|                          PRINTGFMMAT(vl,(GFMMAT)p); break; | 
                         PRINTGFMMAT(vl,(GFMMAT)p); break; | 
|                  case O_BYTEARRAY: | 
                 case O_BYTEARRAY: | 
|                          PRINTBYTEARRAY(vl,(BYTEARRAY)p); break; | 
                         PRINTBYTEARRAY(vl,(BYTEARRAY)p); break; | 
|   | 
                 case O_QUOTE: | 
|   | 
                         PRINTQUOTE(vl,(QUOTE)p); break; | 
|                  default: | 
                 default: | 
|                          break; | 
                         break; | 
|          } | 
         } | 
 | 
 | 
|          } | 
         } | 
|  } | 
 } | 
|   | 
  | 
|   | 
 #if defined(FPRINT) | 
|   | 
 #if defined(ITVDEBUG) | 
|   | 
 void printbin(double z) | 
|   | 
 { | 
|   | 
         int     i, j, mask; | 
|   | 
         union { | 
|   | 
                 double  x; | 
|   | 
                 char    c[8]; | 
|   | 
         } a; | 
|   | 
  | 
|   | 
         a.x = z; | 
|   | 
         for(i=7;i>=0;i--) { | 
|   | 
                 mask = 0x80; | 
|   | 
                 for(j=0;j<8;j++) { | 
|   | 
                         if (a.c[i] & mask) fprintf(stderr,"1"); | 
|   | 
                         else fprintf(stderr,"0"); | 
|   | 
                         mask >>= 1; | 
|   | 
                 } | 
|   | 
         } | 
|   | 
         fprintf(stderr,"\n"); | 
|   | 
 } | 
|   | 
 #endif | 
|   | 
 #endif | 
|   | 
  | 
|   | 
 #if defined(FPRINT) | 
|   | 
 #if 0 | 
|   | 
 int     printmode = PRINTF_E; | 
|   | 
 #else | 
|   | 
 int     printmode = PRINTF_G; | 
|   | 
 #endif | 
|   | 
 #else | 
|   | 
 extern int printmode; | 
|   | 
 #endif | 
|   | 
  | 
|  void PRINTNUM(q) | 
 void PRINTNUM(q) | 
|  Num q; | 
 Num q; | 
|  { | 
 { | 
|   | 
         char real_format[20]; | 
|   | 
  | 
|          if ( !q ) { | 
         if ( !q ) { | 
|                  PUTS("0"); | 
                 PUTS("0"); | 
|                  return; | 
                 return; | 
 | 
 | 
|                          } | 
                         } | 
|                          break; | 
                         break; | 
|                  case N_R: | 
                 case N_R: | 
|                          TAIL PRINTF(OUT,double_output?"%f":"%g",BDY((Real)q)); | 
                         switch (printmode) { | 
|   | 
                                 case PRINTF_E: | 
|   | 
 #if defined(INTERVAL) | 
|   | 
                                 case MID_PRINTF_E: | 
|   | 
 #endif | 
|   | 
                                         TAIL PRINTF(OUT,"%.16e",BDY((Real)q)); | 
|   | 
                                         break; | 
|   | 
                                 case PRINTF_G: | 
|   | 
 #if defined(INTERVAL) | 
|   | 
                                 case MID_PRINTF_G: | 
|   | 
 #endif | 
|   | 
                                 default: | 
|   | 
                                         if ( real_digit ) { | 
|   | 
                                                 sprintf(real_format, | 
|   | 
                                                         double_output?"%%.%df":"%%.%dg",real_digit); | 
|   | 
                                                 TAIL PRINTF(OUT,real_format,BDY((Real)q)); | 
|   | 
                                         } else { | 
|   | 
                                                 TAIL PRINTF(OUT,double_output?"%f":"%g",BDY((Real)q)); | 
|   | 
                                         } | 
|   | 
                                         break; | 
|   | 
                         } | 
|                          break; | 
                         break; | 
|                  case N_A: | 
                 case N_A: | 
|                          PUTS("("); PRINTR(ALG,(R)BDY((Alg)q)); PUTS(")"); | 
                         PUTS("("); PRINTR(ALG,(R)BDY((Alg)q)); PUTS(")"); | 
 | 
 | 
|                  case N_B: | 
                 case N_B: | 
|                          PRINTBF((BF)q); break; | 
                         PRINTBF((BF)q); break; | 
|  #endif | 
 #endif | 
|   | 
 #if defined(INTERVAL) | 
|   | 
                 case N_IP: | 
|   | 
                 case N_IntervalBigFloat: | 
|   | 
                         PUTS("["); | 
|   | 
                         PRINTNUM(INF((Itv)q)); | 
|   | 
                         PUTS(","); | 
|   | 
                         PRINTNUM(SUP((Itv)q)); | 
|   | 
                         PUTS("]"); | 
|   | 
                         break; | 
|   | 
                 case N_IntervalDouble: | 
|   | 
                         switch (printmode) { | 
|   | 
                                 case PRINTF_E: | 
|   | 
                                         TAIL PRINTF(OUT, "[%.16e,%.16e]",INF((IntervalDouble)q),SUP((IntervalDouble)q)); | 
|   | 
 #if defined(ITVDEBUG) | 
|   | 
                                         printbin(INF((IntervalDouble)q)); | 
|   | 
                                         printbin(SUP((IntervalDouble)q)); | 
|   | 
 #endif | 
|   | 
                                         break; | 
|   | 
                                 case MID_PRINTF_G: | 
|   | 
                                         TAIL PRINTF(OUT, "<%g,%g>", (SUP((IntervalDouble)q)+INF((IntervalDouble)q))*0.5,(SUP((IntervalDouble)q)-INF((IntervalDouble)q))*0.5); | 
|   | 
                                         break; | 
|   | 
                                 case MID_PRINTF_E: | 
|   | 
                                         TAIL PRINTF(OUT, "<%.16e,%.16e>", (SUP((IntervalDouble)q)+INF((IntervalDouble)q))*0.5,(SUP((IntervalDouble)q)-INF((IntervalDouble)q))*0.5); | 
|   | 
                                         break; | 
|   | 
                                 case PRINTF_G: | 
|   | 
                                 default: | 
|   | 
                                         TAIL PRINTF(OUT, "[%g,%g]",INF((IntervalDouble)q),SUP((IntervalDouble)q)); | 
|   | 
                                 break; | 
|   | 
                         } | 
|   | 
                         break; | 
|   | 
 #endif | 
|                  case N_C: | 
                 case N_C: | 
|                          PRINTCPLX((C)q); break; | 
                         PRINTCPLX((C)q); break; | 
|                  case N_M: | 
                 case N_M: | 
 | 
 | 
|                  case N_GFPN: | 
                 case N_GFPN: | 
|                          PRINTUP((UP)(((GFPN)q)->body)); | 
                         PRINTUP((UP)(((GFPN)q)->body)); | 
|                          break; | 
                         break; | 
|   | 
                 case N_GFS: | 
|   | 
                         TAIL PRINTF(OUT,"@_%d",CONT((GFS)q)); | 
|   | 
                         break; | 
|   | 
                 case N_GFSN: | 
|   | 
                         PRINTUM(BDY((GFSN)q)); | 
|   | 
                         break; | 
|          } | 
         } | 
|  } | 
 } | 
|   | 
  | 
 | 
 | 
|          if ( a->r ) | 
         if ( a->r ) | 
|                  PRINTNUM(a->r); | 
                 PRINTNUM(a->r); | 
|          if ( a->i ) { | 
         if ( a->i ) { | 
|   | 
 #if defined(INTERVAL) | 
|   | 
                 if ( a->r && ((compnum(0,a->i,0) > 0) | 
|   | 
                         || NID(a->i) == N_IP || NID(a->i) == N_IntervalDouble | 
|   | 
                         || NID(a->i) == N_IntervalQuad || NID(a->i) == N_IntervalBigFloat) ) | 
|   | 
 #else | 
|                  if ( a->r && (compnum(0,a->i,0) > 0) ) | 
                 if ( a->r && (compnum(0,a->i,0) > 0) ) | 
|   | 
 #endif | 
|                          PUTS("+"); | 
                         PUTS("+"); | 
|                  PRINTNUM(a->i); PUTS("*@i"); | 
                 PRINTNUM(a->i); PUTS("*@i"); | 
|          } | 
         } | 
 | 
 | 
|          else if ( (vid)v->attr == V_PF ) { | 
         else if ( (vid)v->attr == V_PF ) { | 
|                  pf = ((PFINS)v->priv)->pf; ad = ((PFINS)v->priv)->ad; | 
                 pf = ((PFINS)v->priv)->pf; ad = ((PFINS)v->priv)->ad; | 
|                  if ( !strcmp(NAME(pf),"pow") ) { | 
                 if ( !strcmp(NAME(pf),"pow") ) { | 
|                          PUTS("("); PRINTR(vl,(R)ad[0].arg); PUTS(")"); PRINTHAT; PUTS("("); | 
                         PUTS("(("); PRINTR(vl,(R)ad[0].arg); PUTS(")"); PRINTHAT; PUTS("("); | 
|                          PRINTR(vl,(R)ad[1].arg); PUTS(")"); | 
                         PRINTR(vl,(R)ad[1].arg); PUTS("))"); | 
|                  } else if ( !pf->argc ) { | 
                 } else if ( !pf->argc ) { | 
|                          TAIL PRINTF(OUT,"%s",NAME(pf)); | 
                         TAIL PRINTF(OUT,"%s",NAME(pf)); | 
|                  } else { | 
                 } else { | 
 | 
 | 
|  GFMMAT mat; | 
 GFMMAT mat; | 
|  { | 
 { | 
|          int row,col,i,j; | 
         int row,col,i,j; | 
|          unsigned int t; | 
  | 
|          unsigned int **b; | 
         unsigned int **b; | 
|   | 
  | 
|          row = mat->row; | 
         row = mat->row; | 
 | 
 | 
|  BYTEARRAY array; | 
 BYTEARRAY array; | 
|  { | 
 { | 
|          int len,i; | 
         int len,i; | 
|          unsigned int t; | 
  | 
|          unsigned char *b; | 
         unsigned char *b; | 
|   | 
  | 
|          len = array->len; | 
         len = array->len; | 
| Line 651  BYTEARRAY array; | 
 
  | 
| Line 776  BYTEARRAY array; | 
 
 
 | 
|          PUTS("|"); | 
         PUTS("|"); | 
|  } | 
 } | 
|   | 
  | 
|   | 
 void PRINTQUOTE(vl,quote) | 
|   | 
 VL vl; | 
|   | 
 QUOTE quote; | 
|   | 
 { | 
|   | 
         LIST list; | 
|   | 
  | 
|   | 
         if ( print_quote ) { | 
|   | 
                 fnodetotree(BDY(quote),&list); | 
|   | 
                 PRINTEXPR(vl,(Obj)list); | 
|   | 
         } else { | 
|   | 
                 PUTS("<...quoted...>"); | 
|   | 
         } | 
|   | 
 } | 
|   | 
  | 
|  void PRINTERR(vl,e) | 
 void PRINTERR(vl,e) | 
|  VL vl; | 
 VL vl; | 
|  ERR e; | 
 ERR e; | 
 | 
 | 
|          } | 
         } | 
|  } | 
 } | 
|   | 
  | 
|  PRINTFOP(vl,f) | 
 void PRINTFOP(vl,f) | 
|  VL vl; | 
 VL vl; | 
|  F f; | 
 F f; | 
|  { | 
 { | 
 | 
 | 
|          } | 
         } | 
|  } | 
 } | 
|   | 
  | 
|  PRINTEOP(vl,f) | 
 void PRINTEOP(vl,f) | 
|  VL vl; | 
 VL vl; | 
|  F f; | 
 F f; | 
|  { | 
 { | 
 | 
 | 
|          PUTS(")"); | 
         PUTS(")"); | 
|  } | 
 } | 
|   | 
  | 
|  PRINTLOP(vl,f) | 
 void PRINTLOP(vl,f) | 
|  VL vl; | 
 VL vl; | 
|  F f; | 
 F f; | 
|  { | 
 { | 
 | 
 | 
|          PRINTEXPR(vl,(Obj)FPL(f)); PUTS(op); PUTS("0"); | 
         PRINTEXPR(vl,(Obj)FPL(f)); PUTS(op); PUTS("0"); | 
|  } | 
 } | 
|   | 
  | 
|  PRINTQOP(vl,f) | 
 void PRINTQOP(vl,f) | 
|  VL vl; | 
 VL vl; | 
|  F f; | 
 F f; | 
|  { | 
 { | 
 | 
 | 
|          PRINTEXPR(vl,(Obj)FQMAT(f)); PUTS(")"); | 
         PRINTEXPR(vl,(Obj)FQMAT(f)); PUTS(")"); | 
|  } | 
 } | 
|   | 
  | 
|  PRINTUP(n) | 
 void PRINTUP(n) | 
|  UP n; | 
 UP n; | 
|  { | 
 { | 
|          int i,d; | 
         int i,d; | 
 | 
 | 
|                          } | 
                         } | 
|                  } | 
                 } | 
|                  PUTS(")"); | 
                 PUTS(")"); | 
|   | 
         } | 
|   | 
 } | 
|   | 
  | 
|   | 
 void PRINTUM(n) | 
|   | 
 UM n; | 
|   | 
 { | 
|   | 
         int i,d; | 
|   | 
  | 
|   | 
         if ( !n ) | 
|   | 
                 PUTS("0"); | 
|   | 
         else if ( !n->d ) | 
|   | 
                 PRINTSF(n->c[0]); | 
|   | 
         else { | 
|   | 
                 d = n->d; | 
|   | 
                 PUTS("("); | 
|   | 
                 if ( !d ) { | 
|   | 
                         PRINTSF(n->c[d]); | 
|   | 
                 } else if ( d == 1 ) { | 
|   | 
                         PRINTSF(n->c[d]); | 
|   | 
                         PUTS("*@s"); | 
|   | 
                 } else { | 
|   | 
                         PRINTSF(n->c[d]); | 
|   | 
                         PUTS("*@s"); PRINTHAT; TAIL PRINTF(OUT,"%d",d); | 
|   | 
                 } | 
|   | 
                 for ( i = d-1; i >= 0; i-- ) { | 
|   | 
                         if ( n->c[i] ) { | 
|   | 
                                 PUTS("+("); PRINTSF(n->c[i]); PUTS(")"); | 
|   | 
                                 if ( i >= 2 ) { | 
|   | 
                                         PUTS("*@s"); PRINTHAT; TAIL PRINTF(OUT,"%d",i); | 
|   | 
                                 } else if ( i == 1 ) | 
|   | 
                                         PUTS("*@s"); | 
|   | 
                         } | 
|   | 
                 } | 
|   | 
                 PUTS(")"); | 
|   | 
         } | 
|   | 
 } | 
|   | 
  | 
|   | 
 void PRINTSF(i) | 
|   | 
 unsigned int i; | 
|   | 
 { | 
|   | 
         if ( !i ) { | 
|   | 
                 PUTS("0"); | 
|   | 
         } else { | 
|   | 
                 TAIL PRINTF(OUT,"@_%d",IFTOF(i)); | 
|          } | 
         } | 
|  } | 
 } |