mpsl.y

   1 %{
   2 /*
   3
   4     MPSL - Minimum Profit Scripting Language
   5     Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
   6
   7     mpsl.y - Minimum Profit Scripting Language YACC parser
   8
   9     This program is free software; you can redistribute it and/or
  10     modify it under the terms of the GNU General Public License
  11     as published by the Free Software Foundation; either version 2
  12     of the License, or (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23     http://www.triptico.com
  24
  25 */
  26
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <wchar.h>
  30 #include "mpdm.h"
  31 #include "mpsl.h"
  32
  33 /*******************
  34         Data
  35 ********************/
  36
  37 /* the bytecode being generated */
  38 static mpdm_t mpsl_bytecode = NULL;
  39
  40 /* pointer to source code being compiled */
  41 extern wchar_t * mpsl_next_char;
  42
  43 /* pointer to file being compiled */
  44 extern FILE * mpsl_file;
  45
  46 /* line number */
  47 extern int mpsl_line;
  48
  49 /* compiled filename (for errors) */
  50 static char * mpsl_filename = NULL;
  51
  52 /* cached value MPSL.OPCODE */
  53 extern mpdm_t mpsl_opcodes;
  54
  55 /* cached value MPSL.LC */
  56 extern mpdm_t mpsl_lc;
  57
  58 /*******************
  59         Code
  60 ********************/
  61
  62 int yylex(void);
  63 void yyerror(char * s);
  64
  65 #define INS0(o)                 mpsl_mkins(o, 0, NULL, NULL, NULL)
  66 #define INS1(o,a1)              mpsl_mkins(o, 1, a1, NULL, NULL)
  67 #define INS2(o,a1,a2)           mpsl_mkins(o, 2, a1, a2, NULL)
  68 #define INS3(o,a1,a2,a3)        mpsl_mkins(o, 3, a1, a2, a3)
  69
  70 static mpdm_t mpsl_x(mpdm_t a1, mpdm_t a2, int sf)
  71 /* creates an executable value with the MPSL executor as the first
  72    argument and a compiled stream as the second */
  73 {
  74         return MPDM_X2(mpsl_exec_p,
  75                 mpsl_mkins(sf ? L"SUBFRAME" : L"BLKFRAME",
  76                         a2 == NULL ? 1 : 2, a1, a2, NULL));
  77 }
  78
  79
  80 static void compiler_warning(char * str)
  81 {
  82         fprintf(stderr, "WARNING: %s.\n", str);
  83 }
  84
  85
  86 %}
  87
  88 %union {
  89         mpdm_t v;       /* a simple value */
  90         mpdm_t ins;     /* an 'instruction': [ opcode, args ] */
  91 };
  92
  93 %token <v> NULLV INTEGER REAL STRING SYMBOL LITERAL
  94 %token WHILE IF SUB FOREACH LOCAL BREAK RETURN
  95 %nonassoc IFI
  96 %nonassoc ELSE
  97
  98 %left BOOLAND BOOLOR
  99 %left INC DEC IADD ISUB IMUL IDIV IMOD
 100 %left '!'
 101 %left STRCAT STREQ NUMEQ STRNE NUMNE NUMGE NUMLE HASHPAIR RANGE '>''<'
 102 %left BITAND
 103 %left BITOR BITXOR
 104 %left '+' '-'
 105 %left '*' '/' MOD
 106 %nonassoc UMINUS
 107
 108 %type <ins> stmt expr sym_list stmt_list list hash compsym
 109
 110 %%
 111
 112 program:
 113         function                { ; }
 114         ;
 115
 116 function:
 117         function stmt_list      {
 118                                         mpsl_bytecode = $2;
 119                                 }
 120         | /* NULL */
 121         ;
 122
 123 stmt:
 124         ';'                     {
 125                                         /* null instruction */
 126                                         $$ = INS0(L"MULTI");
 127                                 }
 128         | expr ';'              {
 129                                         /* expression, as is */
 130                                         $$ = $1;
 131                                 }
 132
 133         | WHILE '(' expr ')' stmt
 134                                 {
 135                                         /* while loop */
 136                                         $$ = INS2(L"WHILE", $3, $5);
 137                                 }
 138         | IF '(' expr ')' stmt %prec IFI
 139                                 {
 140                                         /* if - then construction */
 141                                         $$ = INS2(L"IF", $3, $5);
 142                                 }
 143         | IF '(' expr ')' stmt ELSE stmt
 144                                 {
 145                                         /* if - then - else construction */
 146                                         $$ = INS3(L"IF", $3, $5, $7);
 147                                 }
 148
 149         | SUB compsym '{' stmt_list '}'
 150                                 {
 151                                         /* subroutine definition,
 152                                            without arguments */
 153                                         $$ = INS2(L"ASSIGN", $2,
 154                                                 INS1(L"LITERAL",
 155                                                         mpsl_x($4, NULL, 1)));
 156                                 }
 157
 158         | SUB compsym '(' ')' '{' stmt_list '}'
 159                                 {
 160                                         /* subroutine definition,
 161                                            without arguments (second
 162                                            syntax, including parens) */
 163                                         $$ = INS2(L"ASSIGN", $2,
 164                                                 INS1(L"LITERAL",
 165                                                         mpsl_x($6, NULL, 1)));
 166                                 }
 167
 168         | SUB compsym '(' sym_list ')' '{' stmt_list '}'
 169                                 {
 170                                         /* subroutine definition,
 171                                            with arguments */
 172                                         $$ = INS2(L"ASSIGN", $2,
 173                                                 INS1(L"LITERAL",
 174                                                         mpsl_x($7, $4, 1)));
 175                                 }
 176
 177         | FOREACH '(' compsym ',' expr ')' stmt
 178                                 {
 179                                         /* foreach construction */
 180                                         /* a block frame is created, the iterator
 181                                            created as local, and the foreach executed */
 182                                         $$ = INS1(L"BLKFRAME",
 183                                                 INS2(L"MULTI",
 184                                                         INS1(L"LOCAL", $3),
 185                                                         INS3(L"FOREACH", $3, $5, $7)
 186                                                 )
 187                                         );
 188                                 }
 189         | FOREACH '(' LOCAL compsym ',' expr ')' stmt
 190                                 {
 191                                         compiler_warning("useless use of local in foreach loop");
 192
 193                                         $$ = INS1(L"BLKFRAME",
 194                                                 INS2(L"MULTI",
 195                                                         INS1(L"LOCAL", $4),
 196                                                         INS3(L"FOREACH", $4, $6, $8)
 197                                                 )
 198                                         );
 199                                 }
 200
 201         | '{' stmt_list '}'     {
 202                                         /* block of instructions,
 203                                            with local symbol table */
 204                                         $$ = INS1(L"BLKFRAME", $2);
 205                                 }
 206
 207         | LOCAL sym_list ';'    {
 208                                         /* local symbol creation */
 209                                         $$ = INS1(L"LOCAL", $2);
 210                                 }
 211         | LOCAL SYMBOL '=' expr ';'
 212                                 {
 213                                         /* contraction; local symbol
 214                                            creation and assignation */
 215                                         $$ = INS2(L"MULTI",
 216                                                 INS1(L"LOCAL",
 217                                                         INS1(L"LITERAL", $2)),
 218                                                 INS2(L"ASSIGN",
 219                                                         INS1(L"LITERAL", $2),$4)
 220                                                 );
 221                                 }
 222         | BREAK ';'             {
 223                                         /* break (exit from loop) */
 224                                         $$ = INS0(L"BREAK");
 225                                 }
 226         | RETURN expr ';'       {
 227                                         /* return from subroutine */
 228                                         $$ = INS1(L"RETURN", $2);
 229                                 }
 230         | RETURN ';'            {
 231                                         /* return from subroutine (void) */
 232                                         $$ = INS0(L"RETURN");
 233                                 }
 234         ;
 235
 236 stmt_list:
 237         stmt                    { $$ = $1; }
 238         | stmt_list stmt        {
 239                                         /* sequence of instructions */
 240                                         $$ = INS2(L"MULTI", $1, $2);
 241                                 }
 242         ;
 243
 244 list:
 245         expr                    {
 246                                         $$ = INS1(L"LIST", $1);
 247                                 }
 248         | list ',' expr         {
 249                                         /* build list from list of
 250                                            instructions */
 251                                         $$ = INS2(L"LIST", $3, $1);
 252                                 }
 253         ;
 254
 255 sym_list:
 256         SYMBOL                  {
 257                                         $$ = INS1(L"LIST",
 258                                                 INS1(L"LITERAL", $1));
 259                                 }
 260         | sym_list ',' SYMBOL   {
 261                                         /* comma-separated list of symbols */
 262                                         $$ = INS2(L"LIST",
 263                                                 INS1(L"LITERAL", $3), $1);
 264                                 }
 265         ;
 266
 267 hash:
 268         expr HASHPAIR expr      {
 269                                         $$ = INS2(L"HASH", $1, $3);
 270                                 }
 271         | hash ',' expr HASHPAIR expr
 272                                 {
 273                                         /* build hash from list of
 274                                            instructions */
 275                                         $$ = INS3(L"HASH", $3, $5, $1);
 276                                 }
 277         ;
 278
 279 compsym:
 280         SYMBOL                  {
 281                                         $$ = INS1(L"LIST",
 282                                                 INS1(L"LITERAL", $1));
 283                                 }
 284         | compsym '.' INTEGER   {
 285                                         /* a.5 compound symbol */
 286                                         $$ = INS2(L"LIST",
 287                                                 INS1(L"LITERAL", $3), $1);
 288                                 }
 289         | compsym '.' SYMBOL    {
 290                                         /* a.b compound symbol */
 291                                         $$ = INS2(L"LIST",
 292                                                 INS1(L"LITERAL", $3), $1);
 293                                 }
 294         | compsym '[' expr ']'  {
 295                                         /* a["b"] or a[5] compound symbol */
 296                                         $$ = INS2(L"LIST", $3, $1);
 297                                 }
 298         ;
 299
 300 expr:
 301         INTEGER                 {
 302                                         /* literal integer */
 303                                         $$ = INS1(L"LITERAL", $1);
 304                                 }
 305         | STRING                {
 306                                         /* literal string */
 307                                         $$ = INS1(L"LITERAL", $1);
 308                                 }
 309         | REAL                  {
 310                                         /* literal real number */
 311                                         $$ = INS1(L"LITERAL", $1);
 312                                 }
 313         | compsym               {
 314                                         /* compound symbol */
 315                                         $$ = INS1(L"SYMVAL", $1);
 316                                 }
 317         | NULLV                 {
 318                                         /* NULL value */
 319                                         $$ = INS1(L"LITERAL", NULL);
 320                                 }
 321
 322         | '-' expr %prec UMINUS {
 323                                         /* unary minus */
 324                                         $$ = INS1(L"UMINUS", $2);
 325                                 }
 326
 327                                 /* math operations */
 328         | expr '+' expr         { $$ = INS2(L"ADD", $1, $3); }
 329         | expr '-' expr         { $$ = INS2(L"SUB", $1, $3); }
 330         | expr '*' expr         { $$ = INS2(L"MUL", $1, $3); }
 331         | expr '/' expr         { $$ = INS2(L"DIV", $1, $3); }
 332         | expr MOD expr         { $$ = INS2(L"MOD", $1, $3); }
 333
 334                                 /* bit operations */
 335         | expr BITAND expr      { $$ = INS2(L"BITAND", $1, $3); }
 336         | expr BITOR expr       { $$ = INS2(L"BITOR", $1, $3); }
 337         | expr BITXOR expr      { $$ = INS2(L"BITXOR", $1, $3); }
 338
 339                                 /* immediate math operations */
 340         | INC compsym           { $$ = INS1(L"PINC", $2); }
 341         | compsym INC           { $$ = INS1(L"SINC", $1); }
 342         | DEC compsym           { $$ = INS1(L"PDEC", $2); }
 343         | compsym DEC           { $$ = INS1(L"SDEC", $1); }
 344         | compsym IADD expr     { $$ = INS2(L"IADD", $1, $3); }
 345         | compsym ISUB expr     { $$ = INS2(L"ISUB", $1, $3); }
 346         | compsym IMUL expr     { $$ = INS2(L"IMUL", $1, $3); }
 347         | compsym IDIV expr     { $$ = INS2(L"IDIV", $1, $3); }
 348         | compsym IMOD expr     { $$ = INS2(L"IMOD", $1, $3); }
 349
 350         | '!' expr              {
 351                                         /* boolean not */
 352                                         $$ = INS1(L"NOT", $2);
 353                                 }
 354         | expr '<' expr         {
 355                                         /* bool less than */
 356                                         $$ = INS2(L"NUMLT", $1, $3);
 357                                 }
 358         | expr '>' expr         {
 359                                         /* bool greater than */
 360                                         $$ = INS2(L"NUMGT", $1, $3);
 361                                 }
 362         | expr NUMLE expr       {
 363                                         /* bool less or equal than */
 364                                         $$ = INS2(L"NUMLE", $1, $3);
 365                                 }
 366         | expr NUMGE expr       {
 367                                         /* bool greater or equal than */
 368                                         $$ = INS2(L"NUMGE", $1, $3);
 369                                 }
 370         | expr NUMEQ expr       {
 371                                         /* bool numeric equal */
 372                                         $$ = INS2(L"NUMEQ", $1, $3);
 373                                 }
 374         | expr NUMNE expr       {
 375                                         /* bool numeric non-equal */
 376                                         $$ = INS1(L"NOT",
 377                                                 INS2(L"NUMEQ", $1, $3));
 378                                 }
 379
 380         | expr STRCAT expr      {
 381                                         /* string concatenation */
 382                                         $$ = INS2(L"STRCAT", $1, $3);
 383                                 }
 384         | expr STREQ expr       {
 385                                         /* bool string equal */
 386                                         $$ = INS2(L"STREQ", $1, $3);
 387                                 }
 388         | expr STRNE expr       {
 389                                         /* bool string non-equal */
 390                                         $$ = INS1(L"NOT",
 391                                                 INS2(L"STREQ", $1, $3));
 392                                 }
 393
 394         | expr BOOLAND expr     {
 395                                         /* boolean and */
 396                                         $$ = INS2(L"AND", $1, $3);
 397                                 }
 398         | expr BOOLOR expr      {
 399                                         /* boolean or */
 400                                         $$ = INS2(L"OR", $1, $3);
 401                                 }
 402
 403         | SUB '{' stmt_list '}' {
 404                                         /* anonymous subroutine (without args) */
 405                                         $$ = INS1(L"LITERAL", mpsl_x($3, NULL, 0));
 406                                 }
 407
 408         | SUB '(' sym_list ')' '{' stmt_list '}'
 409                                 {
 410                                         /* anonymous subroutine (with args) */
 411                                         $$ = INS1(L"LITERAL", mpsl_x($6, $3, 0));
 412                                 }
 413
 414         | '(' expr ')'          {
 415                                         /* parenthesized expression */
 416                                         $$ = $2;
 417                                 }
 418
 419         | '[' ']'               {
 420                                         /* empty list */
 421                                         $$ = INS1(L"LITERAL", MPDM_A(0));
 422                                 }
 423         | '[' list ']'          {
 424                                         /* non-empty list */
 425                                         $$ = $2;
 426                                 }
 427         | '[' expr RANGE expr ']'
 428                                 {
 429                                         /* build range from expressions */
 430                                         $$ = INS2(L"RANGE", $2, $4);
 431                                 }
 432
 433         | '{' '}'               {
 434                                         /* empty hash */
 435                                         $$ = INS1(L"LITERAL", MPDM_H(0));
 436                                 }
 437         | '{' hash '}'          {
 438                                         /* non-empty hash */
 439                                         $$ = $2;
 440                                 }
 441
 442         | compsym '(' ')'       {
 443                                         /* function call (without args) */
 444                                         $$ = INS1(L"EXECSYM", $1);
 445                                 }
 446         | compsym '(' list ')'  {
 447                                         /* function call (with args) */
 448                                         $$ = INS2(L"EXECSYM", $1, $3);
 449                                 }
 450         | compsym '=' expr      {
 451                                         /* simple assignation */
 452                                         $$ = INS2(L"ASSIGN", $1, $3);
 453                                 }
 454
 455         ;
 456
 457 %%
 458
 459 void yyerror(char * s)
 460 {
 461         char tmp[1024];
 462
 463         snprintf(tmp, sizeof(tmp), "%s in %s, line %d",
 464                 s, mpsl_filename, mpsl_line + 1);
 465
 466         mpsl_error(MPDM_MBS(tmp));
 467 }
 468
 469
 470 static FILE * inc_fopen(const char * filename, mpdm_t inc)
 471 /* loads filename, searching in INC if not directly accesible */
 472 {
 473         FILE * f = NULL;
 474         char tmp[1024];
 475         int n;
 476
 477         /* loop through INC, prepending each path
 478            to the filename */
 479         for (n = 0; n < mpdm_size(inc); n++) {
 480                 mpdm_t v = mpdm_aget(inc, n);
 481
 482                 v = MPDM_2MBS(v->data);
 483                 snprintf(tmp, sizeof(tmp), "%s/%s",
 484                         (char *)v->data, filename);
 485
 486                 if ((f = fopen(tmp, "r")) != NULL)
 487                         break;
 488         }
 489
 490         return f;
 491 }
 492
 493
 494 static mpdm_t do_parse(const char * filename, wchar_t * code, FILE * file)
 495 /* calls yyparse() after doing some initialisations, and returns
 496    the compiled code as an executable value */
 497 {
 498         mpdm_t v;
 499         mpdm_t x = NULL;
 500
 501         /* first line */
 502         mpsl_line = 0;
 503
 504         /* reset last bytecode */
 505         mpsl_bytecode = NULL;
 506
 507         /* set globals */
 508         mpsl_next_char = code;
 509         mpsl_file = file;
 510
 511         if (mpsl_filename != NULL)
 512                 free(mpsl_filename);
 513
 514         mpsl_filename = strdup(filename);
 515
 516         /* cache some values */
 517         v = mpdm_hget_s(mpdm_root(), L"MPSL");
 518         mpsl_opcodes = mpdm_hget_s(v, L"OPCODE");
 519         mpsl_lc = mpdm_hget_s(v, L"LC");
 520
 521         /* compile! */
 522         if (yyparse() == 0 && mpsl_bytecode != NULL)
 523                 x = mpsl_x(mpsl_bytecode, NULL, 1);
 524
 525         /* clean back cached values */
 526         mpsl_opcodes = NULL;
 527         mpsl_lc = NULL;
 528
 529         return x;
 530 }
 531
 532
 533 /**
 534  * mpsl_compile - Compiles a string of MPSL code.
 535  * @code: A value containing a string of MPSL code
 536  *
 537  * Compiles a string of MPSL code and returns an mpdm value executable
 538  * by mpdm_exec(). If there is a syntax (or other type) error, NULL
 539  * is returned instead.
 540  */
 541 mpdm_t mpsl_compile(mpdm_t code)
 542 {
 543         mpdm_t x = NULL;
 544
 545         mpdm_ref(code);
 546         x = do_parse("<INLINE>", (wchar_t *) code->data, NULL);
 547         mpdm_unref(code);
 548
 549         return x;
 550 }
 551
 552
 553 /**
 554  * mpsl_compile_file - Compiles a file of MPSL code.
 555  * @file: File stream or file name.
 556  *
 557  * Compiles a source file of MPSL code and returns an mpdm value
 558  * executable by mpdm_exec(). If @file is an MPSL file descriptor,
 559  * it's read as is and compiled; otherwise, it's assumed to be a
 560  * file name, that will be searched for in any of the paths defined
 561  * in the INC MPSL global array (take note that the current
 562  * directory is NOT searched by default). If the file cannot be found
 563  * or there is any other error, NULL is returned instead.
 564  */
 565 mpdm_t mpsl_compile_file(mpdm_t file)
 566 {
 567         mpdm_t x = NULL;
 568         FILE * f = NULL;
 569         const char * filename = NULL;
 570
 571         if ((f = mpdm_get_filehandle(file)) != NULL) {
 572                 filename = "<FILE>";
 573         }
 574         else {
 575                 mpdm_t inc = mpsl_get_symbol(MPDM_LS(L"INC"));
 576
 577                 /* it's a filename; open it */
 578                 file = MPDM_2MBS(file->data);
 579
 580                 filename = file->data;
 581
 582                 if ((f = inc_fopen(filename, inc)) == NULL) {
 583                         char tmp[128];
 584
 585                         snprintf(tmp, sizeof(tmp) - 1,
 586                                 "File '%s' not found in INC",
 587                                 filename);
 588                         mpsl_error(MPDM_MBS(tmp));
 589
 590                         return (NULL);
 591                 }
 592
 593                 file = MPDM_F(f);
 594         }
 595
 596         x = do_parse(filename, NULL, f);
 597
 598         mpdm_close(file);
 599
 600         return x;
 601 }
 602
 603
 604 /**
 605  * mpsl_eval - Evaluates MSPL code.
 606  * @code: A value containing a string of MPSL code, or executable code
 607  * @args: optional arguments for @code
 608  *
 609  * Evaluates a piece of code. The @code can be a string containing MPSL source
 610  * code (that will be compiled) or a direct executable value. If the compilation
 611  * or the execution gives an error, the ERROR variable will be set to a printable
 612  * value and NULL returned. Otherwise, the exit value from the code is returned
 613  * and ERROR set to NULL. The abort flag is reset on exit.
 614  */
 615 mpdm_t mpsl_eval(mpdm_t code, mpdm_t args)
 616 {
 617         mpdm_t v = NULL;
 618
 619         /* reset error */
 620         mpsl_error(NULL);
 621         mpsl_abort = 0;
 622
 623         /* if code is not executable, try to compile */
 624         if (!MPDM_IS_EXEC(code))
 625                 code = mpsl_compile(code);
 626
 627         /* execute, if possible */
 628         if (MPDM_IS_EXEC(code))
 629                 v = mpdm_exec(code, args);
 630
 631         /* reset the abort flag */
 632         mpsl_abort = 0;
 633
 634         return v;
 635 }