More work done on Telecomms:

▫ 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.

git-svn-id: http://tgstation13.googlecode.com/svn/trunk@3193 316c924e-a436-60f5-8080-3fe189b3f50e

code/modules/scripting/AST/AST Nodes.dm

@@ -0,0 +1,139 @@
+/*
+	File: AST Nodes
+	An abstract syntax tree (AST) is a representation of source code in a computer-friendly format. It is composed of nodes,
+	each of which represents a certain part of the source code. For example, an <IfStatement> node represents an if statement in the
+	script's source code. Because it is a representation of the source code in memory, it is independent of any specific scripting language.
+	This allows a script in any language for which a parser exists to be run by the interpreter.
+
+	The AST is produced by an <n_Parser> object. It consists of a <GlobalBlock> with an arbitrary amount of statements. These statements are
+	run in order by an <n_Interpreter> object. A statement may in turn run another block (such as an if statement might if its condition is
+	met).
+
+	Articles:
+	- <http://en.wikipedia.org/wiki/Abstract_syntax_tree>
+*/
+var
+	const
+/*
+	Constants: Operator Precedence
+	OOP_OR				- Logical or
+	OOP_AND				- Logical and
+	OOP_BIT				- Bitwise operations
+	OOP_EQUAL			- Equality checks
+	OOP_COMPARE		- Greater than, less then, etc
+	OOP_ADD				- Addition and subtraction
+	OOP_MULTIPLY	- Multiplication and division
+	OOP_POW				- Exponents
+	OOP_UNARY			- Unary Operators
+	OOP_GROUP			- Parentheses
+*/
+		OOP_OR      = 							1   //||
+		OOP_AND     = OOP_OR			+ 1   	//&&
+		OOP_BIT     = OOP_AND			+ 1   //&, |
+		OOP_EQUAL   = OOP_BIT			+ 1   //==, !=
+		OOP_COMPARE = OOP_EQUAL		+ 1   //>, <, >=, <=
+		OOP_ADD     = OOP_COMPARE	+ 1 	//+, -
+		OOP_MULTIPLY= OOP_ADD			+ 1   //*, /, %
+		OOP_POW     = OOP_MULTIPLY+ 1		//^
+		OOP_UNARY   = OOP_POW			+ 1   //!
+		OOP_GROUP   = OOP_UNARY		+ 1   //()
+
+/*
+	Class: node
+*/
+/node
+	proc
+		ToString()
+			return "[src.type]"
+/*
+	Class: identifier
+*/
+/node/identifier
+	var
+		id_name
+
+	New(id)
+		.=..()
+		src.id_name=id
+
+	ToString()
+		return id_name
+
+/*
+	Class: expression
+*/
+/node/expression
+/*
+	Class: operator
+	See <Binary Operators> and <Unary Operators> for subtypes.
+*/
+/node/expression/operator
+	var
+		node/expression/exp
+		tmp
+			name
+			precedence
+
+	New()
+		.=..()
+		if(!src.name) src.name="[src.type]"
+
+	ToString()
+		return "operator: [name]"
+
+/*
+	Class: FunctionCall
+*/
+/node/expression/FunctionCall
+	//Function calls can also be expressions or statements.
+	var
+		func_name
+		node/identifier/object
+		list/parameters=new
+
+/*
+	Class: literal
+*/
+/node/expression/value/literal
+	var
+		value
+
+	New(value)
+		.=..()
+		src.value=value
+
+	ToString()
+		return src.value
+
+/*
+	Class: variable
+*/
+/node/expression/value/variable
+	var
+		node
+			object		//Either a node/identifier or another node/expression/value/variable which points to the object
+		node/identifier
+			id
+
+
+	New(ident)
+		.=..()
+		id=ident
+		if(istext(id))id=new(id)
+
+	ToString()
+		return src.id.ToString()
+
+/*
+	Class: reference
+*/
+/node/expression/value/reference
+	var
+		datum/value
+
+	New(value)
+		.=..()
+		src.value=value
+
+	ToString()
+		return "ref: [src.value] ([src.value.type])"

code/modules/scripting/AST/Blocks.dm

