std/std_pp.c

   1 /*
   2     std_pp.c - MaLa standard preprocessor
   3
   4   Copyright (C) 2007, Christian Thaeter <ct@pipapo.org>
   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 <ctype.h>
  21 #include "mala.h"
  22 #include "std_pp.h"
  23
  24 static
  25 mala_actioninit std_pp[] =
  26   {
  27
  28     MALA_PARSER_SUBSTITUTE("--PREPROCESS", "--PREPROCESS-ARGV"),
  29
  30     MALA_PARSER_EXPAND("--PREPROCESS-ARGV",
  31                        ("--DEF", "--LITERAL", "--ERROR-MISSING-ARGUMENT",
  32                         "--BEGIN","--DEL", "--LITERAL", "--ERROR-MISSING-ARGUMENT", "--END",
  33                         "--PP-ARGV")),
  34
  35     MALA_PARSER_SUBSTITUTE("--PP-ARGV", "--PP-BACKQUOTE-ARGV"),
  36
  37     MALA_PARSER_MACRO("--PP-ARGV-RESTART",("--LITERAL","%^1", "--PP-ARGV")),
  38
  39     MALA_PARSER_SIMPLE("--PP-BACKQUOTE-ARGV", mala_ppbackquote_parser),
  40     MALA_PARSER_SUBSTITUTE("--PP-BACKQUOTE-ARGV-START", "--PP-ARGV"),
  41     MALA_PARSER_SUBSTITUTE("--PP-BACKQUOTE-ARGV-CONTINUE", "--PP-NUMSPLIT-ARGV"),
  42
  43     MALA_PARSER_SIMPLE("--PP-NUMSPLIT-ARGV", mala_ppnumsplit_parser),
  44     MALA_PARSER_SUBSTITUTE("--PP-NUMSPLIT-ARGV-CONTINUE", "--PP-EXCLAM-ARGV"),
  45     //MALA_PARSER_SUBSTITUTE("--PP-NUMSPLIT-ARGV-CONTINUE", "--PP-EXCLAM-ARGV"), // TODO state to bypass EXLAM (optimization)
  46
  47     MALA_PARSER_SIMPLE("--PP-EXCLAM-ARGV", mala_ppexclam_parser),
  48     MALA_PARSER_SUBSTITUTE("--PP-EXCLAM-ARGV-START", "--PP-ARGV-RESTART"),
  49     MALA_PARSER_SUBSTITUTE("--PP-EXCLAM-ARGV-CONTINUE", "--PP-ARGV-RESTART"),
  50
  51
  52     /*
  53     MALA_PARSER_SIMPLE("--PP-QUOTED", mala_ppquoted_parser),
  54     MALA_PARSER_SIMPLE("--PP-DQUOTED", mala_ppdquoted_parser),
  55     MALA_PARSER_SIMPLE("--PP-NUMSPLIT", mala_ppnumsplit_parser),
  56     MALA_PARSER_SIMPLE("--PP-EXCLAM", mala_ppexclam_parser),
  57     MALA_PARSER_SIMPLE("--PP-NO", mala_ppno_parser),
  58     MALA_PARSER_SIMPLE("--PP-ASSIGN", mala_ppassign_parser),
  59     MALA_PARSER_SIMPLE("--PP-CHAR", mala_ppchar_parser),
  60     MALA_PARSER_SIMPLE("--PP-PLUS", mala_ppplus_parser),
  61     MALA_PARSER_SIMPLE("--PP_UNDERSCORE", mala_ppunderscore_parser),
  62     MALA_PARSER_SIMPLE("--PP-SECTION", mala_ppsection_parser),
  63     MALA_PARSER_SIMPLE("--PP-ASSIGNCONCAT", mala_ppassignconcat_parser),
  64     MALA_PARSER_SIMPLE("--PP-ENVSUBST", mala_ppenvsubst_parser),
  65     MALA_PARSER_SIMPLE("--PP-SETENV", mala_ppsetenv_parser),
  66     MALA_PARSER_SIMPLE("--PP-BRACE", mala_ppbrace_parser),
  67     MALA_PARSER_SIMPLE("--PP-SIMPLE", mala_pplist_parser),
  68     MALA_PARSER_SIMPLE("--PP-COMMAND", mala_ppcommand_parser),
  69     MALA_PARSER_SIMPLE("--PP-TOKENIZE", mala_pptokenize_parser),
  70     MALA_PARSER_SIMPLE("--PP-DASHDASH", mala_ppdashdash_parser),
  71     */
  72     MALA_ACTIONS_END
  73   };
  74 \f
  75
  76 /*
  77
  78 HOWTO
  79 envsubst in literal?
  80
  81 note: want a --PP-STOP?
  82
  83  --PREPROCESS           should be defined to the proper preprocessor
  84
  85  --PREPROCESS-ARGV-MINIMAL
  86
  87
  88  --PREPROCESS-ARGV      preprocessor for commandline options
  89    --PP-BACKQUOTE --PP-NUMSPLIT --PP-EXCLAM --PP-NO --PP-ASSIGN --PP-CHAR --PP-PLUS --PP-UNDERSCORE --PP-SECTION --PP-ASSIGN-CONCAT --PP-ENVSUBST --PP-SETENV
  90
  91  --PREPROCESS-CONF      preprocessor for config files
  92    --PP-QUOTED --PP-DQUOTED --PP-NUMSPLIT --PP-EXCLAM --PP-NO --PP-ASSIGN --PP-CHAR --PP-PLUS --PP-UNDERSCORE --PP-SECTION --PP-ASSIGN-CONCAT --PP-ENVSUBST --PP-SETENV --PP-BRACE --PP-LIST --PP-COMMAND
  93
  94  --PREPROCESS-CMD       preprocessor for commandline
  95    --PP-TOKENINZE --PP-LITERAL --PP-NUMSPLIT --PP-EXCLAM --PP-NO --PP-ASSIGN --PP-CHAR --PP-PLUS --PP-UNDERSCORE --PP-SECTION --PP-ASSIGN-CONCAT --PP-ENVSUBST --PP-SETENV --PP-BRACE --PP-LIST --PP-COMMAND
  96
  97 */
  98
  99
 100 /*
 101 Preprocessing applies different parsers to works which might in turn modify them. When finished
 102 with a word it may iterate to the next word and restart the preprocessing.
 103
 104 This is done as state-machine where each parser uses
 105  %0-NEXT to restart on the next word
 106 or
 107  %0-CONTINUE to
 108
 109
 110 parser                          1)              2)
 111 --PP-BACKQUOTE-ARG              --PP-ARGV       --PP-NUMSPLIT-ARGV
 112 --PP-NUMSPLIT-ARGV              --PP-ARGV       --PP-EXCLAM-ARGV
 113 --PP-EXCLAM-ARGV                --PP-ARGV       --PP-NO-ARGV
 114 --PP-NO-ARGV                    --PP-ARGV       --PP-ASSIGN-ARGV
 115 --PP-ASSIGN-ARGV                --PP-ARGV       --PP-CHAR-ARGV
 116 --PP-CHAR-ARGV                  --PP-ARGV       --PP-PLUS-ARGV
 117 --PP-PLUS-ARGV                  --PP-ARGV       --PP-UNDERSCORE-ARGV
 118 --PP-UNDERSCORE-ARGV            --PP-ARGV
 119
 120 */
 121
 122
 123 /*
 124 --PP-BACKQUOTE
 125       literal_expansion `foo becomes --LITERAL foo, where ` is the default of --BACKQUOTE-EXPANSION-CHAR
 126       backquote_expansion ``foo becomes `foo without literal expansion (escaping of literal expansion)
 127 */
 128 mala_state
 129 mala_ppbackquote_parser (MalaProgram prg)
 130 {
 131   int args = 0;
 132   TRACE (mala_module_std);
 133
 134   MALA_MUTATOR_BEGIN
 135     {
 136       MalaStringList str = mala_stringlist_next(mala_stringlist_next(prg->pptr));
 137
 138       if (str != prg->program)
 139         {
 140           ACOGC_STACK_ENTER (&prg->engine->gcroot);
 141           ACOGC_STACK_PTR(MalaString, s);
 142           ACOGC_STACK_PTR(MalaStringList, n);
 143
 144           if (mala_stringlist_cstr (str)[0] == '`' && mala_stringlist_cstr (str)[1])
 145             {
 146               if (mala_stringlist_cstr (str)[1] != '`')
 147                 {
 148                   s.ptr = mala_string_new_print (prg->engine->words, "%s-START",mala_program_pptr_cstr(prg));
 149                   n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 150                   mala_stringlist_insert_after (str, n.ptr);
 151
 152                   n.ptr = mala_stringlist_node_new_cstr (mala_stringlist_cstr (str) + 1, prg->engine);
 153                   mala_stringlist_insert_after (str, n.ptr);
 154
 155                   n.ptr = mala_stringlist_node_new (prg->engine->common_string[MALA_STRING_LITERAL], prg->engine);
 156                   mala_stringlist_insert_after (str, n.ptr);
 157
 158                   s.ptr = mala_string_new_literal_cstr ("2", prg->engine->words);
 159                   n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 160                   mala_stringlist_insert_after (str, n.ptr);
 161
 162                   s.ptr = mala_string_new_literal_cstr ("--SKIP", prg->engine->words);
 163                   n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 164                   mala_stringlist_insert_after (str, n.ptr);
 165
 166                   args = 1;
 167                 }
 168               else
 169                 {
 170                   n.ptr = mala_stringlist_node_new_cstr (mala_stringlist_cstr (str) + 1, prg->engine);
 171                   mala_stringlist_insert_after (str, n.ptr);
 172
 173                   s.ptr = mala_string_new_print (prg->engine->words, "%s-CONTINUE",mala_program_pptr_cstr(prg));
 174                   n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 175                   mala_stringlist_insert_after (str, n.ptr);
 176
 177                   args = 1;
 178                 }
 179             }
 180           else
 181             {
 182               s.ptr = mala_string_new_print (prg->engine->words, "%s-CONTINUE",mala_program_pptr_cstr(prg));
 183               n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 184               mala_stringlist_insert_after (mala_stringlist_next(prg->pptr), n.ptr);
 185               args = 0;
 186             }
 187
 188           ACOGC_STACK_LEAVE;
 189         }
 190     }
 191   MALA_MUTATOR_END;
 192
 193   mala_program_action_done (prg, args);
 194   return MALA_STATEMENT;
 195 }
 196
 197
 198 /*
 199 --PP-NUMSPLIT
 200       numsplit_expansion -a10 becomes -a 10
 201 */
 202 mala_state
 203 mala_ppnumsplit_parser (MalaProgram prg)
 204 {
 205   int args = 0;
 206   TRACE (mala_module_std);
 207
 208   MALA_MUTATOR_BEGIN
 209     {
 210       MalaStringList str = mala_stringlist_next(mala_stringlist_next(prg->pptr));
 211       if (str != prg->program)
 212         {
 213           ACOGC_STACK_ENTER (&prg->engine->gcroot);
 214           ACOGC_STACK_PTR(MalaString, s);
 215           ACOGC_STACK_PTR(MalaStringList, n);
 216           /* starts with -[^-0-9] */
 217           const char* begin = mala_stringlist_cstr (str);
 218
 219           if (begin[0] == '-' && begin[1] && begin[1] != '-' && !isdigit(begin[1]))
 220             {
 221               const char* i;
 222               for (i = begin + 2;
 223                    *i && !isdigit(*i);
 224                    ++i);
 225
 226               if (*i)
 227                 {
 228                   size_t len1 = i - begin;
 229
 230                   s.ptr = mala_string_new_cstr_n (begin + len1,
 231                                                   mala_string_length (mala_stringlist_string (str)) - len1,
 232                                                   prg->engine->words);
 233                   n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 234                   mala_stringlist_insert_after (str, n.ptr);
 235
 236                   s.ptr = mala_string_new_cstr_n (begin,
 237                                                   len1,
 238                                                   prg->engine->words);
 239                   n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 240                   mala_stringlist_insert_after (str, n.ptr);
 241
 242                   s.ptr = mala_string_new_print (prg->engine->words, "%s-CONTINUE",mala_program_pptr_cstr(prg));
 243                   n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 244                   mala_stringlist_insert_after (str, n.ptr);
 245
 246                   args = 1;
 247                 }
 248             }
 249           else
 250             {
 251               s.ptr = mala_string_new_print (prg->engine->words, "%s-CONTINUE",mala_program_pptr_cstr(prg));
 252               n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 253               mala_stringlist_insert_before (str, n.ptr);
 254               args = 0;
 255             }
 256           ACOGC_STACK_LEAVE;
 257         }
 258     }
 259   MALA_MUTATOR_END;
 260
 261   mala_program_action_done (prg, args);
 262   return MALA_STATEMENT;
 263 }
 264
 265
 266 /*
 267 --PP-EXCLAM
 268       exclam_expansion ! becomes --NO
 269 */
 270 mala_state
 271 mala_ppexclam_parser (MalaProgram prg)
 272 {
 273   int args = 0;
 274   TRACE (mala_module_std);
 275
 276   MALA_MUTATOR_BEGIN
 277     {
 278       MalaStringList str = mala_stringlist_next(mala_stringlist_next(prg->pptr));
 279       if (str != prg->program)
 280         {
 281           ACOGC_STACK_ENTER (&prg->engine->gcroot);
 282           ACOGC_STACK_PTR(MalaString, s);
 283           ACOGC_STACK_PTR(MalaStringList, n);
 284
 285           if (mala_stringlist_string(str) == prg->engine->common_string[MALA_STRING_EXCLAMATIONMARK])
 286             {
 287               s.ptr = mala_string_new_print (prg->engine->words, "%s-CONTINUE",mala_program_pptr_cstr(prg));
 288               n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 289               mala_stringlist_insert_after (str, n.ptr);
 290
 291               n.ptr = mala_stringlist_node_new (prg->engine->common_string[MALA_STRING_NO], prg->engine);
 292               mala_stringlist_insert_after (str, n.ptr);
 293
 294               n.ptr = mala_stringlist_node_new (prg->engine->common_string[MALA_STRING_LITERAL], prg->engine);
 295               mala_stringlist_insert_after (str, n.ptr);
 296               args = 1;
 297             }
 298           else
 299             {
 300               s.ptr = mala_string_new_print (prg->engine->words, "%s-CONTINUE",mala_program_pptr_cstr(prg));
 301               n.ptr = mala_stringlist_node_new (s.ptr , prg->engine);
 302               mala_stringlist_insert_before (str, n.ptr);
 303               args = 0;
 304             }
 305           ACOGC_STACK_LEAVE;
 306         }
 307     }
 308   MALA_MUTATOR_END;
 309
 310   mala_program_action_done (prg, args);
 311   return MALA_STATEMENT;
 312 }
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324 /*
 325 --PP-QUOTED
 326       literal_expansion 'foo' becomes --LITERAL foo, where '..' are the default of --QUOTED-EXPANSION-CHAR
 327       backquote_expansion ``foo becomes `foo without literal expansion (escaping of literal expansion)
 328 */
 329 mala_state
 330 mala_ppquoted_parser (MalaProgram prg)
 331 {
 332   TRACE (mala_module_std);
 333
 334   MALA_MUTATOR_BEGIN
 335     {
 336     }
 337   MALA_MUTATOR_END;
 338
 339   mala_program_action_done (prg, 0);
 340   return MALA_SUCCESS;
 341 }
 342
 343
 344 /*
 345 --PP-DQUOTED
 346       literal_expansion "foo" becomes --LITERAL foo, where ".." are the default of --DQUOTED-EXPANSION-CHAR
 347       backquote_expansion ``foo becomes `foo without literal expansion (escaping of literal expansion)
 348 */
 349 mala_state
 350 mala_ppdquoted_parser (MalaProgram prg)
 351 {
 352   TRACE (mala_module_std);
 353
 354   MALA_MUTATOR_BEGIN
 355     {
 356     }
 357   MALA_MUTATOR_END;
 358
 359   return MALA_STATEMENT;
 360 }
 361
 362
 363 /*
 364 --PP-NO
 365       no_expansion --NO-foo or --no-foo becomes --NO --foo
 366 */
 367 mala_state
 368 mala_ppno_parser (MalaProgram prg)
 369 {
 370   TRACE (mala_module_std);
 371
 372   MALA_MUTATOR_BEGIN
 373     {
 374     }
 375   MALA_MUTATOR_END;
 376
 377   return MALA_STATEMENT;
 378 }
 379
 380
 381 /*
 382 --PP-ASSIGN
 383       assign_expansion --foo=bar becomes --foo bar
 384 */
 385 mala_state
 386 mala_ppassign_parser (MalaProgram prg)
 387 {
 388   TRACE (mala_module_std);
 389
 390   MALA_MUTATOR_BEGIN
 391     {
 392     }
 393   MALA_MUTATOR_END;
 394
 395   return MALA_STATEMENT;
 396 }
 397
 398
 399 /*
 400 --PP-CHAR
 401       char_expansion -abc+def123 becomes -a -b -c +d +e +f 123
 402 */
 403 mala_state
 404 mala_ppchar_parser (MalaProgram prg)
 405 {
 406   TRACE (mala_module_std);
 407
 408   MALA_MUTATOR_BEGIN
 409     {
 410     }
 411   MALA_MUTATOR_END;
 412
 413   return MALA_STATEMENT;
 414 }
 415
 416
 417 /*
 418 --PP-PLUS
 419       plus_expansion +a becomes --NO -a
 420 */
 421 mala_state
 422 mala_ppplus_parser (MalaProgram prg)
 423 {
 424   TRACE (mala_module_std);
 425
 426   MALA_MUTATOR_BEGIN
 427     {
 428     }
 429   MALA_MUTATOR_END;
 430
 431   return MALA_STATEMENT;
 432 }
 433
 434
 435 /*
 436 --PP_UNDERSCORE
 437       underscore_expansion --foo_bar becomes --foo-bar
 438 */
 439 mala_state
 440 mala_ppunderscore_parser (MalaProgram prg)
 441 {
 442   TRACE (mala_module_std);
 443
 444   MALA_MUTATOR_BEGIN
 445     {
 446     }
 447   MALA_MUTATOR_END;
 448
 449   return MALA_STATEMENT;
 450 }
 451
 452
 453 /*
 454 --PP-SECTION
 455       bracket_expansion [foo bar] becomes --SECTION foo bar
 456 */
 457 mala_state
 458 mala_ppsection_parser (MalaProgram prg)
 459 {
 460   TRACE (mala_module_std);
 461
 462   MALA_MUTATOR_BEGIN
 463     {
 464     }
 465   MALA_MUTATOR_END;
 466
 467   return MALA_STATEMENT;
 468 }
 469
 470
 471 /*
 472 --PP-ASSIGN-CONCAT
 473       assign_concat foo = bar becomes foo=bar for setenv_expansion
 474 */
 475 mala_state
 476 mala_ppassignconcat_parser (MalaProgram prg)
 477 {
 478   TRACE (mala_module_std);
 479
 480   MALA_MUTATOR_BEGIN
 481     {
 482     }
 483   MALA_MUTATOR_END;
 484
 485   return MALA_STATEMENT;
 486 }
 487
 488
 489 /*
 490 --PP-ENVSUBST
 491       envvar_expansion foo$bar or foo${bar} becomes --ENVSUBST foo${bar}
 492
 493   wordexp()
 494 */
 495 mala_state
 496 mala_ppenvsubst_parser (MalaProgram prg)
 497 {
 498   TRACE (mala_module_std);
 499
 500   MALA_MUTATOR_BEGIN
 501     {
 502     }
 503   MALA_MUTATOR_END;
 504
 505   return MALA_STATEMENT;
 506 }
 507
 508
 509 /*
 510 --PP-SETENV
 511       setenv_expansion foo=bar becomes --SETENV foo bar
 512 */
 513 mala_state
 514 mala_ppsetenv_parser (MalaProgram prg)
 515 {
 516   TRACE (mala_module_std);
 517
 518   MALA_MUTATOR_BEGIN
 519     {
 520     }
 521   MALA_MUTATOR_END;
 522
 523   return MALA_STATEMENT;
 524 }
 525
 526
 527 /*
 528 --PP-BRACE
 529       brace_expansion { becomes --BEGIN and } becomes --END where { is the default value of --OPENING-BRACE and } is the default value of --CLOSING-BRACE
 530 */
 531 mala_state
 532 mala_ppbrace_parser (MalaProgram prg)
 533 {
 534   TRACE (mala_module_std);
 535
 536   MALA_MUTATOR_BEGIN
 537     {
 538     }
 539   MALA_MUTATOR_END;
 540
 541   return MALA_STATEMENT;
 542 }
 543
 544
 545 /*
 546 --PP-LIST
 547       list_expansion foo,bar,baz becomes --BEGIN foo bar baz --END where , is the default value of --LIST-SEPARATOR
 548 */
 549
 550 mala_state
 551 mala_pplist_parser (MalaProgram prg)
 552 {
 553   TRACE (mala_module_std);
 554
 555   MALA_MUTATOR_BEGIN
 556     {
 557     }
 558   MALA_MUTATOR_END;
 559
 560   return MALA_STATEMENT;
 561 }
 562
 563
 564 /*
 565 --PP-COMMAND
 566       comand_expansion foo becomes --foo when --foo is a defined action
 567 */
 568 mala_state
 569 mala_ppcommand_parser (MalaProgram prg)
 570 {
 571   TRACE (mala_module_std);
 572
 573   MALA_MUTATOR_BEGIN
 574     {
 575     }
 576   MALA_MUTATOR_END;
 577
 578   return MALA_STATEMENT;
 579 }
 580
 581
 582 /*
 583 --PP-TOKENIZE
 584       tokenizes a string with respect of quotes
 585 */
 586 mala_state
 587 mala_pptokenize_parser (MalaProgram prg)
 588 {
 589   TRACE (mala_module_std);
 590
 591   MALA_MUTATOR_BEGIN
 592     {
 593     }
 594   MALA_MUTATOR_END;
 595
 596   return MALA_STATEMENT;
 597 }
 598
 599
 600 /*
 601 --PP-DASHDASH
 602       quits preprocessor on --
 603 */
 604 mala_state
 605 mala_ppdashdash_parser (MalaProgram prg)
 606 {
 607   TRACE (mala_module_std);
 608   //--PP-DASHDASH for '--' doesnt add --PP-MARK, returns MALA_SUCCESS (or something other which breaks preprocessing instantly)
 609   MALA_MUTATOR_BEGIN
 610     {
 611     }
 612   MALA_MUTATOR_END;
 613
 614   return MALA_STATEMENT;
 615 }
 616
 617
 618
 619 int
 620 mala_module_std_pp_init (MalaEngine self)
 621 {
 622   return mala_engine_actions_register (self, std_pp);
 623 }
 624
 625
 626 /*
 627 // Local Variables:
 628 // mode: C
 629 // c-file-style: "gnu"
 630 // End:
 631 */