std/std_functional.c

   1 /*
   2   std_parsers.c - MaLa standard module 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.h"
  26
  27 static size_t
  28 reserve_string (char ** s, size_t actual, size_t needed);
  29
  30 static void
  31 mala_macrocheck_list (MalaStringList list, int * max_arg, int argt[10]);
  32
  33 static void
  34 mala_macrocheck_string (MalaString string, int * max_arg, int argt[10]);
  35 \f
  36
  37 #if 0
  38     MALA_PARSER("--MAP", mala_map_parser, NULL, NULL, NULL),
  39     MALA_PARSER_BRIEF("--MAP", "TODO applies an action to each element of a nested list"),
  40     MALA_PARSER_HELP("--MAP", ("TODO")),
  41     MALA_PARSER_SIGNATURE_TYPE("--FOREACH-WORD", ("DEFINED-ACTION", "MACRO-LIST")),
  42     MALA_PARSER_SIGNATURE_USAGE("--FOREACH-WORD", ("Action to be applied",
  43                                                    "list of lists")),
  44     MALA_PARSER_RESULT_TYPE("--MAP", ("SEQUENCE")),
  45     MALA_PARSER_RESULT_USAGE("--MAP", ("Resulting Sequence")),
  46
  47
  48     MALA_PARSER("--LENGTH", mala_length_parser, NULL, NULL, NULL),
  49     MALA_PARSER_BRIEF("--LENGTH", "returns the length of a sequence"),
  50     MALA_PARSER_HELP("--LENGTH", ("TODO")),
  51     MALA_PARSER_SIGNATURE_TYPE("--LENGTH", ("SEQUENCE")),
  52     MALA_PARSER_SIGNATURE_USAGE("--LENGTH", ("list of lists")),
  53     MALA_PARSER_RESULT_TYPE("--LENGTH", ("INTEGER")),
  54     MALA_PARSER_RESULT_USAGE("--LENGTH", ("Length of the Sequence")),
  55 #endif
  56
  57 int
  58 mala_substitute_parser (MalaEngine eng,
  59                         MalaStringListNode_ref pptr,
  60                         void * data)
  61 {
  62   (void) eng;
  63
  64   MALA_SIDEEFFECT_BEGIN
  65     mala_stringlistnode_substitute_string (*pptr, (MalaString) data);
  66   MALA_SIDEEFFECT_END;
  67
  68   return MALA_CONTINUE;
  69 }
  70
  71 int
  72 mala_expand_parser (MalaEngine eng,
  73                     MalaStringListNode_ref pptr,
  74                     void * data)
  75 {
  76   MalaStringListNode itr;
  77   MalaStringListNode end;
  78
  79   MALA_SIDEEFFECT_BEGIN
  80     {
  81       end = mala_stringlistnode_next (*pptr);
  82
  83       for (itr = mala_stringlist_tail ((MalaStringList) data);
  84            !mala_stringlist_is_end ((MalaStringList) data, itr);
  85            mala_stringlistnode_rev (&itr))
  86         {
  87           if (!mala_stringlist_after_new (&eng->program, *pptr,
  88                                           mala_stringlistnode_string (itr)))
  89             goto ealloc_node;
  90         }
  91     }
  92   MALA_SIDEEFFECT_END;
  93
  94   mala_engine_command_done (eng, pptr, 0);
  95   return MALA_CONTINUE;
  96
  97  ealloc_node:
  98   /* remove already added things */
  99   for (itr = mala_stringlistnode_next (*pptr);
 100        itr != end;
 101        mala_stringlist_elem_delete_fwd (&eng->program, &itr));
 102
 103   return MALA_EALLOC;
 104 }
 105
 106
 107 int
 108 mala_macro_parser (MalaEngine eng,
 109                    MalaStringListNode_ref pptr,
 110                    void * data)
 111 {
 112   MalaStringListNode itr;
 113   MalaStringListNode last = NULL;
 114   MalaStringList list;
 115   const char* c;
 116   int i;
 117   int max_arg = 0;
 118   int argt[10] = {0};
 119   char *p;
 120   MalaString args[10];
 121   MalaString str = NULL;
 122
 123   // scan how much args are needed
 124   mala_macrocheck_list ((MalaStringList) data, &max_arg, argt);
 125
 126   // evaluate args, fill arg-array
 127   args[0] = mala_stringlistnode_string (*pptr);
 128
 129   for (i = 1; i <= max_arg; ++i)
 130     {
 131       if (!(last = mala_engine_arg_eval (eng, pptr, i, argt[i] == 1 ? -1 : 0, NULL, NULL))
 132           || eng->state > MALA_EFAULT)
 133         return eng->state;
 134
 135       args[i] = mala_stringlistnode_string (last);
 136     }
 137
 138   MALA_SIDEEFFECT_BEGIN
 139     {
 140       // build list with substitutions
 141       list = mala_stringlist_new ();
 142       if (!list)
 143         goto ealloc_list;
 144
 145       for (itr = mala_stringlist_head ((MalaStringList) data);
 146            !mala_stringlist_is_end ((MalaStringList) data, itr);
 147            mala_stringlistnode_fwd (&itr))
 148         {
 149           size_t size = 64;
 150           if (!(p = malloc (size)))
 151             goto ealloc_cstr;
 152
 153           for (c = mala_string_cstr (mala_stringlistnode_string (itr)), i = 0; *c; ++c,++i)
 154             {
 155               if (*c == '%')
 156                 {
 157                   ++c;
 158                   if (*c == '%')
 159                     {
 160                       // %% -> %
 161                       goto normal_char;
 162                     }
 163                   else if (*c >= '0' && *c <= '9')
 164                     {
 165                       // %0..%9
 166                       if (size <= i+mala_string_length (args[*c-'0'])
 167                           && !(size = reserve_string (&p,
 168                                                       size,
 169                                                       1 + i + mala_string_length (args[*c-'0']))))
 170                         goto ealloc_reserve;
 171                       strcpy(p+i, mala_string_cstr (args[*c-'0']));
 172                       i += (mala_string_length (args[*c-'0']) - 1);
 173                     }
 174                   else if (*c == '-')
 175                     {
 176                       ++c;
 177                       if (*c >= '0' && *c <= '9')
 178                         {
 179                           // %0..%9
 180                           if (size <= i+mala_string_length (args[*c-'0'])
 181                               && !(size = reserve_string (&p,
 182                                                           size,
 183                                                           1 + i +
 184                                                           mala_string_length (args[*c-'0']))))
 185                             goto ealloc_reserve;
 186                           strcpy(p+i, mala_string_cstr (args[*c-'0']));
 187                           i += (mala_string_length (args[*c-'0']) - 1);
 188                         }
 189                     }
 190                 }
 191               else
 192                 {
 193                 normal_char:
 194                   // normal char
 195                   if (size <= (size_t) i && !(size = reserve_string (&p, size, (size_t) i+1)))
 196                     goto ealloc_reserve;
 197                   p[i] = *c;
 198                 }
 199             }
 200
 201           p[i] = '\0';
 202
 203           char* ptmp;
 204           if (!(ptmp = realloc (p, size)))
 205             goto ealloc_realloc;
 206
 207           str = mala_string_new_cstr_attach (ptmp, &eng->words);
 208           if (!str)
 209             goto ealloc_string;
 210
 211           if (!mala_stringlist_tail_new (list, str))
 212             goto ealloc_node;
 213
 214           mala_string_free (str);
 215         }
 216
 217
 218       // insert list
 219       for (itr = mala_stringlist_tail (list);
 220            !mala_stringlist_is_end (list, itr);
 221            mala_stringlistnode_rev (&itr))
 222         {
 223           if (!mala_stringlist_after_new (&eng->program, last,
 224                                           mala_stringlistnode_string (itr)))
 225             goto ealloc_program;
 226         }
 227
 228       // cleanup
 229       mala_stringlist_free (list);
 230
 231     }
 232   MALA_SIDEEFFECT_END;
 233
 234   mala_engine_command_done (eng, pptr, max_arg);
 235   return MALA_CONTINUE;
 236
 237  ealloc_program:
 238  ealloc_node:
 239   mala_string_free (str);
 240  ealloc_string:
 241  ealloc_realloc:
 242  ealloc_reserve:
 243   free (p);
 244  ealloc_cstr:
 245   mala_stringlist_free (list);
 246  ealloc_list:
 247   return MALA_EALLOC;
 248 }
 249
 250 int
 251 mala_defined_parser (MalaEngine eng,
 252                      MalaStringListNode_ref pptr,
 253                      void * data)
 254 {
 255   MalaStringListNode result;
 256   MalaActionDesc desc;
 257
 258   (void) data;
 259
 260   result = mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL);
 261   if (!result)
 262     return eng->state;
 263
 264   MALA_SIDEEFFECT_BEGIN
 265     {
 266       desc = (MalaActionDesc) mala_stringlistnode_user_get (result);
 267
 268       mala_engine_command_done (eng, pptr, 1);
 269
 270       if (desc && mala_actiondesc_top (desc))
 271         {
 272           return MALA_SUCCESS;
 273         }
 274       else
 275         {
 276           return MALA_FAILURE;
 277         }
 278     }
 279   MALA_SIDEEFFECT_END;
 280
 281   return MALA_REMOVE;
 282 }
 283
 284 #if 0
 285 int
 286 mala_map_parser (MalaEngine eng,
 287                  MalaStringListNode_ref pptr,
 288                  void * data)
 289 {
 290   MalaStringListNode function;
 291   MalaStringListNode list_of_lists;
 292
 293   (void) data;
 294
 295   result = mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL);
 296   if (!result)
 297     return eng->state;
 298
 299   MALA_SIDEEFFECT_BEGIN
 300     {
 301       desc = (MalaActionDesc) mala_stringlistnode_user_get (result);
 302
 303       mala_engine_command_done (eng, pptr, 1);
 304
 305       if (desc && mala_actiondesc_top (desc))
 306         {
 307           return MALA_SUCCESS;
 308         }
 309       else
 310         {
 311           return MALA_FAILURE;
 312         }
 313     }
 314   MALA_SIDEEFFECT_END;
 315
 316   return MALA_REMOVE;
 317 }
 318 #endif
 319
 320 int
 321 mala_if_parser (MalaEngine eng,
 322                 MalaStringListNode_ref pptr,
 323                 void * data)
 324 {
 325   MalaStringListNode result;
 326   (void) data;
 327   /*TODO negated, blocks, parse long double 0.0 as false*/
 328   /* what with syntax errors like   --IF foo --ELSE ..  (missing 'then' part)*/
 329   int state;
 330
 331   result = mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL);
 332   if (!result)
 333     return eng->state;
 334
 335   MALA_SIDEEFFECT_BEGIN
 336     {
 337       if (eng->state == MALA_LITERAL)
 338         {
 339           if (mala_engine_string_istrue (eng, mala_stringlistnode_string (result)))
 340             eng->state = MALA_SUCCESS;
 341           else
 342             eng->state = MALA_FAILURE;
 343         }
 344
 345       state = eng->state;
 346
 347       if (eng->state == MALA_FAILURE)
 348           eng->state = MALA_REMOVE;
 349
 350       result = mala_engine_arg_eval (eng, pptr, 2, -1, NULL, NULL);
 351       if (!result)
 352         return eng->state;
 353
 354       if (eng->state == MALA_REMOVE)
 355         eng->state = MALA_FAILURE;
 356     }
 357   MALA_SIDEEFFECT_END;
 358
 359   if (eng->state == MALA_LITERAL)
 360     mala_engine_command_done (eng, pptr, 1);
 361   else
 362     mala_engine_command_done (eng, pptr, 2);
 363   return state;
 364 }
 365
 366 int
 367 mala_else_parser (MalaEngine eng,
 368                   MalaStringListNode_ref pptr,
 369                   void * data)
 370 {
 371   MalaStringListNode result;
 372   (void) data;
 373   /*TODO blocks*/
 374
 375   MALA_SIDEEFFECT_BEGIN
 376     {
 377       if (eng->state == MALA_SUCCESS)
 378           eng->state = MALA_REMOVE;
 379
 380       result = mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL);
 381       if (!result)
 382         return eng->state;
 383
 384       if (eng->state == MALA_REMOVE)
 385         eng->state = MALA_SUCCESS;
 386     }
 387   MALA_SIDEEFFECT_END;
 388
 389   if (eng->state == MALA_LITERAL)
 390     mala_engine_command_done (eng, pptr, 0);
 391   else
 392     mala_engine_command_done (eng, pptr, 0);
 393   return eng->state;
 394 }
 395
 396 int
 397 mala_pass_parser (MalaEngine eng,
 398                   MalaStringListNode_ref pptr,
 399                   void * data)
 400 {
 401   (void) data;
 402
 403   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 404
 405   return eng->state;
 406 }
 407
 408 int
 409 mala_trace_parser (MalaEngine eng,
 410                    MalaStringListNode_ref pptr,
 411                    void * data)
 412 {
 413   (void) data;
 414
 415   MALA_SIDEEFFECT_BEGIN
 416     eng->trace = !eng->negated;
 417   MALA_SIDEEFFECT_END;
 418
 419   mala_engine_command_done (eng, pptr, 0);
 420   return MALA_SUCCESS;
 421 }
 422
 423 /*TODO to predicates*/
 424 static int
 425 mala_predicate_greaterorequal_double (double * a, double * b)
 426 {
 427   return *a >= *b;
 428 };
 429
 430 int
 431 mala_sleep_parser (MalaEngine eng,
 432                    MalaStringListNode_ref pptr,
 433                    void * data)
 434 {
 435   double duration;
 436   double zero = 0.0;
 437   struct timespec req;
 438
 439   (void) data;
 440
 441   if (mala_engine_arg_eval_fmt (eng, pptr, 1, "%lf", &duration,
 442                                 (MalaPredicate) mala_predicate_greaterorequal_double, &zero
 443                                 ) >= MALA_EXCEPTION)
 444     return eng->state;
 445
 446   MALA_SIDEEFFECT_BEGIN
 447     {
 448       req.tv_sec = (time_t) duration;
 449       req.tv_nsec = (long) 1000000000 * (duration - ((double) req.tv_sec));
 450
 451       (void) nanosleep (&req, NULL);
 452     }
 453   MALA_SIDEEFFECT_END;
 454
 455   mala_engine_command_done (eng, pptr, 1);
 456   return MALA_SUCCESS;
 457 }
 458
 459 int
 460 mala_literal_parser (MalaEngine eng,
 461                      MalaStringListNode_ref pptr,
 462                      void * data)
 463 {
 464   (void) data;
 465
 466   MALA_SIDEEFFECT_BEGIN
 467     {
 468       if (mala_stringlist_is_tail (&eng->program, *pptr))
 469         return mala_engine_exception (eng, pptr, *pptr,
 470                                       eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 471     }
 472   MALA_SIDEEFFECT_END;
 473
 474   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 475   return MALA_LITERAL;
 476 }
 477
 478 int
 479 mala_not_parser (MalaEngine eng,
 480                  MalaStringListNode_ref pptr,
 481                  void * data)
 482 {
 483   (void) data;
 484   /*TODO evaluate %1*/
 485   MALA_SIDEEFFECT_BEGIN
 486     {
 487       if (mala_stringlist_is_tail (&eng->program, *pptr))
 488         return mala_engine_exception (eng, pptr, *pptr,
 489                                       eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 490     } /*TODO remove unfinished*/
 491   MALA_SIDEEFFECT_END;
 492
 493   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 494   eng->negated = !eng->negated;
 495   return MALA_SUCCESS; /*TODO*/
 496 }
 497
 498 int
 499 mala_begin_parser (MalaEngine eng,
 500                    MalaStringListNode_ref pptr,
 501                    void * data)
 502 {
 503   MalaStringListNode itr;
 504   MalaStringListNode end;
 505   MalaStringList list;
 506   unsigned depth = 1;
 507   MalaString name = NULL;
 508
 509   (void) data;
 510
 511   if (mala_stringlist_is_tail (&eng->program, *pptr))
 512     return mala_engine_exception (eng, pptr, *pptr,
 513                                   eng->common_string[MALA_STRING_ERROR_MISSING_END]);
 514
 515   // find matching --END
 516   for (end = mala_stringlistnode_next (*pptr);
 517        !mala_stringlist_is_end (&eng->program, end);
 518        mala_stringlistnode_fwd (&end))
 519     {
 520       if (mala_string_same(mala_stringlistnode_string (end),
 521                            eng->common_string[MALA_STRING_BEGIN]))
 522         ++depth;
 523       else if (mala_string_same(mala_stringlistnode_string (end),
 524                                 eng->common_string[MALA_STRING_END]))
 525         --depth;
 526       if (!depth)
 527         break;
 528     }
 529
 530   if (depth)
 531     return mala_engine_exception (eng, pptr, mala_stringlistnode_prev (end),
 532                                   eng->common_string[MALA_STRING_ERROR_MISSING_END]);
 533
 534   MALA_SIDEEFFECT_BEGIN
 535     {
 536       list = mala_stringlist_new ();
 537       if (!list)
 538         return MALA_EALLOC;
 539
 540       // copy the block content to list
 541       for (itr = mala_stringlistnode_next (*pptr); itr != end; mala_stringlistnode_fwd (&itr))
 542         if (!mala_stringlist_tail_new (list, mala_stringlistnode_string (itr)))
 543           goto ealloc_node;
 544
 545       // allocate new block name
 546       do {
 547         mala_string_free (name);
 548         name = mala_string_new_print (&eng->words, "--BLOCK_%08X", ++eng->blockcnt);
 549         if (!name)
 550           goto ealloc_name;
 551       } while (mala_actiondesc_top ((MalaActionDesc)mala_string_user_get (name)));
 552
 553       if (MALA_SUCCESS != mala_engine_add_action (eng, name, list,
 554                                                   mala_block_parser,
 555                                                   (MalaDataFactory)mala_stringlist_factory,
 556                                                   NULL))
 557         goto ealloc_action;
 558
 559       // insert new --BLOCK_... in program
 560       if (!mala_stringlist_after_new (&eng->program, end, name))
 561         goto ealloc_node;
 562       mala_string_free (name);
 563     }
 564   else
 565     {
 566       if (!mala_stringlist_after_new (&eng->program,
 567                                       end,
 568                                       eng->common_string[MALA_STRING_PASS]))
 569         goto ealloc_pass;
 570     }
 571   MALA_SIDEEFFECT_END;
 572
 573   // and remove definition
 574   while (*pptr != end)
 575     mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 576
 577   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 578
 579   return MALA_CONTINUE;
 580
 581  ealloc_action:
 582   mala_string_free (name);
 583  ealloc_name:
 584  ealloc_node:
 585   mala_stringlist_free (list);
 586  ealloc_pass:
 587   return MALA_EALLOC;
 588 }
 589
 590 int
 591 mala_block_parser (MalaEngine eng,
 592                    MalaStringListNode_ref pptr,
 593                    void * data)
 594 {
 595   MalaStringListNode itr;
 596   MalaStringListNode end;
 597
 598   MALA_SIDEEFFECT_BEGIN
 599     {
 600       end = mala_stringlistnode_next (*pptr);
 601
 602       for (itr = mala_stringlist_tail ((MalaStringList) data);
 603            !mala_stringlist_is_end ((MalaStringList) data, itr);
 604            mala_stringlistnode_rev (&itr))
 605         {
 606           if (!mala_stringlist_after_new (&eng->program, *pptr,
 607                                           mala_stringlistnode_string (itr)))
 608             goto ealloc_node;
 609         }
 610     }
 611   MALA_SIDEEFFECT_END;
 612
 613   mala_actiondesc_pop_delete (mala_stringlistnode_user_get (*pptr));
 614   mala_engine_command_done (eng, pptr, 0);
 615   return MALA_CONTINUE;
 616
 617  ealloc_node:
 618   /* remove already added things */
 619   for (itr = mala_stringlistnode_next (*pptr);
 620        itr != end;
 621        mala_stringlist_elem_delete_fwd (&eng->program, &itr));
 622
 623   return MALA_EALLOC;
 624 }
 625
 626 int
 627 mala_macrodelete_parser (MalaEngine eng,
 628                          MalaStringListNode_ref pptr,
 629                          void * data)
 630 {
 631   (void) data;
 632
 633   mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL);
 634
 635   MALA_SIDEEFFECT_BEGIN
 636     {
 637       if (mala_stringlist_is_tail (&eng->program, *pptr))
 638         return mala_engine_exception (eng, pptr, *pptr,
 639                                       eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 640
 641       mala_actiondesc_pop_delete (mala_stringlistnode_user_get (mala_stringlistnode_next (*pptr)));
 642     }
 643   MALA_SIDEEFFECT_END;
 644
 645   mala_engine_command_done (eng, pptr, 1);
 646   return MALA_SUCCESS;
 647 }
 648
 649 int
 650 mala_exception_parser (MalaEngine eng,
 651                        MalaStringListNode_ref pptr,
 652                        void * data)
 653 {
 654   // TODO needs better semantics --EXCEPTION n error  -> --ERROR-error 1 .. n --HERE
 655
 656   (void) data;
 657
 658   mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL);
 659
 660   //TODO  MALA_SIDEEFFECT_BEGIN
 661   //  {
 662   if (mala_stringlist_is_tail (&eng->program, *pptr))
 663     return mala_engine_exception (eng, pptr, *pptr,
 664                                   eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 665
 666   if (eng->state > MALA_EFAULT)
 667     return eng->state;
 668
 669   MalaString ex = mala_string_new_print (&eng->words, "--ERROR-%s",
 670                                          mala_stringlistnode_cstr (mala_stringlistnode_next (*pptr)));
 671
 672   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 673   int state = mala_engine_exception (eng, pptr, *pptr, ex);
 674   mala_stringlist_elem_delete (&eng->program, mala_stringlistnode_next (*pptr));
 675
 676   mala_string_free (ex);
 677   //  MALA_SIDEEFFECT_END;
 678
 679   return state;
 680 }
 681
 682 int
 683 mala_end_parser (MalaEngine eng,
 684                  MalaStringListNode_ref pptr,
 685                  void * data)
 686 {
 687   (void) data;
 688
 689   return mala_engine_exception (eng, pptr, *pptr,
 690                                 eng->common_string[MALA_STRING_ERROR_END_WITHOUT_BEGIN]);
 691 }
 692
 693 static void
 694 mala_macrocheck_list (MalaStringList list, int * max_arg, int argt[10])
 695 {
 696   MalaStringListNode itr;
 697   for (itr = mala_stringlist_head (list);
 698        !mala_stringlist_is_end (list, itr);
 699        mala_stringlistnode_fwd (&itr))
 700     {
 701       mala_macrocheck_string (mala_stringlistnode_string (itr), max_arg, argt);
 702       if (*max_arg == -1)
 703         return;
 704     }
 705 }
 706
 707 static void
 708 mala_macrocheck_string (MalaString string, int * max_arg, int argt[10])
 709 {
 710   const char * c;
 711   for (c = mala_string_cstr (string); *c; ++c)
 712     {
 713       // "foo%1%-2"
 714       if (*c == '%')
 715         {
 716           // %
 717           ++c;
 718           if (*c == '%')
 719             // %%
 720             continue;
 721           if (*c == '-')
 722             {
 723               // %-
 724               ++c;
 725               if (*c >= '0' && *c <= '9')
 726                 {
 727                   // %-0 .. %-9
 728                   if (argt[*c - '0'] == 1)
 729                     goto esyntax;
 730                   if (*c > (char) *max_arg + '0')
 731                     *max_arg = *c - '0';
 732                   argt[*c - '0'] = -1;
 733                 }
 734               else
 735                 goto esyntax;
 736             }
 737           else if (*c >= '0' && *c <= '9')
 738             {
 739               // %0 .. %9
 740               if (argt[*c - '0'] == -1)
 741                 goto esyntax;
 742               if (*c > (char) *max_arg + '0')
 743                 *max_arg = *c - '0';
 744               argt[*c - '0'] = 1;
 745             }
 746           else
 747             goto esyntax;
 748         }
 749     }
 750   return;
 751
 752  esyntax:
 753   *max_arg = -1;
 754   return;
 755 }
 756
 757 int
 758 mala_macrodef_parser (MalaEngine eng,
 759                       MalaStringListNode_ref pptr,
 760                       void * data)
 761 {
 762   int i;
 763   MalaStringListNode itr;
 764   MalaStringListNode arg[2];
 765   MalaString name;
 766   MalaAction act;
 767
 768   (void) data;
 769
 770   // evaluate both args
 771   if (!mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL))
 772     return eng->state;
 773   if (!mala_engine_arg_eval (eng, pptr, 2, -1, NULL, mala_block_parser))
 774     return eng->state;
 775
 776   MALA_SIDEEFFECT_BEGIN
 777     {
 778       // test if 2 arguments left and assign them to arg[], else error
 779       for (i = 0, itr = *pptr; i<2; ++i, mala_stringlistnode_fwd(&itr))
 780         {
 781           if (mala_stringlist_is_tail (&eng->program, itr))
 782             return mala_engine_exception (eng, pptr, itr,
 783                                           eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 784           arg[i] = mala_stringlistnode_next (itr);
 785         }
 786
 787       // if name is a block then error
 788       name = mala_stringlistnode_string (arg[0]);
 789       act = mala_actiondesc_top ((MalaActionDesc) mala_string_user_get (name));
 790       if (act && act->parser == mala_block_parser)
 791         return mala_engine_exception (eng, pptr, arg[0],
 792                                       eng->common_string[MALA_STRING_ERROR_BLOCK_NOT_ALLOWED]);
 793
 794       //expansion check and optimize block
 795       act = mala_actiondesc_top ((MalaActionDesc) mala_stringlistnode_user_get (arg[1]));
 796       if (act && act->factory == (MalaDataFactory) mala_stringlist_factory)
 797         {
 798           int max_arg = 0;
 799           int argt[10] = {0};
 800           mala_macrocheck_list ((MalaStringList) act->data, &max_arg, argt);
 801           // convert block to expansion
 802           if (max_arg > 0)
 803             {
 804               //macro
 805               MalaActionDesc desc;
 806               desc = mala_actiondesc_ensure (name);
 807               if (!desc)
 808                 return MALA_EALLOC;
 809
 810               act = mala_actiondesc_pop ((MalaActionDesc) mala_stringlistnode_user_get (arg[1]));
 811               act->name = name;
 812               act->parser = mala_macro_parser;
 813               mala_actiondesc_push_action (desc, act);
 814             }
 815           else if (mala_stringlist_is_single ((MalaStringList) act->data))
 816             {
 817               //substitute
 818               MalaString subst;
 819               subst = mala_stringlist_head_string_copy ((MalaStringList) act->data);
 820
 821               if (MALA_SUCCESS != mala_engine_add_action (eng, name, subst,
 822                                                           mala_substitute_parser,
 823                                                           (MalaDataFactory) mala_string_factory,
 824                                                           NULL))
 825                 return MALA_EALLOC;
 826
 827               mala_action_free(act);
 828             }
 829           else if (max_arg == 0)
 830             {
 831               //expand
 832               MalaActionDesc desc;
 833               desc = mala_actiondesc_ensure (name);
 834               if (!desc)
 835                 return MALA_EALLOC;
 836
 837               act = mala_actiondesc_pop ((MalaActionDesc) mala_stringlistnode_user_get (arg[1]));
 838               act->name = name;
 839               act->parser = mala_expand_parser;
 840               mala_actiondesc_push_action (desc, act);
 841             }
 842           else
 843             return mala_engine_exception (eng, pptr, arg[1],
 844                                           eng->common_string[MALA_STRING_ERROR_PARAMETER_SYNTAX]);
 845         }
 846       else //if (act && act->factory == (MalaDataFactory)mala_string_factory)
 847         {
 848           // single word
 849           int max_arg = 0;
 850           int argt[10] = {0};
 851           mala_macrocheck_string (mala_stringlistnode_string (arg[1]), &max_arg, argt);
 852           if (max_arg == 0)
 853             {
 854               // substitute
 855               if (MALA_SUCCESS != mala_engine_add_action (eng, name,
 856                                                           mala_stringlistnode_string_copy (arg[1]),
 857                                                           mala_substitute_parser,
 858                                                           (MalaDataFactory) mala_string_factory,
 859                                                           NULL))
 860                 return MALA_EALLOC;
 861             }
 862           else if (max_arg > 0)
 863             {
 864               // macro
 865               MalaStringList list;
 866
 867               list = mala_stringlist_new ();
 868               if (!list)
 869                 return MALA_EALLOC;
 870
 871               mala_stringlist_tail_new (list, mala_stringlistnode_string (arg[1]));
 872
 873               if (MALA_SUCCESS != mala_engine_add_action (eng, name, list,
 874                                                           mala_macro_parser,
 875                                                           (MalaDataFactory) mala_stringlist_factory,
 876                                                           NULL))
 877                 return MALA_EALLOC;
 878             }
 879           else // syntax error
 880             return mala_engine_exception (eng, pptr, arg[1],
 881                                           eng->common_string[MALA_STRING_ERROR_PARAMETER_SYNTAX]);
 882         }
 883     }
 884   MALA_SIDEEFFECT_END;
 885
 886   mala_engine_command_done (eng, pptr, 2);
 887   return MALA_SUCCESS;
 888 }
 889
 890 int
 891 mala_foreach_word_parser (MalaEngine eng,
 892                           MalaStringListNode_ref pptr,
 893                           void * data)
 894 {
 895   MalaAction act;
 896   MalaStringListNode first;
 897   MalaStringListNode second;
 898   MalaStringListNode last;
 899   MalaStringListNode itr;
 900   (void) data;
 901
 902   /*TODO bugs, rename to --APPLY fixit etc*/
 903
 904   first = mala_engine_arg_eval (eng, pptr, 1, -1, NULL, NULL);
 905   if (!first)
 906     return eng->state;
 907   act = mala_actiondesc_top ((MalaActionDesc) mala_stringlistnode_user_get (first));
 908   // TODO allow blocks as first arg (define macro and delete it at later)
 909   if (act && act->parser == mala_block_parser)
 910     return mala_engine_exception (eng, pptr, first,
 911                                   eng->common_string[MALA_STRING_ERROR_BLOCK_NOT_ALLOWED]);
 912
 913   second = mala_engine_arg_eval (eng, pptr, 2, -1, (MalaDataFactory) mala_stringlist_factory, NULL);
 914   if (!second)
 915     return eng->state;
 916
 917   last = mala_stringlistnode_next (second);
 918
 919   act = mala_actiondesc_top ((MalaActionDesc) mala_stringlistnode_user_get (second));
 920
 921   // expand second
 922   if (eng->state != MALA_LITERAL)
 923     for (itr = mala_stringlist_tail ((MalaStringList) act->data);
 924          !mala_stringlist_is_end ((MalaStringList) act->data, itr);
 925          mala_stringlistnode_rev (&itr))
 926       {
 927         if (!mala_stringlist_after_new (&eng->program,
 928                                         second,
 929                                         mala_stringlistnode_string (itr)))
 930           goto ealloc_node;
 931         if (!mala_stringlist_after_new (&eng->program,
 932                                         second,
 933                                         mala_stringlistnode_string (first)))
 934           goto ealloc_node;
 935       }
 936   else
 937     {
 938       if (!mala_stringlist_after_new (&eng->program,
 939                                       second,
 940                                       mala_stringlistnode_string (second)))
 941         goto ealloc_node;
 942       if (!mala_stringlist_after_new (&eng->program,
 943                                       second,
 944                                       mala_stringlistnode_string (first)))
 945         goto ealloc_node;
 946     }
 947
 948
 949   // was a block? delete it
 950   if (act && act->parser == mala_block_parser)
 951     mala_actiondesc_pop_delete (mala_stringlistnode_user_get (second));
 952
 953   mala_engine_command_done (eng, pptr, 2);
 954   return MALA_SUCCESS;
 955
 956  ealloc_node:
 957   for (itr = mala_stringlistnode_next (second);
 958        itr != last;
 959        mala_stringlistnode_fwd (&itr))
 960     {
 961       mala_stringlist_elem_delete (&eng->program, itr);
 962     }
 963
 964   return MALA_EALLOC; // TODO exception instead (needs pools, no allocation possible further)
 965 }
 966
 967
 968
 969
 970 /*
 971   realloc a string to at least needed size
 972   return the amount really reserved or 0 on error
 973 */
 974 static size_t
 975 reserve_string (char ** s, size_t actual, size_t needed)
 976 {
 977   size_t n;
 978   char * r;
 979
 980   for (n = actual>64?actual:64; n <= needed; n += (n>>1)); /*n = n * 1.5*/
 981
 982   r = realloc (*s, n);
 983   if (!r)
 984     {
 985       /* that was to much, try conservatively */
 986       r = realloc (*s, n = needed);
 987       if (!r)
 988         return 0;
 989     }
 990   *s = r;
 991   return n;
 992 }
 993
 994
 995 /*
 996 // Local Variables:
 997 // mode: C
 998 // c-file-style: "gnu"
 999 // End:
1000 // arch-tag: 195047fd-d18b-4af6-a627-43e5655162ed
1001 // end_of_file
1002 */