interpreter.h

Go to the documentation of this file.

// Copyright 2014, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//   * Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above
//     copyright notice, this list of conditions and the following disclaimer
//     in the documentation and/or other materials provided with the
//     distribution.
//   * Neither the name of Google Inc. nor the names of its
//     contributors may be used to endorse or promote products derived from
//     this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// -----------------------------------------------------------------------------
//
//

#ifndef INFACT_INTERPRETER_H_
#define INFACT_INTERPRETER_H_

#include <iostream>
#include <fstream>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>

#include "environment-impl.h"

namespace infact {

using std::ifstream;
using std::istream;
using std::unique_ptr;

class IStreamBuilder {
 public:
  virtual ~IStreamBuilder() = default;

  virtual unique_ptr<istream> Build(
      const string &filename,
      std::ios_base::openmode mode = std::ios_base::in) const = 0;
};

class DefaultIStreamBuilder : public IStreamBuilder {
 public:
  ~DefaultIStreamBuilder() override = default;

  unique_ptr<istream> Build(const string &filename,
                            std::ios_base::openmode mode = std::ios_base::in)
      const override;
};

class EnvironmentImpl;

class Interpreter {
 public:
  Interpreter(int debug = 0) :
      Interpreter(unique_ptr<IStreamBuilder>(new DefaultIStreamBuilder()),
                  debug) { }

  Interpreter(unique_ptr<IStreamBuilder> istream_builder, int debug = 0) :
      env_(new EnvironmentImpl(debug)),
      istream_builder_(std::move(istream_builder)),
      debug_(debug) { }

  virtual ~Interpreter() = default;

  void SetIStreamBuilder(unique_ptr<IStreamBuilder> istream_builder) {
    istream_builder_ = std::move(istream_builder);
  }

  void Eval(const string &filename);

  void EvalString(const string& input) {
    StreamTokenizer st(input);
    Eval(st);
  }

  void Eval(istream &is) {
    StreamTokenizer st(is);
    Eval(st);
  }

  void PrintEnv(ostream &os) const {
    env_->Print(os);
  }

  void PrintFactories(ostream &os) const {
    env_->PrintFactories(os);
  }

  bool GetMany() { return true; }

  template<typename T, typename... Args>
  bool GetMany(const string &varname, T *var,
               Args &&...rest) {
    bool success = Get(varname, var);
    if (!success) {
      std::ostringstream err_ss;
      err_ss << "infact::Interpreter: no variable with name '"
             << varname << "'";
      Error(err_ss.str());
      return false;
    }
    return GetMany(std::forward<Args>(rest)...);  // compile-time recursion ftw
  }

  template<typename T>
  bool Get(const string &varname, T *value) const {
    return env_->Get(varname, value);
  }

  EnvironmentImpl *env() { return env_.get(); }

 private:
  bool IsAbsolute(const string &filename) const;

  bool CanReadFile(const string &filename) const;

  bool CanReadFile(const string &f1, const string &f2, string *filename) const;

  bool HasCycle(const string &filename, const vector<string> &filenames) const;

  void EvalFile(const string &filename);

  void Eval(StreamTokenizer &st);

  void Import(StreamTokenizer &st);

  string curr_filename() const {
    return filenames_.size() > 0 ? filenames_.back() : "";
  }

  string filestack(StreamTokenizer &st, size_t pos) const;

  void WrongTokenError(StreamTokenizer &st,
                       size_t pos,
                       const string &expected,
                       const string &found,
                       StreamTokenizer::TokenType found_type) const;

  void WrongTokenTypeError(StreamTokenizer &st,
                           size_t pos,
                           StreamTokenizer::TokenType expected,
                           StreamTokenizer::TokenType found,
                           const string &token) const;

  void WrongTokenTypeError(StreamTokenizer &st,
                           size_t pos,
                           const string &expected_type,
                           const string &found_type,
                           const string &token) const;

  unique_ptr<EnvironmentImpl> env_;

  vector<string> filenames_;

  // The object for building new istream objects from named files.
  unique_ptr<IStreamBuilder> istream_builder_;

  // The debug level of this interpreter.
  int debug_;
};

}  // namespace infact

#endif