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/intl/uconv/Makefile.in

@@ -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.org code.
-#
-# 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): 
-# IBM Corporation
-#
-# This Original Code has been modified by IBM Corporation.
-# Modifications made by IBM described herein are
-# Copyright (c) International Business Machines
-# Corporation, 1999
-#
-# Modifications to Mozilla code or documentation
-# identified per MPL Section 3.3
-#
-# Date         Modified by     Description of modification
-# 12/09/1999   IBM Corp.       Support for IBM codepages - 850,852,855,857,862,864
-#
-
-DEPTH		= ../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS		= idl public util ucvja ucvcn ucvlatin ucvtw ucvtw2 ucvko ucvibm src
-
-ifdef MOZ_MATHML
-DIRS           += ucvmath
-endif
-
-ifeq ($(OS_ARCH),WINNT)
-ifdef ENABLE_TESTS
-DIRS		+= tests
-endif
-endif
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/intl/uconv/directory.txt

@@ -1,57 +0,0 @@
-Directory Structure :
-================================
-public  - public header file
-src     - source directory of charset converter manager and utility
-tests   - tests program and application for charset converter 
-
-The following directory are used to put different charset converter 
-
-ucvam    - Armenian charsets
-ucvar    - Arabic charsets
-ucvcn    - Simplified chinese charsets- GB2312, HZ, ISO-2022-CN
-ucvcy    - Cyrillic charsets - ISO-8859-5, CP1251, KOI8-R, KOI8-U, Mac Cyrillic 
-ucvgr    - Greek charsets - ISO-8859-7, CP1253
-ucvhr    - Hebrew charsets 
-ucvja    - Japanese charsets Set 1 - Shift-JIS 
-ucvja2   - Japanese charsets Set 2 - ISO-2022-JP , EUC-JP
-ucvko    - Korean charsets - ISO-2022-KR, EUC-KR
-ucvlatin - Latin charsets - ISO-8859-1,2,3,4,9,14,15, CP1250,1252,1254, 
-                            Mac Roman, Central European, Romanian, Icelandic, 
-                            etc
-ucvmath  - Mathematical charsets (symbols for MathML/scientific documents)
-ucvth    - Thai charsets
-ucvtw    - Traditional Chinese charsets Set 1 - Big5
-ucvtw2   - Traditional Chinese charsets Set 2 - EUC-TW, ISO-2022-CN,  
-ucvutf   - UTF-8, UTF-7
-ucvvt    - Vietnamese charsets
-
-The following directory are obsolete and should not be used:
-
-ufromam
-ufromar
-ufromcn
-ufromcy
-ufromgr
-ufromhr
-ufromja
-ufromja2
-ufromko
-ufroml
-ufromtw
-ufromtw2
-ufromutf
-ufromvt
-utoam
-utoar
-utocn
-utocy
-utogr
-utohr
-utoja
-utoja2
-utoko
-utol
-utotw
-utotw2
-utoutf
-utovt

mozilla/intl/uconv/idl/MANIFEST_IDL

@@ -1,4 +0,0 @@
-nsITextToSubURI.idl
-nsICurrentCharsetListener.idl
-nsICharsetConverterManager2.idl
-nsIScriptableUConv.idl

mozilla/intl/uconv/idl/Makefile.in

@@ -1,38 +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.org code.
-#
-# 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): 
-#
-
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= uconv
-
-XPIDLSRCS	= \
-	nsITextToSubURI.idl \
-	nsICurrentCharsetListener.idl \
-	nsICharsetConverterManager2.idl \
- 	nsIScriptableUConv.idl \
-	$(NULL)
-
-include $(topsrcdir)/config/rules.mk

mozilla/intl/uconv/idl/makefile.win

@@ -1,33 +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.org code.
-#
-# 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): 
-
-MODULE = uconv
-
-DEPTH = ..\..\..
-
-XPIDLSRCS =					\
-	.\nsITextToSubURI.idl			\
-	.\nsICurrentCharsetListener.idl		\
-	.\nsICharsetConverterManager2.idl	\
- 	.\nsIScriptableUConv.idl	\
-	$(NULL)
-
-include <$(DEPTH)/config/rules.mak>

mozilla/intl/uconv/idl/nsICharsetConverterManager2.idl

@@ -1,143 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-#include "nsISupportsArray.idl"
-#include "nsIAtom.idl"
-%{ C++
-#include "nsIUnicodeDecoder.h"
-#include "nsIUnicodeEncoder.h"
-#include "nsString.h"
-%}
-
-[ptr] native nsDecoderPtr(nsIUnicodeDecoder);
-[ptr] native nsEncoderPtr(nsIUnicodeEncoder);
-[ptr] native nsStringPtr(nsString);
-
-/**
- * Replacement interface for nsICharsetConverterManager.
- *
- * Here Charsets are indentified by nsIAtom's. I know, we could have our own 
- * interface for charsets (something like nsICharacterSet). But for now, I 
- * will attempt to use Atom's. That is because it requires minimal work, all 
- * the support stuff is already there. The drawback is that we might have some
- * performance loss from going to the Atom engine. Another possible problem is
- * people creating directly the Atom instead of going through GetCharsetAtom()
- * If these problems will hurt us, we'll switch to nsICharacterSet. The 
- * implementation of this interface is ment to be quite flexible.
- *
- * I provide here some nonscriptable "friendly methods". They accept nsString 
- * as params and assign the result to them, freeing the received memory result.
- * These methods are prone to optimisation, in order to elliminate any 
- * allocation when it is not strictly necessary.
- *
- * @created         21/Feb/2000
- * @author  Catalin Rotaru [CATA]
- */
-[scriptable, uuid(8BAFE891-E4CC-11d3-9D0D-0050040007B2)]
-interface nsICharsetConverterManager2 : nsISupports
-{
-  /**
-   * Get the Unicode decoder for the given charset.
-   */
-  [noscript] nsDecoderPtr GetUnicodeDecoder([const] in nsIAtom charset);
-
-  /**
-   * Get the Unicode encoder for the given charset.
-   */
-  [noscript] nsEncoderPtr GetUnicodeEncoder([const] in nsIAtom charset);
-
-  /**
-   * Get the complete list of available decoders.
-   */
-  nsISupportsArray GetDecoderList();
-
-  /**
-   * Get the complete list of available encoders.
-   */
-  nsISupportsArray GetEncoderList();
-
-  /**
-   * Get the complete list of available charset detectors.
-   */
-  nsISupportsArray GetCharsetDetectorList();
-
-  /**
-   * Get the Atom representing the a given character set. PLEASE USE THIS 
-   * METHOD!!! Do not create Atoms directly by going to NS_NewAtom(), because 
-   * here we also do alias resolution...
-   *
-   * Just to let you know, this method will first attempt to resolve this 
-   * charset as an alias. If that failed, the original string will be used.
-   * Then an atom is created and returned.
-   */
-  nsIAtom GetCharsetAtom([const] in wstring charset);
-
-  /**
-   * Friendlier version.
-   */
-  nsIAtom GetCharsetAtom2([const] in string charset);
-
-  /**
-   * Get the human-readable name for the given charset.
-   */
-  wstring GetCharsetTitle([const] in nsIAtom charset);
-
-  /**
-   * Friendlier but non scriptable version.
-   */
-  [noscript] void GetCharsetTitle2([const] in nsIAtom charset, 
-    in nsStringPtr str);
-
-  /**
-   * Get some data about the given charset.
-   */
-  wstring GetCharsetData([const] in nsIAtom charset, 
-    [const] in wstring prop);
-
-  /**
-   * Friendlier but non scriptable version.
-   */
-  [noscript] void GetCharsetData2([const] in nsIAtom charset, 
-    [const] in wstring prop, in nsStringPtr str);
-
-  /**
-   * Get the language group for the given charset.
-   */
-  nsIAtom GetCharsetLangGroup([const] in nsIAtom charset);
-};

mozilla/intl/uconv/idl/nsICurrentCharsetListener.idl

@@ -1,54 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-
-%{C++
-// {CF9428C1-DF50-11d3-9D0C-0050040007B2}
-#define NS_CURRENTCHARSETLISTENER_CID { 0xcf9428c1, 0xdf50, 0x11d3, { 0x9d, 0xc, 0x0, 0x50, 0x4, 0x0, 0x7, 0xb2 } }
-#define NS_ICURRENTCHARSETLISTENER_CONTRACTID "@mozilla.org/intl/currentcharsetlistener;1"
-%}
-
-[scriptable, uuid(CF9428C1-DF50-11d3-9D0C-0050040007B2)]
-interface nsICurrentCharsetListener : nsISupports
-{
-	void SetCurrentCharset(in wstring charset);
-	void SetCurrentMailCharset(in wstring charset);
-	void SetCurrentComposerCharset(in wstring charset);
-};

mozilla/intl/uconv/idl/nsIScriptableUConv.idl

@@ -1,70 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-%{C++
-// {0A698C44-3BFF-11d4-9649-00C0CA135B4E}
-#define NS_ISCRIPTABLEUNICODECONVERTER_CID { 0x0A698C44, 0x3BFF, 0x11d4, { 0x96, 0x49, 0x00, 0xC0, 0xCA, 0x13, 0x5B, 0x4E } }
-#define NS_ISCRIPTABLEUNICODECONVERTER_CONTRACTID "@mozilla.org/intl/scriptableunicodeconverter"
-%}
-
-/**
- * This interface is unicode encoder using from script
- *
- * @created         8/Jun/2000
- * @author          Makoto Kato [m_kato@ga2.so-net.ne.jp]
- */
-[scriptable, uuid(0A698C44-3BFF-11d4-9649-00C0CA135B4E)]
-interface nsIScriptableUnicodeConverter : nsISupports
-{
-  /**
-   * Converts the data from Unicode to one Charset.
-   */
-  string ConvertFromUnicode([const] in wstring aSrc);
-
-  /**
-   * Converts the data from one Charset to Unicode.
-   */
-  wstring ConvertToUnicode([const] in string aSrc);
-
-  /**
-   * Current charactor set
-   */
-  attribute wstring charset;
-};

mozilla/intl/uconv/idl/nsITextToSubURI.idl

@@ -1,53 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.idl"
-
-
-%{C++
-// {8B042E22-6F87-11d3-B3C8-00805F8A6670}
-#define NS_TEXTTOSUBURI_CID { 0x8b042e22, 0x6f87, 0x11d3, { 0xb3, 0xc8, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 } }
-#define NS_ITEXTTOSUBURI_CONTRACTID "@mozilla.org/intl/texttosuburi;1"
-%}
-
-[scriptable, uuid(8B042E24-6F87-11d3-B3C8-00805F8A6670)]
-interface nsITextToSubURI : nsISupports
-{
-	string ConvertAndEscape(in string charset, in wstring text);
-	wstring UnEscapeAndConvert(in string charset, in string text);
-};

mozilla/intl/uconv/macbuild/uconvSharedDebugPrefix.h

@@ -1,25 +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.org code.
- *
- * 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): 
- */
-
-#define _IMPL_NS_UCONV 1
-#define __STDC__
-#include "MacPrefix_debug.h"

mozilla/intl/uconv/macbuild/uconvSharedPrefix.h

@@ -1,25 +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.org code.
- *
- * 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): 
- */
-
-#define _IMPL_NS_UCONV 1
-#define __STDC__
-#include "MacSharedPrefix.h"

mozilla/intl/uconv/makefile.win

@@ -1,53 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-# IBM Corporation
-#
-# This Original Code has been modified by IBM Corporation.
-# Modifications made by IBM described herein are
-# Copyright (c) International Business Machines
-# Corporation, 1999
-#
-# Modifications to Mozilla code or documentation
-# identified per MPL Section 3.3
-#
-# Date         Modified by     Description of modification
-# 12/09/1999   IBM Corp.       Support for IBM codepages - 850,852,855,857,862,864
-
-DEPTH=..\..
-include <$(DEPTH)/config/config.mak>
-
-DIRS=idl public src  \
-     ucvlatin \
-!ifdef MOZ_MATHML
-     ucvmath \
-!endif
-     ucvibm \
-     ucvja \
-     ucvcn \
-     ucvtw \
-     ucvtw2 \
-     ucvko \
-!if !defined(DISABLE_TESTS)
-     tests \
-!endif
-     $(NULL)
-
-include <$(DEPTH)\config\rules.mak>

mozilla/intl/uconv/public/MANIFEST

@@ -1,11 +0,0 @@
-nsICharsetAlias.h
-nsICharsetConverterManager.h
-nsIPlatformCharset.h
-nsIUnicodeDecodeHelper.h
-nsIUnicodeDecoder.h
-nsIUnicodeEncodeHelper.h
-nsIUnicodeEncoder.h
-uconvutil.h
-nsIMappingCache.h
-nsICharRepresentable.h
-nsIConverterInputStream.h

mozilla/intl/uconv/public/Makefile.in

@@ -1,46 +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.org code.
-#
-# 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): 
-#
-
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= uconv
-
-EXPORTS		= \
-		nsICharsetAlias.h \
-		nsICharsetConverterManager.h \
-		nsIPlatformCharset.h \
-		nsIUnicodeDecodeHelper.h \
-		nsIUnicodeDecoder.h \
-		nsIUnicodeEncodeHelper.h \
-		nsIUnicodeEncoder.h \
-		nsICharRepresentable.h \
-		nsIMappingCache.h \
-		nsIConverterInputStream.h \
-		uconvutil.h \
-		$(NULL)
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/intl/uconv/public/makefile.win

@@ -1,41 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..
-
-EXPORTS =				\
-	nsICharsetAlias.h \
-	nsICharsetConverterManager.h \
-	nsIPlatformCharset.h \
-	nsIUnicodeDecodeHelper.h \
-	nsIUnicodeDecoder.h \
-	nsIUnicodeEncodeHelper.h \
-	nsIUnicodeEncoder.h \
-        nsIMappingCache.h \
-        nsICharRepresentable.h \
-	nsIConverterInputStream.h \
-	uconvutil.h \
-        $(NULL)
-
-MODULE=uconv 
-
-include <$(DEPTH)\config\rules.mak>
-

mozilla/intl/uconv/public/nsICharRepresentable.h

@@ -1,72 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsICharRepresentable_h__
-#define nsICharRepresentable_h__
-
-#include "nscore.h"
-#include "nsISupports.h"
-
-// {A4D9A521-185A-11d3-B3BD-00805F8A6670}
-#define NS_ICHARREPRESENTABLE_IID \
-{ 0xa4d9a521, 0x185a, 0x11d3, { 0xb3, 0xbd, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 } }
-
-
-/* 
-   The following two macro have been duplicate in umap.c. 
-   You need to change both place to make it work 
-*/
-#define IS_REPRESENTABLE(info, c) (((info)[(c) >> 5] >> ((c) & 0x1f)) & 1L)
-#define SET_REPRESENTABLE(info, c)  (info)[(c) >> 5] |= (1L << ((c) & 0x1f))
-#define CLEAR_REPRESENTABLE(info, c)  (info)[(c) >> 5] &= (~(1L << ((c) & 0x1f)))
-
-// number of PRUint32 in the 64Kbit char map
-#define UCS2_MAP_LEN 2048
-
-/**
- */
-class nsICharRepresentable : public nsISupports
-{
-public:
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICHARREPRESENTABLE_IID)
-
-  NS_IMETHOD FillInfo(PRUint32* aInfo) = 0;
-
-};
-
-#endif /* nsIUnicodeDecoder_h__ */

mozilla/intl/uconv/public/nsICharsetAlias.h

@@ -1,77 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsICharsetAlias_h___
-#define nsICharsetAlias_h___
-
-#include "nscore.h"
-#include "nsString.h"
-#include "nsISupports.h"
-
-// {CCD4D374-CCDC-11d2-B3B1-00805F8A6670}
-#define NS_ICHARSETALIAS_IID \
-{ 0xccd4d374, 0xccdc, 0x11d2, { 0xb3, 0xb1, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 }}
-static NS_DEFINE_IID(kICharsetAliasIID, NS_ICHARSETALIAS_IID);
-
-
-// {98D41C21-CCF3-11d2-B3B1-00805F8A6670}
-#define NS_CHARSETALIAS_CID \
-{ 0x98d41c21, 0xccf3, 0x11d2, { 0xb3, 0xb1, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 }}
-static NS_DEFINE_IID(kCharsetAliasCID, NS_CHARSETALIAS_CID);
-
-#define NS_CHARSETALIAS_CID \
-{ 0x98d41c21, 0xccf3, 0x11d2, { 0xb3, 0xb1, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 }}
-
-#define NS_CHARSETALIAS_CONTRACTID "@mozilla.org/intl/charsetalias;1"
-
-class nsICharsetAlias : public nsISupports
-{
-public:
-   NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICHARSETALIAS_IID)
-
-   NS_IMETHOD GetPreferred(const nsAString& aAlias, nsAString& aResult) = 0;
-   NS_IMETHOD GetPreferred(const PRUnichar* aAlias, const PRUnichar** aResult) = 0;
-   NS_IMETHOD GetPreferred(const char* aAlias, char* aResult, PRInt32 aBufLength) = 0;
-
-   NS_IMETHOD Equals(const nsAString& aCharset1, const nsAString& aCharset2, PRBool* aResult) = 0;
-   NS_IMETHOD Equals(const PRUnichar* aCharset1, const PRUnichar* aCharset2, PRBool* aResult) = 0;
-   NS_IMETHOD Equals(const char* aCharset1, const char* aCharset2, PRBool* aResult) = 0;
-
-};
-
-#endif /* nsICharsetAlias_h___ */

mozilla/intl/uconv/public/nsICharsetConverterManager.h

