#include "jsvar.h"

#include "jsvarcache.h"

#include "jslex.h"

#include "jsparse.h"

#include "jswrap_json.h"

#include "jsinteractive.h"

#include "jswrapper.h"

#include "jswrap_math.h" // for jswrap_math_mod

#include "jswrap_object.h" // for jswrap_object_toString

#include "jswrap_arraybuffer.h" // for jsvNewTypedArray

ALWAYS_INLINE bool jsvIsRoot(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_ROOT; }

ALWAYS_INLINE bool jsvIsPin(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_PIN; }

ALWAYS_INLINE bool jsvIsSimpleInt(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_INTEGER; } // is just a very basic integer value

ALWAYS_INLINE bool jsvIsInt(const JsVar *v) { return v && ((v->flags&JSV_VARTYPEMASK)==JSV_INTEGER || (v->flags&JSV_VARTYPEMASK)==JSV_PIN || (v->flags&JSV_VARTYPEMASK)==JSV_NAME_INT || (v->flags&JSV_VARTYPEMASK)==JSV_NAME_INT_INT || (v->flags&JSV_VARTYPEMASK)==JSV_NAME_INT_BOOL); }

ALWAYS_INLINE bool jsvIsFloat(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_FLOAT; }

ALWAYS_INLINE bool jsvIsBoolean(const JsVar *v) { return v && ((v->flags&JSV_VARTYPEMASK)==JSV_BOOLEAN || (v->flags&JSV_VARTYPEMASK)==JSV_NAME_INT_BOOL); }

ALWAYS_INLINE bool jsvIsString(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)>=_JSV_STRING_START && (v->flags&JSV_VARTYPEMASK)<=_JSV_STRING_END; } ///< String, or a NAME too

ALWAYS_INLINE bool jsvIsBasicString(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)>=JSV_STRING_0 && (v->flags&JSV_VARTYPEMASK)<=JSV_STRING_MAX; } ///< Just a string (NOT a name)

ALWAYS_INLINE bool jsvIsStringExt(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)>=JSV_STRING_EXT_0 && (v->flags&JSV_VARTYPEMASK)<=JSV_STRING_EXT_MAX; } ///< The extra bits dumped onto the end of a string to store more data

ALWAYS_INLINE bool jsvIsFlatString(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_FLAT_STRING; }

ALWAYS_INLINE bool jsvIsNativeString(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_NATIVE_STRING; }

ALWAYS_INLINE bool jsvIsNumeric(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)>=_JSV_NUMERIC_START && (v->flags&JSV_VARTYPEMASK)<=_JSV_NUMERIC_END; }

ALWAYS_INLINE bool jsvIsFunction(const JsVar *v) { return v && ((v->flags&JSV_VARTYPEMASK)==JSV_FUNCTION || (v->flags&JSV_VARTYPEMASK)==JSV_FUNCTION_RETURN); }

ALWAYS_INLINE bool jsvIsFunctionReturn(const JsVar *v) { return v && ((v->flags&JSV_VARTYPEMASK)==JSV_FUNCTION_RETURN); } ///< Is this a function with an implicit 'return' at the start?

ALWAYS_INLINE bool jsvIsFunctionParameter(const JsVar *v) { return v && (v->flags&JSV_NATIVE) && jsvIsString(v); }

ALWAYS_INLINE bool jsvIsObject(const JsVar *v) { return v && (((v->flags&JSV_VARTYPEMASK)==JSV_OBJECT) || ((v->flags&JSV_VARTYPEMASK)==JSV_ROOT)); }

ALWAYS_INLINE bool jsvIsArray(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_ARRAY; }

ALWAYS_INLINE bool jsvIsArrayBuffer(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_ARRAYBUFFER; }

ALWAYS_INLINE bool jsvIsArrayBufferName(const JsVar *v) { return v && (v->flags&(JSV_VARTYPEMASK))==JSV_ARRAYBUFFERNAME; }

ALWAYS_INLINE bool jsvIsNative(const JsVar *v) { return v && (v->flags&JSV_NATIVE)!=0; }

ALWAYS_INLINE bool jsvIsNativeFunction(const JsVar *v) { return v && (v->flags&(JSV_NATIVE|JSV_VARTYPEMASK))==(JSV_NATIVE|JSV_FUNCTION); }

ALWAYS_INLINE bool jsvIsUndefined(const JsVar *v) { return v==0; }

ALWAYS_INLINE bool jsvIsNull(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_NULL; }

ALWAYS_INLINE bool jsvIsBasic(const JsVar *v) { return jsvIsNumeric(v) || jsvIsString(v);} ///< Is this *not* an array/object/etc

ALWAYS_INLINE bool jsvIsName(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)>=_JSV_NAME_START && (v->flags&JSV_VARTYPEMASK)<=_JSV_NAME_END; } ///< NAMEs are what's used to name a variable (it is not the data itself)

ALWAYS_INLINE bool jsvIsNameWithValue(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)>=_JSV_NAME_WITH_VALUE_START && (v->flags&JSV_VARTYPEMASK)<=_JSV_NAME_WITH_VALUE_END; }

