text: /*
   * 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.
   */
  
  #ifndef _EXPRESSION_H
  #define _EXPRESSION_H
  
  #include <unistd.h>
  
  #include <memory>
  #include <string>
  #include <vector>
  
  #include "edify/updater_interface.h"
  
  // Forward declaration to avoid including "otautil/error_code.h".
  enum ErrorCode : int;
  enum CauseCode : int;
  
  struct State {
    State(const std::string& script, UpdaterInterface* cookie);
  
    // The source of the original script.
    const std::string& script;
  
    // A pointer to app-specific data; the libedify doesn't use this value.
    UpdaterInterface* updater;
  
    // The error message (if any) returned if the evaluation aborts.
    // Should be empty initially, will be either empty or a string that
    // Evaluate() returns.
    std::string errmsg;
  
    // error code indicates the type of failure (e.g. failure to update system image)
    // during the OTA process.
    ErrorCode error_code;
  
    // cause code provides more detailed reason of an OTA failure (e.g. fsync error)
    // in addition to the error code.
    CauseCode cause_code;
  
    bool is_retry = false;
  };
  
  struct Value {
    enum class Type {
      STRING = 1,
      BLOB = 2,
    };
  
    Value(Type type, const std::string& str) : type(type), data(str) {}
  
    Type type;
    std::string data;
  };
  
  struct Expr;
  
  using Function = Value* (*)(const char* name, State* state,
                              const std::vector<std::unique_ptr<Expr>>& argv);
  
  struct Expr {
    Function fn;
    std::string name;
    std::vector<std::unique_ptr<Expr>> argv;
    int start, end;
  
    Expr(Function fn, const std::string& name, int start, int end) :
      fn(fn),
      name(name),
      start(start),
      end(end) {}
  };
  
  // Evaluate the input expr, return the resulting Value.
  Value* EvaluateValue(State* state, const std::unique_ptr<Expr>& expr);
  
  // Evaluate the input expr, assert that it is a string, and update the result parameter. This
  // function returns true if the evaluation succeeds. This is a convenience function for older
  // functions that want to deal only with strings.
  bool Evaluate(State* state, const std::unique_ptr<Expr>& expr, std::string* result);
  
  // Glue to make an Expr out of a literal.
  Value* Literal(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  
  // Functions corresponding to various syntactic sugar operators.
  // ("concat" is also available as a builtin function, to concatenate
  // more than two strings.)
  Value* ConcatFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* LogicalAndFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* LogicalOrFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* LogicalNotFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* SubstringFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* EqualityFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* InequalityFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* SequenceFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  
  // Global builtins, registered by RegisterBuiltins().
  Value* IfElseFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* AssertFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  Value* AbortFn(const char* name, State* state, const std::vector<std::unique_ptr<Expr>>& argv);
  
  // Register a new function.  The same Function may be registered under
  // multiple names, but a given name should only be used once.
  void RegisterFunction(const std::string& name, Function fn);
  
  // Register all the builtins.
  void RegisterBuiltins();
  
  // Find the Function for a given name; return NULL if no such function
  // exists.
  Function FindFunction(const std::string& name);
  
  // --- convenience functions for use in functions ---
  
  // Evaluate the expressions in argv, and put the results of strings in args. If any expression
  // evaluates to nullptr, return false. Return true on success.
  bool ReadArgs(State* state, const std::vector<std::unique_ptr<Expr>>& argv,
                std::vector<std::string>* args);
  bool ReadArgs(State* state, const std::vector<std::unique_ptr<Expr>>& argv,
                std::vector<std::string>* args, size_t start, size_t len);
  
  // Evaluate the expressions in argv, and put the results of Value* in args. If any
  // expression evaluate to nullptr, return false. Return true on success.
  bool ReadValueArgs(State* state, const std::vector<std::unique_ptr<Expr>>& argv,
                     std::vector<std::unique_ptr<Value>>* args);
  bool ReadValueArgs(State* state, const std::vector<std::unique_ptr<Expr>>& argv,
                     std::vector<std::unique_ptr<Value>>* args, size_t start, size_t len);
  
  // Use printf-style arguments to compose an error message to put into
  // *state.  Returns NULL.
  Value* ErrorAbort(State* state, const char* format, ...)
      __attribute__((format(printf, 2, 3), deprecated));
  
  // ErrorAbort has an optional (but recommended) argument 'cause_code'. If the cause code
  // is set, it will be logged into last_install and provides reason of OTA failures.
  Value* ErrorAbort(State* state, CauseCode cause_code, const char* format, ...)
      __attribute__((format(printf, 3, 4)));
  
  // Copying the string into a Value.
  Value* StringValue(const char* str);
  
  Value* StringValue(const std::string& str);
  
  int ParseString(const std::string& str, std::unique_ptr<Expr>* root, int* error_count);
  
  #endif  // _EXPRESSION_H
  