lib.lix

#!/usr/local/bin/node ./lix.js
join := [arr]->{ arr .join "" }

map := [arr cb]->{
	ret := []
	arr foreach [i index]->{
		ret .push (i cb index)
	}
	ret
}

counterGenerator := []->{
	counter := 0
	[]->{
		ret := counter
		counter = counter + 1
		ret
	}
}

getCount := counterGenerator call

getUniqVarName := []->{ '_uniq_var_' + (getCount call) }

generateFuncArgs := [args env ctx]->{
	args map [i]->{
		varname := i.0
		env.(varname) = true
		varname
	} | .join ', '
}

ctx0 := [x]->{x}

generateSeq := [expr env ctx]->{
	last := expr.(0).length - 1
	seqCtx := [index]->{
		if (index < last) {
			ctx0
		} else {
			ctx
		}
	}
	expr.0 map [item index]->{
		item generate env (index seqCtx)
	} | .join ";\n" | + ";\n"
}

generateOr := [expr env ctx]->{
	['(' (expr.0 generate env ctx0) " || " (expr.2 generate env ctx0) ')'] | join | ctx
}

generateAnd := [expr env ctx]->{
	['(' (expr.0 generate env ctx0) " && " (expr.2 generate env ctx0) ')'] | join | ctx
}

generateIf := [expr env ctx]->{
	expr.0 map [i]->{
		if (i.1 == 'else') {
			['{\n' (i.0 generate env ctx) '\n}'] join
		} (i.1 == 'if') {
			(i generateIf env ctx)
		} else {
			[ 'if (' (i.0 generate env ctx0) ') {\n'
					(i.1 generate env ctx)
				'\n}'
			] join
		}
	} | .join ' else '
}

operateFuncName := {
	."+" 				'__add__'
	."-" 				'__sub__'
	."*" 				'__mul__'
	."/" 				'__div__'
	."%" 				'__mod__'
	.">=" 			'__ge__'
	.">" 				'__gt__'
	."==" 			'__eq__'
	."!=" 			'__ne__'
	."<" 				'__lt__'
	."<=" 			'__le__'
}

generateAtomic := [expr env ctx]->{
	ret := expr.0
	if (expr.2 == '{var}') {
		if (operateFuncName.(expr.0)) {
			ret = operateFuncName.(expr.0)
		} else {
			ret = expr.0 transformVarName
		}
	}
	ret ctx
}

generatePropertyName := [expr env ctx]->{
	if (expr.1 == '{atomic}') {
		expr generateAtomic env ctx0 | ctx
	} (expr.1 == '{index}') {
		expr.0 generateAtomic env ctx0 | ctx
	}
}

generateProperty := [expr env ctx]->{
	propertyName := expr.0 generatePropertyName env ctx0
	propertyValue := expr.2 generate env ctx0
	[propertyName ": " propertyValue] | join
}

generateObjectLiteral := [expr env ctx]->{
	objectBody := expr.0 map [i]->{
		(i generateProperty env ctx0)
	} | .join ",\n"
	["{\n" objectBody "\n}"] | join | ctx
}

transformVarName := [name]->{ name }

getVarName := [expr]->{
	if (expr.1 == '{atomic}') {
		expr generateAtomic {} ctx0
	} (expr.1 == '{.}') {
		expr.0 getVarName
	}
}

generateField := [expr env ctx]->{
	if (expr.1 == '{atomic}') {
		'.' + (expr generateAtomic env ctx0)
	} (expr.1 == '{index}') {
		['[' (expr.0 generate env ctx0) ']'] join
	}
}


generateFieldAccess := [expr env ctx]->{
	if (expr.1 == '{atomic}') {
		expr generateAtomic env ctx0 | ctx
	} (expr.1 == '{.}') {
		obj := (expr.0 generateFieldAccess env ctx0)
		field := (expr.2 generateField env ctx0)
		obj + field | ctx
	}
}

generateArray := [expr env ctx]->{
	arrayBody := expr.0 map [i]->{
		(i generate env ctx0)
	} | .join ', '
	['[' arrayBody ']'] | join | ctx
}

