std/std_statements.c

   1 /*
   2   std_statements.c - MaLa statement like parsers
   3
   4   Copyright (C) 2005, Christian Thaeter <chth@gmx.net>
   5
   6   This program is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License version 2 as
   8   published by the Free Software Foundation.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; if not, contact me.
  17
  18 */
  19 \f
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <time.h>
  23
  24 #include "mala.h"
  25 #include "std_statements.h"
  26
  27
  28 static
  29 mala_actioninit std_statements[] =
  30   {
  31     MALA_PARSER_SIMPLE("--LITERAL", mala_literal_parser),
  32     //MALA_PARSER_BRIEF("--LITERAL", "Treats the next word literally"),
  33 //    MALA_PARSER_HELP("--LITERAL", ("TODO")),
  34 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
  35 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
  36 //    MALA_PARSER_RESULT_TYPE("--", ("")),
  37 //    MALA_PARSER_RESULT_USAGE("--", ("")),
  38
  39
  40     MALA_PARSER_SIMPLE("--SKIP", mala_skip_parser),
  41     //MALA_PARSER_BRIEF("--SKIP", "Treats the next n words literally"),
  42 //    MALA_PARSER_HELP("--LITERAL", ("TODO")),
  43 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
  44 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
  45 //    MALA_PARSER_RESULT_TYPE("--", ("")),
  46 //    MALA_PARSER_RESULT_USAGE("--", ("")),
  47
  48
  49     MALA_PARSER_SIMPLE("--PASS", mala_pass_parser),
  50     //MALA_PARSER_BRIEF("--PASS","does nothing"),
  51     //TODO MALA_PARSER_HELP("--PASS",("--HELP-ACTION","blah")),
  52 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
  53 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
  54 //    MALA_PARSER_RESULT_TYPE("--", ("")),
  55 //    MALA_PARSER_RESULT_USAGE("--", ("")),
  56
  57     MALA_PARSER_SIMPLE("--GC", mala_gc_parser),
  58
  59     MALA_PARSER_SIMPLE("--REMOVE", mala_remove_parser),
  60
  61     MALA_PARSER_SIMPLE("--NO", mala_no_parser),
  62
  63     MALA_PARSER_SIMPLE("--NONO", mala_nono_parser),
  64
  65     MALA_PARSER_SIMPLE("--IF-ELSE", mala_ifelse_parser),
  66
  67     MALA_PARSER_MACRO("--IF", ("--IF-ELSE", "%1", "%2", "--BEGIN", "--PASS", "--END")),
  68
  69     MALA_PARSER_SIMPLE("--STOP", mala_stop_parser),
  70     /*
  71     MALA_PARSER("--", mala__parser, NULL, NULL, NULL),
  72     MALA_PARSER_BRIEF("--", ""),
  73 //    MALA_PARSER_HELP("--", ("TODO")),
  74     MALA_PARSER_SIGNATURE_TYPE("--", ("")),
  75     MALA_PARSER_SIGNATURE_USAGE("--", ("")),
  76     MALA_PARSER_RESULT_TYPE("--", ("")),
  77     MALA_PARSER_RESULT_USAGE("--", ("")),
  78
  79     MALA_PARSER("--CHILDOF", mala__parser, NULL, NULL, NULL),
  80     MALA_PARSER_BRIEF("--", ""),
  81 //    MALA_PARSER_HELP("--", ("TODO")),
  82     MALA_PARSER_SIGNATURE_TYPE("--", ("")),
  83     MALA_PARSER_SIGNATURE_USAGE("--", ("")),
  84     MALA_PARSER_RESULT_TYPE("--", ("")),
  85     MALA_PARSER_RESULT_USAGE("--", ("")),
  86     */
  87
  88
  89
  90     //MALA_PARSER("--EXCEPTION", mala_exception_parser, NULL, NULL, NULL),
  91     //MALA_PARSER_BRIEF("--EXCEPTION", "defines a new macro"),
  92 //    MALA_PARSER_HELP("--EXCEPTION", ("TODO")),
  93 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
  94 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
  95 //    MALA_PARSER_RESULT_TYPE("--", ("")),
  96 //    MALA_PARSER_RESULT_USAGE("--", ("")),
  97
  98 //TODO    MALA_EXPAND_PARSER("--IFDEF", ("--IF", "--DEFINED")),
  99     //MALA_PARSER_BRIEF("--IFDEF", "tests if a word is defined as macro"),
 100 //    MALA_PARSER_HELP("--NOT", ("TODO")),
 101 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
 102 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
 103 //    MALA_PARSER_RESULT_TYPE("--", ("")),
 104 //    MALA_PARSER_RESULT_USAGE("--", ("")),
 105
 106     //MALA_PARSER("--DEFINED", mala_defined_parser, NULL, NULL, NULL),
 107     //MALA_PARSER_BRIEF("--DEFINED", "tests if a word is defined as macro"),
 108 //    MALA_PARSER_HELP("--NOT", ("TODO")),
 109 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
 110 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
 111 //    MALA_PARSER_RESULT_TYPE("--", ("")),
 112 //    MALA_PARSER_RESULT_USAGE("--", ("")),
 113
 114     //MALA_PARSER_BRIEF("--IF", "executes some code if a condition succeeded"),
 115 //    MALA_PARSER_HELP("--NOT", ("TODO")),
 116 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
 117 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
 118 //    MALA_PARSER_RESULT_TYPE("--", ("")),
 119 //    MALA_PARSER_RESULT_USAGE("--", ("")),
 120
 121
 122     //MALA_PARSER("--NOT", mala_not_parser, NULL, NULL, NULL),
 123     //MALA_PARSER_BRIEF("--NOT", "negates logic"),
 124 //    MALA_PARSER_HELP("--NOT", ("TODO")),
 125 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
 126 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
 127 //    MALA_PARSER_RESULT_TYPE("--", ("")),
 128 //    MALA_PARSER_RESULT_USAGE("--", ("")),
 129
 130
 131
 132     MALA_PARSER_SIMPLE("--SLEEP",mala_sleep_parser),
 133     //MALA_PARSER_BRIEF("--SLEEP", "delays execution for some time"),
 134     //TODO MALA_PARSER_HELP("--SLEEP", ("The program will be suspended for some time, the time might be specified as fraction of seconds\t example: 9.5")),
 135     //TODO MALA_PARSER_SIGNATURE_USAGE("--SLEEP",("Seconds to sleep")),
 136 //    //MALA_PARSER_RESULT_USAGE("--PRINTWRAPED", ("TODO")),
 137     //MALA_PARSER_SIGNATURE_TYPE("--SLEEP", ("DURATION")),
 138
 139     //MALA_PARSER("--TRACE",mala_trace_parser, NULL, NULL, NULL),
 140     //MALA_PARSER_BRIEF("--TRACE", "controls the trace mode of the MaLa VM"),
 141     //MALA_PARSER_SIGNATURE_USAGE("--SLEEP",("Seconds to sleep")),
 142 //    //MALA_PARSER_RESULT_USAGE("--PRINTWRAPED", ("TODO")),
 143     //MALA_PARSER_SIGNATURE_TYPE("--SLEEP", ("DURATION")),
 144
 145     //MALA_PARSER("--GCTRACE",mala_gctrace_parser, NULL, NULL, NULL),
 146     //MALA_PARSER_BRIEF("--GCTRACE", "controls the trace mode of the MaLa garbagge collector"),
 147     //MALA_PARSER_SIGNATURE_USAGE("--SLEEP",("Seconds to sleep")),
 148 //    //MALA_PARSER_RESULT_USAGE("--PRINTWRAPED", ("TODO")),
 149     //MALA_PARSER_SIGNATURE_TYPE("--SLEEP", ("DURATION")),
 150
 151     //    MALA_PARSER("--EVAL",mala_eval_parser, NULL, NULL, NULL),
 152     //    MALA_PARSER_BRIEF("--EVAL",""),
 153     //    MALA_PARSER_HELP("--EVAL",("blah")),
 154 //    MALA_PARSER_SIGNATURE_TYPE("--", ("")),
 155 //    MALA_PARSER_SIGNATURE_USAGE("--", ("")),
 156 //    MALA_PARSER_RESULT_TYPE("--", ("")),
 157 //    MALA_PARSER_RESULT_USAGE("--", ("")),
 158
 159
 160     MALA_ACTIONS_END
 161   };
 162
 163
 164 mala_state
 165 mala_literal_parser (MalaProgram prg)
 166 {
 167   TRACE (mala_module_std);
 168   if (!mala_program_exists_arg (prg, 1))
 169     return mala_program_commonexception (prg, MALA_STRING_ERROR_MISSING_ARGUMENT);
 170
 171   mala_stringlist_remove (mala_stringlist_next (prg->pptr));
 172   return MALA_LITERAL;
 173 }
 174
 175
 176 mala_state
 177 mala_stop_parser (MalaProgram prg)
 178 {
 179   TRACE (mala_module_std);
 180
 181   mala_stringlist_remove (mala_stringlist_next (prg->pptr));
 182   return MALA_SUCCESS;
 183 }
 184
 185
 186 mala_state
 187 mala_skip_parser (MalaProgram prg)
 188 {
 189   TRACE (mala_module_std);
 190
 191   int n;
 192
 193   if (mala_program_eval_arg_fmt (prg, 1, "%d", &n) > MALA_EFAULT)
 194     return mala_program_commonexception (prg, MALA_STRING_ERROR);
 195   if (n < 0)
 196     return mala_program_commonexception (prg, MALA_STRING_ERROR_OUT_OF_RANGE);
 197
 198   MalaStringList pptr;
 199   if (n)
 200     {
 201       pptr = (MalaStringList) llist_get_nth_stop (&prg->pptr->node, n+2,
 202                                                   &prg->program->node);
 203       if (!pptr)
 204         return mala_program_commonexception (prg, MALA_STRING_ERROR_MISSING_ARGUMENT);
 205     }
 206
 207   mala_program_action_done (prg, 1);
 208   if (n)
 209     prg->pptr = pptr;
 210   return MALA_STATEMENT;
 211 }
 212
 213
 214 mala_state
 215 mala_pass_parser (MalaProgram prg)
 216 {
 217   TRACE (mala_module_std);
 218   mala_stringlist_remove (mala_stringlist_next (prg->pptr));
 219   return MALA_STATEMENT;
 220 }
 221
 222
 223 mala_state
 224 mala_gc_parser (MalaProgram prg)
 225 {
 226   TRACE (mala_module_std);
 227   acogc_root_collect (&prg->engine->gcroot, ACOGC_COLLECT_NORMAL);
 228   mala_program_action_done (prg, 0);
 229   return MALA_STATEMENT;
 230 }
 231
 232
 233 mala_state
 234 mala_remove_parser (MalaProgram prg)
 235 {
 236   TRACE (mala_module_std);
 237   if (mala_program_eval_arg (prg, 1, MALA_REMOVE, NULL) > MALA_EFAULT)
 238     return mala_program_commonexception (prg, MALA_STRING_ERROR);
 239
 240   mala_program_action_done (prg, 0);
 241   return MALA_STATEMENT;
 242 }
 243
 244
 245 mala_state
 246 mala_no_parser (MalaProgram prg)
 247 {
 248   TRACE (mala_module_std);
 249   MALA_MUTATOR_BEGIN
 250     {
 251       ++prg->negated;
 252     }
 253   MALA_MUTATOR_END;
 254
 255   mala_program_action_done (prg, 0);
 256   return MALA_STATEMENT;
 257 }
 258
 259
 260 mala_state
 261 mala_nono_parser (MalaProgram prg)
 262 {
 263   TRACE (mala_module_std);
 264   MALA_MUTATOR_BEGIN
 265     {
 266       prg->negated = 0;
 267     }
 268   MALA_MUTATOR_END;
 269
 270   mala_program_action_done (prg, 0);
 271   return MALA_STATEMENT;
 272 }
 273
 274
 275 mala_state
 276 mala_ifelse_parser (MalaProgram prg)
 277 {
 278   TRACE (mala_module_std);
 279
 280   MalaStringList test;
 281
 282   mala_state state = mala_program_eval_arg (prg, 1, MALA_LITERAL, &test);
 283
 284   if (state > MALA_EFAULT)
 285     return mala_program_commonexception (prg, MALA_STRING_ERROR);
 286
 287   if (state == MALA_LITERAL &&
 288       mala_stringlist_string (test) == prg->engine->common_string[MALA_STRING_TRUE])
 289     {
 290       MalaStringList code;
 291
 292       mala_program_eval_arg (prg, 2, MALA_BLOCK, &code);
 293       mala_program_eval_arg (prg, 3, MALA_REMOVE, NULL);
 294       mala_stringlist_advance (code);
 295     }
 296   else if (state == MALA_LITERAL &&
 297            mala_stringlist_string (test) == prg->engine->common_string[MALA_STRING_FALSE])
 298     {
 299       mala_program_eval_arg (prg, 2, MALA_REMOVE, NULL);
 300     }
 301   else if (prg->state == MALA_REMOVE)
 302     {
 303       mala_program_eval_arg (prg, 2, MALA_BLOCK, NULL);
 304       mala_program_eval_arg (prg, 3, MALA_BLOCK, NULL);
 305
 306       mala_program_action_done (prg, 3);
 307       return MALA_STATEMENT;
 308     }
 309   else
 310     return mala_program_commonexception (prg, MALA_STRING_ERROR_NOT_A_PREDICATE);
 311
 312   mala_program_action_done (prg, 2);
 313   return MALA_STATEMENT;
 314 }
 315
 316
 317 mala_state
 318 mala_sleep_parser (MalaProgram prg)
 319 {
 320   double duration;
 321   struct timespec req;
 322
 323   if (mala_program_eval_arg_fmt (prg, 1, "%lf", &duration) > MALA_EFAULT)
 324     return mala_program_commonexception (prg, MALA_STRING_ERROR);
 325
 326   MALA_MUTATOR_BEGIN
 327     {
 328       req.tv_sec = (time_t) duration;
 329       req.tv_nsec = (long) 1000000000 * (duration - ((double) req.tv_sec));
 330
 331       (void) nanosleep (&req, NULL);
 332     }
 333   MALA_MUTATOR_END;
 334
 335   mala_program_action_done (prg, 1);
 336   return MALA_STATEMENT;
 337 }
 338
 339 #if 0
 340 int
 341 mala_defined_parser (MalaEngine eng,
 342                      MalaStringListNode_ref pptr,
 343                      void * data)
 344 {
 345   MalaStringListNode result;
 346
 347   (void) data;
 348
 349   result = mala_engine_arg_eval (eng, pptr, 1, MALA_LITERAL);
 350   if (!result)
 351     return eng->state;
 352
 353
 354   mala_engine_command_done (eng, pptr, 1);
 355
 356   //  if (desc && 0 /*TODO mala_actiondesc_top (desc)*/)
 357   //  return MALA_SUCCESS;
 358   //else
 359     return MALA_FAILURE;
 360 }
 361
 362
 363 int
 364 mala_trace_parser (MalaEngine eng,
 365                    MalaStringListNode_ref pptr,
 366                    void * data)
 367 {
 368   (void) data;
 369
 370   /*TODO trace levels*/
 371   MALA_SIDEEFFECT_BEGIN
 372     eng->engine_trace = eng->negated ? MALA_NOTRACE:MALA_TRACE;
 373   MALA_SIDEEFFECT_END;
 374
 375   mala_engine_command_done (eng, pptr, 0);
 376   return MALA_CONTINUE;
 377 }
 378
 379 #if 0
 380 int
 381 mala_gctrace_parser (MalaEngine eng,
 382                    MalaStringListNode_ref pptr,
 383                    void * data)
 384 {
 385   (void) data;
 386
 387   /*TODO trace levels*/
 388   MALA_SIDEEFFECT_BEGIN
 389     *eng->gc_trace = eng->negated ? MALA_NOTRACE:MALA_TRACE;
 390   MALA_SIDEEFFECT_END;
 391
 392   mala_engine_command_done (eng, pptr, 0);
 393   return MALA_CONTINUE;
 394 }
 395 #endif
 396
 397 /*TODO to predicates*/
 398 static int
 399 mala_predicate_greaterorequal_double (double * a, double * b)
 400 {
 401   return *a >= *b;
 402 };
 403
 404
 405 int
 406 mala_not_parser (MalaEngine eng,
 407                  MalaStringListNode_ref pptr,
 408                  void * data)
 409 {
 410   MalaStringListNode result;
 411
 412   (void) data;
 413
 414   MALA_SIDEEFFECT_BEGIN
 415       eng->negated = !eng->negated;
 416   MALA_SIDEEFFECT_END;
 417
 418   result = mala_engine_arg_eval (eng, pptr, 1, MALA_LITERAL);
 419   if (!result)
 420     return eng->state;
 421
 422   mala_engine_command_done (eng, pptr, 1);
 423   return eng->state;
 424 }
 425
 426 int
 427 mala_exception_parser (MalaEngine eng,
 428                        MalaStringListNode_ref pptr,
 429                        void * data)
 430 {
 431   // TODO needs better semantics --EXCEPTION n error  -> --ERROR-error 1 .. n --HERE
 432
 433   (void) data;
 434
 435   mala_engine_arg_eval (eng, pptr, 1, MALA_LITERAL);
 436
 437   //TODO  MALA_SIDEEFFECT_BEGIN
 438   //  {
 439 #if 0 // TODO --PROGRAM
 440   if (mala_stringlist_is_tail (&eng->program, *pptr))
 441     return mala_engine_exception (eng, pptr, *pptr,
 442                                   eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 443 #endif
 444   if (eng->state > MALA_EFAULT)
 445     return eng->state;
 446
 447   MalaString ex = mala_string_new_print (&eng->words, NULL, //TODO refs
 448                                          "--ERROR-%s",
 449                                          mala_stringlistnode_cstr (mala_stringlistnode_next (*pptr)));
 450
 451   // TODO  mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 452   int state = mala_engine_exception (eng, pptr, *pptr, ex);
 453   // TODO mala_stringlist_elem_delete (&eng->program, mala_stringlistnode_next (*pptr));
 454
 455   // TODO review mala_string_free (ex);
 456   //  MALA_SIDEEFFECT_END;
 457
 458   return state;
 459 }
 460
 461 #if 0
 462 int
 463 mala_foreach_word_parser (MalaEngine eng,
 464                           MalaStringListNode_ref pptr,
 465                           void * data)
 466 {
 467   MalaAction act;
 468   MalaStringListNode first;
 469   MalaStringListNode second;
 470   MalaStringListNode last;
 471   MalaStringListNode itr;
 472   (void) data;
 473
 474   /*TODO bugs, rename to --APPLY fixit etc*/
 475
 476   first = mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL);
 477   if (!first)
 478     return eng->state;
 479   act = mala_actiondesc_top ((MalaActionDesc) mala_stringlistnode_user_get (first));
 480   // TODO allow blocks as first arg (define macro and delete it at later)
 481   if (act && act->parser == mala_block_parser)
 482     return mala_engine_exception (eng, pptr, first,
 483                                   eng->common_string[MALA_STRING_ERROR_BLOCK_NOT_ALLOWED]);
 484
 485   second = mala_engine_arg_eval (eng, pptr, 2, -1, (MalaDataFactory) mala_stringlist_factory, NULL);
 486   if (!second)
 487     return eng->state;
 488
 489   last = mala_stringlistnode_next (second);
 490
 491   act = mala_actiondesc_top ((MalaActionDesc) mala_stringlistnode_user_get (second));
 492
 493   // expand second
 494   if (eng->state != MALA_LITERAL)
 495     for (itr = mala_stringlist_tail ((MalaStringList) act->data);
 496          !mala_stringlist_is_end ((MalaStringList) act->data, itr);
 497          mala_stringlistnode_rev (&itr))
 498       {
 499 #if 0 // TODO --PROGRAM
 500         if (!mala_stringlist_after_new (&eng->program,
 501                                         second,
 502                                         mala_stringlistnode_string (itr)))
 503           goto ealloc_node;
 504         if (!mala_stringlist_after_new (&eng->program,
 505                                         second,
 506                                         mala_stringlistnode_string (first)))
 507           goto ealloc_node;
 508 #endif
 509       }
 510   else
 511     {
 512 #if 0
 513       if (!mala_stringlist_after_new (&eng->program,
 514                                       second,
 515                                       mala_stringlistnode_string (second)))
 516         goto ealloc_node;
 517       if (!mala_stringlist_after_new (&eng->program,
 518                                       second,
 519                                       mala_stringlistnode_string (first)))
 520         goto ealloc_node;
 521 #endif
 522     }
 523
 524
 525   // was a block? delete it
 526   if (act && act->parser == mala_block_parser)
 527     mala_actiondesc_pop_delete (mala_stringlistnode_user_get (second));
 528
 529   mala_engine_command_done (eng, pptr, 2);
 530   return MALA_SUCCESS;
 531
 532  ealloc_node:
 533   for (itr = mala_stringlistnode_next (second);
 534        itr != last;
 535        mala_stringlistnode_fwd (&itr))
 536     {
 537       //      mala_stringlist_elem_delete (&eng->program, itr);
 538     }
 539
 540   return MALA_EALLOC; // TODO exception instead (needs pools, no allocation possible further)
 541 }
 542
 543
 544
 545
 546 /*
 547   realloc a string to at least needed size
 548   return the amount really reserved or 0 on error
 549 */
 550 static size_t
 551 reserve_string (char ** s, size_t actual, size_t needed)
 552 {
 553   size_t n;
 554   char * r;
 555
 556   for (n = actual>64?actual:64; n <= needed; n += (n>>1)); /*n = n * 1.5*/
 557
 558   r = realloc (*s, n);
 559   if (!r)
 560     {
 561       /* that was to much, try conservatively */
 562       r = realloc (*s, n = needed);
 563       if (!r)
 564         return 0;
 565     }
 566   *s = r;
 567   return n;
 568 }
 569 #endif
 570
 571
 572 #endif
 573
 574
 575 int
 576 mala_module_std_statements_init (MalaEngine self)
 577 {
 578   return mala_engine_actions_register (self, std_statements);
 579 }
 580
 581 /*
 582 // Local Variables:
 583 // mode: C
 584 // c-file-style: "gnu"
 585 // End:
 586 // arch-tag: 7e2dc784-1527-458a-8881-e87d3fb22cef
 587 // end_of_file
 588 */