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/extensions/transformiix/Makefile.in

@@ -1,34 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla 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/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is Transformiix XSLT Processor.
-# 
-# The Initial Developer of the Original Code is Axel Hecht.
-# Portions created by Axel Hecht are  Copyright (C) Axel Hecht.
-# All Rights Reserved.
-# 
-# Contributor(s):
-#	Axel Hecht <axel@pike.org>
-# 
-
-DEPTH           = ../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS            = source
-ifndef TX_EXE
-DIRS += build
-endif
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/transformiix/build/Makefile.in

@@ -1,152 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla 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/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is Transformiix XSLT Processor.
-# 
-# The Initial Developer of the Original Code is Axel Hecht.
-# Portions created by Axel Hecht are  Copyright (C) Axel Hecht.
-# All Rights Reserved.
-# 
-# Contributor(s):
-#	Axel Hecht <axel@pike.org>
-# 
-
-DEPTH           = ../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= transformiix
-LIBRARY_NAME	= transformiix
-EXPORT_LIBRARY = 1
-ifneq ($(OS_ARCH),WINNT)
-SHORT_LIBNAME	= t8iix
-endif
-REQUIRES	= xpcom \
-		  string \
-		  dom \
-		  content \
-		  widget \
-		  necko \
-		  js \
-		  xpconnect \
-		  caps \
-		  locale \
-		  unicharutil \
-		  htmlparser \
-		  webshell \
-		  docshell \
-		  layout \
-		  uconv \
-		  $(NULL)
-IS_COMPONENT	= 1
-MODULE_NAME	= TransformiixModule
-
-
-CPPSRCS = XSLTProcessorModule.cpp
-LOBJS = ../source/base/Double.$(OBJ_SUFFIX) \
-  ../source/base/List.$(OBJ_SUFFIX) \
-  ../source/base/SimpleErrorObserver.$(OBJ_SUFFIX) \
-  ../source/base/txAtoms.$(OBJ_SUFFIX) \
-  ../source/base/txExpandedNameMap.$(OBJ_SUFFIX) \
-  ../source/base/txNamespaceMap.$(OBJ_SUFFIX) \
-  ../source/base/txURIUtils.$(OBJ_SUFFIX) \
-  ../source/xml/dom/mozImpl/MozillaAttr.$(OBJ_SUFFIX) \
-  ../source/xml/dom/mozImpl/MozillaDocument.$(OBJ_SUFFIX) \
-  ../source/xml/dom/mozImpl/MozillaElement.$(OBJ_SUFFIX) \
-  ../source/xml/dom/mozImpl/MozillaNamedNodeMap.$(OBJ_SUFFIX) \
-  ../source/xml/dom/mozImpl/MozillaNode.$(OBJ_SUFFIX) \
-  ../source/xml/dom/mozImpl/MozillaProcInstruction.$(OBJ_SUFFIX) \
-  ../source/xpath/AdditiveExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/AttributeValueTemplate.$(OBJ_SUFFIX) \
-  ../source/xpath/BooleanExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/BooleanFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xpath/BooleanResult.$(OBJ_SUFFIX) \
-  ../source/xpath/ExprLexer.$(OBJ_SUFFIX) \
-  ../source/xpath/ExprParser.$(OBJ_SUFFIX) \
-  ../source/xpath/FilterExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/FunctionCall.$(OBJ_SUFFIX) \
-  ../source/xpath/LocationStep.$(OBJ_SUFFIX) \
-  ../source/xpath/MultiplicativeExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/NodeSet.$(OBJ_SUFFIX) \
-  ../source/xpath/NodeSetFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xpath/nsXPathEvaluator.$(OBJ_SUFFIX) \
-  ../source/xpath/nsXPathException.$(OBJ_SUFFIX) \
-  ../source/xpath/nsXPathExpression.$(OBJ_SUFFIX) \
-  ../source/xpath/nsXPathNSResolver.$(OBJ_SUFFIX) \
-  ../source/xpath/nsXPathResult.$(OBJ_SUFFIX) \
-  ../source/xpath/nsXPath1Scheme.$(OBJ_SUFFIX) \
-  ../source/xpath/NumberExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/NumberFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xpath/NumberResult.$(OBJ_SUFFIX) \
-  ../source/xpath/PathExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/PredicateList.$(OBJ_SUFFIX) \
-  ../source/xpath/RelationalExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/RootExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/StringExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/StringFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xpath/StringResult.$(OBJ_SUFFIX) \
-  ../source/xpath/txNameTest.$(OBJ_SUFFIX) \
-  ../source/xpath/txNodeTypeTest.$(OBJ_SUFFIX) \
-  ../source/xpath/txForwardContext.$(OBJ_SUFFIX) \
-  ../source/xpath/txNodeSetContext.$(OBJ_SUFFIX) \
-  ../source/xpath/UnionExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/UnaryExpr.$(OBJ_SUFFIX) \
-  ../source/xpath/VariableRefExpr.$(OBJ_SUFFIX) \
-  ../source/xml/XMLUtils.$(OBJ_SUFFIX) \
-  ../source/xml/XMLDOMUtils.$(OBJ_SUFFIX) \
-  ../source/xml/parser/txXMLParser.$(OBJ_SUFFIX) \
-  ../source/xslt/txBufferingHandler.$(OBJ_SUFFIX) \
-  ../source/xslt/txOutputFormat.$(OBJ_SUFFIX) \
-  ../source/xslt/txExecutionState.$(OBJ_SUFFIX) \
-  ../source/xslt/txInstructions.$(OBJ_SUFFIX) \
-  ../source/xslt/txMozillaStylesheetCompiler.$(OBJ_SUFFIX) \
-  ../source/xslt/txMozillaTextOutput.$(OBJ_SUFFIX) \
-  ../source/xslt/txMozillaXSLTProcessor.$(OBJ_SUFFIX) \
-  ../source/xslt/txMozillaXMLOutput.$(OBJ_SUFFIX) \
-  ../source/xslt/txRtfHandler.$(OBJ_SUFFIX) \
-  ../source/xslt/txStylesheet.$(OBJ_SUFFIX) \
-  ../source/xslt/txStylesheetCompileHandlers.$(OBJ_SUFFIX) \
-  ../source/xslt/txStylesheetCompiler.$(OBJ_SUFFIX) \
-  ../source/xslt/txTextHandler.$(OBJ_SUFFIX) \
-  ../source/xslt/txToplevelItems.$(OBJ_SUFFIX) \
-  ../source/xslt/txUnknownHandler.$(OBJ_SUFFIX) \
-  ../source/xslt/txXSLTNumber.$(OBJ_SUFFIX) \
-  ../source/xslt/txXSLTNumberCounters.$(OBJ_SUFFIX) \
-  ../source/xslt/txXSLTPatterns.$(OBJ_SUFFIX) \
-  ../source/xslt/txXSLTProcessor.$(OBJ_SUFFIX) \
-  ../source/xslt/txPatternParser.$(OBJ_SUFFIX) \
-  ../source/xslt/functions/CurrentFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xslt/functions/DocumentFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xslt/functions/ElementAvailableFnCall.$(OBJ_SUFFIX) \
-  ../source/xslt/functions/FunctionAvailableFnCall.$(OBJ_SUFFIX) \
-  ../source/xslt/functions/GenerateIdFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xslt/functions/SystemPropertyFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xslt/functions/txFormatNumberFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xslt/functions/txKeyFunctionCall.$(OBJ_SUFFIX) \
-  ../source/xslt/util/txNodeSorter.$(OBJ_SUFFIX) \
-  ../source/xslt/util/txXPathResultComparator.$(OBJ_SUFFIX) \
-  $(NULL)
-
-EXTRA_DSO_LDOPTS += \
-  $(MOZ_UNICHARUTIL_LIBS) \
-  $(MOZ_COMPONENT_LIBS) \
-  $(MOZ_JS_LIBS) \
-  $(NULL)
-
-include $(topsrcdir)/config/rules.mk
-
-INCLUDES += -I$(srcdir)/../source/xslt -I$(srcdir)/../source/base \
-  -I$(srcdir)/../source/xml -I$(srcdir)/../source/xml/dom \
-  -I$(srcdir)/../source/xml/parser -I$(srcdir)/../source/xpath \
-  -I$(srcdir)/../source/xslt/util -I$(srcdir)/../source/xslt/functions

mozilla/extensions/transformiix/build/XSLTProcessorModule.cpp

@@ -1,279 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Peter Van der Beken are Copyright (C) 2000
- * Peter Van der Beken. All Rights Reserved.
- *
- * Contributor(s):
- * Peter Van der Beken, peter.vanderbeken@pandora.be
- *    -- original author.
- *
- */
-
-#include "nsICategoryManager.h"
-#include "nsIDOMClassInfo.h"
-#include "nsIExceptionService.h"
-#include "nsIGenericFactory.h"
-#include "nsIScriptNameSpaceManager.h"
-#include "nsIServiceManager.h"
-#include "nsXPathEvaluator.h"
-#include "nsXPathException.h"
-#include "nsXPathExpression.h"
-#include "nsXPathNSResolver.h"
-#include "nsXPathResult.h"
-#include "nsXPIDLString.h"
-#include "txAtoms.h"
-#include "txMozillaXSLTProcessor.h"
-#include "TxLog.h"
-#include "nsCRT.h"
-#include "nsIScriptSecurityManager.h"
-#include "txURIUtils.h"
-#include "txXSLTProcessor.h"
-#include "nsXPath1Scheme.h"
-
-NS_GENERIC_FACTORY_CONSTRUCTOR(nsXPath1SchemeProcessor)
-
-/* 1c1a3c01-14f6-11d6-a7f2-ea502af815dc */
-#define TRANSFORMIIX_DOMCI_EXTENSION_CID   \
-{ 0x1c1a3c01, 0x14f6, 0x11d6, {0xa7, 0xf2, 0xea, 0x50, 0x2a, 0xf8, 0x15, 0xdc} }
-
-/* {0C351177-0159-4500-86B0-A219DFDE4258} */
-#define TRANSFORMIIX_XPATH1_SCHEME_CID \
-{ 0xc351177, 0x159, 0x4500, { 0x86, 0xb0, 0xa2, 0x19, 0xdf, 0xde, 0x42, 0x58 } }
-
-#define TRANSFORMIIX_DOMCI_EXTENSION_CONTRACTID \
-"@mozilla.org/transformiix-domci-extender;1"
-
-NS_DOMCI_EXTENSION(Transformiix)
-    static NS_DEFINE_CID(kXSLTProcessorCID, TRANSFORMIIX_XSLT_PROCESSOR_CID);
-    NS_DOMCI_EXTENSION_ENTRY_BEGIN(XSLTProcessor)
-        NS_DOMCI_EXTENSION_ENTRY_INTERFACE(nsIXSLTProcessor)
-        NS_DOMCI_EXTENSION_ENTRY_INTERFACE(nsIXSLTProcessorObsolete) // XXX DEPRECATED
-    NS_DOMCI_EXTENSION_ENTRY_END(XSLTProcessor, nsIXSLTProcessor, PR_TRUE,
-                                 &kXSLTProcessorCID)
-
-    static NS_DEFINE_CID(kXPathEvaluatorCID, TRANSFORMIIX_XPATH_EVALUATOR_CID);
-    NS_DOMCI_EXTENSION_ENTRY_BEGIN(XPathEvaluator)
-        NS_DOMCI_EXTENSION_ENTRY_INTERFACE(nsIDOMXPathEvaluator)
-    NS_DOMCI_EXTENSION_ENTRY_END(XPathEvaluator, nsIDOMXPathEvaluator, PR_TRUE,
-                                 &kXPathEvaluatorCID)
-
-    NS_DOMCI_EXTENSION_ENTRY_BEGIN(XPathException)
-        NS_DOMCI_EXTENSION_ENTRY_INTERFACE(nsIDOMXPathException)
-        NS_DOMCI_EXTENSION_ENTRY_INTERFACE(nsIException)
-    NS_DOMCI_EXTENSION_ENTRY_END(XPathException, nsIDOMXPathException, PR_TRUE,
-                                 nsnull)
-
-    NS_DOMCI_EXTENSION_ENTRY_BEGIN(XPathExpression)
-        NS_DOMCI_EXTENSION_ENTRY_INTERFACE(nsIDOMXPathExpression)
-    NS_DOMCI_EXTENSION_ENTRY_END(XPathExpression, nsIDOMXPathExpression,
-                                 PR_TRUE, nsnull)
-
-    NS_DOMCI_EXTENSION_ENTRY_BEGIN(XPathNSResolver)
-        NS_DOMCI_EXTENSION_ENTRY_INTERFACE(nsIDOMXPathNSResolver)
-    NS_DOMCI_EXTENSION_ENTRY_END(XPathNSResolver, nsIDOMXPathNSResolver,
-                                 PR_TRUE, nsnull)
-
-    NS_DOMCI_EXTENSION_ENTRY_BEGIN(XPathResult)
-        NS_DOMCI_EXTENSION_ENTRY_INTERFACE(nsIDOMXPathResult)
-    NS_DOMCI_EXTENSION_ENTRY_END(XPathResult, nsIDOMXPathResult, PR_TRUE,
-                                 nsnull)
-NS_DOMCI_EXTENSION_END
-
-// Factory Constructor
-NS_GENERIC_FACTORY_CONSTRUCTOR(txMozillaXSLTProcessor)
-NS_GENERIC_FACTORY_CONSTRUCTOR(nsXPathEvaluator)
-
-NS_DECL_DOM_CLASSINFO(XSLTProcessor)
-NS_DECL_DOM_CLASSINFO(XPathEvaluator)
-NS_DECL_DOM_CLASSINFO(XPathException)
-NS_DECL_DOM_CLASSINFO(XPathExpression)
-NS_DECL_DOM_CLASSINFO(XPathNSResolver)
-NS_DECL_DOM_CLASSINFO(XPathResult)
-
-static NS_METHOD 
-RegisterTransformiix(nsIComponentManager *aCompMgr,
-                     nsIFile *aPath,
-                     const char *registryLocation,
-                     const char *componentType,
-                     const nsModuleComponentInfo *info)
-{
-    nsresult rv = NS_OK;
-
-    nsCOMPtr<nsICategoryManager> catman =
-        do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
-
-    if (NS_FAILED(rv))
-        return rv;
-
-    nsXPIDLCString previous;
-    rv = catman->AddCategoryEntry(JAVASCRIPT_DOM_CLASS,
-                                  "XSLTProcessor",
-                                  TRANSFORMIIX_DOMCI_EXTENSION_CONTRACTID,
-                                  PR_TRUE, PR_TRUE, getter_Copies(previous));
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = catman->AddCategoryEntry(JAVASCRIPT_DOM_CLASS,
-                                  "XPathEvaluator",
-                                  TRANSFORMIIX_DOMCI_EXTENSION_CONTRACTID,
-                                  PR_TRUE, PR_TRUE, getter_Copies(previous));
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = catman->AddCategoryEntry(JAVASCRIPT_DOM_CLASS,
-                                  "XPathException",
-                                  TRANSFORMIIX_DOMCI_EXTENSION_CONTRACTID,
-                                  PR_TRUE, PR_TRUE, getter_Copies(previous));
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = catman->AddCategoryEntry(JAVASCRIPT_DOM_CLASS,
-                                  "XPathExpression",
-                                  TRANSFORMIIX_DOMCI_EXTENSION_CONTRACTID,
-                                  PR_TRUE, PR_TRUE, getter_Copies(previous));
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = catman->AddCategoryEntry(JAVASCRIPT_DOM_CLASS,
-                                  "XPathNSResolver",
-                                  TRANSFORMIIX_DOMCI_EXTENSION_CONTRACTID,
-                                  PR_TRUE, PR_TRUE, getter_Copies(previous));
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = catman->AddCategoryEntry(JAVASCRIPT_DOM_CLASS,
-                                  "XPathResult",
-                                  TRANSFORMIIX_DOMCI_EXTENSION_CONTRACTID,
-                                  PR_TRUE, PR_TRUE, getter_Copies(previous));
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    char* iidString = NS_GET_IID(nsIXSLTProcessorObsolete).ToString();
-    if (!iidString)
-      return NS_ERROR_OUT_OF_MEMORY;
-    rv = catman->AddCategoryEntry(JAVASCRIPT_DOM_INTERFACE,
-                                  "nsIXSLTProcessorObsolete",
-                                  iidString,
-                                  PR_TRUE, PR_TRUE, getter_Copies(previous));
-    nsCRT::free(iidString);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    iidString = NS_GET_IID(nsIXSLTProcessor).ToString();
-    if (!iidString)
-      return NS_ERROR_OUT_OF_MEMORY;
-    rv = catman->AddCategoryEntry(JAVASCRIPT_DOM_INTERFACE,
-                                  "nsIXSLTProcessor",
-                                  iidString,
-                                  PR_TRUE, PR_TRUE, getter_Copies(previous));
-    nsCRT::free(iidString);
-
-    return rv;
-}
-
-static PRBool gInitialized = PR_FALSE;
-static nsIExceptionProvider *gXPathExceptionProvider = 0;
-nsINameSpaceManager *gTxNameSpaceManager = 0;
-
-// Perform our one-time intialization for this module
-PR_STATIC_CALLBACK(nsresult)
-Initialize(nsIModule* aSelf)
-{
-    NS_PRECONDITION(!gInitialized, "module already initialized");
-    if (gInitialized)
-        return NS_OK;
-
-    gInitialized = PR_TRUE;
-
-    gXPathExceptionProvider = new nsXPathExceptionProvider();
-    if (!gXPathExceptionProvider)
-        return NS_ERROR_OUT_OF_MEMORY;
-    NS_ADDREF(gXPathExceptionProvider);
-    nsCOMPtr<nsIExceptionService> xs =
-        do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID);
-    if (xs)
-        xs->RegisterExceptionProvider(gXPathExceptionProvider,
-                                      NS_ERROR_MODULE_DOM_XPATH);
-
-    if (!txXSLTProcessor::init()) {
-        return NS_ERROR_OUT_OF_MEMORY;
-    }
-
-    nsresult rv = CallGetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID,
-                                 &gTxSecurityManager);
-    if (NS_FAILED(rv)) {
-        gTxSecurityManager = nsnull;
-        return rv;
-    }
-
-    rv = CallGetService(NS_NAMESPACEMANAGER_CONTRACTID, &gTxNameSpaceManager);
-    if (NS_FAILED(rv)) {
-        gTxNameSpaceManager = nsnull;
-        return rv;
-    }
-
-    return NS_OK;
-}
-
-// Shutdown this module, releasing all of the module resources
-PR_STATIC_CALLBACK(void)
-Shutdown(nsIModule* aSelf)
-{
-    NS_PRECONDITION(gInitialized, "module not initialized");
-    if (!gInitialized)
-        return;
-
-    gInitialized = PR_FALSE;
-    if (gXPathExceptionProvider) {
-        nsCOMPtr<nsIExceptionService> xs =
-            do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID);
-        if (xs)
-            xs->UnregisterExceptionProvider(gXPathExceptionProvider,
-                                            NS_ERROR_MODULE_DOM_XPATH);
-        NS_RELEASE(gXPathExceptionProvider);
-    }
-
-    NS_IF_RELEASE(NS_CLASSINFO_NAME(XSLTProcessor));
-    NS_IF_RELEASE(NS_CLASSINFO_NAME(XPathEvaluator));
-    NS_IF_RELEASE(NS_CLASSINFO_NAME(XPathException));
-    NS_IF_RELEASE(NS_CLASSINFO_NAME(XPathExpression));
-    NS_IF_RELEASE(NS_CLASSINFO_NAME(XPathNSResolver));
-    NS_IF_RELEASE(NS_CLASSINFO_NAME(XPathResult));
-
-    txXSLTProcessor::shutdown();
-
-    NS_IF_RELEASE(gTxSecurityManager);
-    NS_IF_RELEASE(gTxNameSpaceManager);
-}
-
-// Component Table
-static const nsModuleComponentInfo gComponents[] = {
-    { "XSLTProcessor",
-      TRANSFORMIIX_XSLT_PROCESSOR_CID,
-      TRANSFORMIIX_XSLT_PROCESSOR_CONTRACTID,
-      txMozillaXSLTProcessorConstructor,
-      RegisterTransformiix },
-    { "XPathEvaluator",
-      TRANSFORMIIX_XPATH_EVALUATOR_CID,
-      NS_XPATH_EVALUATOR_CONTRACTID,
-      nsXPathEvaluatorConstructor },
-    { "Transformiix DOMCI Extender",
-      TRANSFORMIIX_DOMCI_EXTENSION_CID,
-      TRANSFORMIIX_DOMCI_EXTENSION_CONTRACTID,
-      NS_DOMCI_EXTENSION_CONSTRUCTOR(Transformiix) },
-    { "XPath1 XPointer Scheme Processor",
-      TRANSFORMIIX_XPATH1_SCHEME_CID,
-      NS_XPOINTER_SCHEME_PROCESSOR_BASE "xpath1",
-      nsXPath1SchemeProcessorConstructor }
-};
-
-NS_IMPL_NSGETMODULE_WITH_CTOR_DTOR(TransformiixModule, gComponents,
-                                   Initialize, Shutdown)

mozilla/extensions/transformiix/build/transformiix.jst

@@ -1,30 +0,0 @@
-var err = initInstall("Transformiix", "Transformiix", $Version$); 
-logComment("initInstall: " + err);
-
-var fProgram = getFolder("Program");
-logComment("fProgram: " + fProgram);
-
-if (verifyDiskSpace(fProgram, $SpaceRequired$))
-{
-    err = addDirectory("Transformiix",
-                       $Version$,
-                       "bin",
-                       fProgram,
-                       "",
-                       true );
-
-    logComment("addDirectory() returned: " + err);
-
-    if (err==SUCCESS)
-    {
-	    err = performInstall(); 
-          logComment("performInstall() returned: " + err);
-    }
-    else
-    {
-	    cancelInstall(err);
-	    logComment("cancelInstall() due to error: " + err);
-    }
-}
-else
-    cancelInstall(INSUFFICIENT_DISK_SPACE);

mozilla/extensions/transformiix/docs/changes.txt