ALWAYS_INLINE bool jsvIsNameInt(const JsVar *v) { return v && ((v->flags&JSV_VARTYPEMASK)==JSV_NAME_INT_INT || ((v->flags&JSV_VARTYPEMASK)>=JSV_NAME_STRING_INT_0 && (v->flags&JSV_VARTYPEMASK)<=JSV_NAME_STRING_INT_MAX)); }

ALWAYS_INLINE bool jsvIsNameIntInt(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_NAME_INT_INT; }

ALWAYS_INLINE bool jsvIsNameIntBool(const JsVar *v) { return v && (v->flags&JSV_VARTYPEMASK)==JSV_NAME_INT_BOOL; }

ALWAYS_INLINE bool jsvIsNewChild(const JsVar *v) { return jsvIsName(v) && jsvGetNextSibling(v) && jsvGetNextSibling(v)==jsvGetPrevSibling(v); }

ALWAYS_INLINE bool jsvIsRefUsedForData(const JsVar *v) { return jsvIsStringExt(v) || (jsvIsString(v)&&!jsvIsName(v)) || jsvIsFloat(v) || jsvIsNativeFunction(v) || jsvIsArrayBuffer(v) || jsvIsArrayBufferName(v); }

ALWAYS_INLINE bool jsvIsIntegerish(const JsVar *v) { return jsvIsInt(v) || jsvIsPin(v) || jsvIsBoolean(v) || jsvIsNull(v); }

ALWAYS_INLINE bool jsvIsIterable(const JsVar *v) {

return jsvIsArray(v) || jsvIsObject(v) || jsvIsFunction(v) ||

jsvIsString(v) || jsvIsArrayBuffer(v);

}

#ifdef JSVARREF_PACKED_BITS

#define JSVARREF_PACKED_BIT_MASK ((1U<<JSVARREF_PACKED_BITS)-1)

JsVarRef jsvGetFirstChild(const JsVar *v) { return (JsVarRef)(v->varData.ref.firstChild | (((v->varData.ref.pack)&JSVARREF_PACKED_BIT_MASK))<<8); }

JsVarRefSigned jsvGetFirstChildSigned(const JsVar *v) {

JsVarRefSigned r = (JsVarRefSigned)jsvGetFirstChild(v);

if (r & (1<<(JSVARREF_PACKED_BITS+7)))

r -= 1<<(JSVARREF_PACKED_BITS+8);

return r;

}

JsVarRef jsvGetNextSibling(const JsVar *v) { return (JsVarRef)(v->varData.ref.nextSibling | (((v->varData.ref.pack >> (JSVARREF_PACKED_BITS*2))&JSVARREF_PACKED_BIT_MASK))<<8); }

JsVarRef jsvGetPrevSibling(const JsVar *v) { return (JsVarRef)(v->varData.ref.prevSibling | (((v->varData.ref.pack >> (JSVARREF_PACKED_BITS*3))&JSVARREF_PACKED_BIT_MASK))<<8); }

void jsvSetFirstChild(JsVar *v, JsVarRef r) {

v->varData.ref.firstChild = (unsigned char)(r & 0xFF);

v->varData.ref.pack = (unsigned char)((v->varData.ref.pack & ~JSVARREF_PACKED_BIT_MASK) | ((r >> 8) & JSVARREF_PACKED_BIT_MASK));

}

void jsvSetNextSibling(JsVar *v, JsVarRef r) {

v->varData.ref.nextSibling = (unsigned char)(r & 0xFF);

v->varData.ref.pack = (unsigned char)((v->varData.ref.pack & ~(JSVARREF_PACKED_BIT_MASK<<(JSVARREF_PACKED_BITS*2))) | (((r >> 8) & JSVARREF_PACKED_BIT_MASK) << (JSVARREF_PACKED_BITS*2)));

}

void jsvSetPrevSibling(JsVar *v, JsVarRef r) {

v->varData.ref.prevSibling = (unsigned char)(r & 0xFF);

v->varData.ref.pack = (unsigned char)((v->varData.ref.pack & ~(JSVARREF_PACKED_BIT_MASK<<(JSVARREF_PACKED_BITS*3))) | (((r >> 8) & JSVARREF_PACKED_BIT_MASK) << (JSVARREF_PACKED_BITS*3)));

}

JsVarRef jsvGetLastChild(const JsVar *v) {

return (JsVarRef)(v->varData.ref.lastChild | (((v->flags >> JSV_LASTCHILD_BIT_SHIFT)&JSVARREF_PACKED_BIT_MASK))<<8);

}

void jsvSetLastChild(JsVar *v, JsVarRef r) {

v->varData.ref.lastChild = (unsigned char)(r & 0xFF);

v->flags = (v->flags & ~JSV_LASTCHILD_BIT_MASK) | ((r >> 8) << JSV_LASTCHILD_BIT_SHIFT);

}

bool jsvHasCharacterData(const JsVar *v) {

return jsvIsString(v) || jsvIsStringExt(v);

}

bool jsvHasStringExt(const JsVar *v) {

return jsvIsString(v) || jsvIsStringExt(v);

}

bool jsvHasChildren(const JsVar *v) {

return jsvIsFunction(v) || jsvIsObject(v) || jsvIsArray(v) || jsvIsRoot(v);

}

bool jsvHasSingleChild(const JsVar *v) {

return jsvIsArrayBuffer(v) ||

(jsvIsName(v) && !jsvIsNameWithValue(v));

}

