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     // ensure 'simple' ghost users don't see garbage for these fields
 125     type->get_member = 0;
 126     type->set_member = 0;
 127
 128     naRef ghost = naNew(c, T_GHOST);
 129     PTR(ghost).ghost->gtype = type;
 130     PTR(ghost).ghost->ptr = ptr;
 131     return ghost;
 132 }
 133
 134 naRef naNewGhost2(naContext c, naGhostType* t, void* ptr)
 135 {
 136     naRef ghost = naNew(c, T_GHOST);
 137     PTR(ghost).ghost->gtype = t;
 138     PTR(ghost).ghost->ptr = ptr;
 139     return ghost;
 140 }
 141
 142 naGhostType* naGhost_type(naRef ghost)
 143 {
 144     if(!IS_GHOST(ghost)) return 0;
 145     return PTR(ghost).ghost->gtype;
 146 }
 147
 148 void* naGhost_ptr(naRef ghost)
 149 {
 150     if(!IS_GHOST(ghost)) return 0;
 151     return PTR(ghost).ghost->ptr;
 152 }
 153
 154 naRef naNil()
 155 {
 156     naRef r;
 157     SETPTR(r, 0);
 158     return r;
 159 }
 160
 161 naRef naNum(double num)
 162 {
 163     naRef r;
 164     SETNUM(r, num);
 165     return r;
 166 }
 167
 168 int naEqual(naRef a, naRef b)
 169 {
 170     double na=0, nb=0;
 171     if(IS_REF(a) && IS_REF(b) && PTR(a).obj == PTR(b).obj)
 172         return 1; // Object identity (and nil == nil)
 173     if(IS_NIL(a) || IS_NIL(b))
 174         return 0;
 175     if(IS_NUM(a) && IS_NUM(b) && a.num == b.num)
 176         return 1; // Numeric equality
 177     if(IS_STR(a) && IS_STR(b) && naStr_equal(a, b))
 178         return 1; // String equality
 179
 180     // Numeric equality after conversion
 181     if(IS_NUM(a)) { na = a.num; }
 182     else if(!(IS_STR(a) && naStr_tonum(a, &na))) { return 0; }
 183
 184     if(IS_NUM(b)) { nb = b.num; }
 185     else if(!(IS_STR(b) && naStr_tonum(b, &nb))) { return 0; }
 186
 187     return na == nb ? 1 : 0;
 188 }
 189
 190 int naStrEqual(naRef a, naRef b)
 191 {
 192     int i;
 193     char *ap, *bp;
 194     if(!IS_STR(a) || !IS_STR(b) || naStr_len(a) != naStr_len(b))
 195         return 0;
 196     ap = naStr_data(a);
 197     bp = naStr_data(b);
 198     for(i=0; i<naStr_len(a); i++)
 199         if(ap[i] != bp[i])
 200             return 0;
 201     return 1;
 202 }
 203
 204 int naTypeSize(int type)
 205 {
 206     switch(type) {
 207     case T_STR: return sizeof(struct naStr);
 208     case T_VEC: return sizeof(struct naVec);
 209     case T_HASH: return sizeof(struct naHash);
 210     case T_CODE: return sizeof(struct naCode);
 211     case T_FUNC: return sizeof(struct naFunc);
 212     case T_CCODE: return sizeof(struct naCCode);
 213     case T_GHOST: return sizeof(struct naGhost);
 214     };
 215     return 0x7fffffff; // Make sure the answer is nonsense :)
 216 }
 217
 218 int naIsNil(naRef r)    { return IS_NIL(r); }
 219 int naIsNum(naRef r)    { return IS_NUM(r); }
 220 int naIsString(naRef r) { return IS_STR(r); }
 221 int naIsScalar(naRef r) { return IS_SCALAR(r); }
 222 int naIsVector(naRef r) { return IS_VEC(r); }
 223 int naIsHash(naRef r)   { return IS_HASH(r); }
 224 int naIsFunc(naRef r)   { return IS_FUNC(r); }
 225 int naIsCode(naRef r)   { return IS_CODE(r); }
 226 int naIsCCode(naRef r)  { return IS_CCODE(r); }
 227 int naIsGhost(naRef r)  { return IS_GHOST(r); }
 228
 229 void naSetUserData(naContext c, void* p) { c->userData = p; }
 230 void* naGetUserData(naContext c)
 231 {
 232     if(c->userData) return c->userData;
 233     return c->callParent ? naGetUserData(c->callParent) : 0;
 234 }
 235
 236 void naAddSym(naContext c, naRef ns, char *sym, naRef val)
 237 {
 238     naRef name = naStr_fromdata(naNewString(c), sym, strlen(sym));
 239     naHash_set(ns, naInternSymbol(name), val);
 240 }
 241
 242 naRef naGenLib(naContext c, naCFuncItem *fns)
 243 {
 244     naRef ns = naNewHash(c);
 245     for(/**/; fns->name; fns++)
 246         naAddSym(c, ns, fns->name, naNewFunc(c, naNewCCode(c, fns->func)));
 247     return ns;
 248 }