/// <summary>
/// Called when the state of this entities script is changed.
/// </summary>
/// <param name="process">Process that had its state changed.</param>
/// <param name="sate">New state.</param>
public void OnStateChange(ScriptProcess process, StateSymbol state)
{
_renderFunction = state == null ? null : _process.Process.State.FindSymbol("OnRender", SymbolType.Function) as FunctionSymbol;
// SyncCollisionEvents();
}
/// <summary>
/// Compiles a script from a string into byte code.
/// </summary>
/// <param name="data">Data of script to compile.</param>
/// <param name="flags">Bitmask of flags defining how the script should be compiled.</param>
/// <param name="defineList">A list of defines to use while preprocessing script.</param>
/// <param name="includePaths">A list of directory paths to use when looking for include files.</param>
/// <param name="fileUrl">Contains the url of the file this data comes from.</param>
/// <returns>The number of errors or warning this script has generated duren compilation.</returns>
public int CompileString(string data, CompileFlags flags, Define[] defineList, object[] includePaths, string fileUrl)
{
#if !DEBUG
try
{
#endif
// Reset all variables used to store compilation details.
_errorList.Clear();
_compiledSymbolList.Clear();
_compiledInstructionList.Clear();
_compiledDebugFileList.Clear();
_compiledDefineList.Clear();
_loopTrackerStack.Clear();
_metaDataList.Clear();
_currentToken = null;
_currentPass = 0;
_currentScope = null;
_globalScope = new FunctionSymbol("$global", null); // Initialize global scope here.
_memberScope = new FunctionSymbol("$member", null); // Initialize member scope here.
_compileFlags = flags;
_tokenList = null;
_tokenIndex = 0;
_memorySize = 1; // Reserve space for 'special' globals like 'this'.
_internalVariableIndex = 0;
_defaultEngineState = _defaultEditorState = null;
_errorsOccured = false;
_overrideInstructionScope = null;
// Create the 'this' variable.
VariableSymbol thisSymbol = new VariableSymbol(_globalScope);
thisSymbol.DataType = new DataTypeValue(DataType.Object, false, false);
thisSymbol.Identifier = "this";
thisSymbol.IsConstant = true;
thisSymbol.IsUsed = true;
thisSymbol.MemoryIndex = 0;
thisSymbol.VariableType = VariableType.Constant;
// Create a lexer and convert script into a list
// of tokens.
DebugLogger.WriteLog("Preforming lexical analysis on script.");
Lexer lexer = new Lexer();
if (lexer.Analyse(data, _compileFlags, fileUrl) > 0)
{
foreach (CompileError error in lexer.ErrorList)
_errorList.Add(error);
}
_tokenList = lexer.TokenList;
// Add the script directory into the include path array.
string includePath = Path.GetDirectoryName(fileUrl);
string[] newIncludePaths = new string[includePaths.Length + 1];
includePaths.CopyTo(newIncludePaths, 0);
newIncludePaths[newIncludePaths.Length - 1] = includePath;
includePaths = newIncludePaths;
// Create a pre-processor and process the token list
DebugLogger.WriteLog("Preforming preprocessing on script.");
PreProcessor preProcessor = new PreProcessor();
if (preProcessor.Process(_tokenList, _compileFlags, defineList, includePaths) > 0)
{
foreach (CompileError error in preProcessor.ErrorList)
_errorList.Add(error);
}
_compiledDefineList = preProcessor.DefineList;
_tokenList = preProcessor.TokenList;
try
{
// Pass 0: Collect infomation.
// Pass 1: Generate byte code.
DebugLogger.WriteLog("Compiling script in 2 passes.");
// Go over the source code in 2 passes.
for (int pass = 0; pass < 2; pass++)
{
_currentPass = pass;
_currentToken = null;
_tokenIndex = 0;
_currentScope = _globalScope;
_internalVariableIndex = 0; // This needs to be reset so statements using
// an internal variables can find them on the second pass.
while (!EndOfTokenStream())
{
try
{
ParseStatement();
}
catch (CompilePanicModeException)
{
DebugLogger.WriteLog("Panic mode initialized in script.");
// Don't do anything here, just allow the error to be
// forgoten and carry on as normal.
}
// If there are any errors quit compilation now.
if (_errorsOccured == true)
throw new CompileBreakException();
}
}
// Yell at user if no default state has been declared.
if (_defaultEngineState == null && (_compileFlags & CompileFlags.Library) == 0)
Error(ErrorCode.MissingDefaultState, "Default engine state is missing.");
}
catch (CompileBreakException)
{
DebugLogger.WriteLog("Script compilation broken via CompileBreakException.");
}
// Check what errors occured.
int fatalErrorCount = 0;
int errorCount = 0;
int warningCount = 0;
int messageCount = 0;
foreach (CompileError error in _errorList)
{
switch (error.AlertLevel)
{
case ErrorAlertLevel.Error: errorCount++; break;
case ErrorAlertLevel.FatalError: fatalErrorCount++; break;
case ErrorAlertLevel.Message: messageCount++; break;
case ErrorAlertLevel.Warning: warningCount++; break;
}
DebugLogger.WriteLog(error.ToString(), LogAlertLevel.Warning);
}
DebugLogger.WriteLog("Script compiled with "+fatalErrorCount+" fatal errors, "+errorCount+" errors, "+warningCount+" warnings and "+messageCount+" messages.");
// If there are any errors quit compilation now.
if (_errorsOccured == true) return _errorList.Count;
// Append an exit symbol onto the global scopes instruction list.
CreateInstruction(OpCode.EXIT, _globalScope, _currentToken);
DebugLogger.WriteLog("Optimizing and tweeking symbols and instructions.");
// Compile symbol list.
CompileSymbol(_globalScope);
CompileSymbol(_memberScope);
// Go through instruction list and replace placeholders with their values.
int symbolIndex = 0;
foreach (Symbol symbol in _compiledSymbolList)
{
symbol.Index = symbolIndex;
symbolIndex++;
// Update the entry point if this is a function or event.
switch (symbol.Type)
{
case SymbolType.Function:
((FunctionSymbol)symbol).EntryPoint = _compiledInstructionList.Count;
break;
case SymbolType.Variable:
bool check = true;
if (symbol.Scope.Type == SymbolType.Function)
if (((FunctionSymbol)symbol.Scope).IsImport == true) check = false;
// Should we remove it rather than warning?
if (((VariableSymbol)symbol).IsUsed == false && ((VariableSymbol)symbol).IsConstant == false && check == true)
Warning(ErrorCode.UnusedVariable, "Variable \"" + symbol.Identifier + "\" is declared but never used.");
break;
}
foreach (Instruction instruction in symbol.Instructions)
{
// Create a new debug file entry if this instruction
// was generated in a previously unknown file.
if (instruction.File != null && instruction.File != "")
{
bool found = false;
foreach (string file in _compiledDebugFileList)
if (file == instruction.File) found = true;
if (found == false) _compiledDebugFileList.Add(instruction.File);
}
// Go through each operand attach to this instruction
// and check for any trackers.
foreach (Operand operand in instruction.Operands)
{
if (operand == null) continue;
// Update operand based on type.
switch (operand.OpType)
{
case OperandType.JumpTarget:
operand.OpType = OperandType.InstrIndex;
switch (symbol.Type)
{
case SymbolType.Function:
operand.InstrIndex = ((FunctionSymbol)symbol).EntryPoint + operand.JumpTarget.InstrIndex;
break;
}
break;
case OperandType.SymbolIndexTracker:
operand.OpType = OperandType.SymbolIndex;
operand.SymbolIndex = _compiledSymbolList.IndexOf(operand.SymbolIndexTracker);
break;
}
}
_compiledInstructionList.Add(instruction);
}
}
// Optimize this symbols instructions. (Currently somewhat error prone)
//int instructionCount = _compiledInstructionList.Count;
//ScriptOptimizer optimizer = new ScriptOptimizer();
//optimizer.Optimize(_compiledInstructionList, _compiledSymbolList);
//_compiledInstructionList = optimizer.OptimizedInstructions;
//_compiledSymbolList = optimizer.OptimizedSymbols;
// int index = 0;
//foreach (Instruction instr in _compiledInstructionList)
//{
// System.Console.WriteLine("\t"+instr.Decompile());
// index++;
//}
#if !DEBUG
}
catch (Exception)
{
_errorList.Add(new CompileError(ErrorCode.InternalError, "An internal compiler error occured.", ErrorAlertLevel.FatalError, 0, 0, ""));
}
#endif
return _errorList.Count;
}
/// <summary>
/// Parses a state block. A state block is used to seperate events into specific
/// states to better emulate a state based machine.
/// Syntax:
/// "state" Identifier Statement
/// </summary>
private void ParseState()
{
// Make sure we are in a state's scope.
if (_currentScope != _globalScope)
Error(ErrorCode.InvalidScope, "States can only be declared within the global scope.", false, 0);
// See if this is the engine or editor default state.
bool isEngineDefault = false;
bool isEditorDefault = false;
int flagCount = 0;
while (_currentToken.ID != TokenID.KeywordState && EndOfTokenStream() != true)
{
switch (_currentToken.ID)
{
case TokenID.KeywordEngine:
if (_defaultEngineState != null) Error(ErrorCode.DuplicateDefault, "Default engine state declared multiple times.", false, 0);
if (isEngineDefault == true) Error(ErrorCode.DuplicateFlag, "\"" + _currentToken.Ident + "\" flag declared multiple times.", false, 0);
isEngineDefault = true;
break;
case TokenID.KeywordEditor:
if (_defaultEditorState != null) Error(ErrorCode.DuplicateDefault, "Default editor state declared multiple times.", false, 0);
if (isEditorDefault == true) Error(ErrorCode.DuplicateFlag, "\"" + _currentToken.Ident + "\" flag declared multiple times.", false, 0);
isEditorDefault = true;
break;
}
flagCount++;
NextToken();
}
// Read in state keyword if there are previous flags.
if (flagCount != 0) CheckToken(TokenID.KeywordState);
// Validate the "state(Identifier)" section of the
// the event declaration.
ExpectToken(TokenID.TypeIdentifier);
string stateIdent = _currentToken.Ident;
// Create event's symbol.
StateSymbol symbol = null;
if (_currentPass == 0)
{
if (_currentScope.FindSymbol(stateIdent, SymbolType.State) != null)
Error(ErrorCode.DuplicateSymbol, "State \"" + stateIdent + "\" declared multiple times.", false, 0);
symbol = new StateSymbol(_currentScope);
symbol.Identifier = stateIdent;
symbol.IsEngineDefault = isEngineDefault;
symbol.IsEditorDefault = isEditorDefault;
if (isEngineDefault == true)
_defaultEngineState = symbol;
if (isEditorDefault == true)
_defaultEditorState = symbol;
}
else if (_currentPass == 1)
{
symbol = _currentScope.FindSymbol(stateIdent, SymbolType.State) as StateSymbol;
}
// Read in this event's contents.
_lastMetaDataSymbol = symbol;
Symbol scope = _currentScope;
_currentScope = symbol;
ParseStatement();
_currentScope = scope;
}
/// <summary>
/// Changes this scripts state to the given state.
/// </summary>
public void ChangeState(StateSymbol symbol)
{
_callStack.Clear();
_runtimeStack.Clear();
_inAtom = false;
_lockInstruction = null;
_previousInAtom = false;
}
/// <summary>
/// Loads the byte code from a given binary reader.
/// </summary>
/// <param name="reader">BinaryReader to load byte code from.</param>
private void LoadByteCode(BinaryReader reader)
{
// Check the header is correct
if (reader.ReadByte() == 'C' && reader.ReadByte() == 'R' && reader.ReadByte() == 'X')
{
// Read in header variables.
_compileFlags = (CompileFlags)reader.ReadInt32();
_internalVariableIndex = reader.ReadInt32();
_memorySize = reader.ReadInt32();
int globalScopeIndex = reader.ReadInt32();
int memberScopeIndex = reader.ReadInt32();
_defaultEngineStateIndex = reader.ReadInt32();
_defaultEditorStateIndex = reader.ReadInt32();
// Create a new memory heap of the correct size
if (_memorySize > _memoryHeap.Length) _memoryHeap = new RuntimeValue[_memorySize];
for (int i = 0; i < _memorySize; i++)
_memoryHeap[i] = new RuntimeValue(RuntimeValueType.Invalid);
// Set the 'special' globals to their appropriate values.
_memoryHeap[0].ValueType = RuntimeValueType.Object;
_memoryHeap[0].ObjectIndex = 0;
int defineCount = reader.ReadInt32();
int symbolCount = reader.ReadInt32();
int instructionCount = reader.ReadInt32();
int debugFileCount = 0;
if ((_compileFlags & CompileFlags.Debug) != 0)
debugFileCount = reader.ReadInt32();
// Read in debug file list.
string[] debugFiles = new string[debugFileCount];
if ((_compileFlags & CompileFlags.Debug) != 0)
{
for (int i = 0; i < debugFileCount; i++)
debugFiles[i] = reader.ReadString();
}
// Read in the define list.
for (int i = 0; i < defineCount; i++)
{
string ident = reader.ReadString();
TokenID valueID = (TokenID)reader.ReadInt32();
string value = reader.ReadString();
Define define = new Define(ident, value, valueID);
_defineList.Add(define);
}
// Read in symbol list.
_symbolList = new Symbol[symbolCount];
for (int i = 0; i < symbolCount; i++)
{
// Read in general details about symbol.
SymbolType type = (SymbolType)reader.ReadByte();
string identifier = reader.ReadString();
int scopeIndex = reader.ReadInt32();
Symbol scope = null;
Symbol symbol = null;
if (scopeIndex != -1)
scope = (Symbol)_symbolList[scopeIndex];
// Read in specialized details about symbol.
switch (type)
{
case SymbolType.JumpTarget:
continue; // Ignore jump targets.
case SymbolType.Namespace:
NamespaceSymbol namespaceSymbol = new NamespaceSymbol(scope);
symbol = namespaceSymbol;
break;
case SymbolType.Enumeration:
EnumerationSymbol enumSymbol = new EnumerationSymbol(scope);
symbol = enumSymbol;
break;
case SymbolType.String:
StringSymbol stringSymbol = new StringSymbol(scope, identifier);
symbol = stringSymbol;
break;
case SymbolType.Function:
FunctionSymbol functionSymbol = new FunctionSymbol(identifier, scope);
symbol = functionSymbol;
functionSymbol.EntryPoint = reader.ReadInt32();
functionSymbol.LocalDataSize = reader.ReadInt16();
functionSymbol.IsEvent = reader.ReadBoolean();
functionSymbol.IsConsole = reader.ReadBoolean();
functionSymbol.IsExport = reader.ReadBoolean();
functionSymbol.IsImport = reader.ReadBoolean();
functionSymbol.IsThreadSpawner = reader.ReadBoolean();
functionSymbol.IsMember = reader.ReadBoolean();
functionSymbol.ParameterCount = reader.ReadByte();
bool isArray = reader.ReadBoolean();
bool isReference = reader.ReadBoolean();
functionSymbol.ReturnType = new DataTypeValue((DataType)reader.ReadByte(), isArray, isReference);
functionSymbol.AccessModifier = (SymbolAccessModifier)reader.ReadByte();
break;
case SymbolType.State:
StateSymbol stateSymbol = new StateSymbol(scope);
symbol = stateSymbol;
stateSymbol.IsEngineDefault = reader.ReadBoolean();
stateSymbol.IsEditorDefault = reader.ReadBoolean();
break;
case SymbolType.Variable:
VariableSymbol variableSymbol = new VariableSymbol(scope);
symbol = variableSymbol;
variableSymbol.DataType = new DataTypeValue((DataType)reader.ReadByte(), false, false);
variableSymbol.DataType.IsReference = reader.ReadBoolean();
variableSymbol.IsArray = reader.ReadBoolean();
variableSymbol.DataType.IsArray = variableSymbol.IsArray;
variableSymbol.IsConstant = reader.ReadBoolean();
variableSymbol.MemoryIndex = reader.ReadInt32();
variableSymbol.StackIndex = reader.ReadInt32();
variableSymbol.VariableType = (VariableType)reader.ReadByte();
variableSymbol.IsProperty = reader.ReadBoolean();
variableSymbol.AccessModifier = (SymbolAccessModifier)reader.ReadByte();
variableSymbol.ConstToken = new Token(TokenID.TypeIdentifier, reader.ReadString(), 0, 0, "");
break;
case SymbolType.MetaData:
MetaDataSymbol metaDataSymbol = new MetaDataSymbol(scope, identifier, "");
symbol = metaDataSymbol;
metaDataSymbol.Value = reader.ReadString();
break;
}
symbol.Identifier = identifier;
symbol.Index = i;
_symbolList[i] = symbol;
}
// Retrieve global scope.
_globalScope = _symbolList[globalScopeIndex] as FunctionSymbol;
_memberScope = _symbolList[memberScopeIndex] as FunctionSymbol;
//_currentState = _symbolList[_defaultEngineStateIndex] as StateSymbol; // Force this to be declared in the engine / editor.
// Read in instruction list.
_instructionList = new RuntimeInstruction[instructionCount];
for (int i = 0; i < instructionCount; i++)
{
// Read in instruction details and create a new instruction.
OpCode opCode = (OpCode)reader.ReadByte();
int operandCount = reader.ReadByte();
RuntimeInstruction instruction = new RuntimeInstruction(opCode);
_instructionList[i] = instruction;
if ((_compileFlags & CompileFlags.Debug) != 0)
{
int fileIndex = reader.ReadSByte();
if (fileIndex != -1) instruction.File = debugFiles[fileIndex];
instruction.Offset = reader.ReadInt16();
instruction.Line = reader.ReadInt16();
}
// Read in each operand attached to this instruction
for (int k = 0; k < operandCount; k++)
{
// Read in general details about this operand and create
// a new runtime value instance.
RuntimeValueType opType = (RuntimeValueType)reader.ReadInt32();
RuntimeValue operand = new RuntimeValue(opType);
instruction.Operands[instruction.OperandCount] = operand;
instruction.OperandCount++;
// Read in specialized info about this operand.
switch(opType)
{
case RuntimeValueType.BooleanLiteral:
operand.BooleanLiteral = reader.ReadBoolean();
break;
case RuntimeValueType.ByteLiteral:
operand.ByteLiteral = reader.ReadByte();
break;
case RuntimeValueType.DirectMemory:
operand.MemoryIndex = reader.ReadInt32();
break;
case RuntimeValueType.DirectMemoryIndexed:
operand.MemoryIndex = reader.ReadInt32();
operand.OffsetRegister = (Register)reader.ReadByte();
break;
case RuntimeValueType.DirectStack:
operand.StackIndex = reader.ReadInt32();
break;
case RuntimeValueType.DirectStackIndexed:
operand.StackIndex = reader.ReadInt32();
operand.OffsetRegister = (Register)reader.ReadByte();
break;
case RuntimeValueType.DoubleLiteral:
operand.DoubleLiteral = reader.ReadDouble();
break;
case RuntimeValueType.FloatLiteral:
operand.FloatLiteral = reader.ReadSingle();
break;
case RuntimeValueType.IndirectMemory:
operand.Register = (Register)reader.ReadByte();
break;
case RuntimeValueType.IndirectMemoryIndexed:
operand.Register = (Register)reader.ReadByte();
operand.OffsetRegister = (Register)reader.ReadByte();
break;
case RuntimeValueType.IndirectStack:
operand.Register = (Register)reader.ReadByte();
break;
case RuntimeValueType.IndirectStackIndexed:
operand.Register = (Register)reader.ReadByte();
operand.OffsetRegister = (Register)reader.ReadByte();
break;
case RuntimeValueType.InstrIndex:
operand.InstrIndex = reader.ReadInt32();
break;
case RuntimeValueType.IntegerLiteral:
operand.IntegerLiteral = reader.ReadInt32();
break;
case RuntimeValueType.LongLiteral:
operand.LongLiteral = reader.ReadInt64();
break;
case RuntimeValueType.Register:
operand.Register = (Register)reader.ReadByte();
break;
case RuntimeValueType.ShortLiteral:
operand.ShortLiteral = reader.ReadInt16();
break;
case RuntimeValueType.SymbolIndex:
operand.SymbolIndex = reader.ReadInt32();
operand.Symbol = (Symbol)_symbolList[operand.SymbolIndex];
if (operand.Symbol is StringSymbol)
{
operand.StringLiteral = operand.Symbol.Identifier;
operand.ValueType = RuntimeValueType.StringLiteral;
}
break;
}
}
}
// Fill the member-function hash table.
foreach (Symbol symbol in GlobalScope.Symbols)
if (symbol != null && symbol.Type == SymbolType.Function && ((FunctionSymbol)symbol).AccessModifier == SymbolAccessModifier.Public)
_memberFunctionHashTable.Add(symbol.ToString().ToLower(), symbol);
}
else
throw new Exception("Unable to load script byte code, header is invalid.");
}
public void ChangeState(StateSymbol state)
{
// Call the state change event.
if (OnStateChange != null)
OnStateChange(this, state);
// Invoke the state finish function.
if (_currentState != null) InvokeFunction("OnStateFinish", true, false);
_currentState = state;
// Change state for each thread.
foreach (ScriptThread thread in _threads)
thread.ChangeState(state);
// Invoke the state begin function.
if (_currentState != null)
InvokeFunction("OnStateBegin", true, false);
}
/// <summary>
/// Called when the state of this entities script is changed.
/// </summary>
/// <param name="process">Process that had its state changed.</param>
/// <param name="sate">New state.</param>
public void OnStateChange(ScriptProcess process, StateSymbol state)
{
_tickFunction = (state == null ? null : (state.FindSymbol("OnTick", SymbolType.Function) as FunctionSymbol));
}
/// <summary>
/// Called when the state of this entities script is changed.
/// </summary>
/// <param name="process">Process that had its state changed.</param>
/// <param name="sate">New state.</param>
public void OnStateChange(ScriptProcess process, StateSymbol state)
{
if (_isServer == true) return;
if (_mapScriptProcess != null && process == _mapScriptProcess.Process)
_window.MapScriptRenderFunction = state.FindSymbol("OnRender", SymbolType.Function) as FunctionSymbol;
else if (_gameScriptProcess != null && process == _gameScriptProcess.Process)
_window.GameScriptRenderFunction = state.FindSymbol("OnRender", SymbolType.Function) as FunctionSymbol;
}