Changeset 112

Timestamp:

08/19/07 17:19:36 (17 months ago)

Author:

gnue

Message:

The function to call the script from C language is added.

Location:

NEWT0/trunk/src/newt_core

Files:

• NewtGC.c (modified) (1 diff)
• NewtVM.c (modified) (10 diffs)
• incs/NewtEnv.h (modified) (1 diff)
• incs/NewtVM.h (modified) (3 diffs)

NEWT0/trunk/src/newt_core/NewtGC.c

@@ -507 +507 @@
 {
 //    NewtPoolMarkClean(NEWT_POOL);
-    NewtGCMark(&vm_env, NEWT_SWEEP);
+    vm_env_t *  env;
+
+    for (env = &vm_env; env; env = env->next)
+    {
+        NewtGCMark(&vm_env, NEWT_SWEEP);
+    }
+
     NewtPoolSweep(NEWT_POOL, NEWT_SWEEP);
 

NEWT0/trunk/src/newt_core/NewtVM.c

@@ -13 +13 @@
 /* ヘッダファイル */
 #include <stdlib.h>
+#include <stdarg.h>
 
 #include "NewtErrs.h"
@@ -99 +100 @@
 static newtRef      stk_top(void);
 static void         stk_push(newtRefArg value);
+static void         stk_push_varg(int argc, va_list ap);
+static void         stk_push_array(newtRefVar argArray);
 
 static bool         excp_push(newtRefArg sym, newtRefArg pc);
@@ -187 +190 @@
 static void         NVMDumpInstCode(FILE * f, uint8_t * bc, uint32_t pc, uint16_t len);
 
+static void         vm_env_push(vm_env_t * next);
+static void         vm_env_pop(void);
+
 static void         NVMInitREG(void);
 static void         NVMInitSTACK(void);
@@ -204 +210 @@
 
 static newtRef      NVMInterpret2(nps_syntax_node_t * stree, uint32_t numStree, newtErr * errP);
+
+static newtRef      NVMFuncCallWithValist(newtRefArg fn, int argc, va_list ap);
+static newtRef      NVMMessageSendWithValist(newtRefArg impl, newtRefArg receiver, newtRefArg fn, int argc, va_list ap);
 
 
@@ -824 +833 @@
 
 
+/*------------------------------------------------------------------------*/
+/** 可変引数をスタックにプッシュする
+ *
+ * @param argc      [in] 引数の数
+ * @param ap        [in] 可変引数
+ *
+ * @return          なし
+ */
+
+void stk_push_varg(int argc, va_list ap)
+{
+    int     i;
+
+    for (i = 0; i < argc; i++)
+    {
+        stk_push(va_arg(ap, newtRefArg));
+    }
+}
+
+
+/*------------------------------------------------------------------------*/
+/** 配列の要素をスタックにプッシュする
+ *
+ * @param argArray  [in] 引数配列
+ *
+ * @return          なし
+ */
+
+void stk_push_array(newtRefVar argArray)
+{
+    int     numArgs;
+    int     i;
+
+    numArgs = NewtArrayLength(argArray);
+
+    for (i = 0; i < numArgs; i++)
+    {
+        stk_push(NewtGetArraySlot(argArray, i));
+    }
+}
+
+
 #ifndef _MSC_VER
 
@@ -3417 +3468 @@
 #endif
 
+/*------------------------------------------------------------------------*/
+/** VM環境をプッシュする
+ *
+ * @param next      [in] 新しいVM環境
+ *
+ * @return          なし
+ */
+
+void vm_env_push(vm_env_t * next)
+{
+    *next = vm_env;
+    vm_env.next = next;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** VM環境をポップする
+ *
+ * @return          なし
+ */
+
+void vm_env_pop(void)
+{
+    vm_env_t *  next = vm_env.next;
+
+    if (next)
+    {
+        vm_env = *next;
+    }
+}
 
 
@@ -3790 +3871 @@
 newtRef NVMCall(newtRefArg fn, int16_t numArgs, newtErr * errP)
 {
-
     newtRefVar  result = kNewtRefUnbind;
     newtErr     err = kNErrNone;
@@ -3796 +3876 @@
     if (NewtRefIsNotNIL(fn))
     {
+        vm_env_t    saveVM;
+
+        // save the VM
+        vm_env_push(&saveVM);
+
         NVMFnCall(fn, numArgs);
         NVMLoop(CALLSP - 1);
         result = stk_top();
+
+        // restore the VM
+        vm_env_pop();
     }
 
@@ -3988 +4076 @@
 
     /* save the VM */
-    saveVM = vm_env;
-    
+    vm_env_push(&saveVM);
+
     nbArgs = NewtArrayLength(inArgs);
     /* Push the arguments on the stack */
@@ -4003 +4091 @@
 
     /* restore the VM */
-    vm_env = saveVM;
+    vm_env_pop();
 
     return result;
 }
+
+
+/*------------------------------------------------------------------------*/
+/** 関数オブジェクトを va_list で実行
+ *
+ * @param fn        [in] 関数オブジェクト
+ * @param argc      [in] 引数の数
+ * @param ap        [in] va_list
+ *
+ * @return          スタックのトップオブジェクト
+ */
+
+newtRef NVMFuncCallWithValist(newtRefArg fn, int argc, va_list ap)
+{
+    vm_env_t    saveVM;
+    newtRefVar  result;
+
+    // save the VM
+    vm_env_push(&saveVM);
+
+    // Push the arguments on the stack
+    stk_push_varg(argc, ap);
+
+    // Call function
+    NVMFuncCall(fn, argc);
+    NVMLoop(CALLSP - 1);
+    result = stk_top();
+
+    // restore the VM
+    vm_env_pop();
+
+    return result;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** メソッドを va_list で実行
+ *
+ * @param impl      [in] インプリメンタ
+ * @param receiver  [in] レシーバー
+ * @param fn        [in] 関数オブジェクト
+ * @param argc      [in] 引数の数
+ * @param ap        [in] va_list
+ *
+ * @return          スタックのトップオブジェクト
+ */
+
+newtRef NVMMessageSendWithValist(newtRefArg impl, newtRefArg receiver, newtRefArg fn, int argc, va_list ap)
+{
+    newtRefVar  result;
+    vm_env_t    saveVM;
+
+    // save the VM
+    vm_env_push(&saveVM);
+    
+    // Push the arguments on the stack
+    stk_push_varg(argc, ap);
+
+    // Send the message
+    NVMMessageSend(impl, receiver, fn, argc);
+    NVMLoop(CALLSP - 1);
+    result = stk_top();
+
+    /* restore the VM */
+    vm_env_pop();
+
+    return result;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** 関数オブジェクトを可変引数で実行
+ *
+ * @param fn        [in] 関数オブジェクト
+ * @param argc      [in] 引数の数
+ *
+ * @return          スタックのトップオブジェクト
+ */
+
+newtRef NcCall(newtRefArg fn, int argc, ...)
+{
+    newtRefVar  result;
+    va_list     ap;
+
+    va_start(ap, argc);
+    result = NVMFuncCallWithValist(fn, argc, ap);
+    va_end(ap);
+
+    return result;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** 配列を引数にして関数オブジェクトを実行
+ *
+ * @param fn        [in] 関数オブジェクト
+ * @param args      [in] 配列
+ *
+ * @return          スタックのトップオブジェクト
+ */
+
+newtRef NcCallWithArgArray(newtRefArg fn, newtRefArg args)
+{
+    vm_env_t    saveVM;
+    newtRefVar  result;
+    newtErr     err;
+
+    if (! NewtRefIsFrame(args))
+    {
+        return NewtThrow(kNErrNotAFrame, args);
+    }
+
+    // save the VM
+    vm_env_push(&saveVM);
+
+    stk_push_array(args);
+    result = NVMCall(fn, NewtArrayLength(args), &err);
+
+    // restore the VM
+    vm_env_pop();
+
+    return result;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** グローバル関数を可変引数で実行
+ *
+ * @param sym       [in] シンボル
+ * @param argc      [in] 引数の数
+ *
+ * @return          スタックのトップオブジェクト
+ */
+
+newtRef NcCallGlobalFn(newtRefArg sym, int argc, ...)
+{
+    newtRefVar  result;
+    newtRefVar  fn;
+    va_list     ap;
+
+    fn = NcGetGlobalFn(sym);
+    if (NewtRefIsNIL(fn))
+    {
+        return NewtThrow(kNErrUndefinedGlobalFunction, sym);
+    }
+
+    va_start(ap, argc);
+    result = NVMFuncCallWithValist(fn, argc, ap);
+    va_end(ap);
+
+    return result;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** 配列を引数にしてグローバル関数を実行
+ *
+ * @param sym       [in] シンボル
+ * @param args      [in] 配列
+ *
+ * @return          スタックのトップオブジェクト
+ */
+
+newtRef NcCallGlobalFnWithArgArray(newtRefArg sym, newtRefArg args)
+{
+    newtRefVar  fn;
+
+    fn = NcGetGlobalFn(sym);
+    if (NewtRefIsNIL(fn))
+    {
+        return NewtThrow(kNErrUndefinedGlobalFunction, sym);
+    }
+
+    return NcCallWithArgArray(fn, args);
+}
+
+
+/*------------------------------------------------------------------------*/
+/** メソッドを可変引数で実行
+ *
+ * @param receiver  [in] レシーバー
+ * @param sym       [in] シンボル
+ * @param ignore    [in] メソッド未定定義の例外を無視する
+ * @param argc      [in] 引数の数
+ *
+ * @return          スタックのトップオブジェクト
+ */
+
+newtRef NcSend(newtRefArg receiver, newtRefArg sym, bool ignore, int argc, ...)
+{
+    newtRefVar  result = kNewtRefUnbind;
+    newtRefVar  impl;
+    newtRefVar  fn;
+
+    if (! NewtRefIsSymbol(sym))
+    {
+        return NewtThrow(kNErrNotASymbol, sym);
+    }
+
+    if (! NewtRefIsFrame(receiver) && ! NewtRefIsNIL(receiver))
+    {
+        return NewtThrow(kNErrNotAFrame, receiver);
+    }
+
+    impl = NcFullLookupFrame(receiver, sym);
+
+    if (impl != kNewtRefUnbind)
+    {
+        va_list     ap;
+
+        fn = NcGetSlot(impl, sym);
+
+        va_start(ap, argc);
+        result = NVMMessageSendWithValist(impl, receiver, fn, argc, ap);
+        va_end(ap);
+    }
+    else
+    {
+        if (! ignore)
+            return NewtThrow(kNErrUndefinedMethod, sym);
+    }
+
+    return result;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** 配列を引数にしてメソッドを実行
+ *
+ * @param receiver  [in] レシーバー
+ * @param sym       [in] シンボル
+ * @param ignore    [in] メソッド未定定義の例外を無視する
+ * @param args      [in] 配列
+ *
+ * @return          スタックのトップオブジェクト
+ */
+
+newtRef NcSendWithArgArray(newtRefArg receiver, newtRefArg sym, bool ignore, newtRefArg args)
+{
+    newtRefVar  result = kNewtRefUnbind;
+    newtRefVar  impl;
+    newtRefVar  fn;
+
+    if (! NewtRefIsSymbol(sym))
+    {
+        return NewtThrow(kNErrNotASymbol, sym);
+    }
+
+    if (! NewtRefIsFrame(receiver) && ! NewtRefIsNIL(receiver))
+    {
+        return NewtThrow(kNErrNotAFrame, receiver);
+    }
+
+    impl = NcFullLookupFrame(receiver, sym);
+
+    if (impl != kNewtRefUnbind)
+    {
+        fn = NcGetSlot(impl, sym);
+        result = NVMMessageSendWithArgArray(impl, receiver, fn, args);
+    }
+    else
+    {
+        if (! ignore)
+            return NewtThrow(kNErrUndefinedMethod, sym);
+    }
+
+    return result;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** メソッドを可変引数で実行（プロト呼出し）
+ *
+ * @param receiver  [in] レシーバー
+ * @param sym       [in] シンボル
+ * @param ignore    [in] メソッド未定定義の例外を無視する
+ * @param argc      [in] 引数の数
+ *
+ * @return          スタックのトップオブジェクト
+ *
+ * @note            プロト継承のみ行う
+ */
+
+newtRef NcSendProto(newtRefArg receiver, newtRefArg sym, bool ignore, int argc, ...)
+{
+    newtRefVar  result = kNewtRefUnbind;
+    newtRefVar  impl;
+    newtRefVar  fn;
+
+    if (! NewtRefIsSymbol(sym))
+    {
+        return NewtThrow(kNErrNotASymbol, sym);
+    }
+
+    if (! NewtRefIsFrame(receiver) && ! NewtRefIsNIL(receiver))
+    {
+        return NewtThrow(kNErrNotAFrame, receiver);
+    }
+
+    impl = NcProtoLookupFrame(receiver, sym);
+
+    if (impl != kNewtRefUnbind)
+    {
+        va_list     ap;
+
+        fn = NcGetSlot(impl, sym);
+
+        va_start(ap, argc);
+        result = NVMMessageSendWithValist(impl, receiver, fn, argc, ap);
+        va_end(ap);
+    }
+    else
+    {
+        if (! ignore)
+            return NewtThrow(kNErrUndefinedMethod, sym);
+    }
+
+    return result;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** 配列を引数にしてメソッドを実行（プロト呼出し）
+ *
+ * @param receiver  [in] レシーバー
+ * @param sym       [in] シンボル
+ * @param ignore    [in] メソッド未定定義の例外を無視する
+ * @param args      [in] 配列
+ *
+ * @return          スタックのトップオブジェクト
+ *
+ * @note            プロト継承のみ行う
+ */
+
+newtRef NcSendProtoWithArgArray(newtRefArg receiver, newtRefArg sym, bool ignore, newtRefArg args)
+{
+    newtRefVar  result = kNewtRefUnbind;
+    newtRefVar  impl;
+    newtRefVar  fn;
+
+    if (! NewtRefIsSymbol(sym))
+    {
+        return NewtThrow(kNErrNotASymbol, sym);
+    }
+
+    if (! NewtRefIsFrame(receiver) && ! NewtRefIsNIL(receiver))
+    {
+        return NewtThrow(kNErrNotAFrame, receiver);
+    }
+
+    impl = NcProtoLookupFrame(receiver, sym);
+
+    if (impl != kNewtRefUnbind)
+    {
+        fn = NcGetSlot(impl, sym);
+        result = NVMMessageSendWithArgArray(impl, receiver, fn, args);
+    }
+    else
+    {
+        if (! ignore)
+            return NewtThrow(kNErrUndefinedMethod, sym);
+    }
+
+    return result;
+}

NEWT0/trunk/src/newt_core/incs/NewtEnv.h

@@ -41 +41 @@
 
 #define NSNAMEDMP(name)     (NewtMakeNamedMP(#name))        ///< 名前付マジックポインタの作成
-#define NSNAMEDMP0(name)    (NewtSymbolToMP(NSSYM0(name)))  ///< 保管場所から名前付マジックポインタの作成
+#define NSNAMEDMP0(name)    (NewtSymbolToMP(NSSYM0(name)))  ///< 保管場所から名前付マジックポインタを取得
 #define NSMP(n)             (NewtMakeMagicPointer(0, n))    ///< マジックポインタの作成
 

NEWT0/trunk/src/newt_core/incs/NewtVM.h

@@ -19 +19 @@
 #include "NewtType.h"
 #include "NewtMem.h"
+
+
+/* マクロ */
+#define NcCall0(fn)                                                 NcCall(fn, 0)
+#define NcCall1(fn, a1)                                             NcCall(fn, 1, a1)
+#define NcCall2(fn, a1, a2)                                         NcCall(fn, 2, a1, a2)
+#define NcCall3(fn, a1, a2, a3)                                     NcCall(fn, 3, a1, a2, a3)
+#define NcCall4(fn, a1, a2, a3, a4)                                 NcCall(fn, 4, a1, a2, a3, a4)
+#define NcCall5(fn, a1, a2, a3, a4, a5)                             NcCall(fn, 5, a1, a2, a3, a4, a5)
+
+#define NcCallGlobalFn0(sym)                                        NcCallGlobalFn(sym, 0)
+#define NcCallGlobalFn1(sym, a1)                                    NcCallGlobalFn(sym, 1, a1)
+#define NcCallGlobalFn2(sym, a1, a2)                                NcCallGlobalFn(sym, 2, a1, a2)
+#define NcCallGlobalFn3(sym, a1, a2, a3)                            NcCallGlobalFn(sym, 3, a1, a2, a3)
+#define NcCallGlobalFn4(sym, a1, a2, a3, a4)                        NcCallGlobalFn(sym, 4, a1, a2, a3, a4)
+#define NcCallGlobalFn5(sym, a1, a2, a3, a4, a5)                    NcCallGlobalFn(sym, 5, a1, a2, a3, a4, a5)
+
+#define NcSend0(receiver, sym)                                      NcSend(receiver, sym, false, 0)
+#define NcSend1(receiver, sym, a1)                                  NcSend(receiver, sym, false, 1, a1)
+#define NcSend2(receiver, sym, a1, a2)                              NcSend(receiver, sym, false, 2, a1, a2)
+#define NcSend3(receiver, sym, a1, a2, a3)                          NcSend(receiver, sym, false, 3, a1, a2, a3)
+#define NcSend4(receiver, sym, a1, a2, a3, a4)                      NcSend(receiver, sym, false, 4, a1, a2, a3, a4)
+#define NcSend5(receiver, sym, a1, a2, a3, a4, a5)                  NcSend(receiver, sym, false, 5, a1, a2, a3, a4, a5)
+
+#define NcSendIfDefined0(receiver, sym)                             NcSend(receiver, sym, true, 0)
+#define NcSendIfDefined1(receiver, sym, a1)                         NcSend(receiver, sym, true, 1, a1)
+#define NcSendIfDefined2(receiver, sym, a1, a2)                     NcSend(receiver, sym, true, 2, a1, a2)
+#define NcSendIfDefined3(receiver, sym, a1, a2, a3)                 NcSend(receiver, sym, true, 3, a1, a2, a3)
+#define NcSendIfDefined4(receiver, sym, a1, a2, a3, a4)             NcSend(receiver, sym, true, 4, a1, a2, a3, a4)
+#define NcSendIfDefined5(receiver, sym, a1, a2, a3, a4, a5)         NcSend(receiver, sym, true, 5, a1, a2, a3, a4, a5)
+
+#define NcSendProto0(receiver, sym)                                 NcSendProto(receiver, sym, false, 0)
+#define NcSendProto1(receiver, sym, a1)                             NcSendProto(receiver, sym, false, 1, a1)
+#define NcSendProto2(receiver, sym, a1, a2)                         NcSendProto(receiver, sym, false, 2, a1, a2)
+#define NcSendProto3(receiver, sym, a1, a2, a3)                     NcSendProto(receiver, sym, false, 3, a1, a2, a3)
+#define NcSendProto4(receiver, sym, a1, a2, a3, a4)                 NcSendProto(receiver, sym, false, 4, a1, a2, a3, a4)
+#define NcSendProto5(receiver, sym, a1, a2, a3, a4, a5)             NcSendProto(receiver, sym, false, 5, a1, a2, a3, a4, a5)
+
+#define NcSendProtoIfDefined0(receiver, sym)                        NcSendProto(receiver, sym, true, 0)
+#define NcSendProtoIfDefined1(receiver, sym, a1)                    NcSendProto(receiver, sym, true, 1, a1)
+#define NcSendProtoIfDefined2(receiver, sym, a1, a2)                NcSendProto(receiver, sym, true, 2, a1, a2)
+#define NcSendProtoIfDefined3(receiver, sym, a1, a2, a3)            NcSendProto(receiver, sym, true, 3, a1, a2, a3)
+#define NcSendProtoIfDefined4(receiver, sym, a1, a2, a3, a4)        NcSendProto(receiver, sym, true, 4, a1, a2, a3, a4)
+#define NcSendProtoIfDefined5(receiver, sym, a1, a2, a3, a4, a5)    NcSendProto(receiver, sym, true, 5, a1, a2, a3, a4, a5)
 
 
@@ -60 +104 @@
 
 /// VM 実行環境
-typedef struct {
+typedef struct vm_env_t {
     // バイトコード
-    uint8_t *   bc;         ///< バイトコード
-    uint32_t    bclen;      ///< バイトコードの長さ
+    uint8_t *   bc;             ///< バイトコード
+    uint32_t    bclen;          ///< バイトコードの長さ
 
     // レジスタ
-    vm_reg_t    reg;        ///< レジスタ
+    vm_reg_t    reg;            ///< レジスタ
 
     // スタック
-    newtStack   stack;      ///< スタック
-    newtStack   callstack;  ///< 関数呼出しスタック
-    newtStack   excpstack;  ///< 例外ハンドラ・スタック
+    newtStack   stack;          ///< スタック
+    newtStack   callstack;      ///< 関数呼出しスタック
+    newtStack   excpstack;      ///< 例外ハンドラ・スタック
 
     // 例外
-    newtRefVar  currexcp;   ///< 現在の例外
+    newtRefVar  currexcp;       ///< 現在の例外
 
     // VM 管理
-    uint16_t    level;      ///< VM呼出しレベル
+    uint16_t    level;          ///< VM呼出しレベル
+    struct vm_env_t *   next;   ///< VM 実行環境のチェイン
 } vm_env_t;
 
@@ -121 +166 @@
                 newtRefArg inFunction, newtRefArg inArgs);
 
+newtRef     NcCall(newtRefArg fn, int argc, ...);
+newtRef     NcCallWithArgArray(newtRefArg fn, newtRefArg args);
+newtRef     NcCallGlobalFn(newtRefArg sym, int argc, ...);
+newtRef     NcCallGlobalFnWithArgArray(newtRefArg sym, newtRefArg args);
+
+newtRef     NcSend(newtRefArg receiver, newtRefArg sym, bool ignore, int argc, ...);
+newtRef     NcSendWithArgArray(newtRefArg receiver, newtRefArg sym, bool ignore, newtRefArg args);
+newtRef     NcSendProto(newtRefArg receiver, newtRefArg sym, bool ignore, int argc, ...);
+newtRef     NcSendProtoWithArgArray(newtRefArg receiver, newtRefArg sym, bool ignore, newtRefArg args);
+
+
 #ifdef __cplusplus
 }