stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Phil Race 2014-06-18 13:12:58 -07:00
commit d71f56547b
640 changed files with 15031 additions and 7111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.hgtags
View File

@ -259,3 +259,5 @@ efe7dbc6088691757404e0c8745f894e3ca9c022 jdk9-b09
97932f6ad950ae5a73a9da5c96e6e58503ff646b jdk9-b14
74eb0778e4f2dbff6628e718378449fba27c4265 jdk9-b15
4a09f5d30be844ac6f714bdb0f63d8c3c08b9a98 jdk9-b16
410bccbded9e9cce80f1e13ad221e37ae97a3986 jdk9-b17
c5495e25c7258ab5f96a1ae14610887d76d2be63 jdk9-b18

2
.hgtags-top-repo
View File

@ -259,3 +259,5 @@ ab55a18a95e1990a588929d5d29db3eb9985fea0 jdk9-b11
4e3aa9723e9972623e3dafc321b368e7db7e9b3b jdk9-b14
b114474fb25af4e73cb7219f7c04bd8994da03a5 jdk9-b15
cf22a728521f91a4692b433d39d730a0a1b23155 jdk9-b16
24152ee0ee1abef54a8bab04c099261dba7bcca5 jdk9-b17
65abab59f783fcf02ff8e133431c252f9e5f07d5 jdk9-b18

71
common/autoconf/basics.m4
View File

@ -512,7 +512,7 @@ AC_DEFUN_ONCE([BASIC_SETUP_DEVKIT],
)
AC_ARG_WITH(sysroot, [AS_HELP_STRING([--with-sysroot],
[use this directory as sysroot)])],
[use this directory as sysroot])],
[SYSROOT=$with_sysroot]
)
@ -531,6 +531,75 @@ AC_DEFUN_ONCE([BASIC_SETUP_DEVKIT],
[BASIC_PREPEND_TO_PATH([EXTRA_PATH],$with_extra_path)]
)
if test "x$OPENJDK_BUILD_OS" = "xmacosx"; then
# detect if Xcode is installed by running xcodebuild -version
# if no Xcode installed, xcodebuild exits with 1
# if Xcode is installed, even if xcode-select is misconfigured, then it exits with 0
if /usr/bin/xcodebuild -version >/dev/null 2>&1; then
# We need to use xcodebuild in the toolchain dir provided by the user, this will
# fall back on the stub binary in /usr/bin/xcodebuild
AC_PATH_PROG([XCODEBUILD], [xcodebuild], [/usr/bin/xcodebuild], [$TOOLCHAIN_PATH])
else
# this should result in SYSROOT being empty, unless --with-sysroot is provided
# when only the command line tools are installed there are no SDKs, so headers
# are copied into the system frameworks
XCODEBUILD=
AC_SUBST(XCODEBUILD)
fi
AC_MSG_CHECKING([for sdk name])
AC_ARG_WITH([sdk-name], [AS_HELP_STRING([--with-sdk-name],
[use the platform SDK of the given name. @<:@macosx@:>@])],
[SDKNAME=$with_sdk_name]
)
AC_MSG_RESULT([$SDKNAME])
# if toolchain path is specified then don't rely on system headers, they may not compile
HAVE_SYSTEM_FRAMEWORK_HEADERS=0
test -z "$TOOLCHAIN_PATH" && \
HAVE_SYSTEM_FRAMEWORK_HEADERS=`test ! -f /System/Library/Frameworks/Foundation.framework/Headers/Foundation.h; echo $?`
if test -z "$SYSROOT"; then
if test -n "$XCODEBUILD"; then
# if we don't have system headers, use default SDK name (last resort)
if test -z "$SDKNAME" -a $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
SDKNAME=${SDKNAME:-macosx}
fi
if test -n "$SDKNAME"; then
# Call xcodebuild to determine SYSROOT
SYSROOT=`"$XCODEBUILD" -sdk $SDKNAME -version | grep '^Path: ' | sed 's/Path: //'`
fi
else
if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0; then
AC_MSG_ERROR([No xcodebuild tool and no system framework headers found, use --with-sysroot or --with-sdk-name to provide a path to a valid SDK])
fi
fi
else
# warn user if --with-sdk-name was also set
if test -n "$with_sdk_name"; then
AC_MSG_WARN([Both SYSROOT and --with-sdk-name are set, only SYSROOT will be used])
fi
fi
if test $HAVE_SYSTEM_FRAMEWORK_HEADERS -eq 0 -a -z "$SYSROOT"; then
# If no system framework headers, then SYSROOT must be set, or we won't build
AC_MSG_ERROR([Unable to determine SYSROOT and no headers found in /System/Library/Frameworks. Check Xcode configuration, --with-sysroot or --with-sdk-name arguments.])
fi
# Perform a basic sanity test
if test ! -f "$SYSROOT/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h"; then
if test -z "$SYSROOT"; then
AC_MSG_ERROR([Unable to find required framework headers, provide a path to an SDK via --with-sysroot or --with-sdk-name and be sure Xcode is installed properly])
else
AC_MSG_ERROR([Invalid SDK or SYSROOT path, dependent framework headers not found])
fi
fi
# set SDKROOT too, Xcode tools will pick it up
AC_SUBST(SDKROOT,$SYSROOT)
fi
# Prepend the extra path to the global path
BASIC_PREPEND_TO_PATH([PATH],$EXTRA_PATH)

348
common/autoconf/flags.m4
View File

