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/webtools/litmus/.htaccess

@@ -1,3 +0,0 @@
-<FilesMatch ^(.*localconfig.*)$>
-  deny from all
-</FilesMatch>

mozilla/webtools/litmus/INSTALL

@@ -1,44 +0,0 @@
-===Litmus Installation Instructions===
-
-First of all, let me convince you that you in fact probbaly do not want
-to install Litmus. Litmus is not 1.0 software. Litmus is not even 0.5
-software. In fact, Litmus doesn't really do any of the things you would
-expect it to do yet.
-
-In summary, if you're not looking to install Litmus because you are or
-want to be a Litmus developer, you'd best turn around and go back from
-whence you came.
-
-If at any point you find that you don't understand these installation
-instructions, it's a good sign you want to turn back as well.
-
-Required Perl Modules: 
-Class::DBI 
-Class::DBI::mysql 
-Template 
-Time::Piece 
-Time::Piece::mysql 
-Time::Seconds
-Date::Manip
-HTML::StripScripts
-HTML::StripScripts::Parser
-Text::Markdown
-XML::XPath
-
-Once you've got everything installed, run: mysql < createdb.sql to
-create the Litmus database.
-
-Then edit Litmus/Config.pm to give it the information it needs to
-connect to the database.
-
-Run ./populatedb.pl to create products, testgroups, subgroups, etc...
-There is no UI at present for doing this.
-
-Edit the newly created 'localconfig' file and provide your database 
-configuration. 
-
-Then just pop the whole thing into a directory where your web server can
-get at it. Have fun!
-
-Note: After upgrading Litmus, it's a good idea to run populatedb.pl
-again to pick up any schema changes that may have occured. 

mozilla/webtools/litmus/Litmus.pm

@@ -1,109 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #   Max Kanat-Alexander <mkanat@bugzilla.org>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-# Global object store and function library for Litmus
-
-package Litmus;
-
-use strict;
-
-use Litmus::Template;
-use Litmus::Config;
-use Litmus::Error;
-use Litmus::Auth;
-use Litmus::CGI;
-
-our $_request_cache = {};
-
-# each cgi _MUST_ call Litmus->init() prior to doing anything else.
-# init() ensures that the installation has not been disabled, deals with pending 
-# login requests, and other essential tasks.
-sub init() {
-	if ($Litmus::Config::disabled) {
-  	  	my $c = new CGI();
-    	print $c->header();
-    	print "Litmus has been shutdown by the administrator. Please try again later.";
-    	exit;
-	}
-	# check for pending logins:
-	my $c = cgi();
-	if ($c->param("login_type")) {
-		Litmus::Auth::processLoginForm();
-	}
-}
-
-# Global Template object
-sub template() {
-    my $class = shift;
-    request_cache()->{template} ||= Litmus::Template->create();
-    return request_cache()->{template};
-}
-
-# Global CGI object
-sub cgi() {
-    my $class = shift;
-    request_cache()->{cgi} ||= new Litmus::CGI();
-    return request_cache()->{cgi};
-}
-
-sub getCurrentUser {
-	return Litmus::Auth::getCurrentUser();
-}
-
-# cache of global variables for a single request only
-# use me like: Litmus->request_cache->{'var'} = 'foo';
-# entries here are guarenteed to get flushed when the request ends, 
-# even when running under mod_perl
-# from Bugzilla.pm:
-sub request_cache {
-    if ($ENV{MOD_PERL}) {
-        my $request = Apache->request();
-        my $cache = $request->pnotes();
-        # Sometimes mod_perl doesn't properly call DESTROY on all
-        # the objects in pnotes(), so we register a cleanup handler
-        # to make sure that this happens.
-        if (!$cache->{cleanup_registered}) {
-             $request->push_handlers(PerlCleanupHandler => sub {
-                 my $r = shift;
-                 foreach my $key (keys %{$r->pnotes}) {
-                     delete $r->pnotes->{$key};
-                 }
-             });
-             $cache->{cleanup_registered} = 1;
-        }
-        return $cache;
-    }
-    return $_request_cache;
-}
-
-1;

mozilla/webtools/litmus/Litmus/Auth.pm

