4 /* This file is part of NIT ( http://www.nitlanguage.org ).
6 * Copyright 2006-2009 Jean Privat <jean@pryen.org>
8 * This file is free software, which comes along with NIT. This software is
9 * distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
10 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
11 * PARTICULAR PURPOSE. You can modify it is you want, provided this header
12 * is kept unaltered, and a notification of the changes is added.
13 * You are allowed to redistribute it and sell it, alone or is a part of
22 typedef signed long int bigint
; /* standard int value, must be larger that any poiner */
23 typedef bigint (*fun_t
) (bigint
); /* generic function pointer */
24 typedef bigint cid_t
; /* class identifier */
25 typedef char* cname_t
; /* class name */
26 typedef bigint val_t
; /* value (everything is a val_t) */
27 typedef union obj_tu
{union classtable_elt_tu
* vft
; bigint object_id
; val_t objectSize
;} *obj_t
; /* standard object */
28 typedef union classtable_elt_tu
{ bigint i
; fun_t f
; cid_t cid
; cname_t cname
;} classtable_elt_t
; /* classtable element */
29 typedef struct Nit_NativeArray
{const classtable_elt_t
* vft
; bigint object_id
; bigint size
; val_t val
[1];} * Nit_NativeArray
;
31 typedef classtable_elt_t
* classtable_t
; /* classtable */
33 extern bigint object_id_counter
;
35 /*****************************************************************************
36 * Types macros (primitive and less primitives) ******************************
37 *****************************************************************************
41 * OBJ (obj_t) : standard object representation (including boxes + NIL)
42 * Int (int) : integers
43 * Char (car) : characters
44 * Bool (int) : booleans (true or false)
46 * X (x_t) : generic representatio of the previous four types
50 * int ISX(val_t v) : true if v is a X
51 * x_t VAL2X(val_t v) : convert a val_t to a primitive type (you should check ISX before)
52 * val_t X2VAL(x_t x) : convert a type to a val_t
53 * int XTAG : numeric identifier of a type
54 * int TAG(val_t v) : return the XTAG (ie TAG(Char2VAL('e')) == CharTag)
56 * classtable_t VAL2VFT(val_t v): the virtual function table of a value
58 * val_t NIT_NULL : the instance of the None class
59 *****************************************************************************/
61 #define TAG(x) ((int)(x) & 3)
65 #define TAG_Int(x) ((val_t)(((x)<<2)|IntTAG))
66 #define UNTAG_Int(x) ((bigint)(x)>>2)
70 #define TAG_Char(x) ((val_t)((((int)(x))<<2)|CharTAG))
71 #define UNTAG_Char(x) ((char)((int)(x)>>2))
75 #define TAG_Bool(x) ((val_t)(((x)<<2)|BoolTAG))
76 #define UNTAG_Bool(x) ((int)(x)>>2)
81 #define ISOBJ(x) (TAG((x)) == OBJTAG)
82 #define VAL2OBJ(x) ((obj_t)(x))
83 #define VAL2ARRAY(x) ((Nit_NativeArray)(x))
84 #define OBJ2VAL(o) ((val_t)(o))
85 #define VAL2VFT(x) (ISOBJ(x) ? VAL2OBJ(x)->vft : TAG2VFT[TAG(x)])
86 /*#define VAL2CID(x) (ISOBJ(x) ? (VAL2OBJ(x)->vft->cid) : (-TAG(x)))*/
87 #define VAL2CID(x) (VAL2OBJ(x)->vft->cid)
89 #define NIT_NULL ((val_t)0)
90 #define ISNULL(x) ((x)==NIT_NULL)
92 /* Equal comparaison */
93 /* O = Non nil object ; N = Object or nil ; P = Primitive */
94 #define OBJ_IS_BOX(x) ((VAL2OBJ(x)->vft->i) < 0)
95 #define OBJ_IS_ARRAY(x) ((VAL2ARRAY(x)->vft[1].i) == -1)
96 #define IS_BOX(x) (ISOBJ(x) && OBJ_IS_BOX(x))
97 #define IS_EQUAL_BOX(x, y) (ISOBJ(y) && (VAL2OBJ(x)[2].vft==VAL2OBJ(y)[2].vft) && (VAL2OBJ(x)->vft==VAL2OBJ(y)->vft))
98 #define IS_EQUAL_OO(x, y) ((x)==(y) || (IS_BOX(x) && IS_EQUAL_BOX((x), (y))))
99 #define IS_EQUAL_ON(x, y) ((x)==(y) || (IS_BOX(x) && !ISNULL(y) && IS_EQUAL_BOX((x), (y))))
100 #define IS_EQUAL_NN(x, y) ((x)==(y) || (!ISNULL(x) && IS_BOX(x) && !ISNULL(y) && IS_EQUAL_BOX((x), (y))))
102 /* Subclass comparaison */
103 /* check is e is a subtype of c2 */
104 /* Warning, only subclasse comparaison is performed, not subtype */
105 /* e is a val (not nil) */
106 /* c a class name (eg: Int) */
107 #define VALISA(e, c) (VAL2VFT(e)[COLOR_ ## c].cid == (cid_t) ID_ ## c)
108 #define OBJISA(e, c) (VAL2OBJ(e)->vft[COLOR_ ## c].cid == (cid_t) ID_ ## c)
110 #define VAL_ISA(e, c, i) (VAL2VFT((e))[(c)].cid == (cid_t)(i))
112 /* GC and memory management */
113 void *alloc(size_t); /* allocate memory to store an object with an object header */
114 void *raw_alloc(size_t); /* allocate raw memory to store a raw stram of byte */
115 void register_static_object(val_t
*); /* mark that something is a global or once object */
118 extern val_t G_stdin
;
119 extern val_t G_stdout
;
120 extern val_t G_stderr
;
123 extern int glob_argc
;
124 extern char ** glob_argv
;
126 /* Native reference to Nit objects */
127 /* This structure is used to represent every Nit type in extern methods and custom C code. */
129 val_t val
; /* reference to the real Nit object, is kept up-to-date by GC */
130 struct nitni_ref
*next
, *prev
; /* adjacent global references in global list */
131 int count
; /* number of time this global reference has been marked */
134 /* This structure is used by extern methods to keep track of local references to Nit objects */
135 /* These references make sure an object is not collected by the GC while
136 * this extern methods is on the call stack. */
137 /* This takes the form of an array link, each link of size 8 to avoid multiple mallocs. */
138 #define NITNI_REF_ARRAY_LINK_SIZE 8
139 struct nitni_ref_array_link
{
140 struct nitni_ref
*reg
[ NITNI_REF_ARRAY_LINK_SIZE
];
141 int count
; /* nubmer of elements in this link */
142 struct nitni_ref_array_link
*next
; /* next link in the list */
145 /* Register reference to Nit object with the latest extern method called. */
146 extern void nitni_local_ref_add( struct nitni_ref
*ref
);
148 /* Clean all references associated to the current (but returning) extern method. */
149 extern void nitni_local_ref_clean( void );
151 /* List of global references from C code to Nit objects */
152 /* Instanciated empty at init of Nit system and filled explicitly by user in C code */
153 struct nitni_global_ref_list_t
{
154 struct nitni_ref
*head
, *tail
;
156 extern struct nitni_global_ref_list_t
*nitni_global_ref_list
;
158 /* Initializer of global reference list */
159 extern void nitni_global_ref_list_init();
161 /* Intern function to add a global reference to the list */
162 extern void nitni_global_ref_add( struct nitni_ref
*ref
);
164 /* Intern function to remove a global reference from the list */
165 extern void nitni_global_ref_remove( struct nitni_ref
*ref
);
167 /* Increase count on an existing global reference */
168 extern void nitni_global_ref_incr( struct nitni_ref
*ref
);
170 /* Decrease count on an existing global reference */
171 extern void nitni_global_ref_decr( struct nitni_ref
*ref
);
175 * - store local variables (REGS) of functions
176 * - store context for closure
177 * - provide information for stack dump
179 struct stack_frame_t
{
180 struct stack_frame_t
*prev
; /* previous stack frame */
181 const char *file
; /* source filename (.nit) */
182 int line
; /* line number (in the source) */
183 const char *meth
; /* human function name (usually the method name) */
184 struct stack_frame_t
*closure_ctx
; /* closure context (for functions that have closure parameters) */
185 fun_t
*closure_funs
; /* closure functions (for functions that have closure parameters) */
186 int has_broke
; /* has an escape occured? 0 if false, label_idx (>0) if true */
187 struct nitni_ref_array_link
*nitni_local_ref_head
; /* points to head of array link contaning local variables used via nitni */
188 int REG_size
; /* number of local variables */
189 val_t REG
[1]; /* local variables (flexible array, this must be the last variable is extended in fra struct */
191 extern struct stack_frame_t
*stack_frame_head
;
194 typedef enum {true = (1==1),false = (0==1)} bool;
197 void nit_abort(const char*, const char*, const char*, int);
199 #define CALL(r,c) ((VAL2VFT(r)[c].f))
200 #define ATTR(r,c) (*(val_t*)(VAL2OBJ(r)+c))
201 #define ATTRS(r,c,o) ((VAL2OBJ(r)+VAL2VFT(r)[c].i)[o].attr)
203 void prepare_signals(void);
204 extern classtable_t TAG2VFT
[4];
205 val_t
NEW_NativeArray(size_t length
, size_t size
);