workbench/c/Eval.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Eval CLI command
   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         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                         %xd --  hexadecimal output, width digit d
  62                         %od --  octal output, width digit d
  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     04.05.2011  polluks width digit was missing
  85     01.01.2001  SDuvan  implemented (although a bit tired... happy new year!)
  86
  87 ******************************************************************************/
  88
  89 #define   DEBUG  0
  90 #include  <aros/debug.h>
  91
  92 #include  "evalParser.tab.c"
  93
  94 #include  <exec/types.h>
  95 #include  <exec/memory.h>
  96 #include  <dos/dos.h>
  97 #include  <dos/dosextens.h>
  98 #include  <dos/rdargs.h>
  99 #include  <proto/dos.h>
 100 #include  <proto/exec.h>
 101 #include  <proto/alib.h>
 102
 103 const TEXT version[] = "$VER: Eval 41.2 (14.7.2011)\n";
 104
 105 #define  ARG_TEMPLATE  "VALUE1/A,OP,VALUE2/M,TO/K,LFORMAT/K"
 106 enum
 107 {
 108     ARG_VALUE1 = 0,
 109     ARG_OP,
 110     ARG_VALUE2,
 111     ARG_TO,
 112     ARG_LFORMAT,
 113     NOOFARGS
 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_OK;
 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         PrintFault(IoErr(), "Eval");
 139         retval = RETURN_FAIL;
 140     }
 141     else
 142     {
 143         STRPTR  toFile  = (STRPTR)args[ARG_TO];
 144         STRPTR  lFormat = (STRPTR)args[ARG_LFORMAT];
 145         STRPTR  value1  = (STRPTR)args[ARG_VALUE1];
 146         STRPTR  op      = (STRPTR)args[ARG_OP];
 147         STRPTR *value2  = (STRPTR *)args[ARG_VALUE2];
 148
 149         STRPTR  argString;
 150
 151         BPTR  oldout = BNULL; /* Former output stream if using TO */
 152         BPTR  file   = BNULL; /* Output redirection stream */
 153
 154         /* The developer to use fixExpression had no high regard
 155            of the Amiga Eval command, and at the same time considered
 156            ReadArgs() not to be really suitable for these arguments.
 157            To be compatible to the Amiga Eval command, the developer
 158            felt it was necessary to patch the arguments back together. */
 159         argString = fixExpression(value1, op, value2);
 160
 161         text = argString; /* Note: text is a global variable that is
 162                                    modified, so we cannot free 'text' below */
 163
 164         D(bug("Put together text: %s\n", text));
 165
 166         if (text == NULL || yyparse() == 1)
 167         {
 168             retval= RETURN_ERROR;
 169         }
 170         else {
 171             if (toFile != NULL)
 172             {
 173                 file = Open(toFile, MODE_NEWFILE);
 174
 175                 if (file == BNULL)
 176                 {
 177                     Printf("Cannot open output file %s\n", toFile);
 178
 179                     retval= RETURN_FAIL;
 180                 }
 181                 else
 182                 {
 183                     oldout = SelectOutput(file);
 184                 }
 185             }
 186
 187             if (toFile == NULL || file != BNULL) {
 188                 if (lFormat != NULL)
 189                 {
 190                     printLformat(lFormat, g_result);
 191                 }
 192                 else
 193                 {
 194                     Printf("%ld\n", g_result);
 195                 }
 196
 197                 /* Reinstall output stream if we changed it */
 198                 if (oldout != BNULL)
 199                 {
 200                     SelectOutput(oldout);
 201
 202                     /* Close the TO/K file */
 203                     Close(file);
 204                 }
 205             }
 206         }
 207         FreeVec(argString);
 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     char s[10];
 223
 224     /* If it weren't for *n we could use VfWriteF() */
 225
 226     for (i = 0; format[i] != 0; i++)
 227     {
 228         switch (format[i])
 229         {
 230         case '*':
 231             if (format[i] == 'n')
 232             {
 233                 Printf("\n");
 234             }
 235             else
 236             {
 237                 Printf("*");
 238             }
 239
 240             break;
 241
 242         case '%':
 243             i++;
 244
 245             switch (tolower(format[i]))
 246             {
 247             /* Hexadecimal display */
 248             case 'x':
 249                 __sprintf(s, "%X", value);
 250                 s[format[++i] - '0'] = 0;
 251                 Printf("%s", s);
 252                 break;
 253
 254             /* Octal display */
 255             case 'o':
 256                 __sprintf(s, "%o", value);
 257                 s[format[++i] - '0'] = 0;
 258                 Printf("%s", s);
 259                 break;
 260
 261             /* Integer display */
 262             case 'n':
 263                 Printf("%ld", value);
 264                 break;
 265
 266             /* Character display */
 267             case 'c':
 268                 Printf("%c", value);
 269                 break;
 270
 271             case '%':
 272                 Printf("%%");       /* AROS extension */
 273                 break;
 274
 275                 /* Stupid user writes "...%" */
 276             case 0:
 277                 i--;
 278                 break;
 279
 280             default:
 281                 Printf("%%%c", format[i]);
 282                 break;
 283
 284             } /* switch(%-command) */
 285
 286             break;
 287
 288         default:
 289             Printf("%c", format[i]);
 290             break;
 291         } /* switch format character */
 292     }
 293 }
 294
 295
 296 STRPTR fixExpression(STRPTR val1, STRPTR op, STRPTR *vals)
 297 {
 298     /* val1 must be != 0 as it's an /A argument */
 299     int    len;
 300     int    i;                        /* Loop variable */
 301     STRPTR arg;
 302
 303     len = strlen(val1) + 1 + 1;             /* One extra for the 0 byte to end
 304                                         the string */
 305
 306     if (op != NULL)
 307     {
 308         len += strlen(op) + 1;
 309     }
 310
 311     if (vals) for (i = 0; vals[i] != NULL; i++)
 312     {
 313         len += strlen(vals[i]) + 1;
 314     }
 315
 316     arg = AllocVec(len, MEMF_ANY);
 317
 318     if (arg == NULL)
 319     {
 320         return NULL;
 321     }
 322
 323     strcpy(arg, val1);
 324     strcat(arg, " ");
 325
 326     if (op != NULL)
 327     {
 328         strcat(arg, op);
 329         strcat(arg, " ");
 330     }
 331
 332     if (vals) for (i = 0; vals[i] != NULL; i++)
 333     {
 334         strcat(arg, vals[i]);
 335         strcat(arg, " ");
 336     }
 337
 338     return arg;
 339 }
 340
 341 /* For linking with the evalParser.y output
 342  */
 343 void *malloc(YYSIZE_T size)
 344 {
 345     return AllocVec(size, MEMF_ANY);
 346 }
 347
 348 void free(void *ptr)
 349 {
 350     FreeVec(ptr);
 351 }
 352
 353 int puts(const char *s)
 354 {
 355     PutStr(s);
 356     return 0;
 357 }