Added some file handling for cpp

std/cpp/io/File.hx

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package cpp.io;
+
+typedef FileHandle = Dynamic;
+
+enum FileSeek {
+	SeekBegin;
+	SeekCur;
+	SeekEnd;
+}
+
+/**
+	API for reading and writing to files.
+**/
+class File {
+
+	public static function getContent( path : String ) {
+		var b = getBytes(path);
+		return b.toString();
+	}
+
+	public static function getBytes( path : String ) : haxe.io.Bytes {
+		var data:haxe.io.BytesData = file_contents(path);
+		return haxe.io.Bytes.ofData(data);
+	}
+
+	public static function read( path : String, binary : Bool ) {
+		return new FileInput(untyped file_open(path,(if( binary ) "rb" else "r")));
+	}
+
+	public static function write( path : String, binary : Bool ) {
+		return new FileOutput(untyped file_open(path.__s,(if( binary ) "wb" else "w")));
+	}
+
+	public static function append( path : String, binary : Bool ) {
+		return new FileOutput(untyped file_open(path.__s,(if( binary ) "ab" else "a")));
+	}
+
+	public static function copy( src : String, dst : String ) {
+		var s = read(src,true);
+		var d = write(dst,true);
+		d.writeInput(s);
+		s.close();
+		d.close();
+	}
+
+	public static function stdin() {
+		return new FileInput(file_stdin());
+	}
+
+	public static function stdout() {
+		return new FileOutput(file_stdout());
+	}
+
+	public static function stderr() {
+		return new FileOutput(file_stderr());
+	}
+
+	public static function getChar( echo : Bool ) : Int {
+		return getch(echo);
+	}
+
+	private static var file_stdin = cpp.Lib.load("std","file_stdin",0);
+	private static var file_stdout = cpp.Lib.load("std","file_stdout",0);
+	private static var file_stderr = cpp.Lib.load("std","file_stderr",0);
+
+	private static var file_contents = cpp.Lib.load("std","file_contents",1);
+	private static var file_open = cpp.Lib.load("std","file_open",2);
+
+	private static var getch = cpp.Lib.load("std","sys_getch",1);
+
+}

std/cpp/io/FileInput.hx

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package cpp.io;
+import cpp.io.File;
+
+/**
+	Use [cpp.io.File.read] to create a [FileInput]
+**/
+class FileInput extends haxe.io.Input {
+
+	private var __f : FileHandle;
+
+	public function new(f) {
+		__f = f;
+	}
+
+	public override function readByte() : Int {
+		return try {
+			file_read_char(__f);
+		} catch( e : Dynamic ) {
+			if( untyped e.__IsArray() )
+				throw new haxe.io.Eof();
+			else
+				throw haxe.io.Error.Custom(e);
+		}
+	}
+
+	public override function readBytes( s : haxe.io.Bytes, p : Int, l : Int ) : Int {
+		return try {
+			file_read(__f,s.getData(),p,l);
+		} catch( e : Dynamic ) {
+			if( untyped e.__IsArray() )
+				throw new haxe.io.Eof();
+			else
+				throw haxe.io.Error.Custom(e);
+		}
+	}
+
+	public override function close() {
+		super.close();
+		file_close(__f);
+	}
+
+	public function seek( p : Int, pos : FileSeek ) {
+		file_seek(__f,p,switch( pos ) { case SeekBegin: 0; case SeekCur: 1; case SeekEnd: 2; });
+	}
+
+	public function tell() : Int {
+		return file_tell(__f);
+	}
+
+
+	public function eof() : Bool {
+		return file_eof(__f);
+	}
+
+	private static var file_eof = cpp.Lib.load("std","file_eof",1);
+
+	private static var file_read = cpp.Lib.load("std","file_read",4);
+	private static var file_read_char = cpp.Lib.load("std","file_read_char",1);
+
+	private static var file_close = cpp.Lib.load("std","file_close",1);
+	private static var file_seek = cpp.Lib.load("std","file_seek",3);
+	private static var file_tell = cpp.Lib.load("std","file_tell",1);
+
+}

std/cpp/io/FileOutput.hx

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package cpp.io;
+import cpp.io.File;
+
+/**
+	Use [cpp.io.File.write] to create a [FileOutput]
+**/
+class FileOutput extends haxe.io.Output {
+
+	private var __f : FileHandle;
+
+	public function new(f) {
+		__f = f;
+	}
+
+	public override function writeByte( c : Int ) {
+		try file_write_char(__f,c) catch( e : Dynamic ) throw haxe.io.Error.Custom(e);
+	}
+
+	public override function writeBytes( s : haxe.io.Bytes, p : Int, l : Int ) : Int {
+		return try file_write(__f,s.getData(),p,l) catch( e : Dynamic ) throw haxe.io.Error.Custom(e);
+	}
+
+	public override function flush() {
+		file_flush(__f);
+	}
+
+	public override function close() {
+		super.close();
+		file_close(__f);
+	}
+
+	public function seek( p : Int, pos : FileSeek ) {
+		file_seek(__f,p,switch( pos ) { case SeekBegin: 0; case SeekCur: 1; case SeekEnd: 2; });
+	}
+
+	public function tell() : Int {
+		return file_tell(__f);
+	}
+
+	private static var file_close = cpp.Lib.load("std","file_close",1);
+	private static var file_seek = cpp.Lib.load("std","file_seek",3);
+	private static var file_tell = cpp.Lib.load("std","file_tell",1);
+
+	private static var file_flush = cpp.Lib.load("std","file_flush",1);
+	private static var file_write = cpp.Lib.load("std","file_write",4);
+	private static var file_write_char = cpp.Lib.load("std","file_write_char",2);
+
+}

std/cpp/io/Path.hx

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package cpp.io;
+
+class Path {
+
+	public var ext : String;
+	public var dir : String;
+	public var file : String;
+	public var backslash : Bool;
+
+	public function new( path : String ) {
+		var c1 = path.lastIndexOf("/");
+		var c2 = path.lastIndexOf("\\");
+		if( c1 < c2 ) {
+			dir = path.substr(0,c2);
+			path = path.substr(c2+1);
+			backslash = true;
+		} else if( c2 < c1 ) {
+			dir = path.substr(0,c1);
+			path = path.substr(c1+1);
+		} else
+			dir = null;
+		var cp = path.lastIndexOf(".");
+		if( cp != -1 ) {
+			ext = path.substr(cp+1);
+			file = path.substr(0,cp);
+		} else {
+			ext = null;
+			file = path;
+		}
+	}
+
+	public function toString() {
+		return (if( dir == null ) "" else dir + if( backslash ) "\\" else "/") + file + (if( ext == null ) "" else "." + ext);
+	}
+
+	public static function withoutExtension( path : String ) {
+		var s = new Path(path);
+		s.ext = null;
+		return s.toString();
+	}
+
+	public static function withoutDirectory( path ) {
+		var s = new Path(path);
+		s.dir = null;
+		return s.toString();
+	}
+
+	public static function directory( path ) {
+		var s = new Path(path);
+		if( s.dir == null )
+			return "";
+		return s.dir;
+	}
+
+	public static function extension( path ) {
+		var s = new Path(path);
+		if( s.ext == null )
+			return "";
+		return s.ext;
+	}
+
+	public static function withExtension( path, ext ) {
+		var s = new Path(path);
+		s.ext = ext;
+		return s.toString();
+	}
+
+}