script.h

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#ifndef __SCRIPT_HEADER__
#define __SCRIPT_HEADER__

#include <sstream>
#include <fstream>
extern "C" {
  #include <lua.h>
  #include <lauxlib.h>
  #include <lualib.h>
}

// This needs a comment: what is check and why is it undefined for darwin?
#ifdef __MACH__
  #undef check
#endif

#include <luabind/luabind.hpp>
#include <luabind/object.hpp>
#include <luabind/adopt_policy.hpp>

#include "utils.h"
#include "defs.h"

#define ScriptObject luabind::object

#define ScriptCallFunction luabind::call_function


namespace hoa_script {

extern GameScript* ScriptManager;

extern bool SCRIPT_DEBUG;

enum SCRIPT_ACCESS_MODE {
  SCRIPT_CLOSED  = 0,
  SCRIPT_READ    = 1,
  SCRIPT_WRITE   = 2,
  SCRIPT_MODIFY  = 3
};

namespace private_script {

const int32 STACK_TOP = -1;

const luabind::iterator TABLE_END;

} // namespace private_script

class ScriptDescriptor {
  friend class GameScript;

public:
  ScriptDescriptor ()
    { _filename = ""; _access_mode = SCRIPT_CLOSED; _error_messages.clear(); }

  virtual ~ScriptDescriptor ()
    {}



  virtual bool OpenFile(const std::string& file_name) = 0;

  virtual bool OpenFile() = 0;

  virtual void CloseFile() = 0;

  bool IsFileOpen()
    { return (_access_mode != SCRIPT_CLOSED); }

  bool IsErrorDetected()
    { return (_error_messages.str() != ""); }


  const std::string& GetFilename()
    { return _filename; }

  const SCRIPT_ACCESS_MODE GetAccessMode()
    { return _access_mode; }

  void ClearErrors()
    { _error_messages.clear(); }

  std::string GetErrorMessages()
    { std::string errors = _error_messages.str(); ClearErrors(); return errors; }

  std::vector<std::string> GetOpenTables()
    { return _open_tables; }

protected:
  std::string _filename;

  SCRIPT_ACCESS_MODE _access_mode;

  std::ostringstream _error_messages;

  std::vector<std::string> _open_tables;
}; // class ScriptDescriptor


class GameScript : public hoa_utils::Singleton<GameScript> {
  friend class hoa_utils::Singleton<GameScript>;
  friend class ScriptDescriptor;
  friend class ReadScriptDescriptor;
  friend class WriteScriptDescriptor;
  friend class ModifyScriptDescriptor;
public:
  ~GameScript();

  bool SingletonInitialize ();

  lua_State *GetGlobalState()
    { return _global_state; }

  bool IsFileOpen(const std::string& filename);

  void HandleLuaError(luabind::error& err);

  void HandleCastError(luabind::cast_failed& err);

private:
  GameScript();

  std::map<std::string, ScriptDescriptor*> _open_files;

  lua_State *_global_state;

  void _AddOpenFile(ScriptDescriptor* sd);

  void _RemoveOpenFile(ScriptDescriptor* sd);
}; // class GameScript

} // namespace hoa_script

// These #includes are made here rather than the top of the file to avoid a recurisve inclusion problem.
// Each of these files contains a class that dervies from the ScriptDescriptor class that is defined in
// this file. Thus these headers must all include this header file, "script.h". However we would like to
// make the entire script engine API available to the user through one header inclusion (script.h), so
// this file must likewise include these files. When these are placed at the top of this file, the
// ScriptDescriptor definition is not fully parsed by the time control reaches the other script headers,
// hence why they are included here so that the ScriptDescriptor definition is available for the
// other script headers to use.
#include "script_read.h"
#include "script_write.h"
#include "script_modify.h"

#endif // __SCRIPT_HEADER__

---