@@ -1,230 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *    Morten Nilsen <morten@nilsen.com>
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsICharsetConverterManager_h___
-#define nsICharsetConverterManager_h___
-
-#include "nsString.h"
-#include "nsError.h"
-#include "nsISupports.h"
-#include "nsIAtom.h"
-#include "nsIUnicodeEncoder.h"
-#include "nsIUnicodeDecoder.h"
-#include "nsICategoryManager.h"
-
-#define NS_ICHARSETCONVERTERMANAGER_IID \
-  {0x3c1c0161, 0x9bd0, 0x11d3, { 0x9d, 0x9, 0x0, 0x50, 0x4, 0x0, 0x7, 0xb2}}
-
-// XXX change to NS_CHARSETCONVERTERMANAGER_CID
-#define NS_ICHARSETCONVERTERMANAGER_CID \
-  {0x3c1c0163, 0x9bd0, 0x11d3, { 0x9d, 0x9, 0x0, 0x50, 0x4, 0x0, 0x7, 0xb2}}
-
-// XXX change to NS_CHARSETCONVERTERMANAGER_PID
-#define NS_CHARSETCONVERTERMANAGER_CONTRACTID "@mozilla.org/charset-converter-manager;1"
-
-#define NS_DATA_BUNDLE_CATEGORY     "uconv-charset-data"
-#define NS_TITLE_BUNDLE_CATEGORY    "uconv-charset-titles"
-
-#define NS_ERROR_UCONV_NOCONV \
-  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_UCONV, 0x01)
-
-#define NS_SUCCESS_USING_FALLBACK_LOCALE \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 0x02)
-
-#ifdef DEBUG
-#define REGSELF_PRINTF(x,y)                                             \
-  fprintf(stderr,"RegSelf %s to %s converter complete\n",                       \
-         x, y)                                                         
-#else
-#define REGSELF_PRINTF(x,y)
-#endif
-
-#define NS_UNICODEDECODER_NAME "Charset Decoders"
-#define NS_UNICODEENCODER_NAME "Charset Encoders"
-
-struct nsConverterRegistryInfo {
-  PRBool isEncoder;             // PR_TRUE = encoder, PR_FALSE = decoder
-  const char *charset;
-  nsCID cid;
-};
-
-#define NS_CONVERTER_REGISTRY_START \
-  static const nsConverterRegistryInfo gConverterRegistryInfo[] = {
-
-#define NS_CONVERTER_REGISTRY_END \
-  };
-
-
-#define NS_IMPL_NSUCONVERTERREGSELF                                     \
-static NS_IMETHODIMP                                                    \
-nsUConverterRegSelf(nsIComponentManager *aCompMgr,                      \
-                    nsIFile *aPath,                                     \
-                    const char* registryLocation,                       \
-                    const char* componentType,                          \
-                    const nsModuleComponentInfo *info)                  \
-{                                                                       \
-  nsresult rv;                                                          \
-  nsCOMPtr<nsICategoryManager> catman =                                 \
-    do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);                  \
-  if (NS_FAILED(rv)) return rv;                                         \
-                                                                        \
-  nsXPIDLCString previous;                                              \
-  PRUint32 i;                                                           \
-  for (i=0; i<sizeof(gConverterRegistryInfo)/sizeof(gConverterRegistryInfo[0]); i++) { \
-    const nsConverterRegistryInfo* entry = &gConverterRegistryInfo[i];         \
-    const char *category;                                               \
-    const char *key;                                                    \
-                                                                        \
-    if (entry->isEncoder) {                                             \
-      category = NS_UNICODEENCODER_NAME;                                \
-    } else {                                                            \
-      category = NS_UNICODEDECODER_NAME;                                \
-    }                                                                   \
-    key = entry->charset;                                               \
-                                                                        \
-    rv = catman->AddCategoryEntry(category, key, "",                    \
-                                  PR_TRUE,                              \
-                                  PR_TRUE,                              \
-                                  getter_Copies(previous));             \
-  }                                                                     \
-  return rv;                                                            \
-} \
-static NS_IMETHODIMP \
-nsUConverterUnregSelf(nsIComponentManager *aCompMgr,                        \
-                      nsIFile *aPath,                                       \
-                      const char*,                                          \
-                      const nsModuleComponentInfo *info)                    \
-{ \
-  nsresult rv;                                                          \
-  nsCOMPtr<nsICategoryManager> catman =                                 \
-  do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);                    \
-  if (NS_FAILED(rv)) return rv;                                         \
-                                                                        \
-  nsXPIDLCString previous;                                              \
-  PRUint32 i;                                                           \
-  for (i=0; i<sizeof(gConverterRegistryInfo)/sizeof(gConverterRegistryInfo[0]); i++) { \
-    const nsConverterRegistryInfo* entry = &gConverterRegistryInfo[i];         \
-    const char *category;                                               \
-    const char *key;                                                    \
-                                                                        \
-    if (entry->isEncoder) {                                             \
-      category = NS_UNICODEDECODER_NAME;                                \
-    } else {                                                            \
-      category = NS_UNICODEENCODER_NAME;                                \
-    }                                                                   \
-    key = entry->charset;                                               \
-                                                                        \
-    char * value = entry->cid.ToString();                               \
-                                                                        \
-    rv = catman->DeleteCategoryEntry(category, key, PR_TRUE);           \
-    CRTFREEIF(value);                                                   \
-  }                                                                     \
-  return rv;                                                            \
-}
-
-
-#define NS_UCONV_REG_UNREG_DECODER(_Charset, _CID)          \
-  {                                                         \
-    PR_FALSE,                                                \
-    _Charset,                                               \
-    _CID,                                                   \
-  },
-  
-#define NS_UCONV_REG_UNREG_ENCODER(_Charset, _CID)          \
-  {                                                         \
-    PR_TRUE,                                               \
-    _Charset,                                               \
-    _CID,                                                   \
-  }, 
-
-  // this needs to be written out per some odd cpp behavior that
-  // I could not work around - the behavior is document in the cpp
-  // info page however, so I'm not the only one to hit this!
-#define NS_UCONV_REG_UNREG(_Charset, _DecoderCID, _EncoderCID) \
-  {                                                         \
-    PR_FALSE,                                               \
-    _Charset,                                               \
-    _DecoderCID,                                            \
-  },                                                        \
-  {                                                         \
-    PR_TRUE,                                                \
-    _Charset,                                               \
-    _EncoderCID,                                            \
-  }, 
-
-  
-/**
- * Interface for a Manager of Charset Converters.
- * 
- * This Manager's data is a cache of the stuff available directly through 
- * Registry and Extensible String Bundles. Plus a set of convenient APIs.
- * 
- * Note: The term "Charset" used in the classes, interfaces and file names 
- * should be read as "Coded Character Set". I am saying "charset" only for 
- * length considerations: it is a much shorter word. This convention is for 
- * source-code only, in the attached documents I will be either using the 
- * full expression or I'll specify a different convention.
- *
- * A DECODER converts from a random encoding into Unicode.
- * An ENCODER converts from Unicode into a random encoding.
- * All our data structures and APIs are divided like that.
- * However, when you have a charset data, you may have 3 cases:
- * a) the data is charset-dependet, but it is common for encoders and decoders
- * b) the data is different for the two of them, thus needing different APIs
- * and different "aProp" identifying it.
- * c) the data is relevant only for one: encoder or decoder; its nature making 
- * the distinction.
- *
- * @created         15/Nov/1999
- * @author  Catalin Rotaru [CATA]
- */
-class nsICharsetConverterManager : public nsISupports
-{
-public:
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICHARSETCONVERTERMANAGER_IID)
-
-  NS_IMETHOD GetUnicodeEncoder(const nsString * aDest, 
-      nsIUnicodeEncoder ** aResult) = 0;
-  NS_IMETHOD GetUnicodeDecoder(const nsString * aSrc, 
-      nsIUnicodeDecoder ** aResult) = 0;
-
-  NS_IMETHOD GetCharsetLangGroup(nsString * aCharset, nsIAtom ** aResult) = 0;
-};
-
-#endif /* nsICharsetConverterManager_h___ */

mozilla/intl/uconv/public/nsIConverterInputStream.h

@@ -1,53 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or 
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsISupports.h"
-#include "nsIUnicharInputStream.h"
-
-// {FC66FFB6-5404-4908-A4A3-27F92FA0579D}
-#define NS_ICONVERTERSTREAM_IID \
-  { 0xfc66ffb6, 0x5404, 0x4908, \
-  { 0xa4, 0xa3, 0x27, 0xf9, 0x2f, 0xa0, 0x57, 0x9d } }
-
-class nsIConverterInputStream : public nsIUnicharInputStream {
- public:
-    NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICONVERTERSTREAM_IID)
-
-    NS_IMETHOD Init(nsIInputStream *aStream, const PRUnichar *aCharset,
-                    PRInt32 aBufferSize) = 0;
-};
-

mozilla/intl/uconv/public/nsIMappingCache.h

@@ -1,52 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsIMappingCache_h__
-#define nsIMappingCache_h__
-
-typedef void* nsIMappingCache;
-
-typedef enum {
-  kMappingCacheType64 =  0x003F,
-  kMappingCacheType128 = 0x007F,
-  kMappingCacheType256 = 0x00FF,
-  kMappingCacheType512 = 0x01FF
-} nsMappingCacheType;
-
-
-#endif /* nsIMappingCache_h__ */

mozilla/intl/uconv/public/nsIPlatformCharset.h

@@ -1,77 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsIPlatformCharset_h__
-#define nsIPlatformCharset_h__
-
-#include "nsString.h"
-#include "nsISupports.h"
-
-// Interface ID for our nsIPlatformCharset interface
-
-#define NS_IPLATFORMCHARSET_IID \
-{ 0x84b0f181, 0xc6c7, 0x11d2, {0xb3, 0xb0, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 }}
-
-#define NS_PLATFORMCHARSET_CID \
-{ 0x84b0f182, 0xc6c7, 0x11d2, {0xb3, 0xb0, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 }}
-
-#define NS_PLATFORMCHARSET_CONTRACTID "@mozilla.org/intl/platformcharset;1"
-
-typedef enum {
-     kPlatformCharsetSel_PlainTextInClipboard = 0,
-     kPlatformCharsetSel_FileName = 1,
-     kPlatformCharsetSel_Menu = 2,
-     kPlatformCharsetSel_4xBookmarkFile = 3,
-     kPlatformCharsetSel_KeyboardInput = 4,
-     kPlatformCharsetSel_WindowManager = 5,
-     kPlatformCharsetSel_4xPrefsJS = 6
-} nsPlatformCharsetSel;
-
-class nsIPlatformCharset : public nsISupports
-{
-public:
- 
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IPLATFORMCHARSET_IID)
-
-  NS_IMETHOD GetCharset(nsPlatformCharsetSel selector, nsAString& oResult) = 0;
-
-  NS_IMETHOD GetDefaultCharsetForLocale(const PRUnichar* localeName, PRUnichar** _retValue) = 0;
-
-};
-
-#endif /* nsIPlatformCharset_h__ */

mozilla/intl/uconv/public/nsIUnicodeDecodeHelper.h

@@ -1,118 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsIUnicodeDecodeHelper_h___
-#define nsIUnicodeDecodeHelper_h___
-
-#include "nscore.h"
-#include "uconvutil.h"
-#include "nsISupports.h"
-#include "nsIMappingCache.h"
-
-// Interface ID for our Unicode Decode Helper interface
-// {9CC39FF0-DD5D-11d2-8AAC-00600811A836}
-#define NS_IUNICODEDECODEHELPER_IID \
-{ 0x9cc39ff0, 0xdd5d, 0x11d2, {0x8a, 0xac, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36}}
-
-// Class ID for our UnicodeDecoderHelper implementation
-// {9CC39FF1-DD5D-11d2-8AAC-00600811A836}
-#define NS_UNICODEDECODEHELPER_CID \
-{  0x9cc39ff1, 0xdd5d, 0x11d2, {0x8a, 0xac, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36}}
-
-#define NS_UNICODEDECODEHELPER_CONTRACTID "@mozilla.org/intl/unicode/decodehelper;1"
-
-#define NS_ERROR_UDEC_NOHELPER  \
-  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_UCONV, 0x41)
-
-//----------------------------------------------------------------------
-// Class nsIUnicodeDecodeHelper [declaration]
-
-/**
- * Interface for a Unicode Decode Helper object.
- * 
- * @created         22/Feb/1999
- * @author  Catalin Rotaru [CATA]
- */
-class nsIUnicodeDecodeHelper : public nsISupports
-{
-public:
-   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IUNICODEDECODEHELPER_IID)
-
-  /**
-   * Converts data using a lookup table.
-   */
-  NS_IMETHOD ConvertByTable(const char * aSrc, PRInt32 * aSrcLength, 
-      PRUnichar * aDest, PRInt32 * aDestLength, uShiftTable * aShiftTable, 
-      uMappingTable * aMappingTable) = 0;
-
-  /**
-   * Converts data using a set of lookup tables.
-   */
-  NS_IMETHOD ConvertByMultiTable(const char * aSrc, PRInt32 * aSrcLength, 
-      PRUnichar * aDest, PRInt32 * aDestLength, PRInt32 aTableCount, 
-      uRange * aRangeArray, uShiftTable ** aShiftTable, 
-      uMappingTable ** aMappingTable) = 0;
-
-  /**
-   * Converts data using a fast lookup table.
-   */
-  NS_IMETHOD ConvertByFastTable(const char * aSrc, PRInt32 * aSrcLength, 
-      PRUnichar * aDest, PRInt32 * aDestLength, PRUnichar * aFastTable, 
-      PRInt32 aTableSize) = 0;
-
-  /**
-   * Create a Mapping Cache
-   */
-
-  NS_IMETHOD CreateCache(nsMappingCacheType aType, nsIMappingCache* aResult) = 0;
-  /**
-   * Destroy a Mapping Cache
-   */
-
-  NS_IMETHOD DestroyCache(nsIMappingCache aCache) = 0;
-
-
-  /**
-   * Create a cache-like fast lookup table from a normal one.
-   */
-  NS_IMETHOD CreateFastTable( uShiftTable * aShiftTable, 
-      uMappingTable * aMappingTable, PRUnichar * aFastTable, 
-      PRInt32 aTableSize) = 0;
-};
-
-#endif /* nsIUnicodeDecodeHelper_h___ */

mozilla/intl/uconv/public/nsIUnicodeDecoder.h

@@ -1,172 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsIUnicodeDecoder_h___
-#define nsIUnicodeDecoder_h___
-
-#include "nscore.h"
-#include "nsISupports.h"
-
-// Interface ID for our Unicode Decoder interface
-// {B2F178E1-832A-11d2-8A8E-00600811A836}
-//NS_DECLARE_ID(kIUnicodeDecoderIID,
-//  0xb2f178e1, 0x832a, 0x11d2, 0x8a, 0x8e, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36);
-
-#define NS_IUNICODEDECODER_IID	\
-	{ 0xb2f178e1, 0x832a, 0x11d2,	\
-		{ 0x8a, 0x8e, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36 }}
-static NS_DEFINE_IID(kIUnicodeDecoderIID, NS_IUNICODEDECODER_IID);
-
-// XXX deprecated
-/*---------- BEGIN DEPRECATED */ 
-#define NS_EXACT_LENGTH \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 11)
-
-#define NS_PARTIAL_MORE_INPUT \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 12)
-
-#define NS_PARTIAL_MORE_OUTPUT \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 13)
-
-#define NS_ERROR_ILLEGAL_INPUT \
-  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_UCONV, 14)
-/*---------- END DEPRECATED */ 
-
-// XXX make us hex! (same digits though)
-#define NS_OK_UDEC_EXACTLENGTH      \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 11)
-
-#define NS_OK_UDEC_MOREINPUT        \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 12)
-
-#define NS_OK_UDEC_MOREOUTPUT       \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 13)
-
-#define NS_ERROR_UDEC_ILLEGALINPUT  \
-  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_UCONV, 14)
-
-
-#define NS_UNICODEDECODER_CONTRACTID_BASE "@mozilla.org/intl/unicode/decoder;1?charset="
-
-/**
- * Interface for a Converter from a Charset into Unicode.
- *
- * @created         23/Nov/1998
- * @author  Catalin Rotaru [CATA]
- */
-class nsIUnicodeDecoder : public nsISupports
-{
-public:
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IUNICODEDECODER_IID)
-
-  enum {
-    kOnError_Recover,       // on an error, recover and continue
-    kOnError_Signal         // on an error, stop and signal
-  };
-
-  /**
-   * Converts the data from one Charset to Unicode.
-   *
-   * About the byte ordering:
-   * - For input, if the converter cares (that depends of the charset, for 
-   * example a singlebyte will ignore the byte ordering) it should assume 
-   * network order. If necessary and requested, we can add a method 
-   * SetInputByteOrder() so that the reverse order can be used, too. That 
-   * method would have as default the assumed network order.
-   * - The output stream is Unicode, having the byte order which is internal
-   * for the machine on which the converter is running on.
-   *
-   * Unless there is not enough output space, this method must consume all the
-   * available input data! The eventual incomplete final character data will be
-   * stored internally in the converter and used when the method is called 
-   * again for continuing the conversion. This way, the caller will not have to
-   * worry about managing incomplete input data by mergeing it with the next 
-   * buffer.
-   *
-   * Error conditions: 
-   * If the read value does not belong to this character set, one should 
-   * replace it with the Unicode special 0xFFFD. When an actual input error is 
-   * encountered, like a format error, the converter stop and return error.
-   * Hoever, we should keep in mind that we need to be lax in decoding.
-   *
-   * Converter required behavior:
-   * In this order: when output space is full - return right away. When input
-   * data is wrong, return input pointer right after the wrong byte. When 
-   * partial input, it will be consumed and cached. All the time input pointer
-   * will show how much was actually consumed and how much was actually 
-   * written.
-   *
-   * @param aSrc        [IN] the source data buffer
-   * @param aSrcLength  [IN/OUT] the length of source data buffer; after
-   *                    conversion will contain the number of bytes read
-   * @param aDest       [OUT] the destination data buffer
-   * @param aDestLength [IN/OUT] the length of the destination data buffer;
-   *                    after conversion will contain the number of Unicode
-   *                    characters written
-   * @return            NS_PARTIAL_MORE_INPUT if only a partial conversion was
-   *                    done; more input is needed to continue
-   *                    NS_PARTIAL_MORE_OUTPUT if only  a partial conversion
-   *                    was done; more output space is needed to continue
-   *                    NS_ERROR_ILLEGAL_INPUT if an illegal input sequence
-   *                    was encountered and the behavior was set to "signal"
-   */
-  NS_IMETHOD Convert(const char * aSrc, PRInt32 * aSrcLength, 
-      PRUnichar * aDest, PRInt32 * aDestLength) = 0;
-
-  /**
-   * Returns a quick estimation of the size of the buffer needed to hold the
-   * converted data. Remember: this estimation is >= with the actual size of 
-   * the buffer needed. It will be computed for the "worst case"
-   *
-   * @param aSrc        [IN] the source data buffer
-   * @param aSrcLength  [IN] the length of source data buffer
-   * @param aDestLength [OUT] the needed size of the destination buffer
-   * @return            NS_EXACT_LENGTH if an exact length was computed
-   *                    NS_OK is all we have is an approximation
-   */
-  NS_IMETHOD GetMaxLength(const char * aSrc, PRInt32 aSrcLength, 
-      PRInt32 * aDestLength) = 0;
-
-  /**
-   * Resets the charset converter so it may be recycled for a completely 
-   * different and urelated buffer of data.
-   */
-  NS_IMETHOD Reset() = 0;
-};
-
-#endif /* nsIUnicodeDecoder_h___ */

mozilla/intl/uconv/public/nsIUnicodeEncodeHelper.h

@@ -1,111 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsIUnicodeEncodeHelper_h___
-#define nsIUnicodeEncodeHelper_h___
-
-#include "nscore.h"
-#include "uconvutil.h"
-#include "nsISupports.h"
-#include "nsIMappingCache.h"
-
-// Interface ID for our Unicode Encode Helper interface
-// {D8E6B700-CA9D-11d2-8AA9-00600811A836}
-#define NS_IUNICODEENCODEHELPER_IID \
-{ 0xd8e6b700, 0xca9d, 0x11d2, {0x8a, 0xa9, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36}}
-
-// Class ID for our UnicodeEncoderHelper implementation
-// {1767FC50-CAA4-11d2-8AA9-00600811A836}
-#define NS_UNICODEENCODEHELPER_CID \
-{ 0x1767fc50, 0xcaa4, 0x11d2, {0x8a, 0xa9, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36}}
-
-
-#define NS_UNICODEENCODEHELPER_CONTRACTID "@mozilla.org/intl/unicode/encodehelper;1"
-
-#define NS_ERROR_UENC_NOHELPER  \
-  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_UCONV, 0x31)
-
-//----------------------------------------------------------------------
-// Class nsIUnicodeEncodeHelper [declaration]
-
-/**
- * Interface for a Unicode Encode Helper object.
- * 
- * @created         22/Feb/1999
- * @author  Catalin Rotaru [CATA]
- */
-class nsIUnicodeEncodeHelper : public nsISupports
-{
-public:
-
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IUNICODEENCODEHELPER_IID)
-
-  /**
-   * Converts data using a lookup table.
-   */
-  NS_IMETHOD ConvertByTable(const PRUnichar * aSrc, PRInt32 * aSrcLength, 
-      char * aDest, PRInt32 * aDestLength, uShiftTable * aShiftTable, 
-      uMappingTable  * aMappingTable) = 0;
-
-  /**
-   * Converts data using a set of lookup tables.
-   */
-  NS_IMETHOD ConvertByMultiTable(const PRUnichar * aSrc, PRInt32 * aSrcLength,
-      char * aDest, PRInt32 * aDestLength, PRInt32 aTableCount, 
-      uShiftTable ** aShiftTable, uMappingTable  ** aMappingTable) = 0;
-
-  /**
-   * Create a Mapping Cache
-   */
-  NS_IMETHOD CreateCache(nsMappingCacheType aType, nsIMappingCache* aResult) = 0;
-
-  /**
-   * Destroy a Mapping Cache
-   */
-  NS_IMETHOD DestroyCache(nsIMappingCache aCache) = 0;
-  
-  /**
-   * Create Char Representable Info
-   */
-  NS_IMETHOD FillInfo(PRUint32* aInfo, uMappingTable  * aMappingTable) = 0;
-  NS_IMETHOD FillInfo(PRUint32* aInfo, PRInt32 aTableCount, uMappingTable  ** aMappingTable) = 0;
-};
-
-
-
-#endif /* nsIUnicodeEncodeHelper_h___ */

mozilla/intl/uconv/public/nsIUnicodeEncoder.h

