mirror of
https://github.com/CHOMPStation2/CHOMPStation2.git
synced 2025-12-10 10:12:45 +00:00
f8dd926ca5
▫ Signals can now be rejected by Subspace broadcasters through a specific data[] parameter. ▫ Improved the log browser. ▫ Log browsers and telecommunication monitors no longer require access to use. You do need access to delete logs, however. ▫ Intercoms need power to work. They don't drain power, they just need a constant flow of equipment power. As such, that offline intercom sprite's now finally being put to use. Scripting language: ▫ Sorry about all the files; they're all necessary! It's important to notice that the basic structure of the scripting language code is not mine; I cannibalized the base structure from some obscure BYOND project. It's pretty well documented, and I'd say easier to browse through than atmos. Here's the basic deal: A compiler datum manages the relationships between the three main subsystems of a scripting language: the Scanner, the Parser, and the Interpreter. The Scanner splits raw text into token datums that the Parser can read. The Parser transforms the otherwise random bits and strings into ordered AST Trees and nodes for the Interpreter to read. The interpreter actually executes the code and handles scope/functions/code blocks. Revision: r3193 Author: vageyenaman
142 lines
3.8 KiB
Plaintext
142 lines
3.8 KiB
Plaintext
/*
|
|
File: Interpreter (Public)
|
|
Contains methods for interacting with the interpreter.
|
|
*/
|
|
/*
|
|
Class: n_Interpreter
|
|
Procedures allowing for interaction with the script that is being run by the interpreter object.
|
|
*/
|
|
|
|
/n_Interpreter
|
|
proc
|
|
|
|
/*
|
|
Proc: Load
|
|
Loads a 'compiled' script into memory.
|
|
|
|
Parameters:
|
|
program - A <GlobalBlock> object which represents the script's global scope.
|
|
*/
|
|
Load(node/BlockDefinition/GlobalBlock/program)
|
|
ASSERT(program)
|
|
src.program = program
|
|
CreateGlobalScope()
|
|
|
|
/*
|
|
Proc: Run
|
|
Runs the script.
|
|
*/
|
|
Run()
|
|
cur_recursion = 0 // reset recursion
|
|
cur_statements = 0 // reset CPU tracking
|
|
alertadmins = 0
|
|
|
|
ASSERT(src.program)
|
|
RunBlock(src.program)
|
|
|
|
/*
|
|
Proc: SetVar
|
|
Defines a global variable for the duration of the next execution of a script.
|
|
|
|
Notes:
|
|
This differs from <Block.SetVar()> in that variables set using this procedure only last for the session,
|
|
while those defined from the block object persist if it is ran multiple times.
|
|
|
|
See Also:
|
|
- <Block.SetVar()>
|
|
*/
|
|
SetVar(name, value)
|
|
if(!istext(name))
|
|
//CRASH("Invalid variable name")
|
|
return
|
|
AssignVariable(name, value)
|
|
|
|
/*
|
|
Proc: SetProc
|
|
Defines a procedure to be available to the script.
|
|
|
|
Parameters:
|
|
name - The name of the procedure as exposed to the script.
|
|
path - The typepath of a proc to be called when the function call is read by the interpreter, or, if object is specified, a string representing the procedure's name.
|
|
object - (Optional) An object which will the be target of a function call.
|
|
params - Only required if object is not null, a list of the names of parameters the proc takes.
|
|
*/
|
|
SetProc(name, path, object=null, list/params=null)
|
|
if(!istext(name))
|
|
//CRASH("Invalid function name")
|
|
return
|
|
if(!object)
|
|
globalScope.functions[name] = path
|
|
else
|
|
var/node/statement/FunctionDefinition/S = new()
|
|
S.func_name = name
|
|
S.parameters = params
|
|
S.block = new()
|
|
S.block.SetVar("src", object)
|
|
var/node/expression/FunctionCall/C = new()
|
|
C.func_name = path
|
|
C.object = new("src")
|
|
for(var/p in params)
|
|
C.parameters += new/node/expression/value/variable(p)
|
|
var/node/statement/ReturnStatement/R=new()
|
|
R.value=C
|
|
S.block.statements += R
|
|
globalScope.functions[name] = S
|
|
/*
|
|
Proc: VarExists
|
|
Checks whether a global variable with the specified name exists.
|
|
*/
|
|
VarExists(name)
|
|
return globalScope.variables.Find(name) //convert to 1/0 first?
|
|
|
|
/*
|
|
Proc: ProcExists
|
|
Checks whether a global function with the specified name exists.
|
|
*/
|
|
ProcExists(name)
|
|
return globalScope.functions.Find(name)
|
|
|
|
/*
|
|
Proc: GetVar
|
|
Returns the value of a global variable in the script. Remember to ensure that the variable exists before calling this procedure.
|
|
|
|
See Also:
|
|
- <VarExists()>
|
|
*/
|
|
GetVar(name)
|
|
if(!VarExists(name))
|
|
//CRASH("No variable named '[name]'.")
|
|
return
|
|
var/x = globalScope.variables[name]
|
|
return Eval(x)
|
|
|
|
/*
|
|
Proc: CallProc
|
|
Calls a global function defined in the script and, amazingly enough, returns its return value. Remember to ensure that the function
|
|
exists before calling this procedure.
|
|
|
|
See Also:
|
|
- <ProcExists()>
|
|
*/
|
|
CallProc(name, params[]=null)
|
|
if(!ProcExists(name))
|
|
//CRASH("No function named '[name]'.")
|
|
return
|
|
var/node/statement/FunctionDefinition/func = globalScope.functions[name]
|
|
if(istype(func))
|
|
var/node/statement/FunctionCall/stmt = new
|
|
stmt.func_name = func.func_name
|
|
stmt.parameters = params
|
|
return RunFunction(stmt)
|
|
else
|
|
return call(func)(arglist(params))
|
|
//CRASH("Unknown function type '[name]'.")
|
|
|
|
/*
|
|
Event: HandleError
|
|
Called when the interpreter throws a runtime error.
|
|
|
|
See Also:
|
|
- <runtimeError>
|
|
*/
|
|
HandleError(runtimeError/e) |