replced bare send syntax whith << and <- formsno-bare-send

6 files changed, 191 insertions, 185 deletions

diff --git a/cgil/rlhc-c.lm b/cgil/rlhc-c.lm
index 0a2b6d97..dfc24d1d 100644
--- a/cgil/rlhc-c.lm
+++ b/cgil/rlhc-c.lm
@@ -55,19 +55,19 @@ namespace c_gen
 		for Tok: host::tok in repeat(TL) {
 			switch Tok
 			case Stmt {
-				"{
-				"	[stmt_list( StmtList )]
-				"}
+				<<	"{
+					"	[stmt_list( StmtList )]
+					"}
 			}
 			case Expr {
-				"([expr( Expr )])"
+				<<	"([expr( Expr )])"
 			}
 			case Escape {
 				Str: str = $escape
-				"[Str.suffix( 1 )]"
+				<<	"[Str.suffix( 1 )]"
 			}
 			default {
-				[Tok]
+				<<	[Tok]
 			}
 		}
 	}
@@ -77,17 +77,17 @@ namespace c_gen
 		switch EmbeddedHost
 		case Expr
 		{
-			"([tok_list( TL )])"
+			<<	"([tok_list( TL )])"
 		}
 		case Stmt
 		{
-			"{
-			"	[tok_list( TL )]
-			"}
+			<<	"{
+				"	[tok_list( TL )]
+				"}
 		}
 		case Bare
 		{
-			[tok_list( TL )]
+			<<	[tok_list( TL )]
 		}
 	}
 
@@ -96,39 +96,39 @@ namespace c_gen
 		switch ExprFactor
 		case [EH: embedded_host]
 		{
-			[embedded_host( EH )]
+			<<	[embedded_host( EH )]
 		}
 		case Paren
 		{
-			"([expr( expr )])"
+			<<	"([expr( expr )])"
 		}
 		case ArraySub
 		{
-			"[ident]\[[expr( expr )]\]"
+			<<	"[ident]\[[expr( expr )]\]"
 		}
 		case ArraySubField
 		{
-			"[ident]\[[expr( expr )]\].[Field]"
+			<<	"[ident]\[[expr( expr )]\].[Field]"
 		}
 		case Offset
 		{
-			"[ident] + [expr( expr )]"
+			<<	"[ident] + [expr( expr )]"
 		}
 		case Deref
 		{
-			"(*( [expr(expr)] ))
+			<<	"(*( [expr(expr)] ))
 		}
 		case [`TRUE]
 		{
-			"1"
+			<<	"1"
 		}
 		case [`FALSE]
 		{
-			"1"
+			<<	"1"
 		}
 		case [N: `nil]
 		{
-			"0"
+			<<	"0"
 		}
 		case [Number: number]
 		{
@@ -142,11 +142,11 @@ namespace c_gen
 		}
 		case [`cast `( T: type `) F: expr_factor]
 		{
-			"( [type( T )] ) [expr_factor( F )]"
+			<<	"( [type( T )] ) [expr_factor( F )]"
 		}
 		default {
 			# Catches cases not specified
-			[ExprFactor]
+			<<	[ExprFactor]
 		}
 	}
 
@@ -155,15 +155,15 @@ namespace c_gen
 		switch ExprFactor
 		case [EH: embedded_host]
 		{
-			[embedded_host( EH )]
+			<<	[embedded_host( EH )]
 		}
 		case [ident O: `[ TL: expr C: `]]
 		{
-			[ident O expr( TL ) C]
+			<<	[ident O expr( TL ) C]
 		}
 		case [I: ident `[ E: expr `] `. F: ident]
 		{
-			"[I]\[[ expr( E )]\].[F]
+			<<	"[I]\[[ expr( E )]\].[F]
 		}
 		case [E1: embedded_host `-> E2: lvalue]
 		{
@@ -173,7 +173,7 @@ namespace c_gen
 		}
 		default {
 			# Catches cases not specified
-			[ExprFactor]
+			<<	[ExprFactor]
 		}
 	}
 
