std/std_parsers.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
  23 #include "mala.h"
  24 #include "std.h"
  25
  26 static size_t
  27 reserve_string (char ** s, size_t actual, size_t needed);
  28
  29 static void
  30 mala_macrocheck_list (MalaStringList list, int * max_arg, int argt[10]);
  31
  32 static void
  33 mala_macrocheck_string (MalaString string, int * max_arg, int argt[10]);
  34 \f
  35
  36 int
  37 mala_substitute_parser (MalaEngine eng,
  38                         MalaStringListNode_ref pptr,
  39                         void * data)
  40 {
  41   if (!mala_stringlist_after_new (&eng->program, *pptr, (MalaString) data))
  42     return MALA_EALLOC;
  43
  44   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
  45
  46   return MALA_SUCCESS;
  47 }
  48
  49 int
  50 mala_expand_parser (MalaEngine eng,
  51                     MalaStringListNode_ref pptr,
  52                     void * data)
  53 {
  54   MalaStringListNode itr;
  55   MalaStringListNode end;
  56
  57   end = mala_stringlist_next (*pptr);
  58
  59   for (itr = mala_stringlist_tail ((MalaStringList) data);
  60        !mala_stringlist_is_end ((MalaStringList) data, itr);
  61        mala_stringlist_rev (&itr))
  62     {
  63       if (!mala_stringlist_after_new (&eng->program, *pptr, itr->string))
  64         goto ealloc_node;
  65     }
  66
  67   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
  68
  69   return MALA_SUCCESS;
  70
  71  ealloc_node:
  72   /* remove already added things */
  73   for (itr = mala_stringlist_next (*pptr);
  74        itr != end;
  75        mala_stringlist_elem_delete_fwd (&eng->program, &itr));
  76
  77   return MALA_EALLOC;
  78 }
  79
  80
  81 int
  82 mala_macro_parser (MalaEngine eng,
  83                    MalaStringListNode_ref pptr,
  84                    void * data)
  85 {
  86   MalaStringListNode itr;
  87   MalaStringListNode last = NULL;
  88   MalaStringList list;
  89   const char* c;
  90   int i;
  91   int max_arg = 0;
  92   int argt[10] = {0};
  93   char *p;
  94   MalaString args[10];
  95   MalaString str = NULL;
  96
  97
  98   // scan how much args are needed
  99   mala_macrocheck_list ((MalaStringList) data, &max_arg, argt);
 100
 101   // evaluate args, fill arg-array
 102   args[0] = (*pptr)->string;
 103
 104   for (i = 1; i <= max_arg; ++i)
 105     {
 106       if (!(last = mala_engine_arg_eval (eng, pptr, i, argt[i] == 1 ? -1 : 0, NULL))
 107           || eng->state > MALA_EFAULT)
 108         return eng->state;
 109
 110       args[i] = last->string;
 111     }
 112
 113   // build list with substitutions
 114   list = mala_stringlist_new ();
 115   if (!list)
 116     goto ealloc_list;
 117
 118   for (itr = mala_stringlist_head ((MalaStringList) data);
 119        !mala_stringlist_is_end ((MalaStringList) data, itr);
 120        mala_stringlist_fwd (&itr))
 121     {
 122       size_t size = 64;
 123       if (!(p = malloc (size)))
 124         goto ealloc_cstr;
 125
 126       for (c = mala_string_cstr (itr->string), i = 0; *c; ++c,++i)
 127         {
 128           if (*c == '%')
 129             {
 130               ++c;
 131               if (*c == '%')
 132                 {
 133                   // %% -> %
 134                   goto normal_char;
 135                 }
 136               else if (*c >= '0' && *c <= '9')
 137                 {
 138                   // %0..%9
 139                   if (size <= i+mala_string_length (args[*c-'0'])
 140                       && !(size = reserve_string (&p,
 141                                                   size,
 142                                                   1 + i + mala_string_length (args[*c-'0']))))
 143                     goto ealloc_reserve;
 144                   strcpy(p+i, mala_string_cstr (args[*c-'0']));
 145                   i += (mala_string_length (args[*c-'0']) - 1);
 146                 }
 147               else if (*c == '-')
 148                 {
 149                   ++c;
 150                   if (*c >= '0' && *c <= '9')
 151                     {
 152                       // %0..%9
 153                       if (size <= i+mala_string_length (args[*c-'0'])
 154                           && !(size = reserve_string (&p,
 155                                                       size,
 156                                                       1 + i +
 157                                                       mala_string_length (args[*c-'0']))))
 158                         goto ealloc_reserve;
 159                       strcpy(p+i, mala_string_cstr (args[*c-'0']));
 160                       i += (mala_string_length (args[*c-'0']) - 1);
 161                     }
 162                 }
 163             }
 164           else
 165             {
 166             normal_char:
 167               // normal char
 168               if (size <= (size_t) i && !(size = reserve_string (&p, size, (size_t) i+1)))
 169                 goto ealloc_reserve;
 170               p[i] = *c;
 171             }
 172         }
 173
 174       p[i] = '\0';
 175
 176       char* ptmp;
 177       if (!(ptmp = realloc (p, size)))
 178         goto ealloc_realloc;
 179
 180       str = mala_string_new_cstr_attach (ptmp, &eng->words); /*TODO try without bucket?*/
 181       if (!str)
 182         goto ealloc_string;
 183
 184       if (!mala_stringlist_tail_new (list, str))
 185         goto ealloc_node;
 186
 187       mala_string_free (str);
 188     }
 189
 190
 191   // insert list
 192   for (itr = mala_stringlist_tail (list);
 193        !mala_stringlist_is_end (list, itr);
 194        mala_stringlist_rev (&itr))
 195     {
 196       if (!mala_stringlist_after_new (&eng->program, last, itr->string))
 197         goto ealloc_program;
 198     }
 199
 200   // cleanup
 201   mala_stringlist_free (list);
 202
 203   do
 204     mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 205   while (max_arg--);
 206
 207   return MALA_SUCCESS;
 208
 209  ealloc_program:
 210  ealloc_node:
 211   mala_string_free (str);
 212  ealloc_string:
 213  ealloc_realloc:
 214  ealloc_reserve:
 215   free (p);
 216  ealloc_cstr:
 217   mala_stringlist_free (list);
 218  ealloc_list:
 219   return MALA_EALLOC;
 220 }
 221
 222 int
 223 mala_null_parser (MalaEngine eng,
 224                   MalaStringListNode_ref pptr,
 225                   void * data)
 226 {
 227   (void) data;
 228   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 229   return eng->state;
 230 }
 231
 232 int
 233 mala_newline_parser (MalaEngine eng,
 234                      MalaStringListNode_ref pptr,
 235                      void * data)
 236 {
 237   (void) data;
 238
 239   if (eng->state > MALA_EFAULT)
 240     return eng->state;
 241
 242   putchar('\n');
 243
 244   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 245   return MALA_SUCCESS;
 246 }
 247 int
 248
 249 mala_print_parser (MalaEngine eng,
 250                    MalaStringListNode_ref pptr,
 251                    void * data)
 252 {
 253   (void) data;
 254
 255   mala_engine_arg_eval (eng, pptr, 1, -1, NULL);
 256
 257   if (mala_stringlist_is_tail (&eng->program, *pptr))
 258     return mala_engine_exception (eng, pptr, *pptr,
 259                                   eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 260
 261   if (eng->state > MALA_EFAULT)
 262     return eng->state;
 263
 264   // TODO print blocks ?
 265
 266   printf("%s",mala_string_cstr (mala_stringlist_next (*pptr)->string));
 267
 268   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 269   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 270   return MALA_SUCCESS;
 271 }
 272
 273 int
 274 mala_literal_parser (MalaEngine eng,
 275                      MalaStringListNode_ref pptr,
 276                      void * data)
 277 {
 278   (void) data;
 279
 280   if (eng->state > MALA_EFAULT)
 281     return eng->state;
 282
 283   if (mala_stringlist_is_tail (&eng->program, *pptr))
 284     return mala_engine_exception (eng, pptr, *pptr,
 285                                   eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 286
 287   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 288   return MALA_LITERAL;
 289 }
 290
 291 int
 292 mala_not_parser (MalaEngine eng,
 293                  MalaStringListNode_ref pptr,
 294                  void * data)
 295 {
 296   (void) data;
 297
 298   if (eng->state > MALA_EFAULT)
 299     return eng->state;
 300
 301   if (mala_stringlist_is_tail (&eng->program, *pptr))
 302     return mala_engine_exception (eng, pptr, *pptr,
 303                                   eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 304
 305   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 306   eng->negated = !eng->negated;
 307   return MALA_SUCCESS;
 308 }
 309
 310 int
 311 mala_begin_parser (MalaEngine eng,
 312                    MalaStringListNode_ref pptr,
 313                    void * data)
 314 {
 315   MalaStringListNode itr;
 316   MalaStringListNode end;
 317   MalaStringList list;
 318   unsigned depth = 1;
 319   MalaString name = NULL;
 320
 321   (void) data;
 322
 323   if (mala_stringlist_is_tail (&eng->program, *pptr))
 324     return mala_engine_exception (eng, pptr, *pptr,
 325                                   eng->common_string[MALA_STRING_ERROR_MISSING_END]);
 326
 327   // find matching --END
 328   for (end = mala_stringlist_next (*pptr);
 329        !mala_stringlist_is_end (&eng->program, end);
 330        mala_stringlist_fwd (&end))
 331     {
 332       if (mala_string_same(end->string, eng->common_string[MALA_STRING_BEGIN]))
 333         ++depth;
 334       else if (mala_string_same(end->string, eng->common_string[MALA_STRING_END]))
 335         --depth;
 336       if (!depth)
 337         break;
 338     }
 339
 340   if (depth)
 341     return mala_engine_exception (eng, pptr, mala_stringlist_prev (end),
 342                                   eng->common_string[MALA_STRING_ERROR_MISSING_END]);
 343
 344   list = mala_stringlist_new ();
 345   if (!list)
 346     return MALA_EALLOC;
 347
 348   // copy the block content to list
 349   for (itr = mala_stringlist_next (*pptr); itr != end; mala_stringlist_fwd (&itr))
 350       if (!mala_stringlist_tail_new (list, itr->string))
 351         goto ealloc_node;
 352
 353   // allocate new block name
 354   do {
 355     mala_string_free (name);
 356     name = mala_string_new_print (&eng->words, "--BLOCK_%08X", ++eng->blockcnt);
 357     if (!name)
 358       goto ealloc_name;
 359   } while (mala_actiondesc_top ((MalaActionDesc)mala_string_user_get (name)));
 360
 361   if (MALA_SUCCESS != mala_engine_add_action (eng, name, list,
 362                                               mala_block_parser,
 363                                               (MalaDataFactory)mala_stringlist_factory,
 364                                               NULL))
 365     goto ealloc_action;
 366
 367   // insert new --BLOCK_... in program
 368   mala_stringlist_after_new (&eng->program, end, name);
 369   mala_string_free (name);
 370   // and remove its definition
 371   while (*pptr != end)
 372     mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 373   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 374
 375   return MALA_DELAY;
 376
 377  ealloc_action:
 378   mala_string_free (name);
 379  ealloc_name:
 380  ealloc_node:
 381   mala_stringlist_free (list);
 382   return MALA_EALLOC;
 383 }
 384
 385 int
 386 mala_block_parser (MalaEngine eng,
 387                    MalaStringListNode_ref pptr,
 388                    void * data)
 389 {
 390   (void) data;
 391
 392   if (eng->state > MALA_EFAULT)
 393     return eng->state;
 394
 395   mala_actiondesc_pop_delete (mala_string_user_get ((*pptr)->string));
 396
 397   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 398   return MALA_SUCCESS;
 399 }
 400
 401 int
 402 mala_macrodelete_parser (MalaEngine eng,
 403                          MalaStringListNode_ref pptr,
 404                          void * data)
 405 {
 406   (void) data;
 407
 408   if (eng->state > MALA_EFAULT)
 409     return eng->state;
 410
 411   mala_engine_arg_eval (eng, pptr, 1, -1, NULL);
 412
 413   if (mala_stringlist_is_tail (&eng->program, *pptr))
 414     return mala_engine_exception (eng, pptr, *pptr,
 415                                   eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 416
 417   mala_actiondesc_pop_delete (mala_string_user_get (mala_stringlist_next (*pptr)->string));
 418
 419   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 420   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 421   return MALA_SUCCESS;
 422 }
 423
 424 int
 425 mala_exception_parser (MalaEngine eng,
 426                        MalaStringListNode_ref pptr,
 427                        void * data)
 428 {
 429   // TODO needs better semantics --EXCEPTION n error  -> --ERROR-error 1 .. n --HERE
 430
 431   (void) data;
 432
 433   mala_engine_arg_eval (eng, pptr, 1, -1, NULL);
 434
 435   if (mala_stringlist_is_tail (&eng->program, *pptr))
 436     return mala_engine_exception (eng, pptr, *pptr,
 437                                   eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 438
 439   if (eng->state > MALA_EFAULT)
 440     return eng->state;
 441
 442   MalaString ex = mala_string_new_print (&eng->words, "--ERROR-%s",
 443                                          mala_string_cstr (mala_stringlist_next (*pptr)->string));
 444
 445   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 446   int state = mala_engine_exception (eng, pptr, *pptr, ex);
 447   mala_stringlist_elem_delete (&eng->program, mala_stringlist_next (*pptr));
 448
 449   mala_string_free (ex);
 450
 451   return state;
 452 }
 453
 454 int
 455 mala_end_parser (MalaEngine eng,
 456                  MalaStringListNode_ref pptr,
 457                  void * data)
 458 {
 459   (void) data;
 460
 461   return mala_engine_exception (eng, pptr, *pptr,
 462                                 eng->common_string[MALA_STRING_ERROR_END_WITHOUT_BEGIN]);
 463 }
 464
 465 static void
 466 mala_macrocheck_list (MalaStringList list, int * max_arg, int argt[10])
 467 {
 468   MalaStringListNode itr;
 469   for (itr = mala_stringlist_head (list);
 470        !mala_stringlist_is_end (list, itr);
 471        mala_stringlist_fwd (&itr))
 472     {
 473       mala_macrocheck_string (itr->string, max_arg, argt);
 474       if (*max_arg == -1)
 475         return;
 476     }
 477 }
 478
 479 static void
 480 mala_macrocheck_string (MalaString string, int * max_arg, int argt[10])
 481 {
 482   const char * c;
 483   for (c = mala_string_cstr (string); *c; ++c)
 484     {
 485       // "foo%1%-2"
 486       if (*c == '%')
 487         {
 488           // %
 489           ++c;
 490           if (*c == '%')
 491             // %%
 492             continue;
 493           if (*c == '-')
 494             {
 495               // %-
 496               ++c;
 497               if (*c >= '0' && *c <= '9')
 498                 {
 499                   // %-0 .. %-9
 500                   if (argt[*c - '0'] == 1)
 501                     goto esyntax;
 502                   if (*c > (char) *max_arg + '0')
 503                     *max_arg = *c - '0';
 504                   argt[*c - '0'] = -1;
 505                 }
 506               else
 507                 goto esyntax;
 508             }
 509           else if (*c >= '0' && *c <= '9')
 510             {
 511               // %0 .. %9
 512               if (argt[*c - '0'] == -1)
 513                 goto esyntax;
 514               if (*c > (char) *max_arg + '0')
 515                 *max_arg = *c - '0';
 516               argt[*c - '0'] = 1;
 517             }
 518           else
 519             goto esyntax;
 520           }
 521       }
 522   return;
 523
 524  esyntax:
 525   *max_arg = -1;
 526   return;
 527 }
 528
 529 int
 530 mala_macrodef_parser (MalaEngine eng,
 531                       MalaStringListNode_ref pptr,
 532                       void * data)
 533 {
 534   int i;
 535   MalaStringListNode itr;
 536   MalaStringListNode arg[2];
 537   MalaString name;
 538   MalaAction act;
 539
 540   (void) data;
 541
 542
 543   // evaluate both args
 544   if (!mala_engine_arg_eval (eng, pptr, 1, -1, NULL))
 545     return eng->state;
 546   if (!mala_engine_arg_eval (eng, pptr, 2, -1, NULL))
 547     return eng->state;
 548
 549   // test if 2 arguments left and assign them to arg[], else error
 550   for (i = 0, itr = *pptr; i<2; ++i, mala_stringlist_fwd(&itr))
 551     {
 552       if (mala_stringlist_is_tail (&eng->program, itr))
 553         return mala_engine_exception (eng, pptr, itr,
 554                                       eng->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 555       arg[i] = mala_stringlist_next (itr);
 556     }
 557
 558   // if name is a block then error
 559   name = arg[0]->string;
 560   act = mala_actiondesc_top ((MalaActionDesc) mala_string_user_get (name));
 561   if (act && act->parser == mala_block_parser)
 562     return mala_engine_exception (eng, pptr, arg[0],
 563                                   eng->common_string[MALA_STRING_ERROR_BLOCK_NOT_ALLOWED]);
 564
 565   //expansion check and optimize block
 566   act = mala_actiondesc_top ((MalaActionDesc) mala_string_user_get (arg[1]->string));
 567   if (act && act->factory == (MalaDataFactory) mala_stringlist_factory)
 568     {
 569       int max_arg = 0;
 570       int argt[10] = {0};
 571       mala_macrocheck_list ((MalaStringList) act->data, &max_arg, argt);
 572       // convert block to expansion
 573       if (max_arg > 0)
 574         {
 575           //macro
 576           MalaActionDesc desc;
 577           desc = mala_actiondesc_ensure (name);
 578           if (!desc)
 579             return MALA_EALLOC;
 580
 581           act = mala_actiondesc_pop ((MalaActionDesc) mala_string_user_get (arg[1]->string));
 582           act->name = name;
 583           act->parser = mala_macro_parser;
 584           mala_actiondesc_push_action (desc, act);
 585         }
 586       else if (mala_stringlist_is_single ((MalaStringList) act->data))
 587         {
 588           //substitute
 589           MalaString subst;
 590           subst = mala_string_copy (mala_stringlist_head((MalaStringList) act->data)->string);
 591
 592           if (MALA_SUCCESS != mala_engine_add_action (eng, name, subst,
 593                                                       mala_substitute_parser,
 594                                                       (MalaDataFactory) mala_string_factory,
 595                                                       NULL))
 596               return MALA_EALLOC;
 597
 598           mala_action_free(act);
 599         }
 600       else if (max_arg == 0)
 601         {
 602           //expand
 603           MalaActionDesc desc;
 604           desc = mala_actiondesc_ensure (name);
 605           if (!desc)
 606             return MALA_EALLOC;
 607
 608           act = mala_actiondesc_pop ((MalaActionDesc) mala_string_user_get (arg[1]->string));
 609           act->name = name;
 610           act->parser = mala_expand_parser;
 611           mala_actiondesc_push_action (desc, act);
 612         }
 613       else
 614         return mala_engine_exception (eng, pptr, arg[1],
 615                                       eng->common_string[MALA_STRING_ERROR_PARAMETER_SYNTAX]);
 616     }
 617   else //if (act && act->factory == (MalaDataFactory)mala_string_factory)
 618     {
 619       // single word
 620       int max_arg = 0;
 621       int argt[10] = {0};
 622       mala_macrocheck_string (arg[1]->string, &max_arg, argt);
 623       if (max_arg == 0)
 624         {
 625           // substitute
 626           if (MALA_SUCCESS != mala_engine_add_action (eng, name,
 627                                                       mala_string_copy (arg[1]->string),
 628                                                       mala_substitute_parser,
 629                                                       (MalaDataFactory) mala_string_factory,
 630                                                       NULL))
 631             return MALA_EALLOC;
 632         }
 633       else if (max_arg > 0)
 634         {
 635           // macro
 636           MalaStringList list;
 637
 638           list = mala_stringlist_new ();
 639           if (!list)
 640             return MALA_EALLOC;
 641
 642           mala_stringlist_tail_new (list, arg[1]->string);
 643
 644           if (MALA_SUCCESS != mala_engine_add_action (eng, name, list,
 645                                                       mala_macro_parser,
 646                                                       (MalaDataFactory) mala_stringlist_factory,
 647                                                       NULL))
 648             return MALA_EALLOC;
 649         }
 650       else // syntax error
 651         return mala_engine_exception (eng, pptr, arg[1],
 652                                       eng->common_string[MALA_STRING_ERROR_PARAMETER_SYNTAX]);
 653     }
 654
 655   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 656   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 657   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 658   return MALA_SUCCESS;
 659 }
 660
 661 int
 662 mala_foreach_word_parser (MalaEngine eng,
 663                           MalaStringListNode_ref pptr,
 664                           void * data)
 665 {
 666   MalaAction act;
 667   MalaStringListNode first;
 668   MalaStringListNode second;
 669   MalaStringListNode last;
 670   MalaStringListNode itr;
 671   (void) data;
 672
 673   first = mala_engine_arg_eval (eng, pptr, 1, -1, NULL);
 674   if (!first)
 675     return eng->state;
 676   act = mala_actiondesc_top ((MalaActionDesc) mala_string_user_get (first->string));
 677   // TODO allow blocks as first arg (define macro and delete it at later)
 678   if (act && act->parser == mala_block_parser)
 679     return mala_engine_exception (eng, pptr, first,
 680                                   eng->common_string[MALA_STRING_ERROR_BLOCK_NOT_ALLOWED]);
 681
 682   second = mala_engine_arg_eval (eng, pptr, 2, -1, (MalaDataFactory) mala_stringlist_factory);
 683   if (!second)
 684     return eng->state;
 685
 686   last = mala_stringlist_next (second);
 687
 688   act = mala_actiondesc_top ((MalaActionDesc) mala_string_user_get (second->string));
 689
 690   // expand second
 691   if (eng->state != MALA_LITERAL)
 692     for (itr = mala_stringlist_tail ((MalaStringList) act->data);
 693          !mala_stringlist_is_end ((MalaStringList) act->data, itr);
 694          mala_stringlist_rev (&itr))
 695       {
 696         if (!mala_stringlist_after_new (&eng->program, second, itr->string))
 697           goto ealloc_node;
 698         if (!mala_stringlist_after_new (&eng->program, second, first->string))
 699           goto ealloc_node;
 700       }
 701   else
 702       {
 703         if (!mala_stringlist_after_new (&eng->program, second, second->string))
 704           goto ealloc_node;
 705         if (!mala_stringlist_after_new (&eng->program, second, first->string))
 706           goto ealloc_node;
 707       }
 708
 709
 710   // was a block? delete it
 711   if (act && act->parser == mala_block_parser)
 712     mala_actiondesc_pop_delete (mala_string_user_get (second->string));
 713
 714   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 715   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 716   mala_stringlist_elem_delete_fwd (&eng->program, pptr);
 717
 718   return MALA_SUCCESS;
 719  ealloc_node:
 720   for (itr = mala_stringlist_next (second);
 721        itr != last;
 722        mala_stringlist_fwd (&itr))
 723     {
 724       mala_stringlist_elem_delete (&eng->program, itr);
 725     }
 726
 727   return MALA_EALLOC; // TODO exception instead (needs pools, no allocation possible further)
 728 }
 729
 730
 731
 732
 733 /*
 734   realloc a string to at least needed size
 735   return the amount really reserved or 0 on error
 736  */
 737 static size_t
 738 reserve_string (char ** s, size_t actual, size_t needed)
 739 {
 740   size_t n;
 741   char * r;
 742
 743   for (n = actual>64?actual:64; n <= needed; n += (n>>1)); /*n = n * 1.5*/
 744
 745   r = realloc (*s, n);
 746   if (!r)
 747     {
 748       /* that was to much, try conservatively */
 749       r = realloc (*s, n = needed);
 750       if (!r)
 751         return 0;
 752     }
 753   *s = r;
 754   return n;
 755 }
 756
 757
 758 /*
 759 // Local Variables:
 760 // mode: C
 761 // c-file-style: "gnu"
 762 // End:
 763 // arch-tag: 687e1195-8aad-4425-983d-9767a25c3793
 764 // end_of_file
 765 */