--- a/core/src/luan/impl/LuanParser.java	Tue Mar 29 13:53:01 2016 -0600
+++ b/core/src/luan/impl/LuanParser.java	Tue Mar 29 18:09:51 2016 -0600
@@ -8,8 +8,6 @@
 import java.util.Scanner;
 import luan.Luan;
 import luan.LuanState;
-import luan.LuanSource;
-import luan.LuanElement;
 import luan.LuanTable;
 import luan.modules.PackageLuan;
 
@@ -97,14 +95,14 @@
 	private static final String _ENV = "_ENV";
 	private static final UpValue.Getter[] NO_UP_VALUE_GETTERS = new UpValue.Getter[0];
 
-	final LuanSource source;
+//	final LuanSource source;
 	private Frame frame;
 	private final Parser parser;
 
-	LuanParser(LuanSource source,LuanTable env) {
-		this.source = source;
+	LuanParser(String sourceName,String sourceText,LuanTable env) {
+//		this.source = source;
 		this.frame = new Frame( env!=null ? env : new LuanTable() );
-		this.parser = new Parser(source);
+		this.parser = new Parser(sourceName,sourceText);
 		if( env != null )
 			addVar(_ENV,env);
 	}
@@ -113,14 +111,6 @@
 		frame.addUpValueGetter(name,new UpValue.ValueGetter(value));
 	}
 
-	private LuanElement se(int start) {
-		return se(start,null);
-	}
-
-	private LuanElement se(int start,String text) {
-		return new LuanElement(source,start,parser.currentIndex(),text);
-	}
-
 	private List<String> symbols() {
 		return frame.symbols;
 	}
@@ -185,7 +175,7 @@
 	}
 
 	private FnDef newFnDef(int start,Stmt stmt) {
-		return new FnDef( se(start), stmt, frame.stackSize, symbolsSize(), frame.isVarArg, frame.upValueGetters.toArray(NO_UP_VALUE_GETTERS) );
+		return new FnDef( stmt, frame.stackSize, symbolsSize(), frame.isVarArg, frame.upValueGetters.toArray(NO_UP_VALUE_GETTERS) );
 	}
 
 	FnDef Expression() throws ParseException {
@@ -193,7 +183,7 @@
 		int start = parser.begin();
 		Expressions expr = ExprZ(In.NOTHING);
 		if( expr != null && parser.endOfInput() ) {
-			Stmt stmt = new ReturnStmt( se(start), expr );
+			Stmt stmt = new ReturnStmt( expr );
 			return parser.success(newFnDef(start,stmt));
 		}
 		return parser.failure(null);
@@ -266,17 +256,14 @@
 	}
 
 	private Stmt TemplateStmt() throws ParseException {
-		int start = parser.currentIndex();
+		parser.currentIndex();
 		Expressions exprs = TemplateExpressions(In.NOTHING);
 		if( exprs == null )
 			return null;
-		LuanElement se = se(start,"require 'luan:Io'");
-		FnCall requireCall = new FnCall( se, new ConstExpr(se,PackageLuan.requireFn), new ConstExpr(se,"luan:Io") );
-		se = se(start,"stdout");
-		Expr stdoutExp = new IndexExpr( se, expr(requireCall), new ConstExpr(se,"stdout") );
-		se = se(start,"write");
-		Expr writeExp = new IndexExpr( se, stdoutExp, new ConstExpr(se,"write") );
-		FnCall writeCall = new FnCall( se(start), writeExp, exprs );
+		FnCall requireCall = new FnCall( new ConstExpr(PackageLuan.requireFn), new ConstExpr("luan:Io") );
+		Expr stdoutExp = new IndexExpr( expr(requireCall), new ConstExpr("stdout") );
+		Expr writeExp = new IndexExpr( stdoutExp, new ConstExpr("write") );
+		FnCall writeCall = new FnCall( writeExp, exprs );
 		return new ExpressionsStmt(writeCall);
 	}
 
@@ -306,19 +293,19 @@
 						throw parser.exception("Unclosed template expression");
 				} while( !parser.test( "<%" ) );
 				String match = parser.textFrom(i);
-				builder.add( new ConstExpr(se(i),match) );
+				builder.add( new ConstExpr(match) );
 			}
 		}
 	}
 
 	private Stmt ReturnStmt() throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		if( !Keyword("return",In.NOTHING) )
 			return parser.failure(null);
 		Expressions exprs = ExpList(In.NOTHING);
 		if( exprs==null )
 			exprs = ExpList.emptyExpList;
