TestReflect running, not yet passing

src/hl.h

@@ -244,6 +244,7 @@ typedef struct {
 	const uchar *name;
 	int nconstructs;
 	hl_enum_construct *constructs;
+	void **global_value;
 } hl_type_enum;
 
 struct hl_type {
@@ -403,6 +404,7 @@ double hl_dyn_castd( void *data, hl_type *t );
 #define hl_invalid_comparison 0xAABBCCDD
 int hl_dyn_compare( vdynamic *a, vdynamic *b );
 vdynamic *hl_make_dyn( void *data, hl_type *t );
+void hl_write_dyn( void *data, hl_type *t, vdynamic *v );
 
 void hl_dyn_seti( vdynamic *d, int hfield, hl_type *t, int value );
 void hl_dyn_setp( vdynamic *d, int hfield, hl_type *t, void *ptr );

src/hlc.h

@@ -67,11 +67,11 @@ static vdynamic *hlc_dyn_call_args( vclosure *c, vdynamic **args, int nargs ) {
 		ctmp.t = c->t->fun->parent;
 		ctmp.hasValue = 0;
 		ctmp.fun = c->fun;
-		c = &ctmp;
 		tmp.args[0] = hl_make_dyn(&c->value,ctmp.t->fun->args[0]);
 		tmp.a.size++;
 		for(i=0;i<nargs;i++)
 			tmp.args[i+1] = args[i];
+		c = &ctmp;
 	} else {
 		for(i=0;i<nargs;i++)
 			tmp.args[i] = args[i];

src/std/buffer.c

@@ -64,7 +64,7 @@ void hl_buffer_str( hl_buffer *b, const uchar *s ) {
 
 void hl_buffer_cstr( hl_buffer *b, const char *s ) {
 	if( s ) {
-		int len = strlen(s);
+		int len = (int)strlen(s);
 		uchar *out = (uchar*)malloc(sizeof(uchar)*(len+1));
 		strtou(out,len,s);
 		hl_buffer_str_sub(b,out,len);

src/std/cast.c

@@ -116,6 +116,10 @@ void *hl_dyn_castp( void *data, hl_type *t, hl_type *to ) {
 		if( v == NULL ) return NULL;
 		t = v->t;
 		if( !hl_is_dynamic(t) ) data = &v->v;
+	} else if( hl_is_dynamic(t) ) {
+		vdynamic *v = *(vdynamic**)data;
+		if( v == NULL ) return NULL;
+		t = v->t;
 	}
 	if( t == to || hl_safe_cast(t,to) )
 		return *(void**)data;
@@ -154,6 +158,10 @@ void *hl_dyn_castp( void *data, hl_type *t, hl_type *to ) {
 	}
 	if( to->kind == HDYN )
 		return hl_make_dyn(data,t);
+	if( to->kind == HNULL ) {
+		if( to->tparam->kind == t->kind )
+			return hl_make_dyn(data,t);
+	}
 	hl_error_msg(USTR("Can't cast %s(%s) to %s"),hl_to_string(hl_make_dyn(data,t)),hl_type_str(t),hl_type_str(to));
 	return 0;
 }
@@ -184,6 +192,32 @@ double hl_dyn_castd( void *data, hl_type *t ) {
 	return 0.;
 }
 
+float hl_dyn_castf( void *data, hl_type *t ) {
+	if( t->kind == HDYN ) {
+		vdynamic *v = *((vdynamic**)data);
+		if( v == NULL ) return 0;
+		t = v->t;
+		if( !hl_is_dynamic(t) ) data = &v->v;
+	}
+	switch( t->kind ) {
+	case HF32:
+		return *(float*)data;
+	case HF64:
+		return (float)*(double*)data;
+	case HI8:
+		return *(char*)data;
+	case HI16:
+		return *(short*)data;
+	case HI32:
+		return (float)*(int*)data;
+	case HBOOL:
+		return *(bool*)data;
+	default:
+		break;
+	}
+	return 0;
+}
+
 static int fcompare( float d ) {
 	if( d != d ) return hl_invalid_comparison;
  	return d == 0.f ? 0 : (d > 0.f ? 1 : -1);
@@ -233,6 +267,30 @@ int hl_dyn_compare( vdynamic *a, vdynamic *b ) {
 	return hl_invalid_comparison;
 }
 
+void hl_write_dyn( void *data, hl_type *t, vdynamic *v ) {
+	switch( t->kind ) {
+	case HI8:
+	case HBOOL:
+		*(char*)data = (char)hl_dyn_casti(&v,&hlt_dyn,t);
+		break;
+	case HI16:
+		*(short*)data = (short)hl_dyn_casti(&v,&hlt_dyn,t);
+		break;
+	case HI32:
+		*(int*)data = hl_dyn_casti(&v,&hlt_dyn,t);
+		break;
+	case HF32:
+		*(float*)data = hl_dyn_castf(&v,&hlt_dyn);
+		break;
+	case HF64:
+		*(double*)data = hl_dyn_castd(&v,&hlt_dyn);
+		break;
+	default:
+		*(void**)data = hl_dyn_castp(&v,&hlt_dyn,t);
+		break;
+	}
+}
+
 HL_PRIM vdynamic* hl_value_cast( vdynamic *v, hl_type *t ) {
 	if( t->kind == HDYN )
 		return v;
@@ -249,3 +307,9 @@ HL_PRIM bool hl_type_check( hl_type *t, vdynamic *value ) {
 	}
 	return hl_safe_cast(value->t, t);
 }
+
+HL_PRIM vdynamic *hl_type_instance( hl_type *t, vdynamic *v ) {
+	if( v == NULL )
+		return v;
+	return hl_safe_cast(v->t,t) ? v : NULL;
+}

src/std/date.c

@@ -19,6 +19,10 @@ static struct tm *gmtime_r( time_t *t, struct tm *r ) {
 
 #endif
 
+HL_PRIM int hl_date_now() {
+	return (int)time(NULL);
+}
+
 HL_PRIM vbyte *hl_date_to_string( int date, int *len ) {
 	char buf[127];
 	struct tm t;

src/std/fun.c

@@ -63,8 +63,33 @@ void *hlc_dyn_call( void *fun, hl_type *t, vdynamic **args );
 
 HL_PRIM vdynamic* hl_call_method( vdynamic *c, varray *args ) {
 	vclosure *cl = (vclosure*)c;
+	int i;
+	vdynamic **vargs = (vdynamic**)(args + 1);
 	if( cl->hasValue ) hl_error("Can't call closure with value");
 	if( args->size != cl->t->fun->nargs || args->at->kind != HDYN ) hl_error("Invalid args");
-	return (vdynamic*)hlc_dyn_call(cl->fun,cl->t,(vdynamic**)(args +1));
+	for(i=0;i<args->size;i++) {
+		vdynamic *v = vargs[i];
+		hl_type *t = cl->t->fun->args[i];
+		if( v == NULL ) {
+			if( hl_is_ptr(t) )
+				continue;
+			v = hl_alloc_dynamic(t);
+			v->v.d = 0;
+			vargs[i] = v;
+		} else if( !hl_safe_cast(v->t,t) )
+			hl_write_dyn(vargs + i, t, v);
+	}
+	return (vdynamic*)hlc_dyn_call(cl->fun,cl->t,vargs);
 }
 
+bool hl_fun_compare( vdynamic *a, vdynamic *b ) {
+	if( a == b )
+		return true;
+	if( !a || !b )
+		return false;
+	if( a->t->kind != b->t->kind || a->t->kind != HFUN )
+		return false;
+	if( ((vclosure*)a)->fun != ((vclosure*)b)->fun )
+		return false;
+	return true;
+}

src/std/string.c

@@ -108,7 +108,6 @@ HL_PRIM vbyte* hl_ucs2_upper( vbyte *str, int pos, int len ) {
 	for(i=0;i<len;i++) {
 		unsigned int c = *cstr++;
 		int up = c >> UL_BITS;
-		int k;
 		if( up < UMAX ) {
 			unsigned int c2 = UPPER[up][c&((1<<UL_BITS)-1)];
 			if( c2 != 0 ) *cout = (uchar)c2;
@@ -127,7 +126,6 @@ HL_PRIM vbyte* hl_ucs2_lower( vbyte *str, int pos, int len ) {
 	for(i=0;i<len;i++) {
 		unsigned int c = *cstr++;
 		int up = c >> UL_BITS;
-		int k;
 		if( up < UMAX ) {
 			unsigned int c2 = LOWER[up][c&((1<<UL_BITS)-1)];
 			if( c2 != 0 ) *cout = (uchar)c2;

src/std/types.c

@@ -289,10 +289,9 @@ HL_PRIM varray *hl_type_instance_fields( hl_type *t ) {
 HL_PRIM vdynamic *hl_type_get_global( hl_type *t ) {
 	switch( t->kind ) {
 	case HOBJ:
-		return *(vdynamic**)t->obj->global_value;
+		return t->obj->global_value ? *(vdynamic**)t->obj->global_value : NULL;
 	case HENUM:
-		hl_fatal("TODO");
-		break;
+		return *(vdynamic**)t->tenum->global_value;
 	default:
 		break;
 	}
@@ -334,6 +333,28 @@ bool hl_type_enum_eq( vdynamic *a, vdynamic *b ) {
 	return true;
 }
 
+HL_PRIM vdynamic *hl_ealloc( hl_type *t, int index, varray *args ) {
+	hl_enum_construct *c = t->tenum->constructs + index;
+	venum *e;
+	vdynamic *v;
+	int i;
+	bool hasPtr = false;
+	if( c->nparams != args->size )
+		return NULL;
+	for(i=0;i<c->nparams;i++)
+		if( hl_is_ptr(c->params[i]) ) {
+			hasPtr = true;
+			break;
+		}
+	e = (venum*)(hasPtr ? hl_gc_alloc(c->size) : hl_gc_alloc_noptr(c->size));
+	e->index = index;
+	for(i=0;i<c->nparams;i++)
+		hl_write_dyn((char*)e+c->offsets[i],c->params[i],((vdynamic**)(args+1))[i]);
+	v = hl_alloc_dynamic(t);
+	v->v.ptr = e;
+	return v;
+}
+
 DEFINE_PRIM(_BOOL, hl_type_check, _TYPE _DYN);
 DEFINE_PRIM(_BYTES, hl_type_name, _TYPE);
 DEFINE_PRIM(_ARR, hl_type_enum_fields, _TYPE);