yggdrasil/gcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

re PR libgcj/37636 (java tools are unable to find resource files)

Browse Source 
libjava/ChangeLog:

2008-10-21  Andrew John Hughes  <gnu_andrew@member.fsf.org>

        * sources.am, Makfile.in: Regenerate.

2008-10-17  Matthias Klose  <doko@ubuntu.com>

	* configure.ac: Fix bashisms.
	* configure: Regenerate.

2008-10-15  Matthias Klose  <doko@ubuntu.com>

	* configure.ac: Disable build of gjdoc, if configured without
	--with-antlr-jar or if no antlr.jar found.
	* configure: Regenerate.

2008-10-09  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* classpath/configure.ac,
	* classpath/m4/ac_prog_antlr.m4,
	* classpath/m4/ac_prog_java.m4,
	* classpath/tools/Makefile.am:
	Ported --regen-gjdoc-parser patch and
	cantlr support from GNU Classpath.

2008-10-06  Andrew Haley  <aph@redhat.com>

	* java/lang/Thread.java (Thread): Always create the ThreadLocalMap
	when creating a thread.
	(getThreadLocals) Don't lazily create the ThreadLocalMap.

2008-09-28  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* classpath/java/lang/ThreadLocalMap.java,
	* java/lang/ThreadLocalMap$Entry.h,
	* java/lang/ThreadLocalMap.h,
	* lib/java/lang/ThreadLocalMap.class,
	* lib/java/lang/ThreadLocalMap$Entry.class:
	Add the new files for the ThreadLocal patch.

2008-09-28  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* classpath/ChangeLog,
	* classpath/java/lang/InheritableThreadLocal.java,
	* classpath/java/lang/Thread.java,
	* classpath/java/lang/ThreadLocal.java:
	Merge Daniel Frampton's ThreadLocal patch.
	* gcj/javaprims.h: Updated.
	* java/lang/Thread.h: Regenerated.
	* java/lang/Thread.java:
	Replace WeakIdentityHashMap with ThreadLocalMap.
	(getThreadLocals()): Likewise.
	* java/lang/ThreadLocal.h: Regenerated.
	* java/lang/ThreadLocal.java:
	(computeNextHash()): New method.
	(ThreadLocal()): Initialise fastHash.
	(internalGet()): Updated to match Classpath's get().
	(internalSet(Object)): Likewise for set(Object).
	(internalRemove()): Likewise for remove().
	
2008-09-25  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* classpath/configure,
	* classpath/configure.ac:
	Resynchronise with Classpath's configure.
	* classpath/examples/Makefile.in:
	Add equivalent support for building as in
	tools/Makefile.in.
	* classpath/java/nio/Buffer.java,
	* classpath/java/nio/ByteBuffer.java,
	* classpath/java/nio/ByteBufferImpl.java,
	* classpath/java/nio/CharBuffer.java,
	* classpath/java/nio/CharBufferImpl.java,
	* classpath/java/nio/CharSequenceBuffer.java,
	* classpath/java/nio/CharViewBufferImpl.java,
	* classpath/java/nio/DirectByteBufferImpl.java,
	* classpath/java/nio/DoubleBuffer.java,
	* classpath/java/nio/DoubleBufferImpl.java,
	* classpath/java/nio/DoubleViewBufferImpl.java,
	* classpath/java/nio/FloatBuffer.java,
	* classpath/java/nio/FloatBufferImpl.java,
	* classpath/java/nio/FloatViewBufferImpl.java,
	* classpath/java/nio/IntBuffer.java,
	* classpath/java/nio/IntBufferImpl.java,
	* classpath/java/nio/IntViewBufferImpl.java,
	* classpath/java/nio/LongBuffer.java,
	* classpath/java/nio/LongBufferImpl.java,
	* classpath/java/nio/LongViewBufferImpl.java,
	* classpath/java/nio/MappedByteBuffer.java,
	* classpath/java/nio/MappedByteBufferImpl.java,
	* classpath/java/nio/ShortBuffer.java,
	* classpath/java/nio/ShortBufferImpl.java,
	* classpath/java/nio/ShortViewBufferImpl.java:
	Replace use of gnu.classpath.Pointer with gnu.gcj.RawData,
	and fix some formatting issues.
	* classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaLexer.java,
	* classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaLexer.smap,
	* classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java,
	* classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.smap,
	* classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.java,
	* classpath/tools/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.txt:
	Regenerated (later version of antlr).
	* java/nio/Buffer.h: Regenerated.
	* java/nio/Buffer.java: Ported changes from Classpath.
	* java/nio/ByteBuffer.h,
	* java/nio/CharBuffer.h: Regenerated.
	* java/nio/DirectByteBufferImpl.java: Ported changes from
	Classpath.
	* java/nio/DoubleBuffer.h,
	* java/nio/FloatBuffer.h,
	* java/nio/IntBuffer.h,
	* java/nio/LongBuffer.h,
	* java/nio/MappedByteBuffer.h,
	* java/nio/MappedByteBufferImpl.h: Regenerated.
	* java/nio/MappedByteBufferImpl.java: Ported changes from
	Classpath.
	* java/nio/ShortBuffer.h: Regenerated.

2008-09-24  Matthias Klose  <doko@ubuntu.com>

	* configure.ac: Search for antlr.jar, if not configured.
	* configure: Regenerate.

2008-09-24  Matthias Klose  <doko@ubuntu.com>

	* Makefile.am: Build a gjdoc binary, if enabled.
	* configure.ac: Add options --disable-gjdoc, --with-antlr-jar=file.
	* Makefile.in, */Makefile.in, configure: Regenerate.

2008-09-22  Andrew Haley  <aph@redhat.com>

	* java/lang/String.java (toString(char[], int, int)): New method.

2008-09-14  Matthias Klose  <doko@ubuntu.com>

	Import GNU Classpath (libgcj-import-20080914).

	* Regenerate class and header files.
	* Regenerate auto* files.
	* configure.ac: Don't pass --disable-gjdoc to classpath.
	* sources.am: Regenerated.
	* HACKING: Mention to build gjdoc in maintainer builds.
	* gnu/classpath/Configuration.java: Update classpath version.
	* gcj/javaprims.h: Update.

2008-09-08  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* Makefile.am: Replace natStringBuffer.cc
	and natStringBuilder.cc with natAbstractStringBuffer.cc.
	* Makefile.in: Regenerated.
	* java/lang/AbstractStringBuffer.java:
	(append(int)): Made native.
	(regionMatches(int,String)): Likewise.
	* java/lang/StringBuffer.h: Regenerated.
	* java/lang/StringBuffer.java: Remerged with GNU Classpath.
	* java/lang/StringBuilder.h: Regenerated.
	* java/lang/StringBuilder.java: Remerged with GNU Classpath.
	* java/lang/natAbstractStringBuffer.cc: Provide common
	native methods for StringBuffer and StringBuilder.
	* java/lang/natStringBuffer.cc,
	* java/lang/natStringBuilder.cc: Removed.

2008-09-04  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* Makefile.in,
	* classpath/configure: Regenerated.
	* gnu/gcj/util/natDebug.cc,
	* gnu/gcj/xlib/natColormap.cc,
	* gnu/gcj/xlib/natDisplay.cc,
	* gnu/gcj/xlib/natDrawable.cc,
	* gnu/gcj/xlib/natFont.cc,
	* gnu/gcj/xlib/natWMSizeHints.cc,
	* gnu/gcj/xlib/natWindow.cc,
	* gnu/gcj/xlib/natXImage.cc:
	Add :: prefix to namespaces.
	* java/io/CharArrayWriter.h,
	* java/lang/StringBuffer.h:
	Regenerated using patched gjavah.
	* java/lang/natStringBuffer.cc:
	Fix naming of append(jint).
	* java/sql/Timestamp.h: Regenerated
	using patched gjavah.
	* jni.cc: Rename p to functions
	to match change in GNU Classpath.
	* scripts/makemake.tcl: Switch
	gnu.java.math to BC compilation.
	* sources.am: Regenerated.

2008-08-21  Andrew John Hughes  <gnu_andrew@member.fsf.org>
	
	* Makefile.in: Updated location of Configuration.java.
	* classpath/lib/gnu/java/locale/LocaleData.class: Regenerated.

2008-08-18  Andrew John Hughes  <gnu_andrew@member.fsf.org>
	
	* Makefile.in: Updated with new Java files.
	* classpath/configure: Regenerated.
	* classpath/tools/Makefile.am: Add missing
	use of GJDOC_EX so --disable-gjdoc works.
	* classpath/tools/Makefile.in: Regenerated.

2008-08-15  Matthias Klose  <doko@ubuntu.com>

	Import GNU Classpath (libgcj-import-20080811).

	* Regenerate class and header files.
	* Regenerate auto* files.
	* configure.ac: Don't pass --with-fastjar to classpath, substitute new
	dummy value in classpath/gnu/classpath/Configuration.java.in, pass
	--disable-gjdoc to classpath.
	* scripts/makemake.tcl:
	* sources.am: Regenerated.
	* java/lang/AbstractStringBuffer.java, gnu/java/lang/VMCPStringBuilder.java:
	New, copied from classpath, use System instead of VMSystem.
	* java/lang/StringBuffer.java: Merge from classpath.
	* java/lang/ClassLoader.java: Merge from classpath.
	* gcj/javaprims.h: Update class definitions,
	remove _Jv_jobjectRefType, jobjectRefType definitions.

libjava/classpath/ChangeLog.gcj:

2008-10-21  Matthias Klose  <doko@ubuntu.com>

        * classpath/tools/gnu/classpath/tools/gjdoc/expr/Java*: Move from ...
        * classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/ ... here.
        * Update .class files.
        
2008-10-21  Andrew John Hughes  <gnu_andrew@member.fsf.org>

        * tools/Makefile.am:
        Always generate parser in the srcdir.

2008-10-21  Matthias Klose  <doko@ubuntu.com>

        * doc/Makefile.am (MAINTAINERCLEANFILES): Add gjdoc.1.
        * doc/Makefile.in: Regenerate.

2008-10-20  Matthias Klose  <doko@ubuntu.com>

	* configure.ac: Don't check for working java, if not configured
        with --enable-java-maintainer-mode.
	* configure: Regenerate.

2008-10-19  Matthias Klose  <doko@ubuntu.com>

	* m4/ac_prog_java.m4: Revert previous change.
	* m4/ac_prog_javac.m4: Apply it here.
	* configure: Regenerate.

2008-10-19  Matthias Klose  <doko@ubuntu.com>

	* m4/ac_prog_javac.m4: Don't check for working javac, if not configured
	with --enable-java-maintainer-mode.
	* configure: Regenerate.
	* Makefile.in, */Makefile.in: Regenerate.

2008-09-30  Matthias Klose  <doko@ubuntu.com>

	* m4/ac_prog_antlr.m4: Check for cantlr binary as well.

2008-09-29  Matthias Klose  <doko@ubuntu.com>

	* m4/ac_prog_antlr.m4: Check for antlr binary as well.

2008-09-28  Matthias Klose  <doko@ubuntu.com>

	* PR libgcj/37636. Revert:
	2008-02-20  Matthias Klose  <doko@ubuntu.com>

	* tools/Makefile.am ($(TOOLS_ZIP)): Revert part of previous change,
	Do copy resource files in JAVA_MAINTAINER_MODE only.
	* tools/Makefile.in: Regenerate.

2008-09-14  Matthias Klose  <doko@ubuntu.com>

	* m4/ac_prog_javac_works.m4, m4/ac_prog_javac.m4, m4/acinclude.m4:
	Revert local changes.
	* m4/ac_prog_antlr.m4: Check for an runantlr binary.
	* tools/Makefile.am, lib/Makefile.am: Revert local changes (JCOMPILER).
	* tools/Makefile.am: Remove USE_JAVAC_FLAGS, pass ANTLR_JAR in
	GLIBJ_CLASSPATH.

2008-09-14  Matthias Klose  <doko@ubuntu.com>

	Revert:
	Daniel Frampton  <zyridium at zyridium.net>

	* AUTHORS: Added.
	* java/lang/InheritableThreadLocal.java,
	* java/lang/Thread.java,
	* java/lang/ThreadLocal.java:
	Modified to use java.lang.ThreadLocalMap.
	* java/lang/ThreadLocalMap.java:
	New cheaper ThreadLocal-specific WeakHashMap.

2008-08-15  Matthias Klose  <doko@ubuntu.com>

	* m4/acinclude.m4 (CLASSPATH_JAVAC_MEM_CHECK): Remove unknown
	args for javac.

libjava/classpath/ChangeLog:

2008-10-20  Andrew John Hughes  <gnu_andrew@member.fsf.org>

        * m4/ac_prog_antlr.m4:
        Remove redundant checks.
        * tools/Makefile.am:
        Use gjdoc_gendir when calling antlr.

2008-10-15  Andrew John Hughes  <gnu_andrew@member.fsf.org>

        * configure.ac:
        Remove superfluous AC_PROG_JAVA call.

2008-10-06  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* m4/ac_prog_antlr:
	Check for cantlr as well.
	* tools/Makefile.am:
	Only build GJDoc parser when both
	CREATE_GJDOC and CREATE_GJDOC_PARSER
	are on.
	
2008-10-02  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* configure.ac:
	Add regen-gjdoc-parser option,
	and separate antlr tests.
	* m4/ac_prog_antlr.m4:
	Turn single test into AC_LIB_ANTLR
	and AC_PROG_ANTLR.
	* m4/ac_prog_java.m4:
	Quote tests.
	* tools/Makefile.am:
	Support CREATE_GJDOC_PARSER option.

2008-09-14  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* examples/Makefile.am:
        Check lib directly as well as glibj.zip
        for boot classes.
	* m4/acinclude.m4:
        Only require the class files to be built
        to allow the tools and examples to be built,
        not the installation of glibj.zip.
	* tools/Makefile.am:
	Check lib directly as well as glibj.zip
	for boot classes.

2008-09-13  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* examples/Makefile.am,
	* lib/Makefile.am:
	Add GCJ rules.
	* m4/ac_prog_javac.m4:
	Check whether JAVAC is gcj.
	* m4/ac_prog_javac_works.m4:
	Add GCJ rules.
	* m4/acinclude.m4:
	Don't bother checking for -J
	if using GCJ.
	* tools/Makefile.am:
	Add GCJ rules.

2007-08-23  Daniel Frampton  <zyridium@zyridium.net>

	* AUTHORS: Added.
	* java/lang/InheritableThreadLocal.java,
	* java/lang/Thread.java,
	* java/lang/ThreadLocal.java:
	Modified to use java.lang.ThreadLocalMap.
	* java/lang/ThreadLocalMap.java:
	New cheaper ThreadLocal-specific WeakHashMap.

2008-02-07  Ian Rogers  <ian.rogers@manchester.ac.uk>

	* java/util/zip/ZipEntry.java:
	Use byte fields instead of integer fields,
	store the time as well as the DOS time and
	don't retain a global Calendar instance.
	(setDOSTime(int)): Set KNOWN_DOSTIME instead
	of KNOWN_TIME, and unset KNOWN_TIME.
	(getDOSTime()): Compute DOS time from UNIX time
	only when needed.
	(clone()): Provide cloning via the ZipEntry constructor
	where possible.
	(setTime(long)): Don't compute DOS time at this point.
	(getCalendar()): Removed.
	
2008-09-09  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* tools/gnu/classpath/tools/getopt/Parser.java:
	(setHeader(String)): Make synchronized.
	(setFooter(String)): Likewise.
	* tools/gnu/classpath/tools/rmic/SourceGiopRmicCompiler.java,
	(reset()): Make synchronized.
	(name(Class)): Likewise.
	
2008-09-04  Robert Schuster  <robertschuster@fsfe.org>

	* gnu/java/nio/charset/ByteDecodeLoopHelper:
	(arrayDecodeLoop): Added new break label, escape to that label.
	* gnu/java/nio/charset/ByteEncodeLoopHelper:
	(arrayDecodeLoop): Added new break label, escape to that label.

2008-09-04  Robert Schuster  <robertschuster@fsfe.org>

	* java/text/DecimalFormat.java:
	(scanFix): Use 'i + 1' when looking at following character.
	(scanNegativePattern): Dito.

2008-09-02  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* tools/gnu/classpath/tools/javah/ClassWrapper.java:
	(makeVtable()): Populate methodNameMap.
	(printMethods(CniPrintStream)): Always use pre-populated
	methodNameMap for bridge targets.

2008-09-01  Mario Torre  <neugens@aicas.com>

	* gnu/java/awt/peer/x/XImage.java (XImageProducer): remove @Override
	annotation to allow compilation on javac < 1.6 and ecj < 3.4.

2008-09-01  Mario Torre  <neugens@aicas.com>

	* gnu/java/awt/peer/x/XGraphicsDevice.java (getDisplay): fix to support
	new Escher API.
	* gnu/java/awt/peer/x/XImage.java (getSource): method implemented.
	* gnu/java/awt/peer/x/XImage.java (XImageProducer): implement ImageProducer
	for getSource.
	 
2008-09-01  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* gnu/java/util/regex/BacktrackStack.java,
	* gnu/java/util/regex/CharIndexed.java,
	* gnu/java/util/regex/CharIndexedCharArray.java,
	* gnu/java/util/regex/CharIndexedCharSequence.java,
	* gnu/java/util/regex/CharIndexedInputStream.java,
	* gnu/java/util/regex/CharIndexedString.java,
	* gnu/java/util/regex/CharIndexedStringBuffer.java,
	* gnu/java/util/regex/RE.java,
	* gnu/java/util/regex/REException.java,
	* gnu/java/util/regex/REFilterInputStream.java,
	* gnu/java/util/regex/REMatch.java,
	* gnu/java/util/regex/REMatchEnumeration.java,
	* gnu/java/util/regex/RESyntax.java,
	* gnu/java/util/regex/REToken.java,
	* gnu/java/util/regex/RETokenAny.java,
	* gnu/java/util/regex/RETokenBackRef.java,
	* gnu/java/util/regex/RETokenChar.java,
	* gnu/java/util/regex/RETokenEnd.java,
	* gnu/java/util/regex/RETokenEndOfPreviousMatch.java,
	* gnu/java/util/regex/RETokenEndSub.java,
	* gnu/java/util/regex/RETokenIndependent.java,
	* gnu/java/util/regex/RETokenLookAhead.java,
	* gnu/java/util/regex/RETokenLookBehind.java,
	* gnu/java/util/regex/RETokenNamedProperty.java,
	* gnu/java/util/regex/RETokenOneOf.java,
	* gnu/java/util/regex/RETokenPOSIX.java,
	* gnu/java/util/regex/RETokenRange.java,
	* gnu/java/util/regex/RETokenRepeated.java,
	* gnu/java/util/regex/RETokenStart.java,
	* gnu/java/util/regex/RETokenWordBoundary.java,
	* gnu/java/util/regex/UncheckedRE.java:
	Fix indentation.

2008-09-01  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* gnu/java/util/regex/RETokenStart.java:
	(getMaximumLength()): Add Override annotation.
	(matchThis(CharIndexed, REMatch)): Likewise.
	(returnsFixedLengthMatches()): Renamed from
	returnsFixedLengthmatches and added Override
	annotation.
	(findFixedLengthMatches(CharIndexed,REMatch,int)):
	Add Override annotation.
	(dump(CPStringBuilder)): Likewise.
	* gnu/javax/print/ipp/IppRequest.java:
	(RequestWriter.writeOperationAttributes(AttributeSet)):
	Throw exception, don't just create and drop it.
	* javax/management/MBeanServerPermission.java:
	(MBeanServerPermissionCollection.add(Permission)): Compare
	against individual Strings not the entire array, and
	store the result of replace.
	* javax/swing/text/html/StyleSheet.java:
	(setBaseFontSize(size)): Store result of trim().

2008-09-01  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* javax/tools/FileObject.java:
	(openReader(boolean)): Document new parameter.
	
2008-03-27  Michael Franz  <mvfranz@gmail.com>

	PR classpath/35690:
	* javax/tools/FileObject.java:
	(toUri()): Fix case from toURI.
	(openReader(boolean)): Add missing boolean argument.
	
2008-08-26  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	PR classpath/35487:
	* gnu/javax/management/Server.java:
	(beans): Change to ConcurrentHashMap.
	(defaultDomain): Make final.
	(outer): Likewise.
	(LazyListenersHolder): Added to wrap
	listeners, also now a ConcurrentHashMap,
	providing lazy initialisation safely.
	(sequenceNumber): Documented.
	(getBean(ObjectName)): Remove redundant cast.
	(addNotificationListener(ObjectName,NotificationListener,
	NotificationFilter,Object)): Remove map initialisation
	and use holder.
	(getObjectInstance(ObjectName)): Remove redundant cast.
	(registerMBean(Object,ObjectName)): Add bean atomically.
	(removeNotificationListener(ObjectName,NotificationListener)):
	Simplified.
	(removeNotificationListener(ObjectName,NotificationListener,
	NotificationFilter,Object)): Likewise.
	(notify(ObjectName,String)): Documented.
	
2008-08-26  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* gnu/javax/management/Server.java:
	Genericised.

2008-08-26  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* gnu/javax/management/Translator.java:
	Genericised.

2008-08-26  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* javax/management/DefaultLoaderRepository.java,
	* javax/management/JMX.java,
	* javax/management/MBeanAttributeInfo.java,
	* javax/management/MBeanConstructorInfo.java,
	* javax/management/MBeanOperationInfo.java,
	* javax/management/MBeanServerDelegate.java:
	Fix warnings due to generics.

