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 naBZero(void* m, int n) { memset(m, 0, n); }
  11
  12 naRef naObj(int type, struct naObj* o)
  13 {
  14     naRef r;
  15     r.ref.reftag = NASAL_REFTAG;
  16     r.ref.ptr.obj = o;
  17     o->type = type;
  18     return r;
  19 }
  20
  21 int naTrue(naRef r)
  22 {
  23     if(IS_NIL(r)) return 0;
  24     if(IS_NUM(r)) return r.num != 0;
  25     if(IS_STR(r)) return 1;
  26     return 0;
  27 }
  28
  29 naRef naNumValue(naRef n)
  30 {
  31     double d;
  32     if(IS_NUM(n)) return n;
  33     if(IS_NIL(n)) return naNil();
  34     if(IS_STR(n) && naStr_tonum(n, &d))
  35         return naNum(d);
  36     return naNil();
  37 }
  38
  39 naRef naStringValue(naContext c, naRef r)
  40 {
  41     if(IS_NIL(r) || IS_STR(r)) return r;
  42     if(IS_NUM(r)) {
  43         naRef s = naNewString(c);
  44         naStr_fromnum(s, r.num);
  45         return s;
  46     }
  47     return naNil();
  48 }
  49
  50 naRef naNew(struct Context* c, int type)
  51 {
  52     naRef result = naObj(type, naGC_get(&(c->pools[type])));
  53     naVec_append(c->temps, result);
  54     return result;
  55 }
  56
  57 naRef naNewString(struct Context* c)
  58 {
  59     naRef s = naNew(c, T_STR);
  60     s.ref.ptr.str->len = 0;
  61     s.ref.ptr.str->data = 0;
  62     return s;
  63 }
  64
  65 naRef naNewVector(struct Context* c)
  66 {
  67     naRef r = naNew(c, T_VEC);
  68     naVec_init(r);
  69     return r;
  70 }
  71
  72 naRef naNewHash(struct Context* c)
  73 {
  74     naRef r = naNew(c, T_HASH);
  75     naHash_init(r);
  76     return r;
  77 }
  78
  79 naRef naNewCode(struct Context* c)
  80 {
  81     return naNew(c, T_CODE);
  82 }
  83
  84 naRef naNewCCode(struct Context* c, naCFunction fptr)
  85 {
  86     naRef r = naNew(c, T_CCODE);
  87     r.ref.ptr.ccode->fptr = fptr;
  88     return r;
  89 }
  90
  91 naRef naNewFunc(struct Context* c, naRef code)
  92 {
  93     naRef func = naNew(c, T_FUNC);
  94     func.ref.ptr.func->code = code;
  95     func.ref.ptr.func->closure = naNil();
  96     return func;
  97 }
  98
  99 naRef naNewClosure(struct Context* c, naRef namespace, naRef next)
 100 {
 101     naRef closure = naNew(c, T_CLOSURE);
 102     closure.ref.ptr.closure->namespace = namespace;
 103     closure.ref.ptr.closure->next = next;
 104     return closure;
 105 }
 106
 107 naRef naNewGhost(naContext c, naGhostType* type, void* ptr)
 108 {
 109     naRef ghost = naNew(c, T_GHOST);
 110     ghost.ref.ptr.ghost->gtype = type;
 111     ghost.ref.ptr.ghost->ptr = ptr;
 112     return ghost;
 113 }
 114
 115 naGhostType* naGhost_type(naRef ghost)
 116 {
 117     if(!IS_GHOST(ghost)) return 0;
 118     return ghost.ref.ptr.ghost->gtype;
 119 }
 120
 121 void* naGhost_ptr(naRef ghost)
 122 {
 123     if(!IS_GHOST(ghost)) return 0;
 124     return ghost.ref.ptr.ghost->ptr;
 125 }
 126
 127 naRef naNil()
 128 {
 129     naRef r;
 130     r.ref.reftag = NASAL_REFTAG;
 131     r.ref.ptr.obj = 0;
 132     return r;
 133 }
 134
 135 naRef naNum(double num)
 136 {
 137     naRef r;
 138     r.num = num;
 139     return r;
 140 }
 141
 142 int naEqual(naRef a, naRef b)
 143 {
 144     double na=0, nb=0;
 145     if(IS_REF(a) && IS_REF(b) && a.ref.ptr.obj == b.ref.ptr.obj)
 146         return 1; // Object identity (and nil == nil)
 147     if(IS_NIL(a) || IS_NIL(b))
 148         return 0;
 149     if(IS_NUM(a) && IS_NUM(b) && a.num == b.num)
 150         return 1; // Numeric equality
 151     if(IS_STR(a) && IS_STR(b) && naStr_equal(a, b))
 152         return 1; // String equality
 153
 154     // Numeric equality after conversion
 155     if(IS_NUM(a)) { na = a.num; }
 156     else if(!(IS_STR(a) && naStr_tonum(a, &na))) { return 0; }
 157
 158     if(IS_NUM(b)) { nb = b.num; }
 159     else if(!(IS_STR(b) && naStr_tonum(b, &nb))) { return 0; }
 160
 161     return na == nb ? 1 : 0;
 162 }
 163
 164 int naTypeSize(int type)
 165 {
 166     switch(type) {
 167     case T_STR: return sizeof(struct naStr);
 168     case T_VEC: return sizeof(struct naVec);
 169     case T_HASH: return sizeof(struct naHash);
 170     case T_CODE: return sizeof(struct naCode);
 171     case T_FUNC: return sizeof(struct naFunc);
 172     case T_CLOSURE: return sizeof(struct naClosure);
 173     case T_CCODE: return sizeof(struct naCCode);
 174     case T_GHOST: return sizeof(struct naGhost);
 175     };
 176     return 0x7fffffff; // Make sure the answer is nonsense :)
 177 }
 178
 179 int naIsNil(naRef r)
 180 {
 181     return IS_NIL(r);
 182 }
 183
 184 int naIsNum(naRef r)
 185 {
 186     return IS_NUM(r);
 187 }
 188
 189 int naIsString(naRef r)
 190 {
 191     return (!IS_NIL(r))&&IS_STR(r);
 192 }
 193
 194 int naIsScalar(naRef r)
 195 {
 196     return IS_SCALAR(r);
 197 }
 198
 199 int naIsVector(naRef r)
 200 {
 201     return (!IS_NIL(r))&&IS_VEC(r);
 202 }
 203
 204 int naIsHash(naRef r)
 205 {
 206     return (!IS_NIL(r))&&IS_HASH(r);
 207 }
 208
 209 int naIsFunc(naRef r)
 210 {
 211     return (!IS_NIL(r))&&IS_FUNC(r);
 212 }
 213
 214 int naIsCode(naRef r)
 215 {
 216     return IS_CODE(r);
 217 }
 218
 219 int naIsCCode(naRef r)
 220 {
 221     return IS_CCODE(r);
 222 }
 223
 224 int naIsGhost(naRef r)
 225 {
 226     return IS_GHOST(r);
 227 }