-		return parser.success( new ReturnStmt(se(start),exprs) );
+		return parser.success( new ReturnStmt(exprs) );
 	}
 
 	private Stmt FunctionStmt() throws ParseException {
@@ -326,14 +313,14 @@
 		if( !Keyword("function",In.NOTHING) )
 			return parser.failure(null);
 
-		int start = parser.currentIndex();
-		Var var = nameVar(start,RequiredName(In.NOTHING));
+		parser.currentIndex();
+		Var var = nameVar(RequiredName(In.NOTHING));
 		while( parser.match( '.' ) ) {
 			Spaces(In.NOTHING);
 			Expr exp = NameExpr(In.NOTHING);
 			if( exp==null )
 				return parser.failure(null);
-			var = indexVar( start, expr(var.expr()), exp );
+			var = indexVar( expr(var.expr()), exp );
 		}
 		Settable fnName = var.settable();
 
@@ -361,7 +348,7 @@
 	}
 
 	private Stmt ForStmt() throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		int stackStart = symbolsSize();
 		if( !Keyword("for",In.NOTHING) )
 			return parser.failure(null);
@@ -373,7 +360,7 @@
 		addSymbols(names);
 		Stmt loop = RequiredLoopBlock();
 		RequiredKeyword("end",In.NOTHING);
-		Stmt stmt = new ForStmt( se(start), stackStart, symbolsSize() - stackStart, expr, loop );
+		Stmt stmt = new ForStmt( stackStart, symbolsSize() - stackStart, expr, loop );
 		popSymbols( symbolsSize() - stackStart );
 		return parser.success(stmt);
 	}
@@ -445,24 +432,24 @@
 	}
 
 	private Stmt WhileStmt() throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		if( !Keyword("while",In.NOTHING) )
 			return parser.failure(null);
 		Expr cnd = expr(RequiredExpr(In.NOTHING));
 		RequiredKeyword("do",In.NOTHING);
 		Stmt loop = RequiredLoopBlock();
 		RequiredKeyword("end",In.NOTHING);
-		return parser.success( new WhileStmt(se(start),cnd,loop) );
+		return parser.success( new WhileStmt(cnd,loop) );
 	}
 
 	private Stmt RepeatStmt() throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		if( !Keyword("repeat",In.NOTHING) )
 			return parser.failure(null);
 		Stmt loop = RequiredLoopBlock();
 		RequiredKeyword("until",In.NOTHING);
 		Expr cnd = expr(RequiredExpr(In.NOTHING));
-		return parser.success( new RepeatStmt(se(start),loop,cnd) );
+		return parser.success( new RepeatStmt(loop,cnd) );
 	}
 
 	private Stmt RequiredLoopBlock() throws ParseException {
@@ -480,7 +467,7 @@
 	}
 
 	private Stmt IfStmt2() throws ParseException {
-		int start = parser.currentIndex();
+		parser.currentIndex();
 		Expr cnd = expr(RequiredExpr(In.NOTHING));
 		RequiredKeyword("then",In.NOTHING);
 		Stmt thenBlock = RequiredBlock();
@@ -491,7 +478,7 @@
 			elseBlock = Keyword("else",In.NOTHING) ? RequiredBlock() : Stmt.EMPTY;
 			RequiredKeyword("end",In.NOTHING);
 		}
-		return new IfStmt(se(start),cnd,thenBlock,elseBlock);
+		return new IfStmt(cnd,thenBlock,elseBlock);
 	}
 
 	private Stmt SetStmt() throws ParseException {
@@ -544,31 +531,31 @@
 	}
 
 	private Expressions OrExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		Expressions exp = AndExpr(in);
 		if( exp==null )
 			return parser.failure(null);
 		while( Keyword("or",in) ) {
 			Expressions exp2 = AndExpr(in);
-			exp = new OrExpr( se(start), expr(exp), required(expr(exp2)) );
+			exp = new OrExpr( expr(exp), required(expr(exp2)) );
 		}
 		return parser.success(exp);
 	}
 
 	private Expressions AndExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		Expressions exp = RelExpr(in);
 		if( exp==null )
 			return parser.failure(null);
 		while( Keyword("and",in) ) {
 			Expressions exp2 = RelExpr(in);
-			exp = new AndExpr( se(start), expr(exp), required(expr(exp2)) );
+			exp = new AndExpr( expr(exp), required(expr(exp2)) );
 		}
 		return parser.success(exp);
 	}
 
 	private Expressions RelExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		Expressions exp = ConcatExpr(in);
 		if( exp==null )
 			return parser.failure(null);
