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