@ -116,21 +116,25 @@ AC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS],
AC_SUBST(RC_FLAGS)
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
# FIXME: likely bug, should be CCXXFLAGS_JDK? or one for C or CXX.
CCXXFLAGS="$CCXXFLAGS -nologo"
# silence copyright notice and other headers.
COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
fi
if test "x$SYSROOT" != "x"; then
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
# Solaris Studio does not have a concept of sysroot. Instead we must
# make sure the default include and lib dirs are appended to each
# make sure the default include and lib dirs are appended to each
# compile and link command line.
SYSROOT_CFLAGS="-I$SYSROOT/usr/include"
SYSROOT_LDFLAGS="-L$SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \
-L$SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR \
-L$SYSROOT/usr/ccs/lib$OPENJDK_TARGET_CPU_ISADIR"
fi
elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
# Apple only wants -isysroot <path>, but we also need -iframework<path>/System/Library/Frameworks
SYSROOT_CFLAGS="-isysroot \"$SYSROOT\" -iframework\"$SYSROOT/System/Library/Frameworks\""
SYSROOT_LDFLAGS=$SYSROOT_CFLAGS
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
SYSROOT_CFLAGS="--sysroot=\"$SYSROOT\""
SYSROOT_LDFLAGS="--sysroot=\"$SYSROOT\""
@ -143,6 +147,14 @@ AC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS],
LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $SYSROOT_CFLAGS"
LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $SYSROOT_LDFLAGS"
fi
# These always need to be set, or we can't find the frameworks embedded in JavaVM.framework
# set this here so it doesn't have to be peppered throughout the forest
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
SYSROOT_CFLAGS="$SYSROOT_CFLAGS -F\"$SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks\""
SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -F\"$SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks\""
fi
AC_SUBST(SYSROOT_CFLAGS)
AC_SUBST(SYSROOT_LDFLAGS)
])
@ -302,6 +314,7 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
# Debug symbols
if test "x$TOOLCHAIN_TYPE" = xgcc; then
if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then
# reduce from default "-g2" option to save space
CFLAGS_DEBUG_SYMBOLS="-g1"
CXXFLAGS_DEBUG_SYMBOLS="-g1"
else
@ -313,6 +326,7 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
CXXFLAGS_DEBUG_SYMBOLS="-g"
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CFLAGS_DEBUG_SYMBOLS="-g -xs"
# FIXME: likely a bug, this disables debug symbols rather than enables them
CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
CFLAGS_DEBUG_SYMBOLS="-g"
@ -321,6 +335,31 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
AC_SUBST(CFLAGS_DEBUG_SYMBOLS)
AC_SUBST(CXXFLAGS_DEBUG_SYMBOLS)
# bounds, memory and behavior checking options
if test "x$TOOLCHAIN_TYPE" = xgcc; then
case $DEBUG_LEVEL in
release )
# no adjustment
;;
fastdebug )
# Add compile time bounds checks.
CFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1"
CXXFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1"
;;
slowdebug )
# Add runtime bounds checks and symbol info.
CFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1"
CXXFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1"
if test "x$HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR" = "xtrue"; then
CFLAGS_DEBUG_OPTIONS="$CFLAGS_DEBUG_OPTIONS $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG"
CXXFLAGS_DEBUG_OPTIONS="$CXXFLAGS_DEBUG_OPTIONS $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG"
fi
;;
esac
fi
AC_SUBST(CFLAGS_DEBUG_OPTIONS)
AC_SUBST(CXXFLAGS_DEBUG_OPTIONS)
# Optimization levels
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil"
@ -330,10 +369,12 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr"
C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr"
C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr"
C_O_FLAG_DEBUG="-xregs=no%frameptr"
C_O_FLAG_NONE="-xregs=no%frameptr"
CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr"
CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr"
CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr"
CXX_O_FLAG_DEBUG="-xregs=no%frameptr"
CXX_O_FLAG_NONE="-xregs=no%frameptr"
if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
@ -343,10 +384,12 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra"
C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
C_O_FLAG_DEBUG=""
C_O_FLAG_NONE=""
CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
C_O_FLAG_DEBUG=""
CXX_O_FLAG_NONE=""
fi
else
@ -359,13 +402,17 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
C_O_FLAG_HIGHEST="-Os"
C_O_FLAG_HI="-Os"
C_O_FLAG_NORM="-Os"
C_O_FLAG_NONE=""
else
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE="-O0"
fi
if test "x$HAS_CFLAG_OPTIMIZE_DEBUG" = "xtrue"; then
C_O_FLAG_DEBUG="$CFLAG_OPTIMIZE_DEBUG_FLAG"
else
C_O_FLAG_DEBUG="-O0"
fi
C_O_FLAG_NONE="-O0"
elif test "x$TOOLCHAIN_TYPE" = xclang; then
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
# On MacOSX we optimize for size, something
@ -373,37 +420,63 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
C_O_FLAG_HIGHEST="-Os"
C_O_FLAG_HI="-Os"
C_O_FLAG_NORM="-Os"
C_O_FLAG_NONE=""
else
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE="-O0"
fi
C_O_FLAG_DEBUG="-O0"
C_O_FLAG_NONE="-O0"
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3 -qstrict"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE=""
C_O_FLAG_DEBUG="-qnoopt"
C_O_FLAG_NONE="-qnoop"
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
C_O_FLAG_HIGHEST="-O2"
C_O_FLAG_HI="-O1"
C_O_FLAG_NORM="-O1"
C_O_FLAG_DEBUG="-Od"
C_O_FLAG_NONE="-Od"
fi
CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
CXX_O_FLAG_HI="$C_O_FLAG_HI"
CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG"
CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
fi
# Adjust optimization flags according to debug level.
case $DEBUG_LEVEL in
release )
# no adjustment
;;
fastdebug )
# Not quite so much optimization
C_O_FLAG_HI="$C_O_FLAG_NORM"
CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
;;
slowdebug )
# Disable optimization
C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG"
C_O_FLAG_HI="$C_O_FLAG_DEBUG"
C_O_FLAG_NORM="$C_O_FLAG_DEBUG"
CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG"
CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG"
CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG"
;;
esac
AC_SUBST(C_O_FLAG_HIGHEST)
AC_SUBST(C_O_FLAG_HI)
AC_SUBST(C_O_FLAG_NORM)
AC_SUBST(C_O_FLAG_DEBUG)
AC_SUBST(C_O_FLAG_NONE)
AC_SUBST(CXX_O_FLAG_HIGHEST)
AC_SUBST(CXX_O_FLAG_HI)
AC_SUBST(CXX_O_FLAG_NORM)
AC_SUBST(CXX_O_FLAG_DEBUG)
AC_SUBST(CXX_O_FLAG_NONE)
])
@ -461,11 +534,12 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
#
# Setup compiler/platform specific flags to CFLAGS_JDK,
# CXXFLAGS_JDK and CCXXFLAGS_JDK (common to C and CXX?)
# Setup compiler/platform specific flags into
# CFLAGS_JDK - C Compiler flags
# CXXFLAGS_JDK - C++ Compiler flags
# COMMON_CCXXFLAGS_JDK - common to C and C++
if test "x$TOOLCHAIN_TYPE" = xgcc; then
# these options are used for both C and C++ compiles
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Wall -Wno-parentheses -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wno-parentheses -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
-pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
case $OPENJDK_TARGET_CPU_ARCH in
arm )
@ -477,31 +551,31 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
;;
* )
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
;;
esac
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
fi
CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
-D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
-DWIN32 -DIAL"
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
fi
fi
@ -509,28 +583,20 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# Adjust flags according to debug level.
case $DEBUG_LEVEL in
fastdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
C_O_FLAG_HI="$C_O_FLAG_NORM"
C_O_FLAG_NORM="$C_O_FLAG_NORM"
CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
CXX_O_FLAG_NORM="$CXX_O_FLAG_NORM"
fastdebug | slowdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
JAVAC_FLAGS="$JAVAC_FLAGS -g"
;;
slowdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
C_O_FLAG_HI="$C_O_FLAG_NONE"
C_O_FLAG_NORM="$C_O_FLAG_NONE"
CXX_O_FLAG_HI="$CXX_O_FLAG_NONE"
CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE"
JAVAC_FLAGS="$JAVAC_FLAGS -g"
release )
;;
* )
AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL])
;;
esac
# Setup LP64
CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64"
# Set some common defines. These works for all compilers, but assume
# -D is universally accepted.
@ -543,74 +609,69 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# Note: -Dmacro is the same as #define macro 1
# -Dmacro= is the same as #define macro
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
fi
else
# Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
# are defined in the system?
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN="
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
fi
fi
# Setup target OS define. Use OS target name but in upper case.
OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"
# Setup target CPU
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
# Setup debug/release defines
if test "x$DEBUG_LEVEL" = xrelease; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG"
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DTRIMMED"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED"
fi
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG"
fi
# Setup release name
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
# Set some additional per-OS defines.
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
elif test "x$OPENJDK_TARGET_OS" = xaix; then
# FIXME: PPC64 should not be here.
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DPPC64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DPPC64"
elif test "x$OPENJDK_TARGET_OS" = xbsd; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
fi
# Additional macosx handling
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
if test "x$TOOLCHAIN_TYPE" = xgcc; then
# FIXME: This needs to be exported in spec.gmk due to closed legacy code.
# FIXME: clean this up, and/or move it elsewhere.
# Setting these parameters makes it an error to link to macosx APIs that are
# newer than the given OS version and makes the linked binaries compatible
# even if built on a newer version of the OS.
# The expected format is X.Y.Z
MACOSX_VERSION_MIN=10.7.0
AC_SUBST(MACOSX_VERSION_MIN)
# Setting these parameters makes it an error to link to macosx APIs that are
# newer than the given OS version and makes the linked binaries compatible
# even if built on a newer version of the OS.
# The expected format is X.Y.Z
MACOSX_VERSION_MIN=10.7.0
AC_SUBST(MACOSX_VERSION_MIN)
# The macro takes the version with no dots, ex: 1070
# Let the flags variables get resolved in make for easier override on make
# command line.
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
fi
# The macro takes the version with no dots, ex: 1070
# Let the flags variables get resolved in make for easier override on make
# command line.
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
fi
# Setup some hard coded includes
CCXXFLAGS_JDK="$CCXXFLAGS_JDK \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
-I${JDK_OUTPUTDIR}/include \
-I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \
-I${JDK_TOPDIR}/src/share/javavm/export \
@ -619,12 +680,12 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
-I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common"
# The shared libraries are compiled using the picflag.
CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
# Executable flags
CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK"
CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK"
CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
AC_SUBST(CFLAGS_JDKLIB)
AC_SUBST(CFLAGS_JDKEXE)
@ -633,6 +694,7 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# Setup LDFLAGS et al.
#
# Now this is odd. The JDK native libraries have to link against libjvm.so
# On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
# Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
@ -648,39 +710,93 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
fi
# TODO: make -debug optional "--disable-full-debug-symbols"
LDFLAGS_JDK="$LDFLAGS_JDK -debug"
LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib"
LDFLAGS_JDKLIB_SUFFIX=""
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
# If this is a --hash-style=gnu system, use --hash-style=both, why?
# We have previously set HAS_GNU_HASH if this is the case
if test -n "$HAS_GNU_HASH"; then
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both"
fi
if test "x$OPENJDK_TARGET_OS" = xlinux; then
# And since we now know that the linker is gnu, then add -z defs, to forbid
# undefined symbols in object files.
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs"
case $DEBUG_LEVEL in
release )
# tell linker to optimize libraries.
# Should this be supplied to the OSS linker as well?
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1"
;;
slowdebug )
if test "x$HAS_LINKER_NOW" = "xtrue"; then
# do relocations at load
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_NOW_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_NOW_FLAG"
fi
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
# mark relocations read only
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
fi
;;
fastdebug )
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
# mark relocations read only
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
fi
;;
* )
AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL])
;;
esac
fi
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
fi
if test "x$TOOLCHAIN_TYPE" = xgcc || test "x$TOOLCHAIN_TYPE" = xclang; then
# If undefined behaviour detection is enabled then we need to tell linker.
case $DEBUG_LEVEL in
release | fastdebug )
;;
slowdebug )
AC_MSG_WARN([$HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR])
if test "x$HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR" = "xtrue"; then
# enable undefined behaviour checking
LDFLAGS_JDK="$LDFLAGS_JDK `$ECHO -n $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG | sed -e "s/[ ]*\([^ ]\+\)/ -Xlinker \1/g"`"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK `$ECHO -n $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG | sed -e "s/[ ]*\([^ ]\+\)/ -Xlinker \1/g"`"
fi
;;
* )
AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL])
;;
esac
fi
# Customize LDFLAGS for executables
LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
LDFLAGS_STACK_SIZE=1048576
else
LDFLAGS_STACK_SIZE=327680
fi
LDFLAGS_JDKEXE="${LDFLAGS_JDK} /STACK:$LDFLAGS_STACK_SIZE"
LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
elif test "x$OPENJDK_TARGET_OS" = xlinux; then
LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
fi
# Customize LDFLAGS for libs
LDFLAGS_JDKLIB="${LDFLAGS_JDK}"
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -dll -libpath:${JDK_OUTPUTDIR}/lib"
LDFLAGS_JDKLIB_SUFFIX=""
else
if test "x$TOOLCHAIN_TYPE" = xgcc; then
# If this is a --hash-style=gnu system, use --hash-style=both, why?
# We have previously set HAS_GNU_HASH if this is the case
if test -n "$HAS_GNU_HASH"; then
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both "
fi
if test "x$OPENJDK_TARGET_OS" = xlinux; then
# And since we now know that the linker is gnu, then add -z defs, to forbid
# undefined symbols in object files.
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs"
if test "x$DEBUG_LEVEL" = "xrelease"; then
# When building release libraries, tell the linker optimize them.
# Should this be supplied to the OSS linker as well?
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1"
fi
fi
fi
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
fi
LDFLAGS_JDKLIB="${LDFLAGS_JDK} $SHARED_LIBRARY_FLAGS \
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS} \
-L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}"
# On some platforms (mac) the linker warns about non existing -L dirs.
@ -701,12 +817,8 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc"
fi
LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
if test "x$OPENJDK_TARGET_OS" = xlinux; then
LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
fi
fi
AC_SUBST(LDFLAGS_JDKLIB)
AC_SUBST(LDFLAGS_JDKEXE)
AC_SUBST(LDFLAGS_JDKLIB_SUFFIX)
@ -714,7 +826,6 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
AC_SUBST(LDFLAGS_CXX_JDK)
])
# FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
# [RUN-IF-FALSE])
# ------------------------------------------------------------
@ -727,7 +838,7 @@ AC_DEFUN([FLAGS_COMPILER_CHECK_ARGUMENTS],
saved_cflags="$CFLAGS"
CFLAGS="$CFLAGS $1"
AC_LANG_PUSH([C])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
[supports=no])
AC_LANG_POP([C])
CFLAGS="$saved_cflags"
@ -735,7 +846,7 @@ AC_DEFUN([FLAGS_COMPILER_CHECK_ARGUMENTS],
saved_cxxflags="$CXXFLAGS"
CXXFLAGS="$CXXFLAG $1"
AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
[supports=no])
AC_LANG_POP([C++])
CXXFLAGS="$saved_cxxflags"
@ -748,6 +859,31 @@ AC_DEFUN([FLAGS_COMPILER_CHECK_ARGUMENTS],
fi
])
# FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
# [RUN-IF-FALSE])
# ------------------------------------------------------------
# Check that the linker support an argument
AC_DEFUN([FLAGS_LINKER_CHECK_ARGUMENTS],
[
AC_MSG_CHECKING([if linker supports "$1"])
supports=yes
saved_ldflags="$LDFLAGS"
LDFLAGS="$LDFLAGS $1"
AC_LANG_PUSH([C])
AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],
[], [supports=no])
AC_LANG_POP([C])
LDFLAGS="$saved_ldflags"
AC_MSG_RESULT([$supports])
if test "x$supports" = "xyes" ; then
m4_ifval([$2], [$2], [:])
else
m4_ifval([$3], [$3], [:])
fi
])
AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_MISC],
[
# Some Zero and Shark settings.

798
common/autoconf/generated-configure.sh
View File

File diff suppressed because it is too large Load Diff

16
common/autoconf/libraries.m4
View File

@ -65,8 +65,6 @@ AC_DEFUN_ONCE([LIB_SETUP_INIT],
ALSA_NOT_NEEDED=yes
PULSE_NOT_NEEDED=yes
X11_NOT_NEEDED=yes
# If the java runtime framework is disabled, then we need X11.
# This will be adjusted below.
AC_MSG_RESULT([alsa pulse x11])
fi
@ -83,20 +81,6 @@ AC_DEFUN_ONCE([LIB_SETUP_INIT],
if test "x$SUPPORT_HEADFUL" = xno; then
X11_NOT_NEEDED=yes
fi
###############################################################################
#
# Check for MacOSX support for OpenJDK.
#
BASIC_DEPRECATED_ARG_ENABLE(macosx-runtime-support, macosx_runtime_support)
AC_MSG_CHECKING([for Mac OS X Java Framework])
if test -f /System/Library/Frameworks/JavaVM.framework/Frameworks/JavaRuntimeSupport.framework/Headers/JavaRuntimeSupport.h; then
AC_MSG_RESULT([/System/Library/Frameworks/JavaVM.framework])
else
AC_MSG_RESULT([no])
fi
])
AC_DEFUN_ONCE([LIB_SETUP_X11],

5
common/autoconf/spec.gmk.in
View File

@ -347,6 +347,9 @@ CPP:=@FIXPATH@ @CPP@
# The linker can be gcc or ld on posix systems, or link.exe on windows systems.
LD:=@FIXPATH@ @LD@
# Xcode SDK path
SDKROOT:=@SDKROOT@
# The linker on older SuSE distros (e.g. on SLES 10) complains with:
# "Invalid version tag `SUNWprivate_1.1'. Only anonymous version tag is allowed in executable."
# if feeded with a version script which contains named tags.
@ -544,7 +547,7 @@ SETFILE:=@SETFILE@
XATTR:=@XATTR@
JT_HOME:=@JT_HOME@
JTREGEXE:=@JTREGEXE@
XCODEBUILD=@XCODEBUILD@
FIXPATH:=@FIXPATH@
# Where the build output is stored for your convenience.

113
common/autoconf/toolchain.m4
View File

@ -24,11 +24,11 @@
#
########################################################################
# This file is responsible for detecting, verifying and setting up the
# toolchain, i.e. the compiler, linker and related utilities. It will setup
# This file is responsible for detecting, verifying and setting up the
# toolchain, i.e. the compiler, linker and related utilities. It will setup
# proper paths to the binaries, but it will not setup any flags.
#
# The binaries used is determined by the toolchain type, which is the family of
# The binaries used is determined by the toolchain type, which is the family of
# compilers and related tools that are used.
########################################################################
@ -83,7 +83,7 @@ AC_DEFUN([TOOLCHAIN_SETUP_FILENAME_PATTERNS],
AC_SUBST(SHARED_LIBRARY)
AC_SUBST(STATIC_LIBRARY)
AC_SUBST(OBJ_SUFFIX)
AC_SUBST(EXE_SUFFIX)
AC_SUBST(EXE_SUFFIX)
])
# Determine which toolchain type to use, and make sure it is valid for this
@ -98,26 +98,33 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETERMINE_TOOLCHAIN_TYPE],
VALID_TOOLCHAINS=${!toolchain_var_name}
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
# On Mac OS X, default toolchain to clang after Xcode 5
XCODE_VERSION_OUTPUT=`xcodebuild -version 2>&1 | $HEAD -n 1`
$ECHO "$XCODE_VERSION_OUTPUT" | $GREP "Xcode " > /dev/null
if test $? -ne 0; then
AC_MSG_ERROR([Failed to determine Xcode version.])
fi
XCODE_MAJOR_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | \
$SED -e 's/^Xcode \(@<:@1-9@:>@@<:@0-9.@:>@*\)/\1/' | \
$CUT -f 1 -d .`
AC_MSG_NOTICE([Xcode major version: $XCODE_MAJOR_VERSION])
if test $XCODE_MAJOR_VERSION -ge 5; then
DEFAULT_TOOLCHAIN="clang"
if test -n "$XCODEBUILD"; then
# On Mac OS X, default toolchain to clang after Xcode 5
XCODE_VERSION_OUTPUT=`"$XCODEBUILD" -version 2>&1 | $HEAD -n 1`
$ECHO "$XCODE_VERSION_OUTPUT" | $GREP "Xcode " > /dev/null
if test $? -ne 0; then
AC_MSG_ERROR([Failed to determine Xcode version.])
fi
XCODE_MAJOR_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | \
$SED -e 's/^Xcode \(@<:@1-9@:>@@<:@0-9.@:>@*\)/\1/' | \
$CUT -f 1 -d .`
AC_MSG_NOTICE([Xcode major version: $XCODE_MAJOR_VERSION])
if test $XCODE_MAJOR_VERSION -ge 5; then
DEFAULT_TOOLCHAIN="clang"
else
DEFAULT_TOOLCHAIN="gcc"
fi
else
DEFAULT_TOOLCHAIN="gcc"
# If Xcode is not installed, but the command line tools are
# then we can't run xcodebuild. On these systems we should
# default to clang
DEFAULT_TOOLCHAIN="clang"
fi
else
# First toolchain type in the list is the default
DEFAULT_TOOLCHAIN=${VALID_TOOLCHAINS%% *}
fi
if test "x$with_toolchain_type" = xlist; then
# List all toolchains
AC_MSG_NOTICE([The following toolchains are valid on this platform:])
@ -126,7 +133,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETERMINE_TOOLCHAIN_TYPE],
TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
$PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
done
exit 0
elif test "x$with_toolchain_type" != x; then
# User override; check that it is valid
@ -168,10 +175,10 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETERMINE_TOOLCHAIN_TYPE],
AC_MSG_NOTICE([Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)])
else
AC_MSG_NOTICE([Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN.])
fi
fi
])
# Before we start detecting the toolchain executables, we might need some
# Before we start detecting the toolchain executables, we might need some
# special setup, e.g. additional paths etc.
AC_DEFUN_ONCE([TOOLCHAIN_PRE_DETECTION],
[
@ -184,7 +191,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_PRE_DETECTION],
ORG_OBJCFLAGS="$OBJCFLAGS"
# On Windows, we need to detect the visual studio installation first.
# This will change the PATH, but we need to keep that new PATH even
# This will change the PATH, but we need to keep that new PATH even
# after toolchain detection is done, since the compiler (on x86) uses
# it for DLL resolution in runtime.
if test "x$OPENJDK_BUILD_OS" = "xwindows" && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then
@ -208,7 +215,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_PRE_DETECTION],
PATH="/usr/ccs/bin:$PATH"
fi
# Finally add TOOLCHAIN_PATH at the beginning, to allow --with-tools-dir to
# Finally add TOOLCHAIN_PATH at the beginning, to allow --with-tools-dir to
# override all other locations.
if test "x$TOOLCHAIN_PATH" != x; then
PATH=$TOOLCHAIN_PATH:$PATH
@ -254,7 +261,7 @@ AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION],
AC_MSG_NOTICE([The result from running with --version was: "$ALT_VERSION_OUTPUT"])
AC_MSG_ERROR([A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir.])
fi
# Remove usage instructions (if present), and
# Remove usage instructions (if present), and
# collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/ *@<:@Uu@:>@sage:.*//'`
@ -282,7 +289,7 @@ AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION],
# There is no specific version flag, but all output starts with a version string.
# First line typically looks something like:
# Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
# Check that this is likely to be Microsoft CL.EXE.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
if test $? -ne 0; then
@ -360,7 +367,7 @@ AC_DEFUN([TOOLCHAIN_FIND_COMPILER],
AC_MSG_NOTICE([Will use user supplied compiler $1=[$]$1])
if test "x`basename [$]$1`" = "x[$]$1"; then
# A command without a complete path is provided, search $PATH.
AC_PATH_PROGS(POTENTIAL_$1, [$]$1)
if test "x$POTENTIAL_$1" != x; then
$1=$POTENTIAL_$1
@ -375,12 +382,12 @@ AC_DEFUN([TOOLCHAIN_FIND_COMPILER],
fi
else
# No user supplied value. Locate compiler ourselves.
# If we are cross compiling, assume cross compilation tools follows the
# cross compilation standard where they are prefixed with the autoconf
# standard name for the target. For example the binary
# standard name for the target. For example the binary
# i686-sun-solaris2.10-gcc will cross compile for i686-sun-solaris2.10.
# If we are not cross compiling, then the default compiler name will be
# If we are not cross compiling, then the default compiler name will be
# used.
$1=
@ -450,9 +457,9 @@ AC_DEFUN([TOOLCHAIN_FIND_COMPILER],
TOOLCHAIN_CHECK_COMPILER_VERSION([$1], [$COMPILER_NAME])
])
# Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
# preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
# archiver (AR). Verify that the compilers are correct according to the
# Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
# preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
# archiver (AR). Verify that the compilers are correct according to the
# toolchain type.
AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_CORE],
[
@ -529,7 +536,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_CORE],
])
# Setup additional tools that is considered a part of the toolchain, but not the
# core part. Many of these are highly platform-specific and do not exist,
# core part. Many of these are highly platform-specific and do not exist,
# and/or are not needed on all platforms.
AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA],
[
@ -551,7 +558,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA],
AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,)
BASIC_FIXUP_EXECUTABLE(DUMPBIN)
fi
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
BASIC_PATH_PROGS(STRIP, strip)
BASIC_FIXUP_EXECUTABLE(STRIP)
@ -559,7 +566,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA],
BASIC_FIXUP_EXECUTABLE(NM)
BASIC_PATH_PROGS(GNM, gnm)
BASIC_FIXUP_EXECUTABLE(GNM)
BASIC_PATH_PROGS(MCS, mcs)
BASIC_FIXUP_EXECUTABLE(MCS)
elif test "x$OPENJDK_TARGET_OS" != xwindows; then
@ -592,17 +599,17 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA],
# Setup the build tools (i.e, the compiler and linker used to build programs
# that should be run on the build platform, not the target platform, as a build
# helper). Since the non-cross-compile case uses the normal, target compilers
# helper). Since the non-cross-compile case uses the normal, target compilers
# for this, we can only do this after these have been setup.
AC_DEFUN_ONCE([TOOLCHAIN_SETUP_BUILD_COMPILERS],
[
[
if test "x$COMPILE_TYPE" = "xcross"; then
# Now we need to find a C/C++ compiler that can build executables for the
# build platform. We can't use the AC_PROG_CC macro, since it can only be
# used once. Also, we need to do this without adding a tools dir to the
# path, otherwise we might pick up cross-compilers which don't use standard
# naming.
# FIXME: we should list the discovered compilers as an exclude pattern!
# If we do that, we can do this detection before POST_DETECTION, and still
# find the build compilers in the tools dir, if needed.
@ -690,15 +697,39 @@ AC_DEFUN_ONCE([TOOLCHAIN_MISC_CHECKS],
# If this is a --hash-style=gnu system, use --hash-style=both, why?
HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'`
# This is later checked when setting flags.
# "-Og" suppported for GCC 4.8 and later
CFLAG_OPTIMIZE_DEBUG_FLAG="-Og"
FLAGS_COMPILER_CHECK_ARGUMENTS([$CFLAG_OPTIMIZE_DEBUG_FLAG],
[HAS_CFLAG_OPTIMIZE_DEBUG=true],
[HAS_CFLAG_OPTIMIZE_DEBUG=false])
# "-fsanitize=undefined" supported for GCC 4.9 and later
CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG="-fsanitize=undefined -fsanitize-recover"
FLAGS_COMPILER_CHECK_ARGUMENTS([$CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG],
[HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR=true],
[HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR=false])
# "-z relro" supported in GNU binutils 2.17 and later
LINKER_RELRO_FLAG="-Xlinker -z -Xlinker relro"
FLAGS_LINKER_CHECK_ARGUMENTS([$LINKER_RELRO_FLAG],
[HAS_LINKER_RELRO=true],
[HAS_LINKER_RELRO=false])
# "-z now" supported in GNU binutils 2.11 and later
LINKER_NOW_FLAG="-Xlinker -z -Xlinker now"
FLAGS_LINKER_CHECK_ARGUMENTS([$LINKER_NOW_FLAG],
[HAS_LINKER_NOW=true],
[HAS_LINKER_NOW=false])
fi
# Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed
# Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed
# in executable.'
USING_BROKEN_SUSE_LD=no
if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$TOOLCHAIN_TYPE" = xgcc; then
AC_MSG_CHECKING([for broken SuSE 'ld' which only understands anonymous version tags in executables])
echo "SUNWprivate_1.1 { local: *; };" > version-script.map
echo "int main() { }" > main.c
$ECHO "SUNWprivate_1.1 { local: *; };" > version-script.map
$ECHO "int main() { }" > main.c
if $CXX -Xlinker -version-script=version-script.map main.c 2>&AS_MESSAGE_LOG_FD >&AS_MESSAGE_LOG_FD; then
AC_MSG_RESULT(no)
USING_BROKEN_SUSE_LD=no

2
corba/.hgtags
View File

@ -259,3 +259,5 @@ e212cdcc8c11f0ba5acf6f5ddb596c4c545a93f9 jdk9-b12
a2b82f863ba95a596da555a4c1b871c404863e7e jdk9-b14
e54022d0dd92106fff7f7fe670010cd7e6517ee3 jdk9-b15
422ef9d29d84f571453f015c4cb8713c3af70ee4 jdk9-b16
4c75c2ca7cf3e0618315879acf17f42c8fcd0c09 jdk9-b17
77565aaaa2bb814e94817e92d680168052a25395 jdk9-b18

2
hotspot/.hgtags
View File

@ -419,3 +419,5 @@ ebc44d040cd149d2120d69fe183a3dae7840f4b4 jdk9-b10
bd333491bb6c012d7b606939406d0fa9a5ac7ffd jdk9-b14
170f6d733d7aec062f743a6b8c1cce940a7a984a jdk9-b15
b14e7c0b7d3ec04127f565cda1d84122e205680c jdk9-b16
14b656df31c2cb09c505921061e79977823de71a jdk9-b17
871fd128548480095e0dc3fc34c422666baeec75 jdk9-b18

6
hotspot/make/bsd/makefiles/universal.gmk
View File

@ -74,19 +74,21 @@ $(UNIVERSAL_COPY_LIST):
# Replace arch specific binaries with universal binaries
# Do not touch jre/lib/{client,server}/libjsig.$(LIBRARY_SUFFIX)
# That symbolic link belongs to the 'jdk' build.
export_universal:
$(RM) -r $(EXPORT_PATH)/jre/lib/{i386,amd64}
$(RM) -r $(JDK_IMAGE_DIR)/jre/lib/{i386,amd64}
$(RM) $(JDK_IMAGE_DIR)/jre/lib/{client,server}/libjsig.$(LIBRARY_SUFFIX)
($(CD) $(EXPORT_PATH) && \
$(TAR) -cf - *) | \
($(CD) $(JDK_IMAGE_DIR) && $(TAR) -xpf -)
# Overlay universal binaries
# Do not touch jre/lib/{client,server}/libjsig.$(LIBRARY_SUFFIX)
# That symbolic link belongs to the 'jdk' build.
copy_universal:
$(RM) -r $(JDK_IMAGE_DIR)$(COPY_SUBDIR)/jre/lib/{i386,amd64}
$(RM) $(JDK_IMAGE_DIR)$(COPY_SUBDIR)/jre/lib/{client,server}/libjsig.$(LIBRARY_SUFFIX)
($(CD) $(EXPORT_PATH)$(COPY_SUBDIR) && \
$(TAR) -cf - *) | \
($(CD) $(JDK_IMAGE_DIR)$(COPY_SUBDIR) && $(TAR) -xpf -)

4
hotspot/make/jprt.properties
View File

@ -47,10 +47,10 @@ jprt.sync.push=false
# sparc etc.
# Define the Solaris platforms we want for the various releases
jprt.my.solaris.sparcv9.jdk9=solaris_sparcv9_5.10
jprt.my.solaris.sparcv9.jdk9=solaris_sparcv9_5.11
jprt.my.solaris.sparcv9=${jprt.my.solaris.sparcv9.${jprt.tools.default.release}}
jprt.my.solaris.x64.jdk9=solaris_x64_5.10
jprt.my.solaris.x64.jdk9=solaris_x64_5.11
jprt.my.solaris.x64=${jprt.my.solaris.x64.${jprt.tools.default.release}}
jprt.my.linux.i586.jdk9=linux_i586_2.6

10
hotspot/src/share/vm/classfile/classFileParser.cpp
View File

@ -4359,9 +4359,15 @@ void ClassFileParser::set_precomputed_flags(instanceKlassHandle k) {
Method* m = k->lookup_method(vmSymbols::finalize_method_name(),
vmSymbols::void_method_signature());
if (m != NULL && !m->is_empty_method()) {
f = true;
f = true;
}
// Spec doesn't prevent agent from redefinition of empty finalizer.
// Despite the fact that it's generally bad idea and redefined finalizer
// will not work as expected we shouldn't abort vm in this case
if (!k->has_redefined_this_or_super()) {
assert(f == k->has_finalizer(), "inconsistent has_finalizer");
}
assert(f == k->has_finalizer(), "inconsistent has_finalizer");
#endif
// Check if this klass supports the java.lang.Cloneable interface

2
hotspot/src/share/vm/classfile/javaClasses.hpp
View File

@ -1181,7 +1181,7 @@ public:
static oop target( oop site) { return site->obj_field( _target_offset); }
static void set_target( oop site, oop target) { site->obj_field_put( _target_offset, target); }
static volatile oop target_volatile(oop site) { return site->obj_field_volatile( _target_offset); }
static volatile oop target_volatile(oop site) { return oop((oopDesc *)(site->obj_field_volatile(_target_offset))); }
static void set_target_volatile(oop site, oop target) { site->obj_field_put_volatile(_target_offset, target); }
// Testers

3
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
View File

@ -311,8 +311,7 @@ void CMSCollector::ref_processor_init() {
_cmsGen->refs_discovery_is_mt(), // mt discovery
(int) MAX2(ConcGCThreads, ParallelGCThreads), // mt discovery degree
_cmsGen->refs_discovery_is_atomic(), // discovery is not atomic
&_is_alive_closure, // closure for liveness info
false); // next field updates do not need write barrier
&_is_alive_closure); // closure for liveness info
// Initialize the _ref_processor field of CMSGen
_cmsGen->set_ref_processor(_ref_processor);

10
hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
View File

@ -2246,12 +2246,9 @@ void G1CollectedHeap::ref_processing_init() {
// degree of mt discovery
false,
// Reference discovery is not atomic
&_is_alive_closure_cm,
&_is_alive_closure_cm);
// is alive closure
// (for efficiency/performance)
true);
// Setting next fields of discovered
// lists requires a barrier.
// STW ref processor
_ref_processor_stw =
@ -2266,12 +2263,9 @@ void G1CollectedHeap::ref_processing_init() {
// degree of mt discovery
true,
// Reference discovery is atomic
&_is_alive_closure_stw,
&_is_alive_closure_stw);
// is alive closure
// (for efficiency/performance)
false);
// Setting next fields of discovered
// lists does not require a barrier.
}
size_t G1CollectedHeap::capacity() const {

3
hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp
View File

@ -1636,8 +1636,7 @@ void ParNewGeneration::ref_processor_init() {
refs_discovery_is_mt(), // mt discovery
(int) ParallelGCThreads, // mt discovery degree
refs_discovery_is_atomic(), // atomic_discovery
NULL, // is_alive_non_header
false); // write barrier for next field updates
NULL); // is_alive_non_header
}
}

3
hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
View File

@ -854,8 +854,7 @@ void PSParallelCompact::post_initialize() {
true, // mt discovery
(int) ParallelGCThreads, // mt discovery degree
true, // atomic_discovery
&_is_alive_closure, // non-header is alive closure
false); // write barrier for next field updates
&_is_alive_closure); // non-header is alive closure
_counters = new CollectorCounters("PSParallelCompact", 1);
// Initialize static fields in ParCompactionManager.

3
hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp
View File

@ -864,8 +864,7 @@ void PSScavenge::initialize() {
true, // mt discovery
(int) ParallelGCThreads, // mt discovery degree
true, // atomic_discovery
NULL, // header provides liveness info
false); // next field updates do not need write barrier
NULL); // header provides liveness info
// Cache the cardtable
BarrierSet* bs = Universe::heap()->barrier_set();

1
hotspot/src/share/vm/memory/allocation.cpp
View File