@@ -1,222 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsIUnicodeEncoder_h___
-#define nsIUnicodeEncoder_h___
-
-#include "nscore.h"
-#include "nsError.h"
-#include "nsISupports.h"
-
-// Interface ID for our Unicode Encoder interface
-// {2B2CA3D0-A4C9-11d2-8AA1-00600811A836}
-#define NS_IUNICODEENCODER_IID \
-	{ 0x2b2ca3d0, 0xa4c9, 0x11d2, \
-		{ 0x8a, 0xa1, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36 }}  
-static NS_DEFINE_IID(kIUnicodeEncoderIID, NS_IUNICODEENCODER_IID);
-
-// Interface ID for our Unicode Character Encoder interface
-// {299BCCD0-C6DF-11d2-8AA8-00600811A836}
-#define NS_IUNICHARENCODER_IID	\
-	{ 0x299bccd0, 0xc6df, 0x11d2, \
-		{0x8a, 0xa8, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36 }}
-static NS_DEFINE_IID(kIUnicharEncoderIID, NS_IUNICHARENCODER_IID);
-
-#define NS_OK_UENC_EXACTLENGTH      \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 0x21)
-
-#define NS_OK_UENC_MOREOUTPUT       \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 0x22)
-
-#define NS_ERROR_UENC_NOMAPPING     \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 0x23)
-
-#define NS_OK_UENC_MOREINPUT       \
-  NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_UCONV, 0x24)
-
-
-#define NS_UNICODEENCODER_CONTRACTID_BASE "@mozilla.org/intl/unicode/encoder;1?charset="
-
-/**
- * Interface which converts a single character from Unicode into a given 
- * charset.
- *
- * @created         17/Feb/1999
- * @author  Catalin Rotaru [CATA]
- */
-class nsIUnicharEncoder : public nsISupports
-{
-public:
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IUNICHARENCODER_IID)
-
-  /**
-   * Converts a character from Unicode to a Charset.
-   */
-  NS_IMETHOD Convert(PRUnichar aChar, char * aDest, PRInt32 * aDestLength) = 0;
-};
-
-//
-// Malloc an Encoder (unicode -> charset) buffer if the
-// result won't fit in the static buffer
-//
-//    p = the buffer pointer   (char*)
-//    e = encoder              (nsIUnicodeEncoder*)
-//    s = string               (PRUnichar*)
-//    l = string length        (PRInt32)
-//   sb = static buffer        (char[])
-//  sbl = static buffer length (PRUint32)
-//   al = actual buffer length (PRInt32)
-//
-#define ENCODER_BUFFER_ALLOC_IF_NEEDED(p,e,s,l,sb,sbl,al) \
-  PR_BEGIN_MACRO                                          \
-    if (e                                                 \
-        && NS_SUCCEEDED((e)->GetMaxLength((s), (l), &(al)))\
-        && ((al) > (PRInt32)(sbl))                        \
-        && (nsnull!=((p)=(char*)nsMemory::Alloc((al)+1))) \
-        ) {                                               \
-    }                                                     \
-    else {                                                \
-      (p) = (char*)(sb);                                  \
-      (al) = (sbl);                                       \
-    }                                                     \
-  PR_END_MACRO 
-
-//
-// Free the Encoder buffer if it was allocated
-//
-#define ENCODER_BUFFER_FREE_IF_NEEDED(p,sb) \
-  PR_BEGIN_MACRO                            \
-    if ((p) != (char*)(sb))                 \
-      nsMemory::Free(p);                    \
-  PR_END_MACRO 
-
-/**
- * Interface for a Converter from Unicode into a Charset.
- *
- * @created         23/Nov/1998
- * @author  Catalin Rotaru [CATA]
- */
-class nsIUnicodeEncoder : public nsISupports
-{
-public:
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IUNICODEENCODER_IID)
-
-  enum {
-    kOnError_Signal,        // on an error, stop and signal
-    kOnError_CallBack,      // on an error, call the error handler
-    kOnError_Replace       // on an error, replace with a different character
-  };
-
-  /**
-   * Converts the data from Unicode to a Charset.
-   *
-   * About the byte ordering:
-   * - The input stream is Unicode, having the byte order which is internal
-   * for the machine on which the converter is running on.
-   * - For output, if the converter cares (that depends of the charset, for 
-   * example a singlebyte will ignore the byte ordering) it should assume 
-   * network order. If necessary and requested, we can add a method 
-   * SetOutputByteOrder() so that the reverse order can be used, too. That 
-   * method would have as default the assumed network order.
-   *
-   * Unless there is not enough output space, this method must consume all the
-   * available input data! We don't have partial input for the Unicode charset.
-   * And for the last converted char, even if there is not enought output 
-   * space, a partial ouput must be done until all available space will be 
-   * used. The rest of the output should be buffered until more space becomes
-   * available. But this is not also true about the error handling method!!!
-   * So be very, very careful...
-   *
-   * @param aSrc        [IN] the source data buffer
-   * @param aSrcLength  [IN/OUT] the length of source data buffer; after
-   *                    conversion will contain the number of Unicode 
-   *                    characters read
-   * @param aDest       [OUT] the destination data buffer
-   * @param aDestLength [IN/OUT] the length of the destination data buffer;
-   *                    after conversion will contain the number of bytes
-   *                    written
-   * @return            NS_OK_UENC_MOREOUTPUT if only  a partial conversion
-   *                    was done; more output space is needed to continue
-   *                    NS_ERROR_UENC_NOMAPPING if character without mapping
-   *                    was encountered and the behavior was set to "signal".
-   */
-  NS_IMETHOD Convert(const PRUnichar * aSrc, PRInt32 * aSrcLength, 
-      char * aDest, PRInt32 * aDestLength) = 0;
-
-  /**
-   * Finishes the conversion. The converter has the possibility to write some 
-   * extra data and flush its final state.
-   *
-   * @param aDest       [OUT] the destination data buffer
-   * @param aDestLength [IN/OUT] the length of destination data buffer; after
-   *                    conversion it will contain the number of bytes written
-   * @return            NS_OK_UENC_MOREOUTPUT if only  a partial conversion
-   *                    was done; more output space is needed to continue
-   */
-  NS_IMETHOD Finish(char * aDest, PRInt32 * aDestLength) = 0;
-
-  /**
-   * Returns a quick estimation of the size of the buffer needed to hold the
-   * converted data. Remember: this estimation is >= with the actual size of 
-   * the buffer needed. It will be computed for the "worst case"
-   *
-   * @param aSrc        [IN] the source data buffer
-   * @param aSrcLength  [IN] the length of source data buffer
-   * @param aDestLength [OUT] the needed size of the destination buffer
-   * @return            NS_OK_UENC_EXACTLENGTH if an exact length was computed
-   *                    NS_OK if all we have is an approximation
-   */
-  NS_IMETHOD GetMaxLength(const PRUnichar * aSrc, PRInt32 aSrcLength, 
-      PRInt32 * aDestLength) = 0;
-
-  /**
-   * Resets the charset converter so it may be recycled for a completely 
-   * different and urelated buffer of data.
-   */
-  NS_IMETHOD Reset() = 0;
-
-  /**
-   * Specify what to do when a character cannot be mapped into the dest charset
-   *
-   * @param aOrder      [IN] the behavior; taken from the enum
-   */
-  NS_IMETHOD SetOutputErrorBehavior(PRInt32 aBehavior, 
-      nsIUnicharEncoder * aEncoder, PRUnichar aChar) = 0;
-};
-
-#endif /* nsIUnicodeEncoder_h___ */

mozilla/intl/uconv/public/uconvutil.h

@@ -1,120 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   jeroen.dobbelaere@acunia.com
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-#ifndef __UCONV_TIL_H__
-#define __UCONV_TIL_H__
-
-#include "prcpucfg.h"
-
-
-/*=====================================*/
-#define PACK(h,l)   (int16)(( (h) << 8) | (l))
-
-#if defined(IS_LITTLE_ENDIAN)
-#define ShiftCell(sub,len,min,max,minh,minl,maxh,maxl)  \
-    PACK(len,sub), PACK(max,min), PACK(minl,minh), PACK(maxl,maxh)
-#else
-#define ShiftCell(sub,len,min,max,minh,minl,maxh,maxl)  \
-    PACK(sub,len), PACK(min, max), PACK(minh,minl), PACK(maxh,maxl)
-#endif
-
-typedef enum {
-        u1ByteCharset = 0,
-        u2BytesCharset,
-        uMultibytesCharset,
-        u2BytesGRCharset,
-        u2BytesGRPrefix8FCharset,
-        u2BytesGRPrefix8EA2Charset,
-        u2BytesSwapCharset,
-        u4BytesCharset,
-        u4BytesSwapCharset,
-        u2BytesGRPrefix8EA3Charset,
-        u2BytesGRPrefix8EA4Charset,
-        u2BytesGRPrefix8EA5Charset,
-        u2BytesGRPrefix8EA6Charset,
-        u2BytesGRPrefix8EA7Charset,
-        u1ByteGLCharset,
-        uDecomposedHangulCharset,
-        uDecomposedHangulGLCharset,
-        uJohabHangulCharset,
-        uJohabSymbolCharset,
-        u4BytesGB18030Charset,
-        u2BytesGR128Charset,
-        uNumOfCharsetType
-} uScanClassID;
-
-typedef enum {
-        u1ByteChar                      = 0,
-        u2BytesChar,
-        u2BytesGRChar,
-        u1BytePrefix8EChar,             /* Used by JIS0201 GR in EUC_JP */
-        u2BytesUTF8,                    /* Used by UTF8 */
-        u3BytesUTF8,                    /* Used by UTF8 */
-        uNumOfCharType
-} uScanSubClassID;
-
-typedef struct  {
-        unsigned char   classID;
-        unsigned char   reserveLen;
-        unsigned char   shiftin_Min;
-        unsigned char   shiftin_Max;
-        unsigned char   shiftout_MinHB;
-        unsigned char   shiftout_MinLB;
-        unsigned char   shiftout_MaxHB;
-        unsigned char   shiftout_MaxLB;
-} uShiftCell;
-
-typedef struct  {
-        PRInt16         numOfItem;
-        PRInt16         classID; 
-        uShiftCell      shiftcell[1];
-} uShiftTable;
-
-/*=====================================*/
-
-typedef struct {
-        unsigned char min;
-        unsigned char max;
-} uRange;
-
-/*=====================================*/
-
-typedef PRUint16* uMappingTable; 
- 
-#endif
-

mozilla/intl/uconv/src/8859-1.uf

@@ -1,72 +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.org code.
- *
- * 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): 
- */
-/*========================================================
-  This is a Generated file. Please don't edit it.
-
-  The tool which used to generate this file is called fromu.
-  If you have any problem of this file. Please contact 
-  Netscape Client International Team or 
-  ftang@netscape <Frank Tang> 
-
-              Table in Debug form 
-Begin of Item 0000
- Format 0
-  srcBegin = 0000
-  srcEnd = 007E
-  destBegin = 0000
-End of Item 0000 
-
-Begin of Item 0001
- Format 0
-  srcBegin = 00A0
-  srcEnd = 00FF
-  destBegin = 00A0
-End of Item 0001 
-
-========================================================*/
-/* Offset=0x0000  ItemOfList */
-  0x0002,
-/*-------------------------------------------------------*/
-/* Offset=0x0001  offsetToFormatArray */
-  0x0004,
-/*-------------------------------------------------------*/
-/* Offset=0x0002  offsetToMapCellArray */ 
-  0x0005,
-/*-------------------------------------------------------*/
-/* Offset=0x0003  offsetToMappingTable */ 
-  0x000B,
-/*-------------------------------------------------------*/
-/*       Offset=0x0004   Start of Format Array */ 
-/*	Total of Format 0 : 0x0002			 */
-/*	Total of Format 1 : 0x0000			 */
-/*	Total of Format 2 : 0x0000			 */
-/*	Total of Format 3 : 0x0000			 */
-
-0x0000, 
-/*-------------------------------------------------------*/
-/*       Offset=0x0005   Start of MapCell Array */ 
-/* 0000 */    0x0000, 0x007E, 0x0000, 
-/* 0001 */    0x00A0, 0x00FF, 0x00A0, 
-/*-------------------------------------------------------*/
-/*       Offset=0x000B   Start of MappingTable */ 
-
-/*	End of table Total Length = 0x000B * 2 */

mozilla/intl/uconv/src/8859-1.ut

@@ -1,88 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-/*========================================================
-  This is a Generated file. Please don't edit it.
-
-  The tool which used to generate this file is called fromu.
-  If you have any problem of this file. Please contact 
-  Netscape Client International Team or 
-  ftang@netscape <Frank Tang> 
-
-              Table in Debug form 
-Begin of Item 0000
- Format 0
-  srcBegin = 0000
-  srcEnd = 007E
-  destBegin = 0000
-End of Item 0000 
-
-Begin of Item 0001
- Format 0
-  srcBegin = 00A0
-  srcEnd = 00FF
-  destBegin = 00A0
-End of Item 0001 
-
-========================================================*/
-/* Offset=0x0000  ItemOfList */
-  0x0002,
-/*-------------------------------------------------------*/
-/* Offset=0x0001  offsetToFormatArray */
-  0x0004,
-/*-------------------------------------------------------*/
-/* Offset=0x0002  offsetToMapCellArray */ 
-  0x0005,
-/*-------------------------------------------------------*/
-/* Offset=0x0003  offsetToMappingTable */ 
-  0x000B,
-/*-------------------------------------------------------*/
-/*       Offset=0x0004   Start of Format Array */ 
-/*	Total of Format 0 : 0x0002			 */
-/*	Total of Format 1 : 0x0000			 */
-/*	Total of Format 2 : 0x0000			 */
-/*	Total of Format 3 : 0x0000			 */
-
-0x0000, 
-/*-------------------------------------------------------*/
-/*       Offset=0x0005   Start of MapCell Array */ 
-/* 0000 */    0x0000, 0x007E, 0x0000, 
-/* 0001 */    0x00A0, 0x00FF, 0x00A0, 
-/*-------------------------------------------------------*/
-/*       Offset=0x000B   Start of MappingTable */ 
-
-/*	End of table Total Length = 0x000B * 2 */

mozilla/intl/uconv/src/Makefile.in

@@ -1,166 +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.org code.
-#
-# 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): 
-#
-
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= uconv
-LIBRARY_NAME	= uconv
-EXPORT_LIBRARY = 1
-IS_COMPONENT	= 1
-MODULE_NAME	= nsUConvModule
-
-ifneq ($(OS_ARCH),WINNT)
-# To avoid conflict with OS/2 system uconv.dll
-SHORT_LIBNAME  = mozuconv
-endif
-REQUIRES	= xpcom \
-		  string \
-		  intl \
-		  locale \
-		  unicharutil \
-		  chardet \
-		  $(NULL)
-
-CSRCS		= \
-		ugen.c \
-		uscan.c \
-		umap.c \
-		$(NULL)
-
-CPPSRCS		= \
-		nsCharsetConverterManager.cpp \
-		nsTextToSubURI.cpp \
-		nsUnicodeDecodeHelper.cpp \
-		nsUnicodeEncodeHelper.cpp \
-		nsCharsetAliasImp.cpp \
-		nsURLProperties.cpp \
-		nsMappingCache.cpp \
-		nsUConvModule.cpp \
-		nsISO88591ToUnicode.cpp \
-		nsCP1252ToUnicode.cpp \
-		nsMacRomanToUnicode.cpp \
-		nsUTF8ToUnicode.cpp \
-		nsUnicodeToISO88591.cpp \
-		nsUnicodeToCP1252.cpp \
-		nsUnicodeToMacRoman.cpp \
-		nsUnicodeToUTF8.cpp \
-		nsScriptableUConv.cpp \
-		nsConverterInputStream.cpp \
-		$(NULL)
-
-EXPORT_RESOURCE	= \
-		charsetalias.properties \
-		charsetData.properties \
-		$(NULL)
-
-ifeq ($(MOZ_WIDGET_TOOLKIT),os2)
-CPPSRCS			+= nsOS2Charset.cpp
-EXPORT_RESOURCE		+= os2charset.properties
-else
-ifeq ($(MOZ_WIDGET_TOOLKIT),windows)
-CPPSRCS			+= nsWinCharset.cpp
-EXPORT_RESOURCE		+= wincharset.properties
-else
-ifneq (,$(filter cocoa mac, $(MOZ_WIDGET_TOOLKIT)))
-CPPSRCS			+= nsMacCharset.cpp
-EXPORT_RESOURCE		+= maccharset.properties
-else
-CPPSRCS			+= nsUNIXCharset.cpp
-EXPORT_RESOURCE		+= unixcharset.properties
-# add platform charset remapping properties files here if necessary
-# (see unixcharset.sample.properties for an example file)
-# eg: if we needed a charset remap for OSARCH=Linux then add the following line:
-#EXPORT_RESOURCE		+= unixcharset.Linux.properties
-endif
-endif
-endif
-
-EXTRA_DSO_LDOPTS = $(MOZ_NECKO_UTIL_LIBS) \
-		$(MOZ_COMPONENT_LIBS) \
-		$(MOZ_UNICHARUTIL_LIBS) \
-		$(NULL)
-
-ifeq ($(MOZ_WIDGET_TOOLKIT),os2)
-ifeq ($(MOZ_OS2_TOOLS),VACPP)
-OS_LIBS += libuls.lib
-else
-OS_LIBS += -llibuni
-endif
-endif
-
-ifneq (,$(filter cocoa mac, $(MOZ_WIDGET_TOOLKIT)))
-EXTRA_DSO_LDOPTS += $(TK_LIBS)
-endif
-
-LOCAL_INCLUDES	= -I$(srcdir)/../util \
-				-I$(srcdir)/../ucvlatin \
-				-I$(srcdir)/../ucvibm \
-				-I$(srcdir)/../ucvja \
-				-I$(srcdir)/../ucvtw2 \
-				-I$(srcdir)/../ucvtw \
-				-I$(srcdir)/../ucvko \
-				-I$(srcdir)/../ucvcn \
-				$(NULL)
-
-SHARED_LIBRARY_LIBS = \
-	$(DIST)/lib/$(LIB_PREFIX)ucvutil_s.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)ucvlatin_s.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)ucvibm_s.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)ucvutil_s.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)ucvja_s.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)ucvtw2_s.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)ucvtw_s.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)ucvko_s.$(LIB_SUFFIX) \
-	$(DIST)/lib/$(LIB_PREFIX)ucvcn_s.$(LIB_SUFFIX) \
-	$(NULL)
-
-include $(topsrcdir)/config/rules.mk
-
-CFLAGS		+= -DUSE_NSREG -D_IMPL_NS_INTL
-
-# Reserved name __STDC__ cannot be defined as a macro name on AIX or OpenVMS.
-# QNX simply objects to the way it's being redefined.
-ifeq (,$(filter AIX OpenVMS QNX HP-UX,$(OS_ARCH)))
-CFLAGS		+= -D__STDC__
-endif
-
-# CODESET is not automatically defined on some older versions of Redhat.
-# Define _XOPEN_SOURCE so CODESET will get defined and thus allow 
-# nl_langinfo(CODESET) to compile on these systems.
-ifeq ($(OS_ARCH), Linux)
-DEFINES         += -D_XOPEN_SOURCE=500
-endif
-
-ifeq ($(OS_ARCH),WINNT)
-DEFINES		+= -DWIN32_LEAN_AND_MEAN
-endif
-
-libs:: $(EXPORT_RESOURCE)
-	$(INSTALL) $^ $(DIST)/bin/res
-
-install:: $(EXPORT_RESOURCE)
-	$(SYSINSTALL) $(IFLAGS1) $^ $(DESTDIR)$(mozappdir)/res 
-

mozilla/intl/uconv/src/charsetData.properties

@@ -1,149 +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.org code.
-##
-## 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): 
-
-## Rule of this file:
-## 1. key should always be in lower case ascii so we can do case insensitive
-##    comparison in the code faster.
-
-## Format of this file:
-##
-## charset_name.notForBrowser = anything  -  specifies that this charset is 
-## not to be used in the browser
-##
-## charset_name.LangGroup = 
-##
-## charset_name.MIMEHeaderEncodingMethod =
-##
-## charset_name.MIMEMailCharset =
-##
-## charset_name.isMultibyte = multi byte charsets
-
-t.61-8bit.notForBrowser             = true
-utf-32le.notForBrowser              = true
-utf-32be.notForBrowser              = true
-utf-16le.notForBrowser              = true
-utf-16be.notForBrowser              = true
-x-imap4-modified-utf7.notForBrowser = true
-x-u-escaped.notForBrowser           = true
-windows-936.notForBrowser           = true
-us-ascii.notForBrowser                  = true
-x-obsoleted-euc-jp.notForBrowser        = true
-x-obsoleted-iso-2022-jp.notForBrowser   = true
-x-obsoleted-shift_jis.notForBrowser     = true
-iso-8859-6-e.notForBrowser              = true
-iso-8859-6-i.notForBrowser              = true
-ibm864i.notForBrowser                   = true
-iso-8859-8-e.notForBrowser              = true
-
-
-adobe-symbol-encoding.LangGroup    = el
-big5.LangGroup                     = zh-TW
-big5-hkscs.LangGroup               = zh-TW
-euc-jp.LangGroup                   = ja
-euc-kr.LangGroup                   = ko
-gb2312.LangGroup                   = zh-CN
-gb18030.LangGroup                  = zh-CN
-gb18030.2000-0.LangGroup           = zh-CN
-gb18030.2000-1.LangGroup           = zh-CN
-hkscs-1.LangGroup                  = zh-TW
-hz-gb-2312.LangGroup               = zh-CN
-ibm850.LangGroup                   = x-western
-ibm852.LangGroup                   = x-central-euro
-ibm855.LangGroup                   = x-cyrillic
-ibm857.LangGroup                   = tr
-ibm862.LangGroup                   = he
-ibm864.LangGroup                   = ar
-ibm866.LangGroup                   = x-cyrillic
-iso-2022-cn.LangGroup              = zh-CN
-iso-2022-jp.LangGroup              = ja
-iso-2022-kr.LangGroup              = ko
-iso-8859-1.LangGroup               = x-western
-iso-8859-15.LangGroup              = x-western
-iso-8859-2.LangGroup               = x-central-euro
-iso-8859-4.LangGroup               = x-baltic
-iso-8859-13.LangGroup              = x-baltic
-iso-8859-5.LangGroup               = x-cyrillic
-iso-8859-6.LangGroup               = ar
-iso-8859-6-e.LangGroup             = ar
-iso-8859-6-i.LangGroup             = ar
-iso-8859-7.LangGroup               = el
-iso-8859-8.LangGroup               = he
-iso-8859-8-e.LangGroup             = he
-iso-8859-8-i.LangGroup             = he
-iso-8859-9.LangGroup               = tr
-jis_0208-1983.LangGroup            = ja
-koi8-r.LangGroup                   = x-cyrillic
-koi8-u.LangGroup                   = x-cyrillic
-shift_jis.LangGroup                = ja
-tis-620.LangGroup                  = th
-tis620-2.LangGroup                 = th
-us-ascii.LangGroup                 = x-western
-utf-16be.LangGroup                 = x-unicode
-utf-16le.LangGroup                 = x-unicode
-utf-32be.LangGroup                 = x-unicode
-utf-32le.LangGroup                 = x-unicode
-utf-7.LangGroup                    = x-unicode
-utf-8.LangGroup                    = x-unicode
-windows-1250.LangGroup             = x-central-euro
-windows-1251.LangGroup             = x-cyrillic
-windows-1252.LangGroup             = x-western
-windows-1253.LangGroup             = el
-windows-1254.LangGroup             = tr
-windows-1255.LangGroup             = he
-windows-1256.LangGroup             = ar
-windows-1257.LangGroup             = x-baltic
-windows-936.LangGroup              = zh-CN
-x-cns-11643-1.LangGroup            = zh-TW
-x-euc-tw.LangGroup                 = zh-TW
-x-gbk.LangGroup                    = zh-CN
-x-gbk-noascii.LangGroup            = zh-CN
-x-mac-ce.LangGroup                 = x-central-euro
-x-mac-cyrillic.LangGroup           = x-cyrillic
-x-mac-greek.LangGroup              = el
-x-mac-icelandic.LangGroup          = x-western
-x-mac-roman.LangGroup              = x-western
-x-mac-turkish.LangGroup            = tr
-x-mac-ukrainian.LangGroup          = x-cyrillic
-x-user-defined.LangGroup           = x-user-def
-x-x11johab.LangGroup               = ko
-x-johab.LangGroup                  = ko
-x-johab-noascii.LangGroup          = ko
-x-windows-949.LangGroup            = ko
-x-mac-hebrew.LangGroup             = he
-x-mac-arabic.LangGroup             = ar
-
-utf-8.MIMEHeaderEncodingMethod  = B
-utf-8.MIMEMailCharset           = utf-8
-
-
-iso-2022-jp.isMultibyte     = true
-shift_jis.isMultibyte       = true
-euc-jp.isMultibyte          = true
-big5.isMultibyte            = true
-big5-hkscs.isMultibyte      = true
-x-euc-tw.isMultibyte        = true
-gb2312.isMultibyte          = true
-hz-gb-2312.isMultibyte      = true
-iso-2022-kr.isMultibyte     = true
-euc-kr.isMultibyte          = true
-x-johab.isMultibyte         = true
-x-windows-949.isMultibyte   = true
-utf-7.isMultibyte           = true
-utf-8.isMultibyte           = true

