workbench/c/Eval.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 /******************************************************************************
  10
  11     NAME
  12
  13         Eval
  14
  15     SYNOPSIS
  16
  17         VALUE1/A,OP,VALUE2/M,TO/K,LFORMAT/K
  18
  19     LOCATION
  20
  21         Workbench:C
  22
  23     FUNCTION
  24
  25         Evaluate an integer expression and print the result. The result is
  26         written to standard output if not the TO switch are used which instead
  27         prints the result to a file. Using the switch LFORMAT, it is
  28         possible to direct how to write the result. Numbers prefixed by
  29         0x or #x are interpreted as hexadecimal and those prefixed by # or 0
  30         are interpreted as octals. Alphabetical characters are indicated
  31         by a leading single quotation mark ('), and are evaluated as their
  32         ASCII equivalent.
  33
  34     INPUTS
  35
  36         VALUE1,
  37         OP,
  38         VALUE2      --  The expression to evaluate. The following operators
  39                         are supported
  40
  41                         Operator              Symbols
  42                         ----------------------------------
  43                         addition              +
  44                         subtraction           -
  45                         multiplication        *
  46                         division              /
  47                         modulo                mod, M, m, %
  48                         bitwise and           &
  49                         bitwise or            |
  50                         bitwise not           ~
  51                         left shift            lsh, L, l
  52                         right shift           rsh, R, r
  53                         negation               -
  54                         exclusive or          xor, X, x
  55                         bitwise equivalence   eqv, E, e
  56
  57         TO          --  File to write the result to
  58         LFORMAT     --  printf-like specification of what to write.
  59                         The possible swiches are:
  60
  61                         %x  --  hexadecimal output
  62                         %o  --  octal output
  63                         %n  --  decimal output
  64                         %c  --  character output (the ANSI-character
  65                                 corresponding to the result value)
  66
  67                         By specifying *n in the LFORMAT string, a newline
  68                         is output.
  69
  70     RESULT
  71
  72     NOTES
  73
  74     EXAMPLE
  75
  76     BUGS
  77
  78     SEE ALSO
  79
  80     INTERNALS
  81
  82     HISTORY
  83
  84     01.01.2001  SDuvan  implemented (although a bit tired... happy new year!)
  85
  86 ******************************************************************************/
  87
  88 #define   DEBUG  0
  89 #include  <aros/debug.h>
  90
  91 #include  "evalParser.tab.c"
  92
  93 #include  <exec/types.h>
  94 #include  <exec/memory.h>
  95 #include  <dos/dos.h>
  96 #include  <dos/dosextens.h>
  97 #include  <dos/rdargs.h>
  98 #include  <proto/dos.h>
  99 #include  <proto/exec.h>
 100
 101
 102 static const char version[] = "$VER: Eval 41.1 (01.01.2001)\n";
 103
 104 #define  ARG_TEMPLATE  "VALUE1/A,OP,VALUE2/M,TO/K,LFORMAT/K"
 105 enum
 106 {
 107     ARG_VALUE1 = 0,
 108     ARG_OP,
 109     ARG_VALUE2,
 110     ARG_TO,
 111     ARG_LFORMAT,
 112     NOOFARGS
 113 };
 114
 115
 116 void printLformat(STRPTR format, int value);
 117 STRPTR fixExpression(STRPTR val1, STRPTR op, STRPTR *vals);
 118
 119
 120 int __nocommandline;
 121
 122 int main(void)
 123 {
 124     int  retval = RETURN_FAIL;
 125
 126     IPTR args[] = { (IPTR)NULL,
 127                     (IPTR)NULL,
 128                     (IPTR)NULL,
 129                     (IPTR)NULL,
 130                     (IPTR)NULL };
 131
 132     struct RDArgs *rda;
 133
 134     rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 135
 136     if (rda != NULL)
 137     {
 138         STRPTR  toFile  = (STRPTR)args[ARG_TO];
 139         STRPTR  lFormat = (STRPTR)args[ARG_LFORMAT];
 140         STRPTR  value1  = (STRPTR)args[ARG_VALUE1];
 141         STRPTR  op      = (STRPTR)args[ARG_OP];
 142         STRPTR *value2  = (STRPTR *)args[ARG_VALUE2];
 143
 144         STRPTR  argString;
 145
 146         BPTR  oldout = NULL;    /* Former output stream if using TO */
 147         BPTR  file = NULL;      /* Output redirection stream */
 148
 149         /* The Amiga Eval command is totally brain-dead and, at the same time,
 150            ReadArgs() is not really suitable for these arguments. To be
 151            compatible to the Amiga Eval command, we have to patch the arguments
 152            together to get something useful out of this. */
 153         argString = fixExpression(value1, op, value2);
 154
 155         text = argString;       /* Note: text is a global variable that is
 156                                    modified, so we cannot free 'text' below */
 157
 158         D(bug("Put together text: %s\n", text));
 159
 160         if (text == NULL || yyparse() == 1)
 161         {
 162             FreeVec(argString);
 163             FreeArgs(rda);
 164
 165             return RETURN_ERROR;
 166         }
 167
 168         FreeVec(argString);
 169
 170         if (toFile != NULL)
 171         {
 172             file = Open(toFile, MODE_NEWFILE);
 173
 174             if (file != NULL)
 175             {
 176                 oldout = SelectOutput(file);
 177             }
 178             else
 179             {
 180                 printf("Cannot open output file %s\n", toFile);
 181                 FreeArgs(rda);
 182
 183                 return RETURN_FAIL;
 184             }
 185         }
 186
 187         if (lFormat != NULL)
 188         {
 189             printLformat(lFormat, g_result);
 190         }
 191         else
 192         {
 193             printf("%i\n", g_result);
 194         }
 195
 196         /* Reinstall output stream if we changed it */
 197         if (oldout != NULL)
 198         {
 199             SelectOutput(oldout);
 200
 201             /* Close the TO/K file */
 202             Close(file);
 203         }
 204     }
 205     else
 206     {
 207         PrintFault(IoErr(), "Eval");
 208     }
 209
 210     FreeArgs(rda);
 211
 212     return retval;
 213 }
 214
 215
 216
 217 extern int g_result;            /* The result variable is global for now */
 218
 219 void printLformat(STRPTR format, int value)
 220 {
 221     ULONG i;                    /* Loop variable */
 222
 223     /* If it weren't for *n we could use VfWriteF() */
 224
 225     for (i = 0; format[i] != 0; i++)
 226     {
 227         switch (format[i])
 228         {
 229         case '*':
 230             if (format[i] == 'n')
 231             {
 232                 printf("\n");
 233             }
 234             else
 235             {
 236                 printf("*");
 237             }
 238
 239             break;
 240
 241         case '%':
 242             i++;
 243
 244             switch (tolower(format[i]))
 245             {
 246             /* Hexadecimal display */
 247             case 'x':
 248                 printf("%x", value);
 249                 break;
 250
 251             /* Octal display */
 252             case 'o':
 253                 printf("%o", value);
 254                 break;
 255
 256             /* Integer display */
 257             case 'n':
 258                 printf("%i", value);
 259                 break;
 260
 261             /* Character display */
 262             case 'c':
 263                 printf("%c", value);
 264                 break;
 265
 266             case '%':
 267                 printf("%%");
 268                 break;
 269
 270                 /* Stupid user writes "...%" */
 271             case 0:
 272                 i--;
 273                 break;
 274
 275             default:
 276                 printf("%%%c", format[i]);
 277                 break;
 278
 279             } /* switch(%-command) */
 280
 281             break;
 282
 283         default:
 284             printf("%c", format[i]);
 285             break;
 286         } /* switch format character */
 287     }
 288 }
 289
 290
 291 STRPTR fixExpression(STRPTR val1, STRPTR op, STRPTR *vals)
 292 {
 293     /* val1 must be != 0 as it's an /A argument */
 294     int    len;
 295     int    i;                   /* Loop variable */
 296     STRPTR arg;
 297
 298     len = strlen(val1) + 1 + 1;      /* One extra for the 0 byte to end
 299                                         the string */
 300
 301     if (op != NULL)
 302     {
 303         len += strlen(op) + 1;
 304     }
 305
 306     if (vals) for (i = 0; vals[i] != NULL; i++)
 307     {
 308         len += strlen(vals[i]) + 1;
 309     }
 310
 311     arg = AllocVec(len, MEMF_ANY);
 312
 313     if (arg == NULL)
 314     {
 315         return NULL;
 316     }
 317
 318     strcpy(arg, val1);
 319     strcat(arg, " ");
 320
 321     if (op != NULL)
 322     {
 323         strcat(arg, op);
 324         strcat(arg, " ");
 325     }
 326
 327     if (vals) for (i = 0; vals[i] != NULL; i++)
 328     {
 329         strcat(arg, vals[i]);
 330         strcat(arg, " ");
 331     }
 332
 333     return arg;
 334 }