This is a copy of regalloc_code2_BRANCH from Netscape's private repository,

as it existed in January of 1998.


git-svn-id: svn://10.0.0.236/branches/regalloc_code2_BRANCH@22571 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/ef/Compiler/RegisterAllocator/BitSet.cpp

@@ -0,0 +1,134 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "BitSet.h"
+
+// Return the next bit after index set to true or -1 if none.
+//
+Int32 BitSet::nextOne(Int32 pos) const
+{
+	++pos;
+
+	if (pos < 0 || Uint32(pos) >= universeSize)
+		return -1;
+
+	Uint32 offset = getWordOffset(pos);
+	Uint8 index = getBitOffset(pos);
+	Word* ptr = &word[offset];
+	Word currentWord = *ptr++ >> index;
+	
+	if (currentWord != Word(0)) {
+		while ((currentWord & Word(1)) == 0) {
+			++index;
+			currentWord >>= 1;
+		}
+		return (offset << nBitsInWordLog2) + index;
+	}
+
+	Word* limit = &word[getSizeInWords(universeSize)];
+	while (ptr < limit) {
+		++offset;
+		currentWord = *ptr++;
+		if (currentWord != Word(0)) {
+			index = 0;
+			while ((currentWord & Word(1)) == 0) {
+				++index;
+				currentWord >>= 1;
+			}
+			return (offset << nBitsInWordLog2) + index;
+		}
+	}
+	return -1;
+}
+
+// Return the next bit after index set to false or -1 if none.
+//
+Int32 BitSet::nextZero(Int32 pos) const
+{
+	++pos;
+
+	if (pos < 0 || Uint32(pos) >= universeSize)
+		return -1;
+
+	Uint32 offset = getWordOffset(pos);
+	Uint8 index = getBitOffset(pos);
+	Word* ptr = &word[offset];
+	Word currentWord = *ptr++ >> index;
+	
+	if (currentWord != Word(~0)) {
+		for (; index < nBitsInWord; ++index) {
+			if ((currentWord & Word(1)) == 0) {
+				Int32 ret = (offset << nBitsInWordLog2) + index;
+				return (Uint32(ret) < universeSize) ? ret : -1;
+			}
+			currentWord >>= 1;
+		}
+	}
+
+	Word* limit = &word[getSizeInWords(universeSize)];
+	while (ptr < limit) {
+		++offset;
+		currentWord = *ptr++;
+		if (currentWord != Word(~0)) {
+			for (index = 0; index < nBitsInWord; ++index) {
+				if ((currentWord & Word(1)) == 0) {
+					Int32 ret = (offset << nBitsInWordLog2) + index;
+					return (Uint32(ret) < universeSize) ? ret : -1;
+				}
+				currentWord >>= 1;
+			}
+		}
+	}
+	return -1;
+}
+
+#ifdef DEBUG_LOG
+
+// Print the set.
+//
+void BitSet::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("[ "));
+
+	for (Int32 i = firstOne(); i != -1; i = nextOne(i)) {
+		Int32 currentBit = i;
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%d", currentBit));
+
+		Int32 nextBit = nextOne(currentBit);
+		if (nextBit != currentBit + 1) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" "));
+			continue;
+		}
+		  
+		while ((nextBit != -1) && (nextBit == (currentBit + 1))) {
+			currentBit = nextBit;
+			nextBit = nextOne(nextBit);
+		}
+
+		if (currentBit > (i+1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("-%d ", currentBit));
+		else
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" %d ", currentBit));
+
+		i = currentBit;
+	}
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("]\n"));
+}
+
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/BitSet.h

@@ -0,0 +1,195 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _BITSET_H_
+#define _BITSET_H_
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "Pool.h"
+#include <string.h>
+
+//------------------------------------------------------------------------------
+// BitSet -
+
+class BitSet
+{
+private:
+
+#if (PR_BITS_PER_WORD == 64)
+	typedef Uint64 Word;
+#elif (PR_BITS_PER_WORD == 32)
+	typedef Uint32 Word;
+#endif
+
+	static const nBitsInWord = 		PR_BITS_PER_WORD;
+	static const nBytesInWord = 	PR_BYTES_PER_WORD;
+	static const nBitsInWordLog2 =	PR_BITS_PER_WORD_LOG2;
+	static const nBytesInWordLog2 = PR_BYTES_PER_WORD_LOG2;
+
+	// Return the number of Word need to store the universe.
+	static Uint32 getSizeInWords(Uint32 sizeOfUniverse) {return (sizeOfUniverse + (nBitsInWord - 1)) >> nBitsInWordLog2;}
+	// Return the given element offset in its containing Word.
+	static Uint32 getBitOffset(Uint32 element) {return element & (nBitsInWord - 1);}
+	// Return the Word offset for the given element int the universe.
+	static Uint32 getWordOffset(Uint32 element) {return element >> nBitsInWordLog2;}
+	// Return the mask for the given bit index.
+	static Word getMask(Uint8 index) {return Word(1) << index;}
+	
+private:
+
+	Uint32							universeSize;			// Size of the universe
+	Word*							word;					// universe memory.
+
+private:
+
+	// No copy constructor.
+	BitSet(const BitSet&);
+
+	// Check if the given set's universe is of the same size than this universe.
+	void checkUniverseCompatibility(const BitSet& set) const {assert(set.universeSize == universeSize);}
+	// Check if pos is valid for this set's universe.
+	void checkMember(Int32 pos) const {assert(pos >=0 && Uint32(pos) < universeSize);}
+
+public:
+
+	// Create a bitset of universeSize bits.
+	BitSet(Pool& pool, Uint32 universeSize) : universeSize(universeSize) {word = new(pool) Word[getSizeInWords(universeSize)]; clear();}
+
+	// Return the size of this bitset.
+	Uint32 getSize() const {return universeSize;}
+
+	// Clear the bitset.
+	void clear() {memset(word, 0x00, getSizeInWords(universeSize) << nBytesInWordLog2);}
+	// Clear the bit at index.
+	void clear(Uint32 index) {checkMember(index); word[getWordOffset(index)] &= ~getMask(index);}
+	// Set the bitset.
+	void set() {memset(word, 0xFF, getSizeInWords(universeSize) << nBytesInWordLog2);}
+	// Set the bit at index.
+	void set(Uint32 index) {checkMember(index); word[getWordOffset(index)] |= getMask(index);}
+	// Return true if the bit at index is set.
+	bool test(Uint32 index) const {checkMember(index); return (word[getWordOffset(index)] & getMask(index)) != 0;}
+	// Union with the given bitset.
+	inline void or(const BitSet& set);
+	// Intersection with the given bitset.
+	inline void and(const BitSet& set);
+	// Difference with the given bitset.
+	inline void difference(const BitSet& set);
+	// Copy set.
+	inline BitSet& operator = (const BitSet& set);
+	// Return true if the bitset are identical.
+	friend bool operator == (const BitSet& set1, const BitSet& set2);
+	// Return true if the bitset are different.
+	friend bool operator != (const BitSet& set1, const BitSet& set2);
+
+	// Logical operators.
+	BitSet& operator |= (const BitSet& set) {or(set); return *this;}
+	BitSet& operator &= (const BitSet& set) {and(set); return *this;}
+	BitSet& operator -= (const BitSet& set) {difference(set); return *this;}
+
+	// Return the first bit at set to true or -1 if none.
+	Int32 firstOne() const {return nextOne(-1);}
+	// Return the next bit after index set to true or -1 if none.
+	Int32 nextOne(Int32 pos) const;
+	// Return the first bit at set to false or -1 if none.
+	Int32 firstZero() const {return nextZero(-1);}
+	// Return the next bit after index set to false or -1 if none.
+	Int32 nextZero(Int32 pos) const;
+
+	// Iterator to conform with the set API.
+	typedef Int32 iterator;
+	// Return true if the walk is ordered.
+	static bool isOrdered() {return true;}
+	// Return the iterator for the first element of this set.
+	iterator begin() const {return firstOne();}
+	// Return the next iterator.
+	iterator advance(iterator pos) const {return nextOne(pos);}
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos == -1;}
+	// Return the element corresponding to the given iterator.
+	Uint32 get(iterator pos) const {return pos;}
+
+#ifdef DEBUG_LOG
+	// Print the set.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+// Union with the given bitset.
+//
+inline void  BitSet::or(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ |= *src++;
+}
+
+// Intersection with the given bitset.
+//
+inline void  BitSet::and(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ &= *src++;
+}
+
+// Difference with the given bitset.
+//
+inline void BitSet::difference(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ &= ~*src++;
+}
+
+// Copy the given set into this set.
+//
+inline BitSet& BitSet::operator = (const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	if (this != &set)
+		memcpy(word, set.word, getSizeInWords(universeSize) << nBytesInWordLog2);
+	return *this;
+}
+
+// Return true if the given set is identical to this set.
+inline bool operator == (const BitSet& set1, const BitSet& set2)
+{
+	set1.checkUniverseCompatibility(set2);
+
+	if (&set1 == &set2)
+		return true;
+
+	return memcmp(set1.word, set2.word, BitSet::getSizeInWords(set1.universeSize) << BitSet::nBytesInWordLog2) == 0;
+}
+
+inline bool operator != (const BitSet& set1, const BitSet& set2) {return !(set1 == set2);}
+
+#endif // _BITSET_H

mozilla/ef/Compiler/RegisterAllocator/Coalescing.h

@@ -0,0 +1,159 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _COALESCING_H_
+#define _COALESCING_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "RegisterPressure.h"
+#include "InterferenceGraph.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "SparseSet.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+#if 1
+// Performing an ultra conservative coalescing meens that when we look at
+// candidates (source,destination) for coalescing we need to make sure
+// that the combined interference of the source and destination register
+// will not exceed the total number of register available for the register
+// class. 
+#define ULTRA_CONSERVATIVE_COALESCING
+#else
+// If we are not doing an ultra conservative coalescing we have to make sure 
+// that the total number of neighbor whose degree is greater than the total 
+// number of register is not greater than the total number of register.
+#undef ULTRA_CONSERVATIVE_COALESCING
+#endif
+
+template <class RegisterPressure>
+struct Coalescing
+{
+	static bool coalesce(RegisterAllocator& registerAllocator);
+};
+
+template <class RegisterPressure>
+bool Coalescing<RegisterPressure>::coalesce(RegisterAllocator& registerAllocator)
+{
+	Pool& pool = registerAllocator.pool;
+
+   	// Initialize the lookup table
+	//
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* newRange = new RegisterName[2 * rangeCount];
+	RegisterName* coalescedRange = &newRange[rangeCount];
+	RegisterName* name2range = registerAllocator.name2range;
+
+	init(coalescedRange, rangeCount);
+
+	SparseSet interferences(pool, rangeCount);
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+	bool removedInstructions = false;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.lndList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+
+	// Walk the nodes in the loop nesting depth list.
+	for (Int32 n = nNodes - 1; n >= 0; n--) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		InstructionList::iterator it = instructions.begin();
+		while (!instructions.done(it)) {
+			Instruction& instruction = instructions.get(it);
+			it = instructions.advance(it);
+
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(instruction.getInstructionUseBegin() != instruction.getInstructionUseEnd() && instruction.getInstructionUseBegin()[0].isRegister());
+				assert(instruction.getInstructionDefineBegin() != instruction.getInstructionDefineEnd() && instruction.getInstructionDefineBegin()[0].isRegister());
+
+				RegisterName source = findRoot(name2range[instruction.getInstructionUseBegin()[0].getRegisterName()], coalescedRange);
+				RegisterName destination = findRoot(name2range[instruction.getInstructionDefineBegin()[0].getRegisterName()], coalescedRange);
+
+				if (source == destination) {
+					instruction.remove();
+				} else if (!iGraph.interfere(source, destination)) {
+					InterferenceVector* sourceVector = iGraph.getInterferenceVector(source);
+					InterferenceVector* destinationVector = iGraph.getInterferenceVector(destination);
+
+#ifdef ULTRA_CONSERVATIVE_COALESCING
+					interferences.clear();
+
+					InterferenceVector* vector;
+					for (vector = sourceVector; vector != NULL; vector = vector->next) {
+						RegisterName* neighbors = vector->neighbors;
+						for (Uint32 i = 0; i < vector->count; i++)
+							interferences.set(findRoot(neighbors[i], coalescedRange));
+					}
+					for (vector = destinationVector; vector != NULL; vector = vector->next) {
+						RegisterName* neighbors = vector->neighbors;
+						for (Uint32 i = 0; i < vector->count; i++)
+							interferences.set(findRoot(neighbors[i], coalescedRange));
+					}
+
+					Uint32 count = interferences.getSize();
+#else // ULTRA_CONSERVATIVE_COALESCING
+					trespass("not implemented");
+					Uint32 count = 0;
+#endif // ULTRA_CONSERVATIVE_COALESCING
+
+					if (count < 6 /* FIX: should get the number from the class */) {
+						// Update the interferences vector.
+						if (sourceVector == NULL) {
+							iGraph.setInterferenceVector(source, destinationVector);
+							sourceVector = destinationVector;
+						} else if (destinationVector == NULL)
+							iGraph.setInterferenceVector(destination, sourceVector);
+						else {
+							InterferenceVector* last = NULL;
+							for (InterferenceVector* v = sourceVector; v != NULL; v = v->next)
+								last = v;
+							assert(last);
+							last->next = destinationVector;
+							iGraph.setInterferenceVector(destination, sourceVector);
+						}
+						// Update the interference matrix.
+						for (InterferenceVector* v = sourceVector; v != NULL; v = v->next) {
+							RegisterName* neighbors = v->neighbors;
+							for (Uint32 i = 0; i < v->count; i++) {
+								RegisterName neighbor = findRoot(neighbors[i], coalescedRange);
+								iGraph.setInterference(neighbor, source);
+								iGraph.setInterference(neighbor, destination);
+							}
+						}
+
+						instruction.remove();
+						coalescedRange[source] = destination;
+						removedInstructions = true;
+					}
+				}
+			}
+		}
+	}
+
+	registerAllocator.rangeCount = compress(registerAllocator.name2range, coalescedRange, registerAllocator.nameCount, rangeCount);
+	delete newRange;
+
+	return removedInstructions;
+}
+
+#endif // _COALESCING_H_

mozilla/ef/Compiler/RegisterAllocator/Coloring.cpp

@@ -0,0 +1,283 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef NEW_LAURENTM_CODE
+
+#include "Coloring.h"
+#include "VirtualRegister.h"
+#include "FastBitSet.h"
+#include "FastBitMatrix.h"
+#include "CpuInfo.h"
+
+bool Coloring::
+assignRegisters(FastBitMatrix& interferenceMatrix)
+{
+  PRUint32 *stackPtr = new(pool) PRUint32[vRegManager.count()];
+
+  return select(interferenceMatrix, stackPtr, simplify(interferenceMatrix, stackPtr));
+}
+
+PRInt32 Coloring::
+getLowestSpillCostRegister(FastBitSet& bitset)
+{
+  PRInt32 lowest = bitset.firstOne();
+  if (lowest != -1)
+	{
+	  Flt32 cost = vRegManager.getVirtualRegister(lowest).spillInfo.spillCost;
+	  for (PRInt32 r = bitset.nextOne(lowest); r != -1; r = bitset.nextOne(r))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+		  if (!vReg.spillInfo.infiniteSpillCost && (vReg.spillInfo.spillCost < cost))
+			{
+			  cost = vReg.spillInfo.spillCost;
+			  lowest = r;
+			}
+		}
+	}
+  return lowest;
+}
+
+PRUint32* Coloring::
+simplify(FastBitMatrix interferenceMatrix, PRUint32* stackPtr)
+{
+  // first we construct the sets low and high. low contains all nodes of degree
+  // inferior to the number of register available on the processor. All the
+  // nodes with an high degree and a finite spill cost are placed in high.
+  // Nodes of high degree and infinite spill cost are not included in either sets.
+
+  PRUint32 nRegisters = vRegManager.count();
+  FastBitSet low(pool, nRegisters);
+  FastBitSet high(pool, nRegisters);
+  FastBitSet stack(pool, nRegisters);
+
+  for (VirtualRegisterManager::iterator i = vRegManager.begin(); !vRegManager.done(i); i = vRegManager.advance(i))
+	{
+	  VirtualRegister& vReg = vRegManager.getVirtualRegister(i);
+	  
+	  if (vReg.getClass() == vrcStackSlot)
+		{
+		  stack.set(i);
+		  vReg.colorRegister(nRegisters);
+		}
+	  else
+		{
+		  if (vReg.colorInfo.interferenceDegree < NUMBER_OF_REGISTERS)
+			low.set(i);
+		  else // if (!vReg.spillInfo.infiniteSpillCost)
+			high.set(i);
+
+		  // Set coloring info.
+		  vReg.spillInfo.willSpill = false;
+
+		  switch(vReg.getClass())
+			{
+			case vrcInteger:
+			  vReg.colorRegister(LAST_GREGISTER + 1);
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+			  vReg.colorRegister(LAST_FPREGISTER + 1);
+			  break;
+			default:
+			  PR_ASSERT(false); // Cannot happen.
+			}
+		}
+	}
+
+  // push the stack registers
+  PRInt32 j;
+  for (j = stack.firstOne(); j != -1; j = stack.nextOne(j))
+	*stackPtr++ = j;
+
+  // simplify
+  while (true)
+	{
+	  PRInt32 r;
+	  while ((r = getLowestSpillCostRegister(low)) != -1)
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+
+		  /* update low and high */
+		  FastBitSet inter(interferenceMatrix.getRow(r), nRegisters);
+		  for (j = inter.firstOne(); j != -1; j = inter.nextOne(j))
+			{
+			  VirtualRegister& neighbor = vRegManager.getVirtualRegister(j);
+			  // if the new interference degree of one of his neighbor becomes
+			  // NUMBER_OF_REGISTERS - 1 then it is added to the set 'low'.
+			  
+			  PRUint32 maxInterference = 0;
+			  switch (neighbor.getClass())
+				{
+				case vrcInteger:
+				  maxInterference = NUMBER_OF_GREGISTERS;
+				  break;
+				case vrcFloatingPoint:
+				case vrcFixedPoint:
+				  maxInterference = NUMBER_OF_FPREGISTERS;
+				  break;
+				default:
+				  PR_ASSERT(false);
+				}
+			  if ((vRegManager.getVirtualRegister(j).colorInfo.interferenceDegree-- == maxInterference))
+				{
+				  high.clear(j);
+				  low.set(j);
+				}
+			  vReg.colorInfo.interferenceDegree--;
+			  interferenceMatrix.clear(r, j);
+			  interferenceMatrix.clear(j, r);
+			}
+		  low.clear(r);
+
+		  // Push this register.
+		  *stackPtr++ = r;
+		}
+	  if ((r = getLowestSpillCostRegister(high)) != -1)
+		{
+		  high.clear(r);
+		  low.set(r);
+		}
+	  else
+		break;
+	}
+
+  return stackPtr;
+}
+
+bool Coloring::
+select(FastBitMatrix& interferenceMatrix, PRUint32* stackBase, PRUint32* stackPtr)
+{
+  PRUint32 nRegisters = vRegManager.count();
+  FastBitSet usedRegisters(NUMBER_OF_REGISTERS + 1); // usedRegisters if used for both GR & FPR.
+  FastBitSet preColoredRegisters(NUMBER_OF_REGISTERS + 1);
+  FastBitSet usedStack(nRegisters + 1);
+  bool success = true;
+  Int32 lastUsedSSR = -1;
+
+  // select
+  while (stackPtr != stackBase)
+	{
+	  // Pop one register.
+	  PRUint32 r = *--stackPtr;
+	  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+
+	  FastBitSet neighbors(interferenceMatrix.getRow(r), nRegisters);
+		  
+	  if (vReg.getClass() == vrcStackSlot)
+		// Stack slots coloring.
+		{
+		  usedStack.clear();
+
+		  for (PRInt32 i = neighbors.firstOne(); i != -1; i = neighbors.nextOne(i))
+			usedStack.set(vRegManager.getVirtualRegister(i).getColor());
+
+		  Int32 color = usedStack.firstZero();
+		  vReg.colorRegister(color);
+		  if (color > lastUsedSSR)
+			  lastUsedSSR = color;
+		}
+	  else
+		// Integer & Floating point register coloring.
+		{
+		  usedRegisters.clear();
+		  preColoredRegisters.clear();
+		  
+		  for (PRInt32 i = neighbors.firstOne(); i != -1; i = neighbors.nextOne(i))
+			{
+			  VirtualRegister& nvReg = vRegManager.getVirtualRegister(i);
+			  usedRegisters.set(nvReg.getColor());
+			  if (nvReg.isPreColored())
+				preColoredRegisters.set(nvReg.getPreColor());
+			}
+		  if (vReg.hasSpecialInterference)
+			usedRegisters |= vReg.specialInterference;
+
+		  PRInt8 c = -1;
+		  PRInt8 maxColor = 0;
+		  PRInt8 firstColor = 0;
+		  switch (vReg.getClass())
+			{
+			case vrcInteger:
+			  firstColor = FIRST_GREGISTER;
+			  maxColor = LAST_GREGISTER;
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+			  firstColor = FIRST_FPREGISTER;
+			  maxColor = LAST_FPREGISTER;
+			  break;
+			default:
+			  PR_ASSERT(false);
+			}
+
+		  if (vReg.isPreColored())
+			{
+			  c = vReg.getPreColor();
+			  if (usedRegisters.test(c))
+				c = -1;
+			}
+		  else
+			{
+			  for (c = usedRegisters.nextZero(firstColor - 1); (c >= 0) && (c <= maxColor) && (preColoredRegisters.test(c)); 
+				   c = usedRegisters.nextZero(c)) {}
+			}
+
+		  if ((c >= 0) && (c <= maxColor))
+			{
+			  vReg.colorRegister(c);
+			}
+		  else
+			{
+			  VirtualRegister& stackRegister = vRegManager.newVirtualRegister(vrcStackSlot);
+			  vReg.equivalentRegister[vrcStackSlot] = &stackRegister;	  
+			  vReg.spillInfo.willSpill = true;
+			  success = false;
+			}
+		}
+	}
+  
+#ifdef DEBUG
+  if (success)
+	{
+	  for (VirtualRegisterManager::iterator i = vRegManager.begin(); !vRegManager.done(i); i = vRegManager.advance(i))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(i);
+		  switch (vReg.getClass())
+			{
+			case vrcInteger:
+			  if (vReg.getColor() > LAST_GREGISTER)
+				PR_ASSERT(false);
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+#if NUMBER_OF_FPREGISTERS != 0
+			  if (vReg.getColor() > LAST_FPREGISTER)
+				PR_ASSERT(false);
+#endif
+			  break;
+			default:
+			  break;
+			}
+		}
+	}
+#endif
+
+  vRegManager.nUsedStackSlots = lastUsedSSR + 1;
+  return success;
+}
+#endif // NEW_LAURENTM_CODE

mozilla/ef/Compiler/RegisterAllocator/Coloring.h

@@ -0,0 +1,284 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "VirtualRegister.h"
+#include "InterferenceGraph.h"
+#include "SparseSet.h"
+#include "Spilling.h"
+#include "Splits.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+template <class RegisterPressure>
+class Coloring
+{
+private:
+	static RegisterName* simplify(RegisterAllocator& registerAllocator, RegisterName* coloringStack);
+	static bool select(RegisterAllocator& registerAllocator, RegisterName* coloringStack, RegisterName* coloringStackPtr);
+
+public:
+	static bool color(RegisterAllocator& registerAllocator);
+	static void finalColoring(RegisterAllocator& registerAllocator);
+};
+
+
+template <class RegisterPressure>
+void Coloring<RegisterPressure>::finalColoring(RegisterAllocator& registerAllocator)
+{
+	RegisterName* color = registerAllocator.color;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					usePtr->setRegisterName(color[name2range[usePtr->getRegisterName()]]);
+#ifdef DEBUG
+					RegisterID rid = usePtr->getRegisterID();
+					setColoredRegister(rid);
+					usePtr->setRegisterID(rid);
+#endif // DEBUG
+				}
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					definePtr->setRegisterName(color[name2range[definePtr->getRegisterName()]]);
+#ifdef DEBUG
+					RegisterID rid = definePtr->getRegisterID();
+					setColoredRegister(rid);
+					definePtr->setRegisterID(rid);
+#endif // DEBUG
+				}
+		}
+	}
+}
+
+template <class RegisterPressure>
+bool Coloring<RegisterPressure>::select(RegisterAllocator& registerAllocator, RegisterName* coloringStack, RegisterName* coloringStackPtr)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* color = new RegisterName[rangeCount];
+	registerAllocator.color = color;
+
+	for (Uint32 r = 1; r < rangeCount; r++)
+		color[r] = RegisterName(6); // FIX;
+
+	// Color the preColored registers.
+	//
+	VirtualRegisterManager& vrManager = registerAllocator.vrManager;
+	RegisterName* name2range = registerAllocator.name2range;
+	PreColoredRegister* machineEnd = vrManager.getMachineRegistersEnd();
+	for (PreColoredRegister* machinePtr = vrManager.getMachineRegistersBegin(); machinePtr < machineEnd; machinePtr++)
+		if (machinePtr->id != invalidID) {
+			color[name2range[getName(machinePtr->id)]] = machinePtr->color;
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\twill preColor range %d as %d\n", name2range[getName(machinePtr->id)], machinePtr->color));
+		}
+
+	SpillCost* cost = registerAllocator.spillCost;
+	Pool& pool = registerAllocator.pool;
+	SparseSet& spill = *new(pool) SparseSet(pool, rangeCount);
+	registerAllocator.willSpill = &spill;
+	SparseSet neighborColors(pool, 6); // FIX
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+
+	bool coloringFailed = false;
+	while (coloringStackPtr > coloringStack) {
+		RegisterName range = *--coloringStackPtr;
+
+		if (!cost[range].infinite && cost[range].cost < 0) {
+			coloringFailed = true;
+			spill.set(range);
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tfailed to color %d, will spill.\n", range));
+		} else {
+			neighborColors.clear();
+
+			for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+				for (Int32 i = vector->count - 1; i >= 0; --i) {
+					RegisterName neighborColor = color[vector->neighbors[i]];
+					if (neighborColor < 6) // FIX
+						neighborColors.set(neighborColor);
+				}
+
+			if (neighborColors.getSize() == 6) { // FIX
+				coloringFailed = true;
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tfailed to color %d, ", range));
+
+				if (!Splits<RegisterPressure>::findSplit(registerAllocator, color, range)) {
+					UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("will spill.\n"));
+					spill.set(range);
+				} else
+					UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("will split.\n"));
+			} else {
+				for (Uint32 i = 0; i < 6; i++) // FIX
+					if (!neighborColors.test(i)) {
+						fprintf(stdout, "\twill color %d as %d\n", range, i);
+						color[range] = RegisterName(i);
+						break;
+					}
+			}
+		}
+	}
+
+#ifdef DEBUG_LOG
+	if (coloringFailed) {
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring failed:\n"));
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\twill spill: "));
+		spill.printPretty(UT_LOG_MODULE(RegAlloc));
+	} else {
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring succeeded:\n"));
+		for (Uint32 i = 1; i < rangeCount; i++)
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\trange %d colored as %d\n", i, color[i]));
+	}
+#endif
+
+	return !coloringFailed;
+}
+
+template <class RegisterPressure>
+RegisterName* Coloring<RegisterPressure>::simplify(RegisterAllocator& registerAllocator, RegisterName* coloringStack)
+{
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+	SpillCost* spillCost = registerAllocator.spillCost;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+
+	Uint32* degree = new Uint32[rangeCount];
+	for (RegisterName i = RegisterName(1); i < rangeCount; i = RegisterName(i + 1)) {
+		InterferenceVector* vector = iGraph.getInterferenceVector(i);
+		degree[i] = (vector != NULL) ? vector->count : 0;
+	}
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet low(pool, rangeCount);
+	SparseSet high(pool, rangeCount);
+	SparseSet highInfinite(pool, rangeCount);
+	SparseSet preColored(pool, rangeCount);
+
+	// Get the precolored registers.
+	//
+	VirtualRegisterManager& vrManager = registerAllocator.vrManager;
+	RegisterName* name2range = registerAllocator.name2range;
+	PreColoredRegister* machineEnd = vrManager.getMachineRegistersEnd();
+	for (PreColoredRegister* machinePtr = vrManager.getMachineRegistersBegin(); machinePtr < machineEnd; machinePtr++)
+		if (machinePtr->id != invalidID)
+			preColored.set(name2range[getName(machinePtr->id)]);
+
+	// Insert the live ranges in the sets.
+	//
+	for (Uint32 range = 1; range < rangeCount; range++)
+		if (!preColored.test(range))
+			if (degree[range] < 6) // FIX
+				low.set(range);
+			else if (!spillCost[range].infinite)
+				high.set(range);
+			else
+				highInfinite.set(range);
+
+#ifdef DEBUG_LOG
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring sets:\n\tlow = "));
+	low.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\thigh = "));
+	high.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\thighInfinite = "));
+	highInfinite.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tpreColored = "));
+	preColored.printPretty(UT_LOG_MODULE(RegAlloc));
+#endif // DEBUG_LOG
+
+	RegisterName* coloringStackPtr = coloringStack;
+
+	while (low.getSize() != 0 || high.getSize() != 0) {
+		while (low.getSize() != 0) {
+			RegisterName range = RegisterName(low.getOne());
+			low.clear(range);
+			*coloringStackPtr++ = range;
+
+			for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+				for (Int32 i = (vector->count - 1); i >= 0; --i) {
+					RegisterName neighbor = vector->neighbors[i];
+					degree[neighbor]--;
+
+					if (degree[neighbor] < 6) // FIX
+						if (high.test(neighbor)) {
+							high.clear(neighbor);
+							low.set(neighbor);
+						} else if (highInfinite.test(neighbor)) {
+							highInfinite.clear(neighbor);
+							low.set(neighbor);
+						}
+				}
+		}
+
+		if (high.getSize() != 0) {
+			RegisterName best = RegisterName(high.getOne());
+			double bestCost = spillCost[best].cost;
+			double bestDegree = degree[best];
+
+			// Choose the next best candidate.
+			//
+			for (SparseSet::iterator i = high.begin(); !high.done(i); i = high.advance(i)) {
+				RegisterName range = RegisterName(high.get(i));
+				double thisCost = spillCost[range].cost;
+				double thisDegree = degree[range];
+
+				if (thisCost * bestDegree < bestCost * thisDegree) {
+					best = range;
+					bestCost = thisCost;
+					bestDegree = thisDegree;
+				}
+			}
+			
+			high.clear(best);
+			low.set(best);
+		}
+ 	}
+	assert(highInfinite.getSize() == 0);
+
+	delete degree;
+
+#ifdef DEBUG_LOG
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring stack:\n\t"));
+	for (RegisterName* sp = coloringStack; sp < coloringStackPtr; ++sp)
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("%d ", *sp));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\n"));
+#endif // DEBUG_LOG
+
+	return coloringStackPtr;
+}
+
+
+template <class RegisterPressure>
+bool Coloring<RegisterPressure>::color(RegisterAllocator& registerAllocator)
+{
+	RegisterName* coloringStack = new RegisterName[registerAllocator.rangeCount];
+	return select(registerAllocator, coloringStack, simplify(registerAllocator, coloringStack));
+}

mozilla/ef/Compiler/RegisterAllocator/DominatorGraph.cpp

@@ -0,0 +1,212 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+
+#include "DominatorGraph.h"
+
+DominatorGraph::DominatorGraph(ControlGraph& controlGraph) : controlGraph(controlGraph)
+{
+	Uint32 nNodes = controlGraph.nNodes;
+
+	GtoV = new Uint32[nNodes + 1];
+	VtoG = new Uint32[nNodes + 1];
+
+	Uint32 v = 1;
+	for (Uint32 n = 0; n < nNodes; n++) {
+		VtoG[v] = n;
+		GtoV[n] = v++;
+	}
+
+	// Initialize all the 1-based arrays.
+	//
+	parent =	new Uint32[v];
+	semi =		new Uint32[v];
+	vertex =	new Uint32[v];
+	label =		new Uint32[v];
+	size =		new Uint32[v];
+	ancestor =	new Uint32[v];
+	child =		new Uint32[v];
+	dom =		new Uint32[v];
+	bucket =	new DGLinkedList*[v];
+
+	memset(semi, '\0', v * sizeof(Uint32));
+	memset(bucket, '\0', v * sizeof(DGLinkedList*));
+
+	vCount = v;
+
+	build();
+
+	delete parent;
+	delete semi;
+	delete vertex;
+	delete label;
+	delete size;
+	delete ancestor;
+	delete child;
+	delete dom;
+	delete bucket;
+}
+
+Uint32 DominatorGraph::DFS(Uint32 vx, Uint32 n)
+{
+	semi[vx] = ++n;
+	vertex[n] = label[vx] = vx;
+	ancestor[vx] = child[vx] = 0;
+	size[vx] = 1;
+
+
+	ControlNode& node = *controlGraph.dfsList[VtoG[vx]];
+	ControlEdge* successorEnd = node.getSuccessorsEnd();
+	for (ControlEdge* successorPtr = node.getSuccessorsBegin(); successorPtr < successorEnd; successorPtr++) {
+		Uint32 w = GtoV[successorPtr->getTarget().dfsNum];
+		if (semi[w] == 0) {
+			parent[w] = vx;
+			n = DFS(w, n);
+		}
+	}
+	return n;
+}
+
+void DominatorGraph::LINK(Uint32 vx, Uint32 w)
+{
+    Uint32 s = w;
+
+	while (semi[label[w]] < semi[label[child[s]]]) {
+		if (size[s] + size[child[child[s]]] >= (size[child[s]] << 1)) {
+			ancestor[child[s]] = s;
+			child[s] = child[child[s]];
+		} else {
+			size[child[s]] = size[s];
+			s = ancestor[s] = child[s];
+		}
+	}
+	label[s] = label[w];
+	size[vx] += size[w];
+	if(size[vx] < (size[w] << 1)) {
+		Uint32 t = s;
+		s = child[vx]; 
+		child[vx] = t;
+	}
+	while( s != 0 ) {
+		ancestor[s] = vx;
+		s = child[s];
+	}
+}
+
+
+void DominatorGraph::COMPRESS(Uint32 vx)
+{
+	if(ancestor[ancestor[vx]] != 0) {
+		COMPRESS(ancestor[vx]);
+		if(semi[label[ancestor[vx]]] < semi[label[vx]])
+			label[vx] = label[ancestor[vx]];
+		ancestor[vx] = ancestor[ancestor[vx]];
+	}
+}
+
+Uint32 DominatorGraph::EVAL(Uint32 vx)
+{
+	if(ancestor[vx] == 0) 
+		return label[vx];
+	COMPRESS(vx);
+	return (semi[label[ancestor[vx]]] >= semi[label[vx]]) ? label[vx] : label[ancestor[vx]];
+}
+
+void DominatorGraph::build()
+{
+	Uint32 n = DFS(GtoV[0], 0);
+	size[0] = label[0] = semi[0];
+
+	for (Uint32 i = n; i >= 2; i--) {
+		Uint32 w = vertex[i];
+
+		ControlNode& node = *controlGraph.dfsList[VtoG[w]];
+		const DoublyLinkedList<ControlEdge>& predecessors = node.getPredecessors();
+		for (DoublyLinkedList<ControlEdge>::iterator p = predecessors.begin(); !predecessors.done(p); p = predecessors.advance(p)) {
+			Uint32 vx = GtoV[predecessors.get(p).getSource().dfsNum];
+			Uint32 u = EVAL(vx);
+
+			if(semi[u] < semi[w])
+				semi[w] = semi[u];
+		}
+
+		DGLinkedList* elem = new DGLinkedList();
+		elem->next = bucket[vertex[semi[w]]];
+		elem->index = w;
+		bucket[vertex[semi[w]]] = elem;
+
+		LINK(parent[w], w);
+
+		elem = bucket[parent[w]];
+		while(elem != NULL) {
+			Uint32 vx = elem->index;
+			Uint32 u = EVAL(vx);
+			dom[vx] = (semi[u] < semi[vx]) ? u : parent[w];
+			elem = elem->next;
+		}
+	}
+
+	memset(size, '\0', n * sizeof(Uint32));
+	Pool& pool = controlGraph.pool;
+	nodes = new(pool) DGNode[n];
+
+	for(Uint32 j = 2; j <= n; j++) {
+		Uint32 w = vertex[j];
+		Uint32 d = dom[w];
+		if(d != vertex[semi[w]]) {
+			d = dom[d];
+			dom[w] = d;
+		}
+		size[d]++;
+	}
+	dom[GtoV[0]] = 0;
+
+	for (Uint32 k = 1; k <= n; k++) {
+		DGNode& node = nodes[VtoG[k]];
+		Uint32 count = size[k];
+		node.successorsEnd = node.successorsBegin = (count) ? new(pool) Uint32[count] : (Uint32*) 0;
+	}
+
+	for (Uint32 l = 2; l <= n; l++)
+		*(nodes[VtoG[dom[l]]].successorsEnd)++ = VtoG[l];
+}
+
+#ifdef DEBUG_LOG
+void DominatorGraph::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Dominator Graph:\n"));
+	Uint32 nNodes = controlGraph.nNodes;
+	for (Uint32 i = 0; i < nNodes; i++) {
+		DGNode& node = nodes[i];
+		if (node.successorsBegin !=  node.successorsEnd) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tN%d dominates ", i));
+			for (Uint32* successorsPtr = node.successorsBegin; successorsPtr < node.successorsEnd; successorsPtr++)
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("N%d ", *successorsPtr));
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+		}
+	}
+}
+
+#endif // DEBUG_LOG
+
+
+

mozilla/ef/Compiler/RegisterAllocator/DominatorGraph.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _DOMINATOR_GRAPH_H_
+#define _DOMINATOR_GRAPH_H_
+
+#include "LogModule.h"
+
+class ControlGraph;
+
+struct DGNode
+{
+	Uint32* successorsBegin;
+	Uint32* successorsEnd;
+};
+
+struct DGLinkedList
+{
+	DGLinkedList* next;
+	Uint32 index;
+};
+
+class DominatorGraph
+{
+private:
+
+	ControlGraph&	controlGraph;
+
+	Uint32			vCount;
+
+	Uint32*			VtoG;
+	Uint32*			GtoV;
+	Uint32*			parent;
+	Uint32*			semi;
+	Uint32*			vertex;
+	Uint32*			label;
+	Uint32*			size;
+	Uint32*			ancestor;
+	Uint32*			child;
+	Uint32*			dom;
+	DGLinkedList**	bucket;
+	DGNode*			nodes;
+	
+private:
+
+	void build();
+
+	Uint32 DFS(Uint32 vx, Uint32 n);
+	void LINK(Uint32 vx, Uint32 w);
+	void COMPRESS(Uint32 vx);
+	Uint32 EVAL(Uint32 vx);
+
+public:
+
+	DominatorGraph(ControlGraph& controlGraph);
+
+	Uint32* getSuccessorsBegin(Uint32 n) const {return nodes[n].successorsBegin;}
+	Uint32* getSuccessorsEnd(Uint32 n) const {return nodes[n].successorsEnd;}
+
+#ifdef DEBUG_LOG
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+#endif // _DOMINATOR_GRAPH_H_

mozilla/ef/Compiler/RegisterAllocator/HashSet.cpp

@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "HashSet.h"

mozilla/ef/Compiler/RegisterAllocator/HashSet.h

@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _HASH_SET_H_
+#define _HASH_SET_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include <string.h>
+
+struct HashSetElement
+{
+	Uint32 index;
+	HashSetElement* next;
+};
+
+class HashSet
+{
+private:
+
+	static const hashSize = 64;
+
+	// Return the hash code for the given element index.
+	static Uint32 getHashCode(Uint32 index) {return index & (hashSize - 1);} // Could be better !
+
+private:
+
+	Pool&					allocationPool;
+	HashSetElement**		bucket;
+	HashSetElement*			free;
+
+private:
+
+	// No copy constructor.
+	HashSet(const HashSet&);
+	// No copy operator.
+	void operator = (const HashSet&);
+
+public:
+
+	// Create a new HashSet.
+	inline HashSet(Pool& pool, Uint32 universeSize);
+
+	// Clear the hashset.
+	void clear();
+	// Clear the element for the given index.
+	void clear(Uint32 index);
+	// Set the element for the given index.
+	void set(Uint32 index);
+	// Return true if the element at index is a member.
+	bool test(Uint32 index) const;
+	// Union with the given hashset.
+	inline void or(const HashSet& set);
+	// Intersection with the given hashset.
+	inline void and(const HashSet& set);
+	// Difference with the given hashset.
+	inline void difference(const HashSet& set);
+
+	// Logical operators.
+	HashSet& operator |= (const HashSet& set) {or(set); return *this;}
+	HashSet& operator &= (const HashSet& set) {and(set); return *this;}
+	HashSet& operator -= (const HashSet& set) {difference(set); return *this;}
+
+	// Iterator to conform with the set API.
+	typedef HashSetElement* iterator;
+	// Return the iterator for the first element of this set.
+	iterator begin() const;
+	// Return the next iterator.
+	iterator advance(iterator pos) const;
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos == NULL;}
+};
+
+
+inline HashSet::HashSet(Pool& pool, Uint32 /*universeSize*/)
+	: allocationPool(pool), free(NULL)
+{
+	bucket = new(pool) HashSetElement*[hashSize];
+	memset(bucket, '\0', sizeof(HashSetElement*));
+}
+
+#endif // _HASH_SET_H_

mozilla/ef/Compiler/RegisterAllocator/IndexedPool.h

@@ -0,0 +1,213 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _INDEXED_POOL_H_
+#define _INDEXED_POOL_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include <stdlib.h>
+
+//------------------------------------------------------------------------------
+// IndexedPool<IndexedObjectSubclass> is an indexed pool of objects. The
+// template parameter 'IndexedObjectSubclass' must be a subclass of the struct
+// IndexedObject.
+// 
+// When the indexed pool is ask to allocate and initialize a new object (using
+// the operator new(anIndexedPool) it will zero the memory used to store the
+// object and initialize the field 'index' of this object to its position in
+// the pool.
+//
+// An object allocated by the indexed pool can be freed by calling the method
+// IndexedPool::release(IndexedElement& objectIndex).
+//
+// example:
+//
+//   IndexedPool<IndexedElement> elementPool;
+//
+//   IndexedElement& element1 = *new(elementPool) IndexedElement();
+//   IndexedElement& element2 = *new(elementPool) IndexedElement();
+//
+//   indexedPool.release(element1);
+//   IndexedElement& element3 = *new(elementPool) IndexedElement();
+//
+//  At this point element1 is no longer a valid object, element2 is at
+//  index 2 and element3 is at index 1.
+//
+
+//------------------------------------------------------------------------------
+// IndexedObject -
+//
+
+template<class Object>
+struct IndexedObject
+{
+	Uint32			index;				// Index in the pool.
+	Object*			next;				// Used to link IndexedObject together.
+
+	Uint32 getIndex() {return index;}
+};
+
+//------------------------------------------------------------------------------
+// IndexedPool<IndexedObject> -
+//
+
+template <class IndexedObject>
+class IndexedPool
+{
+private:
+
+	static const	blockSize = 4;		// Size of one block.
+
+	Uint32			nBlocks;			// Number of blocks in the pool.
+	IndexedObject**	block;				// Array of block pointers.
+	IndexedObject*  freeObjects;		// Chained list of free IndexedObjects.
+	Uint32			nextIndex;			// Index of the next free object in the last block. 
+
+private:
+
+	void allocateAnotherBlock();
+	IndexedObject& newObject();
+
+public:
+
+	IndexedPool() : nBlocks(0), block(NULL), freeObjects(NULL), nextIndex(1) {}
+	~IndexedPool();
+
+	IndexedObject& get(Uint32 index) const;
+	void release(IndexedObject& object);
+
+	void setSize(Uint32 size) {assert(size < nextIndex); nextIndex = size;}
+
+	// Return the universe size.
+	Uint32 getSize() {return nextIndex;}
+
+	friend void* operator new(size_t, IndexedPool<IndexedObject>& pool); // Needs to call newObject().
+};
+
+// Free all the memory allocated for this object.
+//
+template <class IndexedObject>
+IndexedPool<IndexedObject>::~IndexedPool()
+{
+	for (Uint32 n = 0; n < nBlocks; n++)
+		free(&((IndexedObject **) &block[n][n*blockSize])[-(n + 1)]);
+}
+
+// Release the given. This object will be iserted in the chained
+// list of free IndexedObjects. To minimize the fragmentation the chained list 
+// is ordered by ascending indexes.
+//
+template <class IndexedObject>
+void IndexedPool<IndexedObject>::release(IndexedObject& object)
+{
+	Uint32 index = object.index;
+	IndexedObject* list = freeObjects;
+
+	assert(&object == &get(index)); // Make sure that object is owned by this pool.
+
+	if (list == NULL) { // The list is empty.
+		freeObjects = &object;
+		object.next = NULL;
+	} else { // The list contains at least 1 element.
+		if (index < list->index) { // insert as first element.
+			freeObjects = &object;
+			object.next = list;
+		} else { // Find this object's place.
+			while ((list->next) != NULL && (list->next->index < index))
+				list = list->next;
+
+			object.next = list->next;
+			list->next = &object;
+		}
+	}
+
+#ifdef DEBUG
+	// Sanity check to be sure that the list is correctly ordered.
+	for (IndexedObject* obj = freeObjects; obj != NULL; obj = obj->next)
+		if (obj->next != NULL)
+			assert(obj->index < obj->next->index);
+#endif
+}
+
+// Create a new block of IndexedObjects. We will allocate the memory to
+// store IndexedPool::blockSize IndexedObject and the new Array of block
+// pointers.
+// The newly created IndexedObjects will not be initialized.
+//
+template <class IndexedObject>
+void IndexedPool<IndexedObject>::allocateAnotherBlock()
+{
+	void* memory = (void *) malloc((nBlocks + 1) * sizeof(Uint32) + blockSize * sizeof(IndexedObject));
+
+	memcpy(memory, block, nBlocks * sizeof(Uint32));
+
+	block = (IndexedObject **) memory;
+	IndexedObject* objects = (IndexedObject *) &block[nBlocks + 1];
+
+	block[nBlocks] = &objects[-(nBlocks * blockSize)];
+	nBlocks++;
+}
+
+// Return the IndexedObject at the position 'index' in the pool.
+//
+template <class IndexedObject>
+IndexedObject& IndexedPool<IndexedObject>::get(Uint32 index) const
+{
+	Uint32 blockIndex = index / blockSize;
+	assert(blockIndex < nBlocks);
+
+	return block[blockIndex][index];
+}
+
+// Return the reference of an unused object in the pool.
+//
+template <class IndexedObject>
+IndexedObject& IndexedPool<IndexedObject>::newObject()
+{
+	if (freeObjects != NULL) {
+		IndexedObject& newObject = *freeObjects;
+		freeObjects = newObject.next;
+		return newObject;
+	}
+	
+	Uint32 nextIndex = this->nextIndex++;
+	Uint32 blockIndex = nextIndex / blockSize;
+
+	while (blockIndex >= nBlocks)
+		allocateAnotherBlock();
+	
+	IndexedObject& newObject = block[blockIndex][nextIndex];
+	newObject.index = nextIndex;
+
+	return newObject;
+}
+
+// Return the address of the next unsused object in the given
+// indexed pool. The field index of the newly allocated object
+// will be initialized to the corresponding index of this object
+// in the pool.
+//
+template <class IndexedObject>
+void* operator new(size_t size, IndexedPool<IndexedObject>& pool)
+{
+	assert(size == sizeof(IndexedObject));
+	return (void *) &pool.newObject();
+}
+
+#endif // _INDEXED_POOL_H_

mozilla/ef/Compiler/RegisterAllocator/InterferenceGraph.h

@@ -0,0 +1,258 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _INTERFERENCE_GRAPH_H_
+#define _INTERFERENCE_GRAPH_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "Primitives.h"
+#include "Instruction.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h"
+#include "SparseSet.h"
+#include <string.h>
+
+struct InterferenceVector
+{
+	Uint32				count;
+	InterferenceVector*	next;
+	RegisterName*		neighbors;
+
+	InterferenceVector() : count(0), next(NULL) {}
+};
+
+class RegisterAllocator;
+
+template <class RegisterPressure>
+class InterferenceGraph
+{
+private:
+
+	RegisterAllocator&			registerAllocator;
+
+	RegisterPressure::Set*		interferences;
+	InterferenceVector**		vector;
+	Uint32*						offset;
+	Uint32 						rangeCount;
+
+private:
+
+	// No copy constructor.
+	InterferenceGraph(const InterferenceGraph&);
+	// No copy operator.
+	void operator = (const InterferenceGraph&);
+
+	// Check if reg is a member of the universe.
+	void checkMember(RegisterName name) {assert(name < rangeCount);}
+	// Return the edge index for the interference between name1 and name2.
+	Uint32 getEdgeIndex(RegisterName name1, RegisterName name2);
+
+public:
+	InterferenceGraph(RegisterAllocator& registerAllocator) : registerAllocator(registerAllocator) {}
+
+	// Calculate the interferences.
+	void build();
+	// Return true if reg1 and reg2 interfere.
+	bool interfere(RegisterName name1, RegisterName name2);
+	// Return the interference vector for the given register or NULL if there is none.
+	InterferenceVector* getInterferenceVector(RegisterName name) {return vector[name];}
+	// Set the interference between name1 and name2.
+	void setInterference(RegisterName name1, RegisterName name2);
+	// Set the interference vector for the given register.
+	void setInterferenceVector(RegisterName name, InterferenceVector* v) {vector[name] = v;}
+
+
+#ifdef DEBUG_LOG
+	// Print the interferences.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::build()
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	this->rangeCount = rangeCount;
+
+	// Initialize the structures.
+	//
+	offset = new(pool) Uint32[rangeCount + 1];
+	vector = new(pool) InterferenceVector*[rangeCount];
+	memset(vector, '\0', sizeof(InterferenceVector*) * rangeCount);
+
+	Uint32 o = 0;
+	offset[0] = 0;
+	for (Uint32 i = 1; i <= rangeCount; ++i) {
+		offset[i] = o;
+		o += i;
+	}
+	
+	interferences = new(pool) RegisterPressure::Set(pool, (rangeCount * rangeCount) / 2);
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	RegisterName* name2range = registerAllocator.name2range;
+	LivenessInfo<RegisterPressure> liveness = Liveness<RegisterPressure>::analysis(controlGraph, rangeCount, name2range);
+	registerAllocator.liveness = liveness;
+	SparseSet currentLive(pool, rangeCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		currentLive = liveness.liveOut[n];
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			// Handle the copy instruction to avoid unnecessary interference between the 2 registers.
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				currentLive.clear(name2range[useBegin[0].getRegisterName()]);
+			}
+
+			// Create the interferences.
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					RegisterName define = name2range[definePtr->getRegisterName()];
+
+					for (SparseSet::iterator e = currentLive.begin(); !currentLive.done(e); e = currentLive.advance(e)) {
+						RegisterName live = RegisterName(currentLive.get(e));
+
+						if ((live != define) && !interfere(live, define) && registerAllocator.canInterfere(live, define)) {
+
+							if (vector[define] == NULL)
+								vector[define] = new(pool) InterferenceVector();
+							vector[define]->count++;
+
+							if (vector[live] == NULL)
+								vector[live] = new(pool) InterferenceVector();
+							vector[live]->count++;
+
+							setInterference(live, define);
+						}
+					}
+				}
+
+			// Now update the liveness.
+			//
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					currentLive.set(name2range[usePtr->getRegisterName()]);
+		}
+	}
+
+	// Allocate the memory to store the interferences.
+	//
+	for (Uint32 e = 0; e < rangeCount; e++)
+		if (vector[e] != NULL) {
+			InterferenceVector& v = *vector[e];
+			v.neighbors = new(pool) RegisterName[v.count];
+			v.count = 0;
+		}
+
+	// Initialize the edges.
+	//
+	if (RegisterPressure::Set::isOrdered()) {
+		RegisterName name1 = RegisterName(0);
+
+		for (RegisterPressure::Set::iterator i = interferences->begin(); !interferences->done(i); i = interferences->advance(i)) {
+			Uint32 interferenceIndex = interferences->get(i);
+
+			while(interferenceIndex >= offset[name1 + 1])
+				name1 = RegisterName(name1 + 1);
+
+			assert((interferenceIndex >= offset[name1]) && (interferenceIndex < offset[name1 + 1]));
+
+			RegisterName name2 = RegisterName(interferenceIndex - offset[name1]);
+
+			assert(interfere(name1, name2));
+
+			InterferenceVector& vector1 = *vector[name1];
+			vector1.neighbors[vector1.count++] = name2;
+		
+			InterferenceVector& vector2 = *vector[name2];
+			vector2.neighbors[vector2.count++] = name1;
+		}
+	} else {
+		trespass("not Implemented"); // FIX: need one more pass to initialize the vectors.
+	}
+}
+
+template <class RegisterPressure>
+Uint32 InterferenceGraph<RegisterPressure>::getEdgeIndex(RegisterName name1, RegisterName name2)
+{
+	checkMember(name1); checkMember(name2);
+	assert(name1 != name2); // This is not possible.
+	return (name1 < name2) ? offset[name2] + name1 : offset[name1] + name2;
+}
+
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::setInterference(RegisterName name1, RegisterName name2)
+{
+	interferences->set(getEdgeIndex(name1, name2));
+}
+
+template <class RegisterPressure>
+bool InterferenceGraph<RegisterPressure>::interfere(RegisterName name1, RegisterName name2)
+{
+	return interferences->test(getEdgeIndex(name1, name2));
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Interference Vectors:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		if (vector[i] != NULL) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tvr%d: (", i));
+			for (InterferenceVector* v = vector[i]; v != NULL; v = v->next)
+				for (Uint32 j = 0; j < v->count; j++) {
+					UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%d", v->neighbors[j]));
+					if (v->next != NULL || j != (v->count - 1))
+						UT_OBJECTLOG(log, PR_LOG_ALWAYS, (","));
+				}
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (")\n"));
+		}
+	}
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Interference Matrix:\n"));
+	for (RegisterName name1 = RegisterName(1); name1 < rangeCount; name1 = RegisterName(name1 + 1)) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\t%d:\t", name1));
+		for (RegisterName name2 = RegisterName(1); name2 < rangeCount; name2 = RegisterName(name2 + 1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%c", ((name1 != name2) && interfere(name1, name2)) ? '1' : '0'));
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _INTERFERENCE_GRAPH_H_

mozilla/ef/Compiler/RegisterAllocator/LiveRange.h

@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVE_RANGE_H_
+#define _LIVE_RANGE_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Primitives.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+template <class RegisterPressure>
+struct LiveRange
+{
+	static void build(RegisterAllocator& registerAllocator);
+};
+
+template <class RegisterPressure>
+void LiveRange<RegisterPressure>::build(RegisterAllocator& registerAllocator)
+{
+	// Intialize the lookup table.
+	//
+	Uint32 nameCount = registerAllocator.nameCount;
+	RegisterName* nameTable = new(registerAllocator.pool) RegisterName[2*nameCount];
+	RegisterName* rangeName = &nameTable[nameCount];
+
+	init(rangeName, nameCount);
+
+	// Walk the graph.
+	//
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	SparseSet destination(registerAllocator.pool, nameCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+
+		destination.clear();
+		for (InstructionList::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+			Instruction& phiNode = phiNodes.get(i);
+			assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+			destination.set(findRoot(phiNode.getInstructionDefineBegin()[0].getRegisterName(), rangeName));
+		}
+
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& phiNode = phiNodes.get(p);
+
+			assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+			RegisterName destinationName = phiNode.getInstructionDefineBegin()[0].getRegisterName();
+			RegisterName destinationRoot = findRoot(destinationName, rangeName);
+
+			InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+			for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++) {
+				assert(usePtr->isRegister());
+				RegisterName sourceName = usePtr->getRegisterName();
+				RegisterName sourceRoot = findRoot(sourceName, rangeName);
+
+				if (sourceRoot != destinationRoot && !destination.test(sourceRoot))
+					rangeName[sourceRoot] = destinationRoot;
+			}
+		}
+	}
+
+	registerAllocator.rangeCount = compress(registerAllocator.name2range, rangeName, nameCount, nameCount);
+}
+
+#endif // _LIVE_RANGE_H_

mozilla/ef/Compiler/RegisterAllocator/LiveRangeGraph.h

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVE_RANGE_GRAPH_
+#define _LIVE_RANGE_GRAPH_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterTypes.h"
+
+class RegisterAllocator;
+
+template <class RegisterPressure>
+class LiveRangeGraph
+{
+private:
+
+	RegisterAllocator&		registerAllocator;
+
+	RegisterPressure::Set*	edges;
+	Uint32					rangeCount;
+
+public:
+	//
+	//
+	LiveRangeGraph(RegisterAllocator& registerAllocator) : registerAllocator(registerAllocator) {}
+
+	//
+	//
+	void build();
+
+	//
+	//
+	void addEdge(RegisterName name1, RegisterName name2);
+
+	//
+	//
+	bool haveEdge(RegisterName name1, RegisterName name2);
+
+#ifdef DEBUG_LOG
+	//
+	//
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::build()
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	this->rangeCount = rangeCount;
+
+	edges = new(pool) RegisterPressure::Set(pool, rangeCount * rangeCount);
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	RegisterName* name2range = registerAllocator.name2range;
+	LivenessInfo<RegisterPressure>& liveness = registerAllocator.liveness;
+	SparseSet currentLive(pool, rangeCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		currentLive = liveness.liveOut[n];
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				currentLive.clear(name2range[useBegin[0].getRegisterName()]);
+			}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					RegisterName define = name2range[definePtr->getRegisterName()];
+
+					for (SparseSet::iterator l = currentLive.begin(); !currentLive.done(l); l = currentLive.advance(l)) {
+						RegisterName live = RegisterName(currentLive.get(l));
+						if (define != live && registerAllocator.canInterfere(define, live))
+							addEdge(define, live);
+					}
+				}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					currentLive.set(name2range[usePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName use = name2range[usePtr->getRegisterName()];
+
+					for (SparseSet::iterator l = currentLive.begin(); !currentLive.done(l); l = currentLive.advance(l)) {
+						RegisterName live = RegisterName(currentLive.get(l));
+						if (use != live && registerAllocator.canInterfere(use, live))
+							addEdge(use, live);
+					}
+				}
+		}
+	}
+}
+
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::addEdge(RegisterName name1, RegisterName name2)
+{
+	assert(name1 != name2);
+	edges->set(name1 * rangeCount + name2);
+}
+
+template <class RegisterPressure>
+bool LiveRangeGraph<RegisterPressure>::haveEdge(RegisterName name1, RegisterName name2)
+{
+	assert(name1 != name2);
+	return edges->test(name1 * rangeCount + name2);
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Live ranges graph:\n"));
+	for (RegisterName name1 = RegisterName(1); name1 < rangeCount; name1 = RegisterName(name1 + 1)) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\t%d:\t", name1));
+		for (RegisterName name2 = RegisterName(1); name2 < rangeCount; name2 = RegisterName(name2 + 1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%c", ((name1 != name2) && haveEdge(name1, name2)) ? '1' : '0'));
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _LIVE_RANGE_GRAPH_

mozilla/ef/Compiler/RegisterAllocator/Liveness.cpp

@@ -0,0 +1,21 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "Liveness.h"
+

mozilla/ef/Compiler/RegisterAllocator/Liveness.h

@@ -0,0 +1,301 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVENESS_H_
+#define _LIVENESS_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterTypes.h"
+
+// ----------------------------------------------------------------------------
+// LivenessInfo -
+
+template <class RegisterPressure>
+struct LivenessInfo
+{
+	RegisterPressure::Set*	liveIn;
+	RegisterPressure::Set*	liveOut;
+	DEBUG_LOG_ONLY(Uint32	size);
+
+#ifdef DEBUG_LOG
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+// ----------------------------------------------------------------------------
+// Liveness
+//
+// The liveness is defined by the following data-flow equations:
+//
+//		LiveIn(n) = LocalLive(n) U (LiveOut(n) - Killed(n)).
+//		LiveOut(n) = U LiveIn(s) (s a successor of n).
+//
+//	where LocalLive(n) is the set of used registers in the block n, Killed(n)
+//  is the set of defined registers in the block n, LiveIn(n) is the set of
+//  live registers at the begining of the block n and LiveOut(n) is the set
+//  of live registers at the end of the block n.
+//
+//
+// We will compute the liveness analysis in two stages:
+//
+//	1- Build LocalLive(n) (wich is an approximation of LiveIn(n)) and Killed(n) 
+//     for each block n.
+//  2- Perform a backward data-flow analysis to propagate the liveness information
+//     through the entire control-flow graph.
+//
+
+template <class RegisterPressure>
+struct Liveness
+{
+	static LivenessInfo<RegisterPressure> analysis(ControlGraph& controlGraph, Uint32 rangeCount, const RegisterName* name2range);
+	static LivenessInfo<RegisterPressure> analysis(ControlGraph& controlGraph, Uint32 nameCount);
+};
+
+template <class RegisterPressure>
+LivenessInfo<RegisterPressure> Liveness<RegisterPressure>::analysis(ControlGraph& controlGraph, Uint32 rangeCount, const RegisterName* name2range)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Allocate the temporary sets.
+	RegisterPressure::Set* killed = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+	
+	// Allocate the globals sets.
+	RegisterPressure::Set* liveIn = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+	RegisterPressure::Set* liveOut = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+
+	// First stage of the liveness analysis: Compute the sets LocalLive(stored in LiveIn) and Killed.
+	//
+	for (Uint32 n = 0; n < (nNodes - 1); n++) {
+		ControlNode& node = *nodes[n];
+
+		RegisterPressure::Set& currentLocalLive = liveIn[n];
+		RegisterPressure::Set& currentKilled = killed[n];
+		
+		// Find the instructions contributions to the sets LocalLive and Killed.
+		//
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			// If a VirtualRegister is 'used' before being 'defined' then we add it to set LocalLive.
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					Uint32 index = name2range[usePtr->getRegisterName()];
+
+					if (!currentKilled.test(index))
+						currentLocalLive.set(index);
+				}
+
+			// If a Virtualregister is 'defined' then we add it to the set Killed.
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentKilled.set(name2range[definePtr->getRegisterName()]);
+		}
+	}
+
+	// Second stage of the liveness analysis: We propagate the LiveIn & LiveOut through the entire 
+	// control-flow graph.
+	//
+	RegisterPressure::Set temp(pool, rangeCount);
+
+	bool changed;
+	do {
+		changed = false;
+
+		// For all nodes is this graph except the endNode.
+		for (Int32 n = (nNodes - 2); n >= 0; n--) {
+			ControlNode& node = *nodes[n];
+
+			RegisterPressure::Set& currentLiveIn = liveIn[n];
+			RegisterPressure::Set& currentLiveOut = liveOut[n];
+
+			// Compute temp = Union of LiveIn(s) (s a successor of this node) | usedByPhiNodes(n).
+			// temp will be the new LiveOut(n).
+			Uint32 nSuccessors = node.nSuccessors();
+			if (nSuccessors != 0) {
+				temp = liveIn[node.nthSuccessor(0).getTarget().dfsNum];
+				for (Uint32 s = 1; s < nSuccessors; s++)
+					temp |= liveIn[node.nthSuccessor(s).getTarget().dfsNum];
+			} else 
+				temp.clear();
+
+			// If temp and LiveOut(n) differ then set LiveOut(n) = temp and recalculate the
+			// new LiveIn(n).
+			if (currentLiveOut != temp) {
+				currentLiveOut = temp;
+				temp -= killed[n]; // FIX: could be optimized with one call to unionDiff !
+				temp |= currentLiveIn;
+			
+				if (currentLiveIn != temp) {
+					currentLiveIn = temp;
+					changed = true;
+				}
+			}
+		}
+	} while(changed);
+
+	LivenessInfo<RegisterPressure> liveness;
+	liveness.liveIn = liveIn;
+	liveness.liveOut = liveOut;
+	DEBUG_LOG_ONLY(liveness.size = nNodes);
+	return liveness;
+}
+
+template <class RegisterPressure>
+LivenessInfo<RegisterPressure> Liveness<RegisterPressure>::analysis(ControlGraph& controlGraph, Uint32 nameCount)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Allocate the temporary sets.
+	RegisterPressure::Set* killed = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+	RegisterPressure::Set* usedByPhiNodes = NULL;
+	
+	// Allocate the globals sets.
+	RegisterPressure::Set* liveIn = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+	RegisterPressure::Set* liveOut = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+
+	// First stage of the liveness analysis: Compute the sets LocalLive(stored in LiveIn) and Killed.
+	//
+	for (Uint32 n = 0; n < (nNodes - 1); n++) {
+		ControlNode& node = *nodes[n];
+
+		RegisterPressure::Set& currentLocalLive = liveIn[n];
+		RegisterPressure::Set& currentKilled = killed[n];
+		
+		InstructionList& phiNodes = node.getPhiNodeInstructions();
+
+		if ((usedByPhiNodes == NULL) && !phiNodes.empty())
+			usedByPhiNodes = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& phiNode = phiNodes.get(p);
+
+			InstructionDefine& define = phiNode.getInstructionDefineBegin()[0];
+			currentKilled.set(define.getRegisterName());
+
+			typedef DoublyLinkedList<ControlEdge> ControlEdgeList;
+			const ControlEdgeList& predecessors = node.getPredecessors();
+			ControlEdgeList::iterator p = predecessors.begin();
+			InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+			for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++, p = predecessors.advance(p))
+				if (usePtr->isRegister())
+					usedByPhiNodes[predecessors.get(p).getSource().dfsNum].set(usePtr->getRegisterName());
+		}
+
+		// Find the instructions contributions to the sets LocalLive and Killed.
+		//
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			// If a VirtualRegister is 'used' before being 'defined' then we add it to set LocalLive.
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					Uint32 index = usePtr->getRegisterName();
+
+					if (!currentKilled.test(index))
+						currentLocalLive.set(index);
+				}
+
+			// If a Virtualregister is 'defined' then we add it to the set Killed.
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentKilled.set(definePtr->getRegisterName());
+		}
+	}
+
+	// Second stage of the liveness analysis: We propagate the LiveIn & LiveOut through the entire 
+	// control-flow graph.
+	//
+	RegisterPressure::Set temp(pool, nameCount);
+
+	bool changed;
+	do {
+		changed = false;
+
+		// For all nodes is this graph except the endNode.
+		for (Int32 n = (nNodes - 2); n >= 0; n--) {
+			ControlNode& node = *nodes[n];
+
+			RegisterPressure::Set& currentLiveIn = liveIn[n];
+			RegisterPressure::Set& currentLiveOut = liveOut[n];
+
+			// Compute temp = Union of LiveIn(s) (s a successor of this node) | usedByPhiNodes(n).
+			// temp will be the new LiveOut(n).
+			Uint32 nSuccessors = node.nSuccessors();
+			if (nSuccessors != 0) {
+				temp = liveIn[node.nthSuccessor(0).getTarget().dfsNum];
+				for (Uint32 s = 1; s < nSuccessors; s++)
+					temp |= liveIn[node.nthSuccessor(s).getTarget().dfsNum];
+			} else 
+				temp.clear();
+
+			// Insert the phiNodes contribution.
+			if (usedByPhiNodes != NULL)
+				temp |= usedByPhiNodes[n];
+
+			// If temp and LiveOut(n) differ then set LiveOut(n) = temp and recalculate the
+			// new LiveIn(n).
+			if (currentLiveOut != temp) {
+				currentLiveOut = temp;
+				temp -= killed[n]; // FIX: could be optimized with one call to unionDiff !
+				temp |= currentLiveIn;
+			
+				if (currentLiveIn != temp) {
+					currentLiveIn = temp;
+					changed = true;
+				}
+			}
+		}
+	} while(changed);
+
+	LivenessInfo<RegisterPressure> liveness;
+	liveness.liveIn = liveIn;
+	liveness.liveOut = liveOut;
+	DEBUG_LOG_ONLY(liveness.size = nNodes);
+	return liveness;
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void LivenessInfo<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	for (Uint32 n = 0; n < size; n++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Node N%d:\n\tliveIn = ", n));
+		liveIn[n].printPretty(log);
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tliveOut = "));
+		liveOut[n].printPretty(log);
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _LIVENESS_H_

mozilla/ef/Compiler/RegisterAllocator/Makefile

@@ -0,0 +1,40 @@
+#! gmake
+
+DEPTH			= ../..
+
+MODULE_NAME		= RegisterAllocator
+
+include $(DEPTH)/config/config.mk
+
+INCLUDES		+=										\
+	-I$(DEPTH)/Utilities/General						\
+	-I$(DEPTH)/Utilities/zlib							\
+	-I$(DEPTH)/Runtime/ClassReader						\
+	-I$(DEPTH)/Runtime/NativeMethods					\
+	-I$(DEPTH)/Runtime/System							\
+	-I$(DEPTH)/Runtime/ClassInfo						\
+	-I$(DEPTH)/Runtime/FileReader						\
+	-I$(DEPTH)/Compiler/PrimitiveGraph					\
+	-I$(DEPTH)/Compiler/FrontEnd						\
+	-I$(DEPTH)/Compiler/Optimizer						\
+	-I$(DEPTH)/Compiler/CodeGenerator					\
+	-I$(DEPTH)/Compiler/CodeGenerator/md				\
+	-I$(DEPTH)/Compiler/CodeGenerator/md/$(CPU_ARCH)	\
+	-I$(DEPTH)/Compiler/RegisterAllocator				\
+	-I$(DEPTH)/Driver/StandAloneJava					\
+	-I$(DEPTH)/Debugger									\
+	$(NULL)
+
+CXXSRCS 		=										\
+	RegisterAllocator.cpp								\
+	RegisterAllocatorTools.cpp							\
+	DominatorGraph.cpp									\
+	VirtualRegister.cpp									\
+	BitSet.cpp											\
+	SparseSet.cpp										\
+	$(NULL)
+
+
+include $(DEPTH)/config/rules.mk
+
+libs:: $(MODULE)

mozilla/ef/Compiler/RegisterAllocator/PhiNodeRemover.h

@@ -0,0 +1,392 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _PHI_NODE_REMOVER_H_
+#define _PHI_NODE_REMOVER_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "DominatorGraph.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h"
+#include "Liveness.h"
+#include "Instruction.h"
+#include "InstructionEmitter.h"
+#include "SparseSet.h"
+#include <string.h>
+
+//------------------------------------------------------------------------------
+// RegisterNameNode -
+
+struct RegisterNameNode 
+{
+	RegisterNameNode*	next;
+	RegisterName		newName;
+	Uint32				nextPushed;
+};
+
+//------------------------------------------------------------------------------
+// CopyData -
+
+struct CopyData
+{
+	RegisterName		source;
+	RegisterClassKind	classKind;
+	Uint32				useCount;
+	bool				isLiveOut;
+	RegisterName		sourceNameToUse;
+	RegisterName		temporaryName;
+	RegisterNameNode*	newName;
+};
+
+//------------------------------------------------------------------------------
+// PhiNodeRemover<RegisterPressure> -
+
+template <class RegisterPressure>
+struct PhiNodeRemover
+{
+	// Replace the phi nodes by copy instructions.
+	static void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+};
+
+// Split some of the critical edges and return true if there are still some
+// in the graph after that.
+//
+static bool splitCriticalEdges(ControlGraph& /*cg*/)
+{
+	// FIX: not implemented.
+	return true;
+}
+
+inline void pushName(Pool& pool, RegisterNameNode** stack, SparseSet& pushed, Uint32* nodeListPointer, RegisterName oldName, RegisterName newName)
+{
+	RegisterNameNode& newNode = *new(pool) RegisterNameNode();
+
+	if (pushed.test(oldName))
+		(*stack)->newName = newName;
+	else {
+		newNode.newName = newName;
+		newNode.nextPushed = *nodeListPointer;
+		*nodeListPointer = oldName;
+		newNode.next = *stack;
+		*stack = &newNode;
+		pushed.set(oldName);
+	}
+}
+
+template <class RegisterPressure>
+void PhiNodeRemover<RegisterPressure>::replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Initialize the local variables.
+	//
+
+	// When we insert the copies we will also need to create new VirtualRegisters for
+	// the insertion of temporaries. The maximum number of temporary register will not
+	// exceed the number of phiNodes in the primitive graph.
+	Uint32 nameCount = vrManager.getSize();
+	Uint32 maxNameCount = nameCount;
+	for (Uint32 n = 0; n < nNodes; n++)
+		maxNameCount += nodes[n]->getPhiNodes().length();
+
+	// If the CFG contains some critical edges (backward edge which source has more than one
+	// outgoing edge and destination has more than one incomimg edge) then we need the liveness
+	// information to be able to insert temporary copies.
+	RegisterPressure::Set* liveOut = NULL;
+	if (splitCriticalEdges(controlGraph))
+		liveOut = Liveness<LowRegisterPressure>::analysis(controlGraph, nameCount).liveOut;
+
+	DominatorGraph dGraph(controlGraph);
+
+	SparseSet pushed(pool, maxNameCount);
+	SparseSet destinationList(pool, maxNameCount);
+	SparseSet workList(pool, maxNameCount);
+
+	CopyData* copyStats = new(pool) CopyData[maxNameCount];
+	memset(copyStats, '\0', maxNameCount*sizeof(CopyData));
+
+	struct NodeStack {
+		Uint32* next;
+		Uint32* limit;
+		Uint32 pushedList;
+	};
+
+	// Allocate the node stack and initialize the node stack pointer.
+	NodeStack* nodeStack = new(pool) NodeStack[nNodes + 1];
+	NodeStack* nodeStackPtr = nodeStack;
+
+	// We start by the begin node. 
+	Uint32 startNode = 0;
+	Uint32* next = &startNode;
+	Uint32* limit = &startNode + 1;
+
+	while (true) {
+
+		if (next == limit) {
+			// If there are no more node in the sibling, we have to pop the current
+			// frame from the stack and update the copyStats of the pushed nodes.
+			//
+			if (nodeStackPtr == nodeStack)
+				// We are at the bottom of the stack and there are no more nodes
+				// to look at. We are done !
+				break;
+
+			--nodeStackPtr;
+			// We are done with all the children of this node in the dominator tree.
+			// We need to update the copy information of all the new names pushed
+			// during the walk over this node.
+			Uint32 pushedList = nodeStackPtr->pushedList;
+			while (pushedList != 0) {
+				Uint32 nextName = copyStats[pushedList].newName->nextPushed;
+				copyStats[pushedList].newName = copyStats[pushedList].newName->next;
+				pushedList = nextName;
+			}
+
+			// restore the previous frame.
+			next = nodeStackPtr->next;
+			limit = nodeStackPtr->limit;
+		} else {
+			Uint32 currentNode = *next++;
+			Uint32 pushedList = 0;
+
+
+			// Initialize the sets.
+			pushed.clear();
+			destinationList.clear();
+
+			// STEP1:
+			//  Walk the instruction list and to replace all the instruction uses with their new name. 
+			//  If the instruction is a phi node and its defined register is alive at the end of this 
+			//  block then we push the defined register into the stack.
+			//
+			ControlNode& node = *nodes[currentNode];
+			RegisterPressure::Set* currentLiveOut = (liveOut != NULL) ? &liveOut[currentNode] : (RegisterPressure::Set*) 0;
+
+			InstructionList& phiNodes = node.getPhiNodeInstructions();
+			for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+				Instruction& phiNode = phiNodes.get(p);
+
+				InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+				for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++) {
+					assert(usePtr->isRegister());
+					RegisterName name = usePtr->getRegisterName();
+
+					if (copyStats[name].newName != NULL && copyStats[name].newName->newName != name)
+						usePtr->setRegisterName(copyStats[name].newName->newName);
+				}
+
+				if (currentLiveOut != NULL) {
+					// This is a phi node and we have to push its defined name if it is live
+					// at the end of the node. We only need to do this if the CFG has critical edges.
+					assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+					RegisterName name = phiNode.getInstructionDefineBegin()[0].getRegisterName();
+
+					if (currentLiveOut->test(name))
+						pushName(pool, &(copyStats[name].newName), pushed, &pushedList, name, name);
+				}
+				
+			}
+
+			InstructionList& instructions = node.getInstructions();
+			for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+				Instruction& instruction = instructions.get(i);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+
+						if (copyStats[name].newName != NULL && copyStats[name].newName->newName != name)
+							usePtr->setRegisterName(copyStats[name].newName->newName);
+					}
+			}
+
+			// STEP2:
+			//  Look at this node's successors' phiNodes. We keep track of the number of time
+			//  a VR will be used by another copy instruction and insert each definition into the 
+			//  destinationList. This is the only pass over this node's successors as we will
+			//  get all the information we need in the CopyData structures.
+			//
+			ControlEdge* successorEdgeEnd = node.getSuccessorsEnd();
+			for (ControlEdge* successorEdgePtr = node.getSuccessorsBegin(); successorEdgePtr < successorEdgeEnd; successorEdgePtr++) {
+				Uint32 useIndex = successorEdgePtr->getIndex();
+				ControlNode& successor = successorEdgePtr->getTarget();
+
+				// Look at its phi nodes. The phi nodes are at the top of the instruction list. We exit
+				// as soon as we find an instruction which is not a phi node
+				InstructionList& phiNodes = successor.getPhiNodeInstructions();
+				for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+					Instruction& phiNode = phiNodes.get(p);
+					
+					assert((phiNode.getInstructionUseBegin() + useIndex) < phiNode.getInstructionUseEnd());
+					assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd());
+
+					InstructionUse& source = phiNode.getInstructionUseBegin()[useIndex];
+					InstructionDefine& destination = phiNode.getInstructionDefineBegin()[0];
+
+					assert(source.isRegister() && destination.isRegister());
+
+					RegisterName sourceName = source.getRegisterName();
+					RegisterName destinationName = destination.getRegisterName();
+
+					// Get the correct name for the source.
+					if (copyStats[sourceName].newName != NULL)
+						sourceName = copyStats[sourceName].newName->newName;
+
+					// Update the CopyData structures.
+					if ((sourceName != rnInvalid) && (sourceName != destinationName)) {
+						copyStats[destinationName].source = sourceName;
+						copyStats[destinationName].classKind = destination.getRegisterClass();
+						copyStats[destinationName].isLiveOut = (currentLiveOut != NULL) ? currentLiveOut->test(destinationName) : false;
+						copyStats[destinationName].sourceNameToUse = destinationName;
+						copyStats[sourceName].sourceNameToUse = sourceName;
+						copyStats[sourceName].useCount++;
+						destinationList.set(destinationName);
+					}
+				}
+			}
+
+			// STEP3:
+			//  Insert into the worklist only the destination registers that will be not used in 
+			//  another copy instruction in this block.
+			//
+			assert(workList.getSize() == 0);
+			for (SparseSet::iterator d = destinationList.begin(); !destinationList.done(d); d = destinationList.advance(d)) {
+				Uint32 dest = destinationList.get(d);
+				if (copyStats[dest].useCount == 0)
+					workList.set(dest);
+			}
+
+			// STEP4:
+			//  Insert the copy instructions.
+			//
+			Uint32 destinationListSize = destinationList.getSize();
+			InstructionList::iterator endOfTheNode = instructions.end();
+
+			// Find the right place to insert the copy instructions.
+			if (destinationListSize != 0)
+				while (instructions.get(endOfTheNode).getFlags() & ifControl)
+					endOfTheNode = instructions.retreat(endOfTheNode);
+
+			while (destinationListSize != 0) {
+				while(workList.getSize()) {
+					RegisterName destinationName = RegisterName(workList.getOne());
+					RegisterName sourceName = copyStats[destinationName].source;
+
+					workList.clear(destinationName);
+					if (copyStats[destinationName].isLiveOut && !copyStats[destinationName].temporaryName) {
+						// Lost copy problem.
+						copyStats[destinationName].isLiveOut = false;
+
+						RegisterName sourceName = destinationName;
+						RegisterClassKind classKind = copyStats[sourceName].classKind;
+						RegisterName destinationName = getName(vrManager.newVirtualRegister(classKind));
+						assert(destinationName < maxNameCount);
+
+						copyStats[destinationName].classKind = classKind;
+						copyStats[sourceName].useCount = 0;
+				
+						// We need to insert a copy to a temporary register to keep the
+						// source register valid at the end of the node defining it.
+						// This copy will be inserted right after the phi node defining it.
+						RegisterName from = copyStats[sourceName].sourceNameToUse;
+						Instruction* definingPhiNode = vrManager.getVirtualRegister(from).getDefiningInstruction();
+						assert(definingPhiNode && (definingPhiNode->getFlags() & ifPhiNode) != 0);
+
+						RegisterID fromID = buildRegisterID(from, classKind);
+						RegisterID toID = buildRegisterID(destinationName, classKind);
+						Instruction& copy = emitter.newCopy(*definingPhiNode->getPrimitive(), fromID, toID);
+						vrManager.getVirtualRegister(destinationName).setDefiningInstruction(copy);
+						definingPhiNode->getPrimitive()->getContainer()->getInstructions().addFirst(copy);
+
+						copyStats[sourceName].temporaryName = destinationName;
+						copyStats[sourceName].sourceNameToUse = destinationName;
+						pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+					}
+
+					// Insert the copy instruction at the end of the current node.
+					RegisterName from = copyStats[sourceName].sourceNameToUse;
+
+					RegisterClassKind classKind = copyStats[destinationName].classKind;
+					RegisterID fromID = buildRegisterID(from, classKind);
+					RegisterID toID = buildRegisterID(destinationName, classKind);
+					Instruction& copy = emitter.newCopy(*vrManager.getVirtualRegister(from).getDefiningInstruction()->getPrimitive(), fromID, toID);
+					instructions.insertAfter(copy, endOfTheNode);
+					endOfTheNode = instructions.advance(endOfTheNode);
+
+					copyStats[sourceName].useCount = 0;
+					if (destinationList.test(sourceName) && copyStats[sourceName].isLiveOut)
+						pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+					copyStats[sourceName].isLiveOut = false;
+					copyStats[sourceName].sourceNameToUse = destinationName;
+
+					if (destinationList.test(sourceName))
+						workList.set(sourceName);
+					destinationList.clear(destinationName);
+				}
+
+				destinationListSize = destinationList.getSize();
+				if (destinationListSize != 0) {
+					RegisterName sourceName = RegisterName(destinationList.getOne());
+					RegisterName destinationName;
+
+					if (!copyStats[sourceName].temporaryName) {
+						// Cycle problem.
+						RegisterClassKind classKind = copyStats[sourceName].classKind;
+						destinationName = getName(vrManager.newVirtualRegister(classKind));
+						assert(destinationName < maxNameCount);
+				
+						copyStats[destinationName].classKind = classKind;
+						copyStats[sourceName].temporaryName = destinationName;
+
+						// Insert the copy instruction at the end of the current node.
+						RegisterName from = copyStats[sourceName].sourceNameToUse;
+
+						RegisterID fromID = buildRegisterID(from, classKind);
+						RegisterID toID = buildRegisterID(destinationName, classKind);
+						Instruction& copy = emitter.newCopy(*vrManager.getVirtualRegister(from).getDefiningInstruction()->getPrimitive(), fromID, toID);
+						vrManager.getVirtualRegister(destinationName).setDefiningInstruction(copy);
+						instructions.insertAfter(copy, endOfTheNode);
+						endOfTheNode = instructions.advance(endOfTheNode);
+					} else 
+						destinationName = copyStats[sourceName].temporaryName;
+
+					copyStats[sourceName].useCount = 0;
+					copyStats[sourceName].isLiveOut = false;
+					copyStats[sourceName].sourceNameToUse = destinationName;
+					pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+
+					workList.set(sourceName);
+				}
+			}
+
+			nodeStackPtr->pushedList = pushedList;
+			nodeStackPtr->next = next;
+			nodeStackPtr->limit = limit;
+			++nodeStackPtr;
+			next = dGraph.getSuccessorsBegin(currentNode);
+			limit = dGraph.getSuccessorsEnd(currentNode);
+		}
+	}
+}
+
+#endif // _PHI_NODE_REMOVER_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocator.cpp

@@ -0,0 +1,155 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "RegisterAllocator.h"
+#include "RegisterPressure.h"
+#include "RegisterAllocatorTools.h"
+#include "PhiNodeRemover.h"
+#include "LiveRange.h"
+#include "Liveness.h"
+#include "InterferenceGraph.h"
+#include "LiveRangeGraph.h"
+#include "Coalescing.h"
+#include "Spilling.h"
+#include "Coloring.h"
+#include "Splits.h"
+
+class Pool;
+class ControlGraph;
+class VirtualRegisterManager;
+class InstructionEmitter;
+
+UT_DEFINE_LOG_MODULE(RegAlloc);
+
+void RegisterAllocator::allocateRegisters(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+{
+	// Insert the phi node instructions. We want to do this to have a single defined register per instruction.
+	// If we keep the PhiNode (as a DataNode) and a PhiNode is of DoubleWordKind then we have to execute
+	// some special code for the high word annotation.
+	//
+	RegisterAllocatorTools::insertPhiNodeInstructions(controlGraph, emitter);
+
+	// Perform some tests on the instruction graph.
+	//
+	DEBUG_ONLY(RegisterAllocatorTools::testTheInstructionGraph(controlGraph, vrManager));
+
+	// Replace the phi node instructions by their equivalent copy instructions.
+	//
+	PhiNodeRemover<LowRegisterPressure>::replacePhiNodes(controlGraph, vrManager, emitter);
+
+	// Do the register allocation.
+	//
+	RegisterAllocator registerAllocator(pool, controlGraph, vrManager, emitter);
+	registerAllocator.doGraphColoring();
+}
+
+void RegisterAllocator::doGraphColoring()
+{
+	// Initialize the liverange map.
+	//
+	initLiveRanges();
+
+	// Build the live ranges. We do this to compress the number of RegisterNames 
+	// used in the insterference graph.
+	//
+	LiveRange<LowRegisterPressure>::build(*this);
+
+	// Remove unnecessary copies.
+	//
+	RegisterAllocatorTools::removeUnnecessaryCopies(*this);
+
+	for (Uint8 loop = 0; loop < 10; loop++) {
+
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("********* RegisterAllocator loop %d *********\n", loop));
+
+		while(true) {
+			// Build the interference graph.
+			//
+			iGraph.build();
+
+			// Coalesce the copy instructions.
+			//
+			if (!Coalescing<LowRegisterPressure>::coalesce(*this))
+				break;
+		}
+
+		// Print the interference graph.
+		//
+		DEBUG_LOG_ONLY(iGraph.printPretty(UT_LOG_MODULE(RegAlloc)));
+
+		// Calculate the spill costs.
+		//
+		Spilling<LowRegisterPressure>::calculateSpillCosts(*this);
+		DEBUG_LOG_ONLY(RegisterAllocatorTools::printSpillCosts(*this));
+
+		// Calculate the split costs.
+		//
+		Splits<LowRegisterPressure>::calculateSplitCosts(*this);
+		DEBUG_LOG_ONLY(RegisterAllocatorTools::printSplitCosts(*this));
+
+		// Build the live range graph.
+		//
+		lGraph.build();
+		DEBUG_LOG_ONLY(lGraph.printPretty(UT_LOG_MODULE(RegAlloc)));
+
+		// Color the graph. If it succeeds then we're done with the
+		// register allocation.
+		//
+		if (Coloring<LowRegisterPressure>::color(*this)) {
+			// Write the final colors in the instruction graph.
+			//
+			Coloring<LowRegisterPressure>::finalColoring(*this);
+
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("********** RegisterAllocator  done **********\n"));
+			DEBUG_LOG_ONLY(RegisterAllocatorTools::printInstructions(*this));
+
+			return;
+		}
+
+		// We need to spill some registers.
+		//
+		Spilling<LowRegisterPressure>::insertSpillCode(*this);
+
+		// Insert the split instructions.
+		//
+		Splits<LowRegisterPressure>::insertSplitCode(*this);
+
+		// Update the live ranges.
+		// 
+		// FIX
+	}
+
+#ifdef DEBUG_LOG
+	RegisterAllocatorTools::updateInstructionGraph(*this);
+	RegisterAllocatorTools::printInstructions(*this);
+#endif
+	fprintf(stderr, "!!! Coloring failed after 10 loops !!!\n");
+	abort();
+}
+
+void RegisterAllocator::initLiveRanges()
+{
+	Uint32 count = this->nameCount;
+	RegisterName* name2range = new(pool) RegisterName[nameCount];
+	for (RegisterName r = RegisterName(1); r < count; r = RegisterName(r + 1))
+		name2range[r] = r;
+	this->name2range = name2range;
+	rangeCount = count;
+}

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocator.h

@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_ALLOCATOR_H_
+#define _REGISTER_ALLOCATOR_H_
+
+class Pool;
+class ControlGraph;
+class InstructionEmitter;
+struct SpillCost;
+struct SplitCost;
+
+#include "Liveness.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h" // This should included by Backend.cpp
+#include "InterferenceGraph.h"
+#include "LiveRangeGraph.h"
+
+//template <class RegisterPressure>
+class RegisterAllocator
+{
+public:
+
+	Pool&									pool;			//
+	ControlGraph&							controlGraph;	//
+	VirtualRegisterManager&					vrManager;		//
+	InstructionEmitter&						emitter;		//
+
+	RegisterName*							name2range;		//
+	RegisterName*							color;			//
+	SpillCost*								spillCost;		//
+	SparseSet*								willSpill;		//
+	SplitCost*								splitCost;		//
+	NameLinkedList**						splitAround;	//
+	InterferenceGraph<LowRegisterPressure>	iGraph;			//
+	LiveRangeGraph<LowRegisterPressure>		lGraph;			//
+	LivenessInfo<LowRegisterPressure>		liveness;		//
+	Uint32									nameCount;		//
+	Uint32									rangeCount;		//
+	bool									splitFound;		//
+
+private:
+
+	//
+	//
+	void doGraphColoring();
+
+public:
+
+	//
+	//
+	inline RegisterAllocator(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+
+	//
+	//
+	bool canInterfere(RegisterName /*name1*/, RegisterName /*name2*/) const {return true;}
+
+	//
+	//
+	void initLiveRanges();
+
+	//
+	//
+	static void allocateRegisters(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+};
+
+//
+//
+inline RegisterAllocator::RegisterAllocator(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+	: pool(pool), controlGraph(controlGraph), vrManager(vrManager), emitter(emitter), iGraph(*this), lGraph(*this), nameCount(vrManager.getSize()) {}
+
+#endif // _REGISTER_ALLOCATOR_H_
+

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocatorTools.cpp

@@ -0,0 +1,355 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "RegisterAllocatorTools.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Primitives.h"
+#include "InstructionEmitter.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "Spilling.h"
+#include "Splits.h"
+#include "BitSet.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+#ifdef DEBUG
+void RegisterAllocatorTools::testTheInstructionGraph(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	// Test the declared VirtualRegisters. The register allocator tries to condense the register universe.
+	// Any gap in the VirtualRegister names will be a loss of efficiency !!!!
+
+	Uint32 nameCount = vrManager.getSize();
+	BitSet registerSeen(controlGraph.pool, nameCount);
+
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					registerSeen.set(usePtr->getRegisterName());
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					registerSeen.set(definePtr->getRegisterName());
+		}
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& instruction = phiNodes.get(p);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					registerSeen.set(usePtr->getRegisterName());
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					registerSeen.set(definePtr->getRegisterName());
+		}
+	}
+
+	bool renameRegisters = false;
+	for (BitSet::iterator i = registerSeen.nextZero(0); !registerSeen.done(i); i = registerSeen.nextZero(i)) {
+		renameRegisters = true;
+		fprintf(stderr, 
+				"WARNING: The VirtualRegister vr%d has been allocated during CodeGeneration but\n"
+				"         is never used nor defined by any instruction in the instruction graph\n"
+				"                                  PLEASE FIX                                  \n",
+				i);
+	}
+	if (renameRegisters) {
+		Instruction** definingInstruction = new Instruction*[nameCount];
+		memset(definingInstruction, '\0', nameCount * sizeof(Instruction*));
+		RegisterName* newName = new RegisterName[nameCount];
+		memset(newName, '\0', nameCount * sizeof(RegisterName));
+		RegisterName nextName = RegisterName(1);
+
+		for (Uint32 n = 0; n < nNodes; n++) {
+
+			InstructionList& instructions = nodes[n]->getInstructions();
+			for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+				Instruction& instruction = instructions.get(i);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						usePtr->setRegisterName(newName[name]);
+					}
+
+				InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+				for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+					if (definePtr->isRegister()) {
+						RegisterName name = definePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						definePtr->setRegisterName(newName[name]);
+					}
+			}
+
+			InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+			for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+				Instruction& instruction = phiNodes.get(p);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						usePtr->setRegisterName(newName[name]);
+					}
+
+				InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+				for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+					if (definePtr->isRegister()) {
+						RegisterName name = definePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						definePtr->setRegisterName(newName[name]);
+					}
+			}
+		}
+		
+		vrManager.setSize(nextName);
+
+		for (RegisterName r = RegisterName(1); r < nextName; r = RegisterName(r + 1))
+			vrManager.getVirtualRegister(r).definingInstruction = definingInstruction[r];
+
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("RegisterMap:\n"));
+		for (Uint32 i = 1; i < nameCount; i++)
+			if (newName[i] != 0)
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tvr%d becomes vr%d.\n", i, newName[i]));
+			else
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tvr%d is dead.\n", i));
+
+
+		delete newName;
+		delete definingInstruction;
+	}
+
+}
+#endif // DEBUG
+
+void RegisterAllocatorTools::removeUnnecessaryCopies(RegisterAllocator& registerAllocator)
+{
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i);) {
+			Instruction& instruction = instructions.get(i);
+			i = instructions.advance(i);
+
+			if (instruction.getFlags() & ifCopy) {
+				assert(instruction.getInstructionUseBegin() != instruction.getInstructionUseEnd() && instruction.getInstructionUseBegin()[0].isRegister());
+				assert(instruction.getInstructionDefineBegin() != instruction.getInstructionDefineEnd() && instruction.getInstructionDefineBegin()[0].isRegister());
+				
+				RegisterName source = name2range[instruction.getInstructionUseBegin()[0].getRegisterName()];
+				RegisterName destination = name2range[instruction.getInstructionDefineBegin()[0].getRegisterName()];
+
+				if (source == destination)
+					instruction.remove();
+			}
+		}
+	}
+}
+
+
+void RegisterAllocatorTools::updateInstructionGraph(RegisterAllocator& registerAllocator)
+{
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					usePtr->setRegisterName(name2range[usePtr->getRegisterName()]);
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					definePtr->setRegisterName(name2range[definePtr->getRegisterName()]);
+		}
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& instruction = phiNodes.get(p);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					usePtr->setRegisterName(name2range[usePtr->getRegisterName()]);
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					definePtr->setRegisterName(name2range[definePtr->getRegisterName()]);
+		}
+	}
+}
+
+
+void RegisterAllocatorTools::insertPhiNodeInstructions(ControlGraph& controlGraph, InstructionEmitter& emitter)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		DoublyLinkedList<PhiNode>& phiNodes = node.getPhiNodes();
+
+		if (!phiNodes.empty()) {
+
+			// Set the index of the incoming edges.
+			Uint32 index = 0;
+			const DoublyLinkedList<ControlEdge>& predecessors = node.getPredecessors();
+			for (DoublyLinkedList<ControlEdge>::iterator p = predecessors.begin(); !predecessors.done(p); p = predecessors.advance(p))
+				predecessors.get(p).setIndex(index++);
+
+			// Insert the phi node instruction in the instruction list.
+			for (DoublyLinkedList<PhiNode>::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+				PhiNode& phiNode = phiNodes.get(i);
+				ValueKind kind = phiNode.getKind();
+
+				if (!isStorableKind(kind))
+					continue;
+
+				RegisterClassKind classKind = rckGeneral; // FIX: get class kind from phi node kind.
+				Uint32 nInputs = phiNode.nInputs();
+
+				PhiNodeInstruction& phiNodeInstruction = *new(pool) PhiNodeInstruction(&phiNode, pool, nInputs);
+
+				emitter.defineProducer(phiNode, phiNodeInstruction, 0, classKind, drLow);
+				for (Uint32 whichInput = 0; whichInput < nInputs; whichInput++)
+					emitter.useProducer(phiNode.nthInputVariable(whichInput), phiNodeInstruction, whichInput, classKind, drLow);
+
+				node.addPhiNodeInstruction(phiNodeInstruction);
+
+				if (isDoublewordKind(kind)) {
+					PhiNodeInstruction& phiNodeInstruction = *new(pool) PhiNodeInstruction(&phiNode, pool, nInputs);
+
+					emitter.defineProducer(phiNode, phiNodeInstruction, 0, classKind, drHigh);
+					for (Uint32 whichInput = 0; whichInput < nInputs; whichInput++)
+						emitter.useProducer(phiNode.nthInputVariable(whichInput), phiNodeInstruction, whichInput, classKind, drHigh);
+
+					node.addPhiNodeInstruction(phiNodeInstruction);
+				}
+			}
+		}
+	}
+}
+
+#ifdef DEBUG_LOG
+
+void RegisterAllocatorTools::printSpillCosts(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	SpillCost* cost = registerAllocator.spillCost;
+
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Spill costs:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\trange %d : ", i));
+		if (cost[i].infinite)
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("infinite\n"));
+		else
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%f\n", cost[i].cost));
+	}
+}
+
+void RegisterAllocatorTools::printSplitCosts(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	SplitCost* cost = registerAllocator.splitCost;
+
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Split costs:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\trange %d : loads = %f stores = %f\n", i, cost[i].loads, cost[i].stores));
+	}
+}
+
+void RegisterAllocatorTools::printInstructions(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	ControlNode** nodes = registerAllocator.controlGraph.dfsList;
+	Uint32 nNodes = registerAllocator.controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("N%d:\n", n));
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		if (!phiNodes.empty()) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" PhiNodes:\n", n));
+			for(InstructionList::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+				phiNodes.get(i).printPretty(log);
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+			}
+			if (!instructions.empty())
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" Instructions:\n", n));
+		}
+
+		for(InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			instructions.get(i).printPretty(log);
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+		}
+	}
+}
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocatorTools.h

@@ -0,0 +1,117 @@
+//	-*- mode:C++; tab-width:4; truncate-lines:t -*-
+//
+//           CONFIDENTIAL AND PROPRIETARY SOURCE CODE OF
+//              NETSCAPE COMMUNICATIONS CORPORATION
+// Copyright © 1996, 1997 Netscape Communications Corporation.  All Rights
+// Reserved.  Use of this Source Code is subject to the terms of the
+// applicable license agreement from Netscape Communications Corporation.
+// The copyright notice(s) in this Source Code does not indicate actual or
+// intended publication of this Source Code.
+//
+// $Id: RegisterAllocatorTools.h,v 1.1.2.1 1999-03-02 16:12:05 fur%netscape.com Exp $
+//
+
+#ifndef _REGISTER_ALLOCATOR_TOOLS_H_
+#define _REGISTER_ALLOCATOR_TOOLS_H_
+
+#include "LogModule.h"
+#include "RegisterTypes.h"
+#include <string.h>
+
+class RegisterAllocator;
+class ControlGraph;
+class InstructionEmitter;
+class VirtualRegisterManager;
+
+struct RegisterAllocatorTools
+{
+	//
+	//
+	static void insertPhiNodeInstructions(ControlGraph& controlGraph, InstructionEmitter& emitter);
+
+	//
+	//
+	static void updateInstructionGraph(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void removeUnnecessaryCopies(RegisterAllocator& registerAllocator);
+
+#ifdef DEBUG
+	//
+	//
+	static void testTheInstructionGraph(ControlGraph& controlGraph, VirtualRegisterManager& vrManager);
+#endif // DEBUG
+
+#ifdef DEBUG_LOG
+	//
+	//
+	static void printInstructions(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void printSpillCosts(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void printSplitCosts(RegisterAllocator& registerAllocator);
+#endif // DEBUG_LOG
+};
+
+//
+// FIX: this should go in a class (LookupTable ?)
+//
+
+inline RegisterName findRoot(RegisterName name, RegisterName* table)
+{
+	RegisterName* stack = table;
+	RegisterName* stackPtr = stack;
+
+	RegisterName newName;
+	while((newName = table[name]) != name) {
+		*--stackPtr = name;
+		name = newName;
+	}
+
+	while (stackPtr != stack)
+		table[*stackPtr++] = name;
+
+	return name;
+}
+
+inline void init(RegisterName* table, Uint32 nameCount)
+{
+	for (RegisterName r = RegisterName(0); r < nameCount; r = RegisterName(r + 1))
+		table[r] = r;
+}
+
+inline Uint32 compress(RegisterName* name2range, RegisterName* table, Uint32 nameCount, Uint32 tableSize)
+{
+	RegisterName* liveRange = new RegisterName[tableSize];
+	memset(liveRange, '\0', tableSize * sizeof(RegisterName));
+
+	// Update the lookup table.
+	for (RegisterName r = RegisterName(1); r < tableSize; r = RegisterName(r + 1))
+		findRoot(r, table);
+
+	// Count the liveranges.
+	Uint32 liveRangeCount = 1;
+	for (RegisterName s = RegisterName(1); s < tableSize; s = RegisterName(s + 1))
+		if (table[s] == s)
+			liveRange[s] = RegisterName(liveRangeCount++);
+
+	for (RegisterName t = RegisterName(1); t < nameCount; t = RegisterName(t + 1))
+		name2range[t] = liveRange[table[name2range[t]]];
+
+	return liveRangeCount;
+}
+
+inline double doLog10(Uint32 power)
+{
+	double log = 1.0;
+	while (power--)
+		log *= 10.0;
+	return log;
+}
+
+#endif // _REGISTER_ALLOCATOR_TOOLS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterAssigner.h

@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_ASSIGNER_H_
+#define _REGISTER_ASSIGNER_H_
+
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
+
+class FastBitMatrix;
+
+class RegisterAssigner
+{
+protected:
+  VirtualRegisterManager& vRegManager;
+  
+public:
+  RegisterAssigner(VirtualRegisterManager& vrMan) : vRegManager(vrMan) {}
+  
+  virtual bool assignRegisters(FastBitMatrix& interferenceMatrix) = 0;
+};
+
+#endif /* _REGISTER_ASSIGNER_H_ */

mozilla/ef/Compiler/RegisterAllocator/RegisterClass.h

@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_CLASS_H_
+#define _REGISTER_CLASS_H_
+
+#include "Fundamentals.h"
+#include "RegisterTypes.h"
+
+#endif // _REGISTER_CLASS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterPressure.h

@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_PRESSURE_H_
+#define _REGISTER_PRESSURE_H_
+
+#include "BitSet.h"
+#include "HashSet.h"
+
+struct LowRegisterPressure
+{
+	typedef BitSet Set;
+	static const bool setIsOrdered = true;
+};
+
+struct HighRegisterPressure
+{
+	typedef HashSet Set;
+	static const bool setIsOrdered = false;
+};
+
+#endif // _REGISTER_PRESSURE_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterTypes.h

@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_TYPES_H_
+#define _REGISTER_TYPES_H_
+
+#include "Fundamentals.h"
+
+//------------------------------------------------------------------------------
+// RegisterName -
+//
+
+enum RegisterName {
+	rnInvalid = 0,
+};
+
+//------------------------------------------------------------------------------
+// RegisterClassKind -
+//
+
+enum RegisterClassKind {
+	rckInvalid = 0,
+	rckGeneral,
+	rckStackSlot,
+
+	nRegisterClassKind
+};
+
+//------------------------------------------------------------------------------
+// RegisterID -
+//
+
+enum RegisterID {
+	invalidID = 0
+};
+
+//------------------------------------------------------------------------------
+// RegisterKind -
+//
+
+enum RegisterKind {
+	rkCallerSave = 0,
+	rkCalleeSave,
+};
+
+struct NameLinkedList {
+	RegisterName name;
+	NameLinkedList* next;
+};
+
+#ifdef DEBUG
+
+const registerNameMask = 		0x03ffffff;
+const coloredRegisterMask = 	0x04000000;
+const machineRegisterMask = 	0x08000000;
+const registerClassMask = 		0xf0000000;
+
+const registerNameShift = 		0;
+const coloredRegisterShift = 	26;
+const machineRegisterShift = 	27;
+const registerClassShift = 		28;
+
+#else // DEBUG
+
+const registerNameMask = 		0x0fffffff;
+const registerClassMask = 		0xf0000000;
+
+const registerNameShift = 		0;
+const registerClassShift = 		28;
+
+#endif // DEBUG
+
+
+inline RegisterClassKind getClass(RegisterID registerID) {return RegisterClassKind((registerID & registerClassMask) >> registerClassShift);}
+inline RegisterName getName(RegisterID registerID) {return RegisterName((registerID & registerNameMask) >> registerNameShift);}
+inline void setClass(RegisterID& registerID, RegisterClassKind classKind) {registerID = RegisterID((registerID & ~registerClassMask) | ((classKind << registerClassShift) & registerClassMask));}
+inline void setName(RegisterID& registerID, RegisterName name) {assert((name & ~registerNameMask) == 0); registerID = RegisterID((registerID & ~registerNameMask) | ((name << registerNameShift) & registerNameMask));}
+inline RegisterID buildRegisterID(RegisterName name, RegisterClassKind classKind) {return RegisterID(((classKind << registerClassShift) & registerClassMask) | ((name << registerNameShift) & registerNameMask));}
+
+#ifdef DEBUG
+
+inline bool isMachineRegister(RegisterID rid) {return (rid & machineRegisterMask) != 0;}
+inline void setMachineRegister(RegisterID& rid) {rid = RegisterID(rid | machineRegisterMask);}
+inline bool isColoredRegister(RegisterID rid) {return (rid & coloredRegisterMask) != 0;}
+inline void setColoredRegister(RegisterID& rid) {rid = RegisterID(rid | coloredRegisterMask);}
+
+#endif // DEBUG
+
+#endif // _REGISTER_TYPES_H_

mozilla/ef/Compiler/RegisterAllocator/SSATools.cpp

@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "SSATools.h"
+#include "ControlGraph.h"
+#include "VirtualRegister.h"
+#include "Liveness.h"
+
+void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	if (!controlGraph.hasBackEdges)
+		return;
+
+	Liveness liveness(controlGraph.pool);
+	liveness.buildLivenessAnalysis(controlGraph, vrManager);
+}

mozilla/ef/Compiler/RegisterAllocator/SSATools.h

@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SSA_TOOLS_H_
+#define _SSA_TOOLS_H_
+
+#include "Fundamentals.h"
+
+class ControlGraph;
+class VirtualRegisterManager;
+
+extern void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager);
+
+#endif // _SSA_TOOLS_H_

mozilla/ef/Compiler/RegisterAllocator/SparseSet.cpp

@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "SparseSet.h"
+#include "BitSet.h"
+#include "Pool.h"
+
+#ifdef DEBUG_LOG
+// Print the set.
+//
+void SparseSet::printPretty(LogModuleObject log)
+{
+	Pool pool;
+	BitSet set(pool, universeSize);
+
+	for (Uint32 i = 0; i < count; i++)
+	   set.set(node[i].element);
+
+	set.printPretty(log);
+}
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/SparseSet.h

@@ -0,0 +1,168 @@
+//	-*- mode:C++; tab-width:4; truncate-lines:t -*-
+//
+//           CONFIDENTIAL AND PROPRIETARY SOURCE CODE OF
+//              NETSCAPE COMMUNICATIONS CORPORATION
+// Copyright © 1996, 1997 Netscape Communications Corporation.  All Rights
+// Reserved.  Use of this Source Code is subject to the terms of the
+// applicable license agreement from Netscape Communications Corporation.
+// The copyright notice(s) in this Source Code does not indicate actual or
+// intended publication of this Source Code.
+//
+// $Id: SparseSet.h,v 1.1.2.1 1999-03-02 16:12:07 fur%netscape.com Exp $
+//
+
+#ifndef _SPARSE_SET_H_
+#define _SPARSE_SET_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "LogModule.h"
+#include "BitSet.h"
+
+class SparseSet
+{
+private:
+
+	struct Node {
+		Uint32		element;
+		Uint32		stackIndex;
+	};
+
+	Node*			node;
+	Uint32			count;
+	Uint32			universeSize;
+
+private:
+
+	// No copy constructor.
+	SparseSet(const SparseSet&);
+
+	// Check if the given set's universe is of the same size than this universe.
+	void checkUniverseCompatibility(const SparseSet& set) const {assert(set.universeSize == universeSize);}
+	// Check if pos is valid for this set's universe.
+	void checkMember(Int32 pos) const {assert(pos >=0 && Uint32(pos) < universeSize);}
+
+public:
+
+	SparseSet(Pool& pool, Uint32 universeSize) : universeSize(universeSize) {node = new(pool) Node[universeSize]; clear();}
+
+	// Clear the sparse set.
+	void clear() {count = 0;}
+	// Clear the element at index.
+	inline void clear(Uint32 index);
+	// Set the element at index.
+	inline void set(Uint32 index);
+	// Return true if the element at index is set.
+	inline bool test(Uint32 index) const;
+	// Union with the given sparse set.
+	inline void or(const SparseSet& set);
+	// Intersection with the given sparse set.
+	inline void and(const SparseSet& set);
+	// Difference with the given sparse set.
+	inline void difference(const SparseSet& set);
+	// Copy set.
+	inline SparseSet& operator = (const SparseSet& set);
+	inline SparseSet& operator = (const BitSet& set);
+	// Return true if the sparse sets are identical.
+	friend bool operator == (const SparseSet& set1, const SparseSet& set2);
+	// Return true if the sparse sets are different.
+	friend bool operator != (const SparseSet& set1, const SparseSet& set2);
+
+	// Logical operators.
+	SparseSet& operator |= (const SparseSet& set) {or(set); return *this;}
+	SparseSet& operator &= (const SparseSet& set) {and(set); return *this;}
+	SparseSet& operator -= (const SparseSet& set) {difference(set); return *this;}
+
+	// Iterator to conform with the set API.
+	typedef Int32 iterator;
+	// Return the iterator for the first element of this set.
+	iterator begin() const {return count - 1;}
+	// Return the next iterator.
+	iterator advance(iterator pos) const {return --pos;}
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos < 0;}
+	// Return the element for the given iterator;
+	Uint32 get(iterator pos) const {return node[pos].element;}
+	// Return one element of this set.
+	Uint32 getOne() const {assert(count > 0); return node[0].element;}
+	// Return the size of this set.
+	Uint32 getSize() const {return count;}
+
+#ifdef DEBUG_LOG
+	// Print the set.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+inline void SparseSet::clear(Uint32 element)
+{
+	checkMember(element);
+	Uint32 count = this->count;
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+
+	if ((stackIndex < count) && (node[stackIndex].element == element)) {
+		Uint32 stackTop = node[count - 1].element;
+
+		node[stackIndex].element = stackTop;
+		node[stackTop].stackIndex = stackIndex;
+		this->count = count - 1;
+	}
+}
+
+inline void SparseSet::set(Uint32 element)
+{
+	checkMember(element);
+  	Uint32 count = this->count;
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+
+	if ((stackIndex >= count) || (node[stackIndex].element != element)) {
+		node[count].element = element;
+		node[element].stackIndex = count;
+		this->count = count + 1;
+	}
+}
+
+inline bool SparseSet::test(Uint32 element) const
+{
+	checkMember(element);
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+	return ((stackIndex < count) && (node[stackIndex].element == element));
+}
+
+inline SparseSet& SparseSet::operator = (const SparseSet& set)
+{
+	checkUniverseCompatibility(set);
+	Uint32 sourceCount = set.getSize();
+	Node* node = this->node;
+
+	memcpy(node, set.node, sourceCount * sizeof(Node));
+
+	for (Uint32 i = 0; i < sourceCount; i++) {
+		Uint32 element = node[i].element;
+		node[element].stackIndex = i;
+	}
+
+	count = sourceCount;
+
+	return *this;
+}
+
+
+inline SparseSet& SparseSet::operator = (const BitSet& set)
+{
+	// FIX: there's room for optimization here.
+	assert(universeSize == set.getSize());
+
+	clear();
+	for (Int32 i = set.firstOne(); i != -1; i = set.nextOne(i))
+		this->set(i);
+	return *this;
+}
+
+#endif // _SPARSE_SET_H_

mozilla/ef/Compiler/RegisterAllocator/Spilling.cpp

@@ -0,0 +1,270 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef NEW_LAURENTM_CODE
+#define INCLUDE_EMITTER
+#include "CpuInfo.h"
+#include "Fundamentals.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "InstructionEmitter.h"
+#include "Spilling.h"
+
+
+void Spilling::
+insertSpillCode(ControlNode** dfsList, Uint32 nNodes)
+{
+  PRUint32 nVirtualRegisters = vRegManager.count();
+  FastBitSet currentLive(vRegManager.pool, nVirtualRegisters);
+  FastBitSet usedInThisInstruction(vRegManager.pool, nVirtualRegisters);
+  RegisterFifo grNeedLoad(nVirtualRegisters);
+  RegisterFifo fpNeedLoad(nVirtualRegisters);
+
+  for (PRInt32 n = nNodes - 1; n >= 0; n--)
+	{
+	  PR_ASSERT(grNeedLoad.empty() & fpNeedLoad.empty());
+	  ControlNode& node = *dfsList[n];
+
+	  currentLive = node.liveAtEnd;
+
+	  PRUint32 nGeneralAlive = 0;
+	  PRUint32 nFloatingPointAlive = 0;
+
+	  // Get the number of registers alive at the end of this node.
+	  for (PRInt32 j = currentLive.firstOne(); j != -1; j = currentLive.nextOne(j))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(j);
+		  if (vReg.spillInfo.willSpill)
+			{
+			  currentLive.clear(j);
+			}
+		  else
+			{
+			  switch (vReg.getClass())
+				{
+				case vrcInteger:
+				  nGeneralAlive++;
+				  break;
+				case vrcFloatingPoint:
+				case vrcFixedPoint:
+				  nFloatingPointAlive++;
+				  break;
+				default:
+				  break;
+				}
+			}
+		}
+	  
+//		  if(node.dfsNum == 8) printf("\n________Begin Node %d________\n", node.dfsNum);
+
+		InstructionList& instructions = node.getInstructions();
+	  for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i))
+		{
+		  Instruction&       instruction = instructions.get(i);
+		  InstructionUse*    useBegin    = instruction.getInstructionUseBegin();
+		  InstructionUse*    useEnd      = instruction.getInstructionUseEnd();
+		  InstructionUse*    usePtr;
+		  InstructionDefine* defBegin    = instruction.getInstructionDefineBegin();
+		  InstructionDefine* defEnd      = instruction.getInstructionDefineEnd();
+		  InstructionDefine* defPtr;
+
+//		if(node.dfsNum == 8)  { printf("\n");
+//		instruction.printPretty(stdout);
+//		printf("\n"); }
+
+		  // Handle definitions
+		  for (defPtr = defBegin; defPtr < defEnd; defPtr++)
+			if (defPtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = defPtr->getVirtualRegister();
+				currentLive.clear(vReg.getRegisterIndex());
+				switch (vReg.getClass())
+				  {
+				  case vrcInteger:
+					nGeneralAlive--;
+					break;
+				  case vrcFloatingPoint:
+				  case vrcFixedPoint:
+					nFloatingPointAlive--;
+					break;
+				  default:
+					break;
+				  }
+			  }
+
+		  // Check for deaths
+		  for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+			if (usePtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = usePtr->getVirtualRegister();
+				if (!currentLive.test(vReg.getRegisterIndex()))
+				  // This is the last use of this register.
+				  {
+					currentLive.set(vReg.getRegisterIndex());
+					switch (vReg.getClass())
+					  {
+					  case vrcInteger:
+						nGeneralAlive++;
+						while (/*(nGeneralAlive > NUMBER_OF_GREGISTERS) &&*/ !grNeedLoad.empty())
+						  {
+							PRUint32 toLoad = grNeedLoad.get();
+							currentLive.clear(toLoad);
+							nGeneralAlive--;
+							
+							VirtualRegister& nReg = vRegManager.getVirtualRegister(toLoad);
+							Instruction& lastUsingInstruction = *nReg.spillInfo.lastUsingInstruction;
+							emitter.emitLoadAfter(*lastUsingInstruction.getPrimitive(), lastUsingInstruction.getLinks().prev,
+												  nReg.getAlias(), *nReg.equivalentRegister[vrcStackSlot]);
+							nReg.releaseSelf();
+						  }
+						break;
+					  case vrcFloatingPoint:
+					  case vrcFixedPoint:
+						nFloatingPointAlive++;
+						while (/*(nFloatingPointAlive > NUMBER_OF_FPREGISTERS) &&*/ !fpNeedLoad.empty())
+						  {
+							PRUint32 toLoad = fpNeedLoad.get();
+							currentLive.clear(toLoad);
+							nFloatingPointAlive--;
+							
+							VirtualRegister& nReg = vRegManager.getVirtualRegister(toLoad);
+							Instruction& lastUsingInstruction = *nReg.spillInfo.lastUsingInstruction;
+							emitter.emitLoadAfter(*lastUsingInstruction.getPrimitive(), lastUsingInstruction.getLinks().prev,
+												  nReg.getAlias(), *nReg.equivalentRegister[vrcStackSlot]);
+							nReg.releaseSelf();
+						  }
+						break;
+					  default:
+						break;
+					  }
+				  }
+			  }
+
+		  // Handle uses
+		  for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+			if (usePtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = usePtr->getVirtualRegister();
+				PRUint32 registerIndex = vReg.getRegisterIndex();
+
+				if (vReg.spillInfo.willSpill) {
+#if defined(GENERATE_FOR_X86)
+				  if (!instruction.switchUseToSpill((usePtr - useBegin), *vReg.equivalentRegister[vrcStackSlot]))
+#endif
+					{
+					  switch (vReg.getClass())
+						{
+						case vrcInteger:
+						  if (!grNeedLoad.test(registerIndex))
+							{
+							  grNeedLoad.put(registerIndex);
+							  VirtualRegister& alias = vRegManager.newVirtualRegister(vrcInteger);
+							  if (vReg.isPreColored())
+								  alias.preColorRegister(vReg.getPreColor());
+							  /* if (vReg.hasSpecialInterference) {
+								  alias.specialInterference.sizeTo(NUMBER_OF_REGISTERS);
+								  alias.specialInterference = vReg.specialInterference;
+								  alias.hasSpecialInterference = true;
+							  } */
+							  vReg.setAlias(alias);
+							  vReg.retainSelf();
+							}
+						  break;
+						case vrcFloatingPoint:
+						case vrcFixedPoint:
+						  if (!fpNeedLoad.test(registerIndex))
+							{
+							  fpNeedLoad.put(registerIndex);
+							  VirtualRegister& alias = vRegManager.newVirtualRegister(vReg.getClass());
+							  if (vReg.isPreColored())
+								  alias.preColorRegister(vReg.getPreColor());
+							  /*if (vReg.hasSpecialInterference) {
+								  alias.specialInterference.sizeTo(NUMBER_OF_REGISTERS);
+								  alias.specialInterference = vReg.specialInterference;
+								  alias.hasSpecialInterference = true;
+							  } */
+							  vReg.setAlias(alias);
+							  vReg.retainSelf();
+							}
+						  break;
+						default:
+						  break;
+						}
+					  usePtr->getVirtualRegisterPtr().initialize(vReg.getAlias());
+					  usedInThisInstruction.set(registerIndex);
+					  vReg.spillInfo.lastUsingInstruction = &instruction;
+					}
+				  currentLive.clear(registerIndex);
+				} else { // will not spill
+				  currentLive.set(registerIndex);
+				}
+			  }
+		  
+		  // Handle definitions
+		  for (defPtr = defBegin; defPtr < defEnd; defPtr++)
+			if (defPtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = defPtr->getVirtualRegister();
+				
+				if (vReg.spillInfo.willSpill)
+#if defined(GENERATE_FOR_X86)
+				  if (!instruction.switchDefineToSpill((defPtr - defBegin), *vReg.equivalentRegister[vrcStackSlot]))
+#endif
+					{
+					  if (usedInThisInstruction.test(vReg.getRegisterIndex()))
+						// this virtualRegister was used in this instruction and is also defined. We need to move 
+						// this virtual register to its alias first and then save it to memory.
+						{
+						  emitter.emitStoreAfter(*instruction.getPrimitive(), &instruction.getLinks(), 
+												 vReg.getAlias(), *vReg.equivalentRegister[vrcStackSlot]);
+						  defPtr->getVirtualRegisterPtr().initialize(vReg.getAlias());
+						}
+					  else
+						{
+						  emitter.emitStoreAfter(*instruction.getPrimitive(), &instruction.getLinks(), 
+												 vReg, *vReg.equivalentRegister[vrcStackSlot]);
+						}
+					}
+			  }
+		}
+	  while (!grNeedLoad.empty())
+		{
+		  PRUint32 nl = grNeedLoad.get();
+		  VirtualRegister& nlReg = vRegManager.getVirtualRegister(nl);
+		  Instruction& lastUse = *nlReg.spillInfo.lastUsingInstruction;
+		  
+		  emitter.emitLoadAfter(*lastUse.getPrimitive(), lastUse.getLinks().prev, 
+								nlReg.getAlias(), *nlReg.equivalentRegister[vrcStackSlot]);
+		  nlReg.releaseSelf();
+		}
+	  while (!fpNeedLoad.empty())
+		{
+		  PRUint32 nl = fpNeedLoad.get();
+		  VirtualRegister& nlReg = vRegManager.getVirtualRegister(nl);
+		  Instruction& lastUse = *nlReg.spillInfo.lastUsingInstruction;
+
+		  emitter.emitLoadAfter(*lastUse.getPrimitive(), lastUse.getLinks().prev, 
+								nlReg.getAlias(), *nlReg.equivalentRegister[vrcStackSlot]);
+		  nlReg.releaseSelf();
+		}
+
+//	  if(node.dfsNum == 8) printf("\n________End Node %d________\n", node.dfsNum);
+
+	}
+}
+#endif

mozilla/ef/Compiler/RegisterAllocator/Spilling.h

@@ -0,0 +1,269 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SPILLING_H_
+#define _SPILLING_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "SparseSet.h"
+
+template <class RegisterPressure>
+class Spilling
+{
+private:
+	static void insertStoreAfter(Instruction& instruction, RegisterName name);
+	static void insertLoadBefore(Instruction& instruction, RegisterName name);
+
+public:
+	static void calculateSpillCosts(RegisterAllocator& registerAllocator);
+	static void insertSpillCode(RegisterAllocator& registerAllocator);
+};
+
+struct SpillCost
+{
+	double loads;
+	double stores;
+	double copies;
+	double cost;
+	bool infinite;
+};
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertSpillCode(RegisterAllocator& registerAllocator)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet currentLive(pool, rangeCount);
+	SparseSet needLoad(pool, rangeCount);
+	SparseSet mustSpill(pool, rangeCount);
+	SparseSet& willSpill = *registerAllocator.willSpill;
+	
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+
+		needLoad.clear();
+		currentLive = liveOut[n];
+		mustSpill = currentLive;
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i);) {
+			Instruction& instruction = instructions.get(i);
+			i = instructions.retreat(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			bool foundLiveDefine = false;
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					if (currentLive.test(name2range[definePtr->getRegisterName()])) {
+						foundLiveDefine = true;
+						break;
+					}
+				} else {
+					foundLiveDefine = true;
+					break;
+				}
+			if (defineBegin != defineEnd && !foundLiveDefine) {
+				fprintf(stderr, "!!! Removed instruction because it was only defining unused registers !!!\n");
+				instruction.remove();
+			}
+
+ 			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					RegisterName range = name2range[definePtr->getRegisterName()];
+#ifdef DEBUG
+					if (needLoad.test(range))
+						if (!mustSpill.test(range) && registerAllocator.spillCost[range].infinite && willSpill.test(range)) {
+							fprintf(stderr, "Tried to spill a register with infinite spill cost\n");
+							abort();
+						}
+#endif // DEBUG
+					if (willSpill.test(range))
+						insertStoreAfter(instruction, range);
+
+					needLoad.clear(range);
+				}
+
+			if (instruction.getFlags() & ifCopy)
+				for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName range = name2range[usePtr->getRegisterName()];
+						if (!currentLive.test(range))
+							for (SparseSet::iterator r = needLoad.begin(); !needLoad.done(r); r = needLoad.advance(r)) {
+								RegisterName load = RegisterName(needLoad.get(r));
+								if (willSpill.test(load))
+									insertLoadBefore(instruction, load);
+								mustSpill.set(load);
+							}
+						needLoad.clear();
+					}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+					currentLive.set(range);
+					needLoad.set(range);
+				}
+		}
+
+		for (SparseSet::iterator l = needLoad.begin(); !needLoad.done(l); l = needLoad.advance(l)) {
+			RegisterName load = RegisterName(needLoad.get(l));
+			if (willSpill.test(load))
+				insertLoadBefore(instructions.first(), load);
+		}		
+	}
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertLoadBefore(Instruction& /*instruction*/, RegisterName name)
+{
+	fprintf(stdout, "will insert load for range %d\n", name);
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertStoreAfter(Instruction& /*instruction*/, RegisterName name)
+{
+	fprintf(stdout, "will insert store for range %d\n", name);
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::calculateSpillCosts(RegisterAllocator& registerAllocator)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet live(pool, rangeCount);
+	SparseSet needLoad(pool, rangeCount);
+	SparseSet mustSpill(pool, rangeCount);
+
+	SparseSet alreadyStored(pool, rangeCount); // FIX: should get this from previous spilling.
+
+	SpillCost* cost = new SpillCost[rangeCount];
+	memset(cost, '\0', rangeCount * sizeof(SpillCost));
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+
+		double weight = doLog10(node.loopDepth);
+
+		needLoad.clear();
+		live = liveOut[n];
+		mustSpill = live;
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					RegisterName range = name2range[definePtr->getRegisterName()];
+
+					if (needLoad.test(range))
+						if (!mustSpill.test(range))
+							cost[range].infinite = true;
+
+					if ((false /* !rematerializable(range) */ || !needLoad.test(range)) && !alreadyStored.test(range))
+						cost[range].stores += weight;
+
+					needLoad.clear(range);
+				}
+
+			if (instruction.getFlags() & ifCopy)
+				for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister())
+						if (!live.test(name2range[usePtr->getRegisterName()])) {
+							for (SparseSet::iterator l = needLoad.begin(); !needLoad.done(l); l = needLoad.advance(l)) {
+								Uint32 range = needLoad.get(l);
+								cost[range].loads += weight;
+								mustSpill.set(range);
+							}
+							needLoad.clear();
+						}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					live.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+
+					live.set(range);
+					needLoad.set(range);
+				}
+
+			if (instruction.getFlags() & ifCopy) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				assert(defineBegin != defineEnd && defineBegin[0].isRegister());
+
+				RegisterName source = name2range[useBegin[0].getRegisterName()];
+				RegisterName destination = name2range[defineBegin[0].getRegisterName()];
+
+				cost[source].copies += weight;
+				cost[destination].copies += weight;
+			}			
+		}
+
+		for (SparseSet::iterator s = needLoad.begin(); !needLoad.done(s); s = needLoad.advance(s))
+			cost[needLoad.get(s)].loads += weight;
+	}
+	
+	for (Uint32 r = 0; r < rangeCount; r++) {
+		SpillCost& c = cost[r];
+		c.cost = 2 * (c.loads + c.stores) - c.copies;
+	}
+
+	registerAllocator.spillCost = cost;
+}
+
+#endif // _SPILLING_H_

mozilla/ef/Compiler/RegisterAllocator/Splits.h

@@ -0,0 +1,239 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SPLITS_H_
+#define _SPLITS_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+template <class RegisterPressure>
+struct Splits
+{
+	static void calculateSplitCosts(RegisterAllocator& registerAllocator);
+	static bool findSplit(RegisterAllocator& registerAllocator, RegisterName* color, RegisterName range);
+	static void insertSplitCode(RegisterAllocator& registerAllocator);
+};
+
+struct SplitCost
+{
+	double loads;
+	double stores;
+};
+
+template <class RegisterPressure>
+void Splits<RegisterPressure>::insertSplitCode(RegisterAllocator& /*registerAllocator*/)
+{
+	// FIX
+}
+
+template <class RegisterPressure>
+bool Splits<RegisterPressure>::findSplit(RegisterAllocator& registerAllocator, RegisterName* color, RegisterName range)
+{
+	Pool& pool = registerAllocator.pool;
+	NameLinkedList** neighborsWithColor = new(pool) NameLinkedList*[6]; // FIX
+	memset(neighborsWithColor, '\0', 6 * sizeof(NameLinkedList*));
+
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+
+	for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+		for (Int32 i = vector->count - 1; i >=0; --i) {
+			RegisterName neighbor = vector->neighbors[i];
+			RegisterName c = color[neighbor];
+
+			if (c < 6) { // FIX
+				NameLinkedList* node = new(pool) NameLinkedList();
+				node->name = neighbor;
+				node->next = neighborsWithColor[c];
+				neighborsWithColor[c] = node;
+			}
+		}
+
+	bool splitAroundName = true;
+
+	LiveRangeGraph<RegisterPressure>& lGraph = registerAllocator.lGraph;
+	RegisterName bestColor = RegisterName(6); // FIX
+	double bestCost = registerAllocator.spillCost[range].cost;
+	SplitCost* splitCost = registerAllocator.splitCost;
+
+	for (RegisterName i = RegisterName(0); i < 6; i = RegisterName(i + 1)) { // FIX
+
+		double splitAroundNameCost = 0.0;
+		bool canSplitAroundName = true;
+
+		SplitCost& sCost = splitCost[range];
+		double addedCost = 2.0 * (sCost.stores + sCost.loads);
+
+		for (NameLinkedList* node = neighborsWithColor[i]; node != NULL; node = node->next) {
+			RegisterName neighbor = node->name;
+			if (lGraph.haveEdge(neighbor, range)) {
+				canSplitAroundName = false;
+				break;
+			} else
+				splitAroundNameCost += addedCost;
+		}
+		if (canSplitAroundName && splitAroundNameCost < bestCost) {
+			bestCost = splitAroundNameCost;
+			bestColor = i;
+			splitAroundName = true;
+		}
+
+		double splitAroundColorCost = 0.0;
+		bool canSplitAroundColor = true;
+
+		for (NameLinkedList* node = neighborsWithColor[i]; node != NULL; node = node->next) {
+			RegisterName neighbor = node->name;
+			if (lGraph.haveEdge(range, neighbor)) {
+				canSplitAroundColor = false;
+				break;
+			} else {
+				SplitCost& sCost = splitCost[neighbor];
+				double addedCost = 2.0 * (sCost.stores + sCost.loads);
+				splitAroundColorCost += addedCost;
+			}
+		}
+		if (canSplitAroundColor && splitAroundColorCost < bestCost) {
+			bestCost = splitAroundColorCost;
+			bestColor = i;
+			splitAroundName = false;
+		}
+ 	}
+	if (bestColor < RegisterName(6)) {
+		color[range] = bestColor;
+		registerAllocator.splitFound = true;
+
+		NameLinkedList** splitAround = registerAllocator.splitAround;
+
+		if (splitAroundName)
+			for (NameLinkedList* node = neighborsWithColor[bestColor]; node != NULL; node = node->next) {
+				NameLinkedList* newNode = new(pool) NameLinkedList();
+				newNode->name = node->name;
+				newNode->next = splitAround[range];
+				splitAround[range] = newNode;
+			}
+		else
+			for (NameLinkedList* node = neighborsWithColor[bestColor]; node != NULL; node = node->next) {
+				NameLinkedList* newNode = new(pool) NameLinkedList();
+				RegisterName neighbor = node->name;
+				newNode->name = range;
+				newNode->next = splitAround[neighbor];
+				splitAround[neighbor] = newNode;
+			}
+
+		trespass("Found a split");
+		return true;
+	}
+
+	return false;
+}
+
+template <class RegisterPressure>
+void Splits<RegisterPressure>::calculateSplitCosts(RegisterAllocator& registerAllocator)
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	SplitCost* splitCost = new(pool) SplitCost[rangeCount];
+	memset(splitCost, '\0', rangeCount * sizeof(SplitCost));
+
+	SparseSet live(pool, rangeCount);
+	RegisterPressure::Set* liveIn = registerAllocator.liveness.liveIn;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		double weight = doLog10(node.loopDepth);
+
+		live = liveOut[n];
+
+		ControlEdge* successorsEnd = node.getSuccessorsEnd();
+		for (ControlEdge* successorsPtr = node.getSuccessorsBegin(); successorsPtr < successorsEnd; successorsPtr++) {
+			ControlNode& successor = successorsPtr->getTarget();
+
+			if (successor.getControlKind() != ckEnd) {
+				RegisterPressure::Set& successorLiveIn = liveIn[successor.dfsNum];
+
+				for (SparseSet::iterator i = live.begin(); !live.done(i); i = live.advance(i)) {
+					RegisterName name = RegisterName(live.get(i));
+					if (!successorLiveIn.test(name))
+						splitCost[name].loads += doLog10(successor.loopDepth);
+				}
+			}
+		}
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					splitCost[name2range[definePtr->getRegisterName()]].stores += weight;
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+					if (!live.test(range)) {
+						if (&instruction != &instructions.last())
+							splitCost[range].loads += weight;
+						else {
+							ControlEdge* successorsEnd = node.getSuccessorsEnd();
+							for (ControlEdge* successorsPtr = node.getSuccessorsBegin(); successorsPtr < successorsEnd; successorsPtr++)
+								splitCost[range].loads += doLog10(successorsPtr->getTarget().loopDepth);
+						}
+					}
+				}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					live.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					live.set(name2range[usePtr->getRegisterName()]);
+		}
+	}
+
+	NameLinkedList** splitAround = new(pool) NameLinkedList*[rangeCount];
+	memset(splitAround, '\0', rangeCount * sizeof(NameLinkedList*));
+	registerAllocator.splitAround = splitAround;
+
+	registerAllocator.splitCost = splitCost;
+	registerAllocator.splitFound = false;
+}
+
+#endif // _SPLITS_H_

mozilla/ef/Compiler/RegisterAllocator/Timer.cpp

@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "HashTable.h"
+#include "Timer.h"
+#include "Pool.h"
+
+static Pool pool;											// Pool for the Timer class.
+static HashTable<TimerEntry*> timerEntries(pool);			// Timers hashtable.
+
+const nTimersInABlock = 128;								// Number of timers in a block.
+static PRTime *timers = new(pool) PRTime[nTimersInABlock];	// A block of timers.
+static Uint8 nextTimer = 0;									// nextAvailableTimer.
+
+//
+// Calibrate the call to PR_Now().
+//
+static PRTime calibrate()
+{
+	PRTime t = PR_Now();
+	PRTime& a = *new(pool) PRTime();
+
+	// Call 10 times the PR_Now() function.
+	a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); 
+	a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); 
+	t = (PR_Now() - t + 9) / 10;
+
+	return t;
+}
+
+static PRTime adjust = calibrate();
+
+//
+// Return the named timer..
+//
+TimerEntry& Timer::getTimerEntry(const char* name)
+{
+	if (!timerEntries.exists(name)) {
+		TimerEntry* newEntry = new(pool) TimerEntry();
+		newEntry->accumulator = 0;
+		newEntry->running = false;
+		timerEntries.add(name, newEntry);
+	}
+
+	return *timerEntries[name];
+}
+
+//
+// Return a reference to a new timer.
+//
+PRTime& Timer::getNewTimer()
+{
+	if (nextTimer >= nTimersInABlock) {
+		timers = new(pool) PRTime[nTimersInABlock];
+		nextTimer = 0;
+	}
+	return timers[nextTimer++];
+}
+
+static Uint32 timersAreFrozen = 0;
+
+//
+// Start the named timer.
+//
+void Timer::start(const char* name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+	PR_ASSERT(!timer.running);
+
+	timer.accumulator = 0;
+	timer.running = true;
+	timer.done = false;
+
+	unfreezeTimers();
+}
+
+//
+// Stop the named timer.
+//
+void Timer::stop(const char* name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+	PR_ASSERT(timer.running);
+	timer.running = false;
+	timer.done = true;
+
+	unfreezeTimers();
+}
+
+//
+// Freeze all the running timers.
+//
+void Timer::freezeTimers()
+{
+	PRTime when = PR_Now() - adjust;
+
+	if (timersAreFrozen == 0) {
+		Vector<TimerEntry*> entries = timerEntries;
+		Uint32 count = entries.size();
+
+		for (Uint32 i = 0; i < count; i++) {
+			TimerEntry& entry = *entries[i];
+			if (entry.running) {
+				entry.accumulator += (when - *entry.startTime);
+			}
+		}
+	}
+	timersAreFrozen++;
+}
+ 
+//
+// Unfreeze all the running timers.
+//
+void Timer::unfreezeTimers()
+{
+	PR_ASSERT(timersAreFrozen != 0);
+	timersAreFrozen--;
+
+	if (timersAreFrozen == 0) {
+		Vector<TimerEntry *> entries = timerEntries;
+		Uint32 count = entries.size();
+		
+		PRTime& newStart = getNewTimer();
+		
+		for (Uint32 i = 0; i < count; i++) {
+			TimerEntry& entry = *entries[i];
+			if (entry.running) {
+				entry.startTime = &newStart;
+			}
+		}
+		
+		newStart = PR_Now();
+	}
+}
+
+//
+// Print the named timer in the file f.
+//
+void Timer::print(FILE* f, const char *name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+  
+	PR_ASSERT(timer.done);
+	PRTime elapsed = timer.accumulator;
+
+	if (elapsed >> 32) {
+		fprintf(f, "[timer %s out of range]\n", name);
+	} else {
+		fprintf(f, "[%dus in %s]\n", Uint32(elapsed), name);
+	}
+	fflush(f);
+
+	unfreezeTimers();
+}
+

mozilla/ef/Compiler/RegisterAllocator/Timer.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _TIMER_H_
+#define _TIMER_H_
+
+#include "Fundamentals.h"
+#include "HashTable.h"
+#include "prtime.h"
+
+//
+// Naming convention:
+//  As the class Timer contains only static methods, the timer's name should start with the 
+//  module name. Otherwise starting 2 timers with the same name will assert.
+//
+
+#ifndef NO_TIMER
+
+struct TimerEntry
+{
+	PRTime *startTime;					// Current time when we start the timer.
+	PRTime accumulator;					// Time spent in this timer.
+	bool running;						// True if the timer is running.
+	bool done;							// True if the timer was running and was stopped. 
+};
+
+class Timer
+{
+private:
+
+	// Return the named timer.
+	static TimerEntry& getTimerEntry(const char* name);
+	// Return a reference to a new Timer.
+	static PRTime& getNewTimer();
+
+public:
+
+	// Start the timer.
+	static void start(const char* name);
+	// Stop the timer.
+	static void stop(const char* name);
+	// Freeze all the running timers.
+	static void freezeTimers();
+	// Unfreeze all the running timers.
+	static void unfreezeTimers();
+	// Print the timer.
+	static void print(FILE* f, const char *name);
+};
+
+inline void startTimer(const char* name) 		{Timer::start(name);}
+inline void stopTimer(const char* name) 		{Timer::stop(name); Timer::print(stdout, name);}
+#define START_TIMER_SAFE						Timer::freezeTimers();
+#define END_TIMER_SAFE							Timer::unfreezeTimers();
+#define TIMER_SAFE(x)							START_TIMER_SAFE x; END_TIMER_SAFE
+
+#else /* NO_TIMER */
+
+inline void startTimer(const char* /*name*/) 	{} 
+inline void stopTimer(const char* /*name*/) 	{} 
+#define START_TIMER_SAFE
+#define END_TIMER_SAFE
+#define TIMER_SAFE(x)							x;
+
+#endif /* NO_TIMER */
+#endif /* _TIMER_H_ */

mozilla/ef/Compiler/RegisterAllocator/VirtualRegister.cpp

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
+#include "Instruction.h"
+
+//------------------------------------------------------------------------------
+// VirtualRegister -
+
+#ifdef MANUAL_TEMPLATES
+template class IndexedPool<VirtualRegister>;
+#endif
+
+// Set the defining instruction.
+//
+void VirtualRegister::setDefiningInstruction(Instruction& instruction)
+{
+	if (definingInstruction != NULL) {
+		if ((instruction.getFlags() & ifCopy) && (definingInstruction->getFlags() & ifPhiNode))
+			return;
+	}
+	definingInstruction = &instruction;
+}
+

mozilla/ef/Compiler/RegisterAllocator/VirtualRegister.h

@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _VIRTUAL_REGISTER_H_
+#define _VIRTUAL_REGISTER_H_
+
+#include "Fundamentals.h"
+#include "IndexedPool.h"
+#include <string.h>
+
+#include "RegisterTypes.h"
+#include "RegisterClass.h"
+
+
+//------------------------------------------------------------------------------
+// VirtualRegister - 24b
+
+class Instruction;
+
+class VirtualRegister : public IndexedObject<VirtualRegister>
+{
+public:
+
+	Instruction*					definingInstruction;	// Instruction defining this VR.
+
+	// Initialize a VR of the given classKind.
+	VirtualRegister(RegisterClassKind /*classKind*/) : definingInstruction(NULL) {}
+
+	// Return the defining instruction for this VR.
+	Instruction* getDefiningInstruction() const {return definingInstruction;}
+	// Set the defining instruction.
+	void setDefiningInstruction(Instruction& insn);
+};
+
+// Return true if the VirtualRegisters are equals. The only way 2 VRs can be equal is if
+// they have the same index. If they have the same index then they are at the same
+// address in the indexed pool.
+//
+inline bool operator == (const VirtualRegister& regA, const VirtualRegister& regB) {return &regA == &regB;}
+
+//------------------------------------------------------------------------------
+// VirtualRegisterManager -
+
+struct PreColoredRegister
+{
+	RegisterID id;
+	RegisterName color;
+};
+
+class VirtualRegisterManager
+{
+private:
+
+	IndexedPool<VirtualRegister> registerPool;
+	PreColoredRegister machineRegister[6];
+
+public:
+	VirtualRegisterManager()
+		{
+			for (Uint32 i = 0; i < 6; i++)
+				machineRegister[i].id = invalidID;
+		}
+
+	// Return the VirtualRegister at the given index.
+	VirtualRegister& getVirtualRegister(RegisterName name) const {return registerPool.get(name);}
+
+	// Return a new VirtualRegister.
+	RegisterID newVirtualRegister(RegisterClassKind classKind)
+		{
+			VirtualRegister& vReg = *new(registerPool) VirtualRegister(classKind);
+			RegisterID rid;
+
+			setName(rid, RegisterName(vReg.getIndex()));
+			setClass(rid, classKind);
+			return rid;
+		}
+
+	RegisterID newMachineRegister(RegisterName name, RegisterClassKind classKind)
+		{
+			RegisterID rid = machineRegister[name].id;
+
+			if (rid == invalidID) {
+				rid = newVirtualRegister(classKind);
+				DEBUG_ONLY(setMachineRegister(rid));
+				machineRegister[name].id = rid;
+				machineRegister[name].color = name;
+			}
+
+			return rid;
+		}
+
+	PreColoredRegister* getMachineRegistersBegin() const {return (PreColoredRegister*) machineRegister;} // FIX
+	PreColoredRegister* getMachineRegistersEnd() const {return (PreColoredRegister*) &machineRegister[6];} // FIX
+
+	// Return the VirtualRegister universe size.
+	Uint32 getSize() {return registerPool.getSize();}
+
+	void setSize(Uint32 size) {registerPool.setSize(size);}
+};
+
+#endif // _VIRTUAL_REGISTER_H_

mozilla/js/src/MANIFEST

@@ -1,47 +0,0 @@
-# This file is required for the Mac client mozilla build.
-# This is a list of local files which get copied to the mozilla:dist directory
-#
-
-js.msg
-jsapi.h
-jsarena.h
-jspubtd.h
-jsarray.h
-jsatom.h
-jsbool.h
-jsclist.h
-jscntxt.h
-jscompat.h
-jsconfig.h
-jscpucfg.h
-jsdate.h
-jsdbgapi.h
-jsdtoa.h
-jsemit.h
-jsfun.h
-jsgc.h
-jshash.h
-jsinterp.h
-jslock.h
-jslong.h
-jsmath.h
-jsnum.h
-jsobj.h
-jsopcode.tbl
-jsopcode.h
-jsosdep.h
-jsotypes.h
-jsparse.h
-jsprf.h
-jsprvtd.h
-jspubtd.h
-jsregexp.h
-jsscan.h
-jsscope.h
-jsscript.h
-jsstr.h
-jstypes.h
-jsutil.h
-jsxdrapi.h
-
-

mozilla/js/src/Makefile.in

@@ -1,324 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, released
-# March 31, 1998.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU Public License (the "GPL"), in which case the
-# provisions of the GPL are applicable instead of those above.
-# If you wish to allow use of your version of this file only
-# under the terms of the GPL and not to allow others to use your
-# version of this file under the NPL, indicate your decision by
-# deleting the provisions above and replace them with the notice
-# and other provisions required by the GPL.  If you do not delete
-# the provisions above, a recipient may use your version of this
-# file under either the NPL or the GPL.
-#
-
-DEPTH		= ../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= js
-LIBRARY_NAME	= mozjs
-
-DIRS		= $(OJIDIR) fdlibm xpconnect
-
-CSRCS		= \
-		jsapi.c \
-		jsarena.c \
-		jsarray.c \
-		jsatom.c \
-		jsbool.c \
-		jscntxt.c \
-		jsdate.c \
-		jsdbgapi.c \
-		jsdtoa.c \
-		jsemit.c \
-		jsexn.c \
-		jsfun.c \
-		jsgc.c \
-		jshash.c \
-		jsinterp.c \
-		jslock.c \
-		jslog2.c \
-		jslong.c \
-		jsmath.c \
-		jsnum.c \
-		jsobj.c \
-		jsopcode.c \
-		jsparse.c \
-		jsprf.c \
-		jsregexp.c \
-		jsscan.c \
-		jsscope.c \
-		jsscript.c \
-		jsstr.c \
-		jsutil.c \
-		jsxdrapi.c \
-		prmjtime.c \
-		$(NULL)
-
-EXPORTS		= \
-		js.msg \
-		jsapi.h \
-		jsarray.h \
-		jsarena.h \
-		jsatom.h \
-		jsbit.h \
-		jsbool.h \
-		jsclist.h \
-		jscntxt.h \
-		jscompat.h \
-		jsconfig.h \
-		jsdate.h \
-		jsdbgapi.h \
-		jsemit.h \
-		jsfun.h \
-		jsgc.h \
-		jshash.h \
-		jsinterp.h \
-		jslock.h \
-		jslong.h \
-		jsmath.h \
-		jsnum.h \
-		jsobj.h \
-		jsopcode.tbl \
-		jsopcode.h \
-		jsosdep.h \
-		jsotypes.h \
-		jsparse.h \
-		jsprf.h \
-		jsprvtd.h \
-		jspubtd.h \
-		jsregexp.h \
-		jsscan.h \
-		jsscope.h \
-		jsscript.h \
-		jsstr.h \
-		jstypes.h \
-		jsutil.h \
-		jsxdrapi.h \
-		jsstddef.h \
-		$(NULL)
-
-EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
-
-FDLIBM_LIBRARY	= fdlibm/libfdm.a
-JSMATH_PRELINK	= jsmathtemp.o
-JS_SAFE_ARENA	= 1
-
-ifdef MOZ_OJI
-OJIDIR		= liveconnect
-endif
-
-DASH_R		= -r
-
-include $(topsrcdir)/config/config.mk
-
-ifeq ($(OS_ARCH),OS2)
-ifndef XCFLAGS
-OS2_IMPLIB	= 1
-LIBRARY		= js$(MOZ_BITS)$(VERSION_NUMBER).$(LIB_SUFFIX)
-DEF_FILE	= jsos2$(VERSION_NUMBER).def
-EXTRA_LIBS	= $(NSPR_LIBS) $(LIBNSJAVA)
-else
-EXTRA_LIBS	= $(NSPR_LIBS) $(LIBNSJAVA) libjs.lib
-endif
-OS_CFLAGS	+= -tm-
-endif
-
-EXTRA_DSO_LDOPTS += $(MOZ_COMPONENT_NSPR_LIBS)
-
-# When using gcc the assembly is inlined in the C-file (see jslock.c)
-ifdef NS_USE_NATIVE
-ASFILES		= $(notdir $(wildcard $(srcdir)/*_$(OS_ARCH).s))
-endif
-
-ifndef BUILD_OPT
-MOCHAFILE	= 1
-endif
-
-ifndef NSBUILDROOT
-JSJAVA_STUBHEADERS = \
-		-I$(topsrcdir)/sun-java/include/_gen \
-		-I$(topsrcdir)/sun-java/netscape/javascript/_jri \
-		-I$(topsrcdir)/sun-java/netscape/security/_jri
-else
-JSJAVA_STUBHEADERS = -I$(JRI_GEN_DIR) -I$(JDK_GEN_DIR)
-endif
-
-JSJAVA_CFLAGS	= \
-		-I$(topsrcdir)/sun-java/md-include \
-		-I$(topsrcdir)/sun-java/include \
-		$(JSJAVA_STUBHEADERS)
-
-include $(topsrcdir)/config/rules.mk
-
-DEFINES		+= -DEXPORT_JS_API
-
-INCLUDES	+= -I$(srcdir)
-
-GARBAGE		+= $(JSMATH_PRELINK) jscpucfg.o jsautocfg.h jsautocfg.tmp jscpucfg
-
-TARGETS		+= jscpucfg
-
-ifdef JS_SAFE_ARENA
-DEFINES		+= -DJS_USE_SAFE_ARENA
-endif
-
-ifdef JS_THREADSAFE
-DEFINES		+= -DJS_THREADSAFE
-endif
-
-ifdef JS_NO_THIN_LOCKS
-DEFINES		+= -DJS_USE_ONLY_NSPR_LOCKS
-endif
-
-ifdef JS_VERSION
-DEFINES		+= -DJS_VERSION=$(JS_VERSION)
-endif
-
-ifneq ($(findstring -L,$(NSPR_LIBS)),)
-NSPR_STATIC_PATH = $(subst -L,,$(findstring -L,$(NSPR_LIBS)))
-else
-NSPR_STATIC_PATH = $(DIST)/lib
-endif
-
-LDFLAGS		= $(pathsubst -l%,$(NSPR_STATIC_PATH)/%.a,$(NSPR_LIBS))
-
-ifneq ($(OS_ARCH),BeOS)
-LDFLAGS		+= -lm
-endif
-
-ifeq ($(OS_ARCH),FreeBSD)
-LDFLAGS		+= -pthread
-endif
-ifeq ($(OS_ARCH),IRIX)
-ifneq ($(basename $(OS_RELEASE)),5)
-LDFLAGS		+= -n32
-DASH_R		+= -n32
-endif
-endif
-ifeq ($(OS_ARCH),Linux)
-LDFLAGS		+= -ldl
-endif
-ifeq ($(OS_ARCH),OSF1)
-LDFLAGS		+= -lc_r
-endif
-ifeq ($(OS_ARCH),SunOS)
-ifeq ($(CPU_ARCH),sparc)
-
-ifndef JS_NO_ULTRA
-ULTRA_OPTIONS	:= -xarch=v8plus,-DULTRA_SPARC
-ULTRA_OPTIONSCC	:= -DULTRA_SPARC
-else
-ULTRA_OPTIONS	:= -xarch=v8
-ULTRA_OPTIONSCC	:=
-endif
-
-ifeq ($(shell uname -m),sun4u)
-ASFLAGS		+= -Wa,$(ULTRA_OPTIONS),-P,-L,-D_ASM,-D__STDC__=0 $(ULTRA_OPTIONSCC)
-else
-ASFLAGS		+= -Wa,-xarch=v8,-P,-L,-D_ASM,-D__STDC__=0
-endif
-
-endif
-ifeq ($(OS_RELEASE),4.1)
-LDFLAGS		+= -ldl -lnsl
-else
-LDFLAGS		+= -lposix4 -ldl -lnsl -lsocket
-endif
-endif
-
-ifeq ($(OS_ARCH),QNX)
-ifneq ($(OS_TARGET),NTO)
-# Don't use wildcard here, because we only want this resolved at link time.
-OBJS		+= fdlibm/*.o
-endif
-endif
-
-# special rule for jsmath.o since we want to incrementally link
-# against fdlibm to pull in only what is needed
-jsmath.o: $(FDLIBM_LIBRARY) $(JSMATH_PRELINK)
-ifeq ($(OS_ARCH),QNX)
-ifneq ($(OS_TARGET),NTO)
-	@cp $(JSMATH_PRELINK) $@
-else
-	$(LD) $(DASH_R) -o $@ $(JSMATH_PRELINK) $(FDLIBM_LIBRARY)
-endif
-else
-	$(LD) $(DASH_R) -o $@ $(JSMATH_PRELINK) $(FDLIBM_LIBRARY)
-endif
-
-$(JSMATH_PRELINK): jsmath.c
-ifneq (,$(filter OS2 WINNT,$(OS_ARCH)))
-	$(CC) -Fo$@ -c $(CFLAGS) $<
-else
-	$(CC) -o $@ -c $(COMPILE_CFLAGS) $<
-endif
-
-# An AIX Optimization bug causes PR_dtoa() & JS_dtoa to produce wrong result.
-# This suppresses optimization for this single compilation unit.
-ifeq ($(OS_ARCH),AIX)
-jsdtoa.o: jsdtoa.c
-	$(CC) -o $@ -c $(filter-out -O, $(COMPILE_CFLAGS)) $<
-endif
-
-$(FDLIBM_LIBRARY):
-	@set -e; set $(EXIT_ON_ERROR); \
-	oldDir=`pwd`; \
-	echo "cd $(@D); $(MAKE) $(@F)"; \
-	cd $(@D); $(MAKE) $(@F); cd $$oldDir; \
-	set +e
-
-jsopcode.h jsopcode.c: jsopcode.tbl
-
-jsautocfg.h: jscpucfg
-	@rm -f $@ jsautocfg.tmp
-	./jscpucfg > jsautocfg.tmp
-	mv jsautocfg.tmp $@
-
-# jscpucfg is a strange target
-# Needs to be built with the host compiler but needs to include
-# the mdcpucfg for the target so it needs the appropriate target defines
-ifdef HOST_NSPR_MDCPUCFG
-HOST_CC := $(HOST_CC) -DMDCPUCFG=$(TARGET_NSPR_MDCPUCFG)
-endif
-
-ifeq ($(OS_ARCH),QNX)
-ifneq ($(OS_TARGET),NTO)
-# QNX's compiler apparently can't build a binary directly from a source file.
-jscpucfg.o: jscpucfg.c
-	$(HOST_CC) $(HOST_CFLAGS) -c $(DEFINES) $(NSPR_CFLAGS) -o $@ $<
-
-jscpucfg: jscpucfg.o
-	$(HOST_CC) $(HOST_CFLAGS) $(DEFINES) -o $@ $<
-endif
-else
-jscpucfg: jscpucfg.c
-	$(HOST_CC) $(HOST_CFLAGS) $(DEFINES) $(NSPR_CFLAGS) -o $@ $<
-endif
-
-export:: jsautocfg.h
-	$(INSTALL) -m 444 $< $(PUBLIC)
-

mozilla/js/src/Makefile.ref

@@ -1,294 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, released
-# March 31, 1998.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-# Alternatively, the contents of this file may be used under the
-# terms of the GNU Public License (the "GPL"), in which case the
-# provisions of the GPL are applicable instead of those above.
-# If you wish to allow use of your version of this file only
-# under the terms of the GPL and not to allow others to use your
-# version of this file under the NPL, indicate your decision by
-# deleting the provisions above and replace them with the notice
-# and other provisions required by the GPL.  If you do not delete
-# the provisions above, a recipient may use your version of this
-# file under either the NPL or the GPL.
-
-#
-# JSRef GNUmake makefile.
-#
-
-DEPTH = .
-
-include config.mk
-
-#NS_USE_NATIVE = 1
-
-ifdef USE_MSVC
-OTHER_LIBS += fdlibm/$(OBJDIR)/fdlibm.lib
-else
-OTHER_LIBS += -Lfdlibm/$(OBJDIR) -lfdm
-endif
-
-ifdef JS_THREADSAFE
-DEFINES += -DJS_THREADSAFE
-INCLUDES += -I../../dist/$(OBJDIR)/include
-ifdef USE_MSVC
-OTHER_LIBS += ../../dist/$(OBJDIR)/lib/libnspr3.lib
-else
-OTHER_LIBS += -L../../dist/$(OBJDIR)/lib -lnspr3
-endif
-endif
-
-ifdef JS_NO_THIN_LOCKS
-DEFINES += -DJS_USE_ONLY_NSPR_LOCKS
-endif
-
-ifdef JS_HAS_FILE_OBJECT
-DEFINES += -DJS_HAS_FILE_OBJECT
-endif
-
-#
-# XCFLAGS may be set in the environment or on the gmake command line
-#
-CFLAGS          += $(OPTIMIZER) $(OS_CFLAGS) $(DEFINES) $(INCLUDES) $(XCFLAGS)
-LDFLAGS		= -lm $(XLDFLAGS)
-
-#
-# Ask perl what flags it was built with, so we can build js with similar flags
-# and link properly.  Viva gmake.
-#
-ifdef JS_PERLCONNECT
-DEFINES += -DPERLCONNECT
-
-PERLCFLAGS := $(shell perl -MExtUtils::Embed -e ccopts)
-PERLLDFLAGS := $(shell perl -MExtUtils::Embed -e ldopts)
-
-CFLAGS += $(PERLCFLAGS)
-LDFLAGS += $(PERLLDFLAGS)
-endif
-
-#
-#	Server-related changes :
-#
-ifdef NES40 
-DEFINES += -DNES40 
-endif 
-
-#
-# Line editing support.
-#
-ifdef JS_READLINE
-DEFINES += -DEDITLINE
-PROG_LIBS += -lreadline
-else
-ifdef JS_EDITLINE
-PREDIRS += editline
-DEFINES += -DEDITLINE
-PROG_LIBS += -Leditline/$(OBJDIR) -ledit
-endif
-endif
-
-# For purify
-PURE_CFLAGS     = -DXP_UNIX $(OPTIMIZER) $(PURE_OS_CFLAGS) $(DEFINES) \
-                  $(INCLUDES) $(XCFLAGS)
-
-#
-# JS file lists
-#
-JS_HFILES =		\
-	jsarray.h	\
-	jsatom.h	\
-	jsbool.h	\
-	jsconfig.h	\
-	jscntxt.h	\
-	jsdate.h	\
-	jsemit.h	\
-	jsexn.h		\
-	jsfun.h		\
-	jsgc.h		\
-	jsinterp.h	\
-	jslibmath.h	\
-	jslock.h	\
-	jsmath.h	\
-	jsnum.h		\
-	jsobj.h		\
-	jsopcode.h      \
-	jsparse.h	\
-	jsarena.h	\
-	jsclist.h	\
-	jsdtoa.h	\
-	jshash.h	\
-	jslong.h	\
-	jsosdep.h	\
-	jstypes.h	\
-	jsprvtd.h	\
-	jspubtd.h	\
-	jsregexp.h	\
-	jsscan.h	\
-	jsscope.h	\
-	jsscript.h	\
-	jsstr.h		\
-	jsxdrapi.h	\
-	$(NULL)
-
-API_HFILES =		\
-	jsapi.h		\
-	jsdbgapi.h	\
-	$(NULL)
-
-OTHER_HFILES =		\
-	jsbit.h		\
-	jscompat.h	\
-	jscpucfg.h	\
-	jsotypes.h	\
-	jsstddef.h	\
-	prmjtime.h	\
-	resource.h	\
-	jsopcode.tbl	\
-	js.msg		\
-	jsshell.msg	\
-	$(NULL)
-
-ifndef PREBUILT_CPUCFG
-OTHER_HFILES += $(OBJDIR)/jsautocfg.h
-endif
-
-HFILES = $(JS_HFILES) $(API_HFILES) $(OTHER_HFILES)
-
-JS_CFILES =		\
-	jsapi.c		\
-	jsarena.c	\
-	jsarray.c	\
-	jsatom.c	\
-	jsbool.c	\
-	jscntxt.c	\
-	jsdate.c	\
-	jsdbgapi.c	\
-	jsdtoa.c	\
-	jsemit.c	\
-	jsexn.c		\
-	jsfun.c		\
-	jsgc.c		\
-	jshash.c	\
-	jsinterp.c	\
-	jslock.c	\
-	jslog2.c	\
-	jslong.c	\
-	jsmath.c	\
-	jsnum.c		\
-	jsobj.c		\
-	jsopcode.c      \
-	jsparse.c	\
-	jsprf.c		\
-	jsregexp.c	\
-	jsscan.c	\
-	jsscope.c	\
-	jsscript.c	\
-	jsstr.c		\
-	jsutil.c        \
-	jsxdrapi.c	\
-	prmjtime.c	\
-	$(NULL)
-
-PREDIRS   += fdlibm
-ifdef JS_LIVECONNECT
-DIRS      += liveconnect
-endif
-
-ifdef JS_PERLCONNECT
-JS_CFILES += jsperl.c
-endif
-
-ifdef JS_HAS_FILE_OBJECT
-JS_CFILES += jsfile.c
-JS_HFILES += jsfile.h
-endif
-
-LIB_CFILES  = $(JS_CFILES)
-LIB_ASFILES := $(wildcard *_$(OS_ARCH).s)
-PROG_CFILES = js.c
-
-ifdef USE_MSVC
-LIBRARY = $(OBJDIR)/js32.lib
-SHARED_LIBRARY = $(OBJDIR)/js32.dll
-PROGRAM = $(OBJDIR)/js.exe
-else
-LIBRARY = $(OBJDIR)/libjs.a
-SHARED_LIBRARY = $(OBJDIR)/libjs.$(SO_SUFFIX)
-PROGRAM = $(OBJDIR)/js
-endif
-
-ifdef USE_MSVC
-FDLIBM_LIBRARY = fdlibm.lib
-else
-FDLIBM_LIBRARY = libfdm.a
-endif
-
-include rules.mk
-
-MOZ_DEPTH = ../..
-include jsconfig.mk
-
-nsinstall-target:
-	cd ../../config; $(MAKE) OBJDIR=$(OBJDIR) OBJDIR_NAME=$(OBJDIR)
-ifdef USE_MSVC
-$(PROGRAM): $(PROG_OBJS) $(LIBRARY) fdlibm/$(OBJDIR)/$(FDLIBM_LIBRARY)
-	link.exe -out:"$@" $(EXE_LINK_FLAGS) $^
-else
-$(PROGRAM): $(PROG_OBJS) $(LIBRARY) fdlibm/$(OBJDIR)/$(FDLIBM_LIBRARY)
-	$(CC) -o $@ $(CFLAGS) $(PROG_OBJS) $(LIBRARY) $(LDFLAGS) $(OTHER_LIBS) \
-	    $(PROG_LIBS)
-endif
-
-$(PROGRAM).pure: $(PROG_OBJS) $(LIBRARY)
-	purify $(PUREFLAGS) \
-	    $(CC) -o $@ $(PURE_OS_CFLAGS) $(PROG_OBJS) $(LIBRARY) $(LDFLAGS) \
-		$(OTHER_LIBS) $(PROG_LIBS)
-
-ifndef PREBUILT_CPUCFG
-$(HFILES) $(CFILES): $(OBJDIR)/jsautocfg.h
-
-$(OBJDIR)/jsautocfg.h: $(OBJDIR)/jscpucfg
-	rm -f $@
-	$(OBJDIR)/jscpucfg > $@
-
-$(OBJDIR)/jscpucfg: $(OBJDIR)/jscpucfg.o
-	$(CC) -o $@ $(OBJDIR)/jscpucfg.o
-
-# Look in OBJDIR to find jsautocfg.h
-INCLUDES   += -I$(OBJDIR)
-
-# Add to TARGETS for clobber rule
-TARGETS += $(OBJDIR)/jsautocfg.h $(OBJDIR)/jscpucfg $(OBJDIR)/jscpucfg.o
-endif
-
-#
-# Hardwire dependencies on jsopcode.tbl
-#
-jsopcode.h jsopcode.c: jsopcode.tbl
-
--include $(DEPENDENCIES)
-
-TARNAME = jsref.tar
-TARFILES = files `cat files`
-
-SUFFIXES: .i
-%.i: %.c
-	$(CC) -C -E $(CFLAGS) $< > $*.i

mozilla/js/src/README.html

@@ -1,755 +0,0 @@
-<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
-<html>
-<head>
-   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-   <meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
-   <title>JavaScript Reference Implementation (JSRef) README</title>
-</head>
-<body>
-
-<h2>
-Table of Contents</h2>
-
-<ul>
-<li>
-<a href="#Introduction">Introduction</a></li>
-
-<li>
-<a href="#Build">Build conventions (standalone JS engine and shell)</a></li>
-
-<li>
-<a href="#Debugging">Debugging notes</a></li>
-
-<li>
-<a href="#Conventions">Naming and coding conventions</a></li>
-
-<li>
-<a href="#JSAPI">Using the JS API</a></li>
-
-<li>
-<a href="#Design">Design walk-through</a></li>
-</ul>
-
-<h2>
-<a NAME="Introduction"></a>Introduction</h2>
-This is the README file for the&nbsp;<span CLASS=LXRSHORTDESC>JavaScript
-Reference (JSRef) implementation.</span> It consists of build conventions
-and instructions, source code conventions, a design walk-through, and a
-brief file-by-file description of the source.
-<p><span CLASS=LXRLONGDESC>JSRef builds a library or DLL containing the
-JavaScript runtime (compiler, interpreter, decompiler, garbage collector,
-atom manager, standard classes). It then compiles a small "shell" program
-and links that with the library to make an interpreter that can be used
-interactively and with test .js files to run scripts.&nbsp; The code has
-no dependencies on the Navigator code.</span>
-<p><i>Quick start tip</i>: skip to "Using the JS API" below, build the
-js shell, and play with the object named "it" (start by setting 'it.noisy
-= true').
-<h2>
-<a NAME="Build"></a>Build conventions (standalone JS engine and shell)</h2>
-These build directions refer only to building the standalone JavaScript
-engine and shell.&nbsp; To build within the browser, refer to the <a href="http://www.mozilla.org/docs/">build
-directions</a> on the mozilla.org website.
-<p>By default, all platforms build a version of the JS engine that is <i>not</i>
-threadsafe.&nbsp; If you require thread-safety, you must also populate
-the <tt>mozilla/dist</tt> directory with <a href="http://www.mozilla.org/docs/tplist/catCode/nsprdesc.htm">NSPR</a>
-headers and libraries.&nbsp; (NSPR implements a portable threading library,
-among other things.&nbsp; The source is downloadable via <a href="http://www.mozilla.org/cvs.html">CVS</a>
-from <tt><a href="http://cvs-mirror.mozilla.org/webtools/lxr/source/nsprpub">mozilla/nsprpub</a></tt>.)&nbsp;
-Next, you must define <tt>JS_THREADSAFE</tt> when building the JS engine,
-either on the command-line (gmake/nmake) or in a universal header file.
-<h3>
-Windows</h3>
-
-<ul>
-<li>
-Use MSVC 4.2 or 5.0.</li>
-
-<li>
-For building from the IDE use <tt>js/src/js.mdp</tt>.&nbsp; (<tt>js.mdp</tt>
-is an MSVC4.2 project file, but if you load it into MSVC5, it will be converted
-to the newer project file format.)&nbsp; <font color="#CC0000">NOTE: makefile.win
-is an nmake file used only for building the JS-engine in the Mozilla browser.&nbsp;
-Don't attempt to use it to build the standalone JS-engine.</font></li>
-
-<li>
-If you prefer to build from the command-line, use '<tt>nmake -f js.mak</tt>'</li>
-
-<li>
-Executable shell <tt>js.exe</tt> and runtime library <tt>js32.dll</tt>
-are created in either <tt>js/src/Debug</tt> or <tt>js/src/Release</tt>.</li>
-</ul>
-
-<h3>
-Macintosh</h3>
-
-<ul>
-<li>
-Use CodeWarrior 3.x</li>
-
-<li>
-Load the project file <tt>js:src:macbuild:JSRef.mcp </tt>and select "Make"
-from the menu.</li>
-</ul>
-
-<h3>
-Unix</h3>
-
-<ul>
-<li>
-Use '<tt>gmake -f Makefile.ref</tt>' to build. To compile optimized code,
-pass <tt>BUILD_OPT=1</tt> on the gmake command line or preset it in the
-environment or <tt>Makefile.ref</tt>.&nbsp; <font color="#CC0000">NOTE:
-Do not attempt to use Makefile to build the standalone JavaScript engine.&nbsp;
-This file is used only for building the JS-engine in the Mozilla browser.</font></li>
-
-<li>
-<font color="#000000">Each platform on which JS is built must have a <tt>*.mk</tt>
-configuration file in the <tt>js/src/config</tt> directory.&nbsp; The configuration
-file specifies the compiler/linker to be used and allows for customization
-of command-line options.&nbsp; To date, the build system has been tested
-on Solaris, AIX, HP/UX, OSF, IRIX, x86 Linux and Windows NT.</font></li>
-
-<li>
-<font color="#000000">Most platforms will work with either the vendor compiler
-</font>or
-<a href="ftp://prep.ai.mit.edu/pub/gnu">gcc</a>.&nbsp;
-(Except that HP builds only work using the native compiler.&nbsp; gcc won't
-link correctly with shared libraries on that platform.&nbsp; If someone
-knows a way to fix this, <a href="mailto:wynholds@netscape.com">let us
-know</a>.)</li>
-
-<li>
-<font color="#000000">If you define <tt>JS_LIVECONNECT</tt>, gmake will
-descend into the liveconnect directory and build <a href="http://cvs-mirror.mozilla.org/webtools/lxr/source/js/src/liveconnect/README.html">LiveConnect</a>
-after building the JS engine.</font></li>
-
-<li>
-To build a binary drop (a zip'ed up file of headers, libraries, binaries),
-check out <tt>mozilla/config</tt> and <tt>mozilla/nsprpub/config</tt>.&nbsp;
-Use '<tt>gmake -f Makefile.ref nsinstall-target all export ship</tt>'</li>
-</ul>
-
-<h2>
-<a NAME="Debugging"></a>Debugging notes</h2>
-
-<ul>
-<li>
-To turn on GC instrumentation, define <tt>JS_GCMETER</tt>.</li>
-
-<li>
-To turn on the arena package's instrumentation, define <tt>JS_ARENAMETER</tt>.</li>
-
-<li>
-To turn on the hash table package's metering, define <tt>JS_HASHMETER</tt>.</li>
-</ul>
-
-<h2>
-<a NAME="Conventions"></a>Naming and coding conventions</h2>
-
-<ul>
-<li>
-Public function names begin with <tt>JS_</tt> followed by capitalized "intercaps",
-e.g. <tt>JS_NewObject</tt>.</li>
-
-<li>
-Extern but library-private function names use a <tt>js_</tt> prefix and
-mixed case, e.g. <tt>js_LookupSymbol</tt>.</li>
-
-<li>
-Most static function names have unprefixed, mixed-case names: <tt>GetChar</tt>.</li>
-
-<li>
-But static native methods of JS objects have lowercase, underscore-separated
-or intercaps names, e.g., <tt>str_indexOf</tt>.</li>
-
-<li>
-And library-private and static data use underscores, not intercaps (but
-library-private data do use a <tt>js_</tt> prefix).</li>
-
-<li>
-Scalar type names are lowercase and js-prefixed: <tt>jsdouble</tt>.</li>
-
-<li>
-Aggregate type names are JS-prefixed and mixed-case: <tt>JSObject.</tt></li>
-
-<li>
-Macros are generally <tt>ALL_CAPS </tt>and underscored, to call out potential
-side effects, multiple uses of a formal argument, etc. - Four spaces of
-indentation per statement nesting level.</li>
-
-<li>
-Tabs are taken to be eight spaces, and an Emacs magic comment at the top
-of each file tries to help. If you're using MSVC or similar, you'll want
-to set tab width to 8, or convert these files to be space-filled.</li>
-
-<li>
-DLL entry points have their return type expanded within a <tt>JS_PUBLIC_API()</tt>
-macro call, to get the right Windows secret type qualifiers in the right
-places for both 16- and 32-bit builds.</li>
-
-<li>
-Callback functions that might be called from a DLL are similarly macroized
-with <tt>JS_STATIC_DLL_CALLBACK</tt> (if the function otherwise would be
-static to hide its name) or <tt>JS_DLL_CALLBACK</tt> (this macro takes
-no type argument; it should be used after the return type and before the
-function name).</li>
-</ul>
-
-<h2>
-<a NAME="JSAPI"></a>Using the JS API</h2>
-
-<h4>
-Starting up</h4>
-
-<pre><tt>&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * Tune this to avoid wasting space for shallow stacks, while saving on
-&nbsp;&nbsp;&nbsp;&nbsp; * malloc overhead/fragmentation for deep or highly-variable stacks.
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; #define STACK_CHUNK_SIZE&nbsp;&nbsp;&nbsp; 8192
-
-&nbsp;&nbsp;&nbsp; JSRuntime *rt;
-&nbsp;&nbsp;&nbsp; JSContext *cx;
-
-&nbsp;&nbsp;&nbsp; /* You need a runtime and one or more contexts to do anything with JS. */
-&nbsp;&nbsp;&nbsp; rt = JS_Init(1000000L);
-&nbsp;&nbsp;&nbsp; if (!rt)
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; fail("can't create JavaScript runtime");
-&nbsp;&nbsp;&nbsp; cx = JS_NewContext(rt, STACK_CHUNK_SIZE);
-&nbsp;&nbsp;&nbsp; if (!cx)
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; fail("can't create JavaScript context");
-
-&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * The context definitely wants a global object, in order to have standard
-&nbsp;&nbsp;&nbsp;&nbsp; * classes and functions like Date and parseInt.&nbsp; See below for details on
-&nbsp;&nbsp;&nbsp;&nbsp; * JS_NewObject.
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; JSObject *globalObj;
-
-&nbsp;&nbsp;&nbsp; globalObj = JS_NewObject(cx, &amp;my_global_class, 0, 0);
-&nbsp;&nbsp;&nbsp; JS_InitStandardClasses(cx, globalObj);</tt></pre>
-
-<h4>
-Defining objects and properties</h4>
-
-<pre><tt>&nbsp;&nbsp;&nbsp; /* Statically initialize a class to make "one-off" objects. */
-&nbsp;&nbsp;&nbsp; JSClass my_class = {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; "MyClass",
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* All of these can be replaced with the corresponding JS_*Stub
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; function pointers. */
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; my_addProperty, my_delProperty, my_getProperty, my_setProperty,
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; my_enumerate,&nbsp;&nbsp; my_resolve,&nbsp;&nbsp;&nbsp;&nbsp; my_convert,&nbsp;&nbsp;&nbsp;&nbsp; my_finalize
-&nbsp;&nbsp;&nbsp; };
-
-&nbsp;&nbsp;&nbsp; JSObject *obj;
-
-&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * Define an object named in the global scope that can be enumerated by
-&nbsp;&nbsp;&nbsp;&nbsp; * for/in loops.&nbsp; The parent object is passed as the second argument, as
-&nbsp;&nbsp;&nbsp;&nbsp; * with all other API calls that take an object/name pair.&nbsp; The prototype
-&nbsp;&nbsp;&nbsp;&nbsp; * passed in is null, so the default object prototype will be used.
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; obj = JS_DefineObject(cx, globalObj, "myObject", &amp;my_class, 0,
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; JSPROP_ENUMERATE);
-
-&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * Define a bunch of properties with a JSPropertySpec array statically
-&nbsp;&nbsp;&nbsp;&nbsp; * initialized and terminated with a null-name entry.&nbsp; Besides its name,
-&nbsp;&nbsp;&nbsp;&nbsp; * each property has a "tiny" identifier (MY_COLOR, e.g.) that can be used
-&nbsp;&nbsp;&nbsp;&nbsp; * in switch statements (in a common my_getProperty function, for example).
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; enum my_tinyid {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MY_COLOR, MY_HEIGHT, MY_WIDTH, MY_FUNNY, MY_ARRAY, MY_RDONLY
-&nbsp;&nbsp;&nbsp; };
-
-&nbsp;&nbsp;&nbsp; static JSPropertySpec my_props[] = {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"color",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MY_COLOR,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; JSPROP_ENUMERATE},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"height",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MY_HEIGHT,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; JSPROP_ENUMERATE},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"width",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MY_WIDTH,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; JSPROP_ENUMERATE},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"funny",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MY_FUNNY,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; JSPROP_ENUMERATE},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"array",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MY_ARRAY,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; JSPROP_ENUMERATE},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"rdonly",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MY_RDONLY,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; JSPROP_READONLY},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {0}
-&nbsp;&nbsp;&nbsp; };
-
-&nbsp;&nbsp;&nbsp; JS_DefineProperties(cx, obj, my_props);
-
-&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * Given the above definitions and call to JS_DefineProperties, obj will
-&nbsp;&nbsp;&nbsp;&nbsp; * need this sort of "getter" method in its class (my_class, above).&nbsp; See
-&nbsp;&nbsp;&nbsp;&nbsp; * the example for the "It" class in js.c.
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; static JSBool
-&nbsp;&nbsp;&nbsp; my_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
-&nbsp;&nbsp;&nbsp; {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if (JSVAL_IS_INT(id)) {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; switch (JSVAL_TO_INT(id)) {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; case MY_COLOR:&nbsp; *vp = . . .; break;
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; case MY_HEIGHT: *vp = . . .; break;
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; case MY_WIDTH:&nbsp; *vp = . . .; break;
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; case MY_FUNNY:&nbsp; *vp = . . .; break;
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; case MY_ARRAY:&nbsp; *vp = . . .; break;
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; case MY_RDONLY: *vp = . . .; break;
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return JS_TRUE;
-&nbsp;&nbsp;&nbsp; }</tt></pre>
-
-<h4>
-Defining functions</h4>
-
-<pre><tt>&nbsp;&nbsp;&nbsp; /* Define a bunch of native functions first: */
-&nbsp;&nbsp;&nbsp; static JSBool
-&nbsp;&nbsp;&nbsp; my_abs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-&nbsp;&nbsp;&nbsp; {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; jsdouble x, z;
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if (!JS_ValueToNumber(cx, argv[0], &amp;x))
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return JS_FALSE;
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; z = (x &lt; 0) ? -x : x;
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return JS_NewDoubleValue(cx, z, rval);
-&nbsp;&nbsp;&nbsp; }
-
-&nbsp;&nbsp;&nbsp; . . .
-
-&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * Use a JSFunctionSpec array terminated with a null name to define a
-&nbsp;&nbsp;&nbsp;&nbsp; * bunch of native functions.
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; static JSFunctionSpec my_functions[] = {
-&nbsp;&nbsp;&nbsp; /*&nbsp;&nbsp;&nbsp; name&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; native&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; nargs&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"abs",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; my_abs,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 1},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"acos",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; my_acos,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 1},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"asin",&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; my_asin,&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 1},
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; . . .
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {0}
-&nbsp;&nbsp;&nbsp; };
-
-&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * Pass a particular object to define methods for it alone.&nbsp; If you pass
-&nbsp;&nbsp;&nbsp;&nbsp; * a prototype object, the methods will apply to all instances past and
-&nbsp;&nbsp;&nbsp;&nbsp; * future of the prototype's class (see below for classes).
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; JS_DefineFunctions(cx, globalObj, my_functions);</tt></pre>
-
-<h4>
-Defining classes</h4>
-
-<pre><tt>&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * This pulls together the above API elements by defining a constructor
-&nbsp;&nbsp;&nbsp;&nbsp; * function, a prototype object, and properties of the prototype and of
-&nbsp;&nbsp;&nbsp;&nbsp; * the constructor, all with one API call.
-&nbsp;&nbsp;&nbsp;&nbsp; *
-&nbsp;&nbsp;&nbsp;&nbsp; * Initialize a class by defining its constructor function, prototype, and
-&nbsp;&nbsp;&nbsp;&nbsp; * per-instance and per-class properties.&nbsp; The latter are called "static"
-&nbsp;&nbsp;&nbsp;&nbsp; * below by analogy to Java.&nbsp; They are defined in the constructor object's
-&nbsp;&nbsp;&nbsp;&nbsp; * scope, so that 'MyClass.myStaticProp' works along with 'new MyClass()'.
-&nbsp;&nbsp;&nbsp;&nbsp; *
-&nbsp;&nbsp;&nbsp;&nbsp; * JS_InitClass takes a lot of arguments, but you can pass null for any of
-&nbsp;&nbsp;&nbsp;&nbsp; * the last four if there are no such properties or methods.
-&nbsp;&nbsp;&nbsp;&nbsp; *
-&nbsp;&nbsp;&nbsp;&nbsp; * Note that you do not need to call JS_InitClass to make a new instance of
-&nbsp;&nbsp;&nbsp;&nbsp; * that class -- otherwise there would be a chicken-and-egg problem making
-&nbsp;&nbsp;&nbsp;&nbsp; * the global object -- but you should call JS_InitClass if you require a
-&nbsp;&nbsp;&nbsp;&nbsp; * constructor function for script authors to call via new, and/or a class
-&nbsp;&nbsp;&nbsp;&nbsp; * prototype object ('MyClass.prototype') for authors to extend with new
-&nbsp;&nbsp;&nbsp;&nbsp; * properties at run-time.
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; protoObj = JS_InitClass(cx, globalObj, &amp;my_class,
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* native constructor function and min arg count */
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MyClass, 0,
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* prototype object properties and methods -- these
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; will be "inherited" by all instances through
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; delegation up the instance's prototype link. */
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; my_props, my_methods,
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* class constructor properties and methods */
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; my_static_props, my_static_methods);</tt></pre>
-
-<h4>
-Running scripts</h4>
-
-<pre><tt>&nbsp;&nbsp;&nbsp; /* These should indicate source location for diagnostics. */
-&nbsp;&nbsp;&nbsp; char *filename;
-&nbsp;&nbsp;&nbsp; uintN lineno;
-
-&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * The return value comes back here -- if it could be a GC thing, you must
-&nbsp;&nbsp;&nbsp;&nbsp; * add it to the GC's "root set" with JS_AddRoot(cx, &amp;thing) where thing
-&nbsp;&nbsp;&nbsp;&nbsp; * is a JSString *, JSObject *, or jsdouble *, and remove the root before
-&nbsp;&nbsp;&nbsp;&nbsp; * rval goes out of scope, or when rval is no longer needed.
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; jsval rval;
-&nbsp;&nbsp;&nbsp; JSBool ok;
-
-&nbsp;&nbsp;&nbsp; /*
-&nbsp;&nbsp;&nbsp;&nbsp; * Some example source in a C string.&nbsp; Larger, non-null-terminated buffers
-&nbsp;&nbsp;&nbsp;&nbsp; * can be used, if you pass the buffer length to JS_EvaluateScript.
-&nbsp;&nbsp;&nbsp;&nbsp; */
-&nbsp;&nbsp;&nbsp; char *source = "x * f(y)";
-
-&nbsp;&nbsp;&nbsp; ok = JS_EvaluateScript(cx, globalObj, source, strlen(source),
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; filename, lineno, &amp;rval);
-
-&nbsp;&nbsp;&nbsp; if (ok) {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Should get a number back from the example source. */
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; jsdouble d;
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ok = JS_ValueToNumber(cx, rval, &amp;d);
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; . . .
-&nbsp;&nbsp;&nbsp; }</tt></pre>
-
-<h4>
-Calling functions</h4>
-
-<pre><tt>&nbsp;&nbsp;&nbsp; /* Call a global function named "foo" that takes no arguments. */
-&nbsp;&nbsp;&nbsp; ok = JS_CallFunctionName(cx, globalObj, "foo", 0, 0, &amp;rval);
-
-&nbsp;&nbsp;&nbsp; jsval argv[2];
-
-&nbsp;&nbsp;&nbsp; /* Call a function in obj's scope named "method", passing two arguments. */
-&nbsp;&nbsp;&nbsp; argv[0] = . . .;
-&nbsp;&nbsp;&nbsp; argv[1] = . . .;
-&nbsp;&nbsp;&nbsp; ok = JS_CallFunctionName(cx, obj, "method", 2, argv, &amp;rval);</tt></pre>
-
-<h4>
-Shutting down</h4>
-
-<pre><tt>&nbsp;&nbsp;&nbsp; /* For each context you've created: */
-&nbsp;&nbsp;&nbsp; JS_DestroyContext(cx);
-
-&nbsp;&nbsp;&nbsp; /* And finally: */
-&nbsp;&nbsp;&nbsp; JS_Finish(rt);</tt></pre>
-
-<h4>
-Debugging API</h4>
-See the<tt> trap, untrap, watch, unwatch, line2pc</tt>, and <tt>pc2line</tt>
-commands in <tt>js.c</tt>. Also the (scant) comments in <i>jsdbgapi.h</i>.
-<h2>
-<a NAME="Design"></a>Design walk-through</h2>
-This section must be brief for now -- it could easily turn into a book.
-<h4>
-JS "JavaScript Proper"</h4>
-JS modules declare and implement the JavaScript compiler, interpreter,
-decompiler, GC and atom manager, and standard classes.
-<p>JavaScript uses untyped bytecode and runtime type tagging of data values.
-The <tt>jsval</tt> type is a signed machine word that contains either a
-signed integer value (if the low bit is set), or a type-tagged pointer
-or boolean value (if the low bit is clear). Tagged pointers all refer to
-8-byte-aligned things in the GC heap.
-<p>Objects consist of a possibly shared structural description, called
-the map or scope; and unshared property values in a vector, called the
-slots. Object properties are associated with nonnegative integers stored
-in <tt>jsval</tt>'s, or with atoms (unique string descriptors) if named
-by an identifier or a non-integral index expression.
-<p>Scripts contain bytecode, source annotations, and a pool of string,
-number, and identifier literals. Functions are objects that extend scripts
-or native functions with formal parameters, a literal syntax, and a distinct
-primitive type ("function").
-<p>The compiler consists of a recursive-descent parser and a random-logic
-rather than table-driven lexical scanner. Semantic and lexical feedback
-are used to disambiguate hard cases such as missing semicolons, assignable
-expressions ("lvalues" in C parlance), etc. The parser generates bytecode
-as it parses, using fixup lists for downward branches and code buffering
-and rewriting for exceptional cases such as for loops. It attempts no error
-recovery. The interpreter executes the bytecode of top-level scripts, and
-calls itself indirectly to interpret function bodies (which are also scripts).
-All state associated with an interpreter instance is passed through formal
-parameters to the interpreter entry point; most implicit state is collected
-in a type named JSContext. Therefore, all API and almost all other functions
-in JSRef take a JSContext pointer as their first argument.
-<p>The decompiler translates postfix bytecode into infix source by consulting
-a separate byte-sized code, called source notes, to disambiguate bytecodes
-that result from more than one grammatical production.
-<p>The GC is a mark-and-sweep, non-conservative (perfect) collector. It
-can allocate only fixed-sized things -- the current size is two machine
-words. It is used to hold JS object and string descriptors (but not property
-lists or string bytes), and double-precision floating point numbers. It
-runs automatically only when maxbytes (as passed to <tt>JS_Init()</tt>)
-bytes of GC things have been allocated and another thing-allocation request
-is made. JS API users should call <tt>JS_GC()</tt> or <tt>JS_MaybeGC()</tt>
-between script executions or from the branch callback, as often as necessary.
-<p>An important point about the GC's "perfection": you must add roots for
-new objects created by your native methods if you store references to them
-into a non-JS structure in the malloc heap or in static data. Also, if
-you make a new object in a native method, but do not store it through the
-<tt>rval</tt>
-result parameter (see math_abs in the "Using the JS API" section above)
-so that it is in a known root, the object is guaranteed to survive only
-until another new object is created. Either lock the first new object when
-making two in a row, or store it in a root you've added, or store it via
-rval.
-<p>The atom manager consists of a hash table associating strings uniquely
-with scanner/parser information such as keyword type, index in script or
-function literal pool, etc. Atoms play three roles in JSRef: as literals
-referred to by unaligned 16-bit immediate bytecode operands, as unique
-string descriptors for efficient property name hashing, and as members
-of the root GC set for perfect GC. This design therefore requires atoms
-to be manually reference counted, from script literal pools (<tt>JSAtomMap</tt>)
-and object symbol (<tt>JSSymbol</tt>) entry keys.
-<p>Native objects and methods for arrays, booleans, dates, functions, numbers,
-and strings are implemented using the JS API and certain internal interfaces
-used as "fast paths".
-<p>In general, errors are signaled by false or unoverloaded-null return
-values, and are reported using <tt>JS_ReportError()</tt> or one of its
-variants by the lowest level in order to provide the most detail. Client
-code can substitute its own error reporting function and suppress errors,
-or reflect them into Java or some other runtime system as exceptions, GUI
-dialogs, etc..
-<h2>
-File walk-through (BADLY OUT OF DATE!)</h2>
-
-<h4>
-jsapi.c, jsapi.h</h4>
-The public API to be used by almost all client code.&nbsp; If your client
-code can't make do with <tt>jsapi.h</tt>, and must reach into a friend
-or private js* file, please let us know so we can extend <tt>jsapi.h</tt>
-to include what you need in a fashion that we can support over the long
-run.
-<h4>
-jspubtd.h, jsprvtd.h</h4>
-These files exist to group struct and scalar typedefs so they can be used
-everywhere without dragging in struct definitions from N different files.
-The <tt>jspubtd.h</tt> file contains public typedefs, and is included by
-<tt>jsapi.h</tt>.
-The <tt>jsprvtd.h</tt> file contains private typedefs and is included by
-various .h files that need type names, but not type sizes or declarations.
-<h4>
-jsdbgapi.c, jsdbgapi.h</h4>
-The Debugging API, still very much under development. Provided so far:
-<ul>
-<li>
-Traps, with which breakpoints, single-stepping, step over, step out, and
-so on can be implemented. The debugger will have to consult jsopcode.def
-on its own to figure out where to plant trap instructions to implement
-functions like step out, but a future jsdbgapi.h will provide convenience
-interfaces to do these things. At most one trap per bytecode can be set.
-When a script (<tt>JSScript</tt>) is destroyed, all traps set in its bytecode
-are cleared.</li>
-
-<li>
-Watchpoints, for intercepting set operations on properties and running
-a debugger-supplied function that receives the old value and a pointer
-to the new one, which it can use to modify the new value being set.</li>
-
-<li>
-Line number to PC and back mapping functions. The line-to-PC direction
-"rounds" toward the next bytecode generated from a line greater than or
-equal to the input line, and may return the PC of a for-loop update part,
-if given the line number of the loop body's closing brace. Any line after
-the last one in a script or function maps to a PC one byte beyond the last
-bytecode in the script. An example, from perfect.js:</li>
-
-<pre><tt>14&nbsp;&nbsp; function perfect(n)
-15&nbsp;&nbsp; {
-16&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; print("The perfect numbers up to " +&nbsp; n + " are:");
-17
-18&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // We build sumOfDivisors[i] to hold a string expression for
-19&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // the sum of the divisors of i, excluding i itself.
-20&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; var sumOfDivisors = new ExprArray(n+1,1);
-21&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (var divisor = 2; divisor &lt;= n; divisor++) {
-22&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (var j = divisor + divisor; j &lt;= n; j += divisor) {
-23&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; sumOfDivisors[j] += " + " + divisor;
-24&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }
-25&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // At this point everything up to 'divisor' has its sumOfDivisors
-26&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // expression calculated, so we can determine whether it's perfect
-27&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // already by evaluating.
-28&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if (eval(sumOfDivisors[divisor]) == divisor) {
-29&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; print("" + divisor + " = " + sumOfDivisors[divisor]);
-30&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }
-31&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }
-32&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; delete sumOfDivisors;
-33&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; print("That's all.");
-34&nbsp;&nbsp; }</tt></pre>
-The line number to PC and back mappings can be tested using the js program
-with the following script:
-<pre><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; load("perfect.js")
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; print(perfect)
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; dis(perfect)
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; print()
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for (var ln = 0; ln &lt;= 40; ln++) {
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; var pc = line2pc(perfect,ln)
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; var ln2 = pc2line(perfect,pc)
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; print("\tline " + ln + " => pc " + pc + " => line " + ln2)
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }</tt></pre>
-The result of the for loop over lines 0 to 40 inclusive is:
-<pre><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 0 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 1 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 2 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 3 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 4 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 5 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 6 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 7 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 8 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 9 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 10 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 11 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 12 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 13 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 14 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 15 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 16 => pc 0 => line 16
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 17 => pc 19 => line 20
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 18 => pc 19 => line 20
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 19 => pc 19 => line 20
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 20 => pc 19 => line 20
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 21 => pc 36 => line 21
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 22 => pc 53 => line 22
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 23 => pc 74 => line 23
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 24 => pc 92 => line 22
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 25 => pc 106 => line 28
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 26 => pc 106 => line 28
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 27 => pc 106 => line 28
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 28 => pc 106 => line 28
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 29 => pc 127 => line 29
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 30 => pc 154 => line 21
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 31 => pc 154 => line 21
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 32 => pc 161 => line 32
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 33 => pc 172 => line 33
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 34 => pc 172 => line 33
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 35 => pc 172 => line 33
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 36 => pc 172 => line 33
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 37 => pc 172 => line 33
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 38 => pc 172 => line 33
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 39 => pc 172 => line 33
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; line 40 => pc 172 => line 33</tt></pre>
-</ul>
-
-<h4>
-jsconfig.h</h4>
-Various configuration macros defined as 0 or 1 depending on how <tt>JS_VERSION</tt>
-is defined (as 10 for JavaScript 1.0, 11 for JavaScript 1.1, etc.). Not
-all macros are tested around related code yet. In particular, JS 1.0 support
-is missing from JSRef. JS 1.2 support will appear in a future JSRef release.
-<br>&nbsp;
-<h4>
-js.c</h4>
-The "JS shell", a simple interpreter program that uses the JS API and more
-than a few internal interfaces (some of these internal interfaces could
-be replaced by <tt>jsapi.h</tt> calls). The js program built from this
-source provides a test vehicle for evaluating scripts and calling functions,
-trying out new debugger primitives, etc.
-<h4>
-jsarray.*, jsbool.*, jdsdate.*, jsfun.*, jsmath.*, jsnum.*, jsstr.*</h4>
-These file pairs implement the standard classes and (where they exist)
-their underlying primitive types. They have similar structure, generally
-starting with class definitions and continuing with internal constructors,
-finalizers, and helper functions.
-<h4>
-jsobj.*, jsscope.*</h4>
-These two pairs declare and implement the JS object system. All of the
-following happen here:
-<ul>
-<li>
-creating objects by class and prototype, and finalizing objects;</li>
-
-<li>
-defining, looking up, getting, setting, and deleting properties;</li>
-
-<li>
-creating and destroying properties and binding names to them.</li>
-</ul>
-The details of an object map (scope) are mostly hidden in <tt>jsscope.[ch]</tt>,
-where scopes start out as linked lists of symbols, and grow after some
-threshold into PR hash tables.
-<h4>
-jsatom.c, jsatom.h</h4>
-The atom manager. Contains well-known string constants, their atoms, the
-global atom hash table and related state, the js_Atomize() function that
-turns a counted string of bytes into an atom, and literal pool (<tt>JSAtomMap</tt>)
-methods.
-<h4>
-jsgc.c, jsgc.h</h4>
-[TBD]
-<h4>
-jsinterp.*, jscntxt.*</h4>
-The bytecode interpreter, and related functions such as Call and AllocStack,
-live in <i>jsinterp.c</i>. The JSContext constructor and destructor are
-factored out into <i>jscntxt.c</i> for minimal linking when the compiler
-part of JS is split from the interpreter part into a separate program.
-<h4>
-jsemit.*, jsopcode.tbl, jsopcode.*, jsparse.*, jsscan.*, jsscript.*</h4>
-Compiler and decompiler modules. The <i>jsopcode.tbl</i> file is a C preprocessor
-source that defines almost everything there is to know about JS bytecodes.
-See its major comment for how to use it. For now, a debugger will use it
-and its dependents such as <i>jsopcode.h</i> directly, but over time we
-intend to extend <i>jsdbgapi.h</i> to hide uninteresting details and provide
-conveniences. The code generator is split across paragraphs of code in
-<i>jsparse.c</i>,
-and the utility methods called on <tt>JSCodeGenerator</tt> appear in <i>jsemit.c</i>.
-Source notes generated by <i>jsparse.c</i> and
-<i>jsemit.c</i> are used
-in <i>jsscript.c</i> to map line number to program counter and back.
-<h4>
-jstypes.h, jslog2.c</h4>
-Fundamental representation types and utility macros. This file alone among
-all .h files in JSRef must be included first by .c files. It is not nested
-in .h files, as other prerequisite .h files generally are, since it is
-also a direct dependency of most .c files and would be over-included if
-nested in addition to being directly included. The one "not-quite-a-macro
-macro" is the <tt>JS_CeilingLog2()</tt> function in <i>jslog2.c</i>.
-<h4>
-jsarena.c, jsarena.h</h4>
-Last-In-First-Out allocation macros that amortize malloc costs and allow
-for en-masse freeing. See the paper mentioned in prarena.h's major comment.
-<h4>
-jsutil.c, jsutil.h</h4>
-The <tt>JS_ASSERT</tt> macro is used throughout JSRef source as a proof
-device to make invariants and preconditions clear to the reader, and to
-hold the line during maintenance and evolution against regressions or violations
-of assumptions that it would be too expensive to test unconditionally at
-run-time. Certain assertions are followed by run-time tests that cope with
-assertion failure, but only where I'm too smart or paranoid to believe
-the assertion will never fail...
-<h4>
-jsclist.h</h4>
-Doubly-linked circular list struct and macros.
-<h4>
-jscpucfg.c</h4>
-This standalone program generates <i>jscpucfg.h</i>, a header file containing
-bytes per word and other constants that depend on CPU architecture and
-C compiler type model. It tries to discover most of these constants by
-running its own experiments on the build host, so if you are cross-compiling,
-beware.
-<h4>
-prdtoa.c, prdtoa.h</h4>
-David Gay's portable double-precision floating point to string conversion
-code, with Permission To Use notice included.
-<h4>
-prhash.c, prhash.h</h4>
-Portable, extensible hash tables. These use multiplicative hash for strength
-reduction over division hash, yet with very good key distribution over
-power of two table sizes. Collisions resolve via chaining, so each entry
-burns a malloc and can fragment the heap.
-<h4>
-prlong.c, prlong.h</h4>
-64-bit integer emulation, and compatible macros that use C's long long
-type where it exists (my last company mapped long long to a 128-bit type,
-but no real architecture does 128-bit ints yet).
-<h4>
-jsosdep.h</h4>
-Annoying OS dependencies rationalized into a few "feature-test" macros
-such as <tt>JS_HAVE_LONG_LONG</tt>.
-<h4>
-jsprf.*</h4>
-Portable, buffer-overrun-resistant sprintf and friends. For no good reason
-save lack of time, the %e, %f, and %g formats cause your system's native
-sprintf, rather than <tt>JS_dtoa()</tt>, to be used. This bug doesn't affect
-JSRef, because it uses its own <tt>JS_dtoa()</tt> call in <i>jsnum.c</i>
-to convert from double to string, but it's a bug that we'll fix later,
-and one you should be aware of if you intend to use a <tt>JS_*printf()</tt>&nbsp;
-function with your own floating type arguments - various vendor sprintf's
-mishandle NaN, +/-Inf, and some even print normal floating values inaccurately.
-<h4>
-prmjtime.c, prmjtime.h</h4>
-Time functions. These interfaces are named in a way that makes local vs.
-universal time confusion likely. Caveat emptor, and we're working on it.
-To make matters worse, Java (and therefore JavaScript) uses "local" time
-numbers (offsets from the epoch) in its Date class.
-</body>
-</html>

mozilla/js/src/SpiderMonkey.rsp

@@ -1,12 +0,0 @@
-mozilla/js/src/*
-mozilla/js/src/config/*
-mozilla/js/src/fdlibm/*
-mozilla/js/src/liveconnect/*
-mozilla/js/src/liveconnect/_jni/*
-mozilla/js/src/liveconnect/classes/*
-mozilla/js/src/liveconnect/classes/netscape/*
-mozilla/js/src/liveconnect/classes/netscape/javascript/*
-mozilla/js/src/liveconnect/config/*
-mozilla/js/src/liveconnect/macbuild/*
-mozilla/js/src/liveconnect/macbuild/JavaSession/*
-mozilla/js/src/macbuild/*

mozilla/js/src/config.mk

@@ -1,92 +0,0 @@
-ifdef JS_DIST
-DIST = $(JS_DIST)
-else
-DIST = $(DEPTH)/../../dist/$(OBJDIR)
-endif
-
-# Set os+release dependent make variables
-OS_ARCH         := $(subst /,_,$(shell uname -s))
-
-# Attempt to differentiate between SunOS 5.4 and x86 5.4
-OS_CPUARCH      := $(shell uname -m)
-ifeq ($(OS_CPUARCH),i86pc)
-OS_RELEASE      := $(shell uname -r)_$(OS_CPUARCH)
-else
-ifeq ($(OS_ARCH),AIX)
-OS_RELEASE      := $(shell uname -v).$(shell uname -r)
-else
-OS_RELEASE      := $(shell uname -r)
-endif
-endif
-ifeq ($(OS_ARCH),IRIX64)
-OS_ARCH         := IRIX
-endif
-
-# Virtually all Linux versions are identical.
-# Any distinctions are handled in linux.h
-ifeq ($(OS_ARCH),Linux)
-OS_CONFIG      := Linux_All
-else
-ifeq ($(OS_ARCH),dgux)
-OS_CONFIG      := dgux
-else
-OS_CONFIG       := $(OS_ARCH)$(OS_OBJTYPE)$(OS_RELEASE)
-endif
-endif
-
-ASFLAGS         =
-DEFINES         =
-
-ifeq ($(OS_ARCH), WINNT)
-INSTALL = nsinstall
-CP = cp
-else
-INSTALL	= $(DEPTH)/../../dist/$(OBJDIR)/bin/nsinstall
-CP = cp
-endif
-
-ifdef BUILD_OPT
-OPTIMIZER  = -O
-DEFINES    += -UDEBUG -DNDEBUG -UDEBUG_$(shell whoami)
-OBJDIR_TAG = _OPT
-else
-ifdef USE_MSVC
-OPTIMIZER  = -Zi
-else
-OPTIMIZER  = -g
-endif
-DEFINES    += -DDEBUG -DDEBUG_$(shell whoami)
-OBJDIR_TAG = _DBG
-endif
-
-SO_SUFFIX = so
-
-NS_USE_NATIVE = 1
-
-# Java stuff
-CLASSDIR     = $(DEPTH)/liveconnect/classes
-JAVA_CLASSES = $(patsubst %.java,%.class,$(JAVA_SRCS))
-TARGETS     += $(addprefix $(CLASSDIR)/$(OBJDIR)/$(JARPATH)/, $(JAVA_CLASSES))
-JAVAC        = $(JDK)/bin/javac
-JAVAC_FLAGS  = -classpath "$(CLASSPATH)" -d $(CLASSDIR)/$(OBJDIR)
-ifeq ($(OS_ARCH), WINNT)
-  SEP        = ;
-else
-  SEP        = :
-endif
-CLASSPATH    = $(JDK)/lib/classes.zip$(SEP)$(CLASSDIR)/$(OBJDIR)
-
-include $(DEPTH)/config/$(OS_CONFIG).mk
-
-# Name of the binary code directories
-ifdef BUILD_IDG
-OBJDIR          = $(OS_CONFIG)$(OBJDIR_TAG).OBJD
-else
-OBJDIR          = $(OS_CONFIG)$(OBJDIR_TAG).OBJ
-endif
-VPATH           = $(OBJDIR)
-
-# Automatic make dependencies file
-DEPENDENCIES    = $(OBJDIR)/.md
-
-LCJAR = js14lc30.jar

mozilla/js/src/js.msg

@@ -1,233 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
-	This is the JavaScript error message file.
-
-	The format for each JS error message is:
-
-MSG_DEF(<SYMBOLIC_NAME>, <ERROR_NUMBER>, <ARGUMENT_COUNT>, <EXCEPTION_NAME>,
-	<FORMAT_STRING>)
-
-	where ;
-	<SYMBOLIC_NAME> is a legal C identifer that will be used in the
-	JS engine source.
-
-	<ERROR_NUMBER> is an unique integral value identifying this error.
-
-	<ARGUMENT_COUNT> is an integer literal specifying the total number of
-	replaceable arguments in the following format string.
-
-	<EXCEPTION_NAME> is an exception index from the enum in jsexn.c;
-	JSEXN_NONE for none.  The given exception index will be raised by the
-	engine when the corresponding error occurs.
-
-	<FORMAT_STRING> is a string literal, optionally containing sequences
-	{X} where X  is an integer representing the argument number that will
-	be replaced with a string value when the error is reported.
-
-	e.g.
-
-	MSG_DEF(JSMSG_NOT_A_SUBSPECIES, 73, JSEXN_NONE, 2,
-		"{0} is not a member of the {1} family")
-
-	can be used :
-
-	JS_ReportErrorNumber(JSMSG_NOT_A_SUBSPECIES, "Rhino", "Monkey");
-
-	to report :
-
-	"Rhino is not a member of the Monkey family"
-
-*/
-
-MSG_DEF(JSMSG_NOT_AN_ERROR,             0, 0, JSEXN_NONE, "<Error #0 is reserved>")
-MSG_DEF(JSMSG_NOT_DEFINED,              1, 1, JSEXN_REFERENCEERR, "{0} is not defined")
-MSG_DEF(JSMSG_NO_REG_EXPS,              2, 1, JSEXN_INTERNALERR, "sorry, regular expression are not supported")
-MSG_DEF(JSMSG_MORE_ARGS_NEEDED,         3, 3, JSEXN_NONE, "{0} requires more than {1} argument{2}")
-MSG_DEF(JSMSG_BAD_CHAR,                 4, 1, JSEXN_NONE, "invalid format character {0}")
-MSG_DEF(JSMSG_BAD_TYPE,                 5, 1, JSEXN_NONE, "unknown type {0}")
-MSG_DEF(JSMSG_CANT_LOCK,                6, 0, JSEXN_NONE, "can't lock memory")
-MSG_DEF(JSMSG_CANT_UNLOCK,              7, 0, JSEXN_NONE, "can't unlock memory")
-MSG_DEF(JSMSG_INCOMPATIBLE_PROTO,       8, 3, JSEXN_TYPEERR, "{0}.prototype.{1} called on incompatible {2}")
-MSG_DEF(JSMSG_NO_CONSTRUCTOR,           9, 1, JSEXN_NONE, "{0} has no constructor")
-MSG_DEF(JSMSG_CANT_ALIAS,              10, 3, JSEXN_NONE, "can't alias {0} to {1} in class {2}")
-MSG_DEF(JSMSG_NO_PROTO,                11, 1, JSEXN_INTERNALERR, "sorry, Array.prototype.{0} is not yet implemented")
-MSG_DEF(JSMSG_BAD_SORT_ARG,            12, 0, JSEXN_TYPEERR, "invalid Array.prototype.sort argument")
-MSG_DEF(JSMSG_BAD_ATOMIC_NUMBER,       13, 1, JSEXN_INTERNALERR, "internal error: no index for atom {0}")
-MSG_DEF(JSMSG_TOO_MANY_LITERALS,       14, 0, JSEXN_INTERNALERR, "too many literals")
-MSG_DEF(JSMSG_CANT_WATCH,              15, 1, JSEXN_NONE, "can't watch non-native objects of class {0}")
-MSG_DEF(JSMSG_STACK_UNDERFLOW,         16, 2, JSEXN_INTERNALERR, "internal error compiling {0}: stack underflow at pc {1}")
-MSG_DEF(JSMSG_NEED_DIET,               17, 1, JSEXN_INTERNALERR, "{0} too large")
-MSG_DEF(JSMSG_BAD_CASE,                18, 2, JSEXN_SYNTAXERR, "{0}, line {1}: invalid case expression")
-MSG_DEF(JSMSG_READ_ONLY,               19, 1, JSEXN_ERR, "{0} is read-only")
-MSG_DEF(JSMSG_BAD_FORMAL,              20, 0, JSEXN_SYNTAXERR, "malformed formal parameter")
-MSG_DEF(JSMSG_SAME_FORMAL,             21, 1, JSEXN_NONE, "duplicate formal argument {0}")
-MSG_DEF(JSMSG_NOT_FUNCTION,            22, 1, JSEXN_TYPEERR, "{0} is not a function")
-MSG_DEF(JSMSG_NOT_CONSTRUCTOR,         23, 1, JSEXN_TYPEERR, "{0} is not a constructor")
-MSG_DEF(JSMSG_STACK_OVERFLOW,          24, 1, JSEXN_INTERNALERR, "stack overflow in {0}")
-MSG_DEF(JSMSG_NOT_EXPORTED,            25, 1, JSEXN_NONE, "{0} is not exported")
-MSG_DEF(JSMSG_OVER_RECURSED,           26, 0, JSEXN_INTERNALERR, "too much recursion")
-MSG_DEF(JSMSG_IN_NOT_OBJECT,           27, 0, JSEXN_ERR, "target of 'in' operator must be an object")
-MSG_DEF(JSMSG_BAD_NEW_RESULT,          28, 1, JSEXN_NONE, "invalid new expression result {0}")
-MSG_DEF(JSMSG_BAD_SHARP_DEF,           29, 1, JSEXN_ERR, "invalid sharp variable definition #{0}=")
-MSG_DEF(JSMSG_BAD_SHARP_USE,           30, 1, JSEXN_ERR, "invalid sharp variable use #{0}#")
-MSG_DEF(JSMSG_BAD_INSTANCEOF_RHS,      31, 1, JSEXN_ERR, "invalid instanceof operand {0}")
-MSG_DEF(JSMSG_BAD_BYTECODE,            32, 1, JSEXN_INTERNALERR, "unimplemented JavaScript bytecode {0}")
-MSG_DEF(JSMSG_BAD_RADIX,               33, 1, JSEXN_ERR, "illegal radix {0}")
-MSG_DEF(JSMSG_NAN,                     34, 1, JSEXN_ERR, "{0} is not a number")
-MSG_DEF(JSMSG_CANT_CONVERT,            35, 1, JSEXN_NONE, "can't convert {0} to an integer")
-MSG_DEF(JSMSG_CYCLIC_VALUE,            36, 1, JSEXN_ERR, "cyclic {0} value")
-MSG_DEF(JSMSG_PERMANENT,               37, 1, JSEXN_ERR, "{0} is permanent")
-MSG_DEF(JSMSG_CANT_CONVERT_TO,         38, 2, JSEXN_TYPEERR, "can't convert {0} to {1}")
-MSG_DEF(JSMSG_NO_PROPERTIES,           39, 1, JSEXN_TYPEERR, "{0} has no properties")
-MSG_DEF(JSMSG_CANT_FIND_CLASS,         40, 1, JSEXN_NONE, "can't find class id {0}")
-MSG_DEF(JSMSG_CANT_XDR_CLASS,          41, 1, JSEXN_NONE, "can't XDR class {0}")
-MSG_DEF(JSMSG_BYTECODE_TOO_BIG,        42, 2, JSEXN_INTERNALERR, "bytecode {0} too large (limit {1})")
-MSG_DEF(JSMSG_UNKNOWN_FORMAT,          43, 1, JSEXN_INTERNALERR, "unknown bytecode format {0}")
-MSG_DEF(JSMSG_TOO_MANY_CON_ARGS,       44, 0, JSEXN_SYNTAXERR, "too many constructor arguments")
-MSG_DEF(JSMSG_TOO_MANY_FUN_ARGS,       45, 0, JSEXN_SYNTAXERR, "too many function arguments")
-MSG_DEF(JSMSG_BAD_QUANTIFIER,          46, 1, JSEXN_SYNTAXERR, "invalid quantifier {0}")
-MSG_DEF(JSMSG_MIN_TOO_BIG,             47, 1, JSEXN_SYNTAXERR, "overlarge minimum {0}")
-MSG_DEF(JSMSG_MAX_TOO_BIG,             48, 1, JSEXN_SYNTAXERR, "overlarge maximum {0}")
-MSG_DEF(JSMSG_OUT_OF_ORDER,            49, 1, JSEXN_SYNTAXERR, "maximum {0} less than minimum")
-MSG_DEF(JSMSG_ZERO_QUANTIFIER,         50, 1, JSEXN_SYNTAXERR, "zero quantifier {0}")
-MSG_DEF(JSMSG_UNTERM_QUANTIFIER,       51, 1, JSEXN_SYNTAXERR, "unterminated quantifier {0}")
-MSG_DEF(JSMSG_EMPTY_BEFORE_STAR,       52, 0, JSEXN_SYNTAXERR, "regular expression before * could be empty")
-MSG_DEF(JSMSG_EMPTY_BEFORE_PLUS,       53, 0, JSEXN_SYNTAXERR, "regular expression before + could be empty")
-MSG_DEF(JSMSG_MISSING_PAREN,           54, 1, JSEXN_SYNTAXERR, "unterminated parenthetical {0}")
-MSG_DEF(JSMSG_UNTERM_CLASS,            55, 1, JSEXN_SYNTAXERR, "unterminated character class {0}")
-MSG_DEF(JSMSG_TRAILING_SLASH,          56, 0, JSEXN_SYNTAXERR, "trailing \\ in regular expression")
-MSG_DEF(JSMSG_BAD_CLASS_RANGE,         57, 0, JSEXN_SYNTAXERR, "invalid range in character class")
-MSG_DEF(JSMSG_BAD_FLAG,                58, 1, JSEXN_SYNTAXERR, "invalid regular expression flag {0}")
-MSG_DEF(JSMSG_NO_INPUT,                59, 3, JSEXN_SYNTAXERR, "no input for /{0}/{1}{2}")
-MSG_DEF(JSMSG_CANT_OPEN,               60, 2, JSEXN_NONE, "can't open {0}: {1}")
-MSG_DEF(JSMSG_BAD_STRING_MASK,         61, 1, JSEXN_ERR, "invalid string escape mask {0}")
-MSG_DEF(JSMSG_NO_STRING_PROTO,         62, 1, JSEXN_INTERNALERR, "sorry, String.prototype.{0} is not yet implemented")
-MSG_DEF(JSMSG_END_OF_DATA,             63, 0, JSEXN_NONE, "unexpected end of data")
-MSG_DEF(JSMSG_SEEK_BEYOND_START,       64, 0, JSEXN_NONE, "illegal seek beyond start")
-MSG_DEF(JSMSG_SEEK_BEYOND_END,         65, 0, JSEXN_NONE, "illegal seek beyond end")
-MSG_DEF(JSMSG_END_SEEK,                66, 0, JSEXN_NONE, "illegal end-based seek")
-MSG_DEF(JSMSG_WHITHER_WHENCE,          67, 1, JSEXN_NONE, "unknown seek whence: {0}")
-MSG_DEF(JSMSG_BAD_JVAL_TYPE,           68, 1, JSEXN_NONE, "unknown jsval type {0} for XDR")
-MSG_DEF(JSMSG_PAREN_BEFORE_FORMAL,     69, 0, JSEXN_SYNTAXERR, "missing ( before formal parameters")
-MSG_DEF(JSMSG_MISSING_FORMAL,          70, 0, JSEXN_SYNTAXERR, "missing formal parameter")
-MSG_DEF(JSMSG_PAREN_AFTER_FORMAL,      71, 0, JSEXN_SYNTAXERR, "missing ) after formal parameters")
-MSG_DEF(JSMSG_CURLY_BEFORE_BODY,       72, 0, JSEXN_SYNTAXERR, "missing { before function body")
-MSG_DEF(JSMSG_CURLY_AFTER_BODY,        73, 0, JSEXN_SYNTAXERR, "missing } after function body")
-MSG_DEF(JSMSG_PAREN_BEFORE_COND,       74, 0, JSEXN_SYNTAXERR, "missing ( before condition")
-MSG_DEF(JSMSG_PAREN_AFTER_COND,        75, 0, JSEXN_SYNTAXERR, "missing ) after condition")
-MSG_DEF(JSMSG_NO_IMPORT_NAME,          76, 0, JSEXN_SYNTAXERR, "missing name in import statement")
-MSG_DEF(JSMSG_NAME_AFTER_DOT,          77, 0, JSEXN_SYNTAXERR, "missing name after . operator")
-MSG_DEF(JSMSG_BRACKET_IN_INDEX,        78, 0, JSEXN_SYNTAXERR, "missing ] in index expression")
-MSG_DEF(JSMSG_NO_EXPORT_NAME,          79, 0, JSEXN_SYNTAXERR, "missing name in export statement")
-MSG_DEF(JSMSG_PAREN_BEFORE_SWITCH,     80, 0, JSEXN_SYNTAXERR, "missing ( before switch expression")
-MSG_DEF(JSMSG_PAREN_AFTER_SWITCH,      81, 0, JSEXN_SYNTAXERR, "missing ) after switch expression")
-MSG_DEF(JSMSG_CURLY_BEFORE_SWITCH,     82, 0, JSEXN_SYNTAXERR, "missing { before switch body")
-MSG_DEF(JSMSG_COLON_AFTER_CASE,        83, 0, JSEXN_SYNTAXERR, "missing : after case label")
-MSG_DEF(JSMSG_WHILE_AFTER_DO,          84, 0, JSEXN_SYNTAXERR, "missing while after do-loop body")
-MSG_DEF(JSMSG_PAREN_AFTER_FOR,         85, 0, JSEXN_SYNTAXERR, "missing ( after for")
-MSG_DEF(JSMSG_SEMI_AFTER_FOR_INIT,     86, 0, JSEXN_SYNTAXERR, "missing ; after for-loop initializer")
-MSG_DEF(JSMSG_SEMI_AFTER_FOR_COND,     87, 0, JSEXN_SYNTAXERR, "missing ; after for-loop condition")
-MSG_DEF(JSMSG_PAREN_AFTER_FOR_CTRL,    88, 0, JSEXN_SYNTAXERR, "missing ) after for-loop control")
-MSG_DEF(JSMSG_CURLY_BEFORE_TRY,        89, 0, JSEXN_SYNTAXERR, "missing { before try block")
-MSG_DEF(JSMSG_CURLY_AFTER_TRY,         90, 0, JSEXN_SYNTAXERR, "missing } after try block")
-MSG_DEF(JSMSG_PAREN_BEFORE_CATCH,      91, 0, JSEXN_SYNTAXERR, "missing ( before catch")
-MSG_DEF(JSMSG_CATCH_IDENTIFIER,        92, 0, JSEXN_SYNTAXERR, "missing identifier in catch")
-MSG_DEF(JSMSG_PAREN_AFTER_CATCH,       93, 0, JSEXN_SYNTAXERR, "missing ) after catch")
-MSG_DEF(JSMSG_CURLY_BEFORE_CATCH,      94, 0, JSEXN_SYNTAXERR, "missing { before catch block")
-MSG_DEF(JSMSG_CURLY_AFTER_CATCH,       95, 0, JSEXN_SYNTAXERR, "missing } after catch block")
-MSG_DEF(JSMSG_CURLY_BEFORE_FINALLY,    96, 0, JSEXN_SYNTAXERR, "missing { before finally block")
-MSG_DEF(JSMSG_CURLY_AFTER_FINALLY,     97, 0, JSEXN_SYNTAXERR, "missing } after finally block")
-MSG_DEF(JSMSG_CATCH_OR_FINALLY,        98, 0, JSEXN_SYNTAXERR, "missing catch or finally after try")
-MSG_DEF(JSMSG_PAREN_BEFORE_WITH,       99, 0, JSEXN_SYNTAXERR, "missing ( before with-statement object")
-MSG_DEF(JSMSG_PAREN_AFTER_WITH,       100, 0, JSEXN_SYNTAXERR, "missing ) after with-statement object")
-MSG_DEF(JSMSG_CURLY_IN_COMPOUND,      101, 0, JSEXN_SYNTAXERR, "missing } in compound statement")
-MSG_DEF(JSMSG_NO_VARIABLE_NAME,       102, 0, JSEXN_SYNTAXERR, "missing variable name")
-MSG_DEF(JSMSG_COLON_IN_COND,          103, 0, JSEXN_SYNTAXERR, "missing : in conditional expression")
-MSG_DEF(JSMSG_PAREN_AFTER_ARGS,       104, 0, JSEXN_SYNTAXERR, "missing ) after argument list")
-MSG_DEF(JSMSG_BRACKET_AFTER_LIST,     105, 0, JSEXN_SYNTAXERR, "missing ] after element list")
-MSG_DEF(JSMSG_COLON_AFTER_ID,         106, 0, JSEXN_SYNTAXERR, "missing : after property id")
-MSG_DEF(JSMSG_CURLY_AFTER_LIST,       107, 0, JSEXN_SYNTAXERR, "missing } after property list")
-MSG_DEF(JSMSG_PAREN_IN_PAREN,         108, 0, JSEXN_SYNTAXERR, "missing ) in parenthetical")
-MSG_DEF(JSMSG_SEMI_BEFORE_STMNT,      109, 0, JSEXN_SYNTAXERR, "missing ; before statement")
-MSG_DEF(JSMSG_NO_RETURN_VALUE,        110, 1, JSEXN_TYPEERR, "function {0} does not always return a value")
-MSG_DEF(JSMSG_DUPLICATE_FORMAL,       111, 1, JSEXN_TYPEERR, "duplicate formal argument {0}")
-MSG_DEF(JSMSG_EQUAL_AS_ASSIGN,        112, 1, JSEXN_NONE, "test for equality (==) mistyped as assignment (=)?{0}")
-MSG_DEF(JSMSG_BAD_IMPORT,             113, 0, JSEXN_SYNTAXERR, "invalid import expression")
-MSG_DEF(JSMSG_TOO_MANY_DEFAULTS,      114, 0, JSEXN_SYNTAXERR, "more than one switch default")
-MSG_DEF(JSMSG_TOO_MANY_CASES,         115, 0, JSEXN_INTERNALERR, "too many switch cases")
-MSG_DEF(JSMSG_BAD_SWITCH,             116, 0, JSEXN_SYNTAXERR, "invalid switch statement")
-MSG_DEF(JSMSG_BAD_FOR_LEFTSIDE,       117, 0, JSEXN_SYNTAXERR, "invalid for/in left-hand side")
-MSG_DEF(JSMSG_CATCH_AFTER_GENERAL,    118, 0, JSEXN_SYNTAXERR, "catch after unconditional catch")
-MSG_DEF(JSMSG_CATCH_WITHOUT_TRY,      119, 0, JSEXN_SYNTAXERR, "catch without try")
-MSG_DEF(JSMSG_FINALLY_WITHOUT_TRY,    120, 0, JSEXN_SYNTAXERR, "finally without try")
-MSG_DEF(JSMSG_LABEL_NOT_FOUND,        121, 0, JSEXN_SYNTAXERR, "label not found")
-MSG_DEF(JSMSG_TOUGH_BREAK,            122, 0, JSEXN_SYNTAXERR, "invalid break")
-MSG_DEF(JSMSG_BAD_CONTINUE,           123, 0, JSEXN_SYNTAXERR, "invalid continue")
-MSG_DEF(JSMSG_BAD_RETURN,             124, 0, JSEXN_SYNTAXERR, "invalid return")
-MSG_DEF(JSMSG_BAD_LABEL,              125, 0, JSEXN_SYNTAXERR, "invalid label")
-MSG_DEF(JSMSG_DUPLICATE_LABEL,        126, 0, JSEXN_SYNTAXERR, "duplicate label")
-MSG_DEF(JSMSG_VAR_HIDES_ARG,          127, 1, JSEXN_TYPEERR, "variable {0} hides argument")
-MSG_DEF(JSMSG_BAD_VAR_INIT,           128, 0, JSEXN_SYNTAXERR, "invalid variable initialization")
-MSG_DEF(JSMSG_BAD_LEFTSIDE_OF_ASS,    129, 0, JSEXN_SYNTAXERR, "invalid assignment left-hand side")
-MSG_DEF(JSMSG_BAD_OPERAND,            130, 1, JSEXN_SYNTAXERR, "invalid {0} operand")
-MSG_DEF(JSMSG_BAD_PROP_ID,            131, 0, JSEXN_SYNTAXERR, "invalid property id")
-MSG_DEF(JSMSG_RESERVED_ID,            132, 1, JSEXN_SYNTAXERR, "{0} is a reserved identifier")
-MSG_DEF(JSMSG_SYNTAX_ERROR,           133, 0, JSEXN_SYNTAXERR, "syntax error")
-MSG_DEF(JSMSG_BAD_SHARP_VAR_DEF,      134, 0, JSEXN_SYNTAXERR, "invalid sharp variable definition")
-MSG_DEF(JSMSG_BAD_PROTOTYPE,          135, 1, JSEXN_ERR, "'prototype' property of {0} is not an object")
-MSG_DEF(JSMSG_MISSING_EXPONENT,       136, 0, JSEXN_SYNTAXERR, "missing exponent")
-MSG_DEF(JSMSG_OUT_OF_MEMORY,          137, 0, JSEXN_ERR, "out of memory")
-MSG_DEF(JSMSG_UNTERMINATED_STRING,    138, 0, JSEXN_SYNTAXERR, "unterminated string literal")
-MSG_DEF(JSMSG_NESTED_COMMENT,         139, 0, JSEXN_SYNTAXERR, "nested comment")
-MSG_DEF(JSMSG_UNTERMINATED_COMMENT,   140, 0, JSEXN_SYNTAXERR, "unterminated comment")
-MSG_DEF(JSMSG_UNTERMINATED_REGEXP,    141, 0, JSEXN_SYNTAXERR, "unterminated regular expression literal")
-MSG_DEF(JSMSG_BAD_REGEXP_FLAG,        142, 0, JSEXN_SYNTAXERR, "invalid flag after regular expression")
-MSG_DEF(JSMSG_SHARPVAR_TOO_BIG,       143, 0, JSEXN_SYNTAXERR, "overlarge sharp variable number")
-MSG_DEF(JSMSG_ILLEGAL_CHARACTER,      144, 0, JSEXN_SYNTAXERR, "illegal character")
-MSG_DEF(JSMSG_BAD_OCTAL,              145, 1, JSEXN_NONE, "{0} is not a legal ECMA-262 numeric constant")
-MSG_DEF(JSMSG_BAD_INDIRECT_CALL,      146, 1, JSEXN_EVALERR, "function {0} must be called directly, and not by way of a function of another name.")
-MSG_DEF(JSMSG_UNCAUGHT_EXCEPTION,     147, 1, JSEXN_NONE, "uncaught exception: {0}")
-MSG_DEF(JSMSG_INVALID_BACKREF,        148, 0, JSEXN_SYNTAXERR, "non-octal digit in an escape sequence that doesn't match a back-reference")
-MSG_DEF(JSMSG_BAD_BACKREF,            149, 0, JSEXN_SYNTAXERR, "back-reference exceeds number of capturing parentheses")
-MSG_DEF(JSMSG_PRECISION_RANGE,        150, 1, JSEXN_RANGEERR, "precision {0} out of range")
-MSG_DEF(JSMSG_BAD_GETTER_OR_SETTER,   151, 1, JSEXN_SYNTAXERR, "invalid {0} usage")
-MSG_DEF(JSMSG_BAD_ARRAY_LENGTH,       152, 0, JSEXN_RANGEERR, "invalid array length")
-MSG_DEF(JSMSG_CANT_DESCRIBE_PROPS,    153, 1, JSEXN_NONE, "can't describe non-native properties of class {0}")
-MSG_DEF(JSMSG_BAD_APPLY_ARGS,         154, 0, JSEXN_TYPEERR, "second argument to Function.prototype.apply must be an array")
-MSG_DEF(JSMSG_REDECLARED_VAR,         155, 2, JSEXN_TYPEERR, "redeclaration of {0} {1}")
-MSG_DEF(JSMSG_UNDECLARED_VAR,         156, 1, JSEXN_TYPEERR, "assignment to undeclared variable {0}")
-MSG_DEF(JSMSG_ANON_NO_RETURN_VALUE,   157, 0, JSEXN_TYPEERR, "anonymous function does not always return a value")
-MSG_DEF(JSMSG_DEPRECATED_USAGE,       158, 1, JSEXN_REFERENCEERR, "deprecated {0} usage")

mozilla/js/src/js3240.rc

@@ -1,79 +0,0 @@
-//Microsoft Developer Studio generated resource script.
-//
-#include "resource.h"
-
-#define APSTUDIO_READONLY_SYMBOLS
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 2 resource.
-//
-#include "winver.h"
-
-/////////////////////////////////////////////////////////////////////////////
-#undef APSTUDIO_READONLY_SYMBOLS
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Version
-//
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION 4,0,0,0
- PRODUCTVERSION 4,0,0,0
- FILEFLAGSMASK 0x3fL
-#ifdef _DEBUG
- FILEFLAGS 0x1L
-#else
- FILEFLAGS 0x0L
-#endif
- FILEOS 0x10004L
- FILETYPE 0x2L
- FILESUBTYPE 0x0L
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904e4"
-        BEGIN
-            VALUE "CompanyName", "Netscape Communications Corporation\0"
-            VALUE "FileDescription", "Netscape 32-bit JavaScript Module\0"
-            VALUE "FileVersion", "4.0\0"
-            VALUE "InternalName", "JS3240\0"
-            VALUE "LegalCopyright", "Copyright Netscape Communications. 1994-96\0"
-            VALUE "LegalTrademarks", "Netscape, Mozilla\0"
-            VALUE "OriginalFilename", "js3240.dll\0"
-            VALUE "ProductName", "NETSCAPE\0"
-            VALUE "ProductVersion", "4.0\0"
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1252
-    END
-END
-
-#ifdef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// TEXTINCLUDE
-//
-
-1 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "resource.h\0"
-END
-
-2 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "#include ""winver.h""\r\n"
-    "\0"
-END
-
-3 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "\r\n"
-    "\0"
-END
-
-#endif    // APSTUDIO_INVOKED
-
-/////////////////////////////////////////////////////////////////////////////

mozilla/js/src/jsOS240.def

@@ -1,639 +0,0 @@
-; The contents of this file are subject to the Netscape Public
-; License Version 1.1 (the "License"); you may not use this file
-; except in compliance with the License. You may obtain a copy of
-; the License at http://www.mozilla.org/NPL/
-;
-; Software distributed under the License is distributed on an "AS
-; IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
-; implied. See the License for the specific language governing
-; rights and limitations under the License.
-;
-; The Original Code is Mozilla Communicator client code, released
-; March 31, 1998.
-;
-; The Initial Developer of the Original Code is Netscape
-; Communications Corporation.  Portions created by Netscape are
-; Copyright (C) 1998 Netscape Communications Corporation. All
-; Rights Reserved.
-;
-; Contributor(s): 
-;
-; Alternatively, the contents of this file may be used under the
-; terms of the GNU Public License (the "GPL"), in which case the
-; provisions of the GPL are applicable instead of those above.
-; If you wish to allow use of your version of this file only
-; under the terms of the GPL and not to allow others to use your
-; version of this file under the NPL, indicate your decision by
-; deleting the provisions above and replace them with the notice
-; and other provisions required by the GPL.  If you do not delete
-; the provisions above, a recipient may use your version of this
-; file under either the NPL or the GPL.
-
-LIBRARY JS3240 INITINSTANCE TERMINSTANCE
-PROTMODE
-
-DESCRIPTION 'Netscape OS/2 JavaScript Library'
-
-
-CODE    LOADONCALL MOVEABLE DISCARDABLE
-DATA    PRELOAD MOVEABLE MULTIPLE NONSHARED
-
-
-EXPORTS
-;====================== win16 exports these at least... ===========
-;	JS_Init				= JS_Init		@2
-;	JS_Finish			= JS_Finish		@3
-;	JS_GetNaNValue
-;	JS_GetNegativeInfinityValue
-;	JS_GetPositiveInfinityValue
-;	JS_GetEmptyStringValue
-;	JS_ConvertValue
-;	JS_ValueToObject
-;	JS_ValueToFunction
-;	JS_ValueToString
-;	JS_ValueToNumber
-;	JS_ValueToBoolean
-;	JS_TypeOfValue
-;	JS_GetTypeName
-;	JS_Lock
-;	JS_Unlock
-;	JS_NewContext
-;	JS_DestroyContext
-;	JS_ContextIterator
-;	JS_GetGlobalObject
-;	JS_SetGlobalObject
-;	JS_InitStandardClasses
-;;	JS_GetStaticLink
-;	JS_malloc
-;	JS_realloc
-;	JS_free
-;	JS_strdup
-;	JS_NewDouble
-;	JS_NewDoubleValue
-;	JS_AddRoot
-;	JS_RemoveRoot
-;	JS_LockGCThing
-;	JS_UnlockGCThing
-;	JS_GC
-;	JS_PropertyStub
-;	JS_EnumerateStub
-;	JS_ResolveStub
-;	JS_ConvertStub
-;	JS_FinalizeStub
-;	JS_InitClass
-;	JS_GetClass
-;	JS_InstanceOf
-;	JS_GetPrivate
-;	JS_SetPrivate
-;	JS_GetInstancePrivate
-;	JS_GetPrototype
-;	JS_GetParent
-;	JS_SetParent
-;	JS_GetConstructor
-;	JS_NewObject
-;	JS_DefineObject
-;	JS_DefineConstDoubles
-;	JS_DefineProperties
-;	JS_DefineProperty
-;	JS_DefinePropertyWithTinyId
-;	JS_AliasProperty
-;	JS_LookupProperty
-;	JS_GetProperty
-;	JS_SetProperty
-;	JS_DeleteProperty
-;	JS_NewArrayObject
-;	JS_DefineElement
-;	JS_AliasElement
-;	JS_LookupElement
-;	JS_GetElement
-;	JS_SetElement
-;	JS_DeleteElement
-;	JS_ClearScope
-;	JS_NewFunction
-;	JS_GetFunctionObject
-;	JS_GetFunctionName
-;	JS_DefineFunctions
-;	JS_DefineFunction
-;	JS_CompileScript
-;	JS_DestroyScript
-;	JS_CompileFunction
-;	JS_DecompileScript
-;	JS_DecompileFunction
-;	JS_DecompileFunctionBody
-;	JS_ExecuteScript
-;	JS_EvaluateScript
-;	JS_CallFunction
-;	JS_CallFunctionName
-;	JS_CallFunctionValue
-;	JS_SetBranchCallback
-;	JS_IsRunning
-;	JS_NewString
-;	JS_NewStringCopyN
-;	JS_NewStringCopyZ
-;	JS_InternString
-;	JS_GetStringBytes
-;	JS_GetStringLength
-;	JS_CompareStrings
-;	JS_ReportError
-;	JS_ReportOutOfMemory
-;	JS_SetErrorReporter
-;	JS_NewRegExpObject
-;	JS_SetRegExpInput
-;	JS_ClearRegExpStatics
-;=================================================
-
-
-;00001:jsstr (OFFSET:0x00002e17, SIZE:0x0000ae17):
-; - Public Definitions:
-;     js_EmptySubString
-;     js_CompareStrings
-;     js_HashString
-;     js_ValueToString
-;     js_StringToObject
-;     js_FinalizeString
-;     js_NewStringCopyZ
-;     js_NewString
-;     js_InitStringClass
-;     js_NewStringCopyN
-;     js_BoyerMooreHorspool
-;
-;
-;00002:jsscript (OFFSET:0x0000dc2e, SIZE:0x00003abb):
-; - Public Definitions:
-;     js_LineNumberToPC
-;     js_PCToLineNumber
-;     js_GetSrcNote
-;     js_DestroyScript
-;     js_NewScript
-;
-;
-;00003:jsscope (OFFSET:0x000116e9, SIZE:0x00004f82):
-; - Public Definitions:
-;     js_hash_scope_ops
-;     js_list_scope_ops
-;     js_DestroyProperty
-;     js_NewProperty
-;     js_IdToValue
-;     js_HashValue
-;     js_DestroyScope
-;     js_MutateScope
-;     js_DropScope
-;     js_HoldScope
-;     js_NewScope
-;     js_GetMutableScope
-;     js_HoldProperty
-;     js_DropProperty
-;
-;
-;00004:jsscan (OFFSET:0x0001666b, SIZE:0x00008890):
-; - Public Definitions:
-;     js_MatchToken
-;     js_FlushNewlines
-;     js_PeekTokenSameLine
-;     js_UngetToken
-;     js_GetToken
-;     js_PeekToken
-;     js_ReportCompileError
-      js_CloseTokenStream
-      js_NewBufferTokenStream
-;     js_NewTokenStream
-;     js_InitScanner
-;
-;
-;00005:jsregexp (OFFSET:0x0001eefb, SIZE:0x0000eee4):
-; - Public Definitions:
-;     js_RegExpClass
-;     reopsize
-;     js_NewRegExpObject
-;     js_InitRegExpClass
-;     js_FreeRegExpStatics
-;     js_InitRegExpStatics
-;     js_ExecuteRegExp
-;     js_NewRegExpOpt
-;     js_DestroyRegExp
-;     js_NewRegExp
-;
-;
-;00006:jsparse (OFFSET:0x0002dddf, SIZE:0x00010b71):
-; - Public Definitions:
-;     js_ParseFunctionBody
-      js_Parse
-;
-;
-;00007:jsopcode (OFFSET:0x0003e950, SIZE:0x0000d362):
-; - Public Definitions:
-;     js_EscapeMap
-;     js_NumCodeSpecs
-;     js_CodeSpec
-;     js_incop_str
-;     js_true_str
-;     js_false_str
-;     js_this_str
-;     js_null_str
-;     js_void_str
-;     js_typeof_str
-;     js_delete_str
-;     js_new_str
-;     js_ValueToSource
-;     js_DecompileScript
-;     js_DecompileCode
-;     js_DecompileFunction
-;     js_puts
-;     js_printf
-;     js_GetPrinterOutput
-;     js_DestroyPrinter
-;     js_NewPrinter
-;     js_EscapeString
-;     js_Disassemble1
-;     js_Disassemble
-;
-;00008:jsobj (OFFSET:0x0004bcb2, SIZE:0x000090a4):
-; - Public Definitions:
-;     js_WithClass
-;     js_ObjectClass
-;     js_TryValueOf
-;     js_ValueToNonNullObject
-;     js_TryMethod
-;     js_ObjectToString
-;     js_SetClassPrototype
-;     js_DeleteProperty2
-;     js_DeleteProperty
-;     js_SetProperty
-;     js_GetProperty
-;     js_FindVariableScope
-;     js_FindVariable
-;     js_FindProperty
-;     js_LookupProperty
-;     js_DefineProperty
-;     js_FreeSlot
-;     js_AllocSlot
-;     js_FinalizeObject
-;     js_GetClassPrototype
-;     js_NewObject
-;     js_InitObjectClass
-;     js_ValueToObject
-;     js_obj_toString
-;     js_SetSlot
-;     js_GetSlot
-;
-;
-;00009:jsnum (OFFSET:0x00054d56, SIZE:0x00004f29):
-; - Public Definitions:
-;     js_ValueToInt32
-;     js_NumberToObject
-;     js_FinalizeDouble
-;     js_InitNumberClass
-;     js_NumberToString
-;     js_NewDoubleValue
-;     js_NewDouble
-;     js_ValueToNumber
-;
-;
-;00010:jsmath (OFFSET:0x00059c7f, SIZE:0x000054b6):
-; - Public Definitions:
-;     js_InitMathClass
-;
-;
-;00011:jsjava (OFFSET:0x0005f135, SIZE:0x00022aad):
-; - Public Definitions:
-;     js_Hooks
-;     MojaSrcLog
-;     finalizeTask
-      JSJ_FindCurrentJSContext
-;     JSJ_GetPrincipals
-      JSJ_IsSafeMethod
-      JSJ_InitContext
-      JSJ_Init
-      js_JSErrorToJException
-      js_JavaErrorReporter
-      js_RemoveReflection
-      js_ReflectJObjectToJSObject
-      js_convertJObjectToJSValue
-      js_convertJSValueToJObject
-      js_ReflectJSObjectToJObject
-;     js_ReflectJClassToJSObject
-      JSJ_ExitJS
-      JSJ_EnterJS
-      JSJ_CurrentContext
-      JSJ_IsEnabled
-;added in GA code - DSR70297
-      JSJ_Finish
-      JSJ_IsCalledFromJava
-      js_GetJSPrincipalsFromJavaCaller
-
-;
-;
-;00012:jsinterp (OFFSET:0x00081be2, SIZE:0x00012274):
-; - Public Definitions:
-;     js_Call
-;     js_Interpret
-;     js_SetLocalVariable
-;     js_GetLocalVariable
-;     js_SetArgument
-;     js_GetArgument
-;     js_FlushPropertyCacheByProp
-;     js_FlushPropertyCache
-;
-;
-;00013:jsgc (OFFSET:0x00093e56, SIZE:0x00004f8d):
-; - Public Definitions:
-;     js_ForceGC
-;     js_UnlockGCThing
-;     js_LockGCThing
-;     js_GC
-;     js_AllocGCThing
-;     js_RemoveRoot
-;     js_AddRoot
-;     js_FinishGC
-;     js_InitGC
-;
-;
-;00014:jsfun (OFFSET:0x00098de3, SIZE:0x0000977c):
-; - Public Definitions:
-;     js_FunctionClass
-;     js_ClosureClass
-;     js_CallClass
-;     js_DefineFunction
-;     js_NewFunction
-;     js_InitCallAndClosureClasses
-;     js_InitFunctionClass
-;     js_ValueToFunction
-;     js_SetCallVariable
-;     js_GetCallVariable
-;     js_PutCallObject
-;     js_GetCallObject
-;
-;
-;00015:jsemit (OFFSET:0x000a255f, SIZE:0x000077be):
-; - Public Definitions:
-;     js_SrcNoteName
-;     js_SrcNoteArity
-      js_FinishTakingSrcNotes
-;     js_MoveSrcNotes
-;     js_GetSrcNoteOffset
-;     js_BumpSrcNoteDelta
-;     js_NewSrcNote3
-;     js_NewSrcNote2
-;     js_PopStatement
-;     js_EmitContinue
-;     js_EmitBreak
-;     js_SetSrcNoteOffset
-;     js_NewSrcNote
-;     js_PushStatement
-;     js_MoveCode
-;     js_SetJumpOffset
-;     js_Emit3
-;     js_Emit2
-;     js_Emit1
-;     js_UpdateDepth
-;     js_SrcNoteLength
-;     js_CancelLastOpcode
-      js_InitCodeGenerator
-;
-;
-;00016:jsdbgapi (OFFSET:0x000a9d1d, SIZE:0x000057db):
-; - Public Definitions:
-;     js_watchpoint_list
-;     js_trap_list
-;     JS_SetAnnotationInFrame
-;     JS_GetAnnotationFromFrame
-;     JS_GetJSPrincipalArrayFromFrame
-;     JS_NextJSFrame
-;     JS_InitJSFrameIterator
-      JS_LineNumberToPC
-      JS_PCToLineNumber
-      JS_ClearAllWatchPoints
-      JS_ClearWatchPoint
-      JS_SetWatchPoint
-      JS_HandleTrap
-      JS_ClearAllTraps
-      JS_ClearScriptTraps
-      JS_ClearTrap
-      JS_GetTrapOpcode
-      JS_SetTrap
-;DSR070297 - added in GA code
-      JS_FrameIterator
-      JS_GetFrameAnnotation
-      JS_GetFramePrincipalArray
-      JS_GetFrameScript
-      JS_GetScriptFilename
-      JS_SetFrameAnnotation
-      JS_GetFramePC
-      JS_GetFunctionScript
-
-;
-;
-;00017:jsdate (OFFSET:0x000af4f8, SIZE:0x00009a8e):
-; - Public Definitions:
-      js_DateGetSeconds
-      js_DateGetMinutes
-      js_DateGetHours
-      js_DateGetDate
-      js_DateGetMonth
-      js_DateGetYear
-      js_NewDateObject
-;     js_InitDateClass
-;
-;
-;00018:jscntxt (OFFSET:0x000b8f86, SIZE:0x00003732):
-; - Public Definitions:
-;     js_InterpreterHooks
-;     js_ReportIsNotDefined
-;     js_ReportErrorAgain
-;     js_ReportErrorVA
-;     js_ContextIterator
-;     js_DestroyContext
-;     js_NewContext
-;     js_SetInterpreterHooks
-;
-;
-;00019:jsbool (OFFSET:0x000bc6b8, SIZE:0x00003375):
-; - Public Definitions:
-;     js_BooleanToString
-;     js_BooleanToObject
-;     js_InitBooleanClass
-;     js_ValueToBoolean
-;
-;
-;00020:jsatom (OFFSET:0x000bfa2d, SIZE:0x000058d0):
-; - Public Definitions:
-;     js_valueOf_str
-;     js_toString_str
-;     js_length_str
-;     js_eval_str
-;     js_constructor_str
-;     js_class_prototype_str
-;     js_assign_str
-;     js_anonymous_str
-;     js_Object_str
-;     js_Array_str
-;     js_type_str
-;     js_DropUnmappedAtoms
-      js_FreeAtomMap
-      js_InitAtomMap
-;     js_GetAtom
-;     js_DropAtom
-;     js_IndexAtom
-;     js_ValueToStringAtom
-;     js_AtomizeString
-;     js_AtomizeDouble
-;     js_AtomizeInt
-;     js_AtomizeBoolean
-;     js_AtomizeObject
-;     js_HoldAtom
-;     js_MarkAtomState
-;     js_FreeAtomState
-;     js_Atomize
-;     js_InitAtomState
-;
-;
-;00021:jsarray (OFFSET:0x000c52fd, SIZE:0x00007c86):
-; - Public Definitions:
-;     js_ArrayClass
-;     js_SetArrayLength
-;     js_GetArrayLength
-;     js_InitArrayClass
-;     js_NewArrayObject
-;     PR_qsort
-;
-;
-;00022:jsapi (OFFSET:0x000ccf83, SIZE:0x0000de8c):
-; - Public Definitions:
-      JS_ClearRegExpStatics
-      JS_SetRegExpInput
-      JS_NewRegExpObject
-      JS_SetErrorReporter
-      JS_CompareStrings
-      JS_GetStringLength
-      JS_GetStringBytes
-      JS_InternString
-      JS_NewStringCopyZ
-      JS_NewStringCopyN
-      JS_NewString
-      JS_IsRunning
-      JS_SetBranchCallback
-      JS_CallFunctionValue
-      JS_CallFunctionName
-      JS_CallFunction
-      JS_EvaluateScriptForPrincipals
-      JS_EvaluateScript
-      JS_ExecuteScript
-      JS_DecompileFunctionBody
-      JS_DecompileFunction
-      JS_DecompileScript
-      JS_CompileFunctionForPrincipals
-      JS_CompileFunction
-      JS_DestroyScript
-      JS_CompileScriptForPrincipals
-      JS_CompileScript
-      JS_DefineFunction
-      JS_GetFunctionName
-      JS_GetFunctionObject
-      JS_NewFunction
-      JS_ClearScope
-      JS_DeleteElement
-      JS_SetElement
-      JS_GetElement
-      JS_LookupElement
-      JS_AliasElement
-      JS_DefineElement
-      JS_SetArrayLength
-      JS_GetArrayLength
-      JS_NewArrayObject
-      JS_DeleteProperty
-      JS_SetProperty
-      JS_GetProperty
-      JS_LookupProperty
-      JS_AliasProperty
-      JS_DefinePropertyWithTinyId
-      JS_DefineProperty
-      JS_DefineConstDoubles
-      JS_DefineObject
-      JS_NewObject
-      JS_GetConstructor
-      JS_SetParent
-      JS_GetParent
-      JS_SetPrototype
-      JS_GetPrototype
-      JS_GetInstancePrivate
-      JS_SetPrivate
-      JS_GetPrivate
-      JS_InstanceOf
-      JS_GetClass
-      JS_DefineFunctions
-      JS_DefineProperties
-      JS_InitClass
-      JS_FinalizeStub
-      JS_ConvertStub
-      JS_ResolveStub
-      JS_EnumerateStub
-      JS_PropertyStub
-      JS_GC
-      JS_UnlockGCThing
-      JS_LockGCThing
-      JS_RemoveRoot
-      JS_AddRoot
-      JS_NewDoubleValue
-      JS_NewDouble
-      JS_strdup
-      JS_free
-      JS_realloc
-      JS_ReportOutOfMemory
-      JS_malloc
-      JS_GetScopeChain
-      JS_InitStandardClasses
-      JS_SetGlobalObject
-      JS_GetGlobalObject
-      JS_SetVersion
-      JS_GetVersion
-      JS_ContextIterator
-      JS_GetTaskState
-      JS_DestroyContext
-      JS_NewContext
-      JS_Unlock
-      JS_Lock
-      JS_Finish
-      JS_Init
-      JS_GetTypeName
-      JS_TypeOfValue
-      JS_ValueToBoolean
-      JS_ValueToInt32
-      JS_ValueToNumber
-      JS_ValueToString
-      JS_ValueToFunction
-      JS_ValueToObject
-      JS_ReportError
-      JS_ConvertValue
-      JS_GetEmptyStringValue
-      JS_GetPositiveInfinityValue
-      JS_GetNegativeInfinityValue
-      JS_GetNaNValue
-;DSR062897 - added for GA code
-      JS_MaybeGC
-      JS_GetScriptPrincipals
-      JS_IsAssigning
-      JS_SetCharSetInfo
-;
-;
-;00023:prmjtime (OFFSET:0x000dae0f, SIZE:0x00008986):
-; - Public Definitions:
-      PRMJ_FormatTimeUSEnglish
-      PRMJ_gmtime
-      PRMJ_FormatTime
-      PRMJ_mktime
-      PRMJ_ComputeTime
-      PRMJ_localtime
-      PRMJ_ExplodeTime
-      PRMJ_ToLocal
-      PRMJ_ToGMT
-      PRMJ_NowLocal
-      PRMJ_DSTOffset
-      PRMJ_NowS
-      PRMJ_NowMS
-      PRMJ_Now
-      PRMJ_ToExtendedTime
-      PRMJ_ToBaseTime
-      PRMJ_setDST
-      PRMJ_LocalGMTDifference
-
-

mozilla/js/src/jsarena.c

@@ -1,352 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * Lifetime-based fast allocation, inspired by much prior art, including
- * "Fast Allocation and Deallocation of Memory Based on Object Lifetimes"
- * David R. Hanson, Software -- Practice and Experience, Vol. 20(1).
- */
-#include "jsstddef.h"
-#include <stdlib.h>
-#include <string.h>
-#include "jstypes.h"
-#include "jsbit.h"
-#include "jsarena.h" /* Added by JSIFY */
-#include "jsutil.h" /* Added by JSIFY */
-
-#ifdef JS_THREADSAFE
-extern int js_CompareAndSwap(jsword *, jsword, jsword);
-#endif
-
-static JSArena *arena_freelist;
-
-#ifdef JS_ARENAMETER
-static JSArenaStats *arena_stats_list;
-
-#define COUNT(pool,what)  (pool)->stats.what++
-#else
-#define COUNT(pool,what)  /* nothing */
-#endif
-
-#define JS_ARENA_DEFAULT_ALIGN  sizeof(double)
-
-JS_PUBLIC_API(void)
-JS_InitArenaPool(JSArenaPool *pool, const char *name, JSUint32 size, JSUint32 align)
-{
-    if (align == 0)
-	align = JS_ARENA_DEFAULT_ALIGN;
-    pool->mask = JS_BITMASK(JS_CeilingLog2(align));
-    pool->first.next = NULL;
-    pool->first.base = pool->first.avail = pool->first.limit =
-	(jsuword)JS_ARENA_ALIGN(pool, &pool->first + 1);
-    pool->current = &pool->first;
-    pool->arenasize = size;
-#ifdef JS_ARENAMETER
-    memset(&pool->stats, 0, sizeof pool->stats);
-    pool->stats.name = strdup(name);
-    pool->stats.next = arena_stats_list;
-    arena_stats_list = &pool->stats;
-#endif
-}
-
-JS_PUBLIC_API(void *)
-JS_ArenaAllocate(JSArenaPool *pool, JSUint32 nb)
-{
-    JSArena **ap, *a, *b;
-#ifdef JS_THREADSAFE
-    JSArena *c;
-#endif
-    JSUint32 sz;
-    void *p;
-
-    JS_ASSERT((nb & pool->mask) == 0);
-#if defined(XP_PC) && !defined(_WIN32)
-    if (nb >= 60000U)
-	return 0;
-#endif  /* WIN16 */
-    ap = &arena_freelist;
-    for (a = pool->current; a->avail + nb > a->limit; pool->current = a) {
-        if (a->next) {                          /* move to next arena */
-            a = a->next;
-	    continue;
-        }
-	while ((b = *ap) != NULL) {		/* reclaim a free arena */
-	    if (b->limit - b->base == pool->arenasize) {
-#ifdef JS_THREADSAFE
-		do {
-                    b = *ap;
-		    c = b->next;
-		} while (!js_CompareAndSwap((jsword *)ap,(jsword)b,(jsword)c));
-#else
-		*ap = b->next;
-#endif
-		b->next = NULL;
-		a = a->next = b;
-		COUNT(pool, nreclaims);
-		goto claim;
-	    }
-	    ap = &b->next;
-	}
-	sz = JS_MAX(pool->arenasize, nb);	/* allocate a new arena */
-	sz += sizeof *a + pool->mask;           /* header and alignment slop */
-	b = malloc(sz);
-	if (!b)
-	    return 0;
-	a = a->next = b;
-	a->next = NULL;
-	a->limit = (jsuword)a + sz;
-	JS_COUNT_ARENA(pool,++);
-	COUNT(pool, nmallocs);
-    claim:
-	a->base = a->avail = (jsuword)JS_ARENA_ALIGN(pool, a + 1);
-    }
-    p = (void *)a->avail;
-    a->avail += nb;
-    return p;
-}
-
-JS_PUBLIC_API(void *)
-JS_ArenaGrow(JSArenaPool *pool, void *p, JSUint32 size, JSUint32 incr)
-{
-    void *newp;
-
-    JS_ARENA_ALLOCATE(newp, pool, size + incr);
-    memcpy(newp, p, size);
-    return newp;
-}
-
-/*
- * Free tail arenas linked after head, which may not be the true list head.
- * Reset pool->current to point to head in case it pointed at a tail arena.
- */
-static void
-FreeArenaList(JSArenaPool *pool, JSArena *head, JSBool reallyFree)
-{
-    JSArena **ap, *a;
-#ifdef JS_THREADSAFE
-    JSArena *b;
-#endif
-
-    ap = &head->next;
-    a = *ap;
-    if (!a)
-	return;
-
-#ifdef DEBUG
-    do {
-	JS_ASSERT(a->base <= a->avail && a->avail <= a->limit);
-	a->avail = a->base;
-	JS_CLEAR_UNUSED(a);
-    } while ((a = a->next) != NULL);
-    a = *ap;
-#endif
-
-    if (reallyFree) {
-	do {
-	    *ap = a->next;
-	    JS_CLEAR_ARENA(a);
-	    JS_COUNT_ARENA(pool,--);
-	    free(a);
-	} while ((a = *ap) != NULL);
-    } else {
-	/* Insert the whole arena chain at the front of the freelist. */
-	do {
-	    ap = &(*ap)->next;
-	} while (*ap);
-#ifdef JS_THREADSAFE
-	do {
-	    *ap = b = arena_freelist;
-	} while (!js_CompareAndSwap((jsword*)&arena_freelist,(jsword)b,(jsword)a));
-#else
-	*ap = arena_freelist;
-	arena_freelist = a;
-#endif
-	head->next = NULL;
-    }
-
-    pool->current = head;
-}
-
-JS_PUBLIC_API(void)
-JS_ArenaRelease(JSArenaPool *pool, char *mark)
-{
-    JSArena *a;
-
-    for (a = pool->first.next; a; a = a->next) {
-	if (JS_UPTRDIFF(mark, a) < JS_UPTRDIFF(a->avail, a)) {
-	    a->avail = (jsuword)JS_ARENA_ALIGN(pool, mark);
-	    FreeArenaList(pool, a, JS_TRUE);
-	    return;
-	}
-    }
-}
-
-JS_PUBLIC_API(void)
-JS_FreeArenaPool(JSArenaPool *pool)
-{
-    FreeArenaList(pool, &pool->first, JS_FALSE);
-    COUNT(pool, ndeallocs);
-}
-
-JS_PUBLIC_API(void)
-JS_FinishArenaPool(JSArenaPool *pool)
-{
-    FreeArenaList(pool, &pool->first, JS_TRUE);
-#ifdef JS_ARENAMETER
-    {
-	JSArenaStats *stats, **statsp;
-
-	if (pool->stats.name)
-	    free(pool->stats.name);
-	for (statsp = &arena_stats_list; (stats = *statsp) != 0;
-	     statsp = &stats->next) {
-	    if (stats == &pool->stats) {
-		*statsp = stats->next;
-		return;
-	    }
-	}
-    }
-#endif
-}
-
-JS_PUBLIC_API(void)
-JS_CompactArenaPool(JSArenaPool *pool)
-{
-#if 0 /* XP_MAC */
-    JSArena *a = pool->first.next;
-
-    while (a) {
-        reallocSmaller(a, a->avail - (jsuword)a);
-        a->limit = a->avail;
-        a = a->next;
-    }
-#endif
-}
-
-JS_PUBLIC_API(void)
-JS_ArenaFinish()
-{
-    JSArena *a, *next;
-
-#ifdef JS_THREADSAFE
-    while (arena_freelist) {
-	a = arena_freelist;
-	next = a->next;
-	if (js_CompareAndSwap((jsword*)&arena_freelist,(jsword)a,(jsword)next))
-	    free(a);
-    }
-#else
-    for (a = arena_freelist; a; a = next) {
-        next = a->next;
-        free(a);
-    }
-    arena_freelist = NULL;
-#endif
-}
-
-#ifdef JS_ARENAMETER
-JS_PUBLIC_API(void)
-JS_ArenaCountAllocation(JSArenaPool *pool, JSUint32 nb)
-{
-    pool->stats.nallocs++;
-    pool->stats.nbytes += nb;
-    if (nb > pool->stats.maxalloc)
-        pool->stats.maxalloc = nb;
-    pool->stats.variance += nb * nb;
-}
-
-JS_PUBLIC_API(void)
-JS_ArenaCountInplaceGrowth(JSArenaPool *pool, JSUint32 size, JSUint32 incr)
-{
-    pool->stats.ninplace++;
-}
-
-JS_PUBLIC_API(void)
-JS_ArenaCountGrowth(JSArenaPool *pool, JSUint32 size, JSUint32 incr)
-{
-    pool->stats.ngrows++;
-    pool->stats.nbytes += incr;
-    pool->stats.variance -= size * size;
-    size += incr;
-    if (size > pool->stats.maxalloc)
-        pool->stats.maxalloc = size;
-    pool->stats.variance += size * size;
-}
-
-JS_PUBLIC_API(void)
-JS_ArenaCountRelease(JSArenaPool *pool, char *mark)
-{
-    pool->stats.nreleases++;
-}
-
-JS_PUBLIC_API(void)
-JS_ArenaCountRetract(JSArenaPool *pool, char *mark)
-{
-    pool->stats.nfastrels++;
-}
-
-#include <math.h>
-#include <stdio.h>
-
-JS_PUBLIC_API(void)
-JS_DumpArenaStats(FILE *fp)
-{
-    JSArenaStats *stats;
-    double mean, variance;
-
-    for (stats = arena_stats_list; stats; stats = stats->next) {
-        if (stats->nallocs != 0) {
-	    mean = (double)stats->nbytes / stats->nallocs;
-	    variance = fabs(stats->variance / stats->nallocs - mean * mean);
-	} else {
-	    mean = variance = 0;
-	}
-
-        fprintf(fp, "\n%s allocation statistics:\n", stats->name);
-        fprintf(fp, "              number of arenas: %u\n", stats->narenas);
-        fprintf(fp, "         number of allocations: %u\n", stats->nallocs);
-        fprintf(fp, " number of free arena reclaims: %u\n", stats->nreclaims);
-        fprintf(fp, "        number of malloc calls: %u\n", stats->nmallocs);
-        fprintf(fp, "       number of deallocations: %u\n", stats->ndeallocs);
-        fprintf(fp, "  number of allocation growths: %u\n", stats->ngrows);
-        fprintf(fp, "    number of in-place growths: %u\n", stats->ninplace);
-        fprintf(fp, "number of released allocations: %u\n", stats->nreleases);
-        fprintf(fp, "       number of fast releases: %u\n", stats->nfastrels);
-        fprintf(fp, "         total bytes allocated: %u\n", stats->nbytes);
-        fprintf(fp, "          mean allocation size: %g\n", mean);
-        fprintf(fp, "            standard deviation: %g\n", sqrt(variance));
-        fprintf(fp, "       maximum allocation size: %u\n", stats->maxalloc);
-    }
-}
-#endif /* JS_ARENAMETER */

mozilla/js/src/jsarena.h

@@ -1,261 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsarena_h___
-#define jsarena_h___
-/*
- * Lifetime-based fast allocation, inspired by much prior art, including
- * "Fast Allocation and Deallocation of Memory Based on Object Lifetimes"
- * David R. Hanson, Software -- Practice and Experience, Vol. 20(1).
- *
- * Also supports LIFO allocation (JS_ARENA_MARK/JS_ARENA_RELEASE).
- */
-#include <stdlib.h>
-#include "jstypes.h"
-#include "jscompat.h"
-
-JS_BEGIN_EXTERN_C
-
-typedef struct JSArena JSArena;
-typedef struct JSArenaPool JSArenaPool;
-
-struct JSArena {
-    JSArena     *next;          /* next arena for this lifetime */
-    jsuword     base;           /* aligned base address, follows this header */
-    jsuword     limit;          /* one beyond last byte in arena */
-    jsuword     avail;          /* points to next available byte */
-};
-
-#ifdef JS_ARENAMETER
-typedef struct JSArenaStats JSArenaStats;
-
-struct JSArenaStats {
-    JSArenaStats *next;         /* next in arenaStats list */
-    char        *name;          /* name for debugging */
-    uint32      narenas;        /* number of arenas in pool */
-    uint32      nallocs;        /* number of JS_ARENA_ALLOCATE() calls */
-    uint32      nreclaims;      /* number of reclaims from freeArenas */
-    uint32      nmallocs;       /* number of malloc() calls */
-    uint32      ndeallocs;      /* number of lifetime deallocations */
-    uint32      ngrows;         /* number of JS_ARENA_GROW() calls */
-    uint32      ninplace;       /* number of in-place growths */
-    uint32      nreleases;      /* number of JS_ARENA_RELEASE() calls */
-    uint32      nfastrels;      /* number of "fast path" releases */
-    size_t      nbytes;         /* total bytes allocated */
-    size_t      maxalloc;       /* maximum allocation size in bytes */
-    double      variance;       /* size variance accumulator */
-};
-#endif
-
-struct JSArenaPool {
-    JSArena     first;          /* first arena in pool list */
-    JSArena     *current;       /* arena from which to allocate space */
-    size_t      arenasize;      /* net exact size of a new arena */
-    jsuword     mask;           /* alignment mask (power-of-2 - 1) */
-#ifdef JS_ARENAMETER
-    JSArenaStats stats;
-#endif
-};
-
-/*
- * If the including .c file uses only one power-of-2 alignment, it may define
- * JS_ARENA_CONST_ALIGN_MASK to the alignment mask and save a few instructions
- * per ALLOCATE and GROW.
- */
-#ifdef JS_ARENA_CONST_ALIGN_MASK
-#define JS_ARENA_ALIGN(pool, n)	(((jsuword)(n) + JS_ARENA_CONST_ALIGN_MASK) \
-				 & ~JS_ARENA_CONST_ALIGN_MASK)
-
-#define JS_INIT_ARENA_POOL(pool, name, size) \
-	JS_InitArenaPool(pool, name, size, JS_ARENA_CONST_ALIGN_MASK + 1)
-#else
-#define JS_ARENA_ALIGN(pool, n) (((jsuword)(n) + (pool)->mask) & ~(pool)->mask)
-#endif
-
-#define JS_ARENA_ALLOCATE(p, pool, nb)                                        \
-    JS_BEGIN_MACRO                                                            \
-	JSArena *_a = (pool)->current;                                        \
-	size_t _nb = JS_ARENA_ALIGN(pool, nb);                                \
-	jsuword _p = _a->avail;                                               \
-	jsuword _q = _p + _nb;                                                \
-	if (_q > _a->limit)                                                   \
-	    _p = (jsuword)JS_ArenaAllocate(pool, _nb);                        \
-	else                                                                  \
-	    _a->avail = _q;                                                   \
-	p = (void *)_p;                                                       \
-	JS_ArenaCountAllocation(pool, nb);                                    \
-    JS_END_MACRO
-
-#define JS_ARENA_GROW(p, pool, size, incr)                                    \
-    JS_BEGIN_MACRO                                                            \
-	JSArena *_a = (pool)->current;                                        \
-	size_t _incr = JS_ARENA_ALIGN(pool, incr);                            \
-	jsuword _p = _a->avail;                                               \
-	jsuword _q = _p + _incr;                                              \
-	if (_p == (jsuword)(p) + JS_ARENA_ALIGN(pool, size) &&                \
-	    _q <= _a->limit) {                                                \
-	    _a->avail = _q;                                                   \
-	    JS_ArenaCountInplaceGrowth(pool, size, incr);                     \
-	} else {                                                              \
-	    p = JS_ArenaGrow(pool, p, size, incr);                            \
-	}                                                                     \
-	JS_ArenaCountGrowth(pool, size, incr);                                \
-    JS_END_MACRO
-
-#define JS_ARENA_MARK(pool)     ((void *) (pool)->current->avail)
-#define JS_UPTRDIFF(p,q)	((jsuword)(p) - (jsuword)(q))
-
-#ifdef DEBUG
-#define JS_FREE_PATTERN         0xDA
-#define JS_CLEAR_UNUSED(a)	(JS_ASSERT((a)->avail <= (a)->limit),         \
-				 memset((void*)(a)->avail, JS_FREE_PATTERN,   \
-					(a)->limit - (a)->avail))
-#define JS_CLEAR_ARENA(a)       memset((void*)(a), JS_FREE_PATTERN,           \
-				       (a)->limit - (jsuword)(a))
-#else
-#define JS_CLEAR_UNUSED(a)	/* nothing */
-#define JS_CLEAR_ARENA(a)       /* nothing */
-#endif
-
-#define JS_ARENA_RELEASE(pool, mark)                                          \
-    JS_BEGIN_MACRO                                                            \
-	char *_m = (char *)(mark);                                            \
-	JSArena *_a = (pool)->current;                                        \
-	if (JS_UPTRDIFF(_m, _a) <= JS_UPTRDIFF(_a->avail, _a)) {              \
-	    _a->avail = (jsuword)JS_ARENA_ALIGN(pool, _m);                    \
-	    JS_CLEAR_UNUSED(_a);                                              \
-	    JS_ArenaCountRetract(pool, _m);                                   \
-	} else {                                                              \
-	    JS_ArenaRelease(pool, _m);                                        \
-	}                                                                     \
-	JS_ArenaCountRelease(pool, _m);                                       \
-    JS_END_MACRO
-
-#ifdef JS_ARENAMETER
-#define JS_COUNT_ARENA(pool,op) ((pool)->stats.narenas op)
-#else
-#define JS_COUNT_ARENA(pool,op)
-#endif
-
-#define JS_ARENA_DESTROY(pool, a, pnext)                                      \
-    JS_BEGIN_MACRO                                                            \
-	JS_COUNT_ARENA(pool,--);                                              \
-	if ((pool)->current == (a)) (pool)->current = &(pool)->first;         \
-	*(pnext) = (a)->next;                                                 \
-	JS_CLEAR_ARENA(a);                                                    \
-	free(a);                                                              \
-	(a) = NULL;                                                           \
-    JS_END_MACRO
-
-/*
- * Initialize an arena pool with the given name for debugging and metering,
- * with a minimum size per arena of size bytes.
- */
-extern JS_PUBLIC_API(void)
-JS_InitArenaPool(JSArenaPool *pool, const char *name, JSUint32 size,
-		 JSUint32 align);
-
-/*
- * Free the arenas in pool.  The user may continue to allocate from pool
- * after calling this function.  There is no need to call JS_InitArenaPool()
- * again unless JS_FinishArenaPool(pool) has been called.
- */
-extern JS_PUBLIC_API(void)
-JS_FreeArenaPool(JSArenaPool *pool);
-
-/*
- * Free the arenas in pool and finish using it altogether.
- */
-extern JS_PUBLIC_API(void)
-JS_FinishArenaPool(JSArenaPool *pool);
-
-/*
- * Compact all of the arenas in a pool so that no space is wasted.
- */
-extern JS_PUBLIC_API(void)
-JS_CompactArenaPool(JSArenaPool *pool);
-
-/*
- * Finish using arenas, freeing all memory associated with them.
- */
-extern JS_PUBLIC_API(void)
-JS_ArenaFinish(void);
-
-/*
- * Friend functions used by the JS_ARENA_*() macros.
- */
-extern JS_PUBLIC_API(void *)
-JS_ArenaAllocate(JSArenaPool *pool, JSUint32 nb);
-
-extern JS_PUBLIC_API(void *)
-JS_ArenaGrow(JSArenaPool *pool, void *p, JSUint32 size, JSUint32 incr);
-
-extern JS_PUBLIC_API(void)
-JS_ArenaRelease(JSArenaPool *pool, char *mark);
-
-#ifdef JS_ARENAMETER
-
-#include <stdio.h>
-
-extern JS_PUBLIC_API(void)
-JS_ArenaCountAllocation(JSArenaPool *pool, JSUint32 nb);
-
-extern JS_PUBLIC_API(void)
-JS_ArenaCountInplaceGrowth(JSArenaPool *pool, JSUint32 size, JSUint32 incr);
-
-extern JS_PUBLIC_API(void)
-JS_ArenaCountGrowth(JSArenaPool *pool, JSUint32 size, JSUint32incr);
-
-extern JS_PUBLIC_API(void)
-JS_ArenaCountRelease(JSArenaPool *pool, char *mark);
-
-extern JS_PUBLIC_API(void)
-JS_ArenaCountRetract(JSArenaPool *pool, char *mark);
-
-extern JS_PUBLIC_API(void)
-JS_DumpArenaStats(FILE *fp);
-
-#else  /* !JS_ARENAMETER */
-
-#define JS_ArenaCountAllocation(ap, nb)                 /* nothing */
-#define JS_ArenaCountInplaceGrowth(ap, size, incr)      /* nothing */
-#define JS_ArenaCountGrowth(ap, size, incr)             /* nothing */
-#define JS_ArenaCountRelease(ap, mark)                  /* nothing */
-#define JS_ArenaCountRetract(ap, mark)                  /* nothing */
-
-#endif /* !JS_ARENAMETER */
-
-JS_END_EXTERN_C
-
-#endif /* jsarena_h___ */

mozilla/js/src/jsarray.h

@@ -1,72 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsarray_h___
-#define jsarray_h___
-/*
- * JS Array interface.
- */
-#include "jsprvtd.h"
-#include "jspubtd.h"
-
-JS_BEGIN_EXTERN_C
-
-extern JSClass js_ArrayClass;
-
-extern JSObject *
-js_InitArrayClass(JSContext *cx, JSObject *obj);
-
-extern JSObject *
-js_NewArrayObject(JSContext *cx, jsuint length, jsval *vector);
-
-extern JSBool
-js_GetLengthProperty(JSContext *cx, JSObject *obj, jsuint *lengthp);
-
-extern JSBool
-js_SetLengthProperty(JSContext *cx, JSObject *obj, jsuint length);
-
-extern JSBool
-js_HasLengthProperty(JSContext *cx, JSObject *obj, jsuint *lengthp);
-
-/*
- * JS-specific qsort function.
- */
-typedef int (*JSComparator)(const void *a, const void *b, void *arg);
-
-extern JSBool
-js_qsort(void *vec, size_t nel, size_t elsize, JSComparator cmp, void *arg);
-
-JS_END_EXTERN_C
-
-#endif /* jsarray_h___ */

mozilla/js/src/jsatom.c

@@ -1,779 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS atom table.
- */
-#include "jsstddef.h"
-#include <stdlib.h>
-#include <string.h>
-#include "jstypes.h"
-#include "jsutil.h" /* Added by JSIFY */
-#include "jshash.h" /* Added by JSIFY */
-#include "jsprf.h"
-#include "jsapi.h"
-#include "jsatom.h"
-#include "jscntxt.h"
-#include "jsgc.h"
-#include "jslock.h"
-#include "jsnum.h"
-#include "jsopcode.h"
-#include "jsstr.h"
-
-/*
- * Keep this in sync with jspubtd.h -- an assertion below will insist that
- * its length match the JSType enum's JSTYPE_LIMIT limit value.
- */
-char *js_type_str[] = {
-    "undefined",
-    "object",
-    "function",
-    "string",
-    "number",
-    "boolean",
-};
-
-char *js_boolean_str[] = {
-    js_false_str,
-    js_true_str
-};
-
-char   js_Array_str[]             = "Array";
-char   js_Math_str[]              = "Math";
-char   js_NaN_str[]               = "NaN";
-char   js_Object_str[]            = "Object";
-char   js_anonymous_str[]         = "anonymous";
-char   js_arguments_str[]         = "arguments";
-char   js_arity_str[]             = "arity";
-char   js_callee_str[]            = "callee";
-char   js_caller_str[]            = "caller";
-char   js_class_prototype_str[]   = "prototype";
-char   js_constructor_str[]       = "constructor";
-char   js_count_str[]             = "__count__";
-char   js_eval_str[]              = "eval";
-char   js_getter_str[]            = "getter";
-char   js_index_str[]             = "index";
-char   js_input_str[]             = "input";
-char   js_length_str[]            = "length";
-char   js_name_str[]              = "name";
-char   js_parent_str[]            = "__parent__";
-char   js_proto_str[]             = "__proto__";
-char   js_setter_str[]            = "setter";
-char   js_toSource_str[]          = "toSource";
-char   js_toString_str[]          = "toString";
-char   js_valueOf_str[]           = "valueOf";
-
-#define HASH_OBJECT(o)  ((JSHashNumber)(o) >> JSVAL_TAGBITS)
-#define HASH_INT(i)     ((JSHashNumber)(i))
-#define HASH_DOUBLE(dp) ((JSHashNumber)(((uint32*)(dp))[0] ^ ((uint32*)(dp))[1]))
-#define HASH_BOOLEAN(b) ((JSHashNumber)(b))
-
-JS_STATIC_DLL_CALLBACK(JSHashNumber)
-js_hash_atom_key(const void *key)
-{
-    jsval v;
-    jsdouble *dp;
-
-    /* Order JSVAL_IS_* tests by likelihood of success. */
-    v = (jsval)key;
-    if (JSVAL_IS_STRING(v))
-	return js_HashString(JSVAL_TO_STRING(v));
-    if (JSVAL_IS_INT(v))
-	return HASH_INT(JSVAL_TO_INT(v));
-    if (JSVAL_IS_DOUBLE(v)) {
-	dp = JSVAL_TO_DOUBLE(v);
-	return HASH_DOUBLE(dp);
-    }
-    if (JSVAL_IS_OBJECT(v))
-	return HASH_OBJECT(JSVAL_TO_OBJECT(v));
-    if (JSVAL_IS_BOOLEAN(v))
-	return HASH_BOOLEAN(JSVAL_TO_BOOLEAN(v));
-    return (JSHashNumber)v;
-}
-
-JS_STATIC_DLL_CALLBACK(intN)
-js_compare_atom_keys(const void *k1, const void *k2)
-{
-    jsval v1, v2;
-
-    v1 = (jsval)k1, v2 = (jsval)k2;
-    if (JSVAL_IS_STRING(v1) && JSVAL_IS_STRING(v2))
-	return !js_CompareStrings(JSVAL_TO_STRING(v1), JSVAL_TO_STRING(v2));
-    if (JSVAL_IS_DOUBLE(v1) && JSVAL_IS_DOUBLE(v2)) {
-	double d1 = *JSVAL_TO_DOUBLE(v1);
-	double d2 = *JSVAL_TO_DOUBLE(v2);
-	if (JSDOUBLE_IS_NaN(d1))
-	    return JSDOUBLE_IS_NaN(d2);
-#ifdef XP_PC
-	/* XXX MSVC miscompiles such that (NaN == 0) */
-	if (JSDOUBLE_IS_NaN(d2))
-	    return JS_FALSE;
-#endif
-	return d1 == d2;
-    }
-    return v1 == v2;
-}
-
-JS_STATIC_DLL_CALLBACK(int)
-js_compare_stub(const void *v1, const void *v2)
-{
-    return 1;
-}
-
-JS_STATIC_DLL_CALLBACK(void *)
-js_alloc_atom_space(void *priv, size_t size)
-{
-    return malloc(size);
-}
-
-JS_STATIC_DLL_CALLBACK(void)
-js_free_atom_space(void *priv, void *item)
-{
-    free(item);
-}
-
-JS_STATIC_DLL_CALLBACK(JSHashEntry *)
-js_alloc_atom(void *priv, const void *key)
-{
-    JSAtomState *state = priv;
-    JSAtom *atom;
-
-    atom = malloc(sizeof(JSAtom));
-    if (!atom)
-	return NULL;
-#ifdef JS_THREADSAFE
-    state->tablegen++;
-#endif
-    atom->entry.key = key;
-    atom->entry.value = NULL;
-    atom->flags = 0;
-    atom->kwindex = -1;
-    atom->number = state->number++;
-    return &atom->entry;
-}
-
-JS_STATIC_DLL_CALLBACK(void)
-js_free_atom(void *priv, JSHashEntry *he, uintN flag)
-{
-    if (flag != HT_FREE_ENTRY)
-	return;
-#ifdef JS_THREADSAFE
-    ((JSAtomState *)priv)->tablegen++;
-#endif
-    free(he);
-}
-
-static JSHashAllocOps atom_alloc_ops = {
-    js_alloc_atom_space,    js_free_atom_space,
-    js_alloc_atom,          js_free_atom
-};
-
-#define JS_ATOM_HASH_SIZE   1024
-
-JSBool
-js_InitAtomState(JSContext *cx, JSAtomState *state)
-{
-    uintN i;
-
-    memset(state, 0, sizeof *state);
-    state->runtime = cx->runtime;
-    state->table = JS_NewHashTable(JS_ATOM_HASH_SIZE, js_hash_atom_key,
-				   js_compare_atom_keys, js_compare_stub,
-				   &atom_alloc_ops, state);
-    if (!state->table) {
-	JS_ReportOutOfMemory(cx);
-	return JS_FALSE;
-    }
-#ifdef JS_THREADSAFE
-    js_NewLock(&state->lock);
-    state->tablegen = 0;
-#endif
-
-#define FROB(lval,str)                                                        \
-    JS_BEGIN_MACRO                                                            \
-	if (!(state->lval = js_Atomize(cx, str, strlen(str), ATOM_PINNED)))   \
-	    goto bad;                                                         \
-    JS_END_MACRO
-
-    JS_ASSERT(sizeof js_type_str / sizeof js_type_str[0] == JSTYPE_LIMIT);
-    for (i = 0; i < JSTYPE_LIMIT; i++)
-	FROB(typeAtoms[i],        js_type_str[i]);
-
-    FROB(booleanAtoms[0],         js_false_str);
-    FROB(booleanAtoms[1],         js_true_str);
-    FROB(nullAtom,                js_null_str);
-
-    FROB(ArrayAtom,               js_Array_str);
-    FROB(MathAtom,                js_Math_str);
-    FROB(NaNAtom,                 js_NaN_str);
-    FROB(ObjectAtom,              js_Object_str);
-    FROB(anonymousAtom,           js_anonymous_str);
-    FROB(argumentsAtom,           js_arguments_str);
-    FROB(arityAtom,               js_arity_str);
-    FROB(calleeAtom,              js_callee_str);
-    FROB(callerAtom,              js_caller_str);
-    FROB(classPrototypeAtom,      js_class_prototype_str);
-    FROB(constructorAtom,         js_constructor_str);
-    FROB(countAtom,               js_count_str);
-    FROB(getterAtom,              js_getter_str);
-    FROB(indexAtom,               js_index_str);
-    FROB(inputAtom,               js_input_str);
-    FROB(lengthAtom,              js_length_str);
-    FROB(nameAtom,                js_name_str);
-    FROB(parentAtom,              js_parent_str);
-    FROB(protoAtom,               js_proto_str);
-    FROB(setterAtom,              js_setter_str);
-    FROB(toSourceAtom,            js_toSource_str);
-    FROB(toStringAtom,            js_toString_str);
-    FROB(valueOfAtom,             js_valueOf_str);
-    FROB(evalAtom,                js_eval_str);
-
-#undef FROB
-
-    return JS_TRUE;
-
-bad:
-    js_FreeAtomState(cx, state);
-    return JS_FALSE;
-}
-
-void
-js_FreeAtomState(JSContext *cx, JSAtomState *state)
-{
-    state->runtime = NULL;
-    JS_HashTableDestroy(state->table);
-    state->table = NULL;
-    state->number = 0;
-#ifdef JS_THREADSAFE
-    js_DestroyLock(&state->lock);
-#endif
-}
-
-typedef struct MarkArgs {
-    JSRuntime       *runtime;
-    JSGCThingMarker mark;
-} MarkArgs;
-
-JS_STATIC_DLL_CALLBACK(intN)
-js_atom_marker(JSHashEntry *he, intN i, void *arg)
-{
-    JSAtom *atom;
-    jsval key;
-    MarkArgs *args;
-
-    atom = (JSAtom *)he;
-    if (atom->flags & ATOM_PINNED) {
-	atom->flags |= ATOM_MARK;
-	key = ATOM_KEY(atom);
-	if (JSVAL_IS_GCTHING(key)) {
-	    args = arg;
-	    args->mark(args->runtime, JSVAL_TO_GCTHING(key));
-	}
-    }
-    return HT_ENUMERATE_NEXT;
-}
-
-void
-js_MarkAtomState(JSAtomState *state, JSGCThingMarker mark)
-{
-    MarkArgs args;
-
-    args.runtime = state->runtime;
-    args.mark = mark;
-    JS_HashTableEnumerateEntries(state->table, js_atom_marker, &args);
-}
-
-JS_STATIC_DLL_CALLBACK(intN)
-js_atom_sweeper(JSHashEntry *he, intN i, void *arg)
-{
-    JSAtom *atom;
-
-    atom = (JSAtom *)he;
-    if (atom->flags & ATOM_MARK) {
-	atom->flags &= ~ATOM_MARK;
-	return HT_ENUMERATE_NEXT;
-    }
-    JS_ASSERT((atom->flags & ATOM_PINNED) == 0);
-    atom->entry.key = NULL;
-    atom->flags = 0;
-    return HT_ENUMERATE_REMOVE;
-}
-
-void
-js_SweepAtomState(JSAtomState *state)
-{
-    JS_HashTableEnumerateEntries(state->table, js_atom_sweeper, NULL);
-}
-
-JS_STATIC_DLL_CALLBACK(intN)
-js_atom_unpinner(JSHashEntry *he, intN i, void *arg)
-{
-    JSAtom *atom;
-
-    atom = (JSAtom *)he;
-    atom->flags &= ~ATOM_PINNED;
-    return HT_ENUMERATE_NEXT;
-}
-
-void
-js_UnpinPinnedAtoms(JSAtomState *state)
-{
-    JS_HashTableEnumerateEntries(state->table, js_atom_unpinner, NULL);
-}
-
-static JSAtom *
-js_AtomizeHashedKey(JSContext *cx, jsval key, JSHashNumber keyHash, uintN flags)
-{
-    JSAtomState *state;
-    JSHashTable *table;
-    JSHashEntry *he, **hep;
-    JSAtom *atom;
-
-    state = &cx->runtime->atomState;
-    JS_LOCK(&state->lock,cx);
-    table = state->table;
-    hep = JS_HashTableRawLookup(table, keyHash, (void *)key);
-    if ((he = *hep) == NULL) {
-	he = JS_HashTableRawAdd(table, hep, keyHash, (void *)key, NULL);
-	if (!he) {
-	    JS_ReportOutOfMemory(cx);
-	    atom = NULL;
-	    goto out;
-	}
-    }
-
-    atom = (JSAtom *)he;
-    atom->flags |= flags;
-out:
-    JS_UNLOCK(&state->lock,cx);
-    return atom;
-}
-
-JSAtom *
-js_AtomizeObject(JSContext *cx, JSObject *obj, uintN flags)
-{
-    jsval key;
-    JSHashNumber keyHash;
-
-    /* XXX must be set in the following order or MSVC1.52 will crash */
-    keyHash = HASH_OBJECT(obj);
-    key = OBJECT_TO_JSVAL(obj);
-    return js_AtomizeHashedKey(cx, key, keyHash, flags);
-}
-
-JSAtom *
-js_AtomizeBoolean(JSContext *cx, JSBool b, uintN flags)
-{
-    jsval key;
-    JSHashNumber keyHash;
-
-    key = BOOLEAN_TO_JSVAL(b);
-    keyHash = HASH_BOOLEAN(b);
-    return js_AtomizeHashedKey(cx, key, keyHash, flags);
-}
-
-JSAtom *
-js_AtomizeInt(JSContext *cx, jsint i, uintN flags)
-{
-    jsval key;
-    JSHashNumber keyHash;
-
-    key = INT_TO_JSVAL(i);
-    keyHash = HASH_INT(i);
-    return js_AtomizeHashedKey(cx, key, keyHash, flags);
-}
-
-/* Worst-case alignment grain and aligning macro for 2x-sized buffer. */
-#define ALIGNMENT(t)    JS_MAX(JSVAL_ALIGN, sizeof(t))
-#define ALIGN(b,t)      ((t*) &(b)[ALIGNMENT(t) - (jsuword)(b) % ALIGNMENT(t)])
-
-JSAtom *
-js_AtomizeDouble(JSContext *cx, jsdouble d, uintN flags)
-{
-    jsdouble *dp;
-    JSHashNumber keyHash;
-    jsval key;
-    JSAtomState *state;
-    JSHashTable *table;
-    JSHashEntry *he, **hep;
-    JSAtom *atom;
-    char buf[2 * ALIGNMENT(double)];
-
-    dp = ALIGN(buf, double);
-    *dp = d;
-    keyHash = HASH_DOUBLE(dp);
-    key = DOUBLE_TO_JSVAL(dp);
-    state = &cx->runtime->atomState;
-    JS_LOCK(&state->lock,cx);
-    table = state->table;
-    hep = JS_HashTableRawLookup(table, keyHash, (void *)key);
-    if ((he = *hep) == NULL) {
-#ifdef JS_THREADSAFE
-	uint32 gen = state->tablegen;
-#endif
-	JS_UNLOCK(&state->lock,cx);
-	if (!js_NewDoubleValue(cx, d, &key))
-	    return NULL;
-	JS_LOCK(&state->lock,cx);
-#ifdef JS_THREADSAFE
-	if (state->tablegen != gen) {
-	    hep = JS_HashTableRawLookup(table, keyHash, (void *)key);
-	    if ((he = *hep) != NULL) {
-		atom = (JSAtom *)he;
-		goto out;
-	    }
-	}
-#endif
-	he = JS_HashTableRawAdd(table, hep, keyHash, (void *)key, NULL);
-	if (!he) {
-	    JS_ReportOutOfMemory(cx);
-	    atom = NULL;
-	    goto out;
-	}
-    }
-
-    atom = (JSAtom *)he;
-    atom->flags |= flags;
-out:
-    JS_UNLOCK(&state->lock,cx);
-    return atom;
-}
-
-JSAtom *
-js_AtomizeString(JSContext *cx, JSString *str, uintN flags)
-{
-    JSHashNumber keyHash;
-    jsval key;
-    JSAtomState *state;
-    JSHashTable *table;
-    JSHashEntry *he, **hep;
-    JSAtom *atom;
-
-    keyHash = js_HashString(str);
-    key = STRING_TO_JSVAL(str);
-    state = &cx->runtime->atomState;
-    JS_LOCK(&state->lock,cx);
-    table = state->table;
-    hep = JS_HashTableRawLookup(table, keyHash, (void *)key);
-    if ((he = *hep) == NULL) {
-	if (flags & ATOM_TMPSTR) {
-#ifdef JS_THREADSAFE
-	    uint32 gen = state->tablegen;
-#endif
-	    JS_UNLOCK(&state->lock,cx);
-	    if (flags & ATOM_NOCOPY) {
-		str = js_NewString(cx, str->chars, str->length, 0);
-	    } else {
-		str = js_NewStringCopyN(cx, str->chars, str->length, 0);
-	    }
-	    if (!str)
-		return NULL;
-	    key = STRING_TO_JSVAL(str);
-	    JS_LOCK(&state->lock,cx);
-#ifdef JS_THREADSAFE
-	    if (state->tablegen != gen) {
-		hep = JS_HashTableRawLookup(table, keyHash, (void *)key);
-		if ((he = *hep) != NULL) {
-		    atom = (JSAtom *)he;
-		    if (flags & ATOM_NOCOPY)
-			str->chars = NULL;
-		    goto out;
-		}
-	    }
-#endif
-	}
-	he = JS_HashTableRawAdd(table, hep, keyHash, (void *)key, NULL);
-	if (!he) {
-	    JS_ReportOutOfMemory(cx);
-	    atom = NULL;
-	    goto out;
-	}
-    }
-
-    atom = (JSAtom *)he;
-    atom->flags |= flags & ATOM_PINNED;
-out:
-    JS_UNLOCK(&state->lock,cx);
-    return atom;
-}
-
-JS_FRIEND_API(JSAtom *)
-js_Atomize(JSContext *cx, const char *bytes, size_t length, uintN flags)
-{
-    jschar *chars;
-    JSString *str;
-    JSAtom *atom;
-    char buf[2 * ALIGNMENT(JSString)];
-
-    str = ALIGN(buf, JSString);
-    chars = js_InflateString(cx, bytes, length);
-    if (!chars)
-	return NULL;
-    str->chars = chars;
-    str->length = length;
-    atom = js_AtomizeString(cx, str, ATOM_TMPSTR | ATOM_NOCOPY | flags);
-    if (!atom || ATOM_TO_STRING(atom)->chars != chars)
-	JS_free(cx, chars);
-    return atom;
-}
-
-JS_FRIEND_API(JSAtom *)
-js_AtomizeChars(JSContext *cx, const jschar *chars, size_t length, uintN flags)
-{
-    JSString *str;
-    char buf[2 * ALIGNMENT(JSString)];
-
-    str = ALIGN(buf, JSString);
-    str->chars = (jschar *)chars;
-    str->length = length;
-    return js_AtomizeString(cx, str, ATOM_TMPSTR | flags);
-}
-
-JSAtom *
-js_AtomizeValue(JSContext *cx, jsval value, uintN flags)
-{
-    if (JSVAL_IS_STRING(value))
-	return js_AtomizeString(cx, JSVAL_TO_STRING(value), flags);
-    if (JSVAL_IS_INT(value))
-	return js_AtomizeInt(cx, JSVAL_TO_INT(value), flags);
-    if (JSVAL_IS_DOUBLE(value))
-	return js_AtomizeDouble(cx, *JSVAL_TO_DOUBLE(value), flags);
-    if (JSVAL_IS_OBJECT(value))
-	return js_AtomizeObject(cx, JSVAL_TO_OBJECT(value), flags);
-    if (JSVAL_IS_BOOLEAN(value))
-	return js_AtomizeBoolean(cx, JSVAL_TO_BOOLEAN(value), flags);
-    return js_AtomizeHashedKey(cx, value, (JSHashNumber)value, flags);
-}
-
-JSAtom *
-js_ValueToStringAtom(JSContext *cx, jsval v)
-{
-    JSString *str;
-
-    str = js_ValueToString(cx, v);
-    if (!str)
-	return NULL;
-    return js_AtomizeString(cx, str, 0);
-}
-
-JS_STATIC_DLL_CALLBACK(JSHashNumber)
-js_hash_atom_ptr(const void *key)
-{
-    const JSAtom *atom = key;
-    return atom->number;
-}
-
-JS_STATIC_DLL_CALLBACK(void *)
-js_alloc_temp_space(void *priv, size_t size)
-{
-    JSContext *cx = priv;
-    void *space;
-
-    JS_ARENA_ALLOCATE(space, &cx->tempPool, size);
-    if (!space)
-        JS_ReportOutOfMemory(cx);
-    return space;
-}
-
-JS_STATIC_DLL_CALLBACK(void)
-js_free_temp_space(void *priv, void *item)
-{
-}
-
-JS_STATIC_DLL_CALLBACK(JSHashEntry *)
-js_alloc_temp_entry(void *priv, const void *key)
-{
-    JSContext *cx = priv;
-    JSAtomListElement *ale;
-
-    JS_ARENA_ALLOCATE(ale, &cx->tempPool, sizeof(JSAtomListElement));
-    if (!ale) {
-        JS_ReportOutOfMemory(cx);
-        return NULL;
-    }
-    return &ale->entry;
-}
-
-JS_STATIC_DLL_CALLBACK(void)
-js_free_temp_entry(void *priv, JSHashEntry *he, uintN flag)
-{
-}
-
-static JSHashAllocOps temp_alloc_ops = {
-    js_alloc_temp_space,    js_free_temp_space,
-    js_alloc_temp_entry,    js_free_temp_entry
-};
-
-JSAtomListElement *
-js_IndexAtom(JSContext *cx, JSAtom *atom, JSAtomList *al)
-{
-    JSAtomListElement *ale, *ale2, *next;
-    JSHashEntry **hep;
-
-    ATOM_LIST_LOOKUP(ale, hep, al, atom);
-    if (!ale) {
-        if (al->count <= 5) {
-            /* Few enough for linear search, no hash table needed. */
-            JS_ASSERT(!al->table);
-            ale = (JSAtomListElement *)js_alloc_temp_entry(cx, atom);
-            if (!ale)
-                return NULL;
-            ALE_SET_ATOM(ale, atom);
-            ALE_SET_NEXT(ale, al->list);
-            al->list = ale;
-        } else {
-            /* We want to hash.  Have we already made a hash table? */
-            if (!al->table) {
-                /* No hash table yet, so hep had better be null! */
-                JS_ASSERT(!hep);
-                al->table = JS_NewHashTable(8, js_hash_atom_ptr,
-                                            JS_CompareValues, JS_CompareValues,
-                                            &temp_alloc_ops, cx);
-                if (!al->table)
-                    return NULL;
-
-                /* Insert each ale on al->list into the new hash table. */
-                for (ale2 = al->list; ale2; ale2 = next) {
-                    next = ALE_NEXT(ale2);
-                    ale2->entry.keyHash = ALE_ATOM(ale2)->number;
-                    hep = JS_HashTableRawLookup(al->table, ale2->entry.keyHash,
-                                                ale2->entry.key);
-                    ALE_SET_NEXT(ale2, *hep);
-                    *hep = &ale2->entry;
-                }
-                al->list = NULL;
-
-                /* Set hep for insertion of atom's ale, immediately below. */
-                hep = JS_HashTableRawLookup(al->table, atom->number, atom);
-            }
-
-            /* Finally, add an entry for atom into the hash bucket at hep. */
-            ale = (JSAtomListElement *)
-                JS_HashTableRawAdd(al->table, hep, atom->number, atom, NULL);
-            if (!ale)
-                return NULL;
-        }
-
-	ALE_SET_INDEX(ale, al->count++);
-    }
-    return ale;
-}
-
-JS_FRIEND_API(JSAtom *)
-js_GetAtom(JSContext *cx, JSAtomMap *map, jsatomid i)
-{
-    JSAtom *atom;
-    static JSAtom dummy;
-
-    JS_ASSERT(map->vector && i < map->length);
-    if (!map->vector || i >= map->length) {
-	char numBuf[12];
-	JS_snprintf(numBuf, sizeof numBuf, "%lu", (unsigned long)i);
-	JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
-			     JSMSG_BAD_ATOMIC_NUMBER, numBuf);
-	return &dummy;
-    }
-    atom = map->vector[i];
-    JS_ASSERT(atom);
-    return atom;
-}
-
-JS_STATIC_DLL_CALLBACK(intN)
-js_map_atom(JSHashEntry *he, intN i, void *arg)
-{
-    JSAtomListElement *ale = (JSAtomListElement *)he;
-    JSAtom **vector = arg;
-
-    vector[ALE_INDEX(ale)] = ALE_ATOM(ale);
-    return HT_ENUMERATE_NEXT;
-}
-
-#ifdef DEBUG
-jsrefcount js_atom_map_count;
-jsrefcount js_atom_map_hash_table_count;
-#endif
-
-JS_FRIEND_API(JSBool)
-js_InitAtomMap(JSContext *cx, JSAtomMap *map, JSAtomList *al)
-{
-    JSAtom **vector;
-    JSAtomListElement *ale;
-    uint32 count;
-
-#ifdef DEBUG
-    JS_ATOMIC_ADDREF(&js_atom_map_count, 1);
-#endif
-    ale = al->list;
-    if (!ale && !al->table) {
-	map->vector = NULL;
-	map->length = 0;
-	return JS_TRUE;
-    }
-
-    count = al->count;
-    if (count >= ATOM_INDEX_LIMIT) {
-	JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
-			     JSMSG_TOO_MANY_LITERALS);
-	return JS_FALSE;
-    }
-    vector = JS_malloc(cx, (size_t) count * sizeof *vector);
-    if (!vector)
-	return JS_FALSE;
-
-    if (al->table) {
-#ifdef DEBUG
-        JS_ATOMIC_ADDREF(&js_atom_map_hash_table_count, 1);
-#endif
-        JS_HashTableEnumerateEntries(al->table, js_map_atom, vector);
-    } else {
-        do {
-            vector[ALE_INDEX(ale)] = ALE_ATOM(ale);
-        } while ((ale = ALE_NEXT(ale)) != NULL);
-    }
-    ATOM_LIST_INIT(al);
-
-    map->vector = vector;
-    map->length = (jsatomid)count;
-    return JS_TRUE;
-}
-
-JS_FRIEND_API(void)
-js_FreeAtomMap(JSContext *cx, JSAtomMap *map)
-{
-    if (map->vector) {
-	free(map->vector);
-	map->vector = NULL;
-    }
-    map->length = 0;
-}

mozilla/js/src/jsatom.h

@@ -1,315 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsatom_h___
-#define jsatom_h___
-/*
- * JS atom table.
- */
-#include <stddef.h>
-#include "jstypes.h"
-#include "jshash.h" /* Added by JSIFY */
-#include "jsapi.h"
-#include "jsprvtd.h"
-#include "jspubtd.h"
-
-#ifdef JS_THREADSAFE
-#include "jslock.h"
-#endif
-
-JS_BEGIN_EXTERN_C
-
-#define ATOM_NOCOPY     0x01            /* don't copy atom string bytes */
-#define ATOM_TMPSTR     0x02            /* internal, to avoid extra string */
-#define ATOM_MARK       0x04            /* atom is reachable via GC */
-#define ATOM_PINNED     0x08            /* atom is pinned against GC */
-
-struct JSAtom {
-    JSHashEntry         entry;          /* key is jsval, value keyword info */
-    uint8               flags;          /* flags, PINNED and/or MARK for now */
-    int8                kwindex;        /* keyword index, -1 if not keyword */
-    jsatomid            number;         /* atom serial number and hash code */
-};
-
-#define ATOM_KEY(atom)           ((jsval)(atom)->entry.key)
-#define ATOM_IS_OBJECT(atom)     JSVAL_IS_OBJECT(ATOM_KEY(atom))
-#define ATOM_TO_OBJECT(atom)     JSVAL_TO_OBJECT(ATOM_KEY(atom))
-#define ATOM_IS_INT(atom)        JSVAL_IS_INT(ATOM_KEY(atom))
-#define ATOM_TO_INT(atom)        JSVAL_TO_INT(ATOM_KEY(atom))
-#define ATOM_IS_DOUBLE(atom)     JSVAL_IS_DOUBLE(ATOM_KEY(atom))
-#define ATOM_TO_DOUBLE(atom)     JSVAL_TO_DOUBLE(ATOM_KEY(atom))
-#define ATOM_IS_STRING(atom)     JSVAL_IS_STRING(ATOM_KEY(atom))
-#define ATOM_TO_STRING(atom)     JSVAL_TO_STRING(ATOM_KEY(atom))
-#define ATOM_IS_BOOLEAN(atom)    JSVAL_IS_BOOLEAN(ATOM_KEY(atom))
-#define ATOM_TO_BOOLEAN(atom)    JSVAL_TO_BOOLEAN(ATOM_KEY(atom))
-#define ATOM_BYTES(atom)         JS_GetStringBytes(ATOM_TO_STRING(atom))
-
-struct JSAtomListElement {
-    JSHashEntry         entry;
-};
-
-#define ALE_ATOM(ale)   ((JSAtom *) (ale)->entry.key)
-#define ALE_INDEX(ale)  ((jsatomid) (ale)->entry.value)
-#define ALE_NODE(ale)   ((JSParseNode *) (ale)->entry.value)
-#define ALE_NEXT(ale)   ((JSAtomListElement *) (ale)->entry.next)
-
-#define ALE_SET_ATOM(ale,atom)  ((ale)->entry.key = (const void *)(atom))
-#define ALE_SET_INDEX(ale,index)((ale)->entry.value = (void *)(index))
-#define ALE_SET_NODE(ale,pn)    ((ale)->entry.value = (void *)(pn))
-#define ALE_SET_NEXT(ale,link)  ((ale)->entry.next = (JSHashEntry *)(link))
-
-struct JSAtomList {
-    JSAtomListElement   *list;          /* literals indexed for mapping */
-    JSHashTable         *table;         /* hash table if list gets too long */
-    jsuint              count;          /* count of indexed literals */
-};
-
-#define ATOM_LIST_INIT(al)  ((al)->list = NULL, (al)->table = NULL,           \
-                             (al)->count = 0)
-
-#define ATOM_LIST_SEARCH(_ale,_al,_atom)                                      \
-    JS_BEGIN_MACRO                                                            \
-        JSHashEntry **_hep;                                                   \
-        ATOM_LIST_LOOKUP(_ale, _hep, _al, _atom);                             \
-    JS_END_MACRO
-
-#define ATOM_LIST_LOOKUP(_ale,_hep,_al,_atom)                                 \
-    JS_BEGIN_MACRO                                                            \
-        if ((_al)->table) {                                                   \
-            _hep = JS_HashTableRawLookup((_al)->table, _atom->number, _atom); \
-            _ale = *_hep ? (JSAtomListElement *) *_hep : NULL;                \
-        } else {                                                              \
-            JSAtomListElement **_alep = &(_al)->list;                         \
-            _hep = NULL;                                                      \
-            while ((_ale = *_alep) != NULL) {                                 \
-                if (ALE_ATOM(_ale) == (_atom)) {                              \
-                    /* Hit, move atom's element to the front of the list. */  \
-                    *_alep = ALE_NEXT(_ale);                                  \
-                    ALE_SET_NEXT(_ale, (_al)->list);                          \
-                    (_al)->list = _ale;                                       \
-                    break;                                                    \
-                }                                                             \
-                _alep = (JSAtomListElement **)&_ale->entry.next;              \
-            }                                                                 \
-        }                                                                     \
-    JS_END_MACRO
-
-struct JSAtomMap {
-    JSAtom              **vector;       /* array of ptrs to indexed atoms */
-    jsatomid            length;         /* count of (to-be-)indexed atoms */
-};
-
-struct JSAtomState {
-    JSRuntime           *runtime;       /* runtime that owns us */
-    JSHashTable         *table;         /* hash table containing all atoms */
-    jsatomid            number;         /* one beyond greatest atom number */
-
-    /* Type names and value literals. */
-    JSAtom              *typeAtoms[JSTYPE_LIMIT];
-    JSAtom              *booleanAtoms[2];
-    JSAtom              *nullAtom;
-
-    /* Various built-in or commonly-used atoms. */
-    JSAtom              *ArrayAtom;
-    JSAtom              *MathAtom;
-    JSAtom              *NaNAtom;
-    JSAtom              *ObjectAtom;
-    JSAtom              *anonymousAtom;
-    JSAtom              *argumentsAtom;
-    JSAtom              *arityAtom;
-    JSAtom              *calleeAtom;
-    JSAtom              *callerAtom;
-    JSAtom              *classPrototypeAtom;
-    JSAtom              *constructorAtom;
-    JSAtom              *countAtom;
-    JSAtom              *getterAtom;
-    JSAtom              *indexAtom;
-    JSAtom              *inputAtom;
-    JSAtom              *lengthAtom;
-    JSAtom              *nameAtom;
-    JSAtom              *parentAtom;
-    JSAtom              *protoAtom;
-    JSAtom              *setterAtom;
-    JSAtom              *toSourceAtom;
-    JSAtom              *toStringAtom;
-    JSAtom              *valueOfAtom;
-    JSAtom              *evalAtom;
-
-#ifdef JS_THREADSAFE
-    JSThinLock          lock;
-    volatile uint32     tablegen;
-#endif
-};
-
-/* Well-known predefined strings and their atoms. */
-extern char   *js_type_str[];
-extern char   *js_boolean_str[];
-
-extern char   js_Array_str[];
-extern char   js_Math_str[];
-extern char   js_NaN_str[];
-extern char   js_Object_str[];
-extern char   js_anonymous_str[];
-extern char   js_arguments_str[];
-extern char   js_arity_str[];
-extern char   js_callee_str[];
-extern char   js_caller_str[];
-extern char   js_class_prototype_str[];
-extern char   js_constructor_str[];
-extern char   js_count_str[];
-extern char   js_eval_str[];
-extern char   js_getter_str[];
-extern char   js_index_str[];
-extern char   js_input_str[];
-extern char   js_length_str[];
-extern char   js_name_str[];
-extern char   js_parent_str[];
-extern char   js_proto_str[];
-extern char   js_setter_str[];
-extern char   js_toSource_str[];
-extern char   js_toString_str[];
-extern char   js_valueOf_str[];
-
-/*
- * Initialize atom state.  Return true on success, false with an out of
- * memory error report on failure.
- */
-extern JSBool
-js_InitAtomState(JSContext *cx, JSAtomState *state);
-
-/*
- * Free and clear atom state.
- */
-extern void
-js_FreeAtomState(JSContext *cx, JSAtomState *state);
-
-/*
- * Atom garbage collection hooks.
- */
-typedef void
-(*JSGCThingMarker)(JSRuntime *rt, void *thing);
-
-extern void
-js_MarkAtomState(JSAtomState *state, JSGCThingMarker mark);
-
-extern void
-js_SweepAtomState(JSAtomState *state);
-
-extern void
-js_UnpinPinnedAtoms(JSAtomState *state);
-
-/*
- * Find or create the atom for an object.  If we create a new atom, give it the
- * type indicated in flags.  Return 0 on failure to allocate memory.
- */
-extern JSAtom *
-js_AtomizeObject(JSContext *cx, JSObject *obj, uintN flags);
-
-/*
- * Find or create the atom for a Boolean value.  If we create a new atom, give
- * it the type indicated in flags.  Return 0 on failure to allocate memory.
- */
-extern JSAtom *
-js_AtomizeBoolean(JSContext *cx, JSBool b, uintN flags);
-
-/*
- * Find or create the atom for an integer value.  If we create a new atom, give
- * it the type indicated in flags.  Return 0 on failure to allocate memory.
- */
-extern JSAtom *
-js_AtomizeInt(JSContext *cx, jsint i, uintN flags);
-
-/*
- * Find or create the atom for a double value.  If we create a new atom, give
- * it the type indicated in flags.  Return 0 on failure to allocate memory.
- */
-extern JSAtom *
-js_AtomizeDouble(JSContext *cx, jsdouble d, uintN flags);
-
-/*
- * Find or create the atom for a string.  If we create a new atom, give it the
- * type indicated in flags.  Return 0 on failure to allocate memory.
- */
-extern JSAtom *
-js_AtomizeString(JSContext *cx, JSString *str, uintN flags);
-
-extern JS_FRIEND_API(JSAtom *)
-js_Atomize(JSContext *cx, const char *bytes, size_t length, uintN flags);
-
-extern JS_FRIEND_API(JSAtom *)
-js_AtomizeChars(JSContext *cx, const jschar *chars, size_t length, uintN flags);
-
-/*
- * This variant handles all value tag types.
- */
-extern JSAtom *
-js_AtomizeValue(JSContext *cx, jsval value, uintN flags);
-
-/*
- * Convert v to an atomized string.
- */
-extern JSAtom *
-js_ValueToStringAtom(JSContext *cx, jsval v);
-
-/*
- * Assign atom an index and insert it on al.
- */
-extern JSAtomListElement *
-js_IndexAtom(JSContext *cx, JSAtom *atom, JSAtomList *al);
-
-/*
- * Get the atom with index i from map.
- */
-extern JS_FRIEND_API(JSAtom *)
-js_GetAtom(JSContext *cx, JSAtomMap *map, jsatomid i);
-
-/*
- * For all unmapped atoms recorded in al, add a mapping from the atom's index
- * to its address.  The GC must not run until all indexed atoms in atomLists
- * have been mapped by scripts connected to live objects (Function and Script
- * class objects have scripts as/in their private data -- the GC knows about
- * these two classes).
- */
-extern JS_FRIEND_API(JSBool)
-js_InitAtomMap(JSContext *cx, JSAtomMap *map, JSAtomList *al);
-
-/*
- * Free map->vector and clear map.
- */
-extern JS_FRIEND_API(void)
-js_FreeAtomMap(JSContext *cx, JSAtomMap *map);
-
-JS_END_EXTERN_C
-
-#endif /* jsatom_h___ */

mozilla/js/src/jsbit.h

@@ -1,108 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsbit_h___
-#define jsbit_h___
-
-#include "jstypes.h"
-JS_BEGIN_EXTERN_C
-
-/*
-** A jsbitmap_t is a long integer that can be used for bitmaps
-*/
-typedef unsigned long jsbitmap_t;
-
-#define JS_TEST_BIT(_map,_bit) \
-    ((_map)[(_bit)>>JS_BITS_PER_LONG_LOG2] & (1L << ((_bit) & (JS_BITS_PER_LONG-1))))
-#define JS_SET_BIT(_map,_bit) \
-    ((_map)[(_bit)>>JS_BITS_PER_LONG_LOG2] |= (1L << ((_bit) & (JS_BITS_PER_LONG-1))))
-#define JS_CLEAR_BIT(_map,_bit) \
-    ((_map)[(_bit)>>JS_BITS_PER_LONG_LOG2] &= ~(1L << ((_bit) & (JS_BITS_PER_LONG-1))))
-
-/*
-** Compute the log of the least power of 2 greater than or equal to n
-*/
-extern JS_PUBLIC_API(JSIntn) JS_CeilingLog2(JSUint32 i); 
-
-/*
-** Compute the log of the greatest power of 2 less than or equal to n
-*/
-extern JS_PUBLIC_API(JSIntn) JS_FloorLog2(JSUint32 i); 
-
-/*
-** Macro version of JS_CeilingLog2: Compute the log of the least power of
-** 2 greater than or equal to _n. The result is returned in _log2.
-*/
-#define JS_CEILING_LOG2(_log2,_n)   \
-  JS_BEGIN_MACRO                    \
-    JSUint32 j_ = (JSUint32)(_n); 	\
-    (_log2) = 0;                    \
-    if ((j_) & ((j_)-1))            \
-	(_log2) += 1;               \
-    if ((j_) >> 16)                 \
-	(_log2) += 16, (j_) >>= 16; \
-    if ((j_) >> 8)                  \
-	(_log2) += 8, (j_) >>= 8;   \
-    if ((j_) >> 4)                  \
-	(_log2) += 4, (j_) >>= 4;   \
-    if ((j_) >> 2)                  \
-	(_log2) += 2, (j_) >>= 2;   \
-    if ((j_) >> 1)                  \
-	(_log2) += 1;               \
-  JS_END_MACRO
-
-/*
-** Macro version of JS_FloorLog2: Compute the log of the greatest power of
-** 2 less than or equal to _n. The result is returned in _log2.
-**
-** This is equivalent to finding the highest set bit in the word.
-*/
-#define JS_FLOOR_LOG2(_log2,_n)   \
-  JS_BEGIN_MACRO                    \
-    JSUint32 j_ = (JSUint32)(_n); 	\
-    (_log2) = 0;                    \
-    if ((j_) >> 16)                 \
-	(_log2) += 16, (j_) >>= 16; \
-    if ((j_) >> 8)                  \
-	(_log2) += 8, (j_) >>= 8;   \
-    if ((j_) >> 4)                  \
-	(_log2) += 4, (j_) >>= 4;   \
-    if ((j_) >> 2)                  \
-	(_log2) += 2, (j_) >>= 2;   \
-    if ((j_) >> 1)                  \
-	(_log2) += 1;               \
-  JS_END_MACRO
-
-JS_END_EXTERN_C
-#endif /* jsbit_h___ */

mozilla/js/src/jsbool.c

@@ -1,239 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS boolean implementation.
- */
-#include "jsstddef.h"
-#include "jstypes.h"
-#include "jsutil.h" /* Added by JSIFY */
-#include "jsapi.h"
-#include "jsatom.h"
-#include "jsbool.h"
-#include "jscntxt.h"
-#include "jsconfig.h"
-#include "jsinterp.h"
-#include "jslock.h"
-#include "jsnum.h"
-#include "jsobj.h"
-#include "jsstr.h"
-
-static JSClass boolean_class = {
-    "Boolean",
-    JSCLASS_HAS_PRIVATE,
-    JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
-    JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   JS_FinalizeStub,
-    JSCLASS_NO_OPTIONAL_MEMBERS
-};
-
-#if JS_HAS_TOSOURCE
-#include "jsprf.h"
-
-static JSBool
-bool_toSource(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
-	      jsval *rval)
-{
-    jsval v;
-    char buf[32];
-    JSString *str;
-
-    if (!JS_InstanceOf(cx, obj, &boolean_class, argv))
-	return JS_FALSE;
-    v = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-    if (!JSVAL_IS_BOOLEAN(v))
-	return js_obj_toSource(cx, obj, argc, argv, rval);
-    JS_snprintf(buf, sizeof buf, "(new %s(%s))",
-		boolean_class.name,
-		js_boolean_str[JSVAL_TO_BOOLEAN(v) ? 1 : 0]);
-    str = JS_NewStringCopyZ(cx, buf);
-    if (!str)
-	return JS_FALSE;
-    *rval = STRING_TO_JSVAL(str);
-    return JS_TRUE;
-}
-#endif
-
-static JSBool
-bool_toString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
-	      jsval *rval)
-{
-    jsval v;
-    JSAtom *atom;
-    JSString *str;
-
-    if (!JS_InstanceOf(cx, obj, &boolean_class, argv))
-	return JS_FALSE;
-    v = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-    if (!JSVAL_IS_BOOLEAN(v))
-	return js_obj_toString(cx, obj, argc, argv, rval);
-    atom = cx->runtime->atomState.booleanAtoms[JSVAL_TO_BOOLEAN(v) ? 1 : 0];
-    str = ATOM_TO_STRING(atom);
-    if (!str)
-	return JS_FALSE;
-    *rval = STRING_TO_JSVAL(str);
-    return JS_TRUE;
-}
-
-static JSBool
-bool_valueOf(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    if (!JS_InstanceOf(cx, obj, &boolean_class, argv))
-	return JS_FALSE;
-    *rval = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-    return JS_TRUE;
-}
-
-static JSFunctionSpec boolean_methods[] = {
-#if JS_HAS_TOSOURCE
-    {js_toSource_str,   bool_toSource,          0,0,0},
-#endif
-    {js_toString_str,	bool_toString,		0,0,0},
-    {js_valueOf_str,	bool_valueOf,		0,0,0},
-    {0,0,0,0,0}
-};
-
-#ifdef XP_MAC
-#undef Boolean
-#define Boolean js_Boolean
-#endif
-
-static JSBool
-Boolean(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    JSBool b;
-    jsval bval;
-
-    if (argc != 0) {
-	if (!js_ValueToBoolean(cx, argv[0], &b))
-	    return JS_FALSE;
-	bval = BOOLEAN_TO_JSVAL(b);
-    } else {
-	bval = JSVAL_FALSE;
-    }
-    if (!cx->fp->constructing) {
-	*rval = bval;
-	return JS_TRUE;
-    }
-    OBJ_SET_SLOT(cx, obj, JSSLOT_PRIVATE, bval);
-    return JS_TRUE;
-}
-
-JSObject *
-js_InitBooleanClass(JSContext *cx, JSObject *obj)
-{
-    JSObject *proto;
-
-    proto = JS_InitClass(cx, obj, NULL, &boolean_class, Boolean, 1,
-			NULL, boolean_methods, NULL, NULL);
-    if (!proto)
-	return NULL;
-    OBJ_SET_SLOT(cx, proto, JSSLOT_PRIVATE, JSVAL_FALSE);
-    return proto;
-}
-
-JSObject *
-js_BooleanToObject(JSContext *cx, JSBool b)
-{
-    JSObject *obj;
-
-    obj = js_NewObject(cx, &boolean_class, NULL, NULL);
-    if (!obj)
-	return NULL;
-    OBJ_SET_SLOT(cx, obj, JSSLOT_PRIVATE, BOOLEAN_TO_JSVAL(b));
-    return obj;
-}
-
-JSString *
-js_BooleanToString(JSContext *cx, JSBool b)
-{
-    return ATOM_TO_STRING(cx->runtime->atomState.booleanAtoms[b ? 1 : 0]);
-}
-
-JSBool
-js_ValueToBoolean(JSContext *cx, jsval v, JSBool *bp)
-{
-    JSBool b;
-    jsdouble d;
-
-#if defined XP_PC && defined _MSC_VER && _MSC_VER <= 800
-    /* MSVC1.5 coredumps */
-    if (!bp)
-	return JS_TRUE;
-    /* This should be an if-else chain, but MSVC1.5 crashes if it is. */
-#define ELSE
-#else
-#define ELSE else
-#endif
-
-    if (JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v)) {
-	/* Must return early to avoid falling thru to JSVAL_IS_OBJECT case. */
-	*bp = JS_FALSE;
-	return JS_TRUE;
-    }
-    if (JSVAL_IS_OBJECT(v)) {
-	if (!JSVERSION_IS_ECMA(cx->version)) {
-	    if (!OBJ_DEFAULT_VALUE(cx, JSVAL_TO_OBJECT(v), JSTYPE_BOOLEAN, &v))
-		return JS_FALSE;
-	    if (!JSVAL_IS_BOOLEAN(v))
-		v = JSVAL_TRUE;		/* non-null object is true */
-	    b = JSVAL_TO_BOOLEAN(v);
-	} else {
-	    b = JS_TRUE;
-	}
-    } ELSE
-    if (JSVAL_IS_STRING(v)) {
-	b = JSVAL_TO_STRING(v)->length ? JS_TRUE : JS_FALSE;
-    } ELSE
-    if (JSVAL_IS_INT(v)) {
-	b = JSVAL_TO_INT(v) ? JS_TRUE : JS_FALSE;
-    } ELSE
-    if (JSVAL_IS_DOUBLE(v)) {
-	d = *JSVAL_TO_DOUBLE(v);
-	b = (!JSDOUBLE_IS_NaN(d) && d != 0) ? JS_TRUE : JS_FALSE;
-    } ELSE
-#if defined XP_PC && defined _MSC_VER && _MSC_VER <= 800
-    if (JSVAL_IS_BOOLEAN(v)) {
-	b = JSVAL_TO_BOOLEAN(v);
-    }
-#else
-    {
-        JS_ASSERT(JSVAL_IS_BOOLEAN(v));
-	b = JSVAL_TO_BOOLEAN(v);
-    }
-#endif
-
-#undef ELSE
-    *bp = b;
-    return JS_TRUE;
-}

mozilla/js/src/jsbool.h

@@ -1,57 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsbool_h___
-#define jsbool_h___
-/*
- * JS boolean interface.
- */
-
-JS_BEGIN_EXTERN_C
-
-extern JSObject *
-js_InitBooleanClass(JSContext *cx, JSObject *obj);
-
-extern JSObject *
-js_BooleanToObject(JSContext *cx, JSBool b);
-
-extern JSString *
-js_BooleanToString(JSContext *cx, JSBool b);
-
-extern JSBool
-js_ValueToBoolean(JSContext *cx, jsval v, JSBool *bp);
-
-JS_END_EXTERN_C
-
-#endif /* jsbool_h___ */

mozilla/js/src/jsclist.h

@@ -1,135 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsclist_h___
-#define jsclist_h___
-
-#include "jstypes.h"
-
-/*
-** Circular linked list
-*/
-typedef struct JSCListStr {
-    struct JSCListStr *next;
-    struct JSCListStr *prev;
-} JSCList;
-
-/*
-** Insert element "_e" into the list, before "_l".
-*/
-#define JS_INSERT_BEFORE(_e,_l)	 \
-    JS_BEGIN_MACRO		 \
-	(_e)->next = (_l);	 \
-	(_e)->prev = (_l)->prev; \
-	(_l)->prev->next = (_e); \
-	(_l)->prev = (_e);	 \
-    JS_END_MACRO
-
-/*
-** Insert element "_e" into the list, after "_l".
-*/
-#define JS_INSERT_AFTER(_e,_l)	 \
-    JS_BEGIN_MACRO		 \
-	(_e)->next = (_l)->next; \
-	(_e)->prev = (_l);	 \
-	(_l)->next->prev = (_e); \
-	(_l)->next = (_e);	 \
-    JS_END_MACRO
-
-/*
-** Return the element following element "_e"
-*/
-#define JS_NEXT_LINK(_e)	 \
-    	((_e)->next)
-/*
-** Return the element preceding element "_e"
-*/
-#define JS_PREV_LINK(_e)	 \
-    	((_e)->prev)
-
-/*
-** Append an element "_e" to the end of the list "_l"
-*/
-#define JS_APPEND_LINK(_e,_l) JS_INSERT_BEFORE(_e,_l)
-
-/*
-** Insert an element "_e" at the head of the list "_l"
-*/
-#define JS_INSERT_LINK(_e,_l) JS_INSERT_AFTER(_e,_l)
-
-/* Return the head/tail of the list */
-#define JS_LIST_HEAD(_l) (_l)->next
-#define JS_LIST_TAIL(_l) (_l)->prev
-
-/*
-** Remove the element "_e" from it's circular list.
-*/
-#define JS_REMOVE_LINK(_e)	       \
-    JS_BEGIN_MACRO		       \
-	(_e)->prev->next = (_e)->next; \
-	(_e)->next->prev = (_e)->prev; \
-    JS_END_MACRO
-
-/*
-** Remove the element "_e" from it's circular list. Also initializes the
-** linkage.
-*/
-#define JS_REMOVE_AND_INIT_LINK(_e)    \
-    JS_BEGIN_MACRO		       \
-	(_e)->prev->next = (_e)->next; \
-	(_e)->next->prev = (_e)->prev; \
-	(_e)->next = (_e);	       \
-	(_e)->prev = (_e);	       \
-    JS_END_MACRO
-
-/*
-** Return non-zero if the given circular list "_l" is empty, zero if the
-** circular list is not empty
-*/
-#define JS_CLIST_IS_EMPTY(_l) \
-    ((_l)->next == (_l))
-
-/*
-** Initialize a circular list
-*/
-#define JS_INIT_CLIST(_l)  \
-    JS_BEGIN_MACRO	   \
-	(_l)->next = (_l); \
-	(_l)->prev = (_l); \
-    JS_END_MACRO
-
-#define JS_INIT_STATIC_CLIST(_l) \
-    {(_l), (_l)}
-
-#endif /* jsclist_h___ */

mozilla/js/src/jscntxt.c

@@ -1,586 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS execution context.
- */
-#include "jsstddef.h"
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
-#include "jstypes.h"
-#include "jsarena.h" /* Added by JSIFY */
-#include "jsutil.h" /* Added by JSIFY */
-#include "jsclist.h"
-#include "jsprf.h"
-#include "jsatom.h"
-#include "jscntxt.h"
-#include "jsconfig.h"
-#include "jsdbgapi.h"
-#include "jsexn.h"
-#include "jsgc.h"
-#include "jslock.h"
-#include "jsobj.h"
-#include "jsopcode.h"
-#include "jsscan.h"
-#include "jsscript.h"
-
-JSContext *
-js_NewContext(JSRuntime *rt, size_t stacksize)
-{
-    JSContext *cx;
-    JSBool ok, first;
-
-    cx = malloc(sizeof *cx);
-    if (!cx)
-	return NULL;
-    memset(cx, 0, sizeof *cx);
-
-    cx->runtime = rt;
-#ifdef JS_THREADSAFE
-    js_InitContextForLocking(cx);
-#endif
-
-    JS_LOCK_RUNTIME(rt);
-    for (;;) {
-	first = (rt->contextList.next == (JSCList *)&rt->contextList);
-	if (rt->state == JSRTS_UP) {
-	    JS_ASSERT(!first);
-	    break;
-	}
-	if (rt->state == JSRTS_DOWN) {
-	    JS_ASSERT(first);
-	    rt->state = JSRTS_LAUNCHING;
-	    break;
-	}
-	JS_WAIT_CONDVAR(rt->stateChange, JS_NO_TIMEOUT);
-    }
-    JS_APPEND_LINK(&cx->links, &rt->contextList);
-    JS_UNLOCK_RUNTIME(rt);
-
-    if (first) {
-	/* First context on this runtime: initialize atoms and keywords. */
-	ok = js_InitAtomState(cx, &rt->atomState);
-	if (ok)
-	    ok = js_InitScanner(cx);
-
-	JS_LOCK_RUNTIME(rt);
-	rt->state = JSRTS_UP;
-	JS_NOTIFY_ALL_CONDVAR(rt->stateChange);
-	JS_UNLOCK_RUNTIME(rt);
-
-	if (!ok) {
-	    free(cx);
-	    return NULL;
-	}
-    }
-
-    cx->version = JSVERSION_DEFAULT;
-    cx->jsop_eq = JSOP_EQ;
-    cx->jsop_ne = JSOP_NE;
-    JS_InitArenaPool(&cx->stackPool, "stack", stacksize, sizeof(jsval));
-    JS_InitArenaPool(&cx->codePool, "code", 1024, sizeof(jsbytecode));
-    JS_InitArenaPool(&cx->notePool, "note", 256, sizeof(jssrcnote));
-    JS_InitArenaPool(&cx->tempPool, "temp", 1024, sizeof(jsdouble));
-
-#if JS_HAS_REGEXPS
-    if (!js_InitRegExpStatics(cx, &cx->regExpStatics)) {
-	js_DestroyContext(cx, JS_FORCE_GC);
-	return NULL;
-    }
-#endif
-#if JS_HAS_EXCEPTIONS
-    cx->throwing = JS_FALSE;
-#endif
-
-    return cx;
-}
-
-void
-js_DestroyContext(JSContext *cx, JSGCMode gcmode)
-{
-    JSRuntime *rt;
-    JSBool last;
-    JSArgumentFormatMap *map;
-
-    rt = cx->runtime;
-
-    /* Remove cx from context list first. */
-    JS_LOCK_RUNTIME(rt);
-    JS_ASSERT(rt->state == JSRTS_UP);
-    JS_REMOVE_LINK(&cx->links);
-    last = (rt->contextList.next == (JSCList *)&rt->contextList);
-    if (last)
-    	rt->state = JSRTS_LANDING;
-    JS_UNLOCK_RUNTIME(rt);
-
-    if (last) {
-	/* Unpin all pinned atoms before final GC. */
-	js_UnpinPinnedAtoms(&rt->atomState);
-
-	/* Unlock GC things held by runtime pointers. */
-	js_UnlockGCThing(cx, rt->jsNaN);
-	js_UnlockGCThing(cx, rt->jsNegativeInfinity);
-	js_UnlockGCThing(cx, rt->jsPositiveInfinity);
-	js_UnlockGCThing(cx, rt->emptyString);
-
-	/*
-	 * Clear these so they get recreated if the standard classes are
-	 * initialized again.
-	 */
-	rt->jsNaN = NULL;
-	rt->jsNegativeInfinity = NULL;
-	rt->jsPositiveInfinity = NULL;
-	rt->emptyString = NULL;
-
-	/* Clear debugging state to remove GC roots. */
-	JS_ClearAllTraps(cx);
-	JS_ClearAllWatchPoints(cx);
-    }
-
-    /* Remove more GC roots in regExpStatics, then collect garbage. */
-#if JS_HAS_REGEXPS
-    js_FreeRegExpStatics(cx, &cx->regExpStatics);
-#endif
-
-    /* XXXbe this deadlocks with a GC waiting for this request to end */
-    if (gcmode == JS_FORCE_GC)
-        js_ForceGC(cx);
-    else if (gcmode == JS_MAYBE_GC)
-        JS_MaybeGC(cx);
-
-    if (last) {
-        if (gcmode == JS_NO_GC)
-            js_ForceGC(cx);
-
-	/* Free atom state now that we've run the GC. */
-	js_FreeAtomState(cx, &rt->atomState);
-    }
-
-    /* Free the stuff hanging off of cx. */
-    JS_FinishArenaPool(&cx->stackPool);
-    JS_FinishArenaPool(&cx->codePool);
-    JS_FinishArenaPool(&cx->notePool);
-    JS_FinishArenaPool(&cx->tempPool);
-    if (cx->lastMessage)
-	free(cx->lastMessage);
-
-#ifdef JS_THREADSAFE
-    /* Destroying a context implicitly calls JS_EndRequest(). */
-    if (cx->requestDepth)
-        JS_EndRequest(cx);
-#endif
-
-    /* remove any argument formatters */
-    map = cx->argumentFormatMap;
-    while (map) {
-        JSArgumentFormatMap *temp = map;
-        map = map->next;
-        JS_free(cx, temp);
-    }
-
-    free(cx);
-
-    if (last) {
-	JS_LOCK_RUNTIME(rt);
-    	rt->state = JSRTS_DOWN;
-	JS_NOTIFY_ALL_CONDVAR(rt->stateChange);
-	JS_UNLOCK_RUNTIME(rt);
-    }
-}
-
-JSContext *
-js_ContextIterator(JSRuntime *rt, JSContext **iterp)
-{
-    JSContext *cx = *iterp;
-
-    JS_LOCK_RUNTIME(rt);
-    if (!cx)
-	cx = (JSContext *)rt->contextList.next;
-    if ((void *)cx == &rt->contextList)
-	cx = NULL;
-    else
-	*iterp = (JSContext *)cx->links.next;
-    JS_UNLOCK_RUNTIME(rt);
-    return cx;
-}
-
-static void
-ReportError(JSContext *cx, const char *message, JSErrorReport *reportp)
-{
-    /*
-     * Check the error report, and set a JavaScript-catchable exception
-     * if the error is defined to have an associated exception.  If an
-     * exception is thrown, then the JSREPORT_EXCEPTION flag will be set
-     * on the error report, and exception-aware hosts should ignore it.
-     */
-    if (reportp && reportp->errorNumber == JSMSG_UNCAUGHT_EXCEPTION)
-        reportp->flags |= JSREPORT_EXCEPTION;
-
-#if JS_HAS_ERROR_EXCEPTIONS
-    /*
-     * Call the error reporter only if an exception wasn't raised.
-     *
-     * If an exception was raised, then we call the debugErrorHook
-     * (if present) to give it a chance to see the error before it
-     * propagates out of scope.  This is needed for compatability
-     * with the old scheme.
-     */
-    if (!js_ErrorToException(cx, message, reportp)) {
-        js_ReportErrorAgain(cx, message, reportp);
-    } else if (cx->runtime->debugErrorHook && cx->errorReporter) {
-        JSDebugErrorHook hook = cx->runtime->debugErrorHook;
-        /* test local in case debugErrorHook changed on another thread */
-        if (hook)
-            hook(cx, message, reportp, cx->runtime->debugErrorHookData);
-    }
-#else
-    js_ReportErrorAgain(cx, message, reportp);
-#endif
-}
-
-JSBool
-js_ReportErrorVA(JSContext *cx, uintN flags, const char *format, va_list ap)
-{
-    JSStackFrame *fp;
-    JSErrorReport report, *reportp;
-    char *last;
-    JSBool warning;
-
-    fp = cx->fp;
-
-    /* Walk stack until we find a frame that is associated with
-       some script rather than a native frame. */
-    while (fp && (!fp->script || !fp->pc))
-        fp = fp->down;
-
-    if (fp) {
-	report.filename = fp->script->filename;
-	report.lineno = js_PCToLineNumber(fp->script, fp->pc);
-	/* XXX should fetch line somehow */
-	report.linebuf = NULL;
-	report.tokenptr = NULL;
-        report.uclinebuf = NULL;
-        report.uctokenptr = NULL;
-	report.flags = flags;
-        report.errorNumber = 0;
-        report.ucmessage = NULL;
-        report.messageArgs = NULL;
-	reportp = &report;
-    } else {
-	/* XXXshaver still fill out report here for flags? */
-	reportp = NULL;
-    }
-    last = JS_vsmprintf(format, ap);
-    if (!last)
-	return JS_FALSE;
-
-    ReportError(cx, last, reportp);
-    free(last);
-
-    warning = JSREPORT_IS_WARNING(reportp->flags);
-    if (warning && JS_HAS_WERROR_OPTION(cx)) {
-        reportp->flags &= ~JSREPORT_WARNING;
-        warning = JS_FALSE;
-    }
-    return warning;
-}
-
-/*
- * The arguments from ap need to be packaged up into an array and stored
- * into the report struct.
- *
- * The format string addressed by the error number may contain operands
- * identified by the format {N}, where N is a decimal digit. Each of these
- * is to be replaced by the Nth argument from the va_list. The complete
- * message is placed into reportp->ucmessage converted to a JSString.
- *
- * Returns true if the expansion succeeds (can fail if out of memory).
- */
-JSBool
-js_ExpandErrorArguments(JSContext *cx, JSErrorCallback callback,
-			void *userRef, const uintN errorNumber,
-			char **messagep, JSErrorReport *reportp,
-                        JSBool *warningp, JSBool charArgs, va_list ap)
-{
-    const JSErrorFormatString *fmtData;
-    int i;
-    int argCount;
-
-    *warningp = JSREPORT_IS_WARNING(reportp->flags);
-    if (*warningp && JS_HAS_WERROR_OPTION(cx)) {
-        reportp->flags &= ~JSREPORT_WARNING;
-        *warningp = JS_FALSE;
-    }
-
-    *messagep = NULL;
-    if (callback) {
-	fmtData = (*callback)(userRef, "Mountain View", errorNumber);
-	if (fmtData != NULL) {
-            size_t totalArgsLength = 0;
-            size_t argLengths[10]; /* only {0} thru {9} supported */
-	    argCount = fmtData->argCount;
-            JS_ASSERT(argCount <= 10);
-	    if (argCount > 0) {
-		/*
-                 * Gather the arguments into an array, and accumulate
-                 * their sizes. We allocate 1 more than necessary and
-                 * null it out to act as the caboose when we free the
-                 * pointers later.
-		 */
-		reportp->messageArgs
-                        = JS_malloc(cx, sizeof(jschar *) * (argCount + 1));
-		if (!reportp->messageArgs)
-		    return JS_FALSE;
-                reportp->messageArgs[argCount] = NULL;
-                for (i = 0; i < argCount; i++) {
-                    if (charArgs) {
-                        char *charArg = va_arg(ap, char *);
-		        reportp->messageArgs[i]
-                            = js_InflateString(cx, charArg, strlen(charArg));
-                    }
-                    else
-		        reportp->messageArgs[i] = va_arg(ap, jschar *);
-                    argLengths[i] = js_strlen(reportp->messageArgs[i]);
-                    totalArgsLength += argLengths[i];
-                }
-                /* NULL-terminate for easy copying. */
-                reportp->messageArgs[i] = NULL;
-	    }
-	    /*
-	     * Parse the error format, substituting the argument X
-	     * for {X} in the format.
-	     */
-	    if (argCount > 0) {
-		if (fmtData->format) {
-		    const char *fmt;
-                    const jschar *arg;
-		    jschar *out;
-		    int expandedArgs = 0;
-		    size_t expandedLength
-			= strlen(fmtData->format)
-			  - (3 * argCount) /* exclude the {n} */
-                          + totalArgsLength;
-		    /*
-		     * Note - the above calculation assumes that each argument
-		     * is used once and only once in the expansion !!!
-		     */
-		    reportp->ucmessage = out
-                        = JS_malloc(cx, (expandedLength + 1) * sizeof(jschar));
-		    if (!out) {
-			if (reportp->messageArgs) {
-			    JS_free(cx, (void *)reportp->messageArgs);
-			    reportp->messageArgs = NULL;
-			}
-			return JS_FALSE;
-		    }
-		    fmt = fmtData->format;
-		    while (*fmt) {
-			if (*fmt == '{') {	/* balance} */
-			    if (isdigit(fmt[1])) {
-				int d = JS7_UNDEC(fmt[1]);
-				JS_ASSERT(expandedArgs < argCount);
-				arg = reportp->messageArgs[d];
-				js_strncpy(out, arg, argLengths[d]);
-				out += argLengths[d];
-				fmt += 3;
-				expandedArgs++;
-				continue;
-			    }
-			}
-                        /*
-                         * is this kosher?
-                         */
-			*out++ = (unsigned char)(*fmt++);
-		    }
-		    JS_ASSERT(expandedArgs == argCount);
-		    *out = 0;
-                    *messagep =
-			js_DeflateString(cx, reportp->ucmessage,
-					 (size_t)(out - reportp->ucmessage));
-		}
-            } else {
-            	/*
-            	 * Zero arguments: the format string (if it exists) is the
-            	 * entire message.
-            	 */
-                if (fmtData->format) {
-		    *messagep = JS_strdup(cx, fmtData->format);
-                    reportp->ucmessage
-                        = js_InflateString(cx, *messagep, strlen(*messagep));
-                }
-	    }
-	}
-    }
-    if (*messagep == NULL) {
-	/* where's the right place for this ??? */
-	const char *defaultErrorMessage
-	    = "No error message available for error number %d";
-	size_t nbytes = strlen(defaultErrorMessage) + 16;
-	*messagep = (char *)JS_malloc(cx, nbytes);
-	JS_snprintf(*messagep, nbytes, defaultErrorMessage, errorNumber);
-    }
-    return JS_TRUE;
-}
-
-JSBool
-js_ReportErrorNumberVA(JSContext *cx, uintN flags, JSErrorCallback callback,
-                       void *userRef, const uintN errorNumber,
-                       JSBool charArgs, va_list ap)
-{
-    JSStackFrame *fp;
-    JSErrorReport report;
-    char *message;
-    JSBool warning;
-
-    report.messageArgs = NULL;
-    report.ucmessage = NULL;
-    message = NULL;
-
-    fp = cx->fp;
-    if (fp && fp->script && fp->pc) {
-	report.filename = fp->script->filename;
-	report.lineno = js_PCToLineNumber(fp->script, fp->pc);
-    } else {
-        /*  We can't find out where the error was from the current
-            frame so see if the next frame has a script/pc combo we
-            could use */
-        if (fp && fp->down && fp->down->script && fp->down->pc) {
-	    report.filename = fp->down->script->filename;
-	    report.lineno = js_PCToLineNumber(fp->down->script, fp->down->pc);
-        }
-        else {
-	    report.filename = NULL;
-	    report.lineno = 0;
-        }
-    }
-
-    /* XXX should fetch line somehow */
-    report.linebuf = NULL;
-    report.tokenptr = NULL;
-    report.flags = flags;
-    report.errorNumber = errorNumber;
-
-    /*
-     * XXX js_ExpandErrorArguments only sometimes fills these in, so we
-     * initialize them to clear garbage.
-     */
-    report.uclinebuf = NULL;
-    report.uctokenptr = NULL;
-    report.ucmessage = NULL;
-    report.messageArgs = NULL;
-
-    if (!js_ExpandErrorArguments(cx, callback, userRef, errorNumber,
-				 &message, &report, &warning, charArgs, ap)) {
-	return JS_FALSE;
-    }
-
-    ReportError(cx, message, &report);
-
-    if (message)
-	JS_free(cx, message);
-    if (report.messageArgs) {
-        int i = 0;
-        while (report.messageArgs[i])
-            JS_free(cx, (void *)report.messageArgs[i++]);
-        JS_free(cx, (void *)report.messageArgs);
-    }
-    if (report.ucmessage)
-        JS_free(cx, (void *)report.ucmessage);
-
-    return warning;
-}
-
-JS_FRIEND_API(void)
-js_ReportErrorAgain(JSContext *cx, const char *message, JSErrorReport *reportp)
-{
-    JSErrorReporter onError;
-
-    if (!message)
-	return;
-
-    if (cx->lastMessage)
-	free(cx->lastMessage);
-    cx->lastMessage = JS_strdup(cx, message);
-    if (!cx->lastMessage)
-	return;
-    onError = cx->errorReporter;
-
-    /*
-     * If debugErrorHook is present then we give it a chance to veto
-     * sending the error on to the regular ErrorReporter.
-     */
-    if (cx->runtime->debugErrorHook && onError) {
-        JSDebugErrorHook hook = cx->runtime->debugErrorHook;
-        /* test local in case debugErrorHook changed on another thread */
-        if (hook && !hook(cx, message, reportp,
-                          cx->runtime->debugErrorHookData)) {
-            onError = NULL;
-        }
-    }
-    if (onError)
-	(*onError)(cx, cx->lastMessage, reportp);
-}
-
-void
-js_ReportIsNotDefined(JSContext *cx, const char *name)
-{
-    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NOT_DEFINED, name);
-}
-
-#if defined DEBUG && defined XP_UNIX
-/* For gdb usage. */
-void js_traceon(JSContext *cx)  { cx->tracefp = stderr; }
-void js_traceoff(JSContext *cx) { cx->tracefp = NULL; }
-#endif
-
-JSErrorFormatString js_ErrorFormatString[JSErr_Limit] = {
-#if JS_HAS_DFLT_MSG_STRINGS
-#define MSG_DEF(name, number, count, exception, format) \
-    { format, count } ,
-#else
-#define MSG_DEF(name, number, count, exception, format) \
-    { NULL, count } ,
-#endif
-#include "js.msg"
-#undef MSG_DEF
-};
-
-const JSErrorFormatString *
-js_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber)
-{
-    if ((errorNumber > 0) && (errorNumber < JSErr_Limit))
-        return &js_ErrorFormatString[errorNumber];
-    return NULL;
-}

mozilla/js/src/jscntxt.h

@@ -1,295 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jscntxt_h___
-#define jscntxt_h___
-/*
- * JS execution context.
- */
-#include "jsarena.h" /* Added by JSIFY */
-#include "jsclist.h"
-#include "jslong.h"
-#include "jsatom.h"
-#include "jsconfig.h"
-#include "jsgc.h"
-#include "jsinterp.h"
-#include "jsobj.h"
-#include "jsprvtd.h"
-#include "jspubtd.h"
-#include "jsregexp.h"
-
-JS_BEGIN_EXTERN_C
-
-typedef enum JSGCMode { JS_NO_GC, JS_MAYBE_GC, JS_FORCE_GC } JSGCMode;
-
-typedef enum JSRuntimeState {
-    JSRTS_DOWN,
-    JSRTS_LAUNCHING,
-    JSRTS_UP,
-    JSRTS_LANDING
-} JSRuntimeState;
-
-struct JSRuntime {
-    JSRuntimeState      state;
-
-    /* Garbage collector state, used by jsgc.c. */
-    JSArenaPool         gcArenaPool;
-    JSArenaPool         gcFlagsPool;
-    JSHashTable         *gcRootsHash;
-    JSGCThing           *gcFreeList;
-    jsword              gcDisabled;
-    uint32              gcBytes;
-    uint32              gcLastBytes;
-    uint32              gcMaxBytes;
-    uint32              gcLevel;
-    uint32              gcNumber;
-    JSBool              gcPoke;
-    JSGCCallback        gcCallback;
-    uint32              gcMallocBytes;
-#ifdef JS_GCMETER
-    JSGCStats           gcStats;
-#endif
-
-    /* Literal table maintained by jsatom.c functions. */
-    JSAtomState         atomState;
-
-    /* Random number generator state, used by jsmath.c. */
-    JSBool              rngInitialized;
-    int64               rngMultiplier;
-    int64               rngAddend;
-    int64               rngMask;
-    int64               rngSeed;
-    jsdouble            rngDscale;
-
-    /* Well-known numbers held for use by this runtime's contexts. */
-    jsdouble            *jsNaN;
-    jsdouble            *jsNegativeInfinity;
-    jsdouble            *jsPositiveInfinity;
-
-    /* Empty string held for use by this runtime's contexts. */
-    JSString            *emptyString;
-
-    /* List of active contexts sharing this runtime. */
-    JSCList             contextList;
-
-    /* These are used for debugging -- see jsprvtd.h and jsdbgapi.h. */
-    JSTrapHandler       interruptHandler;
-    void                *interruptHandlerData;
-    JSNewScriptHook     newScriptHook;
-    void                *newScriptHookData;
-    JSDestroyScriptHook destroyScriptHook;
-    void                *destroyScriptHookData;
-    JSTrapHandler       debuggerHandler;
-    void                *debuggerHandlerData;
-    JSSourceHandler     sourceHandler;
-    void                *sourceHandlerData;
-    JSInterpreterHook   executeHook;
-    void                *executeHookData;
-    JSInterpreterHook   callHook;
-    void                *callHookData;
-    JSObjectHook        objectHook;
-    void                *objectHookData;
-    JSTrapHandler       throwHook;
-    void                *throwHookData;
-    JSDebugErrorHook    debugErrorHook;
-    void                *debugErrorHookData;
-
-    /* More debugging state, see jsdbgapi.c. */
-    JSCList             trapList;
-    JSCList             watchPointList;
-
-    /* Weak links to properties, indexed by quickened get/set opcodes. */
-    /* XXX must come after JSCLists or MSVC alignment bug bites empty lists */
-    JSPropertyCache     propertyCache;
-
-#ifdef JS_THREADSAFE
-    /* These combine to interlock the GC and new requests. */
-    PRLock              *gcLock;
-    PRCondVar           *gcDone;
-    PRCondVar           *requestDone;
-    uint32              requestCount;
-
-    /* Lock and owning thread pointer for JS_LOCK_RUNTIME. */
-    PRLock              *rtLock;
-#ifdef DEBUG
-    jsword              rtLockOwner;
-#endif
-
-    /* Used to synchronize down/up state change; uses rtLock. */
-    PRCondVar           *stateChange;
-#endif
-};
-
-#define JS_ENABLE_GC(rt)    JS_ATOMIC_ADDREF(&(rt)->gcDisabled, -1);
-#define JS_DISABLE_GC(rt)   JS_ATOMIC_ADDREF(&(rt)->gcDisabled, 1);
-
-#ifdef JS_ARGUMENT_FORMATTER_DEFINED
-/*
- * Linked list mapping format strings for JS_{Convert,Push}Arguments{,VA} to
- * formatter functions.  Elements are sorted in non-increasing format string
- * length order.
- */
-struct JSArgumentFormatMap {
-    const char          *format;
-    size_t              length;
-    JSArgumentFormatter formatter;
-    JSArgumentFormatMap *next;
-};
-#endif
-
-struct JSContext {
-    JSCList             links;
-
-    /* Interpreter activation count. */
-    uintN               interpLevel;
-
-    /* Runtime version control identifier and equality operators. */
-    JSVersion           version;
-    jsbytecode          jsop_eq;
-    jsbytecode          jsop_ne;
-
-    /* Data shared by threads in an address space. */
-    JSRuntime           *runtime;
-
-    /* Stack arena pool and frame pointer register. */
-    JSArenaPool         stackPool;
-    JSStackFrame        *fp;
-
-    /* Temporary arena pools used while compiling and decompiling. */
-    JSArenaPool         codePool;
-    JSArenaPool         notePool;
-    JSArenaPool         tempPool;
-
-    /* Top-level object and pointer to top stack frame's scope chain. */
-    JSObject            *globalObject;
-
-    /* Most recently created things by type, members of the GC's root set. */
-    JSGCThing           *newborn[GCX_NTYPES];
-
-    /* Regular expression class statics (XXX not shared globally). */
-    JSRegExpStatics     regExpStatics;
-
-    /* State for object and array toSource conversion. */
-    JSSharpObjectMap    sharpObjectMap;
-
-    /* Argument formatter support for JS_{Convert,Push}Arguments{,VA}. */
-    JSArgumentFormatMap *argumentFormatMap;
-
-    /* Last message string and trace file for debugging. */
-    char                *lastMessage;
-#ifdef DEBUG
-    void                *tracefp;
-#endif
-
-    /* Per-context optional user callbacks. */
-    JSBranchCallback    branchCallback;
-    JSErrorReporter     errorReporter;
-
-    /* Client opaque pointer */
-    void                *data;
-
-    /* GC and thread-safe state. */
-    JSStackFrame        *dormantFrameChain; /* dormant stack frame to scan */
-#ifdef JS_THREADSAFE
-    jsword              thread;
-    jsrefcount          requestDepth;
-    JSPackedBool        gcActive;
-#endif
-
-    /* Exception state (NB: throwing is packed with gcActive above). */
-    JSPackedBool        throwing;           /* is there a pending exception? */
-    jsval               exception;          /* most-recently-thrown exceptin */
-
-    uint32              options;            /* see jsapi.h for JSOPTION_* */
-};
-
-/* Slightly more readable macros, also to hide bitset implementation detail. */
-#define JS_HAS_STRICT_OPTION(cx)    ((cx)->options & JSOPTION_STRICT)
-#define JS_HAS_WERROR_OPTION(cx)    ((cx)->options & JSOPTION_WERROR)
-
-extern JSContext *
-js_NewContext(JSRuntime *rt, size_t stacksize);
-
-extern void
-js_DestroyContext(JSContext *cx, JSGCMode gcmode);
-
-extern JSContext *
-js_ContextIterator(JSRuntime *rt, JSContext **iterp);
-
-/*
- * Report an exception, which is currently realized as a printf-style format
- * string and its arguments.
- */
-typedef enum JSErrNum {
-#define MSG_DEF(name, number, count, exception, format) \
-    name = number,
-#include "js.msg"
-#undef MSG_DEF
-    JSErr_Limit
-} JSErrNum;
-
-extern const JSErrorFormatString *
-js_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber);
-
-#ifdef va_start
-extern JSBool
-js_ReportErrorVA(JSContext *cx, uintN flags, const char *format, va_list ap);
-
-extern JSBool
-js_ReportErrorNumberVA(JSContext *cx, uintN flags, JSErrorCallback callback,
-		       void *userRef, const uintN errorNumber,
-                       JSBool charArgs, va_list ap);
-
-extern JSBool
-js_ExpandErrorArguments(JSContext *cx, JSErrorCallback callback,
-			void *userRef, const uintN errorNumber,
-			char **message, JSErrorReport *reportp,
-                        JSBool *warningp, JSBool charArgs, va_list ap);
-#endif
-
-/*
- * Report an exception using a previously composed JSErrorReport.
- * XXXbe remove from "friend" API
- */
-extern JS_FRIEND_API(void)
-js_ReportErrorAgain(JSContext *cx, const char *message, JSErrorReport *report);
-
-extern void
-js_ReportIsNotDefined(JSContext *cx, const char *name);
-
-extern JSErrorFormatString js_ErrorFormatString[JSErr_Limit];
-
-JS_END_EXTERN_C
-
-#endif /* jscntxt_h___ */

mozilla/js/src/jscompat.h

@@ -1,20 +0,0 @@
-/* -*- Mode: C; tab-width: 8 -*-
- * Copyright © 1996 Netscape Communications Corporation, All Rights Reserved.
- */
-#ifndef jscompat_h___
-#define jscompat_h___
-/*
- * Compatibility glue for various NSPR versions.  We must always define int8,
- * int16, jsword, and so on to minimize differences with js/ref, no matter what
- * the NSPR typedef names may be.
- */
-#include "jstypes.h"
-#include "jslong.h"
-
-typedef JSIntn intN;
-typedef JSUintn uintN;
-typedef JSUword jsuword;
-typedef JSWord jsword;
-typedef float float32;
-#define allocPriv allocPool
-#endif /* jscompat_h___ */

mozilla/js/src/jsconfig.h

@@ -1,382 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS configuration macros.
- */
-#ifndef JS_VERSION
-#define JS_VERSION 150
-#endif
-
-#if JS_VERSION == 100
-
-#define JS_BUG_AUTO_INDEX_PROPS 1       /* new object o: o.p = v sets o[0] */
-#define JS_BUG_NULL_INDEX_PROPS 1       /* o[0] defaults to null, not void */
-#define JS_BUG_EMPTY_INDEX_ZERO 1       /* o[""] is equivalent to o[0] */
-#define JS_BUG_SHORT_CIRCUIT    1       /* 1 && 1 => true, 1 && 0 => 0 bug */
-#define JS_BUG_EAGER_TOSTRING   1       /* o.toString() trumps o.valueOf() */
-#define JS_BUG_VOID_TOSTRING    0       /* void 0 + 0 == "undefined0" */
-#define JS_BUG_EVAL_THIS_FUN    0       /* eval('this') in function f is f */
-#define JS_BUG_EVAL_THIS_SCOPE  0       /* Math.eval('sin(x)') vs. local x */
-#define JS_BUG_FALLIBLE_EQOPS   1       /* fallible/intransitive equality ops */
-#define JS_BUG_FALLIBLE_TONUM   1       /* fallible ValueToNumber primitive */
-#define JS_BUG_WITH_CLOSURE     0       /* with(o)function f(){} sets o.f */
-#define JS_BUG_SET_ENUMERATE    1       /* o.p=q flags o.p JSPROP_ENUMERATE */
-
-#define JS_HAS_PROP_DELETE      0       /* delete o.p removes p from o */
-#define JS_HAS_CALL_OBJECT      0       /* fun.caller is stack frame obj */
-#define JS_HAS_LABEL_STATEMENT  0       /* has break/continue to label: */
-#define JS_HAS_DO_WHILE_LOOP    0       /* has do {...} while (b) */
-#define JS_HAS_SWITCH_STATEMENT 0       /* has switch (v) {case c: ...} */
-#define JS_HAS_SOME_PERL_FUN    0       /* has array.join/reverse/sort */
-#define JS_HAS_MORE_PERL_FUN    0       /* has array.push, str.substr, etc */
-#define JS_HAS_VALUEOF_HINT     0       /* valueOf(hint) where hint is typeof */
-#define JS_HAS_LEXICAL_CLOSURE  0       /* nested functions, lexically closed */
-#define JS_HAS_APPLY_FUNCTION   0       /* has fun.apply(obj, argArray) */
-#define JS_HAS_CALL_FUNCTION    0       /* has fun.call(obj, arg1, ... argN) */
-#define JS_HAS_OBJ_PROTO_PROP   0       /* has o.__proto__ etc. */
-#define JS_HAS_REGEXPS          0       /* has perl r.e.s via RegExp, /pat/ */
-#define JS_HAS_SEQUENCE_OPS     0       /* has array.slice, string.concat */
-#define JS_HAS_INITIALIZERS     0       /* has var o = {'foo': 42, 'bar':3} */
-#define JS_HAS_OBJ_WATCHPOINT   0       /* has o.watch and o.unwatch */
-#define JS_HAS_EXPORT_IMPORT    0       /* has export fun; import obj.fun */
-#define JS_HAS_EVAL_THIS_SCOPE  0       /* Math.eval is same as with (Math) */
-#define JS_HAS_TRIPLE_EQOPS     0       /* has === and !== identity eqops */
-#define JS_HAS_SHARP_VARS       0       /* has #n=, #n# for object literals */
-#define JS_HAS_REPLACE_LAMBDA   0       /* has string.replace(re, lambda) */
-#define JS_HAS_SCRIPT_OBJECT    0       /* has (new Script("x++")).exec() */
-#define JS_HAS_XDR              0       /* has XDR API and object methods */
-#define JS_HAS_EXCEPTIONS       0       /* has exception handling */
-#define JS_HAS_UNDEFINED        0       /* has global "undefined" property */
-#define JS_HAS_TOSOURCE         0       /* has Object/Array toSource method */
-#define JS_HAS_IN_OPERATOR      0       /* has in operator ('p' in {p:1}) */
-#define JS_HAS_INSTANCEOF       0       /* has {p:1} instanceof Object */
-#define JS_HAS_ARGS_OBJECT      0       /* has minimal ECMA arguments object */
-#define JS_HAS_DEBUGGER_KEYWORD 0       /* has hook for debugger keyword */
-#define JS_HAS_ERROR_EXCEPTIONS 0       /* has error object hierarchy */
-#define JS_HAS_CATCH_GUARD      0       /* has exception handling catch guard */
-#define JS_HAS_NEW_OBJ_METHODS  0       /* has Object.prototype query methods */
-#define JS_HAS_SPARSE_ARRAYS    0       /* array methods preserve empty elems */
-#define JS_HAS_DFLT_MSG_STRINGS 1       /* provides English error messages */
-#define JS_HAS_NUMBER_FORMATS   0       /* numbers have formatting methods */
-#define JS_HAS_GETTER_SETTER    0       /* has JS2 getter/setter functions */
-#define JS_HAS_UNEVAL           0       /* has uneval() top-level function */
-#define JS_HAS_CONST            0       /* has JS2 const as alternative var */
-#define JS_HAS_FUN_EXPR_STMT    0       /* has function expression statement */
-
-#elif JS_VERSION == 110
-
-#define JS_BUG_AUTO_INDEX_PROPS 0       /* new object o: o.p = v sets o[0] */
-#define JS_BUG_NULL_INDEX_PROPS 1       /* o[0] defaults to null, not void */
-#define JS_BUG_EMPTY_INDEX_ZERO 1       /* o[""] is equivalent to o[0] */
-#define JS_BUG_SHORT_CIRCUIT    1       /* 1 && 1 => true, 1 && 0 => 0 bug */
-#define JS_BUG_EAGER_TOSTRING   1       /* o.toString() trumps o.valueOf() */
-#define JS_BUG_VOID_TOSTRING    0       /* void 0 + 0 == "undefined0" */
-#define JS_BUG_EVAL_THIS_FUN    1       /* eval('this') in function f is f */
-#define JS_BUG_EVAL_THIS_SCOPE  1       /* Math.eval('sin(x)') vs. local x */
-#define JS_BUG_FALLIBLE_EQOPS   1       /* fallible/intransitive equality ops */
-#define JS_BUG_FALLIBLE_TONUM   1       /* fallible ValueToNumber primitive */
-#define JS_BUG_WITH_CLOSURE     0       /* with(o)function f(){} sets o.f */
-#define JS_BUG_SET_ENUMERATE    1       /* o.p=q flags o.p JSPROP_ENUMERATE */
-
-#define JS_HAS_PROP_DELETE      0       /* delete o.p removes p from o */
-#define JS_HAS_CALL_OBJECT      0       /* fun.caller is stack frame obj */
-#define JS_HAS_LABEL_STATEMENT  0       /* has break/continue to label: */
-#define JS_HAS_DO_WHILE_LOOP    0       /* has do {...} while (b) */
-#define JS_HAS_SWITCH_STATEMENT 0       /* has switch (v) {case c: ...} */
-#define JS_HAS_SOME_PERL_FUN    1       /* has array.join/reverse/sort */
-#define JS_HAS_MORE_PERL_FUN    0       /* has array.push, str.substr, etc */
-#define JS_HAS_VALUEOF_HINT     0       /* valueOf(hint) where hint is typeof */
-#define JS_HAS_LEXICAL_CLOSURE  0       /* nested functions, lexically closed */
-#define JS_HAS_APPLY_FUNCTION   0       /* has apply(fun, arg1, ... argN) */
-#define JS_HAS_CALL_FUNCTION    0       /* has fun.call(obj, arg1, ... argN) */
-#define JS_HAS_OBJ_PROTO_PROP   0       /* has o.__proto__ etc. */
-#define JS_HAS_REGEXPS          0       /* has perl r.e.s via RegExp, /pat/ */
-#define JS_HAS_SEQUENCE_OPS     0       /* has array.slice, string.concat */
-#define JS_HAS_INITIALIZERS     0       /* has var o = {'foo': 42, 'bar':3} */
-#define JS_HAS_OBJ_WATCHPOINT   0       /* has o.watch and o.unwatch */
-#define JS_HAS_EXPORT_IMPORT    0       /* has export fun; import obj.fun */
-#define JS_HAS_EVAL_THIS_SCOPE  0       /* Math.eval is same as with (Math) */
-#define JS_HAS_TRIPLE_EQOPS     0       /* has === and !== identity eqops */
-#define JS_HAS_SHARP_VARS       0       /* has #n=, #n# for object literals */
-#define JS_HAS_REPLACE_LAMBDA   0       /* has string.replace(re, lambda) */
-#define JS_HAS_SCRIPT_OBJECT    0       /* has (new Script("x++")).exec() */
-#define JS_HAS_XDR              0       /* has XDR API and object methods */
-#define JS_HAS_EXCEPTIONS       0       /* has exception handling */
-#define JS_HAS_UNDEFINED        0       /* has global "undefined" property */
-#define JS_HAS_TOSOURCE         0       /* has Object/Array toSource method */
-#define JS_HAS_IN_OPERATOR      0       /* has in operator ('p' in {p:1}) */
-#define JS_HAS_INSTANCEOF       0       /* has {p:1} instanceof Object */
-#define JS_HAS_ARGS_OBJECT      0       /* has minimal ECMA arguments object */
-#define JS_HAS_DEBUGGER_KEYWORD 0       /* has hook for debugger keyword */
-#define JS_HAS_ERROR_EXCEPTIONS 0       /* has error object hierarchy */
-#define JS_HAS_CATCH_GUARD      0       /* has exception handling catch guard */
-#define JS_HAS_NEW_OBJ_METHODS  0       /* has Object.prototype query methods */
-#define JS_HAS_SPARSE_ARRAYS    0       /* array methods preserve empty elems */
-#define JS_HAS_DFLT_MSG_STRINGS 1       /* provides English error messages */
-#define JS_HAS_NUMBER_FORMATS   0       /* numbers have formatting methods */
-#define JS_HAS_GETTER_SETTER    0       /* has JS2 getter/setter functions */
-#define JS_HAS_UNEVAL           0       /* has uneval() top-level function */
-#define JS_HAS_CONST            0       /* has JS2 const as alternative var */
-#define JS_HAS_FUN_EXPR_STMT    0       /* has function expression statement */
-
-#elif JS_VERSION == 120
-
-#define JS_BUG_AUTO_INDEX_PROPS 0       /* new object o: o.p = v sets o[0] */
-#define JS_BUG_NULL_INDEX_PROPS 0       /* o[0] defaults to null, not void */
-#define JS_BUG_EMPTY_INDEX_ZERO 0       /* o[""] is equivalent to o[0] */
-#define JS_BUG_SHORT_CIRCUIT    0       /* 1 && 1 => true, 1 && 0 => 0 bug */
-#define JS_BUG_EAGER_TOSTRING   0       /* o.toString() trumps o.valueOf() */
-#define JS_BUG_VOID_TOSTRING    1       /* void 0 + 0 == "undefined0" */
-#define JS_BUG_EVAL_THIS_FUN    0       /* eval('this') in function f is f */
-#define JS_BUG_EVAL_THIS_SCOPE  0       /* Math.eval('sin(x)') vs. local x */
-#define JS_BUG_FALLIBLE_EQOPS   0       /* fallible/intransitive equality ops */
-#define JS_BUG_FALLIBLE_TONUM   0       /* fallible ValueToNumber primitive */
-#define JS_BUG_WITH_CLOSURE     1       /* with(o)function f(){} sets o.f */
-#define JS_BUG_SET_ENUMERATE    1       /* o.p=q flags o.p JSPROP_ENUMERATE */
-
-#define JS_HAS_PROP_DELETE      1       /* delete o.p removes p from o */
-#define JS_HAS_CALL_OBJECT      1       /* fun.caller is stack frame obj */
-#define JS_HAS_LABEL_STATEMENT  1       /* has break/continue to label: */
-#define JS_HAS_DO_WHILE_LOOP    1       /* has do {...} while (b) */
-#define JS_HAS_SWITCH_STATEMENT 1       /* has switch (v) {case c: ...} */
-#define JS_HAS_SOME_PERL_FUN    1       /* has array.join/reverse/sort */
-#define JS_HAS_MORE_PERL_FUN    1       /* has array.push, str.substr, etc */
-#define JS_HAS_VALUEOF_HINT     1       /* valueOf(hint) where hint is typeof */
-#define JS_HAS_LEXICAL_CLOSURE  1       /* nested functions, lexically closed */
-#define JS_HAS_APPLY_FUNCTION   1       /* has apply(fun, arg1, ... argN) */
-#define JS_HAS_CALL_FUNCTION    0       /* has fun.call(obj, arg1, ... argN) */
-#define JS_HAS_OBJ_PROTO_PROP   1       /* has o.__proto__ etc. */
-#define JS_HAS_REGEXPS          1       /* has perl r.e.s via RegExp, /pat/ */
-#define JS_HAS_SEQUENCE_OPS     1       /* has array.slice, string.concat */
-#define JS_HAS_INITIALIZERS     1       /* has var o = {'foo': 42, 'bar':3} */
-#define JS_HAS_OBJ_WATCHPOINT   1       /* has o.watch and o.unwatch */
-#define JS_HAS_EXPORT_IMPORT    1       /* has export fun; import obj.fun */
-#define JS_HAS_EVAL_THIS_SCOPE  1       /* Math.eval is same as with (Math) */
-#define JS_HAS_TRIPLE_EQOPS     0       /* has === and !== identity eqops */
-#define JS_HAS_SHARP_VARS       0       /* has #n=, #n# for object literals */
-#define JS_HAS_REPLACE_LAMBDA   0       /* has string.replace(re, lambda) */
-#define JS_HAS_SCRIPT_OBJECT    0       /* has (new Script("x++")).exec() */
-#define JS_HAS_XDR              0       /* has XDR API and object methods */
-#define JS_HAS_EXCEPTIONS       0       /* has exception handling */
-#define JS_HAS_UNDEFINED        0       /* has global "undefined" property */
-#define JS_HAS_TOSOURCE         0       /* has Object/Array toSource method */
-#define JS_HAS_IN_OPERATOR      0       /* has in operator ('p' in {p:1}) */
-#define JS_HAS_INSTANCEOF       0       /* has {p:1} instanceof Object */
-#define JS_HAS_ARGS_OBJECT      0       /* has minimal ECMA arguments object */
-#define JS_HAS_DEBUGGER_KEYWORD 0       /* has hook for debugger keyword */
-#define JS_HAS_ERROR_EXCEPTIONS 0       /* has error object hierarchy */
-#define JS_HAS_CATCH_GUARD      0       /* has exception handling catch guard */
-#define JS_HAS_NEW_OBJ_METHODS  0       /* has Object.prototype query methods */
-#define JS_HAS_SPARSE_ARRAYS    0       /* array methods preserve empty elems */
-#define JS_HAS_DFLT_MSG_STRINGS 1       /* provides English error messages */
-#define JS_HAS_NUMBER_FORMATS   0       /* numbers have formatting methods */
-#define JS_HAS_GETTER_SETTER    0       /* has JS2 getter/setter functions */
-#define JS_HAS_UNEVAL           0       /* has uneval() top-level function */
-#define JS_HAS_CONST            0       /* has JS2 const as alternative var */
-#define JS_HAS_FUN_EXPR_STMT    0       /* has function expression statement */
-
-#elif JS_VERSION == 130
-
-#define JS_BUG_AUTO_INDEX_PROPS 0       /* new object o: o.p = v sets o[0] */
-#define JS_BUG_NULL_INDEX_PROPS 0       /* o[0] defaults to null, not void */
-#define JS_BUG_EMPTY_INDEX_ZERO 0       /* o[""] is equivalent to o[0] */
-#define JS_BUG_SHORT_CIRCUIT    0       /* 1 && 1 => true, 1 && 0 => 0 bug */
-#define JS_BUG_EAGER_TOSTRING   0       /* o.toString() trumps o.valueOf() */
-#define JS_BUG_VOID_TOSTRING    0       /* void 0 + 0 == "undefined0" */
-#define JS_BUG_EVAL_THIS_FUN    0       /* eval('this') in function f is f */
-#define JS_BUG_EVAL_THIS_SCOPE  0       /* Math.eval('sin(x)') vs. local x */
-#define JS_BUG_FALLIBLE_EQOPS   0       /* fallible/intransitive equality ops */
-#define JS_BUG_FALLIBLE_TONUM   0       /* fallible ValueToNumber primitive */
-#define JS_BUG_WITH_CLOSURE     1       /* with(o)function f(){} sets o.f */
-#define JS_BUG_SET_ENUMERATE    0       /* o.p=q flags o.p JSPROP_ENUMERATE */
-
-#define JS_HAS_PROP_DELETE      1       /* delete o.p removes p from o */
-#define JS_HAS_CALL_OBJECT      1       /* fun.caller is stack frame obj */
-#define JS_HAS_LABEL_STATEMENT  1       /* has break/continue to label: */
-#define JS_HAS_DO_WHILE_LOOP    1       /* has do {...} while (b) */
-#define JS_HAS_SWITCH_STATEMENT 1       /* has switch (v) {case c: ...} */
-#define JS_HAS_SOME_PERL_FUN    1       /* has array.join/reverse/sort */
-#define JS_HAS_MORE_PERL_FUN    1       /* has array.push, str.substr, etc */
-#define JS_HAS_VALUEOF_HINT     1       /* valueOf(hint) where hint is typeof */
-#define JS_HAS_LEXICAL_CLOSURE  1       /* nested functions, lexically closed */
-#define JS_HAS_APPLY_FUNCTION   1       /* has apply(fun, arg1, ... argN) */
-#define JS_HAS_CALL_FUNCTION    1       /* has fun.call(obj, arg1, ... argN) */
-#define JS_HAS_OBJ_PROTO_PROP   1       /* has o.__proto__ etc. */
-#define JS_HAS_REGEXPS          1       /* has perl r.e.s via RegExp, /pat/ */
-#define JS_HAS_SEQUENCE_OPS     1       /* has array.slice, string.concat */
-#define JS_HAS_INITIALIZERS     1       /* has var o = {'foo': 42, 'bar':3} */
-#define JS_HAS_OBJ_WATCHPOINT   1       /* has o.watch and o.unwatch */
-#define JS_HAS_EXPORT_IMPORT    1       /* has export fun; import obj.fun */
-#define JS_HAS_EVAL_THIS_SCOPE  1       /* Math.eval is same as with (Math) */
-#define JS_HAS_TRIPLE_EQOPS     1       /* has === and !== identity eqops */
-#define JS_HAS_SHARP_VARS       1       /* has #n=, #n# for object literals */
-#define JS_HAS_REPLACE_LAMBDA   1       /* has string.replace(re, lambda) */
-#define JS_HAS_SCRIPT_OBJECT    1       /* has (new Script("x++")).exec() */
-#define JS_HAS_XDR              1       /* has XDR API and object methods */
-#define JS_HAS_EXCEPTIONS       0       /* has exception handling */
-#define JS_HAS_UNDEFINED        1       /* has global "undefined" property */
-#define JS_HAS_TOSOURCE         1       /* has Object/Array toSource method */
-#define JS_HAS_IN_OPERATOR      0       /* has in operator ('p' in {p:1}) */
-#define JS_HAS_INSTANCEOF       0       /* has {p:1} instanceof Object */
-#define JS_HAS_ARGS_OBJECT      1       /* has minimal ECMA arguments object */
-#define JS_HAS_DEBUGGER_KEYWORD 1       /* has hook for debugger keyword */
-#define JS_HAS_ERROR_EXCEPTIONS 0       /* has error object hierarchy */
-#define JS_HAS_CATCH_GUARD      0       /* has exception handling catch guard */
-#define JS_HAS_NEW_OBJ_METHODS  0       /* has Object.prototype query methods */
-#define JS_HAS_SPARSE_ARRAYS    0       /* array methods preserve empty elems */
-#define JS_HAS_DFLT_MSG_STRINGS 1       /* provides English error messages */
-#define JS_HAS_NUMBER_FORMATS   0       /* numbers have formatting methods */
-#define JS_HAS_GETTER_SETTER    0       /* has JS2 getter/setter functions */
-#define JS_HAS_UNEVAL           0       /* has uneval() top-level function */
-#define JS_HAS_CONST            0       /* has JS2 const as alternative var */
-#define JS_HAS_FUN_EXPR_STMT    0       /* has function expression statement */
-
-#elif JS_VERSION == 140
-
-#define JS_BUG_AUTO_INDEX_PROPS 0       /* new object o: o.p = v sets o[0] */
-#define JS_BUG_NULL_INDEX_PROPS 0       /* o[0] defaults to null, not void */
-#define JS_BUG_EMPTY_INDEX_ZERO 0       /* o[""] is equivalent to o[0] */
-#define JS_BUG_SHORT_CIRCUIT    0       /* 1 && 1 => true, 1 && 0 => 0 bug */
-#define JS_BUG_EAGER_TOSTRING   0       /* o.toString() trumps o.valueOf() */
-#define JS_BUG_VOID_TOSTRING    0       /* void 0 + 0 == "undefined0" */
-#define JS_BUG_EVAL_THIS_FUN    0       /* eval('this') in function f is f */
-#define JS_BUG_EVAL_THIS_SCOPE  0       /* Math.eval('sin(x)') vs. local x */
-#define JS_BUG_FALLIBLE_EQOPS   0       /* fallible/intransitive equality ops */
-#define JS_BUG_FALLIBLE_TONUM   0       /* fallible ValueToNumber primitive */
-#define JS_BUG_WITH_CLOSURE     1       /* with(o)function f(){} sets o.f */
-#define JS_BUG_SET_ENUMERATE    0       /* o.p=q flags o.p JSPROP_ENUMERATE */
-
-#define JS_HAS_PROP_DELETE      1       /* delete o.p removes p from o */
-#define JS_HAS_CALL_OBJECT      1       /* fun.caller is stack frame obj */
-#define JS_HAS_LABEL_STATEMENT  1       /* has break/continue to label: */
-#define JS_HAS_DO_WHILE_LOOP    1       /* has do {...} while (b) */
-#define JS_HAS_SWITCH_STATEMENT 1       /* has switch (v) {case c: ...} */
-#define JS_HAS_SOME_PERL_FUN    1       /* has array.join/reverse/sort */
-#define JS_HAS_MORE_PERL_FUN    1       /* has array.push, str.substr, etc */
-#define JS_HAS_VALUEOF_HINT     1       /* valueOf(hint) where hint is typeof */
-#define JS_HAS_LEXICAL_CLOSURE  1       /* nested functions, lexically closed */
-#define JS_HAS_APPLY_FUNCTION   1       /* has apply(fun, arg1, ... argN) */
-#define JS_HAS_CALL_FUNCTION    1       /* has fun.call(obj, arg1, ... argN) */
-#define JS_HAS_OBJ_PROTO_PROP   1       /* has o.__proto__ etc. */
-#define JS_HAS_REGEXPS          1       /* has perl r.e.s via RegExp, /pat/ */
-#define JS_HAS_SEQUENCE_OPS     1       /* has array.slice, string.concat */
-#define JS_HAS_INITIALIZERS     1       /* has var o = {'foo': 42, 'bar':3} */
-#define JS_HAS_OBJ_WATCHPOINT   1       /* has o.watch and o.unwatch */
-#define JS_HAS_EXPORT_IMPORT    1       /* has export fun; import obj.fun */
-#define JS_HAS_EVAL_THIS_SCOPE  1       /* Math.eval is same as with (Math) */
-#define JS_HAS_TRIPLE_EQOPS     1       /* has === and !== identity eqops */
-#define JS_HAS_SHARP_VARS       1       /* has #n=, #n# for object literals */
-#define JS_HAS_REPLACE_LAMBDA   1       /* has string.replace(re, lambda) */
-#define JS_HAS_SCRIPT_OBJECT    1       /* has (new Script("x++")).exec() */
-#define JS_HAS_XDR		1	/* has XDR API and object methods */
-#define JS_HAS_EXCEPTIONS	1	/* has exception handling */
-#define JS_HAS_UNDEFINED        1       /* has global "undefined" property */
-#define JS_HAS_TOSOURCE         1       /* has Object/Array toSource method */
-#define JS_HAS_IN_OPERATOR      1       /* has in operator ('p' in {p:1}) */
-#define JS_HAS_INSTANCEOF       1       /* has {p:1} instanceof Object */
-#define JS_HAS_ARGS_OBJECT      1       /* has minimal ECMA arguments object */
-#define JS_HAS_DEBUGGER_KEYWORD 1       /* has hook for debugger keyword */
-#define JS_HAS_ERROR_EXCEPTIONS 0       /* rt errors reflected as exceptions */
-#define JS_HAS_CATCH_GUARD      0       /* has exception handling catch guard */
-#define JS_HAS_NEW_OBJ_METHODS  0       /* has Object.prototype query methods */
-#define JS_HAS_SPARSE_ARRAYS    0       /* array methods preserve empty elems */
-#define JS_HAS_DFLT_MSG_STRINGS 1       /* provides English error messages */
-#define JS_HAS_NUMBER_FORMATS   0       /* numbers have formatting methods */
-#define JS_HAS_GETTER_SETTER    0       /* has JS2 getter/setter functions */
-#define JS_HAS_UNEVAL           0       /* has uneval() top-level function */
-#define JS_HAS_CONST            0       /* has JS2 const as alternative var */
-#define JS_HAS_FUN_EXPR_STMT    0       /* has function expression statement */
-
-#elif JS_VERSION == 150
-
-#define JS_BUG_AUTO_INDEX_PROPS 0       /* new object o: o.p = v sets o[0] */
-#define JS_BUG_NULL_INDEX_PROPS 0       /* o[0] defaults to null, not void */
-#define JS_BUG_EMPTY_INDEX_ZERO 0       /* o[""] is equivalent to o[0] */
-#define JS_BUG_SHORT_CIRCUIT    0       /* 1 && 1 => true, 1 && 0 => 0 bug */
-#define JS_BUG_EAGER_TOSTRING   0       /* o.toString() trumps o.valueOf() */
-#define JS_BUG_VOID_TOSTRING    0       /* void 0 + 0 == "undefined0" */
-#define JS_BUG_EVAL_THIS_FUN    0       /* eval('this') in function f is f */
-#define JS_BUG_EVAL_THIS_SCOPE  0       /* Math.eval('sin(x)') vs. local x */
-#define JS_BUG_FALLIBLE_EQOPS   0       /* fallible/intransitive equality ops */
-#define JS_BUG_FALLIBLE_TONUM   0       /* fallible ValueToNumber primitive */
-#define JS_BUG_WITH_CLOSURE     1       /* with(o)function f(){} sets o.f */
-#define JS_BUG_SET_ENUMERATE    0       /* o.p=q flags o.p JSPROP_ENUMERATE */
-
-#define JS_HAS_PROP_DELETE      1       /* delete o.p removes p from o */
-#define JS_HAS_CALL_OBJECT      1       /* fun.caller is stack frame obj */
-#define JS_HAS_LABEL_STATEMENT  1       /* has break/continue to label: */
-#define JS_HAS_DO_WHILE_LOOP    1       /* has do {...} while (b) */
-#define JS_HAS_SWITCH_STATEMENT 1       /* has switch (v) {case c: ...} */
-#define JS_HAS_SOME_PERL_FUN    1       /* has array.join/reverse/sort */
-#define JS_HAS_MORE_PERL_FUN    1       /* has array.push, str.substr, etc */
-#define JS_HAS_VALUEOF_HINT     1       /* valueOf(hint) where hint is typeof */
-#define JS_HAS_LEXICAL_CLOSURE  1       /* nested functions, lexically closed */
-#define JS_HAS_APPLY_FUNCTION   1       /* has apply(fun, arg1, ... argN) */
-#define JS_HAS_CALL_FUNCTION    1       /* has fun.call(obj, arg1, ... argN) */
-#define JS_HAS_OBJ_PROTO_PROP   1       /* has o.__proto__ etc. */
-#define JS_HAS_REGEXPS          1       /* has perl r.e.s via RegExp, /pat/ */
-#define JS_HAS_SEQUENCE_OPS     1       /* has array.slice, string.concat */
-#define JS_HAS_INITIALIZERS     1       /* has var o = {'foo': 42, 'bar':3} */
-#define JS_HAS_OBJ_WATCHPOINT   1       /* has o.watch and o.unwatch */
-#define JS_HAS_EXPORT_IMPORT    1       /* has export fun; import obj.fun */
-#define JS_HAS_EVAL_THIS_SCOPE  1       /* Math.eval is same as with (Math) */
-#define JS_HAS_TRIPLE_EQOPS     1       /* has === and !== identity eqops */
-#define JS_HAS_SHARP_VARS       1       /* has #n=, #n# for object literals */
-#define JS_HAS_REPLACE_LAMBDA   1       /* has string.replace(re, lambda) */
-#define JS_HAS_SCRIPT_OBJECT    1       /* has (new Script("x++")).exec() */
-#define JS_HAS_XDR              1       /* has XDR API and object methods */
-#define JS_HAS_EXCEPTIONS       1       /* has exception handling */
-#define JS_HAS_UNDEFINED        1       /* has global "undefined" property */
-#define JS_HAS_TOSOURCE         1       /* has Object/Array toSource method */
-#define JS_HAS_IN_OPERATOR      1       /* has in operator ('p' in {p:1}) */
-#define JS_HAS_INSTANCEOF       1       /* has {p:1} instanceof Object */
-#define JS_HAS_ARGS_OBJECT      1       /* has minimal ECMA arguments object */
-#define JS_HAS_DEBUGGER_KEYWORD 1       /* has hook for debugger keyword */
-#define JS_HAS_ERROR_EXCEPTIONS 1       /* rt errors reflected as exceptions */
-#define JS_HAS_CATCH_GUARD      1       /* has exception handling catch guard */
-#define JS_HAS_NEW_OBJ_METHODS  1       /* has Object.prototype query methods */
-#define JS_HAS_SPARSE_ARRAYS    0       /* array methods preserve empty elems */
-#define JS_HAS_DFLT_MSG_STRINGS 1       /* provides English error messages */
-#define JS_HAS_NUMBER_FORMATS   1       /* numbers have formatting methods */
-#define JS_HAS_GETTER_SETTER    1       /* has JS2 getter/setter functions */
-#define JS_HAS_UNEVAL           1       /* has uneval() top-level function */
-#define JS_HAS_CONST            1       /* has JS2 const as alternative var */
-#define JS_HAS_FUN_EXPR_STMT    1       /* has function expression statement */
-
-#else
-
-#error "unknown JS_VERSION"
-
-#endif

mozilla/js/src/jsconfig.mk

@@ -1,140 +0,0 @@
-ifndef OBJDIR
-  ifdef OBJDIR_NAME
-    OBJDIR = $(OBJDIR_NAME)
-  endif
-endif
-
-NSPR_VERSION     = v3.1
-NSPR_LOCAL       = $(MOZ_DEPTH)/dist/$(OBJDIR)/nspr
-NSPR_DIST        = $(MOZ_DEPTH)/dist/$(OBJDIR)
-NSPR_OBJDIR      = $(OBJDIR)
-ifeq ($(OS_ARCH), SunOS)
-  NSPR_OBJDIR   := $(subst _sparc,,$(NSPR_OBJDIR))
-endif
-ifeq ($(OS_ARCH), Linux)
-  LINUX_REL     := $(shell uname -r)
-  ifneq (,$(findstring 2.0,$(LINUX_REL)))
-    NSPR_OBJDIR := $(subst _All,2.0_x86_glibc_PTH,$(NSPR_OBJDIR))
-  else
-    NSPR_OBJDIR := $(subst _All,2.2_x86_glibc_PTH,$(NSPR_OBJDIR))
-  endif
-endif
-ifeq ($(OS_ARCH), AIX)
-  NSPR_OBJDIR   := $(subst 4.1,4.2,$(NSPR_OBJDIR))
-endif
-ifeq ($(OS_CONFIG), IRIX6.2)
-  NSPR_OBJDIR   := $(subst 6.2,6.2_n32_PTH,$(NSPR_OBJDIR))
-endif
-ifeq ($(OS_CONFIG), IRIX6.5)
-  NSPR_OBJDIR   := $(subst 6.5,6.5_n32_PTH,$(NSPR_OBJDIR))
-endif
-ifeq ($(OS_ARCH), WINNT)
-  ifeq ($(OBJDIR), WIN32_D.OBJ)
-    NSPR_OBJDIR  = WINNT4.0_DBG.OBJ
-  endif
-  ifeq ($(OBJDIR), WIN32_O.OBJ)
-    NSPR_OBJDIR  = WINNT4.0_OPT.OBJ
-  endif
-endif
-NSPR_SHARED      = /share/builds/components/nspr20/$(NSPR_VERSION)/$(NSPR_OBJDIR)
-ifeq ($(OS_ARCH), WINNT)
-  NSPR_SHARED    = nspr20/$(NSPR_VERSION)/$(NSPR_OBJDIR)
-endif
-NSPR_VERSIONFILE = $(NSPR_LOCAL)/Version
-NSPR_CURVERSION := $(shell cat $(NSPR_VERSIONFILE))
-
-get_nspr:
-	@echo "Grabbing NSPR component..."
-ifeq ($(NSPR_VERSION), $(NSPR_CURVERSION))
-	@echo "No need, NSPR is up to date in this tree (ver=$(NSPR_VERSION))."
-else
-	mkdir -p $(NSPR_LOCAL)
-	mkdir -p $(NSPR_DIST)
-  ifneq ($(OS_ARCH), WINNT)
-	cp       $(NSPR_SHARED)/*.jar $(NSPR_LOCAL)
-  else
-	sh       $(MOZ_DEPTH)/../reltools/compftp.sh $(NSPR_SHARED) $(NSPR_LOCAL) *.jar
-  endif
-	unzip -o $(NSPR_LOCAL)/mdbinary.jar -d $(NSPR_DIST)
-	mkdir -p $(NSPR_DIST)/include
-	unzip -o $(NSPR_LOCAL)/mdheader.jar -d $(NSPR_DIST)/include
-	rm -rf   $(NSPR_DIST)/META-INF
-	rm -rf   $(NSPR_DIST)/include/META-INF
-	echo $(NSPR_VERSION) > $(NSPR_VERSIONFILE)
-endif
-
-SHIP_DIST  = $(MOZ_DEPTH)/dist/$(OBJDIR)
-SHIP_DIR   = $(SHIP_DIST)/SHIP
-
-SHIP_LIBS      = libjs.$(SO_SUFFIX) libjs.a
-ifdef JS_LIVECONNECT
-  SHIP_LIBS   += libjsj.$(SO_SUFFIX) libjsj.a
-endif
-ifeq ($(OS_ARCH), WINNT)
-  SHIP_LIBS    = js32.dll js32.lib
-  ifdef JS_LIVECONNECT
-    SHIP_LIBS += jsj.dll jsj.lib
-  endif
-endif
-SHIP_LIBS     += $(LCJAR)
-SHIP_LIBS     := $(addprefix $(SHIP_DIST)/lib/, $(SHIP_LIBS))
-
-SHIP_INCS      = js*.h prmjtime.h resource.h *.msg *.tbl
-ifdef JS_LIVECONNECT
-  SHIP_INCS   += netscape*.h nsC*.h nsI*.h
-endif
-SHIP_INCS     := $(addprefix $(SHIP_DIST)/include/, $(SHIP_INCS))
-
-SHIP_BINS      = js
-ifdef JS_LIVECONNECT
-  SHIP_BINS   += lcshell
-endif
-ifeq ($(OS_ARCH), WINNT)
-  SHIP_BINS   := $(addsuffix .exe, $(SHIP_BINS))
-endif
-SHIP_BINS     := $(addprefix $(SHIP_DIST)/bin/, $(SHIP_BINS))
-
-ifdef BUILD_OPT
-  JSREFJAR = jsref_opt.jar
-else
-ifdef BUILD_IDG
-  JSREFJAR = jsref_idg.jar
-else
-  JSREFJAR = jsref_dbg.jar
-endif
-endif
-
-ship:
-	mkdir -p $(SHIP_DIR)/lib
-	mkdir -p $(SHIP_DIR)/include
-	mkdir -p $(SHIP_DIR)/bin
-	cp $(SHIP_LIBS) $(SHIP_DIR)/lib
-	cp $(SHIP_INCS) $(SHIP_DIR)/include
-	cp $(SHIP_BINS) $(SHIP_DIR)/bin
-	cd $(SHIP_DIR); \
-	  zip -r $(JSREFJAR) bin lib include
-ifdef BUILD_SHIP
-	cp $(SHIP_DIR)/$(JSREFJAR) $(BUILD_SHIP)
-endif
-
-CWD = $(shell pwd)
-shipSource: $(SHIP_DIR)/jsref_src.lst .FORCE
-	mkdir -p $(SHIP_DIR)
-	cd $(MOZ_DEPTH)/.. ; \
-	  zip $(CWD)/$(SHIP_DIR)/jsref_src.jar -@ < $(CWD)/$(SHIP_DIR)/jsref_src.lst
-ifdef BUILD_SHIP
-	cp $(SHIP_DIR)/jsref_src.jar $(BUILD_SHIP)
-endif
-
-JSREFSRCDIRS := $(shell cat $(DEPTH)/SpiderMonkey.rsp)
-$(SHIP_DIR)/jsref_src.lst: .FORCE
-	mkdir -p $(SHIP_DIR)
-	rm -f $@
-	touch $@
-	for d in $(JSREFSRCDIRS); do                                \
-	  cd $(MOZ_DEPTH)/..;                                       \
-	  ls -1 -d $$d | grep -v CVS | grep -v \.OBJ >> $(CWD)/$@;  \
-	  cd $(CWD);                                                \
-	done
-
-.FORCE:

mozilla/js/src/jscpucfg.c

@@ -1,318 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * Generate CPU-specific bit-size and similar #defines.
- */
-#include <stdio.h>
-
-#ifdef CROSS_COMPILE
-#include <prtypes.h>
-#define INT64 PRInt64
-#else
-
-#ifdef __MWERKS__
-#define XP_MAC 1
-#endif
-
-/************************************************************************/
-
-/* Generate cpucfg.h */
-#ifdef XP_MAC
-#include <Types.h>
-#define INT64	UnsignedWide
-#else
-#ifdef XP_PC
-#ifdef WIN32
-#if defined(__GNUC__)
-#define INT64   long long
-#else
-#define INT64	_int64
-#endif /* __GNUC__ */
-#else
-#define INT64	long
-#endif
-#else
-#if defined(HPUX) || defined(__QNX__) || defined(_SCO_DS) || defined(UNIXWARE)
-#define INT64	long
-#else
-#define INT64	long long
-#endif
-#endif
-#endif
-
-#endif /* CROSS_COMPILE */
-
-typedef void *prword;
-
-struct align_short {
-    char c;
-    short a;
-};
-struct align_int {
-    char c;
-    int a;
-};
-struct align_long {
-    char c;
-    long a;
-};
-struct align_int64 {
-    char c;
-    INT64 a;
-};
-struct align_fakelonglong {
-    char c;
-    struct {
-	long hi, lo;
-    } a;
-};
-struct align_float {
-    char c;
-    float a;
-};
-struct align_double {
-    char c;
-    double a;
-};
-struct align_pointer {
-    char c;
-    void *a;
-};
-struct align_prword {
-    char c;
-    prword a;
-};
-
-#define ALIGN_OF(type) \
-    (((char*)&(((struct align_##type *)0)->a)) - ((char*)0))
-
-unsigned int bpb;
-
-static int Log2(unsigned int n)
-{
-    int log2 = 0;
-
-    if (n & (n-1))
-	log2++;
-    if (n >> 16)
-	log2 += 16, n >>= 16;
-    if (n >> 8)
-	log2 += 8, n >>= 8;
-    if (n >> 4)
-	log2 += 4, n >>= 4;
-    if (n >> 2)
-	log2 += 2, n >>= 2;
-    if (n >> 1)
-	log2++;
-    return log2;
-}
-
-/* We assume that int's are 32 bits */
-static void do64(void)
-{
-    union {
-	long i;
-	char c[4];
-    } u;
-
-    u.i = 0x01020304;
-    if (u.c[0] == 0x01) {
-	printf("#undef  IS_LITTLE_ENDIAN\n");
-	printf("#define IS_BIG_ENDIAN 1\n\n");
-    } else {
-	printf("#define IS_LITTLE_ENDIAN 1\n");
-	printf("#undef  IS_BIG_ENDIAN\n\n");
-    }
-}
-
-static void do32(void)
-{
-    union {
-	long i;
-	char c[4];
-    } u;
-
-    u.i = 0x01020304;
-    if (u.c[0] == 0x01) {
-	printf("#undef  IS_LITTLE_ENDIAN\n");
-	printf("#define IS_BIG_ENDIAN 1\n\n");
-    } else {
-	printf("#define IS_LITTLE_ENDIAN 1\n");
-	printf("#undef  IS_BIG_ENDIAN\n\n");
-    }
-}
-
-/*
- * Conceivably this could actually be used, but there is lots of code out
- * there with ands and shifts in it that assumes a byte is exactly 8 bits,
- * so forget about porting THIS code to all those non 8 bit byte machines.
- */
-static void BitsPerByte(void)
-{
-    bpb = 8;
-}
-
-int main(int argc, char **argv)
-{
-    int sizeof_char, sizeof_short, sizeof_int, sizeof_int64, sizeof_long,
-        sizeof_float, sizeof_double, sizeof_word, sizeof_dword;
-    int bits_per_int64_log2, align_of_short, align_of_int, align_of_long,
-        align_of_int64, align_of_float, align_of_double, align_of_pointer,
-        align_of_word;
-
-    BitsPerByte();
-
-    printf("#ifndef js_cpucfg___\n");
-    printf("#define js_cpucfg___\n\n");
-
-    printf("/* AUTOMATICALLY GENERATED - DO NOT EDIT */\n\n");
-
-#ifdef CROSS_COMPILE
-#if defined(IS_LITTLE_ENDIAN)
-    printf("#define IS_LITTLE_ENDIAN 1\n");
-    printf("#undef  IS_BIG_ENDIAN\n\n");
-#elif defined(IS_BIG_ENDIAN)
-    printf("#undef  IS_LITTLE_ENDIAN\n");
-    printf("#define IS_BIG_ENDIAN 1\n\n");
-#else
-#error "Endianess not defined."
-#endif
-
-    sizeof_char		= PR_BYTES_PER_BYTE;
-    sizeof_short	= PR_BYTES_PER_SHORT;
-    sizeof_int		= PR_BYTES_PER_INT;
-    sizeof_int64	= PR_BYTES_PER_INT64;
-    sizeof_long		= PR_BYTES_PER_LONG;
-    sizeof_float	= PR_BYTES_PER_FLOAT;
-    sizeof_double	= PR_BYTES_PER_DOUBLE;
-    sizeof_word		= PR_BYTES_PER_WORD;
-    sizeof_dword	= PR_BYTES_PER_DWORD;
-
-    bits_per_int64_log2 = PR_BITS_PER_INT64_LOG2;
-
-    align_of_short	= PR_ALIGN_OF_SHORT;
-    align_of_int	= PR_ALIGN_OF_INT;
-    align_of_long	= PR_ALIGN_OF_LONG;
-    align_of_int64	= PR_ALIGN_OF_INT64;
-    align_of_float	= PR_ALIGN_OF_FLOAT;
-    align_of_double	= PR_ALIGN_OF_DOUBLE;
-    align_of_pointer	= PR_ALIGN_OF_POINTER;
-    align_of_word	= PR_ALIGN_OF_WORD;
-
-#else /* !CROSS_COMPILE */
-    if (sizeof(long) == 8) {
-	do64();
-    } else {
-	do32();
-    }
-
-    sizeof_char		= sizeof(char);
-    sizeof_short	= sizeof(short);
-    sizeof_int		= sizeof(int);
-    sizeof_int64	= 8;
-    sizeof_long		= sizeof(long);
-    sizeof_float	= sizeof(float);
-    sizeof_double	= sizeof(double);
-    sizeof_word		= sizeof(prword);
-    sizeof_dword	= 8;
-
-    bits_per_int64_log2 = 6;
-
-    align_of_short	= ALIGN_OF(short);
-    align_of_int	= ALIGN_OF(int);
-    align_of_long	= ALIGN_OF(long);
-    if (sizeof(INT64) < 8) {
-	/* this machine doesn't actually support int64's */
-        align_of_int64	= ALIGN_OF(fakelonglong);
-    } else {
-        align_of_int64	= ALIGN_OF(int64);
-    }
-    align_of_float	= ALIGN_OF(float);
-    align_of_double	= ALIGN_OF(double);
-    align_of_pointer	= ALIGN_OF(pointer);
-    align_of_word	= ALIGN_OF(prword);
-
-#endif /* CROSS_COMPILE */
-
-    printf("#define JS_BYTES_PER_BYTE   %dL\n", sizeof_char);
-    printf("#define JS_BYTES_PER_SHORT  %dL\n", sizeof_short);
-    printf("#define JS_BYTES_PER_INT    %dL\n", sizeof_int);
-    printf("#define JS_BYTES_PER_INT64  %dL\n", sizeof_int64);
-    printf("#define JS_BYTES_PER_LONG   %dL\n", sizeof_long);
-    printf("#define JS_BYTES_PER_FLOAT  %dL\n", sizeof_float);
-    printf("#define JS_BYTES_PER_DOUBLE %dL\n", sizeof_double);
-    printf("#define JS_BYTES_PER_WORD   %dL\n", sizeof_word);
-    printf("#define JS_BYTES_PER_DWORD  %dL\n", sizeof_dword);
-    printf("\n");
-
-    printf("#define JS_BITS_PER_BYTE    %dL\n", bpb);
-    printf("#define JS_BITS_PER_SHORT   %dL\n", bpb * sizeof_short);
-    printf("#define JS_BITS_PER_INT     %dL\n", bpb * sizeof_int);
-    printf("#define JS_BITS_PER_INT64   %dL\n", bpb * sizeof_int64);
-    printf("#define JS_BITS_PER_LONG    %dL\n", bpb * sizeof_long);
-    printf("#define JS_BITS_PER_FLOAT   %dL\n", bpb * sizeof_float);
-    printf("#define JS_BITS_PER_DOUBLE  %dL\n", bpb * sizeof_double);
-    printf("#define JS_BITS_PER_WORD    %dL\n", bpb * sizeof_word);
-    printf("\n");
-
-    printf("#define JS_BITS_PER_BYTE_LOG2   %dL\n", Log2(bpb));
-    printf("#define JS_BITS_PER_SHORT_LOG2  %dL\n", Log2(bpb * sizeof_short));
-    printf("#define JS_BITS_PER_INT_LOG2    %dL\n", Log2(bpb * sizeof_int));
-    printf("#define JS_BITS_PER_INT64_LOG2  %dL\n", bits_per_int64_log2);
-    printf("#define JS_BITS_PER_LONG_LOG2   %dL\n", Log2(bpb * sizeof_long));
-    printf("#define JS_BITS_PER_FLOAT_LOG2  %dL\n", Log2(bpb * sizeof_float));
-    printf("#define JS_BITS_PER_DOUBLE_LOG2 %dL\n", Log2(bpb * sizeof_double));
-    printf("#define JS_BITS_PER_WORD_LOG2   %dL\n", Log2(bpb * sizeof_word));
-    printf("\n");
-
-    printf("#define JS_ALIGN_OF_SHORT   %dL\n", align_of_short);
-    printf("#define JS_ALIGN_OF_INT     %dL\n", align_of_int);
-    printf("#define JS_ALIGN_OF_LONG    %dL\n", align_of_long);
-    printf("#define JS_ALIGN_OF_INT64   %dL\n", align_of_int64);
-    printf("#define JS_ALIGN_OF_FLOAT   %dL\n", align_of_float);
-    printf("#define JS_ALIGN_OF_DOUBLE  %dL\n", align_of_double);
-    printf("#define JS_ALIGN_OF_POINTER %dL\n", align_of_pointer);
-    printf("#define JS_ALIGN_OF_WORD    %dL\n", align_of_word);
-    printf("\n");
-
-    printf("#define JS_BYTES_PER_WORD_LOG2   %dL\n", Log2(sizeof_word));
-    printf("#define JS_BYTES_PER_DWORD_LOG2  %dL\n", Log2(sizeof_dword));
-    printf("#define JS_WORDS_PER_DWORD_LOG2  %dL\n", Log2(sizeof_dword/sizeof_word));
-    printf("\n");
-
-    printf("#endif /* js_cpucfg___ */\n");
-
-    return 0;
-}

mozilla/js/src/jscpucfg.h

@@ -1,191 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef js_cpucfg___
-#define js_cpucfg___
-
-#include "jsosdep.h"
-
-#ifdef XP_MAC
-#undef  IS_LITTLE_ENDIAN
-#define IS_BIG_ENDIAN 1
-
-#define JS_BYTES_PER_BYTE   1L
-#define JS_BYTES_PER_SHORT  2L
-#define JS_BYTES_PER_INT    4L
-#define JS_BYTES_PER_INT64  8L
-#define JS_BYTES_PER_LONG   4L
-#define JS_BYTES_PER_FLOAT  4L
-#define JS_BYTES_PER_DOUBLE 8L
-#define JS_BYTES_PER_WORD   4L
-#define JS_BYTES_PER_DWORD  8L
-
-#define JS_BITS_PER_BYTE    8L
-#define JS_BITS_PER_SHORT   16L
-#define JS_BITS_PER_INT     32L
-#define JS_BITS_PER_INT64   64L
-#define JS_BITS_PER_LONG    32L
-#define JS_BITS_PER_FLOAT   32L
-#define JS_BITS_PER_DOUBLE  64L
-#define JS_BITS_PER_WORD    32L
-
-#define JS_BITS_PER_BYTE_LOG2   3L
-#define JS_BITS_PER_SHORT_LOG2  4L
-#define JS_BITS_PER_INT_LOG2    5L
-#define JS_BITS_PER_INT64_LOG2  6L
-#define JS_BITS_PER_LONG_LOG2   5L
-#define JS_BITS_PER_FLOAT_LOG2  5L
-#define JS_BITS_PER_DOUBLE_LOG2 6L
-#define JS_BITS_PER_WORD_LOG2   5L
-
-#define JS_ALIGN_OF_SHORT   2L
-#define JS_ALIGN_OF_INT     4L
-#define JS_ALIGN_OF_LONG    4L
-#define JS_ALIGN_OF_INT64   2L
-#define JS_ALIGN_OF_FLOAT   4L
-#define JS_ALIGN_OF_DOUBLE  4L
-#define JS_ALIGN_OF_POINTER 4L
-#define JS_ALIGN_OF_WORD    4L
-
-#define JS_BYTES_PER_WORD_LOG2   2L
-#define JS_BYTES_PER_DWORD_LOG2  3L
-#define PR_WORDS_PER_DWORD_LOG2  1L
-
-#elif defined(XP_PC)
-
-#ifdef _WIN32
-#define IS_LITTLE_ENDIAN 1
-#undef  IS_BIG_ENDIAN
-
-#define JS_BYTES_PER_BYTE   1L
-#define JS_BYTES_PER_SHORT  2L
-#define JS_BYTES_PER_INT    4L
-#define JS_BYTES_PER_INT64  8L
-#define JS_BYTES_PER_LONG   4L
-#define JS_BYTES_PER_FLOAT  4L
-#define JS_BYTES_PER_DOUBLE 8L
-#define JS_BYTES_PER_WORD   4L
-#define JS_BYTES_PER_DWORD  8L
-
-#define JS_BITS_PER_BYTE    8L
-#define JS_BITS_PER_SHORT   16L
-#define JS_BITS_PER_INT     32L
-#define JS_BITS_PER_INT64   64L
-#define JS_BITS_PER_LONG    32L
-#define JS_BITS_PER_FLOAT   32L
-#define JS_BITS_PER_DOUBLE  64L
-#define JS_BITS_PER_WORD    32L
-
-#define JS_BITS_PER_BYTE_LOG2   3L
-#define JS_BITS_PER_SHORT_LOG2  4L
-#define JS_BITS_PER_INT_LOG2    5L
-#define JS_BITS_PER_INT64_LOG2  6L
-#define JS_BITS_PER_LONG_LOG2   5L
-#define JS_BITS_PER_FLOAT_LOG2  5L
-#define JS_BITS_PER_DOUBLE_LOG2 6L
-#define JS_BITS_PER_WORD_LOG2   5L
-
-#define JS_ALIGN_OF_SHORT   2L
-#define JS_ALIGN_OF_INT     4L
-#define JS_ALIGN_OF_LONG    4L
-#define JS_ALIGN_OF_INT64   8L
-#define JS_ALIGN_OF_FLOAT   4L
-#define JS_ALIGN_OF_DOUBLE  4L
-#define JS_ALIGN_OF_POINTER 4L
-#define JS_ALIGN_OF_WORD    4L
-
-#define JS_BYTES_PER_WORD_LOG2   2L
-#define JS_BYTES_PER_DWORD_LOG2  3L
-#define PR_WORDS_PER_DWORD_LOG2  1L
-#endif /* _WIN32 */
-
-#if defined(_WINDOWS) && !defined(_WIN32) /* WIN16 */
-#define IS_LITTLE_ENDIAN 1
-#undef  IS_BIG_ENDIAN
-
-#define JS_BYTES_PER_BYTE   1L
-#define JS_BYTES_PER_SHORT  2L
-#define JS_BYTES_PER_INT    2L
-#define JS_BYTES_PER_INT64  8L
-#define JS_BYTES_PER_LONG   4L
-#define JS_BYTES_PER_FLOAT  4L
-#define JS_BYTES_PER_DOUBLE 8L
-#define JS_BYTES_PER_WORD   4L
-#define JS_BYTES_PER_DWORD  8L
-
-#define JS_BITS_PER_BYTE    8L
-#define JS_BITS_PER_SHORT   16L
-#define JS_BITS_PER_INT     16L
-#define JS_BITS_PER_INT64   64L
-#define JS_BITS_PER_LONG    32L
-#define JS_BITS_PER_FLOAT   32L
-#define JS_BITS_PER_DOUBLE  64L
-#define JS_BITS_PER_WORD    32L
-
-#define JS_BITS_PER_BYTE_LOG2   3L
-#define JS_BITS_PER_SHORT_LOG2  4L
-#define JS_BITS_PER_INT_LOG2    4L
-#define JS_BITS_PER_INT64_LOG2  6L
-#define JS_BITS_PER_LONG_LOG2   5L
-#define JS_BITS_PER_FLOAT_LOG2  5L
-#define JS_BITS_PER_DOUBLE_LOG2 6L
-#define JS_BITS_PER_WORD_LOG2   5L
-
-#define JS_ALIGN_OF_SHORT   2L
-#define JS_ALIGN_OF_INT     2L
-#define JS_ALIGN_OF_LONG    2L
-#define JS_ALIGN_OF_INT64   2L
-#define JS_ALIGN_OF_FLOAT   2L
-#define JS_ALIGN_OF_DOUBLE  2L
-#define JS_ALIGN_OF_POINTER 2L
-#define JS_ALIGN_OF_WORD    2L
-
-#define JS_BYTES_PER_WORD_LOG2   2L
-#define JS_BYTES_PER_DWORD_LOG2  3L
-#define PR_WORDS_PER_DWORD_LOG2  1L
-#endif /* defined(_WINDOWS) && !defined(_WIN32) */
-
-#elif defined(XP_UNIX) || defined(XP_BEOS)
-
-#error "This file is supposed to be auto-generated on UNIX platforms, but the"
-#error "static version for Mac and Windows platforms is being used."
-#error "Something's probably wrong with paths/headers/dependencies/Makefiles."
-
-#else
-
-#error "Must define one of XP_MAC, XP_PC, XP_UNIX, or XP_BEOS"
-
-#endif
-
-#endif /* js_cpucfg___ */

mozilla/js/src/jsdate.h

@@ -1,113 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS Date class interface.
- */
-
-#ifndef jsdate_h___
-#define jsdate_h___
-
-JS_BEGIN_EXTERN_C
-
-extern JSObject *
-js_InitDateClass(JSContext *cx, JSObject *obj);
-
-/*
- * These functions provide a C interface to the date/time object
- */
-
-/*
- * Construct a new Date Object from a time value given in milliseconds UTC
- * since the epoch.
- */
-extern JS_FRIEND_API(JSObject*)
-js_NewDateObjectMsec(JSContext* cx, jsdouble msec_time);
-
-/*
- * Construct a new Date Object from an exploded local time value.
- */
-extern JS_FRIEND_API(JSObject*)
-js_NewDateObject(JSContext* cx, int year, int mon, int mday,
-				int hour, int min, int sec);
-
-/*
- * Detect whether the internal date value is NaN.  (Because failure is
- * out-of-band for js_DateGet*)
- */
-extern JS_FRIEND_API(JSBool)
-js_DateIsValid(JSContext *cx, JSObject* obj);
-
-extern JS_FRIEND_API(int)
-js_DateGetYear(JSContext *cx, JSObject* obj);
-
-extern JS_FRIEND_API(int)
-js_DateGetMonth(JSContext *cx, JSObject* obj);
-
-extern JS_FRIEND_API(int)
-js_DateGetDate(JSContext *cx, JSObject* obj);
-
-extern JS_FRIEND_API(int)
-js_DateGetHours(JSContext *cx, JSObject* obj);
-
-extern JS_FRIEND_API(int)
-js_DateGetMinutes(JSContext *cx, JSObject* obj);
-
-extern JS_FRIEND_API(int)
-js_DateGetSeconds(JSContext *cx, JSObject* obj);
-
-extern JS_FRIEND_API(void)
-js_DateSetYear(JSContext *cx, JSObject *obj, int year);
-
-extern JS_FRIEND_API(void)
-js_DateSetMonth(JSContext *cx, JSObject *obj, int year);
-
-extern JS_FRIEND_API(void)
-js_DateSetDate(JSContext *cx, JSObject *obj, int date);
-
-extern JS_FRIEND_API(void)
-js_DateSetHours(JSContext *cx, JSObject *obj, int hours);
-
-extern JS_FRIEND_API(void)
-js_DateSetMinutes(JSContext *cx, JSObject *obj, int minutes);
-
-extern JS_FRIEND_API(void)
-js_DateSetSeconds(JSContext *cx, JSObject *obj, int seconds);
-
-extern JS_FRIEND_API(jsdouble)
-js_DateGetMsecSinceEpoch(JSContext *cx, JSObject *obj);
-
-JS_END_EXTERN_C
-
-#endif /* jsdate_h___ */

mozilla/js/src/jsdbgapi.c

@@ -1,908 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS debugging API.
- */
-#include "jsstddef.h"
-#include <string.h>
-#include "jstypes.h"
-#include "jsutil.h" /* Added by JSIFY */
-#include "jsclist.h"
-#include "jsapi.h"
-#include "jscntxt.h"
-#include "jsconfig.h"
-#include "jsdbgapi.h"
-#include "jsfun.h"
-#include "jsgc.h"
-#include "jsinterp.h"
-#include "jslock.h"
-#include "jsobj.h"
-#include "jsopcode.h"
-#include "jsscope.h"
-#include "jsscript.h"
-#include "jsstr.h"
-
-typedef struct JSTrap {
-    JSCList         links;
-    JSScript        *script;
-    jsbytecode      *pc;
-    JSOp            op;
-    JSTrapHandler   handler;
-    void            *closure;
-} JSTrap;
-
-static JSTrap *
-FindTrap(JSRuntime *rt, JSScript *script, jsbytecode *pc)
-{
-    JSTrap *trap;
-
-    for (trap = (JSTrap *)rt->trapList.next;
-	 trap != (JSTrap *)&rt->trapList;
-	 trap = (JSTrap *)trap->links.next) {
-	if (trap->script == script && trap->pc == pc)
-	    return trap;
-    }
-    return NULL;
-}
-
-void
-js_PatchOpcode(JSContext *cx, JSScript *script, jsbytecode *pc, JSOp op)
-{
-    JSTrap *trap;
-
-    trap = FindTrap(cx->runtime, script, pc);
-    if (trap)
-	trap->op = op;
-    else
-	*pc = (jsbytecode)op;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetTrap(JSContext *cx, JSScript *script, jsbytecode *pc,
-	   JSTrapHandler handler, void *closure)
-{
-    JSRuntime *rt;
-    JSTrap *trap;
-
-    rt = cx->runtime;
-    trap = FindTrap(rt, script, pc);
-    if (trap) {
-	/* Restore opcode at pc so it can be saved again. */
-	*pc = (jsbytecode)trap->op;
-    } else {
-	trap = JS_malloc(cx, sizeof *trap);
-	if (!trap || !js_AddRoot(cx, &trap->closure, "trap->closure")) {
-	    if (trap)
-		JS_free(cx, trap);
-	    return JS_FALSE;
-	}
-    }
-    JS_APPEND_LINK(&trap->links, &rt->trapList);
-    trap->script = script;
-    trap->pc = pc;
-    trap->op = (JSOp)*pc;
-    trap->handler = handler;
-    trap->closure = closure;
-    *pc = JSOP_TRAP;
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSOp)
-JS_GetTrapOpcode(JSContext *cx, JSScript *script, jsbytecode *pc)
-{
-    JSTrap *trap;
-
-    trap = FindTrap(cx->runtime, script, pc);
-    if (!trap) {
-	JS_ASSERT(0);	/* XXX can't happen */
-	return JSOP_LIMIT;
-    }
-    return trap->op;
-}
-
-static void
-DestroyTrap(JSContext *cx, JSTrap *trap)
-{
-    JS_REMOVE_LINK(&trap->links);
-    *trap->pc = (jsbytecode)trap->op;
-    js_RemoveRoot(cx->runtime, &trap->closure);
-    JS_free(cx, trap);
-}
-
-JS_PUBLIC_API(void)
-JS_ClearTrap(JSContext *cx, JSScript *script, jsbytecode *pc,
-	     JSTrapHandler *handlerp, void **closurep)
-{
-    JSTrap *trap;
-
-    trap = FindTrap(cx->runtime, script, pc);
-    if (handlerp)
-	*handlerp = trap ? trap->handler : NULL;
-    if (closurep)
-	*closurep = trap ? trap->closure : NULL;
-    if (trap)
-	DestroyTrap(cx, trap);
-}
-
-JS_PUBLIC_API(void)
-JS_ClearScriptTraps(JSContext *cx, JSScript *script)
-{
-    JSRuntime *rt;
-    JSTrap *trap, *next;
-
-    rt = cx->runtime;
-    for (trap = (JSTrap *)rt->trapList.next;
-	 trap != (JSTrap *)&rt->trapList;
-	 trap = next) {
-	next = (JSTrap *)trap->links.next;
-	if (trap->script == script)
-	    DestroyTrap(cx, trap);
-    }
-}
-
-JS_PUBLIC_API(void)
-JS_ClearAllTraps(JSContext *cx)
-{
-    JSRuntime *rt;
-    JSTrap *trap, *next;
-
-    rt = cx->runtime;
-    for (trap = (JSTrap *)rt->trapList.next;
-	 trap != (JSTrap *)&rt->trapList;
-	 trap = next) {
-	next = (JSTrap *)trap->links.next;
-	DestroyTrap(cx, trap);
-    }
-}
-
-JS_PUBLIC_API(JSTrapStatus)
-JS_HandleTrap(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval)
-{
-    JSTrap *trap;
-    JSTrapStatus status;
-    jsint op;
-
-    trap = FindTrap(cx->runtime, script, pc);
-    if (!trap) {
-	JS_ASSERT(0);	/* XXX can't happen */
-	return JSTRAP_ERROR;
-    }
-    /*
-     * It's important that we not use 'trap->' after calling the callback --
-     * the callback might remove the trap!
-     */
-    op = (jsint)trap->op;
-    status = trap->handler(cx, script, pc, rval, trap->closure);
-    if (status == JSTRAP_CONTINUE) {
-	/* By convention, return the true op to the interpreter in rval. */
-	*rval = INT_TO_JSVAL(op);
-    }
-    return status;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetInterrupt(JSRuntime *rt, JSTrapHandler handler, void *closure)
-{
-    rt->interruptHandler = handler;
-    rt->interruptHandlerData = closure;
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_ClearInterrupt(JSRuntime *rt, JSTrapHandler *handlerp, void **closurep)
-{
-    if (handlerp)
-	*handlerp = (JSTrapHandler)rt->interruptHandler;
-    if (closurep)
-	*closurep = rt->interruptHandlerData;
-    rt->interruptHandler = 0;
-    rt->interruptHandlerData = 0;
-    return JS_TRUE;
-}
-
-
-typedef struct JSWatchPoint {
-    JSCList             links;
-    JSObject            *object;	/* weak link, see js_FinalizeObject */
-    jsval               userid;
-    JSScopeProperty     *sprop;
-    JSPropertyOp        setter;
-    JSWatchPointHandler handler;
-    void                *closure;
-    jsrefcount          nrefs;
-} JSWatchPoint;
-
-#define HoldWatchPoint(wp) ((wp)->nrefs++)
-
-static void
-DropWatchPoint(JSContext *cx, JSWatchPoint *wp)
-{
-    if (--wp->nrefs != 0)
-	return;
-    SPROP_SETTER(wp->sprop, wp->object) = wp->setter;
-    JS_LOCK_OBJ_VOID(cx, wp->object,
-		     js_DropScopeProperty(cx, OBJ_SCOPE(wp->object),
-					  wp->sprop));
-    JS_REMOVE_LINK(&wp->links);
-    js_RemoveRoot(cx->runtime, &wp->closure);
-    JS_free(cx, wp);
-}
-
-static JSWatchPoint *
-FindWatchPoint(JSRuntime *rt, JSObject *obj, jsval userid)
-{
-    JSWatchPoint *wp;
-
-    for (wp = (JSWatchPoint *)rt->watchPointList.next;
-	 wp != (JSWatchPoint *)&rt->watchPointList;
-	 wp = (JSWatchPoint *)wp->links.next) {
-	if (wp->object == obj && wp->userid == userid)
-	    return wp;
-    }
-    return NULL;
-}
-
-JSScopeProperty *
-js_FindWatchPoint(JSRuntime *rt, JSObject *obj, jsval userid)
-{
-    JSWatchPoint *wp;
-
-    wp = FindWatchPoint(rt, obj, userid);
-    if (!wp)
-	return NULL;
-    return wp->sprop;
-}
-
-JSBool JS_DLL_CALLBACK
-js_watch_set(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
-{
-    JSRuntime *rt;
-    JSWatchPoint *wp;
-    JSScopeProperty *sprop;
-    JSSymbol *sym;
-    jsval userid, value;
-    jsid symid;
-    JSScope *scope;
-    JSAtom *atom;
-    JSBool ok;
-
-    rt = cx->runtime;
-    for (wp = (JSWatchPoint *)rt->watchPointList.next;
-	 wp != (JSWatchPoint *)&rt->watchPointList;
-	 wp = (JSWatchPoint *)wp->links.next) {
-	sprop = wp->sprop;
-	if (wp->object == obj && sprop->id == id) {
-	    JS_LOCK_OBJ(cx, obj);
-	    sym = sprop->symbols;
-	    if (!sym) {
-		userid = wp->userid;
-		atom = NULL;
-		if (JSVAL_IS_INT(userid)) {
-		    symid = (jsid)userid;
-		} else {
-		    atom = js_ValueToStringAtom(cx, userid);
-		    if (!atom) {
-			JS_UNLOCK_OBJ(cx, obj);
-			return JS_FALSE;
-		    }
-		    symid = (jsid)atom;
-		}
-		scope = OBJ_SCOPE(obj);
-		JS_ASSERT(scope->props);
-		ok = LOCKED_OBJ_GET_CLASS(obj)->addProperty(cx, obj, sprop->id,
-							    &value);
-		if (!ok) {
-		    JS_UNLOCK_OBJ(cx, obj);
-		    return JS_FALSE;
-		}
-		ok = (scope->ops->add(cx, scope, symid, sprop) != NULL);
-		if (!ok) {
-		    JS_UNLOCK_OBJ(cx, obj);
-		    return JS_FALSE;
-		}
-		sym = sprop->symbols;
-	    }
-	    JS_UNLOCK_OBJ(cx, obj);
-	    HoldWatchPoint(wp);
-	    ok = wp->handler(cx, obj, js_IdToValue(sym_id(sym)),
-			     OBJ_GET_SLOT(cx, obj, wp->sprop->slot), vp,
-			     wp->closure);
-	    if (ok)
-		ok = wp->setter(cx, obj, id, vp);
-	    DropWatchPoint(cx, wp);
-	    return ok;
-	}
-    }
-    JS_ASSERT(0);	/* XXX can't happen */
-    return JS_FALSE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetWatchPoint(JSContext *cx, JSObject *obj, jsval id,
-		 JSWatchPointHandler handler, void *closure)
-{
-    JSAtom *atom;
-    jsid symid;
-    JSObject *pobj;
-    JSScopeProperty *sprop;
-    JSRuntime *rt;
-    JSWatchPoint *wp;
-
-    if (!OBJ_IS_NATIVE(obj)) {
-	JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CANT_WATCH,
-			     OBJ_GET_CLASS(cx, obj)->name);
-	return JS_FALSE;
-    }
-
-    if (JSVAL_IS_INT(id)) {
-	symid = (jsid)id;
-	atom = NULL;
-    } else {
-	atom = js_ValueToStringAtom(cx, id);
-	if (!atom)
-	    return JS_FALSE;
-	symid = (jsid)atom;
-    }
-
-    if (!js_LookupProperty(cx, obj, symid, &pobj, (JSProperty **)&sprop))
-	return JS_FALSE;
-    rt = cx->runtime;
-    if (!sprop) {
-	/* Check for a deleted symbol watchpoint, which holds its property. */
-	sprop = js_FindWatchPoint(rt, obj, id);
-	if (sprop) {
-#ifdef JS_THREADSAFE
-	    /* Emulate js_LookupProperty if thread-safe. */
-	    JS_LOCK_OBJ(cx, obj);
-	    sprop->nrefs++;
-#endif
-	} else {
-	    /* Make a new property in obj so we can watch for the first set. */
-	    if (!js_DefineProperty(cx, obj, symid, JSVAL_VOID, NULL, NULL, 0,
-				   (JSProperty **)&sprop)) {
-		sprop = NULL;
-	    }
-	}
-    } else if (pobj != obj) {
-	/* Clone the prototype property so we can watch the right object. */
-	jsval value;
-	JSPropertyOp getter, setter;
-	uintN attrs;
-
-	if (OBJ_IS_NATIVE(pobj)) {
-	    value = LOCKED_OBJ_GET_SLOT(pobj, sprop->slot);
-	} else {
-	    if (!OBJ_GET_PROPERTY(cx, pobj, id, &value)) {
-		OBJ_DROP_PROPERTY(cx, pobj, (JSProperty *)sprop);
-		return JS_FALSE;
-	    }
-	}
-	getter = SPROP_GETTER(sprop, pobj);
-	setter = SPROP_SETTER(sprop, pobj);
-	attrs = sprop->attrs;
-	OBJ_DROP_PROPERTY(cx, pobj, (JSProperty *)sprop);
-
-	if (!js_DefineProperty(cx, obj, symid, value, getter, setter, attrs,
-			       (JSProperty **)&sprop)) {
-	    sprop = NULL;
-	}
-    }
-    if (!sprop)
-	return JS_FALSE;
-
-    wp = FindWatchPoint(rt, obj, id);
-    if (!wp) {
-	wp = JS_malloc(cx, sizeof *wp);
-	if (!wp)
-	    return JS_FALSE;
-	if (!js_AddRoot(cx, &wp->closure, "wp->closure")) {
-	    JS_free(cx, wp);
-	    return JS_FALSE;
-	}
-	JS_APPEND_LINK(&wp->links, &rt->watchPointList);
-	wp->object = obj;
-	wp->userid = id;
-	wp->sprop = js_HoldScopeProperty(cx, OBJ_SCOPE(obj), sprop);
-	wp->setter = SPROP_SETTER(sprop, obj);
-	SPROP_SETTER(sprop, obj) = js_watch_set;
-	wp->nrefs = 1;
-    }
-    wp->handler = handler;
-    wp->closure = closure;
-    OBJ_DROP_PROPERTY(cx, obj, (JSProperty *)sprop);
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(void)
-JS_ClearWatchPoint(JSContext *cx, JSObject *obj, jsval id,
-		   JSWatchPointHandler *handlerp, void **closurep)
-{
-    JSRuntime *rt;
-    JSWatchPoint *wp;
-
-    rt = cx->runtime;
-    for (wp = (JSWatchPoint *)rt->watchPointList.next;
-	 wp != (JSWatchPoint *)&rt->watchPointList;
-	 wp = (JSWatchPoint *)wp->links.next) {
-	if (wp->object == obj && wp->userid == id) {
-	    if (handlerp)
-		*handlerp = wp->handler;
-	    if (closurep)
-		*closurep = wp->closure;
-	    DropWatchPoint(cx, wp);
-	    return;
-	}
-    }
-    if (handlerp)
-	*handlerp = NULL;
-    if (closurep)
-	*closurep = NULL;
-}
-
-JS_PUBLIC_API(void)
-JS_ClearWatchPointsForObject(JSContext *cx, JSObject *obj)
-{
-    JSRuntime *rt;
-    JSWatchPoint *wp, *next;
-
-    rt = cx->runtime;
-    for (wp = (JSWatchPoint *)rt->watchPointList.next;
-	 wp != (JSWatchPoint *)&rt->watchPointList;
-	 wp = next) {
-	next = (JSWatchPoint *)wp->links.next;
-	if (wp->object == obj)
-	    DropWatchPoint(cx, wp);
-    }
-}
-
-JS_PUBLIC_API(void)
-JS_ClearAllWatchPoints(JSContext *cx)
-{
-    JSRuntime *rt;
-    JSWatchPoint *wp, *next;
-
-    rt = cx->runtime;
-    for (wp = (JSWatchPoint *)rt->watchPointList.next;
-	 wp != (JSWatchPoint *)&rt->watchPointList;
-	 wp = next) {
-	next = (JSWatchPoint *)wp->links.next;
-	DropWatchPoint(cx, wp);
-    }
-}
-
-JS_PUBLIC_API(uintN)
-JS_PCToLineNumber(JSContext *cx, JSScript *script, jsbytecode *pc)
-{
-    return js_PCToLineNumber(script, pc);
-}
-
-JS_PUBLIC_API(jsbytecode *)
-JS_LineNumberToPC(JSContext *cx, JSScript *script, uintN lineno)
-{
-    return js_LineNumberToPC(script, lineno);
-}
-
-JS_PUBLIC_API(JSScript *)
-JS_GetFunctionScript(JSContext *cx, JSFunction *fun)
-{
-    return fun->script;
-}
-
-JS_PUBLIC_API(JSPrincipals *)
-JS_GetScriptPrincipals(JSContext *cx, JSScript *script)
-{
-    return script->principals;
-}
-
-
-/*
- *  Stack Frame Iterator
- */
-JS_PUBLIC_API(JSStackFrame *)
-JS_FrameIterator(JSContext *cx, JSStackFrame **iteratorp)
-{
-    *iteratorp = (*iteratorp == NULL) ? cx->fp : (*iteratorp)->down;
-    return *iteratorp;
-}
-
-JS_PUBLIC_API(JSScript *)
-JS_GetFrameScript(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->script;
-}
-
-JS_PUBLIC_API(jsbytecode *)
-JS_GetFramePC(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->pc;
-}
-
-JS_PUBLIC_API(void *)
-JS_GetFrameAnnotation(JSContext *cx, JSStackFrame *fp)
-{
-    if (fp->annotation) {
-	JSPrincipals *principals = fp->script
-	    ? fp->script->principals
-	    : NULL;
-
-	if (principals == NULL)
-	    return NULL;
-
-	if (principals->globalPrivilegesEnabled(cx, principals)) {
-	    /*
-	     * Only give out an annotation if privileges have not
-	     * been revoked globally.
-	     */
-	    return fp->annotation;
-	}
-    }
-
-    return NULL;
-}
-
-JS_PUBLIC_API(void)
-JS_SetFrameAnnotation(JSContext *cx, JSStackFrame *fp, void *annotation)
-{
-    fp->annotation = annotation;
-}
-
-JS_PUBLIC_API(void *)
-JS_GetFramePrincipalArray(JSContext *cx, JSStackFrame *fp)
-{
-    JSPrincipals *principals = fp->script
-	? fp->script->principals
-	: NULL;
-
-    return principals
-	? principals->getPrincipalArray(cx, principals)
-	: NULL;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_IsNativeFrame(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->fun && fp->fun->call;
-}
-
-/* this is deprecated, use JS_GetFrameScopeChain instead */
-JS_PUBLIC_API(JSObject *)
-JS_GetFrameObject(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->scopeChain;
-}
-
-JS_PUBLIC_API(JSObject *)
-JS_GetFrameScopeChain(JSContext *cx, JSStackFrame *fp)
-{
-    /* Force creation of argument and call objects if not yet created */
-    JS_GetFrameCallObject(cx, fp);
-    return fp->scopeChain;
-}
-
-JS_PUBLIC_API(JSObject *)
-JS_GetFrameCallObject(JSContext *cx, JSStackFrame *fp)
-{
-    if (! fp->fun)
-	return NULL;
-    /* Force creation of argument object if not yet created */
-     js_GetArgsObject(cx, fp);
-#if JS_HAS_CALL_OBJECT
-    return js_GetCallObject(cx, fp, NULL, NULL);
-#else
-    return NULL;
-#endif /* JS_HAS_CALL_OBJECT */
-}
-
-
-JS_PUBLIC_API(JSObject *)
-JS_GetFrameThis(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->thisp;
-}
-
-JS_PUBLIC_API(JSFunction *)
-JS_GetFrameFunction(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->fun;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_IsContructorFrame(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->constructing;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_IsDebuggerFrame(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->special & JSFRAME_DEBUGGER;
-}
-
-JS_PUBLIC_API(jsval)
-JS_GetFrameReturnValue(JSContext *cx, JSStackFrame *fp)
-{
-    return fp->rval;
-}
-
-JS_PUBLIC_API(void)
-JS_SetFrameReturnValue(JSContext *cx, JSStackFrame *fp, jsval rval)
-{
-    fp->rval = rval;
-}
-
-/************************************************************************/
-
-JS_PUBLIC_API(const char *)
-JS_GetScriptFilename(JSContext *cx, JSScript *script)
-{
-    return script->filename;
-}
-
-JS_PUBLIC_API(uintN)
-JS_GetScriptBaseLineNumber(JSContext *cx, JSScript *script)
-{
-    return script->lineno;
-}
-
-JS_PUBLIC_API(uintN)
-JS_GetScriptLineExtent(JSContext *cx, JSScript *script)
-{
-    return js_GetScriptLineExtent(script);
-}
-
-/***************************************************************************/
-
-JS_PUBLIC_API(void)
-JS_SetNewScriptHook(JSRuntime *rt, JSNewScriptHook hook, void *callerdata)
-{
-    rt->newScriptHook = hook;
-    rt->newScriptHookData = callerdata;
-}
-
-JS_PUBLIC_API(void)
-JS_SetDestroyScriptHook(JSRuntime *rt, JSDestroyScriptHook hook,
-			void *callerdata)
-{
-    rt->destroyScriptHook = hook;
-    rt->destroyScriptHookData = callerdata;
-}
-
-/***************************************************************************/
-
-JS_PUBLIC_API(JSBool)
-JS_EvaluateInStackFrame(JSContext *cx, JSStackFrame *fp,
-			const char *bytes, uintN length,
-			const char *filename, uintN lineno,
-			jsval *rval)
-{
-    JSScript *script;
-    JSBool ok;
-
-    script = JS_CompileScriptForPrincipals(cx, fp->scopeChain,
-					   fp->script ? fp->script->principals
-						      : NULL,
-					   bytes, length, filename, lineno);
-    if (!script)
-	return JS_FALSE;
-    ok = js_Execute(cx, fp->scopeChain, script, fp->fun, fp, JSFRAME_DEBUGGER,
-                    rval);
-    js_DestroyScript(cx, script);
-    return ok;
-}
-
-/************************************************************************/
-
-/* XXXbe this all needs to be reworked to avoid requiring JSScope types. */
-
-JS_PUBLIC_API(JSScopeProperty *)
-JS_PropertyIterator(JSObject *obj, JSScopeProperty **iteratorp)
-{
-    JSScopeProperty *sprop;
-    JSScope *scope;
-
-    sprop = *iteratorp;
-    scope = OBJ_SCOPE(obj);
-    sprop = (sprop == NULL) ? scope->props : sprop->next;
-    *iteratorp = sprop;
-    return sprop;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_GetPropertyDesc(JSContext *cx, JSObject *obj, JSScopeProperty *sprop,
-		   JSPropertyDesc *pd)
-{
-    JSSymbol *sym;
-    JSPropertyOp getter;
-
-    sym = sprop->symbols;
-    pd->id = sym ? js_IdToValue(sym_id(sym)) : JSVAL_VOID;
-    if (!sym || !js_GetProperty(cx, obj, sym_id(sym), &pd->value))
-	pd->value = OBJ_GET_SLOT(cx, obj, sprop->slot);
-    getter = SPROP_GETTER(sprop, obj);
-    pd->flags = ((sprop->attrs & JSPROP_ENUMERATE)      ? JSPD_ENUMERATE : 0)
-	      | ((sprop->attrs & JSPROP_READONLY)       ? JSPD_READONLY  : 0)
-	      | ((sprop->attrs & JSPROP_PERMANENT)      ? JSPD_PERMANENT : 0)
-#if JS_HAS_CALL_OBJECT
-	      | ((getter == js_GetCallVariable)  ? JSPD_VARIABLE  : 0)
-#endif /* JS_HAS_CALL_OBJECT */
-	      | ((getter == js_GetArgument)      ? JSPD_ARGUMENT  : 0)
-	      | ((getter == js_GetLocalVariable) ? JSPD_VARIABLE  : 0);
-#if JS_HAS_CALL_OBJECT
-    /* for Call Object 'real' getter isn't passed in to us */
-    if (OBJ_GET_CLASS(cx, obj) == &js_CallClass &&
-	getter == js_CallClass.getProperty) {
-	pd->flags |= JSPD_ARGUMENT;
-    }
-#endif /* JS_HAS_CALL_OBJECT */
-    pd->spare = 0;
-    pd->slot = (pd->flags & (JSPD_ARGUMENT | JSPD_VARIABLE))
-	       ? JSVAL_TO_INT(sprop->id)
-	       : 0;
-    if (!sym || !sym->next || (pd->flags & (JSPD_ARGUMENT | JSPD_VARIABLE))) {
-	pd->alias = JSVAL_VOID;
-    } else {
-	pd->alias = js_IdToValue(sym_id(sym->next));
-	pd->flags |= JSPD_ALIAS;
-    }
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_GetPropertyDescArray(JSContext *cx, JSObject *obj, JSPropertyDescArray *pda)
-{
-    JSClass *clasp;
-    JSScope *scope;
-    uint32 i, n;
-    JSPropertyDesc *pd;
-    JSScopeProperty *sprop;
-
-    clasp = OBJ_GET_CLASS(cx, obj);
-    if (!OBJ_IS_NATIVE(obj) || (clasp->flags & JSCLASS_NEW_ENUMERATE)) {
-	JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
-			     JSMSG_CANT_DESCRIBE_PROPS, clasp->name);
-    	return JS_FALSE;
-    }
-    if (!clasp->enumerate(cx, obj))
-	return JS_FALSE;
-
-    /* have no props, or object's scope has not mutated from that of proto */
-    scope = OBJ_SCOPE(obj);
-    if (!scope->props ||
-	(OBJ_GET_PROTO(cx,obj) && scope == OBJ_SCOPE(OBJ_GET_PROTO(cx,obj)))) {
-	pda->length = 0;
-	pda->array = NULL;
-	return JS_TRUE;
-    }
-
-    n = scope->map.freeslot;
-    pd = JS_malloc(cx, (size_t)n * sizeof(JSPropertyDesc));
-    if (!pd)
-	return JS_FALSE;
-    i = 0;
-    for (sprop = scope->props; sprop; sprop = sprop->next) {
-	if (!js_AddRoot(cx, &pd[i].id, NULL))
-	    goto bad;
-	if (!js_AddRoot(cx, &pd[i].value, NULL))
-	    goto bad;
-	JS_GetPropertyDesc(cx, obj, sprop, &pd[i]);
-	if ((pd[i].flags & JSPD_ALIAS) && !js_AddRoot(cx, &pd[i].alias, NULL))
-	    goto bad;
-	if (++i == n)
-	    break;
-    }
-    pda->length = i;
-    pda->array = pd;
-    return JS_TRUE;
-
-bad:
-    pda->length = i + 1;
-    pda->array = pd;
-    JS_PutPropertyDescArray(cx, pda);
-    return JS_FALSE;
-}
-
-JS_PUBLIC_API(void)
-JS_PutPropertyDescArray(JSContext *cx, JSPropertyDescArray *pda)
-{
-    JSPropertyDesc *pd;
-    uint32 i;
-
-    pd = pda->array;
-    for (i = 0; i < pda->length; i++) {
-	js_RemoveRoot(cx->runtime, &pd[i].id);
-	js_RemoveRoot(cx->runtime, &pd[i].value);
-	if (pd[i].flags & JSPD_ALIAS)
-	    js_RemoveRoot(cx->runtime, &pd[i].alias);
-    }
-    JS_free(cx, pd);
-}
-
-/************************************************************************/
-
-JS_PUBLIC_API(JSBool)
-JS_SetDebuggerHandler(JSRuntime *rt, JSTrapHandler handler, void *closure)
-{
-    rt->debuggerHandler = handler;
-    rt->debuggerHandlerData = closure;
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetSourceHandler(JSRuntime *rt, JSSourceHandler handler, void *closure)
-{
-    rt->sourceHandler = handler;
-    rt->sourceHandlerData = closure;
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetExecuteHook(JSRuntime *rt, JSInterpreterHook hook, void *closure)
-{
-    rt->executeHook = hook;
-    rt->executeHookData = closure;
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetCallHook(JSRuntime *rt, JSInterpreterHook hook, void *closure)
-{
-    rt->callHook = hook;
-    rt->callHookData = closure;
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetObjectHook(JSRuntime *rt, JSObjectHook hook, void *closure)
-{
-    rt->objectHook = hook;
-    rt->objectHookData = closure;
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetThrowHook(JSRuntime *rt, JSTrapHandler hook, void *closure)
-{
-    rt->throwHook = hook;
-    rt->throwHookData = closure;
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(JSBool)
-JS_SetDebugErrorHook(JSRuntime *rt, JSDebugErrorHook hook, void *closure)
-{
-    rt->debugErrorHook = hook;
-    rt->debugErrorHookData = closure;
-    return JS_TRUE;
-}

mozilla/js/src/jsdbgapi.h

@@ -1,270 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsdbgapi_h___
-#define jsdbgapi_h___
-/*
- * JS debugger API.
- */
-#include "jsapi.h"
-#include "jsopcode.h"
-#include "jsprvtd.h"
-
-JS_BEGIN_EXTERN_C
-
-extern void
-js_PatchOpcode(JSContext *cx, JSScript *script, jsbytecode *pc, JSOp op);
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetTrap(JSContext *cx, JSScript *script, jsbytecode *pc,
-	   JSTrapHandler handler, void *closure);
-
-extern JS_PUBLIC_API(JSOp)
-JS_GetTrapOpcode(JSContext *cx, JSScript *script, jsbytecode *pc);
-
-extern JS_PUBLIC_API(void)
-JS_ClearTrap(JSContext *cx, JSScript *script, jsbytecode *pc,
-	     JSTrapHandler *handlerp, void **closurep);
-
-extern JS_PUBLIC_API(void)
-JS_ClearScriptTraps(JSContext *cx, JSScript *script);
-
-extern JS_PUBLIC_API(void)
-JS_ClearAllTraps(JSContext *cx);
-
-extern JS_PUBLIC_API(JSTrapStatus)
-JS_HandleTrap(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval);
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetInterrupt(JSRuntime *rt, JSTrapHandler handler, void *closure);
-
-extern JS_PUBLIC_API(JSBool)
-JS_ClearInterrupt(JSRuntime *rt, JSTrapHandler *handlerp, void **closurep);
-
-/************************************************************************/
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetWatchPoint(JSContext *cx, JSObject *obj, jsval id,
-		 JSWatchPointHandler handler, void *closure);
-
-extern JS_PUBLIC_API(void)
-JS_ClearWatchPoint(JSContext *cx, JSObject *obj, jsval id,
-		   JSWatchPointHandler *handlerp, void **closurep);
-
-extern JS_PUBLIC_API(void)
-JS_ClearWatchPointsForObject(JSContext *cx, JSObject *obj);
-
-extern JS_PUBLIC_API(void)
-JS_ClearAllWatchPoints(JSContext *cx);
-
-#ifdef JS_HAS_OBJ_WATCHPOINT
-/*
- * Hide these non-API function prototypes by testing whether the internal
- * header file "jsconfig.h" has been included.
- */
-extern JSScopeProperty *
-js_FindWatchPoint(JSRuntime *rt, JSObject *obj, jsval userid);
-
-extern JSBool JS_DLL_CALLBACK
-js_watch_set(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
-#endif
-
-/************************************************************************/
-
-extern JS_PUBLIC_API(uintN)
-JS_PCToLineNumber(JSContext *cx, JSScript *script, jsbytecode *pc);
-
-extern JS_PUBLIC_API(jsbytecode *)
-JS_LineNumberToPC(JSContext *cx, JSScript *script, uintN lineno);
-
-extern JS_PUBLIC_API(JSScript *)
-JS_GetFunctionScript(JSContext *cx, JSFunction *fun);
-
-extern JS_PUBLIC_API(JSPrincipals *)
-JS_GetScriptPrincipals(JSContext *cx, JSScript *script);
-
-/*
- * Stack Frame Iterator
- *
- * Used to iterate through the JS stack frames to extract
- * information from the frames.
- */
-
-extern JS_PUBLIC_API(JSStackFrame *)
-JS_FrameIterator(JSContext *cx, JSStackFrame **iteratorp);
-
-extern JS_PUBLIC_API(JSScript *)
-JS_GetFrameScript(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(jsbytecode *)
-JS_GetFramePC(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(JSBool)
-JS_IsNativeFrame(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(void *)
-JS_GetFrameAnnotation(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(void)
-JS_SetFrameAnnotation(JSContext *cx, JSStackFrame *fp, void *annotation);
-
-extern JS_PUBLIC_API(void *)
-JS_GetFramePrincipalArray(JSContext *cx, JSStackFrame *fp);
-
-/* this is deprecated, use JS_GetFrameScopeChain instead */
-extern JS_PUBLIC_API(JSObject *)
-JS_GetFrameObject(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(JSObject *)
-JS_GetFrameScopeChain(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(JSObject *)
-JS_GetFrameCallObject(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(JSObject *)
-JS_GetFrameThis(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(JSFunction *)
-JS_GetFrameFunction(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(JSBool)
-JS_IsContructorFrame(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(JSBool)
-JS_IsDebuggerFrame(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(jsval)
-JS_GetFrameReturnValue(JSContext *cx, JSStackFrame *fp);
-
-extern JS_PUBLIC_API(void)
-JS_SetFrameReturnValue(JSContext *cx, JSStackFrame *fp, jsval rval);
-
-/************************************************************************/
-
-extern JS_PUBLIC_API(const char *)
-JS_GetScriptFilename(JSContext *cx, JSScript *script);
-
-extern JS_PUBLIC_API(uintN)
-JS_GetScriptBaseLineNumber(JSContext *cx, JSScript *script);
-
-extern JS_PUBLIC_API(uintN)
-JS_GetScriptLineExtent(JSContext *cx, JSScript *script);
-
-/************************************************************************/
-
-/*
- * Hook setters for script creation and destruction, see jsprvtd.h for the
- * typedefs.  These macros provide binary compatibility and newer, shorter
- * synonyms.
- */
-#define JS_SetNewScriptHook     JS_SetNewScriptHookProc
-#define JS_SetDestroyScriptHook JS_SetDestroyScriptHookProc
-
-extern JS_PUBLIC_API(void)
-JS_SetNewScriptHook(JSRuntime *rt, JSNewScriptHook hook, void *callerdata);
-
-extern JS_PUBLIC_API(void)
-JS_SetDestroyScriptHook(JSRuntime *rt, JSDestroyScriptHook hook,
-			void *callerdata);
-
-/************************************************************************/
-
-extern JS_PUBLIC_API(JSBool)
-JS_EvaluateInStackFrame(JSContext *cx, JSStackFrame *fp,
-			const char *bytes, uintN length,
-			const char *filename, uintN lineno,
-			jsval *rval);
-
-/************************************************************************/
-
-typedef struct JSPropertyDesc {
-    jsval           id;         /* primary id, a string or int */
-    jsval           value;      /* property value */
-    uint8           flags;      /* flags, see below */
-    uint8           spare;      /* unused */
-    uint16          slot;       /* argument/variable slot */
-    jsval           alias;      /* alias id if JSPD_ALIAS flag */
-} JSPropertyDesc;
-
-#define JSPD_ENUMERATE  0x01    /* visible to for/in loop */
-#define JSPD_READONLY   0x02    /* assignment is error */
-#define JSPD_PERMANENT  0x04    /* property cannot be deleted */
-#define JSPD_ALIAS      0x08    /* property has an alias id */
-#define JSPD_ARGUMENT   0x10    /* argument to function */
-#define JSPD_VARIABLE   0x20    /* local variable in function */
-
-typedef struct JSPropertyDescArray {
-    uint32          length;     /* number of elements in array */
-    JSPropertyDesc  *array;     /* alloc'd by Get, freed by Put */
-} JSPropertyDescArray;
-
-extern JS_PUBLIC_API(JSScopeProperty *)
-JS_PropertyIterator(JSObject *obj, JSScopeProperty **iteratorp);
-
-extern JS_PUBLIC_API(JSBool)
-JS_GetPropertyDesc(JSContext *cx, JSObject *obj, JSScopeProperty *sprop,
-		   JSPropertyDesc *pd);
-
-extern JS_PUBLIC_API(JSBool)
-JS_GetPropertyDescArray(JSContext *cx, JSObject *obj, JSPropertyDescArray *pda);
-
-extern JS_PUBLIC_API(void)
-JS_PutPropertyDescArray(JSContext *cx, JSPropertyDescArray *pda);
-
-/************************************************************************/
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetDebuggerHandler(JSRuntime *rt, JSTrapHandler handler, void *closure);
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetSourceHandler(JSRuntime *rt, JSSourceHandler handler, void *closure);
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetExecuteHook(JSRuntime *rt, JSInterpreterHook hook, void *closure);
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetCallHook(JSRuntime *rt, JSInterpreterHook hook, void *closure);
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetObjectHook(JSRuntime *rt, JSObjectHook hook, void *closure);
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetThrowHook(JSRuntime *rt, JSTrapHandler hook, void *closure);
-
-extern JS_PUBLIC_API(JSBool)
-JS_SetDebugErrorHook(JSRuntime *rt, JSDebugErrorHook hook, void *closure);
-
-JS_END_EXTERN_C
-
-#endif /* jsdbgapi_h___ */

mozilla/js/src/jsdtoa.h

@@ -1,114 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsdtoa_h___
-#define jsdtoa_h___
-/*
- * Public interface to portable double-precision floating point to string
- * and back conversion package.
- */
-
-#include "jscompat.h"
-
-JS_BEGIN_EXTERN_C
-
-/*
- * JS_strtod() returns as a double-precision floating-point number
- * the  value represented by the character string pointed to by
- * s00.  The string is scanned up to  the  first  unrecognized
- * character.
- * If the value of se is not (char **)NULL,  a  pointer  to
- * the  character terminating the scan is returned in the location pointed
- * to by se.  If no number can be  formed, se is set to s00r, and
- * zero is returned.
- */
-JS_FRIEND_API(double)
-JS_strtod(const char *s00, char **se);
-
-/*
- * Modes for converting floating-point numbers to strings.
- *
- * Some of the modes can round-trip; this means that if the number is converted to
- * a string using one of these mode and then converted back to a number, the result
- * will be identical to the original number (except that, due to ECMA, -0 will get converted
- * to +0).  These round-trip modes return the minimum number of significand digits that
- * permit the round trip.
- *
- * Some of the modes take an integer parameter <precision>.
- */
-/* NB: Keep this in sync with number_constants[]. */
-typedef enum JSDToStrMode {
-    DTOSTR_STANDARD,              /* Either fixed or exponential format; round-trip */
-    DTOSTR_STANDARD_EXPONENTIAL,  /* Always exponential format; round-trip */
-    DTOSTR_FIXED,                 /* Round to <precision> digits after the decimal point; exponential if number is large */
-    DTOSTR_EXPONENTIAL,           /* Always exponential format; <precision> significant digits */
-    DTOSTR_PRECISION              /* Either fixed or exponential format; <precision> significant digits */
-} JSDToStrMode;
-
-
-/* Maximum number of characters (including trailing null) that a DTOSTR_STANDARD or DTOSTR_STANDARD_EXPONENTIAL
- * conversion can produce.  This maximum is reached for a number like -1.2345678901234567e+123. */
-#define DTOSTR_STANDARD_BUFFER_SIZE 25
-
-/* Maximum number of characters (including trailing null) that one of the other conversions
- * can produce.  This maximum is reached for TO_FIXED, which can generate up to 21 digits before the decimal point. */
-#define DTOSTR_VARIABLE_BUFFER_SIZE(precision) ((precision)+24 > DTOSTR_STANDARD_BUFFER_SIZE ? (precision)+24 : DTOSTR_STANDARD_BUFFER_SIZE)
-
-/*
- * Convert dval according to the given mode and return a pointer to the resulting ASCII string.
- * The result is held somewhere in buffer, but not necessarily at the beginning.  The size of
- * buffer is given in bufferSize, and must be at least as large as given by the above macros.
- *
- * Return NULL if out of memory.
- */
-JS_FRIEND_API(char *)
-JS_dtostr(char *buffer, size_t bufferSize, JSDToStrMode mode, int precision, double dval);
-
-/*
- * Convert d to a string in the given base.  The integral part of d will be printed exactly
- * in that base, regardless of how large it is, because there is no exponential notation for non-base-ten
- * numbers.  The fractional part will be rounded to as few digits as possible while still preserving
- * the round-trip property (analogous to that of printing decimal numbers).  In other words, if one were
- * to read the resulting string in via a hypothetical base-number-reading routine that rounds to the nearest
- * IEEE double (and to an even significand if there are two equally near doubles), then the result would
- * equal d (except for -0.0, which converts to "0", and NaN, which is not equal to itself).
- *
- * Return NULL if out of memory.  If the result is not NULL, it must be released via free().
- */
-JS_FRIEND_API(char *)
-JS_dtobasestr(int base, double d);
-
-JS_END_EXTERN_C
-
-#endif /* jsdtoa_h___ */

mozilla/js/src/jsemit.h

@@ -1,419 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsemit_h___
-#define jsemit_h___
-/*
- * JS bytecode generation.
- */
-
-#include "jsstddef.h"
-#include "jstypes.h"
-#include "jsatom.h"
-#include "jsopcode.h"
-#include "jsprvtd.h"
-#include "jspubtd.h"
-
-JS_BEGIN_EXTERN_C
-
-typedef enum JSStmtType {
-    STMT_BLOCK        = 0,      /* compound statement: { s1[;... sN] } */
-    STMT_LABEL        = 1,      /* labeled statement:  L: s */
-    STMT_IF           = 2,      /* if (then) statement */
-    STMT_ELSE         = 3,      /* else clause of if statement */
-    STMT_SWITCH       = 4,      /* switch statement */
-    STMT_WITH         = 5,      /* with statement */
-    STMT_TRY          = 6,      /* try statement */
-    STMT_CATCH        = 7,      /* catch block */
-    STMT_FINALLY      = 8,      /* finally statement */
-    STMT_DO_LOOP      = 9,      /* do/while loop statement */
-    STMT_FOR_LOOP     = 10,     /* for loop statement */
-    STMT_FOR_IN_LOOP  = 11,     /* for/in loop statement */
-    STMT_WHILE_LOOP   = 12      /* while loop statement */
-} JSStmtType;
-
-#define STMT_IS_LOOP(stmt)      ((stmt)->type >= STMT_DO_LOOP)
-
-typedef struct JSStmtInfo JSStmtInfo;
-
-struct JSStmtInfo {
-    JSStmtType      type;           /* statement type */
-    ptrdiff_t       top;            /* offset of loop top from cg base */
-    ptrdiff_t       update;         /* loop update offset (top if none) */
-    ptrdiff_t       breaks;         /* offset of last break in loop */
-    ptrdiff_t       continues;      /* offset of last continue in loop */
-    JSAtom          *label;         /* name of LABEL or CATCH var */
-    JSStmtInfo      *down;          /* info for enclosing statement */
-};
-
-#define SET_STATEMENT_TOP(stmt, top) \
-    ((stmt)->top = (stmt)->update = (top), (stmt)->breaks = (stmt)->continues = (-1))
-
-struct JSTreeContext {              /* tree context for semantic checks */
-    uint32          flags;          /* statement state flags, see below */
-    uint32          tryCount;       /* total count of try statements parsed */
-    JSStmtInfo      *topStmt;       /* top of statement info stack */
-    JSAtomList      decls;          /* function, const, and var declarations */
-};
-
-#define TCF_TOP_LEVEL   0x01        /* at TL of program or function body */
-#define TCF_IN_FUNCTION 0x02        /* parsing inside function body */
-#define TCF_RETURN_EXPR 0x04        /* function has 'return expr;' */
-#define TCF_RETURN_VOID 0x08        /* function has 'return;' */
-#define TCF_IN_FOR_INIT 0x10        /* parsing init expr of for; exclude 'in' */
-#define TCF_FUN_VS_VAR  0x20        /* function and var with same name */
-
-#define TREE_CONTEXT_INIT(tc)                                                 \
-    ((tc)->flags = TCF_TOP_LEVEL, (tc)->tryCount = 0, (tc)->topStmt = NULL,   \
-     ATOM_LIST_INIT(&(tc)->decls))
-
-#define TREE_CONTEXT_FREE(tc)                                                 \
-    ((void)0)
-
-struct JSCodeGenerator {
-    void            *codeMark;      /* low watermark in cx->codePool */
-    void            *noteMark;      /* low watermark in cx->notePool */
-    void            *tempMark;      /* low watermark in cx->tempPool */
-    struct {
-        jsbytecode  *base;          /* base of JS bytecode vector */
-        jsbytecode  *limit;         /* one byte beyond end of bytecode */
-        jsbytecode  *next;          /* pointer to next free bytecode */
-    } prolog, main, *current;
-    const char      *filename;      /* null or weak link to source filename */
-    uintN           firstLine;      /* first line, for js_NewScriptFromCG */
-    uintN           currentLine;    /* line number for tree-based srcnote gen */
-    JSPrincipals    *principals;    /* principals for constant folding eval */
-    JSTreeContext   treeContext;    /* for break/continue code generation */
-    JSAtomList      atomList;       /* literals indexed for mapping */
-    intN            stackDepth;     /* current stack depth in script frame */
-    uintN           maxStackDepth;  /* maximum stack depth so far */
-    jssrcnote       *notes;         /* source notes, see below */
-    uintN           noteCount;      /* number of source notes so far */
-    ptrdiff_t       lastNoteOffset; /* code offset for last source note */
-    JSTryNote       *tryBase;       /* first exception handling note */
-    JSTryNote       *tryNext;       /* next available note */
-    size_t          tryNoteSpace;   /* # of bytes allocated at tryBase */
-};
-
-#define CG_BASE(cg)             ((cg)->current->base)
-#define CG_LIMIT(cg)            ((cg)->current->limit)
-#define CG_NEXT(cg)             ((cg)->current->next)
-#define CG_CODE(cg,offset)      (CG_BASE(cg) + (offset))
-#define CG_OFFSET(cg)           PTRDIFF(CG_NEXT(cg), CG_BASE(cg), jsbytecode)
-
-#define CG_PROLOG_BASE(cg)      ((cg)->prolog.base)
-#define CG_PROLOG_LIMIT(cg)     ((cg)->prolog.limit)
-#define CG_PROLOG_NEXT(cg)      ((cg)->prolog.next)
-#define CG_PROLOG_CODE(cg,poff) (CG_PROLOG_BASE(cg) + (poff))
-#define CG_PROLOG_OFFSET(cg)    PTRDIFF(CG_PROLOG_NEXT(cg), CG_PROLOG_BASE(cg),\
-                                        jsbytecode)
-
-#define CG_SWITCH_TO_MAIN(cg)   ((cg)->current = &(cg)->main)
-#define CG_SWITCH_TO_PROLOG(cg) ((cg)->current = &(cg)->prolog)
-
-/*
- * Initialize cg to allocate bytecode space from cx->codePool, source note
- * space from cx->notePool, and all other arena-allocated temporaries from
- * cx->tempPool.  Return true on success.  Report an error and return false
- * if the initial code segment can't be allocated.
- */
-extern JS_FRIEND_API(JSBool)
-js_InitCodeGenerator(JSContext *cx, JSCodeGenerator *cg,
-		     const char *filename, uintN lineno,
-		     JSPrincipals *principals);
-
-/*
- * Release cx->codePool, cx->notePool, and cx->tempPool to marks set by
- * js_InitCodeGenerator.  Note that cgs are magic: they own the arena pool
- * "tops-of-stack" space above their codeMark, noteMark, and tempMark points.
- * This means you cannot alloc from tempPool and save the pointer beyond the
- * next JS_FinishCodeGenerator.
- */
-extern JS_FRIEND_API(void)
-js_FinishCodeGenerator(JSContext *cx, JSCodeGenerator *cg);
-
-/*
- * Emit one bytecode.
- */
-extern ptrdiff_t
-js_Emit1(JSContext *cx, JSCodeGenerator *cg, JSOp op);
-
-/*
- * Emit two bytecodes, an opcode (op) with a byte of immediate operand (op1).
- */
-extern ptrdiff_t
-js_Emit2(JSContext *cx, JSCodeGenerator *cg, JSOp op, jsbytecode op1);
-
-/*
- * Emit three bytecodes, an opcode with two bytes of immediate operands.
- */
-extern ptrdiff_t
-js_Emit3(JSContext *cx, JSCodeGenerator *cg, JSOp op, jsbytecode op1,
-	 jsbytecode op2);
-
-/*
- * Emit (1 + extra) bytecodes, for N bytes of op and its immediate operand.
- */
-extern ptrdiff_t
-js_EmitN(JSContext *cx, JSCodeGenerator *cg, JSOp op, size_t extra);
-
-/*
- * Unsafe macro to call js_SetJumpOffset and return false if it does.
- */
-#define CHECK_AND_SET_JUMP_OFFSET(cx,cg,pc,off)                               \
-    JS_BEGIN_MACRO                                                            \
-	if (!js_SetJumpOffset(cx, cg, pc, off))                               \
-	    return JS_FALSE;                                                  \
-    JS_END_MACRO
-
-#define CHECK_AND_SET_JUMP_OFFSET_AT(cx,cg,off)                               \
-    CHECK_AND_SET_JUMP_OFFSET(cx, cg, CG_CODE(cg,off), CG_OFFSET(cg) - (off))
-
-extern JSBool
-js_SetJumpOffset(JSContext *cx, JSCodeGenerator *cg, jsbytecode *pc,
-		 ptrdiff_t off);
-
-/*
- * Push the C-stack-allocated struct at stmt onto the stmtInfo stack.
- */
-extern void
-js_PushStatement(JSTreeContext *tc, JSStmtInfo *stmt, JSStmtType type,
-		 ptrdiff_t top);
-
-/*
- * Emit a break instruction, recording it for backpatching.
- */
-extern ptrdiff_t
-js_EmitBreak(JSContext *cx, JSCodeGenerator *cg, JSStmtInfo *stmt,
-	     JSAtomListElement *label);
-
-/*
- * Emit a continue instruction, recording it for backpatching.
- */
-extern ptrdiff_t
-js_EmitContinue(JSContext *cx, JSCodeGenerator *cg, JSStmtInfo *stmt,
-		JSAtomListElement *label);
-
-/*
- * Pop tc->topStmt.  If the top JSStmtInfo struct is not stack-allocated, it
- * is up to the caller to free it.
- */
-extern void
-js_PopStatement(JSTreeContext *tc);
-
-/*
- * Like js_PopStatement(&cg->treeContext), also patch breaks and continues.
- * May fail if a jump offset overflows.
- */
-extern JSBool
-js_PopStatementCG(JSContext *cx, JSCodeGenerator *cg);
-
-/*
- * Emit code into cg for the tree rooted at pn.
- */
-extern JSBool
-js_EmitTree(JSContext *cx, JSCodeGenerator *cg, JSParseNode *pn);
-
-/*
- * Emit code into cg for the tree rooted at body, then create a persistent
- * script for fun from cg.
- */
-extern JSBool
-js_EmitFunctionBody(JSContext *cx, JSCodeGenerator *cg, JSParseNode *body,
-		    JSFunction *fun);
-
-/*
- * Source notes generated along with bytecode for decompiling and debugging.
- * A source note is a uint8 with 5 bits of type and 3 of offset from the pc of
- * the previous note.  If 3 bits of offset aren't enough, extended delta notes
- * (SRC_XDELTA) consisting of 3 set high order bits followed by 5 offset bits
- * are emitted before the next note.  Some notes have operand offsets encoded
- * immediately after them, in note bytes or byte-triples.
- *
- *                 Source Note               Extended Delta
- *              +7-6-5-4-3+2-1-0+           +7-6-5+4-3-2-1-0+
- *              |note-type|delta|           |1 1 1|ext-delta|
- *              +---------+-----+           +-----+---------+
- *
- * At most one "gettable" note (i.e., a note of type other than SRC_NEWLINE,
- * SRC_SETLINE, and SRC_XDELTA) applies to a given bytecode.
- *
- * NB: the js_SrcNoteName and js_SrcNoteArity arrays in jsemit.c are indexed
- * by this enum, so their initializers need to match the order here.
- */
-typedef enum JSSrcNoteType {
-    SRC_NULL        = 0,        /* terminates a note vector */
-    SRC_IF          = 1,        /* JSOP_IFEQ bytecode is from an if-then */
-    SRC_IF_ELSE     = 2,        /* JSOP_IFEQ bytecode is from an if-then-else */
-    SRC_WHILE       = 3,        /* JSOP_IFEQ is from a while loop */
-    SRC_FOR         = 4,        /* JSOP_NOP or JSOP_POP in for loop head */
-    SRC_CONTINUE    = 5,        /* JSOP_GOTO is a continue, not a break;
-                                   also used on JSOP_ENDINIT if extra comma
-                                   at end of array literal: [1,2,,] */
-    SRC_VAR         = 6,        /* JSOP_NAME/SETNAME/FORNAME in a var decl */
-    SRC_PCDELTA     = 7,        /* offset from comma-operator to next POP,
-				   or from CONDSWITCH to first CASE opcode */
-    SRC_ASSIGNOP    = 8,        /* += or another assign-op follows */
-    SRC_COND        = 9,        /* JSOP_IFEQ is from conditional ?: operator */
-    SRC_PAREN       = 10,       /* JSOP_NOP generated to mark user parens */
-    SRC_HIDDEN      = 11,       /* opcode shouldn't be decompiled */
-    SRC_PCBASE      = 12,       /* offset of first obj.prop.subprop bytecode */
-    SRC_LABEL       = 13,       /* JSOP_NOP for label: with atomid immediate */
-    SRC_LABELBRACE  = 14,       /* JSOP_NOP for label: {...} begin brace */
-    SRC_ENDBRACE    = 15,       /* JSOP_NOP for label: {...} end brace */
-    SRC_BREAK2LABEL = 16,       /* JSOP_GOTO for 'break label' with atomid */
-    SRC_CONT2LABEL  = 17,       /* JSOP_GOTO for 'continue label' with atomid */
-    SRC_SWITCH      = 18,       /* JSOP_*SWITCH with offset to end of switch,
-				   2nd off to first JSOP_CASE if condswitch */
-    SRC_FUNCDEF     = 19,       /* JSOP_NOP for function f() with atomid */
-    SRC_TRYFIN	    = 20,       /* JSOP_NOP for try or finally section */
-    SRC_CATCH       = 21,       /* catch block has guard */
-    SRC_CONST       = 22,       /* JSOP_SETCONST in a const decl */
-    SRC_RESERVED1   = 23,       /* reserved for future use */
-    SRC_RESERVED2   = 24,       /* reserved for future use */
-    SRC_RESERVED3   = 25,       /* reserved for future use */
-    SRC_NEWLINE     = 26,       /* bytecode follows a source newline */
-    SRC_SETLINE     = 27,       /* a file-absolute source line number note */
-    SRC_XDELTA      = 28        /* 28-31 are for extended delta notes */
-} JSSrcNoteType;
-
-#define SN_TYPE_BITS            5
-#define SN_DELTA_BITS           3
-#define SN_XDELTA_BITS          5
-#define SN_TYPE_MASK            (JS_BITMASK(SN_TYPE_BITS) << SN_DELTA_BITS)
-#define SN_DELTA_MASK           ((ptrdiff_t)JS_BITMASK(SN_DELTA_BITS))
-#define SN_XDELTA_MASK          ((ptrdiff_t)JS_BITMASK(SN_XDELTA_BITS))
-
-#define SN_MAKE_NOTE(sn,t,d)    (*(sn) = (jssrcnote)                          \
-					  (((t) << SN_DELTA_BITS)             \
-					   | ((d) & SN_DELTA_MASK)))
-#define SN_MAKE_XDELTA(sn,d)    (*(sn) = (jssrcnote)                          \
-					  ((SRC_XDELTA << SN_DELTA_BITS)      \
-					   | ((d) & SN_XDELTA_MASK)))
-
-#define SN_IS_XDELTA(sn)        ((*(sn) >> SN_DELTA_BITS) >= SRC_XDELTA)
-#define SN_TYPE(sn)             (SN_IS_XDELTA(sn) ? SRC_XDELTA                \
-						  : *(sn) >> SN_DELTA_BITS)
-#define SN_SET_TYPE(sn,type)    SN_MAKE_NOTE(sn, type, SN_DELTA(sn))
-#define SN_IS_GETTABLE(sn)      (SN_TYPE(sn) < SRC_NEWLINE)
-
-#define SN_DELTA(sn)            ((ptrdiff_t)(SN_IS_XDELTA(sn)                 \
-					     ? *(sn) & SN_XDELTA_MASK         \
-					     : *(sn) & SN_DELTA_MASK))
-#define SN_SET_DELTA(sn,delta)  (SN_IS_XDELTA(sn)                             \
-				 ? SN_MAKE_XDELTA(sn, delta)                  \
-				 : SN_MAKE_NOTE(sn, SN_TYPE(sn), delta))
-
-#define SN_DELTA_LIMIT          ((ptrdiff_t)JS_BIT(SN_DELTA_BITS))
-#define SN_XDELTA_LIMIT         ((ptrdiff_t)JS_BIT(SN_XDELTA_BITS))
-
-/*
- * Offset fields follow certain notes and are frequency-encoded: an offset in
- * [0,0x7f] consumes one byte, an offset in [0x80,0x7fffff] takes three, and
- * the high bit of the first byte is set.
- */
-#define SN_3BYTE_OFFSET_FLAG    0x80
-#define SN_3BYTE_OFFSET_MASK    0x7f
-
-extern JS_FRIEND_DATA(const char *) js_SrcNoteName[];
-extern JS_FRIEND_DATA(uint8)        js_SrcNoteArity[];
-extern JS_FRIEND_API(uintN)         js_SrcNoteLength(jssrcnote *sn);
-
-#define SN_LENGTH(sn)           ((js_SrcNoteArity[SN_TYPE(sn)] == 0) ? 1      \
-				 : js_SrcNoteLength(sn))
-#define SN_NEXT(sn)             ((sn) + SN_LENGTH(sn))
-
-/* A source note array is terminated by an all-zero element. */
-#define SN_MAKE_TERMINATOR(sn)  (*(sn) = SRC_NULL)
-#define SN_IS_TERMINATOR(sn)    (*(sn) == SRC_NULL)
-
-/*
- * Append a new source note of the given type (and therefore size) to cg's
- * notes dynamic array, updating cg->noteCount.  Return the new note's index
- * within the array pointed at by cg->notes.  Return -1 if out of memory.
- */
-extern intN
-js_NewSrcNote(JSContext *cx, JSCodeGenerator *cg, JSSrcNoteType type);
-
-extern intN
-js_NewSrcNote2(JSContext *cx, JSCodeGenerator *cg, JSSrcNoteType type,
-	       ptrdiff_t offset);
-
-extern intN
-js_NewSrcNote3(JSContext *cx, JSCodeGenerator *cg, JSSrcNoteType type,
-	       ptrdiff_t offset1, ptrdiff_t offset2);
-
-/*
- * Get and set the offset operand identified by which (0 for the first, etc.).
- */
-extern JS_FRIEND_API(ptrdiff_t)
-js_GetSrcNoteOffset(jssrcnote *sn, uintN which);
-
-extern JSBool
-js_SetSrcNoteOffset(JSContext *cx, JSCodeGenerator *cg, uintN index,
-		    uintN which, ptrdiff_t offset);
-
-/*
- * Finish taking source notes in cx's notePool by copying them to new
- * stable store allocated via JS_malloc.  Return null on malloc failure,
- * which means this function reported an error.
- */
-extern jssrcnote *
-js_FinishTakingSrcNotes(JSContext *cx, JSCodeGenerator *cg);
-
-/*
- * Allocate cg->treeContext.tryCount notes (plus one for the end sentinel)
- * from cx->tempPool and set up cg->tryBase/tryNext for exactly tryCount
- * js_NewTryNote calls.  The storage is freed by js_FinishCodeGenerator.
- */
-extern JSBool
-js_AllocTryNotes(JSContext *cx, JSCodeGenerator *cg);
-
-/*
- * Grab the next trynote slot in cg, filling it in appropriately.
- */
-extern JSTryNote *
-js_NewTryNote(JSContext *cx, JSCodeGenerator *cg, ptrdiff_t start,
-	      ptrdiff_t end, ptrdiff_t catchStart);
-
-/*
- * Finish generating exception information, and copy it to JS_malloc
- * storage.
- */
-extern JSBool
-js_FinishTakingTryNotes(JSContext *cx, JSCodeGenerator *cg, JSTryNote **tryp);
-
-JS_END_EXTERN_C
-
-#endif /* jsemit_h___ */

mozilla/js/src/jsexn.c

@@ -1,672 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS standard exception implementation.
- */
-
-#include <string.h>
-#include "jsstddef.h"
-#include "jstypes.h"
-#include "jsutil.h" /* Added by JSIFY */
-#include "jsprf.h"
-#include "jsapi.h"
-#include "jscntxt.h"
-#include "jsconfig.h"
-#include "jsexn.h"
-#include "jsfun.h"
-
-#if JS_HAS_ERROR_EXCEPTIONS
-#if !JS_HAS_EXCEPTIONS
-# error "JS_HAS_EXCEPTIONS must be defined to use JS_HAS_ERROR_EXCEPTIONS"
-#endif
-
-/* Declaration to resolve circular reference of js_ErrorClass by Exception. */
-static JSBool
-Exception(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);
-JSBool
-js_exnHasInstance(JSContext *cx, JSObject *obj, jsval v, JSBool *bp);
-
-static void
-exn_finalize(JSContext *cx, JSObject *obj);
-
-JSClass js_ErrorClass = {
-    "Exception",
-    JSCLASS_HAS_PRIVATE,
-    JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
-    JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   exn_finalize,
-    NULL,             NULL,             NULL,             Exception,
-    0,0,{0,0}
-};
-
-/*
- * A copy of the JSErrorReport originally generated.
- */
-typedef struct JSExnPrivate {
-    JSErrorReport *errorReport;
-} JSExnPrivate;
-
-/*
- * Copy everything interesting about an error into allocated memory.
- */
-static JSExnPrivate *
-exn_initPrivate(JSContext *cx, JSErrorReport *report)
-{
-    JSExnPrivate *newPrivate;
-    JSErrorReport *newReport;
-
-    newPrivate = (JSExnPrivate *)JS_malloc(cx, sizeof (JSExnPrivate));
-
-    /* Copy the error report */
-    newReport = (JSErrorReport *)JS_malloc(cx, sizeof (JSErrorReport));
-
-    if (report->filename != NULL) {
-	newReport->filename =
-	    (const char *)JS_malloc(cx, strlen(report->filename)+1);
-	strcpy((char *)newReport->filename, report->filename);
-    } else {
-	newReport->filename = NULL;
-    }
-
-    newReport->lineno = report->lineno;
-
-    /*
-     * We don't need to copy linebuf and tokenptr, because they
-     * point into the deflated string cache.  (currently?)
-     */
-    newReport->linebuf = report->linebuf;
-    newReport->tokenptr = report->tokenptr;
-
-    /*
-     * But we do need to copy uclinebuf, uctokenptr, because they're
-     * pointers into internal tokenstream structs, and may go away.
-     *
-     * NOTE nothing uses this and I'm not really maintaining it until
-     * I know it's the desired API.
-     */
-    if (report->uclinebuf != NULL) {
-	jsint len = js_strlen(report->uclinebuf) + 1;
-	newReport->uclinebuf =
-	    (const jschar *)JS_malloc(cx, len * sizeof(jschar));
-	js_strncpy((jschar *)newReport->uclinebuf, report->uclinebuf, len);
-	newReport->uctokenptr = newReport->uclinebuf + (report->uctokenptr -
-							report->uclinebuf);
-    } else
-	newReport->uclinebuf = newReport->uctokenptr = NULL;
-   
-    if (report->ucmessage != NULL) {
-        jsint len = js_strlen(report->ucmessage) + 1;
-        newReport->ucmessage = (const jschar *)JS_malloc(cx, len * sizeof(jschar));
-        js_strncpy((jschar *)newReport->ucmessage, report->ucmessage, len);
-        
-        if (report->messageArgs) {
-            intN i;
-            
-            for (i = 0; report->messageArgs[i] != NULL; i++)
-                ;
-            JS_ASSERT(i);
-            newReport->messageArgs =
-                (const jschar **)JS_malloc(cx, (i + 1) * sizeof(jschar *));
-            for (i = 0; report->messageArgs[i] != NULL; i++) {
-                len = js_strlen(report->messageArgs[i]) + 1;
-                newReport->messageArgs[i] =
-                    (const jschar *)JS_malloc(cx, len * sizeof(jschar));
-                js_strncpy((jschar *)(newReport->messageArgs[i]),
-                           report->messageArgs[i], len);
-            }
-            newReport->messageArgs[i] = NULL;
-        } else {
-            newReport->messageArgs = NULL;
-        }
-    } else {
-        newReport->ucmessage = NULL;
-        newReport->messageArgs = NULL;
-    }
-    newReport->errorNumber = report->errorNumber;
-
-    /* Note that this is before it gets flagged with JSREPORT_EXCEPTION */
-    newReport->flags = report->flags;
-
-    newPrivate->errorReport = newReport;
-    return newPrivate;
-}
-
-/*
- * Undo all the damage done by exn_initPrivate.
- */
-static void
-exn_destroyPrivate(JSContext *cx, JSExnPrivate *privateData)
-{
-    JSErrorReport *report;
-    const jschar **args;
-    
-    report = privateData->errorReport;
-    JS_ASSERT(report);
-    if (report->uclinebuf)
-	JS_free(cx, (void *)report->uclinebuf);
-    if (report->filename)
-	JS_free(cx, (void *)report->filename);
-    if (report->ucmessage)
-	JS_free(cx, (void *)report->ucmessage);
-    if (report->messageArgs) {
-        args = report->messageArgs;
-        while(*args != NULL)
-            JS_free(cx, (void *)*args++);
-        JS_free(cx, (void *)report->messageArgs);
-    }
-    JS_free(cx, report);
-    JS_free(cx, privateData);
-}
-
-static void
-exn_finalize(JSContext *cx, JSObject *obj)
-{
-    JSExnPrivate *privateData;
-    jsval private;
-
-    private = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-
-    if (private != JSVAL_NULL) {
-        privateData = JSVAL_TO_PRIVATE(private);
-        if (privateData)
-            exn_destroyPrivate(cx, privateData);
-    }
-}
-
-JSErrorReport *
-js_ErrorFromException(JSContext *cx, jsval exn)
-{
-    JSObject *obj;
-    JSExnPrivate *privateData;
-    jsval private;
-
-    if (JSVAL_IS_PRIMITIVE(exn))
-        return NULL;
-    obj = JSVAL_TO_OBJECT(exn);
-    if (OBJ_GET_CLASS(cx, obj) != &js_ErrorClass)
-        return NULL;
-    private = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-    if (private == JSVAL_NULL)
-        return NULL;
-    privateData = JSVAL_TO_PRIVATE(private);
-    if (!privateData)
-        return NULL;
-    
-    JS_ASSERT(privateData->errorReport);
-    return privateData->errorReport;
-}
-
-/* This must be kept in synch with the exceptions array below. */
-typedef enum JSExnType {
-    JSEXN_NONE = -1,
-      JSEXN_ERR,
-	JSEXN_INTERNALERR,
-	JSEXN_EVALERR,
-	JSEXN_RANGEERR,
-	JSEXN_REFERENCEERR,
-	JSEXN_SYNTAXERR,
-	JSEXN_TYPEERR,
-	JSEXN_URIERR,
-	JSEXN_LIMIT
-} JSExnType;
-
-struct JSExnSpec {
-    int protoIndex;
-    const char *name;
-};
-
-static struct JSExnSpec exceptions[] = {
-    { JSEXN_NONE,          "Error"             },
-    { JSEXN_ERR,           "InternalError"     },
-    { JSEXN_ERR,           "EvalError"         },
-    { JSEXN_ERR,           "RangeError"        },
-    { JSEXN_ERR,           "ReferenceError"    },
-    { JSEXN_ERR,           "SyntaxError"       },
-    { JSEXN_ERR,           "TypeError"         },
-    { JSEXN_ERR,           "URIError"          },
-    {0,0}
-};
-
-static JSBool
-Exception(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    JSString *message;
-
-    /*
-     * Does it make sense to throw a not-a-function-error here?
-     * A constructor that was not a function would be novel.
-     */
-    if (!cx->fp->constructing) {
-	return JS_TRUE;
-    }
-
-    /*
-     * If it's a new object of class Exception, then null out the private
-     * data so that the finalizer doesn't attempt to free it.
-     */
-    if (OBJ_GET_CLASS(cx, obj) == &js_ErrorClass)
-        OBJ_SET_SLOT(cx, obj, JSSLOT_PRIVATE, JSVAL_NULL);
-
-    /*
-     * Set the 'message' property.
-     */
-    if (argc > 0) {
-	message = js_ValueToString(cx, argv[0]);
-	if (!message)
-	    return JS_FALSE;
-    } else {
-	message = cx->runtime->emptyString;
-    }
-    return JS_DefineProperty(cx, obj, "message", STRING_TO_JSVAL(message),
-                           NULL, NULL, JSPROP_ENUMERATE);
-}
-
-/*
-*   Called by fun_hasInstance when 'obj' has js_ErrorClass, to see if
-*   'v' could be an instanceof an exception from some other context
-*   - we'll know it is if it has that special 'something'
-*/
-
-JSBool
-js_exnHasInstance(JSContext *cx, JSObject *obj, jsval v, JSBool *bp)
-{
-    JSFunction *fun;
-    JSAtom *functionName;
-    jsval pval;
-
-    JSObject *obj2;
-    *bp = JS_FALSE;
-
-    fun = (JSFunction *)JS_GetPrivate(cx, obj);
-    functionName = fun->atom;
-
-    obj2 = JSVAL_TO_OBJECT(v);
-    if (!OBJ_GET_PROPERTY(cx, obj2, (jsid)functionName, &pval))
-        return JS_FALSE;
-
-    if (JSVAL_IS_INT(pval))
-        *bp = JS_TRUE;
-
-    return JS_TRUE;
-}
-
-/*
- * Convert to string.
- *
- * This method only uses JavaScript-modifiable properties name, message; it is
- * left to the host to check for private data and report filename and line
- * number information along with this message.
- */
-static JSBool
-exn_toString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsval v;
-    JSString *name, *message, *result;
-    jschar *chars, *cp;
-    size_t length;
-    jsid id;
-
-    id = (jsid) cx->runtime->atomState.nameAtom;
-    if (!OBJ_GET_PROPERTY(cx, obj, id, &v) || !(name = js_ValueToString(cx, v)))
-        return JS_FALSE;
-
-    if (!JS_GetProperty(cx, obj, "message", &v) ||
-        !(message = js_ValueToString(cx, v)))
-        return JS_FALSE;
-
-    if (message->length > 0) {
-        length = name->length + message->length + 2;
-        cp = chars = JS_malloc(cx, (length + 1) * sizeof(jschar));
-        if (!chars)
-            return JS_FALSE;
-        
-        js_strncpy(cp, name->chars, name->length);
-        cp += name->length;
-        *cp++ = ':'; *cp++ = ' ';
-        js_strncpy(cp, message->chars, message->length);
-        cp += message->length;
-        *cp = 0;
-        
-        result = js_NewString(cx, chars, length, 0);
-        if (!result) {
-            JS_free(cx, chars);
-            return JS_FALSE;
-        }
-    } else {
-        result = name;
-    }
-
-    *rval = STRING_TO_JSVAL(result);
-    return JS_TRUE;
-}
-
-#if JS_HAS_TOSOURCE
-/*
- * Return a string that may eval to something similar to the original object.
- */
-static JSBool
-exn_toSource(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    JSString *name, *message, *result;
-    jschar *chars, *cp;
-    jsid id;
-    size_t length;
-    jsval v;
-
-    id = (jsid) cx->runtime->atomState.nameAtom;
-    if (!OBJ_GET_PROPERTY(cx, obj, id, &v) || !(name = js_ValueToString(cx, v)))
-        return JS_FALSE;
-
-    if (!JS_GetProperty(cx, obj, "message", &v) ||
-        !(message = js_ValueToString(cx, v)))
-        return JS_FALSE;
-
-    length = (message->length > 0) ? name->length + message->length + 10
-        : name->length + 8;
-
-    cp = chars = JS_malloc(cx, (length + 1) * sizeof(jschar));
-    if (!chars)
-        return JS_FALSE;
-
-    *cp++ = '('; *cp++ = 'n'; *cp++ = 'e'; *cp++ = 'w'; *cp++ = ' ';
-    js_strncpy(cp, name->chars, name->length);
-    cp += name->length;
-    *cp++ = '(';
-    if (message->length > 0) {
-        *cp++ = '"';
-        js_strncpy(cp, message->chars, message->length);
-        cp += message->length;
-        *cp++ = '"';
-    }
-    *cp++ = ')'; *cp++ = ')'; *cp = 0;
-
-    result = js_NewString(cx, chars, length, 0);
-    if (!result) {
-        JS_free(cx, chars);
-        return JS_FALSE;
-    }
-
-    *rval = STRING_TO_JSVAL(result);
-    return JS_TRUE;
-}
-#endif
-
-static JSFunctionSpec exception_methods[] = {
-#if JS_HAS_TOSOURCE
-    {js_toSource_str,   exn_toSource,           0,0,0},
-#endif
-    {js_toString_str,   exn_toString,           0,0,0},
-    {0,0,0,0,0}
-};
-
-JSObject *
-js_InitExceptionClasses(JSContext *cx, JSObject *obj)
-{
-    int i;
-    JSObject *protos[JSEXN_LIMIT];
-
-    /* Initialize the prototypes first. */
-    for (i = 0; exceptions[i].name != 0; i++) {
-        JSAtom *atom;
-        JSFunction *fun;
-        JSString *nameString;
-        int protoidx = exceptions[i].protoIndex;
-        
-        /* Make the prototype for the current constructor name. */
-        protos[i] = js_NewObject(cx, &js_ErrorClass,
-                                 protoidx >= 0 ? protos[protoidx] : NULL,
-                                 obj);
-        if (!protos[i])
-            return NULL;
-
-        atom = js_Atomize(cx, exceptions[i].name, strlen(exceptions[i].name), 0);
-
-        /*
-            Now add a property to this prototype that can be used to 
-            identify these kind of exceptions across multiple contexts.
-            This is a little less than satisfying, since other proto
-            chains may include objects with the same property but it'll
-            pass for now.
-        */
-        if (!JS_DefineProperty(cx, protos[i], exceptions[i].name,
-                               INT_TO_JSVAL(i),
-                               NULL, NULL,
-                               JSPROP_READONLY | JSPROP_PERMANENT))
-            return NULL;
-
-
-        /* Make a constructor function for the current name. */
-        fun = js_DefineFunction(cx, obj, atom, Exception, 1, 0);
-        if (!fun)
-            return NULL; /* XXX also remove named property from obj... */
-
-        /* Make this constructor make objects of class Exception. */
-        fun->clasp = &js_ErrorClass;
-
-        /* Make the prototype and constructor links. */
-        if (!js_SetClassPrototype(cx, fun->object, 
-                              protos[i],
-                              JSPROP_READONLY | JSPROP_PERMANENT))
-            return NULL;
-
-        /* proto bootstrap bit from JS_InitClass omitted. */
-        nameString = JS_NewStringCopyZ(cx, exceptions[i].name);
-        if (nameString == NULL)
-            return NULL;
-        
-        /* Add the name property to the prototype. */
-        if (!JS_DefineProperty(cx, protos[i], js_name_str,
-                               STRING_TO_JSVAL(nameString),
-                               NULL, NULL,
-                               JSPROP_ENUMERATE)) {
-            /* release it? */
-            return NULL;
-        }   
-        
-        /* So finalize knows whether to. */
-        OBJ_SET_SLOT(cx, protos[i], JSSLOT_PRIVATE, JSVAL_NULL);
-    }
-    
-    /*
-     * Add an empty message property.  (To Exception.prototype only,
-     * because this property will be the same for all the exception
-     * protos.)
-     */
-    if (!JS_DefineProperty(cx, protos[0], "message",
-                           STRING_TO_JSVAL(cx->runtime->emptyString),
-                           NULL, NULL, JSPROP_ENUMERATE))
-        return NULL;
-    
-    /*
-     * Add methods only to Exception.prototype, because ostensibly all
-     * exception types delegate to that.
-     */
-    if (!JS_DefineFunctions(cx, protos[0], exception_methods))
-        return NULL;
-
-    return protos[0];
-}
-
-static JSExnType errorToExceptionNum[] = {
-#define MSG_DEF(name, number, count, exception, format) \
-    exception,
-#include "js.msg"
-#undef MSG_DEF
-};
-
-#if defined ( DEBUG_mccabe ) && defined ( PRINTNAMES )
-/* For use below... get character strings for error name and exception name */
-static struct exnname { char *name; char *exception; } errortoexnname[] = {
-#define MSG_DEF(name, number, count, exception, format) \
-    {#name, #exception},
-#include "js.msg"
-#undef MSG_DEF
-};
-#endif /* DEBUG */
-
-JSBool
-js_ErrorToException(JSContext *cx, const char *message, JSErrorReport *reportp)
-{
-    JSErrNum errorNumber;
-    JSObject *errObject, *errProto;
-    JSExnType exn;
-    JSExnPrivate *privateData;
-    JSString *msgstr;
-
-    /* Find the exception index associated with this error. */
-    JS_ASSERT(reportp);
-    if (JSREPORT_IS_WARNING(reportp->flags))
-        return JS_FALSE;
-    errorNumber = reportp->errorNumber;
-    exn = errorToExceptionNum[errorNumber];
-    JS_ASSERT(exn < JSEXN_LIMIT);
-
-#if defined( DEBUG_mccabe ) && defined ( PRINTNAMES )
-    /* Print the error name and the associated exception name to stderr */
-    fprintf(stderr, "%s\t%s\n",
-	    errortoexnname[errorNumber].name,
-	    errortoexnname[errorNumber].exception);
-#endif
-
-    /*
-     * Return false (no exception raised) if no exception is associated
-     * with the given error number.
-     */
-    if (exn == JSEXN_NONE)
-	return JS_FALSE;
-
-    /*
-     * Try to get an appropriate prototype by looking up the corresponding
-     * exception constructor name in the current context.  If the constructor
-     * has been deleted or overwritten, this may fail or return NULL, and
-     * js_NewObject will fall back to using Object.prototype.
-     */
-    if (!js_GetClassPrototype(cx, exceptions[exn].name, &errProto))
-        errProto = NULL;
-
-    /*
-     * Use js_NewObject instead of js_ConstructObject, because
-     * js_ConstructObject seems to require a frame.
-     */
-    errObject = js_NewObject(cx, &js_ErrorClass, errProto, NULL);
-
-    /* Store 'message' as a javascript-visible value. */
-    msgstr = JS_NewStringCopyZ(cx, message);
-    if (!JS_DefineProperty(cx, errObject, "message", STRING_TO_JSVAL(msgstr),
-                           NULL, NULL,
-                           JSPROP_ENUMERATE))
-        return JS_FALSE;
-
-    /*
-     * Construct a new copy of the error report, and store it in the
-     * exception objects' private data.  We can't use the error report
-     * handed in, because it's stack-allocated, and may point to transient
-     * data in the JSTokenStream.
-     */
-    privateData = exn_initPrivate(cx, reportp);
-    OBJ_SET_SLOT(cx, errObject, JSSLOT_PRIVATE, PRIVATE_TO_JSVAL(privateData));
-
-    /* Set the generated Exception object as the current exception. */
-    JS_SetPendingException(cx, OBJECT_TO_JSVAL(errObject));
-
-    /* Flag the error report passed in to indicate an exception was raised. */
-    reportp->flags |= JSREPORT_EXCEPTION;
-
-    return JS_TRUE;
-}
-#endif /* JS_HAS_ERROR_EXCEPTIONS */
-
-#if JS_HAS_EXCEPTIONS
-
-extern JSBool
-js_ReportUncaughtException(JSContext *cx)
-{
-    JSObject *exnObject;
-    JSString *str;
-    jsval exn;
-    JSErrorReport *reportp;
-    const char *bytes;
-
-    if (!JS_IsExceptionPending(cx))
-        return JS_FALSE;
-    
-    if (!JS_GetPendingException(cx, &exn))
-        return JS_FALSE;
-
-    /*
-     * Because js_ValueToString below could error and an exception object
-     * could become unrooted, we root it here.
-     */
-    if (JSVAL_IS_OBJECT(exn) && exn != JSVAL_NULL) {
-        exnObject = JSVAL_TO_OBJECT(exn);
-        if (!js_AddRoot(cx, &exnObject, "exn.report.root"))
-            return JS_FALSE;
-    } else {
-        exnObject = NULL;
-    }
-    str = js_ValueToString(cx, exn);
-
-#if JS_HAS_ERROR_EXCEPTIONS
-    reportp = js_ErrorFromException(cx, exn);
-#else
-    reportp = NULL;
-#endif
-
-    if (str != NULL) {
-	bytes = js_GetStringBytes(str);
-    }
-    else {
-	bytes = "null";
-    }
-
-    if (reportp == NULL) {
-        /*
-         * XXXmccabe todo: Instead of doing this, synthesize an error report
-         * struct that includes the filename, lineno where the exception was
-         * originally thrown.
-         */
-        JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
-                             JSMSG_UNCAUGHT_EXCEPTION, bytes);
-    } else {
-        /* Flag the error as an exception. */
-        reportp->flags |= JSREPORT_EXCEPTION;
-        js_ReportErrorAgain(cx, bytes, reportp);
-    }
-
-    if (exnObject != NULL)
-        js_RemoveRoot(cx->runtime, &exnObject);
-    return JS_TRUE;
-}
-
-#endif	    /* JS_HAS_EXCEPTIONS */

mozilla/js/src/jsexn.h

@@ -1,89 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS runtime exception classes.
- */
-
-#ifndef jsexn_h___
-#define jsexn_h___
-
-JS_BEGIN_EXTERN_C
-
-/*
- * Initialize exception object hierarchy.
- */
-extern JSObject *
-js_InitExceptionClasses(JSContext *cx, JSObject *obj);
-
-/*
- * Given a JSErrorReport, check to see if there is an exception associated with
- * the error number.  If there is, then create an appropriate exception object,
- * set it as the pending exception, and set the JSREPORT_EXCEPTION flag on the
- * error report.  Exception-aware host error reporters should probably ignore
- * error reports so flagged.  Returns JS_TRUE if an associated exception is
- * found and set, JS_FALSE otherwise..
- */
-extern JSBool
-js_ErrorToException(JSContext *cx, const char *message, JSErrorReport *reportp);
-
-/*
- * Called if a JS API call to js_Execute or js_InternalCall fails; calls the
- * error reporter with the error report associated with any uncaught exception
- * that has been raised.  Returns true if there was an exception pending, and
- * the error reporter was actually called.
- *
- * The JSErrorReport * that the error reporter is called with is currently
- * associated with a JavaScript object, and is not guaranteed to persist after
- * the object is collected.  Any persistent uses of the JSErrorReport contents
- * should make their own copy.
- *
- * The flags field of the JSErrorReport will have the JSREPORT_EXCEPTION flag
- * set; embeddings that want to silently propagate JavaScript exceptions to
- * other contexts may want to use an error reporter that ignores errors with
- * this flag.
- */
-extern JSBool
-js_ReportUncaughtException(JSContext *cx);
-
-extern JS_FRIEND_DATA(JSClass) js_ErrorClass;
-extern JSBool
-js_exnHasInstance(JSContext *cx, JSObject *obj, jsval v, JSBool *bp);
-
-extern JSErrorReport *
-js_ErrorFromException(JSContext *cx, jsval exn);
-
-JS_END_EXTERN_C
-
-#endif /* jsexn_h___ */

mozilla/js/src/jsfile.h

@@ -1,45 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef _jsfile_h__
-#define _jsfile_h__
-
-#if JS_HAS_FILE_OBJECT
-extern JS_PUBLIC_API(JSObject*)
-js_InitFileClass(JSContext *cx, JSObject* obj, JSBool initStandardStreams);
-
-extern JS_PUBLIC_API(JSObject*)
-js_NewFileObject(JSContext *cx, char *bytes);
-#endif /* JS_HAS_FILE_OBJECT */
-#endif /* _jsfile_h__ */

mozilla/js/src/jsfile.msg

@@ -1,84 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
-        Error messages for jsfile.c. See js.msg for format specification.
-*/
-
-MSG_DEF(JSFILEMSG_NOT_AN_ERROR,                                    0, 0, JSEXN_NONE, "<Error #0 is reserved>")
-MSG_DEF(JSFILEMSG_FILE_CONSTRUCTOR_UNDEFINED_ERROR,                1, 0, JSEXN_NONE, "File constructor is undefined")
-MSG_DEF(JSFILEMSG_FILE_CURRENTDIR_UNDEFINED_ERROR,                 2, 0, JSEXN_NONE, "File.currentDir is undefined")
-MSG_DEF(JSFILEMSG_FIRST_ARGUMENT_OPEN_NOT_STRING_ERROR,            3, 1, JSEXN_NONE, "The first argument {0} to file.open must be a string")
-MSG_DEF(JSFILEMSG_SECOND_ARGUMENT_OPEN_NOT_STRING_ERROR,           4, 0, JSEXN_NONE, "The second argument to file.open must be a string")
-MSG_DEF(JSFILEMSG_CANNOT_COPY_FILE_OPEN_FOR_WRITING_ERROR,         5, 1, JSEXN_NONE, "Cannot copy file {0} open for writing")
-MSG_DEF(JSFILEMSG_CANNOT_ACCESS_FILE_INFO_ERROR,                   6, 1, JSEXN_NONE, "Cannot access file information for {0}")
-MSG_DEF(JSFILEMSG_COPY_READ_ERROR,                                 7, 1, JSEXN_NONE, "An error occured while attempting to read a file {0} to copy")
-MSG_DEF(JSFILEMSG_COPY_WRITE_ERROR,                                8, 1, JSEXN_NONE, "An error occured while attempting to copy into file {0}")
-MSG_DEF(JSFILEMSG_EXPECTS_ONE_ARG_ERROR,                           9, 0, JSEXN_NONE, "Operation {0} expects one argument, not {1}")
-MSG_DEF(JSFILEMSG_CANNOT_FLUSH_CLOSE_FILE_ERROR,                  10, 1, JSEXN_NONE, "Cannot flush closed file {0}")
-MSG_DEF(JSFILEMSG_CANNOT_OPEN_WRITING_ERROR,                      11, 1, JSEXN_NONE, "Cannot open file {0} for writing")
-MSG_DEF(JSFILEMSG_WRITEALL_EXPECTS_ONE_ARG_ERROR,                 12, 0, JSEXN_NONE, "writeAll expects one argument")
-MSG_DEF(JSFILEMSG_FIRST_ARGUMENT_WRITEALL_NOT_ARRAY_ERROR,        13, 0, JSEXN_NONE, "writeAll expects an array as an argument")
-MSG_DEF(JSFILEMSG_CANNOT_OPEN_FILE_ERROR,                         15, 1, JSEXN_NONE, "Cannot open file {0}")
-MSG_DEF(JSFILEMSG_FIRST_ARGUMENT_CONSTRUCTOR_NOT_STRING_ERROR,    16, 1, JSEXN_NONE, "The argument to the File constructor {0} must be a string")
-MSG_DEF(JSFILEMSG_BIDIRECTIONAL_PIPE_NOT_SUPPORTED,               17, 0, JSEXN_NONE, "Bidirectional pipes are not supported")
-MSG_DEF(JSFILEMSG_OPEN_MODE_NOT_SUPPORTED_WITH_PIPES,             18, 2, JSEXN_NONE, "The opening mode you have chosen {0} is not supported by the pipe you are trying to open: {1}")
-MSG_DEF(JSFILEMSG_OPEN_FAILED,                                    19, 1, JSEXN_NONE, "open on file {0} failed")
-MSG_DEF(JSFILEMSG_CLOSE_FAILED,                                   20, 1, JSEXN_NONE, "close on file {0} failed")
-MSG_DEF(JSFILEMSG_PCLOSE_FAILED,                                  21, 1, JSEXN_NONE, "pclose on file {0} failed")
-MSG_DEF(JSFILEMSG_REMOVE_FAILED,                                  22, 1, JSEXN_NONE, "remove on file {0} failed")
-MSG_DEF(JSFILEMSG_CANNOT_ACCESS_FILE_STATUS,                      23, 1, JSEXN_NONE, "Cannot access file status for {0}")
-MSG_DEF(JSFILEMSG_RENAME_FAILED,                                  24, 2, JSEXN_NONE, "Cannot rename {0} to {1}")
-MSG_DEF(JSFILEMSG_WRITE_FAILED,                                   25, 1, JSEXN_NONE, "Write failed on file {0}")
-MSG_DEF(JSFILEMSG_READ_FAILED,                                    26, 1, JSEXN_NONE, "Read failed on file {0}")
-MSG_DEF(JSFILEMSG_SKIP_FAILED,                                    27, 1, JSEXN_NONE, "Skip failed on file {0}")
-MSG_DEF(JSFILEMSG_FIRST_ARGUMENT_MUST_BE_A_FUNCTION_OR_REGEX,     28, 1, JSEXN_NONE, "The first argument to file.list must be a function or a regex")
-MSG_DEF(JSFILEMSG_CANNOT_DO_LIST_ON_A_FILE,                       29, 1, JSEXN_NONE, "{0} must be a directory, cannot do list")
-MSG_DEF(JSFILEMSG_NATIVE_OPERATION_IS_NOT_SUPPORTED,              30, 2, JSEXN_NONE, "Native operation {0} is not supported on {1}")
-MSG_DEF(JSFILEMSG_CANNOT_SET_PRIVATE_FILE,                        31, 1, JSEXN_NONE, "Cannot set private data for file {0}")
-MSG_DEF(JSFILEMSG_FIRST_ARGUMENT_MUST_BE_A_NUMBER,                32, 2, JSEXN_NONE, "First argument to {0} must be a number, not {1}")
-MSG_DEF(JSFILEMSG_CANNOT_WRITE,                                   33, 1, JSEXN_NONE, "Cannot write to {0}, file mode is different")
-MSG_DEF(JSFILEMSG_CANNOT_READ,                                    34, 1, JSEXN_NONE, "Cannot read from {0}, file mode is different")
-MSG_DEF(JSFILEMSG_CANNOT_FLUSH,                                   35, 1, JSEXN_NONE, "Flush failed on {0}")
-MSG_DEF(JSFILEMSG_OP_FAILED,									  36, 1, JSEXN_NONE, "File operation {0} failed")
-MSG_DEF(JSFILEMSG_FILE_MUST_BE_OPEN,							  37, 1, JSEXN_NONE, "File must be open for {0}")
-MSG_DEF(JSFILEMSG_FILE_MUST_BE_CLOSED,							  38, 1, JSEXN_NONE, "File must be closed for {0}")
-MSG_DEF(JSFILEMSG_NO_RANDOM_ACCESS,								  39, 1, JSEXN_NONE, "File {0} doesn't allow random access")
-MSG_DEF(JSFILEMSG_OBJECT_CREATION_FAILED,						  40, 1, JSEXN_NONE, "Couldn't create {0}")
-MSG_DEF(JSFILEMSG_CANNOT_OPEN_DIR,								  41, 1, JSEXN_NONE, "Couldn't open directory {0}")
-MSG_DEF(JSFILEMSG_CANNOT_REPORT_POSITION,						  42, 1, JSEXN_NONE, "Couldn't report position for {0}")
-MSG_DEF(JSFILEMSG_CANNOT_SET_POSITION,							  43, 1, JSEXN_NONE, "Couldn't set position for {0}")
-MSG_DEF(JSFILEMSG_INIT_FAILED,									  44, 0, JSEXN_NONE, "File class initialization failed")
-
-

mozilla/js/src/jsfun.h

@@ -1,127 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsfun_h___
-#define jsfun_h___
-/*
- * JS function definitions.
- */
-#include "jsprvtd.h"
-#include "jspubtd.h"
-
-JS_BEGIN_EXTERN_C
-
-struct JSFunction {
-    jsrefcount	 nrefs;		/* number of referencing objects */
-    JSObject     *object;       /* back-pointer to GC'ed object header */
-    JSNative     call;          /* native method pointer or null */
-    uint16       nargs;         /* minimum number of actual arguments */
-    uint16       extra;         /* number of arg slots for local GC roots */
-    uint16       nvars;         /* number of local variables */
-    uint8        flags;         /* bound method and other flags, see jsapi.h */
-    uint8        spare;         /* reserved for future use */
-    JSAtom       *atom;         /* name for diagnostics and decompiling */
-    JSScript     *script;       /* interpreted bytecode descriptor or null */
-    JSClass      *clasp;        /* this function is a constructor for objects 
-                                 * of this class */
-};
-
-extern JSClass js_ArgumentsClass;
-extern JSClass js_CallClass;
-
-/* JS_FRIEND_DATA so that JSVAL_IS_FUNCTION is callable from outside */
-extern JS_FRIEND_DATA(JSClass) js_FunctionClass;
-
-/*
- * NB: jsapi.h and jsobj.h must be included before any call to this macro.
- */
-#define JSVAL_IS_FUNCTION(cx, v)                                              \
-    (JSVAL_IS_OBJECT(v) && JSVAL_TO_OBJECT(v) &&                              \
-     OBJ_GET_CLASS(cx, JSVAL_TO_OBJECT(v)) == &js_FunctionClass)
-
-extern JSBool
-js_IsIdentifier(JSString *str);
-
-extern JSObject *
-js_InitFunctionClass(JSContext *cx, JSObject *obj);
-
-extern JSBool
-js_InitArgsAndCallClasses(JSContext *cx, JSObject *obj,
-			      JSObject *objProto);
-
-extern JSFunction *
-js_NewFunction(JSContext *cx, JSObject *funobj, JSNative call, uintN nargs,
-	       uintN flags, JSObject *parent, JSAtom *atom);
-
-extern JSObject *
-js_CloneFunctionObject(JSContext *cx, JSObject *funobj, JSObject *parent);
-
-extern JSBool
-js_LinkFunctionObject(JSContext *cx, JSFunction *fun, JSObject *object);
-
-extern JSFunction *
-js_DefineFunction(JSContext *cx, JSObject *obj, JSAtom *atom, JSNative call,
-		  uintN nargs, uintN flags);
-
-extern JSFunction *
-js_ValueToFunction(JSContext *cx, jsval *vp, JSBool constructing);
-
-extern void
-js_ReportIsNotFunction(JSContext *cx, jsval *vp, JSBool constructing);
-
-extern JSObject *
-js_GetCallObject(JSContext *cx, JSStackFrame *fp, JSObject *parent,
-		 JSObject *withobj);
-
-extern JSBool
-js_PutCallObject(JSContext *cx, JSStackFrame *fp);
-
-extern JSBool
-js_GetCallVariable(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
-
-extern JSBool
-js_SetCallVariable(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
-
-extern JSObject *
-js_GetArgsObject(JSContext *cx, JSStackFrame *fp);
-
-extern JSBool
-js_PutArgsObject(JSContext *cx, JSStackFrame *fp);
-
-extern JSBool
-js_XDRFunction(JSXDRState *xdr, JSObject **objp);
-
-JS_END_EXTERN_C
-
-#endif /* jsfun_h___ */

mozilla/js/src/jsgc.c

@@ -1,981 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS Mark-and-Sweep Garbage Collector.
- *
- * This GC allocates only fixed-sized things big enough to contain two words
- * (pointers) on any host architecture.  It allocates from an arena pool (see
- * jsarena.h).  It uses a parallel arena-pool array of flag bytes to hold the
- * mark bit, finalizer type index, etc.
- *
- * XXX swizzle page to freelist for better locality of reference
- */
-#include "jsstddef.h"
-#include <stdlib.h>     /* for free, called by JS_ARENA_DESTROY */
-#include <string.h>	/* for memset, called by jsarena.h macros if DEBUG */
-#include "jstypes.h"
-#include "jsarena.h" /* Added by JSIFY */
-#include "jsutil.h" /* Added by JSIFY */
-#include "jshash.h" /* Added by JSIFY */
-#include "jsapi.h"
-#include "jsatom.h"
-#include "jscntxt.h"
-#include "jsconfig.h"
-#include "jsfun.h"
-#include "jsgc.h"
-#include "jsinterp.h"
-#include "jslock.h"
-#include "jsnum.h"
-#include "jsobj.h"
-#include "jsscope.h"
-#include "jsscript.h"
-#include "jsstr.h"
-
-/*
- * Arena sizes, the first must be a multiple of the second so the two arena
- * pools can be maintained (in particular, arenas may be destroyed from the
- * middle of each pool) in parallel.
- */
-#define GC_ARENA_SIZE	8192		/* 1024 (512 on Alpha) objects */
-#define GC_FLAGS_SIZE	(GC_ARENA_SIZE / sizeof(JSGCThing))
-#define GC_ROOTS_SIZE	256		/* SWAG, small enough to amortize */
-
-static JSHashNumber   gc_hash_root(const void *key);
-
-struct JSGCThing {
-    JSGCThing       *next;
-    uint8           *flagp;
-};
-
-typedef void (*GCFinalizeOp)(JSContext *cx, JSGCThing *thing);
-
-static GCFinalizeOp gc_finalizers[GCX_NTYPES];
-
-#ifdef JS_GCMETER
-#define METER(x) x
-#else
-#define METER(x) /* nothing */
-#endif
-
-JSBool
-js_InitGC(JSRuntime *rt, uint32 maxbytes)
-{
-    if (!gc_finalizers[GCX_OBJECT]) {
-	gc_finalizers[GCX_OBJECT] = (GCFinalizeOp)js_FinalizeObject;
-	gc_finalizers[GCX_STRING] = (GCFinalizeOp)js_FinalizeString;
-	gc_finalizers[GCX_DOUBLE] = (GCFinalizeOp)js_FinalizeDouble;
-    }
-
-    JS_InitArenaPool(&rt->gcArenaPool, "gc-arena", GC_ARENA_SIZE,
-		     sizeof(JSGCThing));
-    JS_InitArenaPool(&rt->gcFlagsPool, "gc-flags", GC_FLAGS_SIZE,
-		     sizeof(uint8));
-    rt->gcRootsHash = JS_NewHashTable(GC_ROOTS_SIZE, gc_hash_root,
-				      JS_CompareValues, JS_CompareValues,
-				      NULL, NULL);
-    if (!rt->gcRootsHash)
-	return JS_FALSE;
-    rt->gcMaxBytes = maxbytes;
-    return JS_TRUE;
-}
-
-#ifdef JS_GCMETER
-void
-js_DumpGCStats(JSRuntime *rt, FILE *fp)
-{
-    fprintf(fp, "\nGC allocation statistics:\n");
-    fprintf(fp, "     bytes currently allocated: %lu\n", rt->gcBytes);
-    fprintf(fp, "                alloc attempts: %lu\n", rt->gcStats.alloc);
-    fprintf(fp, "            GC freelist length: %lu\n", rt->gcStats.freelen);
-    fprintf(fp, "  recycles through GC freelist: %lu\n", rt->gcStats.recycle);
-    fprintf(fp, "alloc retries after running GC: %lu\n", rt->gcStats.retry);
-    fprintf(fp, "           allocation failures: %lu\n", rt->gcStats.fail);
-    fprintf(fp, "              valid lock calls: %lu\n", rt->gcStats.lock);
-    fprintf(fp, "            valid unlock calls: %lu\n", rt->gcStats.unlock);
-    fprintf(fp, "   locks that hit stuck counts: %lu\n", rt->gcStats.stuck);
-    fprintf(fp, " unlocks that saw stuck counts: %lu\n", rt->gcStats.unstuck);
-    fprintf(fp, "          mark recursion depth: %lu\n", rt->gcStats.depth);
-    fprintf(fp, "  maximum mark recursion depth: %lu\n", rt->gcStats.maxdepth);
-    fprintf(fp, "      maximum GC nesting level: %lu\n", rt->gcStats.maxlevel);
-    fprintf(fp, "   potentially useful GC calls: %lu\n", rt->gcStats.poke);
-    fprintf(fp, "              useless GC calls: %lu\n", rt->gcStats.nopoke);
-    fprintf(fp, "        thing arena corruption: %lu\n", rt->gcStats.badarena);
-    fprintf(fp, "        flags arena corruption: %lu\n", rt->gcStats.badflag);
-    fprintf(fp, "     thing arenas freed so far: %lu\n", rt->gcStats.afree);
-    fprintf(fp, "     flags arenas freed so far: %lu\n", rt->gcStats.fafree);
-#ifdef JS_ARENAMETER
-    JS_DumpArenaStats(fp);
-#endif
-}
-#endif
-
-void
-js_FinishGC(JSRuntime *rt)
-{
-#ifdef JS_ARENAMETER
-    JS_DumpArenaStats(stdout);
-#endif
-#ifdef JS_GCMETER
-    js_DumpGCStats(rt, stdout);
-#endif
-    JS_FinishArenaPool(&rt->gcArenaPool);
-    JS_FinishArenaPool(&rt->gcFlagsPool);
-    JS_ArenaFinish();
-    JS_HashTableDestroy(rt->gcRootsHash);
-    rt->gcRootsHash = NULL;
-    rt->gcFreeList = NULL;
-}
-
-JSBool
-js_AddRoot(JSContext *cx, void *rp, const char *name)
-{
-    JSRuntime *rt;
-    JSBool ok;
-
-    rt = cx->runtime;
-    JS_LOCK_GC_VOID(rt,
-	ok = (JS_HashTableAdd(rt->gcRootsHash, rp, (void *)name) != NULL));
-    if (!ok)
-	JS_ReportOutOfMemory(cx);
-    return ok;
-}
-
-JSBool
-js_RemoveRoot(JSRuntime *rt, void *rp)
-{
-    JS_LOCK_GC_VOID(rt, JS_HashTableRemove(rt->gcRootsHash, rp));
-    return JS_TRUE;
-}
-
-void *
-js_AllocGCThing(JSContext *cx, uintN flags)
-{
-    JSRuntime *rt;
-    JSGCThing *thing;
-    uint8 *flagp = NULL;
-#ifdef TOO_MUCH_GC
-    JSBool tried_gc = JS_TRUE;
-    js_GC(cx);
-#else
-    JSBool tried_gc = JS_FALSE;
-#endif
-
-#ifdef NES40
-/* Fix for GC bug - previous allocation of a new atom has
-not yet found a home, so a subsequent call to GC here will
-flush that atom. This 'hack' prevents that from happening
-by requiring that the heap grow rather than running a GC. 
-The concern is that enough GC's will not occur then, since
-we're counting on back-branches and force_GC's from the 
-server.
-*/
-	tried_gc = JS_TRUE;
-#endif  /* NES40 */
-
-    rt = cx->runtime;
-    JS_LOCK_GC(rt);
-    METER(rt->gcStats.alloc++);
-retry:
-    thing = rt->gcFreeList;
-    if (thing) {
-	rt->gcFreeList = thing->next;
-	flagp = thing->flagp;
-	METER(rt->gcStats.freelen--);
-	METER(rt->gcStats.recycle++);
-    } else {
-	if (rt->gcBytes < rt->gcMaxBytes &&
-            (tried_gc || rt->gcMallocBytes < rt->gcMaxBytes))
-        {
-	    JS_ARENA_ALLOCATE(thing, &rt->gcArenaPool, sizeof(JSGCThing));
-	    JS_ARENA_ALLOCATE(flagp, &rt->gcFlagsPool, sizeof(uint8));
-	}
-	if (!thing || !flagp) {
-	    if (thing)
-		JS_ARENA_RELEASE(&rt->gcArenaPool, thing);
-	    if (!tried_gc) {
-		JS_UNLOCK_GC(rt);
-		js_GC(cx);
-		tried_gc = JS_TRUE;
-		JS_LOCK_GC(rt);
-		METER(rt->gcStats.retry++);
-		goto retry;
-	    }
-	    METER(rt->gcStats.fail++);
-	    JS_UNLOCK_GC(rt);
-	    JS_ReportOutOfMemory(cx);
-	    return NULL;
-	}
-    }
-    *flagp = (uint8)flags;
-    rt->gcBytes += sizeof(JSGCThing) + sizeof(uint8);
-    cx->newborn[flags & GCF_TYPEMASK] = thing;
-
-    /*
-     * Clear thing before unlocking in case a GC run is about to scan it,
-     * finding it via cx->newborn[].
-     */
-    thing->next = NULL;
-    thing->flagp = NULL;
-    JS_UNLOCK_GC(rt);
-    return thing;
-}
-
-static uint8 *
-gc_find_flags(JSRuntime *rt, void *thing)
-{
-    jsuword index, offset, length;
-    JSArena *a, *fa;
-
-    index = 0;
-    for (a = rt->gcArenaPool.first.next; a; a = a->next) {
-	offset = JS_UPTRDIFF(thing, a->base);
-	length = a->avail - a->base;
-	if (offset < length) {
-	    index += offset / sizeof(JSGCThing);
-	    for (fa = rt->gcFlagsPool.first.next; fa; fa = fa->next) {
-		offset = fa->avail - fa->base;
-		if (index < offset)
-		    return (uint8 *)fa->base + index;
-		index -= offset;
-	    }
-	    return NULL;
-	}
-	index += length / sizeof(JSGCThing);
-    }
-    return NULL;
-}
-
-JSBool
-js_LockGCThing(JSContext *cx, void *thing)
-{
-    uint8 *flagp, flags;
-
-    if (!thing)
-	return JS_TRUE;
-    flagp = gc_find_flags(cx->runtime, thing);
-    if (!flagp)
-	return JS_FALSE;
-    flags = *flagp;
-    if ((flags & GCF_LOCKMASK) != GCF_LOCKMASK) {
-	*flagp = (uint8)(flags + GCF_LOCK);
-    } else {
-	METER(cx->runtime->gcStats.stuck++);
-    }
-    METER(cx->runtime->gcStats.lock++);
-    return JS_TRUE;
-}
-
-JSBool
-js_UnlockGCThing(JSContext *cx, void *thing)
-{
-    uint8 *flagp, flags;
-
-    if (!thing)
-	return JS_TRUE;
-    flagp = gc_find_flags(cx->runtime, thing);
-    if (!flagp)
-	return JS_FALSE;
-    flags = *flagp;
-    if ((flags & GCF_LOCKMASK) != GCF_LOCKMASK) {
-	*flagp = (uint8)(flags - GCF_LOCK);
-    } else {
-	METER(cx->runtime->gcStats.unstuck++);
-    }
-    METER(cx->runtime->gcStats.unlock++);
-    return JS_TRUE;
-}
-
-#ifdef GC_MARK_DEBUG
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "jsprf.h"
-
-JS_FRIEND_DATA(FILE *) js_DumpGCHeap;
-JS_FRIEND_DATA(void *) js_LiveThingToFind;
-
-typedef struct GCMarkNode GCMarkNode;
-
-struct GCMarkNode {
-    void        *thing;
-    char        *name;
-    GCMarkNode  *next;
-    GCMarkNode  *prev;
-};
-
-static void
-gc_dump_thing(JSGCThing *thing, uint8 flags, GCMarkNode *prev, FILE *fp)
-{
-    GCMarkNode *next = NULL;
-    char *path = NULL;
-    JSObject *obj;
-    JSClass *clasp;
-
-    while (prev) {
-	next = prev;
-	prev = prev->prev;
-    }
-    while (next) {
-	path = JS_sprintf_append(path, "%s.", next->name);
-	next = next->next;
-    }
-    if (!path)
-	return;
-
-    fprintf(fp, "%08lx ", (long)thing);
-    switch (flags & GCF_TYPEMASK) {
-      case GCX_OBJECT:
-	obj = (JSObject *)thing;
-	clasp = JSVAL_TO_PRIVATE(obj->slots[JSSLOT_CLASS]);
-	fprintf(fp, "object %s", clasp->name);
-	break;
-      case GCX_STRING:
-	fprintf(fp, "string %s", JS_GetStringBytes((JSString *)thing));
-	break;
-      case GCX_DOUBLE:
-	fprintf(fp, "double %g", *(jsdouble *)thing);
-	break;
-      case GCX_DECIMAL:
-	break;
-    }
-    fprintf(fp, " via %s\n", path);
-    free(path);
-}
-
-static void
-gc_mark_node(JSRuntime *rt, void *thing, GCMarkNode *prev);
-
-#define GC_MARK(_rt, _thing, _name, _prev)                                    \
-    JS_BEGIN_MACRO                                                            \
-	GCMarkNode _node;                                                     \
-	_node.thing = _thing;                                                 \
-	_node.name  = _name;                                                  \
-	_node.next  = NULL;                                                   \
-	_node.prev  = _prev;                                                  \
-	if (_prev) ((GCMarkNode *)(_prev))->next = &_node;                    \
-	gc_mark_node(_rt, _thing, &_node);                                    \
-    JS_END_MACRO
-
-static void
-gc_mark(JSRuntime *rt, void *thing)
-{
-    GC_MARK(rt, thing, "atom", NULL);
-}
-
-#define GC_MARK_ATOM(rt, atom, prev)     gc_mark_atom(rt, atom, prev)
-#define GC_MARK_SCRIPT(rt, script, prev) gc_mark_script(rt, script, prev)
-
-#else  /* !GC_MARK_DEBUG */
-
-#define GC_MARK(rt, thing, name, prev)   gc_mark(rt, thing)
-#define GC_MARK_ATOM(rt, atom, prev)     gc_mark_atom(rt, atom)
-#define GC_MARK_SCRIPT(rt, script, prev) gc_mark_script(rt, script)
-
-static void
-gc_mark(JSRuntime *rt, void *thing);
-
-#endif /* !GC_MARK_DEBUG */
-
-static void
-gc_mark_atom(JSRuntime *rt, JSAtom *atom
-#ifdef GC_MARK_DEBUG
-  , GCMarkNode *prev
-#endif
-)
-{
-    jsval key;
-
-    if (!atom || atom->flags & ATOM_MARK)
-	return;
-    atom->flags |= ATOM_MARK;
-    key = ATOM_KEY(atom);
-    if (JSVAL_IS_GCTHING(key)) {
-#ifdef GC_MARK_DEBUG
-	char name[32];
-
-	if (JSVAL_IS_STRING(key)) {
-	    JS_snprintf(name, sizeof name, "'%s'",
-			JS_GetStringBytes(JSVAL_TO_STRING(key)));
-	} else {
-	    JS_snprintf(name, sizeof name, "<%x>", key);
-	}
-#endif
-	GC_MARK(rt, JSVAL_TO_GCTHING(key), name, prev);
-    }
-}
-
-static void
-gc_mark_script(JSRuntime *rt, JSScript *script
-#ifdef GC_MARK_DEBUG
-  , GCMarkNode *prev
-#endif
-)
-{
-    JSAtomMap *map;
-    uintN i, length;
-    JSAtom **vector;
-
-    map = &script->atomMap;
-    length = map->length;
-    vector = map->vector;
-    for (i = 0; i < length; i++)
-	GC_MARK_ATOM(rt, vector[i], prev);
-}
-
-static void
-#ifdef GC_MARK_DEBUG
-gc_mark_node(JSRuntime *rt, void *thing, GCMarkNode *prev)
-#else
-gc_mark(JSRuntime *rt, void *thing)
-#endif
-{
-    uint8 flags, *flagp;
-    JSObject *obj;
-    jsval v, *vp, *end;
-    JSScope *scope;
-    JSClass *clasp;
-    JSScript *script;
-    JSFunction *fun;
-    JSScopeProperty *sprop;
-    JSSymbol *sym;
-
-    if (!thing)
-	return;
-    flagp = gc_find_flags(rt, thing);
-    if (!flagp)
-	return;
-
-    /* Check for something on the GC freelist to handle recycled stack. */
-    flags = *flagp;
-    if (flags == GCF_FINAL)
-	return;
-
-#ifdef GC_MARK_DEBUG
-    if (js_LiveThingToFind == thing)
-	gc_dump_thing(thing, flags, prev, stderr);
-#endif
-
-    if (flags & GCF_MARK)
-	return;
-    *flagp |= GCF_MARK;
-    METER(if (++rt->gcStats.depth > rt->gcStats.maxdepth)
-	      rt->gcStats.maxdepth = rt->gcStats.depth);
-
-#ifdef GC_MARK_DEBUG
-    if (js_DumpGCHeap)
-	gc_dump_thing(thing, flags, prev, js_DumpGCHeap);
-#endif
-
-    if ((flags & GCF_TYPEMASK) == GCX_OBJECT) {
-	obj = thing;
-	vp = obj->slots;
-	if (vp) {
-	    scope = OBJ_IS_NATIVE(obj) ? OBJ_SCOPE(obj) : NULL;
-	    if (scope) {
-		clasp = JSVAL_TO_PRIVATE(obj->slots[JSSLOT_CLASS]);
-
-		if (clasp == &js_ScriptClass) {
-		    v = vp[JSSLOT_PRIVATE];
-		    if (!JSVAL_IS_VOID(v)) {
-			script = JSVAL_TO_PRIVATE(v);
-			if (script)
-			    GC_MARK_SCRIPT(rt, script, prev);
-		    }
-		}
-
-		if (clasp == &js_FunctionClass) {
-		    v = vp[JSSLOT_PRIVATE];
-		    if (!JSVAL_IS_VOID(v)) {
-			fun = JSVAL_TO_PRIVATE(v);
-			if (fun) {
-			    if (fun->atom)
-				GC_MARK_ATOM(rt, fun->atom, prev);
-			    if (fun->script)
-				GC_MARK_SCRIPT(rt, fun->script, prev);
-			}
-		    }
-		}
-
-		for (sprop = scope->props; sprop; sprop = sprop->next) {
-		    for (sym = sprop->symbols; sym; sym = sym->next) {
-			if (JSVAL_IS_INT(sym_id(sym)))
-			    continue;
-			GC_MARK_ATOM(rt, sym_atom(sym), prev);
-		    }
-#if JS_HAS_GETTER_SETTER
-                    if (sprop->attrs & (JSPROP_GETTER | JSPROP_SETTER)) {
-#ifdef GC_MARK_DEBUG
-                        char buf[64];
-                        JSAtom *atom = sym_atom(sprop->symbols);
-                        const char *id = (atom && ATOM_IS_STRING(atom))
-                                       ? JS_GetStringBytes(ATOM_TO_STRING(atom))
-                                       : "unknown";
-#endif
-
-                        if (sprop->attrs & JSPROP_GETTER) {
-#ifdef GC_MARK_DEBUG
-                            JS_snprintf(buf, sizeof buf, "%s %s",
-                                        id, js_getter_str);
-#endif
-                            GC_MARK(rt,
-                                    JSVAL_TO_GCTHING((jsval)
-                                        SPROP_GETTER_SCOPE(sprop, scope)),
-                                    buf,
-                                    prev);
-                        }
-                        if (sprop->attrs & JSPROP_SETTER) {
-#ifdef GC_MARK_DEBUG
-                            JS_snprintf(buf, sizeof buf, "%s %s",
-                                        id, js_setter_str);
-#endif
-                            GC_MARK(rt,
-                                    JSVAL_TO_GCTHING((jsval)
-                                        SPROP_SETTER_SCOPE(sprop, scope)),
-                                    buf,
-                                    prev);
-                        }
-                    }
-#endif /* JS_HAS_GETTER_SETTER */
-		}
-	    }
-	    if (!scope || scope->object == obj)
-		end = vp + obj->map->freeslot;
-	    else
-		end = vp + JS_INITIAL_NSLOTS;
-	    for (; vp < end; vp++) {
-		v = *vp;
-		if (JSVAL_IS_GCTHING(v)) {
-#ifdef GC_MARK_DEBUG
-		    char name[32];
-
-		    if (scope) {
-			uint32 slot;
-			jsval nval;
-
-			slot = vp - obj->slots;
-			for (sprop = scope->props; ; sprop = sprop->next) {
-			    if (!sprop) {
-				switch (slot) {
-				  case JSSLOT_PROTO:
-				    strcpy(name, "__proto__");
-				    break;
-				  case JSSLOT_PARENT:
-				    strcpy(name, "__parent__");
-				    break;
-				  case JSSLOT_PRIVATE:
-				    strcpy(name, "__private__");
-				    break;
-				  default:
-				    JS_snprintf(name, sizeof name,
-						"**UNKNOWN SLOT %ld**",
-						(long)slot);
-				    break;
-				}
-				break;
-			    }
-			    if (sprop->slot == slot) {
-				nval = sprop->symbols
-				       ? js_IdToValue(sym_id(sprop->symbols))
-				       : sprop->id;
-				if (JSVAL_IS_INT(nval)) {
-				    JS_snprintf(name, sizeof name, "%ld",
-						(long)JSVAL_TO_INT(nval));
-				} else if (JSVAL_IS_STRING(nval)) {
-				    JS_snprintf(name, sizeof name, "%s",
-				      JS_GetStringBytes(JSVAL_TO_STRING(nval)));
-				} else {
-				    strcpy(name, "**FINALIZED ATOM KEY**");
-				}
-				break;
-			    }
-			}
-		    }
-#endif
-		    GC_MARK(rt, JSVAL_TO_GCTHING(v), name, prev);
-		}
-	    }
-	}
-    }
-
-    METER(rt->gcStats.depth--);
-}
-
-static JSHashNumber
-gc_hash_root(const void *key)
-{
-    JSHashNumber num = (JSHashNumber) key;	/* help lame MSVC1.5 on Win16 */
-
-    return num >> 2;
-}
-
-JS_STATIC_DLL_CALLBACK(intN)
-gc_root_marker(JSHashEntry *he, intN i, void *arg)
-{
-    jsval *rp = (jsval *)he->key;
-    jsval v = *rp;
-
-    /* Ignore null object and scalar values. */
-    if (!JSVAL_IS_NULL(v) && JSVAL_IS_GCTHING(v)) {
-        JSRuntime *rt = (JSRuntime *)arg;
-#ifdef DEBUG
-        JSArena *a;
-        JSBool root_points_to_gcArenaPool = JS_FALSE;
-	void *thing = JSVAL_TO_GCTHING(v);
-
-        for (a = rt->gcArenaPool.first.next; a; a = a->next) {
-	    if (JS_UPTRDIFF(thing, a->base) < a->avail - a->base) {
-                root_points_to_gcArenaPool = JS_TRUE;
-                break;
-            }
-        }
-        JS_ASSERT(root_points_to_gcArenaPool);
-#endif
-
-        GC_MARK(rt, JSVAL_TO_GCTHING(v), he->value ? he->value : "root", NULL);
-    }
-    return HT_ENUMERATE_NEXT;
-}
-
-JS_FRIEND_API(void)
-js_ForceGC(JSContext *cx)
-{
-    cx->newborn[GCX_OBJECT] = NULL;
-    cx->newborn[GCX_STRING] = NULL;
-    cx->newborn[GCX_DOUBLE] = NULL;
-    cx->runtime->gcPoke = JS_TRUE;
-    js_GC(cx);
-    JS_ArenaFinish();
-}
-
-void
-js_GC(JSContext *cx)
-{
-    JSRuntime *rt;
-    JSContext *iter, *acx;
-    JSArena *a, *ma, *fa, **ap, **fap;
-    jsval v, *vp, *sp;
-    jsuword begin, end;
-    JSStackFrame *fp, *chain;
-    void *mark;
-    uint8 flags, *flagp;
-    JSGCThing *thing, *final, **flp, **oflp;
-    GCFinalizeOp finalizer;
-    JSBool a_all_clear, f_all_clear;
-
-    rt = cx->runtime;
-    if (rt->gcDisabled)
-	return;
-
-#ifdef JS_THREADSAFE
-    /* Avoid deadlock. */
-    JS_ASSERT(!JS_IS_RUNTIME_LOCKED(rt));
-#endif
-
-    /* Let the API user decide to defer a GC if it wants to. */
-    if (rt->gcCallback && !rt->gcCallback(cx, JSGC_BEGIN))
-	return;
-
-    /* Lock out other GC allocator and collector invocations. */
-    JS_LOCK_GC(rt);
-
-    /* Do nothing if no assignment has executed since the last GC. */
-    if (!rt->gcPoke) {
-	METER(rt->gcStats.nopoke++);
-	JS_UNLOCK_GC(rt);
-	return;
-    }
-    rt->gcPoke = JS_FALSE;
-    METER(rt->gcStats.poke++);
-
-#ifdef JS_THREADSAFE
-    /* Bump gcLevel and return rather than nest on this context. */
-    if (cx->gcActive) {
-	rt->gcLevel++;
-	METER(if (rt->gcLevel > rt->gcStats.maxlevel)
-		  rt->gcStats.maxlevel = rt->gcLevel);
-	if (rt->gcLevel > 1) {
-	    JS_UNLOCK_GC(rt);
-	    return;
-	}
-    }
-
-    /* If we're in a request, indicate, temporarily, that we're inactive. */
-    if (cx->requestDepth) {
-	rt->requestCount--;
-	JS_NOTIFY_REQUEST_DONE(rt);
-    }
-
-    /* If another thread is already in GC, don't attempt GC; wait instead. */
-    if (rt->gcLevel > 0) {
-	while (rt->gcLevel > 0)
-	    JS_AWAIT_GC_DONE(rt);
-	if (cx->requestDepth)
-	    rt->requestCount++;
-	JS_UNLOCK_GC(rt);
-	return;
-    }
-
-    /* No other thread is in GC, so indicate that we're now in GC. */
-    rt->gcLevel = 1;
-
-    /* Also indicate that GC is active on this context. */
-    cx->gcActive = JS_TRUE;
-
-    /* Wait for all other requests to finish. */
-    while (rt->requestCount > 0)
-	JS_AWAIT_REQUEST_DONE(rt);
-
-#else  /* !JS_THREADSAFE */
-
-    /* Bump gcLevel and return rather than nest; the outer gc will restart. */
-    rt->gcLevel++;
-    METER(if (rt->gcLevel > rt->gcStats.maxlevel)
-	      rt->gcStats.maxlevel = rt->gcLevel);
-    if (rt->gcLevel > 1)
-	return;
-
-#endif /* !JS_THREADSAFE */
-
-    /* Reset malloc counter */
-    rt->gcMallocBytes = 0;
-
-    /* Drop atoms held by the property cache, and clear property weak links. */
-    js_FlushPropertyCache(cx);
-restart:
-    rt->gcNumber++;
-
-    /* Mark phase. */
-    JS_HashTableEnumerateEntries(rt->gcRootsHash, gc_root_marker, rt);
-    js_MarkAtomState(&rt->atomState, gc_mark);
-    iter = NULL;
-    while ((acx = js_ContextIterator(rt, &iter)) != NULL) {
-	/*
-	 * Iterate frame chain and dormant chains. Temporarily tack current
-	 * frame onto the head of the dormant list to ease iteration.
-	 *
-	 * (NOTE: see comment on this whole 'dormant' thing in js_Execute)
-	 */
-	chain = acx->fp;
-	if (chain) {
-	    JS_ASSERT(!chain->dormantNext);
-	    chain->dormantNext = acx->dormantFrameChain;
-	} else {
-	    chain = acx->dormantFrameChain;
-	}
-	for (fp=chain; fp; fp = chain = chain->dormantNext) {
-	    sp = fp->sp;
-	    if (sp) {
-		for (a = acx->stackPool.first.next; a; a = a->next) {
-		    begin = a->base;
-		    end = a->avail;
-		    if (JS_UPTRDIFF(sp, begin) < JS_UPTRDIFF(end, begin))
-			end = (jsuword)sp;
-		    for (vp = (jsval *)begin; vp < (jsval *)end; vp++) {
-			v = *vp;
-			if (JSVAL_IS_GCTHING(v))
-			    GC_MARK(rt, JSVAL_TO_GCTHING(v), "stack", NULL);
-		    }
-		    if (end == (jsuword)sp)
-			break;
-		}
-	    }
-	    do {
-		GC_MARK(rt, fp->scopeChain, "scope chain", NULL);
-		GC_MARK(rt, fp->thisp, "this", NULL);
-		if (JSVAL_IS_GCTHING(fp->rval))
-		    GC_MARK(rt, JSVAL_TO_GCTHING(fp->rval), "rval", NULL);
-		if (fp->callobj)
-		    GC_MARK(rt, fp->callobj, "call object", NULL);
-		if (fp->argsobj)
-		    GC_MARK(rt, fp->argsobj, "arguments object", NULL);
-		if (fp->script)
-		    GC_MARK_SCRIPT(rt, fp->script, NULL);
-		if (fp->sharpArray)
-		    GC_MARK(rt, fp->sharpArray, "sharp array", NULL);
-	    } while ((fp = fp->down) != NULL);
-	}
-	/* cleanup temporary link */
-	if (acx->fp)
-	    acx->fp->dormantNext = NULL;
-	GC_MARK(rt, acx->globalObject, "global object", NULL);
-	GC_MARK(rt, acx->newborn[GCX_OBJECT], "newborn object", NULL);
-	GC_MARK(rt, acx->newborn[GCX_STRING], "newborn string", NULL);
-	GC_MARK(rt, acx->newborn[GCX_DOUBLE], "newborn double", NULL);
-#if JS_HAS_EXCEPTIONS
-	if (acx->throwing && JSVAL_IS_GCTHING(acx->exception))
-	    GC_MARK(rt, JSVAL_TO_GCTHING(acx->exception), "exception", NULL);
-#endif
-    }
-
-    /* Sweep phase.  Mark in tempPool for release at label out:. */
-    ma = cx->tempPool.current;
-    mark = JS_ARENA_MARK(&cx->tempPool);
-    js_SweepAtomState(&rt->atomState);
-    fa = rt->gcFlagsPool.first.next;
-    flagp = (uint8 *)fa->base;
-    for (a = rt->gcArenaPool.first.next; a; a = a->next) {
-	for (thing = (JSGCThing *)a->base; thing < (JSGCThing *)a->avail;
-	     thing++) {
-	    if (flagp >= (uint8 *)fa->avail) {
-		fa = fa->next;
-		JS_ASSERT(fa);
-		if (!fa) {
-		    METER(rt->gcStats.badflag++);
-		    goto out;
-		}
-		flagp = (uint8 *)fa->base;
-	    }
-	    flags = *flagp;
-	    if (flags & GCF_MARK) {
-		*flagp &= ~GCF_MARK;
-	    } else if (!(flags & (GCF_LOCKMASK | GCF_FINAL))) {
-		JS_ARENA_ALLOCATE(final, &cx->tempPool, sizeof(JSGCThing));
-		if (!final)
-		    goto out;
-		final->next = thing;
-		final->flagp = flagp;
-		JS_ASSERT(rt->gcBytes >= sizeof(JSGCThing) + sizeof(uint8));
-		rt->gcBytes -= sizeof(JSGCThing) + sizeof(uint8);
-	    }
-	    flagp++;
-	}
-    }
-
-    /* Finalize phase.  Don't hold the GC lock while running finalizers! */
-    JS_UNLOCK_GC(rt);
-    for (final = mark; ; final++) {
-	if ((jsuword)final >= ma->avail) {
-	    ma = ma->next;
-	    if (!ma)
-		break;
-	    final = (JSGCThing *)ma->base;
-	}
-	thing = final->next;
-	flagp = final->flagp;
-	flags = *flagp;
-	finalizer = gc_finalizers[flags & GCF_TYPEMASK];
-	if (finalizer) {
-	    *flagp |= GCF_FINAL;
-	    finalizer(cx, thing);
-	}
-
-	/*
-	 * Set flags to GCF_FINAL, signifying that thing is free, but don't
-	 * thread thing onto rt->gcFreeList.  We need the GC lock to rebuild
-	 * the freelist below while also looking for free-able arenas.
-	 */
-	*flagp = GCF_FINAL;
-    }
-    JS_LOCK_GC(rt);
-
-    /* Free unused arenas and rebuild the freelist. */
-    ap = &rt->gcArenaPool.first.next;
-    a = *ap;
-    if (!a)
-	goto out;
-    thing = (JSGCThing *)a->base;
-    a_all_clear = f_all_clear = JS_TRUE;
-    flp = oflp = &rt->gcFreeList;
-    *flp = NULL;
-    METER(rt->gcStats.freelen = 0);
-
-    fap = &rt->gcFlagsPool.first.next;
-    while ((fa = *fap) != NULL) {
-	/* XXX optimize by unrolling to use word loads */
-	for (flagp = (uint8 *)fa->base; ; flagp++) {
-	    JS_ASSERT(a);
-	    if (!a) {
-		METER(rt->gcStats.badarena++);
-		goto out;
-	    }
-	    if (thing >= (JSGCThing *)a->avail) {
-		if (a_all_clear) {
-		    JS_ARENA_DESTROY(&rt->gcArenaPool, a, ap);
-		    flp = oflp;
-		    METER(rt->gcStats.afree++);
-		} else {
-		    ap = &a->next;
-		    a_all_clear = JS_TRUE;
-		    oflp = flp;
-		}
-		a = *ap;
-		if (!a)
-		    break;
-		thing = (JSGCThing *)a->base;
-	    }
-	    if (flagp >= (uint8 *)fa->avail)
-		break;
-	    if (*flagp != GCF_FINAL) {
-		a_all_clear = f_all_clear = JS_FALSE;
-	    } else {
-		thing->flagp = flagp;
-		*flp = thing;
-		flp = &thing->next;
-		METER(rt->gcStats.freelen++);
-	    }
-	    thing++;
-	}
-	if (f_all_clear) {
-	    JS_ARENA_DESTROY(&rt->gcFlagsPool, fa, fap);
-	    METER(rt->gcStats.fafree++);
-	} else {
-	    fap = &fa->next;
-	    f_all_clear = JS_TRUE;
-	}
-    }
-
-    /* Terminate the new freelist. */
-    *flp = NULL;
-
-out:
-    JS_ARENA_RELEASE(&cx->tempPool, mark);
-    if (rt->gcLevel > 1) {
-	rt->gcLevel = 1;
-	goto restart;
-    }
-    rt->gcLevel = 0;
-    rt->gcLastBytes = rt->gcBytes;
-
-#ifdef JS_THREADSAFE
-    /* If we were invoked during a request, undo the temporary decrement. */
-    if (cx->requestDepth)
-	rt->requestCount++;
-    cx->gcActive = JS_FALSE;
-    JS_NOTIFY_GC_DONE(rt);
-    JS_UNLOCK_GC(rt);
-#endif
-    if (rt->gcCallback)
-	(void) rt->gcCallback(cx, JSGC_END);
-}

mozilla/js/src/jsgc.h

@@ -1,126 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsgc_h___
-#define jsgc_h___
-/*
- * JS Garbage Collector.
- */
-#include "jspubtd.h"
-
-JS_BEGIN_EXTERN_C
-
-/* GC thing type indexes. */
-#define GCX_OBJECT	0			/* JSObject */
-#define GCX_STRING	1			/* JSString */
-#define GCX_DOUBLE	2			/* jsdouble */
-#define GCX_DECIMAL     3                       /* JSDecimal */
-#define GCX_NTYPES      4
-
-/* GC flag definitions (type index goes in low bits). */
-#define GCF_TYPEMASK	JS_BITMASK(2)		/* use low bits for type */
-#define GCF_MARK	JS_BIT(2)		/* mark bit */
-#define GCF_FINAL	JS_BIT(3)		/* in finalization bit */
-#define GCF_LOCKBIT	4			/* lock bit shift and mask */
-#define GCF_LOCKMASK	(JS_BITMASK(4) << GCF_LOCKBIT)
-#define GCF_LOCK	JS_BIT(GCF_LOCKBIT)	/* lock request bit in API */
-
-#if 1
-/*
- * Since we're forcing a GC from JS_GC anyway, don't bother wasting cycles
- * loading oldval.  XXX remove implied force, poke in addroot/removeroot, &c
- */
-#define GC_POKE(cx, oldval) ((cx)->runtime->gcPoke = JS_TRUE)
-#else
-#define GC_POKE(cx, oldval) ((cx)->runtime->gcPoke = JSVAL_IS_GCTHING(oldval))
-#endif
-
-extern JSBool
-js_InitGC(JSRuntime *rt, uint32 maxbytes);
-
-extern void
-js_FinishGC(JSRuntime *rt);
-
-extern JSBool
-js_AddRoot(JSContext *cx, void *rp, const char *name);
-
-extern JSBool
-js_RemoveRoot(JSRuntime *rt, void *rp);
-
-extern void *
-js_AllocGCThing(JSContext *cx, uintN flags);
-
-extern JSBool
-js_LockGCThing(JSContext *cx, void *thing);
-
-extern JSBool
-js_UnlockGCThing(JSContext *cx, void *thing);
-
-extern JS_FRIEND_API(void)
-js_ForceGC(JSContext *cx);
-
-extern void
-js_GC(JSContext *cx);
-
-#ifdef JS_GCMETER
-
-typedef struct JSGCStats {
-    uint32  alloc;      /* number of allocation attempts */
-    uint32  freelen;    /* gcFreeList length */
-    uint32  recycle;    /* number of things recycled through gcFreeList */
-    uint32  retry;      /* allocation attempt retries after running the GC */
-    uint32  fail;       /* allocation failures */
-    uint32  lock;       /* valid lock calls */
-    uint32  unlock;     /* valid unlock calls */
-    uint32  stuck;      /* stuck reference counts seen by lock calls */
-    uint32  unstuck;    /* unlock calls that saw a stuck lock count */
-    uint32  depth;      /* mark recursion depth */
-    uint32  maxdepth;   /* maximum mark recursion depth */
-    uint32  maxlevel;   /* maximum GC nesting (indirect recursion) level */
-    uint32  poke;       /* number of potentially useful GC calls */
-    uint32  nopoke;     /* useless GC calls where js_PokeGC was not set */
-    uint32  badarena;   /* thing arena corruption */
-    uint32  badflag;    /* flags arena corruption */
-    uint32  afree;      /* thing arenas freed so far */
-    uint32  fafree;     /* flags arenas freed so far */
-} JSGCStats;
-
-extern void
-js_DumpGCStats(JSRuntime *rt, FILE *fp);
-
-#endif /* JS_GCMETER */
-
-JS_END_EXTERN_C
-
-#endif /* jsgc_h___ */

mozilla/js/src/jshash.c

@@ -1,466 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * PR hash table package.
- */
-#include <stdlib.h>
-#include <string.h>
-#include "jstypes.h"
-#include "jsbit.h"
-#include "jsutil.h" /* Added by JSIFY */
-#include "jshash.h" /* Added by JSIFY */
-
-/* Compute the number of buckets in ht */
-#define NBUCKETS(ht)    JS_BIT(JS_HASH_BITS - (ht)->shift)
-
-/* The smallest table has 16 buckets */
-#define MINBUCKETSLOG2  4
-#define MINBUCKETS      JS_BIT(MINBUCKETSLOG2)
-
-/* Compute the maximum entries given n buckets that we will tolerate, ~90% */
-#define OVERLOADED(n)   ((n) - ((n) >> 3))
-
-/* Compute the number of entries below which we shrink the table by half */
-#define UNDERLOADED(n)  (((n) > MINBUCKETS) ? ((n) >> 2) : 0)
-
-/*
-** Stubs for default hash allocator ops.
-*/
-static void *
-DefaultAllocTable(void *pool, size_t size)
-{
-    return malloc(size);
-}
-
-static void
-DefaultFreeTable(void *pool, void *item)
-{
-    free(item);
-}
-
-static JSHashEntry *
-DefaultAllocEntry(void *pool, const void *key)
-{
-    return malloc(sizeof(JSHashEntry));
-}
-
-static void
-DefaultFreeEntry(void *pool, JSHashEntry *he, uintN flag)
-{
-    if (flag == HT_FREE_ENTRY)
-        free(he);
-}
-
-static JSHashAllocOps defaultHashAllocOps = {
-    DefaultAllocTable, DefaultFreeTable,
-    DefaultAllocEntry, DefaultFreeEntry
-};
-
-JS_PUBLIC_API(JSHashTable *)
-JS_NewHashTable(uint32 n, JSHashFunction keyHash,
-                JSHashComparator keyCompare, JSHashComparator valueCompare,
-                JSHashAllocOps *allocOps, void *allocPriv)
-{
-    JSHashTable *ht;
-    size_t nb;
-
-    if (n <= MINBUCKETS) {
-        n = MINBUCKETSLOG2;
-    } else {
-        n = JS_CeilingLog2(n);
-        if ((int32)n < 0)
-            return NULL;
-    }
-
-    if (!allocOps) allocOps = &defaultHashAllocOps;
-
-    ht = (*allocOps->allocTable)(allocPriv, sizeof *ht);
-    if (!ht)
-	return NULL;
-    memset(ht, 0, sizeof *ht);
-    ht->shift = JS_HASH_BITS - n;
-    n = JS_BIT(n);
-#if defined(XP_PC) && defined _MSC_VER && _MSC_VER <= 800
-    if (n > 16000) {
-        (*allocOps->freeTable)(allocPriv, ht);
-        return NULL;
-    }
-#endif  /* WIN16 */
-    nb = n * sizeof(JSHashEntry *);
-    ht->buckets = (*allocOps->allocTable)(allocPriv, nb);
-    if (!ht->buckets) {
-        (*allocOps->freeTable)(allocPriv, ht);
-        return NULL;
-    }
-    memset(ht->buckets, 0, nb);
-
-    ht->keyHash = keyHash;
-    ht->keyCompare = keyCompare;
-    ht->valueCompare = valueCompare;
-    ht->allocOps = allocOps;
-    ht->allocPriv = allocPriv;
-    return ht;
-}
-
-JS_PUBLIC_API(void)
-JS_HashTableDestroy(JSHashTable *ht)
-{
-    uint32 i, n;
-    JSHashEntry *he, *next;
-    JSHashAllocOps *allocOps = ht->allocOps;
-    void *allocPriv = ht->allocPriv;
-
-    n = NBUCKETS(ht);
-    for (i = 0; i < n; i++) {
-        for (he = ht->buckets[i]; he; he = next) {
-            next = he->next;
-            (*allocOps->freeEntry)(allocPriv, he, HT_FREE_ENTRY);
-        }
-    }
-#ifdef DEBUG
-    memset(ht->buckets, 0xDB, n * sizeof ht->buckets[0]);
-#endif
-    (*allocOps->freeTable)(allocPriv, ht->buckets);
-#ifdef DEBUG
-    memset(ht, 0xDB, sizeof *ht);
-#endif
-    (*allocOps->freeTable)(allocPriv, ht);
-}
-
-/*
-** Multiplicative hash, from Knuth 6.4.
-*/
-JS_PUBLIC_API(JSHashEntry **)
-JS_HashTableRawLookup(JSHashTable *ht, JSHashNumber keyHash, const void *key)
-{
-    JSHashEntry *he, **hep, **hep0;
-    JSHashNumber h;
-
-#ifdef HASHMETER
-    ht->nlookups++;
-#endif
-    h = keyHash * JS_GOLDEN_RATIO;
-    h >>= ht->shift;
-    hep = hep0 = &ht->buckets[h];
-    while ((he = *hep) != NULL) {
-        if (he->keyHash == keyHash && (*ht->keyCompare)(key, he->key)) {
-            /* Move to front of chain if not already there */
-            if (hep != hep0) {
-                *hep = he->next;
-                he->next = *hep0;
-                *hep0 = he;
-            }
-            return hep0;
-        }
-        hep = &he->next;
-#ifdef HASHMETER
-        ht->nsteps++;
-#endif
-    }
-    return hep;
-}
-
-JS_PUBLIC_API(JSHashEntry *)
-JS_HashTableRawAdd(JSHashTable *ht, JSHashEntry **hep,
-                   JSHashNumber keyHash, const void *key, void *value)
-{
-    uint32 i, n;
-    JSHashEntry *he, *next, **oldbuckets;
-    size_t nb;
-
-    /* Grow the table if it is overloaded */
-    n = NBUCKETS(ht);
-    if (ht->nentries >= OVERLOADED(n)) {
-#ifdef HASHMETER
-        ht->ngrows++;
-#endif
-        ht->shift--;
-        oldbuckets = ht->buckets;
-#if defined(XP_PC) && defined _MSC_VER && _MSC_VER <= 800
-        if (2 * n > 16000)
-            return NULL;
-#endif  /* WIN16 */
-        nb = 2 * n * sizeof(JSHashEntry *);
-        ht->buckets = (*ht->allocOps->allocTable)(ht->allocPriv, nb);
-        if (!ht->buckets) {
-            ht->buckets = oldbuckets;
-            return NULL;
-	}
-        memset(ht->buckets, 0, nb);
-
-        for (i = 0; i < n; i++) {
-            for (he = oldbuckets[i]; he; he = next) {
-                next = he->next;
-                hep = JS_HashTableRawLookup(ht, he->keyHash, he->key);
-                JS_ASSERT(*hep == NULL);
-                he->next = NULL;
-                *hep = he;
-            }
-        }
-#ifdef DEBUG
-        memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
-#endif
-        (*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
-        hep = JS_HashTableRawLookup(ht, keyHash, key);
-    }
-
-    /* Make a new key value entry */
-    he = (*ht->allocOps->allocEntry)(ht->allocPriv, key);
-    if (!he)
-	return NULL;
-    he->keyHash = keyHash;
-    he->key = key;
-    he->value = value;
-    he->next = *hep;
-    *hep = he;
-    ht->nentries++;
-    return he;
-}
-
-JS_PUBLIC_API(JSHashEntry *)
-JS_HashTableAdd(JSHashTable *ht, const void *key, void *value)
-{
-    JSHashNumber keyHash;
-    JSHashEntry *he, **hep;
-
-    keyHash = (*ht->keyHash)(key);
-    hep = JS_HashTableRawLookup(ht, keyHash, key);
-    if ((he = *hep) != NULL) {
-        /* Hit; see if values match */
-        if ((*ht->valueCompare)(he->value, value)) {
-            /* key,value pair is already present in table */
-            return he;
-        }
-        if (he->value)
-            (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_VALUE);
-        he->value = value;
-        return he;
-    }
-    return JS_HashTableRawAdd(ht, hep, keyHash, key, value);
-}
-
-JS_PUBLIC_API(void)
-JS_HashTableRawRemove(JSHashTable *ht, JSHashEntry **hep, JSHashEntry *he)
-{
-    uint32 i, n;
-    JSHashEntry *next, **oldbuckets;
-    size_t nb;
-
-    *hep = he->next;
-    (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_ENTRY);
-
-    /* Shrink table if it's underloaded */
-    n = NBUCKETS(ht);
-    if (--ht->nentries < UNDERLOADED(n)) {
-#ifdef HASHMETER
-        ht->nshrinks++;
-#endif
-        ht->shift++;
-        oldbuckets = ht->buckets;
-        nb = n * sizeof(JSHashEntry*) / 2;
-        ht->buckets = (*ht->allocOps->allocTable)(ht->allocPriv, nb);
-        if (!ht->buckets) {
-            ht->buckets = oldbuckets;
-            return;
-        }
-        memset(ht->buckets, 0, nb);
-
-        for (i = 0; i < n; i++) {
-            for (he = oldbuckets[i]; he; he = next) {
-                next = he->next;
-                hep = JS_HashTableRawLookup(ht, he->keyHash, he->key);
-                JS_ASSERT(*hep == NULL);
-                he->next = NULL;
-                *hep = he;
-            }
-        }
-#ifdef DEBUG
-        memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
-#endif
-        (*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
-    }
-}
-
-JS_PUBLIC_API(JSBool)
-JS_HashTableRemove(JSHashTable *ht, const void *key)
-{
-    JSHashNumber keyHash;
-    JSHashEntry *he, **hep;
-
-    keyHash = (*ht->keyHash)(key);
-    hep = JS_HashTableRawLookup(ht, keyHash, key);
-    if ((he = *hep) == NULL)
-        return JS_FALSE;
-
-    /* Hit; remove element */
-    JS_HashTableRawRemove(ht, hep, he);
-    return JS_TRUE;
-}
-
-JS_PUBLIC_API(void *)
-JS_HashTableLookup(JSHashTable *ht, const void *key)
-{
-    JSHashNumber keyHash;
-    JSHashEntry *he, **hep;
-
-    keyHash = (*ht->keyHash)(key);
-    hep = JS_HashTableRawLookup(ht, keyHash, key);
-    if ((he = *hep) != NULL) {
-        return he->value;
-    }
-    return NULL;
-}
-
-/*
-** Iterate over the entries in the hash table calling func for each
-** entry found. Stop if "f" says to (return value & JS_ENUMERATE_STOP).
-** Return a count of the number of elements scanned.
-*/
-JS_PUBLIC_API(int)
-JS_HashTableEnumerateEntries(JSHashTable *ht, JSHashEnumerator f, void *arg)
-{
-    JSHashEntry *he, **hep;
-    uint32 i, nbuckets;
-    int rv, n = 0;
-    JSHashEntry *todo = NULL;
-
-    nbuckets = NBUCKETS(ht);
-    for (i = 0; i < nbuckets; i++) {
-        hep = &ht->buckets[i];
-        while ((he = *hep) != NULL) {
-            rv = (*f)(he, n, arg);
-            n++;
-            if (rv & (HT_ENUMERATE_REMOVE | HT_ENUMERATE_UNHASH)) {
-                *hep = he->next;
-                if (rv & HT_ENUMERATE_REMOVE) {
-                    he->next = todo;
-                    todo = he;
-                }
-            } else {
-                hep = &he->next;
-            }
-            if (rv & HT_ENUMERATE_STOP) {
-                goto out;
-            }
-        }
-    }
-
-out:
-    hep = &todo;
-    while ((he = *hep) != NULL) {
-        JS_HashTableRawRemove(ht, hep, he);
-    }
-    return n;
-}
-
-#ifdef HASHMETER
-#include <math.h>
-#include <stdio.h>
-
-JS_PUBLIC_API(void)
-JS_HashTableDumpMeter(JSHashTable *ht, JSHashEnumerator dump, FILE *fp)
-{
-    double mean, variance;
-    uint32 nchains, nbuckets;
-    uint32 i, n, maxChain, maxChainLen;
-    JSHashEntry *he;
-
-    variance = 0;
-    nchains = 0;
-    maxChainLen = 0;
-    nbuckets = NBUCKETS(ht);
-    for (i = 0; i < nbuckets; i++) {
-        he = ht->buckets[i];
-        if (!he)
-            continue;
-        nchains++;
-        for (n = 0; he; he = he->next)
-            n++;
-        variance += n * n;
-        if (n > maxChainLen) {
-            maxChainLen = n;
-            maxChain = i;
-        }
-    }
-    mean = (double)ht->nentries / nchains;
-    variance = fabs(variance / nchains - mean * mean);
-
-    fprintf(fp, "\nHash table statistics:\n");
-    fprintf(fp, "     number of lookups: %u\n", ht->nlookups);
-    fprintf(fp, "     number of entries: %u\n", ht->nentries);
-    fprintf(fp, "       number of grows: %u\n", ht->ngrows);
-    fprintf(fp, "     number of shrinks: %u\n", ht->nshrinks);
-    fprintf(fp, "   mean steps per hash: %g\n", (double)ht->nsteps
-                                                / ht->nlookups);
-    fprintf(fp, "mean hash chain length: %g\n", mean);
-    fprintf(fp, "    standard deviation: %g\n", sqrt(variance));
-    fprintf(fp, " max hash chain length: %u\n", maxChainLen);
-    fprintf(fp, "        max hash chain: [%u]\n", maxChain);
-
-    for (he = ht->buckets[maxChain], i = 0; he; he = he->next, i++)
-        if ((*dump)(he, i, fp) != HT_ENUMERATE_NEXT)
-            break;
-}
-#endif /* HASHMETER */
-
-JS_PUBLIC_API(int)
-JS_HashTableDump(JSHashTable *ht, JSHashEnumerator dump, FILE *fp)
-{
-    int count;
-
-    count = JS_HashTableEnumerateEntries(ht, dump, fp);
-#ifdef HASHMETER
-    JS_HashTableDumpMeter(ht, dump, fp);
-#endif
-    return count;
-}
-
-JS_PUBLIC_API(JSHashNumber)
-JS_HashString(const void *key)
-{
-    JSHashNumber h;
-    const unsigned char *s;
-
-    h = 0;
-    for (s = key; *s; s++)
-        h = (h >> 28) ^ (h << 4) ^ *s;
-    return h;
-}
-
-JS_PUBLIC_API(int)
-JS_CompareValues(const void *v1, const void *v2)
-{
-    return v1 == v2;
-}

mozilla/js/src/jshash.h

@@ -1,147 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jshash_h___
-#define jshash_h___
-/*
- * API to portable hash table code.
- */
-#include <stddef.h>
-#include <stdio.h>
-#include "jstypes.h"
-#include "jscompat.h"
-
-JS_BEGIN_EXTERN_C
-
-typedef uint32 JSHashNumber;
-typedef struct JSHashEntry JSHashEntry;
-typedef struct JSHashTable JSHashTable;
-
-#define JS_HASH_BITS 32
-#define JS_GOLDEN_RATIO 0x9E3779B9U
-
-typedef JSHashNumber (*JSHashFunction)(const void *key);
-typedef intN (*JSHashComparator)(const void *v1, const void *v2);
-typedef intN (*JSHashEnumerator)(JSHashEntry *he, intN i, void *arg);
-
-/* Flag bits in JSHashEnumerator's return value */
-#define HT_ENUMERATE_NEXT       0       /* continue enumerating entries */
-#define HT_ENUMERATE_STOP       1       /* stop enumerating entries */
-#define HT_ENUMERATE_REMOVE     2       /* remove and free the current entry */
-#define HT_ENUMERATE_UNHASH     4       /* just unhash the current entry */
-
-typedef struct JSHashAllocOps {
-    void *              (*allocTable)(void *pool, size_t size);
-    void                (*freeTable)(void *pool, void *item);
-    JSHashEntry *       (*allocEntry)(void *pool, const void *key);
-    void                (*freeEntry)(void *pool, JSHashEntry *he, uintN flag);
-} JSHashAllocOps;
-
-#define HT_FREE_VALUE   0               /* just free the entry's value */
-#define HT_FREE_ENTRY   1               /* free value and entire entry */
-
-struct JSHashEntry {
-    JSHashEntry         *next;          /* hash chain linkage */
-    JSHashNumber        keyHash;        /* key hash function result */
-    const void          *key;           /* ptr to opaque key */
-    void                *value;         /* ptr to opaque value */
-};
-
-struct JSHashTable {
-    JSHashEntry         **buckets;      /* vector of hash buckets */
-    uint32              nentries;       /* number of entries in table */
-    uint32              shift;          /* multiplicative hash shift */
-    JSHashFunction      keyHash;        /* key hash function */
-    JSHashComparator    keyCompare;     /* key comparison function */
-    JSHashComparator    valueCompare;   /* value comparison function */
-    JSHashAllocOps      *allocOps;      /* allocation operations */
-    void                *allocPriv;     /* allocation private data */
-#ifdef HASHMETER
-    uint32              nlookups;       /* total number of lookups */
-    uint32              nsteps;         /* number of hash chains traversed */
-    uint32              ngrows;         /* number of table expansions */
-    uint32              nshrinks;       /* number of table contractions */
-#endif
-};
-
-/*
- * Create a new hash table.
- * If allocOps is null, use default allocator ops built on top of malloc().
- */
-extern JS_PUBLIC_API(JSHashTable *)
-JS_NewHashTable(uint32 n, JSHashFunction keyHash,
-                JSHashComparator keyCompare, JSHashComparator valueCompare,
-                JSHashAllocOps *allocOps, void *allocPriv);
-
-extern JS_PUBLIC_API(void)
-JS_HashTableDestroy(JSHashTable *ht);
-
-/* Low level access methods */
-extern JS_PUBLIC_API(JSHashEntry **)
-JS_HashTableRawLookup(JSHashTable *ht, JSHashNumber keyHash, const void *key);
-
-extern JS_PUBLIC_API(JSHashEntry *)
-JS_HashTableRawAdd(JSHashTable *ht, JSHashEntry **hep, JSHashNumber keyHash,
-                   const void *key, void *value);
-
-extern JS_PUBLIC_API(void)
-JS_HashTableRawRemove(JSHashTable *ht, JSHashEntry **hep, JSHashEntry *he);
-
-/* Higher level access methods */
-extern JS_PUBLIC_API(JSHashEntry *)
-JS_HashTableAdd(JSHashTable *ht, const void *key, void *value);
-
-extern JS_PUBLIC_API(JSBool)
-JS_HashTableRemove(JSHashTable *ht, const void *key);
-
-extern JS_PUBLIC_API(intN)
-JS_HashTableEnumerateEntries(JSHashTable *ht, JSHashEnumerator f, void *arg);
-
-extern JS_PUBLIC_API(void *)
-JS_HashTableLookup(JSHashTable *ht, const void *key);
-
-extern JS_PUBLIC_API(intN)
-JS_HashTableDump(JSHashTable *ht, JSHashEnumerator dump, FILE *fp);
-
-/* General-purpose C string hash function. */
-extern JS_PUBLIC_API(JSHashNumber)
-JS_HashString(const void *key);
-
-/* Stub function just returns v1 == v2 */
-extern JS_PUBLIC_API(intN)
-JS_CompareValues(const void *v1, const void *v2);
-
-JS_END_EXTERN_C
-
-#endif /* jshash_h___ */

mozilla/js/src/jsify.pl

@@ -1,485 +0,0 @@
-#!/usr/local/bin/perl
-
-# This script modifies C code to use the hijacked NSPR routines that are
-# now baked into the JavaScript engine rather than using the NSPR
-# routines that they were based on, i.e. types like PRArenaPool are changed
-# to JSArenaPool.
-#
-# This script was used in 9/98 to facilitate the incorporation of some NSPR
-# code into the JS engine so as to minimize dependency on NSPR.
-#
-
-# Command-line: jsify.pl [options] [filename]*
-#
-# Options:
-#  -r         Reverse direction of transformation, i.e. JS ==> NSPR2
-#  -outdir    Directory in which to place output files
-
-
-# NSPR2 symbols that will be modified to JS symbols, e.g.
-# PRArena <==> JSArena
-
-@NSPR_symbols = (
-"PRArena",
-"PRArenaPool",
-"PRArenaStats",
-"PR_ARENAMETER",
-"PR_ARENA_",
-"PR_ARENA_ALIGN",
-"PR_ARENA_ALLOCATE",
-"PR_ARENA_CONST_ALIGN_MASK",
-"PR_ARENA_DEFAULT_ALIGN",
-"PR_ARENA_DESTROY",
-"PR_ARENA_GROW",
-"PR_ARENA_MARK",
-"PR_ARENA_RELEASE",
-
-"PR_smprintf",
-"PR_smprintf_free",
-"PR_snprintf",
-"PR_sprintf_append",
-"PR_sscanf",
-"PR_sxprintf",
-"PR_vsmprintf",
-"PR_vsnprintf",
-"PR_vsprintf_append",
-"PR_vsxprintf",
-
-"PRCList",
-"PRCListStr",
-"PRCLists",
-
-"PRDestroyEventProc",
-"PREvent",
-"PREventFunProc",
-"PREventQueue",
-"PRHandleEventProc",
-"PR_PostEvent",
-"PR_PostSynchronousEvent",
-"PR_ProcessPendingEvents",
-"PR_CreateEventQueue",
-"PR_DequeueEvent",
-"PR_DestroyEvent",
-"PR_DestroyEventQueue",
-"PR_EventAvailable",
-"PR_EventLoop",
-"PR_GetEvent",
-"PR_GetEventOwner",
-"PR_GetEventQueueMonitor",
-"PR_GetEventQueueSelectFD",
-"PR_GetMainEventQueue",
-"PR_HandleEvent",
-"PR_InitEvent",
-"PR_ENTER_EVENT_QUEUE_MONITOR",
-"PR_EXIT_EVENT_QUEUE_MONITOR",
-"PR_MapEvents",
-"PR_RevokeEvents",
-
-"PR_cnvtf",
-"PR_dtoa",
-"PR_strtod",
-
-"PRFileDesc",
-
-"PR_HASH_BITS",
-"PR_GOLDEN_RATIO",
-"PRHashAllocOps",
-"PRHashComparator",
-"PRHashEntry",
-"PRHashEnumerator",
-"PRHashFunction",
-"PRHashNumber",
-"PRHashTable",
-"PR_HashString",
-"PR_HashTableAdd",
-"PR_HashTableDestroy",
-"PR_HashTableDump",
-"PR_HashTableEnumerateEntries",
-"PR_HashTableLookup",
-"PR_HashTableRawAdd",
-"PR_HashTableRawLookup",
-"PR_HashTableRawRemove",
-"PR_HashTableRemove",
-
-"PRBool",
-"PRFloat64",
-"PRInt16",
-"PRInt32",
-"PRInt64",
-"PRInt8",
-"PRIntn",
-"PRUint16",
-"PRUint32",
-"PRUint64",
-"PRUint8",
-"PRUintn",
-"PRPtrDiff",
-"PRPtrdiff",
-"PRUptrdiff",
-"PRUword",
-"PRWord",
-"PRPackedBool",
-"PRSize",
-"PRStatus",
-"pruword",
-"prword",
-"prword_t",
-
-"PR_ALIGN_OF_DOUBLE",
-"PR_ALIGN_OF_FLOAT",
-"PR_ALIGN_OF_INT",
-"PR_ALIGN_OF_INT64",
-"PR_ALIGN_OF_LONG",
-"PR_ALIGN_OF_POINTER",
-"PR_ALIGN_OF_SHORT",
-"PR_ALIGN_OF_WORD",
-"PR_BITS_PER_BYTE",
-"PR_BITS_PER_BYTE_LOG2",
-"PR_BITS_PER_DOUBLE",
-"PR_BITS_PER_DOUBLE_LOG2",
-"PR_BITS_PER_FLOAT",
-"PR_BITS_PER_FLOAT_LOG2",
-"PR_BITS_PER_INT",
-"PR_BITS_PER_INT64",
-"PR_BITS_PER_INT64_LOG2",
-"PR_BITS_PER_INT_LOG2",
-"PR_BITS_PER_LONG",
-"PR_BITS_PER_LONG_LOG2",
-"PR_BITS_PER_SHORT",
-"PR_BITS_PER_SHORT_LOG2",
-"PR_BITS_PER_WORD",
-"PR_BITS_PER_WORD_LOG2",
-"PR_BYTES_PER_BYTE",
-"PR_BYTES_PER_DOUBLE",
-"PR_BYTES_PER_DWORD",
-"PR_BYTES_PER_DWORD_LOG2",
-"PR_BYTES_PER_FLOAT",
-"PR_BYTES_PER_INT",
-"PR_BYTES_PER_INT64",
-"PR_BYTES_PER_LONG",
-"PR_BYTES_PER_SHORT",
-"PR_BYTES_PER_WORD",
-"PR_BYTES_PER_WORD_LOG2",
-
-"PRSegment",
-"PRSegmentAccess",
-"PRStuffFunc",
-"PRThread",
-
-"PR_APPEND_LINK",
-
-"PR_ASSERT",
-
-"PR_ATOMIC_DWORD_LOAD",
-"PR_ATOMIC_DWORD_STORE",
-
-"PR_Abort",
-
-"PR_ArenaAllocate",
-"PR_ArenaCountAllocation",
-"PR_ArenaCountGrowth",
-"PR_ArenaCountInplaceGrowth",
-"PR_ArenaCountRelease",
-"PR_ArenaCountRetract",
-"PR_ArenaFinish",
-"PR_ArenaGrow",
-"PR_ArenaRelease",
-"PR_CompactArenaPool",
-"PR_DumpArenaStats",
-"PR_FinishArenaPool",
-"PR_FreeArenaPool",
-"PR_InitArenaPool",
-
-"PR_Assert",
-
-"PR_AttachThread",
-
-"PR_BEGIN_EXTERN_C",
-"PR_BEGIN_MACRO",
-
-"PR_BIT",
-"PR_BITMASK",
-
-"PR_BUFFER_OVERFLOW_ERROR",
-
-"PR_CALLBACK",
-"PR_CALLBACK_DECL",
-"PR_CALLOC",
-"PR_CEILING_LOG2",
-"PR_CLEAR_ARENA",
-"PR_CLEAR_BIT",
-"PR_CLEAR_UNUSED",
-"PR_CLIST_IS_EMPTY",
-"PR_COUNT_ARENA",
-"PR_CURRENT_THREAD",
-
-"PR_GetSegmentAccess",
-"PR_GetSegmentSize",
-"PR_GetSegmentVaddr",
-"PR_GrowSegment",
-"PR_DestroySegment",
-"PR_MapSegment",
-"PR_NewSegment",
-"PR_Segment",
-"PR_Seg",
-"PR_SEGMENT_NONE",
-"PR_SEGMENT_RDONLY",
-"PR_SEGMENT_RDWR",
-
-"PR_Calloc",
-"PR_CeilingLog2",
-"PR_CompareStrings",
-"PR_CompareValues",
-"PR_DELETE",
-"PR_END_EXTERN_C",
-"PR_END_MACRO",
-"PR_ENUMERATE_STOP",
-"PR_FAILURE",
-"PR_FALSE",
-"PR_FLOOR_LOG2",
-"PR_FREEIF",
-"PR_FREE_PATTERN",
-"PR_FloorLog2",
-"PR_FormatTime",
-"PR_Free",
-
-"PR_GetEnv",
-"PR_GetError",
-"PR_INIT_ARENA_POOL",
-"PR_INIT_CLIST",
-"PR_INIT_STATIC_CLIST",
-"PR_INLINE",
-"PR_INSERT_AFTER",
-"PR_INSERT_BEFORE",
-"PR_INSERT_LINK",
-"PR_INT32",
-"PR_INTERVAL_NO_TIMEOUT",
-"PR_INTERVAL_NO_WAIT",
-"PR_Init",
-"PR_LIST_HEAD",
-"PR_LIST_TAIL",
-"PR_LOG",
-"PR_LOGGING",
-"PR_LOG_ALWAYS",
-"PR_LOG_BEGIN",
-"PR_LOG_DEBUG",
-"PR_LOG_DEFINE",
-"PR_LOG_END",
-"PR_LOG_ERROR",
-"PR_LOG_MAX",
-"PR_LOG_MIN",
-"PR_LOG_NONE",
-"PR_LOG_NOTICE",
-"PR_LOG_TEST",
-"PR_LOG_WARN",
-"PR_LOG_WARNING",
-"PR_LogFlush",
-"PR_LogPrint",
-"PR_MALLOC",
-"PR_MAX",
-"PR_MD_calloc",
-"PR_MD_free",
-"PR_MD_malloc",
-"PR_MD_realloc",
-"PR_MIN",
-"PR_Malloc",
-"PR_NEW",
-"PR_NEWZAP",
-"PR_NEXT_LINK",
-"PR_NOT_REACHED",
-"PR_NewCondVar",
-"PR_NewHashTable",
-"PR_NewLogModule",
-"PR_PREV_LINK",
-"PR_PUBLIC_API",
-"PR_PUBLIC_DATA",
-"PR_RANGE_ERROR",
-"PR_REALLOC",
-"PR_REMOVE_AND_INIT_LINK",
-"PR_REMOVE_LINK",
-"PR_ROUNDUP",
-"PR_Realloc",
-
-"PR_SET_BIT",
-"PR_STATIC_CALLBACK",
-"PR_SUCCESS",
-"PR_SetError",
-"PR_SetLogBuffering",
-"PR_SetLogFile",
-
-"PR_TEST_BIT",
-"PR_TRUE",
-"PR_UINT32",
-"PR_UPTRDIFF",
-
-"prarena_h___",
-"prbit_h___",
-"prclist_h___",
-"prdtoa_h___",
-"prlog_h___",
-"prlong_h___",
-"prmacos_h___",
-"prmem_h___",
-"prprf_h___",
-"prtypes_h___",
-
-"prarena",
-"prbit",
-"prbitmap_t",
-"prclist",
-"prcpucfg",
-"prdtoa",
-"prhash",
-"plhash",
-"prlong",
-"prmacos",
-"prmem",
-"prosdep",
-"protypes",
-"prprf",
-"prtypes"
-);
-
-while ($ARGV[0] =~ /^-/) {
-    if ($ARGV[0] eq "-r") {
-	shift;
-	$reverse_conversion = 1;
-    } elsif ($ARGV[0] eq "-outdir") {
-	shift;
-	$outdir = shift;
-    }
-}
-
-# Given an NSPR symbol compute the JS equivalent or
-# vice-versa
-sub subst {
-    local ($replacement);
-    local ($sym) = @_;
-    
-    $replacement = substr($sym,0,2) eq "pr" ? "js" : "JS";
-    $replacement .= substr($sym, 2);
-    return $replacement;
-}
-
-# Build the regular expression that will convert between the NSPR
-# types and the JS types
-if ($reverse_conversion) {
-    die "Not implemented yet";
-} else {
-    foreach $sym (@NSPR_symbols) {
-	$regexp .= $sym . "|"
-    }
-    # Get rid of the last "!"
-    chop $regexp;
-
-    # Replace PR* with JS* and replace pr* with js*
-    $regexp = 's/(^|\\W)(' . $regexp . ')/$1 . &subst($2)/eg';
-#    print $regexp;
-}
-
-# Pre-compile a little subroutine to perform the regexp substitution
-# between NSPR types and JS types
-eval('sub convert_from_NSPR {($line) = @_; $line =~ ' . $regexp . ';}');
-
-sub convert_mallocs {
-    ($line) = @_;
-    $line =~ s/PR_MALLOC/malloc/g;
-    $line =~ s/PR_REALLOC/realloc/g;
-    $line =~ s/PR_FREE/free/g;
-    return $line;
-}
-
-sub convert_includes {
-    ($line) = @_;
-    if ($line !~ /include/) {
-	return $line;
-    }
-
-    if ($line =~ /prlog\.h/) {
-	$line = '#include "jsutil.h"'. " /* Added by JSIFY */\n";
-    } elsif ($line =~ /plhash\.h/) {
-	$line = '#include "jshash.h"'. " /* Added by JSIFY */\n";
-    } elsif ($line =~ /plarena\.h/) {
-	$line = '#include "jsarena.h"'. " /* Added by JSIFY */\n";
-    } elsif ($line =~ /prmem\.h/) {
-	$line  = "";
-    } elsif ($line =~ /jsmsg\.def/) {
-	$line  = '#include "js.msg"' . "\n";
-    } elsif ($line =~ /shellmsg\.def/) {
-	$line  = '#include "jsshell.msg"' . "\n";
-    } elsif ($line =~ /jsopcode\.def/) {
-	$line  = '#include "jsopcode.tbl"' . "\n";
-    }
-    return $line;
-}
-
-sub convert_declarations {
-    ($line) = @_;
-    $line =~ s/PR_EXTERN/JS_EXTERN_API/g;
-    $line =~ s/PR_IMPLEMENT_DATA/JS_EXPORT_DATA/g;
-    $line =~ s/PR_IMPLEMENT/JS_EXPORT_API/g;
-    $line =~ s/PR_CALLBACK/JS_DLL_CALLBACK/g;
-    $line =~ s/PR_STATIC_CALLBACK/JS_STATIC_DLL_CALLBACK/g;
-    $line =~ s/PR_IMPORT/JS_IMPORT/g;
-    $line =~ s/PR_PUBLIC_API/JS_EXPORT_API/g;
-    $line =~ s/PR_PUBLIC_DATA/JS_EXPORT_DATA/g;
-    return $line;
-}    
-
-sub convert_long_long_macros {
-    ($line) = @_;
-    $line =~ s/\b(LL_)/JSLL_/g;
-    return $line;
-}    
-
-sub convert_asserts {
-    ($line) = @_;
-    $line =~ s/\bPR_ASSERT/JS_ASSERT/g;
-    return $line;
-}
-
-while ($#ARGV >= 0) {
-    $infile = shift;
-
-    # Change filename, e.g. prtime.h to jsprtime.h, except for legacy
-    # files that start with 'prmj', like prmjtime.h.
-    $outfile = $infile;
-    if ($infile !~ /^prmj/) {
-	$outfile =~ s/^pr/js/;
-	$outfile =~ s/^pl/js/;
-    }
-    
-    if ($outdir) {
-	$outfile = $outdir . '/' . $outfile;
-    }	
-
-    if ($infile eq $outfile) {
-	die "Error: refuse to overwrite $outfile, use -outdir option."
-    }
-    die "Can't open $infile" if !open(INFILE, "<$infile");
-    die "Can't open $outfile for writing" if !open(OUTFILE, ">$outfile");
-
-    while (<INFILE>) {
-	$line = $_;
-	
-	#Get rid of #include "prlog.h"
-	&convert_includes($line);
-
-	# Rename PR_EXTERN, PR_IMPORT, etc.
-	&convert_declarations($line);
-
-	# Convert from PR_MALLOC to malloc, etc.
-	&convert_mallocs($line);
-	
-	# Convert from PR_ASSERT to JS_ASSERT
-#	&convert_asserts($line);
-
-	# Convert from, e.g. PRArena to JSPRArena
-	&convert_from_NSPR($line);
-
-	# Change LL_* macros to JSLL_*
-	&convert_long_long_macros($line);
-	
-	print OUTFILE $line;
-    }
-}

mozilla/js/src/jsinterp.h

@@ -1,255 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsinterp_h___
-#define jsinterp_h___
-/*
- * JS interpreter interface.
- */
-#include "jsprvtd.h"
-#include "jspubtd.h"
-
-JS_BEGIN_EXTERN_C
-
-/*
- * JS stack frame, allocated on the C stack.
- */
-struct JSStackFrame {
-    JSObject        *callobj;       /* lazily created Call object */
-    JSObject        *argsobj;       /* lazily created arguments object */
-    JSScript        *script;        /* script being interpreted */
-    JSFunction      *fun;           /* function being called or null */
-    JSObject        *thisp;         /* "this" pointer if in method */
-    uintN           argc;           /* actual argument count */
-    jsval           *argv;          /* base of argument stack slots */
-    jsval           rval;           /* function return value */
-    uintN           nvars;          /* local variable count */
-    jsval           *vars;          /* base of variable stack slots */
-    JSStackFrame    *down;          /* previous frame */
-    void            *annotation;    /* used by Java security */
-    JSObject        *scopeChain;    /* scope chain */
-    jsbytecode      *pc;            /* program counter */
-    jsval           *sp;            /* stack pointer */
-    uintN           sharpDepth;     /* array/object initializer depth */
-    JSObject        *sharpArray;    /* scope for #n= initializer vars */
-    JSPackedBool    constructing;   /* true if called via new operator */
-    uint8           overrides;      /* bit-set of overridden Call properties */
-    uint8           special;        /* special frame type flags, see below */
-    JSPackedBool    reserved;       /* reserved for future use */
-    JSStackFrame    *dormantNext;   /* next dormant frame chain */
-};
-
-/* JS stack frame special flags. */
-#define JSFRAME_DEBUGGER    0x1     /* frame for JS_EvaluateInStackFrame */
-#define JSFRAME_EVAL        0x2     /* frame for obj_eval */
-
-/*
- * Property cache for quickened get/set property opcodes.
- */
-#define PROPERTY_CACHE_LOG2     10
-#define PROPERTY_CACHE_SIZE     JS_BIT(PROPERTY_CACHE_LOG2)
-#define PROPERTY_CACHE_MASK     JS_BITMASK(PROPERTY_CACHE_LOG2)
-
-#define PROPERTY_CACHE_HASH(obj, id) \
-    ((((jsuword)(obj) >> JSVAL_TAGBITS) ^ (jsuword)(id)) & PROPERTY_CACHE_MASK)
-
-#ifdef JS_THREADSAFE
-
-#if HAVE_ATOMIC_DWORD_ACCESS
-
-#define PCE_LOAD(cache, pce, entry)     JS_ATOMIC_DWORD_LOAD(pce, entry)
-#define PCE_STORE(cache, pce, entry)    JS_ATOMIC_DWORD_STORE(pce, entry)
-
-#else  /* !HAVE_ATOMIC_DWORD_ACCESS */
-
-#define PCE_LOAD(cache, pce, entry)                                           \
-    JS_BEGIN_MACRO                                                            \
-	uint32 _prefills;                                                     \
-	uint32 _fills = (cache)->fills;                                       \
-	do {                                                                  \
-	    /* Load until cache->fills is stable (see FILL macro below). */   \
-	    _prefills = _fills;                                               \
-	    (entry) = *(pce);                                                 \
-	} while ((_fills = (cache)->fills) != _prefills);                     \
-    JS_END_MACRO
-
-#define PCE_STORE(cache, pce, entry)                                          \
-    JS_BEGIN_MACRO                                                            \
-	do {                                                                  \
-	    /* Store until no racing collider stores half or all of pce. */   \
-	    *(pce) = (entry);                                                 \
-	} while (PCE_OBJECT(*pce) != PCE_OBJECT(entry) ||                     \
-		 PCE_PROPERTY(*pce) != PCE_PROPERTY(entry));                  \
-    JS_END_MACRO
-
-#endif /* !HAVE_ATOMIC_DWORD_ACCESS */
-
-#else  /* !JS_THREADSAFE */
-
-#define PCE_LOAD(cache, pce, entry)     ((entry) = *(pce))
-#define PCE_STORE(cache, pce, entry)    (*(pce) = (entry))
-
-#endif /* !JS_THREADSAFE */
-
-typedef union JSPropertyCacheEntry {
-    struct {
-	JSObject    *object;    /* weak link to object */
-	JSProperty  *property;  /* weak link to property, or not-found id */
-    } s;
-#ifdef HAVE_ATOMIC_DWORD_ACCESS
-    prdword align;
-#endif
-} JSPropertyCacheEntry;
-
-/* These may be called in lvalue or rvalue position. */
-#define PCE_OBJECT(entry)       ((entry).s.object)
-#define PCE_PROPERTY(entry)     ((entry).s.property)
-
-typedef struct JSPropertyCache {
-    JSPropertyCacheEntry table[PROPERTY_CACHE_SIZE];
-    JSBool               empty;
-    uint32               fills;
-    uint32               recycles;
-    uint32               tests;
-    uint32               misses;
-    uint32               flushes;
-} JSPropertyCache;
-
-/* Property-not-found lookup results are cached using this invalid pointer. */
-#define PROP_NOT_FOUND(obj,id)  ((JSProperty *) ((jsword)(id) | 1))
-#define PROP_NOT_FOUND_ID(prop) ((jsid) ((jsword)(prop) & ~1))
-#define PROP_FOUND(prop)        ((prop) && ((jsword)(prop) & 1) == 0)
-
-#define PROPERTY_CACHE_FILL(cx, cache, obj, id, prop)                         \
-    JS_BEGIN_MACRO                                                            \
-	uintN _hashIndex = (uintN)PROPERTY_CACHE_HASH(obj, id);               \
-	JSPropertyCache *_cache = (cache);                                    \
-	JSPropertyCacheEntry *_pce = &_cache->table[_hashIndex];              \
-	JSPropertyCacheEntry _entry;                                          \
-	JSProperty *_pce_prop;                                                \
-	PCE_LOAD(_cache, _pce, _entry);                                       \
-	_pce_prop = PCE_PROPERTY(_entry);                                     \
-	if (_pce_prop && _pce_prop != prop)                                   \
-	    _cache->recycles++;                                               \
-	PCE_OBJECT(_entry) = obj;                                             \
-	PCE_PROPERTY(_entry) = prop;                                          \
-	_cache->empty = JS_FALSE;                                             \
-	_cache->fills++;                                                      \
-	PCE_STORE(_cache, _pce, _entry);                                      \
-    JS_END_MACRO
-
-#define PROPERTY_CACHE_TEST(cache, obj, id, prop)                             \
-    JS_BEGIN_MACRO                                                            \
-	uintN _hashIndex = (uintN)PROPERTY_CACHE_HASH(obj, id);               \
-	JSPropertyCache *_cache = (cache);                                    \
-	JSPropertyCacheEntry *_pce = &_cache->table[_hashIndex];              \
-	JSPropertyCacheEntry _entry;                                          \
-	JSProperty *_pce_prop;                                                \
-	PCE_LOAD(_cache, _pce, _entry);                                       \
-	_pce_prop = PCE_PROPERTY(_entry);                                     \
-	_cache->tests++;                                                      \
-	if (_pce_prop &&                                                      \
-	    (((jsword)_pce_prop & 1)                                          \
-	     ? PROP_NOT_FOUND_ID(_pce_prop)                                   \
-	     : sym_id(((JSScopeProperty *)_pce_prop)->symbols)) == id &&      \
-	    PCE_OBJECT(_entry) == obj) {                                      \
-	    prop = _pce_prop;                                                 \
-	} else {                                                              \
-	    _cache->misses++;                                                 \
-	    prop = NULL;                                                      \
-	}                                                                     \
-    JS_END_MACRO
-
-extern void
-js_FlushPropertyCache(JSContext *cx);
-
-extern void
-js_FlushPropertyCacheByProp(JSContext *cx, JSProperty *prop);
-
-extern JS_FRIEND_API(jsval *)
-js_AllocStack(JSContext *cx, uintN nslots, void **markp);
-
-extern JS_FRIEND_API(void)
-js_FreeStack(JSContext *cx, void *mark);
-
-extern JSBool
-js_GetArgument(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
-
-extern JSBool
-js_SetArgument(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
-
-extern JSBool
-js_GetLocalVariable(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
-
-extern JSBool
-js_SetLocalVariable(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
-
-/*
- * NB: js_Invoke requires that cx is currently running JS (i.e., that cx->fp
- * is non-null).
- */
-extern JS_FRIEND_API(JSBool)
-js_Invoke(JSContext *cx, uintN argc, uintN flags);
-
-/*
- * Consolidated js_Invoke flags.  NB: JSINVOKE_CONSTRUCT must be 1 or JS_TRUE
- * (see js_Invoke's initialization of frame.constructing).
- */
-#define JSINVOKE_CONSTRUCT      0x1     /* construct object rather than call */
-#define JSINVOKE_INTERNAL       0x2     /* internal call, not from a script */
-
-/*
- * "Internal" calls may come from C or C++ code using a JSContext on which no
- * JS is running (!cx->fp), so they may need to push a dummy JSStackFrame.
- */
-#define js_InternalCall(cx,obj,fval,argc,argv,rval)                           \
-    js_InternalInvoke(cx, obj, fval, 0, argc, argv, rval)
-
-#define js_InternalConstruct(cx,obj,fval,argc,argv,rval)                      \
-    js_InternalInvoke(cx, obj, fval, JSINVOKE_CONSTRUCT, argc, argv, rval)
-
-extern JSBool
-js_InternalInvoke(JSContext *cx, JSObject *obj, jsval fval, uintN flags,
-                  uintN argc, jsval *argv, jsval *rval);
-
-extern JSBool
-js_Execute(JSContext *cx, JSObject *chain, JSScript *script, JSFunction *fun,
-	   JSStackFrame *down, uintN flags, jsval *result);
-
-extern JSBool
-js_Interpret(JSContext *cx, jsval *result);
-
-JS_END_EXTERN_C
-
-#endif /* jsinterp_h___ */

mozilla/js/src/jslibmath.h

@@ -1,292 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * By default all math calls go to fdlibm.  The defines for each platform
- * remap the math calls to native routines.
- */
-
-#ifndef _LIBMATH_H
-#define _LIBMATH_H
-
-#include <math.h>
-#include "jsconfig.h"
-#ifdef MOZILLA_CLIENT
-#include "platform.h"
-#endif
-
-/*
- * Define which platforms on which to use fdlibm.  Not used
- * by default since there can be problems with endian-ness and such.
- */
-
-#if defined(_WIN32) && !defined(__MWERKS__)
-#define JS_USE_FDLIBM_MATH 1
-
-#elif defined(SUNOS4)
-#define JS_USE_FDLIBM_MATH 1
-
-#elif defined(IRIX)
-#define JS_USE_FDLIBM_MATH 1
-
-#elif defined(SOLARIS)
-#define JS_USE_FDLIBM_MATH 1
-
-#elif defined(HPUX)
-#define JS_USE_FDLIBM_MATH 1
-
-#elif defined(linux)
-#define JS_USE_FDLIBM_MATH 1
-
-#elif defined(OSF1)
-/* Want to use some fdlibm functions but fdlibm broken on OSF1/alpha. */
-#define JS_USE_FDLIBM_MATH 0
-
-#elif defined(AIX)
-#define JS_USE_FDLIBM_MATH 1
-
-#else
-#define JS_USE_FDLIBM_MATH 0
-#endif
-
-#if !JS_USE_FDLIBM_MATH
-
-/*
- * Use system provided math routines.
- */
-
-#define fd_acos acos
-#define fd_asin asin
-#define fd_atan atan
-#define fd_atan2 atan2
-#define fd_ceil ceil
-#define fd_copysign copysign
-#define fd_cos cos
-#define fd_exp exp
-#define fd_fabs fabs
-#define fd_floor floor
-#define fd_fmod fmod
-#define fd_log log
-#define fd_pow pow
-#define fd_sin sin
-#define fd_sqrt sqrt
-#define fd_tan tan
-
-#else
-
-/*
- * Use math routines in fdlibm.
- */
-
-#undef __P
-#ifdef __STDC__
-#define __P(p)  p
-#else
-#define __P(p)  ()
-#endif
-
-#if defined _WIN32 || defined SUNOS4 
-
-#define fd_acos acos
-#define fd_asin asin
-#define fd_atan atan
-#define fd_cos cos
-#define fd_sin sin
-#define fd_tan tan
-#define fd_exp exp
-#define fd_log log
-#define fd_sqrt sqrt
-#define fd_ceil ceil
-#define fd_fabs fabs
-#define fd_floor floor
-#define fd_fmod fmod
-
-extern double fd_atan2 __P((double, double));
-extern double fd_copysign __P((double, double));
-
-#ifdef DEBUG
-extern double fd_pow __P((double, double));
-#else
-#define fd_pow pow
-#endif
-
-#elif defined IRIX
-
-#define fd_acos acos
-#define fd_asin asin
-#define fd_atan atan
-#define fd_exp exp
-#define fd_log log
-#define fd_log10 log10
-#define fd_sqrt sqrt
-#define fd_fabs fabs
-#define fd_floor floor
-#define fd_fmod fmod
-
-extern double fd_cos __P((double));
-extern double fd_sin __P((double));
-extern double fd_tan __P((double));
-extern double fd_atan2 __P((double, double));
-extern double fd_pow __P((double, double));
-extern double fd_ceil __P((double));
-extern double fd_copysign __P((double, double));
-
-#elif defined SOLARIS
-
-#define fd_atan atan
-#define fd_cos cos
-#define fd_sin sin
-#define fd_tan tan
-#define fd_exp exp
-#define fd_sqrt sqrt
-#define fd_ceil ceil
-#define fd_fabs fabs
-#define fd_floor floor
-#define fd_fmod fmod
-
-extern double fd_acos __P((double));
-extern double fd_asin __P((double));
-extern double fd_log __P((double));
-extern double fd_atan2 __P((double, double));
-extern double fd_pow __P((double, double));
-extern double fd_copysign __P((double, double));
-
-#elif defined HPUX
-
-#define fd_cos cos
-#define fd_sin sin
-#define fd_exp exp
-#define fd_sqrt sqrt
-#define fd_fabs fabs
-#define fd_floor floor
-#define fd_fmod fmod
-
-extern double fd_ceil __P((double));
-extern double fd_acos __P((double));
-extern double fd_log __P((double));
-extern double fd_atan2 __P((double, double));
-extern double fd_tan __P((double));
-extern double fd_pow __P((double, double));
-extern double fd_asin __P((double));
-extern double fd_atan __P((double));
-extern double fd_copysign __P((double, double));
-
-#elif defined(linux)
-
-#define fd_atan atan
-#define fd_atan2 atan2
-#define fd_ceil ceil
-#define fd_cos cos
-#define fd_fabs fabs
-#define fd_floor floor
-#define fd_fmod fmod
-#define fd_sin sin
-#define fd_sqrt sqrt
-#define fd_tan tan
-#define fd_copysign copysign
-
-extern double fd_asin __P((double));
-extern double fd_acos __P((double));
-extern double fd_exp __P((double));
-extern double fd_log __P((double));
-extern double fd_pow __P((double, double));
-
-#elif defined(OSF1)
-
-#define fd_acos acos
-#define fd_asin asin
-#define fd_atan atan
-#define fd_copysign copysign
-#define fd_cos cos
-#define fd_exp exp
-#define fd_fabs fabs
-#define fd_fmod fmod
-#define fd_sin sin
-#define fd_sqrt sqrt
-#define fd_tan tan
-
-extern double fd_atan2 __P((double, double));
-extern double fd_ceil __P((double));
-extern double fd_floor __P((double));
-extern double fd_log __P((double));
-extern double fd_pow __P((double, double));
-
-#elif defined(AIX)
-
-#define fd_acos acos
-#define fd_asin asin
-#define fd_atan2 atan2
-#define fd_copysign copysign
-#define fd_cos cos
-#define fd_exp exp
-#define fd_fabs fabs
-#define fd_floor floor
-#define fd_fmod fmod
-#define fd_log log
-#define fd_sin sin
-#define fd_sqrt sqrt
-
-extern double fd_atan __P((double));
-extern double fd_ceil __P((double));
-extern double fd_pow __P((double,double));
-extern double fd_tan __P((double));
-
-#else /* other platform.. generic paranoid slow fdlibm */
-
-extern double fd_acos __P((double));
-extern double fd_asin __P((double));
-extern double fd_atan __P((double));
-extern double fd_cos __P((double));
-extern double fd_sin __P((double));
-extern double fd_tan __P((double));
- 
-extern double fd_exp __P((double));
-extern double fd_log __P((double));
-extern double fd_sqrt __P((double));
-
-extern double fd_ceil __P((double));
-extern double fd_fabs __P((double));
-extern double fd_floor __P((double));
-extern double fd_fmod __P((double, double));
-
-extern double fd_atan2 __P((double, double));
-extern double fd_pow __P((double, double));
-extern double fd_copysign __P((double, double));
-
-#endif
-
-#endif /* JS_USE_FDLIBM_MATH */
-
-#endif /* _LIBMATH_H */
-

mozilla/js/src/jslock.c

@@ -1,757 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifdef JS_THREADSAFE
-
-/*
- * JS locking stubs.
- */
-#include "jsstddef.h"
-#include <stdlib.h>
-#include "jspubtd.h"
-#include "prthread.h"
-#include "pratom.h"
-#include "jsutil.h" /* Added by JSIFY */
-#include "jscntxt.h"
-#include "jsscope.h"
-#include "jspubtd.h"
-#include "jslock.h"
-
-#ifndef NSPR_LOCK
-#include <memory.h>
-#endif
-
-static PRLock **_global_locks;
-static int _nr_of_globals=1;
-
-static void
-js_LockGlobal(void *id)
-{
-    int i = ((int)id/4)%_nr_of_globals;
-    PR_Lock(_global_locks[i]);
-}
-
-static void
-js_UnlockGlobal(void *id)
-{
-    int i = ((int)id/4)%_nr_of_globals;
-    PR_Unlock(_global_locks[i]);
-}
-
-#define ReadWord(W) (W)
-#define AtomicAddBody(P,I)                                                    \
-    jsword n;                                                                 \
-    do {                                                                      \
-	n = ReadWord(*(P));                                                   \
-    } while (!js_CompareAndSwap(P, n, n + I))
-
-/* Exclude Alpha NT. */
-#if defined(_WIN32) && defined(_M_IX86) && !defined(NSPR_LOCK)
-#pragma warning( disable : 4035 )
-
-JS_INLINE int
-js_CompareAndSwap(jsword *w, jsword ov, jsword nv)
-{
-    __asm {
-		mov eax,ov
-		mov ecx, nv
-		mov ebx, w
-		lock cmpxchg [ebx], ecx
-		sete al
-		and eax,1h
-	}
-}
-
-#elif defined(SOLARIS) && defined(sparc) && !defined(NSPR_LOCK)
-
-#ifndef ULTRA_SPARC
-JS_INLINE jsword
-js_ReadWord(jsword *p)
-{
-    jsword n;
-    while ((n = *p) == -1)
-	;
-    return n;
-}
-
-#undef ReadWord
-#define ReadWord(W) js_ReadWord(&(W))
-
-static PRLock *_counter_lock;
-#define UsingCounterLock 1
-
-#undef AtomicAddBody
-#define AtomicAddBody(P,I)                                                    \
-    PR_Lock(_counter_lock);                                                   \
-    *(P) += I;                                                                \
-    PR_Unlock(_counter_lock)
-
-#endif /* !ULTRA_SPARC */
-
-JS_INLINE int
-js_CompareAndSwap(jsword *w, jsword ov, jsword nv)
-{
-#if defined(__GNUC__)
-    unsigned int res;
-#ifndef ULTRA_SPARC
-    JS_ASSERT(nv != -1);
-    asm volatile ("\
-stbar\n\
-swap [%1],%4\n\
-1:  cmp %4,-1\n\
-be,a 1b\n\
-swap [%1],%4\n\
-cmp %2,%4\n\
-be,a 2f\n\
-swap [%1],%3\n\
-swap [%1],%4\n\
-ba 3f\n\
-mov 0,%0\n\
-2:  mov 1,%0\n\
-3:"
-		  : "=r" (res)
-		  : "r" (w), "r" (ov), "r" (nv), "r" (-1));
-#else /* ULTRA_SPARC */
-    JS_ASSERT(ov != nv);
-    asm volatile ("\
-stbar\n\
-cas [%1],%2,%3\n\
-cmp %2,%3\n\
-be,a 1f\n\
-mov 1,%0\n\
-mov 0,%0\n\
-1:"
-		  : "=r" (res)
-		  : "r" (w), "r" (ov), "r" (nv));
-#endif /* ULTRA_SPARC */
-    return (int)res;
-#else /* !__GNUC__ */
-    extern int compare_and_swap(jsword*,jsword,jsword);
-#ifndef ULTRA_SPARC
-    JS_ASSERT(nv != -1);
-#else
-    JS_ASSERT(ov != nv);
-#endif
-    return compare_and_swap(w,ov,nv);
-#endif
-}
-
-#elif defined(AIX) && !defined(NSPR_LOCK)
-#include <sys/atomic_op.h>
-
-JS_INLINE int
-js_CompareAndSwap(jsword *w, jsword ov, jsword nv)
-{
-    return !_check_lock((atomic_p)w,ov,nv);
-}
-
-#else
-
-static PRLock *_counter_lock;
-#define UsingCounterLock 1
-
-#undef AtomicAddBody
-#define AtomicAddBody(P,I)                                                    \
-    PR_Lock(_counter_lock);                                                   \
-    *(P) += I;                                                                \
-    PR_Unlock(_counter_lock)
-
-static PRLock *_compare_and_swap_lock;
-#define UsingCompareAndSwapLock 1
-
-JS_INLINE int
-js_CompareAndSwap(jsword *w, jsword ov, jsword nv)
-{
-    int res = 0;
-
-    PR_Lock(_compare_and_swap_lock);
-    if (*w == ov) {
-      *w = nv;
-      res = 1;
-    }
-    PR_Unlock(_compare_and_swap_lock);
-    return res;
-}
-
-#endif /* arch-tests */
-
-JS_INLINE void
-js_AtomicAdd(jsword *p, jsword i)
-{
-    AtomicAddBody(p,i);
-}
-
-jsword
-js_CurrentThreadId()
-{
-    return CurrentThreadId();
-}
-
-void
-js_NewLock(JSThinLock *tl)
-{
-#ifdef NSPR_LOCK
-    tl->owner = 0;
-    tl->fat = (JSFatLock*)JS_NEW_LOCK();
-#else
-    memset(tl, 0, sizeof(JSThinLock));
-#endif
-}
-
-void
-js_DestroyLock(JSThinLock *tl)
-{
-#ifdef NSPR_LOCK
-    tl->owner = 0xdeadbeef;
-    JS_DESTROY_LOCK(((JSLock*)tl->fat));
-#else
-    JS_ASSERT(tl->owner == 0);
-    JS_ASSERT(tl->fat == NULL);
-#endif
-}
-
-static void js_Dequeue(JSThinLock *);
-
-JS_INLINE jsval
-js_GetSlotWhileLocked(JSContext *cx, JSObject *obj, uint32 slot)
-{
-    jsval v;
-#ifndef NSPR_LOCK
-    JSScope *scope = OBJ_SCOPE(obj);
-    JSThinLock *tl = &scope->lock;
-    jsword me = cx->thread;
-#endif
-
-    JS_ASSERT(obj->slots && slot < obj->map->freeslot);
-#ifndef NSPR_LOCK
-    JS_ASSERT(me == CurrentThreadId());
-    if (js_CompareAndSwap(&tl->owner, 0, me)) {
-	if (scope == OBJ_SCOPE(obj)) {
-	    v = obj->slots[slot];
-	    if (!js_CompareAndSwap(&tl->owner, me, 0)) {
-		scope->count = 1;
-		js_UnlockObj(cx,obj);
-	    }
-	    return v;
-	}
-	if (!js_CompareAndSwap(&tl->owner, me, 0))
-	    js_Dequeue(tl);
-    }
-    else if (Thin_RemoveWait(ReadWord(tl->owner)) == me) {
-	return obj->slots[slot];
-    }
-#endif
-    js_LockObj(cx,obj);
-    v = obj->slots[slot];
-    js_UnlockObj(cx,obj);
-    return v;
-}
-
-JS_INLINE void
-js_SetSlotWhileLocked(JSContext *cx, JSObject *obj, uint32 slot, jsval v)
-{
-#ifndef NSPR_LOCK
-    JSScope *scope = OBJ_SCOPE(obj);
-    JSThinLock *tl = &scope->lock;
-    jsword me = cx->thread;
-#endif
-
-    JS_ASSERT(obj->slots && slot < obj->map->freeslot);
-#ifndef NSPR_LOCK
-    JS_ASSERT(me == CurrentThreadId());
-    if (js_CompareAndSwap(&tl->owner, 0, me)) {
-	if (scope == OBJ_SCOPE(obj)) {
-	    obj->slots[slot] = v;
-	    if (!js_CompareAndSwap(&tl->owner, me, 0)) {
-		scope->count = 1;
-		js_UnlockObj(cx,obj);
-	    }
-	    return;
-	}
-	if (!js_CompareAndSwap(&tl->owner, me, 0))
-	    js_Dequeue(tl);
-    }
-    else if (Thin_RemoveWait(ReadWord(tl->owner)) == me) {
-	obj->slots[slot] = v;
-	return;
-    }
-#endif
-    js_LockObj(cx,obj);
-    obj->slots[slot] = v;
-    js_UnlockObj(cx,obj);
-}
-
-static JSFatLock *
-mallocFatlock()
-{
-    JSFatLock *fl = (JSFatLock *)malloc(sizeof(JSFatLock)); /* for now */
-    if (!fl) return NULL;
-    fl->susp = 0;
-    fl->next = NULL;
-    fl->prev = NULL;
-    fl->slock = PR_NewLock();
-    fl->svar = PR_NewCondVar(fl->slock);
-    return fl;
-}
-
-static void
-freeFatlock(JSFatLock *fl)
-{
-    PR_DestroyLock(fl->slock);
-    PR_DestroyCondVar(fl->svar);
-    free(fl);
-}
-
-static JSFatLock *
-listOfFatlocks(int l)
-{
-    JSFatLock *m;
-    JSFatLock *m0;
-    int i;
-
-    JS_ASSERT(l>0);
-    m0 = m = mallocFatlock();
-    for (i=1; i<l; i++) {
-        m->next = mallocFatlock();
-        m = m->next;
-    }
-    return m0;
-}
-
-static void
-deleteListOfFatlocks(JSFatLock *m)
-{
-    JSFatLock *m0;
-    for (; m; m=m0) {
-	m0 = m->next;
-	freeFatlock(m);
-    }
-}
-
-static JSFatLockTable* _fl_tables;
-
-static JSFatLock *
-allocateFatlock(void *id)
-{
-    JSFatLock *m;
-
-    int i = ((int)id/4)%_nr_of_globals;
-    if (_fl_tables[i].free == NULL) {
-  #ifdef DEBUG
-        printf("Ran out of fat locks!\n");
-  #endif
-        _fl_tables[i].free = listOfFatlocks(10);
-    }
-    m = _fl_tables[i].free;
-    _fl_tables[i].free = m->next;
-    _fl_tables[i].free->prev = NULL;
-    m->susp = 0;
-    m->next = _fl_tables[i].taken;
-    m->prev = NULL;
-    if (_fl_tables[i].taken != NULL)
-        _fl_tables[i].taken->prev = m;
-    _fl_tables[i].taken = m;
-    return m;
-}
-
-static void
-deallocateFatlock(JSFatLock *m, void *id)
-{
-    int i = ((int)id/4)%_nr_of_globals;
-    if (m == NULL)
-	return;
-    if (m->prev != NULL)
-	m->prev->next = m->next;
-    if (m->next != NULL)
-	m->next->prev = m->prev;
-    if (m == _fl_tables[i].taken)
-	_fl_tables[i].taken = m->next;
-    m->next = _fl_tables[i].free;
-    _fl_tables[i].free = m;
-}
-
-int
-js_SetupLocks(int l, int g)
-{
-    int i;
-
-    if (_global_locks)
-        return 1;
-    if (l > 10000 || l < 0)       /* l equals number of initially allocated fat locks */
-#ifdef DEBUG
-        printf("Bad number %d in js_SetupLocks()!\n",l);
-#endif
-    if (g > 100 || g < 0)       /* g equals number of global locks */
-#ifdef DEBUG
-        printf("Bad number %d in js_SetupLocks()!\n",l);
-#endif
-    _nr_of_globals = g;
-    _global_locks = (PRLock**)malloc(_nr_of_globals * sizeof(PRLock*));
-    JS_ASSERT(_global_locks != NULL);
-    for (i=0; i<_nr_of_globals; i++) {
-        _global_locks[i] = PR_NewLock();
-        JS_ASSERT(_global_locks[i] != NULL);
-    }
-#ifdef UsingCounterLock
-    _counter_lock = PR_NewLock();
-    JS_ASSERT(_counter_lock);
-#endif
-#ifdef UsingCompareAndSwapLock
-    _compare_and_swap_lock = PR_NewLock();
-    JS_ASSERT(_compare_and_swap_lock);
-#endif
-    _fl_tables = (JSFatLockTable*)malloc(_nr_of_globals * sizeof(JSFatLockTable));
-    JS_ASSERT(_fl_tables != NULL);
-    for (i=0; i<_nr_of_globals; i++) {
-        _fl_tables[i].free = listOfFatlocks(l);
-        _fl_tables[i].taken = NULL;
-    }
-    return 1;
-}
-
-void
-js_CleanupLocks()
-{
-    int i;
-
-    if (_global_locks != NULL) {
-        for (i=0; i<_nr_of_globals; i++) {
-            PR_DestroyLock(_global_locks[i]);
-            deleteListOfFatlocks(_fl_tables[i].free);
-            _fl_tables[i].free = NULL;
-            deleteListOfFatlocks(_fl_tables[i].taken);
-            _fl_tables[i].taken = NULL;
-        }
-        _global_locks = NULL;
-#ifdef UsingCounterLock
-        PR_DestroyLock(_counter_lock);
-        _counter_lock = NULL;
-#endif
-#ifdef UsingCompareAndSwapLock
-        PR_DestroyLock(_compare_and_swap_lock);
-        _compare_and_swap_lock = NULL;
-#endif
-    }
-}
-
-JS_PUBLIC_API(void)
-js_InitContextForLocking(JSContext *cx)
-{
-    cx->thread = CurrentThreadId();
-    JS_ASSERT(Thin_GetWait(cx->thread) == 0);
-}
-
-/*
-  Fast locking and unlocking is implemented by delaying the
-  allocation of a system lock (fat lock) until contention. As long as
-  a locking thread A runs uncontended, the lock is represented solely
-  by storing A's identity in the object being locked.
-
-  If another thread B tries to lock the object currently locked by A,
-  B is enqueued into a fat lock structure (which might have to be
-  allocated and pointed to by the object), and suspended using NSPR
-  conditional variables (wait).  A wait bit (Bacon bit) is set in the
-  lock word of the object, signalling to A that when releasing the
-  lock, B must be dequeued and notified.
-
-  The basic operation of the locking primitives (js_Lock(),
-  js_Unlock(), js_Enqueue(), and js_Dequeue()) is
-  compare-and-swap. Hence, when locking into p, if
-  compare-and-swap(p,NULL,me) succeeds this implies that p is
-  unlocked.  Similarly, when unlocking p, if
-  compare-and-swap(p,me,NULL) succeeds this implies that p is
-  uncontended (no one is waiting because the wait bit is not set).
-
-  When dequeueing, the lock is released, and one of the threads
-  suspended on the lock is notified.  If other threads still are
-  waiting, the wait bit is kept (in js_Enqueue), and if not, the fat
-  lock is deallocated.
-
-  The functions js_Enqueue, js_Dequeque, js_SuspendThread, and js_ResumeThread
-  are serialized using a global lock. For further
-  scalability an array of global locks is used, which is index modulo the
-  thin lock pointer.
-*/
-
-/* (i) global lock is held
-   (ii) fl->susp >= 0
-*/
-static int
-js_SuspendThread(JSThinLock *tl)
-{
-    JSFatLock *fl;
-    JSStatus stat;
-
-    if (tl->fat == NULL)
-        fl = tl->fat = allocateFatlock(tl);
-    else
-        fl = tl->fat;
-    JS_ASSERT(fl->susp >= 0);
-    fl->susp++;
-    PR_Lock(fl->slock);
-    js_UnlockGlobal(tl);
-    stat = (JSStatus)PR_WaitCondVar(fl->svar,PR_INTERVAL_NO_TIMEOUT);
-    JS_ASSERT(stat != JS_FAILURE);
-    PR_Unlock(fl->slock);
-    js_LockGlobal(tl);
-    fl->susp--;
-    if (fl->susp == 0) {
-        deallocateFatlock(fl,tl);
-        tl->fat = NULL;
-    }
-    return tl->fat == NULL;
-}
-
-/* (i) global lock is held
-   (ii) fl->susp > 0
-*/
-static void
-js_ResumeThread(JSThinLock *tl)
-{
-    JSFatLock *fl = tl->fat;
-    JSStatus stat;
-
-    JS_ASSERT(fl != NULL);
-    JS_ASSERT(fl->susp > 0);
-    PR_Lock(fl->slock);
-    js_UnlockGlobal(tl);
-    stat = (JSStatus)PR_NotifyCondVar(fl->svar);
-    JS_ASSERT(stat != JS_FAILURE);
-    PR_Unlock(fl->slock);
-}
-
-static void
-js_Enqueue(JSThinLock *tl, jsword me)
-{
-    jsword o, n;
-
-    js_LockGlobal(tl);
-    while (1) {
-	o = ReadWord(tl->owner);
-	n = Thin_SetWait(o);
-	if (o != 0 && js_CompareAndSwap(&tl->owner,o,n)) {
-	    if (js_SuspendThread(tl))
-                me = Thin_RemoveWait(me);
-	    else
-		me = Thin_SetWait(me);
-	}
-	else if (js_CompareAndSwap(&tl->owner,0,me)) {
-            js_UnlockGlobal(tl);
-	    return;
-	}
-    }
-}
-
-static void
-js_Dequeue(JSThinLock *tl)
-{
-    int o;
-
-    js_LockGlobal(tl);
-    o = ReadWord(tl->owner);
-    JS_ASSERT(Thin_GetWait(o) != 0);
-    JS_ASSERT(tl->fat != NULL);
-    if (!js_CompareAndSwap(&tl->owner,o,0)) /* release it */
-	JS_ASSERT(0);
-    js_ResumeThread(tl);
-}
-
-JS_INLINE void
-js_Lock(JSThinLock *tl, jsword me)
-{
-    JS_ASSERT(me == CurrentThreadId());
-    if (js_CompareAndSwap(&tl->owner, 0, me))
-	return;
-    if (Thin_RemoveWait(ReadWord(tl->owner)) != me)
-	js_Enqueue(tl, me);
-#ifdef DEBUG
-    else
-	JS_ASSERT(0);
-#endif
-}
-
-JS_INLINE void
-js_Unlock(JSThinLock *tl, jsword me)
-{
-    JS_ASSERT(me == CurrentThreadId());
-    if (js_CompareAndSwap(&tl->owner, me, 0))
-	return;
-    if (Thin_RemoveWait(ReadWord(tl->owner)) == me)
-	js_Dequeue(tl);
-#ifdef DEBUG
-    else
-	JS_ASSERT(0);
-#endif
-}
-
-void
-js_LockRuntime(JSRuntime *rt)
-{
-    PR_Lock(rt->rtLock);
-#ifdef DEBUG
-    rt->rtLockOwner = CurrentThreadId();
-#endif
-}
-
-void
-js_UnlockRuntime(JSRuntime *rt)
-{
-#ifdef DEBUG
-    rt->rtLockOwner = 0;
-#endif
-    PR_Unlock(rt->rtLock);
-}
-
-static JS_INLINE void
-js_LockScope1(JSContext *cx, JSScope *scope, jsword me)
-{
-    JSThinLock *tl;
-
-    if (Thin_RemoveWait(ReadWord(scope->lock.owner)) == me) {
-	JS_ASSERT(scope->count > 0);
-	scope->count++;
-    } else {
-	tl = &scope->lock;
-	JS_LOCK0(tl,me);
-	JS_ASSERT(scope->count == 0);
-	scope->count = 1;
-    }
-}
-
-void
-js_LockScope(JSContext *cx, JSScope *scope)
-{
-    JS_ASSERT(cx->thread == CurrentThreadId());
-    js_LockScope1(cx,scope,cx->thread);
-}
-
-void
-js_UnlockScope(JSContext *cx, JSScope *scope)
-{
-    jsword me = cx->thread;
-    JSThinLock *tl;
-
-    JS_ASSERT(scope->count > 0);
-    if (Thin_RemoveWait(ReadWord(scope->lock.owner)) != me) {
-	JS_ASSERT(0);
-	return;
-    }
-    if (--scope->count == 0) {
-	tl = &scope->lock;
-	JS_UNLOCK0(tl,me);
-    }
-}
-
-void
-js_TransferScopeLock(JSContext *cx, JSScope *oldscope, JSScope *newscope)
-{
-    jsword me;
-    JSThinLock *tl;
-
-    JS_ASSERT(JS_IS_SCOPE_LOCKED(newscope));
-
-    /*
-     * If the last reference to oldscope went away, newscope needs no lock
-     * state update.
-     */
-    if (!oldscope)
-	return;
-    JS_ASSERT(JS_IS_SCOPE_LOCKED(oldscope));
-
-    /*
-     * Transfer oldscope's entry count to newscope, as it will be unlocked
-     * now via JS_UNLOCK_OBJ(cx,obj) calls made while we unwind the C stack
-     * from the current point (under js_GetMutableScope).
-     */
-    newscope->count = oldscope->count;
-
-    /*
-     * Reset oldscope's lock state so that it is completely unlocked.
-     */
-    oldscope->count = 0;
-    tl = &oldscope->lock;
-    me = cx->thread;
-    JS_UNLOCK0(tl,me);
-}
-
-void
-js_LockObj(JSContext *cx, JSObject *obj)
-{
-    JSScope *scope;
-    jsword me = cx->thread;
-    JS_ASSERT(me == CurrentThreadId());
-    for (;;) {
-        scope = OBJ_SCOPE(obj);
-        js_LockScope1(cx, scope, me);
-
-        /* If obj still has this scope, we're done. */
-        if (scope == OBJ_SCOPE(obj))
-            return;
-
-        /* Lost a race with a mutator; retry with obj's new scope. */
-        js_UnlockScope(cx, scope);
-    }
-}
-
-void
-js_UnlockObj(JSContext *cx, JSObject *obj)
-{
-    js_UnlockScope(cx, OBJ_SCOPE(obj));
-}
-
-#ifdef DEBUG
-JSBool
-js_IsRuntimeLocked(JSRuntime *rt)
-{
-    return CurrentThreadId() == rt->rtLockOwner;
-}
-
-JSBool
-js_IsObjLocked(JSObject *obj)
-{
-    JSScope *scope = OBJ_SCOPE(obj);
-
-    return MAP_IS_NATIVE(&scope->map) &&
-           CurrentThreadId() == Thin_RemoveWait(ReadWord(scope->lock.owner));
-}
-
-JSBool
-js_IsScopeLocked(JSScope *scope)
-{
-    return CurrentThreadId() == Thin_RemoveWait(ReadWord(scope->lock.owner));
-}
-#endif
-
-#undef ReadWord
-#endif /* JS_THREADSAFE */

mozilla/js/src/jslock.h

@@ -1,229 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-#ifndef jslock_h__
-#define jslock_h__
-
-#ifdef JS_THREADSAFE
-
-#include "jstypes.h"
-#include "prlock.h"
-#include "prcvar.h"
-#include "jshash.h" /* Added by JSIFY */
-
-#define Thin_GetWait(W) ((jsword)(W) & 0x1)
-#define Thin_SetWait(W) ((jsword)(W) | 0x1)
-#define Thin_RemoveWait(W) ((jsword)(W) & ~0x1)
-
-typedef struct JSFatLock {
-    int susp;
-    PRLock* slock;
-    PRCondVar* svar;
-    struct JSFatLock *next;
-    struct JSFatLock *prev;
-} JSFatLock;
-
-typedef struct JSThinLock {
-  jsword owner;
-  JSFatLock *fat;
-} JSThinLock;
-
-typedef PRLock JSLock;
-
-typedef struct JSFatLockTable {
-    JSFatLock *free;
-    JSFatLock *taken;
-} JSFatLockTable;
-
-#define JS_ATOMIC_ADDREF(p, i) js_AtomicAdd(p,i)
-
-#define CurrentThreadId()           (jsword)PR_GetCurrentThread()
-#define JS_CurrentThreadId()        js_CurrentThreadId()
-#define JS_NEW_LOCK()               PR_NewLock()
-#define JS_DESTROY_LOCK(l)          PR_DestroyLock(l)
-#define JS_ACQUIRE_LOCK(l)          PR_Lock(l)
-#define JS_RELEASE_LOCK(l)          PR_Unlock(l)
-#define JS_LOCK0(P,M) js_Lock(P,M)
-#define JS_UNLOCK0(P,M) js_Unlock(P,M)
-
-#define JS_NEW_CONDVAR(l)           PR_NewCondVar(l)
-#define JS_DESTROY_CONDVAR(cv)      PR_DestroyCondVar(cv)
-#define JS_WAIT_CONDVAR(cv,to)      PR_WaitCondVar(cv,to)
-#define JS_NO_TIMEOUT               PR_INTERVAL_NO_TIMEOUT
-#define JS_NOTIFY_CONDVAR(cv)       PR_NotifyCondVar(cv)
-#define JS_NOTIFY_ALL_CONDVAR(cv)   PR_NotifyAllCondVar(cv)
-
-#ifdef DEBUG
-#include "jsscope.h"
-
-#define _SET_OBJ_INFO(obj,f,l)                                                \
-    _SET_SCOPE_INFO(OBJ_SCOPE(obj),f,l)
-
-#define _SET_SCOPE_INFO(scope,f,l)                                            \
-    (JS_ASSERT(scope->count > 0 && scope->count <= 4),                        \
-     scope->file[scope->count-1] = f,                                         \
-     scope->line[scope->count-1] = l)
-#endif /* DEBUG */
-
-#define JS_LOCK_RUNTIME(rt)         js_LockRuntime(rt)
-#define JS_UNLOCK_RUNTIME(rt)       js_UnlockRuntime(rt)
-#define JS_LOCK_OBJ(cx,obj)         (js_LockObj(cx, obj),                    \
-				      _SET_OBJ_INFO(obj,__FILE__,__LINE__))
-#define JS_UNLOCK_OBJ(cx,obj)       js_UnlockObj(cx, obj)
-#define JS_LOCK_SCOPE(cx,scope)     (js_LockScope(cx, scope),                \
-				      _SET_SCOPE_INFO(scope,__FILE__,__LINE__))
-#define JS_UNLOCK_SCOPE(cx,scope)   js_UnlockScope(cx, scope)
-#define JS_TRANSFER_SCOPE_LOCK(cx, scope, newscope) js_TransferScopeLock(cx, scope, newscope)
-
-extern jsword js_CurrentThreadId();
-extern JS_INLINE void js_Lock(JSThinLock *, jsword);
-extern JS_INLINE void js_Unlock(JSThinLock *, jsword);
-extern int js_CompareAndSwap(jsword *, jsword, jsword);
-extern void js_AtomicAdd(jsword*, jsword);
-extern void js_LockRuntime(JSRuntime *rt);
-extern void js_UnlockRuntime(JSRuntime *rt);
-extern void js_LockObj(JSContext *cx, JSObject *obj);
-extern void js_UnlockObj(JSContext *cx, JSObject *obj);
-extern void js_LockScope(JSContext *cx, JSScope *scope);
-extern void js_UnlockScope(JSContext *cx, JSScope *scope);
-extern int js_SetupLocks(int,int);
-extern void js_CleanupLocks();
-extern JS_PUBLIC_API(void) js_InitContextForLocking(JSContext *);
-extern void js_TransferScopeLock(JSContext *, JSScope *, JSScope *);
-extern JS_PUBLIC_API(jsval) js_GetSlotWhileLocked(JSContext *, JSObject *, uint32);
-extern JS_PUBLIC_API(void) js_SetSlotWhileLocked(JSContext *, JSObject *, uint32, jsval);
-extern void js_NewLock(JSThinLock *);
-extern void js_DestroyLock(JSThinLock *);
-
-#ifdef DEBUG
-
-#define JS_IS_RUNTIME_LOCKED(rt)    js_IsRuntimeLocked(rt)
-#define JS_IS_OBJ_LOCKED(obj)       js_IsObjLocked(obj)
-#define JS_IS_SCOPE_LOCKED(scope)   js_IsScopeLocked(scope)
-
-extern JSBool js_IsRuntimeLocked(JSRuntime *rt);
-extern JSBool js_IsObjLocked(JSObject *obj);
-extern JSBool js_IsScopeLocked(JSScope *scope);
-
-#else
-
-#define JS_IS_RUNTIME_LOCKED(rt)    0
-#define JS_IS_OBJ_LOCKED(obj)       1
-#define JS_IS_SCOPE_LOCKED(scope)   1
-
-#endif /* DEBUG */
-
-#define JS_LOCK_OBJ_VOID(cx, obj, e)                                          \
-    JS_BEGIN_MACRO                                                            \
-	js_LockObj(cx, obj);                                                 \
-	e;                                                                    \
-	js_UnlockObj(cx, obj);                                               \
-    JS_END_MACRO
-
-#define JS_LOCK_VOID(cx, e)                                                   \
-    JS_BEGIN_MACRO                                                            \
-	JSRuntime *_rt = (cx)->runtime;                                       \
-	JS_LOCK_RUNTIME_VOID(_rt, e);                                         \
-    JS_END_MACRO
-
-#if defined(JS_USE_ONLY_NSPR_LOCKS) || !(defined(_WIN32) || defined(SOLARIS) || defined(AIX))
-
-#undef JS_LOCK0
-#undef JS_UNLOCK0
-#define JS_LOCK0(P,M) JS_ACQUIRE_LOCK(((JSLock*)(P)->fat)); (P)->owner = (M)
-#define JS_UNLOCK0(P,M) (P)->owner = 0; JS_RELEASE_LOCK(((JSLock*)(P)->fat))
-#define NSPR_LOCK 1
-
-#endif /* arch-tests */
-
-#else  /* !JS_THREADSAFE */
-
-#define JS_ATOMIC_ADDREF(p,i)       (*(p) += i)
-
-#define JS_CurrentThreadId() 0
-#define JS_NEW_LOCK()               NULL
-#define JS_DESTROY_LOCK(l)          ((void)0)
-#define JS_ACQUIRE_LOCK(l)          ((void)0)
-#define JS_RELEASE_LOCK(l)          ((void)0)
-#define JS_LOCK0(P,M)                ((void)0)
-#define JS_UNLOCK0(P,M)              ((void)0)
-
-#define JS_NEW_CONDVAR(l)           NULL
-#define JS_DESTROY_CONDVAR(cv)      ((void)0)
-#define JS_WAIT_CONDVAR(cv,to)      ((void)0)
-#define JS_NOTIFY_CONDVAR(cv)       ((void)0)
-#define JS_NOTIFY_ALL_CONDVAR(cv)   ((void)0)
-
-#define JS_LOCK_RUNTIME(rt)         ((void)0)
-#define JS_UNLOCK_RUNTIME(rt)       ((void)0)
-#define JS_LOCK_OBJ(cx,obj)         ((void)0)
-#define JS_UNLOCK_OBJ(cx,obj)       ((void)0)
-#define JS_LOCK_OBJ_VOID(cx,obj,e)  (e)
-#define JS_LOCK_SCOPE(cx,scope)     ((void)0)
-#define JS_UNLOCK_SCOPE(cx,scope)   ((void)0)
-#define JS_TRANSFER_SCOPE_LOCK(c,o,n) ((void)0)
-
-#define JS_IS_RUNTIME_LOCKED(rt)    1
-#define JS_IS_OBJ_LOCKED(obj)       1
-#define JS_IS_SCOPE_LOCKED(scope)   1
-#define JS_LOCK_VOID(cx, e)         JS_LOCK_RUNTIME_VOID((cx)->runtime, e)
-
-#endif /* !JS_THREADSAFE */
-
-#define JS_LOCK_RUNTIME_VOID(rt,e)                                            \
-    JS_BEGIN_MACRO                                                            \
-	JS_LOCK_RUNTIME(rt);                                                  \
-	e;                                                                    \
-	JS_UNLOCK_RUNTIME(rt);                                                \
-    JS_END_MACRO
-
-#define JS_LOCK_GC(rt)              JS_ACQUIRE_LOCK((rt)->gcLock)
-#define JS_UNLOCK_GC(rt)            JS_RELEASE_LOCK((rt)->gcLock)
-#define JS_LOCK_GC_VOID(rt,e)       (JS_LOCK_GC(rt), (e), JS_UNLOCK_GC(rt))
-#define JS_AWAIT_GC_DONE(rt)        JS_WAIT_CONDVAR((rt)->gcDone, JS_NO_TIMEOUT)
-#define JS_NOTIFY_GC_DONE(rt)       JS_NOTIFY_ALL_CONDVAR((rt)->gcDone)
-#define JS_AWAIT_REQUEST_DONE(rt)   JS_WAIT_CONDVAR((rt)->requestDone,        \
-						    JS_NO_TIMEOUT)
-#define JS_NOTIFY_REQUEST_DONE(rt)  JS_NOTIFY_CONDVAR((rt)->requestDone)
-
-#define JS_LOCK(P,CX) JS_LOCK0(P,(CX)->thread)
-#define JS_UNLOCK(P,CX) JS_UNLOCK0(P,(CX)->thread)
-
-#ifndef _SET_OBJ_INFO
-#define _SET_OBJ_INFO(obj,f,l)      ((void)0)
-#endif
-#ifndef _SET_SCOPE_INFO
-#define _SET_SCOPE_INFO(scope,f,l)  ((void)0)
-#endif
-
-#endif /* jslock_h___ */

mozilla/js/src/jslog2.c

@@ -1,78 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#include "jsbit.h"
-
-/*
-** Compute the log of the least power of 2 greater than or equal to n
-*/
-JS_PUBLIC_API(JSIntn) JS_CeilingLog2(JSUint32 n)
-{
-    JSIntn log2 = 0;
-
-    if (n & (n-1))
-	log2++;
-    if (n >> 16)
-	log2 += 16, n >>= 16;
-    if (n >> 8)
-	log2 += 8, n >>= 8;
-    if (n >> 4)
-	log2 += 4, n >>= 4;
-    if (n >> 2)
-	log2 += 2, n >>= 2;
-    if (n >> 1)
-	log2++;
-    return log2;
-}
-
-/*
-** Compute the log of the greatest power of 2 less than or equal to n.
-** This really just finds the highest set bit in the word.
-*/
-JS_PUBLIC_API(JSIntn) JS_FloorLog2(JSUint32 n)
-{
-    JSIntn log2 = 0;
-
-    if (n >> 16)
-	log2 += 16, n >>= 16;
-    if (n >> 8)
-	log2 += 8, n >>= 8;
-    if (n >> 4)
-	log2 += 4, n >>= 4;
-    if (n >> 2)
-	log2 += 2, n >>= 2;
-    if (n >> 1)
-	log2++;
-    return log2;
-}

mozilla/js/src/jslong.c

@@ -1,276 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#include "jstypes.h"
-#include "jslong.h"
-
-static JSInt64 ll_zero = JSLL_INIT( 0x00000000,0x00000000 );
-static JSInt64 ll_maxint = JSLL_INIT( 0x7fffffff, 0xffffffff );
-static JSInt64 ll_minint = JSLL_INIT( 0x80000000, 0x00000000 );
-
-#ifdef HAVE_WATCOM_BUG_2
-JSInt64 __pascal __loadds __export
-    JSLL_Zero(void) { return ll_zero; }
-JSInt64 __pascal __loadds __export
-    JSLL_MaxInt(void) { return ll_maxint; }
-JSInt64 __pascal __loadds __export
-    JSLL_MinInt(void) { return ll_minint; }
-#else
-JS_PUBLIC_API(JSInt64) JSLL_Zero(void) { return ll_zero; }
-JS_PUBLIC_API(JSInt64) JSLL_MaxInt(void) { return ll_maxint; }
-JS_PUBLIC_API(JSInt64) JSLL_MinInt(void) { return ll_minint; }
-#endif
-
-#ifndef JS_HAVE_LONG_LONG
-/*
-** Divide 64-bit a by 32-bit b, which must be normalized so its high bit is 1.
-*/
-static void norm_udivmod32(JSUint32 *qp, JSUint32 *rp, JSUint64 a, JSUint32 b)
-{
-    JSUint32 d1, d0, q1, q0;
-    JSUint32 r1, r0, m;
-
-    d1 = jshi16(b);
-    d0 = jslo16(b);
-    r1 = a.hi % d1;
-    q1 = a.hi / d1;
-    m = q1 * d0;
-    r1 = (r1 << 16) | jshi16(a.lo);
-    if (r1 < m) {
-        q1--, r1 += b;
-        if (r1 >= b	/* i.e., we didn't get a carry when adding to r1 */
-	    && r1 < m) {
-	    q1--, r1 += b;
-	}
-    }
-    r1 -= m;
-    r0 = r1 % d1;
-    q0 = r1 / d1;
-    m = q0 * d0;
-    r0 = (r0 << 16) | jslo16(a.lo);
-    if (r0 < m) {
-        q0--, r0 += b;
-        if (r0 >= b
-	    && r0 < m) {
-	    q0--, r0 += b;
-	}
-    }
-    *qp = (q1 << 16) | q0;
-    *rp = r0 - m;
-}
-
-static JSUint32 CountLeadingZeros(JSUint32 a)
-{
-    JSUint32 t;
-    JSUint32 r = 32;
-
-    if ((t = a >> 16) != 0)
-	r -= 16, a = t;
-    if ((t = a >> 8) != 0)
-	r -= 8, a = t;
-    if ((t = a >> 4) != 0)
-	r -= 4, a = t;
-    if ((t = a >> 2) != 0)
-	r -= 2, a = t;
-    if ((t = a >> 1) != 0)
-	r -= 1, a = t;
-    if (a & 1)
-	r--;
-    return r;
-}
-
-JS_PUBLIC_API(void) jsll_udivmod(JSUint64 *qp, JSUint64 *rp, JSUint64 a, JSUint64 b)
-{
-    JSUint32 n0, n1, n2;
-    JSUint32 q0, q1;
-    JSUint32 rsh, lsh;
-
-    n0 = a.lo;
-    n1 = a.hi;
-
-    if (b.hi == 0) {
-	if (b.lo > n1) {
-	    /* (0 q0) = (n1 n0) / (0 D0) */
-
-	    lsh = CountLeadingZeros(b.lo);
-
-	    if (lsh) {
-		/*
-		 * Normalize, i.e. make the most significant bit of the
-		 * denominator be set.
-		 */
-		b.lo = b.lo << lsh;
-		n1 = (n1 << lsh) | (n0 >> (32 - lsh));
-		n0 = n0 << lsh;
-	    }
-
-	    a.lo = n0, a.hi = n1;
-	    norm_udivmod32(&q0, &n0, a, b.lo);
-	    q1 = 0;
-
-	    /* remainder is in n0 >> lsh */
-	} else {
-	    /* (q1 q0) = (n1 n0) / (0 d0) */
-
-	    if (b.lo == 0)		/* user wants to divide by zero! */
-		b.lo = 1 / b.lo;	/* so go ahead and crash */
-
-	    lsh = CountLeadingZeros(b.lo);
-
-	    if (lsh == 0) {
-		/*
-		 * From (n1 >= b.lo)
-		 *   && (the most significant bit of b.lo is set),
-		 * conclude that
-		 *	(the most significant bit of n1 is set)
-		 *   && (the leading quotient digit q1 = 1).
-		 *
-		 * This special case is necessary, not an optimization
-		 * (Shifts counts of 32 are undefined).
-		 */
-		n1 -= b.lo;
-		q1 = 1;
-	    } else {
-		/*
-		 * Normalize.
-		 */
-		rsh = 32 - lsh;
-
-		b.lo = b.lo << lsh;
-		n2 = n1 >> rsh;
-		n1 = (n1 << lsh) | (n0 >> rsh);
-		n0 = n0 << lsh;
-
-		a.lo = n1, a.hi = n2;
-		norm_udivmod32(&q1, &n1, a, b.lo);
-	    }
-
-	    /* n1 != b.lo... */
-
-	    a.lo = n0, a.hi = n1;
-	    norm_udivmod32(&q0, &n0, a, b.lo);
-
-	    /* remainder in n0 >> lsh */
-	}
-
-	if (rp) {
-	    rp->lo = n0 >> lsh;
-	    rp->hi = 0;
-	}
-    } else {
-	if (b.hi > n1) {
-	    /* (0 0) = (n1 n0) / (D1 d0) */
-
-	    q0 = 0;
-	    q1 = 0;
-
-	    /* remainder in (n1 n0) */
-	    if (rp) {
-		rp->lo = n0;
-		rp->hi = n1;
-	    }
-	} else {
-	    /* (0 q0) = (n1 n0) / (d1 d0) */
-
-	    lsh = CountLeadingZeros(b.hi);
-	    if (lsh == 0) {
-		/*
-		 * From (n1 >= b.hi)
-		 *   && (the most significant bit of b.hi is set),
-		 * conclude that
-		 *      (the most significant bit of n1 is set)
-		 *   && (the quotient digit q0 = 0 or 1).
-		 *
-		 * This special case is necessary, not an optimization.
-		 */
-
-		/*
-		 * The condition on the next line takes advantage of that
-		 * n1 >= b.hi (true due to control flow).
-		 */
-		if (n1 > b.hi || n0 >= b.lo) {
-		    q0 = 1;
-		    a.lo = n0, a.hi = n1;
-		    JSLL_SUB(a, a, b);
-		} else {
-		    q0 = 0;
-		}
-		q1 = 0;
-
-		if (rp) {
-		    rp->lo = n0;
-		    rp->hi = n1;
-		}
-	    } else {
-		JSInt64 m;
-
-		/*
-		 * Normalize.
-		 */
-		rsh = 32 - lsh;
-
-		b.hi = (b.hi << lsh) | (b.lo >> rsh);
-		b.lo = b.lo << lsh;
-		n2 = n1 >> rsh;
-		n1 = (n1 << lsh) | (n0 >> rsh);
-		n0 = n0 << lsh;
-
-		a.lo = n1, a.hi = n2;
-		norm_udivmod32(&q0, &n1, a, b.hi);
-		JSLL_MUL32(m, q0, b.lo);
-
-		if ((m.hi > n1) || ((m.hi == n1) && (m.lo > n0))) {
-		    q0--;
-		    JSLL_SUB(m, m, b);
-		}
-
-		q1 = 0;
-
-		/* Remainder is ((n1 n0) - (m1 m0)) >> lsh */
-		if (rp) {
-		    a.lo = n0, a.hi = n1;
-		    JSLL_SUB(a, a, m);
-		    rp->lo = (a.hi << rsh) | (a.lo >> lsh);
-		    rp->hi = a.hi >> lsh;
-		}
-	    }
-	}
-    }
-
-    if (qp) {
-	qp->lo = q0;
-	qp->hi = q1;
-    }
-}
-#endif /* !JS_HAVE_LONG_LONG */

mozilla/js/src/jslong.h

@@ -1,433 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
-** File:                jslong.h
-** Description: Portable access to 64 bit numerics
-**
-** Long-long (64-bit signed integer type) support. Some C compilers
-** don't support 64 bit integers yet, so we use these macros to
-** support both machines that do and don't.
-**/
-#ifndef jslong_h___
-#define jslong_h___
-
-#include "jstypes.h"
-
-JS_BEGIN_EXTERN_C
-
-/***********************************************************************
-** DEFINES:     JSLL_MaxInt
-**              JSLL_MinInt
-**              JSLL_Zero
-** DESCRIPTION:
-**      Various interesting constants and static variable
-**      initializer
-***********************************************************************/
-#ifdef HAVE_WATCOM_BUG_2
-JSInt64 __pascal __loadds __export
-    JSLL_MaxInt(void);
-JSInt64 __pascal __loadds __export
-    JSLL_MinInt(void);
-JSInt64 __pascal __loadds __export
-    JSLL_Zero(void);
-#else
-extern JS_PUBLIC_API(JSInt64) JSLL_MaxInt(void);
-extern JS_PUBLIC_API(JSInt64) JSLL_MinInt(void);
-extern JS_PUBLIC_API(JSInt64) JSLL_Zero(void);
-#endif
-
-#define JSLL_MAXINT   JSLL_MaxInt()
-#define JSLL_MININT   JSLL_MinInt()
-#define JSLL_ZERO     JSLL_Zero()
-
-#ifdef JS_HAVE_LONG_LONG
-
-#if JS_BYTES_PER_LONG == 8
-#define JSLL_INIT(hi, lo)  ((hi ## L << 32) + lo ## L)
-#elif defined(WIN32) || defined(WIN16)
-#define JSLL_INIT(hi, lo)  ((hi ## i64 << 32) + lo ## i64)
-#else
-#define JSLL_INIT(hi, lo)  ((hi ## LL << 32) + lo ## LL)
-#endif
-
-/***********************************************************************
-** MACROS:      JSLL_*
-** DESCRIPTION:
-**      The following macros define portable access to the 64 bit
-**      math facilities.
-**
-***********************************************************************/
-
-/***********************************************************************
-** MACROS:      JSLL_<relational operators>
-**
-**  JSLL_IS_ZERO        Test for zero
-**  JSLL_EQ             Test for equality
-**  JSLL_NE             Test for inequality
-**  JSLL_GE_ZERO        Test for zero or positive
-**  JSLL_CMP            Compare two values
-***********************************************************************/
-#define JSLL_IS_ZERO(a)       ((a) == 0)
-#define JSLL_EQ(a, b)         ((a) == (b))
-#define JSLL_NE(a, b)         ((a) != (b))
-#define JSLL_GE_ZERO(a)       ((a) >= 0)
-#define JSLL_CMP(a, op, b)    ((JSInt64)(a) op (JSInt64)(b))
-#define JSLL_UCMP(a, op, b)   ((JSUint64)(a) op (JSUint64)(b))
-
-/***********************************************************************
-** MACROS:      JSLL_<logical operators>
-**
-**  JSLL_AND            Logical and
-**  JSLL_OR             Logical or
-**  JSLL_XOR            Logical exclusion
-**  JSLL_OR2            A disgusting deviation
-**  JSLL_NOT            Negation (one's compliment)
-***********************************************************************/
-#define JSLL_AND(r, a, b)        ((r) = (a) & (b))
-#define JSLL_OR(r, a, b)        ((r) = (a) | (b))
-#define JSLL_XOR(r, a, b)        ((r) = (a) ^ (b))
-#define JSLL_OR2(r, a)        ((r) = (r) | (a))
-#define JSLL_NOT(r, a)        ((r) = ~(a))
-
-/***********************************************************************
-** MACROS:      JSLL_<mathematical operators>
-**
-**  JSLL_NEG            Negation (two's compliment)
-**  JSLL_ADD            Summation (two's compliment)
-**  JSLL_SUB            Difference (two's compliment)
-***********************************************************************/
-#define JSLL_NEG(r, a)        ((r) = -(a))
-#define JSLL_ADD(r, a, b)     ((r) = (a) + (b))
-#define JSLL_SUB(r, a, b)     ((r) = (a) - (b))
-
-/***********************************************************************
-** MACROS:      JSLL_<mathematical operators>
-**
-**  JSLL_MUL            Product (two's compliment)
-**  JSLL_DIV            Quotient (two's compliment)
-**  JSLL_MOD            Modulus (two's compliment)
-***********************************************************************/
-#define JSLL_MUL(r, a, b)        ((r) = (a) * (b))
-#define JSLL_DIV(r, a, b)        ((r) = (a) / (b))
-#define JSLL_MOD(r, a, b)        ((r) = (a) % (b))
-
-/***********************************************************************
-** MACROS:      JSLL_<shifting operators>
-**
-**  JSLL_SHL            Shift left [0..64] bits
-**  JSLL_SHR            Shift right [0..64] bits with sign extension
-**  JSLL_USHR           Unsigned shift right [0..64] bits
-**  JSLL_ISHL           Signed shift left [0..64] bits
-***********************************************************************/
-#define JSLL_SHL(r, a, b)     ((r) = (JSInt64)(a) << (b))
-#define JSLL_SHR(r, a, b)     ((r) = (JSInt64)(a) >> (b))
-#define JSLL_USHR(r, a, b)    ((r) = (JSUint64)(a) >> (b))
-#define JSLL_ISHL(r, a, b)    ((r) = (JSInt64)(a) << (b))
-
-/***********************************************************************
-** MACROS:      JSLL_<conversion operators>
-**
-**  JSLL_L2I            Convert to signed 32 bit
-**  JSLL_L2UI           Convert to unsigned 32 bit
-**  JSLL_L2F            Convert to floating point
-**  JSLL_L2D            Convert to floating point
-**  JSLL_I2L            Convert signed to 64 bit
-**  JSLL_UI2L           Convert unsigned to 64 bit
-**  JSLL_F2L            Convert float to 64 bit
-**  JSLL_D2L            Convert float to 64 bit
-***********************************************************************/
-#define JSLL_L2I(i, l)        ((i) = (JSInt32)(l))
-#define JSLL_L2UI(ui, l)        ((ui) = (JSUint32)(l))
-#define JSLL_L2F(f, l)        ((f) = (JSFloat64)(l))
-#define JSLL_L2D(d, l)        ((d) = (JSFloat64)(l))
-
-#define JSLL_I2L(l, i)        ((l) = (JSInt64)(i))
-#define JSLL_UI2L(l, ui)        ((l) = (JSInt64)(ui))
-#define JSLL_F2L(l, f)        ((l) = (JSInt64)(f))
-#define JSLL_D2L(l, d)        ((l) = (JSInt64)(d))
-
-/***********************************************************************
-** MACROS:      JSLL_UDIVMOD
-** DESCRIPTION:
-**  Produce both a quotient and a remainder given an unsigned 
-** INPUTS:      JSUint64 a: The dividend of the operation
-**              JSUint64 b: The quotient of the operation
-** OUTPUTS:     JSUint64 *qp: pointer to quotient
-**              JSUint64 *rp: pointer to remainder
-***********************************************************************/
-#define JSLL_UDIVMOD(qp, rp, a, b) \
-    (*(qp) = ((JSUint64)(a) / (b)), \
-     *(rp) = ((JSUint64)(a) % (b)))
-
-#else  /* !JS_HAVE_LONG_LONG */
-
-#ifdef IS_LITTLE_ENDIAN
-#define JSLL_INIT(hi, lo) {JS_INT32(lo), JS_INT32(hi)}
-#else
-#define JSLL_INIT(hi, lo) {JS_INT32(hi), JS_INT32(lo)}
-#endif
-
-#define JSLL_IS_ZERO(a)         (((a).hi == 0) && ((a).lo == 0))
-#define JSLL_EQ(a, b)           (((a).hi == (b).hi) && ((a).lo == (b).lo))
-#define JSLL_NE(a, b)           (((a).hi != (b).hi) || ((a).lo != (b).lo))
-#define JSLL_GE_ZERO(a)         (((a).hi >> 31) == 0)
-
-#ifdef DEBUG
-#define JSLL_CMP(a, op, b)      (JS_ASSERT((#op)[1] != '='), JSLL_REAL_CMP(a, op, b))
-#define JSLL_CMP(a, op, b)      (JS_ASSERT((#op)[1] != '='), JSLL_REAL_CMP(a, op, b))
-#else
-#define JSLL_CMP(a, op, b)      JSLL_REAL_CMP(a, op, b)
-#define JSLL_CMP(a, op, b)      JSLL_REAL_CMP(a, op, b)
-#endif
-
-#define JSLL_REAL_CMP(a,op,b)   (((JSInt32)(a).hi op (JSInt32)(b).hi) || \
-                                 (((a).hi == (b).hi) && ((a).lo op (b).lo)))
-#define JSLL_REAL_UCMP(a,op,b)  (((a).hi op (b).hi) || \
-                                 (((a).hi == (b).hi) && ((a).lo op (b).lo)))
-
-#define JSLL_AND(r, a, b)       ((r).lo = (a).lo & (b).lo, \
-                                 (r).hi = (a).hi & (b).hi)
-#define JSLL_OR(r, a, b)        ((r).lo = (a).lo | (b).lo, \
-                                 (r).hi = (a).hi | (b).hi)
-#define JSLL_XOR(r, a, b)       ((r).lo = (a).lo ^ (b).lo, \
-                                 (r).hi = (a).hi ^ (b).hi)
-#define JSLL_OR2(r, a)          ((r).lo = (r).lo | (a).lo, \
-                                 (r).hi = (r).hi | (a).hi)
-#define JSLL_NOT(r, a)          ((r).lo = ~(a).lo, \
-                                 (r).hi = ~(a).hi)
-
-#define JSLL_NEG(r, a)          ((r).lo = -(JSInt32)(a).lo, \
-                                 (r).hi = -(JSInt32)(a).hi - ((r).lo != 0))
-#define JSLL_ADD(r, a, b) { \
-    JSInt64 _a, _b; \
-    _a = a; _b = b; \
-    (r).lo = _a.lo + _b.lo; \
-    (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo); \
-}
-
-#define JSLL_SUB(r, a, b) { \
-    JSInt64 _a, _b; \
-    _a = a; _b = b; \
-    (r).lo = _a.lo - _b.lo; \
-    (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo); \
-}
-
-#define JSLL_MUL(r, a, b) { \
-    JSInt64 _a, _b; \
-    _a = a; _b = b; \
-    JSLL_MUL32(r, _a.lo, _b.lo); \
-    (r).hi += _a.hi * _b.lo + _a.lo * _b.hi; \
-}
-
-#define jslo16(a)        ((a) & JS_BITMASK(16))
-#define jshi16(a)        ((a) >> 16)
-
-#define JSLL_MUL32(r, a, b) { \
-     JSUint32 _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3; \
-     _a1 = jshi16(a), _a0 = jslo16(a); \
-     _b1 = jshi16(b), _b0 = jslo16(b); \
-     _y0 = _a0 * _b0; \
-     _y1 = _a0 * _b1; \
-     _y2 = _a1 * _b0; \
-     _y3 = _a1 * _b1; \
-     _y1 += jshi16(_y0);                         /* can't carry */ \
-     _y1 += _y2;                                /* might carry */ \
-     if (_y1 < _y2)    \
-        _y3 += (JSUint32)(JS_BIT(16));  /* propagate */ \
-     (r).lo = (jslo16(_y1) << 16) + jslo16(_y0); \
-     (r).hi = _y3 + jshi16(_y1); \
-}
-
-#define JSLL_UDIVMOD(qp, rp, a, b)    jsll_udivmod(qp, rp, a, b)
-
-extern JS_PUBLIC_API(void) jsll_udivmod(JSUint64 *qp, JSUint64 *rp, JSUint64 a, JSUint64 b);
-
-#define JSLL_DIV(r, a, b) { \
-    JSInt64 _a, _b; \
-    JSUint32 _negative = (JSInt32)(a).hi < 0; \
-    if (_negative) { \
-    JSLL_NEG(_a, a); \
-    } else { \
-    _a = a; \
-    } \
-    if ((JSInt32)(b).hi < 0) { \
-    _negative ^= 1; \
-    JSLL_NEG(_b, b); \
-    } else { \
-    _b = b; \
-    } \
-    JSLL_UDIVMOD(&(r), 0, _a, _b); \
-    if (_negative) \
-    JSLL_NEG(r, r); \
-}
-
-#define JSLL_MOD(r, a, b) { \
-    JSInt64 _a, _b; \
-    JSUint32 _negative = (JSInt32)(a).hi < 0; \
-    if (_negative) { \
-    JSLL_NEG(_a, a); \
-    } else { \
-    _a = a; \
-    } \
-    if ((JSInt32)(b).hi < 0) { \
-    JSLL_NEG(_b, b); \
-    } else { \
-    _b = b; \
-    } \
-    JSLL_UDIVMOD(0, &(r), _a, _b); \
-    if (_negative) \
-    JSLL_NEG(r, r); \
-}
-
-#define JSLL_SHL(r, a, b) { \
-    if (b) { \
-    JSInt64 _a; \
-        _a = a; \
-        if ((b) < 32) { \
-        (r).lo = _a.lo << ((b) & 31); \
-        (r).hi = (_a.hi << ((b) & 31)) | (_a.lo >> (32 - (b))); \
-    } else { \
-        (r).lo = 0; \
-        (r).hi = _a.lo << ((b) & 31); \
-    } \
-    } else { \
-    (r) = (a); \
-    } \
-}
-
-/* a is an JSInt32, b is JSInt32, r is JSInt64 */
-#define JSLL_ISHL(r, a, b) { \
-    if (b) { \
-    JSInt64 _a; \
-    _a.lo = (a); \
-    _a.hi = 0; \
-        if ((b) < 32) { \
-        (r).lo = (a) << ((b) & 31); \
-        (r).hi = ((a) >> (32 - (b))); \
-    } else { \
-        (r).lo = 0; \
-        (r).hi = (a) << ((b) & 31); \
-    } \
-    } else { \
-    (r).lo = (a); \
-    (r).hi = 0; \
-    } \
-}
-
-#define JSLL_SHR(r, a, b) { \
-    if (b) { \
-    JSInt64 _a; \
-        _a = a; \
-    if ((b) < 32) { \
-        (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> ((b) & 31)); \
-        (r).hi = (JSInt32)_a.hi >> ((b) & 31); \
-    } else { \
-        (r).lo = (JSInt32)_a.hi >> ((b) & 31); \
-        (r).hi = (JSInt32)_a.hi >> 31; \
-    } \
-    } else { \
-    (r) = (a); \
-    } \
-}
-
-#define JSLL_USHR(r, a, b) { \
-    if (b) { \
-    JSInt64 _a; \
-        _a = a; \
-    if ((b) < 32) { \
-        (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> ((b) & 31)); \
-        (r).hi = _a.hi >> ((b) & 31); \
-    } else { \
-        (r).lo = _a.hi >> ((b) & 31); \
-        (r).hi = 0; \
-    } \
-    } else { \
-    (r) = (a); \
-    } \
-}
-
-#define JSLL_L2I(i, l)        ((i) = (l).lo)
-#define JSLL_L2UI(ui, l)        ((ui) = (l).lo)
-#define JSLL_L2F(f, l)        { double _d; JSLL_L2D(_d, l); (f) = (JSFloat64)_d; }
-
-#define JSLL_L2D(d, l) { \
-    int _negative; \
-    JSInt64 _absval; \
- \
-    _negative = (l).hi >> 31; \
-    if (_negative) { \
-    JSLL_NEG(_absval, l); \
-    } else { \
-    _absval = l; \
-    } \
-    (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo; \
-    if (_negative) \
-    (d) = -(d); \
-}
-
-#define JSLL_I2L(l, i)        { JSInt32 _i = (i) >> 31; (l).lo = (i); (l).hi = _i; }
-#define JSLL_UI2L(l, ui)      ((l).lo = (ui), (l).hi = 0)
-#define JSLL_F2L(l, f)        { double _d = (double)f; JSLL_D2L(l, _d); }
-
-#define JSLL_D2L(l, d) { \
-    int _negative; \
-    double _absval, _d_hi; \
-    JSInt64 _lo_d; \
- \
-    _negative = ((d) < 0); \
-    _absval = _negative ? -(d) : (d); \
- \
-    (l).hi = _absval / 4.294967296e9; \
-    (l).lo = 0; \
-    JSLL_L2D(_d_hi, l); \
-    _absval -= _d_hi; \
-    _lo_d.hi = 0; \
-    if (_absval < 0) { \
-    _lo_d.lo = -_absval; \
-    JSLL_SUB(l, l, _lo_d); \
-    } else { \
-    _lo_d.lo = _absval; \
-    JSLL_ADD(l, l, _lo_d); \
-    } \
- \
-    if (_negative) \
-    JSLL_NEG(l, l); \
-}
-
-#endif /* !JS_HAVE_LONG_LONG */
-
-JS_END_EXTERN_C
-
-#endif /* jslong_h___ */

mozilla/js/src/jsmath.c

@@ -1,452 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS math package.
- */
-#include "jsstddef.h"
-#include "jslibmath.h"
-#include <stdlib.h>
-#include "jstypes.h"
-#include "jslong.h"
-#include "prmjtime.h"
-#include "jsapi.h"
-#include "jsatom.h"
-#include "jscntxt.h"
-#include "jsconfig.h"
-#include "jslock.h"
-#include "jsmath.h"
-#include "jsnum.h"
-#include "jsobj.h"
-
-#ifndef M_E
-#define M_E		2.7182818284590452354
-#endif
-#ifndef M_LOG2E
-#define M_LOG2E		1.4426950408889634074
-#endif
-#ifndef M_LOG10E
-#define M_LOG10E	0.43429448190325182765
-#endif
-#ifndef M_LN2
-#define M_LN2		0.69314718055994530942
-#endif
-#ifndef M_LN10
-#define M_LN10		2.30258509299404568402
-#endif
-#ifndef M_PI
-#define M_PI		3.14159265358979323846
-#endif
-#ifndef M_SQRT2
-#define M_SQRT2		1.41421356237309504880
-#endif
-#ifndef M_SQRT1_2
-#define M_SQRT1_2	0.70710678118654752440
-#endif
-
-static JSConstDoubleSpec math_constants[] = {
-    {M_E,       "E",            0, {0,0,0}},
-    {M_LOG2E,   "LOG2E",        0, {0,0,0}},
-    {M_LOG10E,  "LOG10E",       0, {0,0,0}},
-    {M_LN2,     "LN2",          0, {0,0,0}},
-    {M_LN10,    "LN10",         0, {0,0,0}},
-    {M_PI,      "PI",           0, {0,0,0}},
-    {M_SQRT2,   "SQRT2",        0, {0,0,0}},
-    {M_SQRT1_2, "SQRT1_2",      0, {0,0,0}},
-    {0,0,0,{0,0,0}}
-};
-
-static JSClass math_class = {
-    "Math",
-    0,
-    JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
-    JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   JS_FinalizeStub,
-    JSCLASS_NO_OPTIONAL_MEMBERS
-};
-
-static JSBool
-math_abs(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_fabs(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_acos(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_acos(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_asin(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_asin(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_atan(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_atan(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_atan2(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, y, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-	return JS_FALSE;
-    if (!js_ValueToNumber(cx, argv[1], &y))
-	return JS_FALSE;
-    z = fd_atan2(x, y);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_ceil(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_ceil(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_cos(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_cos(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_exp(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_exp(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_floor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_floor(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_log(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_log(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_max(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z = *cx->runtime->jsNegativeInfinity;
-    uintN i;
-
-    if (argc == 0) {
-        *rval = DOUBLE_TO_JSVAL(cx->runtime->jsNegativeInfinity);
-        return JS_TRUE;
-    }
-    for (i = 0; i < argc; i++) {
-        if (!js_ValueToNumber(cx, argv[i], &x))
-            return JS_FALSE;
-        if (JSDOUBLE_IS_NaN(x)) {
-            *rval = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
-            return JS_TRUE;
-        }
-        if ((x==0)&&(x==z)&&(fd_copysign(1.0,z)==-1))
-            z = x;
-        else
-            z = (x > z) ? x : z;
-    }
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_min(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z = *cx->runtime->jsPositiveInfinity;
-    uintN i;
-
-    if (argc == 0) {
-        *rval = DOUBLE_TO_JSVAL(cx->runtime->jsPositiveInfinity);
-        return JS_TRUE;
-    }
-    for (i = 0; i < argc; i++) {
-        if (!js_ValueToNumber(cx, argv[i], &x))
-            return JS_FALSE;
-        if (JSDOUBLE_IS_NaN(x)) {
-            *rval = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
-            return JS_TRUE;
-        }
-        if ((x==0)&&(x==z)&&(fd_copysign(1.0,x)==-1))
-            z = x;
-        else
-            z = (x < z) ? x : z;
-    }
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_pow(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, y, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-	return JS_FALSE;
-    if (!js_ValueToNumber(cx, argv[1], &y))
-    return JS_FALSE;
-    z = fd_pow(x, y);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-/*
- * Math.random() support, lifted from java.util.Random.java.
- */
-static void
-random_setSeed(JSRuntime *rt, int64 seed)
-{
-    int64 tmp;
-
-    JSLL_I2L(tmp, 1000);
-    JSLL_DIV(seed, seed, tmp);
-    JSLL_XOR(tmp, seed, rt->rngMultiplier);
-    JSLL_AND(rt->rngSeed, tmp, rt->rngMask);
-}
-
-static void
-random_init(JSRuntime *rt)
-{
-    int64 tmp, tmp2;
-
-    /* Do at most once. */
-    if (rt->rngInitialized)
-	return;
-    rt->rngInitialized = JS_TRUE;
-
-    /* rt->rngMultiplier = 0x5DEECE66DL */
-    JSLL_ISHL(tmp, 0x5D, 32);
-    JSLL_UI2L(tmp2, 0xEECE66DL);
-    JSLL_OR(rt->rngMultiplier, tmp, tmp2);
-
-    /* rt->rngAddend = 0xBL */
-    JSLL_I2L(rt->rngAddend, 0xBL);
-
-    /* rt->rngMask = (1L << 48) - 1 */
-    JSLL_I2L(tmp, 1);
-    JSLL_SHL(tmp2, tmp, 48);
-    JSLL_SUB(rt->rngMask, tmp2, tmp);
-
-    /* rt->rngDscale = (jsdouble)(1L << 54) */
-    JSLL_SHL(tmp2, tmp, 54);
-    JSLL_L2D(rt->rngDscale, tmp2);
-
-    /* Finally, set the seed from current time. */
-    random_setSeed(rt, PRMJ_Now());
-}
-
-static uint32
-random_next(JSRuntime *rt, int bits)
-{
-    int64 nextseed, tmp;
-    uint32 retval;
-
-    JSLL_MUL(nextseed, rt->rngSeed, rt->rngMultiplier);
-    JSLL_ADD(nextseed, nextseed, rt->rngAddend);
-    JSLL_AND(nextseed, nextseed, rt->rngMask);
-    rt->rngSeed = nextseed;
-    JSLL_USHR(tmp, nextseed, 48 - bits);
-    JSLL_L2I(retval, tmp);
-    return retval;
-}
-
-static jsdouble
-random_nextDouble(JSRuntime *rt)
-{
-    int64 tmp, tmp2;
-    jsdouble d;
-
-    JSLL_ISHL(tmp, random_next(rt, 27), 27);
-    JSLL_UI2L(tmp2, random_next(rt, 27));
-    JSLL_ADD(tmp, tmp, tmp2);
-    JSLL_L2D(d, tmp);
-    return d / rt->rngDscale;
-}
-
-static JSBool
-math_random(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    JSRuntime *rt;
-    jsdouble z;
-
-    rt = cx->runtime;
-    JS_LOCK_RUNTIME(rt);
-    random_init(rt);
-    z = random_nextDouble(rt);
-    JS_UNLOCK_RUNTIME(rt);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_round(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_copysign(fd_floor(x + 0.5), x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_sin(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_sin(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_sqrt(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_sqrt(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-static JSBool
-math_tan(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x, z;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-    return JS_FALSE;
-    z = fd_tan(x);
-    return js_NewNumberValue(cx, z, rval);
-}
-
-#if JS_HAS_TOSOURCE
-static JSBool
-math_toSource(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
-	      jsval *rval)
-{
-    *rval = ATOM_KEY(cx->runtime->atomState.MathAtom);
-    return JS_TRUE;
-}
-#endif
-
-static JSFunctionSpec math_static_methods[] = {
-#ifdef JS_HAS_TOSOURCE
-    {js_toSource_str,   math_toSource,		0, 0, 0},
-#endif
-    {"abs",		math_abs,		1, 0, 0},
-    {"acos",		math_acos,		1, 0, 0},
-    {"asin",		math_asin,		1, 0, 0},
-    {"atan",		math_atan,		1, 0, 0},
-    {"atan2",		math_atan2,		2, 0, 0},
-    {"ceil",		math_ceil,		1, 0, 0},
-    {"cos",		math_cos,		1, 0, 0},
-    {"exp",		math_exp,		1, 0, 0},
-    {"floor",		math_floor,		1, 0, 0},
-    {"log",		math_log,		1, 0, 0},
-    {"max",		math_max,		2, 0, 0},
-    {"min",		math_min,		2, 0, 0},
-    {"pow",		math_pow,		2, 0, 0},
-    {"random",		math_random,		0, 0, 0},
-    {"round",		math_round,		1, 0, 0},
-    {"sin",		math_sin,		1, 0, 0},
-    {"sqrt",		math_sqrt,		1, 0, 0},
-    {"tan",		math_tan,		1, 0, 0},
-    {0,0,0,0,0}
-};
-
-JSObject *
-js_InitMathClass(JSContext *cx, JSObject *obj)
-{
-    JSObject *Math;
-    
-    Math = JS_DefineObject(cx, obj, "Math", &math_class, NULL, 0);
-    if (!Math)
-        return NULL;
-    if (!JS_DefineFunctions(cx, Math, math_static_methods))
-        return NULL;
-    if (!JS_DefineConstDoubles(cx, Math, math_constants))
-        return NULL;
-    return Math;
-}

mozilla/js/src/jsmath.h

@@ -1,18 +0,0 @@
-/* -*- Mode: C; tab-width: 8 -*-
- * Copyright (C) 1998 Netscape Communications Corporation, All Rights Reserved.
- */
-
-#ifndef jsmath_h___
-#define jsmath_h___
-/*
- * JS math functions.
- */
-
-JS_BEGIN_EXTERN_C
-
-extern JSObject *
-js_InitMathClass(JSContext *cx, JSObject *obj);
-
-JS_END_EXTERN_C
-
-#endif /* jsmath_h___ */

mozilla/js/src/jsnum.c

@@ -1,939 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-/*
- * JS number type and wrapper class.
- */
-#include "jsstddef.h"
-#include <errno.h>
-#ifdef XP_PC
-#include <float.h>
-#endif
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-#include "jstypes.h"
-#include "jsutil.h" /* Added by JSIFY */
-#include "jsapi.h"
-#include "jsatom.h"
-#include "jscntxt.h"
-#include "jsconfig.h"
-#include "jsdtoa.h"
-#include "jsgc.h"
-#include "jsinterp.h"
-#include "jsnum.h"
-#include "jsobj.h"
-#include "jsopcode.h"
-#include "jsprf.h"
-#include "jsstr.h"
-
-union dpun {
-    struct {
-#ifdef IS_LITTLE_ENDIAN
-	uint32 lo, hi;
-#else
-	uint32 hi, lo;
-#endif
-    } s;
-    jsdouble d;
-};
-
-static JSBool
-num_isNaN(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-	return JS_FALSE;
-    *rval = BOOLEAN_TO_JSVAL(JSDOUBLE_IS_NaN(x));
-    return JS_TRUE;
-}
-
-static JSBool
-num_isFinite(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble x;
-
-    if (!js_ValueToNumber(cx, argv[0], &x))
-	return JS_FALSE;
-    *rval = BOOLEAN_TO_JSVAL(JSDOUBLE_IS_FINITE(x));
-    return JS_TRUE;
-}
-
-static JSBool
-num_parseFloat(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    JSString *str;
-    jsdouble d;
-    const jschar *ep;
-
-    str = js_ValueToString(cx, argv[0]);
-    if (!str)
-	return JS_FALSE;
-    if (!js_strtod(cx, str->chars, &ep, &d))
-	return JS_FALSE;
-    if (ep == str->chars) {
-	*rval = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
-	return JS_TRUE;
-    }
-    return js_NewNumberValue(cx, d, rval);
-}
-
-/* See ECMA 15.1.2.2. */
-static JSBool
-num_parseInt(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    JSString *str;
-    jsint radix;
-    jsdouble d;
-    const jschar *ep;
-
-    str = js_ValueToString(cx, argv[0]);
-    if (!str)
-	return JS_FALSE;
-
-    if (argc > 1) {
-	if (!js_ValueToECMAInt32(cx, argv[1], &radix))
-	    return JS_FALSE;
-    } else
-	radix = 0;
-
-    if (radix != 0 && (radix < 2 || radix > 36)) {
-	*rval = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
-	return JS_TRUE;
-    }
-    if (!js_strtointeger(cx, str->chars, &ep, radix, &d))
-	return JS_FALSE;
-    if (ep == str->chars) {
-	*rval = DOUBLE_TO_JSVAL(cx->runtime->jsNaN);
-	return JS_TRUE;
-    }
-    return js_NewNumberValue(cx, d, rval);
-}
-
-
-static JSFunctionSpec number_functions[] = {
-    {"isNaN",           num_isNaN,              1,0,0},
-    {"isFinite",        num_isFinite,           1,0,0},
-    {"parseFloat",      num_parseFloat,         1,0,0},
-    {"parseInt",        num_parseInt,           2,0,0},
-    {0,0,0,0,0}
-};
-
-static JSClass number_class = {
-    "Number",
-    JSCLASS_HAS_PRIVATE,
-    JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
-    JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   JS_FinalizeStub,
-    JSCLASS_NO_OPTIONAL_MEMBERS
-};
-
-static JSBool
-Number(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsdouble d;
-    jsval v;
-
-    if (argc != 0) {
-	if (!js_ValueToNumber(cx, argv[0], &d))
-	    return JS_FALSE;
-    } else {
-	d = 0.0;
-    }
-    if (!js_NewNumberValue(cx, d, &v))
-	return JS_FALSE;
-    if (!cx->fp->constructing) {
-	*rval = v;
-	return JS_TRUE;
-    }
-    OBJ_SET_SLOT(cx, obj, JSSLOT_PRIVATE, v);
-    return JS_TRUE;
-}
-
-#if JS_HAS_TOSOURCE
-static JSBool
-num_toSource(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsval v;
-    jsdouble d;
-    char numBuf[DTOSTR_STANDARD_BUFFER_SIZE], *numStr;
-    char buf[64];
-    JSString *str;
-
-    if (!JS_InstanceOf(cx, obj, &number_class, argv))
-	return JS_FALSE;
-    v = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-    JS_ASSERT(JSVAL_IS_NUMBER(v));
-    d = JSVAL_IS_INT(v) ? (jsdouble)JSVAL_TO_INT(v) : *JSVAL_TO_DOUBLE(v);
-    numStr = JS_dtostr(numBuf, sizeof numBuf, DTOSTR_STANDARD, 0, d);
-    if (!numStr) {
-	JS_ReportOutOfMemory(cx);
-	return JS_FALSE;
-    }
-    JS_snprintf(buf, sizeof buf, "(new %s(%s))", number_class.name, numStr);
-    str = JS_NewStringCopyZ(cx, buf);
-    if (!str)
-	return JS_FALSE;
-    *rval = STRING_TO_JSVAL(str);
-    return JS_TRUE;
-}
-#endif
-
-static JSBool
-num_toString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    jsval v;
-    jsdouble d;
-    jsint base;
-    JSString *str;
-
-    if (!JS_InstanceOf(cx, obj, &number_class, argv))
-	return JS_FALSE;
-    v = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-    JS_ASSERT(JSVAL_IS_NUMBER(v));
-    d = JSVAL_IS_INT(v) ? (jsdouble)JSVAL_TO_INT(v) : *JSVAL_TO_DOUBLE(v);
-    base = 10;
-    if (argc != 0) {
-	if (!js_ValueToECMAInt32(cx, argv[0], &base))
-	    return JS_FALSE;
-	if (base < 2 || base > 36) {
-	    char numBuf[12];
-	    JS_snprintf(numBuf, sizeof numBuf, "%ld", (long) base);
-	    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_RADIX,
-	    			 numBuf);
-	    return JS_FALSE;
-	}
-    }
-    if (base == 10)
-	str = js_NumberToString(cx, d);
-    else {
-	char *dStr = JS_dtobasestr(base, d);
-	if (!dStr) {
-	    JS_ReportOutOfMemory(cx);
-	    return JS_FALSE;
-	}
-	str = JS_NewStringCopyZ(cx, dStr);
-	free(dStr);
-    }
-    if (!str)
-	return JS_FALSE;
-    *rval = STRING_TO_JSVAL(str);
-    return JS_TRUE;
-}
-
-static JSBool
-num_valueOf(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    if (!JS_InstanceOf(cx, obj, &number_class, argv))
-	return JS_FALSE;
-    *rval = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-    return JS_TRUE;
-}
-
-
-#if JS_HAS_NUMBER_FORMATS
-#define MAX_PRECISION 100
-
-static JSBool
-num_to(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval, JSDToStrMode zeroArgMode,
-       JSDToStrMode oneArgMode, jsint precisionMin, jsint precisionMax, jsint precisionOffset)
-{
-    jsval v;
-    jsdouble d, precision;
-    JSString *str;
-    char buf[DTOSTR_VARIABLE_BUFFER_SIZE(MAX_PRECISION+1)], *numStr; /* Use MAX_PRECISION+1 because precisionOffset can be 1 */
-
-    if (!JS_InstanceOf(cx, obj, &number_class, argv))
-	return JS_FALSE;
-    v = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
-    JS_ASSERT(JSVAL_IS_NUMBER(v));
-    d = JSVAL_IS_INT(v) ? (jsdouble)JSVAL_TO_INT(v) : *JSVAL_TO_DOUBLE(v);
-
-    if (JSVAL_IS_VOID(argv[0])) {
-	precision = 0.0;
-	oneArgMode = zeroArgMode;
-    } else {
-	if (!js_ValueToNumber(cx, argv[0], &precision))
-	    return JS_FALSE;
-	precision = js_DoubleToInteger(precision);
-        if (precision < precisionMin || precision > precisionMax) {
-            numStr = JS_dtostr(buf, sizeof buf, DTOSTR_STANDARD, 0, precision);
-            if (!numStr)
-                JS_ReportOutOfMemory(cx);
-            else
-                JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_PRECISION_RANGE, numStr);
-            return JS_FALSE;
-        }
-    }
-
-    numStr = JS_dtostr(buf, sizeof buf, oneArgMode, (jsint)precision + precisionOffset, d);
-    if (!numStr) {
-	JS_ReportOutOfMemory(cx);
-	return JS_FALSE;
-    }
-    str = JS_NewStringCopyZ(cx, numStr);
-    if (!str)
-	return JS_FALSE;
-    *rval = STRING_TO_JSVAL(str);
-    return JS_TRUE;
-}
-
-static JSBool
-num_toFixed(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    /* We allow a larger range of precision than ECMA requires; this is permitted by ECMA. */
-    return num_to(cx, obj, argc, argv, rval, DTOSTR_FIXED, DTOSTR_FIXED, -20, MAX_PRECISION, 0);
-}
-
-static JSBool
-num_toExponential(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    /* We allow a larger range of precision than ECMA requires; this is permitted by ECMA. */
-    return num_to(cx, obj, argc, argv, rval, DTOSTR_STANDARD_EXPONENTIAL, DTOSTR_EXPONENTIAL, 0, MAX_PRECISION, 1);
-}
-
-static JSBool
-num_toPrecision(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
-{
-    /* We allow a larger range of precision than ECMA requires; this is permitted by ECMA. */
-    return num_to(cx, obj, argc, argv, rval, DTOSTR_STANDARD, DTOSTR_PRECISION, 1, MAX_PRECISION, 0);
-}
-#endif /* JS_HAS_NUMBER_FORMATS */
-
-
-static JSFunctionSpec number_methods[] = {
-#if JS_HAS_TOSOURCE
-    {js_toSource_str,   num_toSource,      0,0,0},
-#endif
-    {js_toString_str,	num_toString,	   0,0,0},
-    {js_valueOf_str,	num_valueOf,	   0,0,0},
-#if JS_HAS_NUMBER_FORMATS
-    {"toFixed",         num_toFixed,       1,0,0},
-    {"toExponential",   num_toExponential, 1,0,0},
-    {"toPrecision",     num_toPrecision,   1,0,0},
-#endif
-    {0,0,0,0,0}
-};
-
-/* NB: Keep this in synch with number_constants[]. */
-enum nc_slot {
-    NC_NaN,
-    NC_POSITIVE_INFINITY,
-    NC_NEGATIVE_INFINITY,
-    NC_MAX_VALUE,
-    NC_MIN_VALUE,
-    NC_LIMIT
-};
-
-/*
- * Some to most C compilers forbid spelling these at compile time, or barf
- * if you try, so all but MAX_VALUE are set at runtime by js_InitNumberClass
- * using union dpun.
- */
-static JSConstDoubleSpec number_constants[] = {
-    {0,                         js_NaN_str,          0,{0,0,0}},
-    {0,                         "POSITIVE_INFINITY", 0,{0,0,0}},
-    {0,                         "NEGATIVE_INFINITY", 0,{0,0,0}},
-    {1.7976931348623157E+308,   "MAX_VALUE",         0,{0,0,0}},
-    {0,                         "MIN_VALUE",         0,{0,0,0}},
-    {0,0,0,{0,0,0}}
-};
-
-static jsdouble NaN;
-
-JSObject *
-js_InitNumberClass(JSContext *cx, JSObject *obj)
-{
-    JSRuntime *rt;
-    union dpun u;
-    JSObject *proto, *ctor;
-
-    rt = cx->runtime;
-    if (!rt->jsNaN) {
-#ifndef __MWERKS__
-#ifdef XP_PC
-#ifdef XP_OS2
-	/*DSR071597 - I have no idea what this really does other than mucking with the floating     */
-	/*point unit, but it does fix a "floating point underflow" exception I am getting, and there*/
-	/*is similar code in the Hursley java. Making sure we have the same code in Javascript      */
-	/*where Netscape was calling control87 on Windows...                                        */
-	_control87(MCW_EM+PC_53+RC_NEAR,MCW_EM+MCW_PC+MCW_RC);
-#else
-#if defined (_M_IX86)
-        /* On Alpha platform this is handled via Compiler option */
-        _control87(MCW_EM, MCW_EM);
-#endif
-#endif /* XP_OS2 */
-#endif /* XP_PC */
-#endif /* __MWERKS__ */
-
-	u.s.hi = JSDOUBLE_HI32_EXPMASK | JSDOUBLE_HI32_MANTMASK;
-	u.s.lo = 0xffffffff;
-	number_constants[NC_NaN].dval = NaN = u.d;
-	rt->jsNaN = js_NewDouble(cx, NaN);
-	if (!rt->jsNaN || !js_LockGCThing(cx, rt->jsNaN))
-	    return NULL;
-
-	u.s.hi = JSDOUBLE_HI32_EXPMASK;
-	u.s.lo = 0x00000000;
-	number_constants[NC_POSITIVE_INFINITY].dval = u.d;
-	rt->jsPositiveInfinity = js_NewDouble(cx, u.d);
-	if (!rt->jsPositiveInfinity ||
-	    !js_LockGCThing(cx, rt->jsPositiveInfinity)) {
-	    return NULL;
-	}
-
-	u.s.hi = JSDOUBLE_HI32_SIGNBIT | JSDOUBLE_HI32_EXPMASK;
-	u.s.lo = 0x00000000;
-	number_constants[NC_NEGATIVE_INFINITY].dval = u.d;
-	rt->jsNegativeInfinity = js_NewDouble(cx, u.d);
-	if (!rt->jsNegativeInfinity ||
-	    !js_LockGCThing(cx, rt->jsNegativeInfinity)) {
-	    return NULL;
-	}
-
-	u.s.hi = 0;
-	u.s.lo = 1;
-	number_constants[NC_MIN_VALUE].dval = u.d;
-    }
-
-    if (!JS_DefineFunctions(cx, obj, number_functions))
-	return NULL;
-
-    proto = JS_InitClass(cx, obj, NULL, &number_class, Number, 1,
-			 NULL, number_methods, NULL, NULL);
-    if (!proto || !(ctor = JS_GetConstructor(cx, proto)))
-	return NULL;
-    OBJ_SET_SLOT(cx, proto, JSSLOT_PRIVATE, JSVAL_ZERO);
-    if (!JS_DefineConstDoubles(cx, ctor, number_constants))
-	return NULL;
-
-    /* ECMA 15.1.1.1 */
-    if (!JS_DefineProperty(cx, obj, js_NaN_str, DOUBLE_TO_JSVAL(rt->jsNaN),
-			   NULL, NULL, 0)) {
-	return NULL;
-    }
-
-    /* ECMA 15.1.1.2 */
-    if (!JS_DefineProperty(cx, obj, "Infinity",
-			   DOUBLE_TO_JSVAL(rt->jsPositiveInfinity),
-			   NULL, NULL, 0)) {
-	return NULL;
-    }
-    return proto;
-}
-
-jsdouble *
-js_NewDouble(JSContext *cx, jsdouble d)
-{
-    jsdouble *dp;
-
-    dp = js_AllocGCThing(cx, GCX_DOUBLE);
-    if (!dp)
-	return NULL;
-    *dp = d;
-    return dp;
-}
-
-void
-js_FinalizeDouble(JSContext *cx, jsdouble *dp)
-{
-    *dp = NaN;
-}
-
-JSBool
-js_NewDoubleValue(JSContext *cx, jsdouble d, jsval *rval)
-{
-    jsdouble *dp;
-
-    dp = js_NewDouble(cx, d);
-    if (!dp)
-	return JS_FALSE;
-    *rval = DOUBLE_TO_JSVAL(dp);
-    return JS_TRUE;
-}
-
-JSBool
-js_NewNumberValue(JSContext *cx, jsdouble d, jsval *rval)
-{
-    jsint i;
-
-    if (JSDOUBLE_IS_INT(d, i) && INT_FITS_IN_JSVAL(i)) {
-	*rval = INT_TO_JSVAL(i);
-    } else {
-	if (!js_NewDoubleValue(cx, d, rval))
-	    return JS_FALSE;
-    }
-    return JS_TRUE;
-}
-
-JSObject *
-js_NumberToObject(JSContext *cx, jsdouble d)
-{
-    JSObject *obj;
-    jsval v;
-
-    obj = js_NewObject(cx, &number_class, NULL, NULL);
-    if (!obj)
-	return NULL;
-    if (!js_NewNumberValue(cx, d, &v)) {
-	cx->newborn[GCX_OBJECT] = NULL;
-	return NULL;
-    }
-    OBJ_SET_SLOT(cx, obj, JSSLOT_PRIVATE, v);
-    return obj;
-}
-
-JSString *
-js_NumberToString(JSContext *cx, jsdouble d)
-{
-    jsint i;
-    char buf[DTOSTR_STANDARD_BUFFER_SIZE];
-    char *numStr = buf;
-
-    if (JSDOUBLE_IS_INT(d, i))
-	JS_snprintf(buf, sizeof buf, "%ld", (long)i);
-    else {
-	numStr = JS_dtostr(buf, sizeof buf, DTOSTR_STANDARD, 0, d);
-	if (!numStr) {
-	    JS_ReportOutOfMemory(cx);
-	    return NULL;
-	}
-    }
-    return JS_NewStringCopyZ(cx, numStr);
-}
-
-JSBool
-js_ValueToNumber(JSContext *cx, jsval v, jsdouble *dp)
-{
-    JSObject *obj;
-    JSString *str;
-    const jschar *ep;
-    jsdouble d;
-
-    if (JSVAL_IS_OBJECT(v)) {
-	obj = JSVAL_TO_OBJECT(v);
-	if (!obj) {
-	    *dp = 0;
-	    return JS_TRUE;
-	}
-	if (!OBJ_DEFAULT_VALUE(cx, obj, JSTYPE_NUMBER, &v))
-	    return JS_FALSE;
-    }
-    if (JSVAL_IS_INT(v)) {
-	*dp = (jsdouble)JSVAL_TO_INT(v);
-    } else if (JSVAL_IS_DOUBLE(v)) {
-	*dp = *JSVAL_TO_DOUBLE(v);
-    } else if (JSVAL_IS_STRING(v)) {
-	str = JSVAL_TO_STRING(v);
-	errno = 0;
-	/* Note that ECMAScript doesn't treat numbers beginning with a zero as octal numbers here.
-	 * This works because all such numbers will be interpreted as decimal by js_strtod and
-	 * will never get passed to js_strtointeger, which would interpret them as octal. */
-	if ((!js_strtod(cx, str->chars, &ep, &d) || js_SkipWhiteSpace(ep) != str->chars + str->length) &&
-	    (!js_strtointeger(cx, str->chars, &ep, 0, &d) || js_SkipWhiteSpace(ep) != str->chars + str->length)) {
-	    goto badstr;
-	}
-	*dp = d;
-    } else if (JSVAL_IS_BOOLEAN(v)) {
-	*dp = JSVAL_TO_BOOLEAN(v) ? 1 : 0;
-    } else {
-#if JS_BUG_FALLIBLE_TONUM
-	str = js_DecompileValueGenerator(cx, JS_TRUE, v, NULL);
-badstr:
-	if (str) {
-	    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NAN,
-				 JS_GetStringBytes(str));
-
-	}
-	return JS_FALSE;
-#else
-badstr:
-	*dp = *cx->runtime->jsNaN;
-#endif
-    }
-    return JS_TRUE;
-}
-
-JSBool
-js_ValueToECMAInt32(JSContext *cx, jsval v, int32 *ip)
-{
-    jsdouble d;
-
-    if (!js_ValueToNumber(cx, v, &d))
-	return JS_FALSE;
-    return js_DoubleToECMAInt32(cx, d, ip);
-}
-
-JSBool
-js_DoubleToECMAInt32(JSContext *cx, jsdouble d, int32 *ip)
-{
-    jsdouble two32 = 4294967296.0;
-    jsdouble two31 = 2147483648.0;
-
-    if (!JSDOUBLE_IS_FINITE(d) || d == 0) {
-	*ip = 0;
-	return JS_TRUE;
-    }
-    d = fmod(d, two32);
-    d = d >= 0 ? d : d + two32;
-    if (d >= two31)
-	*ip = (int32)(d - two32);
-    else
-	*ip = (int32)d;
-    return JS_TRUE;
-}
-
-JSBool
-js_ValueToECMAUint32(JSContext *cx, jsval v, uint32 *ip)
-{
-    jsdouble d;
-
-    if (!js_ValueToNumber(cx, v, &d))
-	return JS_FALSE;
-    return js_DoubleToECMAUint32(cx, d, ip);
-}
-
-JSBool
-js_DoubleToECMAUint32(JSContext *cx, jsdouble d, uint32 *ip)
-{
-    JSBool neg;
-    jsdouble two32 = 4294967296.0;
-
-    if (!JSDOUBLE_IS_FINITE(d) || d == 0) {
-	*ip = 0;
-	return JS_TRUE;
-    }
-
-    neg = (d < 0);
-    d = floor(neg ? -d : d);
-    d = neg ? -d : d;
-
-    d = fmod(d, two32);
-
-    d = d >= 0 ? d : d + two32;
-    *ip = (uint32)d;
-    return JS_TRUE;
-}
-
-JSBool
-js_ValueToInt32(JSContext *cx, jsval v, int32 *ip)
-{
-    jsdouble d;
-    JSString *str;
-
-    if (!js_ValueToNumber(cx, v, &d))
-	return JS_FALSE;
-    if (JSDOUBLE_IS_NaN(d) || d <= -2147483649.0 || 2147483648.0 <= d) {
-	str = js_DecompileValueGenerator(cx, JS_TRUE, v, NULL);
-	if (str) {
-	    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
-				 JSMSG_CANT_CONVERT, JS_GetStringBytes(str));
-
-	}
-	return JS_FALSE;
-    }
-    *ip = (int32)floor(d + 0.5);     /* Round to nearest */
-    return JS_TRUE;
-}
-
-JSBool
-js_ValueToUint16(JSContext *cx, jsval v, uint16 *ip)
-{
-    jsdouble d;
-    jsuint i, m;
-    JSBool neg;
-
-    if (!js_ValueToNumber(cx, v, &d))
-	return JS_FALSE;
-    if (d == 0 || !JSDOUBLE_IS_FINITE(d)) {
-	*ip = 0;
-	return JS_TRUE;
-    }
-    i = (jsuint)d;
-    if ((jsdouble)i == d) {
-	*ip = (uint16)i;
-	return JS_TRUE;
-    }
-    neg = (d < 0);
-    d = floor(neg ? -d : d);
-    d = neg ? -d : d;
-    m = JS_BIT(16);
-    d = fmod(d, m);
-    if (d < 0)
-	d += m;
-    *ip = (uint16) d;
-    return JS_TRUE;
-}
-
-jsdouble
-js_DoubleToInteger(jsdouble d)
-{
-    JSBool neg;
-
-    if (d == 0)
-	return d;
-    if (!JSDOUBLE_IS_FINITE(d)) {
-	if (JSDOUBLE_IS_NaN(d))
-	    return 0;
-	return d;
-    }
-    neg = (d < 0);
-    d = floor(neg ? -d : d);
-    return neg ? -d : d;
-}
-
-
-JSBool
-js_strtod(JSContext *cx, const jschar *s, const jschar **ep, jsdouble *dp)
-{
-    size_t i;
-    char *cstr, *istr, *estr;
-    JSBool negative;
-    jsdouble d;
-    const jschar *s1 = js_SkipWhiteSpace(s);
-    size_t length = js_strlen(s1);
-
-    cstr = malloc(length + 1);
-    if (!cstr)
-	return JS_FALSE;
-    for (i = 0; i <= length; i++) {
-	if (s1[i] >> 8) {
-	    cstr[i] = 0;
-	    break;
-	}
-	cstr[i] = (char)s1[i];
-    }
-
-    istr = cstr;
-    if ((negative = (*istr == '-')) != 0 || *istr == '+')
-	istr++;
-    if (!strncmp(istr, "Infinity", 8)) {
-	d = *(negative ? cx->runtime->jsNegativeInfinity : cx->runtime->jsPositiveInfinity);
-	estr = istr + 8;
-    } else {
-	errno = 0;
-	d = JS_strtod(cstr, &estr);
-	if (errno == ERANGE) {
-	    if (d == HUGE_VAL)
-		d = *cx->runtime->jsPositiveInfinity;
-	    else if (d == -HUGE_VAL)
-		d = *cx->runtime->jsNegativeInfinity;
-        }
-#ifdef HPUX
-        if (d == 0.0 && negative) {
-            /*
-             * "-0", "-1e-2000" come out as positive zero
-    		 * here on HPUX. Force a negative zero instead.
-             */
-            JSDOUBLE_HI32(d) = JSDOUBLE_HI32_SIGNBIT;
-            JSDOUBLE_LO32(d) = 0;
-        }
-#endif
-    }
-
-    free(cstr);
-    i = estr - cstr;
-    *ep = i ? s1 + i : s;
-    *dp = d;
-    return JS_TRUE;
-}
-
-struct BinaryDigitReader
-{
-    uintN base;			/* Base of number; must be a power of 2 */
-    uintN digit;		/* Current digit value in radix given by base */
-    uintN digitMask;		/* Mask to extract the next bit from digit */
-    const jschar *digits;	/* Pointer to the remaining digits */
-    const jschar *end;		/* Pointer to first non-digit */
-};
-
-/* Return the next binary digit from the number or -1 if done */
-static intN GetNextBinaryDigit(struct BinaryDigitReader *bdr)
-{
-    intN bit;
-
-    if (bdr->digitMask == 0) {
-	uintN c;
-
-	if (bdr->digits == bdr->end)
-	    return -1;
-
-	c = *bdr->digits++;
-	if ('0' <= c && c <= '9')
-	    bdr->digit = c - '0';
-	else if ('a' <= c && c <= 'z')
-	    bdr->digit = c - 'a' + 10;
-	else bdr->digit = c - 'A' + 10;
-	bdr->digitMask = bdr->base >> 1;
-    }
-    bit = (bdr->digit & bdr->digitMask) != 0;
-    bdr->digitMask >>= 1;
-    return bit;
-}
-
-JSBool
-js_strtointeger(JSContext *cx, const jschar *s, const jschar **ep, jsint base, jsdouble *dp)
-{
-    JSBool negative;
-    jsdouble value;
-    const jschar *start;
-    const jschar *s1 = js_SkipWhiteSpace(s);
-
-    if ((negative = (*s1 == '-')) != 0 || *s1 == '+')
-	s1++;
-
-    if (base == 0)
-	/* No base supplied, or some base that evaluated to 0. */
-	if (*s1 == '0')
-	    /* It's either hex or octal; only increment char if str isn't '0' */
-	    if (s1[1] == 'X' || s1[1] == 'x') { /* Hex */
-		s1 += 2;
-		base = 16;
-	    } else /* Octal */
-		base = 8;
-	else
-	    base = 10; /* Default to decimal. */
-    else if (base == 16 && *s1 == '0' && (s1[1] == 'X' || s1[1] == 'x'))
-	/* If base is 16, ignore hex prefix. */
-	s1 += 2;
-
-    /* Done with the preliminaries; find some prefix of the string that's
-     * a number in the given base.
-     */
-    start = s1; /* Mark - if string is empty, we return NaN. */
-    value = 0.0;
-    while (1) {
-	uintN digit;
-	jschar c = *s1;
-	if ('0' <= c && c <= '9')
-	    digit = c - '0';
-	else if ('a' <= c && c <= 'z')
-	    digit = c - 'a' + 10;
-	else if ('A' <= c && c <= 'Z')
-	    digit = c - 'A' + 10;
-	else
-	    break;
-	if (digit >= (uintN)base)
-	    break;
-	value = value*base + digit;
-	s1++;
-    }
-
-    if (value >= 9007199254740992.0) {
-	if (base == 10) {
-	    /* If we're accumulating a decimal number and the number is >= 2^53, then
-	     * the result from the repeated multiply-add above may be inaccurate.  Call
-	     * JS_strtod to get the correct answer.
-	     */
-	    size_t i;
-	    size_t length = s1 - start;
-	    char *cstr = malloc(length + 1);
-	    char *estr;
-
-	    if (!cstr)
-		return JS_FALSE;
-	    for (i = 0; i != length; i++)
-		cstr[i] = (char)start[i];
-	    cstr[length] = 0;
-
-	    errno = 0;
-	    value = JS_strtod(cstr, &estr);
-	    if (errno == ERANGE && value == HUGE_VAL)
-		value = *cx->runtime->jsPositiveInfinity;
-	    free(cstr);
-
-	} else if (base == 2 || base == 4 || base == 8 || base == 16 || base == 32) {
-	    /* The number may also be inaccurate for one of these bases.  This
-	     * happens if the addition in value*base + digit causes a round-down
-	     * to an even least significant mantissa bit when the first dropped bit
-	     * is a one.  If any of the following digits in the number (which haven't
-	     * been added in yet) are nonzero then the correct action would have
-	     * been to round up instead of down.  An example of this occurs when
-	     * reading the number 0x1000000000000081, which rounds to 0x1000000000000000
-	     * instead of 0x1000000000000100.
-	     */
-	    struct BinaryDigitReader bdr;
-	    intN bit, bit2;
-	    intN j;
-
-	    bdr.base = base;
-	    bdr.digitMask = 0;
-	    bdr.digits = start;
-	    bdr.end = s1;
-	    value = 0.0;
-
-	    /* Skip leading zeros. */
-	    do {
-		bit = GetNextBinaryDigit(&bdr);
-	    } while (bit == 0);
-
-	    if (bit == 1) {
-		/* Gather the 53 significant bits (including the leading 1) */
-		value = 1.0;
-		for (j = 52; j; j--) {
-		    bit = GetNextBinaryDigit(&bdr);
-		    if (bit < 0)
-			goto done;
-		    value = value*2 + bit;
-		}
-		/* bit2 is the 54th bit (the first dropped from the mantissa) */
-		bit2 = GetNextBinaryDigit(&bdr);
-		if (bit2 >= 0) {
-		    jsdouble factor = 2.0;
-		    intN sticky = 0;  /* sticky is 1 if any bit beyond the 54th is 1 */
-		    intN bit3;
-
-		    while ((bit3 = GetNextBinaryDigit(&bdr)) >= 0) {
-			sticky |= bit3;
-			factor *= 2;
-		    }
-		    value += bit2 & (bit | sticky);
-		    value *= factor;
-		}
-	      done:;
-	    }
-	}
-    }
-    /* We don't worry about inaccurate numbers for any other base. */
-
-    if (s1 == start) {
-	*dp = 0.0;
-	*ep = s;
-    } else {
-	*dp = negative ? -value : value;
-	*ep = s1;
-    }
-    return JS_TRUE;
-}

mozilla/js/src/jsnum.h

@@ -1,183 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, released
- * March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *
- * Alternatively, the contents of this file may be used under the
- * terms of the GNU Public License (the "GPL"), in which case the
- * provisions of the GPL are applicable instead of those above.
- * If you wish to allow use of your version of this file only
- * under the terms of the GPL and not to allow others to use your
- * version of this file under the NPL, indicate your decision by
- * deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL.  If you do not delete
- * the provisions above, a recipient may use your version of this
- * file under either the NPL or the GPL.
- */
-
-#ifndef jsnum_h___
-#define jsnum_h___
-/*
- * JS number (IEEE double) interface.
- *
- * JS numbers are optimistically stored in the top 31 bits of 32-bit integers,
- * but floating point literals, results that overflow 31 bits, and division and
- * modulus operands and results require a 64-bit IEEE double.  These are GC'ed
- * and pointed to by 32-bit jsvals on the stack and in object properties.
- *
- * When a JS number is treated as an object (followed by . or []), the runtime
- * wraps it with a JSObject whose valueOf method returns the unwrapped number.
- */
-
-JS_BEGIN_EXTERN_C
-
-#ifdef IS_LITTLE_ENDIAN
-#define JSDOUBLE_HI32(x)        (((uint32 *)&(x))[1])
-#define JSDOUBLE_LO32(x)        (((uint32 *)&(x))[0])
-#else
-#define JSDOUBLE_HI32(x)        (((uint32 *)&(x))[0])
-#define JSDOUBLE_LO32(x)        (((uint32 *)&(x))[1])
-#endif
-#define JSDOUBLE_HI32_SIGNBIT   0x80000000
-#define JSDOUBLE_HI32_EXPMASK   0x7ff00000
-#define JSDOUBLE_HI32_MANTMASK  0x000fffff
-
-#define JSDOUBLE_IS_NaN(x)                                                    \
-    ((JSDOUBLE_HI32(x) & JSDOUBLE_HI32_EXPMASK) == JSDOUBLE_HI32_EXPMASK &&   \
-     (JSDOUBLE_LO32(x) || (JSDOUBLE_HI32(x) & JSDOUBLE_HI32_MANTMASK)))
-
-#define JSDOUBLE_IS_INFINITE(x)                                               \
-    ((JSDOUBLE_HI32(x) & ~JSDOUBLE_HI32_SIGNBIT) == JSDOUBLE_HI32_EXPMASK &&   \
-     !JSDOUBLE_LO32(x))
-
-#define JSDOUBLE_IS_FINITE(x)                                                 \
-    ((JSDOUBLE_HI32(x) & JSDOUBLE_HI32_EXPMASK) != JSDOUBLE_HI32_EXPMASK)
-
-#define JSDOUBLE_IS_NEGZERO(d)  (JSDOUBLE_HI32(d) == JSDOUBLE_HI32_SIGNBIT && \
-				 JSDOUBLE_LO32(d) == 0)
-
-/*
- * JSDOUBLE_IS_INT first checks that d is neither NaN nor infinite, to avoid
- * raising SIGFPE on platforms such as Alpha Linux, then (only if the cast is
- * safe) leaves i as (jsint)d.  This also avoid anomalous NaN floating point
- * comparisons under MSVC.
- */
-#define JSDOUBLE_IS_INT(d, i) (JSDOUBLE_IS_FINITE(d) && !JSDOUBLE_IS_NEGZERO(d) \
-			       && ((d) == (i = (jsint)(d))))
-
-/* Initialize the Number class, returning its prototype object. */
-extern JSObject *
-js_InitNumberClass(JSContext *cx, JSObject *obj);
-
-/* GC-allocate a new JS number. */
-extern jsdouble *
-js_NewDouble(JSContext *cx, jsdouble d);
-
-extern void
-js_FinalizeDouble(JSContext *cx, jsdouble *dp);
-
-extern JSBool
-js_NewDoubleValue(JSContext *cx, jsdouble d, jsval *rval);
-
-extern JSBool
-js_NewNumberValue(JSContext *cx, jsdouble d, jsval *rval);
-
-/* Construct a Number instance that wraps around d. */
-extern JSObject *
-js_NumberToObject(JSContext *cx, jsdouble d);
-
-/* Convert a number to a GC'ed string. */
-extern JSString *
-js_NumberToString(JSContext *cx, jsdouble d);
-
-/*
- * Convert a value to a number, returning false after reporting any error,
- * otherwise returning true with *dp set.
- */
-extern JSBool
-js_ValueToNumber(JSContext *cx, jsval v, jsdouble *dp);
-
-/*
- * Convert a value or a double to an int32, according to the ECMA rules
- * for ToInt32.
- */
-extern JSBool
-js_ValueToECMAInt32(JSContext *cx, jsval v, int32 *ip);
-
-extern JSBool
-js_DoubleToECMAInt32(JSContext *cx, jsdouble d, int32 *ip);
-
-/*
- * Convert a value or a double to a uint32, according to the ECMA rules
- * for ToUint32.
- */
-extern JSBool
-js_ValueToECMAUint32(JSContext *cx, jsval v, uint32 *ip);
-
-extern JSBool
-js_DoubleToECMAUint32(JSContext *cx, jsdouble d, uint32 *ip);
-
-/*
- * Convert a value to a number, then to an int32 if it fits by rounding to
- * nearest; but failing with an error report if the double is out of range
- * or unordered.
- */
-extern JSBool
-js_ValueToInt32(JSContext *cx, jsval v, int32 *ip);
-
-/*
- * Convert a value to a number, then to a uint16 according to the ECMA rules
- * for ToUint16.
- */
-extern JSBool
-js_ValueToUint16(JSContext *cx, jsval v, uint16 *ip);
-
-/*
- * Convert a jsdouble to an integral number, stored in a jsdouble.
- * If d is NaN, return 0.  If d is an infinity, return it without conversion.
- */
-extern jsdouble
-js_DoubleToInteger(jsdouble d);
-
-/*
- * Similar to strtod except that replaces overflows with infinities of the correct
- * sign and underflows with zeros of the correct sign.  Guaranteed to return the
- * closest double number to the given input in dp.
- * Also allows inputs of the form [+|-]Infinity, which produce an infinity of the
- * appropriate sign.  The case of the "Infinity" string must match.
- * If the string does not have a number in it, set *ep to s and return 0.0 in dp.
- * Return false if out of memory.
- */
-extern JSBool
-js_strtod(JSContext *cx, const jschar *s, const jschar **ep, jsdouble *dp);
-
-/*
- * Similar to strtol except that handles integers of arbitrary size.  Guaranteed to
- * return the closest double number to the given input when radix is 10 or a power of 2.
- * May experience roundoff errors for very large numbers of a different radix.
- * If the string does not have a number in it, set *ep to s and return 0.0 in dp.
- * Return false if out of memory.
- */
-extern JSBool
-js_strtointeger(JSContext *cx, const jschar *s, const jschar **ep, jsint radix, jsdouble *dp);
-
-JS_END_EXTERN_C
-
-#endif /* jsnum_h___ */