mozilla/intl/uconv/src/charsetTitles.properties

@@ -1,118 +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.org code.
-##
-## 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): 
-
-## Rule of this file:
-## 1. key should always be in lower case ascii so we can do case insensitive
-##    comparison in the code faster.
-
-## Format of this file:
-## charset_name.title = a_title  -  specifies the human readable title for 
-## this charset
-
-us-ascii.title    = English (US-ASCII)
-iso-8859-1.title    = Western (ISO-8859-1)
-iso-8859-2.title    = Central European (ISO-8859-2)
-iso-8859-3.title    = South European (ISO-8859-3)
-iso-8859-4.title    = Baltic (ISO-8859-4)
-iso-8859-9.title    = Turkish (ISO-8859-9)
-iso-8859-10.title   = Nordic (ISO-8859-10)
-iso-8859-13.title   = Baltic (ISO-8859-13)
-iso-8859-14.title   = Celtic (ISO-8859-14)
-iso-8859-15.title   = Western (ISO-8859-15)
-iso-8859-16.title   = Romanian (ISO-8859-16)
-windows-1250.title  = Central European (Windows-1250)
-windows-1252.title  = Western (Windows-1252)
-windows-1254.title  = Turkish (Windows-1254)
-windows-1257.title  = Baltic (Windows-1257)
-x-mac-roman.title       = Western (MacRoman)
-x-mac-ce.title          = Central European (MacCE)
-x-mac-turkish.title     = Turkish (MacTurkish)
-x-mac-croatian.title    = Croatian (MacCroatian)
-x-mac-romanian.title    = Romanian (MacRomanian)
-x-mac-icelandic.title   = Icelandic (MacIcelandic)
-iso-2022-jp.title = Japanese (ISO-2022-JP)
-shift_jis.title = Japanese (Shift_JIS)
-euc-jp.title = Japanese (EUC-JP)
-big5.title = Chinese Traditional (Big5)
-big5-hkscs.title = Chinese Traditional (Big5-HKSCS)
-x-euc-tw.title = Chinese Traditional (EUC-TW)
-gb2312.title = Chinese Simplified (GB2312)
-hz-gb-2312.title = Chinese Simplified (HZ)
-x-gbk.title = Chinese Simplified (GBK)
-iso-2022-cn.title = Chinese Simplified (ISO-2022-CN)
-euc-kr.title = Korean (EUC-KR)
-x-johab.title = Korean (JOHAB)
-x-windows-949.title = Korean (UHC)
-iso-2022-kr.title = Korean (ISO-2022-KR)
-utf-7.title = Unicode (UTF-7)
-utf-8.title = Unicode (UTF-8)
-iso-8859-5.title = Cyrillic (ISO-8859-5)
-iso-ir-111.title = Cyrillic (ISO-IR-111)
-windows-1251.title = Cyrillic (Windows-1251)
-x-mac-cyrillic.title = Cyrillic (MacCyrillic)
-x-mac-ukrainian.title = Cyrillic/Ukrainian (MacUkrainian)
-koi8-r.title = Cyrillic (KOI8-R)
-koi8-u.title = Cyrillic/Ukrainian (KOI8-U)
-iso-8859-7.title = Greek (ISO-8859-7)
-windows-1253.title = Greek (Windows-1253)
-x-mac-greek.title = Greek (MacGreek)
-windows-1258.title = Vietnamese (Windows-1258)
-x-viet-tcvn5712.title = Vietnamese (TCVN)
-viscii.title = Vietnamese (VISCII)
-x-viet-vps.title = Vietnamese (VPS)
-geostd8.title = Georgian (GEOSTD8)
-tis-620.title = Thai (TIS-620)
-armscii-8.title = Armenian (ARMSCII-8)
-iso-8859-6.title = Arabic (ISO-8859-6)
-iso-8859-6-i.title = Arabic (ISO-8859-6-I)
-iso-8859-6-e.title = Arabic (ISO-8859-6-E)
-iso-8859-8.title = Hebrew Visual (ISO-8859-8)
-iso-8859-8-i.title = Hebrew (ISO-8859-8-I)
-iso-8859-8-e.title = Hebrew (ISO-8859-8-E)
-windows-1255.title = Hebrew (Windows-1255)
-windows-1256.title = Arabic (Windows-1256)
-x-user-defined.title = User Defined
-ibm866.title = Cyrillic/Russian (CP-866)
-ibm850.title = Western (IBM-850)
-ibm852.title = Central European (IBM-852)
-ibm855.title = Cyrillic (IBM-855)
-ibm857.title = Turkish (IBM-857)
-ibm862.title = Hebrew (IBM-862)
-ibm864.title = Arabic (IBM-864)
-ibm864i.title = Arabic (IBM-864-I)
-gb18030.title = Chinese Simplified (GB18030)
-x-mac-arabic.title = Arabic (MacArabic)
-x-mac-farsi.title = Farsi (MacFarsi)
-x-mac-hebrew.title = Hebrew (MacHebrew)
-x-mac-devanagari.title = Hindi (MacDevanagari)
-x-mac-gujarati.title = Gujarati (MacGujarati)
-x-mac-gurmukhi.title = Gurmukhi (MacGurmukhi)
-
-chardet.off.title                           = (Off)
-chardet.alis_charset_detector.title         = All
-chardet.universal_charset_detector.title    = Universal
-chardet.ja_parallel_state_machine.title     = Japanese
-chardet.ko_parallel_state_machine.title     = Korean
-chardet.zhtw_parallel_state_machine.title   = Traditional Chinese
-chardet.zhcn_parallel_state_machine.title   = Simplified Chinese
-chardet.zh_parallel_state_machine.title     = Chinese
-chardet.cjk_parallel_state_machine.title    = East Asian
-chardet.ruprob.title                        = Russian
-chardet.ukprob.title                        = Ukrainian

mozilla/intl/uconv/src/charsetalias.properties

@@ -1,493 +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.org code.
-##
-## 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): 
-## IBM Corporation
-##
-## This Original Code has been modified by IBM Corporation.
-## Modifications made by IBM described herein are
-## Copyright (c) International Business Machines
-## Corporation, 1999
-##
-## Modifications to Mozilla code or documentation
-## identified per MPL Section 3.3
-##
-## Date         Modified by     Description of modification
-## 12/09/1999   IBM Corp.       Support for IBM codepages - 850,852,855,857,862,864
-##
-## Rule of this file:
-## 1. key should always be in lower case ascii so we can do case insensitive
-##    comparison in the code faster.
-## 2. value should be the one used in unicode converter
-## 3. If you want to add more charset, mailto:ftang@netscape.com 
-##
-## 4. If the charset is not used for document charset, but font charset
-##    (e.g. XLFD charset- such as JIS x0201, JIS x0208), don't put here
-##
-us-ascii=us-ascii
-ansi_x3.4-1968=us-ascii
-646=us-ascii
-iso-8859-1=ISO-8859-1
-iso-8859-2=ISO-8859-2
-iso-8859-3=ISO-8859-3
-iso-8859-4=ISO-8859-4
-iso-8859-5=ISO-8859-5
-iso-8859-6=ISO-8859-6
-iso-8859-6-i=ISO-8859-6-I
-iso-8859-6-e=ISO-8859-6-E
-iso-8859-7=ISO-8859-7
-iso-8859-8=ISO-8859-8
-iso-8859-8-i=ISO-8859-8-I
-iso-8859-8-e=ISO-8859-8-E
-iso-8859-9=ISO-8859-9
-iso-8859-10=ISO-8859-10
-iso-8859-11=TIS-620
-iso-8859-13=ISO-8859-13
-iso-8859-14=ISO-8859-14
-iso-8859-15=ISO-8859-15
-iso-8859-16=ISO-8859-16
-iso-ir-111=ISO-IR-111
-iso-2022-cn=ISO-2022-CN
-iso-2022-kr=ISO-2022-KR
-iso-2022-jp=ISO-2022-JP
-utf-32be=UTF-32BE
-utf-32le=UTF-32LE
-utf-32=UTF-32BE
-utf-16be=UTF-16BE
-utf-16le=UTF-16LE
-utf-16=UTF-16BE
-windows-1250=windows-1250
-windows-1251=windows-1251
-windows-1252=windows-1252
-windows-1253=windows-1253
-windows-1254=windows-1254
-windows-1255=windows-1255
-windows-1256=windows-1256
-windows-1257=windows-1257
-windows-1258=windows-1258
-ibm866=IBM866
-ibm850=IBM850
-ibm852=IBM852
-ibm855=IBM855
-ibm857=IBM857
-ibm862=IBM862
-ibm864=IBM864
-ibm864i=IBM864i
-utf-8=UTF-8
-utf-7=UTF-7
-shift_jis=Shift_JIS
-big5=Big5
-euc-jp=EUC-JP
-euc-kr=EUC-KR
-gb2312=GB2312
-gb18030=gb18030
-viscii=VISCII
-koi8-r=KOI8-R
-koi8-u=KOI8-U
-tis-620=TIS-620
-t.61-8bit=T.61-8bit
-hz-gb-2312=HZ-GB-2312
-big5-hkscs=Big5-HKSCS
-gbk=x-gbk
-cns11643=x-euc-tw
-##
-## Netscape private ...
-##
-x-imap4-modified-utf7=x-imap4-modified-utf7
-x-euc-tw=x-euc-tw
-x-mac-roman=x-mac-roman
-x-mac-ce=x-mac-ce
-x-mac-turkish=x-mac-turkish
-x-mac-greek=x-mac-greek
-x-mac-icelandic=x-mac-icelandic
-x-mac-croatian=x-mac-croatian
-x-mac-romanian=x-mac-romanian
-x-mac-cyrillic=x-mac-cyrillic
-x-mac-ukrainian=x-mac-ukrainian
-x-mac-hebrew=x-mac-hebrew
-x-mac-arabic=x-mac-arabic
-geostd8=GEOSTD8
-armscii-8=armscii-8
-x-viet-tcvn5712=x-viet-tcvn5712
-x-viet-vps=x-viet-vps
-x-viet-vni=x-viet-vni
-iso-10646-ucs-2=UTF-16BE
-x-iso-10646-ucs-2-be=UTF-16BE
-x-iso-10646-ucs-2-le=UTF-16LE
-iso-10646-ucs-4=UTF-32BE
-x-iso-10646-ucs-4-be=UTF-32BE
-x-iso-10646-ucs-4-le=UTF-32LE
-x-user-defined=x-user-defined
-x-u-escaped=x-u-escaped
-x-johab=x-johab
-x-windows-949=x-windows-949
-##
-## Aliases for ISO-8859-1
-##
-latin1=ISO-8859-1
-iso_8859-1=ISO-8859-1
-iso8859-1=ISO-8859-1
-iso8859-2=ISO-8859-2
-iso8859-3=ISO-8859-3
-iso8859-4=ISO-8859-4
-iso8859-5=ISO-8859-5
-iso8859-6=ISO-8859-6
-iso8859-7=ISO-8859-7
-iso8859-8=ISO-8859-8
-iso8859-9=ISO-8859-9
-iso8859-10=ISO-8859-10
-iso8859-11=TIS-620
-iso8859-13=ISO-8859-13
-iso8859-14=ISO-8859-14
-iso8859-15=ISO-8859-15
-# Currently .properties cannot handle : in key
-# iso_8859-1:1987=ISO-8859-1
-iso-ir-100=ISO-8859-1
-l1=ISO-8859-1
-ibm819=ISO-8859-1
-cp819=ISO-8859-1
-csisolatin1=ISO-8859-1
-##
-## Aliases for ISO-8859-2
-##
-latin2=ISO-8859-2
-iso_8859-2=ISO-8859-2
-# Currently .properties cannot handle : in key
-# iso_8859-2:1987=ISO-8859-2
-iso-ir-101=ISO-8859-2
-l2=ISO-8859-2
-csisolatin2=ISO-8859-2
-##
-## Aliases for ISO-8859-3
-##
-latin3=ISO-8859-3
-iso_8859-3=ISO-8859-3
-# Currently .properties cannot handle : in key
-#iso_8859-3:1988=ISO-8859-3
-iso-ir-109=ISO-8859-3
-l3=ISO-8859-3
-csisolatin3=ISO-8859-3
-##
-## Aliases for ISO-8859-4
-##
-latin4=ISO-8859-4
-iso_8859-4=ISO-8859-4
-# Currently .properties cannot handle : in key
-#iso_8859-4:1988=ISO-8859-4
-iso-ir-110=ISO-8859-4
-l4=ISO-8859-4
-csisolatin4=ISO-8859-4
-##
-## Aliases for ISO-8859-5
-##
-cyrillic=ISO-8859-5
-iso_8859-5=ISO-8859-5
-# Currently .properties cannot handle : in key
-#iso_8859-5:1988=ISO-8859-5
-iso-ir-144=ISO-8859-5
-csisolatincyrillic=ISO-8859-5
-##
-## Aliases for ISO-8859-6
-##
-arabic=ISO-8859-6
-iso_8859-6=ISO-8859-6
-# Currently .properties cannot handle : in key
-#iso_8859-6:1987=ISO-8859-6
-iso-ir-127=ISO-8859-6
-ecma-114=ISO-8859-6
-asmo-708=ISO-8859-6
-csisolatinarabic=ISO-8859-6
-##
-## Aliases for ISO-8859-6-I
-##
-csiso88596i=ISO-8859-6-I
-##
-## Aliases for ISO-8859-6-E
-##
-csiso88596e=ISO-8859-6-E
-##
-## Aliases for ISO-8859-7
-##
-greek=ISO-8859-7
-greek8=ISO-8859-7
-sun_eu_greek=ISO-8859-7
-iso_8859-7=ISO-8859-7
-# Currently .properties cannot handle : in key
-#iso_8859-7:1987=ISO-8859-7
-iso-ir-126=ISO-8859-7
-elot_928=ISO-8859-7
-ecma-118=ISO-8859-7
-csisolatingreek=ISO-8859-7
-##
-## Aliases for ISO-8859-8
-##
-hebrew=ISO-8859-8
-iso_8859-8=ISO-8859-8
-visual=ISO-8859-8
-# Currently .properties cannot handle : in key
-#iso_8859-8:1988=ISO-8859-8
-iso-ir-138=ISO-8859-8
-csisolatinhebrew=ISO-8859-8
-##
-## Aliases for ISO-8859-8-I
-##
-csiso88598i=ISO-8859-8-I
-iso-8859-8i=ISO-8859-8-I
-##
-## Aliases for ISO-8859-8-E
-##
-csiso88598e=ISO-8859-8-E
-##
-## Aliases for ISO-8859-9
-##
-latin5=ISO-8859-9
-iso_8859-9=ISO-8859-9
-# Currently .properties cannot handle : in key
-#iso_8859-9:1989=ISO-8859-9
-iso-ir-148=ISO-8859-9
-l5=ISO-8859-9
-csisolatin5=ISO-8859-9
-##
-## Aliases for UTF-8
-##
-unicode-1-1-utf-8=UTF-8
-##
-## Aliases for Shift_JIS
-##
-x-sjis=Shift_JIS
-shift-jis=Shift_JIS
-ms_kanji=Shift_JIS
-csshiftjis=Shift_JIS
-windows-31j=Shift_JIS
-##
-## Aliases for EUC_JP
-##
-cseucjpkdfmtjapanese=EUC-JP
-x-euc-jp=EUC-JP
-##
-## Aliases for ISO-2022-JP
-##
-csiso2022jp=ISO-2022-JP
-# The following are really not aliases ISO-2022-JP, but sharing the same decoder
-iso-2022-jp-2=ISO-2022-JP
-csiso2022jp2=ISO-2022-JP
-##
-## Aliases for Big5
-##
-csbig5=Big5
-# x-x-big5 is not really a alias for Big5, add it only for MS FrontPage
-x-x-big5=Big5
-# Sun Solaris
-zh_tw-big5=Big5
-##
-## Aliases for EUC-KR
-##
-csueckr=EUC-KR
-# The following are really not aliases EUC-KR, add them only for MS FrontPage
-#ks_c_5601-1987=EUC-KR
-iso-ir-149=EUC-KR
-ks_c_5601-1989=EUC-KR
-ksc_5601=EUC-KR
-ksc5601=EUC-KR
-korean=EUC-KR
-csksc56011987=EUC-KR
-5601=EUC-KR
-##
-## Aliases for X-Windows-949, CP949, Unified Hangul Code (UHC)
-##
-# Microsoft uses ks_c_5601-1987 to mean Windows-949 or its subset EUC-KR.
-ks_c_5601-1987=x-windows-949
-##
-## Aliases for GB2312
-##
-# The following are really not aliases GB2312, add them only for MS FrontPage
-gb_2312-80=GB2312
-iso-ir-58=GB2312
-chinese=GB2312
-csiso58gb231280=GB2312
-csgb2312=GB2312
-zh_cn.euc=GB2312
-# Sun Solaris
-gb_2312=GB2312
-##
-## Aliases for windows-125x 
-##
-x-cp1250=windows-1250
-x-cp1251=windows-1251
-x-cp1252=windows-1252
-x-cp1253=windows-1253
-x-cp1254=windows-1254
-x-cp1255=windows-1255
-x-cp1256=windows-1256
-x-cp1257=windows-1257
-x-cp1258=windows-1258
-##
-## Aliases for windows-874 
-##
-windows-874=TIS-620
-ibm874=TIS-620
-tis620.2533=TIS-620
-##
-## Aliases for IBM866
-##
-cp866=IBM866
-cp-866=IBM866
-866=IBM866
-csIBM866=IBM866
-##
-## Aliases for IBM850
-##
-cp850=IBM850
-850=IBM850
-csIBM850=IBM850
-##
-## Aliases for IBM852
-##
-cp852=IBM852
-852=IBM852
-csIBM852=IBM852
-##
-## Aliases for IBM855
-##
-cp855=IBM855
-855=IBM855
-csIBM855=IBM855
-##
-## Aliases for IBM857
-##
-cp857=IBM857
-857=IBM857
-csIBM857=IBM857
-##
-## Aliases for IBM862
-##
-cp862=IBM862
-862=IBM862
-csIBM862=IBM862
-##
-## Aliases for IBM864
-##
-cp864=IBM864
-864=IBM864
-csIBM864=IBM864
-ibm-864=IBM864
-##
-## Aliases for IBM864i
-##
-cp864i=IBM864i
-864i=IBM864i
-csibm864i=IBM864i
-ibm-864i=IBM864i
-##
-## Aliases for T.61-8bit
-##
-t.61=T.61-8bit
-iso-ir-103=T.61-8bit
-csiso103t618bit=T.61-8bit
-##
-## Aliases for UTF-7
-##
-x-unicode-2-0-utf-7=UTF-7
-unicode-2-0-utf-7=UTF-7
-unicode-1-1-utf-7=UTF-7
-csunicode11utf7=UTF-7
-##
-## Aliases for ISO-10646-UCS-2
-##
-csunicode=UTF-16BE
-csunicode11=UTF-16BE
-iso-10646-ucs-basic=UTF-16BE
-csunicodeascii=UTF-16BE
-iso-10646-unicode-latin1=UTF-16BE
-csunicodelatin1=UTF-16BE
-iso-10646=UTF-16BE
-iso-10646-j-1=UTF-16BE
-##
-## Aliases for ISO-8859-10
-##
-latin6=ISO-8859-10
-iso-ir-157=ISO-8859-10
-l6=ISO-8859-10
-# Currently .properties cannot handle : in key
-#iso_8859-10:1992=ISO-8859-10
-csisolatin6=ISO-8859-10
-##
-## Aliases for ISO-8859-15
-##
-iso_8859-15=ISO-8859-15
-##
-## Aliases for ISO-IR-111
-##
-ecma-cyrillic=ISO-IR-111
-csiso111ecmacyrillic=ISO-IR-111
-##
-## Aliases for ISO-2022-KR
-##
-csiso2022kr=ISO-2022-KR
-##
-## Aliases for VISCII
-##
-csviscii=VISCII
-##
-## Aliases for VIQR
-##
-csviqr=VIQR
-##
-## Aliases for x-euc-tw
-##
-zh_tw-euc=x-euc-tw
-##
-## Following names appears in unix nl_langinfo(CODESET)
-## They can be compiled as platform specific if necessary
-## DONT put things here if it does not look generic enough (like hp15CN)
-##
-iso88591=ISO-8859-1
-iso88592=ISO-8859-2
-iso88593=ISO-8859-3
-iso88594=ISO-8859-4
-iso88595=ISO-8859-5
-iso88596=ISO-8859-6
-iso88597=ISO-8859-7
-iso88598=ISO-8859-8
-iso88599=ISO-8859-9
-iso885910=ISO-8859-10
-iso885911=TIS-620
-iso885912=ISO-8859-12
-iso885913=ISO-8859-13
-iso885914=ISO-8859-14
-iso885915=ISO-8859-15
-##
-tis620=TIS-620
-##
-cp1250=windows-1250
-cp1251=windows-1251
-cp1252=windows-1252
-cp1253=windows-1253
-cp1254=windows-1254
-cp1255=windows-1255
-cp1256=windows-1256
-cp1257=windows-1257
-cp1258=windows-1258
-
-## Tempory charset for testing purpose. Should be remove before Beta
-x-obsoleted-shift_jis=x-obsoleted-Shift_JIS
-x-obsoleted-iso-2022-jp=x-obsoleted-ISO-2022-JP
-x-obsoleted-euc-jp=x-obsoleted-EUC-JP
-x-gbk=x-gbk
-windows-936=windows-936
-ansi-1251=windows-1251

