vm.h

Go to the documentation of this file.

#pragma once
#include <stdarg.h>
#include <sys/types.h>
#include "kuroko.h"
#include "value.h"
#include "table.h"
#include "object.h"
 
#define KRK_CALL_FRAMES_MAX 1000
 
#define KRK_THREAD_SCRATCH_SIZE 3
 
typedef struct {
    KrkClosure * closure; 
    uint8_t * ip;         
    size_t slots;         
    size_t outSlots;      
    KrkTable * globals;   
    KrkValue   globalsOwner; 
} KrkCallFrame;
 
struct Exceptions {
    KrkClass * baseException;       
    KrkClass * typeError;           
    KrkClass * argumentError;       
    KrkClass * indexError;          
    KrkClass * keyError;            
    KrkClass * attributeError;      
    KrkClass * nameError;           
    KrkClass * importError;         
    KrkClass * ioError;             
    KrkClass * valueError;          
    KrkClass * keyboardInterrupt;   
    KrkClass * zeroDivisionError;   
    KrkClass * notImplementedError; 
    KrkClass * syntaxError;         
    KrkClass * assertionError;      
    KrkClass * OSError;             
    KrkClass * ThreadError;         
    KrkClass * Exception;           
    KrkClass * SystemError;         
};
 
struct BaseClasses {
    KrkClass * objectClass;          
    KrkClass * moduleClass;          
    KrkClass * typeClass;            
    KrkClass * intClass;             
    KrkClass * floatClass;           
    KrkClass * boolClass;            
    KrkClass * noneTypeClass;        
    KrkClass * strClass;             
    KrkClass * functionClass;        
    KrkClass * methodClass;          
    KrkClass * tupleClass;           
    KrkClass * bytesClass;           
    KrkClass * listiteratorClass;    
    KrkClass * rangeClass;           
    KrkClass * rangeiteratorClass;   
    KrkClass * striteratorClass;     
    KrkClass * tupleiteratorClass;   
    KrkClass * listClass;            
    KrkClass * dictClass;            
    KrkClass * dictitemsClass;       
    KrkClass * dictkeysClass;        
    KrkClass * bytesiteratorClass;   
    KrkClass * propertyClass;        
    KrkClass * codeobjectClass;      
    KrkClass * generatorClass;       
    KrkClass * notImplClass;         
    KrkClass * bytearrayClass;       
    KrkClass * dictvaluesClass;      
    KrkClass * sliceClass;           
    KrkClass * longClass;            
    KrkClass * mapClass;             
    KrkClass * zipClass;             
    KrkClass * filterClass;          
    KrkClass * enumerateClass;       
    KrkClass * HelperClass;          
    KrkClass * LicenseReaderClass;   
    KrkClass * CompilerStateClass;   
    KrkClass * CellClass;            
    KrkClass * setClass;             
    KrkClass * setiteratorClass;     
    KrkClass * ThreadClass;          
    KrkClass * LockClass;            
    KrkClass * ellipsisClass;        
};
 
typedef struct KrkThreadState {
    struct KrkThreadState * next; 
    KrkCallFrame * frames;     
    size_t frameCount;         
    size_t stackSize;          
    KrkValue * stack;          
    KrkValue * stackTop;       
    KrkUpvalue * openUpvalues; 
    ssize_t exitOnFrame;       
    KrkInstance * module;      
    KrkValue currentException; 
    int flags;                 
    unsigned int maximumCallDepth;  
    KrkValue * stackMax;       
    KrkValue scratchSpace[KRK_THREAD_SCRATCH_SIZE]; 
} KrkThreadState;
 
typedef struct KrkVM {
    int globalFlags;                  
    char * binpath;                   
    KrkTable strings;                 
    KrkTable modules;                 
    KrkInstance * builtins;           
    KrkInstance * system;             
    KrkValue * specialMethodNames;    
    struct BaseClasses * baseClasses; 
    struct Exceptions * exceptions;   
    /* Garbage collector state */
    KrkObj * objects;                 
    size_t bytesAllocated;            
    size_t nextGC;                    
    size_t grayCount;                 
    size_t grayCapacity;              
    KrkObj** grayStack;               
    KrkThreadState * threads;         
    struct DebuggerState * dbgState;  
} KrkVM;
 
/* Thread-specific flags */
#define KRK_THREAD_ENABLE_TRACING      (1 << 0)
#define KRK_THREAD_ENABLE_DISASSEMBLY  (1 << 1)
/* reserved, formerly SCAN_TRACING */
#define KRK_THREAD_HAS_EXCEPTION       (1 << 3)
#define KRK_THREAD_SINGLE_STEP         (1 << 4)
#define KRK_THREAD_SIGNALLED           (1 << 5)
#define KRK_THREAD_DEFER_STACK_FREE    (1 << 6)
 
/* Global flags */
#define KRK_GLOBAL_ENABLE_STRESS_GC    (1 << 8)
#define KRK_GLOBAL_GC_PAUSED           (1 << 9)
#define KRK_GLOBAL_CLEAN_OUTPUT        (1 << 10)
/* 11 is available again */
#define KRK_GLOBAL_REPORT_GC_COLLECTS  (1 << 12)
#define KRK_GLOBAL_THREADS             (1 << 13)
#define KRK_GLOBAL_NO_DEFAULT_MODULES  (1 << 14)
 
#ifndef KRK_DISABLE_THREADS
#  define krk_threadLocal __thread
#else
#  define krk_threadLocal
#endif
 