@@ -1,227 +0,0 @@
-TransforMiiX (TM)
-(C) Copyright 1999, 2000, The MITRE Corporation, Keith Visco, et al. All rights reserved.
-
-Note: The changes listed here mainly reflect the core XSLT processor and
-      the standalone version.
-
-Build 20000906
-
--- Fixed UTF8 bug
-   - reported by Steve Tinney (stinney@sas.upenn.edu)
-
--- Updated Expat for standalone version
-
-Build 20000725
-
--- Windows Makefiles are up to date to create Mozilla module
-   - thanx to Arthur Barrett and Justin Smith
-
-Build 20000722
-
--- Fixed leading + trailing whitspace when printing comments
-   - reported by Jeff Bailey
-
--- Fixed bug in ExprLexer caused by a previous patch
-   - The prevToken was being set to NULL, in cases when
-     it shouldn't have been
-   - discovered when looking for an error reported by
-     Bernhard Zwischenbrugger
-
-Build 20000618
-
--- Added changes from Olivier Gerardin for improved
-   handling of template parameters
-
-Build 20000523
-
--- Added fix from Marc Schefer regarding OR expressions
-   - If the left hand expression was false...the right
-     hand expression was not evaluated (which should
-     only happen if the expression is an AND expr).
-
--- Added support for document() function
-   - implemented by Olivier Gerardin
-   - The second argument to the function is not yet supported
-
--- Added support for lang() function
-   - implemented by Marina Mechtcherikova
-
--- Fixed bug with doing xsl:copy-of on a document node.
-   - reported by Olivier Gerardin
-
-
-Build 20000420
-
--- Fixed document base issue with transfromiix.cpp (Nathan)
-   - When an XSLT stylesheet is specified on the command line
-     the document base was still defaulting to the XML document,
-     instead of the stylesheet
-
--- Fixed bug in namespace-uri() function [NodeSetFunctionCall.cpp] - Marina
-   - If an expression was passed as an argument to the function,
-     which evaluated to an empty NodeSet, the context node was being
-     used, which is incorrect. We now just return an empty string.
-
--- Fixed bug in PathExpr::matches (Marina)
-   - expressions such as "foo//bar" would not always match
-     properly if more than one node existed in the final
-     set of "matching context nodes" (so basically if foo
-     was not the root element).
-
-
-Build 20000419
-
--- Added the generate-id function
--- Added XPath Extension Function support
-
-Build 20000413
-
--- Added some bug fixes from Marina
-   -- fixed parsing of multiple predicates
-   -- added support to handle attribute-set recursion
-   -- added appropriate calls to handle use-attribute-sets on xsl:copy
-
-Build 20000412
-
--- Fixed the following Axes names in Names.cpp so that
-   the are compatible with the XSLT 1.0 recommendation (Marina)
-   -- FOLLOWING_SIBLING_AXIS - removed the trailing s
-   -- PRECEDING_SIBLING_AXIS - removed the trailing s
-
--- Added support for xsl:sort (kvisco)
-   -- simple sorting is working...documentation to follow
--- Added StringComparator and DefaultStringComparator
-   -- we need some more comparators for I18N support
--- Did some directory structure changes
-   - source/xsl is now source/xslt
-   - source/xsl/expr is now source/xpath
--- Changed xslt/XSLProcessor.* to XSLTProcessor.*
-
--- Incorporated some changes from Olivier Gerardin for the Expat parser
-
-Build 20000331
-
--- Fixed a memory leak with translate() function (kvisco)
-   -- StringFunctionCall.cpp
--- Updated the necessary source files to support the changes to
-   the String class (kvisco)
--- Overloaded String::toCharArray to automatically create the
-   character array (tomk)
--- Changed String::toChar to String::toCharArray (tomk)
-
-
-Build 20000327
--- Fixed "dot" bug in CNAME parsing (ExprLexer.cpp) reported by Nathan Pride
-
-Build 20000326
--- Added Peter Van der Beken's changes to net/URIUtils for integration
-   within Mozilla
-
--- Added Marina Mechtcheriakova's changes to xml/parser/XMLParser.cpp to fix
-   a Unicode bug in ::startElement. Instead of improperly casting char*
-   as DOM_CHAR*, the proper String constructor, String(char*) is used
-
-Build 20000322
--- Added Unicode bug fix from Lidong
-
-Build 20000318
--- Added Olivier's implementation of the XPath Number functions
--- Added missing prototype to TxString.h (Peter Van der Beken)
-
-Build 20000222
--- Added Attribute parent mapping since DOM 1.0 doesn't support it
--- Added default sorting of NodeSet by DocumentOrder
-   -- yes this is a hint that xsl:sort is will be available soon
-
-Build 20000218
--- Fixed bug reported by Thiery Le Bouil, xsl:param was getting
-   processed, and then treated as a literal element
-
-Build 20000217
-
--- Changed StringList#iterator to return a pointer instead of a reference
--- Added patches from Eric Du for FreeBSD, sorry for the delay in committing these
-
-Build 20000216
-
--- Fixed bug with using wildcards directly after the parent operator, such as "/*"
--- Fixed bug with PredicateList#isEmpty which was returning the opposite of the
-   expected value.
-   -- this also caused default priorities to be incorrectly calculated.
-
-Build 19991110
--- fixed bug with PathExpr and LocationStep with respect
-   to the ::match method
-   -- problem reported by Oblix
--- Added support for xsl:include (only file URLs will work)
--- fixed the built-in xsl:apply-templates rule to handle text nodes
--- moved code base to Linux platform for default development environment
-
-Build 19990818
--- Added very simple support for xsl:number
--- Added support for xsl:with-param
--- Added more XPath support
-   -- added operator precedence
-   -- added and, or, <,<=,>=,>
-
-
-Build 19990816
--- Changed focus from 19990709 to 19990813 XSLT Working Draft
--- Made some changes for Borland C compatibility
-   -- submitted by Stefan Heesch
--- added xsl:copy-of
--- fixed a bug with DOM Element, to allow DocumentFragments as children
-
-Build 19990813
--- added new example: identity.xml/xsl which tests:
-   -- xsl:copy, node()
--- added comment(), pi(), and node()
-   -- XMLParser still needs to handle reading in XML comments
--- added xsl:copy
--- added xsl:processing-instruction
--- added xsl:comment
-
-Build 19990812
--- Created base/Double.cpp  (primitives.h)
-   -- Based off some code submitted by Larry Fitzpatrick, changed Name from
-     FloatPort to Double, I wanted to add more Double related methods
-     -- changed the NaN() method to just a static double
-     -- All expr classes now use Double::isNaN() and Double::NaN
-     -- I added Double::isInfinite, Double::POSITIVE_INFINITY and
-       Double::NEGATIVE_INFINITY
--- Added base/Integer.cpp back into Makefile
-   -- added Integer::toString(int,String);
-   -- changed implementation
--- Moved code to convert from Strings to doubles and from doubles to Strings
-   into the Double class
--- removed testdom.cpp from xml/dom
--- Added more changes from Larry Fitzpatrick and Michele Lee for
-   porting issues
-   -- added appropriate return values for:
-      -- xml/dom/Element.cpp
-      -- xml/dom/NodeDefinition.cpp
-      -- base/StringList.cpp
-      -- xsl/expr/PredicateList.cpp
--- Added remaining String Function Calls
-   -- substring(), substring-after(), substring-before(), translate(),
-      string-length()
-
-
-Build 19990810
--- Added most of the Whitespace handling
--- Added ErrorObserver interface
-   -- ErrorObserver is now used throughout most of the code
--- Added SimpleErrorObserver implementation of ErrorObserver
--- Moved main() method from XSLProcessor.cpp to tranformiix.cpp
--- Added the following XPath functions:
-   -- local-part(), name(), namespace()
-   -- see functions.xml/functions.xsl for available functions
-
-Build 19990806
--- Incoporated Changes From Larry Fitzpatrick
--- Added more XPath functions
-   -- last(), count(), string(), contains(), starts-with(), concat()
-   -- see functions.xml/functions.xsl for available functions
--- Added xsl:text support
-
-

mozilla/extensions/transformiix/docs/compiled-templates.html

@@ -1,273 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-  <head>
-    <title>XSLT Templates and Compiling</title>
-    <style type="text/css">
-      .section {
-        background-color: #cfcfcf;
-        margin-left: 2em;
-      }
-      .required {
-        font-weight: bold;
-      }
-      .TODO {
-        color: red;
-      }
-    </style>
-  </head>
-
-  <body>
-    <h1>XSLT Templates and Compiling</h1>
-    <p>This document describes compiling of XSLT stylesheets and the
-      evaluation of the result.</p>
-    <div>
-      <ul>
-	<li><a href="#pre">Prerequisites</a></li>
-	<li><a href="#comp">Compilation</a></li>
-	<li><a href="#eval">Evaluation</a></li>
-      </ul>
-</div>
-    <h2><a name="pre">Objectives:</a></h2>
-    <ul>
-      <li>Speed</li>
-      <li>Better support for AVTs</li>
-      <li>Interruptability of processing</li>
-      <li>exclude and alias namespaces</li>
-    </ul>
-    <h2>Concepts:</h2>
-    <div>
-      <dl>
-	<dt>LRE namespaces</dt>
-	<dd>All namespace aliases are merged wit import precedence
-	  into an array of all namespace ids, which is used to map the
-	  LRE namespace in the source to the LRE namespace in the
-	  result. Non-aliased namespaces just have their namespace id
-	  in that array.</dd>
-      </dl>
-    </div>
-
-    <h2><a name="comp">Compilation:</a></h2>
-    <p>The XSLT specification describes XSLT in terms of the XPath
-      datamodel, something pretty close to a DOM. So we talk about the
-      input in terms of DOM elements.</p>
-    <div>The DOM nodes in a stylesheet get compiled into either
-      <ul>
-	<li>nothing :-) (stuff like xsl:output),</li>
-	<li><code>xslTopElement</code>s or</li>
-	<li><code>xslInstruction</code>s.</li>
-      </ul>
-      The <code>xslInstruction</code>s fall into classes,
-      <ol>
-	<li>simple instructions,</li>
-	<li>utilities (no-op, variable-pop, push-handler),</li>
-	<li>branching instructions,</li>
-	<li>instructions changing the result handler and</li>
-	<li>instructions calling into different
-	  <code>xslTopElement</code>s.</li>
-      </ol>
-    </div>
-    <h2><a name="eval">How do instructions work?</a></h2>
-    <div>The general pattern used to create output from a set of
-      instructions is
-      <pre>while (instruction) {
-  rv = instruction.do(args);
-  if (NS_FAILED(rv)) {
-    //cleanup
-    return rv;
-  }
-  instruction = instruction.mNext;
-}</pre>
-      This says pretty much all about simple and utility instructions.
-    </div>
-    <h3>Branching instructions</h3>
-    <div>see <a href="#choose">xsl:choose</a>. The trailing single
-      no-op helps in rejoining the paths, as that no-op can be created
-      before the paths and thus easily appended to each end of the
-      paths.</div>
-    <h3>Instructions that change the output handler</h3>
-    <div>These instructions (attribute, comment, pi creating text
-      handlers, variable possibly creating a rtf handler) get created
-      by inserting a push-handler-instruction into the workflow for
-      the start of the element and the XSLT instruction at the
-      end. The handler instruction should keep a non-owning reference
-      to the push-handler-instruction to get the result and restore
-      the previous handler.</div>
-
-    <h3><a name="apply-imports">xsl:apply-imports</a></h3>
-    <div class="section">no idea</div>
-
-    <h3><a name="apply-templates">xsl:apply-templates</a></h3>
-    <div class="section">
-      <dl>
-	<dt>members:</dt>
-	<dd>
-	  <dl>
-	    <dt>select</dt> <dd>node-set-expression</dd>
-	    <dt>mode</dt> <dd>qname</dd>
-	    <dt>sorts</dt> <dd>list of xsl:sort elements</dd>
-	    <dt>params</dt> <dd>list of xsl:with-param elements</dd>
-	  </dl>
-	</dd>
-	<dt>do()</dt>
-	<dd>set up the params, if any, evaluate the select, create a
-	evalContext and push it on the evalContextStack. push the next
-	instruction to the instruction return stack. trigger the new
-	context (how do we do this?).</dd>
-      </dl>
-    </div>
-
-    <h3><a name="attribute">xsl:attribute</a></h3>
-    <div class="section">
-      <dl>
-	<dt>members:</dt>
-	<dd>
-	  <dl>
-	    <dt class="required">name</dt> <dd>AVT with QName value</dd>
-	    <dt>namespace</dt> <dd>AVT with uri value</dd>
-	  </dl>
-	</dd>
-	<dt>do()</dt>
-	<dd>the start tag pushes a textValueHandler, the end tag pops
-	  the value handler and calls the outputhandler::attribute</dd>
-      </dl>
-    </div>
-
-    <h3><a name="attribute-set">xsl:attribute-set</a> (tle)</h3>
-    <div class="section"><span class="TODO">attribute sets are merged,
-	we should pay attention that multiple stylesheet compilers
-	don't mix their content. Order of attributes is relevant, IMHO.</span>
-      <dl>
-	<dt>members:</dt>
-	<dd>
-	  <dl>
-	    <dt class="required">name</dt> <dd>qname</dd>
-	    <dt>use-attribute-sets</dt> <dd>list of qnames</dd>
-	  </dl>
-	</dd>
-	<dt>do()</dt>
-	<dd>merging and stuff needed in the global stylesheet object,
-	  (NOT part of <a href="#import-frame">import frame).</a></dd>
-      </dl>
-    </div>
-
-    <h3><a name="call-template">xsl:call-template</a></h3>
-    <div class="section">
-      <dl>
-	<dt>members:</dt>
-	<dd>
-	  <dl>
-	    <dt class="required">name</dt> <dd>qname</dd>
-	    <dt>with-params</dt> <dd>list of xsl:with-params</dd>
-	  </dl>
-	</dd>
-	<dt>do()</dt>
-	<dd>push the next instruction onto the instruction return
-	  stack, lookup the template and set the instruction pointer
-	  to the called template. Setup the params, if there are. This
-	  does not change the evalContextStack.
-	  <div class="issue">Can we cache this? What happens if a
-	    added stylesheet between two transforms changes which
-	    stylesheet this qname resolves to?</div></dd>
-      </dl>
-    </div>
-
-    <h3><a name="choose">xsl:choose</a></h3>
-    <div class="section">
-      This is a branching instruction with one exit point and several
-      conditional entry points (xsl:when) and one default
-      (xsl:otherwise). The conditional entry points start with a
-      conditionalGotoInstrunction, which jumps to the next entry point
-      if they don't succeed. Each of them ends with a gotoInstruction
-      that jumps to the end of the xsl:choose (for simplicity in the
-      compilation phase, this might be a noopInstruction). The
-      xsl:otherwise is just the instructions list of the
-      xsl:otherwise, linked to the ending noopInstruction. Note that
-      this construct a single instruction list for the complete
-      xsl:choose, as the mNext of the final gotos is the next entry
-      point. This mNext is only used for iterations, though.
-    </div>
-
-    <h3><a name="comment">xsl:comment</a></h3>
-    <div class="section">
-      <dl>
-	<dt>do()</dt>
-	<dd>startElement pushes a textHandler, endElement takes the
-	  value and calls ::comment() in the output handler</dd>
-      </dl>
-    </div>
-
-    <h3><a name="copy">xsl:copy</a></h3>
-    <div class="section">
-      <dl>
-	<dt>members:</dt>
-	<dd></dd>
-	<dt>do()</dt>
-	<dd>xsl:copy has a <a
-	    href="#attribute-sets">use-attribute-sets</a> attribute,
-	  <span class="TODO">TODO</span></dd>
-      </dl>
-    </div>
-
-    <h3><a name="copy-of">xsl:copy-of</a></h3>
-    <div class="section">
-      <dl>
-	<dt>members:</dt>
-	<dd>
-	  <dl>
-	    <dt class="required">select</dt>
-	    <dd>an expression to be added to the result tree</dd>
-	  </dl>
-	</dd>
-	<dt>do()</dt>
-	<dd>the value of the result is added to the result tree. If
-	  the result is a RTF, the RTF is just fed into the output
-	  handler, if the result is not a nodeset, it is converted
-	  into a string and ::characters is called on the output
-	  handler. For nodesets, the result is a list of source nodes
-	  which have to be interpreted, for example thru the
-	  stylesheet compiler. This has be xslt-blind, that is, xslt
-	  elements in the source must be treated as LRE elements and
-	  copied into the result, instead of generating XSLT
-	  instructions. <span class="TODO">is this all?</span></dd>
-      </dl>
-    </div>
-
-    <h3><a name="decimal-format">xsl:decimal-format</a> (tle)</h3>
-    <div class="section">xsl:decimal-format is stored in the global
-      stylesheet object, import precedence <b>does not</b> apply.</div>
-
-    <h3><a name="element">xsl:element</a></h3>
-    <div class="section">
-      <dl>
-	<dt>members:</dt>
-	<dd>
-	  <dl>
-	    <dt class="required">name</dt> <dd>AVT with QName
-	      value</dd>
-	    <dt>namespace</dt> <dd>AVT with URI value</dd>
-	  </dl>
-	</dd>
-	<dt>do()</dt>
-	<dd>xsl:element has <a
-	    href="#attribute-sets">attribute-set</a>s, <span
-	    class="TODO">todo</span>. Other than that, this just
-	  generates an element. Note that the attributes of this
-	  element have to be discarded, if the name AVT does not
-	  evaluate to a QName.</dd>
-      </dl>
-    </div>
-
-    <h3><a name="fallback">xsl:fallback</a></h3>
-    <div class="section"><span class="TODO">do we care?</span></div>
-
-    <h3><a name=""></a></h3>
-    <div class="section">
-      <dl>
-	<dt>members:</dt>
-	<dd></dd>
-	<dt>do()</dt>
-	<dd></dd>
-      </dl>
-    </div>
-  </body>
-</html>

mozilla/extensions/transformiix/docs/contributors.html

@@ -1,376 +0,0 @@
-<HTML>
-<HEAD>
-<TITLE>Transformiix (TM)  Contributors</TITLE>
-<META name="author" content="Keith Visco">
-</HEAD>
-<BODY Text="#000000" BGColor="#FFFFFF">
-<!-- OUTER TABLE -->
-<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0" WIDTH="640">
-<TR>
-<TD WIDTH="80"></TD>
-<TD WIDTH="560" COLSPAN="2" ALIGN="RIGHT">
-  <B><FONT SIZE="+2">Transfor<FONT Color="blue">Mii</FONT>X</FONT></B>
-  <SUP>TM</SUP>
-</TD>
-</TR>
-<TD WIDTH="80"><BR></TD>
-<TD WIDTH="560" COLSPAN="2">
-<!-- Contents -->
-<HR SIZE="1" />
-<BR/>
-<P>
-  Much of the original <B>Transfor<FONT Color="blue">Mii</FONT>X</B> code was ported
-  from <A HREF="http://www.clc-marketing.com/xslp">XSL:P</A>,
-  an open source XSLT processor. Thanks to all the contributors of
-  that project.  TransforMiiX is now a whole new beast...thanks to all
-  of the hard work of those listed below.
-<P>
-<P>
-<B>Core Developers</B><P>
-The following people have contributed substantial time and
-effort to the development.
-<TABLE WIDTH="100%" CELLSPACING="1">
-<TR BGColor="#EEEEEE"><TH>Name</TH><TH>Contribution</TH><TH>Company</TH></TR>
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A href="mailto:kvisco@ziplink.net">Visco, Keith</a>
-  </TD>
-  <TD VALIGN="TOP" WIDTH="300">
-    Software design, and most of the XSLT implementation and
-    base classes implementation.
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.exoffice.com">Exoffice Technologies</A>
-    <P>
-    <FONT SIZE="-1">Formerly with The MITRE Corporation</FONT>.
-  </TD>
-</TR>
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A href="mailto:tomk@mitre.org">Kneeland, Tom</a>
-  </TD>
-  <TD>
-    Software design, DOM Implementation. Handled the initial
-    Mozilla integration and wrapper classes,
-    String and String wrapper classes.
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.mitre.org">The MITRE Corporation</A>
-  </TD>
-</TR>
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:peter.vanderbeken@pandora.be">Van der Beken, Peter</A>
-  </TD>
-  <TD VALING="TOP" WIDTH="300">
-    Leading the Transformiix/Mozilla integration,
-    and Macintosh porting issues. Without Peter...we'd be doomed! :-)
-  </TD>
-  <TD VALIGN="TOP">
-    <BR>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:axel@pike.org">Hecht, Axel</A> (AKA - Pike)
-  </TD>
-  <TD WIDTH="300">
-    Build issues...configure, Make, etc. Solaris porting issues.
-    All nasty comments on regarding make files should now be directed to Pike!
-  </TD>
-  <TD VALIGN="TOP">
-    <BR>
-  </TD>
-</TR>
-
-</TABLE>
-</P>
-<P>
-<P>
-<B>Additional Developers</B><P>
-The following people have contributed to the development.
-<BR>(appearing in alphabetical order)
-<TABLE WIDTH="100%" CELLSPACING="1">
-<TR BGColor="#EEEEEE"><TH>Name</TH><TH>Contribution</TH><TH>Company</TH></TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:arthur.barrett@march-hare.com">Barrett, Arthur</A>
-  </TD>
-  <TD WIDTH="300">
-    Working on Windows makefiles.
-  </TD>
-  <TD VALIGN="TOP">
-    <BR>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:bbrown@solana.com">Brown, William Lewis</A>
-  </TD>
-  <TD WIDTH="300">
-    Working with Marina on XSLT 1.0 conformity issues.
-  </TD>
-  <TD VALIGN="TOP">
-    <BR>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:duxy@leyou.com.cn">Du, Eric</A>
-  </TD>
-  <TD WIDTH="300">
-     FreeBSD floating point porting issues
-  </TD>
-  <TD VALIGN="TOP">
-    <BR>
-  </TD>
-</TR>
-
-<!-- Entry -->
-
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:lef@opentext.com">Fitzpatrick, Larry</A>
-  </TD>
-  <TD WIDTH="300">
-    Larry was the first contributor to the project. He sent
-    a number of C++ porting issues with Visual C++,
-    and has influenced some of the early design.
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.opentext.com">OpenText</A>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:ogerardin@vo.lu">Gerardin, Olivier</A>
-  </TD>
-  <TD WIDTH="300">
-    Implemented the XPath Number functions, the document()
-    function, as well as some other changes/improvements.
-    <FONT SIZE="-1">
-       (see <A HREF="changes.txt">changes.txt</A> for more info)
-    </FONT>
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.digitalwave.lu">DigitalWave</A>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:rguarino@wavo.com">Guarino, Bobbi</A>
-  </TD>
-  <TD WIDTH="300">
-    Solaris porting issues
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.wavo.com">Wavo Corporation</A>
-  </TD>
-</TR>
-
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:Heesch@t-online.de">Heesch, Stefan</A>
-  </TD>
-  <TD WIDTH="300">
-    C++ porting issues with Borland C
-  </TD>
-  <TD VALIGN="TOP">
-    <BR><A HREF=""></A>
-  </TD>
-</TR>
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:joe@pwd.hp.com">Kuan, Joseph</A>
-  </TD>
-  <TD WIDTH="300">
-    Sent changes for getting TransforMiiX to build on HPUX, SUNOS and AIX.
-    <I>I still need to add these into the CVS.</I>
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.hp.com">Hewlett-Packard</A>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:mclee@oblix.com">Lee, Michele</A>
-  </TD>
-  <TD WIDTH="300">
-    C++ porting issues, bug reports
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.oblix.com">Oblix</A>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:lidong@leyou.com.cn">Lidong</A>
-  </TD>
-  <TD WIDTH="300">
-    Some Unicode bug fixes
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.leyou.com">Leyou.com</A>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:mmarina@mindspring.com">Mechtcheriakova, Marina</A>
-  </TD>
-  <TD WIDTH="300">
-    Contributed a number of bug fixes, as well as handling
-    some conformity issues.
-  </TD>
-  <TD VALIGN="TOP">
-    <BR>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:kbob@oblix.com">Miller, Bob</A>
-  </TD>
-  <TD WIDTH="300">
-    A number of bug fixes, C++ porting issues
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.oblix.com">Oblix</A>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:andreas.otte@primus-online.de">Otte, Andreas</A>
-  </TD>
-  <TD WIDTH="300">
-    Helping Axel with build issues...configure, make files, etc.
-  </TD>
-  <TD VALIGN="TOP">
-    <BR>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:npride@wavo.com">Pride, Nathan</A>
-  </TD>
-  <TD WIDTH="300">
-    Solaris porting issues, some general bug fixes
-  </TD>
-  <TD VALIGN="TOP">
-    <A HREF="http://www.wavo.com">Wavo Corporation</A>
-  </TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD VALIGN="TOP">
-    <A HREF="mailto:jjs@acis.com.au">Smith, Justin</A>
-  </TD>
-  <TD WIDTH="300">
-    Working on Windows Makefiles.
-  </TD>
-  <TD VALIGN="TOP">
-    <BR>
-  </TD>
-</TR>
-
-
-
-</TABLE>
-
-<P><B>Testing/Feedback (Suggestions/Bug Reports)</B><P>
-The following people have used TransforMiiX and provided feedback that has been
-beneficial to the development.
-<BR>(appearing in alphabetical order)
-<TABLE BORDER="0" WIDTH="100%">
-<TR BGColor="#EEEEEE"><TD><B>Name</B></TD><TD><B>Company</B></TD></TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD><A HREF="mailto:jbailey@nisa.net">Bailey, Jeff</A></TD>
-  <TD><BR></TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD><A HREF="mailto:bbrown@solana.com">Brown, William Lewis</A></TD>
-  <TD><BR></TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD><A HREF="mailto:tlebouil@lucent.com">Le Bouil, Thierry</A></TD>
-  <TD><A HREF="http://www.lucent.com">Lucent Technologies, Inc.</A></TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD><A HREF="mailto:schefer@xo3.com">Schefer, Marc</A></TD>
-  <TD><BR></TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD><A HREF="mailto:stinney@sas.upenn.edu">Tinney, Steve</A></TD>
-  <TD><A HREF="http://www.upenn.com">University of Pennsylvania</A></TD>
-  <!-- Comments: UTF8 bug report -->
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD><A HREF="mailto:jiwei.wang@saraide.com">Wang, Jiwei</A></TD>
-  <TD><BR></TD>
-</TR>
-
-<!-- Entry -->
-<TR BGColor="#EEEEEE">
-  <TD>
-      <A HREF="mailto:bzwische@email.archlab.tuwien.ac.at">
-       Zwischenbrugger, Bernhard</A>
-  </TD>
-  <TD><BR></TD>
-</TR>
-
-</TABLE>
-<!-- End Contents -->
-
-<!-- Footer -->
-<HR SIZE="1">
-<FONT SIZE="-1">
-The MITRE Corporation, Keith Visco (C) Copyright 1999-2000, All rights reserved<BR>
-Email:<A HREF="mailto:kvisco@ziplink.net">kvisco@ziplink.net</A>
-</FONT>
-<!-- End Footer -->
-</TD>
-</TR>
-</TABLE>
-<!-- End Outer Table -->
-</HTML>

mozilla/extensions/transformiix/docs/readme.html