@@ -576,27 +563,27 @@
 			if( parser.match("==") ) {
 				Spaces(in);
 				Expressions exp2 = ConcatExpr(in);
-				exp = new EqExpr( se(start), expr(exp), required(expr(exp2)) );
+				exp = new EqExpr( expr(exp), required(expr(exp2)) );
 			} else if( parser.match("~=") ) {
 				Spaces(in);
 				Expressions exp2 = ConcatExpr(in);
-				exp = new NotExpr( se(start), new EqExpr( se(start), expr(exp), required(expr(exp2)) ) );
+				exp = new NotExpr( new EqExpr( expr(exp), required(expr(exp2)) ) );
 			} else if( parser.match("<=") ) {
 				Spaces(in);
 				Expressions exp2 = ConcatExpr(in);
-				exp = new LeExpr( se(start), expr(exp), required(expr(exp2)) );
+				exp = new LeExpr( expr(exp), required(expr(exp2)) );
 			} else if( parser.match(">=") ) {
 				Spaces(in);
 				Expressions exp2 = ConcatExpr(in);
-				exp = new LeExpr( se(start), required(expr(exp2)), expr(exp) );
+				exp = new LeExpr( required(expr(exp2)), expr(exp) );
 			} else if( parser.match("<") ) {
 				Spaces(in);
 				Expressions exp2 = ConcatExpr(in);
-				exp = new LtExpr( se(start), expr(exp), required(expr(exp2)) );
+				exp = new LtExpr( expr(exp), required(expr(exp2)) );
 			} else if( parser.match(">") ) {
 				Spaces(in);
 				Expressions exp2 = ConcatExpr(in);
-				exp = new LtExpr( se(start), required(expr(exp2)), expr(exp) );
+				exp = new LtExpr( required(expr(exp2)), expr(exp) );
 			} else
 				break;
 		}
@@ -604,20 +591,20 @@
 	}
 
 	private Expressions ConcatExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		Expressions exp = SumExpr(in);
 		if( exp==null )
 			return parser.failure(null);
 		if( parser.match("..") ) {
 			Spaces(in);
 			Expressions exp2 = ConcatExpr(in);
-			exp = new ConcatExpr( se(start), expr(exp), required(expr(exp2)) );
+			exp = new ConcatExpr( expr(exp), required(expr(exp2)) );
 		}
 		return parser.success(exp);
 	}
 
 	private Expressions SumExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		Expressions exp = TermExpr(in);
 		if( exp==null )
 			return parser.failure(null);
@@ -625,11 +612,11 @@
 			if( parser.match('+') ) {
 				Spaces(in);
 				Expressions exp2 = TermExpr(in);
-				exp = new AddExpr( se(start), expr(exp), required(expr(exp2)) );
+				exp = new AddExpr( expr(exp), required(expr(exp2)) );
 			} else if( Minus() ) {
 				Spaces(in);
 				Expressions exp2 = TermExpr(in);
-				exp = new SubExpr( se(start), expr(exp), required(expr(exp2)) );
+				exp = new SubExpr( expr(exp), required(expr(exp2)) );
 			} else
 				break;
 		}
@@ -642,7 +629,7 @@
 	}
 
 	private Expressions TermExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		Expressions exp = UnaryExpr(in);
 		if( exp==null )
 			return parser.failure(null);
@@ -650,15 +637,15 @@
 			if( parser.match('*') ) {
 				Spaces(in);
 				Expressions exp2 = UnaryExpr(in);
-				exp = new MulExpr( se(start), expr(exp), required(expr(exp2)) );
+				exp = new MulExpr( expr(exp), required(expr(exp2)) );
 			} else if( parser.match('/') ) {
 				Spaces(in);
 				Expressions exp2 = UnaryExpr(in);
-				exp = new DivExpr( se(start), expr(exp), required(expr(exp2)) );
+				exp = new DivExpr( expr(exp), required(expr(exp2)) );
 			} else if( Mod() ) {
 				Spaces(in);
 				Expressions exp2 = UnaryExpr(in);
-				exp = new ModExpr( se(start), expr(exp), required(expr(exp2)) );
+				exp = new ModExpr( expr(exp), required(expr(exp2)) );
 			} else
 				break;
 		}