@@ -182,15 +182,15 @@ namespace c_gen
 		switch ExprFactorOp
 		case [B: `! expr_factor_op]
 		{
-			['!' expr_factor_op( _expr_factor_op )]
+			<<	['!' expr_factor_op( _expr_factor_op )]
 		}
 		case [T: `~ expr_factor_op]
 		{
-			['~' expr_factor_op( _expr_factor_op )]
+			<<	['~' expr_factor_op( _expr_factor_op )]
 		}
 		case [expr_factor]
 		{
-			[expr_factor( expr_factor )]
+			<<	[expr_factor( expr_factor )]
 		}
 	}
 
@@ -199,11 +199,11 @@ namespace c_gen
 		switch ExprBitwise
 		case [expr_bitwise A: `& expr_factor_op]
 		{
-			[expr_bitwise( _expr_bitwise ) A expr_factor_op( expr_factor_op )]
+			<<	[expr_bitwise( _expr_bitwise ) A expr_factor_op( expr_factor_op )]
 		}
 		case [expr_factor_op]
 		{
-			[expr_factor_op( expr_factor_op )]
+			<<	[expr_factor_op( expr_factor_op )]
 		}
 	}
 
@@ -212,11 +212,11 @@ namespace c_gen
 		switch ExprMult
 		case [expr_mult T: `* expr_bitwise]
 		{
-			[expr_mult( _expr_mult ) T expr_bitwise( expr_bitwise )]
+			<<	[expr_mult( _expr_mult ) T expr_bitwise( expr_bitwise )]
 		}
 		case [expr_bitwise]
 		{
-			[expr_bitwise( expr_bitwise )]
+			<<	[expr_bitwise( expr_bitwise )]
 		}
 	}
 
@@ -225,11 +225,11 @@ namespace c_gen
 		switch ExprAdd
 		case [expr_add Op: add_op expr_mult]
 		{
-			[expr_add( _expr_add ) Op expr_mult( expr_mult )]
+			<<	[expr_add( _expr_add ) Op expr_mult( expr_mult )]
 		}
 		case [expr_mult]
 		{
-			[expr_mult( expr_mult )]
+			<<	[expr_mult( expr_mult )]
 		}
 	}
 
@@ -238,11 +238,11 @@ namespace c_gen
 		switch ExprShift
 		case [expr_shift Op: shift_op expr_add]
 		{
-			[expr_shift( _expr_shift ) Op expr_add( expr_add )]
+			<<	[expr_shift( _expr_shift ) Op expr_add( expr_add )]
 		}
 		case [expr_add]
 		{
-			[expr_add( expr_add )]
+			<<	[expr_add( expr_add )]
 		}
 	}
 
@@ -251,11 +251,11 @@ namespace c_gen
 		switch ExprTest
 		case [expr_test Op: test_op expr_shift]
 		{
-			[expr_test( _expr_test ) Op expr_shift( expr_shift )]
+			<<	[expr_test( _expr_test ) Op expr_shift( expr_shift )]
 		}
 		case [expr_shift]
 		{
-			[expr_shift( expr_shift )]
+			<<	[expr_shift( expr_shift )]
 		}
 	}
 
@@ -268,34 +268,34 @@ namespace c_gen
 	{
 		switch Type
 		case S8
-			['signed char ']
+			<<	['signed char ']
 		case S16
-			['short ']
+			<<	['short ']
 		case S32
-			['int ']
+			<<	['int ']
 		case S64
-			['long ']
+			<<	['long ']
 		case S128
-			['long long ']
+			<<	['long long ']
 		case "uint"
-			['unsigned int ']
+			<<	['unsigned int ']
 		default
-			[Type]
+			<<	[Type]
 	}
 
 	void number( Number: number )
 	{
 		switch Number
 		case Unsigned
-			"[uint]u"
+			<<	"[uint]u"
 		default
-			[Number]
+			<<	[Number]
 	}
 
 	void num_list( NumList: num_list )
 	{
 		for Number: number in NumList
-			"[number( Number )], "
+			<<	"[number( Number )], "
 	}
 
 	void stmt( Stmt: stmt )
