added : String ok, Array missing methods

std/neko/Boot.hx

@@ -0,0 +1,11 @@
+class Boot {
+
+
+	private static function __init() {
+		untyped {
+			String = NekoString__;
+			//Array = NekoArray__;
+		}
+	}
+
+}

std/neko/Lib.hx

@@ -0,0 +1,7 @@
+class Neko {
+
+	public static function load( lib : String, prim : String, nargs : Int ) : Dynamic {
+		return untyped __dollar__loader.loadprim((lib+"@"+prim).__s,nargs);
+	}
+
+}

std/neko/NekoArray__.hx

@@ -0,0 +1,83 @@
+
+class NekoArray__<T> implements Array<T> {
+
+	public var length : Int;
+
+	private function new() {
+	}
+
+	private static function new1(a) {
+		untyped {
+			if( __dollar__typeof(a) != __dollar__tarray )
+				__dollar__throw(a);
+			var arr = new Array<Dynamic>();
+			arr.__a = a;
+			arr.length = __dollar__asize(a);
+			return arr;
+		}
+	}
+
+	public function concat(arr) {
+		untyped {
+			var a1 = this.__a;
+			var a2 = arr.__a;
+			var s1 = __dollar__asize(a1);
+			var s2 = __dollar__asize(a2);
+			var a = __dollar__amake(s1+s2);
+			__dollar__ablit(a,0,a1,0,s1);
+			__dollar__ablit(a,s1,a2,0,s2);
+			return Array.new1(a);
+		}
+	}
+
+	public function copy() {
+		return untyped Array.new1(__dollar__acopy(this.__a));
+	}
+
+	public function indexes() {
+		return untyped {
+			a : this.__arr,
+			p : 0,
+			l : this.length,
+			hasNext : function() {
+				while( this.p < this.l ) {
+					if( this.a[this.p] != null )
+						return true;
+					this.p += 1;
+				}
+				return false;
+			},
+			next : function() {
+				var i = this.p;
+				this.p += 1;
+				return i;
+			}
+		};
+	}
+
+	public function iterator() {
+		return untyped {
+			a : this.__arr,
+			p : 0,
+			l : this.length,
+			hasNext : function() {
+				while( this.p < this.l ) {
+					if( this.a[this.p] != null )
+						return true;
+					this.p += 1;
+				}
+				return false;
+			},
+			next : function() {
+				var i = this.a[this.p];
+				this.p += 1;
+				return i;
+			}
+		};
+	}
+
+	public function insert( pos, x ) {
+		//
+	}
+
+}

std/neko/NekoString__.hx

@@ -0,0 +1,118 @@
+class NekoString__ implements String {
+
+	private static var __split : Dynamic = Neko.load("std","string_split",2);
+
+	public var length : Int;
+
+	private function new(s) {
+		untyped {
+			if( __dollar__typeof(s) != __dollar__tstring )
+				s = __dollar__string(s);
+			this.__s = s;
+			this.length = __dollar__ssize(s);
+		}
+	}
+
+	public function charAt(p) {
+		untyped {
+			var s = __dollar__smake(1);
+			__dollar__sset(s,0,__dollar__sget(this.__s,p));
+			return new String(s);
+		}
+	}
+
+	public function charCodeAt(p) {
+		untyped {
+			return __dollar__sget(this.__s,p);
+		}
+	}
+
+	public function indexOf( str, pos ) {
+		untyped {
+			var p = __dollar__sfind(this.__s,pos,str.__s);
+			if( p == null )
+				return -1;
+			return p;
+		}
+	}
+
+	public function lastIndexOf( str, pos ) {
+		untyped {
+			var last = -1;
+			while( true ) {
+				var p = __dollar__sfind(this.__s,last + 1,str.__s);
+				if( p == null )
+					return last;
+				last = p;
+			}
+			return null;
+		}
+	}
+
+	public function split( delim ) {
+		untyped {
+			var l = __split(this.__s,delim.__s);
+			var a = new Array<String>();
+			while( l != null ) {
+				a.push(new String(l[0]));
+				l = l[1];
+			}
+			return a;
+		}
+	}
+
+	public function substr( pos, len ) {
+		return untyped new String(__dollar__ssub(this.__s,pos,len));
+	}
+
+	public function toLowerCase() {
+		untyped {
+			var s = this.__s;
+			var l = this.length;
+			var s2 = __dollar__scopy(s);
+			var i = 0;
+			while( i < l ) {
+				var c = __dollar__sget(s,i);
+				if( c >= 65 && c <= 90 )
+					__dollar__sset(s2,i,c-65+97);
+				i++;
+			}
+			return new String(s2);
+		}
+	}
+
+	public function toUpperCase() {
+		untyped {
+			var s = this.__s;
+			var l = this.length;
+			var s2 = __dollar__scopy(s);
+			var i = 0;
+			while( i < l ) {
+				var c = __dollar__sget(s,i);
+				if( c >= 97 && c <= 122 )
+					__dollar__sset(s2,i,c-97+65);
+				i++;
+			}
+			return new String(s2);
+		}
+	}
+
+	/* NEKO INTERNALS */
+
+	private function __string() {
+		return untyped this.__s;
+	}
+
+	private function __compare(o) {
+		return untyped __compare__(this.__s,o.__s);
+	}
+
+	private function __add(s) {
+		return untyped new String(this.__s+__dollar__string(s));
+	}
+
+	private function __radd(s) {
+		return untyped new String(__dollar__string(s)+this.__s);
+	}
+
+}