mozilla/intl/uconv/src/cp1252.uf

@@ -1,182 +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.org code.
- *
- * 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): 
- */
-/*========================================================
-  This is a Generated file. Please don't edit it.
-
-  The tool which used to generate this file is called fromu.
-  If you have any problem of this file. Please contact 
-  Netscape Client International Team or 
-  ftang@netscape <Frank Tang> 
-
-              Table in Debug form 
-Begin of Item 0000
- Format 0
-  srcBegin = 0000
-  srcEnd = 007F
-  destBegin = 0000
-End of Item 0000 
-
-Begin of Item 0001
- Format 0
-  srcBegin = 00A0
-  srcEnd = 00FF
-  destBegin = 00A0
-End of Item 0001 
-
-Begin of Item 0002
- Format 2
-  srcBegin = 0081
-  destBegin = 0081
-End of Item 0002 
-
-Begin of Item 0003
- Format 1
-  srcBegin = 008D
-  srcEnd = 0090
-  mappingOffset = 0000
- Mapping  = 
-  008D FFFD 008F 0090 
-End of Item 0003 
-
-Begin of Item 0004
- Format 2
-  srcBegin = 009D
-  destBegin = 009D
-End of Item 0004 
-
-Begin of Item 0005
- Format 1
-  srcBegin = 0152
-  srcEnd = 0153
-  mappingOffset = 0004
- Mapping  = 
-  008C 009C 
-End of Item 0005 
-
-Begin of Item 0006
- Format 1
-  srcBegin = 0160
-  srcEnd = 0161
-  mappingOffset = 0006
- Mapping  = 
-  008A 009A 
-End of Item 0006 
-
-Begin of Item 0007
- Format 1
-  srcBegin = 0178
-  srcEnd = 017E
-  mappingOffset = 0008
- Mapping  = 
-  009F FFFD FFFD FFFD FFFD 008E 009E 
-End of Item 0007 
-
-Begin of Item 0008
- Format 2
-  srcBegin = 0192
-  destBegin = 0083
-End of Item 0008 
-
-Begin of Item 0009
- Format 2
-  srcBegin = 02C6
-  destBegin = 0088
-End of Item 0009 
-
-Begin of Item 000A
- Format 2
-  srcBegin = 02DC
-  destBegin = 0098
-End of Item 000A 
-
-Begin of Item 000B
- Format 1
-  srcBegin = 2013
-  srcEnd = 203A
-  mappingOffset = 000F
- Mapping  = 
-  0096 0097 FFFD FFFD FFFD 0091 0092 0082 
-  FFFD 0093 0094 0084 FFFD 0086 0087 0095 
-  FFFD FFFD FFFD 0085 FFFD FFFD FFFD FFFD 
-  FFFD FFFD FFFD FFFD FFFD 0089 FFFD FFFD 
-  FFFD FFFD FFFD FFFD FFFD FFFD 008B 009B 
-End of Item 000B 
-
-Begin of Item 000C
- Format 2
-  srcBegin = 20AC
-  destBegin = 0080
-End of Item 000C 
-
-Begin of Item 000D
- Format 2
-  srcBegin = 2122
-  destBegin = 0099
-End of Item 000D 
-
-========================================================*/
-/* Offset=0x0000  ItemOfList */
-  0x000E,
-/*-------------------------------------------------------*/
-/* Offset=0x0001  offsetToFormatArray */
-  0x0004,
-/*-------------------------------------------------------*/
-/* Offset=0x0002  offsetToMapCellArray */ 
-  0x0008,
-/*-------------------------------------------------------*/
-/* Offset=0x0003  offsetToMappingTable */ 
-  0x0032,
-/*-------------------------------------------------------*/
-/*       Offset=0x0004   Start of Format Array */ 
-/*	Total of Format 0 : 0x0002			 */
-/*	Total of Format 1 : 0x0005			 */
-/*	Total of Format 2 : 0x0007			 */
-/*	Total of Format 3 : 0x0000			 */
-
-0x1200, 0x1112, 0x1222, 0x0022, 
-/*-------------------------------------------------------*/
-/*       Offset=0x0008   Start of MapCell Array */ 
-/* 0000 */    0x0000, 0x007F, 0x0000, 
-/* 0001 */    0x00A0, 0x00FF, 0x00A0, 
-/* 0002 */    0x0081, 0x0000, 0x0081, 
-/* 0003 */    0x008D, 0x0090, 0x0000, 
-/* 0004 */    0x009D, 0x0000, 0x009D, 
-/* 0005 */    0x0152, 0x0153, 0x0004, 
-/* 0006 */    0x0160, 0x0161, 0x0006, 
-/* 0007 */    0x0178, 0x017E, 0x0008, 
-/* 0008 */    0x0192, 0x0000, 0x0083, 
-/* 0009 */    0x02C6, 0x0000, 0x0088, 
-/* 000A */    0x02DC, 0x0000, 0x0098, 
-/* 000B */    0x2013, 0x203A, 0x000F, 
-/* 000C */    0x20AC, 0x0000, 0x0080, 
-/* 000D */    0x2122, 0x0000, 0x0099, 
-/*-------------------------------------------------------*/
-/*       Offset=0x0032   Start of MappingTable */ 
-
-/* 0000 */    0x008D, 0xFFFD, 0x008F, 0x0090, 0x008C, 0x009C, 0x008A, 0x009A, 
-/* 0008 */    0x009F, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x008E, 0x009E, 0x0096, 
-/* 0010 */    0x0097, 0xFFFD, 0xFFFD, 0xFFFD, 0x0091, 0x0092, 0x0082, 0xFFFD, 
-/* 0018 */    0x0093, 0x0094, 0x0084, 0xFFFD, 0x0086, 0x0087, 0x0095, 0xFFFD, 
-/* 0020 */    0xFFFD, 0xFFFD, 0x0085, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 
-/* 0028 */    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0089, 0xFFFD, 0xFFFD, 0xFFFD, 
-/* 0030 */    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x008B, 0x009B, 
-/*	End of table Total Length = 0x0069 * 2 */

mozilla/intl/uconv/src/cp1252.ut

@@ -1,105 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-/*========================================================
-  This is a Generated file. Please don't edit it.
-
-  The tool which used to generate this file is called fromu.
-  If you have any problem of this file. Please contact 
-  Netscape Client International Team or 
-  ftang@netscape <Frank Tang> 
-
-              Table in Debug form 
-Begin of Item 0000
- Format 0
-  srcBegin = 0000
-  srcEnd = 007F
-  destBegin = 0000
-End of Item 0000 
-
-Begin of Item 0001
- Format 0
-  srcBegin = 00A0
-  srcEnd = 00FF
-  destBegin = 00A0
-End of Item 0001 
-
-Begin of Item 0002
- Format 1
-  srcBegin = 0080
-  srcEnd = 009F
-  mappingOffset = 0000
- Mapping  = 
-  20AC 0081 201A 0192 201E 2026 2020 2021 
-  02C6 2030 0160 2039 0152 008D 017D 008F 
-  0090 2018 2019 201C 201D 2022 2013 2014 
-  02DC 2122 0161 203A 0153 009D 017E 0178 
-End of Item 0002 
-
-========================================================*/
-/* Offset=0x0000  ItemOfList */
-  0x0003,
-/*-------------------------------------------------------*/
-/* Offset=0x0001  offsetToFormatArray */
-  0x0004,
-/*-------------------------------------------------------*/
-/* Offset=0x0002  offsetToMapCellArray */ 
-  0x0005,
-/*-------------------------------------------------------*/
-/* Offset=0x0003  offsetToMappingTable */ 
-  0x000E,
-/*-------------------------------------------------------*/
-/*       Offset=0x0004   Start of Format Array */ 
-/*	Total of Format 0 : 0x0002			 */
-/*	Total of Format 1 : 0x0001			 */
-/*	Total of Format 2 : 0x0000			 */
-/*	Total of Format 3 : 0x0000			 */
-
-0x0100, 
-/*-------------------------------------------------------*/
-/*       Offset=0x0005   Start of MapCell Array */ 
-/* 0000 */    0x0000, 0x007F, 0x0000, 
-/* 0001 */    0x00A0, 0x00FF, 0x00A0, 
-/* 0002 */    0x0080, 0x009F, 0x0000, 
-/*-------------------------------------------------------*/
-/*       Offset=0x000E   Start of MappingTable */ 
-
-/* 0000 */    0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, 
-/* 0008 */    0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F, 
-/* 0010 */    0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 
-/* 0018 */    0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178, 
-/*	End of table Total Length = 0x002E * 2 */

mozilla/intl/uconv/src/jar.mn

@@ -1,2 +0,0 @@
-en-US.jar:
-	locale/en-US/global/charsetTitles.properties

mozilla/intl/uconv/src/maccharset.properties

@@ -1,66 +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.org code.
-##
-## 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): 
-##
-## Region code section, this is used to map a region code to a charset name
-## It have higher priority than the Script code section
-##
-region.68=x-mac-croatian
-region.25=x-mac-croatian
-region.20=x-mac-greek
-region.21=x-mac-icelandic
-region.39=x-mac-romanian
-region.24=x-mac-turkish
-region.62=x-mac-ukrainian
-##
-## Script code section, this is used to map a script code to a charset name
-## It have lower priority than the Region code section
-##
-script.0=x-mac-roman
-script.1=Shift_JIS
-script.2=Big5
-script.3=EUC-KR
-script.4=x-mac-arabic
-script.5=x-mac-hebrew
-script.6=x-mac-greek
-script.7=x-mac-cyrillic
-script.8=x-mac-rsymbol
-script.9=x-mac-devanagari
-script.10=x-mac-gurmukhi
-script.11=x-mac-gujarati
-script.12=x-mac-oriya
-script.13=x-mac-bengali
-script.14=x-mac-tamil
-script.15=x-mac-telugu
-script.16=x-mac-kannada
-script.17=x-mac-malayalam
-script.18=x-mac-sinhalese
-script.19=x-mac-burmese
-script.20=x-mac-khmer
-script.21=TIS-620
-script.22=x-mac-lao
-script.23=x-mac-georgian
-script.24=x-mac-armenian
-script.25=GB2312
-script.26=x-mac-tibetan
-script.27=x-mac-mongolian
-script.28=x-mac-ethiopic
-script.29=x-mac-ce
-script.30=x-mac-vietnamese
-script.31=x-mac-extarabic

mozilla/intl/uconv/src/macroman.uf

@@ -1,262 +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.org code.
- *
- * 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): 
- */
-/*========================================================
-  This is a Generated file. Please don't edit it.
-
-  The tool which used to generate this file is called fromu.
-  If you have any problem of this file. Please contact 
-  Netscape Client International Team or 
-  ftang@netscape <Frank Tang> 
-
-              Table in Debug form 
-Begin of Item 0000
- Format 0
-  srcBegin = 0000
-  srcEnd = 007E
-  destBegin = 0000
-End of Item 0000 
-
-Begin of Item 0001
- Format 1
-  srcBegin = 00A0
-  srcEnd = 00FF
-  mappingOffset = 0000
- Mapping  = 
-  00CA 00C1 00A2 00A3 FFFD 00B4 FFFD 00A4 
-  00AC 00A9 00BB 00C7 00C2 FFFD 00A8 00F8 
-  00A1 00B1 FFFD FFFD 00AB 00B5 00A6 00E1 
-  00FC FFFD 00BC 00C8 FFFD FFFD FFFD 00C0 
-  00CB 00E7 00E5 00CC 0080 0081 00AE 0082 
-  00E9 0083 00E6 00E8 00ED 00EA 00EB 00EC 
-  FFFD 0084 00F1 00EE 00EF 00CD 0085 FFFD 
-  00AF 00F4 00F2 00F3 0086 FFFD FFFD 00A7 
-  0088 0087 0089 008B 008A 008C 00BE 008D 
-  008F 008E 0090 0091 0093 0092 0094 0095 
-  FFFD 0096 0098 0097 0099 009B 009A 00D6 
-  00BF 009D 009C 009E 009F FFFD FFFD 00D8 
-End of Item 0001 
-
-Begin of Item 0002
- Format 2
-  srcBegin = 0131
-  destBegin = 00F5
-End of Item 0002 
-
-Begin of Item 0003
- Format 1
-  srcBegin = 0152
-  srcEnd = 0153
-  mappingOffset = 0060
- Mapping  = 
-  00CE 00CF 
-End of Item 0003 
-
-Begin of Item 0004
- Format 2
-  srcBegin = 0178
-  destBegin = 00D9
-End of Item 0004 
-
-Begin of Item 0005
- Format 2
-  srcBegin = 0192
-  destBegin = 00C4
-End of Item 0005 
-
-Begin of Item 0006
- Format 1
-  srcBegin = 02C6
-  srcEnd = 02C7
-  mappingOffset = 0062
- Mapping  = 
-  00F6 00FF 
-End of Item 0006 
-
-Begin of Item 0007
- Format 1
-  srcBegin = 02D8
-  srcEnd = 02DD
-  mappingOffset = 0064
- Mapping  = 
-  00F9 00FA 00FB 00FE 00F7 00FD 
-End of Item 0007 
-
-Begin of Item 0008
- Format 2
-  srcBegin = 03C0
-  destBegin = 00B9
-End of Item 0008 
-
-Begin of Item 0009
- Format 1
-  srcBegin = 2013
-  srcEnd = 2044
-  mappingOffset = 006A
- Mapping  = 
-  00D0 00D1 FFFD FFFD FFFD 00D4 00D5 00E2 
-  FFFD 00D2 00D3 00E3 FFFD 00A0 00E0 00A5 
-  FFFD FFFD FFFD 00C9 FFFD FFFD FFFD FFFD 
-  FFFD FFFD FFFD FFFD FFFD 00E4 FFFD FFFD 
-  FFFD FFFD FFFD FFFD FFFD FFFD 00DC 00DD 
-  FFFD FFFD FFFD FFFD FFFD FFFD FFFD FFFD 
-  FFFD 00DA 
-End of Item 0009 
-
-Begin of Item 000A
- Format 2
-  srcBegin = 20AC
-  destBegin = 00DB
-End of Item 000A 
-
-Begin of Item 000B
- Format 1
-  srcBegin = 2122
-  srcEnd = 2126
-  mappingOffset = 009C
- Mapping  = 
-  00AA FFFD FFFD FFFD 00BD 
-End of Item 000B 
-
-Begin of Item 000C
- Format 1
-  srcBegin = 2202
-  srcEnd = 221E
-  mappingOffset = 00A1
- Mapping  = 
-  00B6 FFFD FFFD FFFD 00C6 FFFD FFFD FFFD 
-  FFFD FFFD FFFD FFFD FFFD 00B8 FFFD 00B7 
-  FFFD FFFD FFFD FFFD FFFD FFFD FFFD FFFD 
-  00C3 FFFD FFFD FFFD 00B0 
-End of Item 000C 
-
-Begin of Item 000D
- Format 2
-  srcBegin = 222B
-  destBegin = 00BA
-End of Item 000D 
-
-Begin of Item 000E
- Format 2
-  srcBegin = 2248
-  destBegin = 00C5
-End of Item 000E 
-
-Begin of Item 000F
- Format 1
-  srcBegin = 2260
-  srcEnd = 2265
-  mappingOffset = 00BE
- Mapping  = 
-  00AD FFFD FFFD FFFD 00B2 00B3 
-End of Item 000F 
-
-Begin of Item 0010
- Format 2
-  srcBegin = 25CA
-  destBegin = 00D7
-End of Item 0010 
-
-Begin of Item 0011
- Format 2
-  srcBegin = F8FF
-  destBegin = 00F0
-End of Item 0011 
-
-Begin of Item 0012
- Format 1
-  srcBegin = FB01
-  srcEnd = FB02
-  mappingOffset = 00C4
- Mapping  = 
-  00DE 00DF 
-End of Item 0012 
-
-========================================================*/
-/* Offset=0x0000  ItemOfList */
-  0x0013,
-/*-------------------------------------------------------*/
-/* Offset=0x0001  offsetToFormatArray */
-  0x0004,
-/*-------------------------------------------------------*/
-/* Offset=0x0002  offsetToMapCellArray */ 
-  0x0009,
-/*-------------------------------------------------------*/
-/* Offset=0x0003  offsetToMappingTable */ 
-  0x0042,
-/*-------------------------------------------------------*/
-/*       Offset=0x0004   Start of Format Array */ 
-/*	Total of Format 0 : 0x0001			 */
-/*	Total of Format 1 : 0x0009			 */
-/*	Total of Format 2 : 0x0009			 */
-/*	Total of Format 3 : 0x0000			 */
-
-0x1210, 0x1122, 0x1212, 0x1221, 0x0122, 
-/*-------------------------------------------------------*/
-/*       Offset=0x0009   Start of MapCell Array */ 
-/* 0000 */    0x0000, 0x007E, 0x0000, 
-/* 0001 */    0x00A0, 0x00FF, 0x0000, 
-/* 0002 */    0x0131, 0x0000, 0x00F5, 
-/* 0003 */    0x0152, 0x0153, 0x0060, 
-/* 0004 */    0x0178, 0x0000, 0x00D9, 
-/* 0005 */    0x0192, 0x0000, 0x00C4, 
-/* 0006 */    0x02C6, 0x02C7, 0x0062, 
-/* 0007 */    0x02D8, 0x02DD, 0x0064, 
-/* 0008 */    0x03C0, 0x0000, 0x00B9, 
-/* 0009 */    0x2013, 0x2044, 0x006A, 
-/* 000A */    0x20AC, 0x0000, 0x00DB, 
-/* 000B */    0x2122, 0x2126, 0x009C, 
-/* 000C */    0x2202, 0x221E, 0x00A1, 
-/* 000D */    0x222B, 0x0000, 0x00BA, 
-/* 000E */    0x2248, 0x0000, 0x00C5, 
-/* 000F */    0x2260, 0x2265, 0x00BE, 
-/* 0010 */    0x25CA, 0x0000, 0x00D7, 
-/* 0011 */    0xF8FF, 0x0000, 0x00F0, 
-/* 0012 */    0xFB01, 0xFB02, 0x00C4, 
-/*-------------------------------------------------------*/
-/*       Offset=0x0042   Start of MappingTable */ 
-
-/* 0000 */    0x00CA, 0x00C1, 0x00A2, 0x00A3, 0xFFFD, 0x00B4, 0xFFFD, 0x00A4, 
-/* 0008 */    0x00AC, 0x00A9, 0x00BB, 0x00C7, 0x00C2, 0xFFFD, 0x00A8, 0x00F8, 
-/* 0010 */    0x00A1, 0x00B1, 0xFFFD, 0xFFFD, 0x00AB, 0x00B5, 0x00A6, 0x00E1, 
-/* 0018 */    0x00FC, 0xFFFD, 0x00BC, 0x00C8, 0xFFFD, 0xFFFD, 0xFFFD, 0x00C0, 
-/* 0020 */    0x00CB, 0x00E7, 0x00E5, 0x00CC, 0x0080, 0x0081, 0x00AE, 0x0082, 
-/* 0028 */    0x00E9, 0x0083, 0x00E6, 0x00E8, 0x00ED, 0x00EA, 0x00EB, 0x00EC, 
-/* 0030 */    0xFFFD, 0x0084, 0x00F1, 0x00EE, 0x00EF, 0x00CD, 0x0085, 0xFFFD, 
-/* 0038 */    0x00AF, 0x00F4, 0x00F2, 0x00F3, 0x0086, 0xFFFD, 0xFFFD, 0x00A7, 
-/* 0040 */    0x0088, 0x0087, 0x0089, 0x008B, 0x008A, 0x008C, 0x00BE, 0x008D, 
-/* 0048 */    0x008F, 0x008E, 0x0090, 0x0091, 0x0093, 0x0092, 0x0094, 0x0095, 
-/* 0050 */    0xFFFD, 0x0096, 0x0098, 0x0097, 0x0099, 0x009B, 0x009A, 0x00D6, 
-/* 0058 */    0x00BF, 0x009D, 0x009C, 0x009E, 0x009F, 0xFFFD, 0xFFFD, 0x00D8, 
-/* 0060 */    0x00CE, 0x00CF, 0x00F6, 0x00FF, 0x00F9, 0x00FA, 0x00FB, 0x00FE, 
-/* 0068 */    0x00F7, 0x00FD, 0x00D0, 0x00D1, 0xFFFD, 0xFFFD, 0xFFFD, 0x00D4, 
-/* 0070 */    0x00D5, 0x00E2, 0xFFFD, 0x00D2, 0x00D3, 0x00E3, 0xFFFD, 0x00A0, 
-/* 0078 */    0x00E0, 0x00A5, 0xFFFD, 0xFFFD, 0xFFFD, 0x00C9, 0xFFFD, 0xFFFD, 
-/* 0080 */    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x00E4, 
-/* 0088 */    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 
-/* 0090 */    0x00DC, 0x00DD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 
-/* 0098 */    0xFFFD, 0xFFFD, 0xFFFD, 0x00DA, 0x00AA, 0xFFFD, 0xFFFD, 0xFFFD, 
-/* 00A0 */    0x00BD, 0x00B6, 0xFFFD, 0xFFFD, 0xFFFD, 0x00C6, 0xFFFD, 0xFFFD, 
-/* 00A8 */    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x00B8, 0xFFFD, 
-/* 00B0 */    0x00B7, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 
-/* 00B8 */    0xFFFD, 0x00C3, 0xFFFD, 0xFFFD, 0xFFFD, 0x00B0, 0x00AD, 0xFFFD, 
-/* 00C0 */    0xFFFD, 0xFFFD, 0x00B2, 0x00B3, 0x00DE, 0x00DF, 
-/*	End of table Total Length = 0x0108 * 2 */

