/// <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; }