#if !defined(KRK_DISABLE_THREADS) && ((defined(__APPLE__)) && defined(__aarch64__))
extern void krk_forceThreadData(void);
#define krk_currentThread (*_macos_currentThread())
#pragma clang diagnostic ignored "-Wlanguage-extension-token"
__attribute__((always_inline))
inline KrkThreadState * _macos_currentThread(void) {
    extern const uint64_t tls_desc[] asm("_krk_currentThread");
    const uintptr_t * threadptr; asm ("mrs %0, TPIDRRO_EL0" : "=r"(threadptr));
    return (KrkThreadState*)(threadptr[tls_desc[1]] + tls_desc[2]);
}
#elif !defined(KRK_DISABLE_THREADS) && ((defined(_WIN32) && !defined(KRKINLIB)) || defined(KRK_MEDIOCRE_TLS))
#define krk_currentThread (*krk_getCurrentThread())
#else
extern krk_threadLocal KrkThreadState krk_currentThread;
#endif
 
extern KrkVM krk_vm;
 
#define vm krk_vm
 
extern void krk_initVM(int flags);
 
extern void krk_freeVM(void);
 
extern void krk_resetStack(void);
 
extern KrkValue krk_interpret(const char * src, const char * fromFile);
 
extern KrkValue krk_runfile(const char * fileName, const char * fromFile);
 
extern void krk_push(KrkValue value);
 
extern KrkValue krk_pop(void);
 
extern KrkValue krk_peek(int distance);
 
extern void krk_swap(int distance);
 
extern const char * krk_typeName(KrkValue value);
 
extern KrkNative * krk_defineNative(KrkTable * table, const char * name, NativeFn function);
 
extern KrkNative * krk_defineNativeProperty(KrkTable * table, const char * name, NativeFn func);
 
extern void krk_attachNamedValue(KrkTable * table, const char name[], KrkValue obj);
 
extern void krk_attachNamedObject(KrkTable * table, const char name[], KrkObj * obj);
 
extern KrkValue krk_runtimeError(KrkClass * type, const char * fmt, ...);
 
extern void krk_raiseException(KrkValue base, KrkValue cause);
 
extern void krk_attachInnerException(KrkValue innerException);
 
extern KrkThreadState * krk_getCurrentThread(void);
 
extern KrkValue  krk_runNext(void);
 
extern KrkClass * krk_getType(KrkValue value);
 
extern int krk_isInstanceOf(KrkValue obj, const KrkClass * type);
 
extern int krk_bindMethod(KrkClass * _class, KrkString * name);
 
extern int krk_bindMethodSuper(KrkClass * baseClass, KrkString * name, KrkClass * realClass);
 
extern int krk_callValue(KrkValue callee, int argCount, int callableOnStack);
 
extern KrkValue krk_list_of(int argc, const KrkValue argv[], int hasKw);
 
extern KrkValue krk_dict_of(int argc, const KrkValue argv[], int hasKw);
 
extern KrkValue krk_tuple_of(int argc, const KrkValue argv[], int hasKw);
 
extern KrkValue krk_set_of(int argc, const KrkValue argv[], int hasKw);
 
extern KrkValue krk_slice_of(int argc, const KrkValue argv[], int hasKw);
 
extern KrkValue krk_callStack(int argCount);
 
extern KrkValue krk_callDirect(KrkObj * callable, int argCount);
 
extern KrkClass * krk_makeClass(KrkInstance * module, KrkClass ** _class, const char * name, KrkClass * base);
 
extern void krk_finalizeClass(KrkClass * _class);
 
extern void krk_dumpTraceback(void);
 
extern KrkInstance * krk_startModule(const char * name);
 
extern KrkValue krk_dirObject(int argc, const KrkValue argv[], int hasKw);
 
extern int krk_loadModule(KrkString * path, KrkValue * moduleOut, KrkString * runAs, KrkValue parent);
 
extern int krk_doRecursiveModuleLoad(KrkString * name);
 
extern int krk_importModule(KrkString * name, KrkString * runAs);
 
extern int krk_isFalsey(KrkValue value);
 
extern KrkValue krk_valueGetAttribute(KrkValue value, char * name);
 
extern KrkValue krk_valueGetAttribute_default(KrkValue value, char * name, KrkValue defaultVal);
 
extern KrkValue krk_valueSetAttribute(KrkValue owner, char * name, KrkValue to);
 
extern KrkValue krk_valueDelAttribute(KrkValue owner, char * name);
 
extern void krk_addObjects(void);
 
extern KrkValue krk_operator_lt(KrkValue,KrkValue);
 
extern KrkValue krk_operator_gt(KrkValue,KrkValue);
 
extern KrkValue krk_operator_le(KrkValue,KrkValue);
 
extern KrkValue krk_operator_ge(KrkValue,KrkValue);
 
extern void krk_setMaximumRecursionDepth(size_t maxDepth);
 
extern KrkValue krk_callNativeOnStack(size_t argCount, const KrkValue *stackArgs, int hasKw, NativeFn native);
 
extern KrkValue krk_instanceSetAttribute_wrapper(KrkValue owner, KrkString * name, KrkValue to);
 
extern int krk_getAttribute(KrkString * name);
 
extern int krk_setAttribute(KrkString * name);
 
extern int krk_delAttribute(KrkString * name);
 
extern void krk_module_init_kuroko(void);
 
extern void krk_module_init_threading(void);