/*static*/ NamespaceSet* NamespaceSet::_create(MMgc::GC* gc, uint32_t count)
 {
     AvmAssert(count <= 0x7fffffff); // should be impossible since ABC only allow U30...
     size_t extra = (count >= 1 ? count-1 : 0)*sizeof(Namespacep);
     NamespaceSet* nsset = new (gc, extra) NamespaceSet;
     nsset->_countAndFlags = count<<1;
     return nsset;
 }

	void CallStackNode::exit()
	{
		// m_env might be null (for fake CallStackNode), be careful
		AvmAssert(m_core != NULL);
		m_core->callStack = m_next;
		m_next = NULL;
		m_core = NULL; // so the dtor doesn't call exit() again
	}

    // OSR is supported generally only in runmode RM_mixed.  We don't support
    // methods with try/catch blocks because of the complexity of establishing
    // a new ExceptionFrame and jmp_buf.  We also don't support methods for which
    // a previous compilation attempt failed, or for which failure can be predicted.
    //
    // We must only OSR methods that will execute with a BugCompatibility object
    // such that interpreter/compiler divergences are corrected.  Builtin methods
    // are invoked with bug compatibility inherited from the innermost non-builtin
    // function on the call chain, and thus may vary from call to call. Non-builtins
    // should always execute with bug compatibility taken from the AbcEnv to which
    // the method belongs, which will thus remain invariant. We can therefore only OSR
    // non-builtin methods.
    bool OSR::isSupported(const AbcEnv* abc_env, const MethodInfo* m, MethodSignaturep ms)
    {
        AvmCore* core = abc_env->core();

        AvmAssert(core == m->pool()->core);
        AvmAssert(abc_env->pool() == m->pool());
        AvmAssert(abc_env->codeContext() != NULL);
        AvmAssert(abc_env->codeContext()->bugCompatibility() != NULL);

        return (!m->hasExceptions() &&                // method does not have a try block
                core->config.runmode == RM_mixed &&   // mixed runmode, allowing both interpreter and JIT
                core->config.osr_threshold != 0 &&    // OSR is enabled (may be disabled by host)
                !m->hasFailedJit() &&                 // no previous attempt to compile the method has failed
                !CodegenLIR::jitWillFail(ms) &&       // fast-fail predictor says JIT success is possible
                !m->pool()->isBuiltin &&              // the method is not a builtin (ABC baked into application)
                abc_env->codeContext()->bugCompatibility()->bugzilla539094);  // bug compatibility permits OSR
    }

