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/xpinstall/packager/windows/browser.jst

@@ -1,80 +0,0 @@
-function updateWinReg()
-{
-  //Notes:
-  // can't use a double backslash before subkey - Windows already puts it in.
-  // subkeys have to exist before values can be put in.
-  var winreg = getWinRegistry();
-  var subkey;  //the name of the subkey you are poking around in
-  var valname; // the name of the value you want to look at
-  var value;   //the data in the value you want to look at.
-
-  if(winreg != null) 
-  {
-    winreg.setRootKey(winreg.HKEY_LOCAL_MACHINE);
-    subkey  = "SOFTWARE\\Netscape\\Netscape Seamonkey";
-    winreg.createKey(subkey,"");
-    valname = "CurrentVersion";
-    value   = "$UserAgent$";
-    err     = winreg.setValueString(subkey, valname, value);
-
-    subkey  = "SOFTWARE\\Netscape\\Netscape Seamonkey\\$UserAgent$\\Main";
-    winreg.createKey(subkey,"");
-    valname = "Install Directory";
-    value   = communicatorFolder;
-    err     = winreg.setValueString(subkey, valname, value);
-
-    // set the App Paths key here
-    subkey  = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\mozilla.exe";
-    winreg.createKey(subkey,"");
-    valname = "";
-    value   = communicatorFolder + "\\mozilla.exe";
-    err     = winreg.setValueString(subkey, valname, value);
-
-    valname = "Path";
-    value   = communicatorFolder;
-    err     = winreg.setValueString(subkey, valname, value);
-  }
-}
-
-// main
-var srDest;
-var err;
-var communicatorFolder;
-var fWindowsSystem;
-var fileComponentRegStr;
-var fileComponentReg;
-
-srDest = $SpaceRequired$:bin;
-err    = startInstall("Mozilla Seamonkey", "", "$Version$"); 
-logComment("startInstall: " + err);
-
-communicatorFolder = getFolder("Communicator");
-fWindowsSystem     = getFolder("Win System");
-logComment("communicatorFolder: " + communicatorFolder);
-
-if(verifyDiskSpace(communicatorFolder, srDest) == true)
-{
-  err = addDirectory("Program",
-                     "$Version$",
-                     "bin",              // dir name in jar to extract 
-                     communicatorFolder, // Where to put this file (Returned from GetFolder) 
-                     "",                 // subdir name to create relative to communicatorFolder
-                     true);              // Force Flag 
-  logComment("addDirectory() of Program returned: " + err);
-
-  // check return value
-  if(!checkError(err))
-  {
-    fileComponentRegStr = communicatorFolder + "\\component.reg";
-    fileComponentReg    = getFolder("file:///", fileComponentRegStr);
-    err                 = fileDelete(fileComponentReg);
-    logComment("fileDelete() returned: " + err);
-
-    updateWinReg();
-
-    err = finalizeInstall(); 
-    logComment("finalizeInstall() returned: " + err);
-  }
-}
-
-// end main

mozilla/xpinstall/packager/windows/config.it

@@ -1,451 +0,0 @@
-[General]
-; Run Mode values:
-;   Normal - Shows all dialogs.  Requires user input.
-;   Auto   - Shows some dialogs, but none requiring user input.  It will
-;            automatically install the product using default values.
-;   Silent - Show no dialogs at all.  It will install product using default
-;            values.
-Run Mode=Normal
-
-Product Name=Mozilla Seamonkey
-
-; Destination Path values:
-;   PROGRAMFILESDIR
-;   WINDISK
-;   WINDIR
-;   WINSYSDIR
-Path=[PROGRAMFILESDIR]\Netscape\Seamonkey
-
-; Program Folder Path values:
-;   COMMON_STARTUP
-;   COMMON_PROGRAMS
-;   COMMON_STARTMENU
-;   COMMON_DESKTOP
-;
-;   PERSONAL_STARTUP
-;   PERSONAL_PROGRAMS
-;   PERSONAL_STARTMENU
-;   PERSONAL_DESKTOP
-;
-;   PERSONAL_APPDATA
-;   PERSONAL_CACHE
-;   PERSONAL_COOKIES
-;   PERSONAL_FAVORITES
-;   PERSONAL_FONTS
-;   PERSONAL_HISTORY
-;   PERSONAL_NETHOOD
-;   PERSONAL_PERSONAL
-;   PERSONAL_PRINTHOOD (supported only under Windows NT)
-;   PERSONAL_RECENT
-;   PERSONAL_SENDTO
-;   PERSONAL_TEMPLATES
-;
-;   PROGRAMFILESDIR
-;   COMMONFILESDIR
-;   MEDIAPATH
-;   CONFIGPATH (supported only under Windows95 and Windows98)
-;   DEVICEPATH
-Program Folder Name=Mozilla Seamonkey
-Program Folder Path=[COMMON_PROGRAMS]
-
-; Default Setup Type values:
-;   Setup Type 0 - first radio button (default)
-;   Setup Type 1 - second radio button
-;   Setup Type 2 - third radio button
-;   Setup Type 3 - fourth radio button (usually the Custom option)
-Default Setup Type=Setup Type 0
-
-Setup Title0=Mozilla Seamonkey Setup
-Setup Title1=Build $Version$
-Setup Title2=
-
-; HKey:              valid decryptable setup keys are [Mozilla Seamonkey CurrentVersion]
-;                    and [Mozilla Seamonkey CurrentVersion].
-; Decrypt HKey:      there are times when '[' and ']' are valid part of windows registry key names.
-; Contains Filename: tells setup that the path contains filename needed to be removed before
-;                    using it as a path.
-; Verify Existance:  FILE or PATH
-;
-[Locate Previous Product Path0]
-HRoot=HKEY_LOCAL_MACHINE
-HKey=[Netscape Seamonkey CurrentVersion]\Main
-Name=Install Directory
-Decrypt HKey=TRUE
-Contains Filename=FALSE
-Verify Existance=
-
-; This section checks for legacy files.
-; If the file(s), indicated by the Filename= key, is found to have a version of less than the value
-; indicated by the Version= key, then display the string in the Message= key.
-[Legacy Check0]
-Filename=[SETUP PATH]\mozilla.exe
-Version=6.0.0.0
-Message=Setup has detected an old version of Mozilla in the chosen destination path that may pose compatibility issues.  It is highly recommended that a different destination path be used.  Would you like to chose a different path?
-
-[Dialog Welcome]
-Show Dialog=TRUE
-Title=Welcome
-Message0=Welcome to %s Setup.
-Message1=It is strongly recommended that you exit all Windows programs before running this Setup program.
-Message2=Click Cancel to quit Setup and then close any programs you have running.  Click Next to continue the Setup Program.
-
-[Dialog License]
-Show Dialog=FALSE
-Title=Software License Agreement
-License File=license.txt
-Message0=Please read the following license agreement.  Use the scroll bar to view the rest of this agreement.
-Message1=Click Accept if you accept the terms of the preceeding license agreement.  If No is clicked, setup will quit.
-
-[Dialog Setup Type]
-Show Dialog=TRUE
-Title=Setup Type
-Message0=Click the type of Setup you prefer, then click Next.
-Readme Filename=readme.txt
-Readme App=notepad.exe
-
-; at least one Setup Type needs to be set, and up to 4 can be
-; set (Setup Type0, Setup Type1, Setup Type2, Setup Type3).
-[Setup Type0]
-Description Short=B&ase
-Description Long=Program will be installed with the minimal options.
-
-; List of components to install/enable for this Setup Type.
-; All other components not listed here will be disabled if
-; this Setup Type is selected.
-C0=Component0
-C1=Component1
-
-[Setup Type1]
-Description Short=C&omplete
-Description Long=Program will be installed with the most common options.
-
-; List of components to install/enable for this Setup Type.
-; All other components not listed here will be disabled if
-; this Setup Type is selected.
-C0=Component0
-C1=Component1
-C2=Component2
-
-[Setup Type2]
-Description Short=C&ustom
-Description Long=You may choose the options you want to install.  Recommended for advanced users.
-;Description Short=&Pro
-;Description Long=Program will be installed with all the options available.
-
-; List of components to install/enable for this Setup Type.
-; All other components not listed here will be disabled if
-; this Setup Type is selected.
-C0=Component0
-C1=Component1
-C2=Component2
-
-;[Setup Type3]
-;Description Short=C&ustom
-;Description Long=You may choose the options you want to install.  Recommended for advanced users.
-
-; List of components to install/enable for this Setup Type.
-; All other components not listed here will be disabled if
-; this Setup Type is selected.
-;C0=Component0
-;C1=Component1
-;C2=Component2
-;C3=Component3
-
-[Dialog Select Components]
-Show Dialog=TRUE
-Title=Select Components
-Message0=
-
-[Dialog Windows Integration]
-Show Dialog=FALSE
-Title=Windows Integration
-Message0=Check the Mozilla Preference options you would like Setup to perform.
-Message1=These settings allow you to set default Internet preferences for browsing and searching.  They affect browsers installed on your machine, including Mozilla Communicator and Microsoft Internet Explorer.
-
-; Only a maximum of 4 "Windows Integration-Item"s are allowded.  Each Item
-; shows up as a checkbox in the Windows Integration dialog.
-[Windows Integration-Item0]
-CheckBoxState=FALSE
-Description=Make Mozilla Communicator my default Internet browser
-Archive=
-
-[Windows Integration-Item1]
-CheckBoxState=FALSE
-Description=Make Mozilla Netcenter my home page
-Archive=
-
-[Windows Integration-Item2]
-CheckBoxState=FALSE
-Description=Use Mozilla Netcenter to search the Web
-Archive=
-
-[Dialog Program Folder]
-Show Dialog=TRUE
-Title=Program Folder
-Message0=Setup will add program icons to the Program Folder listed below.  You may type a new folder name, or select one from the existing folder list.  Click Next to continue.
-
-[Dialog Start Install]
-Show Dialog=TRUE
-Title=Start Install
-Message0=Setup has enough information to start copying the program files.  If you want to review or change settings, click Back.  If you are satisfied with the current settings, click Install to begin copying files.
-
-[Dialog Reboot]
-; Show Dialog values are:
-;   TRUE  - Always show
-;   FALSE - Don't show unless at least one component has its reboot show value set
-;           to TRUE.  This will not show even if some files were in use and a reboot
-;           is necessary.
-;   AUTO  - Don't show unless a component has its reboot show value set to
-;           TRUE or there was at least one file in use and a reboot is
-;           is required for the file to be replaced correctly.
-Show Dialog=AUTO
-
-; These SmartDownload sections contain information to configure SmartDownload.
-; The info is applied to all components to be downloaded.
-[SmartDownload-Netscape Install]
-;core_file=base.zip
-;core_dir=[SETUP PATH]
-no_ads=true
-silent=false
-execution=false
-confirm_install=false
-;extract_msg=Uncompressing Seamonkey.  Please wait...
-
-[SmartDownload-Proxy]
-
-[SmartDownload-Execution]
-exe=
-exe_param=
-
-[Check Instance0]
-Class Name=NetscapeWindowClass
-Window Name=
-Message=Setup has detected that an instance of Seamonkey is currently running.  Please quit Seamonkey before continuing Setup.
-
-[Check Instance1]
-Process Name=psm.exe
-Message=Setup has detected that an instance of Personal Security Manager is currently running.  Personal Security Manager will quit by itself when there are no other applications running that require it.  A reboot might be necessary.  Setup will then be able to continue.
-
-; These are the components to be offered to the user (shown in the Select
-; Components dialog) for installation.
-; There is no limit to the number of components to install.
-[Component0]
-Description Short=Mozilla Xpinstall Engine
-Description Long=Install Engine
-Archive=core.xpi
-$InstallSize$:core
-$InstallSizeSystem$
-$InstallSizeArchive$:core.xpi
-; Attributes can be the following values:
-;   SELECTED  - the component is selected to be installed by default.
-;   INVISIBLE - the component is not shown in the Select Components dialog.
-Attributes=SELECTED|INVISIBLE
-; url keys can be as many as needed.  url0 is attempted first.  if it fails,
-; the next url key is tried in sequential order.
-; The url should not contain the filename.  Setup will assemble the complete url
-; using the url keys and the Archive key.
-url0=$URLPath$
-
-[Component1]
-Description Short=Mozilla Seamonkey
-Description Long=Browser software for the internet
-Archive=browser.xpi
-$InstallSize$:browser
-$InstallSizeSystem$
-$InstallSizeArchive$:browser.xpi
-Dependency0=Mozilla Xpinstall Engine
-; Attributes can be the following values:
-;   SELECTED  - the component is selected to be installed by default.
-;   INVISIBLE - the component is not shown in the Select Components dialog.
-Attributes=SELECTED|INVISIBLE
-; url keys can be as many as needed.  url0 is attempted first.  if it fails,
-; the next url key is tried in sequential order.
-; The url should not contain the filename.  Setup will assemble the complete url
-; using the url keys and the Archive key.
-url0=$URLPath$
-
-[Component2]
-Description Short=Mail & News
-Description Long=Seamonkey Mail & News
-Archive=mail.xpi
-$InstallSize$:mail
-$InstallSizeSystem$
-$InstallSizeArchive$:mail.xpi
-Dependency0=Mozilla Xpinstall Engine
-; Attributes can be the following values:
-;   SELECTED  - the component is selected to be installed by default.
-;   INVISIBLE - the component is not shown in the Select Components dialog.
-Attributes=SELECTED
-Parameter=
-; url keys can be as many as needed.  url0 is attempted first.  if it fails,
-; the next url key is tried in sequential order.
-; The url should not contain the filename.  Setup will assemble the complete url
-; using the url keys and the Archive key.
-url0=$URLPath$
-
-[Core]
-Source=[XPI PATH]\core.xpi
-Destination=[TEMP]\core.ns
-$InstallSize$:core
-Cleanup=TRUE
-Message=Preparing Install, please wait...
-
-; The Timing key needs to be one of the following values:
-;   pre download     - process before any files have been downloaded.
-;   post download    - process after all files have been downloaded.
-;   pre core         - process before the core file has been uncompressed.
-;   post core        - process after the core file has been uncompressed.
-;   pre smartupdate  - process before the smartupdate engine has been launched.
-;   post smartupdate - process after the smartupdate engine has been launched.
-;   pre launchapp    - process before the launching of executables.
-;   post launchapp   - process after the launching of executables.
-;   depend reboot    - process depending on if a reboot is necessary or not.
-;                      if reboot is necessary, installer can set it up so
-;                      the app runs once upon windows reboot.
-
-;Uncompress FileX sections
-;[Uncompress File0]
-;Timing=post download
-;Source=[XPI PATH]\core.xpi
-;Destination=[SETUP PATH]
-;Message=Configuring Seamonkey, please wait...
-
-;[Uncompress File1]
-;Timing=post download
-;Source=[XPI PATH]\extratest.xpi
-;Destination=[SETUP PATH]
-;Message=Configuring Extra test files, please wait...
-
-;Move FileX sections
-;[Move File0]
-;Timing=post download
-;Source=[SETUP PATH]\bin\*
-;Destination=[SETUP PATH]\program
-
-;[Move File1]
-;Timing=post download
-;Source=[SETUP PATH]\ftmain\*
-;Destination=[SETUP PATH]\program
-
-;Copy FileX sections
-[Copy File0]
-Timing=post launchapp
-Source=[JRE BIN PATH]\npjava*.dll
-Destination=[SETUP PATH]\Plugins
-Fail If Exists=FALSE
-
-;[Copy File1]
-;Timing=post launchapp
-;Source=[TEMP]\xtratest\bin\*.*
-;Destination=[SETUP PATH]
-;Fail If Exists=FALSE
-
-;[Copy File1]
-;Timing=post download
-;Source=[SETUP PATH]\bin\*.exe
-;Destination=[TEMP]
-;Fail If Exists=
-
-;Create DirectoryX sections
-[Create Directory0]
-Timing=post download
-Destination=[SETUP PATH]\Plugins
-
-;[Create Directory1]
-;Timing=post download
-;Destination=[TEMP]\Test\temp
-
-;Delete FileX sections
-[Delete File0]
-Timing=post download
-Destination=[COMMON_PROGRAMS]\Mozilla Seamonkey\Mozilla AppRunner.lnk
-
-;Remove DirectoryX sections
-;[Remove Directory0]
-;Timing=post launchapp
-;Destination=[TEMP]\xtratest
-;Remove subdirs=TRUE
-
-;RunAppX sections
-[RunApp0]
-Timing=depend reboot
-Wait=FALSE
-Target=[SETUP PATH]\mozilla.exe
-Parameters=-installer
-WorkingDir=[SETUP PATH]
-
-; Values for Show Folder:
-;   HIDE             Hides the window and activates another window.
-;   MAXIMIZE         Maximizes the specified window.
-;   MINIMIZE         Minimizes the specified window and activates the next
-;                    top-level window in the z-order.
-;   RESTORE          Activates and displays the window. If the window is
-;                    minimized or maximized, Windows restores it to its
-;                    original size and position. An application should specify
-;                    this flag when restoring a minimized window.
-;   SHOW             Activates the window and displays it in its current size
-;                    and position.
-;   SHOWMAXIMIZED    Activates the window and displays it as a maximized
-;                    window.
-;   SHOWMINIMIZED    Activates the window and displays it as a minimized
-;                    window.
-;   SHOWMINNOACTIVE  Displays the window as a minimized window. The active
-;                    window remains active.
-;   SHOWNA           Displays the window in its current state. The active
-;                    window remains active.
-;   SHOWNOACTIVATE   Displays a window in its most recent size and position.
-;                    The active window remains active.
-;   SHOWNORMAL       Activates and displays a window. If the window is
-;                    minimized or maximized, Windows restores it to its
-;                    original size and position. An application should specify
-;                    this flag when displaying the window for the first time.
-[Program Folder0]
-Timing=post download
-Show Folder=SHOW
-Program Folder=[Default Folder]
-
-[Program Folder0-Shortcut0]
-File=[SETUP PATH]\mozilla.exe
-Arguments=
-Working Dir=[SETUP PATH]
-Description=Mozilla Seamonkey
-Icon Path=[SETUP PATH]\mozilla.exe
-Icon Id=0
-
-;[Program Folder0-Shortcut1]
-;File=[SETUP PATH]\bin\viewer.exe
-;Arguments=
-;Working Dir=[SETUP PATH]
-;Description=Mozilla Viewer
-;Icon Path=[SETUP PATH]\bin\viewer.exe
-;Icon Id=0
-
-;[Program Folder0-Shortcut2]
-;File=[SETUP PATH]\bin\Net2fone.exe
-;Arguments=
-;Working Dir=[SETUP PATH]
-;Description=Net2Fone
-;Icon Path=[SETUP PATH]\bin\Net2fone.exe
-;Icon Id=0
-
-;[Program Folder1]
-;Timing=post download
-;Show Folder=SHOW
-;Program Folder=[Default Folder]\lala land
-
-;[Program Folder1-Shortcut0]
-;File=c:\bin\getver.exe
-;Arguments=
-;Working Dir=[TEMP]
-;Description=Getver Test
-;Icon Path=[WINDISK]\4nt\4nt.exe
-;Icon Id=0
-
-;[Program Folder1-Shortcut1]
-;File=c:\perl\bin\perl.exe
-;Arguments=
-;Working Dir=[WINSYS]
-;Description=Perl
-;Icon Path=c:\perl\bin\perl.exe
-;Icon Id=0
-

mozilla/xpinstall/packager/windows/core.jst

@@ -1,40 +0,0 @@
-// main
-var srDest;
-var err;
-var communicatorFolder;
-var fWindowsSystem;
-var fileComponentRegStr;
-var fileComponentReg;
-
-srDest = $SpaceRequired$:bin;
-err    = startInstall("Mozilla Xpinstall Engine", "", "$Version$"); 
-logComment("startInstall: " + err);
-
-communicatorFolder = getFolder("Communicator");
-fWindowsSystem     = getFolder("Win System");
-logComment("communicatorFolder: " + communicatorFolder);
-
-if(verifyDiskSpace(communicatorFolder, srDest) == true)
-{
-  err = addDirectory("Program",
-                     "$Version$",
-                     "bin",              // dir name in jar to extract 
-                     communicatorFolder, // Where to put this file (Returned from GetFolder) 
-                     "",                 // subdir name to create relative to communicatorFolder
-                     true);              // Force Flag 
-  logComment("addDirectory() of Program returned: " + err);
-
-  // check return value
-  if(!checkError(err))
-  {
-    fileComponentRegStr = communicatorFolder + "\\component.reg";
-    fileComponentReg    = getFolder("file:///", fileComponentRegStr);
-    err                 = fileDelete(fileComponentReg);
-    logComment("fileDelete() returned: " + err);
-
-    err = finalizeInstall(); 
-    logComment("finalizeInstall() returned: " + err);
-  }
-}
-
-// end main

mozilla/xpinstall/packager/windows/editor.jst

@@ -1,18 +0,0 @@
-var err = StartInstall("Mozilla Editor", "Seamonkey", "$Version$"); 
-LogComment("StartInstall: " + err);
-
-var communicatorFolder = Install.GetFolder("Communicator");
-LogComment("communicatorFolder: " + communicatorFolder);
-
-err = AddDirectory("Program",
-                   "$Version$",
-                   "bin",              // fileName in jar, 
-                   communicatorFolder, // Where to put this file (Returned from GetFolder) 
-                   "",                 // fileName in jar, 
-                   true);              // Force Flag 
-
-LogComment("AddDirectory() returned: " + err);
-
-err = FinalizeInstall(); 
-LogComment("FinalizeInstall() returned: " + err);
-

mozilla/xpinstall/packager/windows/mail.jst

@@ -1,33 +0,0 @@
-// main
-var srDest;
-var err;
-var communicatorFolder;
-
-srDest = $SpaceRequired$:bin;
-err    = startInstall("Mozilla Mail", "", "$Version$"); 
-logComment("startInstall: " + err);
-// check return value
-checkError(err);
-
-communicatorFolder = getFolder("Communicator");
-logComment("communicatorFolder: " + communicatorFolder);
-
-if(verifyDiskSpace(communicatorFolder, srDest) == true)
-{
-  err = addDirectory("Program",
-                     "$Version$",
-                     "bin",              // dir name in jar to extract 
-                     communicatorFolder, // Where to put this file (Returned from GetFolder) 
-                     "",                 // subdir name to create relative to communicatorFolder
-                     true);              // Force Flag 
-  logComment("addDirectory() returned: " + err);
-
-  // check return value
-  if(!checkError(err))
-  {
-    err = finalizeInstall(); 
-    logComment("finalizeInstall() returned: " + err);
-  }
-}
-
-// end main

mozilla/xpinstall/packager/windows/makeall.pl