@@ -303,14 +303,14 @@ namespace c_gen
 		switch Stmt
 		case [EH: embedded_host]
 		{
-			[embedded_host( EH )]
+			<<	[embedded_host( EH )]
 		}
 		case [A: static_array] {
-			"static const [type(A.type)] "
+			<<	"static const [type(A.type)] "
 				"[A.ident] \[\] = { [num_list(A.num_list)] };
 		}
 		case [V: static_value] {
-			"static const [V.type] [V.ident] = [V.number];
+			<<	"static const [V.type] [V.ident] = [V.number];
 		}
 		case [
 				`if `( IfExpr: expr `)
@@ -318,72 +318,72 @@ namespace c_gen
 				ElseIfClauseList: else_if_clause*
 				ElseClauseOpt: else_clause?
 		] {
-			"if ( [expr(IfExpr)] )
-			"	[stmt(IfStmt)]
+			<<	"if ( [expr(IfExpr)] )
+			<<	"	[stmt(IfStmt)]
 
 			for ElseIfClause: else_if_clause in repeat( ElseIfClauseList ) {
 				match ElseIfClause
 					[`else `if `( ElseIfExpr: expr `) ElseIfStmt: stmt]
 
-				"else if ( [expr(ElseIfExpr)] )
-				"	[stmt(ElseIfStmt)]
+				<<	"else if ( [expr(ElseIfExpr)] )
+					"	[stmt(ElseIfStmt)]
 			}
 
 			if ( match ElseClauseOpt ['else' ElseStmt: stmt] ) {
-				"else
-				"	[stmt(ElseStmt)]
+				<<	"else
+				<<	"	[stmt(ElseStmt)]
 			}
 		}
 		case [`while `( WhileExpr: expr `) WhileStmt: stmt] {
-			"while ( [expr(WhileExpr)] )
-			"	[stmt(WhileStmt)]
+			<<	"while ( [expr(WhileExpr)] )
+				"	[stmt(WhileStmt)]
 		}
 		case [M: match_stmt] {
-			"switch ( [expr(M.E)] ) {
+			<<	"switch ( [expr(M.E)] ) {
 
 			for PB: pat_block in repeat( M.P ) {
-				"case [expr( PB.expr )]:
-				"[stmt_list( PB._repeat_stmt )]
-				"break;
+				<<	"case [expr( PB.expr )]:
+					"[stmt_list( PB._repeat_stmt )]
+					"break;
 			}
 
 			if match M.D [D: default_block] {
-				"default:
-				"[stmt_list( D._repeat_stmt )]
-				"break;
+				<<	"default:
+					"[stmt_list( D._repeat_stmt )]
+					"break;
 			}
 
-			"}
+			<<	"}
 		}
 		case [`switch `( SwitchExpr: expr `) `{ StmtList: stmt* `}] {
-			"switch ( [expr(SwitchExpr)] ) {
-			"	[stmt_list(StmtList)]
-			"}
+			<<	"switch ( [expr(SwitchExpr)] ) {
+				"	[stmt_list(StmtList)]
+				"}
 		}
 		case [ES: expr_stmt] {
-			"[expr(ES.expr)];
+			<<	"[expr(ES.expr)];
 		}
 		case [B: block] {
-			"{
-			"	[stmt_list(B.StmtList)]
-			"}
+			<<	"{
+				"	[stmt_list(B.StmtList)]
+				"}
 		}
 		case [
 			OptConst: opt_const Type: type 
 			Ident: ident OptInit: opt_init Semi: `;
 		]
 		{
-			"[OptConst] [type(Type)] [Ident]"
+			<<	"[OptConst] [type(Type)] [Ident]"
 
 			if match OptInit [`= Init: expr] {
-				" = [expr(Init)]
+				<<	" = [expr(Init)]
 			}
 
-			";
+			<<	";
 		}
 		case [Export: export_stmt]
 		{
-			"#define [Export.ident] [number(Export.number)] 
+			<<	"#define [Export.ident] [number(Export.number)] 
 		}
 		case [fallthrough]
 		{
@@ -392,37 +392,37 @@ namespace c_gen
 		}
 		case [Index: index_stmt]
 		{
-			"const [type(Index.type)] *[Index.ident]
+			<<	"const [type(Index.type)] *[Index.ident]
 
 			if match Index.opt_init [E: `= expr] {
-				[E expr(Index.opt_init.expr)]
+				<<	[E expr(Index.opt_init.expr)]
 			}
 
-			";
+			<<	";
 		}
 		case [CB: case_block]
 		{
-			"case [expr( CB.expr )]:
-			"[stmt_list( CB._repeat_stmt )]
-			"break;
+			<<	"case [expr( CB.expr )]:
+				"[stmt_list( CB._repeat_stmt )]
+				"break;
 		}
 		case [DB: default_block]
 		{
-			"default:
-			"[stmt_list( DB._repeat_stmt )]
-			"break;
+			<<	"default:
+				"[stmt_list( DB._repeat_stmt )]
+				"break;
 		}
 		case [CL: case_label]
 		{
-			"case [expr( CL.expr )]:
+			<<	"case [expr( CL.expr )]:
 		}
 		case [AS: assign_stmt]
 		{
-			"[lvalue(AS.LValue) AS.assign_op expr(AS.expr)];
+			<<	"[lvalue(AS.LValue) AS.assign_op expr(AS.expr)];
 		}
 		default {
 			# catches unspecified cases
-			[Stmt]
+			<<	[Stmt]
 		}
 	}
 
diff --git a/cgil/rlhc-go.lm b/cgil/rlhc-go.lm
index 21aa1cee..b8353d10 100644
--- a/cgil/rlhc-go.lm
+++ b/cgil/rlhc-go.lm
@@ -57,19 +57,19 @@ namespace go_gen
 		for Tok: host::tok in repeat(TL) {
 			switch Tok
 			case Stmt {
-				"{
-					stmt_list( StmtList )
-				"}
+				<<	"{
+					"	[stmt_list( StmtList )]
+					"}
 			}
 			case Expr {
-				"([expr( Expr )])"
+				<<	"([expr( Expr )])"
 			}
 			case Escape {
 				Str: str = $Tok
-				"[Str.suffix( 1 )]"
+				<<	"[Str.suffix( 1 )]"
 			}
 			default {
-				[Tok]
+				<<	[Tok]
 			}
 		}
 	}
@@ -79,15 +79,15 @@ namespace go_gen
 		switch EmbeddedHost
 		case Expr
 		{
-			['(' tok_list( TL ) ')']
+			<<	['(' tok_list( TL ) ')']
 		}
 		case Stmt
 		{
-			['{' tok_list( TL ) '}\n']
+			<<	['{' tok_list( TL ) '}\n']
 		}
 		case Bare
 		{
-			[tok_list( TL )]
+			<<	[tok_list( TL )]
 		}
 	}
 
