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->len = 0;
  81     PTR(s).str->data = 0;
  82     PTR(s).str->hashcode = 0;
  83     return s;
  84 }
  85
  86 naRef naNewVector(struct Context* c)
  87 {
  88     naRef r = naNew(c, T_VEC);
  89     PTR(r).vec->rec = 0;
  90     return r;
  91 }
  92
  93 naRef naNewHash(struct Context* c)
  94 {
  95     naRef r = naNew(c, T_HASH);
  96     PTR(r).hash->rec = 0;
  97     return r;
  98 }
  99
 100 naRef naNewCode(struct Context* c)
 101 {
 102     return naNew(c, T_CODE);
 103 }
 104
 105 naRef naNewCCode(struct Context* c, naCFunction fptr)
 106 {
 107     naRef r = naNew(c, T_CCODE);
 108     PTR(r).ccode->fptr = fptr;
 109     return r;
 110 }
 111
 112 naRef naNewFunc(struct Context* c, naRef code)
 113 {
 114     naRef func = naNew(c, T_FUNC);
 115     PTR(func).func->code = code;
 116     PTR(func).func->namespace = naNil();
 117     PTR(func).func->next = naNil();
 118     return func;
 119 }
 120
 121 naRef naNewGhost(naContext c, naGhostType* type, void* ptr)
 122 {
 123     naRef ghost = naNew(c, T_GHOST);
 124     PTR(ghost).ghost->gtype = type;
 125     PTR(ghost).ghost->ptr = ptr;
 126     return ghost;
 127 }
 128
 129 naGhostType* naGhost_type(naRef ghost)
 130 {
 131     if(!IS_GHOST(ghost)) return 0;
 132     return PTR(ghost).ghost->gtype;
 133 }
 134
 135 void* naGhost_ptr(naRef ghost)
 136 {
 137     if(!IS_GHOST(ghost)) return 0;
 138     return PTR(ghost).ghost->ptr;
 139 }
 140
 141 naRef naNil()
 142 {
 143     naRef r;
 144     SETPTR(r, 0);
 145     return r;
 146 }
 147
 148 naRef naNum(double num)
 149 {
 150     naRef r;
 151     SETNUM(r, num);
 152     return r;
 153 }
 154
 155 int naEqual(naRef a, naRef b)
 156 {
 157     double na=0, nb=0;
 158     if(IS_REF(a) && IS_REF(b) && PTR(a).obj == PTR(b).obj)
 159         return 1; // Object identity (and nil == nil)
 160     if(IS_NIL(a) || IS_NIL(b))
 161         return 0;
 162     if(IS_NUM(a) && IS_NUM(b) && a.num == b.num)
 163         return 1; // Numeric equality
 164     if(IS_STR(a) && IS_STR(b) && naStr_equal(a, b))
 165         return 1; // String equality
 166
 167     // Numeric equality after conversion
 168     if(IS_NUM(a)) { na = a.num; }
 169     else if(!(IS_STR(a) && naStr_tonum(a, &na))) { return 0; }
 170
 171     if(IS_NUM(b)) { nb = b.num; }
 172     else if(!(IS_STR(b) && naStr_tonum(b, &nb))) { return 0; }
 173
 174     return na == nb ? 1 : 0;
 175 }
 176
 177 int naStrEqual(naRef a, naRef b)
 178 {
 179     int i;
 180     if(!(IS_STR(a) && IS_STR(b)))
 181         return 0;
 182     if(PTR(a).str->len != PTR(b).str->len)
 183         return 0;
 184     for(i=0; i<PTR(a).str->len; i++)
 185         if(PTR(a).str->data[i] != PTR(b).str->data[i])
 186             return 0;
 187     return 1;
 188 }
 189
 190 int naTypeSize(int type)
 191 {
 192     switch(type) {
 193     case T_STR: return sizeof(struct naStr);
 194     case T_VEC: return sizeof(struct naVec);
 195     case T_HASH: return sizeof(struct naHash);
 196     case T_CODE: return sizeof(struct naCode);
 197     case T_FUNC: return sizeof(struct naFunc);
 198     case T_CCODE: return sizeof(struct naCCode);
 199     case T_GHOST: return sizeof(struct naGhost);
 200     };
 201     return 0x7fffffff; // Make sure the answer is nonsense :)
 202 }
 203
 204 int naIsNil(naRef r)    { return IS_NIL(r); }
 205 int naIsNum(naRef r)    { return IS_NUM(r); }
 206 int naIsString(naRef r) { return IS_STR(r); }
 207 int naIsScalar(naRef r) { return IS_SCALAR(r); }
 208 int naIsVector(naRef r) { return IS_VEC(r); }
 209 int naIsHash(naRef r)   { return IS_HASH(r); }
 210 int naIsFunc(naRef r)   { return IS_FUNC(r); }
 211 int naIsCode(naRef r)   { return IS_CODE(r); }
 212 int naIsCCode(naRef r)  { return IS_CCODE(r); }
 213 int naIsGhost(naRef r)  { return IS_GHOST(r); }
 214
 215 void naSetUserData(naContext c, void* p) { c->userData = p; }
 216 void* naGetUserData(naContext c)
 217 {
 218     if(c->userData) return c->userData;
 219     return c->callParent ? naGetUserData(c->callParent) : 0;
 220 }
 221
 222 void naAddSym(naContext c, naRef ns, char *sym, naRef val)
 223 {
 224     naRef name = naStr_fromdata(naNewString(c), sym, strlen(sym));
 225     naHash_set(ns, naInternSymbol(name), val);
 226 }
 227
 228 naRef naGenLib(naContext c, naCFuncItem *fns)
 229 {
 230     naRef ns = naNewHash(c);
 231     for(/**/; fns->name; fns++)
 232         naAddSym(c, ns, fns->name, naNewFunc(c, naNewCCode(c, fns->func)));
 233     return ns;
 234 }