mozilla/intl/uconv/src/macroman.ut

@@ -1,121 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-/*========================================================
-  This is a Generated file. Please don't edit it.
-
-  The tool which used to generate this file is called fromu.
-  If you have any problem of this file. Please contact 
-  Netscape Client International Team or 
-  ftang@netscape <Frank Tang> 
-
-              Table in Debug form 
-Begin of Item 0000
- Format 0
-  srcBegin = 0000
-  srcEnd = 007E
-  destBegin = 0000
-End of Item 0000 
-
-Begin of Item 0001
- Format 1
-  srcBegin = 0080
-  srcEnd = 00FF
-  mappingOffset = 0000
- Mapping  = 
-  00C4 00C5 00C7 00C9 00D1 00D6 00DC 00E1 
-  00E0 00E2 00E4 00E3 00E5 00E7 00E9 00E8 
-  00EA 00EB 00ED 00EC 00EE 00EF 00F1 00F3 
-  00F2 00F4 00F6 00F5 00FA 00F9 00FB 00FC 
-  2020 00B0 00A2 00A3 00A7 2022 00B6 00DF 
-  00AE 00A9 2122 00B4 00A8 2260 00C6 00D8 
-  221E 00B1 2264 2265 00A5 00B5 2202 2211 
-  220F 03C0 222B 00AA 00BA 2126 00E6 00F8 
-  00BF 00A1 00AC 221A 0192 2248 2206 00AB 
-  00BB 2026 00A0 00C0 00C3 00D5 0152 0153 
-  2013 2014 201C 201D 2018 2019 00F7 25CA 
-  00FF 0178 2044 20AC 2039 203A FB01 FB02 
-  2021 00B7 201A 201E 2030 00C2 00CA 00C1 
-  00CB 00C8 00CD 00CE 00CF 00CC 00D3 00D4 
-  F8FF 00D2 00DA 00DB 00D9 0131 02C6 02DC 
-  00AF 02D8 02D9 02DA 00B8 02DD 02DB 02C7 
-End of Item 0001 
-
-========================================================*/
-/* Offset=0x0000  ItemOfList */
-  0x0002,
-/*-------------------------------------------------------*/
-/* Offset=0x0001  offsetToFormatArray */
-  0x0004,
-/*-------------------------------------------------------*/
-/* Offset=0x0002  offsetToMapCellArray */ 
-  0x0005,
-/*-------------------------------------------------------*/
-/* Offset=0x0003  offsetToMappingTable */ 
-  0x000B,
-/*-------------------------------------------------------*/
-/*       Offset=0x0004   Start of Format Array */ 
-/*	Total of Format 0 : 0x0001			 */
-/*	Total of Format 1 : 0x0001			 */
-/*	Total of Format 2 : 0x0000			 */
-/*	Total of Format 3 : 0x0000			 */
-
-0x0010, 
-/*-------------------------------------------------------*/
-/*       Offset=0x0005   Start of MapCell Array */ 
-/* 0000 */    0x0000, 0x007E, 0x0000, 
-/* 0001 */    0x0080, 0x00FF, 0x0000, 
-/*-------------------------------------------------------*/
-/*       Offset=0x000B   Start of MappingTable */ 
-
-/* 0000 */    0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1, 
-/* 0008 */    0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8, 
-/* 0010 */    0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3, 
-/* 0018 */    0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC, 
-/* 0020 */    0x2020, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF, 
-/* 0028 */    0x00AE, 0x00A9, 0x2122, 0x00B4, 0x00A8, 0x2260, 0x00C6, 0x00D8, 
-/* 0030 */    0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5, 0x2202, 0x2211, 
-/* 0038 */    0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x2126, 0x00E6, 0x00F8, 
-/* 0040 */    0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB, 
-/* 0048 */    0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153, 
-/* 0050 */    0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA, 
-/* 0058 */    0x00FF, 0x0178, 0x2044, 0x20AC, 0x2039, 0x203A, 0xFB01, 0xFB02, 
-/* 0060 */    0x2021, 0x00B7, 0x201A, 0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1, 
-/* 0068 */    0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 0x00D3, 0x00D4, 
-/* 0070 */    0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0x0131, 0x02C6, 0x02DC, 
-/* 0078 */    0x00AF, 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD, 0x02DB, 0x02C7, 
-/*	End of table Total Length = 0x008B * 2 */

mozilla/intl/uconv/src/makefile.win

@@ -1,99 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..
-MODULE=uconv
-REQUIRES	= xpcom \
-		  string \
-		  intl \
-		  locale \
-		  unicharutil \
-		  chardet \
-		  $(NULL)
-include <$(DEPTH)/config/config.mak>
-
-DEFINES=-D_IMPL_NS_INTL -DWIN32_LEAN_AND_MEAN
-
-LIBRARY_NAME=uconv
-MODULE_NAME=nsUConvModule
-
-CPP_OBJS=						\
-	.\$(OBJDIR)\nsTextToSubURI.obj			\
-	.\$(OBJDIR)\nsCharsetConverterManager.obj 	\
-	.\$(OBJDIR)\nsUnicodeDecodeHelper.obj 		\
-	.\$(OBJDIR)\nsUnicodeEncodeHelper.obj 		\
-	.\$(OBJDIR)\nsWinCharset.obj 			\
-	.\$(OBJDIR)\nsCharsetAliasImp.obj 		\
-	.\$(OBJDIR)\nsUConvModule.obj 			\
-	.\$(OBJDIR)\nsMappingCache.obj 			\
-	.\$(OBJDIR)\nsURLProperties.obj 		\
-	.\$(OBJDIR)\nsISO88591ToUnicode.obj			\
-	.\$(OBJDIR)\nsCP1252ToUnicode.obj			\
-	.\$(OBJDIR)\nsMacRomanToUnicode.obj			\
-	.\$(OBJDIR)\nsUTF8ToUnicode.obj			\
-	.\$(OBJDIR)\nsUnicodeToISO88591.obj			\
-	.\$(OBJDIR)\nsUnicodeToCP1252.obj			\
-	.\$(OBJDIR)\nsUnicodeToMacRoman.obj			\
-	.\$(OBJDIR)\nsUnicodeToUTF8.obj			\
-	.\$(OBJDIR)\nsUCvMinSupport.obj			\
-	.\$(OBJDIR)\nsScriptableUConv.obj	\
-	.\$(OBJDIR)\nsConverterInputStream.obj	\
-	$(NULL)
-
-CSRCS =		\
-	umap.c	\
-	ugen.c	\
-	uscan.c	\
-	$(NULL)
-
-OBJS = 				\
-        .\$(OBJDIR)\umap.obj	\
-        .\$(OBJDIR)\ugen.obj	\
-        .\$(OBJDIR)\uscan.obj	\
-        $(NULL)
-
-EXPORTS=				\
-	$(NULL)
-
-
-
-LLIBS=					\
- $(DIST)\lib\xpcom.lib		\
- $(DIST)\lib\unicharutil_s.lib \
- $(LIBNSPR)
-
-LCFLAGS = \
-        $(LCFLAGS) \
-        $(DEFINES) \
-        $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-libs::
-	$(MAKE_INSTALL) .\charsetalias.properties $(DIST)\bin\res
-	$(MAKE_INSTALL) .\wincharset.properties $(DIST)\bin\res
-	$(MAKE_INSTALL) charsetData.properties $(DIST)\bin\res
-
-clobber::
-	rm -f $(DIST)\bin\res\charsetalias.properties
-	rm -f $(DIST)\bin\res\wincharset.properties
-	rm -f $(DIST)\bin\res\charsetData.properties
-    

mozilla/intl/uconv/src/nsCP1252ToUnicode.cpp

@@ -1,61 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsUCSupport.h"
-#include "nsCP1252ToUnicode.h"
-
-//----------------------------------------------------------------------
-// Global functions and data [declaration]
-
-static const PRUint16 g_utMappingTable[] = {
-#include "cp1252.ut"
-};
-
-static const PRInt16 g_utShiftTable[] =  {
-  0, u1ByteCharset ,
-  ShiftCell(0,0,0,0,0,0,0,0)
-};
-
-//----------------------------------------------------------------------
-// Class nsCP1252ToUnicode [implementation]
-
-nsCP1252ToUnicode::nsCP1252ToUnicode() 
-: nsOneByteDecoderSupport((uShiftTable*) &g_utShiftTable, 
-                          (uMappingTable*) &g_utMappingTable)
-{
-}

mozilla/intl/uconv/src/nsCP1252ToUnicode.h

@@ -1,69 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsCP1252ToUnicode_h___
-#define nsCP1252ToUnicode_h___
-
-// Class ID for our CP1252ToUnicode charset converter
-// {7C657D15-EC5E-11d2-8AAC-00600811A836}
-#define NS_CP1252TOUNICODE_CID \
-  { 0x7c657d15, 0xec5e, 0x11d2, {0x8a, 0xac, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36}}
-
-#define NS_CP1252TOUNICODE_CONTRACTID "@mozilla.org/intl/unicode/decoder;1?charset=windows-1252"
-
-//----------------------------------------------------------------------
-// Class nsCP1252ToUnicode [declaration]
-
-/**
- * A character set converter from CP1252 to Unicode.
- *
- * @created         20/Apr/1999
- * @author  Catalin Rotaru [CATA]
- */
-class nsCP1252ToUnicode : public nsOneByteDecoderSupport
-{
-public:
-
-  /**
-   * Class constructor.
-   */
-  nsCP1252ToUnicode();
-
-};
-
-#endif /* nsCP1252ToUnicode_h___ */

mozilla/intl/uconv/src/nsCharsetAlias.h

@@ -1,68 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-#ifndef nsCharsetAlias_h__
-#define nsCharsetAlias_h__
-
-#include "nsICharsetAlias.h"
-#include "nsURLProperties.h"
-
-//==============================================================
-class nsCharsetAlias2 : public nsICharsetAlias
-{
-  NS_DECL_ISUPPORTS
-
-public:
-
-  nsCharsetAlias2();
-  virtual ~nsCharsetAlias2();
-
-  NS_IMETHOD GetPreferred(const nsAString& aAlias, nsAString& oResult);
-  NS_IMETHOD GetPreferred(const PRUnichar* aAlias, const PRUnichar** oResult) ;
-  NS_IMETHOD GetPreferred(const char* aAlias, char* oResult, PRInt32 aBufLength) ;
-
-  NS_IMETHOD Equals(const nsAString& aCharset1, const nsAString& aCharset2, PRBool* oResult) ;
-  NS_IMETHOD Equals(const PRUnichar* aCharset1, const PRUnichar* aCharset2, PRBool* oResult) ;
-  NS_IMETHOD Equals(const char* aCharset1, const char* aCharset2, PRBool* oResult) ;
-
-private:
-  nsURLProperties* mDelegate;
-};
-
-#endif // nsCharsetAlias_h__
-
-

mozilla/intl/uconv/src/nsCharsetAliasImp.cpp

