WINGs/menuparser_macros.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 2012 Christophe Curis
   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 as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License along
  17  *  with this program; if not, write to the Free Software Foundation, Inc.,
  18  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20 #include "wconfig.h"
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <ctype.h>
  26 #include <unistd.h>
  27 #include <pwd.h>
  28
  29 #include <WINGs/WUtil.h>
  30
  31 #include "menuparser.h"
  32
  33 /*
  34  This file contains the functions related to macros:
  35   - parse a macro being defined
  36   - handle single macro expansion
  37   - pre-defined parser's macros
  38
  39  Some design notes for macro internal storage:
  40
  41  arg_count is -1 when the macro does not take arguments
  42    but 0 when no args but still using parenthesis. The
  43    difference is explained in GNU cpp's documentation:
  44  http://gcc.gnu.org/onlinedocs/cpp/Function_002dlike-Macros.html
  45
  46  the value is stored for fast expansion; here is an
  47    example of the storage format used:
  48  #define EXAMPLE(a, b)  "text:" a and b!
  49    will be stored in macro->value[] as:
  50  0x0000: 0x00 0x07       (strlen(part 1))
  51  0x0002: '"', 't', 'e', 'x', 't', ':', '"'   (first part)
  52  0x0009: 0x00            (part 2, id=0 for replacement by 1st parameter 'a')
  53  0x000A: 0x00 0x03       (strlen(part 3))
  54  0x000C: 'a', 'n', 'd'   (part 3)
  55  0x000F: 0x01            (part 4, id=1 for replacement by 2nd parameter 'b')
  56  0x0010: 0x00 0x01       (strlen(part 5))
  57  0x0012: '!'             (part 5)
  58  0x0013: 0xFF            (end of macro)
  59   This structure allows to store any number and combination
  60    of text/parameter and still provide very fast generation
  61    at macro replacement time.
  62
  63  Predefined macros are using a call-back function mechanism
  64    to generate the value on-demand. This value is generated
  65    in the 'value' buffer of the structure.
  66  Most of these call-backs will actually cache the value:
  67    they generate it on the first use (inside a parser,
  68    not globally) and reuse that value on next call(s).
  69
  70  Because none of these macros take parameters, the call-back
  71    mechanism does not include passing of user arguments; the
  72    complex storage mechanism for argument replacement being
  73    not necessary the macro->value parameter is used as a
  74    plain C string to be copied, this fact being recognised
  75    by macro->function being non-null. It was chosen that the
  76    call-back function would not have the possibility to fail.
  77 */
  78
  79 static Bool menu_parser_read_macro_def(WMenuParser parser, WParserMacro *macro, char **argname);
  80
  81 static Bool menu_parser_read_macro_args(WMenuParser parser, WParserMacro *macro,
  82                                         char *array[], char *buffer, ssize_t buffer_size);
  83
  84 /* Free all used memory associated with parser's macros */
  85 void menu_parser_free_macros(WMenuParser parser)
  86 {
  87         WParserMacro *macro, *mnext;
  88 #ifdef DEBUG
  89         unsigned char *rd;
  90         unsigned int size;
  91         unsigned int count;
  92
  93         /* if we were compiled with debugging, we take the opportunity that we
  94                 parse the list of macros, for memory release, to print all the
  95                 definitions */
  96         printf(__FILE__ ": Macros defined while parsing \"%s\"\n", parser->file_name);
  97         count = 0;
  98 #endif
  99         for (macro = parser->macros; macro != NULL; macro = mnext) {
 100 #ifdef DEBUG
 101                 printf("  %s", macro->name);
 102                 if (macro->arg_count >= 0)
 103                         printf("(args=%d)", macro->arg_count);
 104                 printf(" = ");
 105
 106                 if (macro->function != NULL) {
 107                         macro->function(macro, parser);
 108                         printf("function:\"%s\"", macro->value);
 109                 } else {
 110                         rd = macro->value;
 111                         for (;;) {
 112                                 putchar('"');
 113                                 size  = (*rd++) << 8;
 114                                 size |=  *rd++;
 115                                 while (size-- > 0) putchar(*rd++);
 116                                 putchar('"');
 117                                 if (*rd == 0xFF) break;
 118                                 printf(" #%d ", (*rd++) + 1);
 119                         }
 120                 }
 121                 printf(", used %d times\n", macro->usage_count);
 122                 count++;
 123 #endif
 124                 mnext = macro->next;
 125                 wfree(macro);
 126         }
 127 #ifdef DEBUG
 128         printf(__FILE__ ": %d macros\n", count);
 129 #endif
 130         parser->macros = NULL; // Security
 131 }
 132
 133 /* Check wether the specified character is valid for a name (macro, parameter) or not */
 134 int isnamechr(char ch)
 135 {
 136         static const int table[256] = {
 137                 [0] = 0, // In case we'd fall on buggy compiler, to avoid crash
 138                 // C99: 6.7.8.21 -> non specified values are initialised to 0
 139                 ['0'] = 1, ['1'] = 1, ['2'] = 1, ['3'] = 1, ['4'] = 1,
 140                 ['5'] = 1, ['6'] = 1, ['7'] = 1, ['8'] = 1, ['9'] = 1,
 141                 ['A'] = 1, ['B'] = 1, ['C'] = 1, ['D'] = 1, ['E'] = 1, ['F'] = 1,
 142                 ['G'] = 1, ['H'] = 1, ['I'] = 1, ['J'] = 1, ['K'] = 1, ['L'] = 1,
 143                 ['M'] = 1, ['N'] = 1, ['O'] = 1, ['P'] = 1, ['Q'] = 1, ['R'] = 1,
 144                 ['S'] = 1, ['T'] = 1, ['U'] = 1, ['V'] = 1, ['W'] = 1, ['X'] = 1,
 145                 ['Y'] = 1, ['Z'] = 1,
 146                 ['a'] = 1, ['b'] = 1, ['c'] = 1, ['d'] = 1, ['e'] = 1, ['f'] = 1,
 147                 ['g'] = 1, ['h'] = 1, ['i'] = 1, ['j'] = 1, ['k'] = 1, ['l'] = 1,
 148                 ['m'] = 1, ['n'] = 1, ['o'] = 1, ['p'] = 1, ['q'] = 1, ['r'] = 1,
 149                 ['s'] = 1, ['t'] = 1, ['u'] = 1, ['v'] = 1, ['w'] = 1, ['x'] = 1,
 150                 ['y'] = 1, ['z'] = 1,
 151                 ['_'] = 1
 152                 // We refuse any UTF-8 coded character, or accents in ISO-xxx codepages
 153         };
 154         return table[0x00FF & (unsigned)ch ];
 155 }
 156
 157 /* Parse the definition of the macro and add it to the top-most parser's list */
 158 void menu_parser_define_macro(WMenuParser parser)
 159 {
 160         WParserMacro *macro;
 161         int idx;
 162         char arg_names_buf[MAXLINE];
 163         char *arg_name[MAX_MACRO_ARG_COUNT];
 164
 165         if (!menu_parser_skip_spaces_and_comments(parser)) {
 166                 WMenuParserError(parser, _("no macro name found for #define") );
 167                 return;
 168         }
 169         macro = wmalloc(sizeof(*macro));
 170
 171         /* Isolate name of macro */
 172         idx = 0;
 173         while (isnamechr(*parser->rd)) {
 174                 if (idx < sizeof(macro->name) - 1)
 175                         macro->name[idx++] = *parser->rd;
 176                 parser->rd++;
 177         }
 178         // macro->name[idx] = '\0'; -> Already present because wmalloc filled struct with 0s
 179
 180         /* Build list of expected arguments */
 181         if (*parser->rd == '(') {
 182                 parser->rd++;
 183                 idx = 0;
 184                 for (;;) {
 185                         if (!menu_parser_skip_spaces_and_comments(parser)) {
 186                         arglist_error_premature_eol:
 187                                 WMenuParserError(parser, _("premature end of file while reading arg-list for macro \"%s\""), macro->name);
 188                                 wfree(macro);
 189                                 return;
 190                         }
 191                         if (*parser->rd == ')') break;
 192
 193                         if (macro->arg_count >= wlengthof(arg_name)) {
 194                                 WMenuParserError(parser, _("too many parameters for macro \"%s\" definition"), macro->name);
 195                                 wfree(macro);
 196                                 *parser->rd = '\0'; // fake end-of-line to avoid warnings from remaining line content
 197                                 return;
 198                         }
 199                         if (isnamechr(*parser->rd)) {
 200                                 arg_name[macro->arg_count++] = arg_names_buf + idx;
 201                                 do {
 202                                         if (idx < sizeof(arg_names_buf) - 1)
 203                                                 arg_names_buf[idx++] = *parser->rd;
 204                                         parser->rd++;
 205                                 } while (isnamechr(*parser->rd));
 206                                 arg_names_buf[idx] = '\0';
 207                                 if (idx < sizeof(arg_names_buf) - 1) idx++;
 208                         } else {
 209                                 WMenuParserError(parser, _("invalid characted '%c' in arg-list for macro \"%s\" while expecting parameter name"),
 210                                                                           *parser->rd, macro->name);
 211                                 wfree(macro);
 212                                 *parser->rd = '\0'; // fake end-of-line to avoid warnings from remaining line content
 213                                 return;
 214                         }
 215                         if (!menu_parser_skip_spaces_and_comments(parser))
 216                                 goto arglist_error_premature_eol;
 217                         if (*parser->rd == ')') break;
 218
 219                         if (*parser->rd != ',') {
 220                                 WMenuParserError(parser, _("invalid characted '%c' in arg-list for macro \"%s\" while expecting ',' or ')'"),
 221                                                                           *parser->rd, macro->name);
 222                                 wfree(macro);
 223                                 *parser->rd = '\0'; // fake end-of-line to avoid warnings from remaining line content
 224                                 return;
 225                         }
 226                         parser->rd++;
 227                 }
 228                 parser->rd++;  // skip the closing ')'
 229         } else
 230                 macro->arg_count = -1; // Means no parenthesis at all to expect
 231
 232         /* If we're inside a #if sequence, we abort now, but not sooner in
 233                 order to keep the syntax check */
 234         if (parser->cond.stack[0].skip) {
 235                 wfree(macro);
 236                 *parser->rd = '\0'; // Ignore macro content
 237                 return;
 238         }
 239
 240         /* Get the macro's definition */
 241         menu_parser_skip_spaces_and_comments(parser);
 242         if (!menu_parser_read_macro_def(parser, macro, arg_name)) {
 243                 wfree(macro);
 244                 return;
 245         }
 246
 247         /* Create the macro in the Root parser */
 248         while (parser->parent_file != NULL)
 249                 parser = parser->parent_file;
 250
 251         /* Check that the macro was not already defined */
 252         if (menu_parser_find_macro(parser, macro->name) != NULL) {
 253                 WMenuParserError(parser, _("macro \"%s\" already defined, ignoring redefinition"),
 254                                                           macro->name);
 255                 wfree(macro);
 256                 return;
 257         }
 258
 259         /* Append at beginning of list */
 260         macro->next = parser->macros;
 261         parser->macros = macro;
 262 }
 263
 264 /* Check if the current word in the parser matches a macro */
 265 WParserMacro *menu_parser_find_macro(WMenuParser parser, const char *name)
 266 {
 267         const char *ref, *cmp;
 268         WParserMacro *macro;
 269
 270         while (parser->parent_file != NULL)
 271                 parser = parser->parent_file;
 272         for (macro = parser->macros; macro != NULL; macro = macro->next) {
 273                 ref = macro->name;
 274                 cmp = name;
 275                 while (*ref != '\0')
 276                         if (*ref++ != *cmp++)
 277                                 goto check_next_macro;
 278                 if (isnamechr(*cmp))
 279                         continue;
 280
 281                 return macro;
 282         check_next_macro: ;
 283         }
 284         return NULL;
 285 }
 286
 287 /* look to see if the next word matches the name of one of the parameter
 288         names for a macro definition
 289         This function is internal to the macro definition function as this is
 290         where the analysis is done */
 291 static inline char *mp_is_parameter(char *parse, const char *param) {
 292         while (*param)
 293                 if (*parse++ != *param++)
 294                         return NULL;
 295         if (isnamechr(*parse))
 296                 return NULL;
 297         return parse;
 298 }
 299
 300 /* Read the content definition part of a #define construct (the part after the optional
 301         argument list) and store it in the prepared format for quick expansion
 302
 303         There is no need to keep track of the names of the parameters, so they are stored in
 304         a temporary storage for the time of the macro parsing. */
 305 static Bool menu_parser_read_macro_def(WMenuParser parser, WParserMacro *macro, char **arg)
 306 {
 307         unsigned char *wr_size;
 308         unsigned char *wr;
 309         unsigned int size_data;
 310         unsigned int size_max;
 311         int i;
 312
 313         wr_size = macro->value;
 314         size_data = 0;
 315         wr = wr_size + 2;
 316         size_max = sizeof(macro->value) - (wr - macro->value) - 3;
 317         while (menu_parser_skip_spaces_and_comments(parser)) {
 318                 if (isnamechr(*parser->rd)) {
 319                         char *next_rd;
 320
 321                         /* Is the current word a parameter to replace? */
 322                         for (i = 0; i < macro->arg_count; i++) {
 323                                 next_rd = mp_is_parameter(parser->rd, arg[i]);
 324                                 if (next_rd != NULL) {
 325                                         if (wr + 4 >= macro->value + sizeof(macro->value))
 326                                                 goto error_too_much_data;
 327                                         wr_size[0] = (size_data >> 8) & 0xFF;
 328                                         wr_size[1] =  size_data       & 0xFF;
 329                                         *wr++ = i;
 330                                         wr_size = wr;
 331                                         wr += 2;
 332                                         parser->rd = next_rd;
 333                                         *wr++ = ' ';
 334                                         size_data = 1;
 335                                         size_max = sizeof(macro->value) - (wr - macro->value) - 3;
 336                                         goto next_loop; // Because we can't 'break' this loop and 'continue'
 337                                         //                 the outer one in a clean and easy way
 338                                 }
 339                         }
 340
 341                         /* Not parameter name -> copy as-is */
 342                         do {
 343                                 *wr++ = *parser->rd++;
 344                                 if (++size_data >= size_max) {
 345                                 error_too_much_data:
 346                                         WMenuParserError(parser, _("more content than supported for the macro \"%s\""),
 347                                                                                   macro->name);
 348                                         return False;
 349                                 }
 350                         } while (isnamechr(*parser->rd));
 351                         if (isspace(*parser->rd)) {
 352                                 *wr++ = ' ';
 353                                 if (++size_data >= size_max)
 354                                         goto error_too_much_data;
 355                         }
 356                 } else {
 357                         /* Some uninterresting characters, copy as-is */
 358                         while (*parser->rd != '\0') {
 359                                 if (isnamechr(*parser->rd)) break; // handle in next loop
 360                                 if (parser->rd[0] == '/')
 361                                         if ((parser->rd[1] == '*') || (parser->rd[1] == '/'))
 362                                                 break; // Comments are handled by std function
 363                                 if ((parser->rd[0] == '\\') &&
 364                                          (parser->rd[1] == '\n') &&
 365                                          (parser->rd[2] == '\0'))
 366                                         break; // Long-lines are handled by std function
 367                                 *wr++ = *parser->rd++;
 368                                 if (++size_data >= size_max)
 369                                         goto error_too_much_data;
 370                         }
 371                 }
 372         next_loop:
 373                 ;
 374         }
 375         wr_size[0] = (size_data >> 8) & 0xFF;
 376         wr_size[1] =  size_data       & 0xFF;
 377         *wr = 0xFF;
 378         return True;
 379 }
 380
 381 /* When a macro is being used in the file, this function will generate the
 382         expanded value for the macro in the parser's work line.
 383         It blindly supposes that the data generated in macro->value is valid */
 384 void menu_parser_expand_macro(WMenuParser parser, WParserMacro *macro)
 385 {
 386         char save_buf[sizeof(parser->line_buffer)];
 387         char arg_values_buf[MAXLINE];
 388         char *arg_value[MAX_MACRO_ARG_COUNT];
 389         char *src, *dst;
 390         unsigned char *rd;
 391         unsigned int size;
 392         int i, space_left;
 393
 394         /* Skip the name of the macro, this was not done by caller */
 395         for (i = 0; macro->name[i] != '\0'; i++)
 396                 parser->rd++;
 397
 398         if (macro->arg_count >= 0) {
 399                 menu_parser_skip_spaces_and_comments(parser);
 400                 if (!menu_parser_read_macro_args(parser, macro, arg_value, arg_values_buf, sizeof(arg_values_buf)))
 401                         return;
 402         }
 403
 404 #ifdef DEBUG
 405         macro->usage_count++;
 406 #endif
 407
 408         /* Save the remaining data from current line as we will overwrite the
 409                 current line's workspace with the expanded macro, so we can re-append
 410                 it afterwards */
 411         dst = save_buf;
 412         while ((*dst++ = *parser->rd++) != '\0') ;
 413
 414         /* Generate expanded macro */
 415         dst = parser->line_buffer;
 416         parser->rd = dst;
 417         space_left = sizeof(parser->line_buffer) - 1;
 418         if (macro->function != NULL) {
 419         /* Parser's pre-defined macros actually proposes a function call to
 420                           generate dynamic value for the expansion of the macro. In this case
 421                           it is generated as a C string in the macro->value and used directly */
 422                 macro->function(macro, parser);
 423                 rd = macro->value;
 424                 while (--space_left > 0)
 425                         if ((*dst = *rd++) == '\0')
 426                                 break;
 427                         else
 428                                 dst++;
 429         } else {
 430                 rd = macro->value;
 431                 for (;;) {
 432                         size  = (*rd++) << 8;
 433                         size |=  *rd++;
 434                         while (size-- > 0) {
 435                                 *dst = *rd++;
 436                                 if (--space_left > 0) dst++;
 437                         }
 438                         if (*rd == 0xFF) break;
 439                         src = arg_value[*rd++];
 440                         while (*src) {
 441                                 *dst = *src++;
 442                                 if (--space_left > 0) dst++;
 443                         }
 444                 }
 445         }
 446
 447         /* Copy finished -> Re-append the text that was following the macro */
 448         src = save_buf;
 449         while (--space_left > 0)
 450                 if ((*dst++ = *src++) == '\0')
 451                         break;
 452         *dst = '\0';
 453
 454         if (space_left <= 0)
 455                 WMenuParserError(parser, _("expansion for macro \"%s\" too big, line truncated"),
 456                                                           macro->name);
 457 }
 458
 459 /* When reading a macro to be expanded (not being defined), that takes arguments,
 460         this function parses the arguments being provided */
 461 static Bool menu_parser_read_macro_args(WMenuParser parser, WParserMacro *macro,
 462                                                                                                          char *array[], char *buffer, ssize_t buffer_size)
 463 {
 464         int arg;
 465
 466         if (*parser->rd != '(') {
 467                 WMenuParserError(parser, _("macro \"%s\" needs parenthesis for arguments"),
 468                                                           macro->name);
 469                 return False;
 470         }
 471         parser->rd++;
 472
 473         buffer_size--; // Room for final '\0'
 474         menu_parser_skip_spaces_and_comments(parser);
 475         arg = 0;
 476         for (;;) {
 477                 int paren_count;
 478
 479                 array[arg] = buffer;
 480                 paren_count = 0;
 481                 while (*parser->rd != '\0') {
 482
 483                         if (*parser->rd == '(')
 484                                 paren_count++;
 485
 486                         if (paren_count <= 0)
 487                                 if ((*parser->rd == ',') ||
 488                                          (*parser->rd == ')') ) break;
 489
 490                         if ((*parser->rd == '"') || (*parser->rd == '\'')) {
 491                                 char eot = *parser->rd++;
 492                                 if (buffer_size-- > 0) *buffer++ = eot;
 493                                 while (*parser->rd) {
 494                                         if ((*buffer = *parser->rd++) == eot)
 495                                                 goto found_end_of_string;
 496                                         if (buffer_size-- > 0) buffer++;
 497                                 }
 498                                 WMenuParserError(parser, _("missing closing quote or double-quote before end-of-line") );
 499                                 return False;
 500                         found_end_of_string:
 501                                 continue;
 502                         }
 503
 504                         if (isspace(*parser->rd)) {
 505                                 if (buffer_size-- > 0) *buffer++ = ' ';
 506                                 menu_parser_skip_spaces_and_comments(parser);
 507                                 continue;
 508                         }
 509
 510                         *buffer = *parser->rd++;
 511                         if (buffer_size-- > 0) buffer++;
 512                 }
 513                 *buffer = '\0';
 514                 if (buffer_size-- > 0) buffer++;
 515
 516                 arg++;
 517
 518                 if (*parser->rd == ',') {
 519                         parser->rd++;
 520                         if (arg >= macro->arg_count) {
 521                                 WMenuParserError(parser, _("too many arguments for macro \"%s\", expected only %d"),
 522                                                                           macro->name, macro->arg_count);
 523                                 return False;
 524                         }
 525                         continue;
 526                 }
 527                 break;
 528         }
 529         if (*parser->rd != ')') {
 530                 WMenuParserError(parser, _("premature end of line while searching for arguments to macro \"%s\""),
 531                                                           macro->name);
 532                 return False;
 533         }
 534         parser->rd++;
 535         if (arg < macro->arg_count) {
 536                 WMenuParserError(parser, _("not enough arguments for macro \"%s\", expected %d but got only %d"),
 537                                                           macro->name, macro->arg_count, arg);
 538                 return False;
 539         }
 540         if (buffer_size < 0)
 541                 WMenuParserError(parser, _("too much data in parameter list of macro \"%s\", truncated"),
 542                                                           macro->name);
 543         return True;
 544 }
 545
 546 /******************************************************************************/
 547 /* Definition of pre-defined macros */
 548 /******************************************************************************/
 549
 550 void WMenuParserRegisterSimpleMacro(WMenuParser parser, const char *name, const char *value)
 551 {
 552         WParserMacro *macro;
 553         size_t len;
 554         unsigned char *wr;
 555
 556         macro = wmalloc(sizeof(*macro));
 557         strncpy(macro->name, name, sizeof(macro->name)-1);
 558         macro->arg_count = -1;
 559         len = strlen(value);
 560         if (len > sizeof(macro->value) - 3) {
 561                 wwarning(_("size of value for macro '%s' is too big, truncated"), name);
 562                 len = sizeof(macro->value) - 3;
 563         }
 564         macro->value[0] = (len >> 8) & 0xFF;
 565         macro->value[1] =  len       & 0xFF;
 566         wr = &macro->value[2];
 567         while (len-- > 0)
 568                 *wr++ = *value++;
 569         *wr = 0xFF;
 570         macro->next = parser->macros;
 571         parser->macros = macro;
 572 }
 573
 574 /* Name of the originally loaded file (before #includes) */
 575 static void mpm_base_file(WParserMacro *this, WMenuParser parser)
 576 {
 577         unsigned char *src, *dst;
 578
 579         if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
 580
 581         while (parser->parent_file != NULL)
 582                 parser = parser->parent_file;
 583
 584         dst = this->value;
 585         src = (unsigned char *) parser->file_name;
 586         *dst++ = '\"';
 587         while (*src != '\0')
 588                 if (dst < this->value + sizeof(this->value) - 2)
 589                         *dst++ = *src++;
 590                 else
 591                         break;
 592         *dst++ = '\"';
 593         *dst   = '\0';
 594 }
 595
 596 /* Number of #include currently nested */
 597 static void mpm_include_level(WParserMacro *this, WMenuParser parser)
 598 {
 599         int level = 0;
 600         while (parser->parent_file != NULL) {
 601                 parser = parser->parent_file;
 602                 level++;
 603         }
 604         snprintf((char *) this->value, sizeof(this->value), "%d", level);
 605 }
 606
 607 /* Name of current file */
 608 static void mpm_current_file(WParserMacro *this, WMenuParser parser)
 609 {
 610         unsigned char *src, *dst;
 611
 612         dst = this->value;
 613         src = (unsigned char *) parser->file_name;
 614         *dst++ = '\"';
 615         while (*src != '\0')
 616                 if (dst < this->value + sizeof(this->value) - 2)
 617                         *dst++ = *src++;
 618                 else
 619                         break;
 620         *dst++ = '\"';
 621         *dst   = '\0';
 622 }
 623
 624 /* Number of current line */
 625 static void mpm_current_line(WParserMacro *this, WMenuParser parser)
 626 {
 627         snprintf((char *) this->value, sizeof(this->value), "%d", parser->line_number);
 628 }
 629
 630 /* Name of host on which we are running, not necessarily displaying */
 631 static void mpm_get_hostname(WParserMacro *this, WMenuParser parser)
 632 {
 633         char *h;
 634
 635         if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
 636
 637         h = getenv("HOSTNAME");
 638         if (h == NULL) {
 639                 h = getenv("HOST");
 640                 if (h == NULL) {
 641                         if (gethostname((char *) this->value, sizeof(this->value) ) != 0) {
 642                                 WMenuParserError(parser, _("could not determine %s"), "HOSTNAME");
 643                                 this->value[0] = '?';
 644                                 this->value[1] = '?';
 645                                 this->value[2] = '?';
 646                                 this->value[3] = '\0';
 647                         }
 648                         return;
 649                 }
 650         }
 651         wstrlcpy((char *) this->value, h, sizeof(this->value) );
 652 }
 653
 654 /* Name of the current user */
 655 static void mpm_get_user_name(WParserMacro *this, WMenuParser parser)
 656 {
 657         char *user;
 658
 659         if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
 660
 661         user = getlogin();
 662         if (user == NULL) {
 663                 struct passwd *pw_user;
 664
 665                 pw_user = getpwuid(getuid());
 666                 if (pw_user == NULL) {
 667                 error_no_username:
 668                         WMenuParserError(parser, _("could not determine %s"), "USER" );
 669                         /* Fall back on numeric id - better than nothing */
 670                         snprintf((char *) this->value, sizeof(this->value), "%d", getuid() );
 671                         return;
 672                 }
 673                 user = pw_user->pw_name;
 674                 if (user == NULL) goto error_no_username;
 675         }
 676         wstrlcpy((char *) this->value, user, sizeof(this->value) );
 677 }
 678
 679 /* Number id of the user under which we are running */
 680 static void mpm_get_user_id(WParserMacro *this, WMenuParser parser)
 681 {
 682         /* Parameter not used, but tell the compiler that it is ok */
 683         (void) parser;
 684
 685         if (this->value[0] != '\0') return; // Already evaluated, re-use previous
 686         snprintf((char *) this->value, sizeof(this->value), "%d", getuid() );
 687 }
 688
 689 /* Small helper to automate creation of one pre-defined macro in the parser */
 690 static void w_create_macro(WMenuParser parser, const char *name, WParserMacroFunction *handler)
 691 {
 692         WParserMacro *macro;
 693
 694         macro = wmalloc(sizeof(*macro));
 695         strcpy(macro->name, name);
 696         macro->function = handler;
 697         macro->arg_count = -1;
 698         macro->next = parser->macros;
 699         parser->macros = macro;
 700 }
 701
 702 /***** Register all the pre-defined macros in the parser *****/
 703 void menu_parser_register_preset_macros(WMenuParser parser)
 704 {
 705         /* Defined by CPP: common predefined macros (GNU C extension) */
 706         w_create_macro(parser, "__BASE_FILE__", mpm_base_file);
 707         w_create_macro(parser, "__INCLUDE_LEVEL__", mpm_include_level);
 708
 709         /* Defined by CPP: standard predefined macros */
 710         w_create_macro(parser, "__FILE__", mpm_current_file);
 711         w_create_macro(parser, "__LINE__", mpm_current_line);
 712         // w_create_macro(parser, "__DATE__", NULL);  [will be implemented only per user request]
 713         // w_create_macro(parser, "__TIME__", NULL);  [will be implemented only per user request]
 714
 715         /* Historically defined by WindowMaker */
 716         w_create_macro(parser, "HOST", mpm_get_hostname);
 717         w_create_macro(parser, "UID", mpm_get_user_id);
 718         w_create_macro(parser, "USER", mpm_get_user_name);
 719 }