simgear/nasal/misc.c

   1 #include <string.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4
   5 #include "nasal.h"
   6 #include "code.h"
   7
   8 void naFree(void* m) { free(m); }
   9 void* naAlloc(int n) { return malloc(n); }
  10 void* naRealloc(void* b, int n) { return realloc(b, n); }
  11 void naBZero(void* m, int n) { memset(m, 0, n); }
  12
  13 void naTempSave(naContext c, naRef r)
  14 {
  15     int i;
  16     if(!IS_OBJ(r)) return;
  17     if(c->ntemps >= c->tempsz) {
  18         struct naObj** newtemps;
  19         c->tempsz *= 2;
  20         newtemps = naAlloc(c->tempsz * sizeof(struct naObj*));
  21         for(i=0; i<c->ntemps; i++)
  22             newtemps[i] = c->temps[i];
  23         naFree(c->temps);
  24         c->temps = newtemps;
  25     }
  26     c->temps[c->ntemps++] = PTR(r).obj;
  27 }
  28
  29 naRef naObj(int type, struct naObj* o)
  30 {
  31     naRef r;
  32     SETPTR(r, o);
  33     o->type = type;
  34     return r;
  35 }
  36
  37 int naTrue(naRef r)
  38 {
  39     if(IS_NIL(r)) return 0;
  40     if(IS_NUM(r)) return r.num != 0;
  41     if(IS_STR(r)) return 1;
  42     return 0;
  43 }
  44
  45 naRef naNumValue(naRef n)
  46 {
  47     double d;
  48     if(IS_NUM(n)) return n;
  49     if(IS_NIL(n)) return naNil();
  50     if(IS_STR(n) && naStr_tonum(n, &d))
  51         return naNum(d);
  52     return naNil();
  53 }
  54
  55 naRef naStringValue(naContext c, naRef r)
  56 {
  57     if(IS_NIL(r) || IS_STR(r)) return r;
  58     if(IS_NUM(r)) {
  59         naRef s = naNewString(c);
  60         naStr_fromnum(s, r.num);
  61         return s;
  62     }
  63     return naNil();
  64 }
  65
  66 naRef naNew(struct Context* c, int type)
  67 {
  68     naRef result;
  69     if(c->nfree[type] == 0)
  70         c->free[type] = naGC_get(&globals->pools[type],
  71                                  OBJ_CACHE_SZ, &c->nfree[type]);
  72     result = naObj(type, c->free[type][--c->nfree[type]]);
  73     naTempSave(c, result);
  74     return result;
  75 }
  76
  77 naRef naNewString(struct Context* c)
  78 {
  79     naRef s = naNew(c, T_STR);
  80     PTR(s).str->emblen = 0;
  81     PTR(s).str->data.ref.len = 0;
  82     PTR(s).str->data.ref.ptr = 0;
  83     PTR(s).str->hashcode = 0;
  84     return s;
  85 }
  86
  87 naRef naNewVector(struct Context* c)
  88 {
  89     naRef r = naNew(c, T_VEC);
  90     PTR(r).vec->rec = 0;
  91     return r;
  92 }
  93
  94 naRef naNewHash(struct Context* c)
  95 {
  96     naRef r = naNew(c, T_HASH);
  97     PTR(r).hash->rec = 0;
  98     return r;
  99 }
 100
 101 naRef naNewCode(struct Context* c)
 102 {
 103     return naNew(c, T_CODE);
 104 }
 105
 106 naRef naNewCCode(struct Context* c, naCFunction fptr)
 107 {
 108     naRef r = naNew(c, T_CCODE);
 109     PTR(r).ccode->fptr = fptr;
 110     return r;
 111 }
 112
 113 naRef naNewFunc(struct Context* c, naRef code)
 114 {
 115     naRef func = naNew(c, T_FUNC);
 116     PTR(func).func->code = code;
 117     PTR(func).func->namespace = naNil();
 118     PTR(func).func->next = naNil();
 119     return func;
 120 }
 121
 122 naRef naNewGhost(naContext c, naGhostType* type, void* ptr)
 123 {
 124     naRef ghost;
 125     // ensure 'simple' ghost users don't see garbage for these fields
 126     type->get_member = 0;
 127     type->set_member = 0;
 128
 129     ghost = naNew(c, T_GHOST);
 130     PTR(ghost).ghost->gtype = type;
 131     PTR(ghost).ghost->ptr = ptr;
 132     return ghost;
 133 }
 134
 135 naRef naNewGhost2(naContext c, naGhostType* t, void* ptr)
 136 {
 137     naRef ghost = naNew(c, T_GHOST);
 138     PTR(ghost).ghost->gtype = t;
 139     PTR(ghost).ghost->ptr = ptr;
 140     return ghost;
 141 }
 142
 143 naGhostType* naGhost_type(naRef ghost)
 144 {
 145     if(!IS_GHOST(ghost)) return 0;
 146     return PTR(ghost).ghost->gtype;
 147 }
 148
 149 void* naGhost_ptr(naRef ghost)
 150 {
 151     if(!IS_GHOST(ghost)) return 0;
 152     return PTR(ghost).ghost->ptr;
 153 }
 154
 155 naRef naNil()
 156 {
 157     naRef r;
 158     SETPTR(r, 0);
 159     return r;
 160 }
 161
 162 naRef naNum(double num)
 163 {
 164     naRef r;
 165     SETNUM(r, num);
 166     return r;
 167 }
 168
 169 int naEqual(naRef a, naRef b)
 170 {
 171     double na=0, nb=0;
 172     if(IS_REF(a) && IS_REF(b) && PTR(a).obj == PTR(b).obj)
 173         return 1; // Object identity (and nil == nil)
 174     if(IS_NIL(a) || IS_NIL(b))
 175         return 0;
 176     if(IS_NUM(a) && IS_NUM(b) && a.num == b.num)
 177         return 1; // Numeric equality
 178     if(IS_STR(a) && IS_STR(b) && naStr_equal(a, b))
 179         return 1; // String equality
 180
 181     // Numeric equality after conversion
 182     if(IS_NUM(a)) { na = a.num; }
 183     else if(!(IS_STR(a) && naStr_tonum(a, &na))) { return 0; }
 184
 185     if(IS_NUM(b)) { nb = b.num; }
 186     else if(!(IS_STR(b) && naStr_tonum(b, &nb))) { return 0; }
 187
 188     return na == nb ? 1 : 0;
 189 }
 190
 191 int naStrEqual(naRef a, naRef b)
 192 {
 193     int i;
 194     char *ap, *bp;
 195     if(!IS_STR(a) || !IS_STR(b) || naStr_len(a) != naStr_len(b))
 196         return 0;
 197     ap = naStr_data(a);
 198     bp = naStr_data(b);
 199     for(i=0; i<naStr_len(a); i++)
 200         if(ap[i] != bp[i])
 201             return 0;
 202     return 1;
 203 }
 204
 205 int naTypeSize(int type)
 206 {
 207     switch(type) {
 208     case T_STR: return sizeof(struct naStr);
 209     case T_VEC: return sizeof(struct naVec);
 210     case T_HASH: return sizeof(struct naHash);
 211     case T_CODE: return sizeof(struct naCode);
 212     case T_FUNC: return sizeof(struct naFunc);
 213     case T_CCODE: return sizeof(struct naCCode);
 214     case T_GHOST: return sizeof(struct naGhost);
 215     };
 216     return 0x7fffffff; // Make sure the answer is nonsense :)
 217 }
 218
 219 int naIsNil(naRef r)    { return IS_NIL(r); }
 220 int naIsNum(naRef r)    { return IS_NUM(r); }
 221 int naIsString(naRef r) { return IS_STR(r); }
 222 int naIsScalar(naRef r) { return IS_SCALAR(r); }
 223 int naIsVector(naRef r) { return IS_VEC(r); }
 224 int naIsHash(naRef r)   { return IS_HASH(r); }
 225 int naIsFunc(naRef r)   { return IS_FUNC(r); }
 226 int naIsCode(naRef r)   { return IS_CODE(r); }
 227 int naIsCCode(naRef r)  { return IS_CCODE(r); }
 228 int naIsGhost(naRef r)  { return IS_GHOST(r); }
 229
 230 void naSetUserData(naContext c, void* p) { c->userData = p; }
 231 void* naGetUserData(naContext c)
 232 {
 233     if(c->userData) return c->userData;
 234     return c->callParent ? naGetUserData(c->callParent) : 0;
 235 }
 236
 237 void naAddSym(naContext c, naRef ns, char *sym, naRef val)
 238 {
 239     naRef name = naStr_fromdata(naNewString(c), sym, strlen(sym));
 240     naHash_set(ns, naInternSymbol(name), val);
 241 }
 242
 243 naRef naGenLib(naContext c, naCFuncItem *fns)
 244 {
 245     naRef ns = naNewHash(c);
 246     for(/**/; fns->name; fns++)
 247         naAddSym(c, ns, fns->name, naNewFunc(c, naNewCCode(c, fns->func)));
 248     return ns;
 249 }