2008-08-25  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* javax/management/MBeanPermission.java,
	* javax/management/MBeanServerDelegate.java,
	* javax/management/MBeanServerFactory.java,
	* javax/management/MBeanServerInvocationHandler.java,
	* javax/management/MBeanServerPermission.java:
	Fix warnings due to use of non-generic collections.

2008-08-25  Mario Torre  <neugens@aicas.com>

	* gnu/javax/rmi/CORBA/RmiUtilities.java (readValue): check if sender is
	null to avoid NPE.
	
2008-08-22  Mario Torre  <neugens@aicas.com>
 
	* gnu/CORBA/OrbFunctional.java (set_parameters): Fix
	NullPointerException checking when param is null. 

2008-08-23  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* java/util/regex/Matcher.java:
	(reset()): Reset append position so
	we don't try and append to the end of
	the old input.
	
2008-08-22  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	PR classpath/32028:
	* m4/acinclude.m4:
	Also allow versions of GJDoc from 0.8* on, as
	CVS is 0.8.0-pre.
	
2008-08-21  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	PR classpath/32028:
	* m4/acinclude.m4:
	(CLASSPATH_WITH_GJDOC): Ensure version 0.7.9 is
	being used.
	
2008-08-20  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* tools/Makefile.am:
	Add taglets subdirectory to list of excluded
	paths when GJDoc is not compiled.
	
2008-08-19  David P Grove  <groved@us.ibm.com>

	* scripts/check_jni_methods.sh.in:
	Fix build issue on AIX by splitting generation
	of method list.
	
2008-08-18  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* native/jni/gstreamer-peer/gst_native_pipeline.c:
	(get_free_space(int)): Use #else not #elif when
	there is no condition.

2008-08-17  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	PR classpath/31895:
	* java/text/DecimalFormat.java:
	(setCurrency(Currency)): Update prefixes and
	suffixes when currency changes.
	* java/text/DecimalFormatSymbols.java:
	(DecimalFormatSymbols(Locale)): Set locale earlier
	so it can be used by setCurrency(Currency).
	(setCurrency(Currency)): Set the symbol correctly using
	the locale of the instance.
	* java/util/Currency.java:
	Throw error instead of just printing a message.

2008-08-17  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* javax/activation/ActivationDataFlavor.java:
	Suppress warnings from public API.
	(mimeType): Made final.
	(representationClass): Added generic type and
	made final.
	(normalizeMimeTypeParameter(String,String)):
	Use CPStringBuilder.
	* javax/activation/CommandInfo.java:
	(verb): Made final.
	(className): Made final.
	* javax/activation/DataHandler.java:
	(dataSource): Made final.
	* javax/activation/FileDataSource.java:
	(file): Made final.
	* javax/activation/MailcapCommandMap.java:
	Use generics on collections and CPStringBuilder
	instead of StringBuffer.
	* javax/activation/MimeType.java:
	(toString()): Use CPStringBuilder.
	(getBaseType()): Likewise.
	* javax/activation/MimeTypeParameterList.java:
	Use generics on collections and CPStringBuilder
	instead of StringBuffer.
	* javax/activation/MimeTypeParseException.java:
	(MimeTypeParseException(String,String)): Use
	CPStringBuilder.
	* javax/activation/MimetypesFileTypeMap.java:
	Use generics on collections and CPStringBuilder
	instead of StringBuffer.	
	* javax/activation/URLDataSource.java:
	(url): Made final.

2008-08-17  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* gnu/javax/activation/viewers/ImageViewer.java,
	* gnu/javax/activation/viewers/TextEditor.java,
	* gnu/javax/activation/viewers/TextViewer.java,
	* javax/activation/ActivationDataFlavor.java,
	* javax/activation/CommandInfo.java,
	* javax/activation/CommandMap.java,
	* javax/activation/CommandObject.java,
	* javax/activation/DataContentHandler.java,
	* javax/activation/DataContentHandlerFactory.java,
	* javax/activation/DataHandler.java,
	* javax/activation/DataHandlerDataSource.java,
	* javax/activation/DataSource.java,
	* javax/activation/DataSourceDataContentHandler.java,
	* javax/activation/FileDataSource.java,
	* javax/activation/FileTypeMap.java,
	* javax/activation/MailcapCommandMap.java,
	* javax/activation/MimeType.java,
	* javax/activation/MimeTypeParameterList.java,
	* javax/activation/MimeTypeParseException.java,
	* javax/activation/MimetypesFileTypeMap.java,
	* javax/activation/ObjectDataContentHandler.java,
	* javax/activation/URLDataSource.java,
	* javax/activation/UnsupportedDataTypeException.java,
	* javax/activation/package.html,
	* resource/META-INF/mailcap.default,
	* resource/META-INF/mimetypes.default:
	Import GNU JAF CVS as of 17/08/2008.

2006-04-25  Archit Shah  <ashah@redhat.com>

	* javax/activation/MimeTypeParameterList.java:
	Insert ';' separator before parameter list.

2005-06-29  Xavier Poinsard  <xpoinsard@openpricer.com>

	* javax/activation/ObjectDataContentHandler.java:
	Fixed typo.

2005-05-28  Chris Burdess  <dog@bluezoo.org>

	* javax/activation/CommandMap.java, 
	* javax/activation/MailcapCommandMap.java:
	Updated to JAF 1.1.

2004-06-09  Chris Burdess  <dog@bluezoo.org>

	* javax/activation/MailcapCommandMap.java:
	Fixed bug whereby x-java prefix was not
	attempted.

2008-08-17  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* AUTHORS: Added Laszlo.

2008-04-20  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	PR classpath/30436:
	* java/util/Scanner.java:
	Fix package to be java.util and correct
	indentation.

2007-07-25  Laszlo Andras Hernadi  <e0327023@student.tuwien.ac.at>

	PR classpath/30436:
	* java/util/Scanner.java:
	Initial implementation.

2008-08-17  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* java/util/regex/Matcher.java:
	(toMatchResult()): Implemented.
	
2008-08-13  Joshua Sumali  <jsumali@redhat.com>

	* doc/Makefile.am (gjdoc.pod): Generate gjdoc pod from cp-tools.texinfo
	instead of invoke.texi. Remove invoke.texi from EXTRA_DIST.
	* doc/invoke.texi: Removed and merged into ...
	* doc/cp-tools.texinfo: Here

2008-08-12  Robert Schuster  <robertschuster@fsfe.org>

	* native/jni/java-net/local.c
	(local_bind): Removed fprintf call, fixed access outside
	of array bounds.

