difference between lua_dofile and luaL_loadfile?
[
Date Prev][
Date Next][
Thread Prev][
Thread Next]
[
Date Index]
[
Thread Index]
- Subject: difference between lua_dofile and luaL_loadfile?
- From: Johannes Hager <hager.j@...>
- Date: Thu, 4 Sep 2003 16:54:57 +0200
Hi Peter,
We talked about lua before, if you remembering. I aked a question about the
difference between lua_dofile and luaL_loadfile and why lua_dofile is working
and luaL_loadfile isn't working. In the attachment i send you some classes i
which i had written for a game project im working for. It's job is to wrapp
some functions of a other class, but this shouldn't be important.
In cScripting.cpp about line 18 i load the script. luaL_loadfile returns 0.
But if i call it cames attempt to call a nil value. Today i had a quick view
in the lua sources. Speciely lauxlib.c.
The only difference between this two functions is that lua_dofile
luaL_loadfile over aux_do calles. If i delete in aux_do the lua_pcall all
went and i compile the lua new. lua_dofile works too. But their is no
difference to take luaL_loadfile directly. Have you a clue why and is it
dangerous to delete the lua_pcall in the lua sources. Because it is a bit
faster and we trying to get the game as fast as possible.
Thanks for your time and help and have a nice day,
- Johannes
#ifndef __SCRIPT__H__
#define __SCRIPT__H__
namespace script
{
class cScript;
class cScriptPoint;
class cScriptList;
class cInterpreter;
};
#include "cScripting.h"
#endif /*__SCRIPT__H__*/
function test_lua_scripting()
show()
end
function test()
show()
end
LIBS = `sdl-config --cflags --libs` -llua -llualib
OBJ = ../cObject.cpp ../cObjectContainer.cpp ../cScripting.cpp main.cpp
test: $(OBJ)
g++ $(OBJ) -o test $(LIBS)
cObject.o: ../cObject.cpp
g++ -c -g ../cObject.cpp $(LIBS)
cObjectContainer.o: ../cObjectContainer.cpp
g++ -c -g ../cObjectContainer.cpp $(LIBS)
cScripting.o: ../cScripting.cpp
g++ -c -g ../cScripting.cpp $(LIBS)
main.o: main.cpp
g++ -c -g main.cpp $(LIBS)
#include "../cScripting.h"
using namespace script;
int main(int argc, char *argv[])
{
cInterpreter *interp = cInterpreter::getInstance();
cScriptList *script_list = cScriptList::getInstance();
obj::cBaseObject *test_object1;
int test_script1 = script_list->addScript("test.lua", "test_lua_scripting");
cerr<<test_script1<<endl;
int test_script2 = script_list->addScript("test.lua", "test_lua_scripting");
cerr<<test_script2<<endl;
int test_script3 = script_list->addScript("test.lua", "test_lua_scripting");
cerr<<test_script3<<endl;
int test_script4 = script_list->addScript("test2.lua", "test");
cerr<<test_script4<<endl;
interp->runScript(test_object1, script_list->getScript(test_script1));
interp->runScript(test_object1, script_list->getScript(test_script2));
interp->runScript(test_object1, script_list->getScript(test_script3));
interp->runScript(test_object1, script_list->getScript(test_script4));
test_script2 = script_list->deleteScript(test_script2);
interp->runScript(test_object1, script_list->getScript(test_script1));
interp->runScript(test_object1, script_list->getScript(test_script2));
interp->runScript(test_object1, script_list->getScript(test_script3));
interp->runScript(test_object1, script_list->getScript(test_script4));
cerr<<"third time"<<endl;
test_script4 = script_list->deleteScript(test_script4);
interp->runScript(test_object1, script_list->getScript(test_script1));
interp->runScript(test_object1, script_list->getScript(test_script2));
interp->runScript(test_object1, script_list->getScript(test_script3));
interp->runScript(test_object1, script_list->getScript(test_script4));
return 0;
}
#ifndef _LUA_SCRIPTING_H_
#define _LUA_SCRIPTING_H_
extern "C"{
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
}
#include <iostream>
#include <fstream>
#include "cObject.h"
/**
* Namescpae aller Klassen, die mit dem Scripting der cObject Klassen zu tuen hat
*/
namespace script {
/**
* Speichert die eigentlichen Scriptdaten
* @author Johannes Hager email: hager.j@gmx.de
*/
class cScript{
private:
int m_id; /**< Id des Scriptes */
int counter_used; /**< wieviele Instanzen nutzen dieses Script */
char *script_file;
char *script_function;
public:
/**
* @param Name des Scriptes
* @param Name der Lua Funktion, innerhalb des Scriptes
*/
cScript(char *filename, char *function_name);
~cScript();
protected:
int getId();
void setId(int id);
/**
* erhöht counter_used um eins
* @param void
* @return void
*/
void inkCounter();
/**
* verringert counter_used um eins
* @param void
* @return void
*/
void dekCounter();
int getCounter();
char *getFile();
char *getFunction();
friend class cScriptList;
friend class cInterpreter;
};
/**
* die einzelnen Knoten für cScriptList
* @author Johannes Hager email: hager.j@gmx.de
*/
class cScriptPoint{
private:
cScriptPoint *m_pNext; /**< Zeiger auf naechsten Listenknoten */
cScriptPoint *m_pLast; /**< Zeiger auf vorherigen Listenknoten */
friend class cScriptList;
public:
cScript *m_pScript; /**< Zeiger auf das eigentliche Script */
cScriptPoint();
/**
* Wird von cScriptList->addScript() aufgerufen und erzeugt den neuen Konten in der Liste
* @param Name der Scriptdatei
* @param Name der Lua Funktion
* @param Zeiger auf den nächsten Knoten in der Liste
* @param Zeiger auf den vorherigen Knoten in der Liste
*/
cScriptPoint(char *filename, char *function_name, cScriptPoint *next, cScriptPoint
*last);
~cScriptPoint();
/**
* Kann die Scriptdaten des Knoten ändern / Vorsicht noch nicht benuten!
*/
// noch nicht korrekt implementiert
int loadScript(char *filename, char *function_name);
char *getFile();
char *getFunction();
//get& and set...functions();
void setNext(cScriptPoint *next);
void setLast(cScriptPoint *last);
cScriptPoint *getNext();
cScriptPoint *getLast();
int getId();
};
/**
* Klasse zur Verwaltung der cScriptPoint Klasse (eigengtliche Liste)
*/
class cScriptList{
private:
static cScriptList *m_pInstance; /**< Zeiger auf die einzige Instance derKlasse */
cScriptPoint *m_pFirst; /**< Zeiger auf das erste Element der Liste */
cScriptPoint *m_pLast; /**< Zeiger auf das letzte Element der Liste */
int m_iSize; /**< Größe der Liste */
public:
cScriptList();
~cScriptList();
static cScriptList* const getInstance(); /**< liefert Zeiger auf die einzige Instanze der Klasse */
/**
* Fügt ein Script der Liste an und überprpüft ob dieses schon in der Liste ist.
* Liefert einen Integer Wert als Id zurück mit welchem man Zugriff auf das Script hat
* @param Name der Scriptdatei
* @param Name der Lua Funktion
* @return Script Id
*/
int addScript(char *filename, char *function_name);
/**
* Liefert einen Zeiger auf das cScript zurück (benötigt von cInterpreter->runScript(...)
* @param Script Id
* @return Zeiger auf ein cScript
*/
cScript *getScript(int id);
/**
* Löscht ein Script aus der Liste
* @param Script Id
* @return wenn alles klappt eine 0, sprich Script gibt es nicht mehr
*/
int deleteScript(int id);
};
/**
* Stellt den lua State und die wrapper Funktionen zur Verfügung
*/
class cInterpreter{
private:
obj::cBaseObject *object;
obj::cBaseObject *object1;
cScript* at_run;
static cInterpreter *m_pInstance; /**< Zeiger auf die einzige Instanz der Klasse */
// a whole mass of static wrapper functions...
static int show(lua_State *L); //nur zum tesen
public:
cInterpreter();
~cInterpreter();
/**
* Gibt Zeiger auf die einzige Instanz der Klasse zurück
* @param void
* @return Zeiger auf die einzige Instanz der Klasse
*/
static cInterpreter* const getInstance();
/**
* for handling ai, drawing operations etc...,
* führt das übergebenen Lua Script aus welches Zugriff auf die static Funktionnen von
* cBaseObject obj1 hat
* @param cObject Objekt :-)
* @param cScript
*/
bool runScript(obj::cBaseObject* obj1, cScript* script);
// for doing the stuff after collision between two objects on the game field
//int runScript(cObject& obj1, cObject& obj2, cScript& script);
};
}
#endif
#include "cScripting.h"
using namespace script;
lua_State *L = lua_open();
/*********************************************************************
* *
* cScript Class *
* *
********************************************************************/
cScript::cScript(char *filename, char *function_name){
counter_used = 1;
script_file = filename;
script_function = function_name;
/* Important */
lua_dofile(L, filename);
//luaL_loadfile(L, filename);
// Why doesnt this work
// It returns 0, i think that means all wents right
// But if i call script it brings attempt to call a nil value
}
cScript::~cScript(){
}
void cScript::setId(int id){
m_id = id;
}
int cScript::getId(){
return m_id;
}
void cScript::inkCounter(){
counter_used++;
}
void cScript::dekCounter(){
counter_used--;
}
int cScript::getCounter(){
return counter_used;
}
char *cScript::getFile(){
return script_file;
}
char *cScript::getFunction(){
return script_function;
}
/*********************************************************************
* *
* cScriptPoint Class *
* *
********************************************************************/
cScriptPoint::cScriptPoint(){
}
cScriptPoint::cScriptPoint(char *filename, char *function_name, cScriptPoint *next, cScriptPoint *last){
m_pScript = new cScript(filename,function_name);
m_pNext = next;
m_pLast = last;
}
cScriptPoint::~cScriptPoint(){
}
void cScriptPoint::setNext(cScriptPoint *next){
m_pNext = next;
}
void cScriptPoint::setLast(cScriptPoint *last){
m_pLast = last;
}
cScriptPoint *cScriptPoint::getNext(){
return m_pNext;
}
cScriptPoint *cScriptPoint::getLast(){
return m_pLast;
}
/*********************************************************************
* *
* cScriptListe Class *
* *
********************************************************************/
cScriptList::cScriptList(){
m_pFirst = NULL;
m_pLast = NULL;
}
cScriptList::~cScriptList(){
cScriptPoint *marker = m_pFirst;
while(marker != NULL);
{
m_pFirst = m_pFirst->getNext();
delete marker;
marker = m_pFirst;
}
}
int cScriptList::addScript(char *filename, char *function_name){
if(m_pFirst == NULL){
m_pFirst = new cScriptPoint(filename, function_name, NULL, NULL);
m_pLast = m_pFirst;
m_iSize = 1;
m_pLast->m_pScript->setId(m_iSize);
}
else{
cScriptPoint *temp = m_pFirst;
while(temp != NULL){
if(strcmp(function_name, temp->m_pScript->getFunction()) == 0){
return temp->m_pScript->getId();
temp->m_pScript->inkCounter();
}
temp = temp->m_pNext;
}
m_pLast->setNext(new cScriptPoint(filename, function_name, NULL, m_pLast));
m_pLast = m_pLast->getNext();
m_iSize++;
m_pLast->m_pScript->setId(m_pLast->getLast()->m_pScript->getId() + 1);
}
return m_pLast->m_pScript->getId();
}
cScript *cScriptList::getScript(int id){
cScriptPoint *temp = m_pFirst;
while(temp != NULL){
if(temp->m_pScript->getId() == id)
return temp->m_pScript;
temp = temp->getNext();
}
return NULL;
}
int cScriptList::deleteScript(int id){
cScriptPoint *marker = m_pFirst;
while(id != marker->m_pScript->getId()){
marker = marker->getNext();
}
if(marker->m_pScript->getId() == id){
marker->m_pScript->inkCounter();
if(marker->m_pScript->getCounter() <= 0){
cScriptPoint *temp_last = marker->getLast();
cScriptPoint *temp_next = marker->getNext();
temp_last->setNext(temp_next);
temp_next->setLast(temp_last);
m_iSize--;
delete marker;
return 0;
}
}else{
return 0;
}
return 0;
}
/*********************************************************************
* *
* cInterpreter Class *
* *
*********************************************************************/
cInterpreter::cInterpreter(){
lua_baselibopen(L);
lua_iolibopen(L);
// registriert Wrapperfunktionen in lua
lua_register(L, "show", show); //nur zum testen
}
cInterpreter::~cInterpreter(){
lua_close(L);
}
cScriptList* const cScriptList::getInstance(){
if(!m_pInstance)
{
m_pInstance = new cScriptList;
}
return m_pInstance;
}
cScriptList *cScriptList::m_pInstance = NULL;
/************** Beginn Wrapper Functions ******************/
//nur zum testen
int cInterpreter::show(lua_State *L){
cout<<"test"<<endl;
return 1;
}
/************** End Wrapper Functions *********************/
cInterpreter* const cInterpreter::getInstance(){
if(!m_pInstance)
{
m_pInstance = new cInterpreter;
}
return m_pInstance;
}
bool cInterpreter::runScript(obj::cBaseObject* obj1, cScript* script){
if(script == NULL){
return false;
}else{
object = obj1;
at_run = script;
lua_getglobal(L, at_run->getFunction());
int status = lua_pcall(L, 0, 0, 0); // Argumente und Returns ermoeglichen
if (status) {
const char *msg = lua_tostring(L, -1);
if (msg == NULL) msg = "(error with no message)";
cerr<<"Error: "<<msg<<endl; //Fehlerabfrage einbauen
lua_pop(L, 1);
}
}
return true;
}
cInterpreter *cInterpreter::m_pInstance = NULL;