new built-ins: SORT/Sort, COMMAND/Command

[k8jam.git] / builtins.c

/*
 * Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * builtins.c - builtin jam rules
 *
 * External routines:
 *
 *  load_builtin() - define builtin rules
 *
 * Internal routines:
 *
 *  builtin_depends() - DEPENDS/INCLUDES rule
 *  builtin_echo() - ECHO rule
 *  builtin_exit() - EXIT rule
 *  builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule
 *  builtin_glob() - GLOB rule
 *  builtin_match() - MATCH rule
 *  builtin_hdrmacro() - HDRMACRO rule
 *
 * 01/10/01 (seiwald) - split from compile.c
 * 01/08/01 (seiwald) - new 'Glob' (file expansion) builtin
 * 03/02/02 (seiwald) - new 'Match' (regexp match) builtin
 * 04/03/02 (seiwald) - Glob matches only filename, not directory
 * 10/22/02 (seiwald) - list_new() now does its own newstr()/copystr()
 * 10/22/02 (seiwald) - working return/break/continue statements
 * 11/04/02 (seiwald) - const-ing for string literals
 * 12/03/02 (seiwald) - fix odd includes support by grafting them onto depends
 * 01/14/03 (seiwald) - fix includes fix with new internal includes TARGET
 */

#include <unistd.h>
#include <limits.h>

#include "jam.h"

#include "lists.h"
#include "parse.h"
#include "builtins.h"
#include "rules.h"
#include "filesys.h"
#include "newstr.h"
#include "regexp.h"
#include "pathsys.h"
#include "hdrmacro.h"

/*
 * compile_builtin() - define builtin rules
 */

#define P0 (PARSE *)0
#define C0 (char *)0


int glob (const char *s, const char *c);


void load_builtins (void) {
  bindrule("Always")->procedure =
  bindrule("ALWAYS")->procedure =
  parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_TOUCHED);

  bindrule("Depends")->procedure =
  bindrule("DEPENDS")->procedure =
  parse_make(builtin_depends, P0, P0, P0, C0, C0, 0);

  bindrule("echo")->procedure =
  bindrule("Echo")->procedure =
  bindrule("ECHO")->procedure =
  parse_make(builtin_echo, P0, P0, P0, C0, C0, 0);

  bindrule("exit")->procedure =
  bindrule("Exit")->procedure =
  bindrule("EXIT")->procedure =
  parse_make(builtin_exit, P0, P0, P0, C0, C0, 0);

  bindrule("Glob")->procedure =
  bindrule("GLOB")->procedure =
  parse_make(builtin_glob, P0, P0, P0, C0, C0, 0);

  bindrule("Includes")->procedure =
  bindrule("INCLUDES")->procedure =
  parse_make(builtin_depends, P0, P0, P0, C0, C0, 1);

  bindrule("Leaves")->procedure =
  bindrule("LEAVES")->procedure =
  parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_LEAVES);

  bindrule("Match")->procedure =
  bindrule("MATCH")->procedure =
  parse_make(builtin_match, P0, P0, P0, C0, C0, 0);

  bindrule("NoCare")->procedure =
  bindrule("NOCARE")->procedure =
  parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_NOCARE);

  bindrule("NOTIME")->procedure =
  bindrule("NotFile")->procedure =
  bindrule("NOTFILE")->procedure =
  parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_NOTFILE);

  bindrule("NoUpdate")->procedure =
  bindrule("NOUPDATE")->procedure =
  parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_NOUPDATE);

  bindrule("Temporary")->procedure =
  bindrule("TEMPORARY")->procedure =
  parse_make(builtin_flags, P0, P0, P0, C0, C0, T_FLAG_TEMP);

  bindrule("HdrMacro")->procedure =
  bindrule("HDRMACRO")->procedure =
  parse_make(builtin_hdrmacro, P0, P0, P0, C0, C0, 0);

  bindrule("PWD")->procedure =
  bindrule("Pwd")->procedure =
  parse_make(builtin_pwd, P0, P0, P0, C0, C0, 0);

  bindrule("SORT")->procedure =
  bindrule("Sort")->procedure =
  parse_make(builtin_sort, P0, P0, P0, C0, C0, 0);

  bindrule("COMMAND")->procedure =
  bindrule("Command")->procedure =
  parse_make(builtin_command, P0, P0, P0, C0, C0, 0);
}


/*
 * builtin_depends() - DEPENDS/INCLUDES rule
 *
 * The DEPENDS builtin rule appends each of the listed sources on the
 * dependency list of each of the listed targets.  It binds both the
 * targets and sources as TARGETs.
 */
LIST *builtin_depends (PARSE *parse, LOL *args, int *jmp) {
  LIST *targets = lol_get(args, 0);
  LIST *sources = lol_get(args, 1);
  /*k8: int which = parse->num;*/
  LIST *l;

  for (l = targets; l; l = list_next(l)) {
    TARGET *t = bindtarget(l->string);
    /* If doing INCLUDES, switch to the TARGET's include */
    /* TARGET, creating it if needed.  The internal include */
    /* TARGET shares the name of its parent. */
    if (parse->num) {
      if (!t->includes) t->includes = copytarget(t);
      t = t->includes;
    }
    t->depends = targetlist(t->depends, sources);
  }
  return L0;
}


