removed test case directory

tests now maintained outside of code repository

1 files changed, 0 insertions, 473 deletions

diff --git a/test/rlhc.d/rlhc-csharp.lm b/test/rlhc.d/rlhc-csharp.lm
deleted file mode 100644
index 1ae36af2..00000000
--- a/test/rlhc.d/rlhc-csharp.lm
+++ /dev/null
@@ -1,473 +0,0 @@
-
-namespace csharp_out
-	token _IN_ /''/
-	token _EX_ /''/
-
-	lex
-		token comment /
-			'//' any* :> '\n' |
-			'/*' any* :>> '*/'
-		/
-
-		token id
-			/[a-zA-Z_][a-zA-Z_0-9]*/
-
-		token number /
-			[0-9]+
-		/
-
-		token symbol /
-			'!' | '#' | '$' | '%' | '&' | '(' | ')' | '*' |
-			'+' | ',' | '-' | '.' | '/' | ':' | ';' | '<' |
-			'=' | '>' | '?' | '@' | '[' | ']' | '^' | '|' |
-			'~' /
-
-		literal `{ `}
-
-		token string /
-				'"' ( [^"\\] | '\\' any ) * '"' |
-				"'" ( [^'\\] | '\\' any ) * "'"
-			/
-
-		ignore
-			/[ \t\v\r\n]+/
-	end
-
-	def item
-		[comment]
-	|	[id]
-	|	[number]
-	|	[symbol]
-	|	[string]
-	|	[`{ _IN_ item* _EX_ `} ]
-
-	def csharp_out
-		[_IN_ _EX_ item*]
-end
-
-namespace csharp_gen
-
-	global Parser: parser<csharp_out::csharp_out>
-
-	void tok_list( TL: host::tok* )
-	{
-		for Tok: host::tok in repeat(TL) {
-			switch Tok
-			case [host::`${ StmtList: stmt* host::`}$]
-				send Parser "{[stmt_list( StmtList )]}"
-			case [host::`={ Expr: expr host::`}=]
-				send Parser "([expr( Expr )])"
-			case [E: escape] {
-				Str: str = $E
-				send Parser
-					"[Str.suffix( 1 )]"
-			}
-			default {
-				send Parser [Tok]
-			}
-		}
-	}
-
-	void embedded_host( EH: embedded_host )
-	{
-		switch EH
-		case [`host `( string `, uint `) `={ TL: host::tok* host::`}=]
-		{
-			send Parser
-				"([tok_list( TL )])"
-		}
-		case [`host `( string `, uint `) `${ TL: host::tok* host::`}$]
-		{
-			send Parser 
-				"{[tok_list( TL )]}
-		}
-		case [`host `( string `, uint `) `@{ TL: host::tok* host::`}@]
-		{
-			send Parser
-				[tok_list( TL )]
-		}
-	}
-
-	void expr_factor( ExprFactor: expr_factor )
-	{
-		switch ExprFactor
-		case
-			[EH: embedded_host]
-		{
-			send Parser
-				[embedded_host( EH )]
-		}
-		case [O:`( TL: expr C: `)]
-		{
-			send Parser
-				[O expr(TL) C]
-		}
-		case [ident O: `[ TL: expr C: `]]
-		{
-			send Parser
-				[ExprFactor.ident O expr( TL ) C]
-		}
-		case ['offset' '(' ident ',' expr ')']
-		{
-			send Parser
-				[expr( ExprFactor.expr )]
-		}
-		case ['deref' '(' ident ',' expr ')']
-		{
-			send Parser
-				[ ExprFactor.ident '[' expr( ExprFactor.expr ) ']']
-		}
-		case [T: `TRUE]
-		{
-			T.data = 'true'
-			send Parser [T]
-		}
-		case [F: `FALSE]
-		{
-			F.data = 'false'
-			send Parser [F]
-		}
-		case [N: `nil]
-		{
-			N.data = '0'
-			send Parser [N]
-		}
-		case [Number: number]
-		{
-			number( Number )
-		}
-		case [E1: embedded_host `-> E2: expr_factor]
-		{
-			embedded_host( E1 )
-			expr_factor( E2 )
-		}
-		case [`cast Open: `( Type: type Close: `) expr_factor]
-		{
-			send Parser [Open]
-			type( Type )
-			send Parser [Close]
-			expr_factor( ExprFactor._expr_factor )
-		}
-		default {
-			# Catches cases not specified
-			send Parser [ExprFactor]
-		}
-	}
-
-	void lvalue( ExprFactor: lvalue )
-	{
-		switch ExprFactor
-		case [EH: embedded_host]
-		{
-			send Parser
-				[embedded_host( EH )]
-		}
-		case [ident O: `[ TL: expr C: `]]
-		{
-			send Parser
-				[ExprFactor.ident O expr( TL ) C]
-		}
-		case [E1: embedded_host `-> E2: lvalue]
-		{
-			embedded_host( E1 )
-			lvalue( E2 )
-		}
-		default {
-			# Catches cases not specified
-			send Parser [ExprFactor]
-		}
-	}
-
-	void expr_factor_op( ExprFactorOp: expr_factor_op )
-	{
-		switch ExprFactorOp
-		case [B: `! expr_factor_op]
-		{
-			send Parser [B]
-			expr_factor_op( ExprFactorOp._expr_factor_op )
-		}
-		case [T: `~ expr_factor_op]
-		{
-			send Parser [T]
-			expr_factor_op( ExprFactorOp._expr_factor_op )
-		}
-		case [expr_factor]
-		{
-			expr_factor( ExprFactorOp.expr_factor )
-		}
-	}
-
-	void expr_bitwise( ExprBitwise: expr_bitwise )
-	{
-		switch ExprBitwise
-		case [expr_bitwise A: `& expr_factor_op]
-		{
-			expr_bitwise( ExprBitwise._expr_bitwise )
-			send Parser [A]
-			expr_factor_op( ExprBitwise.expr_factor_op )
-		}
-		case [expr_factor_op]
-		{
-			expr_factor_op( ExprBitwise.expr_factor_op )
-		}
-	}
-
-	void expr_mult( ExprMult: expr_mult )
-	{
-		switch ExprMult
-		case [expr_mult T: `* expr_bitwise]
-		{
-			expr_mult( ExprMult._expr_mult )
-			send Parser [T]
-			expr_bitwise( ExprMult.expr_bitwise )
-		}
-		case [expr_bitwise]
-		{
-			expr_bitwise( ExprMult.expr_bitwise )
-		}
-	}
-
-	void expr_add( ExprAdd: expr_add )
-	{
-		switch ExprAdd
-		case [expr_add Op: add_op expr_mult]
-		{
-			expr_add( ExprAdd._expr_add )
-			send Parser [Op]
-			expr_mult( ExprAdd.expr_mult )
-		}
-		case [expr_mult]
-		{
-			expr_mult( ExprAdd.expr_mult )
-		}
-	}
-
-	void expr_shift( ExprShift: expr_shift )
-	{
-		switch ExprShift
-		case [expr_shift Op: shift_op expr_add]
-		{
-			expr_shift( ExprShift._expr_shift )
-			send Parser [Op]
-			expr_add( ExprShift.expr_add )
-		}
-		case [expr_add]
-		{
-			expr_add( ExprShift.expr_add )
-		}
-	}
-
-	void expr_test( ExprTest: expr_test )
-	{
-		switch ExprTest
-		case [expr_test Op: test_op expr_shift]
-		{
-			expr_test( ExprTest._expr_test )
-			send Parser [Op]
-			expr_shift( ExprTest.expr_shift )
-		}
-		case [expr_shift]
-		{
-			expr_shift( ExprTest.expr_shift )
-		}
-	}
-
-	void expr( Expr: expr )
-	{
-		expr_test( Expr.expr_test )
-	}
-
-	void type( Type: type )
-	{
-		switch Type
-		case "s8"
-			send Parser ['sbyte ']
-		case "s16"
-			send Parser ['short ']
-		case "s32"
-			send Parser ['int ']
-		case "s64"
-			send Parser ['long ']
-		case "s128"
-			send Parser ['long long ']
-		case "uint"
-			send Parser ['uint ']
-		default
-			send Parser [Type]
-	}
-
-	void number( Number: number )
-	{
-		switch Number
-		case [`c `( uint `) ] {
-			Str: str = $Number.uint
-			send Parser "'\\u[sprintf( "%04x", Str.atoi() )]'"
-		}
-		case [`u `( uint `) ] {
-			send Parser [$Number.uint]
-		}
-		default {
-			send Parser [$Number.sint]
-		}
-	}
-
-	void num_list( NumList: num_list )
-	{
-		for Number: number in NumList
-			send Parser "[number( Number )], "
-	}
-
-	void stmt( Stmt: stmt )
-	{
-		switch Stmt
-		case [EH: embedded_host]
-		{
-			send Parser
-				[embedded_host( EH )]
-		}
-		case [A: static_array] {
-			send Parser
-				"static readonly [type(A.type)] \[\]"
-					"[A.ident] = { [num_list( A.num_list )] };
-		}
-		case [V: static_value] {
-			send Parser
-				"static readonly [V.type] [V.ident] = [V.number];
-		}
-		case [
-				'if' O: `( IfExpr: expr C: `) IfStmt: stmt
-				ElseIfClauseList: else_if_clause* ElseClauseOpt: else_clause?
-		] {
-			send Parser
-				"if ( [expr(IfExpr)] )
-				"	[stmt(IfStmt)]
-
-			for ElseIfClause: else_if_clause in repeat( ElseIfClauseList ) {
-				match ElseIfClause
-					['else if (' ElseIfExpr: expr ')' ElseIfStmt: stmt]
-
-				send Parser
-					"else if ( [expr(ElseIfExpr)] )
-					"	[stmt(ElseIfStmt)]
-			}
-
-			if ( match ElseClauseOpt ['else' ElseStmt: stmt] ) {
-				send Parser
-					"else
-					"	[stmt(ElseStmt)]
-			}
-		}
-		case ['while' '(' WhileExpr: expr ')' WhileStmt: stmt] {
-			send Parser
-				"while ( [expr(WhileExpr)] )
-				"	[stmt(WhileStmt)]
-		}
-		case ['switch' '(' SwitchExpr: expr ')' '{' StmtList: stmt* '}'] {
-			send Parser
-				"switch ( [expr(SwitchExpr)] ) {
-				"	[stmt_list(StmtList)]
-				"}
-		}
-		case [ExprExpr: expr Semi: `;] {
-			send Parser
-				[expr(ExprExpr) Semi]
-		}
-		case [L: `{ TL: stmt* R: `}] {
-			send Parser
-				[L stmt_list(TL) R]
-		}
-		case [
-			TypeList: opt_const Type: type Ident: ident
-			OptInit: opt_init Semi: `;
-		]
-		{
-			send Parser
-				[TypeList type(Type) Ident]
-
-			if match OptInit [E: `= expr] {
-				send Parser
-					[E expr(OptInit.expr)]
-			}
-
-			send Parser
-				[Semi]
-		}
-		case [Export: export_stmt]
-		{
-			send Parser
-				"#define [Export.ident] [Export.number] 
-		}
-		case ['fallthrough' ';']
-		{
-			# Nothing needed here.
-		}
-		case [index_stmt]
-		{
-			send Parser
-				"int [Stmt.index_stmt.ident];
-		}
-		case [case_block]
-		{
-			send Parser
-				"case [expr( Stmt.case_block.expr )]:
-				"[stmt_list( Stmt.case_block._repeat_stmt )]
-				"break;
-		}
-		case [default_block]
-		{
-			send Parser
-				"default:
-				"[stmt_list( Stmt.default_block._repeat_stmt )]
-				"break;
-		}
-		case [case_label]
-		{
-			send Parser
-				"case [expr( Stmt.case_label.expr )]:
-		}
-		case [label_stmt]
-		{
-			send Parser
-				"[Stmt.label_stmt.ident]:
-				"[stmt_list( Stmt.label_stmt._repeat_stmt )]
-		}
-		case [entry_loop]
-		{
-			send Parser
-				[stmt_list( Stmt.entry_loop._repeat_stmt )]
-		}
-		case [AS: assign_stmt]
-		{
-			send Parser
-				"[lvalue(AS.LValue) AS.assign_op expr(AS.expr)];
-		}
-		default {
-			# catches unspecified cases
-			send Parser [Stmt]
-		}
-	}
-
-	void stmt_list( StmtList: stmt* )
-	{
-		for Stmt: stmt in repeat( StmtList )
-			stmt( Stmt )
-	}
-
-	void trans( Output: stream, Start: start )
-	{
-		Parser = new parser<csharp_out::csharp_out>()
-
-		stmt_list( Start._repeat_stmt )
-
-		CSO: csharp_out::csharp_out = Parser->finish()
-
-		if CSO {
-			send Output
-				[@CSO]
-		}
-		else {
-			send stderr
-				"failed to parse output: [Parser->error]
-		}
-	}
-end