@@ -96,35 +96,35 @@ namespace go_gen
 		switch ExprFactor
 		case EmbeddedHost
 		{
-			[embedded_host(embedded_host)]
+			<<	[embedded_host(embedded_host)]
 		}
 		case Paren
 		{
-			['( ' expr(expr) ' )']
+			<<	['( ' expr(expr) ' )']
 		}
 		case ArraySub
 		{
-			[ident '[ ' expr( expr ) ' ]']
+			<<	[ident '[ ' expr( expr ) ' ]']
 		}
 		case Offset
 		{
-			"int([expr(expr )])
+			<<	"int([expr(expr )])
 		}
 		case Deref
 		{
-			[ident '[ ' expr( expr ) ' ]' ]
+			<<	[ident '[ ' expr( expr ) ' ]' ]
 		}
 		case True
 		{
-			"true"
+			<<	"true"
 		}
 		case False
 		{
-			"false"
+			<<	"false"
 		}
 		case Nil
 		{
-			"0"
+			<<	"0"
 		}
 		case Access
 		{
@@ -133,11 +133,11 @@ namespace go_gen
 		}
 		case Cast
 		{
-			[type(type) '( ' expr_factor(_expr_factor) ' )' ]
+			<<	[type(type) '( ' expr_factor(_expr_factor) ' )' ]
 		}
 		default {
 			# Catches cases not specified
-			[ExprFactor]
+			<<	[ExprFactor]
 		}
 	}
 
