NewtEnv.c

説明を見る。

/*------------------------------------------------------------------------*/
/* ヘッダファイル */
#include <string.h>
#include <errno.h>

#include "version.h"
#include "NewtEnv.h"
#include "NewtObj.h"
#include "NewtFns.h"
#include "NewtGC.h"
#include "NewtStr.h"
#include "NewtFile.h"


/* マクロ */
#define SYM_TABLE           (newt_env.sym_table)                
#define ROOT                (newt_env.root)                     
#define GLOBALS             (newt_env.globals)                  
#define GLOBAL_FNS          (newt_env.global_fns)               
#define MAGIC_POINTERS      (newt_env.magic_pointers)           

#define INITSYM2(sym, str)  sym = NewtMakeSymbol(str)           
#define INITSYM(name)       INITSYM2(newt_sym.name, #name)      


/* グローバル変数 */
newt_env_t  newt_env;       
newt_sym_t  newt_sym;       


/* 関数プロトタイプ */
char *  replacechr(char * str, char srch, char repl);

static void     NewtInitSYM(void);
static void     NewtInitSysEnv(void);
static void     NewtInitARGV(int argc, const char * argv[], int n);
static void     NewtInitVersInfo(void);
static void     NewtInitEnv(int argc, const char * argv[], int n);


#pragma mark -
/*------------------------------------------------------------------------*/
char * replacechr(char * str, char src, char dest)
{
    char *  s;

    for (s = str; *s; s++)
    {
        if (*s == src) *s = dest;
    }

    return str;
}


#pragma mark -
/*------------------------------------------------------------------------*/
char * NewtDefaultEncoding(void)
{
    char *  encoding = NULL;
    char *  lang;

    lang = (char *)getenv("LANG");
    if (! lang) lang = (char *)getenv("LC_ALL");
    if (lang) encoding = strchr(lang, '.');

    if (encoding)
        encoding++;
    else
        encoding = NEWT_DEFAULT_ENCODING;

    return encoding;
}


#pragma mark -
/*------------------------------------------------------------------------*/
void NewtInitSYM(void)
{
    // frame
    INITSYM(_proto);
    INITSYM(_parent);

    // function
    INITSYM(_implementor);
    INITSYM(_nextArgFrame);
    INITSYM(CodeBlock);
    INITSYM2(NS_CLASS, "class");
    INITSYM(instructions);
    INITSYM(literals);
    INITSYM(argFrame);
    INITSYM(numArgs);
    INITSYM(indefinite);

    // native function
    INITSYM(_function.native0);
    INITSYM(_function.native);
    INITSYM(funcPtr);
    INITSYM(docString);

    // classes or types
    INITSYM(binary);
    INITSYM(string);
    INITSYM(real);
    INITSYM(array);
    INITSYM(frame);
    INITSYM2(NS_INT, "int");
    INITSYM(int32);
    INITSYM(pathExpr);

    // for loop
    INITSYM(collect);
    INITSYM(deeply);

    // class
    INITSYM2(NS_CHAR, "char");
    INITSYM(boolean);
    INITSYM(weird_immediate);
    INITSYM(forEachState);

    // functions（必須）
    INITSYM(hasVariable);
    INITSYM(hasVar);
    INITSYM(defGlobalFn);
    INITSYM(defGlobalVar);
//    INITSYM(and);
//    INITSYM(or);
    INITSYM(mod);
    INITSYM(shiftLeft);
    INITSYM(shiftRight);
    INITSYM(objectEqual);
    INITSYM(defMagicPointer);
    INITSYM(makeRegex);

    // exception type
    INITSYM(type.ref);
    INITSYM(ext.ex.msg);

    // exception frame
    INITSYM(name);
    INITSYM(data);
    INITSYM(message);
    INITSYM(error);

    INITSYM(errorCode);
    INITSYM(symbol);
    INITSYM(value);
    INITSYM(index);

    // root
    INITSYM(sym_table);
    INITSYM(globals);
    INITSYM(global_fns);
    INITSYM(magic_pointers);

    // for print
    INITSYM(printDepth);
    INITSYM(printLength);

    // for regex
    INITSYM(protoREGEX);
    INITSYM(regex);
    INITSYM(pattern);
    INITSYM(option);

    // for require
    INITSYM(requires);

    // ENV
    INITSYM(_ENV_);
    INITSYM(NEWTLIB);

    // ARGV
    INITSYM(_ARGV_);
    INITSYM(_EXEDIR_);

    // stdout, stderr
    INITSYM(_STDOUT_);
    INITSYM(_STDERR_);
}