/*
 * builtin_echo() - ECHO rule
 *
 * The ECHO builtin rule echoes the targets to the user.  No other
 * actions are taken.
 */
LIST * builtin_echo (PARSE *parse, LOL *args, int *jmp) {
  list_print(lol_get(args, 0));
  printf("\n");
  return L0;
}


/*
 * builtin_exit() - EXIT rule
 *
 * The EXIT builtin rule echoes the targets to the user and exits
 * the program with a failure status.
 */
LIST *builtin_exit (PARSE *parse, LOL *args, int *jmp) {
  list_print(lol_get(args, 0));
  printf("\n");
  exit(EXITBAD); /* yeech */
  return L0;
}


/*
 * builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule
 *
 * Builtin_flags() marks the target with the appropriate flag, for use
 * by make0().  It binds each target as a TARGET.
 */
LIST *builtin_flags (PARSE *parse, LOL *args, int *jmp) {
  LIST *l = lol_get(args, 0);

  for (; l; l = list_next(l)) bindtarget(l->string)->flags |= parse->num;
  return L0;
}


/*
 * builtin_globbing() - GLOB rule
 */
struct globbing {
  LIST  *patterns;
  LIST  *results;
};


static void builtin_glob_back (void  *closure, const char *file, int status, time_t time) {
  struct globbing *globbing = (struct globbing *)closure;
  LIST *l;
  PATHNAME f;
  char buf[MAXJPATH];

  /* Null out directory for matching. */
  /* We wish we had file_dirscan() pass up a PATHNAME. */
  path_parse(file, &f);
  f.f_dir.len = 0;
  path_build(&f, buf, 0);

  for (l = globbing->patterns; l; l = l->next) {
    if (!glob(l->string, buf)) {
      globbing->results = list_new(globbing->results, file, 0);
      break;
    }
  }
}


LIST *builtin_glob (PARSE *parse, LOL *args, int *jmp) {
  struct globbing globbing;
  LIST *l = lol_get(args, 0);
  LIST *r = lol_get(args, 1);

  globbing.results = L0;
  globbing.patterns = r;

  for (; l; l = list_next(l)) file_dirscan(l->string, builtin_glob_back, &globbing);

  return globbing.results;
}


/*
 * builtin_match() - MATCH rule, regexp matching
 */
LIST *builtin_match (PARSE *parse, LOL *args, int *jmp) {
  LIST *l, *r;
  LIST *result = 0;

  /* For each pattern */
  for (l = lol_get(args, 0); l; l = l->next) {
    regexp *re = regcomp(l->string);
    /* For each string to match against */
    for (r = lol_get(args, 1); r; r = r->next) {
      if (regexec(re, r->string)) {
        int i, top;
        /* Find highest parameter */
        for (top = NSUBEXP; top-- > 1;) if (re->startp[top]) break;
        /* And add all parameters up to highest onto list. */
        /* Must have parameters to have results! */
        for (i = 1; i <= top; i++) {
          char buf[MAXSYM];
          int l = re->endp[i]-re->startp[i];
          memcpy(buf, re->startp[i], l);
          buf[l] = 0;
          result = list_new(result, buf, 0);
        }
      }
    }
    free((char *)re);
  }

  return result;
}


LIST *builtin_hdrmacro (PARSE *parse, LOL *args, int *jmp) {
  LIST *l = lol_get(args, 0);

  for (; l; l = list_next(l)) {
    TARGET *t = bindtarget(l->string);
    /* scan file for header filename macro definitions */
    if (DEBUG_HEADER) printf("scanning '%s' for header file macro definitions\n", l->string);
    macro_headers(t);
  }

  return L0;
}


/* backported from boost-jam */
/*
 * Return the current working directory.
 *
 * Usage: pwd = [ PWD ] ;
 */
LIST *builtin_pwd (PARSE *parse, LOL *args, int *jmp) {
  char pwd_buffer[PATH_MAX];

  if (!getcwd(pwd_buffer, sizeof(pwd_buffer))) {
    perror("can not get current directory");
    return L0;
  }
  return list_new(L0, pwd_buffer, 0);
}



/* backported from boost-jam */
LIST *builtin_sort (PARSE *parse, LOL *args, int *jmp) {
  LIST *arg = lol_get(args, 0);
  /*printf("unsorted: "); list_print(arg); printf("\n");*/
  arg = list_sort(arg);
  /*printf("sorted: "); list_print(arg); printf("\n");*/
  return arg;
}