@@ -1,163 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-
-#include "nsICharsetAlias.h"
-#include "pratom.h"
-
-// for NS_IMPL_IDS only
-#include "nsIPlatformCharset.h"
-
-#include "nsUConvDll.h"
-#include "nsReadableUtils.h"
-#include "nsUnicharUtils.h"
-#include "nsURLProperties.h"
-#include "nsITimelineService.h"
-#include "nsCharsetAlias.h"
-
-//--------------------------------------------------------------
-NS_IMPL_ISUPPORTS1(nsCharsetAlias2, nsICharsetAlias);
-
-//--------------------------------------------------------------
-nsCharsetAlias2::nsCharsetAlias2()
-{
-  NS_INIT_REFCNT();
-  mDelegate = nsnull; // delay the load of mDelegate untill we need it.
-}
-//--------------------------------------------------------------
-nsCharsetAlias2::~nsCharsetAlias2()
-{
-  if(mDelegate)
-     delete mDelegate;
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsCharsetAlias2::GetPreferred(const nsAString& aAlias, nsAString& oResult)
-{
-   if (aAlias.IsEmpty()) return NS_ERROR_NULL_POINTER;
-   NS_TIMELINE_START_TIMER("nsCharsetAlias2:GetPreferred");
-
-   nsAutoString aKey(aAlias);
-   ToLowerCase(aKey);
-   oResult.Truncate();
-
-   //delay loading charsetalias.properties by resolving most freq. aliases
-   if(!mDelegate) {
-     if(aKey.Equals(NS_LITERAL_STRING("utf-8"))) {
-       oResult = NS_LITERAL_STRING("UTF-8");
-       NS_TIMELINE_STOP_TIMER("nsCharsetAlias2:GetPreferred");
-       return NS_OK;
-     } 
-     if(aKey.Equals(NS_LITERAL_STRING("iso-8859-1"))) {
-       oResult = NS_LITERAL_STRING("ISO-8859-1");
-       NS_TIMELINE_STOP_TIMER("nsCharsetAlias2:GetPreferred");
-       return NS_OK;
-     } 
-     if(aKey.Equals(NS_LITERAL_STRING("x-sjis")) ||
-        aKey.Equals(NS_LITERAL_STRING("shift_jis"))) {
-       oResult = NS_LITERAL_STRING("Shift_JIS");
-       NS_TIMELINE_STOP_TIMER("nsCharsetAlias2:GetPreferred");
-       return NS_OK;
-     } 
-     //load charsetalias.properties string bundle with all remaining aliases
-     // we may need to protect the following section with a lock so we won't call the 
-     // 'new nsURLProperties' from two different threads
-     mDelegate = new nsURLProperties( NS_LITERAL_CSTRING("resource:/res/charsetalias.properties") );
-     NS_ASSERTION(mDelegate, "cannot create nsURLProperties");
-     if(nsnull == mDelegate)
-       return NS_ERROR_OUT_OF_MEMORY;
-   }
-
-   NS_TIMELINE_STOP_TIMER("nsCharsetAlias2:GetPreferred");
-   NS_TIMELINE_MARK_TIMER("nsCharsetAlias2:GetPreferred");
-
-   return mDelegate->Get(aKey, oResult);
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsCharsetAlias2::GetPreferred(const PRUnichar* aAlias, const PRUnichar** oResult)
-{
-   // this method should be obsoleted
-   return NS_ERROR_NOT_IMPLEMENTED;
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsCharsetAlias2::GetPreferred(const char* aAlias, char* oResult, PRInt32 aBufLength) 
-{
-   // this method should be obsoleted
-   return NS_ERROR_NOT_IMPLEMENTED;
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsCharsetAlias2::Equals(const nsAString& aCharset1, const nsAString& aCharset2, PRBool* oResult)
-{
-   nsresult res = NS_OK;
-
-   if(aCharset1.Equals(aCharset2, nsCaseInsensitiveStringComparator())) {
-      *oResult = PR_TRUE;
-      return res;
-   }
-
-   if(aCharset1.IsEmpty() || aCharset2.IsEmpty()) {
-      *oResult = PR_FALSE;
-      return res;
-   }
-
-   *oResult = PR_FALSE;
-   nsString name1;
-   nsString name2;
-   res = this->GetPreferred(aCharset1, name1);
-   if(NS_SUCCEEDED(res)) {
-      res = this->GetPreferred(aCharset2, name2);
-      if(NS_SUCCEEDED(res)) {
-        *oResult = name1.Equals(name2, nsCaseInsensitiveStringComparator());
-      }
-   }
-   
-   return res;
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsCharsetAlias2::Equals(const PRUnichar* aCharset1, const PRUnichar* aCharset2, PRBool* oResult)
-{
-   // this method should be obsoleted
-   return NS_ERROR_NOT_IMPLEMENTED;
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsCharsetAlias2::Equals(const char* aCharset1, const char* aCharset2, PRBool* oResult)
-{
-   // this method should be obsoleted
-   return NS_ERROR_NOT_IMPLEMENTED;
-}
- 
-

mozilla/intl/uconv/src/nsCharsetConverterManager.cpp

@@ -1,479 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Pierre Phaneuf <pp@ludusdesign.com>
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsCOMPtr.h"
-#include "nsString.h"
-#include "nsReadableUtils.h"
-#include "nsUnicharUtils.h"
-#include "nsICharsetAlias.h"
-#include "nsIServiceManager.h"
-#include "nsICategoryManager.h"
-#include "nsICharsetConverterManager.h"
-#include "nsICharsetConverterManager2.h"
-#include "nsIStringBundle.h"
-#include "nsILocaleService.h"
-#include "nsUConvDll.h"
-#include "prmem.h"
-#include "nsCRT.h"
-
-#include "nsISupportsPrimitives.h"
-#include "nsICharsetDetector.h"
-
-// just for CIDs
-#include "nsIUnicodeDecodeHelper.h"
-#include "nsIUnicodeEncodeHelper.h"
-#include "nsCharsetConverterManager.h"
-
-static NS_DEFINE_CID(kStringBundleServiceCID, NS_STRINGBUNDLESERVICE_CID);
-static NS_DEFINE_CID(kLocaleServiceCID, NS_LOCALESERVICE_CID); 
-static NS_DEFINE_CID(kSupportsArrayCID, NS_SUPPORTSARRAY_CID); 
-
-// Pattern of cached, commonly used, single byte decoder
-#define NS_1BYTE_CODER_PATTERN "ISO-8859"
-#define NS_1BYTE_CODER_PATTERN_LEN 8
-
-// Class nsCharsetConverterManager [implementation]
-
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsCharsetConverterManager,
-                              nsICharsetConverterManager, 
-                              nsICharsetConverterManager2);
-
-nsCharsetConverterManager::nsCharsetConverterManager() 
-:mDataBundle(NULL), mTitleBundle(NULL)
-{
-  NS_INIT_REFCNT();
-}
-
-nsCharsetConverterManager::~nsCharsetConverterManager() 
-{
-  NS_IF_RELEASE(mDataBundle);
-  NS_IF_RELEASE(mTitleBundle);
-}
-
-
-nsresult nsCharsetConverterManager::RegisterConverterManagerData()
-{
-  nsresult rv;
-  nsCOMPtr<nsICategoryManager> catman = do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  RegisterConverterCategory(catman, NS_TITLE_BUNDLE_CATEGORY,
-                            "chrome://global/locale/charsetTitles.properties");
-  RegisterConverterCategory(catman, NS_DATA_BUNDLE_CATEGORY,
-                            "resource:/res/charsetData.properties");
-
-  return NS_OK;
-}
-
-nsresult
-nsCharsetConverterManager::RegisterConverterCategory(nsICategoryManager* catman,
-                                                     const char* aCategory,
-                                                     const char* aURL)
-{
-  return catman->AddCategoryEntry(aCategory, aURL, "",
-                                  PR_TRUE, PR_TRUE, nsnull);
-}
-
-nsresult nsCharsetConverterManager::LoadExtensibleBundle(
-                                    const char* aCategory, 
-                                    nsIStringBundle ** aResult)
-{
-  nsresult res = NS_OK;
-
-  nsCOMPtr<nsIStringBundleService> sbServ = 
-           do_GetService(kStringBundleServiceCID, &res);
-  if (NS_FAILED(res)) return res;
-
-  res = sbServ->CreateExtensibleBundle(aCategory, aResult);
-  if (NS_FAILED(res)) return res;
-
-  return res;
-}
-
-nsresult nsCharsetConverterManager::GetBundleValue(nsIStringBundle * aBundle, 
-                                                   const nsIAtom * aName, 
-                                                   const nsAFlatString& aProp, 
-                                                   PRUnichar ** aResult)
-{
-  nsresult res = NS_OK;
-
-  nsAutoString key;
-  res = ((nsIAtom *) aName)->ToString(key);
-  if (NS_FAILED(res)) return res;
-
-  ToLowerCase(key); // we lowercase the main comparison key
-  if (!aProp.IsEmpty()) key.Append(aProp.get()); // yes, this param may be NULL
-
-  res = aBundle->GetStringFromName(key.get(), aResult);
-  return res;
-}
-
-nsresult nsCharsetConverterManager::GetBundleValue(nsIStringBundle * aBundle, 
-                                                   const nsIAtom * aName, 
-                                                   const nsAFlatString& aProp, 
-                                                   nsIAtom ** aResult)
-{
-  nsresult res = NS_OK;
-
-  PRUnichar * value;
-  res = GetBundleValue(aBundle, aName, aProp, &value);
-  if (NS_FAILED(res)) return res;
-
-  *aResult =  NS_NewAtom(value);
-  PR_Free(value);
-
-  return NS_OK;
-}
-
-
-//----------------------------------------------------------------------------
-// Interface nsICharsetConverterManager [implementation]
-
-NS_IMETHODIMP nsCharsetConverterManager::GetUnicodeEncoder(
-                                         const nsString * aDest, 
-                                         nsIUnicodeEncoder ** aResult)
-{
-  *aResult= nsnull;
-  nsresult res = NS_OK;
-
-  nsCAutoString contractid(
-                    NS_LITERAL_CSTRING(NS_UNICODEENCODER_CONTRACTID_BASE) +
-                    NS_LossyConvertUCS2toASCII(*aDest));
-
-  nsCOMPtr<nsIUnicodeEncoder> encoder;
-  // Always create an instance since encoders hold state.
-  encoder = do_CreateInstance(contractid.get(), &res);
-
-  if (NS_FAILED(res))
-    res = NS_ERROR_UCONV_NOCONV;
-  else
-  {
-    *aResult = encoder.get();
-    NS_ADDREF(*aResult);
-  }
-  return res;
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetUnicodeDecoder(
-                                         const nsString * aSrc, 
-                                         nsIUnicodeDecoder ** aResult)
-{
-  *aResult= nsnull;
-  nsresult res = NS_OK;;
-
-  NS_NAMED_LITERAL_CSTRING(kUnicodeDecoderContractIDBase,
-                           NS_UNICODEDECODER_CONTRACTID_BASE);
-
-  nsCAutoString contractid(kUnicodeDecoderContractIDBase +
-                           NS_LossyConvertUCS2toASCII(*aSrc));
-
-  nsCOMPtr<nsIUnicodeDecoder> decoder;
-  if (!strncmp(contractid.get()+kUnicodeDecoderContractIDBase.Length(),
-               NS_1BYTE_CODER_PATTERN,
-               NS_1BYTE_CODER_PATTERN_LEN))
-  {
-    // Single byte decoders dont hold state. Optimize by using a service.
-    decoder = do_GetService(contractid.get(), &res);
-  }
-  else
-  {
-    decoder = do_CreateInstance(contractid.get(), &res);
-  }
-  if(NS_FAILED(res))
-    res = NS_ERROR_UCONV_NOCONV;
-  else
-  {
-    *aResult = decoder.get();
-    NS_ADDREF(*aResult);
-  }
-  return res;
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetLangGroup(
-                                         nsString * aCharset, 
-                                         nsIAtom ** aResult)
-{
-  if (aCharset == NULL) return NS_ERROR_NULL_POINTER;
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-  *aResult = NULL;
-
-  nsCOMPtr<nsIAtom> atom;
-  nsresult res = GetCharsetAtom(aCharset->get(), getter_AddRefs(atom));
-  if (NS_FAILED(res)) return res;
-
-  res = GetCharsetLangGroup(atom, aResult);
-  return res;
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetUnicodeDecoder(
-                                         const nsIAtom * aCharset, 
-                                         nsIUnicodeDecoder ** aResult)
-{
-  if (aCharset == NULL) return NS_ERROR_NULL_POINTER;
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-  *aResult = NULL;
-
-  // XXX use nsImmutableString
-  nsAutoString name;
-  NS_CONST_CAST(nsIAtom*, aCharset)->ToString(name);
-  return GetUnicodeDecoder(&name, aResult);
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetUnicodeEncoder(
-                                         const nsIAtom * aCharset, 
-                                         nsIUnicodeEncoder ** aResult)
-{
-  if (aCharset == NULL) return NS_ERROR_NULL_POINTER;
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-  *aResult = NULL;
-
-  // XXX use nsImmutableString
-  nsAutoString name;
-  NS_CONST_CAST(nsIAtom*, aCharset)->ToString(name);
-  return GetUnicodeEncoder(&name, aResult);
-}
-
-nsresult 
-nsCharsetConverterManager::GetList(const nsACString& aCategory,
-                                   const nsACString& aPrefix,
-                                   nsISupportsArray** aResult)
-{
-  if (aResult == NULL) 
-    return NS_ERROR_NULL_POINTER;
-  *aResult = NULL;
-
-  nsresult rv;
-  nsCOMPtr<nsIAtom> atom;
- 
-  nsCOMPtr<nsISupportsArray> array = do_CreateInstance(kSupportsArrayCID, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  nsCOMPtr<nsICategoryManager> catman = do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
-  if (NS_FAILED(rv)) return rv;
-  
-  nsCOMPtr<nsISimpleEnumerator> enumerator;
-  catman->EnumerateCategory(PromiseFlatCString(aCategory).get(), 
-                            getter_AddRefs(enumerator));
-
-  PRBool hasMore;
-  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore) {
-    nsCOMPtr<nsISupports> supports;
-    if (NS_FAILED(enumerator->GetNext(getter_AddRefs(supports))))
-      continue;
-    
-    nsCOMPtr<nsISupportsString> supStr = do_QueryInterface(supports);
-    if (!supStr)
-      continue;
-
-    nsCAutoString fullName(aPrefix);
-    
-    nsXPIDLCString name;
-    if (NS_FAILED(supStr->GetData(getter_Copies(name))))
-      continue;
-
-    fullName += name;
-    rv = GetCharsetAtom2(fullName.get(), getter_AddRefs(atom));
-    if (NS_FAILED(rv)) 
-      continue;
-    
-    rv = array->AppendElement(atom);
-  }
-    
-  NS_ADDREF(*aResult = array);
-  return NS_OK;
-}
-
-// we should change the interface so that we can just pass back a enumerator!
-NS_IMETHODIMP nsCharsetConverterManager::GetDecoderList(nsISupportsArray ** aResult)
-{
-  return GetList(NS_LITERAL_CSTRING(NS_UNICODEDECODER_NAME),
-                 NS_LITERAL_CSTRING(""), aResult);
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetEncoderList(
-                                         nsISupportsArray ** aResult)
-{
-  return GetList(NS_LITERAL_CSTRING(NS_UNICODEENCODER_NAME),
-                 NS_LITERAL_CSTRING(""), aResult);
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetDetectorList(
-                                         nsISupportsArray ** aResult)
-{
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-  *aResult = NULL;
-
-  return GetList(NS_LITERAL_CSTRING(NS_CHARSET_DETECTOR_CATEGORY),
-                 NS_LITERAL_CSTRING("chardet."), aResult);
-}
-
-// XXX Improve the implementation of this method. Right now, it is build on 
-// top of two things: the nsCharsetAlias service and the Atom engine. We can 
-// improve on both. First, make the nsCharsetAlias better, with its own hash 
-// table (not the StringBundle anymore) and a nicer file format. Second, 
-// reimplement the Atom engine for the specific Charset case - more optimal.
-// Finally, unify the two for even better performance.
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetAtom(
-                                         const PRUnichar * aCharset, 
-                                         nsIAtom ** aResult)
-{
-  NS_PRECONDITION(aCharset && aResult, "null param");
-  if (!aCharset)
-    return NS_ERROR_NULL_POINTER;
-
-  // We try to obtain the preferred name for this charset from the charset 
-  // aliases. If we don't get it from there, we just use the original string
-  nsDependentString charset(aCharset);
-  nsCOMPtr<nsICharsetAlias> csAlias( do_GetService(kCharsetAliasCID) );
-  NS_ASSERTION(csAlias, "failed to get the CharsetAlias service");
-  if (csAlias) {
-    nsAutoString pref;
-    nsresult res = csAlias->GetPreferred(charset, pref);
-    if (NS_SUCCEEDED(res)) {
-      *aResult = NS_NewAtom(pref);
-      return *aResult ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
-    }
-  }
-
-  *aResult = NS_NewAtom(charset);
-  return *aResult ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetAtom2(
-                                         const char * aCharset, 
-                                         nsIAtom ** aResult)
-{
-  nsAutoString str;
-  str.AssignWithConversion(aCharset);
-  return GetCharsetAtom(str.get(), aResult);
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetTitle(
-                                         const nsIAtom * aCharset, 
-                                         PRUnichar ** aResult)
-{
-  if (aCharset == NULL) return NS_ERROR_NULL_POINTER;
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-  *aResult = NULL;
-
-  nsresult res = NS_OK;
-
-  if (mTitleBundle == NULL) {
-    res = LoadExtensibleBundle(NS_TITLE_BUNDLE_CATEGORY, &mTitleBundle);
-    if (NS_FAILED(res)) return res;
-  }
-
-  res = GetBundleValue(mTitleBundle, aCharset, NS_LITERAL_STRING(".title"), aResult);
-  return res;
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetTitle2(
-                                         const nsIAtom * aCharset, 
-                                         nsString * aResult)
-{
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-
-  nsresult res = NS_OK;
-
-  PRUnichar * title;
-  res = GetCharsetTitle(aCharset, &title);
-  if (NS_FAILED(res)) return res;
-
-  aResult->Assign(title);
-  PR_Free(title);
-  return res;
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetData(
-                                         const nsIAtom * aCharset, 
-                                         const PRUnichar * aProp,
-                                         PRUnichar ** aResult)
-{
-  if (aCharset == NULL) return NS_ERROR_NULL_POINTER;
-  // aProp can be NULL
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-  *aResult = NULL;
-
-  nsresult res = NS_OK;
-
-  if (mDataBundle == NULL) {
-    res = LoadExtensibleBundle(NS_DATA_BUNDLE_CATEGORY, &mDataBundle);
-    if (NS_FAILED(res)) return res;
-  }
-
-  res = GetBundleValue(mDataBundle, aCharset, nsDependentString(aProp), aResult);
-  return res;
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetData2(
-                                         const nsIAtom * aCharset, 
-                                         const PRUnichar * aProp,
-                                         nsString * aResult)
-{
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-
-  nsresult res = NS_OK;
-
-  PRUnichar * data;
-  res = GetCharsetData(aCharset, aProp, &data);
-  if (NS_FAILED(res)) return res;
-
-  aResult->Assign(data);
-  PR_Free(data);
-  return res;
-}
-
-NS_IMETHODIMP nsCharsetConverterManager::GetCharsetLangGroup(
-                                         const nsIAtom * aCharset, 
-                                         nsIAtom ** aResult)
-{
-  if (aCharset == NULL) return NS_ERROR_NULL_POINTER;
-  if (aResult == NULL) return NS_ERROR_NULL_POINTER;
-  *aResult = NULL;
-
-  nsresult res = NS_OK;
-
-  if (mDataBundle == NULL) {
-    res = LoadExtensibleBundle(NS_DATA_BUNDLE_CATEGORY, &mDataBundle);
-    if (NS_FAILED(res)) return res;
-  }
-
-  res = GetBundleValue(mDataBundle, aCharset, NS_LITERAL_STRING(".LangGroup"), aResult);
-  return res;
-}

mozilla/intl/uconv/src/nsCharsetConverterManager.h

@@ -1,91 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-#ifndef nsCharsetConverterManager_h__
-#define nsCharsetConverterManager_h__
-
-#include "nsISupports.h"
-#include "nsICharsetConverterManager.h"
-#include "nsIStringBundle.h"
-#include "nsISupportsArray.h"
-#include "nsIRegistry.h"
-
-class nsCharsetConverterManager : public nsICharsetConverterManager, 
-public nsICharsetConverterManager2
-{
-  NS_DECL_ISUPPORTS
-  NS_DECL_NSICHARSETCONVERTERMANAGER2
-
-public:
-
-  nsCharsetConverterManager();
-  virtual ~nsCharsetConverterManager();
-
-  NS_IMETHOD GetUnicodeEncoder(const nsString * aDest, 
-      nsIUnicodeEncoder ** aResult);
-  NS_IMETHOD GetUnicodeDecoder(const nsString * aSrc, 
-      nsIUnicodeDecoder ** aResult);
-  NS_IMETHOD GetCharsetLangGroup(nsString * aCharset, nsIAtom ** aResult);
-
-private:
-
-  nsIStringBundle * mDataBundle;
-  nsIStringBundle * mTitleBundle;
-
-  nsresult LoadExtensibleBundle(const char * aRegistryKey, 
-      nsIStringBundle ** aResult);
-
-  static nsresult RegisterConverterCategory(nsICategoryManager*,
-                                            const char* aCategory,
-                                            const char* aURL);
-
-  nsresult GetBundleValue(nsIStringBundle * aBundle, const nsIAtom * aName, 
-    const nsAFlatString& aProp, PRUnichar ** aResult);
-
-  nsresult GetBundleValue(nsIStringBundle * aBundle, const nsIAtom * aName, 
-    const nsAFlatString& aProp, nsIAtom ** aResult);      
-
-  nsresult GetList(const nsACString& aCategory,
-                   const nsACString& aPrefix, nsISupportsArray** aResult);
-public:
-  static nsresult RegisterConverterManagerData();
-
-};
-
-#endif // nsCharsetConverterManager_h__
-
-

mozilla/intl/uconv/src/nsConverterInputStream.cpp

@@ -1,153 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsConverterInputStream.h"
-#include "nsICharsetConverterManager.h"
-#include "nsIServiceManager.h"
-
-#define CONVERTER_BUFFER_SIZE 8192
-
-NS_IMPL_ISUPPORTS1(nsConverterInputStream, nsIConverterInputStream)
-    
-static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
-
-NS_IMETHODIMP
-nsConverterInputStream::Init(nsIInputStream* aStream,
-                             const PRUnichar *aCharset,
-                             PRInt32 aBufferSize)
-{
-    nsresult rv;
-
-    if (aBufferSize <=0) aBufferSize=CONVERTER_BUFFER_SIZE;
-    
-    // get the decoder
-    nsCOMPtr<nsICharsetConverterManager> ccm =
-        do_GetService(kCharsetConverterManagerCID, &rv);
-    if (NS_FAILED(rv)) return nsnull;
-
-    nsAutoString charset;
-    if (aCharset)
-        charset.Assign(aCharset);
-    else
-        charset.Assign(NS_LITERAL_STRING("ISO-8859-1"));
-    
-    rv = ccm->GetUnicodeDecoder(&charset, getter_AddRefs(mConverter));
-    if (NS_FAILED(rv)) return rv;
- 
-    // set up our buffers
-    rv = NS_NewByteBuffer(getter_AddRefs(mByteData), nsnull, aBufferSize);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = NS_NewUnicharBuffer(getter_AddRefs(mUnicharData), nsnull, aBufferSize);
-    if (NS_FAILED(rv)) return rv;
-
-    mInput = aStream;
-    
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsConverterInputStream::Close()
-{
-    mInput = nsnull;
-    mConverter = nsnull;
-    mByteData = nsnull;
-    mUnicharData = nsnull;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsConverterInputStream::Read(PRUnichar* aBuf,
-                             PRUint32 aOffset,
-                             PRUint32 aCount,
-                             PRUint32 *aReadCount)
-{
-  NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
-  PRUint32 rv = mUnicharDataLength - mUnicharDataOffset;
-  nsresult errorCode;
-  if (0 == rv) {
-    // Fill the unichar buffer
-    rv = Fill(&errorCode);
-    if (rv <= 0) {
-      *aReadCount = 0;
-      return errorCode;
-    }
-  }
-  if (rv > aCount) {
-    rv = aCount;
-  }
-  memcpy(aBuf + aOffset, mUnicharData->GetBuffer() + mUnicharDataOffset,
-         rv * sizeof(PRUnichar));
-  mUnicharDataOffset += rv;
-  *aReadCount = rv;
-  return NS_OK;
-}
-
-PRInt32
-nsConverterInputStream::Fill(nsresult * aErrorCode)
-{
-  if (nsnull == mInput) {
-    // We already closed the stream!
-    *aErrorCode = NS_BASE_STREAM_CLOSED;
-    return -1;
-  }
-
-  NS_ASSERTION(mByteData->GetLength() >= mByteDataOffset, "unsigned madness");
-  PRUint32 remainder = mByteData->GetLength() - mByteDataOffset;
-  mByteDataOffset = remainder;
-  PRInt32 nb = mByteData->Fill(aErrorCode, mInput, remainder);
-  if (nb <= 0) {
-    // Because we assume a many to one conversion, the lingering data
-    // in the byte buffer must be a partial conversion
-    // fragment. Because we know that we have recieved no more new
-    // data to add to it, we can't convert it. Therefore, we discard
-    // it.
-    return nb;
-  }
-  NS_ASSERTION(remainder + nb == mByteData->GetLength(), "bad nb");
-
-  // Now convert as much of the byte buffer to unicode as possible
-  PRInt32 dstLen = mUnicharData->GetBufferSize();
-  PRInt32 srcLen = remainder + nb;
-  *aErrorCode = mConverter->Convert(mByteData->GetBuffer(), &srcLen,
-                                    mUnicharData->GetBuffer(), &dstLen);
-  mUnicharDataOffset = 0;
-  mUnicharDataLength = dstLen;
-  mByteDataOffset += srcLen;
-  return dstLen;
-}

mozilla/intl/uconv/src/nsConverterInputStream.h

@@ -1,89 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsIConverterInputStream.h"
-#include "nsString.h"
-
-#include "nsCOMPtr.h"
-#include "nsIUnicodeDecoder.h"
-#include "nsIByteBuffer.h"
-#include "nsIUnicharBuffer.h"
-
-#define NS_CONVERTERINPUTSTREAM_CONTRACTID "@mozilla.org/intl/converter-input-stream;1"
-
-// {2BC2AD62-AD5D-4b7b-A9DB-F74AE203C527}
-#define NS_CONVERTERINPUTSTREAM_CID \
-  { 0x2bc2ad62, 0xad5d, 0x4b7b, \
-   { 0xa9, 0xdb, 0xf7, 0x4a, 0xe2, 0x3, 0xc5, 0x27 } }
-
-
-
-class nsConverterInputStream : nsIConverterInputStream {
-
- public:
-    NS_DECL_ISUPPORTS
-    NS_IMETHOD Read(PRUnichar* aBuf,
-                    PRUint32 aOffset,
-                    PRUint32 aCount,
-                    PRUint32 *aReadCount);
-    NS_IMETHOD Close();
-    NS_IMETHOD Init(nsIInputStream* aStream, const PRUnichar *aCharset,
-                    PRInt32 aBufferSize);
-
-    nsConverterInputStream() :
-        mByteDataOffset(0),
-        mUnicharDataOffset(0),
-        mUnicharDataLength(0) { NS_INIT_REFCNT(); }
-    
-    virtual ~nsConverterInputStream() {}
-
- private:
-
-
-    PRInt32 Fill(nsresult *aErrorCode);
-    
-    nsCOMPtr<nsIUnicodeDecoder> mConverter;
-    nsCOMPtr<nsIByteBuffer> mByteData;
-    nsCOMPtr<nsIUnicharBuffer> mUnicharData;
-    nsCOMPtr<nsIInputStream> mInput;
-    
-    PRUint32 mByteDataOffset;
-    PRUint32 mUnicharDataOffset;
-    PRUint32 mUnicharDataLength;
-    
-};

mozilla/intl/uconv/src/nsISO88591ToUnicode.cpp

@@ -1,62 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsUCSupport.h"
-#include "nsISO88591ToUnicode.h"
-
-//----------------------------------------------------------------------
-// Global functions and data [declaration]
-
-static const PRUint16 g_utMappingTable[] = {
-#include "cp1252.ut"
-};
-
-static const PRInt16 g_utShiftTable[] =  {
-  0, u1ByteCharset ,
-  ShiftCell(0,0,0,0,0,0,0,0)
-};
-
-//----------------------------------------------------------------------
-// Class nsISO88591ToUnicode [implementation]
-
-nsISO88591ToUnicode::nsISO88591ToUnicode() 
-: nsOneByteDecoderSupport((uShiftTable*) &g_utShiftTable, 
-                          (uMappingTable*) &g_utMappingTable)
-{
-}
-

mozilla/intl/uconv/src/nsISO88591ToUnicode.h

@@ -1,69 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsISO88591ToUnicode_h___
-#define nsISO88591ToUnicode_h___
-
-// Class ID for our ISO88591ToUnicode charset converter
-// {A3254CB0-8E20-11d2-8A98-00600811A836}
-#define NS_ISO88591TOUNICODE_CID \
-  { 0xa3254cb0, 0x8e20, 0x11d2, {0x8a, 0x98, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36}}
-
-#define NS_ISO88591TOUNICODE_CONTRACTID "@mozilla.org/intl/unicode/decoder;1?charset=ISO-8859-1"
-
-//----------------------------------------------------------------------
-// Class nsISO88591ToUnicode [declaration]
-
-/**
- * A character set converter from ISO88591 to Unicode.
- *
- * @created         23/Nov/1998
- * @author  Catalin Rotaru [CATA]
- */
-class nsISO88591ToUnicode : public nsOneByteDecoderSupport
-{
-public:
-
-  /**
-   * Class constructor.
-   */
-  nsISO88591ToUnicode();
-
-};
-
-#endif /* nsISO88591ToUnicode_h___ */

mozilla/intl/uconv/src/nsMacCharset.cpp

@@ -1,195 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include <Script.h>
-#include <TextCommon.h>
-#include "nsIPlatformCharset.h"
-#include "pratom.h"
-#include "nsURLProperties.h"
-#include "nsUConvDll.h"
-#include "nsCOMPtr.h"
-#include "nsIComponentManager.h"
-#include "nsIMacLocale.h"
-#include "nsLocaleCID.h"
-#include "nsReadableUtils.h"
-#include "nsPlatformCharset.h"
-
-static nsURLProperties *gInfo = nsnull;
-static PRInt32 gCnt = 0;
-
-NS_IMPL_ISUPPORTS1(nsPlatformCharset, nsIPlatformCharset);
-
-nsPlatformCharset::nsPlatformCharset()
-{
-  NS_INIT_REFCNT();
-  PR_AtomicIncrement(&gCnt);
-}
-nsPlatformCharset::~nsPlatformCharset()
-{
-  PR_AtomicDecrement(&gCnt);
-  if((0 == gCnt) && (nsnull != gInfo)) {
-  	delete gInfo;
-  	gInfo = nsnull;
-  }
-}
-
-nsresult nsPlatformCharset::InitInfo()
-{  
-  // load the .property file if necessary
-  if (gInfo == nsnull) {
-    nsURLProperties *info = new nsURLProperties( NS_LITERAL_CSTRING("resource:/res/maccharset.properties") );
-    NS_ASSERTION(info , "cannot open properties file");
-    NS_ENSURE_TRUE(info, NS_ERROR_FAILURE);
-    gInfo = info;
-  }
-
-  return NS_OK;
-}
-
-nsresult nsPlatformCharset::MapToCharset(short script, short region, nsAString& outCharset)
-{
-  switch (region) {
-    case verUS:
-    case verFrance:
-    case verGermany:
-      outCharset.Assign(NS_LITERAL_STRING("x-mac-roman"));
-      return NS_OK;
-    case verJapan:
-      outCharset.Assign(NS_LITERAL_STRING("Shift_JIS"));
-      return NS_OK;
-  }
-
-  // ensure the .property file is loaded
-  nsresult rv = InitInfo();
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  // try mapping from region then from script
-  nsAutoString key(NS_LITERAL_STRING("region."));
-  key.AppendInt(region, 10);
-
-  rv = gInfo->Get(key, outCharset);
-  if (NS_FAILED(rv)) {
-    key.Assign(NS_LITERAL_STRING("script."));
-    key.AppendInt(script, 10);
-    rv = gInfo->Get(key, outCharset);
-    // not found in the .property file, assign x-mac-roman
-    if (NS_FAILED(rv)) { 
-      outCharset.Assign(NS_LITERAL_STRING("x-mac-roman"));
-    }
-  }
-  
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-nsPlatformCharset::GetCharset(nsPlatformCharsetSel selector, nsAString& oResult)
-{
-  nsresult rv;
-  if (mCharset.IsEmpty()) {
-    rv = MapToCharset(
-           (short)(0x0000FFFF & ::GetScriptManagerVariable(smSysScript)),
-           (short)(0x0000FFFF & ::GetScriptManagerVariable(smRegionCode)),
-           mCharset);
-    NS_ENSURE_SUCCESS(rv, rv);
-  }
-
-  switch (selector) {
-    case  kPlatformCharsetSel_KeyboardInput:
-      rv = MapToCharset(
-             (short) (0x0000FFFF & ::GetScriptManagerVariable(smKeyScript)),
-             kTextRegionDontCare, oResult);
-      NS_ENSURE_SUCCESS(rv, rv);
-      break;
-    default:
-      oResult = mCharset;
-      break;
-  }
-
-   return NS_OK;
-}
-
-NS_IMETHODIMP 
-nsPlatformCharset::GetDefaultCharsetForLocale(const PRUnichar* localeName, PRUnichar** _retValue)
-{
-  nsCOMPtr<nsIMacLocale>	pMacLocale;
-  nsAutoString localeAsString(localeName), charset(NS_LITERAL_STRING("x-mac-roman"));
-  short script, language, region;
-	
-  nsresult rv;
-  pMacLocale = do_CreateInstance(NS_MACLOCALE_CONTRACTID, &rv);
-  if (NS_SUCCEEDED(rv)) {
-    rv = pMacLocale->GetPlatformLocale(&localeAsString, &script, &language, &region);
-    if (NS_SUCCEEDED(rv)) {
-      rv = MapToCharset(script, region, charset);
-    }
-  }
-  *_retValue = ToNewUnicode(charset);
-  NS_ENSURE_TRUE(*_retValue, NS_ERROR_OUT_OF_MEMORY);
-  
-  return rv;
-}
-
-NS_IMETHODIMP 
-nsPlatformCharset::Init()
-{
-  return NS_OK;
-}
-
-nsresult 
-nsPlatformCharset::MapToCharset(nsAString& inANSICodePage, nsAString& outCharset)
-{
-  return NS_OK;
-}
-
-nsresult
-nsPlatformCharset::InitGetCharset(nsAString &oString)
-{
-  return NS_OK;
-}
-
-nsresult
-nsPlatformCharset::ConvertLocaleToCharsetUsingDeprecatedConfig(nsAutoString& locale, nsAString& oResult)
-{
-  return NS_OK;
-}
-
-nsresult
-nsPlatformCharset::VerifyCharset(nsString &aCharset)
-{
-  return NS_OK;
-}

mozilla/intl/uconv/src/nsMacRomanToUnicode.cpp

@@ -1,62 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsUCSupport.h"
-#include "nsMacRomanToUnicode.h"
-
-//----------------------------------------------------------------------
-// Global functions and data [declaration]
-
-static const PRUint16 g_MacRomanMappingTable[] = {
-#include "macroman.ut"
-};
-
-static const PRInt16 g_MacRomanShiftTable[] =  {
-  1, u1ByteCharset ,
-  ShiftCell(0,0,0,0,0,0,0,0)
-};
-
-//----------------------------------------------------------------------
-// Class nsMacRomanToUnicode [implementation]
-
-nsMacRomanToUnicode::nsMacRomanToUnicode() 
-: nsTableDecoderSupport((uShiftTable*) &g_MacRomanShiftTable, 
-                        (uMappingTable*) &g_MacRomanMappingTable, 1)
-{
-}
-

mozilla/intl/uconv/src/nsMacRomanToUnicode.h

@@ -1,74 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsMacRomanToUnicode_h___
-#define nsMacRomanToUnicode_h___
-
-// Class ID for our MacRomanToUnicode charset converter
-// {7B8556A1-EC79-11d2-8AAC-00600811A836}
-#define NS_MACROMANTOUNICODE_CID \
-  { 0x7b8556a1, 0xec79, 0x11d2, {0x8a, 0xac, 0x0, 0x60, 0x8, 0x11, 0xa8, 0x36}}
-
-#define NS_MACROMANTOUNICODE_CONTRACTID "@mozilla.org/intl/unicode/decoder;1?charset=x-mac-roman"
-
-//#define NS_ERROR_UCONV_NOMACROMANTOUNICODE   
-//  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_UCONV, 0x31)
-
-//----------------------------------------------------------------------
-// Class nsMacRomanToUnicode [declaration]
-
-/**
- * A character set converter from MacRoman to Unicode.
- *
- * @created         05/Apr/1999
- * @author  Catalin Rotaru [CATA]
- */
-class nsMacRomanToUnicode : public nsTableDecoderSupport
-{
-public:
-
-  /**
-   * Class constructor.
-   */
-  nsMacRomanToUnicode();
-
-protected:
-
-};
-
-#endif /* nsMacRomanToUnicode_h___ */

mozilla/intl/uconv/src/nsMappingCache.cpp

@@ -1,81 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1999
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsMappingCache.h"
-
-typedef struct {
-  PRInt16 mask;
-  PRInt16 reserved;
-  PRUint32 data[1] ;
-} nsMappingCacheBase;
-
-typedef struct {
-  PRInt16 mask;
-  PRInt16 reserved;
-  PRUint32 data[64] ;
-} nsMappingCache64;
-
-typedef struct {
-  PRInt16 mask;
-  PRInt16 reserved;
-  PRUint32 data[128] ;
-} nsMappingCache128;
-
-typedef struct {
-  PRInt16 mask;
-  PRInt16 reserved;
-  PRUint32 data[256] ;
-} nsMappingCache256;
-
-typedef struct {
-  PRInt16 mask;
-  PRInt16 reserved;
-  PRUint32 data[512] ;
-} nsMappingCache512;
-
-nsresult nsMappingCache::CreateCache(nsMappingCacheType aType, nsIMappingCache* aResult)
-{
-  // to be implemented
-  return NS_OK;
-}
-
-nsresult nsMappingCache::DestroyCache(nsIMappingCache aCache)
-{
-  // to be implemented
-  return NS_OK;
-}

mozilla/intl/uconv/src/nsMappingCache.h

@@ -1,59 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsMappingCache_h__
-#define nsMappingCache_h__
-
-
-#include "nsIMappingCache.h"
-#include "nsError.h"
-
-
-class nsMappingCache {
-public:
-  /**
-   * Create a Mapping Cache
-   */
-  static nsresult CreateCache(nsMappingCacheType aType, nsIMappingCache* aResult);
-
-  /**
-   * Destroy a Mapping Cache
-   */
-  static nsresult DestroyCache(nsIMappingCache aCache);
-};
-#endif /* nsMappingCache_h__ */

mozilla/intl/uconv/src/nsOS2Charset.cpp

@@ -1,148 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * 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): 
- *   John Fairhurst
- *   Henry Sobotka
- *   IBM Corp.
- */
-#include "nsIPlatformCharset.h"
-#include "nsURLProperties.h"
-#include "pratom.h"
-#define INCL_PM
-#include <os2.h>
-#include "nsUConvDll.h"
-#include "nsIOS2Locale.h"
-#include "nsCOMPtr.h"
-#include "nsLocaleCID.h"
-#include "nsIComponentManager.h"
-#include "nsPlatformCharset.h"
-
-static nsURLProperties *gInfo = nsnull;
-static PRInt32 gCnt= 0;
-
-NS_IMPL_ISUPPORTS1(nsPlatformCharset, nsIPlatformCharset);
-
-nsPlatformCharset::nsPlatformCharset()
-{
-  NS_INIT_REFCNT();
-  PR_AtomicIncrement(&gCnt); // count for gInfo
-
-  // XXX We should make the following block critical section
-  if(nsnull == gInfo)
-  {
-    nsURLProperties *info = new nsURLProperties(NS_LITERAL_CSTRING("resource:/res/os2charset.properties"));
-    NS_ASSERTION( info , " cannot create nsURLProperties");
-    gInfo = info;
-  }
-  NS_ASSERTION(gInfo, "Cannot open property file");
-  if( gInfo ) 
-  {
-    UINT acp = ::WinQueryCp(HMQ_CURRENT);
-    PRInt32 acpint = (PRInt32)(acp & 0x00FFFF);
-    nsAutoString acpKey(NS_LITERAL_STRING("os2."));
-    acpKey.AppendInt(acpint, 10);
-
-    nsresult res = gInfo->Get(acpKey, mCharset);
-    if(NS_FAILED(res)) {
-      mCharset.Assign(NS_LITERAL_STRING("IBM850"));
-    }
-
-  } else {
-    mCharset.Assign(NS_LITERAL_STRING("IBM850"));
-  }
-}
-
-nsPlatformCharset::~nsPlatformCharset()
-{
-  PR_AtomicDecrement(&gCnt);
-  if(0 == gCnt) {
-    delete gInfo;
-    gInfo = nsnull;
-  }
-}
-
-NS_IMETHODIMP
-nsPlatformCharset::GetCharset(nsPlatformCharsetSel selector, nsAString& oResult)
-{
-  if ((selector == kPlatformCharsetSel_4xBookmarkFile) || (selector == kPlatformCharsetSel_4xPrefsJS)) {
-    if ((mCharset.Find("IBM850", IGNORE_CASE) != -1) || (mCharset.Find("IBM437", IGNORE_CASE) != -1)) 
-      oResult.Assign(NS_LITERAL_STRING("ISO-8859-1"));
-    else if (mCharset.Find("IBM852", IGNORE_CASE) != -1)
-      oResult.Assign(NS_LITERAL_STRING("windows-1250"));
-    else if ((mCharset.Find("IBM855", IGNORE_CASE) != -1) || (mCharset.Find("IBM866", IGNORE_CASE) != -1))
-      oResult.Assign(NS_LITERAL_STRING("windows-1251"));
-    else if ((mCharset.Find("IBM869", IGNORE_CASE) != -1) || (mCharset.Find("IBM813", IGNORE_CASE) != -1))
-      oResult.Assign(NS_LITERAL_STRING("windows-1253"));
-    else if (mCharset.Find("IBM857", IGNORE_CASE) != -1)
-      oResult.Assign(NS_LITERAL_STRING("windows-1254"));
-    else
-      oResult = mCharset;
-  } else {
-    oResult = mCharset;
-  }
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPlatformCharset::GetDefaultCharsetForLocale(const PRUnichar* localeName, PRUnichar** _retValue)
-{
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-nsPlatformCharset::Init()
-{
-  return NS_OK;
-}
-nsresult 
-nsPlatformCharset::MapToCharset(short script, short region, nsAString& outCharset)
-{
-  return NS_OK;
-}
-
-nsresult 
-nsPlatformCharset::MapToCharset(nsAString& inANSICodePage, nsAString& outCharset)
-{
-  return NS_OK;
-}
-
-nsresult
-nsPlatformCharset::InitGetCharset(nsAString &oString)
-{
-  return NS_OK;
-}
-
-nsresult
-nsPlatformCharset::ConvertLocaleToCharsetUsingDeprecatedConfig(nsAutoString& locale, nsAString& oResult)
-{
-  return NS_OK;
-}
-
-nsresult
-nsPlatformCharset::VerifyCharset(nsString &aCharset)
-{
-  return NS_OK;
-}
-
-nsresult 
-nsPlatformCharset::InitInfo()
-{  
-  return NS_OK;
-}

mozilla/intl/uconv/src/nsPlatformCharset.h

@@ -1,70 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-#ifndef nsPlatformCharset_h__
-#define nsPlatformCharset_h__
-
-#include "nsIPlatformCharset.h"
-
-class nsPlatformCharset : public nsIPlatformCharset
-{
-  NS_DECL_ISUPPORTS
-
-public:
-
-  nsPlatformCharset();
-  virtual ~nsPlatformCharset();
-
-  NS_IMETHOD Init();
-  NS_IMETHOD GetCharset(nsPlatformCharsetSel selector, nsAString& oResult);
-  NS_IMETHOD GetDefaultCharsetForLocale(const PRUnichar* localeName, PRUnichar** _retValue);
-
-private:
-  nsString mCharset;
-  nsString mLocale; // remember the locale & charset
-
-  nsresult InitInfo();
-  nsresult MapToCharset(short script, short region, nsAString& outCharset); 
-  nsresult MapToCharset(nsAString& inANSICodePage, nsAString& outCharset);
-  nsresult InitGetCharset(nsAString& oString);
-  nsresult ConvertLocaleToCharsetUsingDeprecatedConfig(nsAutoString& locale, nsAString& oResult);
-  nsresult VerifyCharset(nsString &aCharset);
-};
-
-#endif // nsPlatformCharset_h__
-
-

mozilla/intl/uconv/src/nsScriptableUConv.cpp

@@ -1,172 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Makoto Kato <m_kato@ga2.so-net.ne.jp >
- *   Ryoichi Furukawa <oliver@1000cp.com>
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "pratom.h"
-#include "nsString.h"
-#include "nsReadableUtils.h"
-#include "nsIServiceManager.h"
-#include "nsICharsetConverterManager.h"
-#include "nsICharsetConverterManager2.h"
-#include "nsIScriptableUConv.h"
-#include "nsScriptableUConv.h"
-#include "nsCRT.h"
-
-#include "nsIPlatformCharset.h"
-
-static NS_DEFINE_CID(kIScriptableUnicodeConverterCID, NS_ISCRIPTABLEUNICODECONVERTER_CID);
-static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
-
-static PRInt32          gInstanceCount = 0;
-
-/* Implementation file */
-NS_IMPL_ISUPPORTS1(nsScriptableUnicodeConverter, nsIScriptableUnicodeConverter)
-
-nsScriptableUnicodeConverter::nsScriptableUnicodeConverter()
-{
-  NS_INIT_REFCNT();
-  PR_AtomicIncrement(&gInstanceCount);
-}
-
-nsScriptableUnicodeConverter::~nsScriptableUnicodeConverter()
-{
-  PR_AtomicDecrement(&gInstanceCount);
-}
-
-/* string ConvertFromUnicode ([const] in wstring src); */
-NS_IMETHODIMP
-nsScriptableUnicodeConverter::ConvertFromUnicode(const PRUnichar *aSrc, char **_retval)
-{
-  if (!mEncoder)
-    return NS_ERROR_FAILURE;
-
-  nsresult rv = NS_OK;
-  PRInt32 inLength = nsCRT::strlen(aSrc);
-  PRInt32 outLength;
-  rv = mEncoder->GetMaxLength(aSrc, inLength, &outLength);
-  if (NS_SUCCEEDED(rv)) {
-    *_retval = (char*) nsMemory::Alloc(outLength+1);
-    if (!*_retval)
-      return NS_ERROR_OUT_OF_MEMORY;
-
-    rv = mEncoder->Convert(aSrc, &inLength, *_retval, &outLength);
-    if (NS_SUCCEEDED(rv))
-    {
-      (*_retval)[outLength] = '\0';
-      return NS_OK;
-    }
-    nsMemory::Free(*_retval);
-  }
-  *_retval = nsnull;
-  return NS_ERROR_FAILURE;
-}
-
-/* wstring ConvertToUnicode ([const] in string src); */
-NS_IMETHODIMP
-nsScriptableUnicodeConverter::ConvertToUnicode(const char *aSrc, PRUnichar **_retval)
-{
-  if (!mDecoder)
-    return NS_ERROR_FAILURE;
-
-  nsresult rv = NS_OK;
-  PRInt32 inLength = strlen(aSrc);
-  PRInt32 outLength;
-  rv = mDecoder->GetMaxLength(aSrc, inLength, &outLength);
-  if (NS_SUCCEEDED(rv))
-  {
-    *_retval = (PRUnichar*) nsMemory::Alloc((outLength+1)*sizeof(PRUnichar));
-    if (!*_retval)
-      return NS_ERROR_OUT_OF_MEMORY;
-
-    rv = mDecoder->Convert(aSrc, &inLength, *_retval, &outLength);
-    if (NS_SUCCEEDED(rv))
-    {
-      (*_retval)[outLength] = 0;
-      return NS_OK;
-    }
-    nsMemory::Free(*_retval);
-  }
-  *_retval = nsnull;
-  return NS_ERROR_FAILURE;
-}
-
-/* attribute wstring charset; */
-NS_IMETHODIMP
-nsScriptableUnicodeConverter::GetCharset(PRUnichar * *aCharset)
-{
-  *aCharset = ToNewUnicode(mCharset);
-  if (!*aCharset)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsScriptableUnicodeConverter::SetCharset(const PRUnichar * aCharset)
-{
-  mCharset.Assign(aCharset);
-  return InitConverter();
-}
-
-nsresult
-nsScriptableUnicodeConverter::InitConverter()
-{
-  nsresult rv = NS_OK;
-  mEncoder = NULL ;
-
-  nsCOMPtr<nsICharsetConverterManager2> ccm2 = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
-
-  if (NS_SUCCEEDED( rv) && (nsnull != ccm2)) {
-    // get charset atom due to getting unicode converter
-    nsCOMPtr <nsIAtom> charsetAtom;
-    rv = ccm2->GetCharsetAtom(mCharset.get(), getter_AddRefs(charsetAtom));
-    if (NS_SUCCEEDED(rv)) {
-      // get an unicode converter
-      rv = ccm2->GetUnicodeEncoder(charsetAtom, getter_AddRefs(mEncoder));
-      if(NS_SUCCEEDED(rv)) {
-        rv = mEncoder->SetOutputErrorBehavior(nsIUnicodeEncoder::kOnError_Replace, nsnull, (PRUnichar)'?');
-        if(NS_SUCCEEDED(rv)) {
-          rv = ccm2->GetUnicodeDecoder(charsetAtom, getter_AddRefs(mDecoder));
-        }
-      }
-    }
-  }
-
-  return rv ;
-}

mozilla/intl/uconv/src/nsScriptableUConv.h

@@ -1,65 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: NPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is 
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Makoto Kato <m_kato@ga2.so-net.ne.jp >
- *   Ryoichi Furukawa <oliver@1000cp.com>
- *
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the NPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the NPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-
-#ifndef __nsScriptableUConv_h_
-#define __nsScriptableUConv_h_
-
-#include "nsICharsetConverterManager.h"
-#include "nsIScriptableUConv.h"
-
-class nsScriptableUnicodeConverter : public nsIScriptableUnicodeConverter
-{
-public:
-  NS_DECL_ISUPPORTS
-  NS_DECL_NSISCRIPTABLEUNICODECONVERTER
-
-  nsScriptableUnicodeConverter();
-  virtual ~nsScriptableUnicodeConverter();
-
-protected:
-  nsAutoString mCharset;
-  nsCOMPtr<nsIUnicodeEncoder> mEncoder;
-  nsCOMPtr<nsIUnicodeDecoder> mDecoder;
-
-  nsresult InitConverter();
-};
-
-#endif