@@ -146,11 +146,11 @@ namespace go_gen
 		switch ExprFactor
 		case [EH: embedded_host]
 		{
-			[embedded_host(EH)]
+			<<	[embedded_host(EH)]
 		}
 		case [ident `[ TL: expr `]]
 		{
-			[ident '[' expr( TL ) ']']
+			<<	[ident '[' expr( TL ) ']']
 		}
 		case [E1: embedded_host `-> E2: lvalue]
 		{
@@ -159,7 +159,7 @@ namespace go_gen
 		}
 		default {
 			# Catches cases not specified
-			[ExprFactor]
+			<<	[ExprFactor]
 		}
 	}
 
@@ -168,15 +168,15 @@ namespace go_gen
 		switch ExprFactorOp
 		case [B: `! expr_factor_op]
 		{
-			['! ' expr_factor_op( _expr_factor_op )]
+			<<	['! ' expr_factor_op( _expr_factor_op )]
 		}
 		case [T: `~ expr_factor_op]
 		{
-			['^ ' expr_factor_op( _expr_factor_op )]
+			<<	['^ ' expr_factor_op( _expr_factor_op )]
 		}
 		case [expr_factor]
 		{
-			[expr_factor( ExprFactorOp.expr_factor )]
+			<<	[expr_factor( ExprFactorOp.expr_factor )]
 		}
 	}
 
@@ -185,11 +185,11 @@ namespace go_gen
 		switch ExprBitwise
 		case [expr_bitwise A: `& expr_factor_op]
 		{
-			[expr_bitwise( _expr_bitwise ) ' & ' expr_factor_op( expr_factor_op )]
+			<<	[expr_bitwise( _expr_bitwise ) ' & ' expr_factor_op( expr_factor_op )]
 		}
 		case [expr_factor_op]
 		{
-			[expr_factor_op( ExprBitwise.expr_factor_op )]
+			<<	[expr_factor_op( ExprBitwise.expr_factor_op )]
 		}
 	}
 
