engine/engine.c

   1 /*
   2     engine.c - MaLa core engine
   3
   4   Copyright (C) 2004, 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 <stdlib.h>
  21 #include <ctype.h>
  22 #include <stdio.h>
  23 #include "mala_types.h"
  24 #include "engine.h"
  25 #include "actiondesc.h"
  26 #include "action.h"
  27 #include "stringlist.h"
  28 #include "std/std.h"
  29
  30 \f
  31 #define MALA_EXPAND(e,S) S
  32 static const char * mala_common_strings [] = MALA_COMMON_STRINGS;
  33 #undef MALA_EXPAND
  34
  35 \f
  36 /*
  37  * function definitions
  38  */
  39
  40 MalaEngine
  41 mala_engine_new ()
  42 {
  43   MalaEngine self;
  44   int i;
  45
  46   self = malloc (sizeof(mala_engine));
  47   if (!self)
  48     return NULL;
  49
  50   self->negated = 0;
  51   self->blockcnt = 0;
  52
  53   self->state = MALA_SUCCESS;
  54
  55   mala_stringbucket_init (&self->words, MALA_STRING_FWD, (void(*)(void*)) mala_actiondesc_free);
  56
  57   for (i = 0; i < MALA_STRING_MAX; ++i)
  58     {
  59       self->common_string[i] = mala_string_new (mala_common_strings[i], &self->words);
  60       if (!self->common_string[i])
  61         goto ealloc_strings;
  62     }
  63
  64   mala_stringlist_init (&self->program);
  65   mala_stringlist_init (&self->arguments);
  66
  67   return self;
  68
  69  ealloc_strings:
  70   while (--i >= 0)
  71     mala_string_free (self->common_string[i]);
  72   free (self);
  73   return NULL;
  74 }
  75
  76 #if 0
  77 MalaEngine
  78 mala_engine_new_main (int (*initfunc) (MalaEngine),
  79                       int argc, char **argv,
  80                       mala_actioninit * actions_init)
  81 {
  82   /*TODO convinience function*/
  83 }
  84 #endif
  85
  86 int
  87 mala_engine_ppexpand_define (MalaEngine self, const char * name, int argc, char ** argv)
  88 {
  89   int i;
  90   MalaStringList list;
  91   MalaStringListNode itr;
  92   mala_stringlist pre;
  93
  94   if(!self)
  95     return MALA_EINVALID;
  96   if(self->state > MALA_EFAULT)
  97     return self->state;
  98
  99   mala_stringlist_init (&pre);
 100
 101   for (i = 0; i != argc && *argv; ++i ,++argv)
 102     {
 103       if (!mala_stringlist_tail_new_cstr (&pre, *argv, &self->words))
 104         goto ealloc_node;
 105     }
 106
 107   list = mala_stringlist_new ();
 108   if (!list)
 109     goto ealloc_list;
 110
 111   /*TODO preprocess in own function*/
 112   while (!mala_stringlist_is_empty (&pre))
 113     {
 114       int putaway;
 115
 116       itr = mala_stringlist_head (&pre);
 117
 118       putaway = mala_engine_ppexpand (self, &pre, &itr);
 119
 120       if (self->state > MALA_EFAULT)
 121         return self->state;
 122
 123       while (putaway--)
 124         {
 125           mala_stringlist_node_remove (&pre, itr);
 126           mala_stringlist_tail_insert (list, itr);
 127           if (putaway && mala_stringlist_is_empty (&pre))
 128             goto eunderrun;
 129           itr = mala_stringlist_head (&pre);
 130         }
 131     }
 132
 133   if (mala_stringlist_is_empty (list))
 134     {
 135       /* empty substituted by --NULL, TODO use empty string instead? */
 136       mala_stringlist_free (list);
 137       return mala_engine_add_action_cstr (self, name,
 138                                           mala_string_copy (self->common_string[MALA_STRING_NULL]),
 139                                           mala_substitute_parser,
 140                                           (MalaDataFactory)mala_string_factory,
 141                                           NULL);
 142     }
 143
 144   if (mala_stringlist_is_tail (list, mala_stringlist_head (list)))
 145     {
 146       /* substitute */
 147       MalaString subst;
 148
 149       subst = mala_string_copy (mala_stringlist_head (list) -> string);
 150       mala_stringlist_free (list);
 151
 152       return mala_engine_add_action_cstr (self, name, subst,
 153                                           mala_substitute_parser,
 154                                           (MalaDataFactory)mala_string_factory,
 155                                           NULL);
 156     }
 157   else
 158     {
 159       /* expand */
 160       return mala_engine_add_action_cstr (self, name, list,
 161                                           mala_expand_parser,
 162                                           (MalaDataFactory) mala_stringlist_factory,
 163                                           NULL);
 164     }
 165
 166  eunderrun:
 167   mala_stringlist_free (list);
 168   mala_stringlist_erase (&pre);
 169   return self->state = MALA_ESYNTAX;
 170
 171  ealloc_list:
 172  ealloc_node:
 173   mala_stringlist_erase (&pre);
 174   return self->state = MALA_EALLOC;
 175 }
 176
 177 int
 178 mala_engine_pushback_word (MalaEngine self, const char * word)
 179 {
 180   if(!self)
 181     return MALA_EINVALID;
 182   if(self->state > MALA_EFAULT)
 183     return self->state;
 184
 185   if (!mala_stringlist_tail_new_cstr (&self->program, word, &self->words))
 186     return self->state = MALA_EALLOC;
 187
 188   return MALA_SUCCESS;
 189 }
 190
 191 int
 192 mala_engine_add_action_cstr (MalaEngine self, const char * cname, void * data,
 193                              MalaParserFunc parser, MalaDataFactory factory,
 194                              MalaAction parent)
 195 {
 196   MalaString name;
 197   MalaAction action;
 198
 199   /*TODO such checks everywhere*/
 200   if(!self)
 201     return MALA_EINVALID;
 202   if(self->state > MALA_EFAULT)
 203     return self->state;
 204
 205   name = mala_string_new (cname, &self->words);
 206   if (!name)
 207     goto ealloc_name;
 208
 209   action = mala_action_new (name, data, parser, factory, parent);
 210   if (!action)
 211     goto ealloc_action;
 212
 213   if (mala_action_attach (action) != MALA_SUCCESS)
 214     goto ealloc_attach;
 215
 216   mala_string_free (name);
 217   return MALA_SUCCESS;
 218
 219  ealloc_attach:
 220   mala_action_free (action);
 221  ealloc_action:
 222   mala_string_free (name);
 223  ealloc_name:
 224   return self->state = MALA_EALLOC;
 225 }
 226
 227 int
 228 mala_engine_add_action (MalaEngine self, MalaString name, void * data,
 229                         MalaParserFunc parser, MalaDataFactory factory,
 230                         MalaAction parent)
 231 {
 232   MalaAction action;
 233
 234   /*TODO such checks everywhere*/
 235   if(!self)
 236     return MALA_EINVALID;
 237   if(self->state > MALA_EFAULT)
 238     return self->state;
 239
 240   action = mala_action_new (name, data, parser, factory, parent);
 241   if (!action)
 242     goto ealloc_action;
 243
 244   if (mala_action_attach (action) != MALA_SUCCESS)
 245     goto ealloc_attach;
 246
 247   return MALA_SUCCESS;
 248
 249  ealloc_attach:
 250   mala_action_free (action);
 251  ealloc_action:
 252   return self->state = MALA_EALLOC;
 253 }
 254
 255
 256 MalaEngine
 257 mala_engine_new_initfunc (int (*initfunc)(MalaEngine))
 258 {
 259   MalaEngine self;
 260
 261   self = mala_engine_new ();
 262   if (!self)
 263     return 0;
 264
 265   self->state = initfunc (self);
 266   return self;
 267 }
 268
 269 void
 270 mala_engine_free (MalaEngine self)
 271 {
 272   int i;
 273
 274   if (!self)
 275     return;
 276
 277   mala_stringlist_erase (&self->program);
 278   mala_stringlist_erase (&self->arguments);
 279
 280   mala_stringbucket_erase (&self->words);
 281
 282   for (i = 0; i < MALA_STRING_MAX; ++i)
 283     mala_string_free (self->common_string[i]);
 284
 285   free (self);
 286 }
 287
 288 int
 289 mala_engine_actions_register (MalaEngine self, mala_actioninit * actioninit)
 290 {
 291   MalaAction action;
 292
 293   if (!self)
 294     return MALA_EINVALID;
 295
 296   if (self->state > MALA_EFAULT)
 297     return self->state;
 298
 299   while (actioninit->command)
 300     {
 301       action = mala_action_new_actioninit (actioninit, &self->words);
 302       if (!action)
 303         goto ealloc;
 304
 305       if (mala_action_attach (action) != MALA_SUCCESS)
 306         goto ealloc;
 307
 308       ++actioninit;
 309     }
 310
 311   return MALA_SUCCESS;
 312
 313  ealloc:
 314   return self->state = MALA_EINIT;
 315 }
 316
 317
 318 /*TODO make some inlines { */
 319
 320 MalaStringList
 321 mala_engine_getprogram (MalaEngine self)
 322 {
 323   return &self->program;
 324 }
 325
 326 mala_state
 327 mala_engine_state_get (MalaEngine self)
 328 {
 329   return self->state;
 330 }
 331
 332 void
 333 mala_engine_clearstate (MalaEngine self)
 334 {
 335   self->state = MALA_SUCCESS;
 336 }
 337
 338 int
 339 mala_engine_negated (MalaEngine self)
 340 {
 341   return self->negated;
 342 }
 343
 344 void
 345 mala_engine_clear_negated (MalaEngine self)
 346 {
 347   self->negated = 0;
 348 }
 349 /* } TODO make some inlines */
 350
 351
 352 void
 353 mala_engine_dumpprogram (MalaEngine self, const char * prefix, const char * suffix)
 354 {
 355   MalaStringListNode node;
 356
 357   for (node = mala_stringlist_head (&self->program);
 358        node != (void *)&self->program;
 359        mala_stringlistnode_fwd (&node))
 360     {
 361       fprintf (stderr, "%s%s%s", prefix, mala_string_cstr (node->string), suffix);
 362     }
 363 }
 364
 365 void
 366 mala_engine_dumpargs (MalaEngine self, const char * prefix, const char * suffix)
 367 {
 368   MalaStringListNode node;
 369
 370   for (node = mala_stringlist_head (&self->arguments);
 371        node != (void *)&self->arguments;
 372        mala_stringlistnode_fwd (&node))
 373     {
 374       fprintf (stderr, "%s%s%s", prefix, mala_string_cstr (node->string), suffix);
 375     }
 376 }
 377
 378
 379 MalaEngine
 380 mala_engine_run (MalaEngine self)
 381 {
 382   MalaStringListNode pptr;
 383
 384   while (self->state < MALA_EFAULT &&
 385          (pptr = mala_stringlist_head (&self->program)) != (void *)&self->program)
 386     {
 387       if (self->state == MALA_LITERAL)
 388         {
 389           mala_stringlist_elem_remove (&self->program, pptr);
 390           mala_stringlist_tail_insert (&self->arguments, pptr);
 391           self->state = MALA_SUCCESS;
 392         }
 393       else
 394         mala_engine_eval (self, &pptr);
 395     }
 396   return self;
 397 }
 398
 399 MalaEngine
 400 mala_engine_step (MalaEngine self)
 401 {
 402   MalaStringListNode pptr;
 403
 404   if (self->state < MALA_EFAULT &&
 405          (pptr = mala_stringlist_head (&self->program)) != (void *)&self->program)
 406     {
 407       if (self->state == MALA_LITERAL)
 408         {
 409           mala_stringlist_elem_remove (&self->program, pptr);
 410           mala_stringlist_tail_insert (&self->arguments, pptr);
 411           self->state = MALA_SUCCESS;
 412         }
 413       else
 414         mala_engine_eval (self, &pptr);
 415     }
 416   return self;
 417 }
 418
 419 int
 420 mala_engine_eval (MalaEngine self, MalaStringListNode_ref pptr)
 421 {
 422   MalaAction act;
 423   MalaActionDesc desc;
 424
 425   desc = (MalaActionDesc) mala_string_user_get ((*pptr)->string);
 426   if (!desc)
 427     goto def_parser;
 428
 429   act = mala_actiondesc_top (desc);
 430
 431   if (act)
 432     self->state = mala_action_execute (act, pptr, self);
 433   else
 434     {
 435     def_parser:
 436       if (!(*pptr = mala_stringlist_before_new (&self->program,
 437                                                 *pptr,
 438                                                 self->common_string[MALA_STRING_DEFAULT_PARSER])))
 439         return self->state = MALA_EALLOC;
 440     }
 441
 442   if (self->state == MALA_EXCEPTION)
 443     self->state = MALA_ENOACTION;
 444
 445   return self->state;
 446 }
 447
 448 /*
 449   Evaluate the nth argument until one of the following happens
 450    - for at most 'times'
 451    - until we reach the state of MALA_LITERAL (no further expansions are possible)
 452    - an error/exception is flagged
 453    - the type associated with the data of the current word equals to 'type'
 454  */
 455 MalaStringListNode
 456 mala_engine_arg_eval (MalaEngine self,
 457                       MalaStringListNode_ref pptr,
 458                       unsigned nth,
 459                       int times,
 460                       MalaDataFactory type)
 461 {
 462   MalaAction act;
 463   MalaStringListNode next;
 464
 465   if (!self || self->state > MALA_EFAULT)
 466     return NULL;
 467
 468   for (next = *pptr;
 469        nth && !mala_stringlist_is_tail (&self->program, next);
 470        mala_stringlistnode_fwd (&next), --nth);
 471
 472   if (nth)
 473     goto eend;
 474
 475   self->state = MALA_SUCCESS;
 476   act = mala_actiondesc_top ((MalaActionDesc) mala_string_user_get (next->string));
 477   while (self->state < MALA_EXCEPTION
 478          && times--
 479          && ((act && type) ? (act->factory != type) : 1))
 480     {
 481       mala_engine_eval (self, &next);
 482       if (mala_stringlist_is_end (&self->program, next))
 483         goto eend;
 484     }
 485
 486   return next;
 487
 488  eend:
 489   mala_engine_exception (self, pptr, mala_stringlist_tail (&self->program),
 490                          self->common_string[MALA_STRING_ERROR_MISSING_ARGUMENT]);
 491   return NULL;
 492 }
 493
 494
 495 int
 496 mala_engine_exception (MalaEngine self,
 497                        MalaStringListNode_ref pptr,
 498                        MalaStringListNode here,
 499                        MalaString except)
 500 {
 501   MalaStringListNode tmp;
 502
 503   tmp = mala_stringlist_before_new (&self->program, *pptr, except);
 504   if (!tmp)
 505     return self->state = MALA_EALLOC;
 506
 507   if (!mala_stringlist_after_new (&self->program, here,
 508                                    self->common_string[MALA_STRING_HERE]))
 509     return self->state = MALA_EALLOC;
 510
 511   *pptr = tmp;
 512
 513   /*TODO self-state needs to be preserved somehow?*/
 514   return self->state = MALA_EXCEPTION;
 515 }
 516
 517
 518 int
 519 mala_engine_ppexpand (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 520 {
 521   int ret = 0;
 522
 523   if (self->state > MALA_EFAULT)
 524     return MALA_EXPANSION_ERROR;
 525
 526 #define mala_run_expansion(name) \
 527   if (MALA_NO_EXPANSION != (ret = mala_engine_##name (self, list, pptr))) return ret
 528
 529   mala_run_expansion (literal_expansion);
 530   mala_run_expansion (numsplit_expansion);
 531   mala_run_expansion (exclam_expansion);
 532   mala_run_expansion (no_expansion);
 533   mala_run_expansion (assign_expansion);
 534   mala_run_expansion (char_expansion);
 535   mala_run_expansion (underscore_expansion);
 536   mala_run_expansion (bracket_expansion);
 537   mala_run_expansion (assign_contraction);
 538   mala_run_expansion (envvar_expansion);
 539   mala_run_expansion (setenv_expansion);
 540   mala_run_expansion (backquote_expansion);
 541 #undef mala_run_expansion
 542
 543   return 1;
 544 }
 545
 546 int
 547 mala_engine_literal_expansion (MalaEngine self,
 548                                MalaStringList list,
 549                                MalaStringListNode_ref pptr)
 550 {
 551   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_LITERAL_EXPANSION)
 552       && mala_string_check_prefix ((*pptr)->string, "`")
 553       && !mala_string_check_prefix ((*pptr)->string, "``"))
 554     {
 555       MalaString nstr;
 556       MalaStringListNode newnode1;
 557       MalaStringListNode newnode2;
 558
 559       newnode1 = mala_stringlist_after_new (list,
 560                                             *pptr,
 561                                             self->common_string[MALA_STRING_LITERAL]);
 562       if (!newnode1)
 563         goto ealloc_newnode1;
 564
 565       nstr = mala_string_new_substr ((*pptr)->string, 1, SIZE_MAX);
 566       newnode2 = mala_stringlist_after_new (list, newnode1, nstr);
 567       if (!newnode2)
 568         goto ealloc_newnode2;
 569
 570       mala_stringlist_elem_delete (list, *pptr);
 571       *pptr = newnode1;
 572
 573       return 2;
 574
 575     ealloc_newnode2:
 576       mala_stringlist_elem_delete (list, newnode1);
 577     ealloc_newnode1:
 578       self->state = MALA_EALLOC;
 579       return MALA_EXPANSION_ERROR;
 580     }
 581   return MALA_NO_EXPANSION;
 582 }
 583
 584
 585 int
 586 mala_engine_backquote_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 587 {
 588   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_LITERAL_EXPANSION)
 589       && mala_string_check_prefix ((*pptr)->string, "``"))
 590     {
 591       MalaString nstr;
 592       MalaStringListNode newnode;
 593
 594       nstr = mala_string_new_substr ((*pptr)->string, 1, SIZE_MAX);
 595       newnode = mala_stringlist_after_new (list, *pptr, nstr);
 596       if (!newnode)
 597         goto ealloc_newnode;
 598
 599       mala_stringlist_elem_delete (list, *pptr);
 600       *pptr = newnode;
 601
 602       return 1;
 603
 604     ealloc_newnode:
 605       self->state = MALA_EALLOC;
 606       return MALA_EXPANSION_ERROR;
 607     }
 608   return MALA_NO_EXPANSION;
 609 }
 610
 611 int
 612 mala_engine_numsplit_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 613 {
 614   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_NUMSPLIT_EXPANSION)
 615       && mala_string_length ((*pptr)->string) > 2
 616       && mala_string_at ((*pptr)->string, 0) == '-'
 617       && isalpha (mala_string_at ((*pptr)->string, 1))
 618       )
 619     {
 620       size_t i;
 621
 622       for (i = 2; i < mala_string_length ((*pptr)->string); ++i)
 623         {
 624           if (isdigit (mala_string_at ((*pptr)->string, i)))
 625             {
 626               MalaString a;
 627               MalaString b;
 628
 629               MalaStringListNode na;
 630               MalaStringListNode nb;
 631
 632               a = mala_string_new_substr ((*pptr)->string, 0, i);
 633               b = mala_string_new_substr ((*pptr)->string, i, SIZE_MAX);
 634               if (!a || !b)
 635                 goto ealloc_str;
 636
 637               na = mala_stringlist_after_new (list, *pptr, a);
 638               if (!na)
 639                 goto ealloc_nodea;
 640
 641               nb = mala_stringlist_after_new (list, na, b);
 642               if (!nb)
 643                 goto ealloc_nodeb;
 644
 645               mala_stringlist_elem_delete (list, *pptr);
 646               *pptr = na;
 647
 648               mala_string_free (a);
 649               mala_string_free (b);
 650
 651               return 0;
 652
 653             ealloc_nodeb:
 654               mala_stringlist_elem_delete (list, na);
 655             ealloc_nodea:
 656             ealloc_str:
 657               mala_string_free (a);
 658               mala_string_free (b);
 659               self->state = MALA_EALLOC;
 660               return MALA_EXPANSION_ERROR;
 661             }
 662         }
 663     }
 664   return MALA_NO_EXPANSION;
 665 }
 666
 667
 668 int
 669 mala_engine_exclam_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 670 {
 671   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_EXCLAM_EXPANSION)
 672       && mala_string_length ((*pptr)->string) == 1
 673       && mala_string_same ((*pptr)->string, self->common_string[MALA_STRING_EXCLAMATIONMARK]))
 674     {
 675       MalaStringListNode newnode;
 676
 677       newnode = mala_stringlist_after_new (list,
 678                                            *pptr,
 679                                            self->common_string[MALA_STRING_NOT]);
 680       if (!newnode)
 681         return self->state = MALA_EALLOC;
 682
 683       mala_stringlist_elem_delete (list, *pptr);
 684       *pptr= newnode;
 685       return 1;
 686     }
 687   return MALA_NO_EXPANSION;
 688 }
 689
 690
 691 int
 692 mala_engine_no_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 693 {
 694   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_NO_EXPANSION)
 695       && mala_string_check_prefix_nocase ((*pptr)->string, "--NO-")
 696       && mala_string_length ((*pptr)->string) >= sizeof ("--NO-"))
 697     {
 698       MalaString a;
 699       MalaString aa;
 700       MalaStringListNode n1;
 701       MalaStringListNode n2;
 702
 703       a = mala_string_new_substr ((*pptr)->string, sizeof ("--NO-")-1, SIZE_MAX);
 704       aa = mala_string_new_prefix ("--", a);
 705       if (!a || !aa)
 706         goto ealloc_a;
 707
 708       n1 = mala_stringlist_after_new (list,
 709                                       *pptr, self->common_string[MALA_STRING_NOT]);
 710       if (!n1)
 711         goto ealloc_n1;
 712
 713       n2 = mala_stringlist_after_new (list, n1, aa);
 714       if (!n2)
 715         goto ealloc_n2;
 716
 717       mala_string_free (a);
 718       mala_string_free (aa);
 719       mala_stringlist_elem_delete (list, *pptr);
 720       *pptr = n1;
 721       return 1;
 722
 723     ealloc_n2:
 724       mala_stringlist_elem_delete (list, n1);
 725     ealloc_n1:
 726       mala_string_free (a);
 727       mala_string_free (aa);
 728     ealloc_a:
 729       self->state = MALA_EALLOC;
 730       return MALA_EXPANSION_ERROR;
 731     }
 732   return MALA_NO_EXPANSION;
 733 }
 734
 735
 736 int
 737 mala_engine_assign_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 738 {
 739   size_t eq;
 740
 741   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_ASSIGN_EXPANSION)
 742       && mala_string_check_prefix ((*pptr)->string, "--")
 743       && ((eq = mala_string_char_find ((*pptr)->string, '=')) != SIZE_MAX)
 744       && mala_string_length ((*pptr)->string) > eq + 1)
 745     {
 746       MalaString a;
 747       MalaString b;
 748
 749       MalaStringListNode na;
 750       MalaStringListNode nb;
 751
 752       a = mala_string_new_substr ((*pptr)->string, 0, eq);
 753       b = mala_string_new_substr ((*pptr)->string, eq + 1, SIZE_MAX);
 754       if (!a || !b)
 755         goto ealloc_str;
 756
 757       na = mala_stringlist_after_new (list, *pptr, a);
 758       if (!na)
 759         goto ealloc_nodea;
 760
 761       nb = mala_stringlist_after_new (list, na, b);
 762       if (!nb)
 763         goto ealloc_nodeb;
 764
 765       mala_stringlist_elem_delete (list, *pptr);
 766       *pptr = na;
 767
 768       mala_string_free (a);
 769       mala_string_free (b);
 770
 771
 772       return 0;
 773
 774     ealloc_nodeb:
 775       mala_stringlist_elem_delete (list, na);
 776     ealloc_nodea:
 777     ealloc_str:
 778       mala_string_free (a);
 779       mala_string_free (b);
 780       self->state = MALA_EALLOC;
 781       return MALA_EXPANSION_ERROR;
 782     }
 783   return MALA_NO_EXPANSION;
 784 }
 785
 786
 787 int
 788 mala_engine_envvar_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 789 {
 790   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_ENVVAR_EXPANSION)
 791       && (mala_string_char_find ((*pptr)->string, '$') != SIZE_MAX))
 792     {
 793       MalaStringListNode newnode;
 794
 795       newnode = mala_stringlist_before_new (list,
 796                                            *pptr,
 797                                            self->common_string[MALA_STRING_ENVSUBST]);
 798       if (!newnode)
 799         goto ealloc_node;
 800
 801       *pptr= newnode;
 802       return 2;
 803
 804     ealloc_node:
 805       self->state = MALA_EALLOC;
 806       return MALA_EXPANSION_ERROR;
 807     }
 808
 809   return MALA_NO_EXPANSION;
 810 }
 811
 812
 813 int
 814 mala_engine_char_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 815 {
 816   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_CHAR_EXPANSION)
 817       && mala_string_length ((*pptr)->string) > 2
 818       && ( mala_string_at ((*pptr)->string, 0) == '-'
 819           || mala_string_at ((*pptr)->string, 0) == '+')
 820       && isalpha (mala_string_at ((*pptr)->string, 1)))
 821     {
 822       char prefix[2] = "-";
 823       char current[2] = " ";
 824       const char * i;
 825       int cnt = 0;
 826
 827       MalaString str;
 828       MalaStringListNode node = NULL;
 829       MalaStringListNode pred = *pptr;
 830
 831
 832       for (i = mala_string_cstr ((*pptr)->string); *i; ++i)
 833         {
 834           if (*i == '-' || *i == '+')
 835             prefix[0] = *i;
 836           else if (isalpha (*i))
 837             {
 838               ++cnt;
 839               current[0] = *i;
 840               str = mala_string_new_cat2 (prefix, current,
 841                                           mala_string_bucket_get ((*pptr)->string));
 842               if (!str)
 843                 goto ealloc;
 844
 845               node = mala_stringlist_after_new (list,
 846                                                 pred, str);
 847               if (!node)
 848                 goto ealloc;
 849
 850               pred = node;
 851               mala_string_free (str);
 852             }
 853           else
 854             break;
 855         }
 856
 857       pred = *pptr;
 858       mala_stringlistnode_fwd (&pred);
 859       mala_stringlist_elem_delete (list, *pptr);
 860       *pptr= pred;
 861       return cnt;
 862
 863     ealloc:
 864       mala_string_free (str);
 865       /* cleanup from pred downto pptr */
 866       while (pred != *pptr)
 867         {
 868           MalaStringListNode tmp = mala_stringlistnode_prev (pred);
 869           mala_stringlist_elem_delete (list, pred);
 870           pred = tmp;
 871         }
 872       self->state = MALA_EALLOC;
 873       return MALA_EXPANSION_ERROR;
 874     }
 875   return MALA_NO_EXPANSION;
 876 }
 877
 878
 879 int
 880 mala_engine_underscore_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 881 {
 882   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_UNDERSCORE_EXPANSION)
 883       && mala_string_check_prefix ((*pptr)->string, "--")
 884       && strchr (mala_string_cstr ((*pptr)->string), '_'))
 885     {
 886       MalaString str;
 887       MalaStringListNode node;
 888       char * cstr;
 889       char * i;
 890
 891       cstr = strdup (mala_string_cstr ((*pptr)->string));
 892       if (!cstr)
 893         goto ealloc_cstr;
 894
 895       for (i = cstr + 2; *i; ++i)
 896         {
 897           if (*i == '_')
 898             *i = '-';
 899         }
 900
 901       str = mala_string_new (cstr, &self->words);
 902       if (!str)
 903         goto ealloc_str;
 904
 905       node = mala_stringlist_after_new (list,
 906                                         *pptr,
 907                                         str);
 908       if (!node)
 909         goto ealloc_node;
 910
 911       free (cstr);
 912       mala_string_free (str);
 913
 914       mala_stringlist_elem_delete (list, *pptr);
 915       *pptr= node;
 916       return 0;
 917
 918     ealloc_node:
 919       mala_string_free (str);
 920     ealloc_str:
 921       free (cstr);
 922     ealloc_cstr:
 923       self->state = MALA_EALLOC;
 924       return MALA_EXPANSION_ERROR;
 925     }
 926   return MALA_NO_EXPANSION;
 927 }
 928
 929
 930 int
 931 mala_engine_setenv_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 932 {
 933   size_t eq;
 934
 935   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_SETENV_EXPANSION)
 936       && mala_string_length ((*pptr)->string) > 1
 937       && (eq = mala_string_char_find ((*pptr)->string, '='))
 938       && eq > 0
 939       && eq < SIZE_MAX
 940       && !mala_string_check_prefix ((*pptr)->string, "-"))
 941     {
 942       MalaString key;
 943       MalaString value;
 944       MalaStringListNode n1;
 945       MalaStringListNode n2;
 946       MalaStringListNode n3;
 947
 948       key = mala_string_new_substr ((*pptr)->string, 0, eq);
 949       if (!key)
 950         goto ealloc_key;
 951
 952       value = mala_string_new_substr ((*pptr)->string, eq + 1, SIZE_MAX);
 953       if (!value)
 954         goto ealloc_value;
 955
 956       n1 = mala_stringlist_after_new (list,
 957                                       *pptr, self->common_string[MALA_STRING_SETENV]);
 958       if (!n1)
 959         goto ealloc_n1;
 960
 961       n2 = mala_stringlist_after_new (list, n1, key);
 962       if (!n2)
 963         goto ealloc_n2;
 964
 965       n3 = mala_stringlist_after_new (list, n2, value);
 966       if (!n3)
 967         goto ealloc_n3;
 968
 969       mala_string_free (key);
 970       mala_string_free (value);
 971       mala_stringlist_elem_delete (list, *pptr);
 972       *pptr = n1;
 973       return 3;
 974
 975     ealloc_n3:
 976       mala_stringlist_elem_delete (list, n2);
 977     ealloc_n2:
 978       mala_stringlist_elem_delete (list, n1);
 979     ealloc_n1:
 980       mala_string_free (value);
 981     ealloc_value:
 982       mala_string_free (key);
 983     ealloc_key:
 984       self->state = MALA_EALLOC;
 985       return MALA_EXPANSION_ERROR;
 986     }
 987   return MALA_NO_EXPANSION;
 988 }
 989
 990
 991 int
 992 mala_engine_bracket_expansion (MalaEngine self, MalaStringList list, MalaStringListNode_ref pptr)
 993 {
 994   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_BRACKET_EXPANSION)
 995       && mala_string_at ((*pptr)->string, 0) == '[')
 996     {
 997       MalaStringListNode nitr;
 998       MalaStringListNode node;
 999
1000       MalaString str1 = NULL;
1001       MalaStringListNode node1;
1002
1003       MalaString str2 = NULL;
1004       MalaStringListNode node2;
1005
1006       node = mala_stringlist_after_new (list, *pptr, self->common_string[MALA_STRING_SECTION]);
1007       if (!node)
1008         goto ealloc_node;
1009
1010       if (mala_string_length((*pptr)->string) > 1)
1011         {
1012           str1 = mala_string_new_substr ((*pptr)->string, 1, SIZE_MAX);
1013           node1 = mala_stringlist_after_new (list, node, str1);
1014           if (!node1)
1015             goto ealloc_node1;
1016         }
1017       else
1018         {
1019           node1 = node;
1020           mala_stringlistnode_fwd (&node1);
1021         }
1022
1023       for (nitr = node1; (void*)nitr != (void*)list; mala_stringlistnode_fwd (&nitr))
1024         {
1025           if (mala_string_at (nitr->string, mala_string_length(nitr->string) - 1) == ']')
1026             break;
1027         }
1028
1029       if ((void*)nitr != (void*)list)
1030         {
1031           if (mala_string_length(nitr->string) > 1)
1032             {
1033               str2 = mala_string_new_substr (nitr->string, 0,
1034                                              mala_string_length(nitr->string) - 1);
1035               node2 = mala_stringlist_after_new (list, nitr, str2);
1036               if (!node2)
1037                 goto ealloc_node2;
1038             }
1039         }
1040       else
1041         goto esyntax;
1042
1043
1044       mala_string_free (str1);
1045       mala_string_free (str2);
1046       mala_stringlist_elem_delete (list, *pptr);
1047       mala_stringlist_elem_delete (list, nitr);
1048       *pptr = node;
1049
1050       return 0;
1051
1052     esyntax:
1053       mala_string_free (str1);
1054       mala_stringlist_elem_delete (list, node1);
1055       mala_stringlist_elem_delete (list, node);
1056       self->state = MALA_ESYNTAX;
1057       return MALA_EXPANSION_ERROR;
1058
1059     ealloc_node2:
1060       mala_string_free (str1);
1061       mala_stringlist_elem_delete (list, node1);
1062     ealloc_node1:
1063       mala_stringlist_elem_delete (list, node);
1064     ealloc_node:
1065       self->state = MALA_EALLOC;
1066       return MALA_EXPANSION_ERROR;
1067     }
1068   return MALA_NO_EXPANSION;
1069 }
1070
1071
1072 int
1073 mala_engine_assign_contraction (MalaEngine self,
1074                                 MalaStringList list,
1075                                 MalaStringListNode_ref pptr)
1076 {
1077   MalaStringListNode assign;
1078   MalaStringListNode value ;
1079
1080   assign = *pptr;
1081   mala_stringlistnode_fwd (&assign);
1082   value = assign;
1083
1084   if (mala_engine_check_expansionflag (self, MALA_STRING_FLAG_ASSIGN_CONTRACTION)
1085       && !mala_stringlist_is_tail (list, *pptr)
1086       && !mala_stringlist_is_tail (list, assign)
1087       && mala_string_same (assign->string, self->common_string[MALA_STRING_ASSIGN]))
1088     {
1089       MalaString str;
1090       MalaStringListNode node;
1091
1092       mala_stringlistnode_fwd (&value);
1093
1094       str = mala_string_new_print (mala_string_bucket_get ((*pptr)->string),
1095                                    "%s=%s",
1096                                    mala_string_cstr ((*pptr)->string),
1097                                    mala_string_cstr (value->string));
1098
1099
1100       node = mala_stringlist_after_new (list,
1101                                         value,
1102                                         str);
1103       if (!node)
1104         goto ealloc_node;
1105
1106       mala_string_free (str);
1107       mala_stringlist_elem_delete (list, *pptr);
1108       mala_stringlist_elem_delete (list, assign);
1109       mala_stringlist_elem_delete (list, value);
1110       *pptr = node;
1111       return 0;
1112
1113     ealloc_node:
1114       mala_string_free (str);
1115       self->state = MALA_EALLOC;
1116       return MALA_EXPANSION_ERROR;
1117     }
1118   return MALA_NO_EXPANSION;
1119 }
1120
1121
1122
1123
1124 int
1125 mala_engine_string_istrue (MalaEngine self, MalaString str)
1126 {
1127   if (!str
1128       || !mala_string_compare (str, self->common_string[MALA_STRING_FALSE])
1129       || !mala_string_compare (str, self->common_string[MALA_STRING_ZERO]))
1130     return 0;
1131
1132   return 1;
1133 }
1134
1135 int
1136 mala_engine_check_expansionflag (MalaEngine self, int flag)
1137 {
1138   MalaActionDesc desc;
1139   desc = (MalaActionDesc) mala_string_user_get (self->common_string[flag]);
1140
1141   /*only enabled when the topmost action is a subtitution to --TRUE*/
1142   return mala_actiondesc_data_top (desc) == self->common_string[MALA_STRING_TRUE];
1143 }
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157 #if 0 /*TODO*/
1158 int
1159 mala_engine_erase_action (MalaEngine self, const t_uchar * key)
1160 {
1161   MalaAction act;
1162
1163   if (self->state > MALA_EFAULT)
1164     return self->state;
1165
1166   act = mala_actiondict_lookupaction (self->actions, key);
1167   if (!act)
1168     goto enoact;
1169
1170   mala_actiondict_destroy_action (self->actions, act);
1171
1172   return MALA_SUCCESS;
1173
1174  enoact:
1175   self->state = MALA_ENOACTION;
1176   return self->state;
1177 }
1178
1179
1180
1181 int
1182 mala_engine_deepeval (MalaEngine self, MalaStringListNode_ref pptr)
1183 {
1184   MalaStringListNode base = llist_get_prev (pptr);
1185   while (mala_engine_eval (self, llist_get_nextt (base)) < MALA_EVAL)
1186     if (llist_get_next (base) == &self->program)
1187       return MALA_ENOACTION;
1188
1189   return self->state;
1190 }
1191
1192
1193
1194 void
1195 mala_engine_pusfront_program (MalaEngine self, int argc, char ** argv)
1196 {
1197   self->state = mala_strlist_pushfront_cstrings (&self->program, argc, argv);
1198 }
1199
1200
1201
1202 int
1203 mala_engine_argc (MalaEngine self)
1204 {
1205   return llist_count (&self->arguments) + 1;
1206 }
1207
1208 const char*
1209 mala_engine_argv (MalaEngine self, int n)
1210 {
1211   MalaStringListNode p;
1212   p = llist_get_next (&self->arguments);
1213
1214   if (n==0)
1215     return self->argv_0;
1216
1217   while (--n)
1218     {
1219       if (p == &self->arguments)
1220         return 0;
1221       p = llist_get_next (p);
1222     }
1223   return (const char *)(p)->data;
1224 }
1225
1226
1227
1228 MalaAction
1229 mala_engine_action_new (MalaEngine self, t_uchar** name, void** data,
1230                         MalaParserFunc parser, MalaDataDestructor destructor)
1231 {
1232   MalaAction act;
1233
1234   act = mala_action_new (name, data, parser, destructor);
1235   if (!act)
1236     goto ealloc;
1237
1238   self->state = mala_actiondict_push (self->actions, act);
1239   if (self->state)
1240     goto epush;
1241
1242   return act;
1243
1244  epush:
1245   mala_action_destroy (act);
1246  ealloc:
1247   return 0;
1248 }
1249
1250 int
1251 mala_engine_check_expansionflag (MalaEngine self, const t_uchar * name)
1252 {
1253   MalaAction act;
1254
1255   act = mala_actiondict_lookupaction (self->actions, name);
1256   if (!act)
1257     return MALA_NO_EXPANSION;
1258
1259   if (act->parser != mala_substitute_parser)
1260     return MALA_EPARSER;
1261
1262   return mala_string_check ((t_uchar*) act->data);
1263 }
1264
1265
1266 MalaAction
1267 mala_engine_getaction (MalaEngine self, const t_uchar * name)
1268 {
1269   return mala_actiondict_lookupaction (self->actions, name);
1270 }
1271
1272 MalaAction
1273 mala_engine_getprevaction (MalaEngine self, const t_uchar * name)
1274 {
1275   return mala_actiondict_lookupprevaction (self->actions, name);
1276 }
1277
1278 #endif /*TODO*/
1279
1280
1281
1282
1283
1284 /*
1285 // Local Variables:
1286 // mode: C
1287 // c-file-style: "gnu"
1288 // End:
1289 // arch-tag: ece5489f-f703-4033-8cbc-efc1b0562100
1290 // end_of_file
1291 */