cppbind.Ghost: clean up a bit

[simgear.git] / simgear / nasal / code.c

diff --git a/simgear/nasal/code.c b/simgear/nasal/code.c
index 08d710f81f6014edce893b2d13b8a3fce9f85ff3..5f94217f45d403c769a5f898294994587f3fc99b 100644 (file)
--- a/simgear/nasal/code.c
+++ b/simgear/nasal/code.c
@@ -180,6 +180,8 @@ static void initGlobals()
 
     globals->symbols = naNewHash(c);
     globals->save = naNewVector(c);
+    globals->save_hash = naNewHash(c);
+    globals->next_gc_key = 0;
 
     // Cache pre-calculated "me", "arg" and "parents" scalars
     globals->meRef = naInternSymbol(naStr_fromdata(naNewString(c), "me", 2));
@@ -313,7 +315,10 @@ static struct Frame* setupFuncall(naContext ctx, int nargs, int mcall, int named
     ctx->opFrame = opf;
 
     if(IS_CCODE(code)) {
-        naRef result = (*PTR(code).ccode->fptr)(ctx, obj, nargs, args);
+        struct naCCode *ccode = PTR(code).ccode;
+        naRef result = ccode->fptru
+                     ? (*ccode->fptru)(ctx, obj, nargs, args, ccode->user_data)
+                     : (*ccode->fptr)(ctx, obj, nargs, args);
         if(named) ERR(ctx, "native functions have no named arguments");
         ctx->opTop = ctx->opFrame;
         PUSH(result);
@@ -441,14 +446,17 @@ static const char* getMember_r(naContext ctx, naRef obj, naRef field, naRef* out
     naRef p;
     struct VecRec* pv;
     if(--count < 0) return "too many parents";
-    if(!IS_HASH(obj) && !IS_GHOST(obj)) return "non-objects have no members";
-    
+
     if (IS_GHOST(obj)) {
         if (ghostGetMember(ctx, obj, field, out)) return "";
         if(!ghostGetMember(ctx, obj, globals->parentsRef, &p)) return 0;
-    } else {
+    } else if (IS_HASH(obj)) {
         if(naHash_get(obj, field, out)) return "";
         if(!naHash_get(obj, globals->parentsRef, &p)) return 0;
+    } else if (IS_STR(obj) ) {
+        return getMember_r(ctx, getStringMethods(ctx), field, out, count);
+    } else {
+        return "non-objects have no members";
     }
     
     if(!IS_VEC(p)) return "object \"parents\" field not vector";
@@ -759,6 +767,27 @@ void naSave(naContext ctx, naRef obj)
     naVec_append(globals->save, obj);
 }
 
+int naGCSave(naRef obj)
+{
+  int key = globals->next_gc_key++;
+  naHash_set(globals->save_hash, naNum(key), obj);
+  return key;
+}
+
+void naGCRelease(int key)
+{
+  naHash_delete(globals->save_hash, naNum(key));
+}
+
+void naClearSaved()
+{
+    naContext c;
+    c = naNewContext();
+    globals->save = naNewVector(c);
+    globals->save_hash = naNewHash(c);
+    naFreeContext(c);
+}
+
 int naStackDepth(naContext ctx)
 {
     return ctx ? ctx->fTop + naStackDepth(ctx->callChild): 0;
@@ -845,8 +874,10 @@ naRef naCall(naContext ctx, naRef func, int argc, naRef* args,
     }
 
     if(IS_CCODE(PTR(func).func->code)) {
-        naCFunction fp = PTR(PTR(func).func->code).ccode->fptr;
-        result = (*fp)(ctx, obj, argc, args);
+        struct naCCode *ccode = PTR(PTR(func).func->code).ccode;
+        result = ccode->fptru
+               ? (*ccode->fptru)(ctx, obj, argc, args, ccode->user_data)
+               : (*ccode->fptr) (ctx, obj, argc, args);
         if(!ctx->callParent) naModUnlock();
         return result;
     }
@@ -907,3 +938,52 @@ naRef naContinue(naContext ctx)
     if(!ctx->callParent) naModUnlock();
     return result;
 }
+
+static void logError(naContext ctx)
+{
+    int i, stack_depth = naStackDepth(ctx);
+    printf("Nasal runtime error: %s\n", naGetError(ctx));
+    if( stack_depth < 1 )
+        return;
+    printf("  at %s\n", naStr_data(naGetSourceFile(ctx, 0)));
+    printf(", line %d\n", naGetLine(ctx, 0));
+    for(i = 1; i < stack_depth; ++i )
+        printf( "  called from: %s, line %d",
+                naStr_data(naGetSourceFile(ctx, i)),
+                naGetLine(ctx, i));
+}
+
+static naErrorHandler error_handler = &logError;
+naErrorHandler naSetErrorHandler(naErrorHandler cb)
+{
+  naErrorHandler old_handler = error_handler;
+  error_handler = cb;
+  return old_handler;
+}
+
+static int call_count = 0;
+naRef naCallMethodCtx( naContext ctx,
+                       naRef code,
+                       naRef self,
+                       int argc,
+                       naRef* args,
+                       naRef locals )
+{
+    naRef result;
+    if(call_count) naModUnlock();
+    call_count++;
+    result = naCall(ctx, code, argc, args, self, locals);
+    if(naGetError(ctx) && error_handler)
+        error_handler(ctx);
+    call_count--;
+    if(call_count) naModLock();
+    return result;
+}
+
+naRef naCallMethod(naRef code, naRef self, int argc, naRef* args, naRef locals)
+{
+    naContext ctx = naNewContext();
+    naRef result = naCallMethodCtx(ctx, code, self, argc, args, locals);
+    naFreeContext(ctx);
+    return result;
+}