@@ -1,134 +0,0 @@
-#!c:\perl\bin\perl
-# 
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#  
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#  
-# The Original Code is Mozilla Communicator client code, released
-# March 31, 1998.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation. Portions created by Netscape are
-# Copyright (C) 1998-1999 Netscape Communications Corporation. All
-# Rights Reserved.
-# 
-# Contributor(s): 
-# Sean Su <ssu@netscape.com>
-# 
-
-#
-# This perl script builds the xpi, config.ini, and js files.
-#
-
-# Make sure there are at least four arguments
-if($#ARGV < 3)
-{
-  die "usage: $0 <default version> <URL path> <staging path> <dist install path>
-
-       default version   : julian based date version
-                           ie: 5.0.0.99257
-
-       URL path          : URL path to where the .xpi files will be staged at.
-                           Either ftp:// or http:// can be used.  Nothing will be
-                           copied to there by this script.  It is used for config.ini.
-
-       staging path      : full path to where the components are staged at
-
-       dist install path : full path to where the mozilla/dist/win32_o.obj/install is at.
-       \n";
-}
-
-$inDefaultVersion     = $ARGV[0];
-$inURLPath            = $ARGV[1];
-$inStagePath          = $ARGV[2];
-$inDistPath           = $ARGV[3];
-$seiFileNameGeneric   = "nsinstall.exe";
-$seiFileNameSpecific  = "mozilla-win32-installer.exe";
-$userAgent            = "5.0b1 (en)";
-
-# Check for existance of staging path
-if(!(-e "$inStagePath"))
-{
-  die "invalid path: $inStagePath\n";
-}
-
-# Make sure inDestPath exists
-if(!(-e "$inDistPath"))
-{
-  mkdir ("$inDestPath",0775);
-}
-
-# Make .js files
-MakeJsFile("core");
-MakeJsFile("browser");
-MakeJsFile("mail");
-
-# Make .xpi files
-MakeXpiFile("core");
-MakeXpiFile("browser");
-MakeXpiFile("mail");
-
-MakeConfigFile();
-
-if(-e "$inDistPath\\setup")
-{
-  unlink <$inDistPath\\setup\\*>;
-}
-else
-{
-  mkdir ("$inDistPath\\setup",0775);
-}
-
-# Copy the setup files to the dist setup directory.
-system("xcopy /f config.ini                 $inDistPath\\");
-system("xcopy /f config.ini                 $inDistPath\\setup\\");
-system("xcopy /f $inDistPath\\setup.exe     $inDistPath\\setup\\");
-system("xcopy /f $inDistPath\\setuprsc.dll  $inDistPath\\setup\\");
-
-# build the self-extracting .exe file.
-print "\nbuilding self-extracting installer ($seiFileNameSpecific)...\n";
-system("copy $inDistPath\\$seiFileNameGeneric $inDistPath\\$seiFileNameSpecific");
-system("$inDistPath\\nszip.exe $inDistPath\\$seiFileNameSpecific $inDistPath\\setup\\*.* $inDistPath\\xpi\\*.*");
-
-print " done!\n";
-
-# end of script
-exit(0);
-
-sub MakeConfigFile
-{
-  # Make config.ini file
-  if(system("perl makecfgini.pl config.it $inDefaultVersion $inStagePath $inDistPath\\xpi $inURLPath") != 0)
-  {
-    exit(1);
-  }
-}
-
-sub MakeJsFile
-{
-  my($componentName) = @_;
-
-  # Make .js file
-  if(system("perl makejs.pl $componentName.jst $inDefaultVersion \"$userAgent\" $inStagePath\\$componentName") != 0)
-  {
-    exit(1);
-  }
-}
-
-sub MakeXpiFile
-{
-  my($componentName) = @_;
-
-  # Make .xpi file
-  if(system("perl makexpi.pl $componentName $inStagePath $inDistPath\\xpi") != 0)
-  {
-    exit(1);
-  }
-}
-

mozilla/xpinstall/packager/windows/makecfgini.pl

@@ -1,207 +0,0 @@
-#!c:\perl\bin\perl
-# 
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#  
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#  
-# The Original Code is Mozilla Communicator client code, released
-# March 31, 1998.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation. Portions created by Netscape are
-# Copyright (C) 1998-1999 Netscape Communications Corporation. All
-# Rights Reserved.
-# 
-# Contributor(s): 
-# Sean Su <ssu@netscape.com>
-# 
-
-#
-# This perl script parses the input file for special variables
-# in the format of $Variable$ and replace it with the appropriate
-# value(s).
-#
-# Input: .it file
-#             - which is a .ini template
-#        version
-#             - version to display on the blue background
-#        Path to staging area
-#             - path on where the seamonkey built bits are staged to
-#        xpi path
-#             - path on where xpi files will be located at
-#        URL path
-#             - path to where the .xpi files are staged.  can be
-#               either ftp:// or http://
-#
-#   ie: perl makecfgini.pl config.it 5.0.0.1999120608 z:\exposed\windows\32bit\en\5.0 d:\builds\mozilla\dist\win32_0.obj\install\xpi ftp://sweetlou/products/client/seamonkey/windows/32bit/x86/1999-09-13-10-M10
-#
-
-# Make sure there are at least two arguments
-if($#ARGV < 4)
-{
-  die "usage: $0 <.it file> <version> <staging path> <.xpi path> <URL path>
-
-       .it file     : input ini template file
-       version      : version to be shown in setup.  Typically the same version
-                      as show in mozilla.exe.
-       staging path : path to where the components are staged at
-       .xpi path    : path to where the .xpi files have been built to
-       URL path     : URL path to where the .xpi files will be staged at.
-                      Either ftp:// or http:// can be used
-       \n";
-}
-
-$inItFile         = $ARGV[0];
-$inVersion        = $ARGV[1];
-$inStagePath      = $ARGV[2];
-$inXpiPath        = $ARGV[3];
-$inURLPath        = $ARGV[4];
-
-# Get the name of the file replacing the .it extension with a .ini extension
-@inItFileSplit    = split(/\./,$inItFile);
-$outIniFile       = $inItFileSplit[0];
-$outIniFile      .= ".ini";
-
-# Open the input file
-open(fpInIt, $inItFile) || die "\ncould not open $ARGV[0]: $!\n";
-
-# Open the output file
-open(fpOutIni, ">$outIniFile") || die "\nCould not open $outIniFile: $!\n";
-
-print "\n Making $outIniFile...\n";
-
-# While loop to read each line from input file
-while($line = <fpInIt>)
-{
-  # For each line read, search and replace $InstallSize$ with the calculated size
-  if($line =~ /\$InstallSize\$/i)
-  {
-    $installSize          = 0;
-    $installSizeSystem    = 0;
-
-    # split read line by ":" deliminator
-    @colonSplit = split(/:/, $line);
-    if($#colonSplit >= 0)
-    {
-      $componentName    = $colonSplit[1];
-      chop($componentName);
-
-      $installSize      = OutputInstallSize("$inStagePath\\$componentName");
-
-      # special oji consideration here.  Since it's an installer that 
-      # seamonkey installer will be calling, the disk space allocation
-      # needs to be adjusted by an expansion factor of 3.62.
-      if($componentName =~ /oji/i)
-      {
-        $installSize = int($installSize * 3.62);
-      }
-    }
-
-    # Read the next line to calculate for the "Install Size System="
-    if($line = <fpInIt>)
-    {
-      if($line =~ /\$InstallSizeSystem\$/i)
-      {
-        $installSizeSystem = OutputInstallSizeSystem($line, "$inStagePath\\$componentName");
-      }
-    }
-
-    $installSize -= $installSizeSystem;
-    print fpOutIni "Install Size=$installSize\n";
-    print fpOutIni "Install Size System=$installSizeSystem\n";
-  }
-  elsif($line =~ /\$InstallSizeArchive\$/i)
-  {
-    $installSizeArchive = 0;
-
-    # split read line by ":" deliminator
-    @colonSplit = split(/:/, $line);
-    if($#colonSplit >= 0)
-    {
-      $componentName = $colonSplit[1];
-      chop($componentName);
-
-      $installSizeArchive = OutputInstallSizeArchive("$inXpiPath\\$componentName");
-    }
-
-    print fpOutIni "Install Size Archive=$installSizeArchive\n";
-  }
-  elsif($line =~ /\$Version\$/i)
-  {
-    # For each line read, search and replace $Version$ with the version passed in
-    $line =~ s/\$Version\$/$inVersion/i;
-    print fpOutIni $line;
-  }
-  else
-  {
-    # For each line read, search and replace $InstallSizeSystem$ with the calculated size
-    $line =~ s/\$URLPath\$/$inURLPath/i;
-    print fpOutIni $line;
-  }
-}
-
-print " done!\n";
-
-# end of script
-exit(0);
-
-sub OutputInstallSize()
-{
-  my($inPath) = @_;
-  my($installSize);
-
-  print "   calculating size for $inPath\n";
-  $installSize    = `ds32.exe /D /L0 /A /S /C 32768 $inPath`;
-  $installSize   += 32768; # take into account install.js
-  $installSize    = int($installSize / 1024);
-  $installSize   += 1;
-  return($installSize);
-}
-
-sub OutputInstallSizeArchive()
-{
-  my($inPath) = @_;
-  my($installSizeArchive);
-  my($dev, $ino, $mode, $nlink, $uid, $gui, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks);
-
-  print "   calculating size for $inPath\n";
-  ($dev, $ino, $mode, $nlink, $uid, $gui, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks) = stat $inPath;
-  $installSizeArchive   += 32768; # take into account install.js
-  $installSizeArchive    = int($size / 1024);
-  $installSizeArchive   += 1;
-  return($installSizeArchive);
-}
-
-sub OutputInstallSizeSystem()
-{
-  my($inLine, $inPath) = @_;
-  my($installSizeSystem) = 0;
-
-  # split read line by ":" deliminator
-  @colonSplit = split(/:/, $inLine);
-  if($#colonSplit >= 0)
-  {
-    # split line by "," deliminator
-    @commaSplit = split(/\,/, $colonSplit[1]);
-    if($#commaSplit >= 0)
-    {
-      foreach(@commaSplit)
-      {
-        # calculate the size of component installed using ds32.exe in Kbytes
-        print "   calculating size for $inPath\\$_";
-        $installSizeSystem += `ds32.exe /D /L0 /A /S /C 32768 $inPath\\$_`;
-      }
-    }
-  }
-
-  $installSizeSystem  = int($installSizeSystem / 1024);
-  $installSizeSystem += 1;
-  return($installSizeSystem);
-}
-

mozilla/xpinstall/packager/windows/makejs.pl

@@ -1,122 +0,0 @@
-#!c:\perl\bin\perl
-# 
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#  
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#  
-# The Original Code is Mozilla Communicator client code, released
-# March 31, 1998.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation. Portions created by Netscape are
-# Copyright (C) 1998-1999 Netscape Communications Corporation. All
-# Rights Reserved.
-# 
-# Contributor(s): 
-# Sean Su <ssu@netscape.com>
-# 
-
-#
-# This perl script parses the input file for special variables
-# in the format of $Variable$ and replace it with the appropriate
-# value(s).
-#
-# Input: .jst file              - which is a .js template
-#        default version        - a julian date in the form of:
-#                                 major.minor.release.yydoy
-#                                 ie: 5.0.0.99256
-#        user agent             - user agent of product
-#        component staging path - path to where the components are staged at
-#
-#        ie: perl makejs.pl core.jst 5.0.0.99256
-#
-
-# Make sure there are at least two arguments
-if($#ARGV < 3)
-{
-  die "usage: $0 <.jst file> <default version> <UserAgent> <staging path>
-
-       .jst file              : .js template input file
-       default version        : default julian base version number to use in the
-                                form of: major.minor.release.yydoy
-                                ie: 5.0.0.99256
-       user agent             : user agent of product (5.0b1 [en])
-       component staging path : path to where this component is staged at
-                                ie: z:\\stage\\windows\\32bit\\en\\5.0\\core
-       \n";
-}
-
-$inJstFile        = $ARGV[0];
-$inVersion        = $ARGV[1];
-$inUserAgent      = $ARGV[2];
-$inStagePath      = $ARGV[3];
-
-# Get the name of the file replacing the .jst extension with a .js extension
-@inJstFileSplit   = split(/\./,$inJstFile);
-$outJsFile        = $inJstFileSplit[0];
-$outJsFile       .= ".js";
-$outTempFile      = $inJstFileSplit[0];
-$outTempFile     .= ".template";
-
-system("copy ..\\common\\share.t $outTempFile");
-system("cat $inJstFile >> $outTempFile");
-
-# Open the input .template file
-open(fpInTemplate, $outTempFile) || die "\ncould not open $outTempFile: $!\n";
-
-# Open the output .js file
-open(fpOutJs, ">$outJsFile") || die "\nCould not open $outJsFile: $!\n";
-
-# While loop to read each line from input file
-while($line = <fpInTemplate>)
-{
-  # For each line read, search and replace $Version$ with the version passed in
-  if($line =~ /\$Version\$/i)
-  {
-    $line =~ s/\$Version\$/$inVersion/i;
-  }
-  elsif($line =~ /\$UserAgent\$/i)
-  {
-    $line =~ s/\$UserAgent\$/$inUserAgent/i;
-  }
-  elsif($line =~ /\$SpaceRequired\$/i) # For each line read, search and replace $InstallSize$ with the calculated size
-  {
-    $spaceRequired = 0;
-
-    # split read line by ":" deliminator
-    @colonSplit = split(/:/, $line);
-    if($#colonSplit > 0)
-    {
-      @semiColonSplit = split(/;/, $colonSplit[1]);
-      $subDir         = $semiColonSplit[0];
-      $spaceRequired  = GetSpaceRequired("$inStagePath\\$subDir");
-      $line =~ s/\$SpaceRequired\$:$subDir/$spaceRequired/i;
-    }
-    else
-    {
-      $spaceRequired = GetSpaceRequired("$inStagePath");
-      $line =~ s/\$SpaceRequired\$/$spaceRequired/i;
-    }
-  }
-
-  print fpOutJs $line;
-}
-
-sub GetSpaceRequired()
-{
-  my($inPath) = @_;
-  my($spaceRequired);
-
-  print "   calulating size for $inPath\n";
-  $spaceRequired    = `ds32.exe /D /L0 /A /S /C 32768 $inPath`;
-  $spaceRequired    = int($spaceRequired / 1024);
-  $spaceRequired   += 1;
-  return($spaceRequired);
-}
-

mozilla/xpinstall/packager/windows/makexpi.pl

@@ -1,114 +0,0 @@
-#!c:\perl\bin\perl
-# 
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#  
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#  
-# The Original Code is Mozilla Communicator client code, released
-# March 31, 1998.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation. Portions created by Netscape are
-# Copyright (C) 1998-1999 Netscape Communications Corporation. All
-# Rights Reserved.
-# 
-# Contributor(s): 
-# Sean Su <ssu@netscape.com>
-# 
-
-#
-# This perl script creates .xpi files given component input name
-#
-# Input: component name
-#             - name of the component directory located in the staging path
-#        staging path
-#             - path to where the built files are staged at
-#        dest path
-#             - path to where the .xpi files are are to be created at.
-#               ** MUST BE AN ABSOLUTE PATH, NOT A RELATIVE PATH **
-#
-#   ie: perl makexpi.pl core z:\exposed\windows\32bit\en\5.0 d:\build\mozilla\dist\win32_o.obj\install\working
-#
-
-use File::Copy;
-use Cwd;
-
-# Make sure there are at least three arguments
-if($#ARGV < 2)
-{
-  die "usage: $0 <component name> <staging path> <dest path>
-
-       component name : name of component directory within staging path
-       staging path   : path to where the components are staged at
-       dest path      : path to where the .xpi files are to be created at
-       \n";
-}
-
-$inComponentName  = $ARGV[0];
-$inStagePath      = $ARGV[1];
-$inDestPath       = $ARGV[2];
-
-# check for existance of staging component path
-if(!(-e "$inStagePath\\$inComponentName"))
-{
-  die "invalid path: $inStagePath\\$inComponentName\n";
-}
-
-# check for existance of .js script
-if(!(-e "$inComponentName.js"))
-{
-  die "missing .js script: $inComponentName.js\n";
-}
-
-# delete component .xpi file
-if(-e "$inDestPath\\$inComponentName.xpi")
-{
-  unlink("$inDestPath\\$inComponentName.xpi");
-}
-if(-e "$inStagePath\\$incomponentName\\$inComponentName.xpi")
-{
-  unlink("$inDestPath\\$inComponentName.xpi");
-}
-
-# delete install.js
-if(-e "install.js")
-{
-  unlink("install.js");
-}
-
-# make sure inDestPath exists
-if(!(-e "$inDestPath"))
-{
-  system("mkdir $inDestPath");
-}
-
-print "\n Making $inComponentName.xpi...\n";
-
-$saveCwdir = cwd();
-
-# change directory to where the files are, else zip will store
-# unwanted path information.
-chdir("$inStagePath\\$inComponentName");
-system("zip -r $inDestPath\\$inComponentName.xpi *");
-chdir("$saveCwdir");
-
-copy("$inComponentName.js", "install.js");
-system("zip -g $inDestPath\\$inComponentName.xpi install.js");
-
-# delete install.js
-if(-e "install.js")
-{
-  unlink("install.js");
-}
-
-print " done!\n";
-
-# end of script
-exit(0);
-

mozilla/xpinstall/packager/windows/rdir.pl

@@ -1,111 +0,0 @@
-#!c:\perl\bin\perl
-# 
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#  
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#  
-# The Original Code is Mozilla Communicator client code, released
-# March 31, 1998.
-# 
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation. Portions created by Netscape are
-# Copyright (C) 1998-1999 Netscape Communications Corporation. All
-# Rights Reserved.
-# 
-# Contributor(s): 
-# Sean Su <ssu@netscape.com>
-# 
-
-use Cwd;
-
-if($#ARGV < 0)
-{
-    print_usage();
-    exit(1);
-}
-
-print "removing directory:\n";
-for($i = 0; $i <= $#ARGV; $i++)
-{
-    print "  $ARGV[$i]";
-    remove_dir_structure($ARGV[$i]);
-    print "\n";
-}
-
-exit(0);
-# end
-
-sub remove_dir_structure
-{
-    my($curr_dir) = @_;
-    $save_cwd     = cwd();
-    $save_cwd     =~ s/\//\\/g;
-    if((-e "$curr_dir") && (-d "$curr_dir"))
-    {
-        remove_all_dir($curr_dir);
-        chdir($save_cwd);
-        remove_directory($curr_dir);
-        print " done!";
-    }
-    else
-    {
-        if(!(-e "$curr_dir"))
-        {
-            print "\n";
-            print "$curr_dir does not exist!";
-        }
-        elsif(!(-d "$curr_dir"))
-        {
-            print "\n";
-            print "$curr_dir is not a valid directory!";
-        }
-    }
-}
-
-sub remove_all_dir
-{
-    my($curr_dir) = @_;
-    my(@dirlist);
-    my($dir);
-
-    chdir("$curr_dir");
-    @dirlist = <*>;
-    foreach $dir (@dirlist)
-    {
-        if(-d "$dir")
-        {
-            print ".";
-            remove_all_dir($dir);
-        }
-    }
-    chdir("..");
-    remove_directory($curr_dir);
-}
-
-sub remove_directory
-{
-    my($directory) = @_;
-    my($save_cwd);
-
-    $save_cwd = cwd();
-    $save_cwd =~ s/\//\\/g;
-
-    if(-e "$directory")
-    {
-        chdir($directory);
-        unlink <*>; # remove files
-        chdir($save_cwd);
-        rmdir $directory;         # remove directory
-    }
-}
-
-sub print_usage
-{
-    print "usage: $0 <dir1> [dir2 dir3...]\n";
-}

mozilla/xpinstall/wizard/windows/builder/build.pl

@@ -1,233 +0,0 @@
-#!c:\perl\bin\perl
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, 
-# released March 31, 1998. 
-#
-# The Initial Developer of the Original Code is Netscape Communications 
-# Corporation.  Portions created by Netscape are
-# Copyright (C) 1999 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#   Sean Su <ssu@netscape.com>
-
-#
-# Purpose:
-#    To build the mozilla self-extracting installer and its corresponding .xpi files
-#    given a mozilla build on a local system.
-#
-# Requirements:
-# 1. perl needs to be installed correctly on the build system because cwd.pm is used.
-# 2. mozilla\xpinstall\wizard\windows needs to be built.
-#    a. to build it, MFC must be installed with VC
-#    b. set MOZ_MFC=1 in the build environment
-#    c. run nmake -f makefile.win from the above directory
-#
-
-if($ENV{MOZ_SRC} eq "")
-{
-  print "Error: MOZ_SRC not set!";
-  exit(1);
-}
-
-$DEPTH        = "$ENV{MOZ_SRC}\\mozilla";
-$cwdBuilder   = "$DEPTH\\xpinstall\\wizard\\windows\\builder";
-$cwdBuilder   =~ s/\//\\/g; # convert slashes to backslashes for Dos commands to work
-$cwdDist      = GetCwd("dist",     $DEPTH, $cwdBuilder);
-$cwdDistWin   = GetCwd("distwin",  $DEPTH, $cwdBuilder);
-$cwdInstall   = GetCwd("install",  $DEPTH, $cwdBuilder);
-$cwdPackager  = GetCwd("packager", $DEPTH, $cwdBuilder);
-$verPartial   = "5.0.0.";
-$ver          = $verPartial . GetVersion($DEPTH);
-$ftpStr       = "ftp://not.needed.com/because/the/xpi/files/will/be/located/in/the/same/dir/as/the/installer";
-
-if(-e "$cwdDist\\stage")
-{
-  system("perl $cwdPackager\\windows\\rdir.pl $cwdDist\\stage");
-}
-
-mkdir("$cwdDist\\stage", 775);
-system("perl $cwdPackager\\pkgcp.pl -s $cwdDistWin -d $cwdDist\\stage -f $cwdPackager\\packages-win -o dos -v");
-
-chdir("$cwdPackager\\windows");
-system("perl makeall.pl $ver $ftpStr $cwdDist\\stage $cwdDistWin\\install");
-chdir($cwdBuilder);
-
-# Copy the .xpi files to the same directory as setup.exe.
-# This is so that setup.exe can find the .xpi files
-# in the same directory and use them.
-#
-# Mozilla-win32-install.exe (a self extracting file) will use the .xpi
-# files from its current directory as well, but it is not a requirement
-# that they exist because it already contains the .xpi files within itself.
-system("xcopy /f $cwdDistWin\\install\\xpi\\*.* $cwdDistWin\\install");
-
-print "\n";
-print "**\n";
-print "*\n";
-print "*  A self-extracting installer has been built and delivered:\n";
-print "*\n";
-print "*      $cwdDistWin\\install\\mozilla-win32-install.exe\n";
-print "*\n";
-print "**\n";
-print "\n";
-
-exit(0);
-
-sub GetCwd
-{
-  my($whichPath, $depthPath, $returnCwd) = @_;
-  my($distCwd);
-  my($distWinPathName);
-  my($distPath);
-
-  # determine if build is debug or optimized
-  if($ENV{MOZ_DEBUG} eq "")
-  {
-    $distWinPathName = "Win32_o.obj";
-  }
-  else
-  {
-    $distWinPathName = "Win32_d.obj";
-  }
-
-  if($whichPath eq "dist")
-  {
-    # verify the existance of path
-    if(!(-e "$depthPath\\dist"))
-    {
-      print "path not found: $depthPath\\dist\n";
-      exit(1);
-    }
-
-    $distPath = "$depthPath\\dist";
-  }
-  elsif($whichPath eq "distwin")
-  {
-    # verify the existance of path
-    if(!(-e "$depthPath\\dist\\$distWinPathName"))
-    {
-      print "path not found: $depthPath\\dist\\$distWinPathName\n";
-      exit(1);
-    }
-
-    $distPath = "$depthPath\\dist\\$distWinPathName";
-  }
-  elsif($whichPath eq "install")
-  {
-    # verify the existance of path
-    if(!(-e "$depthPath\\dist\\$distWinPathName\\install"))
-    {
-      print "path not found: $depthPath\\dist\\$distWinPathName\\install\n";
-      exit(1);
-    }
-
-    $distPath = "$depthPath\\dist\\$distWinPathName\\install";
-  }
-  elsif($whichPath eq "packager")
-  {
-    # verify the existance of path
-    if(!(-e "$depthPath\\xpinstall\\packager"))
-    {
-      print "path not found: $depthPath\\xpinstall\\packager\n";
-      exit(1);
-    }
-
-    $distPath = "$depthPath\\xpinstall\\packager";
-  }
-
-  $distPath =~ s/\//\\/g; # convert slashes to backslashes for Dos commands to work
-  return($distPath);
-}
-
-sub GetVersion
-{
-  my($depthPath) = @_;
-  my($fileMozilla);
-  my($fileMozillaVer);
-  my($distWinPathName);
-  my($monAdjusted);
-  my($yy);
-  my($mm);
-  my($dd);
-  my($hh);
-
-  # determine if build is debug or optimized
-  if($ENV{MOZ_DEBUG} eq "")
-  {
-    $distWinPathName = "Win32_o.obj";
-  }
-  else
-  {
-    $distWinPathName = "Win32_d.obj";
-  }
-
-  $fileMozilla = "$depthPath\\dist\\$distWinPathName\\bin\\mozilla.exe";
-  # verify the existance of file
-  if(!(-e "$fileMozilla"))
-  {
-    print "file not found: $fileMozilla\n";
-    exit(1);
-  }
-
-  ($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks) = stat $fileMozilla;
-  ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime($mtime);
-
-  # calculate year
-  # localtime() returns year 2000 as 100, we mod 100 to get at the last 2 digits
-  $yy = $year % 100;
-  if($yy < 10)
-  {
-    $yy = "200$yy";
-  }
-  else
-  {
-    $yy = "20$yy";
-  }
-
-  # calculate month
-  $monAdjusted = $mon + 1;
-  if(($monAdjusted) < 10)
-  {
-    $mm = "0$monAdjusted";
-  }
-  else
-  {
-    $mm = "$mon";
-  }
-
-  # calculate month day
-  if(($mday) < 10)
-  {
-    $dd = "0$mday";
-  }
-  else
-  {
-    $dd = "$mday";
-  }
-
-  # calculate day hour
-  if(($hour) < 10)
-  {
-    $hh = "0$hour";
-  }
-  else
-  {
-    $hh = "$hour";
-  }
-
-  $fileMozillaVer = "$yy$mm$dd$hh";
-  print "y2k compliant version string for $fileMozilla: $fileMozillaVer\n";
-  return($fileMozillaVer);
-}
-

mozilla/xpinstall/wizard/windows/builder/readme.txt

@@ -1,54 +0,0 @@
-
-The contents of this file are subject to the Netscape Public
-License Version 1.1 (the "License"); you may not use this file
-except in compliance with the License. You may obtain a copy of
-the License at http://www.mozilla.org/NPL/
-
-Software distributed under the License is distributed on an "AS
-IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-implied. See the License for the specific language governing
-rights and limitations under the License.
-
-The Original Code is Mozilla Communicator client code, 
-released March 31, 1998. 
-
-The Initial Developer of the Original Code is Netscape Communications 
-Corporation.  Portions created by Netscape are
-Copyright (C) 1999 Netscape Communications Corporation. All
-Rights Reserved.
-
-Contributor(s): 
- Sean Su <ssu@netscape.com>
-
-
-Purpose:
-  To build the mozilla self-extracting installer and its corresponding .xpi files
-  given a mozilla build on a local system.
-
-Requirements:
-1. Perl needs to be installed correctly on the build system because cwd.pm is used.
-   Preferably, perl version 5.004 or newer should be used.
-   
-2. Mozilla\xpinstall\wizard\windows needs to be built.
-  a. to build it, MFC must be installed with VC6
-  b. set MOZ_MFC=1 in the build environment
-  c. run nmake -f makefile.win from the above directory
-
-
-Build.pl requires no parameters.  When it finishes, it will have created a
-temporary staging area in mozilla\dist\stage to build the .xpi archives from.
-The self-extracting installer (mozilla-win32-installer.exe) will be delivered to:
-  mozilla\dist\win32_o.obj\install
-
-The .xpi archives will be delivered to:
-  mozilla\dist\win32_o.obj\install\xpi
-
-Mozilla-win32-installer.exe does not require the .xpi archives once its been created
-because they have been packaged up in the .exe file.
-
-The .xpi archives will also be copied to:
-  mozilla\dist\win32_o.obj\install
-
-This is so setup.exe can install them.  Setup.exe is usually run when debugging the
-installer code.  This makes it easier to debug.
-

mozilla/xpinstall/wizard/windows/makefile.win

@@ -1,33 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, 
-# released March 31, 1998. 
-#
-# The Initial Developer of the Original Code is Netscape Communications 
-# Corporation.  Portions created by Netscape are
-# Copyright (C) 1999 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#   Sean Su <ssu@netscape.com>
-
-DEPTH=..\..\..
-
-DIRS=$(DIRS) nsinstall \
-!if "$(WINOS)"=="WINNT"
-             nsztool   \
-!endif
-             setup     \
-             setuprsc  \
-             ren8dot3
-
-include <$(DEPTH)\config\rules.mak>

mozilla/xpinstall/wizard/windows/nsinstall/makefile.win

@@ -1,61 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, 
-# released March 31, 1998. 
-#
-# The Initial Developer of the Original Code is Netscape Communications 
-# Corporation.  Portions created by Netscape are
-# Copyright (C) 1999 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#   Sean Su <ssu@netscape.com>
-
-DEPTH=..\..\..\..
-
-MAKE_OBJ_TYPE   = EXE
-USE_NON_MT_LIBS = 1
-
-MODULE          = nsinstall
-PROGRAM         = .\$(OBJDIR)\$(MODULE).exe
-RESFILE         = $(MODULE).res
-
-OBJS =  \
-    .\$(OBJDIR)\nsinstall.obj   \
-    .\$(OBJDIR)\adler32.obj     \
-    .\$(OBJDIR)\infblock.obj    \
-    .\$(OBJDIR)\infcodes.obj    \
-    .\$(OBJDIR)\inffast.obj     \
-    .\$(OBJDIR)\inflate.obj     \
-    .\$(OBJDIR)\inftrees.obj    \
-    .\$(OBJDIR)\infutil.obj     \
-    .\$(OBJDIR)\uncompr.obj     \
-    .\$(OBJDIR)\zutil.obj       \
-    $(NULL)
-
-LCFLAGS= -UMOZILLA_CLIENT
-
-include <$(DEPTH)\config\rules.mak>
-
-docopy:
-    $(MAKE_INSTALL) $(DEPTH)\modules\zlib\src\*.h .
-    $(MAKE_INSTALL) $(DEPTH)\modules\zlib\src\*.c .
-
-export:: docopy
-
-install:: $(PROGRAM)
-    $(MAKE_INSTALL) $(PROGRAM) $(DIST)\install
-
-clobber_all::
-    $(RM) inf*.* adler32.c uncompr.c z*.* trees.c deflate.* compr* gzio* example.c crc* mini*
-    $(RM) $(DIST)\install\$(MODULE).exe
-

mozilla/xpinstall/wizard/windows/nsinstall/nsinstall.cpp

@@ -1,564 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-#include <windows.h>
-#include "resource.h"
-#include "zlib.h"
-
-#define BAR_MARGIN    1
-#define BAR_SPACING   2
-#define BAR_WIDTH     6
-#define MAX_BUF       4096
-
-char szTitle[4096];
-HINSTANCE hInst;
-
-/////////////////////////////////////////////////////////////////////////////
-// Global Declarations
-
-static DWORD	nTotalBytes = 0;  // sum of all the FILE resources
-
-struct ExtractFilesDlgInfo {
-	HWND	hWndDlg;
-	int		nMaxBars;	// maximum number of bars that can be displayed
-	int		nBars;		// current number of bars to display
-} dlgInfo;
-
-/////////////////////////////////////////////////////////////////////////////
-// Utility Functions
-
-// This function is similar to GetFullPathName except instead of
-// using the current drive and directory it uses the path of the
-// directory designated for temporary files
-static BOOL
-GetFullTempPathName(LPCTSTR lpszFileName, DWORD dwBufferLength, LPTSTR lpszBuffer)
-{
-	DWORD	dwLen;
-
-	dwLen = GetTempPath(dwBufferLength, lpszBuffer);
-	if (lpszBuffer[dwLen - 1] != '\\')
-		strcat(lpszBuffer, "\\");
-	strcat(lpszBuffer, lpszFileName);
-	return TRUE;
-}
-
-// this function appends a backslash at the end of a string,
-// if one does not already exists.
-void AppendBackSlash(LPSTR szInput, DWORD dwInputSize)
-{
-  if(szInput != NULL)
-  {
-    if(szInput[strlen(szInput) - 1] != '\\')
-    {
-      if(((DWORD)lstrlen(szInput) + 1) < dwInputSize)
-      {
-        lstrcat(szInput, "\\");
-      }
-    }
-  }
-}
-
-// This function removes a directory and its subdirectories
-HRESULT DirectoryRemove(LPSTR szDestination, BOOL bRemoveSubdirs)
-{
-  HANDLE          hFile;
-  WIN32_FIND_DATA fdFile;
-  char            szDestTemp[MAX_BUF];
-  BOOL            bFound;
-
-  if(GetFileAttributes(szDestination) == -1)
-    return(0);
-
-  if(bRemoveSubdirs == TRUE)
-  {
-    lstrcpy(szDestTemp, szDestination);
-    AppendBackSlash(szDestTemp, sizeof(szDestTemp));
-    lstrcat(szDestTemp, "*");
-
-    bFound = TRUE;
-    hFile = FindFirstFile(szDestTemp, &fdFile);
-    while((hFile != INVALID_HANDLE_VALUE) && (bFound == TRUE))
-    {
-      if((lstrcmpi(fdFile.cFileName, ".") != 0) && (lstrcmpi(fdFile.cFileName, "..") != 0))
-      {
-        /* create full path */
-        lstrcpy(szDestTemp, szDestination);
-        AppendBackSlash(szDestTemp, sizeof(szDestTemp));
-        lstrcat(szDestTemp, fdFile.cFileName);
-
-        if(fdFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-        {
-          DirectoryRemove(szDestTemp, bRemoveSubdirs);
-        }
-        else
-        {
-          DeleteFile(szDestTemp);
-        }
-      }
-
-      bFound = FindNextFile(hFile, &fdFile);
-    }
-
-    FindClose(hFile);
-  }
-  
-  RemoveDirectory(szDestination);
-  return(0);
-}
-
-// Centers the specified window over the desktop. Assumes the window is
-// smaller both horizontally and vertically than the desktop
-static void
-CenterWindow(HWND hWndDlg)
-{
-	RECT	rect;
-	int		iLeft, iTop;
-
-	GetWindowRect(hWndDlg, &rect);
-	iLeft = (GetSystemMetrics(SM_CXSCREEN) - (rect.right - rect.left)) / 2;
-	iTop = (GetSystemMetrics(SM_CYSCREEN) - (rect.bottom - rect.top)) / 2;
-
-	SetWindowPos(hWndDlg, NULL, iLeft, iTop, -1, -1,
-		SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Extract Files Dialog
-
-// This routine updates the status string in the extracting dialog
-static void
-SetStatusLine(LPCTSTR lpszStatus)
-{
-	HWND	hWndLabel = GetDlgItem(dlgInfo.hWndDlg, IDC_STATUS);
-
-	SetWindowText(hWndLabel, lpszStatus);
-	UpdateWindow(hWndLabel);
-}
-
-// This routine will update the progress bar to the specified percentage
-// (value between 0 and 100)
-static void
-UpdateProgressBar(unsigned value)
-{
-	int	nBars;
-
-	// Figure out how many bars should be displayed
-	nBars = dlgInfo.nMaxBars * value / 100;
-
-	// Only paint if we need to display more bars
-	if (nBars > dlgInfo.nBars) {
-		HWND	hWndGauge = GetDlgItem(dlgInfo.hWndDlg, IDC_GAUGE);
-		RECT	rect;
-
-		// Update the gauge state before painting
-		dlgInfo.nBars = nBars;
-
-		// Only invalidate the part that needs updating
-		GetClientRect(hWndGauge, &rect);
-		rect.left = BAR_MARGIN + (nBars - 1) * (BAR_WIDTH + BAR_SPACING);
-		InvalidateRect(hWndGauge, &rect, FALSE);
-	
-		// Update the whole extracting dialog. We do this because we don't
-		// have a message loop to process WM_PAINT messages in case the
-		// extracting dialog was exposed
-		UpdateWindow(dlgInfo.hWndDlg);
-	}
-}
-
-// Window proc for dialog
-BOOL APIENTRY
-DialogProc(HWND hWndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
-{
-	switch (msg) {
-		case WM_INITDIALOG:
-			// Center the dialog over the desktop
-			CenterWindow(hWndDlg);
-			return FALSE;
-
-		case WM_COMMAND:
-			DestroyWindow(hWndDlg);
-			return TRUE;
-	}
-
-	return FALSE;  // didn't handle the message
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Resource Callback Functions
-
-BOOL APIENTRY
-DeleteTempFilesProc(HANDLE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG lParam)
-{
-	char	szTmpFile[MAX_PATH];
-
-	// Get the path to the file in the temp directory
-	GetFullTempPathName(lpszName, sizeof(szTmpFile), szTmpFile);
-
-	// Delete the file
-	DeleteFile(szTmpFile);
-	return TRUE;
-}
-
-BOOL APIENTRY
-SizeOfResourcesProc(HANDLE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG lParam)
-{
-	HRSRC	hResInfo;
-
-	// Find the resource
-	hResInfo = FindResource((HINSTANCE)hModule, lpszName, lpszType);
-
-#ifdef _DEBUG
-	if (!hResInfo) {
-		char	buf[512];
-
-		wsprintf(buf, "Error '%d' when loading FILE resource: %s", GetLastError(), lpszName);
-		MessageBox(NULL, buf, szTitle, MB_OK | MB_ICONEXCLAMATION);
-		return FALSE;
-	}
-#endif
-
-	// Add its size to the total size. Note that the return value is subject
-	// to alignment rounding, but it's close enough for our purposes
-	nTotalBytes += SizeofResource(NULL, hResInfo);
-
-	// Release the resource
-	FreeResource(hResInfo);
-	return TRUE;  // keep enumerating
-}
-
-BOOL APIENTRY
-ExtractFilesProc(HANDLE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG lParam)
-{
-	char	szTmpFile[MAX_PATH];
-	char	szArcLstFile[MAX_PATH];
-	HRSRC	hResInfo;
-	HGLOBAL	hGlobal;
-	LPBYTE	lpBytes;
-	LPBYTE	lpBytesUnCmp;
-	HANDLE	hFile;
-	char	szStatus[128];
-	char	szText[4096];
-	
-	// Update the UI
-	LoadString(hInst, IDS_STATUS_EXTRACTING, szText, sizeof(szText));
-	wsprintf(szStatus, szText, lpszName);
-	SetStatusLine(szStatus);
-
-	// Create a file in the temp directory
-	GetFullTempPathName(lpszName, sizeof(szTmpFile), szTmpFile);
-
-	// Extract the file
-	hResInfo = FindResource((HINSTANCE)hModule, lpszName, lpszType);
-	hGlobal = LoadResource((HINSTANCE)hModule, hResInfo);
-	lpBytes = (LPBYTE)LockResource(hGlobal);
-
-	// Create the file
-	hFile = CreateFile(szTmpFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
-		FILE_ATTRIBUTE_TEMPORARY, NULL);
-
-	if (hFile != INVALID_HANDLE_VALUE) {
-		DWORD	dwSize;
-		DWORD	dwSizeUnCmp;
-    DWORD dwTemp;
-
-	  GetFullTempPathName("Archive.lst", sizeof(szArcLstFile), szArcLstFile);
-    WritePrivateProfileString("Archives", lpszName, "TRUE", szArcLstFile);
-
-    lpBytesUnCmp = (LPBYTE)malloc((*(LPDWORD)(lpBytes + sizeof(DWORD))) + 1);
-    dwSizeUnCmp  = *(LPDWORD)(lpBytes + sizeof(DWORD));
-
-		// Copy the file. The first DWORD specifies the size of the file
-		dwSize = *(LPDWORD)lpBytes;
-		lpBytes += (sizeof(DWORD) * 2);
-
-    dwTemp = uncompress(lpBytesUnCmp, &dwSizeUnCmp, lpBytes, dwSize);
-
-    while (dwSizeUnCmp > 0)
-    {
-			DWORD	dwBytesToWrite, dwBytesWritten;
-
-			dwBytesToWrite = dwSizeUnCmp > 4096 ? 4096 : dwSizeUnCmp;
-			if (!WriteFile(hFile, lpBytesUnCmp, dwBytesToWrite, &dwBytesWritten, NULL))
-      {
-				char szBuf[512];
-
-      	LoadString(hInst, IDS_STATUS_EXTRACTING, szText, sizeof(szText));
-				wsprintf(szBuf, szText, szTmpFile);
-				MessageBox(NULL, szBuf, szTitle, MB_OK | MB_ICONEXCLAMATION);
-				FreeResource(hResInfo);
-				return FALSE;
-			}
-
-			dwSizeUnCmp -= dwBytesWritten;
-			lpBytesUnCmp += dwBytesWritten;
-
-			// Update the UI to reflect the total number of bytes written
-			static DWORD	nBytesWritten = 0;
-
-			nBytesWritten += dwBytesWritten;
-			UpdateProgressBar(nBytesWritten * 100 / nTotalBytes);
-		}
-
-		CloseHandle(hFile);
-	}
-
-	// Release the resource
-	FreeResource(hResInfo);
-
-	return TRUE;  // keep enumerating
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Progress bar
-
-// Draws a recessed border around the gauge
-static void
-DrawGaugeBorder(HWND hWnd)
-{
-	HDC		hDC = GetWindowDC(hWnd);
-	RECT	rect;
-	int		cx, cy;
-	HPEN	hShadowPen = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNSHADOW));
-	HGDIOBJ	hOldPen;
-
-	GetWindowRect(hWnd, &rect);
-	cx = rect.right - rect.left;
-	cy = rect.bottom - rect.top;
-
-	// Draw a dark gray line segment
-	hOldPen = SelectObject(hDC, (HGDIOBJ)hShadowPen);
-	MoveToEx(hDC, 0, cy - 1, NULL);
-	LineTo(hDC, 0, 0);
-	LineTo(hDC, cx - 1, 0);
-
-	// Draw a white line segment
-	SelectObject(hDC, GetStockObject(WHITE_PEN));
-	MoveToEx(hDC, 0, cy - 1, NULL);
-	LineTo(hDC, cx - 1, cy - 1);
-	LineTo(hDC, cx - 1, 0);
-
-	SelectObject(hDC, hOldPen);
-	DeleteObject(hShadowPen);
-	ReleaseDC(hWnd, hDC);
-}
-
-// Draws the blue progress bar
-static void
-DrawProgressBar(HWND hWnd)
-{
-	PAINTSTRUCT	ps;
-	HDC			hDC = BeginPaint(hWnd, &ps);
-	RECT		rect;
-	HBRUSH		hBlueBrush = CreateSolidBrush(RGB(0, 0, 128));
-
-	// Draw the bars
-	GetClientRect(hWnd, &rect);
-	rect.left = rect.top = BAR_MARGIN;
-	rect.bottom -= BAR_MARGIN;
-	rect.right = rect.left + BAR_WIDTH;
-
-	for (int i = 0; i < dlgInfo.nBars; i++) {
-		RECT	dest;
-
-		if (IntersectRect(&dest, &ps.rcPaint, &rect))
-			FillRect(hDC, &rect, hBlueBrush);
-		OffsetRect(&rect, BAR_WIDTH + BAR_SPACING, 0);
-	}
-
-	DeleteObject(hBlueBrush);
-	EndPaint(hWnd, &ps);
-}
-
-// Adjusts the width of the gauge based on the maximum number of bars
-static void
-SizeToFitGauge(HWND hWnd)
-{
-	RECT	rect;
-	int		cx;
-
-	// Get the window size in pixels
-	GetWindowRect(hWnd, &rect);
-
-	// Size the width to fit
-	cx = 2 * GetSystemMetrics(SM_CXBORDER) + 2 * BAR_MARGIN +
-		dlgInfo.nMaxBars * BAR_WIDTH + (dlgInfo.nMaxBars - 1) * BAR_SPACING;
-
-	SetWindowPos(hWnd, NULL, -1, -1, cx, rect.bottom - rect.top,
-		SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
-}
-
-// Window proc for gauge
-LRESULT APIENTRY
-GaugeWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
-{
-	DWORD	dwStyle;
-	RECT	rect;
-
-	switch (msg) {
-		case WM_NCCREATE:
-			dwStyle = GetWindowLong(hWnd, GWL_STYLE);
-			SetWindowLong(hWnd, GWL_STYLE, dwStyle | WS_BORDER);
-			return TRUE;
-
-		case WM_CREATE:
-			// Figure out the maximum number of bars that can be displayed
-			GetClientRect(hWnd, &rect);
-			dlgInfo.nBars = 0;
-			dlgInfo.nMaxBars = (rect.right - rect.left - 2 * BAR_MARGIN + BAR_SPACING) /
-				(BAR_WIDTH + BAR_SPACING);
-
-			// Size the gauge to exactly fit the maximum number of bars
-			SizeToFitGauge(hWnd);
-			return TRUE;
-
-		case WM_NCPAINT:
-			DrawGaugeBorder(hWnd);
-			return TRUE;
-
-		case WM_PAINT:
-			DrawProgressBar(hWnd);
-			return TRUE;
-	}
-
-	return DefWindowProc(hWnd, msg, wParam, lParam);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// WinMain
-
-static BOOL
-RunInstaller(LPSTR lpCmdLine)
-{
-    PROCESS_INFORMATION pi;
-    STARTUPINFO         sti;
-    char                szCmdLine[MAX_PATH];
-    BOOL                bRet;
-	  char                szText[256];
-    char                szTempPath[4096];
-    char                szTmp[MAX_PATH];
-    char                szCurrentDirectory[MAX_PATH];
-    char                szBuf[MAX_PATH];
-
-	// Update UI
-	UpdateProgressBar(100);
-	LoadString(hInst, IDS_STATUS_LAUNCHING_SETUP, szText, sizeof(szText));
-	SetStatusLine(szText);
-
-    memset(&sti,0,sizeof(sti));
-    sti.cb = sizeof(STARTUPINFO);
-
-    // Setup program is in the directory specified for temporary files
-	  GetFullTempPathName("SETUP.EXE", sizeof(szCmdLine), szCmdLine);
-	  GetTempPath(4096, szTempPath);
-    GetCurrentDirectory(MAX_PATH, szCurrentDirectory);
-    GetShortPathName(szCurrentDirectory, szBuf, MAX_PATH);
-
-    lstrcat(szCmdLine, " -a");
-    lstrcat(szCmdLine, szBuf);
-
-    if((lpCmdLine != NULL) && (*lpCmdLine != '\0'))
-    {
-      lstrcat(szCmdLine, " ");
-      lstrcat(szCmdLine, lpCmdLine);
-    }
-
-	  // Launch the installer
-    bRet = CreateProcess(NULL, szCmdLine, NULL, NULL, FALSE, 0, NULL, szTempPath, &sti, &pi);
-
-    if (!bRet)
-        return FALSE;
-
-   	CloseHandle(pi.hThread);
-
-	// Wait for the InstallShield UI to appear before taking down the dialog box
-	WaitForInputIdle(pi.hProcess, 3000);  // wait up to 3 seconds
-	DestroyWindow(dlgInfo.hWndDlg);
-
-	// Wait for the installer to complete
-    WaitForSingleObject(pi.hProcess, INFINITE);
-    CloseHandle(pi.hProcess);
-
-	// That was just the installer bootstrapper. Now we need to wait for the
-	// installer itself. We can find the process ID by looking for a window of
-	// class ISINSTALLSCLASS
-	HWND	hWnd = FindWindow("ISINSTALLSCLASS", NULL);
-
-	if (hWnd) {
-		DWORD	dwProcessId;
-		HANDLE	hProcess;
-
-		// Get the associated process handle and wait for it to terminate
-		GetWindowThreadProcessId(hWnd, &dwProcessId);
-
-		// We need the process handle to use WaitForSingleObject
-		hProcess = OpenProcess(STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE, FALSE, dwProcessId);
-
-		if (hProcess) {
-			WaitForSingleObject(hProcess, INFINITE);
-			CloseHandle(hProcess);
-		}
-	}
-	// Delete the files from the temp directory
-  EnumResourceNames(NULL, "FILE", (ENUMRESNAMEPROC)DeleteTempFilesProc, 0);
-
-  // delete archive.lst file in the temp directory
-	GetFullTempPathName("Archive.lst", sizeof(szTmp), szTmp);
-	DeleteFile(szTmp);
-	GetFullTempPathName("core.ns", sizeof(szTmp), szTmp);
-  DirectoryRemove(szTmp, TRUE);
-	return TRUE;
-}
-
-int APIENTRY
-WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
-{
-	WNDCLASS	wc;
-
-	hInst = hInstance;
-	LoadString(hInst, IDS_TITLE, szTitle, sizeof(szTitle));
-
-	// Figure out the total size of the resources
-	EnumResourceNames(NULL, "FILE", (ENUMRESNAMEPROC)SizeOfResourcesProc, 0);
-
-	// Register a class for the gauge
-	memset(&wc, 0, sizeof(wc));
-	wc.lpfnWndProc = (WNDPROC)GaugeWndProc;
-	wc.hInstance = hInstance;
-	wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
-	wc.lpszClassName = "NSGauge";
-	RegisterClass(&wc);
-
-	// Display the dialog box
-	dlgInfo.hWndDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_EXTRACTING),
-		NULL, (DLGPROC)DialogProc);
-	UpdateWindow(dlgInfo.hWndDlg);
-
-	// Extract the files
-	EnumResourceNames(NULL, "FILE", (ENUMRESNAMEPROC)ExtractFilesProc, 0);
-	
-	// Launch the install program and wait for it to finish
-	RunInstaller(lpCmdLine);
-	return 0;  
-}

mozilla/xpinstall/wizard/windows/nsinstall/nsinstall.rc

@@ -1,125 +0,0 @@
-//Microsoft Developer Studio generated resource script.
-//
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-#include "resource.h"
-
-#define APSTUDIO_READONLY_SYMBOLS
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 2 resource.
-//
-
-/////////////////////////////////////////////////////////////////////////////
-#undef APSTUDIO_READONLY_SYMBOLS
-
-/////////////////////////////////////////////////////////////////////////////
-// English (U.S.) resources
-
-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
-#ifdef _WIN32
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-#pragma code_page(1252)
-#endif //_WIN32
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Dialog
-//
-
-IDD_EXTRACTING DIALOG DISCARDABLE  0, 0, 193, 61
-STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
-CAPTION "Extracting..."
-FONT 8, "MS Sans Serif"
-BEGIN
-    LTEXT           "",IDC_STATUS,9,13,159,8
-    CONTROL         "",IDC_GAUGE,"NSGauge",0x0,9,31,175,11
-END
-
-
-#ifdef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// TEXTINCLUDE
-//
-
-1 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "resource.h\0"
-END
-
-2 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "\r\n"
-    "\0"
-END
-
-3 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "\r\n"
-    "\0"
-END
-
-#endif    // APSTUDIO_INVOKED
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Icon
-//
-
-// Icon with lowest ID value placed first to ensure application icon
-// remains consistent on all systems.
-1                       ICON    DISCARDABLE     "nsinstall.ico"
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// String Table
-//
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    IDS_STATUS_EXTRACTING   "Extracting %s"
-    IDS_STATUS_LAUNCHING_SETUP "Launching Setup..."
-    IDS_ERROR_FILE_WRITE    "Unable to write file %s"
-    IDS_TITLE               "Netscape Communicator Installation"
-END
-
-#endif    // English (U.S.) resources
-/////////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 3 resource.
-//
-
-
-/////////////////////////////////////////////////////////////////////////////
-#endif    // not APSTUDIO_INVOKED
-

mozilla/xpinstall/wizard/windows/nsinstall/resource.h

@@ -1,52 +0,0 @@
-//{{NO_DEPENDENCIES}}
-// Microsoft Developer Studio generated include file.
-// Used by nsinstall.rc
-//
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-#include "winuser.h"
-#include "winresrc.h"
-
-#define IDS_PROMPT                      1
-#define IDS_STATUS_EXTRACTING           2
-#define IDS_STATUS_LAUNCHING_SETUP      3
-#define IDS_ERROR_FILE_WRITE            4
-#define IDS_TITLE                       5
-#define IDD_EXTRACTING                  101
-#define IDC_STATUS                      1001
-#define IDC_GAUGE                       1002
-
-// Next default values for new objects
-// 
-#ifdef APSTUDIO_INVOKED
-#ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        103
-#define _APS_NEXT_COMMAND_VALUE         40001
-#define _APS_NEXT_CONTROL_VALUE         1003
-#define _APS_NEXT_SYMED_VALUE           101
-#define _APS_NO_MFC                     1
-#endif
-#endif

mozilla/xpinstall/wizard/windows/nszip/mainfrm.cpp

@@ -1,109 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// mainfrm.cpp : implementation of the CMainFrame class
-//
-
-#include "stdafx.h"
-#include "nszip.h"
-
-#include "mainfrm.h"
-
-#ifdef _DEBUG
-#undef THIS_FILE
-static char BASED_CODE THIS_FILE[] = __FILE__;
-#endif
-
-/////////////////////////////////////////////////////////////////////////////
-// CMainFrame
-
-IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)
-
-BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
-	//{{AFX_MSG_MAP(CMainFrame)
-		// NOTE - the ClassWizard will add and remove mapping macros here.
-		//    DO NOT EDIT what you see in these blocks of generated code !
-	ON_WM_CREATE()
-	//}}AFX_MSG_MAP
-END_MESSAGE_MAP()
-
-/////////////////////////////////////////////////////////////////////////////
-// arrays of IDs used to initialize control bars
-
-static UINT BASED_CODE indicators[] =
-{
-	ID_SEPARATOR,           // status line indicator
-	ID_INDICATOR_CAPS,
-	ID_INDICATOR_NUM,
-	ID_INDICATOR_SCRL,
-};
-
-/////////////////////////////////////////////////////////////////////////////
-// CMainFrame construction/destruction
-
-CMainFrame::CMainFrame()
-{
-	// TODO: add member initialization code here
-	
-}
-
-CMainFrame::~CMainFrame()
-{
-}
-
-int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
-{
-	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
-		return -1;
-
-	if (!m_wndStatusBar.Create(this) ||
-		!m_wndStatusBar.SetIndicators(indicators,
-		  sizeof(indicators)/sizeof(UINT)))
-	{
-		TRACE0("Failed to create status bar\n");
-		return -1;      // fail to create
-	}
-
-	return 0;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// CMainFrame diagnostics
-
-#ifdef _DEBUG
-void CMainFrame::AssertValid() const
-{
-	CFrameWnd::AssertValid();
-}
-
-void CMainFrame::Dump(CDumpContext& dc) const
-{
-	CFrameWnd::Dump(dc);
-}
-
-#endif //_DEBUG
-
-/////////////////////////////////////////////////////////////////////////////
-// CMainFrame message handlers

mozilla/xpinstall/wizard/windows/nszip/mainfrm.h

@@ -1,68 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// mainfrm.h : interface of the CMainFrame class
-//
-/////////////////////////////////////////////////////////////////////////////
-
-class CMainFrame : public CFrameWnd
-{
-protected: // create from serialization only
-	CMainFrame();
-	DECLARE_DYNCREATE(CMainFrame)
-
-// Attributes
-public:
-
-// Operations
-public:
-
-// Overrides
-	// ClassWizard generated virtual function overrides
-	//{{AFX_VIRTUAL(CMainFrame)
-	//}}AFX_VIRTUAL
-
-// Implementation
-public:
-	virtual ~CMainFrame();
-#ifdef _DEBUG
-	virtual void AssertValid() const;
-	virtual void Dump(CDumpContext& dc) const;
-#endif
-
-protected:  // control bar embedded members
-	CStatusBar  m_wndStatusBar;
-
-// Generated message map functions
-protected:
-	//{{AFX_MSG(CMainFrame)
-	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
-		// NOTE - the ClassWizard will add and remove member functions here.
-		//    DO NOT EDIT what you see in these blocks of generated code!
-	//}}AFX_MSG
-	DECLARE_MESSAGE_MAP()
-};
-
-/////////////////////////////////////////////////////////////////////////////

mozilla/xpinstall/wizard/windows/nszip/makefile.win

@@ -1,55 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, 
-# released March 31, 1998. 
-#
-# The Initial Developer of the Original Code is Netscape Communications 
-# Corporation.  Portions created by Netscape are
-# Copyright (C) 1999 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..\..
-
-MAKE_OBJ_TYPE   = EXE
-USE_STATIC_LIBS = 1
-
-MODULE          = nszip
-PROGRAM         = .\$(OBJDIR)\$(MODULE).exe
-RESFILE         = $(MODULE).res
-
-OBJS =                          \
-    .\$(OBJDIR)\nszip.obj       \
-    .\$(OBJDIR)\mainfrm.obj     \
-    .\$(OBJDIR)\nszipdoc.obj    \
-    .\$(OBJDIR)\nszipvw.obj     \
-    .\$(OBJDIR)\stdafx.obj      \
-    $(NULL)
-
-LLIBS=                          \
-    $(DIST)\lib\zlib_s.lib      \
-    $(NULL)
-
-LLFLAGS=                        \
-    /subsystem:windows          \
-    /machine:i386               \
-    $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-install:: $(PROGRAM)
-    $(MAKE_INSTALL) $(PROGRAM) $(DIST)\install
-
-clobber_all::
-    $(RM) $(DIST)\install\$(MODULE).exe
-

mozilla/xpinstall/wizard/windows/nszip/nszip.cpp

@@ -1,202 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// nszip.cpp : Defines the class behaviors for the application.
-//
-
-#include "stdafx.h"
-#include "nszip.h"
-
-#include "mainfrm.h"
-#include "nszipdoc.h"
-#include "nszipvw.h"
-
-#ifdef _DEBUG
-#undef THIS_FILE
-static char BASED_CODE THIS_FILE[] = __FILE__;
-#endif
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipApp
-
-BEGIN_MESSAGE_MAP(CNsZipApp, CWinApp)
-	//{{AFX_MSG_MAP(CNsZipApp)
-	ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
-		// NOTE - the ClassWizard will add and remove mapping macros here.
-		//    DO NOT EDIT what you see in these blocks of generated code!
-	//}}AFX_MSG_MAP
-	// Standard file based document commands
-	ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
-	ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
-END_MESSAGE_MAP()
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipApp construction
-
-CNsZipApp::CNsZipApp()
-{
-	// TODO: add construction code here,
-	// Place all significant initialization in InitInstance
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// The one and only CNsZipApp object
-
-CNsZipApp theApp;
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipApp initialization
-
-void CNsZipApp::ProcessCmdLine()
-{
-	// Make a copy of the command line since we will change it while parsing
-	CString		strCmdLine(m_lpCmdLine);
-
-	// Get the name of the archive
-	LPSTR	lpArchive = strtok((LPSTR)(LPCSTR)strCmdLine, " ");
-
-	if (lpArchive) {
-		char			szPath[MAX_PATH], szExtension[_MAX_EXT];
-		LPSTR			lpFiles;
-		CDocTemplate*	pTemplate;
-		CNsZipDoc*		pDoc;
-
-//		ASSERT(m_templateList.GetCount() == 1);
-//		pTemplate = (CDocTemplate*)m_templateList.GetHead();
-
-    POSITION pos = GetFirstDocTemplatePosition();
-
-    pTemplate = (CDocTemplate*)GetNextDocTemplate(pos);
-    ASSERT(pTemplate);
-		ASSERT(pTemplate->IsKindOf(RUNTIME_CLASS(CDocTemplate)));
-
-		// Create a new document
-		VERIFY(pDoc = (CNsZipDoc*)pTemplate->CreateNewDocument());
-
-		// We need a fully qualified pathname
-		::GetFullPathName(lpArchive, sizeof(szPath), szPath, NULL);
-
-		// Make sure it ends with .EXE
-		_splitpath(szPath, NULL, NULL, NULL, szExtension);
-		if (stricmp(szExtension, ".exe") != 0)
-			strcat(szPath, ".exe");
-
-		// Now go ahead and create the archive
-		pDoc->OnNewDocument(szPath);
-
-		// Process the files. These can be wildcards
-		while (lpFiles = strtok(NULL, " "))
-			pDoc->AddFiles(lpFiles);		
-//		while (lpFiles = strtok(lpArchive, " "))
-//			pDoc->AddFiles(lpFiles);		
-	
-		pDoc->OnSaveDocument(szPath);
-		delete pDoc;
-	}
-}
-
-BOOL CNsZipApp::InitInstance()
-{
-	// Standard initialization
-	// If you are not using these features and wish to reduce the size
-	//  of your final executable, you should remove from the following
-	//  the specific initialization routines you do not need.
-
-	Enable3dControls();
-
-	LoadStdProfileSettings();  // Load standard INI file options (including MRU)
-
-	// Register the application's document templates.  Document templates
-	//  serve as the connection between documents, frame windows and views.
-	CSingleDocTemplate* pDocTemplate;
-	pDocTemplate = new CSingleDocTemplate(
-		IDR_MAINFRAME,
-		RUNTIME_CLASS(CNsZipDoc),
-		RUNTIME_CLASS(CMainFrame),       // main SDI frame window
-		RUNTIME_CLASS(CNsZipView));
-	AddDocTemplate(pDocTemplate);
-
-	if (m_lpCmdLine[0] != '\0') {
-		ProcessCmdLine();
-		return FALSE;
-	}
-
-	// create a new (empty) document
-	OnFileNew();
-
-	return TRUE;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// CAboutDlg dialog used for App About
-
-class CAboutDlg : public CDialog
-{
-public:
-	CAboutDlg();
-
-// Dialog Data
-	//{{AFX_DATA(CAboutDlg)
-	enum { IDD = IDD_ABOUTBOX };
-	//}}AFX_DATA
-
-// Implementation
-protected:
-	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
-	//{{AFX_MSG(CAboutDlg)
-		// No message handlers
-	//}}AFX_MSG
-	DECLARE_MESSAGE_MAP()
-};
-
-CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
-{
-	//{{AFX_DATA_INIT(CAboutDlg)
-	//}}AFX_DATA_INIT
-}
-
-void CAboutDlg::DoDataExchange(CDataExchange* pDX)
-{
-	CDialog::DoDataExchange(pDX);
-	//{{AFX_DATA_MAP(CAboutDlg)
-	//}}AFX_DATA_MAP
-}
-
-BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
-	//{{AFX_MSG_MAP(CAboutDlg)
-		// No message handlers
-	//}}AFX_MSG_MAP
-END_MESSAGE_MAP()
-
-// App command to run the dialog
-void CNsZipApp::OnAppAbout()
-{
-	CAboutDlg aboutDlg;
-	aboutDlg.DoModal();
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipApp commands
-

mozilla/xpinstall/wizard/windows/nszip/nszip.h

@@ -1,66 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// nszip.h : main header file for the NSZIP application
-//
-
-#ifndef __AFXWIN_H__
-	#error include 'stdafx.h' before including this file for PCH
-#endif
-
-#include "resource.h"       // main symbols
-#include "zlib.h"
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipApp:
-// See nszip.cpp for the implementation of this class
-//
-
-class CNsZipApp : public CWinApp
-{
-public:
-	CNsZipApp();
-
-// Overrides
-	// ClassWizard generated virtual function overrides
-	//{{AFX_VIRTUAL(CNsZipApp)
-	public:
-	virtual BOOL InitInstance();
-	//}}AFX_VIRTUAL
-
-// Implementation
-protected:
-	void	ProcessCmdLine();
-
-	//{{AFX_MSG(CNsZipApp)
-	afx_msg void OnAppAbout();
-		// NOTE - the ClassWizard will add and remove member functions here.
-		//    DO NOT EDIT what you see in these blocks of generated code !
-	//}}AFX_MSG
-	DECLARE_MESSAGE_MAP()
-};
-
-
-/////////////////////////////////////////////////////////////////////////////

mozilla/xpinstall/wizard/windows/nszip/nszip.rc

@@ -1,305 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-//Microsoft Visual C++ generated resource script.
-//
-#include "resource.h"
-
-#define APSTUDIO_READONLY_SYMBOLS
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 2 resource.
-//
-#include "afxres.h"
-
-/////////////////////////////////////////////////////////////////////////////
-#undef APSTUDIO_READONLY_SYMBOLS
-
-
-#ifdef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// TEXTINCLUDE
-//
-
-1 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "resource.h\0"
-END
-
-2 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "#include ""afxres.h""\r\n"
-    "\0"
-END
-
-3 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "#include ""res\\nszip.rc2""  // non-Microsoft Visual C++ edited resources\r\n"
-    "\r\n"
-    "#define _AFX_NO_SPLITTER_RESOURCES\r\n"
-    "#define _AFX_NO_OLE_RESOURCES\r\n"
-    "#define _AFX_NO_TRACKER_RESOURCES\r\n"
-    "#define _AFX_NO_PROPERTY_RESOURCES\r\n"
-    "#include ""afxres.rc""  \011// Standard components\r\n"
-    "\0"
-END
-
-/////////////////////////////////////////////////////////////////////////////
-#endif    // APSTUDIO_INVOKED
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Icon
-//
-
-IDR_MAINFRAME           ICON    DISCARDABLE     "res\\nszip.ico"
-IDR_NSZIPTYPE           ICON    DISCARDABLE     "res\\nszipdoc.ico"
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Menu
-//
-
-IDR_MAINFRAME MENU PRELOAD DISCARDABLE 
-BEGIN
-    POPUP "&File"
-    BEGIN
-        MENUITEM "&New Archive...\tCtrl+N",     ID_FILE_NEW
-        MENUITEM "&Open Archive...\tCtrl+O",    ID_FILE_OPEN
-        MENUITEM "&Close Archive\tCtrl+L",      ID_FILE_CLOSE
-        MENUITEM SEPARATOR
-        MENUITEM "Recent File",                 ID_FILE_MRU_FILE1, GRAYED
-        MENUITEM SEPARATOR
-        MENUITEM "E&xit",                       ID_APP_EXIT
-    END
-    POPUP "&Actions"
-    BEGIN
-        MENUITEM "Add...\tCtrl+A",              ID_ACTIONS_ADD
-        MENUITEM "&Delete\tCtrl+D",             ID_ACTIONS_DELETE
-    END
-    POPUP "&Help"
-    BEGIN
-        MENUITEM "&About NsZip...",             ID_APP_ABOUT
-    END
-END
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Accelerator
-//
-
-IDR_MAINFRAME ACCELERATORS PRELOAD MOVEABLE PURE 
-BEGIN
-    "N",            ID_FILE_NEW,            VIRTKEY, CONTROL
-    "O",            ID_FILE_OPEN,           VIRTKEY, CONTROL
-    "S",            ID_FILE_SAVE,           VIRTKEY, CONTROL
-    "Z",            ID_EDIT_UNDO,           VIRTKEY, CONTROL
-    "X",            ID_EDIT_CUT,            VIRTKEY, CONTROL
-    "C",            ID_EDIT_COPY,           VIRTKEY, CONTROL
-    "V",            ID_EDIT_PASTE,          VIRTKEY, CONTROL
-    VK_BACK,        ID_EDIT_UNDO,           VIRTKEY, ALT
-    VK_DELETE,      ID_EDIT_CUT,            VIRTKEY, SHIFT
-    VK_INSERT,      ID_EDIT_COPY,           VIRTKEY, CONTROL
-    VK_INSERT,      ID_EDIT_PASTE,          VIRTKEY, SHIFT
-    VK_F6,          ID_NEXT_PANE,           VIRTKEY 
-    VK_F6,          ID_PREV_PANE,           VIRTKEY, SHIFT
-END
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Dialog
-//
-
-IDD_ABOUTBOX DIALOG DISCARDABLE  34, 22, 217, 55
-STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
-CAPTION "About nszip"
-FONT 8, "MS Sans Serif"
-BEGIN
-    ICON            IDR_MAINFRAME,IDC_STATIC,11,17,20,20
-    LTEXT           "nszip Version 1.0",IDC_STATIC,40,10,119,8
-    LTEXT           "Copyright \251 1995",IDC_STATIC,40,25,119,8
-    DEFPUSHBUTTON   "OK",IDOK,176,6,32,14,WS_GROUP
-END
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Version
-//
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,0,0,1
- PRODUCTVERSION 1,0,0,1
- FILEFLAGSMASK 0x3fL
-#ifdef _DEBUG
- FILEFLAGS 0x1L
-#else
- FILEFLAGS 0x0L
-#endif
- FILEOS 0x4L
- FILETYPE 0x1L
- FILESUBTYPE 0x0L
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904B0"
-        BEGIN
-            VALUE "CompanyName", "\0"
-            VALUE "FileDescription", "NSZIP MFC Application\0"
-            VALUE "FileVersion", "1, 0, 0, 1\0"
-            VALUE "InternalName", "NSZIP\0"
-            VALUE "LegalCopyright", "Copyright \251 1995\0"
-            VALUE "LegalTrademarks", "\0"
-            VALUE "OriginalFilename", "NSZIP.EXE\0"
-            VALUE "ProductName", "NSZIP Application\0"
-            VALUE "ProductVersion", "1, 0, 0, 1\0"
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
-
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// String Table
-//
-
-STRINGTABLE PRELOAD DISCARDABLE 
-BEGIN
-    IDR_MAINFRAME           "nszip\n\nNszip\n\n\nNszip.Document\nNszip Document"
-END
-
-STRINGTABLE PRELOAD DISCARDABLE 
-BEGIN
-    AFX_IDS_APP_TITLE       "nszip"
-    AFX_IDS_IDLEMESSAGE     "Ready"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    ID_INDICATOR_EXT        "EXT"
-    ID_INDICATOR_CAPS       "CAP"
-    ID_INDICATOR_NUM        "NUM"
-    ID_INDICATOR_SCRL       "SCRL"
-    ID_INDICATOR_OVR        "OVR"
-    ID_INDICATOR_REC        "REC"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    ID_FILE_NEW             "Create a new archive\nNew"
-    ID_FILE_OPEN            "Open an existing archive\nOpen"
-    ID_FILE_CLOSE           "Close the active archive\nClose"
-    ID_FILE_SAVE            "Save the active document\nSave"
-    ID_FILE_SAVE_AS         "Save the active document with a new name\nSave As"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    ID_APP_ABOUT            "Display program information, version number and copyright\nAbout"
-    ID_APP_EXIT             "Quit the application; prompts to save documents\nExit"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    ID_FILE_MRU_FILE1       "Open this document"
-    ID_FILE_MRU_FILE2       "Open this document"
-    ID_FILE_MRU_FILE3       "Open this document"
-    ID_FILE_MRU_FILE4       "Open this document"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    ID_NEXT_PANE            "Switch to the next window pane\nNext Pane"
-    ID_PREV_PANE            "Switch back to the previous window pane\nPrevious Pane"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    ID_WINDOW_SPLIT         "Split the active window into panes\nSplit"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    ID_EDIT_CLEAR           "Erase the selection\nErase"
-    ID_EDIT_CLEAR_ALL       "Erase everything\nErase All"
-    ID_EDIT_COPY            "Copy the selection and put it on the Clipboard\nCopy"
-    ID_EDIT_CUT             "Cut the selection and put it on the Clipboard\nCut"
-    ID_EDIT_FIND            "Find the specified text\nFind"
-    ID_EDIT_PASTE           "Insert Clipboard contents\nPaste"
-    ID_EDIT_REPEAT          "Repeat the last action\nRepeat"
-    ID_EDIT_REPLACE         "Replace specific text with different text\nReplace"
-    ID_EDIT_SELECT_ALL      "Select the entire document\nSelect All"
-    ID_EDIT_UNDO            "Undo the last action\nUndo"
-    ID_EDIT_REDO            "Redo the previously undone action\nRedo"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    ID_VIEW_STATUS_BAR      "Show or hide the status bar\nToggle StatusBar"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    AFX_IDS_SCSIZE          "Change the window size"
-    AFX_IDS_SCMOVE          "Change the window position"
-    AFX_IDS_SCMINIMIZE      "Reduce the window to an icon"
-    AFX_IDS_SCMAXIMIZE      "Enlarge the window to full size"
-    AFX_IDS_SCNEXTWINDOW    "Switch to the next document window"
-    AFX_IDS_SCPREVWINDOW    "Switch to the previous document window"
-    AFX_IDS_SCCLOSE         "Close the active window and prompts to save the documents"
-END
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    AFX_IDS_SCRESTORE       "Restore the window to normal size"
-    AFX_IDS_SCTASKLIST      "Activate Task List"
-END
-
-
-#ifndef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 3 resource.
-//
-#include "res\nszip.rc2"  // non-Microsoft Visual C++ edited resources
-
-#define _AFX_NO_SPLITTER_RESOURCES
-#define _AFX_NO_OLE_RESOURCES
-#define _AFX_NO_TRACKER_RESOURCES
-#define _AFX_NO_PROPERTY_RESOURCES
-#include "afxres.rc"  	// Standard components
-
-/////////////////////////////////////////////////////////////////////////////
-#endif    // not APSTUDIO_INVOKED
-

mozilla/xpinstall/wizard/windows/nszip/nszipdoc.cpp

@@ -1,264 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// nszipdoc.cpp : implementation of the CNsZipDoc class
-//
-
-#include "stdafx.h"
-#include "nszip.h"
-
-#include "nszipdoc.h"
-
-#ifdef _DEBUG
-#undef THIS_FILE
-static char BASED_CODE THIS_FILE[] = __FILE__;
-#endif
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipDoc
-
-IMPLEMENT_DYNCREATE(CNsZipDoc, CDocument)
-
-BEGIN_MESSAGE_MAP(CNsZipDoc, CDocument)
-	//{{AFX_MSG_MAP(CNsZipDoc)
-	//}}AFX_MSG_MAP
-END_MESSAGE_MAP()
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipDoc construction/destruction
-
-CNsZipDoc::CNsZipDoc()
-{
-	m_hUpdateFile = NULL;
-}
-
-CNsZipDoc::~CNsZipDoc()
-{
-}
-
-BOOL CNsZipDoc::OnNewDocument(LPCTSTR lpszPathName)
-{
-	char	szStub[MAX_PATH];
-
-	// If we were doing a resource update, discard any changes
-	if (m_hUpdateFile) {
-		VERIFY(::EndUpdateResource(m_hUpdateFile, TRUE));
-
-		// Delete the archive
-		DeleteFile(m_strPathName);
-	}
-
-	if (!CDocument::OnNewDocument())
-		return FALSE;
-
-	// Set the pathname
-	SetPathName(lpszPathName);
-
-	// Copy the stub executable and make it the basis of the archive
-	::GetModuleFileName(NULL, szStub, sizeof(szStub));
-	strcpy(strrchr(szStub, '\\') + 1, "Nsinstall.exe");
-	::CopyFile(szStub, m_strPathName, FALSE);  // overwrite an existing file
-
-	// Get a handle we can use with UpdateResource()
-	VERIFY(m_hUpdateFile = ::BeginUpdateResource(m_strPathName, FALSE));
-	return m_hUpdateFile != NULL;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipDoc serialization
-
-void CNsZipDoc::Serialize(CArchive& ar)
-{
-	if (ar.IsStoring())
-	{
-		// TODO: add storing code here
-	}
-	else
-	{
-		// TODO: add loading code here
-	}
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipDoc diagnostics
-
-#ifdef _DEBUG
-void CNsZipDoc::AssertValid() const
-{
-	CDocument::AssertValid();
-}
-
-void CNsZipDoc::Dump(CDumpContext& dc) const
-{
-	CDocument::Dump(dc);
-}
-#endif //_DEBUG
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipDoc commands
-
-void CNsZipDoc::OnCloseDocument() 
-{
-	// If we were doing a resource update, discard any changes
-	if (m_hUpdateFile) {
-		VERIFY(::EndUpdateResource(m_hUpdateFile, TRUE));
-		m_hUpdateFile = NULL;
-
-		// Delete the archive
-		DeleteFile(m_strPathName);
-	}
-	
-	CDocument::OnCloseDocument();
-}
-
-BOOL CNsZipDoc::OnOpenDocument(LPCTSTR lpszPathName) 
-{
-	// If we were doing a resource update, discard any changes
-	if (m_hUpdateFile) {
-		VERIFY(::EndUpdateResource(m_hUpdateFile, TRUE));
-
-		// Delete the archive
-		DeleteFile(m_strPathName);
-	}
-
-	DeleteContents();
-
-	// ZZZ: Get a list of all the FILE resources
-	ASSERT(FALSE);	
-	return TRUE;
-}
-
-void CNsZipDoc::DeleteContents() 
-{
-	m_hUpdateFile = NULL;
-	CDocument::DeleteContents();
-}
-
-BOOL CNsZipDoc::OnSaveDocument(LPCTSTR lpszPathName) 
-{
-	// If we were doing a resource update, save any changes
-	if (m_hUpdateFile) {
-		BOOL	bRet = ::EndUpdateResource(m_hUpdateFile, FALSE);
-
-		ASSERT(bRet);
-		m_hUpdateFile = NULL;
-		return bRet;
-	}
-
-	return TRUE;
-}
-
-// Add a single file to the archive
-BOOL CNsZipDoc::AddFile(LPCTSTR lpszFile)
-{
-	HANDLE	hFile;
-	LPBYTE	lpBuf;
-	LPBYTE	lpBufCmp;
-	DWORD	dwBytesRead;
-	DWORD	dwFileSize;
-	DWORD	dwFileSizeCmp;
-
-	// Check if we are trying to add the archive file itself
-	// (this could happen if the user passes *.* as a file spec)
-	if (m_strPathName.CompareNoCase(lpszFile) == 0)
-		return FALSE;
-
-	// Open the file
-	hFile = ::CreateFile(lpszFile, GENERIC_READ, FILE_SHARE_READ, NULL,
-		OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-
-	if (hFile == INVALID_HANDLE_VALUE)
-		return FALSE;
-
-	// Figure out how big the file is
-	dwFileSize = GetFileSize(hFile, NULL);
-
-	// Allocate enough space for the file contents and a DWORD header that
-	// contains the size of the file
-	lpBuf         = (LPBYTE)malloc(dwFileSize);
-	lpBufCmp      = (LPBYTE)malloc(dwFileSize + (sizeof(DWORD) * 2));
-  dwFileSizeCmp = dwFileSize;
-
-  if (lpBuf) {
-		CString	strResourceName = strrchr(lpszFile, '\\') + 1;
-
-		// It's really important that the resource name be UPPERCASE
-		strResourceName.MakeUpper();
-
-//		*(LPDWORD)lpBuf = dwFileSize;
-		::ReadFile(hFile, lpBuf, dwFileSize, &dwBytesRead, NULL);
-		ASSERT(dwBytesRead == dwFileSize);
-
-    if(compress((lpBufCmp + (sizeof(DWORD) * 2)), &dwFileSizeCmp, (const Bytef*)lpBuf, dwFileSize) != Z_OK)
-      return(FALSE);
-
-    // The first DWORD holds the total size of the file to be stored in the
-    // resource (in this case, it's the compressed size)
-    // The second DWORD holds the original uncompressed size of the file.
-    *(LPDWORD)lpBufCmp = dwFileSizeCmp;
-    *(LPDWORD)(lpBufCmp + sizeof(DWORD)) = dwFileSize;
-    
-    VERIFY(::UpdateResource(m_hUpdateFile, "FILE", strResourceName,
-			MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), lpBufCmp, dwFileSizeCmp + (sizeof(DWORD) * 2)));
-	}
-
-	free(lpBuf);
-	::CloseHandle(hFile);
-	return TRUE;
-}
-
-// Add one or more files to the archive (lpszFiles can be a wildcard)
-void CNsZipDoc::AddFiles(LPCTSTR lpszFiles)
-{
-	ASSERT(m_hUpdateFile);
-	ASSERT(lpszFiles);
-
-	if (lpszFiles) {
-		HANDLE			hFindFile;
-		WIN32_FIND_DATA	findFileData;
-		char			szPath[MAX_PATH];
-
-		// Get a full pathname to the files
-		::GetFullPathName(lpszFiles, sizeof(szPath), szPath, NULL);
-
-		// Get the first file that matches
-		hFindFile = ::FindFirstFile(szPath, &findFileData);
-
-		if (hFindFile == INVALID_HANDLE_VALUE)
-			return;
-
-		do {
-			char	szFile[MAX_PATH];
-
-			// We need to pass to AddFile() whatever kind of path we were passed,
-			// e.g. simple, relative, full
-			strcpy(szFile, szPath);
-			strcpy(strrchr(szFile, '\\') + 1, findFileData.cFileName);
-			AddFile(szFile);
-		} while (::FindNextFile(hFindFile, &findFileData));
-
-		::FindClose(hFindFile);
-	}
-}

mozilla/xpinstall/wizard/windows/nszip/nszipdoc.h

@@ -1,80 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// nszipdoc.h : interface of the CNsZipDoc class
-//
-/////////////////////////////////////////////////////////////////////////////
-
-class CNsZipDoc : public CDocument
-{
-protected: // create from serialization only
-	CNsZipDoc();
-	DECLARE_DYNCREATE(CNsZipDoc)
-
-// Attributes
-public:
-
-// Operations
-public:
-	// Create an archive with the specified file name. Wrapper around
-	// the MFC OnNewDocument member
-	BOOL	OnNewDocument(LPCTSTR lpszPathName);
-
-	// Add a single file to the archive
-	BOOL	AddFile(LPCTSTR lpszFile);
-
-	// Add one or more files to the archive (lpszFiles can be a wildcard)
-	void	AddFiles(LPCTSTR lpszFiles);
-
-// Overrides
-	// ClassWizard generated virtual function overrides
-	//{{AFX_VIRTUAL(CNsZipDoc)
-	public:
-	virtual void OnCloseDocument();
-	virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
-	virtual void DeleteContents();
-	virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
-	//}}AFX_VIRTUAL
-
-// Implementation
-public:
-	virtual ~CNsZipDoc();
-	virtual void Serialize(CArchive& ar);   // overridden for document i/o
-#ifdef _DEBUG
-	virtual void AssertValid() const;
-	virtual void Dump(CDumpContext& dc) const;
-#endif
-
-protected:
-	HANDLE	m_hUpdateFile;
-
-// Generated message map functions
-protected:
-	//{{AFX_MSG(CNsZipDoc)
-	//}}AFX_MSG
-	DECLARE_MESSAGE_MAP()
-};
-
-/////////////////////////////////////////////////////////////////////////////

mozilla/xpinstall/wizard/windows/nszip/nszipvw.cpp

@@ -1,117 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// nszipvw.cpp : implementation of the CNsZipView class
-//
-
-#include "stdafx.h"
-#include "nszip.h"
-
-#include "nszipdoc.h"
-#include "nszipvw.h"
-
-#ifdef _DEBUG
-#undef THIS_FILE
-static char BASED_CODE THIS_FILE[] = __FILE__;
-#endif
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipView
-
-IMPLEMENT_DYNCREATE(CNsZipView, CView)
-
-BEGIN_MESSAGE_MAP(CNsZipView, CView)
-	//{{AFX_MSG_MAP(CNsZipView)
-	ON_COMMAND(ID_ACTIONS_DELETE, OnActionsDelete)
-	ON_UPDATE_COMMAND_UI(ID_ACTIONS_DELETE, OnUpdateActionsDelete)
-	ON_COMMAND(ID_ACTIONS_ADD, OnActionsAdd)
-	//}}AFX_MSG_MAP
-END_MESSAGE_MAP()
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipView construction/destruction
-
-CNsZipView::CNsZipView()
-{
-	// TODO: add construction code here
-
-}
-
-CNsZipView::~CNsZipView()
-{
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipView drawing
-
-void CNsZipView::OnDraw(CDC* pDC)
-{
-	CNsZipDoc* pDoc = GetDocument();
-	ASSERT_VALID(pDoc);
-
-	// TODO: add draw code for native data here
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipView diagnostics
-
-#ifdef _DEBUG
-void CNsZipView::AssertValid() const
-{
-	CView::AssertValid();
-}
-
-void CNsZipView::Dump(CDumpContext& dc) const
-{
-	CView::Dump(dc);
-}
-
-CNsZipDoc* CNsZipView::GetDocument() // non-debug version is inline
-{
-	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CNsZipDoc)));
-	return (CNsZipDoc*)m_pDocument;
-}
-#endif //_DEBUG
-
-/////////////////////////////////////////////////////////////////////////////
-// CNsZipView message handlers
-
-void CNsZipView::OnActionsDelete() 
-{
-	// TODO: Add your command handler code here
-	
-}
-
-void CNsZipView::OnUpdateActionsDelete(CCmdUI* pCmdUI) 
-{
-	// TODO: Add your command update UI handler code here
-	
-}
-
-void CNsZipView::OnActionsAdd() 
-{
-	// TODO: Add your command handler code here
-	
-}

mozilla/xpinstall/wizard/windows/nszip/nszipvw.h

@@ -1,76 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// nszipvw.h : interface of the CNsZipView class
-//
-/////////////////////////////////////////////////////////////////////////////
-
-class CNsZipView : public CView
-{
-protected: // create from serialization only
-	CNsZipView();
-	DECLARE_DYNCREATE(CNsZipView)
-
-// Attributes
-public:
-	CNsZipDoc* GetDocument();
-
-// Operations
-public:
-
-// Overrides
-	// ClassWizard generated virtual function overrides
-	//{{AFX_VIRTUAL(CNsZipView)
-	public:
-	virtual void OnDraw(CDC* pDC);  // overridden to draw this view
-	protected:
-	//}}AFX_VIRTUAL
-
-// Implementation
-public:
-	virtual ~CNsZipView();
-#ifdef _DEBUG
-	virtual void AssertValid() const;
-	virtual void Dump(CDumpContext& dc) const;
-#endif
-
-protected:
-
-// Generated message map functions
-protected:
-	//{{AFX_MSG(CNsZipView)
-	afx_msg void OnActionsDelete();
-	afx_msg void OnUpdateActionsDelete(CCmdUI* pCmdUI);
-	afx_msg void OnActionsAdd();
-	//}}AFX_MSG
-	DECLARE_MESSAGE_MAP()
-};
-
-#ifndef _DEBUG  // debug version in nszipvw.cpp
-inline CNsZipDoc* CNsZipView::GetDocument()
-   { return (CNsZipDoc*)m_pDocument; }
-#endif
-
-/////////////////////////////////////////////////////////////////////////////

mozilla/xpinstall/wizard/windows/nszip/res/nszip.rc2

@@ -1,13 +0,0 @@
-//
-// NSZIP.RC2 - resources Microsoft Visual C++ does not edit directly
-//
-
-#ifdef APSTUDIO_INVOKED
-	#error this file is not editable by Microsoft Visual C++
-#endif //APSTUDIO_INVOKED
-
-
-/////////////////////////////////////////////////////////////////////////////
-// Add manually edited resources here...
-
-/////////////////////////////////////////////////////////////////////////////

mozilla/xpinstall/wizard/windows/nszip/resource.h

@@ -1,46 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-//{{NO_DEPENDENCIES}}
-// Microsoft Visual C++ generated include file.
-// Used by nszip.rc
-//
-#define IDD_ABOUTBOX                    100
-#define IDR_MAINFRAME                   128
-#define IDR_NSZIPTYPE                   129
-#define ID_ACTIONS_ADD                  32772
-#define ID_ACTIONS_DELETE               32773
-
-// Next default values for new objects
-// 
-#ifdef APSTUDIO_INVOKED
-#ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_3D_CONTROLS                     1
-#define _APS_NEXT_RESOURCE_VALUE        130
-#define _APS_NEXT_COMMAND_VALUE         32774
-#define _APS_NEXT_CONTROL_VALUE         1000
-#define _APS_NEXT_SYMED_VALUE           101
-#endif
-#endif

mozilla/xpinstall/wizard/windows/nszip/stdafx.cpp

@@ -1,31 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// stdafx.cpp : source file that includes just the standard includes
-//	nszip.pch will be the pre-compiled header
-//	stdafx.obj will contain the pre-compiled type information
-
-#include "stdafx.h"
-

mozilla/xpinstall/wizard/windows/nszip/stdafx.h

@@ -1,32 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Troy Chevalier <troy@netscape.com>
- *     Sean Su <ssu@netscape.com>
- */
-
-// stdafx.h : include file for standard system include files,
-//  or project specific include files that are used frequently, but
-//      are changed infrequently
-//
-
-#include <afxwin.h>         // MFC core and standard components
-#include <afxext.h>         // MFC extensions

mozilla/xpinstall/wizard/windows/nsztool/makefile.win

@@ -1,52 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, 
-# released March 31, 1998. 
-#
-# The Initial Developer of the Original Code is Netscape Communications 
-# Corporation.  Portions created by Netscape are
-# Copyright (C) 1999 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..\..
-
-MAKE_OBJ_TYPE   = EXE
-USE_NON_MT_LIBS = 1
-
-MODULE          = nsztool
-PROGRAM         = .\$(OBJDIR)\$(MODULE).exe
-
-OBJS =                          \
-    .\$(OBJDIR)\nsztool.obj     \
-    $(NULL)
-
-LLIBS=                          \
-    $(DIST)\lib\zlib_s.lib      \
-    $(NULL)
-
-LLFLAGS=                        \
-    /subsystem:windows          \
-    /machine:i386               \
-    $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-install:: $(PROGRAM)
-    $(MAKE_INSTALL) $(PROGRAM) $(DIST)\install
-    $(DIST)\install\$(MODULE).exe -g $(DIST)\install\nszip.exe $(DIST)\install\nsinstall.exe
-
-clobber_all::
-    $(RM) $(DIST)\install\$(MODULE).exe
-    $(RM) $(DIST)\install\nszip.exe
-

mozilla/xpinstall/wizard/windows/nsztool/nsztool.c

@@ -1,659 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#include <windows.h>
-#include <stdio.h>
-#include <io.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include "nsztool.h"
-#include "zlib.h"
-
-//#define SSU_DEBUG
-
-/* Function to show the usage for this application */
-void ShowUsage(char *name)
-{
-    char szBuf[MAX_BUF];
-
-    wsprintf(szBuf, "Usage: %s <output sea name> <files [file1] [file2]...>\n", name);
-    lstrcat(szBuf, "\n");
-    lstrcat(szBuf, "    output sea name: name to use for the self-extracting executable\n");
-    lstrcat(szBuf, "    files: one or more files to add to the self-extracing executable\n");
-    MessageBox(NULL, szBuf, "Usage", MB_OK);
-}
-
-/* Function to print error message with/without error code */
-void PrintError(LPSTR szMsg, DWORD dwErrorCodeSH)
-{
-  DWORD dwErr;
-  char  szErrorString[MAX_BUF];
-
-  if(dwErrorCodeSH == ERROR_CODE_SHOW)
-  {
-    dwErr = GetLastError();
-    wsprintf(szErrorString, "%d : %s", dwErr, szMsg);
-  }
-  else
-    wsprintf(szErrorString, "%s", szMsg);
-
-  MessageBox(NULL, szErrorString, NULL, MB_ICONEXCLAMATION);
-}
-
-/* Function to remove quotes from a string */
-void RemoveQuotes(LPSTR lpszSrc, LPSTR lpszDest, int iDestSize)
-{
-  char *lpszBegin;
-
-  if(lstrlen(lpszSrc) > iDestSize)
-    return;
-
-  if(*lpszSrc == '\"')
-    lpszBegin = &lpszSrc[1];
-  else
-    lpszBegin = lpszSrc;
-
-  lstrcpy(lpszDest, lpszBegin);
-
-  if(lpszDest[lstrlen(lpszDest) - 1] == '\"')
-    lpszDest[lstrlen(lpszDest) - 1] = '\0';
-}
-
-/* Function to remove the last backslash from a path string */
-void RemoveBackSlash(LPSTR szInput)
-{
-  int   iCounter;
-  DWORD dwInputLen;
-
-  if(szInput != NULL)
-  {
-    dwInputLen = lstrlen(szInput);
-
-    for(iCounter = dwInputLen -1; iCounter >= 0 ; iCounter--)
-    {
-      if(szInput[iCounter] == '\\')
-        szInput[iCounter] = '\0';
-      else
-        break;
-    }
-  }
-}
-
-/* Function to append a backslash to a path string */
-void AppendBackSlash(LPSTR szInput, DWORD dwInputSize)
-{
-  if(szInput != NULL)
-  {
-    if(szInput[strlen(szInput) - 1] != '\\')
-    {
-      if(((DWORD)lstrlen(szInput) + 1) < dwInputSize)
-      {
-        lstrcat(szInput, "\\");
-      }
-    }
-  }
-}
-
-/* Function to parse a path string for one of three parts of a path:
- *   Filename only
- *   Path only
- *   drive only */
-void ParsePath(LPSTR szInput, LPSTR szOutput, DWORD dwOutputSize, DWORD dwType)
-{
-  int   iCounter;
-  DWORD dwCounter;
-  DWORD dwInputLen;
-  BOOL  bFound;
-
-  if((szInput != NULL) && (szOutput != NULL))
-  {
-    bFound        = FALSE;
-    dwInputLen    = lstrlen(szInput);
-    ZeroMemory(szOutput, dwOutputSize);
-
-    if(dwInputLen < dwOutputSize)
-    {
-      switch(dwType)
-      {
-        case PP_FILENAME_ONLY:
-          for(iCounter = dwInputLen - 1; iCounter >= 0; iCounter--)
-          {
-            if(szInput[iCounter] == '\\')
-            {
-              lstrcpy(szOutput, &szInput[iCounter + 1]);
-              bFound = TRUE;
-              break;
-            }
-          }
-          if(bFound == FALSE)
-            lstrcpy(szOutput, szInput);
-
-          break;
-
-        case PP_PATH_ONLY:
-          for(iCounter = dwInputLen - 1; iCounter >= 0; iCounter--)
-          {
-            if(szInput[iCounter] == '\\')
-            {
-              lstrcpy(szOutput, szInput);
-              szOutput[iCounter + 1] = '\0';
-              bFound = TRUE;
-              break;
-            }
-          }
-          if(bFound == FALSE)
-            lstrcpy(szOutput, szInput);
-
-          break;
-
-        case PP_ROOT_ONLY:
-          if(szInput[1] == ':')
-          {
-            szOutput[0] = szInput[0];
-            szOutput[1] = szInput[1];
-            AppendBackSlash(szOutput, dwOutputSize);
-          }
-          else if(szInput[1] == '\\')
-          {
-            int iFoundBackSlash = 0;
-            for(dwCounter = 0; dwCounter < dwInputLen; dwCounter++)
-            {
-              if(szInput[dwCounter] == '\\')
-              {
-                szOutput[dwCounter] = szInput[dwCounter];
-                ++iFoundBackSlash;
-              }
-
-              if(iFoundBackSlash == 3)
-                break;
-            }
-
-            if(iFoundBackSlash != 0)
-              AppendBackSlash(szOutput, dwOutputSize);
-          }
-          break;
-      }
-    }
-  }
-}
-
-/* Function to check to see if a file exists.
- * If it does, return it's attributes */
-long FileExists(LPSTR szFile)
-{
-  DWORD rv;
-
-  if((rv = GetFileAttributes(szFile)) == -1)
-  {
-    return(FALSE);
-  }
-  else
-  {
-    return(rv);
-  }
-}
-
-/* Function to locate the first non space character in a string,
- * and return a pointer to it. */
-LPSTR GetFirstNonSpace(LPSTR lpszString)
-{
-  int   i;
-  int   iStrLength;
-
-  iStrLength = lstrlen(lpszString);
-
-  for(i = 0; i < iStrLength; i++)
-  {
-    if(!isspace(lpszString[i]))
-      return(&lpszString[i]);
-  }
-
-  return(NULL);
-}
-
-/* Function to return the argument count given a command line input
- * format string */
-int GetArgC(LPSTR lpszCommandLine)
-{
-  int   i;
-  int   iArgCount;
-  int   iStrLength;
-  LPSTR lpszBeginStr;
-  BOOL  bFoundQuote;
-  BOOL  bFoundSpace;
-
-  iArgCount    = 0;
-  lpszBeginStr = GetFirstNonSpace(lpszCommandLine);
-
-  if(lpszBeginStr == NULL)
-    return(iArgCount);
-
-  iStrLength   = lstrlen(lpszBeginStr);
-  bFoundQuote  = FALSE;
-  bFoundSpace  = TRUE;
-
-  for(i = 0; i < iStrLength; i++)
-  {
-    if(lpszCommandLine[i] == '\"')
-    {
-      if(bFoundQuote == FALSE)
-      {
-        ++iArgCount;
-        bFoundQuote = TRUE;
-      }
-      else
-      {
-        bFoundQuote = FALSE;
-      }
-    }
-    else if(bFoundQuote == FALSE)
-    {
-      if(!isspace(lpszCommandLine[i]) && (bFoundSpace == TRUE))
-      {
-        ++iArgCount;
-        bFoundSpace = FALSE;
-      }
-      else if(isspace(lpszCommandLine[i]))
-      {
-        bFoundSpace = TRUE;
-      }
-    }
-  }
-
-  return(iArgCount);
-}
-
-/* Function to return a specific argument parameter from a given command line input
- * format string. */
-LPSTR GetArgV(LPSTR lpszCommandLine, int iIndex, LPSTR lpszDest, int iDestSize)
-{
-  int   i;
-  int   j;
-  int   iArgCount;
-  int   iStrLength;
-  LPSTR lpszBeginStr;
-  LPSTR lpszDestTemp;
-  BOOL  bFoundQuote;
-  BOOL  bFoundSpace;
-
-  iArgCount    = 0;
-  lpszBeginStr = GetFirstNonSpace(lpszCommandLine);
-
-  if(lpszBeginStr == NULL)
-    return(NULL);
-
-  lpszDestTemp = (char *)calloc(iDestSize, sizeof(char));
-  if(lpszDestTemp == NULL)
-  {
-    PrintError("Out of memory", ERROR_CODE_HIDE);
-    exit(1);
-  }
-
-  ZeroMemory(lpszDest, iDestSize);
-  iStrLength    = lstrlen(lpszBeginStr);
-  bFoundQuote   = FALSE;
-  bFoundSpace   = TRUE;
-  j             = 0;
-
-  for(i = 0; i < iStrLength; i++)
-  {
-    if(lpszCommandLine[i] == '\"')
-    {
-      if(bFoundQuote == FALSE)
-      {
-        ++iArgCount;
-        bFoundQuote = TRUE;
-      }
-      else
-      {
-        bFoundQuote = FALSE;
-      }
-    }
-    else if(bFoundQuote == FALSE)
-    {
-      if(!isspace(lpszCommandLine[i]) && (bFoundSpace == TRUE))
-      {
-        ++iArgCount;
-        bFoundSpace = FALSE;
-      }
-      else if(isspace(lpszCommandLine[i]))
-      {
-        bFoundSpace = TRUE;
-      }
-    }
-
-    if((iIndex == (iArgCount - 1)) &&
-      ((bFoundQuote == TRUE) || (bFoundSpace == FALSE) ||
-      ((bFoundQuote == FALSE) && (lpszCommandLine[i] == '\"'))))
-    {
-      if(j < iDestSize)
-      {
-        lpszDestTemp[j] = lpszCommandLine[i];
-        ++j;
-      }
-      else
-      {
-        lpszDestTemp[j] = '\0';
-      }
-    }
-  }
-
-  RemoveQuotes(lpszDestTemp, lpszDest, iDestSize);
-  free(lpszDestTemp);
-  return(lpszDest);
-}
-
-/* Function to add a file to a self-extracting .exe file.
- * It compresses the file, then adds it as a resource type "FILE". */
-void AddFile(LPSTR lpszSeaExe, LPSTR lpszFile)
-{
-  char        szBuf[MAX_BUF];
-  char        szResourceName[MAX_BUF];
-  HANDLE      hSeaExe;
-  HANDLE      hInputFile;
-  DWORD       dwBytesRead;
-  DWORD       dwFileSize;
-  DWORD       dwFileSizeCmp;
-  LPBYTE      lpBuf;
-  LPBYTE      lpBufCmp;
-
-  ParsePath(lpszFile, szResourceName, sizeof(szResourceName), PP_FILENAME_ONLY);
-  strupr(szResourceName);
-  hInputFile = CreateFile(lpszFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-
-  if(hInputFile == INVALID_HANDLE_VALUE)
-  {
-    PrintError("CreateFile() failed", ERROR_CODE_SHOW);
-    exit(1);
-  }
-
-  dwFileSize    = GetFileSize(hInputFile, NULL);
-  dwFileSizeCmp = dwFileSize;
-  lpBuf         = (LPBYTE)malloc(dwFileSize);
-  lpBufCmp      = (LPBYTE)malloc(dwFileSize + (sizeof(DWORD) * 2));
-  if((lpBuf == NULL) || (lpBufCmp == NULL))
-  {
-    PrintError("Out of memory", ERROR_CODE_HIDE);
-    exit(1);
-  }
-
-  ReadFile(hInputFile, lpBuf, dwFileSize, &dwBytesRead, NULL);
-  if(dwBytesRead != dwFileSize)
-  {
-    wsprintf(szBuf, "Error reading file: %s", lpszFile);
-    PrintError(szBuf, ERROR_CODE_HIDE);
-    exit(1);
-  }
-
-  if(compress((lpBufCmp + (sizeof(DWORD) * 2)), &dwFileSizeCmp, (const Bytef*)lpBuf, dwFileSize) != Z_OK)
-  {
-    PrintError("Error occurred during compression of archives!", ERROR_CODE_HIDE);
-    exit(1);
-  }
-
-  *(LPDWORD)lpBufCmp = dwFileSizeCmp;
-  *(LPDWORD)(lpBufCmp + sizeof(DWORD)) = dwFileSize;
-
-  if((hSeaExe = BeginUpdateResource(lpszSeaExe, FALSE)) == NULL)
-  {
-    DWORD dwErr;
-
-    dwErr = GetLastError();
-    if(dwErr == ERROR_CALL_NOT_IMPLEMENTED)
-    {
-      MessageBox(NULL, "This application does not run under this OS", NULL, MB_ICONEXCLAMATION);
-      exit(0);
-    }
-    else
-    {
-      PrintError("BeginUpdateResource() error", ERROR_CODE_SHOW);
-      exit(1);
-    }
-  }
-  if(!UpdateResource(hSeaExe, "FILE", szResourceName, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
-                     lpBufCmp, dwFileSizeCmp + (sizeof(DWORD) * 2)))
-  {
-    PrintError("UpdateResource() failed", ERROR_CODE_SHOW);
-    exit(1);
-  }
-  if(!EndUpdateResource(hSeaExe, FALSE))
-  {
-    PrintError("EndUpdateResource() failed", ERROR_CODE_SHOW);
-    exit(1);
-  }
-
-  free(lpBuf);
-  if(!CloseHandle(hInputFile))
-  {
-    PrintError("CloseHandle() failed", ERROR_CODE_SHOW);
-    exit(1);
-  }
-}
-
-/* Function to extract a resourced file from a .exe file.
- * It also uncompresss the file after extracting it. */
-BOOL APIENTRY ExtractFilesProc(HANDLE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG lParam)
-{
-  char    szBuf[MAX_BUF];
-  HRSRC   hResInfo;
-  LPSTR   lpszSeaExe = (LPSTR)lParam;
-  HANDLE  hFile;
-  LPBYTE  lpBytes;
-  LPBYTE  lpBytesUnCmp;
-  HGLOBAL hGlobal;
-
-  // Extract the file
-  hResInfo = FindResource((HINSTANCE)hModule, lpszName, lpszType);
-  hGlobal  = LoadResource((HINSTANCE)hModule, hResInfo);
-  lpBytes  = (LPBYTE)LockResource(hGlobal);
-
-  // Create the file
-  hFile = CreateFile(lpszSeaExe, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
-                     FILE_ATTRIBUTE_TEMPORARY, NULL);
-
-  if(hFile != INVALID_HANDLE_VALUE)
-  {
-    DWORD dwSize;
-    DWORD dwSizeUnCmp;
-
-    lpBytesUnCmp = (LPBYTE)malloc((*(LPDWORD)(lpBytes + sizeof(DWORD))) + 1);
-    dwSizeUnCmp  = *(LPDWORD)(lpBytes + sizeof(DWORD));
-
-    // Copy the file. The first DWORD specifies the size of the file
-    dwSize = *(LPDWORD)lpBytes;
-    lpBytes += (sizeof(DWORD) * 2);
-
-    if(uncompress(lpBytesUnCmp, &dwSizeUnCmp, lpBytes, dwSize) != Z_OK)
-    {
-      wsprintf(szBuf, "Error occurred during uncompression of %s: ", lpszSeaExe);
-      PrintError(szBuf, ERROR_CODE_HIDE);
-      CloseHandle(hFile);
-      FreeResource(hResInfo);
-      return FALSE;
-    }
-
-    while(dwSizeUnCmp > 0)
-    {
-      DWORD dwBytesToWrite;
-      DWORD dwBytesWritten;
-
-      dwBytesToWrite = dwSizeUnCmp > 4096 ? 4096 : dwSizeUnCmp;
-      if(!WriteFile(hFile, lpBytesUnCmp, dwBytesToWrite, &dwBytesWritten, NULL))
-      {
-        wsprintf(szBuf, "%s: write error", lpszSeaExe);
-        MessageBox(NULL, szBuf, "Error", MB_OK | MB_ICONEXCLAMATION);
-        CloseHandle(hFile);
-        FreeResource(hResInfo);
-        return FALSE;
-      }
-
-      dwSizeUnCmp -= dwBytesWritten;
-      lpBytesUnCmp += dwBytesWritten;
-    }
-
-    CloseHandle(hFile);
-  }
-
-  // Release the resource
-  FreeResource(hResInfo);
-
-  return TRUE;  // keep enumerating
-}
-
-int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)
-{
-  int               i;
-  int               iArgC;
-  char              szBuf[MAX_BUF];
-  char              szArgVBuf[MAX_BUF];
-  char              szFileFullPath[MAX_BUF];
-  char              szSeaExe[MAX_BUF];
-  char              szNsZipName[MAX_BUF];
-  char              szAppName[MAX_BUF];
-
-#ifdef SSU_DEBUG
-  char              szOutputStr[MAX_BUF];
-#endif
-
-  WIN32_FIND_DATA   findFileData;
-  HANDLE            hFindFile;
-  BOOL              bSelfUpdate;
-
-  if(*lpszCmdLine == '\0')
-  {
-    if(GetModuleFileName(NULL, szAppName, sizeof(szAppName)) == 0L)
-    {
-      PrintError("GetModuleFileName() failed", ERROR_CODE_SHOW);
-      exit(1);
-    }
-    ParsePath(szAppName, szBuf, sizeof(szBuf), PP_FILENAME_ONLY);
-    ShowUsage(szBuf);
-    exit(1);
-  }
-
-  iArgC = GetArgC(lpszCmdLine);
-  bSelfUpdate = FALSE;
-
-#ifdef SSU_DEBUG
-  wsprintf(szOutputStr, "ArgC: %d\n", iArgC);
-  for(i = 0; i < iArgC; i++)
-  {
-    GetArgV(lpszCmdLine, i, szArgVBuf, sizeof(szArgVBuf));
-    itoa(i, szBuf, 10);
-    lstrcat(szOutputStr, "    ");
-    lstrcat(szOutputStr, szBuf);
-    lstrcat(szOutputStr, ": ");
-    lstrcat(szOutputStr, szArgVBuf);
-    lstrcat(szOutputStr, "\n");
-  }
-  MessageBox(NULL, szOutputStr, "Output", MB_OK);
-#endif
-
-  /* Get the first parameter */
-  GetArgV(lpszCmdLine, 0, szSeaExe, sizeof(szSeaExe));
-  if(lstrcmpi(szSeaExe, "-g") == 0)
-  {
-    /* The first parameter is "-g".
-     * Create a new nszip that contains nsinstall.exe in itself */
-
-    GetArgV(lpszCmdLine, 1, szNsZipName, sizeof(szNsZipName));
-    GetArgV(lpszCmdLine, 2, szSeaExe, sizeof(szSeaExe));
-    if(!FileExists(szSeaExe))
-    {
-      wsprintf(szBuf, "file not found: %s", szSeaExe);
-      PrintError(szBuf, ERROR_CODE_HIDE);
-      exit(1);
-    }
-
-    if(GetModuleFileName(NULL, szAppName, sizeof(szAppName)) == 0L)
-    {
-      PrintError("GetModuleFileName() failed", ERROR_CODE_SHOW);
-      exit(1);
-    }
-    if(!FileExists(szAppName))
-    {
-      wsprintf(szBuf, "File not found: %s", szAppName);
-      PrintError(szBuf, ERROR_CODE_HIDE);
-      exit(1);
-    }
-
-    if(CopyFile(szAppName, szNsZipName, FALSE) == FALSE)
-    {
-      wsprintf(szBuf, "Error creating %s", szNsZipName);
-      PrintError(szBuf, ERROR_CODE_SHOW);
-      exit(1);
-    }
-
-    AddFile(szNsZipName, szSeaExe);
-    return(0);
-  }
-  else
-  {
-    /* The first parameter is not "-g".  Assume that it's the name of the
-     * self-extracting .exe to be saved as.  So lets create it only if it does not exist. */
-
-    if(!FileExists(szSeaExe))
-      EnumResourceNames(NULL, "FILE", (ENUMRESNAMEPROC)ExtractFilesProc, (LONG)szSeaExe);
-
-    if(!FileExists(szSeaExe))
-    {
-      wsprintf(szBuf, "file not found: %s", szSeaExe);
-      PrintError(szBuf, ERROR_CODE_HIDE);
-      exit(1);
-    }
-  }
-
-  for(i = 1; i < iArgC; i++)
-  {
-    GetArgV(lpszCmdLine, i, szArgVBuf, sizeof(szArgVBuf));
-    GetFullPathName(szArgVBuf, sizeof(szFileFullPath), szFileFullPath, NULL);
-    hFindFile = FindFirstFile(szFileFullPath, &findFileData);
-
-    if(hFindFile == INVALID_HANDLE_VALUE)
-    {
-      wsprintf(szBuf, "file not found: %s", szArgVBuf);
-      PrintError(szBuf, ERROR_CODE_HIDE);
-      exit(1);
-    }
-
-    do
-    {
-      char szFile[MAX_BUF];
-
-      if(!(findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
-      {
-        // We need to pass to AddFile() whatever kind of path we were passed,
-        // e.g. simple, relative, full
-        strcpy(szFile, szFileFullPath);
-        strcpy(strrchr(szFile, '\\') + 1, findFileData.cFileName);
-        AddFile(szSeaExe, szFile);
-      }
-    } while(FindNextFile(hFindFile, &findFileData));
-
-    FindClose(hFindFile);
-  }
-
-  return(0);
-}
-

mozilla/xpinstall/wizard/windows/nsztool/nsztool.h

@@ -1,50 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#ifndef _TESTXPI_H_
-#define _TESTXPI_H_
-
-#define MAX_BUF                         4096
-
-#define ERROR_CODE_HIDE                 0
-#define ERROR_CODE_SHOW                 1
-
-/* PP: Parse Path */
-#define PP_FILENAME_ONLY                1
-#define PP_PATH_ONLY                    2
-#define PP_ROOT_ONLY                    3
-
-void            PrintError(LPSTR szMsg, DWORD dwErrorCodeSH);
-void            RemoveQuotes(LPSTR lpszSrc, LPSTR lpszDest, int dwDestSize);
-void            RemoveBackSlash(LPSTR szInput);
-void            AppendBackSlash(LPSTR szInput, DWORD dwInputSize);
-void            ParsePath(LPSTR szInput, LPSTR szOutput, DWORD dwOutputSize, DWORD dwType);
-long            FileExists(LPSTR szFile);
-int             GetArgC(LPSTR lpszCommandLine);
-LPSTR           GetArgV(LPSTR lpszCommandLine, int iIndex, LPSTR lpszDest, int iDestSize);
-void            AddFile(LPSTR lpszSeaExe, LPSTR lpszFile);
-BOOL APIENTRY   ExtractFilesProc(HANDLE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG lParam);
-
-#endif
-

mozilla/xpinstall/wizard/windows/ren8dot3/example.ini

@@ -1,3 +0,0 @@
-[rename]
-d:\work\1 2\longfi~1.txt=d:\work\1 2\longfilename.txt
-

mozilla/xpinstall/wizard/windows/ren8dot3/makefile.win

@@ -1,42 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, 
-# released March 31, 1998. 
-#
-# The Initial Developer of the Original Code is Netscape Communications 
-# Corporation.  Portions created by Netscape are
-# Copyright (C) 1999 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#     Sean Su <ssu@netscape.com>
-
-DEPTH=..\..\..\..
-
-MAKE_OBJ_TYPE   = EXE
-USE_NON_MT_LIBS = 1
-
-MODULE          = ren8dot3
-PROGRAM         = .\$(OBJDIR)\$(MODULE).exe
-
-OBJS =                          \
-    .\$(OBJDIR)\ren8dot3.obj    \
-    $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-install:: $(PROGRAM)
-    $(MAKE_INSTALL) $(PROGRAM) $(DIST)\install
-
-clobber_all::
-    $(RM) $(DIST)\install\$(MODULE).exe
-

mozilla/xpinstall/wizard/windows/ren8dot3/ren8dot3.c

@@ -1,117 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#include <windows.h>
-#include <stdio.h>
-#include <io.h>
-#include <stdlib.h>
-
-#define _MAX_SIZE_ 64000
-
-char *GetSubString(char *Strings)
-{
-    return(strchr(Strings,0)+1);
-}
-
-void ShowUsage(char *name)
-{
-    char szBuf[_MAX_SIZE_];
-
-    sprintf(szBuf, "usage: %s <source .ini file>\n", name);
-    MessageBox(NULL, szBuf, "Usage", MB_OK);
-}
-
-void RemoveQuotes(LPSTR lpszCmdLine, LPSTR szBuf)
-{
-  char *lpszBegin;
-
-  if(*lpszCmdLine == '\"')
-    lpszBegin = &lpszCmdLine[1];
-  else
-    lpszBegin = lpszCmdLine;
-
-  lstrcpy(szBuf, lpszBegin);
-
-  if(szBuf[lstrlen(szBuf) - 1] == '\"')
-    szBuf[lstrlen(szBuf) - 1] = '\0';
-}
-
-int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)
-{
-    char *temp;
-    char *SubKey;
-    char *SubKeyPtr;
-    char *SubString;
-    char *SubStringPtr;
-    char *ReturnedKeys;
-    char *ReturnedStrings;
-    char *KeyValue;
-    char *SrcIni;
-    char *DestIni;
-    char szBuf[_MAX_SIZE_];
-
-    if(*lpszCmdLine == '\0')
-    {
-        ShowUsage("Ren8dot3.exe");
-        exit(1);
-    }
-
-    SrcIni = (char *)calloc(_MAX_DIR, sizeof(char));
-
-    RemoveQuotes(lpszCmdLine, szBuf);
-    GetShortPathName(szBuf, SrcIni, _MAX_DIR);
-
-    temp            = (char *)calloc(_MAX_SIZE_, sizeof(char));
-    KeyValue        = (char *)calloc(_MAX_SIZE_, sizeof(char));
-    ReturnedKeys    = (char *)calloc(_MAX_SIZE_, sizeof(char));
-    ReturnedStrings = (char *)calloc(_MAX_SIZE_, sizeof(char));
-    SubString       = (char *)calloc(_MAX_SIZE_, sizeof(char));
-    DestIni         = (char *)calloc(_MAX_DIR,   sizeof(char));
-    SubStringPtr    = SubString;
-
-    GetPrivateProfileString("rename", NULL, "_error_", &ReturnedKeys[1], _MAX_SIZE_, SrcIni);
-    SubKey    = (char *)calloc(_MAX_SIZE_, sizeof(char));
-    SubKeyPtr = SubKey;
-    memcpy(SubKey, ReturnedKeys, _MAX_SIZE_);
-    SubKey    = GetSubString(SubKey);
-    while((SubKey[0]) != 0)
-    {
-        GetPrivateProfileString("rename", SubKey, "_error_", KeyValue, _MAX_SIZE_, SrcIni);
-        rename(SubKey, KeyValue);
-        SubKey = GetSubString(SubKey);
-    }
-
-    unlink(SrcIni);
-
-    free(SubKeyPtr);
-    free(temp);
-    free(ReturnedKeys);
-    free(ReturnedStrings);
-    free(KeyValue);
-    free(SubStringPtr);
-    free(SrcIni);
-    free(DestIni);
-
-    return(0);
-}

mozilla/xpinstall/wizard/windows/setup/dialogs.h

@@ -1,56 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#ifndef _DIALOGS_H_
-#define _DIALOGS_H_
-
-LRESULT CALLBACK  DlgProcMain(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
-LRESULT CALLBACK  DlgProcWelcome(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  DlgProcLicense(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  DlgProcSetupType(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  DlgProcSelectComponents(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  DlgProcWindowsIntegration(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  DlgProcProgramFolder(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  DlgProcStartInstall(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  DlgProcReboot(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  DlgProcMessage(HWND hDlg, UINT msg, WPARAM wParam, LONG lParam);
-LRESULT CALLBACK  NewListBoxWndProc( HWND, UINT, WPARAM, LPARAM);
-
-void              AskCancelDlg(HWND hDlg);
-void              lbAddItem(HWND hList, siC *siCComponent);
-void              InstantiateDialog(DWORD dwDlgID, LPSTR szTitle, WNDPROC wpDlgProc);
-void              DlgSequenceNext(void);
-void              DlgSequencePrev(void);
-void              PaintGradientShade(HWND hWnd, HDC hdc);
-BOOL              BrowseForDirectory(HWND hDlg, char *szCurrDir);
-LRESULT CALLBACK  BrowseHookProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
-void              ShowMessage(LPSTR szMessage, BOOL bShow);
-void              DrawCheck(LPDRAWITEMSTRUCT lpdis);
-void              InvalidateLBCheckbox(HWND hwndListBox);
-void              ProcessWindowsMessages(void);
-void              CheckWizardStateCustom(DWORD dwDefault);
-void              SunJavaDependencyHack(DWORD dwIndex, BOOL bSelected);
-
-
-#endif

mozilla/xpinstall/wizard/windows/setup/extern.h

@@ -1,85 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#ifndef _EXTERN_H_
-#define _EXTERN_H_
-
-#include "setup.h"
-
-/* external global variables */
-extern HINSTANCE        hInst;
-extern HINSTANCE        hSetupRscInst;
-extern HINSTANCE        hSDInst;
-extern HINSTANCE        hXPIStubInst;
-
-extern HBITMAP          hbmpBoxChecked;
-extern HBITMAP          hbmpBoxUnChecked;
-
-extern HANDLE           hAccelTable;
-
-extern HWND             hDlg;
-extern HWND             hDlgMessage;
-extern HWND             hWndMain;
-
-extern SDI_NETINSTALL   pfnNetInstall;
-
-extern LPSTR            szEGlobalAlloc;
-extern LPSTR            szEStringLoad;
-extern LPSTR            szEDllLoad;
-extern LPSTR            szEStringNull;
-extern LPSTR            szTempSetupPath;
-
-extern LPSTR            szClassName;
-extern LPSTR            szSetupDir;
-extern LPSTR            szTempDir;
-extern LPSTR            szFileIniConfig;
-
-extern DWORD            dwWizardState;
-extern DWORD            dwSetupType;
-extern DWORD            dwOSType;
-extern DWORD            dwScreenX;
-extern DWORD            dwScreenY;
-
-extern DWORD            dwTempSetupType;
-
-extern BOOL             bSDUserCanceled;
-extern BOOL             bIdiArchivesExists;
-extern BOOL             bCreateDestinationDir;
-extern BOOL             bReboot;
-
-extern setupGen         sgProduct;
-extern diS              diSetup;
-extern diW              diWelcome;
-extern diL              diLicense;
-extern diST             diSetupType;
-extern diSC             diSelectComponents;
-extern diWI             diWindowsIntegration;
-extern diPF             diProgramFolder;
-extern diSI             diStartInstall;
-extern diR              diReboot;
-extern siSD             siSDObject;
-extern siCF             siCFCoreFile;
-extern siC              *siComponents;
-
-#endif

mozilla/xpinstall/wizard/windows/setup/extra.h

@@ -1,155 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#ifndef _EXTRA_H_
-#define _EXTRA_H_
-
-typedef struct diskSpaceNode dsN;
-struct diskSpaceNode
-{
-  ULONGLONG       ullSpaceRequired;
-  LPSTR           szPath;
-  dsN             *Next;
-  dsN             *Prev;
-};
-
-typedef struct structVer
-{
-  ULONGLONG ullMajor;
-  ULONGLONG ullMinor;
-  ULONGLONG ullRelease;
-  ULONGLONG ullBuild;
-} verBlock;
-
-BOOL              InitApplication(HINSTANCE hInstance, HINSTANCE hSetupRscInst);
-BOOL              InitInstance(HINSTANCE hInstance, DWORD dwCmdShow);
-void              PrintError(LPSTR szMsg, DWORD dwErrorCodeSH);
-void              FreeMemory(void **vPointer);
-void              *NS_GlobalAlloc(DWORD dwMaxBuf);
-HRESULT           Initialize(HINSTANCE hInstance);
-HRESULT           NS_LoadStringAlloc(HANDLE hInstance, DWORD dwID, LPSTR *szStringBuf, DWORD dwStringBuf);
-HRESULT           NS_LoadString(HANDLE hInstance, DWORD dwID, LPSTR szStringBuf, DWORD dwStringBuf);
-HRESULT           WinSpawn(LPSTR szClientName, LPSTR szParameters, LPSTR szCurrentDir, int iShowCmd, BOOL bWait);
-HRESULT           ParseConfigIni(LPSTR lpszCmdLine);
-HRESULT           DecryptString(LPSTR szOutputStr, LPSTR szInputStr);
-HRESULT           DecryptVariable(LPSTR szVariable, DWORD dwVariableSize);
-void              GetWinReg(HKEY hkRootKey, LPSTR szKey, LPSTR szName, LPSTR szReturnValue, DWORD dwSize);
-void              SetWinReg(HKEY hkRootKey, LPSTR szKey, LPSTR szName, DWORD dwType, LPSTR szData, DWORD dwSize);
-HRESULT           InitSetupGeneral(void);
-HRESULT           InitDlgWelcome(diW *diDialog);
-HRESULT           InitDlgLicense(diL *diDialog);
-HRESULT           InitDlgSetupType(diST *diDialog);
-HRESULT           InitDlgSelectComponents(diSC *diDialog, DWORD dwSM);
-HRESULT           InitDlgWindowsIntegration(diWI *diDialog);
-HRESULT           InitDlgProgramFolder(diPF *diDialog);
-HRESULT           InitDlgStartInstall(diSI *diDialog);
-HRESULT           InitSDObject(void);
-void              DeInitSDObject(void);
-siC               *CreateSiCNode(void);
-void              SiCNodeInsert(siC **siCHead, siC *siCTemp);
-void              SiCNodeDelete(siC *siCTemp);
-siCD              *CreateSiCDepNode(void);
-void              SiCDepNodeDelete(siCD *siCDepTemp);
-void              SiCDepNodeInsert(siCD **siCDepHead, siCD *siCDepTemp);
-HRESULT           SiCNodeGetAttributes(DWORD dwIndex, BOOL bIncludeInvisible);
-void              SiCNodeSetAttributes(DWORD dwIndex, DWORD dwAttributes, BOOL bSet, BOOL bIncludeInvisible);
-void              SiCNodeSetItemsSelected(DWORD dwItems, DWORD *dwItemsSelected);
-char              *SiCNodeGetDescriptionLong(DWORD dwIndex, BOOL bIncludeInvisible);
-siC               *SiCNodeGetObject(DWORD dwIndex, BOOL bIncludeInvisibleObjs);
-ULONGLONG         SiCNodeGetInstallSize(DWORD dwIndex, BOOL bIncludeInvisible);
-ULONGLONG         SiCNodeGetInstallSizeSystem(DWORD dwIndex, BOOL bIncludeInvisible);
-ULONGLONG         SiCNodeGetInstallSizeArchive(DWORD dwIndex, BOOL bIncludeInvisible);
-void              InitSiComponents(char *szFileIni);
-HRESULT           ParseComponentAttributes(char *szBuf);
-void              InitSiComponents(char *szFileIni);
-void              DeInitSiCDependencies(siCD *siCDDependencies);
-BOOL              ResolveDependencies(DWORD dwIndex);
-BOOL              ResolveComponentDependency(siCD *siCDInDependency);
-void              STGetComponents(LPSTR szSection, st *stSetupType, LPSTR szFileIni);
-HRESULT           InitSCoreFile(void);
-void              DeInitSCoreFile(void);
-void              DeInitialize(void);
-void              DeInitDlgWelcome(diW *diDialog);
-void              DeInitDlgLicense(diL *diDialog);
-void              DeInitDlgSetupType(diST *diDialog);
-void              DeInitDlgSelectComponents(diSC *diDialog);
-void              DeInitDlgWindowsIntegration(diWI *diDialog);
-void              DeInitDlgProgramFolder(diPF *diDialog);
-void              DeInitDlgStartInstall(diSI *diDialog);
-void              DetermineOSVersion(void);
-void              DeInitSiComponents(void);
-void              DeInitSetupGeneral(void);
-HRESULT           InitializeSmartDownload(void);
-HRESULT           DeInitializeSmartDownload(void);
-HRESULT           ParseSetupIni(void);
-HRESULT           GetConfigIni(void);
-void              CleanTempFiles(void);
-void              OutputSetupTitle(HDC hDC);
-HRESULT           SdArchives(LPSTR szFileIdi, LPSTR szDownloadDir);
-HRESULT           RetrieveArchives(void);
-/* HRESULT           SmartUpdateJars(void); */
-void              ParsePath(LPSTR szInput, LPSTR szOutput, DWORD dwLength, DWORD dwType);
-void              RemoveBackSlash(LPSTR szInput);
-void              AppendBackSlash(LPSTR szInput, DWORD dwInputSize);
-BOOL              DeleteIdiGetConfigIni(void);
-BOOL              DeleteIdiGetArchives(void);
-BOOL              DeleteIdiFileIniConfig(void);
-void              DeleteArchives(void);
-HRESULT           LaunchApps(void);
-HRESULT           FileExists(LPSTR szFile);
-int               ExtractDirEntries(char* directory,void* vZip);
-BOOL              LocateJar(siC *siCObject);
-HRESULT           AddArchiveToIdiFile(siC *siCObject, char *szSComponent, char *szSFile, char *szFileIdiGetArchives);
-int               SiCNodeGetIndexDS(char *szInDescriptionShort);
-void              ViewSiComponents(void);
-BOOL              IsWin95Debute(void);
-ULONGLONG         GetDiskSpaceRequired(DWORD dwType);
-ULONGLONG         GetDiskSpaceAvailable(LPSTR szPath);
-HRESULT           VerifyDiskSpace(void);
-HRESULT           ErrorMsgDiskSpace(ULONGLONG ullDSAvailable, ULONGLONG ullDSRequired, LPSTR szPath, BOOL bCrutialMsg);
-void              SetCustomType(void);
-void              GetAlternateArchiveSearchPath(LPSTR lpszCmdLine);
-BOOL              NeedReboot(void);
-BOOL              LocatePreviousPath(LPSTR szMainSectionName, LPSTR szPath, DWORD dwPathSize);
-BOOL              LocatePathNscpReg(LPSTR szSection, LPSTR szPath, DWORD dwPathSize);
-BOOL              LocatePathWinReg(LPSTR szSection, LPSTR szPath, DWORD dwPathSize);
-BOOL              LocatePath(LPSTR szSection, LPSTR szPath, DWORD dwPathSize);
-int               VR_GetPath(char *component_path, unsigned long sizebuf, char *buf);
-dsN               *CreateDSNode();
-void              DsNodeInsert(dsN **dsNHead, dsN *dsNTemp);
-void              DsNodeDelete(dsN **dsNTemp);
-void              DeInitDSNode(dsN **dsnComponentDSRequirement);
-void              UpdatePathDiskSpaceRequired(LPSTR szPath, ULONGLONG ullInstallSize, dsN **dsnComponentDSRequirement);
-HRESULT           InitComponentDiskSpaceInfo(dsN **dsnComponentDSRequirement);
-HRESULT           CheckInstances();
-long              RandomSelect(void);
-void              TranslateVersionStr(LPSTR szVersion, verBlock *vbVersion);
-BOOL              GetFileVersion(LPSTR szFile, verBlock *vbVersion);
-BOOL              CheckLegacy(void);
-int               CompareVersion(verBlock vbVersionOld, verBlock vbVersionNew);
-
-BOOL              bSDInit;
-
-#endif
-

mozilla/xpinstall/wizard/windows/setup/ifuncns.c

@@ -1,779 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#include "extern.h"
-#include "extra.h"
-#include "dialogs.h"
-#include "shortcut.h"
-#include "ifuncns.h"
-
-HRESULT TimingCheck(DWORD dwTiming, LPSTR szSection, LPSTR szFile)
-{
-  char szBuf[MAX_BUF];
-
-  GetPrivateProfileString(szSection, "Timing", "", szBuf, MAX_BUF, szFile);
-  if(*szBuf != '\0')
-  {
-    switch(dwTiming)
-    {
-      case T_PRE_DOWNLOAD:
-        if(lstrcmpi(szBuf, "pre download") == 0)
-          return(TRUE);
-        break;
-
-      case T_POST_DOWNLOAD:
-        if(lstrcmpi(szBuf, "post download") == 0)
-          return(TRUE);
-        break;
-
-      case T_PRE_CORE:
-        if(lstrcmpi(szBuf, "pre core") == 0)
-          return(TRUE);
-        break;
-
-      case T_POST_CORE:
-        if(lstrcmpi(szBuf, "post core") == 0)
-          return(TRUE);
-        break;
-
-      case T_PRE_SMARTUPDATE:
-        if(lstrcmpi(szBuf, "pre smartupdate") == 0)
-          return(TRUE);
-        break;
-
-      case T_POST_SMARTUPDATE:
-        if(lstrcmpi(szBuf, "post smartupdate") == 0)
-          return(TRUE);
-        break;
-
-      case T_PRE_LAUNCHAPP:
-        if(lstrcmpi(szBuf, "pre launchapp") == 0)
-          return(TRUE);
-        break;
-
-      case T_POST_LAUNCHAPP:
-        if(lstrcmpi(szBuf, "post launchapp") == 0)
-          return(TRUE);
-        break;
-
-      case T_DEPEND_REBOOT:
-        if(lstrcmpi(szBuf, "depend reboot") == 0)
-          return(TRUE);
-        break;
-    }
-  }
-  return(FALSE);
-}
-
-void ProcessFileOps(DWORD dwTiming)
-{
-  ProcessUncompressFile(dwTiming);
-  ProcessCreateDirectory(dwTiming);
-  ProcessMoveFile(dwTiming);
-  ProcessCopyFile(dwTiming);
-  ProcessDeleteFile(dwTiming);
-  ProcessRemoveDirectory(dwTiming);
-  ProcessRunApp(dwTiming);
-  ProcessProgramFolder(dwTiming);
-}
-
-HRESULT FileUncompress(LPSTR szFrom, LPSTR szTo)
-{
-  char  szBuf[MAX_BUF];
-  DWORD dwReturn;
-  void  *vZip;
-
-  /* Check for the existance of the from (source) file */
-  if(!FileExists(szFrom))
-    return(FO_ERROR_FILE_NOT_FOUND);
-
-  /* Check for the existance of the to (destination) path */
-  dwReturn = FileExists(szTo);
-  if(dwReturn && !(dwReturn & FILE_ATTRIBUTE_DIRECTORY))
-  {
-    /* found a file with the same name as the destination path */
-    return(FO_ERROR_DESTINATION_CONFLICT);
-  }
-  else if(!dwReturn)
-  {
-    lstrcpy(szBuf, szTo);
-    AppendBackSlash(szBuf, sizeof(szBuf));
-    CreateDirectoriesAll(szBuf);
-  }
-
-  GetCurrentDirectory(MAX_BUF, szBuf);
-  if(SetCurrentDirectory(szTo) == FALSE)
-    return(FO_ERROR_CHANGE_DIR);
-
-  ZIP_OpenArchive(szFrom, &vZip);
-  /* 1st parameter should be NULL or it will fail */
-  /* It indicates extract the entire archive */
-  ExtractDirEntries(NULL, vZip);
-  ZIP_CloseArchive(&vZip);
-
-  if(SetCurrentDirectory(szBuf) == FALSE)
-    return(FO_ERROR_CHANGE_DIR);
-
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessCoreFile()
-{
-  if(*siCFCoreFile.szMessage != '\0')
-    ShowMessage(siCFCoreFile.szMessage, TRUE);
-
-  FileUncompress(siCFCoreFile.szSource, siCFCoreFile.szDestination);
-
-  if(*siCFCoreFile.szMessage != '\0')
-    ShowMessage(siCFCoreFile.szMessage, FALSE);
-
-  return(FO_SUCCESS);
-}
-
-HRESULT CleanupCoreFile()
-{
-  if(siCFCoreFile.bCleanup == TRUE)
-    DirectoryRemove(siCFCoreFile.szDestination, TRUE);
-
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessUncompressFile(DWORD dwTiming)
-{
-  DWORD   dwIndex;
-  BOOL    bOnlyIfExists;
-  char    szIndex[MAX_BUF];
-  char    szBuf[MAX_BUF];
-  char    szSection[MAX_BUF];
-  char    szSource[MAX_BUF];
-  char    szDestination[MAX_BUF];
-
-  dwIndex = 0;
-  itoa(dwIndex, szIndex, 10);
-  lstrcpy(szSection, "Uncompress File");
-  lstrcat(szSection, szIndex);
-  GetPrivateProfileString(szSection, "Source", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    if(TimingCheck(dwTiming, szSection, szFileIniConfig))
-    {
-      DecryptString(szSource, szBuf);
-      GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-      DecryptString(szDestination, szBuf);
-      GetPrivateProfileString(szSection, "Only If Exists", "", szBuf, MAX_BUF, szFileIniConfig);
-      if(lstrcmpi(szBuf, "TRUE") == 0)
-        bOnlyIfExists = TRUE;
-      else
-        bOnlyIfExists = FALSE;
-
-      if((!bOnlyIfExists) || (bOnlyIfExists && FileExists(szDestination)))
-      {
-        GetPrivateProfileString(szSection, "Message",     "", szBuf, MAX_BUF, szFileIniConfig);
-        ShowMessage(szBuf, TRUE);
-        FileUncompress(szSource, szDestination);
-        ShowMessage(szBuf, FALSE);
-      }
-    }
-
-    ++dwIndex;
-    itoa(dwIndex, szIndex, 10);
-    lstrcpy(szSection, "Uncompress File");
-    lstrcat(szSection, szIndex);
-    GetPrivateProfileString(szSection, "Source", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}
-
-HRESULT FileMove(LPSTR szFrom, LPSTR szTo)
-{
-  HANDLE          hFile;
-  WIN32_FIND_DATA fdFile;
-  char            szFromDir[MAX_BUF];
-  char            szFromTemp[MAX_BUF];
-  char            szToTemp[MAX_BUF];
-  char            szBuf[MAX_BUF];
-  BOOL            bFound;
-
-  /* From file path exists and To file path does not exist */
-  if((FileExists(szFrom)) && (!FileExists(szTo)))
-  {
-    MoveFile(szFrom, szTo);
-    return(FO_SUCCESS);
-  }
-  /* From file path exists and To file path exists */
-  if(FileExists(szFrom) && FileExists(szTo))
-  {
-    /* Since the To file path exists, assume it to be a directory and proceed.      */
-    /* We don't care if it's a file.  If it is a file, then config.ini needs to be  */
-    /* corrected to remove the file before attempting a MoveFile().                 */
-    lstrcpy(szToTemp, szTo);
-    AppendBackSlash(szToTemp, sizeof(szToTemp));
-    ParsePath(szFrom, szBuf, MAX_BUF, PP_FILENAME_ONLY);
-    lstrcat(szToTemp, szBuf);
-    MoveFile(szFrom, szToTemp);
-    return(FO_SUCCESS);
-  }
-
-  ParsePath(szFrom, szFromDir, MAX_BUF, PP_PATH_ONLY);
-
-  if((hFile = FindFirstFile(szFrom, &fdFile)) == INVALID_HANDLE_VALUE)
-    bFound = FALSE;
-  else
-    bFound = TRUE;
-
-  while(bFound)
-  {
-    if((lstrcmpi(fdFile.cFileName, ".") != 0) && (lstrcmpi(fdFile.cFileName, "..") != 0))
-    {
-      /* create full path string including filename for source */
-      lstrcpy(szFromTemp, szFromDir);
-      AppendBackSlash(szFromTemp, sizeof(szFromTemp));
-      lstrcat(szFromTemp, fdFile.cFileName);
-
-      /* create full path string including filename for destination */
-      lstrcpy(szToTemp, szTo);
-      AppendBackSlash(szToTemp, sizeof(szToTemp));
-      lstrcat(szToTemp, fdFile.cFileName);
-
-      MoveFile(szFromTemp, szToTemp);
-    }
-
-    bFound = FindNextFile(hFile, &fdFile);
-  }
-
-  FindClose(hFile);
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessMoveFile(DWORD dwTiming)
-{
-  DWORD dwIndex;
-  char  szIndex[MAX_BUF];
-  char  szBuf[MAX_BUF];
-  char  szSection[MAX_BUF];
-  char  szSource[MAX_BUF];
-  char  szDestination[MAX_BUF];
-
-  dwIndex = 0;
-  itoa(dwIndex, szIndex, 10);
-  lstrcpy(szSection, "Move File");
-  lstrcat(szSection, szIndex);
-  GetPrivateProfileString(szSection, "Source", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    if(TimingCheck(dwTiming, szSection, szFileIniConfig))
-    {
-      DecryptString(szSource, szBuf);
-      GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-      DecryptString(szDestination, szBuf);
-      FileMove(szSource, szDestination);
-    }
-
-    ++dwIndex;
-    itoa(dwIndex, szIndex, 10);
-    lstrcpy(szSection, "Move File");
-    lstrcat(szSection, szIndex);
-    GetPrivateProfileString(szSection, "Source", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}
-
-HRESULT FileCopy(LPSTR szFrom, LPSTR szTo, BOOL bFailIfExists)
-{
-  HANDLE          hFile;
-  WIN32_FIND_DATA fdFile;
-  char            szFromDir[MAX_BUF];
-  char            szFromTemp[MAX_BUF];
-  char            szToTemp[MAX_BUF];
-  char            szBuf[MAX_BUF];
-  BOOL            bFound;
-
-  if(FileExists(szFrom))
-  {
-    /* The file in the From file path exists */
-    ParsePath(szFrom, szBuf, MAX_BUF, PP_FILENAME_ONLY);
-    lstrcpy(szToTemp, szTo);
-    AppendBackSlash(szToTemp, sizeof(szToTemp));
-    lstrcat(szToTemp, szBuf);
-    CopyFile(szFrom, szToTemp, bFailIfExists);
-    return(FO_SUCCESS);
-  }
-
-  /* The file in the From file path does not exist.  Assume to contain wild args and */
-  /* proceed acordingly.                                                             */
-  ParsePath(szFrom, szFromDir, MAX_BUF, PP_PATH_ONLY);
-
-  if((hFile = FindFirstFile(szFrom, &fdFile)) == INVALID_HANDLE_VALUE)
-    bFound = FALSE;
-  else
-    bFound = TRUE;
-
-  while(bFound)
-  {
-    if((lstrcmpi(fdFile.cFileName, ".") != 0) && (lstrcmpi(fdFile.cFileName, "..") != 0))
-    {
-      /* create full path string including filename for source */
-      lstrcpy(szFromTemp, szFromDir);
-      AppendBackSlash(szFromTemp, sizeof(szFromTemp));
-      lstrcat(szFromTemp, fdFile.cFileName);
-
-      /* create full path string including filename for destination */
-      lstrcpy(szToTemp, szTo);
-      AppendBackSlash(szToTemp, sizeof(szToTemp));
-      lstrcat(szToTemp, fdFile.cFileName);
-
-      CopyFile(szFromTemp, szToTemp, bFailIfExists);
-    }
-
-    bFound = FindNextFile(hFile, &fdFile);
-  }
-
-  FindClose(hFile);
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessCopyFile(DWORD dwTiming)
-{
-  DWORD dwIndex;
-  char  szIndex[MAX_BUF];
-  char  szBuf[MAX_BUF];
-  char  szSection[MAX_BUF];
-  char  szSource[MAX_BUF];
-  char  szDestination[MAX_BUF];
-  BOOL  bFailIfExists;
-
-  dwIndex = 0;
-  itoa(dwIndex, szIndex, 10);
-  lstrcpy(szSection, "Copy File");
-  lstrcat(szSection, szIndex);
-  GetPrivateProfileString(szSection, "Source", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    if(TimingCheck(dwTiming, szSection, szFileIniConfig))
-    {
-      DecryptString(szSource, szBuf);
-      GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-      DecryptString(szDestination, szBuf);
-
-      GetPrivateProfileString(szSection, "Fail If Exists", "", szBuf, MAX_BUF, szFileIniConfig);
-      if(lstrcmpi(szBuf, "TRUE") == 0)
-        bFailIfExists = TRUE;
-      else
-        bFailIfExists = FALSE;
-
-      FileCopy(szSource, szDestination, bFailIfExists);
-    }
-
-    ++dwIndex;
-    itoa(dwIndex, szIndex, 10);
-    lstrcpy(szSection, "Copy File");
-    lstrcat(szSection, szIndex);
-    GetPrivateProfileString(szSection, "Source", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}
-
-HRESULT CreateDirectoriesAll(char* szPath)
-{
-  int     i;
-  int     iLen = lstrlen(szPath);
-  char    szCreatePath[MAX_BUF];
-  HRESULT hrResult;
-
-  ZeroMemory(szCreatePath, MAX_BUF);
-  memcpy(szCreatePath, szPath, iLen);
-  for(i = 0; i < iLen; i++)
-  {
-    if((iLen > 1) &&
-      ((i != 0) && ((szPath[i] == '\\') || (szPath[i] == '/'))) &&
-      (!((szPath[0] == '\\') && (i == 1)) && !((szPath[1] == ':') && (i == 2))))
-    {
-      szCreatePath[i] = '\0';
-      hrResult        = CreateDirectory(szCreatePath, NULL);
-      szCreatePath[i] = szPath[i];
-    }
-  }
-  return(hrResult);
-}
-
-HRESULT ProcessCreateDirectory(DWORD dwTiming)
-{
-  DWORD dwIndex;
-  char  szIndex[MAX_BUF];
-  char  szBuf[MAX_BUF];
-  char  szSection[MAX_BUF];
-  char  szDestination[MAX_BUF];
-
-  dwIndex = 0;
-  itoa(dwIndex, szIndex, 10);
-  lstrcpy(szSection, "Create Directory");
-  lstrcat(szSection, szIndex);
-  GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    if(TimingCheck(dwTiming, szSection, szFileIniConfig))
-    {
-      DecryptString(szDestination, szBuf);
-      AppendBackSlash(szDestination, sizeof(szDestination));
-      CreateDirectoriesAll(szDestination);
-    }
-
-    ++dwIndex;
-    itoa(dwIndex, szIndex, 10);
-    lstrcpy(szSection, "Create Directory");
-    lstrcat(szSection, szIndex);
-    GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}
-
-HRESULT FileDelete(LPSTR szDestination)
-{
-  HANDLE          hFile;
-  WIN32_FIND_DATA fdFile;
-  char            szBuf[MAX_BUF];
-  char            szPathOnly[MAX_BUF];
-  BOOL            bFound;
-
-  if(FileExists(szDestination))
-  {
-    /* The file in the From file path exists */
-    DeleteFile(szDestination);
-    return(FO_SUCCESS);
-  }
-
-  /* The file in the From file path does not exist.  Assume to contain wild args and */
-  /* proceed acordingly.                                                             */
-  ParsePath(szDestination, szPathOnly, MAX_BUF, PP_PATH_ONLY);
-
-  if((hFile = FindFirstFile(szDestination, &fdFile)) == INVALID_HANDLE_VALUE)
-    bFound = FALSE;
-  else
-    bFound = TRUE;
-
-  while(bFound)
-  {
-    if(!(fdFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
-    {
-      lstrcpy(szBuf, szPathOnly);
-      AppendBackSlash(szBuf, sizeof(szBuf));
-      lstrcat(szBuf, fdFile.cFileName);
-
-      DeleteFile(szBuf);
-    }
-
-    bFound = FindNextFile(hFile, &fdFile);
-  }
-
-  FindClose(hFile);
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessDeleteFile(DWORD dwTiming)
-{
-  DWORD dwIndex;
-  char  szIndex[MAX_BUF];
-  char  szBuf[MAX_BUF];
-  char  szSection[MAX_BUF];
-  char  szDestination[MAX_BUF];
-
-  dwIndex = 0;
-  itoa(dwIndex, szIndex, 10);
-  lstrcpy(szSection, "Delete File");
-  lstrcat(szSection, szIndex);
-  GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    if(TimingCheck(dwTiming, szSection, szFileIniConfig))
-    {
-      DecryptString(szDestination, szBuf);
-      FileDelete(szDestination);
-    }
-
-    ++dwIndex;
-    itoa(dwIndex, szIndex, 10);
-    lstrcpy(szSection, "Delete File");
-    lstrcat(szSection, szIndex);
-    GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}
-
-HRESULT DirectoryRemove(LPSTR szDestination, BOOL bRemoveSubdirs)
-{
-  HANDLE          hFile;
-  WIN32_FIND_DATA fdFile;
-  char            szDestTemp[MAX_BUF];
-  BOOL            bFound;
-
-  if(!FileExists(szDestination))
-    return(FO_SUCCESS);
-
-  if(bRemoveSubdirs == TRUE)
-  {
-    lstrcpy(szDestTemp, szDestination);
-    AppendBackSlash(szDestTemp, sizeof(szDestTemp));
-    lstrcat(szDestTemp, "*");
-
-    bFound = TRUE;
-    hFile = FindFirstFile(szDestTemp, &fdFile);
-    while((hFile != INVALID_HANDLE_VALUE) && (bFound == TRUE))
-    {
-      if((lstrcmpi(fdFile.cFileName, ".") != 0) && (lstrcmpi(fdFile.cFileName, "..") != 0))
-      {
-        /* create full path */
-        lstrcpy(szDestTemp, szDestination);
-        AppendBackSlash(szDestTemp, sizeof(szDestTemp));
-        lstrcat(szDestTemp, fdFile.cFileName);
-
-        if(fdFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-        {
-          DirectoryRemove(szDestTemp, bRemoveSubdirs);
-        }
-        else
-        {
-          DeleteFile(szDestTemp);
-        }
-      }
-
-      bFound = FindNextFile(hFile, &fdFile);
-    }
-
-    FindClose(hFile);
-  }
-  
-  RemoveDirectory(szDestination);
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessRemoveDirectory(DWORD dwTiming)
-{
-  DWORD dwIndex;
-  char  szIndex[MAX_BUF];
-  char  szBuf[MAX_BUF];
-  char  szSection[MAX_BUF];
-  char  szDestination[MAX_BUF];
-  BOOL  bRemoveSubdirs;
-
-  dwIndex = 0;
-  itoa(dwIndex, szIndex, 10);
-  lstrcpy(szSection, "Remove Directory");
-  lstrcat(szSection, szIndex);
-  GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    if(TimingCheck(dwTiming, szSection, szFileIniConfig))
-    {
-      DecryptString(szDestination, szBuf);
-      GetPrivateProfileString(szSection, "Remove subdirs", "", szBuf, MAX_BUF, szFileIniConfig);
-      bRemoveSubdirs = FALSE;
-      if(lstrcmpi(szBuf, "TRUE") == 0)
-        bRemoveSubdirs = TRUE;
-
-      DirectoryRemove(szDestination, bRemoveSubdirs);
-    }
-
-    ++dwIndex;
-    itoa(dwIndex, szIndex, 10);
-    lstrcpy(szSection, "Remove Directory");
-    lstrcat(szSection, szIndex);
-    GetPrivateProfileString(szSection, "Destination", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessRunApp(DWORD dwTiming)
-{
-  DWORD dwIndex;
-  char  szIndex[MAX_BUF];
-  char  szBuf[MAX_BUF];
-  char  szSection[MAX_BUF];
-  char  szTarget[MAX_BUF];
-  char  szParameters[MAX_BUF];
-  char  szWorkingDir[MAX_BUF];
-  BOOL  bWait;
-
-  dwIndex = 0;
-  itoa(dwIndex, szIndex, 10);
-  lstrcpy(szSection, "RunApp");
-  lstrcat(szSection, szIndex);
-  GetPrivateProfileString(szSection, "Target", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    if(TimingCheck(dwTiming, szSection, szFileIniConfig))
-    {
-      DecryptString(szTarget, szBuf);
-      GetPrivateProfileString(szSection, "Parameters", "", szBuf, MAX_BUF, szFileIniConfig);
-      DecryptString(szParameters, szBuf);
-      GetPrivateProfileString(szSection, "WorkingDir", "", szBuf, MAX_BUF, szFileIniConfig);
-      DecryptString(szWorkingDir, szBuf);
-      GetPrivateProfileString(szSection, "Wait", "", szBuf, MAX_BUF, szFileIniConfig);
-
-      if(lstrcmpi(szBuf, "FALSE") == 0)
-        bWait = FALSE;
-      else
-        bWait = TRUE;
-
-      if((dwTiming == T_DEPEND_REBOOT) && (NeedReboot() == TRUE))
-      {
-        lstrcat(szTarget, " ");
-        lstrcat(szTarget, szParameters);
-        SetWinReg(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce", "Netscape", REG_SZ, szTarget, lstrlen(szTarget));
-      }
-      else
-        WinSpawn(szTarget, szParameters, szWorkingDir, SW_SHOWNORMAL, bWait);
-    }
-
-    ++dwIndex;
-    itoa(dwIndex, szIndex, 10);
-    lstrcpy(szSection, "RunApp");
-    lstrcat(szSection, szIndex);
-    GetPrivateProfileString(szSection, "Target", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessProgramFolder(DWORD dwTiming)
-{
-  DWORD dwIndex0;
-  DWORD dwIndex1;
-  DWORD dwIconId;
-  char  szIndex0[MAX_BUF];
-  char  szIndex1[MAX_BUF];
-  char  szBuf[MAX_BUF];
-  char  szSection0[MAX_BUF];
-  char  szSection1[MAX_BUF];
-  char  szProgramFolder[MAX_BUF];
-  char  szFile[MAX_BUF];
-  char  szArguments[MAX_BUF];
-  char  szWorkingDir[MAX_BUF];
-  char  szDescription[MAX_BUF];
-  char  szIconPath[MAX_BUF];
-
-  dwIndex0 = 0;
-  itoa(dwIndex0, szIndex0, 10);
-  lstrcpy(szSection0, "Program Folder");
-  lstrcat(szSection0, szIndex0);
-  GetPrivateProfileString(szSection0, "Program Folder", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    if(TimingCheck(dwTiming, szSection0, szFileIniConfig))
-    {
-      DecryptString(szProgramFolder, szBuf);
-
-      dwIndex1 = 0;
-      itoa(dwIndex1, szIndex1, 10);
-      lstrcpy(szSection1, szSection0);
-      lstrcat(szSection1, "-Shortcut");
-      lstrcat(szSection1, szIndex1);
-      GetPrivateProfileString(szSection1, "File", "", szBuf, MAX_BUF, szFileIniConfig);
-      while(*szBuf != '\0')
-      {
-        DecryptString(szFile, szBuf);
-        GetPrivateProfileString(szSection1, "Arguments",    "", szBuf, MAX_BUF, szFileIniConfig);
-        DecryptString(szArguments, szBuf);
-        GetPrivateProfileString(szSection1, "Working Dir",  "", szBuf, MAX_BUF, szFileIniConfig);
-        DecryptString(szWorkingDir, szBuf);
-        GetPrivateProfileString(szSection1, "Description",  "", szBuf, MAX_BUF, szFileIniConfig);
-        DecryptString(szDescription, szBuf);
-        GetPrivateProfileString(szSection1, "Icon Path",    "", szBuf, MAX_BUF, szFileIniConfig);
-        DecryptString(szIconPath, szBuf);
-        GetPrivateProfileString(szSection1, "Icon Id",      "", szBuf, MAX_BUF, szFileIniConfig);
-        if(*szBuf != '\0')
-          dwIconId = atol(szBuf);
-        else
-          dwIconId = 0;
-
-        CreateALink(szFile, szProgramFolder, szDescription, szWorkingDir, szArguments, szIconPath, dwIconId);
-
-        ++dwIndex1;
-        itoa(dwIndex1, szIndex1, 10);
-        lstrcpy(szSection1, szSection0);
-        lstrcat(szSection1, "-Shortcut");
-        lstrcat(szSection1, szIndex1);
-        GetPrivateProfileString(szSection1, "File", "", szBuf, MAX_BUF, szFileIniConfig);
-      }
-    }
-
-    ++dwIndex0;
-    itoa(dwIndex0, szIndex0, 10);
-    lstrcpy(szSection0, "Program Folder");
-    lstrcat(szSection0, szIndex0);
-    GetPrivateProfileString(szSection0, "Program Folder", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}
-
-HRESULT ProcessProgramFolderShowCmd()
-{
-  DWORD dwIndex0;
-  int   iShowFolder;
-  char  szIndex0[MAX_BUF];
-  char  szBuf[MAX_BUF];
-  char  szSection0[MAX_BUF];
-  char  szProgramFolder[MAX_BUF];
-
-  dwIndex0 = 0;
-  itoa(dwIndex0, szIndex0, 10);
-  lstrcpy(szSection0, "Program Folder");
-  lstrcat(szSection0, szIndex0);
-  GetPrivateProfileString(szSection0, "Program Folder", "", szBuf, MAX_BUF, szFileIniConfig);
-  while(*szBuf != '\0')
-  {
-    DecryptString(szProgramFolder, szBuf);
-    GetPrivateProfileString(szSection0, "Show Folder", "", szBuf, MAX_BUF, szFileIniConfig);
-
-    if(strcmpi(szBuf, "HIDE") == 0)
-      iShowFolder = SW_HIDE;
-    else if(strcmpi(szBuf, "MAXIMIZE") == 0)
-      iShowFolder = SW_MAXIMIZE;
-    else if(strcmpi(szBuf, "MINIMIZE") == 0)
-      iShowFolder = SW_MINIMIZE;
-    else if(strcmpi(szBuf, "RESTORE") == 0)
-      iShowFolder = SW_RESTORE;
-    else if(strcmpi(szBuf, "SHOW") == 0)
-      iShowFolder = SW_SHOW;
-    else if(strcmpi(szBuf, "SHOWMAXIMIZED") == 0)
-      iShowFolder = SW_SHOWMAXIMIZED;
-    else if(strcmpi(szBuf, "SHOWMINIMIZED") == 0)
-      iShowFolder = SW_SHOWMINIMIZED;
-    else if(strcmpi(szBuf, "SHOWMINNOACTIVE") == 0)
-      iShowFolder = SW_SHOWMINNOACTIVE;
-    else if(strcmpi(szBuf, "SHOWNA") == 0)
-      iShowFolder = SW_SHOWNA;
-    else if(strcmpi(szBuf, "SHOWNOACTIVATE") == 0)
-      iShowFolder = SW_SHOWNOACTIVATE;
-    else if(strcmpi(szBuf, "SHOWNORMAL") == 0)
-      iShowFolder = SW_SHOWNORMAL;
-
-    WinSpawn(szProgramFolder, NULL, NULL, iShowFolder, TRUE);
-
-    ++dwIndex0;
-    itoa(dwIndex0, szIndex0, 10);
-    lstrcpy(szSection0, "Program Folder");
-    lstrcat(szSection0, szIndex0);
-    GetPrivateProfileString(szSection0, "Program Folder", "", szBuf, MAX_BUF, szFileIniConfig);
-  }
-  return(FO_SUCCESS);
-}

mozilla/xpinstall/wizard/windows/setup/ifuncns.h

@@ -1,55 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#ifndef _IFUNCNS_H_
-#define _IFUNCNS_H_
-
-HRESULT     TimingCheck(DWORD dwTiming, LPSTR szSection, LPSTR szFile);
-HRESULT     FileUncompress(LPSTR szFrom, LPSTR szTo);
-HRESULT     ProcessCoreFile(void);
-HRESULT     CleanupCoreFile(void);
-HRESULT     ProcessUncompressFile(DWORD dwTiming);
-HRESULT     FileMove(LPSTR szFrom, LPSTR szTo);
-HRESULT     ProcessMoveFile(DWORD dwTiming);
-HRESULT     FileCopy(LPSTR szFrom, LPSTR szTo, BOOL bFailIfExists);
-HRESULT     ProcessCopyFile(DWORD dwTiming);
-HRESULT     ProcessCreateDirectory(DWORD dwTiming);
-HRESULT     FileDelete(LPSTR szDestination);
-HRESULT     ProcessDeleteFile(DWORD dwTiming);
-HRESULT     DirectoryRemove(LPSTR szDestination, BOOL bRemoveSubdirs);
-HRESULT     ProcessRemoveDirectory(DWORD dwTiming);
-HRESULT     ProcessRunApp(DWORD dwTiming);
-HRESULT     CreateALink(LPSTR lpszPathObj,
-                        LPSTR lpszPathLink,
-                        LPSTR lpszDesc,
-                        LPSTR lpszWorkingPath,
-                        LPSTR lpszArgs,
-                        LPSTR lpszIconFullPath,
-                        int iIcon);
-HRESULT     ProcessProgramFolder(DWORD dwTiming);
-HRESULT     ProcessProgramFolderShowCmd(void);
-HRESULT     CreateDirectoriesAll(char* szPath);
-void        ProcessFileOps(DWORD dwTiming);
-
-#endif

mozilla/xpinstall/wizard/windows/setup/makefile.win

@@ -1,61 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, 
-# released March 31, 1998. 
-#
-# The Initial Developer of the Original Code is Netscape Communications 
-# Corporation.  Portions created by Netscape are
-# Copyright (C) 1999 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#     Sean Su <ssu@netscape.com>
-
-DEPTH=..\..\..\..
-
-MAKE_OBJ_TYPE   = EXE
-USE_NON_MT_LIBS = 1
-
-MODULE          = setup
-PROGRAM         = .\$(OBJDIR)\$(MODULE).exe
-RESFILE         = $(MODULE).res
-
-OBJS =                          \
-    .\$(OBJDIR)\dialogs.obj     \
-    .\$(OBJDIR)\extra.obj       \
-    .\$(OBJDIR)\ifuncns.obj     \
-    .\$(OBJDIR)\setup.obj       \
-    .\$(OBJDIR)\shortcut.obj    \
-    .\$(OBJDIR)\xpi.obj         \
-    $(NULL)
-
-LLIBS=                          \
-    $(DIST)\lib\nsreg_s.lib     \
-    $(DIST)\lib\jar_s.lib       \
-    $(DIST)\lib\zlib_s.lib      \
-    $(NULL)
-
-WIN_LIBS=                       \
-    ole32.lib                   \
-    comdlg32.lib                \
-    shell32.lib                 \
-    version.lib                 \
-    $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-install:: $(PROGRAM)
-    $(MAKE_INSTALL) $(PROGRAM) $(DIST)\install
-
-clobber_all::
-    $(RM) $(DIST)\install\$(MODULE).exe
-

mozilla/xpinstall/wizard/windows/setup/resource.h

@@ -1,47 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-//{{NO_DEPENDENCIES}}
-// Microsoft Developer Studio generated include file.
-// Used by setup.rc
-//
-
-#include "winresrc.h"
-
-#define IDS_ERROR_DLL_LOAD              1
-#define IDS_ERROR_STRING_LOAD           2
-#define IDS_ERROR_STRING_NULL           4
-#define IDS_ERROR_GLOBALALLOC           5
-
-// Next default values for new objects
-// 
-#ifdef APSTUDIO_INVOKED
-#ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NO_MFC                     1
-#define _APS_NEXT_RESOURCE_VALUE        103
-#define _APS_NEXT_COMMAND_VALUE         40001
-#define _APS_NEXT_CONTROL_VALUE         1000
-#define _APS_NEXT_SYMED_VALUE           101
-#endif
-#endif

mozilla/xpinstall/wizard/windows/setup/setup.c

@@ -1,151 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#include "setup.h"
-#include "extra.h"
-#include "dialogs.h"
-#include "ifuncns.h"
-
-/* global variables */
-HINSTANCE       hInst;
-HINSTANCE       hSetupRscInst;
-HINSTANCE       hSDInst;
-HINSTANCE       hXPIStubInst;
-
-HBITMAP         hbmpBoxChecked;
-HBITMAP         hbmpBoxUnChecked;
-
-HANDLE          hAccelTable;
-
-HWND            hDlg;
-HWND            hDlgMessage;
-HWND            hWndMain;
-
-SDI_NETINSTALL  pfnNetInstall;
-
-LPSTR           szEGlobalAlloc;
-LPSTR           szEStringLoad;
-LPSTR           szEDllLoad;
-LPSTR           szEStringNull;
-LPSTR           szTempSetupPath;
-
-LPSTR           szClassName;
-LPSTR           szSetupDir;
-LPSTR           szTempDir;
-LPSTR           szFileIniConfig;
-
-DWORD           dwWizardState;
-DWORD           dwSetupType;
-DWORD           dwOSType;
-DWORD           dwScreenX;
-DWORD           dwScreenY;
-
-DWORD           dwTempSetupType;
-
-BOOL            bSDUserCanceled;
-BOOL            bIdiArchivesExists;
-BOOL            bCreateDestinationDir;
-BOOL            bReboot;
-
-setupGen        sgProduct;
-diS             diSetup;
-diW             diWelcome;
-diL             diLicense;
-diST            diSetupType;
-diSC            diSelectComponents;
-diWI            diWindowsIntegration;
-diPF            diProgramFolder;
-diSI            diStartInstall;
-diR             diReboot;
-siSD            siSDObject;
-siCF            siCFCoreFile;
-siC             *siComponents;
-
-int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)
-{
-  /***********************************************************************/
-  /* HANDLE hInstance;       handle for this instance                    */
-  /* HANDLE hPrevInstance;   handle for possible previous instances      */
-  /* LPSTR  lpszCmdLine;     long pointer to exec command line           */
-  /* int    nCmdShow;        Show code for main window display           */
-  /***********************************************************************/
-
-  MSG   msg;
-  char  szBuf[MAX_BUF];
-
-  if(!hPrevInstance)
-  {
-    if(Initialize(hInstance))
-      PostQuitMessage(1);
-    else if(!InitApplication(hInstance, hSetupRscInst))
-    {
-      char szEFailed[MAX_BUF];
-
-      if(NS_LoadString(hInstance, IDS_ERROR_FAILED, szEFailed, MAX_BUF) == WIZ_OK)
-      {
-        wsprintf(szBuf, szEFailed, "InitApplication().");
-        PrintError(szBuf, ERROR_CODE_SHOW);
-      }
-      PostQuitMessage(1);
-    }
-    else if(!InitInstance(hInstance, nCmdShow))
-    {
-      char szEFailed[MAX_BUF];
-
-      if(NS_LoadString(hInstance, IDS_ERROR_FAILED, szEFailed, MAX_BUF) == WIZ_OK)
-      {
-        wsprintf(szBuf, szEFailed, "InitInstance().");
-        PrintError(szBuf, ERROR_CODE_SHOW);
-      }
-      PostQuitMessage(1);
-    }
-    else if(GetConfigIni())
-    {
-      PostQuitMessage(1);
-    }
-    else if(ParseConfigIni(lpszCmdLine))
-    {
-      PostQuitMessage(1);
-    }
-    else
-    {
-      DlgSequenceNext();
-    }
-  }
-
-  while(GetMessage(&msg, NULL, 0, 0))
-  {
-    if((!IsDialogMessage(hDlg, &msg)) && (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)))
-    {
-      TranslateMessage(&msg);
-      DispatchMessage(&msg);
-    }
-  }
-
-  /* Do clean up before exiting from the application */
-  DeInitialize();
-
-  return(msg.wParam);
-} /*  End of WinMain */
-

mozilla/xpinstall/wizard/windows/setup/setup.h

@@ -1,296 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#ifndef _SETUP_H_
-#define _SETUP_H_
-
-#ifdef __cplusplus
-#define PR_BEGIN_EXTERN_C       extern "C" {
-#define PR_END_EXTERN_C         }
-#else
-#define PR_BEGIN_EXTERN_C
-#define PR_END_EXTERN_C
-#endif
-
-#define PR_EXTERN(type) type
-
-typedef unsigned int PRUint32;
-typedef int PRInt32;
-
-#include <windows.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-#include <direct.h>
-#include <tchar.h>
-#include <commctrl.h>
-#include "setuprsc.h"
-#include "resource.h"
-#include "zipfile.h"
-
-/* required only by commercial seamonkey build */
-#ifndef MOZILLA_CLIENT
-#include "sdinst.h"
-#endif
-
-#define CLASS_NAME                      "Setup"
-#define FILE_INI_SETUP                  "setup.ini"
-#define FILE_INI_CONFIG                 "config.ini"
-#define FILE_IDI_GETCONFIGINI           "getconfigini.idi"
-#define FILE_IDI_GETARCHIVES            "getarchives.idi"
-
-/* PP: Parse Path */
-#define PP_FILENAME_ONLY                1
-#define PP_PATH_ONLY                    2
-#define PP_ROOT_ONLY                    3
-
-/* T: Timing */
-#define T_PRE_DOWNLOAD                  1
-#define T_POST_DOWNLOAD                 2
-#define T_PRE_CORE                      3
-#define T_POST_CORE                     4
-#define T_PRE_SMARTUPDATE               5
-#define T_POST_SMARTUPDATE              6
-#define T_PRE_LAUNCHAPP                 7
-#define T_POST_LAUNCHAPP                8
-#define T_DEPEND_REBOOT                 9
-
-#define MAX_BUF                         4096
-#define ERROR_CODE_HIDE                 0
-#define ERROR_CODE_SHOW                 1
-#define DLG_NONE                        0
-#define CX_CHECKBOX                     13
-#define CY_CHECKBOX                     13
-
-/* WIZ: WIZARD defines */
-#define WIZ_OK                          0
-#define WIZ_MEMORY_ALLOC_FAILED         1
-
-/* FO: File Operation */
-#define FO_OK                           0
-#define FO_SUCCESS                      0
-#define FO_ERROR_FILE_NOT_FOUND         1
-#define FO_ERROR_DESTINATION_CONFLICT   2
-#define FO_ERROR_CHANGE_DIR             3
-
-#define NORMAL                          0
-#define SILENT                          1
-#define AUTO                            2
-
-/* ST: Setup Type */
-#define ST_RADIO0                       0
-#define ST_RADIO1                       1
-#define ST_RADIO2                       2
-#define ST_RADIO3                       3
-
-/* SM: Setup Type Mode */
-#define SM_SINGLE                       0
-#define SM_MULTI                        1
-
-/* SIC: Setup Info Component*/
-#define SIC_SELECTED                    1
-#define SIC_INVISIBLE                   2
-#define SIC_LAUNCHAPP                   4
-#define SIC_DOWNLOAD_REQUIRED           8
-#define SIC_DOWNLOAD_ONLY               16
-
-/* OS: Operating System */
-#define OS_WIN95_DEBUTE                 1
-#define OS_WIN95                        2
-#define OS_WIN98                        4
-#define OS_NT3                          8
-#define OS_NT4                         16
-
-/* DSR: Disk Space Required */
-#define DSR_DESTINATION                 0
-#define DSR_SYSTEM                      1
-#define DSR_TEMP                        2
-#define DSR_DOWNLOAD_SIZE               3
-
-typedef HRESULT (_cdecl *SDI_NETINSTALL) (LPSDISTRUCT);
-
-typedef struct dlgSetup
-{
-  DWORD   dwDlgID;
-  WNDPROC fDlgProc;
-  LPSTR   szTitle;
-} diS;
-
-typedef struct dlgWelcome
-{
-  BOOL  bShowDialog;
-  LPSTR szTitle;
-  LPSTR szMessage0;
-  LPSTR szMessage1;
-  LPSTR szMessage2;
-} diW;
-
-typedef struct dlgLicense
-{
-  BOOL  bShowDialog;
-  LPSTR szTitle;
-  LPSTR szLicenseFilename;
-  LPSTR szMessage0;
-  LPSTR szMessage1;
-} diL;
-
-typedef struct stStruct
-{
-  BOOL  bVisible;
-  DWORD dwCItems;
-  DWORD dwCItemsSelected[MAX_BUF]; /* components */
-  DWORD dwAItems;
-  DWORD dwAItemsSelected[MAX_BUF]; /* additions */
-  LPSTR szDescriptionShort;
-  LPSTR szDescriptionLong;
-} st;
-
-typedef struct dlgSetupType
-{
-  BOOL  bShowDialog;
-  LPSTR szTitle;
-  LPSTR szMessage0;
-  LPSTR szReadmeFilename;
-  LPSTR szReadmeApp;
-  st    stSetupType0;
-  st    stSetupType1;
-  st    stSetupType2;
-  st    stSetupType3;
-} diST;
-
-typedef struct dlgSelectComponents
-{
-  BOOL  bShowDialog;
-  DWORD bShowDialogSM;
-  LPSTR szTitle;
-  LPSTR szMessage0;
-} diSC;
-
-typedef struct wiCBstruct
-{
-  BOOL  bEnabled;
-  BOOL  bCheckBoxState;
-  LPSTR szDescription;
-  LPSTR szArchive;
-} wiCBs;
-
-typedef struct dlgWindowsIntegration
-{
-  BOOL  bShowDialog;
-  LPSTR szTitle;
-  LPSTR szMessage0;
-  LPSTR szMessage1;
-  wiCBs wiCB0;
-  wiCBs wiCB1;
-  wiCBs wiCB2;
-  wiCBs wiCB3;
-} diWI;
-
-typedef struct dlgProgramFolder
-{
-  BOOL  bShowDialog;
-  LPSTR szTitle;
-  LPSTR szMessage0;
-} diPF;
-
-typedef struct dlgStartInstall
-{
-  BOOL  bShowDialog;
-  LPSTR szTitle;
-  LPSTR szMessage0;
-} diSI;
-
-typedef struct dlgReboot
-{
-  DWORD dwShowDialog;
-  LPSTR szTitle;
-} diR;
-
-typedef struct setupStruct
-{
-  DWORD dwMode;
-  DWORD dwCustomType;
-  LPSTR szPath;
-  LPSTR szProductName;
-  LPSTR szProgramFolderName;
-  LPSTR szProgramFolderPath;
-  LPSTR szAlternateArchiveSearchPath;
-  LPSTR szSetupTitle0;
-  LPSTR szSetupTitle1;
-  LPSTR szSetupTitle2;
-} setupGen;
-
-typedef struct sinfoSmartDownload
-{
-  LPSTR szCoreFile;
-  LPSTR szCoreDir;
-  LPSTR szNoAds;
-  LPSTR szSilent;
-  LPSTR szExecution;
-  LPSTR szConfirmInstall;
-  LPSTR szExtractMsg;
-  LPSTR szExe;
-  LPSTR szExeParam;
-  LPSTR szCoreFilePath;
-} siSD;
-
-typedef struct sinfoCoreFile
-{
-  LPSTR       szSource;
-  LPSTR       szDestination;
-  LPSTR       szMessage;
-  BOOL        bCleanup;
-  ULONGLONG   ullInstallSize;
-} siCF;
-
-typedef struct sinfoComponentDep siCD;
-struct sinfoComponentDep
-{
-  LPSTR szDescriptionShort;
-  siCD  *Next;
-  siCD  *Prev;
-};
-
-typedef struct sinfoComponent siC;
-struct sinfoComponent
-{
-  ULONGLONG       ullInstallSize;
-  ULONGLONG       ullInstallSizeSystem;
-  ULONGLONG       ullInstallSizeArchive;
-  long            lRandomInstallPercentage;
-  long            lRandomInstallValue;
-  DWORD           dwAttributes;
-  LPSTR           szArchiveName;
-  LPSTR           szArchivePath;
-  LPSTR           szDestinationPath;
-  LPSTR           szDescriptionShort;
-  LPSTR           szDescriptionLong;
-  LPSTR           szParameter;
-  siCD            *siCDDependencies;
-  siC             *Next;
-  siC             *Prev;
-};
-
-#endif

mozilla/xpinstall/wizard/windows/setup/setup.ini

@@ -1,12 +0,0 @@
-[Netscape Install]
-no_ads=true
-silent=true
-execution=false
-confirm_install=false
-
-[Proxy]
-
-[File0]
-desc=Configuration file for setup.exe
-0=ftp://sweetlou/products/client/ssu/windows/config.ini
-

mozilla/xpinstall/wizard/windows/setup/setup.rc

@@ -1,156 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-//Microsoft Developer Studio generated resource script.
-//
-#include "resource.h"
-
-#define APSTUDIO_READONLY_SYMBOLS
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 2 resource.
-//
-
-
-/////////////////////////////////////////////////////////////////////////////
-#undef APSTUDIO_READONLY_SYMBOLS
-
-/////////////////////////////////////////////////////////////////////////////
-// English (U.S.) resources
-
-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
-#ifdef _WIN32
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-#pragma code_page(1252)
-#endif //_WIN32
-
-#ifdef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// TEXTINCLUDE
-//
-
-1 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "resource.h\0"
-END
-
-2 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "\r\n"
-    "\0"
-END
-
-3 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "\r\n"
-    "\0"
-END
-
-#endif    // APSTUDIO_INVOKED
-
-
-#ifndef _MAC
-/////////////////////////////////////////////////////////////////////////////
-//
-// Version
-//
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,0,0,1
- PRODUCTVERSION 1,0,0,1
- FILEFLAGSMASK 0x3fL
-#ifdef _DEBUG
- FILEFLAGS 0x1L
-#else
- FILEFLAGS 0x0L
-#endif
- FILEOS 0x40004L
- FILETYPE 0x1L
- FILESUBTYPE 0x0L
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "Comments", "\0"
-            VALUE "CompanyName", "Netscape Communications\0"
-            VALUE "FileDescription", "setup\0"
-            VALUE "FileVersion", "1, 0, 0, 1\0"
-            VALUE "InternalName", "setup\0"
-            VALUE "LegalCopyright", "Copyright © 1999\0"
-            VALUE "LegalTrademarks", "\0"
-            VALUE "OriginalFilename", "setup.exe\0"
-            VALUE "PrivateBuild", "\0"
-            VALUE "ProductName", "Netscape Communications setup\0"
-            VALUE "ProductVersion", "1, 0, 0, 1\0"
-            VALUE "SpecialBuild", "\0"
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
-
-#endif    // !_MAC
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Icon
-//
-
-// Icon with lowest ID value placed first to ensure application icon
-// remains consistent on all systems.
-1                       ICON    DISCARDABLE     "setup.ico"
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// String Table
-//
-
-STRINGTABLE DISCARDABLE 
-BEGIN
-    IDS_ERROR_DLL_LOAD      "Could not load %s"
-    IDS_ERROR_STRING_LOAD   "Could not load string resource ID %d"
-    IDS_ERROR_STRING_NULL   "Null pointer encountered."
-    IDS_ERROR_GLOBALALLOC   "Memory allocation error."
-END
-
-#endif    // English (U.S.) resources
-/////////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 3 resource.
-//
-
-
-/////////////////////////////////////////////////////////////////////////////
-#endif    // not APSTUDIO_INVOKED
-

mozilla/xpinstall/wizard/windows/setup/shortcut.cpp

@@ -1,88 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-/* This is a hack for vc5.0.  It needs to be set *before* any shell
- * include files. The INITGUID definition turns off the inclusion
- * of shlguid.h in shlobj.h so it has to be done explicitly.
- */
-#if (_MSC_VER == 1100)
-#define INITGUID
-#include "objbase.h"
-DEFINE_OLEGUID(IID_IPersistFile, 0x0000010BL, 0, 0);
-#endif
-
-#include <shlobj.h>
-#include <shlguid.h>
-#include "shortcut.h"
-
-HRESULT CreateALink(LPSTR lpszPathObj, LPSTR lpszPathLink, LPSTR lpszDesc, LPSTR lpszWorkingPath, LPSTR lpszArgs, LPSTR lpszIconFullPath, int iIcon)
-{ 
-    HRESULT    hres; 
-    IShellLink *psl;
-    char       lpszFullPath[MAX_BUF];
-
-    lstrcpy(lpszFullPath, lpszPathLink);
-    lstrcat(lpszFullPath, "\\");
-    lstrcat(lpszFullPath, lpszDesc);
-    lstrcat(lpszFullPath, ".lnk");
-
-    CreateDirectory(lpszPathLink, NULL);
-    CoInitialize(NULL);
-
-    // Get a pointer to the IShellLink interface. 
-    hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID *)&psl); 
-    if(SUCCEEDED(hres))
-    { 
-        IPersistFile* ppf; 
- 
-        // Set the path to the shortcut target, and add the 
-        // description. 
-        psl->SetPath(lpszPathObj);
-        psl->SetDescription(lpszDesc);
-        if(lpszWorkingPath)
-            psl->SetWorkingDirectory(lpszWorkingPath);
-        if(lpszArgs)
-            psl->SetArguments(lpszArgs);
-        psl->SetIconLocation(lpszIconFullPath, iIcon);
- 
-        // Query IShellLink for the IPersistFile interface for saving the 
-        // shortcut in persistent storage. 
-        hres = psl->QueryInterface(IID_IPersistFile, (LPVOID FAR *)&ppf); 
-        if(SUCCEEDED(hres))
-        { 
-            WORD wsz[MAX_BUF]; 
- 
-            // Ensure that the string is ANSI. 
-            MultiByteToWideChar(CP_ACP, 0, lpszFullPath, -1, (wchar_t *)wsz, MAX_BUF);
- 
-            // Save the link by calling IPersistFile::Save. 
-            hres = ppf->Save((wchar_t *)wsz, TRUE); 
-            ppf->Release(); 
-        } 
-        psl->Release(); 
-    } 
-    CoUninitialize();
-
-    return hres;
-} 

mozilla/xpinstall/wizard/windows/setup/shortcut.h

@@ -1,43 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#ifndef _SHORTCUT_H_
-#define _SHORTCUT_H_
-
-#ifndef MAX_BUF
-#define MAX_BUF 4096
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-HRESULT CreateALink(LPSTR lpszPathObj, LPSTR lpszPathLink, LPSTR lpszDesc, LPSTR lpszWorkingPath, LPSTR lpszArgs, LPSTR lpszIconFullPath, int iIcon);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

mozilla/xpinstall/wizard/windows/setup/xpi.c

@@ -1,688 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#include "extern.h"
-#include "dialogs.h"
-#include "extra.h"
-#include "xpistub.h"
-#include "xpi.h"
-
-#define BDIR_RIGHT 1
-#define BDIR_LEFT  2
-
-static XpiInit          pfnXpiInit;
-static XpiInstall       pfnXpiInstall;
-static XpiExit          pfnXpiExit;
-
-static long             lFileCounter;
-static long             lBarberCounter;
-static BOOL             bBarberBar;
-static DWORD            dwBarberDirection;
-static DWORD            dwCurrentArchive;
-static DWORD            dwTotalArchives;
-char                    szStrProcessingFile[MAX_BUF];
-char                    szStrCopyingFile[MAX_BUF];
-char                    szStrInstalling[MAX_BUF];
-
-static void UpdateGaugeFileProgressBar(unsigned value);
-static void UpdateGaugeArchiveProgressBar(unsigned value);
-static void UpdateGaugeFileBarber(void);
-
-struct ExtractFilesDlgInfo
-{
-	HWND	hWndDlg;
-	int		nMaxFileBars;	    // maximum number of bars that can be displayed
-	int		nMaxArchiveBars;	// maximum number of bars that can be displayed
-	int		nFileBars;		    // current number of bars to display
-	int		nArchiveBars;		  // current number of bars to display
-} dlgInfo;
-
-HRESULT InitializeXPIStub()
-{
-  char szBuf[MAX_BUF];
-  char szXPIStubFile[MAX_BUF];
-  char szEGetProcAddress[MAX_BUF];
-
-  hXPIStubInst = NULL;
-
-  if(NS_LoadString(hSetupRscInst, IDS_ERROR_GETPROCADDRESS, szEGetProcAddress, MAX_BUF) != WIZ_OK)
-    return(1);
-
-  /* change current directory to where xpistub.dll */
-  lstrcpy(szBuf, siCFCoreFile.szDestination);
-  AppendBackSlash(szBuf, sizeof(szBuf));
-  lstrcat(szBuf, "bin");
-  chdir(szBuf);
-
-  /* build full path to xpistub.dll */
-  lstrcpy(szXPIStubFile, szBuf);
-  AppendBackSlash(szXPIStubFile, sizeof(szXPIStubFile));
-  lstrcat(szXPIStubFile, "xpistub.dll");
-
-  if(FileExists(szXPIStubFile) == FALSE)
-    return(2);
-
-  /* load xpistub.dll */
-  if((hXPIStubInst = LoadLibraryEx(szXPIStubFile, NULL, LOAD_WITH_ALTERED_SEARCH_PATH)) == NULL)
-  {
-    wsprintf(szBuf, szEDllLoad, szXPIStubFile);
-    PrintError(szBuf, ERROR_CODE_SHOW);
-    return(1);
-  }
-  if(((FARPROC)pfnXpiInit = GetProcAddress(hXPIStubInst, "XPI_Init")) == NULL)
-  {
-    wsprintf(szBuf, szEGetProcAddress, "XPI_Init");
-    PrintError(szBuf, ERROR_CODE_SHOW);
-    return(1);
-  }
-  if(((FARPROC)pfnXpiInstall = GetProcAddress(hXPIStubInst, "XPI_Install")) == NULL)
-  {
-    wsprintf(szBuf, szEGetProcAddress, "XPI_Install");
-    PrintError(szBuf, ERROR_CODE_SHOW);
-    return(1);
-  }
-  if(((FARPROC)pfnXpiExit = GetProcAddress(hXPIStubInst, "XPI_Exit")) == NULL)
-  {
-    wsprintf(szBuf, szEGetProcAddress, "XPI_Exit");
-    PrintError(szBuf, ERROR_CODE_SHOW);
-    return(1);
-  }
-
-  return(0);
-}
-
-HRESULT DeInitializeXPIStub()
-{
-  pfnXpiInit    = NULL;
-  pfnXpiInstall = NULL;
-  pfnXpiExit    = NULL;
-
-  if(hXPIStubInst)
-    FreeLibrary(hXPIStubInst);
-
-  chdir(szSetupDir);
-  return(0);
-}
-
-void GetTotalArchivesToInstall(void)
-{
-  DWORD     dwIndex0;
-  siC       *siCObject = NULL;
-
-  dwIndex0        = 0;
-  dwTotalArchives = 0;
-  siCObject = SiCNodeGetObject(dwIndex0, TRUE);
-  while(siCObject)
-  {
-    if((siCObject->dwAttributes & SIC_SELECTED) && !(siCObject->dwAttributes & SIC_LAUNCHAPP))
-      ++dwTotalArchives;
-
-    ++dwIndex0;
-    siCObject = SiCNodeGetObject(dwIndex0, TRUE);
-  }
-}
-
-HRESULT SmartUpdateJars()
-{
-  DWORD     dwIndex0;
-  siC       *siCObject = NULL;
-  HRESULT   hrResult;
-  char      szBuf[MAX_BUF];
-  char      szEXpiInstall[MAX_BUF];
-  char      szArchive[MAX_BUF];
-  char      szMsgSmartUpdateStart[MAX_BUF];
-  char      szDlgExtractingTitle[MAX_BUF];
-
-  if(NS_LoadString(hSetupRscInst, IDS_MSG_SMARTUPDATE_START, szMsgSmartUpdateStart, MAX_BUF) != WIZ_OK)
-    return(1);
-  if(NS_LoadString(hSetupRscInst, IDS_DLG_EXTRACTING_TITLE, szDlgExtractingTitle, MAX_BUF) != WIZ_OK)
-    return(1);
-  if(NS_LoadString(hSetupRscInst, IDS_STR_PROCESSINGFILE, szStrProcessingFile, MAX_BUF) != WIZ_OK)
-    exit(1);
-  if(NS_LoadString(hSetupRscInst, IDS_STR_INSTALLING, szStrInstalling, MAX_BUF) != WIZ_OK)
-    exit(1);
-  if(NS_LoadString(hSetupRscInst, IDS_STR_COPYINGFILE, szStrCopyingFile, MAX_BUF) != WIZ_OK)
-    exit(1);
-
-  ShowMessage(szMsgSmartUpdateStart, TRUE);
-  if(InitializeXPIStub() == WIZ_OK)
-  {
-    hrResult = pfnXpiInit(sgProduct.szPath, cbXPIProgress);
-
-    ShowMessage(szMsgSmartUpdateStart, FALSE);
-    InitProgressDlg();
-    GetTotalArchivesToInstall();
-    SetWindowText(dlgInfo.hWndDlg, szDlgExtractingTitle);
-
-    dwIndex0          = 0;
-    dwCurrentArchive  = 0;
-    dwTotalArchives   = (dwTotalArchives * 2) + 1;
-    bBarberBar        = FALSE;
-    siCObject         = SiCNodeGetObject(dwIndex0, TRUE);
-    while(siCObject)
-    {
-      /* launch smartupdate engine for earch jar to be installed */
-      if((siCObject->dwAttributes & SIC_SELECTED)   &&
-        !(siCObject->dwAttributes & SIC_LAUNCHAPP) &&
-        !(siCObject->dwAttributes & SIC_DOWNLOAD_ONLY))
-      {
-        lFileCounter      = 0;
-        lBarberCounter    = 0;
-        dwBarberDirection = BDIR_RIGHT;
-			  dlgInfo.nFileBars = 0;
-        UpdateGaugeFileProgressBar(0);
-
-        lstrcpy(szArchive, sgProduct.szAlternateArchiveSearchPath);
-        AppendBackSlash(szArchive, sizeof(szArchive));
-        lstrcat(szArchive, siCObject->szArchiveName);
-        if((*sgProduct.szAlternateArchiveSearchPath == '\0') || (!FileExists(szArchive)))
-        {
-          lstrcpy(szArchive, szSetupDir);
-          AppendBackSlash(szArchive, sizeof(szArchive));
-          lstrcat(szArchive, siCObject->szArchiveName);
-          if(!FileExists(szArchive))
-          {
-            lstrcpy(szArchive, szTempDir);
-            AppendBackSlash(szArchive, sizeof(szArchive));
-            lstrcat(szArchive, siCObject->szArchiveName);
-            if(!FileExists(szArchive))
-            {
-              char szEFileNotFound[MAX_BUF];
-
-              if(NS_LoadString(hSetupRscInst, IDS_ERROR_FILE_NOT_FOUND, szEFileNotFound, MAX_BUF) == WIZ_OK)
-              {
-                wsprintf(szBuf, szEFileNotFound, szArchive);
-                PrintError(szBuf, ERROR_CODE_HIDE);
-              }
-              return(1);
-            }
-          }
-        }
-
-        if(dwCurrentArchive == 0)
-        {
-          ++dwCurrentArchive;
-          UpdateGaugeArchiveProgressBar((unsigned)(((double)(dwCurrentArchive)/(double)dwTotalArchives)*(double)100));
-        }
-
-        wsprintf(szBuf, szStrInstalling, siCObject->szDescriptionShort);
-        SetDlgItemText(dlgInfo.hWndDlg, IDC_STATUS0, szBuf);
-
-        hrResult = pfnXpiInstall(szArchive, "", 0xFFFF);
-        if(hrResult == 999)
-          bReboot = TRUE;
-        else if(hrResult != WIZ_OK)
-        {
-          if(NS_LoadString(hSetupRscInst, IDS_ERROR_XPI_INSTALL, szEXpiInstall, MAX_BUF) == WIZ_OK)
-          {
-            wsprintf(szBuf, "%d: %s", hrResult, szEXpiInstall);
-            PrintError(szBuf, ERROR_CODE_HIDE);
-          }
-
-          /* break out of the while loop */
-          break;
-        }
-
-        ++dwCurrentArchive;
-        UpdateGaugeArchiveProgressBar((unsigned)(((double)(dwCurrentArchive)/(double)dwTotalArchives)*(double)100));
-        ProcessWindowsMessages();
-      }
-
-      ++dwIndex0;
-      siCObject = SiCNodeGetObject(dwIndex0, TRUE);
-    }
-
-    pfnXpiExit();
-    DeInitProgressDlg();
-  }
-  else
-  {
-    ShowMessage(szMsgSmartUpdateStart, FALSE);
-  }
-
-  DeInitializeXPIStub();
-
-  return(hrResult);
-}
-
-void cbXPIStart(const char *URL, const char *UIName)
-{
-}
-
-void cbXPIProgress(const char* msg, PRInt32 val, PRInt32 max)
-{
-  char szFilename[MAX_BUF];
-  char szStrProcessingFileBuf[MAX_BUF];
-  char szStrCopyingFileBuf[MAX_BUF];
-
-  ParsePath((char *)msg, szFilename, sizeof(szFilename), PP_FILENAME_ONLY);
-
-  if(max == 0)
-  {
-    wsprintf(szStrProcessingFileBuf, szStrProcessingFile, szFilename);
-    SetDlgItemText(dlgInfo.hWndDlg, IDC_STATUS3, szStrProcessingFileBuf);
-    bBarberBar = TRUE;
-    UpdateGaugeFileBarber();
-  }
-  else
-  {
-    if(bBarberBar == TRUE)
-    {
-      dlgInfo.nFileBars = 0;
-      ++dwCurrentArchive;
-      UpdateGaugeArchiveProgressBar((unsigned)(((double)(dwCurrentArchive)/(double)dwTotalArchives)*(double)100));
-      bBarberBar = FALSE;
-    }
-
-    wsprintf(szStrCopyingFileBuf, szStrCopyingFile, szFilename);
-    SetDlgItemText(dlgInfo.hWndDlg, IDC_STATUS3, szStrCopyingFileBuf);
-    UpdateGaugeFileProgressBar((unsigned)(((double)(val+1)/(double)max)*(double)100));
-  }
-
-  ProcessWindowsMessages();
-}
-
-void cbXPIFinal(const char *URL, PRInt32 finalStatus)
-{
-}
-
-
-
-/////////////////////////////////////////////////////////////////////////////
-// Progress bar
-
-// Centers the specified window over the desktop. Assumes the window is
-// smaller both horizontally and vertically than the desktop
-static void
-CenterWindow(HWND hWndDlg)
-{
-	RECT	rect;
-	int		iLeft, iTop;
-
-	GetWindowRect(hWndDlg, &rect);
-	iLeft = (GetSystemMetrics(SM_CXSCREEN) - (rect.right - rect.left)) / 2;
-	iTop  = (GetSystemMetrics(SM_CYSCREEN) - (rect.bottom - rect.top)) / 2;
-
-	SetWindowPos(hWndDlg, NULL, iLeft, iTop, -1, -1, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
-}
-
-// Window proc for dialog
-LRESULT CALLBACK
-ProgressDlgProc(HWND hWndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
-{
-	switch (msg)
-  {
-		case WM_INITDIALOG:
-			CenterWindow(hWndDlg);
-			return FALSE;
-
-		case WM_COMMAND:
-			return TRUE;
-	}
-
-	return FALSE;  // didn't handle the message
-}
-
-// This routine will update the File Gauge progress bar to the specified percentage
-// (value between 0 and 100)
-static void
-UpdateGaugeFileBarber()
-{
-	int	nBars;
-	HWND	hWndGauge = GetDlgItem(dlgInfo.hWndDlg, IDC_GAUGE_FILE);
-	RECT	rect;
-
-  if(dwBarberDirection == BDIR_RIGHT)
-  {
-    if(lBarberCounter < 151)
-      ++lBarberCounter;
-    else
-      dwBarberDirection = BDIR_LEFT;
-  }
-  else if(dwBarberDirection == BDIR_LEFT)
-  {
-    if(lBarberCounter > 0)
-      --lBarberCounter;
-    else
-      dwBarberDirection = BDIR_RIGHT;
-  }
-
-  // Figure out how many bars should be displayed
-  nBars = (dlgInfo.nMaxFileBars * lBarberCounter / 100);
-
-  // Update the gauge state before painting
-  dlgInfo.nFileBars = nBars;
-
-  // Only invalidate the part that needs updating
-  GetClientRect(hWndGauge, &rect);
-  InvalidateRect(hWndGauge, &rect, FALSE);
-
-  // Update the whole extracting dialog. We do this because we don't
-  // have a message loop to process WM_PAINT messages in case the
-  // extracting dialog was exposed
-  UpdateWindow(dlgInfo.hWndDlg);
-}
-
-// This routine will update the File Gauge progress bar to the specified percentage
-// (value between 0 and 100)
-static void
-UpdateGaugeFileProgressBar(unsigned value)
-{
-	int	nBars;
-
-	// Figure out how many bars should be displayed
-	nBars = dlgInfo.nMaxFileBars * value / 100;
-
-	// Only paint if we need to display more bars
-	if((nBars > dlgInfo.nFileBars) || (dlgInfo.nFileBars == 0))
-  {
-		HWND	hWndGauge = GetDlgItem(dlgInfo.hWndDlg, IDC_GAUGE_FILE);
-		RECT	rect;
-
-		// Update the gauge state before painting
-		dlgInfo.nFileBars = nBars;
-
-		// Only invalidate the part that needs updating
-		GetClientRect(hWndGauge, &rect);
-		InvalidateRect(hWndGauge, &rect, FALSE);
-	
-		// Update the whole extracting dialog. We do this because we don't
-		// have a message loop to process WM_PAINT messages in case the
-		// extracting dialog was exposed
-		UpdateWindow(dlgInfo.hWndDlg);
-	}
-}
-
-// This routine will update the Archive Gauge progress bar to the specified percentage
-// (value between 0 and 100)
-static void
-UpdateGaugeArchiveProgressBar(unsigned value)
-{
-	int	nBars;
-
-	// Figure out how many bars should be displayed
-	nBars = dlgInfo.nMaxArchiveBars * value / 100;
-
-	// Only paint if we need to display more bars
-	if (nBars > dlgInfo.nArchiveBars)
-  {
-		HWND	hWndGauge = GetDlgItem(dlgInfo.hWndDlg, IDC_GAUGE_ARCHIVE);
-		RECT	rect;
-
-		// Update the gauge state before painting
-		dlgInfo.nArchiveBars = nBars;
-
-		// Only invalidate the part that needs updating
-		GetClientRect(hWndGauge, &rect);
-		InvalidateRect(hWndGauge, &rect, FALSE);
-	
-		// Update the whole extracting dialog. We do this because we don't
-		// have a message loop to process WM_PAINT messages in case the
-		// extracting dialog was exposed
-		UpdateWindow(dlgInfo.hWndDlg);
-	}
-}
-
-// Draws a recessed border around the gauge
-static void
-DrawGaugeBorder(HWND hWnd)
-{
-	HDC		hDC = GetWindowDC(hWnd);
-	RECT	rect;
-	int		cx, cy;
-	HPEN	hShadowPen = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNSHADOW));
-	HGDIOBJ	hOldPen;
-
-	GetWindowRect(hWnd, &rect);
-	cx = rect.right - rect.left;
-	cy = rect.bottom - rect.top;
-
-	// Draw a dark gray line segment
-	hOldPen = SelectObject(hDC, (HGDIOBJ)hShadowPen);
-	MoveToEx(hDC, 0, cy - 1, NULL);
-	LineTo(hDC, 0, 0);
-	LineTo(hDC, cx - 1, 0);
-
-	// Draw a white line segment
-	SelectObject(hDC, GetStockObject(WHITE_PEN));
-	MoveToEx(hDC, 0, cy - 1, NULL);
-	LineTo(hDC, cx - 1, cy - 1);
-	LineTo(hDC, cx - 1, 0);
-
-	SelectObject(hDC, hOldPen);
-	DeleteObject(hShadowPen);
-	ReleaseDC(hWnd, hDC);
-}
-
-// Draws the blue progress bar
-static void
-DrawProgressBar(HWND hWnd, int nBars)
-{
-  int         i;
-	PAINTSTRUCT	ps;
-	HDC         hDC;
-	RECT        rect;
-	HBRUSH      hBrush;
-
-  hDC = BeginPaint(hWnd, &ps);
-	GetClientRect(hWnd, &rect);
-  if(nBars <= 0)
-  {
-    /* clear the bars */
-    hBrush = CreateSolidBrush(GetSysColor(COLOR_MENU));
-    FillRect(hDC, &rect, hBrush);
-  }
-  else
-  {
-  	// Draw the bars
-    hBrush = CreateSolidBrush(RGB(0, 0, 128));
-	  rect.left     = rect.top = BAR_MARGIN;
-	  rect.bottom  -= BAR_MARGIN;
-	  rect.right    = rect.left + BAR_WIDTH;
-
-	  for(i = 0; i < nBars; i++)
-    {
-		  RECT	dest;
-
-		  if(IntersectRect(&dest, &ps.rcPaint, &rect))
-			  FillRect(hDC, &rect, hBrush);
-
-      OffsetRect(&rect, BAR_WIDTH + BAR_SPACING, 0);
-	  }
-  }
-
-	DeleteObject(hBrush);
-	EndPaint(hWnd, &ps);
-}
-
-// Draws the blue progress bar
-static void
-DrawBarberBar(HWND hWnd, int nBars)
-{
-  int         i;
-	PAINTSTRUCT	ps;
-	HDC         hDC;
-	RECT        rect;
-	HBRUSH      hBrush;
-	HBRUSH      hBrushClear;
-
-  hDC = BeginPaint(hWnd, &ps);
-	GetClientRect(hWnd, &rect);
-  if(nBars <= 0)
-  {
-    /* clear the bars */
-    hBrushClear = CreateSolidBrush(GetSysColor(COLOR_MENU));
-    FillRect(hDC, &rect, hBrushClear);
-  }
-  else
-  {
-  	// Draw the bars
-    hBrushClear   = CreateSolidBrush(GetSysColor(COLOR_MENU));
-    hBrush        = CreateSolidBrush(RGB(0, 0, 128));
-	  rect.left     = rect.top = BAR_MARGIN;
-	  rect.bottom  -= BAR_MARGIN;
-	  rect.right    = rect.left + BAR_WIDTH;
-
-	  for(i = 0; i < (nBars + 1); i++)
-    {
-		  RECT	dest;
-
-		  if(IntersectRect(&dest, &ps.rcPaint, &rect))
-      {
-        if((i >= (nBars - 15)) && (i < nBars))
-			    FillRect(hDC, &rect, hBrush);
-        else
-			    FillRect(hDC, &rect, hBrushClear);
-      }
-
-      OffsetRect(&rect, BAR_WIDTH + BAR_SPACING, 0);
-	  }
-  }
-
-	DeleteObject(hBrushClear);
-	DeleteObject(hBrush);
-	EndPaint(hWnd, &ps);
-}
-
-// Adjusts the width of the gauge based on the maximum number of bars
-static void
-SizeToFitGauge(HWND hWnd, int nMaxBars)
-{
-	RECT	rect;
-	int		cx;
-
-	// Get the window size in pixels
-	GetWindowRect(hWnd, &rect);
-
-	// Size the width to fit
-	cx = 2 * GetSystemMetrics(SM_CXBORDER) + 2 * BAR_MARGIN +
-		nMaxBars * BAR_WIDTH + (nMaxBars - 1) * BAR_SPACING;
-
-	SetWindowPos(hWnd, NULL, -1, -1, cx, rect.bottom - rect.top,
-		SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
-}
-
-// Window proc for file gauge
-LRESULT CALLBACK
-GaugeFileWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
-{
-	DWORD	dwStyle;
-	RECT	rect;
-
-	switch(msg)
-  {
-		case WM_NCCREATE:
-			dwStyle = GetWindowLong(hWnd, GWL_STYLE);
-			SetWindowLong(hWnd, GWL_STYLE, dwStyle | WS_BORDER);
-			return(TRUE);
-
-		case WM_CREATE:
-			// Figure out the maximum number of bars that can be displayed
-			GetClientRect(hWnd, &rect);
-			dlgInfo.nFileBars = 0;
-			dlgInfo.nMaxFileBars = (rect.right - rect.left - 2 * BAR_MARGIN + BAR_SPACING) / (BAR_WIDTH + BAR_SPACING);
-
-			// Size the gauge to exactly fit the maximum number of bars
-			SizeToFitGauge(hWnd, dlgInfo.nMaxFileBars);
-			return(FALSE);
-
-		case WM_NCPAINT:
-			DrawGaugeBorder(hWnd);
-			return(FALSE);
-
-		case WM_PAINT:
-      if(bBarberBar == TRUE)
-			  DrawBarberBar(hWnd, dlgInfo.nFileBars);
-      else
-			  DrawProgressBar(hWnd, dlgInfo.nFileBars);
-
-			return(FALSE);
-	}
-
-	return(DefWindowProc(hWnd, msg, wParam, lParam));
-}
-
-// Window proc for file gauge
-LRESULT CALLBACK
-GaugeArchiveWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
-{
-	DWORD	dwStyle;
-	RECT	rect;
-
-	switch(msg)
-  {
-		case WM_NCCREATE:
-			dwStyle = GetWindowLong(hWnd, GWL_STYLE);
-			SetWindowLong(hWnd, GWL_STYLE, dwStyle | WS_BORDER);
-			return(TRUE);
-
-		case WM_CREATE:
-			// Figure out the maximum number of bars that can be displayed
-			GetClientRect(hWnd, &rect);
-			dlgInfo.nArchiveBars = 0;
-			dlgInfo.nMaxArchiveBars = (rect.right - rect.left - 2 * BAR_MARGIN + BAR_SPACING) / (BAR_WIDTH + BAR_SPACING);
-
-			// Size the gauge to exactly fit the maximum number of bars
-			SizeToFitGauge(hWnd, dlgInfo.nMaxArchiveBars);
-			return(FALSE);
-
-		case WM_NCPAINT:
-			DrawGaugeBorder(hWnd);
-			return(FALSE);
-
-		case WM_PAINT:
-			DrawProgressBar(hWnd, dlgInfo.nArchiveBars);
-			return(FALSE);
-	}
-
-	return(DefWindowProc(hWnd, msg, wParam, lParam));
-}
-
-void InitProgressDlg()
-{
-	WNDCLASS	wc;
-
-	memset(&wc, 0, sizeof(wc));
-  wc.style          = CS_GLOBALCLASS;
-	wc.hInstance      = hInst;
-	wc.hbrBackground  = (HBRUSH)(COLOR_BTNFACE + 1);
-  wc.lpfnWndProc    = (WNDPROC)GaugeFileWndProc;
-	wc.lpszClassName  = "GaugeFile";
-	RegisterClass(&wc);
-
-  wc.lpfnWndProc    = (WNDPROC)GaugeArchiveWndProc;
-	wc.lpszClassName  = "GaugeArchive";
-	RegisterClass(&wc);
-
-	// Display the dialog box
-	dlgInfo.hWndDlg = CreateDialog(hSetupRscInst, MAKEINTRESOURCE(DLG_EXTRACTING), hWndMain, (WNDPROC)ProgressDlgProc);
-	UpdateWindow(dlgInfo.hWndDlg);
-}
-
-void DeInitProgressDlg()
-{
-  DestroyWindow(dlgInfo.hWndDlg);
-  UnregisterClass("GaugeFile", hInst);
-  UnregisterClass("GaugeArchive", hInst);
-}

mozilla/xpinstall/wizard/windows/setup/xpi.h

@@ -1,46 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code,
- * released March 31, 1998.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Sean Su <ssu@netscape.com>
- */
-
-#ifndef _XPI_H_
-#define _XPI_H_
-
-#define BAR_MARGIN    1
-#define BAR_SPACING   2
-#define BAR_WIDTH     6
-
-typedef HRESULT (_cdecl *XpiInit)(const char *, pfnXPIProgress);
-typedef HRESULT (_cdecl *XpiInstall)(const char *, const char *, long);
-typedef void    (_cdecl *XpiExit)(void);
-
-HRESULT         InitializeXPIStub(void);
-HRESULT         DeInitializeXPIStub(void);
-HRESULT         SmartUpdateJars(void);
-void            cbXPIStart(const char *, const char *UIName);
-void            cbXPIProgress(const char* msg, PRInt32 val, PRInt32 max);
-void            cbXPIFinal(const char *, PRInt32 finalStatus);
-void            InitProgressDlg(void);
-void            DeInitProgressDlg(void);
-void            GetTotalArchivesToInstall(void);
-
-#endif

mozilla/xpinstall/wizard/windows/setup/xpistub.h

@@ -1,118 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, 
- * released March 31, 1998. 
- *
- * The Initial Developer of the Original Code is Netscape Communications 
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Daniel Veditz <dveditz@netscape.com>
- */
-
-
-//#include "nsError.h"
-//#include "prtypes.h"
-
-#ifdef XP_MAC
-#include <Files.h>
-#endif
-
-#define nsresult long
-
-PR_BEGIN_EXTERN_C
-
-/** pfnXPIStart  -- script start callback
- *  
- *  When an install script gets to StartInstall() this function
- *  will be called to tell the observer the pretty-name of the
- *  install package. You are not guaranteed this will be called
- *  for all scripts--there might be a fatal error before it gets
- *  to StartInstall(), either in the script itself or in the
- *  engine trying to set up for it.
- */
-typedef void     (*pfnXPIStart)   (const char* URL, const char* UIName);
-
-/** pfnXPIProgress  -- individual install item callback
- *
- *  This callback will be called twice for each installed item,
- *  First when it is scheduled (val and max will both be 0) and
- *  then during the finalize step.
- */
-typedef void    (*pfnXPIProgress)(const char* msg, PRInt32 val, PRInt32 max);
-
-/** pfnXPIFinal  -- script end callback
- *
- *  This function will be called when the script calls either
- *  AbortInstall() or FinalizeInstall() and will return the
- *  last error code.
- */
-typedef void     (*pfnXPIFinal)   (const char* URL, PRInt32 finalStatus);
-
-
-
-/** XPI_Init
- *
- *  call XPI_Init() to initialize XPCOM and the XPInstall
- *  engine, and to pass in your callback functions.
- *
- *  @param aXPIStubDir   [MAC only] directory of the xpistub shlb off of which
- *                       the component manager derives the components directory.
- *  @param aProgramDir   directory to use as "program" directory. If NULL default
- *                       will be used -- the location of the calling executable.
- *                       Must be native filename format.
- *  @param startCB       Called when script started
- *  @param progressCB    Called for each installed file
- *  @param finalCB       Called with status code at end
- *
- *  @returns    XPCOM status code indicating success or failure
- */
-PR_EXTERN(nsresult) XPI_Init( 
-#ifdef XP_MAC
-                              const FSSpec&     aXPIStubDir,
-                              const FSSpec&     aProgramDir,
-#else
-                              const char*       aProgramDir,
-#endif
-                              pfnXPIProgress    progressCB );
-
-/** XPI_Install
- *
- *  Install an XPI package from a local file
- *
- *  @param file     Native filename of XPI archive
- *  @param args     Install.arguments, if any
- *  @param flags    the old SmartUpdate trigger flags. This may go away
- *
- *  @returns status  Status from the installed archive
- */
-PR_EXTERN(PRInt32) XPI_Install( 
-#ifdef XP_MAC
-                                 const FSSpec& file,
-#else
-                                 const char*    file,
-#endif
-                                 const char* args, 
-                                 long flags         );
-
-/** XPI_Exit
- * 
- *  call when done to shut down the XPInstall and XPCOM engines
- *  and free allocated memory
- */
-PR_EXTERN(void) XPI_Exit();
-
-PR_END_EXTERN_C
-

mozilla/xpinstall/wizard/windows/setup/zipfile.h

@@ -1,86 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code, 
- * released March 31, 1998. 
- *
- * The Initial Developer of the Original Code is Netscape Communications 
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- *     Daniel Veditz <dveditz@netscape.com>
- */
-
-#ifndef _zipfile_h
-#define _zipfile_h
-/* 
- * This module implements a simple archive extractor for the PKZIP format.
- *
- * All functions return a status/error code, and have an opaque hZip argument 
- * that represents an open archive.
- *
- * Currently only compression mode 8 (or none) is supported.
- */
-
-
-#define ZIP_OK                 0
-#define ZIP_ERR_GENERAL       -1
-#define ZIP_ERR_MEMORY        -2
-#define ZIP_ERR_DISK          -3
-#define ZIP_ERR_CORRUPT       -4
-#define ZIP_ERR_PARAM         -5
-#define ZIP_ERR_FNF           -6
-#define ZIP_ERR_UNSUPPORTED   -7
-#define ZIP_ERR_SMALLBUF      -8
-
-PR_BEGIN_EXTERN_C
-
-/* Open and close the archive 
- *
- * If successful OpenArchive returns a handle in the hZip parameter
- * that must be passed to all subsequent operations on the archive
- */
-extern _declspec(dllexport)int ZIP_OpenArchive( const char * zipname, void** hZip );
-extern _declspec(dllexport)int ZIP_CloseArchive( void** hZip );
-
-
-/* Extract the named file in the archive to disk. 
- * This function will happily overwrite an existing Outfile if it can.
- * It's up to the caller to detect or move it out of the way if it's important.
- */
-extern _declspec(dllexport)int ZIP_ExtractFile( void* hZip, const char * filename, const char * outname );
-
-
-/* Functions to list the files contained in the archive
- *
- * FindInit() initializes the search with the pattern and returns a find token, 
- * or NULL on an error.  Then FindNext() is called with the token to get the 
- * matching filenames if any. When done you must call FindFree() with the 
- * token to release memory.
- * 
- * a NULL pattern will find all the files in the archive, otherwise the 
- * pattern must be a shell regexp type pattern.
- *
- * if a matching filename is too small for the passed buffer FindNext()
- * will return ZIP_ERR_SMALLBUF. When no more matches can be found in
- * the archive it will return ZIP_ERR_FNF
- */
-extern _declspec(dllexport)void* ZIP_FindInit( void* hZip, const char * pattern );
-extern _declspec(dllexport)int ZIP_FindNext( void* hFind, char * outbuf, int bufsize );
-extern _declspec(dllexport)int ZIP_FindFree( void* hFind );
-
-
-PR_END_EXTERN_C
-
-#endif /* _zipfile_h */

mozilla/xpinstall/wizard/windows/setuprsc/makefile.win

@@ -1,55 +0,0 @@
-#!gmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is Mozilla Communicator client code, 
-# released March 31, 1998. 
-#
-# The Initial Developer of the Original Code is Netscape Communications 
-# Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#     Sean Su <ssu@netscape.com>
-#     Daniel Veditz <dveditz@netscape.com>
-
-DEPTH=..\..\..\..
-
-MAKE_OBJ_TYPE=DLL
-
-USE_NON_MT_LIBS=1
-#USE_STATIC_LIBS=1
-
-MODULE      = setuprsc
-RESFILE     = $(MODULE).res
-DLL         = $(OBJDIR)\$(MODULE).dll
-
-OBJS=                             \
-    .\$(OBJDIR)\setuprsc.obj      \
-    $(NULL)
-
-include <$(DEPTH)/config/rules.mak>
-
-docopy:
-    $(MAKE_INSTALL) setuprsc.h $(DIST)\include
-
-export:: docopy
-
-install:: $(DLL)
-    $(MAKE_INSTALL) .\$(OBJDIR)\$(MODULE).dll $(DIST)\install
-
-clobber::
-  $(RM) $(DIST)\include\setuprsc.h
-
-clobber_all:: clobber
-  $(RM) $(DIST)\install\$(MODULE).dll
-