// bitmask that sets the top 16 bits. As a double, this is a
// signalling NaN that cannot itself be produced by normal numerics
// code. The pointer value can be reconstructed if (and only if) we
-// are guaranteed that all memory that can be poitned to by a naRef
+// are guaranteed that all memory that can be pointed to by a naRef
// (i.e. all memory returned by naAlloc) lives in the bottom 48 bits
// of memory. Linux on x86_64, Win64, Solaris and Irix all have such
// policies with address spaces:
#define IS_GHOST(r) (IS_OBJ(r) && PTR(r).obj->type == T_GHOST)
#define IS_CONTAINER(r) (IS_VEC(r)||IS_HASH(r))
#define IS_SCALAR(r) (IS_NUM(r) || IS_STR(r))
-#define IDENTICAL(a, b) (IS_REF(a) && IS_REF(b) \
- && PTR(a).obj == PTR(b).obj)
+#define IDENTICAL(a, b) (IS_REF(a) && IS_REF(b) && PTR(a).obj == PTR(b).obj)
#define MUTABLE(r) (IS_STR(r) && PTR(r).str->hashcode == 0)
// This is a macro instead of a separate struct to allow compilers to
-// avoid padding. GCC on x86, at least, will always padd the size of
+// avoid padding. GCC on x86, at least, will always pad the size of
// an embedded struct up to 32 bits. Doing it this way allows the
// implementing objects to pack in 16 bits worth of data "for free".
#define GC_HEADER \
GC_HEADER;
};
+#define MAX_STR_EMBLEN 15
struct naStr {
GC_HEADER;
- int len;
- unsigned char* data;
+ char emblen; /* [0-15], or -1 to indicate "not embedded" */
unsigned int hashcode;
+ union {
+ unsigned char buf[16];
+ struct {
+ int len;
+ unsigned char* ptr;
+ } ref;
+ } data;
};
struct VecRec {
struct HashNode* next;
};
-struct HashRec {
- int size;
- int dels;
- int lgalloced;
- struct HashNode* nodes;
- struct HashNode* table[];
-};
-
struct naHash {
GC_HEADER;
struct HashRec* rec;
struct naCode {
GC_HEADER;
- unsigned char nArgs;
- unsigned char nOptArgs;
- unsigned char needArgVector;
+ unsigned int nArgs : 5;
+ unsigned int nOptArgs : 5;
+ unsigned int needArgVector : 1;
unsigned short nConstants;
- unsigned short nLines;
unsigned short codesz;
- unsigned short* byteCode;
- naRef* constants;
- int* argSyms; // indices into constants
- int* optArgSyms;
- int* optArgVals;
- unsigned short* lineIps; // pairs of {ip, line}
+ unsigned short restArgSym; // The "..." vector name, defaults to "arg"
+ unsigned short nLines;
naRef srcFile;
- naRef restArgSym; // The "..." vector name, defaults to "arg"
+ naRef* constants;
};
+/* naCode objects store their variable length arrays in a single block
+ * starting with their constants table. Compute indexes at runtime
+ * for space efficiency: */
+#define BYTECODE(c) ((unsigned short*)((c)->constants+(c)->nConstants))
+#define ARGSYMS(c) (BYTECODE(c)+(c)->codesz)
+#define OPTARGSYMS(c) (ARGSYMS(c)+(c)->nArgs)
+#define OPTARGVALS(c) (OPTARGSYMS(c)+(c)->nOptArgs)
+#define LINEIPS(c) (OPTARGVALS(c)+(c)->nOptArgs)
+
struct naFunc {
GC_HEADER;
naRef code;
int naStr_tonum(naRef str, double* out);
naRef naStr_buf(naRef str, int len);
-int naHash_tryset(naRef hash, naRef key, naRef val); // sets if exists
-int naHash_sym(struct naHash* h, struct naStr* sym, naRef* out);
-void naHash_newsym(struct naHash* h, naRef* sym, naRef* val);
+int naiHash_tryset(naRef hash, naRef key, naRef val); // sets if exists
+int naiHash_sym(struct naHash* h, struct naStr* sym, naRef* out);
+void naiHash_newsym(struct naHash* h, naRef* sym, naRef* val);
void naGC_init(struct naPool* p, int type);
struct naObj** naGC_get(struct naPool* p, int n, int* nout);
void naGC_swapfree(void** target, void* val);
void naGC_freedead();
+void naiGCMark(naRef r);
+void naiGCMarkHash(naRef h);
void naStr_gcclean(struct naStr* s);
void naVec_gcclean(struct naVec* s);
-void naHash_gcclean(struct naHash* s);
+void naiGCHashClean(struct naHash* h);
#endif // _DATA_H