NewtEnv.h

説明を見る。

/*------------------------------------------------------------------------*/
#ifndef NEWTENV_H
#define NEWTENV_H


/* ヘッダファイル */
#include "NewtType.h"
#include "NewtMem.h"


/* マクロ */
#define NEWT_DEBUG          (newt_env._debug)               
#define NEWT_TRACE          (newt_env._trace)               
#define NEWT_DUMPLEX        (newt_env._dumpLex)             
#define NEWT_DUMPSYNTAX     (newt_env._dumpSyntax)          
#define NEWT_DUMPBC         (newt_env._dumpBC)              
#define NEWT_POOL           (newt_env.pool)                 
#define NEWT_SWEEP          (newt_env.sweep)                
#define NEWT_NEEDGC         (newt_env.needgc)               
#define NEWT_MODE_NOS2      (newt_env.mode.nos2)            

#define NSSTR(s)            (NewtMakeString(s, false))      
#define NSSTRCONST(s)       (NewtMakeString(s, true))       
#define NSINT(n)            (NewtMakeInteger(n))            
#define NSREAL(n)           (NewtMakeReal(n))               

#define NSSYM0(name)        newt_sym.name                   
#define NSSYM(name)         (NewtMakeSymbol(#name))         

#define NSNAMEDMP(name)     (NewtMakeNamedMP(#name))        
#define NSNAMEDMP0(name)    (NewtSymbolToMP(NSSYM0(name)))  
#define NSMP(n)             (NewtMakeMagicPointer(0, n))    

#define NS_CLASS            NSSYM0(__class)                 
#define NS_INT              NSSYM0(__int)                   
#define NS_CHAR             NSSYM0(__char)                  

#define NcGlobalFnExists(r)             NsGlobalFnExists(kNewtRefNIL, r)
#define NcGetGlobalFn(r)                NsGetGlobalFn(kNewtRefNIL, r)
#define NcDefGlobalFn(r, fn)            NsDefGlobalFn(kNewtRefNIL, r, fn)
#define NcUndefGlobalFn(r)              NsUndefGlobalFn(kNewtRefNIL, r)
#define NcGlobalVarExists(r)            NsGlobalVarExists(kNewtRefNIL, r)
#define NcGetGlobalVar(r)               NsGetGlobalVar(kNewtRefNIL, r)
#define NcDefGlobalVar(r, v)            NsDefGlobalVar(kNewtRefNIL, r, v)
#define NcUndefGlobalVar(r)             NsUndefGlobalVar(kNewtRefNIL, r)
#define NcDefMagicPointer(r, v)         NsDefMagicPointer(kNewtRefNIL, r, v)
#define NcGetRoot()                     NsGetRoot(kNewtRefNIL)
#define NcGetGlobals()                  NsGetGlobals(kNewtRefNIL)
#define NcGetGlobalFns()                NsGetGlobalFns(kNewtRefNIL)
#define NcGetMagicPointers()            NsGetMagicPointers(kNewtRefNIL)
#define NcGetSymTable()                 NsGetSymTable(kNewtRefNIL)

// OBSOLETE
#define NcHasGlobalFn(r)                NsGlobalFnExists(kNewtRefNIL, r)
#define NcHasGlobalVar(r)               NsGlobalVarExists(kNewtRefNIL, r)
#define NcSetGlobalVar(r, v)            NsDefGlobalVar(kNewtRefNIL, r, v)


typedef struct {
    newtRefVar  sym_table;      
    newtRefVar  root;           
    newtRefVar  globals;        
    newtRefVar  global_fns;     
    newtRefVar  magic_pointers; 

    // メモリ関係
    newtPool    pool;           
    bool        sweep;          
    bool        needgc;         

    struct {
        bool    nos2;           
    } mode;

    // デバッグ
    bool        _debug;         
    bool        _trace;         
    bool        _dumpLex;       
    bool        _dumpSyntax;    
    bool        _dumpBC;        
} newt_env_t;