@@ -671,21 +658,21 @@
 	}
 
 	private Expressions UnaryExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		if( parser.match('#') ) {
 			Spaces(in);
 			Expressions exp = UnaryExpr(in);
-			return parser.success( new LenExpr( se(start), required(expr(exp)) ) );
+			return parser.success( new LenExpr( required(expr(exp)) ) );
 		}
 		if( Minus() ) {
 			Spaces(in);
 			Expressions exp = UnaryExpr(in);
-			return parser.success( new UnmExpr( se(start), required(expr(exp)) ) );
+			return parser.success( new UnmExpr( required(expr(exp)) ) );
 		}
 		if( Keyword("not",in) ) {
 			Spaces(in);
 			Expressions exp = UnaryExpr(in);
-			return parser.success( new NotExpr( se(start), required(expr(exp)) ) );
+			return parser.success( new NotExpr( required(expr(exp)) ) );
 		}
 		Expressions exp = PowExpr(in);
 		if( exp==null )
@@ -694,14 +681,14 @@
 	}
 
 	private Expressions PowExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		Expressions exp = SingleExpr(in);
 		if( exp==null )
 			return parser.failure(null);
 		if( parser.match('^') ) {
 			Spaces(in);
 			Expressions exp2 = PowExpr(in);
-			exp = new PowExpr( se(start), expr(exp), required(expr(exp2)) );
+			exp = new PowExpr( expr(exp), required(expr(exp2)) );
 		}
 		return parser.success(exp);
 	}
@@ -757,15 +744,15 @@
 	}
 
 	private VarArgs VarArgs(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		if( !frame.isVarArg || !parser.match("...") )
 			return parser.failure(null);
 		Spaces(in);
-		return parser.success( new VarArgs(se(start)) );
+		return parser.success( new VarArgs() );
 	}
 
 	private Expr TableExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		if( !parser.match('{') )
 			return parser.failure(null);
 		Spaces(In.NOTHING);
@@ -782,7 +769,7 @@
 		if( !parser.match('}') )
 			throw parser.exception("Expected table element or '}'");
 		Spaces(in);