@@ -198,11 +198,11 @@ namespace go_gen
 		switch ExprMult
 		case [expr_mult T: `* expr_bitwise]
 		{
-			[expr_mult( _expr_mult ) ' * ' expr_bitwise( expr_bitwise )]
+			<<	[expr_mult( _expr_mult ) ' * ' expr_bitwise( expr_bitwise )]
 		}
 		case [expr_bitwise]
 		{
-			[expr_bitwise( expr_bitwise )]
+			<<	[expr_bitwise( expr_bitwise )]
 		}
 	}
 
@@ -211,11 +211,11 @@ namespace go_gen
 		switch ExprAdd
 		case [expr_add Op: add_op expr_mult]
 		{
-			[expr_add( _expr_add ) ' ' Op ' ' expr_mult( expr_mult )]
+			<<	[expr_add( _expr_add ) ' ' Op ' ' expr_mult( expr_mult )]
 		}
 		case [expr_mult]
 		{
-			[expr_mult( ExprAdd.expr_mult )]
+			<<	[expr_mult( ExprAdd.expr_mult )]
 		}
 	}
 
@@ -224,11 +224,11 @@ namespace go_gen
 		switch ExprShift
 		case [expr_shift Op: shift_op expr_add]
 		{
-			[expr_shift( _expr_shift ) ' ' Op ' ' expr_add( expr_add )]
+			<<	[expr_shift( _expr_shift ) ' ' Op ' ' expr_add( expr_add )]
 		}
 		case [expr_add]
 		{
-			[expr_add( expr_add )]
+			<<	[expr_add( expr_add )]
 		}
 	}
 
@@ -237,11 +237,11 @@ namespace go_gen
 		switch ExprTest
 		case [expr_test Op: test_op expr_shift]
 		{
-			[expr_test( _expr_test ) ' ' Op ' ' expr_shift( expr_shift )]
+			<<	[expr_test( _expr_test ) ' ' Op ' ' expr_shift( expr_shift )]
 		}
 		case [expr_shift]
 		{
-			[expr_shift( ExprTest.expr_shift )]
+			<<	[expr_shift( ExprTest.expr_shift )]
 		}
 	}
 
@@ -254,33 +254,33 @@ namespace go_gen
 	{
 		switch Type
 		case S8
-			['int8']
+			<<	['int8']
 		case S16
-			['int16']
+			<<	['int16']
 		case S32
-			['int32']
+			<<	['int32']
 		case S64
-			['int64']
+			<<	['int64']
 		case S128
-			['long long']
+			<<	['long long']
 		default
-			[Type]
+			<<	[Type]
 	}
 
 	void number( Number: number )
 	{
 		switch Number
 		case Unsigned
-			[uint]
+			<<	[uint]
 		default
-			[Number]
+			<<	[Number]
 	}
 
 	void num_list( NumList: num_list )
 	{
 		number( NumList.number )
 		for CommaNum: comma_num in NumList {
-			[', ' number( CommaNum.number )]
+			<<	[', ' number( CommaNum.number )]
 		}
 	}
 
@@ -299,118 +299,119 @@ namespace go_gen
 		switch Stmt
 		case [EH: embedded_host]
 		{
-			[embedded_host(EH)]
+			<<	[embedded_host(EH)]
 		}
 		case [A: static_array] {
-			"var [A.ident] = \[\] "
+			<<	"var [A.ident] = \[\] "
 				"[type(A.type)] { [num_list(A.num_list)] }
 		}
 		case [V: static_value] {
-			"var [V.ident] [type(V.type)] = [V.number]
-			"var _ = [V.ident]
+			<<	"var [V.ident] [type(V.type)] = [V.number]
+				"var _ = [V.ident]
 		}
 		case [
 				'if' O: `( IfExpr: expr C: `) IfStmt: stmt
 		] {
 			# if-statements with only the if clause can go out as an if.
-			"if [expr(IfExpr)] {
-				strip_block_stmt(IfStmt)
-			"}
+			<<	"if [expr(IfExpr)] {
+				"	[strip_block_stmt(IfStmt)]
+				"}
 		}
 		case [
 				'if' O: `( IfExpr: expr C: `) IfStmt: stmt
 				ElseIfClauseList: else_if_clause* ElseClauseOpt: else_clause?
 		] {
 			# If the if-statement has more than just an if clause it goes out as a switch.
-			"if [expr( IfExpr )] {
-				strip_block_stmt( IfStmt )
+			<<	"if [expr( IfExpr )] {
+				"	[strip_block_stmt( IfStmt )]
 
 			for ElseIfClause: else_if_clause in repeat( ElseIfClauseList ) {
 				match ElseIfClause
 					['else if (' ElseIfExpr: expr ')' ElseIfStmt: stmt]
 
-				"} else if [expr(ElseIfExpr)] {
-					strip_block_stmt(ElseIfStmt)
+				<<	"} else if [expr(ElseIfExpr)] {
+					"	[strip_block_stmt(ElseIfStmt)]
 			}
 
 			if ( match ElseClauseOpt ['else' ElseStmt: stmt] ) {
-				"} else {
-					strip_block_stmt(ElseStmt)
+				<<	"} else {
+					"	[strip_block_stmt(ElseStmt)]
 			}
 
-			"}
+			<<	"}
 		}
 		case ["while ( TRUE )" WhileStmt: stmt] {
-			"for {
-				strip_block_stmt(WhileStmt)
-			"}
+			<<	"for {
+				"	[strip_block_stmt(WhileStmt)]
+				"}
 		}
 		case ['while' '(' WhileExpr: expr ')' WhileStmt: stmt] {
-			"for [expr(WhileExpr)] {
-				strip_block_stmt(WhileStmt)
-			"}
+			<<	"for [expr(WhileExpr)] {
+				"	[strip_block_stmt(WhileStmt)]
+				"}
 		}
 		case ['switch' '(' SwitchExpr: expr ')' '{' StmtList: stmt* '}'] {
-			"switch [expr(SwitchExpr)] {
-				stmt_list(StmtList)
-			"}
+			<<	"switch [expr(SwitchExpr)] {
+				"	[stmt_list(StmtList)]
+				"}
 		}
 		case [ExprExpr: expr `;] {
-			[expr(ExprExpr) ';']
+			<<	[expr(ExprExpr) ';']
 		}
 		case [B: block] {
-			"{
-				stmt_list(B.StmtList)
-			"}
+			<<	"{
+				"	[stmt_list(B.StmtList)]
+				"}
 		}
 		case [D: declaration]
 		{
-			"var [D.ident] [type(D.type)]"
+			<<	"var [D.ident] [type(D.type)]"
 
 			if match D.opt_init ['=' Expr: expr] {
-				"  = [expr(Expr)]"
+				<<	"  = [expr(Expr)]"
 			}
-			['\n']
+
+			<<	['\n']
 		}
 		case [ES: export_stmt]
 		{
-			"#define [ES.ident] [number(ES.number)]
+			<<	"#define [ES.ident] [number(ES.number)]
 		}
 		case [fallthrough]
 		{
-			"fallthrough
+			<<	"fallthrough
 		}
 		case [Index: index_stmt]
 		{
-			"var [Index.ident] int"
+			<<	"var [Index.ident] int"
 
 			if match Index.opt_init ['=' Expr: expr] {
-				" = [expr(Expr)]"
+				<<	" = [expr(Expr)]"
 			}
 
-			['\n']
+			<<	['\n']
 		}
 		case [CB: case_block]
 		{
-			"case [expr( CB.expr )]:
-			stmt_list( CB._repeat_stmt )
+			<<	"case [expr( CB.expr )]:
+				"	[stmt_list( CB._repeat_stmt )]
 		}
 		case [DB: default_block]
 		{
-			"default:
-			stmt_list( DB._repeat_stmt )
+			<<	"default:
+				"	[stmt_list( DB._repeat_stmt )]
 		}
 		case [CL: case_label]
 		{
-			"case [expr( CL.expr )]:
+			<<	"case [expr( CL.expr )]:
 		}
 		case [AS: assign_stmt]
 		{
-			"[lvalue(AS.LValue) AS.assign_op expr(AS.expr)];
+			<<	"[lvalue(AS.LValue) AS.assign_op expr(AS.expr)];
 		}
 		default {
 			# catches unspecified cases
-			"[Stmt]
+			<<	"[Stmt]
 		}
 	}
 
diff --git a/src/colm.lm b/src/colm.lm
index 16a9eeb5..9deb3d90 100644
--- a/src/colm.lm
+++ b/src/colm.lm
@@ -126,6 +126,8 @@ lex
 	token AMP_AMP /'&&'/
 	token BAR_BAR /'||'/
 	token DOT_DOT_DOT /'...'/
+	token LT_LT /'<<'/
+	token LARROW /'<-'/
 
 	ignore / ( '\n' | '\t' | ' ' )+ /
 	ignore / '#' . ( ^'\n' )* . '\n' /
@@ -540,6 +542,9 @@ def case_clause_list
 # to the clauses, which is is a better commit strategy anyways. Gives more
 # regular commits.
 
+def bare_tok
+	[LT_LT] | [LARROW]
+
 def statement
 	[print_stmt] :Print commit
 |	[var_def opt_def_init] :VarDef commit
@@ -555,7 +560,7 @@ def statement
 |	[REJECT] :Reject commit
 |	[var_ref POPEN call_arg_list PCLOSE] :Call
 |	[stmt_or_factor] :StmtOrFactor
-|	[accumulate opt_eos] :BareSend
+|	[bare_tok accumulate opt_eos] :BareSend
 
 def elsif_list
 	[elsif_clause elsif_list] :Clause
diff --git a/src/loadfinal.cc b/src/loadfinal.cc
index d478a446..52481bed 100644
--- a/src/loadfinal.cc
+++ b/src/loadfinal.cc
@@ -111,9 +111,9 @@ struct LoadColm
 				/* Checking if we are outdented. Indents and are ok. So is
 				 * outdenting back to the first. */
 				if ( loc->column < firstColumn ) {
-					warning( loc ) << type << " literal outdented beyond first at " <<
-							firstLine << ":" << firstColumn <<
-							", possible unintended concatenation" << std::endl;
+					// warning( loc ) << type << " literal outdented beyond first at " <<
+					//		firstLine << ":" << firstColumn <<
+					//		", possible unintended concatenation" << std::endl;
 				}
 
 				lastLine = loc->line;
diff --git a/test/colm.d/sendstream.lm b/test/colm.d/sendstream.lm
index 50edeae6..0db1cb99 100644
--- a/test/colm.d/sendstream.lm
+++ b/test/colm.d/sendstream.lm
@@ -16,14 +16,14 @@ Go: bool
 Go = true
 while ( Go ) {
 	_: parser<g> = Parser
-	"  hello friend
+	<<	"  hello friend
 	Go = false
 }
 
 Go = true
 while ( Go ) {
 	_: stream = stdout
-	"  hello friend
+	<<	"  hello friend
 	Go = false
 }
 
diff --git a/test/colm.d/stds1.lm b/test/colm.d/stds1.lm
index 64ba0f72..b1752b90 100644
--- a/test/colm.d/stds1.lm
+++ b/test/colm.d/stds1.lm
@@ -1,8 +1,8 @@
 _: stream = stdout
 
-"hello
+<<	"hello
 
-"hello
+<<	"hello
 
 ##### EXP #####
 hello