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