generateMethod := [expr env ctx]->{
	localVarName := getUniqVarName call
	localValueName := getUniqVarName call
	method := localVarName + (expr.0 generateField env ctx0)
	tmpVar := (getUniqVarName call)
	["(function () {"
		'var ' tmpVar ' = function (' localVarName ", " localValueName ") {\n"
			"if (typeof " method " === 'function') {\n"
				"arguments = Array.prototype.slice.call("
					"arguments, (" method ".__lix_func__ ? 0 : 1), arguments.length);"
				"return " method ".apply(" localVarName ", arguments);\n"
			"} else if (" method " !== undefined) {\n"
				"if (" localValueName " === undefined) {\n"
					"return " method ';\n'
				"}\n"
				method " = " localValueName ";\n"
			"}"
			"return " localVarName ';\n'
		'};'
		tmpVar '.__lix_func__ = true;'
		'return ' tmpVar ';'
	'})()'] | join | ctx
}


generateWhile := [expr env ctx]->{
	['while (' (expr.0 generate env ctx0) ') {\n'
			(expr.2 generate env ctx0)
		"}\n"
		('null' ctx)] join
}

generateBreak := [expr env ctx]->{
	'break'
}

generateEmpty := [expr env ctx]->{
	0 ctx
}

generateDef := [expr env ctx]->{
	varname := expr.(0).(0)
	ret := [
		'var ' varname ' = ' (expr.2 generate env ctx0) ";\n"
		(varname ctx)
	] | join
	env.(varname) = true
	ret
}

generateAssign := [expr env ctx]->{
	varname := expr.0 getVarName
	if (env.(varname) == undefined) {
		varname console.log
		"var undefined" console.log
	}

	["("
			(expr.0 generate env ctx0) " = " (expr.2 generate env ctx0)
	")"] | join | ctx
}

generateFunc := [expr env ctx]->{
	funcEnv := env env_new
	args := expr.0 generateFuncArgs funcEnv ctx0
	body := expr.2 generate funcEnv [v]->{
		'return ' + v
	}
	tmpVar := (getUniqVarName call)
	['(function () {'
		'var ' tmpVar ' = function (' args ') {' body '};'
		tmpVar '.__lix_func__ = true;'
		'return ' tmpVar ';'
	'})()'] | join | ctx
}

generateExpr := [expr env ctx]->{
	func := (expr.1 generate env ctx0)
	args := (expr.0 generate env ctx0)
	expr foreach [item index]->{
		if (index > 1) {
			args = [args ', ' (item generate env ctx0)] join
		}
	}
	[func '(' args ')'] | join | ctx
}

generateStart := [expr env ctx]->{
	expr.0 generate env ctx
}

generateMono := [expr env ctx]->{
	expr.0 generate env ctx
}

generatePathItem := [expr env ctx]->{
	['"' expr.0 '"'] | join | ctx
}

generatePathArgItem := [expr env ctx]->{
	['("' expr.2 '" + ' (expr.0 generate env ctx0) ')'] | join | ctx
}

generatePath := [expr env ctx]->{
	path := expr.0 map [i]->{
		i generate env ctx0
	} | .join ','
	['[' path '].join("/")'] | join | ctx
}

generateOpTable := {
	.'{start}' 							generateStart
	.'{seq}' 								generateSeq
	.'{mono}' 							generateMono
	.'{atomic}'							generateAtomic
	.'{.}' 									generateFieldAccess
	.'{func}' 							generateFunc
	.'{array}' 							generateArray
	.'{object}' 						generateObjectLiteral
	.'{method}' 						generateMethod
	.'{empty}' 							generateEmpty
	.'{path}' 							generatePath
	.'{path_item}' 					generatePathItem
	.'{path_arg_item}'			generatePathArgItem
	.':='										generateDef
	.'=' 										generateAssign
	.'if'										generateIf
	.'and'									generateAnd
	.'or' 									generateOr
	.'while'								generateWhile
	.'break' 								generateBreak
}

generateOp := [hint]->{
	if (generateOpTable.(hint)) {
		generateOpTable.(hint)
	} else {
		generateExpr
	}
}

generate := [expr env ctx]->{
	expr (expr.1 generateOp) env ctx
}