/*------------------------------------------------------------------------*/
void NewtInitSysEnv(void)
{
    struct {
        char *      name;
        newtRefVar  slot;
        char *      defaultValue;
        bool        ispath;
    } envs[] = {
        {"NEWTLIB",     NSSYM0(NEWTLIB),    NULL,               true},
        {"PLATFORM",    NSSYM(PLATFORM),    __PLATFORM__,       false},
        {"DYLIBSUFFIX", NSSYM(DYLIBSUFFIX), __DYLIBSUFFIX__,    false},
        {NULL,          kNewtRefUnbind,     NULL,               false}
    };

    newtRefVar  env;
    newtRefVar  proto;
    newtRefVar  v;
    uint16_t    i;

    env = NcMakeFrame();
    proto = NcMakeFrame();

    for (i = 0; envs[i].name != NULL; i++)
    {
        v = NewtGetEnv(envs[i].name);

        if (NewtRefIsString(v))
        {
            if (envs[i].ispath)
                v = NcSplit(v, NewtMakeCharacter(':'));

            NcSetSlot(proto, envs[i].slot, v);
        }
        else if (envs[i].defaultValue)
        {
            NcSetSlot(proto, envs[i].slot, NewtMakeString(envs[i].defaultValue, true));
        }
    }

    NcSetSlot(env, NSSYM0(_proto), NewtPackLiteral(proto));
    NcSetSlot(GLOBALS, NSSYM0(_ENV_), env);
}


/*------------------------------------------------------------------------*/
void NewtInitARGV(int argc, const char * argv[], int n)
{
    newtRefVar  exepath = kNewtRefUnbind;
    newtRefVar  r;
    uint16_t    j;
    uint16_t    i;

    r = NewtMakeArray(kNewtRefUnbind, argc - n);
    NcSetSlot(GLOBALS, NSSYM0(_ARGV_), r);

    for (i = n, j = 0; i < argc; i++, j++)
    {
        NewtSetArraySlot(r, j, NewtMakeString(argv[i], true));
    }

#ifdef __WIN32__
    {
        char    sep;

        sep = NewtGetFileSeparator();

        if (sep != '')
        {
            char *  path;

            path = strdup(argv[0]);

            if (path)
            {
                replacechr(path, '', sep);
                exepath = NewtExpandPath(path);
                free(path);
            }
            else
            {
                exit(errno);
            }
        }
    }
#endif

    if (NewtRefIsNIL(exepath))
        exepath = NewtExpandPath(argv[0]);

    NcSetSlot(GLOBALS, NSSYM0(_EXEDIR_), NcDirName(exepath));
}


/*------------------------------------------------------------------------*/
void NewtInitVersInfo(void)
{
    newtRefVar  versInfo;

    versInfo = NcMakeFrame();

    // プロダクト名
    NcSetSlot(versInfo, NSSYM(name), NewtMakeString(NEWT_NAME, true));
    // プロト番号
    NcSetSlot(versInfo, NSSYM(proto), NewtMakeString(NEWT_PROTO, true));
    // バージョン番号
    NcSetSlot(versInfo, NSSYM(version), NewtMakeString(NEWT_VERSION, true));
    // ビルド番号
    NcSetSlot(versInfo, NSSYM(build), NewtMakeString(NEWT_BUILD, true));
    // コピーライト
    NcSetSlot(versInfo, NSSYM(copyright), NewtMakeString(NEWT_COPYRIGHT, true));
    // スタッフロール
    NcSetSlot(versInfo, NSSYM(staff), NewtMakeString(NEWT_STAFF, true));

    // リードオンリーにしてグローバル変数に入れる
    NcSetSlot(GLOBALS, NSSYM(_VERSION_), NewtPackLiteral(versInfo));
}


