After registering the application interface it's time to compile the scripts that will be executed.
Message callback
Before starting the compilation, remember to have the message callback set in the engine so that you can get more information on compilation errors than just an error code. In fact, it is recommended to set the message callback right after creating the script engine, as the message callback may even be helpful while registering the application interface.
The message callback has been designed so that it doesn't output anything if there are no errors or warnings, so when everything is ok, you shouldn't get anything from it. But if the Build method returns an error, the message callback will have received detailed information about the error.
If desired, the application may send its own messages to the callback via the WriteMessage method on the engine.
{
const char *type = "ERR ";
type = "WARN";
type = "INFO";
}
@ asCALL_CDECL
A cdecl function.
Definition: angelscript.h:230
#define asFUNCTION(f)
Returns an asSFuncPtr representing the function specified by the name.
Definition: angelscript.h:685
@ asMSGTYPE_WARNING
The message is a warning.
Definition: angelscript.h:428
@ asMSGTYPE_INFORMATION
The message is informational only.
Definition: angelscript.h:430
The engine interface.
Definition: angelscript.h:1102
virtual int SetMessageCallback(const asSFuncPtr &callback, void *obj, asDWORD callConv)=0
Sets a message callback that will receive compiler messages.
AS_API asIScriptEngine * asCreateScriptEngine(asDWORD version=ANGELSCRIPT_VERSION)
Creates the script engine.
Represents a compiler message.
Definition: angelscript.h:777
int col
The column.
Definition: angelscript.h:783
int row
The row number.
Definition: angelscript.h:781
asEMsgType type
The type of message.
Definition: angelscript.h:785
const char * section
The script section where the message is raised.
Definition: angelscript.h:779
const char * message
The message text.
Definition: angelscript.h:787
Loading and compiling scripts
To build a script module you first obtain a module from the engine, then add the script sections, and finally compile them. A compiled script module may be composed of one or more script sections, so your application may store each section in different files, or even generate them dynamically. It doesn't matter in which order the script sections are added to the module, as the compiler is able to resolve all names regardless of where they are declared in the script.
string script;
LoadScriptFile("script.as", script);
if( r < 0 )
{
}
@ asGM_ALWAYS_CREATE
Always create a new module, discarding the existing one.
Definition: angelscript.h:534
virtual asIScriptModule * GetModule(const char *module, asEGMFlags flag=asGM_ONLY_IF_EXISTS)=0
Return an interface pointer to the module.
The interface to the script modules.
Definition: angelscript.h:2232
virtual int AddScriptSection(const char *name, const char *code, size_t codeLength=0, int lineOffset=0)=0
Add a script section for the next build.
virtual int Build()=0
Build the previously added script sections.
AngelScript doesn't provide built-in functions for loading script files as most applications have their own way of loading files. However, it is quite easy to write your own routines for loading script files, for example:
void LoadScriptFile(const char *fileName, string &script)
{
FILE *f = fopen("test.as", "rb");
fseek(f, 0, SEEK_END);
int len = ftell(f);
fseek(f, 0, SEEK_SET);
script.resize(len);
fread(&script[0], len, 1, f);
fclose(f);
}
As AngelScript doesn't load the files itself, it also doesn't have built-in support for including other files from within the script. However, if you look in the add-on directory, you'll find a CScriptBuilder class that provides this support and more. It is a helper class for loading files, perform a pre-processing pass, and then building the module. You can a see an example of how to use the script builder in Your first script.
- See also
- Pre-compiled byte code