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 >= sizeof(arg_name) / sizeof(arg_name[0])) {
 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                                                                                 char *write_buf, int write_buf_size)
 386 {
 387         char save_buf[sizeof(parser->line_buffer)];
 388         char arg_values_buf[MAXLINE];
 389         char *arg_value[MAX_MACRO_ARG_COUNT];
 390         char *src, *dst;
 391         unsigned char *rd;
 392         unsigned int size;
 393         int space_left;
 394
 395         if (macro->arg_count >= 0) {
 396                 menu_parser_skip_spaces_and_comments(parser);
 397                 if (!menu_parser_read_macro_args(parser, macro, arg_value, arg_values_buf, sizeof(arg_values_buf)))
 398                         return;
 399         }
 400
 401 #ifdef DEBUG
 402         macro->usage_count++;
 403 #endif
 404
 405         /* Save the remaining data from current line as we will overwrite the
 406                 current line's workspace with the expanded macro, so we can re-append
 407                 it afterwards */
 408         dst = save_buf;
 409         while ((*dst++ = *parser->rd++) != '\0') ;
 410
 411         /* Generate expanded macro */
 412         dst = write_buf;
 413         space_left = write_buf_size - 1;
 414         if (macro->function != NULL) {
 415         /* Parser's pre-defined macros actually proposes a function call to
 416                           generate dynamic value for the expansion of the macro. In this case
 417                           it is generated as a C string in the macro->value and used directly */
 418                 macro->function(macro, parser);
 419                 rd = macro->value;
 420                 while (--space_left > 0)
 421                         if ((*dst = *rd++) == '\0')
 422                                 break;
 423                         else
 424                                 dst++;
 425         } else {
 426                 rd = macro->value;
 427                 for (;;) {
 428                         size  = (*rd++) << 8;
 429                         size |=  *rd++;
 430                         while (size-- > 0) {
 431                                 *dst = *rd++;
 432                                 if (--space_left > 0) dst++;
 433                         }
 434                         if (*rd == 0xFF) break;
 435                         src = arg_value[*rd++];
 436                         while (*src) {
 437                                 *dst = *src++;
 438                                 if (--space_left > 0) dst++;
 439                         }
 440                 }
 441         }
 442
 443         /* Copy finished -> Re-append the text that was following the macro */
 444         src = save_buf;
 445         while (--space_left > 0)
 446                 if ((*dst++ = *src++) == '\0')
 447                         break;
 448         *dst = '\0';
 449
 450         if (space_left <= 0)
 451                 WMenuParserError(parser, _("expansion for macro \"%s\" too big, line truncated"),
 452                                                           macro->name);
 453 }
 454
 455 /* When reading a macro to be expanded (not being defined), that takes arguments,
 456         this function parses the arguments being provided */
 457 static Bool menu_parser_read_macro_args(WMenuParser parser, WParserMacro *macro,
 458                                                                                                          char *array[], char *buffer, ssize_t buffer_size)
 459 {
 460         int arg;
 461
 462         if (*parser->rd != '(') {
 463                 WMenuParserError(parser, _("macro \"%s\" needs parenthesis for arguments"),
 464                                                           macro->name);
 465                 return False;
 466         }
 467         parser->rd++;
 468
 469         buffer_size--; // Room for final '\0'
 470         menu_parser_skip_spaces_and_comments(parser);
 471         arg = 0;
 472         for (;;) {
 473                 int paren_count;
 474
 475                 array[arg] = buffer;
 476                 paren_count = 0;
 477                 while (*parser->rd != '\0') {
 478
 479                         if (*parser->rd == '(')
 480                                 paren_count++;
 481
 482                         if (paren_count <= 0)
 483                                 if ((*parser->rd == ',') ||
 484                                          (*parser->rd == ')') ) break;
 485
 486                         if ((*parser->rd == '"') || (*parser->rd == '\'')) {
 487                                 char eot = *parser->rd++;
 488                                 if (buffer_size-- > 0) *buffer++ = eot;
 489                                 while (*parser->rd) {
 490                                         if ((*buffer = *parser->rd++) == eot)
 491                                                 goto found_end_of_string;
 492                                         if (buffer_size-- > 0) buffer++;
 493                                 }
 494                                 WMenuParserError(parser, _("missing closing quote or double-quote before end-of-line") );
 495                                 return False;
 496                         found_end_of_string:
 497                                 continue;
 498                         }
 499
 500                         if (isspace(*parser->rd)) {
 501                                 if (buffer_size-- > 0) *buffer++ = ' ';
 502                                 menu_parser_skip_spaces_and_comments(parser);
 503                                 continue;
 504                         }
 505
 506                         *buffer = *parser->rd++;
 507                         if (buffer_size-- > 0) buffer++;
 508                 }
 509                 *buffer = '\0';
 510                 if (buffer_size-- > 0) buffer++;
 511
 512                 arg++;
 513
 514                 if (*parser->rd == ',') {
 515                         parser->rd++;
 516                         if (arg >= macro->arg_count) {
 517                                 WMenuParserError(parser, _("too many arguments for macro \"%s\", expected only %d"),
 518                                                                           macro->name, macro->arg_count);
 519                                 return False;
 520                         }
 521                         continue;
 522                 }
 523                 break;
 524         }
 525         if (*parser->rd != ')') {
 526                 WMenuParserError(parser, _("premature end of line while searching for arguments to macro \"%s\""),
 527                                                           macro->name);
 528                 return False;
 529         }
 530         parser->rd++;
 531         if (arg < macro->arg_count) {
 532                 WMenuParserError(parser, _("not enough arguments for macro \"%s\", expected %d but got only %d"),
 533                                                           macro->name, macro->arg_count, arg);
 534                 return False;
 535         }
 536         if (buffer_size < 0)
 537                 WMenuParserError(parser, _("too much data in parameter list of macro \"%s\", truncated"),
 538                                                           macro->name);
 539         return True;
 540 }
 541
 542 /******************************************************************************/
 543 /* Definition of pre-defined macros */
 544 /******************************************************************************/
 545
 546 void WMenuParserRegisterSimpleMacro(WMenuParser parser, const char *name, const char *value)
 547 {
 548         WParserMacro *macro;
 549         size_t len;
 550         unsigned char *wr;
 551
 552         macro = wmalloc(sizeof(*macro));
 553         strncpy(macro->name, name, sizeof(macro->name)-1);
 554         macro->arg_count = -1;
 555         len = strlen(value);
 556         if (len > sizeof(macro->value) - 3) {
 557                 wwarning(_("size of value for macro '%s' is too big, truncated"), name);
 558                 len = sizeof(macro->value) - 3;
 559         }
 560         macro->value[0] = (len >> 8) & 0xFF;
 561         macro->value[1] =  len       & 0xFF;
 562         wr = &macro->value[2];
 563         while (len-- > 0)
 564                 *wr++ = *value++;
 565         *wr = 0xFF;
 566         macro->next = parser->macros;
 567         parser->macros = macro;
 568 }
 569
 570 /* Name of the originally loaded file (before #includes) */
 571 static void mpm_base_file(WParserMacro *this, WMenuParser parser)
 572 {
 573         unsigned char *src, *dst;
 574
 575         if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
 576
 577         while (parser->parent_file != NULL)
 578                 parser = parser->parent_file;
 579
 580         dst = this->value;
 581         src = (unsigned char *) parser->file_name;
 582         *dst++ = '\"';
 583         while (*src != '\0')
 584                 if (dst < this->value + sizeof(this->value) - 2)
 585                         *dst++ = *src++;
 586                 else
 587                         break;
 588         *dst++ = '\"';
 589         *dst   = '\0';
 590 }
 591
 592 /* Number of #include currently nested */
 593 static void mpm_include_level(WParserMacro *this, WMenuParser parser)
 594 {
 595         int level = 0;
 596         while (parser->parent_file != NULL) {
 597                 parser = parser->parent_file;
 598                 level++;
 599         }
 600         snprintf((char *) this->value, sizeof(this->value), "%d", level);
 601 }
 602
 603 /* Name of current file */
 604 static void mpm_current_file(WParserMacro *this, WMenuParser parser)
 605 {
 606         unsigned char *src, *dst;
 607
 608         dst = this->value;
 609         src = (unsigned char *) parser->file_name;
 610         *dst++ = '\"';
 611         while (*src != '\0')
 612                 if (dst < this->value + sizeof(this->value) - 2)
 613                         *dst++ = *src++;
 614                 else
 615                         break;
 616         *dst++ = '\"';
 617         *dst   = '\0';
 618 }
 619
 620 /* Number of current line */
 621 static void mpm_current_line(WParserMacro *this, WMenuParser parser)
 622 {
 623         snprintf((char *) this->value, sizeof(this->value), "%d", parser->line_number);
 624 }
 625
 626 /* Name of host on which we are running, not necessarily displaying */
 627 static void mpm_get_hostname(WParserMacro *this, WMenuParser parser)
 628 {
 629         char *h;
 630
 631         if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
 632
 633         h = getenv("HOSTNAME");
 634         if (h == NULL) {
 635                 h = getenv("HOST");
 636                 if (h == NULL) {
 637                         if (gethostname((char *) this->value, sizeof(this->value) ) != 0) {
 638                                 WMenuParserError(parser, _("could not determine %s"), "HOSTNAME");
 639                                 this->value[0] = '?';
 640                                 this->value[1] = '?';
 641                                 this->value[2] = '?';
 642                                 this->value[3] = '\0';
 643                         }
 644                         return;
 645                 }
 646         }
 647         wstrlcpy((char *) this->value, h, sizeof(this->value) );
 648 }
 649
 650 /* Name of the current user */
 651 static void mpm_get_user_name(WParserMacro *this, WMenuParser parser)
 652 {
 653         char *user;
 654
 655         if (this->value[0] != '\0') return; // Value already evaluated, re-use previous
 656
 657         user = getlogin();
 658         if (user == NULL) {
 659                 struct passwd *pw_user;
 660
 661                 pw_user = getpwuid(getuid());
 662                 if (pw_user == NULL) {
 663                 error_no_username:
 664                         WMenuParserError(parser, _("could not determine %s"), "USER" );
 665                         /* Fall back on numeric id - better than nothing */
 666                         snprintf((char *) this->value, sizeof(this->value), "%d", getuid() );
 667                         return;
 668                 }
 669                 user = pw_user->pw_name;
 670                 if (user == NULL) goto error_no_username;
 671         }
 672         wstrlcpy((char *) this->value, user, sizeof(this->value) );
 673 }
 674
 675 /* Number id of the user under which we are running */
 676 static void mpm_get_user_id(WParserMacro *this, WMenuParser parser)
 677 {
 678         if (this->value[0] != '\0') return; // Already evaluated, re-use previous
 679         snprintf((char *) this->value, sizeof(this->value), "%d", getuid() );
 680 }
 681
 682 /* Small helper to automate creation of one pre-defined macro in the parser */
 683 static void w_create_macro(WMenuParser parser, const char *name, WParserMacroFunction *handler)
 684 {
 685         WParserMacro *macro;
 686
 687         macro = wmalloc(sizeof(*macro));
 688         strcpy(macro->name, name);
 689         macro->function = handler;
 690         macro->arg_count = -1;
 691         macro->next = parser->macros;
 692         parser->macros = macro;
 693 }
 694
 695 /***** Register all the pre-defined macros in the parser *****/
 696 void menu_parser_register_preset_macros(WMenuParser parser)
 697 {
 698         /* Defined by CPP: common predefined macros (GNU C extension) */
 699         w_create_macro(parser, "__BASE_FILE__", mpm_base_file);
 700         w_create_macro(parser, "__INCLUDE_LEVEL__", mpm_include_level);
 701
 702         /* Defined by CPP: standard predefined macros */
 703         w_create_macro(parser, "__FILE__", mpm_current_file);
 704         w_create_macro(parser, "__LINE__", mpm_current_line);
 705         // w_create_macro(parser, "__DATE__", NULL);  [will be implemented only per user request]
 706         // w_create_macro(parser, "__TIME__", NULL);  [will be implemented only per user request]
 707
 708         /* Historically defined by WindowMaker */
 709         w_create_macro(parser, "HOST", mpm_get_hostname);
 710         w_create_macro(parser, "UID", mpm_get_user_id);
 711         w_create_macro(parser, "USER", mpm_get_user_name);
 712 }