@@ -1,172 +0,0 @@
-<HTML>
-<HEAD>
-<TITLE>TransforMiiX(tm)</TITLE>
-<META name="author" content="Keith Visco">
-</HEAD>
-<BODY Text="#000000" BGColor="#FFFFFF">
-<!-- OUTER TABLE -->
-<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0" WIDTH="640">
-<TR>
-<TD WIDTH="80"></TD>
-<TD WIDTH="80">
-  <B><I><FONT SIZE="+2" COLOR="BLUE">MITRE</FONT></I></B>
-</TD>
-<TD WIDTH="480" ALIGN="RIGHT">
-  <B><FONT SIZE="+2">Transfor<FONT Color="blue">Mii</FONT>X</FONT></B>
-  <SUP>TM</SUP>
-</TD>
-</TR>
-<TD WIDTH="80"><BR></TD>
-<TD WIDTH="560" COLSPAN="2">
-<!-- Contents -->
-
-<HR SIZE="1" />
-<BR/>
-<P>
-<B>Transfor<FONT Color="blue">Mii</FONT>X</B> is an XSLT processor which is
-not yet complete, but supports a good portion of the 
-<A HREF="http://www.w3.org/TR/1999/REC-xslt-19991116">XSLT 1.0 recommendation</A>.
-
-<P>
-<B>Transfor<FONT Color="blue">Mii</FONT>X</B> was designed to be a "standalone" 
-XSLT processor. This means you can call the processor from the command line,
-or via the XSLProcessor API. The only thing TransforMiiX requires is an XML parser,
-and the currently supported parser is 
-<A href="http://www.jclark.com/xml/expat.html">Expat</A> written by James Clark.
-</P>
-<P>
-There is currently an effort undergoing to integrate 
-TransforMiiX with Mozilla. This effort
-is not yet complete and therefor the XSLT processor cannot yet be used 
-within the Mozilla browser. Integration is nearing completion, however.
-</P>
-<P>
-<HR SIZE="1">
-<P>
-<B>Running <B>Transfor<FONT Color="blue">Mii</FONT>X</B> from the command line</B>
-<P />
-The command line syntax is pretty straight forward:
-<P>
-<B>example:</B> <I>transfrmx -i my.xml -s my.xsl -o my.out</I>
-</P>
-This will process the XML source file called "my.xml" using the "my.xsl" XSLT stylesheet,
-and the result will be placed in "my.out".
-
-The "-s" flag is not required if the XSLT stylesheet is specified inside the XML source 
-document using the "xml-stylesheet" PI (processing instruction).
-<P>
-The stylesheet PI, should appear below the XML declaration 
-("<FONT SIZE="-1">&lt;?xml version="1.0"?&gt;</FONT>").
-<P>
-<B>example:</B>
-<TABLE BGColor="" BORDER="1">
-<TR>
-  <TD>
-    <PRE>
-
-&lt;?xml version="1.0"?&gt;
-&lt;?xml-stylesheet href="my.xsl" type="text/xsl"?&gt;
-&lt;document&gt;
-   ...
-&lt;/document&gt;
-    </PRE>
-  </TD>
-</TR>
-</TABLE>
-
-<P>
-The command line program is in "source/main/transformiix.cpp" and is simply
-a wrapper for "source/xsl/XSLProcessor.cpp" which is the TransforMiiX API.
-</P>
-<P>
-Feel free to run the examples in the "source/examples" directory, they are a
-good example of what has been implemented so far in TransforMiiX.
-<P>
-
-<HR SIZE="1">
-<P>
-<B>What is the current status of Transfor<FONT Color="blue">Mii</FONT>X</B>?
-<P />
-You can check the current status by looking three main files:
-<UL>
-<LI><A HREF="changes.txt">changes.txt</A> - lists the changes from different builds
-<LI><A HREF="remaining.txt">remaining.txt</A> - lists what needs to be implemented.
-<LI><A HREF="known-issues.html">known-issues.html</A> - lists known bugs or issues.
-<BR />
- -- this is a little out of date...sorry.
-</UL>
-<P>
-<HR SIZE="1">
-<P>
-<B>What can I do to help finish the implementation of
- Transfor<FONT Color="blue">Mii</FONT>X</B>?
-<P />
-There are a number of things that can be done:
-<P>
-<B>Development</B>
-<OL>
-<LI>Check out the source code, build it. 
-<LI>Use it. 
-<LI>Familiarize yourself with the code. 
-<LI>Look at the the "to-do" or "known issues" list and choose something
-that you would like to work on. 
-<LI> If it's a large task, notify us that you are working on a task or issue, or
-would like to contribute to the existing effort of a specific task.
-<BR>
-If it's a simple change you may contact us first to make sure
-you are not duplicating effort, or feel free to just make the changes.
-<LI>If you have CVS commit status, commit your code, 
-otherwise submit your code to be integrated to us.
-<BR>
-<B>
-<FONT SIZE="-1">
-Please do a "cvs update" to make sure you have the latest changes, and that
-your changes work with any code changes that might have occured during
-your development. 
-</FONT>
-</B> 
-</OL>
-
-<B>Bug Reporting</B>
-<OL>
-<LI>Check out the source code, build it.
-<LI>Use it.
-<LI>Submit any bugs to the 
-<A HREF="news://news.mozilla.org/netscape.public.mozilla.layout.xslt">
-mailing list [netscape.public.mozilla.layout.xslt]</A>
- or directly to us.
-</OL>
-
-<B>Documentation</B>
-<OL>
-<LI>Check out the source code, build it.
-<LI>Use it.
-<LI>Find something that's not documented - pretty easy to do at this point.
-<LI>Document #3.
-<LI>If you have commit status, commit your documentation, otherwise
-submit your documentation directly to us.
-</OL>
-<P>
-
-<B>Miscellaneous (but important)</B> <BR>
-<FONT SIZE="-1">&nbsp;-- I just wouldn't be myself if I didn't add these! -- Keith :-) </FONT>
-<OL>
-<LI>Get me a date with Claudia Schiffer or Kelly Hu.
-<LI>Get me some coffee!
-</OL>
-<P>
-<!-- End Contents -->
-
-<!-- Footer -->
-<HR SIZE="1">
-<FONT SIZE="-1">
-The MITRE Corporation, Keith Visco (C) Copyright 1999, All rights reserved<BR>
-Email: <A HREF="mailto:kvisco@ziplink.net">Keith Visco</A>, 
-<A HREF="mailto:tomk@mitre.org">Tom Kneeland</A>
-</FONT>
-<!-- End Footer -->
-</TD>
-</TR>
-</TABLE>
-<!-- End Outer Table -->
-</HTML>

mozilla/extensions/transformiix/macbuild/transformiixPrefix.h

@@ -1,27 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- * 
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Peter Van der Beken are Copyright (C) 2000
- * Peter Van der Beken. All Rights Reserved.
- *
- * Contributor(s): 
- * Peter Van der Beken, peter.vanderbeken@pandora.be
- *    -- original author.
- *
- */
-
-#include "MacSharedPrefix.h"

mozilla/extensions/transformiix/macbuild/transformiixPrefix_debug.h

@@ -1,27 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Peter Van der Beken are Copyright (C) 2000
- * Peter Van der Beken. All Rights Reserved.
- *
- * Contributor(s): 
- * Peter Van der Beken, peter.vanderbeken@pandora.be
- *    -- original author.
- *
- */
-
-#include "MacSharedPrefix_debug.h"

mozilla/extensions/transformiix/resources/Makefile.in

@@ -1,47 +0,0 @@
-# ***** BEGIN LICENSE BLOCK *****
-# Version: MPL 1.1/GPL 2.0/LGPL 2.1
-#
-# The contents of this file are subject to the Mozilla 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/MPL/
-#
-# Software distributed under the License is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
-# for the specific language governing rights and limitations under the
-# License.
-#
-# The Original Code is mozilla.org.
-#
-# The Initial Developer of the Original Code is Axel Hecht.
-# Portions created by the Initial Developer are Copyright (C) 2002
-# the Initial Developer. All Rights Reserved.
-#
-# Contributor(s):
-#   Axel Hecht <axel@pike.org>
-#
-# Alternatively, the contents of this file may be used under the terms of
-# either the GNU General Public License Version 2 or later (the "GPL"), or
-# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
-# in which case the provisions of the GPL or the LGPL are applicable instead
-# of those above. If you wish to allow use of your version of this file only
-# under the terms of either the GPL or the LGPL, and not to allow others to
-# use your version of this file under the terms of the MPL, indicate your
-# decision by deleting the provisions above and replace them with the notice
-# and other provisions required by the GPL or the LGPL. If you do not delete
-# the provisions above, a recipient may use your version of this file under
-# the terms of any one of the MPL, the GPL or the LGPL.
-#
-# ***** END LICENSE BLOCK *****
-
-
-DEPTH           = ../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MOZ_CHROME_FILE_FORMAT=flat
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/transformiix/resources/XSLTMark/XSLTMark-static.js

@@ -1,77 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-const enablePrivilege = netscape.security.PrivilegeManager.enablePrivilege;
-const IOSERVICE_CTRID = "@mozilla.org/network/io-service;1";
-const nsIIOService    = Components.interfaces.nsIIOService;
-const SIS_CTRID       = "@mozilla.org/scriptableinputstream;1";
-const nsISIS          = Components.interfaces.nsIScriptableInputStream;
-const nsIFilePicker   = Components.interfaces.nsIFilePicker;
-const STDURL_CTRID    = "@mozilla.org/network/standard-url;1";
-const nsIURI          = Components.interfaces.nsIURI;
-
-var gStop = false;
-
-function loadFile(aUriSpec)
-{
-    enablePrivilege('UniversalXPConnect');
-    var serv = Components.classes[IOSERVICE_CTRID].
-        getService(nsIIOService);
-    if (!serv) {
-        throw Components.results.ERR_FAILURE;
-    }
-    var chan = serv.newChannel(aUriSpec, null, null);
-    var instream = 
-        Components.classes[SIS_CTRID].createInstance(nsISIS);
-    instream.init(chan.open());
-
-    return instream.read(instream.available());
-}
-
-function dump20(aVal)
-{
-    const pads = '                    ';
-    if (typeof(aVal)=='string')
-        out = aVal;
-    else if (typeof(aVal)=='number')
-        out = Number(aVal).toFixed(2);
-    else
-        out = new String(aVal);
-    dump(pads.substring(0, 20 - out.length));
-    dump(out);
-}

mozilla/extensions/transformiix/resources/XSLTMark/XSLTMark-test.js

@@ -1,79 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-var gParser = new DOMParser;
-var gProc = new XSLTProcessor;
-var gTimeout;
-
-function Test(aTitle, aSourceURL, aStyleURL, aNumber, aObserver)
-{
-    this.mTitle = aTitle;
-    this.mObserver = aObserver;
-    this.mTotal = aNumber;
-    this.mDone = 0;
-    var xmlcontent = loadFile(aSourceURL);
-    var xslcontent = loadFile(aStyleURL);
-    this.mSource = gParser.parseFromString(xmlcontent, 'text/xml');
-    this.mStyle = gParser.parseFromString(xslcontent, 'text/xml');
-}
-
-function runTest(aTitle, aSourceURL, aStyleURL, aNumber, aObserver)
-{
-    test = new Test(aTitle, aSourceURL, aStyleURL, aNumber,
-                        aObserver);
-    gTimeout = setTimeout(onNextTransform, 100, test, 0);
-}
-
-function onNextTransform(aTest, aNumber)
-{
-    res = document.implementation.createDocument('', '', null);
-    var startTime = Date.now();
-    gProc.transformDocument(aTest.mSource, aTest.mStyle, res, null);
-    var endTime = Date.now();
-    aNumber++;
-    var progress = aNumber / aTest.mTotal * 100;
-    if (aTest.mObserver) {
-        aTest.mObserver.progress(aTest.mTitle, endTime - startTime,
-                                 progress);
-    }
-    if (aNumber < aTest.mTotal) {
-        gTimeout = setTimeout(onNextTransform, 100, aTest, aNumber);
-    } else if (aTest.mObserver) {
-        aTest.mObserver.done(aTest.mTitle);
-    }
-}

mozilla/extensions/transformiix/resources/XSLTMark/XSLTMark-view.js

@@ -1,208 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-var view = 
-{
-    configUrl: null,
-    testArray: null,
-    mCurrent: null,
-
-    browseForConfig: function()
-    {
-        enablePrivilege('UniversalXPConnect');
-        var fp = Components.classes["@mozilla.org/filepicker;1"].
-        createInstance(nsIFilePicker);
-        fp.init(window,'XSLTMark Description File',nsIFilePicker.modeOpen);
-        fp.appendFilter('*.conf', '*.conf');
-        fp.appendFilters(nsIFilePicker.filterAll);
-        var res = fp.show();
-
-        if (res == nsIFilePicker.returnOK) {
-            this.configUrl = Components.classes[STDURL_CTRID].createInstance(nsIURI);
-            this.configUrl.spec = fp.fileURL.spec;
-            document.getElementById('config').setAttribute('value', this.configUrl.spec);
-        }
-        this.parseConfig();
-        return true;
-    },
-
-    parseConfig: function()
-    {
-        this.testArray = new Array();
-        var test;
-        if (!this.configUrl) {
-            return;
-        }
-
-        var content = loadFile(this.configUrl.spec);
-
-        var lines = content.split("\n");
-        var line, res;
-        var head = /^\[(.+)\]$/;
-        var instruct = /^(.+)=(.+)$/;
-        while (lines.length) {
-            line = lines.shift();
-            if (head.test(line)) {
-                test = new Object;
-                res = head.exec(line);
-                test['title'] = res[1];
-                this.testArray.push(test);
-            }
-            else if (line == '') {
-                test = undefined;
-            }
-            else {
-                res = instruct.exec(line);
-                test[res[1]] = res[2];
-            }
-        }
-    },
-
-    onLoad: function()
-    {
-        this.mCurrentStatus = document.getElementById('currentStatus');
-        this.mCurrentProgress = document.getElementById('currentProgress');
-        this.mTotalProgress = document.getElementById('totalProgress');
-        this.mOutput = document.getElementById('transformOutput');
-        this.mDetailOutput = 
-            document.getElementById('transformDetailedOutput');
-        this.mDetail = true;
-    },
-
-    progress: function(aTitle, aTime, aProgress)
-    {
-        // dump20(aTitle);
-        // dump20(aTime);
-        // dump20(aProgress);
-        this.mCurrentProgress.value = aProgress;
-        this.displayDetailTime(aTime);
-        this.mTimes.push(aTime);
-        // dump("\n");
-    },
-
-    done: function(aTitle)
-    {
-        // dump(aTitle + " is finished.\n");
-        this.mCurrent++;
-        this.mCurrentProgress.value = 0;
-        this.displayTotalTime();
-        if (this.mCurrent >= this.testArray.length) {
-            this.mTotalProgress.value = 0;
-            this.mCurrentStatus.value = "done";
-            return;
-        }
-        this.mTotalProgress.value = this.mCurrent*100/this.testArray.length;
-        var test = this.testArray[this.mCurrent];
-        enablePrivilege('UniversalXPConnect');
-        this.displayTest(test.title);
-        runTest(test.title, this.configUrl.resolve(test.input),
-                this.configUrl.resolve(test.stylesheet),
-                test.iterations, this);
-    },
-
-    onStop: function()
-    {
-        clearTimeout(gTimeout);
-        this.mCurrentProgress.value = 0;
-        this.mTotalProgress.value = 0;
-        this.mCurrentStatus.value = "stopped";
-    },
-
-    displayTest: function(aTitle)
-    {
-        this.mTimes = new Array;
-        aTitle += "\t";
-        this.mCurrentStatus.value = aTitle;
-        this.mOutput.value += aTitle;
-        if (this.mDetail) {
-            this.mDetailOutput.value += aTitle;
-        }
-    },
-
-    displayDetailTime: function(aTime)
-    {
-        if (this.mDetail) {
-            this.mDetailOutput.value += aTime + " ms\t";
-        }
-    },
-
-    displayTotalTime: function()
-    {
-        var sum = 0;
-        for (k = 0; k < this.mTimes.length; k++) {
-            sum += this.mTimes[k];
-        }
-        var mean = sum / this.mTimes.length;
-        this.mOutput.value += Number(mean).toFixed(2) + " ms\t" + sum + " ms\t";
-        var variance = 0;
-        for (k = 0; k < this.mTimes.length; k++) {
-            var n = this.mTimes[k] - mean;
-            variance += n*n;
-        }
-        variance = Math.sqrt(variance/this.mTimes.length);
-        this.mOutput.value += Number(variance).toFixed(2)+"\n";
-        if (this.mDetail) {
-            this.mDetailOutput.value += "\n";
-        }
-    },
-
-    runBenchmark: function()
-    {
-        enablePrivilege('UniversalXPConnect');
-        if (!this.testArray) {
-            if (!this.configUrl) {
-                this.configUrl = Components.classes[STDURL_CTRID].createInstance(nsIURI);
-                this.configUrl.spec = document.getElementById('config').value;
-            }
-            this.parseConfig();
-        }
-
-        this.mCurrent = 0;
-        var test = this.testArray[this.mCurrent];
-        this.mOutput.value = '';
-        if (this.mDetail) {
-            this.mDetailOutput.value = '';
-        }
-        this.displayTest(test.title);
-        runTest(test.title, this.configUrl.resolve(test.input),
-                this.configUrl.resolve(test.stylesheet),
-                test.iterations, this);
-        return true;
-    }
-}
-

mozilla/extensions/transformiix/resources/XSLTMark/XSLTMark.css

@@ -1,25 +0,0 @@
-/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is Axel Hecht.
- * Portions created by Axel Hecht are Copyright (C) 2002 Axel Hecht.
- * All Rights Reserved.
- *
- * Contributor(s):
- *   Axel Hecht <axel@pike.org> (Original Author)
- */
-
-textbox.out {
-  white-space: pre;
-}

mozilla/extensions/transformiix/resources/XSLTMark/XSLTMark.xul