/*------------------------------------------------------------------------*/
void NewtInitEnv(int argc, const char * argv[], int n)
{
    // シンボルテーブルの作成
    SYM_TABLE = NewtMakeArray(kNewtRefUnbind, 0);
    NewtInitSYM();

    // ルートフレームの作成
    ROOT = NcMakeFrame();
    // グローバル変数テーブルの作成
    GLOBALS = NcMakeFrame();
    // グローバル関数テーブルの作成
    GLOBAL_FNS = NcMakeFrame();
    // マジックポインタテーブルの作成
#ifdef __NAMED_MAGIC_POINTER__
    MAGIC_POINTERS = NcMakeFrame();
#else
    MAGIC_POINTERS = NewtMakeArray(kNewtRefUnbind, 0);
#endif

    // ルートフレームに各テーブルを格納
    NcSetSlot(ROOT, NSSYM0(globals), GLOBALS);
    NcSetSlot(ROOT, NSSYM0(global_fns), GLOBAL_FNS);
    NcSetSlot(ROOT, NSSYM0(magic_pointers), MAGIC_POINTERS);
    NcSetSlot(ROOT, NSSYM0(sym_table), SYM_TABLE);

    // 環境変数の初期化
    NewtInitSysEnv();
    // ARGV の初期化
    NewtInitARGV(argc, argv, n);
    // バージョン情報の初期化
    NewtInitVersInfo();
}


/*------------------------------------------------------------------------*/
void NewtInit(int argc, const char * argv[], int n)
{
    // メモリプールの確保
    NEWT_POOL = NewtPoolAlloc(NEWT_POOL_EXPANDSPACE);
    // 実行環境の初期化
    NewtInitEnv(argc, argv, n);
}


/*------------------------------------------------------------------------*/
void NewtCleanup(void)
{
    // 後始末をすること

    // メモリプールの解放
    if (NEWT_POOL != NULL)
    {
        NewtPoolRelease(NEWT_POOL);
        NewtMemFree(NEWT_POOL);
        NEWT_POOL = NULL;
    }
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NewtLookupSymbolTable(const char * name)
{
    return NewtLookupSymbol(SYM_TABLE, name, 0, 0);
}


#pragma mark -
/*------------------------------------------------------------------------*/
bool NewtHasGlobalFn(newtRefArg r)
{
    return NewtHasSlot(GLOBAL_FNS, r);
}


/*------------------------------------------------------------------------*/
bool NewtHasGlobalVar(newtRefArg r)
{
    return NewtHasSlot(GLOBALS, r);
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NsGlobalFnExists(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtHasGlobalFn(r));
}


#ifdef __USE_OBSOLETE_STYLE__
/*------------------------------------------------------------------------*/
newtRef NsHasGlobalFn(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtHasGlobalFn(r));
}
#endif /* __USE_OBSOLETE_STYLE__ */


/*------------------------------------------------------------------------*/
newtRef NsGetGlobalFn(newtRefArg rcvr, newtRefArg r)
{
    return NcGetSlot(GLOBAL_FNS, r);
}


/*------------------------------------------------------------------------*/
newtRef NsDefGlobalFn(newtRefArg rcvr, newtRefArg r, newtRefArg fn)
{
    return NcSetSlot(GLOBAL_FNS, r, fn);
}


/*------------------------------------------------------------------------*/
newtRef NsUndefGlobalFn(newtRefArg rcvr, newtRefArg r)
{
    (void) NcRemoveSlot(GLOBAL_FNS, r);
    return kNewtRefNIL;
}


/*------------------------------------------------------------------------*/
newtRef NsGlobalVarExists(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtHasGlobalVar(r));
}


#ifdef __USE_OBSOLETE_STYLE__
/*------------------------------------------------------------------------*/
newtRef NsHasGlobalVar(newtRefArg rcvr, newtRefArg r)
{
    return NsGlobalVarExists(rcvr, r);
}
#endif /* __USE_OBSOLETE_STYLE__ */


