vm                 89 ext/threads/mutex.c     ScmVM *vm;
vm                 95 ext/threads/mutex.c     vm = mutex->owner;
vm                102 ext/threads/mutex.c         if (vm) {
vm                103 ext/threads/mutex.c             if (vm->state == SCM_VM_TERMINATED) {
vm                106 ext/threads/mutex.c                 Scm_Printf(port, "locked/owned by %S>", vm);
vm                 67 ext/threads/threads.c     ScmVM *current = Scm_VM(), *vm;
vm                 72 ext/threads/threads.c     vm = Scm_NewVM(current, name);
vm                 73 ext/threads/threads.c     vm->thunk = thunk;
vm                 74 ext/threads/threads.c     vm->defaultEscapeHandler = SCM_OBJ(&thread_error_handler_STUB);
vm                 75 ext/threads/threads.c     return SCM_OBJ(vm);
vm                 94 ext/threads/threads.c     ScmVM *vm = SCM_VM(data);
vm                 99 ext/threads/threads.c     if (pthread_mutex_lock(&vm->vmlock) == EDEADLK) {
vm                102 ext/threads/threads.c     vm->state = SCM_VM_TERMINATED;
vm                103 ext/threads/threads.c     if (vm->canceller) {
vm                105 ext/threads/threads.c         exc = Scm_MakeThreadException(SCM_CLASS_TERMINATED_THREAD_EXCEPTION, vm);
vm                106 ext/threads/threads.c         SCM_THREAD_EXCEPTION(exc)->data = SCM_OBJ(vm->canceller);
vm                107 ext/threads/threads.c         vm->resultException = exc;
vm                109 ext/threads/threads.c     pthread_cond_broadcast(&vm->cond);
vm                110 ext/threads/threads.c     pthread_mutex_unlock(&vm->vmlock);
vm                115 ext/threads/threads.c     ScmVM *vm = SCM_VM(data);
vm                116 ext/threads/threads.c     pthread_cleanup_push(thread_cleanup, vm);
vm                117 ext/threads/threads.c     if (pthread_setspecific(Scm_VMKey(), vm) != 0) {
vm                119 ext/threads/threads.c         vm->resultException =
vm                123 ext/threads/threads.c             vm->result = Scm_Apply(SCM_OBJ(vm->thunk), SCM_NIL);
vm                126 ext/threads/threads.c             switch (vm->escapeReason) {
vm                129 ext/threads/threads.c                 vm->resultException =
vm                135 ext/threads/threads.c                 exc = Scm_MakeThreadException(SCM_CLASS_UNCAUGHT_EXCEPTION, vm);
vm                136 ext/threads/threads.c                 SCM_THREAD_EXCEPTION(exc)->data = SCM_OBJ(vm->escapeData[1]);
vm                137 ext/threads/threads.c                 vm->resultException = exc;
vm                138 ext/threads/threads.c                 Scm_ReportError(SCM_OBJ(vm->escapeData[1]));
vm                154 ext/threads/threads.c ScmObj Scm_ThreadStart(ScmVM *vm)
vm                161 ext/threads/threads.c     (void)SCM_INTERNAL_MUTEX_LOCK(vm->vmlock);
vm                162 ext/threads/threads.c     if (vm->state != SCM_VM_NEW) {
vm                165 ext/threads/threads.c         SCM_ASSERT(vm->thunk);
vm                166 ext/threads/threads.c         vm->state = SCM_VM_RUNNABLE;
vm                170 ext/threads/threads.c         if (pthread_create(&vm->thread, &thattr, thread_entry, vm) != 0) {
vm                171 ext/threads/threads.c             vm->state = SCM_VM_NEW;
vm                177 ext/threads/threads.c     (void)SCM_INTERNAL_MUTEX_UNLOCK(vm->vmlock);
vm                178 ext/threads/threads.c     if (err_state) Scm_Error("attempt to start an already-started thread: %S", vm);
vm                179 ext/threads/threads.c     if (err_create) Scm_Error("couldn't start a new thread: %S", vm);
vm                183 ext/threads/threads.c     return SCM_OBJ(vm);
vm                266 ext/threads/threads.c     ScmVM *vm = Scm_VM();
vm                267 ext/threads/threads.c     if (target == vm) {
vm                271 ext/threads/threads.c             target->canceller = vm;
vm                282 ext/threads/threads.c             target->canceller = vm;
vm                 44 ext/threads/threads.h extern ScmObj Scm_ThreadStart(ScmVM *vm);
vm                 45 ext/threads/threads.h extern ScmObj Scm_ThreadJoin(ScmVM *vm, ScmObj timeout, ScmObj timeoutval);
vm                 48 ext/threads/threads.h extern ScmObj Scm_ThreadTerminate(ScmVM *vm);
vm                 55 ext/threads/thrlib.c   ScmVM* vm;
vm                 59 ext/threads/thrlib.c   vm = SCM_VM(vm_scm);
vm                 63 ext/threads/thrlib.c  SCM_RESULT = (vm->name);
vm                 75 ext/threads/thrlib.c   ScmVM* vm;
vm                 79 ext/threads/thrlib.c   vm = SCM_VM(vm_scm);
vm                 83 ext/threads/thrlib.c  SCM_RESULT = (vm->specific);
vm                 95 ext/threads/thrlib.c   ScmVM* vm;
vm                101 ext/threads/thrlib.c   vm = SCM_VM(vm_scm);
vm                105 ext/threads/thrlib.c vm->specific = obj;
vm                147 ext/threads/thrlib.c   ScmVM* vm;
vm                151 ext/threads/thrlib.c   vm = SCM_VM(vm_scm);
vm                155 ext/threads/thrlib.c SCM_RESULT = Scm_ThreadStart(vm);
vm                201 ext/threads/thrlib.c   ScmVM* vm;
vm                212 ext/threads/thrlib.c   vm = SCM_VM(vm_scm);
vm                228 ext/threads/thrlib.c SCM_RESULT = Scm_ThreadJoin(vm, timeout, timeout_val);
vm                240 ext/threads/thrlib.c   ScmVM* vm;
vm                244 ext/threads/thrlib.c   vm = SCM_VM(vm_scm);
vm                248 ext/threads/thrlib.c SCM_RESULT = Scm_ThreadTerminate(vm);
vm                865 src/class.c    static void lock_class_redefinition(ScmVM *vm)
vm                868 src/class.c        if (class_redefinition_lock.owner == vm) {
vm                872 src/class.c            while (class_redefinition_lock.owner != vm) {
vm                874 src/class.c                    class_redefinition_lock.owner = vm;
vm                878 src/class.c                    class_redefinition_lock.owner = vm;
vm                892 src/class.c    static void unlock_class_redefinition(ScmVM *vm)
vm                894 src/class.c        if (class_redefinition_lock.owner != vm) return;
vm                904 src/class.c        ScmVM *vm;
vm                909 src/class.c        vm = Scm_VM();
vm                912 src/class.c        lock_class_redefinition(vm);
vm                917 src/class.c            klass->redefined = SCM_OBJ(vm);
vm                923 src/class.c            unlock_class_redefinition(vm);
vm                931 src/class.c        ScmVM *vm;
vm                938 src/class.c        vm = Scm_VM();
vm                947 src/class.c        if (SCM_EQ(klass->redefined, SCM_OBJ(vm))) {
vm                954 src/class.c        unlock_class_redefinition(vm);
vm                107 src/code.c         ScmVM *vm;
vm                112 src/code.c         vm = Scm_VM();
vm                113 src/code.c         vm->base = cs[0];
vm                114 src/code.c         vm->pc = vm->base->code;
vm                225 src/core.c         ScmVM *vm = Scm_VM();
vm                226 src/core.c         vm->queueNotEmpty |= SCM_VM_FINQ_MASK;
vm                230 src/core.c     ScmObj Scm_VMFinalizerRun(ScmVM *vm)
vm                233 src/core.c         vm->queueNotEmpty &= ~SCM_VM_FINQ_MASK;
vm                296 src/core.c         ScmVM *vm = Scm_VM();
vm                304 src/core.c         SCM_FOR_EACH(hp, vm->handlers) {
vm                305 src/core.c             vm->handlers = SCM_CDR(hp);
vm                490 src/error.c        ScmVM *vm = Scm_VM();
vm                493 src/error.c        if (SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_ERROR_BEING_HANDLED)) {
vm                495 src/error.c            Scm_VMThrowException(vm, e);
vm                497 src/error.c        SCM_VM_RUNTIME_FLAG_SET(vm, SCM_ERROR_BEING_HANDLED);
vm                511 src/error.c        Scm_VMThrowException(vm, e);
vm                552 src/error.c        ScmVM *vm = Scm_VM();
vm                570 src/error.c        Scm_VMThrowException(vm, e);
vm                587 src/error.c        ScmVM *vm = Scm_VM();
vm                631 src/error.c        Scm_VMThrowException(vm, e);
vm                693 src/error.c        ScmVM *vm = Scm_VM();
vm                829 src/error.c    static void report_error_inner(ScmVM *vm, ScmObj e)
vm                831 src/error.c        ScmObj stack = Scm_VMGetStackLite(vm);
vm                832 src/error.c        ScmPort *err = SCM_VM_CURRENT_ERROR_PORT(vm);
vm                845 src/error.c        ScmVM *vm = Scm_VM();
vm                847 src/error.c        if (SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_ERROR_BEING_REPORTED)) {
vm                861 src/error.c        SCM_VM_RUNTIME_FLAG_SET(vm, SCM_ERROR_BEING_REPORTED);
vm                863 src/error.c            if (SCM_PROCEDUREP(vm->defaultEscapeHandler)) {
vm                864 src/error.c                Scm_Apply(vm->defaultEscapeHandler, SCM_LIST1(e));
vm                866 src/error.c                report_error_inner(vm, e);
vm                873 src/error.c            SCM_VM_RUNTIME_FLAG_CLEAR(vm, SCM_ERROR_BEING_REPORTED);
vm                876 src/error.c        SCM_VM_RUNTIME_FLAG_CLEAR(vm, SCM_ERROR_BEING_REPORTED);
vm               5282 src/extlib.c   ScmVM *vm = SCM_VM(obj);
vm               5284 src/extlib.c       switch (vm->state) {
vm               5291 src/extlib.c       Scm_Printf(port, "#<thread %S %s %p>", vm->name, state, vm);
vm               5329 src/extlib.c     ScmObj vm;
vm               5339 src/extlib.c     vm = (vm_scm);
vm               5341 src/extlib.c    if (vm == SCM_UNBOUND) vm = SCM_OBJ(Scm_VM());
vm               5342 src/extlib.c     else if (!SCM_VMP(vm)) Scm_Error("VM object required, got %S", vm);
vm               5343 src/extlib.c     Scm_VMDump(SCM_VM(vm));
vm               5354 src/extlib.c     ScmObj vm;
vm               5364 src/extlib.c     vm = (vm_scm);
vm               5366 src/extlib.c    if (vm == SCM_UNBOUND) vm = SCM_OBJ(Scm_VM());
vm               5367 src/extlib.c     else if (!SCM_VMP(vm)) Scm_Error("VM object required, got %S", vm);
vm               5368 src/extlib.c     SCM_RETURN(Scm_VMGetStack(SCM_VM(vm)));
vm               5378 src/extlib.c     ScmObj vm;
vm               5388 src/extlib.c     vm = (vm_scm);
vm               5390 src/extlib.c    if (vm == SCM_UNBOUND) vm = SCM_OBJ(Scm_VM());
vm               5391 src/extlib.c     else if (!SCM_VMP(vm)) Scm_Error("VM object required, got %S", vm);
vm               5392 src/extlib.c     SCM_RETURN(Scm_VMGetStackLite(SCM_VM(vm)));
vm               5402 src/extlib.c     ScmObj vm;
vm               5407 src/extlib.c     vm = (vm_scm);
vm               5411 src/extlib.c     if (!SCM_VMP(vm)) Scm_Error("VM object required, got %S", vm);
vm               5415 src/extlib.c     SCM_VM(vm)->defaultEscapeHandler = handler;
vm                391 src/gauche.h   #define SCM_VM_CURRENT_INPUT_PORT(vm)   (SCM_VM(vm)->curin)
vm                392 src/gauche.h   #define SCM_VM_CURRENT_OUTPUT_PORT(vm)  (SCM_VM(vm)->curout)
vm                393 src/gauche.h   #define SCM_VM_CURRENT_ERROR_PORT(vm)   (SCM_VM(vm)->curerr)
vm                415 src/gauche.h   SCM_EXTERN ScmObj Scm_VMGetResult(ScmVM *vm);
vm                416 src/gauche.h   SCM_EXTERN ScmObj Scm_VMGetStackLite(ScmVM *vm);
vm                417 src/gauche.h   SCM_EXTERN ScmObj Scm_VMGetStack(ScmVM *vm);
vm                 78 src/gauche/port.h #define PORT_LOCK(p, vm)                                        \
vm                 81 src/gauche/port.h         if (p->lockOwner != vm) {                               \
vm                 89 src/gauche/port.h           p->lockOwner = vm;                                    \
vm                123 src/gauche/port.h #define PORT_LOCKED(p, vm) \
vm                124 src/gauche/port.h    (((p)->flags&SCM_PORT_PRIVATE)||((p)->lockOwner == (vm)))
vm                130 src/gauche/port.h #define PORT_PRELOCK(p, vm)                     \
vm                132 src/gauche/port.h      p->lockOwner = vm;                         \
vm                126 src/gauche/prof.h SCM_EXTERN void Scm_ProfilerCountBufferFlush(ScmVM *vm);
vm                129 src/gauche/prof.h #define SCM_PROF_COUNT_CALL(vm, obj)                                    \
vm                131 src/gauche/prof.h         if (vm->profilerRunning) {                                      \
vm                132 src/gauche/prof.h             if (vm->prof->currentCount == SCM_PROF_COUNTER_IN_BUFFER) { \
vm                133 src/gauche/prof.h                 Scm_ProfilerCountBufferFlush(vm);                       \
vm                135 src/gauche/prof.h             vm->prof->counts[vm->prof->currentCount++].func = obj;      \
vm                139 src/gauche/prof.h #define SCM_PROF_COUNT_CALL(vm, obj)  /*empty*/
vm                233 src/gauche/vm.h #define SCM_VM_FLOATING_EP(vm) \
vm                234 src/gauche/vm.h     ((vm)->escapePoint? (vm)->escapePoint->floating : vm->escapePointFloating)
vm                235 src/gauche/vm.h #define SCM_VM_FLOATING_EP_SET(vm, ep)          \
vm                237 src/gauche/vm.h         if ((vm)->escapePoint) {                \
vm                238 src/gauche/vm.h             (vm)->escapePoint->floating = (ep); \
vm                240 src/gauche/vm.h             (vm)->escapePointFloating = (ep);   \
vm                268 src/gauche/vm.h SCM_EXTERN int Scm_MakeParameterSlot(ScmVM *vm, int *newid);
vm                269 src/gauche/vm.h SCM_EXTERN ScmObj Scm_ParameterRef(ScmVM *vm, int index, int id);
vm                270 src/gauche/vm.h SCM_EXTERN ScmObj Scm_ParameterSet(ScmVM *vm, int index, int id, ScmObj value);
vm                294 src/gauche/vm.h #define SCM_SIGPENDING(vm) \
vm                295 src/gauche/vm.h     ((vm)->queueNotEmpty&SCM_VM_SIGQ_MASK)
vm                297 src/gauche/vm.h #define SCM_SIGCHECK(vm) \
vm                298 src/gauche/vm.h     do { if (vm->queueNotEmpty&SCM_VM_SIGQ_MASK) Scm_SigCheck(vm); } while (0)
vm                300 src/gauche/vm.h SCM_EXTERN void   Scm_SigCheck(ScmVM *vm);
vm                312 src/gauche/vm.h SCM_EXTERN ScmObj Scm_VMFinalizerRun(ScmVM *vm);
vm                437 src/gauche/vm.h SCM_EXTERN int    Scm_AttachVM(ScmVM *vm);
vm                438 src/gauche/vm.h SCM_EXTERN void   Scm_VMDump(ScmVM *vm);
vm                440 src/gauche/vm.h SCM_EXTERN ScmObj Scm_VMThrowException(ScmVM *vm, ScmObj exc);
vm                548 src/gauche/vm.h #define SCM_VM_RUNTIME_FLAG_IS_SET(vm, flag) ((vm)->runtimeFlags & (flag))
vm                549 src/gauche/vm.h #define SCM_VM_RUNTIME_FLAG_SET(vm, flag)    ((vm)->runtimeFlags |= (flag))
vm                550 src/gauche/vm.h #define SCM_VM_RUNTIME_FLAG_CLEAR(vm, flag)  ((vm)->runtimeFlags &= ~(flag))
vm                588 src/gauche/vm.h #define SCM_VM_COMPILER_FLAG_IS_SET(vm, flag) ((vm)->compilerFlags & (flag))
vm                589 src/gauche/vm.h #define SCM_VM_COMPILER_FLAG_SET(vm, flag)    ((vm)->compilerFlags |= (flag))
vm                590 src/gauche/vm.h #define SCM_VM_COMPILER_FLAG_CLEAR(vm, flag)  ((vm)->compilerFlags &= ~(flag))
vm                126 src/load.c         ScmVM *vm = Scm_VM();
vm                139 src/load.c         vm->load_port = p->prev_port;
vm                140 src/load.c         vm->load_history = p->prev_history;
vm                141 src/load.c         vm->load_next = p->prev_next;
vm                142 src/load.c         vm->evalSituation = p->prev_situation;
vm                170 src/load.c         ScmVM *vm = Scm_VM();
vm                171 src/load.c         ScmModule *module = vm->module;
vm                186 src/load.c         p->prev_module = vm->module;
vm                187 src/load.c         p->prev_port = vm->load_port;
vm                188 src/load.c         p->prev_history = vm->load_history;
vm                189 src/load.c         p->prev_next = vm->load_next;
vm                190 src/load.c         p->prev_situation = vm->evalSituation;
vm                194 src/load.c         if (SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_CASE_FOLD)) {
vm                198 src/load.c         vm->load_next = next_paths;
vm                199 src/load.c         vm->load_port = SCM_OBJ(port);
vm                200 src/load.c         vm->module = module;
vm                201 src/load.c         vm->evalSituation = SCM_VM_LOADING;
vm                208 src/load.c         vm->load_history = Scm_Cons(port_info, vm->load_history);
vm                210 src/load.c         PORT_LOCK(port, vm);
vm                352 src/load.c         ScmVM *vm = Scm_VM();
vm                370 src/load.c         if (SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_LOAD_VERBOSE)) {
vm                371 src/load.c             int len = Scm_Length(vm->load_history);
vm                735 src/load.c             ScmVM *vm = Scm_VM();
vm                736 src/load.c             if (SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_LOAD_VERBOSE)) {
vm                737 src/load.c                 int len = Scm_Length(vm->load_history);
vm                827 src/load.c         ScmVM *vm = Scm_VM();
vm                845 src/load.c             if (SCM_CDR(p) == SCM_OBJ(vm)) {
vm                856 src/load.c                 if (SCM_CDR(p) == SCM_OBJ(vm)) {
vm                862 src/load.c             ldinfo.waiting = Scm_Acons(SCM_OBJ(vm), feature, ldinfo.waiting);
vm                864 src/load.c             ldinfo.waiting = Scm_AssocDeleteX(SCM_OBJ(vm), ldinfo.waiting, SCM_CMP_EQ);
vm                868 src/load.c             ldinfo.providing = Scm_Acons(feature, SCM_OBJ(vm), ldinfo.providing);
vm                990 src/load.c         ScmVM *vm = Scm_VM();
vm               1002 src/load.c                 adata->locker = vm;
vm               1003 src/load.c             } else if (adata->locker == vm) {
vm               1009 src/load.c                 adata->locker = vm;
vm               1028 src/load.c         prev_module = vm->module;
vm               1030 src/load.c             vm->module = adata->module;
vm               1032 src/load.c             vm->module = prev_module;
vm               1067 src/load.c             vm->module = prev_module;
vm                111 src/main.c         ScmVM *vm = Scm_VM();
vm                113 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_NOINLINE_GLOBALS);
vm                116 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_NOINLINE_LOCALS);
vm                119 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_NOINLINE_CONSTS);
vm                122 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_NOINLINE_GLOBALS);
vm                123 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_NOINLINE_LOCALS);
vm                124 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_NOINLINE_CONSTS);
vm                127 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_NOSOURCE);
vm                130 src/main.c             SCM_VM_RUNTIME_FLAG_SET(vm, SCM_LOAD_VERBOSE);
vm                133 src/main.c             SCM_VM_RUNTIME_FLAG_SET(vm, SCM_CASE_FOLD);
vm                141 src/main.c             SCM_VM_RUNTIME_FLAG_SET(vm, SCM_COLLECT_VM_STATS);
vm                145 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_NOCOMBINE);
vm                149 src/main.c             SCM_VM_COMPILER_FLAG_SET(vm, SCM_COMPILE_SHOWRESULT);
vm                153 src/main.c             SCM_VM_RUNTIME_FLAG_SET(vm, SCM_LIMIT_MODULE_MUTATION);
vm                240 src/main.c         ScmVM *vm = Scm_VM();
vm                255 src/main.c                     vm->stat.sovCount,
vm                256 src/main.c                     vm->stat.sovTime/1000.0,
vm                257 src/main.c                     (vm->stat.sovCount > 0?
vm                258 src/main.c                      (double)(vm->stat.sovTime/vm->stat.sovCount)/1000.0 :
vm                 99 src/parameter.c int Scm_MakeParameterSlot(ScmVM *vm, int *newid)
vm                101 src/parameter.c     ScmVMParameterTable *p = &(vm->parameters);
vm                127 src/parameter.c ScmObj Scm_ParameterRef(ScmVM *vm, int index, int id)
vm                129 src/parameter.c     ScmVMParameterTable *p = &(vm->parameters);
vm                133 src/parameter.c                   vm, index, id);
vm                139 src/parameter.c ScmObj Scm_ParameterSet(ScmVM *vm, int index, int id, ScmObj value)
vm                141 src/parameter.c     ScmVMParameterTable *p = &(vm->parameters);
vm                145 src/parameter.c                   vm, index, id);
vm                158 src/port.c         ScmVM *vm = Scm_VM();
vm                159 src/port.c         PORT_LOCK(port, vm);
vm                179 src/port.c         ScmVM *vm = Scm_VM();
vm                180 src/port.c         PORT_LOCK(p, vm);
vm                924 src/port.c         ScmVM *vm;
vm                927 src/port.c         vm = Scm_VM();
vm                928 src/port.c         PORT_LOCK(port, vm);
vm                 66 src/portapi.c  #define VMDECL        ScmVM *vm = Scm_VM()
vm                 67 src/portapi.c  #define LOCK(p)       PORT_LOCK(p, vm)
vm                 71 src/portapi.c    do { if (PORT_LOCKED(p, vm)) { unsafe; }} while (0)
vm                 91 src/prof.c     static void sampler_flush(ScmVM *vm)
vm                 96 src/prof.c         if (vm->prof == NULL) return; /* for safety */
vm                 97 src/prof.c         if (vm->prof->samplerFd < 0 || vm->prof->currentSample == 0) return;
vm                 99 src/prof.c         nsamples = vm->prof->currentSample;
vm                100 src/prof.c         r = write(vm->prof->samplerFd, vm->prof->samples,
vm                103 src/prof.c             vm->prof->errorOccurred++;
vm                105 src/prof.c         vm->prof->currentSample = 0;
vm                112 src/prof.c         ScmVM *vm;
vm                115 src/prof.c         vm = Scm_VM();
vm                116 src/prof.c         if (vm->prof == NULL) return;
vm                117 src/prof.c         if (vm->prof->state != SCM_PROFILER_RUNNING) return;
vm                119 src/prof.c         if (vm->prof->currentSample >= SCM_PROF_SAMPLES_IN_BUFFER) {
vm                121 src/prof.c             sampler_flush(vm);
vm                125 src/prof.c         i = vm->prof->currentSample++;
vm                126 src/prof.c         if (vm->base) {
vm                129 src/prof.c             if (vm->pc && SCM_VM_INSN_CODE(*vm->pc) == SCM_VM_RET
vm                130 src/prof.c                 && SCM_SUBRP(vm->val0)) {
vm                131 src/prof.c                 vm->prof->samples[i].func = vm->val0;
vm                132 src/prof.c                 vm->prof->samples[i].pc = NULL;
vm                134 src/prof.c                 vm->prof->samples[i].func = SCM_OBJ(vm->base);
vm                135 src/prof.c                 vm->prof->samples[i].pc = vm->pc;
vm                138 src/prof.c             vm->prof->samples[i].func = SCM_FALSE;
vm                139 src/prof.c             vm->prof->samples[i].pc = NULL;
vm                141 src/prof.c         vm->prof->totalSamples++;
vm                170 src/prof.c     void Scm_ProfilerCountBufferFlush(ScmVM *vm)
vm                176 src/prof.c         if (vm->prof == NULL) return; /* for safety */
vm                177 src/prof.c         if (vm->prof->currentCount == 0) return;
vm                184 src/prof.c         ncounts = vm->prof->currentCount;
vm                189 src/prof.c             func = vm->prof->counts[i].func;
vm                197 src/prof.c             e = Scm_HashTableAdd(vm->prof->statHash,
vm                198 src/prof.c                                  vm->prof->counts[i].func,
vm                208 src/prof.c         vm->prof->currentCount = 0;
vm                220 src/prof.c         ScmVM *vm = Scm_VM();
vm                223 src/prof.c         if (!vm->prof) {
vm                224 src/prof.c             vm->prof = SCM_NEW(ScmVMProfiler);
vm                225 src/prof.c             vm->prof->state = SCM_PROFILER_INACTIVE;
vm                226 src/prof.c             vm->prof->samplerFd = Scm_Mkstemp(templat);
vm                227 src/prof.c             vm->prof->currentSample = 0;
vm                228 src/prof.c             vm->prof->totalSamples = 0;
vm                229 src/prof.c             vm->prof->errorOccurred = 0;
vm                230 src/prof.c             vm->prof->currentCount = 0;
vm                231 src/prof.c             vm->prof->statHash =
vm                234 src/prof.c         } else if (vm->prof->samplerFd < 0) {
vm                235 src/prof.c     	vm->prof->samplerFd = Scm_Mkstemp(templat);
vm                239 src/prof.c         if (vm->prof->state == SCM_PROFILER_RUNNING) return;
vm                240 src/prof.c         vm->prof->state = SCM_PROFILER_RUNNING;
vm                241 src/prof.c         vm->profilerRunning = TRUE;
vm                256 src/prof.c         ScmVM *vm = Scm_VM();
vm                257 src/prof.c         if (vm->prof == NULL) return 0;
vm                258 src/prof.c         if (vm->prof->state != SCM_PROFILER_RUNNING) return 0;
vm                260 src/prof.c         vm->prof->state = SCM_PROFILER_PAUSING;
vm                261 src/prof.c         vm->profilerRunning = FALSE;
vm                262 src/prof.c         return vm->prof->totalSamples;
vm                267 src/prof.c         ScmVM *vm = Scm_VM();
vm                269 src/prof.c         if (vm->prof == NULL) return;
vm                270 src/prof.c         if (vm->prof->state == SCM_PROFILER_INACTIVE) return;
vm                271 src/prof.c         if (vm->prof->state == SCM_PROFILER_RUNNING) Scm_ProfilerStop();
vm                273 src/prof.c         if (vm->prof->samplerFd >= 0) {
vm                274 src/prof.c             close(vm->prof->samplerFd);
vm                275 src/prof.c             vm->prof->samplerFd = -1;
vm                277 src/prof.c         vm->prof->totalSamples = 0;
vm                278 src/prof.c         vm->prof->currentSample = 0;
vm                279 src/prof.c         vm->prof->errorOccurred = 0;
vm                280 src/prof.c         vm->prof->currentCount = 0;
vm                281 src/prof.c         vm->prof->statHash =
vm                283 src/prof.c         vm->prof->state = SCM_PROFILER_INACTIVE;
vm                292 src/prof.c         ScmVM *vm = Scm_VM();
vm                294 src/prof.c         if (vm->prof == NULL) return SCM_FALSE;
vm                295 src/prof.c         if (vm->prof->state == SCM_PROFILER_INACTIVE) return SCM_FALSE;
vm                296 src/prof.c         if (vm->prof->state == SCM_PROFILER_RUNNING) Scm_ProfilerStop();
vm                298 src/prof.c         if (vm->prof->errorOccurred > 0) {
vm                302 src/prof.c         Scm_ProfilerCountBufferFlush(vm);
vm                305 src/prof.c         collect_samples(vm->prof);
vm                308 src/prof.c         SCM_SYSCALL(off, lseek(vm->prof->samplerFd, 0, SEEK_SET));
vm                314 src/prof.c             Scm_MakePortWithFd(SCM_FALSE, SCM_PORT_INPUT, vm->prof->samplerFd,
vm                318 src/prof.c             r = read(vm->prof->samplerFd, vm->prof->samples,
vm                321 src/prof.c             vm->prof->currentSample = r / sizeof(ScmProfSample[1]);
vm                322 src/prof.c             collect_samples(vm->prof);
vm                324 src/prof.c         vm->prof->currentSample = 0;
vm                325 src/prof.c         if (ftruncate(vm->prof->samplerFd, 0) < 0) {
vm                329 src/prof.c         return SCM_OBJ(vm->prof->statHash);
vm                 49 src/read.c     static void   read_context_init(ScmVM *vm, ScmReadContext *ctx);
vm                 92 src/read.c         ScmVM *vm = Scm_VM();
vm                101 src/read.c         if (PORT_LOCKED(SCM_PORT(port), vm)) {
vm                104 src/read.c             PORT_LOCK(SCM_PORT(port), vm);
vm                146 src/read.c         ScmVM *vm = Scm_VM();
vm                155 src/read.c         if (PORT_LOCKED(SCM_PORT(port), vm)) {
vm                158 src/read.c             PORT_LOCK(SCM_PORT(port), vm);
vm                175 src/read.c     static void read_context_init(ScmVM *vm, ScmReadContext *ctx)
vm                178 src/read.c         if (SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_CASE_FOLD)) {
vm                 82 src/repl.c         ScmVM *vm = Scm_VM();
vm                 85 src/repl.c             if (vm->numVals == 1) {
vm                 88 src/repl.c                 return Scm_VMApply(printer, Scm_VMGetResult(vm));
vm                 91 src/repl.c             ScmObj result = Scm_VMGetResult(vm), cp;
vm                392 src/signal.c       ScmVM *vm = Scm_VM();
vm                395 src/signal.c       if (vm == NULL) return;
vm                397 src/signal.c       if (vm->sigq.overflow) {
vm                402 src/signal.c       vm->sigq.queue[vm->sigq.tail++] = signum;
vm                403 src/signal.c       if (vm->sigq.tail >= SCM_VM_SIGQ_SIZE) {
vm                404 src/signal.c           vm->sigq.tail = 0;
vm                406 src/signal.c       if (vm->sigq.tail == vm->sigq.head) vm->sigq.overflow++;
vm                407 src/signal.c       vm->queueNotEmpty |= SCM_VM_SIGQ_MASK;
vm                426 src/signal.c   void Scm_SigCheck(ScmVM *vm)
vm                429 src/signal.c       ScmSignalQueue *q = &vm->sigq;
vm                442 src/signal.c       vm->queueNotEmpty &= ~SCM_VM_SIGQ_MASK;
vm                653 src/signal.c       ScmVM *vm = Scm_VM();
vm                656 src/signal.c           if (vm->sigq.tail != vm->sigq.head) {
vm                658 src/signal.c               Scm_SigCheck(vm);
vm                665 src/signal.c       SCM_SIGCHECK(vm);
vm                116 src/system.c           ScmVM *vm = Scm_VM();
vm                118 src/system.c           SCM_SIGCHECK(vm);
vm                127 src/system.c           ScmVM *vm = Scm_VM();
vm                129 src/system.c           SCM_SIGCHECK(vm);
vm                168 src/system.c       ScmVM *vm = Scm_VM();
vm                173 src/system.c           SCM_SIGCHECK(vm);
vm                180 src/system.c       SCM_SIGCHECK(vm);
vm                107 src/vm.c       static void save_stack(ScmVM *vm);
vm                113 src/vm.c       static void   process_queued_requests(ScmVM *vm);
vm                115 src/vm.c       static ScmEnvFrame *get_env(ScmVM *vm);
vm                228 src/vm.c       int Scm_AttachVM(ScmVM *vm)
vm                231 src/vm.c           if (vm->thread != (pthread_t)NULL) return FALSE;
vm                234 src/vm.c           if (pthread_setspecific(Scm_VMKey(), vm) != 0) return FALSE;
vm                236 src/vm.c           vm->thread = pthread_self();
vm                237 src/vm.c           vm->state = SCM_VM_RUNNABLE;
vm                245 src/vm.c       ScmObj Scm_VMGetResult(ScmVM *vm)
vm                249 src/vm.c           if (vm->numVals == 0) return SCM_NIL;
vm                250 src/vm.c           SCM_APPEND1(head, tail, vm->val0);
vm                251 src/vm.c           for (i=1; i<vm->numVals; i++) {
vm                252 src/vm.c               SCM_APPEND1(head, tail, vm->vals[i-1]);
vm                259 src/vm.c           ScmVM *vm = theVM;
vm                260 src/vm.c           vm->val0 = obj;
vm                261 src/vm.c           vm->numVals = 1;
vm                301 src/vm.c       #define FETCH_INSN(var)         ((var) = fetch_insn_counting(vm, var))
vm                344 src/vm.c       #define CONT  vm->cont
vm                345 src/vm.c       #define ARGP  vm->argp
vm                346 src/vm.c       #define BASE  vm->base
vm                351 src/vm.c       #define ENV   vm->env
vm                352 src/vm.c       #define CONT  vm->cont
vm                353 src/vm.c       #define ARGP  vm->argp
vm                354 src/vm.c       #define BASE  vm->base
vm                358 src/vm.c       #define VAL0  vm->val0
vm                359 src/vm.c       #define ENV   vm->env
vm                360 src/vm.c       #define CONT  vm->cont
vm                361 src/vm.c       #define ARGP  vm->argp
vm                362 src/vm.c       #define BASE  vm->base
vm                364 src/vm.c       #define PC    vm->pc
vm                365 src/vm.c       #define SP    vm->sp
vm                366 src/vm.c       #define VAL0  vm->val0
vm                367 src/vm.c       #define ENV   vm->env
vm                368 src/vm.c       #define CONT  vm->cont
vm                369 src/vm.c       #define ARGP  vm->argp
vm                370 src/vm.c       #define BASE  vm->base
vm                378 src/vm.c       #define BASE  vm->base
vm                389 src/vm.c           ScmVM *VOLATILE vm = theVM;                 \
vm                390 src/vm.c           SCM_PCTYPE VOLATILE pc = vm->pc;            \
vm                391 src/vm.c           ScmEnvFrame *VOLATILE env = vm->env;        \
vm                392 src/vm.c           ScmObj *VOLATILE sp = vm->sp;               \
vm                393 src/vm.c           VOLATILE ScmObj val0 = vm->val0
vm                396 src/vm.c           ScmVM *VOLATILE vm = theVM;                 \
vm                397 src/vm.c           SCM_PCTYPE VOLATILE pc = vm->pc;            \
vm                398 src/vm.c           ScmObj *VOLATILE sp = vm->sp;               \
vm                399 src/vm.c           VOLATILE ScmObj val0 = vm->val0
vm                402 src/vm.c           ScmVM *VOLATILE vm = theVM;                 \
vm                403 src/vm.c           SCM_PCTYPE VOLATILE pc = vm->pc;            \
vm                404 src/vm.c           ScmObj *VOLATILE sp = vm->sp
vm                407 src/vm.c           ScmVM *VOLATILE vm = theVM
vm                410 src/vm.c           ScmVM *VOLATILE vm = theVM;                 \
vm                411 src/vm.c           SCM_PCTYPE VOLATILE pc = vm->pc;            \
vm                412 src/vm.c           ScmContFrame *VOLATILE cont = vm->cont;     \
vm                413 src/vm.c           ScmEnvFrame *VOLATILE env = vm->env;        \
vm                414 src/vm.c           ScmObj *VOLATILE argp = vm->argp;           \
vm                415 src/vm.c           ScmObj *VOLATILE sp = vm->sp;               \
vm                416 src/vm.c           VOLATILE ScmObj val0 = vm->val0
vm                423 src/vm.c               vm->pc = pc;                            \
vm                424 src/vm.c               vm->env = env;                          \
vm                425 src/vm.c               vm->sp = sp;                            \
vm                426 src/vm.c               vm->val0 = val0;                        \
vm                431 src/vm.c               vm->pc = pc;                            \
vm                432 src/vm.c               vm->sp = sp;                            \
vm                433 src/vm.c               vm->val0 = val0;                        \
vm                438 src/vm.c               vm->pc = pc;                            \
vm                439 src/vm.c               vm->sp = sp;                            \
vm                446 src/vm.c               vm->pc = pc;                            \
vm                447 src/vm.c               vm->env = env;                          \
vm                448 src/vm.c               vm->argp = argp;                        \
vm                449 src/vm.c               vm->cont = cont;                        \
vm                450 src/vm.c               vm->sp = sp;                            \
vm                451 src/vm.c               vm->val0 = val0;                        \
vm                457 src/vm.c             ((unsigned long)((ptr) - vm->stackBase) < SCM_VM_STACK_SIZE)
vm                462 src/vm.c               pc = vm->pc;                            \
vm                463 src/vm.c               env = vm->env;                          \
vm                464 src/vm.c               sp = vm->sp;                            \
vm                469 src/vm.c               pc = vm->pc;                            \
vm                470 src/vm.c               sp = vm->sp;                            \
vm                477 src/vm.c               pc = vm->pc;                            \
vm                478 src/vm.c               env = vm->env;                          \
vm                479 src/vm.c               argp = vm->argp;                        \
vm                480 src/vm.c               cont = vm->cont;                        \
vm                481 src/vm.c               sp = vm->sp;                            \
vm                488 src/vm.c               if (MOSTLY_FALSE(SP >= vm->stackEnd - (size))) {        \
vm                490 src/vm.c                   save_stack(vm);                                     \
vm                542 src/vm.c                   ARGP = SP = vm->stackBase;                                  \
vm                638 src/vm.c           Scm_VMDump(vm)
vm                713 src/vm.c               if (vm->queueNotEmpty) goto process_queue;      \
vm                731 src/vm.c               vm->numVals = 1;                        \
vm                772 src/vm.c               if (vm->queueNotEmpty) goto process_queue;
vm                826 src/vm.c                           to = vm->stackBase;
vm                849 src/vm.c                       vm->numVals = 1; /* default */
vm                879 src/vm.c                           SCM_PROF_COUNT_CALL(vm, VAL0);
vm                897 src/vm.c                           vm->base = SCM_COMPILED_CODE(SCM_CLOSURE(VAL0)->code);
vm                898 src/vm.c                           PC = vm->base->code;
vm                899 src/vm.c                           CHECK_STACK(vm->base->maxstack);
vm                900 src/vm.c                           SCM_PROF_COUNT_CALL(vm, SCM_OBJ(vm->base));
vm                965 src/vm.c                           SCM_PROF_COUNT_CALL(vm, VAL0);
vm                987 src/vm.c                           SCM_PROF_COUNT_CALL(vm, VAL0);
vm               1004 src/vm.c                           vm->base = SCM_COMPILED_CODE(SCM_METHOD(VAL0)->data);
vm               1005 src/vm.c                           PC = vm->base->code;
vm               1006 src/vm.c                           CHECK_STACK(vm->base->maxstack);
vm               1007 src/vm.c                           SCM_PROF_COUNT_CALL(vm, SCM_OBJ(vm->base));
vm               1036 src/vm.c                           vm->numVals = 1;
vm               1046 src/vm.c                           vm->numVals = 1;
vm               1056 src/vm.c                           vm->numVals = 1;
vm               1222 src/vm.c                               to = vm->stackBase;
vm               1247 src/vm.c                           to = vm->stackBase;
vm               1268 src/vm.c                       vm->base = SCM_COMPILED_CODE(SCM_CLOSURE(VAL0)->code);
vm               1269 src/vm.c                       PC = vm->base->code;
vm               1270 src/vm.c                       CHECK_STACK(vm->base->maxstack);
vm               1271 src/vm.c                       SCM_PROF_COUNT_CALL(vm, SCM_OBJ(vm->base));
vm               1285 src/vm.c                       e = get_env(vm);
vm               1316 src/vm.c                                                  SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_LIMIT_MODULE_MUTATION));
vm               1319 src/vm.c                               if (SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_LIMIT_MODULE_MUTATION)) {
vm               1519 src/vm.c                       VAL0 = Scm_MakeClosure(body, get_env(vm));
vm               1533 src/vm.c                       if (vm->numVals < reqargs) {
vm               1535 src/vm.c                       } else if (!restarg && vm->numVals > reqargs) {
vm               1553 src/vm.c                       } else if (restarg && vm->numVals > 0) {
vm               1558 src/vm.c                           PUSH_ARG(vm->vals[i-1]);
vm               1561 src/vm.c                           for (; i < vm->numVals; i++) {
vm               1562 src/vm.c                               SCM_APPEND1(rest, tail, vm->vals[i-1]);
vm               1602 src/vm.c                       vm->numVals = 1;
vm               1608 src/vm.c                       vm->numVals = 1;
vm               1614 src/vm.c                       vm->numVals = 1;
vm               1801 src/vm.c                       vm->numVals = 1;
vm               1986 src/vm.c                       VM_ASSERT(nargs -1 <= SP - vm->stackBase);
vm               1989 src/vm.c                               vm->vals[i-1] = VAL0;
vm               1993 src/vm.c                       vm->numVals = nargs;
vm               2107 src/vm.c                       vm->numVals = 1;
vm               2114 src/vm.c                       vm->numVals = 1;
vm               2121 src/vm.c                       vm->numVals = 1;
vm               2128 src/vm.c                       vm->numVals = 1;
vm               2395 src/vm.c                       VAL0 = SCM_OBJ(vm->curin);
vm               2399 src/vm.c                       VAL0 = SCM_OBJ(vm->curout);
vm               2403 src/vm.c                       VAL0 = SCM_OBJ(vm->curerr);
vm               2456 src/vm.c               process_queued_requests(vm);
vm               2504 src/vm.c       static inline ScmEnvFrame *save_env(ScmVM *vm, ScmEnvFrame *env_begin)
vm               2542 src/vm.c       static void save_cont(ScmVM *vm)
vm               2544 src/vm.c           ScmContFrame *c = vm->cont, *prev = NULL, *tmp;
vm               2551 src/vm.c           vm->env = save_env(vm, vm->env);
vm               2564 src/vm.c                   c->env = save_env(vm, c->env);
vm               2599 src/vm.c           if (FORWARDED_CONT_P(vm->cont)) {
vm               2600 src/vm.c               vm->cont = FORWARDED_CONT(vm->cont);
vm               2602 src/vm.c           for (cstk = vm->cstack; cstk; cstk = cstk->prev) {
vm               2607 src/vm.c           for (ep = vm->escapePoint; ep; ep = ep->prev) {
vm               2612 src/vm.c           for (ep = SCM_VM_FLOATING_EP(vm); ep; ep = ep->floating) {
vm               2619 src/vm.c       static void save_stack(ScmVM *vm)
vm               2623 src/vm.c           int stats = SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_COLLECT_VM_STATS);
vm               2631 src/vm.c           save_cont(vm);
vm               2632 src/vm.c           memmove(vm->stackBase, vm->argp,
vm               2633 src/vm.c                   (vm->sp - (ScmObj*)vm->argp) * sizeof(ScmObj*));
vm               2634 src/vm.c           vm->sp -= (ScmObj*)vm->argp - vm->stackBase;
vm               2635 src/vm.c           vm->argp = vm->stackBase;
vm               2637 src/vm.c           for (p = vm->sp; p < vm->stackEnd; p++) *p = NULL;
vm               2642 src/vm.c               vm->stat.sovCount++;
vm               2643 src/vm.c               vm->stat.sovTime +=
vm               2649 src/vm.c       static ScmEnvFrame *get_env(ScmVM *vm)
vm               2654 src/vm.c           e = save_env(vm, vm->env);
vm               2655 src/vm.c           if (e != vm->env) {
vm               2656 src/vm.c               vm->env = e;
vm               2657 src/vm.c               for (c = vm->cont; IN_STACK_P((ScmObj*)c); c = c->prev) {
vm               2727 src/vm.c           ScmVM *vm = theVM;
vm               2728 src/vm.c           vm->pc = apply_calls[0];
vm               2788 src/vm.c           ScmVM *vm = Scm_VM();
vm               2796 src/vm.c           vm->numVals = 1;
vm               2800 src/vm.c               ScmObj body = Scm_MakeClosure(v, get_env(vm));
vm               2803 src/vm.c               ScmObj after = Scm_MakeSubr(eval_restore_env, (void*)vm->module,
vm               2809 src/vm.c               vm->base = SCM_COMPILED_CODE(v);
vm               2810 src/vm.c               vm->pc = SCM_COMPILED_CODE(v)->code;
vm               2811 src/vm.c               SCM_PROF_COUNT_CALL(vm, v);
vm               2852 src/vm.c           vm->base = SCM_COMPILED_CODE(program);
vm               2856 src/vm.c               PC = vm->base->code;
vm               2857 src/vm.c               CHECK_STACK(vm->base->maxstack);
vm               2859 src/vm.c           SCM_PROF_COUNT_CALL(vm, program);
vm               2862 src/vm.c           cstack.prev = vm->cstack;
vm               2863 src/vm.c           cstack.cont = vm->cont;
vm               2864 src/vm.c           vm->cstack = &cstack;
vm               2867 src/vm.c           vm->escapeReason = SCM_VM_ESCAPE_NONE;
vm               2870 src/vm.c               VAL0 = vm->val0;
vm               2871 src/vm.c               if (vm->cont == cstack.cont) {
vm               2879 src/vm.c               if (vm->escapeReason == SCM_VM_ESCAPE_CONT) {
vm               2880 src/vm.c                    ScmEscapePoint *ep = (ScmEscapePoint*)vm->escapeData[0];
vm               2881 src/vm.c                   if (ep->cstack == vm->cstack) {
vm               2882 src/vm.c                       ScmObj handlers = throw_cont_calculate_handlers(ep, vm);
vm               2884 src/vm.c                       vm->pc = PC_TO_RETURN;
vm               2885 src/vm.c                       vm->val0 = throw_cont_body(handlers, ep, vm->escapeData[1]);
vm               2888 src/vm.c                       SCM_ASSERT(vm->cstack && vm->cstack->prev);
vm               2889 src/vm.c                       vm->cont = cstack.cont;
vm               2890 src/vm.c                       VAL0 = vm->val0;
vm               2894 src/vm.c                       vm->cstack = vm->cstack->prev;
vm               2895 src/vm.c                       siglongjmp(vm->cstack->jbuf, 1);
vm               2897 src/vm.c               } else if (vm->escapeReason == SCM_VM_ESCAPE_ERROR) {
vm               2898 src/vm.c                   ScmEscapePoint *ep = (ScmEscapePoint*)vm->escapeData[0];
vm               2899 src/vm.c                   if (ep && ep->cstack == vm->cstack) {
vm               2900 src/vm.c                       vm->cont = ep->cont;
vm               2901 src/vm.c                       vm->pc = PC_TO_RETURN;
vm               2903 src/vm.c                   } else if (vm->cstack->prev == NULL) {
vm               2913 src/vm.c                       vm->cont = cstack.cont;
vm               2914 src/vm.c                       VAL0 = vm->val0;
vm               2918 src/vm.c                       vm->cstack = vm->cstack->prev;
vm               2919 src/vm.c                       siglongjmp(vm->cstack->jbuf, 1);
vm               2926 src/vm.c           vm->cstack = vm->cstack->prev;
vm               2927 src/vm.c           return vm->val0;
vm               2950 src/vm.c           ScmVM *vm = Scm_VM();
vm               2961 src/vm.c           program = vm->base? SCM_OBJ(vm->base) : SCM_OBJ(&internal_apply_compiled_code);
vm               3041 src/vm.c           ScmVM *vm = theVM;
vm               3046 src/vm.c           vm->handlers = prev;
vm               3048 src/vm.c           d[1] = (void*)vm->numVals;
vm               3049 src/vm.c           if (vm->numVals > 1) {
vm               3050 src/vm.c               ScmObj *array = SCM_NEW_ARRAY(ScmObj, (vm->numVals-1));
vm               3051 src/vm.c               memcpy(array, vm->vals, sizeof(ScmObj)*(vm->numVals-1));
vm               3061 src/vm.c           ScmVM *vm = theVM;
vm               3063 src/vm.c           vm->numVals = nvals;
vm               3066 src/vm.c               memcpy(vm->vals, data[2], sizeof(ScmObj)*(nvals-1));
vm               3184 src/vm.c           ScmVM *vm = theVM;
vm               3185 src/vm.c           ScmEscapePoint *ep = vm->escapePoint;
vm               3202 src/vm.c               vm->escapePoint = ep->prev;
vm               3203 src/vm.c               SCM_VM_FLOATING_EP_SET(vm, ep);
vm               3207 src/vm.c                   if ((numVals = vm->numVals) > 1) {
vm               3208 src/vm.c                       for (i=0; i<numVals-1; i++) rvals[i] = vm->vals[i];
vm               3211 src/vm.c                   current = vm->handlers;
vm               3215 src/vm.c                       vm->handlers = SCM_CDR(hp);
vm               3222 src/vm.c                   SCM_VM_FLOATING_EP_SET(vm, ep->floating);
vm               3228 src/vm.c               for (i=0; i<numVals; i++) vm->vals[i] = rvals[i];
vm               3229 src/vm.c               vm->numVals = numVals;
vm               3230 src/vm.c               vm->val0 = result;
vm               3231 src/vm.c               vm->cont = ep->cont;
vm               3232 src/vm.c               SCM_VM_FLOATING_EP_SET(vm, ep->floating);
vm               3234 src/vm.c                   SCM_VM_RUNTIME_FLAG_SET(vm, SCM_ERROR_BEING_REPORTED);
vm               3239 src/vm.c               SCM_FOR_EACH(hp, vm->handlers) {
vm               3241 src/vm.c                   vm->handlers = SCM_CDR(hp);
vm               3246 src/vm.c           if (vm->cstack) {
vm               3247 src/vm.c               vm->escapeReason = SCM_VM_ESCAPE_ERROR;
vm               3248 src/vm.c               vm->escapeData[0] = ep;
vm               3249 src/vm.c               vm->escapeData[1] = e;
vm               3250 src/vm.c               siglongjmp(vm->cstack->jbuf, 1);
vm               3280 src/vm.c       ScmObj Scm_VMThrowException(ScmVM *vm, ScmObj exception)
vm               3282 src/vm.c           ScmEscapePoint *ep = vm->escapePoint;
vm               3284 src/vm.c           SCM_VM_RUNTIME_FLAG_CLEAR(vm, SCM_ERROR_BEING_HANDLED);
vm               3286 src/vm.c           if (vm->exceptionHandler != DEFAULT_EXCEPTION_HANDLER) {
vm               3287 src/vm.c               vm->val0 = Scm_Apply(vm->exceptionHandler, SCM_LIST1(exception));
vm               3293 src/vm.c                   vm->exceptionHandler = DEFAULT_EXCEPTION_HANDLER;
vm               3296 src/vm.c               return vm->val0;
vm               3317 src/vm.c           ScmVM *vm = theVM;
vm               3318 src/vm.c           vm->exceptionHandler = DEFAULT_EXCEPTION_HANDLER;
vm               3319 src/vm.c           vm->escapePoint = ep;
vm               3320 src/vm.c           SCM_VM_RUNTIME_FLAG_CLEAR(vm, SCM_ERROR_BEING_REPORTED);
vm               3327 src/vm.c           ScmVM *vm = theVM;
vm               3328 src/vm.c           vm->escapePoint = ep->prev;
vm               3329 src/vm.c           vm->exceptionHandler = ep->xhandler;
vm               3331 src/vm.c               SCM_VM_RUNTIME_FLAG_SET(vm, SCM_ERROR_BEING_REPORTED);
vm               3338 src/vm.c           ScmVM *vm = theVM;
vm               3347 src/vm.c           ep->prev = vm->escapePoint;
vm               3348 src/vm.c           ep->floating = SCM_VM_FLOATING_EP(vm);
vm               3350 src/vm.c           ep->handlers = vm->handlers;
vm               3351 src/vm.c           ep->cstack = vm->cstack;
vm               3352 src/vm.c           ep->xhandler = vm->exceptionHandler;
vm               3353 src/vm.c           ep->cont = vm->cont;
vm               3355 src/vm.c               SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_ERROR_BEING_REPORTED);
vm               3357 src/vm.c           vm->escapePoint = ep; /* This will be done in install_ehandler, but
vm               3392 src/vm.c                                                   ScmVM *vm)
vm               3395 src/vm.c           ScmObj current = vm->handlers;
vm               3424 src/vm.c           ScmVM *vm = theVM;
vm               3440 src/vm.c           vm->pc = PC_TO_RETURN;
vm               3441 src/vm.c           vm->cont = ep->cont;
vm               3453 src/vm.c               vm->vals[i] = SCM_CAR(ap);
vm               3455 src/vm.c           vm->numVals = nargs;
vm               3471 src/vm.c           ScmVM *vm = theVM;
vm               3474 src/vm.c           if (vm->cstack != ep->cstack) {
vm               3476 src/vm.c               for (cstk = vm->cstack; cstk; cstk = cstk->prev) {
vm               3484 src/vm.c                   vm->escapeReason = SCM_VM_ESCAPE_CONT;
vm               3485 src/vm.c                   vm->escapeData[0] = ep;
vm               3486 src/vm.c                   vm->escapeData[1] = args;
vm               3487 src/vm.c                   siglongjmp(vm->cstack->jbuf, 1);
vm               3490 src/vm.c               ScmObj handlers_to_call = throw_cont_calculate_handlers(ep, vm);
vm               3491 src/vm.c               vm->handlers = ep->handlers;
vm               3501 src/vm.c           ScmVM *vm = theVM;
vm               3509 src/vm.c           save_cont(vm);
vm               3513 src/vm.c           ep->cont = vm->cont;
vm               3514 src/vm.c           ep->handlers = vm->handlers;
vm               3515 src/vm.c           ep->cstack = vm->cstack;
vm               3528 src/vm.c           ScmVM *vm = theVM;
vm               3533 src/vm.c               vm->numVals = 0;
vm               3538 src/vm.c               vm->vals[nvals-1] = SCM_CAR(cp);
vm               3543 src/vm.c           vm->numVals = nvals;
vm               3549 src/vm.c           ScmVM *vm = theVM;
vm               3550 src/vm.c           vm->numVals = 2;
vm               3551 src/vm.c           vm->vals[0] = val1;
vm               3557 src/vm.c           ScmVM *vm = theVM;
vm               3558 src/vm.c           vm->numVals = 3;
vm               3559 src/vm.c           vm->vals[0] = val1;
vm               3560 src/vm.c           vm->vals[1] = val2;
vm               3566 src/vm.c           ScmVM *vm = theVM;
vm               3567 src/vm.c           vm->numVals = 4;
vm               3568 src/vm.c           vm->vals[0] = val1;
vm               3569 src/vm.c           vm->vals[1] = val2;
vm               3570 src/vm.c           vm->vals[2] = val3;
vm               3576 src/vm.c           ScmVM *vm = theVM;
vm               3577 src/vm.c           vm->numVals = 5;
vm               3578 src/vm.c           vm->vals[0] = val1;
vm               3579 src/vm.c           vm->vals[1] = val2;
vm               3580 src/vm.c           vm->vals[2] = val3;
vm               3581 src/vm.c           vm->vals[3] = val4;
vm               3607 src/vm.c           ScmVM *vm = theVM;
vm               3608 src/vm.c           vm->numVals = (int)data[0];
vm               3609 src/vm.c           vm->val0 = data[1];
vm               3610 src/vm.c           if (vm->numVals > 1) {
vm               3612 src/vm.c               for (i=0; i<vm->numVals-1; i++) {
vm               3613 src/vm.c                   vm->vals[i] = SCM_CAR(cp);
vm               3617 src/vm.c           return vm->val0;
vm               3620 src/vm.c       static void process_queued_requests(ScmVM *vm)
vm               3625 src/vm.c           data[0] = (void*)vm->numVals;
vm               3626 src/vm.c           data[1] = vm->val0;
vm               3627 src/vm.c           if (vm->numVals > 1) {
vm               3631 src/vm.c               for (i=0; i<vm->numVals-1; i++) {
vm               3632 src/vm.c                   SCM_APPEND1(h, t, vm->vals[i]);
vm               3643 src/vm.c           if (vm->queueNotEmpty & SCM_VM_SIGQ_MASK) {
vm               3644 src/vm.c               Scm_SigCheck(vm);
vm               3646 src/vm.c           if (vm->queueNotEmpty & SCM_VM_FINQ_MASK) {
vm               3647 src/vm.c               Scm_VMFinalizerRun(vm);
vm               3668 src/vm.c       ScmObj Scm_VMGetStackLite(ScmVM *vm)
vm               3670 src/vm.c           ScmContFrame *c = vm->cont;
vm               3674 src/vm.c           info = Scm_VMGetSourceInfo(vm->base, vm->pc);
vm               3719 src/vm.c       ScmObj Scm_VMGetStack(ScmVM *vm)
vm               3722 src/vm.c           ScmContFrame *c = vm->cont;
vm               3728 src/vm.c           if (SCM_PAIRP(vm->pc)) {
vm               3729 src/vm.c               info = Scm_VMGetSourceInfo(vm->pc);
vm               3730 src/vm.c               SCM_APPEND1(stack, tail, Scm_Cons(info, env2vec(vm->env, &envTab)));
vm               3799 src/vm.c       void Scm_VMDump(ScmVM *vm)
vm               3801 src/vm.c           ScmPort *out = vm->curerr;
vm               3802 src/vm.c           ScmEnvFrame *env = vm->env;
vm               3803 src/vm.c           ScmContFrame *cont = vm->cont;
vm               3804 src/vm.c           ScmCStack *cstk = vm->cstack;
vm               3805 src/vm.c           ScmEscapePoint *ep = vm->escapePoint;
vm               3807 src/vm.c           Scm_Printf(out, "VM %p -----------------------------------------------------------\n", vm);
vm               3808 src/vm.c           Scm_Printf(out, "   pc: %08x ", vm->pc);
vm               3809 src/vm.c           Scm_Printf(out, "(%08x)\n", *vm->pc);
vm               3810 src/vm.c           Scm_Printf(out, "   sp: %p  base: %p  [%p-%p]\n", vm->sp, vm->stackBase,
vm               3811 src/vm.c                      vm->stack, vm->stackEnd);
vm               3812 src/vm.c           Scm_Printf(out, " argp: %p\n", vm->argp);
vm               3813 src/vm.c           Scm_Printf(out, " val0: %#65.1S\n", vm->val0);
vm               3848 src/vm.c           Scm_Printf(out, "dynenv: %S\n", vm->handlers);
vm               3849 src/vm.c           if (vm->base) {
vm               3851 src/vm.c               Scm_CompiledCodeDump(vm->base);
vm               3863 src/vm.c           ScmVM *vm = (ScmVM*)*addr;
vm               3864 src/vm.c           int i, limit = vm->sp - vm->stackBase + 5;
vm               3865 src/vm.c           GC_PTR spb = (GC_PTR)vm->stackBase;
vm               3866 src/vm.c           GC_PTR sbe = (GC_PTR)(vm->stackBase + SCM_VM_STACK_SIZE);
vm                 47 src/vmstat.c   static ScmWord fetch_insn_counting(ScmVM *vm, ScmWord code)
vm                 49 src/vmstat.c       if (vm->base && vm->pc != vm->base->code) {
vm                 50 src/vmstat.c           insn2_freq[SCM_VM_INSN_CODE(code)][SCM_VM_INSN_CODE(*vm->pc)]++;
vm                 52 src/vmstat.c       code = *vm->pc++;
vm                133 src/write.c        ScmVM *vm;
vm                159 src/write.c        vm = Scm_VM();
vm                160 src/write.c        PORT_LOCK(port, vm);
vm                244 src/write.c            ScmVM *vm = Scm_VM();
vm                245 src/write.c            PORT_LOCK(SCM_PORT(port), vm);
vm                937 src/write.c        ScmVM *vm;
vm                943 src/write.c        vm = Scm_VM();
vm                944 src/write.c        PORT_LOCK(out, vm);
vm               1163 src/write.c        ScmVM *vm;
vm               1236 src/write.c        vm = Scm_VM();
vm               1237 src/write.c        PORT_LOCK(out, vm);