env0 := {
	.exports 				true
	.require 				true
	.print 					"function print(x) {\n return console.log(x); \n}"
	.print 					"function print(x) {\n return console.log(x); \n}"
	.not 						"function not(x) {\n return !x;\n}"
	._instance_ 		"function _instance_(x) {\n return new x(); \n}"
	.__add__ 				"function __add__(x, y) {\n return x + y;\n}"
	.__sub__ 				"function __sub__(x, y) {\n return x - y;\n}"
	.__mul__ 				"function __mul__(x, y) {\n return x * y;\n}"
	.__div__ 				"function __div__(x, y) {\n return x / y;\n}"
	.__mod__ 				"function __mod__(x, y) {\n return x % y;\n}"
	.__gt__ 				"function __gt__(x, y) {\n return x > y;\n}"
	.__ge__ 				"function __ge__(x, y) {\n return x >= y;\n}"
	.__eq__ 				"function __eq__(x, y) {\n return x == y;\n}"
	.__ne__ 				"function __ne__(x, y) {\n return x != y;\n}"
	.__le__ 				"function __le__(x, y) {\n return x <= y;\n}"
	.__lt__ 				"function __lt__(x, y) {\n return x < y;\n}"
	.AND 						"function AND(x, y) {\n return x & y;\n}"
	.OR 						"function AND(x, y) {\n return x | y;\n}"
	.XOR 						"function AND(x, y) {\n return x ^ y;\n}"
	.isFunction 		"function isFunction(x) {\n return typeof x === 'function';\n}"
	.isArray 				"function isArray(x) {\n return x instanceof Array;\n}"
	.foreach 				"function foreach(arr, cb) {\n for (var i in arr) { cb(arr[i], i); };\n}"
	.call 					"function call(fn) {\n var collect = []; for (var i in arguments) { collect.push(arguments[i]); }; collect.shift(); return fn.apply(fn, collect); \n}"
	.apply 					"function apply(fn) {\n return fn.apply(fn, arguments[1]); \n}"
}

env_new := [env]->{
	env = env or env0
	Env := []->{}
	Env.prototype = env
	Env _instance_
}

flattenExpr := [expr define]->{
	expr map [item]->{
		item flatten define
	} | define
}

flattenBreak := [expr define]->{
	expr
}

flattenWhile := [expr define]->{
		whileDefine := statementFlattenGenerator call
		expr.0 = expr.0 flatten whileDefine
		expr.2 = expr.2 flatten define0
		expr.(2).(0) = expr.(2).(0) .concat (whileDefine call)

		whileDefine call | foreach [i]->{
			i define true
		}
		expr
}

flattenOr := [expr define]->{
	ret := expr.0 flatten define
	if (ret.2 != 'var') {
		ret := ret define
	}
	getAndOpSeq := []->{
		AndDefine := statementFlattenGenerator call
		seqRet := expr.2 flatten AndDefine
		seq := (AndDefine call)
		seq .push [ret '=' seqRet]
		[seq '{seq}']
	}
	[[[[ret ['not' '{atomic}' 'var']] (getAndOpSeq call)]] 'if'] define true
	ret
}

flattenAnd := [expr define]->{
	ret := expr.0 flatten define
	if (ret.2 != 'var') {
		ret := ret define
	}
	getAndOpSeq := []->{
		AndDefine := statementFlattenGenerator call
		seqRet := expr.2 flatten AndDefine
		seq := (AndDefine call)
		seq .push [ret '=' seqRet]
		[seq '{seq}']
	}
	[[[ret (getAndOpSeq call)]] 'if'] define true
	ret
}

_flattenIf := [expr define tmpVar ctx]->{
	expr.0 foreach [i]->{
		if (i.1 == 'else') {
			elseSeq := i.0 flatten define0 ctx
			[[[tmpVar elseSeq]] 'if'] define true
		} (i.1 == 'if') {
			i _flattenIf define tmpVar ctx | define
		} else {
			ifSeq := i.1 flatten define0 ctx
			ifSeq.0 .unshift [tmpVar '=' ['false' '{atomic}']]
			cond := i.0 flatten define
			cond := [tmpVar 'and' cond]
			[[[cond ifSeq]] 'if'] define true
		}
	}
}

