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_ */