edify/expr.c - android_bootable_recovery - Gitiles

 /*
  * 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;
 }
	/*
	* 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;
	}