src/builtins.c

   1 /*
   2  * Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.
   3  *
   4  * This file is part of Jam - see jam.c for Copyright information.
   5  */
   6
   7 /*
   8  * builtins.c - builtin jam rules
   9  *
  10  * External routines:
  11  *
  12  *  load_builtin() - define builtin rules
  13  *
  14  * Internal routines:
  15  *
  16  *  builtin_depends() - DEPENDS/INCLUDES rule
  17  *  builtin_echo() - ECHO rule
  18  *  builtin_echon() - ECHO-N rule
  19  *  builtin_oflush() - O-FLUSH rule
  20  *  builtin_exit() - EXIT rule
  21  *  builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule
  22  *  builtin_glob() - GLOB rule
  23  *  builtin_match() - MATCH rule
  24  *  builtin_hdrmacro() - HDRMACRO rule
  25  *
  26  * 01/10/01 (seiwald) - split from compile.c
  27  * 01/08/01 (seiwald) - new 'Glob' (file expansion) builtin
  28  * 03/02/02 (seiwald) - new 'Match' (regexp match) builtin
  29  * 04/03/02 (seiwald) - Glob matches only filename, not directory
  30  * 10/22/02 (seiwald) - list_new() now does its own newstr()/copystr()
  31  * 10/22/02 (seiwald) - working return/break/continue statements
  32  * 11/04/02 (seiwald) - const-ing for string literals
  33  * 12/03/02 (seiwald) - fix odd includes support by grafting them onto depends
  34  * 01/14/03 (seiwald) - fix includes fix with new internal includes TARGET
  35  */
  36
  37 #include <unistd.h>
  38 #include <limits.h>
  39
  40 #include "jam.h"
  41
  42 #include "lists.h"
  43 #include "parse.h"
  44 #include "builtins.h"
  45 #include "rules.h"
  46 #include "filesys.h"
  47 #include "newstr.h"
  48 #include "hsregexp.h"
  49 #include "pathsys.h"
  50 #include "hdrmacro.h"
  51
  52 #include "kstrings.h"
  53
  54
  55 /*
  56  * compile_builtin() - define builtin rules
  57  */
  58
  59 #define P0 (PARSE *)0
  60 #define C0 (char *)0
  61
  62
  63 int glob (const char *s, const char *c);
  64
  65
  66 void load_builtins (void) {
  67   bindrule("Always")->procedure =
  68   bindrule("ALWAYS")->procedure =
  69   parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_TOUCHED);
  70
  71   bindrule("Depends")->procedure =
  72   bindrule("DEPENDS")->procedure =
  73   parse_make(builtin_depends, P0, P0, P0, C0, C0, 0);
  74
  75   bindrule("echo")->procedure =
  76   bindrule("Echo")->procedure =
  77   bindrule("ECHO")->procedure =
  78   parse_make(builtin_echo, P0, P0, P0, C0, C0, 0);
  79
  80   bindrule("echo-n")->procedure =
  81   bindrule("Echo-n")->procedure =
  82   bindrule("ECHO-N")->procedure =
  83   parse_make(builtin_echon, P0, P0, P0, C0, C0, 0);
  84
  85   bindrule("o-flush")->procedure =
  86   bindrule("O-flush")->procedure =
  87   bindrule("O-Flush")->procedure =
  88   bindrule("O-FLUSH")->procedure =
  89   parse_make(builtin_oflush, P0, P0, P0, C0, C0, 0);
  90
  91   bindrule("exit")->procedure =
  92   bindrule("Exit")->procedure =
  93   bindrule("EXIT")->procedure =
  94   parse_make(builtin_exit, P0, P0, P0, C0, C0, 0);
  95
  96   bindrule("Glob")->procedure =
  97   bindrule("GLOB")->procedure =
  98   parse_make(builtin_glob, P0, P0, P0, C0, C0, 0);
  99
 100   bindrule("Includes")->procedure =
 101   bindrule("INCLUDES")->procedure =
 102   parse_make(builtin_depends, P0, P0, P0, C0, C0, 1);
 103
 104   bindrule("Leaves")->procedure =
 105   bindrule("LEAVES")->procedure =
 106   parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_LEAVES);
 107
 108   bindrule("Match")->procedure =
 109   bindrule("MATCH")->procedure =
 110   parse_make(builtin_match, P0, P0, P0, C0, C0, 0);
 111
 112   bindrule("NoCare")->procedure =
 113   bindrule("NOCARE")->procedure =
 114   parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_NOCARE);
 115
 116   bindrule("NOTIME")->procedure =
 117   bindrule("NotFile")->procedure =
 118   bindrule("NOTFILE")->procedure =
 119   parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_NOTFILE);
 120
 121   bindrule("NoUpdate")->procedure =
 122   bindrule("NOUPDATE")->procedure =
 123   parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_NOUPDATE);
 124
 125   bindrule("Temporary")->procedure =
 126   bindrule("TEMPORARY")->procedure =
 127   parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_TEMP);
 128
 129   bindrule("HdrMacro")->procedure =
 130   bindrule("HDRMACRO")->procedure =
 131   parse_make(builtin_hdrmacro, P0, P0, P0, C0, C0, 0);
 132
 133   bindrule("PWD")->procedure =
 134   bindrule("Pwd")->procedure =
 135   parse_make(builtin_pwd, P0, P0, P0, C0, C0, 0);
 136
 137   bindrule("SORT")->procedure =
 138   bindrule("Sort")->procedure =
 139   parse_make(builtin_sort, P0, P0, P0, C0, C0, 0);
 140
 141   bindrule("COMMAND")->procedure =
 142   bindrule("Command")->procedure =
 143   parse_make(builtin_command, P0, P0, P0, C0, C0, 0);
 144
 145   bindrule("ForceCare")->procedure =
 146   bindrule("FORCECARE")->procedure =
 147   parse_make(builtin_flags_forcecare, P0, P0, P0, C0, C0, T_FLAG_FORCECARE);
 148
 149   bindrule("ExprI1")->procedure =
 150   bindrule("EXPRI1")->procedure =
 151   parse_make(builtin_expri1, P0, P0, P0, C0, C0, 0);
 152
 153   bindrule("Split")->procedure =
 154   bindrule("SPLIT")->procedure =
 155   parse_make(builtin_split, P0, P0, P0, C0, C0, 0);
 156
 157   bindrule("DependsList")->procedure =
 158   bindrule("DEPENDSLIST")->procedure =
 159   parse_make(builtin_dependslist, P0, P0, P0, C0, C0, 0);
 160
 161   bindrule("NormPath")->procedure =
 162   bindrule("NORMPATH")->procedure =
 163   parse_make(builtin_normpath, P0, P0, P0, C0, C0, 0);
 164 }
 165
 166
 167 /*
 168  * builtin_depends() - DEPENDS/INCLUDES rule
 169  *
 170  * The DEPENDS builtin rule appends each of the listed sources on the
 171  * dependency list of each of the listed targets.
 172  * It binds both the targets and sources as TARGETs.
 173  */
 174 LIST *builtin_depends (PARSE *parse, LOL *args, int *jmp) {
 175   LIST *targets = lol_get(args, 0);
 176   LIST *sources = lol_get(args, 1);
 177   LIST *l;
 178   //
 179   for (l = targets; l; l = list_next(l)) {
 180     TARGET *t = bindtarget(l->string);
 181     /* If doing INCLUDES, switch to the TARGET's include */
 182     /* TARGET, creating it if needed.  The internal include */
 183     /* TARGET shares the name of its parent. */
 184     if (parse->num) {
 185       if (!t->includes) t->includes = copytarget(t);
 186       t = t->includes;
 187     }
 188     t->depends = targetlist(t->depends, sources);
 189   }
 190   return L0;
 191 }
 192
 193
 194 /*
 195  * builtin_echo() - ECHO rule
 196  *
 197  * The ECHO builtin rule echoes the targets to the user.
 198  * No other actions are taken.
 199  */
 200 LIST *builtin_echo (PARSE *parse, LOL *args, int *jmp) {
 201   list_print(lol_get(args, 0));
 202   printf("\n");
 203   return L0;
 204 }
 205
 206
 207 /*
 208  * builtin_echon() - ECHO-N rule
 209  *
 210  * The ECHO-N builtin rule echoes the targets to the user.
 211  * No other actions are taken, no newline is written.
 212  */
 213 LIST *builtin_echon (PARSE *parse, LOL *args, int *jmp) {
 214   list_print(lol_get(args, 0));
 215   return L0;
 216 }
 217
 218
 219 /*
 220  * builtin_oflush() - O-FLUSH rule
 221  *
 222  * The O-FLUSH builtin rule flushes current output stream.
 223  * Used with ECHO-N.
 224  */
 225 LIST *builtin_oflush (PARSE *parse, LOL *args, int *jmp) {
 226   fflush(stdout);
 227   return L0;
 228 }
 229
 230
 231 /*
 232  * builtin_exit() - EXIT rule
 233  *
 234  * The EXIT builtin rule echoes the targets to the user and exits
 235  * the program with a failure status.
 236  */
 237 LIST *builtin_exit (PARSE *parse, LOL *args, int *jmp) {
 238   list_print(lol_get(args, 0));
 239   printf("\n");
 240   exit(EXITBAD); /* yeech */
 241   return L0;
 242 }
 243
 244
 245 /*
 246  * builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule
 247  *
 248  * Builtin_flags() marks the target with the appropriate flag, for use by make0().
 249  * It binds each target as a TARGET.
 250  */
 251 LIST *builtin_flags (PARSE *parse, LOL *args, int *jmp) {
 252   LIST *l = lol_get(args, 0);
 253   for (; l; l = list_next(l)) bindtarget(l->string)->flags |= parse->num;
 254   return L0;
 255 }
 256
 257
 258 /*
 259  * builtin_flags_forcecare() - ForceCare rule
 260  */
 261 LIST *builtin_flags_forcecare (PARSE *parse, LOL *args, int *jmp) {
 262   LIST *l = lol_get(args, 0);
 263   for( ; l; l = list_next(l)) {
 264     TARGET *t = bindtarget(l->string);
 265     t->flags |= T_FLAG_FORCECARE;
 266     t->flags &= ~T_FLAG_NOCARE;
 267   }
 268   return L0;
 269 }
 270
 271
 272 /*
 273  * builtin_globbing() - GLOB rule
 274  */
 275 struct globbing {
 276   LIST  *patterns;
 277   LIST  *results;
 278 };
 279
 280
 281 static void builtin_glob_back (void  *closure, const char *file, int status, time_t time) {
 282   struct globbing *globbing = (struct globbing *)closure;
 283   LIST *l;
 284   PATHNAME f;
 285   char buf[MAXJPATH];
 286   /* null out directory for matching */
 287   /* we wish we had file_dirscan() pass up a PATHNAME */
 288   path_parse(file, &f);
 289   f.f_dir.len = 0;
 290   /* For globbing, we unconditionally ignore current and parent
 291    * directory items. Since those items always exist, there's no
 292    * reason why caller of GLOB would want to see them.
 293    * We could also change file_dirscan, but then paths with embedded
 294    * "." and ".." won't work anywhere. */
 295   /* k8: will this break anything? it shouldn't... */
 296   if (!strcmp(f.f_base.ptr, ".") || !strcmp(f.f_base.ptr, "..")) return;
 297   path_build(&f, buf, 0);
 298   for (l = globbing->patterns; l; l = l->next) {
 299     if (!glob(l->string, buf)) {
 300       globbing->results = list_new(globbing->results, file, 0);
 301       break;
 302     }
 303   }
 304 }
 305
 306
 307 LIST *builtin_glob (PARSE *parse, LOL *args, int *jmp) {
 308   struct globbing globbing;
 309   LIST *l = lol_get(args, 0);
 310   LIST *r = lol_get(args, 1);
 311   globbing.results = L0;
 312   globbing.patterns = r;
 313   for (; l; l = list_next(l)) file_dirscan(l->string, builtin_glob_back, &globbing);
 314   return globbing.results;
 315 }
 316
 317
 318 /*
 319  * builtin_match() - MATCH rule, regexp matching
 320  */
 321 LIST *builtin_match (PARSE *parse, LOL *args, int *jmp) {
 322   LIST *l, *r;
 323   LIST *res = 0;
 324   /* for each pattern */
 325   for (l = lol_get(args, 0); l; l = l->next) {
 326     HSRegExp re;
 327     HSRxMatch *mt;
 328     int err;
 329     //
 330     if ((err = hsrxCompile(&re, l->string, HSRX_EXTENDED|HSRX_NEWLINE)) != 0) {
 331       static char errbuf[512];
 332       //
 333       hsrxError(err, &re, errbuf, sizeof(errbuf));
 334       hsrxFree(&re);
 335       printf("FATAL: %s\n", errbuf);
 336       exit(42);
 337     }
 338     mt = malloc(sizeof(HSRxMatch)*(re.re_nsub+1));
 339     if (mt == NULL) { printf("FATAL: out of memory!\n"); exit(42); }
 340     /* for each string to match against */
 341     for (r = lol_get(args, 1); r; r = r->next) {
 342       if (hsrxExec(&re, r->string, re.re_nsub+1, mt, 0) == HSRX_NOERROR) {
 343         int i;
 344         /* add all parameters up to highest onto list */
 345         /* must have parameters to have results! */
 346         for (i = 1; i <= re.re_nsub; ++i) {
 347           char buf[MAXSYM];
 348           //FIXME
 349           int l = mt[i].rm_eo-mt[i].rm_so;
 350           if (l > 0) memcpy(buf, r->string+mt[i].rm_so, l);
 351           buf[l] = 0;
 352           res = list_new(res, buf, 0);
 353         }
 354       }
 355     }
 356     free(mt);
 357     hsrxFree(&re);
 358   }
 359   return res;
 360 }
 361
 362
 363 LIST *builtin_hdrmacro (PARSE *parse, LOL *args, int *jmp) {
 364   LIST *l = lol_get(args, 0);
 365   for (; l; l = list_next(l)) {
 366     TARGET *t = bindtarget(l->string);
 367     /* scan file for header filename macro definitions */
 368     if (DEBUG_HEADER) printf("scanning '%s' for header file macro definitions\n", l->string);
 369     macro_headers(t);
 370   }
 371   return L0;
 372 }
 373
 374
 375 /* backported from boost-jam */
 376 /*
 377  * Return the current working directory.
 378  *
 379  * Usage: pwd = [ PWD ] ;
 380  */
 381 LIST *builtin_pwd (PARSE *parse, LOL *args, int *jmp) {
 382   char pwd_buffer[PATH_MAX];
 383   if (!getcwd(pwd_buffer, sizeof(pwd_buffer))) {
 384     perror("can not get current directory");
 385     return L0;
 386   }
 387   return list_new(L0, pwd_buffer, 0);
 388 }
 389
 390
 391 /* backported from boost-jam */
 392 LIST *builtin_sort (PARSE *parse, LOL *args, int *jmp) {
 393   LIST *arg = lol_get(args, 0);
 394   arg = list_sort(arg);
 395   return arg;
 396 }
 397
 398
 399 /* backported from boost-jam; greatly improved */
 400 /* Command shcmd [[ : options ]] */
 401 LIST *builtin_command (PARSE *parse, LOL *args, int *jmp) {
 402   LIST *res = NULL;
 403   LIST *l;
 404   int ret;
 405   char buffer[1024], buf1[32], *spos, *epos;
 406   FILE *p = NULL;
 407   int exitStatus = -1;
 408   int optExitStatus = 0;
 409   int optNoOutput = 0;
 410   int optTrimLeft = 1;
 411   int optTrimRight = 1;
 412   int optStatus1st = 0;
 413   int optParseOut = 0;
 414   int optSpaceBreak = 1;
 415   int optTabBreak = 1;
 416   int optCRBreak = 1;
 417   int optLFBreak = 1;
 418   tKString str;
 419   //
 420   /* for each string in 2nd list: check for arg */
 421   for (l = lol_get(args, 1); l != NULL; l = l->next) {
 422     if (!strcmp("exit-status", l->string)) optExitStatus = 1;
 423     else if (!strcmp("exit-code", l->string)) optExitStatus = 1;
 424     else if (!strcmp("status-first", l->string)) optStatus1st = 1;
 425     else if (!strcmp("code-first", l->string)) optStatus1st = 1;
 426     else if (!strcmp("no-output", l->string)) optNoOutput = 1;
 427     else if (!strcmp("no-trim", l->string)) optTrimLeft = optTrimRight = 0;
 428     else if (!strcmp("no-trim-left", l->string)) optTrimLeft = 0;
 429     else if (!strcmp("no-trim-right", l->string)) optTrimRight = 0;
 430     else if (!strcmp("parse-output", l->string)) optParseOut = 1;
 431     else if (!strcmp("no-space-break", l->string)) optSpaceBreak = 0;
 432     else if (!strcmp("no-tab-break", l->string)) optTabBreak = 0;
 433     else if (!strcmp("no-nl-break", l->string)) optLFBreak = 0;
 434     else if (!strcmp("no-lf-break", l->string)) optLFBreak = 0;
 435     else if (!strcmp("no-cr-break", l->string)) optCRBreak = 0;
 436     else {
 437       printf("jam: invalid option for COMMAND built-in: '%s'\n", l->string);
 438       exit(EXITBAD); /* yeech */
 439     }
 440   }
 441   /* build shell command */
 442   kStringNew(&str);
 443   /* for each arg */
 444   for (l = lol_get(args, 0); l; l = l->next) {
 445     if (kStringLen(&str)) kStringPushBack(&str, ' ');
 446     kStringAppendCStr(&str, l->string);
 447   }
 448   /* no shell command? */
 449   if (kStringLen(&str) < 1) { kStringFree(&str); return L0; }
 450   //
 451   fflush(NULL);
 452   p = popen(kStringCStr(&str), "r");
 453   if (!p) { kStringFree(&str); return L0; }
 454   //
 455   kStringClear(&str);
 456   while ((ret = fread(buffer, sizeof(char), sizeof(buffer)-1, p)) > 0) {
 457     if (!optNoOutput) {
 458       buffer[ret] = 0;
 459       kStringAppendCStr(&str, buffer);
 460     }
 461   }
 462   exitStatus = pclose(p);
 463   if (optExitStatus && optStatus1st) {
 464     sprintf(buf1, "%d", exitStatus);
 465     res = list_new(res, buf1, 0);
 466   }
 467   /* trim output if necessary */
 468   if (!optNoOutput) {
 469     if (!optParseOut) {
 470       /* don't parse */
 471       if (optTrimRight) {
 472         // trim trailing blanks
 473         int sl = kStringLen(&str);
 474         spos = kStringCStr(&str);
 475         while (sl > 0 && (unsigned char)spos[sl] <= ' ') --sl;
 476         kStringTruncate(&str, sl);
 477       }
 478       spos = kStringCStr(&str);
 479       if (optTrimLeft) {
 480         // trim leading blanks
 481         while (*spos && *((unsigned char *)spos) <= ' ') ++spos;
 482       }
 483       res = list_new(res, spos, 0);
 484     } else {
 485       tKString tmp;
 486       /* parse output */
 487       ret = 0; /* was anything added? list must have at least one element */
 488       spos = kStringCStr(&str);
 489       kStringNew(&tmp);
 490       while (*spos) {
 491         /* skip delimiters */
 492         while (*spos) {
 493           unsigned char ch = (unsigned char)(*spos);
 494           if (ch == ' ') { if (!optSpaceBreak) break; }
 495           else if (ch == '\t') { if (!optTabBreak) break; }
 496           else if (ch == '\r') { if (!optCRBreak) break; }
 497           else if (ch == '\n') { if (!optLFBreak) break; }
 498           else if (ch > ' ') break;
 499           ++spos;
 500         }
 501         if (!*spos) break;
 502         epos = spos+1;
 503         while (*epos) {
 504           int ch = *epos;
 505           if (ch == ' ') { if (optSpaceBreak) break; }
 506           else if (ch == '\t') { if (optTabBreak) break; }
 507           else if (ch == '\r') { if (optCRBreak) break; }
 508           else if (ch == '\n') { if (optLFBreak) break; }
 509           else if ((unsigned char)ch <= ' ') break;
 510           ++epos;
 511         }
 512         kStringClear(&tmp);
 513         kStringAppendRange(&tmp, spos, epos);
 514         res = list_new(res, kStringCStr(&tmp), 0);
 515         ret = 1;
 516         spos = epos;
 517       }
 518       kStringFree(&tmp);
 519       if (!ret) { buf1[0] = '\0'; res = list_new(res, buf1, 0); }
 520     }
 521   } else {
 522     res = list_new(res, kStringCStr(&str), 0);
 523   }
 524   kStringFree(&str);
 525   /* command exit result next */
 526   if (optExitStatus && !optStatus1st) {
 527     sprintf(buf1, "%d", exitStatus);
 528     res = list_new(res, buf1, 0);
 529   }
 530   return res;
 531 }
 532
 533
 534 LIST *builtin_expri1 (PARSE *parse, LOL *args, int *jmp) {
 535   char buffer[100];
 536   int op0, op1, res, comp = 0;
 537   LIST *el = lol_get(args, 0);
 538   //
 539   if (!el || !el->next || !el->next->next) return L0;
 540   op0 = atoi(el->string);
 541   op1 = atoi(el->next->next->string);
 542   res = 0;
 543   switch (el->next->string[0]) {
 544     case '+': res = op0+op1; break;
 545     case '-': res = op0-op1; break;
 546     case '*': res = op0*op1; break;
 547     case '/': res = op0/op1; break;
 548     case '%': res = op0%op1; break;
 549     case '<':
 550       comp = 1;
 551       if (el->next->string[1] == '=') res = op0<=op1; else res = op0<op1;
 552       break;
 553     case '=': comp = 1; res = op0==op1; break;
 554     case '!': comp = 1; res = op0!=op1; break;
 555     case '>':
 556       comp = 1;
 557       if (el->next->string[1] == '=') res = op0>=op1; else res = op0>op1;
 558       break;
 559     default:
 560       printf("jam: rule ExprI1: unknown operator: '%s'\n", el->next->string);
 561       exit(EXITBAD);
 562   }
 563   if (comp) return res?list_new(L0, "tan", 0):L0;
 564   sprintf(buffer, "%d", res);
 565   return list_new(L0, buffer, 0);
 566 }
 567
 568
 569 /* Based on code from ftjam by David Turner */
 570 LIST *builtin_split (PARSE *parse, LOL *args, int *jmp) {
 571   LIST *input = lol_get(args, 0);
 572   LIST *tokens = lol_get(args, 1);
 573   LIST *res = L0;
 574   char token[256];
 575   tKString str;
 576   //
 577   kStringNew(&str);
 578   /* build token array */
 579   if (tokens == NULL) {
 580     memset(token, 1, sizeof(token));
 581   } else {
 582     memset(token, 0, sizeof(token));
 583     for (; tokens; tokens = tokens->next) {
 584       const char *s = tokens->string;
 585       for (; *s; ++s) token[(unsigned char)*s] = 1;
 586     }
 587   }
 588   token[0] = 0;
 589   /* now parse the input and split it */
 590   for (; input; input = input->next) {
 591     const char *ptr = input->string;
 592     const char *lastPtr = input->string;
 593     while (*ptr) {
 594       if (token[(unsigned char)*ptr]) {
 595         size_t count = ptr-lastPtr;
 596         if (count > 0) {
 597           kStringClear(&str);
 598           kStringAppendRange(&str, lastPtr, ptr);
 599           res = list_new(res, kStringCStr(&str), 0);
 600         }
 601         lastPtr = ptr+1;
 602       }
 603       ++ptr;
 604     }
 605     if (ptr > lastPtr) res = list_new(res, lastPtr, 0);
 606   }
 607   kStringFree(&str);
 608   return res;
 609 }
 610
 611
 612 LIST *builtin_dependslist (PARSE *parse, LOL *args, int *jmp) {
 613   LIST *res = L0;
 614   LIST *parents;
 615   //
 616   for (parents = lol_get(args, 0); parents; parents = parents->next) {
 617     TARGET *t = bindtarget(parents->string);
 618     TARGETS *child;
 619     //
 620     for (child = t->depends; child; child = child->next) res = list_new(res, child->target->name, 1);
 621   }
 622   return res;
 623 }
 624
 625
 626 LIST *builtin_normpath (PARSE *parse, LOL *args, int *jmp) {
 627   LIST *el = lol_get(args, 0);
 628   char *buf;
 629   int bsz;
 630   //
 631   if (!el || !el->string) return L0;
 632   bsz = strlen(el->string)*2+1024;
 633   buf = malloc(bsz);
 634   if (buf == NULL) return L0;
 635   if (!normalize_path(el->string, buf, bsz)) { free(buf); return L0; }
 636   el = list_new(NULL, buf, 0);
 637   free(buf);
 638   return el;
 639 }