JavaScriptCore:
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 11 Nov 2007 18:56:13 +0000 (18:56 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 11 Nov 2007 18:56:13 +0000 (18:56 +0000)
        Reviewed by Sam.

        - http://bugs.webkit.org/show_bug.cgi?id=15924
          next round of changes to JSRegExp (formerly PCRE)

        This is a combination of converting to C++, tweaking the API, and adding
        some additional optimizations.

        Future steps will involve getting rid of the use of UTF-8 completely
        (we'll use UTF-16 exclusively instead), eliminating more source files,
        and some more speed-ups.

        SunSpider says the current round is an 0.9% speed-up overall, and a
        5.3% speed-up for regexp.

        * JavaScriptCore.exp: Updated for new entry points.

        * JavaScriptCore.pri:
        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
        * JavaScriptCore.vcproj/dftables/dftables.vcproj:
        * JavaScriptCore.xcodeproj/project.pbxproj:
        * JavaScriptCoreSources.bkl:
        * jscore.bkl:
        Updated for new source file names and ForwardingHeaders.

        * kjs/regexp.cpp:
        (KJS::RegExp::RegExp): Changed to use the error message without calling
        strdup on it and to pass the new types and options.
        (KJS::RegExp::~RegExp): Removed the now-unneeded free of the error message.
        (KJS::RegExp::match): Pass the new types and options.
        * kjs/regexp.h: Update type of m_constructionError.

        * pcre/AUTHORS: Update to reflect the status of the project -- we don't include
        the Google parts, and this isn't the PCRE library, per se.
        * pcre/COPYING: Ditto.

        * pcre/dftables.cpp: Copied from JavaScriptCore/pcre/dftables.c.
        (main): Removed unneeded ctype_digit.

        * pcre/pcre.h: Convert to C++, tweak API a bit. Use UChar instead of JSRegExpChar.

        * pcre/pcre_compile.cpp: Copied from JavaScriptCore/pcre/pcre_compile.c.
        Moved a lot of private stuff used only within this file here from pcre_internal.h.
        Renumbered the error codes.
        (error_text): Use a single string with embedded nulls for the error text (I got
        this idea from newer versions of PCRE).
        (check_escape): Changed return type to be enum instead of int. Replaced ctype_digit
        uses with isASCIIDigit.
        (is_counted_repeat): Ditto.
        (read_repeat_counts): Ditto.
        (first_significant_code): Ditto.
        (find_fixedlength): Ditto.
        (could_be_empty_branch): Ditto.
        (compile_branch): Ditto. Also removed some code that handles changing options.
        JavaScript doesn't have any of the features that allow options to change.
        (compile_regex): Updated for change to options parameter.
        (is_anchored): Ditto.
        (find_firstassertedchar): Ditto.
        (jsRegExpCompile): Changed to take separate flags instead of an options int.
        Also changed to call new/delete instead of pcre_malloc/free.
        (jsRegExpFree): Ditto.

        * pcre/pcre_exec.cpp: Copied from JavaScriptCore/pcre/pcre_exec.c.
        Added a case that uses computed goto for the opcode loop, but did not turn it on.
        Changed the RMATCH macro to handle returns more efficiently by putting the where
        pointer in the new frame instead of the old one, allowing us to branch to the
        return with a single statement. Switched to new/delete from pcre_malloc/free.
        Changed many RRETURN callers to not set the return value since it's already
        set correctly. Replaced the rrc variable with an is_match variable. Values other
        than "match" and "no match" are now handled differently. This allows us to remove
        the code to check for those cases in various rules.
        (match): All the case statements use a macro BEGIN_OPCODE instead. And all the
        continue statements, or break statements that break out of the outer case use
        a macro NEXT_OPCODE instead. Replaced a few if statements with assertions.
        (jsRegExpExecute): Use new/delete instead of pcre_malloc/free. Removed unused
        start_match field from the match block.

        * pcre/pcre_internal.h: Moved the last few configuration macros from pcre-config.h
        in here. Removed various unused types. Converted from JSRegExpChar to UChar.
        Eliminated pcre_malloc/free. Replaced the opcode enum with a macro that can be
        used in multiple places. Unfortunately we lose the comments for each opcode; we
        should find a place to put those back. Removed ctype_digit.

        * pcre/pcre_maketables.cpp: Copied from JavaScriptCore/pcre/pcre_maketables.c.
        (pcre_maketables): Got rid of the conditional code that allows this to be compiled
        in -- it's only used for dftables now (and soon may be obsolete entirely).
        Changed code for cbit_digit to not use isdigit, and took the "_" case out of the
        loop. Removed ctype_digit.

        * pcre/pcre_ord2utf8.cpp: Copied from JavaScriptCore/pcre/pcre_ord2utf8.c.

        * pcre/pcre_tables.cpp: Copied from JavaScriptCore/pcre/pcre_tables.c.
        Moved _pcre_OP_lengths out of here into pcre_exec.cpp.

        * pcre/pcre_ucp_searchfuncs.cpp: Copied from JavaScriptCore/pcre/pcre_ucp_searchfuncs.c.
        Updated for other file name changes.

        * pcre/pcre_xclass.cpp: Copied from JavaScriptCore/pcre/pcre_xclass.c.

        * pcre/ucpinternal.h: Updated header.

        * pcre/ucptable.cpp: Copied from JavaScriptCore/pcre/ucptable.c.

        * wtf/ASCIICType.h: (WTF::isASCIIDigit): Removed a branch by changing from && to
        & for this operation. Also added an overload that takes an int because that's
        useful for PCRE. Later we could optimize for int and overload other functions in
        this file; stuck to this simple one for now.

        * wtf/unicode/icu/UnicodeIcu.h: Removed unused isUpper.
        * wtf/unicode/qt4/UnicodeQt4.h: Ditto.

        * pcre/LICENCE: Removed.
        * pcre/pcre-config.h: Removed.
        * wtf/FastMallocPCRE.cpp: Removed.

        * pcre/dftables.c: Renamed to cpp.
        * pcre/pcre_compile.c: Ditto.
        * pcre/pcre_exec.c: Ditto.
        * pcre/pcre_maketables.c: Ditto.
        * pcre/pcre_ord2utf8.c: Ditto.
        * pcre/pcre_tables.c: Ditto.
        * pcre/pcre_ucp_searchfuncs.c: Ditto.
        * pcre/pcre_xclass.c: Ditto.
        * pcre/ucptable.c: Ditto.

WebCore:

        Reviewed by Sam.

        - updated for JSRegExp function changes

        * platform/RegularExpression.cpp:
        (WebCore::RegularExpression::Private::compile):
        (WebCore::RegularExpression::match):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@27686 268f45cc-cd09-0410-ab3c-d52691b4dbfc

34 files changed:
JavaScriptCore/ChangeLog
JavaScriptCore/JavaScriptCore.exp
JavaScriptCore/JavaScriptCore.pri
JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj
JavaScriptCore/JavaScriptCore.vcproj/dftables/dftables.vcproj
JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
JavaScriptCore/JavaScriptCoreSources.bkl
JavaScriptCore/jscore.bkl
JavaScriptCore/kjs/regexp.cpp
JavaScriptCore/kjs/regexp.h
JavaScriptCore/pcre/AUTHORS
JavaScriptCore/pcre/COPYING
JavaScriptCore/pcre/LICENCE [deleted file]
JavaScriptCore/pcre/dftables.cpp [moved from JavaScriptCore/pcre/dftables.c with 90% similarity]
JavaScriptCore/pcre/dftables.pro
JavaScriptCore/pcre/pcre-config.h [deleted file]
JavaScriptCore/pcre/pcre.h
JavaScriptCore/pcre/pcre.pri
JavaScriptCore/pcre/pcre_compile.cpp [moved from JavaScriptCore/pcre/pcre_compile.c with 94% similarity]
JavaScriptCore/pcre/pcre_exec.cpp [moved from JavaScriptCore/pcre/pcre_exec.c with 82% similarity]
JavaScriptCore/pcre/pcre_internal.h
JavaScriptCore/pcre/pcre_maketables.cpp [moved from JavaScriptCore/pcre/pcre_maketables.c with 84% similarity]
JavaScriptCore/pcre/pcre_ord2utf8.cpp [moved from JavaScriptCore/pcre/pcre_ord2utf8.c with 84% similarity]
JavaScriptCore/pcre/pcre_tables.cpp [moved from JavaScriptCore/pcre/pcre_tables.c with 78% similarity]
JavaScriptCore/pcre/pcre_ucp_searchfuncs.cpp [moved from JavaScriptCore/pcre/pcre_ucp_searchfuncs.c with 86% similarity]
JavaScriptCore/pcre/pcre_xclass.cpp [moved from JavaScriptCore/pcre/pcre_xclass.c with 85% similarity]
JavaScriptCore/pcre/ucpinternal.h
JavaScriptCore/pcre/ucptable.cpp [moved from JavaScriptCore/pcre/ucptable.c with 100% similarity]
JavaScriptCore/wtf/ASCIICType.h
JavaScriptCore/wtf/FastMallocPCRE.cpp [deleted file]
JavaScriptCore/wtf/unicode/icu/UnicodeIcu.h
JavaScriptCore/wtf/unicode/qt4/UnicodeQt4.h
WebCore/ChangeLog
WebCore/platform/RegularExpression.cpp

index 7fd3695adb5c847f41860f4c5ba5e9590259d3a8..4167489ab1309915b42addc33ed02037454a031d 100644 (file)
@@ -1,3 +1,130 @@
+2007-11-11  Darin Adler  <darin@apple.com>
+
+        Reviewed by Sam.
+
+        - http://bugs.webkit.org/show_bug.cgi?id=15924
+          next round of changes to JSRegExp (formerly PCRE)
+
+        This is a combination of converting to C++, tweaking the API, and adding
+        some additional optimizations.
+
+        Future steps will involve getting rid of the use of UTF-8 completely
+        (we'll use UTF-16 exclusively instead), eliminating more source files,
+        and some more speed-ups.
+
+        SunSpider says the current round is an 0.9% speed-up overall, and a
+        5.3% speed-up for regexp.
+
+        * JavaScriptCore.exp: Updated for new entry points.
+
+        * JavaScriptCore.pri:
+        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
+        * JavaScriptCore.vcproj/dftables/dftables.vcproj:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * JavaScriptCoreSources.bkl:
+        * jscore.bkl:
+        Updated for new source file names and ForwardingHeaders.
+
+        * kjs/regexp.cpp:
+        (KJS::RegExp::RegExp): Changed to use the error message without calling
+        strdup on it and to pass the new types and options.
+        (KJS::RegExp::~RegExp): Removed the now-unneeded free of the error message.
+        (KJS::RegExp::match): Pass the new types and options.
+        * kjs/regexp.h: Update type of m_constructionError.
+
+        * pcre/AUTHORS: Update to reflect the status of the project -- we don't include
+        the Google parts, and this isn't the PCRE library, per se.
+        * pcre/COPYING: Ditto.
+
+        * pcre/dftables.cpp: Copied from JavaScriptCore/pcre/dftables.c.
+        (main): Removed unneeded ctype_digit.
+
+        * pcre/pcre.h: Convert to C++, tweak API a bit. Use UChar instead of JSRegExpChar.
+
+        * pcre/pcre_compile.cpp: Copied from JavaScriptCore/pcre/pcre_compile.c.
+        Moved a lot of private stuff used only within this file here from pcre_internal.h.
+        Renumbered the error codes.
+        (error_text): Use a single string with embedded nulls for the error text (I got
+        this idea from newer versions of PCRE).
+        (check_escape): Changed return type to be enum instead of int. Replaced ctype_digit
+        uses with isASCIIDigit.
+        (is_counted_repeat): Ditto.
+        (read_repeat_counts): Ditto.
+        (first_significant_code): Ditto.
+        (find_fixedlength): Ditto.
+        (could_be_empty_branch): Ditto.
+        (compile_branch): Ditto. Also removed some code that handles changing options.
+        JavaScript doesn't have any of the features that allow options to change.
+        (compile_regex): Updated for change to options parameter.
+        (is_anchored): Ditto.
+        (find_firstassertedchar): Ditto.
+        (jsRegExpCompile): Changed to take separate flags instead of an options int.
+        Also changed to call new/delete instead of pcre_malloc/free.
+        (jsRegExpFree): Ditto.
+
+        * pcre/pcre_exec.cpp: Copied from JavaScriptCore/pcre/pcre_exec.c.
+        Added a case that uses computed goto for the opcode loop, but did not turn it on.
+        Changed the RMATCH macro to handle returns more efficiently by putting the where
+        pointer in the new frame instead of the old one, allowing us to branch to the
+        return with a single statement. Switched to new/delete from pcre_malloc/free.
+        Changed many RRETURN callers to not set the return value since it's already
+        set correctly. Replaced the rrc variable with an is_match variable. Values other
+        than "match" and "no match" are now handled differently. This allows us to remove
+        the code to check for those cases in various rules.
+        (match): All the case statements use a macro BEGIN_OPCODE instead. And all the
+        continue statements, or break statements that break out of the outer case use
+        a macro NEXT_OPCODE instead. Replaced a few if statements with assertions.
+        (jsRegExpExecute): Use new/delete instead of pcre_malloc/free. Removed unused
+        start_match field from the match block.
+
+        * pcre/pcre_internal.h: Moved the last few configuration macros from pcre-config.h
+        in here. Removed various unused types. Converted from JSRegExpChar to UChar.
+        Eliminated pcre_malloc/free. Replaced the opcode enum with a macro that can be
+        used in multiple places. Unfortunately we lose the comments for each opcode; we
+        should find a place to put those back. Removed ctype_digit.
+
+        * pcre/pcre_maketables.cpp: Copied from JavaScriptCore/pcre/pcre_maketables.c.
+        (pcre_maketables): Got rid of the conditional code that allows this to be compiled
+        in -- it's only used for dftables now (and soon may be obsolete entirely).
+        Changed code for cbit_digit to not use isdigit, and took the "_" case out of the
+        loop. Removed ctype_digit.
+
+        * pcre/pcre_ord2utf8.cpp: Copied from JavaScriptCore/pcre/pcre_ord2utf8.c.
+
+        * pcre/pcre_tables.cpp: Copied from JavaScriptCore/pcre/pcre_tables.c.
+        Moved _pcre_OP_lengths out of here into pcre_exec.cpp.
+
+        * pcre/pcre_ucp_searchfuncs.cpp: Copied from JavaScriptCore/pcre/pcre_ucp_searchfuncs.c.
+        Updated for other file name changes.
+
+        * pcre/pcre_xclass.cpp: Copied from JavaScriptCore/pcre/pcre_xclass.c.
+
+        * pcre/ucpinternal.h: Updated header.
+
+        * pcre/ucptable.cpp: Copied from JavaScriptCore/pcre/ucptable.c.
+
+        * wtf/ASCIICType.h: (WTF::isASCIIDigit): Removed a branch by changing from && to
+        & for this operation. Also added an overload that takes an int because that's
+        useful for PCRE. Later we could optimize for int and overload other functions in
+        this file; stuck to this simple one for now.
+
+        * wtf/unicode/icu/UnicodeIcu.h: Removed unused isUpper.
+        * wtf/unicode/qt4/UnicodeQt4.h: Ditto.
+
+        * pcre/LICENCE: Removed.
+        * pcre/pcre-config.h: Removed.
+        * wtf/FastMallocPCRE.cpp: Removed.
+
+        * pcre/dftables.c: Renamed to cpp.
+        * pcre/pcre_compile.c: Ditto.
+        * pcre/pcre_exec.c: Ditto.
+        * pcre/pcre_maketables.c: Ditto.
+        * pcre/pcre_ord2utf8.c: Ditto.
+        * pcre/pcre_tables.c: Ditto.
+        * pcre/pcre_ucp_searchfuncs.c: Ditto.
+        * pcre/pcre_xclass.c: Ditto.
+        * pcre/ucptable.c: Ditto.
+
 2007-11-11  Eric Seidel  <eric@webkit.org>
 
         Reviewed by Oliver.
index ee66ff9c4bc26e81cf71d06a2bef60e7963f6b0c..5bd99d0b7585b70e5ce742c7ad617144ffc0b508 100644 (file)
@@ -101,6 +101,9 @@ __NPN_RetainObject
 __NPN_SetException
 __NPN_SetProperty
 __NPN_UTF8FromIdentifier
+__Z12jsRegExpFreeP8JSRegExp
+__Z15jsRegExpCompilePKti24JSRegExpIgnoreCaseOption23JSRegExpMultilineOptionPjPPKc
+__Z15jsRegExpExecutePK8JSRegExpPKtiiPii
 __Z23_NPN_CreateScriptObjectP4_NPPPN3KJS8JSObjectEN3WTF10PassRefPtrINS1_8Bindings10RootObjectEEES8_
 __Z25_NPN_CreateNoScriptObjectv
 __ZN3KJS10Identifier11addSlowCaseEPNS_7UString3RepE
@@ -285,9 +288,6 @@ __ZTVN3KJS14StringInstanceE
 __ZTVN3KJS15JSWrapperObjectE
 __ZTVN3KJS19InternalFunctionImpE
 __ZTVN3KJS8JSObjectE
-_jsRegExpCompile
-_jsRegExpExecute
-_jsRegExpFree
 _jscore_collector_introspection
 _jscore_fastmalloc_introspection
 _kJSClassDefinitionEmpty
index 979cc21135cfb714894bce471948ea3388055f8b..5147b2837c255e0fd0abad3bf2157cbaa7edcdf5 100644 (file)
@@ -33,7 +33,6 @@ SOURCES += \
     wtf/Assertions.cpp \
     wtf/HashTable.cpp \
     wtf/FastMalloc.cpp \
-    wtf/FastMallocPCRE.cpp \
     bindings/NP_jsobject.cpp \
     bindings/npruntime.cpp \
     bindings/runtime_array.cpp \
index cc65b4083d9fa85e9e85846e98ddfe12b044448d..cf600d0c55e12b90379fdcc1cbc27fa682e4d31a 100644 (file)
                <Filter\r
                        Name="PCRE"\r
                        >\r
-                       <File\r
-                               RelativePath="..\..\wtf\FastMallocPCRE.cpp"\r
-                               >\r
-                       </File>\r
-                       <File\r
-                               RelativePath="..\..\pcre\pcre-config.h"\r
-                               >\r
-                       </File>\r
                        <File\r
                                RelativePath="..\..\pcre\pcre.h"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\pcre\pcre_compile.c"\r
+                               RelativePath="..\..\pcre\pcre_compile.cpp"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\pcre\pcre_exec.c"\r
+                               RelativePath="..\..\pcre\pcre_exec.cpp"\r
                                >\r
                        </File>\r
                        <File\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\pcre\pcre_ord2utf8.c"\r
+                               RelativePath="..\..\pcre\pcre_ord2utf8.cpp"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\pcre\pcre_tables.c"\r
+                               RelativePath="..\..\pcre\pcre_tables.cpp"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\pcre\pcre_ucp_searchfuncs.c"\r
+                               RelativePath="..\..\pcre\pcre_ucp_searchfuncs.cpp"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\pcre\pcre_xclass.c"\r
+                               RelativePath="..\..\pcre\pcre_xclass.cpp"\r
                                >\r
                        </File>\r
                        <File\r
index 98b0590bf2659e99ccc506fd90eb0133731ebc4e..d3ee9516c06a10226de5d3c0267cc10643156165 100644 (file)
@@ -41,7 +41,7 @@
                        <Tool\r
                                Name="VCCLCompilerTool"\r
                                Optimization="0"\r
-                               AdditionalIncludeDirectories="../../wtf"\r
+                               AdditionalIncludeDirectories="../../wtf;../..;&quot;$(WebKitLibrariesDir)\include\&quot;"\r
                                PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE"\r
                                MinimalRebuild="true"\r
                                ExceptionHandling="0"\r
index dff42f5a5676cba06804a5f31601bac6d3398357..f20d03f0e85daa3904acdef31fa82a78bf1fdd80 100644 (file)
                65FB3F5109D11B2400F49DEB /* grammar.h in Headers */ = {isa = PBXBuildFile; fileRef = 65FB3F4909D11B2400F49DEB /* grammar.h */; };
                65FB3F5409D11B2400F49DEB /* regexp_object.lut.h in Headers */ = {isa = PBXBuildFile; fileRef = 65FB3F4C09D11B2400F49DEB /* regexp_object.lut.h */; };
                65FDE49C0BDD1D4A00E80111 /* Assertions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 65E217B808E7EECC0023E5F6 /* Assertions.cpp */; };
-               9302043B0B790750000C6115 /* FastMallocPCRE.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9302043A0B790750000C6115 /* FastMallocPCRE.cpp */; };
                9303F568099118FA00AD71B8 /* OwnPtr.h in Headers */ = {isa = PBXBuildFile; fileRef = 9303F567099118FA00AD71B8 /* OwnPtr.h */; settings = {ATTRIBUTES = (Private, ); }; };
                9303F56A0991190000AD71B8 /* Noncopyable.h in Headers */ = {isa = PBXBuildFile; fileRef = 9303F5690991190000AD71B8 /* Noncopyable.h */; settings = {ATTRIBUTES = (Private, ); }; };
                9303F5A509911A5800AD71B8 /* OwnArrayPtr.h in Headers */ = {isa = PBXBuildFile; fileRef = 9303F5A409911A5800AD71B8 /* OwnArrayPtr.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               930754C108B0F68000AB3056 /* pcre_compile.c in Sources */ = {isa = PBXBuildFile; fileRef = 930754BF08B0F68000AB3056 /* pcre_compile.c */; };
-               930754D008B0F74600AB3056 /* pcre_tables.c in Sources */ = {isa = PBXBuildFile; fileRef = 930754CE08B0F74500AB3056 /* pcre_tables.c */; };
-               930754EB08B0F78500AB3056 /* pcre_exec.c in Sources */ = {isa = PBXBuildFile; fileRef = 930754E908B0F78500AB3056 /* pcre_exec.c */; };
+               930754C108B0F68000AB3056 /* pcre_compile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 930754BF08B0F68000AB3056 /* pcre_compile.cpp */; };
+               930754D008B0F74600AB3056 /* pcre_tables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 930754CE08B0F74500AB3056 /* pcre_tables.cpp */; };
+               930754EB08B0F78500AB3056 /* pcre_exec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 930754E908B0F78500AB3056 /* pcre_exec.cpp */; };
                932F5B400822A1C700736975 /* array_object.h in Headers */ = {isa = PBXBuildFile; fileRef = F692A84E0255597D01FF60F7 /* array_object.h */; settings = {ATTRIBUTES = (Private, ); }; };
                932F5B420822A1C700736975 /* collector.h in Headers */ = {isa = PBXBuildFile; fileRef = F692A8530255597D01FF60F7 /* collector.h */; settings = {ATTRIBUTES = (Private, ); }; };
                932F5B430822A1C700736975 /* date_object.h in Headers */ = {isa = PBXBuildFile; fileRef = F692A8560255597D01FF60F7 /* date_object.h */; settings = {ATTRIBUTES = (Private, ); }; };
                932F5B6A0822A1C700736975 /* list.h in Headers */ = {isa = PBXBuildFile; fileRef = 931C6CEF038EE8DE008635CE /* list.h */; settings = {ATTRIBUTES = (Private, ); }; };
                932F5B6B0822A1C700736975 /* dtoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 651F6413039D5B5F0078395C /* dtoa.h */; settings = {ATTRIBUTES = (Private, ); }; };
                932F5B6C0822A1C700736975 /* pcre.h in Headers */ = {isa = PBXBuildFile; fileRef = 6541720F039E08B90058BFEB /* pcre.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               932F5B6D0822A1C700736975 /* pcre-config.h in Headers */ = {isa = PBXBuildFile; fileRef = 65417217039E0B280058BFEB /* pcre-config.h */; };
                932F5B6F0822A1C700736975 /* jni_utility.h in Headers */ = {isa = PBXBuildFile; fileRef = 51856D900562EE95008B9D83 /* jni_utility.h */; };
                932F5B700822A1C700736975 /* runtime.h in Headers */ = {isa = PBXBuildFile; fileRef = 511B0870056468730080E486 /* runtime.h */; settings = {ATTRIBUTES = (Private, ); }; };
                932F5B710822A1C700736975 /* jni_runtime.h in Headers */ = {isa = PBXBuildFile; fileRef = 511B0876056468BB0080E486 /* jni_runtime.h */; };
                932FC11D0824A6A3005B3C75 /* create_hash_table in Headers */ = {isa = PBXBuildFile; fileRef = F692A8540255597D01FF60F7 /* create_hash_table */; settings = {ATTRIBUTES = (Private, ); }; };
                935AF46C09E9D9DB00ACD1D8 /* Forward.h in Headers */ = {isa = PBXBuildFile; fileRef = 935AF46909E9D9DB00ACD1D8 /* Forward.h */; settings = {ATTRIBUTES = (Private, ); }; };
                935AF46E09E9D9DB00ACD1D8 /* UnusedParam.h in Headers */ = {isa = PBXBuildFile; fileRef = 935AF46B09E9D9DB00ACD1D8 /* UnusedParam.h */; };
-               935F69FE08245057003D1A45 /* dftables.c in Sources */ = {isa = PBXBuildFile; fileRef = 6541720E039E08B90058BFEB /* dftables.c */; };
-               937013480CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.c in Sources */ = {isa = PBXBuildFile; fileRef = 937013470CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.c */; settings = {COMPILER_FLAGS = "-Wno-sign-compare"; }; };
+               935F69FE08245057003D1A45 /* dftables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6541720E039E08B90058BFEB /* dftables.cpp */; };
+               937013480CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 937013470CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.cpp */; settings = {COMPILER_FLAGS = "-Wno-sign-compare"; }; };
                938C4F6A0CA06BC700D9310A /* ASCIICType.h in Headers */ = {isa = PBXBuildFile; fileRef = 938C4F690CA06BC700D9310A /* ASCIICType.h */; settings = {ATTRIBUTES = (Private, ); }; };
                938C4F6C0CA06BCE00D9310A /* DisallowCType.h in Headers */ = {isa = PBXBuildFile; fileRef = 938C4F6B0CA06BCE00D9310A /* DisallowCType.h */; settings = {ATTRIBUTES = (Private, ); }; };
                93AA4F780957251F0084B3A7 /* AlwaysInline.h in Headers */ = {isa = PBXBuildFile; fileRef = 93AA4F770957251F0084B3A7 /* AlwaysInline.h */; settings = {ATTRIBUTES = (Private, ); }; };
                93B6A0DF0AA64DA40076DE27 /* GetPtr.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B6A0DE0AA64DA40076DE27 /* GetPtr.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               93E26BCA08B1511900F85226 /* pcre_ord2utf8.c in Sources */ = {isa = PBXBuildFile; fileRef = 93E26BC908B1511900F85226 /* pcre_ord2utf8.c */; };