@@ -0,0 +1,48 @@
+/*
+	File: Block Types
+*/
+/*
+	Class: BlockDefinition
+	An object representing a set of actions to perform independently from the rest of the script. Blocks are basically just
+	lists of statements to execute which also contain some local variables and methods. Note that since functions are local to a block,
+	it is possible to have a function definition inside of any type of block (such as in an if statement or another function),
+	and not just in the global scope as in many languages.
+*/
+/node/BlockDefinition
+	var/list
+		statements = new
+		functions  = new
+		initial_variables = new
+
+	proc
+/*
+	Proc: SetVar
+	Defines a permanent variable. The variable will not be deleted when it goes out of scope.
+
+	Notes:
+	Since all pre-existing temporary variables are deleted, it is not generally desirable to use this proc after the interpreter has been instantiated.
+	Instead, use <n_Interpreter.SetVar()>.
+
+	See Also:
+	- <n_Interpreter.SetVar()>
+*/
+		SetVar(name, value)
+			initial_variables[name]=value
+
+
+/*
+	Class: GlobalBlock
+	A block object representing the global scope.
+*/
+//
+	GlobalBlock
+		New()
+			initial_variables["null"]=null
+			return ..()
+
+/*
+	Class: FunctionBlock
+	A block representing a function body.
+*/
+//
+	FunctionBlock

code/modules/scripting/AST/Operators/Binary Operators.dm

@@ -0,0 +1,173 @@
+/*
+	File: Binary Operators
+*/
+/*
+	Class: binary
+	Represents a binary operator in the AST. A binary operator takes two operands (ie x and y) and returns a value.
+*/
+/node/expression/operator/binary
+	var
+		node/expression/exp2
+
+////////// Comparison Operators //////////
+/*
+	Class: Equal
+	Returns true if x = y.
+*/
+//
+	Equal
+		precedence=OOP_EQUAL
+
+/*
+	Class: NotEqual
+	Returns true if x and y aren't equal.
+*/
+//
+	NotEqual
+		precedence=OOP_EQUAL
+
+/*
+	Class: Greater
+	Returns true if x > y.
+*/
+//
+	Greater
+		precedence=OOP_COMPARE
+
+/*
+	Class: Less
+	Returns true if x < y.
+*/
+//
+	Less
+		precedence=OOP_COMPARE
+
+/*
+	Class: GreaterOrEqual
+	Returns true if x >= y.
+*/
+//
+	GreaterOrEqual
+		precedence=OOP_COMPARE
+
+/*
+	Class: LessOrEqual
+	Returns true if x <= y.
+*/
+//
+	LessOrEqual
+		precedence=OOP_COMPARE
+
+
+////////// Logical Operators //////////
+
+/*
+	Class: LogicalAnd
+	Returns true if x and y are true.
+*/
+//
+	LogicalAnd
+		precedence=OOP_AND
+
+/*
+	Class: LogicalOr
+	Returns true if x, y, or both are true.
+*/
+//
+	LogicalOr
+		precedence=OOP_OR
+
+/*
+	Class: LogicalXor
+	Returns true if either x or y but not both are true.
+*/
+//
+	LogicalXor					//Not implemented in nS
+		precedence=OOP_OR
+
+
+////////// Bitwise Operators //////////
+
+/*
+	Class: BitwiseAnd
+	Performs a bitwise and operation.
+
+	Example:
+	011 & 110 = 010
+*/
+//
+	BitwiseAnd
+		precedence=OOP_BIT
+
+/*
+	Class: BitwiseOr
+	Performs a bitwise or operation.
+
+	Example:
+	011 | 110 = 111
+*/
+//
+	BitwiseOr
+		precedence=OOP_BIT
+
+/*
+	Class: BitwiseXor
+	Performs a bitwise exclusive or operation.
+
+	Example:
+	011 xor 110 = 101
+*/
+//
+	BitwiseXor
+		precedence=OOP_BIT
+
+
+////////// Arithmetic Operators //////////
+
+/*
+	Class: Add
+	Returns the sum of x and y.
+*/
+//
+	Add
+		precedence=OOP_ADD
+
+/*
+	Class: Subtract
+	Returns the difference of x and y.
+*/
+//
+	Subtract
+		precedence=OOP_ADD
+
+/*
+	Class: Multiply
+	Returns the product of x and y.
+*/
+//
+	Multiply
+		precedence=OOP_MULTIPLY
+
+/*
+	Class: Divide
+	Returns the quotient of x and y.
+*/
+//
+	Divide
+		precedence=OOP_MULTIPLY
+
+/*
+	Class: Power
+	Returns x raised to the power of y.
+*/
+//
+	Power
+		precedence=OOP_POW
+
+/*
+	Class: Modulo
+	Returns the remainder of x / y.
+*/
+//
+	Modulo
+		precedence=OOP_MULTIPLY