void BigInteger::setFromBigInteger(const BigInteger* from, int32 offset, int32 amount)
{
    numWords = amount;
    AvmAssert(numWords <= kMaxBigIntegerBufferSize);
    memcpy( (byte*)wordBuffer,
            (byte*)&(from->wordBuffer[offset]),
            amount*sizeof(uint32));
}

	PoolObject* NativeInitializer::parseBuiltinABC(Domain* domain)
	{
		AvmAssert(domain != NULL);
		
		ScriptBuffer code = ScriptBuffer(new (core->GetGC()) ConstDataScriptBufferImpl(abcData, abcDataLen));

		return core->parseActionBlock(code, /*start*/0, /*toplevel*/NULL, domain, this, ApiUtils::getLargestAPI(core)/*active api*/);
	}

	MathClass::MathClass(VTable* cvtable)
		: ClassClosure(cvtable)
	{
		AvmAssert(traits()->getSizeOfInstance() == sizeof(MathClass));
		MathUtils::initRandom(&seed);

        // todo does ES4 Math have a prototype object?
	}

    /*static*/ CreateInstanceProc ClassClosure::calcCreateInstanceProc(VTable* cvtable)
    {
        VTable* ivtable = cvtable->ivtable;
        if (ivtable && ivtable->base)
        {
            ScopeChain* scope = cvtable->init->scope();
            if (scope->getSize())
            {
                Atom baseAtom = scope->getScope(scope->getSize()-1);
                if (!AvmCore::isObject(baseAtom))
                    cvtable->toplevel()->throwVerifyError(kCorruptABCError);

                ScriptObject* base = AvmCore::atomToScriptObject(baseAtom);
                // make sure scope object is base type's class object
                AvmAssert(base->traits()->itraits == cvtable->traits->itraits->base);
                if (base->traits()->itraits->isAbstractBase)
                {
                    // If we get here, it means that we descend from an abstract base class,
                    // but don't have a native createInstanceProc of our own; in that case, we
                    // should just create a plain old ScriptObject. (Note that this can
                    // happen for abstract and abstract-restricted; for the latter, we will do
                    // a second check in checkForRestrictedInheritance() and may reject it anyway.)
                    goto create_normal;
                }
                // ...otherwise, we're done.
                ClassClosure* base_cc = base->toClassClosure();
                AvmAssert(base_cc != NULL);
                CreateInstanceProc proc = base_cc->m_createInstanceProc;
                // If the proc is SemiSealedArrayObject, revert back to normal Array,
                // and let checkForRestrictedInheritance() choose the proper proc:
                // we might be a dynamic subclass of a non-dynamic subclass of Array.
                if (proc == SemiSealedArrayObject::createInstanceProc)
                    proc = ArrayClass::createInstanceProc;

                // Bugzilla 688486: don't use unsubclassed-specialized
                // instance creator to create subclassed instances.
                if (proc == ArrayClass::createUnsubclassedInstanceProc)
                    proc = ArrayClass::createInstanceProc;

                return proc;
            }
        }

create_normal:
        return ClassClosure::createScriptObjectProc;
    }

	void PoolObject::resolveQName(uint32_t index, Multiname &m, const Toplevel* toplevel) const
	{
		if (index == 0 || index >= constantMnCount)
		{
			if (toplevel)
				toplevel->throwVerifyError(kCpoolIndexRangeError, core->toErrorString(index), core->toErrorString(constantMnCount));
			AvmAssert(!"unhandled verify error");
		}

		parseMultiname(cpool_mn[index], m);
		if (!m.isQName())
		{
			if (toplevel)
				toplevel->throwVerifyError(kCpoolEntryWrongTypeError, core->toErrorString(index));
			AvmAssert(!"unhandled verify error");
		}
	}

	void WordcodeEmitter::emitAbsJump(const uint8_t *new_pc)
	{
		code_start = new_pc;
		
		// When performing a jump:
		//  - require that backpatches and labels no longer reference the old
		//    code vector; those sets must both be empty.  (We could clear out
		//    labels, alternatively, but that appears not to be required.)
		//  - recompute all the exception information, and require that none of it
		//    has been consumed -- this is the only thing that makes sense, and appears
		//    to be the view the verifier sanctions.  (A full definition for the
		//    semantics of abs_jump is sorely needed.)
		
		AvmAssert(!exceptions_consumed);
		AvmAssert(backpatches == NULL);
		AvmAssert(labels == NULL);
		computeExceptionFixups();
	}

 Token Lexer::xmlName()
 {
     AvmAssert( isXmlNameStart(*idx) );
     mark = idx;
     while (isXmlNameSubsequent(*idx))
         idx++;
     val.s = compiler->intern(mark, uint32_t(idx-mark));
     return T_XmlName;
 }

    int ScriptObject::nextNameIndex(int index)
    {
        AvmAssert(index >= 0);

        if (!traits()->needsHashtable())
            return 0;

        return getTable()->next(index);
    }

    Atom FASTCALL DictionaryObject::getKeyFromObject(Atom key) const
    {
        AvmAssert(AvmCore::isObject(key));
        ScriptObject* obj = AvmCore::atomToScriptObject(key);
        AvmAssert(Traits::getBuiltinType(obj->traits()) != BUILTIN_qName);
        AvmAssert(MMgc::GC::Size(obj) >= sizeof(ScriptObject));
        (void)obj;

        // This commented-out code probably pertains to Bugzilla 507699:
        // "Dictionary key of Xml type are not matching."
        //
        // FIXME: this doesn't work, need to convert back to an XMLObject
        // on the way out or intern XMLObject's somehow
        //if(AvmCore::isXML(key))
        //  key = AvmCore::genericObjectToAtom(AvmCore::atomToXML(key));

        return key;
    }