-               93E26BD408B1514100F85226 /* pcre_xclass.c in Sources */ = {isa = PBXBuildFile; fileRef = 93E26BD308B1514100F85226 /* pcre_xclass.c */; };
+               93E26BCA08B1511900F85226 /* pcre_ord2utf8.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93E26BC908B1511900F85226 /* pcre_ord2utf8.cpp */; };
+               93E26BD408B1514100F85226 /* pcre_xclass.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93E26BD308B1514100F85226 /* pcre_xclass.cpp */; };
                93E26BE608B1517100F85226 /* pcre_internal.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E26BE508B1517100F85226 /* pcre_internal.h */; };
                93E26BFE08B151D400F85226 /* ucpinternal.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E26BFC08B151D400F85226 /* ucpinternal.h */; };
                93F0B3AC09BB4DC00068FCE3 /* Parser.h in Headers */ = {isa = PBXBuildFile; fileRef = 93F0B3AA09BB4DC00068FCE3 /* Parser.h */; };
                652246A40C8D7A0E007BDAF7 /* HashIterators.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HashIterators.h; sourceTree = "<group>"; };
                65400C0F0A69BAF200509887 /* PropertyNameArray.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = PropertyNameArray.cpp; sourceTree = "<group>"; };
                65400C100A69BAF200509887 /* PropertyNameArray.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = PropertyNameArray.h; sourceTree = "<group>"; };
-               6541720E039E08B90058BFEB /* dftables.c */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.c; name = dftables.c; path = pcre/dftables.c; sourceTree = "<group>"; tabWidth = 8; };
+               6541720E039E08B90058BFEB /* dftables.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; name = dftables.cpp; path = pcre/dftables.cpp; sourceTree = "<group>"; tabWidth = 8; };
                6541720F039E08B90058BFEB /* pcre.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; name = pcre.h; path = pcre/pcre.h; sourceTree = "<group>"; tabWidth = 8; };
-               65417217039E0B280058BFEB /* pcre-config.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; name = "pcre-config.h"; path = "pcre/pcre-config.h"; sourceTree = "<group>"; tabWidth = 8; };
                6541BD6E08E80A17002CBEE7 /* TCPageMap.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = TCPageMap.h; sourceTree = "<group>"; tabWidth = 8; };
                6541BD6F08E80A17002CBEE7 /* TCSpinLock.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = TCSpinLock.h; sourceTree = "<group>"; tabWidth = 8; };
                6541BD7008E80A17002CBEE7 /* TCSystemAlloc.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TCSystemAlloc.cpp; sourceTree = "<group>"; tabWidth = 8; };
                70B16A260569A10900DB756D /* runtime_object.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; name = runtime_object.cpp; path = bindings/runtime_object.cpp; sourceTree = "<group>"; tabWidth = 8; };
                70B16A270569A10900DB756D /* runtime_object.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; name = runtime_object.h; path = bindings/runtime_object.h; sourceTree = "<group>"; tabWidth = 8; };
                84ABF1DE070B628C00A3AC05 /* npruntime_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; name = npruntime_impl.h; path = bindings/npruntime_impl.h; sourceTree = "<group>"; tabWidth = 8; };
-               9302043A0B790750000C6115 /* FastMallocPCRE.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FastMallocPCRE.cpp; sourceTree = "<group>"; };
                9303F567099118FA00AD71B8 /* OwnPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OwnPtr.h; sourceTree = "<group>"; };
                9303F5690991190000AD71B8 /* Noncopyable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Noncopyable.h; sourceTree = "<group>"; };
                9303F5A409911A5800AD71B8 /* OwnArrayPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OwnArrayPtr.h; sourceTree = "<group>"; };
-               930754BF08B0F68000AB3056 /* pcre_compile.c */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.c; name = pcre_compile.c; path = pcre/pcre_compile.c; sourceTree = "<group>"; tabWidth = 8; };
-               930754CE08B0F74500AB3056 /* pcre_tables.c */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.c; name = pcre_tables.c; path = pcre/pcre_tables.c; sourceTree = "<group>"; tabWidth = 8; };
-               930754E908B0F78500AB3056 /* pcre_exec.c */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.c; name = pcre_exec.c; path = pcre/pcre_exec.c; sourceTree = "<group>"; tabWidth = 8; };
+               930754BF08B0F68000AB3056 /* pcre_compile.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pcre_compile.cpp; path = pcre/pcre_compile.cpp; sourceTree = "<group>"; tabWidth = 8; };
+               930754CE08B0F74500AB3056 /* pcre_tables.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pcre_tables.cpp; path = pcre/pcre_tables.cpp; sourceTree = "<group>"; tabWidth = 8; };
+               930754E908B0F78500AB3056 /* pcre_exec.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pcre_exec.cpp; path = pcre/pcre_exec.cpp; sourceTree = "<group>"; tabWidth = 8; };
                931C6CEF038EE8DE008635CE /* list.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = list.h; sourceTree = "<group>"; tabWidth = 8; };
                931C6CF0038EE8DE008635CE /* list.cpp */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = list.cpp; sourceTree = "<group>"; tabWidth = 8; };
                9322A00306C341D3009067BB /* libicucore.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libicucore.dylib; path = /usr/lib/libicucore.dylib; sourceTree = "<absolute>"; };
                935AF46B09E9D9DB00ACD1D8 /* UnusedParam.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UnusedParam.h; sourceTree = "<group>"; };
                935F69F608244FEA003D1A45 /* dftables */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = dftables; sourceTree = BUILT_PRODUCTS_DIR; };
                9364B273045B7D6C00A9CAC1 /* fpconst.cpp */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = fpconst.cpp; sourceTree = "<group>"; tabWidth = 8; };
-               937013470CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pcre_ucp_searchfuncs.c; path = pcre/pcre_ucp_searchfuncs.c; sourceTree = "<group>"; };
+               937013470CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pcre_ucp_searchfuncs.cpp; path = pcre/pcre_ucp_searchfuncs.cpp; sourceTree = "<group>"; };
                9374D3A7038D9D74008635CE /* scope_chain.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = scope_chain.h; sourceTree = "<group>"; tabWidth = 8; };
                9374D3A8038D9D74008635CE /* scope_chain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = scope_chain.cpp; sourceTree = "<group>"; tabWidth = 8; };
                937B63CC09E766D200A671DD /* DerivedSources.make */ = {isa = PBXFileReference; explicitFileType = sourcecode.make; fileEncoding = 4; path = DerivedSources.make; sourceTree = "<group>"; usesTabs = 1; };
                93AA4F770957251F0084B3A7 /* AlwaysInline.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = AlwaysInline.h; sourceTree = "<group>"; tabWidth = 8; };
                93ADFCE60CCBD7AC00D30B08 /* array_instance.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = array_instance.cpp; sourceTree = "<group>"; };
                93B6A0DE0AA64DA40076DE27 /* GetPtr.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = GetPtr.h; sourceTree = "<group>"; };
-               93E26BC908B1511900F85226 /* pcre_ord2utf8.c */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.c; name = pcre_ord2utf8.c; path = pcre/pcre_ord2utf8.c; sourceTree = "<group>"; tabWidth = 8; };
-               93E26BD308B1514100F85226 /* pcre_xclass.c */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.c; name = pcre_xclass.c; path = pcre/pcre_xclass.c; sourceTree = "<group>"; tabWidth = 8; };
+               93E26BC908B1511900F85226 /* pcre_ord2utf8.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pcre_ord2utf8.cpp; path = pcre/pcre_ord2utf8.cpp; sourceTree = "<group>"; tabWidth = 8; };
+               93E26BD308B1514100F85226 /* pcre_xclass.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pcre_xclass.cpp; path = pcre/pcre_xclass.cpp; sourceTree = "<group>"; tabWidth = 8; };
                93E26BE508B1517100F85226 /* pcre_internal.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; name = pcre_internal.h; path = pcre/pcre_internal.h; sourceTree = "<group>"; tabWidth = 8; };
                93E26BFC08B151D400F85226 /* ucpinternal.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; name = ucpinternal.h; path = pcre/ucpinternal.h; sourceTree = "<group>"; tabWidth = 8; };
                93F0B3A909BB4DC00068FCE3 /* Parser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Parser.cpp; sourceTree = "<group>"; };
                                938C4F6B0CA06BCE00D9310A /* DisallowCType.h */,
                                65E217B908E7EECC0023E5F6 /* FastMalloc.cpp */,
                                65E217BA08E7EECC0023E5F6 /* FastMalloc.h */,
-                               9302043A0B790750000C6115 /* FastMallocPCRE.cpp */,
                                935AF46909E9D9DB00ACD1D8 /* Forward.h */,
                                93B6A0DE0AA64DA40076DE27 /* GetPtr.h */,
                                657EEBBF094E445E008C9C7B /* HashCountedSet.h */,
                65417203039E01F90058BFEB /* pcre */ = {
                        isa = PBXGroup;
                        children = (
-                               6541720E039E08B90058BFEB /* dftables.c */,
-                               65417217039E0B280058BFEB /* pcre-config.h */,
+                               6541720E039E08B90058BFEB /* dftables.cpp */,
                                6541720F039E08B90058BFEB /* pcre.h */,
-                               930754BF08B0F68000AB3056 /* pcre_compile.c */,
-                               930754E908B0F78500AB3056 /* pcre_exec.c */,
+                               930754BF08B0F68000AB3056 /* pcre_compile.cpp */,
+                               930754E908B0F78500AB3056 /* pcre_exec.cpp */,
                                93E26BE508B1517100F85226 /* pcre_internal.h */,
-                               93E26BC908B1511900F85226 /* pcre_ord2utf8.c */,
-                               930754CE08B0F74500AB3056 /* pcre_tables.c */,
-                               937013470CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.c */,
-                               93E26BD308B1514100F85226 /* pcre_xclass.c */,
+                               93E26BC908B1511900F85226 /* pcre_ord2utf8.cpp */,
+                               930754CE08B0F74500AB3056 /* pcre_tables.cpp */,
+                               937013470CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.cpp */,
+                               93E26BD308B1514100F85226 /* pcre_xclass.cpp */,
                                93E26BFC08B151D400F85226 /* ucpinternal.h */,
                        );
                        name = pcre;
                                932F5B540822A1C700736975 /* object.h in Headers */,
                                932F5B530822A1C700736975 /* object_object.h in Headers */,
                                932F5B550822A1C700736975 /* operations.h in Headers */,
-                               932F5B6D0822A1C700736975 /* pcre-config.h in Headers */,
                                932F5B6C0822A1C700736975 /* pcre.h in Headers */,
                                93E26BE608B1517100F85226 /* pcre_internal.h in Headers */,
                                932F5B560822A1C700736975 /* property_map.h in Headers */,
                        files = (
                                659126BD0BDD1728001921FB /* AllInOneFile.cpp in Sources */,
                                65FDE49C0BDD1D4A00E80111 /* Assertions.cpp in Sources */,
-                               9302043B0B790750000C6115 /* FastMallocPCRE.cpp in Sources */,
                                65DFC93308EA173A00F7300B /* HashTable.cpp in Sources */,
                                1421359B0A677F4F00A8195E /* JSBase.cpp in Sources */,
                                1440F8AF0A508D200005F061 /* JSCallbackConstructor.cpp in Sources */,
                                932F5BC20822A1C700736975 /* objc_instance.mm in Sources */,
                                932F5BC10822A1C700736975 /* objc_runtime.mm in Sources */,
                                932F5BC30822A1C700736975 /* objc_utility.mm in Sources */,
-                               930754C108B0F68000AB3056 /* pcre_compile.c in Sources */,
-                               930754EB08B0F78500AB3056 /* pcre_exec.c in Sources */,
-                               93E26BCA08B1511900F85226 /* pcre_ord2utf8.c in Sources */,
-                               930754D008B0F74600AB3056 /* pcre_tables.c in Sources */,
-                               937013480CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.c in Sources */,
-                               93E26BD408B1514100F85226 /* pcre_xclass.c in Sources */,
+                               930754C108B0F68000AB3056 /* pcre_compile.cpp in Sources */,
+                               930754EB08B0F78500AB3056 /* pcre_exec.cpp in Sources */,
+                               93E26BCA08B1511900F85226 /* pcre_ord2utf8.cpp in Sources */,
+                               930754D008B0F74600AB3056 /* pcre_tables.cpp in Sources */,
+                               937013480CA97E0E00FA14D3 /* pcre_ucp_searchfuncs.cpp in Sources */,
+                               93E26BD408B1514100F85226 /* pcre_xclass.cpp in Sources */,
                                932F5BB90822A1C700736975 /* runtime.cpp in Sources */,
                                932F5BBE0822A1C700736975 /* runtime_array.cpp in Sources */,
                                932F5BBD0822A1C700736975 /* runtime_method.cpp in Sources */,
                        isa = PBXSourcesBuildPhase;
                        buildActionMask = 2147483647;
                        files = (
-                               935F69FE08245057003D1A45 /* dftables.c in Sources */,
+                               935F69FE08245057003D1A45 /* dftables.cpp in Sources */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
                        baseConfigurationReference = 1C9051440BA9E8A70081E9D0 /* DebugRelease.xcconfig */;
                        buildSettings = {
                                GCC_OPTIMIZATION_LEVEL = 0;
+                               HEADER_SEARCH_PATHS = .;
                                STRIP_INSTALLED_PRODUCT = NO;
                        };
                        name = Debug;
                        isa = XCBuildConfiguration;
                        baseConfigurationReference = 1C9051440BA9E8A70081E9D0 /* DebugRelease.xcconfig */;
                        buildSettings = {
+                               HEADER_SEARCH_PATHS = .;
                                STRIP_INSTALLED_PRODUCT = NO;
                        };
                        name = Release;
                        isa = XCBuildConfiguration;
                        baseConfigurationReference = 1C9051450BA9E8A70081E9D0 /* Base.xcconfig */;
                        buildSettings = {
+                               HEADER_SEARCH_PATHS = .;
                        };
                        name = Production;
                };
index 61763b73979261da4adea63941461b4fece8e37b..337108fa94029b2f41d0b8231e74c70ec76da636 100644 (file)
@@ -30,7 +30,6 @@ Source files for JSCore.
 -->
 <makefile>
     <set append="1" var="JSCORE_SOURCES_API">
-        
         API/JSBase.cpp
         API/JSCallbackConstructor.cpp
         API/JSCallbackFunction.cpp
@@ -40,11 +39,9 @@ Source files for JSCore.
         API/JSObjectRef.cpp
         API/JSStringRef.cpp
         API/JSValueRef.cpp
-
     </set>
 
     <set append="1" var="JSCORE_SOURCES_BINDINGS">
-        
         bindings/c/c_class.cpp
         bindings/c/c_instance.cpp
         bindings/c/c_runtime.cpp
@@ -56,7 +53,6 @@ Source files for JSCore.
         bindings/runtime_method.cpp
         bindings/runtime_object.cpp
         bindings/runtime_root.cpp
-
     </set>
     
     <set append="1" var="JSCORE_SOURCES_KJS">
@@ -104,18 +100,17 @@ Source files for JSCore.
 
     </set>
     <set append="1" var="JSCORE_SOURCES_PCRE">
-        pcre/pcre_compile.c
-        pcre/pcre_exec.c
-        pcre/pcre_ord2utf8.c
-        pcre/pcre_tables.c
-        pcre/pcre_ucp_searchfuncs.c
-        pcre/pcre_xclass.c
+        pcre/pcre_compile.cpp
+        pcre/pcre_exec.cpp
+        pcre/pcre_ord2utf8.cpp
+        pcre/pcre_tables.cpp
+        pcre/pcre_ucp_searchfuncs.cpp
+        pcre/pcre_xclass.cpp
     </set>
     
     <set append="1" var="WTF_SOURCES">
         wtf/Assertions.cpp
         wtf/FastMalloc.cpp
-        wtf/FastMallocPCRE.cpp
         wtf/HashTable.cpp
         wtf/TCSystemAlloc.cpp
     </set>
index 27febdf11fac30eb474ef8cab934c3c3d6fa742a..5705108895836b37c99a16cbe1ebea9bc6c91cd4 100644 (file)
@@ -106,7 +106,7 @@ JavaScriptCore Bakefile project file.
     <exe id="dftables">
         <dirname>$(SRCDIR)</dirname>
         <include>$(SRCDIR)/wtf</include>
-        <sources>$(SRCDIR)/pcre/dftables.c</sources>
+        <sources>$(SRCDIR)/pcre/dftables.cpp</sources>
     </exe>
 
     <action id="DerivedSources">
index 8a332b7c85d61584e3e8c4da4f6ff34459575cc7..14386de8b86e76b6fd51fd15715ef7cd898eb4d8 100644 (file)
@@ -37,10 +37,8 @@ RegExp::RegExp(const UString& pattern)
   , m_constructionError(0)
   , m_numSubpatterns(0)
 {
-    const char* errorMessage;
-    m_regExp = jsRegExpCompile(reinterpret_cast<const JSRegExpChar*>(m_pattern.data()), m_pattern.size(), 0, &m_numSubpatterns, &errorMessage);
-    if (!m_regExp)
-        m_constructionError = strdup(errorMessage);
+    m_regExp = jsRegExpCompile(reinterpret_cast<const ::UChar*>(m_pattern.data()), m_pattern.size(),
+        JSRegExpDoNotIgnoreCase, JSRegExpSingleLine, &m_numSubpatterns, &m_constructionError);
 }
 
 RegExp::RegExp(const UString& pattern, const UString& flags)
@@ -55,28 +53,26 @@ RegExp::RegExp(const UString& pattern, const UString& flags)
     if (flags.find('g') != -1)
         m_flags |= Global;
 
-    // FIXME: Eliminate duplication by adding a way ask a JSRegExp what its flags are.
-    int options = 0;
+    // FIXME: Eliminate duplication by adding a way ask a JSRegExp what its flags are?
+    JSRegExpIgnoreCaseOption ignoreCaseOption = JSRegExpDoNotIgnoreCase;
     if (flags.find('i') != -1) {
         m_flags |= IgnoreCase;
-        options |= JS_REGEXP_CASELESS;
+        ignoreCaseOption = JSRegExpIgnoreCase;
     }
 
+    JSRegExpMultilineOption multilineOption = JSRegExpSingleLine;
     if (flags.find('m') != -1) {
         m_flags |= Multiline;
-        options |= JS_REGEXP_MULTILINE;
+        multilineOption = JSRegExpMultiline;
     }
     
-    const char* errorMessage;
-    m_regExp = jsRegExpCompile(reinterpret_cast<const JSRegExpChar*>(m_pattern.data()), m_pattern.size(), options, &m_numSubpatterns, &errorMessage);
-    if (!m_regExp)
-        m_constructionError = strdup(errorMessage);
+    m_regExp = jsRegExpCompile(reinterpret_cast<const ::UChar*>(m_pattern.data()), m_pattern.size(),
+        ignoreCaseOption, multilineOption, &m_numSubpatterns, &m_constructionError);
 }
 
 RegExp::~RegExp()
 {
-  jsRegExpFree(m_regExp);
-  free(m_constructionError);
+    jsRegExpFree(m_regExp);
 }
 
 int RegExp::match(const UString& s, int i, OwnArrayPtr<int>* ovector)
@@ -106,11 +102,11 @@ int RegExp::match(const UString& s, int i, OwnArrayPtr<int>* ovector)
     ovector->set(offsetVector);
   }
 
