edify/expr.c

/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>

#include "expr.h"

// Functions should:
//
//    - return a malloc()'d string
//    - if Evaluate() on any argument returns NULL, return NULL.

int BooleanString(const char* s) {
  return s[0] != '\0';
}

char* Evaluate(void* cookie, Expr* expr) {
  return expr->fn(expr->name, cookie, expr->argc, expr->argv);
}

char* ConcatFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  if (argc == 0) {
    return strdup("");
  }
  char** strings = malloc(argc * sizeof(char*));
  int i;
  for (i = 0; i < argc; ++i) {
    strings[i] = NULL;
  }
  char* result = NULL;
  int length = 0;
  for (i = 0; i < argc; ++i) {
    strings[i] = Evaluate(cookie, argv[i]);
    if (strings[i] == NULL) {
      goto done;
    }
    length += strlen(strings[i]);
  }

  result = malloc(length+1);
  int p = 0;
  for (i = 0; i < argc; ++i) {
    strcpy(result+p, strings[i]);
    p += strlen(strings[i]);
  }
  result[p] = '\0';

done:
  for (i = 0; i < argc; ++i) {
    free(strings[i]);
  }
  return result;
}

char* IfElseFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  if (argc != 2 && argc != 3) {
    return NULL;
  }
  char* cond = Evaluate(cookie, argv[0]);
  if (cond == NULL) {
    return NULL;
  }

  if (BooleanString(cond) == true) {
    free(cond);
    return Evaluate(cookie, argv[1]);
  } else {
    if (argc == 3) {
      free(cond);
      return Evaluate(cookie, argv[2]);
    } else {
      return cond;
    }
  }
}

char* AbortFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  char* msg = NULL;
  if (argc > 0) {
    msg = Evaluate(cookie, argv[0]);
  }
  SetError(msg == NULL ? "called abort()" : msg);
  free(msg);
  return NULL;
}

char* AssertFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  int i;
  for (i = 0; i < argc; ++i) {
    char* v = Evaluate(cookie, argv[i]);
    if (v == NULL) {
      return NULL;
    }
    int b = BooleanString(v);
    free(v);
    if (!b) {
      SetError("assert() failed");
      return NULL;
    }
  }
  return strdup("");
}

char* SleepFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  char* val = Evaluate(cookie, argv[0]);
  if (val == NULL) {
    return NULL;
  }
  int v = strtol(val, NULL, 10);
  sleep(v);
  return val;
}

char* PrintFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  int i;
  for (i = 0; i < argc; ++i) {
    char* v = Evaluate(cookie, argv[i]);
    if (v == NULL) {
      return NULL;
    }
    fputs(v, stdout);
    free(v);
  }
  return strdup("");
}

char* LogicalAndFn(const char* name, void* cookie,
                   int argc, Expr* argv[]) {
  char* left = Evaluate(cookie, argv[0]);
  if (left == NULL) return NULL;
  if (BooleanString(left) == true) {
    free(left);
    return Evaluate(cookie, argv[1]);
  } else {
    return left;
  }
}

char* LogicalOrFn(const char* name, void* cookie,
                  int argc, Expr* argv[]) {
  char* left = Evaluate(cookie, argv[0]);
  if (left == NULL) return NULL;
  if (BooleanString(left) == false) {
    free(left);
    return Evaluate(cookie, argv[1]);
  } else {
    return left;
  }
}

char* LogicalNotFn(const char* name, void* cookie,
                  int argc, Expr* argv[]) {
  char* val = Evaluate(cookie, argv[0]);
  if (val == NULL) return NULL;
  bool bv = BooleanString(val);
  free(val);
  if (bv) {
    return strdup("");
  } else {
    return strdup("t");
  }
}

char* SubstringFn(const char* name, void* cookie,
                  int argc, Expr* argv[]) {
  char* needle = Evaluate(cookie, argv[0]);
  if (needle == NULL) return NULL;
  char* haystack = Evaluate(cookie, argv[1]);
  if (haystack == NULL) {
    free(needle);
    return NULL;
  }

  char* result = strdup(strstr(haystack, needle) ? "t" : "");
  free(needle);
  free(haystack);
  return result;
}

char* EqualityFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  char* left = Evaluate(cookie, argv[0]);
  if (left == NULL) return NULL;
  char* right = Evaluate(cookie, argv[1]);
  if (right == NULL) {
    free(left);
    return NULL;
  }

  char* result = strdup(strcmp(left, right) == 0 ? "t" : "");
  free(left);
  free(right);
  return result;
}

char* InequalityFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  char* left = Evaluate(cookie, argv[0]);
  if (left == NULL) return NULL;
  char* right = Evaluate(cookie, argv[1]);
  if (right == NULL) {
    free(left);
    return NULL;
  }

  char* result = strdup(strcmp(left, right) != 0 ? "t" : "");
  free(left);
  free(right);
  return result;
}

char* SequenceFn(const char* name, void* cookie, int argc, Expr* argv[]) {
  char* left = Evaluate(cookie, argv[0]);
  if (left == NULL) return NULL;
  free(left);
  return Evaluate(cookie, argv[1]);
}

char* Literal(const char* name, void* cookie, int argc, Expr* argv[]) {
  return strdup(name);
}

Expr* Build(Function fn, int count, ...) {
  va_list v;
  va_start(v, count);
  Expr* e = malloc(sizeof(Expr));
  e->fn = fn;
  e->name = "(operator)";
  e->argc = count;
  e->argv = malloc(count * sizeof(Expr*));
  int i;
  for (i = 0; i < count; ++i) {
    e->argv[i] = va_arg(v, Expr*);
  }
  va_end(v);
  return e;
}

// -----------------------------------------------------------------
//   error reporting
// -----------------------------------------------------------------

static char* error_message = NULL;

void SetError(const char* message) {
  if (error_message) {
    free(error_message);
  }
  error_message = strdup(message);
}

const char* GetError() {
  return error_message;
}

void ClearError() {
  free(error_message);
  error_message = NULL;
}

// -----------------------------------------------------------------
//   the function table
// -----------------------------------------------------------------

static int fn_entries = 0;
static int fn_size = 0;
NamedFunction* fn_table = NULL;

void RegisterFunction(const char* name, Function fn) {
  if (fn_entries >= fn_size) {
    fn_size = fn_size*2 + 1;
    fn_table = realloc(fn_table, fn_size * sizeof(NamedFunction));
  }
  fn_table[fn_entries].name = name;
  fn_table[fn_entries].fn = fn;
  ++fn_entries;
}

static int fn_entry_compare(const void* a, const void* b) {
  const char* na = ((const NamedFunction*)a)->name;
  const char* nb = ((const NamedFunction*)b)->name;
  return strcmp(na, nb);
}

void FinishRegistration() {
  qsort(fn_table, fn_entries, sizeof(NamedFunction), fn_entry_compare);
}

Function FindFunction(const char* name) {
  NamedFunction key;
  key.name = name;
  NamedFunction* nf = bsearch(&key, fn_table, fn_entries, sizeof(NamedFunction),
                              fn_entry_compare);
  if (nf == NULL) {
    return NULL;
  }
  return nf->fn;
}

void RegisterBuiltins() {
  RegisterFunction("ifelse", IfElseFn);
  RegisterFunction("abort", AbortFn);
  RegisterFunction("assert", AssertFn);
  RegisterFunction("concat", ConcatFn);
  RegisterFunction("is_substring", SubstringFn);
  RegisterFunction("print", PrintFn);
  RegisterFunction("sleep", SleepFn);
}


// -----------------------------------------------------------------
//   convenience methods for functions
// -----------------------------------------------------------------

// Evaluate the expressions in argv, giving 'count' char* (the ... is
// zero or more char** to put them in).  If any expression evaluates
// to NULL, free the rest and return -1.  Return 0 on success.
int ReadArgs(void* cookie, Expr* argv[], int count, ...) {
  char** args = malloc(count * sizeof(char*));
  va_list v;
  va_start(v, count);
  int i;
  for (i = 0; i < count; ++i) {
    args[i] = Evaluate(cookie, argv[i]);
    if (args[i] == NULL) {
      va_end(v);
      int j;
      for (j = 0; j < i; ++j) {
        free(args[j]);
      }
      return -1;
    }
    *(va_arg(v, char**)) = args[i];
  }
  va_end(v);
  return 0;
}

// Evaluate the expressions in argv, returning an array of char*
// results.  If any evaluate to NULL, free the rest and return NULL.
// The caller is responsible for freeing the returned array and the
// strings it contains.
char** ReadVarArgs(void* cookie, int argc, Expr* argv[]) {
  char** args = (char**)malloc(argc * sizeof(char*));
  int i = 0;
  for (i = 0; i < argc; ++i) {
    args[i] = Evaluate(cookie, argv[i]);
    if (args[i] == NULL) {
      int j;
      for (j = 0; j < i; ++j) {
        free(args[j]);
      }
      free(args);
      return NULL;
    }
  }
  return args;
}