From-SVN: r141271
This commit is contained in:
Matthias Klose
2008-10-21 17:55:01 +00:00
parent d9cc481a35
commit cd6d4007aa
2325 changed files with 121399 additions and 23635 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libjava/classpath/gnu/java/util/regex/BacktrackStack.java
+63 -51
View File
@@ -44,69 +44,81 @@ package gnu.java.util.regex;
*
* @author Ito Kazumitsu</A>
*/
final class BacktrackStack {
final class BacktrackStack
{
/** A set of data to be used for backtracking. */
static class Backtrack {
/** REToken to which to go back */
REToken token;
static class Backtrack
{
/** REToken to which to go back */
REToken token;
/** CharIndexed on which matches are being searched for. */
CharIndexed input;
CharIndexed input;
/** REMatch to be used by the REToken token. */
REMatch match;
REMatch match;
/** Some parameter used by the token's backtrack method. */
Object param;
Backtrack(REToken token, CharIndexed input, REMatch match, Object param) {
this.token = token;
this.input = input;
// REMatch may change before backtracking is needed. So we
// keep a clone of it.
this.match = (REMatch) match.clone();
this.param = param;
}
Object param;
Backtrack (REToken token, CharIndexed input, REMatch match,
Object param)
{
this.token = token;
this.input = input;
// REMatch may change before backtracking is needed. So we
// keep a clone of it.
this.match = (REMatch) match.clone ();
this.param = param;
}
}
Backtrack[] stack;
private int size;
private int capacity;
private static final int INITIAL_CAPACITY = 32;
private static final int CAPACITY_INCREMENT = 16;
Backtrack[] stack;
private int size;
private int capacity;
private static final int INITIAL_CAPACITY = 32;
private static final int CAPACITY_INCREMENT = 16;
BacktrackStack() {
stack = new Backtrack[INITIAL_CAPACITY];
size = 0;
capacity = INITIAL_CAPACITY;
}
BacktrackStack ()
{
stack = new Backtrack[INITIAL_CAPACITY];
size = 0;
capacity = INITIAL_CAPACITY;
}
boolean empty() {
return size == 0;
}
boolean empty ()
{
return size == 0;
}
Backtrack peek() {
return stack[size - 1];
}
Backtrack peek ()
{
return stack[size - 1];
}
Backtrack pop() {
Backtrack bt = stack[--size];
stack[size] = null;
return bt;
}
Backtrack pop ()
{
Backtrack bt = stack[--size];
stack[size] = null;
return bt;
}
void clear() {
for (int i = 0; i < size; i++) {
stack[i] = null;
}
size = 0;
}
void clear ()
{
for (int i = 0; i < size; i++)
{
stack[i] = null;
}
size = 0;
}
void push(Backtrack bt) {
if (size >= capacity) {
capacity += CAPACITY_INCREMENT;
Backtrack[] newStack = new Backtrack[capacity];
System.arraycopy(stack, 0, newStack, 0, size);
stack = newStack;
}
stack[size++] = bt;
}
void push (Backtrack bt)
{
if (size >= capacity)
{
capacity += CAPACITY_INCREMENT;
Backtrack[]newStack = new Backtrack[capacity];
System.arraycopy (stack, 0, newStack, 0, size);
stack = newStack;
}
stack[size++] = bt;
}
}
libjava/classpath/gnu/java/util/regex/CharIndexed.java
+15 -14
View File
@@ -48,13 +48,14 @@ package gnu.java.util.regex;
*
* @author <A HREF="mailto:wes@cacas.org">Wes Biggs</A>
*/
public interface CharIndexed {
public interface CharIndexed
{
/**
* Defines a constant (0xFFFF was somewhat arbitrarily chosen)
* that can be returned by the charAt() function indicating that
* the specified index is out of range.
*/
char OUT_OF_BOUNDS = '\uFFFF';
char OUT_OF_BOUNDS = '\uFFFF';
/**
* Returns the character at the given offset past the current cursor
@@ -68,66 +69,66 @@ public interface CharIndexed {
* @return the character at the specified index, or the OUT_OF_BOUNDS
* character defined by this interface.
*/
char charAt(int index);
char charAt (int index);
/**
* Shifts the input buffer by a given number of positions. Returns
* true if the new cursor position is valid.
*/
boolean move(int index);
boolean move (int index);
/**
* Shifts the input buffer by a given number of positions. Returns
* true if the new cursor position is valid or cursor position is at
* the end of input.
*/
boolean move1(int index); // I cannot think of a better name for this.
boolean move1 (int index); // I cannot think of a better name for this.
/**
* Returns true if the most recent move() operation placed the cursor
* position at a valid position in the input.
*/
boolean isValid();
boolean isValid ();
/**
* Returns another CharIndexed containing length characters to the left
* of the given index. The given length is an expected maximum and
* the returned CharIndexed may not necessarily contain so many characters.
*/
CharIndexed lookBehind(int index, int length);
CharIndexed lookBehind (int index, int length);
/**
* Returns the effective length of this CharIndexed
*/
int length();
int length ();
/**
* Sets the REMatch last found on this input.
*/
void setLastMatch(REMatch match);
void setLastMatch (REMatch match);
/**
* Returns the REMatch last found on this input.
*/
REMatch getLastMatch();
REMatch getLastMatch ();
/**
* Sets the information used for hitEnd().
*/
void setHitEnd(REMatch match);
void setHitEnd (REMatch match);
/**
* Returns whether the matcher has hit the end of input.
*/
boolean hitEnd();
boolean hitEnd ();
/**
* Returns the anchor.
*/
int getAnchor();
int getAnchor ();
/**
* Sets the anchor.
*/
void setAnchor(int anchor);
void setAnchor (int anchor);
}
libjava/classpath/gnu/java/util/regex/CharIndexedCharArray.java
+7 -5
View File
@@ -38,9 +38,11 @@ exception statement from your version. */
package gnu.java.util.regex;
import java.nio.CharBuffer;
class CharIndexedCharArray extends CharIndexedCharSequence {
CharIndexedCharArray(char[] str, int index) {
super(CharBuffer.wrap(str), index);
}
class CharIndexedCharArray extends CharIndexedCharSequence
{
CharIndexedCharArray (char[]str, int index)
{
super (CharBuffer.wrap (str), index);
}
}
libjava/classpath/gnu/java/util/regex/CharIndexedCharSequence.java
+70 -46
View File
@@ -38,58 +38,82 @@ exception statement from your version. */
package gnu.java.util.regex;
import java.io.Serializable;
class CharIndexedCharSequence implements CharIndexed, Serializable {
private CharSequence s;
private int anchor;
private int len;
CharIndexedCharSequence(CharSequence s, int index) {
this.s = s;
len = s.length();
anchor = index;
}
class CharIndexedCharSequence implements CharIndexed, Serializable
{
private CharSequence s;
private int anchor;
private int len;
public char charAt(int index) {
int pos = anchor + index;
return ((pos < len) && (pos >= 0)) ? s.charAt(pos) : OUT_OF_BOUNDS;
}
public boolean isValid() {
return (anchor < len);
}
public boolean move(int index) {
return ((anchor += index) < len);
}
CharIndexedCharSequence (CharSequence s, int index)
{
this.s = s;
len = s.length ();
anchor = index;
}
public boolean move1(int index) {
return ((anchor += index) <= len);
}
public char charAt (int index)
{
int pos = anchor + index;
return ((pos < len) && (pos >= 0)) ? s.charAt (pos) : OUT_OF_BOUNDS;
}
public CharIndexed lookBehind(int index, int length) {
if (length > (anchor + index)) length = anchor + index;
return new CharIndexedCharSequence(s, anchor + index - length);
}
public boolean isValid ()
{
return (anchor < len);
}
public int length() {
return len - anchor;
}
public boolean move (int index)
{
return ((anchor += index) < len);
}
private REMatch lastMatch;
public void setLastMatch(REMatch match) {
lastMatch = (REMatch)match.clone();
lastMatch.anchor = anchor;
}
public REMatch getLastMatch() { return lastMatch; }
public boolean move1 (int index)
{
return ((anchor += index) <= len);
}
private int rightmostTriedPosition = 0;
public void setHitEnd(REMatch match) {
int pos = anchor + match.index;
if (pos > rightmostTriedPosition) rightmostTriedPosition = pos;
}
public boolean hitEnd() { return rightmostTriedPosition >= len; }
public CharIndexed lookBehind (int index, int length)
{
if (length > (anchor + index))
length = anchor + index;
return new CharIndexedCharSequence (s, anchor + index - length);
}
public int getAnchor() { return anchor; }
public void setAnchor(int anchor) { this.anchor = anchor; }
public int length ()
{
return len - anchor;
}
private REMatch lastMatch;
public void setLastMatch (REMatch match)
{
lastMatch = (REMatch) match.clone ();
lastMatch.anchor = anchor;
}
public REMatch getLastMatch ()
{
return lastMatch;
}
private int rightmostTriedPosition = 0;
public void setHitEnd (REMatch match)
{
int pos = anchor + match.index;
if (pos > rightmostTriedPosition)
rightmostTriedPosition = pos;
}
public boolean hitEnd ()
{
return rightmostTriedPosition >= len;
}
public int getAnchor ()
{
return anchor;
}
public void setAnchor (int anchor)
{
this.anchor = anchor;
}
}
libjava/classpath/gnu/java/util/regex/CharIndexedInputStream.java
+188 -130
View File
@@ -42,154 +42,212 @@ import java.io.InputStream;
// TODO: move(x) shouldn't rely on calling next() x times
class CharIndexedInputStream implements CharIndexed {
private static final int BUFFER_INCREMENT = 1024;
private static final int UNKNOWN = Integer.MAX_VALUE; // value for end
private BufferedInputStream br;
class CharIndexedInputStream implements CharIndexed
{
private static final int BUFFER_INCREMENT = 1024;
private static final int UNKNOWN = Integer.MAX_VALUE; // value for end
// so that we don't try to reset() right away
private int index = -1;
private BufferedInputStream br;
private int bufsize = BUFFER_INCREMENT;
// so that we don't try to reset() right away
private int index = -1;
private int end = UNKNOWN;
private int bufsize = BUFFER_INCREMENT;
private char cached = OUT_OF_BOUNDS;
private int end = UNKNOWN;
// Big enough for a \r\n pair
// lookBehind[0] = most recent
// lookBehind[1] = second most recent
private char[] lookBehind = new char[] { OUT_OF_BOUNDS, OUT_OF_BOUNDS };
CharIndexedInputStream(InputStream str, int index) {
if (str instanceof BufferedInputStream) br = (BufferedInputStream) str;
else br = new BufferedInputStream(str,BUFFER_INCREMENT);
next();
if (index > 0) move(index);
}
private boolean next() {
if (end == 1) return false;
end--; // closer to end
private char cached = OUT_OF_BOUNDS;
try {
if (index != -1) {
br.reset();
}
int i = br.read();
br.mark(bufsize);
if (i == -1) {
end = 1;
cached = OUT_OF_BOUNDS;
return false;
}
cached = (char) i;
index = 1;
} catch (IOException e) {
e.printStackTrace();
cached = OUT_OF_BOUNDS;
return false;
// Big enough for a \r\n pair
// lookBehind[0] = most recent
// lookBehind[1] = second most recent
private char[] lookBehind = new char[]{ OUT_OF_BOUNDS, OUT_OF_BOUNDS };
CharIndexedInputStream (InputStream str, int index)
{
if (str instanceof BufferedInputStream)
br = (BufferedInputStream) str;
else
br = new BufferedInputStream (str, BUFFER_INCREMENT);
next ();
if (index > 0)
move (index);
}
private boolean next ()
{
if (end == 1)
return false;
end--; // closer to end
try
{
if (index != -1)
{
br.reset ();
}
return true;
}
public char charAt(int index) {
if (index == 0) {
return cached;
} else if (index >= end) {
return OUT_OF_BOUNDS;
} else if (index == -1) {
return lookBehind[0];
} else if (index == -2) {
return lookBehind[1];
} else if (index < -2) {
return OUT_OF_BOUNDS;
} else if (index >= bufsize) {
// Allocate more space in the buffer.
try {
while (bufsize <= index) bufsize += BUFFER_INCREMENT;
br.reset();
br.mark(bufsize);
br.skip(index-1);
} catch (IOException e) { }
} else if (this.index != index) {
try {
br.reset();
br.skip(index-1);
} catch (IOException e) { }
int i = br.read ();
br.mark (bufsize);
if (i == -1)
{
end = 1;
cached = OUT_OF_BOUNDS;
return false;
}
char ch = OUT_OF_BOUNDS;
try {
int i = br.read();
this.index = index+1; // this.index is index of next pos relative to charAt(0)
if (i == -1) {
// set flag that next should fail next time?
end = index;
return ch;
}
ch = (char) i;
} catch (IOException ie) { }
return ch;
cached = (char) i;
index = 1;
} catch (IOException e)
{
e.printStackTrace ();
cached = OUT_OF_BOUNDS;
return false;
}
public boolean move(int index) {
// move read position [index] clicks from 'charAt(0)'
boolean retval = true;
while (retval && (index-- > 0)) retval = next();
return retval;
}
public boolean isValid() {
return (cached != OUT_OF_BOUNDS);
return true;
}
public char charAt (int index)
{
if (index == 0)
{
return cached;
}
else if (index >= end)
{
return OUT_OF_BOUNDS;
}
else if (index == -1)
{
return lookBehind[0];
}
else if (index == -2)
{
return lookBehind[1];
}
else if (index < -2)
{
return OUT_OF_BOUNDS;
}
else if (index >= bufsize)
{
// Allocate more space in the buffer.
try
{
while (bufsize <= index)
bufsize += BUFFER_INCREMENT;
br.reset ();
br.mark (bufsize);
br.skip (index - 1);
}
catch (IOException e)
{
}
}
else if (this.index != index)
{
try
{
br.reset ();
br.skip (index - 1);
}
catch (IOException e)
{
}
}
char ch = OUT_OF_BOUNDS;
try
{
int i = br.read ();
this.index = index + 1; // this.index is index of next pos relative to charAt(0)
if (i == -1)
{
// set flag that next should fail next time?
end = index;
return ch;
}
ch = (char) i;
} catch (IOException ie)
{
}
public CharIndexed lookBehind(int index, int length) {
throw new UnsupportedOperationException(
"difficult to look behind for an input stream");
}
return ch;
}
public int length() {
throw new UnsupportedOperationException(
"difficult to tell the length for an input stream");
}
public boolean move (int index)
{
// move read position [index] clicks from 'charAt(0)'
boolean retval = true;
while (retval && (index-- > 0))
retval = next ();
return retval;
}
public void setLastMatch(REMatch match) {
throw new UnsupportedOperationException(
"difficult to support setLastMatch for an input stream");
}
public boolean isValid ()
{
return (cached != OUT_OF_BOUNDS);
}
public REMatch getLastMatch() {
throw new UnsupportedOperationException(
"difficult to support getLastMatch for an input stream");
}
public CharIndexed lookBehind (int index, int length)
{
throw new
UnsupportedOperationException
("difficult to look behind for an input stream");
}
public void setHitEnd(REMatch match) {
throw new UnsupportedOperationException(
"difficult to support setHitEnd for an input stream");
}
public int length ()
{
throw new
UnsupportedOperationException
("difficult to tell the length for an input stream");
}
public boolean hitEnd() {
throw new UnsupportedOperationException(
"difficult to support hitEnd for an input stream");
}
public void setLastMatch (REMatch match)
{
throw new
UnsupportedOperationException
("difficult to support setLastMatch for an input stream");
}
public int getAnchor() {
throw new UnsupportedOperationException(
"difficult to support getAnchor for an input stream");
}
public REMatch getLastMatch ()
{
throw new
UnsupportedOperationException
("difficult to support getLastMatch for an input stream");
}
public void setAnchor(int anchor) {
throw new UnsupportedOperationException(
"difficult to support setAnchor for an input stream");
}
public void setHitEnd (REMatch match)
{
throw new
UnsupportedOperationException
("difficult to support setHitEnd for an input stream");
}
public boolean move1(int index) {
throw new UnsupportedOperationException(
"difficult to support move1 for an input stream");
}
public boolean hitEnd ()
{
throw new
UnsupportedOperationException
("difficult to support hitEnd for an input stream");
}
public int getAnchor ()
{
throw new
UnsupportedOperationException
("difficult to support getAnchor for an input stream");
}
public void setAnchor (int anchor)
{
throw new
UnsupportedOperationException
("difficult to support setAnchor for an input stream");
}
public boolean move1 (int index)
{
throw new
UnsupportedOperationException
("difficult to support move1 for an input stream");
}
}
libjava/classpath/gnu/java/util/regex/CharIndexedString.java
+6 -4
View File
@@ -37,8 +37,10 @@ exception statement from your version. */
package gnu.java.util.regex;
class CharIndexedString extends CharIndexedCharSequence {
CharIndexedString(String str, int index) {
super(str, index);
}
class CharIndexedString extends CharIndexedCharSequence
{
CharIndexedString (String str, int index)
{
super (str, index);
}
}
libjava/classpath/gnu/java/util/regex/CharIndexedStringBuffer.java
+6 -4
View File
@@ -37,9 +37,11 @@ exception statement from your version. */
package gnu.java.util.regex;
class CharIndexedStringBuffer extends CharIndexedCharSequence {
class CharIndexedStringBuffer extends CharIndexedCharSequence
{
CharIndexedStringBuffer(StringBuffer str, int index) {
super(str, index);
}
CharIndexedStringBuffer (StringBuffer str, int index)
{
super (str, index);
}
}
libjava/classpath/gnu/java/util/regex/RE.java
+1822 -1300
View File
File diff suppressed because it is too large Load Diff
libjava/classpath/gnu/java/util/regex/REException.java
+38 -28
View File
@@ -37,6 +37,8 @@ exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
import java.text.MessageFormat;
/**
@@ -53,7 +55,8 @@ import java.text.MessageFormat;
* @author <A HREF="mailto:wes@cacas.org">Wes Biggs</A>
*/
public class REException extends Exception {
public class REException extends Exception
{
private int type;
private int pos;
@@ -64,25 +67,25 @@ public class REException extends Exception {
* Invalid use of repetition operators such as using
* `*' as the first character.
*/
public static final int REG_BADRPT = 1;
public static final int REG_BADRPT = 1;
/**
* Error flag.
* Invalid use of back reference operator.
*/
public static final int REG_BADBR = 2;
public static final int REG_BADBR = 2;
/**
* Error flag.
* Un-matched brace interval operators.
*/
public static final int REG_EBRACE = 3;
public static final int REG_EBRACE = 3;
/**
* Error flag.
* Un-matched bracket list operators.
*/
public static final int REG_EBRACK = 4;
public static final int REG_EBRACK = 4;
/**
* Error flag.
@@ -90,65 +93,67 @@ public class REException extends Exception {
* point of the range occurs prior to the starting
* point.
*/
public static final int REG_ERANGE = 5;
public static final int REG_ERANGE = 5;
/**
* Error flag.
* Unknown character class name. <B>Not implemented</B>.
*/
public static final int REG_ECTYPE = 6;
public static final int REG_ECTYPE = 6;
/**
* Error flag.
* Un-matched parenthesis group operators.
*/
public static final int REG_EPAREN = 7;
public static final int REG_EPAREN = 7;
/**
* Error flag.
* Invalid back reference to a subexpression.
*/
public static final int REG_ESUBREG = 8;
public static final int REG_ESUBREG = 8;
/**
* Error flag.
* Non specific error. <B>Not implemented</B>.
*/
public static final int REG_EEND = 9;
public static final int REG_EEND = 9;
/**
* Error flag.
* Invalid escape sequence. <B>Not implemented</B>.
*/
public static final int REG_ESCAPE = 10;
public static final int REG_ESCAPE = 10;
/**
* Error flag.
* Invalid use of pattern operators such as group or list.
*/
public static final int REG_BADPAT = 11;
public static final int REG_BADPAT = 11;
/**
* Error flag.
* Compiled regular expression requires a pattern
* buffer larger than 64Kb. <B>Not implemented</B>.
*/
public static final int REG_ESIZE = 12;
public static final int REG_ESIZE = 12;
/**
* Error flag.
* The regex routines ran out of memory. <B>Not implemented</B>.
*/
public static final int REG_ESPACE = 13;
public static final int REG_ESPACE = 13;
REException(String msg, int type, int position) {
super(msg);
REException (String msg, int type, int position)
{
super (msg);
this.type = type;
this.pos = position;
}
REException(String msg, Throwable cause, int type, int position) {
super(msg, cause);
REException (String msg, Throwable cause, int type, int position)
{
super (msg, cause);
this.type = type;
this.pos = position;
}
@@ -157,7 +162,8 @@ public class REException extends Exception {
* Returns the type of the exception, one of the constants listed above.
*/
public int getType() {
public int getType ()
{
return type;
}
@@ -167,7 +173,8 @@ public class REException extends Exception {
* where the error was detected, not necessarily the starting index of
* a bad subexpression.
*/
public int getPosition() {
public int getPosition ()
{
return pos;
}
@@ -176,13 +183,16 @@ public class REException extends Exception {
* as well as its index position in the string or character array
* being compiled.
*/
public String getMessage() {
Object[] args = {new Integer(pos)};
StringBuffer sb = new StringBuffer();
String prefix = RE.getLocalizedMessage("error.prefix");
sb.append(MessageFormat.format(prefix, args));
sb.append('\n');
sb.append(super.getMessage());
return sb.toString();
public String getMessage ()
{
Object[]args =
{
new Integer (pos)};
CPStringBuilder sb = new CPStringBuilder ();
String prefix = RE.getLocalizedMessage ("error.prefix");
sb.append (MessageFormat.format (prefix, args));
sb.append ('\n');
sb.append (super.getMessage ());
return sb.toString ();
}
}
libjava/classpath/gnu/java/util/regex/REFilterInputStream.java
+53 -40
View File
@@ -51,14 +51,15 @@ import java.io.InputStream;
* class instead.
*/
public class REFilterInputStream extends FilterInputStream {
public class REFilterInputStream extends FilterInputStream
{
private RE expr;
private String replace;
private String buffer;
private int bufpos;
private int offset;
private CharIndexedInputStream stream;
private RE expr;
private String replace;
private String buffer;
private int bufpos;
private int offset;
private CharIndexedInputStream stream;
/**
* Creates an REFilterInputStream. When reading from this stream,
@@ -71,9 +72,10 @@ public class REFilterInputStream extends FilterInputStream {
* @param expr The regular expression to search for.
* @param replace The text pattern to replace matches with.
*/
public REFilterInputStream(InputStream stream, RE expr, String replace) {
super(stream);
this.stream = new CharIndexedInputStream(stream,0);
public REFilterInputStream (InputStream stream, RE expr, String replace)
{
super (stream);
this.stream = new CharIndexedInputStream (stream, 0);
this.expr = expr;
this.replace = replace;
}
@@ -82,32 +84,38 @@ public class REFilterInputStream extends FilterInputStream {
* Reads the next byte from the stream per the general contract of
* InputStream.read(). Returns -1 on error or end of stream.
*/
public int read() {
public int read ()
{
// If we have buffered replace data, use it.
if ((buffer != null) && (bufpos < buffer.length())) {
return (int) buffer.charAt(bufpos++);
}
if ((buffer != null) && (bufpos < buffer.length ()))
{
return (int) buffer.charAt (bufpos++);
}
// check if input is at a valid position
if (!stream.isValid()) return -1;
if (!stream.isValid ())
return -1;
REMatch mymatch = new REMatch(expr.getNumSubs(),offset,0);
if (expr.match(stream, mymatch)) {
mymatch.end[0] = mymatch.index;
mymatch.finish(stream);
stream.move(mymatch.toString().length());
offset += mymatch.toString().length();
buffer = mymatch.substituteInto(replace);
bufpos = 1;
REMatch mymatch = new REMatch (expr.getNumSubs (), offset, 0);
if (expr.match (stream, mymatch))
{
mymatch.end[0] = mymatch.index;
mymatch.finish (stream);
stream.move (mymatch.toString ().length ());
offset += mymatch.toString ().length ();
buffer = mymatch.substituteInto (replace);
bufpos = 1;
// This is prone to infinite loops if replace string turns out empty.
if (buffer.length() > 0) {
return buffer.charAt(0);
// This is prone to infinite loops if replace string turns out empty.
if (buffer.length () > 0)
{
return buffer.charAt (0);
}
}
}
char ch = stream.charAt(0);
if (ch == CharIndexed.OUT_OF_BOUNDS) return -1;
stream.move(1);
char ch = stream.charAt (0);
if (ch == CharIndexed.OUT_OF_BOUNDS)
return -1;
stream.move (1);
offset++;
return ch;
}
@@ -116,25 +124,30 @@ public class REFilterInputStream extends FilterInputStream {
* Returns false. REFilterInputStream does not support mark() and
* reset() methods.
*/
public boolean markSupported() {
public boolean markSupported ()
{
return false;
}
/** Reads from the stream into the provided array. */
public int read(byte[] b, int off, int len) {
public int read (byte[]b, int off, int len)
{
int i;
int ok = 0;
while (len-- > 0) {
i = read();
if (i == -1) return (ok == 0) ? -1 : ok;
b[off++] = (byte) i;
ok++;
}
while (len-- > 0)
{
i = read ();
if (i == -1)
return (ok == 0) ? -1 : ok;
b[off++] = (byte) i;
ok++;
}
return ok;
}
/** Reads from the stream into the provided array. */
public int read(byte[] b) {
return read(b,0,b.length);
public int read (byte[]b)
{
return read (b, 0, b.length);
}
}
libjava/classpath/gnu/java/util/regex/REMatch.java
+201 -163
View File
@@ -37,6 +37,9 @@ exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
import java.io.Serializable;
/**
@@ -47,100 +50,112 @@ import java.io.Serializable;
*
* @author <A HREF="mailto:wes@cacas.org">Wes Biggs</A>
*/
public final class REMatch implements Serializable, Cloneable {
private String matchedText;
private CharIndexed matchedCharIndexed;
public final class REMatch implements Serializable, Cloneable
{
private String matchedText;
private CharIndexed matchedCharIndexed;
// These variables are package scope for fast access within the engine
int eflags; // execution flags this match was made using
// These variables are package scope for fast access within the engine
int eflags; // execution flags this match was made using
// Offset in source text where match was tried. This is zero-based;
// the actual position in the source text is given by (offset + anchor).
int offset;
// Offset in source text where match was tried. This is zero-based;
// the actual position in the source text is given by (offset + anchor).
int offset;
// Anchor position refers to the index into the source input
// at which the matching operation began.
// This is also useful for the ANCHORINDEX option.
int anchor;
// Anchor position refers to the index into the source input
// at which the matching operation began.
// This is also useful for the ANCHORINDEX option.
int anchor;
// Package scope; used by RE.
int index; // used while matching to mark current match position in input
// start1[i] is set when the i-th subexp starts. And start1[i] is copied
// to start[i] when the i-th subexp ends. So start[i] keeps the previously
// assigned value while the i-th subexp is being processed. This makes
// backreference to the i-th subexp within the i-th subexp possible.
int[] start; // start positions (relative to offset) for each (sub)exp.
int[] start1; // start positions (relative to offset) for each (sub)exp.
int[] end; // end positions for the same
// start[i] == -1 or end[i] == -1 means that the start/end position is void.
// start[i] == p or end[i] == p where p < 0 and p != -1 means that
// the actual start/end position is (p+1). Start/end positions may
// become negative when the subexpression is in a RETokenLookBehind.
boolean empty; // empty string matched. This flag is used only within
// RETokenRepeated.
// Package scope; used by RE.
int index; // used while matching to mark current match position in input
// start1[i] is set when the i-th subexp starts. And start1[i] is copied
// to start[i] when the i-th subexp ends. So start[i] keeps the previously
// assigned value while the i-th subexp is being processed. This makes
// backreference to the i-th subexp within the i-th subexp possible.
int[] start; // start positions (relative to offset) for each (sub)exp.
int[] start1; // start positions (relative to offset) for each (sub)exp.
int[] end; // end positions for the same
// start[i] == -1 or end[i] == -1 means that the start/end position is void.
// start[i] == p or end[i] == p where p < 0 and p != -1 means that
// the actual start/end position is (p+1). Start/end positions may
// become negative when the subexpression is in a RETokenLookBehind.
boolean empty; // empty string matched. This flag is used only within
// RETokenRepeated.
BacktrackStack backtrackStack;
BacktrackStack backtrackStack;
public Object clone() {
try {
REMatch copy = (REMatch) super.clone();
public Object clone ()
{
try
{
REMatch copy = (REMatch) super.clone ();
copy.start = (int[]) start.clone();
copy.start1 = (int[]) start1.clone();
copy.end = (int[]) end.clone();
copy.start = (int[]) start.clone ();
copy.start1 = (int[]) start1.clone ();
copy.end = (int[]) end.clone ();
return copy;
} catch (CloneNotSupportedException e) {
throw new Error(); // doesn't happen
}
return copy;
}
void assignFrom(REMatch other) {
start = other.start;
start1 = other.start1;
end = other.end;
index = other.index;
backtrackStack = other.backtrackStack;
catch (CloneNotSupportedException e)
{
throw new Error (); // doesn't happen
}
}
REMatch(int subs, int anchor, int eflags) {
start = new int[subs+1];
start1 = new int[subs+1];
end = new int[subs+1];
this.anchor = anchor;
this.eflags = eflags;
clear(anchor);
}
void assignFrom (REMatch other)
{
start = other.start;
start1 = other.start1;
end = other.end;
index = other.index;
backtrackStack = other.backtrackStack;
}
REMatch (int subs, int anchor, int eflags)
{
start = new int[subs + 1];
start1 = new int[subs + 1];
end = new int[subs + 1];
this.anchor = anchor;
this.eflags = eflags;
clear (anchor);
}
void finish (CharIndexed text)
{
start[0] = 0;
CPStringBuilder sb = new CPStringBuilder ();
int i;
for (i = 0; i < end[0]; i++)
sb.append (text.charAt (i));
matchedText = sb.toString ();
matchedCharIndexed = text;
for (i = 0; i < start.length; i++)
{
// If any subexpressions didn't terminate, they don't count
// TODO check if this code ever gets hit
if ((start[i] == -1) ^ (end[i] == -1))
{
start[i] = -1;
end[i] = -1;
}
}
backtrackStack = null;
}
void finish(CharIndexed text) {
start[0] = 0;
StringBuffer sb = new StringBuffer();
int i;
for (i = 0; i < end[0]; i++)
sb.append(text.charAt(i));
matchedText = sb.toString();
matchedCharIndexed = text;
for (i = 0; i < start.length; i++) {
// If any subexpressions didn't terminate, they don't count
// TODO check if this code ever gets hit
if ((start[i] == -1) ^ (end[i] == -1)) {
start[i] = -1;
end[i] = -1;
}
}
backtrackStack = null;
}
/** Clears the current match and moves the offset to the new index. */
void clear(int index) {
offset = index;
this.index = 0;
for (int i = 0; i < start.length; i++) {
start[i] = start1[i] = end[i] = -1;
}
backtrackStack = null;
}
void clear (int index)
{
offset = index;
this.index = 0;
for (int i = 0; i < start.length; i++)
{
start[i] = start1[i] = end[i] = -1;
}
backtrackStack = null;
}
/**
* Returns the string matching the pattern. This makes it convenient
* to write code like the following:
@@ -150,18 +165,20 @@ public final class REMatch implements Serializable, Cloneable {
* if (myMatch != null) System.out.println("Regexp found: "+myMatch);
* </code>
*/
public String toString() {
return matchedText;
}
public String toString ()
{
return matchedText;
}
/**
* Returns the index within the input text where the match in its entirety
* began.
*/
public int getStartIndex() {
return offset + start[0];
}
public int getStartIndex ()
{
return offset + start[0];
}
/**
* Returns the index within the input string where the match in
* its entirety ends. The return value is the next position after
@@ -179,10 +196,11 @@ public final class REMatch implements Serializable, Cloneable {
* But you can save yourself that work, since the <code>toString()</code>
* method (above) does exactly that for you.
*/
public int getEndIndex() {
return offset + end[0];
}
public int getEndIndex ()
{
return offset + end[0];
}
/**
* Returns the string matching the given subexpression. The subexpressions
* are indexed starting with one, not zero. That is, the subexpression
@@ -191,25 +209,30 @@ public final class REMatch implements Serializable, Cloneable {
*
* @param sub Index of the subexpression.
*/
public String toString(int sub) {
if ((sub >= start.length) || sub < 0)
throw new IndexOutOfBoundsException("No group " + sub);
if (start[sub] == -1) return null;
if (start[sub] >= 0 && end[sub] <= matchedText.length())
return (matchedText.substring(start[sub],end[sub]));
else {
public String toString (int sub)
{
if ((sub >= start.length) || sub < 0)
throw new IndexOutOfBoundsException ("No group " + sub);
if (start[sub] == -1)
return null;
if (start[sub] >= 0 && end[sub] <= matchedText.length ())
return (matchedText.substring (start[sub], end[sub]));
else
{
// This case occurs with RETokenLookAhead or RETokenLookBehind.
StringBuffer sb = new StringBuffer();
int s = start[sub];
int e = end[sub];
if (s < 0) s += 1;
if (e < 0) e += 1;
for (int i = start[0] + s; i < start[0] + e; i++)
sb.append(matchedCharIndexed.charAt(i));
return sb.toString();
}
}
CPStringBuilder sb = new CPStringBuilder ();
int s = start[sub];
int e = end[sub];
if (s < 0)
s += 1;
if (e < 0)
e += 1;
for (int i = start[0] + s; i < start[0] + e; i++)
sb.append (matchedCharIndexed.charAt (i));
return sb.toString ();
}
}
/**
* Returns the index within the input string used to generate this match
* where subexpression number <i>sub</i> begins, or <code>-1</code> if
@@ -218,13 +241,14 @@ public final class REMatch implements Serializable, Cloneable {
* @param sub Subexpression index
* @deprecated Use getStartIndex(int) instead.
*/
public int getSubStartIndex(int sub) {
if (sub >= start.length) return -1;
int x = start[sub];
return (x == -1) ? x :
(x >= 0) ? offset + x : offset + x + 1;
}
public int getSubStartIndex (int sub)
{
if (sub >= start.length)
return -1;
int x = start[sub];
return (x == -1) ? x : (x >= 0) ? offset + x : offset + x + 1;
}
/**
* Returns the index within the input string used to generate this match
* where subexpression number <i>sub</i> begins, or <code>-1</code> if
@@ -233,13 +257,14 @@ public final class REMatch implements Serializable, Cloneable {
* @param sub Subexpression index
* @since gnu.regexp 1.1.0
*/
public int getStartIndex(int sub) {
if (sub >= start.length) return -1;
int x = start[sub];
return (x == -1) ? x :
(x >= 0) ? offset + x : offset + x + 1;
}
public int getStartIndex (int sub)
{
if (sub >= start.length)
return -1;
int x = start[sub];
return (x == -1) ? x : (x >= 0) ? offset + x : offset + x + 1;
}
/**
* Returns the index within the input string used to generate this match
* where subexpression number <i>sub</i> ends, or <code>-1</code> if
@@ -248,13 +273,14 @@ public final class REMatch implements Serializable, Cloneable {
* @param sub Subexpression index
* @deprecated Use getEndIndex(int) instead
*/
public int getSubEndIndex(int sub) {
if (sub >= start.length) return -1;
int x = end[sub];
return (x == -1) ? x :
(x >= 0) ? offset + x : offset + x + 1;
}
public int getSubEndIndex (int sub)
{
if (sub >= start.length)
return -1;
int x = end[sub];
return (x == -1) ? x : (x >= 0) ? offset + x : offset + x + 1;
}
/**
* Returns the index within the input string used to generate this match
* where subexpression number <i>sub</i> ends, or <code>-1</code> if
@@ -262,13 +288,14 @@ public final class REMatch implements Serializable, Cloneable {
*
* @param sub Subexpression index
*/
public int getEndIndex(int sub) {
if (sub >= start.length) return -1;
int x = end[sub];
return (x == -1) ? x :
(x >= 0) ? offset + x : offset + x + 1;
}
public int getEndIndex (int sub)
{
if (sub >= start.length)
return -1;
int x = end[sub];
return (x == -1) ? x : (x >= 0) ? offset + x : offset + x + 1;
}
/**
* Substitute the results of this match to create a new string.
* This is patterned after PERL, so the tokens to watch out for are
@@ -280,31 +307,42 @@ public final class REMatch implements Serializable, Cloneable {
*
* @param input A string consisting of literals and <code>$<i>n</i></code> tokens.
*/
public String substituteInto(String input) {
// a la Perl, $0 is whole thing, $1 - $9 are subexpressions
StringBuffer output = new StringBuffer();
int pos;
for (pos = 0; pos < input.length()-1; pos++) {
if ((input.charAt(pos) == '$') && (Character.isDigit(input.charAt(pos+1)))) {
int val = Character.digit(input.charAt(++pos),10);
int pos1 = pos + 1;
while (pos1 < input.length() &&
Character.isDigit(input.charAt(pos1))) {
int val1 = val*10 + Character.digit(input.charAt(pos1),10);
if (val1 >= start.length) break;
pos1++;
val = val1;
}
pos = pos1 - 1;
public String substituteInto (String input)
{
// a la Perl, $0 is whole thing, $1 - $9 are subexpressions
CPStringBuilder output = new CPStringBuilder ();
int pos;
for (pos = 0; pos < input.length () - 1; pos++)
{
if ((input.charAt (pos) == '$')
&& (Character.isDigit (input.charAt (pos + 1))))
{
int val = Character.digit (input.charAt (++pos), 10);
int pos1 = pos + 1;
while (pos1 < input.length () &&
Character.isDigit (input.charAt (pos1)))
{
int val1 =
val * 10 + Character.digit (input.charAt (pos1), 10);
if (val1 >= start.length)
break;
pos1++;
val = val1;
}
pos = pos1 - 1;
if (val < start.length) {
output.append(toString(val));
}
} else output.append(input.charAt(pos));
}
if (pos < input.length()) output.append(input.charAt(pos));
return output.toString();
}
if (val < start.length)
{
output.append (toString (val));
}
}
else
output.append (input.charAt (pos));
}
if (pos < input.length ())
output.append (input.charAt (pos));
return output.toString ();
}
/* The following are used for debugging purpose
public static String d(REMatch m) {
libjava/classpath/gnu/java/util/regex/REMatchEnumeration.java
+41 -35
View File
@@ -36,6 +36,9 @@ obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
import java.io.Serializable;
import java.util.Enumeration;
import java.util.NoSuchElementException;
@@ -66,20 +69,23 @@ import java.util.NoSuchElementException;
*
* @author <A HREF="mailto:wes@cacas.org">Wes Biggs</A>
*/
public class REMatchEnumeration implements Enumeration, Serializable {
public class REMatchEnumeration
implements Enumeration < REMatch >, Serializable
{
private static final int YES = 1;
private static final int MAYBE = 0;
private static final int NO = -1;
private int more;
private REMatch match;
private RE expr;
private CharIndexed input;
private int eflags;
private int index;
private final RE expr;
private final CharIndexed input;
private final int eflags;
private int index;
// Package scope constructor is used by RE.getMatchEnumeration()
REMatchEnumeration(RE expr, CharIndexed input, int index, int eflags) {
REMatchEnumeration (RE expr, CharIndexed input, int index, int eflags)
{
more = MAYBE;
this.expr = expr;
this.input = input;
@@ -88,48 +94,48 @@ public class REMatchEnumeration implements Enumeration, Serializable {
}
/** Returns true if there are more matches in the input text. */
public boolean hasMoreElements() {
return hasMoreMatches(null);
public boolean hasMoreElements ()
{
return hasMoreMatches (null);
}
/** Returns true if there are more matches in the input text. */
public boolean hasMoreMatches() {
return hasMoreMatches(null);
public boolean hasMoreMatches ()
{
return hasMoreMatches (null);
}
/** Returns true if there are more matches in the input text.
* Saves the text leading up to the match (or to the end of the input)
* in the specified buffer.
*/
public boolean hasMoreMatches(StringBuffer buffer) {
if (more == MAYBE) {
match = expr.getMatchImpl(input,index,eflags,buffer);
if (match != null) {
input.move((match.end[0] > 0) ? match.end[0] : 1);
index = (match.end[0] > 0) ? match.end[0] + match.offset : index + 1;
public boolean hasMoreMatches (CPStringBuilder buffer)
{
if (more == MAYBE)
{
match = expr.getMatchImpl (input, index, eflags, buffer);
if (match != null)
{
input.move ((match.end[0] > 0) ? match.end[0] : 1);
index =
(match.end[0] > 0) ? match.end[0] + match.offset : index + 1;
more = YES;
} else more = NO;
}
}
else
more = NO;
}
return (more == YES);
}
/** Returns the next match in the input text. */
public Object nextElement() throws NoSuchElementException {
return nextMatch();
}
/**
* Returns the next match in the input text. This method is provided
* for convenience to avoid having to explicitly cast the return value
* to class REMatch.
*/
public REMatch nextMatch() throws NoSuchElementException {
if (hasMoreElements()) {
more = (input.isValid()) ? MAYBE : NO;
public REMatch nextElement () throws NoSuchElementException
{
if (hasMoreElements ())
{
more = (input.isValid ())? MAYBE : NO;
return match;
}
throw new NoSuchElementException();
}
throw new NoSuchElementException ();
}
}
libjava/classpath/gnu/java/util/regex/RESyntax.java
+168 -195
View File
@@ -51,102 +51,104 @@ import java.util.BitSet;
* @author <A HREF="mailto:wes@cacas.org">Wes Biggs</A>
*/
public final class RESyntax implements Serializable {
static final String DEFAULT_LINE_SEPARATOR = System.getProperty("line.separator");
public final class RESyntax implements Serializable
{
static final String DEFAULT_LINE_SEPARATOR =
System.getProperty ("line.separator");
private BitSet bits;
private BitSet bits;
// true for the constant defined syntaxes
private boolean isFinal = false;
// true for the constant defined syntaxes
private boolean isFinal = false;
private String lineSeparator = DEFAULT_LINE_SEPARATOR;
private String lineSeparator = DEFAULT_LINE_SEPARATOR;
// Values for constants are bit indexes
/**
* Syntax bit. Backslash is an escape character in lists.
*/
public static final int RE_BACKSLASH_ESCAPE_IN_LISTS = 0;
public static final int RE_BACKSLASH_ESCAPE_IN_LISTS = 0;
/**
* Syntax bit. Use \? instead of ? and \+ instead of +.
*/
public static final int RE_BK_PLUS_QM = 1;
public static final int RE_BK_PLUS_QM = 1;
/**
* Syntax bit. POSIX character classes ([:...:]) in lists are allowed.
*/
public static final int RE_CHAR_CLASSES = 2;
public static final int RE_CHAR_CLASSES = 2;
/**
* Syntax bit. ^ and $ are special everywhere.
* <B>Not implemented.</B>
*/
public static final int RE_CONTEXT_INDEP_ANCHORS = 3;
public static final int RE_CONTEXT_INDEP_ANCHORS = 3;
/**
* Syntax bit. Repetition operators are only special in valid positions.
* <B>Not implemented.</B>
*/
public static final int RE_CONTEXT_INDEP_OPS = 4;
public static final int RE_CONTEXT_INDEP_OPS = 4;
/**
* Syntax bit. Repetition and alternation operators are invalid
* at start and end of pattern and other places.
* <B>Not implemented</B>.
*/
public static final int RE_CONTEXT_INVALID_OPS = 5;
public static final int RE_CONTEXT_INVALID_OPS = 5;
/**
* Syntax bit. Match-any-character operator (.) matches a newline.
*/
public static final int RE_DOT_NEWLINE = 6;
public static final int RE_DOT_NEWLINE = 6;
/**
* Syntax bit. Match-any-character operator (.) does not match a null.
*/
public static final int RE_DOT_NOT_NULL = 7;
public static final int RE_DOT_NOT_NULL = 7;
/**
* Syntax bit. Intervals ({x}, {x,}, {x,y}) are allowed.
*/
public static final int RE_INTERVALS = 8;
public static final int RE_INTERVALS = 8;
/**
* Syntax bit. No alternation (|), match one-or-more (+), or
* match zero-or-one (?) operators.
*/
public static final int RE_LIMITED_OPS = 9;
public static final int RE_LIMITED_OPS = 9;
/**
* Syntax bit. Newline is an alternation operator.
*/
public static final int RE_NEWLINE_ALT = 10; // impl.
public static final int RE_NEWLINE_ALT = 10; // impl.
/**
* Syntax bit. Intervals use { } instead of \{ \}
*/
public static final int RE_NO_BK_BRACES = 11;
public static final int RE_NO_BK_BRACES = 11;
/**
* Syntax bit. Grouping uses ( ) instead of \( \).
*/
public static final int RE_NO_BK_PARENS = 12;
public static final int RE_NO_BK_PARENS = 12;
/**
* Syntax bit. Backreferences not allowed.
*/
public static final int RE_NO_BK_REFS = 13;
public static final int RE_NO_BK_REFS = 13;
/**
* Syntax bit. Alternation uses | instead of \|
*/
public static final int RE_NO_BK_VBAR = 14;
public static final int RE_NO_BK_VBAR = 14;
/**
* Syntax bit. <B>Not implemented</B>.
*/
public static final int RE_NO_EMPTY_RANGES = 15;
public static final int RE_NO_EMPTY_RANGES = 15;
/**
* Syntax bit. An unmatched right parenthesis (')' or '\)', depending
@@ -157,80 +159,80 @@ public final class RESyntax implements Serializable {
/**
* Syntax bit. <B>Not implemented.</B>
*/
public static final int RE_HAT_LISTS_NOT_NEWLINE = 17;
public static final int RE_HAT_LISTS_NOT_NEWLINE = 17;
/**
* Syntax bit. Stingy matching is allowed (+?, *?, ??, {x,y}?).
*/
public static final int RE_STINGY_OPS = 18;
public static final int RE_STINGY_OPS = 18;
/**
* Syntax bit. Allow character class escapes (\d, \D, \s, \S, \w, \W).
*/
public static final int RE_CHAR_CLASS_ESCAPES = 19;
public static final int RE_CHAR_CLASS_ESCAPES = 19;
/**
* Syntax bit. Allow use of (?:xxx) grouping (subexpression is not saved).
*/
public static final int RE_PURE_GROUPING = 20;
public static final int RE_PURE_GROUPING = 20;
/**
* Syntax bit. Allow use of (?=xxx) and (?!xxx) apply the subexpression
* to the text following the current position without consuming that text.
*/
public static final int RE_LOOKAHEAD = 21;
public static final int RE_LOOKAHEAD = 21;
/**
* Syntax bit. Allow beginning- and end-of-string anchors (\A, \Z).
*/
public static final int RE_STRING_ANCHORS = 22;
public static final int RE_STRING_ANCHORS = 22;
/**
* Syntax bit. Allow embedded comments, (?#comment), as in Perl5.
*/
public static final int RE_COMMENTS = 23;
public static final int RE_COMMENTS = 23;
/**
* Syntax bit. Allow character class escapes within lists, as in Perl5.
*/
public static final int RE_CHAR_CLASS_ESC_IN_LISTS = 24;
public static final int RE_CHAR_CLASS_ESC_IN_LISTS = 24;
/**
* Syntax bit. Possessive matching is allowed (++, *+, ?+, {x,y}+).
*/
public static final int RE_POSSESSIVE_OPS = 25;
public static final int RE_POSSESSIVE_OPS = 25;
/**
* Syntax bit. Allow embedded flags, (?is-x), as in Perl5.
*/
public static final int RE_EMBEDDED_FLAGS = 26;
public static final int RE_EMBEDDED_FLAGS = 26;
/**
* Syntax bit. Allow octal char (\0377), as in Perl5.
*/
public static final int RE_OCTAL_CHAR = 27;
public static final int RE_OCTAL_CHAR = 27;
/**
* Syntax bit. Allow hex char (\x1b), as in Perl5.
*/
public static final int RE_HEX_CHAR = 28;
public static final int RE_HEX_CHAR = 28;
/**
* Syntax bit. Allow Unicode char (\u1234), as in Java 1.4.
*/
public static final int RE_UNICODE_CHAR = 29;
public static final int RE_UNICODE_CHAR = 29;
/**
* Syntax bit. Allow named property (\p{P}, \P{p}), as in Perl5.
*/
public static final int RE_NAMED_PROPERTY = 30;
public static final int RE_NAMED_PROPERTY = 30;
/**
* Syntax bit. Allow nested characterclass ([a-z&&[^p-r]]), as in Java 1.4.
*/
public static final int RE_NESTED_CHARCLASS = 31;
public static final int RE_NESTED_CHARCLASS = 31;
private static final int BIT_TOTAL = 32;
private static final int BIT_TOTAL = 32;
/**
* Predefined syntax.
@@ -315,13 +317,13 @@ public final class RESyntax implements Serializable {
* Emulates regular expression support in Larry Wall's perl, version 4,
* using single line mode (/s modifier).
*/
public static final RESyntax RE_SYNTAX_PERL4_S; // single line mode (/s)
public static final RESyntax RE_SYNTAX_PERL4_S; // single line mode (/s)
/**
* Predefined syntax.
* Emulates regular expression support in Larry Wall's perl, version 5.
*/
public static final RESyntax RE_SYNTAX_PERL5;
public static final RESyntax RE_SYNTAX_PERL5;
/**
* Predefined syntax.
@@ -335,145 +337,109 @@ public final class RESyntax implements Serializable {
* Emulates regular expression support in Java 1.4's java.util.regex
* package.
*/
public static final RESyntax RE_SYNTAX_JAVA_1_4;
public static final RESyntax RE_SYNTAX_JAVA_1_4;
static {
// Define syntaxes
RE_SYNTAX_EMACS = new RESyntax().makeFinal();
RESyntax RE_SYNTAX_POSIX_COMMON = new RESyntax()
.set(RE_CHAR_CLASSES)
.set(RE_DOT_NEWLINE)
.set(RE_DOT_NOT_NULL)
.set(RE_INTERVALS)
.set(RE_NO_EMPTY_RANGES)
.makeFinal();
RE_SYNTAX_POSIX_BASIC = new RESyntax(RE_SYNTAX_POSIX_COMMON)
.set(RE_BK_PLUS_QM)
.makeFinal();
RE_SYNTAX_POSIX_EXTENDED = new RESyntax(RE_SYNTAX_POSIX_COMMON)
.set(RE_CONTEXT_INDEP_ANCHORS)
.set(RE_CONTEXT_INDEP_OPS)
.set(RE_NO_BK_BRACES)
.set(RE_NO_BK_PARENS)
.set(RE_NO_BK_VBAR)
.set(RE_UNMATCHED_RIGHT_PAREN_ORD)
.makeFinal();
static
{
// Define syntaxes
RE_SYNTAX_AWK = new RESyntax()
.set(RE_BACKSLASH_ESCAPE_IN_LISTS)
.set(RE_DOT_NOT_NULL)
.set(RE_NO_BK_PARENS)
.set(RE_NO_BK_REFS)
.set(RE_NO_BK_VBAR)
.set(RE_NO_EMPTY_RANGES)
.set(RE_UNMATCHED_RIGHT_PAREN_ORD)
.makeFinal();
RE_SYNTAX_POSIX_AWK = new RESyntax(RE_SYNTAX_POSIX_EXTENDED)
.set(RE_BACKSLASH_ESCAPE_IN_LISTS)
.makeFinal();
RE_SYNTAX_GREP = new RESyntax()
.set(RE_BK_PLUS_QM)
.set(RE_CHAR_CLASSES)
.set(RE_HAT_LISTS_NOT_NEWLINE)
.set(RE_INTERVALS)
.set(RE_NEWLINE_ALT)
.makeFinal();
RE_SYNTAX_EGREP = new RESyntax()
.set(RE_CHAR_CLASSES)
.set(RE_CONTEXT_INDEP_ANCHORS)
.set(RE_CONTEXT_INDEP_OPS)
.set(RE_HAT_LISTS_NOT_NEWLINE)
.set(RE_NEWLINE_ALT)
.set(RE_NO_BK_PARENS)
.set(RE_NO_BK_VBAR)
.makeFinal();
RE_SYNTAX_POSIX_EGREP = new RESyntax(RE_SYNTAX_EGREP)
.set(RE_INTERVALS)
.set(RE_NO_BK_BRACES)
.makeFinal();
/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */
RE_SYNTAX_ED = new RESyntax(RE_SYNTAX_POSIX_BASIC)
.makeFinal();
RE_SYNTAX_SED = new RESyntax(RE_SYNTAX_POSIX_BASIC)
.makeFinal();
RE_SYNTAX_POSIX_MINIMAL_BASIC = new RESyntax(RE_SYNTAX_POSIX_COMMON)
.set(RE_LIMITED_OPS)
.makeFinal();
/* Differs from RE_SYNTAX_POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS
replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */
RE_SYNTAX_POSIX_MINIMAL_EXTENDED = new RESyntax(RE_SYNTAX_POSIX_COMMON)
.set(RE_CONTEXT_INDEP_ANCHORS)
.set(RE_CONTEXT_INVALID_OPS)
.set(RE_NO_BK_BRACES)
.set(RE_NO_BK_PARENS)
.set(RE_NO_BK_REFS)
.set(RE_NO_BK_VBAR)
.set(RE_UNMATCHED_RIGHT_PAREN_ORD)
.makeFinal();
/* There is no official Perl spec, but here's a "best guess" */
RE_SYNTAX_PERL4 = new RESyntax()
.set(RE_BACKSLASH_ESCAPE_IN_LISTS)
.set(RE_CONTEXT_INDEP_ANCHORS)
.set(RE_CONTEXT_INDEP_OPS) // except for '{', apparently
.set(RE_INTERVALS)
.set(RE_NO_BK_BRACES)
.set(RE_NO_BK_PARENS)
.set(RE_NO_BK_VBAR)
.set(RE_NO_EMPTY_RANGES)
.set(RE_CHAR_CLASS_ESCAPES) // \d,\D,\w,\W,\s,\S
.makeFinal();
RE_SYNTAX_PERL4_S = new RESyntax(RE_SYNTAX_PERL4)
.set(RE_DOT_NEWLINE)
.makeFinal();
RE_SYNTAX_PERL5 = new RESyntax(RE_SYNTAX_PERL4)
.set(RE_PURE_GROUPING) // (?:)
.set(RE_STINGY_OPS) // *?,??,+?,{}?
.set(RE_LOOKAHEAD) // (?=)(?!)
.set(RE_STRING_ANCHORS) // \A,\Z
.set(RE_CHAR_CLASS_ESC_IN_LISTS)// \d,\D,\w,\W,\s,\S within []
.set(RE_COMMENTS) // (?#)
.set(RE_EMBEDDED_FLAGS) // (?imsx-imsx)
.set(RE_OCTAL_CHAR) // \0377
.set(RE_HEX_CHAR) // \x1b
.set(RE_NAMED_PROPERTY) // \p{prop}, \P{prop}
.makeFinal();
RE_SYNTAX_PERL5_S = new RESyntax(RE_SYNTAX_PERL5)
.set(RE_DOT_NEWLINE)
.makeFinal();
RE_SYNTAX_EMACS = new RESyntax ().makeFinal ();
RE_SYNTAX_JAVA_1_4 = new RESyntax(RE_SYNTAX_PERL5)
// XXX
.set(RE_POSSESSIVE_OPS) // *+,?+,++,{}+
.set(RE_UNICODE_CHAR) // \u1234
.set(RE_NESTED_CHARCLASS) // [a-z&&[^p-r]]
.makeFinal();
RESyntax RE_SYNTAX_POSIX_COMMON =
new RESyntax ().set (RE_CHAR_CLASSES).set (RE_DOT_NEWLINE).
set (RE_DOT_NOT_NULL).set (RE_INTERVALS).set (RE_NO_EMPTY_RANGES).
makeFinal ();
RE_SYNTAX_POSIX_BASIC =
new RESyntax (RE_SYNTAX_POSIX_COMMON).set (RE_BK_PLUS_QM).makeFinal ();
RE_SYNTAX_POSIX_EXTENDED =
new RESyntax (RE_SYNTAX_POSIX_COMMON).set (RE_CONTEXT_INDEP_ANCHORS).
set (RE_CONTEXT_INDEP_OPS).set (RE_NO_BK_BRACES).set (RE_NO_BK_PARENS).
set (RE_NO_BK_VBAR).set (RE_UNMATCHED_RIGHT_PAREN_ORD).makeFinal ();
RE_SYNTAX_AWK =
new RESyntax ().set (RE_BACKSLASH_ESCAPE_IN_LISTS).
set (RE_DOT_NOT_NULL).set (RE_NO_BK_PARENS).set (RE_NO_BK_REFS).
set (RE_NO_BK_VBAR).set (RE_NO_EMPTY_RANGES).
set (RE_UNMATCHED_RIGHT_PAREN_ORD).makeFinal ();
RE_SYNTAX_POSIX_AWK =
new RESyntax (RE_SYNTAX_POSIX_EXTENDED).
set (RE_BACKSLASH_ESCAPE_IN_LISTS).makeFinal ();
RE_SYNTAX_GREP =
new RESyntax ().set (RE_BK_PLUS_QM).set (RE_CHAR_CLASSES).
set (RE_HAT_LISTS_NOT_NEWLINE).set (RE_INTERVALS).set (RE_NEWLINE_ALT).
makeFinal ();
RE_SYNTAX_EGREP =
new RESyntax ().set (RE_CHAR_CLASSES).set (RE_CONTEXT_INDEP_ANCHORS).
set (RE_CONTEXT_INDEP_OPS).set (RE_HAT_LISTS_NOT_NEWLINE).
set (RE_NEWLINE_ALT).set (RE_NO_BK_PARENS).set (RE_NO_BK_VBAR).
makeFinal ();
RE_SYNTAX_POSIX_EGREP =
new RESyntax (RE_SYNTAX_EGREP).set (RE_INTERVALS).set (RE_NO_BK_BRACES).
makeFinal ();
/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */
RE_SYNTAX_ED = new RESyntax (RE_SYNTAX_POSIX_BASIC).makeFinal ();
RE_SYNTAX_SED = new RESyntax (RE_SYNTAX_POSIX_BASIC).makeFinal ();
RE_SYNTAX_POSIX_MINIMAL_BASIC =
new RESyntax (RE_SYNTAX_POSIX_COMMON).set (RE_LIMITED_OPS).makeFinal ();
/* Differs from RE_SYNTAX_POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS
replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */
RE_SYNTAX_POSIX_MINIMAL_EXTENDED =
new RESyntax (RE_SYNTAX_POSIX_COMMON).set (RE_CONTEXT_INDEP_ANCHORS).
set (RE_CONTEXT_INVALID_OPS).set (RE_NO_BK_BRACES).
set (RE_NO_BK_PARENS).set (RE_NO_BK_REFS).set (RE_NO_BK_VBAR).
set (RE_UNMATCHED_RIGHT_PAREN_ORD).makeFinal ();
/* There is no official Perl spec, but here's a "best guess" */
RE_SYNTAX_PERL4 = new RESyntax ().set (RE_BACKSLASH_ESCAPE_IN_LISTS).set (RE_CONTEXT_INDEP_ANCHORS).set (RE_CONTEXT_INDEP_OPS) // except for '{', apparently
.set (RE_INTERVALS).set (RE_NO_BK_BRACES).set (RE_NO_BK_PARENS).set (RE_NO_BK_VBAR).set (RE_NO_EMPTY_RANGES).set (RE_CHAR_CLASS_ESCAPES) // \d,\D,\w,\W,\s,\S
.makeFinal ();
RE_SYNTAX_PERL4_S =
new RESyntax (RE_SYNTAX_PERL4).set (RE_DOT_NEWLINE).makeFinal ();
RE_SYNTAX_PERL5 = new RESyntax (RE_SYNTAX_PERL4).set (RE_PURE_GROUPING) // (?:)
.set (RE_STINGY_OPS) // *?,??,+?,{}?
.set (RE_LOOKAHEAD) // (?=)(?!)
.set (RE_STRING_ANCHORS) // \A,\Z
.set (RE_CHAR_CLASS_ESC_IN_LISTS) // \d,\D,\w,\W,\s,\S within []
.set (RE_COMMENTS) // (?#)
.set (RE_EMBEDDED_FLAGS) // (?imsx-imsx)
.set (RE_OCTAL_CHAR) // \0377
.set (RE_HEX_CHAR) // \x1b
.set (RE_NAMED_PROPERTY) // \p{prop}, \P{prop}
.makeFinal ();
RE_SYNTAX_PERL5_S =
new RESyntax (RE_SYNTAX_PERL5).set (RE_DOT_NEWLINE).makeFinal ();
RE_SYNTAX_JAVA_1_4 = new RESyntax (RE_SYNTAX_PERL5)
// XXX
.set (RE_POSSESSIVE_OPS) // *+,?+,++,{}+
.set (RE_UNICODE_CHAR) // \u1234
.set (RE_NESTED_CHARCLASS) // [a-z&&[^p-r]]
.makeFinal ();
}
/**
* Construct a new syntax object with all bits turned off.
* This is equivalent to RE_SYNTAX_EMACS.
*/
public RESyntax() {
bits = new BitSet(BIT_TOTAL);
public RESyntax ()
{
bits = new BitSet (BIT_TOTAL);
}
/**
@@ -484,24 +450,27 @@ public final class RESyntax implements Serializable {
*
* @return this object for convenient chaining
*/
public RESyntax makeFinal() {
isFinal = true;
return this;
}
public RESyntax makeFinal ()
{
isFinal = true;
return this;
}
/**
* Construct a new syntax object with all bits set the same
* as the other syntax.
*/
public RESyntax(RESyntax other) {
bits = (BitSet) other.bits.clone();
public RESyntax (RESyntax other)
{
bits = (BitSet) other.bits.clone ();
}
/**
* Check if a given bit is set in this syntax.
*/
public boolean get(int index) {
return bits.get(index);
public boolean get (int index)
{
return bits.get (index);
}
/**
@@ -510,10 +479,11 @@ public final class RESyntax implements Serializable {
* @param index the constant (RESyntax.RE_xxx) bit to set.
* @return a reference to this object for easy chaining.
*/
public RESyntax set(int index) {
public RESyntax set (int index)
{
if (isFinal)
throw new IllegalAccessError(RE.getLocalizedMessage("syntax.final"));
bits.set(index);
throw new IllegalAccessError (RE.getLocalizedMessage ("syntax.final"));
bits.set (index);
return this;
}
@@ -523,11 +493,12 @@ public final class RESyntax implements Serializable {
* @param index the constant (RESyntax.RE_xxx) bit to clear.
* @return a reference to this object for easy chaining.
*/
public RESyntax clear(int index) {
if (isFinal)
throw new IllegalAccessError(RE.getLocalizedMessage("syntax.final"));
bits.clear(index);
return this;
public RESyntax clear (int index)
{
if (isFinal)
throw new IllegalAccessError (RE.getLocalizedMessage ("syntax.final"));
bits.clear (index);
return this;
}
/**
@@ -547,18 +518,20 @@ public final class RESyntax implements Serializable {
*
* @return this object for convenient chaining
*/
public RESyntax setLineSeparator(String aSeparator) {
if (isFinal)
throw new IllegalAccessError(RE.getLocalizedMessage("syntax.final"));
lineSeparator = aSeparator;
return this;
}
public RESyntax setLineSeparator (String aSeparator)
{
if (isFinal)
throw new IllegalAccessError (RE.getLocalizedMessage ("syntax.final"));
lineSeparator = aSeparator;
return this;
}
/**
* Returns the currently active line separator string. The default
* is the platform-dependent system property "line.separator".
*/
public String getLineSeparator() {
return lineSeparator;
}
public String getLineSeparator ()
{
return lineSeparator;
}
}
libjava/classpath/gnu/java/util/regex/REToken.java
+120 -80
View File
@@ -36,65 +36,84 @@ obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
import java.io.Serializable;
abstract class REToken implements Serializable, Cloneable {
abstract class REToken implements Serializable, Cloneable
{
protected REToken next = null;
protected REToken uncle = null;
protected int subIndex;
protected boolean unicodeAware = true;
public Object clone() {
try {
REToken copy = (REToken) super.clone();
return copy;
} catch (CloneNotSupportedException e) {
throw new Error(); // doesn't happen
public Object clone ()
{
try
{
REToken copy = (REToken) super.clone ();
return copy;
}
catch (CloneNotSupportedException e)
{
throw new Error (); // doesn't happen
}
}
protected REToken(int subIndex) {
this.subIndex = subIndex;
protected REToken (int subIndex)
{
this.subIndex = subIndex;
}
int getMinimumLength() {
int getMinimumLength ()
{
return 0;
}
int getMaximumLength() {
int getMaximumLength ()
{
return Integer.MAX_VALUE;
}
void setUncle(REToken anUncle) {
void setUncle (REToken anUncle)
{
uncle = anUncle;
}
/** Returns true if the match succeeded, false if it failed. */
boolean match(CharIndexed input, REMatch mymatch) {
return match(input, mymatch, false);
}
boolean matchFake(CharIndexed input, REMatch mymatch) {
return match(input, mymatch, true);
}
boolean match (CharIndexed input, REMatch mymatch)
{
return match (input, mymatch, false);
}
boolean matchFake (CharIndexed input, REMatch mymatch)
{
return match (input, mymatch, true);
}
private boolean match(CharIndexed input, REMatch mymatch, boolean fake) {
if (!fake) {
setHitEnd(input, mymatch);
}
REMatch m = matchThis(input, mymatch);
if (m == null) return false;
if (next(input, m)) {
mymatch.assignFrom(m);
return true;
}
return false;
}
private boolean match (CharIndexed input, REMatch mymatch, boolean fake)
{
if (!fake)
{
setHitEnd (input, mymatch);
}
REMatch m = matchThis (input, mymatch);
if (m == null)
return false;
if (next (input, m))
{
mymatch.assignFrom (m);
return true;
}
return false;
}
/** Sets whether the matching occurs at the end of input */
void setHitEnd(CharIndexed input, REMatch mymatch) {
input.setHitEnd(mymatch);
}
void setHitEnd (CharIndexed input, REMatch mymatch)
{
input.setHitEnd (mymatch);
}
/** Returns true if the match succeeded, false if it failed.
* The matching is done against this REToken only. Chained
@@ -106,22 +125,27 @@ abstract class REToken implements Serializable, Cloneable {
* subclasses of REToken, which needs a special match method,
* do not have to implement this method.
*/
REMatch matchThis(CharIndexed input, REMatch mymatch) {
throw new UnsupportedOperationException(
"This REToken does not have a matchThis method");
}
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
throw new
UnsupportedOperationException
("This REToken does not have a matchThis method");
}
/** Returns true if the rest of the tokens match, false if they fail. */
protected boolean next(CharIndexed input, REMatch mymatch) {
REToken nextToken = getNext();
if (nextToken == null) return true;
return nextToken.match(input, mymatch);
}
protected boolean next (CharIndexed input, REMatch mymatch)
{
REToken nextToken = getNext ();
if (nextToken == null)
return true;
return nextToken.match (input, mymatch);
}
/** Returns the next REToken chained to this REToken. */
REToken getNext() {
return (next != null ? next : uncle);
}
REToken getNext ()
{
return (next != null ? next : uncle);
}
/** Finds a match at the position specified by the given REMatch.
* If necessary, adds a BacktrackStack.Backtrack object to backtrackStack
@@ -132,45 +156,55 @@ abstract class REToken implements Serializable, Cloneable {
* @param mymatch Position at which a match should be found
* @return REMatch object if a match was found, null otherwise.
*/
REMatch findMatch(CharIndexed input, REMatch mymatch) {
boolean b = match(input, mymatch);
if (b) return mymatch;
return null;
}
REMatch findMatch (CharIndexed input, REMatch mymatch)
{
boolean b = match (input, mymatch);
if (b)
return mymatch;
return null;
}
boolean returnsFixedLengthMatches() {
return false;
}
boolean returnsFixedLengthMatches ()
{
return false;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
throw new UnsupportedOperationException(
"This token does not support findFixedLengthMatches");
}
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
throw new
UnsupportedOperationException
("This token does not support findFixedLengthMatches");
}
/**
* Backtrack to another possibility.
* Ordinary REToken cannot do anything if this method is called.
*/
REMatch backtrack(CharIndexed input, REMatch mymatch, Object param) {
throw new IllegalStateException("This token cannot be backtracked to");
}
boolean chain(REToken token) {
next = token;
return true; // Token was accepted
REMatch backtrack (CharIndexed input, REMatch mymatch, Object param)
{
throw new IllegalStateException ("This token cannot be backtracked to");
}
abstract void dump(StringBuffer os);
void dumpAll(StringBuffer os) {
dump(os);
if (next != null) next.dumpAll(os);
boolean chain (REToken token)
{
next = token;
return true; // Token was accepted
}
public String toString() {
StringBuffer os = new StringBuffer();
dump(os);
return os.toString();
abstract void dump (CPStringBuilder os);
void dumpAll (CPStringBuilder os)
{
dump (os);
if (next != null)
next.dumpAll (os);
}
public String toString ()
{
CPStringBuilder os = new CPStringBuilder ();
dump (os);
return os.toString ();
}
/**
@@ -181,9 +215,12 @@ abstract class REToken implements Serializable, Cloneable {
* @return the lowercase equivalent of the character, if any;
* otherwise, the character itself.
*/
public static char toLowerCase(char ch, boolean unicodeAware) {
if (unicodeAware) return Character.toLowerCase(ch);
if (ch >= 'A' && ch <= 'Z') return (char)(ch + 'a' - 'A');
public static char toLowerCase (char ch, boolean unicodeAware)
{
if (unicodeAware)
return Character.toLowerCase (ch);
if (ch >= 'A' && ch <= 'Z')
return (char) (ch + 'a' - 'A');
return ch;
}
@@ -195,9 +232,12 @@ abstract class REToken implements Serializable, Cloneable {
* @return the uppercase equivalent of the character, if any;
* otherwise, the character itself.
*/
public static char toUpperCase(char ch, boolean unicodeAware) {
if (unicodeAware) return Character.toUpperCase(ch);
if (ch >= 'a' && ch <= 'z') return (char)(ch + 'A' - 'a');
public static char toUpperCase (char ch, boolean unicodeAware)
{
if (unicodeAware)
return Character.toUpperCase (ch);
if (ch >= 'a' && ch <= 'z')
return (char) (ch + 'A' - 'a');
return ch;
}
libjava/classpath/gnu/java/util/regex/RETokenAny.java
+51 -35
View File
@@ -38,62 +38,78 @@ exception statement from your version. */
package gnu.java.util.regex;
final class RETokenAny extends REToken {
import gnu.java.lang.CPStringBuilder;
final class RETokenAny extends REToken
{
/** True if '.' can match a newline (RE_DOT_NEWLINE) */
private boolean newline;
private boolean newline;
/** True if '.' can't match a null (RE_DOT_NOT_NULL) */
private boolean matchNull;
RETokenAny(int subIndex, boolean newline, boolean matchNull) {
super(subIndex);
private boolean matchNull;
RETokenAny (int subIndex, boolean newline, boolean matchNull)
{
super (subIndex);
this.newline = newline;
this.matchNull = matchNull;
}
int getMinimumLength() {
int getMinimumLength ()
{
return 1;
}
int getMaximumLength() {
int getMaximumLength ()
{
return 1;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
char ch = input.charAt(mymatch.index);
boolean retval = matchOneChar(ch);
if (retval) {
++mymatch.index;
return mymatch;
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
char ch = input.charAt (mymatch.index);
boolean retval = matchOneChar (ch);
if (retval)
{
++mymatch.index;
return mymatch;
}
return null;
}
boolean matchOneChar(char ch) {
if ((ch == CharIndexed.OUT_OF_BOUNDS)
|| (!newline && (ch == '\n'))
|| (matchNull && (ch == 0))) {
return false;
}
return true;
return null;
}
boolean returnsFixedLengthMatches() { return true; }
boolean matchOneChar (char ch)
{
if ((ch == CharIndexed.OUT_OF_BOUNDS)
|| (!newline && (ch == '\n')) || (matchNull && (ch == 0)))
{
return false;
}
return true;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
boolean returnsFixedLengthMatches ()
{
return true;
}
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
int index = mymatch.index;
int numRepeats = 0;
while (true) {
if (numRepeats >= max) break;
char ch = input.charAt(index++);
if (! matchOneChar(ch)) break;
numRepeats++;
}
while (true)
{
if (numRepeats >= max)
break;
char ch = input.charAt (index++);
if (!matchOneChar (ch))
break;
numRepeats++;
}
return numRepeats;
}
void dump(StringBuffer os) {
os.append('.');
void dump (CPStringBuilder os)
{
os.append ('.');
}
}
libjava/classpath/gnu/java/util/regex/RETokenBackRef.java
+50 -36
View File
@@ -38,49 +38,63 @@ exception statement from your version. */
package gnu.java.util.regex;
final class RETokenBackRef extends REToken {
import gnu.java.lang.CPStringBuilder;
final class RETokenBackRef extends REToken
{
private int num;
private boolean insens;
RETokenBackRef(int subIndex, int num, boolean insens) {
super(subIndex);
RETokenBackRef (int subIndex, int num, boolean insens)
{
super (subIndex);
this.num = num;
this.insens = insens;
}
// should implement getMinimumLength() -- any ideas?
REMatch matchThis(CharIndexed input, REMatch mymatch) {
if (num >= mymatch.start.length) return null;
if (num >= mymatch.end.length) return null;
int b,e;
b = mymatch.start[num];
e = mymatch.end[num];
if ((b==-1)||(e==-1)) return null; // this shouldn't happen, but...
if (b < 0) b += 1;
if (e < 0) e += 1;
for (int i=b; i<e; i++) {
char c1 = input.charAt(mymatch.index+i-b);
char c2 = input.charAt(i);
if (c1 != c2) {
if (insens) {
if (c1 != toLowerCase(c2, unicodeAware) &&
c1 != toUpperCase(c2, unicodeAware)) {
return null;
}
}
else {
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
if (num >= mymatch.start.length)
return null;
if (num >= mymatch.end.length)
return null;
int b, e;
b = mymatch.start[num];
e = mymatch.end[num];
if ((b == -1) || (e == -1))
return null; // this shouldn't happen, but...
if (b < 0)
b += 1;
if (e < 0)
e += 1;
for (int i = b; i < e; i++)
{
char c1 = input.charAt (mymatch.index + i - b);
char c2 = input.charAt (i);
if (c1 != c2)
{
if (insens)
{
if (c1 != toLowerCase (c2, unicodeAware) &&
c1 != toUpperCase (c2, unicodeAware))
{
return null;
}
}
}
mymatch.index += e-b;
return mymatch;
}
void dump(StringBuffer os) {
os.append('\\').append(num);
}
}
}
else
{
return null;
}
}
}
mymatch.index += e - b;
return mymatch;
}
void dump (CPStringBuilder os)
{
os.append ('\\').append (num);
}
}
libjava/classpath/gnu/java/util/regex/RETokenChar.java
+101 -74
View File
@@ -38,98 +38,125 @@ exception statement from your version. */
package gnu.java.util.regex;
final class RETokenChar extends REToken {
import gnu.java.lang.CPStringBuilder;
final class RETokenChar extends REToken
{
private char[] ch;
private boolean insens;
RETokenChar(int subIndex, char c, boolean ins) {
super(subIndex);
RETokenChar (int subIndex, char c, boolean ins)
{
super (subIndex);
insens = ins;
ch = new char [1];
ch[0] = c;
ch = new char[1];
ch[0] = c;
}
int getMinimumLength() {
int getMinimumLength ()
{
return ch.length;
}
int getMaximumLength() {
int getMaximumLength ()
{
return ch.length;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
if (matchOneString(input, mymatch.index)) {
mymatch.index += matchedLength;
return mymatch;
}
// java.util.regex.Matcher#hitEnd() requires that the length of
// partial match be counted.
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
if (matchOneString (input, mymatch.index))
{
mymatch.index += matchedLength;
input.setHitEnd(mymatch);
return null;
}
return mymatch;
}
// java.util.regex.Matcher#hitEnd() requires that the length of
// partial match be counted.
mymatch.index += matchedLength;
input.setHitEnd (mymatch);
return null;
}
private int matchedLength;
private boolean matchOneString(CharIndexed input, int index) {
matchedLength = 0;
int z = ch.length;
char c;
for (int i=0; i<z; i++) {
c = input.charAt(index+i);
if (! charEquals(c, ch[i])) {
return false;
}
++matchedLength;
}
return true;
}
private int matchedLength;
private boolean matchOneString (CharIndexed input, int index)
{
matchedLength = 0;
int z = ch.length;
char c;
for (int i = 0; i < z; i++)
{
c = input.charAt (index + i);
if (!charEquals (c, ch[i]))
{
return false;
}
++matchedLength;
}
return true;
}
private boolean charEquals(char c1, char c2) {
if (c1 == c2) return true;
if (! insens) return false;
if (toLowerCase(c1, unicodeAware) == c2) return true;
if (toUpperCase(c1, unicodeAware) == c2) return true;
return false;
}
private boolean charEquals (char c1, char c2)
{
if (c1 == c2)
return true;
if (!insens)
return false;
if (toLowerCase (c1, unicodeAware) == c2)
return true;
if (toUpperCase (c1, unicodeAware) == c2)
return true;
return false;
}
boolean returnsFixedLengthMatches() { return true; }
boolean returnsFixedLengthMatches ()
{
return true;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
int index = mymatch.index;
int numRepeats = 0;
int z = ch.length;
while (true) {
if (numRepeats >= max) break;
if (matchOneString(input, index)) {
index += z;
numRepeats++;
}
else break;
}
return numRepeats;
}
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
int index = mymatch.index;
int numRepeats = 0;
int z = ch.length;
while (true)
{
if (numRepeats >= max)
break;
if (matchOneString (input, index))
{
index += z;
numRepeats++;
}
else
break;
}
return numRepeats;
}
// Overrides REToken.chain() to optimize for strings
boolean chain(REToken next) {
if (next instanceof RETokenChar && ((RETokenChar)next).insens == insens) {
RETokenChar cnext = (RETokenChar) next;
int newsize = ch.length + cnext.ch.length;
char[] chTemp = new char [newsize];
System.arraycopy(ch,0,chTemp,0,ch.length);
System.arraycopy(cnext.ch,0,chTemp,ch.length,cnext.ch.length);
ch = chTemp;
if (cnext.next == null)
return false;
return chain(cnext.next);
} else return super.chain(next);
boolean chain (REToken next)
{
if (next instanceof RETokenChar && ((RETokenChar) next).insens == insens)
{
RETokenChar cnext = (RETokenChar) next;
int newsize = ch.length + cnext.ch.length;
char[] chTemp = new char[newsize];
System.arraycopy (ch, 0, chTemp, 0, ch.length);
System.arraycopy (cnext.ch, 0, chTemp, ch.length, cnext.ch.length);
ch = chTemp;
if (cnext.next == null)
return false;
return chain (cnext.next);
}
else
return super.chain (next);
}
void dump(StringBuffer os) {
os.append(ch);
void dump (CPStringBuilder os)
{
os.append (ch);
}
}
libjava/classpath/gnu/java/util/regex/RETokenEnd.java
+76 -49
View File
@@ -38,7 +38,10 @@ exception statement from your version. */
package gnu.java.util.regex;
final class RETokenEnd extends REToken {
import gnu.java.lang.CPStringBuilder;
final class RETokenEnd extends REToken
{
/**
* Indicates whether this token should match on a line break.
*/
@@ -51,74 +54,98 @@ final class RETokenEnd extends REToken {
*/
private boolean fake = false;
RETokenEnd(int subIndex,String newline) {
super(subIndex);
RETokenEnd (int subIndex, String newline)
{
super (subIndex);
this.newline = newline;
this.check_java_line_terminators = false;
}
RETokenEnd(int subIndex, String newline, boolean b) {
super(subIndex);
RETokenEnd (int subIndex, String newline, boolean b)
{
super (subIndex);
this.newline = newline;
this.check_java_line_terminators = b;
}
void setFake(boolean fake) {
void setFake (boolean fake)
{
this.fake = fake;
}
int getMaximumLength() {
int getMaximumLength ()
{
return 0;
}
boolean match(CharIndexed input, REMatch mymatch) {
if (!fake) return super.match(input, mymatch);
return super.matchFake(input, mymatch);
boolean match (CharIndexed input, REMatch mymatch)
{
if (!fake)
return super.match (input, mymatch);
return super.matchFake (input, mymatch);
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
char ch = input.charAt(mymatch.index);
if (ch == CharIndexed.OUT_OF_BOUNDS)
return ((mymatch.eflags & RE.REG_NOTEOL)>0) ?
null : mymatch;
if (check_java_line_terminators) {
if (ch == '\n') {
char ch1 = input.charAt(mymatch.index - 1);
if (ch1 == '\r') return null;
return mymatch;
}
if (ch == '\r') return mymatch;
if (ch == '\u0085') return mymatch; // A next-line character
if (ch == '\u2028') return mymatch; // A line-separator character
if (ch == '\u2029') return mymatch; // A paragraph-separator character
return null;
}
if (newline != null) {
char z;
int i = 0; // position in newline
do {
z = newline.charAt(i);
if (ch != z) return null;
++i;
ch = input.charAt(mymatch.index + i);
} while (i < newline.length());
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
char ch = input.charAt (mymatch.index);
if (ch == CharIndexed.OUT_OF_BOUNDS)
return ((mymatch.eflags & RE.REG_NOTEOL) > 0) ? null : mymatch;
if (check_java_line_terminators)
{
if (ch == '\n')
{
char ch1 = input.charAt (mymatch.index - 1);
if (ch1 == '\r')
return null;
return mymatch;
}
}
if (ch == '\r')
return mymatch;
if (ch == '\u0085')
return mymatch; // A next-line character
if (ch == '\u2028')
return mymatch; // A line-separator character
if (ch == '\u2029')
return mymatch; // A paragraph-separator character
return null;
}
}
if (newline != null)
{
char z;
int i = 0; // position in newline
do
{
z = newline.charAt (i);
if (ch != z)
return null;
++i;
ch = input.charAt (mymatch.index + i);
}
while (i < newline.length ());
boolean returnsFixedLengthMatches() { return true; }
return mymatch;
}
return null;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
REMatch m = (REMatch) mymatch.clone();
REToken tk = (REToken) this.clone();
tk.chain(null);
if (tk.match(input, m)) return max;
else return 0;
}
boolean returnsFixedLengthMatches ()
{
return true;
}
void dump(StringBuffer os) {
os.append('$');
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
REMatch m = (REMatch) mymatch.clone ();
REToken tk = (REToken) this.clone ();
tk.chain (null);
if (tk.match (input, m))
return max;
else
return 0;
}
void dump (CPStringBuilder os)
{
os.append ('$');
}
}
libjava/classpath/gnu/java/util/regex/RETokenEndOfPreviousMatch.java
+44 -28
View File
@@ -37,36 +37,52 @@ exception statement from your version. */
package gnu.java.util.regex;
class RETokenEndOfPreviousMatch extends RETokenStart {
import gnu.java.lang.CPStringBuilder;
RETokenEndOfPreviousMatch(int subIndex) {
super(subIndex, null);
}
class RETokenEndOfPreviousMatch extends RETokenStart
{
int getMaximumLength() {
return 0;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
REMatch lastMatch = input.getLastMatch();
if (lastMatch == null) return super.matchThis(input, mymatch);
if (input.getAnchor()+mymatch.index ==
lastMatch.anchor+lastMatch.index) {
return mymatch;
}
else {
return null;
}
}
RETokenEndOfPreviousMatch (int subIndex)
{
super (subIndex, null);
}
boolean returnsFixedLengthmatches() { return true; }
int getMaximumLength ()
{
return 0;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
if (matchThis(input, mymatch) != null) return max;
else return 0;
}
void dump(StringBuffer os) {
os.append("\\G");
}
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
REMatch lastMatch = input.getLastMatch ();
if (lastMatch == null)
return super.matchThis (input, mymatch);
if (input.getAnchor () + mymatch.index ==
lastMatch.anchor + lastMatch.index)
{
return mymatch;
}
else
{
return null;
}
}
boolean returnsFixedLengthmatches ()
{
return true;
}
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
if (matchThis (input, mymatch) != null)
return max;
else
return 0;
}
void dump (CPStringBuilder os)
{
os.append ("\\G");
}
}
libjava/classpath/gnu/java/util/regex/RETokenEndSub.java
+35 -26
View File
@@ -37,34 +37,43 @@ exception statement from your version. */
package gnu.java.util.regex;
final class RETokenEndSub extends REToken {
RETokenEndSub(int subIndex) {
super(subIndex);
}
import gnu.java.lang.CPStringBuilder;
int getMaximumLength() {
return 0;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
mymatch.start[subIndex] = mymatch.start1[subIndex];
mymatch.end[subIndex] = mymatch.index;
return mymatch;
}
final class RETokenEndSub extends REToken
{
RETokenEndSub (int subIndex)
{
super (subIndex);
}
REMatch findMatch(CharIndexed input, REMatch mymatch) {
mymatch.start[subIndex] = mymatch.start1[subIndex];
mymatch.end[subIndex] = mymatch.index;
return super.findMatch(input, mymatch);
}
int getMaximumLength ()
{
return 0;
}
void setHitEnd(CharIndexed input, REMatch mymatch) {
// Do nothing
}
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
mymatch.start[subIndex] = mymatch.start1[subIndex];
mymatch.end[subIndex] = mymatch.index;
return mymatch;
}
void dump(StringBuffer os) {
// handled by RE
// But add something for debugging.
os.append("(?#RETokenEndSub subIndex=" + subIndex + ")");
}
REMatch findMatch (CharIndexed input, REMatch mymatch)
{
mymatch.start[subIndex] = mymatch.start1[subIndex];
mymatch.end[subIndex] = mymatch.index;
return super.findMatch (input, mymatch);
}
void setHitEnd (CharIndexed input, REMatch mymatch)
{
// Do nothing
}
void dump (CPStringBuilder os)
{
// handled by RE
// But add something for debugging.
os.append ("(?#RETokenEndSub subIndex=" + subIndex + ")");
}
}
libjava/classpath/gnu/java/util/regex/RETokenIndependent.java
+30 -23
View File
@@ -37,6 +37,8 @@ exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
/**
* @author Ito Kazumitsu
*/
@@ -44,35 +46,40 @@ final class RETokenIndependent extends REToken
{
REToken re;
RETokenIndependent(REToken re) throws REException {
super(0);
RETokenIndependent (REToken re) throws REException
{
super (0);
this.re = re;
}
int getMinimumLength() {
return re.getMinimumLength();
}
int getMaximumLength() {
return re.getMaximumLength();
}
REMatch matchThis(CharIndexed input, REMatch mymatch)
int getMinimumLength ()
{
boolean b = re.match(input, mymatch);
if (b) {
// Once we have found a match, we do not see other possible matches.
if (mymatch.backtrackStack != null) mymatch.backtrackStack.clear();
return mymatch;
return re.getMinimumLength ();
}
}
int getMaximumLength ()
{
return re.getMaximumLength ();
}
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
boolean b = re.match (input, mymatch);
if (b)
{
// Once we have found a match, we do not see other possible matches.
if (mymatch.backtrackStack != null)
mymatch.backtrackStack.clear ();
return mymatch;
}
return null;
}
void dump(StringBuffer os) {
os.append("(?>");
re.dumpAll(os);
os.append(')');
}
void dump (CPStringBuilder os)
{
os.append ("(?>");
re.dumpAll (os);
os.append (')');
}
}
libjava/classpath/gnu/java/util/regex/RETokenLookAhead.java
+29 -21
View File
@@ -37,6 +37,8 @@ exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
/**
* @since gnu.regexp 1.1.3
* @author Shashank Bapat
@@ -46,35 +48,41 @@ final class RETokenLookAhead extends REToken
REToken re;
boolean negative;
RETokenLookAhead(REToken re, boolean negative) throws REException {
super(0);
RETokenLookAhead (REToken re, boolean negative) throws REException
{
super (0);
this.re = re;
this.negative = negative;
}
int getMaximumLength() {
int getMaximumLength ()
{
return 0;
}
REMatch matchThis(CharIndexed input, REMatch mymatch)
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
REMatch trymatch = (REMatch)mymatch.clone();
if (re.match(input, trymatch)) {
if (negative) return null;
trymatch.index = mymatch.index;
return trymatch;
}
else {
if (negative) return mymatch;
return null;
}
REMatch trymatch = (REMatch) mymatch.clone ();
if (re.match (input, trymatch))
{
if (negative)
return null;
trymatch.index = mymatch.index;
return trymatch;
}
else
{
if (negative)
return mymatch;
return null;
}
}
void dump(StringBuffer os) {
os.append("(?");
os.append(negative ? '!' : '=');
re.dumpAll(os);
os.append(')');
}
void dump (CPStringBuilder os)
{
os.append ("(?");
os.append (negative ? '!' : '=');
re.dumpAll (os);
os.append (')');
}
}
libjava/classpath/gnu/java/util/regex/RETokenLookBehind.java
+69 -51
View File
@@ -37,6 +37,8 @@ exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
/**
* @author Ito Kazumitsu
*/
@@ -45,74 +47,90 @@ final class RETokenLookBehind extends REToken
REToken re;
boolean negative;
RETokenLookBehind(REToken re, boolean negative) throws REException {
super(0);
RETokenLookBehind (REToken re, boolean negative) throws REException
{
super (0);
this.re = re;
this.negative = negative;
}
int getMaximumLength() {
int getMaximumLength ()
{
return 0;
}
REMatch matchThis(CharIndexed input, REMatch mymatch)
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
int max = re.getMaximumLength();
CharIndexed behind = input.lookBehind(mymatch.index, max);
REMatch trymatch = (REMatch)mymatch.clone();
REMatch trymatch1 = (REMatch)mymatch.clone();
REMatch newMatch = null;
int diff = behind.length() - input.length();
int max = re.getMaximumLength ();
CharIndexed behind = input.lookBehind (mymatch.index, max);
REMatch trymatch = (REMatch) mymatch.clone ();
int diff = behind.length () - input.length ();
int curIndex = trymatch.index + diff;
trymatch.index = 0;
trymatch.offset = 0;
RETokenMatchHereOnly stopper = new RETokenMatchHereOnly(curIndex);
REToken re1 = (REToken) re.clone();
re1.chain(stopper);
if (re1.match(behind, trymatch)) {
if (negative) return null;
for (int i = 0; i < trymatch.start.length; i++) {
if (trymatch.start[i] != -1 && trymatch.end[i] != -1) {
trymatch.start[i] -= diff;
if (trymatch.start[i] < 0) trymatch.start[i] -= 1;
trymatch.end[i] -= diff;
if (trymatch.end[i] < 0) trymatch.end[i] -= 1;
RETokenMatchHereOnly stopper = new RETokenMatchHereOnly (curIndex);
REToken re1 = (REToken) re.clone ();
re1.chain (stopper);
if (re1.match (behind, trymatch))
{
if (negative)
return null;
for (int i = 0; i < trymatch.start.length; i++)
{
if (trymatch.start[i] != -1 && trymatch.end[i] != -1)
{
trymatch.start[i] -= diff;
if (trymatch.start[i] < 0)
trymatch.start[i] -= 1;
trymatch.end[i] -= diff;
if (trymatch.end[i] < 0)
trymatch.end[i] -= 1;
}
}
trymatch.index = mymatch.index;
trymatch.offset = mymatch.offset;
return trymatch;
}
else
{
if (negative)
return mymatch;
return null;
}
trymatch.index = mymatch.index;
trymatch.offset = mymatch.offset;
return trymatch;
}
else {
if (negative) return mymatch;
return null;
}
}
void dump(StringBuffer os) {
os.append("(?<");
os.append(negative ? '!' : '=');
re.dumpAll(os);
os.append(')');
void dump (CPStringBuilder os)
{
os.append ("(?<");
os.append (negative ? '!' : '=');
re.dumpAll (os);
os.append (')');
}
private static class RETokenMatchHereOnly extends REToken
{
int getMaximumLength ()
{
return 0;
}
private static class RETokenMatchHereOnly extends REToken {
int getMaximumLength() { return 0; }
private int index;
RETokenMatchHereOnly(int index) {
super(0);
this.index = index;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
return (index == mymatch.index ? mymatch : null);
}
void dump(StringBuffer os) {}
private int index;
RETokenMatchHereOnly (int index)
{
super (0);
this.index = index;
}
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
return (index == mymatch.index ? mymatch : null);
}
void dump (CPStringBuilder os)
{
}
}
}
libjava/classpath/gnu/java/util/regex/RETokenNamedProperty.java
+281 -244
View File
@@ -38,303 +38,341 @@ exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
final class RETokenNamedProperty extends REToken {
final class RETokenNamedProperty extends REToken
{
String name;
boolean insens;
boolean negate;
Handler handler;
// Grouped properties
static final byte[] LETTER = new byte[]
{ Character.LOWERCASE_LETTER,
static final byte[] LETTER = new byte[]{ Character.LOWERCASE_LETTER,
Character.UPPERCASE_LETTER,
Character.TITLECASE_LETTER,
Character.MODIFIER_LETTER,
Character.OTHER_LETTER };
static final byte[] MARK = new byte[]
{ Character.NON_SPACING_MARK,
Character.OTHER_LETTER
};
static final byte[] MARK = new byte[]{ Character.NON_SPACING_MARK,
Character.COMBINING_SPACING_MARK,
Character.ENCLOSING_MARK };
static final byte[] SEPARATOR = new byte[]
{ Character.SPACE_SEPARATOR,
Character.ENCLOSING_MARK
};
static final byte[] SEPARATOR = new byte[]{ Character.SPACE_SEPARATOR,
Character.LINE_SEPARATOR,
Character.PARAGRAPH_SEPARATOR };
static final byte[] SYMBOL = new byte[]
{ Character.MATH_SYMBOL,
Character.PARAGRAPH_SEPARATOR
};
static final byte[] SYMBOL = new byte[]{ Character.MATH_SYMBOL,
Character.CURRENCY_SYMBOL,
Character.MODIFIER_SYMBOL,
Character.OTHER_SYMBOL };
static final byte[] NUMBER = new byte[]
{ Character.DECIMAL_DIGIT_NUMBER,
Character.OTHER_SYMBOL
};
static final byte[] NUMBER = new byte[]{ Character.DECIMAL_DIGIT_NUMBER,
Character.LETTER_NUMBER,
Character.OTHER_NUMBER };
static final byte[] PUNCTUATION = new byte[]
{ Character.DASH_PUNCTUATION,
Character.OTHER_NUMBER
};
static final byte[] PUNCTUATION = new byte[]{ Character.DASH_PUNCTUATION,
Character.START_PUNCTUATION,
Character.END_PUNCTUATION,
Character.CONNECTOR_PUNCTUATION,
Character.OTHER_PUNCTUATION,
Character.INITIAL_QUOTE_PUNCTUATION,
Character.FINAL_QUOTE_PUNCTUATION};
static final byte[] OTHER = new byte[]
{ Character.CONTROL,
Character.FINAL_QUOTE_PUNCTUATION
};
static final byte[] OTHER = new byte[]{ Character.CONTROL,
Character.FORMAT,
Character.PRIVATE_USE,
Character.SURROGATE,
Character.UNASSIGNED };
Character.UNASSIGNED
};
RETokenNamedProperty(int subIndex, String name, boolean insens, boolean negate) throws REException {
super(subIndex);
RETokenNamedProperty (int subIndex, String name, boolean insens,
boolean negate) throws REException
{
super (subIndex);
this.name = name;
this.insens = insens;
this.negate = negate;
handler = getHandler(name);
handler = getHandler (name);
}
int getMinimumLength() {
return 1;
}
int getMinimumLength ()
{
return 1;
}
int getMaximumLength() {
return 1;
}
int getMaximumLength ()
{
return 1;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
char ch = input.charAt(mymatch.index);
boolean retval = matchOneChar(ch);
if (retval) {
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
char ch = input.charAt (mymatch.index);
boolean retval = matchOneChar (ch);
if (retval)
{
++mymatch.index;
return mymatch;
}
return null;
return null;
}
private boolean matchOneChar(char ch) {
private boolean matchOneChar (char ch)
{
if (ch == CharIndexed.OUT_OF_BOUNDS)
return false;
boolean retval = handler.includes(ch);
if (insens) {
retval = retval ||
handler.includes(toUpperCase(ch, unicodeAware)) ||
handler.includes(toLowerCase(ch, unicodeAware));
}
if (negate) retval = !retval;
boolean retval = handler.includes (ch);
if (insens)
{
retval = retval ||
handler.includes (toUpperCase (ch, unicodeAware)) ||
handler.includes (toLowerCase (ch, unicodeAware));
}
if (negate)
retval = !retval;
return retval;
}
boolean returnsFixedLengthMatches() { return true; }
boolean returnsFixedLengthMatches ()
{
return true;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
int index = mymatch.index;
int numRepeats = 0;
while (true) {
if (numRepeats >= max) break;
char ch = input.charAt(index++);
if (! matchOneChar(ch)) break;
while (true)
{
if (numRepeats >= max)
break;
char ch = input.charAt (index++);
if (!matchOneChar (ch))
break;
numRepeats++;
}
}
return numRepeats;
}
void dump(StringBuffer os) {
os.append("\\")
.append(negate ? "P" : "p")
.append("{" + name + "}");
void dump (CPStringBuilder os)
{
os.append ("\\").append (negate ? "P" : "p").append ("{" + name + "}");
}
private abstract static class Handler {
public abstract boolean includes(char c);
private abstract static class Handler
{
public abstract boolean includes (char c);
}
private Handler getHandler(String name) throws REException {
if (name.equals("Lower") ||
name.equals("Upper") ||
// name.equals("ASCII") ||
name.equals("Alpha") ||
name.equals("Digit") ||
name.equals("Alnum") ||
name.equals("Punct") ||
name.equals("Graph") ||
name.equals("Print") ||
name.equals("Blank") ||
name.equals("Cntrl") ||
name.equals("XDigit") ||
name.equals("Space") ) {
return new POSIXHandler(name);
private Handler getHandler (String name) throws REException
{
if (name.equals ("Lower") || name.equals ("Upper") ||
// name.equals("ASCII") ||
name.equals ("Alpha") ||
name.equals ("Digit") ||
name.equals ("Alnum") ||
name.equals ("Punct") ||
name.equals ("Graph") ||
name.equals ("Print") ||
name.equals ("Blank") ||
name.equals ("Cntrl") ||
name.equals ("XDigit") || name.equals ("Space"))
{
return new POSIXHandler (name);
}
if (name.startsWith("In")) {
try {
name = name.substring(2);
Character.UnicodeBlock block = Character.UnicodeBlock.forName(name);
return new UnicodeBlockHandler(block);
}
catch (IllegalArgumentException e) {
throw new REException("Invalid Unicode block name: " + name, REException.REG_ESCAPE, 0);
}
}
if (name.startsWith("Is")) {
name = name.substring(2);
}
// "grouped properties"
if (name.equals("L"))
return new UnicodeCategoriesHandler(LETTER);
if (name.equals("M"))
return new UnicodeCategoriesHandler(MARK);
if (name.equals("Z"))
return new UnicodeCategoriesHandler(SEPARATOR);
if (name.equals("S"))
return new UnicodeCategoriesHandler(SYMBOL);
if (name.equals("N"))
return new UnicodeCategoriesHandler(NUMBER);
if (name.equals("P"))
return new UnicodeCategoriesHandler(PUNCTUATION);
if (name.equals("C"))
return new UnicodeCategoriesHandler(OTHER);
if (name.equals("Mc"))
return new UnicodeCategoryHandler(Character.COMBINING_SPACING_MARK);
if (name.equals("Pc"))
return new UnicodeCategoryHandler(Character.CONNECTOR_PUNCTUATION);
if (name.equals("Cc"))
return new UnicodeCategoryHandler(Character.CONTROL);
if (name.equals("Sc"))
return new UnicodeCategoryHandler(Character.CURRENCY_SYMBOL);
if (name.equals("Pd"))
return new UnicodeCategoryHandler(Character.DASH_PUNCTUATION);
if (name.equals("Nd"))
return new UnicodeCategoryHandler(Character.DECIMAL_DIGIT_NUMBER);
if (name.equals("Me"))
return new UnicodeCategoryHandler(Character.ENCLOSING_MARK);
if (name.equals("Pe"))
return new UnicodeCategoryHandler(Character.END_PUNCTUATION);
if (name.equals("Pf"))
return new UnicodeCategoryHandler(Character.FINAL_QUOTE_PUNCTUATION);
if (name.equals("Cf"))
return new UnicodeCategoryHandler(Character.FORMAT);
if (name.equals("Pi"))
return new UnicodeCategoryHandler(Character.INITIAL_QUOTE_PUNCTUATION);
if (name.equals("Nl"))
return new UnicodeCategoryHandler(Character.LETTER_NUMBER);
if (name.equals("Zl"))
return new UnicodeCategoryHandler(Character.LINE_SEPARATOR);
if (name.equals("Ll"))
return new UnicodeCategoryHandler(Character.LOWERCASE_LETTER);
if (name.equals("Sm"))
return new UnicodeCategoryHandler(Character.MATH_SYMBOL);
if (name.equals("Lm"))
return new UnicodeCategoryHandler(Character.MODIFIER_LETTER);
if (name.equals("Sk"))
return new UnicodeCategoryHandler(Character.MODIFIER_SYMBOL);
if (name.equals("Mn"))
return new UnicodeCategoryHandler(Character.NON_SPACING_MARK);
if (name.equals("Lo"))
return new UnicodeCategoryHandler(Character.OTHER_LETTER);
if (name.equals("No"))
return new UnicodeCategoryHandler(Character.OTHER_NUMBER);
if (name.equals("Po"))
return new UnicodeCategoryHandler(Character.OTHER_PUNCTUATION);
if (name.equals("So"))
return new UnicodeCategoryHandler(Character.OTHER_SYMBOL);
if (name.equals("Zp"))
return new UnicodeCategoryHandler(Character.PARAGRAPH_SEPARATOR);
if (name.equals("Co"))
return new UnicodeCategoryHandler(Character.PRIVATE_USE);
if (name.equals("Zs"))
return new UnicodeCategoryHandler(Character.SPACE_SEPARATOR);
if (name.equals("Ps"))
return new UnicodeCategoryHandler(Character.START_PUNCTUATION);
if (name.equals("Cs"))
return new UnicodeCategoryHandler(Character.SURROGATE);
if (name.equals("Lt"))
return new UnicodeCategoryHandler(Character.TITLECASE_LETTER);
if (name.equals("Cn"))
return new UnicodeCategoryHandler(Character.UNASSIGNED);
if (name.equals("Lu"))
return new UnicodeCategoryHandler(Character.UPPERCASE_LETTER);
if (name.equals("all"))
return new Handler()
{
public boolean includes(char c)
{
return true;
}
};
if (name.startsWith("java"))
if (name.startsWith ("In"))
{
try
{
try
{
Method m = Character.class.getMethod("is" + name.substring(4),
Character.TYPE);
return new JavaCategoryHandler(m);
}
catch (NoSuchMethodException e)
{
throw new REException("Unsupported Java handler: " + name, e,
REException.REG_ESCAPE, 0);
}
name = name.substring (2);
Character.UnicodeBlock block =
Character.UnicodeBlock.forName (name);
return new UnicodeBlockHandler (block);
}
throw new REException("unsupported name " + name, REException.REG_ESCAPE, 0);
catch (IllegalArgumentException e)
{
throw new REException ("Invalid Unicode block name: " + name,
REException.REG_ESCAPE, 0);
}
}
if (name.startsWith ("Is"))
{
name = name.substring (2);
}
// "grouped properties"
if (name.equals ("L"))
return new UnicodeCategoriesHandler (LETTER);
if (name.equals ("M"))
return new UnicodeCategoriesHandler (MARK);
if (name.equals ("Z"))
return new UnicodeCategoriesHandler (SEPARATOR);
if (name.equals ("S"))
return new UnicodeCategoriesHandler (SYMBOL);
if (name.equals ("N"))
return new UnicodeCategoriesHandler (NUMBER);
if (name.equals ("P"))
return new UnicodeCategoriesHandler (PUNCTUATION);
if (name.equals ("C"))
return new UnicodeCategoriesHandler (OTHER);
if (name.equals ("Mc"))
return new UnicodeCategoryHandler (Character.COMBINING_SPACING_MARK);
if (name.equals ("Pc"))
return new UnicodeCategoryHandler (Character.CONNECTOR_PUNCTUATION);
if (name.equals ("Cc"))
return new UnicodeCategoryHandler (Character.CONTROL);
if (name.equals ("Sc"))
return new UnicodeCategoryHandler (Character.CURRENCY_SYMBOL);
if (name.equals ("Pd"))
return new UnicodeCategoryHandler (Character.DASH_PUNCTUATION);
if (name.equals ("Nd"))
return new UnicodeCategoryHandler (Character.DECIMAL_DIGIT_NUMBER);
if (name.equals ("Me"))
return new UnicodeCategoryHandler (Character.ENCLOSING_MARK);
if (name.equals ("Pe"))
return new UnicodeCategoryHandler (Character.END_PUNCTUATION);
if (name.equals ("Pf"))
return new UnicodeCategoryHandler (Character.FINAL_QUOTE_PUNCTUATION);
if (name.equals ("Cf"))
return new UnicodeCategoryHandler (Character.FORMAT);
if (name.equals ("Pi"))
return new UnicodeCategoryHandler (Character.INITIAL_QUOTE_PUNCTUATION);
if (name.equals ("Nl"))
return new UnicodeCategoryHandler (Character.LETTER_NUMBER);
if (name.equals ("Zl"))
return new UnicodeCategoryHandler (Character.LINE_SEPARATOR);
if (name.equals ("Ll"))
return new UnicodeCategoryHandler (Character.LOWERCASE_LETTER);
if (name.equals ("Sm"))
return new UnicodeCategoryHandler (Character.MATH_SYMBOL);
if (name.equals ("Lm"))
return new UnicodeCategoryHandler (Character.MODIFIER_LETTER);
if (name.equals ("Sk"))
return new UnicodeCategoryHandler (Character.MODIFIER_SYMBOL);
if (name.equals ("Mn"))
return new UnicodeCategoryHandler (Character.NON_SPACING_MARK);
if (name.equals ("Lo"))
return new UnicodeCategoryHandler (Character.OTHER_LETTER);
if (name.equals ("No"))
return new UnicodeCategoryHandler (Character.OTHER_NUMBER);
if (name.equals ("Po"))
return new UnicodeCategoryHandler (Character.OTHER_PUNCTUATION);
if (name.equals ("So"))
return new UnicodeCategoryHandler (Character.OTHER_SYMBOL);
if (name.equals ("Zp"))
return new UnicodeCategoryHandler (Character.PARAGRAPH_SEPARATOR);
if (name.equals ("Co"))
return new UnicodeCategoryHandler (Character.PRIVATE_USE);
if (name.equals ("Zs"))
return new UnicodeCategoryHandler (Character.SPACE_SEPARATOR);
if (name.equals ("Ps"))
return new UnicodeCategoryHandler (Character.START_PUNCTUATION);
if (name.equals ("Cs"))
return new UnicodeCategoryHandler (Character.SURROGATE);
if (name.equals ("Lt"))
return new UnicodeCategoryHandler (Character.TITLECASE_LETTER);
if (name.equals ("Cn"))
return new UnicodeCategoryHandler (Character.UNASSIGNED);
if (name.equals ("Lu"))
return new UnicodeCategoryHandler (Character.UPPERCASE_LETTER);
if (name.equals ("all"))
return new Handler ()
{
public boolean includes (char c)
{
return true;
}
};
if (name.startsWith ("java"))
{
try
{
Method m = Character.class.getMethod ("is" + name.substring (4),
Character.TYPE);
return new JavaCategoryHandler (m);
}
catch (NoSuchMethodException e)
{
throw new REException ("Unsupported Java handler: " + name, e,
REException.REG_ESCAPE, 0);
}
}
throw new REException ("unsupported name " + name, REException.REG_ESCAPE,
0);
}
private static class POSIXHandler extends Handler {
private RETokenPOSIX retoken;
public POSIXHandler(String name) {
int posixId = RETokenPOSIX.intValue(name.toLowerCase());
if (posixId != -1)
retoken = new RETokenPOSIX(0,posixId,false,false);
else
throw new RuntimeException("Unknown posix ID: " + name);
}
public boolean includes(char c) {
return retoken.matchOneChar(c);
}
private static class POSIXHandler extends Handler
{
private RETokenPOSIX retoken;
public POSIXHandler (String name)
{
int posixId = RETokenPOSIX.intValue (name.toLowerCase ());
if (posixId != -1)
retoken = new RETokenPOSIX (0, posixId, false, false);
else
throw new RuntimeException ("Unknown posix ID: " + name);
}
public boolean includes (char c)
{
return retoken.matchOneChar (c);
}
}
private static class UnicodeCategoryHandler extends Handler {
public UnicodeCategoryHandler(byte category) {
this.category = (int)category;
}
private int category;
public boolean includes(char c) {
return Character.getType(c) == category;
}
private static class UnicodeCategoryHandler extends Handler
{
public UnicodeCategoryHandler (byte category)
{
this.category = (int) category;
}
private int category;
public boolean includes (char c)
{
return Character.getType (c) == category;
}
}
private static class UnicodeCategoriesHandler extends Handler {
public UnicodeCategoriesHandler(byte[] categories) {
this.categories = categories;
}
private byte[] categories;
public boolean includes(char c) {
int category = Character.getType(c);
for (int i = 0; i < categories.length; i++)
if (category == categories[i])
return true;
return false;
}
private static class UnicodeCategoriesHandler extends Handler
{
public UnicodeCategoriesHandler (byte[]categories)
{
this.categories = categories;
}
private byte[] categories;
public boolean includes (char c)
{
int category = Character.getType (c);
for (int i = 0; i < categories.length; i++)
if (category == categories[i])
return true;
return false;
}
}
private static class UnicodeBlockHandler extends Handler {
public UnicodeBlockHandler(Character.UnicodeBlock block) {
this.block = block;
}
private Character.UnicodeBlock block;
public boolean includes(char c) {
Character.UnicodeBlock cblock = Character.UnicodeBlock.of(c);
return (cblock != null && cblock.equals(block));
}
private static class UnicodeBlockHandler extends Handler
{
public UnicodeBlockHandler (Character.UnicodeBlock block)
{
this.block = block;
}
private Character.UnicodeBlock block;
public boolean includes (char c)
{
Character.UnicodeBlock cblock = Character.UnicodeBlock.of (c);
return (cblock != null && cblock.equals (block));
}
}
/**
@@ -343,30 +381,29 @@ final class RETokenNamedProperty extends REToken {
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
*/
private static class JavaCategoryHandler
extends Handler
private static class JavaCategoryHandler extends Handler
{
private Method method;
public JavaCategoryHandler(Method m)
public JavaCategoryHandler (Method m)
{
this.method = m;
}
public boolean includes(char c)
public boolean includes (char c)
{
try
{
return (Boolean) method.invoke(null, c);
}
{
return (Boolean) method.invoke (null, c);
}
catch (IllegalAccessException e)
{
throw new InternalError("Unable to access method " + method);
}
{
throw new InternalError ("Unable to access method " + method);
}
catch (InvocationTargetException e)
{
throw new InternalError("Error invoking " + method);
}
{
throw new InternalError ("Error invoking " + method);
}
}
}
libjava/classpath/gnu/java/util/regex/RETokenOneOf.java
+213 -162
View File
@@ -36,23 +36,29 @@ obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.util.regex;
import java.util.Vector;
import java.util.Stack;
final class RETokenOneOf extends REToken {
private Vector options;
import gnu.java.lang.CPStringBuilder;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
final class RETokenOneOf extends REToken
{
private final List < REToken > options;
private boolean negative;
// True if this RETokenOneOf is supposed to match only one character,
// which is typically the case of a character class expression.
private boolean matchesOneChar;
private Vector addition;
// This Vector addition is used to store nested character classes.
private final List < Object > addition;
// This ArrayList addition is used to store nested character classes.
// For example, if the original expression is
// [2-7a-c[f-k][m-z]&&[^p-v][st]]
// the basic part /2-7a-c/ is stored in the Vector options, and
// the basic part /2-7a-c/ is stored in the ArrayList options, and
// the additional part /[f-k][m-z]&&[^p-v][st]/ is stored in the
// Vector addition in the following order (Reverse Polish Notation):
// ArrayList addition in the following order (Reverse Polish Notation):
// -- The matching result of the basic part is assumed here.
// [f-k] -- REToken
// "|" -- or
@@ -65,7 +71,7 @@ final class RETokenOneOf extends REToken {
// "|" -- or
// "&" -- and
//
// As it is clear from the explanation above, the Vector addition is
// As it is clear from the explanation above, the ArrayList addition is
// effective only when this REToken originates from a character class
// expression.
@@ -73,209 +79,254 @@ final class RETokenOneOf extends REToken {
// e.g. \d --> new RETokenOneOf("0123456789",false, ..)
// \D --> new RETokenOneOf("0123456789",true, ..)
RETokenOneOf(int subIndex, String optionsStr, boolean negative, boolean insens) {
super(subIndex);
options = new Vector();
RETokenOneOf (int subIndex, String optionsStr, boolean negative,
boolean insens)
{
super (subIndex);
options = new ArrayList < REToken > ();
this.negative = negative;
for (int i = 0; i < optionsStr.length(); i++)
options.addElement(new RETokenChar(subIndex,optionsStr.charAt(i),insens));
for (int i = 0; i < optionsStr.length (); i++)
options.add (new RETokenChar (subIndex, optionsStr.charAt (i), insens));
matchesOneChar = true;
addition = null;
}
RETokenOneOf(int subIndex, Vector options, boolean negative) {
super(subIndex);
this.options = options;
this.negative = negative;
matchesOneChar = negative;
RETokenOneOf (int subIndex, List < REToken > options, boolean negative)
{
this (subIndex, options, null, negative);
}
RETokenOneOf(int subIndex, Vector options, Vector addition, boolean negative) {
super(subIndex);
RETokenOneOf (int subIndex, List < REToken > options,
List < Object > addition, boolean negative)
{
super (subIndex);
this.options = options;
this.addition = addition;
this.negative = negative;
matchesOneChar = (negative || addition != null);
}
int getMinimumLength() {
if (matchesOneChar) return 1;
int getMinimumLength ()
{
if (matchesOneChar)
return 1;
int min = Integer.MAX_VALUE;
int x;
for (int i=0; i < options.size(); i++) {
if ((x = ((REToken) options.elementAt(i)).getMinimumLength()) < min)
min = x;
}
for (REToken t:options)
{
if ((x = t.getMinimumLength ()) < min)
min = x;
}
return min;
}
int getMaximumLength() {
if (matchesOneChar) return 1;
int getMaximumLength ()
{
if (matchesOneChar)
return 1;
int max = 0;
int x;
for (int i=0; i < options.size(); i++) {
if ((x = ((REToken) options.elementAt(i)).getMaximumLength()) > max)
max = x;
}
for (REToken t:options)
{
if ((x = t.getMaximumLength ()) > max)
max = x;
}
return max;
}
boolean match(CharIndexed input, REMatch mymatch) {
setHitEnd(input, mymatch);
if (matchesOneChar) return matchOneChar(input, mymatch);
else return matchOneRE(input, mymatch);
}
boolean match (CharIndexed input, REMatch mymatch)
{
setHitEnd (input, mymatch);
if (matchesOneChar)
return matchOneChar (input, mymatch);
else
return matchOneRE (input, mymatch);
}
boolean matchOneChar(CharIndexed input, REMatch mymatch) {
REMatch tryMatch;
boolean tryOnly;
if (addition == null) {
tryMatch = mymatch;
tryOnly = false;
boolean matchOneChar (CharIndexed input, REMatch mymatch)
{
REMatch tryMatch;
boolean tryOnly;
if (addition == null)
{
tryMatch = mymatch;
tryOnly = false;
}
else {
tryMatch = (REMatch) mymatch.clone();
tryOnly = true;
else
{
tryMatch = (REMatch) mymatch.clone ();
tryOnly = true;
}
boolean b = negative ?
matchN(input, tryMatch, tryOnly) :
matchP(input, tryMatch, tryOnly);
if (addition == null) return b;
boolean b = negative ?
matchN (input, tryMatch, tryOnly) : matchP (input, tryMatch, tryOnly);
if (addition == null)
return b;
Stack stack = new Stack();
stack.push(new Boolean(b));
for (int i=0; i < addition.size(); i++) {
Object obj = addition.elementAt(i);
if (obj instanceof REToken) {
b = ((REToken)obj).match(input, (REMatch)mymatch.clone());
stack.push(new Boolean(b));
}
else if (obj instanceof Boolean) {
stack.push(obj);
}
else if (obj.equals("|")) {
b = ((Boolean)stack.pop()).booleanValue();
b = ((Boolean)stack.pop()).booleanValue() || b;
stack.push(new Boolean(b));
}
else if (obj.equals("&")) {
b = ((Boolean)stack.pop()).booleanValue();
b = ((Boolean)stack.pop()).booleanValue() && b;
stack.push(new Boolean(b));
}
else {
throw new RuntimeException("Invalid object found");
}
final Deque < Boolean > stack = new ArrayDeque < Boolean > ();
stack.push (new Boolean (b));
for (Object obj:addition)
{
if (obj instanceof REToken)
{
b = ((REToken) obj).match (input, (REMatch) mymatch.clone ());
stack.push (new Boolean (b));
}
else if (obj instanceof Boolean)
{
stack.push ((Boolean) obj);
}
else if (obj.equals ("|"))
{
b = stack.pop ();
b = stack.pop () || b;
stack.push (new Boolean (b));
}
else if (obj.equals ("&"))
{
b = stack.pop ();
b = stack.pop () && b;
stack.push (new Boolean (b));
}
else
{
throw new RuntimeException ("Invalid object found");
}
}
b = ((Boolean)stack.pop()).booleanValue();
if (b) {
++mymatch.index;
return next(input, mymatch);
if (stack.pop ())
{
++mymatch.index;
return next (input, mymatch);
}
return false;
}
private boolean matchN (CharIndexed input, REMatch mymatch, boolean tryOnly)
{
if (input.charAt (mymatch.index) == CharIndexed.OUT_OF_BOUNDS)
return false;
}
private boolean matchN(CharIndexed input, REMatch mymatch, boolean tryOnly) {
if (input.charAt(mymatch.index) == CharIndexed.OUT_OF_BOUNDS)
return false;
REMatch newMatch = null;
REMatch last = null;
REToken tk;
for (int i=0; i < options.size(); i++) {
tk = (REToken) options.elementAt(i);
REMatch tryMatch = (REMatch) mymatch.clone();
if (tk.match(input, tryMatch)) { // match was successful
for (REToken tk:options)
{
REMatch tryMatch = (REMatch) mymatch.clone ();
if (tk.match (input, tryMatch))
{ // match was successful
return false;
} // is a match
} // try next option
} // is a match
} // try next option
if (tryOnly) return true;
++mymatch.index;
return next(input, mymatch);
}
if (tryOnly)
return true;
++mymatch.index;
return next (input, mymatch);
}
private boolean matchP(CharIndexed input, REMatch mymatch, boolean tryOnly) {
REToken tk;
for (int i=0; i < options.size(); i++) {
tk = (REToken) options.elementAt(i);
REMatch tryMatch = (REMatch) mymatch.clone();
if (tk.match(input, tryMatch)) { // match was successful
if (tryOnly) return true;
if (next(input, tryMatch)) {
mymatch.assignFrom(tryMatch);
private boolean matchP (CharIndexed input, REMatch mymatch, boolean tryOnly)
{
for (REToken tk:options)
{
REMatch tryMatch = (REMatch) mymatch.clone ();
if (tk.match (input, tryMatch))
{ // match was successful
if (tryOnly)
return true;
if (next (input, tryMatch))
{
mymatch.assignFrom (tryMatch);
return true;
}
}
}
}
return false;
}
return false;
}
private boolean matchOneRE(CharIndexed input, REMatch mymatch) {
REMatch newMatch = findMatch(input, mymatch);
if (newMatch != null) {
mymatch.assignFrom(newMatch);
return true;
private boolean matchOneRE (CharIndexed input, REMatch mymatch)
{
REMatch newMatch = findMatch (input, mymatch);
if (newMatch != null)
{
mymatch.assignFrom (newMatch);
return true;
}
return false;
return false;
}
REMatch findMatch(CharIndexed input, REMatch mymatch) {
if (matchesOneChar) return super.findMatch(input, mymatch);
return findMatch(input, mymatch, 0);
REMatch findMatch (CharIndexed input, REMatch mymatch)
{
if (matchesOneChar)
return super.findMatch (input, mymatch);
return findMatch (input, mymatch, 0);
}
REMatch backtrack(CharIndexed input, REMatch mymatch, Object param) {
return findMatch(input, mymatch, ((Integer)param).intValue());
REMatch backtrack (CharIndexed input, REMatch mymatch, Object param)
{
return findMatch (input, mymatch, ((Integer) param).intValue ());
}
private REMatch findMatch(CharIndexed input, REMatch mymatch, int optionIndex) {
for (int i = optionIndex; i < options.size(); i++) {
REToken tk = (REToken) options.elementAt(i);
tk = (REToken) tk.clone();
tk.chain(getNext());
REMatch tryMatch = (REMatch) mymatch.clone();
if (tryMatch.backtrackStack == null) {
tryMatch.backtrackStack = new BacktrackStack();
private REMatch findMatch (CharIndexed input, REMatch mymatch,
int optionIndex)
{
for (int i = optionIndex; i < options.size (); i++)
{
REToken tk = options.get (i);
tk = (REToken) tk.clone ();
tk.chain (getNext ());
REMatch tryMatch = (REMatch) mymatch.clone ();
if (tryMatch.backtrackStack == null)
{
tryMatch.backtrackStack = new BacktrackStack ();
}
boolean stackPushed = false;
if (i + 1 < options.size()) {
tryMatch.backtrackStack.push(new BacktrackStack.Backtrack(
this, input, mymatch, new Integer(i + 1)));
boolean stackPushed = false;
if (i + 1 < options.size ())
{
tryMatch.backtrackStack.push (new BacktrackStack.
Backtrack (this, input, mymatch,
i + 1));
stackPushed = true;
}
boolean b = tk.match(input, tryMatch);
if (b) {
return tryMatch;
}
if (stackPushed) tryMatch.backtrackStack.pop();
if (tk.match (input, tryMatch))
{
return tryMatch;
}
if (stackPushed)
tryMatch.backtrackStack.pop ();
}
return null;
return null;
}
boolean returnsFixedLengthMatches() { return matchesOneChar; }
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
if (!matchesOneChar)
return super.findFixedLengthMatches(input, mymatch, max);
int numRepeats = 0;
REMatch m = (REMatch) mymatch.clone();
REToken tk = (REToken) this.clone();
tk.chain(null);
while (true) {
if (numRepeats >= max) break;
m = tk.findMatch(input, m);
if (m == null) break;
numRepeats++;
}
return numRepeats;
boolean returnsFixedLengthMatches ()
{
return matchesOneChar;
}
void dump(StringBuffer os) {
os.append(negative ? "[^" : "(?:");
for (int i = 0; i < options.size(); i++) {
if (!negative && (i > 0)) os.append('|');
((REToken) options.elementAt(i)).dumpAll(os);
}
os.append(negative ? ']' : ')');
}
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
if (!matchesOneChar)
return super.findFixedLengthMatches (input, mymatch, max);
int numRepeats = 0;
REMatch m = (REMatch) mymatch.clone ();
REToken tk = (REToken) this.clone ();
tk.chain (null);
while (true)
{
if (numRepeats >= max)
break;
m = tk.findMatch (input, m);
if (m == null)
break;
numRepeats++;
}
return numRepeats;
}
void dump (CPStringBuilder os)
{
os.append (negative ? "[^" : "(?:");
for (int i = 0; i < options.size (); i++)
{
if (!negative && (i > 0))
os.append ('|');
options.get (i).dumpAll (os);
}
os.append (negative ? ']' : ')');
}
}
libjava/classpath/gnu/java/util/regex/RETokenPOSIX.java
+101 -73
View File
@@ -38,130 +38,158 @@ exception statement from your version. */
package gnu.java.util.regex;
final class RETokenPOSIX extends REToken {
import gnu.java.lang.CPStringBuilder;
final class RETokenPOSIX extends REToken
{
int type;
boolean insens;
boolean negated;
static final int ALNUM = 0;
static final int ALPHA = 1;
static final int BLANK = 2;
static final int CNTRL = 3;
static final int DIGIT = 4;
static final int GRAPH = 5;
static final int LOWER = 6;
static final int PRINT = 7;
static final int PUNCT = 8;
static final int SPACE = 9;
static final int UPPER = 10;
static final int ALNUM = 0;
static final int ALPHA = 1;
static final int BLANK = 2;
static final int CNTRL = 3;
static final int DIGIT = 4;
static final int GRAPH = 5;
static final int LOWER = 6;
static final int PRINT = 7;
static final int PUNCT = 8;
static final int SPACE = 9;
static final int UPPER = 10;
static final int XDIGIT = 11;
// Array indices correspond to constants defined above.
static final String[] s_nameTable = {
static final String[] s_nameTable = {
"alnum", "alpha", "blank", "cntrl", "digit", "graph", "lower",
"print", "punct", "space", "upper", "xdigit"
"print", "punct", "space", "upper", "xdigit"
};
// The RE constructor uses this to look up the constant for a string
static int intValue(String key) {
for (int i = 0; i < s_nameTable.length; i++) {
if (s_nameTable[i].equals(key)) return i;
}
static int intValue (String key)
{
for (int i = 0; i < s_nameTable.length; i++)
{
if (s_nameTable[i].equals (key))
return i;
}
return -1;
}
RETokenPOSIX(int subIndex, int type, boolean insens, boolean negated) {
super(subIndex);
RETokenPOSIX (int subIndex, int type, boolean insens, boolean negated)
{
super (subIndex);
this.type = type;
this.insens = insens;
this.negated = negated;
}
int getMinimumLength() {
return 1;
}
int getMinimumLength ()
{
return 1;
}
int getMaximumLength() {
return 1;
}
int getMaximumLength ()
{
return 1;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
char ch = input.charAt(mymatch.index);
boolean retval = matchOneChar(ch);
if (retval) {
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
char ch = input.charAt (mymatch.index);
boolean retval = matchOneChar (ch);
if (retval)
{
++mymatch.index;
return mymatch;
}
return null;
}
return null;
}
boolean matchOneChar(char ch) {
boolean matchOneChar (char ch)
{
if (ch == CharIndexed.OUT_OF_BOUNDS)
return false;
boolean retval = false;
switch (type) {
case ALNUM:
switch (type)
{
case ALNUM:
// Note that there is some debate over whether '_' should be included
retval = Character.isLetterOrDigit(ch) || (ch == '_');
retval = Character.isLetterOrDigit (ch) || (ch == '_');
break;
case ALPHA:
retval = Character.isLetter(ch);
case ALPHA:
retval = Character.isLetter (ch);
break;
case BLANK:
case BLANK:
retval = ((ch == ' ') || (ch == '\t'));
break;
case CNTRL:
retval = Character.isISOControl(ch);
case CNTRL:
retval = Character.isISOControl (ch);
break;
case DIGIT:
retval = Character.isDigit(ch);
case DIGIT:
retval = Character.isDigit (ch);
break;
case GRAPH:
retval = (!(Character.isWhitespace(ch) || Character.isISOControl(ch)));
case GRAPH:
retval =
(!(Character.isWhitespace (ch) || Character.isISOControl (ch)));
break;
case LOWER:
retval = ((insens && Character.isLetter(ch)) || Character.isLowerCase(ch));
case LOWER:
retval = ((insens && Character.isLetter (ch))
|| Character.isLowerCase (ch));
break;
case PRINT:
retval = (!(Character.isWhitespace(ch) || Character.isISOControl(ch)))
|| (ch == ' ');
case PRINT:
retval =
(!(Character.isWhitespace (ch) || Character.isISOControl (ch)))
|| (ch == ' ');
break;
case PUNCT:
case PUNCT:
// This feels sloppy, especially for non-U.S. locales.
retval = ("`~!@#$%^&*()-_=+[]{}\\|;:'\"/?,.<>".indexOf(ch)!=-1);
retval = ("`~!@#$%^&*()-_=+[]{}\\|;:'\"/?,.<>".indexOf (ch) != -1);
break;
case SPACE:
retval = Character.isWhitespace(ch);
case SPACE:
retval = Character.isWhitespace (ch);
break;
case UPPER:
retval = ((insens && Character.isLetter(ch)) || Character.isUpperCase(ch));
case UPPER:
retval = ((insens && Character.isLetter (ch))
|| Character.isUpperCase (ch));
break;
case XDIGIT:
retval = (Character.isDigit(ch) || ("abcdefABCDEF".indexOf(ch)!=-1));
case XDIGIT:
retval = (Character.isDigit (ch)
|| ("abcdefABCDEF".indexOf (ch) != -1));
break;
}
}
if (negated) retval = !retval;
if (negated)
retval = !retval;
return retval;
}
boolean returnsFixedLengthMatches() { return true; }
boolean returnsFixedLengthMatches ()
{
return true;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
int index = mymatch.index;
int numRepeats = 0;
while (true) {
if (numRepeats >= max) break;
char ch = input.charAt(index++);
if (! matchOneChar(ch)) break;
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
int index = mymatch.index;
int numRepeats = 0;
while (true)
{
if (numRepeats >= max)
break;
char ch = input.charAt (index++);
if (!matchOneChar (ch))
break;
numRepeats++;
}
return numRepeats;
return numRepeats;
}
void dump(StringBuffer os) {
if (negated) os.append('^');
os.append("[:" + s_nameTable[type] + ":]");
void dump (CPStringBuilder os)
{
if (negated)
os.append ('^');
os.append ("[:" + s_nameTable[type] + ":]");
}
}
libjava/classpath/gnu/java/util/regex/RETokenRange.java
+59 -40
View File
@@ -37,64 +37,83 @@ exception statement from your version. */
package gnu.java.util.regex;
final class RETokenRange extends REToken {
import gnu.java.lang.CPStringBuilder;
final class RETokenRange extends REToken
{
private char lo, hi;
private boolean insens;
RETokenRange(int subIndex, char lo, char hi, boolean ins) {
super(subIndex);
RETokenRange (int subIndex, char lo, char hi, boolean ins)
{
super (subIndex);
insens = ins;
this.lo = lo;
this.hi = hi;
}
int getMinimumLength() {
int getMinimumLength ()
{
return 1;
}
int getMaximumLength() {
int getMaximumLength ()
{
return 1;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
char c = input.charAt(mymatch.index);
if (matchOneChar(c)) {
++mymatch.index;
return mymatch;
}
return null;
}
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
char c = input.charAt (mymatch.index);
if (matchOneChar (c))
{
++mymatch.index;
return mymatch;
}
return null;
}
boolean matchOneChar(char c) {
if (c == CharIndexed.OUT_OF_BOUNDS) return false;
boolean matches = (c >= lo) && (c <= hi);
if (! matches && insens) {
char c1 = toLowerCase(c, unicodeAware);
matches = (c1 >= lo) && (c1 <= hi);
if (!matches) {
c1 = toUpperCase(c, unicodeAware);
boolean matchOneChar (char c)
{
if (c == CharIndexed.OUT_OF_BOUNDS)
return false;
boolean matches = (c >= lo) && (c <= hi);
if (!matches && insens)
{
char c1 = toLowerCase (c, unicodeAware);
matches = (c1 >= lo) && (c1 <= hi);
if (!matches)
{
c1 = toUpperCase (c, unicodeAware);
matches = (c1 >= lo) && (c1 <= hi);
}
}
return matches;
}
}
return matches;
}
boolean returnsFixedLengthMatches() { return true; }
boolean returnsFixedLengthMatches ()
{
return true;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
int index = mymatch.index;
int numRepeats = 0;
while (true) {
if (numRepeats >= max) break;
char ch = input.charAt(index++);
if (! matchOneChar(ch)) break;
numRepeats++;
}
return numRepeats;
}
void dump(StringBuffer os) {
os.append(lo).append('-').append(hi);
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
int index = mymatch.index;
int numRepeats = 0;
while (true)
{
if (numRepeats >= max)
break;
char ch = input.charAt (index++);
if (!matchOneChar (ch))
break;
numRepeats++;
}
return numRepeats;
}
void dump (CPStringBuilder os)
{
os.append (lo).append ('-').append (hi);
}
}
libjava/classpath/gnu/java/util/regex/RETokenRepeated.java
+519 -410
View File
File diff suppressed because it is too large Load Diff
libjava/classpath/gnu/java/util/regex/RETokenStart.java
+108 -76
View File
@@ -37,85 +37,117 @@ exception statement from your version. */
package gnu.java.util.regex;
class RETokenStart extends REToken {
private String newline; // matches after a newline
private boolean check_java_line_terminators;
RETokenStart(int subIndex, String newline) {
super(subIndex);
this.newline = newline;
this.check_java_line_terminators = false;
}
import gnu.java.lang.CPStringBuilder;
RETokenStart(int subIndex, String newline, boolean b) {
super(subIndex);
this.newline = newline;
this.check_java_line_terminators = b;
}
class RETokenStart extends REToken
{
private String newline; // matches after a newline
private boolean check_java_line_terminators;
int getMaximumLength() {
return 0;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
// charAt(index-n) may be unknown on a Reader/InputStream. FIXME
// Match after a newline if in multiline mode
if (check_java_line_terminators) {
char ch = input.charAt(mymatch.index - 1);
if (ch != CharIndexed.OUT_OF_BOUNDS) {
if (ch == '\n') return mymatch;
if (ch == '\r') {
char ch1 = input.charAt(mymatch.index);
if (ch1 != '\n') return mymatch;
return null;
}
if (ch == '\u0085') return mymatch; // A next-line character
if (ch == '\u2028') return mymatch; // A line-separator character
if (ch == '\u2029') return mymatch; // A paragraph-separator character
}
}
RETokenStart (int subIndex, String newline)
{
super (subIndex);
this.newline = newline;
this.check_java_line_terminators = false;
}
if (newline != null) {
int len = newline.length();
if (mymatch.offset >= len) {
boolean found = true;
char z;
int i = 0; // position in REToken.newline
char ch = input.charAt(mymatch.index - len);
do {
z = newline.charAt(i);
if (ch != z) {
found = false;
break;
}
++i;
ch = input.charAt(mymatch.index - len + i);
} while (i < len);
if (found) return mymatch;
}
}
// Don't match at all if REG_NOTBOL is set.
if ((mymatch.eflags & RE.REG_NOTBOL) > 0) return null;
if ((mymatch.eflags & RE.REG_ANCHORINDEX) > 0)
return (mymatch.anchor == mymatch.offset) ?
mymatch : null;
else
return ((mymatch.index == 0) && (mymatch.offset == 0)) ?
mymatch : null;
}
RETokenStart (int subIndex, String newline, boolean b)
{
super (subIndex);
this.newline = newline;
this.check_java_line_terminators = b;
}
boolean returnsFixedLengthmatches() { return true; }
@Override
int getMaximumLength ()
{
return 0;
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
if (matchThis(input, mymatch) != null) return max;
else return 0;
}
void dump(StringBuffer os) {
os.append('^');
}
@Override
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
// charAt(index-n) may be unknown on a Reader/InputStream. FIXME
// Match after a newline if in multiline mode
if (check_java_line_terminators)
{
char ch = input.charAt (mymatch.index - 1);
if (ch != CharIndexed.OUT_OF_BOUNDS)
{
if (ch == '\n')
return mymatch;
if (ch == '\r')
{
char ch1 = input.charAt (mymatch.index);
if (ch1 != '\n')
return mymatch;
return null;
}
if (ch == '\u0085')
return mymatch; // A next-line character
if (ch == '\u2028')
return mymatch; // A line-separator character
if (ch == '\u2029')
return mymatch; // A paragraph-separator character
}
}
if (newline != null)
{
int len = newline.length ();
if (mymatch.offset >= len)
{
boolean found = true;
char z;
int i = 0; // position in REToken.newline
char ch = input.charAt (mymatch.index - len);
do
{
z = newline.charAt (i);
if (ch != z)
{
found = false;
break;
}
++i;
ch = input.charAt (mymatch.index - len + i);
}
while (i < len);
if (found)
return mymatch;
}
}
// Don't match at all if REG_NOTBOL is set.
if ((mymatch.eflags & RE.REG_NOTBOL) > 0)
return null;
if ((mymatch.eflags & RE.REG_ANCHORINDEX) > 0)
return (mymatch.anchor == mymatch.offset) ? mymatch : null;
else
return ((mymatch.index == 0) && (mymatch.offset == 0)) ? mymatch : null;
}
@Override
boolean returnsFixedLengthMatches ()
{
return true;
}
@Override
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
if (matchThis (input, mymatch) != null)
return max;
else
return 0;
}
@Override
void dump (CPStringBuilder os)
{
os.append ('^');
}
}
libjava/classpath/gnu/java/util/regex/RETokenWordBoundary.java
+86 -61
View File
@@ -38,79 +38,104 @@ exception statement from your version. */
package gnu.java.util.regex;
import gnu.java.lang.CPStringBuilder;
/**
* Represents a combination lookahead/lookbehind for POSIX [:alnum:].
*/
final class RETokenWordBoundary extends REToken {
private boolean negated;
private int where;
static final int BEGIN = 1;
static final int END = 2;
final class RETokenWordBoundary extends REToken
{
private boolean negated;
private int where;
static final int BEGIN = 1;
static final int END = 2;
RETokenWordBoundary(int subIndex, int where, boolean negated) {
super(subIndex);
this.where = where;
this.negated = negated;
}
RETokenWordBoundary (int subIndex, int where, boolean negated)
{
super (subIndex);
this.where = where;
this.negated = negated;
}
int getMaximumLength() {
return 0;
}
int getMaximumLength ()
{
return 0;
}
REMatch matchThis(CharIndexed input, REMatch mymatch) {
// Word boundary means input[index-1] was a word character
// and input[index] is not, or input[index] is a word character
// and input[index-1] was not
// In the string "one two three", these positions match:
// |o|n|e| |t|w|o| |t|h|r|e|e|
// ^ ^ ^ ^ ^ ^
boolean after = false; // is current character a letter or digit?
boolean before = false; // is previous character a letter or digit?
char ch;
// TODO: Also check REG_ANCHORINDEX vs. anchor
if (((mymatch.eflags & RE.REG_ANCHORINDEX) != RE.REG_ANCHORINDEX)
|| (mymatch.offset + mymatch.index > mymatch.anchor)) {
if ((ch = input.charAt(mymatch.index - 1)) != CharIndexed.OUT_OF_BOUNDS) {
before = Character.isLetterOrDigit(ch) || (ch == '_');
}
}
REMatch matchThis (CharIndexed input, REMatch mymatch)
{
// Word boundary means input[index-1] was a word character
// and input[index] is not, or input[index] is a word character
// and input[index-1] was not
// In the string "one two three", these positions match:
// |o|n|e| |t|w|o| |t|h|r|e|e|
// ^ ^ ^ ^ ^ ^
boolean after = false; // is current character a letter or digit?
boolean before = false; // is previous character a letter or digit?
char ch;
if ((ch = input.charAt(mymatch.index)) != CharIndexed.OUT_OF_BOUNDS) {
after = Character.isLetterOrDigit(ch) || (ch == '_');
}
// TODO: Also check REG_ANCHORINDEX vs. anchor
if (((mymatch.eflags & RE.REG_ANCHORINDEX) != RE.REG_ANCHORINDEX)
|| (mymatch.offset + mymatch.index > mymatch.anchor))
{
if ((ch =
input.charAt (mymatch.index - 1)) != CharIndexed.OUT_OF_BOUNDS)
{
before = Character.isLetterOrDigit (ch) || (ch == '_');
}
}
// if (before) and (!after), we're at end (\>)
// if (after) and (!before), we're at beginning (\<)
boolean doNext = false;
if ((ch = input.charAt (mymatch.index)) != CharIndexed.OUT_OF_BOUNDS)
{
after = Character.isLetterOrDigit (ch) || (ch == '_');
}
if ((where & BEGIN) == BEGIN) {
doNext = after && !before;
}
if ((where & END) == END) {
doNext ^= before && !after;
}
// if (before) and (!after), we're at end (\>)
// if (after) and (!before), we're at beginning (\<)
boolean doNext = false;
if (negated) doNext = !doNext;
if ((where & BEGIN) == BEGIN)
{
doNext = after && !before;
}
if ((where & END) == END)
{
doNext ^= before && !after;
}
return (doNext ? mymatch : null);
}
if (negated)
doNext = !doNext;
boolean returnsFixedLengthMatches() { return true; }
return (doNext ? mymatch : null);
}
int findFixedLengthMatches(CharIndexed input, REMatch mymatch, int max) {
if(matchThis(input, mymatch) != null) return max;
else return 0;
}
void dump(StringBuffer os) {
if (where == (BEGIN | END)) {
os.append( negated ? "\\B" : "\\b" );
} else if (where == BEGIN) {
os.append("\\<");
} else {
os.append("\\>");
}
}
boolean returnsFixedLengthMatches ()
{
return true;
}
int findFixedLengthMatches (CharIndexed input, REMatch mymatch, int max)
{
if (matchThis (input, mymatch) != null)
return max;
else
return 0;
}
void dump (CPStringBuilder os)
{
if (where == (BEGIN | END))
{
os.append (negated ? "\\B" : "\\b");
}
else if (where == BEGIN)
{
os.append ("\\<");
}
else
{
os.append ("\\>");
}
}
}
libjava/classpath/gnu/java/util/regex/UncheckedRE.java
+18 -13
View File
@@ -55,7 +55,8 @@ package gnu.java.util.regex;
* @since gnu.regexp 1.1.4
*/
public final class UncheckedRE extends RE {
public final class UncheckedRE extends RE
{
/**
* Constructs a regular expression pattern buffer without any compilation
* flags set, and using the default syntax (RESyntax.RE_SYNTAX_PERL5).
@@ -66,8 +67,9 @@ public final class UncheckedRE extends RE {
* @exception RuntimeException The input pattern could not be parsed.
* @exception NullPointerException The pattern was null.
*/
public UncheckedRE(Object pattern) {
this(pattern,0,RESyntax.RE_SYNTAX_PERL5);
public UncheckedRE (Object pattern)
{
this (pattern, 0, RESyntax.RE_SYNTAX_PERL5);
}
/**
@@ -81,8 +83,9 @@ public final class UncheckedRE extends RE {
* @exception RuntimeException The input pattern could not be parsed.
* @exception NullPointerException The pattern was null.
*/
public UncheckedRE(Object pattern, int cflags) {
this(pattern,cflags,RESyntax.RE_SYNTAX_PERL5);
public UncheckedRE (Object pattern, int cflags)
{
this (pattern, cflags, RESyntax.RE_SYNTAX_PERL5);
}
/**
@@ -97,13 +100,15 @@ public final class UncheckedRE extends RE {
* @exception RuntimeException The input pattern could not be parsed.
* @exception NullPointerException The pattern was null.
*/
public UncheckedRE(Object pattern, int cflags, RESyntax syntax) {
try {
initialize(pattern,cflags,syntax,0,0);
} catch (REException e) {
throw new RuntimeException(e.getMessage());
}
public UncheckedRE (Object pattern, int cflags, RESyntax syntax)
{
try
{
initialize (pattern, cflags, syntax, 0, 0);
}
catch (REException e)
{
throw new RuntimeException (e.getMessage ());
}
}
}