-  int numMatches = jsRegExpExecute(m_regExp, reinterpret_cast<const JSRegExpChar*>(s.data()), s.size(), i, offsetVector, offsetVectorSize);
+  int numMatches = jsRegExpExecute(m_regExp, reinterpret_cast<const ::UChar*>(s.data()), s.size(), i, offsetVector, offsetVectorSize);
 
   if (numMatches < 0) {
 #ifndef NDEBUG
-    if (numMatches != JS_REGEXP_ERROR_NOMATCH)
+    if (numMatches != JSRegExpErrorNoMatch)
       fprintf(stderr, "KJS: pcre_exec() failed with result %d\n", numMatches);
 #endif
     if (ovector)
index a0420825014a96cf9e8c65b12392389e1739fc7b..fcbf6fc38d4129b1cd4fc776e5adcada200b73f9 100644 (file)
@@ -68,7 +68,7 @@ namespace KJS {
 
     // Data supplied by PCRE.
     JSRegExp* m_regExp;
-    char* m_constructionError;
+    const char* m_constructionError;
     unsigned m_numSubpatterns;
   };
 
index bc3e76d03d0f620e0b946a378d3b96cf26b1b152..dbac2a54834bcdac7c15b69b41354dbed467da7d 100644 (file)
@@ -1,28 +1,12 @@
-THE MAIN PCRE LIBRARY
----------------------
-
-Written by:       Philip Hazel
-Email local part: ph10
-Email domain:     cam.ac.uk
+Originally written by:  Philip Hazel
+Email local part:       ph10
+Email domain:           cam.ac.uk
 
 University of Cambridge Computing Service,
 Cambridge, England. Phone: +44 1223 334714.
 
-Copyright (c) 1997-2005 University of Cambridge
-All rights reserved
-
-
-UTF-16 changes by Darin Adler and Geoff Garen
-Copyright (c) 2005, 2006, 2007 Apple Inc.
-All rights reserved
-
-
-THE C++ WRAPPER LIBRARY
------------------------
-
-Written by:       Google Inc.
+Copyright (c) 1997-2005 University of Cambridge. All rights reserved.
 
-Copyright (c) 2005 Google Inc
-All rights reserved
+Adapted for JavaScriptCore and WebKit by Apple Inc.
 
-####
+Copyright (c) 2005, 2006, 2007 Apple Inc. All rights reserved.
index e8eb0d9370321dca0b8b0ee34223ab38826592f6..6ffdc24342d5f2b8c2f37e4cfce13f244cd5bce0 100644 (file)
@@ -1,42 +1,11 @@
-PCRE LICENCE
-------------
-
 PCRE is a library of functions to support regular expressions whose syntax
 and semantics are as close as possible to those of the Perl 5 language.
 
-Release 6 of PCRE is distributed under the terms of the "BSD" licence, as
-specified below. The documentation for PCRE, supplied in the "doc"
-directory, is distributed under the same terms as the software itself.
-
-The basic library functions are written in C and are freestanding. Also
-included in the distribution is a set of C++ wrapper functions.
-
-
-THE BASIC LIBRARY FUNCTIONS
----------------------------
-
-Written by:       Philip Hazel
-Email local part: ph10
-Email domain:     cam.ac.uk
-
-University of Cambridge Computing Service,
-Cambridge, England. Phone: +44 1223 334714.
-
-Copyright (c) 1997-2005 University of Cambridge
-All rights reserved.
+This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed.
 
-
-THE C++ WRAPPER FUNCTIONS
--------------------------
-
-Contributed by:   Google Inc.
-
-Copyright (c) 2005, Google Inc.
-All rights reserved.
-
-
-THE "BSD" LICENCE
------------------
+Copyright (c) 1997-2005 University of Cambridge. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
@@ -48,7 +17,7 @@ modification, are permitted provided that the following conditions are met:
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
 
-    * Neither the name of the University of Cambridge nor the name of Google
+    * Neither the name of the University of Cambridge nor the name of Apple
       Inc. nor the names of their contributors may be used to endorse or
       promote products derived from this software without specific prior
       written permission.
@@ -64,5 +33,3 @@ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
-
-End
diff --git a/JavaScriptCore/pcre/LICENCE b/JavaScriptCore/pcre/LICENCE
deleted file mode 100644 (file)
index 2a3d00e..0000000
+++ /dev/null
@@ -1,68 +0,0 @@
-PCRE LICENCE
-------------
-
-PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
-
-Release 6 of PCRE is distributed under the terms of the "BSD" licence, as
-specified below. The documentation for PCRE, supplied in the "doc"
-directory, is distributed under the same terms as the software itself.
-
-The basic library functions are written in C and are freestanding. Also
-included in the distribution is a set of C++ wrapper functions.
-
-
-THE BASIC LIBRARY FUNCTIONS
----------------------------
-
-Written by:       Philip Hazel
-Email local part: ph10
-Email domain:     cam.ac.uk
-
-University of Cambridge Computing Service,
-Cambridge, England. Phone: +44 1223 334714.
-
-Copyright (c) 1997-2006 University of Cambridge
-All rights reserved.
-
-
-THE C++ WRAPPER FUNCTIONS
--------------------------
-
-Contributed by:   Google Inc.
-
-Copyright (c) 2005, Google Inc.
-All rights reserved.
-
-
-THE "BSD" LICENCE
------------------
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-    * Neither the name of the University of Cambridge nor the name of Google
-      Inc. nor the names of their contributors may be used to endorse or
-      promote products derived from this software without specific prior
-      written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
-End
similarity index 90%
rename from JavaScriptCore/pcre/dftables.c
rename to JavaScriptCore/pcre/dftables.cpp
index ecbf684ec674f5affceeade799022d4a94ef65c0..7cdc9855cbc90c2c0cc3441c849dcd38cff0d5cc 100644 (file)
@@ -1,12 +1,12 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
-
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -49,9 +49,7 @@ make use of its code from here in order to be consistent. */
 
 #include "pcre_internal.h"
 
-#define DFTABLES          /* pcre_maketables.c notices this */
-#include "pcre_maketables.c"
-
+#include "pcre_maketables.cpp"
 
 int main(int argc, char **argv)
 {
@@ -133,10 +131,9 @@ fprintf(f, ",\n\n");
 fprintf(f,
   "/* This table identifies various classes of character by individual bits:\n"
   "  0x%02x   white space character\n"
-  "  0x%02x   decimal digit\n"
   "  0x%02x   hexadecimal digit\n"
   "  0x%02x   alphanumeric or '_'\n*/\n\n",
-  ctype_space, ctype_digit, ctype_xdigit, ctype_word);
+  ctype_space, ctype_xdigit, ctype_word);
 
 fprintf(f, "  ");
 for (i = 0; i < 256; i++)
@@ -165,5 +162,3 @@ fclose(f);
 free((void *)base_of_tables);
 return 0;
 }
-
-/* End of dftables.c */
index 234dc64409a1cb4741303ddda45b44fd450624bd..01a535f7abbeabe74167e7669669e38435b78d03 100644 (file)
@@ -1,7 +1,7 @@
 TEMPLATE = app
 CONFIG += console
 CONFIG -= app_bundle qt
-SOURCES = dftables.c
+SOURCES = dftables.cpp
 TARGET = dftables
 DESTDIR = tmp
 
@@ -12,4 +12,3 @@ gtk-port {
 } else {
   DEFINES += BUILDING_QT__
 }
-
diff --git a/JavaScriptCore/pcre/pcre-config.h b/JavaScriptCore/pcre/pcre-config.h
deleted file mode 100644 (file)
index 2d0b0a2..0000000
+++ /dev/null
@@ -1,31 +0,0 @@
-/* The value of LINK_SIZE determines the number of bytes used to store links as
-offsets within the compiled regex. The default is 2, which allows for compiled
-patterns up to 64K long. This covers the vast majority of cases. However, PCRE
-can also be compiled to use 3 or 4 bytes instead. This allows for longer
-patterns in extreme cases. On systems that support it, "configure" can be used
-to override this default. */
-
-#define LINK_SIZE   2
-
-/* The value of MATCH_LIMIT determines the default number of times the internal
-match() function can be called during a single execution of pcre_exec(). There
-is a runtime interface for setting a different limit. The limit exists in order
-to catch runaway regular expressions that take for ever to determine that they
-do not match. The default is set very large so that it does not accidentally
-catch legitimate cases. On systems that support it, "configure" can be used to
-override this default default. */
-
-#define MATCH_LIMIT 10000000
-
-/* The above limit applies to all calls of match(), whether or not they
-increase the recursion depth. In some environments it is desirable to limit the
-depth of recursive calls of match() more strictly, in order to restrict the
-maximum amount of stack (or heap, if NO_RECURSE is defined) that is used. The
-value of MATCH_LIMIT_RECURSION applies only to recursive calls of match(). To
-have any useful effect, it must be less than the value of MATCH_LIMIT. There is
-a runtime method for setting a different limit. On systems that support it,
-"configure" can be used to override this default default. */
-
-#define MATCH_LIMIT_RECURSION MATCH_LIMIT
-
-/* End */
index 99e24f6f4107597ac9f589b413498a7c3bf9243c..961876b89761079bcf7aed30d3196f41830df085 100644 (file)
@@ -1,11 +1,12 @@
 /* This is the public header file for JavaScriptCore's variant of the PCRE
 library. While this library started out as a copy of PCRE, many of the
 features of PCRE have been removed. This library now supports only the
-regular expression features required by the JavaScript language specification,
-and has only the functions needed by JavaScriptCore and the rest of WebKit.
+regular expression features required by the JavaScript language
+specification, and has only the functions needed by JavaScriptCore and the
+rest of WebKit.
 
            Copyright (c) 1997-2005 University of Cambridge
-           Copyright (c) 2004, 2005, 2006, 2007 Apple Inc.
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -36,41 +37,33 @@ POSSIBILITY OF SUCH DAMAGE.
 -----------------------------------------------------------------------------
 */
 
-// FIXME: Header needs to be renamed.
+// FIXME: This file needs to be renamed to JSRegExp.h; it's no longer PCRE.
 
-#ifndef PCRE_H
-#define PCRE_H
+#ifndef JSRegExp_h
+#define JSRegExp_h
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include <wtf/unicode/Unicode.h>
 
-/* jsRegExpCompile options */
-/* FIXME: Use two booleans instead? */
+struct JSRegExp;
 
-#define JS_REGEXP_CASELESS      0x00000001
-#define JS_REGEXP_MULTILINE     0x00000002
+enum JSRegExpIgnoreCaseOption { JSRegExpDoNotIgnoreCase, JSRegExpIgnoreCase };
+enum JSRegExpMultilineOption { JSRegExpSingleLine, JSRegExpMultiline };
 
 /* jsRegExpExecute error codes */
-/* FIXME: Use const after changing this to C++? */
-
-#define JS_REGEXP_ERROR_NOMATCH         (-1)
-#define JS_REGEXP_ERROR_NOMEMORY        (-6)
-#define JS_REGEXP_ERROR_MATCHLIMIT      (-8)
-#define JS_REGEXP_ERROR_INTERNAL       (-14)
-#define JS_REGEXP_ERROR_RECURSIONLIMIT (-21)
+const int JSRegExpErrorNoMatch = -1;
+const int JSRegExpErrorInternal = -2;
+const int JSRegExpErrorNoMemory = -3;
+const int JSRegExpErrorMatchLimit = -4;
+const int JSRegExpErrorRecursionLimit = -5;
 
-/* FIXME: Merge with WTF's UChar? */
-typedef unsigned short JSRegExpChar;
+JSRegExp* jsRegExpCompile(const ::UChar* pattern, int patternLength,
+    JSRegExpIgnoreCaseOption, JSRegExpMultilineOption,
+    unsigned* numSubpatterns, const char** errorMessage);
 
-typedef struct JSRegExp JSRegExp;
+int jsRegExpExecute(const JSRegExp*,
+    const ::UChar* subject, int subjectLength, int startOffset,
+    int* offsetsVector, int offsetsVectorLength);
 
-JSRegExp* jsRegExpCompile(const JSRegExpChar* pattern, int patternLength, int options, unsigned* numSubpatterns, const char** errorMessage);
-int jsRegExpExecute(const JSRegExp*, const JSRegExpChar*, int, int, int*, int);
 void jsRegExpFree(JSRegExp*);
 
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
 #endif
index ea1927dda77f557d8a1f5c70e8353bdc7b84f9c1..a7c6c1cb526fa7a495987fb42d3524939181a3d9 100644 (file)
@@ -4,15 +4,15 @@ INCLUDEPATH += $$PWD $$OUTPUT_DIR/JavaScriptCore/kjs/tmp
 DEPENDPATH += $$PWD
 
 SOURCES += \
-    pcre_compile.c \
-    pcre_exec.c \
-    pcre_ord2utf8.c \
-    pcre_tables.c \
-    pcre_ucp_searchfuncs.c \
-    pcre_xclass.c
+    pcre_compile.cpp \
+    pcre_exec.cpp \
+    pcre_ord2utf8.cpp \
+    pcre_tables.cpp \
+    pcre_ucp_searchfuncs.cpp \
+    pcre_xclass.cpp
 
 CTGENFILE += \
-    dftables.c
+    dftables.cpp
 
 # GENERATOR: "chartables.c": compile and execute the chartables generator (and add it to sources)
 ctgen.output = tmp/chartables.c
similarity index 94%
rename from JavaScriptCore/pcre/pcre_compile.c
rename to JavaScriptCore/pcre/pcre_compile.cpp
index 57e37fcf22a636eaebaa401eec0373bacefd6528..da886502478812580ca53fffa76db71e6943ff46 100644 (file)
@@ -1,13 +1,12 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
-
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
-           Copyright (c) 2004, 2005 Apple Computer, Inc.
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -38,26 +37,18 @@ POSSIBILITY OF SUCH DAMAGE.
 -----------------------------------------------------------------------------
 */
 
-
-/* This module contains the external function pcre_compile(), along with
+/* This module contains the external function jsRegExpExecute(), along with
 supporting internal functions that are not used by other modules. */
 
-
 #include "pcre_internal.h"
 
+#include <wtf/ASCIICType.h>
+#include <wtf/FastMalloc.h>
 
-/* WARNING: These macros evaluate their parameters more than once. */
-#define DIGITAB(x) ((x) < 128 ? digitab[(x)] : 0)
-
-
-/* When DEBUG is defined, we need the pcre_printint() function, which is also
-used by pcretest. DEBUG is not defined when building a production library. */
-
-#ifdef DEBUG
-#include "pcre_printint.src"
-#endif
-
+using namespace WTF;
 
+/* WARNING: This macro evaluates its parameters more than once. */
+#define DIGITAB(x) ((x) < 128 ? digitab[(x)] : 0)
 
 /*************************************************
 *      Code parameters and static tables         *
@@ -76,7 +67,7 @@ are simple data values; negative values are for special things like \d and so
 on. Zero means further processing is needed (for things like \x), or the escape
 is invalid. */
 