int VMPI_system(const char *command)
{
    #ifdef UNDER_CE
        AvmAssert(0);
        return 0;
    #else
        return system( command );
    #endif
}

 template<class T> T SeqBuilder<T>::dequeue()
 {
     AvmAssert(items != NULL);
     T v = items->hd;
     items = items->tl;
     if (items == NULL)
         last = NULL;
     return v;
 }

    ClassClosure::ClassClosure(VTable* cvtable)
        : ScriptObject(cvtable, NULL)
        , m_createInstanceProc(checkForRestrictedInheritance(cvtable->ivtable, cvtable->ivtable->createInstanceProc))
        // NB: prototype is null right now, but we expect our subclass to
        // initialize it in their ctor (or, at a minimum, before it attempts
        // to create any instances).
    {
        AvmAssert(traits()->getSizeOfInstance() >= sizeof(ClassClosure));

        // All callers of this ctor must have a non-null ivtable.
        AvmAssert(cvtable->ivtable != NULL);
        cvtable->ivtable->createInstanceProc = ClassClosure::reinitNullPrototypeCreateInstanceProc;
        AvmAssert(m_createInstanceProc != reinitNullPrototypeCreateInstanceProc);
        
        // don't assert here any more: MethodClosure descends
        //AvmAssert(cvtable->traits->itraits != NULL);
        //AvmAssert(ivtable() != NULL);
    }

	void ConsistencyChecker::checkPhiOperandsJumpToCurrentBlock() {
		List<BasicBlock*, LIST_GCObjects>* basicBlocks = _functionToCheck->getBasicBlocks();
		TessaAssert(basicBlocks != NULL);

		for (size_t i = 0; i < basicBlocks->size(); i++) {
			BasicBlock* currentBasicBlock = basicBlocks->get(i);

			if (currentBasicBlock->getPredecessors()->size() > 1) {
				List<PhiInstruction*, LIST_GCObjects>* phiInstructions = currentBasicBlock->getPhiInstructions();

				for (size_t j = 0; j < phiInstructions->size(); j++) {
					PhiInstruction* phiInstruction = phiInstructions->get(j);
					AvmAssert(allPhiOperandsArePredecessors(phiInstruction));
					AvmAssert(phiOperandsExistsInPredecessorBlock(phiInstruction));
				}
			}
		}
	}

	ArrayObject::ArrayObject(VTable *vtable, ScriptObject* proto, uint32 capacity)
		: ScriptObject(vtable, proto, 0),
		m_denseArr(capacity)
	{
		SAMPLE_FRAME("Array", core());
		AvmAssert(traits()->getSizeOfInstance() >= sizeof(ArrayObject));
		m_length = 0;
		m_lowHTentry = NO_LOW_HTENTRY;
	}

	void CallStackNode::init(AvmCore* core, uint64_t functionId, int32_t lineno)
	{
		AvmAssert(core != NULL);
		AvmAssert(functionId != 0);
		
		m_functionId	= functionId;
		m_info			= NULL;
		m_env			= NULL;
		m_fakename		= NULL;
		m_core          = core;
		m_next          = core->callStack; core->callStack = this;
		m_depth         = m_next ? (m_next->m_depth + 1) : 1;
		m_eip			= NULL;    
		m_filename		= NULL;
		m_framep		= NULL;
		m_traits		= NULL;
		m_linenum		= lineno;
	}

void DomainMgr::addNamedScriptEnvs(AbcEnv* abcEnv, const GCList<ScriptEnv>& envs)
{
    // If the MethodInfo for this ScriptEnv isn't in the Domain's or Pool's
    // map, then we must have filtered it out as unreachable: don't
    // bother adding the ScriptEnv, as we'll never need to look it up.
    // (Note that we don't need to bother checking the parent Domains
    // for this, since we want to check loaded, not cached.) We can't rely
    // on looking up by name, since scripts all tend to be named "global",
    // so instead we make a temporary map of all the entries in the relevant
    // Pool and Domain.

    PoolObject* pool = abcEnv->pool();
    DomainEnv* domainEnv = abcEnv->domainEnv();
    Domain* domain = domainEnv->domain();

    // we have no generic "set" type, so let's use a hashtable for the same purpose
    // (a bit more mem, but short-lived and better average lookup time than using List<>)
    HeapHashtable* ht = HeapHashtable::create(core->GetGC());
    for (StMNHTMethodInfoIterator iter(pool->m_loadedScripts); iter.next(); )
    {
        if (!iter.key()) continue;
        Atom const a = AvmCore::genericObjectToAtom(iter.value());
        ht->add(a, a);
    }
    for (StMNHTMethodInfoIterator iter(domain->m_loadedScripts); iter.next(); )
    {
        if (!iter.key()) continue;
        Atom const a = AvmCore::genericObjectToAtom(iter.value());
        ht->add(a, a);
    }

    for (uint32_t i = 0, n = envs.length(); i < n; ++i)
    {
        ScriptEnv* se = envs[i];
        AvmAssert(se->abcEnv() == abcEnv);
        MethodInfo* mi = se->method;
        AvmAssert(domainEnv->m_scriptEnvMap->get(mi) == NULL);
        if (ht->get(AvmCore::genericObjectToAtom(mi)) == undefinedAtom)
            continue;
        domainEnv->m_scriptEnvMap->add(mi, se);
    }

    delete ht;
}

	void NativeInitializer::fillInMethods(const NativeMethodInfo* _methodEntry)
	{
		while (_methodEntry->method_id != -1)
		{
			// if we overwrite a native method mapping, something is hosed
			AvmAssert(methods[_methodEntry->method_id] == NULL);
			methods[_methodEntry->method_id] = _methodEntry;
			_methodEntry++;
		}
	}