code/modules/scripting/AST/Operators/Unary Operators.dm

@@ -0,0 +1,51 @@
+/*
+	File: Unary Operators
+*/
+/*
+	Class: unary
+	Represents a unary operator in the AST. Unary operators take a single operand (referred to as x below) and return a value.
+*/
+/node/expression/operator/unary
+	precedence=OOP_UNARY
+
+/*
+	Class: LogicalNot
+	Returns !x.
+
+	Example:
+	!true = false and !false = true
+*/
+//
+	LogicalNot
+		name="logical not"
+
+/*
+	Class: BitwiseNot
+	Returns the value of a bitwise not operation performed on x.
+
+	Example:
+	~10 (decimal 2) = 01 (decimal 1).
+*/
+//
+	BitwiseNot
+		name="bitwise not"
+
+/*
+	Class: Minus
+	Returns -x.
+*/
+//
+	Minus
+		name="minus"
+
+/*
+	Class: group
+	A special unary operator representing a value in parentheses.
+*/
+//
+	group
+		precedence=OOP_GROUP
+
+	New(node/expression/exp)
+		src.exp=exp
+		return ..()

code/modules/scripting/AST/Statements.dm

@@ -0,0 +1,122 @@
+/*
+	File: Statement Types
+*/
+/*
+	Class: statement
+	An object representing a single instruction run by an interpreter.
+*/
+/node/statement
+/*
+	Class: FunctionCall
+	Represents a call to a function.
+*/
+//
+	FunctionCall
+		var
+			func_name
+			node/identifier/object
+			list/parameters=new
+
+/*
+	Class: FunctionDefinition
+	Defines a function.
+*/
+//
+	FunctionDefinition
+		var
+			func_name
+			list/parameters=new
+			node/BlockDefinition/FunctionBlock/block
+
+/*
+	Class: VariableAssignment
+	Sets a variable in an accessible scope to the given value if one exists, otherwise initializes a new local variable to the given value.
+
+	Notes:
+	If a variable with the same name exists in a higher block, the value will be assigned to it. If not,
+	a new variable is created in the current block. To force creation of a new variable, use <VariableDeclaration>.
+
+	See Also:
+	- <VariableDeclaration>
+*/
+//
+	VariableAssignment
+		var
+			node
+				identifier
+					object
+					var_name
+				expression/value
+
+/*
+	Class: VariableDeclaration
+	Intializes a local variable to a null value.
+
+	See Also:
+	- <VariableAssignment>
+*/
+//
+	VariableDeclaration
+		var
+			node
+				identifier
+					object
+					var_name
+
+/*
+	Class: IfStatement
+*/
+//
+	IfStatement
+		var
+			node
+				BlockDefinition
+					block
+					else_block //may be null
+				expression/cond
+
+/*
+	Class: WhileLoop
+	Loops while a given condition is true.
+*/
+//
+	WhileLoop
+		var
+			node
+				BlockDefinition/block
+				expression/cond
+
+/*
+	Class: ForLoop
+	Loops while test is true, initializing a variable, increasing the variable
+*/
+	ForLoop
+		var
+			node
+				BlockDefinition/block
+				expression/test
+				expression/init
+				expression/increment
+
+/*
+	Class: BreakStatement
+	Ends a loop.
+*/
+//
+	BreakStatement
+
+/*
+	Class: ContinueStatement
+	Skips to the next iteration of a loop.
+*/
+//
+	ContinueStatement
+
+/*
+	Class: ReturnStatement
+	Ends the function and returns a value.
+*/
+//
+	ReturnStatement
+		var
+			node/expression/value