-static const short int escapes[] = {
+static const short escapes[] = {
      0,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
      0,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
    '@',      0, -ESC_B,      0, -ESC_D,      0,      0,      0,   /* @ - G */
@@ -89,72 +80,56 @@ static const short int escapes[] = {
      0,      0,      0                                            /* x - z */
 };
 
+/* Error code numbers. They are given names so that they can more easily be
+tracked. */
+
+typedef enum {
+    ERR0, ERR1, ERR2, ERR3, ERR4, ERR5, ERR6, ERR7, ERR8, ERR9,
+    ERR10, ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17
+} ErrorCode;
+
+/* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
+the definition is next to the definition of the opcodes in pcre_internal.h. */
+
+static const uschar OP_lengths[] = { OP_LENGTHS };
 
 /* The texts of compile-time error messages. These are "char *" because they
 are passed to the outside world. */
 
-static const char * const error_texts[] = {
-  "no error",
-  "\\ at end of pattern",
-  "\\c at end of pattern",
-  "unrecognized character follows \\",
-  "numbers out of order in {} quantifier",
-  /* 5 */
-  "number too big in {} quantifier",
-  "missing terminating ] for character class",
-  "invalid escape sequence in character class",
-  "range out of order in character class",
-  "nothing to repeat",
-  /* 10 */
-  "operand of unlimited repeat could match the empty string",
-  "internal error: unexpected repeat",
-  "unrecognized character after (?",
-  "POSIX named classes are supported only within a class",
-  "missing )",
-  /* 15 */
-  "reference to non-existent subpattern",
-  "erroffset passed as NULL",
-  "unknown option bit(s) set",
-  "missing ) after comment",
-  "parentheses nested too deeply",
-  /* 20 */
-  "regular expression too large",
-  "failed to get memory",
-  "unmatched parentheses",
-  "internal error: code overflow",
-  "unrecognized character after (?<",
-  /* 25 */
-  "lookbehind assertion is not fixed length",
-  "malformed number after (?(",
-  "conditional group contains more than two branches",
-  "assertion expected after (?(",
-  "(?R or (?digits must be followed by )",
-  /* 30 */
-  "unknown POSIX class name",
-  "POSIX collating elements are not supported",
-  "this version of PCRE is not compiled with PCRE_UTF8 support",
-  "spare error",
-  "character value in \\x{...} sequence is too large",
-  /* 35 */
-  "invalid condition (?(0)",
-  "\\C not allowed in lookbehind assertion",
-  "PCRE does not support \\L, \\l, \\N, \\U, or \\u",
-  "number after (?C is > 255",
-  "closing ) for (?C expected",
-  /* 40 */
-  "recursive call could loop indefinitely",
-  "unrecognized character after (?P",
-  "syntax error after (?P",
-  "two named groups have the same name",
-  "invalid UTF-16 string",
-  /* 45 */
-  "support for \\P, \\p, and \\X has not been compiled",
-  "malformed \\P or \\p sequence",
-  "unknown property name after \\P or \\p"
-};
-
+static const char* error_text(ErrorCode code)
+{
+    static const char error_texts[] =
+      /* 1 */
+      "\\ at end of pattern\0"
+      "\\c at end of pattern\0"
+      "character value in \\x{...} sequence is too large\0"
+      "numbers out of order in {} quantifier\0"
+      /* 5 */
+      "number too big in {} quantifier\0"
+      "missing terminating ] for character class\0"
+      "internal error: code overflow\0"
+      "range out of order in character class\0"
+      "nothing to repeat\0"
+      /* 10 */
+      "unmatched parentheses\0"
+      "internal error: unexpected repeat\0"
+      "unrecognized character after (?\0"
+      "failed to get memory\0"
+      "missing )\0"
+      /* 15 */
+      "reference to non-existent subpattern\0"
+      "regular expression too large\0"
+      "parentheses nested too deeply"
+    ;
+
+    int i = code;
+    const char* text = error_texts;
+    while (i > 1)
+        i -= !*text++;
+    return text;
+}
 
-/* Table to identify digits and hex digits. This is used when compiling
+/* Table to hex digits. This is used when compiling
 patterns. Note that the tables in chartables are dependent on the locale, and
 may mark arbitrary characters as digits - but the PCRE compiling code expects
 to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
@@ -163,12 +138,11 @@ character value tests (at least in some simple cases I timed), and in some
 applications one wants PCRE to compile efficiently as well as match
 efficiently.
 
-For convenience, we use the same bit definitions as in chartables:
+For convenience, we use the same bit definition as in chartables:
 
-  0x04   decimal digit
   0x08   hexadecimal digit
 
-Then we can use ctype_digit and ctype_xdigit in the code. */
+Then we can use ctype_xdigit in the code. */
 
 static const unsigned char digitab[] =
   {
@@ -205,15 +179,12 @@ static const unsigned char digitab[] =
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
 
-
 /* Definition to allow mutual recursion */
 
 static BOOL
-  compile_regex(int, int *, uschar **, const pcre_uchar **, const pcre_uchar *, int *, int,
+  compile_regex(int, int *, uschar **, const pcre_uchar **, const pcre_uchar *, ErrorCode*, int,
     int *, int *, compile_data *);
 
-
-
 /*************************************************
 *            Handle escapes                      *
 *************************************************/
@@ -237,7 +208,7 @@ Returns:         zero or positive => a data character
 */
 
 static int
-check_escape(const pcre_uchar **ptrptr, const pcre_uchar *patternEnd, int *errorcodeptr, int bracount,
+check_escape(const pcre_uchar **ptrptr, const pcre_uchar *patternEnd, ErrorCode* errorcodeptr, int bracount,
   BOOL isclass)
 {
 const pcre_uchar *ptr = *ptrptr + 1;
@@ -252,13 +223,11 @@ if (ptr == patternEnd) {
 
 c = *ptr;
 
-if (0) { } /* Matches with else below; to make merging easier. */
-
 /* Non-alphamerics are literals. For digits or letters, do an initial lookup in
 a table. A non-zero result is something that can be returned immediately.
 Otherwise further processing may be required. */
 
-else if (c < '0' || c > 'z') {}                           /* Not alphameric */
+if (c < '0' || c > 'z') {}                           /* Not alphameric */
 else if ((i = escapes[c - '0']) != 0) c = i;
 
 /* Escapes that need further processing, or are illegal. */
@@ -290,7 +259,7 @@ else
       {
       oldptr = ptr;
       c -= '0';
-      while (ptr + 1 < patternEnd && (DIGITAB(ptr[1]) & ctype_digit) != 0)
+      while (ptr + 1 < patternEnd && isASCIIDigit(ptr[1]))
         c = c * 10 + *(++ptr) - '0';
       if (c < 10 || c <= bracount)
         {
@@ -344,12 +313,12 @@ else
 
       if (pt < patternEnd && *pt == '}')
         {
-        if (c < 0 || count > 8) *errorcodeptr = ERR34;
-        else if (c >= 0xD800 && c <= 0xDFFF) *errorcodeptr = ERR34; // half of surrogate pair
-        else if (c >= 0xFDD0 && c <= 0xFDEF) *errorcodeptr = ERR34; // ?
-        else if (c == 0xFFFE) *errorcodeptr = ERR34; // not a character
-        else if (c == 0xFFFF)  *errorcodeptr = ERR34; // not a character
-        else if (c > 0x10FFFF) *errorcodeptr = ERR34; // out of Unicode character range
+        if (c < 0 || count > 8) *errorcodeptr = ERR3;
+        else if (c >= 0xD800 && c <= 0xDFFF) *errorcodeptr = ERR3; // half of surrogate pair
+        else if (c >= 0xFDD0 && c <= 0xFDEF) *errorcodeptr = ERR3; // ?
+        else if (c == 0xFFFE) *errorcodeptr = ERR3; // not a character
+        else if (c == 0xFFFF)  *errorcodeptr = ERR3; // not a character
+        else if (c > 0x10FFFF) *errorcodeptr = ERR3; // out of Unicode character range
         ptr = pt;
         break;
         }
@@ -440,10 +409,10 @@ Returns:    TRUE or FALSE
 static BOOL
 is_counted_repeat(const pcre_uchar *p, const pcre_uchar *patternEnd)
 {
-if (p >= patternEnd || (DIGITAB(*p) & ctype_digit) == 0)
+if (p >= patternEnd || !isASCIIDigit(*p))
     return FALSE;
 p++;
-while (p < patternEnd && (DIGITAB(*p) & ctype_digit) != 0)
+while (p < patternEnd && isASCIIDigit(*p))
     p++;
 if (p < patternEnd && *p == '}')
     return TRUE;
@@ -453,10 +422,10 @@ if (p >= patternEnd || *p++ != ',')
 if (p < patternEnd && *p == '}')
     return TRUE;
 
-if (p >= patternEnd || (DIGITAB(*p) & ctype_digit) == 0)
+if (p >= patternEnd || !isASCIIDigit(*p))
     return FALSE;
 p++;
-while (p < patternEnd && (DIGITAB(*p) & ctype_digit) != 0)
+while (p < patternEnd && isASCIIDigit(*p))
     p++;
 
 return (p < patternEnd && *p == '}');
@@ -484,7 +453,7 @@ Returns:         pointer to '}' on success;
 */
 
 static const pcre_uchar *
-read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, int *errorcodeptr)
+read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, ErrorCode* errorcodeptr)
 {
 int min = 0;
 int max = -1;
@@ -492,7 +461,7 @@ int max = -1;
 /* Read the minimum value and do a paranoid check: a negative value indicates
 an integer overflow. */
 
-while ((DIGITAB(*p) & ctype_digit) != 0) min = min * 10 + *p++ - '0';
+while (isASCIIDigit(*p)) min = min * 10 + *p++ - '0';
 if (min < 0 || min > 65535)
   {
   *errorcodeptr = ERR5;
@@ -507,7 +476,7 @@ if (*p == '}') max = min; else
   if (*(++p) != '}')
     {
     max = 0;
-    while((DIGITAB(*p) & ctype_digit) != 0) max = max * 10 + *p++ - '0';
+    while (isASCIIDigit(*p)) max = max * 10 + *p++ - '0';
     if (max < 0 || max > 65535)
       {
       *errorcodeptr = ERR5;
@@ -558,7 +527,7 @@ for (;;)
     case OP_ASSERT_NOT:
     if (!skipassert) return code;
     do code += GET(code, 1); while (*code == OP_ALT);
-    code += _pcre_OP_lengths[*code];
+    code += OP_lengths[*code];
     break;
 
     case OP_WORD_BOUNDARY:
@@ -567,7 +536,7 @@ for (;;)
     /* Fall through */
 
     case OP_BRANUMBER:
-    code += _pcre_OP_lengths[*code];
+    code += OP_lengths[*code];
     break;
 
     default:
@@ -654,7 +623,7 @@ for (;;)
     case OP_DOLL:
     case OP_NOT_WORD_BOUNDARY:
     case OP_WORD_BOUNDARY:
-    cc += _pcre_OP_lengths[*cc];
+    cc += OP_lengths[*cc];
     break;
 
     /* Handle literal characters */
@@ -765,7 +734,7 @@ could_be_empty_branch(const uschar *code, const uschar *endcode)
 register int c;
 for (code = first_significant_code(code + 1 + LINK_SIZE, TRUE);
      code < endcode;
-     code = first_significant_code(code + _pcre_OP_lengths[c], TRUE))
+     code = first_significant_code(code + OP_lengths[c], TRUE))
   {
   const uschar *ccode;
 
@@ -955,7 +924,7 @@ changed during the branch, the pointer is used to change the external options
 bits.
 
 Arguments:
-  optionsptr     pointer to the option bits
+  options        the option bits
   brackets       points to number of extracting brackets used
   codeptr        points to the pointer to the current code point
   ptrptr         points to the current pattern pointer
@@ -969,8 +938,8 @@ Returns:         TRUE on success
 */
 
 static BOOL
-compile_branch(int *optionsptr, int *brackets, uschar **codeptr,
-  const pcre_uchar **ptrptr, const pcre_uchar *patternEnd, int *errorcodeptr, int *firstbyteptr,
+compile_branch(int options, int *brackets, uschar **codeptr,
+  const pcre_uchar **ptrptr, const pcre_uchar *patternEnd, ErrorCode* errorcodeptr, int *firstbyteptr,
   int *reqbyteptr, compile_data *cd)
 {
 int repeat_type, op_type;
@@ -979,7 +948,6 @@ int bravalue = 0;
 int firstbyte, reqbyte;
 int zeroreqbyte, zerofirstbyte;
 int req_caseopt, reqvary, tempreqvary;
-int options = *optionsptr;
 int after_manual_callout = 0;
 register int c;
 register uschar *code = *codeptr;
@@ -1024,7 +992,6 @@ for (;; ptr++)
   BOOL is_quantifier;
   int class_charcount;
   int class_lastchar;
-  int newoptions;
   int skipbytes;
   int subreqbyte;
   int subfirstbyte;
@@ -1954,7 +1921,6 @@ for (;; ptr++)
     check for syntax errors here.  */
 
     case '(':
-    newoptions = options;
     skipbytes = 0;
 
     if (*(++ptr) == '?')
@@ -2011,7 +1977,7 @@ for (;; ptr++)
     tempreqvary = cd->req_varyopt;     /* Save value before bracket */
 
     if (!compile_regex(
-         newoptions,                   /* The complete new option state */
+         options,
          brackets,                     /* Extracting bracket count */
          &tempcode,                    /* Where to put code (updated) */
          &ptr,                         /* Input pointer (updated) */
@@ -2253,7 +2219,7 @@ Returns:      TRUE on success
 
 static BOOL
 compile_regex(int options, int *brackets, uschar **codeptr,
-  const pcre_uchar **ptrptr, const pcre_uchar *patternEnd, int *errorcodeptr, int skipbytes,
+  const pcre_uchar **ptrptr, const pcre_uchar *patternEnd, ErrorCode* errorcodeptr, int skipbytes,
   int *firstbyteptr, int *reqbyteptr, compile_data *cd)
 {
 const pcre_uchar *ptr = *ptrptr;
@@ -2276,7 +2242,7 @@ for (;;)
   {
   /* Now compile the branch */
 
-  if (!compile_branch(&options, brackets, &code, &ptr, patternEnd, errorcodeptr,
+  if (!compile_branch(options, brackets, &code, &ptr, patternEnd, errorcodeptr,
         &branchfirstbyte, &branchreqbyte, cd))
     {
     *ptrptr = ptr;
@@ -2414,7 +2380,7 @@ Returns:     TRUE or FALSE
 */
 
 static BOOL
-is_anchored(register const uschar *code, int *options, unsigned int bracket_map,
+is_anchored(register const uschar *code, int options, unsigned int bracket_map,
   unsigned int backref_map)
 {
 do {
@@ -2442,7 +2408,7 @@ do {
 
    /* Check for explicit anchoring */
 
-   else if (((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
+   else if (((options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
      return FALSE;
    code += GET(code, 1);
    }
@@ -2540,7 +2506,7 @@ Returns:     -1 or the fixed first char
 */
 
 static int
-find_firstassertedchar(const uschar *code, int *options, BOOL inassert)
+find_firstassertedchar(const uschar *code, int options, BOOL inassert)
 {
 register int c = -1;
 do {
@@ -2577,7 +2543,7 @@ do {
      if (c < 0)
        {
        c = scode[1];
-       if ((*options & PCRE_CASELESS) != 0) c |= REQ_CASELESS;
+       if ((options & PCRE_CASELESS) != 0) c |= REQ_CASELESS;
        }
      else if (c != scode[1]) return -1;
      break;
@@ -2614,7 +2580,9 @@ Returns:        pointer to compiled data block, or NULL on error,
 */
 
 pcre *
-jsRegExpCompile(const pcre_char* pattern, int patternLength, int options, unsigned* numSubpatterns, const char** errorptr)
+jsRegExpCompile(const pcre_char* pattern, int patternLength,
+    JSRegExpIgnoreCaseOption ignoreCase, JSRegExpMultilineOption multiline,
+    unsigned* numSubpatterns, const char** errorptr)
 {
 real_pcre *re;
 int length = 1 + LINK_SIZE;      /* For initial BRA plus length */
@@ -2626,7 +2594,7 @@ int item_count = -1;
 int name_count = 0;
 int max_name_size = 0;
 int lastitemlength = 0;
-int errorcode = 0;
+ErrorCode errorcode = ERR0;
 BOOL class_utf8;
 BOOL capturing;
 unsigned int brastackptr = 0;
@@ -2908,7 +2876,7 @@ while (++ptr < patternEnd)
             goto PCRE_ERROR_RETURN;
             }
 
-          if ((d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
+          if ((d > 255 || (ignoreCase && d > 127)))
             {
             uschar buffer[6];
             if (!class_utf8)         /* Allow for XCLASS overhead */
@@ -2923,7 +2891,7 @@ while (++ptr < patternEnd)
             range upwards might push d over a boundary that makes is use
             another byte in the UTF-8 representation. */
 
-            if ((options & PCRE_CASELESS) != 0)
+            if (ignoreCase)
               {
               int occ, ocd;
               int cc = c;
@@ -2964,7 +2932,7 @@ while (++ptr < patternEnd)
 
         else
           {
-          if ((c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
+          if ((c > 255 || (ignoreCase && c > 127)))
             {
             uschar buffer[6];
             class_optcount = 10;     /* Ensure > 1 */
@@ -2973,8 +2941,7 @@ while (++ptr < patternEnd)
               class_utf8 = TRUE;
               length += LINK_SIZE + 2;
               }
-            length += (((options & PCRE_CASELESS) != 0)? 2 : 1) *
-              (1 + _pcre_ord2utf8(c, buffer));
+            length += (ignoreCase ? 2 : 1) * (1 + _pcre_ord2utf8(c, buffer));
             }
           }
         }
@@ -3070,7 +3037,7 @@ while (++ptr < patternEnd)
 
     if (brastackptr >= sizeof(brastack)/sizeof(int))
       {
-      errorcode = ERR19;
+      errorcode = ERR17;
       goto PCRE_ERROR_RETURN;
       }
 
@@ -3180,20 +3147,19 @@ length += 2 + LINK_SIZE;    /* For final KET and END */
 
 if (length > MAX_PATTERN_SIZE)
   {
-  errorcode = ERR20;
-  goto PCRE_EARLY_ERROR_RETURN;
+  errorcode = ERR16;
+  goto PCRE_ERROR_RETURN;
   }
 
-/* Compute the size of data block needed and get it, either from malloc or
-externally provided function. */
+/* Compute the size of data block needed and get it. */
 
 size = length + sizeof(real_pcre) + name_count * (max_name_size + 3);
-re = (real_pcre *)(pcre_malloc)(size);
+re = reinterpret_cast<real_pcre*>(new char[size]);
 
 if (re == NULL)
   {
-  errorcode = ERR21;
-  goto PCRE_EARLY_ERROR_RETURN;
+  errorcode = ERR13;
+  goto PCRE_ERROR_RETURN;
   }
 
 /* Put in the magic number, and save the sizes, options, and character table
@@ -3202,7 +3168,7 @@ the end; it's there to help in the case when a regex compiled on a system with
 4-byte pointers is run on another with 8-byte pointers. */
 
 re->size = (pcre_uint32)size;
-re->options = options;
+re->options = (ignoreCase ? PCRE_CASELESS : 0) | (multiline ? PCRE_MULTILINE : 0);
 
 /* The starting points of the name/number translation table and of the code are
 passed around in the compile data block. */
@@ -3220,7 +3186,7 @@ ptr = (const pcre_uchar *)pattern;
 code = (uschar *)codestart;
 *code = OP_BRA;
 bracount = 0;
-(void)compile_regex(options, &bracount, &code, &ptr,
+(void)compile_regex(re->options, &bracount, &code, &ptr,
   patternEnd,
   &errorcode, 0, &firstbyte, &reqbyte, &compile_block);
 re->top_bracket = bracount;
@@ -3228,7 +3194,7 @@ re->top_backref = compile_block.top_backref;
 
 /* If not reached end of pattern on success, there's an excess bracket. */
 
-if (errorcode == 0 && ptr < patternEnd) errorcode = ERR22;
+if (errorcode == 0 && ptr < patternEnd) errorcode = ERR10;
 
 /* Fill in the terminating state and check for disastrous overflow, but
 if debugging, leave the test till after things are printed out. */
@@ -3236,7 +3202,7 @@ if debugging, leave the test till after things are printed out. */
 *code++ = OP_END;
 
 #ifndef DEBUG
-if (code - codestart > length) errorcode = ERR23;
+if (code - codestart > length) errorcode = ERR7;
 #endif
 
 /* Give an error if there's back reference to a non-existent capturing
@@ -3246,12 +3212,11 @@ if (re->top_backref > re->top_bracket) errorcode = ERR15;
 
 /* Failed to compile, or error while post-processing */
 
-if (errorcode != 0)
+if (errorcode != ERR0)
   {
-  (pcre_free)(re);
+  delete [] reinterpret_cast<char*>(re);
   PCRE_ERROR_RETURN:
-  PCRE_EARLY_ERROR_RETURN:
-  *errorptr = error_texts[errorcode];
+  *errorptr = error_text(errorcode);
   return NULL;
   }
 
@@ -3266,13 +3231,12 @@ start with ^. and also when all branches start with .* for non-DOTALL matches.
 */
 
   {
-  int temp_options = options;
-  if (is_anchored(codestart, &temp_options, 0, compile_block.backref_map))
+  if (is_anchored(codestart, re->options, 0, compile_block.backref_map))
     re->options |= PCRE_ANCHORED;
   else
     {
     if (firstbyte < 0)
-      firstbyte = find_firstassertedchar(codestart, &temp_options, FALSE);
+      firstbyte = find_firstassertedchar(codestart, re->options, FALSE);
     if (firstbyte >= 0)   /* Remove caseless flag for non-caseable chars */
       {
       int ch = firstbyte & 255;
@@ -3346,9 +3310,10 @@ was compiled can be seen. */
 if (code - codestart > length)
   {
   (pcre_free)(re);
-  *errorptr = error_texts[ERR23];
+  *errorptr = error_text(ERR7);
   return NULL;
   }
+
 #endif
 
 if (numSubpatterns)
@@ -3358,7 +3323,5 @@ return (pcre *)re;
 
 void jsRegExpFree(JSRegExp* re)
 {
-    pcre_free(re);
+    delete [] reinterpret_cast<char*>(re);
 }
-
-/* End of pcre_compile.c */
similarity index 82%
rename from JavaScriptCore/pcre/pcre_exec.c
rename to JavaScriptCore/pcre/pcre_exec.cpp
index bad3169447449b76da627e912b23222ad4fcb79b..acfb7ede5c500358910ee1ba7bb7e5cbba255ba7 100644 (file)
@@ -1,13 +1,11 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
-
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
-
     Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
@@ -39,13 +37,21 @@ POSSIBILITY OF SUCH DAMAGE.
 -----------------------------------------------------------------------------
 */
 
+/* This module contains jsRegExpExecute(), the externally visible function
+that does pattern matching using an NFA algorithm, following the rules from
+the JavaScript specification. There are also some supporting functions. */
 
-/* This module contains pcre_exec(), the externally visible function that does
-pattern matching using an NFA algorithm, trying to mimic Perl as closely as
-possible. There are also some static supporting functions. */
+#include "pcre_internal.h"
 
+#include <wtf/ASCIICType.h>
+#include <wtf/Vector.h>
 
-#include "pcre_internal.h"
+using namespace WTF;
+
+#ifdef __GNUC__
+#define USE_COMPUTED_GOTO_FOR_MATCH_RECURSION
+//#define USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP
+#endif
 
 /* Avoid warnings on Windows. */
 #undef min
@@ -62,6 +68,66 @@ typedef struct eptrblock {
   USPTR epb_saved_eptr;
 } eptrblock;
 
+/* Structure for remembering the local variables in a private frame */
+
+typedef struct matchframe {
+  /* Where to jump back to */
+#ifndef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION
+  int where;
+#else
+  void *where;
+#endif
+
+  struct matchframe *prevframe;
+
+  /* Function arguments that may change */
+
+  const pcre_uchar *eptr;
+  const uschar *ecode;
+  int offset_top;
+  eptrblock *eptrb;
+
+  /* Function local variables */
+
+  const uschar *data;
+  const uschar *next;
+  const pcre_uchar *pp;
+  const uschar *prev;
+  const pcre_uchar *saved_eptr;
+
+  int repeat_othercase;
+
+  int ctype;
+  int fc;
+  int fi;
+  int length;
+  int max;
+  int number;
+  int offset;
+  int save_offset1, save_offset2, save_offset3;
+
+  eptrblock newptrb;
+} matchframe;
+
+/* Structure for passing "static" information around between the functions
+doing traditional NFA matching, so that they are thread-safe. */
+
+typedef struct match_data {
+  unsigned long int match_call_count;      /* As it says */
+  int   *offset_vector;         /* Offset vector */
+  int    offset_end;            /* One past the end */
+  int    offset_max;            /* The maximum usable for return data */
+  const uschar *lcc;            /* Points to lower casing table */
+  const uschar *ctypes;         /* Points to table of type maps */
+  BOOL   offset_overflow;       /* Set if too many extractions */
+  USPTR  start_subject;         /* Start of the subject string */
+  USPTR  end_subject;           /* End of the subject string */
+  USPTR  end_match_ptr;         /* Subject position at end match */
+  int    end_offset_top;        /* Highwater mark at end of match */
+  BOOL   multiline;
+  BOOL   caseless;
+} match_data;
+
 #define match_isgroup      TRUE    /* Set if start of bracketed group */
 
 /* Non-error returns from the match() function. Error returns are externally
@@ -170,31 +236,17 @@ return TRUE;
 ****************************************************************************
                    RECURSION IN THE match() FUNCTION
 
-The match() function is highly recursive, though not every recursive call
-increases the recursive depth. Nevertheless, some regular expressions can cause
-it to recurse to a great depth. I was writing for Unix, so I just let it call
-itself recursively. This uses the stack for saving everything that has to be
-saved for a recursive call. On Unix, the stack can be large, and this works
-fine.
-
-It turns out that on some non-Unix-like systems there are problems with
-programs that use a lot of stack. (This despite the fact that every last chip
-has oodles of memory these days, and techniques for extending the stack have
-been known for decades.) So....
-
-There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
-calls by keeping local variables that need to be preserved in blocks of memory
-obtained from malloc() instead instead of on the stack. Macros are used to
-achieve this so that the actual code doesn't look very different to what it
-always used to.
+The original match() function was highly recursive. The current version
+still has the remnants of the original in that recursive processing of the
+regular expression is triggered by invoking a macro named RMATCH. This is
+no longer really much like a recursive call to match() itself.
 ****************************************************************************
 ***************************************************************************/
 
-
 /* These versions of the macros use the stack, as normal. There are debugging
 versions and production versions. */
 
-#ifndef __GNUC__
+#ifndef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION
 
 /* Use numbered labels and switch statement at the bottom of the match function. */
 
@@ -215,14 +267,12 @@ a bit more code and notice if we use conflicting numbers.*/
 
 #endif
 
-
 #define RMATCH(num, ra, rb, rc)\
   {\
   if (frame >= stackframes && frame + 1 < stackframesend)\
     newframe = frame + 1;\
   else\
-    newframe = (pcre_malloc)(sizeof(matchframe));\
-  frame->where = RMATCH_WHERE(num);\
+    newframe = new matchframe;\
   newframe->eptr = frame->eptr;\
   newframe->ecode = (ra);\
   newframe->offset_top = frame->offset_top;\
@@ -231,75 +281,31 @@ a bit more code and notice if we use conflicting numbers.*/
   ++rdepth;\
   newframe->prevframe = frame;\
   frame = newframe;\
+  frame->where = RMATCH_WHERE(num);\
   DPRINTF(("restarting from line %d\n", __LINE__));\
-  goto HEAP_RECURSE;\
+  goto RECURSE;\
 RRETURN_##num:\
+  newframe = frame;\
+  frame = frame->prevframe;\
+  if (!(newframe >= stackframes && newframe < stackframesend))\
+    delete newframe;\
   --rdepth;\
   DPRINTF(("did a goto back to line %d\n", __LINE__));\
   }
+#define RRETURN goto RRETURN_LABEL
 
-#define RRETURN(ra)\
+#define RRETURN_NO_MATCH \
   {\
-  newframe = frame;\
-  frame = newframe->prevframe;\
-  if (!(newframe >= stackframes && newframe < stackframesend))\
-    (pcre_free)(newframe);\
-  if (frame != NULL)\
-    {\
-    rrc = (ra);\
-    goto RRETURN_LABEL;\
-    }\
-  return ra;\
+    is_match = FALSE;\
+    RRETURN;\
   }
 
-/* Structure for remembering the local variables in a private frame */
-
-typedef struct matchframe {
-  struct matchframe *prevframe;
-
-  /* Function arguments that may change */
-
-  const pcre_uchar *eptr;
-  const uschar *ecode;
-  int offset_top;
-  eptrblock *eptrb;
-
-  /* Function local variables */
-
-  const uschar *data;
-  const uschar *next;
-  const pcre_uchar *pp;
-  const uschar *prev;
-  const pcre_uchar *saved_eptr;
-
-  int repeat_othercase;
-
-  int ctype;
-  int fc;
-  int fi;
-  int length;
-  int max;
-  int number;
-  int offset;
-  int save_offset1, save_offset2, save_offset3;
-
-  eptrblock newptrb;
-
-  /* Where to jump back to */
-
-#ifndef __GNUC__
-  int where;
-#else
-  void *where;
-#endif
-
-} matchframe;
-
-
-/***************************************************************************
-***************************************************************************/
-
-
+#define RRETURN_ERROR(error) \
+  { \
+    i = (error); \
+    goto RETURN_ERROR; \
+  }
 
 /*************************************************
 *         Match from current position            *
@@ -324,16 +330,12 @@ Returns:       MATCH_MATCH if matched            )  these values are >= 0
                  (e.g. stopped by repeated call or recursion limit)
 */
 
-static int
-match(USPTR eptr, const uschar *ecode, int offset_top, match_data *md)
+static int match(USPTR eptr, const uschar *ecode, int offset_top, match_data *md)
 {
-/* These variables do not need to be preserved over recursion in this function,
-so they can be ordinary variables in all cases. Mark them with "register"
-because they are used a lot in loops. */
+register int is_match = FALSE;
+register int i;
+register int c;
 
-register int  rrc;    /* Returns from recursive calls */
-register int  i;      /* Used for loops not involving calls to RMATCH() */
-register int  c;      /* Character values not kept over RMATCH() calls */
 unsigned rdepth = 0;
 
 BOOL cur_is_word;
@@ -342,11 +344,6 @@ BOOL is_group_start = TRUE;
 int min;
 BOOL minimize = FALSE; /* Initialization not really needed, but some compilers think so. */
 
-/* When recursion is not being used, all "local" variables that have to be
-preserved over calls to RMATCH() are part of a "frame" which is obtained from
-heap storage. Set up the top-level frame here; others are obtained from the
-heap whenever RMATCH() does a "recursion". See the macro definitions above. */
-
 /* The value 16 here is large enough that most regular expressions don't require
 any calls to pcre_stack_malloc, yet the amount of stack used for the array is
 modest enough that we don't run out of stack. */
@@ -355,9 +352,26 @@ matchframe *stackframesend = stackframes + sizeof(stackframes) / sizeof(stackfra
 
 matchframe *frame = stackframes;
 matchframe *newframe;
-frame->prevframe = NULL;            /* Marks the top level */
 
-/* Copy in the original argument variables */
+/* The opcode jump table. */
+#ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP
+#define EMIT_JUMP_TABLE_ENTRY(opcode) &&LABEL_OP_##opcode,
+static void* opcode_jump_table[256] = { FOR_EACH_OPCODE(EMIT_JUMP_TABLE_ENTRY) };
+#undef EMIT_JUMP_TABLE_ENTRY
+#endif
+
+/* One-time setup of the opcode jump table. */
+#ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP
+i = 255;
+while (!opcode_jump_table[i])
+  opcode_jump_table[i--] = &&CAPTURING_BRACKET;
+#endif
+
+#ifdef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION
+frame->where = &&RETURN;
+#else
+frame->where = 0;
+#endif
 
 frame->eptr = eptr;
 frame->ecode = ecode;
@@ -366,7 +380,7 @@ frame->eptrb = NULL;
 
 /* This is where control jumps back to to effect "recursion" */
 
-HEAP_RECURSE:
+RECURSE:
 
 /* OK, now we can get on with the real code of the function. Recursive calls
 are specified by the macro RMATCH and RRETURN is used to return. When
@@ -379,8 +393,8 @@ however, impact performance when true recursion is being used. */
 /* First check that we haven't called match() too many times, or that we
 haven't exceeded the recursive call limit. */
 
-if (md->match_call_count++ >= MATCH_LIMIT) RRETURN(JS_REGEXP_ERROR_MATCHLIMIT);
-if (rdepth >= MATCH_LIMIT_RECURSION) RRETURN(JS_REGEXP_ERROR_RECURSIONLIMIT);
+if (md->match_call_count++ >= MATCH_LIMIT) RRETURN_ERROR(JSRegExpErrorMatchLimit);
+if (rdepth >= MATCH_LIMIT_RECURSION) RRETURN_ERROR(JSRegExpErrorRecursionLimit);
 
 /* At the start of a bracketed group, add the current subject pointer to the
 stack of such pointers, to be re-instated at the end of the group when we hit
@@ -396,29 +410,47 @@ if (is_group_start)
 
 /* Now start processing the operations. */
 
+#ifndef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP
 for (;;)
+#endif
   {
+
+#ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP
+  #define BEGIN_OPCODE(opcode) LABEL_OP_##opcode
+  #define NEXT_OPCODE goto *opcode_jump_table[*frame->ecode]
+#else
+  #define BEGIN_OPCODE(opcode) case OP_##opcode
+  #define NEXT_OPCODE continue
+#endif
+
+#ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP
+  NEXT_OPCODE;
+#else
   switch (*frame->ecode)
+#endif
     {
-    case OP_BRA:     /* Non-capturing bracket: optimized */
+    /* Non-capturing bracket: optimized */
+
+    BEGIN_OPCODE(BRA):
     NON_CAPTURING_BRACKET:
     DPRINTF(("start bracket 0\n"));
     do
       {
       RMATCH(2, frame->ecode + 1 + LINK_SIZE, frame->eptrb, match_isgroup);
-      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      if (is_match) RRETURN;
       frame->ecode += GET(frame->ecode, 1);
       }
     while (*frame->ecode == OP_ALT);
     DPRINTF(("bracket 0 failed\n"));
-    RRETURN(MATCH_NOMATCH);
+    RRETURN;
 
     /* End of the pattern. */
 
-    case OP_END:
+    BEGIN_OPCODE(END):
     md->end_match_ptr = frame->eptr;          /* Record where we ended */
     md->end_offset_top = frame->offset_top;   /* and how many extracts were taken */
-    RRETURN(MATCH_MATCH);
+    is_match = TRUE;
+    RRETURN;
 
     /* Assertion brackets. Check the alternative branches in turn - the
     matching won't pass the KET for an assertion. If any one branch matches,
@@ -426,16 +458,15 @@ for (;;)
     start of each branch to move the current point backwards, so the code at
     this level is identical to the lookahead case. */
 
-    case OP_ASSERT:
+    BEGIN_OPCODE(ASSERT):
     do
       {
       RMATCH(6, frame->ecode + 1 + LINK_SIZE, NULL, match_isgroup);
-      if (rrc == MATCH_MATCH) break;
-      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      if (is_match) break;
       frame->ecode += GET(frame->ecode, 1);
       }
     while (*frame->ecode == OP_ALT);
-    if (*frame->ecode == OP_KET) RRETURN(MATCH_NOMATCH);
+    if (*frame->ecode == OP_KET) RRETURN_NO_MATCH;
 
     /* Continue from after the assertion, updating the offsets high water
     mark, since extracts may have been taken during the assertion. */
@@ -443,22 +474,21 @@ for (;;)
     do frame->ecode += GET(frame->ecode,1); while (*frame->ecode == OP_ALT);
     frame->ecode += 1 + LINK_SIZE;
     frame->offset_top = md->end_offset_top;
-    continue;
+    NEXT_OPCODE;
 
     /* Negative assertion: all branches must fail to match */
 
-    case OP_ASSERT_NOT:
+    BEGIN_OPCODE(ASSERT_NOT):
     do
       {
       RMATCH(7, frame->ecode + 1 + LINK_SIZE, NULL, match_isgroup);
-      if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
-      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      if (is_match) RRETURN_NO_MATCH;
       frame->ecode += GET(frame->ecode,1);
       }
     while (*frame->ecode == OP_ALT);
 
     frame->ecode += 1 + LINK_SIZE;
-    continue;
+    NEXT_OPCODE;
 
     /* "Once" brackets are like assertion brackets except that after a match,
     the point in the subject string is not moved back. Thus there can never be
@@ -467,7 +497,7 @@ for (;;)
     for this kind of subpattern. If any one branch matches, we carry on as at
     the end of a normal bracket, leaving the subject pointer. */
 
-    case OP_ONCE:
+    BEGIN_OPCODE(ONCE):
       {
       frame->prev = frame->ecode;
       frame->saved_eptr = frame->eptr;
@@ -475,15 +505,14 @@ for (;;)
       do
         {
         RMATCH(9, frame->ecode + 1 + LINK_SIZE, frame->eptrb, match_isgroup);
-        if (rrc == MATCH_MATCH) break;
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) break;
         frame->ecode += GET(frame->ecode,1);
         }
       while (*frame->ecode == OP_ALT);
 
       /* If hit the end of the group (which could be repeated), fail */
 
-      if (*frame->ecode != OP_ONCE && *frame->ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
+      if (*frame->ecode != OP_ONCE && *frame->ecode != OP_ALT) RRETURN;
 
       /* Continue as from after the assertion, updating the offsets high water
       mark, since extracts may have been taken. */
@@ -502,7 +531,7 @@ for (;;)
       if (*frame->ecode == OP_KET || frame->eptr == frame->saved_eptr)
         {
         frame->ecode += 1+LINK_SIZE;
-        break;
+        NEXT_OPCODE;
         }
 
       /* The repeating kets try the rest of the pattern or restart from the
@@ -513,26 +542,26 @@ for (;;)
       if (*frame->ecode == OP_KETRMIN)
         {
         RMATCH(10, frame->ecode + 1 + LINK_SIZE, frame->eptrb, 0);
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) RRETURN;
         RMATCH(11, frame->prev, frame->eptrb, match_isgroup);
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) RRETURN;
         }
       else  /* OP_KETRMAX */
         {
         RMATCH(12, frame->prev, frame->eptrb, match_isgroup);
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) RRETURN;
         RMATCH(13, frame->ecode + 1+LINK_SIZE, frame->eptrb, 0);
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) RRETURN;
         }
       }
-    RRETURN(MATCH_NOMATCH);
+    RRETURN;
 
     /* An alternation is the end of a branch; scan along to find the end of the
     bracketed group and go to there. */
 
-    case OP_ALT:
+    BEGIN_OPCODE(ALT):
     do frame->ecode += GET(frame->ecode,1); while (*frame->ecode == OP_ALT);
-    break;
+    NEXT_OPCODE;
 
     /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
     that it may occur zero times. It may repeat infinitely, or not at all -
@@ -540,34 +569,34 @@ for (;;)
     repeat limits are compiled as a number of copies, with the optional ones
     preceded by BRAZERO or BRAMINZERO. */
 
-    case OP_BRAZERO:
+    BEGIN_OPCODE(BRAZERO):
       {
       frame->next = frame->ecode+1;
       RMATCH(14, frame->next, frame->eptrb, match_isgroup);
-      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      if (is_match) RRETURN;
       do frame->next += GET(frame->next,1); while (*frame->next == OP_ALT);
       frame->ecode = frame->next + 1+LINK_SIZE;
       }
-    break;
+    NEXT_OPCODE;
 
-    case OP_BRAMINZERO:
+    BEGIN_OPCODE(BRAMINZERO):
       {
       frame->next = frame->ecode+1;
       do frame->next += GET(frame->next,1); while (*frame->next == OP_ALT);
       RMATCH(15, frame->next + 1+LINK_SIZE, frame->eptrb, match_isgroup);
-      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      if (is_match) RRETURN;
       frame->ecode++;
       }
-    break;
+    NEXT_OPCODE;
 
     /* End of a group, repeated or non-repeating. If we are at the end of
     an assertion "group", stop matching and return MATCH_MATCH, but record the
     current high water mark for use by positive assertions. Do this also
     for the "once" (not-backup up) groups. */
 
-    case OP_KET:
-    case OP_KETRMIN:
-    case OP_KETRMAX:
+    BEGIN_OPCODE(KET):
+    BEGIN_OPCODE(KETRMIN):
+    BEGIN_OPCODE(KETRMAX):
       {
       frame->prev = frame->ecode - GET(frame->ecode, 1);
       frame->saved_eptr = frame->eptrb->epb_saved_eptr;
@@ -580,7 +609,8 @@ for (;;)
         {
         md->end_match_ptr = frame->eptr;      /* For ONCE */
         md->end_offset_top = frame->offset_top;
-        RRETURN(MATCH_MATCH);
+        is_match = TRUE;
+        RRETURN;
         }
 
       /* In all other cases except a conditional group we have to check the
@@ -627,7 +657,7 @@ for (;;)
       if (*frame->ecode == OP_KET || frame->eptr == frame->saved_eptr)
         {
         frame->ecode += 1 + LINK_SIZE;
-        break;
+        NEXT_OPCODE;
         }
 
       /* The repeating kets try the rest of the pattern or restart from the
@@ -636,60 +666,57 @@ for (;;)
       if (*frame->ecode == OP_KETRMIN)
         {
         RMATCH(16, frame->ecode + 1+LINK_SIZE, frame->eptrb, 0);
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) RRETURN;
         RMATCH(17, frame->prev, frame->eptrb, match_isgroup);
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) RRETURN;
         }
       else  /* OP_KETRMAX */
         {
         RMATCH(18, frame->prev, frame->eptrb, match_isgroup);
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) RRETURN;
         RMATCH(19, frame->ecode + 1+LINK_SIZE, frame->eptrb, 0);
-        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (is_match) RRETURN;
         }
       }
-
-    RRETURN(MATCH_NOMATCH);
+    RRETURN;
 
     /* Start of subject unless notbol, or after internal newline if multiline */
 
-    case OP_CIRC:
+    BEGIN_OPCODE(CIRC):
     if (md->multiline)
       {
       if (frame->eptr != md->start_subject && !IS_NEWLINE(frame->eptr[-1]))
-        RRETURN(MATCH_NOMATCH);
+        RRETURN_NO_MATCH;
       frame->ecode++;
-      break;
+      NEXT_OPCODE;
       }
-    if (frame->eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
+    if (frame->eptr != md->start_subject) RRETURN_NO_MATCH;
     frame->ecode++;
-    break;
+    NEXT_OPCODE;
 
     /* Assert before internal newline if multiline, or before a terminating
     newline unless endonly is set, else end of subject unless noteol is set. */
 
-    case OP_DOLL:
+    BEGIN_OPCODE(DOLL):
     if (md->multiline)
       {
       if (frame->eptr < md->end_subject)
-        { if (!IS_NEWLINE(*frame->eptr)) RRETURN(MATCH_NOMATCH); }
+        { if (!IS_NEWLINE(*frame->eptr)) RRETURN_NO_MATCH; }
       frame->ecode++;
-      break;
       }
     else
       {
       if (frame->eptr < md->end_subject - 1 ||
          (frame->eptr == md->end_subject - 1 && !IS_NEWLINE(*frame->eptr)))
-        RRETURN(MATCH_NOMATCH);
+        RRETURN_NO_MATCH;
       frame->ecode++;
-      break;
       }
-    break;
+    NEXT_OPCODE;
 
     /* Word boundary assertions */
 
-    case OP_NOT_WORD_BOUNDARY:
-    case OP_WORD_BOUNDARY:
+    BEGIN_OPCODE(NOT_WORD_BOUNDARY):
+    BEGIN_OPCODE(WORD_BOUNDARY):
       {
       /* Find out if the previous and current characters are "word" characters.
       It takes a bit more work in UTF-8 mode. Characters > 128 are assumed to
@@ -714,85 +741,67 @@ for (;;)
 
       if ((*frame->ecode++ == OP_WORD_BOUNDARY)?
            cur_is_word == prev_is_word : cur_is_word != prev_is_word)
-        RRETURN(MATCH_NOMATCH);
+        RRETURN_NO_MATCH;
       }
-    break;
+    NEXT_OPCODE;
 
     /* Match a single character type; inline for speed */
 
-    case OP_ANY:
+    BEGIN_OPCODE(ANY):
     if (frame->eptr < md->end_subject && IS_NEWLINE(*frame->eptr))
-      RRETURN(MATCH_NOMATCH);
-    if (frame->eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
+      RRETURN_NO_MATCH;
+    if (frame->eptr++ >= md->end_subject) RRETURN_NO_MATCH;
       while (frame->eptr < md->end_subject && ISMIDCHAR(*frame->eptr)) frame->eptr++;
     frame->ecode++;
-    break;
+    NEXT_OPCODE;
 
-    case OP_NOT_DIGIT:
-    if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    BEGIN_OPCODE(NOT_DIGIT):
+    if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
     GETCHARINCTEST(c, frame->eptr);
-    if (
-       c < 128 &&
-       (md->ctypes[c] & ctype_digit) != 0
-       )
-      RRETURN(MATCH_NOMATCH);
+    if (isASCIIDigit(c))
+      RRETURN_NO_MATCH;
     frame->ecode++;
-    break;
+    NEXT_OPCODE;
 
-    case OP_DIGIT:
-    if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    BEGIN_OPCODE(DIGIT):
+    if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
     GETCHARINCTEST(c, frame->eptr);
-    if (
-       c >= 128 ||
-       (md->ctypes[c] & ctype_digit) == 0
-       )
-      RRETURN(MATCH_NOMATCH);
+    if (!isASCIIDigit(c))
+      RRETURN_NO_MATCH;
     frame->ecode++;
-    break;
+    NEXT_OPCODE;
 
-    case OP_NOT_WHITESPACE:
-    if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    BEGIN_OPCODE(NOT_WHITESPACE):
+    if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
     GETCHARINCTEST(c, frame->eptr);
-    if (
-       c < 128 &&
-       (md->ctypes[c] & ctype_space) != 0
-       )
-      RRETURN(MATCH_NOMATCH);
+    if (c < 128 && (md->ctypes[c] & ctype_space) != 0)
+      RRETURN_NO_MATCH;
     frame->ecode++;
-    break;
+    NEXT_OPCODE;
 
-    case OP_WHITESPACE:
-    if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    BEGIN_OPCODE(WHITESPACE):
+    if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
     GETCHARINCTEST(c, frame->eptr);
-    if (
-       c >= 128 ||
-       (md->ctypes[c] & ctype_space) == 0
-       )
-      RRETURN(MATCH_NOMATCH);
+    if (c >= 128 || (md->ctypes[c] & ctype_space) == 0)
+      RRETURN_NO_MATCH;
     frame->ecode++;
-    break;
+    NEXT_OPCODE;
 
-    case OP_NOT_WORDCHAR:
-    if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    BEGIN_OPCODE(NOT_WORDCHAR):
+    if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
     GETCHARINCTEST(c, frame->eptr);
-    if (
-       c < 128 &&
-       (md->ctypes[c] & ctype_word) != 0
-       )
-      RRETURN(MATCH_NOMATCH);
+    if (c < 128 && (md->ctypes[c] & ctype_word) != 0)
+      RRETURN_NO_MATCH;
     frame->ecode++;
-    break;
+    NEXT_OPCODE;
 
-    case OP_WORDCHAR:
-    if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    BEGIN_OPCODE(WORDCHAR):
+    if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
     GETCHARINCTEST(c, frame->eptr);
-    if (
-       c >= 128 ||
-       (md->ctypes[c] & ctype_word) == 0
-       )
-      RRETURN(MATCH_NOMATCH);
+    if (c >= 128 || (md->ctypes[c] & ctype_word) == 0)
+      RRETURN_NO_MATCH;
     frame->ecode++;
-    break;
+    NEXT_OPCODE;
 
     /* Match a back reference, possibly repeatedly. Look past the end of the
     item to see if there is repeat information following. The code is similar
@@ -802,7 +811,7 @@ for (;;)
     it as matched, any number of times (otherwise there could be infinite
     loops). */
 
-    case OP_REF:
+    BEGIN_OPCODE(REF):
       {
       frame->offset = GET2(frame->ecode, 1) << 1;               /* Doubled ref number */
       frame->ecode += 3;                                 /* Advance past item */
@@ -843,28 +852,30 @@ for (;;)
         break;
 
         default:               /* No repeat follows */
-        if (!match_ref(frame->offset, frame->eptr, frame->length, md)) RRETURN(MATCH_NOMATCH);
+        if (!match_ref(frame->offset, frame->eptr, frame->length, md)) RRETURN_NO_MATCH;
         frame->eptr += frame->length;
-        continue;              /* With the main loop */
+        NEXT_OPCODE;
         }
 
       /* If the length of the reference is zero, just continue with the
       main loop. */
 
-      if (frame->length == 0) continue;
+      if (frame->length == 0)
+        NEXT_OPCODE;
 
       /* First, ensure the minimum number of matches are present. */
 
       for (i = 1; i <= min; i++)
         {
-        if (!match_ref(frame->offset, frame->eptr, frame->length, md)) RRETURN(MATCH_NOMATCH);
+        if (!match_ref(frame->offset, frame->eptr, frame->length, md)) RRETURN_NO_MATCH;
         frame->eptr += frame->length;
         }
 
       /* If min = max, continue at the same level without recursion.
       They are not both allowed to be zero. */
 
-      if (min == frame->max) continue;
+      if (min == frame->max)
+        NEXT_OPCODE;
 
       /* If minimizing, keep trying and advancing the pointer */
 
@@ -873,9 +884,9 @@ for (;;)
         for (frame->fi = min;; frame->fi++)
           {
           RMATCH(20, frame->ecode, frame->eptrb, 0);
-          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (is_match) RRETURN;
           if (frame->fi >= frame->max || !match_ref(frame->offset, frame->eptr, frame->length, md))
-            RRETURN(MATCH_NOMATCH);
+            RRETURN;
           frame->eptr += frame->length;
           }
         /* Control never gets here */
@@ -894,16 +905,14 @@ for (;;)
         while (frame->eptr >= frame->pp)
           {
           RMATCH(21, frame->ecode, frame->eptrb, 0);
-          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (is_match) RRETURN;
           frame->eptr -= frame->length;
           }
-        RRETURN(MATCH_NOMATCH);
+        RRETURN_NO_MATCH;
         }
       }
     /* Control never gets here */
 
-
-
     /* Match a bit-mapped character class, possibly repeatedly. This op code is
     used when all the characters in the class have values in the range 0-255,
     and either the matching is caseful, or the characters are in the range
@@ -915,8 +924,8 @@ for (;;)
     following. Then obey similar code to character type repeats - written out
     again for speed. */
 
-    case OP_NCLASS:
-    case OP_CLASS:
+    BEGIN_OPCODE(NCLASS):
+    BEGIN_OPCODE(CLASS):
       {
       frame->data = frame->ecode + 1;                /* Save for matching */
       frame->ecode += 33;                     /* Advance past the item */
@@ -955,15 +964,15 @@ for (;;)
         {
         for (i = 1; i <= min; i++)
           {
-          if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
           GETCHARINC(c, frame->eptr);
           if (c > 255)
             {
-            if (frame->data[-1] == OP_CLASS) RRETURN(MATCH_NOMATCH);
+            if (frame->data[-1] == OP_CLASS) RRETURN_NO_MATCH;
             }
           else
             {
-            if ((frame->data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+            if ((frame->data[c/8] & (1 << (c&7))) == 0) RRETURN_NO_MATCH;
             }
           }
         }
@@ -971,40 +980,37 @@ for (;;)
       /* If max == min we can continue with the main loop without the
       need to recurse. */
 
-      if (min == frame->max) continue;
+      if (min == frame->max)
+        NEXT_OPCODE;      
 
       /* If minimizing, keep testing the rest of the expression and advancing
       the pointer while it matches the class. */
-
       if (minimize)
         {
           {
           for (frame->fi = min;; frame->fi++)
             {
             RMATCH(22, frame->ecode, frame->eptrb, 0);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-            if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+            if (is_match) RRETURN;
+            if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN;
             GETCHARINC(c, frame->eptr);
             if (c > 255)
               {
-              if (frame->data[-1] == OP_CLASS) RRETURN(MATCH_NOMATCH);
+              if (frame->data[-1] == OP_CLASS) RRETURN;
               }
             else
               {
-              if ((frame->data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+              if ((frame->data[c/8] & (1 << (c&7))) == 0) RRETURN;
               }
             }
           }
         /* Control never gets here */
         }
-
       /* If maximizing, find the longest possible run, then work backwards. */
-
       else
         {
         frame->pp = frame->eptr;
 
-          {
           for (i = min; i < frame->max; i++)
             {
             int len = 1;
@@ -1023,21 +1029,20 @@ for (;;)
           for (;;)
             {
             RMATCH(24, frame->ecode, frame->eptrb, 0);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (is_match) RRETURN;
             if (frame->eptr-- == frame->pp) break;        /* Stop if tried at original pos */
             BACKCHAR(frame->eptr);
             }
-          }
-        RRETURN(MATCH_NOMATCH);
+
+        RRETURN;
         }
       }
     /* Control never gets here */
 
-
     /* Match an extended character class. This opcode is encountered only
     in UTF-8 mode, because that's the only time it is compiled. */
 
-    case OP_XCLASS:
+    BEGIN_OPCODE(XCLASS):
       {
       frame->data = frame->ecode + 1 + LINK_SIZE;                /* Save for matching */
       frame->ecode += GET(frame->ecode, 1);                      /* Advance past the item */
@@ -1068,22 +1073,22 @@ for (;;)
 
         default:               /* No repeat follows */
         min = frame->max = 1;
-        break;
         }
 
       /* First, ensure the minimum number of matches are present. */
 
       for (i = 1; i <= min; i++)
         {
-        if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+        if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
         GETCHARINC(c, frame->eptr);
-        if (!_pcre_xclass(c, frame->data)) RRETURN(MATCH_NOMATCH);
+        if (!_pcre_xclass(c, frame->data)) RRETURN_NO_MATCH;
         }
 
       /* If max == min we can continue with the main loop without the
       need to recurse. */
 
-      if (min == frame->max) continue;
+      if (min == frame->max)
+        NEXT_OPCODE;
 
       /* If minimizing, keep testing the rest of the expression and advancing
       the pointer while it matches the class. */
@@ -1093,10 +1098,10 @@ for (;;)
         for (frame->fi = min;; frame->fi++)
           {
           RMATCH(26, frame->ecode, frame->eptrb, 0);
-          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-          if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          if (is_match) RRETURN;
+          if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN;
           GETCHARINC(c, frame->eptr);
-          if (!_pcre_xclass(c, frame->data)) RRETURN(MATCH_NOMATCH);
+          if (!_pcre_xclass(c, frame->data)) RRETURN;
           }
         /* Control never gets here */
         }
@@ -1117,11 +1122,11 @@ for (;;)
         for(;;)
           {
           RMATCH(27, frame->ecode, frame->eptrb, 0);
-          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (is_match) RRETURN;
           if (frame->eptr-- == frame->pp) break;        /* Stop if tried at original pos */
           BACKCHAR(frame->eptr)
           }
-        RRETURN(MATCH_NOMATCH);
+        RRETURN;
         }
 
       /* Control never gets here */
@@ -1129,7 +1134,7 @@ for (;;)
 
     /* Match a single character, casefully */
 
-    case OP_CHAR:
+    BEGIN_OPCODE(CHAR):
       {
       frame->length = 1;
       frame->ecode++;
@@ -1140,50 +1145,36 @@ for (;;)
         switch (md->end_subject - frame->eptr)
         {
           case 0:
-            RRETURN(MATCH_NOMATCH);
+            RRETURN_NO_MATCH;
           case 1:
             dc = *frame->eptr++;
             if (IS_LEADING_SURROGATE(dc))
-              RRETURN(MATCH_NOMATCH);
+              RRETURN_NO_MATCH;
             break;
           default:
             GETCHARINC(dc, frame->eptr);
         }
-        if (frame->fc != dc) RRETURN(MATCH_NOMATCH);
-     }  
+        if (frame->fc != dc) RRETURN_NO_MATCH;
+      }
       }
-    break;
+    NEXT_OPCODE;
 
     /* Match a single character, caselessly */
 
-    case OP_CHARNC:
+    BEGIN_OPCODE(CHARNC):
       {
       frame->length = 1;
       frame->ecode++;
       GETUTF8CHARLEN(frame->fc, frame->ecode, frame->length);
 
-      if (md->end_subject - frame->eptr == 0) RRETURN(MATCH_NOMATCH);
-
-      /* If the pattern character's value is < 128, we have only one byte, and
-      can use the fast lookup table. */
-
-      if (frame->fc < 128)
-        {
-        int dc;
-        frame->ecode++;
-        dc = *frame->eptr++;
-        if (dc >= 128 || md->lcc[frame->fc] != md->lcc[dc]) RRETURN(MATCH_NOMATCH);
-        }
-
-      /* Otherwise we must pick up the subject character */
+      if (md->end_subject - frame->eptr == 0) RRETURN_NO_MATCH;
 
-      else
         {
         int dc;
         if (md->end_subject - frame->eptr == 1) {
           dc = *frame->eptr++;
           if (IS_LEADING_SURROGATE(dc))
-            RRETURN(MATCH_NOMATCH);
+            RRETURN_NO_MATCH;
         } else
         GETCHARINC(dc, frame->eptr);
         frame->ecode += frame->length;
@@ -1194,56 +1185,56 @@ for (;;)
         if (frame->fc != dc)
           {
           if (dc != _pcre_ucp_othercase(frame->fc))
-            RRETURN(MATCH_NOMATCH);
+            RRETURN_NO_MATCH;
           }
         }
       }
-    break;
+    NEXT_OPCODE;
 
     /* Match a single ASCII character. */
 
-    case OP_ASCII_CHAR:
+    BEGIN_OPCODE(ASCII_CHAR):
     if (md->end_subject == frame->eptr)
-      RRETURN(MATCH_NOMATCH);
+      RRETURN_NO_MATCH;
     if (*frame->eptr != frame->ecode[1])
-      RRETURN(MATCH_NOMATCH);
+      RRETURN_NO_MATCH;
     ++frame->eptr;
     frame->ecode += 2;
-    break;
+    NEXT_OPCODE;
 
     /* Match one of two cases of an ASCII character. */
 
-    case OP_ASCII_LETTER_NC:
+    BEGIN_OPCODE(ASCII_LETTER_NC):
     if (md->end_subject == frame->eptr)
-      RRETURN(MATCH_NOMATCH);
+      RRETURN_NO_MATCH;
     if ((*frame->eptr | 0x20) != frame->ecode[1])
-      RRETURN(MATCH_NOMATCH);
+      RRETURN_NO_MATCH;
     ++frame->eptr;
     frame->ecode += 2;
-    break;
+    NEXT_OPCODE;
 
     /* Match a single character repeatedly; different opcodes share code. */
 
-    case OP_EXACT:
+    BEGIN_OPCODE(EXACT):
     min = frame->max = GET2(frame->ecode, 1);
     minimize = FALSE;
     frame->ecode += 3;
     goto REPEATCHAR;
 
-    case OP_UPTO:
-    case OP_MINUPTO:
+    BEGIN_OPCODE(UPTO):
+    BEGIN_OPCODE(MINUPTO):
     min = 0;
     frame->max = GET2(frame->ecode, 1);
     minimize = *frame->ecode == OP_MINUPTO;
     frame->ecode += 3;
     goto REPEATCHAR;
 
-    case OP_STAR:
-    case OP_MINSTAR:
-    case OP_PLUS:
-    case OP_MINPLUS:
-    case OP_QUERY:
-    case OP_MINQUERY:
+    BEGIN_OPCODE(STAR):
+    BEGIN_OPCODE(MINSTAR):
+    BEGIN_OPCODE(PLUS):
+    BEGIN_OPCODE(MINPLUS):
+    BEGIN_OPCODE(QUERY):
+    BEGIN_OPCODE(MINQUERY):
     c = *frame->ecode++ - OP_STAR;
     minimize = (c & 1) != 0;
     min = rep_min[c];                 /* Pick up values from tables; */
@@ -1259,7 +1250,7 @@ for (;;)
       frame->length = 1;
       GETUTF8CHARLEN(frame->fc, frame->ecode, frame->length);
       {
-      if (min * (frame->fc > 0xFFFF ? 2 : 1) > md->end_subject - frame->eptr) RRETURN(MATCH_NOMATCH);
+      if (min * (frame->fc > 0xFFFF ? 2 : 1) > md->end_subject - frame->eptr) RRETURN_NO_MATCH;
       frame->ecode += frame->length;
 
       if (frame->fc <= 0xFFFF)
@@ -1268,11 +1259,12 @@ for (;;)
 
         for (i = 1; i <= min; i++)
           {
-          if (*frame->eptr != frame->fc && *frame->eptr != othercase) RRETURN(MATCH_NOMATCH);
+          if (*frame->eptr != frame->fc && *frame->eptr != othercase) RRETURN_NO_MATCH;
           ++frame->eptr;
           }
 
-        if (min == frame->max) continue;
+        if (min == frame->max)
+          NEXT_OPCODE;
 
         if (minimize)
           {
@@ -1280,9 +1272,9 @@ for (;;)
           for (frame->fi = min;; frame->fi++)
             {
             RMATCH(28, frame->ecode, frame->eptrb, 0);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-            if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
-            if (*frame->eptr != frame->fc && *frame->eptr != frame->repeat_othercase) RRETURN(MATCH_NOMATCH);
+            if (is_match) RRETURN;
+            if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN;
+            if (*frame->eptr != frame->fc && *frame->eptr != frame->repeat_othercase) RRETURN;
             ++frame->eptr;
             }
           /* Control never gets here */
@@ -1299,10 +1291,10 @@ for (;;)
           while (frame->eptr >= frame->pp)
            {
            RMATCH(29, frame->ecode, frame->eptrb, 0);
-           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+           if (is_match) RRETURN;
            --frame->eptr;
            }
-          RRETURN(MATCH_NOMATCH);
+          RRETURN_NO_MATCH;
           }
         /* Control never gets here */
         }
@@ -1314,11 +1306,12 @@ for (;;)
           {
           int nc;
           GETCHAR(nc, frame->eptr);
-          if (nc != frame->fc) RRETURN(MATCH_NOMATCH);
+          if (nc != frame->fc) RRETURN_NO_MATCH;
           frame->eptr += 2;
           }
 
-        if (min == frame->max) continue;
+        if (min == frame->max)
+          NEXT_OPCODE;
 
         if (minimize)
           {
@@ -1326,10 +1319,10 @@ for (;;)
             {
             int nc;
             RMATCH(30, frame->ecode, frame->eptrb, 0);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-            if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+            if (is_match) RRETURN;
+            if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN;
             GETCHAR(nc, frame->eptr);
-            if (*frame->eptr != frame->fc) RRETURN(MATCH_NOMATCH);
+            if (*frame->eptr != frame->fc) RRETURN;
             frame->eptr += 2;
             }
           /* Control never gets here */
@@ -1348,10 +1341,10 @@ for (;;)
           while (frame->eptr >= frame->pp)
            {
            RMATCH(31, frame->ecode, frame->eptrb, 0);
-           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+           if (is_match) RRETURN;
            frame->eptr -= 2;
            }
-          RRETURN(MATCH_NOMATCH);
+          RRETURN_NO_MATCH;
           }
           /* Control never gets here */
         }
@@ -1361,21 +1354,21 @@ for (;;)
     /* Match a negated single one-byte character. The character we are
     checking can be multibyte. */
 
-    case OP_NOT:
-    if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    BEGIN_OPCODE(NOT):
+    if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
     frame->ecode++;
     GETCHARINCTEST(c, frame->eptr);
     if (md->caseless)
       {
       if (c < 128)
         c = md->lcc[c];
-      if (md->lcc[*frame->ecode++] == c) RRETURN(MATCH_NOMATCH);
+      if (md->lcc[*frame->ecode++] == c) RRETURN_NO_MATCH;
       }
     else
       {
-      if (*frame->ecode++ == c) RRETURN(MATCH_NOMATCH);
+      if (*frame->ecode++ == c) RRETURN_NO_MATCH;
       }
-    break;
+    NEXT_OPCODE;
 
     /* Match a negated single one-byte character repeatedly. This is almost a
     repeat of the code for a repeated single character, but I haven't found a
@@ -1384,26 +1377,26 @@ for (;;)
     very much to the time taken, but character matching *is* what this is all
     about... */
 
-    case OP_NOTEXACT:
+    BEGIN_OPCODE(NOTEXACT):
     min = frame->max = GET2(frame->ecode, 1);
     minimize = FALSE;
     frame->ecode += 3;
     goto REPEATNOTCHAR;
 
-    case OP_NOTUPTO:
-    case OP_NOTMINUPTO:
+    BEGIN_OPCODE(NOTUPTO):
+    BEGIN_OPCODE(NOTMINUPTO):
     min = 0;
     frame->max = GET2(frame->ecode, 1);
     minimize = *frame->ecode == OP_NOTMINUPTO;
     frame->ecode += 3;
     goto REPEATNOTCHAR;
 
-    case OP_NOTSTAR:
-    case OP_NOTMINSTAR:
-    case OP_NOTPLUS:
-    case OP_NOTMINPLUS:
-    case OP_NOTQUERY:
-    case OP_NOTMINQUERY:
+    BEGIN_OPCODE(NOTSTAR):
+    BEGIN_OPCODE(NOTMINSTAR):
+    BEGIN_OPCODE(NOTPLUS):
+    BEGIN_OPCODE(NOTMINPLUS):
+    BEGIN_OPCODE(NOTQUERY):
+    BEGIN_OPCODE(NOTMINQUERY):
     c = *frame->ecode++ - OP_NOTSTAR;
     minimize = (c & 1) != 0;
     min = rep_min[c];                 /* Pick up values from tables; */
@@ -1415,7 +1408,7 @@ for (;;)
     subject. */
 
     REPEATNOTCHAR:
-    if (min > md->end_subject - frame->eptr) RRETURN(MATCH_NOMATCH);
+    if (min > md->end_subject - frame->eptr) RRETURN_NO_MATCH;
     frame->fc = *frame->ecode++;
 
     /* The code is duplicated for the caseless and caseful cases, for speed,
@@ -1430,7 +1423,8 @@ for (;;)
 
     if (md->caseless)
       {
-      frame->fc = md->lcc[frame->fc];
+      if (frame->fc < 128)
+        frame->fc = md->lcc[frame->fc];
 
         {
         register int d;
@@ -1438,11 +1432,12 @@ for (;;)
           {
           GETCHARINC(d, frame->eptr);
           if (d < 128) d = md->lcc[d];
-          if (frame->fc == d) RRETURN(MATCH_NOMATCH);
+          if (frame->fc == d) RRETURN_NO_MATCH;
           }
         }
 
-      if (min == frame->max) continue;
+      if (min == frame->max)
+        NEXT_OPCODE;      
 
       if (minimize)
         {
@@ -1451,11 +1446,11 @@ for (;;)
           for (frame->fi = min;; frame->fi++)
             {
             RMATCH(38, frame->ecode, frame->eptrb, 0);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (is_match) RRETURN;
             GETCHARINC(d, frame->eptr);
             if (d < 128) d = md->lcc[d];
             if (frame->fi >= frame->max || frame->eptr >= md->end_subject || frame->fc == d)
-              RRETURN(MATCH_NOMATCH);
+              RRETURN;
             }
           }
         /* Control never gets here */
@@ -1481,13 +1476,13 @@ for (;;)
           for(;;)
             {
             RMATCH(40, frame->ecode, frame->eptrb, 0);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (is_match) RRETURN;
             if (frame->eptr-- == frame->pp) break;        /* Stop if tried at original pos */
             BACKCHAR(frame->eptr);
             }
           }
 
-        RRETURN(MATCH_NOMATCH);
+        RRETURN;
         }
       /* Control never gets here */
       }
@@ -1501,11 +1496,12 @@ for (;;)
         for (i = 1; i <= min; i++)
           {
           GETCHARINC(d, frame->eptr);
-          if (frame->fc == d) RRETURN(MATCH_NOMATCH);
+          if (frame->fc == d) RRETURN_NO_MATCH;
           }
         }
 
-      if (min == frame->max) continue;
+      if (min == frame->max)
+        NEXT_OPCODE;
 
       if (minimize)
         {
@@ -1514,10 +1510,10 @@ for (;;)
           for (frame->fi = min;; frame->fi++)
             {
             RMATCH(42, frame->ecode, frame->eptrb, 0);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (is_match) RRETURN;
             GETCHARINC(d, frame->eptr);
             if (frame->fi >= frame->max || frame->eptr >= md->end_subject || frame->fc == d)
-              RRETURN(MATCH_NOMATCH);
+              RRETURN;
             }
           }
         /* Control never gets here */
@@ -1542,13 +1538,13 @@ for (;;)
           for(;;)
             {
             RMATCH(44, frame->ecode, frame->eptrb, 0);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (is_match) RRETURN;
             if (frame->eptr-- == frame->pp) break;        /* Stop if tried at original pos */
             BACKCHAR(frame->eptr);
             }
           }
 
-        RRETURN(MATCH_NOMATCH);
+        RRETURN;
         }
       }
     /* Control never gets here */
@@ -1557,26 +1553,26 @@ for (;;)
     share code. This is very similar to the code for single characters, but we
     repeat it in the interests of efficiency. */
 
-    case OP_TYPEEXACT:
+    BEGIN_OPCODE(TYPEEXACT):
     min = frame->max = GET2(frame->ecode, 1);
     minimize = TRUE;
     frame->ecode += 3;
     goto REPEATTYPE;
 
-    case OP_TYPEUPTO:
-    case OP_TYPEMINUPTO:
+    BEGIN_OPCODE(TYPEUPTO):
+    BEGIN_OPCODE(TYPEMINUPTO):
     min = 0;
     frame->max = GET2(frame->ecode, 1);
     minimize = *frame->ecode == OP_TYPEMINUPTO;
     frame->ecode += 3;
     goto REPEATTYPE;
 
-    case OP_TYPESTAR:
-    case OP_TYPEMINSTAR:
-    case OP_TYPEPLUS:
-    case OP_TYPEMINPLUS:
-    case OP_TYPEQUERY:
-    case OP_TYPEMINQUERY:
+    BEGIN_OPCODE(TYPESTAR):
+    BEGIN_OPCODE(TYPEMINSTAR):
+    BEGIN_OPCODE(TYPEPLUS):
+    BEGIN_OPCODE(TYPEMINPLUS):
+    BEGIN_OPCODE(TYPEQUERY):
+    BEGIN_OPCODE(TYPEMINQUERY):
     c = *frame->ecode++ - OP_TYPESTAR;
     minimize = (c & 1) != 0;
     min = rep_min[c];                 /* Pick up values from tables; */
@@ -1598,7 +1594,7 @@ for (;;)
     is tidier. Also separate the UCP code, which can be the same for both UTF-8
     and single-bytes. */
 
-    if (min > md->end_subject - frame->eptr) RRETURN(MATCH_NOMATCH);
+    if (min > md->end_subject - frame->eptr) RRETURN_NO_MATCH;
     if (min > 0)
       {
       switch(frame->ctype)
@@ -1607,7 +1603,7 @@ for (;;)
         for (i = 1; i <= min; i++)
           {
           if (frame->eptr >= md->end_subject || IS_NEWLINE(*frame->eptr))
-            RRETURN(MATCH_NOMATCH);
+            RRETURN_NO_MATCH;
           ++frame->eptr;
           while (frame->eptr < md->end_subject && ISMIDCHAR(*frame->eptr)) frame->eptr++;
           }
@@ -1616,19 +1612,18 @@ for (;;)
         case OP_NOT_DIGIT:
         for (i = 1; i <= min; i++)
           {
-          if (frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          if (frame->eptr >= md->end_subject) RRETURN_NO_MATCH;
           GETCHARINC(c, frame->eptr);
-          if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
-            RRETURN(MATCH_NOMATCH);
+          if (isASCIIDigit(c))
+            RRETURN_NO_MATCH;
           }
         break;
 
         case OP_DIGIT:
         for (i = 1; i <= min; i++)
           {
-          if (frame->eptr >= md->end_subject ||
-             *frame->eptr >= 128 || (md->ctypes[*frame->eptr++] & ctype_digit) == 0)
-            RRETURN(MATCH_NOMATCH);
+          if (frame->eptr >= md->end_subject || !isASCIIDigit(*frame->eptr++))
+            RRETURN_NO_MATCH;
           /* No need to skip more bytes - we know it's a 1-byte character */
           }
         break;
@@ -1638,7 +1633,7 @@ for (;;)
           {
           if (frame->eptr >= md->end_subject ||
              (*frame->eptr < 128 && (md->ctypes[*frame->eptr] & ctype_space) != 0))
-            RRETURN(MATCH_NOMATCH);
+            RRETURN_NO_MATCH;
           while (++frame->eptr < md->end_subject && ISMIDCHAR(*frame->eptr));
           }
         break;
@@ -1648,7 +1643,7 @@ for (;;)
           {
           if (frame->eptr >= md->end_subject ||
              *frame->eptr >= 128 || (md->ctypes[*frame->eptr++] & ctype_space) == 0)
-            RRETURN(MATCH_NOMATCH);
+            RRETURN_NO_MATCH;
           /* No need to skip more bytes - we know it's a 1-byte character */
           }
         break;
@@ -1658,7 +1653,7 @@ for (;;)
           {
           if (frame->eptr >= md->end_subject ||
              (*frame->eptr < 128 && (md->ctypes[*frame->eptr] & ctype_word) != 0))
-            RRETURN(MATCH_NOMATCH);
+            RRETURN_NO_MATCH;
           while (++frame->eptr < md->end_subject && ISMIDCHAR(*frame->eptr));
           }
         break;
@@ -1668,19 +1663,21 @@ for (;;)
           {
           if (frame->eptr >= md->end_subject ||
              *frame->eptr >= 128 || (md->ctypes[*frame->eptr++] & ctype_word) == 0)
-            RRETURN(MATCH_NOMATCH);
+            RRETURN_NO_MATCH;
           /* No need to skip more bytes - we know it's a 1-byte character */
           }
         break;
 
         default:
-        RRETURN(JS_REGEXP_ERROR_INTERNAL);
+        ASSERT_NOT_REACHED();
+        RRETURN_ERROR(JSRegExpErrorInternal);
         }  /* End switch(frame->ctype) */
       }
 
     /* If min = max, continue at the same level without recursing */
 
-    if (min == frame->max) continue;
+    if (min == frame->max)
+      NEXT_OPCODE;    
 
     /* If minimizing, we have to test the rest of the pattern before each
     subsequent match. */
@@ -1691,48 +1688,49 @@ for (;;)
         for (frame->fi = min;; frame->fi++)
           {
           RMATCH(48, frame->ecode, frame->eptrb, 0);
-          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-          if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          if (is_match) RRETURN;
+          if (frame->fi >= frame->max || frame->eptr >= md->end_subject) RRETURN;
 
           GETCHARINC(c, frame->eptr);
           switch(frame->ctype)
             {
             case OP_ANY:
-            if (IS_NEWLINE(c)) RRETURN(MATCH_NOMATCH);
+            if (IS_NEWLINE(c)) RRETURN;
             break;
 
             case OP_NOT_DIGIT:
-            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
-              RRETURN(MATCH_NOMATCH);
+            if (isASCIIDigit(c))
+              RRETURN;
             break;
 
             case OP_DIGIT:
-            if (c >= 128 || (md->ctypes[c] & ctype_digit) == 0)
-              RRETURN(MATCH_NOMATCH);
+            if (!isASCIIDigit(c))
+              RRETURN;
             break;
 
             case OP_NOT_WHITESPACE:
             if (c < 128 && (md->ctypes[c] & ctype_space) != 0)
-              RRETURN(MATCH_NOMATCH);
+              RRETURN;
             break;
 
             case OP_WHITESPACE:
             if  (c >= 128 || (md->ctypes[c] & ctype_space) == 0)
-              RRETURN(MATCH_NOMATCH);
+              RRETURN;
             break;
 
             case OP_NOT_WORDCHAR:
             if (c < 128 && (md->ctypes[c] & ctype_word) != 0)
-              RRETURN(MATCH_NOMATCH);
+              RRETURN;
             break;
 
             case OP_WORDCHAR:
             if (c >= 128 || (md->ctypes[c] & ctype_word) == 0)
-              RRETURN(MATCH_NOMATCH);
+              RRETURN;
             break;
 
             default:
-            RRETURN(JS_REGEXP_ERROR_INTERNAL);
+            ASSERT_NOT_REACHED();
+            RRETURN_ERROR(JSRegExpErrorInternal);
             }
           }
         }
@@ -1746,7 +1744,6 @@ for (;;)
       {
       frame->pp = frame->eptr;  /* Remember where we started */
 
-        {
         switch(frame->ctype)
           {
           case OP_ANY:
@@ -1788,7 +1785,7 @@ for (;;)
             int len = 1;
             if (frame->eptr >= md->end_subject) break;
             GETCHARLEN(c, frame->eptr, len);
-            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0) break;
+            if (isASCIIDigit(c)) break;
             frame->eptr+= len;
             }
           break;
@@ -1799,7 +1796,7 @@ for (;;)
             int len = 1;
             if (frame->eptr >= md->end_subject) break;
             GETCHARLEN(c, frame->eptr, len);
-            if (c >= 128 ||(md->ctypes[c] & ctype_digit) == 0) break;
+            if (!isASCIIDigit(c)) break;
             frame->eptr+= len;
             }
           break;
@@ -1849,7 +1846,8 @@ for (;;)
           break;
 
           default:
-          RRETURN(JS_REGEXP_ERROR_INTERNAL);
+          ASSERT_NOT_REACHED();
+          RRETURN_ERROR(JSRegExpErrorInternal);
           }
 
         /* frame->eptr is now past the end of the maximum run */
@@ -1857,19 +1855,34 @@ for (;;)
         for(;;)
           {
           RMATCH(52, frame->ecode, frame->eptrb, 0);
-          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (is_match) RRETURN;
           if (frame->eptr-- == frame->pp) break;        /* Stop if tried at original pos */
           BACKCHAR(frame->eptr);
           }
-        }
 
       /* Get here if we can't make it match with any permitted repetitions */
 
-      RRETURN(MATCH_NOMATCH);
+      RRETURN;
       }
     /* Control never gets here */
 
+    BEGIN_OPCODE(BRANUMBER):
+    BEGIN_OPCODE(CRMINPLUS):
+    BEGIN_OPCODE(CRMINQUERY):
+    BEGIN_OPCODE(CRMINRANGE):
+    BEGIN_OPCODE(CRMINSTAR):
+    BEGIN_OPCODE(CRPLUS):
+    BEGIN_OPCODE(CRQUERY):
+    BEGIN_OPCODE(CRRANGE):
+    BEGIN_OPCODE(CRSTAR):
+      ASSERT_NOT_REACHED();
+      RRETURN_ERROR(JSRegExpErrorInternal);
+
+#ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP
+    CAPTURING_BRACKET:
+#else
     default:
+#endif
       /* Opening capturing bracket. If there is space in the offset vector, save
       the current subject position in the working slot at the top of the vector. We
       mustn't change the current values of the data slot, because they may be set
@@ -1884,8 +1897,8 @@ for (;;)
       non-capturing bracket. Don't worry about setting the flag for the error case
       here; that is handled in the code for KET. */
 
-      if (*frame->ecode > OP_BRA)
-        {
+      ASSERT(*frame->ecode > OP_BRA);
+
         frame->number = *frame->ecode - OP_BRA;
 
         /* For extended extraction brackets (large number), we have to fish out the
@@ -1904,7 +1917,7 @@ for (;;)
         if (frame->offset < md->offset_max)
           {
           frame->save_offset1 = md->offset_vector[frame->offset];
-          frame->save_offset2 = md->offset_vector[frame->offset+1];
+          frame->save_offset2 = md->offset_vector[frame->offset + 1];
           frame->save_offset3 = md->offset_vector[md->offset_end - frame->number];
 
           DPRINTF(("saving %d %d %d\n", frame->save_offset1, frame->save_offset2, frame->save_offset3));
@@ -1913,7 +1926,7 @@ for (;;)
           do
             {
             RMATCH(1, frame->ecode + 1 + LINK_SIZE, frame->eptrb, match_isgroup);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (is_match) RRETURN;
             frame->ecode += GET(frame->ecode, 1);
             }
           while (*frame->ecode == OP_ALT);
@@ -1921,38 +1934,31 @@ for (;;)
           DPRINTF(("bracket %d failed\n", frame->number));
 
           md->offset_vector[frame->offset] = frame->save_offset1;
-          md->offset_vector[frame->offset+1] = frame->save_offset2;
+          md->offset_vector[frame->offset + 1] = frame->save_offset2;
           md->offset_vector[md->offset_end - frame->number] = frame->save_offset3;
 
-          RRETURN(MATCH_NOMATCH);
+          RRETURN;
           }
 
         /* Insufficient room for saving captured contents */
 
         goto NON_CAPTURING_BRACKET;
-        }
-
-    /* There's been some horrible disaster. Since all codes > OP_BRA are
-    for capturing brackets, and there shouldn't be any gaps between 0 and
-    OP_BRA, arrival here can only mean there is something seriously wrong
-    in the code above or the OP_xxx definitions. */
-
-    DPRINTF(("Unknown opcode %d\n", *frame->ecode));
-    RRETURN(JS_REGEXP_ERROR_INTERNAL);
     }
 
   /* Do not stick any code in here without much thought; it is assumed
   that "continue" in the code above comes out to here to repeat the main
   loop. */
 
-  }             /* End of main loop */
+  } /* End of main loop */
+
 /* Control never reaches here */
 
-#ifndef __GNUC__
+#ifndef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION
 
 RRETURN_SWITCH:
 switch (frame->where)
   {
+  case 0: goto RETURN;
   case 1: goto RRETURN_1;
   case 2: goto RRETURN_2;
   case 6: goto RRETURN_6;
@@ -1987,10 +1993,20 @@ switch (frame->where)
   }
 
 abort();
-return 0;
+RRETURN_ERROR(JSRegExpErrorInternal);
 
 #endif
 
+RETURN:
+    return is_match ? MATCH_MATCH : MATCH_NOMATCH;
+
+RETURN_ERROR:
+    while (!(frame >= stackframes && frame < stackframesend)) {
+        newframe = frame->prevframe;
+        delete frame;
+        frame = newframe;
+    }
+    return i;
 }
 
 
@@ -2020,7 +2036,7 @@ Returns:          > 0 => success; value is the number of elements filled in
 
 int
 jsRegExpExecute(const pcre *argument_re,
-  const JSRegExpChar* subject, int length, int start_offset, int *offsets,
+  const UChar* subject, int length, int start_offset, int *offsets,
   int offsetcount)
 {
 int rc, resetcount, ocount;
@@ -2075,8 +2091,8 @@ ocount = offsetcount - (offsetcount % 3);
 if (re->top_backref > 0 && re->top_backref >= ocount/3)
   {
   ocount = re->top_backref * 3 + 3;
-  match_block.offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));
-  if (match_block.offset_vector == NULL) return JS_REGEXP_ERROR_NOMEMORY;
+  match_block.offset_vector = new int[ocount];
+  if (match_block.offset_vector == NULL) return JSRegExpErrorNoMemory;
   using_temporary_offsets = TRUE;
   DPRINTF(("Got memory to hold back references\n"));
   }
@@ -2110,14 +2126,12 @@ at run time, so we have to test for anchoring. The first char may be unset for
 an unanchored pattern, of course. If there's no first char and the pattern was
 studied, there may be a bitmap of possible first characters. */
 
-  {
   if ((re->options & PCRE_FIRSTSET) != 0)
     {
     first_byte = re->first_byte & 255;
     if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
       first_byte = match_block.lcc[first_byte];
     }
-  }
 
 /* For anchored or unanchored matches, there may be a "last known required
 character" set. */
@@ -2253,7 +2267,6 @@ do
   those back references that we can. In this case there need not be overflow
   if certain parts of the pattern were not used. */
 
-  match_block.start_match = start_match;
   match_block.match_call_count = 0;
 
   rc = match(start_match, start_code, 2, &match_block);
@@ -2294,7 +2307,7 @@ do
       match_block.offset_overflow = TRUE;
 
     DPRINTF(("Freeing temporary memory\n"));
-    (pcre_free)(match_block.offset_vector);
+    delete [] match_block.offset_vector;
     }
 
   rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
@@ -2316,11 +2329,9 @@ while (start_match <= end_subject);
 if (using_temporary_offsets)
   {
   DPRINTF(("Freeing temporary memory\n"));
-  (pcre_free)(match_block.offset_vector);
+  delete [] match_block.offset_vector;
   }
 
   DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
-  return JS_REGEXP_ERROR_NOMATCH;
+  return JSRegExpErrorNoMatch;
 }
-
-/* End of pcre_exec.c */
index 9795a0360fcc950a4cd3b483af0cf00b174043f3..5644d0310a0f961676f0c30b2d7b6443f9ce87f6 100644 (file)
@@ -1,14 +1,12 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
-
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
-           Copyright (c) 2004, 2005 Apple Computer, Inc.
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -53,20 +51,43 @@ functions whose names all begin with "_pcre_". */
 #pragma warning(disable: 4244)
 #endif
 
-#define _pcre_OP_lengths kjs_pcre_OP_lengths
+/* The value of LINK_SIZE determines the number of bytes used to store links as
+offsets within the compiled regex. The default is 2, which allows for compiled
+patterns up to 64K long. This covers the vast majority of cases. However, PCRE
+can also be compiled to use 3 or 4 bytes instead. This allows for longer
+patterns in extreme cases. On systems that support it, "configure" can be used
+to override this default. */
+
+#define LINK_SIZE   2
+
+/* The value of MATCH_LIMIT determines the default number of times the internal
+match() function can be called during a single execution of pcre_exec(). There
+is a runtime interface for setting a different limit. The limit exists in order
+to catch runaway regular expressions that take for ever to determine that they
+do not match. The default is set very large so that it does not accidentally
+catch legitimate cases. On systems that support it, "configure" can be used to
+override this default default. */
+
+#define MATCH_LIMIT 10000000
+
+/* The above limit applies to all calls of match(), whether or not they
+increase the recursion depth. In some environments it is desirable to limit the
+depth of recursive calls of match() more strictly, in order to restrict the
+maximum amount of stack (or heap, if NO_RECURSE is defined) that is used. The
+value of MATCH_LIMIT_RECURSION applies only to recursive calls of match(). To
+have any useful effect, it must be less than the value of MATCH_LIMIT. There is
+a runtime method for setting a different limit. On systems that support it,
+"configure" can be used to override this default default. */
+
+#define MATCH_LIMIT_RECURSION MATCH_LIMIT
+
 #define _pcre_default_tables kjs_pcre_default_tables
 #define _pcre_ord2utf8 kjs_pcre_ord2utf8
-#define _pcre_printint kjs_pcre_printint
-#define _pcre_try_flipped kjs_pcre_try_flipped
-#define _pcre_ucp_findchar kjs_pcre_ucp_findchar
 #define _pcre_utf8_table1 kjs_pcre_utf8_table1
 #define _pcre_utf8_table1_size  kjs_pcre_utf8_table1_size
 #define _pcre_utf8_table2 kjs_pcre_utf8_table2
 #define _pcre_utf8_table3 kjs_pcre_utf8_table3
 #define _pcre_utf8_table4 kjs_pcre_utf8_table4
-#define _pcre_utt kjs_pcre_utt
-#define _pcre_utt_size kjs_pcre_utt_size
-#define _pcre_valid_utf8 kjs_pcre_valid_utf8
 #define _pcre_xclass kjs_pcre_xclass
 
 /* Define DEBUG to get debugging output on stdout. */
@@ -86,11 +107,6 @@ all, it had only been about 10 years then... */
 #define DPRINTF(p) /*nothing*/
 #endif
 
-
-/* Get the definitions provided by running "configure" */
-
-#include "pcre-config.h"
-
 /* Standard C headers plus the external interface definition. The only time
 setjmp and stdarg are used is when NO_RECURSE is set. */
 
@@ -114,19 +130,9 @@ typedef unsigned char uschar;
 
 typedef JSRegExp pcre;
 
-typedef JSRegExpChar pcre_char;
-typedef JSRegExpChar pcre_uchar;
-typedef const JSRegExpChar* USPTR;
-
-/* Temporary fastMalloc/fastFree until we port to C++. */
-#ifdef __cplusplus
-extern "C" {
-#endif
-extern void* (*pcre_malloc)(size_t);
-extern void (*pcre_free)(void*);
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
+typedef UChar pcre_char;
+typedef UChar pcre_uchar;
+typedef const UChar* USPTR;
 
 /* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored
 in big-endian order) by default. These are used, for example, to link from the
@@ -286,31 +292,14 @@ if ((c & 0xc0) == 0xc0) \
 
 #define ISMIDCHAR(c) IS_TRAILING_SURROGATE(c)
 
-/* If the pointer is not at the start of a character, move it back until
-it is. Called only in UTF-8 mode. */
-
 #define BACKCHAR(eptr) while(ISMIDCHAR(*eptr)) eptr--;
 
-
-/* In case there is no definition of offsetof() provided - though any proper
-Standard C system should have one. */
-
-#ifndef offsetof
-#define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field))
-#endif
-
-
-/* Private options flags start at the most significant end of the four bytes,
-but skip the top bit so we can use ints for convenience without getting tangled
-with negative values. The public options defined in pcre.h start at the least
-significant end. Make sure they don't overlap! */
-
 #define PCRE_FIRSTSET      0x40000000  /* first_byte is set */
 #define PCRE_REQCHSET      0x20000000  /* req_byte is set */
 #define PCRE_STARTLINE     0x10000000  /* start after \n for multiline */
 #define PCRE_ANCHORED      0x02000000  /* can't use partial with this regex */
-#define PCRE_CASELESS      JS_REGEXP_CASELESS
-#define PCRE_MULTILINE     JS_REGEXP_MULTILINE
+#define PCRE_CASELESS      0x00000001
+#define PCRE_MULTILINE     0x00000002
 
 /* Negative values for the firstchar and reqchar variables */
 
@@ -364,104 +353,90 @@ OP_EOD must correspond in order to the list of escapes immediately above.
 Note that whenever this list is updated, the two macro definitions that follow
 must also be updated to match. */
 
-enum {
-  OP_END,                   /* End of pattern */
-
-  /* Values corresponding to backslashed metacharacters */
-
-  OP_NOT_WORD_BOUNDARY,     /* \B */
-  OP_WORD_BOUNDARY,         /* \b */
-  OP_NOT_DIGIT,             /* \D */
-  OP_DIGIT,                 /* \d */
-  OP_NOT_WHITESPACE,        /* \S */
-  OP_WHITESPACE,            /* \s */
-  OP_NOT_WORDCHAR,          /* \W */
-  OP_WORDCHAR,              /* \w */
-
-  OP_ANY,                   /* . -- Match any character */
-
-  OP_CIRC,                  /* ^ */
-  OP_DOLL,                  /* $ */
-  OP_CHAR,                  /* Match one character, casefully */
-  OP_CHARNC,                /* Match one character, caselessly */
-  OP_ASCII_CHAR,            /* Match one ASCII (0-127) character. */
-  OP_ASCII_LETTER_NC,       /* Match one ASCII letter, caselessly. */
-  OP_NOT,                   /* Match anything but the following char */
-
-  OP_STAR,                  /* The maximizing and minimizing versions of */
-  OP_MINSTAR,               /* all these opcodes must come in pairs, with */
-  OP_PLUS,                  /* the minimizing one second. */
-  OP_MINPLUS,               /* This first set applies to single characters */
-  OP_QUERY,
-  OP_MINQUERY,
-  OP_UPTO,                  /* From 0 to n matches */
-  OP_MINUPTO,
-  OP_EXACT,                 /* Exactly n matches */
-
-  OP_NOTSTAR,               /* This set applies to "not" single characters */
-  OP_NOTMINSTAR,
-  OP_NOTPLUS,
-  OP_NOTMINPLUS,
-  OP_NOTQUERY,
-  OP_NOTMINQUERY,
-  OP_NOTUPTO,
-  OP_NOTMINUPTO,
-  OP_NOTEXACT,
-
-  OP_TYPESTAR,              /* This set applies to character types such as \d */
-  OP_TYPEMINSTAR,
-  OP_TYPEPLUS,
-  OP_TYPEMINPLUS,
-  OP_TYPEQUERY,
-  OP_TYPEMINQUERY,
-  OP_TYPEUPTO,
-  OP_TYPEMINUPTO,
-  OP_TYPEEXACT,
-
-  OP_CRSTAR,                /* These are for character classes and back refs */
-  OP_CRMINSTAR,
-  OP_CRPLUS,
-  OP_CRMINPLUS,
-  OP_CRQUERY,
-  OP_CRMINQUERY,
-  OP_CRRANGE,               /* These are different to the three sets above. */
-  OP_CRMINRANGE,
-
-  OP_CLASS,                 /* Match a character class, chars < 256 only */
-  OP_NCLASS,                /* Same, but the bitmap was created from a negative
-                               class - the difference is relevant when a UTF-8
-                               character > 255 is encountered. */
-
-  OP_XCLASS,                /* Extended class for handling UTF-8 chars within the
-                               class. This does both positive and negative. */
-
-  OP_REF,                   /* Match a back reference */
-
-  OP_ALT,                   /* Start of alternation */
-  OP_KET,                   /* End of group that doesn't have an unbounded repeat */
-  OP_KETRMAX,               /* These two must remain together and in this */
-  OP_KETRMIN,               /* order. They are for groups the repeat for ever. */
-
-  /* The assertions must come before ONCE and COND */
-
-  OP_ASSERT,                /* Positive lookahead */
-  OP_ASSERT_NOT,            /* Negative lookahead */
-
-  /* ONCE and COND must come after the assertions, with ONCE first, as there's
-  a test for >= ONCE for a subpattern that isn't an assertion. */
-
-  OP_ONCE,                  /* Once matched, don't back up into the subpattern */
-
-  OP_BRAZERO,               /* These two must remain together and in this */
-  OP_BRAMINZERO,            /* order. */
-
-  OP_BRANUMBER,             /* Used for extracting brackets whose number is greater
-                               than can fit into an opcode. */
-
-  OP_BRA                    /* This and greater values are used for brackets that
-                               extract substrings up to EXTRACT_BASIC_MAX. After
-                               that, use is made of OP_BRANUMBER. */
-};
+#define FOR_EACH_OPCODE(macro) \
+    macro(END) \
+    \
+    macro(NOT_WORD_BOUNDARY) \
+    macro(WORD_BOUNDARY) \
+    macro(NOT_DIGIT) \
+    macro(DIGIT) \
+    macro(NOT_WHITESPACE) \
+    macro(WHITESPACE) \
+    macro(NOT_WORDCHAR) \
+    macro(WORDCHAR) \
+    \
+    macro(ANY) \
+    \
+    macro(CIRC) \
+    macro(DOLL) \
+    macro(CHAR) \
+    macro(CHARNC) \
+    macro(ASCII_CHAR) \
+    macro(ASCII_LETTER_NC) \
+    macro(NOT) \
+    \
+    macro(STAR) \
+    macro(MINSTAR) \
+    macro(PLUS) \
+    macro(MINPLUS) \
+    macro(QUERY) \
+    macro(MINQUERY) \
+    macro(UPTO) \
+    macro(MINUPTO) \
+    macro(EXACT) \
+    \
+    macro(NOTSTAR) \
+    macro(NOTMINSTAR) \
+    macro(NOTPLUS) \
+    macro(NOTMINPLUS) \
+    macro(NOTQUERY) \
+    macro(NOTMINQUERY) \
+    macro(NOTUPTO) \
+    macro(NOTMINUPTO) \
+    macro(NOTEXACT) \
+    \
+    macro(TYPESTAR) \
+    macro(TYPEMINSTAR) \
+    macro(TYPEPLUS) \
+    macro(TYPEMINPLUS) \
+    macro(TYPEQUERY) \
+    macro(TYPEMINQUERY) \
+    macro(TYPEUPTO) \
+    macro(TYPEMINUPTO) \
+    macro(TYPEEXACT) \
+    \
+    macro(CRSTAR) \
+    macro(CRMINSTAR) \
+    macro(CRPLUS) \
+    macro(CRMINPLUS) \
+    macro(CRQUERY) \
+    macro(CRMINQUERY) \
+    macro(CRRANGE) \
+    macro(CRMINRANGE) \
+    \
+    macro(CLASS) \
+    macro(NCLASS) \
+    macro(XCLASS) \
+    \
+    macro(REF) \
+    \
+    macro(ALT) \
+    macro(KET) \
+    macro(KETRMAX) \
+    macro(KETRMIN) \
+    \
+    macro(ASSERT) \
+    macro(ASSERT_NOT) \
+    \
+    macro(ONCE) \
+    \
+    macro(BRAZERO) \
+    macro(BRAMINZERO) \
+    macro(BRANUMBER) \
+    macro(BRA)
+
+#define OPCODE_ENUM_VALUE(opcode) OP_##opcode,
+enum { FOR_EACH_OPCODE(OPCODE_ENUM_VALUE) };
 
 /* WARNING WARNING WARNING: There is an implicit assumption in pcre.c and
 study.c that all opcodes are less than 128 in value. This makes handling UTF-8
@@ -475,7 +450,6 @@ opcodes. */
 
 #define EXTRACT_BASIC_MAX  100
 
-
 /* This macro defines the length of fixed length operations in the compiled
 regex. The lengths are used when searching for specific things, and also in the
 debugging printing of a compiled regex. We use a macro so that it can be
@@ -521,15 +495,6 @@ in UTF-8 mode. The code that uses this table must know about such things. */
   1+LINK_SIZE                    /* BRA                                    */ \
 
 
-/* Error code numbers. They are given names so that they can more easily be
-tracked. */
-
-enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,  ERR5,  ERR6,  ERR7,  ERR8,  ERR9,
-       ERR10, ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19,
-       ERR20, ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR28, ERR29,
-       ERR30, ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39,
-       ERR40, ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47 };
-
 /* The real format of the start of the pcre block; the index of names and the
 code vector run on as long as necessary after the end. We store an explicit
 offset to the name table so that if a regex is compiled on one host, saved, and
@@ -572,40 +537,9 @@ typedef struct compile_data {
   int  req_varyopt;             /* "After variable item" flag for reqbyte */
 } compile_data;
 
-/* When compiling in a mode that doesn't use recursive calls to match(),
-a structure is used to remember local variables on the heap. It is defined in
-pcre.c, close to the match() function, so that it is easy to keep it in step
-with any changes of local variable. However, the pointer to the current frame
-must be saved in some "static" place over a longjmp(). We declare the
-structure here so that we can put a pointer in the match_data structure.
-NOTE: This isn't used for a "normal" compilation of pcre. */
-
-struct heapframe;
-
-/* Structure for passing "static" information around between the functions
-doing traditional NFA matching, so that they are thread-safe. */
-
-typedef struct match_data {
-  unsigned long int match_call_count;      /* As it says */
-  int   *offset_vector;         /* Offset vector */
-  int    offset_end;            /* One past the end */
-  int    offset_max;            /* The maximum usable for return data */
-  const uschar *lcc;            /* Points to lower casing table */
-  const uschar *ctypes;         /* Points to table of type maps */
-  BOOL   offset_overflow;       /* Set if too many extractions */
-  USPTR  start_subject;         /* Start of the subject string */
-  USPTR  end_subject;           /* End of the subject string */
-  USPTR  start_match;           /* Start of this match attempt */
-  USPTR  end_match_ptr;         /* Subject position at end match */
-  int    end_offset_top;        /* Highwater mark at end of match */
-  BOOL   multiline;
-  BOOL   caseless;
-} match_data;
-
 /* Bit definitions for entries in the pcre_ctypes table. */
 
 #define ctype_space   0x01
-#define ctype_digit   0x04
 #define ctype_xdigit  0x08
 #define ctype_word    0x10   /* alphameric or '_' */
 
@@ -650,8 +584,6 @@ extern const int    _pcre_utf8_table1_size;
 
 extern const uschar _pcre_default_tables[];
 
-extern const uschar _pcre_OP_lengths[];
-
 
 /* Internal shared functions. These are functions that are used by more than
 one of the exported public functions. They have to be "external" in the C
similarity index 84%
rename from JavaScriptCore/pcre/pcre_maketables.c
rename to JavaScriptCore/pcre/pcre_maketables.cpp
index 6f4bc44d0930422c6607bf69af71d4121b77d6cf..d7f20c47dc2bdc9b97abf9837b0444c9162087a5 100644 (file)
@@ -1,12 +1,12 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
-
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -58,11 +58,7 @@ pcre_maketables(void)
 unsigned char *yield, *p;
 int i;
 
-#ifndef DFTABLES
-yield = (unsigned char*)(pcre_malloc)(tables_length);
-#else
 yield = (unsigned char*)malloc(tables_length);
-#endif
 
 if (yield == NULL) return NULL;
 p = yield;
@@ -85,12 +81,13 @@ least under Debian Linux's locales as of 12/2005). So we must test for alnum
 specially. */
 
 memset(p, 0, cbit_length);
+for (i = '0'; i <= '9'; i++)
+  p[cbit_digit + i / 8] |= 1 << (i & 7);
+p[cbit_word + '_' / 8] |= 1 << ('_' & 7);
 for (i = 0; i < 128; i++)
   {
-  if (isdigit(i)) p[cbit_digit  + i/8] |= 1 << (i&7);
-  if (isalnum(i)) p[cbit_word   + i/8] |= 1 << (i&7);
-  if (i == '_')   p[cbit_word   + i/8] |= 1 << (i&7);
-  if (isspace(i)) p[cbit_space  + i/8] |= 1 << (i&7);
+  if (isalnum(i)) p[cbit_word + i/8] |= 1 << (i & 7);
+  if (isspace(i)) p[cbit_space + i/8] |= 1 << (i & 7);
   }
 p += cbit_length;
 
@@ -102,7 +99,6 @@ for (i = 0; i < 128; i++)
   {
   int x = 0;
   if (isspace(i)) x += ctype_space;
-  if (isdigit(i)) x += ctype_digit;
   if (isxdigit(i)) x += ctype_xdigit;
   if (isalnum(i) || i == '_') x += ctype_word;
   *p++ = x;
similarity index 84%
rename from JavaScriptCore/pcre/pcre_ord2utf8.c
rename to JavaScriptCore/pcre/pcre_ord2utf8.cpp
index fc4d6de81262f2d443d14fad27869774f46f4564..6fb9e467c0eb4ae26d3a09c6c4e7d2dd05c695ca 100644 (file)
@@ -1,12 +1,12 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
-
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -74,5 +74,3 @@ for (j = i; j > 0; j--)
 *buffer = _pcre_utf8_table2[i] | cvalue;
 return i + 1;
 }
-
-/* End of pcre_ord2utf8.c */
similarity index 78%
rename from JavaScriptCore/pcre/pcre_tables.c
rename to JavaScriptCore/pcre/pcre_tables.cpp
index d78d4258720397462b6442f8fa7d5528a7155503..18ac9608875c80a047c61fc6e23fc6528dee3752 100644 (file)
@@ -1,12 +1,12 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
-
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -37,23 +37,11 @@ POSSIBILITY OF SUCH DAMAGE.
 -----------------------------------------------------------------------------
 */
 
-
 /* This module contains some fixed tables that are used by more than one of the
-PCRE code modules. The tables are also #included by the pcretest program, which
-uses macros to change their names from _pcre_xxx to xxxx, thereby avoiding name
-clashes with the library. */
-
+PCRE code modules. */
 
 #include "pcre_internal.h"
 
-
-/* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
-the definition is next to the definition of the opcodes in pcre_internal.h. */
-
-const uschar _pcre_OP_lengths[] = { OP_LENGTHS };
-
-
-
 /*************************************************
 *           Tables for UTF-8 support             *
 *************************************************/
@@ -83,5 +71,3 @@ const uschar _pcre_utf8_table4[] = {
   3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
 
 #include "chartables.c"
-
-/* End of pcre_tables.c */
similarity index 86%
rename from JavaScriptCore/pcre/pcre_ucp_searchfuncs.c
rename to JavaScriptCore/pcre/pcre_ucp_searchfuncs.cpp
index 386f93dc2f5cf4c816faf977c201a2f36f50def3..cb41e9235a0754515507132e2a6a3fed95fa9a4d 100644 (file)
@@ -1,12 +1,12 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
-
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -44,8 +44,7 @@ properties. */
 #include "pcre_internal.h"
 
 #include "ucpinternal.h"       /* Internal table details */
-#include "ucptable.c"          /* The table itself */
-
+#include "ucptable.cpp"        /* The table itself */
 
 /*************************************************
 *       Search table and return other case       *
@@ -96,6 +95,3 @@ offset = ucp_table[mid].f1 & f1_casemask;
 if ((offset & f1_caseneg) != 0) offset |= f1_caseneg;
 return (offset == 0)? -1 : c + offset;
 }
-
-
-/* End of pcre_ucp_searchfuncs.c */
similarity index 85%
rename from JavaScriptCore/pcre/pcre_xclass.c
rename to JavaScriptCore/pcre/pcre_xclass.cpp
index a0ec9f319282154081f1a913e21a2de84a6fcc30..8c4d624462fdbc1c942ec265ec5b22693a485465 100644 (file)
@@ -1,12 +1,12 @@
-/*************************************************
-*      Perl-Compatible Regular Expressions       *
-*************************************************/
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
 
-/* PCRE is a library of functions to support regular expressions whose syntax
-and semantics are as close as possible to those of the Perl 5 language.
-
-                       Written by Philip Hazel
+                 Originally written by Philip Hazel
            Copyright (c) 1997-2006 University of Cambridge
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -37,15 +37,11 @@ POSSIBILITY OF SUCH DAMAGE.
 -----------------------------------------------------------------------------
 */
 
-
 /* This module contains an internal function that is used to match an extended
-class (one that contains characters whose values are > 255). It is used by both
-pcre_exec() and pcre_def_exec(). */
-
+class (one that contains characters whose values are > 255). */
 
 #include "pcre_internal.h"
 
-
 /*************************************************
 *       Match character against an XCLASS        *
 *************************************************/
@@ -100,5 +96,3 @@ while ((t = *data++) != XCL_END)
 
 return negated;   /* char did not match */
 }
-
-/* End of pcre_xclass.c */
index 16dfbe9b0f7eeaeb1fdc88a3e4a567845e15b07f..a981f585bd607f334fb946c98a1c5887983cdbec 100644 (file)
@@ -1,3 +1,42 @@
+/* This is JavaScriptCore's variant of the PCRE library. While this library
+started out as a copy of PCRE, many of the features of PCRE have been
+removed. This library now supports only the regular expression features
+required by the JavaScript language specification, and has only the functions
+needed by JavaScriptCore and the rest of WebKit.
+
+                 Originally written by Philip Hazel
+           Copyright (c) 1997-2006 University of Cambridge
+    Copyright (C) 2002, 2004, 2006, 2007 Apple Inc. All rights reserved.
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+*/
+
 /*************************************************
 *           Unicode Property Table handler       *
 *************************************************/
index 849b811d1feabd963aff589311eb3880eb68f562..d3657fed9b882d550120c645692d4ef8f77c20b9 100644 (file)
@@ -55,11 +55,12 @@ namespace WTF {
     inline bool isASCIIAlphanumeric(wchar_t c) { return c >= '0' && c <= '9' || (c | 0x20) >= 'a' && (c | 0x20) <= 'z'; }
 #endif
 
-    inline bool isASCIIDigit(char c) { return c >= '0' && c <= '9'; }
-    inline bool isASCIIDigit(unsigned short c) { return c >= '0' && c <= '9'; }
+    inline bool isASCIIDigit(char c) { return (c >= '0') & (c <= '9'); }
+    inline bool isASCIIDigit(unsigned short c) { return (c >= '0') & (c <= '9'); }
 #if !COMPILER(MSVC) || defined(_NATIVE_WCHAR_T_DEFINED)
-    inline bool isASCIIDigit(wchar_t c) { return c >= '0' && c <= '9'; }
+    inline bool isASCIIDigit(wchar_t c) { return (c >= '0') & (c <= '9'); }
 #endif
+    inline bool isASCIIDigit(int c) { return (c >= '0') & (c <= '9'); }
 
     inline bool isASCIIHexDigit(char c) { return c >= '0' && c <= '9' || (c | 0x20) >= 'a' && (c | 0x20) <= 'f'; }
     inline bool isASCIIHexDigit(unsigned short c) { return c >= '0' && c <= '9' || (c | 0x20) >= 'a' && (c | 0x20) <= 'f'; }
diff --git a/JavaScriptCore/wtf/FastMallocPCRE.cpp b/JavaScriptCore/wtf/FastMallocPCRE.cpp
deleted file mode 100644 (file)
index abf9cc3..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-// -*- mode: c++; c-basic-offset: 4 -*-
-/*
- *  Copyright (C) 2007 Apple Inc. All rights reserved.
- *
- *  This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- *  You should have received a copy of the GNU Library General Public License
- *  along with this library; see the file COPYING.LIB.  If not, write to
- *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
-
-#include "FastMalloc.h"
-#include "pcre_internal.h"
-
-void* (*pcre_malloc)(size_t) = fastMalloc;
-void (*pcre_free)(void*) = fastFree;
index 4501f1a3f90cec287671451a135ce2dcc0b38845..3ff84946f8fac9568119df61c132ad1ea3fd70d7 100644 (file)
@@ -207,11 +207,6 @@ namespace WTF {
       return !!u_islower(c);
     }
 
-    inline bool isUpper(UChar32 c)
-    {
-      return !!u_isUUppercase(c);
-      }
-
     inline int digitValue(UChar32 c)
     {
       return u_charDigitValue(c);
index cc2a391443b281c06c726c3dd309cece6898e386..a552bd957a15aac21a468af94fe034415681cdb7 100644 (file)
@@ -343,11 +343,6 @@ namespace WTF {
       return QChar::category(c) == QChar::Letter_Lowercase;
     }
 
-    inline bool isUpper(UChar32 c)
-    {
-      return QChar::category(c) == QChar::Letter_Uppercase;
-    }
-
     inline int digitValue(UChar32 c)
     {
       return QChar::digitValue(c);
@@ -479,11 +474,6 @@ namespace WTF {
       return (c & 0xffff0000) == 0 && QChar((unsigned short)c).category() == QChar::Letter_Lowercase;
     }
 
-    inline bool isUpper(UChar32 c)
-    {
-      return (c & 0xffff0000) == 0 && QChar((unsigned short)c).category() == QChar::Letter_Uppercase;
-    }
-
     inline int digitValue(UChar32 c)
     {
       if (c > 0xffff)
index d0e0d8730d4967d63edb8dc26576aa7511ebcf23..c13a9dce9ca0986ea8040f30e26ddf1aca659bb0 100644 (file)
@@ -1,3 +1,13 @@
+2007-11-11  Darin Adler  <darin@apple.com>
+
+        Reviewed by Sam.
+
+        - updated for JSRegExp function changes
+
+        * platform/RegularExpression.cpp:
+        (WebCore::RegularExpression::Private::compile):
+        (WebCore::RegularExpression::match):
+
 2007-11-10  Mark Rowe  <mrowe@apple.com>
 
         Qt Linux build fix.
index c614e01a6f4136a12c4a7ee59795dd4a79af6ac8..fc4fd3407f56ea0457a44152848797750d08cf32 100644 (file)
@@ -102,7 +102,9 @@ void RegularExpression::Private::compile(bool caseSensitive, bool glob)
     // on the regex syntax (see FrameMac.mm for a couple examples).
     
     const char* errorMessage;
-    regex = jsRegExpCompile(reinterpret_cast<const uint16_t *>(p.unicode()), p.length(), caseSensitive ? 0 : JS_REGEXP_CASELESS, 0, &errorMessage);
+    regex = jsRegExpCompile(reinterpret_cast<const UChar*>(p.unicode()), p.length(),
+        caseSensitive ? JSRegExpDoNotIgnoreCase : JSRegExpIgnoreCase, JSRegExpSingleLine,
+        0, &errorMessage);
     if (!regex)
         LOG_ERROR("RegularExpression: pcre_compile failed with '%s'", errorMessage);
 }
@@ -154,9 +156,9 @@ int RegularExpression::match(const DeprecatedString &str, int startFrom, int *ma
 {
     d->lastMatchString = str;
     // First 2 offsets are start and end offsets; 3rd entry is used internally by pcre
-    d->lastMatchCount = jsRegExpExecute(d->regex, reinterpret_cast<const JSRegExpChar*>(d->lastMatchString.unicode()), d->lastMatchString.length(), startFrom, d->lastMatchOffsets, maxOffsets);
+    d->lastMatchCount = jsRegExpExecute(d->regex, reinterpret_cast<const UChar*>(d->lastMatchString.unicode()), d->lastMatchString.length(), startFrom, d->lastMatchOffsets, maxOffsets);
     if (d->lastMatchCount < 0) {
-        if (d->lastMatchCount != JS_REGEXP_ERROR_NOMATCH)
+        if (d->lastMatchCount != JSRegExpErrorNoMatch)
             LOG_ERROR("RegularExpression: pcre_exec() failed with result %d", d->lastMatchCount);
         d->lastMatchPos = -1;
         d->lastMatchLength = -1;