/*------------------------------------------------------------------------*/
newtRef NsGetGlobalVar(newtRefArg rcvr, newtRefArg r)
{
    return NcGetSlot(GLOBALS, r);
}


/*------------------------------------------------------------------------*/
newtRef NsDefGlobalVar(newtRefArg rcvr, newtRefArg r, newtRefArg v)
{
    return NcSetSlot(GLOBALS, r, v);
}


#ifdef __USE_OBSOLETE_STYLE__
/*------------------------------------------------------------------------*/
newtRef NsSetGlobalVar(newtRefArg rcvr, newtRefArg r, newtRefArg v)
{
    return NcSetSlot(GLOBALS, r, v);
}
#endif /* __USE_OBSOLETE_STYLE__ */


/*------------------------------------------------------------------------*/
newtRef NsUndefGlobalVar(newtRefArg rcvr, newtRefArg r)
{
    (void) NcRemoveSlot(GLOBALS, r);
    return kNewtRefNIL;
}


#ifdef __NAMED_MAGIC_POINTER__

/*------------------------------------------------------------------------*/
newtRef NcResolveMagicPointer(newtRefArg r)
{
    newtRefVar  sym;

    if (! NewtRefIsMagicPointer(r))
        return r;

    sym = NewtMPToSymbol(r);

    if (NewtHasSlot(MAGIC_POINTERS, sym))
        return NcGetSlot(MAGIC_POINTERS, sym);
    else
        return r;
}


/*------------------------------------------------------------------------*/
newtRef NsDefMagicPointer(newtRefArg rcvr, newtRefArg r, newtRefArg v)
{
    newtRefVar  sym;

    if (NewtRefIsMagicPointer(r))
    {
        sym = NewtMPToSymbol(r);
    }
    else if (NewtRefIsSymbol(r))
    {
        sym = r;
    }
    else
    {
        return r;
    }

    return NcSetSlot(MAGIC_POINTERS, sym, v);
}


#else

/*------------------------------------------------------------------------*/
newtRef NcResolveMagicPointer(newtRefArg r)
{
    int32_t table = 0;
    int32_t index;

    if (! NewtRefIsMagicPointer(r))
        return r;

    table = NewtMPToTable(r);
    index = NewtMPToIndex(r);

    if (table != 0)
    {   // テーブル番号 0 以外は未サポート
        return r;
    }

    if (index < NewtLength(MAGIC_POINTERS))
    {
        newtRefVar  result;

        result = NewtGetArraySlot(MAGIC_POINTERS, index);

        if (result != kNewtRefUnbind)
            return result;
    }

    return r;
}


/*------------------------------------------------------------------------*/
newtRef NsDefMagicPointer(newtRefArg rcvr, newtRefArg r, newtRefArg v)
{
    int32_t table = 0;
    int32_t index;

    if (NewtRefIsMagicPointer(r))
    {
        table = NewtMPToTable(r);
        index = NewtMPToIndex(r);

        if (table != 0)
        {   // テーブル番号 0 以外は未サポート
            return kNewtRefUnbind;
        }
    }
    else if (NewtRefIsInteger(r))
    {
        index = NewtRefToInteger(r);
    }
    else
    {
        return kNewtRefUnbind;
    }

    if (NewtLength(MAGIC_POINTERS) <= index)
    {   // テーブルの長さを拡張
        NewtSetLength(MAGIC_POINTERS, index + 1);
    }

    return NewtSetArraySlot(MAGIC_POINTERS, index, v);
}

#endif


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NsGetRoot(newtRefArg rcvr)
{
    return ROOT;
}


/*------------------------------------------------------------------------*/
newtRef NsGetGlobals(newtRefArg rcvr)
{
    return GLOBALS;
}


/*------------------------------------------------------------------------*/
newtRef NsGetGlobalFns(newtRefArg rcvr)
{
    return GLOBAL_FNS;
}


/*------------------------------------------------------------------------*/
newtRef NsGetMagicPointers(newtRefArg rcvr)
{
    return MAGIC_POINTERS;
}


/*------------------------------------------------------------------------*/
newtRef NsGetSymTable(newtRefArg rcvr)
{
    return SYM_TABLE;
}

---