@@ -1,70 +0,0 @@
-<?xml version="1.0"?>
-
-<!-- 
-  The contents of this file are subject to the Mozilla 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/MPL/
-  
-  Software distributed under the License is distributed on an "AS
-  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-  implied. See the License for the specific language governing
-  rights and limitations under the License.
-  
-  The Original Code is mozilla.org.
-  
-  The Initial Developer of the Original Code is Axel Hecht.
-  Portions created by Axel Hecht are Copyright (C) 2002 Axel Hecht.
-  All Rights Reserved.
-  
-  Contributor(s):
-    Axel Hecht <axel@pike.org> (Original Author)
-  --> 
-
-<?xml-stylesheet href="chrome://communicator/skin/" type="text/css"?>
-<?xml-stylesheet href="XSLTMark.css" type="text/css"?>
-<window id="XSLTMarkHarness"
-        title="XSLTMark"
-        onload="view.onLoad()"
-        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-        orient="vertical">
-<script type="application/x-javascript" src="XSLTMark-static.js" />
-<script type="application/x-javascript" src="XSLTMark-test.js" />
-<script type="application/x-javascript" src="XSLTMark-view.js" />
-
-<hbox>
-  <groupbox orient="horizontal">
-    <caption label="test description file" />
-    <label value=""/><!-- needed, otherwise groupbox fucks up :-( -->
-    <textbox id="config" persist="value" readonly="true"/>
-    <button label="browse..." oncommand="view.browseForConfig();" />
-  </groupbox>
-  <groupbox orient="horizontal">
-    <caption label="test control" />
-    <button label="run..."
-            oncommand="setTimeout('view.runBenchmark();', 0);" />
-    <button label="stop" oncommand="view.onStop();" />
-  </groupbox>
-  <groupbox orient="horizontal">
-    <caption label="options" />
-    <label value="responsiveness: "/>
-    <menulist label="sloppy">
-      <menupopup>
-      <menuitem label="sloppy" selected="true"/>
-      <menuitem label="bad"/>
-      </menupopup>
-    </menulist>
-  </groupbox>
-</hbox>
-<hbox>
-  <textbox id="currentStatus" readonly="true" flex="1"/>
-  <progressmeter id="currentProgress" mode="normal" value="0" flex="2"/>
-  <progressmeter id="totalProgress" mode="normal" value="0" flex="2"/>
-</hbox>
-<hbox flex="1">
-  <textbox id="transformOutput" class="out" readonly="true" multiline="true" flex="1"/>
-</hbox>
-<hbox flex="1">
-  <textbox id="transformDetailedOutput" class="out" readonly="true" multiline="true" flex="1"/>
-</hbox>
-</window>

mozilla/extensions/transformiix/resources/buster/DiffDOM.js

@@ -1,120 +0,0 @@
-/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is Axel Hecht.
- * Portions created by Axel Hecht are Copyright (C) 2001 Axel Hecht.
- * All Rights Reserved.
- *
- * Contributor(s):
- *   Axel Hecht <axel@pike.org> (Original Author)
- */
-
-// ----------------------
-// DiffDOM(node1,node2)
-// ----------------------
-
-var isHTML = false;
-
-function DiffDOM(node1, node2, aIsHTML)
-{
-  isHTML = aIsHTML;
-  return DiffNodeAndChildren(node1, node2);
-}
-
-
-// namespace attributes in the second node are ignored
-const nsreg = /^xmlns[|:\w]/;
-
-// This function does the work of DiffDOM by recursively calling
-// itself to explore the tree
-function DiffNodeAndChildren(node1, node2)
-{
-  if (!node1 && !node2)
-    return true;
-  if (!node1 || !node2)
-    return ErrorUp("One of the nodes is null", node1, node2);
-  if (node1.type!=node2.type)
-    return ErrorUp("Different node types", node1, node2);
-
-  var attributes = node2.attributes;
-  if (attributes && attributes.length) {
-    var item, name, ns, value, otherValue;
-    for (var index = 0; index < attributes.length; index++) {
-      item = attributes.item(index);
-      ns = item.namespaceURI;
-      if (ns) {
-        name = item.localName;
-        otherValue = node2.getAttributeNS(ns, name);
-      }
-      else {
-        name = item.nodeName;
-        otherValue = node2.getAttribute(name);
-      }
-      value = item.nodeValue;
-      if (!nsreg.test(name) && otherValue!=value) {
-        return ErrorUp("Different values for attribute", node1, node2);
-      }
-    }
-  }
-  else if (node1.attributes && node1.attributes.length) {
-    return ErrorUp("Different number of attributes", node1, node2);
-  }
-
-  if (isHTML) {
-    if (node1.nodeName.toLowerCase()!=node2.nodeName.toLowerCase())
-      return ErrorUp("Different node names", node1, node2);
-  }
-  else {
-    if (node1.nodeName!=node2.nodeName)
-      return ErrorUp("Different node names", node1, node2);
-  }
-  if (node1.nodeValue!=node2.nodeValue)
-    return ErrorUp("Different node values", node1, node2);
-  if (!isHTML)
-    if (node1.namespaceURI!=node2.namespaceURI)
-      return ErrorUp("Different namespace", node1, node2);
-  if (node1.hasChildNodes() != node2.hasChildNodes())
-    return ErrorUp("Different children", node1, node2);
-  if (node1.childNodes) {
-    if (node1.childNodes.length != node2.childNodes.length)
-      return ErrorUp("Different number of children", node1, node2);
-    for (var child = 0; child < node1.childNodes.length; child++) {
-      if (!DiffNodeAndChildren(node1.childNodes[child],
-                               node2.childNodes[child])) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-function ErrorUp(errMsg, node1, node2)
-{
-  dump("Error: "+errMsg+"\n");
-  if (node1) {
-      dump("Node 1: "+node1+", ");
-      if (node1.nodeType == Node.TEXT_NODE)
-          dump("nodeValue: "+node1.nodeValue+"\n");
-      else
-          dump("nodeName: "+node1.namespaceURI+":"+node1.nodeName+"\n");
-  }
-  if (node2) {
-      dump("Node 2: "+node2+", ");
-      if (node2.nodeType == Node.TEXT_NODE)
-          dump("nodeValue: "+node2.nodeValue+"\n");
-      else
-          dump("nodeName: "+node2.namespaceURI+":"+node2.nodeName+"\n");
-  }
-  return false;
-}

mozilla/extensions/transformiix/resources/buster/DumpDOM.js

@@ -1,85 +0,0 @@
-// ----------------------
-// DumpDOM(node)
-//
-// Call this function to dump the contents of the DOM starting at the specified node.
-// Use node = document.documentElement to dump every element of the current document.
-// Use node = top.window.document.documentElement to dump every element.
-//
-// 8-13-99 Updated to dump almost all attributes of every node.  There are still some attributes
-//         that are purposely skipped to make it more readable.
-// ----------------------
-function DumpDOM(node)
-{
-	dump("--------------------- DumpDOM ---------------------\n");
-	
-	DumpNodeAndChildren(node, "");
-	
-	dump("------------------- End DumpDOM -------------------\n");
-}
-
-
-// This function does the work of DumpDOM by recursively calling itself to explore the tree
-function DumpNodeAndChildren(node, prefix)
-{
-	dump(prefix + "<" + node.nodeName);
-
-	var attributes = node.attributes;
-	
-	if ( attributes && attributes.length )
-	{
-		var item, name, value;
-		
-		for ( var index = 0; index < attributes.length; index++ )
-		{
-			item = attributes.item(index);
-			name = item.nodeName;
-			value = item.nodeValue;
-			
-			if ( (name == 'lazycontent' && value == 'true') ||
-				 (name == 'xulcontentsgenerated' && value == 'true') ||
-				 (name == 'id') ||
-				 (name == 'instanceOf') )
-			{
-				// ignore these
-			}
-			else
-			{
-				dump(" " + name + "=\"" + value + "\"");
-			}
-		}
-	}
-	
-	if ( node.nodeType == 1 )
-	{
-		// id
-		var text = node.getAttribute('id');
-		if ( text && text[0] != '$' )
-			dump(" id=\"" + text + "\"");
-	}
-	
-	if ( node.nodeName == "#text" )
-		dump(" = \"" + node.data + "\"");
-	
-	dump(">\n");
-	
-	// dump IFRAME && FRAME DOM
-	if ( node.nodeName == "IFRAME" || node.nodeName == "FRAME" )
-	{
-		if ( node.name )
-		{
-			var wind = top.frames[node.name];
-			if ( wind && wind.document && wind.document.documentElement )
-			{
-				dump(prefix + "----------- " + node.nodeName + " -----------\n");
-				DumpNodeAndChildren(wind.document.documentElement, prefix + "  ");
-				dump(prefix + "--------- End " + node.nodeName + " ---------\n");
-			}
-		}
-	}
-	// children of nodes (other than frames)
-	else if ( node.childNodes )
-	{
-		for ( var child = 0; child < node.childNodes.length; child++ )
-			DumpNodeAndChildren(node.childNodes[child], prefix + "  ");
-	} 
-}

mozilla/extensions/transformiix/resources/buster/ReadMe

@@ -1,22 +0,0 @@
-The buster is a XUL interface to the conformance tests shipped as part of
-Xalan. For information about Xalan, please see http://xml.apache.org/.
-For your convenience we provide a packed distribution of all needed files
-in http://www.axel.pike.org/mozilla/xalan.tar.gz. Please see the included 
-LICENSE.txt or http://xml.apache.org/dist/LICENSE.txt for terms of 
-distributing those files.
-
-To use the buster, open buster.xul with a XSLT enabled Mozilla.
-Open the rdf index file shipped with the test package into the 
-"Xalan index", and the available tests will show up as a tree.
-Once you have selected the tests you're interested in, press the button
-"run checked tests", and all the tests will be run.
-You can save the results into an rdf, and load it for comparison and 
-regression hunting.
-
-DiffDOM tries to find out, which tests failed, and will DumpDOM both the
-result and the reference solution. Not all reference solutions load
-properly, those need manual love.
-
-Good luck and fun
-
-Axel Hecht <axel@pike.org>

mozilla/extensions/transformiix/resources/buster/buster-files.js

@@ -1,115 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *  Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-const kFileOutStreamCID = "@mozilla.org/network/file-output-stream;1";
-const nsIFileOutputStream = Components.interfaces.nsIFileOutputStream;
-
-var cmdFileController = 
-{
-    supportsCommand: function(aCommand)
-    {
-        switch(aCommand) {
-            case 'cmd_fl_save':
-            case 'cmd_fl_import':
-                return true;
-            default:
-        }
-        return false;
-    },
-    isCommandEnabled: function(aCommand)
-    {
-        return this.supportsCommand(aCommand);
-    },
-    doCommand: function(aCommand)
-    {
-        switch(aCommand) {
-            case 'cmd_fl_save':
-                var sink = new Object;
-                sink.write = function(aContent, aCount)
-                {
-                    // replace NC:succ with NC:orig_succ,
-                    //  so the rdf stuff differs
-                    var content = aContent.replace(/NC:succ/g,"NC:orig_succ");
-                    content = content.replace(/NC:failCount/g,"NC:orig_failCount");
-                    this.mSink.write(content, content.length);
-                    return aCount;
-                };
-                var fp = doCreateRDFFP('Xalan results',
-                                       nsIFilePicker.modeSave);
-                var res = fp.show();
-
-                if (res == nsIFilePicker.returnOK ||
-                    res == nsIFilePicker.returnReplace) {
-                    var serial = doCreate(kRDFXMLSerializerID,
-                                          nsIRDFXMLSerializer);
-                    serial.init(view.mResultDS);
-                    serial.QueryInterface(nsIRDFXMLSource);
-                    var fl = fp.file;
-                    var fstream = doCreate(kFileOutStreamCID,
-                                           nsIFileOutputStream);
-                    fstream.init(fl, 26, 420, 0);
-                    sink.mSink = fstream;
-                    serial.Serialize(sink);
-                }
-                break;
-            case 'cmd_fl_import':
-                var fp = doCreateRDFFP('Previous Xalan results',
-                                       nsIFilePicker.modeLoad);
-                var res = fp.show();
-
-                if (res == nsIFilePicker.returnOK) {
-                    var fl = fp.file;
-                    if (view.mPreviousResultDS) {
-                        view.database.RemoveDataSource(view.mPreviousResultDS);
-                        view.mPreviousResultDS = null;
-                    }
-                    view.mPreviousResultDS = kRDFSvc.GetDataSource(fp.fileURL.spec);
-                    view.database.AddDataSource(view.mPreviousResultDS);
-                }
-
-                document.getElementById('obs_orig_success')
-                    .setAttribute('hidden','false');
-                break;
-            default:
-                alert('Unknown Command'+aCommand);
-        }
-    }
-};
-
-registerController(cmdFileController);

mozilla/extensions/transformiix/resources/buster/buster-handlers.js

@@ -1,71 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *  Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-var xalan_field;
-
-function onLoad()
-{
-    view.tree = document.getElementById('out');
-    view.boxObject = view.tree.boxObject.QueryInterface(Components.interfaces.nsITreeBoxObject);
-    {  
-        view.mIframe = document.getElementById('hiddenHtml');
-        view.mIframe.webNavigation.allowPlugins = false;
-        view.mIframe.webNavigation.allowJavascript = false;
-        view.mIframe.webNavigation.allowMetaRedirects = false;
-        view.mIframe.webNavigation.allowImages = false;
-    }
-    view.database = view.tree.database;
-    view.builder = view.tree.builder.QueryInterface(nsIXULTemplateBuilder);
-    view.builder.QueryInterface(nsIXULTreeBuilder);
-    runItem.prototype.kDatabase = view.database;
-    xalan_field = document.getElementById("xalan_rdf");
-    var persistedUrl = xalan_field.getAttribute('url');
-    if (persistedUrl) {
-        view.xalan_url = persistedUrl;
-        xalan_field.value = persistedUrl;
-    }
-    view.setDataSource();
-    return true;
-}
-
-function onUnload()
-{
-    if (xalan_field)
-        xalan_field.setAttribute('url', xalan_field.value);
-}

mozilla/extensions/transformiix/resources/buster/buster-statics.js

@@ -1,121 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *  Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-// helper function to shortcut component creation
-function doCreate(aContract, aInterface)
-{
-    return Components.classes[aContract].createInstance(aInterface);
-}
-
-// for the items, loading a text file
-const IOSERVICE_CTRID = "@mozilla.org/network/io-service;1";
-const nsIIOService    = Components.interfaces.nsIIOService;
-const SIS_CTRID       = "@mozilla.org/scriptableinputstream;1"
-const nsISIS          = Components.interfaces.nsIScriptableInputStream;
-
-// rdf foo, onload handler
-const kRDFSvcContractID = "@mozilla.org/rdf/rdf-service;1";
-const kRDFInMemContractID = 
-    "@mozilla.org/rdf/datasource;1?name=in-memory-datasource";
-const kRDFContUtilsID = "@mozilla.org/rdf/container-utils;1";
-const kRDFXMLSerializerID = "@mozilla.org/rdf/xml-serializer;1";
-const kIOSvcContractID  = "@mozilla.org/network/io-service;1";
-const kStandardURL = Components.classes["@mozilla.org/network/standard-url;1"];
-const nsIURL = Components.interfaces.nsIURL;
-const nsIStandardURL = Components.interfaces.nsIStandardURL;
-const nsIFilePicker = Components.interfaces.nsIFilePicker;
-const nsIXULTreeBuilder = Components.interfaces.nsIXULTreeBuilder;
-const nsIXULTemplateBuilder = Components.interfaces.nsIXULTemplateBuilder;
-const kIOSvc = Components.classes[kIOSvcContractID]
-    .getService(Components.interfaces.nsIIOService);
-const nsIRDFService = Components.interfaces.nsIRDFService;
-const nsIRDFDataSource = Components.interfaces.nsIRDFDataSource;
-const nsIRDFRemoteDataSource = Components.interfaces.nsIRDFRemoteDataSource;
-const nsIRDFPurgeableDataSource =
-    Components.interfaces.nsIRDFPurgeableDataSource;
-const nsIRDFResource = Components.interfaces.nsIRDFResource;
-const nsIRDFLiteral = Components.interfaces.nsIRDFLiteral;
-const nsIRDFInt = Components.interfaces.nsIRDFInt;
-const nsIRDFContainerUtils = Components.interfaces.nsIRDFContainerUtils;
-const nsIRDFXMLSerializer = Components.interfaces.nsIRDFXMLSerializer;
-const nsIRDFXMLSource = Components.interfaces.nsIRDFXMLSource;
-const kRDFSvc =
-    Components.classes[kRDFSvcContractID].getService(nsIRDFService);
-const krTypeCat = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#category");
-const krTypeFailCount = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#failCount");
-const krTypeName = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#name");
-const krTypeSucc = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#succ");
-const krTypeOrigSucc = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#orig_succ");
-const krTypeOrigFailCount = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#orig_failCount");
-const krTypeOrigSuccCount = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#orig_succCount");
-const krTypePath = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#path");
-const krTypeParent = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#parent");
-const krTypePurp = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#purp");
-const krTypeSuccCount = kRDFSvc.GetResource("http://home.netscape.com/NC-rdf#succCount");
-const kGood  = kRDFSvc.GetLiteral("yes");
-const kBad   = kRDFSvc.GetLiteral("no");
-const kMixed = kRDFSvc.GetLiteral("+-");
-const kContUtils = doCreate(kRDFContUtilsID, nsIRDFContainerUtils);
-
-function doCreateRDFFP(aTitle, aMode)
-{
-    var fp = doCreate("@mozilla.org/filepicker;1", nsIFilePicker);
-    fp.init(window, aTitle, aMode);
-    fp.appendFilter('*.rdf', '*.rdf');
-    fp.appendFilters(nsIFilePicker.filterAll);
-    return fp;
-}
-
-function goDoCommand(aCommand)
-{
-    try {
-        var controller = 
-            top.document.commandDispatcher.getControllerForCommand(aCommand);
-        if (controller && controller.isCommandEnabled(aCommand))
-            controller.doCommand(aCommand);
-    }
-    catch(e) {
-        dump("An error "+e+" occurred executing the "+aCommand+" command\n");
-    }
-}
-
-function registerController(aController)
-{
-    top.controllers.appendController(aController);
-}

mozilla/extensions/transformiix/resources/buster/buster-test.js

@@ -1,390 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *  Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-var parser = new DOMParser();
-var methodExpr = (new XPathEvaluator).createExpression("xsl:output/@method",
-    {
-    lookupNamespaceURI: function(aPrefix)
-        {
-            if (aPrefix == "xsl")
-                return "http://www.w3.org/1999/XSL/Transform";
-            return "";
-        }
-    });
-
-const nsIWebProgListener = Components.interfaces.nsIWebProgressListener;
-
-var runQueue = 
-{
-    mArray : new Array(),
-    push : function(aRunItem)
-    {
-        this.mArray.push(aRunItem);
-    },
-    observe : function(aSubject, aTopic, aData)
-    {
-        var item = this.mArray.shift();
-        if (item) {
-            item.run(this);
-        }
-    },
-    run : function()
-    {
-        this.observe(null,'','');
-    }
-}
-
-var itemCache = 
-{
-    mArray : new Array(),
-    getItem : function(aResource)
-    {
-        // Directory selected
-        if (kContUtils.IsSeq(runItem.prototype.kDatabase, aResource)) {
-            var aSeq = kContUtils.MakeSeq(runItem.prototype.kDatabase, aResource);
-            dump("sequence: "+aSeq+" with "+aSeq.GetCount()+" elements\n");
-            var child, children = aSeq.GetElements();
-            var m = 0, first;
-            while (children.hasMoreElements()) {
-                m += 1;
-                child = children.getNext();
-                child.QueryInterface(nsIRDFResource);
-                if (!first)
-                    first = itemCache.getItem(child);
-                else
-                    itemCache.getItem(child);
-            }
-            return first;
-        }
-        if (aResource.Value in this.mArray) {
-            return this.mArray[aResource.Value];
-        }
-        var retItem = new runItem(aResource);
-        this.mArray[aResource.Value] = retItem;
-        runQueue.push(retItem);
-        return retItem;
-    },
-    rerunItem : function(aResource, aObserver)
-    {
-        var anItem = new runItem(aResource);
-        this.mArray[aResource.Value] = anItem;
-        anItem.run(aObserver);
-    },
-    observe : function(aSubject, aTopic, aData)
-    {
-        this.mRun += 1;
-        if (aTopic == "success") {
-            if (aData == "yes") {
-                this.mGood += 1;
-            }
-            else {
-                this.mFalse +=1;
-            }
-        }
-    }
-}
-
-function runItem(aResource)
-{
-  this.mResource = aResource;
-  // Directory selected
-  if (kContUtils.IsSeq(this.kDatabase,this.mResource)) {
-      var aSeq = kContUtils.MakeSeq(this.kDatabase,this.mResource);
-      dump("THIS SHOULDN'T HAPPEN\n");
-      var child, children = aSeq.GetElements();
-      var m = 0;
-      while (children.hasMoreElements()) {
-          m += 1;
-          child = children.getNext();
-          child.QueryInterface(nsIRDFResource);
-          itemCache.getItem(child);
-      }
-  }
-}
-
-runItem.prototype = 
-{
-    // RDF resource associated with this test
-    mResource : null,
-    // XML documents for the XSLT transformation
-    mSourceDoc : null,
-    mStyleDoc  : null,
-    mResDoc    : null,
-    // XML or plaintext document for the reference
-    mRefDoc    : null,
-    // bitfield signaling the loaded documents
-    mLoaded    : 0,
-    kSource    : 1,
-    kStyle     : 2,
-    kReference : 4,
-    // a observer, potential argument to run()
-    mObserver  : null,
-    mSuccess   : null,
-    mMethod    : 'xml',
-    // XSLTProcessor, shared by the instances
-    kProcessor : new XSLTProcessor(),
-    kXalan     : kStandardURL.createInstance(nsIURL),
-    kDatabase  : null,
-    kObservers : new Array(),
-
-    run : function(aObserver)
-    {
-        if (aObserver && typeof(aObserver)=='function' ||
-            (typeof(aObserver)=='object' && 
-             typeof(aObserver.observe)=='function')) {
-            this.mObserver=aObserver;
-        }
-        var name = this.kDatabase.GetTarget(this.mResource, krTypeName, true);
-        if (name) {
-            var cat = this.kDatabase.GetTarget(this.mResource, krTypeCat, true);
-            var path = this.kDatabase.GetTarget(this.mResource, krTypePath, true);
-            cat = cat.QueryInterface(nsIRDFLiteral);
-            name = name.QueryInterface(nsIRDFLiteral);
-            path = path.QueryInterface(nsIRDFLiteral);
-            var xalan_fl  = this.kXalan.resolve(cat.Value+"/"+path.Value);
-            var xalan_ref  = this.kXalan.resolve(cat.Value+"-gold/"+path.Value);
-            this.mRefURL =
-                this.kXalan.resolve(cat.Value + "-gold/" + path.Value + ".out");
-            dump(name.Value+" links to "+xalan_fl+"\n");
-        }
-        // Directory selected
-        if (kContUtils.IsSeq(this.kDatabase,this.mResource)) {
-            return;
-            var aSeq = kContUtils.MakeSeq(this.kDatabase,this.mResource);
-            dump("sequence: "+aSeq+" with "+aSeq.GetCount()+" elements\n");
-            var child, children = aSeq.GetElements();
-            var m = 0;
-            while (children.hasMoreElements()) {
-                m += 1;
-                child = children.getNext();
-                child.QueryInterface(nsIRDFResource);
-            }
-        }
-        this.mSourceDoc = document.implementation.createDocument('', '', null);
-        this.mSourceDoc.addEventListener("load",this.onload(1),false);
-        this.mSourceDoc.load(xalan_fl+".xml");
-        this.mStyleDoc = document.implementation.createDocument('', '', null);
-        this.mStyleDoc.addEventListener("load",this.styleLoaded(),false);
-        this.mStyleDoc.load(xalan_fl+".xsl");
-    },
-
-    // nsIWebProgressListener
-    QueryInterface: function(aIID)
-    {
-        return this;
-    },
-    onStateChange: function(aProg, aRequest, aFlags, aStatus)
-    {
-        if ((aFlags & nsIWebProgListener.STATE_STOP) &&
-            (aFlags & nsIWebProgListener.STATE_IS_DOCUMENT)) {
-            aProg.removeProgressListener(this);
-            this.mRefDoc = document.getElementById('hiddenHtml').contentDocument;
-            this.fileLoaded(4);
-        }
-    },
-    onProgressChange: function(aProg, b,c,d,e,f)
-    {
-    },
-    onLocationChange: function(aProg, aRequest, aURI)
-    {
-    },
-    onStatusChange: function(aProg, aRequest, aStatus, aMessage)
-    {
-    },
-    onSecurityChange: function(aWebProgress, aRequest, aState)
-    {
-    },
-
-    // onload handler helper
-    onload : function(file)
-    {
-        var self = this;
-        return function(e)
-        {
-            return self.fileLoaded(file);
-        };
-    },
-
-    styleLoaded : function()
-    {
-        var self = this;
-        return function(e)
-        {
-            return self.styleLoadedHelper();
-        };
-    },
-    styleLoadedHelper : function()
-    {
-        var method = methodExpr.evaluate(this.mStyleDoc.documentElement, 2,
-                                         null).stringValue;
-        var refContent;
-        if (!method) {
-            // implicit method, guess from result
-            refContent = this.loadTextFile(this.mRefURL);
-            if (refContent.match(/^\s*<html/gi)) {
-                method = 'html';
-            }
-            else {
-                method = 'xml';
-            }
-        }
-        this.mMethod = method;
-
-        switch (method) {
-        case 'xml':
-            if (!refContent) {
-                refContent = this.loadTextFile(this.mRefURL);
-            }
-            this.mRefDoc = parser.parseFromString(refContent, 'text/xml');
-            this.mLoaded += 4;
-            break;
-        case 'html':
-            view.loadHtml(this.mRefURL, this);
-            break;
-        case 'text':
-            if (!refContent) {
-                refContent = this.loadTextFile(this.mRefURL);
-            }
-            const ns = 'http://www.mozilla.org/TransforMiix';
-            const qn = 'transformiix:result';
-            this.mRefDoc =
-                document.implementation.createDocument(ns, qn, null);
-            var txt = this.mRefDoc.createTextNode(refContent);
-            this.mRefDoc.documentElement.appendChild(txt);
-            this.mLoaded += 4;
-            break;
-        default:
-            throw "unkown XSLT output method";
-        }
-        this.fileLoaded(2)
-    },
-
-    fileLoaded : function(mask)
-    {
-        this.mLoaded += mask;
-        if (this.mLoaded < 7) {
-            return;
-        }
-        this.doTransform();
-    },
-
-    doTransform : function()
-    {
-        this.kProcessor.reset();
-        try {
-            this.kProcessor.importStylesheet(this.mStyleDoc);
-            this.mResDoc =
-                this.kProcessor.transformToDocument(this.mSourceDoc);
-            this.mRefDoc.normalize();
-            isGood = DiffDOM(this.mResDoc.documentElement,
-                             this.mRefDoc.documentElement,
-                             this.mMethod == 'html');
-        } catch (e) {
-            isGood = false;
-        };
-        dump("This succeeded. "+isGood+"\n");
-        isGood = isGood.toString();
-        for (var i=0; i<this.kObservers.length; i++) {
-            var aObs = this.kObservers[i];
-            if (typeof(aObs)=='object' && typeof(aObs.observe)=='function') {
-                aObs.observe(this.mResource, 'success', isGood);
-            }
-            else if (typeof(aObs)=='function') {
-                aObs(this.mResource, 'success', isGood);
-            }
-        }
-        if (this.mObserver) {
-            if (typeof(this.mObserver)=='object') {
-                this.mObserver.observe(this.mResource, 'success', isGood);
-            }
-            else {
-                this.mObserver(this.mResource, 'success', isGood);
-            }
-        }
-    },
-
-    loadTextFile : function(url)
-    {
-        var serv = Components.classes[IOSERVICE_CTRID].
-            getService(nsIIOService);
-        if (!serv) {
-            throw Components.results.ERR_FAILURE;
-        }
-        var chan = serv.newChannel(url, null, null);
-        var instream = doCreate(SIS_CTRID, nsISIS);
-        instream.init(chan.open());
-
-        return instream.read(instream.available());
-    }
-}
-
-runItem.prototype.kXalan.QueryInterface(nsIStandardURL);
-
-var cmdTestController = 
-{
-    supportsCommand: function(aCommand)
-    {
-        switch(aCommand) {
-            case 'cmd_tst_run':
-            case 'cmd_tst_runall':
-                return true;
-            default:
-        }
-        return false;
-    },
-    isCommandEnabled: function(aCommand)
-    {
-        return this.supportsCommand(aCommand);
-    },
-    doCommand: function(aCommand)
-    {
-        switch(aCommand) {
-            case 'cmd_tst_run':
-                dump("cmd_tst_run\n");
-                break;
-            case 'cmd_tst_runall':
-                dump("cmd_tst_runall\n");
-                var tst_run = document.getElementById('cmd_tst_run');
-                tst_run.doCommand();
-            default:
-        }
-    }
-};
-
-registerController(cmdTestController);

mozilla/extensions/transformiix/resources/buster/buster-view.js

@@ -1,227 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *  Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-var view = 
-{
-    onRun : function()
-    {
-        runQueue.mArray = new Array();
-        var sels = this.boxObject.selection,a=new Object(),b=new Object(),k;
-        var rowResource, name, path;
-        for (k=0;k<sels.getRangeCount();k++){
-            sels.getRangeAt(k,a,b);
-            for (var l=a.value;l<=b.value;l++) {
-                rowResource = this.builder.getResourceAtIndex(l);
-                itemCache.getItem(rowResource);
-            }
-        }
-        runQueue.run();
-    },
-    displayTest : function()
-    {
-        var current = this.boxObject.selection.currentIndex;
-        var rowResource = this.builder.getResourceAtIndex(current);
-        var item = itemCache.getItem(rowResource);
-    },
-    browseForRDF : function()
-    {
-        var fp = doCreateRDFFP('Xalan Description File',
-                               nsIFilePicker.modeOpen);
-        var res = fp.show();
-
-        if (res == nsIFilePicker.returnOK) {
-            var furl = fp.fileURL;
-            this.setDataSource(fp.fileURL.spec);
-        }
-    },
-    dump_Good : function()
-    {
-        var enumi = this.mResultDS.GetSources(krTypeSucc, kGood, true);
-        var k = 0;
-        while (enumi.hasMoreElements()) {
-            k += 1;
-            dump(enumi.getNext().QueryInterface(nsIRDFResource).Value+"\n");
-        }
-        dump("found "+k+" good tests\n");
-    },
-    prune_ds : function()
-    {
-        if (this.mResultDS) {
-            this.mResultDS.QueryInterface(nsIRDFPurgeableDataSource).Sweep();
-        }
-        regressionStats.init()
-        itemCache.mArray = new Array();
-    },
-    setDataSource : function(aSpec)
-    {
-        var baseSpec;
-        if (aSpec) {
-            baseSpec = aSpec;
-        }
-        else {
-            baseSpec = document.getElementById("xalan_rdf").value;
-        }
-        if (this.mXalanDS && this.mXalanDS.URI == baseSpec) {
-            this.mXalanDS.QueryInterface(nsIRDFRemoteDataSource);
-            this.mXalanDS.Refresh(true);
-        }
-        else {
-            if (this.mXalanDS) {
-                this.database.RemoveDataSource(view.mXalanDS);
-            }
-            this.mXalanDS = kRDFSvc.GetDataSourceBlocking(baseSpec);
-            if (!this.mXalanDS) {
-                alert("Unable do load DataSource: "+baseSpec);
-                return;
-            }
-            this.database.AddDataSource(this.mXalanDS);
-        }
-        regressionStats.init();
-        if (!this.mResultDS) {
-            this.mResultDS = doCreate(kRDFInMemContractID,
-                                      nsIRDFDataSource);
-            this.database.AddDataSource(view.mResultDS);
-            if (!this.mResultDS) {
-                alert("Unable to create result InMemDatasource");
-                return;
-            }
-        }
-
-        this.builder.rebuild();
-        document.getElementById("xalan_rdf").value = baseSpec;
-        runItem.prototype.kXalan.init(runItem.prototype.kXalan.URLTYPE_STANDARD,
-                                      0, baseSpec, null, null);
-    },
-    loadHtml : function(aUrl, aListener)
-    {
-        const nsIIRequestor = Components.interfaces.nsIInterfaceRequestor;
-        const nsIWebProgress = Components.interfaces.nsIWebProgress;
-        var req = this.mIframe.webNavigation.QueryInterface(nsIIRequestor);
-        var prog = req.getInterface(nsIWebProgress);
-        prog.addProgressListener(aListener, nsIWebProgress.NOTIFY_ALL);
-        this.mIframe.webNavigation.loadURI(aUrl, 0,null,null,null);
-    },
-    fillItemContext : function()
-    {
-        var index = view.boxObject.selection.currentIndex;
-        var res = view.builder.getResourceAtIndex(index);
-        var purp = view.mXalanDS.GetTarget(res, krTypePurp, true);
-        return (purp != null);
-    }
-}
-
-regressionStats =
-{
-    observe: function(aSubject, aTopic, aData)
-    {
-        if (aTopic != 'success') {
-            return;
-        }
-        var arc = (aData == "true") ? krTypeSuccCount : krTypeFailCount;
-        this.assertNewCount(aSubject, arc, 1);
-    },
-    init: function()
-    {
-        if (this.mRegressionDS) {
-            this.mRegressionDS.QueryInterface(nsIRDFPurgeableDataSource).Sweep();
-        }
-        else {
-            this.mRegressionDS = 
-                doCreate(kRDFInMemContractID, nsIRDFDataSource);
-            view.database.AddDataSource(this.mRegressionDS);
-        }
-    },
-    getParent: function(aDS, aSource)
-    {
-        // parent chached?
-        var parent = this.mRegressionDS.GetTarget(aSource, krTypeParent, true);
-        if (!parent) {
-            var labels = view.mXalanDS.ArcLabelsIn(aSource);
-            while (labels.hasMoreElements()) {
-                var arc = labels.getNext().QueryInterface(nsIRDFResource);
-                if (arc.Value.match(this.mChildRE)) {
-                    parent = view.mXalanDS.GetSource(arc, aSource, true);
-                    // cache the parent
-                    this.mRegressionDS.Assert(aSource, krTypeParent,
-                                              parent, true);
-                }
-            }
-        }
-        return parent;
-    },
-    assertNewCount: function(aSource, aArc, aIncrement)
-    {
-        var root = kRDFSvc.GetResource('urn:root');
-        var count = 0;
-        // parent chached?
-        var parent = this.getParent(view.XalanDS, aSource);
-        while (parent && !parent.EqualsNode(root)) {
-            var countRes = view.mResultDS.GetTarget(parent, aArc, true);
-            if (countRes) {
-                count = countRes.QueryInterface(nsIRDFInt).Value;
-            }
-            var newCountRes = kRDFSvc.GetIntLiteral(count + aIncrement);
-            if (!newCountRes) {
-                return;
-            }
-
-            if (countRes) {
-                view.mResultDS.Change(parent, aArc, countRes, newCountRes);
-            }
-            else {
-                view.mResultDS.Assert(parent, aArc, newCountRes, true);
-            }
-            parent = this.getParent(view.XalanDS, parent);
-        }
-    },
-    mRegressionDS: 0,
-    mChildRE: /http:\/\/www\.w3\.org\/1999\/02\/22-rdf-syntax-ns#_/
-}
-
-function rdfObserve(aSubject, aTopic, aData)
-{
-    if (aTopic == "success") {
-        var target = (aData == "true") ? kGood : kBad;
-        view.mResultDS.Assert(aSubject, krTypeSucc, target, true);
-
-        regressionStats.observe(aSubject, aTopic, aData);
-    }
-}
-
-runItem.prototype.kObservers.push(rdfObserve);

mozilla/extensions/transformiix/resources/buster/buster.css

@@ -1,38 +0,0 @@
-/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is Axel Hecht.
- * Portions created by Axel Hecht are Copyright (C) 2002 Axel Hecht.
- * All Rights Reserved.
- *
- * Contributor(s):
- *   Axel Hecht <axel@pike.org> (Original Author)
- */
-
-
-label.head {
-  padding:     5px;
-  font-size:   medium;
-  font-weight: bold;
-}
-
-treechildren:-moz-tree-cell(success yes)
-{
-  background-color: green ;
-}
-
-treechildren:-moz-tree-cell(success no)
-{
-  background-color: red ;
-}

mozilla/extensions/transformiix/resources/buster/buster.xul

@@ -1,227 +0,0 @@
-<?xml version="1.0"?>
-
-<!-- ***** BEGIN LICENSE BLOCK *****
-   - Version: MPL 1.1/GPL 2.0/LGPL 2.1
-   -
-   - The contents of this file are subject to the Mozilla 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/MPL/
-   -
-   - Software distributed under the License is distributed on an "AS IS" basis,
-   - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
-   - for the specific language governing rights and limitations under the
-   - License.
-   -
-   - The Original Code is mozilla.org.
-   -
-   - The Initial Developer of the Original Code is Axel Hecht
-   - Portions created by the Initial Developer are Copyright (C) 2002
-   - the Initial Developer. All Rights Reserved.
-   -
-   - Contributor(s):
-   -   Axel Hecht <axel@pike.org> (Original Author)
-   -
-   - Alternatively, the contents of this file may be used under the terms of
-   - either the GNU General Public License Version 2 or later (the "GPL"), or
-   - the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
-   - in which case the provisions of the GPL or the LGPL are applicable instead
-   - of those above. If you wish to allow use of your version of this file only
-   - under the terms of either the GPL or the LGPL, and not to allow others to
-   - use your version of this file under the terms of the MPL, indicate your
-   - decision by deleting the provisions above and replace them with the notice
-   - and other provisions required by the LGPL or the GPL. If you do not delete
-   - the provisions above, a recipient may use your version of this file under
-   - the terms of any one of the MPL, the GPL or the LGPL.
-   -
-   - ***** END LICENSE BLOCK ***** -->
-
-<?xml-stylesheet href="chrome://communicator/skin/" type="text/css"?>
-<?xml-stylesheet href="buster.css" type="text/css"?>
-
-<?xul-overlay href="chrome://global/content/globalOverlay.xul"?>
-<?xul-overlay href="chrome://communicator/content/utilityOverlay.xul"?>
-
-<window id="XalanBuster"
-        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-        onload="onLoad()" onunload="onUnload()"
-        title="Xalan testcase harness"
-        persist="width,height"
-        orient="vertical">
-<script type="application/x-javascript" src="buster-statics.js" />
-<script type="application/x-javascript" src="buster-test.js" />
-<script type="application/x-javascript" src="buster-view.js" />
-<script type="application/x-javascript" src="buster-handlers.js" />
-<script type="application/x-javascript" src="result-view.js" />
-<script type="application/x-javascript" src="buster-files.js" />
-<script type="application/x-javascript" src="DumpDOM.js" />
-<script type="application/x-javascript" src="DiffDOM.js" />
-
-<commands id="busterKing">
-  <commandset id="buster_file_cmds">
-    <command id="cmd_fl_save" oncommand="goDoCommand('cmd_fl_save')" />
-    <command id="cmd_fl_import" oncommand="goDoCommand('cmd_fl_import')"/>
-  </commandset>
-  <commandset id="buster_test_cmds">
-    <command id="cmd_tst_run" oncommand="goDoCommand('cmd_tst_run')" />
-    <command id="cmd_tst_runall" oncommand="goDoCommand('cmd_tst_runall')" />
-  </commandset>
-  <commandset id="commands">
-    <command id="cmd_quit"/>
-    <command id="cmd_close" oncommand="window.close();"/>
-  </commandset>
-</commands>
-
-<keyset>
-  <key id="key_quit"/>
-  <key id="key_close"/>
-</keyset>
-
-<broadcasterset>
-  <broadcaster id="obs_orig_success" hidden="true"/>
-  <broadcaster id="not_yet" disabled="true"/>
-</broadcasterset>
-
-
-<menubar>
-  <menu id="menu_File" label="File" accesskey="f">
-    <menupopup id="menu_FilePopup">
-      <menuitem label="Save results ..." accesskey="s"
-                observes="cmd_fl_save"/>
-      <menuitem label="Import results ..." accesskey="i"
-                observes="cmd_fl_import"/>
-      <menuitem id="menu_close"/>
-    </menupopup>
-  </menu>
-  <menu id="busterTests" label="Tests" accesskey="t">
-    <menupopup id="tests-popup">
-      <menuitem label="run a test" accesskey="r"
-                observes="cmd_tst_run"/>
-      <menuitem label="run all tests" accesskey="a"
-                observes="cmd_tst_runall"/>
-    </menupopup>
-  </menu>
-</menubar>
-
-<popupset>
-  <popup id="itemcontext" onpopupshowing="return view.fillItemContext();">
-    <menuitem label="View Test" oncommand="onNewResultView(event)"/>
-  </popup>
-</popupset>
-
-<hbox>
-  <button label="check all" oncommand="check(true)" observes="not_yet"/>
-  <button label="uncheck all" oncommand="check(false)" observes="not_yet"/>
-  <button label="reset success" oncommand="view.prune_ds()" />
-  <button label="run checked tests" oncommand="view.onRun()" />
-</hbox>
-<hbox>
-  <label value="Xalan index: " class="head"/>
-  <textbox id="xalan_rdf" persist="url" crop="end" size="40"/>
-  <button label="browse..." oncommand="view.browseForRDF()" />
-</hbox>
-<hbox>
-<groupbox orient="horizontal"><caption label="search" />
-  <button label="Search for " oncommand="select()" observes="not_yet"/>
-  <textbox style="width: 10em;" id="search-name" persist="value" /><label value=" in " />
-  <menulist id="search-field" persist="data" observes="not_yet">
-    <menupopup>
-      <menuitem value="1" label="Name" />
-      <menuitem value="2" label="Purpose" />
-      <menuitem value="3" label="Comment" />
-    </menupopup>
-  </menulist>
-</groupbox>
-<spacer flex="1" /></hbox>
-
-<tree id="out" flex="1" flags="dont-build-content" hidecolumnpicker="true"
-      datasources="rdf:null" ref="urn:root" context="itemcontext">
-  <treecols>
-    <treecol id="NameColumn" flex="1" label="Name" sort="?name"
-             primary="true" />
-    <splitter class="tree-splitter" />
-    <treecol id="PurpsColumn" flex="2" label="Purpose" sort="?purp" />
-    <splitter class="tree-splitter" />
-    <treecol id="SuccessColumn" flex="0" label="Success"  />
-    <splitter class="tree-splitter" observes="obs_orig_success" />
-    <treecol id="OrigSuccessColumn" flex="0" label="Previously" 
-             observes="obs_orig_success" />
-  </treecols>
-  <template>
-    <rule>
-      <conditions>
-        <treeitem uri="?uri" />
-        <member container="?uri" child="?subheading" />
-        <triple subject="?subheading"
-                predicate="http://home.netscape.com/NC-rdf#purp"
-                object="?purp" />
-      </conditions>
-
-      <bindings>
-        <binding subject="?subheading"
-                 predicate="http://home.netscape.com/NC-rdf#name"
-                 object="?name" />
-        <binding subject="?subheading"
-                 predicate="http://home.netscape.com/NC-rdf#succ"
-                 object="?succ" />
-        <binding subject="?subheading"
-                 predicate="http://home.netscape.com/NC-rdf#orig_succ"
-                 object="?orig_succ" />
-      </bindings>
-
-      <action>
-        <treechildren>
-          <treeitem uri="?subheading">
-            <treerow>
-              <treecell ref="NameColumn"    label="?name" />
-              <treecell ref="PurpsColumn"   label="?purp" />
-              <treecell ref="SuccessColumn" label="?succ"
-                        properties="success ?succ"/>
-              <treecell ref="OrigSuccessColumn" label="?orig_succ"
-                        properties="success ?orig_succ" />
-            </treerow>
-          </treeitem>
-        </treechildren>
-      </action>
-    </rule>
-    <rule>
-      <conditions>
-        <treeitem uri="?uri" />
-        <member container="?uri" child="?subheading" />
-      </conditions>
-
-      <bindings>
-        <binding subject="?subheading"
-                 predicate="http://home.netscape.com/NC-rdf#dir"
-                 object="?dir" />
-        <binding subject="?subheading"
-                 predicate="http://home.netscape.com/NC-rdf#succCount"
-                 object="?succ" />
-        <binding subject="?subheading"
-                 predicate="http://home.netscape.com/NC-rdf#failCount"
-                 object="?fail" />
-        <binding subject="?subheading"
-                 predicate="http://home.netscape.com/NC-rdf#orig_succCount"
-                 object="?orig_succ" />
-        <binding subject="?subheading"
-                 predicate="http://home.netscape.com/NC-rdf#orig_failCount"
-                 object="?orig_fail" />
-      </bindings>
-
-      <action>
-        <treechildren>
-          <treeitem uri="?subheading">
-            <treerow>
-              <treecell ref="NameColumn"    label="?dir" />
-              <treecell ref="PurpsColumn"   label="" />
-              <treecell ref="SuccessColumn" label="?succ / ?fail" />
-              <treecell ref="OrigSuccessColumn" label="?orig_succ / ?orig_fail" />
-            </treerow>
-          </treeitem>
-        </treechildren>
-      </action>
-    </rule>
-  </template>
-</tree>
-<iframe style="visibility:hidden; height:0px;" id="hiddenHtml" />
-</window>

mozilla/extensions/transformiix/resources/buster/helper/generate-rdf.pl

@@ -1,95 +0,0 @@
-use File::Spec;
-
-my(@chunks, @list, $entry, $main_cats, $spacing);
-@list = ('conf', 'perf');
-foreach $entry (@list) {
-    $main_cats .= "     <rdf:li><rdf:Description about=\"urn:x-buster:$entry\" nc:dir=\"$entry\" /></rdf:li>\n";
-    go_in($entry, '', $entry);
-}
-if ($ARGV[0]) {
-    open OUTPUT, ">$ARGV[0]";
-}
-else {
-    open OUTPUT, ">xalan.rdf";
-};
-select(OUTPUT);
-print '<?xml version="1.0"?>
-
-<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-         xmlns:nc="http://home.netscape.com/NC-rdf#">
-  <rdf:Seq about="urn:root">
-' . $main_cats . '  </rdf:Seq>
-';
-print join('',@chunks);
-print '</rdf:RDF>
-';
-exit 0;
-
-sub go_in {
-    my($current, $about, $cat) = @_;
-    my (@list, $entry, @subdirs, @files, @purps, $rdf);
-    chdir $current;
-    @list = <*>;
-    
-    LOOP: foreach $entry (@list) {
-        next LOOP if $entry=~/^CVS$/;
-        if (! -d $entry) {
-            if ($entry=~/^($current.*)\.xsl$/) {
-		local $source = $entry;
-		$source=~s/xsl$/xml/;
-		next LOOP if ! -f $source;
-		$entry=~/^($current.*)\.xsl$/;
-                push(@files, $1);
-                local ($purp, $purp_open);
-                open STYLE, $entry;
-                $purp_open = 0;
-                while (<STYLE>) {
-                    if (/<!--\s+purpose: (.+)\s*-->/i) {
-                        $purp .= $1;
-                    }
-                    elsif (/<!--\s+purpose: (.+)\s*$/i) {
-                        $purp_open = 1;
-                        $purp .= $1;
-                    }
-                    elsif ($purp_open) {
-                        if (/\s*(\s.+)\s*-->/) {
-                            $purp_open = 0;
-                            $purp .= $1;
-                        }
-                        elsif (/\s*(\s.+)\s*$/) {
-                            $purp .= $1;
-                        }
-                    }
-                }
-                $purp=~s/"/'/g; $purp=~s/&/&amp;/g; $purp=~s/</&lt;/g;
-                $purp=~s/\r/ /g; $purp=~s/\s\s/ /g; $purp=~s/\s$//g;
-                push(@purps, $purp);
-            }
-        }
-        else {
-            push(@subdirs, $entry);
-        }
-    }
-
-    if (@subdirs > 0 || @files > 0) {
-        my $topic = $about.$current; $topic=~s/\///g;
-        $rdf = '  <rdf:Seq about="urn:x-buster:'.$topic."\">\n";
-        foreach $entry (@subdirs) {
-            if (go_in($entry, $about.$current.'/', $cat)) {
-                my $id = 'urn:x-buster:'.$about.$current.$entry; $id=~s/\///g;
-                $rdf .= "    <rdf:li><rdf:Description about=\"$id\" nc:dir=\"$entry\" /></rdf:li>\n";
-            }
-        }
-        for (my $i=0; $i < @files; $i++) {
-            my $uri = $about.$current.'/'.$files[$i];
-            $uri=~s/[^\/]+\///;
-            my $id = $uri; $id=~s/\///g;
-            $rdf .= "    <rdf:li><rdf:Description about=\"urn:x-buster:$files[$i]\" nc:name=\"$files[$i]\" nc:purp=\"$purps[$i]\" nc:path=\"$uri\" nc:category=\"$cat\" /></rdf:li>\n";
-        }
-        $rdf .= "  </rdf:Seq>\n";
-        push(@chunks, $rdf);
-    }
-
-    chdir File::Spec->updir;
-    return (@subdirs > 0 || @files > 0);
-}

mozilla/extensions/transformiix/resources/buster/result-inspector.xul

@@ -1,70 +0,0 @@
-<?xml version="1.0"?>
-<!-- ***** BEGIN LICENSE BLOCK *****
-   - Version: MPL 1.1/GPL 2.0/LGPL 2.1
-   -
-   - The contents of this file are subject to the Mozilla 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/MPL/
-   -
-   - Software distributed under the License is distributed on an "AS IS" basis,
-   - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
-   - for the specific language governing rights and limitations under the
-   - License.
-   -
-   - The Original Code is mozilla.org.
-   -
-   - The Initial Developer of the Original Code is
-   - Netscape Communications Corporation.
-   - Portions created by the Initial Developer are Copyright (C) 2002
-   - the Initial Developer. All Rights Reserved.
-   -
-   - Contributor(s):
-   -   Peter Van der Beken <peterv@netscape.com> (original author)
-   -
-   - Alternatively, the contents of this file may be used under the terms of
-   - either the GNU General Public License Version 2 or later (the "GPL"), or
-   - the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
-   - in which case the provisions of the GPL or the LGPL are applicable instead
-   - of those above. If you wish to allow use of your version of this file only
-   - under the terms of either the GPL or the LGPL, and not to allow others to
-   - use your version of this file under the terms of the MPL, indicate your
-   - decision by deleting the provisions above and replace them with the notice
-   - and other provisions required by the LGPL or the GPL. If you do not delete
-   - the provisions above, a recipient may use your version of this file under
-   - the terms of any one of the MPL, the GPL or the LGPL.
-   -
-   - ***** END LICENSE BLOCK ***** -->
-
-<!DOCTYPE overlay [
-  <!ENTITY % dtd1 SYSTEM "chrome://inspector/locale/inspector.dtd"> %dtd1;
-  <!ENTITY % dtd2 SYSTEM "chrome://inspector/content/util.dtd"> %dtd2;
-]>
-
-<?xul-overlay href="chrome://inspector/content/commandOverlay.xul"?>
-<?xul-overlay href="chrome://inspector/content/keysetOverlay.xul"?>
-<?xul-overlay href="chrome://inspector/content/popupOverlay.xul"?>
-
-<?xml-stylesheet href="chrome://inspector/skin/inspectorWindow.css"?>
-
-<window class="color-dialog" 
-        title="&Inspector.title;"
-        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  
-  <script type="application/x-javascript" src="chrome://inspector/content/ViewerRegistry.js"/>
-  <script type="application/x-javascript" src="chrome://inspector/content/utils.js"/>
-  <script type="application/x-javascript" src="chrome://inspector/content/jsutil/xpcom/XPCU.js"/>
-  <script type="application/x-javascript" src="chrome://inspector/content/jsutil/rdf/RDFU.js"/>
-  <script type="application/x-javascript" src="chrome://inspector/content/jsutil/rdf/RDFArray.js"/>
-  <script type="application/x-javascript" src="chrome://inspector/content/jsutil/events/ObserverManager.js"/>
-  <script type="application/x-javascript" src="chrome://inspector/content/jsutil/xul/FrameExchange.js"/>
-      
-  <commandset id="cmdsGlobalCommands"/>
-  <keyset id="ksGlobalKeyset"/>
-  <popupset id="ppsViewerPopupset"/>
-  
-  <domi-panelset id="bxPanelSet" flex="1" viewercommandset="cmdsGlobalCommands">
-    <domi-panel title="&bxDocPanel.title;" flex="1"/>
-  </domi-panelset>
-
-</window>

mozilla/extensions/transformiix/resources/buster/result-view.css

@@ -1,16 +0,0 @@
-label.heading {
-  font-size:   medium;
-  font-weight: bold;
-}
-
-button.close {
-  font-size:   small;
-}
-
-iframe {
-  padding-left: 10px;
-}
-
-vbox.hidden {
-    display: none;
-}

mozilla/extensions/transformiix/resources/buster/result-view.js

@@ -1,139 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *  Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-function onNewResultView(event)
-{
-    dump("onNewResultView\n");
-    const db = runItem.prototype.kDatabase;
-    const kXalan = runItem.prototype.kXalan;
-    var index = view.boxObject.selection.currentIndex;
-    var res = view.builder.getResourceAtIndex(index);
-    var name = db.GetTarget(res, krTypeName, true);
-    if (!name) {
-        return false;
-    }
-    var cat = db.GetTarget(res, krTypeCat, true);
-    var path = db.GetTarget(res, krTypePath, true);
-    cat = cat.QueryInterface(nsIRDFLiteral);
-    name = name.QueryInterface(nsIRDFLiteral);
-    path = path.QueryInterface(nsIRDFLiteral);
-    xalan_fl  = kXalan.resolve(cat.Value+"/"+path.Value);
-    xalan_ref  = kXalan.resolve(cat.Value+"-gold/"+path.Value);
-    var currentResultItem = new Object();
-    currentResultItem.testpath = xalan_fl;
-    currentResultItem.refpath = xalan_ref;
-    var currentRunItem = itemCache.getItem(res);
-    // XXX todo, keep a list of these windows, so that we can close them.
-    resultWin = window.openDialog('result-view.xul','_blank',
-                                   'chrome,resizable,dialog=no',
-                                   currentResultItem, currentRunItem);
-    return true;
-}
-
-var refInspector;
-var resInspector;
-
-function onResultViewLoad(event)
-{
-    dump("onResultViewLoad\n");
-    aResultItem = window.arguments[0];
-    aRunItem = window.arguments[1];
-    var loadFlags = Components.interfaces.nsIWebNavigation.LOAD_FLAGS_NONE;
-    document.getElementById('src').webNavigation.loadURI('view-source:'+
-        aResultItem.testpath+'.xml', loadFlags, null, null, null);
-    document.getElementById('style').webNavigation.loadURI('view-source:'+
-        aResultItem.testpath+'.xsl', loadFlags, null, null, null);
-
-    if (aRunItem && aRunItem.mRefDoc && aRunItem.mResDoc) {
-        document.getElementById("refSourceBox").setAttribute("class", "hidden");
-        refInspector = new ObjectApp();
-        refInspector.initialize("refInsp", aRunItem.mRefDoc);
-        resInspector = new ObjectApp();
-        resInspector.initialize("resInsp", aRunItem.mResDoc);
-    }
-    else {
-        document.getElementById("inspectorBox").setAttribute("class", "hidden");
-        document.getElementById('ref').webNavigation.loadURI('view-source:'+
-            aResultItem.refpath+'.out', loadFlags, null, null, null);
-    }
-    return true;
-}
-
-function onResultViewUnload(event)
-{
-    dump("onResultUnload\n");
-}
-
-function ObjectApp()
-{
-}
-
-ObjectApp.prototype = 
-{
-    mDoc: null,
-    mPanelSet: null,
-
-    initialize: function(aId, aDoc)
-    {
-        this.mDoc = aDoc;
-        this.mPanelSet = document.getElementById(aId).contentDocument.getElementById("bxPanelSet");
-        this.mPanelSet.addObserver("panelsetready", this, false);
-        this.mPanelSet.initialize();
-    },
-
-    doViewerCommand: function(aCommand)
-    {
-        this.mPanelSet.execCommand(aCommand);
-    },
-
-    getViewer: function(aUID)
-    {
-        return this.mPanelSet.registry.getViewerByUID(aUID);
-    },
-
-    onEvent: function(aEvent)
-    {
-        switch (aEvent.type) {
-            case "panelsetready":
-            {
-                this.mPanelSet.getPanel(0).subject = this.mDoc;
-            }
-        }
-    }
-};

mozilla/extensions/transformiix/resources/buster/result-view.xul

@@ -1,79 +0,0 @@
-<?xml version="1.0"?>
-
-<!-- ***** BEGIN LICENSE BLOCK *****
-   - Version: MPL 1.1/GPL 2.0/LGPL 2.1
-   -
-   - The contents of this file are subject to the Mozilla 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/MPL/
-   -
-   - Software distributed under the License is distributed on an "AS IS" basis,
-   - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
-   - for the specific language governing rights and limitations under the
-   - License.
-   -
-   - The Original Code is mozilla.org.
-   -
-   - The Initial Developer of the Original Code is Axel Hecht
-   - Portions created by the Initial Developer are Copyright (C) 2002
-   - the Initial Developer. All Rights Reserved.
-   -
-   - Contributor(s):
-   -   Axel Hecht <axel@pike.org> (Original Author)
-   -
-   - Alternatively, the contents of this file may be used under the terms of
-   - either the GNU General Public License Version 2 or later (the "GPL"), or
-   - the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
-   - in which case the provisions of the GPL or the LGPL are applicable instead
-   - of those above. If you wish to allow use of your version of this file only
-   - under the terms of either the GPL or the LGPL, and not to allow others to
-   - use your version of this file under the terms of the MPL, indicate your
-   - decision by deleting the provisions above and replace them with the notice
-   - and other provisions required by the LGPL or the GPL. If you do not delete
-   - the provisions above, a recipient may use your version of this file under
-   - the terms of any one of the MPL, the GPL or the LGPL.
-   -
-   - ***** END LICENSE BLOCK ***** -->
-
-<?xml-stylesheet href="chrome://communicator/skin/" type="text/css"?>
-<?xml-stylesheet href="result-view.css" type="text/css"?>
-
-<window id="buster-result-view" title="Xalan testcase details"
-        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-        orient="vertical" persist="width height"
-	onload="onResultViewLoad()" onunload="onResultViewUnload()">
-  <script type="application/x-javascript" src="DumpDOM.js" />
-  <script type="application/x-javascript" src="buster-statics.js" />
-  <script type="application/x-javascript" src="buster-test.js" />
-  <script type="application/x-javascript" src="result-view.js" />
-
-  <hbox>
-    <button class="close" label="close this window"
-            oncommand="window.close()" />
-  </hbox>
-  <vbox flex="1">
-    <label class="heading" value="XML Source:" />
-    <iframe flex="1" id="src" />
-  </vbox>
-  <vbox flex="1">
-    <label class="heading" value="XSL Source:" />
-    <iframe flex="1" id="style" />
-  </vbox>
-  <vbox flex="1" id="refSourceBox">
-    <label class="heading" value="Reference Source:" />
-    <iframe flex="1" id="ref" />
-  </vbox>
-  <vbox flex="2" id="inspectorBox">
-    <hbox flex="1">  
-      <vbox flex="1">
-        <label class="heading" value="Reference" />
-        <iframe flex="1" id="refInsp" src="result-inspector.xul" />
-      </vbox>
-      <vbox flex="1">
-        <label class="heading" value="Result" />
-        <iframe flex="1" id="resInsp" src="result-inspector.xul" />
-      </vbox>
-    </hbox>
-  </vbox>
-</window>

mozilla/extensions/transformiix/resources/contents.rdf

@@ -1,28 +0,0 @@
-<?xml version="1.0"?>
-<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-         xmlns:chrome="http://www.mozilla.org/rdf/chrome#">
-
-  <!-- list all the packages being supplied by this jar -->
-  <RDF:Seq about="urn:mozilla:package:root">
-    <RDF:li resource="urn:mozilla:package:xslt-qa"/>
-  </RDF:Seq>
-
-  <!-- package information -->
-  <RDF:Description about="urn:mozilla:package:xslt-qa"
-        chrome:displayName="XSLT QA Tools"
-        chrome:author="mozilla.org"
-        chrome:name="xslt-qa"
-        chrome:localeVersion="1.4a"
-        chrome:skinVersion="1.2">
-  </RDF:Description>
-
-  <!-- overlay information -->
-  <RDF:Seq about="urn:mozilla:overlays">
-    <RDF:li resource="chrome://navigator/content/navigatorOverlay.xul"/>
-  </RDF:Seq>
-
-  <RDF:Seq about="chrome://navigator/content/navigatorOverlay.xul">
-    <RDF:li>chrome://xslt-qa/content/xslt-qa-overlay.xul</RDF:li>
-  </RDF:Seq>
-
-</RDF:RDF>

mozilla/extensions/transformiix/resources/jar.mn

@@ -1,17 +0,0 @@
-xslt-qa.jar:
-  content/xslt-qa/contents.rdf		(contents.rdf)
-  content/xslt-qa/xslt-qa-overlay.xul	(xslt-qa-overlay.xul)
-  content/xslt-qa/xslt-qa-overlay.js	(xslt-qa-overlay.js)
-  content/xslt-qa/buster/buster.xul		(buster/buster.xul)
-  content/xslt-qa/buster/buster.css		(buster/buster.css)
-  content/xslt-qa/buster/buster-statics.js	(buster/buster-statics.js)
-  content/xslt-qa/buster/buster-handlers.js	(buster/buster-handlers.js)
-  content/xslt-qa/buster/buster-files.js	(buster/buster-files.js)
-  content/xslt-qa/buster/buster-test.js		(buster/buster-test.js)
-  content/xslt-qa/buster/buster-view.js		(buster/buster-view.js)
-  content/xslt-qa/buster/result-view.xul	(buster/result-view.xul)
-  content/xslt-qa/buster/result-inspector.xul	(buster/result-inspector.xul)
-  content/xslt-qa/buster/result-view.css	(buster/result-view.css)
-  content/xslt-qa/buster/result-view.js		(buster/result-view.js)
-  content/xslt-qa/buster/DumpDOM.js		(buster/DumpDOM.js)
-  content/xslt-qa/buster/DiffDOM.js		(buster/DiffDOM.js)

mozilla/extensions/transformiix/resources/xslt-qa-overlay.js

@@ -1,44 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *  Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-function onStartBuster()
-{
-    window.open('chrome://xslt-qa/content/buster/buster.xul',
-                'buster', 'chrome,resizable');
-}

mozilla/extensions/transformiix/resources/xslt-qa-overlay.xul

@@ -1,51 +0,0 @@
-<?xml version="1.0"?>
-
-<!-- ***** BEGIN LICENSE BLOCK *****
-   - Version: MPL 1.1/GPL 2.0/LGPL 2.1
-   -
-   - The contents of this file are subject to the Mozilla 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/MPL/
-   -
-   - Software distributed under the License is distributed on an "AS IS" basis,
-   - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
-   - for the specific language governing rights and limitations under the
-   - License.
-   -
-   - The Original Code is mozilla.org.
-   -
-   - The Initial Developer of the Original Code is Axel Hecht
-   - Portions created by the Initial Developer are Copyright (C) 2002
-   - the Initial Developer. All Rights Reserved.
-   -
-   - Contributor(s):
-   -   Axel Hecht <axel@pike.org> (Original Author)
-   -
-   - Alternatively, the contents of this file may be used under the terms of
-   - either the GNU General Public License Version 2 or later (the "GPL"), or
-   - the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
-   - in which case the provisions of the GPL or the LGPL are applicable instead
-   - of those above. If you wish to allow use of your version of this file only
-   - under the terms of either the GPL or the LGPL, and not to allow others to
-   - use your version of this file under the terms of the MPL, indicate your
-   - decision by deleting the provisions above and replace them with the notice
-   - and other provisions required by the LGPL or the GPL. If you do not delete
-   - the provisions above, a recipient may use your version of this file under
-   - the terms of any one of the MPL, the GPL or the LGPL.
-   -
-   - ***** END LICENSE BLOCK ***** -->
-
-<overlay id="xsltQAMenuID"
-         xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
-  <script src="xslt-qa-overlay.js" />
-  <menupopup id="qaMenuPopup">
-    <menuseparator/>
-    <menu label="XSLT QA" accesskey="X">
-      <menupopup>
-        <menuitem label="Xalan Tests" oncommand="onStartBuster()"/>
-        <menuitem label="XSLTMark" oncommand="alert('bar2')"/>
-      </menupopup>
-    </menu>
-  </menupopup>
-</overlay>

mozilla/extensions/transformiix/source/Makefile.in

@@ -1,35 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla 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/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is Transformiix XSLT Processor.
-# 
-# The Initial Developer of the Original Code is Axel Hecht.
-# Portions created by Axel Hecht are  Copyright (C) Axel Hecht.
-# All Rights Reserved.
-# 
-# Contributor(s):
-#	Axel Hecht <axel@pike.org>
-# 
-
-DEPTH           = ../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS            = base xml xpath xslt 
-
-ifdef TX_EXE
-DIRS += lib main
-endif
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/transformiix/source/base/Double.cpp

@@ -1,313 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- * Larry Fitzpatrick, lef@opentext.com
- *
- * Eric Du, duxy@leyou.com.cn
- *   -- added fix for FreeBSD
- *
- * NaN/Infinity code copied from the JS-library with permission from
- * Netscape Communications Corporation: http://www.mozilla.org/js
- * http://lxr.mozilla.org/seamonkey/source/js/src/jsnum.h
- *
- */
-
-#include "nsString.h"
-#include "primitives.h"
-#include "XMLUtils.h"
-#include <math.h>
-#include <stdlib.h>
-#ifdef WIN32
-#include <float.h>
-#endif
-#include "prdtoa.h"
-
-/*
- * Utility class for doubles
- */
-
-//A trick to handle IEEE floating point exceptions on FreeBSD - E.D.
-#ifdef __FreeBSD__
-#include <ieeefp.h>
-#ifdef __alpha__
-fp_except_t allmask = FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP;
-#else
-fp_except_t allmask = FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP|FP_X_DNML;
-#endif
-fp_except_t oldmask = fpsetmask(~allmask);
-#endif
-
-/*
- * Macros to workaround math-bugs bugs in various platforms
- */
-
-#ifdef IS_BIG_ENDIAN
-#define TX_DOUBLE_HI32(x)        (((PRUint32 *)&(x))[0])
-#define TX_DOUBLE_LO32(x)        (((PRUint32 *)&(x))[1])
-#else
-#define TX_DOUBLE_HI32(x)        (((PRUint32 *)&(x))[1])
-#define TX_DOUBLE_LO32(x)        (((PRUint32 *)&(x))[0])
-#endif
-
-#define TX_DOUBLE_HI32_SIGNBIT   0x80000000
-#define TX_DOUBLE_HI32_EXPMASK   0x7ff00000
-#define TX_DOUBLE_HI32_MANTMASK  0x000fffff
-
-//-- Initialize Double related constants
-#ifdef IS_BIG_ENDIAN
-const PRUint32 nanMask[2] =    {TX_DOUBLE_HI32_EXPMASK | TX_DOUBLE_HI32_MANTMASK,
-                                0xffffffff};
-const PRUint32 infMask[2] =    {TX_DOUBLE_HI32_EXPMASK, 0};
-const PRUint32 negInfMask[2] = {TX_DOUBLE_HI32_EXPMASK | TX_DOUBLE_HI32_SIGNBIT, 0};
-#else
-const PRUint32 nanMask[2] =    {0xffffffff,
-                                TX_DOUBLE_HI32_EXPMASK | TX_DOUBLE_HI32_MANTMASK};
-const PRUint32 infMask[2] =    {0, TX_DOUBLE_HI32_EXPMASK};
-const PRUint32 negInfMask[2] = {0, TX_DOUBLE_HI32_EXPMASK | TX_DOUBLE_HI32_SIGNBIT};
-#endif
-
-const double Double::NaN = *((double*)nanMask);
-const double Double::POSITIVE_INFINITY = *((double*)infMask);
-const double Double::NEGATIVE_INFINITY = *((double*)negInfMask);
-
-/*
- * Determines whether the given double represents positive or negative
- * inifinity
- */
-MBool Double::isInfinite(double aDbl)
-{
-    return ((TX_DOUBLE_HI32(aDbl) & ~TX_DOUBLE_HI32_SIGNBIT) == TX_DOUBLE_HI32_EXPMASK &&
-            !TX_DOUBLE_LO32(aDbl));
-}
-
-/*
- * Determines whether the given double is NaN
- */
-MBool Double::isNaN(double aDbl)
-{
-    return ((TX_DOUBLE_HI32(aDbl) & TX_DOUBLE_HI32_EXPMASK) == TX_DOUBLE_HI32_EXPMASK &&
-            (TX_DOUBLE_LO32(aDbl) || (TX_DOUBLE_HI32(aDbl) & TX_DOUBLE_HI32_MANTMASK)));
-}
-
-/*
- * Determines whether the given double is negative
- */
-MBool Double::isNeg(double aDbl)
-{
-    return (TX_DOUBLE_HI32(aDbl) & TX_DOUBLE_HI32_SIGNBIT) != 0;
-}
-
-/*
- * Converts the given String to a double, if the String value does not
- * represent a double, NaN will be returned
- */
-class txStringToDouble
-{
-public:
-    typedef PRUnichar input_type;
-    typedef PRUnichar value_type;
-    txStringToDouble(): mState(eWhitestart), mSign(ePositive) {}
-
-    PRUint32
-    write(const input_type* aSource, PRUint32 aSourceLength)
-    {
-        if (mState == eIllegal) {
-            return aSourceLength;
-        }
-        PRUint32 i = 0;
-        PRUnichar c;
-        for ( ; i < aSourceLength; ++i) {
-            c = aSource[i];
-            switch (mState) {
-                case eWhitestart:
-                    if (c == '-') {
-                        mState = eDecimal;
-                        mSign = eNegative;
-                    }
-                    else if (c >= '0' && c <= '9') {
-                        mState = eDecimal;
-                        mBuffer.Append((char)c);
-                    }
-                    else if (c == '.') {
-                        mState = eMantissa;
-                        mBuffer.Append((char)c);
-                    }
-                    else if (!XMLUtils::isWhitespace(c)) {
-                        mState = eIllegal;
-                        return aSourceLength;
-                    }
-                    break;
-                case eDecimal:
-                    if (c >= '0' && c <= '9') {
-                        mBuffer.Append((char)c);
-                    }
-                    else if (c == '.') {
-                        mState = eMantissa;
-                        mBuffer.Append((char)c);
-                    }
-                    else if (XMLUtils::isWhitespace(c)) {
-                        mState = eWhiteend;
-                    }
-                    else {
-                        mState = eIllegal;
-                        return aSourceLength;
-                    }
-                    break;
-                case eMantissa:
-                    if (c >= '0' && c <= '9') {
-                        mBuffer.Append((char)c);
-                    }
-                    else if (XMLUtils::isWhitespace(c)) {
-                        mState = eWhiteend;
-                    }
-                    else {
-                        mState = eIllegal;
-                        return aSourceLength;
-                    }
-                    break;
-                case eWhiteend:
-                    if (!XMLUtils::isWhitespace(c)) {
-                        mState = eIllegal;
-                        return aSourceLength;
-                    }
-                    break;
-                default:
-                    break;
-            }
-        }
-        return aSourceLength;
-    }
-
-    double
-    getDouble()
-    {
-        if (mState == eIllegal || mBuffer.IsEmpty() ||
-            (mBuffer.Length() == 1 && mBuffer[0] == '.')) {
-            return Double::NaN;
-        }
-        return mSign*PR_strtod(mBuffer.get(), 0);
-    }
-private:
-    nsCAutoString mBuffer;
-    enum {
-        eWhitestart,
-        eDecimal,
-        eMantissa,
-        eWhiteend,
-        eIllegal
-    } mState;
-    enum {
-        eNegative = -1,
-        ePositive = 1
-    } mSign;
-};
-
-double Double::toDouble(const nsAString& aSrc)
-{
-    txStringToDouble sink;
-    nsAString::const_iterator fromBegin, fromEnd;
-    copy_string(aSrc.BeginReading(fromBegin), aSrc.EndReading(fromEnd), sink);
-    return sink.getDouble();
-}
-
-/*
- * Converts the value of the given double to a String, and places
- * The result into the destination String.
- * @return the given dest string
- */
-void Double::toString(double aValue, nsAString& aDest)
-{
-
-    // check for special cases
-
-    if (isNaN(aValue)) {
-        aDest.Append(NS_LITERAL_STRING("NaN"));
-        return;
-    }
-    if (isInfinite(aValue)) {
-        if (aValue < 0)
-            aDest.Append(PRUnichar('-'));
-        aDest.Append(NS_LITERAL_STRING("Infinity"));
-        return;
-    }
-
-    // Mantissa length is 17, so this is plenty
-    const int buflen = 20;
-    char buf[buflen];
-
-    PRIntn intDigits, sign;
-    char* endp;
-    PR_dtoa(aValue, 0, 0, &intDigits, &sign, &endp, buf, buflen - 1);
-
-    // compute length
-    PRInt32 length = endp - buf;
-    if (length > intDigits) {
-        // decimal point needed
-        ++length;
-        if (intDigits < 1) {
-            // leading zeros, -intDigits + 1
-            length += 1 - intDigits;
-        }
-    }
-    else {
-        // trailing zeros, total length given by intDigits
-        length = intDigits;
-    }
-    if (aValue < 0)
-        ++length;
-    PRUint32 oldlength = aDest.Length();
-    aDest.SetLength(oldlength + length); // grow the string
-    nsAString::iterator dest;
-    aDest.BeginWriting(dest).advance(PRInt32(oldlength));
-    if (aValue < 0) {
-        *dest = '-'; ++dest;
-    }
-    int i;
-    // leading zeros
-    if (intDigits < 1) {
-        *dest = '0'; ++dest;
-        *dest = '.'; ++dest;
-        for (i = 0; i > intDigits; --i) {
-            *dest = '0'; ++dest;
-        }
-    }
-    // mantissa
-    int firstlen = PR_MIN(intDigits, endp - buf);
-    for (i = 0; i < firstlen; i++) {
-        *dest = buf[i]; ++dest;
-    }
-    if (i < endp - buf) {
-        if (i > 0) {
-            *dest = '.'; ++dest;
-        }
-        for (; i < endp - buf; i++) {
-            *dest = buf[i]; ++dest;
-        }
-    }
-    // trailing zeros
-    for (; i < intDigits; i++) {
-        *dest = '0'; ++dest;
-    }
-}

mozilla/extensions/transformiix/source/base/ErrorObserver.h

@@ -1,98 +0,0 @@
-/*
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- * 
- * Contributor(s): 
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- */
-
-#ifndef MITRE_ERROROBSERVER_H
-#define MITRE_ERROROBSERVER_H
-
-#include "baseutils.h"
-#include "txError.h"
-#include <iostream.h>
-class nsAString;
-
-/**
- * A simple interface for observing errors
-**/
-class ErrorObserver {
-
-public:
-
-    /**
-     * Default Destructor for ErrorObserver
-    **/
-    virtual ~ErrorObserver() {};
-
-    /**
-     *  Notifies this Error observer of a new error aRes
-    **/
-    virtual void receiveError(const nsAString& errorMessage, nsresult aRes) = 0;
-
-    /**
-     *  Notifies this Error observer of a new error, with default
-     *  error code NS_ERROR_FAILURE
-    **/
-    void receiveError(const nsAString& errorMessage)
-    {
-        receiveError(errorMessage, NS_ERROR_FAILURE);
-    }
-
-        
-
-}; //-- ErrorObserver
-
-/**
- * A simple ErrorObserver which allows printing error messages to a stream
-**/
-class SimpleErrorObserver : public ErrorObserver {
-
-public:
-
-    /**
-     * Creates a new SimpleErrorObserver.
-     * All errors will be printed to the console (cout).
-    **/
-    SimpleErrorObserver();
-
-    /**
-     * Creates a new SimpleErrorObserver.
-     * All errors will be printed to the given ostream.
-    **/
-    SimpleErrorObserver(ostream& errStream);
-
-    virtual ~SimpleErrorObserver() {};
-
-    /**
-     *  Notifies this Error observer of a new error aRes
-    **/
-    void receiveError(const nsAString& errorMessage, nsresult aRes);
-
-    virtual void supressWarnings(MBool supress);
-
-private:
-
-    ostream* errStream;
-    MBool hideWarnings;
-}; //-- SimpleErrorObserver
-#endif
-

mozilla/extensions/transformiix/source/base/List.cpp

@@ -1,420 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- * 
- * Contributor(s): 
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- * Bob Miller, kbob@oblix.com
- *    -- plugged core leak.
- *
- * Jonas Sicking, sicking@bigfoot.com
- *    -- Cleanup/bugfix/features in Iterator
- *       Added tx prefix to classnames
- */
-
-#include "List.h"
-
-  //----------------------------/
- //- Implementation of txList -/
-//----------------------------/
-
-/**
- * Default constructor for a txList;
-**/
-
-txList::txList() {
-   firstItem  = 0;
-   lastItem   = 0;
-   itemCount  = 0;
-} //-- txList;
-
-/**
- * txList destructor, cleans up ListItems, but will not delete the Object
- * references
-*/
-txList::~txList() {
-    clear();
-} //-- ~txList
-
-nsresult txList::insert(int index, void* objPtr)
-{
-    if (index >= itemCount) {
-        return insertBefore(objPtr, 0);
-    }
-    // add inside the list
-    ListItem* nextItem = firstItem;
-    for (int i = 0; i < index; i++)
-        nextItem = nextItem->nextItem;
-    return insertBefore(objPtr, nextItem);
-} //-- insert
-
-nsresult txList::add(void* objPtr)
-{
-    return insertBefore(objPtr, 0);
-} //-- add
-
-/**
- * Returns the object located at the given index. This may
- * be slow or fast depending on the implementation.
- * Note:
- * Currently this list is implemented via a linked list, so
- * this method will be slow (unless the list only has a couple
- * members) as it will need traverse the links each time
- * @return the object located at the given index
-**/
-void* txList::get(int index) {
-
-    if (index < 0 || index >= itemCount)
-        return 0;
-
-    int c = 0;
-    ListItem* item = firstItem;
-    while ((c != index) && item) {
-        item = item->nextItem;
-        ++c;
-    }
-
-    if (item)
-        return item->objPtr;
-    return 0;
-} //-- get(int)
-
-txList::ListItem* txList::getFirstItem() {
-    return firstItem;
-} //-- getFirstItem
-
-txList::ListItem* txList::getLastItem() {
-    return lastItem;
-} //-- getLastItem
-
-/**
- * Returns the number of items in this txList
-**/
-PRInt32 List::getLength() {
-   return itemCount;
-} //-- getLength
-
-
-/**
- * Inserts the given Object pointer as the item just after refItem.
- * If refItem is a null pointer the Object will be inserted at the
- * beginning of the txList (ie, insert after nothing).
- * This method assumes refItem is a member of this list, and since this
- * is a private method, I feel that's a valid assumption
-**/
-nsresult txList::insertAfter(void* objPtr, ListItem* refItem)
-{
-    //-- if refItem == null insert at front
-    if (!refItem)
-        return insertBefore(objPtr, firstItem);
-    return insertBefore(objPtr, refItem->nextItem);
-} //-- insertAfter
-
-/**
- * Inserts the given Object pointer as the item just before refItem.
- * If refItem is a null pointer the Object will be inserted at the
- * end of the txList (ie, insert before nothing).
- * This method assumes refItem is a member of this list, and since this
- * is a private method, I feel that's a valid assumption
-**/
-nsresult txList::insertBefore(void* objPtr, ListItem* refItem)
-{
-    ListItem* item = new ListItem;
-    NS_ENSURE_TRUE(item, NS_ERROR_OUT_OF_MEMORY);
-
-    item->objPtr = objPtr;
-    item->nextItem = 0;
-    item->prevItem = 0;
-
-    //-- if refItem == null insert at end
-    if (!refItem) {
-        //-- add to back of list
-        if (lastItem) {
-            lastItem->nextItem = item;
-            item->prevItem = lastItem;
-        }
-        lastItem = item;
-        if (!firstItem)
-            firstItem = item;
-    }
-    else {
-        //-- insert before given item
-        item->nextItem = refItem;
-        item->prevItem = refItem->prevItem;
-        refItem->prevItem = item;
-
-        if (item->prevItem)
-            item->prevItem->nextItem = item;
-        else
-            firstItem = item;
-    }
-
-    // increase the item count
-    ++itemCount;
-    
-    return NS_OK;
-} //-- insertBefore
-
-void* txList::remove(void* objPtr) {
-   ListItem* item = firstItem;
-   while (item) {
-      if (item->objPtr == objPtr) {
-         remove(item);
-         delete item;
-         return objPtr;
-      }
-      item = item->nextItem;
-   }
-   // not in list
-   return 0;
-} //-- remove
-
-txList::ListItem* txList::remove(ListItem* item) {
-
-    if (!item)
-        return item;
-
-    //-- adjust the previous item's next pointer
-    if (item->prevItem) {
-        item->prevItem->nextItem = item->nextItem;
-    }
-    //-- adjust the next item's previous pointer
-    if (item->nextItem) {
-        item->nextItem->prevItem = item->prevItem;
-    }
-
-    //-- adjust first and last items
-    if (item == firstItem)
-        firstItem = item->nextItem;
-    if (item == lastItem)
-        lastItem = item->prevItem;
-
-    //-- decrease Item count
-    --itemCount;
-    return item;
-} //-- remove
-
-void txList::clear()
-{
-    ListItem* item = firstItem;
-    while (item) {
-        ListItem* tItem = item;
-        item = item->nextItem;
-        delete tItem;
-    }
-    firstItem  = 0;
-    lastItem   = 0;
-    itemCount  = 0;
-}
-
-  //------------------------------------/
- //- Implementation of txListIterator -/
-//------------------------------------/
-
-
-/**
- * Creates a new txListIterator for the given txList
- * @param list, the txList to create an Iterator for
-**/
-txListIterator::txListIterator(txList* list) {
-   this->list   = list;
-   currentItem  = 0;
-   atEndOfList  = MB_FALSE;
-} //-- txListIterator
-
-txListIterator::~txListIterator() {
-  //-- overrides default destructor to do nothing
-} //-- ~txListIterator
-
-/**
- * Adds the Object pointer to the txList pointed to by this txListIterator.
- * The Object pointer is inserted as the next item in the txList
- * based on the current position within the txList
- * @param objPtr the Object pointer to add to the list
-**/
-nsresult txListIterator::addAfter(void* objPtr)
-{
-    if (currentItem || !atEndOfList)
-        return list->insertAfter(objPtr, currentItem);
-    return list->insertBefore(objPtr, 0);
-
-} //-- addAfter
-
-/**
- * Adds the Object pointer to the txList pointed to by this txListIterator.
- * The Object pointer is inserted as the previous item in the txList
- * based on the current position within the txList
- * @param objPtr the Object pointer to add to the list
-**/
-nsresult txListIterator::addBefore(void* objPtr)
-{
-    if (currentItem || atEndOfList)
-        return list->insertBefore(objPtr, currentItem);
-    return list->insertAfter(objPtr, 0);
-
-} //-- addBefore
-
-/**
- * Returns true if a sucessful call to the next() method can be made
- * @return MB_TRUE if a sucessful call to the next() method can be made,
- * otherwise MB_FALSE
-**/
-MBool txListIterator::hasNext() {
-    MBool hasNext = MB_FALSE;
-    if (currentItem)
-        hasNext = (currentItem->nextItem != 0);
-    else if (!atEndOfList)
-        hasNext = (list->firstItem != 0);
-
-    return hasNext;
-} //-- hasNext
-
-/**
- * Returns true if a sucessful call to the previous() method can be made
- * @return MB_TRUE if a sucessful call to the previous() method can be made,
- * otherwise MB_FALSE
-**/
-MBool txListIterator::hasPrevious() {
-    MBool hasPrevious = MB_FALSE;
-    if (currentItem)
-        hasPrevious = (currentItem->prevItem != 0);
-    else if (atEndOfList)
-        hasPrevious = (list->lastItem != 0);
-
-    return hasPrevious;
-} //-- hasPrevious
-
-/**
- * Returns the next Object pointer in the list
-**/
-void* txListIterator::next() {
-
-    void* obj = 0;
-    if (currentItem)
-        currentItem = currentItem->nextItem;
-    else if (!atEndOfList)
-        currentItem = list->firstItem;
-
-    if (currentItem)
-        obj = currentItem->objPtr;
-    else
-        atEndOfList = MB_TRUE;
-
-    return obj;
-} //-- next
-
-/**
- * Returns the previous Object in the list
-**/
-void* txListIterator::previous() {
-
-    void* obj = 0;
-
-    if (currentItem)
-        currentItem = currentItem->prevItem;
-    else if (atEndOfList)
-        currentItem = list->lastItem;
-    
-    if (currentItem)
-        obj = currentItem->objPtr;
-
-    atEndOfList = MB_FALSE;
-
-    return obj;
-} //-- previous
-
-/**
- * Returns the current Object
-**/
-void* txListIterator::current() {
-
-    if (currentItem)
-        return currentItem->objPtr;
-
-    return 0;
-} //-- current
-
-/**
- * Moves the specified number of steps
-**/
-void* txListIterator::advance(int i) {
-
-    void* obj = 0;
-
-    if (i > 0) {
-        if (!currentItem && !atEndOfList) {
-            currentItem = list->firstItem;
-            --i;
-        }
-        for (; currentItem && i > 0; i--)
-            currentItem = currentItem->nextItem;
-        
-        atEndOfList = currentItem == 0;
-    }
-    else if (i < 0) {
-        if (!currentItem && atEndOfList) {
-            currentItem = list->lastItem;
-            ++i;
-        }
-        for (; currentItem && i < 0; i++)
-            currentItem = currentItem->prevItem;
-
-        atEndOfList = MB_FALSE;
-    }
-
-    if (currentItem)
-        obj = currentItem->objPtr;
-
-    return obj;
-} //-- advance
-
-/**
- * Removes the Object last returned by the next() or previous() methods;
- * @return the removed Object pointer
-**/
-void* txListIterator::remove() {
-
-    void* obj = 0;
-    if (currentItem) {
-        obj = currentItem->objPtr;
-        txList::ListItem* item = currentItem;
-        previous(); //-- make previous item the current item
-        list->remove(item);
-        delete item;
-    }
-    return obj;
-} //-- remove
-
-/**
- * Resets the current location within the txList to the beginning of the txList
-**/
-void txListIterator::reset() {
-   atEndOfList = MB_FALSE;
-   currentItem = 0;
-} //-- reset
-
-/**
- * Move the iterator to right after the last element
-**/
-void txListIterator::resetToEnd() {
-   atEndOfList = MB_TRUE;
-   currentItem = 0;
-} //-- moveToEnd

mozilla/extensions/transformiix/source/base/List.h

@@ -1,217 +0,0 @@
-/*
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- * 
- * Contributor(s): 
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- * Jonas Sicking, sicking@bigfoot.com
- *    -- Cleanup/bugfix/features in Iterator
- *       Added tx prefix to classnames
- *
- */
-
-#ifndef TRANSFRMX_LIST_H
-#define TRANSFRMX_LIST_H
-
-#include "baseutils.h"
-#include "TxObject.h"
-#include "txError.h"
-
-class txListIterator;
-
-/**
- * Represents an ordered list of Object pointers. Modeled after a Java 2 List.
-**/
-class txList : public TxObject {
-
-friend class txListIterator;
-
-public:
-
-    /**
-    * Creates an empty txList
-    **/
-    txList();
-
-    /**
-     * txList destructor, object references will not be deleted.
-    **/
-    virtual ~txList();
-
-    /**
-     * Returns the object located at the given index. This may
-     * be slow or fast depending on the implementation.
-     * @return the object located at the given index
-    **/
-    void* get(int index);
-
-    /**
-     * Returns the number of items in this txList
-    **/
-    PRInt32 getLength();
-
-    /**
-     * Adds the given Object to the specified position in the list
-    **/
-    nsresult insert(int index, void* objPtr);
-
-    /**
-     * Adds the given Object to the list
-    **/
-    nsresult add(void* objPtr);
-
-    /**
-     * Removes the given Object pointer from the list
-    **/
-    void* remove(void* objPtr);
-    
-    /*
-     * Removes all the objects from the list
-     */
-    void clear();
-
-
-protected:
-
-    struct ListItem {
-        ListItem* nextItem;
-        ListItem* prevItem;
-        void* objPtr;
-    };
-
-    ListItem* getFirstItem();
-    ListItem* getLastItem();
-
-    /**
-     * Removes the given ListItem pointer from the list
-    **/
-    ListItem* remove(ListItem* sItem);
-
-private:
-      txList(const txList& aOther); // not implemented
-
-      ListItem* firstItem;
-      ListItem* lastItem;
-      PRInt32 itemCount;
-
-      nsresult insertAfter(void* objPtr, ListItem* sItem);
-      nsresult insertBefore(void* objPtr, ListItem* sItem);
-};
-
-
-
-/**
- * An Iterator for the txList Class
-**/
-class txListIterator {
-
-public:
-    /**
-     * Creates a new txListIterator for the given txList
-     * @param list, the txList to create an Iterator for
-    **/
-    txListIterator(txList* list);
-
-    /**
-     * Destructor, destroys a given instance of a txListIterator
-    **/
-    ~txListIterator();
-
-    /**
-     * Adds the Object pointer to the txList pointed to by this txListIterator.
-     * The Object pointer is inserted as the next item in the txList
-     * based on the current position within the txList
-     * @param objPtr the Object pointer to add to the list
-    **/
-    nsresult addAfter(void* objPtr);
-
-    /**
-     * Adds the Object pointer to the txList pointed to by this txListIterator.
-     * The Object pointer is inserted as the previous item in the txList
-     * based on the current position within the txList
-     * @param objPtr the Object pointer to add to the list
-    **/
-    nsresult addBefore(void* objPtr);
-
-    /**
-     * Returns true if a sucessful call to the next() method can be made
-     * @return MB_TRUE if a sucessful call to the next() method can be made,
-     * otherwise MB_FALSE
-    **/
-    MBool  hasNext();
-
-    /**
-     * Returns true if a sucessful call to the previous() method can be made
-     * @return MB_TRUE if a sucessful call to the previous() method can be made,
-     * otherwise MB_FALSE
-    **/
-    MBool  hasPrevious();
-
-    /**
-     * Returns the next Object pointer from the list
-    **/
-    void* next();
-
-    /**
-     * Returns the previous Object pointer from the list
-    **/
-    void* previous();
-    
-    /**
-     * Returns the current Object
-    **/
-    void* current();
-    
-    /**
-     * Moves the specified number of steps
-    **/
-    void* advance(int i);
-
-    /**
-     * Removes the Object last returned by the next() or previous() methods;
-     * @return the removed Object pointer
-    **/
-    void* remove();
-
-    /**
-     * Resets the current location within the txList to the beginning of the txList
-    **/
-    void reset();
-
-    /**
-     * Resets the current location within the txList to the end of the txList
-    **/
-    void resetToEnd();
-
-private:
-
-   //-- points to the current list item
-   txList::ListItem* currentItem;
-
-   //-- points to the list to iterator over
-   txList* list;
-
-   //-- we've moved off the end of the list
-   MBool atEndOfList;
-};
-
-typedef txList List;
-
-#endif

mozilla/extensions/transformiix/source/base/Makefile.in

@@ -1,62 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla 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/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is Transformiix XSLT Processor.
-# 
-# The Initial Developer of the Original Code is Axel Hecht.
-# Portions created by Axel Hecht are  Copyright (C) Axel Hecht.
-# All Rights Reserved.
-# 
-# Contributor(s):
-#	Axel Hecht <axel@pike.org>
-# 
-
-DEPTH           = ../../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-REQUIRES	= string \
-		  xpcom \
-		  $(NULL)
-ifndef TX_EXE
-MODULE = transformiix
-REQUIRES	+= unicharutil \
-		  dom \
-		  content \
-		  widget \
-		  necko \
-		  caps \
-		  xpconnect \
-		  js \
-		  $(NULL)
-endif
-
-CPPSRCS	= Double.cpp \
-	List.cpp \
-	SimpleErrorObserver.cpp \
-	txAtoms.cpp \
-	txExpandedNameMap.cpp \
-	txNamespaceMap.cpp \
-	txURIUtils.cpp
-
-ifdef TX_EXE
-	CPPSRCS	+= txStringUtils.cpp
-endif
-
-include $(topsrcdir)/config/rules.mk
-
-INCLUDES += -I$(srcdir)/../xpath -I$(srcdir)/../xslt -I$(srcdir)/../xml   \
-  -I$(srcdir)/../xml/dom -I$(srcdir)
-
-libs:: $(OBJS)

mozilla/extensions/transformiix/source/base/SimpleErrorObserver.cpp

@@ -1,67 +0,0 @@
-/*
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- * 
- * Contributor(s): 
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- */
-
-#include "ErrorObserver.h"
-#include "nsString.h"
-
-/**
- * Creates a new SimpleErrorObserver.
- * All errors will be printed to the console (cout).
-**/
-SimpleErrorObserver::SimpleErrorObserver() {
-#ifdef TX_EXE
-    errStream = &cout;
-#endif
-    hideWarnings = MB_FALSE;
-} //-- SimpleErrorObserver
-
-/**
- * Creates a new SimpleErrorObserver.
- * All errors will be printed to the given ostream.
-**/
-SimpleErrorObserver::SimpleErrorObserver(ostream& errStream) {
-    this->errStream = &errStream;
-    hideWarnings = MB_FALSE;
-} //-- SimpleErrorObserver
-
-/**
- *  Notifies this Error observer of a new error using the given error level
-**/
-void SimpleErrorObserver::receiveError(const nsAString& errorMessage,
-                                       nsresult aRes)
-{
-#ifdef TX_EXE
-    if (NS_FAILED(aRes)) {
-        *errStream << "error: ";
-    }
-
-    *errStream << NS_LossyConvertUCS2toASCII(errorMessage).get() << endl;
-    errStream->flush();
-#endif
-}
-
-void SimpleErrorObserver::supressWarnings(MBool supress) {
-    this->hideWarnings = supress;
-} //-- supressWarnings

mozilla/extensions/transformiix/source/base/TxLog.h

@@ -1,73 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * 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 or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Axel Hecht <axel@pike.org>
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef TxLog_h__
-#define TxLog_h__
-
-#include "prlog.h"
-#include "prmem.h"
-#endif
-
-#ifdef PR_LOGGING
-class txLog
-{
-public:
-    static PRLogModuleInfo *xpath;
-    static PRLogModuleInfo *xslt;
-};
-
-#define TX_LG_IMPL \
-    PRLogModuleInfo * txLog::xpath = 0; \
-    PRLogModuleInfo * txLog::xslt = 0
-
-#define TX_LG_CREATE \
-    txLog::xpath = PR_NewLogModule("xpath"); \
-    txLog::xslt  = PR_NewLogModule("xslt")
-
-#define TX_LG_DELETE \
-    PR_FREEIF(txLog::xpath); \
-    PR_FREEIF(txLog::xslt)
-
-#else
-
-#define TX_LG_IMPL
-#define TX_LG_CREATE
-#define TX_LG_DELETE
-
-#endif

mozilla/extensions/transformiix/source/base/TxObject.h

@@ -1,61 +0,0 @@
-/*
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is Keith Visco.
- * Portions created by Keith Visco (C) 1999, 2000 Keith Visco.
- * All Rights Reserved..
- *
- * Contributor(s): 
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- */
-
-
-#ifndef TRANSFRMX_TXOBJECT_H
-#define TRANSFRMX_TXOBJECT_H
-
-#include "baseutils.h"
-
-class TxObject {
-
- public:
-
-    /**
-     * Creates a new TxObject
-    **/
-    TxObject() {};
-
-    /**
-     * Deletes this TxObject
-    **/
-    virtual ~TxObject() {};
-
-    /**
-     * Returns the Hashcode for this TxObject
-    **/
-    virtual PRUint32 hashCode() {
-        return NS_PTR_TO_INT32(this);
-    } //-- hashCode
-
-    /**
-     * Returns true if the given Object is equal to this object.
-     * By default the comparison operator == is used, but this may
-     * be overridden
-    **/
-    virtual MBool equals(TxObject* obj) {
-        return (MBool)(obj == this);
-    } //-- equals
-};
-
-#endif

mozilla/extensions/transformiix/source/base/baseutils.h

@@ -1,44 +0,0 @@
-/*
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- * 
- * Contributor(s): 
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- * Tom Kneeland, tomk@mitre.org
- *    -- added PRUint32 to provide a common unsigned integer
- *
- */
-
-// Basic Definitions used throughout many of these classes
-
-
-#ifndef TRANSFRMX_BASEUTILS_H
-#define TRANSFRMX_BASEUTILS_H
-
-#include "prtypes.h"
-#include "nscore.h"
-#include "nsDebug.h"
-typedef PRBool MBool;
-
-#define MB_TRUE  PR_TRUE
-#define MB_FALSE PR_FALSE
-
-#endif
-

mozilla/extensions/transformiix/source/base/primitives.h

@@ -1,88 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- * Larry Fitzpatrick, OpenText, lef@opentext.com
- *    --
- *
- * Eric Du, duxy@leyou.com.cn
- *   -- added fix for FreeBSD
- *
- * NaN/Infinity code copied from the JS-library with permission from
- * Netscape Communications Corporation: http://www.mozilla.org/js
- * http://lxr.mozilla.org/seamonkey/source/js/src/jsnum.h
- *
- */
-
-
-#ifndef MITRE_PRIMITIVES_H
-#define MITRE_PRIMITIVES_H
-
-#include "baseutils.h"
-class nsAString;
-
-/*
- * Utility class for doubles
- */
-class Double {
-public:
-
-    /*
-     * Usefull constants
-     */
-
-    static const double NaN;
-    static const double POSITIVE_INFINITY;
-    static const double NEGATIVE_INFINITY;
-
-    /*
-     * Determines whether the given double represents positive or negative
-     * inifinity
-     */
-    static MBool isInfinite(double aDbl);
-
-    /*
-     * Determines whether the given double is NaN
-     */
-    static MBool isNaN(double aDbl);
-
-    /*
-     * Determines whether the given double is negative
-     */
-    static MBool isNeg(double aDbl);
-
-    /*
-     * Converts the value of the given double to a String, and appends
-     * the result to the destination String.
-     */
-    static void toString(double aValue, nsAString& aDest);
-
-    /*
-     * Converts the given String to a double, if the String value does not
-     * represent a double, NaN will be returned
-     */
-    static double toDouble(const nsAString& aStr);
-};
-
-#endif

mozilla/extensions/transformiix/source/base/txAtoms.cpp

@@ -1,141 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-
-#include "txAtoms.h"
-
-#define TX_ATOM(_name, _value) nsIAtom* txXMLAtoms::_name = 0
-XML_ATOMS;
-#undef TX_ATOM
-#define TX_ATOM(_name, _value) nsIAtom* txXPathAtoms::_name = 0
-#include "txXPathAtomList.h"
-#undef TX_ATOM
-#define TX_ATOM(_name, _value) nsIAtom* txXSLTAtoms::_name = 0
-#include "txXSLTAtomList.h"
-#undef TX_ATOM
-#define TX_ATOM(_name, _value) nsIAtom* txHTMLAtoms::_name = 0
-#include "txHTMLAtomList.h"
-#undef TX_ATOM
-
-static PRUint32 gXMLRefCnt = 0;
-static PRUint32 gXPathRefCnt = 0;
-static PRUint32 gXSLTRefCnt = 0;
-static PRUint32 gHTMLRefCnt = 0;
-
-#define TX_ATOM(_name, _value)      \
-    _name = NS_NewAtom(_value);     \
-    NS_ENSURE_TRUE(_name, MB_FALSE)
-
-MBool txXMLAtoms::init()
-{
-    if (0 == gXMLRefCnt++) {
-        // create atoms
-XML_ATOMS;
-    }
-    return MB_TRUE;
-}
-
-MBool txXPathAtoms::init()
-{
-    if (0 == gXPathRefCnt++) {
-        // create atoms
-#include "txXPathAtomList.h"
-    }
-    return MB_TRUE;
-}
-
-MBool txXSLTAtoms::init()
-{
-    if (0 == gXSLTRefCnt++) {
-        // create atoms
-#include "txXSLTAtomList.h"
-    }
-    return MB_TRUE;
-}
-
-MBool txHTMLAtoms::init()
-{
-    if (0 == gHTMLRefCnt++) {
-        // create atoms
-#include "txHTMLAtomList.h"
-    }
-    return MB_TRUE;
-}
-
-#undef TX_ATOM
-
-#define TX_ATOM(_name, _value) \
-NS_IF_RELEASE(_name)
-
-void txXMLAtoms::shutdown()
-{
-    NS_ASSERTION(gXMLRefCnt != 0, "bad release atoms");
-    if (--gXMLRefCnt == 0) {
-        // release atoms
-XML_ATOMS;
-    }
-}
-
-void txXPathAtoms::shutdown()
-{
-    NS_ASSERTION(gXPathRefCnt != 0, "bad release atoms");
-    if (--gXPathRefCnt == 0) {
-        // release atoms
-#include "txXPathAtomList.h"
-    }
-}
-
-void txXSLTAtoms::shutdown()
-{
-    NS_ASSERTION(gXSLTRefCnt != 0, "bad release atoms");
-    if (--gXSLTRefCnt == 0) {
-        // release atoms
-#include "txXSLTAtomList.h"
-    }
-}
-
-void txHTMLAtoms::shutdown()
-{
-    NS_ASSERTION(gHTMLRefCnt != 0, "bad release atoms");
-    if (--gHTMLRefCnt == 0) {
-        // release atoms
-#include "txHTMLAtomList.h"
-    }
-}
-
-#undef TX_ATOM

mozilla/extensions/transformiix/source/base/txAtoms.h

@@ -1,100 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Peter Van der Beken <peterv@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef TRANSFRMX_ATOMS_H
-#define TRANSFRMX_ATOMS_H
-
-#include "nsIAtom.h"
-#include "baseutils.h"
-
-/*
- * Declare all atoms
- *
- * The atom names and values are stored in tx*AtomList.h and
- * are brought to you by the magic of C preprocessing.
- * Add new atoms to tx*AtomList.h and all support logic will
- * be auto-generated.
- */
-
-#define XML_ATOMS        \
-TX_ATOM(_empty, "");     \
-TX_ATOM(base, "base");   \
-TX_ATOM(_default, "default");   \
-TX_ATOM(lang, "lang");   \
-TX_ATOM(preserve, "preserve");   \
-TX_ATOM(space, "space"); \
-TX_ATOM(xml, "xml");     \
-TX_ATOM(xmlns, "xmlns")
-
-#define TX_ATOM(_name, _value) static nsIAtom* _name
-
-class txXMLAtoms
-{
-public:
-    static MBool init();
-    static void shutdown();
-XML_ATOMS;
-};
-
-class txXPathAtoms
-{
-public:
-    static MBool init();
-    static void shutdown();
-#include "txXPathAtomList.h"
-};
-
-class txXSLTAtoms
-{
-public:
-    static MBool init();
-    static void shutdown();
-#include "txXSLTAtomList.h"
-};
-
-class txHTMLAtoms
-{
-public:
-    static MBool init();
-    static void shutdown();
-#include "txHTMLAtomList.h"
-};
-
-#undef TX_ATOM
-
-#endif

mozilla/extensions/transformiix/source/base/txError.h

@@ -1,84 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT Processor.
- *
- * The Initial Developer of the Original Code is
- * Axel Hecht.
- * Portions created by the Initial Developer are Copyright (C) 2001
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Axel Hecht <axel@pike.org>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef __TX_ERROR
-#define __TX_ERROR
-
-/*
- * Error value mockup for standalone.
- * See nsError.h for details.
- */
-
-#include "nsError.h"
-
-#define NS_ERROR_XPATH_EVAL_FAILED         NS_ERROR_FAILURE
-#define NS_ERROR_XPATH_PARSE_FAILED        NS_ERROR_FAILURE
-#define NS_ERROR_XPATH_INVALID_ARG         NS_ERROR_INVALID_ARG
-#define NS_ERROR_XSLT_INVALID_URL          NS_ERROR_INVALID_ARG
-
-#define NS_ERROR_XSLT_PARSE_FAILURE                    \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 1)
-
-#define NS_ERROR_XPATH_PARSE_FAILURE                   \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 2)
-
-#define NS_ERROR_XSLT_GET_NEW_HANDLER                  \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 3)
-
-#define NS_ERROR_XSLT_ALREADY_SET                      \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 4)
-
-#define NS_ERROR_XSLT_EXECUTION_FAILURE                \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 5)
-
-#define NS_ERROR_XPATH_UNKNOWN_FUNCTION                \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 6)
-
-#define NS_ERROR_XSLT_BAD_RECURSION                    \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 7)
-
-#define NS_ERROR_XSLT_BAD_VALUE                        \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 8)
-
-#define NS_ERROR_XSLT_NODESET_EXPECTED                 \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 9)
-
-#define NS_ERROR_XSLT_ABORTED                          \
-    NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XSLT, 10)
-
-#endif // __TX_ERROR

mozilla/extensions/transformiix/source/base/txExpandedNameMap.cpp

@@ -1,201 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is
- * Jonas Sicking.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * Jonas Sicking. All Rights Reserved.
- *
- * Contributor(s):
- *   Jonas Sicking <sicking@bigfoot.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "txExpandedNameMap.h"
-#include "string.h"
-
-const int kTxExpandedNameMapAllocSize = 16;
-
-txExpandedNameMap::txExpandedNameMap(MBool aOwnsValues) :
-    mItems(0), mItemCount(0), mBufferCount(0), mOwnsValues(aOwnsValues)
-{
-}
-
-txExpandedNameMap::~txExpandedNameMap()
-{
-    clear();
-}
-
-/**
- * Adds an item, if an item with this key already exists an error is
- * returned
- * @param  aKey   key for item to add
- * @param  aValue value of item to add
- * @return errorcode
- */
-nsresult txExpandedNameMap::add(const txExpandedName& aKey, TxObject* aValue)
-{
-    int i;
-    // Check if there already is an item with this key
-    for (i = 0; i < mItemCount; ++i) {
-        if (mItems[i].mLocalName == aKey.mLocalName &&
-            mItems[i].mNamespaceID == aKey.mNamespaceID) {
-            return NS_ERROR_XSLT_ALREADY_SET;
-        }
-    }
-    
-    // Allocate a new array if needed
-    if (mBufferCount == mItemCount) {
-        MapItem* newItems = new MapItem[mItemCount +
-                                        kTxExpandedNameMapAllocSize];
-        if (!newItems) {
-            return NS_ERROR_OUT_OF_MEMORY;
-        }
-
-        mBufferCount += kTxExpandedNameMapAllocSize;
-        memcpy(newItems, mItems, mItemCount * sizeof(MapItem));
-        delete [] mItems;
-        mItems = newItems;
-    }
-    
-    mItems[mItemCount].mNamespaceID = aKey.mNamespaceID;
-    mItems[mItemCount].mLocalName = aKey.mLocalName;
-    NS_IF_ADDREF(mItems[mItemCount].mLocalName);
-    mItems[mItemCount].mValue = aValue;
-    ++mItemCount;
-    
-    return NS_OK;
-}
-
-/**
- * Sets an item, if an item with this key already exists it is overwritten
- * with the new value
- * @param  aKey   key for item to set
- * @param  aValue value of item to set
- * @return errorcode
- */
-nsresult txExpandedNameMap::set(const txExpandedName& aKey, TxObject* aValue)
-{
-    int i;
-    // Check if there already is an item with this key
-    for (i = 0; i < mItemCount; ++i) {
-        if (mItems[i].mLocalName == aKey.mLocalName &&
-            mItems[i].mNamespaceID == aKey.mNamespaceID) {
-            if (mOwnsValues) {
-                delete mItems[i].mValue;
-            }
-            mItems[i].mValue = aValue;
-            return NS_OK;
-        }
-    }
-    
-    // Allocate a new array if needed
-    if (mBufferCount == mItemCount) {
-        MapItem* newItems = new MapItem[mItemCount +
-                                        kTxExpandedNameMapAllocSize];
-        if (!newItems) {
-            return NS_ERROR_OUT_OF_MEMORY;
-        }
-
-        mBufferCount += kTxExpandedNameMapAllocSize;
-        memcpy(newItems, mItems, mItemCount * sizeof(MapItem));
-        delete [] mItems;
-        mItems = newItems;
-    }
-    
-    mItems[mItemCount].mNamespaceID = aKey.mNamespaceID;
-    mItems[mItemCount].mLocalName = aKey.mLocalName;
-    NS_IF_ADDREF(mItems[mItemCount].mLocalName);
-    mItems[mItemCount].mValue = aValue;
-    ++mItemCount;
-    
-    return NS_OK;
-}
-
-/**
- * Gets an item
- * @param  aKey  key for item to get
- * @return item with specified key, or null if no such item exists
- */
-TxObject* txExpandedNameMap::get(const txExpandedName& aKey) const
-{
-    int i;
-    for (i = 0; i < mItemCount; ++i) {
-        if (mItems[i].mLocalName == aKey.mLocalName &&
-            mItems[i].mNamespaceID == aKey.mNamespaceID) {
-            return mItems[i].mValue;
-        }
-    }
-    return 0;
-}
-
-/**
- * Removes an item, deleting it if the map owns the values
- * @param  aKey  key for item to remove
- * @return item with specified key, or null if it has been deleted
- *         or no such item exists
- */
-TxObject* txExpandedNameMap::remove(const txExpandedName& aKey)
-{
-    TxObject* value = 0;
-    int i;
-    for (i = 0; i < mItemCount; ++i) {
-        if (mItems[i].mLocalName == aKey.mLocalName &&
-            mItems[i].mNamespaceID == aKey.mNamespaceID) {
-            NS_IF_RELEASE(mItems[i].mLocalName);
-            if (mOwnsValues) {
-                delete mItems[i].mValue;
-            }
-            else {
-                value = mItems[i].mValue;
-            }
-            --mItemCount;
-            if (i != mItemCount) {
-                memcpy(&mItems[i], &mItems[mItemCount], sizeof(MapItem));
-            }
-        }
-    }
-    return value;
-}
-
-/**
- * Clears the items
- */
-void txExpandedNameMap::clear()
-{
-    int i;
-    for (i = 0; i < mItemCount; ++i) {
-        NS_IF_RELEASE(mItems[i].mLocalName);
-        if (mOwnsValues) {
-            delete mItems[i].mValue;
-        }
-    }
-    delete [] mItems;
-    mItemCount = 0;
-    mBufferCount = 0;
-}

mozilla/extensions/transformiix/source/base/txExpandedNameMap.h

@@ -1,137 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is
- * Jonas Sicking.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * Jonas Sicking. All Rights Reserved.
- *
- * Contributor(s):
- *   Jonas Sicking <sicking@bigfoot.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef TRANSFRMX_EXPANDEDNAMEMAP_H
-#define TRANSFRMX_EXPANDEDNAMEMAP_H
-
-#include "txError.h"
-#include "XMLUtils.h"
-
-class TxObject;
-
-class txExpandedNameMap {
-public:
-    txExpandedNameMap(MBool aOwnsValues);
-    
-    ~txExpandedNameMap();
-    
-    /**
-     * Adds an item, if an item with this key already exists an error is
-     * returned
-     * @param  aKey   key for item to add
-     * @param  aValue value of item to add
-     * @return errorcode
-     */
-    nsresult add(const txExpandedName& aKey, TxObject* aValue);
-
-    /**
-     * Sets an item, if an item with this key already exists it is overwritten
-     * with the new value
-     * @param  aKey   key for item to set
-     * @param  aValue value of item to set
-     * @return errorcode
-     */
-    nsresult set(const txExpandedName& aKey, TxObject* aValue);
-
-    /**
-     * Gets an item
-     * @param  aKey  key for item to get
-     * @return item with specified key, or null if no such item exists
-     */
-    TxObject* get(const txExpandedName& aKey) const;
-
-    /**
-     * Removes an item, deleting it if the map owns the values
-     * @param  aKey  key for item to remove
-     * @return item with specified key, or null if it has been deleted
-     *         or no such item exists
-     */
-    TxObject* remove(const txExpandedName& aKey);
-
-    /**
-     * Clears the items
-     */
-    void clear();
-
-    class iterator {
-    public:
-        iterator(txExpandedNameMap& aMap) : mMap(aMap),
-                                            mCurrentPos(-1)
-        {
-        }
-
-        MBool next()
-        {
-            return ++mCurrentPos < mMap.mItemCount;
-        }
-
-        const txExpandedName key()
-        {
-            NS_ASSERTION(mCurrentPos >= 0 && mCurrentPos < mMap.mItemCount,
-                         "invalid position in txExpandedNameMap::iterator");
-            return txExpandedName(mMap.mItems[mCurrentPos].mNamespaceID,
-                                  mMap.mItems[mCurrentPos].mLocalName);
-        }
-
-        TxObject* value()
-        {
-            NS_ASSERTION(mCurrentPos >= 0 && mCurrentPos < mMap.mItemCount,
-                         "invalid position in txExpandedNameMap::iterator");
-            return mMap.mItems[mCurrentPos].mValue;
-        }
-
-    private:
-        txExpandedNameMap& mMap;
-        int mCurrentPos;
-    };
-    
-    friend class iterator;
-
-private:
-    struct MapItem {
-        PRInt32 mNamespaceID;
-        nsIAtom* mLocalName;
-        TxObject* mValue;
-    };
-    
-    MapItem* mItems;
-    int mItemCount, mBufferCount;
-    MBool mOwnsValues;
-};
-
-#endif //TRANSFRMX_EXPANDEDNAMEMAP_H

mozilla/extensions/transformiix/source/base/txNamespaceMap.cpp

@@ -1,131 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is
- * Jonas Sicking.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * Jonas Sicking. All Rights Reserved.
- *
- * Contributor(s):
- *   Jonas Sicking <jonas@sicking.cc>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "txNamespaceMap.h"
-#include "dom.h"
-#include "txAtoms.h"
-
-txNamespaceMap::txNamespaceMap()
-{
-}
-
-txNamespaceMap::txNamespaceMap(const txNamespaceMap& aOther)
-    : mPrefixes(aOther.mPrefixes)
-{
-    mNamespaces = aOther.mNamespaces; //bah! I want a copy-constructor!
-}
-
-nsresult
-txNamespaceMap::addNamespace(nsIAtom* aPrefix, const nsAString& aNamespaceURI)
-{
-    nsIAtom* prefix = aPrefix == txXMLAtoms::_empty ? 0 : aPrefix;
-
-    PRInt32 nsId;
-    if (!prefix && aNamespaceURI.IsEmpty()) {
-        nsId = kNameSpaceID_None;
-    }
-    else {
-#ifdef TX_EXE
-        nsId = txNamespaceManager::getNamespaceID(aNamespaceURI);
-#else
-        NS_ASSERTION(gTxNameSpaceManager, "No namespace manager");
-        gTxNameSpaceManager->RegisterNameSpace(aNamespaceURI, nsId);
-#endif
-    }
-
-    // Check if the mapping already exists
-    PRInt32 index = mPrefixes.IndexOf(prefix);
-    if (index >= 0) {
-        mNamespaces.ReplaceElementAt(NS_INT32_TO_PTR(nsId), index);
-
-        return NS_OK;
-    }
-
-    // New mapping
-    if (!mPrefixes.AppendObject(prefix)) {
-        return NS_ERROR_OUT_OF_MEMORY;
-    }
-    
-    if (!mNamespaces.AppendElement(NS_INT32_TO_PTR(nsId))) {
-        mPrefixes.RemoveObjectAt(mPrefixes.Count() - 1);
-
-        return NS_ERROR_OUT_OF_MEMORY;
-    }
-
-    return NS_OK;
-}
-
-PRInt32
-txNamespaceMap::lookupNamespace(nsIAtom* aPrefix)
-{
-    if (aPrefix == txXMLAtoms::xml) {
-        return kNameSpaceID_XML;
-    }
-
-    nsIAtom* prefix = aPrefix == txXMLAtoms::_empty ? 0 : aPrefix;
-
-    PRInt32 index = mPrefixes.IndexOf(prefix);
-    if (index >= 0) {
-        return NS_PTR_TO_INT32(mNamespaces.SafeElementAt(index));
-    }
-
-    if (!prefix) {
-        return kNameSpaceID_None;
-    }
-
-    return kNameSpaceID_Unknown;
-}
-
-PRInt32
-txNamespaceMap::lookupNamespace(const nsAString& aPrefix)
-{
-    nsCOMPtr<nsIAtom> prefix = do_GetAtom(aPrefix);
-
-    return lookupNamespace(prefix);
-}
-
-PRInt32
-txNamespaceMap::lookupNamespaceWithDefault(const nsAString& aPrefix)
-{
-    nsCOMPtr<nsIAtom> prefix = do_GetAtom(aPrefix);
-    if (prefix != txXSLTAtoms::_poundDefault) {
-        return lookupNamespace(prefix);
-    }
-
-    return lookupNamespace(nsnull);
-}

mozilla/extensions/transformiix/source/base/txNamespaceMap.h

@@ -1,78 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is
- * Jonas Sicking.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * Jonas Sicking. All Rights Reserved.
- *
- * Contributor(s):
- *   Jonas Sicking <sicking@bigfoot.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef TRANSFRMX_TXNAMESPACEMAP_H
-#define TRANSFRMX_TXNAMESPACEMAP_H
-
-#include "txError.h"
-#include "baseutils.h"
-#include "nsIAtom.h"
-#include "nsCOMArray.h"
-
-class txNamespaceMap
-{
-public:
-    txNamespaceMap();
-    txNamespaceMap(const txNamespaceMap& aOther);
-
-    nsrefcnt AddRef()
-    {
-        return ++mRefCnt;
-    }
-    nsrefcnt Release()
-    {
-        if (--mRefCnt == 0) {
-            mRefCnt = 1; //stabilize
-            delete this;
-            return 0;
-        }
-        return mRefCnt;
-    }
-
-    nsresult addNamespace(nsIAtom* aPrefix, const nsAString& aNamespaceURI);
-    PRInt32 lookupNamespace(nsIAtom* aPrefix);
-    PRInt32 lookupNamespace(const nsAString& aPrefix);
-    PRInt32 lookupNamespaceWithDefault(const nsAString& aPrefix);
-
-private:
-    nsAutoRefCnt mRefCnt;
-    nsCOMArray<nsIAtom> mPrefixes;
-    nsVoidArray mNamespaces;
-};
-
-#endif //TRANSFRMX_TXNAMESPACEMAP_H

mozilla/extensions/transformiix/source/base/txStack.h

@@ -1,154 +0,0 @@
-//* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Peter Van der Beken <peterv@netscape.com> (original author)
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef txStack_h___
-#define txStack_h___
-
-#include "nsVoidArray.h"
-
-class txStack : private nsVoidArray
-{
-public:
-    /**
-     * Returns the specified object from the top of this stack,
-     * without removing it from the stack.
-     *
-     * @return a pointer to the object that is the top of this stack.
-     */
-    void* peek()
-    {
-        PRInt32 count = Count() - 1;
-        NS_ENSURE_TRUE(count >= 0, nsnull);
-
-        return ElementAt(count);
-    }
-
-    /**
-     * Adds the specified object to the top of this stack.
-     *
-     * @param obj a pointer to the object that is to be added to the
-     * top of this stack.
-     */
-    nsresult push(void* aObject)
-    {
-        return AppendElement(aObject);
-    }
-
-    /**
-     * Removes and returns the specified object from the top of this
-     * stack.
-     *
-     * @return a pointer to the object that was the top of this stack.
-     */
-    void* pop()
-    {
-        PRInt32 count = Count() - 1;
-        NS_ENSURE_TRUE(count >= 0, nsnull);
-
-        void* object = ElementAt(count);
-        RemoveElementAt(count);
-        return object;
-    }
-
-    /**
-     * Returns true if there are no objects in the stack.
-     *
-     * @return true if there are no objects in the stack.
-     */
-    PRBool isEmpty()
-    {
-        return (Count() <= 0);
-    }
-
-    /**
-     * Returns the number of elements in the Stack.
-     *
-     * @return the number of elements in the Stack.
-     */
-    PRInt32 size()
-    {
-        return Count();
-    }
-
-private:
-    friend class txStackIterator;
-};
-
-class txStackIterator
-{
-public:
-    /**
-     * Creates an iterator for the given stack.
-     *
-     * @param aStack the stack to create an iterator for.
-     */
-    txStackIterator(txStack* aStack) : mStack(aStack),
-                                       mPosition(0)
-    {
-    }
-
-    /**
-     * Returns true if there is more objects on the stack.
-     *
-     * @return .
-     */
-    PRBool hasNext()
-    {
-        return (mPosition < mStack->Count());
-    }
-
-    /**
-     * Returns the next object pointer from the stack.
-     *
-     * @return .
-     */
-    void* next()
-    {
-        if (mPosition == mStack->Count()) {
-            return nsnull;
-        }
-        return mStack->ElementAt(mPosition++);
-    }
-
-private:
-    txStack* mStack;
-    PRInt32 mPosition;
-};
-
-#endif /* txStack_h___ */

mozilla/extensions/transformiix/source/base/txStringUtils.cpp

@@ -1,153 +0,0 @@
-/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Axel Hecht <axel@pike.org>
- *   Peter Van der Beken <peterv@netscape.com>
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "txStringUtils.h"
-
-int
-txCaseInsensitiveStringComparator::operator()(const char_type* lhs,
-                                              const char_type* rhs,
-                                              PRUint32 aLength ) const
-{
-  PRUnichar thisChar, otherChar;
-  PRUint32 compLoop = 0;
-  while (compLoop < aLength) {
-    thisChar = lhs[compLoop];
-    if ((thisChar >= 'A') && (thisChar <= 'Z')) {
-      thisChar += 32;
-    }
-    otherChar = rhs[compLoop];
-    if ((otherChar >= 'A') && (otherChar <= 'Z')) {
-      otherChar += 32;
-    }
-    if (thisChar != otherChar) {
-      return thisChar - otherChar;
-    }
-    ++compLoop;
-  }
-  return 0;
-
-}
-
-int
-txCaseInsensitiveStringComparator::operator()(char_type lhs,
-                                              char_type rhs) const
-{
-  if (lhs >= 'A' && lhs <= 'Z') {
-    lhs += 32;
-  }
-  if (rhs >= 'A' && rhs <= 'Z') {
-    rhs += 32;
-  }
-  return lhs - rhs;
-} 
-
-/**
- * A character sink for case conversion.
- */
-class ConvertToLowerCase
-{
-public:
-  typedef PRUnichar value_type;
-
-  PRUint32 write( const PRUnichar* aSource, PRUint32 aSourceLength)
-  {
-    PRUnichar* cp = NS_CONST_CAST(PRUnichar*, aSource);
-    const PRUnichar* end = aSource + aSourceLength;
-    while (cp != end) {
-      PRUnichar ch = *cp;
-      if ((ch >= 'A') && (ch <= 'Z'))
-        *cp = ch + ('a' - 'A');
-      ++cp;
-    }
-    return aSourceLength;
-  }
-};
-
-void TX_ToLowerCase(nsAString& aString)
-{
-  nsAString::iterator fromBegin, fromEnd;
-  ConvertToLowerCase converter;
-  copy_string(aString.BeginWriting(fromBegin), aString.EndWriting(fromEnd),
-              converter);
-}
-
-/**
- * A character sink for copying with case conversion.
- */
-class CopyToLowerCase
-{
-public:
-  typedef PRUnichar value_type;
-
-  CopyToLowerCase(nsAString::iterator& aDestIter) : mIter(aDestIter)
-  {
-  }
-
-  PRUint32 write(const PRUnichar* aSource, PRUint32 aSourceLength)
-  {
-    PRUint32 len = PR_MIN(PRUint32(mIter.size_forward()), aSourceLength);
-    PRUnichar* cp = mIter.get();
-    const PRUnichar* end = aSource + len;
-    while (aSource != end) {
-      PRUnichar ch = *aSource;
-      if ((ch >= 'A') && (ch <= 'Z'))
-        *cp = ch + ('a' - 'A');
-      else
-        *cp = ch;
-      ++aSource;
-      ++cp;
-    }
-    mIter.advance(len);
-    return len;
-  }
-
-protected:
-  nsAString::iterator& mIter;
-};
-
-void TX_ToLowerCase(const nsAString& aSource, nsAString& aDest)
-{
-  nsAString::const_iterator fromBegin, fromEnd;
-  nsAString::iterator toBegin;
-  aDest.SetLength(aSource.Length());
-  CopyToLowerCase converter(aDest.BeginWriting(toBegin));
-  copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd),
-              converter);
-}

mozilla/extensions/transformiix/source/base/txStringUtils.h

@@ -1,81 +0,0 @@
-/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Axel Hecht <axel@pike.org>
- *   Peter Van der Beken <peterv@netscape.com>
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef txStringUtils_h__
-#define txStringUtils_h__
-
-#include "nsAString.h"
-#include "nsIAtom.h"
-
-#ifndef TX_EXE
-
-#include "nsUnicharUtils.h"
-typedef nsCaseInsensitiveStringComparator txCaseInsensitiveStringComparator;
-
-#define TX_ToLowerCase ToLowerCase
-
-#else
-
-// These only work for ASCII ranges!
-
-class txCaseInsensitiveStringComparator
-: public nsStringComparator
-{
-public:
-  virtual int operator()(const char_type*, const char_type*, PRUint32 aLength) const;
-  virtual int operator()(char_type, char_type) const;
-};
-
-void TX_ToLowerCase(nsAString& aString);
-void TX_ToLowerCase(const nsAString& aSource, nsAString& aDest);
-
-#endif
-
-/**
- * Check equality between a string and an atom.
- */
-static PRBool TX_StringEqualsAtom(const nsAString& aString, nsIAtom* aAtom)
-{
-  const PRUnichar* atom;
-  aAtom->GetUnicode(&atom);
-  return aString.Equals(atom);
-};
-
-#endif // txStringUtils_h__

mozilla/extensions/transformiix/source/base/txTokenizer.h

@@ -1,91 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Peter Van der Beken <peterv@netscape.com> (original author)
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef txTokenizer_h___
-#define txTokenizer_h___
-
-#include "nsDependentSubstring.h"
-#include "XMLUtils.h"
-
-class txTokenizer
-{
-public:
-    /**
-     * Creates a new txTokenizer using the given source string.
-     */
-    txTokenizer(const nsAFlatString& aSource)
-    {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
-
-        while (mIter != mEnd && XMLUtils::isWhitespace(*mIter)) {
-            ++mIter;
-        }
-    }
-
-    /**
-     * Checks if any more tokens are available.
-     */
-    PRBool hasMoreTokens()
-    {
-        return (mIter != mEnd);
-    }
-
-    /**
-     * Returns the next token.
-     */
-    const nsDependentSingleFragmentSubstring nextToken()
-    {
-        nsAFlatString::const_char_iterator begin = mIter;
-        while (mIter != mEnd && !XMLUtils::isWhitespace(*mIter)) {
-            ++mIter;
-        }
-        nsAFlatString::const_char_iterator end = mIter;
-        while (mIter != mEnd && XMLUtils::isWhitespace(*mIter)) {
-            ++mIter;
-        }
-        return Substring(begin, end);
-    }
-
-private:
-    nsAFlatString::const_char_iterator mIter, mEnd;
-};
-
-#endif /* txTokenizer_h___ */
-

mozilla/extensions/transformiix/source/base/txURIUtils.cpp

@@ -1,228 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla 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/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is TransforMiiX XSLT processor.
- *
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- *
- * Contributor(s):
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- * Larry Fitzpatrick, OpenText, lef@opentext.com
- *   -- 19990806
- *     -- moved initialization of constant shorts and chars from
- *        URIUtils.cpp to here
- *
- * Peter Van der Beken
- *
- */
-
-#include "txURIUtils.h"
-
-#ifndef TX_EXE
-#include "nsNetUtil.h"
-#include "nsIAttribute.h"
-#include "nsIScriptSecurityManager.h"
-#include "nsIDocument.h"
-#include "nsIDOMDocument.h"
-#include "nsIContent.h"
-#include "nsIPrincipal.h"
-#include "nsINodeInfo.h"
-#endif
-
-/**
- * URIUtils
- * A set of utilities for handling URIs
-**/
-
-#ifdef TX_EXE
-//- Constants -/
-
-const char   URIUtils::HREF_PATH_SEP  = '/';
-
-/**
- * Returns an InputStream for the file represented by the href
- * argument
- * @param href the href of the file to get the input stream for.
- * @return an InputStream to the desired resource
- * @exception java.io.FileNotFoundException when the file could not be
- * found
-**/
-istream* URIUtils::getInputStream(const nsAString& href, nsAString& errMsg)
-{
-    return new ifstream(NS_LossyConvertUCS2toASCII(href).get(), ios::in);
-} //-- getInputStream
-
-/**
-    * Returns the document base of the href argument
-    * @return the document base of the given href
-**/
-void URIUtils::getDocumentBase(const nsAFlatString& href, nsAString& dest)
-{
-    if (href.IsEmpty()) {
-        return;
-    }
-
-    nsAFlatString::const_char_iterator temp;
-    href.BeginReading(temp);
-    PRUint32 iter = href.Length();
-    while (iter > 0) {
-        if (temp[--iter] == HREF_PATH_SEP) {
-            dest.Append(Substring(href, 0, iter));
-            break;
-        }
-    }
-}
-#endif
-
-/**
- * Resolves the given href argument, using the given documentBase
- * if necessary.
- * The new resolved href will be appended to the given dest String
-**/
-void URIUtils::resolveHref(const nsAString& href, const nsAString& base,
-                           nsAString& dest) {
-    if (base.IsEmpty()) {
-        dest.Append(href);
-        return;
-    }
-    if (href.IsEmpty()) {
-        dest.Append(base);
-        return;
-    }
-
-#ifndef TX_EXE
-    nsCOMPtr<nsIURI> pURL;
-    nsAutoString resultHref;
-    nsresult result = NS_NewURI(getter_AddRefs(pURL), base);
-    if (NS_SUCCEEDED(result)) {
-        NS_MakeAbsoluteURI(resultHref, href, pURL);
-        dest.Append(resultHref);
-    }
-#else
-    nsAutoString documentBase;
-    getDocumentBase(PromiseFlatString(base), documentBase);
-
-    //-- join document base + href
-    if (!documentBase.IsEmpty()) {
-        dest.Append(documentBase);
-        if (documentBase.CharAt(documentBase.Length()-1) != HREF_PATH_SEP)
-            dest.Append(PRUnichar(HREF_PATH_SEP));
-    }
-    dest.Append(href);
-
-#endif
-} //-- resolveHref
-
-#ifndef TX_EXE
-
-nsIScriptSecurityManager *gTxSecurityManager = 0;
-
-// static
-PRBool URIUtils::CanCallerAccess(nsIDOMNode *aNode)
-{
-    if (!gTxSecurityManager) {
-        // No security manager available, let any calls go through...
-
-        return PR_TRUE;
-    }
-
-    nsCOMPtr<nsIPrincipal> subjectPrincipal;
-    gTxSecurityManager->GetSubjectPrincipal(getter_AddRefs(subjectPrincipal));
-
-    if (!subjectPrincipal) {
-        // we're running as system, grant access to the node.
-
-        return PR_TRUE;
-    }
-
-    // Make sure that this is a real node. We do this by first QI'ing to
-    // nsIContent (which is important performance wise) and if that QI
-    // fails we QI to nsIDocument. If both those QI's fail we won't let
-    // the caller access this unknown node.
-    nsCOMPtr<nsIPrincipal> principal;
-    nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
-    nsCOMPtr<nsIAttribute> attr;
-    nsCOMPtr<nsIDocument> doc;
-
-    if (!content) {
-        doc = do_QueryInterface(aNode);
-
-        if (!doc) {
-            attr = do_QueryInterface(aNode);
-            if (!attr) {
-                // aNode is not a nsIContent, a nsIAttribute or a nsIDocument,
-                // something weird is going on...
-
-                NS_ERROR("aNode is not a nsIContent, a nsIAttribute or a nsIDocument!");
-
-                return PR_FALSE;
-            }
-        }
-    }
-
-    if (!doc) {
-        nsCOMPtr<nsIDOMDocument> domDoc;
-        aNode->GetOwnerDocument(getter_AddRefs(domDoc));
-        if (!domDoc) {
-            nsCOMPtr<nsINodeInfo> ni;
-            if (content) {
-                content->GetNodeInfo(*getter_AddRefs(ni));
-            }
-            else {
-                attr->GetNodeInfo(*getter_AddRefs(ni));
-            }
-
-            if (!ni) {
-                // aNode is not part of a document, let any caller access it.
-
-                return PR_TRUE;
-            }
-
-            ni->GetDocumentPrincipal(getter_AddRefs(principal));
-
-            if (!principal) {
-              // we can't get to the principal so we'll give up and give the
-              // caller access
-
-              return PR_TRUE;
-            }
-        }
-        else {
-            doc = do_QueryInterface(domDoc);
-            NS_ASSERTION(doc, "QI to nsIDocument failed");
-        }
-    }
-
-    if (!principal) {
-        doc->GetPrincipal(getter_AddRefs(principal));
-    }
-
-    if (!principal) {
-        // We can't get hold of the principal for this node. This should happen
-        // very rarely, like for textnodes out of the tree and <option>s created
-        // using 'new Option'.
-
-        return PR_TRUE;
-    }
-
-    nsresult rv = gTxSecurityManager->CheckSameOriginPrincipal(subjectPrincipal,
-                                                               principal);
-
-    return NS_SUCCEEDED(rv);
-}
-
-#endif /* TX_EXE */

mozilla/extensions/transformiix/source/base/txURIUtils.h

@@ -1,96 +0,0 @@
-/*
- * The contents of this file are subject to the Mozilla 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/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is TransforMiiX XSLT processor.
- * 
- * The Initial Developer of the Original Code is The MITRE Corporation.
- * Portions created by MITRE are Copyright (C) 1999 The MITRE Corporation.
- *
- * Portions created by Keith Visco as a Non MITRE employee,
- * (C) 1999 Keith Visco. All Rights Reserved.
- * 
- * Contributor(s): 
- *
- * Keith Visco, kvisco@ziplink.net
- *    -- original author.
- *
- * Larry Fitzpatrick, OpenText, lef@opentext.com
- *   -- 19990806
- *     -- moved initialization of constant shorts and chars to 
- *        URIUtils.cpp
- *
- * Peter Van der Beken
- *   -- 20000326
- *     -- added Mozilla integration code
- *
- */
-
-#ifndef TRANSFRMX_URIUTILS_H
-#define TRANSFRMX_URIUTILS_H
-
-#include "baseutils.h"
-#ifdef TX_EXE
-#include <fstream.h>
-#include <iostream.h>
-#include "nsString.h"
-#else
-#include "nsIDOMNode.h"
-
-class nsIScriptSecurityManager;
-extern nsIScriptSecurityManager *gTxSecurityManager;
-
-#endif
-
-/**
- * A utility class for URI handling
- * Not yet finished, only handles file URI at this point
-**/
-
-class URIUtils {
-
-
-public:
-
-#ifdef TX_EXE
-    /**
-     * the path separator for an URI
-    **/
-    static const char HREF_PATH_SEP;
-
-    static istream* getInputStream
-        (const nsAString& href, nsAString& errMsg);
-
-    /**
-     * Returns the document base of the href argument
-     * The document base will be appended to the given dest String
-    **/
-    static void getDocumentBase(const nsAFlatString& href, nsAString& dest);
-
-#else /* TX_EXE */
-
-    /*
-     * Checks if a caller is allowed to access a given node
-     */
-    static PRBool CanCallerAccess(nsIDOMNode *aNode);
-
-#endif /* TX_EXE */
-
-    /**
-     * Resolves the given href argument, using the given documentBase
-     * if necessary.
-     * The new resolved href will be appended to the given dest String
-    **/
-    static void resolveHref(const nsAString& href, const nsAString& base,
-                            nsAString& dest);
-}; //-- URIUtils
-
-/* */
-#endif

mozilla/extensions/transformiix/source/examples/functions.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0"?>
-<?xml-stylesheet type="text/xsl" href="functions.xsl"?>
-<!-- this is a test document -->
-<document>
-   <!-- test comment -->
-   <x name="x">x</x>
-   <y name="y">y</y>
-   <z name="z">z</z>
-   <names xmlns:abc="foo">
-     <abc:test-name/>
-   </names>
-</document>

mozilla/extensions/transformiix/source/examples/identity-result.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0"?>
-<?xml-stylesheet type="text/xsl" href="identity.xsl"?>
-<document>
-   
-   <x name="x">x</x>
-   <y name="y">y</y>
-   <z name="z">z</z>
-</document>