@ -563,6 +563,7 @@ void* Arena::grow(size_t x, AllocFailType alloc_failmode) {
_chunk = new (alloc_failmode, len) Chunk(len);
if (_chunk == NULL) {
_chunk = k; // restore the previous value of _chunk
return NULL;
}
if (k) k->set_next(_chunk); // Append new chunk to end of linked list

44
hotspot/src/share/vm/memory/metaspace.cpp
View File

@ -1423,6 +1423,17 @@ size_t MetaspaceGC::dec_capacity_until_GC(size_t v) {
return (size_t)Atomic::add_ptr(-(intptr_t)v, &_capacity_until_GC);
}
void MetaspaceGC::initialize() {
// Set the high-water mark to MaxMetapaceSize during VM initializaton since
// we can't do a GC during initialization.
_capacity_until_GC = MaxMetaspaceSize;
}
void MetaspaceGC::post_initialize() {
// Reset the high-water mark once the VM initialization is done.
_capacity_until_GC = MAX2(MetaspaceAux::committed_bytes(), MetaspaceSize);
}
bool MetaspaceGC::can_expand(size_t word_size, bool is_class) {
// Check if the compressed class space is full.
if (is_class && Metaspace::using_class_space()) {
@ -1443,21 +1454,13 @@ bool MetaspaceGC::can_expand(size_t word_size, bool is_class) {
size_t MetaspaceGC::allowed_expansion() {
size_t committed_bytes = MetaspaceAux::committed_bytes();
size_t left_until_max = MaxMetaspaceSize - committed_bytes;
// Always grant expansion if we are initiating the JVM,
// or if the GC_locker is preventing GCs.
if (!is_init_completed() || GC_locker::is_active_and_needs_gc()) {
return left_until_max / BytesPerWord;
}
size_t capacity_until_gc = capacity_until_GC();
if (capacity_until_gc <= committed_bytes) {
return 0;
}
assert(capacity_until_gc >= committed_bytes,
err_msg("capacity_until_gc: " SIZE_FORMAT " < committed_bytes: " SIZE_FORMAT,
capacity_until_gc, committed_bytes));
size_t left_until_max = MaxMetaspaceSize - committed_bytes;
size_t left_until_GC = capacity_until_gc - committed_bytes;
size_t left_to_commit = MIN2(left_until_GC, left_until_max);
@ -1469,7 +1472,15 @@ void MetaspaceGC::compute_new_size() {
uint current_shrink_factor = _shrink_factor;
_shrink_factor = 0;
const size_t used_after_gc = MetaspaceAux::capacity_bytes();
// Using committed_bytes() for used_after_gc is an overestimation, since the
// chunk free lists are included in committed_bytes() and the memory in an
// un-fragmented chunk free list is available for future allocations.
// However, if the chunk free lists becomes fragmented, then the memory may
// not be available for future allocations and the memory is therefore "in use".
// Including the chunk free lists in the definition of "in use" is therefore
// necessary. Not including the chunk free lists can cause capacity_until_GC to
// shrink below committed_bytes() and this has caused serious bugs in the past.
const size_t used_after_gc = MetaspaceAux::committed_bytes();
const size_t capacity_until_GC = MetaspaceGC::capacity_until_GC();
const double minimum_free_percentage = MinMetaspaceFreeRatio / 100.0;
@ -3094,6 +3105,8 @@ void Metaspace::ergo_initialize() {
}
void Metaspace::global_initialize() {
MetaspaceGC::initialize();
// Initialize the alignment for shared spaces.
int max_alignment = os::vm_allocation_granularity();
size_t cds_total = 0;
@ -3201,10 +3214,13 @@ void Metaspace::global_initialize() {
}
}
MetaspaceGC::initialize();
_tracer = new MetaspaceTracer();
}
void Metaspace::post_initialize() {
MetaspaceGC::post_initialize();
}
Metachunk* Metaspace::get_initialization_chunk(MetadataType mdtype,
size_t chunk_word_size,
size_t chunk_bunch) {

4
hotspot/src/share/vm/memory/metaspace.hpp
View File

@ -208,6 +208,7 @@ class Metaspace : public CHeapObj<mtClass> {
static void ergo_initialize();
static void global_initialize();
static void post_initialize();
static size_t first_chunk_word_size() { return _first_chunk_word_size; }
static size_t first_class_chunk_word_size() { return _first_class_chunk_word_size; }
@ -398,7 +399,8 @@ class MetaspaceGC : AllStatic {
public:
static void initialize() { _capacity_until_GC = MetaspaceSize; }
static void initialize();
static void post_initialize();
static size_t capacity_until_GC();
static size_t inc_capacity_until_GC(size_t v);

89
hotspot/src/share/vm/memory/referenceProcessor.cpp
View File

@ -96,12 +96,10 @@ ReferenceProcessor::ReferenceProcessor(MemRegion span,
bool mt_discovery,
uint mt_discovery_degree,
bool atomic_discovery,
BoolObjectClosure* is_alive_non_header,
bool discovered_list_needs_post_barrier) :
BoolObjectClosure* is_alive_non_header) :
_discovering_refs(false),
_enqueuing_is_done(false),
_is_alive_non_header(is_alive_non_header),
_discovered_list_needs_post_barrier(discovered_list_needs_post_barrier),
_processing_is_mt(mt_processing),
_next_id(0)
{
@ -340,10 +338,18 @@ void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list,
// (java.lang.ref.Reference.discovered), self-loop their "next" field
// thus distinguishing them from active References, then
// prepend them to the pending list.
//
// The Java threads will see the Reference objects linked together through
// the discovered field. Instead of trying to do the write barrier updates
// in all places in the reference processor where we manipulate the discovered
// field we make sure to do the barrier here where we anyway iterate through
// all linked Reference objects. Note that it is important to not dirty any
// cards during reference processing since this will cause card table
// verification to fail for G1.
//
// BKWRD COMPATIBILITY NOTE: For older JDKs (prior to the fix for 4956777),
// the "next" field is used to chain the pending list, not the discovered
// field.
if (TraceReferenceGC && PrintGCDetails) {
gclog_or_tty->print_cr("ReferenceProcessor::enqueue_discovered_reflist list "
INTPTR_FORMAT, (address)refs_list.head());
@ -365,15 +371,15 @@ void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list,
assert(java_lang_ref_Reference::next(obj) == NULL,
"Reference not active; should not be discovered");
// Self-loop next, so as to make Ref not active.
// Post-barrier not needed when looping to self.
java_lang_ref_Reference::set_next_raw(obj, obj);
if (next_d == obj) { // obj is last
if (next_d != obj) {
oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), next_d);
} else {
// This is the last object.
// Swap refs_list into pending_list_addr and
// set obj's discovered to what we read from pending_list_addr.
oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
// Need post-barrier on pending_list_addr above;
// see special post-barrier code at the end of
// enqueue_discovered_reflists() further below.
// Need post-barrier on pending_list_addr. See enqueue_discovered_ref_helper() above.
java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL
oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old);
}
@ -496,20 +502,15 @@ void DiscoveredListIterator::remove() {
// pre-barrier here because we know the Reference has already been found/marked,
// that's how it ended up in the discovered list in the first place.
oop_store_raw(_prev_next, new_next);
if (_discovered_list_needs_post_barrier && _prev_next != _refs_list.adr_head()) {
// Needs post-barrier and this is not the list head (which is not on the heap)
oopDesc::bs()->write_ref_field(_prev_next, new_next);
}
NOT_PRODUCT(_removed++);
_refs_list.dec_length(1);
}
// Make the Reference object active again.
void DiscoveredListIterator::make_active() {
// For G1 we don't want to use set_next - it
// will dirty the card for the next field of
// the reference object and will fail
// CT verification.
// The pre barrier for G1 is probably just needed for the old
// reference processing behavior. Should we guard this with
// ReferenceProcessor::pending_list_uses_discovered_field() ?
if (UseG1GC) {
HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref);
if (UseCompressedOops) {
@ -517,10 +518,8 @@ void DiscoveredListIterator::make_active() {
} else {
oopDesc::bs()->write_ref_field_pre((oop*)next_addr, NULL);
}
java_lang_ref_Reference::set_next_raw(_ref, NULL);
} else {
java_lang_ref_Reference::set_next(_ref, NULL);
}
java_lang_ref_Reference::set_next_raw(_ref, NULL);
}
void DiscoveredListIterator::clear_referent() {
@ -546,7 +545,7 @@ ReferenceProcessor::process_phase1(DiscoveredList& refs_list,
OopClosure* keep_alive,
VoidClosure* complete_gc) {
assert(policy != NULL, "Must have a non-NULL policy");
DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
// Decide which softly reachable refs should be kept alive.
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));
@ -586,7 +585,7 @@ ReferenceProcessor::pp2_work(DiscoveredList& refs_list,
BoolObjectClosure* is_alive,
OopClosure* keep_alive) {
assert(discovery_is_atomic(), "Error");
DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
DEBUG_ONLY(oop next = java_lang_ref_Reference::next(iter.obj());)
@ -623,7 +622,7 @@ ReferenceProcessor::pp2_work_concurrent_discovery(DiscoveredList& refs_list,
OopClosure* keep_alive,
VoidClosure* complete_gc) {
assert(!discovery_is_atomic(), "Error");
DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
HeapWord* next_addr = java_lang_ref_Reference::next_addr(iter.obj());
@ -666,7 +665,7 @@ ReferenceProcessor::process_phase3(DiscoveredList& refs_list,
OopClosure* keep_alive,
VoidClosure* complete_gc) {
ResourceMark rm;
DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
while (iter.has_next()) {
iter.update_discovered();
iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
@ -782,13 +781,6 @@ private:
bool _clear_referent;
};
void ReferenceProcessor::set_discovered(oop ref, oop value) {
java_lang_ref_Reference::set_discovered_raw(ref, value);
if (_discovered_list_needs_post_barrier) {
oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(ref), value);
}
}
// Balances reference queues.
// Move entries from all queues[0, 1, ..., _max_num_q-1] to
// queues[0, 1, ..., _num_q-1] because only the first _num_q
@ -846,9 +838,9 @@ void ReferenceProcessor::balance_queues(DiscoveredList ref_lists[])
// Add the chain to the to list.
if (ref_lists[to_idx].head() == NULL) {
// to list is empty. Make a loop at the end.
set_discovered(move_tail, move_tail);
java_lang_ref_Reference::set_discovered_raw(move_tail, move_tail);
} else {
set_discovered(move_tail, ref_lists[to_idx].head());
java_lang_ref_Reference::set_discovered_raw(move_tail, ref_lists[to_idx].head());
}
ref_lists[to_idx].set_head(move_head);
ref_lists[to_idx].inc_length(refs_to_move);
@ -982,7 +974,7 @@ void ReferenceProcessor::clean_up_discovered_references() {
void ReferenceProcessor::clean_up_discovered_reflist(DiscoveredList& refs_list) {
assert(!discovery_is_atomic(), "Else why call this method?");
DiscoveredListIterator iter(refs_list, NULL, NULL, _discovered_list_needs_post_barrier);
DiscoveredListIterator iter(refs_list, NULL, NULL);
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
oop next = java_lang_ref_Reference::next(iter.obj());
@ -1071,16 +1063,6 @@ ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,
// The last ref must have its discovered field pointing to itself.
oop next_discovered = (current_head != NULL) ? current_head : obj;
// Note: In the case of G1, this specific pre-barrier is strictly
// not necessary because the only case we are interested in
// here is when *discovered_addr is NULL (see the CAS further below),
// so this will expand to nothing. As a result, we have manually
// elided this out for G1, but left in the test for some future
// collector that might have need for a pre-barrier here, e.g.:-
// oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
assert(!_discovered_list_needs_post_barrier || UseG1GC,
"Need to check non-G1 collector: "
"may need a pre-write-barrier for CAS from NULL below");
oop retest = oopDesc::atomic_compare_exchange_oop(next_discovered, discovered_addr,
NULL);
if (retest == NULL) {
@ -1089,9 +1071,6 @@ ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,
// is necessary.
refs_list.set_head(obj);
refs_list.inc_length(1);
if (_discovered_list_needs_post_barrier) {
oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
}
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",
@ -1242,24 +1221,14 @@ bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {
if (_discovery_is_mt) {
add_to_discovered_list_mt(*list, obj, discovered_addr);
} else {
// If "_discovered_list_needs_post_barrier", we do write barriers when
// updating the discovered reference list. Otherwise, we do a raw store
// here: the field will be visited later when processing the discovered
// references.
// We do a raw store here: the field will be visited later when processing
// the discovered references.
oop current_head = list->head();
// The last ref must have its discovered field pointing to itself.
oop next_discovered = (current_head != NULL) ? current_head : obj;
// As in the case further above, since we are over-writing a NULL
// pre-value, we can safely elide the pre-barrier here for the case of G1.
// e.g.:- oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
assert(discovered == NULL, "control point invariant");
assert(!_discovered_list_needs_post_barrier || UseG1GC,
"For non-G1 collector, may need a pre-write-barrier for CAS from NULL below");
oop_store_raw(discovered_addr, next_discovered);
if (_discovered_list_needs_post_barrier) {
oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
}
list->set_head(obj);
list->inc_length(1);
@ -1353,7 +1322,7 @@ ReferenceProcessor::preclean_discovered_reflist(DiscoveredList& refs_list,
OopClosure* keep_alive,
VoidClosure* complete_gc,
YieldClosure* yield) {
DiscoveredListIterator iter(refs_list, keep_alive, is_alive, _discovered_list_needs_post_barrier);
DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
oop obj = iter.obj();

23
hotspot/src/share/vm/memory/referenceProcessor.hpp
View File

@ -99,7 +99,6 @@ private:
oop _referent;
OopClosure* _keep_alive;
BoolObjectClosure* _is_alive;
bool _discovered_list_needs_post_barrier;
DEBUG_ONLY(
oop _first_seen; // cyclic linked list check
@ -113,8 +112,7 @@ private:
public:
inline DiscoveredListIterator(DiscoveredList& refs_list,
OopClosure* keep_alive,
BoolObjectClosure* is_alive,
bool discovered_list_needs_post_barrier = false):
BoolObjectClosure* is_alive):
_refs_list(refs_list),
_prev_next(refs_list.adr_head()),
_prev(NULL),
@ -128,8 +126,7 @@ public:
#endif
_next(NULL),
_keep_alive(keep_alive),
_is_alive(is_alive),
_discovered_list_needs_post_barrier(discovered_list_needs_post_barrier)
_is_alive(is_alive)
{ }
// End Of List.
@ -230,14 +227,6 @@ class ReferenceProcessor : public CHeapObj<mtGC> {
// other collectors in configuration
bool _discovery_is_mt; // true if reference discovery is MT.
// If true, setting "next" field of a discovered refs list requires
// write post barrier. (Must be true if used in a collector in which
// elements of a discovered list may be moved during discovery: for
// example, a collector like Garbage-First that moves objects during a
// long-term concurrent marking phase that does weak reference
// discovery.)
bool _discovered_list_needs_post_barrier;
bool _enqueuing_is_done; // true if all weak references enqueued
bool _processing_is_mt; // true during phases when
// reference processing is MT.
@ -382,11 +371,6 @@ class ReferenceProcessor : public CHeapObj<mtGC> {
void enqueue_discovered_reflists(HeapWord* pending_list_addr, AbstractRefProcTaskExecutor* task_executor);
protected:
// Set the 'discovered' field of the given reference to
// the given value - emitting post barriers depending upon
// the value of _discovered_list_needs_post_barrier.
void set_discovered(oop ref, oop value);
// "Preclean" the given discovered reference list
// by removing references with strongly reachable referents.
// Currently used in support of CMS only.
@ -427,8 +411,7 @@ class ReferenceProcessor : public CHeapObj<mtGC> {
bool mt_processing = false, uint mt_processing_degree = 1,
bool mt_discovery = false, uint mt_discovery_degree = 1,
bool atomic_discovery = true,
BoolObjectClosure* is_alive_non_header = NULL,
bool discovered_list_needs_post_barrier = false);
BoolObjectClosure* is_alive_non_header = NULL);
// RefDiscoveryPolicy values
enum DiscoveryPolicy {

15
hotspot/src/share/vm/oops/instanceKlass.cpp
View File

@ -1501,6 +1501,21 @@ Method* InstanceKlass::uncached_lookup_method(Symbol* name, Symbol* signature, M
return NULL;
}
#ifdef ASSERT
// search through class hierarchy and return true if this class or
// one of the superclasses was redefined
bool InstanceKlass::has_redefined_this_or_super() const {
const InstanceKlass* klass = this;
while (klass != NULL) {
if (klass->has_been_redefined()) {
return true;
}
klass = InstanceKlass::cast(klass->super());
}
return false;
}
#endif
// lookup a method in the default methods list then in all transitive interfaces
// Do NOT return private or static methods
Method* InstanceKlass::lookup_method_in_ordered_interfaces(Symbol* name,

9
hotspot/src/share/vm/oops/instanceKlass.hpp
View File

@ -754,6 +754,11 @@ class InstanceKlass: public Klass {
bool implements_interface(Klass* k) const;
bool is_same_or_direct_interface(Klass* k) const;
#ifdef ASSERT
// check whether this class or one of its superclasses was redefined
bool has_redefined_this_or_super() const;
#endif
// Access to the implementor of an interface.
Klass* implementor() const
{
@ -811,8 +816,8 @@ class InstanceKlass: public Klass {
// Casting from Klass*
static InstanceKlass* cast(Klass* k) {
assert(k->is_klass(), "must be");
assert(k->oop_is_instance(), "cast to InstanceKlass");
assert(k == NULL || k->is_klass(), "must be");
assert(k == NULL || k->oop_is_instance(), "cast to InstanceKlass");
return (InstanceKlass*) k;
}

10
hotspot/src/share/vm/oops/oopsHierarchy.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -112,9 +112,7 @@ public:
// Assignment
oop& operator=(const oop& o) { _o = o.obj(); return *this; }
#ifndef SOLARIS
volatile oop& operator=(const oop& o) volatile { _o = o.obj(); return *this; }
#endif
volatile oop& operator=(const volatile oop& o) volatile { _o = o.obj(); return *this; }
// Explict user conversions
@ -123,11 +121,10 @@ public:
operator void* () const volatile { return (void *)obj(); }
#endif
operator HeapWord* () const { return (HeapWord*)obj(); }
operator oopDesc* () const { return obj(); }
operator oopDesc* () const volatile { return obj(); }
operator intptr_t* () const { return (intptr_t*)obj(); }
operator PromotedObject* () const { return (PromotedObject*)obj(); }
operator markOop () const { return markOop(obj()); }
operator address () const { return (address)obj(); }
// from javaCalls.cpp
@ -161,11 +158,10 @@ public:
oop::operator=(o); \
return *this; \
} \
NOT_SOLARIS( \
volatile type##Oop& operator=(const type##Oop& o) volatile { \
(void)const_cast<oop&>(oop::operator=(o)); \
return *this; \
}) \
} \
volatile type##Oop& operator=(const volatile type##Oop& o) volatile {\
(void)const_cast<oop&>(oop::operator=(o)); \
return *this; \

8
hotspot/src/share/vm/runtime/mutexLocker.cpp
View File

@ -280,10 +280,10 @@ void mutex_init() {
#ifdef INCLUDE_TRACE
def(JfrMsg_lock , Monitor, leaf, true);
def(JfrBuffer_lock , Mutex, nonleaf+1, true);
def(JfrThreadGroups_lock , Mutex, nonleaf+1, true);
def(JfrStream_lock , Mutex, nonleaf+2, true);
def(JfrStacktrace_lock , Mutex, special, true );
def(JfrBuffer_lock , Mutex, leaf, true);
def(JfrThreadGroups_lock , Mutex, leaf, true);
def(JfrStream_lock , Mutex, nonleaf, true);
def(JfrStacktrace_lock , Mutex, special, true);
#endif
}

9
hotspot/src/share/vm/runtime/objectMonitor.cpp
View File

@ -385,6 +385,15 @@ void ATTR ObjectMonitor::enter(TRAPS) {
jt->java_suspend_self();
}
Self->set_current_pending_monitor(NULL);
// We cleared the pending monitor info since we've just gotten past
// the enter-check-for-suspend dance and we now own the monitor free
// and clear, i.e., it is no longer pending. The ThreadBlockInVM
// destructor can go to a safepoint at the end of this block. If we
// do a thread dump during that safepoint, then this thread will show
// as having "-locked" the monitor, but the OS and java.lang.Thread
// states will still report that the thread is blocked trying to
// acquire it.
}
Atomic::dec_ptr(&_count);

4
hotspot/src/share/vm/runtime/thread.cpp
View File

@ -1434,7 +1434,7 @@ void JavaThread::initialize() {
_in_deopt_handler = 0;
_doing_unsafe_access = false;
_stack_guard_state = stack_guard_unused;
(void)const_cast<oop&>(_exception_oop = NULL);
(void)const_cast<oop&>(_exception_oop = oop(NULL));
_exception_pc = 0;
_exception_handler_pc = 0;
_is_method_handle_return = 0;
@ -3543,6 +3543,8 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
// debug stuff, that does not work until all basic classes have been initialized.
set_init_completed();
Metaspace::post_initialize();
HOTSPOT_VM_INIT_END();
// record VM initialization completion time

7
hotspot/src/share/vm/runtime/vframe.cpp
View File

@ -199,6 +199,7 @@ void javaVFrame::print_lock_info_on(outputStream* st, int frame_count) {
continue;
}
if (monitor->owner() != NULL) {
// the monitor is associated with an object, i.e., it is locked
// First, assume we have the monitor locked. If we haven't found an
// owned monitor before and this is the first frame, then we need to
@ -209,7 +210,11 @@ void javaVFrame::print_lock_info_on(outputStream* st, int frame_count) {
if (!found_first_monitor && frame_count == 0) {
markOop mark = monitor->owner()->mark();
if (mark->has_monitor() &&
mark->monitor() == thread()->current_pending_monitor()) {
( // we have marked ourself as pending on this monitor
mark->monitor() == thread()->current_pending_monitor() ||
// we are not the owner of this monitor
!mark->monitor()->is_entered(thread())
)) {
lock_state = "waiting to lock";
}
}

5
hotspot/src/share/vm/services/attachListener.cpp
View File

@ -162,10 +162,7 @@ static jint jcmd(AttachOperation* op, outputStream* out) {
java_lang_Throwable::print(PENDING_EXCEPTION, out);
out->cr();
CLEAR_PENDING_EXCEPTION;
// The exception has been printed on the output stream
// If the JVM returns JNI_ERR, the attachAPI throws a generic I/O
// exception and the content of the output stream is not processed.
// By returning JNI_OK, the exception will be displayed on the client side
return JNI_ERR;
}
return JNI_OK;
}

4
hotspot/src/share/vm/services/memoryManager.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -39,7 +39,7 @@
MemoryManager::MemoryManager() {
_num_pools = 0;
(void)const_cast<instanceOop&>(_memory_mgr_obj = NULL);
(void)const_cast<instanceOop&>(_memory_mgr_obj = instanceOop(NULL));
}
void MemoryManager::add_pool(MemoryPool* pool) {

4
hotspot/src/share/vm/services/memoryPool.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -46,7 +46,7 @@ MemoryPool::MemoryPool(const char* name,
_name = name;
_initial_size = init_size;
_max_size = max_size;
(void)const_cast<instanceOop&>(_memory_pool_obj = NULL);
(void)const_cast<instanceOop&>(_memory_pool_obj = instanceOop(NULL));
_available_for_allocation = true;
_num_managers = 0;
_type = type;

2
hotspot/src/share/vm/utilities/debug.cpp
View File

@ -263,13 +263,11 @@ void report_untested(const char* file, int line, const char* message) {
void report_out_of_shared_space(SharedSpaceType shared_space) {
static const char* name[] = {
"native memory for metadata",
"shared read only space",
"shared read write space",
"shared miscellaneous data space"
};
static const char* flag[] = {
"Metaspace",
"SharedReadOnlySize",
"SharedReadWriteSize",
"SharedMiscDataSize"

1
hotspot/test/TEST.groups
View File

@ -81,6 +81,7 @@ needs_jdk = \
runtime/NMT/ThreadedVirtualAllocTestType.java \
runtime/NMT/VirtualAllocTestType.java \
runtime/RedefineObject/TestRedefineObject.java \
runtime/Thread/TestThreadDumpMonitorContention.java \
runtime/XCheckJniJsig/XCheckJSig.java \
serviceability/attach/AttachWithStalePidFile.java \
serviceability/jvmti/8036666/GetObjectLockCount.java \

1
hotspot/test/gc/arguments/TestParallelHeapSizeFlags.java
View File

@ -22,6 +22,7 @@
*/
/*
* @ignore 8027915
* @test TestParallelHeapSizeFlags
* @key gc
* @bug 8006088

1
hotspot/test/gc/arguments/TestUseCompressedOopsErgo.java
View File

@ -22,6 +22,7 @@
*/
/*
* @ignore 8025645
* @test TestUseCompressedOopsErgo
* @key gc
* @bug 8010722

1
hotspot/test/gc/g1/TestHumongousShrinkHeap.java
View File

@ -22,6 +22,7 @@
*/
/**
* @ignore 8041506, 8041946, 8042051
* @test TestHumongousShrinkHeap
* @bug 8036025
* @summary Verify that heap shrinks after GC in the presence of fragmentation due to humongous objects

89
hotspot/test/gc/g1/TestStringDeduplicationTools.java
View File

@ -294,55 +294,6 @@ class TestStringDeduplicationTools {
}
}
private static class MemoryUsageTest {
public static void main(String[] args) {
System.out.println("Begin: MemoryUsageTest");
final boolean useStringDeduplication = Boolean.parseBoolean(args[0]);
final int numberOfStrings = LargeNumberOfStrings;
final int numberOfUniqueStrings = 1;
ArrayList<String> list = createStrings(numberOfStrings, numberOfUniqueStrings);
forceDeduplication(DefaultAgeThreshold, FullGC);
if (useStringDeduplication) {
verifyStrings(list, numberOfUniqueStrings);
}
System.gc();
System.out.println("Heap Memory Usage: " + ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed());
System.out.println("Array Header Size: " + unsafe.ARRAY_CHAR_BASE_OFFSET);
System.out.println("End: MemoryUsageTest");
}
public static OutputAnalyzer run(boolean useStringDeduplication) throws Exception {
String[] extraArgs = new String[0];
if (useStringDeduplication) {
extraArgs = new String[] {
"-XX:+UseStringDeduplication",
"-XX:+PrintStringDeduplicationStatistics",
"-XX:StringDeduplicationAgeThreshold=" + DefaultAgeThreshold
};
}
String[] defaultArgs = new String[] {
"-XX:+PrintGC",
"-XX:+PrintGCDetails",
MemoryUsageTest.class.getName(),
"" + useStringDeduplication
};
ArrayList<String> args = new ArrayList<String>();
args.addAll(Arrays.asList(extraArgs));
args.addAll(Arrays.asList(defaultArgs));
return runTest(args.toArray(new String[args.size()]));
}
}
/*
* Tests
*/
@ -480,44 +431,4 @@ class TestStringDeduplicationTools {
OutputAnalyzer output = InternedTest.run();
output.shouldHaveExitValue(0);
}
public static void testMemoryUsage() throws Exception {
// Test that memory usage is reduced after deduplication
OutputAnalyzer output;
final String heapMemoryUsagePattern = "Heap Memory Usage: (\\d+)";
final String arrayHeaderSizePattern = "Array Header Size: (\\d+)";
// Run without deduplication
output = MemoryUsageTest.run(false);
output.shouldHaveExitValue(0);
final long heapMemoryUsageWithoutDedup = Long.parseLong(output.firstMatch(heapMemoryUsagePattern, 1));
final long arrayHeaderSizeWithoutDedup = Long.parseLong(output.firstMatch(arrayHeaderSizePattern, 1));
// Run with deduplication
output = MemoryUsageTest.run(true);
output.shouldHaveExitValue(0);
final long heapMemoryUsageWithDedup = Long.parseLong(output.firstMatch(heapMemoryUsagePattern, 1));
final long arrayHeaderSizeWithDedup = Long.parseLong(output.firstMatch(arrayHeaderSizePattern, 1));
// Sanity check to make sure one instance isn't using compressed class pointers and the other not
if (arrayHeaderSizeWithoutDedup != arrayHeaderSizeWithDedup) {
throw new Exception("Unexpected difference between array header sizes");
}
// Calculate expected memory usage with deduplication enabled. This calculation does
// not take alignment and padding into account, so it's a conservative estimate.
final long sizeOfChar = unsafe.ARRAY_CHAR_INDEX_SCALE;
final long sizeOfCharArray = StringLength * sizeOfChar + arrayHeaderSizeWithoutDedup;
final long bytesSaved = (LargeNumberOfStrings - 1) * sizeOfCharArray;
final long heapMemoryUsageWithDedupExpected = heapMemoryUsageWithoutDedup - bytesSaved;
System.out.println("Memory usage summary:");
System.out.println(" heapMemoryUsageWithoutDedup: " + heapMemoryUsageWithoutDedup);
System.out.println(" heapMemoryUsageWithDedup: " + heapMemoryUsageWithDedup);
System.out.println(" heapMemoryUsageWithDedupExpected: " + heapMemoryUsageWithDedupExpected);
if (heapMemoryUsageWithDedup > heapMemoryUsageWithDedupExpected) {
throw new Exception("Unexpected memory usage, heapMemoryUsageWithDedup should be less or equal to heapMemoryUsageWithDedupExpected");
}
}
}

48
hotspot/test/gc/metaspace/TestMetaspaceInitialization.java Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.util.ArrayList;
/* @test TestMetaspaceInitialization
* @bug 8042933
* @summary Tests to initialize metaspace with a very low MetaspaceSize
* @library /testlibrary
* @run main/othervm -XX:MetaspaceSize=2m TestMetaspaceInitialization
*/
public class TestMetaspaceInitialization {
private class Internal {
public int x;
public Internal(int x) {
this.x = x;
}
}
private void test() {
ArrayList<Internal> l = new ArrayList<>();
l.add(new Internal(17));
}
public static void main(String[] args) {
new TestMetaspaceInitialization().test();
}
}

1
hotspot/test/gc/parallelScavenge/TestDynShrinkHeap.java
View File

@ -22,6 +22,7 @@
*/
/**
* @ignore 8042051
* @test TestDynShrinkHeap
* @bug 8016479
* @summary Verify that the heap shrinks after full GC according to the current values of the Min/MaxHeapFreeRatio flags

4
hotspot/test/runtime/CommandLine/TestHexArguments.java
View File

@ -35,14 +35,14 @@ import com.oracle.java.testlibrary.*;
public class TestHexArguments {
public static void main(String args[]) throws Exception {
String[] javaArgs = {"-XX:SharedBaseAddress=0x1D000000", "-version"};
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(true, javaArgs);
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(javaArgs);
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldNotContain("Could not create the Java Virtual Machine");
output.shouldHaveExitValue(0);
String[] javaArgs1 = {"-XX:SharedBaseAddress=1D000000", "-version"};
pb = ProcessTools.createJavaProcessBuilder(true, javaArgs1);
pb = ProcessTools.createJavaProcessBuilder(javaArgs1);
output = new OutputAnalyzer(pb.start());
output.shouldContain("Could not create the Java Virtual Machine");
}

64
hotspot/test/runtime/RedefineFinalizer/RedefineFinalizer.java Normal file
View File

@ -0,0 +1,64 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 6904403
* @summary Don't assert if we redefine finalize method
* @library /testlibrary
* @build RedefineClassHelper
* @run main RedefineClassHelper
* @run main/othervm -javaagent:redefineagent.jar RedefineFinalizer
*/
/*
* Regression test for hitting:
*
* assert(f == k->has_finalizer()) failed: inconsistent has_finalizer
*
* when redefining finalizer method
*/
public class RedefineFinalizer {
public static String newB =
"class RedefineFinalizer$B {" +
" protected void finalize() { " +
" System.out.println(\"Finalizer called\");" +
" }" +
"}";
public static void main(String[] args) throws Exception {
RedefineClassHelper.redefineClass(B.class, newB);
A a = new A();
}
static class A extends B {
}
static class B {
protected void finalize() {
// should be empty
}
}
}

93
hotspot/test/runtime/SharedArchiveFile/LimitSharedSizes.java Normal file
View File

@ -0,0 +1,93 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @ignore JDK-8043896
* @test LimitSharedSizes
* @summary Test handling of limits on shared space size
* @library /testlibrary
* @run main LimitSharedSizes
*/
import com.oracle.java.testlibrary.*;
public class LimitSharedSizes {
private static class SharedSizeTestData {
public String optionName;
public String optionValue;
public String expectedErrorMsg;
public SharedSizeTestData(String name, String value, String msg) {
optionName = name;
optionValue = value;
expectedErrorMsg = msg;
}
}
private static final SharedSizeTestData[] testTable = {
// values in this part of the test table should cause failure
// (shared space sizes are deliberately too small)
new SharedSizeTestData("-XX:SharedReadOnlySize", "4M", "read only"),
new SharedSizeTestData("-XX:SharedReadWriteSize","4M", "read write"),
// Known issue, JDK-8038422 (assert() on Windows)
// new SharedSizeTestData("-XX:SharedMiscDataSize", "500k", "miscellaneous data"),
// This will cause a VM crash; commenting out for now; see bug JDK-8038268
// @ignore JDK-8038268
// new SharedSizeTestData("-XX:SharedMiscCodeSize", "20k", "miscellaneous code"),
// these values are larger than default ones, but should
// be acceptable and not cause failure
new SharedSizeTestData("-XX:SharedReadOnlySize", "20M", null),
new SharedSizeTestData("-XX:SharedReadWriteSize", "20M", null),
new SharedSizeTestData("-XX:SharedMiscDataSize", "20M", null),
new SharedSizeTestData("-XX:SharedMiscCodeSize", "20M", null)
};
public static void main(String[] args) throws Exception {
String fileName = "test.jsa";
for (SharedSizeTestData td : testTable) {
String option = td.optionName + "=" + td.optionValue;
System.out.println("testing option <" + option + ">");
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=./" + fileName,
option,
"-Xshare:dump");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
if (td.expectedErrorMsg != null) {
output.shouldContain("The shared " + td.expectedErrorMsg
+ " space is not large enough");
output.shouldHaveExitValue(2);
} else {
output.shouldNotContain("space is not large enough");
output.shouldHaveExitValue(0);
}
}
}
}

77
hotspot/test/runtime/SharedArchiveFile/SharedBaseAddress.java Normal file
View File

@ -0,0 +1,77 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test SharedBaseAddress
* @summary Test variety of values for SharedBaseAddress, making sure
* VM handles normal values as well as edge values w/o a crash.
* @library /testlibrary
* @run main SharedBaseAddress
*/
import com.oracle.java.testlibrary.*;
public class SharedBaseAddress {
// shared base address test table
private static final String[] testTable = {
"1g", "8g", "64g","512g", "4t",
"32t", "128t", "0",
"1", "64k", "64M"
};
public static void main(String[] args) throws Exception {
// Known issue on Solaris-Sparc
// @ignore JDK-8044600
if (Platform.isSolaris() && Platform.isSparc())
return;
for (String testEntry : testTable) {
System.out.println("sharedBaseAddress = " + testEntry);
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=test.jsa",
"-XX:SharedBaseAddress=" + testEntry,
"-Xshare:dump");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Loading classes to share");
try {
pb = ProcessTools.createJavaProcessBuilder(
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=test.jsa",
"-Xshare:on",
"-version");
output = new OutputAnalyzer(pb.start());
output.shouldContain("sharing");
output.shouldHaveExitValue(0);
} catch (RuntimeException e) {
output.shouldContain("Unable to use shared archive");
output.shouldHaveExitValue(1);
}
}
}
}

96
hotspot/test/runtime/SharedArchiveFile/SpaceUtilizationCheck.java Normal file
View File

@ -0,0 +1,96 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test SpaceUtilizationCheck
* @summary Check if the space utilization for shared spaces is adequate
* @library /testlibrary
* @run main SpaceUtilizationCheck
*/
import com.oracle.java.testlibrary.*;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.ArrayList;
import java.lang.Integer;
public class SpaceUtilizationCheck {
// Minimum allowed utilization value (percent)
// The goal is to have this number to be 50% for RO and RW regions
// Once that feature is implemented, increase the MIN_UTILIZATION to 50
private static final int MIN_UTILIZATION = 30;
// Only RO and RW regions are considered for this check, since they
// currently account for the bulk of the shared space
private static final int NUMBER_OF_CHECKED_SHARED_REGIONS = 2;
public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
"-XX:+UnlockDiagnosticVMOptions",
"-XX:SharedArchiveFile=./test.jsa",
"-Xshare:dump");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
String stdout = output.getStdout();
ArrayList<String> utilization = findUtilization(stdout);
if (utilization.size() != NUMBER_OF_CHECKED_SHARED_REGIONS )
throw new RuntimeException("The output format of sharing summary has changed");
for(String str : utilization) {
int value = Integer.parseInt(str);
if (value < MIN_UTILIZATION) {
System.out.println(stdout);
throw new RuntimeException("Utilization for one of the regions" +
"is below a threshold of " + MIN_UTILIZATION + "%");
}
}
}
public static ArrayList<String> findUtilization(String input) {
ArrayList<String> regions = filterRegionsOfInterest(input.split("\n"));
return filterByPattern(filterByPattern(regions, "bytes \\[.*% used\\]"), "\\d+");
}
private static ArrayList<String> filterByPattern(Iterable<String> input, String pattern) {
ArrayList<String> result = new ArrayList<String>();
for (String str : input) {
Matcher matcher = Pattern.compile(pattern).matcher(str);
if (matcher.find()) {
result.add(matcher.group());
}
}
return result;
}
private static ArrayList<String> filterRegionsOfInterest(String[] inputLines) {
ArrayList<String> result = new ArrayList<String>();
for (String str : inputLines) {
if (str.contains("ro space:") || str.contains("rw space:")) {
result.add(str);
}
}
return result;
}
}

405
hotspot/test/runtime/Thread/TestThreadDumpMonitorContention.java Normal file
View File

@ -0,0 +1,405 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8036823
* @summary Creates two threads contending for the same lock and checks
* whether jstack reports "locked" by more than one thread.
*
* @library /testlibrary
* @run main/othervm TestThreadDumpMonitorContention
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.oracle.java.testlibrary.*;
public class TestThreadDumpMonitorContention {
// jstack tends to be closely bound to the VM that we are running
// so use getTestJDKTool() instead of getCompileJDKTool() or even
// getJDKTool() which can fall back to "compile.jdk".
final static String JSTACK = JDKToolFinder.getTestJDKTool("jstack");
final static String PID = getPid();
// looking for header lines with these patterns:
// "ContendingThread-1" #19 prio=5 os_prio=64 tid=0x000000000079c000 nid=0x23 runnable [0xffff80ffb8b87000]
// "ContendingThread-2" #21 prio=5 os_prio=64 tid=0x0000000000780000 nid=0x2f waiting for monitor entry [0xfffffd7fc1111000]
final static Pattern HEADER_PREFIX_PATTERN = Pattern.compile(
"^\"ContendingThread-.*");
final static Pattern HEADER_WAITING_PATTERN = Pattern.compile(
"^\"ContendingThread-.* waiting for monitor entry .*");
final static Pattern HEADER_RUNNABLE_PATTERN = Pattern.compile(
"^\"ContendingThread-.* runnable .*");
// looking for thread state lines with these patterns:
// java.lang.Thread.State: RUNNABLE
// java.lang.Thread.State: BLOCKED (on object monitor)
final static Pattern THREAD_STATE_PREFIX_PATTERN = Pattern.compile(
" *java\\.lang\\.Thread\\.State: .*");
final static Pattern THREAD_STATE_BLOCKED_PATTERN = Pattern.compile(
" *java\\.lang\\.Thread\\.State: BLOCKED \\(on object monitor\\)");
final static Pattern THREAD_STATE_RUNNABLE_PATTERN = Pattern.compile(
" *java\\.lang\\.Thread\\.State: RUNNABLE");
// looking for duplicates of this pattern:
// - locked <0x000000076ac59e20> (a TestThreadDumpMonitorContention$1)
final static Pattern LOCK_PATTERN = Pattern.compile(
".* locked \\<.*\\(a TestThreadDumpMonitorContention.*");
// sanity checking header and thread state lines associated
// with this pattern:
// - waiting to lock <0x000000076ac59e20> (a TestThreadDumpMonitorContention$1)
final static Pattern WAITING_PATTERN = Pattern.compile(
".* waiting to lock \\<.*\\(a TestThreadDumpMonitorContention.*");
volatile static boolean done = false;
static int error_cnt = 0;
static String header_line = null;
static boolean have_header_line = false;
static boolean have_thread_state_line = false;
static int match_cnt = 0;
static String[] match_list = new String[2];
static int n_samples = 15;
static String thread_state_line = null;
static boolean verbose = false;
public static void main(String[] args) throws Exception {
if (args.length != 0) {
int arg_i = 0;
if (args[arg_i].equals("-v")) {
verbose = true;
arg_i++;
}
try {
n_samples = Integer.parseInt(args[arg_i]);
} catch (NumberFormatException nfe) {
System.err.println(nfe);
usage();
}
}
Runnable runnable = new Runnable() {
public void run() {
while (!done) {
synchronized (this) { }
}
}
};
Thread[] thread_list = new Thread[2];
thread_list[0] = new Thread(runnable, "ContendingThread-1");
thread_list[1] = new Thread(runnable, "ContendingThread-2");
thread_list[0].start();
thread_list[1].start();
doSamples();
done = true;
thread_list[0].join();
thread_list[1].join();
if (error_cnt == 0) {
System.out.println("Test PASSED.");
} else {
System.out.println("Test FAILED.");
throw new AssertionError("error_cnt=" + error_cnt);
}
}
// Reached a blank line which is the end of the
// stack trace without matching either LOCK_PATTERN
// or WAITING_PATTERN. Rare, but it's not an error.
//
// Example:
// "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f runnable [0xfffffd7fc1111000]
// java.lang.Thread.State: RUNNABLE
// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:67)
// at java.lang.Thread.run(Thread.java:745)
//
static boolean checkBlankLine(String line) {
if (line.length() == 0) {
have_header_line = false;
have_thread_state_line = false;
return true;
}
return false;
}
// Process the locked line here if we found one.
//
// Example 1:
// "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f runnable [0xfffffd7fc1111000]
// java.lang.Thread.State: RUNNABLE
// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:67)
// - locked <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
// at java.lang.Thread.run(Thread.java:745)
//
// Example 2:
// "ContendingThread-1" #21 prio=5 os_prio=64 tid=0x00000000007b9000 nid=0x2f waiting for monitor entry [0xfffffd7fc1111000]
// java.lang.Thread.State: BLOCKED (on object monitor)
// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:67)
// - locked <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
// at java.lang.Thread.run(Thread.java:745)
//
static boolean checkLockedLine(String line) {
Matcher matcher = LOCK_PATTERN.matcher(line);
if (matcher.matches()) {
if (verbose) {
System.out.println("locked_line='" + line + "'");
}
match_list[match_cnt] = new String(line);
match_cnt++;
matcher = HEADER_RUNNABLE_PATTERN.matcher(header_line);
if (!matcher.matches()) {
// It's strange, but a locked line can also
// match the HEADER_WAITING_PATTERN.
matcher = HEADER_WAITING_PATTERN.matcher(header_line);
if (!matcher.matches()) {
System.err.println();
System.err.println("ERROR: header line does " +
"not match runnable or waiting patterns.");
System.err.println("ERROR: header_line='" +
header_line + "'");
System.err.println("ERROR: locked_line='" + line + "'");
error_cnt++;
}
}
matcher = THREAD_STATE_RUNNABLE_PATTERN.matcher(thread_state_line);
if (!matcher.matches()) {
// It's strange, but a locked line can also
// match the THREAD_STATE_BLOCKED_PATTERN.
matcher = THREAD_STATE_BLOCKED_PATTERN.matcher(
thread_state_line);
if (!matcher.matches()) {
System.err.println();
System.err.println("ERROR: thread state line does not " +
"match runnable or waiting patterns.");
System.err.println("ERROR: " + "thread_state_line='" +
thread_state_line + "'");
System.err.println("ERROR: locked_line='" + line + "'");
error_cnt++;
}
}
// Have everything we need from this thread stack
// that matches the LOCK_PATTERN.
have_header_line = false;
have_thread_state_line = false;
return true;
}
return false;
}
// Process the waiting line here if we found one.
//
// Example:
// "ContendingThread-2" #22 prio=5 os_prio=64 tid=0x00000000007b9800 nid=0x30 waiting for monitor entry [0xfffffd7fc1010000]
// java.lang.Thread.State: BLOCKED (on object monitor)
// at TestThreadDumpMonitorContention$1.run(TestThreadDumpMonitorContention.java:67)
// - waiting to lock <0xfffffd7e6a2912f8> (a TestThreadDumpMonitorContention$1)
// at java.lang.Thread.run(Thread.java:745)
//
static boolean checkWaitingLine(String line) {
Matcher matcher = WAITING_PATTERN.matcher(line);
if (matcher.matches()) {
if (verbose) {
System.out.println("waiting_line='" + line + "'");
}
matcher = HEADER_WAITING_PATTERN.matcher(header_line);
if (!matcher.matches()) {
System.err.println();
System.err.println("ERROR: header line does " +
"not match a waiting pattern.");
System.err.println("ERROR: header_line='" + header_line + "'");
System.err.println("ERROR: waiting_line='" + line + "'");
error_cnt++;
}
matcher = THREAD_STATE_BLOCKED_PATTERN.matcher(thread_state_line);
if (!matcher.matches()) {
System.err.println();
System.err.println("ERROR: thread state line " +
"does not match a waiting pattern.");
System.err.println("ERROR: thread_state_line='" +
thread_state_line + "'");
System.err.println("ERROR: waiting_line='" + line + "'");
error_cnt++;
}
// Have everything we need from this thread stack
// that matches the WAITING_PATTERN.
have_header_line = false;
have_thread_state_line = false;
return true;
}
return false;
}
static void doSamples() throws Exception {
for (int count = 0; count < n_samples; count++) {
match_cnt = 0;
// verbose mode or an error has a lot of output so add more space
if (verbose || error_cnt > 0) System.out.println();
System.out.println("Sample #" + count);
// We don't use the ProcessTools, OutputBuffer or
// OutputAnalyzer classes from the testlibrary because
// we have a complicated multi-line parse to perform
// on a narrow subset of the JSTACK output.
//
// - we only care about stack traces that match
// HEADER_PREFIX_PATTERN; only two should match
// - we care about at most three lines from each stack trace
// - if both stack traces match LOCKED_PATTERN, then that's
// a failure and we report it
// - for a stack trace that matches LOCKED_PATTERN, we verify:
// - the header line matches HEADER_RUNNABLE_PATTERN
// or HEADER_WAITING_PATTERN
// - the thread state line matches THREAD_STATE_BLOCKED_PATTERN
// or THREAD_STATE_RUNNABLE_PATTERN
// - we report any mismatches as failures
// - for a stack trace that matches WAITING_PATTERN, we verify:
// - the header line matches HEADER_WAITING_PATTERN
// - the thread state line matches THREAD_STATE_BLOCKED_PATTERN
// - we report any mismatches as failures
// - the stack traces that match HEADER_PREFIX_PATTERN may
// not match either LOCKED_PATTERN or WAITING_PATTERN
// because we might observe the thread outside of
// monitor operations; this is not considered a failure
//
// When we do observe LOCKED_PATTERN or WAITING_PATTERN,
// then we are checking the header and thread state patterns
// that occurred earlier in the current stack trace that
// matched HEADER_PREFIX_PATTERN. We don't use data from
// stack traces that don't match HEADER_PREFIX_PATTERN and
// we don't mix data between the two stack traces that do
// match HEADER_PREFIX_PATTERN.
//
Process process = new ProcessBuilder(JSTACK, PID)
.redirectErrorStream(true).start();
BufferedReader reader = new BufferedReader(new InputStreamReader(
process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
Matcher matcher = null;
// process the header line here
if (!have_header_line) {
matcher = HEADER_PREFIX_PATTERN.matcher(line);
if (matcher.matches()) {
if (verbose) {
System.out.println();
System.out.println("header='" + line + "'");
}
header_line = new String(line);
have_header_line = true;
continue;
}
continue; // skip until have a header line
}
// process the thread state line here
if (!have_thread_state_line) {
matcher = THREAD_STATE_PREFIX_PATTERN.matcher(line);
if (matcher.matches()) {
if (verbose) {
System.out.println("thread_state='" + line + "'");
}
thread_state_line = new String(line);
have_thread_state_line = true;
continue;
}
continue; // skip until we have a thread state line
}
// process the locked line here if we find one
if (checkLockedLine(line)) {
continue;
}
// process the waiting line here if we find one
if (checkWaitingLine(line)) {
continue;
}
// process the blank line here if we find one
if (checkBlankLine(line)) {
continue;
}
}
process.waitFor();
if (match_cnt == 2) {
if (match_list[0].equals(match_list[1])) {
System.err.println();
System.err.println("ERROR: matching lock lines:");
System.err.println("ERROR: line[0]'" + match_list[0] + "'");
System.err.println("ERROR: line[1]'" + match_list[1] + "'");
error_cnt++;
}
}
// slight delay between jstack launches
Thread.sleep(500);
}
}
// This helper relies on RuntimeMXBean.getName() returning a string
// that looks like this: 5436@mt-haku
//
// The testlibrary has tryFindJvmPid(), but that uses a separate
// process which is much more expensive for finding out your own PID.
//
static String getPid() {
RuntimeMXBean runtimebean = ManagementFactory.getRuntimeMXBean();
String vmname = runtimebean.getName();
int i = vmname.indexOf('@');
if (i != -1) {
vmname = vmname.substring(0, i);
}
return vmname;
}
static void usage() {
System.err.println("Usage: " +
"java TestThreadDumpMonitorContention [-v] [n_samples]");
System.exit(1);
}
}

4
hotspot/test/serviceability/ParserTest.java
View File

@ -22,10 +22,10 @@
*/
/*
* @test ParserTest
* @test
* @summary Test that the diagnostic command arguemnt parser works
* @library /testlibrary /testlibrary/whitebox
* @build ParserTest
* @build ClassFileInstaller sun.hotspot.WhiteBox sun.hotspot.parser.*
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ParserTest
*/

2
hotspot/test/serviceability/attach/AttachWithStalePidFile.java
View File

@ -27,7 +27,7 @@
* @key regression
* @summary Regression test for attach issue where stale pid files in /tmp lead to connection issues
* @library /testlibrary
* @compile AttachWithStalePidFileTarget.java
* @build com.oracle.java.testlibrary.* AttachWithStalePidFileTarget
* @run main AttachWithStalePidFile
*/

2
hotspot/test/serviceability/dcmd/DynLibDcmdTest.java
View File

@ -29,7 +29,7 @@ import com.oracle.java.testlibrary.Platform;
* @test
* @summary Test of VM.dynlib diagnostic command via MBean
* @library /testlibrary
* @compile DcmdUtil.java
* @build com.oracle.java.testlibrary.* DcmdUtil
* @run main DynLibDcmdTest
*/

2
hotspot/test/serviceability/jvmti/GetObjectSizeOverflow.java
View File

@ -29,7 +29,7 @@ import com.oracle.java.testlibrary.*;
* @test
* @bug 8027230
* @library /testlibrary
* @build GetObjectSizeOverflowAgent
* @build ClassFileInstaller com.oracle.java.testlibrary.* GetObjectSizeOverflowAgent
* @run main ClassFileInstaller GetObjectSizeOverflowAgent
* @run main GetObjectSizeOverflow
*/

2
hotspot/test/serviceability/jvmti/TestRedefineWithUnresolvedClass.java
View File

@ -26,7 +26,7 @@
* @summary Redefine a class with an UnresolvedClass reference in the constant pool.
* @bug 8035150
* @library /testlibrary
* @build UnresolvedClassAgent com.oracle.java.testlibrary.ProcessTools com.oracle.java.testlibrary.OutputAnalyzer
* @build com.oracle.java.testlibrary.* UnresolvedClassAgent
* @run main TestRedefineWithUnresolvedClass
*/

1
hotspot/test/serviceability/sa/jmap-hashcode/Test8028623.java
View File

@ -26,6 +26,7 @@
* @bug 8028623
* @summary Test hashing of extended characters in Serviceability Agent.
* @library /testlibrary
* @build com.oracle.java.testlibrary.*
* @compile -encoding utf8 Test8028623.java
* @run main Test8028623
*/

2
hotspot/test/serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java
View File

@ -44,7 +44,7 @@ import com.oracle.java.testlibrary.ProcessTools;
* @key regression
* @summary Regression test for hprof export issue due to large heaps (>2G)
* @library /testlibrary
* @compile JMapHProfLargeHeapProc.java
* @build com.oracle.java.testlibrary.* JMapHProfLargeHeapProc
* @run main JMapHProfLargeHeapTest
*/

79
hotspot/test/testlibrary/RedefineClassHelper.java Normal file
View File

@ -0,0 +1,79 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.io.PrintWriter;
import java.lang.instrument.*;
import com.oracle.java.testlibrary.*;
/*
* Helper class to write tests that redefine classes.
* When main method is run, it will create a redefineagent.jar that can be used
* with the -javaagent option to support redefining classes in jtreg tests.
*
* See sample test in test/testlibrary_tests/RedefineClassTest.java
*/
public class RedefineClassHelper {
public static Instrumentation instrumentation;
public static void premain(String agentArgs, Instrumentation inst) {
instrumentation = inst;
}
/**
* Redefine a class
*
* @param clazz Class to redefine
* @param javacode String with the new java code for the class to be redefined
*/
public static void redefineClass(Class clazz, String javacode) throws Exception {
byte[] bytecode = InMemoryJavaCompiler.compile(clazz.getName(), javacode);
redefineClass(clazz, bytecode);
}
/**
* Redefine a class
*
* @param clazz Class to redefine
* @param bytecode byte[] with the new class
*/
public static void redefineClass(Class clazz, byte[] bytecode) throws Exception {
instrumentation.redefineClasses(new ClassDefinition(clazz, bytecode));
}
/**
* Main method to be invoked before test to create the redefineagent.jar
*/
public static void main(String[] args) throws Exception {
ClassFileInstaller.main("RedefineClassHelper");
PrintWriter pw = new PrintWriter("MANIFEST.MF");
pw.println("Premain-Class: RedefineClassHelper");
pw.println("Can-Redefine-Classes: true");
pw.close();
sun.tools.jar.Main jarTool = new sun.tools.jar.Main(System.out, System.err, "jar");
if (!jarTool.run(new String[] { "-cmf", "MANIFEST.MF", "redefineagent.jar", "RedefineClassHelper.class" })) {
throw new Exception("jar operation failed");
}
}
}

4
hotspot/test/testlibrary/ctw/test/ClassesDirTest.java
View File

@ -22,10 +22,10 @@
*/
/*
* @test ClassesDirTest
* @test
* @bug 8012447
* @library /testlibrary /testlibrary/whitebox /testlibrary/ctw/src
* @build sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox ClassesDirTest Foo Bar
* @build ClassFileInstaller sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox Foo Bar
* @run main ClassFileInstaller sun.hotspot.WhiteBox Foo Bar
* @run main ClassesDirTest prepare
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Dsun.hotspot.tools.ctw.logfile=ctw.log sun.hotspot.tools.ctw.CompileTheWorld classes

4
hotspot/test/testlibrary/ctw/test/ClassesListTest.java
View File

@ -22,10 +22,10 @@
*/
/*
* @test ClassesListTest
* @test
* @bug 8012447
* @library /testlibrary /testlibrary/whitebox /testlibrary/ctw/src
* @build sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox ClassesListTest Foo Bar
* @build ClassFileInstaller sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox Foo Bar
* @run main ClassFileInstaller sun.hotspot.WhiteBox Foo Bar
* @run main ClassesListTest prepare
* @run main/othervm/timeout=600 -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Dsun.hotspot.tools.ctw.logfile=ctw.log sun.hotspot.tools.ctw.CompileTheWorld classes.lst

4
hotspot/test/testlibrary/ctw/test/JarDirTest.java
View File

@ -22,10 +22,10 @@
*/
/*
* @test JarDirTest
* @test
* @bug 8012447
* @library /testlibrary /testlibrary/whitebox /testlibrary/ctw/src
* @build sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox JarDirTest Foo Bar
* @build ClassFileInstaller com.oracle.java.testlibrary.* sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox Foo Bar
* @run main ClassFileInstaller sun.hotspot.WhiteBox Foo Bar
* @run main JarDirTest prepare
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Dsun.hotspot.tools.ctw.logfile=ctw.log sun.hotspot.tools.ctw.CompileTheWorld jars/*

4
hotspot/test/testlibrary/ctw/test/JarsTest.java
View File

@ -22,10 +22,10 @@
*/
/*
* @test JarsTest
* @test
* @bug 8012447
* @library /testlibrary /testlibrary/whitebox /testlibrary/ctw/src
* @build sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox JarsTest Foo Bar
* @build ClassFileInstaller com.oracle.java.testlibrary.* sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox Foo Bar
* @run main ClassFileInstaller sun.hotspot.WhiteBox Foo Bar
* @run main JarsTest prepare
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Dsun.hotspot.tools.ctw.logfile=ctw.log sun.hotspot.tools.ctw.CompileTheWorld foo.jar bar.jar

54
hotspot/test/testlibrary_tests/RedefineClassTest.java Normal file
View File

@ -0,0 +1,54 @@
/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @library /testlibrary
* @summary Proof of concept test for RedefineClassHelper
* @build RedefineClassHelper
* @run main RedefineClassHelper
* @run main/othervm -javaagent:redefineagent.jar RedefineClassTest
*/
import static com.oracle.java.testlibrary.Asserts.*;
import com.oracle.java.testlibrary.*;
/*
* Proof of concept test for the test utility class RedefineClassHelper
*/
public class RedefineClassTest {
public static String newClass = "class RedefineClassTest$A { public int Method() { return 2; } }";
public static void main(String[] args) throws Exception {
A a = new A();
assertTrue(a.Method() == 1);
RedefineClassHelper.redefineClass(A.class, newClass);
assertTrue(a.Method() == 2);
}
static class A {
public int Method() {
return 1;
}
}
}

2
jaxp/.hgtags
View File

@ -259,3 +259,5 @@ e88cecf5a21b760ff7d7761c2db6bb8c82bc9f0c jdk9-b12
32b3fc4bc7374a34d52b7f4e2391b4b4b0c084e8 jdk9-b14
6bad71866c7598587860e0981b0b0e51ec8c0476 jdk9-b15
a1461221b05d4620e4d7d1907e2a0282aaedf31c jdk9-b16
6f923fcbe5129eceb9617a9a18dbdd743980e785 jdk9-b17
5afa90c28742d175431be75f9098745510bd2b30 jdk9-b18

22
jaxp/src/com/sun/org/apache/xalan/internal/xsltc/runtime/AbstractTranslet.java
View File

@ -3,9 +3,11 @@
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
@ -32,7 +34,6 @@ import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;
import javax.xml.transform.Templates;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
@ -51,6 +52,7 @@ import com.sun.org.apache.xalan.internal.xsltc.dom.KeyIndex;
import com.sun.org.apache.xalan.internal.xsltc.runtime.output.TransletOutputHandlerFactory;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import com.sun.org.apache.xml.internal.serializer.ToStream;
/**
* @author Jacek Ambroziak
@ -74,7 +76,7 @@ public abstract class AbstractTranslet implements Translet {
public String _doctypeSystem = null;
public boolean _indent = false;
public String _mediaType = null;
public Vector _cdata = null;
public ArrayList<String> _cdata = null;
public int _indentamount = -1;
public static final int FIRST_TRANSLET_VERSION = 100;
@ -642,7 +644,7 @@ public abstract class AbstractTranslet implements Translet {
*/
public void addCdataElement(String name) {
if (_cdata == null) {
_cdata = new Vector();
_cdata = new ArrayList<>();
}
int lastColon = name.lastIndexOf(':');
@ -650,11 +652,11 @@ public abstract class AbstractTranslet implements Translet {
if (lastColon > 0) {
String uri = name.substring(0, lastColon);
String localName = name.substring(lastColon+1);
_cdata.addElement(uri);
_cdata.addElement(localName);
_cdata.add(uri);
_cdata.add(localName);
} else {
_cdata.addElement(null);
_cdata.addElement(name);
_cdata.add(null);
_cdata.add(name);
}
}

18
jaxp/src/com/sun/org/apache/xalan/internal/xsltc/trax/TransformerImpl.java
View File

@ -3,9 +3,11 @@
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
@ -40,7 +42,7 @@ import java.net.UnknownServiceException;
import java.util.Enumeration;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.ArrayList;
import java.lang.reflect.Constructor;
import javax.xml.parsers.DocumentBuilder;
@ -1084,7 +1086,7 @@ public final class TransformerImpl extends Transformer
else if (name.equals(OutputKeys.CDATA_SECTION_ELEMENTS)) {
if (value != null) {
StringTokenizer e = new StringTokenizer(value);
Vector uriAndLocalNames = null;
ArrayList<String> uriAndLocalNames = null;
while (e.hasMoreTokens()) {
final String token = e.nextToken();
@ -1104,11 +1106,11 @@ public final class TransformerImpl extends Transformer
}
if (uriAndLocalNames == null) {
uriAndLocalNames = new Vector();
uriAndLocalNames = new ArrayList<>();
}
// add the uri/localName as a pair, in that order
uriAndLocalNames.addElement(uri);
uriAndLocalNames.addElement(localName);
uriAndLocalNames.add(uri);
uriAndLocalNames.add(localName);
}
handler.setCdataSectionElements(uriAndLocalNames);
}

2
jaxp/src/com/sun/org/apache/xerces/internal/dom/EntityReferenceImpl.java
View File

@ -347,7 +347,7 @@ implements EntityReference {
* @see DocumentTypeImpl
* @see EntityImpl
*/
// The Xerces parser invokes callbacks for startEnityReference
// The Xerces parser invokes callbacks for startEntityReference
// the parsed value of the entity EACH TIME, so it is actually
// easier to create the nodes through the callbacks rather than
// clone the Entity.

2
jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLDTDScannerImpl.java
View File

@ -585,7 +585,7 @@ implements XMLDTDScanner, XMLComponent, XMLEntityHandler {
boolean reportEntity = fReportEntity;
if (name.startsWith("%")) {
reportEntity = peekReportEntity();
// check well-formedness of the enity
// check well-formedness of the entity
int startMarkUpDepth = popPEStack();
// throw fatalError if this entity was incomplete and
// was a freestanding decl

2
jaxp/src/com/sun/org/apache/xerces/internal/impl/XMLDocumentFragmentScannerImpl.java
View File

@ -2728,7 +2728,7 @@ public class XMLDocumentFragmentScannerImpl
//if the last section was character data
if(fLastSectionWasCharacterData){
//if we dont encounter any CDATA or ENITY REFERENCE and current state is also not SCANNER_STATE_CHARACTER_DATA
//if we dont encounter any CDATA or ENTITY REFERENCE and current state is also not SCANNER_STATE_CHARACTER_DATA
//return the last scanned charactrer data.
if((fScannerState != SCANNER_STATE_CDATA) && (fScannerState != SCANNER_STATE_REFERENCE)
&& (fScannerState != SCANNER_STATE_CHARACTER_DATA)){

2
jaxp/src/com/sun/org/apache/xerces/internal/impl/dtd/XMLDTDValidator.java
View File

@ -1218,7 +1218,7 @@ public class XMLDTDValidator
// references appear in the document.
// REVISIT: this can be combined to a single check in
// startEntity if we add one more argument in
// startEnity, inAttrValue
// startEntity, inAttrValue
String nonNormalizedValue = attributes.getNonNormalizedValue(i);
if (nonNormalizedValue != null) {
String entityName = getExternalEntityRefInAttrValue(nonNormalizedValue);

8
jaxp/src/com/sun/org/apache/xerces/internal/xpointer/ElementSchemePointer.java
View File

@ -559,11 +559,13 @@ final class ElementSchemePointer implements XPointerPart {
* @param token The token string
*/
private void addToken(String tokenStr) {
if (!fTokenNames.containsValue(tokenStr)) {
Integer tokenInt = new Integer(fTokenNames.size());
String str = fTokenNames.get(tokenStr);
Integer tokenInt = str == null ? null : Integer.parseInt(str);
if (tokenInt == null) {
tokenInt = new Integer(fTokenNames.size());
fTokenNames.put(tokenInt, tokenStr);
addToken(tokenInt.intValue());
}
addToken(tokenInt.intValue());
}
/**

10
jaxp/src/com/sun/org/apache/xerces/internal/xpointer/XPointerHandler.java
View File

@ -524,11 +524,13 @@ public final class XPointerHandler extends XIncludeHandler implements
* @param token The token string
*/
private void addToken(String tokenStr) {
if (!fTokenNames.containsValue(tokenStr)) {
Integer tokenInt = new Integer(fTokenNames.size());
String str = fTokenNames.get(tokenStr);
Integer tokenInt = str == null ? null : Integer.parseInt(str);
if (tokenInt == null) {
tokenInt = new Integer(fTokenNames.size());
fTokenNames.put(tokenInt, tokenStr);
addToken(tokenInt.intValue());
}
addToken(tokenInt.intValue());
}
/**
@ -1251,4 +1253,4 @@ public final class XPointerHandler extends XIncludeHandler implements
super.setProperty(propertyId, value);
}
}
}

2
jaxp/src/com/sun/org/apache/xml/internal/dtm/DTMConfigurationException.java
View File

@ -32,7 +32,7 @@ public class DTMConfigurationException extends DTMException {
/**
* Create a new <code>DTMConfigurationException</code> with no
* detail mesage.
* detail message.
*/
public DTMConfigurationException() {
super("Configuration Error");

35
jaxp/src/com/sun/org/apache/xml/internal/serializer/EmptySerializer.java
View File

@ -3,9 +3,11 @@
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2003-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
@ -27,7 +29,7 @@ import java.io.OutputStream;
import java.io.Writer;
import java.util.Hashtable;
import java.util.Properties;
import java.util.Vector;
import java.util.ArrayList;
import javax.xml.transform.SourceLocator;
import javax.xml.transform.Transformer;
@ -150,9 +152,9 @@ public class EmptySerializer implements SerializationHandler
couldThrowIOException();
}
/**
* @see SerializationHandler#setCdataSectionElements(java.util.Vector)
* @see SerializationHandler#setCdataSectionElements(java.util.ArrayList<String>)
*/
public void setCdataSectionElements(Vector URI_and_localNames)
public void setCdataSectionElements(ArrayList<String> URI_and_localNames)
{
aMethodIsCalled();
}
@ -763,4 +765,25 @@ public class EmptySerializer implements SerializationHandler
aMethodIsCalled();
}
public String getOutputProperty(String name) {
aMethodIsCalled();
return null;
}
public String getOutputPropertyDefault(String name) {
aMethodIsCalled();
return null;
}
public void setOutputProperty(String name, String val) {
aMethodIsCalled();
}
public void setOutputPropertyDefault(String name, String val) {
aMethodIsCalled();
}
}

452
jaxp/src/com/sun/org/apache/xml/internal/serializer/SerializerBase.java
View File

@ -3,9 +3,11 @@
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
@ -23,8 +25,11 @@
package com.sun.org.apache.xml.internal.serializer;
import java.io.IOException;
import java.util.Vector;
import java.util.HashMap;
import java.util.Set;
import java.util.ArrayList;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.SourceLocator;
import javax.xml.transform.Transformer;
@ -108,12 +113,12 @@ public abstract class SerializerBase
/**
* The System ID for the doc type.
*/
private String m_doctypeSystem;
protected String m_doctypeSystem;
/**
* The public ID for the doc type.
*/
private String m_doctypePublic;
protected String m_doctypePublic;
/**
* Flag to tell that we need to add the doctype decl, which we can't do
@ -121,16 +126,10 @@ public abstract class SerializerBase
*/
boolean m_needToOutputDocTypeDecl = true;
/**
* The character encoding. Must match the encoding used for the
* printWriter.
*/
private String m_encoding = null;
/**
* Tells if we should write the XML declaration.
*/
private boolean m_shouldNotWriteXMLHeader = false;
protected boolean m_shouldNotWriteXMLHeader = false;
/**
* The standalone value for the doctype.
@ -159,12 +158,12 @@ public abstract class SerializerBase
/**
* Tells the XML version, for writing out to the XML decl.
*/
private String m_version = null;
protected String m_version = null;
/**
* The mediatype. Not used right now.
*/
private String m_mediatype;
protected String m_mediatype;
/**
* The transformer that was around when this output handler was created (if
@ -172,13 +171,6 @@ public abstract class SerializerBase
*/
private Transformer m_transformer;
/**
* Pairs of local names and corresponding URIs of CDATA sections. This list
* comes from the cdata-section-elements attribute. Every second one is a
* local name, and every other second one is the URI for the local name.
*/
protected Vector m_cdataSectionElements = null;
/**
* Namespace support, that keeps track of currently defined
* prefix/uri mappings. As processed elements come and go, so do
@ -538,16 +530,16 @@ public abstract class SerializerBase
*/
public String getEncoding()
{
return m_encoding;
return getOutputProperty(OutputKeys.ENCODING);
}
/**
* Sets the character encoding coming from the xsl:output encoding stylesheet attribute.
* @param m_encoding the character encoding
*/
public void setEncoding(String m_encoding)
public void setEncoding(String encoding)
{
this.m_encoding = m_encoding;
setOutputProperty(OutputKeys.ENCODING,encoding);
}
/**
@ -557,7 +549,8 @@ public abstract class SerializerBase
*/
public void setOmitXMLDeclaration(boolean b)
{
this.m_shouldNotWriteXMLHeader = b;
String val = b ? "yes":"no";
setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,val);
}
@ -588,7 +581,7 @@ public abstract class SerializerBase
*/
public void setDoctypePublic(String doctypePublic)
{
this.m_doctypePublic = doctypePublic;
setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, doctypePublic);
}
@ -610,7 +603,7 @@ public abstract class SerializerBase
*/
public void setDoctypeSystem(String doctypeSystem)
{
this.m_doctypeSystem = doctypeSystem;
setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, doctypeSystem);
}
/** Set the value coming from the xsl:output doctype-public and doctype-system stylesheet properties
@ -621,8 +614,8 @@ public abstract class SerializerBase
*/
public void setDoctype(String doctypeSystem, String doctypePublic)
{
this.m_doctypeSystem = doctypeSystem;
this.m_doctypePublic = doctypePublic;
setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, doctypeSystem);
setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, doctypePublic);
}
/**
@ -634,12 +627,9 @@ public abstract class SerializerBase
*/
public void setStandalone(String standalone)
{
if (standalone != null)
{
m_standaloneWasSpecified = true;
setStandaloneInternal(standalone);
}
setOutputProperty(OutputKeys.STANDALONE, standalone);
}
/**
* Sets the XSL standalone attribute, but does not remember if this is a
* default or explicite setting.
@ -700,7 +690,7 @@ public abstract class SerializerBase
*/
public void setVersion(String version)
{
m_version = version;
setOutputProperty(OutputKeys.VERSION, version);
}
/**
@ -712,7 +702,7 @@ public abstract class SerializerBase
*/
public void setMediaType(String mediaType)
{
m_mediatype = mediaType;
setOutputProperty(OutputKeys.MEDIA_TYPE,mediaType);
}
/**
@ -741,7 +731,8 @@ public abstract class SerializerBase
*/
public void setIndent(boolean doIndent)
{
m_doIndent = doIndent;
String val = doIndent ? "yes":"no";
setOutputProperty(OutputKeys.INDENT,val);
}
/**
@ -786,59 +777,6 @@ public abstract class SerializerBase
return this;
}
/**
* Push a boolean state based on if the name of the current element
* is found in the list of qnames. A state is only pushed if
* there were some cdata-section-names were specified.
* <p>
* Hidden parameters are the vector of qualified elements specified in
* cdata-section-names attribute, and the m_cdataSectionStates stack
* onto which whether the current element is in the list is pushed (true or
* false). Other hidden parameters are the current elements namespaceURI,
* localName and qName
*/
protected boolean isCdataSection()
{
boolean b = false;
if (null != m_cdataSectionElements)
{
if (m_elemContext.m_elementLocalName == null)
m_elemContext.m_elementLocalName =
getLocalName(m_elemContext.m_elementName);
if (m_elemContext.m_elementURI == null)
{
String prefix = getPrefixPart(m_elemContext.m_elementName);
if (prefix != null)
m_elemContext.m_elementURI =
m_prefixMap.lookupNamespace(prefix);
}
if ((null != m_elemContext.m_elementURI)
&& m_elemContext.m_elementURI.length() == 0)
m_elemContext.m_elementURI = null;
int nElems = m_cdataSectionElements.size();
// loop through 2 at a time, as these are pairs of URI and localName
for (int i = 0; i < nElems; i += 2)
{
String uri = (String) m_cdataSectionElements.elementAt(i);
String loc = (String) m_cdataSectionElements.elementAt(i + 1);
if (loc.equals(m_elemContext.m_elementLocalName)
&& subPartMatch(m_elemContext.m_elementURI, uri))
{
b = true;
break;
}
}
}
return b;
}
/**
* Tell if two strings are equal, without worry if the first string is null.
*
@ -1312,12 +1250,11 @@ public abstract class SerializerBase
private void resetSerializerBase()
{
this.m_attributes.clear();
this.m_cdataSectionElements = null;
this.m_StringOfCDATASections = null;
this.m_elemContext = new ElemContext();
this.m_doctypePublic = null;
this.m_doctypeSystem = null;
this.m_doIndent = false;
this.m_encoding = null;
this.m_indentAmount = 0;
this.m_inEntityRef = false;
this.m_inExternalDTD = false;
@ -1399,4 +1336,333 @@ public abstract class SerializerBase
// A particular sub-class of SerializerBase provides the implementation (if desired)
}
/**
* The CDATA section names stored in a whitespace separateed list with
* each element being a word of the form "{uri}localName" This list
* comes from the cdata-section-elements attribute.
*
* This field replaces m_cdataSectionElements Vector.
*/
protected String m_StringOfCDATASections = null;
boolean m_docIsEmpty = true;
void initCdataElems(String s)
{
if (s != null)
{
int max = s.length();
// true if we are in the middle of a pair of curly braces that delimit a URI
boolean inCurly = false;
// true if we found a URI but haven't yet processed the local name
boolean foundURI = false;
StringBuilder buf = new StringBuilder();
String uri = null;
String localName = null;
// parse through string, breaking on whitespaces. I do this instead
// of a tokenizer so I can track whitespace inside of curly brackets,
// which theoretically shouldn't happen if they contain legal URLs.
for (int i = 0; i < max; i++)
{
char c = s.charAt(i);
if (Character.isWhitespace(c))
{
if (!inCurly)
{
if (buf.length() > 0)
{
localName = buf.toString();
if (!foundURI)
uri = "";
addCDATAElement(uri,localName);
buf.setLength(0);
foundURI = false;
}
continue;
}
else
buf.append(c); // add whitespace to the URI
}
else if ('{' == c) // starting a URI
inCurly = true;
else if ('}' == c)
{
// we just ended a URI
foundURI = true;
uri = buf.toString();
buf.setLength(0);
inCurly = false;
}
else
{
// append non-whitespace, non-curly to current URI or localName being gathered.
buf.append(c);
}
}
if (buf.length() > 0)
{
// We have one last localName to process.
localName = buf.toString();
if (!foundURI)
uri = "";
addCDATAElement(uri,localName);
}
}
}
protected java.util.HashMap<String, HashMap<String, String>> m_CdataElems = null;
private void addCDATAElement(String uri, String localName)
{
if (m_CdataElems == null) {
m_CdataElems = new java.util.HashMap<>();
}
HashMap<String,String> h = m_CdataElems.get(localName);
if (h == null) {
h = new HashMap<>();
m_CdataElems.put(localName,h);
}
h.put(uri,uri);
}
/**
* Return true if nothing has been sent to this result tree yet.
* <p>
* This is not a public API.
*
* @xsl.usage internal
*/
public boolean documentIsEmpty() {
// If we haven't called startDocument() yet, then this document is empty
return m_docIsEmpty && (m_elemContext.m_currentElemDepth == 0);
}
/**
* Return true if the current element in m_elemContext
* is a CDATA section.
* CDATA sections are specified in the <xsl:output> attribute
* cdata-section-names or in the JAXP equivalent property.
* In any case the format of the value of such a property is:
* <pre>
* "{uri1}localName1 {uri2}localName2 . . . "
* </pre>
*
* <p>
* This method is not a public API, but is only used internally by the serializer.
*/
protected boolean isCdataSection() {
boolean b = false;
if (null != m_StringOfCDATASections) {
if (m_elemContext.m_elementLocalName == null) {
String localName = getLocalName(m_elemContext.m_elementName);
m_elemContext.m_elementLocalName = localName;
}
if ( m_elemContext.m_elementURI == null) {
m_elemContext.m_elementURI = getElementURI();
}
else if ( m_elemContext.m_elementURI.length() == 0) {
if ( m_elemContext.m_elementName == null) {
m_elemContext.m_elementName = m_elemContext.m_elementLocalName;
// leave URI as "", meaning in no namespace
}
else if (m_elemContext.m_elementLocalName.length() < m_elemContext.m_elementName.length()){
// We were told the URI was "", yet the name has a prefix since the name is longer than the localname.
// So we will fix that incorrect information here.
m_elemContext.m_elementURI = getElementURI();
}
}
HashMap<String, String> h = null;
if (m_CdataElems != null) {
h = m_CdataElems.get(m_elemContext.m_elementLocalName);
}
if (h != null) {
Object obj = h.get(m_elemContext.m_elementURI);
if (obj != null)
b = true;
}
}
return b;
}
/**
* Before this call m_elementContext.m_elementURI is null,
* which means it is not yet known. After this call it
* is non-null, but possibly "" meaning that it is in the
* default namespace.
*
* @return The URI of the element, never null, but possibly "".
*/
private String getElementURI() {
String uri = null;
// At this point in processing we have received all the
// namespace mappings
// As we still don't know the elements namespace,
// we now figure it out.
String prefix = getPrefixPart(m_elemContext.m_elementName);
if (prefix == null) {
// no prefix so lookup the URI of the default namespace
uri = m_prefixMap.lookupNamespace("");
} else {
uri = m_prefixMap.lookupNamespace(prefix);
}
if (uri == null) {
// We didn't find the namespace for the
// prefix ... ouch, that shouldn't happen.
// This is a hack, we really don't know
// the namespace
uri = EMPTYSTRING;
}
return uri;
}
/**
* Get the value of an output property,
* the explicit value, if any, otherwise the
* default value, if any, otherwise null.
*/
public String getOutputProperty(String name) {
String val = getOutputPropertyNonDefault(name);
// If no explicit value, try to get the default value
if (val == null)
val = getOutputPropertyDefault(name);
return val;
}
/**
* Get the value of an output property,
* not the default value. If there is a default
* value, but no non-default value this method
* will return null.
* <p>
*
*/
public String getOutputPropertyNonDefault(String name) {
return getProp(name,false);
}
/**
* Get the default value of an xsl:output property,
* which would be null only if no default value exists
* for the property.
*/
public String getOutputPropertyDefault(String name) {
return getProp(name, true);
}
/**
* Set the value for the output property, typically from
* an xsl:output element, but this does not change what
* the default value is.
*/
public void setOutputProperty(String name, String val) {
setProp(name,val,false);
}
/**
* Set the default value for an output property, but this does
* not impact any explicitly set value.
*/
public void setOutputPropertyDefault(String name, String val) {
setProp(name,val,true);
}
/**
* A mapping of keys to explicitly set values, for example if
* and <xsl:output/> has an "encoding" attribute, this
* map will have what that attribute maps to.
*/
private HashMap<String, String> m_OutputProps;
/**
* A mapping of keys to default values, for example if
* the default value of the encoding is "UTF-8" then this
* map will have that "encoding" maps to "UTF-8".
*/
private HashMap<String, String> m_OutputPropsDefault;
Set<String> getOutputPropDefaultKeys() {
return m_OutputPropsDefault.keySet();
}
Set<String> getOutputPropKeys() {
return m_OutputProps.keySet();
}
private String getProp(String name, boolean defaultVal) {
if (m_OutputProps == null) {
m_OutputProps = new HashMap<>();
m_OutputPropsDefault = new HashMap<>();
}
String val;
if (defaultVal)
val = m_OutputPropsDefault.get(name);
else
val = m_OutputProps.get(name);
return val;
}
/**
*
* @param name The name of the property, e.g. "{http://myprop}indent-tabs" or "indent".
* @param val The value of the property, e.g. "4"
* @param defaultVal true if this is a default value being set for the property as
* opposed to a user define on, set say explicitly in the stylesheet or via JAXP
*/
void setProp(String name, String val, boolean defaultVal) {
if (m_OutputProps == null) {
m_OutputProps = new HashMap<>();
m_OutputPropsDefault = new HashMap<>();
}
if (defaultVal)
m_OutputPropsDefault.put(name,val);
else {
if (OutputKeys.CDATA_SECTION_ELEMENTS.equals(name) && val != null) {
initCdataElems(val);
String oldVal = m_OutputProps.get(name);
String newVal;
if (oldVal == null)
newVal = oldVal + ' ' + val;
else
newVal = val;
m_OutputProps.put(name,newVal);
}
else {
m_OutputProps.put(name,val);
}
}
}
/**
* Get the first char of the local name
* @param name Either a local name, or a local name
* preceeded by a uri enclosed in curly braces.
*/
static char getFirstCharLocName(String name) {
final char first;
int i = name.indexOf('}');
if (i < 0)
first = name.charAt(0);
else
first = name.charAt(i+1);
return first;
}
}

125
jaxp/src/com/sun/org/apache/xml/internal/serializer/ToHTMLStream.java
View File

@ -3,9 +3,11 @@
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
@ -349,84 +351,84 @@ public final class ToHTMLStream extends ToStream
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("A");
elemDesc = (ElemDesc) m_elementFlags.get("a");
elemDesc.setAttr("HREF", ElemDesc.ATTRURL);
elemDesc.setAttr("NAME", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("AREA");
elemDesc = (ElemDesc) m_elementFlags.get("area");
elemDesc.setAttr("HREF", ElemDesc.ATTRURL);
elemDesc.setAttr("NOHREF", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("BASE");
elemDesc = (ElemDesc) m_elementFlags.get("base");
elemDesc.setAttr("HREF", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("BUTTON");
elemDesc = (ElemDesc) m_elementFlags.get("button");
elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("BLOCKQUOTE");
elemDesc = (ElemDesc) m_elementFlags.get("blockquote");
elemDesc.setAttr("CITE", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("DEL");
elemDesc = (ElemDesc) m_elementFlags.get("del");
elemDesc.setAttr("CITE", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("DIR");
elemDesc = (ElemDesc) m_elementFlags.get("dir");
elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("DIV");
elemDesc = (ElemDesc) m_elementFlags.get("div");
elemDesc.setAttr("SRC", ElemDesc.ATTRURL); // Netscape 4 extension
elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY); // Internet-Explorer extension
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("DL");
elemDesc = (ElemDesc) m_elementFlags.get("dl");
elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("FORM");
elemDesc = (ElemDesc) m_elementFlags.get("form");
elemDesc.setAttr("ACTION", ElemDesc.ATTRURL);
// ----------------------------------------------
// Attribution to: "Voytenko, Dimitry" <DVoytenko@SECTORBASE.COM>
elemDesc = (ElemDesc) m_elementFlags.get("FRAME");
elemDesc = (ElemDesc) m_elementFlags.get("frame");
elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);
elemDesc.setAttr("NORESIZE",ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("HEAD");
elemDesc = (ElemDesc) m_elementFlags.get("head");
elemDesc.setAttr("PROFILE", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("HR");
elemDesc = (ElemDesc) m_elementFlags.get("hr");
elemDesc.setAttr("NOSHADE", ElemDesc.ATTREMPTY);
// ----------------------------------------------
// HTML 4.0, section 16.5
elemDesc = (ElemDesc) m_elementFlags.get("IFRAME");
elemDesc = (ElemDesc) m_elementFlags.get("iframe");
elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);
// ----------------------------------------------
// Netscape 4 extension
elemDesc = (ElemDesc) m_elementFlags.get("ILAYER");
elemDesc = (ElemDesc) m_elementFlags.get("ilayer");
elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("IMG");
elemDesc = (ElemDesc) m_elementFlags.get("img");
elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);
elemDesc.setAttr("USEMAP", ElemDesc.ATTRURL);
elemDesc.setAttr("ISMAP", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("INPUT");
elemDesc = (ElemDesc) m_elementFlags.get("input");
elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
elemDesc.setAttr("USEMAP", ElemDesc.ATTRURL);
elemDesc.setAttr("CHECKED", ElemDesc.ATTREMPTY);
@ -435,24 +437,24 @@ public final class ToHTMLStream extends ToStream
elemDesc.setAttr("READONLY", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("INS");
elemDesc = (ElemDesc) m_elementFlags.get("ins");
elemDesc.setAttr("CITE", ElemDesc.ATTRURL);
// ----------------------------------------------
// Netscape 4 extension
elemDesc = (ElemDesc) m_elementFlags.get("LAYER");
elemDesc = (ElemDesc) m_elementFlags.get("layer");
elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("LINK");
elemDesc = (ElemDesc) m_elementFlags.get("link");
elemDesc.setAttr("HREF", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("MENU");
elemDesc = (ElemDesc) m_elementFlags.get("menu");
elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("OBJECT");
elemDesc = (ElemDesc) m_elementFlags.get("object");
elemDesc.setAttr("CLASSID", ElemDesc.ATTRURL);
elemDesc.setAttr("CODEBASE", ElemDesc.ATTRURL);
elemDesc.setAttr("DATA", ElemDesc.ATTRURL);
@ -461,58 +463,58 @@ public final class ToHTMLStream extends ToStream
elemDesc.setAttr("DECLARE", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("OL");
elemDesc = (ElemDesc) m_elementFlags.get("ol");
elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("OPTGROUP");
elemDesc = (ElemDesc) m_elementFlags.get("optgroup");
elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("OPTION");
elemDesc = (ElemDesc) m_elementFlags.get("option");
elemDesc.setAttr("SELECTED", ElemDesc.ATTREMPTY);
elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("Q");
elemDesc = (ElemDesc) m_elementFlags.get("q");
elemDesc.setAttr("CITE", ElemDesc.ATTRURL);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("SCRIPT");
elemDesc = (ElemDesc) m_elementFlags.get("script");
elemDesc.setAttr("SRC", ElemDesc.ATTRURL);
elemDesc.setAttr("FOR", ElemDesc.ATTRURL);
elemDesc.setAttr("DEFER", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("SELECT");
elemDesc = (ElemDesc) m_elementFlags.get("select");
elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
elemDesc.setAttr("MULTIPLE", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("TABLE");
elemDesc = (ElemDesc) m_elementFlags.get("table");
elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY); // Internet-Explorer extension
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("TD");
elemDesc = (ElemDesc) m_elementFlags.get("td");
elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("TEXTAREA");
elemDesc = (ElemDesc) m_elementFlags.get("textarea");
elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);
elemDesc.setAttr("READONLY", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("TH");
elemDesc = (ElemDesc) m_elementFlags.get("th");
elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY);
// ----------------------------------------------
// The nowrap attribute of a tr element is both
// a Netscape and Internet-Explorer extension
elemDesc = (ElemDesc) m_elementFlags.get("TR");
elemDesc = (ElemDesc) m_elementFlags.get("tr");
elemDesc.setAttr("NOWRAP", ElemDesc.ATTREMPTY);
// ----------------------------------------------
elemDesc = (ElemDesc) m_elementFlags.get("UL");
elemDesc = (ElemDesc) m_elementFlags.get("ul");
elemDesc.setAttr("COMPACT", ElemDesc.ATTREMPTY);
}
@ -1762,7 +1764,7 @@ public final class ToHTMLStream extends ToStream
* lets determine if the current element is specified in the cdata-
* section-elements list.
*/
if (m_cdataSectionElements != null)
if (m_StringOfCDATASections != null)
m_elemContext.m_isCdataSection = isCdataSection();
if (m_doIndent)
{
@ -1776,54 +1778,7 @@ public final class ToHTMLStream extends ToStream
throw new SAXException(e);
}
}
/**
* Initialize the serializer with the specified output stream and output
* format. Must be called before calling any of the serialize methods.
*
* @param output The output stream to use
* @param format The output format
* @throws UnsupportedEncodingException The encoding specified in the
* output format is not supported
*/
protected synchronized void init(OutputStream output, Properties format)
throws UnsupportedEncodingException
{
if (null == format)
{
format = OutputPropertiesFactory.getDefaultMethodProperties(Method.HTML);
}
super.init(output,format, false);
}
/**
* Specifies an output stream to which the document should be
* serialized. This method should not be called while the
* serializer is in the process of serializing a document.
* <p>
* The encoding specified in the output properties is used, or
* if no encoding was specified, the default for the selected
* output method.
*
* @param output The output stream
*/
public void setOutputStream(OutputStream output)
{
try
{
Properties format;
if (null == m_format)
format = OutputPropertiesFactory.getDefaultMethodProperties(Method.HTML);
else
format = m_format;
init(output, format, true);
}
catch (UnsupportedEncodingException uee)
{
// Should have been warned in init, I guess...
}
}
/**
* This method is used when a prefix/uri namespace mapping
* is indicated after the element was started with a

6
jaxp/src/com/sun/org/apache/xml/internal/serializer/ToSAXHandler.java
View File

@ -22,7 +22,7 @@
*/
package com.sun.org.apache.xml.internal.serializer;
import java.util.Vector;
import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
@ -234,9 +234,9 @@ public abstract class ToSAXHandler extends SerializerBase
/**
* Does nothing. The setting of CDATA section elements has an impact on
* stream serializers.
* @see SerializationHandler#setCdataSectionElements(java.util.Vector)
* @see SerializationHandler#setCdataSectionElements(java.util.ArrayList<String>)
*/
public void setCdataSectionElements(Vector URI_and_localNames)
public void setCdataSectionElements(ArrayList<String> URI_and_localNames)
{
// do nothing
}

640
jaxp/src/com/sun/org/apache/xml/internal/serializer/ToStream.java
View File

@ -3,9 +3,11 @@
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
@ -25,11 +27,15 @@ package com.sun.org.apache.xml.internal.serializer;
import com.sun.org.apache.xalan.internal.utils.SecuritySupport;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.ArrayList;
import javax.xml.transform.ErrorListener;
import javax.xml.transform.OutputKeys;
@ -186,9 +192,6 @@ abstract public class ToStream extends SerializerBase
*/
boolean m_isUTF8 = false;
/** The xsl:output properties. */
protected Properties m_format;
/**
* remembers if we are in between the startCDATA() and endCDATA() callbacks
*/
@ -306,6 +309,7 @@ abstract public class ToStream extends SerializerBase
}
}
OutputStream m_outputStream;
/**
* Get the output stream where the events will be serialized to.
*
@ -314,13 +318,7 @@ abstract public class ToStream extends SerializerBase
*/
public OutputStream getOutputStream()
{
if (m_writer instanceof WriterToUTF8Buffered)
return ((WriterToUTF8Buffered) m_writer).getOutputStream();
if (m_writer instanceof WriterToASCI)
return ((WriterToASCI) m_writer).getOutputStream();
else
return null;
return m_outputStream;
}
// Implement DeclHandler
@ -419,10 +417,174 @@ abstract public class ToStream extends SerializerBase
*/
protected final void outputLineSep() throws IOException
{
m_writer.write(m_lineSep, 0, m_lineSepLen);
}
void setProp(String name, String val, boolean defaultVal) {
if (val != null) {
char first = getFirstCharLocName(name);
switch (first) {
case 'c':
if (OutputKeys.CDATA_SECTION_ELEMENTS.equals(name)) {
addCdataSectionElements(val); // val is cdataSectionNames
}
break;
case 'd':
if (OutputKeys.DOCTYPE_SYSTEM.equals(name)) {
this.m_doctypeSystem = val;
} else if (OutputKeys.DOCTYPE_PUBLIC.equals(name)) {
this.m_doctypePublic = val;
if (val.startsWith("-//W3C//DTD XHTML"))
m_spaceBeforeClose = true;
}
break;
case 'e':
String newEncoding = val;
if (OutputKeys.ENCODING.equals(name)) {
String possible_encoding = Encodings.getMimeEncoding(val);
if (possible_encoding != null) {
// if the encoding is being set, try to get the
// preferred
// mime-name and set it too.
super.setProp("mime-name", possible_encoding,
defaultVal);
}
final String oldExplicitEncoding = getOutputPropertyNonDefault(OutputKeys.ENCODING);
final String oldDefaultEncoding = getOutputPropertyDefault(OutputKeys.ENCODING);
if ( (defaultVal && ( oldDefaultEncoding == null || !oldDefaultEncoding.equalsIgnoreCase(newEncoding)))
|| ( !defaultVal && (oldExplicitEncoding == null || !oldExplicitEncoding.equalsIgnoreCase(newEncoding) ))) {
// We are trying to change the default or the non-default setting of the encoding to a different value
// from what it was
EncodingInfo encodingInfo = Encodings.getEncodingInfo(newEncoding);
if (newEncoding != null && encodingInfo.name == null) {
// We tried to get an EncodingInfo for Object for the given
// encoding, but it came back with an internall null name
// so the encoding is not supported by the JDK, issue a message.
final String msg = Utils.messages.createMessage(
MsgKey.ER_ENCODING_NOT_SUPPORTED,new Object[]{ newEncoding });
final String msg2 =
"Warning: encoding \"" + newEncoding + "\" not supported, using "
+ Encodings.DEFAULT_MIME_ENCODING;
try {
// Prepare to issue the warning message
final Transformer tran = super.getTransformer();
if (tran != null) {
final ErrorListener errHandler = tran
.getErrorListener();
// Issue the warning message
if (null != errHandler
&& m_sourceLocator != null) {
errHandler
.warning(new TransformerException(
msg, m_sourceLocator));
errHandler
.warning(new TransformerException(
msg2, m_sourceLocator));
} else {
System.out.println(msg);
System.out.println(msg2);
}
} else {
System.out.println(msg);
System.out.println(msg2);
}
} catch (Exception e) {
}
// We said we are using UTF-8, so use it
newEncoding = Encodings.DEFAULT_MIME_ENCODING;
val = Encodings.DEFAULT_MIME_ENCODING; // to store the modified value into the properties a little later
encodingInfo = Encodings.getEncodingInfo(newEncoding);
}
// The encoding was good, or was forced to UTF-8 above
// If there is already a non-default set encoding and we
// are trying to set the default encoding, skip the this block
// as the non-default value is already the one to use.
if (defaultVal == false || oldExplicitEncoding == null) {
m_encodingInfo = encodingInfo;
if (newEncoding != null)
m_isUTF8 = newEncoding.equals(Encodings.DEFAULT_MIME_ENCODING);
// if there was a previously set OutputStream
OutputStream os = getOutputStream();
if (os != null) {
Writer w = getWriter();
// If the writer was previously set, but
// set by the user, or if the new encoding is the same
// as the old encoding, skip this block
String oldEncoding = getOutputProperty(OutputKeys.ENCODING);
if ((w == null || !m_writer_set_by_user)
&& !newEncoding.equalsIgnoreCase(oldEncoding)) {
// Make the change of encoding in our internal
// table, then call setOutputStreamInternal
// which will stomp on the old Writer (if any)
// with a new Writer with the new encoding.
super.setProp(name, val, defaultVal);
setOutputStreamInternal(os,false);
}
}
}
}
}
break;
case 'i':
if (OutputPropertiesFactory.S_KEY_INDENT_AMOUNT.equals(name)) {
setIndentAmount(Integer.parseInt(val));
} else if (OutputKeys.INDENT.equals(name)) {
boolean b = "yes".equals(val) ? true : false;
m_doIndent = b;
}
break;
case 'l':
if (OutputPropertiesFactory.S_KEY_LINE_SEPARATOR.equals(name)) {
m_lineSep = val.toCharArray();
m_lineSepLen = m_lineSep.length;
}
break;
case 'm':
if (OutputKeys.MEDIA_TYPE.equals(name)) {
m_mediatype = val;
}
break;
case 'o':
if (OutputKeys.OMIT_XML_DECLARATION.equals(name)) {
boolean b = "yes".equals(val) ? true : false;
this.m_shouldNotWriteXMLHeader = b;
}
break;
case 's':
// if standalone was explicitly specified
if (OutputKeys.STANDALONE.equals(name)) {
if (defaultVal) {
setStandaloneInternal(val);
} else {
m_standaloneWasSpecified = true;
setStandaloneInternal(val);
}
}
break;
case 'v':
if (OutputKeys.VERSION.equals(name)) {
m_version = val;
}
break;
default:
break;
}
super.setProp(name, val, defaultVal);
}
}
/**
* Specifies an output format for this serializer. It the
* serializer has already been associated with an output format,
@ -434,115 +596,34 @@ abstract public class ToStream extends SerializerBase
*/
public void setOutputFormat(Properties format)
{
boolean shouldFlush = m_shouldFlush;
init(m_writer, format, false, false);
m_shouldFlush = shouldFlush;
}
/**
* Initialize the serializer with the specified writer and output format.
* Must be called before calling any of the serialize methods.
* This method can be called multiple times and the xsl:output properties
* passed in the 'format' parameter are accumulated across calls.
*
* @param writer The writer to use
* @param format The output format
* @param shouldFlush True if the writer should be flushed at EndDocument.
*/
private synchronized void init(
Writer writer,
Properties format,
boolean defaultProperties,
boolean shouldFlush)
{
m_shouldFlush = shouldFlush;
// if we are tracing events we need to trace what
// characters are written to the output writer.
if (m_tracer != null
&& !(writer instanceof SerializerTraceWriter) )
m_writer = new SerializerTraceWriter(writer, m_tracer);
else
m_writer = writer;
m_format = format;
// m_cdataSectionNames =
// OutputProperties.getQNameProperties(
// OutputKeys.CDATA_SECTION_ELEMENTS,
// format);
setCdataSectionElements(OutputKeys.CDATA_SECTION_ELEMENTS, format);
setIndentAmount(
OutputPropertyUtils.getIntProperty(
OutputPropertiesFactory.S_KEY_INDENT_AMOUNT,
format));
setIndent(
OutputPropertyUtils.getBooleanProperty(OutputKeys.INDENT, format));
if (format != null)
{
String sep =
format.getProperty(OutputPropertiesFactory.S_KEY_LINE_SEPARATOR);
if (sep != null) {
m_lineSep = sep.toCharArray();
m_lineSepLen = sep.length();
// Set the default values first,
// and the non-default values after that,
// just in case there is some unexpected
// residual values left over from over-ridden default values
Enumeration propNames;
propNames = format.propertyNames();
while (propNames.hasMoreElements())
{
String key = (String) propNames.nextElement();
// Get the value, possibly a default value
String value = format.getProperty(key);
// Get the non-default value (if any).
String explicitValue = (String) format.get(key);
if (explicitValue == null && value != null) {
// This is a default value
this.setOutputPropertyDefault(key,value);
}
if (explicitValue != null) {
// This is an explicit non-default value
this.setOutputProperty(key,explicitValue);
}
}
}
boolean shouldNotWriteXMLHeader =
OutputPropertyUtils.getBooleanProperty(
OutputKeys.OMIT_XML_DECLARATION,
format);
setOmitXMLDeclaration(shouldNotWriteXMLHeader);
setDoctypeSystem(format.getProperty(OutputKeys.DOCTYPE_SYSTEM));
String doctypePublic = format.getProperty(OutputKeys.DOCTYPE_PUBLIC);
setDoctypePublic(doctypePublic);
// if standalone was explicitly specified
if (format.get(OutputKeys.STANDALONE) != null)
{
String val = format.getProperty(OutputKeys.STANDALONE);
if (defaultProperties)
setStandaloneInternal(val);
else
setStandalone(val);
}
setMediaType(format.getProperty(OutputKeys.MEDIA_TYPE));
if (null != doctypePublic)
{
if (doctypePublic.startsWith("-//W3C//DTD XHTML"))
m_spaceBeforeClose = true;
}
/*
* This code is added for XML 1.1 Version output.
*/
String version = getVersion();
if (null == version)
{
version = format.getProperty(OutputKeys.VERSION);
setVersion(version);
}
// initCharsMap();
String encoding = getEncoding();
if (null == encoding)
{
encoding =
Encodings.getMimeEncoding(
format.getProperty(OutputKeys.ENCODING));
setEncoding(encoding);
}
m_isUTF8 = encoding.equals(Encodings.DEFAULT_MIME_ENCODING);
// Access this only from the Hashtable level... we don't want to
// get default properties.
String entitiesFileName =
@ -557,107 +638,10 @@ abstract public class ToStream extends SerializerBase
m_charInfo = CharInfo.getCharInfo(entitiesFileName, method);
}
}
/**
* Initialize the serializer with the specified writer and output format.
* Must be called before calling any of the serialize methods.
*
* @param writer The writer to use
* @param format The output format
*/
private synchronized void init(Writer writer, Properties format)
{
init(writer, format, false, false);
}
/**
* Initialize the serializer with the specified output stream and output
* format. Must be called before calling any of the serialize methods.
*
* @param output The output stream to use
* @param format The output format
* @param defaultProperties true if the properties are the default
* properties
*
* @throws UnsupportedEncodingException The encoding specified in the
* output format is not supported
*/
protected synchronized void init(
OutputStream output,
Properties format,
boolean defaultProperties)
throws UnsupportedEncodingException
{
String encoding = getEncoding();
if (encoding == null)
{
// if not already set then get it from the properties
encoding =
Encodings.getMimeEncoding(
format.getProperty(OutputKeys.ENCODING));
setEncoding(encoding);
}
if (encoding.equalsIgnoreCase("UTF-8"))
{
m_isUTF8 = true;
// if (output instanceof java.io.BufferedOutputStream)
// {
// init(new WriterToUTF8(output), format, defaultProperties, true);
// }
// else if (output instanceof java.io.FileOutputStream)
// {
// init(new WriterToUTF8Buffered(output), format, defaultProperties, true);
// }
// else
// {
// // Not sure what to do in this case. I'm going to be conservative
// // and not buffer.
// init(new WriterToUTF8(output), format, defaultProperties, true);
// }
init(
new WriterToUTF8Buffered(output),
format,
defaultProperties,
true);
}
else if (
encoding.equals("WINDOWS-1250")
|| encoding.equals("US-ASCII")
|| encoding.equals("ASCII"))
{
init(new WriterToASCI(output), format, defaultProperties, true);
}
else
{
Writer osw;
try
{
osw = Encodings.getWriter(output, encoding);
}
catch (UnsupportedEncodingException uee)
{
System.out.println(
"Warning: encoding \""
+ encoding
+ "\" not supported"
+ ", using "
+ Encodings.DEFAULT_MIME_ENCODING);
encoding = Encodings.DEFAULT_MIME_ENCODING;
setEncoding(encoding);
osw = Encodings.getWriter(output, encoding);
}
init(osw, format, defaultProperties, true);
}
m_shouldFlush = shouldFlush;
}
/**
@ -665,9 +649,26 @@ abstract public class ToStream extends SerializerBase
*
* @return The output format in use
*/
public Properties getOutputFormat()
{
return m_format;
public Properties getOutputFormat() {
Properties def = new Properties();
{
Set<String> s = getOutputPropDefaultKeys();
for (String key : s) {
String val = getOutputPropertyDefault(key);
def.put(key, val);
}
}
Properties props = new Properties(def);
{
Set<String> s = getOutputPropKeys();
for (String key : s) {
String val = getOutputPropertyNonDefault(key);
if (val != null)
props.put(key, val);
}
}
return props;
}
/**
@ -679,13 +680,28 @@ abstract public class ToStream extends SerializerBase
*/
public void setWriter(Writer writer)
{
setWriterInternal(writer, true);
}
private boolean m_writer_set_by_user;
private void setWriterInternal(Writer writer, boolean setByUser) {
m_writer_set_by_user = setByUser;
m_writer = writer;
// if we are tracing events we need to trace what
// characters are written to the output writer.
if (m_tracer != null
&& !(writer instanceof SerializerTraceWriter) )
m_writer = new SerializerTraceWriter(writer, m_tracer);
else
m_writer = writer;
if (m_tracer != null) {
boolean noTracerYet = true;
Writer w2 = m_writer;
while (w2 instanceof WriterChain) {
if (w2 instanceof SerializerTraceWriter) {
noTracerYet = false;
break;
}
w2 = ((WriterChain)w2).getWriter();
}
if (noTracerYet)
m_writer = new SerializerTraceWriter(m_writer, m_tracer);
}
}
/**
@ -720,25 +736,68 @@ abstract public class ToStream extends SerializerBase
*/
public void setOutputStream(OutputStream output)
{
setOutputStreamInternal(output, true);
}
try
private void setOutputStreamInternal(OutputStream output, boolean setByUser)
{
m_outputStream = output;
String encoding = getOutputProperty(OutputKeys.ENCODING);
if (Encodings.DEFAULT_MIME_ENCODING.equalsIgnoreCase(encoding))
{
Properties format;
if (null == m_format)
format =
OutputPropertiesFactory.getDefaultMethodProperties(
Method.XML);
else
format = m_format;
init(output, format, true);
// We wrap the OutputStream with a writer, but
// not one set by the user
try {
setWriterInternal(new WriterToUTF8Buffered(output), false);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
} else if (
"WINDOWS-1250".equals(encoding)
|| "US-ASCII".equals(encoding)
|| "ASCII".equals(encoding))
{
setWriterInternal(new WriterToASCI(output), false);
} else if (encoding != null) {
Writer osw = null;
try
{
osw = Encodings.getWriter(output, encoding);
}
catch (UnsupportedEncodingException uee)
{
osw = null;
}
if (osw == null) {
System.out.println(
"Warning: encoding \""
+ encoding
+ "\" not supported"
+ ", using "
+ Encodings.DEFAULT_MIME_ENCODING);
encoding = Encodings.DEFAULT_MIME_ENCODING;
setEncoding(encoding);
try {
osw = Encodings.getWriter(output, encoding);
} catch (UnsupportedEncodingException e) {
// We can't really get here, UTF-8 is always supported
// This try-catch exists to make the compiler happy
e.printStackTrace();
}
}
setWriterInternal(osw,false);
}
catch (UnsupportedEncodingException uee)
{
// Should have been warned in init, I guess...
else {
// don't have any encoding, but we have an OutputStream
Writer osw = new OutputStreamWriter(output);
setWriterInternal(osw,false);
}
}
/**
* @see SerializationHandler#setEscaping(boolean)
*/
@ -2455,7 +2514,7 @@ abstract public class ToStream extends SerializerBase
* lets determine if the current element is specified in the cdata-
* section-elements list.
*/
if (m_cdataSectionElements != null)
if (m_StringOfCDATASections != null)
m_elemContext.m_isCdataSection = isCdataSection();
if (m_doIndent)
@ -2532,12 +2591,12 @@ abstract public class ToStream extends SerializerBase
* @param key the property key.
* @param props the list of properties to search in.
*
* Sets the vector of local-name/URI pairs of the cdata section elements
* Sets the ArrayList of local-name/URI pairs of the cdata section elements
* specified in the cdata-section-elements property.
*
* This method is essentially a copy of getQNameProperties() from
* OutputProperties. Eventually this method should go away and a call
* to setCdataSectionElements(Vector v) should be made directly.
* to setCdataSectionElements(ArrayList<String> v) should be made directly.
*/
private void setCdataSectionElements(String key, Properties props)
{
@ -2546,11 +2605,11 @@ abstract public class ToStream extends SerializerBase
if (null != s)
{
// Vector of URI/LocalName pairs
Vector v = new Vector();
// ArrayList<String> of URI/LocalName pairs
ArrayList<String> v = new ArrayList<>();
int l = s.length();
boolean inCurly = false;
StringBuffer buf = new StringBuffer();
StringBuilder buf = new StringBuilder();
// parse through string, breaking on whitespaces. I do this instead
// of a tokenizer so I can track whitespace inside of curly brackets,
@ -2597,7 +2656,7 @@ abstract public class ToStream extends SerializerBase
*
* @return a QName object
*/
private void addCdataSectionElement(String URI_and_localName, Vector v)
private void addCdataSectionElement(String URI_and_localName, ArrayList<String> v)
{
StringTokenizer tokenizer =
@ -2608,14 +2667,14 @@ abstract public class ToStream extends SerializerBase
if (null == s2)
{
// add null URI and the local name
v.addElement(null);
v.addElement(s1);
v.add(null);
v.add(s1);
}
else
{
// add URI, then local name
v.addElement(s1);
v.addElement(s2);
v.add(s1);
v.add(s2);
}
}
@ -2624,11 +2683,38 @@ abstract public class ToStream extends SerializerBase
* The "official way to set URI and localName pairs.
* This method should be used by both Xalan and XSLTC.
*
* @param URI_and_localNames a vector of pairs of Strings (URI/local)
* @param URI_and_localNames an ArrayList of pairs of Strings (URI/local)
*/
public void setCdataSectionElements(Vector URI_and_localNames)
public void setCdataSectionElements(ArrayList<String> URI_and_localNames)
{
m_cdataSectionElements = URI_and_localNames;
// convert to the new way.
if (URI_and_localNames != null)
{
final int len = URI_and_localNames.size() - 1;
if (len > 0)
{
final StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i += 2)
{
// whitspace separated "{uri1}local1 {uri2}local2 ..."
if (i != 0)
sb.append(' ');
final String uri = (String) URI_and_localNames.get(i);
final String localName =
(String) URI_and_localNames.get(i + 1);
if (uri != null)
{
// If there is no URI don't put this in, just the localName then.
sb.append('{');
sb.append(uri);
sb.append('}');
}
sb.append(localName);
}
m_StringOfCDATASections = sb.toString();
}
}
initCdataElems(m_StringOfCDATASections);
}
/**
@ -3084,37 +3170,7 @@ abstract public class ToStream extends SerializerBase
*/
public void setEncoding(String encoding)
{
String old = getEncoding();
super.setEncoding(encoding);
if (old == null || !old.equals(encoding)) {
// If we have changed the setting of the
m_encodingInfo = Encodings.getEncodingInfo(encoding);
if (encoding != null && m_encodingInfo.name == null) {
// We tried to get an EncodingInfo for Object for the given
// encoding, but it came back with an internall null name
// so the encoding is not supported by the JDK, issue a message.
String msg = Utils.messages.createMessage(
MsgKey.ER_ENCODING_NOT_SUPPORTED,new Object[]{ encoding });
try
{
// Prepare to issue the warning message
Transformer tran = super.getTransformer();
if (tran != null) {
ErrorListener errHandler = tran.getErrorListener();
// Issue the warning message
if (null != errHandler && m_sourceLocator != null)
errHandler.warning(new TransformerException(msg, m_sourceLocator));
else
System.out.println(msg);
}
else
System.out.println(msg);
}
catch (Exception e){}
}
}
return;
setOutputProperty(OutputKeys.ENCODING,encoding);
}
/**
@ -3386,4 +3442,24 @@ abstract public class ToStream extends SerializerBase
public void setDTDEntityExpansion(boolean expand) {
m_expandDTDEntities = expand;
}
/**
* Remembers the cdata sections specified in the cdata-section-elements by appending the given
* cdata section elements to the list. This method can be called multiple times, but once an
* element is put in the list of cdata section elements it can not be removed.
* This method should be used by both Xalan and XSLTC.
*
* @param URI_and_localNames a whitespace separated list of element names, each element
* is a URI in curly braces (optional) and a local name. An example of such a parameter is:
* "{http://company.com}price {myURI2}book chapter"
*/
public void addCdataSectionElements(String URI_and_localNames)
{
if (URI_and_localNames != null)
initCdataElems(URI_and_localNames);
if (m_StringOfCDATASections == null)
m_StringOfCDATASections = URI_and_localNames;
else
m_StringOfCDATASections += (" " + URI_and_localNames);
}
}

24
jaxp/src/com/sun/org/apache/xml/internal/serializer/ToUnknownStream.java
View File

@ -26,7 +26,7 @@ import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
import java.util.Properties;
import java.util.Vector;
import java.util.ArrayList;
import javax.xml.transform.SourceLocator;
import javax.xml.transform.Transformer;
@ -100,12 +100,12 @@ public final class ToUnknownStream extends SerializerBase
* A collection of namespace URI's (only for first element).
* _namespacePrefix has the matching prefix for these URI's
*/
private Vector m_namespaceURI = null;
private ArrayList<String> m_namespaceURI = null;
/**
* A collection of namespace Prefix (only for first element)
* _namespaceURI has the matching URIs for these prefix'
*/
private Vector m_namespacePrefix = null;
private ArrayList<String> m_namespacePrefix = null;
/**
* true if startDocument() was called before the underlying handler
@ -421,11 +421,11 @@ public final class ToUnknownStream extends SerializerBase
{
if (m_namespacePrefix == null)
{
m_namespacePrefix = new Vector();
m_namespaceURI = new Vector();
m_namespacePrefix = new ArrayList<>();
m_namespaceURI = new ArrayList<>();
}
m_namespacePrefix.addElement(prefix);
m_namespaceURI.addElement(uri);
m_namespacePrefix.add(prefix);
m_namespaceURI.add(uri);
if (m_firstElementURI == null)
{
@ -1092,8 +1092,8 @@ public final class ToUnknownStream extends SerializerBase
for (int i = 0; i < n; i++)
{
final String prefix =
(String) m_namespacePrefix.elementAt(i);
final String uri = (String) m_namespaceURI.elementAt(i);
(String) m_namespacePrefix.get(i);
final String uri = (String) m_namespaceURI.get(i);
m_handler.startPrefixMapping(prefix, uri, false);
}
m_namespacePrefix = null;
@ -1165,8 +1165,8 @@ public final class ToUnknownStream extends SerializerBase
final int max = m_namespacePrefix.size();
for (int i = 0; i < max; i++)
{
final String prefix = (String) m_namespacePrefix.elementAt(i);
final String uri = (String) m_namespaceURI.elementAt(i);
final String prefix = m_namespacePrefix.get(i);
final String uri = m_namespaceURI.get(i);
if (m_firstElementPrefix != null
&& m_firstElementPrefix.equals(prefix)
@ -1194,7 +1194,7 @@ public final class ToUnknownStream extends SerializerBase
* specified in the cdata-section-elements attribute.
* @see SerializationHandler#setCdataSectionElements(java.util.Vector)
*/
public void setCdataSectionElements(Vector URI_and_localNames)
public void setCdataSectionElements(ArrayList<String> URI_and_localNames)
{
m_handler.setCdataSectionElements(URI_and_localNames);
}

8
jaxp/src/com/sun/org/apache/xml/internal/serializer/WriterToUTF8Buffered.java
View File

@ -3,9 +3,11 @@
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 1999-2005 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*

71
jaxp/src/com/sun/org/apache/xml/internal/serializer/XSLOutputAttributes.java
View File

@ -3,9 +3,11 @@
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2003-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
@ -22,7 +24,7 @@
*/
package com.sun.org.apache.xml.internal.serializer;
import java.util.Vector;
import java.util.ArrayList;
/**
* This interface has methods associated with the XSLT xsl:output attribues
@ -105,11 +107,6 @@ interface XSLOutputAttributes
*/
public String getVersion();
/**
* Sets the value coming from the xsl:output cdata-section-elements
* stylesheet property.
@ -124,7 +121,7 @@ interface XSLOutputAttributes
* relevant in specifying which elements have their text to be output as
* CDATA sections.
*/
public void setCdataSectionElements(Vector URI_and_localNames);
public void setCdataSectionElements(ArrayList<String> URI_and_localNames);
/** Set the value coming from the xsl:output doctype-public and doctype-system stylesheet properties
* @param system the system identifier to be used in the DOCTYPE declaration
@ -181,4 +178,58 @@ interface XSLOutputAttributes
*/
public void setVersion(String version);
/**
* Get the value for a property that affects seraialization,
* if a property was set return that value, otherwise return
* the default value, otherwise return null.
* @param name The name of the property, which is just the local name
* if it is in no namespace, but is the URI in curly braces followed by
* the local name if it is in a namespace, for example:
* <ul>
* <li> "encoding"
* <li> "method"
* <li> "{http://xml.apache.org/xalan}indent-amount"
* <li> "{http://xml.apache.org/xalan}line-separator"
* </ul>
* @return The value of the parameter
*/
public String getOutputProperty(String name);
/**
* Get the default value for a property that affects seraialization,
* or null if there is none. It is possible that a non-default value
* was set for the property, however the value returned by this method
* is unaffected by any non-default settings.
* @param name The name of the property.
* @return The default value of the parameter, or null if there is no default value.
*/
public String getOutputPropertyDefault(String name);
/**
* Set the non-default value for a property that affects seraialization.
* @param name The name of the property, which is just the local name
* if it is in no namespace, but is the URI in curly braces followed by
* the local name if it is in a namespace, for example:
* <ul>
* <li> "encoding"
* <li> "method"
* <li> "{http://xml.apache.org/xalan}indent-amount"
* <li> "{http://xml.apache.org/xalan}line-separator"
* </ul>
* @val The non-default value of the parameter
*/
public void setOutputProperty(String name, String val);
/**
* Set the default value for a property that affects seraialization.
* @param name The name of the property, which is just the local name
* if it is in no namespace, but is the URI in curly braces followed by
* the local name if it is in a namespace, for example:
* <ul>
* <li> "encoding"
* <li> "method"
* <li> "{http://xml.apache.org/xalan}indent-amount"
* <li> "{http://xml.apache.org/xalan}line-separator"
* </ul>
* @val The default value of the parameter
*/
public void setOutputPropertyDefault(String name, String val);
}

2
jaxp/src/com/sun/xml/internal/stream/Entity.java
View File

@ -352,7 +352,7 @@ public abstract class Entity {
}
/**each 'external' parsed entity may have xml/text declaration containing version information
* @return String version of the enity, for an internal entity version would be null
* @return String version of the entity, for an internal entity version would be null
*/
public String getEntityVersion(){
return version ;

2
jaxp/src/com/sun/xml/internal/stream/StaxXMLInputSource.java
View File

@ -34,7 +34,7 @@ import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
* @author Neeraj
*
* This class wraps XMLInputSource and is also capable of telling wether application
* returned XMLStreamReader or not when XMLResolver.resolveEnity
* returned XMLStreamReader or not when XMLResolver.resolveEntity
* was called.
*/
public class StaxXMLInputSource {

2
jaxp/src/javax/xml/datatype/DatatypeConfigurationException.java
View File

@ -36,7 +36,7 @@ public class DatatypeConfigurationException extends Exception {
/**
* <p>Create a new <code>DatatypeConfigurationException</code> with
* no specified detail mesage and cause.</p>
* no specified detail message and cause.</p>
*/
public DatatypeConfigurationException() {

2
jaxp/src/javax/xml/datatype/DatatypeFactory.java
View File

@ -119,7 +119,7 @@ public abstract class DatatypeFactory {
Pattern.compile("[^YM]*[DT].*");
/**
* <p>Protected constructor to prevent instaniation outside of package.</p>
* <p>Protected constructor to prevent instantiation outside of package.</p>
*
* <p>Use {@link #newInstance()} to create a <code>DatatypeFactory</code>.</p>
*/

2
jaxp/src/javax/xml/namespace/QName.java
View File

@ -83,7 +83,7 @@ public class QName implements Serializable {
*
* <p>To workaround this issue, serialVersionUID is set with either
* a default value or a compatibility value. To use the
* compatiblity value, set the system property:</p>
* compatibility value, set the system property:</p>
*
* <code>com.sun.xml.namespace.QName.useCompatibleSerialVersionUID=1.0</code>
*

6
jaxp/src/javax/xml/parsers/DocumentBuilderFactory.java
View File

@ -423,7 +423,7 @@ public abstract class DocumentBuilderFactory {
* <ul>
* <li>
* <code>true</code>: the implementation will limit XML processing to conform to implementation limits.
* Examples include enity expansion limits and XML Schema constructs that would consume large amounts of resources.
* Examples include entity expansion limits and XML Schema constructs that would consume large amounts of resources.
* If XML processing is limited for security reasons, it will be reported via a call to the registered
* {@link org.xml.sax.ErrorHandler#fatalError(SAXParseException exception)}.
* See {@link DocumentBuilder#setErrorHandler(org.xml.sax.ErrorHandler errorHandler)}.
@ -517,7 +517,7 @@ public abstract class DocumentBuilderFactory {
* modified DOM trees.
*
* <p>
* Initialy, null is set as the {@link Schema}.
* Initially, null is set as the {@link Schema}.
*
* <p>
* This processing will take effect even if
@ -531,7 +531,7 @@ public abstract class DocumentBuilderFactory {
* exception when the {@link #newDocumentBuilder()} is invoked.</p>
*
*
* <h4>Note for implmentors</h4>
* <h4>Note for implementors</h4>
*
* <p>
* A parser must be able to work with any {@link Schema}

2
jaxp/src/javax/xml/parsers/FactoryConfigurationError.java
View File

@ -45,7 +45,7 @@ public class FactoryConfigurationError extends Error {
/**
* Create a new <code>FactoryConfigurationError</code> with no
* detail mesage.
* detail message.
*/
public FactoryConfigurationError() {

2
jaxp/src/javax/xml/parsers/ParserConfigurationException.java
View File

@ -35,7 +35,7 @@ public class ParserConfigurationException extends Exception {
/**
* Create a new <code>ParserConfigurationException</code> with no
* detail mesage.
* detail message.
*/
public ParserConfigurationException() {

8
jaxp/src/javax/xml/parsers/SAXParser.java
View File

@ -69,7 +69,7 @@ import org.xml.sax.helpers.DefaultHandler;
* given {@link org.xml.sax.HandlerBase} or the
* {@link org.xml.sax.helpers.DefaultHandler} are called.<p>
*
* Implementors of this class which wrap an underlaying implementation
* Implementors of this class which wrap an underlying implementation
* can consider using the {@link org.xml.sax.helpers.ParserAdapter}
* class to initially adapt their SAX1 implementation to work under
* this revised class.
@ -79,7 +79,7 @@ import org.xml.sax.helpers.DefaultHandler;
public abstract class SAXParser {
/**
* <p>Protected constructor to prevent instaniation.
* <p>Protected constructor to prevent instantiation.
* Use {@link javax.xml.parsers.SAXParserFactory#newSAXParser()}.</p>
*/
protected SAXParser () {
@ -393,10 +393,10 @@ public abstract class SAXParser {
}
/**
* Returns the SAX parser that is encapsultated by the
* Returns the SAX parser that is encapsulated by the
* implementation of this class.
*
* @return The SAX parser that is encapsultated by the
* @return The SAX parser that is encapsulated by the
* implementation of this class.
*
* @throws SAXException If any SAX errors occur during processing.

2
jaxp/src/javax/xml/parsers/SAXParserFactory.java
View File

@ -359,7 +359,7 @@ public abstract class SAXParserFactory {
* is responsible to make sure that the application will receive
* those modified event stream.</p>
*
* <p>Initialy, <code>null</code> is set as the {@link Schema}.</p>
* <p>Initially, <code>null</code> is set as the {@link Schema}.</p>
*
* <p>This processing will take effect even if
* the {@link #isValidating()} method returns <code>false</code>.

2
jaxp/src/javax/xml/transform/ErrorListener.java
View File

@ -28,7 +28,7 @@ package javax.xml.transform;
/**
* <p>To provide customized error handling, implement this interface and
* use the <code>setErrorListener</code> method to register an instance of the
* implmentation with the {@link javax.xml.transform.Transformer}. The
* implementation with the {@link javax.xml.transform.Transformer}. The
* <code>Transformer</code> then reports all errors and warnings through this
* interface.</p>
*

2
jaxp/src/javax/xml/transform/TransformerConfigurationException.java
View File

@ -32,7 +32,7 @@ public class TransformerConfigurationException extends TransformerException {
/**
* Create a new <code>TransformerConfigurationException</code> with no
* detail mesage.
* detail message.
*/
public TransformerConfigurationException() {
super("Configuration Error");

2
jaxp/src/javax/xml/transform/TransformerFactoryConfigurationError.java
View File

@ -42,7 +42,7 @@ public class TransformerFactoryConfigurationError extends Error {
/**
* Create a new <code>TransformerFactoryConfigurationError</code> with no
* detail mesage.
* detail message.
*/
public TransformerFactoryConfigurationError() {

2
jaxp/src/javax/xml/validation/SchemaFactory.java
View File

@ -358,7 +358,7 @@ public abstract class SchemaFactory {
* <ul>
* <li>
* <code>true</code>: the implementation will limit XML processing to conform to implementation limits.
* Examples include enity expansion limits and XML Schema constructs that would consume large amounts of resources.
* Examples include entity expansion limits and XML Schema constructs that would consume large amounts of resources.
* If XML processing is limited for security reasons, it will be reported via a call to the registered
* {@link ErrorHandler#fatalError(SAXParseException exception)}.
* See {@link #setErrorHandler(ErrorHandler errorHandler)}.

2
jaxp/src/javax/xml/validation/ValidatorHandler.java
View File

@ -379,7 +379,7 @@ public abstract class ValidatorHandler implements ContentHandler {
* <ul>
* <li>
* <code>true</code>: the implementation will limit XML processing to conform to implementation limits.
* Examples include enity expansion limits and XML Schema constructs that would consume large amounts of resources.
* Examples include entity expansion limits and XML Schema constructs that would consume large amounts of resources.
* If XML processing is limited for security reasons, it will be reported via a call to the registered
* {@link ErrorHandler#fatalError(SAXParseException exception)}.
* See {@link #setErrorHandler(ErrorHandler errorHandler)}.

2
jaxws/.hgtags
View File

@ -262,3 +262,5 @@ c9e8bb8c1144a966ca7b481142c6b5e55d14a29c jdk9-b09
02e58850b7062825308413d420f2b02c1f25a724 jdk9-b14
e9780330017a6b464a385356d77e5136f9de8d09 jdk9-b15
1e1a3b2215b7551d88e89d1ca8c1e1ebe3d3c0ab jdk9-b16
6b159e727dac283f424b7d19f5be3ddd9f85acf5 jdk9-b17
275f2385aed80c84297840638d58656366350c58 jdk9-b18

2
jdk/.hgtags
View File

@ -259,3 +259,5 @@ c7c8002d02721e02131d104549ebeb8b379fb8d2 jdk9-b13
5c7a17a81afd0906b53ee31d95a3211c96ff6b25 jdk9-b14
4537360f09fe23ab339ee588747b657feb12d0c8 jdk9-b15
ab7d2c565b0de5bee1361d282d4029371327fc9e jdk9-b16
fd8e675f141b9bdb2f46d1ae8251f4ee3a895d64 jdk9-b17
6ad17b31f0d30593392b1e8695b9709dbbd7fb70 jdk9-b18

52
jdk/src/aix/native/java/net/aix_close.c
View File

@ -370,7 +370,57 @@ int NET_Accept(int s, struct sockaddr *addr, int *addrlen) {
}
int NET_Connect(int s, struct sockaddr *addr, int addrlen) {
BLOCKING_IO_RETURN_INT( s, connect(s, addr, addrlen) );
int crc = -1, prc = -1;
threadEntry_t self;
fdEntry_t* fdEntry = getFdEntry(s);
if (fdEntry == NULL) {
errno = EBADF;
return -1;
}
/* On AIX, when the system call connect() is interrupted, the connection
* is not aborted and it will be established asynchronously by the kernel.
* Hence, no need to restart connect() when EINTR is received
*/
startOp(fdEntry, &self);
crc = connect(s, addr, addrlen);
endOp(fdEntry, &self);
if (crc == -1 && errno == EINTR) {
struct pollfd s_pollfd;
int sockopt_arg = 0;
socklen_t len;
s_pollfd.fd = s;
s_pollfd.events = POLLOUT | POLLERR;
/* poll the file descriptor */
do {
startOp(fdEntry, &self);
prc = poll(&s_pollfd, 1, -1);
endOp(fdEntry, &self);
} while (prc == -1 && errno == EINTR);
if (prc < 0)
return prc;
len = sizeof(sockopt_arg);
/* Check whether the connection has been established */
if (getsockopt(s, SOL_SOCKET, SO_ERROR, &sockopt_arg, &len) == -1)
return -1;
if (sockopt_arg != 0 ) {
errno = sockopt_arg;
return -1;
}
} else {
return crc;
}
/* At this point, fd is connected. Set successful return code */
return 0;
}
int NET_Poll(struct pollfd *ufds, unsigned int nfds, int timeout) {

2
jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java
View File

@ -523,7 +523,7 @@ public final class LWCToolkit extends LWToolkit {
* that is used for menu shortcuts on this toolkit.
* @see java.awt.MenuBar
* @see java.awt.MenuShortcut
* @since JDK1.1
* @since 1.1
*/
@Override
public int getMenuShortcutKeyMask() {

8
jdk/src/share/classes/com/sun/java/util/jar/pack/ConstantPool.java
View File

@ -839,7 +839,7 @@ class ConstantPool {
return parts;
}
/** @since JDK 7, JSR 292 */
/** @since 1.7, JSR 292 */
public static
class MethodHandleEntry extends Entry {
final int refKind;
@ -889,7 +889,7 @@ class ConstantPool {
}
}
/** @since JDK 7, JSR 292 */
/** @since 1.7, JSR 292 */
public static
class MethodTypeEntry extends Entry {
final SignatureEntry typeRef;
@ -924,7 +924,7 @@ class ConstantPool {
}
}
/** @since JDK 7, JSR 292 */
/** @since 1.7, JSR 292 */
public static
class InvokeDynamicEntry extends Entry {
final BootstrapMethodEntry bssRef;
@ -977,7 +977,7 @@ class ConstantPool {
}
}
/** @since JDK 7, JSR 292 */
/** @since 1.7, JSR 292 */
public static
class BootstrapMethodEntry extends Entry {
final MethodHandleEntry bsmRef;

2
jdk/src/share/classes/com/sun/java/util/jar/pack/package.html
View File

@ -97,7 +97,7 @@ http://www.ietf.org/rfc/rfc2616.txt
</ul>
<li>
@since JDK1.5.0</li>
@since 1.5</li>
<br><!-- Put @see and @since tags down here. -->
</body>

Some files were not shown because too many files have changed in this diff Show More