JsVar *jsvFindOrCreateRoot() {

JsVarRef i;

for (i=1;i<=jsvGetMemoryTotal();i++)

if (jsvIsRoot(_jsvGetAddressOf(i)))

return jsvLock(i);

return jsvRef(jsvNewWithFlags(JSV_ROOT));

}

void jsvResetVariable(JsVar *v, JsVarFlags flags) {

assert((v->flags&JSV_VARTYPEMASK) == JSV_UNUSED);

// make sure we clear all data...

/* Force a proper zeroing of all data. We don't use

unsigned int i;

assert((sizeof(JsVar)&3) == 0); // must be a multiple of 4 in size

for (i=0;i<sizeof(JsVar)/sizeof(uint32_t);i++)

((uint32_t*)v)[i] = 0;

// set flags

assert(!(flags & JSV_LOCK_MASK));

v->flags = flags | JSV_LOCK_ONE;

}

JsVar *jsvNewWithFlags(JsVarFlags flags) {

if (isMemoryBusy) {

jsErrorFlags |= JSERR_MEMORY_BUSY;

return 0;

}

if (jsVarFirstEmpty!=0) {

assert(_jsvGetAddressOf(jsVarFirstEmpty)->flags == JSV_UNUSED);

jshInterruptOff(); // to allow this to be used from an IRQ

JsVar *v = jsvLock(jsVarFirstEmpty); // jsvResetVariable will lock

jsVarFirstEmpty = jsvGetNextSibling(v); // move our reference to the next in the fr

jshInterruptOn();

assert(v->flags == JSV_UNUSED);

// Cope with IRQs/multi-threading when getting a new free variable

/* JsVarRef empty;

jsvResetVariable(v, flags); // setup variable, and add one lock

// return pointer

return v;

}

jsErrorFlags |= JSERR_LOW_MEMORY;

/* we don't have memory - second last hope - run garbage collector */

if (jsvGarbageCollect()) {

return jsvNewWithFlags(flags); // if it freed something, continue

}

/* we don't have memory - last hope - ask jsInteractive to try and free some it

if (jsiFreeMoreMemory()) {

return jsvNewWithFlags(flags);

}

/* We couldn't claim any more memory by Garbage collecting... */

#ifdef RESIZABLE_JSVARS

jsvSetMemoryTotal(jsvGetMemoryTotal()*2);

return jsvNewWithFlags(flags);

// On a micro, we're screwed.

if (!(jsErrorFlags&JSERR_MEMORY))

jsError("Out of Memory!");

jsErrorFlags |= JSERR_MEMORY;

jspSetInterrupted(true);

return 0;

}

ALWAYS_INLINE void jsvFreePtrInternal(JsVar *var) {

assert(jsvGetLocks(var)==0);

var->flags = JSV_UNUSED;

// add this to our free list

jshInterruptOff(); // to allow this to be used from an IRQ

jsvSetNextSibling(var, jsVarFirstEmpty);

jsVarFirstEmpty = jsvGetRef(var);

jshInterruptOn();

}