#if 0
/* backported from boost-jam */
LIST *builtin_normalize_path (PARSE *parse, LOL *args, int *jmp) {
  LIST *arg = lol_get(args, 0);
  /* First, we iterate over all '/'-separated elements, starting from
     the end of string. If we see '..', we remove previous path elements.
     If we see '.', we remove it.
     The removal is done by putting '\1' in the string. After all the string
     is processed, we do a second pass, removing '\1' characters.
  */
  string in[1], out[1], tmp[1];
  char *end; /* Last character of the part of string still to be processed. */
  char *current; /* Working pointer. */
  int dotdots = 0; /* Number of '..' elements seen and not processed yet. */
  int rooted = arg->string[0] == '/';
  char *result;

  /* Make a copy of input: we should not change it. */
  string_new(in);
  if (!rooted) string_push_back(in, '/');
  while (arg) {
    string_append(in, arg->string);
    arg = list_next(arg);
    if (arg) string_append(in, "/");
  }

  end = in->value+in->size-1;
  current = end;

  for (; end >= in->value;) {
    /* Set 'current' to the next occurence of '/', which always exists. */
    for (current = end; *current != '/'; --current) ;
    if (current == end && current != in->value) {
      /* Found a trailing slash. Remove it. */
      *current = '\1';
    } else if (current == end && *(current+1) == '/') {
      /* Found duplicated slash. Remove it. */
      *current = '\1';
    } else if (end - current == 1 && strncmp(current, "/.", 2) == 0) {
      /* Found '/.'. Drop them all. */
      *current = '\1';
      *(current+1) = '\1';
    } else if (end - current == 2 && strncmp(current, "/..", 3) == 0) {
      /* Found '/..' */
      *current = '\1';
      *(current+1) = '\1';
      *(current+2) = '\1';
      ++dotdots;
    } else if (dotdots) {
      char* p = current;
      memset(current, '\1', end-current+1);
      --dotdots;
    }
    end = current-1;
  }

  string_new(tmp);
  while (dotdots--) string_append(tmp, "/..");
  string_append(tmp, in->value);
  string_copy(in, tmp->value);
  string_free(tmp);

  string_new(out);
  /* The resulting path is either empty or has '/' as the first significant
     element. If the original path was not rooted, we need to drop first '/'.
     If the original path was rooted, and we've got empty path, need to add '/'
  */
  if (!rooted) {
    current = strchr(in->value, '/');
    if (current) *current = '\1';
  }

  for (current = in->value; *current; ++current) if (*current != '\1') string_push_back(out, *current);

  result = newstr(out->size ? out->value : (rooted ? "/" : "."));
  string_free(in);
  string_free(out);

  return list_new(0, result);
}
#endif


/* backported from boost-jam */
LIST *builtin_command (PARSE *parse, LOL *args, int *jmp) {
  LIST *l;
  LIST *command = 0;
  LIST *result = 0;
  int ret, f;
  char buffer[1024];
  FILE *p = NULL;
  int exit_status = -1;
  int exit_status_opt = 0;
  int no_output_opt = 0;
  int trim_left = 1;
  int trim_right = 1;
  char *str, *spos;
  int strSize = 1024;


  /* for each arg */
  for (l = lol_get(args, 0); l; l = l->next) {
    if (!command) {
      command = l;
    } else {
      /* for each string in list: check for arg */
      if (!strcmp("exit-status", l->string)) {
        exit_status_opt = 1;
      } else if (!strcmp("exit-code", l->string)) {
        exit_status_opt = 1;
      } else if (!strcmp("no-output", l->string)) {
        no_output_opt = 1;
      } else if (!strcmp("no-trim", l->string)) {
        trim_left = trim_right = 0;
      } else if (!strcmp("no-trim-left", l->string)) {
        trim_left = 0;
      } else if (!strcmp("no-trim-right", l->string)) {
        trim_right = 0;
      }
    }
  }

  fflush(NULL);
  if (!(str = (char *)malloc((strSize+1)*sizeof(char)))) {
    perror("COMMAND: out of memory");
  }
  if (!(p = popen(command->string, "r"))) {
    free(str);
    return L0;
  }
  *str = '\0'; spos = str;
  while ((ret = fread(buffer, sizeof(char), sizeof(buffer)-1, p)) > 0) {
    buffer[ret] = 0;
    if (!no_output_opt) {
      f = spos-str;
      if ((spos-str)+ret > strSize) {
        strSize = (spos-str)+ret+2048;
        spos = str;
        str = (char *)realloc(str, (strSize+1)*sizeof(char));
        if (!str) {
          pclose(p);
          free(spos);
          perror("COMMAND: out of memory");
        }
        spos = str+f;
      }
      strcpy(spos, buffer);
      spos += ret;
    }
  }
  exit_status = pclose(p);

  /* trim output if necessary */
  if (trim_right) {
    spos = str+strlen(str)-1;
    while (spos >= str && *((unsigned char *)spos) <= ' ') spos--;
    *(++spos) = '\0';
  }
  spos = str;
  if (trim_left) {
    while (*spos && *((unsigned char *)spos) <= ' ') spos++;
  }
  /* The command output is returned first. */
  result = list_new(L0, spos, 0);
  free(str);

  /* The command exit result next. */
  if (exit_status_opt) {
    sprintf(buffer, "%d", exit_status);
    result = list_new(result, buffer, 0);
  }

  return result;
}