src/main/java/org/luaj/vm3/lib/IoLib.java - minecraft/opencomputers - Rivoreo Source Code Repositories

 /*******************************************************************************
 * Copyright (c) 2009-2011 Luaj.org. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 ******************************************************************************/
 package org.luaj.vm3.lib;

 import java.io.ByteArrayOutputStream;
 import java.io.EOFException;
 import java.io.IOException;

 import org.luaj.vm3.Globals;
 import org.luaj.vm3.LuaString;
 import org.luaj.vm3.LuaTable;
 import org.luaj.vm3.LuaValue;
 import org.luaj.vm3.Varargs;

 /**
  * Abstract base class extending {@link LibFunction} which implements the
  * core of the lua standard {@code io} library.
  * <p>
  * It contains the implementation of the io library support that is common to
  * the JSE and JME platforms.
  * In practice on of the concrete IOLib subclasses is chosen:
  * {@link org.luaj.vm3.lib.jse.JseIoLib} for the JSE platform, and
  * {@link org.luaj.vm3.lib.jme.JmeIoLib} for the JME platform.
  * <p>
  * The JSE implementation conforms almost completely to the C-based lua library,
  * while the JME implementation follows closely except in the area of random-access files,
  * which are difficult to support properly on JME.
  * <p>
  * Typically, this library is included as part of a call to either
  * {@link JsePlatform#standardGlobals()} or {@link JmePlatform#standardGlobals()}
  * <pre> {@code
  * Globals globals = JsePlatform.standardGlobals();
  * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
  * } </pre>
  * In this example the platform-specific {@link JseIoLib} library will be loaded, which will include
  * the base functionality provided by this class, whereas the {@link JsePlatform} would load the
  * {@link JseIoLib}.
  * <p>
  * To instantiate and use it directly,
  * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
  * <pre> {@code
  * Globals globals = new Globals();
  * globals.load(new JseBaseLib());
  * globals.load(new PackageLib());
  * globals.load(new OsLib());
  * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
  * } </pre>
  * <p>
  * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
  * @see LibFunction
  * @see JsePlatform
  * @see JmePlatform
  * @see JseIoLib
  * @see JmeIoLib
  * @see <a href="http://www.lua.org/manual/5.1/manual.html#5.7">http://www.lua.org/manual/5.1/manual.html#5.7</a>
  */
 abstract public class IoLib extends TwoArgFunction {

 	abstract protected class File extends LuaValue {
 		abstract public void write(LuaString string) throws IOException;

 		abstract public void flush() throws IOException;

 		abstract public boolean isstdfile();

 		abstract public void close() throws IOException;

 		abstract public boolean isclosed();

 		// returns new position
 		abstract public int seek(String option, int bytecount) throws IOException;

 		abstract public void setvbuf(String mode, int size);

 		// get length remaining to read
 		abstract public int remaining() throws IOException;

 		// peek ahead one character
 		abstract public int peek() throws IOException, EOFException;

 		// return char if read, -1 if eof, throw IOException on other exception
 		abstract public int read() throws IOException, EOFException;

 		// return number of bytes read if positive, false if eof, throw IOException on other exception
 		abstract public int read(byte[] bytes, int offset, int length) throws IOException;

 		// delegate method access to file methods table
 		public LuaValue get(LuaValue key) {
 			return filemethods.get(key);
 		}

 		// essentially a userdata instance
 		public int type() {
 			return LuaValue.TUSERDATA;
 		}

 		public String typename() {
 			return "userdata";
 		}

 		// displays as "file" type
 		public String tojstring() {
 			return "file: " + Integer.toHexString(hashCode());
 		}
 	}

 	/** Enumerated value representing stdin */
 	protected static final int FTYPE_STDIN = 0;
 	/** Enumerated value representing stdout */
 	protected static final int FTYPE_STDOUT = 1;
 	/** Enumerated value representing stderr */
 	protected static final int FTYPE_STDERR = 2;
 	/** Enumerated value representing a file type for a named file */
 	protected static final int FTYPE_NAMED = 3;

 	/**
 	 * Wrap the standard input.
 	 * @return File
 	 * @throws IOException
 	 */
 	abstract protected File wrapStdin() throws IOException;

 	/**
 	 * Wrap the standard output.
 	 * @return File
 	 * @throws IOException
 	 */
 	abstract protected File wrapStdout() throws IOException;

 	/**
 	 * Wrap the standard error output.
 	 * @return File
 	 * @throws IOException
 	 */
 	abstract protected File wrapStderr() throws IOException;

 	/**
 	 * Open a file in a particular mode.
 	 * @param filename
 	 * @param readMode true if opening in read mode
 	 * @param appendMode true if opening in append mode
 	 * @param updateMode true if opening in update mode
 	 * @param binaryMode true if opening in binary mode
 	 * @return File object if successful
 	 * @throws IOException if could not be opened
 	 */
 	abstract protected File openFile(String filename, boolean readMode, boolean appendMode, boolean updateMode, boolean binaryMode) throws IOException;

 	/**
 	 * Open a temporary file.
 	 * @return File object if successful
 	 * @throws IOException if could not be opened
 	 */
 	abstract protected File tmpFile() throws IOException;

 	/**
 	 * Start a new process and return a file for input or output
 	 * @param prog the program to execute
 	 * @param mode "r" to read, "w" to write
 	 * @return File to read to or write from
 	 * @throws IOException if an i/o exception occurs
 	 */
 	abstract protected File openProgram(String prog, String mode) throws IOException;

 	private File infile = null;
 	private File outfile = null;
 	private File errfile = null;

 	private static final LuaValue STDIN = valueOf("stdin");
 	private static final LuaValue STDOUT = valueOf("stdout");
 	private static final LuaValue STDERR = valueOf("stderr");
 	private static final LuaValue FILE = valueOf("file");
 	private static final LuaValue CLOSED_FILE = valueOf("closed file");

 	private static final int IO_CLOSE = 0;
 	private static final int IO_FLUSH = 1;
 	private static final int IO_INPUT = 2;
 	private static final int IO_LINES = 3;
 	private static final int IO_OPEN = 4;
 	private static final int IO_OUTPUT = 5;
 	private static final int IO_POPEN = 6;
 	private static final int IO_READ = 7;
 	private static final int IO_TMPFILE = 8;
 	private static final int IO_TYPE = 9;
 	private static final int IO_WRITE = 10;

 	private static final int FILE_CLOSE = 11;
 	private static final int FILE_FLUSH = 12;
 	private static final int FILE_LINES = 13;
 	private static final int FILE_READ = 14;
 	private static final int FILE_SEEK = 15;
 	private static final int FILE_SETVBUF = 16;
 	private static final int FILE_WRITE = 17;

 	private static final int IO_INDEX = 18;
 	private static final int LINES_ITER = 19;

 	public static final String[] IO_NAMES = { "close", "flush", "input", "lines", "open", "output", "popen", "read", "tmpfile", "type", "write", };

 	public static final String[] FILE_NAMES = { "close", "flush", "lines", "read", "seek", "setvbuf", "write", };

 	LuaTable filemethods;

 	protected Globals globals;

 	public LuaValue call(LuaValue modname, LuaValue env) {
 		globals = env.checkglobals();

 		// io lib functions
 		LuaTable t = new LuaTable();
 		bind(t, IoLibV.class, IO_NAMES);

 		// create file methods table
 		filemethods = new LuaTable();
 		bind(filemethods, IoLibV.class, FILE_NAMES, FILE_CLOSE);

 		// set up file metatable
 		LuaTable mt = new LuaTable();
 		bind(mt, IoLibV.class, new String[] { "__index" }, IO_INDEX);
 		t.setmetatable(mt);

 		// all functions link to library instance
 		setLibInstance(t);
 		setLibInstance(filemethods);
 		setLibInstance(mt);

 		// return the table
 		env.set("io", t);
 		env.get("package").get("loaded").set("io", t);
 		return t;
 	}

 	private void setLibInstance(LuaTable t) {
 		LuaValue[] k = t.keys();
 		for (int i = 0, n = k.length; i < n; i++)
 			((IoLibV) t.get(k[i])).iolib = this;
 	}

 	static final class IoLibV extends VarArgFunction {
 		private File f;
 		public IoLib iolib;

 		public IoLibV() {}

 		public IoLibV(File f, String name, int opcode, IoLib iolib) {
 			super();
 			this.f = f;
 			this.name = name;
 			this.opcode = opcode;
 			this.iolib = iolib;
 		}

 		public Varargs invoke(Varargs args) {
 			try {
 				switch (opcode) {
 				case IO_FLUSH:
 					return iolib._io_flush();
 				case IO_TMPFILE:
 					return iolib._io_tmpfile();
 				case IO_CLOSE:
 					return iolib._io_close(args.arg1());
 				case IO_INPUT:
 					return iolib._io_input(args.arg1());
 				case IO_OUTPUT:
 					return iolib._io_output(args.arg1());
 				case IO_TYPE:
 					return iolib._io_type(args.arg1());
 				case IO_POPEN:
 					return iolib._io_popen(args.checkjstring(1), args.optjstring(2, "r"));
 				case IO_OPEN:
 					return iolib._io_open(args.checkjstring(1), args.optjstring(2, "r"));
 				case IO_LINES:
 					return iolib._io_lines(args.isvalue(1) ? args.checkjstring(1) : null);
 				case IO_READ:
 					return iolib._io_read(args);
 				case IO_WRITE:
 					return iolib._io_write(args);

 				case FILE_CLOSE:
 					return iolib._file_close(args.arg1());
 				case FILE_FLUSH:
 					return iolib._file_flush(args.arg1());
 				case FILE_SETVBUF:
 					return iolib._file_setvbuf(args.arg1(), args.checkjstring(2), args.optint(3, 1024));
 				case FILE_LINES:
 					return iolib._file_lines(args.arg1());
 				case FILE_READ:
 					return iolib._file_read(args.arg1(), args.subargs(2));
 				case FILE_SEEK:
 					return iolib._file_seek(args.arg1(), args.optjstring(2, "cur"), args.optint(3, 0));
 				case FILE_WRITE:
 					return iolib._file_write(args.arg1(), args.subargs(2));

 				case IO_INDEX:
 					return iolib._io_index(args.arg(2));
 				case LINES_ITER:
 					return iolib._lines_iter(f);
 				}
 			} catch (IOException ioe) {
 				return errorresult(ioe);
 			}
 			return NONE;
 		}
 	}

 	private File input() {
 		return infile != null ? infile : (infile = ioopenfile(FTYPE_STDIN, "-", "r"));
 	}

 	//	io.flush() -> bool
 	public Varargs _io_flush() throws IOException {
 		checkopen(output());
 		outfile.flush();
 		return LuaValue.TRUE;
 	}

 	//	io.tmpfile() -> file
 	public Varargs _io_tmpfile() throws IOException {
 		return tmpFile();
 	}

 	//	io.close([file]) -> void
 	public Varargs _io_close(LuaValue file) throws IOException {
 		File f = file.isnil() ? output() : checkfile(file);
 		checkopen(f);
 		return ioclose(f);
 	}

 	//	io.input([file]) -> file
 	public Varargs _io_input(LuaValue file) {
 		infile = file.isnil() ? input() : file.isstring() ? ioopenfile(FTYPE_NAMED, file.checkjstring(), "r") : checkfile(file);
 		return infile;
 	}

 	// io.output(filename) -> file
 	public Varargs _io_output(LuaValue filename) {
 		outfile = filename.isnil() ? output() : filename.isstring() ? ioopenfile(FTYPE_NAMED, filename.checkjstring(), "w") : checkfile(filename);
 		return outfile;
 	}

 	//	io.type(obj) -> "file" | "closed file" | nil
 	public Varargs _io_type(LuaValue obj) {
 		File f = optfile(obj);
 		return f != null ? f.isclosed() ? CLOSED_FILE : FILE : NIL;
 	}

 	// io.popen(prog, [mode]) -> file
 	public Varargs _io_popen(String prog, String mode) throws IOException {
 		return openProgram(prog, mode);
 	}

 	//	io.open(filename, [mode]) -> file | nil,err
 	public Varargs _io_open(String filename, String mode) throws IOException {
 		return rawopenfile(FTYPE_NAMED, filename, mode);
 	}

 	//	io.lines(filename) -> iterator
 	public Varargs _io_lines(String filename) {
 		infile = filename == null ? input() : ioopenfile(FTYPE_NAMED, filename, "r");
 		checkopen(infile);
 		return lines(infile);
 	}

 	//	io.read(...) -> (...)
 	public Varargs _io_read(Varargs args) throws IOException {
 		checkopen(input());
 		return ioread(infile, args);
 	}

 	//	io.write(...) -> void
 	public Varargs _io_write(Varargs args) throws IOException {
 		checkopen(output());
 		return iowrite(outfile, args);
 	}

 	// file:close() -> void
 	public Varargs _file_close(LuaValue file) throws IOException {
 		return ioclose(checkfile(file));
 	}

 	// file:flush() -> void
 	public Varargs _file_flush(LuaValue file) throws IOException {
 		checkfile(file).flush();
 		return LuaValue.TRUE;
 	}

 	// file:setvbuf(mode,[size]) -> void
 	public Varargs _file_setvbuf(LuaValue file, String mode, int size) {
 		checkfile(file).setvbuf(mode, size);
 		return LuaValue.TRUE;
 	}

 	// file:lines() -> iterator
 	public Varargs _file_lines(LuaValue file) {
 		return lines(checkfile(file));
 	}

 	//	file:read(...) -> (...)
 	public Varargs _file_read(LuaValue file, Varargs subargs) throws IOException {
 		return ioread(checkfile(file), subargs);
 	}

 	//  file:seek([whence][,offset]) -> pos | nil,error
 	public Varargs _file_seek(LuaValue file, String whence, int offset) throws IOException {
 		return valueOf(checkfile(file).seek(whence, offset));
 	}

 	//	file:write(...) -> void
 	public Varargs _file_write(LuaValue file, Varargs subargs) throws IOException {
 		return iowrite(checkfile(file), subargs);
 	}

 	// __index, returns a field
 	public Varargs _io_index(LuaValue v) {
 		return v.equals(STDOUT) ? output() : v.equals(STDIN) ? input() : v.equals(STDERR) ? errput() : NIL;
 	}

 	//	lines iterator(s,var) -> var'
 	public Varargs _lines_iter(LuaValue file) throws IOException {
 		return freadline(checkfile(file));
 	}

 	private File output() {
 		return outfile != null ? outfile : (outfile = ioopenfile(FTYPE_STDOUT, "-", "w"));
 	}

 	private File errput() {
 		return errfile != null ? errfile : (errfile = ioopenfile(FTYPE_STDERR, "-", "w"));
 	}

 	private File ioopenfile(int filetype, String filename, String mode) {
 		try {
 			return rawopenfile(filetype, filename, mode);
 		} catch (Exception e) {
 			error("io error: " + e.getMessage());
 			return null;
 		}
 	}

 	private static Varargs ioclose(File f) throws IOException {
 		if (f.isstdfile())
 			return errorresult("cannot close standard file");
 		else {
 			f.close();
 			return successresult();
 		}
 	}

 	private static Varargs successresult() {
 		return LuaValue.TRUE;
 	}

 	private static Varargs errorresult(Exception ioe) {
 		String s = ioe.getMessage();
 		return errorresult("io error: " + (s != null ? s : ioe.toString()));
 	}

 	private static Varargs errorresult(String errortext) {
 		return varargsOf(NIL, valueOf(errortext));
 	}

 	private Varargs lines(final File f) {
 		try {
 			return new IoLibV(f, "lnext", LINES_ITER, this);
 		} catch (Exception e) {
 			return error("lines: " + e);
 		}
 	}

 	private static Varargs iowrite(File f, Varargs args) throws IOException {
 		for (int i = 1, n = args.narg(); i <= n; i++)
 			f.write(args.checkstring(i));
 		return f;
 	}

 	private Varargs ioread(File f, Varargs args) throws IOException {
 		int i, n = args.narg();
 		LuaValue[] v = new LuaValue[n];
 		LuaValue ai, vi;
 		LuaString fmt;
 		for (i = 0; i < n;) {
 			item: switch ((ai = args.arg(i + 1)).type()) {
 			case LuaValue.TNUMBER:
 				vi = freadbytes(f, ai.toint());
 				break item;
 			case LuaValue.TSTRING:
 				fmt = ai.checkstring();
 				if (fmt.m_length == 2 && fmt.m_bytes[fmt.m_offset] == '*') {
 					switch (fmt.m_bytes[fmt.m_offset + 1]) {
 					case 'n':
 						vi = freadnumber(f);
 						break item;
 					case 'l':
 						vi = freadline(f);
 						break item;
 					case 'a':
 						vi = freadall(f);
 						break item;
 					}
 				}
 			default:
 				return argerror(i + 1, "(invalid format)");
 			}
 			if ((v[i++] = vi).isnil())
 				break;
 		}
 		return i == 0 ? NIL : varargsOf(v, 0, i);
 	}

 	private static File checkfile(LuaValue val) {
 		File f = optfile(val);
 		if (f == null)
 			argerror(1, "file");
 		checkopen(f);
 		return f;
 	}

 	private static File optfile(LuaValue val) {
 		return (val instanceof File) ? (File) val : null;
 	}

 	private static File checkopen(File file) {
 		if (file.isclosed())
 			error("attempt to use a closed file");
 		return file;
 	}

 	private File rawopenfile(int filetype, String filename, String mode) throws IOException {
 		switch (filetype) {
 		case FTYPE_STDIN:
 			return wrapStdin();
 		case FTYPE_STDOUT:
 			return wrapStdout();
 		case FTYPE_STDERR:
 			return wrapStderr();
 		}
 		boolean isreadmode = mode.startsWith("r");
 		boolean isappend = mode.startsWith("a");
 		boolean isupdate = mode.indexOf("+") > 0;
 		boolean isbinary = mode.endsWith("b");
 		return openFile(filename, isreadmode, isappend, isupdate, isbinary);
 	}

 	// ------------- file reading utilitied ------------------

 	public static LuaValue freadbytes(File f, int count) throws IOException {
 		byte[] b = new byte[count];
 		int r;
 		if ((r = f.read(b, 0, b.length)) < 0)
 			return NIL;
 		return LuaString.valueOf(b, 0, r);
 	}

 	public static LuaValue freaduntil(File f, boolean lineonly) throws IOException {
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
 		int c;
 		try {
 			if (lineonly) {
 				loop: while ((c = f.read()) > 0) {
 					switch (c) {
 					case '\r':
 						break;
 					case '\n':
 						break loop;
 					default:
 						baos.write(c);
 						break;
 					}
 				}
 			} else {
 				while ((c = f.read()) > 0)
 					baos.write(c);
 			}
 		} catch (EOFException e) {
 			c = -1;
 		}
 		return (c < 0 && baos.size() == 0) ? (LuaValue) NIL : (LuaValue) LuaString.valueOf(baos.toByteArray());
 	}

 	public static LuaValue freadline(File f) throws IOException {
 		return freaduntil(f, true);
 	}

 	public static LuaValue freadall(File f) throws IOException {
 		int n = f.remaining();
 		if (n >= 0) {
 			return freadbytes(f, n);
 		} else {
 			return freaduntil(f, false);
 		}
 	}

 	public static LuaValue freadnumber(File f) throws IOException {
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
 		freadchars(f, " \t\r\n", null);
 		freadchars(f, "-+", baos);
 		//freadchars(f,"0",baos);
 		//freadchars(f,"xX",baos);
 		freadchars(f, "0123456789", baos);
 		freadchars(f, ".", baos);
 		freadchars(f, "0123456789", baos);
 		//freadchars(f,"eEfFgG",baos);
 		// freadchars(f,"+-",baos);
 		//freadchars(f,"0123456789",baos);
 		String s = baos.toString();
 		return s.length() > 0 ? valueOf(Double.parseDouble(s)) : NIL;
 	}

 	private static void freadchars(File f, String chars, ByteArrayOutputStream baos) throws IOException {
 		int c;
 		while (true) {
 			c = f.peek();
 			if (chars.indexOf(c) < 0) {
 				return;
 			}
 			f.read();
 			if (baos != null)
 				baos.write(c);
 		}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2009-2011 Luaj.org. All rights reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	* THE SOFTWARE.
	******************************************************************************/
	package org.luaj.vm3.lib;

	import java.io.ByteArrayOutputStream;
	import java.io.EOFException;
	import java.io.IOException;

	import org.luaj.vm3.Globals;
	import org.luaj.vm3.LuaString;
	import org.luaj.vm3.LuaTable;
	import org.luaj.vm3.LuaValue;
	import org.luaj.vm3.Varargs;

	/**
	* Abstract base class extending {@link LibFunction} which implements the
	* core of the lua standard {@code io} library.
	* <p>
	* It contains the implementation of the io library support that is common to
	* the JSE and JME platforms.
	* In practice on of the concrete IOLib subclasses is chosen:
	* {@link org.luaj.vm3.lib.jse.JseIoLib} for the JSE platform, and
	* {@link org.luaj.vm3.lib.jme.JmeIoLib} for the JME platform.
	* <p>
	* The JSE implementation conforms almost completely to the C-based lua library,
	* while the JME implementation follows closely except in the area of random-access files,
	* which are difficult to support properly on JME.
	* <p>
	* Typically, this library is included as part of a call to either
	* {@link JsePlatform#standardGlobals()} or {@link JmePlatform#standardGlobals()}
	* <pre> {@code
	* Globals globals = JsePlatform.standardGlobals();
	* globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
	* } </pre>
	* In this example the platform-specific {@link JseIoLib} library will be loaded, which will include
	* the base functionality provided by this class, whereas the {@link JsePlatform} would load the
	* {@link JseIoLib}.
	* <p>
	* To instantiate and use it directly,
	* link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
	* <pre> {@code
	* Globals globals = new Globals();
	* globals.load(new JseBaseLib());
	* globals.load(new PackageLib());
	* globals.load(new OsLib());
	* globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
	* } </pre>
	* <p>
	* This has been implemented to match as closely as possible the behavior in the corresponding library in C.
	* @see LibFunction
	* @see JsePlatform
	* @see JmePlatform
	* @see JseIoLib
	* @see JmeIoLib
	* @see <a href="http://www.lua.org/manual/5.1/manual.html#5.7">http://www.lua.org/manual/5.1/manual.html#5.7</a>
	*/
	abstract public class IoLib extends TwoArgFunction {

	abstract protected class File extends LuaValue {
	abstract public void write(LuaString string) throws IOException;

	abstract public void flush() throws IOException;

	abstract public boolean isstdfile();

	abstract public void close() throws IOException;

	abstract public boolean isclosed();

	// returns new position
	abstract public int seek(String option, int bytecount) throws IOException;

	abstract public void setvbuf(String mode, int size);

	// get length remaining to read
	abstract public int remaining() throws IOException;

	// peek ahead one character
	abstract public int peek() throws IOException, EOFException;

	// return char if read, -1 if eof, throw IOException on other exception
	abstract public int read() throws IOException, EOFException;

	// return number of bytes read if positive, false if eof, throw IOException on other exception
	abstract public int read(byte[] bytes, int offset, int length) throws IOException;

	// delegate method access to file methods table
	public LuaValue get(LuaValue key) {
	return filemethods.get(key);
	}

	// essentially a userdata instance
	public int type() {
	return LuaValue.TUSERDATA;
	}

	public String typename() {
	return "userdata";
	}

	// displays as "file" type
	public String tojstring() {
	return "file: " + Integer.toHexString(hashCode());
	}
	}

	/** Enumerated value representing stdin */
	protected static final int FTYPE_STDIN = 0;
	/** Enumerated value representing stdout */
	protected static final int FTYPE_STDOUT = 1;
	/** Enumerated value representing stderr */
	protected static final int FTYPE_STDERR = 2;
	/** Enumerated value representing a file type for a named file */
	protected static final int FTYPE_NAMED = 3;

	/**
	* Wrap the standard input.
	* @return File
	* @throws IOException
	*/
	abstract protected File wrapStdin() throws IOException;

	/**
	* Wrap the standard output.
	* @return File
	* @throws IOException
	*/
	abstract protected File wrapStdout() throws IOException;

	/**
	* Wrap the standard error output.
	* @return File
	* @throws IOException
	*/
	abstract protected File wrapStderr() throws IOException;

	/**
	* Open a file in a particular mode.
	* @param filename
	* @param readMode true if opening in read mode
	* @param appendMode true if opening in append mode
	* @param updateMode true if opening in update mode
	* @param binaryMode true if opening in binary mode
	* @return File object if successful
	* @throws IOException if could not be opened
	*/
	abstract protected File openFile(String filename, boolean readMode, boolean appendMode, boolean updateMode, boolean binaryMode) throws IOException;

	/**
	* Open a temporary file.
	* @return File object if successful
	* @throws IOException if could not be opened
	*/
	abstract protected File tmpFile() throws IOException;

	/**
	* Start a new process and return a file for input or output
	* @param prog the program to execute
	* @param mode "r" to read, "w" to write
	* @return File to read to or write from
	* @throws IOException if an i/o exception occurs
	*/
	abstract protected File openProgram(String prog, String mode) throws IOException;

	private File infile = null;
	private File outfile = null;
	private File errfile = null;

	private static final LuaValue STDIN = valueOf("stdin");
	private static final LuaValue STDOUT = valueOf("stdout");
	private static final LuaValue STDERR = valueOf("stderr");
	private static final LuaValue FILE = valueOf("file");
	private static final LuaValue CLOSED_FILE = valueOf("closed file");

	private static final int IO_CLOSE = 0;
	private static final int IO_FLUSH = 1;
	private static final int IO_INPUT = 2;
	private static final int IO_LINES = 3;
	private static final int IO_OPEN = 4;
	private static final int IO_OUTPUT = 5;
	private static final int IO_POPEN = 6;
	private static final int IO_READ = 7;
	private static final int IO_TMPFILE = 8;
	private static final int IO_TYPE = 9;
	private static final int IO_WRITE = 10;

	private static final int FILE_CLOSE = 11;
	private static final int FILE_FLUSH = 12;
	private static final int FILE_LINES = 13;
	private static final int FILE_READ = 14;
	private static final int FILE_SEEK = 15;
	private static final int FILE_SETVBUF = 16;
	private static final int FILE_WRITE = 17;

	private static final int IO_INDEX = 18;
	private static final int LINES_ITER = 19;

	public static final String[] IO_NAMES = { "close", "flush", "input", "lines", "open", "output", "popen", "read", "tmpfile", "type", "write", };

	public static final String[] FILE_NAMES = { "close", "flush", "lines", "read", "seek", "setvbuf", "write", };

	LuaTable filemethods;

	protected Globals globals;

	public LuaValue call(LuaValue modname, LuaValue env) {
	globals = env.checkglobals();

	// io lib functions
	LuaTable t = new LuaTable();
	bind(t, IoLibV.class, IO_NAMES);

	// create file methods table
	filemethods = new LuaTable();
	bind(filemethods, IoLibV.class, FILE_NAMES, FILE_CLOSE);

	// set up file metatable
	LuaTable mt = new LuaTable();
	bind(mt, IoLibV.class, new String[] { "__index" }, IO_INDEX);
	t.setmetatable(mt);

	// all functions link to library instance
	setLibInstance(t);
	setLibInstance(filemethods);
	setLibInstance(mt);

	// return the table
	env.set("io", t);
	env.get("package").get("loaded").set("io", t);
	return t;
	}

	private void setLibInstance(LuaTable t) {
	LuaValue[] k = t.keys();
	for (int i = 0, n = k.length; i < n; i++)
	((IoLibV) t.get(k[i])).iolib = this;
	}

	static final class IoLibV extends VarArgFunction {
	private File f;
	public IoLib iolib;

	public IoLibV() {}

	public IoLibV(File f, String name, int opcode, IoLib iolib) {
	super();
	this.f = f;
	this.name = name;
	this.opcode = opcode;
	this.iolib = iolib;
	}

	public Varargs invoke(Varargs args) {
	try {
	switch (opcode) {
	case IO_FLUSH:
	return iolib._io_flush();
	case IO_TMPFILE:
	return iolib._io_tmpfile();
	case IO_CLOSE:
	return iolib._io_close(args.arg1());
	case IO_INPUT:
	return iolib._io_input(args.arg1());
	case IO_OUTPUT:
	return iolib._io_output(args.arg1());
	case IO_TYPE:
	return iolib._io_type(args.arg1());
	case IO_POPEN:
	return iolib._io_popen(args.checkjstring(1), args.optjstring(2, "r"));
	case IO_OPEN:
	return iolib._io_open(args.checkjstring(1), args.optjstring(2, "r"));
	case IO_LINES:
	return iolib._io_lines(args.isvalue(1) ? args.checkjstring(1) : null);
	case IO_READ:
	return iolib._io_read(args);
	case IO_WRITE:
	return iolib._io_write(args);

	case FILE_CLOSE:
	return iolib._file_close(args.arg1());
	case FILE_FLUSH:
	return iolib._file_flush(args.arg1());
	case FILE_SETVBUF:
	return iolib._file_setvbuf(args.arg1(), args.checkjstring(2), args.optint(3, 1024));
	case FILE_LINES:
	return iolib._file_lines(args.arg1());
	case FILE_READ:
	return iolib._file_read(args.arg1(), args.subargs(2));
	case FILE_SEEK:
	return iolib._file_seek(args.arg1(), args.optjstring(2, "cur"), args.optint(3, 0));
	case FILE_WRITE:
	return iolib._file_write(args.arg1(), args.subargs(2));

	case IO_INDEX:
	return iolib._io_index(args.arg(2));
	case LINES_ITER:
	return iolib._lines_iter(f);
	}
	} catch (IOException ioe) {
	return errorresult(ioe);
	}
	return NONE;
	}
	}

	private File input() {
	return infile != null ? infile : (infile = ioopenfile(FTYPE_STDIN, "-", "r"));
	}

	// io.flush() -> bool
	public Varargs _io_flush() throws IOException {
	checkopen(output());
	outfile.flush();
	return LuaValue.TRUE;
	}

	// io.tmpfile() -> file
	public Varargs _io_tmpfile() throws IOException {
	return tmpFile();
	}

	// io.close([file]) -> void
	public Varargs _io_close(LuaValue file) throws IOException {
	File f = file.isnil() ? output() : checkfile(file);
	checkopen(f);
	return ioclose(f);
	}

	// io.input([file]) -> file
	public Varargs _io_input(LuaValue file) {
	infile = file.isnil() ? input() : file.isstring() ? ioopenfile(FTYPE_NAMED, file.checkjstring(), "r") : checkfile(file);
	return infile;
	}

	// io.output(filename) -> file
	public Varargs _io_output(LuaValue filename) {
	outfile = filename.isnil() ? output() : filename.isstring() ? ioopenfile(FTYPE_NAMED, filename.checkjstring(), "w") : checkfile(filename);
	return outfile;
	}

	// io.type(obj) -> "file" \| "closed file" \| nil
	public Varargs _io_type(LuaValue obj) {
	File f = optfile(obj);
	return f != null ? f.isclosed() ? CLOSED_FILE : FILE : NIL;
	}

	// io.popen(prog, [mode]) -> file
	public Varargs _io_popen(String prog, String mode) throws IOException {
	return openProgram(prog, mode);
	}

	// io.open(filename, [mode]) -> file \| nil,err
	public Varargs _io_open(String filename, String mode) throws IOException {
	return rawopenfile(FTYPE_NAMED, filename, mode);
	}

	// io.lines(filename) -> iterator
	public Varargs _io_lines(String filename) {
	infile = filename == null ? input() : ioopenfile(FTYPE_NAMED, filename, "r");
	checkopen(infile);
	return lines(infile);
	}

	// io.read(...) -> (...)
	public Varargs _io_read(Varargs args) throws IOException {
	checkopen(input());
	return ioread(infile, args);
	}

	// io.write(...) -> void
	public Varargs _io_write(Varargs args) throws IOException {
	checkopen(output());
	return iowrite(outfile, args);
	}

	// file:close() -> void
	public Varargs _file_close(LuaValue file) throws IOException {
	return ioclose(checkfile(file));
	}

	// file:flush() -> void
	public Varargs _file_flush(LuaValue file) throws IOException {
	checkfile(file).flush();
	return LuaValue.TRUE;
	}

	// file:setvbuf(mode,[size]) -> void
	public Varargs _file_setvbuf(LuaValue file, String mode, int size) {
	checkfile(file).setvbuf(mode, size);
	return LuaValue.TRUE;
	}

	// file:lines() -> iterator
	public Varargs _file_lines(LuaValue file) {
	return lines(checkfile(file));
	}

	// file:read(...) -> (...)
	public Varargs _file_read(LuaValue file, Varargs subargs) throws IOException {
	return ioread(checkfile(file), subargs);
	}

	// file:seek([whence][,offset]) -> pos \| nil,error
	public Varargs _file_seek(LuaValue file, String whence, int offset) throws IOException {
	return valueOf(checkfile(file).seek(whence, offset));
	}

	// file:write(...) -> void
	public Varargs _file_write(LuaValue file, Varargs subargs) throws IOException {
	return iowrite(checkfile(file), subargs);
	}

	// __index, returns a field
	public Varargs _io_index(LuaValue v) {
	return v.equals(STDOUT) ? output() : v.equals(STDIN) ? input() : v.equals(STDERR) ? errput() : NIL;
	}

	// lines iterator(s,var) -> var'
	public Varargs _lines_iter(LuaValue file) throws IOException {
	return freadline(checkfile(file));
	}

	private File output() {
	return outfile != null ? outfile : (outfile = ioopenfile(FTYPE_STDOUT, "-", "w"));
	}

	private File errput() {
	return errfile != null ? errfile : (errfile = ioopenfile(FTYPE_STDERR, "-", "w"));
	}

	private File ioopenfile(int filetype, String filename, String mode) {
	try {
	return rawopenfile(filetype, filename, mode);
	} catch (Exception e) {
	error("io error: " + e.getMessage());
	return null;
	}
	}

	private static Varargs ioclose(File f) throws IOException {
	if (f.isstdfile())
	return errorresult("cannot close standard file");
	else {
	f.close();
	return successresult();
	}
	}

	private static Varargs successresult() {
	return LuaValue.TRUE;
	}

	private static Varargs errorresult(Exception ioe) {
	String s = ioe.getMessage();
	return errorresult("io error: " + (s != null ? s : ioe.toString()));
	}

	private static Varargs errorresult(String errortext) {
	return varargsOf(NIL, valueOf(errortext));
	}

	private Varargs lines(final File f) {
	try {
	return new IoLibV(f, "lnext", LINES_ITER, this);
	} catch (Exception e) {
	return error("lines: " + e);
	}
	}

	private static Varargs iowrite(File f, Varargs args) throws IOException {
	for (int i = 1, n = args.narg(); i <= n; i++)
	f.write(args.checkstring(i));
	return f;
	}

	private Varargs ioread(File f, Varargs args) throws IOException {
	int i, n = args.narg();
	LuaValue[] v = new LuaValue[n];
	LuaValue ai, vi;
	LuaString fmt;
	for (i = 0; i < n;) {
	item: switch ((ai = args.arg(i + 1)).type()) {
	case LuaValue.TNUMBER:
	vi = freadbytes(f, ai.toint());
	break item;
	case LuaValue.TSTRING:
	fmt = ai.checkstring();
	if (fmt.m_length == 2 && fmt.m_bytes[fmt.m_offset] == '*') {
	switch (fmt.m_bytes[fmt.m_offset + 1]) {
	case 'n':
	vi = freadnumber(f);
	break item;
	case 'l':
	vi = freadline(f);
	break item;
	case 'a':
	vi = freadall(f);
	break item;
	}
	}
	default:
	return argerror(i + 1, "(invalid format)");
	}
	if ((v[i++] = vi).isnil())
	break;
	}
	return i == 0 ? NIL : varargsOf(v, 0, i);
	}

	private static File checkfile(LuaValue val) {
	File f = optfile(val);
	if (f == null)
	argerror(1, "file");
	checkopen(f);
	return f;
	}

	private static File optfile(LuaValue val) {
	return (val instanceof File) ? (File) val : null;
	}

	private static File checkopen(File file) {
	if (file.isclosed())
	error("attempt to use a closed file");
	return file;
	}

	private File rawopenfile(int filetype, String filename, String mode) throws IOException {
	switch (filetype) {
	case FTYPE_STDIN:
	return wrapStdin();
	case FTYPE_STDOUT:
	return wrapStdout();
	case FTYPE_STDERR:
	return wrapStderr();
	}
	boolean isreadmode = mode.startsWith("r");
	boolean isappend = mode.startsWith("a");
	boolean isupdate = mode.indexOf("+") > 0;
	boolean isbinary = mode.endsWith("b");
	return openFile(filename, isreadmode, isappend, isupdate, isbinary);
	}

	// ------------- file reading utilitied ------------------

	public static LuaValue freadbytes(File f, int count) throws IOException {
	byte[] b = new byte[count];
	int r;
	if ((r = f.read(b, 0, b.length)) < 0)
	return NIL;
	return LuaString.valueOf(b, 0, r);
	}

	public static LuaValue freaduntil(File f, boolean lineonly) throws IOException {
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	int c;
	try {
	if (lineonly) {
	loop: while ((c = f.read()) > 0) {
	switch (c) {
	case '\r':
	break;
	case '\n':
	break loop;
	default:
	baos.write(c);
	break;
	}
	}
	} else {
	while ((c = f.read()) > 0)
	baos.write(c);
	}
	} catch (EOFException e) {
	c = -1;
	}
	return (c < 0 && baos.size() == 0) ? (LuaValue) NIL : (LuaValue) LuaString.valueOf(baos.toByteArray());
	}

	public static LuaValue freadline(File f) throws IOException {
	return freaduntil(f, true);
	}

	public static LuaValue freadall(File f) throws IOException {
	int n = f.remaining();
	if (n >= 0) {
	return freadbytes(f, n);
	} else {
	return freaduntil(f, false);
	}
	}

	public static LuaValue freadnumber(File f) throws IOException {
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	freadchars(f, " \t\r\n", null);
	freadchars(f, "-+", baos);
	//freadchars(f,"0",baos);
	//freadchars(f,"xX",baos);
	freadchars(f, "0123456789", baos);
	freadchars(f, ".", baos);
	freadchars(f, "0123456789", baos);
	//freadchars(f,"eEfFgG",baos);
	// freadchars(f,"+-",baos);
	//freadchars(f,"0123456789",baos);
	String s = baos.toString();
	return s.length() > 0 ? valueOf(Double.parseDouble(s)) : NIL;
	}

	private static void freadchars(File f, String chars, ByteArrayOutputStream baos) throws IOException {
	int c;
	while (true) {
	c = f.peek();
	if (chars.indexOf(c) < 0) {
	return;
	}
	f.read();
	if (baos != null)
	baos.write(c);
	}
	}

	}