diff options
Diffstat (limited to 'www-client/mozilla-firefox/files')
22 files changed, 2727 insertions, 0 deletions
diff --git a/www-client/mozilla-firefox/files/10MozillaFirefox b/www-client/mozilla-firefox/files/10MozillaFirefox new file mode 100644 index 000000000000..099c99810107 --- /dev/null +++ b/www-client/mozilla-firefox/files/10MozillaFirefox @@ -0,0 +1 @@ +LDPATH=/usr/lib/MozillaFirefox diff --git a/www-client/mozilla-firefox/files/digest-mozilla-firefox-0.9.3 b/www-client/mozilla-firefox/files/digest-mozilla-firefox-0.9.3 new file mode 100644 index 000000000000..a76e9602e97f --- /dev/null +++ b/www-client/mozilla-firefox/files/digest-mozilla-firefox-0.9.3 @@ -0,0 +1 @@ +MD5 641ebf96d2211b3c5527e88389b9687e firefox-0.9.3-source.tar.bz2 33945173 diff --git a/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0 b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0 new file mode 100644 index 000000000000..e6d2584b2eac --- /dev/null +++ b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0 @@ -0,0 +1 @@ +MD5 49c16a71f4de014ea471be81e46b1da8 firefox-1.0-source.tar.bz2 32686249 diff --git a/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0-r2 b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0-r2 new file mode 100644 index 000000000000..e6d2584b2eac --- /dev/null +++ b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0-r2 @@ -0,0 +1 @@ +MD5 49c16a71f4de014ea471be81e46b1da8 firefox-1.0-source.tar.bz2 32686249 diff --git a/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0-r3 b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0-r3 new file mode 100644 index 000000000000..e6d2584b2eac --- /dev/null +++ b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0-r3 @@ -0,0 +1 @@ +MD5 49c16a71f4de014ea471be81e46b1da8 firefox-1.0-source.tar.bz2 32686249 diff --git a/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0.1 b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0.1 new file mode 100644 index 000000000000..d93a4c1b13de --- /dev/null +++ b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0.1 @@ -0,0 +1 @@ +MD5 ebaea974fea9460ab7050fff76b41cb1 firefox-1.0.1-source.tar.bz2 32671529 diff --git a/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_pre-r2 b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_pre-r2 new file mode 100644 index 000000000000..8484ceb42494 --- /dev/null +++ b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_pre-r2 @@ -0,0 +1 @@ +MD5 ff9eae3b90b8573bf44293ea44bf3c50 firefox-1.0PR.1-source.tar.bz2 32380173 diff --git a/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_rc1 b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_rc1 new file mode 100644 index 000000000000..a8e293a143dd --- /dev/null +++ b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_rc1 @@ -0,0 +1 @@ +MD5 7a0411859fc5d5f647e211c24beaf94b firefox-1.0rc1-source.tar.bz2 32706624 diff --git a/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_rc2 b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_rc2 new file mode 100644 index 000000000000..b2270531c18c --- /dev/null +++ b/www-client/mozilla-firefox/files/digest-mozilla-firefox-1.0_rc2 @@ -0,0 +1 @@ +MD5 aab6ffe0e57de39b20d1c8ccef057171 firefox-1.0rc2-source.tar.bz2 32659115 diff --git a/www-client/mozilla-firefox/files/firefox b/www-client/mozilla-firefox/files/firefox new file mode 100644 index 000000000000..2994493a4c8d --- /dev/null +++ b/www-client/mozilla-firefox/files/firefox @@ -0,0 +1,141 @@ +#!/bin/bash +# +# Copyright 1999-2004 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/www-client/mozilla-firefox/files/firefox,v 1.1 2005/03/18 19:47:25 seemant Exp $ + +# Set MOZILLA_NEWTYPE to "window" in your environment if you prefer +# new Firefox windows instead of new tabs +newtype=${MOZILLA_NEWTYPE:-"window"} + +# Make sure necessary progs are in the PATH +PATH=/usr/bin:/bin:/usr/X11R6/bin:$PATH + +# Support both firefox and mozilla +case "$0" in + *fox*) + export MOZILLA_FIVE_HOME="/usr/lib/MozillaFirefox" + remote=$MOZILLA_FIVE_HOME/mozilla-xremote-client + mozbin=$MOZILLA_FIVE_HOME/firefox + grepfor=firefox-bin + ;; + + *mozilla*) + export MOZILLA_FIVE_HOME="/usr/lib/mozilla" + remote=$MOZILLA_FIVE_HOME/mozilla-xremote-client + # This is the old mozilla.sh which used to be installed as /usr/bin/mozilla. + # I have no idea what parts of it should be kept/dropped so I'm just calling + # it for now. + mozbin=$MOZILLA_FIVE_HOME/mozilla.sh + grepfor=mozilla-bin + ;; +esac + +# Validate the args and extract the urls +args=() +urls=() +while [[ $# -ne 0 ]] ; do + if [[ $1 == -* ]] ; then + case "${1#-}" in + height|width|CreateProfile|P|UILocale|contentLocale|remote|edit|chrome) + args=("${args[@]}" "$1" "$2") + shift 2 ;; + *) + args=("${args[@]}" "$1") + shift 1 ;; + esac + else + # check for relative path to a file, transform to absolute path + if [[ $1 != *://* && $1 != /* && -e $1 ]]; then + urls=("${urls[@]}" "file://$PWD/$1") + else + urls=("${urls[@]}" $1) + fi + shift + fi +done + +# Try to start in an existing session; check all screens +declare -a screens=( + $(xdpyinfo | awk ' + /^name of display:/ { + disp = substr($NF, 0, match($NF, /\.[^.]*$/)-1) + } + /^number of screens:/ { + for (i = 0; i < $NF; i++) printf("%s.%d\n", disp, i) + }') + ) + +# Attempt to fix bug 39797 by making sure MozillaFirefox is running +# on the DISPLAY prior to calling mozilla-xremote-client. The +# problem here is that mozilla-xremote-client will return a zero +# exit status if it contacts a Thunderbird-0.3 instance, even though +# Thunderbird can't handle the openURL request. :-( +# +# Note: This seems to be fixed with Thunderbird-0.4, which rejects the +# openURL request appropriately. +declare -a candidates=() +for s in $DISPLAY "${screens[@]}"; do + if DISPLAY=$s xwininfo -root -tree | grep -q "$grepfor"; then + candidates=("${candidates[@]}" $s) + fi +done + +# Make sure we'll get at least an empty window/tab +[[ ${#urls[@]} == 0 ]] && urls=('') + +# Handle multiple URLs by looping over the xremote call +for u in "${urls[@]}"; do + + # Try mozilla-xremote-client on each candidate screen. + # Only use mozilla-xremote-client if we have no other args (which + # must be passed to the browser binary). + if [[ ${#candidates[@]} > 0 && ${#args[*]} == 0 ]]; then + for s in "${candidates[@]}"; do + DISPLAY=$s $remote "openURL($u, new-$newtype)" && break + done + retval=$? + else + # simulate mozilla-xremote-client's response when it can't find an instance + retval=2 + fi + + # 2 = No running windows found, so start a new instance + # 3 = Browser is running, but doesn't handle openURL command + # (or it might be unresponsive) + if [[ $retval -eq 2 || $retval -eq 3 ]] ; then + + # Handle case of multiple URLs + if [[ ${#urls[@]} > 1 ]]; then + $mozbin "${args[@]}" "$u" & + if [[ -x /usr/bin/xtoolwait ]]; then + xtoolwait sleep 10 + else + sleep 10 # totally arbitrary without xtoolwait! :-( + fi + candidates=$DISPLAY # next time through, use $remote + args=() # and drop the args + continue + fi + + # Handle case of single URL + $mozbin "${args[@]}" "$u" & + break + + elif [[ $retval -eq 1 ]]; then + echo "Unable to connect to X server" >&2 + elif [[ $retval -ne 0 ]]; then + echo "Unknown error $retval from mozilla-xremote-client" >&2 + fi + +done + +# Will only wait here if firefox was started by this script +if ! wait; then + retval=$? + echo "${mozbin##*/} exited with non-zero status ($?)" >&2 +fi + +exit $retval + +# vim:expandtab sw=2: diff --git a/www-client/mozilla-firefox/files/firefox-0.8-gcc-3.4.patch b/www-client/mozilla-firefox/files/firefox-0.8-gcc-3.4.patch new file mode 100644 index 000000000000..9de10a1fae8c --- /dev/null +++ b/www-client/mozilla-firefox/files/firefox-0.8-gcc-3.4.patch @@ -0,0 +1,11 @@ +--- gfx/public/nsRegion.h.old 2003-03-25 02:57:42.000000000 +0000 ++++ gfx/public/nsRegion.h 2004-04-23 02:25:09.606368256 +0100 +@@ -234,7 +234,7 @@ + void MoveInto (nsRegion& aDestRegion) + { MoveInto (aDestRegion, mRectListHead.next); } + +- nsRegion (const nsRegion& aRegion); // Prevent copying of regions ++ public:nsRegion (const nsRegion& aRegion); // Prevent copying of regions + nsRegion& operator = (const nsRegion& aRegion); + }; + diff --git a/www-client/mozilla-firefox/files/firefox-0.9-init.tar.bz2 b/www-client/mozilla-firefox/files/firefox-0.9-init.tar.bz2 Binary files differnew file mode 100644 index 000000000000..c00209c6881b --- /dev/null +++ b/www-client/mozilla-firefox/files/firefox-0.9-init.tar.bz2 diff --git a/www-client/mozilla-firefox/files/firefox-0.9-nsFormHistory-crash-fix.patch b/www-client/mozilla-firefox/files/firefox-0.9-nsFormHistory-crash-fix.patch new file mode 100644 index 000000000000..afd4e1691689 --- /dev/null +++ b/www-client/mozilla-firefox/files/firefox-0.9-nsFormHistory-crash-fix.patch @@ -0,0 +1,47 @@ +Index: toolkit/components/satchel/src/nsFormHistory.cpp +=================================================================== +RCS file: /cvsroot/mozilla/toolkit/components/satchel/src/nsFormHistory.cpp,v +retrieving revision 1.13 +diff -u -9 -p -w -r1.13 nsFormHistory.cpp +--- toolkit/components/satchel/src/nsFormHistory.cpp 17 Jun 2004 00:13:16 -0000 1.13 ++++ toolkit/components/satchel/src/nsFormHistory.cpp 24 Jun 2004 06:56:29 -0000 +@@ -734,35 +734,38 @@ nsFormHistory::AutoCompleteSearch(const + if (RowMatch(row, aInputName, aInputValue, &value)) { + matchingRows.AppendElement(row); + matchingValues.AppendElement(value); + } + } while (row); + + // Turn auto array into flat array for quick sort, now that we + // know how many items there are + PRUint32 count = matchingRows.Count(); ++ ++ if (count > 0) { + PRUint32* items = new PRUint32[count]; + PRUint32 i; + for (i = 0; i < count; ++i) + items[i] = i; + +- NS_QuickSort(items, count, sizeof(nsIMdbRow*), ++ NS_QuickSort(items, count, sizeof(PRUint32), + SortComparison, &matchingValues); + + for (i = 0; i < count; ++i) { + // Place the sorted result into the autocomplete result + result->AddRow((nsIMdbRow *)matchingRows[items[i]]); + + // Free up these strings we owned. + delete (PRUnichar *) matchingValues[i]; + } + + delete[] items; ++ } + + PRUint32 matchCount; + result->GetMatchCount(&matchCount); + if (matchCount > 0) { + result->SetSearchResult(nsIAutoCompleteResult::RESULT_SUCCESS); + result->SetDefaultIndex(0); + } else { + result->SetSearchResult(nsIAutoCompleteResult::RESULT_NOMATCH); + result->SetDefaultIndex(-1); diff --git a/www-client/mozilla-firefox/files/icon/firefox-icon.png b/www-client/mozilla-firefox/files/icon/firefox-icon.png Binary files differnew file mode 100644 index 000000000000..b7ff7197cad1 --- /dev/null +++ b/www-client/mozilla-firefox/files/icon/firefox-icon.png diff --git a/www-client/mozilla-firefox/files/icon/mozillafirefox.desktop b/www-client/mozilla-firefox/files/icon/mozillafirefox.desktop new file mode 100644 index 000000000000..c9eb057275ff --- /dev/null +++ b/www-client/mozilla-firefox/files/icon/mozillafirefox.desktop @@ -0,0 +1,8 @@ +[Desktop Entry] +Name=Mozilla Firefox +Comment=Web Browser +Exec=/usr/bin/firefox %U +Icon=firefox-icon.png +Terminal=false +Type=Application +Categories=Application;Network; diff --git a/www-client/mozilla-firefox/files/mozilla-1.3-alpha-stubs.patch b/www-client/mozilla-firefox/files/mozilla-1.3-alpha-stubs.patch new file mode 100644 index 000000000000..3aa192be9246 --- /dev/null +++ b/www-client/mozilla-firefox/files/mozilla-1.3-alpha-stubs.patch @@ -0,0 +1,121 @@ +diff -Naur mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_linux_alpha.cpp mozilla-alpha-stubs/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_linux_alpha.cpp +--- mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_linux_alpha.cpp 2001-09-28 15:12:51.000000000 -0500 ++++ mozilla-alpha-stubs/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_linux_alpha.cpp 2003-03-18 09:50:06.000000000 -0600 +@@ -20,6 +20,7 @@ + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): ++ * Glen Nakamura <glen@imodulo.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 +@@ -37,8 +38,6 @@ + + /* Platform specific code to invoke XPCOM methods on native objects */ + +-/* contributed by Glen Nakamura <glen.nakamura@usa.net> */ +- + #include "xptcprivate.h" + + /* Prototype specifies unmangled function name and disables unused warning */ +@@ -163,7 +162,11 @@ + "bis $16,$16,$1\n\t" /* load "this" */ + "ldq $2,16($15)\n\t" /* load "methodIndex" */ + "ldq $1,0($1)\n\t" /* load vtable */ ++#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100 /* G++ V3 ABI */ ++ "s8addq $2,$31,$2\n\t" /* vtable index = "methodIndex" * 8 */ ++#else /* not G++ V3 ABI */ + "s8addq $2,16,$2\n\t" /* vtable index = "methodIndex" * 8 + 16 */ ++#endif /* G++ V3 ABI */ + "addq $1,$2,$1\n\t" + "ldq $27,0($1)\n\t" /* load address of function */ + "jsr $26,($27),0\n\t" /* call virtual function */ +@@ -176,4 +179,3 @@ + "ret $31,($26),1\n\t" + ".end XPTC_InvokeByIndex" + ); +- +diff -Naur mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_alpha.cpp mozilla-alpha-stubs/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_alpha.cpp +--- mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_alpha.cpp 2001-09-28 15:12:52.000000000 -0500 ++++ mozilla-alpha-stubs/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_alpha.cpp 2003-03-18 09:50:06.000000000 -0600 +@@ -20,6 +20,7 @@ + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): ++ * Glen Nakamura <glen@imodulo.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 +@@ -37,8 +38,6 @@ + + /* Implement shared vtbl methods. */ + +-/* contributed by Glen Nakamura <glen.nakamura@usa.net> */ +- + #include "xptcprivate.h" + + /* Prototype specifies unmangled function name and disables unused warning */ +@@ -188,23 +187,45 @@ + * nsresult nsXPTCStubBase::Stub##n() + * Sets register $1 to "methodIndex" and jumps to SharedStub. + */ ++#define STUB_MANGLED_ENTRY(n, symbol) \ ++ "#### Stub"#n" ####" "\n\t" \ ++ ".text" "\n\t" \ ++ ".align 5" "\n\t" \ ++ ".globl " symbol "\n\t" \ ++ ".ent " symbol "\n" \ ++symbol ":" "\n\t" \ ++ ".frame $30,0,$26,0" "\n\t" \ ++ "ldgp $29,0($27)" "\n" \ ++"$" symbol "..ng:" "\n\t" \ ++ ".prologue 1" "\n\t" \ ++ "lda $1,"#n "\n\t" \ ++ "br $31,$SharedStub..ng" "\n\t" \ ++ ".end " symbol ++ ++#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100 /* G++ V3 ABI */ ++ ++#define STUB_ENTRY(n) \ ++__asm__( \ ++ ".if "#n" < 10" "\n\t" \ ++ STUB_MANGLED_ENTRY(n, "_ZN14nsXPTCStubBase5Stub"#n"Ev") "\n\t" \ ++ ".elseif "#n" < 100" "\n\t" \ ++ STUB_MANGLED_ENTRY(n, "_ZN14nsXPTCStubBase6Stub"#n"Ev") "\n\t" \ ++ ".elseif "#n" < 1000" "\n\t" \ ++ STUB_MANGLED_ENTRY(n, "_ZN14nsXPTCStubBase7Stub"#n"Ev") "\n\t" \ ++ ".else" "\n\t" \ ++ ".err \"Stub"#n" >= 1000 not yet supported.\"" "\n\t" \ ++ ".endif" \ ++ ); ++ ++#else /* not G++ V3 ABI */ ++ + #define STUB_ENTRY(n) \ + __asm__( \ +- "#### Stub"#n" ####\n" \ +-".text\n\t" \ +- ".align 5\n\t" \ +- ".globl Stub"#n"__14nsXPTCStubBase\n\t" \ +- ".ent Stub"#n"__14nsXPTCStubBase\n" \ +-"Stub"#n"__14nsXPTCStubBase:\n\t" \ +- ".frame $30,0,$26,0\n\t" \ +- "ldgp $29,0($27)\n" \ +-"$Stub"#n"__14nsXPTCStubBase..ng:\n\t" \ +- ".prologue 1\n\t" \ +- "lda $1,"#n"\n\t" \ +- "br $31,$SharedStub..ng\n\t" \ +- ".end Stub"#n"__14nsXPTCStubBase" \ ++ STUB_MANGLED_ENTRY(n, "Stub"#n"__14nsXPTCStubBase") \ + ); + ++#endif /* G++ V3 ABI */ ++ + #define SENTINEL_ENTRY(n) \ + nsresult nsXPTCStubBase::Sentinel##n() \ + { \ +@@ -213,4 +234,3 @@ + } + + #include "xptcstubsdef.inc" +- diff --git a/www-client/mozilla-firefox/files/mozilla-firebird-amd64.patch b/www-client/mozilla-firefox/files/mozilla-firebird-amd64.patch new file mode 100644 index 000000000000..5dd2cb2503ed --- /dev/null +++ b/www-client/mozilla-firefox/files/mozilla-firebird-amd64.patch @@ -0,0 +1,1026 @@ +diff -ruN mozilla.old/config/mkdepend/imakemdep.h mozilla/config/mkdepend/imakemdep.h +--- mozilla.old/config/mkdepend/imakemdep.h 1998-09-05 00:22:25.000000000 -0400 ++++ mozilla/config/mkdepend/imakemdep.h 2003-09-27 16:20:55.105322104 -0400 +@@ -277,6 +277,9 @@ + # ifdef __i386__ + "-D__i386__", + # endif ++# ifdef __x86_64__ ++ "-D__x86_64__", ++# endif + # ifdef __GNUC__ + "-traditional", + # endif +diff -ruN mozilla.old/directory/c-sdk/ldap/libraries/liblber/lber-int.h mozilla/directory/c-sdk/ldap/libraries/liblber/lber-int.h +--- mozilla.old/directory/c-sdk/ldap/libraries/liblber/lber-int.h 2002-03-26 16:53:23.000000000 -0500 ++++ mozilla/directory/c-sdk/ldap/libraries/liblber/lber-int.h 2003-09-27 16:20:55.104322256 -0400 +@@ -236,23 +236,22 @@ + (((_l)&0xff0000)>>8) + (((_l)&0xff000000)>>24)) + #define LBER_NTOHL(_l) LBER_HTONL(_l) + +-#elif !defined(__alpha) || defined(VMS) ++#elif !defined(__x86_64__) && (!defined(__alpha) || defined(VMS)) + + #define LBER_HTONL( l ) htonl( l ) + #define LBER_NTOHL( l ) ntohl( l ) + + #else /* __alpha */ + /* +- * htonl and ntohl on the DEC Alpha under OSF 1 seem to only swap the +- * lower-order 32-bits of a (64-bit) long, so we define correct versions +- * here. ++ * htonl and ntohl on the 64-bit UNIX platforms only swap the lower-order ++ * 32-bits of a (64-bit) long, so we define correct versions here. + */ + #define LBER_HTONL( l ) (((long)htonl( (l) & 0x00000000FFFFFFFF )) << 32 \ + | htonl( ( (l) & 0xFFFFFFFF00000000 ) >> 32 )) + + #define LBER_NTOHL( l ) (((long)ntohl( (l) & 0x00000000FFFFFFFF )) << 32 \ + | ntohl( ( (l) & 0xFFFFFFFF00000000 ) >> 32 )) +-#endif /* __alpha */ ++#endif /* __alpha || __x86_64__ */ + + + /* function prototypes */ +diff -ruN mozilla.old/nsprpub/configure mozilla/nsprpub/configure +--- mozilla.old/nsprpub/configure 2003-05-19 15:05:42.000000000 -0400 ++++ mozilla/nsprpub/configure 2003-09-27 16:20:55.085325144 -0400 +@@ -3729,6 +3729,9 @@ + ia64) + PR_MD_ASFILES=os_Linux_ia64.s + ;; ++ x86_64) ++ PR_MD_ASFILES=os_Linux_x86_64.s ++ ;; + m68k) + CFLAGS="$CFLAGS -m68020-60" + CXXFLAGS="$CXXFLAGS -m68020-60" +diff -ruN mozilla.old/nsprpub/configure.in mozilla/nsprpub/configure.in +--- mozilla.old/nsprpub/configure.in 2003-05-19 15:05:48.000000000 -0400 ++++ mozilla/nsprpub/configure.in 2003-09-27 16:20:55.077326360 -0400 +@@ -1218,6 +1218,9 @@ + ia64) + PR_MD_ASFILES=os_Linux_ia64.s + ;; ++ x86_64) ++ PR_MD_ASFILES=os_Linux_x86_64.s ++ ;; + m68k) + CFLAGS="$CFLAGS -m68020-60" + CXXFLAGS="$CXXFLAGS -m68020-60" +diff -ruN mozilla.old/nsprpub/pr/include/md/_linux.cfg mozilla/nsprpub/pr/include/md/_linux.cfg +--- mozilla.old/nsprpub/pr/include/md/_linux.cfg 2003-02-26 18:53:38.000000000 -0500 ++++ mozilla/nsprpub/pr/include/md/_linux.cfg 2003-09-27 16:20:55.053330008 -0400 +@@ -182,6 +182,52 @@ + #define PR_BYTES_PER_WORD_LOG2 3 + #define PR_BYTES_PER_DWORD_LOG2 3 + ++#elif defined(__x86_64__) ++ ++#define IS_LITTLE_ENDIAN 1 ++#undef IS_BIG_ENDIAN ++#define IS_64 ++ ++#define PR_BYTES_PER_BYTE 1 ++#define PR_BYTES_PER_SHORT 2 ++#define PR_BYTES_PER_INT 4 ++#define PR_BYTES_PER_INT64 8 ++#define PR_BYTES_PER_LONG 8 ++#define PR_BYTES_PER_FLOAT 4 ++#define PR_BYTES_PER_DOUBLE 8 ++#define PR_BYTES_PER_WORD 8 ++#define PR_BYTES_PER_DWORD 8 ++ ++#define PR_BITS_PER_BYTE 8 ++#define PR_BITS_PER_SHORT 16 ++#define PR_BITS_PER_INT 32 ++#define PR_BITS_PER_INT64 64 ++#define PR_BITS_PER_LONG 64 ++#define PR_BITS_PER_FLOAT 32 ++#define PR_BITS_PER_DOUBLE 64 ++#define PR_BITS_PER_WORD 64 ++ ++#define PR_BITS_PER_BYTE_LOG2 3 ++#define PR_BITS_PER_SHORT_LOG2 4 ++#define PR_BITS_PER_INT_LOG2 5 ++#define PR_BITS_PER_INT64_LOG2 6 ++#define PR_BITS_PER_LONG_LOG2 6 ++#define PR_BITS_PER_FLOAT_LOG2 5 ++#define PR_BITS_PER_DOUBLE_LOG2 6 ++#define PR_BITS_PER_WORD_LOG2 6 ++ ++#define PR_ALIGN_OF_SHORT 2 ++#define PR_ALIGN_OF_INT 4 ++#define PR_ALIGN_OF_LONG 8 ++#define PR_ALIGN_OF_INT64 8 ++#define PR_ALIGN_OF_FLOAT 4 ++#define PR_ALIGN_OF_DOUBLE 8 ++#define PR_ALIGN_OF_POINTER 8 ++#define PR_ALIGN_OF_WORD 8 ++ ++#define PR_BYTES_PER_WORD_LOG2 3 ++#define PR_BYTES_PER_DWORD_LOG2 3 ++ + #elif defined(__mc68000__) + + #undef IS_LITTLE_ENDIAN +diff -ruN mozilla.old/nsprpub/pr/include/md/_linux.h mozilla/nsprpub/pr/include/md/_linux.h +--- mozilla.old/nsprpub/pr/include/md/_linux.h 2003-02-26 18:53:39.000000000 -0500 ++++ mozilla/nsprpub/pr/include/md/_linux.h 2003-09-27 16:20:55.053330008 -0400 +@@ -49,6 +49,8 @@ + #define _PR_SI_ARCHITECTURE "alpha" + #elif defined(__ia64__) + #define _PR_SI_ARCHITECTURE "ia64" ++#elif defined(__x86_64__) ++#define _PR_SI_ARCHITECTURE "x86-64" + #elif defined(__mc68000__) + #define _PR_SI_ARCHITECTURE "m68k" + #elif defined(__sparc__) +@@ -107,6 +109,19 @@ + #define _MD_ATOMIC_SET _PR_ia64_AtomicSet + #endif + ++#if defined(__x86_64__) ++#define _PR_HAVE_ATOMIC_OPS ++#define _MD_INIT_ATOMIC() ++extern PRInt32 _PR_x86_64_AtomicIncrement(PRInt32 *val); ++#define _MD_ATOMIC_INCREMENT _PR_x86_64_AtomicIncrement ++extern PRInt32 _PR_x86_64_AtomicDecrement(PRInt32 *val); ++#define _MD_ATOMIC_DECREMENT _PR_x86_64_AtomicDecrement ++extern PRInt32 _PR_x86_64_AtomicAdd(PRInt32 *ptr, PRInt32 val); ++#define _MD_ATOMIC_ADD _PR_x86_64_AtomicAdd ++extern PRInt32 _PR_x86_64_AtomicSet(PRInt32 *val, PRInt32 newval); ++#define _MD_ATOMIC_SET _PR_x86_64_AtomicSet ++#endif ++ + #define USE_SETJMP + #if defined(__GLIBC__) && __GLIBC__ >= 2 + #define _PR_POLL_AVAILABLE +diff -ruN mozilla.old/nsprpub/pr/src/io/prprf.c mozilla/nsprpub/pr/src/io/prprf.c +--- mozilla.old/nsprpub/pr/src/io/prprf.c 2003-02-26 18:53:42.000000000 -0500 ++++ mozilla/nsprpub/pr/src/io/prprf.c 2003-09-27 16:20:55.068327728 -0400 +@@ -51,7 +51,10 @@ + ** Note: on some platforms va_list is defined as an array, + ** and requires array notation. + */ +-#if (defined(LINUX) && defined(__powerpc__)) || \ ++#if (defined(LINUX) && defined(__x86_64__)) ++#include <stdarg.h> ++#define VARARGS_ASSIGN(foo, bar) __va_copy((foo), (bar)) ++#elif (defined(LINUX) && defined(__powerpc__)) || \ + (defined(LINUX) && defined(__s390__)) || \ + (defined(LINUX) && defined(__s390x__)) || \ + defined(WIN16) || defined(QNX) || \ +diff -ruN mozilla.old/nsprpub/pr/src/md/unix/os_Linux_x86_64.s mozilla/nsprpub/pr/src/md/unix/os_Linux_x86_64.s +--- mozilla.old/nsprpub/pr/src/md/unix/os_Linux_x86_64.s 1969-12-31 19:00:00.000000000 -0500 ++++ mozilla/nsprpub/pr/src/md/unix/os_Linux_x86_64.s 2003-09-27 16:20:55.068327728 -0400 +@@ -0,0 +1,91 @@ ++/ -*- Mode: C++; tab-width: 4; 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 the Netscape Portable Runtime (NSPR). ++/ ++/ The Initial Developer of the Original Code is Netscape ++/ Communications Corporation. Portions created by Netscape are ++/ Copyright (C) 2000 Netscape Communications Corporation. All ++/ Rights Reserved. ++/ ++/ Contributor(s): ++/ ++/ Alternatively, the contents of this file may be used under the ++/ terms of the GNU General Public License Version 2 or later (the ++/ "GPL"), in which case the provisions of the GPL are applicable ++/ instead of those above. If you wish to allow use of your ++/ version of this file only under the terms of the GPL and not to ++/ allow others to use your version of this file under the MPL, ++/ indicate your decision by deleting the provisions above and ++/ replace them with the notice and other provisions required by ++/ the GPL. If you do not delete the provisions above, a recipient ++/ may use your version of this file under either the MPL or the ++/ GPL. ++/ ++ ++/ PRInt32 _PR_x86_64_AtomicIncrement(PRInt32 *val) ++/ ++/ Atomically increment the integer pointed to by 'val' and return ++/ the result of the increment. ++/ ++ .text ++ .globl _PR_x86_64_AtomicIncrement ++ .align 4 ++_PR_x86_64_AtomicIncrement: ++ movl $1, %eax ++ lock ++ xaddl %eax, (%rdi) ++ incl %eax ++ ret ++ ++/ PRInt32 _PR_x86_64_AtomicDecrement(PRInt32 *val) ++/ ++/ Atomically decrement the integer pointed to by 'val' and return ++/ the result of the decrement. ++/ ++ .text ++ .globl _PR_x86_64_AtomicDecrement ++ .align 4 ++_PR_x86_64_AtomicDecrement: ++ movl $-1, %eax ++ lock ++ xaddl %eax, (%rdi) ++ decl %eax ++ ret ++ ++/ PRInt32 _PR_x86_64_AtomicSet(PRInt32 *val, PRInt32 newval) ++/ ++/ Atomically set the integer pointed to by 'val' to the new ++/ value 'newval' and return the old value. ++ .text ++ .globl _PR_x86_64_AtomicSet ++ .align 4 ++_PR_x86_64_AtomicSet: ++ movl %esi, %eax ++ lock ++ xchgl %eax, (%rdi) ++ ret ++ ++/ PRInt32 _PR_x86_64_AtomicAdd(PRInt32 *ptr, PRInt32 val) ++/ ++/ Atomically add 'val' to the integer pointed to by 'ptr' ++/ and return the result of the addition. ++/ ++ .text ++ .globl _PR_x86_64_AtomicAdd ++ .align 4 ++_PR_x86_64_AtomicAdd: ++ movl %esi, %eax ++ lock ++ xaddl %eax, (%rdi) ++ addl %esi, %eax ++ ret +diff -ruN mozilla.old/security/coreconf/Linux.mk mozilla/security/coreconf/Linux.mk +--- mozilla.old/security/coreconf/Linux.mk 2003-04-30 20:31:20.000000000 -0400 ++++ mozilla/security/coreconf/Linux.mk 2003-09-27 16:20:55.093323928 -0400 +@@ -66,6 +66,10 @@ + OS_REL_CFLAGS = -DLINUX1_2 -D_XOPEN_SOURCE + CPU_ARCH = ia64 + else ++ifeq ($(OS_TEST),x86_64) ++ OS_REL_CFLAGS = -DLINUX1_2 -D_XOPEN_SOURCE ++ CPU_ARCH = x86_64 ++else + ifeq ($(OS_TEST),sparc) + OS_REL_CFLAGS = -DLINUX1_2 -D_XOPEN_SOURCE + CPU_ARCH = sparc +@@ -107,6 +111,7 @@ + endif + endif + endif ++endif + + + LIBC_TAG = _glibc +diff -ruN mozilla.old/xpcom/reflect/xptcall/src/md/unix/Makefile.in mozilla/xpcom/reflect/xptcall/src/md/unix/Makefile.in +--- mozilla.old/xpcom/reflect/xptcall/src/md/unix/Makefile.in 2003-06-18 23:02:34.000000000 -0400 ++++ mozilla/xpcom/reflect/xptcall/src/md/unix/Makefile.in 2003-09-27 16:20:55.105322104 -0400 +@@ -55,6 +55,10 @@ + # Migrate other platforms here after testing + # + ifneq (,$(filter Linux,$(OS_ARCH))) ++# Linux/x86-64 ++ifeq (x86_64,$(OS_TEST)) ++CPPSRCS := xptcinvoke_x86_64_linux.cpp xptcstubs_x86_64_linux.cpp ++else + ifeq (86,$(findstring 86,$(OS_TEST))) + CPPSRCS := xptcinvoke_gcc_x86_unix.cpp xptcstubs_gcc_x86_unix.cpp + endif +@@ -66,6 +70,7 @@ + ASFILES := xptcstubs_asm_ipf64.s xptcinvoke_asm_ipf64.s + endif + endif ++endif + # + # BeOS/Intel (uses the same unixish_x86 code) + # +diff -ruN mozilla.old/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_x86_64_linux.cpp mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_x86_64_linux.cpp +--- mozilla.old/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_x86_64_linux.cpp 1969-12-31 19:00:00.000000000 -0500 ++++ mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_x86_64_linux.cpp 2003-09-27 16:20:55.105322104 -0400 +@@ -0,0 +1,174 @@ ++/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ ++// Platform specific code to invoke XPCOM methods on native objects ++ ++#include "xptcprivate.h" ++ ++// 6 integral parameters are passed in registers ++const PRUint32 GPR_COUNT = 6; ++ ++// 8 floating point parameters are passed in SSE registers ++const PRUint32 FPR_COUNT = 8; ++ ++// Remember that these 'words' are 64-bit long ++static inline void ++invoke_count_words(PRUint32 paramCount, nsXPTCVariant * s, ++ PRUint32 & nr_gpr, PRUint32 & nr_fpr, PRUint32 & nr_stack) ++{ ++ nr_gpr = 1; // skip one GP register for 'that' ++ nr_fpr = 0; ++ nr_stack = 0; ++ ++ /* Compute number of eightbytes of class MEMORY. */ ++ for (uint32 i = 0; i < paramCount; i++, s++) { ++ if (!s->IsPtrData() ++ && (s->type == nsXPTType::T_FLOAT || s->type == nsXPTType::T_DOUBLE)) { ++ if (nr_fpr < FPR_COUNT) ++ nr_fpr++; ++ else ++ nr_stack++; ++ } ++ else { ++ if (nr_gpr < GPR_COUNT) ++ nr_gpr++; ++ else ++ nr_stack++; ++ } ++ } ++} ++ ++static void ++invoke_copy_to_stack(PRUint64 * d, PRUint32 paramCount, nsXPTCVariant * s, ++ PRUint64 * gpregs, double * fpregs) ++{ ++ PRUint32 nr_gpr = 1; // skip one GP register for 'that' ++ PRUint32 nr_fpr = 0; ++ PRUint64 value; ++ ++ for (uint32 i = 0; i < paramCount; i++, s++) { ++ if (s->IsPtrData()) ++ value = (PRUint64) s->ptr; ++ else { ++ switch (s->type) { ++ case nsXPTType::T_FLOAT: break; ++ case nsXPTType::T_DOUBLE: break; ++ case nsXPTType::T_I8: value = s->val.i8; break; ++ case nsXPTType::T_I16: value = s->val.i16; break; ++ case nsXPTType::T_I32: value = s->val.i32; break; ++ case nsXPTType::T_I64: value = s->val.i64; break; ++ case nsXPTType::T_U8: value = s->val.u8; break; ++ case nsXPTType::T_U16: value = s->val.u16; break; ++ case nsXPTType::T_U32: value = s->val.u32; break; ++ case nsXPTType::T_U64: value = s->val.u64; break; ++ case nsXPTType::T_BOOL: value = s->val.b; break; ++ case nsXPTType::T_CHAR: value = s->val.c; break; ++ case nsXPTType::T_WCHAR: value = s->val.wc; break; ++ default: value = (PRUint64) s->val.p; break; ++ } ++ } ++ ++ if (!s->IsPtrData() && s->type == nsXPTType::T_DOUBLE) { ++ if (nr_fpr < FPR_COUNT) ++ fpregs[nr_fpr++] = s->val.d; ++ else { ++ *((double *)d) = s->val.d; ++ d++; ++ } ++ } ++ else if (!s->IsPtrData() && s->type == nsXPTType::T_FLOAT) { ++ if (nr_fpr < FPR_COUNT) ++ // The value in %xmm register is already prepared to ++ // be retrieved as a float. Therefore, we pass the ++ // value verbatim, as a double without conversion. ++ fpregs[nr_fpr++] = s->val.d; ++ else { ++ *((float *)d) = s->val.f; ++ d++; ++ } ++ } ++ else { ++ if (nr_gpr < GPR_COUNT) ++ gpregs[nr_gpr++] = value; ++ else ++ *d++ = value; ++ } ++ } ++} ++ ++extern "C" ++XPTC_PUBLIC_API(nsresult) ++XPTC_InvokeByIndex(nsISupports * that, PRUint32 methodIndex, ++ PRUint32 paramCount, nsXPTCVariant * params) ++{ ++ PRUint32 nr_gpr, nr_fpr, nr_stack; ++ invoke_count_words(paramCount, params, nr_gpr, nr_fpr, nr_stack); ++ ++ // Stack, if used, must be 16-bytes aligned ++ if (nr_stack) ++ nr_stack = (nr_stack + 1) & ~1; ++ ++ // Load parameters to stack, if necessary ++ PRUint64 *stack = (PRUint64 *) __builtin_alloca(nr_stack * 8); ++ PRUint64 gpregs[GPR_COUNT]; ++ double fpregs[FPR_COUNT]; ++ invoke_copy_to_stack(stack, paramCount, params, gpregs, fpregs); ++ ++ // Load FPR registers from fpregs[] ++ register double d0 asm("xmm0"); ++ register double d1 asm("xmm1"); ++ register double d2 asm("xmm2"); ++ register double d3 asm("xmm3"); ++ register double d4 asm("xmm4"); ++ register double d5 asm("xmm5"); ++ register double d6 asm("xmm6"); ++ register double d7 asm("xmm7"); ++ ++ switch (nr_fpr) { ++#define ARG_FPR(N) \ ++ case N+1: d##N = fpregs[N]; ++ ARG_FPR(7); ++ ARG_FPR(6); ++ ARG_FPR(5); ++ ARG_FPR(4); ++ ARG_FPR(3); ++ ARG_FPR(2); ++ ARG_FPR(1); ++ ARG_FPR(0); ++ case 0:; ++#undef ARG_FPR ++ } ++ ++ // Load GPR registers from gpregs[] ++ register PRUint64 a0 asm("rdi"); ++ register PRUint64 a1 asm("rsi"); ++ register PRUint64 a2 asm("rdx"); ++ register PRUint64 a3 asm("rcx"); ++ register PRUint64 a4 asm("r8"); ++ register PRUint64 a5 asm("r9"); ++ ++ switch (nr_gpr) { ++#define ARG_GPR(N) \ ++ case N+1: a##N = gpregs[N]; ++ ARG_GPR(5); ++ ARG_GPR(4); ++ ARG_GPR(3); ++ ARG_GPR(2); ++ ARG_GPR(1); ++ case 1: a0 = (PRUint64) that; ++ case 0:; ++#undef ARG_GPR ++ } ++ ++ // Ensure that assignments to SSE registers won't be optimized away ++ asm("" :: ++ "x" (d0), "x" (d1), "x" (d2), "x" (d3), ++ "x" (d4), "x" (d5), "x" (d6), "x" (d7)); ++ ++ // Get pointer to method ++ PRUint64 methodAddress = *((PRUint64 *)that); ++ methodAddress += 8 * methodIndex; ++ methodAddress = *((PRUint64 *)methodAddress); ++ ++ typedef PRUint32 (*Method)(PRUint64, PRUint64, PRUint64, PRUint64, PRUint64, PRUint64); ++ PRUint32 result = ((Method)methodAddress)(a0, a1, a2, a3, a4, a5); ++ return result; ++} +diff -ruN mozilla.old/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_linux.cpp mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_linux.cpp +--- mozilla.old/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_linux.cpp 1969-12-31 19:00:00.000000000 -0500 ++++ mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_linux.cpp 2003-09-27 16:20:55.106321952 -0400 +@@ -0,0 +1,206 @@ ++/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ ++ ++// Implement shared vtbl methods. ++ ++#include "xptcprivate.h" ++ ++// The Linux/x86-64 ABI passes the first 6 integral parameters and the ++// first 8 floating point parameters in registers (rdi, rsi, rdx, rcx, ++// r8, r9 and xmm0-xmm7), no stack space is allocated for these by the ++// caller. The rest of the parameters are passed in the callers stack ++// area. ++ ++const PRUint32 PARAM_BUFFER_COUNT = 16; ++const PRUint32 GPR_COUNT = 6; ++const PRUint32 FPR_COUNT = 8; ++ ++// PrepareAndDispatch() is called by SharedStub() and calls the actual method. ++// ++// - 'args[]' contains the arguments passed on stack ++// - 'gpregs[]' contains the arguments passed in integer registers ++// - 'fpregs[]' contains the arguments passed in floating point registers ++// ++// The parameters are mapped into an array of type 'nsXPTCMiniVariant' ++// and then the method gets called. ++ ++extern "C" nsresult ++PrepareAndDispatch(nsXPTCStubBase * self, PRUint32 methodIndex, ++ PRUint64 * args, PRUint64 * gpregs, double *fpregs) ++{ ++ nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT]; ++ nsXPTCMiniVariant* dispatchParams = NULL; ++ nsIInterfaceInfo* iface_info = NULL; ++ const nsXPTMethodInfo* info; ++ PRUint32 paramCount; ++ PRUint32 i; ++ nsresult result = NS_ERROR_FAILURE; ++ ++ NS_ASSERTION(self,"no self"); ++ ++ self->GetInterfaceInfo(&iface_info); ++ NS_ASSERTION(iface_info,"no interface info"); ++ if (! iface_info) ++ return NS_ERROR_UNEXPECTED; ++ ++ iface_info->GetMethodInfo(PRUint16(methodIndex), &info); ++ NS_ASSERTION(info,"no method info"); ++ if (! info) ++ return NS_ERROR_UNEXPECTED; ++ ++ paramCount = info->GetParamCount(); ++ ++ // setup variant array pointer ++ if(paramCount > PARAM_BUFFER_COUNT) ++ dispatchParams = new nsXPTCMiniVariant[paramCount]; ++ else ++ dispatchParams = paramBuffer; ++ ++ NS_ASSERTION(dispatchParams,"no place for params"); ++ if (! dispatchParams) ++ return NS_ERROR_OUT_OF_MEMORY; ++ ++ PRUint64* ap = args; ++ PRUint32 nr_gpr = 1; // skip one GPR register for 'that' ++ PRUint32 nr_fpr = 0; ++ PRUint64 value; ++ ++ for(i = 0; i < paramCount; i++) { ++ const nsXPTParamInfo& param = info->GetParam(i); ++ const nsXPTType& type = param.GetType(); ++ nsXPTCMiniVariant* dp = &dispatchParams[i]; ++ ++ if (!param.IsOut() && type == nsXPTType::T_DOUBLE) { ++ if (nr_fpr < FPR_COUNT) ++ dp->val.d = fpregs[nr_fpr++]; ++ else ++ dp->val.d = *(double*) ap++; ++ continue; ++ } ++ else if (!param.IsOut() && type == nsXPTType::T_FLOAT) { ++ if (nr_fpr < FPR_COUNT) ++ // The value in %xmm register is already prepared to ++ // be retrieved as a float. Therefore, we pass the ++ // value verbatim, as a double without conversion. ++ dp->val.d = *(double*) ap++; ++ else ++ dp->val.f = *(float*) ap++; ++ continue; ++ } ++ else { ++ if (nr_gpr < GPR_COUNT) ++ value = gpregs[nr_gpr++]; ++ else ++ value = *ap++; ++ } ++ ++ if (param.IsOut() || !type.IsArithmetic()) { ++ dp->val.p = (void*) value; ++ continue; ++ } ++ ++ switch (type) { ++ case nsXPTType::T_I8: dp->val.i8 = (PRInt8) value; break; ++ case nsXPTType::T_I16: dp->val.i16 = (PRInt16) value; break; ++ case nsXPTType::T_I32: dp->val.i32 = (PRInt32) value; break; ++ case nsXPTType::T_I64: dp->val.i64 = (PRInt64) value; break; ++ case nsXPTType::T_U8: dp->val.u8 = (PRUint8) value; break; ++ case nsXPTType::T_U16: dp->val.u16 = (PRUint16) value; break; ++ case nsXPTType::T_U32: dp->val.u32 = (PRUint32) value; break; ++ case nsXPTType::T_U64: dp->val.u64 = (PRUint64) value; break; ++ case nsXPTType::T_BOOL: dp->val.b = (PRBool) value; break; ++ case nsXPTType::T_CHAR: dp->val.c = (char) value; break; ++ case nsXPTType::T_WCHAR: dp->val.wc = (wchar_t) value; break; ++ ++ default: ++ NS_ASSERTION(0, "bad type"); ++ break; ++ } ++ } ++ ++ result = self->CallMethod((PRUint16) methodIndex, info, dispatchParams); ++ ++ NS_RELEASE(iface_info); ++ ++ if (dispatchParams != paramBuffer) ++ delete [] dispatchParams; ++ ++ return result; ++} ++ ++#if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100 /* G++ V3 ABI */ ++// Linux/x86-64 uses gcc >= 3.1 ++#define STUB_ENTRY(n) \ ++asm(".section \".text\"\n\t" \ ++ ".align 2\n\t" \ ++ ".if " #n " < 10\n\t" \ ++ ".globl _ZN14nsXPTCStubBase5Stub" #n "Ev\n\t" \ ++ ".type _ZN14nsXPTCStubBase5Stub" #n "Ev,@function\n" \ ++ "_ZN14nsXPTCStubBase5Stub" #n "Ev:\n\t" \ ++ ".elseif " #n " < 100\n\t" \ ++ ".globl _ZN14nsXPTCStubBase6Stub" #n "Ev\n\t" \ ++ ".type _ZN14nsXPTCStubBase6Stub" #n "Ev,@function\n" \ ++ "_ZN14nsXPTCStubBase6Stub" #n "Ev:\n\t" \ ++ ".elseif " #n " < 1000\n\t" \ ++ ".globl _ZN14nsXPTCStubBase7Stub" #n "Ev\n\t" \ ++ ".type _ZN14nsXPTCStubBase7Stub" #n "Ev,@function\n" \ ++ "_ZN14nsXPTCStubBase7Stub" #n "Ev:\n\t" \ ++ ".else\n\t" \ ++ ".err \"stub number " #n " >= 1000 not yet supported\"\n\t" \ ++ ".endif\n\t" \ ++ "movl $" #n ", %eax\n\t" \ ++ "jmp SharedStub\n\t" \ ++ ".if " #n " < 10\n\t" \ ++ ".size _ZN14nsXPTCStubBase5Stub" #n "Ev,.-_ZN14nsXPTCStubBase5Stub" #n "Ev\n\t" \ ++ ".elseif " #n " < 100\n\t" \ ++ ".size _ZN14nsXPTCStubBase6Stub" #n "Ev,.-_ZN14nsXPTCStubBase6Stub" #n "Ev\n\t" \ ++ ".else\n\t" \ ++ ".size _ZN14nsXPTCStubBase7Stub" #n "Ev,.-_ZN14nsXPTCStubBase7Stub" #n "Ev\n\t" \ ++ ".endif"); ++ ++// static nsresult SharedStub(PRUint32 methodIndex) ++asm(".section \".text\"\n\t" ++ ".align 2\n\t" ++ ".type SharedStub,@function\n\t" ++ "SharedStub:\n\t" ++ // make room for gpregs (48), fpregs (64) ++ "pushq %rbp\n\t" ++ "movq %rsp,%rbp\n\t" ++ "subq $112,%rsp\n\t" ++ // save GP registers ++ "movq %rdi,-112(%rbp)\n\t" ++ "movq %rsi,-104(%rbp)\n\t" ++ "movq %rdx, -96(%rbp)\n\t" ++ "movq %rcx, -88(%rbp)\n\t" ++ "movq %r8 , -80(%rbp)\n\t" ++ "movq %r9 , -72(%rbp)\n\t" ++ "leaq -112(%rbp),%rcx\n\t" ++ // save FP registers ++ "movsd %xmm0,-64(%rbp)\n\t" ++ "movsd %xmm1,-56(%rbp)\n\t" ++ "movsd %xmm2,-48(%rbp)\n\t" ++ "movsd %xmm3,-40(%rbp)\n\t" ++ "movsd %xmm4,-32(%rbp)\n\t" ++ "movsd %xmm5,-24(%rbp)\n\t" ++ "movsd %xmm6,-16(%rbp)\n\t" ++ "movsd %xmm7, -8(%rbp)\n\t" ++ "leaq -64(%rbp),%r8\n\t" ++ // rdi has the 'self' pointer already ++ "movl %eax,%esi\n\t" ++ "leaq 16(%rbp),%rdx\n\t" ++ "call PrepareAndDispatch@plt\n\t" ++ "leave\n\t" ++ "ret\n\t" ++ ".size SharedStub,.-SharedStub"); ++ ++#define SENTINEL_ENTRY(n) \ ++nsresult nsXPTCStubBase::Sentinel##n() \ ++{ \ ++ NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called"); \ ++ return NS_ERROR_NOT_IMPLEMENTED; \ ++} ++ ++#include "xptcstubsdef.inc" ++ ++#else ++#error "can't find a compiler to use" ++#endif /* __GNUC__ */ +diff -ruN mozilla.old/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp mozilla/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp +--- mozilla.old/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp 2003-02-22 23:41:18.000000000 -0500 ++++ mozilla/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp 2003-09-27 16:21:05.754703152 -0400 +@@ -87,6 +87,19 @@ + float p17, float p18, float p19, float p20, + float *retval) = 0; + ++ NS_IMETHOD AddMixedInts(PRInt64 p1, PRInt32 p2, PRInt64 p3, PRInt32 p4, ++ PRInt32 p5, PRInt64 p6, PRInt32 p7, PRInt32 p8, ++ PRInt64 p9, PRInt32 p10, PRInt64* retval) = 0; ++ ++ NS_IMETHOD AddMixedInts2(PRInt32 p1, PRInt64 p2, PRInt32 p3, PRInt64 p4, ++ PRInt64 p5, PRInt32 p6, PRInt64 p7, PRInt64 p8, ++ PRInt32 p9, PRInt64 p10, PRInt64* retval) = 0; ++ ++ NS_IMETHOD AddMixedFloats(float p1, float p2, double p3, double p4, ++ float p5, float p6, double p7, double p8, ++ float p9, double p10, float p11, ++ double *retval) = 0; ++ + NS_IMETHOD PassTwoStrings(const char* s1, const char* s2, char** retval) = 0; + + }; +@@ -114,6 +127,19 @@ + float p5, float p6, float p7, float p8, + float p9, float p10, float* retval); + ++ NS_IMETHOD AddMixedInts(PRInt64 p1, PRInt32 p2, PRInt64 p3, PRInt32 p4, ++ PRInt32 p5, PRInt64 p6, PRInt32 p7, PRInt32 p8, ++ PRInt64 p9, PRInt32 p10, PRInt64* retval); ++ ++ NS_IMETHOD AddMixedInts2(PRInt32 p1, PRInt64 p2, PRInt32 p3, PRInt64 p4, ++ PRInt64 p5, PRInt32 p6, PRInt64 p7, PRInt64 p8, ++ PRInt32 p9, PRInt64 p10, PRInt64* retval); ++ ++ NS_IMETHOD AddMixedFloats(float p1, float p2, double p3, double p4, ++ float p5, float p6, double p7, double p8, ++ float p9, double p10, float p11, ++ double *retval); ++ + NS_IMETHOD AddManyManyFloats(float p1, float p2, float p3, float p4, + float p5, float p6, float p7, float p8, + float p9, float p10, float p11, float p12, +@@ -211,6 +237,20 @@ + } + + NS_IMETHODIMP ++InvokeTestTarget::AddMixedFloats(float p1, float p2, double p3, double p4, ++ float p5, float p6, double p7, double p8, ++ float p9, double p10, float p11, ++ double *retval) ++{ ++#ifdef DEBUG_TESTINVOKE ++ printf("%f, %f, %lf, %lf, %f, %f, %lf, %lf, %f, %lf, %f\n", ++ p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); ++#endif ++ *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10 + p11; ++ return NS_OK; ++} ++ ++NS_IMETHODIMP + InvokeTestTarget::AddManyManyFloats(float p1, float p2, float p3, float p4, + float p5, float p6, float p7, float p8, + float p9, float p10, float p11, float p12, +@@ -230,6 +270,24 @@ + } + + NS_IMETHODIMP ++InvokeTestTarget::AddMixedInts(PRInt64 p1, PRInt32 p2, PRInt64 p3, PRInt32 p4, ++ PRInt32 p5, PRInt64 p6, PRInt32 p7, PRInt32 p8, ++ PRInt64 p9, PRInt32 p10, PRInt64* retval) ++{ ++ *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10; ++ return NS_OK; ++} ++ ++NS_IMETHODIMP ++InvokeTestTarget::AddMixedInts2(PRInt32 p1, PRInt64 p2, PRInt32 p3, PRInt64 p4, ++ PRInt64 p5, PRInt32 p6, PRInt64 p7, PRInt64 p8, ++ PRInt32 p9, PRInt64 p10, PRInt64* retval) ++{ ++ *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10; ++ return NS_OK; ++} ++ ++NS_IMETHODIMP + InvokeTestTarget::PassTwoStrings(const char* s1, const char* s2, char** retval) + { + const char milk[] = "milk"; +@@ -309,14 +367,33 @@ + else + printf("\tFAILED"); + +- if(NS_SUCCEEDED(test->PassTwoStrings("moo","cow",&outS))) { +- printf(" = %s\n", outS); ++ if(NS_SUCCEEDED(test->AddMixedInts(1,2,3,4,5,6,7,8,9,10,&out64))) ++ { ++ LL_L2I(tmp32, out64); ++ printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", (int)tmp32); ++ } ++ else ++ printf("\tFAILED"); ++ ++ if(NS_SUCCEEDED(test->AddMixedInts2(1,2,3,4,5,6,7,8,9,10,&out64))) ++ { ++ LL_L2I(tmp32, out64); ++ printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", (int)tmp32); ++ } ++ else ++ printf("\tFAILED"); ++ ++ if(NS_SUCCEEDED(test->AddMixedFloats(1,2,3,4,5,6,7,8,9,10,11,&outD))) ++ printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 = %f\n", (double)outD); ++ else ++ printf("\tFAILED"); ++ ++ if (NS_SUCCEEDED(test->PassTwoStrings("moo","cow",&outS))) { ++ printf(" = %s\n", outS); + nsMemory::Free(outS); +- } else ++ } else + printf("\tFAILED"); + +- +- + printf("calling via invoke:\n"); + + nsXPTCVariant var[21]; +@@ -388,8 +465,8 @@ + var[2].flags = nsXPTCVariant::PTR_IS_DATA; + var[2].ptr = &var[2].val.i64; + +- if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 6, 3, var))) +- printf("\t2L * 2L = %d\n", (int)var[2].val.i64); ++ if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 6, 3, var))) ++ printf("\t2L * 2L = %d\n", (int)var[2].val.i64); + else + printf("\tFAILED"); + +@@ -559,6 +636,8 @@ + if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 10, 11, var))) + printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %ff\n", + (double) var[10].val.f); ++ else ++ printf("\tFAILED"); + + var[0].val.f = 1.0f; + var[0].type = nsXPTType::T_FLOAT; +@@ -649,6 +728,163 @@ + printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 = %ff\n", + (double) var[20].val.f); + ++ var[0].val.i64 = 1; ++ var[0].type = nsXPTType::T_I64; ++ var[0].flags = 0; ++ ++ var[1].val.i32 = 2; ++ var[1].type = nsXPTType::T_I32; ++ var[1].flags = 0; ++ ++ var[2].val.i64 = 3; ++ var[2].type = nsXPTType::T_I64; ++ var[2].flags = 0; ++ ++ var[3].val.i32 = 4; ++ var[3].type = nsXPTType::T_I32; ++ var[3].flags = 0; ++ ++ var[4].val.i32 = 5; ++ var[4].type = nsXPTType::T_I32; ++ var[4].flags = 0; ++ ++ var[5].val.i64 = 6; ++ var[5].type = nsXPTType::T_I64; ++ var[5].flags = 0; ++ ++ var[6].val.i32 = 7; ++ var[6].type = nsXPTType::T_I32; ++ var[6].flags = 0; ++ ++ var[7].val.i32 = 8; ++ var[7].type = nsXPTType::T_I32; ++ var[7].flags = 0; ++ ++ var[8].val.i64 = 9; ++ var[8].type = nsXPTType::T_I64; ++ var[8].flags = 0; ++ ++ var[9].val.i32 = 10; ++ var[9].type = nsXPTType::T_I32; ++ var[9].flags = 0; ++ ++ var[10].val.i64 = 0; ++ var[10].type = nsXPTType::T_I64; ++ var[10].flags = nsXPTCVariant::PTR_IS_DATA; ++ var[10].ptr = &var[10].val.i64; ++ ++ if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 12, 11, var))) ++ printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", ++ (int)var[10].val.i64); ++ else ++ printf("\tFAILED"); ++ ++ var[0].val.i32 = 1; ++ var[0].type = nsXPTType::T_I32; ++ var[0].flags = 0; ++ ++ var[1].val.i64 = 2; ++ var[1].type = nsXPTType::T_I64; ++ var[1].flags = 0; ++ ++ var[2].val.i32 = 3; ++ var[2].type = nsXPTType::T_I32; ++ var[2].flags = 0; ++ ++ var[3].val.i64 = 4; ++ var[3].type = nsXPTType::T_I64; ++ var[3].flags = 0; ++ ++ var[4].val.i64 = 5; ++ var[4].type = nsXPTType::T_I64; ++ var[4].flags = 0; ++ ++ var[5].val.i32 = 6; ++ var[5].type = nsXPTType::T_I32; ++ var[5].flags = 0; ++ ++ var[6].val.i64 = 7; ++ var[6].type = nsXPTType::T_I64; ++ var[6].flags = 0; ++ ++ var[7].val.i64 = 8; ++ var[7].type = nsXPTType::T_I64; ++ var[7].flags = 0; ++ ++ var[8].val.i32 = 9; ++ var[8].type = nsXPTType::T_I32; ++ var[8].flags = 0; ++ ++ var[9].val.i64 = 10; ++ var[9].type = nsXPTType::T_I64; ++ var[9].flags = 0; ++ ++ var[10].val.i64 = 0; ++ var[10].type = nsXPTType::T_I64; ++ var[10].flags = nsXPTCVariant::PTR_IS_DATA; ++ var[10].ptr = &var[10].val.i64; ++ ++ if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 13, 11, var))) ++ printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", ++ (int)var[10].val.i64); ++ else ++ printf("\tFAILED"); ++ ++ var[0].val.f = 1.0f; ++ var[0].type = nsXPTType::T_FLOAT; ++ var[0].flags = 0; ++ ++ var[1].val.f = 2.0f; ++ var[1].type = nsXPTType::T_FLOAT; ++ var[1].flags = 0; ++ ++ var[2].val.d = 3.0; ++ var[2].type = nsXPTType::T_DOUBLE; ++ var[2].flags = 0; ++ ++ var[3].val.d = 4.0; ++ var[3].type = nsXPTType::T_DOUBLE; ++ var[3].flags = 0; ++ ++ var[4].val.f = 5.0f; ++ var[4].type = nsXPTType::T_FLOAT; ++ var[4].flags = 0; ++ ++ var[5].val.f = 6.0f; ++ var[5].type = nsXPTType::T_FLOAT; ++ var[5].flags = 0; ++ ++ var[6].val.d = 7.0; ++ var[6].type = nsXPTType::T_DOUBLE; ++ var[6].flags = 0; ++ ++ var[7].val.d = 8.0; ++ var[7].type = nsXPTType::T_DOUBLE; ++ var[7].flags = 0; ++ ++ var[8].val.f = 9.0f; ++ var[8].type = nsXPTType::T_FLOAT; ++ var[8].flags = 0; ++ ++ var[9].val.d = 10.0; ++ var[9].type = nsXPTType::T_DOUBLE; ++ var[9].flags = 0; ++ ++ var[10].val.f = 11.0f; ++ var[10].type = nsXPTType::T_FLOAT; ++ var[10].flags = 0; ++ ++ var[11].val.d = 0.0; ++ var[11].type = nsXPTType::T_DOUBLE; ++ var[11].flags = nsXPTCVariant::PTR_IS_DATA; ++ var[11].ptr = &var[11].val.d; ++ ++ if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 14, 12, var))) ++ printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 = %f\n", ++ var[11].val.d); ++ else ++ printf("\tFAILED"); ++ + var[0].val.p = (void*)"moo"; + var[0].type = nsXPTType::T_CHAR_STR; + var[0].flags = 0; +@@ -662,12 +898,11 @@ + var[2].flags = nsXPTCVariant::PTR_IS_DATA; + var[2].ptr = &var[2].val.p; + +- if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 12, 3, var))) ++ if(NS_SUCCEEDED(XPTC_InvokeByIndex(test, 15, 3, var))) + printf(" = %s\n", var[2].val.p); + else + printf("\tFAILED"); + +- + DoMultipleInheritenceTest(); + DoMultipleInheritenceTest2(); + // Disabled by default - takes too much time on slow machines diff --git a/www-client/mozilla-firefox/files/mozilla-firefox-1.0-4ft2.patch b/www-client/mozilla-firefox/files/mozilla-firefox-1.0-4ft2.patch new file mode 100644 index 000000000000..11028aba71cc --- /dev/null +++ b/www-client/mozilla-firefox/files/mozilla-firefox-1.0-4ft2.patch @@ -0,0 +1,654 @@ +This patch is from +https://bugzilla.mozilla.org/show_bug.cgi?id=234035#c65 to enable +linking against freetype-2.1.8+. It disables the experimental +freetype caching. I modified this patch slightly to apply to 1.0; +some things had moved around in the files since the original patch. + +15 Nov 2004 agriffis + +--- gfx/idl/nsIFreeType2.idl.agriffis 2004-04-15 21:09:33.000000000 -0400 ++++ gfx/idl/nsIFreeType2.idl 2004-11-15 13:29:05.120343408 -0500 +@@ -98,8 +98,6 @@ + { + + readonly attribute FT_Library library; +- readonly attribute FTC_Manager FTCacheManager; +- readonly attribute FTC_Image_Cache ImageCache; + + void doneFace(in FT_Face face); + void doneFreeType(in FT_Library lib); +@@ -114,17 +112,8 @@ + in FT_Long face_num, out FT_Face face); + void outlineDecompose(in FT_Outline_p outline, + in const_FT_Outline_Funcs_p funcs, in voidPtr p); ++ void setPixelSizes(in FT_Face face, in FT_UInt width, in FT_UInt height); + void setCharmap(in FT_Face face, in FT_CharMap charmap); +- void imageCacheLookup(in FTC_Image_Cache cache, in FTC_Image_Desc_p desc, +- in FT_UInt gindex, out FT_Glyph glyph); +- void managerLookupSize(in FTC_Manager manager, in FTC_Font font, +- out FT_Face face, out FT_Size size); +- void managerDone(in FTC_Manager manager); +- void managerNew(in FT_Library lib, in FT_UInt max_faces, +- in FT_UInt max_sizes, in FT_ULong max_bytes, +- in FTC_Face_Requester requester, in FT_Pointer req_data, +- out FTC_Manager manager); +- void imageCacheNew(in FTC_Manager manager, out FTC_Image_Cache cache); + /* #ifdef MOZ_SVG */ + void glyphTransform(in FT_Glyph glyph, in FT_Matrix_p matrix, + in FT_Vector_p delta); +--- gfx/src/ps/nsFontMetricsPS.h.agriffis 2003-04-22 12:25:09.000000000 -0400 ++++ gfx/src/ps/nsFontMetricsPS.h 2004-11-15 13:37:58.431267824 -0500 +@@ -320,7 +320,8 @@ + nsCOMPtr<nsITrueTypeFontCatalogEntry> mFaceID; + nsCOMPtr<nsIFreeType2> mFt2; + PRUint16 mPixelSize; +- FTC_Image_Desc mImageDesc; ++ FT_Face mFace; ++ FT_Library mFreeTypeLibrary; + + + static PRBool AddUserPref(nsIAtom *aLang, const nsFont& aFont, +@@ -363,7 +364,8 @@ + protected: + nsCOMPtr<nsITrueTypeFontCatalogEntry> mEntry; + nsCOMPtr<nsIFreeType2> mFt2; +- FTC_Image_Desc mImageDesc; ++ FT_Face mFace; ++ FT_Library mFreeTypeLibrary; + }; + #endif + +--- gfx/src/ps/nsFontMetricsPS.cpp.agriffis 2004-02-04 20:57:05.000000000 -0500 ++++ gfx/src/ps/nsFontMetricsPS.cpp 2004-11-15 13:29:05.123342952 -0500 +@@ -1141,21 +1141,26 @@ + + mPixelSize = NSToIntRound(app2dev * mFont->size); + +- mImageDesc.font.face_id = (void*)mEntry; +- mImageDesc.font.pix_width = mPixelSize; +- mImageDesc.font.pix_height = mPixelSize; +- mImageDesc.image_type = 0; +- + nsresult rv; + mFt2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv); + if (NS_FAILED(rv)) { ++ NS_ERROR("failed to get ft2 service"); ++ return NS_ERROR_FAILURE; ++ } ++ ++ if (NS_FAILED(mFt2->GetLibrary(&mFreeTypeLibrary))) { ++ NS_ERROR("failed to get ft2 library"); + return NS_ERROR_FAILURE; + } ++ ++ mFace = nsnull; + return NS_OK; + } + + nsFontPSFreeType::~nsFontPSFreeType() + { ++ if (mFace) ++ mFt2->DoneFace(mFace); + mEntry = nsnull; + } + +@@ -1180,32 +1185,26 @@ + nscoord + nsFontPSFreeType::GetWidth(const PRUnichar* aString, PRUint32 aLength) + { +- FT_UInt glyph_index; +- FT_Glyph glyph; +- double origin_x = 0; +- + // get the face/size from the FreeType cache + FT_Face face = getFTFace(); + NS_ASSERTION(face, "failed to get face/size"); + if (!face) + return 0; + +- FTC_Image_Cache iCache; +- nsresult rv = mFt2->GetImageCache(&iCache); +- if (NS_FAILED(rv)) { +- NS_ERROR("Failed to get Image Cache"); +- return 0; +- } ++ FT_UInt glyph_index; ++ FT_Glyph glyph; ++ double origin_x = 0; + ++ // XXX : we might need some caching here + for (PRUint32 i=0; i<aLength; i++) { +- mFt2->GetCharIndex((FT_Face)face, aString[i], &glyph_index); +- nsresult rv = mFt2->ImageCacheLookup(iCache, &mImageDesc, +- glyph_index, &glyph); +- if (NS_FAILED(rv)) { ++ mFt2->GetCharIndex(face, aString[i], &glyph_index); ++ if (NS_FAILED(mFt2->LoadGlyph(face, glyph_index, FT_LOAD_DEFAULT)) || ++ NS_FAILED(mFt2->GetGlyph(face->glyph, &glyph))) { + origin_x += FT_REG_TO_16_16(face->size->metrics.x_ppem/2 + 2); + continue; + } + origin_x += glyph->advance.x; ++ mFt2->DoneGlyph(glyph); + } + + NS_ENSURE_TRUE(mFontMetrics, 0); +@@ -1224,16 +1223,26 @@ + FT_Face + nsFontPSFreeType::getFTFace() + { +- FT_Face face = nsnull; +- +- FTC_Manager cManager; +- mFt2->GetFTCacheManager(&cManager); +- nsresult rv = mFt2->ManagerLookupSize(cManager, &mImageDesc.font, +- &face, nsnull); ++ if (mFace) return mFace; ++ ++ nsCAutoString fileName; ++ PRInt16 faceIndex; ++ mEntry->GetFileName(fileName); ++ mEntry->GetFaceIndex(&faceIndex); ++ ++ nsresult rv = ++ mFt2->NewFace(mFreeTypeLibrary, fileName.get(), faceIndex, &mFace); ++ + NS_ASSERTION(rv==0, "failed to get face/size"); +- if (rv) +- return nsnull; +- return face; ++ if (NS_FAILED(rv)) { ++ return nsnull; ++ } ++ ++ if (NS_FAILED(mFt2->SetPixelSizes(mFace, mPixelSize, 0))) { ++ return nsnull; ++ } ++ ++ return mFace; + } + + nscoord +@@ -1618,26 +1627,23 @@ + + void nsFT2Type8Generator::GeneratePSFont(FILE* aFile) + { +- nsCAutoString fontName, styleName; +- mEntry->GetFamilyName(fontName); +- mEntry->GetStyleName(styleName); +- +- mImageDesc.font.face_id = (void*)mEntry; +- // TT glyph has no relation to size +- mImageDesc.font.pix_width = 16; +- mImageDesc.font.pix_height = 16; +- mImageDesc.image_type = 0; +- FT_Face face = nsnull; +- FTC_Manager cManager; +- mFt2->GetFTCacheManager(&cManager); +- nsresult rv = mFt2->ManagerLookupSize(cManager, &mImageDesc.font, +- &face, nsnull); +- if (NS_FAILED(rv)) +- return; ++ if (mFace == nsnull) { ++ nsCAutoString fileName; ++ PRInt16 faceIndex; ++ ++ mEntry->GetFileName(fileName); ++ mEntry->GetFaceIndex(&faceIndex); ++ if (NS_FAILED(mFt2-> ++ NewFace(mFreeTypeLibrary, fileName.get(), faceIndex, &mFace))) { ++ return; ++ } ++ NS_ASSERTION(mFace != nsnull, "mFace is null"); ++ } ++ + + int wmode = 0; + if (!mSubset.IsEmpty()) +- FT2SubsetToType8(face, mSubset.get(), mSubset.Length(), wmode, aFile); ++ FT2SubsetToType8(mFace, mSubset.get(), mSubset.Length(), wmode, aFile); + } + #endif //MOZ_ENABLE_FREETYPE2 + +--- gfx/src/x11shared/nsFontFreeType.cpp.agriffis 2003-12-25 03:24:52.000000000 -0500 ++++ gfx/src/x11shared/nsFontFreeType.cpp 2004-11-15 13:29:05.125342648 -0500 +@@ -173,15 +173,22 @@ + FT_Face + nsFreeTypeFont::getFTFace() + { +- FT_Face face = nsnull; +- FTC_Manager mgr; ++ if (mFace) return mFace; ++ ++ nsCAutoString fileName; ++ PRInt16 faceIndex; ++ mFaceID->GetFileName(fileName); ++ mFaceID->GetFaceIndex(&faceIndex); ++ + nsresult rv; +- mFt2->GetFTCacheManager(&mgr); +- rv = mFt2->ManagerLookupSize(mgr, &mImageDesc.font, &face, nsnull); ++ rv = mFt2->NewFace(mFreeTypeLibrary, fileName.get(), faceIndex, &mFace); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get face/size"); + if (NS_FAILED(rv)) + return nsnull; +- return face; ++ rv = mFt2->SetPixelSizes(mFace, mPixelSize, 0); ++ if (NS_FAILED(rv)) ++ return nsnull; ++ return mFace; + } + + nsFreeTypeFont::nsFreeTypeFont(nsITrueTypeFontCatalogEntry *aFaceID, +@@ -191,21 +198,20 @@ + PRBool embedded_bimap = PR_FALSE; + mFaceID = aFaceID; + mPixelSize = aPixelSize; +- mImageDesc.font.face_id = (void*)mFaceID; +- mImageDesc.font.pix_width = aPixelSize; +- mImageDesc.font.pix_height = aPixelSize; +- mImageDesc.image_type = 0; ++//mLoadFlag = FT_LOAD_RENDER; ++ mLoadFlag = 0; ++ mFace = nsnull; + + if (aPixelSize < nsFreeType2::gAntiAliasMinimum) { +- mImageDesc.image_type |= ftc_image_mono; ++ mLoadFlag |= FT_LOAD_MONOCHROME; + anti_alias = PR_FALSE; + } + + if (nsFreeType2::gFreeType2Autohinted) +- mImageDesc.image_type |= ftc_image_flag_autohinted; ++ mLoadFlag |= FT_LOAD_FORCE_AUTOHINT; + + if (nsFreeType2::gFreeType2Unhinted) +- mImageDesc.image_type |= ftc_image_flag_unhinted; ++ mLoadFlag |= FT_LOAD_NO_HINTING; + + PRUint32 num_embedded_bitmaps, i; + PRInt32* embedded_bitmapheights; +@@ -218,7 +224,7 @@ + if (embedded_bitmapheights[i] == aPixelSize) { + embedded_bimap = PR_TRUE; + // unhinted must be set for embedded bitmaps to be used +- mImageDesc.image_type |= ftc_image_flag_unhinted; ++ mLoadFlag |= FT_LOAD_NO_HINTING; + break; + } + } +@@ -230,6 +236,11 @@ + mFt2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to find FreeType routines"); + ++ if (mFt2) { ++ rv = mFt2->GetLibrary(&mFreeTypeLibrary); ++ NS_ASSERTION(NS_SUCCEEDED(rv), "failed to find FreeType library"); ++ } ++ + FREETYPE_FONT_PRINTF(("anti_alias=%d, embedded_bitmap=%d, " + "AutoHinted=%d, gFreeType2Unhinted = %d, " + "size=%dpx, \"%s\"", +@@ -288,8 +299,6 @@ + PRInt32* aDescent, + PRInt32* aWidth) + { +- nsresult rv; +- + *aLeftBearing = 0; + *aRightBearing = 0; + *aAscent = 0; +@@ -312,11 +321,6 @@ + if (!face) + return NS_ERROR_FAILURE; + +- FTC_Image_Cache icache; +- mFt2->GetImageCache(&icache); +- if (!icache) +- return NS_ERROR_FAILURE; +- + // get the text size + PRUint32 i, extraSurrogateLength; + for (i=0; i<aLength; i+=1+extraSurrogateLength) { +@@ -337,16 +341,17 @@ + } + mFt2->GetCharIndex(face, code_point, &glyph_index); + +- //NS_ASSERTION(glyph_index,"failed to get glyph"); +- if (glyph_index) { +- rv = mFt2->ImageCacheLookup(icache, &mImageDesc, glyph_index, &glyph); +- NS_ASSERTION(NS_SUCCEEDED(rv),"error loading glyph"); +- } +- if ((glyph_index) && (NS_SUCCEEDED(rv))) { ++ // XXX : we need some caching here ++ if (glyph_index && ++ NS_SUCCEEDED(mFt2->LoadGlyph(face, glyph_index, mLoadFlag)) && ++// NS_SUCCEEDED(mFt2->LoadGlyph(face, glyph_index, FT_LOAD_DEFAULT)) && ++ NS_SUCCEEDED(mFt2->GetGlyph(face->glyph, &glyph))) { + mFt2->GlyphGetCBox(glyph, ft_glyph_bbox_pixels, &glyph_bbox); + advance = FT_16_16_TO_REG(glyph->advance.x); ++ mFt2->DoneGlyph(glyph); + } + else { ++ NS_ERROR("failed to get or load glyph"); + // allocate space to draw an empty box in + GetFallbackGlyphMetrics(&glyph_bbox, face); + advance = glyph_bbox.xMax + 1; +@@ -401,11 +406,6 @@ + if (!face) + return 0; + +- FTC_Image_Cache icache; +- mFt2->GetImageCache(&icache); +- if (!icache) +- return 0; +- + PRUint32 i, extraSurrogateLength; + for (i=0; i<aLength; i+=1+extraSurrogateLength) { + extraSurrogateLength=0; +@@ -418,15 +418,18 @@ + // skip aString[i+1], it is already used as low surrogate + extraSurrogateLength = 1; + } ++ ++ // XXX : we need some caching here + mFt2->GetCharIndex((FT_Face)face, code_point, &glyph_index); +- nsresult rv; +- rv = mFt2->ImageCacheLookup(icache, &mImageDesc, glyph_index, &glyph); +- NS_ASSERTION(NS_SUCCEEDED(rv),"error loading glyph"); +- if (NS_FAILED(rv)) { ++ if (NS_FAILED(mFt2->LoadGlyph(face, glyph_index, mLoadFlag)) || ++// if (NS_FAILED(mFt2->LoadGlyph(face, glyph_index, FT_LOAD_DEFAULT)) || ++ NS_FAILED(mFt2->GetGlyph(face->glyph, &glyph))) { ++ NS_ERROR("error loading glyph"); + origin_x += face->size->metrics.x_ppem/2 + 2; + continue; + } + origin_x += FT_16_16_TO_REG(glyph->advance.x); ++ mFt2->DoneGlyph(glyph); + } + + return origin_x; +@@ -723,11 +726,6 @@ + if (y%4==0) (*blendPixelFunc)(sub_image, y, ascent-1, black, 255/2); + #endif + +- FTC_Image_Cache icache; +- mFt2->GetImageCache(&icache); +- if (!icache) +- return 0; +- + // + // Get aa glyphs and blend with background + // +@@ -736,7 +734,6 @@ + for (i=0; i<aLength; i+=1+extraSurrogateLength) { + FT_UInt glyph_index; + FT_Glyph glyph; +- nsresult rv; + FT_BBox glyph_bbox; + FT_ULong code_point = aString[i]; + extraSurrogateLength = 0; +@@ -750,11 +747,12 @@ + extraSurrogateLength = 1; + } + ++ // XXX : we need some caching here + mFt2->GetCharIndex(face, code_point, &glyph_index); +- if (glyph_index) { +- rv = mFt2->ImageCacheLookup(icache, &mImageDesc, glyph_index, &glyph); +- } +- if ((glyph_index) && (NS_SUCCEEDED(rv))) { ++ if (glyph_index && ++ NS_SUCCEEDED(mFt2->LoadGlyph(face, glyph_index, mLoadFlag)) && ++// NS_SUCCEEDED(mFt2->LoadGlyph(face, glyph_index, FT_LOAD_DEFAULT)) && ++ NS_SUCCEEDED(mFt2->GetGlyph(face->glyph, &glyph))) { + mFt2->GlyphGetCBox(glyph, ft_glyph_bbox_pixels, &glyph_bbox); + } + else { +@@ -775,13 +773,26 @@ + continue; + } + +- FT_BitmapGlyph slot = (FT_BitmapGlyph)glyph; ++ FT_BitmapGlyph slot; ++ ++ if (glyph->format != FT_GLYPH_FORMAT_BITMAP) ++ { ++ if (mFt2->GlyphToBitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 1)) { ++ NS_ERROR("failed to convert outline to bitmap "); ++ XDestroyImage(sub_image); ++ mFt2->DoneGlyph(glyph); ++ return 0; ++ } ++ } ++ ++ slot = (FT_BitmapGlyph)glyph; + nsAntiAliasedGlyph aaglyph(glyph_bbox.xMax-glyph_bbox.xMin, + glyph_bbox.yMax-glyph_bbox.yMin, 0); + PRUint8 buf[IMAGE_BUFFER_SIZE]; // try to use the stack for data + if (!aaglyph.WrapFreeType(&glyph_bbox, slot, buf, IMAGE_BUFFER_SIZE)) { + NS_ERROR("failed to wrap freetype image"); + XDestroyImage(sub_image); ++ mFt2->DoneGlyph(glyph); + return 0; + } + +@@ -815,6 +826,7 @@ + x_pos + aaglyph.GetLBearing(), ascent-glyph_bbox.yMax); + + x_pos += aaglyph.GetAdvance(); ++ mFt2->DoneGlyph(glyph); + } + + // +--- gfx/src/x11shared/nsFontFreeType.h.agriffis 2003-04-22 12:25:13.000000000 -0400 ++++ gfx/src/x11shared/nsFontFreeType.h 2004-11-15 13:29:05.125342648 -0500 +@@ -110,8 +110,10 @@ + XImage *GetXImage(PRUint32 width, PRUint32 height); + nsITrueTypeFontCatalogEntry *mFaceID; + PRUint16 mPixelSize; +- FTC_Image_Desc mImageDesc; + nsCOMPtr<nsIFreeType2> mFt2; ++ FT_Face mFace; ++ FT_Int32 mLoadFlag; ++ FT_Library mFreeTypeLibrary; + }; + + void WeightTableInitCorrection(PRUint8*, PRUint8, double); +--- gfx/src/freetype/nsFreeType.cpp.agriffis 2004-02-07 10:22:30.000000000 -0500 ++++ gfx/src/freetype/nsFreeType.cpp 2004-11-15 13:29:05.121343256 -0500 +@@ -109,12 +109,8 @@ + {"FT_Load_Glyph", NS_FT2_OFFSET(nsFT_Load_Glyph), PR_TRUE}, + {"FT_New_Face", NS_FT2_OFFSET(nsFT_New_Face), PR_TRUE}, + {"FT_Outline_Decompose", NS_FT2_OFFSET(nsFT_Outline_Decompose), PR_TRUE}, ++ {"FT_Set_Pixel_Sizes", NS_FT2_OFFSET(nsFT_Set_Pixel_Sizes), PR_TRUE}, + {"FT_Set_Charmap", NS_FT2_OFFSET(nsFT_Set_Charmap), PR_TRUE}, +- {"FTC_Image_Cache_Lookup", NS_FT2_OFFSET(nsFTC_Image_Cache_Lookup), PR_TRUE}, +- {"FTC_Manager_Lookup_Size", NS_FT2_OFFSET(nsFTC_Manager_Lookup_Size), PR_TRUE}, +- {"FTC_Manager_Done", NS_FT2_OFFSET(nsFTC_Manager_Done), PR_TRUE}, +- {"FTC_Manager_New", NS_FT2_OFFSET(nsFTC_Manager_New), PR_TRUE}, +- {"FTC_Image_Cache_New", NS_FT2_OFFSET(nsFTC_Image_Cache_New), PR_TRUE}, + // #ifdef MOZ_SVG + {"FT_Glyph_Transform", NS_FT2_OFFSET(nsFT_Glyph_Transform), PR_TRUE}, + {"FT_Get_Kerning", NS_FT2_OFFSET(nsFT_Get_Kerning), PR_TRUE}, +@@ -274,59 +270,21 @@ + } + + NS_IMETHODIMP +-nsFreeType2::SetCharmap(FT_Face face, FT_CharMap charmap) +-{ +- // call the FreeType2 function via the function pointer +- FT_Error error = nsFT_Set_Charmap(face, charmap); +- return error ? NS_ERROR_FAILURE : NS_OK; +-} +- +-NS_IMETHODIMP +-nsFreeType2::ImageCacheLookup(FTC_Image_Cache cache, FTC_Image_Desc *desc, +- FT_UInt glyphID, FT_Glyph *glyph) +-{ +- // call the FreeType2 function via the function pointer +- FT_Error error = nsFTC_Image_Cache_Lookup(cache, desc, glyphID, glyph); +- return error ? NS_ERROR_FAILURE : NS_OK; +-} +- +-NS_IMETHODIMP +-nsFreeType2::ManagerLookupSize(FTC_Manager manager, FTC_Font font, +- FT_Face *face, FT_Size *size) ++nsFreeType2::SetPixelSizes(FT_Face face, FT_UInt width, FT_UInt height) + { + // call the FreeType2 function via the function pointer +- FT_Error error = nsFTC_Manager_Lookup_Size(manager, font, face, size); ++ FT_Error error = nsFT_Set_Pixel_Sizes(face, width, height); + return error ? NS_ERROR_FAILURE : NS_OK; + } +- +-NS_IMETHODIMP +-nsFreeType2::ManagerDone(FTC_Manager manager) +-{ +- // call the FreeType2 function via the function pointer +- nsFTC_Manager_Done(manager); +- return NS_OK; +-} +- ++ + NS_IMETHODIMP +-nsFreeType2::ManagerNew(FT_Library library, FT_UInt max_faces, +- FT_UInt max_sizes, FT_ULong max_bytes, +- FTC_Face_Requester requester, FT_Pointer req_data, +- FTC_Manager *manager) ++nsFreeType2::SetCharmap(FT_Face face, FT_CharMap charmap) + { + // call the FreeType2 function via the function pointer +- FT_Error error = nsFTC_Manager_New(library, max_faces, max_sizes, max_bytes, +- requester, req_data, manager); ++ FT_Error error = nsFT_Set_Charmap(face, charmap); + return error ? NS_ERROR_FAILURE : NS_OK; + } + +-NS_IMETHODIMP +-nsFreeType2::ImageCacheNew(FTC_Manager manager, FTC_Image_Cache *cache) +-{ +- // call the FreeType2 function via the function pointer +- FT_Error error = nsFTC_Image_Cache_New(manager, cache); +- return error ? NS_ERROR_FAILURE : NS_OK; +-} +- + // #ifdef MOZ_SVG + NS_IMETHODIMP + nsFreeType2::GlyphTransform(FT_Glyph glyph, FT_Matrix * matrix, FT_Vector * delta) +@@ -389,20 +347,6 @@ + } + + NS_IMETHODIMP +-nsFreeType2::GetImageCache(FTC_Image_Cache *aCache) +-{ +- *aCache = mImageCache; +- return NS_OK; +-} +- +-NS_IMETHODIMP +-nsFreeType2::GetFTCacheManager(FTC_Manager *aManager) +-{ +- *aManager = mFTCacheManager; +- return NS_OK; +-} +- +-NS_IMETHODIMP + nsFreeType2::GetLibrary(FT_Library *aLibrary) + { + *aLibrary = mFreeTypeLibrary; +@@ -425,8 +369,6 @@ + { + mSharedLib = nsnull; + mFreeTypeLibrary = nsnull; +- mFTCacheManager = nsnull; +- mImageCache = nsnull; + } + + // I would like to make this a static member function but the compilier +@@ -456,12 +398,6 @@ + delete gFreeTypeFaces; + gFreeTypeFaces = nsnull; + } +- // mImageCache released by cache manager +- if (mFTCacheManager) { +- // use "this->" to make sure it is obivious we are calling the member func +- this->ManagerDone(mFTCacheManager); +- mFTCacheManager = nsnull; +- } + if (mFreeTypeLibrary) { + // use "this->" to make sure it is obivious we are calling the member func + this->DoneFreeType(mFreeTypeLibrary); +@@ -658,17 +594,6 @@ + mFreeTypeLibrary = nsnull; + goto cleanup_and_return; + } +- // use "this->" to make sure it is obivious we are calling the member func +- rv = this->ManagerNew(mFreeTypeLibrary, 0, 0, 0, nsFreeTypeFaceRequester, +- this, &mFTCacheManager); +- NS_ASSERTION(NS_SUCCEEDED(rv), "failed to create FreeType Cache manager"); +- if (NS_FAILED(rv)) +- goto cleanup_and_return; +- // use "this->" to make sure it is obivious we are calling the member func +- rv = this->ImageCacheNew(mFTCacheManager, &mImageCache); +- NS_ASSERTION(NS_SUCCEEDED(rv), "failed to create FreeType image cache"); +- if (NS_FAILED(rv)) +- goto cleanup_and_return; + return PR_TRUE; + + cleanup_and_return: +--- gfx/src/freetype/nsFreeType.h.agriffis 2004-04-16 17:31:42.000000000 -0400 ++++ gfx/src/freetype/nsFreeType.h 2004-11-15 13:29:05.122343104 -0500 +@@ -102,15 +102,8 @@ + typedef FT_Error (*FT_Outline_Decompose_t) + (FT_Outline*, const FT_Outline_Funcs*, void*); + typedef FT_Error (*FT_New_Face_t)(FT_Library, const char*, FT_Long, FT_Face*); ++typedef FT_Error (*FT_Set_Pixel_Sizes_t)(FT_Face face, FT_UInt, FT_UInt); + typedef FT_Error (*FT_Set_Charmap_t)(FT_Face face, FT_CharMap charmap); +-typedef FT_Error (*FTC_Image_Cache_Lookup_t) +- (FTC_Image_Cache, FTC_Image_Desc*, FT_UInt, FT_Glyph*); +-typedef FT_Error (*FTC_Manager_Lookup_Size_t) +- (FTC_Manager, FTC_Font, FT_Face*, FT_Size*); +-typedef FT_Error (*FTC_Manager_Done_t)(FTC_Manager); +-typedef FT_Error (*FTC_Manager_New_t)(FT_Library, FT_UInt, FT_UInt, FT_ULong, +- FTC_Face_Requester, FT_Pointer, FTC_Manager*); +-typedef FT_Error (*FTC_Image_Cache_New_t)(FTC_Manager, FTC_Image_Cache*); + // #ifdef MOZ_SVG + typedef FT_Error (*FT_Glyph_Transform_t)(FT_Glyph, FT_Matrix*, FT_Vector*); + typedef FT_Error (*FT_Get_Kerning_t) +@@ -163,12 +156,8 @@ + FT_Load_Glyph_t nsFT_Load_Glyph; + FT_New_Face_t nsFT_New_Face; + FT_Outline_Decompose_t nsFT_Outline_Decompose; ++ FT_Set_Pixel_Sizes_t nsFT_Set_Pixel_Sizes; + FT_Set_Charmap_t nsFT_Set_Charmap; +- FTC_Image_Cache_Lookup_t nsFTC_Image_Cache_Lookup; +- FTC_Manager_Lookup_Size_t nsFTC_Manager_Lookup_Size; +- FTC_Manager_Done_t nsFTC_Manager_Done; +- FTC_Manager_New_t nsFTC_Manager_New; +- FTC_Image_Cache_New_t nsFTC_Image_Cache_New; + // #ifdef MOZ_SVG + FT_Glyph_Transform_t nsFT_Glyph_Transform; + FT_Get_Kerning_t nsFT_Get_Kerning; +@@ -181,9 +170,9 @@ + // this array needs to be big enough to hold all the function pointers + // plus one extra for the null at the end + // #ifdef MOZ_SVG +- static FtFuncList FtFuncs[24]; ++ static FtFuncList FtFuncs[20]; + // #else +-// static FtFuncList FtFuncs[20]; ++// static FtFuncList FtFuncs[17]; + // #endif + + protected: +@@ -212,8 +201,6 @@ + + PRLibrary *mSharedLib; + FT_Library mFreeTypeLibrary; +- FTC_Manager mFTCacheManager; +- FTC_Image_Cache mImageCache; + + static nsHashtable *sFontFamilies; + static nsHashtable *sRange1CharSetNames; diff --git a/www-client/mozilla-firefox/files/mozilla-firefox-1.0-kp_separator.patch b/www-client/mozilla-firefox/files/mozilla-firefox-1.0-kp_separator.patch new file mode 100644 index 000000000000..589179158f12 --- /dev/null +++ b/www-client/mozilla-firefox/files/mozilla-firefox-1.0-kp_separator.patch @@ -0,0 +1,11 @@ +--- mozilla/widget/src/gtk2/nsGtkKeyUtils.cpp.original 2004-10-03 20:16:19.884311832 +0200 ++++ mozilla/widget/src/gtk2/nsGtkKeyUtils.cpp 2004-10-03 20:16:31.562536472 +0200 +@@ -280,7 +280,7 @@ + case GDK_KP_Add: + return '+'; + case GDK_KP_Separator: +- return '|'; ++ return ','; + case GDK_KP_Subtract: + return '-'; + case GDK_KP_Decimal: diff --git a/www-client/mozilla-firefox/files/mozilla-firefox-mousebuttons.patch b/www-client/mozilla-firefox/files/mozilla-firefox-mousebuttons.patch new file mode 100644 index 000000000000..2050b7d174d8 --- /dev/null +++ b/www-client/mozilla-firefox/files/mozilla-firefox-mousebuttons.patch @@ -0,0 +1,445 @@ +Index: browser/app/profile/all.js +=================================================================== +RCS file: /cvsroot/mozilla/browser/app/profile/all.js,v +retrieving revision 1.84 +diff -u -r1.84 all.js +--- browser/app/profile/all.js 18 Dec 2003 08:12:58 -0000 1.84 ++++ browser/app/profile/all.js 20 Dec 2003 16:11:27 -0000 +@@ -527,6 +527,29 @@ + pref("mousewheel.withaltkey.numlines",1); + pref("mousewheel.withaltkey.sysnumlines",false); + ++pref("mousewheel.horizscroll.withnokey.action",2); ++pref("mousewheel.horizscroll.withnokey.numlines",-1); ++pref("mousewheel.horizscroll.withnokey.sysnumlines",true); ++pref("mousewheel.horizscroll.withcontrolkey.action",0); ++pref("mousewheel.horizscroll.withcontrolkey.numlines",1); ++pref("mousewheel.horizscroll.withcontrolkey.sysnumlines",true); ++pref("mousewheel.horizscroll.withshiftkey.action",0); ++pref("mousewheel.horizscroll.withshiftkey.numlines",1); ++pref("mousewheel.horizscroll.withshiftkey.sysnumlines",false); ++pref("mousewheel.horizscroll.withaltkey.action",2); ++pref("mousewheel.horizscroll.withaltkey.numlines",-1); ++pref("mousewheel.horizscroll.withaltkey.sysnumlines",false); ++ ++pref("mousebuttonsextended.buttonlist", "67"); ++pref("mousebuttonsextended.buttons.6.action.up", 2); ++pref("mousebuttonsextended.buttons.6.numlines.up", -1); ++pref("mousebuttonsextended.buttons.6.action.down", 2); ++pref("mousebuttonsextended.buttons.6.numlines.down", 1); ++pref("mousebuttonsextended.buttons.7.action.up", 2); ++pref("mousebuttonsextended.buttons.7.numlines.up", 1); ++pref("mousebuttonsextended.buttons.7.action.down", -1); ++pref("mousebuttonsextended.buttons.7.numlines.down", -1); ++ + pref("profile.confirm_automigration",true); + pref("profile.allow_automigration", false); // setting to false bypasses automigration in the profile code + +Index: modules/libpref/src/init/all.js +=================================================================== +RCS file: /cvsroot/mozilla/modules/libpref/src/init/all.js,v +retrieving revision 3.484 +diff -u -r3.484 all.js +--- modules/libpref/src/init/all.js 16 Dec 2003 13:58:02 -0000 3.484 ++++ modules/libpref/src/init/all.js 20 Dec 2003 16:11:27 -0000 +@@ -755,6 +755,29 @@ + pref("mousewheel.withaltkey.numlines",1); + pref("mousewheel.withaltkey.sysnumlines",false); + ++pref("mousewheel.horizscroll.withnokey.action",2); ++pref("mousewheel.horizscroll.withnokey.numlines",-1); ++pref("mousewheel.horizscroll.withnokey.sysnumlines",true); ++pref("mousewheel.horizscroll.withcontrolkey.action",0); ++pref("mousewheel.horizscroll.withcontrolkey.numlines",1); ++pref("mousewheel.horizscroll.withcontrolkey.sysnumlines",true); ++pref("mousewheel.horizscroll.withshiftkey.action",0); ++pref("mousewheel.horizscroll.withshiftkey.numlines",1); ++pref("mousewheel.horizscroll.withshiftkey.sysnumlines",false); ++pref("mousewheel.horizscroll.withaltkey.action",2); ++pref("mousewheel.horizscroll.withaltkey.numlines",-1); ++pref("mousewheel.horizscroll.withaltkey.sysnumlines",false); ++ ++pref("mousebuttonsextended.buttonlist", "67"); ++pref("mousebuttonsextended.buttons.6.action.up", 2); ++pref("mousebuttonsextended.buttons.6.numlines.up", -1); ++pref("mousebuttonsextended.buttons.6.action.down", 2); ++pref("mousebuttonsextended.buttons.6.numlines.down", 1); ++pref("mousebuttonsextended.buttons.7.action.up", 2); ++pref("mousebuttonsextended.buttons.7.numlines.up", 1); ++pref("mousebuttonsextended.buttons.7.action.down", -1); ++pref("mousebuttonsextended.buttons.7.numlines.down", -1); ++ + pref("profile.confirm_automigration",true); + // profile.migration_behavior determines how the profiles root is set + // 0 - use NS_APP_USER_PROFILES_ROOT_DIR +Index: widget/src/gtk/nsWidget.cpp +=================================================================== +RCS file: /cvsroot/mozilla/widget/src/gtk/nsWidget.cpp,v +retrieving revision 1.288 +diff -u -r1.288 nsWidget.cpp +--- widget/src/gtk/nsWidget.cpp 25 Sep 2003 05:34:25 -0000 1.288 ++++ widget/src/gtk/nsWidget.cpp 20 Dec 2003 16:11:27 -0000 +@@ -20,6 +20,8 @@ + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): ++ * Andrew Wellington <proton@wiretapped.net> ++ * Graham Dennis <u3952328@anu.edu.au> + * + * 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 +@@ -1884,9 +1886,17 @@ + Release(); + return; + +- // Single-click default. ++ // Single-click default. <-- Perhaps the default should be ++ // decided elsewhere? + default: +- eventType = NS_MOUSE_LEFT_BUTTON_DOWN; ++ // was: eventType = NS_MOUSE_LEFT_BUTTON_DOWN; ++ { ++ nsExtendedMouseEventStatus *eMEStatus; ++ eMEStatus = (nsExtendedMouseEventStatus*) &event.clickCount; ++ eventType = NS_USER_DEFINED_EVENT; ++ eMEStatus->event = nsExtendedMouseEventStatus_down; ++ eMEStatus->button = aGdkButtonEvent->button; ++ } + break; + } + break; +@@ -1955,8 +1965,17 @@ + // LEFT_BUTTON_UP to happen + return; + ++ // Left-click default. <-- Perhaps the default should be ++ // decided elsewhere? + default: +- eventType = NS_MOUSE_LEFT_BUTTON_UP; ++ // was: eventType = NS_MOUSE_LEFT_BUTTON_UP; ++ { ++ nsExtendedMouseEventStatus *eMEStatus; ++ eMEStatus = (nsExtendedMouseEventStatus*) &event.clickCount; ++ eventType = NS_USER_DEFINED_EVENT; ++ eMEStatus->event = nsExtendedMouseEventStatus_up; ++ eMEStatus->button = aGdkButtonEvent->button; ++ } + break; + } + +@@ -2082,6 +2101,7 @@ + nsMouseEvent &anEvent, + PRUint32 aEventType) + { ++ PRUint16 clickCount; + anEvent.message = aEventType; + anEvent.widget = this; + +@@ -2100,16 +2120,23 @@ + switch(aGdkButtonEvent->type) + { + case GDK_BUTTON_PRESS: +- anEvent.clickCount = 1; ++ clickCount = 1; + break; + case GDK_2BUTTON_PRESS: +- anEvent.clickCount = 2; ++ clickCount = 2; + break; + case GDK_3BUTTON_PRESS: +- anEvent.clickCount = 3; ++ clickCount = 3; + break; + default: +- anEvent.clickCount = 1; ++ clickCount = 1; ++ } ++ if (aEventType!=NS_USER_DEFINED_EVENT) { ++ anEvent.clickCount = clickCount; ++ } else { ++ nsExtendedMouseEventStatus *eMEStatus; ++ eMEStatus = (nsExtendedMouseEventStatus*) &anEvent.clickCount; ++ eMEStatus->realClickCount = clickCount; + } + + } +Index: widget/public/nsGUIEvent.h +=================================================================== +RCS file: /cvsroot/mozilla/widget/public/nsGUIEvent.h,v +retrieving revision 3.98 +diff -u -r3.98 nsGUIEvent.h +--- widget/public/nsGUIEvent.h 1 May 2003 01:01:03 -0000 3.98 ++++ widget/public/nsGUIEvent.h 20 Dec 2003 16:11:27 -0000 +@@ -22,6 +22,8 @@ + * Contributor(s): + * Makoto Kato <m_kato@ga2.so-net.ne.jp> + * Dean Tessman <dean_tessman@hotmail.com> ++ * Andrew Wellington <proton@wiretapped.net> ++ * Graham Dennis <u3952328@anu.edu.au> + * + * 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 +@@ -416,6 +418,22 @@ + nsDragDropEventStatus_eDrop + }; + ++/** ++ * Event status for an extended mouse button event ++ * The event (called clickCount) is type PRUint32: ++ * hence this struct will be of the same size ++ */ ++typedef struct { ++ PRUint16 realClickCount; ++ PRUint8 button; ++ PRUint8 event; // eg button went up / down ++} nsExtendedMouseEventStatus; ++ ++enum { ++ /// different types of events ++ nsExtendedMouseEventStatus_up, ++ nsExtendedMouseEventStatus_down ++}; + + /** + * GUI MESSAGES +Index: content/events/src/nsEventStateManager.cpp +=================================================================== +RCS file: /cvsroot/mozilla/content/events/src/nsEventStateManager.cpp,v +retrieving revision 1.466 +diff -u -r1.466 nsEventStateManager.cpp +--- content/events/src/nsEventStateManager.cpp 19 Nov 2003 02:23:25 -0000 1.466 ++++ content/events/src/nsEventStateManager.cpp 20 Dec 2003 16:11:28 -0000 +@@ -22,6 +22,9 @@ + * Contributor(s): + * Makoto Kato <m_kato@ga2.so-net.ne.jp> + * Dean Tessman <dean_tessman@hotmail.com> ++ * Andrew Wellington <proton@wiretapped.net> ++ * Graham Dennis <u3952328@anu.edu.au> ++ * Thomas Kleffel <thomas.kleffel@maintech.de> + * + * 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 +@@ -1911,6 +1914,96 @@ + } + } + break; ++ case NS_USER_DEFINED_EVENT: // In reality an extended mouse event ++ { ++ nsExtendedMouseEventStatus *eMEStatus; ++ nsMouseEvent *mEvent = (nsMouseEvent* )aEvent; ++ eMEStatus = (nsExtendedMouseEventStatus *)&mEvent->clickCount; ++ nsresult rv; ++ nsXPIDLCString buttonList; ++ char ourbutton=0; ++ nsCAutoString keyBase, keySuffix; ++ PRInt32 action; ++ PRInt32 numLines; ++ ++ rv = getPrefBranch(); ++ if (NS_FAILED(rv)) return rv; ++ ++ // adding 2 below so the maximum number of mouse buttons we can ++ // support is 99 but to represent the buttons in buttonlist ++ // we're going to map 10->35 onto 'a'->'z' ++ // the storage actually supports 256 ++ if(eMEStatus->button > 35) break; ++ if(eMEStatus->button > 9) ++ ourbutton = 'a' + eMEStatus->button -9; ++ else ++ ourbutton = '0' + eMEStatus->button; ++ rv = mPrefBranch->GetCharPref("mousebuttonsextended.buttonlist", ++ getter_Copies(buttonList)); ++ if(NS_FAILED(rv)) break; ++ if(!PL_strchr(buttonList.get(), ourbutton)) break; ++ keyBase = NS_LITERAL_CSTRING("mouseextended.buttons."); ++ keyBase.Append(ourbutton); ++ keySuffix = (eMEStatus->event == nsExtendedMouseEventStatus_up) ++ ? NS_LITERAL_CSTRING(".up") ++ : NS_LITERAL_CSTRING(".down"); ++ rv = mPrefBranch->GetIntPref(PromiseFlatCString ++ (keyBase + NS_LITERAL_CSTRING(".action") + keySuffix).get(), ++ &action); ++ if(NS_FAILED(rv)) break; ++ rv = mPrefBranch->GetIntPref(PromiseFlatCString ++ (keyBase + NS_LITERAL_CSTRING(".numlines") + keySuffix).get(), ++ &numLines); ++ if(NS_FAILED(rv)) break; ++ ++ switch (action) { ++ ++#if 0 // Because we would have to create a msEvent ++ case MOUSE_SCROLL_N_LINES: ++ case MOUSE_SCROLL_PAGE: ++ { ++ DoWheelScroll(aPresContext, aTargetFrame, msEvent, numLines, ++ (msEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal), ++ (action == MOUSE_SCROLL_PAGE), PR_FALSE); ++ ++ } ++ break; ++#endif ++ case MOUSE_SCROLL_HISTORY: ++ { ++ nsCOMPtr<nsISupports> pcContainer; ++ mPresContext->GetContainer(getter_AddRefs(pcContainer)); ++ if (pcContainer) { ++ nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(pcContainer)); ++ if (webNav) { ++ // negative numLines to go back one step, nonneg to go forward ++ if (numLines < 0) ++ webNav->GoBack(); ++ else ++ webNav->GoForward(); ++ } ++ } ++ } ++ break; ++ ++ case MOUSE_SCROLL_TEXTSIZE: ++ { ++ // Exclude form controls and XUL content. ++ nsIContent *content = aTargetFrame->GetContent(); ++ if (content && ++ !content->IsContentOfType(nsIContent::eHTML_FORM_CONTROL) && ++ !content->IsContentOfType(nsIContent::eXUL)) ++ { ++ ChangeTextSize((numLines > 0) ? 1 : -1); ++ } ++ } ++ break; ++ ++ default: // Including -1 (do nothing) ++ break; ++ } ++ } ++ break; + case NS_MOUSE_SCROLL: + if (nsEventStatus_eConsumeNoDefault != *aStatus) { + nsresult rv; +@@ -1920,55 +2013,58 @@ + nsMouseScrollEvent *msEvent = (nsMouseScrollEvent*) aEvent; + PRInt32 action = 0; + PRInt32 numLines = 0; +- PRBool aBool; +- if (msEvent->isShift) { +- mPrefBranch->GetIntPref("mousewheel.withshiftkey.action", &action); +- mPrefBranch->GetBoolPref("mousewheel.withshiftkey.sysnumlines", +- &aBool); +- if (aBool) { +- numLines = msEvent->delta; +- if (msEvent->scrollFlags & nsMouseScrollEvent::kIsFullPage) +- action = MOUSE_SCROLL_PAGE; +- } +- else +- mPrefBranch->GetIntPref("mousewheel.withshiftkey.numlines", +- &numLines); +- } else if (msEvent->isControl) { +- mPrefBranch->GetIntPref("mousewheel.withcontrolkey.action", &action); +- mPrefBranch->GetBoolPref("mousewheel.withcontrolkey.sysnumlines", +- &aBool); +- if (aBool) { +- numLines = msEvent->delta; +- if (msEvent->scrollFlags & nsMouseScrollEvent::kIsFullPage) +- action = MOUSE_SCROLL_PAGE; +- } +- else +- mPrefBranch->GetIntPref("mousewheel.withcontrolkey.numlines", +- &numLines); +- } else if (msEvent->isAlt) { +- mPrefBranch->GetIntPref("mousewheel.withaltkey.action", &action); +- mPrefBranch->GetBoolPref("mousewheel.withaltkey.sysnumlines", &aBool); +- if (aBool) { +- numLines = msEvent->delta; +- if (msEvent->scrollFlags & nsMouseScrollEvent::kIsFullPage) +- action = MOUSE_SCROLL_PAGE; +- } +- else +- mPrefBranch->GetIntPref("mousewheel.withaltkey.numlines", +- &numLines); +- } else { +- mPrefBranch->GetIntPref("mousewheel.withnokey.action", &action); +- mPrefBranch->GetBoolPref("mousewheel.withnokey.sysnumlines", &aBool); +- if (aBool) { +- numLines = msEvent->delta; +- if (msEvent->scrollFlags & nsMouseScrollEvent::kIsFullPage) +- action = MOUSE_SCROLL_PAGE; +- } +- else +- mPrefBranch->GetIntPref("mousewheel.withnokey.numlines", &numLines); +- } ++ PRBool useSysNumLines; + +- if ((msEvent->delta < 0) && (numLines > 0)) ++ NS_NAMED_LITERAL_CSTRING(prefmousewheel, "mousewheel"); ++ NS_NAMED_LITERAL_CSTRING(prefhoriz, ".horizscroll"); ++ NS_NAMED_LITERAL_CSTRING(prefvert, ""); ++ NS_NAMED_LITERAL_CSTRING(prefnodir, ""); ++ NS_NAMED_LITERAL_CSTRING(prefnokey, ".withnokey"); ++ NS_NAMED_LITERAL_CSTRING(prefshiftkey, ".withshiftkey"); ++ NS_NAMED_LITERAL_CSTRING(prefctrlkey, ".withcontrolkey"); ++ NS_NAMED_LITERAL_CSTRING(prefaltkey, ".withaltkey"); ++ NS_NAMED_LITERAL_CSTRING(prefaction, ".action"); ++ NS_NAMED_LITERAL_CSTRING(prefsysnumlines, ".sysnumlines"); ++ NS_NAMED_LITERAL_CSTRING(prefnumlines, ".numlines"); ++ ++ nsCString prefDirection; ++ nsCString prefModifier; ++ ++ //if delta==0 we have nothing to do! ++ if(msEvent->delta == 0) break; ++ ++ prefDirection = prefnodir; ++ switch(msEvent->scrollFlags) { ++ case nsMouseScrollEvent::kIsHorizontal: ++ prefDirection = prefhoriz; break; ++ case nsMouseScrollEvent::kIsVertical: ++ prefDirection = prefvert; break; ++ } ++ ++ prefModifier = prefnokey; ++ if(msEvent->isAlt) prefModifier = prefaltkey; ++ if(msEvent->isControl) prefModifier = prefctrlkey; ++ if(msEvent->isShift) prefModifier = prefshiftkey; ++ ++ rv = mPrefBranch->GetIntPref(PromiseFlatCString(prefmousewheel + ++ prefDirection + prefModifier + prefaction).get(), ++ &action); ++ if(NS_FAILED(rv)) break; ++ ++ rv = mPrefBranch->GetIntPref(PromiseFlatCString(prefmousewheel + ++ prefDirection + prefModifier + prefnumlines).get(), ++ &numLines); ++ ++ rv = mPrefBranch->GetBoolPref(PromiseFlatCString(prefmousewheel + ++ prefDirection + prefModifier + prefsysnumlines).get(), ++ &useSysNumLines); ++ if(NS_FAILED(rv)) break; ++ ++ // if numlines == 0 take the system value ++ if(numLines == 0 || useSysNumLines) ++ numLines = msEvent->delta; ++ // invert the given value if the system delta is negative ++ else if(msEvent->delta < 0) + numLines = -numLines; + + switch (action) { +@@ -1990,7 +2086,8 @@ + if (pcContainer) { + nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(pcContainer)); + if (webNav) { +- if (msEvent->delta > 0) ++ // negative numLines to go back one step, nonneg to go forward ++ if (numLines < 0) + webNav->GoBack(); + else + webNav->GoForward(); +@@ -2007,7 +2104,8 @@ + !content->IsContentOfType(nsIContent::eHTML_FORM_CONTROL) && + !content->IsContentOfType(nsIContent::eXUL)) + { +- ChangeTextSize((msEvent->delta > 0) ? 1 : -1); ++ // As before numLines is used to give the sign of the event ++ ChangeTextSize((numLines < 0) ? -1 : 1); + } + } + break; diff --git a/www-client/mozilla-firefox/files/mozilla-hppa.patch b/www-client/mozilla-firefox/files/mozilla-hppa.patch new file mode 100644 index 000000000000..f6171cf77eb4 --- /dev/null +++ b/www-client/mozilla-firefox/files/mozilla-hppa.patch @@ -0,0 +1,232 @@ +diff -uNr mozilla.orig/xpcom/reflect/xptcall/src/md/unix/Makefile.in mozilla/xpcom/reflect/xptcall/src/md/unix/Makefile.in +--- mozilla.orig/xpcom/reflect/xptcall/src/md/unix/Makefile.in 2004-12-21 13:37:00.503842544 +0000 ++++ mozilla/xpcom/reflect/xptcall/src/md/unix/Makefile.in 2004-12-21 13:41:49.439917584 +0000 +@@ -167,6 +167,19 @@ + endif + endif + ++# ++# Linux/HPPA/gcc ++# ++ifeq ($(OS_ARCH),Linux) ++ifneq (,$(filter parisc parisc64,$(OS_TEST))) ++ifeq ($(CC),gcc) ++CPPSRCS := xptcinvoke_pa32.cpp xptcstubs_pa32.cpp ++ASFILES := xptcstubs_asm_parisc_linux.s xptcinvoke_asm_parisc_linux.s ++endif ++endif ++endif ++ ++ + ###################################################################### + # M68k + ###################################################################### +diff -uNr mozilla.orig/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_parisc_linux.s mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_parisc_linux.s +--- mozilla.orig/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_parisc_linux.s 1970-01-01 00:00:00.000000000 +0000 ++++ mozilla/xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_parisc_linux.s 2004-12-21 13:39:03.390160984 +0000 +@@ -0,0 +1,128 @@ ++ ++ .LEVEL 1.1 ++ .text ++ .align 4 ++ ++framesz: ++ .equ 128 ++ ++; XPTC_InvokeByIndex(nsISuppots* that, PRUint32 methodIndex, ++; PRUint32 paramCount, nsXPTCVariant* params); ++ ++.globl XPTC_InvokeByIndex ++ .type XPTC_InvokeByIndex, @function ++ ++ ++XPTC_InvokeByIndex: ++ .PROC ++ .CALLINFO FRAME=72, CALLER,SAVE_RP, SAVE_SP, ENTRY_GR=3 ++ .ENTRY ++ ++ ; frame marker takes 48 bytes, ++ ; register spill area takes 8 bytes, ++ ; local stack area takes 72 bytes result in 128 bytes total ++ ++ STW %rp,-20(%sp) ++ STW,MA %r3,128(%sp) ++ ++ LDO -framesz(%r30),%r28 ++ STW %r28,-4(%r30) ; save previous sp ++ STW %r19,-32(%r30) ++ ++ STW %r26,-36-framesz(%r30) ; save argument registers in ++ STW %r25,-40-framesz(%r30) ; in PREVIOUS frame ++ STW %r24,-44-framesz(%r30) ; ++ STW %r23,-48-framesz(%r30) ; ++ ++; B,L .+8,%r2 ++; ADDIL L'invoke_count_bytes-$PIC_pcrel$1+4,%r2,%r1 ++; ; LDO R'invoke_count_bytes-$PIC_pcrel$2+8(%r1),%r1 ++;$PIC_pcrel$1 ++; LDSID (%r1),%r31 ++;$PIC_pcrel$2 ++; MTSP %r31,%sr0 ++ ++ .CALL ARGW0=GR,ARGW1=GR,ARGW2=GR ;in=24,25,26;out=28 ++ BL invoke_count_bytes,%r31 ++ COPY %r31,%r2 ++ ++ CMPIB,>= 0,%r28, .+76 ++ COPY %r30,%r3 ; copy stack ptr to saved stack ptr ++ ADD %r30,%r28,%r30 ; extend stack frame ++ LDW -4(%r3),%r28 ; move frame ++ STW %r28,-4(%r30) ++ LDW -8(%r3),%r28 ++ STW %r28,-8(%r30) ++ LDW -12(%r3),%r28 ++ STW %r28,-12(%r30) ++ LDW -16(%r3),%r28 ++ STW %r28,-16(%r30) ++ LDW -20(%r3),%r28 ++ STW %r28,-20(%r30) ++ LDW -24(%r3),%r28 ++ STW %r28,-24(%r30) ++ LDW -28(%r3),%r28 ++ STW %r28,-28(%r30) ++ LDW -32(%r3),%r28 ++ STW %r28,-32(%r30) ++ ++ LDO -40(%r30),%r26 ; load copy address ++ LDW -44-framesz(%r3),%r25 ; load rest of 2 arguments ++ LDW -48-framesz(%r3),%r24 ; ++ ++ LDW -32(%r30),%r19 ; shared lib call destroys r19; reload ++; B,L .+8,%r2 ++; ADDIL L'invoke_copy_to_stack-$PIC_pcrel$3+4,%r2,%r1 ++; LDO R'invoke_copy_to_stack-$PIC_pcrel$4+8(%r1),%r1 ++;$PIC_pcrel$3 ++; LDSID (%r1),%r31 ++;$PIC_pcrel$4 ++; MTSP %r31,%sr0 ++ .CALL ARGW0=GR,ARGW1=GR,ARGW2=GR ;in=24,25,26 ++ BL invoke_copy_to_stack,%r31 ++ COPY %r31,%r2 ++ ++ LDO -48(%r30),%r20 ++ EXTRW,U,= %r28,31,1,%r22 ++ FLDD 0(%r20),%fr7 ; load double arg 1 ++ EXTRW,U,= %r28,30,1,%r22 ++ FLDW 8(%r20),%fr5L ; load float arg 1 ++ EXTRW,U,= %r28,29,1,%r22 ++ FLDW 4(%r20),%fr6L ; load float arg 2 ++ EXTRW,U,= %r28,28,1,%r22 ++ FLDW 0(%r20),%fr7L ; load float arg 3 ++ ++ LDW -36-framesz(%r3),%r26 ; load ptr to 'that' ++ LDW -40(%r30),%r25 ; load the rest of dispatch argument registers ++ LDW -44(%r30),%r24 ++ LDW -48(%r30),%r23 ++ ++ LDW -36-framesz(%r3),%r20 ; load vtable addr ++ LDW -40-framesz(%r3),%r28 ; load index ++ LDW 0(%r20),%r20 ; follow vtable ++; LDO 0(%r20),%r20 ; offset vtable by 16 bytes (g++: 8, aCC: 16) ++ SH2ADDL %r28,%r20,%r28 ; add 4*index to vtable entry ++ LDW 0(%r28),%r22 ; load vtable entry ++ ++; B,L .+8,%r2 ++; ADDIL L'$$dyncall_external-$PIC_pcrel$5+4,%r2,%r1 ++; LDO R'$$dyncall_external-$PIC_pcrel$6+8(%r1),%r1 ++;$PIC_pcrel$5 ++; LDSID (%r1),%r31 ++;$PIC_pcrel$6 ++; MTSP %r31,%sr0 ++ .CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR,RTNVAL=GR ;in=22-26;out=28; ++ BL $$dyncall,%r31 ++ COPY %r31,%r2 ++ ++ LDW -32(%r30),%r19 ++ COPY %r3,%r30 ; restore saved stack ptr ++ ++ LDW -148(%sp),%rp ++ LDWM -128(%sp),%r3 ++ BV,N (%rp) ++ NOP ++ .EXIT ++ .PROCEND ;in=23,24,25,26; ++ .SIZE XPTC_InvokeByIndex, .-XPTC_InvokeByIndex ++ +diff -uNr mozilla.orig/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_parisc_linux.s mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_parisc_linux.s +--- mozilla.orig/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_parisc_linux.s 1970-01-01 00:00:00.000000000 +0000 ++++ mozilla/xpcom/reflect/xptcall/src/md/unix/xptcstubs_asm_parisc_linux.s 2004-12-21 13:39:03.392160680 +0000 +@@ -0,0 +1,73 @@ ++ .LEVEL 1.1 ++ .TEXT ++ .ALIGN 4 ++ ++curframesz: ++ .EQU 128 ++ ++ ++; SharedStub has stack size of 128 bytes ++ ++lastframesz: ++ .EQU 64 ++ ++; the StubN C++ function has a small stack size of 64 bytes ++ ++ ++.globl SharedStub ++ .type SharedStub, @function ++ ++SharedStub: ++ .PROC ++ .CALLINFO CALLER,FRAME=80,SAVE_RP ++ ++ .ENTRY ++ STW %rp,-20(%sp) ++ LDO 128(%sp),%sp ++ ++ STW %r19,-32(%r30) ++ STW %r26,-36-curframesz(%r30) ; save arg0 in previous frame ++ ++ LDO -80(%r30),%r28 ++ FSTD,MA %fr5,8(%r28) ; save darg0 ++ FSTD,MA %fr7,8(%r28) ; save darg1 ++ FSTW,MA %fr4L,4(%r28) ; save farg0 ++ FSTW,MA %fr5L,4(%r28) ; save farg1 ++ FSTW,MA %fr6L,4(%r28) ; save farg2 ++ FSTW,MA %fr7L,4(%r28) ; save farg3 ++ ++ ; Former value of register 26 is already properly saved by StubN, ++ ; but register 25-23 are not because of the arguments mismatch ++ STW %r25,-40-curframesz-lastframesz(%r30) ; save r25 ++ STW %r24,-44-curframesz-lastframesz(%r30) ; save r24 ++ STW %r23,-48-curframesz-lastframesz(%r30) ; save r23 ++ COPY %r26,%r25 ; method index is arg1 ++ LDW -36-curframesz-lastframesz(%r30),%r26 ; self is arg0 ++ LDO -40-curframesz-lastframesz(%r30),%r24 ; normal args is arg2 ++ LDO -80(%r30),%r23 ; floating args is arg3 ++ ++; BL .+8,%r2 ++; ADDIL L'PrepareAndDispatch-$PIC_pcrel$0+4,%r2 ++; LDO R'PrepareAndDispatch-$PIC_pcrel$1+8(%r1),%r1 ++;$PIC_pcrel$0 ++; LDSID (%r1),%r31 ++;$PIC_pcrel$1 ++; MTSP %r31,%sr0 ++ .CALL ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR,RTNVAL=GR ;in=23-26;out=28; ++ BL PrepareAndDispatch, %r31 ++ COPY %r31,%r2 ++ ++ LDW -32(%r30),%r19 ++ ++ LDW -148(%sp),%rp ++ LDO -128(%sp),%sp ++ ++ ++ BV,N (%rp) ++ NOP ++ NOP ++ ++ .EXIT ++ .PROCEND ;in=26;out=28; ++ ++ .SIZE SharedStub, .-SharedStub diff --git a/www-client/mozilla-firefox/files/svg-cairo-0.3.0-fix.patch b/www-client/mozilla-firefox/files/svg-cairo-0.3.0-fix.patch new file mode 100644 index 000000000000..9d1f0d830559 --- /dev/null +++ b/www-client/mozilla-firefox/files/svg-cairo-0.3.0-fix.patch @@ -0,0 +1,22 @@ +diff -aur mozilla-orig/layout/svg/renderer/src/cairo/nsSVGCairoCanvas.cpp mozilla/layout/svg/renderer/src/cairo/nsSVGCairoCanvas.cpp +--- mozilla-orig/layout/svg/renderer/src/cairo/nsSVGCairoCanvas.cpp 2004-02-10 15:18:09.000000000 -0500 ++++ mozilla/layout/svg/renderer/src/cairo/nsSVGCairoCanvas.cpp 2005-02-23 20:25:32.240459288 -0500 +@@ -50,6 +50,7 @@ + #include "nsRenderingContextGTK.h" + #include <gdk/gdkx.h> + #include <cairo.h> ++#include <cairo-xlib.h> + + /** + * \addtogroup cairo_renderer Cairo Rendering Engine +diff -aur mozilla-orig/layout/svg/renderer/src/cairo/nsSVGCairoGlyphMetrics.cpp mozilla/layout/svg/renderer/src/cairo/nsSVGCairoGlyphMetrics.cpp +--- mozilla-orig/layout/svg/renderer/src/cairo/nsSVGCairoGlyphMetrics.cpp 2004-03-16 16:40:07.000000000 -0500 ++++ mozilla/layout/svg/renderer/src/cairo/nsSVGCairoGlyphMetrics.cpp 2005-02-23 20:25:09.538910448 -0500 +@@ -51,6 +51,7 @@ + #include "nsSVGTypeCIDs.h" + #include "nsIComponentManager.h" + #include <cairo.h> ++#include <stdlib.h> + + /** + * \addtogroup gdiplus_renderer Cairo Rendering Engine |