ALWAYS_INLINE void jsvFreePtr(JsVar *var) {

/* To be here, we're not supposed to be part of anything else. If

assert((!jsvGetNextSibling(var) && !jsvGetPrevSibling(var)) || // check that next/prevSibling are not set

jsvIsRefUsedForData(var) || // UNLESS we're part of a string and nextSibling/prevSibling are used for string data

(jsvIsName(var) && (jsvGetNextSibling(var)==jsvGetPrevSibling(var)))); // UNLESS we're signalling that we're jsvIsNewChild

// Names that Link to other things

if (jsvIsNameWithValue(var)) {

#ifdef CLEAR_MEMORY_ON_FREE

jsvSetFirstChild(var, 0); // it just contained random data - zero it

#endif // CLEAR_MEMORY_ON_FREE

} else if (jsvHasSingleChild(var)) {

if (jsvGetFirstChild(var)) {

JsVar *child = jsvLock(jsvGetFirstChild(var));

jsvUnRef(child);

#ifdef CLEAR_MEMORY_ON_FREE

jsvSetFirstChild(var, 0); // unlink the child

#endif // CLEAR_MEMORY_ON_FREE

jsvUnLock(child); // unlock should trigger a free

}

}

/* No else, because a String Name may have a single child, but

/* Now, free children - see jsvar.h comments for how! */

if (jsvHasStringExt(var)) {

// Free the string without recursing

JsVarRef stringDataRef = jsvGetLastChild(var);

#ifdef CLEAR_MEMORY_ON_FREE

jsvSetLastChild(var, 0);

#endif // CLEAR_MEMORY_ON_FREE

while (stringDataRef) {

JsVar *child = _jsvGetAddressOf(stringDataRef);

assert(jsvIsStringExt(child));

stringDataRef = jsvGetLastChild(child);

jsvFreePtrInternal(child);

}

// We might be a flat string

if (jsvIsFlatString(var)) {

// in which case we need to free all the blocks.

size_t count = jsvGetFlatStringBlocks(var);

JsVarRef i = (JsVarRef)(jsvGetRef(var)+count);

// do it in reverse, so the free list ends up in kind of the right order

while (count--) {

JsVar *p = _jsvGetAddressOf(i--);

p->flags = JSV_UNUSED; // set locks to 0 so the assert in jsvFreePtrInternal doesn't get fed up

jsvFreePtrInternal(p);

}

} else if (jsvIsBasicString(var)) {

#ifdef CLEAR_MEMORY_ON_FREE

jsvSetFirstChild(var, 0); // firstchild could have had string data in

#endif // CLEAR_MEMORY_ON_FREE

}

}

/* NO ELSE HERE - because jsvIsNewChild stuff can be for Names, which

if (jsvHasChildren(var)) {

JsVarRef childref = jsvGetFirstChild(var);

#ifdef CLEAR_MEMORY_ON_FREE

jsvSetFirstChild(var, 0);

jsvSetLastChild(var, 0);

#endif // CLEAR_MEMORY_ON_FREE

while (childref) {

JsVar *child = jsvLock(childref);

assert(jsvIsName(child));

childref = jsvGetNextSibling(child);

jsvSetPrevSibling(child, 0);

jsvSetNextSibling(child, 0);

jsvUnRef(child);

jsvUnLock(child);

}

} else {

#ifdef CLEAR_MEMORY_ON_FREE

#if JSVARREF_SIZE==1

assert(jsvIsFloat(var) || !jsvGetFirstChild(var));

assert(jsvIsFloat(var) || !jsvGetLastChild(var));

assert(!jsvGetFirstChild(var)); // strings use firstchild now as well

assert(!jsvGetLastChild(var));

#endif // CLEAR_MEMORY_ON_FREE

if (jsvIsName(var)) {

assert(jsvGetNextSibling(var)==jsvGetPrevSibling(var)); // the case for jsvIsNewChild

if (jsvGetNextSibling(var)) {

jsvUnRefRef(jsvGetNextSibling(var));

jsvUnRefRef(jsvGetPrevSibling(var));

}

}

}

// free!

jsvFreePtrInternal(var);

}

ALWAYS_INLINE JsVar *jsvLock(JsVarRef ref) {

JsVar *var = _jsvGetAddressOf(ref);

//var->locks++;

assert(jsvGetLocks(var) < JSV_LOCK_MAX);

var->flags += JSV_LOCK_ONE;

#ifdef DEBUG

if (jsvGetLocks(var)==0) {

jsError("Too many locks to Variable!");

//jsPrint("Var #");jsPrintInt(ref);jsPrint("\n");

}

return var;

}

ALWAYS_INLINE JsVar *jsvLockAgain(JsVar *var) {

assert(var);

assert(jsvGetLocks(var) < JSV_LOCK_MAX);

var->flags += JSV_LOCK_ONE;

return var;

}

ALWAYS_INLINE JsVar *jsvLockAgainSafe(JsVar *var) {

return var ? jsvLockAgain(var) : 0;

}

static NO_INLINE void jsvUnLockFreeIfNeeded(JsVar *var) {

assert(jsvGetLocks(var) == 0);

/* if we know we're free, then we can just free this variable right now.

if (jsvGetRefs(var) == 0 && jsvHasRef(var) && (var->flags&JSV_VARTYPEMASK)!=JSV_UNUSED) {

jsvFreePtr(var);

}

}

ALWAYS_INLINE void jsvUnLock(JsVar *var) {

if (!var) return;

assert(jsvGetLocks(var)>0);

var->flags -= JSV_LOCK_ONE;

// Now see if we can properly free the data

// Note: we check locks first as they are already in a register

if ((var->flags & JSV_LOCK_MASK) == 0) jsvUnLockFreeIfNeeded(var);

}

void jsvUnLock2(JsVar *var1, JsVar *var2) {

jsvUnLock(var1);

jsvUnLock(var2);

}

void jsvUnLock3(JsVar *var1, JsVar *var2, JsVar *var3) {

jsvUnLock(var1);

jsvUnLock(var2);

jsvUnLock(var3);

}

NO_INLINE void jsvUnLockMany(unsigned int count, JsVar **vars) {

while (count) jsvUnLock(vars[--count]);

}

JsVar *jsvRef(JsVar *var) {

assert(var && jsvHasRef(var));

jsvSetRefs(var, (JsVarRefCounter)(jsvGetRefs(var)+1));

assert(jsvGetRefs(var));

return var;

}

void jsvUnRef(JsVar *var) {

assert(var && jsvGetRefs(var)>0 && jsvHasRef(var));

jsvSetRefs(var, (JsVarRefCounter)(jsvGetRefs(var)-1));

}

JsVarRef jsvRefRef(JsVarRef ref) {

JsVar *v;

assert(ref);

v = jsvLock(ref);

assert(!jsvIsStringExt(v));

jsvRef(v);

jsvUnLock(v);

return ref;

}

JsVarRef jsvUnRefRef(JsVarRef ref) {

JsVar *v;

assert(ref);

v = jsvLock(ref);

assert(!jsvIsStringExt(v));

jsvUnRef(v);

jsvUnLock(v);

return 0;

}

JsVar *jsvNewFlatStringOfLength(unsigned int byteLength) {

#ifdef VAR_CACHE

return 0;

if (isMemoryBusy) {

jsErrorFlags |= JSERR_MEMORY_BUSY;

return 0;

}

isMemoryBusy = true;

// Work out how many blocks we need. One for the header, plus some for the characters

size_t blocks = 1 + ((byteLength+sizeof(JsVar)-1) / sizeof(JsVar));

// Now try and find them

unsigned int blockCount = 0;

#ifdef RESIZABLE_JSVARS

JsVar *lastVar = 0;

jsVarFirstEmpty = 0;

JsVar firstVar; // temporary var to simplify code in the loop below

jsvSetNextSibling(&firstVar, 0);

JsVar *lastEmpty = &firstVar;

JsVarRef i, j;

JsVar *flatString = 0;

for (i=1;i<=jsVarsSize;i++) {

JsVar *var = _jsvGetAddressOf(i);

if ((var->flags&JSV_VARTYPEMASK) == JSV_UNUSED) {

#ifdef RESIZABLE_JSVARS

/** With RESIZABLE_JSVARS (Linux), we have chunks of variables that may

if (var != lastVar+1)

blockCount = 0;

lastVar = var;

blockCount++;

if (blockCount>=blocks) { // Wohoo! We found enough blocks

flatString = _jsvGetAddressOf((JsVarRef)(unsigned int)((unsigned)i+1-blocks)); // the first block

// Set up the header block (including one lock)

jsvResetVariable(flatString, JSV_FLAT_STRING);

flatString->varData.integer = (JsVarInt)byteLength;

// clear data

memset((char*)&flatString[1], 0, sizeof(JsVar)*(blocks-1));

// break out of the loop, and we'll return 'flatString'

i++; // we are already at the final block

break;

}

} else {

// we didn't have enough free blocks of memory,

// but we must add them to the free list again anyway

for (j=(JsVarRef)(i-blockCount);j<i;j++) {

JsVar *v = _jsvGetAddressOf(j);

jsvSetNextSibling(lastEmpty, j);

lastEmpty = v;

}

// start again...

blockCount = 0; // non-continuous

if (jsvIsFlatString(var))

i = (JsVarRef)(i+jsvGetFlatStringBlocks(var));

}

}

/* continue where we left off, and keep re-linking the

for (;i<=jsVarsSize;i++) {

JsVar *var = _jsvGetAddressOf(i);

if ((var->flags&JSV_VARTYPEMASK) == JSV_UNUSED) {

jsvSetNextSibling(lastEmpty, i);

lastEmpty = var;

} else if (jsvIsFlatString(var)) {

// skip over used blocks for flat strings

i = (JsVarRef)(i+jsvGetFlatStringBlocks(var));

}

}

jsvSetNextSibling(lastEmpty, 0);

jsVarFirstEmpty = jsvGetNextSibling(&firstVar);

isMemoryBusy = false;

// Return whatever we had (0 if we couldn't manage it)

return flatString;

}

JsVar *jsvNewFromString(const char *str) {

// Create a var

JsVar *first = jsvNewWithFlags(JSV_STRING_0);

if (!first) return 0; // out of memory

// Now we copy the string, but keep creating new jsVars if we go

// over the end

JsVar *var = jsvLockAgain(first);

while (*str) {

// copy data in

size_t i, l = jsvGetMaxCharactersInVar(var);

for (i=0;i<l && *str;i++)

var->varData.str[i] = *(str++);

// we already set the variable data to 0, so no need for adding one

// we've stopped if the string was empty

jsvSetCharactersInVar(var, i);

// if there is still some left, it's because we filled up our var...

// make a new one, link it in, and unlock the old one.

if (*str) {

JsVar *next = jsvNewWithFlags(JSV_STRING_EXT_0);

if (!next) {

// Truncating string as not enough memory

jsvUnLock(var);

return first;

}

// we don't ref, because StringExts are never reffed as they only have one owner (and ALWAYS have an owner)

jsvSetLastChild(var, jsvGetRef(next));

jsvUnLock(var);

var = next;

}

}

jsvUnLock(var);

// return

return first;

}

JsVar *jsvNewStringOfLength(unsigned int byteLength) {

// Create a var

JsVar *first = jsvNewWithFlags(JSV_STRING_0);

if (!first) {

jsWarn("Unable to create string as not enough memory");

return 0;

}

// Now keep creating enough new jsVars

JsVar *var = jsvLockAgain(first);

while (true) {

// copy data in

unsigned int l = (unsigned int)jsvGetMaxCharactersInVar(var);

if (l>=byteLength) {

// we've got enough

jsvSetCharactersInVar(var, byteLength);

break;

} else {

// We need more

jsvSetCharactersInVar(var, l);

byteLength -= l;

// Make a new one, link it in, and unlock the old one.

JsVar *next = jsvNewWithFlags(JSV_STRING_EXT_0);

if (!next) {

jsWarn("Truncating string as not enough memory");

break;

}

// we don't ref, because StringExts are never reffed as they only have one owner (and ALWAYS have an owner)

jsvSetLastChild(var, jsvGetRef(next));

jsvUnLock(var);

var = next;

}

}

jsvUnLock(var);

// return

return first;

}

JsVar *jsvNewFromInteger(JsVarInt value) {

JsVar *var = jsvNewWithFlags(JSV_INTEGER);

if (!var) return 0; // no memory

var->varData.integer = value;

return var;

}

JsVar *jsvNewFromBool(bool value) {

JsVar *var = jsvNewWithFlags(JSV_BOOLEAN);

if (!var) return 0; // no memory

var->varData.integer = value ? 1 : 0;

return var;

}

JsVar *jsvNewFromFloat(JsVarFloat value) {

JsVar *var = jsvNewWithFlags(JSV_FLOAT);

if (!var) return 0; // no memory

var->varData.floating = value;

return var;

}

JsVar *jsvNewFromLongInteger(long long value) {

if (value>=-2147483648LL && value<=2147483647LL)

return jsvNewFromInteger((JsVarInt)value);

else

return jsvNewFromFloat((JsVarFloat)value);

}

JsVar *jsvMakeIntoVariableName(JsVar *var, JsVar *valueOrZero) {

if (!var) return 0;

assert(jsvGetRefs(var)==0); // make sure it's unused

assert(jsvIsSimpleInt(var) || jsvIsString(var));

JsVarFlags varType = (var->flags & JSV_VARTYPEMASK);

if (varType==JSV_INTEGER) {

int t = JSV_NAME_INT;

if ((jsvIsInt(valueOrZero) || jsvIsBoolean(valueOrZero)) && !jsvIsPin(valueOrZero)) {

JsVarInt v = valueOrZero->varData.integer;

if (v>=JSVARREF_MIN && v<=JSVARREF_MAX) {

t = jsvIsInt(valueOrZero) ? JSV_NAME_INT_INT : JSV_NAME_INT_BOOL;

jsvSetFirstChild(var, (JsVarRef)v);

valueOrZero = 0;

}

}

var->flags = (JsVarFlags)(var->flags & ~JSV_VARTYPEMASK) | t;

} else if (varType>=JSV_STRING_0 && varType<=JSV_STRING_MAX) {

if ((varType-JSV_STRING_0) > JSVAR_DATA_STRING_NAME_LEN) {

/* Argh. String is too large to fit in a JSV_NAME! We must chomp make

JsvStringIterator it;

jsvStringIteratorNew(&it, var, JSVAR_DATA_STRING_NAME_LEN);

JsVar *startExt = jsvNewWithFlags(JSV_STRING_EXT_0);

JsVar *ext = jsvLockAgainSafe(startExt);

size_t nChars = 0;

while (ext && jsvStringIteratorHasChar(&it)) {

if (nChars >= JSVAR_DATA_STRING_MAX_LEN) {

jsvSetCharactersInVar(ext, nChars);

JsVar *ext2 = jsvNewWithFlags(JSV_STRING_EXT_0);

if (ext2) {

jsvSetLastChild(ext, jsvGetRef(ext2));

}

jsvUnLock(ext);

ext = ext2;

nChars = 0;

}

ext->varData.str[nChars++] = jsvStringIteratorGetChar(&it);

jsvStringIteratorNext(&it);

}

jsvStringIteratorFree(&it);

if (ext) {

jsvSetCharactersInVar(ext, nChars);

jsvUnLock(ext);

}

jsvSetCharactersInVar(var, JSVAR_DATA_STRING_NAME_LEN);

jsvSetLastChild(var, jsvGetRef(startExt));

jsvSetNextSibling(var, 0);

jsvSetPrevSibling(var, 0);

jsvSetFirstChild(var, 0);

jsvUnLock(startExt);

}

size_t t = JSV_NAME_STRING_0;

if (jsvIsInt(valueOrZero) && !jsvIsPin(valueOrZero)) {

JsVarInt v = valueOrZero->varData.integer;

if (v>=JSVARREF_MIN && v<=JSVARREF_MAX) {

t = JSV_NAME_STRING_INT_0;

jsvSetFirstChild(var, (JsVarRef)v);

valueOrZero = 0;

}

}

var->flags = (var->flags & (JsVarFlags)~JSV_VARTYPEMASK) | (t+jsvGetCharactersInVar(var));

} else assert(0);

if (valueOrZero)

jsvSetFirstChild(var, jsvGetRef(jsvRef(valueOrZero)));

return var;

}

void jsvMakeFunctionParameter(JsVar *v) {

assert(jsvIsString(v));

if (!jsvIsName(v)) jsvMakeIntoVariableName(v,0);

v->flags = (JsVarFlags)(v->flags | JSV_NATIVE);

}

JsVar *jsvNewFromPin(int pin) {

JsVar *v = jsvNewFromInteger((JsVarInt)pin);

if (v) {

v->flags = (JsVarFlags)((v->flags & ~JSV_VARTYPEMASK) | JSV_PIN);

}

return v;

}

JsVar *jsvNewObject() {

return jsvNewWithFlags(JSV_OBJECT);

}

JsVar *jsvNewEmptyArray() {

return jsvNewWithFlags(JSV_ARRAY);

}

JsVar *jsvNewArray(JsVar **elements, int elementCount) {

JsVar *arr = jsvNewEmptyArray();

if (!arr) return 0;

int i;

for (i=0;i<elementCount;i++)

jsvArrayPush(arr, elements[i]);

return arr;

}

JsVar *jsvNewNativeFunction(void (*ptr)(void), unsigned short argTypes) {

JsVar *func = jsvNewWithFlags(JSV_FUNCTION | JSV_NATIVE);

if (!func) return 0;

func->varData.native.ptr = ptr;

func->varData.native.argTypes = argTypes;

return func;

}

void *jsvGetNativeFunctionPtr(const JsVar *function) {

/* see descriptions in jsvar.h. If we have a child called JSPARSE_FUNCTION_CODE_NAME

JsVar *flatString = jsvFindChildFromString((JsVar*)function, JSPARSE_FUNCTION_CODE_NAME, 0);

if (flatString) {

flatString = jsvSkipNameAndUnLock(flatString);

void *v = (void*)((size_t)function->varData.native.ptr + (char*)jsvGetFlatStringPointer(flatString));

jsvUnLock(flatString);

return v;

} else

return (void *)function->varData.native.ptr;

}

JsVar *jsvNewArrayBufferFromString(JsVar *str, unsigned int lengthOrZero) {

JsVar *arr = jsvNewWithFlags(JSV_ARRAYBUFFER);

if (!arr) return 0;

jsvSetFirstChild(arr, jsvGetRef(jsvRef(str)));

arr->varData.arraybuffer.type = ARRAYBUFFERVIEW_ARRAYBUFFER;

assert(arr->varData.arraybuffer.byteOffset == 0);

if (lengthOrZero==0) lengthOrZero = (unsigned int)jsvGetStringLength(str);

arr->varData.arraybuffer.length = (unsigned short)lengthOrZero;

return arr;

}

bool jsvIsBasicVarEqual(JsVar *a, JsVar *b) {

// quick checks

if (a==b) return true;

if (!a || !b) return false; // one of them is undefined

// OPT: would this be useful as compare instead?

assert(jsvIsBasic(a) && jsvIsBasic(b));

if (jsvIsNumeric(a) && jsvIsNumeric(b)) {

if (jsvIsIntegerish(a)) {

if (jsvIsIntegerish(b)) {

return a->varData.integer == b->varData.integer;

} else {

assert(jsvIsFloat(b));

return a->varData.integer == b->varData.floating;

}

} else {

assert(jsvIsFloat(a));

if (jsvIsIntegerish(b)) {

return a->varData.floating == b->varData.integer;

} else {

assert(jsvIsFloat(b));

return a->varData.floating == b->varData.floating;

}

}

} else if (jsvIsString(a) && jsvIsString(b)) {

JsvStringIterator ita, itb;

jsvStringIteratorNew(&ita, a, 0);

jsvStringIteratorNew(&itb, b, 0);

while (true) {

char a = jsvStringIteratorGetChar(&ita);

char b = jsvStringIteratorGetChar(&itb);

if (a != b) {

jsvStringIteratorFree(&ita);

jsvStringIteratorFree(&itb);

return false;

}

if (!a) { // equal, but end of string

jsvStringIteratorFree(&ita);

jsvStringIteratorFree(&itb);

return true;

}

jsvStringIteratorNext(&ita);

jsvStringIteratorNext(&itb);

}

// we never get here

return false; // make compiler happy

} else {

//TODO: are there any other combinations we should check here?? String v int?

return false;

}

}

bool jsvIsEqual(JsVar *a, JsVar *b) {

if (jsvIsBasic(a) && jsvIsBasic(b))

return jsvIsBasicVarEqual(a,b);

return jsvGetRef(a)==jsvGetRef(b);

}

const char *jsvGetConstString(const JsVar *v) {

if (jsvIsUndefined(v)) {

return "undefined";

} else if (jsvIsNull(v)) {

return "null";

} else if (jsvIsBoolean(v)) {

return jsvGetBool(v) ? "true" : "false";

}

return 0;

}

const char *jsvGetTypeOf(const JsVar *v) {

if (jsvIsUndefined(v)) return "undefined";

if (jsvIsNull(v) || jsvIsObject(v) ||

jsvIsArray(v) || jsvIsArrayBuffer(v)) return "object";

if (jsvIsFunction(v)) return "function";

if (jsvIsString(v)) return "string";

if (jsvIsBoolean(v)) return "boolean";

if (jsvIsNumeric(v)) return "number";

return "?";

}

JsVar *jsvGetValueOf(JsVar *v) {

if (!jsvIsObject(v)) return jsvLockAgainSafe(v);

JsVar *valueOf = jspGetNamedField(v, "valueOf", false);

if (!jsvIsFunction(valueOf)) {

jsvUnLock(valueOf);

return jsvLockAgain(v);

}

v = jspeFunctionCall(valueOf, 0, v, false, 0, 0);

jsvUnLock(valueOf);

return v;

}

size_t jsvGetString(const JsVar *v, char *str, size_t len) {

const char *s = jsvGetConstString(v);

if (s) {

strncpy(str, s, len);

return strlen(s);

} else if (jsvIsInt(v)) {

itostr(v->varData.integer, str, 10);

return strlen(str);

} else if (jsvIsFloat(v)) {

ftoa_bounded(v->varData.floating, str, len);

return strlen(str);

} else if (jsvHasCharacterData(v)) {

assert(!jsvIsStringExt(v));

size_t l = len;

JsvStringIterator it;

jsvStringIteratorNewConst(&it, v, 0);

while (jsvStringIteratorHasChar(&it)) {

if (l--<=1) {

*str = 0;

jsvStringIteratorFree(&it);

return len;

}

*(str++) = jsvStringIteratorGetChar(&it);

jsvStringIteratorNext(&it);

}

jsvStringIteratorFree(&it);

*str = 0;

return len-l;

} else {

// Try and get as a JsVar string, and try again

JsVar *stringVar = jsvAsString((JsVar*)v, false); // we know we're casting to non-const here

if (stringVar) {

size_t l = jsvGetString(stringVar, str, len); // call again - but this time with converted var

jsvUnLock(stringVar);

return l;

} else {

strncpy(str, "", len);

jsExceptionHere(JSET_INTERNALERROR, "Variable type cannot be converted to string");

return 0;

}

}

}

size_t jsvGetStringChars(const JsVar *v, size_t startChar, char *str, size_t len) {

assert(jsvHasCharacterData(v));

size_t l = len;

JsvStringIterator it;

jsvStringIteratorNewConst(&it, v, startChar);

while (jsvStringIteratorHasChar(&it)) {

if (l--<=0) {

jsvStringIteratorFree(&it);

return len;

}

*(str++) = jsvStringIteratorGetChar(&it);

jsvStringIteratorNext(&it);

}

jsvStringIteratorFree(&it);

*str = 0;

return len-l;

}

void jsvSetString(JsVar *v, const char *str, size_t len) {

assert(jsvHasCharacterData(v));

assert(len == jsvGetStringLength(v));

JsvStringIterator it;

jsvStringIteratorNew(&it, v, 0);

size_t i;

for (i=0;i<len;i++) {

jsvStringIteratorSetChar(&it, str[i]);

jsvStringIteratorNext(&it);

}

jsvStringIteratorFree(&it);

}

JsVar *jsvAsString(JsVar *v, bool unlockVar) {

JsVar *str = 0;

// If it is string-ish, but not quite a string, copy it

if (jsvHasCharacterData(v) && jsvIsName(v)) {

str = jsvNewFromStringVar(v,0,JSVAPPENDSTRINGVAR_MAXLENGTH);

} else if (jsvIsString(v)) { // If it is a string - just return a reference

str = jsvLockAgain(v);

} else if (jsvIsObject(v)) { // If it is an object and we can call toString on it

JsVar *toStringFn = jspGetNamedField(v, "toString", false);

if (toStringFn && toStringFn->varData.native.ptr != (void (*)(void))jswrap_object_toString) {

// Function found and it's not the default one - execute it

JsVar *result = jspExecuteFunction(toStringFn,v,0,0);

jsvUnLock(toStringFn);

return jsvAsString(result, true);

} else {

jsvUnLock(toStringFn);

return jsvNewFromString("[object Object]");

}

} else {

const char *constChar = jsvGetConstString(v);

char buf[JS_NUMBER_BUFFER_SIZE];

if (constChar) {

// if we could get this as a simple const char, do that..

str = jsvNewFromString(constChar);

} else if (jsvIsPin(v)) {

jshGetPinString(buf, (Pin)v->varData.integer);

str = jsvNewFromString(buf);

} else if (jsvIsInt(v)) {

itostr(v->varData.integer, buf, 10);

str = jsvNewFromString(buf);

} else if (jsvIsFloat(v)) {

ftoa_bounded(v->varData.floating, buf, sizeof(buf));

str = jsvNewFromString(buf);

} else if (jsvIsArray(v) || jsvIsArrayBuffer(v)) {

JsVar *filler = jsvNewFromString(",");

str = jsvArrayJoin(v, filler);

jsvUnLock(filler);

} else if (jsvIsFunction(v)) {

str = jsvNewFromEmptyString();

if (str) jsfGetJSON(v, str, JSON_NONE);

} else {

jsExceptionHere(JSET_INTERNALERROR, "Variable type cannot be converted to string");

str = 0;

}

}

if (unlockVar) jsvUnLock(v);

return str;

}

JsVar *jsvAsFlatString(JsVar *var) {

if (jsvIsFlatString(var)) return jsvLockAgain(var);

JsVar *str = jsvAsString(var, false);

size_t len = jsvGetStringLength(str);

JsVar *flat = jsvNewFlatStringOfLength((unsigned int)len);

if (flat) {

JsvStringIterator src;

JsvStringIterator dst;

jsvStringIteratorNew(&src, str, 0);

jsvStringIteratorNew(&dst, flat, 0);

while (len--) {

jsvStringIteratorSetChar(&dst, jsvStringIteratorGetChar(&src));

if (len>0) {

jsvStringIteratorNext(&src);

jsvStringIteratorNext(&dst);

}

}

jsvStringIteratorFree(&src);

jsvStringIteratorFree(&dst);

}

jsvUnLock(str);

return flat;

}

JsVar *jsvAsArrayIndex(JsVar *index) {

if (jsvIsSimpleInt(index)) {

return jsvLockAgain(index); // we're ok!

} else if (jsvIsString(index)) {

/* Index filtering (bug #19) - if we have an array index A that is:

if (jsvIsStringNumericStrict(index))

return jsvNewFromInteger(jsvGetInteger(index));

} else if (jsvIsFloat(index)) {

// if it's a float that is actually integral, return an integer...

JsVarFloat v = jsvGetFloat(index);

JsVarInt vi = jsvGetInteger(index);

if (v == vi) return jsvNewFromInteger(vi);

}