Interpreter.h

Go to the documentation of this file.

 
 
#ifndef _MADARA_KNOWLEDGE_INTERPRETER_H_
#define _MADARA_KNOWLEDGE_INTERPRETER_H_
 
#ifndef _MADARA_NO_KARL_
 
#include <string>
#include <list>
#include <map>
 
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/expression/ExpressionTree.h"
#include "madara/knowledge/ThreadSafeContext.h"
 
namespace madara
{
namespace expression
{
// Forward declaration.
class Symbol;
 
typedef std::map<std::string, ExpressionTree> ExpressionTreeMap;
 
class Interpreter
{
public:
  Interpreter();
 
  virtual ~Interpreter();
 
  ExpressionTree interpret(
      madara::knowledge::ThreadSafeContext& context, const std::string& input);
 
  static inline bool is_string_literal(char input);
 
  static inline bool is_operator(char input);
 
  static inline bool is_number(char input);
 
  static inline bool is_alphanumeric(char input);
 
  static inline bool is_whitespace(char input);
 
  static inline bool is_exponential(char input);
 
  static inline bool is_reserved_word(const std::string& input);
 
  inline bool delete_expression(const std::string& expression);
 
private:
  void handle_for_loop(madara::knowledge::ThreadSafeContext& context,
      std::string& variable, const std::string& input,
      std::string::size_type& i, int& accumulated_precedence,
      ::std::list<Symbol*>& list, Symbol*& returnableInput);
 
  void variable_insert(madara::knowledge::ThreadSafeContext& context,
      const std::string& input, std::string::size_type& i,
      int& accumulated_precedence, ::std::list<Symbol*>& list,
      Symbol*& lastValidInput);
 
  void string_insert(char opener, madara::knowledge::ThreadSafeContext& context,
      const std::string& input, std::string::size_type& i,
      int& accumulated_precedence, ::std::list<Symbol*>& list,
      Symbol*& lastValidInput);
 
  void system_call_insert(madara::knowledge::ThreadSafeContext& context,
      const std::string& input, std::string::size_type& i,
      int& accumulated_precedence, ::std::list<Symbol*>& list,
      Symbol*& lastValidInput);
 
  void number_insert(madara::knowledge::ThreadSafeContext& context,
      const std::string& input, std::string::size_type& i,
      int& accumulated_precedence, ::std::list<Symbol*>& list,
      Symbol*& lastValidInput);
 
  void precedence_insert(madara::knowledge::ThreadSafeContext& context,
      Symbol* op, ::std::list<Symbol*>& list);
 
  void main_loop(madara::knowledge::ThreadSafeContext& context,
      const std::string& input, std::string::size_type& i,
      Symbol*& lastValidInput, bool& handled, int& accumulated_precedence,
      ::std::list<Symbol*>& list, bool build_argument_list = false);
 
  void handle_array(madara::knowledge::ThreadSafeContext& context,
      const std::string& input, std::string::size_type& i,
      Symbol*& lastValidInput, bool& handled, int& accumulated_precedence,
      ::std::list<Symbol*>& list);
 
  void handle_parenthesis(madara::knowledge::ThreadSafeContext& context,
      const std::string& input, std::string::size_type& i,
      Symbol*& lastValidInput, bool& handled, int& accumulated_precedence,
      ::std::list<Symbol*>& list, bool build_argument_list = false);
  ExpressionTreeMap cache_;
};
}
}
 
#include "Interpreter.inl"
 
#endif  // _MADARA_NO_KARL_
 
#endif /* _MADARA_KNOWLEDGE_INTERPRETER_H_ */