flattenIf := [expr define]->{
	tmpVar := ['true' '{atomic}'] define
	retVar := ['null' '{atomic}'] define
	ctx := [i]->{
		[retVar '=' i]
	}
	expr _flattenIf define tmpVar ctx
	retVar
}

flattenAssign := [expr define]->{
	expr.2 = expr.2 flatten define
	expr
}

flattenDef := [expr define]->{
	expr.2 = expr.2 flatten define
	expr define true
	expr.0
}

flattenPathArgItem := [expr define]->{
	expr.0 = expr.0 flatten define
	expr
}

flattenPathItem := [expr define]->{
	expr
}

flattenPath := [expr define]->{
	expr.0 = expr.0 map [i]->{
		i flatten define
	}
	expr
}

flattenEmpty := [expr define]->{
	expr
}

flattenField := [expr define]->{
	if (expr.1 == '{index}') {
		expr.0 = expr.0 flatten define
	}
	expr
}

flattenMethod := [expr define]->{
	expr.0 = expr.0 flattenField define
	expr
}

flattenProperty := [expr define]->{
	expr.2 = expr.2 flatten define
	expr
}

flattenObjectLiteral := [expr define]->{
	expr.0 = expr.0 map [i]->{
		i flattenProperty define
	}
	expr
}

flattenArray := [expr define]->{
	expr.0 = expr.0 map [i]->{
		i flatten define
	}
	expr
}

flattenFunc := [expr define]->{
	expr.2 = expr.2 flatten define
	expr
}

flattenFieldAccess := [expr define]->{
	if (expr.1 == '{.}') {
		expr.0 = expr.0 flattenFieldAccess define
		expr.2 = expr.2 flattenField define
	}
	expr
}

flattenAtomic := [expr define]->{
	expr
}

flattenMono := [expr define]->{
	expr.0 flatten define
}

statementFlattenGenerator := []->{
	data := []
	[statement onlyPush]->{
		if (statement == undefined) {
			data
		} (onlyPush) {
			data .push statement 
		} else {
			varName := getUniqVarName call
			lixVar := [varName '{atomic}' '{var}']
			data .push [lixVar ':=' statement] 
			lixVar
		}
	}
}

flattenSeq := [expr define seqCtx]->{
	ret := []
	ctx := [stmt index]->{
		ret := stmt
		if (seqCtx and ((index parseInt) == (expr.(0).length - 1))) {
			ret := stmt seqCtx
		}
		ret
	}
	expr.0 foreach [item index]->{
		exprDefine := statementFlattenGenerator call
		itemRet := item flatten exprDefine
		ret = ret .concat (exprDefine call)
		ret .push (itemRet ctx index)
	}
	expr.0 = ret
	expr
}

flattenStart := [expr define]->{
	ret := expr.0 flatten define
	[ret '{start}']
}

flattenOpTable := {
	.'{start}' 							flattenStart
	.'{seq}' 								flattenSeq
	.'{mono}' 							flattenMono
	.'{atomic}'							flattenAtomic
	.'{.}' 									flattenFieldAccess
	.'{func}' 							flattenFunc
	.'{array}' 							flattenArray
	.'{object}' 						flattenObjectLiteral
	.'{method}' 						flattenMethod
	.'{empty}' 							flattenEmpty
	.'{path}' 							flattenPath
	.'{path_item}' 					flattenPathItem
	.'{path_arg_item}'			flattenPathArgItem
	.':='										flattenDef
	.'=' 										flattenAssign
	.'if'										flattenIf
	.'and'									flattenAnd
	.'or' 									flattenOr
	.'while'								flattenWhile
	.'break' 								flattenBreak
}

flattenOp := [hint]->{
	if (flattenOpTable.(hint)) {
		flattenOpTable.(hint)
	} else {
		flattenExpr
	}
}

flatten := [expr define ctx]->{
	expr (expr.1 flattenOp) define ctx
}

define0 := [i]->{i}

exports.compile = [expr]->{
	libs := env0 | map [i]->{i} | .join "\n"
	code := expr | flatten [i]->{} | generate (env_new call) ctx0
	[libs "\n" code] join | console.log
}