-		return parser.success( new TableExpr( se(start), fields.toArray(new TableExpr.Field[0]), ExpList.build(builder) ) );
+		return parser.success( new TableExpr( fields.toArray(new TableExpr.Field[0]), ExpList.build(builder) ) );
 	}
 
 	private boolean FieldSep() throws ParseException {
@@ -814,18 +801,18 @@
 	}
 
 	private Var VarZ(In in) throws ParseException {
-		int start = parser.begin();
-		Var var = VarStart(in,start);
+		parser.begin();
+		Var var = VarStart(in);
 		if( var==null )
 			return parser.failure(null);
 		Var var2;
-		while( (var2=Var2(in,start,var.expr())) != null ) {
+		while( (var2=Var2(in,var.expr())) != null ) {
 			var = var2;
 		}
 		return parser.success(var);
 	}
 
-	private Var VarStart(In in,int start) throws ParseException {
+	private Var VarStart(In in) throws ParseException {
 		if( parser.match('(') ) {
 			In inParens = in.parens();
 			Spaces(inParens);
@@ -836,7 +823,7 @@
 		}
 		String name = Name(in);
 		if( name != null )
-			return nameVar(start,name);
+			return nameVar(name);
 		Expressions exp;
 		exp = TableExpr(in);
 		if( exp != null )
@@ -847,19 +834,19 @@
 		return null;
 	}
 
-	private Var Var2(In in,int start,Expressions exp1) throws ParseException {
+	private Var Var2(In in,Expressions exp1) throws ParseException {
 		parser.begin();
 		Expr exp2 = SubExpr(in);
 		if( exp2 != null )
-			return parser.success(indexVar(start,expr(exp1),exp2));
+			return parser.success(indexVar(expr(exp1),exp2));
 		if( parser.match('.') ) {
 			Spaces(in);
 			exp2 = NameExpr(in);
 			if( exp2!=null )
-				return parser.success(indexVar(start,expr(exp1),exp2));
+				return parser.success(indexVar(expr(exp1),exp2));
 			return parser.failure(null);
 		}
-		FnCall fnCall = Args( in, start, expr(exp1), new ArrayList<Expressions>() );
+		FnCall fnCall = Args( in, expr(exp1), new ArrayList<Expressions>() );
 		if( fnCall != null )
 			return parser.success(exprVar(fnCall));
 		return parser.failure(null);
@@ -873,30 +860,26 @@
 	private Expr env() {
 		int index = stackIndex(_ENV);
 		if( index != -1 )
-			return new GetLocalVar(null,index);
+			return new GetLocalVar(index);
 		index = upValueIndex(_ENV);
 		if( index != -1 )
-			return new GetUpVar(null,index);
+			return new GetUpVar(index);
 		return null;
 	}
 
-	private Var nameVar(final int start,final String name) {
-		return nameVar(se(start,name),name);
-	}
-
-	private Var nameVar(final LuanElement se,final String name) {
+	private Var nameVar(final String name) {
 		return new Var() {
 
 			public Expr expr() throws ParseException {
 				int index = stackIndex(name);
 				if( index != -1 )
-					return new GetLocalVar(se,index);
+					return new GetLocalVar(index);
 				index = upValueIndex(name);
 				if( index != -1 )
-					return new GetUpVar(se,index);
+					return new GetUpVar(index);
 				Expr envExpr = env();
 				if( envExpr != null )
-					return new IndexExpr( se, envExpr, new ConstExpr(se,name) );
+					return new IndexExpr( envExpr, new ConstExpr(name) );
 				parser.failure(null);
 				throw parser.exception("name '"+name+"' not defined");
 			}
@@ -910,7 +893,7 @@
 					return new SetUpVar(index);
 				Expr envExpr = env();
 				if( envExpr != null )
-					return new SetTableEntry( se, envExpr, new ConstExpr(se,name) );
+					return new SetTableEntry( envExpr, new ConstExpr(name) );
 				parser.failure(null);
 				throw parser.exception("name '"+name+"' not defined");
 			}
@@ -930,28 +913,28 @@
 		};
 	}
 
-	private Var indexVar(final int start,final Expr table,final Expr key) {
+	private Var indexVar(final Expr table,final Expr key) {
 		return new Var() {
 
 			public Expr expr() {
-				return new IndexExpr( se(start), table, key );
+				return new IndexExpr( table, key );
 			}
 
 			public Settable settable() {
-				return new SetTableEntry(se(start),table,key);
+				return new SetTableEntry(table,key);
 			}
 		};
 	}
 
-	private FnCall Args(In in,int start,Expr fn,List<Expressions> builder) throws ParseException {
+	private FnCall Args(In in,Expr fn,List<Expressions> builder) throws ParseException {
 		parser.begin();
 		return args(in,builder)
-			? parser.success( new FnCall( se(start), fn, ExpList.build(builder) ) )
+			? parser.success( new FnCall( fn, ExpList.build(builder) ) )
 			: parser.failure((FnCall)null);
 	}
 
 	private boolean args(In in,List<Expressions> builder) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		if( parser.match('(') ) {
 			In inParens = in.parens();
 			Spaces(inParens);
@@ -968,7 +951,7 @@
 		}
 		String s = StringLiteral(in);
 		if( s != null ) {
-			builder.add( new ConstExpr(se(start),s) );
+			builder.add( new ConstExpr(s) );
 			return parser.success();
 		}
 /*
@@ -1021,11 +1004,11 @@
 	}
 
 	private Expr NameExpr(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		String name = Name(in);
 		if( name==null )
 			return parser.failure(null);
-		return parser.success(new ConstExpr(se(start),name));
+		return parser.success(new ConstExpr(name));
 	}
 
 	private String RequiredName(In in) throws ParseException {
@@ -1105,18 +1088,18 @@
 	));
 
 	private Expr Literal(In in) throws ParseException {
-		int start = parser.begin();
+		parser.begin();
 		if( NilLiteral(in) )
-			return parser.success(new ConstExpr(se(start),null));
+			return parser.success(new ConstExpr(null));
 		Boolean b = BooleanLiteral(in);
 		if( b != null )
-			return parser.success(new ConstExpr(se(start),b));
+			return parser.success(new ConstExpr(b));
 		Number n = NumberLiteral(in);
 		if( n != null )
-			return parser.success(new ConstExpr(se(start),n));
+			return parser.success(new ConstExpr(n));
 		String s = StringLiteral(in);
 		if( s != null )
-			return parser.success(new ConstExpr(se(start),s));
+			return parser.success(new ConstExpr(s));
 		return parser.failure(null);
 	}