typedef struct {
    // frame
    newtRefVar  _proto;             
    newtRefVar  _parent;            

    // function
    newtRefVar  _implementor;       
    newtRefVar  _nextArgFrame;      
    newtRefVar  CodeBlock;          
    newtRefVar  __class;            
    newtRefVar  instructions;       
    newtRefVar  literals;           
    newtRefVar  argFrame;           
    newtRefVar  numArgs;            
    newtRefVar  indefinite;         

    // native function

    struct {
        newtRefVar  native0;        
        newtRefVar  native;         
    } _function;

    newtRefVar  funcPtr;            
    newtRefVar  docString;          

    // classes or types
    newtRefVar  binary;             
    newtRefVar  string;             
    newtRefVar  real;               
    newtRefVar  array;              
    newtRefVar  frame;              
    newtRefVar  __int;              
    newtRefVar  int32;              
    newtRefVar  pathExpr;           

    // for loop
    newtRefVar  collect;            
    newtRefVar  deeply;             

    // class    
    newtRefVar  __char;             
    newtRefVar  boolean;            
    newtRefVar  weird_immediate;    
    newtRefVar  forEachState;       

    // functions（必須）
    newtRefVar  hasVariable;        
    newtRefVar  hasVar;             
    newtRefVar  defGlobalFn;        
    newtRefVar  defGlobalVar;       
//    newtRefVar    and;                ///< and
//    newtRefVar    or;                 ///< or
    newtRefVar  mod;                
    newtRefVar  shiftLeft;          
    newtRefVar  shiftRight;         
    newtRefVar  objectEqual;        
    newtRefVar  defMagicPointer;    
    newtRefVar  makeRegex;          

    // exception frame

    struct {
        newtRefVar  ref;            
    } type;

    struct {
        struct {
            newtRefVar  msg;        
        } ex;
    } ext;

    newtRefVar  name;               
    newtRefVar  data;               
    newtRefVar  message;            
    newtRefVar  error;              

    newtRefVar  errorCode;          
    newtRefVar  symbol;             
    newtRefVar  value;              
    newtRefVar  index;              

    // root
    newtRefVar  sym_table;          
    newtRefVar  globals;            
    newtRefVar  global_fns;         
    newtRefVar  magic_pointers;     

    // for print
    newtRefVar  printDepth;         
    newtRefVar  printLength;        

    // for regex
    newtRefVar  protoREGEX;         
    newtRefVar  regex;              
    newtRefVar  pattern;            
    newtRefVar  option;             

    // for require
    newtRefVar  requires;           

    // ENV
    newtRefVar  _ENV_;              
    newtRefVar  NEWTLIB;            

    // ARGV
    newtRefVar  _ARGV_;             
    newtRefVar  _EXEDIR_;           

    // stdout, stderr
    newtRefVar  _STDOUT_;           
    newtRefVar  _STDERR_;           
} newt_sym_t;


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


/* 関数プロトタイプ */

#ifdef __cplusplus
extern "C" {
#endif


char *      NewtDefaultEncoding(void);
void        NewtInit(int argc, const char * argv[], int n);
void        NewtCleanup(void);

newtRef     NewtLookupSymbolTable(const char * name);

bool        NewtHasGlobalFn(newtRefArg r);
bool        NewtHasGlobalVar(newtRefArg r);

// NewtonScript native functions(new style)
newtRef     NsGlobalFnExists(newtRefArg rcvr, newtRefArg r);
newtRef     NsGetGlobalFn(newtRefArg rcvr, newtRefArg r);
newtRef     NsDefGlobalFn(newtRefArg rcvr, newtRefArg r, newtRefArg fn);
newtRef     NsUndefGlobalFn(newtRefArg rcvr, newtRefArg r);
newtRef     NsGlobalVarExists(newtRefArg rcvr, newtRefArg r);
newtRef     NsGetGlobalVar(newtRefArg rcvr, newtRefArg r);
newtRef     NsDefGlobalVar(newtRefArg rcvr, newtRefArg r, newtRefArg v);
newtRef     NsUndefGlobalVar(newtRefArg rcvr, newtRefArg r);
newtRef     NcResolveMagicPointer(newtRefArg r);
newtRef     NsDefMagicPointer(newtRefArg rcvr, newtRefArg r, newtRefArg v);

newtRef     NsGetRoot(newtRefArg rcvr);
newtRef     NsGetGlobals(newtRefArg rcvr);
newtRef     NsGetGlobalFns(newtRefArg rcvr);
newtRef     NsGetMagicPointers(newtRefArg rcvr);
newtRef     NsGetSymTable(newtRefArg rcvr);

#ifdef __USE_OBSOLETE_STYLE__
newtRef     NsHasGlobalFn(newtRefArg rcvr, newtRefArg r);                   // OBSOLETE
newtRef     NsHasGlobalVar(newtRefArg rcvr, newtRefArg r);                  // OBSOLETE
newtRef     NsSetGlobalVar(newtRefArg rcvr, newtRefArg r, newtRefArg v);    // OBSOLETE
#endif /* __USE_OBSOLETE_STYLE__ */


#ifdef __cplusplus
}
#endif


#endif /* NEWTENV_H */

---