From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../gnu/java/util/regex/BacktrackStack$Backtrack.h | 43 ++++++ libjava/gnu/java/util/regex/BacktrackStack.h | 50 +++++++ libjava/gnu/java/util/regex/CharIndexed.h | 48 +++++++ libjava/gnu/java/util/regex/CharIndexedCharArray.h | 38 ++++++ .../gnu/java/util/regex/CharIndexedCharSequence.h | 57 ++++++++ .../gnu/java/util/regex/CharIndexedInputStream.h | 64 +++++++++ libjava/gnu/java/util/regex/CharIndexedString.h | 36 +++++ .../gnu/java/util/regex/CharIndexedStringBuffer.h | 36 +++++ libjava/gnu/java/util/regex/RE$CharExpression.h | 42 ++++++ libjava/gnu/java/util/regex/RE$CharUnit.h | 39 ++++++ libjava/gnu/java/util/regex/RE$IntPair.h | 39 ++++++ libjava/gnu/java/util/regex/RE$NamedProperty.h | 40 ++++++ .../gnu/java/util/regex/RE$ParseCharClassResult.h | 41 ++++++ libjava/gnu/java/util/regex/RE.h | 150 +++++++++++++++++++++ libjava/gnu/java/util/regex/REException.h | 57 ++++++++ libjava/gnu/java/util/regex/REFilterInputStream.h | 51 +++++++ libjava/gnu/java/util/regex/REMatch.h | 68 ++++++++++ libjava/gnu/java/util/regex/REMatchEnumeration.h | 59 ++++++++ libjava/gnu/java/util/regex/RESyntax.h | 101 ++++++++++++++ libjava/gnu/java/util/regex/REToken.h | 75 +++++++++++ libjava/gnu/java/util/regex/RETokenAny.h | 52 +++++++ libjava/gnu/java/util/regex/RETokenBackRef.h | 47 +++++++ libjava/gnu/java/util/regex/RETokenChar.h | 60 +++++++++ libjava/gnu/java/util/regex/RETokenEnd.h | 54 ++++++++ .../java/util/regex/RETokenEndOfPreviousMatch.h | 47 +++++++ libjava/gnu/java/util/regex/RETokenEndSub.h | 47 +++++++ libjava/gnu/java/util/regex/RETokenIndependent.h | 48 +++++++ libjava/gnu/java/util/regex/RETokenLookAhead.h | 48 +++++++ .../regex/RETokenLookBehind$RETokenMatchHereOnly.h | 47 +++++++ libjava/gnu/java/util/regex/RETokenLookBehind.h | 48 +++++++ .../gnu/java/util/regex/RETokenNamedProperty$1.h | 41 ++++++ .../java/util/regex/RETokenNamedProperty$Handler.h | 39 ++++++ .../RETokenNamedProperty$JavaCategoryHandler.h | 39 ++++++ .../util/regex/RETokenNamedProperty$POSIXHandler.h | 40 ++++++ .../RETokenNamedProperty$UnicodeBlockHandler.h | 39 ++++++ ...RETokenNamedProperty$UnicodeCategoriesHandler.h | 41 ++++++ .../RETokenNamedProperty$UnicodeCategoryHandler.h | 39 ++++++ libjava/gnu/java/util/regex/RETokenNamedProperty.h | 68 ++++++++++ libjava/gnu/java/util/regex/RETokenOneOf.h | 66 +++++++++ libjava/gnu/java/util/regex/RETokenPOSIX.h | 68 ++++++++++ libjava/gnu/java/util/regex/RETokenRange.h | 53 ++++++++ .../util/regex/RETokenRepeated$DoablesFinder.h | 48 +++++++ .../util/regex/RETokenRepeated$FindMatchControl.h | 38 ++++++ .../java/util/regex/RETokenRepeated$StackedInfo.h | 44 ++++++ .../util/regex/RETokenRepeated$TryAnotherResult.h | 46 +++++++ libjava/gnu/java/util/regex/RETokenRepeated.h | 79 +++++++++++ libjava/gnu/java/util/regex/RETokenStart.h | 51 +++++++ libjava/gnu/java/util/regex/RETokenWordBoundary.h | 53 ++++++++ libjava/gnu/java/util/regex/UncheckedRE.h | 38 ++++++ 49 files changed, 2562 insertions(+) create mode 100644 libjava/gnu/java/util/regex/BacktrackStack$Backtrack.h create mode 100644 libjava/gnu/java/util/regex/BacktrackStack.h create mode 100644 libjava/gnu/java/util/regex/CharIndexed.h create mode 100644 libjava/gnu/java/util/regex/CharIndexedCharArray.h create mode 100644 libjava/gnu/java/util/regex/CharIndexedCharSequence.h create mode 100644 libjava/gnu/java/util/regex/CharIndexedInputStream.h create mode 100644 libjava/gnu/java/util/regex/CharIndexedString.h create mode 100644 libjava/gnu/java/util/regex/CharIndexedStringBuffer.h create mode 100644 libjava/gnu/java/util/regex/RE$CharExpression.h create mode 100644 libjava/gnu/java/util/regex/RE$CharUnit.h create mode 100644 libjava/gnu/java/util/regex/RE$IntPair.h create mode 100644 libjava/gnu/java/util/regex/RE$NamedProperty.h create mode 100644 libjava/gnu/java/util/regex/RE$ParseCharClassResult.h create mode 100644 libjava/gnu/java/util/regex/RE.h create mode 100644 libjava/gnu/java/util/regex/REException.h create mode 100644 libjava/gnu/java/util/regex/REFilterInputStream.h create mode 100644 libjava/gnu/java/util/regex/REMatch.h create mode 100644 libjava/gnu/java/util/regex/REMatchEnumeration.h create mode 100644 libjava/gnu/java/util/regex/RESyntax.h create mode 100644 libjava/gnu/java/util/regex/REToken.h create mode 100644 libjava/gnu/java/util/regex/RETokenAny.h create mode 100644 libjava/gnu/java/util/regex/RETokenBackRef.h create mode 100644 libjava/gnu/java/util/regex/RETokenChar.h create mode 100644 libjava/gnu/java/util/regex/RETokenEnd.h create mode 100644 libjava/gnu/java/util/regex/RETokenEndOfPreviousMatch.h create mode 100644 libjava/gnu/java/util/regex/RETokenEndSub.h create mode 100644 libjava/gnu/java/util/regex/RETokenIndependent.h create mode 100644 libjava/gnu/java/util/regex/RETokenLookAhead.h create mode 100644 libjava/gnu/java/util/regex/RETokenLookBehind$RETokenMatchHereOnly.h create mode 100644 libjava/gnu/java/util/regex/RETokenLookBehind.h create mode 100644 libjava/gnu/java/util/regex/RETokenNamedProperty$1.h create mode 100644 libjava/gnu/java/util/regex/RETokenNamedProperty$Handler.h create mode 100644 libjava/gnu/java/util/regex/RETokenNamedProperty$JavaCategoryHandler.h create mode 100644 libjava/gnu/java/util/regex/RETokenNamedProperty$POSIXHandler.h create mode 100644 libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeBlockHandler.h create mode 100644 libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeCategoriesHandler.h create mode 100644 libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeCategoryHandler.h create mode 100644 libjava/gnu/java/util/regex/RETokenNamedProperty.h create mode 100644 libjava/gnu/java/util/regex/RETokenOneOf.h create mode 100644 libjava/gnu/java/util/regex/RETokenPOSIX.h create mode 100644 libjava/gnu/java/util/regex/RETokenRange.h create mode 100644 libjava/gnu/java/util/regex/RETokenRepeated$DoablesFinder.h create mode 100644 libjava/gnu/java/util/regex/RETokenRepeated$FindMatchControl.h create mode 100644 libjava/gnu/java/util/regex/RETokenRepeated$StackedInfo.h create mode 100644 libjava/gnu/java/util/regex/RETokenRepeated$TryAnotherResult.h create mode 100644 libjava/gnu/java/util/regex/RETokenRepeated.h create mode 100644 libjava/gnu/java/util/regex/RETokenStart.h create mode 100644 libjava/gnu/java/util/regex/RETokenWordBoundary.h create mode 100644 libjava/gnu/java/util/regex/UncheckedRE.h (limited to 'libjava/gnu/java/util/regex') diff --git a/libjava/gnu/java/util/regex/BacktrackStack$Backtrack.h b/libjava/gnu/java/util/regex/BacktrackStack$Backtrack.h new file mode 100644 index 000000000..00d9e51fc --- /dev/null +++ b/libjava/gnu/java/util/regex/BacktrackStack$Backtrack.h @@ -0,0 +1,43 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_BacktrackStack$Backtrack__ +#define __gnu_java_util_regex_BacktrackStack$Backtrack__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class BacktrackStack$Backtrack; + class CharIndexed; + class REMatch; + class REToken; + } + } + } + } +} + +class gnu::java::util::regex::BacktrackStack$Backtrack : public ::java::lang::Object +{ + +public: // actually package-private + BacktrackStack$Backtrack(::gnu::java::util::regex::REToken *, ::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, ::java::lang::Object *); + ::gnu::java::util::regex::REToken * __attribute__((aligned(__alignof__( ::java::lang::Object)))) token; + ::gnu::java::util::regex::CharIndexed * input; + ::gnu::java::util::regex::REMatch * match; + ::java::lang::Object * param; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_BacktrackStack$Backtrack__ diff --git a/libjava/gnu/java/util/regex/BacktrackStack.h b/libjava/gnu/java/util/regex/BacktrackStack.h new file mode 100644 index 000000000..94ab3fdd6 --- /dev/null +++ b/libjava/gnu/java/util/regex/BacktrackStack.h @@ -0,0 +1,50 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_BacktrackStack__ +#define __gnu_java_util_regex_BacktrackStack__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class BacktrackStack; + class BacktrackStack$Backtrack; + } + } + } + } +} + +class gnu::java::util::regex::BacktrackStack : public ::java::lang::Object +{ + +public: // actually package-private + BacktrackStack(); + jboolean empty(); + ::gnu::java::util::regex::BacktrackStack$Backtrack * peek(); + ::gnu::java::util::regex::BacktrackStack$Backtrack * pop(); + void clear(); + void push(::gnu::java::util::regex::BacktrackStack$Backtrack *); + JArray< ::gnu::java::util::regex::BacktrackStack$Backtrack * > * __attribute__((aligned(__alignof__( ::java::lang::Object)))) stack; +private: + jint size; + jint capacity; + static const jint INITIAL_CAPACITY = 32; + static const jint CAPACITY_INCREMENT = 16; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_BacktrackStack__ diff --git a/libjava/gnu/java/util/regex/CharIndexed.h b/libjava/gnu/java/util/regex/CharIndexed.h new file mode 100644 index 000000000..0f2687a68 --- /dev/null +++ b/libjava/gnu/java/util/regex/CharIndexed.h @@ -0,0 +1,48 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_CharIndexed__ +#define __gnu_java_util_regex_CharIndexed__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + } + } + } + } +} + +class gnu::java::util::regex::CharIndexed : public ::java::lang::Object +{ + +public: + virtual jchar charAt(jint) = 0; + virtual jboolean move(jint) = 0; + virtual jboolean move1(jint) = 0; + virtual jboolean isValid() = 0; + virtual ::gnu::java::util::regex::CharIndexed * lookBehind(jint, jint) = 0; + virtual jint length() = 0; + virtual void setLastMatch(::gnu::java::util::regex::REMatch *) = 0; + virtual ::gnu::java::util::regex::REMatch * getLastMatch() = 0; + virtual void setHitEnd(::gnu::java::util::regex::REMatch *) = 0; + virtual jboolean hitEnd() = 0; + virtual jint getAnchor() = 0; + virtual void setAnchor(jint) = 0; + static const jchar OUT_OF_BOUNDS = 65535; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __gnu_java_util_regex_CharIndexed__ diff --git a/libjava/gnu/java/util/regex/CharIndexedCharArray.h b/libjava/gnu/java/util/regex/CharIndexedCharArray.h new file mode 100644 index 000000000..30e97db55 --- /dev/null +++ b/libjava/gnu/java/util/regex/CharIndexedCharArray.h @@ -0,0 +1,38 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_CharIndexedCharArray__ +#define __gnu_java_util_regex_CharIndexedCharArray__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexedCharArray; + } + } + } + } +} + +class gnu::java::util::regex::CharIndexedCharArray : public ::gnu::java::util::regex::CharIndexedCharSequence +{ + +public: // actually package-private + CharIndexedCharArray(JArray< jchar > *, jint); +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_CharIndexedCharArray__ diff --git a/libjava/gnu/java/util/regex/CharIndexedCharSequence.h b/libjava/gnu/java/util/regex/CharIndexedCharSequence.h new file mode 100644 index 000000000..f45b1460b --- /dev/null +++ b/libjava/gnu/java/util/regex/CharIndexedCharSequence.h @@ -0,0 +1,57 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_CharIndexedCharSequence__ +#define __gnu_java_util_regex_CharIndexedCharSequence__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexed; + class CharIndexedCharSequence; + class REMatch; + } + } + } + } +} + +class gnu::java::util::regex::CharIndexedCharSequence : public ::java::lang::Object +{ + +public: // actually package-private + CharIndexedCharSequence(::java::lang::CharSequence *, jint); +public: + virtual jchar charAt(jint); + virtual jboolean isValid(); + virtual jboolean move(jint); + virtual jboolean move1(jint); + virtual ::gnu::java::util::regex::CharIndexed * lookBehind(jint, jint); + virtual jint length(); + virtual void setLastMatch(::gnu::java::util::regex::REMatch *); + virtual ::gnu::java::util::regex::REMatch * getLastMatch(); + virtual void setHitEnd(::gnu::java::util::regex::REMatch *); + virtual jboolean hitEnd(); + virtual jint getAnchor(); + virtual void setAnchor(jint); +private: + ::java::lang::CharSequence * __attribute__((aligned(__alignof__( ::java::lang::Object)))) s; + jint anchor; + jint len; + ::gnu::java::util::regex::REMatch * lastMatch; + jint rightmostTriedPosition; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_CharIndexedCharSequence__ diff --git a/libjava/gnu/java/util/regex/CharIndexedInputStream.h b/libjava/gnu/java/util/regex/CharIndexedInputStream.h new file mode 100644 index 000000000..46c858266 --- /dev/null +++ b/libjava/gnu/java/util/regex/CharIndexedInputStream.h @@ -0,0 +1,64 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_CharIndexedInputStream__ +#define __gnu_java_util_regex_CharIndexedInputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexed; + class CharIndexedInputStream; + class REMatch; + } + } + } + } +} + +class gnu::java::util::regex::CharIndexedInputStream : public ::java::lang::Object +{ + +public: // actually package-private + CharIndexedInputStream(::java::io::InputStream *, jint); +private: + jboolean next(); +public: + virtual jchar charAt(jint); + virtual jboolean move(jint); + virtual jboolean isValid(); + virtual ::gnu::java::util::regex::CharIndexed * lookBehind(jint, jint); + virtual jint length(); + virtual void setLastMatch(::gnu::java::util::regex::REMatch *); + virtual ::gnu::java::util::regex::REMatch * getLastMatch(); + virtual void setHitEnd(::gnu::java::util::regex::REMatch *); + virtual jboolean hitEnd(); + virtual jint getAnchor(); + virtual void setAnchor(jint); + virtual jboolean move1(jint); +private: + static const jint BUFFER_INCREMENT = 1024; + static const jint UNKNOWN = 2147483647; + ::java::io::BufferedInputStream * __attribute__((aligned(__alignof__( ::java::lang::Object)))) br; + jint index; + jint bufsize; + jint end; + jchar cached; + JArray< jchar > * lookBehind__; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_CharIndexedInputStream__ diff --git a/libjava/gnu/java/util/regex/CharIndexedString.h b/libjava/gnu/java/util/regex/CharIndexedString.h new file mode 100644 index 000000000..e250a31d8 --- /dev/null +++ b/libjava/gnu/java/util/regex/CharIndexedString.h @@ -0,0 +1,36 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_CharIndexedString__ +#define __gnu_java_util_regex_CharIndexedString__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexedString; + } + } + } + } +} + +class gnu::java::util::regex::CharIndexedString : public ::gnu::java::util::regex::CharIndexedCharSequence +{ + +public: // actually package-private + CharIndexedString(::java::lang::String *, jint); +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_CharIndexedString__ diff --git a/libjava/gnu/java/util/regex/CharIndexedStringBuffer.h b/libjava/gnu/java/util/regex/CharIndexedStringBuffer.h new file mode 100644 index 000000000..497422bfa --- /dev/null +++ b/libjava/gnu/java/util/regex/CharIndexedStringBuffer.h @@ -0,0 +1,36 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_CharIndexedStringBuffer__ +#define __gnu_java_util_regex_CharIndexedStringBuffer__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexedStringBuffer; + } + } + } + } +} + +class gnu::java::util::regex::CharIndexedStringBuffer : public ::gnu::java::util::regex::CharIndexedCharSequence +{ + +public: // actually package-private + CharIndexedStringBuffer(::java::lang::StringBuffer *, jint); +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_CharIndexedStringBuffer__ diff --git a/libjava/gnu/java/util/regex/RE$CharExpression.h b/libjava/gnu/java/util/regex/RE$CharExpression.h new file mode 100644 index 000000000..d39ea7bc5 --- /dev/null +++ b/libjava/gnu/java/util/regex/RE$CharExpression.h @@ -0,0 +1,42 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RE$CharExpression__ +#define __gnu_java_util_regex_RE$CharExpression__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RE$CharExpression; + } + } + } + } +} + +class gnu::java::util::regex::RE$CharExpression : public ::java::lang::Object +{ + + RE$CharExpression(); +public: + virtual ::java::lang::String * toString(); +public: // actually package-private + RE$CharExpression(::gnu::java::util::regex::RE$CharExpression *); + jchar __attribute__((aligned(__alignof__( ::java::lang::Object)))) ch; + ::java::lang::String * expr; + jint len; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RE$CharExpression__ diff --git a/libjava/gnu/java/util/regex/RE$CharUnit.h b/libjava/gnu/java/util/regex/RE$CharUnit.h new file mode 100644 index 000000000..2ca308880 --- /dev/null +++ b/libjava/gnu/java/util/regex/RE$CharUnit.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RE$CharUnit__ +#define __gnu_java_util_regex_RE$CharUnit__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RE$CharUnit; + } + } + } + } +} + +class gnu::java::util::regex::RE$CharUnit : public ::java::lang::Object +{ + + RE$CharUnit(); +public: // actually package-private + RE$CharUnit(::gnu::java::util::regex::RE$CharUnit *); +public: + jchar __attribute__((aligned(__alignof__( ::java::lang::Object)))) ch; + jboolean bk; + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RE$CharUnit__ diff --git a/libjava/gnu/java/util/regex/RE$IntPair.h b/libjava/gnu/java/util/regex/RE$IntPair.h new file mode 100644 index 000000000..88019c293 --- /dev/null +++ b/libjava/gnu/java/util/regex/RE$IntPair.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RE$IntPair__ +#define __gnu_java_util_regex_RE$IntPair__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RE$IntPair; + } + } + } + } +} + +class gnu::java::util::regex::RE$IntPair : public ::java::lang::Object +{ + + RE$IntPair(); +public: // actually package-private + RE$IntPair(::gnu::java::util::regex::RE$IntPair *); +public: + jint __attribute__((aligned(__alignof__( ::java::lang::Object)))) first; + jint second; + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RE$IntPair__ diff --git a/libjava/gnu/java/util/regex/RE$NamedProperty.h b/libjava/gnu/java/util/regex/RE$NamedProperty.h new file mode 100644 index 000000000..a874f8500 --- /dev/null +++ b/libjava/gnu/java/util/regex/RE$NamedProperty.h @@ -0,0 +1,40 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RE$NamedProperty__ +#define __gnu_java_util_regex_RE$NamedProperty__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RE$NamedProperty; + } + } + } + } +} + +class gnu::java::util::regex::RE$NamedProperty : public ::java::lang::Object +{ + + RE$NamedProperty(); +public: // actually package-private + RE$NamedProperty(::gnu::java::util::regex::RE$NamedProperty *); + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) name; + jboolean negate; + jint len; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RE$NamedProperty__ diff --git a/libjava/gnu/java/util/regex/RE$ParseCharClassResult.h b/libjava/gnu/java/util/regex/RE$ParseCharClassResult.h new file mode 100644 index 000000000..539587703 --- /dev/null +++ b/libjava/gnu/java/util/regex/RE$ParseCharClassResult.h @@ -0,0 +1,41 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RE$ParseCharClassResult__ +#define __gnu_java_util_regex_RE$ParseCharClassResult__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RE$ParseCharClassResult; + class RETokenOneOf; + } + } + } + } +} + +class gnu::java::util::regex::RE$ParseCharClassResult : public ::java::lang::Object +{ + + RE$ParseCharClassResult(); +public: // actually package-private + RE$ParseCharClassResult(::gnu::java::util::regex::RE$ParseCharClassResult *); + ::gnu::java::util::regex::RETokenOneOf * __attribute__((aligned(__alignof__( ::java::lang::Object)))) token; + jint index; + jboolean returnAtAndOperator; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RE$ParseCharClassResult__ diff --git a/libjava/gnu/java/util/regex/RE.h b/libjava/gnu/java/util/regex/RE.h new file mode 100644 index 000000000..ee798b7ad --- /dev/null +++ b/libjava/gnu/java/util/regex/RE.h @@ -0,0 +1,150 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RE__ +#define __gnu_java_util_regex_RE__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class RE; + class RE$CharExpression; + class RE$CharUnit; + class RE$IntPair; + class RE$NamedProperty; + class RE$ParseCharClassResult; + class REMatch; + class REMatchEnumeration; + class RESyntax; + class REToken; + class RETokenNamedProperty; + } + } + } + } +} + +class gnu::java::util::regex::RE : public ::gnu::java::util::regex::REToken +{ + +public: + static ::java::lang::String * version(); +public: // actually package-private + static ::java::lang::String * getLocalizedMessage(::java::lang::String *); +public: + RE(::java::lang::Object *); + RE(::java::lang::Object *, jint); + RE(::java::lang::Object *, jint, ::gnu::java::util::regex::RESyntax *); +private: + RE(::gnu::java::util::regex::REToken *, ::gnu::java::util::regex::REToken *, jint, jint, jint, jint); + RE(::java::lang::Object *, jint, ::gnu::java::util::regex::RESyntax *, jint, jint); +public: // actually protected + RE(); + virtual void initialize(::java::lang::Object *, jint, ::gnu::java::util::regex::RESyntax *, jint, jint); +private: + static ::gnu::java::util::regex::RE$ParseCharClassResult * parseCharClass(jint, JArray< jchar > *, jint, jint, jint, ::gnu::java::util::regex::RESyntax *, jint); + static jint getCharUnit(JArray< jchar > *, jint, ::gnu::java::util::regex::RE$CharUnit *, jboolean); + static jint parseInt(JArray< jchar > *, jint, jint, jint); + static ::gnu::java::util::regex::RE$CharExpression * getCharExpression(JArray< jchar > *, jint, jint, ::gnu::java::util::regex::RESyntax *); + static ::gnu::java::util::regex::RE$NamedProperty * getNamedProperty(JArray< jchar > *, jint, jint); + static ::gnu::java::util::regex::RETokenNamedProperty * getRETokenNamedProperty(jint, ::gnu::java::util::regex::RE$NamedProperty *, jboolean, jint); +public: + virtual jboolean isMatch(::java::lang::Object *); + virtual jboolean isMatch(::java::lang::Object *, jint); + virtual jboolean isMatch(::java::lang::Object *, jint, jint); +private: + jboolean isMatchImpl(::gnu::java::util::regex::CharIndexed *, jint, jint); +public: + virtual jint getNumSubs(); +public: // actually package-private + virtual void setUncle(::gnu::java::util::regex::REToken *); + virtual jboolean chain(::gnu::java::util::regex::REToken *); +public: + virtual jint getMinimumLength(); + virtual jint getMaximumLength(); + virtual JArray< ::gnu::java::util::regex::REMatch * > * getAllMatches(::java::lang::Object *); + virtual JArray< ::gnu::java::util::regex::REMatch * > * getAllMatches(::java::lang::Object *, jint); + virtual JArray< ::gnu::java::util::regex::REMatch * > * getAllMatches(::java::lang::Object *, jint, jint); +private: + JArray< ::gnu::java::util::regex::REMatch * > * getAllMatchesImpl(::gnu::java::util::regex::CharIndexed *, jint, jint); +public: // actually package-private + virtual jboolean match(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + virtual ::gnu::java::util::regex::REMatch * findMatch(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +public: + virtual ::gnu::java::util::regex::REMatch * getMatch(::java::lang::Object *); + virtual ::gnu::java::util::regex::REMatch * getMatch(::java::lang::Object *, jint); + virtual ::gnu::java::util::regex::REMatch * getMatch(::java::lang::Object *, jint, jint); + virtual ::gnu::java::util::regex::REMatch * getMatch(::java::lang::Object *, jint, jint, ::gnu::java::lang::CPStringBuilder *); +public: // actually package-private + virtual ::gnu::java::util::regex::REMatch * getMatchImpl(::gnu::java::util::regex::CharIndexed *, jint, jint, ::gnu::java::lang::CPStringBuilder *); +public: + virtual ::gnu::java::util::regex::REMatchEnumeration * getMatchEnumeration(::java::lang::Object *); + virtual ::gnu::java::util::regex::REMatchEnumeration * getMatchEnumeration(::java::lang::Object *, jint); + virtual ::gnu::java::util::regex::REMatchEnumeration * getMatchEnumeration(::java::lang::Object *, jint, jint); + virtual ::java::lang::String * substitute(::java::lang::Object *, ::java::lang::String *); + virtual ::java::lang::String * substitute(::java::lang::Object *, ::java::lang::String *, jint); + virtual ::java::lang::String * substitute(::java::lang::Object *, ::java::lang::String *, jint, jint); +private: + ::java::lang::String * substituteImpl(::gnu::java::util::regex::CharIndexed *, ::java::lang::String *, jint, jint); +public: + virtual ::java::lang::String * substituteAll(::java::lang::Object *, ::java::lang::String *); + virtual ::java::lang::String * substituteAll(::java::lang::Object *, ::java::lang::String *, jint); + virtual ::java::lang::String * substituteAll(::java::lang::Object *, ::java::lang::String *, jint, jint); +private: + ::java::lang::String * substituteAllImpl(::gnu::java::util::regex::CharIndexed *, ::java::lang::String *, jint, jint); +public: + static ::java::lang::String * getReplacement(::java::lang::String *, ::gnu::java::util::regex::REMatch *, jint); +private: + void addToken(::gnu::java::util::regex::REToken *); + static ::gnu::java::util::regex::REToken * setRepeated(::gnu::java::util::regex::REToken *, jint, jint, jint); + static jint getPosixSet(JArray< jchar > *, jint, ::gnu::java::lang::CPStringBuilder *); + jint getMinMax(JArray< jchar > *, jint, ::gnu::java::util::regex::RE$IntPair *, ::gnu::java::util::regex::RESyntax *); +public: + virtual ::java::lang::String * toString(); +public: // actually package-private + virtual void dump(::gnu::java::lang::CPStringBuilder *); +public: + static ::gnu::java::util::regex::CharIndexed * makeCharIndexed(::java::lang::Object *, jint); +private: + static ::java::lang::String * VERSION; + static ::java::util::ResourceBundle * messages; + static ::java::lang::String * bundle; + ::gnu::java::util::regex::REToken * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) firstToken; + ::gnu::java::util::regex::REToken * lastToken; + jint numSubs; + jint minimumLength; + jint maximumLength; +public: + static const jint REG_ICASE = 2; + static const jint REG_DOT_NEWLINE = 4; + static const jint REG_MULTILINE = 8; + static const jint REG_NOTBOL = 16; + static const jint REG_NOTEOL = 32; + static const jint REG_ANCHORINDEX = 64; + static const jint REG_NO_INTERPOLATE = 128; + static const jint REG_TRY_ENTIRE_MATCH = 256; + static const jint REG_REPLACE_USE_BACKSLASHESCAPE = 512; + static const jint REG_X_COMMENTS = 1024; + static const jint REG_ICASE_USASCII = 2048; + static const jint REG_FIX_STARTING_POSITION = 4096; + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RE__ diff --git a/libjava/gnu/java/util/regex/REException.h b/libjava/gnu/java/util/regex/REException.h new file mode 100644 index 000000000..dc91d47cd --- /dev/null +++ b/libjava/gnu/java/util/regex/REException.h @@ -0,0 +1,57 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_REException__ +#define __gnu_java_util_regex_REException__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class REException; + } + } + } + } +} + +class gnu::java::util::regex::REException : public ::java::lang::Exception +{ + +public: // actually package-private + REException(::java::lang::String *, jint, jint); + REException(::java::lang::String *, ::java::lang::Throwable *, jint, jint); +public: + virtual jint getType(); + virtual jint getPosition(); + virtual ::java::lang::String * getMessage(); +private: + jint __attribute__((aligned(__alignof__( ::java::lang::Exception)))) type; + jint pos; +public: + static const jint REG_BADRPT = 1; + static const jint REG_BADBR = 2; + static const jint REG_EBRACE = 3; + static const jint REG_EBRACK = 4; + static const jint REG_ERANGE = 5; + static const jint REG_ECTYPE = 6; + static const jint REG_EPAREN = 7; + static const jint REG_ESUBREG = 8; + static const jint REG_EEND = 9; + static const jint REG_ESCAPE = 10; + static const jint REG_BADPAT = 11; + static const jint REG_ESIZE = 12; + static const jint REG_ESPACE = 13; + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_REException__ diff --git a/libjava/gnu/java/util/regex/REFilterInputStream.h b/libjava/gnu/java/util/regex/REFilterInputStream.h new file mode 100644 index 000000000..2bed26536 --- /dev/null +++ b/libjava/gnu/java/util/regex/REFilterInputStream.h @@ -0,0 +1,51 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_REFilterInputStream__ +#define __gnu_java_util_regex_REFilterInputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexedInputStream; + class RE; + class REFilterInputStream; + } + } + } + } +} + +class gnu::java::util::regex::REFilterInputStream : public ::java::io::FilterInputStream +{ + +public: + REFilterInputStream(::java::io::InputStream *, ::gnu::java::util::regex::RE *, ::java::lang::String *); + virtual jint read(); + virtual jboolean markSupported(); + virtual jint read(JArray< jbyte > *, jint, jint); + virtual jint read(JArray< jbyte > *); +private: + ::gnu::java::util::regex::RE * __attribute__((aligned(__alignof__( ::java::io::FilterInputStream)))) expr; + ::java::lang::String * replace; + ::java::lang::String * buffer; + jint bufpos; + jint offset; + ::gnu::java::util::regex::CharIndexedInputStream * stream; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_REFilterInputStream__ diff --git a/libjava/gnu/java/util/regex/REMatch.h b/libjava/gnu/java/util/regex/REMatch.h new file mode 100644 index 000000000..363bb74a4 --- /dev/null +++ b/libjava/gnu/java/util/regex/REMatch.h @@ -0,0 +1,68 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_REMatch__ +#define __gnu_java_util_regex_REMatch__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class BacktrackStack; + class CharIndexed; + class REMatch; + } + } + } + } +} + +class gnu::java::util::regex::REMatch : public ::java::lang::Object +{ + +public: + ::java::lang::Object * clone(); +public: // actually package-private + void assignFrom(::gnu::java::util::regex::REMatch *); + REMatch(jint, jint, jint); + void finish(::gnu::java::util::regex::CharIndexed *); + void clear(jint); +public: + ::java::lang::String * toString(); + jint getStartIndex(); + jint getEndIndex(); + ::java::lang::String * toString(jint); + jint getSubStartIndex(jint); + jint getStartIndex(jint); + jint getSubEndIndex(jint); + jint getEndIndex(jint); + ::java::lang::String * substituteInto(::java::lang::String *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) matchedText; + ::gnu::java::util::regex::CharIndexed * matchedCharIndexed; +public: // actually package-private + jint eflags; + jint offset; + jint anchor; + jint index; + JArray< jint > * start; + JArray< jint > * start1; + JArray< jint > * end; + jboolean empty; + ::gnu::java::util::regex::BacktrackStack * backtrackStack; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_REMatch__ diff --git a/libjava/gnu/java/util/regex/REMatchEnumeration.h b/libjava/gnu/java/util/regex/REMatchEnumeration.h new file mode 100644 index 000000000..6b0d888b7 --- /dev/null +++ b/libjava/gnu/java/util/regex/REMatchEnumeration.h @@ -0,0 +1,59 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_REMatchEnumeration__ +#define __gnu_java_util_regex_REMatchEnumeration__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class RE; + class REMatch; + class REMatchEnumeration; + } + } + } + } +} + +class gnu::java::util::regex::REMatchEnumeration : public ::java::lang::Object +{ + +public: // actually package-private + REMatchEnumeration(::gnu::java::util::regex::RE *, ::gnu::java::util::regex::CharIndexed *, jint, jint); +public: + virtual jboolean hasMoreElements(); + virtual jboolean hasMoreMatches(); + virtual jboolean hasMoreMatches(::gnu::java::lang::CPStringBuilder *); + virtual ::gnu::java::util::regex::REMatch * REMatchEnumeration$nextElement(); + virtual ::java::lang::Object * nextElement(); +private: + static const jint YES = 1; + static const jint MAYBE = 0; + static const jint NO = -1; + jint __attribute__((aligned(__alignof__( ::java::lang::Object)))) more; + ::gnu::java::util::regex::REMatch * match; + ::gnu::java::util::regex::RE * expr; + ::gnu::java::util::regex::CharIndexed * input; + jint eflags; + jint index; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_REMatchEnumeration__ diff --git a/libjava/gnu/java/util/regex/RESyntax.h b/libjava/gnu/java/util/regex/RESyntax.h new file mode 100644 index 000000000..59c8de002 --- /dev/null +++ b/libjava/gnu/java/util/regex/RESyntax.h @@ -0,0 +1,101 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RESyntax__ +#define __gnu_java_util_regex_RESyntax__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RESyntax; + } + } + } + } +} + +class gnu::java::util::regex::RESyntax : public ::java::lang::Object +{ + +public: + RESyntax(); + ::gnu::java::util::regex::RESyntax * makeFinal(); + RESyntax(::gnu::java::util::regex::RESyntax *); + jboolean get(jint); + ::gnu::java::util::regex::RESyntax * set(jint); + ::gnu::java::util::regex::RESyntax * clear(jint); + ::gnu::java::util::regex::RESyntax * setLineSeparator(::java::lang::String *); + ::java::lang::String * getLineSeparator(); +public: // actually package-private + static ::java::lang::String * DEFAULT_LINE_SEPARATOR; +private: + ::java::util::BitSet * __attribute__((aligned(__alignof__( ::java::lang::Object)))) bits; + jboolean isFinal; + ::java::lang::String * lineSeparator; +public: + static const jint RE_BACKSLASH_ESCAPE_IN_LISTS = 0; + static const jint RE_BK_PLUS_QM = 1; + static const jint RE_CHAR_CLASSES = 2; + static const jint RE_CONTEXT_INDEP_ANCHORS = 3; + static const jint RE_CONTEXT_INDEP_OPS = 4; + static const jint RE_CONTEXT_INVALID_OPS = 5; + static const jint RE_DOT_NEWLINE = 6; + static const jint RE_DOT_NOT_NULL = 7; + static const jint RE_INTERVALS = 8; + static const jint RE_LIMITED_OPS = 9; + static const jint RE_NEWLINE_ALT = 10; + static const jint RE_NO_BK_BRACES = 11; + static const jint RE_NO_BK_PARENS = 12; + static const jint RE_NO_BK_REFS = 13; + static const jint RE_NO_BK_VBAR = 14; + static const jint RE_NO_EMPTY_RANGES = 15; + static const jint RE_UNMATCHED_RIGHT_PAREN_ORD = 16; + static const jint RE_HAT_LISTS_NOT_NEWLINE = 17; + static const jint RE_STINGY_OPS = 18; + static const jint RE_CHAR_CLASS_ESCAPES = 19; + static const jint RE_PURE_GROUPING = 20; + static const jint RE_LOOKAHEAD = 21; + static const jint RE_STRING_ANCHORS = 22; + static const jint RE_COMMENTS = 23; + static const jint RE_CHAR_CLASS_ESC_IN_LISTS = 24; + static const jint RE_POSSESSIVE_OPS = 25; + static const jint RE_EMBEDDED_FLAGS = 26; + static const jint RE_OCTAL_CHAR = 27; + static const jint RE_HEX_CHAR = 28; + static const jint RE_UNICODE_CHAR = 29; + static const jint RE_NAMED_PROPERTY = 30; + static const jint RE_NESTED_CHARCLASS = 31; +private: + static const jint BIT_TOTAL = 32; +public: + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_AWK; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_ED; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_EGREP; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_EMACS; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_GREP; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_POSIX_AWK; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_POSIX_BASIC; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_POSIX_EGREP; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_POSIX_EXTENDED; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_POSIX_MINIMAL_BASIC; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_POSIX_MINIMAL_EXTENDED; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_SED; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_PERL4; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_PERL4_S; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_PERL5; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_PERL5_S; + static ::gnu::java::util::regex::RESyntax * RE_SYNTAX_JAVA_1_4; + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RESyntax__ diff --git a/libjava/gnu/java/util/regex/REToken.h b/libjava/gnu/java/util/regex/REToken.h new file mode 100644 index 000000000..552d47a3b --- /dev/null +++ b/libjava/gnu/java/util/regex/REToken.h @@ -0,0 +1,75 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_REToken__ +#define __gnu_java_util_regex_REToken__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class REToken; + } + } + } + } +} + +class gnu::java::util::regex::REToken : public ::java::lang::Object +{ + +public: + virtual ::java::lang::Object * clone(); +public: // actually protected + REToken(jint); +public: // actually package-private + virtual jint getMinimumLength(); + virtual jint getMaximumLength(); + virtual void setUncle(::gnu::java::util::regex::REToken *); + virtual jboolean match(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + virtual jboolean matchFake(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +private: + jboolean match(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jboolean); +public: // actually package-private + virtual void setHitEnd(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + virtual ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +public: // actually protected + virtual jboolean next(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +public: // actually package-private + virtual ::gnu::java::util::regex::REToken * getNext(); + virtual ::gnu::java::util::regex::REMatch * findMatch(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + virtual jboolean returnsFixedLengthMatches(); + virtual jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + virtual ::gnu::java::util::regex::REMatch * backtrack(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, ::java::lang::Object *); + virtual jboolean chain(::gnu::java::util::regex::REToken *); + virtual void dump(::gnu::java::lang::CPStringBuilder *) = 0; + virtual void dumpAll(::gnu::java::lang::CPStringBuilder *); +public: + virtual ::java::lang::String * toString(); + static jchar toLowerCase(jchar, jboolean); + static jchar toUpperCase(jchar, jboolean); +public: // actually protected + ::gnu::java::util::regex::REToken * __attribute__((aligned(__alignof__( ::java::lang::Object)))) next__; + ::gnu::java::util::regex::REToken * uncle; + jint subIndex; + jboolean unicodeAware; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_REToken__ diff --git a/libjava/gnu/java/util/regex/RETokenAny.h b/libjava/gnu/java/util/regex/RETokenAny.h new file mode 100644 index 000000000..77f00aaad --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenAny.h @@ -0,0 +1,52 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenAny__ +#define __gnu_java_util_regex_RETokenAny__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenAny; + } + } + } + } +} + +class gnu::java::util::regex::RETokenAny : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenAny(jint, jboolean, jboolean); + jint getMinimumLength(); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + jboolean matchOneChar(jchar); + jboolean returnsFixedLengthMatches(); + jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + void dump(::gnu::java::lang::CPStringBuilder *); +private: + jboolean __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) newline; + jboolean matchNull; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenAny__ diff --git a/libjava/gnu/java/util/regex/RETokenBackRef.h b/libjava/gnu/java/util/regex/RETokenBackRef.h new file mode 100644 index 000000000..4cadd5405 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenBackRef.h @@ -0,0 +1,47 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenBackRef__ +#define __gnu_java_util_regex_RETokenBackRef__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenBackRef; + } + } + } + } +} + +class gnu::java::util::regex::RETokenBackRef : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenBackRef(jint, jint, jboolean); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + void dump(::gnu::java::lang::CPStringBuilder *); +private: + jint __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) num; + jboolean insens; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenBackRef__ diff --git a/libjava/gnu/java/util/regex/RETokenChar.h b/libjava/gnu/java/util/regex/RETokenChar.h new file mode 100644 index 000000000..723bed8c6 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenChar.h @@ -0,0 +1,60 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenChar__ +#define __gnu_java_util_regex_RETokenChar__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class REToken; + class RETokenChar; + } + } + } + } +} + +class gnu::java::util::regex::RETokenChar : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenChar(jint, jchar, jboolean); + jint getMinimumLength(); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +private: + jboolean matchOneString(::gnu::java::util::regex::CharIndexed *, jint); + jboolean charEquals(jchar, jchar); +public: // actually package-private + jboolean returnsFixedLengthMatches(); + jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + jboolean chain(::gnu::java::util::regex::REToken *); + void dump(::gnu::java::lang::CPStringBuilder *); +private: + JArray< jchar > * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) ch; + jboolean insens; + jint matchedLength; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenChar__ diff --git a/libjava/gnu/java/util/regex/RETokenEnd.h b/libjava/gnu/java/util/regex/RETokenEnd.h new file mode 100644 index 000000000..975bb1625 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenEnd.h @@ -0,0 +1,54 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenEnd__ +#define __gnu_java_util_regex_RETokenEnd__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenEnd; + } + } + } + } +} + +class gnu::java::util::regex::RETokenEnd : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenEnd(jint, ::java::lang::String *); + RETokenEnd(jint, ::java::lang::String *, jboolean); + void setFake(jboolean); + jint getMaximumLength(); + jboolean match(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + jboolean returnsFixedLengthMatches(); + jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + void dump(::gnu::java::lang::CPStringBuilder *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) newline; + jboolean check_java_line_terminators; + jboolean fake; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenEnd__ diff --git a/libjava/gnu/java/util/regex/RETokenEndOfPreviousMatch.h b/libjava/gnu/java/util/regex/RETokenEndOfPreviousMatch.h new file mode 100644 index 000000000..be5683341 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenEndOfPreviousMatch.h @@ -0,0 +1,47 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenEndOfPreviousMatch__ +#define __gnu_java_util_regex_RETokenEndOfPreviousMatch__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenEndOfPreviousMatch; + } + } + } + } +} + +class gnu::java::util::regex::RETokenEndOfPreviousMatch : public ::gnu::java::util::regex::RETokenStart +{ + +public: // actually package-private + RETokenEndOfPreviousMatch(jint); + virtual jint getMaximumLength(); + virtual ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + virtual jboolean returnsFixedLengthmatches(); + virtual jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + virtual void dump(::gnu::java::lang::CPStringBuilder *); +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenEndOfPreviousMatch__ diff --git a/libjava/gnu/java/util/regex/RETokenEndSub.h b/libjava/gnu/java/util/regex/RETokenEndSub.h new file mode 100644 index 000000000..109e28b3e --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenEndSub.h @@ -0,0 +1,47 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenEndSub__ +#define __gnu_java_util_regex_RETokenEndSub__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenEndSub; + } + } + } + } +} + +class gnu::java::util::regex::RETokenEndSub : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenEndSub(jint); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + ::gnu::java::util::regex::REMatch * findMatch(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + void setHitEnd(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + void dump(::gnu::java::lang::CPStringBuilder *); +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenEndSub__ diff --git a/libjava/gnu/java/util/regex/RETokenIndependent.h b/libjava/gnu/java/util/regex/RETokenIndependent.h new file mode 100644 index 000000000..780029684 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenIndependent.h @@ -0,0 +1,48 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenIndependent__ +#define __gnu_java_util_regex_RETokenIndependent__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class REToken; + class RETokenIndependent; + } + } + } + } +} + +class gnu::java::util::regex::RETokenIndependent : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenIndependent(::gnu::java::util::regex::REToken *); + jint getMinimumLength(); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + void dump(::gnu::java::lang::CPStringBuilder *); + ::gnu::java::util::regex::REToken * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) re; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenIndependent__ diff --git a/libjava/gnu/java/util/regex/RETokenLookAhead.h b/libjava/gnu/java/util/regex/RETokenLookAhead.h new file mode 100644 index 000000000..b3e1a72df --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenLookAhead.h @@ -0,0 +1,48 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenLookAhead__ +#define __gnu_java_util_regex_RETokenLookAhead__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class REToken; + class RETokenLookAhead; + } + } + } + } +} + +class gnu::java::util::regex::RETokenLookAhead : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenLookAhead(::gnu::java::util::regex::REToken *, jboolean); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + void dump(::gnu::java::lang::CPStringBuilder *); + ::gnu::java::util::regex::REToken * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) re; + jboolean negative; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenLookAhead__ diff --git a/libjava/gnu/java/util/regex/RETokenLookBehind$RETokenMatchHereOnly.h b/libjava/gnu/java/util/regex/RETokenLookBehind$RETokenMatchHereOnly.h new file mode 100644 index 000000000..dc771b480 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenLookBehind$RETokenMatchHereOnly.h @@ -0,0 +1,47 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenLookBehind$RETokenMatchHereOnly__ +#define __gnu_java_util_regex_RETokenLookBehind$RETokenMatchHereOnly__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenLookBehind$RETokenMatchHereOnly; + } + } + } + } +} + +class gnu::java::util::regex::RETokenLookBehind$RETokenMatchHereOnly : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + virtual jint getMaximumLength(); + RETokenLookBehind$RETokenMatchHereOnly(jint); + virtual ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + virtual void dump(::gnu::java::lang::CPStringBuilder *); +private: + jint __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) index; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenLookBehind$RETokenMatchHereOnly__ diff --git a/libjava/gnu/java/util/regex/RETokenLookBehind.h b/libjava/gnu/java/util/regex/RETokenLookBehind.h new file mode 100644 index 000000000..3aa8013f0 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenLookBehind.h @@ -0,0 +1,48 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenLookBehind__ +#define __gnu_java_util_regex_RETokenLookBehind__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class REToken; + class RETokenLookBehind; + } + } + } + } +} + +class gnu::java::util::regex::RETokenLookBehind : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenLookBehind(::gnu::java::util::regex::REToken *, jboolean); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + void dump(::gnu::java::lang::CPStringBuilder *); + ::gnu::java::util::regex::REToken * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) re; + jboolean negative; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenLookBehind__ diff --git a/libjava/gnu/java/util/regex/RETokenNamedProperty$1.h b/libjava/gnu/java/util/regex/RETokenNamedProperty$1.h new file mode 100644 index 000000000..559e06152 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenNamedProperty$1.h @@ -0,0 +1,41 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenNamedProperty$1__ +#define __gnu_java_util_regex_RETokenNamedProperty$1__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RETokenNamedProperty; + class RETokenNamedProperty$1; + } + } + } + } +} + +class gnu::java::util::regex::RETokenNamedProperty$1 : public ::gnu::java::util::regex::RETokenNamedProperty$Handler +{ + +public: // actually package-private + RETokenNamedProperty$1(::gnu::java::util::regex::RETokenNamedProperty *); +public: + virtual jboolean includes(jchar); +public: // actually package-private + ::gnu::java::util::regex::RETokenNamedProperty * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::RETokenNamedProperty$Handler)))) this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenNamedProperty$1__ diff --git a/libjava/gnu/java/util/regex/RETokenNamedProperty$Handler.h b/libjava/gnu/java/util/regex/RETokenNamedProperty$Handler.h new file mode 100644 index 000000000..bc5efe100 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenNamedProperty$Handler.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenNamedProperty$Handler__ +#define __gnu_java_util_regex_RETokenNamedProperty$Handler__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RETokenNamedProperty$Handler; + } + } + } + } +} + +class gnu::java::util::regex::RETokenNamedProperty$Handler : public ::java::lang::Object +{ + + RETokenNamedProperty$Handler(); +public: + virtual jboolean includes(jchar) = 0; +public: // actually package-private + RETokenNamedProperty$Handler(::gnu::java::util::regex::RETokenNamedProperty$Handler *); +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenNamedProperty$Handler__ diff --git a/libjava/gnu/java/util/regex/RETokenNamedProperty$JavaCategoryHandler.h b/libjava/gnu/java/util/regex/RETokenNamedProperty$JavaCategoryHandler.h new file mode 100644 index 000000000..8c9e229b0 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenNamedProperty$JavaCategoryHandler.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenNamedProperty$JavaCategoryHandler__ +#define __gnu_java_util_regex_RETokenNamedProperty$JavaCategoryHandler__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RETokenNamedProperty$JavaCategoryHandler; + } + } + } + } +} + +class gnu::java::util::regex::RETokenNamedProperty$JavaCategoryHandler : public ::gnu::java::util::regex::RETokenNamedProperty$Handler +{ + +public: + RETokenNamedProperty$JavaCategoryHandler(::java::lang::reflect::Method *); + virtual jboolean includes(jchar); +private: + ::java::lang::reflect::Method * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::RETokenNamedProperty$Handler)))) method; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenNamedProperty$JavaCategoryHandler__ diff --git a/libjava/gnu/java/util/regex/RETokenNamedProperty$POSIXHandler.h b/libjava/gnu/java/util/regex/RETokenNamedProperty$POSIXHandler.h new file mode 100644 index 000000000..121acccad --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenNamedProperty$POSIXHandler.h @@ -0,0 +1,40 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenNamedProperty$POSIXHandler__ +#define __gnu_java_util_regex_RETokenNamedProperty$POSIXHandler__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RETokenNamedProperty$POSIXHandler; + class RETokenPOSIX; + } + } + } + } +} + +class gnu::java::util::regex::RETokenNamedProperty$POSIXHandler : public ::gnu::java::util::regex::RETokenNamedProperty$Handler +{ + +public: + RETokenNamedProperty$POSIXHandler(::java::lang::String *); + virtual jboolean includes(jchar); +private: + ::gnu::java::util::regex::RETokenPOSIX * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::RETokenNamedProperty$Handler)))) retoken; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenNamedProperty$POSIXHandler__ diff --git a/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeBlockHandler.h b/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeBlockHandler.h new file mode 100644 index 000000000..c2890ed23 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeBlockHandler.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenNamedProperty$UnicodeBlockHandler__ +#define __gnu_java_util_regex_RETokenNamedProperty$UnicodeBlockHandler__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RETokenNamedProperty$UnicodeBlockHandler; + } + } + } + } +} + +class gnu::java::util::regex::RETokenNamedProperty$UnicodeBlockHandler : public ::gnu::java::util::regex::RETokenNamedProperty$Handler +{ + +public: + RETokenNamedProperty$UnicodeBlockHandler(::java::lang::Character$UnicodeBlock *); + virtual jboolean includes(jchar); +private: + ::java::lang::Character$UnicodeBlock * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::RETokenNamedProperty$Handler)))) block; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenNamedProperty$UnicodeBlockHandler__ diff --git a/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeCategoriesHandler.h b/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeCategoriesHandler.h new file mode 100644 index 000000000..af6c5aee0 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeCategoriesHandler.h @@ -0,0 +1,41 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenNamedProperty$UnicodeCategoriesHandler__ +#define __gnu_java_util_regex_RETokenNamedProperty$UnicodeCategoriesHandler__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RETokenNamedProperty$UnicodeCategoriesHandler; + } + } + } + } +} + +class gnu::java::util::regex::RETokenNamedProperty$UnicodeCategoriesHandler : public ::gnu::java::util::regex::RETokenNamedProperty$Handler +{ + +public: + RETokenNamedProperty$UnicodeCategoriesHandler(JArray< jbyte > *); + virtual jboolean includes(jchar); +private: + JArray< jbyte > * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::RETokenNamedProperty$Handler)))) categories; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenNamedProperty$UnicodeCategoriesHandler__ diff --git a/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeCategoryHandler.h b/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeCategoryHandler.h new file mode 100644 index 000000000..f090dbd1a --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenNamedProperty$UnicodeCategoryHandler.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenNamedProperty$UnicodeCategoryHandler__ +#define __gnu_java_util_regex_RETokenNamedProperty$UnicodeCategoryHandler__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RETokenNamedProperty$UnicodeCategoryHandler; + } + } + } + } +} + +class gnu::java::util::regex::RETokenNamedProperty$UnicodeCategoryHandler : public ::gnu::java::util::regex::RETokenNamedProperty$Handler +{ + +public: + RETokenNamedProperty$UnicodeCategoryHandler(jbyte); + virtual jboolean includes(jchar); +private: + jint __attribute__((aligned(__alignof__( ::gnu::java::util::regex::RETokenNamedProperty$Handler)))) category; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenNamedProperty$UnicodeCategoryHandler__ diff --git a/libjava/gnu/java/util/regex/RETokenNamedProperty.h b/libjava/gnu/java/util/regex/RETokenNamedProperty.h new file mode 100644 index 000000000..a20a1a3ef --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenNamedProperty.h @@ -0,0 +1,68 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenNamedProperty__ +#define __gnu_java_util_regex_RETokenNamedProperty__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenNamedProperty; + class RETokenNamedProperty$Handler; + } + } + } + } +} + +class gnu::java::util::regex::RETokenNamedProperty : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenNamedProperty(jint, ::java::lang::String *, jboolean, jboolean); + jint getMinimumLength(); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +private: + jboolean matchOneChar(jchar); +public: // actually package-private + jboolean returnsFixedLengthMatches(); + jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + void dump(::gnu::java::lang::CPStringBuilder *); +private: + ::gnu::java::util::regex::RETokenNamedProperty$Handler * getHandler(::java::lang::String *); +public: // actually package-private + ::java::lang::String * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) name; + jboolean insens; + jboolean negate; + ::gnu::java::util::regex::RETokenNamedProperty$Handler * handler; + static JArray< jbyte > * LETTER; + static JArray< jbyte > * MARK; + static JArray< jbyte > * SEPARATOR; + static JArray< jbyte > * SYMBOL; + static JArray< jbyte > * NUMBER; + static JArray< jbyte > * PUNCTUATION; + static JArray< jbyte > * OTHER; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenNamedProperty__ diff --git a/libjava/gnu/java/util/regex/RETokenOneOf.h b/libjava/gnu/java/util/regex/RETokenOneOf.h new file mode 100644 index 000000000..b7f819dd7 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenOneOf.h @@ -0,0 +1,66 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenOneOf__ +#define __gnu_java_util_regex_RETokenOneOf__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenOneOf; + } + } + } + } +} + +class gnu::java::util::regex::RETokenOneOf : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenOneOf(jint, ::java::lang::String *, jboolean, jboolean); + RETokenOneOf(jint, ::java::util::List *, jboolean); + RETokenOneOf(jint, ::java::util::List *, ::java::util::List *, jboolean); + jint getMinimumLength(); + jint getMaximumLength(); + jboolean match(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + jboolean matchOneChar(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +private: + jboolean matchN(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jboolean); + jboolean matchP(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jboolean); + jboolean matchOneRE(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +public: // actually package-private + ::gnu::java::util::regex::REMatch * findMatch(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + ::gnu::java::util::regex::REMatch * backtrack(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, ::java::lang::Object *); +private: + ::gnu::java::util::regex::REMatch * findMatch(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); +public: // actually package-private + jboolean returnsFixedLengthMatches(); + jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + void dump(::gnu::java::lang::CPStringBuilder *); +private: + ::java::util::List * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) options; + jboolean negative; + jboolean matchesOneChar; + ::java::util::List * addition; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenOneOf__ diff --git a/libjava/gnu/java/util/regex/RETokenPOSIX.h b/libjava/gnu/java/util/regex/RETokenPOSIX.h new file mode 100644 index 000000000..5704ab8e6 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenPOSIX.h @@ -0,0 +1,68 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenPOSIX__ +#define __gnu_java_util_regex_RETokenPOSIX__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenPOSIX; + } + } + } + } +} + +class gnu::java::util::regex::RETokenPOSIX : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + static jint intValue(::java::lang::String *); + RETokenPOSIX(jint, jint, jboolean, jboolean); + jint getMinimumLength(); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + jboolean matchOneChar(jchar); + jboolean returnsFixedLengthMatches(); + jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + void dump(::gnu::java::lang::CPStringBuilder *); + jint __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) type; + jboolean insens; + jboolean negated; + static const jint ALNUM = 0; + static const jint ALPHA = 1; + static const jint BLANK = 2; + static const jint CNTRL = 3; + static const jint DIGIT = 4; + static const jint GRAPH = 5; + static const jint LOWER = 6; + static const jint PRINT = 7; + static const jint PUNCT = 8; + static const jint SPACE = 9; + static const jint UPPER = 10; + static const jint XDIGIT = 11; + static JArray< ::java::lang::String * > * s_nameTable; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenPOSIX__ diff --git a/libjava/gnu/java/util/regex/RETokenRange.h b/libjava/gnu/java/util/regex/RETokenRange.h new file mode 100644 index 000000000..fa3c923b7 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenRange.h @@ -0,0 +1,53 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenRange__ +#define __gnu_java_util_regex_RETokenRange__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenRange; + } + } + } + } +} + +class gnu::java::util::regex::RETokenRange : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenRange(jint, jchar, jchar, jboolean); + jint getMinimumLength(); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + jboolean matchOneChar(jchar); + jboolean returnsFixedLengthMatches(); + jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + void dump(::gnu::java::lang::CPStringBuilder *); +private: + jchar __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) lo; + jchar hi; + jboolean insens; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenRange__ diff --git a/libjava/gnu/java/util/regex/RETokenRepeated$DoablesFinder.h b/libjava/gnu/java/util/regex/RETokenRepeated$DoablesFinder.h new file mode 100644 index 000000000..8b92ce527 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenRepeated$DoablesFinder.h @@ -0,0 +1,48 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenRepeated$DoablesFinder__ +#define __gnu_java_util_regex_RETokenRepeated$DoablesFinder__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class REToken; + class RETokenRepeated$DoablesFinder; + } + } + } + } +} + +class gnu::java::util::regex::RETokenRepeated$DoablesFinder : public ::java::lang::Object +{ + + RETokenRepeated$DoablesFinder(::gnu::java::util::regex::REToken *, ::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + ::gnu::java::util::regex::REMatch * find(); +public: // actually package-private + virtual jboolean noMore(); + RETokenRepeated$DoablesFinder(::gnu::java::util::regex::REToken *, ::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, ::gnu::java::util::regex::RETokenRepeated$DoablesFinder *); + static ::gnu::java::util::regex::REMatch * access$1(::gnu::java::util::regex::RETokenRepeated$DoablesFinder *); +private: + ::gnu::java::util::regex::REToken * __attribute__((aligned(__alignof__( ::java::lang::Object)))) tk; + ::gnu::java::util::regex::CharIndexed * input; + ::gnu::java::util::regex::REMatch * rematch; + jboolean findFirst; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenRepeated$DoablesFinder__ diff --git a/libjava/gnu/java/util/regex/RETokenRepeated$FindMatchControl.h b/libjava/gnu/java/util/regex/RETokenRepeated$FindMatchControl.h new file mode 100644 index 000000000..5858aeda3 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenRepeated$FindMatchControl.h @@ -0,0 +1,38 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenRepeated$FindMatchControl__ +#define __gnu_java_util_regex_RETokenRepeated$FindMatchControl__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RETokenRepeated$DoablesFinder; + class RETokenRepeated$FindMatchControl; + } + } + } + } +} + +class gnu::java::util::regex::RETokenRepeated$FindMatchControl : public ::java::lang::Object +{ + +public: // actually package-private + RETokenRepeated$FindMatchControl(::gnu::java::util::regex::RETokenRepeated$DoablesFinder *); + ::gnu::java::util::regex::RETokenRepeated$DoablesFinder * __attribute__((aligned(__alignof__( ::java::lang::Object)))) finder; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenRepeated$FindMatchControl__ diff --git a/libjava/gnu/java/util/regex/RETokenRepeated$StackedInfo.h b/libjava/gnu/java/util/regex/RETokenRepeated$StackedInfo.h new file mode 100644 index 000000000..6253b6492 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenRepeated$StackedInfo.h @@ -0,0 +1,44 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenRepeated$StackedInfo__ +#define __gnu_java_util_regex_RETokenRepeated$StackedInfo__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenRepeated$DoablesFinder; + class RETokenRepeated$StackedInfo; + } + } + } + } +} + +class gnu::java::util::regex::RETokenRepeated$StackedInfo : public ::gnu::java::util::regex::BacktrackStack$Backtrack +{ + +public: // actually package-private + RETokenRepeated$StackedInfo(::gnu::java::util::regex::CharIndexed *, jint, ::gnu::java::util::regex::REMatch *, JArray< jint > *, ::gnu::java::util::regex::RETokenRepeated$DoablesFinder *); + jint __attribute__((aligned(__alignof__( ::gnu::java::util::regex::BacktrackStack$Backtrack)))) numRepeats; + JArray< jint > * visited; + ::gnu::java::util::regex::RETokenRepeated$DoablesFinder * finder; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenRepeated$StackedInfo__ diff --git a/libjava/gnu/java/util/regex/RETokenRepeated$TryAnotherResult.h b/libjava/gnu/java/util/regex/RETokenRepeated$TryAnotherResult.h new file mode 100644 index 000000000..5a6ef3b42 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenRepeated$TryAnotherResult.h @@ -0,0 +1,46 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenRepeated$TryAnotherResult__ +#define __gnu_java_util_regex_RETokenRepeated$TryAnotherResult__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class REMatch; + class RETokenRepeated$TryAnotherResult; + } + } + } + } +} + +class gnu::java::util::regex::RETokenRepeated$TryAnotherResult : public ::java::lang::Object +{ + + RETokenRepeated$TryAnotherResult(); +public: // actually package-private + RETokenRepeated$TryAnotherResult(::gnu::java::util::regex::RETokenRepeated$TryAnotherResult *); + ::gnu::java::util::regex::REMatch * __attribute__((aligned(__alignof__( ::java::lang::Object)))) result; + jint status; + static const jint RESULT_FOUND = 1; + static const jint TRY_FURTHER = 2; + static const jint NOTHING_FOUND = 3; + JArray< jint > * visited; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenRepeated$TryAnotherResult__ diff --git a/libjava/gnu/java/util/regex/RETokenRepeated.h b/libjava/gnu/java/util/regex/RETokenRepeated.h new file mode 100644 index 000000000..09aca7a58 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenRepeated.h @@ -0,0 +1,79 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenRepeated__ +#define __gnu_java_util_regex_RETokenRepeated__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class BacktrackStack; + class CharIndexed; + class REMatch; + class REToken; + class RETokenRepeated; + class RETokenRepeated$DoablesFinder; + class RETokenRepeated$TryAnotherResult; + } + } + } + } +} + +class gnu::java::util::regex::RETokenRepeated : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenRepeated(jint, ::gnu::java::util::regex::REToken *, jint, jint); + void makeStingy(); + jboolean isStingy(); + void makePossessive(); + jboolean isPossessive(); + jint getMinimumLength(); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * findMatch(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + ::gnu::java::util::regex::REMatch * backtrack(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, ::java::lang::Object *); +private: + ::gnu::java::util::regex::REMatch * findMatch(::gnu::java::util::regex::BacktrackStack *); + ::gnu::java::util::regex::REMatch * findMatch(::gnu::java::util::regex::BacktrackStack *, ::java::util::Deque *); + ::gnu::java::util::regex::RETokenRepeated$TryAnotherResult * tryAnother(::gnu::java::util::regex::BacktrackStack *, ::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint, ::gnu::java::util::regex::RETokenRepeated$DoablesFinder *, JArray< jint > *); +public: // actually package-private + jboolean match(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); +private: + static JArray< jint > * initVisited(); + static jboolean visitedContains(jint, JArray< jint > *); + static JArray< jint > * addVisited(jint, JArray< jint > *); + ::gnu::java::util::regex::REMatch * matchRest(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + ::gnu::java::util::regex::REMatch * findMatchFixedLength(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + ::gnu::java::util::regex::REMatch * backtrackFixedLength(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, ::java::lang::Object *); + ::gnu::java::util::regex::REMatch * findMatchFixedLength(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint, jint); +public: // actually package-private + void dump(::gnu::java::lang::CPStringBuilder *); +private: + ::gnu::java::util::regex::REToken * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) token; + jint min; + jint max; + jboolean stingy; + jboolean possessive; + jint tokenFixedLength; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenRepeated__ diff --git a/libjava/gnu/java/util/regex/RETokenStart.h b/libjava/gnu/java/util/regex/RETokenStart.h new file mode 100644 index 000000000..95654f795 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenStart.h @@ -0,0 +1,51 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenStart__ +#define __gnu_java_util_regex_RETokenStart__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenStart; + } + } + } + } +} + +class gnu::java::util::regex::RETokenStart : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenStart(jint, ::java::lang::String *); + RETokenStart(jint, ::java::lang::String *, jboolean); + virtual jint getMaximumLength(); + virtual ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + virtual jboolean returnsFixedLengthMatches(); + virtual jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + virtual void dump(::gnu::java::lang::CPStringBuilder *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) newline; + jboolean check_java_line_terminators; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenStart__ diff --git a/libjava/gnu/java/util/regex/RETokenWordBoundary.h b/libjava/gnu/java/util/regex/RETokenWordBoundary.h new file mode 100644 index 000000000..18d5b2ca1 --- /dev/null +++ b/libjava/gnu/java/util/regex/RETokenWordBoundary.h @@ -0,0 +1,53 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_RETokenWordBoundary__ +#define __gnu_java_util_regex_RETokenWordBoundary__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace lang + { + class CPStringBuilder; + } + namespace util + { + namespace regex + { + class CharIndexed; + class REMatch; + class RETokenWordBoundary; + } + } + } + } +} + +class gnu::java::util::regex::RETokenWordBoundary : public ::gnu::java::util::regex::REToken +{ + +public: // actually package-private + RETokenWordBoundary(jint, jint, jboolean); + jint getMaximumLength(); + ::gnu::java::util::regex::REMatch * matchThis(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *); + jboolean returnsFixedLengthMatches(); + jint findFixedLengthMatches(::gnu::java::util::regex::CharIndexed *, ::gnu::java::util::regex::REMatch *, jint); + void dump(::gnu::java::lang::CPStringBuilder *); +private: + jboolean __attribute__((aligned(__alignof__( ::gnu::java::util::regex::REToken)))) negated; + jint where; +public: // actually package-private + static const jint BEGIN = 1; + static const jint END = 2; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_RETokenWordBoundary__ diff --git a/libjava/gnu/java/util/regex/UncheckedRE.h b/libjava/gnu/java/util/regex/UncheckedRE.h new file mode 100644 index 000000000..23a289889 --- /dev/null +++ b/libjava/gnu/java/util/regex/UncheckedRE.h @@ -0,0 +1,38 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_util_regex_UncheckedRE__ +#define __gnu_java_util_regex_UncheckedRE__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace util + { + namespace regex + { + class RESyntax; + class UncheckedRE; + } + } + } + } +} + +class gnu::java::util::regex::UncheckedRE : public ::gnu::java::util::regex::RE +{ + +public: + UncheckedRE(::java::lang::Object *); + UncheckedRE(::java::lang::Object *, jint); + UncheckedRE(::java::lang::Object *, jint, ::gnu::java::util::regex::RESyntax *); + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_util_regex_UncheckedRE__ -- cgit v1.2.3