@@ -1,555 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::Auth;
-
-use strict;
-
-# IMPORTANT! 
-## You _must_ call Litmus::Auth methods before sending a Content-type
-## header so that any required cookies can be sent.
-
-require Exporter;
-use Litmus::Error;
-use Time::Piece;
-use Time::Seconds;
-use Litmus::DB::User;
-
-use CGI;
-
-our @ISA = qw(Exporter);
-our @EXPORT = qw();
-
-my $logincookiename = $Litmus::Config::user_cookiename;
-my $cookie_expire_days = 7;
-
-# Given a username and password, validate the login. Returns the 
-# Litmus::DB::User object associated with the username if the login 
-# is sucuessful. Returns false otherwise.
-sub validate_login($$) {
-  my $username = shift;
-  my $password = shift;
-
-  return 0 if (!$username or $username eq '' or 
-               !$password or $password eq '');
-
-  my ($userobj) = Litmus::DB::User->search(email => $username);
-
-  if (!$userobj) { 
-    return 0; 
-  } 
-
-  if (!$userobj->enabled() || $userobj->enabled() == 0) { 
-    die "Account ".$userobj->username()." has been disabled by the administrator"; 
-  }
-	
-  # for security reasons, we use the real (correct) crypt'd passwd
-  # as the salt:
-  my $realPasswordCrypted = $userobj->getRealPasswd();
-  return 0 if (!$realPasswordCrypted or $realPasswordCrypted eq '');
-  my $enteredPasswordCrypted = crypt($password, $realPasswordCrypted);
-  if ($enteredPasswordCrypted eq $realPasswordCrypted) {
-    return $userobj;
-  } else {
-    return 0;
-  }
-}
-
-# Used by a CGI when a login is required to proceed beyond a certain point.
-# requireLogin() will return a Litmus::User object to indicate that the user 
-# is logged in, or it will redirect to a login page to allow the login to be 
-# completed. Once the login is complete, the user will be redirected back to 
-# $return_to and any parameters in the current CGI.pm object will be passed 
-# to the new script. 
-#
-sub requireLogin {
-  my $return_to = shift;
-  my $admin_login_required = shift;
-  my $cgi = Litmus->cgi();
-
-  # see if we are already logged in:
-  my $user = getCurrentUser();
-  return $user if $user; # well, that was easy...
-
-  my $vars = {
-              title => "Login",
-              return_to => $return_to,
-              adminrequired => $admin_login_required,
-              params => $cgi,
-             };
-
-  print $cgi->header();
-  Litmus->template()->process("auth/login.html.tmpl", $vars) ||
-    internalError(Litmus->template()->error());
-  
-  exit;	
-}
-
-# Used by a CGI in much the same way as requireLogin() when the user must
-# be an admin to proceed.
-sub requireAdmin {
-  my $return_to = shift;
-  my $cgi = Litmus->cgi();
-  
-  my $user = requireLogin($return_to, 1);
-  if (!$user || !$user->is_admin()) { 
-  	print $cgi->header();
-    basicError("You must be a Litmus administrator to perform this function.");
-  }
-  return $user;
-}
-
-# Returns the current Litmus::DB::Session object corresponding to the current 
-# logged-in user, or 0 if no valid session exists
-sub getCurrentSession() {
-	my $c = Litmus->cgi();
-	
-	# we're actually processing the login form right now, so the cookie hasn't
-	# been sent yet...
-	if (Litmus->request_cache->{'curSession'}) { 
-		return Litmus->request_cache->{'curSession'}; 
-	} 
-	
-	my $sessionCookie = $c->cookie($logincookiename);
-  	if (! $sessionCookie) {
-    	return 0
-    }
-  
-	my @sessions = Litmus::DB::Session->search(sessioncookie => $sessionCookie);
-	my $session = $sessions[0];
-	if (! $session) { return 0 }
-  
-	# see if it's still valid and that the user hasn't been disabled
-	if (! $session->isValid()) { return 0 }
-  
-	return $session;
-}
-
-# Returns the Litmus::User object corresponding to the current logged-in
-# user, or 0 if no valid login cookie exists
-sub getCurrentUser() {
-	my $session = getCurrentSession();
-	
-	if ($session) {
-		return $session->user_id();
-	} else {
-		return 0;
-	}
-}
-
-
-#
-# ONLY NON-PUBLIC API BEYOND THIS POINT
-#
-
-# Processes data from a login form (auth/login.html.tmpl) using data 
-# from the current Litmus::CGI object in use. When complete, returns the 
-# flow of control to the script the user wanted to reach before the login,
-# setting a login cookie for the user.
-sub processLoginForm {
-  my $c = Litmus->cgi();
-  
-  my $type = $c->param("login_type");
-  
-  if ($c->param("accountCreated")  && 
-      $c->param("accountCreated") eq "true") {
-    # make sure they really are logged in and didn't just set
-    # the accountCreated flag:
-    requireLogin("index.cgi");
-    return; # we're done here
-  }
-  
-  if ($type eq "litmus") {
-    my $username = $c->param("email");
-    my $password = $c->param("password");
-    
-    my $user = validate_login($username, $password);
-    
-    if (!$user) {
-      loginError($c, "Username/Password incorrect. Please try again.");
-    }
-    
-    my $session = makeSession($user);
-    $c->storeCookie(makeCookie($session));
-    
-  } elsif ($type eq "newaccount") {
-    my $email = $c->param("email");
-    my $name = $c->param("realname");
-    my $password = $c->param("password"); 
-    my $nickname = $c->param("irc_nickname");
-    
-    # some basic form-field validation:
-    my $emailregexp = q:^[\\w\\.\\+\\-=]+@[\\w\\.\\-]+\\.[\\w\\-]+$:;
-    if (! $email || ! $email =~ /$emailregexp/) {
-      loginError($c, "You must enter a valid email address");
-    }
-    if (! $password eq $c->param("password_confirm")) {
-      loginError($c, "Passwords do not match. Please try again.");
-    }
-
-    my @users = Litmus::DB::User->search(email => $email);
-    if ($users[0]) {
-      loginError($c, "User ".$users[0]->email() ." already exists.");
-    }
-    if ($nickname and $nickname ne '') {
-      @users = Litmus::DB::User->search(irc_nickname => $nickname);
-      if ($users[0]) {
-        loginError($c, "An account with that IRC nickname already exists.");
-      }
-    } else {
-      $nickname = undef;
-    }
-    
-    my $userobj = 
-      Litmus::DB::User->create({email => $email, 
-                                password => bz_crypt($password),
-                                bugzilla_uid => 0,
-                                realname => $name,
-                                enabled => 1, 
-                                is_admin => 0,
-                                irc_nickname => $nickname
-                               });
-    
-    my $session = makeSession($userobj);
-    $c->storeCookie(makeCookie($session));
-    
-    my $vars = {
-                title => "Account Created",
-                email => $email,
-                realname => $name,
-                return_to => $c->param("login_loc"),
-                params => $c
-               };
-    
-    print $c->header();
-    Litmus->template()->process("auth/accountcreated.html.tmpl", $vars) ||
-      internalError(Litmus->template()->error());
-    
-    exit;	
-    
-  } elsif ($type eq "bugzilla") {
-    my $username = $c->param("username");
-    my $password = $c->param("password");
-    
-    
-  } elsif ($type eq "convert") {
-    # convert an old-school Litmus account (pre authentication system) 
-    # to a new one with a password:
-    my $username = $c->param("email");
-    
-    my @userobjs = Litmus::DB::User->search(email => $username);
-    my $userobj = $userobjs[0];
-    if (! $userobj || $userobj->email() ne $username) {
-      loginError($c, "User $username does not exist.");
-    }
-    
-    if ($userobj->password() ne "") {
-      # already a new-style account
-      loginError($c, "User $username has already been updated.");
-    }
-    
-    # display a "convert login" form to get the rest of the information
-    print $c->header();
-    my $return_to = $c->param("login_loc") || "";
-    unsetFields();
-    my $vars = {
-                title => "Update Login",
-                email => $username,
-                return_to => $return_to,
-                params => $c,
-               };
-    
-    Litmus->template()->process("auth/convertaccount.html.tmpl", $vars) ||
-      internalError(Litmus->template()->error());
-    exit;
-  } elsif ($type eq "reallyconvert") {
-    my $username = $c->param("email");
-    my $realname = $c->param("realname");
-    my $password = $c->param("password");
-    my $password_confirm = $c->param("password_confirm");
-    my $nickname = $c->param("irc_nickname");
-    
-    if (! $password eq $password_confirm) {
-      loginError($c, "Passwords do not match. Please try again.");
-    }
-    
-    my @userobjs = Litmus::DB::User->search(email => $username);
-    my $userobj = $userobjs[0];
-    
-    # just to be safe:
-    if (! $userobj || $userobj->email() ne $username) {
-      loginError($c, "User $username does not exist.");
-    }
-    
-    if ($userobj->password() ne "" && ($userobj->bugzilla_uid() == 0 || 
-                                       !$userobj->bugzilla_uid())) {
-      # already a new-style account
-      loginError($c, "User $username has already been updated.");
-    }
-    my ($nickname_exists) = 
-      Litmus::DB::User->search(irc_nickname => $nickname);
-    if ($nickname_exists) {
-      loginError($c,
-                 "An account with that IRC nickname already exists.",
-                 "auth/convertaccount.html.tmpl",
-                 "Update Login");
-    }
-    
-    # do the upgrade:
-    $userobj->password(bz_crypt($password));
-    $userobj->bugzilla_uid("0");
-    $userobj->realname($realname);
-    $userobj->enabled(1);
-#    $userobj->is_admin(0);
-    $userobj->irc_nickname($nickname);
-    $userobj->update();
-    
-    my $session = makeSession($userobj);
-    $c->storeCookie(makeCookie($session));
-
-    my $vars = {
-                title => "Account Created",
-                email => $username,
-                realname => $realname,
-                return_to => $c->param("login_loc"),
-                params => $c
-               };
-    
-    print $c->header();
-    Litmus->template()->process("auth/accountcreated.html.tmpl", $vars) ||
-      internalError(Litmus->template()->error());
-    
-    exit;
-    
-  } else {
-    internalError("Unknown login scheme attempted");
-  }
-}
-
-sub changePassword {
-	my $userobj = shift;
-	my $password = shift;
-	$userobj->password(bz_crypt($password));
-	$userobj->update();
-	
-	my @sessions = $userobj->sessions();
-	foreach my $session (@sessions) {
-		$session->makeExpire();
-	}
-}
-
-# Given a userobj, process the login and return a session object
-sub makeSession {
-  my $userobj = shift;
-  my $c = Litmus->cgi();
-  
-  my $expires = localtime() + ONE_DAY * $cookie_expire_days;
-  
-  my $sessioncookie = randomToken(64);
-  
-  my $session = Litmus::DB::Session->create({
-                                             user_id => $userobj, 
-                                             sessioncookie => $sessioncookie,
-                                             expires => $expires});
-  
-  Litmus->request_cache->{'curSession'} = $session;
-  return $session;
-}
-
-# Given a session, create a login cookie to go with it
-sub makeCookie {
-  my $session = shift;
-  
-  my $cookie = Litmus->cgi()->cookie( 
-                                     -name    => $logincookiename,
-                                     -value   => $session->sessioncookie(),
-                                     -domain  => $main::ENV{"HTTP_HOST"},
-                                     -expires => $session->expires(),
-                                    );
-  return $cookie;
-}
-
-sub loginError {
-  my $c = shift;
-  my $message = shift;
-  my $template = shift;
-  my $title = shift;
-
-  if (!$template) {
-    $template = "auth/login.html.tmpl";
-  }
-  if (!$title) {
-    $title = "Login";
-  }
-
-  print $c->header();
-  
-  my $return_to = $c->param("login_loc") || "";
-  my $email = $c->param("email") || "";
-	
-  unsetFields();
-  
-  my $vars = {
-              title => $title,
-              return_to => $return_to,
-              email => $email,
-              params => $c,
-              onload => "toggleMessage('failure','$message')", 
-            };
-
-  Litmus->template()->process($template, $vars) ||
-    internalError(Litmus->template()->error());
-  
-  exit;
-}
-
-sub unsetFields() {
-  my $c = Litmus->cgi();
-  
-  # We need to unset some params in $c since otherwise we end up with 
-  # a hidden form field set for "email" and friends and madness results:
-  $c->param('email', '');
-  $c->param('username', '');
-  $c->param('login_type', '');
-  $c->param('login_loc', '');
-  $c->param('realname', '');
-  $c->param('password', '');
-  $c->param('password_confirm', '');
-  
-}
-
-# Like crypt(), but with a random salt. Thanks to Bugzilla for this.
-sub bz_crypt {
-  my ($password) = @_;
-  
-  # The list of characters that can appear in a salt.  Salts and hashes
-  # are both encoded as a sequence of characters from a set containing
-  # 64 characters, each one of which represents 6 bits of the salt/hash.
-  # The encoding is similar to BASE64, the difference being that the
-  # BASE64 plus sign (+) is replaced with a forward slash (/).
-  my @saltchars = (0..9, 'A'..'Z', 'a'..'z', '.', '/');
-  
-  # Generate the salt.  We use an 8 character (48 bit) salt for maximum
-  # security on systems whose crypt uses MD5.  Systems with older
-  # versions of crypt will just use the first two characters of the salt.
-  my $salt = '';
-  for ( my $i=0 ; $i < 8 ; ++$i ) {
-    $salt .= $saltchars[rand(64)];
-  }
-  
-  # Crypt the password.
-  my $cryptedpassword = crypt($password, $salt);
-  
-  # Return the crypted password.
-  return $cryptedpassword;
-}
-
-sub randomToken {
-  my $size = shift || 10; # default to 10 chars if nothing specified
-  return join("", map{ ('0'..'9','a'..'z','A'..'Z')[rand 62] } (1..$size));
-}
-
-# Deprecated:
-# DO NOT USE
-sub setCookie {
-  my $user = shift;
-  my $expires = shift;
-
-  my $user_id = 0;
-  if ($user) {
-    $user_id = $user->user_id();
-  }
-  
-  if (!$expires or $expires eq '') {
-    $expires = '+3d';
-  }
-    
-  my $c = Litmus->cgi();
-  
-  my $cookie = $c->cookie( 
-                          -name    => $logincookiename,
-                          -value   => $user_id,
-                          -domain  => $main::ENV{"HTTP_HOST"},
-                          -expires => $expires,
-                         );
-  
-  return $cookie;
-}
-
-# Deprecated:
-sub getCookie() {
-  return getCurrentUser();
-}
-
-sub istrusted($) {
-  my $userobj = shift;
-
-  return 0 if (!$userobj);
-  
-  if ($userobj->istrusted()) {
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-sub canEdit($) {
-  my $userobj = shift;
-  
-  return $userobj->istrusted();
-}
-
-#########################################################################
-# logout()
-#
-# Unset the user's cookie
-#########################################################################
-sub logout() {
-  my $c = Litmus->cgi();
-
-  my $cookie = $c->cookie(
-                          -name => $logincookiename,
-                          -value => '',
-                          -domain  => $main::ENV{"HTTP_HOST"},
-                          -expires => '-1d'
-                         );
-  $c->storeCookie($cookie);
-  
-  # invalidate the session behind the cookie as well:
-  my $session = getCurrentSession();
-  if ($session) { $session->makeExpire() } 
-}
-
-
-1;
-
-

mozilla/webtools/litmus/Litmus/BugzillaDBI.pm

@@ -1,59 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::BugzillaDBI;
-
-use strict;
-use warnings;
-use Litmus::Config;
-use Litmus::Error;
-use Memoize;
-
-use base 'Litmus::DBI';
-
-BEGIN {
-unless ($Litmus::Config::bugzilla_auth_enabled) {
-	return 1;
-}
-}
-
-my $dsn = "dbi:mysql:$Litmus::Config::bugzilla_db:$Litmus::Config::bugzilla_host";
-
-Litmus::BugzillaDBI->set_db('Main',
-                         $dsn,
-                         $Litmus::Config::bugzilla_user,
-                         $Litmus::Config::bugzilla_pass);
-                         
-
-                                         
-1;
-

mozilla/webtools/litmus/Litmus/CGI.pm

@@ -1,72 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::CGI; 
-
-use strict;
-use base 'CGI';
-
-# Subclass of CGI.pm that can store cookies in advance and output them 
-# later when the header() method is called. This feature should probably 
-# be submitted as a patch to CGI.pm itself.
-
-sub new {
-	my $class = shift;
-	my @args = @_;
-	
-	my $self = $class->SUPER::new(@args);
-	$self->{'litmusCookieStore'} = [];
-	return $self;
-}
-
-# Stores a cookie to be set later by the header() method
-sub storeCookie {
-	my $self = shift;
-	my $cookie = shift;
-	
-	# "we're like kids in a candy shop"
-	my @cookieStore = @{$self->{'litmusCookieStore'}};
-	push(@cookieStore, $cookie);
-	$self->{'litmusCookieStore'} = \@cookieStore;
-}
-
-sub header {
-	my $self = shift;
-	my @args = @_;
-	
-	foreach my $cur ($self->{'litmusCookieStore'}) {
-		push(@args, {-cookie => $cur});
-	}
-	
-	$self->SUPER::header(@args);
-}
-
-1;

mozilla/webtools/litmus/Litmus/Cache.pm

@@ -1,125 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::Cache;
-
-use strict;
-
-use Litmus;
-use Data::JavaScript;
-use Litmus::DB::Product;
-
-our @ISA = qw(Exporter);
-@Litmus::Cache::EXPORT = qw(
-    rebuildCache
-);
-
-# generate a new litmusconfig.js file because something has updated:
-sub rebuildCache {
-    unless (-e "data") { system("mkdir", "data") }
-    open(CACHE, ">data/litmusconfig.js.new");
-    
-    print CACHE "// Litmus configuration information\n";
-    print CACHE "// Do not edit this file directly. It is autogenerated from the database\n";
-    print CACHE "\n";
-    
-    # we build up @litmusconfig, a big perl data structure, and spit the 
-    # whole thing out as javascript with Data::JavaScript
-    # shield your eyes, we're in for a long trip
-    my @litmusconfig;
-    my @products = Litmus::DB::Product->search(enabled => 1);
-    my $prodcount = 0;
-    foreach my $curproduct (@products) {
-        my $prodrow =  \%{$litmusconfig[$prodcount]};
-           $prodrow->{"name"} = $curproduct->name();
-           $prodrow->{"id"} = $curproduct->product_id();
-           
-           my $brancharray = \@{$prodrow->{"branches"}};
-           my $branchcount = 0;
-           foreach my $curbranch ($curproduct->branches(enabled => 1)) {
-               my $branchrow = \%{$brancharray->[$branchcount]};
-               $branchrow->{"name"} = $curbranch->name();
-               $branchrow->{"id"} = $curbranch->branch_id();
-               $branchcount++;
-           }
-           
-           my $platformarray = \@{$prodrow->{"platforms"}};
-           my $platformcount = 0;
-           foreach my $curplat (Litmus::DB::Platform->search_ByProduct($curproduct->product_id())) {
-               my $platrow = \%{$platformarray->[$platformcount]};
-               $platrow->{"name"} = $curplat->name();
-               $platrow->{"id"} = $curplat->platform_id();
-               
-               my $opsysarray = \@{$platrow->{"opsyses"}};
-               my $opsyscount = 0;
-               foreach my $curopsys ($curplat->opsyses()) {
-                   my $opsysrow = \%{$opsysarray->[$opsyscount]};
-                   $opsysrow->{"name"} = $curopsys->name();
-                   $opsysrow->{"id"} = $curopsys->opsys_id();
-                   $opsyscount++;
-               }
-               $platformcount++;
-           }
-           
-           my $grouparray = \@{$prodrow->{"testgroups"}};
-           my $groupcount = 0;
-           foreach my $curgroup ($curproduct->testgroups()) {
-               next if (!$curgroup->enabled);
-               my $grouprow = \%{$grouparray->[$groupcount]};
-               $grouprow->{"name"} = $curgroup->name();
-               $grouprow->{"id"} = $curgroup->testgroup_id();
-               $groupcount++;
-               
-               my $subgrouparray = \@{$grouprow->{"subgroups"}};
-               my $subgroupcount = 0;
-               foreach my $cursubgroup (Litmus::DB::Subgroup->search_EnabledByTestgroup($curgroup->testgroup_id())) {
-                 next if (!$cursubgroup->enabled);
-                   my $subgrouprow = \%{$subgrouparray->[$subgroupcount]};
-                   $subgrouprow->{"name"} = $cursubgroup->name();
-                   $subgrouprow->{"id"} = $cursubgroup->subgroup_id();
-                   $subgroupcount++;
-               }
-           }
-           
-        $prodcount++;
-    }
-        
-    
-    my $data = jsdump('litmusconfig', \@litmusconfig);
-    $data =~ s/new Object;/new Array\(\);/g;
-    print CACHE $data;
-    close(CACHE);
-    system("mv", "data/litmusconfig.js.new", "data/litmusconfig.js");
-    #system("chmod", "-R", "755", "data/");
-}
-
-1;

mozilla/webtools/litmus/Litmus/Config.pm

@@ -1,49 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::Config; 
-
-use strict;
-
-do 'localconfig';
-
-our $version = "0.6";
-
-# if true, then Litmus will not accept any requests
-our $disabled = 0;
-
-our $datadir = "data/";
-
-# Set/unset this to display inline debugging value/code.
-our $DEBUG = 0;
-
-1;

mozilla/webtools/litmus/Litmus/DB/Branch.pm

@@ -1,48 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Branch;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::Branch->table('branches');
-
-Litmus::DB::Branch->columns(All => qw/branch_id product_id name detect_regexp enabled/);
-Litmus::DB::Branch->columns(Essential => qw/branch_id product_id name detect_regexp enabled/);
-
-Litmus::DB::Branch->column_alias("product_id", "product");
-
-Litmus::DB::Branch->has_many(test_results => "Litmus::DB::Testresult");
-Litmus::DB::Branch->has_a(product => "Litmus::DB::Product");
-
-1;

mozilla/webtools/litmus/Litmus/DB/BugzillaUser.pm

@@ -1,44 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::BugzillaUser;
-
-use strict;
-use base 'Litmus::BugzillaDBI';
-
-Litmus::DB::BugzillaUser->table('profiles');
-
-Litmus::DB::BugzillaUser->columns(All => qw/userid login_name cryptpassword realname 
-	disabledtext mybugslink refreshed_when extern_id/);
-
-
-1;

mozilla/webtools/litmus/Litmus/DB/BuildType.pm

@@ -1,44 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::BuildType;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::BuildType->table('build_type_lookup');
-
-Litmus::DB::BuildType->columns(All => qw/build_type_id name/);
-
-Litmus::DB::BuildType->has_many(test_results => "Litmus::DB::Testresult");
-
-1;

mozilla/webtools/litmus/Litmus/DB/Comment.pm

@@ -1,53 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Comment;
-
-use strict;
-use base 'Litmus::DBI';
-
-use Time::Piece;
-
-Litmus::DB::Comment->table('test_result_comments');
-
-Litmus::DB::Comment->columns(All => qw/comment_id test_result_id last_updated submission_time user_id comment/);
-
-Litmus::DB::Comment->column_alias("test_result_id", "test_result");
-Litmus::DB::Comment->column_alias("user_id", "user");
-
-Litmus::DB::Comment->has_a(test_result => "Litmus::DB::Testresult");
-Litmus::DB::Comment->has_a(user => "Litmus::DB::User");
-
-Litmus::DB::Comment->autoinflate(dates => 'Time::Piece');
-
-1;
-

mozilla/webtools/litmus/Litmus/DB/ExitStatus.pm

@@ -1,44 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::ExitStatus;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::ExitStatus->table('exit_status_lookup');
-
-Litmus::DB::ExitStatus->columns(All => qw/exit_status_id name/);
-
-Litmus::DB::ExitStatus->has_many(test_results => "Litmus::DB::Testresult");
-
-1;

mozilla/webtools/litmus/Litmus/DB/Format.pm

@@ -1,46 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Format;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::Format->table('test_format_lookup');
-
-Litmus::DB::Format->columns(All => qw/format_id name/);
-
-Litmus::DB::Format->column_alias("format_id", "formatid");
-
-Litmus::DB::Format->has_many(testcases => "Litmus::DB::Testcase");
-
-1;

mozilla/webtools/litmus/Litmus/DB/Locale.pm

@@ -1,52 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Locale;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::Locale->table('locale_lookup');
-
-Litmus::DB::Locale->columns(All => qw/abbrev name/);
-
-Litmus::DB::Locale->column_alias("abbrev", "locale");
-
-Litmus::DB::Locale->has_many(test_results => "Litmus::DB::Testresult");
-
-__PACKAGE__->set_sql(RetrieveAll => qq{
-                                       SELECT __ESSENTIAL__
-                                       FROM   __TABLE__
-                                       ORDER BY abbrev ASC
-});
-
-1;

mozilla/webtools/litmus/Litmus/DB/Log.pm

@@ -1,50 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Log;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::Log->table('test_result_logs');
-
-Litmus::DB::Log->columns(All => qw/log_id last_updated submission_time log_type_id log_text/);
-
-Litmus::DB::Log->column_alias("test_results", "testresults");
-Litmus::DB::Log->column_alias("log_type_id", "log_type");
-
-Litmus::DB::Log->has_a(log_type => "Litmus::DB::LogType");
-Litmus::DB::Log->has_many(test_results => ["Litmus::DB::LogTestresult" => 'test_result']);
-
-Litmus::DB::Testresult->autoinflate(dates => 'Time::Piece');
-
-1;

mozilla/webtools/litmus/Litmus/DB/LogTestresult.pm

@@ -1,47 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::LogTestresult;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::LogTestresult->table('testresult_logs_join');
-
-Litmus::DB::LogTestresult->columns(Primary => qw/test_result_id log_id/);
-
-Litmus::DB::LogTestresult->column_alias("test_result_id", "test_result");
-
-Litmus::DB::LogTestresult->has_a(test_result => "Litmus::DB::Testresult");
-Litmus::DB::LogTestresult->has_a(log_id => "Litmus::DB::Log");
-
-1;

mozilla/webtools/litmus/Litmus/DB/LogType.pm

@@ -1,44 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::LogType;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::LogType->table('log_type_lookup');
-
-Litmus::DB::LogType->columns(All => qw/log_type_id name/);
-
-Litmus::DB::LogType->has_many(test_result_logs => "Litmus::DB::Log");
-
-1;

mozilla/webtools/litmus/Litmus/DB/Opsys.pm

@@ -1,48 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Opsys;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::Opsys->table('opsyses');
-
-Litmus::DB::Opsys->columns(All => qw/opsys_id platform_id name detect_regexp/);
-Litmus::DB::Opsys->columns(Essential => qw/opsys_id platform_id name detect_regexp/);
-
-Litmus::DB::Opsys->column_alias("platform_id", "platform");
-
-Litmus::DB::Opsys->has_many(test_results => "Litmus::DB::Testresult");
-Litmus::DB::Opsys->has_a(platform => "Litmus::DB::Platform");
-
-1;

mozilla/webtools/litmus/Litmus/DB/Platform.pm

@@ -1,105 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Platform;
-
-use strict;
-use base 'Litmus::DBI';
-use CGI;
-
-Litmus::DB::Platform->table('platforms');
-
-Litmus::DB::Platform->columns(All => qw/platform_id name detect_regexp iconpath/);
-Litmus::DB::Platform->columns(Essential => qw/platform_id name detect_regexp iconpath/);
-
-Litmus::DB::Platform->column_alias("platform_id", "platformid");
-
-Litmus::DB::Platform->has_many(opsyses => "Litmus::DB::Opsys");
-
-Litmus::DB::Platform->set_sql(ByProduct => qq{
-                                              SELECT pl.* 
-                                              FROM platforms pl, platform_products plpr
-                                              WHERE plpr.product_id=? AND plpr.platform_id=pl.platform_id
-});
-
-Litmus::DB::Platform->set_sql(ByProductAndName => qq{
-                                                     SELECT pl.* 
-                                                     FROM platforms pl, platform_products plpr
-                                                     WHERE plpr.product_id=? AND plpr.platform_id=pl.platform_id
-                                                     AND pl.name=?
-});
-
-#########################################################################
-sub delete_from_products() {
-  my $self = shift;
-  
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "DELETE from platform_products WHERE platform_id=?";
-  my $rows = $dbh->do($sql,
-                      undef,
-                      $self->platform_id
-                     );
-}
-
-#########################################################################
-sub delete_with_refs() {
-  my $self = shift;
-
-  $self->delete_from_products();
-
-  # XXX: How to handle opsyses?
-
-  return $self->delete;
-}
-
-#########################################################################
-sub update_products() {
-  my $self = shift;
-  my $new_product_ids = shift;
-  
-  if (scalar @$new_product_ids) {
-    # Failing to delete products is _not_ fatal when adding a new subgroup.
-    my $rv = $self->delete_from_products();
-    my $dbh = __PACKAGE__->db_Main();  
-    my $sql = "INSERT INTO platform_products (platform_id,product_id) VALUES (?,?)";
-    foreach my $new_product_id (@$new_product_ids) {
-      my $rows = $dbh->do($sql, 
-			  undef,
-			  $self->platform_id,
-			  $new_product_id
-			 );
-    }
-  }
-}
-
-
-1;

mozilla/webtools/litmus/Litmus/DB/Product.pm

@@ -1,108 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Product;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::Product->table('products');
-
-Litmus::DB::Product->columns(All => qw/product_id name iconpath enabled/);
-Litmus::DB::Product->columns(Essential => qw/product_id name iconpath enabled/);
-
-Litmus::DB::Product->column_alias("product_id", "productid");
-
-Litmus::DB::Product->has_many(testcases => "Litmus::DB::Testcase", 
-                              { order_by => 'testcase_id' });
-Litmus::DB::Product->has_many(subgroups => "Litmus::DB::Subgroup",
-                              { order_by => 'name' });
-Litmus::DB::Product->has_many(testgroups => "Litmus::DB::Testgroup",
-                              { order_by => 'name' });
-Litmus::DB::Product->has_many(branches => "Litmus::DB::Branch",
-                              { order_by => 'name' });
-
-__PACKAGE__->set_sql(ByPlatform => qq{
-                                      SELECT pr.* 
-                                      FROM products pr, platform_products plpr 
-                                      WHERE plpr.platform_id=? AND plpr.product_id=pr.product_id
-                                      ORDER BY pr.name ASC
-});
-
-#########################################################################
-sub delete_from_platforms() {
-  my $self = shift;
-  
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "DELETE from platform_products WHERE product_id=?";
-  my $rows = $dbh->do($sql,
-                      undef,
-                      $self->product_id
-                     );
-}
-
-#########################################################################
-sub delete_with_refs() {
-  my $self = shift;
-  $self->delete_from_platforms();
-
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "UPDATE testgroups SET product_id=0,enabled=0 WHERE product_id=?";
-  my $rows = $dbh->do($sql,
-                      undef,
-                      $self->product_id
-                     );
-
-  # Remove references to product in other entities. 
-  # Disable those entities for good measure.
-  $sql = "UPDATE subgroups SET product_id=0,enabled=0 WHERE product_id=?";
-  $rows = $dbh->do($sql,
-                   undef,
-                   $self->product_id
-                  );
-
-  $sql = "UPDATE testcases SET product_id=0,enabled=0,community_enabled=0 WHERE product_id=?";
-  $rows = $dbh->do($sql,
-                   undef,
-                   $self->product_id
-                  );
-
-  $sql = "UPDATE branches SET product_id=0,enabled=0 WHERE product_id=?";
-  $rows = $dbh->do($sql,
-                   undef,
-                   $self->product_id
-                  );
-
-  return $self->delete;
-}
-
-1;

mozilla/webtools/litmus/Litmus/DB/ResultStatus.pm

@@ -1,44 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::ResultStatus;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::ResultStatus->table('test_result_status_lookup');
-
-Litmus::DB::ResultStatus->columns(All => qw/result_status_id name class_name/);
-
-Litmus::DB::ResultStatus->has_many(test_results => "Litmus::DB::Testresult");
-
-1;

mozilla/webtools/litmus/Litmus/DB/Resultbug.pm

@@ -1,54 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Resultbug;
-
-use strict;
-use base 'Litmus::DBI';
-
-use Time::Piece;
-
-Litmus::DB::Resultbug->table('test_result_bugs');
-
-Litmus::DB::Resultbug->columns(Primary => qw/test_result_id bug_id/);
-Litmus::DB::Resultbug->columns(All => qw/last_updated submission_time user_id/);
-
-Litmus::DB::Resultbug->column_alias("test_result_id", "test_result");
-Litmus::DB::Resultbug->column_alias("test_result_id", "testresult");
-Litmus::DB::Resultbug->column_alias("user_id", "user");
-
-Litmus::DB::Resultbug->has_a(test_result => "Litmus::DB::Testresult");
-Litmus::DB::Resultbug->has_a(user => "Litmus::DB::User");
-
-Litmus::DB::Resultbug->autoinflate(dates => 'Time::Piece');
-
-1;

mozilla/webtools/litmus/Litmus/DB/Session.pm

@@ -1,69 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Session;
-
-use strict;
-use base 'Litmus::DBI';
-
-use Time::Piece;
-
-Litmus::DB::Session->table('sessions');
-
-Litmus::DB::Session->columns(All => qw/session_id user_id sessioncookie expires/);
-
-Litmus::DB::Session->has_a(user_id => "Litmus::DB::User");
-
-Litmus::DB::Session->autoinflate(dates => 'Time::Piece');
-
-# expire the current Session object 
-sub makeExpire {
-	my $self = shift;
-	$self->delete();
-}
-
-sub isValid {
-	my $self = shift;
-	
-	if ($self->expires() <= localtime()) {
-    	$self->makeExpire();
-    	return 0;
-    }
-    
-    if (!$self->user_id()->enabled() || $self->user_id()->enabled() == 0) {
-    	$self->makeExpire();
-    	return 0;
-    }
-    return 1;
-}
-
-1;

mozilla/webtools/litmus/Litmus/DB/Subgroup.pm

@@ -1,306 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Subgroup;
-
-use strict;
-use base 'Litmus::DBI';
-
-use Time::Piece::MySQL;
-#use Litmus::DB::Testresult;
-
-Litmus::DB::Subgroup->table('subgroups');
-
-Litmus::DB::Subgroup->columns(All => qw/subgroup_id name testrunner_group_id enabled product_id/);
-Litmus::DB::Subgroup->columns(Essential => qw/subgroup_id name testrunner_group_id enabled product_id/);
-
-Litmus::DB::Subgroup->column_alias("subgroup_id", "subgroupid");
-
-Litmus::DB::Subgroup->has_a(product => "Litmus::DB::Product");
-
-__PACKAGE__->set_sql(EnabledByTestgroup => qq{
-                                              SELECT sg.* 
-                                              FROM subgroups sg, subgroup_testgroups sgtg 
-                                              WHERE sgtg.testgroup_id=? AND sgtg.subgroup_id=sg.subgroup_id AND sg.enabled=1 
-                                              ORDER BY sgtg.sort_order ASC
-});
-
-__PACKAGE__->set_sql(ByTestgroup => qq{
-                                       SELECT sg.* 
-                                       FROM subgroups sg, subgroup_testgroups sgtg 
-                                       WHERE sgtg.testgroup_id=? AND sgtg.subgroup_id=sg.subgroup_id
-                                       ORDER BY sgtg.sort_order ASC
-});
-
-__PACKAGE__->set_sql(NumEnabledTestcases => qq{
-                                               SELECT count(tc.testcase_id) as num_testcases
-                                               FROM testcases tc, testcase_subgroups tcsg
-                                               WHERE tcsg.subgroup_id=? AND tcsg.testcase_id=tc.testcase_id AND tc.enabled=1 AND tc.community_enabled=1 
-});
-
-__PACKAGE__->set_sql(EnabledByTestcase => qq{
-                                             SELECT sg.* 
-                                             FROM subgroups sg, testcase_subgroups tcsg
-                                             WHERE tcsg.testcase_id=? AND tcsg.subgroup_id=sg.subgroup_id AND sg.enabled=1 
-                                             ORDER by sg.name ASC
-});
-
-__PACKAGE__->set_sql(ByTestcase => qq{
-                                      SELECT sg.* 
-                                      FROM subgroups sg, testcase_subgroups tcsg
-                                      WHERE tcsg.testcase_id=? AND tcsg.subgroup_id=sg.subgroup_id 
-                                      ORDER by sg.name ASC
-});
-
-#########################################################################
-sub coverage() {
-  my $self = shift;
-  my $platform = shift;
-  my $build_id = shift;
-  my $locale = shift;
-  my $community_only = shift;
-  my $user = shift;
-
-  my $sql = "SELECT COUNT(t.testcase_id) FROM testcase_subgroups tsg, testcases t WHERE tsg.subgroup_id=? AND tsg.testcase_id=t.testcase_id AND t.enabled=1";
-  if ($community_only) {
-    $sql .= " AND t.community_enabled=1";
-  }
-  my $dbh = $self->db_Main();
-  my $sth = $dbh->prepare_cached($sql);
-  $sth->execute(
-                $self->{'subgroup_id'},
-               );
-  my ($num_testcases) = $sth->fetchrow_array;
-
-  $sth->finish;
-
-  if (!$num_testcases or 
-      $num_testcases == 0) { return "N/A" }
-
-
-  $sql = "SELECT t.testcase_id, count(tr.testresult_id) AS num_results
-             FROM testcase_subgroups tsg JOIN testcases t ON (tsg.testcase_id=t.testcase_id) LEFT JOIN test_results tr ON (tr.testcase_id=t.testcase_id) JOIN opsyses o ON (tr.opsys_id=o.opsys_id)
-             WHERE tsg.subgroup_id=? AND tr.build_id=? AND tr.locale_abbrev=? AND o.platform_id=?";
-  if ($community_only) {
-    $sql .= " AND t.community_enabled=1";
-  }
-  if ($user) {
-    $sql .= " AND tr.user_id=" . $user->{'user_id'};
-  }
-  
-  $sql .= " GROUP BY tr.testcase_id";
-
-  $sth = $dbh->prepare_cached($sql);
-  $sth->execute(
-                $self->{'subgroup_id'},
-                $build_id,
-                $locale,
-                $platform->{'platform_id'}
-               );
-  my @test_results = $self->sth_to_objects($sth);
-
-  $sth->finish;
-
-  if (@test_results == 0) { return "0" }
-
-  my $num_completed = 0;
-  foreach my $curtest (@test_results) {
-    if ($curtest->{'num_results'} > 0) {
-      $num_completed++;
-    }
-  }
-  
-  my $result = $num_completed/($num_testcases) * 100;
-  unless ($result) {                   
-    return "0";
-  }
-
-  return sprintf("%d",$result);  
-}
-
-#########################################################################
-sub clone() {
-  my $self = shift;
-
-  my $new_subgroup = $self->copy;
-  if (!$new_subgroup) { 
-    return undef;
-  }
-
-  # Propagate testgroup membership;
-  my $dbh = __PACKAGE__->db_Main();  
-  my $sql = "INSERT INTO subgroup_testgroups (subgroup_id,testgroup_id,sort_order) SELECT ?,testgroup_id,sort_order FROM subgroup_testgroups WHERE subgroup_id=?";
-  
-  my $rows = $dbh->do($sql,
-		      undef,
-		      $new_subgroup->subgroup_id,
-		      $self->subgroup_id
-		     );
-  if (! $rows) {
-    # XXX: Do we need to throw a warning here?
-    # What happens when we clone a subgroup that doesn't belong to  
-    # any testgroups?
-  }  
-
-  $sql = "INSERT INTO testcase_subgroups (testcase_id,subgroup_id,sort_order) SELECT testcase_id,?,sort_order FROM testcase_subgroups WHERE subgroup_id=?";
-  
-  $rows = $dbh->do($sql,
-                   undef,
-                   $new_subgroup->subgroup_id,
-                   $self->subgroup_id
-                  );
-  if (! $rows) {
-    # XXX: Do we need to throw a warning here?
-  }  
-
-  return $new_subgroup;
-}
-
-#########################################################################
-sub delete_from_testgroups() {
-  my $self = shift;
-  
-  my $dbh = __PACKAGE__->db_Main();  
-  my $sql = "DELETE from subgroup_testgroups WHERE subgroup_id=?";
-  return $dbh->do($sql,
-                  undef,
-                  $self->subgroup_id
-                 );
-}
-
-#########################################################################
-sub delete_from_testgroup() {
-  my $self = shift;
-  my $testgroup_id = shift;
-  
-  my $dbh = __PACKAGE__->db_Main();  
-  my $sql = "DELETE from subgroup_testgroups WHERE subgroup_id=? AND testgroup_id=?";
-  return $dbh->do($sql,
-                  undef,
-                  $self->subgroup_id,
-                  $testgroup_id
-                 );
-}
-
-#########################################################################
-sub delete_from_testcases() {
-  my $self = shift;
-  
-  my $dbh = __PACKAGE__->db_Main();  
-  my $sql = "DELETE from testcase_subgroups WHERE subgroup_id=?";
-  return $dbh->do($sql,
-                  undef,
-                  $self->subgroup_id
-                 );
-}
-
-#########################################################################
-sub delete_with_refs() {
-  my $self = shift;
-  $self->delete_from_testgroups();
-  $self->delete_from_testcases();
-  return $self->delete;
-}
-
-#########################################################################
-sub update_testgroups() {
-  my $self = shift;
-  my $new_testgroup_ids = shift;
-  
-  if (scalar @$new_testgroup_ids) {
-    # Failing to delete testgroups is _not_ fatal when adding a new subgroup.
-    my $rv = $self->delete_from_testgroups();
-    my $dbh = __PACKAGE__->db_Main();  
-    my $sql = "INSERT INTO subgroup_testgroups (subgroup_id,testgroup_id,sort_order) VALUES (?,?,1)";
-    foreach my $new_testgroup_id (@$new_testgroup_ids) {
-      my $rows = $dbh->do($sql, 
-			  undef,
-			  $self->subgroup_id,
-			  $new_testgroup_id
-			 );
-    }
-  }
-}
-
-#########################################################################
-sub update_testgroup() {
-  my $self = shift;
-  my $testgroup_id = shift;
-  my $sort_order = shift;
-  
-  # Sort order defaults to 1.
-  if (!$sort_order) {
-    $sort_order = 1;
-  }
-
-  my $rv = $self->delete_from_testgroup($testgroup_id);
-  my $dbh = __PACKAGE__->db_Main();  
-  my $sql = "INSERT INTO subgroup_testgroups (subgroup_id,testgroup_id,sort_order) VALUES (?,?,?)";
-  return $dbh->do($sql, 
-                  undef,
-                  $self->subgroup_id,
-                  $testgroup_id,
-                  $sort_order
-                 );
-}
-
-#########################################################################
-sub update_testcases() {
-  my $self = shift;
-  my $new_testcase_ids = shift;
-  
-  if (scalar @$new_testcase_ids) {
-    # Failing to delete testcases is _not_ fatal when adding a new subgroup.
-    my $rv = $self->delete_from_testcases();
-    my $dbh = __PACKAGE__->db_Main();  
-    my $sql = "INSERT INTO testcase_subgroups (testcase_id,subgroup_id,sort_order) VALUES (?,?,?)";
-    my $sort_order = 1;
-    foreach my $new_testcase_id (@$new_testcase_ids) {
-      next if (!$new_testcase_id);
-      # Log any failures/duplicate keys to STDERR.
-      eval {
-        my $rows = $dbh->do($sql, 
-                            undef,
-                            $new_testcase_id,
-                            $self->subgroup_id,
-                            $sort_order
-                           );
-      };
-      if ($@) {
-        print STDERR $@;
-      }
-      $sort_order++;
-    }
-  }
-}
-
-1;

mozilla/webtools/litmus/Litmus/DB/TestRun.pm

@@ -1,61 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::TestRun;
-
-use strict;
-use base 'Litmus::DBI';
-
-use Time::Piece;
-use Time::Seconds;
-
-Litmus::DB::TestRun->table('test_runs');
-
-Litmus::DB::TestRun->columns(All => qw/test_run_id testgroup_id name description start_timestamp finish_timestamp enabled/);
-
-Litmus::DB::TestRun->column_alias("testgroup_id", "testgroup");
-
-Litmus::DB::TestRun->has_a(testgroup => "Litmus::DB::Testgroup");
-Litmus::DB::TestRun->has_many(subgroups => 
-                                [ "Litmus::DB::SubgroupTestgroup" => "testgroup" ]);
-
-Litmus::DB::TestRun->autoinflate(dates => 'Time::Piece');
-
-1;
-
-
-
-
-
-
-
-

mozilla/webtools/litmus/Litmus/DB/Testcase.pm

@@ -1,377 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Testcase;
-
-use strict;
-use base 'Litmus::DBI';
-
-use Date::Manip;
-#use Litmus::DB::Testresult;
-use Memoize;
-#use Litmus::Error;
-
-our $default_relevance_threshold = 1.0;
-our $default_match_limit = 25;
-our $default_num_days = 7;
-
-Litmus::DB::Testcase->table('testcases');
-
-Litmus::DB::Testcase->columns(Primary => qw/testcase_id/);
-Litmus::DB::Testcase->columns(Essential => qw/summary details enabled community_enabled format_id regression_bug_id product_id steps expected_results author_id creation_date last_updated version testrunner_case_id testrunner_case_version/);
-
-Litmus::DB::Testcase->column_alias("testcase_id", "testid");
-Litmus::DB::Testcase->column_alias("testcase_id", "test_id");
-Litmus::DB::Testcase->column_alias("testcase_id", "id");
-Litmus::DB::Testcase->column_alias("community_enabled", "communityenabled");
-Litmus::DB::Testcase->column_alias("format_id", "format");
-Litmus::DB::Testcase->column_alias("author_id", "author");
-Litmus::DB::Testcase->column_alias("product_id", "product");
-
-Litmus::DB::Testcase->has_a("format" => "Litmus::DB::Format");
-Litmus::DB::Testcase->has_a("author" => "Litmus::DB::User");
-Litmus::DB::Testcase->has_a("product" => "Litmus::DB::Product");
-
-__PACKAGE__->set_sql(EnabledBySubgroup => qq{
-				             SELECT t.* 
-					     FROM testcases t, testcase_subgroups tsg
-					     WHERE tsg.subgroup_id=? AND tsg.testcase_id=t.testcase_id AND t.enabled=1 
-					     ORDER BY tsg.sort_order ASC
-});
-
-__PACKAGE__->set_sql(BySubgroup => qq{
-SELECT t.* 
-FROM testcases t, testcase_subgroups tsg
-WHERE 
-  tsg.subgroup_id=? AND
-  tsg.testcase_id=t.testcase_id
-  ORDER BY tsg.sort_order ASC
-});
-
-__PACKAGE__->set_sql(ByTestgroup => qq{
-SELECT t.* 
-FROM testcases t, testcase_subgroups tsg, subgroup_testgroups sgtg
-WHERE 
-  tsg.testcase_id=t.testcase_id AND
-  tsg.subgroup_id=sgtg.subgroup_id AND
-  sgtg.testgroup_id = ?
-  ORDER BY tsg.sort_order ASC
-});
-
-__PACKAGE__->set_sql(CommunityEnabledBySubgroup => qq{
-                                                      SELECT t.* 
-                                                      FROM testcases t, testcase_subgroups tsg
-						      WHERE tsg.subgroup_id=? AND tsg.testcase_id=t.testcase_id AND t.enabled=1 AND t.community_enabled=1
-						      ORDER BY tsg.sort_order ASC, t.testcase_id ASC
-});
-
-Litmus::DB::Testcase->has_many(test_results => "Litmus::DB::Testresult", {order_by => 'submission_time DESC'});
-
-Litmus::DB::Testcase->has_many(subgroups => 
-	["Litmus::DB::TestcaseSubgroup" => 'subgroup']);
-
-#########################################################################
-# is_completed($$$$$)
-#
-# Check whether we have test results for the current test that correspond
-# to the provided platform, build_id, and user(optional).
-#########################################################################
-memoize('is_completed');
-sub is_completed {
-  my $self = shift;
-  my $platform = shift;
-  my $build_id = shift;
-  my $locale = shift;
-  my $user = shift;        # optional
-
-  my @results;
-  if ($user) {
-    @results = Litmus::DB::Testresult->search_CompletedByUser(
-                                                              $self->{'testcase_id'},
-                                                              $build_id,
-                                                              $locale->{'abbrev'},
-                                                              $platform->{'platform_id'},
-                                                              $user->{'user_id'},
-                                                             );
-  } else {
-    @results = Litmus::DB::Testresult->search_Completed(
-                                                        $self->{'testcase_id'},
-                                                        $build_id,
-                                                        $locale->{'abbrev'},
-                                                        $platform->{'platform_id'},
-                                                       );
-  }
-
-  return @results;
-}
-
-#########################################################################
-sub getFullTextMatches() {
-  my $self = shift;
-  my $text_snippet = shift;
-  my $match_limit = shift;
-  my $relevance_threshold = shift;
-  
-  if (!$match_limit) {
-    $match_limit = $default_match_limit;
-  }
-  if (!$relevance_threshold) {
-    $relevance_threshold = $default_relevance_threshold
-  }
-  
-  __PACKAGE__->set_sql(FullTextMatches => qq{
-                                             SELECT testcase_id, summary, creation_date, last_updated, MATCH (summary,steps,expected_results) AGAINST (?) AS relevance
-					     FROM testcases
-					     WHERE MATCH (summary,steps,expected_results) AGAINST (?) HAVING relevance > ?
-					     ORDER BY relevance DESC, summary ASC
-                                             LIMIT $match_limit
-});
-  
-  
-  return $self->search_FullTextMatches(
-                                       $text_snippet,
-                                       $text_snippet,
-                                       $relevance_threshold
-                                      );
-}
-
-#########################################################################
-sub getNewTestcases() {
-  my $self = shift;
-  my $num_days = shift;
-  my $match_limit = shift;
-  
-  if (!$num_days) {
-    $num_days = $default_num_days;
-  }
-  
-  if (!$match_limit) {
-    $match_limit = $default_match_limit;
-  }
-  
-  __PACKAGE__->set_sql(NewTestcases => qq{
-				          SELECT testcase_id, summary, creation_date, last_updated
-                                          FROM testcases
-                                          WHERE creation_date>=?
-                                          ORDER BY creation_date DESC
-                                          LIMIT $match_limit
-});
-  
-  my $err;
-  my $new_datestamp=&UnixDate(DateCalc("now","- $num_days days"),"%q");
-  return $self->search_NewTestcases($new_datestamp);
-}
-
-#########################################################################
-sub getRecentlyUpdated() {
-  my $self = shift;
-  my $num_days = shift;
-  my $match_limit = shift;
-  
-  if (!$num_days) {
-    $num_days = $default_num_days;
-  }
-  
-  if (!$match_limit) {
-    $match_limit = $default_match_limit;
-  }
-  
-  __PACKAGE__->set_sql(RecentlyUpdated => qq{
-                                             SELECT testcase_id, summary, creation_date, last_updated
-                                             FROM testcases
-                                             WHERE last_updated>=? AND last_updated>creation_date
-                                             ORDER BY last_updated DESC
-                                             LIMIT $match_limit
-});
-  
-  my $err;
-  my $new_datestamp=&UnixDate(DateCalc("now","- $num_days days"),"%q");
-  return $self->search_RecentlyUpdated($new_datestamp);
-}
-
-#########################################################################
-sub getDefaultMatchLimit() {
-  return $default_match_limit;
-}
-
-#########################################################################
-sub getDefaultRelevanceThreshold() {
-  return $default_relevance_threshold;
-}
-
-#########################################################################
-sub getDefaultNumDays() {
-  return $default_num_days;
-}
-
-#########################################################################
-sub clone() {
-  my $self = shift;
-  
-  my $new_testcase = $self->copy;
-  if (!$new_testcase) {
-    return undef;
-  }
-  
-  # Update dates to now.
-  my $now = &UnixDate("today","%q");
-  $new_testcase->creation_date($now);
-  $new_testcase->last_updated($now);
-  $new_testcase->update();
-  
-  # Propagate subgroup membership;
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "INSERT INTO testcase_subgroups (testcase_id,subgroup_id,sort_order) SELECT ?,subgroup_id,sort_order FROM testcase_subgroups WHERE testcase_id=?";
-  
-  my $rows = $dbh->do($sql,
-		      undef,
-		      $new_testcase->testcase_id,
-		      $self->testcase_id
-		     );
-  if (! $rows) {
-    # XXX: Do we need to throw a warning here?
-    # What happens when we clone a testcase that doesn't belong to
-    # any subgroups?
-  }
-  
-  $sql = "INSERT INTO related_testcases (testcase_id, related_testcase_id) VALUES (?,?)";
-  $rows = $dbh->do($sql, 
-                   undef,
-                   $self->testcase_id,
-                   $new_testcase->testcase_id
-                  );
-  if (! $rows) {
-    # XXX: Do we need to throw a warning here?
-  }
-  
-  return $new_testcase;
-}
-
-#########################################################################
-sub delete_from_subgroups() {
-  my $self = shift;
-  
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "DELETE from testcase_subgroups WHERE testcase_id=?";
-  return $dbh->do($sql,
-                  undef,
-                  $self->testcase_id
-                 );
-}
-
-#########################################################################
-sub delete_from_subgroup() {
-  my $self = shift;
-  my $subgroup_id = shift;  
-
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "DELETE from testcase_subgroups WHERE testcase_id=? AND subgroup_id=?";
-  return $dbh->do($sql,
-                  undef,
-                  $self->testcase_id,
-                  $subgroup_id
-                 );
-}
-
-#########################################################################
-sub delete_from_related() {
-  my $self = shift;
-  
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "DELETE from related_testcases WHERE testcase_id=? OR related_testcase_id=?";
-  return $dbh->do($sql,
-                  undef,
-                  $self->testcase_id,
-                  $self->testcase_id
-                 );
-}
-
-#########################################################################
-sub delete_with_refs() {
-  my $self = shift;
-  $self->delete_from_subgroups();
-  $self->delete_from_related();
-  return $self->delete;
-}
-
-#########################################################################
-sub update_subgroups() {
-  my $self = shift;
-  my $new_subgroup_ids = shift;
-  
-  if (scalar @$new_subgroup_ids) {
-    # Failing to delete subgroups is _not_ fatal when adding a new testcase.
-    my $rv = $self->delete_from_subgroups();
-    my $dbh = __PACKAGE__->db_Main();
-    my $sql = "INSERT INTO testcase_subgroups (testcase_id,subgroup_id,sort_order) VALUES (?,?,1)";
-    foreach my $new_subgroup_id (@$new_subgroup_ids) {
-      my $rows = $dbh->do($sql, 
-			  undef,
-			  $self->testcase_id,
-			  $new_subgroup_id
-			 );
-    }
-  }
-}
-
-#########################################################################
-sub update_subgroup() {
-  my $self = shift;
-  my $subgroup_id = shift;
-  my $sort_order = shift;
-
-  # Sort order defaults to 1.
-  if (!$sort_order) {
-    $sort_order = 1;
-  }
-  
-  my $rv = $self->delete_from_subgroup($subgroup_id);
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "INSERT INTO testcase_subgroups (testcase_id,subgroup_id,sort_order) VALUES (?,?,?)";
-  return $dbh->do($sql, 
-                  undef,
-                  $self->testcase_id,
-                  $subgroup_id,
-                  $sort_order
-                 );
-}
-
-1;
-
-
-
-
-
-
-
-
-

mozilla/webtools/litmus/Litmus/DB/TestcaseSubgroup.pm

@@ -1,49 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::TestcaseSubgroup;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::TestcaseSubgroup->table('testcase_subgroups');
-
-Litmus::DB::TestcaseSubgroup->columns(All => qw/testcase_id subgroup_id/);
-
-Litmus::DB::TestcaseSubgroup->has_a(testcase_id => "Litmus::DB::Testcase");
-Litmus::DB::TestcaseSubgroup->has_a(subgroup_id => "Litmus::DB::Subgroup");
-
-Litmus::DB::TestcaseSubgroup->column_alias("testcase_id", "testcase");
-Litmus::DB::TestcaseSubgroup->column_alias("testcase_id", "test");
-Litmus::DB::TestcaseSubgroup->column_alias("subgroup_id", "subgroup");
-
-1;

mozilla/webtools/litmus/Litmus/DB/Testgroup.pm

@@ -1,260 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Testgroup;
-
-use strict;
-use base 'Litmus::DBI';
-
-Litmus::DB::Testgroup->table('testgroups');
-
-Litmus::DB::Testgroup->columns(All => qw/testgroup_id product_id name enabled testrunner_plan_id/);
-Litmus::DB::Testgroup->columns(Essential => qw/testgroup_id product_id name enabled testrunner_plan_id/);
-
-Litmus::DB::Testgroup->column_alias("product_id", "product");
-
-Litmus::DB::Testgroup->has_a(product => "Litmus::DB::Product");
-
-__PACKAGE__->set_sql(EnabledByBranch => qq{
-                                           SELECT tg.* 
-                                           FROM testgroups tg, testgroup_branches tgb
-                                           WHERE tgb.branch_id=? AND tgb.testgroup_id=tg.testgroup_id AND tg.enabled=1 ORDER by tg.name ASC
-});
-
-__PACKAGE__->set_sql(ByBranch => qq{
-                                    SELECT tg.* 
-                                    FROM testgroups tg, testgroup_branches tgb
-                                    WHERE tgb.branch_id=? AND tgb.testgroup_id=tg.testgroup_id ORDER by tg.name ASC
-});
-
-__PACKAGE__->set_sql(EnabledBySubgroup => qq{
-                                             SELECT tg.* 
-                                             FROM testgroups tg, subgroup_testgroups sgtg
-                                             WHERE sgtg.subgroup_id=? AND sgtg.testgroup_id=tg.testgroup_id AND tg.enabled=1 ORDER by tg.name ASC
-});
-
-__PACKAGE__->set_sql(BySubgroup => qq{
-                                      SELECT tg.* 
-                                      FROM testgroups tg, subgroup_testgroups sgtg
-                                      WHERE sgtg.subgroup_id=? AND sgtg.testgroup_id=tg.testgroup_id ORDER by tg.name ASC
-});
-
-__PACKAGE__->set_sql(EnabledByTestcase => qq{
-                                             SELECT tg.* 
-                                             FROM testgroups tg, subgroup_testgroups sgtg, testcase_subgroups tcsg
-                                             WHERE tcsg.testcase_id=? AND tcsg.subgroup_id=sgtg.subgroup_id AND sgtg.testgroup_id=tg.testgroup_id AND tg.enabled=1 ORDER by tg.name ASC
-});
-
-__PACKAGE__->set_sql(ByTestcase => qq{
-                                      SELECT tg.* 
-                                      FROM testgroups tg, subgroup_testgroups sgtg, testcase_subgroups tcsg
-                                      WHERE tcsg.testcase_id=? AND tcsg.subgroup_id=sgtg.subgroup_id AND sgtg.testgroup_id=tg.testgroup_id ORDER by tg.name ASC
-});
-
-#########################################################################
-sub coverage {
-  my $self = shift;
-  my $platform = shift;
-  my $build_id = shift;
-  my $locale = shift;
-  my $community_only = shift;
-  my $user = shift;
-
-  my $percent_completed = 0;
-
-  my @subgroups = Litmus::DB::Subgroup->search_EnabledByTestgroup($self->testgroup_id);
-  my $num_empty_subgroups = 0;
-  foreach my $subgroup (@subgroups) {
-    my $subgroup_percent = $subgroup->coverage(
-                                               $platform, 
-                                               $build_id, 
-                                               $locale,
-                                               $community_only,
-                                               $user,
-                                              );
-    if ($subgroup_percent eq "N/A") {
-      $num_empty_subgroups++;
-    } else {
-      $percent_completed += $subgroup_percent;
-    }
-  }
-  
-  if (scalar(@subgroups) - $num_empty_subgroups == 0) { 
-    return "N/A"
-  }
-  my $total_percentage = $percent_completed / 
-    (scalar @subgroups - $num_empty_subgroups);
-  
-  return sprintf("%d",$total_percentage);
-}
-
-#########################################################################
-sub clone() {
-  my $self = shift;
-
-  my $new_testgroup = $self->copy;
-  if (!$new_testgroup) {
-    return undef;
-  }
-
-  # Propagate testgroup membership;
-  my $dbh = __PACKAGE__->db_Main();
-  my $sql = "INSERT INTO subgroup_testgroups (subgroup_id,testgroup_id,sort_order) SELECT subgroup_id,?,sort_order FROM subgroup_testgroups WHERE testgroup_id=?";
-
-  my $rows = $dbh->do($sql,
-		      undef,
-		      $new_testgroup->testgroup_id,
-		      $self->testgroup_id
-		     );
-  if (! $rows) {
-    # XXX: Do we need to throw a warning here?
-  }  
-
-  return $new_testgroup;
-}
-
-#########################################################################
-sub delete_from_subgroups() {
-  my $self = shift;
-
-  my $dbh = __PACKAGE__->db_Main();  
-  my $sql = "DELETE from subgroup_testgroups WHERE testgroup_id=?";
-  my $rows = $dbh->do($sql,
-                      undef,
-                      $self->testgroup_id
-                     );
-}
-
-#########################################################################
-sub delete_from_test_runs() {
-  my $self = shift;
-
-  # XXX: Placeholder for test runs.
-  return;
-}
-
-#########################################################################
-sub delete_with_refs() {
-  my $self = shift;
-  $self->delete_from_subgroups();
-  $self->delete_from_test_runs();
-  return $self->delete;
-}
-
-#########################################################################
-sub update_subgroups() {
-  my $self = shift;
-  my $new_subgroup_ids = shift;
-  
-  if (scalar @$new_subgroup_ids) {
-    # Failing to delete subgroups is _not_ fatal when adding a new testgroup.
-    my $rv = $self->delete_from_subgroups();
-    my $dbh = __PACKAGE__->db_Main();  
-    my $sql = "INSERT INTO subgroup_testgroups (subgroup_id,testgroup_id,sort_order) VALUES (?,?,?)";
-    my $sort_order = 1;
-    foreach my $new_subgroup_id (@$new_subgroup_ids) {
-      next if (!$new_subgroup_id);
-      # Log any failures/duplicate keys to STDERR.
-      eval {
-        my $rows = $dbh->do($sql, 
-                            undef,
-                            $new_subgroup_id,
-                            $self->testgroup_id,
-                            $sort_order
-                           );
-      };
-      if ($@) {
-        print STDERR $@;
-      }
-      $sort_order++;
-    }
-  }
-}
-
-#########################################################################
-sub update_branches() {
-  my $self = shift;
-  my $new_branch_ids = shift;
-  
-  if (scalar @$new_branch_ids) {
-    # Failing to delete branches is _not_ fatal when adding a new testgroup.
-    my $rv = $self->delete_from_branches();
-    my $dbh = __PACKAGE__->db_Main();  
-    my $sql = "INSERT INTO testgroup_branches (testgroup_id,branch_id) VALUES (?,?)";
-    foreach my $new_branch_id (@$new_branch_ids) {
-      next if (!$new_branch_id);
-      # Log any failures/duplicate keys to STDERR.
-      eval {
-        my $rows = $dbh->do($sql, 
-                            undef,
-                            $self->testgroup_id,
-                            $new_branch_id,
-                           );
-      };
-      if ($@) {
-        print STDERR $@;
-      }
-    }
-  }
-}
-
-#########################################################################
-sub add_branch() {
-  my $self = shift;
-  my $new_branch_id = shift;
-  
-  # Failure to insert isn't fatal in the case of a collision, but we do want
-  # to log it.
-  my $dbh = __PACKAGE__->db_Main();  
-  my $sql = "INSERT INTO testgroup_branches (testgroup_id,branch_id) VALUES (?,?)";
-  # Log any failures/duplicate keys to STDERR.
-  eval {
-    my $rows = $dbh->do($sql, 
-                        undef,
-                        $self->testgroup_id,
-                        $new_branch_id,
-                       );
-  };
-  if ($@) {
-    print STDERR $@;
-  }
-}
-
-1;
-
-
-
-
-
-
-
-

mozilla/webtools/litmus/Litmus/DB/Testresult.pm

@@ -1,390 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::Testresult;
-
-use strict;
-use base 'Litmus::DBI';
-
-use Date::Manip;
-use Time::Piece;
-use Time::Seconds;
-use Memoize;
-
-our $_num_results_default = 15;
-
-Litmus::DB::Testresult->table('test_results');
-
-Litmus::DB::Testresult->columns(All => qw/testresult_id testcase_id last_updated submission_time user_id opsys_id branch_id build_id user_agent result_status_id build_type_id machine_name exit_status_id duration_ms talkback_id valid vetted validated_by_user_id vetted_by_user_id validated_timestamp vetted_timestamp locale_abbrev is_automated_result/);
-
-Litmus::DB::Testresult->column_alias("testcase_id", "testcase");
-Litmus::DB::Testresult->column_alias("submission_time", "timestamp");
-Litmus::DB::Testresult->column_alias("user_id", "user");
-Litmus::DB::Testresult->column_alias("opsys_id", "opsys");
-Litmus::DB::Testresult->column_alias("branch_id", "branch");
-Litmus::DB::Testresult->column_alias("user_agent", "useragent");
-Litmus::DB::Testresult->column_alias("result_status_id", "result_status");
-Litmus::DB::Testresult->column_alias("build_type_id", "build_type");
-Litmus::DB::Testresult->column_alias("exit_status_id", "exit_status");
-Litmus::DB::Testresult->column_alias("validity_id", "validity");
-Litmus::DB::Testresult->column_alias("vetting_status_id", "vetting_status");
-Litmus::DB::Testresult->column_alias("locale_abbrev", "locale");
-Litmus::DB::Testresult->column_alias("is_automated_result", "isAutomated");
-
-Litmus::DB::Testresult->has_a(opsys => "Litmus::DB::Opsys");
-Litmus::DB::Testresult->has_a(branch => "Litmus::DB::Branch");
-Litmus::DB::Testresult->has_a(testcase => "Litmus::DB::Testcase");
-Litmus::DB::Testresult->has_a(result_status => "Litmus::DB::ResultStatus");
-Litmus::DB::Testresult->has_a(user => "Litmus::DB::User");
-Litmus::DB::Testresult->has_a(useragent => "Litmus::UserAgentDetect");
-Litmus::DB::Testresult->has_a(build_type => "Litmus::DB::BuildType");
-Litmus::DB::Testresult->has_a(exit_status => "Litmus::DB::ExitStatus");
-Litmus::DB::Testresult->has_a(locale => "Litmus::DB::Locale");
-Litmus::DB::Testresult->has_a(platform => 
-                              [ "Litmus::DB::Opsys" => "platform" ]);
-
-Litmus::DB::Testresult->has_many(logs => 
-						  ["Litmus::DB::LogTestresult" => 'log_id']);
-Litmus::DB::Testresult->has_many(comments => "Litmus::DB::Comment", {order_by => 'comment_id ASC, submission_time ASC'});
-Litmus::DB::Testresult->has_many(bugs => "Litmus::DB::Resultbug", {order_by => 'bug_id ASC, submission_time DESC'});
-
-Litmus::DB::Testresult->autoinflate(dates => 'Time::Piece');
-
-Litmus::DB::Testresult->set_sql(DefaultTestResults => qq{
-    SELECT tr.testresult_id,tr.testcase_id,t.summary,tr.submission_time AS created,p.name AS platform_name,pr.name as product_name,trsl.name AS result_status,trsl.class_name result_status_class,b.name AS branch_name,tg.name AS test_group_name, tr.locale_abbrev, u.email
-    FROM test_results tr, testcases t, platforms p, opsyses o, branches b, products pr, test_result_status_lookup trsl, testgroups tg, subgroups sg, users u, testcase_subgroups tcsg, subgroup_testgroups sgtg
-    WHERE tr.testcase_id=t.testcase_id AND tr.opsys_id=o.opsys_id AND o.platform_id=p.platform_id AND tr.branch_id=b.branch_id AND b.product_id=pr.product_id AND tr.result_status_id=trsl.result_status_id AND tcsg.testcase_id=tr.testcase_id AND tcsg.subgroup_id=sg.subgroup_id AND sg.subgroup_id=sgtg.subgroup_id AND sgtg.testgroup_id=tg.testgroup_id AND tr.user_id=u.user_id AND tr.valid=1
-    ORDER BY tr.submission_time DESC, t.testcase_id DESC
-    LIMIT $_num_results_default 
-});
-
-Litmus::DB::Testresult->set_sql(CommonResults => qq{ 
-    SELECT COUNT(tr.testcase_id) AS num_results, tr.testcase_id, t.summary, MAX(tr.submission_time) AS most_recent, MAX(tr.testresult_id) AS max_id 
-    FROM test_results tr, testcases t, test_result_status_lookup trsl 
-    WHERE tr.testcase_id=t.testcase_id AND tr.result_status_id=trsl.result_status_id AND trsl.class_name=? 
-    GROUP BY tr.testcase_id 
-    ORDER BY num_results DESC, tr.testresult_id DESC 
-    LIMIT 15
-    });
-
-Litmus::DB::Testresult->set_sql(Completed => qq{
-    SELECT tr.* 
-    FROM test_results tr, opsyses o
-    WHERE tr.testcase_id=? AND 
-        tr.build_id=? AND 
-        tr.locale_abbrev=? AND
-        tr.opsys_id=o.opsys_id AND
-        o.platform_id=?
-    ORDER BY tr.submission_time DESC
-});
-
-Litmus::DB::Testresult->set_sql(CompletedByUser => qq{
-    SELECT tr.* 
-    FROM test_results tr, opsyses o
-    WHERE tr.testcase_id=? AND 
-        tr.build_id=? AND 
-        tr.locale_abbrev=? AND
-        tr.opsys_id=o.opsys_id AND
-        o.platform_id=? AND
-        tr.user_id=?
-    ORDER BY tr.submission_time DESC
-});
-
-#########################################################################
-# for historical reasons, note() is a shorthand way of saying "the text of 
-# the first comment on this result if that comment was submitted by the 
-# result submitter"
-#########################################################################
-sub note {
-    my $self = shift;
-    
-    my @comments = $self->comments();
-    
-    if (@comments && $comments[0] &&
-        $comments[0]->user() == $self->user()) {
-        return $comments[0]->comment();
-    } else {
-        return undef;
-    }
-}
-
-#########################################################################
-# is this test result from a trusted user?
-#########################################################################
-sub istrusted {
-  my $self = shift; 
-  
-   if ($self->user()->istrusted()) {
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-#########################################################################
-# &getDefaultTestResults($)
-#
-#########################################################################
-sub getDefaultTestResults($) {
-    my $self = shift;
-    my @rows = $self->search_DefaultTestResults();
-    my $criteria = "Default<br/>Ordered by Created<br/>Limit to $_num_results_default results";
-    return $criteria, \@rows;
-}
-
-#########################################################################
-# &getTestResults($\@\@$)
-# 
-######################################################################### 
-sub getTestResults($\@\@$) {
-    my ($self,$where_criteria,$order_by_criteria,$limit_value) = @_;
-    
-    my $select = 'SELECT tr.testresult_id,tr.testcase_id,t.summary,tr.submission_time AS created,p.name AS platform_name,pr.name as product_name,trsl.name AS result_status,trsl.class_name AS result_status_class,b.name AS branch_name,tg.name AS test_group_name, tr.locale_abbrev, u.email';
-    
-    my $from = 'FROM test_results tr, testcases t, platforms p, opsyses o, branches b, products pr, test_result_status_lookup trsl, testgroups tg, subgroups sg, users u, testcase_subgroups tcsg, subgroup_testgroups sgtg';
-    
-    my $where = 'WHERE tr.testcase_id=t.testcase_id AND tr.opsys_id=o.opsys_id AND o.platform_id=p.platform_id AND tr.branch_id=b.branch_id AND b.product_id=pr.product_id AND tr.result_status_id=trsl.result_status_id AND tcsg.testcase_id=tr.testcase_id AND tcsg.subgroup_id=sg.subgroup_id AND sg.subgroup_id=sgtg.subgroup_id AND sgtg.testgroup_id=tg.testgroup_id AND tr.user_id=u.user_id AND tr.valid=1';
-    
-    my $limit = 'LIMIT ';
-
-    foreach my $criterion (@$where_criteria) {
-         $criterion->{'value'} =~ s/'/\'/g;
-        if ($criterion->{'field'} eq 'branch') {
-            $where .= " AND b.name='" . $criterion->{'value'} . "'";
-        } elsif ($criterion->{'field'} eq 'locale') {
-            $where .= " AND tr.locale_abbrev='" . $criterion->{'value'} . "'";
-        } elsif ($criterion->{'field'} eq 'product') {
-            $where .= " AND pr.name='" . $criterion->{'value'} . "'";
-        } elsif ($criterion->{'field'} eq 'platform') {
-            $where .= " AND p.name='" . $criterion->{'value'} . "'";
-        } elsif ($criterion->{'field'} eq 'test_group') {
-            $where .= " AND tg.name='" . $criterion->{'value'} . "'";
-        } elsif ($criterion->{'field'} eq 'testcase_id') {
-            $where .= " AND tr.testcase_id='" . $criterion->{'value'} . "'";
-        } elsif ($criterion->{'field'} eq 'summary') {
-            $where .= ' AND t.summary LIKE \'%%' . $criterion->{'value'} . '%%\'';
-        } elsif ($criterion->{'field'} eq 'email') {
-            $where .= ' AND u.email LIKE \'%%' . $criterion->{'value'} . '%%\'';
-        } elsif ($criterion->{'field'} eq 'result_status') {
-            $where .= " AND trsl.class_name='" . $criterion->{'value'} . "'";
-        } elsif ($criterion->{'field'} eq 'trusted_only') {            
-            if ($from !~ /users u/) {
-                $from .= ", users u";
-            }
-            $where .= " AND u.user_id=tr.user_id AND u.is_admin=1";
-        } elsif ($criterion->{'field'} eq 'start_date') {
-            my $start_timestamp = &Date::Manip::UnixDate(&Date::Manip::ParseDateString($criterion->{'value'}),"%q");
-            if ($start_timestamp !~ /^\d\d\d\d\d\d\d\d\d\d\d\d\d\d$/) {
-                print STDERR "Unable to parse a valid start date from '$criterion->{'value'},' ignoring.\n";
-            } else {
-                $where .= " AND tr.submission_time>=$start_timestamp";
-            }
-        } elsif ($criterion->{'field'} eq 'end_date') {
-            my $end_timestamp = &Date::Manip::UnixDate(&Date::Manip::ParseDateString($criterion->{'value'}),"%q");
-            if ($end_timestamp !~ /^\d\d\d\d\d\d\d\d\d\d\d\d\d\d$/) {
-                print STDERR "Unable to parse a valid end date from '$criterion->{'value'},' ignoring.\n";
-            } else {
-                $where .= " AND tr.submission_time<=$end_timestamp";
-            }
-        } elsif ($criterion->{'field'} eq 'timespan') {
-            next if ($criterion->{'value'} eq 'all');
-            my $day_delta = $criterion->{'value'};
-            my $err;
-            my $timestamp = 
-                &Date::Manip::UnixDate(&Date::Manip::DateCalc("now",
-                                                              "$day_delta days",
-                                                              \$err),
-                                       "%q");
-            $where .= " AND tr.submission_time>=$timestamp";
-
-        } elsif ($criterion->{'field'} eq 'search_field') {
-            ($from,$where) = &_processSearchField($criterion,$from,$where);
-        } else {
-            # Skip unknown field
-        }
-    }
-
-    my $order_by = 'ORDER BY ';
-    foreach my $criterion (@$order_by_criteria) {
-        # Skip empty fields.
-        next if (!$criterion or !$criterion->{'field'});
-
-        if ($criterion->{'field'} eq 'created') {
-            $order_by .= "tr.submission_time $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'product') {
-            $order_by .= "pr.name $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'platform') {
-            $order_by .= "p.name $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'test_group') {
-            $order_by .= "tg.name $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'testcase_id') {
-            $order_by .= "tr.testcase_id $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'summary') {
-            $order_by .= "t.summary $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'result_status') {
-            $order_by .= "trsl.class_name $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'branch') {
-            $order_by .= "b.name $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'locale') {
-            $order_by .= "tr.locale_abbrev $criterion->{'direction'},";
-        } elsif ($criterion->{'field'} eq 'email') {
-            $order_by .= "u.email $criterion->{'direction'},";
-        } else {
-            # Skip unknown field
-        }
-    }
-    if ($order_by eq 'ORDER BY ') {
-        $order_by .= 'tr.submission_time DESC';
-    } else {
-        chop($order_by);
-    }
-
-    if ($limit_value and $limit_value ne '') {
-        $limit .= "$limit_value";
-    } else {
-        $limit .= "$_num_results_default";
-    }
-    
-    my $sql = "$select $from $where $order_by $limit";
-#print $sql,"<br/>\n";
-    Litmus::DB::Testresult->set_sql(TestResults => qq{
-        $sql
-        });
-
-    my @rows = $self->search_TestResults();
-    
-    return \@rows;
-}
-
-#########################################################################
-# &_processSearchField(\%\$\$)
-# 
-######################################################################### 
-sub _processSearchField(\%) {
-    my ($search_field,$from,$where) = @_;
- 
-    my $table_field = "";
-    if ($search_field->{'search_field'} eq 'build_id') {
-        $table_field='tr.build_id';
-    } elsif ($search_field->{'search_field'} eq 'comments') {
-        $table_field='c.comment';        
-    } elsif ($search_field->{'search_field'} eq 'locale') {
-        $table_field='tr.locale_abbrev';        
-    } elsif ($search_field->{'search_field'} eq 'opsys') {
-        $table_field='o.name';
-    } elsif ($search_field->{'search_field'} eq 'platform') {
-        $table_field='p.name';
-    } elsif ($search_field->{'search_field'} eq 'product') {
-        $table_field='pr.name';
-    } elsif ($search_field->{'search_field'} eq 'result_status') {
-        $table_field='trsl.name';        
-    } elsif ($search_field->{'search_field'} eq 'subgroup') {
-        $table_field='sg.name';        
-    } elsif ($search_field->{'search_field'} eq 'email') {
-        if ($from !~ /users u/) {
-            $from .= ", users u";
-            $where .= " AND tr.user_id=u.user_id";
-        }
-        $table_field='u.email';        
-    } elsif ($search_field->{'search_field'} eq 'summary') {
-        $table_field='t.summary';
-    } elsif ($search_field->{'search_field'} eq 'test_group') {
-        $table_field='tg.name';        
-    } elsif ($search_field->{'search_field'} eq 'user_agent') {
-        $table_field='tr.user_agent';        
-    } else {
-        return ($from,$where);
-    }
-
-    if ($search_field->{'match_criteria'} eq 'contains_all' or
-        $search_field->{'match_criteria'} eq 'contains_any' or
-        $search_field->{'match_criteria'} eq 'not_contain_any') {
-        
-        my $join = "";
-        if ($search_field->{'match_criteria'} eq 'contains_all') {
-            $join = 'AND';
-        } else {
-            $join = 'OR';
-        }
-
-        my @words = split(/ /,$search_field->{'value'});
-        if ($search_field->{'match_criteria'} eq 'not_contain_any') {
-            $where .= " AND NOT (";
-        } else {
-            $where .= " AND (";
-        }
-        my $first_pass = 1;
-        foreach my $word (@words) {
-            if ( $first_pass ) {
-                $where .= "UPPER($table_field) LIKE UPPER('%%" . $word . "%%')";
-                $first_pass = 0;
-            } else {
-                $where .= " $join UPPER($table_field) LIKE UPPER('%%" . $word . "%%')";
-            }
-        }
-        $where .= ")";        
-    } elsif ($search_field->{'match_criteria'} eq 'contains') {
-        $where .= " AND UPPER($table_field) LIKE UPPER('%%" . $search_field->{'value'} . "%%')";
-    } elsif ($search_field->{'match_criteria'} eq 'contains_case') {
-        $where .= " AND $table_field LIKE '%%" . $search_field->{'value'} . "%%'";
-    } elsif ($search_field->{'match_criteria'} eq 'not_contain') {
-        $where .= " AND UPPER($table_field) NOT LIKE UPPER('%%" . $search_field->{'value'} . "%%')";
-    } elsif ($search_field->{'match_criteria'} eq 'regexp') {
-        $where .= " AND $table_field REGEXP '" . $search_field->{'value'} . "'";        
-    } elsif ($search_field->{'match_criteria'} eq 'not_regexp') {        
-        $where .= " AND $table_field NOT REGEXP '" . $search_field->{'value'} . "'";        
-    } else {
-      # Ignore unknown match criteria.
-      return ($from,$where);
-    }
-
-    return ($from,$where);
-}
-
-#########################################################################
-#########################################################################
-sub getCommonResults($$) {
-    my ($self,$status,$limit_value) = @_;
-    
-    if (!$status) {
-      return undef;
-    }
-    
-    if (!$limit_value) {
-        $limit_value = $_num_results_default;
-    }
-
-    my @rows = $self->search_CommonResults($status);
-    return \@rows;    
-}
-
-1;

mozilla/webtools/litmus/Litmus/DB/User.pm

@@ -1,119 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DB::User;
-
-use strict;
-use Litmus::Config;
-use base 'Litmus::DBI';
-
-Litmus::DB::User->table('users');
-
-Litmus::DB::User->columns(All => qw/user_id bugzilla_uid email password realname irc_nickname enabled is_admin authtoken/);
-
-Litmus::DB::User->column_alias("is_trusted", "istrusted");
-Litmus::DB::User->column_alias("is_admin", "is_trusted");
-
-Litmus::DB::User->has_many(test_results => "Litmus::DB::Testresult");
-Litmus::DB::User->has_many(sessions => "Litmus::DB::Session");
-
-# ZLL: only load BugzillaUser if Bugzilla Auth is actually enabled
-if ($Litmus::Config::bugzilla_auth_enabled) {
-	Litmus::DB::User->has_a(bugzilla_uid => "Litmus::DB::BugzillaUser");
-}
-
-__PACKAGE__->set_sql(RetrieveAll => qq{
-                                       SELECT __ESSENTIAL__
-                                       FROM   __TABLE__
-                                       ORDER BY email ASC
-});
-
-__PACKAGE__->set_sql(TopTesters => qq{
-                                      SELECT users.user_id, users.email, count(*) AS num_results
-                                      FROM users, test_results
-                                      WHERE users.user_id=test_results.user_id
-                                      GROUP BY user_id
-                                      ORDER BY num_results DESC
-                                      LIMIT 15
-});
-
-# the COLLATE latin1_general_ci sillyness forces a case-insensitive match
-# removed a LIMIT 300 to work around a mysql bug in the ancient version
-# on rodan
-__PACKAGE__->set_sql(FullTextMatches => q{
-	SELECT *
-	FROM __TABLE__ 
-	WHERE 
-	  email COLLATE latin1_general_ci like concat('%%',?,'%%') OR 
-	  irc_nickname COLLATE latin1_general_ci  like concat('%%',?,'%%') OR 
-	  realname COLLATE latin1_general_ci like concat('%%',?,'%%') 
-	ORDER BY email ASC
-});
-
-
-
-#########################################################################
-# returns the crypt'd password from a linked Bugzilla account if it 
-# exists or the Litmus user account
-sub getRealPasswd {
-  my $self = shift;
-  if ($self->bugzilla_uid()) {
-    return $self->bugzilla_uid()->cryptpassword();
-  } else {
-    return $self->password();
-  }
-}
-
-#########################################################################
-sub getDisplayName() {
-  my $self = shift;
-  
-  return $self->irc_nickname if ($self->irc_nickname and
-                                 $self->irc_nickname ne '');
-  return $self->realname if ($self->realname and
-                             $self->realname ne '');
-  
-  if ($self->email and
-      $self->email ne '') {
-    my $display_name = $self->email;
-    $display_name =~ s/\@.*$//g;
-    return $display_name
-  }
-
-  return undef;
-}
-
-
-1;
-
-
-

mozilla/webtools/litmus/Litmus/DBI.pm

@@ -1,130 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::DBI;
-
-require Apache::DBI;
-use strict;
-use warnings;
-use Litmus::Config;
-use Memoize;
-
-use base 'Class::DBI::mysql';
-
-our $dsn = "dbi:mysql:database=$Litmus::Config::db_name;host=$Litmus::Config::db_host;port=3306";
-
-
-
-our %column_aliases;
-
-Litmus::DBI->connection( $dsn,
-                         $Litmus::Config::db_user,
-                         $Litmus::Config::db_pass,
-                         	{AutoCommit=>1}
-                         );
-Litmus::DBI->autoupdate(1);
-                         
-# In some cases, we have column names that make sense from a database perspective
-# (i.e. subgroup_id), but that don't make sense from a class/object perspective 
-# (where subgroup would be more appropriate). To handle this, we allow for 
-# Litmus::DBI's subclasses to set column aliases with the column_alias() sub. 
-# Takes the database column name and the alias name. 
-sub column_alias {
-    my ($self, $db_name, $alias_name) = @_;
-    
-    $column_aliases{$alias_name} = $db_name;
-}
-
-# here's where the actual work happens. We consult our alias list 
-# (as created by calls to column_alias()) and substitute the 
-# database column if we find a match
-memoize('find_column');
-sub find_column {
-    my $self = shift;
-    my $wanted = shift;
-    
-    if (ref $self) {
-        $wanted =~ s/^.*::(\w+)$/$1/;
-    }
-    if ($column_aliases{$wanted}) {
-        return $column_aliases{$wanted};
-    } else {
-        # not an alias, so we use the normal 
-        # find_column() from Class::DBI
-        $self->SUPER::find_column($wanted);
-    }
-}
-
-sub AUTOLOAD {
-    my $self = shift;
-    my @args = @_;
-    my $name = our $AUTOLOAD;
-    
-    my $col = $self->find_column($name);
-    if (!$col) {
-        internalError("tried to call Litmus::DBI method $name which does not exist");
-    }
-    
-    return $self->$col(@args);
-}
-        
-sub _croak {
-	my ($self, $message, %info) = @_;
-	internalError($message);
-	return;
-}
-
-# Get Class::DBI's default dbh options
-my $db_options = { __PACKAGE__->_default_attributes };
-
-__PACKAGE__->_remember_handle('Main'); # so dbi_commit works
-
-# override default to avoid using Ima::DBI closure
-sub db_Main {
-   my $dbh;
-   if ( $ENV{'MOD_PERL'} and !$Apache::ServerStarting ) {
-	   $dbh = Apache->request()->pnotes('dbh');
-   }
-   if ( !$dbh ) {
-	   $dbh = DBI->connect(
-		   $dsn,  $Litmus::Config::db_user,
-		   $Litmus::Config::db_pass, $db_options
-	   );
-	   if ( $ENV{'MOD_PERL'} and !$Apache::ServerStarting ) {
-		   Apache->request()->pnotes( 'dbh', $dbh );
-	   }
-   }
-   return $dbh;
-}
-
-1;
-

mozilla/webtools/litmus/Litmus/DBTools.pm

@@ -1,275 +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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
-
-# Utility functions (based on those from Bugzilla's checksetup.pl to 
-# create new fields and indicies to the schema when upgrading an installation.
-
-package Litmus::DBTools;
-
-use strict;
-
-#########################################################################
-sub new {
-	my ($class, $dbh) = @_;
-	my $self = {};
-	$self->{'dbh'} = $dbh;
-	bless($self);
-	return $self;
-}
-
-#########################################################################
-sub ChangeFieldType {
-    my ($self, $table, $field, $newtype) = @_;
-
-    my $ref = $self->GetFieldDef($table, $field);
-    #print "0: $$ref[0]   1: $$ref[1]   2: $$ref[2]   3: $$ref[3]  4: $$ref[4]\n";
-
-    my $oldtype = $ref->[1];
-    if (! $ref->[2]) {
-        $oldtype .= qq{ not null};
-    }
-    if ($ref->[4]) {
-        $oldtype .= qq{ default "$ref->[4]"};
-    }
-
-    if ($oldtype ne $newtype) {
-        print "Updating field type $field in table $table ...\n";
-        print "old: $oldtype\n";
-        print "new: $newtype\n";
-#        'not null' should be passed as part of the call to ChangeFieldType()
-#        $newtype .= " NOT NULL" if $$ref[3];
-        $self->{'dbh'}->do("ALTER TABLE $table
-                  CHANGE $field
-                  $field $newtype");
-    }
-}
-
-#########################################################################
-sub RenameTable {
-    my ($self, $table, $newname) = @_;
-
-    my $ref = $self->TableExists($table);
-    return unless $ref; # already renamed?
-
-    $self->{'dbh'}->do("ALTER TABLE $table
-                  RENAME TO $newname");
-}
-
-#########################################################################
-sub RenameField {
-    my ($self, $table, $field, $newname) = @_;
-
-    my $ref = $self->GetFieldDef($table, $field);
-    return unless $ref; # already fixed?
-    #print "0: $$ref[0]   1: $$ref[1]   2: $$ref[2]   3: $$ref[3]  4: $$ref[4]\n";
-
-    if ($$ref[1] ne $newname) {
-        print "Updating field $field in table $table ...\n";
-        my $type = $$ref[1];
-        $type .= " NOT NULL" if !$$ref[2];
-        $type .= " auto_increment" if $$ref[5] =~ /auto_increment/;
-        $self->{'dbh'}->do("ALTER TABLE $table
-                  CHANGE $field
-                  $newname $type");
-    }
-}
-
-#########################################################################
-sub AddField {
-    my ($self, $table, $field, $definition) = @_;
-
-    my $ref = $self->GetFieldDef($table, $field);
-    return if $ref; # already added?
-
-    print "Adding new field $field to table $table ...\n";
-    $self->{'dbh'}->do("ALTER TABLE $table
-              ADD COLUMN $field $definition");
-}
-
-#########################################################################
-sub AddKey {
-    my ($self, $table, $field, $definition) = @_;
-
-    my $ref = $self->GetIndexDef($table, $field);
-    return if $ref; # already added?
-
-    print "Adding new key $field to table $table ...\n";
-    $self->{'dbh'}->do("ALTER TABLE $table
-              ADD KEY $field $definition");
-}
-
-#########################################################################
-sub AddUniqueKey {
-    my ($self, $table, $field, $definition) = @_;
-
-    my $ref = $self->GetIndexDef($table, $field);
-    return if $ref; # already added?
-
-    print "Adding new key $field to table $table ...\n";
-    $self->{'dbh'}->do("ALTER TABLE $table
-              ADD UNIQUE KEY $field $definition");
-}
-
-#########################################################################
-sub AddFullText {
-    my ($self, $table, $index, $definition) = @_;
-
-    my $ref = $self->GetIndexDef($table, $index);
-    return if $ref; # already added?
-
-    print "Adding new fulltext $index to table $table ...\n";
-    $self->{'dbh'}->do("ALTER TABLE $table
-              ADD FULLTEXT $index $definition");
-}
-
-
-#########################################################################
-sub DropField {
-    my ($self, $table, $field) = @_;
-
-    my $ref = $self->GetFieldDef($table, $field);
-    return unless $ref; # already dropped?
-
-    print "Deleting unused field $field from table $table ...\n";
-    $self->{'dbh'}->do("ALTER TABLE $table
-              DROP COLUMN $field");
-}
-
-#########################################################################
-sub DropTable {
-    my ($self, $table, $field) = @_;
-
-    my $ref = $self->TableExists($table);
-    return unless $ref; # already dropped?
-
-    print "Deleting unused table $table ...\n";
-    $self->{'dbh'}->do("DROP TABLE $table");
-}
-
-#########################################################################
-# this uses a mysql specific command. 
-sub TableExists {
-   my ($self, $table) = @_;
-   my @tables;
-   my $dbtable;
-   my $exists = 0;
-   my $sth = $self->{'dbh'}->prepare("SHOW TABLES");
-   $sth->execute;
-   while ( ($dbtable) = $sth->fetchrow_array ) {
-      if ($dbtable eq $table) {
-         $exists = 1;
-      } 
-   } 
-   $sth->finish;
-   return $exists;
-} 
-
-#########################################################################
-sub GetFieldDef {
-    my ($self, $table, $field) = @_;
-    my $sth = $self->{'dbh'}->prepare("SHOW COLUMNS FROM $table");
-    $sth->execute;
-
-    while (my $ref = $sth->fetchrow_arrayref) {
-        next if $$ref[0] ne $field;
-        $sth->finish;
-        return $ref;
-   }
-}
-
-#########################################################################
-sub GetIndexDef {
-    my ($self, $table, $field) = @_;
-    my $sth = $self->{'dbh'}->prepare("SHOW INDEX FROM $table");
-    $sth->execute;
-
-    while (my $ref = $sth->fetchrow_arrayref) {
-        next if $$ref[2] ne $field;
-        $sth->finish;
-        return $ref;
-   }
-}
-
-#########################################################################
-sub CountIndexes {
-    my ($self, $table) = @_;
-    
-    my $sth = $self->{'dbh'}->prepare("SHOW INDEX FROM $table");
-    $sth->execute;
-
-    if ( $sth->rows == -1 ) {
-      $sth->finish;
-      die ("Unexpected response while counting indexes in $table:" .
-           " \$sth->rows == -1");
-    }
-    
-    my $rows = $sth->rows;
-    $sth->finish;
-    return ($rows);
-}
-
-#########################################################################
-sub DropIndex {
-    my ($self, $table, $index) = @_;
-
-    my $ref = $self->GetIndexDef($table, $index);
-    return unless $ref; # no matching index?
-
-	print "Removing index $index from table $table ...\n";
-    $self->{'dbh'}->do("ALTER TABLE $table
-                  DROP INDEX $index");
-}
-
-#########################################################################
-sub DropIndexes {
-    my ($self, $table) = @_;
-    my %SEEN;
-
-    # get the list of indexes
-    #
-    my $sth = $self->{'dbh'}->prepare("SHOW INDEX FROM $table");
-    $sth->execute;
-
-    # drop each index
-    #
-    while ( my $ref = $sth->fetchrow_arrayref) {
-      
-      # note that some indexes are described by multiple rows in the
-      # index table, so we may have already dropped the index described
-      # in the current row.
-      # 
-      next if exists $SEEN{$$ref[2]};
-
-      if ($$ref[2] eq 'PRIMARY') {
-          # The syntax for dropping a PRIMARY KEY is different
-          # from the normal DROP INDEX syntax.
-          $self->{'dbh'}->do("ALTER TABLE $table DROP PRIMARY KEY"); 
-      }
-      else {
-          $self->{'dbh'}->do("ALTER TABLE $table DROP INDEX $$ref[2]");
-      }
-      $SEEN{$$ref[2]} = 1;
-
-    }
-    $sth->finish;
-}
-
-1;

mozilla/webtools/litmus/Litmus/Error.pm

@@ -1,84 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-# General error reporting
-
-package Litmus::Error;
-
-use strict;
-
-our @ISA = qw(Exporter);
-@Litmus::Error::EXPORT = qw(
-	basicError
-    invalidInputError
-    internalError
-    lastDitchError
-);
-
-# just a general run of the mill error
-sub basicError {
-	my $message = shift;
-	_doError($message);
-	exit;
-}
-
-# used to alert the user when an unexpected input value is found
-sub invalidInputError($) {
-    my $message = shift;
-    _doError("Invalid Input - $message");
-    exit;
-}
-
-sub internalError($) {
-    my $message = shift;
-    _doError("Litmus has suffered an internal error - $message");
-    exit;
-}
-
-# an error type that does not use a template error message. Used if we 
-# can't even process the error template. 
-sub lastDitchError($) {
-    my $message = shift;
-    print "Error - Litmus has suffered a serious fatal internal error - $message";
-    exit;
-}
-
-sub _doError($) {
-    my $message = shift;
-    my $vars = {
-        message => $message,
-    };
-    Litmus->template()->process("error/error.html.tmpl", $vars) || 
-         lastDitchError(Litmus->template()->error());
-}
-
-1;

mozilla/webtools/litmus/Litmus/FormWidget.pm

@@ -1,342 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::FormWidget;
-use strict;
-
-BEGIN {
-    use Exporter ();
-    use vars qw ($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
-    $VERSION     = 0.01;
-    @ISA         = qw (Exporter);
-    #Give a hoot don't pollute, do not export more than needed by default
-    @EXPORT      = qw ( getProducts );
-    @EXPORT_OK   = qw ();
-    %EXPORT_TAGS = ();
-}
-
-use DBI;
-use Litmus::DBI;
-
-our $_dbh = Litmus::DBI->db_Main();
-
-#########################################################################
-=head1 NAME
-
-Litmus::FormWidget - Create value lists to be used in HTML forms
-
-=head1 SYNOPSIS
-
-  use Litmus::FormWidget
-
-=head1 DESCRIPTION
-
-Litmus::FormWidget creates value lists to be used in HTML forms.
-
-=head1 USAGE
-
-
-=head1 BUGS
-
-
-
-=head1 SUPPORT
-
-
-
-=head1 AUTHOR
-
-    Chris Cooper
-    CPAN ID: CCOOPER
-    Mozilla Corporation
-    ccooper@deadsquid.com
-    http://litmus.mozilla.org/
-
-=head1 SEE ALSO
-
-perl(1).
-
-=cut
-
-#########################################################################
-
-#sub new
-#{
-#    my ($class, %parameters) = @_;
-#    my $self = bless ({}, ref ($class) || $class);
-#    return ($self);
-#}
-
-#########################################################################
-
-=head2 getProducts
-
- Usage     : How to use this function/method
- Purpose   : What it does
- Returns   : What it returns
- Argument  : What it wants to know
- Throws    : Exceptions and other anomolies
- Comments  : This is a sample subroutine header.
-           : It is polite to include more pod and fewer comments.
-
-See Also   : 
-
-=cut
-
-#########################################################################
-sub getProducts()
-{
-    my $sql = "SELECT name, product_id FROM products ORDER BY name";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getUniquePlatforms()
-{
-    my $sql = "SELECT DISTINCT(name), platform_id FROM platforms ORDER BY name";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getPlatforms()
-{
-    my $sql = "SELECT platform_id, name from platforms ORDER BY name ASC";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getBranches()
-{
-    my $sql = "SELECT name, branch_id FROM branches ORDER BY name ASC";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getUniqueBranches()
-{
-    my $sql = "SELECT DISTINCT(name) FROM branches ORDER BY name ASC";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getOpsyses()
-{
-    my $sql = "SELECT name, opsys_id FROM opsyses ORDER BY name ASC";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getUniqueOpsyses()
-{
-    my $sql = "SELECT DISTINCT(name) FROM opsyses ORDER BY name ASC";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getLogTypes()
-{
-    my $sql = "SELECT DISTINCT(name) FROM log_type_lookup ORDER BY name";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getTestStatuses()
-{
-    my @TestStatuses = ({name => 'Enabled'},
-                        {name => 'Disabled'});
-    return \@TestStatuses;
-}
-
-#########################################################################
-sub getResultStatuses()
-{
-    my $sql = "SELECT result_status_id,class_name FROM test_result_status_lookup ORDER BY result_status_id";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getTestcaseIDs()
-{
-    my $sql = "SELECT testcase_id FROM testcases ORDER BY testcase_id";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getTestcases()
-{
-    my $sql = "SELECT testcase_id, summary, product_id FROM testcases ORDER BY testcase_id";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getSubgroups()
-{
-    my $sql = "SELECT subgroup_id, name, product_id FROM subgroups ORDER BY name, subgroup_id";
-    return _getValues($sql);
-}
-
-#########################################################################
-sub getTestgroups()
-{
-    my $sql = "SELECT testgroup_id, name, product_id FROM testgroups ORDER BY name, testgroup_id";
-    return _getValues($sql);
-}
-
-
-#########################################################################
-sub getLocales()
-{
-  my @locales = Litmus::DB::Locale->retrieve_all();
-  return \@locales;
-}
-
-#########################################################################
-sub getUsers()
-{
-  my @users = Litmus::DB::User->retrieve_all();
-  return \@users;
-}
-
-#########################################################################
-sub getAuthors()
-{
-  my $sql = "SELECT user_id, email FROM users WHERE is_admin=1 ORDER BY email";
-  return _getValues($sql);
-}
-
-
-
-#########################################################################
-sub getFields()
-{
-    my @fields = (
-                  { name => 'build_id',
-                    display_string => "Build ID", },
-                  { name => 'comment',
-                    display_string => "Comments", }, 
-                  { name => 'locale',
-                    display_string => "Locale", }, 
-                  { name => 'opsys',
-                    display_string => "Operating System", }, 
-                  { name => 'platform',
-                    display_string => "Platform", }, 
-                  { name => 'product',
-                    display_string => "Product", },
-                  { name => 'result_status',
-                    display_string => "Result Status", },
-                  { name => 'subgroup',
-                    display_string => "Subgroup", },
-                  { name => 'email',
-                    display_string => "Submitted By", },
-                  { name => 'summary',
-                    display_string => "Summary", }, 
-                  { name => 'testgroup',
-                    display_string => "Testgroup", },
-                  { name => 'user_agent',
-                    display_string => "User Agent", },
-                  );
-    return \@fields;
-}
-
-#########################################################################
-sub getMatchCriteria()
-{
-    my @match_criteria = (
-                          { name => "contains_all",
-                            display_string => "contains all of the words/strings" },
-                          { name => "contains_any",
-                            display_string => "contains any of the words/strings" },
-                          { name => "contains",
-                            display_string => "contains the word/string" },
-                          { name => "contains_case",
-                            display_string => "contains the word/string (exact case)" },
-                          { name => "not_contain",
-                            display_string => "does not contains the word/string" },
-                          { name => "not_contain_any",
-                            display_string => "does not contains any of the words/string" },
-                          { name => "regexp",
-                            display_string => "matches the regexp" },
-                          { name => "not_regexp",
-                            display_string => "does not match the regexp" },
-                          );
-    return \@match_criteria;
-}
-
-#########################################################################
-sub getSortFields()
-{
-    my @sort_fields = (
-                       { name => "branch", 
-                         display_string => "Branch"},
-                       { name => "created", 
-                         display_string => "Date"},
-                       { name => "locale", 
-                         display_string => "Locale"},
-                       { name => "platform", 
-                         display_string => "Platform"},
-                       { name => "product", 
-                         display_string => "Product"},
-                       { name => "email", 
-                         display_string => "Submitted By"},
-                       { name => "summary", 
-                         display_string => "Summary"},
-                       { name => "result_status", 
-                         display_string => "Status"},
-                       { name => "testcase_id", 
-                         display_string => "Testcase ID#"},
-                       { name => "testgroup", 
-                         display_string => "Testgroup"},
-                       );
-    return \@sort_fields;
-}
-
-#########################################################################
-sub _getValues($)
-{
-    my ($sql) = @_;
-    my $sth = $_dbh->prepare_cached($sql);
-    $sth->execute();
-    my @rows;
-    while (my $data = $sth->fetchrow_hashref) {
-    push @rows, $data;
-    }
-    return \@rows;
-    $sth->finish();
-}
-
-1; 
-
-
-
-
-
-

mozilla/webtools/litmus/Litmus/StripScripts.pm

@@ -1,43 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::StripScripts;
-use base qw(HTML::StripScripts::Parser);
-    
-# Override broken href validation code.
-sub validate_href_attribute {
-  my ($self, $text) = @_;
-  
-  $self->SUPER::validate_href_attribute or $text =~ m<^((https?|ftp|mailto)://[\w\-\.]{1,100}(?:\:\d{1,5})?(?:/(?:[\w\-.!~*|;:/?=+\$\,%#]|&amp;){0,100})?)$>x ? $1 : undef;
-} 
-
-1;

mozilla/webtools/litmus/Litmus/SysConfig.pm

@@ -1,263 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::SysConfig;
-
-use strict;
-
-require Exporter;
-use Litmus;
-use Litmus::DB::Locale;
-use Litmus::DB::Product;
-use Litmus::Error;
-use Litmus::Utils;
-use CGI;
-
-our @ISA = qw(Exporter);
-our @EXPORT = qw();
-
-my $configcookiename = $Litmus::Config::sysconfig_cookiename;
-
-sub new {
-    my ($class, $product, $platform, $opsys, $branch, $build_id, $locale) = @_;
-
-    my $self = {};
-    bless($self);
-    
-    $self->{"product"}  = $product;
-    $self->{"platform"} = $platform;
-    $self->{"opsys"}    = $opsys;
-    $self->{"branch"}   = $branch;
-    $self->{"build_id"}  = $build_id;
-    $self->{"locale"}   = $locale;
-    
-    return $self;
-}
-
-sub setCookie {
-    my $self = shift;
-    
-    my %cookiedata;
-    
-    my $c = Litmus->cgi();
-    my $cookie = $c->cookie( 
-        -name   => $configcookiename.'_'.$self->{"product"}->product_id(),
-        -value  => join('|', $self->{"product"}->product_id(), $self->{"platform"}->platform_id(),
-             $self->{"opsys"}->opsys_id(), $self->{"branch"}->branch_id(), $self->{"build_id"}, $self->{"locale"}->abbrev()),
-        -domain => $main::ENV{"HTTP_HOST"},
-    );
-    
-    return $cookie;
-}
-
-sub getCookie {
-    my $self = shift;
-    my $c = Litmus->cgi();
-    my $product = shift;
-    
-    return Litmus::SysConfig->
-    	realGetCookie($configcookiename.'_'.$product->product_id());
-    
-}
-
-# returns sysconfig objects corresponding to all sysconfig cookies the user 
-# has set
-sub getAllCookies {
-	my $self = shift;
-	my $c = Litmus->cgi();
-	
-	my @cookies = ();
-	my @names = $c->cookie();
-	foreach my $cur (@names) {
-		if ($cur =~ /^\Q$configcookiename\E_/) {
-			push(@cookies, Litmus::SysConfig->realGetCookie($cur));
-		}
-	}
-	if (@cookies == 0) { push(@cookies, undef) }
-	return @cookies;
-}
-
-sub realGetCookie {
-	my $self = shift;
-	my $cookiename = shift;
-	
-	my $c = Litmus->cgi();
-	my $cookie = $c->cookie($cookiename);
-	if (! $cookie) {
-        return;
-    }
-    
-    my @sysconfig = split(/\|/, $cookie);
-    
-    return new(undef,
-               Litmus::DB::Product->retrieve($sysconfig[0]), 
-               Litmus::DB::Platform->retrieve($sysconfig[1]), 
-               Litmus::DB::Opsys->retrieve($sysconfig[2]), 
-               Litmus::DB::Branch->retrieve($sysconfig[3]), 
-               $sysconfig[4],
-               Litmus::DB::Locale->retrieve($sysconfig[5])
-               );    
-}
-
-sub product() {
-    my $self = shift;
-    
-    return $self->{"product"};
-}
-
-sub platform() {
-    my $self = shift;
-    
-    return $self->{"platform"};
-}
-
-sub opsys() {
-    my $self = shift;
-    
-    return $self->{"opsys"};
-}
-
-sub branch() {
-    my $self = shift;
-    
-    return $self->{"branch"};
-}
-
-sub build_id() {
-    my $self = shift;
-    
-    return $self->{"build_id"};
-}
-
-sub locale() {
-    my $self = shift;
-    
-    return $self->{"locale"};
-}
-
-
-# display the system configuration form
-# optionally takes the product to configure for 
-# and requires a url to load when done. this 
-# url should call processForm() to 
-# set the sysconfig cookie and do 
-# error handling.
-# optionaly, pass a CGI object and its
-# data will be stored in the form so 
-# the receiving script can access it.
-sub displayForm {
-    my $self = shift;
-    my $product = shift;
-    my $goto = shift;
-    my $c = shift; 
-    
-    my @products; 
-    # if we already know the product, then just send it on:
-    if ($product) {
-        $products[0] = $product;
-    } else {
-        # we need to ask the user for the product then
-        @products = Litmus::DB::Product->retrieve_all();
-    }
-
-    my @locales = Litmus::DB::Locale->retrieve_all(
-                                                   { order_by => 'abbrev' }
-                                                  );
-    my $vars = {
-        locales    => \@locales,        
-        products   => \@products,
-        ua         => Litmus::UserAgentDetect->new(),
-        "goto" => $goto,
-        cgidata   => $c,
-        };
-        
-    # if the user already has a cookie set for this product, then 
-    # load those values as defaults:
-    if ($product && Litmus::SysConfig->getCookie($product)) {
-        my $sysconfig = Litmus::SysConfig->getCookie($product);
-        $vars->{"defaultplatform"} = $sysconfig->platform();
-        $vars->{"defaultopsys"} = $sysconfig->opsys();
-        $vars->{"defaultbranch"} = $sysconfig->branch();
-        $vars->{"defaultlocale"} = $sysconfig->locale();
-    }
-    
-    # send a default build id if we have one:
-    my @cookies = Litmus::SysConfig->getAllCookies();
-    if ($cookies[0]) { $vars->{"defaultbuildid"} = $cookies[0]->build_id() }
-    
-    my $cookie =  Litmus::Auth::getCurrentUser();
-    $vars->{"defaultemail"} = $cookie;
-    $vars->{"show_admin"} = Litmus::Auth::istrusted($cookie);
-
-    $vars->{"title"} = "Run Tests";
-    
-    Litmus->template()->process("runtests/sysconfig.html.tmpl", $vars) || 
-        internalError(Litmus->template()->error());    
-}
-
-# process a form containing sysconfig information. 
-# takes a CGI object containing param data
-sub processForm {
-    my $self = shift;
-    my $c = shift;
-    
-    my $product = Litmus::DB::Product->retrieve($c->param("product"));
-    my $platform = Litmus::DB::Platform->retrieve($c->param("platform"));
-    my $opsys = Litmus::DB::Opsys->retrieve($c->param("opsys"));
-    my $branch = Litmus::DB::Branch->retrieve($c->param("branch"));
-    my $build_id = $c->param("build_id");
-    my $locale = Litmus::DB::Locale->retrieve($c->param("locale"));
-    
-    requireField("product", $product);
-    requireField("platform", $platform);
-    requireField("opsys", $opsys);
-    requireField("branch", $branch);
-    requireField("build_id", $build_id);
-    requireField("locale", $locale);
-    
-    # set a cookie with the user's testing details:
-    my $prod =  Litmus::DB::Product->retrieve($c->param("product"));
-    my $sysconfig = Litmus::SysConfig->new(
-                            $product,
-                            $platform, 
-                            $opsys,
-                            $branch,
-                            $build_id,
-                            $locale
-                            );
-                                    
-    return $sysconfig;
-}
-1;
-
-
-

mozilla/webtools/litmus/Litmus/Template.pm

@@ -1,205 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 the Bugzilla Bug Tracking System.
- #
- # The Initial Developer of the Original Code is Netscape Communications
- # Corporation. Portions created by Netscape are
- # Copyright (C) 1998 Netscape Communications Corporation. All
- # Rights Reserved.
- #
- # Contributor(s): Terry Weissman <terry@mozilla.org>
- #                 Dan Mosedale <dmose@mozilla.org>
- #                 Jacob Steenhagen <jake@bugzilla.org>
- #                 Bradley Baetz <bbaetz@student.usyd.edu.au>
- #                 Christopher Aillon <christopher@aillon.com>
- #                 Tobias Burnus <burnus@net-b.de>
- #                 Myk Melez <myk@mozilla.org>
- #                 Max Kanat-Alexander <mkanat@bugzilla.org>
- #                 Zach Lipton <zach@zachlipton.com>
- #                 Chris Cooper <ccooper@deadsquid.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-# This is mostly a placeholder. At some point in the future, we might 
-# want to be more like Bugzilla and support multiple languages and 
-# other fine features, so we keep this around now so that adding new 
-# things later won't require changing every source file. 
-
-package Litmus::Template;
-
-use strict;
-
-use Litmus::Config;
-use Litmus::StripScripts;
-use Text::Markdown;
-
-use base qw(Template);
-
-my $template_include_path;
-
-$Template::Directive::WHILE_MAX = 30000;
-
-# Returns the path to the templates based on the Accept-Language
-# settings of the user and of the available languages
-# If no Accept-Language is present it uses the defined default
-sub getTemplateIncludePath () {
-    return "templates/en/default";
-}
-
-# Constants:
-my %constants = {};
-$constants{litmus_version} = $Litmus::Config::version;
-
-# html tag stripper:
-my $strip = Litmus::StripScripts->new(
-                                      {
-                                       AllowHref => 1,
-                                       AllowSrc => 1,
-                                       Context => 'Document'
-                                      },
-                                      strict_names => 1,
-                                     );
-
-###############################################################################
-# Templatization Code
-
-# Use the Toolkit Template's Stash module to add utility pseudo-methods
-# to template variables.
-use Template::Stash;
-
-# Add "contains***" methods to list variables that search for one or more 
-# items in a list and return boolean values representing whether or not 
-# one/all/any item(s) were found.
-$Template::Stash::LIST_OPS->{ contains } =
-  sub {
-      my ($list, $item) = @_;
-      return grep($_ eq $item, @$list);
-  };
-
-$Template::Stash::LIST_OPS->{ containsany } =
-  sub {
-      my ($list, $items) = @_;
-      foreach my $item (@$items) { 
-          return 1 if grep($_ eq $item, @$list);
-      }
-      return 0;
-  };
-
-# Allow us to still get the scalar if we use the list operation ".0" on it
-$Template::Stash::SCALAR_OPS->{ 0 } = 
-  sub {
-      return $_[0];
-  };
-
-# Add a "substr" method to the Template Toolkit's "scalar" object
-# that returns a substring of a string.
-$Template::Stash::SCALAR_OPS->{ substr } = 
-  sub {
-      my ($scalar, $offset, $length) = @_;
-      return substr($scalar, $offset, $length);
-  };
-
-# Add a "truncate" method to the Template Toolkit's "scalar" object
-# that truncates a string to a certain length.
-$Template::Stash::SCALAR_OPS->{ truncate } = 
-  sub {
-      my ($string, $length, $ellipsis) = @_;
-      $ellipsis ||= "";
-      
-      return $string if !$length || length($string) <= $length;
-      
-      my $strlen = $length - length($ellipsis);
-      my $newstr = substr($string, 0, $strlen) . $ellipsis;
-      return $newstr;
-  };
-
-# Create the template object that processes templates and specify
-# configuration parameters that apply to all templates.
-sub create {
-    my $class = shift;
-    return $class->new({
-        INCLUDE_PATH => &getTemplateIncludePath,
-        CONSTANTS => \%constants,
-        PRE_PROCESS => "variables.none.tmpl",
-        POST_CHOMP => 1,
-        EVAL_PERL => 1,
-        
-        COMPILE_DIR => $Litmus::Config::datadir,
-        
-        FILTERS => {
-            # disallow all html in testcase data except for non-evil tags
-            testdata => sub {
-                my ($data) = @_;
-                
-                $strip->parse($data);
-                $strip->eof();
-                
-                return $strip->filtered_document;
-            }, 
-            
-            # process the text with the markdown text processor
-            markdown => sub {
-            	my ($data) = @_;
-            	$data = Text::Markdown::markdown($data);
-            	return $data;
-            },
-            
-            # Returns the text with backslashes, single/double quotes,
-            # and newlines/carriage returns escaped for use in JS strings.
-            # thanks to bugzilla!
-            js => sub {
-                my ($var) = @_;
-                $var =~ s/([\\\'\"\/])/\\$1/g;
-                $var =~ s/\n/\\n/g;
-                $var =~ s/\r/\\r/g;
-                $var =~ s/\@/\\x40/g; # anti-spam for email addresses
-                return $var;
-            },
-            
-            # anti-spam filtering of email addresses
-            email => sub {
-                my ($var) = @_;
-                $var =~ s/\@/\&#64;/g;
-                return $var;    
-            }, 
-            
-            # dummy filter when we don't actually need to filter anything
-            none => sub {
-            	my ($var) = @_;
-                return $var;
-            },
-        },
-    });
-}
-
-# override the process() method to sneak defaultemail into all template 
-# variable spaces
-sub process {
-	my ($self, $template, $vars, $outstream, @opts) = @_;
-	my %vars = %$vars;
-	
-	$vars{defaultemail} = $vars{defaultemail} ? $vars{defaultemail} : 
-		Litmus->getCurrentUser();
-	
-	$vars{show_admin} = Litmus->getCurrentUser() ? 
-	  Litmus->getCurrentUser()->is_admin() : 0;
-	
-	$self->SUPER::process($template, \%vars, $outstream, @opts);
-}

mozilla/webtools/litmus/Litmus/Testlist.pm

@@ -1,66 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::Testlist;
-
-use strict;
-
-use base qw(Exporter);
-@Litmus::Testlist::EXPORT = qw(
-                               makeHotlist
-                              );
-
-sub makeHotlist {
-    my $numtests = shift;
-    my $state = shift;
-    my @tests = @_;
-    
-    my @potentialtests;
-    foreach my $curtest (@tests) {
-        if ($curtest->isrecent()) {
-            foreach my $curplat ($curtest->subgroup()->testgroup()->product()->platforms()) {
-                my $found;
-                my $curstate = $curtest->state($curplat);
-                if ($curstate && $curstate->resultid() == $state->resultid()) {
-                    push(@potentialtests, $curtest);
-                    $found++;
-                } 
-                if ($found) {next}
-            }
-        }
-    }
-    
-    @potentialtests = sort{$b->num_recent_results() <=> $a->num_recent_results()} 
-                           @potentialtests;
-                           
-    return @potentialtests;
-}

mozilla/webtools/litmus/Litmus/UserAgentDetect.pm

@@ -1,147 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-# Handle detection of system information from the UA string
-
-package Litmus::UserAgentDetect;
-
-use strict;
-
-require Exporter;
-use Litmus;
-use Litmus::DB::Platform;
-use Litmus::DB::Opsys;
-use Litmus::DB::Branch;
-
-our @ISA = qw(Exporter);
-our @EXPORT = qw(detectBuildID);
-
-# define some SQL queries we will use:
-Litmus::DB::Platform->set_sql(detectplatform => qq{
-                                                  SELECT p.platform_id
-                                                  FROM platforms p, platform_products pp
-                                                  WHERE 
-                                                      ? REGEXP detect_regexp AND 
-                                                      p.platform_id=pp.platform_id  AND
-                                                      pp.product_id LIKE ?
-                                                });
-Litmus::DB::Branch->set_sql(detectbranch => qq{
-                                                SELECT __ESSENTIAL__
-                                                FROM __TABLE__
-                                                WHERE 
-                                                    ? REGEXP detect_regexp AND 
-                                                    product_id LIKE ?
-                                            });                                                
-
-# constructor. Optionally you can pass a UA string 
-# and it will be used. Otherwise the default is the 
-# current useragent.
-sub new {
-    my $self = {};
-    my $class = shift;
-    my $ua = shift;
-    
-    bless($self);
-    $self->{ua} = $main::ENV{"HTTP_USER_AGENT"};
-    if ($ua) { $self->{ua} = $ua }
-    return $self;
-}
-
-# default stringification is to return the ua:
-use overload 
-    '""' => \&ua;
-    
-
-sub ua {
-    my $self = shift;
-    
-    # we pad the UA with a space since some of our regexp matches expect 
-    # to match things at the end of the string. This is quite possibly 
-    # a bug. 
-    return $self->{ua}." ";
-}
-
-sub build_id {
-    my $self = shift;
-    my $ua = $self->{ua};
-    
-    # mozilla products only
-    unless ($ua =~ /Mozilla\/5\.0/) {
-        return undef;
-    }
-    $ua =~ /(200\d*)/;
-    return $1; 
-}
-
-sub locale {
-    my $self = shift;
-    my $ua = $self->{ua};
-    
-    # mozilla products only
-    unless ($ua =~ /Mozilla\/5\.0/) {
-        return undef;
-    }
-
-    # Format (e.g.): 
-    # Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8) Gecko/20051111 Firefox/1.5
-    $ua =~ /Mozilla\/5\.0 \([^;]*; [^;]*; [^;]*; ([^;]*); [^;]*\)/;
-    return $1; 
-}
-
-sub platform {
-    my $self = shift;
-    my $product = shift; # optionally, just lookup for one product
-    
-    if (! $product) { $product = '%' }
-    
-    my @platforms = Litmus::DB::Platform->search_detectplatform($self->ua, $product);
-    return @platforms;
-}
-
-sub branch {
-    my $self = shift;
-    my $product = shift; # optionally, just lookup for one branch
-    
-    if (! $product) { $product = '%' }
-    
-    my @branches = Litmus::DB::Branch->search_detectbranch($self->ua, $product);
-    return @branches;
-}
-
-# from the legacy API before we had an OO interface:
-sub detectBuildId() {
-    my $self = Litmus::UserAgentDetect->new($main::ENV{"HTTP_USER_AGENT"});
-    
-    return $self->build_id();
-}
-
-1;

mozilla/webtools/litmus/Litmus/Utils.pm

@@ -1,61 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Chris Cooper <ccooper@deadsquid.com>
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-# General utility functions
-
-package Litmus::Utils;
-
-use strict;
-
-use Litmus;
-use Litmus::Error;
-use CGI;
-
-our @ISA = qw(Exporter);
-@Litmus::Utils::EXPORT = qw(
-    requireField
-);
-
-
-# requireField - checks that $field contains data (other than ---) and throws
-# an invalidInputError if it does not.
-sub requireField {
-    my ($fieldname, $field) = @_;
-    
-    unless($field && $field ne "---") {
-        my $c = Litmus->cgi();
-        print $c->header();
-        invalidInputError("You must make a valid selection for field ".$fieldname.".");
-    }
-}
-
-1;

mozilla/webtools/litmus/Litmus/XML.pm

@@ -1,419 +0,0 @@
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-=head1 COPYRIGHT
-
- # ***** BEGIN LICENSE BLOCK *****
- # Version: MPL 1.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 Litmus.
- #
- # The Initial Developer of the Original Code is
- # the Mozilla Corporation.
- # Portions created by the Initial Developer are Copyright (C) 2006
- # the Initial Developer. All Rights Reserved.
- #
- # Contributor(s):
- #   Zach Lipton <zach@zachlipton.com>
- #
- # ***** END LICENSE BLOCK *****
-
-=cut
-
-package Litmus::XML; 
-
-# Litmus XML Interface
-# For further details, see the web services specification at 
-# http://wiki.mozilla.org/Litmus:Web_Services
-
-use strict;
-
-use XML::XPath;
-use XML::XPath::XMLParser;
-
-use Litmus::DB::User;
-use Litmus::UserAgentDetect;
-use Date::Manip;
-
-use CGI::Carp qw(set_message fatalsToBrowser);
-
-# if we die for some reason, make sure we give a fatal error per spec
-BEGIN { 
-	set_message(sub { 
-		print "Fatal error: internal server error\n";
-	});
-}
-
-no warnings;
-no diagnostics;
-
-sub new {
-	my $self = {};
-	bless($self);
-	return $self;
-}
-
-# process XML test result data as described by 
-# the spec at http://wiki.mozilla.org/Litmus:Web_Services
-sub processResults {
-	my $self = shift;
-	my $data = shift;
-	
-	$self->parseResultFile($data) ? 1 : return 0;
-	
-	unless ($self->authenticate()) { return 0} # login failure
-	
-	$self->validateResults() ? 1 : return 0;
-	
-	# at this point, everything is valid, so if we're just validating the 
-	# results, we can return an ok:
-	if ($self->{'action'} eq 'validate') {
-		unless  ($self->{'response'}) { $self->respOk() }
-		return 1;
-	}
-	
-	# add so-called 'global logs' that apply to all the results
-	# we save them in @globallogs so we can map them to the results later
-	my @globallogs;
-	foreach my $log (@{$self->{'logs'}}) {
-		# the submission time is the timestamp of the first testresult:
-		my $newlog = Litmus::DB::Log->create({
-			submission_time => $self->{'results'}->[0]->{'timestamp'},
-			log_type => $log->{'type'},
-			log_text => $log->{'data'},
-		});
-		push(@globallogs, $newlog);
-	}
-	
-	# now actually add the new results to the db:
-	foreach my $result (@{$self->{'results'}}) {
-		my $newres = Litmus::DB::Testresult->create({
-			testcase      => $result->{'testid'},
-			user_agent    => new Litmus::UserAgentDetect($self->{'useragent'}),
-			user 	      => $self->{'user'}, 
-			opsys 	      => $self->{'sysconfig'}->{'opsys'},
-			branch 	      => $self->{'sysconfig'}->{'branch'},
-			locale	      => $self->{'sysconfig'}->{'locale'},
-			build_id      => $self->{'sysconfig'}->{'buildid'},
-			machine_name  => $self->{'machinename'},
-			result_status => $result->{'resultstatus'},
-			timestamp     => $result->{'timestamp'},
-			exit_status   => $result->{'exitstatus'},
-			duration_ms   => $result->{'duration'},
-			valid		  => 1,
-			isAutomated   => $result->{'isAutomated'},
-		});
-		
-		if (!$newres) { $self->respErrResult($result->{'testid'}); next; }
-		
-		# add any bug ids:
-		foreach my $bug (@{$result->{'bugs'}}) {
-			my $newbug = Litmus::DB::Resultbug->create({
-				test_result_id  => $newres,
-				bug_id 		    => $bug, 
-				submission_time => $result->{'timestamp'},
-				user		    => $self->{'user'},
-			});
-		}
-		
-		# add any comments:
-		foreach my $comment (@{$result->{'comments'}}) {
-			my $newcomment = Litmus::DB::Comment->create({
-				test_result     => $newres,
-				submission_time => $result->{'timestamp'},
-				user            => $self->{'user'},
-				comment         => $comment,
-			});
-		}
-	
-		# add logs:
-		my @resultlogs;
-		push(@resultlogs, @globallogs); # all results get the global logs
-		foreach my $log (@{$result->{'logs'}}) {
-			my $newlog = Litmus::DB::Log->create({
-				submission_time => $result->{'timestamp'},
-				log_type => $log->{'type'},
-				log_text => $log->{'data'},
-			});
-			push(@resultlogs, $newlog);
-		}
-		
-		# now we map the logs to the current result:
-		foreach my $log (@resultlogs) {
-			Litmus::DB::LogTestresult->create({
-				test_result => $newres,
-				log_id => $log,
-			});
-		}
-	}
-	
-	unless  ($self->{'response'}) { $self->respOk() }
-	
-	#$self->{'response'} = $self->{'results'}->[0]->{'resultstatus'};
-	
-}
-
-sub parseResultFile {
-	my $self = shift;
-	my $data = shift;
-	my $x = XML::XPath->new(xml => $data, standalone => 1);
-	$self->{'useragent'} = $x->findvalue('/litmusresults/@useragent');
-	$self->{'machinename'} = $x->findvalue('litmusresults/@machinename');
-	$self->{'action'} = $x->findvalue('/litmusresults/@action');
-	$self->{'user'}->{'username'} = $x->findvalue(
-									'/litmusresults/testresults/@username');
-	$self->{'user'}->{'token'} = $x->findvalue(
-								   '/litmusresults/testresults/@authtoken');
-	
-	$self->{'sysconfig'}->{'product'} = $x->findvalue('/litmusresults/testresults/@product');
-	$self->{'sysconfig'}->{'platform'} = $x->findvalue('/litmusresults/testresults/@platform');
-	$self->{'sysconfig'}->{'opsys'} = $x->findvalue('/litmusresults/testresults/@opsys');
-	$self->{'sysconfig'}->{'branch'} = $x->findvalue('/litmusresults/testresults/@branch');
-	$self->{'sysconfig'}->{'buildid'} = $x->findvalue('/litmusresults/testresults/@buildid');
-	$self->{'sysconfig'}->{'locale'} = $x->findvalue('/litmusresults/testresults/@locale');
-	
-	my @glogs = $x->find('/litmusresults/testresults/log')->get_nodelist();
-	my $l_ct = 0;
-	foreach my $log (@glogs) {
-		my $type = $x->findvalue('@logtype', $log);
-			my $logdata = stripWhitespace($log->string_value());
-			$self->{'logs'}->[$l_ct]->{'type'} = $type;
-			$self->{'logs'}->[$l_ct]->{'data'} = $logdata;
-			$l_ct++;
-	}
-	
-	my @results = $x->find('/litmusresults/testresults/result')->get_nodelist();
-	my $c = 0;
-	foreach my $result (@results) {
-		$self->{'results'}->[$c]->{'testid'} = $x->findvalue('@testid', $result);
-		$self->{'results'}->[$c]->{'isAutomated'} = $x->findvalue('@is_automated_result', $result);
-		$self->{'results'}->[$c]->{'resultstatus'} = $x->findvalue('@resultstatus', $result);
-		$self->{'results'}->[$c]->{'exitstatus'} = $x->findvalue('@exitstatus', $result);
-		$self->{'results'}->[$c]->{'duration'} = $x->findvalue('@duration', $result);
-		$self->{'results'}->[$c]->{'timestamp'} = 
-			&Date::Manip::UnixDate($x->findvalue('@timestamp', $result), "%q");
-		
-		
-		my @comments = $x->find('comment', $result)->get_nodelist();
-		my $com_ct = 0;
-		foreach my $comment (@comments) {
-			$comment = stripWhitespace($comment->string_value());
-			$self->{'results'}->[$c]->{'comments'}->[$com_ct] = $comment;
-			$com_ct++;
-		}
-		
-		my @bugs = $x->find('bugnumber', $result)->get_nodelist();
-		my $bug_ct = 0;
-		foreach my $bug (@bugs) {
-			$bug = stripWhitespace($bug->string_value());
-			$self->{'results'}->[$c]->{'bugs'}->[$bug_ct];
-			$bug_ct++;
-		}
-		
-		my @logs = $x->find('log', $result)->get_nodelist();
-		my $log_ct = 0;
-		foreach my $log (@logs) {
-			my $type = $x->findvalue('@logtype', $log);
-			my $logdata = stripWhitespace($log->string_value());
-			$self->{'results'}->[$c]->{'logs'}->[$log_ct]->{'type'} = $type;
-			$self->{'results'}->[$c]->{'logs'}->[$log_ct]->{'data'} = $logdata;
-			$log_ct++;
-		}	
-		$c++;
-	}
-	
-	$self->{'x'} = $x;
-}
-
-# validate the result data, and resolve references to various tables
-# the correct objects, looking up id numbers as needed
-sub validateResults {
-	my $self = shift;
-
-	my $action = $self->{'action'};
-	if ($action ne 'submit' && $action ne 'validate') {
-		$self->respErrFatal("Action must be either 'submit' or 'validate'");
-		return 0;
-	}
-	
-	my @users = Litmus::DB::User->search(email => $self->{'user'}->{'username'});
-	$self->{'user'} = $users[0];
-	
-	
-	unless ($self->{'useragent'}) { 
-		$self->respErrFatal("You must specify a useragent");
-		return 0;
-	}
-	
-	my @prods = Litmus::DB::Product->search(name => $self->{'sysconfig'}->{'product'});
-	unless ($prods[0]) { 
-		$self->respErrFatal("Invalid product: ".$self->{'sysconfig'}->{'product'});
-		return 0;
-	}
-	$self->{'sysconfig'}->{'product'} = $prods[0];
-	
-	my @platforms = Litmus::DB::Platform->search_ByProductAndName(
-											$self->{'sysconfig'}->{'product'},
-											$self->{'sysconfig'}->{'platform'});
-	unless ($platforms[0]) { 
-		$self->respErrFatal("Invalid platform: ".$self->{'sysconfig'}->{'platform'});
-		return 0;
-	}
-	$self->{'sysconfig'}->{'platform'} = $platforms[0];
-	
-	my @opsyses = Litmus::DB::Opsys->search(
-								name => $self->{'sysconfig'}->{'opsys'}, 
-							    platform => $self->{'sysconfig'}->{'platform'});
-	unless ($opsyses[0]) { 
-		$self->respErrFatal("Invalid opsys: ".$self->{'sysconfig'}->{'opsys'});
-		return 0;
-	}
-	$self->{'sysconfig'}->{'opsys'} = $opsyses[0];
-	
-	my @branches = Litmus::DB::Branch->search(
-										name => $self->{'sysconfig'}->{'branch'},
-										product => $self->{'sysconfig'}->{'product'});
-	unless ($branches[0]) { 
-		$self->respErrFatal("Invalid branch: ".$self->{'sysconfig'}->{'branch'});
-		return 0;
-	}
-	$self->{'sysconfig'}->{'branch'} = $branches[0];
-	
-	unless ($self->{'sysconfig'}->{'buildid'}) {
-		$self->respErrFatal("Invalid build id: ".$self->{'sysconfig'}->{'buildid'});
-		return 0;
-	}
-	
-	my @locales = Litmus::DB::Locale->search(
-									locale => $self->{'sysconfig'}->{'locale'});
-	unless ($locales[0]) { 
-		$self->respErrFatal("Invalid locale: ".$self->{'sysconfig'}->{'locale'});
-		return 0;
-	}
-	$self->{'sysconfig'}->{'locale'} = $locales[0];
-	
-	foreach my $log (@{$self->{'logs'}}) {
-		my @types = Litmus::DB::LogType->search(name => $log->{'type'});
-		unless ($types[0]) {
-			$self->respErrFatal("Invalid log type: ".$log->{'type'});
-			return 0;
-		}
-		$log->{'type'} = $types[0];
-	}
-	
-	foreach my $result (@{$self->{'results'}}) {
-		my @tests = Litmus::DB::Testcase->search(
-									test_id => $result->{'testid'});
-		unless ($tests[0]) { 
-			$self->respErrResult('unknown', "Invalid test id");
-			next;
-		}
-		$result->{'testid'} = $tests[0];
-		
-		# assume it's an automated test result if not specified
-		($result->{'isAutomated'} eq '0' || $result->{'isAutomated'} ne undef) ? 
-			$result->{'isAutomated'} = 0 : $result->{'isAutomated'} = 1;
-		
-		my @results = Litmus::DB::ResultStatus->search(
-									name => $result->{'resultstatus'});
-		unless ($results[0]) { 
-			$self->respErrResult($result->{'testid'}, "Invalid resultstatus");
-			next;
-		}
-		$result->{'resultstatus'} = $results[0];
-		
-		my @es = Litmus::DB::ExitStatus->search(
-									name => $result->{'exitstatus'});
-		unless ($es[0]) { 
-			$self->respErrResult($result->{'testid'}, "Invalid exitstatus");
-			next;
-		}
-		$result->{'exitstatus'} = $es[0];
-		
-		# if there's no duration, then it's just 0:
-		unless ($result->{'duration'}) {
-			$result->{'duration'} = 0;
-		}
-		
-		# if there's no timestamp, then it's now:
-		unless ($result->{'timestamp'}) {
-			$result->{'timestamp'} = &Date::Manip::UnixDate("now","%q");
-		}
-		
-		foreach my $log (@{$result->{'logs'}}) {
-			my @types = Litmus::DB::LogType->search(name => $log->{'type'});
-			unless ($types[0]) {
-				$self->respErrResult($result->{'testid'}, 
-									 "Invalid log type: ".$log->{'type'});
-				next;
-			}
-			$log->{'type'} = $types[0];
-		}		
-	}
-	return 1;
-}
-
-sub response {
-	my $self = shift;
-	return $self->{'response'};
-}
-
-
-# ONLY NON-PUBLIC API BELOW THIS POINT
-
-sub authenticate {
-	my $self = shift;
-	
-	my @users = Litmus::DB::User->search(email => $self->{'user'}->{'username'});
-	my $user = $users[0];
-	
-	unless ($user) { $self->respErrFatal("User does not exist"); return 0 }
-	
-	unless ($user->enabled()) { $self->respErrFatal("User disabled"); return 0 }
-	
-	if ($user->authtoken() ne $self->{'user'}->{'token'}) {
-		respErrFatal("Invalid authentication token for user ".
-			$self->{'user'}->{'username'});
-		return 0;
-	}
-	return 1;
-}
-
-sub respOk {
-	my $self = shift;
-	$self->{'response'} = 'ok';
-}
-
-sub respErrFatal {
-	my $self = shift;
-	my $error = shift;
-	$self->{'response'} = "Fatal error: $error\n";
-}
-
-sub respErrResult {
-	my $self = shift;
-	my $testid = shift;
-	my $error = shift;
-	$self->{'response'} .= "Error processing result for test $testid: $error\n";
-}
-
-# remove leading and trailing whitespace from logs and comments
-sub stripWhitespace {
-	my $txt = shift;
-	$txt =~ s/^\s+//;
-	$txt =~ s/\s+$//;
-	return $txt;
-}
-
-
-
-1;

mozilla/webtools/litmus/Makefile

@@ -1,56 +0,0 @@
-# Litmus Makefile
-
-PERL=perl
-
-install: templates
-	$(PERL) populatedb.pl
-
-# precompile all templates with the Template Toolkit
-# to speed things up a good bit. 
-# This ought to be done in a more "makelike" way, but 
-# various difficulties prevent that unless we use a configure 
-# script to generate the Makefile, at which point we could have 
-# been done already...
-
-%.tmpl: 
-	$(PERL) -e " \
-		eval('use CGI qw(-no_debug)'); \
-		use Litmus::Template;use diagnostics; \
-		\$$template = Litmus::Template->create(); \
-		\$$template->context()->template('$@'); \
-	"
-
-templates: index.html.tmpl
-	$(PERL) -e " \
-		use File::Find; \
-		find({ wanted => sub { \
-			\$$name = \$$File::Find::name; \
-			return if (-d \$$name); \
-			return if (\$$name =~ /\/CVS\//); \
-			return if (\$$name !~ /\.tmpl\$$/); \
-			\$$name =~ s/templates\/en\/default\///; \
-			if (-M 'templates/en/default/'.\$$name < -M 'data/templates/en/default/'.\$$name \
-				|| ! -e 'data/templates/en/default/'.\$$name \
-				|| -M 'Litmus/Template.pm' < -M 'data/templates/en/default/'.\$$name) { \
-				system("make", "\$$name"); \
-			} \
-		}, no_chdir => 1 }, 'templates/en/default'); \
-	"
-	
-# tags: generate ctags style hints for ease of editing
-# requires Exuberant Ctags to be installed (http://ctags.sf.net/)
-ctags: 
-	`which ctags` --excmd=number --tag-relative=no --fields=+a+m+n+S -R `pwd`
-
-tags: ctags
-	
-test: 
-	$(PERL) runtests.pl
-
-cache: 
-	$(PERL) -MLitmus -MLitmus::Cache -e "Litmus::Cache::rebuildCache();"
-	@echo "Done";
-
-clean: 
-	rm -rf data
-	make install

mozilla/webtools/litmus/README

@@ -1,47 +0,0 @@
-===Litmus===
-
-If you're reading this, you've downloaded, received, or simply conjured
-out of thin air, a copy of the Litmus testcase management system.
-Presumably, you're reading this file because you have some sort of
-question about Litmus. Hopefully, if we've done our job right, this file
-ought to answer your questions. 
-
-Q: What is Litmus?
-A: Litmus is a testcase management system. Its goal is to allow users to
-enter software tests, run them, and view and manage the results. Along
-the way, users can expect to be able to do queries and reports and have
-access all the usual features they expect from a first-class web
-application. The reality may be somewhat different than this goal.
-Litmus is developed by mozilla.org.  
-
-Q: How do I install this dang thing?
-A: You probably want the file called INSTALL.
-
-Q: Where is the real documentation?
-A: Hahahaha. What is this "documentation" you speak of? You might want
-to check out the Litmus Wiki, which may or may not contain useful
-information. See http://wiki.mozilla.org/Litmus.
-
-Q: What needs to be done?
-A: See http://wiki.mozilla.org/Litmus:Todo
-
-Q: How much does it cost?
-A: Nothing. Litmus is Free Software, licensed under the Mozilla Public
-License.
-
-Q: Wait. Isn't "testcase" two words? 
-A: Not here it isn't. 
-
-Q: Waaaaaaah. Why is Litmus written in Perl and not
-PHP/Python/Java/Objective Pascal/Latin?
-A: Because I know Perl. Duh. Also because Litmus uses some code from
-Bugzilla, and it wouldn't be able to do this if it was written in some
-other language. Camels are also some of the least buggy animals around,
-as they swat flies away with their tails. 
-
-Q: I'm still confused. You didn't answer my question. I don't know what
-to do. Help!
-A: First of all, that's not a question. In any case, your best bet is
-probably to email Zach Lipton <zach@zachlipton.com>, and if you ask
-nicely and don't make too much of a pest of yourself, he'd be glad to
-get you on the right track. 

mozilla/webtools/litmus/advanced_search.cgi

@@ -1,246 +0,0 @@
-#!/usr/bin/perl -w
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-# ***** BEGIN LICENSE BLOCK *****
-# Version: MPL 1.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 Litmus.
-#
-# The Initial Developer of the Original Code is
-# the Mozilla Corporation.
-# Portions created by the Initial Developer are Copyright (C) 2006
-# the Initial Developer. All Rights Reserved.
-#
-# Contributor(s):
-#   Chris Cooper <ccooper@deadsquid.com>
-#   Zach Lipton <zach@zachlipton.com>
-#
-# ***** END LICENSE BLOCK *****
-
-use strict;
-
-use Litmus;
-use Litmus::Auth;
-use Litmus::Error;
-use Litmus::DB::Testresult;
-use Litmus::FormWidget;
-
-use CGI;
-use Time::Piece::MySQL;
-
-Litmus->init();
-my $c = Litmus->cgi();
-print $c->header();
-
-
-
-# Hash refs for maintaining state in the search form.
-my $defaults = undef;
-my $order_bys = undef;
-
-my $MAX_SORT_FIELDS = 10;
-my $MAX_SEARCH_FIELDS = 10;
-
-my $criteria = "Custom<br/>";
-my $results;
-my @where;
-my @order_by;
-my $limit;
-my $where_criteria = "";
-my $order_by_criteria = "";
-my $limit_criteria = "";
-
-if ($c->param) {    
-
-    foreach my $param ($c->param) {
-        next if ($c->param($param) eq '');
-        
-        if ($param =~ /sort_field(\d+)/) {
-            # We slot sort fields into the @order_by array based on their
-            # field_num. Empty array slots will be ignored when the SQL 
-            # is built. We set an upper limit on the number of sort fields 
-            # we can handle to prevent abuse.
-            my $field_num = $1;
-            next if ($field_num > $MAX_SORT_FIELDS);
-            my $sort_field = $c->param($param);
-            my $sort_order = 'ASC';
-            if ($c->param("sort_order$field_num")) {
-                $sort_order = $c->param("sort_order$field_num");
-            }
-            $order_by[$field_num] = { field => $sort_field,
-                                      direction => $sort_order};
-
-        } elsif ($param =~ /search_field(\d+)/) {
-            # We set an upper limit on the number of search fields 
-            # we can handle to prevent abuse.
-            my $field_num = $1;
-            next if ($field_num > $MAX_SEARCH_FIELDS);
-            my $search_field = $c->param($param);
-            my $match_criteria = $c->param("match_criteria$field_num");
-            my $value = $c->param("search_value$field_num");
-            push @where, { 'field' => 'search_field',
-                           'search_field' => $search_field,
-                           'match_criteria' => $match_criteria,
-                           'value' => $value};
-            $where_criteria .= "$search_field $match_criteria '$value'<br/>";
-
-        } elsif ($param eq 'start_date') {
-            my $start_date = $c->param($param);
-            $start_date =~ s/[^0-9A-Za-z ]/ /g;
-            my $end_date;
-            # Use 'now' as the default end date.
-            if ($c->param('end_date') and $c->param('end_date') ne '') {
-                $end_date = $c->param('end_date');
-                $end_date =~ s/[^0-9A-Za-z ]/ /g;
-            } else {
-                $end_date = 'Now';
-            }
-            push @where, { field => 'start_date',
-                           value => $start_date};
-            push @where, { field => 'end_date',
-                           value => $end_date};
-            $where_criteria .= "Date between '$start_date' and '$end_date'<br/>";
-        } elsif ($param eq 'trusted_only') {
-            push @where, {field => 'trusted_only',
-                          value => 1};            
-            $limit_criteria .= "Display trusted results only<br/>";
-        } elsif ($param eq "limit") {
-            $limit = $c->param($param);
-            next if ($limit == $Litmus::DB::Testresult::_num_results_default);
-            $limit_criteria .= "Limit to $limit results<br/>";
-        } elsif ($param eq 'branch') {
-            my $value = $c->param($param);
-            push @where, {field => $param,
-                          value => $value};
-            $where_criteria .= "Branch is \'".$c->param($param)."\'<br/>";
-            $defaults->{branch} =  $c->param($param);
-        } elsif ($param eq 'locale') {
-            my $value = $c->param($param);
-            push @where, {field => 'locale',
-                          value => $value};
-            $where_criteria .= "Locale is \'".$c->param($param)."\'<br/>";
-            $defaults->{locale} =  $c->param($param);
-        } elsif ($param eq 'email') {
-            my $value = $c->param($param);
-            push @where, {field => 'email',
-                          value => $value};
-            $where_criteria .= "Submitted By is \'".$c->param($param)."\'<br/>";
-            $defaults->{locale} =  $c->param($param);
-        } elsif ($param eq 'product') {
-            my $value = $c->param($param);
-            push @where, {field => $param,
-                          value => $value};
-            $where_criteria .= "Product is \'".$c->param($param)."\'<br/>";
-            $defaults->{product} = $c->param($param);
-        } elsif ($param eq 'platform') {
-            my $value = $c->param($param);
-            push @where, {field => $param,
-                          value => $value};
-            $where_criteria .= "Platform is \'".$c->param($param)."\'<br/>";
-            $defaults->{platform} = $c->param($param);
-        } elsif ($param eq 'test_group') {
-            my $value = $c->param($param);
-            push @where, {field => $param,
-                          value => $value};
-            $where_criteria .= "Test group is \'".$c->param($param)."\'<br/>";
-            $defaults->{test_group} = $c->param($param);
-        } elsif ($param eq 'test_id') {
-            my $value = $c->param($param);
-            push @where, {field => $param,
-                          value => $value};
-            $where_criteria .= "Testcase ID# is \'".$c->param($param)."\'<br/>";
-            $defaults->{test_id} = $c->param($param);                
-        } elsif ($param eq 'summary') {
-            my $value = $c->param($param);
-            push @where, {field => $param,
-                          value => $value};
-            $where_criteria .= "Summary like \'".$c->param($param)."\'<br/>";
-            $defaults->{summary} = $c->param($param);
-        } elsif ($param eq 'result_status') {
-            my $value = $c->param($param);
-            push @where, {field => $param,
-                          value => $value};
-            $where_criteria .= "Status is \'".$c->param($param)."\'<br/>";
-            $defaults->{result_status} = $c->param($param);
-        } else {
-            # Skip unknown field
-        }
-    }
-    if ($where_criteria eq '' and 
-        scalar(@order_by) == 0 and
-        $limit_criteria eq '') {
-        ($criteria,$results) = 
-          Litmus::DB::Testresult->getDefaultTestResults;    
-    } else {
-        foreach my $order_by_field (@order_by) {
-            next if (!$order_by_field);
-            $order_by_criteria .= "Order by $order_by_field->{field} $order_by_field->{direction}<br/>";
-        }
-
-        $criteria .= $where_criteria . $order_by_criteria . $limit_criteria;
-        $criteria =~ s/_/ /g;
-        $results = Litmus::DB::Testresult->getTestResults(\@where,
-                                                          \@order_by,
-                                                          $limit);
-    }
-} else {
-    ($criteria,$results) = 
-      Litmus::DB::Testresult->getDefaultTestResults;    
-}
-
-# Populate each of our form widgets for select/input.
-# Set a default value as appropriate.
-my $products = Litmus::FormWidget->getProducts;
-my $platforms = Litmus::FormWidget->getUniquePlatforms;
-my $test_groups = Litmus::FormWidget->getTestgroups;
-my $testcases = Litmus::FormWidget->getTestcaseIDs;
-my $result_statuses = Litmus::FormWidget->getResultStatuses;
-my $branches = Litmus::FormWidget->getBranches;
-my $locales = Litmus::FormWidget->getLocales;
-my $users = Litmus::FormWidget->getUsers;
-
-my $fields = Litmus::FormWidget->getFields;
-my $match_criteria = Litmus::FormWidget->getMatchCriteria;
-my $sort_fields = Litmus::FormWidget->getSortFields;
-
-my $title = 'Advanced Search';
-
-my $vars = {
-    title => $title,
-    criteria => $criteria,
-    products => $products,
-    platforms => $platforms,
-    test_groups => $test_groups,
-    testcases => $testcases,
-    result_statuses => $result_statuses,
-    branches => $branches,
-    locales => $locales,
-    users => $users,
-    fields => $fields,
-    match_criteria => $match_criteria,
-    sort_fields => $sort_fields,
-};
-
-# Only include results if we have them.
-if ($results and scalar @$results > 0) {
-    $vars->{results} = $results;
-}
-
-my $cookie =  Litmus::Auth::getCookie();
-$vars->{"defaultemail"} = $cookie;
-$vars->{"show_admin"} = Litmus::Auth::istrusted($cookie);
-
-Litmus->template()->process("reporting/advanced_search.tmpl", $vars) || 
-    internalError(Litmus->template()->error());
-
-exit 0;

mozilla/webtools/litmus/common_results.cgi

@@ -1,92 +0,0 @@
-#!/usr/bin/perl -w
-# -*- mode: cperl; c-basic-offset: 8; indent-tabs-mode: nil; -*-
-
-# ***** BEGIN LICENSE BLOCK *****
-# Version: MPL 1.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 Litmus.
-#
-# The Initial Developer of the Original Code is
-# the Mozilla Corporation.
-# Portions created by the Initial Developer are Copyright (C) 2006
-# the Initial Developer. All Rights Reserved.
-#
-# Contributor(s):
-#   Chris Cooper <ccooper@deadsquid.com>
-#   Zach Lipton <zach@zachlipton.com>
-#
-# ***** END LICENSE BLOCK *****
-
-use strict;
-$|++;
-
-use Litmus;
-use Litmus::Auth;
-use Litmus::Error;
-use Litmus::DB::Testresult;
-use Litmus::FormWidget;
-
-
-use CGI;
-use Time::Piece::MySQL;
-
-Litmus->init();
-my $c = Litmus->cgi();
-print $c->header();
-
-my $results;
-if ($c->param and $c->param('status')) {
-  if ($c->param('status') =~ /pass/i or
-      $c->param('status') =~ /fail/i or
-      $c->param('status') =~ /unclear/i) {
-    $results = Litmus::DB::Testresult->getCommonResults($c->param('status'));
-  } else {
-    internalError("You must provide a valid status type: pass|fail|unclear");
-    exit 1;
-  }                                                      
-} else {
-  internalError("You must provide a status type: pass|fail|unclear");
-  exit 1;
-}
-
-my $title;
-if ($c->param('status') eq 'pass') {
-  $title = "Most Commonly Passed Testcases";
-} elsif ($c->param('status') eq 'fail') {
-  $title = "Most Common Failures";
-} elsif ($c->param('status') eq 'unclear') {
-  $title = "Testcases Most Frequently Marked As Unclear";
-} 
-
-my $vars = {
-            title => $title,
-            status => $c->param('status'),
-           };
-
-# Only include results if we have them.
-if ($results and scalar @$results > 0) {
-    $vars->{results} = $results;
-}
-
-$vars->{"defaultemail"} = Litmus::Auth::getCookie();
-
-Litmus->template()->process("reporting/common_results.tmpl", $vars) ||
-  internalError(Litmus->template()->error());
-
-exit 0;
-
-
-
-
-
-

mozilla/webtools/litmus/edit_users.cgi

@@ -1,105 +0,0 @@
-#!/usr/bin/perl -w
-# -*- Mode: perl; indent-tabs-mode: nil -*-
-#
-# 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 Litmus.
-#
-# The Initial Developer of the Original Code is Netscape Communications
-# Corporation. Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): Zach Lipton <zach@zachlipton.com>
-
-use strict;
-
-use Litmus;
-use Litmus::Error;
-use Litmus::DB::Product;
-use Litmus::DB::TestcaseSubgroup;
-use Litmus::Auth;
-use Litmus::Utils;
-
-use CGI;
-use Time::Piece::MySQL;
-
-Litmus->init();
-my $c = Litmus->cgi(); 
-
-# obviously, you need to be an admin to edit users...
-Litmus::Auth::requireAdmin('edit_users.cgi');
-
-if ($c->param('search_string')) {
-	# search for users:
-	my $users = Litmus::DB::User->search_FullTextMatches(
-													$c->param('search_string'), 
-													$c->param('search_string'),
-													$c->param('search_string'));
-	my $vars = {
-		users => $users,
-	};
-	print $c->header();
-	Litmus->template()->process("admin/edit_users/search_results.html.tmpl", $vars) || 
-		internalError(Litmus->template()->error()); 
-} elsif ($c->param('id')) {
-	# lookup a given user
-	my $uid = $c->param('id');
-	my $user = Litmus::DB::User->retrieve($uid);
-	print $c->header();
-	if (! $user) {
-		invalidInputError("Invalid user id: $uid");
-	}
-	my $vars = {
-		user => $user,
-	};
-		Litmus->template()->process("admin/edit_users/edit_user.html.tmpl", $vars) || 
-		internalError(Litmus->template()->error()); 
-} elsif ($c->param('user_id')) {
-	# process changes to a user:
-	my $user = Litmus::DB::User->retrieve($c->param('user_id'));
-	print $c->header();
-	if (! $user) {
-		invalidInputError("Invalid user id: " . $c->param('user_id'));
-	}
-	$user->bugzilla_uid($c->param('bugzilla_uid'));
-	$user->email($c->param('edit_email'));
-
-	if ($c->param('edit_password') ne 'unchanged') {
-		# they changed the password, so let the auth folks know:
-		Litmus::Auth::changePassword($user, $c->param('edit_password'));
-	}
-	$user->realname($c->param('realname'));
-	$user->irc_nickname($c->param('irc_nickname'));
-	if ($c->param('enabled')) {
-		$user->enabled(1);
-	}
-	if ($c->param('is_admin')) {
-		$user->is_admin(1);
-	}
-	$user->authtoken($c->param('authtoken'));
-	$user->update();
-	my $vars = {
-		user => $user,
-	};
-	Litmus->template()->process("admin/edit_users/user_edited.html.tmpl", $vars) || 
-		internalError(Litmus->template()->error()); 
-} else {
-	# we're here for the first time, so display the search form
-	my $vars = {
-	};
-	print $c->header();
-	Litmus->template()->process("admin/edit_users/search_users.html.tmpl", $vars) || 
-		internalError(Litmus->template()->error()); 
-}
-
-
-

mozilla/webtools/litmus/enter_test.cgi

@@ -1,82 +0,0 @@
-#!/usr/bin/perl -w
-# -*- Mode: perl; indent-tabs-mode: nil -*-
-#
-# 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 Litmus.
-#
-# The Initial Developer of the Original Code is Netscape Communications
-# Corporation. Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): Zach Lipton <zach@zachlipton.com>
-
-use strict;
-
-use Litmus;
-use Litmus::Error;
-use Litmus::DB::Product;
-use Litmus::DB::TestcaseSubgroup;
-use Litmus::Auth;
-use Litmus::Utils;
-
-use CGI;
-use Time::Piece::MySQL;
-use Date::Manip;
-
-Litmus->init();
-my $c = Litmus->cgi(); 
-
-# for the moment, you must be an admin to enter tests:
-Litmus::Auth::requireAdmin('enter_test.cgi');
-
-# if we're here for the first time, display the enter testcase form, 
-# otherwise, process the results: 
-
-if (! $c->param('enteringTestcase')) {
-	my $vars = {
-
-	};
-
-	print $c->header();
-	Litmus->template()->process("enter/enter.html.tmpl", $vars) || 
-        internalError(Litmus->template()->error()); 
-} else {
-	requireField('product', $c->param('product'));
-	requireField('test group', $c->param('testgroup'));
-	requireField('subgroup', $c->param('subgroup'));
-	requireField('summary', $c->param('summary'));
-	
-	my $newtest = Litmus::DB::Testcase->create({
-		product => $c->param('product'),
-		summary => $c->param('summary'), 
-		steps => $c->param('steps') ? $c->param('steps') : '',
-		expected_results => $c->param('expectedResults') ? 
-			$c->param('expectedResults') : '',
-		author  => Litmus::Auth::getCurrentUser(),
-		creation_date => &Date::Manip::UnixDate("now","%q"),
-		version => 1,
-	});
-	
-	my $newtsg = Litmus::DB::TestcaseSubgroup->create({
-		test => $newtest,
-		subgroup => $c->param('subgroup'),
-	});
-	
-	my $vars = {
-		test => $newtest,
-	};
-	
-	print $c->header();
-	Litmus->template()->process("enter/enterComplete.html.tmpl", $vars) || 
-        internalError(Litmus->template()->error()); 
-}