1 /* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef _EXPRESSION_H 18 #define _EXPRESSION_H 19 20 #include <unistd.h> 21 22 #include <memory> 23 #include <string> 24 #include <vector> 25 26 // Forward declaration to avoid including "otautil/error_code.h". 27 enum ErrorCode : int; 28 enum CauseCode : int; 29 30 struct State { 31 State(const std::string& script, void* cookie); 32 33 // The source of the original script. 34 const std::string& script; 35 36 // Optional pointer to app-specific data; the core of edify never 37 // uses this value. 38 void* cookie; 39 40 // The error message (if any) returned if the evaluation aborts. 41 // Should be empty initially, will be either empty or a string that 42 // Evaluate() returns. 43 std::string errmsg; 44 45 // error code indicates the type of failure (e.g. failure to update system image) 46 // during the OTA process. 47 ErrorCode error_code; 48 49 // cause code provides more detailed reason of an OTA failure (e.g. fsync error) 50 // in addition to the error code. 51 CauseCode cause_code; 52 53 bool is_retry = false; 54 }; 55 56 enum ValueType { 57 VAL_INVALID = -1, 58 VAL_STRING = 1, 59 VAL_BLOB = 2, 60 }; 61 62 struct Value { 63 ValueType type; 64 std::string data; 65 ValueValue66 Value(ValueType type, const std::string& str) : 67 type(type), 68 data(str) {} 69 }; 70 71 struct Expr; 72 73 using Function = Value* (*)(const char* name, State* state, 74 const std::vector<std::unique_ptr<Expr>>& argv); 75 76 struct Expr { 77 Function fn; 78 std::string name; 79 std::vector<std::unique_ptr<Expr>> argv; 80 int start, end; 81 ExprExpr82 Expr(Function fn, const std::string& name, int start, int end) : 83 fn(fn), 84 name(name), 85 start(start), 86 end(end) {} 87 }; 88 89 // Evaluate the input expr, return the resulting Value. 90 Value* EvaluateValue(State* state, const std::unique_ptr<Expr>& expr); 91 92 // Evaluate the input expr, assert that it is a string, and update the result parameter. This 93 // function returns true if the evaluation succeeds. This is a convenience function for older 94 // functions that want to deal only with strings. 95 bool Evaluate(State* state, const std::unique_ptr<Expr>& expr, std::string* result); 96 97 // Glue to make an Expr out of a literal. 98 Value* Literal(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 99 100 // Functions corresponding to various syntactic sugar operators. 101 // ("concat" is also available as a builtin function, to concatenate 102 // more than two strings.) 103 Value* ConcatFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 104 Value* LogicalAndFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 105 Value* LogicalOrFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 106 Value* LogicalNotFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 107 Value* SubstringFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 108 Value* EqualityFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 109 Value* InequalityFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 110 Value* SequenceFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 111 112 // Global builtins, registered by RegisterBuiltins(). 113 Value* IfElseFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 114 Value* AssertFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 115 Value* AbortFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv); 116 117 // Register a new function. The same Function may be registered under 118 // multiple names, but a given name should only be used once. 119 void RegisterFunction(const std::string& name, Function fn); 120 121 // Register all the builtins. 122 void RegisterBuiltins(); 123 124 // Find the Function for a given name; return NULL if no such function 125 // exists. 126 Function FindFunction(const std::string& name); 127 128 // --- convenience functions for use in functions --- 129 130 // Evaluate the expressions in argv, and put the results of strings in args. If any expression 131 // evaluates to nullptr, return false. Return true on success. 132 bool ReadArgs(State* state, const std::vector<std::unique_ptr<Expr>>& argv, 133 std::vector<std::string>* args); 134 bool ReadArgs(State* state, const std::vector<std::unique_ptr<Expr>>& argv, 135 std::vector<std::string>* args, size_t start, size_t len); 136 137 // Evaluate the expressions in argv, and put the results of Value* in args. If any 138 // expression evaluate to nullptr, return false. Return true on success. 139 bool ReadValueArgs(State* state, const std::vector<std::unique_ptr<Expr>>& argv, 140 std::vector<std::unique_ptr<Value>>* args); 141 bool ReadValueArgs(State* state, const std::vector<std::unique_ptr<Expr>>& argv, 142 std::vector<std::unique_ptr<Value>>* args, size_t start, size_t len); 143 144 // Use printf-style arguments to compose an error message to put into 145 // *state. Returns NULL. 146 Value* ErrorAbort(State* state, const char* format, ...) 147 __attribute__((format(printf, 2, 3), deprecated)); 148 149 // ErrorAbort has an optional (but recommended) argument 'cause_code'. If the cause code 150 // is set, it will be logged into last_install and provides reason of OTA failures. 151 Value* ErrorAbort(State* state, CauseCode cause_code, const char* format, ...) 152 __attribute__((format(printf, 3, 4))); 153 154 // Copying the string into a Value. 155 Value* StringValue(const char* str); 156 157 Value* StringValue(const std::string& str); 158 159 int parse_string(const char* str, std::unique_ptr<Expr>* root, int* error_count); 160 161 #endif // _EXPRESSION_H 162