Sindbad~EG File Manager

#include <string.h>
#include <ctype.h>
#include <assert.h>
#include "bsym.h"


static int bsym1(char *s,int arity)
// If s is the string form of a built-in symbol such as "+", "*", then return its
// MathXpert number; if not, return 0.
{  // see LITERALFUNCTOR in functors.h in MathXpert
  if(s[1] == 0 && arity == 2)
     { switch(s[0])
         { case '*' : return 42;
           case '+' : return 43;
           case '/' : return 47;
           case '=' : return 61;
           case '^' : return 94;
           case ':' : return 58;
           case '<' : return 60;
           case '>' : return 62;
         }
       return 0;
     }
   if(!strcmp(s,"-") && arity == 1) return 45;
   if(!strcmp(s,"<=") && arity == 2) return LE;
   if(!strcmp(s,">=") && arity == 2) return GE;
   return 0;
}           

#define LITERALFUNCTOR(f) ((f)==42 || (f)==43 || (f)==45 || (f)==47 || (f)==58 || (f)==60 || (f)==61 || (f)==62 || (f)==94)

// supply fixed symbol numbers for built-in symbols

int bsym(char *s,int arity)
{  char buffer[32];
   int i,ans;
   int n = strlen(s);
   if(n > 10)
      return 0;
   /* first we must detect +, *, ^, etc. */
   ans = bsym1(s,arity);
   if(ans)
      return ans;
   memset(buffer,0, 32);
   for(i=0;i<n;i++)
      buffer[i] = toupper(s[i]);
   if(arity==4)
     { if (!strcmp(buffer,"SUM")) return SUM;
       if (!strcmp(buffer,"PRODUCT")) return PRODUCT;
       return 0;
     }
       
   if(arity == 2)
     { switch(buffer[0])
          { case 'A' : switch(buffer[1])
                          { case 'L' :  if (!strcmp(buffer,"ALL")) return FORALL;
                               break;
                            case 'N'  : if (!strcmp(buffer,"AND")) return AND;
                            case 'P'  : if (!strcmp(buffer, "AP")) return AP;
                               break;
                            case 'O':   if (!strcmp(buffer,"OR")) return OR;
                               break;
                          }
                       break;
            case 'B':  if (!strcmp(buffer,"BINOMIAL")) return BINOMIAL;
                       break;
            case 'E':  if (!strcmp(buffer,"EXISTS")) return EXISTS;
                       break;
            case 'I':  if (!strcmp(buffer,"IF")) return IF;
                       if (!strcmp(buffer,"IMPLIES")) return IMPLIES;
                       break;
            case 'L':  if (!strcmp(buffer,"LIM")) return LIMIT;
                       if (!strcmp(buffer,"LIMIT")) return LIMIT;
                       if (!strcmp(buffer,"LAMBDA")) return LAMBDA;
                       if( !strcmp(buffer,"LOGB")) return LOGB;
                       break;
            case 'O':  if(!strcmp(buffer,"OR")) return OR;
                       break;
            case 'R':  if (!strcmp(buffer,"ROOT")) return ROOT;
                       break;
            case 'S':  if (!strcmp(buffer,"SET")) return SETOF;
                       break;
                     
         }
       return 0;
     }
   if(arity == 1)
   { switch(buffer[0])
     {  case 'A':
          switch (buffer[1])
             {  case 'B' :  if (!strcmp(buffer,"ABS")) return ABS;
                            break;
                case 'C' :  if (!strcmp(buffer,"ACOS")) return ACOS;
                            if (!strcmp(buffer,"ACOT")) return ACOT;
                            if (!strcmp(buffer,"ACSC")) return ACSC;
                            if (!strcmp(buffer,"ACOSH")) return ACOSH;
                            if (!strcmp(buffer,"ACOTH")) return ACOTH;
                            if (!strcmp(buffer,"ACSCH")) return ACSCH;
                            break;
                case 'R'  : if (!strcmp(buffer,"ARCSIN")) return ASIN;
                            if (!strcmp(buffer,"ARCCOS")) return ACOS;
                            if (!strcmp(buffer,"ARCTAN")) return ATAN;
                            if (!strcmp(buffer,"ARCSEC")) return ASEC;
                            if (!strcmp(buffer,"ARCCSC")) return ACSC;
                            if (!strcmp(buffer,"ARCCOT")) return ACOT;
                            if (!strcmp(buffer,"ARCSINH")) return ASINH;
                            if (!strcmp(buffer,"ARCCOSH")) return ACOSH;
                            if (!strcmp(buffer,"ARCTANH")) return ATANH;
                            if (!strcmp(buffer,"ARCSECH")) return ASECH;
                            if (!strcmp(buffer,"ARCCSCH")) return ACSCH;
                            if (!strcmp(buffer,"ARCCOTH")) return ACOTH;
                            break;
                case 'S'  : if (!strcmp(buffer, "ASEC")) return ASEC;
                            if (!strcmp(buffer, "ASECH")) return ASECH;
                            if (!strcmp(buffer,"ASIN")) return ASIN;
                            if (!strcmp(buffer,"ASINH")) return ASINH;
                            break;
                case 'T'  : if (!strcmp(buffer, "ATAN")) return ATAN;
                            if (!strcmp(buffer, "ATANH")) return ATANH;
                            break;
             }
          break;
        case 'B':    if (!strcmp(buffer,"BETA")) return BETAFUNCTION;
                     break;
        case 'C':    if (!strcmp(buffer,"COS")) return COS;
                     if (!strcmp(buffer,"COSH")) return COSH;
                     if (!strcmp(buffer,"COT")) return COT;
                     if (!strcmp(buffer,"COTH")) return COTH;
                     if (!strcmp(buffer,"CSC")) return CSC;
                     if (!strcmp(buffer,"CSCH")) return CSCH;
                     if (!strcmp(buffer,"CASES")) return CASES;
                     if (!strcmp(buffer,"COFI")) return CONSTANTOFINTEGRATION;
                        /* must be parseable for cut-and-paste to work */
                     if (!strcmp(buffer,"COSINTEGRAL")) return COSINTEGRAL;
                     break;
        case 'D':    // if (!strcmp(buffer,"DEG")) return DEG;
                     if (!strcmp(buffer,"DET")) return DET;
                     if (!strcmp(buffer,"DIFF")) return DIFF;
                     if (!strcmp(buffer,"DIGAMMA")) return DIGAMMA;
                     break;
        case 'E':    if (!strcmp(buffer,"ERF")) return ERF;
                     if (!strcmp(buffer,"ERFC")) return ERFC;
                     if (!strcmp(buffer,"EVAL")) return EVAL;
                     if (!strcmp(buffer,"EXPINTEGRALE")) return EXPINTEGRALE;
                     if (!strcmp(buffer,"EXPINTEGRALI")) return EXPINTEGRALE;                    
                     break;
        case 'F':    if (!strcmp(buffer,"FLOOR")) return FLOOR;
                     if( !strcmp(buffer,"FACTORIAL"))  return FACTORIAL;
                     break;
        case 'G':    if (!strcmp(buffer,"GCD")) return GCD;
                     if (!strcmp(buffer,"GAMMA")) return GAMMA;
                     break;
        case 'I'  :  if (!strcmp(buffer,"INTEGRAL")) return INTEGRAL;                     
                     if (!strcmp(buffer,"I")) return BESSELI;
                     if (!strcmp(buffer,"INCOMPLETEBETA")) return INCOMPLETEBETA;
                     if (!strcmp(buffer,"INCOMPLETEGAMMA")) return INCOMPLETEGAMMA;
                     if (!strcmp(buffer,"INCOMPLETEGAMMAP")) return INCOMPLETEGAMMAP;
                     if (!strcmp(buffer,"IM")) return IMAGPART;
                     // if (!strcmp(buffer,"INVERSE")) return MATRIXINVERSE;
                     break;
        case 'J':    if (!strcmp(buffer,"J")) return BESSELJ;
                     break;
        case 'K':    if (!strcmp(buffer,"K")) return BESSELK;
                     break;
        case 'L':    if (!strcmp(buffer,"LOG")) return LOG;
                     if (!strcmp(buffer,"LN")) return LN;
                     if (!strcmp(buffer,"LOGINTEGRAL")) return LOGINTEGRAL;
                     break;
        case 'M':    if (!strcmp(buffer,"MATRIX")) return MATRIX;
                     if (!strcmp(buffer,"MOD")) return MOD;
                     if(!strcmp(buffer,"MIN")) return MINFUNCTOR;
                     if(!strcmp(buffer,"MAX")) return MAXFUNCTOR;
                     break;
        case 'N':    if (!strcmp(buffer,"NOT")) return NOT;
                     break;
        case 'P':    if (!strcmp(buffer,"PE")) return WEIERSTRASSP;
                     if (!strcmp(buffer,"PRODUCT")) return PRODUCT;
                     if (!strcmp(buffer,"POLYGAMMA")) return POLYGAMMA;
                     break;
        case 'R':    if (!strcmp(buffer,"RE")) return REALPART;
                     break;
        case 'S':    if (!strcmp(buffer,"SIN")) return SIN;
                     if (!strcmp(buffer,"SINH")) return SINH;
                     if (!strcmp(buffer,"SEC")) return SEC;
                     if (!strcmp(buffer,"SECH")) return SECH;
                     if (!strcmp(buffer,"SQRT")) return SQRT;                     
                     if (!strcmp(buffer,"SININTEGRAL")) return SININTEGRAL;
                     if (!strcmp(buffer,"SG")) return SG;
                     break;
        case 'T':    if (!strcmp(buffer,"TAN")) return TAN;
                     if (!strcmp(buffer,"TANH")) return TANH;
                     break;
        case 'W':    if (!strcmp(buffer,"WEIERSTRASSP")) return WEIERSTRASSP;
                     break;
        case 'Y':    if (!strcmp(buffer,"Y")) return BESSELY;
                     break;
        case 'Z':    if (!strcmp(buffer,"ZETA")) return RIEMANNZETA;
                     break;
      }
     }
     return 0;   /* not a known functor */
}