regex-pcre-builtin 0.94.6.8.8.35 → 0.95.2.3.8.44
raw patch · 35 files changed
Files
- ChangeLog.md +15/−0
- LICENSE +1/−1
- Text/Regex/PCRE.hs +0/−62
- Text/Regex/PCRE/ByteString.hs +0/−141
- Text/Regex/PCRE/ByteString/Lazy.hs +0/−137
- Text/Regex/PCRE/Sequence.hs +0/−154
- Text/Regex/PCRE/String.hs +0/−123
- Text/Regex/PCRE/Wrap.hsc +0/−490
- pcre/config.h +8/−26
- pcre/pcre.h +13/−7
- pcre/pcre_byte_order.c +3/−3
- pcre/pcre_chartables.c +1/−1
- pcre/pcre_compile.c +9797/−9425
- pcre/pcre_dfa_exec.c +38/−44
- pcre/pcre_exec.c +178/−187
- pcre/pcre_get.c +15/−8
- pcre/pcre_globals.c +3/−1
- pcre/pcre_internal.h +62/−96
- pcre/pcre_jit_compile.c +11754/−9707
- pcre/pcre_printint.c +14/−1
- pcre/pcre_string_utils.c +4/−4
- pcre/pcre_study.c +126/−42
- pcre/pcre_tables.c +211/−142
- pcre/pcre_ucd.c +3613/−3266
- pcre/pcre_xclass.c +6/−1
- pcre/ucp.h +25/−1
- regex-pcre-builtin.cabal +83/−72
- src/Text/Regex/PCRE.hs +52/−0
- src/Text/Regex/PCRE/ByteString.hs +144/−0
- src/Text/Regex/PCRE/ByteString/Lazy.hs +140/−0
- src/Text/Regex/PCRE/Sequence.hs +157/−0
- src/Text/Regex/PCRE/String.hs +126/−0
- src/Text/Regex/PCRE/Text.hs +175/−0
- src/Text/Regex/PCRE/Text/Lazy.hs +170/−0
- src/Text/Regex/PCRE/Wrap.hsc +421/−0
+ ChangeLog.md view
@@ -0,0 +1,15 @@+See also http://pvp.haskell.org/faq++## 0.95.1.3.8.43+- Version bump to reflect pcre version (8.43) and to have Hackage upgrade from 0.95.1.2.8.43 which does not include #15++## 0.95.1.1.8.44+- Fix: `asCString` for `Text` regexes doesn't check for null-termination, causing the compiled regex to be corrupted. (@kuribas)++## 0.95.1.0.8.43++- Update to `regex-0.94.0.0` API+- Compatibility with `base-4.13.0`+- New `Text.Regex.PCRE.Text` & `Text.Regex.PCRE.Text.Lazy` modules (merged from `regex-pcre-text` package)++----
LICENSE view
@@ -7,7 +7,7 @@ http://creativecommons.org/publicdomain/zero/1.0 -# Contains code from from pcre 8.31, under the BSD license:+# Contains code from from pcre 8.43, under the BSD license: http://www.pcre.org/licence.txt
− Text/Regex/PCRE.hs
@@ -1,62 +0,0 @@-{-# OPTIONS_GHC -fno-warn-unused-imports #-}-{-|-The "Text.Regex.PCRE" module provides a backend for regular-expressions. If you import this along with other backends, then-you should do so with qualified imports, perhaps renamed for-convenience.--You will need to have libpcre, from www.pcre.org, to use-this module. The haskell must be compiled with -DHAVE_PCRE_H and-linked with pcre. This is the default in the cabal file.--If you do not compile with HAVE_PCRE_H then the functions will still-exist, but using them will create a run time error. You can test for-the existance of PCRE by checking 'getVersion' which is 'Nothing' if-not compiled with PCRE or 'Just' 'String' if PCRE is present.--Using the provided 'CompOption' and 'ExecOption' values and if-'configUTF8' is True, then you might be able to send UTF8 encoded-ByteStrings to PCRE and get sensible results. This is currently-untested.--The regular expression can be provided as a 'ByteString', but it will-be copied and a NUL byte appended to make a 'CString' unless such a-byte is already present. Thus the regular expression cannot contain-an explicit NUL byte. The search string is passed as a 'CStringLen'-and may contain NUL bytes and does not need to end in a NUL-byte. 'ByteString's are searched in place (via unsafeUseAsCStringLen).--A 'String' will be converted into a 'CString' or 'CStringLen' for-processing. Doing this repeatedly will be very inefficient.--The "Text.Regex.PCRE.String", "Text.Regex.PCRE.ByteString", and-"Text.Regex.PCRE.Wrap" modules provides both the high level interface-exported by this module and medium- and low-level interfaces that-returns error using Either structures.--}-{- Copyright : (c) Chris Kuklewicz 2007 -}-module Text.Regex.PCRE(getVersion_Text_Regex_PCRE- ,module Text.Regex.Base- -- ** Wrap, for '=~' and '=~~', types and constants- ,module Text.Regex.PCRE.Wrap) where--import Text.Regex.PCRE.Wrap(Regex, CompOption(CompOption), ExecOption(ExecOption), (=~), (=~~),- unusedOffset, getNumSubs, configUTF8, getVersion,- compBlank, compAnchored, compAutoCallout, compCaseless,- compDollarEndOnly, compDotAll, compExtended, compExtra,- compFirstLine, compMultiline, compNoAutoCapture, compUngreedy,- compUTF8, compNoUTF8Check,- execBlank, execAnchored, execNotBOL, execNotEOL, execNotEmpty,- execNoUTF8Check, execPartial)-import Text.Regex.PCRE.String()-import Text.Regex.PCRE.Sequence()-import Text.Regex.PCRE.ByteString()-import Text.Regex.PCRE.ByteString.Lazy()-import Data.Version(Version(..))-import Text.Regex.Base--getVersion_Text_Regex_PCRE :: Version-getVersion_Text_Regex_PCRE =- Version { versionBranch = [0,94,4,0,8,35] -- Keep in sync with regex-pcre.cabal- , versionTags = ["unstable"]- }
− Text/Regex/PCRE/ByteString.hs
@@ -1,141 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}-{-|-This exports instances of the high level API and the medium level-API of 'compile','execute', and 'regexec'.--}-{- Copyright : (c) Chris Kuklewicz 2007 -}-module Text.Regex.PCRE.ByteString(- -- ** Types- Regex,- MatchOffset,- MatchLength,- CompOption(CompOption),- ExecOption(ExecOption),- ReturnCode,- WrapError,- -- ** Miscellaneous- unusedOffset,- getVersion,- -- ** Medium level API functions- compile,- execute,- regexec,- -- ** CompOption flags- compBlank,- compAnchored,- compAutoCallout,- compCaseless,- compDollarEndOnly,- compDotAll,- compExtended,- compExtra,- compFirstLine,- compMultiline,- compNoAutoCapture,- compUngreedy,- compUTF8,- compNoUTF8Check,- -- ** ExecOption flags- execBlank,- execAnchored,- execNotBOL,- execNotEOL,- execNotEmpty,- execNoUTF8Check,- execPartial- ) where--import Text.Regex.PCRE.Wrap -- all-import Data.Array(Array,listArray)-import Data.ByteString(ByteString)-import qualified Data.ByteString as B(empty,useAsCString,last,take,drop,null,pack)-import qualified Data.ByteString.Unsafe as B(unsafeUseAsCString,unsafeUseAsCStringLen)-import System.IO.Unsafe(unsafePerformIO)-import Text.Regex.Base.RegexLike(RegexContext(..),RegexMaker(..),RegexLike(..),MatchOffset,MatchLength)-import Text.Regex.Base.Impl(polymatch,polymatchM)-import Foreign.C.String(CStringLen)-import Foreign(nullPtr)--instance RegexContext Regex ByteString ByteString where- match = polymatch- matchM = polymatchM--unwrap :: (Show e) => Either e v -> IO v-unwrap x = case x of Left err -> fail ("Text.Regex.PCRE.ByteString died: "++ show err)- Right v -> return v--{-# INLINE asCStringLen #-}-asCStringLen :: ByteString -> (CStringLen -> IO a) -> IO a-asCStringLen s op = B.unsafeUseAsCStringLen s checked- where checked cs@(ptr,_) | ptr == nullPtr = B.unsafeUseAsCStringLen myEmpty (op . trim)- | otherwise = op cs- myEmpty = B.pack [0]- trim (ptr,_) = (ptr,0)--instance RegexMaker Regex CompOption ExecOption ByteString where- makeRegexOpts c e pattern = unsafePerformIO $- compile c e pattern >>= unwrap- makeRegexOptsM c e pattern = either (fail.show) return $ unsafePerformIO $- compile c e pattern--instance RegexLike Regex ByteString where- matchTest regex bs = unsafePerformIO $- asCStringLen bs (wrapTest 0 regex) >>= unwrap- matchOnce regex bs = unsafePerformIO $- execute regex bs >>= unwrap- matchAll regex bs = unsafePerformIO $- asCStringLen bs (wrapMatchAll regex) >>= unwrap- matchCount regex bs = unsafePerformIO $- asCStringLen bs (wrapCount regex) >>= unwrap---- ------------------------------------------------------------------------ | Compiles a regular expression----compile :: CompOption -- ^ (summed together)- -> ExecOption -- ^ (summed together)- -> ByteString -- ^ The regular expression to compile- -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: the compiled regular expression-compile c e pattern = do- -- PCRE does not allow one to specify a length for the regular expression, it must by 0 terminated- let asCString bs = if (not (B.null bs)) && (0==B.last bs)- then B.unsafeUseAsCString bs- else B.useAsCString bs- asCString pattern (wrapCompile c e)---- ------------------------------------------------------------------------ | Matches a regular expression against a buffer, returning the buffer--- indicies of the match, and any submatches------ | Matches a regular expression against a string-execute :: Regex -- ^ Compiled regular expression- -> ByteString -- ^ String to match against- -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))- -- ^ Returns: 'Nothing' if the regex did not match the- -- string, or:- -- 'Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions.-execute regex bs = do- maybeStartEnd <- asCStringLen bs (wrapMatch 0 regex)- case maybeStartEnd of- Right Nothing -> return (Right Nothing)- Right (Just parts) ->- return . Right . Just . listArray (0,pred (length parts))- . map (\(s,e)->(fromIntegral s, fromIntegral (e-s))) $ parts- Left err -> return (Left err)--regexec :: Regex -- ^ Compiled regular expression- -> ByteString -- ^ String to match against- -> IO (Either WrapError (Maybe (ByteString, ByteString, ByteString, [ByteString])))-regexec regex bs = do- let getSub (start,stop) | start == unusedOffset = B.empty- | otherwise = B.take (stop-start) . B.drop start $ bs- matchedParts [] = (B.empty,B.empty,bs,[]) -- no information- matchedParts (matchedStartStop@(start,stop):subStartStop) =- (B.take start bs- ,getSub matchedStartStop- ,B.drop stop bs- ,map getSub subStartStop)- maybeStartEnd <- asCStringLen bs (wrapMatch 0 regex)- case maybeStartEnd of- Right Nothing -> return (Right Nothing)- Right (Just parts) -> return . Right . Just . matchedParts $ parts- Left err -> return (Left err)
− Text/Regex/PCRE/ByteString/Lazy.hs
@@ -1,137 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}-{-|-This exports instances of the high level API and the medium level-API of 'compile','execute', and 'regexec'.--}-{- Copyright : (c) Chris Kuklewicz 2007 -}-module Text.Regex.PCRE.ByteString.Lazy(- -- ** Types- Regex,- MatchOffset,- MatchLength,- CompOption(CompOption),- ExecOption(ExecOption),- ReturnCode,- WrapError,- -- ** Miscellaneous- unusedOffset,- getVersion,- -- ** Medium level API functions- compile,- execute,- regexec,- -- ** CompOption flags- compBlank,- compAnchored,- compAutoCallout,- compCaseless,- compDollarEndOnly,- compDotAll,- compExtended,- compExtra,- compFirstLine,- compMultiline,- compNoAutoCapture,- compUngreedy,- compUTF8,- compNoUTF8Check,- -- ** ExecOption flags- execBlank,- execAnchored,- execNotBOL,- execNotEOL,- execNotEmpty,- execNoUTF8Check,- execPartial- ) where--import Text.Regex.PCRE.Wrap -- all-import Data.Array(Array)-import qualified Data.ByteString.Lazy as L(ByteString,toChunks,fromChunks,last,null,snoc)-import qualified Data.ByteString as B(ByteString,concat,pack)-import qualified Data.ByteString.Unsafe as B(unsafeUseAsCString,unsafeUseAsCStringLen)-import System.IO.Unsafe(unsafePerformIO)-import Text.Regex.Base.RegexLike(RegexContext(..),RegexMaker(..),RegexLike(..),MatchOffset,MatchLength)-import Text.Regex.Base.Impl(polymatch,polymatchM)-import qualified Text.Regex.PCRE.ByteString as BS(execute,regexec)-import Foreign.C.String(CString,CStringLen)-import Foreign(nullPtr)--instance RegexContext Regex L.ByteString L.ByteString where- match = polymatch- matchM = polymatchM--{-# INLINE fromLazy #-}-fromLazy :: L.ByteString -> B.ByteString-fromLazy = B.concat . L.toChunks--{-# INLINE toLazy #-}-toLazy :: B.ByteString -> L.ByteString-toLazy = L.fromChunks . return--unwrap :: (Show e) => Either e v -> IO v-unwrap x = case x of Left err -> fail ("Text.Regex.PCRE.ByteString.Lazy died: "++ show err)- Right v -> return v--{-# INLINE asCString #-}-asCString :: L.ByteString -> (CString -> IO a) -> IO a-asCString s = if (not (L.null s)) && (0==L.last s)- then B.unsafeUseAsCString (fromLazy s)- else B.unsafeUseAsCString (fromLazy (L.snoc s 0))--{-# INLINE asCStringLen #-}-asCStringLen :: L.ByteString -> (CStringLen -> IO a) -> IO a-asCStringLen ls op = B.unsafeUseAsCStringLen (fromLazy ls) checked- where checked cs@(ptr,_) | ptr == nullPtr = B.unsafeUseAsCStringLen myEmpty (op . trim)- | otherwise = op cs- myEmpty = B.pack [0]- trim (ptr,_) = (ptr,0)--instance RegexMaker Regex CompOption ExecOption L.ByteString where- makeRegexOpts c e pattern = unsafePerformIO $- compile c e pattern >>= unwrap- makeRegexOptsM c e pattern = either (fail.show) return $ unsafePerformIO $- compile c e pattern--instance RegexLike Regex L.ByteString where- matchTest regex bs = unsafePerformIO $- asCStringLen bs (wrapTest 0 regex) >>= unwrap- matchOnce regex bs = unsafePerformIO $- execute regex bs >>= unwrap- matchAll regex bs = unsafePerformIO $- asCStringLen bs (wrapMatchAll regex) >>= unwrap- matchCount regex bs = unsafePerformIO $- asCStringLen bs (wrapCount regex) >>= unwrap---- ------------------------------------------------------------------------ | Compiles a regular expression----compile :: CompOption -- ^ (summed together)- -> ExecOption -- ^ (summed together)- -> L.ByteString -- ^ The regular expression to compile- -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: the compiled regular expression-compile c e pattern = do- asCString pattern (wrapCompile c e)---- ------------------------------------------------------------------------ | Matches a regular expression against a buffer, returning the buffer--- indicies of the match, and any submatches------ | Matches a regular expression against a string-execute :: Regex -- ^ Compiled regular expression- -> L.ByteString -- ^ String to match against- -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))- -- ^ Returns: 'Nothing' if the regex did not match the- -- string, or:- -- 'Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions.-execute regex bs = BS.execute regex (fromLazy bs)--regexec :: Regex -- ^ Compiled regular expression- -> L.ByteString -- ^ String to match against- -> IO (Either WrapError (Maybe (L.ByteString, L.ByteString, L.ByteString, [L.ByteString])))-regexec regex bs = do- x <- BS.regexec regex (fromLazy bs)- return $ case x of- Left e -> Left e- Right Nothing -> Right Nothing- Right (Just (a,b,c,ds)) -> Right (Just (toLazy a,toLazy b,toLazy c,map toLazy ds))
− Text/Regex/PCRE/Sequence.hs
@@ -1,154 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}-{-|-This exports instances of the high level API and the medium level-API of 'compile','execute', and 'regexec'.--}-{- Copyright : (c) Chris Kuklewicz 2007 -}-module Text.Regex.PCRE.Sequence(- -- ** Types- Regex,- MatchOffset,- MatchLength,- CompOption(CompOption),- ExecOption(ExecOption),- ReturnCode,- WrapError,- -- ** Miscellaneous- unusedOffset,- getVersion,- -- ** Medium level API functions- compile,- execute,- regexec,- -- ** Constants for CompOption- compBlank,- compAnchored,- compAutoCallout,- compCaseless,- compDollarEndOnly,- compDotAll,- compExtended,- compExtra,- compFirstLine,- compMultiline,- compNoAutoCapture,- compUngreedy,- compUTF8,- compNoUTF8Check,- -- ** Constants for ExecOption- execBlank,- execAnchored,- execNotBOL,- execNotEOL,- execNotEmpty,- execNoUTF8Check,- execPartial- ) where--import Text.Regex.PCRE.Wrap -- all---import Foreign.C.String(withCStringLen,withCString)-import Data.Array(Array,listArray)-import System.IO.Unsafe(unsafePerformIO)-import Text.Regex.Base.RegexLike(RegexMaker(..),RegexLike(..),RegexContext(..),MatchLength,MatchOffset,Extract(..))-import Text.Regex.Base.Impl(polymatch,polymatchM)-import Data.Sequence as S hiding (length)-import qualified Data.Sequence as S (length)-import Foreign.C.String-import Foreign.Marshal.Array-import Foreign.Marshal.Alloc-import Foreign.Storable--instance RegexContext Regex (Seq Char) (Seq Char) where- match = polymatch- matchM = polymatchM--unwrap :: (Show e) => Either e v -> IO v-unwrap x = case x of Left err -> fail ("Text.Regex.PCRE.Sequence died: "++ show err)- Right v -> return v--instance RegexMaker Regex CompOption ExecOption (Seq Char) where- makeRegexOpts c e pattern = unsafePerformIO $- compile c e pattern >>= unwrap- makeRegexOptsM c e pattern = either (fail.show) return $ unsafePerformIO $- compile c e pattern--instance RegexLike Regex (Seq Char) where- matchTest regex str = unsafePerformIO $- withSeq str (wrapTest 0 regex) >>= unwrap- matchOnce regex str = unsafePerformIO $- execute regex str >>= unwrap- matchAll regex str = unsafePerformIO $ - withSeq str (wrapMatchAll regex) >>= unwrap- matchCount regex str = unsafePerformIO $ - withSeq str (wrapCount regex) >>= unwrap---- | Compiles a regular expression-compile :: CompOption -- ^ Flags (summed together)- -> ExecOption -- ^ Flags (summed together)- -> (Seq Char) -- ^ The regular expression to compile- -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: an error string and offset or the compiled regular expression-compile c e pattern = withSeq0 pattern (wrapCompile c e)---- | Matches a regular expression against a string-execute :: Regex -- ^ Compiled regular expression- -> (Seq Char) -- ^ (Seq Char) to match against- -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))- -- ^ Returns: 'Nothing' if the regex did not match the- -- string, or:- -- 'Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions.-execute regex str = do- maybeStartEnd <- withSeq str (wrapMatch 0 regex)- case maybeStartEnd of- Right Nothing -> return (Right Nothing)--- Right (Just []) -> fail "got [] back!" -- should never happen- Right (Just parts) -> - return . Right . Just . listArray (0,pred (length parts))- . map (\(s,e)->(fromIntegral s, fromIntegral (e-s))) $ parts- Left err -> return (Left err)---- | execute match and extract substrings rather than just offsets-regexec :: Regex -- ^ compiled regular expression- -> (Seq Char) -- ^ string to match- -> IO (Either WrapError (Maybe ((Seq Char), (Seq Char),(Seq Char), [(Seq Char)])))- -- ^ Returns: Nothing if no match, else- -- (text before match, text after match, array of matches with 0 being the whole match)-regexec regex str = do- let getSub (start,stop) | start == unusedOffset = S.empty- | otherwise = extract (start,stop-start) str- matchedParts [] = (S.empty,S.empty,str,[]) -- no information- matchedParts (matchedStartStop@(start,stop):subStartStop) = - (before start str- ,getSub matchedStartStop- ,after stop str- ,map getSub subStartStop)- maybeStartEnd <- withSeq str (wrapMatch 0 regex)- case maybeStartEnd of- Right Nothing -> return (Right Nothing)--- Right (Just []) -> fail "got [] back!" -- should never happen- Right (Just parts) -> return . Right . Just . matchedParts $ parts- Left err -> return (Left err)--withSeq :: Seq Char -> (CStringLen -> IO a) -> IO a-withSeq s f =- let -- Ensure null at end of s- len = S.length s- pokes p a | seq p (seq a False) = undefined- | otherwise =- case viewl a of- EmptyL -> return ()- c :< a' -> poke p (castCharToCChar c) >> pokes (advancePtr p 1) a'- in allocaBytes (S.length s) (\ptr -> pokes ptr s >> f (ptr,len))--withSeq0 :: Seq Char -> (CString -> IO a) -> IO a-withSeq0 s f =- let -- Ensure null at end of s- s' = case viewr s of -- bang !s'- EmptyR -> singleton '\0'- _ :> '\0' -> s- _ -> s |> '\0'- pokes p a | seq p (seq a False) = undefined- | otherwise =- case viewl a of -- bang pokes !p !a- EmptyL -> return ()- c :< a' -> poke p (castCharToCChar c) >> pokes (advancePtr p 1) a'- in allocaBytes (S.length s') (\ptr -> pokes ptr s' >> f ptr)
− Text/Regex/PCRE/String.hs
@@ -1,123 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans #-}-{-|-This exports instances of the high level API and the medium level-API of 'compile','execute', and 'regexec'.--}-{- Copyright : (c) Chris Kuklewicz 2007 -}-module Text.Regex.PCRE.String(- -- ** Types- Regex,- MatchOffset,- MatchLength,- CompOption(CompOption),- ExecOption(ExecOption),- ReturnCode,- WrapError,- -- ** Miscellaneous- unusedOffset,- getVersion,- -- ** Medium level API functions- compile,- execute,- regexec,- -- ** Constants for CompOption- compBlank,- compAnchored,- compAutoCallout,- compCaseless,- compDollarEndOnly,- compDotAll,- compExtended,- compExtra,- compFirstLine,- compMultiline,- compNoAutoCapture,- compUngreedy,- compUTF8,- compNoUTF8Check,- -- ** Constants for ExecOption- execBlank,- execAnchored,- execNotBOL,- execNotEOL,- execNotEmpty,- execNoUTF8Check,- execPartial- ) where--import Text.Regex.PCRE.Wrap -- all-import Foreign.C.String(withCStringLen,withCString)-import Data.Array(Array,listArray)-import System.IO.Unsafe(unsafePerformIO)-import Text.Regex.Base.RegexLike(RegexMaker(..),RegexLike(..),RegexContext(..),MatchLength,MatchOffset)-import Text.Regex.Base.Impl(polymatch,polymatchM)--instance RegexContext Regex String String where- match = polymatch- matchM = polymatchM--unwrap :: (Show e) => Either e v -> IO v-unwrap x = case x of Left err -> fail ("Text.Regex.PCRE.String died: "++ show err)- Right v -> return v--instance RegexMaker Regex CompOption ExecOption String where- makeRegexOpts c e pattern = unsafePerformIO $- compile c e pattern >>= unwrap- makeRegexOptsM c e pattern = either (fail.show) return $ unsafePerformIO $- compile c e pattern--instance RegexLike Regex String where- matchTest regex str = unsafePerformIO $- withCStringLen str (wrapTest 0 regex) >>= unwrap- matchOnce regex str = unsafePerformIO $- execute regex str >>= unwrap- matchAll regex str = unsafePerformIO $ - withCStringLen str (wrapMatchAll regex) >>= unwrap- matchCount regex str = unsafePerformIO $ - withCStringLen str (wrapCount regex) >>= unwrap---- | Compiles a regular expression-compile :: CompOption -- ^ Flags (summed together)- -> ExecOption -- ^ Flags (summed together)- -> String -- ^ The regular expression to compile- -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: an error string and offset or the compiled regular expression-compile c e pattern = withCString pattern (wrapCompile c e)---- | Matches a regular expression against a string-execute :: Regex -- ^ Compiled regular expression- -> String -- ^ String to match against- -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))- -- ^ Returns: 'Nothing' if the regex did not match the- -- string, or:- -- 'Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions.-execute regex str = do- maybeStartEnd <- withCStringLen str (wrapMatch 0 regex)- case maybeStartEnd of- Right Nothing -> return (Right Nothing)--- Right (Just []) -> fail "got [] back!" -- should never happen- Right (Just parts) -> - return . Right . Just . listArray (0,pred (length parts))- . map (\(s,e)->(fromIntegral s, fromIntegral (e-s))) $ parts- Left err -> return (Left err)---- | execute match and extract substrings rather than just offsets-regexec :: Regex -- ^ compiled regular expression- -> String -- ^ string to match- -> IO (Either WrapError (Maybe (String, String,String, [String])))- -- ^ Returns: Nothing if no match, else- -- (text before match, text after match, array of matches with 0 being the whole match)-regexec regex str = do- let getSub (start,stop) | start == unusedOffset = ""- | otherwise = take (stop-start) . drop start $ str- matchedParts [] = ("","",str,[]) -- no information- matchedParts (matchedStartStop@(start,stop):subStartStop) = - (take start str- ,getSub matchedStartStop- ,drop stop str- ,map getSub subStartStop)- maybeStartEnd <- withCStringLen str (wrapMatch 0 regex)- case maybeStartEnd of- Right Nothing -> return (Right Nothing)--- Right (Just []) -> fail "got [] back!" -- should never happen- Right (Just parts) -> return . Right . Just . matchedParts $ parts- Left err -> return (Left err)
− Text/Regex/PCRE/Wrap.hsc
@@ -1,490 +0,0 @@--- The exported symbols are the same whether HAVE_PCRE_H is defined,--- but when if it is not defined then 'getVersion == Nothing' and all--- other exported values will call error or fail.---- | This will fail or error only if allocation fails or a nullPtr is passed in.---- TODO :: Consider wrapMatchAll using list of start/end offsets and not MatchArray-----{- Copyright : (c) Chris Kuklewicz 2007 -}-module Text.Regex.PCRE.Wrap(- -- ** High-level interface- Regex,- CompOption(CompOption),- ExecOption(ExecOption),- (=~),- (=~~),-- -- ** Low-level interface- StartOffset,- EndOffset,- ReturnCode(ReturnCode),- WrapError,- wrapCompile,- wrapTest,- wrapMatch,- wrapMatchAll,- wrapCount,-- -- ** Miscellaneous- getVersion,- configUTF8,- getNumSubs,- unusedOffset,-- -- ** CompOption values- compBlank,- compAnchored,- compAutoCallout,- compCaseless,- compDollarEndOnly,- compDotAll,- compExtended,- compExtra,- compFirstLine,- compMultiline,- compNoAutoCapture,- compUngreedy,- compUTF8,- compNoUTF8Check,-- -- ** ExecOption values- execBlank,- execAnchored,- execNotBOL,- execNotEOL,- execNotEmpty,- execNoUTF8Check,- execPartial,-- -- ** ReturnCode values- retOk,- retNoMatch,- retNull,- retBadOption,- retBadMagic,- retUnknownNode,- retNoMemory,- retNoSubstring- ) where--import Control.Monad.Fail (MonadFail)-#if defined(HAVE_PCRE_H)-import Control.Monad(when)-import Data.Array(Array,accumArray)-import Data.Bits(Bits((.|.))) -- ((.&.),(.|.),complement))-import System.IO.Unsafe(unsafePerformIO)-import Foreign(Ptr,ForeignPtr,FinalizerPtr -- ,FunPtr- ,alloca,allocaBytes,nullPtr- ,peek,peekElemOff- ,newForeignPtr,withForeignPtr)-import Foreign.C(CInt(..),CChar)-import Foreign.C.String(CString,CStringLen,peekCString)-import Text.Regex.Base.RegexLike(RegexOptions(..),RegexMaker(..),RegexContext(..),MatchArray,MatchOffset)-#else-import Data.Array(Array)-import Data.Bits(Bits)-import Foreign(ForeignPtr)-import Foreign.C.String(CString,CStringLen)-import Text.Regex.Base.RegexLike(RegexOptions(..),RegexMaker(..),RegexContext(..),MatchArray,MatchOffset)-#endif----- | return version of pcre used or Nothing if pcre is not available.-getVersion :: Maybe String--type PCRE = ()-type StartOffset = MatchOffset-type EndOffset = MatchOffset-type WrapError = (ReturnCode,String)--newtype CompOption = CompOption CInt deriving (Eq,Show,Num,Bits)-newtype ExecOption = ExecOption CInt deriving (Eq,Show,Num,Bits)-newtype ReturnCode = ReturnCode CInt deriving (Eq,Show)---- | A compiled regular expression-data Regex = Regex (ForeignPtr PCRE) CompOption ExecOption--compBlank :: CompOption-execBlank :: ExecOption-unusedOffset :: MatchOffset-retOk :: ReturnCode--wrapCompile :: CompOption -- ^ Flags (summed together)- -> ExecOption -- ^ Flags (summed together)- -> CString -- ^ The regular expression to compile- -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: an error offset and string or the compiled regular expression-wrapTest :: StartOffset -- ^ Starting index in CStringLen- -> Regex -- ^ Compiled regular expression- -> CStringLen -- ^ String to match against and length in bytes- -> IO (Either WrapError Bool)-wrapMatch :: StartOffset -- ^ Starting index in CStringLen- -> Regex -- ^ Compiled regular expression- -> CStringLen -- ^ String to match against and length in bytes- -> IO (Either WrapError (Maybe [(StartOffset,EndOffset)]))- -- ^ Returns: 'Right Nothing' if the regex did not match the- -- string, or:- -- 'Right Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions, or:- -- 'Left ReturnCode' if there is some strange error-wrapMatchAll :: Regex -> CStringLen -> IO (Either WrapError [ MatchArray ])-wrapCount :: Regex -> CStringLen -> IO (Either WrapError Int)--getNumSubs :: Regex -> Int-configUTF8 :: Bool--(=~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target)- => source1 -> source -> target-(=~~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target,MonadFail m)- => source1 -> source -> m target--#if defined(HAVE_PCRE_H)-#include <sys/types.h>-#include <pcre.h>--instance RegexOptions Regex CompOption ExecOption where- blankCompOpt = compBlank- blankExecOpt = execBlank- defaultCompOpt = compMultiline- defaultExecOpt = execBlank- setExecOpts e' (Regex r c _) = Regex r c e'- getExecOpts (Regex _ _ e) = e---- (=~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target) => source1 -> source -> target-(=~) x r = let q :: Regex- q = makeRegex r- in match q x---- (=~~) ::(RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target,Monad m) => source1 -> source -> m target-(=~~) x r = do (q :: Regex) <- makeRegexM r- matchM q x--type PCRE_Extra = ()--fi :: (Integral i,Num n ) => i -> n-fi x = fromIntegral x--compBlank = CompOption 0-execBlank = ExecOption 0-unusedOffset = (-1)-retOk = ReturnCode 0--retNeededMoreSpace :: ReturnCode-retNeededMoreSpace = ReturnCode 0--newtype InfoWhat = InfoWhat CInt deriving (Eq,Show)-newtype ConfigWhat = ConfigWhat CInt deriving (Eq,Show)--nullTest' :: Ptr a -> String -> IO (Either (MatchOffset,String) b) -> IO (Either (MatchOffset,String) b)-{-# INLINE nullTest' #-}-nullTest' ptr msg io = do- if nullPtr == ptr- then return (Left (0,"Ptr parameter was nullPtr in Text.Regex.PCRE.Wrap."++msg)) - else io--nullTest :: Ptr a -> String -> IO (Either WrapError b) -> IO (Either WrapError b)-{-# INLINE nullTest #-}-nullTest ptr msg io = do- if nullPtr == ptr- then return (Left (retOk,"Ptr parameter was nullPtr in Text.Regex.PCRE.Wrap."++msg)) - else io--wrapRC :: ReturnCode -> IO (Either WrapError b)-{-# INLINE wrapRC #-}-wrapRC r = return (Left (r,"Error in Text.Regex.PCRE.Wrap: "++show r))---- | Compiles a regular expression-wrapCompile flags e pattern = do- nullTest' pattern "wrapCompile pattern" $ do- alloca $ \errOffset -> alloca $ \errPtr -> do- nullTest' errPtr "wrapCompile errPtr" $ do- pcre_ptr <- c_pcre_compile pattern flags errPtr errOffset nullPtr- if pcre_ptr == nullPtr- then do- -- No need to use c_ptr_free in the error case (e.g. pcredemo.c)- offset <- peek errOffset- string <- peekCString =<< peek errPtr- return (Left (fi offset,string))- else do regex <- newForeignPtr c_ptr_free pcre_ptr- return . Right $ Regex regex flags e--getNumSubs (Regex pcre_fptr _ _) = fi . unsafePerformIO $ withForeignPtr pcre_fptr getNumSubs'--getNumSubs' :: Ptr PCRE -> IO CInt-{-# INLINE getNumSubs' #-}-getNumSubs' pcre_ptr =- alloca $ \st -> do -- (st :: Ptr CInt)- when (st == nullPtr) (fail "Text.Regex.PCRE.Wrap.getNumSubs' could not allocate a CInt!!!")- c_pcre_fullinfo pcre_ptr nullPtr pcreInfoCapturecount st- peek st--wrapTest startOffset (Regex pcre_fptr _ flags) (cstr,len) = do- nullTest cstr "wrapTest cstr" $ do- withForeignPtr pcre_fptr $ \pcre_ptr -> do- r@(ReturnCode r') <- c_pcre_exec pcre_ptr nullPtr cstr (fi len) (fi startOffset) flags nullPtr 0- if r == retNoMatch- then return (Right False)- else if r' < 0- then wrapRC r- else return (Right True)---- | Matches a regular expression against a string------ Should never return (Right (Just []))-wrapMatch startOffset (Regex pcre_fptr _ flags) (cstr,len) = do- nullTest cstr "wrapMatch cstr" $ do- withForeignPtr pcre_fptr $ \pcre_ptr -> do- nsub <- getNumSubs' pcre_ptr- let nsub_int :: Int- nsub_int = fi nsub- ovec_size :: CInt- ovec_size = ((nsub + 1) * 3) -- "man pcreapi" for explanation- ovec_bytes :: Int- ovec_bytes = (fi ovec_size) * (#const sizeof(int))- allocaBytes ovec_bytes $ \ovec -> do- nullTest ovec "wrapMatch ovec" $ do- r@(ReturnCode r') <- c_pcre_exec pcre_ptr nullPtr cstr (fi len) (fi startOffset) flags ovec ovec_size- if r == retNoMatch- then return (Right Nothing)- else if r' < 0- then wrapRC r- else do- let pairsSet :: Int- pairsSet = if r == retNeededMoreSpace -- if r == ReturnCode 0- then nsub_int + 1 -- should not happen- else fi r' -- implies pairsSet > 0- extraPairs :: [(Int,Int)]- extraPairs = replicate (nsub_int + 1 - pairsSet)- (unusedOffset,unusedOffset)- pairs <- return . toPairs =<< mapM (peekElemOff ovec) [0 .. ((pairsSet*2)-1)]- return . Right . Just $ (pairs ++ extraPairs)---- | wrapMatchAll is an improvement over wrapMatch since it only--- allocates memory with allocaBytes once at the start.--- --- -wrapMatchAll (Regex pcre_fptr _ flags) (cstr,len) = do- nullTest cstr "wrapMatchAll cstr" $ do- withForeignPtr pcre_fptr $ \regex -> do- nsub <- getNumSubs' regex- let nsub_int :: Int- nsub_int = fi nsub- ovec_size :: CInt- ovec_size = ((nsub + 1) * 3) -- "man pcreapi" for explanation- ovec_bytes :: Int- ovec_bytes = (fi ovec_size) * (#const sizeof(int))- clen = fi len- flags' = (execNotEmpty .|. execAnchored .|. flags)- allocaBytes ovec_bytes $ \ovec ->- nullTest ovec "wrapMatchAll ovec" $- let loop acc flags_in_use pos = do- r@(ReturnCode r') <- c_pcre_exec regex nullPtr cstr clen (fi pos) flags_in_use ovec ovec_size- if r == retNoMatch- then return (Right (acc []))- else if r' < 0- then wrapRC r- else do- let pairsSet = if r == retNeededMoreSpace then nsub_int+1 else fi r'- pairs <- return . toPairs =<< mapM (peekElemOff ovec) [0 .. ((pairsSet*2)-1)]- let acc' = acc . (toMatchArray nsub_int pairs:)- case pairs of- [] -> return (Right (acc' []))- ((s,e):_) | s==e -> if s == len - then return (Right (acc' []))- else loop acc' flags' e- | otherwise -> loop acc' flags e- in loop id flags 0-toMatchArray :: Int -> [(Int,Int)] -> Array Int (Int,Int)-toMatchArray n pairs = accumArray (\_ (s,e) -> (s,(e-s))) (-1,0) (0,n) (zip [0..] pairs)--toPairs :: [CInt] -> [(Int,Int)]-toPairs [] = []-toPairs (a:b:rest) = (fi a,fi b):toPairs rest-toPairs [_] = error "Should not have just one element in WrapPCRE.wrapMatchAll.toPairs"--wrapCount (Regex pcre_fptr _ flags) (cstr,len) = do- nullTest cstr "wrapCount cstr" $ do- withForeignPtr pcre_fptr $ \pcre_ptr -> do- nsub <- getNumSubs' pcre_ptr- let ovec_size :: CInt- ovec_size = ((nsub + 1) * 3) -- "man pcreapi" for explanation- ovec_bytes :: Int- ovec_bytes = (fi ovec_size) * (#const sizeof(int))- clen = fi len- allocaBytes ovec_bytes $ \ovec ->- nullTest ovec "wrapCount ovec" $- let act pos = c_pcre_exec pcre_ptr nullPtr cstr clen (fi pos) flags ovec ovec_size- loop acc pos | acc `seq` pos `seq` False = undefined- | otherwise = do- r@(ReturnCode r') <- act pos- if r == retNoMatch- then return (Right acc)- else if r' < 0- then wrapRC r- else do- pairs <- return . toPairs =<< mapM (peekElemOff ovec) [0,1]- case pairs of- [] -> return (Right (succ acc))- ((s,e):_) | s==e -> return (Right (succ acc))- | otherwise -> loop (succ acc) e- in loop 0 0--getVersion = unsafePerformIO $ do- version <- c_pcre_version- if version == nullPtr- then return (Just "pcre_version was null")- else return . Just =<< peekCString version--configUTF8 = unsafePerformIO $- alloca $ \ptrVal -> do -- (ptrVal :: Ptr CInt)- when (ptrVal == nullPtr) (fail "Text.Regex.PCRE.Wrap.configUTF8 could not alloca CInt!!!")- c_pcre_config pcreConfigUtf8 ptrVal- val <- peek ptrVal- case val of- (1 :: CInt) -> return True- 0 -> return False- _ -> return False -- should not happen--foreign import ccall unsafe "pcre.h pcre_compile"- c_pcre_compile :: CString -> CompOption -> Ptr CString -> Ptr CInt -> CString -> IO (Ptr PCRE)-foreign import ccall unsafe "&free"- c_ptr_free :: FinalizerPtr a -- FunPtr (Ptr a -> IO ())-foreign import ccall unsafe "pcre.h pcre_exec"- c_pcre_exec :: Ptr PCRE -> Ptr PCRE_Extra -> CString -> CInt -> CInt -> ExecOption -> Ptr CInt -> CInt -> IO ReturnCode-foreign import ccall unsafe "pcre.h pcre_fullinfo"- c_pcre_fullinfo :: Ptr PCRE -> Ptr PCRE_Extra -> InfoWhat -> Ptr a -> IO CInt-foreign import ccall unsafe "pcre.h pcre_version"- c_pcre_version :: IO (Ptr CChar)-foreign import ccall unsafe "pcre.h pcre_config"- c_pcre_config :: ConfigWhat -> Ptr a -> IO CInt---#enum CompOption,CompOption, \- compAnchored = PCRE_ANCHORED, \- compAutoCallout = PCRE_AUTO_CALLOUT, \- compCaseless = PCRE_CASELESS, \- compDollarEndOnly = PCRE_DOLLAR_ENDONLY, \- compDotAll = PCRE_DOTALL, \- compExtended = PCRE_EXTENDED, \- compExtra = PCRE_EXTRA, \- compFirstLine = PCRE_FIRSTLINE, \- compMultiline = PCRE_MULTILINE, \- compNoAutoCapture = PCRE_NO_AUTO_CAPTURE, \- compUngreedy = PCRE_UNGREEDY, \- compUTF8 = PCRE_UTF8, \- compNoUTF8Check = PCRE_NO_UTF8_CHECK--#enum ExecOption,ExecOption, \- execAnchored = PCRE_ANCHORED, \- execNotBOL = PCRE_NOTBOL, \- execNotEOL = PCRE_NOTEOL, \- execNotEmpty = PCRE_NOTEMPTY, \- execNoUTF8Check = PCRE_NO_UTF8_CHECK, \- execPartial = PCRE_PARTIAL--#enum ReturnCode,ReturnCode, \- retNoMatch = PCRE_ERROR_NOMATCH, \- retNull = PCRE_ERROR_NULL, \- retBadOption = PCRE_ERROR_BADOPTION, \- retBadMagic = PCRE_ERROR_BADMAGIC, \- retUnknownNode = PCRE_ERROR_UNKNOWN_NODE, \- retNoMemory = PCRE_ERROR_NOMEMORY, \- retNoSubstring = PCRE_ERROR_NOSUBSTRING---- Comment out most of these to avoid unused binding warnings---- PCRE_INFO_FIRSTCHAR is deprecated, use PCRE_INFO_FIRSTBYTE instead.-#enum InfoWhat,InfoWhat, \- PCRE_INFO_CAPTURECOUNT-{-- PCRE_INFO_BACKREFMAX, \- PCRE_INFO_DEFAULT_TABLES, \- PCRE_INFO_FIRSTBYTE, \- PCRE_INFO_FIRSTCHAR, \- PCRE_INFO_FIRSTTABLE, \- PCRE_INFO_LASTLITERAL, \- PCRE_INFO_NAMECOUNT, \- PCRE_INFO_NAMEENTRYSIZE, \- PCRE_INFO_NAMETABLE, \- PCRE_INFO_OPTIONS, \- PCRE_INFO_SIZE, \- PCRE_INFO_STUDYSIZE--}-#enum ConfigWhat,ConfigWhat, \- PCRE_CONFIG_UTF8-{-- PCRE_CONFIG_UNICODE_PROPERTIES, \- PCRE_CONFIG_NEWLINE, \- PCRE_CONFIG_LINK_SIZE, \- PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, \- PCRE_CONFIG_MATCH_LIMIT, \- PCRE_CONFIG_MATCH_LIMIT_RECURSION, \- PCRE_CONFIG_STACKRECURSE--}--#else /* do not HAVE_PCRE_H */--instance RegexOptions Regex CompOption ExecOption where- blankCompOpt = err- blankExecOpt = err- defaultCompOpt = err- defaultExecOpt = err- getExecOpts = err- setExecOpts = err--msg :: String-msg = "WrapPCRE.hsc was not compiled against pcre library with HAVE_PCRE_H defined"-err :: a-err = error msg--(=~) = err-(=~~) = err---- Hack to avoid the constructor from being unused-wrapCompile _ _ _ = err >> return (Right (Regex err err err))-wrapTest = err-wrapMatch = err-wrapMatchAll = err-wrapCount = err--compAnchored, compAutoCallout, compCaseless, compDollarEndOnly, compDotAll, compExtended, compExtra, compFirstLine, compMultiline, compNoAutoCapture, compUngreedy, compUTF8, compNoUTF8Check :: CompOption-compBlank = err-compAnchored = err-compAutoCallout = err-compCaseless = err-compDollarEndOnly = err-compDotAll = err-compExtended = err-compExtra = err-compFirstLine = err-compMultiline = err-compNoAutoCapture = err-compUngreedy = err-compUTF8 = err-compNoUTF8Check = err--execAnchored, execNotBOL, execNotEOL, execNotEmpty, execNoUTF8Check, execPartial :: ExecOption -execBlank = err-execAnchored = err-execNotBOL = err-execNotEOL = err-execNotEmpty = err-execNoUTF8Check = err-execPartial = err--retNoMatch, retNull, retBadOption, retBadMagic, retUnknownNode, retNoMemory, retNoSubstring :: ReturnCode -retNoMatch = err-retNull = err-retBadOption = err-retBadMagic = err-retUnknownNode = err-retNoMemory = err-retNoSubstring = err--getNumSubs = err-unusedOffset = err-configUTF8 = err--getVersion = Nothing--#endif /* HAVE_PCRE_H */
pcre/config.h view
@@ -74,6 +74,7 @@ /* Define to 1 if you have the <inttypes.h> header file. */ /* #undef HAVE_INTTYPES_H */+#define HAVE_INTTYPES_H 1 /* Define to 1 if you have the <limits.h> header file. */ /* #undef HAVE_LIMITS_H */@@ -101,9 +102,11 @@ /* Define to 1 if you have the <stdint.h> header file. */ /* #undef HAVE_STDINT_H */+#define HAVE_STDINT_H 1 /* Define to 1 if you have the <stdlib.h> header file. */ /* #undef HAVE_STDLIB_H */+#define HAVE_STDLIB_H 1 /* Define to 1 if you have the `strerror' function. */ /* #undef HAVE_STRERROR */@@ -158,16 +161,10 @@ 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. */-#ifndef LINK_SIZE #define LINK_SIZE 2-#endif -/* Define to the sub-directory in which libtool stores uninstalled libraries.- */-/* This is ignored unless you are using libtool. */-#ifndef LT_OBJDIR+/* Define to the sub-directory where libtool stores uninstalled libraries. */ #define LT_OBJDIR ".libs/"-#endif /* The value of MATCH_LIMIT determines the default number of times the internal match() function can be called during a single execution of@@ -175,9 +172,7 @@ 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. */-#ifndef MATCH_LIMIT #define MATCH_LIMIT 10000000-#endif /* 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@@ -187,23 +182,17 @@ match(). To have any useful effect, it must be less than the value of MATCH_LIMIT. The default is to use the same value as MATCH_LIMIT. There is a runtime method for setting a different limit. */-#ifndef MATCH_LIMIT_RECURSION #define MATCH_LIMIT_RECURSION MATCH_LIMIT-#endif /* This limit is parameterized just in case anybody ever wants to change it. Care must be taken if it is increased, because it guards against integer overflow caused by enormously large patterns. */-#ifndef MAX_NAME_COUNT #define MAX_NAME_COUNT 10000-#endif /* This limit is parameterized just in case anybody ever wants to change it. Care must be taken if it is increased, because it guards against integer overflow caused by enormously large patterns. */-#ifndef MAX_NAME_SIZE #define MAX_NAME_SIZE 32-#endif /* The value of NEWLINE determines the default newline character sequence. PCRE client programs can override this by selecting other values at run@@ -213,9 +202,7 @@ 0x25) that are used as the NL line terminator that is equivalent to ASCII LF. In both ASCII and EBCDIC environments the value can also be -1 (ANY), or -2 (ANYCRLF). */-#ifndef NEWLINE #define NEWLINE 10-#endif /* PCRE uses recursive function calls to handle backtracking while matching. This can sometimes be a problem on systems that have stacks of limited@@ -236,7 +223,7 @@ #define PACKAGE_NAME "PCRE" /* Define to the full name and version of this package. */-#define PACKAGE_STRING "PCRE 8.34"+#define PACKAGE_STRING "PCRE 8.43" /* Define to the one symbol short name of this package. */ #define PACKAGE_TARNAME "pcre"@@ -245,23 +232,19 @@ #define PACKAGE_URL "" /* Define to the version of this package. */-#define PACKAGE_VERSION "8.34"+#define PACKAGE_VERSION "8.43" /* The value of PARENS_NEST_LIMIT specifies the maximum depth of nested parentheses (of any kind) in a pattern. This limits the amount of system stack that is used while compiling a pattern. */-#ifndef PARENS_NEST_LIMIT #define PARENS_NEST_LIMIT 250-#endif /* The value of PCREGREP_BUFSIZE determines the size of buffer used by pcregrep to hold parts of the file it is searching. This is also the minimum value. The actual amount of memory used by pcregrep is three times this number, because it allows for the buffering of "before" and "after" lines. */-#ifndef PCREGREP_BUFSIZE #define PCREGREP_BUFSIZE 20480-#endif /* If you are compiling for a system other than a Unix-like system or Win32, and it needs some magic to be inserted before the definition@@ -276,6 +259,7 @@ /* Define to any value if linking statically (TODO: make nice with Libtool) */ /* #undef PCRE_STATIC */+#define PCRE_STATIC 1 /* When calling PCRE via the POSIX interface, additional working storage is required for holding the pointers to capturing substrings because PCRE@@ -284,9 +268,7 @@ function uses space on the stack, because this is faster than using malloc() for each call. The threshold above which the stack is no longer used is defined by POSIX_MALLOC_THRESHOLD. */-#ifndef POSIX_MALLOC_THRESHOLD #define POSIX_MALLOC_THRESHOLD 10-#endif /* Define to necessary symbol if this constant uses a non-standard name on your system. */@@ -337,7 +319,7 @@ /* #undef SUPPORT_VALGRIND */ /* Version number of package */-#define VERSION "8.34"+#define VERSION "8.43" /* Define to empty if `const' does not conform to ANSI C. */ /* #undef const */
pcre/pcre.h view
@@ -5,7 +5,7 @@ /* This is the public header file for the PCRE library, to be #included by applications that call the PCRE functions. - Copyright (c) 1997-2013 University of Cambridge+ Copyright (c) 1997-2014 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without@@ -42,9 +42,9 @@ /* The current PCRE version information. */ #define PCRE_MAJOR 8-#define PCRE_MINOR 34+#define PCRE_MINOR 43 #define PCRE_PRERELEASE -#define PCRE_DATE 2013-12-15+#define PCRE_DATE 2019-02-23 /* When an application links to a PCRE DLL in Windows, the symbols that are imported have to be identified as such. When building PCRE, the appropriate@@ -321,11 +321,11 @@ /* Types */ -struct real_pcre; /* declaration; the definition is private */-typedef struct real_pcre pcre;+struct real_pcre8_or_16; /* declaration; the definition is private */+typedef struct real_pcre8_or_16 pcre; -struct real_pcre16; /* declaration; the definition is private */-typedef struct real_pcre16 pcre16;+struct real_pcre8_or_16; /* declaration; the definition is private */+typedef struct real_pcre8_or_16 pcre16; struct real_pcre32; /* declaration; the definition is private */ typedef struct real_pcre32 pcre32;@@ -491,36 +491,42 @@ PCRE_EXP_DECL void *(*pcre_stack_malloc)(size_t); PCRE_EXP_DECL void (*pcre_stack_free)(void *); PCRE_EXP_DECL int (*pcre_callout)(pcre_callout_block *);+PCRE_EXP_DECL int (*pcre_stack_guard)(void); PCRE_EXP_DECL void *(*pcre16_malloc)(size_t); PCRE_EXP_DECL void (*pcre16_free)(void *); PCRE_EXP_DECL void *(*pcre16_stack_malloc)(size_t); PCRE_EXP_DECL void (*pcre16_stack_free)(void *); PCRE_EXP_DECL int (*pcre16_callout)(pcre16_callout_block *);+PCRE_EXP_DECL int (*pcre16_stack_guard)(void); PCRE_EXP_DECL void *(*pcre32_malloc)(size_t); PCRE_EXP_DECL void (*pcre32_free)(void *); PCRE_EXP_DECL void *(*pcre32_stack_malloc)(size_t); PCRE_EXP_DECL void (*pcre32_stack_free)(void *); PCRE_EXP_DECL int (*pcre32_callout)(pcre32_callout_block *);+PCRE_EXP_DECL int (*pcre32_stack_guard)(void); #else /* VPCOMPAT */ PCRE_EXP_DECL void *pcre_malloc(size_t); PCRE_EXP_DECL void pcre_free(void *); PCRE_EXP_DECL void *pcre_stack_malloc(size_t); PCRE_EXP_DECL void pcre_stack_free(void *); PCRE_EXP_DECL int pcre_callout(pcre_callout_block *);+PCRE_EXP_DECL int pcre_stack_guard(void); PCRE_EXP_DECL void *pcre16_malloc(size_t); PCRE_EXP_DECL void pcre16_free(void *); PCRE_EXP_DECL void *pcre16_stack_malloc(size_t); PCRE_EXP_DECL void pcre16_stack_free(void *); PCRE_EXP_DECL int pcre16_callout(pcre16_callout_block *);+PCRE_EXP_DECL int pcre16_stack_guard(void); PCRE_EXP_DECL void *pcre32_malloc(size_t); PCRE_EXP_DECL void pcre32_free(void *); PCRE_EXP_DECL void *pcre32_stack_malloc(size_t); PCRE_EXP_DECL void pcre32_stack_free(void *); PCRE_EXP_DECL int pcre32_callout(pcre32_callout_block *);+PCRE_EXP_DECL int pcre32_stack_guard(void); #endif /* VPCOMPAT */ /* User defined callback which provides a stack just before the match starts. */
pcre/pcre_byte_order.c view
@@ -6,7 +6,7 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel- Copyright (c) 1997-2013 University of Cambridge+ Copyright (c) 1997-2014 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without@@ -311,9 +311,9 @@ ptr++; } /* Control should never reach here in 16/32 bit mode. */-#endif /* !COMPILE_PCRE8 */-+#else /* In 8-bit mode, the pattern does not need to be processed. */ return 0;+#endif /* !COMPILE_PCRE8 */ } /* End of pcre_byte_order.c */
pcre/pcre_chartables.c view
@@ -163,7 +163,7 @@ */ 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */- 0x00,0x01,0x01,0x00,0x01,0x01,0x00,0x00, /* 8- 15 */+ 0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /* 8- 15 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */ 0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /* - ' */
pcre/pcre_compile.c view
@@ -6,9428 +6,9800 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel- Copyright (c) 1997-2013 University of Cambridge--------------------------------------------------------------------------------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.-------------------------------------------------------------------------------*/---/* This module contains the external function pcre_compile(), along with-supporting internal functions that are not used by other modules. */---#ifdef HAVE_CONFIG_H-#include "config.h"-#endif--#define NLBLOCK cd /* Block containing newline information */-#define PSSTART start_pattern /* Field containing processed string start */-#define PSEND end_pattern /* Field containing processed string end */--#include "pcre_internal.h"---/* When PCRE_DEBUG is defined, we need the pcre(16|32)_printint() function, which-is also used by pcretest. PCRE_DEBUG is not defined when building a production-library. We do not need to select pcre16_printint.c specially, because the-COMPILE_PCREx macro will already be appropriately set. */--#ifdef PCRE_DEBUG-/* pcre_printint.c should not include any headers */-#define PCRE_INCLUDED-#include "pcre_printint.c"-#undef PCRE_INCLUDED-#endif---/* Macro for setting individual bits in class bitmaps. */--#define SETBIT(a,b) a[(b)/8] |= (1 << ((b)&7))--/* Maximum length value to check against when making sure that the integer that-holds the compiled pattern length does not overflow. We make it a bit less than-INT_MAX to allow for adding in group terminating bytes, so that we don't have-to check them every time. */--#define OFLOW_MAX (INT_MAX - 20)--/* Definitions to allow mutual recursion */--static int- add_list_to_class(pcre_uint8 *, pcre_uchar **, int, compile_data *,- const pcre_uint32 *, unsigned int);--static BOOL- compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,- pcre_uint32 *, pcre_int32 *, pcre_uint32 *, pcre_int32 *, branch_chain *,- compile_data *, int *);----/*************************************************-* Code parameters and static tables *-*************************************************/--/* This value specifies the size of stack workspace that is used during the-first pre-compile phase that determines how much memory is required. The regex-is partly compiled into this space, but the compiled parts are discarded as-soon as they can be, so that hopefully there will never be an overrun. The code-does, however, check for an overrun. The largest amount I've seen used is 218,-so this number is very generous.--The same workspace is used during the second, actual compile phase for-remembering forward references to groups so that they can be filled in at the-end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE-is 4 there is plenty of room for most patterns. However, the memory can get-filled up by repetitions of forward references, for example patterns like-/(?1){0,1999}(b)/, and one user did hit the limit. The code has been changed so-that the workspace is expanded using malloc() in this situation. The value-below is therefore a minimum, and we put a maximum on it for safety. The-minimum is now also defined in terms of LINK_SIZE so that the use of malloc()-kicks in at the same number of forward references in all cases. */--#define COMPILE_WORK_SIZE (2048*LINK_SIZE)-#define COMPILE_WORK_SIZE_MAX (100*COMPILE_WORK_SIZE)--/* This value determines the size of the initial vector that is used for-remembering named groups during the pre-compile. It is allocated on the stack,-but if it is too small, it is expanded using malloc(), in a similar way to the-workspace. The value is the number of slots in the list. */--#define NAMED_GROUP_LIST_SIZE 20--/* The overrun tests check for a slightly smaller size so that they detect the-overrun before it actually does run off the end of the data block. */--#define WORK_SIZE_SAFETY_MARGIN (100)--/* Private flags added to firstchar and reqchar. */--#define REQ_CASELESS (1 << 0) /* Indicates caselessness */-#define REQ_VARY (1 << 1) /* Reqchar followed non-literal item */-/* Negative values for the firstchar and reqchar flags */-#define REQ_UNSET (-2)-#define REQ_NONE (-1)--/* Repeated character flags. */--#define UTF_LENGTH 0x10000000l /* The char contains its length. */--/* Table for handling escaped characters in the range '0'-'z'. Positive returns-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. */--#ifndef EBCDIC--/* This is the "normal" table for ASCII systems or for EBCDIC systems running-in UTF-8 mode. */--static const short int escapes[] = {- 0, 0,- 0, 0,- 0, 0,- 0, 0,- 0, 0,- CHAR_COLON, CHAR_SEMICOLON,- CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN,- CHAR_GREATER_THAN_SIGN, CHAR_QUESTION_MARK,- CHAR_COMMERCIAL_AT, -ESC_A,- -ESC_B, -ESC_C,- -ESC_D, -ESC_E,- 0, -ESC_G,- -ESC_H, 0,- 0, -ESC_K,- 0, 0,- -ESC_N, 0,- -ESC_P, -ESC_Q,- -ESC_R, -ESC_S,- 0, 0,- -ESC_V, -ESC_W,- -ESC_X, 0,- -ESC_Z, CHAR_LEFT_SQUARE_BRACKET,- CHAR_BACKSLASH, CHAR_RIGHT_SQUARE_BRACKET,- CHAR_CIRCUMFLEX_ACCENT, CHAR_UNDERSCORE,- CHAR_GRAVE_ACCENT, 7,- -ESC_b, 0,- -ESC_d, ESC_e,- ESC_f, 0,- -ESC_h, 0,- 0, -ESC_k,- 0, 0,- ESC_n, 0,- -ESC_p, 0,- ESC_r, -ESC_s,- ESC_tee, 0,- -ESC_v, -ESC_w,- 0, 0,- -ESC_z-};--#else--/* This is the "abnormal" table for EBCDIC systems without UTF-8 support. */--static const short int escapes[] = {-/* 48 */ 0, 0, 0, '.', '<', '(', '+', '|',-/* 50 */ '&', 0, 0, 0, 0, 0, 0, 0,-/* 58 */ 0, 0, '!', '$', '*', ')', ';', '~',-/* 60 */ '-', '/', 0, 0, 0, 0, 0, 0,-/* 68 */ 0, 0, '|', ',', '%', '_', '>', '?',-/* 70 */ 0, 0, 0, 0, 0, 0, 0, 0,-/* 78 */ 0, '`', ':', '#', '@', '\'', '=', '"',-/* 80 */ 0, 7, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0,-/* 88 */-ESC_h, 0, 0, '{', 0, 0, 0, 0,-/* 90 */ 0, 0, -ESC_k, 'l', 0, ESC_n, 0, -ESC_p,-/* 98 */ 0, ESC_r, 0, '}', 0, 0, 0, 0,-/* A0 */ 0, '~', -ESC_s, ESC_tee, 0,-ESC_v, -ESC_w, 0,-/* A8 */ 0,-ESC_z, 0, 0, 0, '[', 0, 0,-/* B0 */ 0, 0, 0, 0, 0, 0, 0, 0,-/* B8 */ 0, 0, 0, 0, 0, ']', '=', '-',-/* C0 */ '{',-ESC_A, -ESC_B, -ESC_C, -ESC_D,-ESC_E, 0, -ESC_G,-/* C8 */-ESC_H, 0, 0, 0, 0, 0, 0, 0,-/* D0 */ '}', 0, -ESC_K, 0, 0,-ESC_N, 0, -ESC_P,-/* D8 */-ESC_Q,-ESC_R, 0, 0, 0, 0, 0, 0,-/* E0 */ '\\', 0, -ESC_S, 0, 0,-ESC_V, -ESC_W, -ESC_X,-/* E8 */ 0,-ESC_Z, 0, 0, 0, 0, 0, 0,-/* F0 */ 0, 0, 0, 0, 0, 0, 0, 0,-/* F8 */ 0, 0, 0, 0, 0, 0, 0, 0-};-#endif---/* Table of special "verbs" like (*PRUNE). This is a short table, so it is-searched linearly. Put all the names into a single string, in order to reduce-the number of relocations when a shared library is dynamically linked. The-string is built from string macros so that it works in UTF-8 mode on EBCDIC-platforms. */--typedef struct verbitem {- int len; /* Length of verb name */- int op; /* Op when no arg, or -1 if arg mandatory */- int op_arg; /* Op when arg present, or -1 if not allowed */-} verbitem;--static const char verbnames[] =- "\0" /* Empty name is a shorthand for MARK */- STRING_MARK0- STRING_ACCEPT0- STRING_COMMIT0- STRING_F0- STRING_FAIL0- STRING_PRUNE0- STRING_SKIP0- STRING_THEN;--static const verbitem verbs[] = {- { 0, -1, OP_MARK },- { 4, -1, OP_MARK },- { 6, OP_ACCEPT, -1 },- { 6, OP_COMMIT, -1 },- { 1, OP_FAIL, -1 },- { 4, OP_FAIL, -1 },- { 5, OP_PRUNE, OP_PRUNE_ARG },- { 4, OP_SKIP, OP_SKIP_ARG },- { 4, OP_THEN, OP_THEN_ARG }-};--static const int verbcount = sizeof(verbs)/sizeof(verbitem);---/* Substitutes for [[:<:]] and [[:>:]], which mean start and end of word in-another regex library. */--static const pcre_uchar sub_start_of_word[] = {- CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,- CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w, CHAR_RIGHT_PARENTHESIS, '\0' };--static const pcre_uchar sub_end_of_word[] = {- CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,- CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w,- CHAR_RIGHT_PARENTHESIS, '\0' };---/* Tables of names of POSIX character classes and their lengths. The names are-now all in a single string, to reduce the number of relocations when a shared-library is dynamically loaded. The list of lengths is terminated by a zero-length entry. The first three must be alpha, lower, upper, as this is assumed-for handling case independence. The indices for graph, print, and punct are-needed, so identify them. */--static const char posix_names[] =- STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0- STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0- STRING_graph0 STRING_print0 STRING_punct0 STRING_space0- STRING_word0 STRING_xdigit;--static const pcre_uint8 posix_name_lengths[] = {- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };--#define PC_GRAPH 8-#define PC_PRINT 9-#define PC_PUNCT 10---/* Table of class bit maps for each POSIX class. Each class is formed from a-base map, with an optional addition or removal of another map. Then, for some-classes, there is some additional tweaking: for [:blank:] the vertical space-characters are removed, and for [:alpha:] and [:alnum:] the underscore-character is removed. The triples in the table consist of the base map offset,-second map offset or -1 if no second map, and a non-negative value for map-addition or a negative value for map subtraction (if there are two maps). The-absolute value of the third field has these meanings: 0 => no tweaking, 1 =>-remove vertical space characters, 2 => remove underscore. */--static const int posix_class_maps[] = {- cbit_word, cbit_digit, -2, /* alpha */- cbit_lower, -1, 0, /* lower */- cbit_upper, -1, 0, /* upper */- cbit_word, -1, 2, /* alnum - word without underscore */- cbit_print, cbit_cntrl, 0, /* ascii */- cbit_space, -1, 1, /* blank - a GNU extension */- cbit_cntrl, -1, 0, /* cntrl */- cbit_digit, -1, 0, /* digit */- cbit_graph, -1, 0, /* graph */- cbit_print, -1, 0, /* print */- cbit_punct, -1, 0, /* punct */- cbit_space, -1, 0, /* space */- cbit_word, -1, 0, /* word - a Perl extension */- cbit_xdigit,-1, 0 /* xdigit */-};--/* Table of substitutes for \d etc when PCRE_UCP is set. They are replaced by-Unicode property escapes. */--#ifdef SUPPORT_UCP-static const pcre_uchar string_PNd[] = {- CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,- CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_pNd[] = {- CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,- CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_PXsp[] = {- CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,- CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_pXsp[] = {- CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,- CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_PXwd[] = {- CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,- CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_pXwd[] = {- CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,- CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };--static const pcre_uchar *substitutes[] = {- string_PNd, /* \D */- string_pNd, /* \d */- string_PXsp, /* \S */ /* Xsp is Perl space, but from 8.34, Perl */- string_pXsp, /* \s */ /* space and POSIX space are the same. */- string_PXwd, /* \W */- string_pXwd /* \w */-};--/* The POSIX class substitutes must be in the order of the POSIX class names,-defined above, and there are both positive and negative cases. NULL means no-general substitute of a Unicode property escape (\p or \P). However, for some-POSIX classes (e.g. graph, print, punct) a special property code is compiled-directly. */--static const pcre_uchar string_pL[] = {- CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,- CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_pLl[] = {- CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,- CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_pLu[] = {- CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,- CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_pXan[] = {- CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,- CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_h[] = {- CHAR_BACKSLASH, CHAR_h, '\0' };-static const pcre_uchar string_pXps[] = {- CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,- CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_PL[] = {- CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,- CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_PLl[] = {- CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,- CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_PLu[] = {- CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,- CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_PXan[] = {- CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,- CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };-static const pcre_uchar string_H[] = {- CHAR_BACKSLASH, CHAR_H, '\0' };-static const pcre_uchar string_PXps[] = {- CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,- CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };--static const pcre_uchar *posix_substitutes[] = {- string_pL, /* alpha */- string_pLl, /* lower */- string_pLu, /* upper */- string_pXan, /* alnum */- NULL, /* ascii */- string_h, /* blank */- NULL, /* cntrl */- string_pNd, /* digit */- NULL, /* graph */- NULL, /* print */- NULL, /* punct */- string_pXps, /* space */ /* Xps is POSIX space, but from 8.34 */- string_pXwd, /* word */ /* Perl and POSIX space are the same */- NULL, /* xdigit */- /* Negated cases */- string_PL, /* ^alpha */- string_PLl, /* ^lower */- string_PLu, /* ^upper */- string_PXan, /* ^alnum */- NULL, /* ^ascii */- string_H, /* ^blank */- NULL, /* ^cntrl */- string_PNd, /* ^digit */- NULL, /* ^graph */- NULL, /* ^print */- NULL, /* ^punct */- string_PXps, /* ^space */ /* Xps is POSIX space, but from 8.34 */- string_PXwd, /* ^word */ /* Perl and POSIX space are the same */- NULL /* ^xdigit */-};-#define POSIX_SUBSIZE (sizeof(posix_substitutes) / sizeof(pcre_uchar *))-#endif--#define STRING(a) # a-#define XSTRING(s) STRING(s)--/* The texts of compile-time error messages. These are "char *" because they-are passed to the outside world. Do not ever re-use any error number, because-they are documented. Always add a new error instead. Messages marked DEAD below-are no longer used. This used to be a table of strings, but in order to reduce-the number of relocations needed when a shared library is loaded dynamically,-it is now one long string. We cannot use a table of offsets, because the-lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we-simply count through to the one we want - this isn't a performance issue-because these strings are used only when there is a compilation error.--Each substring ends with \0 to insert a null character. This includes the final-substring, so that the whole string ends with \0\0, which can be detected when-counting through. */--static const char error_texts[] =- "no error\0"- "\\ at end of pattern\0"- "\\c at end of pattern\0"- "unrecognized character follows \\\0"- "numbers out of order in {} quantifier\0"- /* 5 */- "number too big in {} quantifier\0"- "missing terminating ] for character class\0"- "invalid escape sequence in character class\0"- "range out of order in character class\0"- "nothing to repeat\0"- /* 10 */- "operand of unlimited repeat could match the empty string\0" /** DEAD **/- "internal error: unexpected repeat\0"- "unrecognized character after (? or (?-\0"- "POSIX named classes are supported only within a class\0"- "missing )\0"- /* 15 */- "reference to non-existent subpattern\0"- "erroffset passed as NULL\0"- "unknown option bit(s) set\0"- "missing ) after comment\0"- "parentheses nested too deeply\0" /** DEAD **/- /* 20 */- "regular expression is too large\0"- "failed to get memory\0"- "unmatched parentheses\0"- "internal error: code overflow\0"- "unrecognized character after (?<\0"- /* 25 */- "lookbehind assertion is not fixed length\0"- "malformed number or name after (?(\0"- "conditional group contains more than two branches\0"- "assertion expected after (?(\0"- "(?R or (?[+-]digits must be followed by )\0"- /* 30 */- "unknown POSIX class name\0"- "POSIX collating elements are not supported\0"- "this version of PCRE is compiled without UTF support\0"- "spare error\0" /** DEAD **/- "character value in \\x{} or \\o{} is too large\0"- /* 35 */- "invalid condition (?(0)\0"- "\\C not allowed in lookbehind assertion\0"- "PCRE does not support \\L, \\l, \\N{name}, \\U, or \\u\0"- "number after (?C is > 255\0"- "closing ) for (?C expected\0"- /* 40 */- "recursive call could loop indefinitely\0"- "unrecognized character after (?P\0"- "syntax error in subpattern name (missing terminator)\0"- "two named subpatterns have the same name\0"- "invalid UTF-8 string\0"- /* 45 */- "support for \\P, \\p, and \\X has not been compiled\0"- "malformed \\P or \\p sequence\0"- "unknown property name after \\P or \\p\0"- "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)\0"- "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")\0"- /* 50 */- "repeated subpattern is too long\0" /** DEAD **/- "octal value is greater than \\377 in 8-bit non-UTF-8 mode\0"- "internal error: overran compiling workspace\0"- "internal error: previously-checked referenced subpattern not found\0"- "DEFINE group contains more than one branch\0"- /* 55 */- "repeating a DEFINE group is not allowed\0" /** DEAD **/- "inconsistent NEWLINE options\0"- "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"- "a numbered reference must not be zero\0"- "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0"- /* 60 */- "(*VERB) not recognized or malformed\0"- "number is too big\0"- "subpattern name expected\0"- "digit expected after (?+\0"- "] is an invalid data character in JavaScript compatibility mode\0"- /* 65 */- "different names for subpatterns of the same number are not allowed\0"- "(*MARK) must have an argument\0"- "this version of PCRE is not compiled with Unicode property support\0"- "\\c must be followed by an ASCII character\0"- "\\k is not followed by a braced, angle-bracketed, or quoted name\0"- /* 70 */- "internal error: unknown opcode in find_fixedlength()\0"- "\\N is not supported in a class\0"- "too many forward references\0"- "disallowed Unicode code point (>= 0xd800 && <= 0xdfff)\0"- "invalid UTF-16 string\0"- /* 75 */- "name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)\0"- "character value in \\u.... sequence is too large\0"- "invalid UTF-32 string\0"- "setting UTF is disabled by the application\0"- "non-hex character in \\x{} (closing brace missing?)\0"- /* 80 */- "non-octal character in \\o{} (closing brace missing?)\0"- "missing opening brace after \\o\0"- "parentheses are too deeply nested\0"- "invalid range in character class\0"- "group name must start with a non-digit\0"- ;--/* Table to identify digits and 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-a private table here. It costs 256 bytes, but it is a lot faster than doing-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:-- 0x04 decimal digit- 0x08 hexadecimal digit--Then we can use ctype_digit and ctype_xdigit in the code. */--/* Using a simple comparison for decimal numbers rather than a memory read-is much faster, and the resulting code is simpler (the compiler turns it-into a subtraction and unsigned comparison). */--#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9)--#ifndef EBCDIC--/* This is the "normal" case, for ASCII systems, and EBCDIC systems running in-UTF-8 mode. */--static const pcre_uint8 digitab[] =- {- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - ' */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ( - / */- 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 */- 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /* 8 - ? */- 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* @ - G */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H - O */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* P - W */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* X - _ */- 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* ` - g */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h - o */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* p - w */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* x -127 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */--#else--/* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */--static const pcre_uint8 digitab[] =- {- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 0 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 10 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 32- 39 20 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 30 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 40 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 72- | */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 50 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 88- 95 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 60 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ? */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */- 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g 80 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p 90 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x A0 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 B0 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */- 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* { - G C0 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* } - P D0 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* \ - X E0 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */- 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 F0 */- 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */--static const pcre_uint8 ebcdic_chartab[] = { /* chartable partial dup */- 0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 0- 7 */- 0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /* 8- 15 */- 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 16- 23 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */- 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 32- 39 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */- 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 */- 0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /* 72- | */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 */- 0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /* 88- 95 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 */- 0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ? */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */- 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */- 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g */- 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */- 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p */- 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */- 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x */- 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */- 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 */- 0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */- 0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* { - G */- 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */- 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* } - P */- 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */- 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* \ - X */- 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */- 0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */- 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */-#endif---/* This table is used to check whether auto-possessification is possible-between adjacent character-type opcodes. The left-hand (repeated) opcode is-used to select the row, and the right-hand opcode is use to select the column.-A value of 1 means that auto-possessification is OK. For example, the second-value in the first row means that \D+\d can be turned into \D++\d.--The Unicode property types (\P and \p) have to be present to fill out the table-because of what their opcode values are, but the table values should always be-zero because property types are handled separately in the code. The last four-columns apply to items that cannot be repeated, so there is no need to have-rows for them. Note that OP_DIGIT etc. are generated only when PCRE_UCP is-*not* set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */--#define APTROWS (LAST_AUTOTAB_LEFT_OP - FIRST_AUTOTAB_OP + 1)-#define APTCOLS (LAST_AUTOTAB_RIGHT_OP - FIRST_AUTOTAB_OP + 1)--static const pcre_uint8 autoposstab[APTROWS][APTCOLS] = {-/* \D \d \S \s \W \w . .+ \C \P \p \R \H \h \V \v \X \Z \z $ $M */- { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \D */- { 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \d */- { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \S */- { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \s */- { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \W */- { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \w */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* . */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* .+ */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \C */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* \P */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* \p */- { 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }, /* \R */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }, /* \H */- { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0 }, /* \h */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0 }, /* \V */- { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0 }, /* \v */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 } /* \X */-};---/* This table is used to check whether auto-possessification is possible-between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP). The-left-hand (repeated) opcode is used to select the row, and the right-hand-opcode is used to select the column. The values are as follows:-- 0 Always return FALSE (never auto-possessify)- 1 Character groups are distinct (possessify if both are OP_PROP)- 2 Check character categories in the same group (general or particular)- 3 TRUE if the two opcodes are not the same (PROP vs NOTPROP)-- 4 Check left general category vs right particular category- 5 Check right general category vs left particular category-- 6 Left alphanum vs right general category- 7 Left space vs right general category- 8 Left word vs right general category-- 9 Right alphanum vs left general category- 10 Right space vs left general category- 11 Right word vs left general category-- 12 Left alphanum vs right particular category- 13 Left space vs right particular category- 14 Left word vs right particular category-- 15 Right alphanum vs left particular category- 16 Right space vs left particular category- 17 Right word vs left particular category-*/--static const pcre_uint8 propposstab[PT_TABSIZE][PT_TABSIZE] = {-/* ANY LAMP GC PC SC ALNUM SPACE PXSPACE WORD CLIST UCNC */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* PT_ANY */- { 0, 3, 0, 0, 0, 3, 1, 1, 0, 0, 0 }, /* PT_LAMP */- { 0, 0, 2, 4, 0, 9, 10, 10, 11, 0, 0 }, /* PT_GC */- { 0, 0, 5, 2, 0, 15, 16, 16, 17, 0, 0 }, /* PT_PC */- { 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0 }, /* PT_SC */- { 0, 3, 6, 12, 0, 3, 1, 1, 0, 0, 0 }, /* PT_ALNUM */- { 0, 1, 7, 13, 0, 1, 3, 3, 1, 0, 0 }, /* PT_SPACE */- { 0, 1, 7, 13, 0, 1, 3, 3, 1, 0, 0 }, /* PT_PXSPACE */- { 0, 0, 8, 14, 0, 0, 1, 1, 3, 0, 0 }, /* PT_WORD */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* PT_CLIST */- { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3 } /* PT_UCNC */-};--/* This table is used to check whether auto-possessification is possible-between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP) when one-specifies a general category and the other specifies a particular category. The-row is selected by the general category and the column by the particular-category. The value is 1 if the particular category is not part of the general-category. */--static const pcre_uint8 catposstab[7][30] = {-/* Cc Cf Cn Co Cs Ll Lm Lo Lt Lu Mc Me Mn Nd Nl No Pc Pd Pe Pf Pi Po Ps Sc Sk Sm So Zl Zp Zs */- { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* C */- { 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* L */- { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* M */- { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* N */- { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 }, /* P */- { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 }, /* S */- { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 } /* Z */-};--/* This table is used when checking ALNUM, (PX)SPACE, SPACE, and WORD against-a general or particular category. The properties in each row are those-that apply to the character set in question. Duplication means that a little-unnecessary work is done when checking, but this keeps things much simpler-because they can all use the same code. For more details see the comment where-this table is used.--Note: SPACE and PXSPACE used to be different because Perl excluded VT from-"space", but from Perl 5.18 it's included, so both categories are treated the-same here. */--static const pcre_uint8 posspropstab[3][4] = {- { ucp_L, ucp_N, ucp_N, ucp_Nl }, /* ALNUM, 3rd and 4th values redundant */- { ucp_Z, ucp_Z, ucp_C, ucp_Cc }, /* SPACE and PXSPACE, 2nd value redundant */- { ucp_L, ucp_N, ucp_P, ucp_Po } /* WORD */-};--/* This table is used when converting repeating opcodes into possessified-versions as a result of an explicit possessive quantifier such as ++. A zero-value means there is no possessified version - in those cases the item in-question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT-because all relevant opcodes are less than that. */--static const pcre_uint8 opcode_possessify[] = {- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 15 */- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16 - 31 */-- 0, /* NOTI */- OP_POSSTAR, 0, /* STAR, MINSTAR */- OP_POSPLUS, 0, /* PLUS, MINPLUS */- OP_POSQUERY, 0, /* QUERY, MINQUERY */- OP_POSUPTO, 0, /* UPTO, MINUPTO */- 0, /* EXACT */- 0, 0, 0, 0, /* POS{STAR,PLUS,QUERY,UPTO} */-- OP_POSSTARI, 0, /* STARI, MINSTARI */- OP_POSPLUSI, 0, /* PLUSI, MINPLUSI */- OP_POSQUERYI, 0, /* QUERYI, MINQUERYI */- OP_POSUPTOI, 0, /* UPTOI, MINUPTOI */- 0, /* EXACTI */- 0, 0, 0, 0, /* POS{STARI,PLUSI,QUERYI,UPTOI} */-- OP_NOTPOSSTAR, 0, /* NOTSTAR, NOTMINSTAR */- OP_NOTPOSPLUS, 0, /* NOTPLUS, NOTMINPLUS */- OP_NOTPOSQUERY, 0, /* NOTQUERY, NOTMINQUERY */- OP_NOTPOSUPTO, 0, /* NOTUPTO, NOTMINUPTO */- 0, /* NOTEXACT */- 0, 0, 0, 0, /* NOTPOS{STAR,PLUS,QUERY,UPTO} */-- OP_NOTPOSSTARI, 0, /* NOTSTARI, NOTMINSTARI */- OP_NOTPOSPLUSI, 0, /* NOTPLUSI, NOTMINPLUSI */- OP_NOTPOSQUERYI, 0, /* NOTQUERYI, NOTMINQUERYI */- OP_NOTPOSUPTOI, 0, /* NOTUPTOI, NOTMINUPTOI */- 0, /* NOTEXACTI */- 0, 0, 0, 0, /* NOTPOS{STARI,PLUSI,QUERYI,UPTOI} */-- OP_TYPEPOSSTAR, 0, /* TYPESTAR, TYPEMINSTAR */- OP_TYPEPOSPLUS, 0, /* TYPEPLUS, TYPEMINPLUS */- OP_TYPEPOSQUERY, 0, /* TYPEQUERY, TYPEMINQUERY */- OP_TYPEPOSUPTO, 0, /* TYPEUPTO, TYPEMINUPTO */- 0, /* TYPEEXACT */- 0, 0, 0, 0, /* TYPEPOS{STAR,PLUS,QUERY,UPTO} */-- OP_CRPOSSTAR, 0, /* CRSTAR, CRMINSTAR */- OP_CRPOSPLUS, 0, /* CRPLUS, CRMINPLUS */- OP_CRPOSQUERY, 0, /* CRQUERY, CRMINQUERY */- OP_CRPOSRANGE, 0, /* CRRANGE, CRMINRANGE */- 0, 0, 0, 0, /* CRPOS{STAR,PLUS,QUERY,RANGE} */-- 0, 0, 0, /* CLASS, NCLASS, XCLASS */- 0, 0, /* REF, REFI */- 0, 0, /* DNREF, DNREFI */- 0, 0 /* RECURSE, CALLOUT */-};----/*************************************************-* Find an error text *-*************************************************/--/* The error texts are now all in one long string, to save on relocations. As-some of the text is of unknown length, we can't use a table of offsets.-Instead, just count through the strings. This is not a performance issue-because it happens only when there has been a compilation error.--Argument: the error number-Returns: pointer to the error string-*/--static const char *-find_error_text(int n)-{-const char *s = error_texts;-for (; n > 0; n--)- {- while (*s++ != CHAR_NULL) {};- if (*s == CHAR_NULL) return "Error text not found (please report)";- }-return s;-}----/*************************************************-* Expand the workspace *-*************************************************/--/* This function is called during the second compiling phase, if the number of-forward references fills the existing workspace, which is originally a block on-the stack. A larger block is obtained from malloc() unless the ultimate limit-has been reached or the increase will be rather small.--Argument: pointer to the compile data block-Returns: 0 if all went well, else an error number-*/--static int-expand_workspace(compile_data *cd)-{-pcre_uchar *newspace;-int newsize = cd->workspace_size * 2;--if (newsize > COMPILE_WORK_SIZE_MAX) newsize = COMPILE_WORK_SIZE_MAX;-if (cd->workspace_size >= COMPILE_WORK_SIZE_MAX ||- newsize - cd->workspace_size < WORK_SIZE_SAFETY_MARGIN)- return ERR72;--newspace = (PUBL(malloc))(IN_UCHARS(newsize));-if (newspace == NULL) return ERR21;-memcpy(newspace, cd->start_workspace, cd->workspace_size * sizeof(pcre_uchar));-cd->hwm = (pcre_uchar *)newspace + (cd->hwm - cd->start_workspace);-if (cd->workspace_size > COMPILE_WORK_SIZE)- (PUBL(free))((void *)cd->start_workspace);-cd->start_workspace = newspace;-cd->workspace_size = newsize;-return 0;-}----/*************************************************-* Check for counted repeat *-*************************************************/--/* This function is called when a '{' is encountered in a place where it might-start a quantifier. It looks ahead to see if it really is a quantifier or not.-It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}-where the ddds are digits.--Arguments:- p pointer to the first char after '{'--Returns: TRUE or FALSE-*/--static BOOL-is_counted_repeat(const pcre_uchar *p)-{-if (!IS_DIGIT(*p)) return FALSE;-p++;-while (IS_DIGIT(*p)) p++;-if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;--if (*p++ != CHAR_COMMA) return FALSE;-if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;--if (!IS_DIGIT(*p)) return FALSE;-p++;-while (IS_DIGIT(*p)) p++;--return (*p == CHAR_RIGHT_CURLY_BRACKET);-}----/*************************************************-* Handle escapes *-*************************************************/--/* This function is called when a \ has been encountered. It either returns a-positive value for a simple escape such as \n, or 0 for a data character which-will be placed in chptr. A backreference to group n is returned as negative n.-When UTF-8 is enabled, a positive value greater than 255 may be returned in-chptr. On entry, ptr is pointing at the \. On exit, it is on the final-character of the escape sequence.--Arguments:- ptrptr points to the pattern position pointer- chptr points to a returned data character- errorcodeptr points to the errorcode variable- bracount number of previous extracting brackets- options the options bits- isclass TRUE if inside a character class--Returns: zero => a data character- positive => a special escape sequence- negative => a back reference- on error, errorcodeptr is set-*/--static int-check_escape(const pcre_uchar **ptrptr, pcre_uint32 *chptr, int *errorcodeptr,- int bracount, int options, BOOL isclass)-{-/* PCRE_UTF16 has the same value as PCRE_UTF8. */-BOOL utf = (options & PCRE_UTF8) != 0;-const pcre_uchar *ptr = *ptrptr + 1;-pcre_uint32 c;-int escape = 0;-int i;--GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */-ptr--; /* Set pointer back to the last byte */--/* If backslash is at the end of the pattern, it's an error. */--if (c == CHAR_NULL) *errorcodeptr = ERR1;--/* Non-alphanumerics 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. */--#ifndef EBCDIC /* ASCII/UTF-8 coding */-/* Not alphanumeric */-else if (c < CHAR_0 || c > CHAR_z) {}-else if ((i = escapes[c - CHAR_0]) != 0)- { if (i > 0) c = (pcre_uint32)i; else escape = -i; }--#else /* EBCDIC coding */-/* Not alphanumeric */-else if (c < CHAR_a || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}-else if ((i = escapes[c - 0x48]) != 0) { if (i > 0) c = (pcre_uint32)i; else escape = -i; }-#endif--/* Escapes that need further processing, or are illegal. */--else- {- const pcre_uchar *oldptr;- BOOL braced, negated, overflow;- int s;-- switch (c)- {- /* A number of Perl escapes are not handled by PCRE. We give an explicit- error. */-- case CHAR_l:- case CHAR_L:- *errorcodeptr = ERR37;- break;-- case CHAR_u:- if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)- {- /* In JavaScript, \u must be followed by four hexadecimal numbers.- Otherwise it is a lowercase u letter. */- if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0- && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0- && MAX_255(ptr[3]) && (digitab[ptr[3]] & ctype_xdigit) != 0- && MAX_255(ptr[4]) && (digitab[ptr[4]] & ctype_xdigit) != 0)- {- c = 0;- for (i = 0; i < 4; ++i)- {- register pcre_uint32 cc = *(++ptr);-#ifndef EBCDIC /* ASCII/UTF-8 coding */- if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */- c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));-#else /* EBCDIC coding */- if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */- c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));-#endif- }--#if defined COMPILE_PCRE8- if (c > (utf ? 0x10ffffU : 0xffU))-#elif defined COMPILE_PCRE16- if (c > (utf ? 0x10ffffU : 0xffffU))-#elif defined COMPILE_PCRE32- if (utf && c > 0x10ffffU)-#endif- {- *errorcodeptr = ERR76;- }- else if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;- }- }- else- *errorcodeptr = ERR37;- break;-- case CHAR_U:- /* In JavaScript, \U is an uppercase U letter. */- if ((options & PCRE_JAVASCRIPT_COMPAT) == 0) *errorcodeptr = ERR37;- break;-- /* In a character class, \g is just a literal "g". Outside a character- class, \g must be followed by one of a number of specific things:-- (1) A number, either plain or braced. If positive, it is an absolute- backreference. If negative, it is a relative backreference. This is a Perl- 5.10 feature.-- (2) Perl 5.10 also supports \g{name} as a reference to a named group. This- is part of Perl's movement towards a unified syntax for back references. As- this is synonymous with \k{name}, we fudge it up by pretending it really- was \k.-- (3) For Oniguruma compatibility we also support \g followed by a name or a- number either in angle brackets or in single quotes. However, these are- (possibly recursive) subroutine calls, _not_ backreferences. Just return- the ESC_g code (cf \k). */-- case CHAR_g:- if (isclass) break;- if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)- {- escape = ESC_g;- break;- }-- /* Handle the Perl-compatible cases */-- if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)- {- const pcre_uchar *p;- for (p = ptr+2; *p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET; p++)- if (*p != CHAR_MINUS && !IS_DIGIT(*p)) break;- if (*p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET)- {- escape = ESC_k;- break;- }- braced = TRUE;- ptr++;- }- else braced = FALSE;-- if (ptr[1] == CHAR_MINUS)- {- negated = TRUE;- ptr++;- }- else negated = FALSE;-- /* The integer range is limited by the machine's int representation. */- s = 0;- overflow = FALSE;- while (IS_DIGIT(ptr[1]))- {- if (s > INT_MAX / 10 - 1) /* Integer overflow */- {- overflow = TRUE;- break;- }- s = s * 10 + (int)(*(++ptr) - CHAR_0);- }- if (overflow) /* Integer overflow */- {- while (IS_DIGIT(ptr[1]))- ptr++;- *errorcodeptr = ERR61;- break;- }-- if (braced && *(++ptr) != CHAR_RIGHT_CURLY_BRACKET)- {- *errorcodeptr = ERR57;- break;- }-- if (s == 0)- {- *errorcodeptr = ERR58;- break;- }-- if (negated)- {- if (s > bracount)- {- *errorcodeptr = ERR15;- break;- }- s = bracount - (s - 1);- }-- escape = -s;- break;-- /* The handling of escape sequences consisting of a string of digits- starting with one that is not zero is not straightforward. Perl has changed- over the years. Nowadays \g{} for backreferences and \o{} for octal are- recommended to avoid the ambiguities in the old syntax.-- Outside a character class, the digits are read as a decimal number. If the- number is less than 8 (used to be 10), or if there are that many previous- extracting left brackets, then it is a back reference. Otherwise, up to- three octal digits are read to form an escaped byte. Thus \123 is likely to- be octal 123 (cf \0123, which is octal 012 followed by the literal 3). If- the octal value is greater than 377, the least significant 8 bits are- taken. \8 and \9 are treated as the literal characters 8 and 9.-- Inside a character class, \ followed by a digit is always either a literal- 8 or 9 or an octal number. */-- case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:- case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:-- if (!isclass)- {- oldptr = ptr;- /* The integer range is limited by the machine's int representation. */- s = (int)(c -CHAR_0);- overflow = FALSE;- while (IS_DIGIT(ptr[1]))- {- if (s > INT_MAX / 10 - 1) /* Integer overflow */- {- overflow = TRUE;- break;- }- s = s * 10 + (int)(*(++ptr) - CHAR_0);- }- if (overflow) /* Integer overflow */- {- while (IS_DIGIT(ptr[1]))- ptr++;- *errorcodeptr = ERR61;- break;- }- if (s < 8 || s <= bracount) /* Check for back reference */- {- escape = -s;- break;- }- ptr = oldptr; /* Put the pointer back and fall through */- }-- /* Handle a digit following \ when the number is not a back reference. If- the first digit is 8 or 9, Perl used to generate a binary zero byte and- then treat the digit as a following literal. At least by Perl 5.18 this- changed so as not to insert the binary zero. */-- if ((c = *ptr) >= CHAR_8) break;-- /* Fall through with a digit less than 8 */-- /* \0 always starts an octal number, but we may drop through to here with a- larger first octal digit. The original code used just to take the least- significant 8 bits of octal numbers (I think this is what early Perls used- to do). Nowadays we allow for larger numbers in UTF-8 mode and 16-bit mode,- but no more than 3 octal digits. */-- case CHAR_0:- c -= CHAR_0;- while(i++ < 2 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)- c = c * 8 + *(++ptr) - CHAR_0;-#ifdef COMPILE_PCRE8- if (!utf && c > 0xff) *errorcodeptr = ERR51;-#endif- break;-- /* \o is a relatively new Perl feature, supporting a more general way of- specifying character codes in octal. The only supported form is \o{ddd}. */-- case CHAR_o:- if (ptr[1] != CHAR_LEFT_CURLY_BRACKET) *errorcodeptr = ERR81; else- {- ptr += 2;- c = 0;- overflow = FALSE;- while (*ptr >= CHAR_0 && *ptr <= CHAR_7)- {- register pcre_uint32 cc = *ptr++;- if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */-#ifdef COMPILE_PCRE32- if (c >= 0x20000000l) { overflow = TRUE; break; }-#endif- c = (c << 3) + cc - CHAR_0 ;-#if defined COMPILE_PCRE8- if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }-#elif defined COMPILE_PCRE16- if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }-#elif defined COMPILE_PCRE32- if (utf && c > 0x10ffffU) { overflow = TRUE; break; }-#endif- }- if (overflow)- {- while (*ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++;- *errorcodeptr = ERR34;- }- else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)- {- if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;- }- else *errorcodeptr = ERR80;- }- break;-- /* \x is complicated. In JavaScript, \x must be followed by two hexadecimal- numbers. Otherwise it is a lowercase x letter. */-- case CHAR_x:- if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)- {- if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0- && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0)- {- c = 0;- for (i = 0; i < 2; ++i)- {- register pcre_uint32 cc = *(++ptr);-#ifndef EBCDIC /* ASCII/UTF-8 coding */- if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */- c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));-#else /* EBCDIC coding */- if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */- c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));-#endif- }- }- } /* End JavaScript handling */-- /* Handle \x in Perl's style. \x{ddd} is a character number which can be- greater than 0xff in utf or non-8bit mode, but only if the ddd are hex- digits. If not, { used to be treated as a data character. However, Perl- seems to read hex digits up to the first non-such, and ignore the rest, so- that, for example \x{zz} matches a binary zero. This seems crazy, so PCRE- now gives an error. */-- else- {- if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)- {- ptr += 2;- c = 0;- overflow = FALSE;- while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0)- {- register pcre_uint32 cc = *ptr++;- if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */--#ifdef COMPILE_PCRE32- if (c >= 0x10000000l) { overflow = TRUE; break; }-#endif--#ifndef EBCDIC /* ASCII/UTF-8 coding */- if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */- c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));-#else /* EBCDIC coding */- if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */- c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));-#endif--#if defined COMPILE_PCRE8- if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }-#elif defined COMPILE_PCRE16- if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }-#elif defined COMPILE_PCRE32- if (utf && c > 0x10ffffU) { overflow = TRUE; break; }-#endif- }-- if (overflow)- {- while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0) ptr++;- *errorcodeptr = ERR34;- }-- else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)- {- if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;- }-- /* If the sequence of hex digits does not end with '}', give an error.- We used just to recognize this construct and fall through to the normal- \x handling, but nowadays Perl gives an error, which seems much more- sensible, so we do too. */-- else *errorcodeptr = ERR79;- } /* End of \x{} processing */-- /* Read a single-byte hex-defined char (up to two hex digits after \x) */-- else- {- c = 0;- while (i++ < 2 && MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0)- {- pcre_uint32 cc; /* Some compilers don't like */- cc = *(++ptr); /* ++ in initializers */-#ifndef EBCDIC /* ASCII/UTF-8 coding */- if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */- c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));-#else /* EBCDIC coding */- if (cc <= CHAR_z) cc += 64; /* Convert to upper case */- c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));-#endif- }- } /* End of \xdd handling */- } /* End of Perl-style \x handling */- break;-- /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.- An error is given if the byte following \c is not an ASCII character. This- coding is ASCII-specific, but then the whole concept of \cx is- ASCII-specific. (However, an EBCDIC equivalent has now been added.) */-- case CHAR_c:- c = *(++ptr);- if (c == CHAR_NULL)- {- *errorcodeptr = ERR2;- break;- }-#ifndef EBCDIC /* ASCII/UTF-8 coding */- if (c > 127) /* Excludes all non-ASCII in either mode */- {- *errorcodeptr = ERR68;- break;- }- if (c >= CHAR_a && c <= CHAR_z) c -= 32;- c ^= 0x40;-#else /* EBCDIC coding */- if (c >= CHAR_a && c <= CHAR_z) c += 64;- c ^= 0xC0;-#endif- break;-- /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any- other alphanumeric following \ is an error if PCRE_EXTRA was set;- otherwise, for Perl compatibility, it is a literal. This code looks a bit- odd, but there used to be some cases other than the default, and there may- be again in future, so I haven't "optimized" it. */-- default:- if ((options & PCRE_EXTRA) != 0) switch(c)- {- default:- *errorcodeptr = ERR3;- break;- }- break;- }- }--/* Perl supports \N{name} for character names, as well as plain \N for "not-newline". PCRE does not support \N{name}. However, it does support-quantification such as \N{2,3}. */--if (escape == ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&- !is_counted_repeat(ptr+2))- *errorcodeptr = ERR37;--/* If PCRE_UCP is set, we change the values for \d etc. */--if ((options & PCRE_UCP) != 0 && escape >= ESC_D && escape <= ESC_w)- escape += (ESC_DU - ESC_D);--/* Set the pointer to the final character before returning. */--*ptrptr = ptr;-*chptr = c;-return escape;-}----#ifdef SUPPORT_UCP-/*************************************************-* Handle \P and \p *-*************************************************/--/* This function is called after \P or \p has been encountered, provided that-PCRE is compiled with support for Unicode properties. On entry, ptrptr is-pointing at the P or p. On exit, it is pointing at the final character of the-escape sequence.--Argument:- ptrptr points to the pattern position pointer- negptr points to a boolean that is set TRUE for negation else FALSE- ptypeptr points to an unsigned int that is set to the type value- pdataptr points to an unsigned int that is set to the detailed property value- errorcodeptr points to the error code variable--Returns: TRUE if the type value was found, or FALSE for an invalid type-*/--static BOOL-get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, unsigned int *ptypeptr,- unsigned int *pdataptr, int *errorcodeptr)-{-pcre_uchar c;-int i, bot, top;-const pcre_uchar *ptr = *ptrptr;-pcre_uchar name[32];--c = *(++ptr);-if (c == CHAR_NULL) goto ERROR_RETURN;--*negptr = FALSE;--/* \P or \p can be followed by a name in {}, optionally preceded by ^ for-negation. */--if (c == CHAR_LEFT_CURLY_BRACKET)- {- if (ptr[1] == CHAR_CIRCUMFLEX_ACCENT)- {- *negptr = TRUE;- ptr++;- }- for (i = 0; i < (int)(sizeof(name) / sizeof(pcre_uchar)) - 1; i++)- {- c = *(++ptr);- if (c == CHAR_NULL) goto ERROR_RETURN;- if (c == CHAR_RIGHT_CURLY_BRACKET) break;- name[i] = c;- }- if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;- name[i] = 0;- }--/* Otherwise there is just one following character */--else- {- name[0] = c;- name[1] = 0;- }--*ptrptr = ptr;--/* Search for a recognized property name using binary chop */--bot = 0;-top = PRIV(utt_size);--while (bot < top)- {- int r;- i = (bot + top) >> 1;- r = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);- if (r == 0)- {- *ptypeptr = PRIV(utt)[i].type;- *pdataptr = PRIV(utt)[i].value;- return TRUE;- }- if (r > 0) bot = i + 1; else top = i;- }--*errorcodeptr = ERR47;-*ptrptr = ptr;-return FALSE;--ERROR_RETURN:-*errorcodeptr = ERR46;-*ptrptr = ptr;-return FALSE;-}-#endif----/*************************************************-* Read repeat counts *-*************************************************/--/* Read an item of the form {n,m} and return the values. This is called only-after is_counted_repeat() has confirmed that a repeat-count quantifier exists,-so the syntax is guaranteed to be correct, but we need to check the values.--Arguments:- p pointer to first char after '{'- minp pointer to int for min- maxp pointer to int for max- returned as -1 if no max- errorcodeptr points to error code variable--Returns: pointer to '}' on success;- current ptr on error, with errorcodeptr set non-zero-*/--static const pcre_uchar *-read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, int *errorcodeptr)-{-int min = 0;-int max = -1;--/* Read the minimum value and do a paranoid check: a negative value indicates-an integer overflow. */--while (IS_DIGIT(*p)) min = min * 10 + (int)(*p++ - CHAR_0);-if (min < 0 || min > 65535)- {- *errorcodeptr = ERR5;- return p;- }--/* Read the maximum value if there is one, and again do a paranoid on its size.-Also, max must not be less than min. */--if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else- {- if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)- {- max = 0;- while(IS_DIGIT(*p)) max = max * 10 + (int)(*p++ - CHAR_0);- if (max < 0 || max > 65535)- {- *errorcodeptr = ERR5;- return p;- }- if (max < min)- {- *errorcodeptr = ERR4;- return p;- }- }- }--/* Fill in the required variables, and pass back the pointer to the terminating-'}'. */--*minp = min;-*maxp = max;-return p;-}----/*************************************************-* Find first significant op code *-*************************************************/--/* This is called by several functions that scan a compiled expression looking-for a fixed first character, or an anchoring op code etc. It skips over things-that do not influence this. For some calls, it makes sense to skip negative-forward and all backward assertions, and also the \b assertion; for others it-does not.--Arguments:- code pointer to the start of the group- skipassert TRUE if certain assertions are to be skipped--Returns: pointer to the first significant opcode-*/--static const pcre_uchar*-first_significant_code(const pcre_uchar *code, BOOL skipassert)-{-for (;;)- {- switch ((int)*code)- {- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- if (!skipassert) return code;- do code += GET(code, 1); while (*code == OP_ALT);- code += PRIV(OP_lengths)[*code];- break;-- case OP_WORD_BOUNDARY:- case OP_NOT_WORD_BOUNDARY:- if (!skipassert) return code;- /* Fall through */-- case OP_CALLOUT:- case OP_CREF:- case OP_DNCREF:- case OP_RREF:- case OP_DNRREF:- case OP_DEF:- code += PRIV(OP_lengths)[*code];- break;-- default:- return code;- }- }-/* Control never reaches here */-}----/*************************************************-* Find the fixed length of a branch *-*************************************************/--/* Scan a branch and compute the fixed length of subject that will match it,-if the length is fixed. This is needed for dealing with backward assertions.-In UTF8 mode, the result is in characters rather than bytes. The branch is-temporarily terminated with OP_END when this function is called.--This function is called when a backward assertion is encountered, so that if it-fails, the error message can point to the correct place in the pattern.-However, we cannot do this when the assertion contains subroutine calls,-because they can be forward references. We solve this by remembering this case-and doing the check at the end; a flag specifies which mode we are running in.--Arguments:- code points to the start of the pattern (the bracket)- utf TRUE in UTF-8 / UTF-16 / UTF-32 mode- atend TRUE if called when the pattern is complete- cd the "compile data" structure--Returns: the fixed length,- or -1 if there is no fixed length,- or -2 if \C was encountered (in UTF-8 mode only)- or -3 if an OP_RECURSE item was encountered and atend is FALSE- or -4 if an unknown opcode was encountered (internal error)-*/--static int-find_fixedlength(pcre_uchar *code, BOOL utf, BOOL atend, compile_data *cd)-{-int length = -1;--register int branchlength = 0;-register pcre_uchar *cc = code + 1 + LINK_SIZE;--/* Scan along the opcodes for this branch. If we get to the end of the-branch, check the length against that of the other branches. */--for (;;)- {- int d;- pcre_uchar *ce, *cs;- register pcre_uchar op = *cc;-- switch (op)- {- /* We only need to continue for OP_CBRA (normal capturing bracket) and- OP_BRA (normal non-capturing bracket) because the other variants of these- opcodes are all concerned with unlimited repeated groups, which of course- are not of fixed length. */-- case OP_CBRA:- case OP_BRA:- case OP_ONCE:- case OP_ONCE_NC:- case OP_COND:- d = find_fixedlength(cc + ((op == OP_CBRA)? IMM2_SIZE : 0), utf, atend, cd);- if (d < 0) return d;- branchlength += d;- do cc += GET(cc, 1); while (*cc == OP_ALT);- cc += 1 + LINK_SIZE;- break;-- /* Reached end of a branch; if it's a ket it is the end of a nested call.- If it's ALT it is an alternation in a nested call. An ACCEPT is effectively- an ALT. If it is END it's the end of the outer call. All can be handled by- the same code. Note that we must not include the OP_KETRxxx opcodes here,- because they all imply an unlimited repeat. */-- case OP_ALT:- case OP_KET:- case OP_END:- case OP_ACCEPT:- case OP_ASSERT_ACCEPT:- if (length < 0) length = branchlength;- else if (length != branchlength) return -1;- if (*cc != OP_ALT) return length;- cc += 1 + LINK_SIZE;- branchlength = 0;- break;-- /* A true recursion implies not fixed length, but a subroutine call may- be OK. If the subroutine is a forward reference, we can't deal with- it until the end of the pattern, so return -3. */-- case OP_RECURSE:- if (!atend) return -3;- cs = ce = (pcre_uchar *)cd->start_code + GET(cc, 1); /* Start subpattern */- do ce += GET(ce, 1); while (*ce == OP_ALT); /* End subpattern */- if (cc > cs && cc < ce) return -1; /* Recursion */- d = find_fixedlength(cs + IMM2_SIZE, utf, atend, cd);- if (d < 0) return d;- branchlength += d;- cc += 1 + LINK_SIZE;- break;-- /* Skip over assertive subpatterns */-- case OP_ASSERT:- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- do cc += GET(cc, 1); while (*cc == OP_ALT);- cc += PRIV(OP_lengths)[*cc];- break;-- /* Skip over things that don't match chars */-- case OP_MARK:- case OP_PRUNE_ARG:- case OP_SKIP_ARG:- case OP_THEN_ARG:- cc += cc[1] + PRIV(OP_lengths)[*cc];- break;-- case OP_CALLOUT:- case OP_CIRC:- case OP_CIRCM:- case OP_CLOSE:- case OP_COMMIT:- case OP_CREF:- case OP_DEF:- case OP_DNCREF:- case OP_DNRREF:- case OP_DOLL:- case OP_DOLLM:- case OP_EOD:- case OP_EODN:- case OP_FAIL:- case OP_NOT_WORD_BOUNDARY:- case OP_PRUNE:- case OP_REVERSE:- case OP_RREF:- case OP_SET_SOM:- case OP_SKIP:- case OP_SOD:- case OP_SOM:- case OP_THEN:- case OP_WORD_BOUNDARY:- cc += PRIV(OP_lengths)[*cc];- break;-- /* Handle literal characters */-- case OP_CHAR:- case OP_CHARI:- case OP_NOT:- case OP_NOTI:- branchlength++;- cc += 2;-#ifdef SUPPORT_UTF- if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- break;-- /* Handle exact repetitions. The count is already in characters, but we- need to skip over a multibyte character in UTF8 mode. */-- case OP_EXACT:- case OP_EXACTI:- case OP_NOTEXACT:- case OP_NOTEXACTI:- branchlength += (int)GET2(cc,1);- cc += 2 + IMM2_SIZE;-#ifdef SUPPORT_UTF- if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- break;-- case OP_TYPEEXACT:- branchlength += GET2(cc,1);- if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP)- cc += 2;- cc += 1 + IMM2_SIZE + 1;- break;-- /* Handle single-char matchers */-- case OP_PROP:- case OP_NOTPROP:- cc += 2;- /* Fall through */-- case OP_HSPACE:- case OP_VSPACE:- case OP_NOT_HSPACE:- case OP_NOT_VSPACE:- case OP_NOT_DIGIT:- case OP_DIGIT:- case OP_NOT_WHITESPACE:- case OP_WHITESPACE:- case OP_NOT_WORDCHAR:- case OP_WORDCHAR:- case OP_ANY:- case OP_ALLANY:- branchlength++;- cc++;- break;-- /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode;- otherwise \C is coded as OP_ALLANY. */-- case OP_ANYBYTE:- return -2;-- /* Check a class for variable quantification */-- case OP_CLASS:- case OP_NCLASS:-#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32- case OP_XCLASS:- /* The original code caused an unsigned overflow in 64 bit systems,- so now we use a conditional statement. */- if (op == OP_XCLASS)- cc += GET(cc, 1);- else- cc += PRIV(OP_lengths)[OP_CLASS];-#else- cc += PRIV(OP_lengths)[OP_CLASS];-#endif-- switch (*cc)- {- case OP_CRSTAR:- case OP_CRMINSTAR:- case OP_CRPLUS:- case OP_CRMINPLUS:- case OP_CRQUERY:- case OP_CRMINQUERY:- case OP_CRPOSSTAR:- case OP_CRPOSPLUS:- case OP_CRPOSQUERY:- return -1;-- case OP_CRRANGE:- case OP_CRMINRANGE:- case OP_CRPOSRANGE:- if (GET2(cc,1) != GET2(cc,1+IMM2_SIZE)) return -1;- branchlength += (int)GET2(cc,1);- cc += 1 + 2 * IMM2_SIZE;- break;-- default:- branchlength++;- }- break;-- /* Anything else is variable length */-- case OP_ANYNL:- case OP_BRAMINZERO:- case OP_BRAPOS:- case OP_BRAPOSZERO:- case OP_BRAZERO:- case OP_CBRAPOS:- case OP_EXTUNI:- case OP_KETRMAX:- case OP_KETRMIN:- case OP_KETRPOS:- case OP_MINPLUS:- case OP_MINPLUSI:- case OP_MINQUERY:- case OP_MINQUERYI:- case OP_MINSTAR:- case OP_MINSTARI:- case OP_MINUPTO:- case OP_MINUPTOI:- case OP_NOTMINPLUS:- case OP_NOTMINPLUSI:- case OP_NOTMINQUERY:- case OP_NOTMINQUERYI:- case OP_NOTMINSTAR:- case OP_NOTMINSTARI:- case OP_NOTMINUPTO:- case OP_NOTMINUPTOI:- case OP_NOTPLUS:- case OP_NOTPLUSI:- case OP_NOTPOSPLUS:- case OP_NOTPOSPLUSI:- case OP_NOTPOSQUERY:- case OP_NOTPOSQUERYI:- case OP_NOTPOSSTAR:- case OP_NOTPOSSTARI:- case OP_NOTPOSUPTO:- case OP_NOTPOSUPTOI:- case OP_NOTQUERY:- case OP_NOTQUERYI:- case OP_NOTSTAR:- case OP_NOTSTARI:- case OP_NOTUPTO:- case OP_NOTUPTOI:- case OP_PLUS:- case OP_PLUSI:- case OP_POSPLUS:- case OP_POSPLUSI:- case OP_POSQUERY:- case OP_POSQUERYI:- case OP_POSSTAR:- case OP_POSSTARI:- case OP_POSUPTO:- case OP_POSUPTOI:- case OP_QUERY:- case OP_QUERYI:- case OP_REF:- case OP_REFI:- case OP_DNREF:- case OP_DNREFI:- case OP_SBRA:- case OP_SBRAPOS:- case OP_SCBRA:- case OP_SCBRAPOS:- case OP_SCOND:- case OP_SKIPZERO:- case OP_STAR:- case OP_STARI:- case OP_TYPEMINPLUS:- case OP_TYPEMINQUERY:- case OP_TYPEMINSTAR:- case OP_TYPEMINUPTO:- case OP_TYPEPLUS:- case OP_TYPEPOSPLUS:- case OP_TYPEPOSQUERY:- case OP_TYPEPOSSTAR:- case OP_TYPEPOSUPTO:- case OP_TYPEQUERY:- case OP_TYPESTAR:- case OP_TYPEUPTO:- case OP_UPTO:- case OP_UPTOI:- return -1;-- /* Catch unrecognized opcodes so that when new ones are added they- are not forgotten, as has happened in the past. */-- default:- return -4;- }- }-/* Control never gets here */-}----/*************************************************-* Scan compiled regex for specific bracket *-*************************************************/--/* This little function scans through a compiled pattern until it finds a-capturing bracket with the given number, or, if the number is negative, an-instance of OP_REVERSE for a lookbehind. The function is global in the C sense-so that it can be called from pcre_study() when finding the minimum matching-length.--Arguments:- code points to start of expression- utf TRUE in UTF-8 / UTF-16 / UTF-32 mode- number the required bracket number or negative to find a lookbehind--Returns: pointer to the opcode for the bracket, or NULL if not found-*/--const pcre_uchar *-PRIV(find_bracket)(const pcre_uchar *code, BOOL utf, int number)-{-for (;;)- {- register pcre_uchar c = *code;-- if (c == OP_END) return NULL;-- /* XCLASS is used for classes that cannot be represented just by a bit- map. This includes negated single high-valued characters. The length in- the table is zero; the actual length is stored in the compiled code. */-- if (c == OP_XCLASS) code += GET(code, 1);-- /* Handle recursion */-- else if (c == OP_REVERSE)- {- if (number < 0) return (pcre_uchar *)code;- code += PRIV(OP_lengths)[c];- }-- /* Handle capturing bracket */-- else if (c == OP_CBRA || c == OP_SCBRA ||- c == OP_CBRAPOS || c == OP_SCBRAPOS)- {- int n = (int)GET2(code, 1+LINK_SIZE);- if (n == number) return (pcre_uchar *)code;- code += PRIV(OP_lengths)[c];- }-- /* Otherwise, we can get the item's length from the table, except that for- repeated character types, we have to test for \p and \P, which have an extra- two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we- must add in its length. */-- else- {- switch(c)- {- case OP_TYPESTAR:- case OP_TYPEMINSTAR:- case OP_TYPEPLUS:- case OP_TYPEMINPLUS:- case OP_TYPEQUERY:- case OP_TYPEMINQUERY:- case OP_TYPEPOSSTAR:- case OP_TYPEPOSPLUS:- case OP_TYPEPOSQUERY:- if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;- break;-- case OP_TYPEUPTO:- case OP_TYPEMINUPTO:- case OP_TYPEEXACT:- case OP_TYPEPOSUPTO:- if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)- code += 2;- break;-- case OP_MARK:- case OP_PRUNE_ARG:- case OP_SKIP_ARG:- case OP_THEN_ARG:- code += code[1];- break;- }-- /* Add in the fixed length from the table */-- code += PRIV(OP_lengths)[c];-- /* In UTF-8 mode, opcodes that are followed by a character may be followed by- a multi-byte character. The length in the table is a minimum, so we have to- arrange to skip the extra bytes. */--#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf) switch(c)- {- case OP_CHAR:- case OP_CHARI:- case OP_EXACT:- case OP_EXACTI:- case OP_UPTO:- case OP_UPTOI:- case OP_MINUPTO:- case OP_MINUPTOI:- case OP_POSUPTO:- case OP_POSUPTOI:- case OP_STAR:- case OP_STARI:- case OP_MINSTAR:- case OP_MINSTARI:- case OP_POSSTAR:- case OP_POSSTARI:- case OP_PLUS:- case OP_PLUSI:- case OP_MINPLUS:- case OP_MINPLUSI:- case OP_POSPLUS:- case OP_POSPLUSI:- case OP_QUERY:- case OP_QUERYI:- case OP_MINQUERY:- case OP_MINQUERYI:- case OP_POSQUERY:- case OP_POSQUERYI:- if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);- break;- }-#else- (void)(utf); /* Keep compiler happy by referencing function argument */-#endif- }- }-}----/*************************************************-* Scan compiled regex for recursion reference *-*************************************************/--/* This little function scans through a compiled pattern until it finds an-instance of OP_RECURSE.--Arguments:- code points to start of expression- utf TRUE in UTF-8 / UTF-16 / UTF-32 mode--Returns: pointer to the opcode for OP_RECURSE, or NULL if not found-*/--static const pcre_uchar *-find_recurse(const pcre_uchar *code, BOOL utf)-{-for (;;)- {- register pcre_uchar c = *code;- if (c == OP_END) return NULL;- if (c == OP_RECURSE) return code;-- /* XCLASS is used for classes that cannot be represented just by a bit- map. This includes negated single high-valued characters. The length in- the table is zero; the actual length is stored in the compiled code. */-- if (c == OP_XCLASS) code += GET(code, 1);-- /* Otherwise, we can get the item's length from the table, except that for- repeated character types, we have to test for \p and \P, which have an extra- two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we- must add in its length. */-- else- {- switch(c)- {- case OP_TYPESTAR:- case OP_TYPEMINSTAR:- case OP_TYPEPLUS:- case OP_TYPEMINPLUS:- case OP_TYPEQUERY:- case OP_TYPEMINQUERY:- case OP_TYPEPOSSTAR:- case OP_TYPEPOSPLUS:- case OP_TYPEPOSQUERY:- if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;- break;-- case OP_TYPEPOSUPTO:- case OP_TYPEUPTO:- case OP_TYPEMINUPTO:- case OP_TYPEEXACT:- if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)- code += 2;- break;-- case OP_MARK:- case OP_PRUNE_ARG:- case OP_SKIP_ARG:- case OP_THEN_ARG:- code += code[1];- break;- }-- /* Add in the fixed length from the table */-- code += PRIV(OP_lengths)[c];-- /* In UTF-8 mode, opcodes that are followed by a character may be followed- by a multi-byte character. The length in the table is a minimum, so we have- to arrange to skip the extra bytes. */--#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf) switch(c)- {- case OP_CHAR:- case OP_CHARI:- case OP_NOT:- case OP_NOTI:- case OP_EXACT:- case OP_EXACTI:- case OP_NOTEXACT:- case OP_NOTEXACTI:- case OP_UPTO:- case OP_UPTOI:- case OP_NOTUPTO:- case OP_NOTUPTOI:- case OP_MINUPTO:- case OP_MINUPTOI:- case OP_NOTMINUPTO:- case OP_NOTMINUPTOI:- case OP_POSUPTO:- case OP_POSUPTOI:- case OP_NOTPOSUPTO:- case OP_NOTPOSUPTOI:- case OP_STAR:- case OP_STARI:- case OP_NOTSTAR:- case OP_NOTSTARI:- case OP_MINSTAR:- case OP_MINSTARI:- case OP_NOTMINSTAR:- case OP_NOTMINSTARI:- case OP_POSSTAR:- case OP_POSSTARI:- case OP_NOTPOSSTAR:- case OP_NOTPOSSTARI:- case OP_PLUS:- case OP_PLUSI:- case OP_NOTPLUS:- case OP_NOTPLUSI:- case OP_MINPLUS:- case OP_MINPLUSI:- case OP_NOTMINPLUS:- case OP_NOTMINPLUSI:- case OP_POSPLUS:- case OP_POSPLUSI:- case OP_NOTPOSPLUS:- case OP_NOTPOSPLUSI:- case OP_QUERY:- case OP_QUERYI:- case OP_NOTQUERY:- case OP_NOTQUERYI:- case OP_MINQUERY:- case OP_MINQUERYI:- case OP_NOTMINQUERY:- case OP_NOTMINQUERYI:- case OP_POSQUERY:- case OP_POSQUERYI:- case OP_NOTPOSQUERY:- case OP_NOTPOSQUERYI:- if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);- break;- }-#else- (void)(utf); /* Keep compiler happy by referencing function argument */-#endif- }- }-}----/*************************************************-* Scan compiled branch for non-emptiness *-*************************************************/--/* This function scans through a branch of a compiled pattern to see whether it-can match the empty string or not. It is called from could_be_empty()-below and from compile_branch() when checking for an unlimited repeat of a-group that can match nothing. Note that first_significant_code() skips over-backward and negative forward assertions when its final argument is TRUE. If we-hit an unclosed bracket, we return "empty" - this means we've struck an inner-bracket whose current branch will already have been scanned.--Arguments:- code points to start of search- endcode points to where to stop- utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode- cd contains pointers to tables etc.- recurses chain of recurse_check to catch mutual recursion--Returns: TRUE if what is matched could be empty-*/--typedef struct recurse_check {- struct recurse_check *prev;- const pcre_uchar *group;-} recurse_check;--static BOOL-could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,- BOOL utf, compile_data *cd, recurse_check *recurses)-{-register pcre_uchar c;-recurse_check this_recurse;--for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);- code < endcode;- code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))- {- const pcre_uchar *ccode;-- c = *code;-- /* Skip over forward assertions; the other assertions are skipped by- first_significant_code() with a TRUE final argument. */-- if (c == OP_ASSERT)- {- do code += GET(code, 1); while (*code == OP_ALT);- c = *code;- continue;- }-- /* For a recursion/subroutine call, if its end has been reached, which- implies a backward reference subroutine call, we can scan it. If it's a- forward reference subroutine call, we can't. To detect forward reference- we have to scan up the list that is kept in the workspace. This function is- called only when doing the real compile, not during the pre-compile that- measures the size of the compiled pattern. */-- if (c == OP_RECURSE)- {- const pcre_uchar *scode = cd->start_code + GET(code, 1);- BOOL empty_branch;-- /* Test for forward reference or uncompleted reference. This is disabled- when called to scan a completed pattern by setting cd->start_workspace to- NULL. */-- if (cd->start_workspace != NULL)- {- const pcre_uchar *tcode;- for (tcode = cd->start_workspace; tcode < cd->hwm; tcode += LINK_SIZE)- if ((int)GET(tcode, 0) == (int)(code + 1 - cd->start_code)) return TRUE;- if (GET(scode, 1) == 0) return TRUE; /* Unclosed */- }-- /* If we are scanning a completed pattern, there are no forward references- and all groups are complete. We need to detect whether this is a recursive- call, as otherwise there will be an infinite loop. If it is a recursion,- just skip over it. Simple recursions are easily detected. For mutual- recursions we keep a chain on the stack. */-- else- {- recurse_check *r = recurses;- const pcre_uchar *endgroup = scode;-- do endgroup += GET(endgroup, 1); while (*endgroup == OP_ALT);- if (code >= scode && code <= endgroup) continue; /* Simple recursion */-- for (r = recurses; r != NULL; r = r->prev)- if (r->group == scode) break;- if (r != NULL) continue; /* Mutual recursion */- }-- /* Completed reference; scan the referenced group, remembering it on the- stack chain to detect mutual recursions. */-- empty_branch = FALSE;- this_recurse.prev = recurses;- this_recurse.group = scode;-- do- {- if (could_be_empty_branch(scode, endcode, utf, cd, &this_recurse))- {- empty_branch = TRUE;- break;- }- scode += GET(scode, 1);- }- while (*scode == OP_ALT);-- if (!empty_branch) return FALSE; /* All branches are non-empty */- continue;- }-- /* Groups with zero repeats can of course be empty; skip them. */-- if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO ||- c == OP_BRAPOSZERO)- {- code += PRIV(OP_lengths)[c];- do code += GET(code, 1); while (*code == OP_ALT);- c = *code;- continue;- }-- /* A nested group that is already marked as "could be empty" can just be- skipped. */-- if (c == OP_SBRA || c == OP_SBRAPOS ||- c == OP_SCBRA || c == OP_SCBRAPOS)- {- do code += GET(code, 1); while (*code == OP_ALT);- c = *code;- continue;- }-- /* For other groups, scan the branches. */-- if (c == OP_BRA || c == OP_BRAPOS ||- c == OP_CBRA || c == OP_CBRAPOS ||- c == OP_ONCE || c == OP_ONCE_NC ||- c == OP_COND)- {- BOOL empty_branch;- if (GET(code, 1) == 0) return TRUE; /* Hit unclosed bracket */-- /* If a conditional group has only one branch, there is a second, implied,- empty branch, so just skip over the conditional, because it could be empty.- Otherwise, scan the individual branches of the group. */-- if (c == OP_COND && code[GET(code, 1)] != OP_ALT)- code += GET(code, 1);- else- {- empty_branch = FALSE;- do- {- if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd, NULL))- empty_branch = TRUE;- code += GET(code, 1);- }- while (*code == OP_ALT);- if (!empty_branch) return FALSE; /* All branches are non-empty */- }-- c = *code;- continue;- }-- /* Handle the other opcodes */-- switch (c)- {- /* Check for quantifiers after a class. XCLASS is used for classes that- cannot be represented just by a bit map. This includes negated single- high-valued characters. The length in PRIV(OP_lengths)[] is zero; the- actual length is stored in the compiled code, so we must update "code"- here. */--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- ccode = code += GET(code, 1);- goto CHECK_CLASS_REPEAT;-#endif-- case OP_CLASS:- case OP_NCLASS:- ccode = code + PRIV(OP_lengths)[OP_CLASS];--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- CHECK_CLASS_REPEAT:-#endif-- switch (*ccode)- {- case OP_CRSTAR: /* These could be empty; continue */- case OP_CRMINSTAR:- case OP_CRQUERY:- case OP_CRMINQUERY:- case OP_CRPOSSTAR:- case OP_CRPOSQUERY:- break;-- default: /* Non-repeat => class must match */- case OP_CRPLUS: /* These repeats aren't empty */- case OP_CRMINPLUS:- case OP_CRPOSPLUS:- return FALSE;-- case OP_CRRANGE:- case OP_CRMINRANGE:- case OP_CRPOSRANGE:- if (GET2(ccode, 1) > 0) return FALSE; /* Minimum > 0 */- break;- }- break;-- /* Opcodes that must match a character */-- case OP_ANY:- case OP_ALLANY:- case OP_ANYBYTE:-- case OP_PROP:- case OP_NOTPROP:- case OP_ANYNL:-- case OP_NOT_HSPACE:- case OP_HSPACE:- case OP_NOT_VSPACE:- case OP_VSPACE:- case OP_EXTUNI:-- case OP_NOT_DIGIT:- case OP_DIGIT:- case OP_NOT_WHITESPACE:- case OP_WHITESPACE:- case OP_NOT_WORDCHAR:- case OP_WORDCHAR:-- case OP_CHAR:- case OP_CHARI:- case OP_NOT:- case OP_NOTI:-- case OP_PLUS:- case OP_PLUSI:- case OP_MINPLUS:- case OP_MINPLUSI:-- case OP_NOTPLUS:- case OP_NOTPLUSI:- case OP_NOTMINPLUS:- case OP_NOTMINPLUSI:-- case OP_POSPLUS:- case OP_POSPLUSI:- case OP_NOTPOSPLUS:- case OP_NOTPOSPLUSI:-- case OP_EXACT:- case OP_EXACTI:- case OP_NOTEXACT:- case OP_NOTEXACTI:-- case OP_TYPEPLUS:- case OP_TYPEMINPLUS:- case OP_TYPEPOSPLUS:- case OP_TYPEEXACT:-- return FALSE;-- /* These are going to continue, as they may be empty, but we have to- fudge the length for the \p and \P cases. */-- case OP_TYPESTAR:- case OP_TYPEMINSTAR:- case OP_TYPEPOSSTAR:- case OP_TYPEQUERY:- case OP_TYPEMINQUERY:- case OP_TYPEPOSQUERY:- if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;- break;-- /* Same for these */-- case OP_TYPEUPTO:- case OP_TYPEMINUPTO:- case OP_TYPEPOSUPTO:- if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)- code += 2;- break;-- /* End of branch */-- case OP_KET:- case OP_KETRMAX:- case OP_KETRMIN:- case OP_KETRPOS:- case OP_ALT:- return TRUE;-- /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,- MINUPTO, and POSUPTO and their caseless and negative versions may be- followed by a multibyte character. */--#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- case OP_STAR:- case OP_STARI:- case OP_NOTSTAR:- case OP_NOTSTARI:-- case OP_MINSTAR:- case OP_MINSTARI:- case OP_NOTMINSTAR:- case OP_NOTMINSTARI:-- case OP_POSSTAR:- case OP_POSSTARI:- case OP_NOTPOSSTAR:- case OP_NOTPOSSTARI:-- case OP_QUERY:- case OP_QUERYI:- case OP_NOTQUERY:- case OP_NOTQUERYI:-- case OP_MINQUERY:- case OP_MINQUERYI:- case OP_NOTMINQUERY:- case OP_NOTMINQUERYI:-- case OP_POSQUERY:- case OP_POSQUERYI:- case OP_NOTPOSQUERY:- case OP_NOTPOSQUERYI:-- if (utf && HAS_EXTRALEN(code[1])) code += GET_EXTRALEN(code[1]);- break;-- case OP_UPTO:- case OP_UPTOI:- case OP_NOTUPTO:- case OP_NOTUPTOI:-- case OP_MINUPTO:- case OP_MINUPTOI:- case OP_NOTMINUPTO:- case OP_NOTMINUPTOI:-- case OP_POSUPTO:- case OP_POSUPTOI:- case OP_NOTPOSUPTO:- case OP_NOTPOSUPTOI:-- if (utf && HAS_EXTRALEN(code[1 + IMM2_SIZE])) code += GET_EXTRALEN(code[1 + IMM2_SIZE]);- break;-#endif-- /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument- string. */-- case OP_MARK:- case OP_PRUNE_ARG:- case OP_SKIP_ARG:- case OP_THEN_ARG:- code += code[1];- break;-- /* None of the remaining opcodes are required to match a character. */-- default:- break;- }- }--return TRUE;-}----/*************************************************-* Scan compiled regex for non-emptiness *-*************************************************/--/* This function is called to check for left recursive calls. We want to check-the current branch of the current pattern to see if it could match the empty-string. If it could, we must look outwards for branches at other levels,-stopping when we pass beyond the bracket which is the subject of the recursion.-This function is called only during the real compile, not during the-pre-compile.--Arguments:- code points to start of the recursion- endcode points to where to stop (current RECURSE item)- bcptr points to the chain of current (unclosed) branch starts- utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode- cd pointers to tables etc--Returns: TRUE if what is matched could be empty-*/--static BOOL-could_be_empty(const pcre_uchar *code, const pcre_uchar *endcode,- branch_chain *bcptr, BOOL utf, compile_data *cd)-{-while (bcptr != NULL && bcptr->current_branch >= code)- {- if (!could_be_empty_branch(bcptr->current_branch, endcode, utf, cd, NULL))- return FALSE;- bcptr = bcptr->outer;- }-return TRUE;-}----/*************************************************-* Base opcode of repeated opcodes *-*************************************************/--/* Returns the base opcode for repeated single character type opcodes. If the-opcode is not a repeated character type, it returns with the original value.--Arguments: c opcode-Returns: base opcode for the type-*/--static pcre_uchar-get_repeat_base(pcre_uchar c)-{-return (c > OP_TYPEPOSUPTO)? c :- (c >= OP_TYPESTAR)? OP_TYPESTAR :- (c >= OP_NOTSTARI)? OP_NOTSTARI :- (c >= OP_NOTSTAR)? OP_NOTSTAR :- (c >= OP_STARI)? OP_STARI :- OP_STAR;-}----#ifdef SUPPORT_UCP-/*************************************************-* Check a character and a property *-*************************************************/--/* This function is called by check_auto_possessive() when a property item-is adjacent to a fixed character.--Arguments:- c the character- ptype the property type- pdata the data for the type- negated TRUE if it's a negated property (\P or \p{^)--Returns: TRUE if auto-possessifying is OK-*/--static BOOL-check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata,- BOOL negated)-{-const pcre_uint32 *p;-const ucd_record *prop = GET_UCD(c);--switch(ptype)- {- case PT_LAMP:- return (prop->chartype == ucp_Lu ||- prop->chartype == ucp_Ll ||- prop->chartype == ucp_Lt) == negated;-- case PT_GC:- return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;-- case PT_PC:- return (pdata == prop->chartype) == negated;-- case PT_SC:- return (pdata == prop->script) == negated;-- /* These are specials */-- case PT_ALNUM:- return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||- PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;-- /* Perl space used to exclude VT, but from Perl 5.18 it is included, which- means that Perl space and POSIX space are now identical. PCRE was changed- at release 8.34. */-- case PT_SPACE: /* Perl space */- case PT_PXSPACE: /* POSIX space */- switch(c)- {- HSPACE_CASES:- VSPACE_CASES:- return negated;-- default:- return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated;- }- break; /* Control never reaches here */-- case PT_WORD:- return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||- PRIV(ucp_gentype)[prop->chartype] == ucp_N ||- c == CHAR_UNDERSCORE) == negated;-- case PT_CLIST:- p = PRIV(ucd_caseless_sets) + prop->caseset;- for (;;)- {- if (c < *p) return !negated;- if (c == *p++) return negated;- }- break; /* Control never reaches here */- }--return FALSE;-}-#endif /* SUPPORT_UCP */----/*************************************************-* Fill the character property list *-*************************************************/--/* Checks whether the code points to an opcode that can take part in auto--possessification, and if so, fills a list with its properties.--Arguments:- code points to start of expression- utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode- fcc points to case-flipping table- list points to output list- list[0] will be filled with the opcode- list[1] will be non-zero if this opcode- can match an empty character string- list[2..7] depends on the opcode--Returns: points to the start of the next opcode if *code is accepted- NULL if *code is not accepted-*/--static const pcre_uchar *-get_chr_property_list(const pcre_uchar *code, BOOL utf,- const pcre_uint8 *fcc, pcre_uint32 *list)-{-pcre_uchar c = *code;-pcre_uchar base;-const pcre_uchar *end;-pcre_uint32 chr;--#ifdef SUPPORT_UCP-pcre_uint32 *clist_dest;-const pcre_uint32 *clist_src;-#else-utf = utf; /* Suppress "unused parameter" compiler warning */-#endif--list[0] = c;-list[1] = FALSE;-code++;--if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)- {- base = get_repeat_base(c);- c -= (base - OP_STAR);-- if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO)- code += IMM2_SIZE;-- list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT && c != OP_POSPLUS);-- switch(base)- {- case OP_STAR:- list[0] = OP_CHAR;- break;-- case OP_STARI:- list[0] = OP_CHARI;- break;-- case OP_NOTSTAR:- list[0] = OP_NOT;- break;-- case OP_NOTSTARI:- list[0] = OP_NOTI;- break;-- case OP_TYPESTAR:- list[0] = *code;- code++;- break;- }- c = list[0];- }--switch(c)- {- case OP_NOT_DIGIT:- case OP_DIGIT:- case OP_NOT_WHITESPACE:- case OP_WHITESPACE:- case OP_NOT_WORDCHAR:- case OP_WORDCHAR:- case OP_ANY:- case OP_ALLANY:- case OP_ANYNL:- case OP_NOT_HSPACE:- case OP_HSPACE:- case OP_NOT_VSPACE:- case OP_VSPACE:- case OP_EXTUNI:- case OP_EODN:- case OP_EOD:- case OP_DOLL:- case OP_DOLLM:- return code;-- case OP_CHAR:- case OP_NOT:- GETCHARINCTEST(chr, code);- list[2] = chr;- list[3] = NOTACHAR;- return code;-- case OP_CHARI:- case OP_NOTI:- list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT;- GETCHARINCTEST(chr, code);- list[2] = chr;--#ifdef SUPPORT_UCP- if (chr < 128 || (chr < 256 && !utf))- list[3] = fcc[chr];- else- list[3] = UCD_OTHERCASE(chr);-#elif defined SUPPORT_UTF || !defined COMPILE_PCRE8- list[3] = (chr < 256) ? fcc[chr] : chr;-#else- list[3] = fcc[chr];-#endif-- /* The othercase might be the same value. */-- if (chr == list[3])- list[3] = NOTACHAR;- else- list[4] = NOTACHAR;- return code;--#ifdef SUPPORT_UCP- case OP_PROP:- case OP_NOTPROP:- if (code[0] != PT_CLIST)- {- list[2] = code[0];- list[3] = code[1];- return code + 2;- }-- /* Convert only if we have enough space. */-- clist_src = PRIV(ucd_caseless_sets) + code[1];- clist_dest = list + 2;- code += 2;-- do {- if (clist_dest >= list + 8)- {- /* Early return if there is not enough space. This should never- happen, since all clists are shorter than 5 character now. */- list[2] = code[0];- list[3] = code[1];- return code;- }- *clist_dest++ = *clist_src;- }- while(*clist_src++ != NOTACHAR);-- /* All characters are stored. The terminating NOTACHAR- is copied form the clist itself. */-- list[0] = (c == OP_PROP) ? OP_CHAR : OP_NOT;- return code;-#endif-- case OP_NCLASS:- case OP_CLASS:-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- if (c == OP_XCLASS)- end = code + GET(code, 0) - 1;- else-#endif- end = code + 32 / sizeof(pcre_uchar);-- switch(*end)- {- case OP_CRSTAR:- case OP_CRMINSTAR:- case OP_CRQUERY:- case OP_CRMINQUERY:- case OP_CRPOSSTAR:- case OP_CRPOSQUERY:- list[1] = TRUE;- end++;- break;-- case OP_CRPLUS:- case OP_CRMINPLUS:- case OP_CRPOSPLUS:- end++;- break;-- case OP_CRRANGE:- case OP_CRMINRANGE:- case OP_CRPOSRANGE:- list[1] = (GET2(end, 1) == 0);- end += 1 + 2 * IMM2_SIZE;- break;- }- list[2] = end - code;- return end;- }-return NULL; /* Opcode not accepted */-}----/*************************************************-* Scan further character sets for match *-*************************************************/--/* Checks whether the base and the current opcode have a common character, in-which case the base cannot be possessified.--Arguments:- code points to the byte code- utf TRUE in UTF-8 / UTF-16 / UTF-32 mode- cd static compile data- base_list the data list of the base opcode--Returns: TRUE if the auto-possessification is possible-*/--static BOOL-compare_opcodes(const pcre_uchar *code, BOOL utf, const compile_data *cd,- const pcre_uint32 *base_list, const pcre_uchar *base_end)-{-pcre_uchar c;-pcre_uint32 list[8];-const pcre_uint32 *chr_ptr;-const pcre_uint32 *ochr_ptr;-const pcre_uint32 *list_ptr;-const pcre_uchar *next_code;-const pcre_uint8 *class_bitset;-const pcre_uint32 *set1, *set2, *set_end;-pcre_uint32 chr;-BOOL accepted, invert_bits;--/* Note: the base_list[1] contains whether the current opcode has greedy-(represented by a non-zero value) quantifier. This is a different from-other character type lists, which stores here that the character iterator-matches to an empty string (also represented by a non-zero value). */--for(;;)- {- /* All operations move the code pointer forward.- Therefore infinite recursions are not possible. */-- c = *code;-- /* Skip over callouts */-- if (c == OP_CALLOUT)- {- code += PRIV(OP_lengths)[c];- continue;- }-- if (c == OP_ALT)- {- do code += GET(code, 1); while (*code == OP_ALT);- c = *code;- }-- switch(c)- {- case OP_END:- case OP_KETRPOS:- /* TRUE only in greedy case. The non-greedy case could be replaced by- an OP_EXACT, but it is probably not worth it. (And note that OP_EXACT- uses more memory, which we cannot get at this stage.) */-- return base_list[1] != 0;-- case OP_KET:- /* If the bracket is capturing, and referenced by an OP_RECURSE, or- it is an atomic sub-pattern (assert, once, etc.) the non-greedy case- cannot be converted to a possessive form. */-- if (base_list[1] == 0) return FALSE;-- switch(*(code - GET(code, 1)))- {- case OP_ASSERT:- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- case OP_ONCE:- case OP_ONCE_NC:- /* Atomic sub-patterns and assertions can always auto-possessify their- last iterator. */- return TRUE;- }-- code += PRIV(OP_lengths)[c];- continue;-- case OP_ONCE:- case OP_ONCE_NC:- case OP_BRA:- case OP_CBRA:- next_code = code + GET(code, 1);- code += PRIV(OP_lengths)[c];-- while (*next_code == OP_ALT)- {- if (!compare_opcodes(code, utf, cd, base_list, base_end)) return FALSE;- code = next_code + 1 + LINK_SIZE;- next_code += GET(next_code, 1);- }- continue;-- case OP_BRAZERO:- case OP_BRAMINZERO:-- next_code = code + 1;- if (*next_code != OP_BRA && *next_code != OP_CBRA- && *next_code != OP_ONCE && *next_code != OP_ONCE_NC) return FALSE;-- do next_code += GET(next_code, 1); while (*next_code == OP_ALT);-- /* The bracket content will be checked by the- OP_BRA/OP_CBRA case above. */- next_code += 1 + LINK_SIZE;- if (!compare_opcodes(next_code, utf, cd, base_list, base_end))- return FALSE;-- code += PRIV(OP_lengths)[c];- continue;- }-- /* Check for a supported opcode, and load its properties. */-- code = get_chr_property_list(code, utf, cd->fcc, list);- if (code == NULL) return FALSE; /* Unsupported */-- /* If either opcode is a small character list, set pointers for comparing- characters from that list with another list, or with a property. */-- if (base_list[0] == OP_CHAR)- {- chr_ptr = base_list + 2;- list_ptr = list;- }- else if (list[0] == OP_CHAR)- {- chr_ptr = list + 2;- list_ptr = base_list;- }-- /* Character bitsets can also be compared to certain opcodes. */-- else if (base_list[0] == OP_CLASS || list[0] == OP_CLASS-#ifdef COMPILE_PCRE8- /* In 8 bit, non-UTF mode, OP_CLASS and OP_NCLASS are the same. */- || (!utf && (base_list[0] == OP_NCLASS || list[0] == OP_NCLASS))-#endif- )- {-#ifdef COMPILE_PCRE8- if (base_list[0] == OP_CLASS || (!utf && base_list[0] == OP_NCLASS))-#else- if (base_list[0] == OP_CLASS)-#endif- {- set1 = (pcre_uint32 *)(base_end - base_list[2]);- list_ptr = list;- }- else- {- set1 = (pcre_uint32 *)(code - list[2]);- list_ptr = base_list;- }-- invert_bits = FALSE;- switch(list_ptr[0])- {- case OP_CLASS:- case OP_NCLASS:- set2 = (pcre_uint32 *)- ((list_ptr == list ? code : base_end) - list_ptr[2]);- break;-- /* OP_XCLASS cannot be supported here, because its bitset- is not necessarily complete. E.g: [a-\0x{200}] is stored- as a character range, and the appropriate bits are not set. */-- case OP_NOT_DIGIT:- invert_bits = TRUE;- /* Fall through */- case OP_DIGIT:- set2 = (pcre_uint32 *)(cd->cbits + cbit_digit);- break;-- case OP_NOT_WHITESPACE:- invert_bits = TRUE;- /* Fall through */- case OP_WHITESPACE:- set2 = (pcre_uint32 *)(cd->cbits + cbit_space);- break;-- case OP_NOT_WORDCHAR:- invert_bits = TRUE;- /* Fall through */- case OP_WORDCHAR:- set2 = (pcre_uint32 *)(cd->cbits + cbit_word);- break;-- default:- return FALSE;- }-- /* Compare 4 bytes to improve speed. */- set_end = set1 + (32 / 4);- if (invert_bits)- {- do- {- if ((*set1++ & ~(*set2++)) != 0) return FALSE;- }- while (set1 < set_end);- }- else- {- do- {- if ((*set1++ & *set2++) != 0) return FALSE;- }- while (set1 < set_end);- }-- if (list[1] == 0) return TRUE;- /* Might be an empty repeat. */- continue;- }-- /* Some property combinations also acceptable. Unicode property opcodes are- processed specially; the rest can be handled with a lookup table. */-- else- {- pcre_uint32 leftop, rightop;-- leftop = base_list[0];- rightop = list[0];--#ifdef SUPPORT_UCP- accepted = FALSE; /* Always set in non-unicode case. */- if (leftop == OP_PROP || leftop == OP_NOTPROP)- {- if (rightop == OP_EOD)- accepted = TRUE;- else if (rightop == OP_PROP || rightop == OP_NOTPROP)- {- int n;- const pcre_uint8 *p;- BOOL same = leftop == rightop;- BOOL lisprop = leftop == OP_PROP;- BOOL risprop = rightop == OP_PROP;- BOOL bothprop = lisprop && risprop;-- /* There's a table that specifies how each combination is to be- processed:- 0 Always return FALSE (never auto-possessify)- 1 Character groups are distinct (possessify if both are OP_PROP)- 2 Check character categories in the same group (general or particular)- 3 Return TRUE if the two opcodes are not the same- ... see comments below- */-- n = propposstab[base_list[2]][list[2]];- switch(n)- {- case 0: break;- case 1: accepted = bothprop; break;- case 2: accepted = (base_list[3] == list[3]) != same; break;- case 3: accepted = !same; break;-- case 4: /* Left general category, right particular category */- accepted = risprop && catposstab[base_list[3]][list[3]] == same;- break;-- case 5: /* Right general category, left particular category */- accepted = lisprop && catposstab[list[3]][base_list[3]] == same;- break;-- /* This code is logically tricky. Think hard before fiddling with it.- The posspropstab table has four entries per row. Each row relates to- one of PCRE's special properties such as ALNUM or SPACE or WORD.- Only WORD actually needs all four entries, but using repeats for the- others means they can all use the same code below.-- The first two entries in each row are Unicode general categories, and- apply always, because all the characters they include are part of the- PCRE character set. The third and fourth entries are a general and a- particular category, respectively, that include one or more relevant- characters. One or the other is used, depending on whether the check- is for a general or a particular category. However, in both cases the- category contains more characters than the specials that are defined- for the property being tested against. Therefore, it cannot be used- in a NOTPROP case.-- Example: the row for WORD contains ucp_L, ucp_N, ucp_P, ucp_Po.- Underscore is covered by ucp_P or ucp_Po. */-- case 6: /* Left alphanum vs right general category */- case 7: /* Left space vs right general category */- case 8: /* Left word vs right general category */- p = posspropstab[n-6];- accepted = risprop && lisprop ==- (list[3] != p[0] &&- list[3] != p[1] &&- (list[3] != p[2] || !lisprop));- break;-- case 9: /* Right alphanum vs left general category */- case 10: /* Right space vs left general category */- case 11: /* Right word vs left general category */- p = posspropstab[n-9];- accepted = lisprop && risprop ==- (base_list[3] != p[0] &&- base_list[3] != p[1] &&- (base_list[3] != p[2] || !risprop));- break;-- case 12: /* Left alphanum vs right particular category */- case 13: /* Left space vs right particular category */- case 14: /* Left word vs right particular category */- p = posspropstab[n-12];- accepted = risprop && lisprop ==- (catposstab[p[0]][list[3]] &&- catposstab[p[1]][list[3]] &&- (list[3] != p[3] || !lisprop));- break;-- case 15: /* Right alphanum vs left particular category */- case 16: /* Right space vs left particular category */- case 17: /* Right word vs left particular category */- p = posspropstab[n-15];- accepted = lisprop && risprop ==- (catposstab[p[0]][base_list[3]] &&- catposstab[p[1]][base_list[3]] &&- (base_list[3] != p[3] || !risprop));- break;- }- }- }-- else-#endif /* SUPPORT_UCP */-- accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP &&- rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP &&- autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP];-- if (!accepted)- return FALSE;-- if (list[1] == 0) return TRUE;- /* Might be an empty repeat. */- continue;- }-- /* Control reaches here only if one of the items is a small character list.- All characters are checked against the other side. */-- do- {- chr = *chr_ptr;-- switch(list_ptr[0])- {- case OP_CHAR:- ochr_ptr = list_ptr + 2;- do- {- if (chr == *ochr_ptr) return FALSE;- ochr_ptr++;- }- while(*ochr_ptr != NOTACHAR);- break;-- case OP_NOT:- ochr_ptr = list_ptr + 2;- do- {- if (chr == *ochr_ptr)- break;- ochr_ptr++;- }- while(*ochr_ptr != NOTACHAR);- if (*ochr_ptr == NOTACHAR) return FALSE; /* Not found */- break;-- /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not*- set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */-- case OP_DIGIT:- if (chr < 256 && (cd->ctypes[chr] & ctype_digit) != 0) return FALSE;- break;-- case OP_NOT_DIGIT:- if (chr > 255 || (cd->ctypes[chr] & ctype_digit) == 0) return FALSE;- break;-- case OP_WHITESPACE:- if (chr < 256 && (cd->ctypes[chr] & ctype_space) != 0) return FALSE;- break;-- case OP_NOT_WHITESPACE:- if (chr > 255 || (cd->ctypes[chr] & ctype_space) == 0) return FALSE;- break;-- case OP_WORDCHAR:- if (chr < 255 && (cd->ctypes[chr] & ctype_word) != 0) return FALSE;- break;-- case OP_NOT_WORDCHAR:- if (chr > 255 || (cd->ctypes[chr] & ctype_word) == 0) return FALSE;- break;-- case OP_HSPACE:- switch(chr)- {- HSPACE_CASES: return FALSE;- default: break;- }- break;-- case OP_NOT_HSPACE:- switch(chr)- {- HSPACE_CASES: break;- default: return FALSE;- }- break;-- case OP_ANYNL:- case OP_VSPACE:- switch(chr)- {- VSPACE_CASES: return FALSE;- default: break;- }- break;-- case OP_NOT_VSPACE:- switch(chr)- {- VSPACE_CASES: break;- default: return FALSE;- }- break;-- case OP_DOLL:- case OP_EODN:- switch (chr)- {- case CHAR_CR:- case CHAR_LF:- case CHAR_VT:- case CHAR_FF:- case CHAR_NEL:-#ifndef EBCDIC- case 0x2028:- case 0x2029:-#endif /* Not EBCDIC */- return FALSE;- }- break;-- case OP_EOD: /* Can always possessify before \z */- break;--#ifdef SUPPORT_UCP- case OP_PROP:- case OP_NOTPROP:- if (!check_char_prop(chr, list_ptr[2], list_ptr[3],- list_ptr[0] == OP_NOTPROP))- return FALSE;- break;-#endif-- case OP_NCLASS:- if (chr > 255) return FALSE;- /* Fall through */-- case OP_CLASS:- if (chr > 255) break;- class_bitset = (pcre_uint8 *)- ((list_ptr == list ? code : base_end) - list_ptr[2]);- if ((class_bitset[chr >> 3] & (1 << (chr & 7))) != 0) return FALSE;- break;--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) -- list_ptr[2] + LINK_SIZE, utf)) return FALSE;- break;-#endif-- default:- return FALSE;- }-- chr_ptr++;- }- while(*chr_ptr != NOTACHAR);-- /* At least one character must be matched from this opcode. */-- if (list[1] == 0) return TRUE;- }--return FALSE;-}----/*************************************************-* Scan compiled regex for auto-possession *-*************************************************/--/* Replaces single character iterations with their possessive alternatives-if appropriate. This function modifies the compiled opcode!--Arguments:- code points to start of the byte code- utf TRUE in UTF-8 / UTF-16 / UTF-32 mode- cd static compile data--Returns: nothing-*/--static void-auto_possessify(pcre_uchar *code, BOOL utf, const compile_data *cd)-{-register pcre_uchar c;-const pcre_uchar *end;-pcre_uchar *repeat_opcode;-pcre_uint32 list[8];--for (;;)- {- c = *code;-- if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)- {- c -= get_repeat_base(c) - OP_STAR;- end = (c <= OP_MINUPTO) ?- get_chr_property_list(code, utf, cd->fcc, list) : NULL;- list[1] = c == OP_STAR || c == OP_PLUS || c == OP_QUERY || c == OP_UPTO;-- if (end != NULL && compare_opcodes(end, utf, cd, list, end))- {- switch(c)- {- case OP_STAR:- *code += OP_POSSTAR - OP_STAR;- break;-- case OP_MINSTAR:- *code += OP_POSSTAR - OP_MINSTAR;- break;-- case OP_PLUS:- *code += OP_POSPLUS - OP_PLUS;- break;-- case OP_MINPLUS:- *code += OP_POSPLUS - OP_MINPLUS;- break;-- case OP_QUERY:- *code += OP_POSQUERY - OP_QUERY;- break;-- case OP_MINQUERY:- *code += OP_POSQUERY - OP_MINQUERY;- break;-- case OP_UPTO:- *code += OP_POSUPTO - OP_UPTO;- break;-- case OP_MINUPTO:- *code += OP_MINUPTO - OP_UPTO;- break;- }- }- c = *code;- }- else if (c == OP_CLASS || c == OP_NCLASS || c == OP_XCLASS)- {-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- if (c == OP_XCLASS)- repeat_opcode = code + GET(code, 1);- else-#endif- repeat_opcode = code + 1 + (32 / sizeof(pcre_uchar));-- c = *repeat_opcode;- if (c >= OP_CRSTAR && c <= OP_CRMINRANGE)- {- /* end must not be NULL. */- end = get_chr_property_list(code, utf, cd->fcc, list);-- list[1] = (c & 1) == 0;-- if (compare_opcodes(end, utf, cd, list, end))- {- switch (c)- {- case OP_CRSTAR:- case OP_CRMINSTAR:- *repeat_opcode = OP_CRPOSSTAR;- break;-- case OP_CRPLUS:- case OP_CRMINPLUS:- *repeat_opcode = OP_CRPOSPLUS;- break;-- case OP_CRQUERY:- case OP_CRMINQUERY:- *repeat_opcode = OP_CRPOSQUERY;- break;-- case OP_CRRANGE:- case OP_CRMINRANGE:- *repeat_opcode = OP_CRPOSRANGE;- break;- }- }- }- c = *code;- }-- switch(c)- {- case OP_END:- return;-- case OP_TYPESTAR:- case OP_TYPEMINSTAR:- case OP_TYPEPLUS:- case OP_TYPEMINPLUS:- case OP_TYPEQUERY:- case OP_TYPEMINQUERY:- case OP_TYPEPOSSTAR:- case OP_TYPEPOSPLUS:- case OP_TYPEPOSQUERY:- if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;- break;-- case OP_TYPEUPTO:- case OP_TYPEMINUPTO:- case OP_TYPEEXACT:- case OP_TYPEPOSUPTO:- if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)- code += 2;- break;--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- code += GET(code, 1);- break;-#endif-- case OP_MARK:- case OP_PRUNE_ARG:- case OP_SKIP_ARG:- case OP_THEN_ARG:- code += code[1];- break;- }-- /* Add in the fixed length from the table */-- code += PRIV(OP_lengths)[c];-- /* In UTF-8 mode, opcodes that are followed by a character may be followed by- a multi-byte character. The length in the table is a minimum, so we have to- arrange to skip the extra bytes. */--#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf) switch(c)- {- case OP_CHAR:- case OP_CHARI:- case OP_NOT:- case OP_NOTI:- case OP_STAR:- case OP_MINSTAR:- case OP_PLUS:- case OP_MINPLUS:- case OP_QUERY:- case OP_MINQUERY:- case OP_UPTO:- case OP_MINUPTO:- case OP_EXACT:- case OP_POSSTAR:- case OP_POSPLUS:- case OP_POSQUERY:- case OP_POSUPTO:- case OP_STARI:- case OP_MINSTARI:- case OP_PLUSI:- case OP_MINPLUSI:- case OP_QUERYI:- case OP_MINQUERYI:- case OP_UPTOI:- case OP_MINUPTOI:- case OP_EXACTI:- case OP_POSSTARI:- case OP_POSPLUSI:- case OP_POSQUERYI:- case OP_POSUPTOI:- case OP_NOTSTAR:- case OP_NOTMINSTAR:- case OP_NOTPLUS:- case OP_NOTMINPLUS:- case OP_NOTQUERY:- case OP_NOTMINQUERY:- case OP_NOTUPTO:- case OP_NOTMINUPTO:- case OP_NOTEXACT:- case OP_NOTPOSSTAR:- case OP_NOTPOSPLUS:- case OP_NOTPOSQUERY:- case OP_NOTPOSUPTO:- case OP_NOTSTARI:- case OP_NOTMINSTARI:- case OP_NOTPLUSI:- case OP_NOTMINPLUSI:- case OP_NOTQUERYI:- case OP_NOTMINQUERYI:- case OP_NOTUPTOI:- case OP_NOTMINUPTOI:- case OP_NOTEXACTI:- case OP_NOTPOSSTARI:- case OP_NOTPOSPLUSI:- case OP_NOTPOSQUERYI:- case OP_NOTPOSUPTOI:- if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);- break;- }-#else- (void)(utf); /* Keep compiler happy by referencing function argument */-#endif- }-}----/*************************************************-* Check for POSIX class syntax *-*************************************************/--/* This function is called when the sequence "[:" or "[." or "[=" is-encountered in a character class. It checks whether this is followed by a-sequence of characters terminated by a matching ":]" or ".]" or "=]". If we-reach an unescaped ']' without the special preceding character, return FALSE.--Originally, this function only recognized a sequence of letters between the-terminators, but it seems that Perl recognizes any sequence of characters,-though of course unknown POSIX names are subsequently rejected. Perl gives an-"Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE-didn't consider this to be a POSIX class. Likewise for [:1234:].--The problem in trying to be exactly like Perl is in the handling of escapes. We-have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX-class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code-below handles the special case of \], but does not try to do any other escape-processing. This makes it different from Perl for cases such as [:l\ower:]-where Perl recognizes it as the POSIX class "lower" but PCRE does not recognize-"l\ower". This is a lesser evil than not diagnosing bad classes when Perl does,-I think.--A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.-It seems that the appearance of a nested POSIX class supersedes an apparent-external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or-a digit.--In Perl, unescaped square brackets may also appear as part of class names. For-example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for-[:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not-seem right at all. PCRE does not allow closing square brackets in POSIX class-names.--Arguments:- ptr pointer to the initial [- endptr where to return the end pointer--Returns: TRUE or FALSE-*/--static BOOL-check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)-{-pcre_uchar terminator; /* Don't combine these lines; the Solaris cc */-terminator = *(++ptr); /* compiler warns about "non-constant" initializer. */-for (++ptr; *ptr != CHAR_NULL; ptr++)- {- if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)- ptr++;- else if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;- else- {- if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)- {- *endptr = ptr;- return TRUE;- }- if (*ptr == CHAR_LEFT_SQUARE_BRACKET &&- (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||- ptr[1] == CHAR_EQUALS_SIGN) &&- check_posix_syntax(ptr, endptr))- return FALSE;- }- }-return FALSE;-}-----/*************************************************-* Check POSIX class name *-*************************************************/--/* This function is called to check the name given in a POSIX-style class entry-such as [:alnum:].--Arguments:- ptr points to the first letter- len the length of the name--Returns: a value representing the name, or -1 if unknown-*/--static int-check_posix_name(const pcre_uchar *ptr, int len)-{-const char *pn = posix_names;-register int yield = 0;-while (posix_name_lengths[yield] != 0)- {- if (len == posix_name_lengths[yield] &&- STRNCMP_UC_C8(ptr, pn, (unsigned int)len) == 0) return yield;- pn += posix_name_lengths[yield] + 1;- yield++;- }-return -1;-}---/*************************************************-* Adjust OP_RECURSE items in repeated group *-*************************************************/--/* OP_RECURSE items contain an offset from the start of the regex to the group-that is referenced. This means that groups can be replicated for fixed-repetition simply by copying (because the recursion is allowed to refer to-earlier groups that are outside the current group). However, when a group is-optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is-inserted before it, after it has been compiled. This means that any OP_RECURSE-items within it that refer to the group itself or any contained groups have to-have their offsets adjusted. That one of the jobs of this function. Before it-is called, the partially compiled regex must be temporarily terminated with-OP_END.--This function has been extended with the possibility of forward references for-recursions and subroutine calls. It must also check the list of such references-for the group we are dealing with. If it finds that one of the recursions in-the current group is on this list, it adjusts the offset in the list, not the-value in the reference (which is a group number).--Arguments:- group points to the start of the group- adjust the amount by which the group is to be moved- utf TRUE in UTF-8 / UTF-16 / UTF-32 mode- cd contains pointers to tables etc.- save_hwm the hwm forward reference pointer at the start of the group--Returns: nothing-*/--static void-adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd,- pcre_uchar *save_hwm)-{-pcre_uchar *ptr = group;--while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)- {- int offset;- pcre_uchar *hc;-- /* See if this recursion is on the forward reference list. If so, adjust the- reference. */-- for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)- {- offset = (int)GET(hc, 0);- if (cd->start_code + offset == ptr + 1)- {- PUT(hc, 0, offset + adjust);- break;- }- }-- /* Otherwise, adjust the recursion offset if it's after the start of this- group. */-- if (hc >= cd->hwm)- {- offset = (int)GET(ptr, 1);- if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);- }-- ptr += 1 + LINK_SIZE;- }-}----/*************************************************-* Insert an automatic callout point *-*************************************************/--/* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert-callout points before each pattern item.--Arguments:- code current code pointer- ptr current pattern pointer- cd pointers to tables etc--Returns: new code pointer-*/--static pcre_uchar *-auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd)-{-*code++ = OP_CALLOUT;-*code++ = 255;-PUT(code, 0, (int)(ptr - cd->start_pattern)); /* Pattern offset */-PUT(code, LINK_SIZE, 0); /* Default length */-return code + 2 * LINK_SIZE;-}----/*************************************************-* Complete a callout item *-*************************************************/--/* A callout item contains the length of the next item in the pattern, which-we can't fill in till after we have reached the relevant point. This is used-for both automatic and manual callouts.--Arguments:- previous_callout points to previous callout item- ptr current pattern pointer- cd pointers to tables etc--Returns: nothing-*/--static void-complete_callout(pcre_uchar *previous_callout, const pcre_uchar *ptr, compile_data *cd)-{-int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));-PUT(previous_callout, 2 + LINK_SIZE, length);-}----#ifdef SUPPORT_UCP-/*************************************************-* Get othercase range *-*************************************************/--/* This function is passed the start and end of a class range, in UTF-8 mode-with UCP support. It searches up the characters, looking for ranges of-characters in the "other" case. Each call returns the next one, updating the-start address. A character with multiple other cases is returned on its own-with a special return value.--Arguments:- cptr points to starting character value; updated- d end value- ocptr where to put start of othercase range- odptr where to put end of othercase range--Yield: -1 when no more- 0 when a range is returned- >0 the CASESET offset for char with multiple other cases- in this case, ocptr contains the original-*/--static int-get_othercase_range(pcre_uint32 *cptr, pcre_uint32 d, pcre_uint32 *ocptr,- pcre_uint32 *odptr)-{-pcre_uint32 c, othercase, next;-unsigned int co;--/* Find the first character that has an other case. If it has multiple other-cases, return its case offset value. */--for (c = *cptr; c <= d; c++)- {- if ((co = UCD_CASESET(c)) != 0)- {- *ocptr = c++; /* Character that has the set */- *cptr = c; /* Rest of input range */- return (int)co;- }- if ((othercase = UCD_OTHERCASE(c)) != c) break;- }--if (c > d) return -1; /* Reached end of range */--*ocptr = othercase;-next = othercase + 1;--for (++c; c <= d; c++)- {- if (UCD_OTHERCASE(c) != next) break;- next++;- }--*odptr = next - 1; /* End of othercase range */-*cptr = c; /* Rest of input range */-return 0;-}-#endif /* SUPPORT_UCP */----/*************************************************-* Add a character or range to a class *-*************************************************/--/* This function packages up the logic of adding a character or range of-characters to a class. The character values in the arguments will be within the-valid values for the current mode (8-bit, 16-bit, UTF, etc). This function is-mutually recursive with the function immediately below.--Arguments:- classbits the bit map for characters < 256- uchardptr points to the pointer for extra data- options the options word- cd contains pointers to tables etc.- start start of range character- end end of range character--Returns: the number of < 256 characters added- the pointer to extra data is updated-*/--static int-add_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,- compile_data *cd, pcre_uint32 start, pcre_uint32 end)-{-pcre_uint32 c;-int n8 = 0;--/* If caseless matching is required, scan the range and process alternate-cases. In Unicode, there are 8-bit characters that have alternate cases that-are greater than 255 and vice-versa. Sometimes we can just extend the original-range. */--if ((options & PCRE_CASELESS) != 0)- {-#ifdef SUPPORT_UCP- if ((options & PCRE_UTF8) != 0)- {- int rc;- pcre_uint32 oc, od;-- options &= ~PCRE_CASELESS; /* Remove for recursive calls */- c = start;-- while ((rc = get_othercase_range(&c, end, &oc, &od)) >= 0)- {- /* Handle a single character that has more than one other case. */-- if (rc > 0) n8 += add_list_to_class(classbits, uchardptr, options, cd,- PRIV(ucd_caseless_sets) + rc, oc);-- /* Do nothing if the other case range is within the original range. */-- else if (oc >= start && od <= end) continue;-- /* Extend the original range if there is overlap, noting that if oc < c, we- can't have od > end because a subrange is always shorter than the basic- range. Otherwise, use a recursive call to add the additional range. */-- else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */- else if (od > end && oc <= end + 1) end = od; /* Extend upwards */- else n8 += add_to_class(classbits, uchardptr, options, cd, oc, od);- }- }- else-#endif /* SUPPORT_UCP */-- /* Not UTF-mode, or no UCP */-- for (c = start; c <= end && c < 256; c++)- {- SETBIT(classbits, cd->fcc[c]);- n8++;- }- }--/* Now handle the original range. Adjust the final value according to the bit-length - this means that the same lists of (e.g.) horizontal spaces can be used-in all cases. */--#if defined COMPILE_PCRE8-#ifdef SUPPORT_UTF- if ((options & PCRE_UTF8) == 0)-#endif- if (end > 0xff) end = 0xff;--#elif defined COMPILE_PCRE16-#ifdef SUPPORT_UTF- if ((options & PCRE_UTF16) == 0)-#endif- if (end > 0xffff) end = 0xffff;--#endif /* COMPILE_PCRE[8|16] */--/* If all characters are less than 256, use the bit map. Otherwise use extra-data. */--if (end < 0x100)- {- for (c = start; c <= end; c++)- {- n8++;- SETBIT(classbits, c);- }- }--else- {- pcre_uchar *uchardata = *uchardptr;--#ifdef SUPPORT_UTF- if ((options & PCRE_UTF8) != 0) /* All UTFs use the same flag bit */- {- if (start < end)- {- *uchardata++ = XCL_RANGE;- uchardata += PRIV(ord2utf)(start, uchardata);- uchardata += PRIV(ord2utf)(end, uchardata);- }- else if (start == end)- {- *uchardata++ = XCL_SINGLE;- uchardata += PRIV(ord2utf)(start, uchardata);- }- }- else-#endif /* SUPPORT_UTF */-- /* Without UTF support, character values are constrained by the bit length,- and can only be > 256 for 16-bit and 32-bit libraries. */--#ifdef COMPILE_PCRE8- {}-#else- if (start < end)- {- *uchardata++ = XCL_RANGE;- *uchardata++ = start;- *uchardata++ = end;- }- else if (start == end)- {- *uchardata++ = XCL_SINGLE;- *uchardata++ = start;- }-#endif-- *uchardptr = uchardata; /* Updata extra data pointer */- }--return n8; /* Number of 8-bit characters */-}-----/*************************************************-* Add a list of characters to a class *-*************************************************/--/* This function is used for adding a list of case-equivalent characters to a-class, and also for adding a list of horizontal or vertical whitespace. If the-list is in order (which it should be), ranges of characters are detected and-handled appropriately. This function is mutually recursive with the function-above.--Arguments:- classbits the bit map for characters < 256- uchardptr points to the pointer for extra data- options the options word- cd contains pointers to tables etc.- p points to row of 32-bit values, terminated by NOTACHAR- except character to omit; this is used when adding lists of- case-equivalent characters to avoid including the one we- already know about--Returns: the number of < 256 characters added- the pointer to extra data is updated-*/--static int-add_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,- compile_data *cd, const pcre_uint32 *p, unsigned int except)-{-int n8 = 0;-while (p[0] < NOTACHAR)- {- int n = 0;- if (p[0] != except)- {- while(p[n+1] == p[0] + n + 1) n++;- n8 += add_to_class(classbits, uchardptr, options, cd, p[0], p[n]);- }- p += n + 1;- }-return n8;-}----/*************************************************-* Add characters not in a list to a class *-*************************************************/--/* This function is used for adding the complement of a list of horizontal or-vertical whitespace to a class. The list must be in order.--Arguments:- classbits the bit map for characters < 256- uchardptr points to the pointer for extra data- options the options word- cd contains pointers to tables etc.- p points to row of 32-bit values, terminated by NOTACHAR--Returns: the number of < 256 characters added- the pointer to extra data is updated-*/--static int-add_not_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr,- int options, compile_data *cd, const pcre_uint32 *p)-{-BOOL utf = (options & PCRE_UTF8) != 0;-int n8 = 0;-if (p[0] > 0)- n8 += add_to_class(classbits, uchardptr, options, cd, 0, p[0] - 1);-while (p[0] < NOTACHAR)- {- while (p[1] == p[0] + 1) p++;- n8 += add_to_class(classbits, uchardptr, options, cd, p[0] + 1,- (p[1] == NOTACHAR) ? (utf ? 0x10ffffu : 0xffffffffu) : p[1] - 1);- p++;- }-return n8;-}----/*************************************************-* Compile one branch *-*************************************************/--/* Scan the pattern, compiling it into the a vector. If the options are-changed during the branch, the pointer is used to change the external options-bits. This function is used during the pre-compile phase when we are trying-to find out the amount of memory needed, as well as during the real compile-phase. The value of lengthptr distinguishes the two phases.--Arguments:- optionsptr pointer to the option bits- codeptr points to the pointer to the current code point- ptrptr points to the current pattern pointer- errorcodeptr points to error code variable- firstcharptr place to put the first required character- firstcharflagsptr place to put the first character flags, or a negative number- reqcharptr place to put the last required character- reqcharflagsptr place to put the last required character flags, or a negative number- bcptr points to current branch chain- cond_depth conditional nesting depth- cd contains pointers to tables etc.- lengthptr NULL during the real compile phase- points to length accumulator during pre-compile phase--Returns: TRUE on success- FALSE, with *errorcodeptr set non-zero on error-*/--static BOOL-compile_branch(int *optionsptr, pcre_uchar **codeptr,- const pcre_uchar **ptrptr, int *errorcodeptr,- pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,- pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,- branch_chain *bcptr, int cond_depth,- compile_data *cd, int *lengthptr)-{-int repeat_type, op_type;-int repeat_min = 0, repeat_max = 0; /* To please picky compilers */-int bravalue = 0;-int greedy_default, greedy_non_default;-pcre_uint32 firstchar, reqchar;-pcre_int32 firstcharflags, reqcharflags;-pcre_uint32 zeroreqchar, zerofirstchar;-pcre_int32 zeroreqcharflags, zerofirstcharflags;-pcre_int32 req_caseopt, reqvary, tempreqvary;-int options = *optionsptr; /* May change dynamically */-int after_manual_callout = 0;-int length_prevgroup = 0;-register pcre_uint32 c;-int escape;-register pcre_uchar *code = *codeptr;-pcre_uchar *last_code = code;-pcre_uchar *orig_code = code;-pcre_uchar *tempcode;-BOOL inescq = FALSE;-BOOL groupsetfirstchar = FALSE;-const pcre_uchar *ptr = *ptrptr;-const pcre_uchar *tempptr;-const pcre_uchar *nestptr = NULL;-pcre_uchar *previous = NULL;-pcre_uchar *previous_callout = NULL;-pcre_uchar *save_hwm = NULL;-pcre_uint8 classbits[32];--/* We can fish out the UTF-8 setting once and for all into a BOOL, but we-must not do this for other options (e.g. PCRE_EXTENDED) because they may change-dynamically as we process the pattern. */--#ifdef SUPPORT_UTF-/* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */-BOOL utf = (options & PCRE_UTF8) != 0;-#ifndef COMPILE_PCRE32-pcre_uchar utf_chars[6];-#endif-#else-BOOL utf = FALSE;-#endif--/* Helper variables for OP_XCLASS opcode (for characters > 255). We define-class_uchardata always so that it can be passed to add_to_class() always,-though it will not be used in non-UTF 8-bit cases. This avoids having to supply-alternative calls for the different cases. */--pcre_uchar *class_uchardata;-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8-BOOL xclass;-pcre_uchar *class_uchardata_base;-#endif--#ifdef PCRE_DEBUG-if (lengthptr != NULL) DPRINTF((">> start branch\n"));-#endif--/* Set up the default and non-default settings for greediness */--greedy_default = ((options & PCRE_UNGREEDY) != 0);-greedy_non_default = greedy_default ^ 1;--/* Initialize no first byte, no required byte. REQ_UNSET means "no char-matching encountered yet". It gets changed to REQ_NONE if we hit something that-matches a non-fixed char first char; reqchar just remains unset if we never-find one.--When we hit a repeat whose minimum is zero, we may have to adjust these values-to take the zero repeat into account. This is implemented by setting them to-zerofirstbyte and zeroreqchar when such a repeat is encountered. The individual-item types that can be repeated set these backoff variables appropriately. */--firstchar = reqchar = zerofirstchar = zeroreqchar = 0;-firstcharflags = reqcharflags = zerofirstcharflags = zeroreqcharflags = REQ_UNSET;--/* The variable req_caseopt contains either the REQ_CASELESS value-or zero, according to the current setting of the caseless flag. The-REQ_CASELESS leaves the lower 28 bit empty. It is added into the-firstchar or reqchar variables to record the case status of the-value. This is used only for ASCII characters. */--req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS:0;--/* Switch on next character until the end of the branch */--for (;; ptr++)- {- BOOL negate_class;- BOOL should_flip_negation;- BOOL possessive_quantifier;- BOOL is_quantifier;- BOOL is_recurse;- BOOL reset_bracount;- int class_has_8bitchar;- int class_one_char;- int newoptions;- int recno;- int refsign;- int skipbytes;- pcre_uint32 subreqchar, subfirstchar;- pcre_int32 subreqcharflags, subfirstcharflags;- int terminator;- unsigned int mclength;- unsigned int tempbracount;- pcre_uint32 ec;- pcre_uchar mcbuffer[8];-- /* Get next character in the pattern */-- c = *ptr;-- /* If we are at the end of a nested substitution, revert to the outer level- string. Nesting only happens one level deep. */-- if (c == CHAR_NULL && nestptr != NULL)- {- ptr = nestptr;- nestptr = NULL;- c = *ptr;- }-- /* If we are in the pre-compile phase, accumulate the length used for the- previous cycle of this loop. */-- if (lengthptr != NULL)- {-#ifdef PCRE_DEBUG- if (code > cd->hwm) cd->hwm = code; /* High water info */-#endif- if (code > cd->start_workspace + cd->workspace_size -- WORK_SIZE_SAFETY_MARGIN) /* Check for overrun */- {- *errorcodeptr = ERR52;- goto FAILED;- }-- /* There is at least one situation where code goes backwards: this is the- case of a zero quantifier after a class (e.g. [ab]{0}). At compile time,- the class is simply eliminated. However, it is created first, so we have to- allow memory for it. Therefore, don't ever reduce the length at this point.- */-- if (code < last_code) code = last_code;-- /* Paranoid check for integer overflow */-- if (OFLOW_MAX - *lengthptr < code - last_code)- {- *errorcodeptr = ERR20;- goto FAILED;- }-- *lengthptr += (int)(code - last_code);- DPRINTF(("length=%d added %d c=%c (0x%x)\n", *lengthptr,- (int)(code - last_code), c, c));-- /* If "previous" is set and it is not at the start of the work space, move- it back to there, in order to avoid filling up the work space. Otherwise,- if "previous" is NULL, reset the current code pointer to the start. */-- if (previous != NULL)- {- if (previous > orig_code)- {- memmove(orig_code, previous, IN_UCHARS(code - previous));- code -= previous - orig_code;- previous = orig_code;- }- }- else code = orig_code;-- /* Remember where this code item starts so we can pick up the length- next time round. */-- last_code = code;- }-- /* In the real compile phase, just check the workspace used by the forward- reference list. */-- else if (cd->hwm > cd->start_workspace + cd->workspace_size -- WORK_SIZE_SAFETY_MARGIN)- {- *errorcodeptr = ERR52;- goto FAILED;- }-- /* If in \Q...\E, check for the end; if not, we have a literal */-- if (inescq && c != CHAR_NULL)- {- if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)- {- inescq = FALSE;- ptr++;- continue;- }- else- {- if (previous_callout != NULL)- {- if (lengthptr == NULL) /* Don't attempt in pre-compile phase */- complete_callout(previous_callout, ptr, cd);- previous_callout = NULL;- }- if ((options & PCRE_AUTO_CALLOUT) != 0)- {- previous_callout = code;- code = auto_callout(code, ptr, cd);- }- goto NORMAL_CHAR;- }- /* Control does not reach here. */- }-- /* In extended mode, skip white space and comments. We need a loop in order- to check for more white space and more comments after a comment. */-- if ((options & PCRE_EXTENDED) != 0)- {- for (;;)- {- while (MAX_255(c) && (cd->ctypes[c] & ctype_space) != 0) c = *(++ptr);- if (c != CHAR_NUMBER_SIGN) break;- ptr++;- while (*ptr != CHAR_NULL)- {- if (IS_NEWLINE(ptr)) /* For non-fixed-length newline cases, */- { /* IS_NEWLINE sets cd->nllen. */- ptr += cd->nllen;- break;- }- ptr++;-#ifdef SUPPORT_UTF- if (utf) FORWARDCHAR(ptr);-#endif- }- c = *ptr; /* Either NULL or the char after a newline */- }- }-- /* See if the next thing is a quantifier. */-- is_quantifier =- c == CHAR_ASTERISK || c == CHAR_PLUS || c == CHAR_QUESTION_MARK ||- (c == CHAR_LEFT_CURLY_BRACKET && is_counted_repeat(ptr+1));-- /* Fill in length of a previous callout, except when the next thing is a- quantifier or when processing a property substitution string in UCP mode. */-- if (!is_quantifier && previous_callout != NULL && nestptr == NULL &&- after_manual_callout-- <= 0)- {- if (lengthptr == NULL) /* Don't attempt in pre-compile phase */- complete_callout(previous_callout, ptr, cd);- previous_callout = NULL;- }-- /* Create auto callout, except for quantifiers, or while processing property- strings that are substituted for \w etc in UCP mode. */-- if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier && nestptr == NULL)- {- previous_callout = code;- code = auto_callout(code, ptr, cd);- }-- /* Process the next pattern item. */-- switch(c)- {- /* ===================================================================*/- case CHAR_NULL: /* The branch terminates at string end */- case CHAR_VERTICAL_LINE: /* or | or ) */- case CHAR_RIGHT_PARENTHESIS:- *firstcharptr = firstchar;- *firstcharflagsptr = firstcharflags;- *reqcharptr = reqchar;- *reqcharflagsptr = reqcharflags;- *codeptr = code;- *ptrptr = ptr;- if (lengthptr != NULL)- {- if (OFLOW_MAX - *lengthptr < code - last_code)- {- *errorcodeptr = ERR20;- goto FAILED;- }- *lengthptr += (int)(code - last_code); /* To include callout length */- DPRINTF((">> end branch\n"));- }- return TRUE;--- /* ===================================================================*/- /* Handle single-character metacharacters. In multiline mode, ^ disables- the setting of any following char as a first character. */-- case CHAR_CIRCUMFLEX_ACCENT:- previous = NULL;- if ((options & PCRE_MULTILINE) != 0)- {- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- *code++ = OP_CIRCM;- }- else *code++ = OP_CIRC;- break;-- case CHAR_DOLLAR_SIGN:- previous = NULL;- *code++ = ((options & PCRE_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;- break;-- /* There can never be a first char if '.' is first, whatever happens about- repeats. The value of reqchar doesn't change either. */-- case CHAR_DOT:- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- zerofirstchar = firstchar;- zerofirstcharflags = firstcharflags;- zeroreqchar = reqchar;- zeroreqcharflags = reqcharflags;- previous = code;- *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;- break;--- /* ===================================================================*/- /* Character classes. If the included characters are all < 256, we build a- 32-byte bitmap of the permitted characters, except in the special case- where there is only one such character. For negated classes, we build the- map as usual, then invert it at the end. However, we use a different opcode- so that data characters > 255 can be handled correctly.-- If the class contains characters outside the 0-255 range, a different- opcode is compiled. It may optionally have a bit map for characters < 256,- but those above are are explicitly listed afterwards. A flag byte tells- whether the bitmap is present, and whether this is a negated class or not.-- In JavaScript compatibility mode, an isolated ']' causes an error. In- default (Perl) mode, it is treated as a data character. */-- case CHAR_RIGHT_SQUARE_BRACKET:- if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)- {- *errorcodeptr = ERR64;- goto FAILED;- }- goto NORMAL_CHAR;-- /* In another (POSIX) regex library, the ugly syntax [[:<:]] and [[:>:]] is- used for "start of word" and "end of word". As these are otherwise illegal- sequences, we don't break anything by recognizing them. They are replaced- by \b(?=\w) and \b(?<=\w) respectively. Sequences like [a[:<:]] are- erroneous and are handled by the normal code below. */-- case CHAR_LEFT_SQUARE_BRACKET:- if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_STARTWORD, 6) == 0)- {- nestptr = ptr + 7;- ptr = sub_start_of_word - 1;- continue;- }-- if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_ENDWORD, 6) == 0)- {- nestptr = ptr + 7;- ptr = sub_end_of_word - 1;- continue;- }-- /* Handle a real character class. */-- previous = code;-- /* PCRE supports POSIX class stuff inside a class. Perl gives an error if- they are encountered at the top level, so we'll do that too. */-- if ((ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||- ptr[1] == CHAR_EQUALS_SIGN) &&- check_posix_syntax(ptr, &tempptr))- {- *errorcodeptr = (ptr[1] == CHAR_COLON)? ERR13 : ERR31;- goto FAILED;- }-- /* If the first character is '^', set the negation flag and skip it. Also,- if the first few characters (either before or after ^) are \Q\E or \E we- skip them too. This makes for compatibility with Perl. */-- negate_class = FALSE;- for (;;)- {- c = *(++ptr);- if (c == CHAR_BACKSLASH)- {- if (ptr[1] == CHAR_E)- ptr++;- else if (STRNCMP_UC_C8(ptr + 1, STR_Q STR_BACKSLASH STR_E, 3) == 0)- ptr += 3;- else- break;- }- else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)- negate_class = TRUE;- else break;- }-- /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,- an initial ']' is taken as a data character -- the code below handles- that. In JS mode, [] must always fail, so generate OP_FAIL, whereas- [^] must match any character, so generate OP_ALLANY. */-- if (c == CHAR_RIGHT_SQUARE_BRACKET &&- (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)- {- *code++ = negate_class? OP_ALLANY : OP_FAIL;- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- zerofirstchar = firstchar;- zerofirstcharflags = firstcharflags;- break;- }-- /* If a class contains a negative special such as \S, we need to flip the- negation flag at the end, so that support for characters > 255 works- correctly (they are all included in the class). */-- should_flip_negation = FALSE;-- /* For optimization purposes, we track some properties of the class:- class_has_8bitchar will be non-zero if the class contains at least one <- 256 character; class_one_char will be 1 if the class contains just one- character. */-- class_has_8bitchar = 0;- class_one_char = 0;-- /* Initialize the 32-char bit map to all zeros. We build the map in a- temporary bit of memory, in case the class contains fewer than two- 8-bit characters because in that case the compiled code doesn't use the bit- map. */-- memset(classbits, 0, 32 * sizeof(pcre_uint8));--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- xclass = FALSE;- class_uchardata = code + LINK_SIZE + 2; /* For XCLASS items */- class_uchardata_base = class_uchardata; /* Save the start */-#endif-- /* Process characters until ] is reached. By writing this as a "do" it- means that an initial ] is taken as a data character. At the start of the- loop, c contains the first byte of the character. */-- if (c != CHAR_NULL) do- {- const pcre_uchar *oldptr;--#ifdef SUPPORT_UTF- if (utf && HAS_EXTRALEN(c))- { /* Braces are required because the */- GETCHARLEN(c, ptr, ptr); /* macro generates multiple statements */- }-#endif--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- /* In the pre-compile phase, accumulate the length of any extra- data and reset the pointer. This is so that very large classes that- contain a zillion > 255 characters no longer overwrite the work space- (which is on the stack). We have to remember that there was XCLASS data,- however. */-- if (lengthptr != NULL && class_uchardata > class_uchardata_base)- {- xclass = TRUE;- *lengthptr += class_uchardata - class_uchardata_base;- class_uchardata = class_uchardata_base;- }-#endif-- /* Inside \Q...\E everything is literal except \E */-- if (inescq)- {- if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E) /* If we are at \E */- {- inescq = FALSE; /* Reset literal state */- ptr++; /* Skip the 'E' */- continue; /* Carry on with next */- }- goto CHECK_RANGE; /* Could be range if \E follows */- }-- /* Handle POSIX class names. Perl allows a negation extension of the- form [:^name:]. A square bracket that doesn't match the syntax is- treated as a literal. We also recognize the POSIX constructions- [.ch.] and [=ch=] ("collating elements") and fault them, as Perl- 5.6 and 5.8 do. */-- if (c == CHAR_LEFT_SQUARE_BRACKET &&- (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||- ptr[1] == CHAR_EQUALS_SIGN) && check_posix_syntax(ptr, &tempptr))- {- BOOL local_negate = FALSE;- int posix_class, taboffset, tabopt;- register const pcre_uint8 *cbits = cd->cbits;- pcre_uint8 pbits[32];-- if (ptr[1] != CHAR_COLON)- {- *errorcodeptr = ERR31;- goto FAILED;- }-- ptr += 2;- if (*ptr == CHAR_CIRCUMFLEX_ACCENT)- {- local_negate = TRUE;- should_flip_negation = TRUE; /* Note negative special */- ptr++;- }-- posix_class = check_posix_name(ptr, (int)(tempptr - ptr));- if (posix_class < 0)- {- *errorcodeptr = ERR30;- goto FAILED;- }-- /* If matching is caseless, upper and lower are converted to- alpha. This relies on the fact that the class table starts with- alpha, lower, upper as the first 3 entries. */-- if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)- posix_class = 0;-- /* When PCRE_UCP is set, some of the POSIX classes are converted to- different escape sequences that use Unicode properties \p or \P. Others- that are not available via \p or \P generate XCL_PROP/XCL_NOTPROP- directly. */--#ifdef SUPPORT_UCP- if ((options & PCRE_UCP) != 0)- {- unsigned int ptype = 0;- int pc = posix_class + ((local_negate)? POSIX_SUBSIZE/2 : 0);-- /* The posix_substitutes table specifies which POSIX classes can be- converted to \p or \P items. */-- if (posix_substitutes[pc] != NULL)- {- nestptr = tempptr + 1;- ptr = posix_substitutes[pc] - 1;- continue;- }-- /* There are three other classes that generate special property calls- that are recognized only in an XCLASS. */-- else switch(posix_class)- {- case PC_GRAPH:- ptype = PT_PXGRAPH;- /* Fall through */- case PC_PRINT:- if (ptype == 0) ptype = PT_PXPRINT;- /* Fall through */- case PC_PUNCT:- if (ptype == 0) ptype = PT_PXPUNCT;- *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP;- *class_uchardata++ = ptype;- *class_uchardata++ = 0;- ptr = tempptr + 1;- continue;-- /* For all other POSIX classes, no special action is taken in UCP- mode. Fall through to the non_UCP case. */-- default:- break;- }- }-#endif- /* In the non-UCP case, or when UCP makes no difference, we build the- bit map for the POSIX class in a chunk of local store because we may be- adding and subtracting from it, and we don't want to subtract bits that- may be in the main map already. At the end we or the result into the- bit map that is being built. */-- posix_class *= 3;-- /* Copy in the first table (always present) */-- memcpy(pbits, cbits + posix_class_maps[posix_class],- 32 * sizeof(pcre_uint8));-- /* If there is a second table, add or remove it as required. */-- taboffset = posix_class_maps[posix_class + 1];- tabopt = posix_class_maps[posix_class + 2];-- if (taboffset >= 0)- {- if (tabopt >= 0)- for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];- else- for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];- }-- /* Now see if we need to remove any special characters. An option- value of 1 removes vertical space and 2 removes underscore. */-- if (tabopt < 0) tabopt = -tabopt;- if (tabopt == 1) pbits[1] &= ~0x3c;- else if (tabopt == 2) pbits[11] &= 0x7f;-- /* Add the POSIX table or its complement into the main table that is- being built and we are done. */-- if (local_negate)- for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];- else- for (c = 0; c < 32; c++) classbits[c] |= pbits[c];-- ptr = tempptr + 1;- /* Every class contains at least one < 256 character. */- class_has_8bitchar = 1;- /* Every class contains at least two characters. */- class_one_char = 2;- continue; /* End of POSIX syntax handling */- }-- /* Backslash may introduce a single character, or it may introduce one- of the specials, which just set a flag. The sequence \b is a special- case. Inside a class (and only there) it is treated as backspace. We- assume that other escapes have more than one character in them, so- speculatively set both class_has_8bitchar and class_one_char bigger- than one. Unrecognized escapes fall through and are either treated- as literal characters (by default), or are faulted if- PCRE_EXTRA is set. */-- if (c == CHAR_BACKSLASH)- {- escape = check_escape(&ptr, &ec, errorcodeptr, cd->bracount, options,- TRUE);- if (*errorcodeptr != 0) goto FAILED;- if (escape == 0) c = ec;- else if (escape == ESC_b) c = CHAR_BS; /* \b is backspace in a class */- else if (escape == ESC_N) /* \N is not supported in a class */- {- *errorcodeptr = ERR71;- goto FAILED;- }- else if (escape == ESC_Q) /* Handle start of quoted string */- {- if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)- {- ptr += 2; /* avoid empty string */- }- else inescq = TRUE;- continue;- }- else if (escape == ESC_E) continue; /* Ignore orphan \E */-- else- {- register const pcre_uint8 *cbits = cd->cbits;- /* Every class contains at least two < 256 characters. */- class_has_8bitchar++;- /* Every class contains at least two characters. */- class_one_char += 2;-- switch (escape)- {-#ifdef SUPPORT_UCP- case ESC_du: /* These are the values given for \d etc */- case ESC_DU: /* when PCRE_UCP is set. We replace the */- case ESC_wu: /* escape sequence with an appropriate \p */- case ESC_WU: /* or \P to test Unicode properties instead */- case ESC_su: /* of the default ASCII testing. */- case ESC_SU:- nestptr = ptr;- ptr = substitutes[escape - ESC_DU] - 1; /* Just before substitute */- class_has_8bitchar--; /* Undo! */- continue;-#endif- case ESC_d:- for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];- continue;-- case ESC_D:- should_flip_negation = TRUE;- for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];- continue;-- case ESC_w:- for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];- continue;-- case ESC_W:- should_flip_negation = TRUE;- for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];- continue;-- /* Perl 5.004 onwards omitted VT from \s, but restored it at Perl- 5.18. Before PCRE 8.34, we had to preserve the VT bit if it was- previously set by something earlier in the character class.- Luckily, the value of CHAR_VT is 0x0b in both ASCII and EBCDIC, so- we could just adjust the appropriate bit. From PCRE 8.34 we no- longer treat \s and \S specially. */-- case ESC_s:- for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];- continue;-- case ESC_S:- should_flip_negation = TRUE;- for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];- continue;-- /* The rest apply in both UCP and non-UCP cases. */-- case ESC_h:- (void)add_list_to_class(classbits, &class_uchardata, options, cd,- PRIV(hspace_list), NOTACHAR);- continue;-- case ESC_H:- (void)add_not_list_to_class(classbits, &class_uchardata, options,- cd, PRIV(hspace_list));- continue;-- case ESC_v:- (void)add_list_to_class(classbits, &class_uchardata, options, cd,- PRIV(vspace_list), NOTACHAR);- continue;-- case ESC_V:- (void)add_not_list_to_class(classbits, &class_uchardata, options,- cd, PRIV(vspace_list));- continue;--#ifdef SUPPORT_UCP- case ESC_p:- case ESC_P:- {- BOOL negated;- unsigned int ptype = 0, pdata = 0;- if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))- goto FAILED;- *class_uchardata++ = ((escape == ESC_p) != negated)?- XCL_PROP : XCL_NOTPROP;- *class_uchardata++ = ptype;- *class_uchardata++ = pdata;- class_has_8bitchar--; /* Undo! */- continue;- }-#endif- /* Unrecognized escapes are faulted if PCRE is running in its- strict mode. By default, for compatibility with Perl, they are- treated as literals. */-- default:- if ((options & PCRE_EXTRA) != 0)- {- *errorcodeptr = ERR7;- goto FAILED;- }- class_has_8bitchar--; /* Undo the speculative increase. */- class_one_char -= 2; /* Undo the speculative increase. */- c = *ptr; /* Get the final character and fall through */- break;- }- }-- /* Fall through if the escape just defined a single character (c >= 0).- This may be greater than 256. */-- escape = 0;-- } /* End of backslash handling */-- /* A character may be followed by '-' to form a range. However, Perl does- not permit ']' to be the end of the range. A '-' character at the end is- treated as a literal. Perl ignores orphaned \E sequences entirely. The- code for handling \Q and \E is messy. */-- CHECK_RANGE:- while (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)- {- inescq = FALSE;- ptr += 2;- }- oldptr = ptr;-- /* Remember if \r or \n were explicitly used */-- if (c == CHAR_CR || c == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;-- /* Check for range */-- if (!inescq && ptr[1] == CHAR_MINUS)- {- pcre_uint32 d;- ptr += 2;- while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E) ptr += 2;-- /* If we hit \Q (not followed by \E) at this point, go into escaped- mode. */-- while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_Q)- {- ptr += 2;- if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E)- { ptr += 2; continue; }- inescq = TRUE;- break;- }-- /* Minus (hyphen) at the end of a class is treated as a literal, so put- back the pointer and jump to handle the character that preceded it. */-- if (*ptr == CHAR_NULL || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))- {- ptr = oldptr;- goto CLASS_SINGLE_CHARACTER;- }-- /* Otherwise, we have a potential range; pick up the next character */--#ifdef SUPPORT_UTF- if (utf)- { /* Braces are required because the */- GETCHARLEN(d, ptr, ptr); /* macro generates multiple statements */- }- else-#endif- d = *ptr; /* Not UTF-8 mode */-- /* The second part of a range can be a single-character escape- sequence, but not any of the other escapes. Perl treats a hyphen as a- literal in such circumstances. However, in Perl's warning mode, a- warning is given, so PCRE now faults it as it is almost certainly a- mistake on the user's part. */-- if (!inescq)- {- if (d == CHAR_BACKSLASH)- {- int descape;- descape = check_escape(&ptr, &d, errorcodeptr, cd->bracount, options, TRUE);- if (*errorcodeptr != 0) goto FAILED;-- /* 0 means a character was put into d; \b is backspace; any other- special causes an error. */-- if (descape != 0)- {- if (descape == ESC_b) d = CHAR_BS; else- {- *errorcodeptr = ERR83;- goto FAILED;- }- }- }-- /* A hyphen followed by a POSIX class is treated in the same way. */-- else if (d == CHAR_LEFT_SQUARE_BRACKET &&- (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||- ptr[1] == CHAR_EQUALS_SIGN) &&- check_posix_syntax(ptr, &tempptr))- {- *errorcodeptr = ERR83;- goto FAILED;- }- }-- /* Check that the two values are in the correct order. Optimize- one-character ranges. */-- if (d < c)- {- *errorcodeptr = ERR8;- goto FAILED;- }- if (d == c) goto CLASS_SINGLE_CHARACTER; /* A few lines below */-- /* We have found a character range, so single character optimizations- cannot be done anymore. Any value greater than 1 indicates that there- is more than one character. */-- class_one_char = 2;-- /* Remember an explicit \r or \n, and add the range to the class. */-- if (d == CHAR_CR || d == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;-- class_has_8bitchar +=- add_to_class(classbits, &class_uchardata, options, cd, c, d);-- continue; /* Go get the next char in the class */- }-- /* Handle a single character - we can get here for a normal non-escape- char, or after \ that introduces a single character or for an apparent- range that isn't. Only the value 1 matters for class_one_char, so don't- increase it if it is already 2 or more ... just in case there's a class- with a zillion characters in it. */-- CLASS_SINGLE_CHARACTER:- if (class_one_char < 2) class_one_char++;-- /* If class_one_char is 1, we have the first single character in the- class, and there have been no prior ranges, or XCLASS items generated by- escapes. If this is the final character in the class, we can optimize by- turning the item into a 1-character OP_CHAR[I] if it's positive, or- OP_NOT[I] if it's negative. In the positive case, it can cause firstchar- to be set. Otherwise, there can be no first char if this item is first,- whatever repeat count may follow. In the case of reqchar, save the- previous value for reinstating. */-- if (class_one_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)- {- ptr++;- zeroreqchar = reqchar;- zeroreqcharflags = reqcharflags;-- if (negate_class)- {-#ifdef SUPPORT_UCP- int d;-#endif- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- zerofirstchar = firstchar;- zerofirstcharflags = firstcharflags;-- /* For caseless UTF-8 mode when UCP support is available, check- whether this character has more than one other case. If so, generate- a special OP_NOTPROP item instead of OP_NOTI. */--#ifdef SUPPORT_UCP- if (utf && (options & PCRE_CASELESS) != 0 &&- (d = UCD_CASESET(c)) != 0)- {- *code++ = OP_NOTPROP;- *code++ = PT_CLIST;- *code++ = d;- }- else-#endif- /* Char has only one other case, or UCP not available */-- {- *code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)- code += PRIV(ord2utf)(c, code);- else-#endif- *code++ = c;- }-- /* We are finished with this character class */-- goto END_CLASS;- }-- /* For a single, positive character, get the value into mcbuffer, and- then we can handle this with the normal one-character code. */--#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)- mclength = PRIV(ord2utf)(c, mcbuffer);- else-#endif- {- mcbuffer[0] = c;- mclength = 1;- }- goto ONE_CHAR;- } /* End of 1-char optimization */-- /* There is more than one character in the class, or an XCLASS item- has been generated. Add this character to the class. */-- class_has_8bitchar +=- add_to_class(classbits, &class_uchardata, options, cd, c, c);- }-- /* Loop until ']' reached. This "while" is the end of the "do" far above.- If we are at the end of an internal nested string, revert to the outer- string. */-- while (((c = *(++ptr)) != CHAR_NULL ||- (nestptr != NULL &&- (ptr = nestptr, nestptr = NULL, c = *(++ptr)) != CHAR_NULL)) &&- (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));-- /* Check for missing terminating ']' */-- if (c == CHAR_NULL)- {- *errorcodeptr = ERR6;- goto FAILED;- }-- /* We will need an XCLASS if data has been placed in class_uchardata. In- the second phase this is a sufficient test. However, in the pre-compile- phase, class_uchardata gets emptied to prevent workspace overflow, so it- only if the very last character in the class needs XCLASS will it contain- anything at this point. For this reason, xclass gets set TRUE above when- uchar_classdata is emptied, and that's why this code is the way it is here- instead of just doing a test on class_uchardata below. */--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- if (class_uchardata > class_uchardata_base) xclass = TRUE;-#endif-- /* If this is the first thing in the branch, there can be no first char- setting, whatever the repeat count. Any reqchar setting must remain- unchanged after any kind of repeat. */-- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- zerofirstchar = firstchar;- zerofirstcharflags = firstcharflags;- zeroreqchar = reqchar;- zeroreqcharflags = reqcharflags;-- /* If there are characters with values > 255, we have to compile an- extended class, with its own opcode, unless there was a negated special- such as \S in the class, and PCRE_UCP is not set, because in that case all- characters > 255 are in the class, so any that were explicitly given as- well can be ignored. If (when there are explicit characters > 255 that must- be listed) there are no characters < 256, we can omit the bitmap in the- actual compiled code. */--#ifdef SUPPORT_UTF- if (xclass && (!should_flip_negation || (options & PCRE_UCP) != 0))-#elif !defined COMPILE_PCRE8- if (xclass && !should_flip_negation)-#endif-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- {- *class_uchardata++ = XCL_END; /* Marks the end of extra data */- *code++ = OP_XCLASS;- code += LINK_SIZE;- *code = negate_class? XCL_NOT:0;-- /* If the map is required, move up the extra data to make room for it;- otherwise just move the code pointer to the end of the extra data. */-- if (class_has_8bitchar > 0)- {- *code++ |= XCL_MAP;- memmove(code + (32 / sizeof(pcre_uchar)), code,- IN_UCHARS(class_uchardata - code));- memcpy(code, classbits, 32);- code = class_uchardata + (32 / sizeof(pcre_uchar));- }- else code = class_uchardata;-- /* Now fill in the complete length of the item */-- PUT(previous, 1, (int)(code - previous));- break; /* End of class handling */- }-#endif-- /* If there are no characters > 255, or they are all to be included or- excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the- whole class was negated and whether there were negative specials such as \S- (non-UCP) in the class. Then copy the 32-byte map into the code vector,- negating it if necessary. */-- *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;- if (lengthptr == NULL) /* Save time in the pre-compile phase */- {- if (negate_class)- for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];- memcpy(code, classbits, 32);- }- code += 32 / sizeof(pcre_uchar);-- END_CLASS:- break;--- /* ===================================================================*/- /* Various kinds of repeat; '{' is not necessarily a quantifier, but this- has been tested above. */-- case CHAR_LEFT_CURLY_BRACKET:- if (!is_quantifier) goto NORMAL_CHAR;- ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);- if (*errorcodeptr != 0) goto FAILED;- goto REPEAT;-- case CHAR_ASTERISK:- repeat_min = 0;- repeat_max = -1;- goto REPEAT;-- case CHAR_PLUS:- repeat_min = 1;- repeat_max = -1;- goto REPEAT;-- case CHAR_QUESTION_MARK:- repeat_min = 0;- repeat_max = 1;-- REPEAT:- if (previous == NULL)- {- *errorcodeptr = ERR9;- goto FAILED;- }-- if (repeat_min == 0)- {- firstchar = zerofirstchar; /* Adjust for zero repeat */- firstcharflags = zerofirstcharflags;- reqchar = zeroreqchar; /* Ditto */- reqcharflags = zeroreqcharflags;- }-- /* Remember whether this is a variable length repeat */-- reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;-- op_type = 0; /* Default single-char op codes */- possessive_quantifier = FALSE; /* Default not possessive quantifier */-- /* Save start of previous item, in case we have to move it up in order to- insert something before it. */-- tempcode = previous;-- /* Before checking for a possessive quantifier, we must skip over- whitespace and comments in extended mode because Perl allows white space at- this point. */-- if ((options & PCRE_EXTENDED) != 0)- {- const pcre_uchar *p = ptr + 1;- for (;;)- {- while (MAX_255(*p) && (cd->ctypes[*p] & ctype_space) != 0) p++;- if (*p != CHAR_NUMBER_SIGN) break;- p++;- while (*p != CHAR_NULL)- {- if (IS_NEWLINE(p)) /* For non-fixed-length newline cases, */- { /* IS_NEWLINE sets cd->nllen. */- p += cd->nllen;- break;- }- p++;-#ifdef SUPPORT_UTF- if (utf) FORWARDCHAR(p);-#endif- } /* Loop for comment characters */- } /* Loop for multiple comments */- ptr = p - 1; /* Character before the next significant one. */- }-- /* If the next character is '+', we have a possessive quantifier. This- implies greediness, whatever the setting of the PCRE_UNGREEDY option.- If the next character is '?' this is a minimizing repeat, by default,- but if PCRE_UNGREEDY is set, it works the other way round. We change the- repeat type to the non-default. */-- if (ptr[1] == CHAR_PLUS)- {- repeat_type = 0; /* Force greedy */- possessive_quantifier = TRUE;- ptr++;- }- else if (ptr[1] == CHAR_QUESTION_MARK)- {- repeat_type = greedy_non_default;- ptr++;- }- else repeat_type = greedy_default;-- /* If previous was a recursion call, wrap it in atomic brackets so that- previous becomes the atomic group. All recursions were so wrapped in the- past, but it no longer happens for non-repeated recursions. In fact, the- repeated ones could be re-implemented independently so as not to need this,- but for the moment we rely on the code for repeating groups. */-- if (*previous == OP_RECURSE)- {- memmove(previous + 1 + LINK_SIZE, previous, IN_UCHARS(1 + LINK_SIZE));- *previous = OP_ONCE;- PUT(previous, 1, 2 + 2*LINK_SIZE);- previous[2 + 2*LINK_SIZE] = OP_KET;- PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);- code += 2 + 2 * LINK_SIZE;- length_prevgroup = 3 + 3*LINK_SIZE;-- /* When actually compiling, we need to check whether this was a forward- reference, and if so, adjust the offset. */-- if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)- {- int offset = GET(cd->hwm, -LINK_SIZE);- if (offset == previous + 1 - cd->start_code)- PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);- }- }-- /* Now handle repetition for the different types of item. */-- /* If previous was a character or negated character match, abolish the item- and generate a repeat item instead. If a char item has a minimum of more- than one, ensure that it is set in reqchar - it might not be if a sequence- such as x{3} is the first thing in a branch because the x will have gone- into firstchar instead. */-- if (*previous == OP_CHAR || *previous == OP_CHARI- || *previous == OP_NOT || *previous == OP_NOTI)- {- switch (*previous)- {- default: /* Make compiler happy. */- case OP_CHAR: op_type = OP_STAR - OP_STAR; break;- case OP_CHARI: op_type = OP_STARI - OP_STAR; break;- case OP_NOT: op_type = OP_NOTSTAR - OP_STAR; break;- case OP_NOTI: op_type = OP_NOTSTARI - OP_STAR; break;- }-- /* Deal with UTF characters that take up more than one character. It's- easier to write this out separately than try to macrify it. Use c to- hold the length of the character in bytes, plus UTF_LENGTH to flag that- it's a length rather than a small character. */--#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf && NOT_FIRSTCHAR(code[-1]))- {- pcre_uchar *lastchar = code - 1;- BACKCHAR(lastchar);- c = (int)(code - lastchar); /* Length of UTF-8 character */- memcpy(utf_chars, lastchar, IN_UCHARS(c)); /* Save the char */- c |= UTF_LENGTH; /* Flag c as a length */- }- else-#endif /* SUPPORT_UTF */-- /* Handle the case of a single charater - either with no UTF support, or- with UTF disabled, or for a single character UTF character. */- {- c = code[-1];- if (*previous <= OP_CHARI && repeat_min > 1)- {- reqchar = c;- reqcharflags = req_caseopt | cd->req_varyopt;- }- }-- goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */- }-- /* If previous was a character type match (\d or similar), abolish it and- create a suitable repeat item. The code is shared with single-character- repeats by setting op_type to add a suitable offset into repeat_type. Note- the the Unicode property types will be present only when SUPPORT_UCP is- defined, but we don't wrap the little bits of code here because it just- makes it horribly messy. */-- else if (*previous < OP_EODN)- {- pcre_uchar *oldcode;- int prop_type, prop_value;- op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */- c = *previous;-- OUTPUT_SINGLE_REPEAT:- if (*previous == OP_PROP || *previous == OP_NOTPROP)- {- prop_type = previous[1];- prop_value = previous[2];- }- else prop_type = prop_value = -1;-- oldcode = code;- code = previous; /* Usually overwrite previous item */-- /* If the maximum is zero then the minimum must also be zero; Perl allows- this case, so we do too - by simply omitting the item altogether. */-- if (repeat_max == 0) goto END_REPEAT;-- /* Combine the op_type with the repeat_type */-- repeat_type += op_type;-- /* A minimum of zero is handled either as the special case * or ?, or as- an UPTO, with the maximum given. */-- if (repeat_min == 0)- {- if (repeat_max == -1) *code++ = OP_STAR + repeat_type;- else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;- else- {- *code++ = OP_UPTO + repeat_type;- PUT2INC(code, 0, repeat_max);- }- }-- /* A repeat minimum of 1 is optimized into some special cases. If the- maximum is unlimited, we use OP_PLUS. Otherwise, the original item is- left in place and, if the maximum is greater than 1, we use OP_UPTO with- one less than the maximum. */-- else if (repeat_min == 1)- {- if (repeat_max == -1)- *code++ = OP_PLUS + repeat_type;- else- {- code = oldcode; /* leave previous item in place */- if (repeat_max == 1) goto END_REPEAT;- *code++ = OP_UPTO + repeat_type;- PUT2INC(code, 0, repeat_max - 1);- }- }-- /* The case {n,n} is just an EXACT, while the general case {n,m} is- handled as an EXACT followed by an UPTO. */-- else- {- *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */- PUT2INC(code, 0, repeat_min);-- /* If the maximum is unlimited, insert an OP_STAR. Before doing so,- we have to insert the character for the previous code. For a repeated- Unicode property match, there are two extra bytes that define the- required property. In UTF-8 mode, long characters have their length in- c, with the UTF_LENGTH bit as a flag. */-- if (repeat_max < 0)- {-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf && (c & UTF_LENGTH) != 0)- {- memcpy(code, utf_chars, IN_UCHARS(c & 7));- code += c & 7;- }- else-#endif- {- *code++ = c;- if (prop_type >= 0)- {- *code++ = prop_type;- *code++ = prop_value;- }- }- *code++ = OP_STAR + repeat_type;- }-- /* Else insert an UPTO if the max is greater than the min, again- preceded by the character, for the previously inserted code. If the- UPTO is just for 1 instance, we can use QUERY instead. */-- else if (repeat_max != repeat_min)- {-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf && (c & UTF_LENGTH) != 0)- {- memcpy(code, utf_chars, IN_UCHARS(c & 7));- code += c & 7;- }- else-#endif- *code++ = c;- if (prop_type >= 0)- {- *code++ = prop_type;- *code++ = prop_value;- }- repeat_max -= repeat_min;-- if (repeat_max == 1)- {- *code++ = OP_QUERY + repeat_type;- }- else- {- *code++ = OP_UPTO + repeat_type;- PUT2INC(code, 0, repeat_max);- }- }- }-- /* The character or character type itself comes last in all cases. */--#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf && (c & UTF_LENGTH) != 0)- {- memcpy(code, utf_chars, IN_UCHARS(c & 7));- code += c & 7;- }- else-#endif- *code++ = c;-- /* For a repeated Unicode property match, there are two extra bytes that- define the required property. */--#ifdef SUPPORT_UCP- if (prop_type >= 0)- {- *code++ = prop_type;- *code++ = prop_value;- }-#endif- }-- /* If previous was a character class or a back reference, we put the repeat- stuff after it, but just skip the item if the repeat was {0,0}. */-- else if (*previous == OP_CLASS || *previous == OP_NCLASS ||-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- *previous == OP_XCLASS ||-#endif- *previous == OP_REF || *previous == OP_REFI ||- *previous == OP_DNREF || *previous == OP_DNREFI)- {- if (repeat_max == 0)- {- code = previous;- goto END_REPEAT;- }-- if (repeat_min == 0 && repeat_max == -1)- *code++ = OP_CRSTAR + repeat_type;- else if (repeat_min == 1 && repeat_max == -1)- *code++ = OP_CRPLUS + repeat_type;- else if (repeat_min == 0 && repeat_max == 1)- *code++ = OP_CRQUERY + repeat_type;- else- {- *code++ = OP_CRRANGE + repeat_type;- PUT2INC(code, 0, repeat_min);- if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */- PUT2INC(code, 0, repeat_max);- }- }-- /* If previous was a bracket group, we may have to replicate it in certain- cases. Note that at this point we can encounter only the "basic" bracket- opcodes such as BRA and CBRA, as this is the place where they get converted- into the more special varieties such as BRAPOS and SBRA. A test for >=- OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK,- ASSERTBACK_NOT, ONCE, ONCE_NC, BRA, BRAPOS, CBRA, CBRAPOS, and COND.- Originally, PCRE did not allow repetition of assertions, but now it does,- for Perl compatibility. */-- else if (*previous >= OP_ASSERT && *previous <= OP_COND)- {- register int i;- int len = (int)(code - previous);- pcre_uchar *bralink = NULL;- pcre_uchar *brazeroptr = NULL;-- /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so- we just ignore the repeat. */-- if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)- goto END_REPEAT;-- /* There is no sense in actually repeating assertions. The only potential- use of repetition is in cases when the assertion is optional. Therefore,- if the minimum is greater than zero, just ignore the repeat. If the- maximum is not zero or one, set it to 1. */-- if (*previous < OP_ONCE) /* Assertion */- {- if (repeat_min > 0) goto END_REPEAT;- if (repeat_max < 0 || repeat_max > 1) repeat_max = 1;- }-- /* The case of a zero minimum is special because of the need to stick- OP_BRAZERO in front of it, and because the group appears once in the- data, whereas in other cases it appears the minimum number of times. For- this reason, it is simplest to treat this case separately, as otherwise- the code gets far too messy. There are several special subcases when the- minimum is zero. */-- if (repeat_min == 0)- {- /* If the maximum is also zero, we used to just omit the group from the- output altogether, like this:-- ** if (repeat_max == 0)- ** {- ** code = previous;- ** goto END_REPEAT;- ** }-- However, that fails when a group or a subgroup within it is referenced- as a subroutine from elsewhere in the pattern, so now we stick in- OP_SKIPZERO in front of it so that it is skipped on execution. As we- don't have a list of which groups are referenced, we cannot do this- selectively.-- If the maximum is 1 or unlimited, we just have to stick in the BRAZERO- and do no more at this point. However, we do need to adjust any- OP_RECURSE calls inside the group that refer to the group itself or any- internal or forward referenced group, because the offset is from the- start of the whole regex. Temporarily terminate the pattern while doing- this. */-- if (repeat_max <= 1) /* Covers 0, 1, and unlimited */- {- *code = OP_END;- adjust_recurse(previous, 1, utf, cd, save_hwm);- memmove(previous + 1, previous, IN_UCHARS(len));- code++;- if (repeat_max == 0)- {- *previous++ = OP_SKIPZERO;- goto END_REPEAT;- }- brazeroptr = previous; /* Save for possessive optimizing */- *previous++ = OP_BRAZERO + repeat_type;- }-- /* If the maximum is greater than 1 and limited, we have to replicate- in a nested fashion, sticking OP_BRAZERO before each set of brackets.- The first one has to be handled carefully because it's the original- copy, which has to be moved up. The remainder can be handled by code- that is common with the non-zero minimum case below. We have to- adjust the value or repeat_max, since one less copy is required. Once- again, we may have to adjust any OP_RECURSE calls inside the group. */-- else- {- int offset;- *code = OP_END;- adjust_recurse(previous, 2 + LINK_SIZE, utf, cd, save_hwm);- memmove(previous + 2 + LINK_SIZE, previous, IN_UCHARS(len));- code += 2 + LINK_SIZE;- *previous++ = OP_BRAZERO + repeat_type;- *previous++ = OP_BRA;-- /* We chain together the bracket offset fields that have to be- filled in later when the ends of the brackets are reached. */-- offset = (bralink == NULL)? 0 : (int)(previous - bralink);- bralink = previous;- PUTINC(previous, 0, offset);- }-- repeat_max--;- }-- /* If the minimum is greater than zero, replicate the group as many- times as necessary, and adjust the maximum to the number of subsequent- copies that we need. If we set a first char from the group, and didn't- set a required char, copy the latter from the former. If there are any- forward reference subroutine calls in the group, there will be entries on- the workspace list; replicate these with an appropriate increment. */-- else- {- if (repeat_min > 1)- {- /* In the pre-compile phase, we don't actually do the replication. We- just adjust the length as if we had. Do some paranoid checks for- potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit- integer type when available, otherwise double. */-- if (lengthptr != NULL)- {- int delta = (repeat_min - 1)*length_prevgroup;- if ((INT64_OR_DOUBLE)(repeat_min - 1)*- (INT64_OR_DOUBLE)length_prevgroup >- (INT64_OR_DOUBLE)INT_MAX ||- OFLOW_MAX - *lengthptr < delta)- {- *errorcodeptr = ERR20;- goto FAILED;- }- *lengthptr += delta;- }-- /* This is compiling for real. If there is a set first byte for- the group, and we have not yet set a "required byte", set it. Make- sure there is enough workspace for copying forward references before- doing the copy. */-- else- {- if (groupsetfirstchar && reqcharflags < 0)- {- reqchar = firstchar;- reqcharflags = firstcharflags;- }-- for (i = 1; i < repeat_min; i++)- {- pcre_uchar *hc;- pcre_uchar *this_hwm = cd->hwm;- memcpy(code, previous, IN_UCHARS(len));-- while (cd->hwm > cd->start_workspace + cd->workspace_size -- WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm))- {- int save_offset = save_hwm - cd->start_workspace;- int this_offset = this_hwm - cd->start_workspace;- *errorcodeptr = expand_workspace(cd);- if (*errorcodeptr != 0) goto FAILED;- save_hwm = (pcre_uchar *)cd->start_workspace + save_offset;- this_hwm = (pcre_uchar *)cd->start_workspace + this_offset;- }-- for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)- {- PUT(cd->hwm, 0, GET(hc, 0) + len);- cd->hwm += LINK_SIZE;- }- save_hwm = this_hwm;- code += len;- }- }- }-- if (repeat_max > 0) repeat_max -= repeat_min;- }-- /* This code is common to both the zero and non-zero minimum cases. If- the maximum is limited, it replicates the group in a nested fashion,- remembering the bracket starts on a stack. In the case of a zero minimum,- the first one was set up above. In all cases the repeat_max now specifies- the number of additional copies needed. Again, we must remember to- replicate entries on the forward reference list. */-- if (repeat_max >= 0)- {- /* In the pre-compile phase, we don't actually do the replication. We- just adjust the length as if we had. For each repetition we must add 1- to the length for BRAZERO and for all but the last repetition we must- add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some- paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is- a 64-bit integer type when available, otherwise double. */-- if (lengthptr != NULL && repeat_max > 0)- {- int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -- 2 - 2*LINK_SIZE; /* Last one doesn't nest */- if ((INT64_OR_DOUBLE)repeat_max *- (INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)- > (INT64_OR_DOUBLE)INT_MAX ||- OFLOW_MAX - *lengthptr < delta)- {- *errorcodeptr = ERR20;- goto FAILED;- }- *lengthptr += delta;- }-- /* This is compiling for real */-- else for (i = repeat_max - 1; i >= 0; i--)- {- pcre_uchar *hc;- pcre_uchar *this_hwm = cd->hwm;-- *code++ = OP_BRAZERO + repeat_type;-- /* All but the final copy start a new nesting, maintaining the- chain of brackets outstanding. */-- if (i != 0)- {- int offset;- *code++ = OP_BRA;- offset = (bralink == NULL)? 0 : (int)(code - bralink);- bralink = code;- PUTINC(code, 0, offset);- }-- memcpy(code, previous, IN_UCHARS(len));-- /* Ensure there is enough workspace for forward references before- copying them. */-- while (cd->hwm > cd->start_workspace + cd->workspace_size -- WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm))- {- int save_offset = save_hwm - cd->start_workspace;- int this_offset = this_hwm - cd->start_workspace;- *errorcodeptr = expand_workspace(cd);- if (*errorcodeptr != 0) goto FAILED;- save_hwm = (pcre_uchar *)cd->start_workspace + save_offset;- this_hwm = (pcre_uchar *)cd->start_workspace + this_offset;- }-- for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)- {- PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));- cd->hwm += LINK_SIZE;- }- save_hwm = this_hwm;- code += len;- }-- /* Now chain through the pending brackets, and fill in their length- fields (which are holding the chain links pro tem). */-- while (bralink != NULL)- {- int oldlinkoffset;- int offset = (int)(code - bralink + 1);- pcre_uchar *bra = code - offset;- oldlinkoffset = GET(bra, 1);- bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;- *code++ = OP_KET;- PUTINC(code, 0, offset);- PUT(bra, 1, offset);- }- }-- /* If the maximum is unlimited, set a repeater in the final copy. For- ONCE brackets, that's all we need to do. However, possessively repeated- ONCE brackets can be converted into non-capturing brackets, as the- behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to- deal with possessive ONCEs specially.-- Otherwise, when we are doing the actual compile phase, check to see- whether this group is one that could match an empty string. If so,- convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so- that runtime checking can be done. [This check is also applied to ONCE- groups at runtime, but in a different way.]-- Then, if the quantifier was possessive and the bracket is not a- conditional, we convert the BRA code to the POS form, and the KET code to- KETRPOS. (It turns out to be convenient at runtime to detect this kind of- subpattern at both the start and at the end.) The use of special opcodes- makes it possible to reduce greatly the stack usage in pcre_exec(). If- the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO.-- Then, if the minimum number of matches is 1 or 0, cancel the possessive- flag so that the default action below, of wrapping everything inside- atomic brackets, does not happen. When the minimum is greater than 1,- there will be earlier copies of the group, and so we still have to wrap- the whole thing. */-- else- {- pcre_uchar *ketcode = code - 1 - LINK_SIZE;- pcre_uchar *bracode = ketcode - GET(ketcode, 1);-- /* Convert possessive ONCE brackets to non-capturing */-- if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) &&- possessive_quantifier) *bracode = OP_BRA;-- /* For non-possessive ONCE brackets, all we need to do is to- set the KET. */-- if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC)- *ketcode = OP_KETRMAX + repeat_type;-- /* Handle non-ONCE brackets and possessive ONCEs (which have been- converted to non-capturing above). */-- else- {- /* In the compile phase, check for empty string matching. */-- if (lengthptr == NULL)- {- pcre_uchar *scode = bracode;- do- {- if (could_be_empty_branch(scode, ketcode, utf, cd, NULL))- {- *bracode += OP_SBRA - OP_BRA;- break;- }- scode += GET(scode, 1);- }- while (*scode == OP_ALT);- }-- /* Handle possessive quantifiers. */-- if (possessive_quantifier)- {- /* For COND brackets, we wrap the whole thing in a possessively- repeated non-capturing bracket, because we have not invented POS- versions of the COND opcodes. Because we are moving code along, we- must ensure that any pending recursive references are updated. */-- if (*bracode == OP_COND || *bracode == OP_SCOND)- {- int nlen = (int)(code - bracode);- *code = OP_END;- adjust_recurse(bracode, 1 + LINK_SIZE, utf, cd, save_hwm);- memmove(bracode + 1 + LINK_SIZE, bracode, IN_UCHARS(nlen));- code += 1 + LINK_SIZE;- nlen += 1 + LINK_SIZE;- *bracode = OP_BRAPOS;- *code++ = OP_KETRPOS;- PUTINC(code, 0, nlen);- PUT(bracode, 1, nlen);- }-- /* For non-COND brackets, we modify the BRA code and use KETRPOS. */-- else- {- *bracode += 1; /* Switch to xxxPOS opcodes */- *ketcode = OP_KETRPOS;- }-- /* If the minimum is zero, mark it as possessive, then unset the- possessive flag when the minimum is 0 or 1. */-- if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;- if (repeat_min < 2) possessive_quantifier = FALSE;- }-- /* Non-possessive quantifier */-- else *ketcode = OP_KETRMAX + repeat_type;- }- }- }-- /* If previous is OP_FAIL, it was generated by an empty class [] in- JavaScript mode. The other ways in which OP_FAIL can be generated, that is- by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"- error above. We can just ignore the repeat in JS case. */-- else if (*previous == OP_FAIL) goto END_REPEAT;-- /* Else there's some kind of shambles */-- else- {- *errorcodeptr = ERR11;- goto FAILED;- }-- /* If the character following a repeat is '+', possessive_quantifier is- TRUE. For some opcodes, there are special alternative opcodes for this- case. For anything else, we wrap the entire repeated item inside OP_ONCE- brackets. Logically, the '+' notation is just syntactic sugar, taken from- Sun's Java package, but the special opcodes can optimize it.-- Some (but not all) possessively repeated subpatterns have already been- completely handled in the code just above. For them, possessive_quantifier- is always FALSE at this stage. Note that the repeated item starts at- tempcode, not at previous, which might be the first part of a string whose- (former) last char we repeated. */-- if (possessive_quantifier)- {- int len;-- /* Possessifying an EXACT quantifier has no effect, so we can ignore it.- However, QUERY, STAR, or UPTO may follow (for quantifiers such as {5,6},- {5,}, or {5,10}). We skip over an EXACT item; if the length of what- remains is greater than zero, there's a further opcode that can be- handled. If not, do nothing, leaving the EXACT alone. */-- switch(*tempcode)- {- case OP_TYPEEXACT:- tempcode += PRIV(OP_lengths)[*tempcode] +- ((tempcode[1 + IMM2_SIZE] == OP_PROP- || tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);- break;-- /* CHAR opcodes are used for exacts whose count is 1. */-- case OP_CHAR:- case OP_CHARI:- case OP_NOT:- case OP_NOTI:- case OP_EXACT:- case OP_EXACTI:- case OP_NOTEXACT:- case OP_NOTEXACTI:- tempcode += PRIV(OP_lengths)[*tempcode];-#ifdef SUPPORT_UTF- if (utf && HAS_EXTRALEN(tempcode[-1]))- tempcode += GET_EXTRALEN(tempcode[-1]);-#endif- break;-- /* For the class opcodes, the repeat operator appears at the end;- adjust tempcode to point to it. */-- case OP_CLASS:- case OP_NCLASS:- tempcode += 1 + 32/sizeof(pcre_uchar);- break;--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- tempcode += GET(tempcode, 1);- break;-#endif- }-- /* If tempcode is equal to code (which points to the end of the repeated- item), it means we have skipped an EXACT item but there is no following- QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In- all other cases, tempcode will be pointing to the repeat opcode, and will- be less than code, so the value of len will be greater than 0. */-- len = (int)(code - tempcode);- if (len > 0)- {- unsigned int repcode = *tempcode;-- /* There is a table for possessifying opcodes, all of which are less- than OP_CALLOUT. A zero entry means there is no possessified version.- */-- if (repcode < OP_CALLOUT && opcode_possessify[repcode] > 0)- *tempcode = opcode_possessify[repcode];-- /* For opcode without a special possessified version, wrap the item in- ONCE brackets. Because we are moving code along, we must ensure that any- pending recursive references are updated. */-- else- {- *code = OP_END;- adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, save_hwm);- memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));- code += 1 + LINK_SIZE;- len += 1 + LINK_SIZE;- tempcode[0] = OP_ONCE;- *code++ = OP_KET;- PUTINC(code, 0, len);- PUT(tempcode, 1, len);- }- }--#ifdef NEVER- if (len > 0) switch (*tempcode)- {- case OP_STAR: *tempcode = OP_POSSTAR; break;- case OP_PLUS: *tempcode = OP_POSPLUS; break;- case OP_QUERY: *tempcode = OP_POSQUERY; break;- case OP_UPTO: *tempcode = OP_POSUPTO; break;-- case OP_STARI: *tempcode = OP_POSSTARI; break;- case OP_PLUSI: *tempcode = OP_POSPLUSI; break;- case OP_QUERYI: *tempcode = OP_POSQUERYI; break;- case OP_UPTOI: *tempcode = OP_POSUPTOI; break;-- case OP_NOTSTAR: *tempcode = OP_NOTPOSSTAR; break;- case OP_NOTPLUS: *tempcode = OP_NOTPOSPLUS; break;- case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;- case OP_NOTUPTO: *tempcode = OP_NOTPOSUPTO; break;-- case OP_NOTSTARI: *tempcode = OP_NOTPOSSTARI; break;- case OP_NOTPLUSI: *tempcode = OP_NOTPOSPLUSI; break;- case OP_NOTQUERYI: *tempcode = OP_NOTPOSQUERYI; break;- case OP_NOTUPTOI: *tempcode = OP_NOTPOSUPTOI; break;-- case OP_TYPESTAR: *tempcode = OP_TYPEPOSSTAR; break;- case OP_TYPEPLUS: *tempcode = OP_TYPEPOSPLUS; break;- case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;- case OP_TYPEUPTO: *tempcode = OP_TYPEPOSUPTO; break;-- case OP_CRSTAR: *tempcode = OP_CRPOSSTAR; break;- case OP_CRPLUS: *tempcode = OP_CRPOSPLUS; break;- case OP_CRQUERY: *tempcode = OP_CRPOSQUERY; break;- case OP_CRRANGE: *tempcode = OP_CRPOSRANGE; break;-- /* Because we are moving code along, we must ensure that any- pending recursive references are updated. */-- default:- *code = OP_END;- adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, save_hwm);- memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));- code += 1 + LINK_SIZE;- len += 1 + LINK_SIZE;- tempcode[0] = OP_ONCE;- *code++ = OP_KET;- PUTINC(code, 0, len);- PUT(tempcode, 1, len);- break;- }-#endif- }-- /* In all case we no longer have a previous item. We also set the- "follows varying string" flag for subsequently encountered reqchars if- it isn't already set and we have just passed a varying length item. */-- END_REPEAT:- previous = NULL;- cd->req_varyopt |= reqvary;- break;--- /* ===================================================================*/- /* Start of nested parenthesized sub-expression, or comment or lookahead or- lookbehind or option setting or condition or all the other extended- parenthesis forms. */-- case CHAR_LEFT_PARENTHESIS:- newoptions = options;- skipbytes = 0;- bravalue = OP_CBRA;- save_hwm = cd->hwm;- reset_bracount = FALSE;-- /* First deal with various "verbs" that can be introduced by '*'. */-- ptr++;- if (ptr[0] == CHAR_ASTERISK && (ptr[1] == ':'- || (MAX_255(ptr[1]) && ((cd->ctypes[ptr[1]] & ctype_letter) != 0))))- {- int i, namelen;- int arglen = 0;- const char *vn = verbnames;- const pcre_uchar *name = ptr + 1;- const pcre_uchar *arg = NULL;- previous = NULL;- ptr++;- while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;- namelen = (int)(ptr - name);-- /* It appears that Perl allows any characters whatsoever, other than- a closing parenthesis, to appear in arguments, so we no longer insist on- letters, digits, and underscores. */-- if (*ptr == CHAR_COLON)- {- arg = ++ptr;- while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;- arglen = (int)(ptr - arg);- if ((unsigned int)arglen > MAX_MARK)- {- *errorcodeptr = ERR75;- goto FAILED;- }- }-- if (*ptr != CHAR_RIGHT_PARENTHESIS)- {- *errorcodeptr = ERR60;- goto FAILED;- }-- /* Scan the table of verb names */-- for (i = 0; i < verbcount; i++)- {- if (namelen == verbs[i].len &&- STRNCMP_UC_C8(name, vn, namelen) == 0)- {- int setverb;-- /* Check for open captures before ACCEPT and convert it to- ASSERT_ACCEPT if in an assertion. */-- if (verbs[i].op == OP_ACCEPT)- {- open_capitem *oc;- if (arglen != 0)- {- *errorcodeptr = ERR59;- goto FAILED;- }- cd->had_accept = TRUE;- for (oc = cd->open_caps; oc != NULL; oc = oc->next)- {- *code++ = OP_CLOSE;- PUT2INC(code, 0, oc->number);- }- setverb = *code++ =- (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;-- /* Do not set firstchar after *ACCEPT */- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- }-- /* Handle other cases with/without an argument */-- else if (arglen == 0)- {- if (verbs[i].op < 0) /* Argument is mandatory */- {- *errorcodeptr = ERR66;- goto FAILED;- }- setverb = *code++ = verbs[i].op;- }-- else- {- if (verbs[i].op_arg < 0) /* Argument is forbidden */- {- *errorcodeptr = ERR59;- goto FAILED;- }- setverb = *code++ = verbs[i].op_arg;- *code++ = arglen;- memcpy(code, arg, IN_UCHARS(arglen));- code += arglen;- *code++ = 0;- }-- switch (setverb)- {- case OP_THEN:- case OP_THEN_ARG:- cd->external_flags |= PCRE_HASTHEN;- break;-- case OP_PRUNE:- case OP_PRUNE_ARG:- case OP_SKIP:- case OP_SKIP_ARG:- cd->had_pruneorskip = TRUE;- break;- }-- break; /* Found verb, exit loop */- }-- vn += verbs[i].len + 1;- }-- if (i < verbcount) continue; /* Successfully handled a verb */- *errorcodeptr = ERR60; /* Verb not recognized */- goto FAILED;- }-- /* Deal with the extended parentheses; all are introduced by '?', and the- appearance of any of them means that this is not a capturing group. */-- else if (*ptr == CHAR_QUESTION_MARK)- {- int i, set, unset, namelen;- int *optset;- const pcre_uchar *name;- pcre_uchar *slot;-- switch (*(++ptr))- {- case CHAR_NUMBER_SIGN: /* Comment; skip to ket */- ptr++;- while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;- if (*ptr == CHAR_NULL)- {- *errorcodeptr = ERR18;- goto FAILED;- }- continue;--- /* ------------------------------------------------------------ */- case CHAR_VERTICAL_LINE: /* Reset capture count for each branch */- reset_bracount = TRUE;- /* Fall through */-- /* ------------------------------------------------------------ */- case CHAR_COLON: /* Non-capturing bracket */- bravalue = OP_BRA;- ptr++;- break;--- /* ------------------------------------------------------------ */- case CHAR_LEFT_PARENTHESIS:- bravalue = OP_COND; /* Conditional group */- tempptr = ptr;-- /* A condition can be an assertion, a number (referring to a numbered- group's having been set), a name (referring to a named group), or 'R',- referring to recursion. R<digits> and R&name are also permitted for- recursion tests.-- There are ways of testing a named group: (?(name)) is used by Python;- Perl 5.10 onwards uses (?(<name>) or (?('name')).-- There is one unfortunate ambiguity, caused by history. 'R' can be the- recursive thing or the name 'R' (and similarly for 'R' followed by- digits). We look for a name first; if not found, we try the other case.-- For compatibility with auto-callouts, we allow a callout to be- specified before a condition that is an assertion. First, check for the- syntax of a callout; if found, adjust the temporary pointer that is- used to check for an assertion condition. That's all that is needed! */-- if (ptr[1] == CHAR_QUESTION_MARK && ptr[2] == CHAR_C)- {- for (i = 3;; i++) if (!IS_DIGIT(ptr[i])) break;- if (ptr[i] == CHAR_RIGHT_PARENTHESIS)- tempptr += i + 1;- }-- /* For conditions that are assertions, check the syntax, and then exit- the switch. This will take control down to where bracketed groups,- including assertions, are processed. */-- if (tempptr[1] == CHAR_QUESTION_MARK &&- (tempptr[2] == CHAR_EQUALS_SIGN ||- tempptr[2] == CHAR_EXCLAMATION_MARK ||- tempptr[2] == CHAR_LESS_THAN_SIGN))- break;-- /* Other conditions use OP_CREF/OP_DNCREF/OP_RREF/OP_DNRREF, and all- need to skip at least 1+IMM2_SIZE bytes at the start of the group. */-- code[1+LINK_SIZE] = OP_CREF;- skipbytes = 1+IMM2_SIZE;- refsign = -1;-- /* Check for a test for recursion in a named group. */-- ptr++;- if (*ptr == CHAR_R && ptr[1] == CHAR_AMPERSAND)- {- terminator = -1;- ptr += 2;- code[1+LINK_SIZE] = OP_RREF; /* Change the type of test */- }-- /* Check for a test for a named group's having been set, using the Perl- syntax (?(<name>) or (?('name'), and also allow for the original PCRE- syntax of (?(name) or for (?(+n), (?(-n), and just (?(n). */-- else if (*ptr == CHAR_LESS_THAN_SIGN)- {- terminator = CHAR_GREATER_THAN_SIGN;- ptr++;- }- else if (*ptr == CHAR_APOSTROPHE)- {- terminator = CHAR_APOSTROPHE;- ptr++;- }- else- {- terminator = CHAR_NULL;- if (*ptr == CHAR_MINUS || *ptr == CHAR_PLUS) refsign = *ptr++;- else if (IS_DIGIT(*ptr)) refsign = 0;- }-- /* Handle a number */-- if (refsign >= 0)- {- recno = 0;- while (IS_DIGIT(*ptr))- {- recno = recno * 10 + (int)(*ptr - CHAR_0);- ptr++;- }- }-- /* Otherwise we expect to read a name; anything else is an error. When- a name is one of a number of duplicates, a different opcode is used and- it needs more memory. Unfortunately we cannot tell whether a name is a- duplicate in the first pass, so we have to allow for more memory. */-- else- {- if (IS_DIGIT(*ptr))- {- *errorcodeptr = ERR84;- goto FAILED;- }- if (!MAX_255(*ptr) || (cd->ctypes[*ptr] & ctype_word) == 0)- {- *errorcodeptr = ERR28; /* Assertion expected */- goto FAILED;- }- name = ptr++;- while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0)- {- ptr++;- }- namelen = (int)(ptr - name);- if (lengthptr != NULL) *lengthptr += IMM2_SIZE;- }-- /* Check the terminator */-- if ((terminator > 0 && *ptr++ != (pcre_uchar)terminator) ||- *ptr++ != CHAR_RIGHT_PARENTHESIS)- {- ptr--; /* Error offset */- *errorcodeptr = ERR26; /* Malformed number or name */- goto FAILED;- }-- /* Do no further checking in the pre-compile phase. */-- if (lengthptr != NULL) break;-- /* In the real compile we do the work of looking for the actual- reference. If refsign is not negative, it means we have a number in- recno. */-- if (refsign >= 0)- {- if (recno <= 0)- {- *errorcodeptr = ERR35;- goto FAILED;- }- if (refsign != 0) recno = (refsign == CHAR_MINUS)?- cd->bracount - recno + 1 : recno + cd->bracount;- if (recno <= 0 || recno > cd->final_bracount)- {- *errorcodeptr = ERR15;- goto FAILED;- }- PUT2(code, 2+LINK_SIZE, recno);- break;- }-- /* Otherwise look for the name. */-- slot = cd->name_table;- for (i = 0; i < cd->names_found; i++)- {- if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0) break;- slot += cd->name_entry_size;- }-- /* Found the named subpattern. If the name is duplicated, add one to- the opcode to change CREF/RREF into DNCREF/DNRREF and insert- appropriate data values. Otherwise, just insert the unique subpattern- number. */-- if (i < cd->names_found)- {- int offset = i++;- int count = 1;- recno = GET2(slot, 0); /* Number from first found */- for (; i < cd->names_found; i++)- {- slot += cd->name_entry_size;- if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) != 0) break;- count++;- }- if (count > 1)- {- PUT2(code, 2+LINK_SIZE, offset);- PUT2(code, 2+LINK_SIZE+IMM2_SIZE, count);- skipbytes += IMM2_SIZE;- code[1+LINK_SIZE]++;- }- else /* Not a duplicated name */- {- PUT2(code, 2+LINK_SIZE, recno);- }- }-- /* If terminator == CHAR_NULL it means that the name followed directly- after the opening parenthesis [e.g. (?(abc)...] and in this case there- are some further alternatives to try. For the cases where terminator !=- CHAR_NULL [things like (?(<name>... or (?('name')... or (?(R&name)... ]- we have now checked all the possibilities, so give an error. */-- else if (terminator != CHAR_NULL)- {- *errorcodeptr = ERR15;- goto FAILED;- }-- /* Check for (?(R) for recursion. Allow digits after R to specify a- specific group number. */-- else if (*name == CHAR_R)- {- recno = 0;- for (i = 1; i < namelen; i++)- {- if (!IS_DIGIT(name[i]))- {- *errorcodeptr = ERR15;- goto FAILED;- }- recno = recno * 10 + name[i] - CHAR_0;- }- if (recno == 0) recno = RREF_ANY;- code[1+LINK_SIZE] = OP_RREF; /* Change test type */- PUT2(code, 2+LINK_SIZE, recno);- }-- /* Similarly, check for the (?(DEFINE) "condition", which is always- false. */-- else if (namelen == 6 && STRNCMP_UC_C8(name, STRING_DEFINE, 6) == 0)- {- code[1+LINK_SIZE] = OP_DEF;- skipbytes = 1;- }-- /* Reference to an unidentified subpattern. */-- else- {- *errorcodeptr = ERR15;- goto FAILED;- }- break;--- /* ------------------------------------------------------------ */- case CHAR_EQUALS_SIGN: /* Positive lookahead */- bravalue = OP_ASSERT;- cd->assert_depth += 1;- ptr++;- break;-- /* Optimize (?!) to (*FAIL) unless it is quantified - which is a weird- thing to do, but Perl allows all assertions to be quantified, and when- they contain capturing parentheses there may be a potential use for- this feature. Not that that applies to a quantified (?!) but we allow- it for uniformity. */-- /* ------------------------------------------------------------ */- case CHAR_EXCLAMATION_MARK: /* Negative lookahead */- ptr++;- if (*ptr == CHAR_RIGHT_PARENTHESIS && ptr[1] != CHAR_ASTERISK &&- ptr[1] != CHAR_PLUS && ptr[1] != CHAR_QUESTION_MARK &&- (ptr[1] != CHAR_LEFT_CURLY_BRACKET || !is_counted_repeat(ptr+2)))- {- *code++ = OP_FAIL;- previous = NULL;- continue;- }- bravalue = OP_ASSERT_NOT;- cd->assert_depth += 1;- break;--- /* ------------------------------------------------------------ */- case CHAR_LESS_THAN_SIGN: /* Lookbehind or named define */- switch (ptr[1])- {- case CHAR_EQUALS_SIGN: /* Positive lookbehind */- bravalue = OP_ASSERTBACK;- cd->assert_depth += 1;- ptr += 2;- break;-- case CHAR_EXCLAMATION_MARK: /* Negative lookbehind */- bravalue = OP_ASSERTBACK_NOT;- cd->assert_depth += 1;- ptr += 2;- break;-- default: /* Could be name define, else bad */- if (MAX_255(ptr[1]) && (cd->ctypes[ptr[1]] & ctype_word) != 0)- goto DEFINE_NAME;- ptr++; /* Correct offset for error */- *errorcodeptr = ERR24;- goto FAILED;- }- break;--- /* ------------------------------------------------------------ */- case CHAR_GREATER_THAN_SIGN: /* One-time brackets */- bravalue = OP_ONCE;- ptr++;- break;--- /* ------------------------------------------------------------ */- case CHAR_C: /* Callout - may be followed by digits; */- previous_callout = code; /* Save for later completion */- after_manual_callout = 1; /* Skip one item before completing */- *code++ = OP_CALLOUT;- {- int n = 0;- ptr++;- while(IS_DIGIT(*ptr))- n = n * 10 + *ptr++ - CHAR_0;- if (*ptr != CHAR_RIGHT_PARENTHESIS)- {- *errorcodeptr = ERR39;- goto FAILED;- }- if (n > 255)- {- *errorcodeptr = ERR38;- goto FAILED;- }- *code++ = n;- PUT(code, 0, (int)(ptr - cd->start_pattern + 1)); /* Pattern offset */- PUT(code, LINK_SIZE, 0); /* Default length */- code += 2 * LINK_SIZE;- }- previous = NULL;- continue;--- /* ------------------------------------------------------------ */- case CHAR_P: /* Python-style named subpattern handling */- if (*(++ptr) == CHAR_EQUALS_SIGN ||- *ptr == CHAR_GREATER_THAN_SIGN) /* Reference or recursion */- {- is_recurse = *ptr == CHAR_GREATER_THAN_SIGN;- terminator = CHAR_RIGHT_PARENTHESIS;- goto NAMED_REF_OR_RECURSE;- }- else if (*ptr != CHAR_LESS_THAN_SIGN) /* Test for Python-style defn */- {- *errorcodeptr = ERR41;- goto FAILED;- }- /* Fall through to handle (?P< as (?< is handled */--- /* ------------------------------------------------------------ */- DEFINE_NAME: /* Come here from (?< handling */- case CHAR_APOSTROPHE:- terminator = (*ptr == CHAR_LESS_THAN_SIGN)?- CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;- name = ++ptr;- if (IS_DIGIT(*ptr))- {- *errorcodeptr = ERR84; /* Group name must start with non-digit */- goto FAILED;- }- while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;- namelen = (int)(ptr - name);-- /* In the pre-compile phase, do a syntax check, remember the longest- name, and then remember the group in a vector, expanding it if- necessary. Duplicates for the same number are skipped; other duplicates- are checked for validity. In the actual compile, there is nothing to- do. */-- if (lengthptr != NULL)- {- named_group *ng;- pcre_uint32 number = cd->bracount + 1;-- if (*ptr != (pcre_uchar)terminator)- {- *errorcodeptr = ERR42;- goto FAILED;- }-- if (cd->names_found >= MAX_NAME_COUNT)- {- *errorcodeptr = ERR49;- goto FAILED;- }-- if (namelen + IMM2_SIZE + 1 > cd->name_entry_size)- {- cd->name_entry_size = namelen + IMM2_SIZE + 1;- if (namelen > MAX_NAME_SIZE)- {- *errorcodeptr = ERR48;- goto FAILED;- }- }-- /* Scan the list to check for duplicates. For duplicate names, if the- number is the same, break the loop, which causes the name to be- discarded; otherwise, if DUPNAMES is not set, give an error.- If it is set, allow the name with a different number, but continue- scanning in case this is a duplicate with the same number. For- non-duplicate names, give an error if the number is duplicated. */-- ng = cd->named_groups;- for (i = 0; i < cd->names_found; i++, ng++)- {- if (namelen == ng->length &&- STRNCMP_UC_UC(name, ng->name, namelen) == 0)- {- if (ng->number == number) break;- if ((options & PCRE_DUPNAMES) == 0)- {- *errorcodeptr = ERR43;- goto FAILED;- }- cd->dupnames = TRUE; /* Duplicate names exist */- }- else if (ng->number == number)- {- *errorcodeptr = ERR65;- goto FAILED;- }- }-- if (i >= cd->names_found) /* Not a duplicate with same number */- {- /* Increase the list size if necessary */-- if (cd->names_found >= cd->named_group_list_size)- {- int newsize = cd->named_group_list_size * 2;- named_group *newspace = (PUBL(malloc))- (newsize * sizeof(named_group));-- if (newspace == NULL)- {- *errorcodeptr = ERR21;- goto FAILED;- }-- memcpy(newspace, cd->named_groups,- cd->named_group_list_size * sizeof(named_group));- if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE)- (PUBL(free))((void *)cd->named_groups);- cd->named_groups = newspace;- cd->named_group_list_size = newsize;- }-- cd->named_groups[cd->names_found].name = name;- cd->named_groups[cd->names_found].length = namelen;- cd->named_groups[cd->names_found].number = number;- cd->names_found++;- }- }-- ptr++; /* Move past > or ' in both passes. */- goto NUMBERED_GROUP;--- /* ------------------------------------------------------------ */- case CHAR_AMPERSAND: /* Perl recursion/subroutine syntax */- terminator = CHAR_RIGHT_PARENTHESIS;- is_recurse = TRUE;- /* Fall through */-- /* We come here from the Python syntax above that handles both- references (?P=name) and recursion (?P>name), as well as falling- through from the Perl recursion syntax (?&name). We also come here from- the Perl \k<name> or \k'name' back reference syntax and the \k{name}- .NET syntax, and the Oniguruma \g<...> and \g'...' subroutine syntax. */-- NAMED_REF_OR_RECURSE:- name = ++ptr;- if (IS_DIGIT(*ptr))- {- *errorcodeptr = ERR84; /* Group name must start with non-digit */- goto FAILED;- }- while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;- namelen = (int)(ptr - name);-- /* In the pre-compile phase, do a syntax check. We used to just set- a dummy reference number, because it was not used in the first pass.- However, with the change of recursive back references to be atomic,- we have to look for the number so that this state can be identified, as- otherwise the incorrect length is computed. If it's not a backwards- reference, the dummy number will do. */-- if (lengthptr != NULL)- {- named_group *ng;-- if (namelen == 0)- {- *errorcodeptr = ERR62;- goto FAILED;- }- if (*ptr != (pcre_uchar)terminator)- {- *errorcodeptr = ERR42;- goto FAILED;- }- if (namelen > MAX_NAME_SIZE)- {- *errorcodeptr = ERR48;- goto FAILED;- }-- /* The name table does not exist in the first pass; instead we must- scan the list of names encountered so far in order to get the- number. If the name is not found, set the value to 0 for a forward- reference. */-- ng = cd->named_groups;- for (i = 0; i < cd->names_found; i++, ng++)- {- if (namelen == ng->length &&- STRNCMP_UC_UC(name, ng->name, namelen) == 0)- break;- }- recno = (i < cd->names_found)? ng->number : 0;-- /* Count named back references. */-- if (!is_recurse) cd->namedrefcount++;- }-- /* In the real compile, search the name table. We check the name- first, and then check that we have reached the end of the name in the- table. That way, if the name is longer than any in the table, the- comparison will fail without reading beyond the table entry. */-- else- {- slot = cd->name_table;- for (i = 0; i < cd->names_found; i++)- {- if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&- slot[IMM2_SIZE+namelen] == 0)- break;- slot += cd->name_entry_size;- }-- if (i < cd->names_found)- {- recno = GET2(slot, 0);- }- else- {- *errorcodeptr = ERR15;- goto FAILED;- }- }-- /* In both phases, for recursions, we can now go to the code than- handles numerical recursion. */-- if (is_recurse) goto HANDLE_RECURSION;-- /* In the second pass we must see if the name is duplicated. If so, we- generate a different opcode. */-- if (lengthptr == NULL && cd->dupnames)- {- int count = 1;- unsigned int index = i;- pcre_uchar *cslot = slot + cd->name_entry_size;-- for (i++; i < cd->names_found; i++)- {- if (STRCMP_UC_UC(slot + IMM2_SIZE, cslot + IMM2_SIZE) != 0) break;- count++;- cslot += cd->name_entry_size;- }-- if (count > 1)- {- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- previous = code;- *code++ = ((options & PCRE_CASELESS) != 0)? OP_DNREFI : OP_DNREF;- PUT2INC(code, 0, index);- PUT2INC(code, 0, count);-- /* Process each potentially referenced group. */-- for (; slot < cslot; slot += cd->name_entry_size)- {- open_capitem *oc;- recno = GET2(slot, 0);- cd->backref_map |= (recno < 32)? (1 << recno) : 1;- if (recno > cd->top_backref) cd->top_backref = recno;-- /* Check to see if this back reference is recursive, that it, it- is inside the group that it references. A flag is set so that the- group can be made atomic. */-- for (oc = cd->open_caps; oc != NULL; oc = oc->next)- {- if (oc->number == recno)- {- oc->flag = TRUE;- break;- }- }- }-- continue; /* End of back ref handling */- }- }-- /* First pass, or a non-duplicated name. */-- goto HANDLE_REFERENCE;--- /* ------------------------------------------------------------ */- case CHAR_R: /* Recursion */- ptr++; /* Same as (?0) */- /* Fall through */--- /* ------------------------------------------------------------ */- case CHAR_MINUS: case CHAR_PLUS: /* Recursion or subroutine */- case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:- case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:- {- const pcre_uchar *called;- terminator = CHAR_RIGHT_PARENTHESIS;-- /* Come here from the \g<...> and \g'...' code (Oniguruma- compatibility). However, the syntax has been checked to ensure that- the ... are a (signed) number, so that neither ERR63 nor ERR29 will- be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY- ever be taken. */-- HANDLE_NUMERICAL_RECURSION:-- if ((refsign = *ptr) == CHAR_PLUS)- {- ptr++;- if (!IS_DIGIT(*ptr))- {- *errorcodeptr = ERR63;- goto FAILED;- }- }- else if (refsign == CHAR_MINUS)- {- if (!IS_DIGIT(ptr[1]))- goto OTHER_CHAR_AFTER_QUERY;- ptr++;- }-- recno = 0;- while(IS_DIGIT(*ptr))- recno = recno * 10 + *ptr++ - CHAR_0;-- if (*ptr != (pcre_uchar)terminator)- {- *errorcodeptr = ERR29;- goto FAILED;- }-- if (refsign == CHAR_MINUS)- {- if (recno == 0)- {- *errorcodeptr = ERR58;- goto FAILED;- }- recno = cd->bracount - recno + 1;- if (recno <= 0)- {- *errorcodeptr = ERR15;- goto FAILED;- }- }- else if (refsign == CHAR_PLUS)- {- if (recno == 0)- {- *errorcodeptr = ERR58;- goto FAILED;- }- recno += cd->bracount;- }-- /* Come here from code above that handles a named recursion */-- HANDLE_RECURSION:-- previous = code;- called = cd->start_code;-- /* When we are actually compiling, find the bracket that is being- referenced. Temporarily end the regex in case it doesn't exist before- this point. If we end up with a forward reference, first check that- the bracket does occur later so we can give the error (and position)- now. Then remember this forward reference in the workspace so it can- be filled in at the end. */-- if (lengthptr == NULL)- {- *code = OP_END;- if (recno != 0)- called = PRIV(find_bracket)(cd->start_code, utf, recno);-- /* Forward reference */-- if (called == NULL)- {- if (recno > cd->final_bracount)- {- *errorcodeptr = ERR15;- goto FAILED;- }-- /* Fudge the value of "called" so that when it is inserted as an- offset below, what it actually inserted is the reference number- of the group. Then remember the forward reference. */-- called = cd->start_code + recno;- if (cd->hwm >= cd->start_workspace + cd->workspace_size -- WORK_SIZE_SAFETY_MARGIN)- {- *errorcodeptr = expand_workspace(cd);- if (*errorcodeptr != 0) goto FAILED;- }- PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));- }-- /* If not a forward reference, and the subpattern is still open,- this is a recursive call. We check to see if this is a left- recursion that could loop for ever, and diagnose that case. We- must not, however, do this check if we are in a conditional- subpattern because the condition might be testing for recursion in- a pattern such as /(?(R)a+|(?R)b)/, which is perfectly valid.- Forever loops are also detected at runtime, so those that occur in- conditional subpatterns will be picked up then. */-- else if (GET(called, 1) == 0 && cond_depth <= 0 &&- could_be_empty(called, code, bcptr, utf, cd))- {- *errorcodeptr = ERR40;- goto FAILED;- }- }-- /* Insert the recursion/subroutine item. It does not have a set first- character (relevant if it is repeated, because it will then be- wrapped with ONCE brackets). */-- *code = OP_RECURSE;- PUT(code, 1, (int)(called - cd->start_code));- code += 1 + LINK_SIZE;- groupsetfirstchar = FALSE;- }-- /* Can't determine a first byte now */-- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- continue;--- /* ------------------------------------------------------------ */- default: /* Other characters: check option setting */- OTHER_CHAR_AFTER_QUERY:- set = unset = 0;- optset = &set;-- while (*ptr != CHAR_RIGHT_PARENTHESIS && *ptr != CHAR_COLON)- {- switch (*ptr++)- {- case CHAR_MINUS: optset = &unset; break;-- case CHAR_J: /* Record that it changed in the external options */- *optset |= PCRE_DUPNAMES;- cd->external_flags |= PCRE_JCHANGED;- break;-- case CHAR_i: *optset |= PCRE_CASELESS; break;- case CHAR_m: *optset |= PCRE_MULTILINE; break;- case CHAR_s: *optset |= PCRE_DOTALL; break;- case CHAR_x: *optset |= PCRE_EXTENDED; break;- case CHAR_U: *optset |= PCRE_UNGREEDY; break;- case CHAR_X: *optset |= PCRE_EXTRA; break;-- default: *errorcodeptr = ERR12;- ptr--; /* Correct the offset */- goto FAILED;- }- }-- /* Set up the changed option bits, but don't change anything yet. */-- newoptions = (options | set) & (~unset);-- /* If the options ended with ')' this is not the start of a nested- group with option changes, so the options change at this level. If this- item is right at the start of the pattern, the options can be- abstracted and made external in the pre-compile phase, and ignored in- the compile phase. This can be helpful when matching -- for instance in- caseless checking of required bytes.-- If the code pointer is not (cd->start_code + 1 + LINK_SIZE), we are- definitely *not* at the start of the pattern because something has been- compiled. In the pre-compile phase, however, the code pointer can have- that value after the start, because it gets reset as code is discarded- during the pre-compile. However, this can happen only at top level - if- we are within parentheses, the starting BRA will still be present. At- any parenthesis level, the length value can be used to test if anything- has been compiled at that level. Thus, a test for both these conditions- is necessary to ensure we correctly detect the start of the pattern in- both phases.-- If we are not at the pattern start, reset the greedy defaults and the- case value for firstchar and reqchar. */-- if (*ptr == CHAR_RIGHT_PARENTHESIS)- {- if (code == cd->start_code + 1 + LINK_SIZE &&- (lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))- {- cd->external_options = newoptions;- }- else- {- greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);- greedy_non_default = greedy_default ^ 1;- req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS:0;- }-- /* Change options at this level, and pass them back for use- in subsequent branches. */-- *optionsptr = options = newoptions;- previous = NULL; /* This item can't be repeated */- continue; /* It is complete */- }-- /* If the options ended with ':' we are heading into a nested group- with possible change of options. Such groups are non-capturing and are- not assertions of any kind. All we need to do is skip over the ':';- the newoptions value is handled below. */-- bravalue = OP_BRA;- ptr++;- } /* End of switch for character following (? */- } /* End of (? handling */-- /* Opening parenthesis not followed by '*' or '?'. If PCRE_NO_AUTO_CAPTURE- is set, all unadorned brackets become non-capturing and behave like (?:...)- brackets. */-- else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)- {- bravalue = OP_BRA;- }-- /* Else we have a capturing group. */-- else- {- NUMBERED_GROUP:- cd->bracount += 1;- PUT2(code, 1+LINK_SIZE, cd->bracount);- skipbytes = IMM2_SIZE;- }-- /* Process nested bracketed regex. First check for parentheses nested too- deeply. */-- if ((cd->parens_depth += 1) > PARENS_NEST_LIMIT)- {- *errorcodeptr = ERR82;- goto FAILED;- }-- /* Assertions used not to be repeatable, but this was changed for Perl- compatibility, so all kinds can now be repeated. We copy code into a- non-register variable (tempcode) in order to be able to pass its address- because some compilers complain otherwise. */-- previous = code; /* For handling repetition */- *code = bravalue;- tempcode = code;- tempreqvary = cd->req_varyopt; /* Save value before bracket */- tempbracount = cd->bracount; /* Save value before bracket */- length_prevgroup = 0; /* Initialize for pre-compile phase */-- if (!compile_regex(- newoptions, /* The complete new option state */- &tempcode, /* Where to put code (updated) */- &ptr, /* Input pointer (updated) */- errorcodeptr, /* Where to put an error message */- (bravalue == OP_ASSERTBACK ||- bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */- reset_bracount, /* True if (?| group */- skipbytes, /* Skip over bracket number */- cond_depth +- ((bravalue == OP_COND)?1:0), /* Depth of condition subpatterns */- &subfirstchar, /* For possible first char */- &subfirstcharflags,- &subreqchar, /* For possible last char */- &subreqcharflags,- bcptr, /* Current branch chain */- cd, /* Tables block */- (lengthptr == NULL)? NULL : /* Actual compile phase */- &length_prevgroup /* Pre-compile phase */- ))- goto FAILED;-- cd->parens_depth -= 1;-- /* If this was an atomic group and there are no capturing groups within it,- generate OP_ONCE_NC instead of OP_ONCE. */-- if (bravalue == OP_ONCE && cd->bracount <= tempbracount)- *code = OP_ONCE_NC;-- if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)- cd->assert_depth -= 1;-- /* At the end of compiling, code is still pointing to the start of the- group, while tempcode has been updated to point past the end of the group.- The pattern pointer (ptr) is on the bracket.-- If this is a conditional bracket, check that there are no more than- two branches in the group, or just one if it's a DEFINE group. We do this- in the real compile phase, not in the pre-pass, where the whole group may- not be available. */-- if (bravalue == OP_COND && lengthptr == NULL)- {- pcre_uchar *tc = code;- int condcount = 0;-- do {- condcount++;- tc += GET(tc,1);- }- while (*tc != OP_KET);-- /* A DEFINE group is never obeyed inline (the "condition" is always- false). It must have only one branch. */-- if (code[LINK_SIZE+1] == OP_DEF)- {- if (condcount > 1)- {- *errorcodeptr = ERR54;- goto FAILED;- }- bravalue = OP_DEF; /* Just a flag to suppress char handling below */- }-- /* A "normal" conditional group. If there is just one branch, we must not- make use of its firstchar or reqchar, because this is equivalent to an- empty second branch. */-- else- {- if (condcount > 2)- {- *errorcodeptr = ERR27;- goto FAILED;- }- if (condcount == 1) subfirstcharflags = subreqcharflags = REQ_NONE;- }- }-- /* Error if hit end of pattern */-- if (*ptr != CHAR_RIGHT_PARENTHESIS)- {- *errorcodeptr = ERR14;- goto FAILED;- }-- /* In the pre-compile phase, update the length by the length of the group,- less the brackets at either end. Then reduce the compiled code to just a- set of non-capturing brackets so that it doesn't use much memory if it is- duplicated by a quantifier.*/-- if (lengthptr != NULL)- {- if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)- {- *errorcodeptr = ERR20;- goto FAILED;- }- *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;- code++; /* This already contains bravalue */- PUTINC(code, 0, 1 + LINK_SIZE);- *code++ = OP_KET;- PUTINC(code, 0, 1 + LINK_SIZE);- break; /* No need to waste time with special character handling */- }-- /* Otherwise update the main code pointer to the end of the group. */-- code = tempcode;-- /* For a DEFINE group, required and first character settings are not- relevant. */-- if (bravalue == OP_DEF) break;-- /* Handle updating of the required and first characters for other types of- group. Update for normal brackets of all kinds, and conditions with two- branches (see code above). If the bracket is followed by a quantifier with- zero repeat, we have to back off. Hence the definition of zeroreqchar and- zerofirstchar outside the main loop so that they can be accessed for the- back off. */-- zeroreqchar = reqchar;- zeroreqcharflags = reqcharflags;- zerofirstchar = firstchar;- zerofirstcharflags = firstcharflags;- groupsetfirstchar = FALSE;-- if (bravalue >= OP_ONCE)- {- /* If we have not yet set a firstchar in this branch, take it from the- subpattern, remembering that it was set here so that a repeat of more- than one can replicate it as reqchar if necessary. If the subpattern has- no firstchar, set "none" for the whole branch. In both cases, a zero- repeat forces firstchar to "none". */-- if (firstcharflags == REQ_UNSET)- {- if (subfirstcharflags >= 0)- {- firstchar = subfirstchar;- firstcharflags = subfirstcharflags;- groupsetfirstchar = TRUE;- }- else firstcharflags = REQ_NONE;- zerofirstcharflags = REQ_NONE;- }-- /* If firstchar was previously set, convert the subpattern's firstchar- into reqchar if there wasn't one, using the vary flag that was in- existence beforehand. */-- else if (subfirstcharflags >= 0 && subreqcharflags < 0)- {- subreqchar = subfirstchar;- subreqcharflags = subfirstcharflags | tempreqvary;- }-- /* If the subpattern set a required byte (or set a first byte that isn't- really the first byte - see above), set it. */-- if (subreqcharflags >= 0)- {- reqchar = subreqchar;- reqcharflags = subreqcharflags;- }- }-- /* For a forward assertion, we take the reqchar, if set. This can be- helpful if the pattern that follows the assertion doesn't set a different- char. For example, it's useful for /(?=abcde).+/. We can't set firstchar- for an assertion, however because it leads to incorrect effect for patterns- such as /(?=a)a.+/ when the "real" "a" would then become a reqchar instead- of a firstchar. This is overcome by a scan at the end if there's no- firstchar, looking for an asserted first char. */-- else if (bravalue == OP_ASSERT && subreqcharflags >= 0)- {- reqchar = subreqchar;- reqcharflags = subreqcharflags;- }- break; /* End of processing '(' */--- /* ===================================================================*/- /* Handle metasequences introduced by \. For ones like \d, the ESC_ values- are arranged to be the negation of the corresponding OP_values in the- default case when PCRE_UCP is not set. For the back references, the values- are negative the reference number. Only back references and those types- that consume a character may be repeated. We can test for values between- ESC_b and ESC_Z for the latter; this may have to change if any new ones are- ever created. */-- case CHAR_BACKSLASH:- tempptr = ptr;- escape = check_escape(&ptr, &ec, errorcodeptr, cd->bracount, options, FALSE);- if (*errorcodeptr != 0) goto FAILED;-- if (escape == 0) /* The escape coded a single character */- c = ec;- else- {- if (escape == ESC_Q) /* Handle start of quoted string */- {- if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)- ptr += 2; /* avoid empty string */- else inescq = TRUE;- continue;- }-- if (escape == ESC_E) continue; /* Perl ignores an orphan \E */-- /* For metasequences that actually match a character, we disable the- setting of a first character if it hasn't already been set. */-- if (firstcharflags == REQ_UNSET && escape > ESC_b && escape < ESC_Z)- firstcharflags = REQ_NONE;-- /* Set values to reset to if this is followed by a zero repeat. */-- zerofirstchar = firstchar;- zerofirstcharflags = firstcharflags;- zeroreqchar = reqchar;- zeroreqcharflags = reqcharflags;-- /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'- is a subroutine call by number (Oniguruma syntax). In fact, the value- ESC_g is returned only for these cases. So we don't need to check for <- or ' if the value is ESC_g. For the Perl syntax \g{n} the value is- -n, and for the Perl syntax \g{name} the result is ESC_k (as- that is a synonym for a named back reference). */-- if (escape == ESC_g)- {- const pcre_uchar *p;- pcre_uint32 cf;-- save_hwm = cd->hwm; /* Normally this is set when '(' is read */- terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?- CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;-- /* These two statements stop the compiler for warning about possibly- unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In- fact, because we do the check for a number below, the paths that- would actually be in error are never taken. */-- skipbytes = 0;- reset_bracount = FALSE;-- /* If it's not a signed or unsigned number, treat it as a name. */-- cf = ptr[1];- if (cf != CHAR_PLUS && cf != CHAR_MINUS && !IS_DIGIT(cf))- {- is_recurse = TRUE;- goto NAMED_REF_OR_RECURSE;- }-- /* Signed or unsigned number (cf = ptr[1]) is known to be plus or minus- or a digit. */-- p = ptr + 2;- while (IS_DIGIT(*p)) p++;- if (*p != (pcre_uchar)terminator)- {- *errorcodeptr = ERR57;- break;- }- ptr++;- goto HANDLE_NUMERICAL_RECURSION;- }-- /* \k<name> or \k'name' is a back reference by name (Perl syntax).- We also support \k{name} (.NET syntax). */-- if (escape == ESC_k)- {- if ((ptr[1] != CHAR_LESS_THAN_SIGN &&- ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))- {- *errorcodeptr = ERR69;- break;- }- is_recurse = FALSE;- terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?- CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?- CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;- goto NAMED_REF_OR_RECURSE;- }-- /* Back references are handled specially; must disable firstchar if- not set to cope with cases like (?=(\w+))\1: which would otherwise set- ':' later. */-- if (escape < 0)- {- open_capitem *oc;- recno = -escape;-- /* Come here from named backref handling when the reference is to a- single group (i.e. not to a duplicated name. */-- HANDLE_REFERENCE:- if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;- previous = code;- *code++ = ((options & PCRE_CASELESS) != 0)? OP_REFI : OP_REF;- PUT2INC(code, 0, recno);- cd->backref_map |= (recno < 32)? (1 << recno) : 1;- if (recno > cd->top_backref) cd->top_backref = recno;-- /* Check to see if this back reference is recursive, that it, it- is inside the group that it references. A flag is set so that the- group can be made atomic. */-- for (oc = cd->open_caps; oc != NULL; oc = oc->next)- {- if (oc->number == recno)- {- oc->flag = TRUE;- break;- }- }- }-- /* So are Unicode property matches, if supported. */--#ifdef SUPPORT_UCP- else if (escape == ESC_P || escape == ESC_p)- {- BOOL negated;- unsigned int ptype = 0, pdata = 0;- if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))- goto FAILED;- previous = code;- *code++ = ((escape == ESC_p) != negated)? OP_PROP : OP_NOTPROP;- *code++ = ptype;- *code++ = pdata;- }-#else-- /* If Unicode properties are not supported, \X, \P, and \p are not- allowed. */-- else if (escape == ESC_X || escape == ESC_P || escape == ESC_p)- {- *errorcodeptr = ERR45;- goto FAILED;- }-#endif-- /* For the rest (including \X when Unicode properties are supported), we- can obtain the OP value by negating the escape value in the default- situation when PCRE_UCP is not set. When it *is* set, we substitute- Unicode property tests. Note that \b and \B do a one-character- lookbehind, and \A also behaves as if it does. */-- else- {- if ((escape == ESC_b || escape == ESC_B || escape == ESC_A) &&- cd->max_lookbehind == 0)- cd->max_lookbehind = 1;-#ifdef SUPPORT_UCP- if (escape >= ESC_DU && escape <= ESC_wu)- {- nestptr = ptr + 1; /* Where to resume */- ptr = substitutes[escape - ESC_DU] - 1; /* Just before substitute */- }- else-#endif- /* In non-UTF-8 mode, we turn \C into OP_ALLANY instead of OP_ANYBYTE- so that it works in DFA mode and in lookbehinds. */-- {- previous = (escape > ESC_b && escape < ESC_Z)? code : NULL;- *code++ = (!utf && escape == ESC_C)? OP_ALLANY : escape;- }- }- continue;- }-- /* We have a data character whose value is in c. In UTF-8 mode it may have- a value > 127. We set its representation in the length/buffer, and then- handle it as a data character. */--#if defined SUPPORT_UTF && !defined COMPILE_PCRE32- if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)- mclength = PRIV(ord2utf)(c, mcbuffer);- else-#endif-- {- mcbuffer[0] = c;- mclength = 1;- }- goto ONE_CHAR;--- /* ===================================================================*/- /* Handle a literal character. It is guaranteed not to be whitespace or #- when the extended flag is set. If we are in a UTF mode, it may be a- multi-unit literal character. */-- default:- NORMAL_CHAR:- mclength = 1;- mcbuffer[0] = c;--#ifdef SUPPORT_UTF- if (utf && HAS_EXTRALEN(c))- ACROSSCHAR(TRUE, ptr[1], mcbuffer[mclength++] = *(++ptr));-#endif-- /* At this point we have the character's bytes in mcbuffer, and the length- in mclength. When not in UTF-8 mode, the length is always 1. */-- ONE_CHAR:- previous = code;-- /* For caseless UTF-8 mode when UCP support is available, check whether- this character has more than one other case. If so, generate a special- OP_PROP item instead of OP_CHARI. */--#ifdef SUPPORT_UCP- if (utf && (options & PCRE_CASELESS) != 0)- {- GETCHAR(c, mcbuffer);- if ((c = UCD_CASESET(c)) != 0)- {- *code++ = OP_PROP;- *code++ = PT_CLIST;- *code++ = c;- if (firstcharflags == REQ_UNSET)- firstcharflags = zerofirstcharflags = REQ_NONE;- break;- }- }-#endif-- /* Caseful matches, or not one of the multicase characters. */-- *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARI : OP_CHAR;- for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];-- /* Remember if \r or \n were seen */-- if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)- cd->external_flags |= PCRE_HASCRORLF;-- /* Set the first and required bytes appropriately. If no previous first- byte, set it from this character, but revert to none on a zero repeat.- Otherwise, leave the firstchar value alone, and don't change it on a zero- repeat. */-- if (firstcharflags == REQ_UNSET)- {- zerofirstcharflags = REQ_NONE;- zeroreqchar = reqchar;- zeroreqcharflags = reqcharflags;-- /* If the character is more than one byte long, we can set firstchar- only if it is not to be matched caselessly. */-- if (mclength == 1 || req_caseopt == 0)- {- firstchar = mcbuffer[0] | req_caseopt;- firstchar = mcbuffer[0];- firstcharflags = req_caseopt;-- if (mclength != 1)- {- reqchar = code[-1];- reqcharflags = cd->req_varyopt;- }- }- else firstcharflags = reqcharflags = REQ_NONE;- }-- /* firstchar was previously set; we can set reqchar only if the length is- 1 or the matching is caseful. */-- else- {- zerofirstchar = firstchar;- zerofirstcharflags = firstcharflags;- zeroreqchar = reqchar;- zeroreqcharflags = reqcharflags;- if (mclength == 1 || req_caseopt == 0)- {- reqchar = code[-1];- reqcharflags = req_caseopt | cd->req_varyopt;- }- }-- break; /* End of literal character handling */- }- } /* end of big loop */---/* Control never reaches here by falling through, only by a goto for all the-error states. Pass back the position in the pattern so that it can be displayed-to the user for diagnosing the error. */--FAILED:-*ptrptr = ptr;-return FALSE;-}----/*************************************************-* Compile sequence of alternatives *-*************************************************/--/* On entry, ptr is pointing past the bracket character, but on return it-points to the closing bracket, or vertical bar, or end of string. The code-variable is pointing at the byte into which the BRA operator has been stored.-This function is used during the pre-compile phase when we are trying to find-out the amount of memory needed, as well as during the real compile phase. The-value of lengthptr distinguishes the two phases.--Arguments:- options option bits, including any changes for this subpattern- codeptr -> the address of the current code pointer- ptrptr -> the address of the current pattern pointer- errorcodeptr -> pointer to error code variable- lookbehind TRUE if this is a lookbehind assertion- reset_bracount TRUE to reset the count for each branch- skipbytes skip this many bytes at start (for brackets and OP_COND)- cond_depth depth of nesting for conditional subpatterns- firstcharptr place to put the first required character- firstcharflagsptr place to put the first character flags, or a negative number- reqcharptr place to put the last required character- reqcharflagsptr place to put the last required character flags, or a negative number- bcptr pointer to the chain of currently open branches- cd points to the data block with tables pointers etc.- lengthptr NULL during the real compile phase- points to length accumulator during pre-compile phase--Returns: TRUE on success-*/--static BOOL-compile_regex(int options, pcre_uchar **codeptr, const pcre_uchar **ptrptr,- int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,- int cond_depth,- pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,- pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,- branch_chain *bcptr, compile_data *cd, int *lengthptr)-{-const pcre_uchar *ptr = *ptrptr;-pcre_uchar *code = *codeptr;-pcre_uchar *last_branch = code;-pcre_uchar *start_bracket = code;-pcre_uchar *reverse_count = NULL;-open_capitem capitem;-int capnumber = 0;-pcre_uint32 firstchar, reqchar;-pcre_int32 firstcharflags, reqcharflags;-pcre_uint32 branchfirstchar, branchreqchar;-pcre_int32 branchfirstcharflags, branchreqcharflags;-int length;-unsigned int orig_bracount;-unsigned int max_bracount;-branch_chain bc;--bc.outer = bcptr;-bc.current_branch = code;--firstchar = reqchar = 0;-firstcharflags = reqcharflags = REQ_UNSET;--/* Accumulate the length for use in the pre-compile phase. Start with the-length of the BRA and KET and any extra bytes that are required at the-beginning. We accumulate in a local variable to save frequent testing of-lenthptr for NULL. We cannot do this by looking at the value of code at the-start and end of each alternative, because compiled items are discarded during-the pre-compile phase so that the work space is not exceeded. */--length = 2 + 2*LINK_SIZE + skipbytes;--/* WARNING: If the above line is changed for any reason, you must also change-the code that abstracts option settings at the start of the pattern and makes-them global. It tests the value of length for (2 + 2*LINK_SIZE) in the-pre-compile phase to find out whether anything has yet been compiled or not. */--/* If this is a capturing subpattern, add to the chain of open capturing items-so that we can detect them if (*ACCEPT) is encountered. This is also used to-detect groups that contain recursive back references to themselves. Note that-only OP_CBRA need be tested here; changing this opcode to one of its variants,-e.g. OP_SCBRAPOS, happens later, after the group has been compiled. */--if (*code == OP_CBRA)- {- capnumber = GET2(code, 1 + LINK_SIZE);- capitem.number = capnumber;- capitem.next = cd->open_caps;- capitem.flag = FALSE;- cd->open_caps = &capitem;- }--/* Offset is set zero to mark that this bracket is still open */--PUT(code, 1, 0);-code += 1 + LINK_SIZE + skipbytes;--/* Loop for each alternative branch */--orig_bracount = max_bracount = cd->bracount;-for (;;)- {- /* For a (?| group, reset the capturing bracket count so that each branch- uses the same numbers. */-- if (reset_bracount) cd->bracount = orig_bracount;-- /* Set up dummy OP_REVERSE if lookbehind assertion */-- if (lookbehind)- {- *code++ = OP_REVERSE;- reverse_count = code;- PUTINC(code, 0, 0);- length += 1 + LINK_SIZE;- }-- /* Now compile the branch; in the pre-compile phase its length gets added- into the length. */-- if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar,- &branchfirstcharflags, &branchreqchar, &branchreqcharflags, &bc,- cond_depth, cd, (lengthptr == NULL)? NULL : &length))- {- *ptrptr = ptr;- return FALSE;- }-- /* Keep the highest bracket count in case (?| was used and some branch- has fewer than the rest. */-- if (cd->bracount > max_bracount) max_bracount = cd->bracount;-- /* In the real compile phase, there is some post-processing to be done. */-- if (lengthptr == NULL)- {- /* If this is the first branch, the firstchar and reqchar values for the- branch become the values for the regex. */-- if (*last_branch != OP_ALT)- {- firstchar = branchfirstchar;- firstcharflags = branchfirstcharflags;- reqchar = branchreqchar;- reqcharflags = branchreqcharflags;- }-- /* If this is not the first branch, the first char and reqchar have to- match the values from all the previous branches, except that if the- previous value for reqchar didn't have REQ_VARY set, it can still match,- and we set REQ_VARY for the regex. */-- else- {- /* If we previously had a firstchar, but it doesn't match the new branch,- we have to abandon the firstchar for the regex, but if there was- previously no reqchar, it takes on the value of the old firstchar. */-- if (firstcharflags >= 0 &&- (firstcharflags != branchfirstcharflags || firstchar != branchfirstchar))- {- if (reqcharflags < 0)- {- reqchar = firstchar;- reqcharflags = firstcharflags;- }- firstcharflags = REQ_NONE;- }-- /* If we (now or from before) have no firstchar, a firstchar from the- branch becomes a reqchar if there isn't a branch reqchar. */-- if (firstcharflags < 0 && branchfirstcharflags >= 0 && branchreqcharflags < 0)- {- branchreqchar = branchfirstchar;- branchreqcharflags = branchfirstcharflags;- }-- /* Now ensure that the reqchars match */-- if (((reqcharflags & ~REQ_VARY) != (branchreqcharflags & ~REQ_VARY)) ||- reqchar != branchreqchar)- reqcharflags = REQ_NONE;- else- {- reqchar = branchreqchar;- reqcharflags |= branchreqcharflags; /* To "or" REQ_VARY */- }- }-- /* If lookbehind, check that this branch matches a fixed-length string, and- put the length into the OP_REVERSE item. Temporarily mark the end of the- branch with OP_END. If the branch contains OP_RECURSE, the result is -3- because there may be forward references that we can't check here. Set a- flag to cause another lookbehind check at the end. Why not do it all at the- end? Because common, erroneous checks are picked up here and the offset of- the problem can be shown. */-- if (lookbehind)- {- int fixed_length;- *code = OP_END;- fixed_length = find_fixedlength(last_branch, (options & PCRE_UTF8) != 0,- FALSE, cd);- DPRINTF(("fixed length = %d\n", fixed_length));- if (fixed_length == -3)- {- cd->check_lookbehind = TRUE;- }- else if (fixed_length < 0)- {- *errorcodeptr = (fixed_length == -2)? ERR36 :- (fixed_length == -4)? ERR70: ERR25;- *ptrptr = ptr;- return FALSE;- }- else- {- if (fixed_length > cd->max_lookbehind)- cd->max_lookbehind = fixed_length;- PUT(reverse_count, 0, fixed_length);- }- }- }-- /* Reached end of expression, either ')' or end of pattern. In the real- compile phase, go back through the alternative branches and reverse the chain- of offsets, with the field in the BRA item now becoming an offset to the- first alternative. If there are no alternatives, it points to the end of the- group. The length in the terminating ket is always the length of the whole- bracketed item. Return leaving the pointer at the terminating char. */-- if (*ptr != CHAR_VERTICAL_LINE)- {- if (lengthptr == NULL)- {- int branch_length = (int)(code - last_branch);- do- {- int prev_length = GET(last_branch, 1);- PUT(last_branch, 1, branch_length);- branch_length = prev_length;- last_branch -= branch_length;- }- while (branch_length > 0);- }-- /* Fill in the ket */-- *code = OP_KET;- PUT(code, 1, (int)(code - start_bracket));- code += 1 + LINK_SIZE;-- /* If it was a capturing subpattern, check to see if it contained any- recursive back references. If so, we must wrap it in atomic brackets.- In any event, remove the block from the chain. */-- if (capnumber > 0)- {- if (cd->open_caps->flag)- {- memmove(start_bracket + 1 + LINK_SIZE, start_bracket,- IN_UCHARS(code - start_bracket));- *start_bracket = OP_ONCE;- code += 1 + LINK_SIZE;- PUT(start_bracket, 1, (int)(code - start_bracket));- *code = OP_KET;- PUT(code, 1, (int)(code - start_bracket));- code += 1 + LINK_SIZE;- length += 2 + 2*LINK_SIZE;- }- cd->open_caps = cd->open_caps->next;- }-- /* Retain the highest bracket number, in case resetting was used. */-- cd->bracount = max_bracount;-- /* Set values to pass back */-- *codeptr = code;- *ptrptr = ptr;- *firstcharptr = firstchar;- *firstcharflagsptr = firstcharflags;- *reqcharptr = reqchar;- *reqcharflagsptr = reqcharflags;- if (lengthptr != NULL)- {- if (OFLOW_MAX - *lengthptr < length)- {- *errorcodeptr = ERR20;- return FALSE;- }- *lengthptr += length;- }- return TRUE;- }-- /* Another branch follows. In the pre-compile phase, we can move the code- pointer back to where it was for the start of the first branch. (That is,- pretend that each branch is the only one.)-- In the real compile phase, insert an ALT node. Its length field points back- to the previous branch while the bracket remains open. At the end the chain- is reversed. It's done like this so that the start of the bracket has a- zero offset until it is closed, making it possible to detect recursion. */-- if (lengthptr != NULL)- {- code = *codeptr + 1 + LINK_SIZE + skipbytes;- length += 1 + LINK_SIZE;- }- else- {- *code = OP_ALT;- PUT(code, 1, (int)(code - last_branch));- bc.current_branch = last_branch = code;- code += 1 + LINK_SIZE;- }-- ptr++;- }-/* Control never reaches here */-}-----/*************************************************-* Check for anchored expression *-*************************************************/--/* Try to find out if this is an anchored regular expression. Consider each-alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket-all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then-it's anchored. However, if this is a multiline pattern, then only OP_SOD will-be found, because ^ generates OP_CIRCM in that mode.--We can also consider a regex to be anchored if OP_SOM starts all its branches.-This is the code for \G, which means "match at start of match position, taking-into account the match offset".--A branch is also implicitly anchored if it starts with .* and DOTALL is set,-because that will try the rest of the pattern at all possible matching points,-so there is no point trying again.... er ....--.... except when the .* appears inside capturing parentheses, and there is a-subsequent back reference to those parentheses. We haven't enough information-to catch that case precisely.--At first, the best we could do was to detect when .* was in capturing brackets-and the highest back reference was greater than or equal to that level.-However, by keeping a bitmap of the first 31 back references, we can catch some-of the more common cases more precisely.--... A second exception is when the .* appears inside an atomic group, because-this prevents the number of characters it matches from being adjusted.--Arguments:- code points to start of expression (the bracket)- bracket_map a bitmap of which brackets we are inside while testing; this- handles up to substring 31; after that we just have to take- the less precise approach- cd points to the compile data block- atomcount atomic group level--Returns: TRUE or FALSE-*/--static BOOL-is_anchored(register const pcre_uchar *code, unsigned int bracket_map,- compile_data *cd, int atomcount)-{-do {- const pcre_uchar *scode = first_significant_code(- code + PRIV(OP_lengths)[*code], FALSE);- register int op = *scode;-- /* Non-capturing brackets */-- if (op == OP_BRA || op == OP_BRAPOS ||- op == OP_SBRA || op == OP_SBRAPOS)- {- if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;- }-- /* Capturing brackets */-- else if (op == OP_CBRA || op == OP_CBRAPOS ||- op == OP_SCBRA || op == OP_SCBRAPOS)- {- int n = GET2(scode, 1+LINK_SIZE);- int new_map = bracket_map | ((n < 32)? (1 << n) : 1);- if (!is_anchored(scode, new_map, cd, atomcount)) return FALSE;- }-- /* Positive forward assertions and conditions */-- else if (op == OP_ASSERT || op == OP_COND)- {- if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;- }-- /* Atomic groups */-- else if (op == OP_ONCE || op == OP_ONCE_NC)- {- if (!is_anchored(scode, bracket_map, cd, atomcount + 1))- return FALSE;- }-- /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and- it isn't in brackets that are or may be referenced or inside an atomic- group. */-- else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||- op == OP_TYPEPOSSTAR))- {- if (scode[1] != OP_ALLANY || (bracket_map & cd->backref_map) != 0 ||- atomcount > 0 || cd->had_pruneorskip)- return FALSE;- }-- /* Check for explicit anchoring */-- else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;-- code += GET(code, 1);- }-while (*code == OP_ALT); /* Loop for each alternative */-return TRUE;-}----/*************************************************-* Check for starting with ^ or .* *-*************************************************/--/* This is called to find out if every branch starts with ^ or .* so that-"first char" processing can be done to speed things up in multiline-matching and for non-DOTALL patterns that start with .* (which must start at-the beginning or after \n). As in the case of is_anchored() (see above), we-have to take account of back references to capturing brackets that contain .*-because in that case we can't make the assumption. Also, the appearance of .*-inside atomic brackets or in a pattern that contains *PRUNE or *SKIP does not-count, because once again the assumption no longer holds.--Arguments:- code points to start of expression (the bracket)- bracket_map a bitmap of which brackets we are inside while testing; this- handles up to substring 31; after that we just have to take- the less precise approach- cd points to the compile data- atomcount atomic group level--Returns: TRUE or FALSE-*/--static BOOL-is_startline(const pcre_uchar *code, unsigned int bracket_map,- compile_data *cd, int atomcount)-{-do {- const pcre_uchar *scode = first_significant_code(- code + PRIV(OP_lengths)[*code], FALSE);- register int op = *scode;-- /* If we are at the start of a conditional assertion group, *both* the- conditional assertion *and* what follows the condition must satisfy the test- for start of line. Other kinds of condition fail. Note that there may be an- auto-callout at the start of a condition. */-- if (op == OP_COND)- {- scode += 1 + LINK_SIZE;- if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];- switch (*scode)- {- case OP_CREF:- case OP_DNCREF:- case OP_RREF:- case OP_DNRREF:- case OP_DEF:- return FALSE;-- default: /* Assertion */- if (!is_startline(scode, bracket_map, cd, atomcount)) return FALSE;- do scode += GET(scode, 1); while (*scode == OP_ALT);- scode += 1 + LINK_SIZE;- break;- }- scode = first_significant_code(scode, FALSE);- op = *scode;- }-- /* Non-capturing brackets */-- if (op == OP_BRA || op == OP_BRAPOS ||- op == OP_SBRA || op == OP_SBRAPOS)- {- if (!is_startline(scode, bracket_map, cd, atomcount)) return FALSE;- }-- /* Capturing brackets */-- else if (op == OP_CBRA || op == OP_CBRAPOS ||- op == OP_SCBRA || op == OP_SCBRAPOS)- {- int n = GET2(scode, 1+LINK_SIZE);- int new_map = bracket_map | ((n < 32)? (1 << n) : 1);- if (!is_startline(scode, new_map, cd, atomcount)) return FALSE;- }-- /* Positive forward assertions */-- else if (op == OP_ASSERT)- {- if (!is_startline(scode, bracket_map, cd, atomcount)) return FALSE;- }-- /* Atomic brackets */-- else if (op == OP_ONCE || op == OP_ONCE_NC)- {- if (!is_startline(scode, bracket_map, cd, atomcount + 1)) return FALSE;- }-- /* .* means "start at start or after \n" if it isn't in atomic brackets or- brackets that may be referenced, as long as the pattern does not contain- *PRUNE or *SKIP, because these break the feature. Consider, for example,- /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab", i.e. not at the- start of a line. */-- else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)- {- if (scode[1] != OP_ANY || (bracket_map & cd->backref_map) != 0 ||- atomcount > 0 || cd->had_pruneorskip)- return FALSE;- }-- /* Check for explicit circumflex; anything else gives a FALSE result. Note- in particular that this includes atomic brackets OP_ONCE and OP_ONCE_NC- because the number of characters matched by .* cannot be adjusted inside- them. */-- else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;-- /* Move on to the next alternative */-- code += GET(code, 1);- }-while (*code == OP_ALT); /* Loop for each alternative */-return TRUE;-}----/*************************************************-* Check for asserted fixed first char *-*************************************************/--/* During compilation, the "first char" settings from forward assertions are-discarded, because they can cause conflicts with actual literals that follow.-However, if we end up without a first char setting for an unanchored pattern,-it is worth scanning the regex to see if there is an initial asserted first-char. If all branches start with the same asserted char, or with a-non-conditional bracket all of whose alternatives start with the same asserted-char (recurse ad lib), then we return that char, with the flags set to zero or-REQ_CASELESS; otherwise return zero with REQ_NONE in the flags.--Arguments:- code points to start of expression (the bracket)- flags points to the first char flags, or to REQ_NONE- inassert TRUE if in an assertion--Returns: the fixed first char, or 0 with REQ_NONE in flags-*/--static pcre_uint32-find_firstassertedchar(const pcre_uchar *code, pcre_int32 *flags,- BOOL inassert)-{-register pcre_uint32 c = 0;-int cflags = REQ_NONE;--*flags = REQ_NONE;-do {- pcre_uint32 d;- int dflags;- int xl = (*code == OP_CBRA || *code == OP_SCBRA ||- *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;- const pcre_uchar *scode = first_significant_code(code + 1+LINK_SIZE + xl,- TRUE);- register pcre_uchar op = *scode;-- switch(op)- {- default:- return 0;-- case OP_BRA:- case OP_BRAPOS:- case OP_CBRA:- case OP_SCBRA:- case OP_CBRAPOS:- case OP_SCBRAPOS:- case OP_ASSERT:- case OP_ONCE:- case OP_ONCE_NC:- d = find_firstassertedchar(scode, &dflags, op == OP_ASSERT);- if (dflags < 0)- return 0;- if (cflags < 0) { c = d; cflags = dflags; } else if (c != d || cflags != dflags) return 0;- break;-- case OP_EXACT:- scode += IMM2_SIZE;- /* Fall through */-- case OP_CHAR:- case OP_PLUS:- case OP_MINPLUS:- case OP_POSPLUS:- if (!inassert) return 0;- if (cflags < 0) { c = scode[1]; cflags = 0; }- else if (c != scode[1]) return 0;- break;-- case OP_EXACTI:- scode += IMM2_SIZE;- /* Fall through */-- case OP_CHARI:- case OP_PLUSI:- case OP_MINPLUSI:- case OP_POSPLUSI:- if (!inassert) return 0;- if (cflags < 0) { c = scode[1]; cflags = REQ_CASELESS; }- else if (c != scode[1]) return 0;- break;- }-- code += GET(code, 1);- }-while (*code == OP_ALT);--*flags = cflags;-return c;-}----/*************************************************-* Add an entry to the name/number table *-*************************************************/--/* This function is called between compiling passes to add an entry to the-name/number table, maintaining alphabetical order. Checking for permitted-and forbidden duplicates has already been done.--Arguments:- cd the compile data block- name the name to add- length the length of the name- groupno the group number--Returns: nothing-*/--static void-add_name(compile_data *cd, const pcre_uchar *name, int length,- unsigned int groupno)-{-int i;-pcre_uchar *slot = cd->name_table;--for (i = 0; i < cd->names_found; i++)- {- int crc = memcmp(name, slot+IMM2_SIZE, IN_UCHARS(length));- if (crc == 0 && slot[IMM2_SIZE+length] != 0)- crc = -1; /* Current name is a substring */-- /* Make space in the table and break the loop for an earlier name. For a- duplicate or later name, carry on. We do this for duplicates so that in the- simple case (when ?(| is not used) they are in order of their numbers. In all- cases they are in the order in which they appear in the pattern. */-- if (crc < 0)- {- memmove(slot + cd->name_entry_size, slot,- IN_UCHARS((cd->names_found - i) * cd->name_entry_size));- break;- }-- /* Continue the loop for a later or duplicate name */-- slot += cd->name_entry_size;- }--PUT2(slot, 0, groupno);-memcpy(slot + IMM2_SIZE, name, IN_UCHARS(length));-slot[IMM2_SIZE + length] = 0;-cd->names_found++;-}----/*************************************************-* Compile a Regular Expression *-*************************************************/--/* This function takes a string and returns a pointer to a block of store-holding a compiled version of the expression. The original API for this-function had no error code return variable; it is retained for backwards-compatibility. The new function is given a new name.--Arguments:- pattern the regular expression- options various option bits- errorcodeptr pointer to error code variable (pcre_compile2() only)- can be NULL if you don't want a code value- errorptr pointer to pointer to error text- erroroffset ptr offset in pattern where error was detected- tables pointer to character tables or NULL--Returns: pointer to compiled data block, or NULL on error,- with errorptr and erroroffset set-*/--#if defined COMPILE_PCRE8-PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION-pcre_compile(const char *pattern, int options, const char **errorptr,- int *erroroffset, const unsigned char *tables)-#elif defined COMPILE_PCRE16-PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION-pcre16_compile(PCRE_SPTR16 pattern, int options, const char **errorptr,- int *erroroffset, const unsigned char *tables)-#elif defined COMPILE_PCRE32-PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION-pcre32_compile(PCRE_SPTR32 pattern, int options, const char **errorptr,- int *erroroffset, const unsigned char *tables)-#endif-{-#if defined COMPILE_PCRE8-return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);-#elif defined COMPILE_PCRE16-return pcre16_compile2(pattern, options, NULL, errorptr, erroroffset, tables);-#elif defined COMPILE_PCRE32-return pcre32_compile2(pattern, options, NULL, errorptr, erroroffset, tables);-#endif-}---#if defined COMPILE_PCRE8-PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION-pcre_compile2(const char *pattern, int options, int *errorcodeptr,- const char **errorptr, int *erroroffset, const unsigned char *tables)-#elif defined COMPILE_PCRE16-PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION-pcre16_compile2(PCRE_SPTR16 pattern, int options, int *errorcodeptr,- const char **errorptr, int *erroroffset, const unsigned char *tables)-#elif defined COMPILE_PCRE32-PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION-pcre32_compile2(PCRE_SPTR32 pattern, int options, int *errorcodeptr,- const char **errorptr, int *erroroffset, const unsigned char *tables)-#endif-{-REAL_PCRE *re;-int length = 1; /* For final END opcode */-pcre_int32 firstcharflags, reqcharflags;-pcre_uint32 firstchar, reqchar;-pcre_uint32 limit_match = PCRE_UINT32_MAX;-pcre_uint32 limit_recursion = PCRE_UINT32_MAX;-int newline;-int errorcode = 0;-int skipatstart = 0;-BOOL utf;-BOOL never_utf = FALSE;-size_t size;-pcre_uchar *code;-const pcre_uchar *codestart;-const pcre_uchar *ptr;-compile_data compile_block;-compile_data *cd = &compile_block;--/* This space is used for "compiling" into during the first phase, when we are-computing the amount of memory that is needed. Compiled items are thrown away-as soon as possible, so that a fairly large buffer should be sufficient for-this purpose. The same space is used in the second phase for remembering where-to fill in forward references to subpatterns. That may overflow, in which case-new memory is obtained from malloc(). */--pcre_uchar cworkspace[COMPILE_WORK_SIZE];--/* This vector is used for remembering name groups during the pre-compile. In a-similar way to cworkspace, it can be expanded using malloc() if necessary. */--named_group named_groups[NAMED_GROUP_LIST_SIZE];--/* Set this early so that early errors get offset 0. */--ptr = (const pcre_uchar *)pattern;--/* We can't pass back an error message if errorptr is NULL; I guess the best we-can do is just return NULL, but we can set a code value if there is a code-pointer. */--if (errorptr == NULL)- {- if (errorcodeptr != NULL) *errorcodeptr = 99;- return NULL;- }--*errorptr = NULL;-if (errorcodeptr != NULL) *errorcodeptr = ERR0;--/* However, we can give a message for this error */--if (erroroffset == NULL)- {- errorcode = ERR16;- goto PCRE_EARLY_ERROR_RETURN2;- }--*erroroffset = 0;--/* Set up pointers to the individual character tables */--if (tables == NULL) tables = PRIV(default_tables);-cd->lcc = tables + lcc_offset;-cd->fcc = tables + fcc_offset;-cd->cbits = tables + cbits_offset;-cd->ctypes = tables + ctypes_offset;--/* Check that all undefined public option bits are zero */--if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0)- {- errorcode = ERR17;- goto PCRE_EARLY_ERROR_RETURN;- }--/* If PCRE_NEVER_UTF is set, remember it. */--if ((options & PCRE_NEVER_UTF) != 0) never_utf = TRUE;--/* Check for global one-time settings at the start of the pattern, and remember-the offset for later. */--cd->external_flags = 0; /* Initialize here for LIMIT_MATCH/RECURSION */--while (ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&- ptr[skipatstart+1] == CHAR_ASTERISK)- {- int newnl = 0;- int newbsr = 0;--/* For completeness and backward compatibility, (*UTFn) is supported in the-relevant libraries, but (*UTF) is generic and always supported. Note that-PCRE_UTF8 == PCRE_UTF16 == PCRE_UTF32. */--#ifdef COMPILE_PCRE8- if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF8_RIGHTPAR, 5) == 0)- { skipatstart += 7; options |= PCRE_UTF8; continue; }-#endif-#ifdef COMPILE_PCRE16- if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF16_RIGHTPAR, 6) == 0)- { skipatstart += 8; options |= PCRE_UTF16; continue; }-#endif-#ifdef COMPILE_PCRE32- if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF32_RIGHTPAR, 6) == 0)- { skipatstart += 8; options |= PCRE_UTF32; continue; }-#endif-- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 4) == 0)- { skipatstart += 6; options |= PCRE_UTF8; continue; }- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UCP_RIGHTPAR, 4) == 0)- { skipatstart += 6; options |= PCRE_UCP; continue; }- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_AUTO_POSSESS_RIGHTPAR, 16) == 0)- { skipatstart += 18; options |= PCRE_NO_AUTO_POSSESS; continue; }- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_START_OPT_RIGHTPAR, 13) == 0)- { skipatstart += 15; options |= PCRE_NO_START_OPTIMIZE; continue; }-- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LIMIT_MATCH_EQ, 12) == 0)- {- pcre_uint32 c = 0;- int p = skipatstart + 14;- while (isdigit(ptr[p]))- {- if (c > PCRE_UINT32_MAX / 10 - 1) break; /* Integer overflow */- c = c*10 + ptr[p++] - CHAR_0;- }- if (ptr[p++] != CHAR_RIGHT_PARENTHESIS) break;- if (c < limit_match)- {- limit_match = c;- cd->external_flags |= PCRE_MLSET;- }- skipatstart = p;- continue;- }-- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LIMIT_RECURSION_EQ, 16) == 0)- {- pcre_uint32 c = 0;- int p = skipatstart + 18;- while (isdigit(ptr[p]))- {- if (c > PCRE_UINT32_MAX / 10 - 1) break; /* Integer overflow check */- c = c*10 + ptr[p++] - CHAR_0;- }- if (ptr[p++] != CHAR_RIGHT_PARENTHESIS) break;- if (c < limit_recursion)- {- limit_recursion = c;- cd->external_flags |= PCRE_RLSET;- }- skipatstart = p;- continue;- }-- if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CR_RIGHTPAR, 3) == 0)- { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LF_RIGHTPAR, 3) == 0)- { skipatstart += 5; newnl = PCRE_NEWLINE_LF; }- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CRLF_RIGHTPAR, 5) == 0)- { skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANY_RIGHTPAR, 4) == 0)- { skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANYCRLF_RIGHTPAR, 8) == 0)- { skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }-- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)- { skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }- else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)- { skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }-- if (newnl != 0)- options = (options & ~PCRE_NEWLINE_BITS) | newnl;- else if (newbsr != 0)- options = (options & ~(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) | newbsr;- else break;- }--/* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */-utf = (options & PCRE_UTF8) != 0;-if (utf && never_utf)- {- errorcode = ERR78;- goto PCRE_EARLY_ERROR_RETURN2;- }--/* Can't support UTF unless PCRE has been compiled to include the code. The-return of an error code from PRIV(valid_utf)() is a new feature, introduced in-release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is-not used here. */--#ifdef SUPPORT_UTF-if (utf && (options & PCRE_NO_UTF8_CHECK) == 0 &&- (errorcode = PRIV(valid_utf)((PCRE_PUCHAR)pattern, -1, erroroffset)) != 0)- {-#if defined COMPILE_PCRE8- errorcode = ERR44;-#elif defined COMPILE_PCRE16- errorcode = ERR74;-#elif defined COMPILE_PCRE32- errorcode = ERR77;-#endif- goto PCRE_EARLY_ERROR_RETURN2;- }-#else-if (utf)- {- errorcode = ERR32;- goto PCRE_EARLY_ERROR_RETURN;- }-#endif--/* Can't support UCP unless PCRE has been compiled to include the code. */--#ifndef SUPPORT_UCP-if ((options & PCRE_UCP) != 0)- {- errorcode = ERR67;- goto PCRE_EARLY_ERROR_RETURN;- }-#endif--/* Check validity of \R options. */--if ((options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) ==- (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))- {- errorcode = ERR56;- goto PCRE_EARLY_ERROR_RETURN;- }--/* Handle different types of newline. The three bits give seven cases. The-current code allows for fixed one- or two-byte sequences, plus "any" and-"anycrlf". */--switch (options & PCRE_NEWLINE_BITS)- {- case 0: newline = NEWLINE; break; /* Build-time default */- case PCRE_NEWLINE_CR: newline = CHAR_CR; break;- case PCRE_NEWLINE_LF: newline = CHAR_NL; break;- case PCRE_NEWLINE_CR+- PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;- case PCRE_NEWLINE_ANY: newline = -1; break;- case PCRE_NEWLINE_ANYCRLF: newline = -2; break;- default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;- }--if (newline == -2)- {- cd->nltype = NLTYPE_ANYCRLF;- }-else if (newline < 0)- {- cd->nltype = NLTYPE_ANY;- }-else- {- cd->nltype = NLTYPE_FIXED;- if (newline > 255)- {- cd->nllen = 2;- cd->nl[0] = (newline >> 8) & 255;- cd->nl[1] = newline & 255;- }- else- {- cd->nllen = 1;- cd->nl[0] = newline;- }- }--/* Maximum back reference and backref bitmap. The bitmap records up to 31 back-references to help in deciding whether (.*) can be treated as anchored or not.-*/--cd->top_backref = 0;-cd->backref_map = 0;--/* Reflect pattern for debugging output */--DPRINTF(("------------------------------------------------------------------\n"));-#ifdef PCRE_DEBUG-print_puchar(stdout, (PCRE_PUCHAR)pattern);-#endif-DPRINTF(("\n"));--/* Pretend to compile the pattern while actually just accumulating the length-of memory required. This behaviour is triggered by passing a non-NULL final-argument to compile_regex(). We pass a block of workspace (cworkspace) for it-to compile parts of the pattern into; the compiled code is discarded when it is-no longer needed, so hopefully this workspace will never overflow, though there-is a test for its doing so. */--cd->bracount = cd->final_bracount = 0;-cd->names_found = 0;-cd->name_entry_size = 0;-cd->name_table = NULL;-cd->dupnames = FALSE;-cd->namedrefcount = 0;-cd->start_code = cworkspace;-cd->hwm = cworkspace;-cd->start_workspace = cworkspace;-cd->workspace_size = COMPILE_WORK_SIZE;-cd->named_groups = named_groups;-cd->named_group_list_size = NAMED_GROUP_LIST_SIZE;-cd->start_pattern = (const pcre_uchar *)pattern;-cd->end_pattern = (const pcre_uchar *)(pattern + STRLEN_UC((const pcre_uchar *)pattern));-cd->req_varyopt = 0;-cd->parens_depth = 0;-cd->assert_depth = 0;-cd->max_lookbehind = 0;-cd->external_options = options;-cd->open_caps = NULL;--/* Now do the pre-compile. On error, errorcode will be set non-zero, so we-don't need to look at the result of the function here. The initial options have-been put into the cd block so that they can be changed if an option setting is-found within the regex right at the beginning. Bringing initial option settings-outside can help speed up starting point checks. */--ptr += skipatstart;-code = cworkspace;-*code = OP_BRA;--(void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,- FALSE, 0, 0, &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL,- cd, &length);-if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;--DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,- (int)(cd->hwm - cworkspace)));--if (length > MAX_PATTERN_SIZE)- {- errorcode = ERR20;- goto PCRE_EARLY_ERROR_RETURN;- }--/* If there are groups with duplicate names and there are also references by-name, we must allow for the possibility of named references to duplicated-groups. These require an extra data item each. */--if (cd->dupnames && cd->namedrefcount > 0)- length += cd->namedrefcount * IMM2_SIZE * sizeof(pcre_uchar);--/* Compute the size of the data block for storing the compiled pattern. Integer-overflow should no longer be possible because nowadays we limit the maximum-value of cd->names_found and cd->name_entry_size. */--size = sizeof(REAL_PCRE) +- (length + cd->names_found * cd->name_entry_size) * sizeof(pcre_uchar);--/* Get the memory. */--re = (REAL_PCRE *)(PUBL(malloc))(size);-if (re == NULL)- {- errorcode = ERR21;- goto PCRE_EARLY_ERROR_RETURN;- }--/* Put in the magic number, and save the sizes, initial options, internal-flags, and character table pointer. NULL is used for the default character-tables. The nullpad field is at 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->magic_number = MAGIC_NUMBER;-re->size = (int)size;-re->options = cd->external_options;-re->flags = cd->external_flags;-re->limit_match = limit_match;-re->limit_recursion = limit_recursion;-re->first_char = 0;-re->req_char = 0;-re->name_table_offset = sizeof(REAL_PCRE) / sizeof(pcre_uchar);-re->name_entry_size = cd->name_entry_size;-re->name_count = cd->names_found;-re->ref_count = 0;-re->tables = (tables == PRIV(default_tables))? NULL : tables;-re->nullpad = NULL;-#ifdef COMPILE_PCRE32-re->dummy = 0;-#else-re->dummy1 = re->dummy2 = re->dummy3 = 0;-#endif--/* The starting points of the name/number translation table and of the code are-passed around in the compile data block. The start/end pattern and initial-options are already set from the pre-compile phase, as is the name_entry_size-field. Reset the bracket count and the names_found field. Also reset the hwm-field; this time it's used for remembering forward references to subpatterns.-*/--cd->final_bracount = cd->bracount; /* Save for checking forward references */-cd->parens_depth = 0;-cd->assert_depth = 0;-cd->bracount = 0;-cd->max_lookbehind = 0;-cd->name_table = (pcre_uchar *)re + re->name_table_offset;-codestart = cd->name_table + re->name_entry_size * re->name_count;-cd->start_code = codestart;-cd->hwm = (pcre_uchar *)(cd->start_workspace);-cd->req_varyopt = 0;-cd->had_accept = FALSE;-cd->had_pruneorskip = FALSE;-cd->check_lookbehind = FALSE;-cd->open_caps = NULL;--/* If any named groups were found, create the name/number table from the list-created in the first pass. */--if (cd->names_found > 0)- {- int i = cd->names_found;- named_group *ng = cd->named_groups;- cd->names_found = 0;- for (; i > 0; i--, ng++)- add_name(cd, ng->name, ng->length, ng->number);- if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE)- (PUBL(free))((void *)cd->named_groups);- }--/* Set up a starting, non-extracting bracket, then compile the expression. On-error, errorcode will be set non-zero, so we don't need to look at the result-of the function here. */--ptr = (const pcre_uchar *)pattern + skipatstart;-code = (pcre_uchar *)codestart;-*code = OP_BRA;-(void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,- &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL, cd, NULL);-re->top_bracket = cd->bracount;-re->top_backref = cd->top_backref;-re->max_lookbehind = cd->max_lookbehind;-re->flags = cd->external_flags | PCRE_MODE;--if (cd->had_accept)- {- reqchar = 0; /* Must disable after (*ACCEPT) */- reqcharflags = REQ_NONE;- }--/* If not reached end of pattern on success, there's an excess bracket. */--if (errorcode == 0 && *ptr != CHAR_NULL) errorcode = ERR22;--/* Fill in the terminating state and check for disastrous overflow, but-if debugging, leave the test till after things are printed out. */--*code++ = OP_END;--#ifndef PCRE_DEBUG-if (code - codestart > length) errorcode = ERR23;-#endif--#ifdef SUPPORT_VALGRIND-/* If the estimated length exceeds the really used length, mark the extra-allocated memory as unaddressable, so that any out-of-bound reads can be-detected. */-VALGRIND_MAKE_MEM_NOACCESS(code, (length - (code - codestart)) * sizeof(pcre_uchar));-#endif--/* Fill in any forward references that are required. There may be repeated-references; optimize for them, as searching a large regex takes time. */--if (cd->hwm > cd->start_workspace)- {- int prev_recno = -1;- const pcre_uchar *groupptr = NULL;- while (errorcode == 0 && cd->hwm > cd->start_workspace)- {- int offset, recno;- cd->hwm -= LINK_SIZE;- offset = GET(cd->hwm, 0);- recno = GET(codestart, offset);- if (recno != prev_recno)- {- groupptr = PRIV(find_bracket)(codestart, utf, recno);- prev_recno = recno;- }- if (groupptr == NULL) errorcode = ERR53;- else PUT(((pcre_uchar *)codestart), offset, (int)(groupptr - codestart));- }- }--/* If the workspace had to be expanded, free the new memory. Set the pointer to-NULL to indicate that forward references have been filled in. */--if (cd->workspace_size > COMPILE_WORK_SIZE)- (PUBL(free))((void *)cd->start_workspace);-cd->start_workspace = NULL;--/* Give an error if there's back reference to a non-existent capturing-subpattern. */--if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;--/* Unless disabled, check whether single character iterators can be-auto-possessified. The function overwrites the appropriate opcode values. */--if ((options & PCRE_NO_AUTO_POSSESS) == 0)- auto_possessify((pcre_uchar *)codestart, utf, cd);--/* If there were any lookbehind assertions that contained OP_RECURSE-(recursions or subroutine calls), a flag is set for them to be checked here,-because they may contain forward references. Actual recursions cannot be fixed-length, but subroutine calls can. It is done like this so that those without-OP_RECURSE that are not fixed length get a diagnosic with a useful offset. The-exceptional ones forgo this. We scan the pattern to check that they are fixed-length, and set their lengths. */--if (cd->check_lookbehind)- {- pcre_uchar *cc = (pcre_uchar *)codestart;-- /* Loop, searching for OP_REVERSE items, and process those that do not have- their length set. (Actually, it will also re-process any that have a length- of zero, but that is a pathological case, and it does no harm.) When we find- one, we temporarily terminate the branch it is in while we scan it. */-- for (cc = (pcre_uchar *)PRIV(find_bracket)(codestart, utf, -1);- cc != NULL;- cc = (pcre_uchar *)PRIV(find_bracket)(cc, utf, -1))- {- if (GET(cc, 1) == 0)- {- int fixed_length;- pcre_uchar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);- int end_op = *be;- *be = OP_END;- fixed_length = find_fixedlength(cc, (re->options & PCRE_UTF8) != 0, TRUE,- cd);- *be = end_op;- DPRINTF(("fixed length = %d\n", fixed_length));- if (fixed_length < 0)- {- errorcode = (fixed_length == -2)? ERR36 :- (fixed_length == -4)? ERR70 : ERR25;- break;- }- if (fixed_length > cd->max_lookbehind) cd->max_lookbehind = fixed_length;- PUT(cc, 1, fixed_length);- }- cc += 1 + LINK_SIZE;- }- }--/* Failed to compile, or error while post-processing */--if (errorcode != 0)- {- (PUBL(free))(re);- PCRE_EARLY_ERROR_RETURN:- *erroroffset = (int)(ptr - (const pcre_uchar *)pattern);- PCRE_EARLY_ERROR_RETURN2:- *errorptr = find_error_text(errorcode);- if (errorcodeptr != NULL) *errorcodeptr = errorcode;- return NULL;- }--/* If the anchored option was not passed, set the flag if we can determine that-the pattern is anchored by virtue of ^ characters or \A or anything else, such-as starting with non-atomic .* when DOTALL is set and there are no occurrences-of *PRUNE or *SKIP.--Otherwise, if we know what the first byte has to be, save it, because that-speeds up unanchored matches no end. If not, see if we can set the-PCRE_STARTLINE flag. This is helpful for multiline matches when all branches-start with ^. and also when all branches start with non-atomic .* for-non-DOTALL matches when *PRUNE and SKIP are not present. */--if ((re->options & PCRE_ANCHORED) == 0)- {- if (is_anchored(codestart, 0, cd, 0)) re->options |= PCRE_ANCHORED;- else- {- if (firstcharflags < 0)- firstchar = find_firstassertedchar(codestart, &firstcharflags, FALSE);- if (firstcharflags >= 0) /* Remove caseless flag for non-caseable chars */- {-#if defined COMPILE_PCRE8- re->first_char = firstchar & 0xff;-#elif defined COMPILE_PCRE16- re->first_char = firstchar & 0xffff;-#elif defined COMPILE_PCRE32- re->first_char = firstchar;-#endif- if ((firstcharflags & REQ_CASELESS) != 0)- {-#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)- /* We ignore non-ASCII first chars in 8 bit mode. */- if (utf)- {- if (re->first_char < 128)- {- if (cd->fcc[re->first_char] != re->first_char)- re->flags |= PCRE_FCH_CASELESS;- }- else if (UCD_OTHERCASE(re->first_char) != re->first_char)- re->flags |= PCRE_FCH_CASELESS;- }- else-#endif- if (MAX_255(re->first_char)- && cd->fcc[re->first_char] != re->first_char)- re->flags |= PCRE_FCH_CASELESS;- }-- re->flags |= PCRE_FIRSTSET;- }-- else if (is_startline(codestart, 0, cd, 0)) re->flags |= PCRE_STARTLINE;- }- }--/* For an anchored pattern, we use the "required byte" only if it follows a-variable length item in the regex. Remove the caseless flag for non-caseable-bytes. */--if (reqcharflags >= 0 &&- ((re->options & PCRE_ANCHORED) == 0 || (reqcharflags & REQ_VARY) != 0))- {-#if defined COMPILE_PCRE8- re->req_char = reqchar & 0xff;-#elif defined COMPILE_PCRE16- re->req_char = reqchar & 0xffff;-#elif defined COMPILE_PCRE32- re->req_char = reqchar;-#endif- if ((reqcharflags & REQ_CASELESS) != 0)- {-#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)- /* We ignore non-ASCII first chars in 8 bit mode. */- if (utf)- {- if (re->req_char < 128)- {- if (cd->fcc[re->req_char] != re->req_char)- re->flags |= PCRE_RCH_CASELESS;- }- else if (UCD_OTHERCASE(re->req_char) != re->req_char)- re->flags |= PCRE_RCH_CASELESS;- }- else-#endif- if (MAX_255(re->req_char) && cd->fcc[re->req_char] != re->req_char)- re->flags |= PCRE_RCH_CASELESS;- }-- re->flags |= PCRE_REQCHSET;- }--/* Print out the compiled data if debugging is enabled. This is never the-case when building a production library. */--#ifdef PCRE_DEBUG-printf("Length = %d top_bracket = %d top_backref = %d\n",- length, re->top_bracket, re->top_backref);--printf("Options=%08x\n", re->options);--if ((re->flags & PCRE_FIRSTSET) != 0)- {- pcre_uchar ch = re->first_char;- const char *caseless =- ((re->flags & PCRE_FCH_CASELESS) == 0)? "" : " (caseless)";- if (PRINTABLE(ch)) printf("First char = %c%s\n", ch, caseless);- else printf("First char = \\x%02x%s\n", ch, caseless);- }--if ((re->flags & PCRE_REQCHSET) != 0)- {- pcre_uchar ch = re->req_char;- const char *caseless =- ((re->flags & PCRE_RCH_CASELESS) == 0)? "" : " (caseless)";- if (PRINTABLE(ch)) printf("Req char = %c%s\n", ch, caseless);- else printf("Req char = \\x%02x%s\n", ch, caseless);- }--#if defined COMPILE_PCRE8-pcre_printint((pcre *)re, stdout, TRUE);-#elif defined COMPILE_PCRE16-pcre16_printint((pcre *)re, stdout, TRUE);-#elif defined COMPILE_PCRE32-pcre32_printint((pcre *)re, stdout, TRUE);-#endif--/* This check is done here in the debugging case so that the code that-was compiled can be seen. */--if (code - codestart > length)- {- (PUBL(free))(re);- *errorptr = find_error_text(ERR23);- *erroroffset = ptr - (pcre_uchar *)pattern;- if (errorcodeptr != NULL) *errorcodeptr = ERR23;- return NULL;- }-#endif /* PCRE_DEBUG */--/* Check for a pattern than can match an empty string, so that this information-can be provided to applications. */--do- {- if (could_be_empty_branch(codestart, code, utf, cd, NULL))- {- re->flags |= PCRE_MATCH_EMPTY;- break;- }- codestart += GET(codestart, 1);- }-while (*codestart == OP_ALT);--#if defined COMPILE_PCRE8-return (pcre *)re;-#elif defined COMPILE_PCRE16-return (pcre16 *)re;-#elif defined COMPILE_PCRE32-return (pcre32 *)re;-#endif-}--/* End of pcre_compile.c */-+ Copyright (c) 1997-2018 University of Cambridge++-----------------------------------------------------------------------------+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.+-----------------------------------------------------------------------------+*/+++/* This module contains the external function pcre_compile(), along with+supporting internal functions that are not used by other modules. */+++#ifdef HAVE_CONFIG_H+#include "config.h"+#endif++#define NLBLOCK cd /* Block containing newline information */+#define PSSTART start_pattern /* Field containing pattern start */+#define PSEND end_pattern /* Field containing pattern end */++#include "pcre_internal.h"+++/* When PCRE_DEBUG is defined, we need the pcre(16|32)_printint() function, which+is also used by pcretest. PCRE_DEBUG is not defined when building a production+library. We do not need to select pcre16_printint.c specially, because the+COMPILE_PCREx macro will already be appropriately set. */++#ifdef PCRE_DEBUG+/* pcre_printint.c should not include any headers */+#define PCRE_INCLUDED+#include "pcre_printint.c"+#undef PCRE_INCLUDED+#endif+++/* Macro for setting individual bits in class bitmaps. */++#define SETBIT(a,b) a[(b)/8] |= (1 << ((b)&7))++/* Maximum length value to check against when making sure that the integer that+holds the compiled pattern length does not overflow. We make it a bit less than+INT_MAX to allow for adding in group terminating bytes, so that we don't have+to check them every time. */++#define OFLOW_MAX (INT_MAX - 20)++/* Definitions to allow mutual recursion */++static int+ add_list_to_class(pcre_uint8 *, pcre_uchar **, int, compile_data *,+ const pcre_uint32 *, unsigned int);++static BOOL+ compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,+ pcre_uint32 *, pcre_int32 *, pcre_uint32 *, pcre_int32 *, branch_chain *,+ compile_data *, int *);++++/*************************************************+* Code parameters and static tables *+*************************************************/++/* This value specifies the size of stack workspace that is used during the+first pre-compile phase that determines how much memory is required. The regex+is partly compiled into this space, but the compiled parts are discarded as+soon as they can be, so that hopefully there will never be an overrun. The code+does, however, check for an overrun. The largest amount I've seen used is 218,+so this number is very generous.++The same workspace is used during the second, actual compile phase for+remembering forward references to groups so that they can be filled in at the+end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE+is 4 there is plenty of room for most patterns. However, the memory can get+filled up by repetitions of forward references, for example patterns like+/(?1){0,1999}(b)/, and one user did hit the limit. The code has been changed so+that the workspace is expanded using malloc() in this situation. The value+below is therefore a minimum, and we put a maximum on it for safety. The+minimum is now also defined in terms of LINK_SIZE so that the use of malloc()+kicks in at the same number of forward references in all cases. */++#define COMPILE_WORK_SIZE (2048*LINK_SIZE)+#define COMPILE_WORK_SIZE_MAX (100*COMPILE_WORK_SIZE)++/* This value determines the size of the initial vector that is used for+remembering named groups during the pre-compile. It is allocated on the stack,+but if it is too small, it is expanded using malloc(), in a similar way to the+workspace. The value is the number of slots in the list. */++#define NAMED_GROUP_LIST_SIZE 20++/* The overrun tests check for a slightly smaller size so that they detect the+overrun before it actually does run off the end of the data block. */++#define WORK_SIZE_SAFETY_MARGIN (100)++/* Private flags added to firstchar and reqchar. */++#define REQ_CASELESS (1 << 0) /* Indicates caselessness */+#define REQ_VARY (1 << 1) /* Reqchar followed non-literal item */+/* Negative values for the firstchar and reqchar flags */+#define REQ_UNSET (-2)+#define REQ_NONE (-1)++/* Repeated character flags. */++#define UTF_LENGTH 0x10000000l /* The char contains its length. */++/* Table for handling escaped characters in the range '0'-'z'. Positive returns+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. */++#ifndef EBCDIC++/* This is the "normal" table for ASCII systems or for EBCDIC systems running+in UTF-8 mode. */++static const short int escapes[] = {+ 0, 0,+ 0, 0,+ 0, 0,+ 0, 0,+ 0, 0,+ CHAR_COLON, CHAR_SEMICOLON,+ CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN,+ CHAR_GREATER_THAN_SIGN, CHAR_QUESTION_MARK,+ CHAR_COMMERCIAL_AT, -ESC_A,+ -ESC_B, -ESC_C,+ -ESC_D, -ESC_E,+ 0, -ESC_G,+ -ESC_H, 0,+ 0, -ESC_K,+ 0, 0,+ -ESC_N, 0,+ -ESC_P, -ESC_Q,+ -ESC_R, -ESC_S,+ 0, 0,+ -ESC_V, -ESC_W,+ -ESC_X, 0,+ -ESC_Z, CHAR_LEFT_SQUARE_BRACKET,+ CHAR_BACKSLASH, CHAR_RIGHT_SQUARE_BRACKET,+ CHAR_CIRCUMFLEX_ACCENT, CHAR_UNDERSCORE,+ CHAR_GRAVE_ACCENT, ESC_a,+ -ESC_b, 0,+ -ESC_d, ESC_e,+ ESC_f, 0,+ -ESC_h, 0,+ 0, -ESC_k,+ 0, 0,+ ESC_n, 0,+ -ESC_p, 0,+ ESC_r, -ESC_s,+ ESC_tee, 0,+ -ESC_v, -ESC_w,+ 0, 0,+ -ESC_z+};++#else++/* This is the "abnormal" table for EBCDIC systems without UTF-8 support. */++static const short int escapes[] = {+/* 48 */ 0, 0, 0, '.', '<', '(', '+', '|',+/* 50 */ '&', 0, 0, 0, 0, 0, 0, 0,+/* 58 */ 0, 0, '!', '$', '*', ')', ';', '~',+/* 60 */ '-', '/', 0, 0, 0, 0, 0, 0,+/* 68 */ 0, 0, '|', ',', '%', '_', '>', '?',+/* 70 */ 0, 0, 0, 0, 0, 0, 0, 0,+/* 78 */ 0, '`', ':', '#', '@', '\'', '=', '"',+/* 80 */ 0, ESC_a, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0,+/* 88 */-ESC_h, 0, 0, '{', 0, 0, 0, 0,+/* 90 */ 0, 0, -ESC_k, 0, 0, ESC_n, 0, -ESC_p,+/* 98 */ 0, ESC_r, 0, '}', 0, 0, 0, 0,+/* A0 */ 0, '~', -ESC_s, ESC_tee, 0,-ESC_v, -ESC_w, 0,+/* A8 */ 0,-ESC_z, 0, 0, 0, '[', 0, 0,+/* B0 */ 0, 0, 0, 0, 0, 0, 0, 0,+/* B8 */ 0, 0, 0, 0, 0, ']', '=', '-',+/* C0 */ '{',-ESC_A, -ESC_B, -ESC_C, -ESC_D,-ESC_E, 0, -ESC_G,+/* C8 */-ESC_H, 0, 0, 0, 0, 0, 0, 0,+/* D0 */ '}', 0, -ESC_K, 0, 0,-ESC_N, 0, -ESC_P,+/* D8 */-ESC_Q,-ESC_R, 0, 0, 0, 0, 0, 0,+/* E0 */ '\\', 0, -ESC_S, 0, 0,-ESC_V, -ESC_W, -ESC_X,+/* E8 */ 0,-ESC_Z, 0, 0, 0, 0, 0, 0,+/* F0 */ 0, 0, 0, 0, 0, 0, 0, 0,+/* F8 */ 0, 0, 0, 0, 0, 0, 0, 0+};++/* We also need a table of characters that may follow \c in an EBCDIC+environment for characters 0-31. */++static unsigned char ebcdic_escape_c[] = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";++#endif+++/* Table of special "verbs" like (*PRUNE). This is a short table, so it is+searched linearly. Put all the names into a single string, in order to reduce+the number of relocations when a shared library is dynamically linked. The+string is built from string macros so that it works in UTF-8 mode on EBCDIC+platforms. */++typedef struct verbitem {+ int len; /* Length of verb name */+ int op; /* Op when no arg, or -1 if arg mandatory */+ int op_arg; /* Op when arg present, or -1 if not allowed */+} verbitem;++static const char verbnames[] =+ "\0" /* Empty name is a shorthand for MARK */+ STRING_MARK0+ STRING_ACCEPT0+ STRING_COMMIT0+ STRING_F0+ STRING_FAIL0+ STRING_PRUNE0+ STRING_SKIP0+ STRING_THEN;++static const verbitem verbs[] = {+ { 0, -1, OP_MARK },+ { 4, -1, OP_MARK },+ { 6, OP_ACCEPT, -1 },+ { 6, OP_COMMIT, -1 },+ { 1, OP_FAIL, -1 },+ { 4, OP_FAIL, -1 },+ { 5, OP_PRUNE, OP_PRUNE_ARG },+ { 4, OP_SKIP, OP_SKIP_ARG },+ { 4, OP_THEN, OP_THEN_ARG }+};++static const int verbcount = sizeof(verbs)/sizeof(verbitem);+++/* Substitutes for [[:<:]] and [[:>:]], which mean start and end of word in+another regex library. */++static const pcre_uchar sub_start_of_word[] = {+ CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,+ CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w, CHAR_RIGHT_PARENTHESIS, '\0' };++static const pcre_uchar sub_end_of_word[] = {+ CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,+ CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w,+ CHAR_RIGHT_PARENTHESIS, '\0' };+++/* Tables of names of POSIX character classes and their lengths. The names are+now all in a single string, to reduce the number of relocations when a shared+library is dynamically loaded. The list of lengths is terminated by a zero+length entry. The first three must be alpha, lower, upper, as this is assumed+for handling case independence. The indices for graph, print, and punct are+needed, so identify them. */++static const char posix_names[] =+ STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0+ STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0+ STRING_graph0 STRING_print0 STRING_punct0 STRING_space0+ STRING_word0 STRING_xdigit;++static const pcre_uint8 posix_name_lengths[] = {+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };++#define PC_GRAPH 8+#define PC_PRINT 9+#define PC_PUNCT 10+++/* Table of class bit maps for each POSIX class. Each class is formed from a+base map, with an optional addition or removal of another map. Then, for some+classes, there is some additional tweaking: for [:blank:] the vertical space+characters are removed, and for [:alpha:] and [:alnum:] the underscore+character is removed. The triples in the table consist of the base map offset,+second map offset or -1 if no second map, and a non-negative value for map+addition or a negative value for map subtraction (if there are two maps). The+absolute value of the third field has these meanings: 0 => no tweaking, 1 =>+remove vertical space characters, 2 => remove underscore. */++static const int posix_class_maps[] = {+ cbit_word, cbit_digit, -2, /* alpha */+ cbit_lower, -1, 0, /* lower */+ cbit_upper, -1, 0, /* upper */+ cbit_word, -1, 2, /* alnum - word without underscore */+ cbit_print, cbit_cntrl, 0, /* ascii */+ cbit_space, -1, 1, /* blank - a GNU extension */+ cbit_cntrl, -1, 0, /* cntrl */+ cbit_digit, -1, 0, /* digit */+ cbit_graph, -1, 0, /* graph */+ cbit_print, -1, 0, /* print */+ cbit_punct, -1, 0, /* punct */+ cbit_space, -1, 0, /* space */+ cbit_word, -1, 0, /* word - a Perl extension */+ cbit_xdigit,-1, 0 /* xdigit */+};++/* Table of substitutes for \d etc when PCRE_UCP is set. They are replaced by+Unicode property escapes. */++#ifdef SUPPORT_UCP+static const pcre_uchar string_PNd[] = {+ CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,+ CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_pNd[] = {+ CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,+ CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_PXsp[] = {+ CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,+ CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_pXsp[] = {+ CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,+ CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_PXwd[] = {+ CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,+ CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_pXwd[] = {+ CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,+ CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };++static const pcre_uchar *substitutes[] = {+ string_PNd, /* \D */+ string_pNd, /* \d */+ string_PXsp, /* \S */ /* Xsp is Perl space, but from 8.34, Perl */+ string_pXsp, /* \s */ /* space and POSIX space are the same. */+ string_PXwd, /* \W */+ string_pXwd /* \w */+};++/* The POSIX class substitutes must be in the order of the POSIX class names,+defined above, and there are both positive and negative cases. NULL means no+general substitute of a Unicode property escape (\p or \P). However, for some+POSIX classes (e.g. graph, print, punct) a special property code is compiled+directly. */++static const pcre_uchar string_pL[] = {+ CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,+ CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_pLl[] = {+ CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,+ CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_pLu[] = {+ CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,+ CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_pXan[] = {+ CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,+ CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_h[] = {+ CHAR_BACKSLASH, CHAR_h, '\0' };+static const pcre_uchar string_pXps[] = {+ CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,+ CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_PL[] = {+ CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,+ CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_PLl[] = {+ CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,+ CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_PLu[] = {+ CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,+ CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_PXan[] = {+ CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,+ CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };+static const pcre_uchar string_H[] = {+ CHAR_BACKSLASH, CHAR_H, '\0' };+static const pcre_uchar string_PXps[] = {+ CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,+ CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };++static const pcre_uchar *posix_substitutes[] = {+ string_pL, /* alpha */+ string_pLl, /* lower */+ string_pLu, /* upper */+ string_pXan, /* alnum */+ NULL, /* ascii */+ string_h, /* blank */+ NULL, /* cntrl */+ string_pNd, /* digit */+ NULL, /* graph */+ NULL, /* print */+ NULL, /* punct */+ string_pXps, /* space */ /* Xps is POSIX space, but from 8.34 */+ string_pXwd, /* word */ /* Perl and POSIX space are the same */+ NULL, /* xdigit */+ /* Negated cases */+ string_PL, /* ^alpha */+ string_PLl, /* ^lower */+ string_PLu, /* ^upper */+ string_PXan, /* ^alnum */+ NULL, /* ^ascii */+ string_H, /* ^blank */+ NULL, /* ^cntrl */+ string_PNd, /* ^digit */+ NULL, /* ^graph */+ NULL, /* ^print */+ NULL, /* ^punct */+ string_PXps, /* ^space */ /* Xps is POSIX space, but from 8.34 */+ string_PXwd, /* ^word */ /* Perl and POSIX space are the same */+ NULL /* ^xdigit */+};+#define POSIX_SUBSIZE (sizeof(posix_substitutes) / sizeof(pcre_uchar *))+#endif++#define STRING(a) # a+#define XSTRING(s) STRING(s)++/* The texts of compile-time error messages. These are "char *" because they+are passed to the outside world. Do not ever re-use any error number, because+they are documented. Always add a new error instead. Messages marked DEAD below+are no longer used. This used to be a table of strings, but in order to reduce+the number of relocations needed when a shared library is loaded dynamically,+it is now one long string. We cannot use a table of offsets, because the+lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we+simply count through to the one we want - this isn't a performance issue+because these strings are used only when there is a compilation error.++Each substring ends with \0 to insert a null character. This includes the final+substring, so that the whole string ends with \0\0, which can be detected when+counting through. */++static const char error_texts[] =+ "no error\0"+ "\\ at end of pattern\0"+ "\\c at end of pattern\0"+ "unrecognized character follows \\\0"+ "numbers out of order in {} quantifier\0"+ /* 5 */+ "number too big in {} quantifier\0"+ "missing terminating ] for character class\0"+ "invalid escape sequence in character class\0"+ "range out of order in character class\0"+ "nothing to repeat\0"+ /* 10 */+ "internal error: invalid forward reference offset\0"+ "internal error: unexpected repeat\0"+ "unrecognized character after (? or (?-\0"+ "POSIX named classes are supported only within a class\0"+ "missing )\0"+ /* 15 */+ "reference to non-existent subpattern\0"+ "erroffset passed as NULL\0"+ "unknown option bit(s) set\0"+ "missing ) after comment\0"+ "parentheses nested too deeply\0" /** DEAD **/+ /* 20 */+ "regular expression is too large\0"+ "failed to get memory\0"+ "unmatched parentheses\0"+ "internal error: code overflow\0"+ "unrecognized character after (?<\0"+ /* 25 */+ "lookbehind assertion is not fixed length\0"+ "malformed number or name after (?(\0"+ "conditional group contains more than two branches\0"+ "assertion expected after (?( or (?(?C)\0"+ "(?R or (?[+-]digits must be followed by )\0"+ /* 30 */+ "unknown POSIX class name\0"+ "POSIX collating elements are not supported\0"+ "this version of PCRE is compiled without UTF support\0"+ "spare error\0" /** DEAD **/+ "character value in \\x{} or \\o{} is too large\0"+ /* 35 */+ "invalid condition (?(0)\0"+ "\\C not allowed in lookbehind assertion\0"+ "PCRE does not support \\L, \\l, \\N{name}, \\U, or \\u\0"+ "number after (?C is > 255\0"+ "closing ) for (?C expected\0"+ /* 40 */+ "recursive call could loop indefinitely\0"+ "unrecognized character after (?P\0"+ "syntax error in subpattern name (missing terminator)\0"+ "two named subpatterns have the same name\0"+ "invalid UTF-8 string\0"+ /* 45 */+ "support for \\P, \\p, and \\X has not been compiled\0"+ "malformed \\P or \\p sequence\0"+ "unknown property name after \\P or \\p\0"+ "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)\0"+ "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")\0"+ /* 50 */+ "repeated subpattern is too long\0" /** DEAD **/+ "octal value is greater than \\377 in 8-bit non-UTF-8 mode\0"+ "internal error: overran compiling workspace\0"+ "internal error: previously-checked referenced subpattern not found\0"+ "DEFINE group contains more than one branch\0"+ /* 55 */+ "repeating a DEFINE group is not allowed\0" /** DEAD **/+ "inconsistent NEWLINE options\0"+ "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"+ "a numbered reference must not be zero\0"+ "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0"+ /* 60 */+ "(*VERB) not recognized or malformed\0"+ "number is too big\0"+ "subpattern name expected\0"+ "digit expected after (?+\0"+ "] is an invalid data character in JavaScript compatibility mode\0"+ /* 65 */+ "different names for subpatterns of the same number are not allowed\0"+ "(*MARK) must have an argument\0"+ "this version of PCRE is not compiled with Unicode property support\0"+#ifndef EBCDIC+ "\\c must be followed by an ASCII character\0"+#else+ "\\c must be followed by a letter or one of [\\]^_?\0"+#endif+ "\\k is not followed by a braced, angle-bracketed, or quoted name\0"+ /* 70 */+ "internal error: unknown opcode in find_fixedlength()\0"+ "\\N is not supported in a class\0"+ "too many forward references\0"+ "disallowed Unicode code point (>= 0xd800 && <= 0xdfff)\0"+ "invalid UTF-16 string\0"+ /* 75 */+ "name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)\0"+ "character value in \\u.... sequence is too large\0"+ "invalid UTF-32 string\0"+ "setting UTF is disabled by the application\0"+ "non-hex character in \\x{} (closing brace missing?)\0"+ /* 80 */+ "non-octal character in \\o{} (closing brace missing?)\0"+ "missing opening brace after \\o\0"+ "parentheses are too deeply nested\0"+ "invalid range in character class\0"+ "group name must start with a non-digit\0"+ /* 85 */+ "parentheses are too deeply nested (stack check)\0"+ "digits missing in \\x{} or \\o{}\0"+ "regular expression is too complicated\0"+ ;++/* Table to identify digits and 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+a private table here. It costs 256 bytes, but it is a lot faster than doing+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:++ 0x04 decimal digit+ 0x08 hexadecimal digit++Then we can use ctype_digit and ctype_xdigit in the code. */++/* Using a simple comparison for decimal numbers rather than a memory read+is much faster, and the resulting code is simpler (the compiler turns it+into a subtraction and unsigned comparison). */++#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9)++#ifndef EBCDIC++/* This is the "normal" case, for ASCII systems, and EBCDIC systems running in+UTF-8 mode. */++static const pcre_uint8 digitab[] =+ {+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - ' */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ( - / */+ 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 */+ 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /* 8 - ? */+ 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* @ - G */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H - O */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* P - W */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* X - _ */+ 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* ` - g */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h - o */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* p - w */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* x -127 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */++#else++/* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */++static const pcre_uint8 digitab[] =+ {+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0- 7 0 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8- 15 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 16- 23 10 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 32- 39 20 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 30 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 40 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 72- | */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 50 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 88- 95 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 60 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ? */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */+ 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g 80 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p 90 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x A0 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 B0 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */+ 0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* { - G C0 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* } - P D0 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* \ - X E0 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */+ 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /* 0 - 7 F0 */+ 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */++static const pcre_uint8 ebcdic_chartab[] = { /* chartable partial dup */+ 0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 0- 7 */+ 0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /* 8- 15 */+ 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 16- 23 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 24- 31 */+ 0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /* 32- 39 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 40- 47 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 48- 55 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 56- 63 */+ 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - 71 */+ 0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /* 72- | */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* & - 87 */+ 0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /* 88- 95 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - -103 */+ 0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ? */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- " */+ 0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g */+ 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* h -143 */+ 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p */+ 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* q -159 */+ 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x */+ 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* y -175 */+ 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ -183 */+ 0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */+ 0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* { - G */+ 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* H -207 */+ 0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* } - P */+ 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Q -223 */+ 0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* \ - X */+ 0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /* Y -239 */+ 0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /* 0 - 7 */+ 0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/* 8 -255 */+#endif+++/* This table is used to check whether auto-possessification is possible+between adjacent character-type opcodes. The left-hand (repeated) opcode is+used to select the row, and the right-hand opcode is use to select the column.+A value of 1 means that auto-possessification is OK. For example, the second+value in the first row means that \D+\d can be turned into \D++\d.++The Unicode property types (\P and \p) have to be present to fill out the table+because of what their opcode values are, but the table values should always be+zero because property types are handled separately in the code. The last four+columns apply to items that cannot be repeated, so there is no need to have+rows for them. Note that OP_DIGIT etc. are generated only when PCRE_UCP is+*not* set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */++#define APTROWS (LAST_AUTOTAB_LEFT_OP - FIRST_AUTOTAB_OP + 1)+#define APTCOLS (LAST_AUTOTAB_RIGHT_OP - FIRST_AUTOTAB_OP + 1)++static const pcre_uint8 autoposstab[APTROWS][APTCOLS] = {+/* \D \d \S \s \W \w . .+ \C \P \p \R \H \h \V \v \X \Z \z $ $M */+ { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \D */+ { 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \d */+ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \S */+ { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \s */+ { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \W */+ { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 }, /* \w */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* . */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* .+ */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, /* \C */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* \P */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* \p */+ { 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }, /* \R */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }, /* \H */+ { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0 }, /* \h */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0 }, /* \V */+ { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0 }, /* \v */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 } /* \X */+};+++/* This table is used to check whether auto-possessification is possible+between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP). The+left-hand (repeated) opcode is used to select the row, and the right-hand+opcode is used to select the column. The values are as follows:++ 0 Always return FALSE (never auto-possessify)+ 1 Character groups are distinct (possessify if both are OP_PROP)+ 2 Check character categories in the same group (general or particular)+ 3 TRUE if the two opcodes are not the same (PROP vs NOTPROP)++ 4 Check left general category vs right particular category+ 5 Check right general category vs left particular category++ 6 Left alphanum vs right general category+ 7 Left space vs right general category+ 8 Left word vs right general category++ 9 Right alphanum vs left general category+ 10 Right space vs left general category+ 11 Right word vs left general category++ 12 Left alphanum vs right particular category+ 13 Left space vs right particular category+ 14 Left word vs right particular category++ 15 Right alphanum vs left particular category+ 16 Right space vs left particular category+ 17 Right word vs left particular category+*/++static const pcre_uint8 propposstab[PT_TABSIZE][PT_TABSIZE] = {+/* ANY LAMP GC PC SC ALNUM SPACE PXSPACE WORD CLIST UCNC */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* PT_ANY */+ { 0, 3, 0, 0, 0, 3, 1, 1, 0, 0, 0 }, /* PT_LAMP */+ { 0, 0, 2, 4, 0, 9, 10, 10, 11, 0, 0 }, /* PT_GC */+ { 0, 0, 5, 2, 0, 15, 16, 16, 17, 0, 0 }, /* PT_PC */+ { 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0 }, /* PT_SC */+ { 0, 3, 6, 12, 0, 3, 1, 1, 0, 0, 0 }, /* PT_ALNUM */+ { 0, 1, 7, 13, 0, 1, 3, 3, 1, 0, 0 }, /* PT_SPACE */+ { 0, 1, 7, 13, 0, 1, 3, 3, 1, 0, 0 }, /* PT_PXSPACE */+ { 0, 0, 8, 14, 0, 0, 1, 1, 3, 0, 0 }, /* PT_WORD */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* PT_CLIST */+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3 } /* PT_UCNC */+};++/* This table is used to check whether auto-possessification is possible+between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP) when one+specifies a general category and the other specifies a particular category. The+row is selected by the general category and the column by the particular+category. The value is 1 if the particular category is not part of the general+category. */++static const pcre_uint8 catposstab[7][30] = {+/* Cc Cf Cn Co Cs Ll Lm Lo Lt Lu Mc Me Mn Nd Nl No Pc Pd Pe Pf Pi Po Ps Sc Sk Sm So Zl Zp Zs */+ { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* C */+ { 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* L */+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* M */+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, /* N */+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 }, /* P */+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 }, /* S */+ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 } /* Z */+};++/* This table is used when checking ALNUM, (PX)SPACE, SPACE, and WORD against+a general or particular category. The properties in each row are those+that apply to the character set in question. Duplication means that a little+unnecessary work is done when checking, but this keeps things much simpler+because they can all use the same code. For more details see the comment where+this table is used.++Note: SPACE and PXSPACE used to be different because Perl excluded VT from+"space", but from Perl 5.18 it's included, so both categories are treated the+same here. */++static const pcre_uint8 posspropstab[3][4] = {+ { ucp_L, ucp_N, ucp_N, ucp_Nl }, /* ALNUM, 3rd and 4th values redundant */+ { ucp_Z, ucp_Z, ucp_C, ucp_Cc }, /* SPACE and PXSPACE, 2nd value redundant */+ { ucp_L, ucp_N, ucp_P, ucp_Po } /* WORD */+};++/* This table is used when converting repeating opcodes into possessified+versions as a result of an explicit possessive quantifier such as ++. A zero+value means there is no possessified version - in those cases the item in+question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT+because all relevant opcodes are less than that. */++static const pcre_uint8 opcode_possessify[] = {+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 15 */+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16 - 31 */++ 0, /* NOTI */+ OP_POSSTAR, 0, /* STAR, MINSTAR */+ OP_POSPLUS, 0, /* PLUS, MINPLUS */+ OP_POSQUERY, 0, /* QUERY, MINQUERY */+ OP_POSUPTO, 0, /* UPTO, MINUPTO */+ 0, /* EXACT */+ 0, 0, 0, 0, /* POS{STAR,PLUS,QUERY,UPTO} */++ OP_POSSTARI, 0, /* STARI, MINSTARI */+ OP_POSPLUSI, 0, /* PLUSI, MINPLUSI */+ OP_POSQUERYI, 0, /* QUERYI, MINQUERYI */+ OP_POSUPTOI, 0, /* UPTOI, MINUPTOI */+ 0, /* EXACTI */+ 0, 0, 0, 0, /* POS{STARI,PLUSI,QUERYI,UPTOI} */++ OP_NOTPOSSTAR, 0, /* NOTSTAR, NOTMINSTAR */+ OP_NOTPOSPLUS, 0, /* NOTPLUS, NOTMINPLUS */+ OP_NOTPOSQUERY, 0, /* NOTQUERY, NOTMINQUERY */+ OP_NOTPOSUPTO, 0, /* NOTUPTO, NOTMINUPTO */+ 0, /* NOTEXACT */+ 0, 0, 0, 0, /* NOTPOS{STAR,PLUS,QUERY,UPTO} */++ OP_NOTPOSSTARI, 0, /* NOTSTARI, NOTMINSTARI */+ OP_NOTPOSPLUSI, 0, /* NOTPLUSI, NOTMINPLUSI */+ OP_NOTPOSQUERYI, 0, /* NOTQUERYI, NOTMINQUERYI */+ OP_NOTPOSUPTOI, 0, /* NOTUPTOI, NOTMINUPTOI */+ 0, /* NOTEXACTI */+ 0, 0, 0, 0, /* NOTPOS{STARI,PLUSI,QUERYI,UPTOI} */++ OP_TYPEPOSSTAR, 0, /* TYPESTAR, TYPEMINSTAR */+ OP_TYPEPOSPLUS, 0, /* TYPEPLUS, TYPEMINPLUS */+ OP_TYPEPOSQUERY, 0, /* TYPEQUERY, TYPEMINQUERY */+ OP_TYPEPOSUPTO, 0, /* TYPEUPTO, TYPEMINUPTO */+ 0, /* TYPEEXACT */+ 0, 0, 0, 0, /* TYPEPOS{STAR,PLUS,QUERY,UPTO} */++ OP_CRPOSSTAR, 0, /* CRSTAR, CRMINSTAR */+ OP_CRPOSPLUS, 0, /* CRPLUS, CRMINPLUS */+ OP_CRPOSQUERY, 0, /* CRQUERY, CRMINQUERY */+ OP_CRPOSRANGE, 0, /* CRRANGE, CRMINRANGE */+ 0, 0, 0, 0, /* CRPOS{STAR,PLUS,QUERY,RANGE} */++ 0, 0, 0, /* CLASS, NCLASS, XCLASS */+ 0, 0, /* REF, REFI */+ 0, 0, /* DNREF, DNREFI */+ 0, 0 /* RECURSE, CALLOUT */+};++++/*************************************************+* Find an error text *+*************************************************/++/* The error texts are now all in one long string, to save on relocations. As+some of the text is of unknown length, we can't use a table of offsets.+Instead, just count through the strings. This is not a performance issue+because it happens only when there has been a compilation error.++Argument: the error number+Returns: pointer to the error string+*/++static const char *+find_error_text(int n)+{+const char *s = error_texts;+for (; n > 0; n--)+ {+ while (*s++ != CHAR_NULL) {};+ if (*s == CHAR_NULL) return "Error text not found (please report)";+ }+return s;+}++++/*************************************************+* Expand the workspace *+*************************************************/++/* This function is called during the second compiling phase, if the number of+forward references fills the existing workspace, which is originally a block on+the stack. A larger block is obtained from malloc() unless the ultimate limit+has been reached or the increase will be rather small.++Argument: pointer to the compile data block+Returns: 0 if all went well, else an error number+*/++static int+expand_workspace(compile_data *cd)+{+pcre_uchar *newspace;+int newsize = cd->workspace_size * 2;++if (newsize > COMPILE_WORK_SIZE_MAX) newsize = COMPILE_WORK_SIZE_MAX;+if (cd->workspace_size >= COMPILE_WORK_SIZE_MAX ||+ newsize - cd->workspace_size < WORK_SIZE_SAFETY_MARGIN)+ return ERR72;++newspace = (PUBL(malloc))(IN_UCHARS(newsize));+if (newspace == NULL) return ERR21;+memcpy(newspace, cd->start_workspace, cd->workspace_size * sizeof(pcre_uchar));+cd->hwm = (pcre_uchar *)newspace + (cd->hwm - cd->start_workspace);+if (cd->workspace_size > COMPILE_WORK_SIZE)+ (PUBL(free))((void *)cd->start_workspace);+cd->start_workspace = newspace;+cd->workspace_size = newsize;+return 0;+}++++/*************************************************+* Check for counted repeat *+*************************************************/++/* This function is called when a '{' is encountered in a place where it might+start a quantifier. It looks ahead to see if it really is a quantifier or not.+It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}+where the ddds are digits.++Arguments:+ p pointer to the first char after '{'++Returns: TRUE or FALSE+*/++static BOOL+is_counted_repeat(const pcre_uchar *p)+{+if (!IS_DIGIT(*p)) return FALSE;+p++;+while (IS_DIGIT(*p)) p++;+if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;++if (*p++ != CHAR_COMMA) return FALSE;+if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;++if (!IS_DIGIT(*p)) return FALSE;+p++;+while (IS_DIGIT(*p)) p++;++return (*p == CHAR_RIGHT_CURLY_BRACKET);+}++++/*************************************************+* Handle escapes *+*************************************************/++/* This function is called when a \ has been encountered. It either returns a+positive value for a simple escape such as \n, or 0 for a data character which+will be placed in chptr. A backreference to group n is returned as negative n.+When UTF-8 is enabled, a positive value greater than 255 may be returned in+chptr. On entry, ptr is pointing at the \. On exit, it is on the final+character of the escape sequence.++Arguments:+ ptrptr points to the pattern position pointer+ chptr points to a returned data character+ errorcodeptr points to the errorcode variable+ bracount number of previous extracting brackets+ options the options bits+ isclass TRUE if inside a character class++Returns: zero => a data character+ positive => a special escape sequence+ negative => a back reference+ on error, errorcodeptr is set+*/++static int+check_escape(const pcre_uchar **ptrptr, pcre_uint32 *chptr, int *errorcodeptr,+ int bracount, int options, BOOL isclass)+{+/* PCRE_UTF16 has the same value as PCRE_UTF8. */+BOOL utf = (options & PCRE_UTF8) != 0;+const pcre_uchar *ptr = *ptrptr + 1;+pcre_uint32 c;+int escape = 0;+int i;++GETCHARINCTEST(c, ptr); /* Get character value, increment pointer */+ptr--; /* Set pointer back to the last byte */++/* If backslash is at the end of the pattern, it's an error. */++if (c == CHAR_NULL) *errorcodeptr = ERR1;++/* Non-alphanumerics 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. */++#ifndef EBCDIC /* ASCII/UTF-8 coding */+/* Not alphanumeric */+else if (c < CHAR_0 || c > CHAR_z) {}+else if ((i = escapes[c - CHAR_0]) != 0)+ { if (i > 0) c = (pcre_uint32)i; else escape = -i; }++#else /* EBCDIC coding */+/* Not alphanumeric */+else if (c < CHAR_a || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}+else if ((i = escapes[c - 0x48]) != 0) { if (i > 0) c = (pcre_uint32)i; else escape = -i; }+#endif++/* Escapes that need further processing, or are illegal. */++else+ {+ const pcre_uchar *oldptr;+ BOOL braced, negated, overflow;+ int s;++ switch (c)+ {+ /* A number of Perl escapes are not handled by PCRE. We give an explicit+ error. */++ case CHAR_l:+ case CHAR_L:+ *errorcodeptr = ERR37;+ break;++ case CHAR_u:+ if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)+ {+ /* In JavaScript, \u must be followed by four hexadecimal numbers.+ Otherwise it is a lowercase u letter. */+ if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0+ && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0+ && MAX_255(ptr[3]) && (digitab[ptr[3]] & ctype_xdigit) != 0+ && MAX_255(ptr[4]) && (digitab[ptr[4]] & ctype_xdigit) != 0)+ {+ c = 0;+ for (i = 0; i < 4; ++i)+ {+ register pcre_uint32 cc = *(++ptr);+#ifndef EBCDIC /* ASCII/UTF-8 coding */+ if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */+ c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));+#else /* EBCDIC coding */+ if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */+ c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));+#endif+ }++#if defined COMPILE_PCRE8+ if (c > (utf ? 0x10ffffU : 0xffU))+#elif defined COMPILE_PCRE16+ if (c > (utf ? 0x10ffffU : 0xffffU))+#elif defined COMPILE_PCRE32+ if (utf && c > 0x10ffffU)+#endif+ {+ *errorcodeptr = ERR76;+ }+ else if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;+ }+ }+ else+ *errorcodeptr = ERR37;+ break;++ case CHAR_U:+ /* In JavaScript, \U is an uppercase U letter. */+ if ((options & PCRE_JAVASCRIPT_COMPAT) == 0) *errorcodeptr = ERR37;+ break;++ /* In a character class, \g is just a literal "g". Outside a character+ class, \g must be followed by one of a number of specific things:++ (1) A number, either plain or braced. If positive, it is an absolute+ backreference. If negative, it is a relative backreference. This is a Perl+ 5.10 feature.++ (2) Perl 5.10 also supports \g{name} as a reference to a named group. This+ is part of Perl's movement towards a unified syntax for back references. As+ this is synonymous with \k{name}, we fudge it up by pretending it really+ was \k.++ (3) For Oniguruma compatibility we also support \g followed by a name or a+ number either in angle brackets or in single quotes. However, these are+ (possibly recursive) subroutine calls, _not_ backreferences. Just return+ the ESC_g code (cf \k). */++ case CHAR_g:+ if (isclass) break;+ if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)+ {+ escape = ESC_g;+ break;+ }++ /* Handle the Perl-compatible cases */++ if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)+ {+ const pcre_uchar *p;+ for (p = ptr+2; *p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET; p++)+ if (*p != CHAR_MINUS && !IS_DIGIT(*p)) break;+ if (*p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET)+ {+ escape = ESC_k;+ break;+ }+ braced = TRUE;+ ptr++;+ }+ else braced = FALSE;++ if (ptr[1] == CHAR_MINUS)+ {+ negated = TRUE;+ ptr++;+ }+ else negated = FALSE;++ /* The integer range is limited by the machine's int representation. */+ s = 0;+ overflow = FALSE;+ while (IS_DIGIT(ptr[1]))+ {+ if (s > INT_MAX / 10 - 1) /* Integer overflow */+ {+ overflow = TRUE;+ break;+ }+ s = s * 10 + (int)(*(++ptr) - CHAR_0);+ }+ if (overflow) /* Integer overflow */+ {+ while (IS_DIGIT(ptr[1]))+ ptr++;+ *errorcodeptr = ERR61;+ break;+ }++ if (braced && *(++ptr) != CHAR_RIGHT_CURLY_BRACKET)+ {+ *errorcodeptr = ERR57;+ break;+ }++ if (s == 0)+ {+ *errorcodeptr = ERR58;+ break;+ }++ if (negated)+ {+ if (s > bracount)+ {+ *errorcodeptr = ERR15;+ break;+ }+ s = bracount - (s - 1);+ }++ escape = -s;+ break;++ /* The handling of escape sequences consisting of a string of digits+ starting with one that is not zero is not straightforward. Perl has changed+ over the years. Nowadays \g{} for backreferences and \o{} for octal are+ recommended to avoid the ambiguities in the old syntax.++ Outside a character class, the digits are read as a decimal number. If the+ number is less than 8 (used to be 10), or if there are that many previous+ extracting left brackets, then it is a back reference. Otherwise, up to+ three octal digits are read to form an escaped byte. Thus \123 is likely to+ be octal 123 (cf \0123, which is octal 012 followed by the literal 3). If+ the octal value is greater than 377, the least significant 8 bits are+ taken. \8 and \9 are treated as the literal characters 8 and 9.++ Inside a character class, \ followed by a digit is always either a literal+ 8 or 9 or an octal number. */++ case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:+ case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:++ if (!isclass)+ {+ oldptr = ptr;+ /* The integer range is limited by the machine's int representation. */+ s = (int)(c -CHAR_0);+ overflow = FALSE;+ while (IS_DIGIT(ptr[1]))+ {+ if (s > INT_MAX / 10 - 1) /* Integer overflow */+ {+ overflow = TRUE;+ break;+ }+ s = s * 10 + (int)(*(++ptr) - CHAR_0);+ }+ if (overflow) /* Integer overflow */+ {+ while (IS_DIGIT(ptr[1]))+ ptr++;+ *errorcodeptr = ERR61;+ break;+ }+ if (s < 8 || s <= bracount) /* Check for back reference */+ {+ escape = -s;+ break;+ }+ ptr = oldptr; /* Put the pointer back and fall through */+ }++ /* Handle a digit following \ when the number is not a back reference. If+ the first digit is 8 or 9, Perl used to generate a binary zero byte and+ then treat the digit as a following literal. At least by Perl 5.18 this+ changed so as not to insert the binary zero. */++ if ((c = *ptr) >= CHAR_8) break;++ /* Fall through with a digit less than 8 */++ /* \0 always starts an octal number, but we may drop through to here with a+ larger first octal digit. The original code used just to take the least+ significant 8 bits of octal numbers (I think this is what early Perls used+ to do). Nowadays we allow for larger numbers in UTF-8 mode and 16-bit mode,+ but no more than 3 octal digits. */++ case CHAR_0:+ c -= CHAR_0;+ while(i++ < 2 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)+ c = c * 8 + *(++ptr) - CHAR_0;+#ifdef COMPILE_PCRE8+ if (!utf && c > 0xff) *errorcodeptr = ERR51;+#endif+ break;++ /* \o is a relatively new Perl feature, supporting a more general way of+ specifying character codes in octal. The only supported form is \o{ddd}. */++ case CHAR_o:+ if (ptr[1] != CHAR_LEFT_CURLY_BRACKET) *errorcodeptr = ERR81; else+ if (ptr[2] == CHAR_RIGHT_CURLY_BRACKET) *errorcodeptr = ERR86; else+ {+ ptr += 2;+ c = 0;+ overflow = FALSE;+ while (*ptr >= CHAR_0 && *ptr <= CHAR_7)+ {+ register pcre_uint32 cc = *ptr++;+ if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */+#ifdef COMPILE_PCRE32+ if (c >= 0x20000000l) { overflow = TRUE; break; }+#endif+ c = (c << 3) + cc - CHAR_0 ;+#if defined COMPILE_PCRE8+ if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }+#elif defined COMPILE_PCRE16+ if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }+#elif defined COMPILE_PCRE32+ if (utf && c > 0x10ffffU) { overflow = TRUE; break; }+#endif+ }+ if (overflow)+ {+ while (*ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++;+ *errorcodeptr = ERR34;+ }+ else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)+ {+ if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;+ }+ else *errorcodeptr = ERR80;+ }+ break;++ /* \x is complicated. In JavaScript, \x must be followed by two hexadecimal+ numbers. Otherwise it is a lowercase x letter. */++ case CHAR_x:+ if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)+ {+ if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0+ && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0)+ {+ c = 0;+ for (i = 0; i < 2; ++i)+ {+ register pcre_uint32 cc = *(++ptr);+#ifndef EBCDIC /* ASCII/UTF-8 coding */+ if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */+ c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));+#else /* EBCDIC coding */+ if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */+ c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));+#endif+ }+ }+ } /* End JavaScript handling */++ /* Handle \x in Perl's style. \x{ddd} is a character number which can be+ greater than 0xff in utf or non-8bit mode, but only if the ddd are hex+ digits. If not, { used to be treated as a data character. However, Perl+ seems to read hex digits up to the first non-such, and ignore the rest, so+ that, for example \x{zz} matches a binary zero. This seems crazy, so PCRE+ now gives an error. */++ else+ {+ if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)+ {+ ptr += 2;+ if (*ptr == CHAR_RIGHT_CURLY_BRACKET)+ {+ *errorcodeptr = ERR86;+ break;+ }+ c = 0;+ overflow = FALSE;+ while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0)+ {+ register pcre_uint32 cc = *ptr++;+ if (c == 0 && cc == CHAR_0) continue; /* Leading zeroes */++#ifdef COMPILE_PCRE32+ if (c >= 0x10000000l) { overflow = TRUE; break; }+#endif++#ifndef EBCDIC /* ASCII/UTF-8 coding */+ if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */+ c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));+#else /* EBCDIC coding */+ if (cc >= CHAR_a && cc <= CHAR_z) cc += 64; /* Convert to upper case */+ c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));+#endif++#if defined COMPILE_PCRE8+ if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }+#elif defined COMPILE_PCRE16+ if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }+#elif defined COMPILE_PCRE32+ if (utf && c > 0x10ffffU) { overflow = TRUE; break; }+#endif+ }++ if (overflow)+ {+ while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0) ptr++;+ *errorcodeptr = ERR34;+ }++ else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)+ {+ if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;+ }++ /* If the sequence of hex digits does not end with '}', give an error.+ We used just to recognize this construct and fall through to the normal+ \x handling, but nowadays Perl gives an error, which seems much more+ sensible, so we do too. */++ else *errorcodeptr = ERR79;+ } /* End of \x{} processing */++ /* Read a single-byte hex-defined char (up to two hex digits after \x) */++ else+ {+ c = 0;+ while (i++ < 2 && MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0)+ {+ pcre_uint32 cc; /* Some compilers don't like */+ cc = *(++ptr); /* ++ in initializers */+#ifndef EBCDIC /* ASCII/UTF-8 coding */+ if (cc >= CHAR_a) cc -= 32; /* Convert to upper case */+ c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));+#else /* EBCDIC coding */+ if (cc <= CHAR_z) cc += 64; /* Convert to upper case */+ c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));+#endif+ }+ } /* End of \xdd handling */+ } /* End of Perl-style \x handling */+ break;++ /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.+ An error is given if the byte following \c is not an ASCII character. This+ coding is ASCII-specific, but then the whole concept of \cx is+ ASCII-specific. (However, an EBCDIC equivalent has now been added.) */++ case CHAR_c:+ c = *(++ptr);+ if (c == CHAR_NULL)+ {+ *errorcodeptr = ERR2;+ break;+ }+#ifndef EBCDIC /* ASCII/UTF-8 coding */+ if (c > 127) /* Excludes all non-ASCII in either mode */+ {+ *errorcodeptr = ERR68;+ break;+ }+ if (c >= CHAR_a && c <= CHAR_z) c -= 32;+ c ^= 0x40;+#else /* EBCDIC coding */+ if (c >= CHAR_a && c <= CHAR_z) c += 64;+ if (c == CHAR_QUESTION_MARK)+ c = ('\\' == 188 && '`' == 74)? 0x5f : 0xff;+ else+ {+ for (i = 0; i < 32; i++)+ {+ if (c == ebcdic_escape_c[i]) break;+ }+ if (i < 32) c = i; else *errorcodeptr = ERR68;+ }+#endif+ break;++ /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any+ other alphanumeric following \ is an error if PCRE_EXTRA was set;+ otherwise, for Perl compatibility, it is a literal. This code looks a bit+ odd, but there used to be some cases other than the default, and there may+ be again in future, so I haven't "optimized" it. */++ default:+ if ((options & PCRE_EXTRA) != 0) switch(c)+ {+ default:+ *errorcodeptr = ERR3;+ break;+ }+ break;+ }+ }++/* Perl supports \N{name} for character names, as well as plain \N for "not+newline". PCRE does not support \N{name}. However, it does support+quantification such as \N{2,3}. */++if (escape == ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&+ !is_counted_repeat(ptr+2))+ *errorcodeptr = ERR37;++/* If PCRE_UCP is set, we change the values for \d etc. */++if ((options & PCRE_UCP) != 0 && escape >= ESC_D && escape <= ESC_w)+ escape += (ESC_DU - ESC_D);++/* Set the pointer to the final character before returning. */++*ptrptr = ptr;+*chptr = c;+return escape;+}++++#ifdef SUPPORT_UCP+/*************************************************+* Handle \P and \p *+*************************************************/++/* This function is called after \P or \p has been encountered, provided that+PCRE is compiled with support for Unicode properties. On entry, ptrptr is+pointing at the P or p. On exit, it is pointing at the final character of the+escape sequence.++Argument:+ ptrptr points to the pattern position pointer+ negptr points to a boolean that is set TRUE for negation else FALSE+ ptypeptr points to an unsigned int that is set to the type value+ pdataptr points to an unsigned int that is set to the detailed property value+ errorcodeptr points to the error code variable++Returns: TRUE if the type value was found, or FALSE for an invalid type+*/++static BOOL+get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, unsigned int *ptypeptr,+ unsigned int *pdataptr, int *errorcodeptr)+{+pcre_uchar c;+int i, bot, top;+const pcre_uchar *ptr = *ptrptr;+pcre_uchar name[32];++c = *(++ptr);+if (c == CHAR_NULL) goto ERROR_RETURN;++*negptr = FALSE;++/* \P or \p can be followed by a name in {}, optionally preceded by ^ for+negation. */++if (c == CHAR_LEFT_CURLY_BRACKET)+ {+ if (ptr[1] == CHAR_CIRCUMFLEX_ACCENT)+ {+ *negptr = TRUE;+ ptr++;+ }+ for (i = 0; i < (int)(sizeof(name) / sizeof(pcre_uchar)) - 1; i++)+ {+ c = *(++ptr);+ if (c == CHAR_NULL) goto ERROR_RETURN;+ if (c == CHAR_RIGHT_CURLY_BRACKET) break;+ name[i] = c;+ }+ if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;+ name[i] = 0;+ }++/* Otherwise there is just one following character */++else+ {+ name[0] = c;+ name[1] = 0;+ }++*ptrptr = ptr;++/* Search for a recognized property name using binary chop */++bot = 0;+top = PRIV(utt_size);++while (bot < top)+ {+ int r;+ i = (bot + top) >> 1;+ r = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);+ if (r == 0)+ {+ *ptypeptr = PRIV(utt)[i].type;+ *pdataptr = PRIV(utt)[i].value;+ return TRUE;+ }+ if (r > 0) bot = i + 1; else top = i;+ }++*errorcodeptr = ERR47;+*ptrptr = ptr;+return FALSE;++ERROR_RETURN:+*errorcodeptr = ERR46;+*ptrptr = ptr;+return FALSE;+}+#endif++++/*************************************************+* Read repeat counts *+*************************************************/++/* Read an item of the form {n,m} and return the values. This is called only+after is_counted_repeat() has confirmed that a repeat-count quantifier exists,+so the syntax is guaranteed to be correct, but we need to check the values.++Arguments:+ p pointer to first char after '{'+ minp pointer to int for min+ maxp pointer to int for max+ returned as -1 if no max+ errorcodeptr points to error code variable++Returns: pointer to '}' on success;+ current ptr on error, with errorcodeptr set non-zero+*/++static const pcre_uchar *+read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, int *errorcodeptr)+{+int min = 0;+int max = -1;++while (IS_DIGIT(*p))+ {+ min = min * 10 + (int)(*p++ - CHAR_0);+ if (min > 65535)+ {+ *errorcodeptr = ERR5;+ return p;+ }+ }++if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else+ {+ if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)+ {+ max = 0;+ while(IS_DIGIT(*p))+ {+ max = max * 10 + (int)(*p++ - CHAR_0);+ if (max > 65535)+ {+ *errorcodeptr = ERR5;+ return p;+ }+ }+ if (max < min)+ {+ *errorcodeptr = ERR4;+ return p;+ }+ }+ }++*minp = min;+*maxp = max;+return p;+}++++/*************************************************+* Find first significant op code *+*************************************************/++/* This is called by several functions that scan a compiled expression looking+for a fixed first character, or an anchoring op code etc. It skips over things+that do not influence this. For some calls, it makes sense to skip negative+forward and all backward assertions, and also the \b assertion; for others it+does not.++Arguments:+ code pointer to the start of the group+ skipassert TRUE if certain assertions are to be skipped++Returns: pointer to the first significant opcode+*/++static const pcre_uchar*+first_significant_code(const pcre_uchar *code, BOOL skipassert)+{+for (;;)+ {+ switch ((int)*code)+ {+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ if (!skipassert) return code;+ do code += GET(code, 1); while (*code == OP_ALT);+ code += PRIV(OP_lengths)[*code];+ break;++ case OP_WORD_BOUNDARY:+ case OP_NOT_WORD_BOUNDARY:+ if (!skipassert) return code;+ /* Fall through */++ case OP_CALLOUT:+ case OP_CREF:+ case OP_DNCREF:+ case OP_RREF:+ case OP_DNRREF:+ case OP_DEF:+ code += PRIV(OP_lengths)[*code];+ break;++ default:+ return code;+ }+ }+/* Control never reaches here */+}++++/*************************************************+* Find the fixed length of a branch *+*************************************************/++/* Scan a branch and compute the fixed length of subject that will match it,+if the length is fixed. This is needed for dealing with backward assertions.+In UTF8 mode, the result is in characters rather than bytes. The branch is+temporarily terminated with OP_END when this function is called.++This function is called when a backward assertion is encountered, so that if it+fails, the error message can point to the correct place in the pattern.+However, we cannot do this when the assertion contains subroutine calls,+because they can be forward references. We solve this by remembering this case+and doing the check at the end; a flag specifies which mode we are running in.++Arguments:+ code points to the start of the pattern (the bracket)+ utf TRUE in UTF-8 / UTF-16 / UTF-32 mode+ atend TRUE if called when the pattern is complete+ cd the "compile data" structure+ recurses chain of recurse_check to catch mutual recursion++Returns: the fixed length,+ or -1 if there is no fixed length,+ or -2 if \C was encountered (in UTF-8 mode only)+ or -3 if an OP_RECURSE item was encountered and atend is FALSE+ or -4 if an unknown opcode was encountered (internal error)+*/++static int+find_fixedlength(pcre_uchar *code, BOOL utf, BOOL atend, compile_data *cd,+ recurse_check *recurses)+{+int length = -1;+recurse_check this_recurse;+register int branchlength = 0;+register pcre_uchar *cc = code + 1 + LINK_SIZE;++/* Scan along the opcodes for this branch. If we get to the end of the+branch, check the length against that of the other branches. */++for (;;)+ {+ int d;+ pcre_uchar *ce, *cs;+ register pcre_uchar op = *cc;++ switch (op)+ {+ /* We only need to continue for OP_CBRA (normal capturing bracket) and+ OP_BRA (normal non-capturing bracket) because the other variants of these+ opcodes are all concerned with unlimited repeated groups, which of course+ are not of fixed length. */++ case OP_CBRA:+ case OP_BRA:+ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_COND:+ d = find_fixedlength(cc + ((op == OP_CBRA)? IMM2_SIZE : 0), utf, atend, cd,+ recurses);+ if (d < 0) return d;+ branchlength += d;+ do cc += GET(cc, 1); while (*cc == OP_ALT);+ cc += 1 + LINK_SIZE;+ break;++ /* Reached end of a branch; if it's a ket it is the end of a nested call.+ If it's ALT it is an alternation in a nested call. An ACCEPT is effectively+ an ALT. If it is END it's the end of the outer call. All can be handled by+ the same code. Note that we must not include the OP_KETRxxx opcodes here,+ because they all imply an unlimited repeat. */++ case OP_ALT:+ case OP_KET:+ case OP_END:+ case OP_ACCEPT:+ case OP_ASSERT_ACCEPT:+ if (length < 0) length = branchlength;+ else if (length != branchlength) return -1;+ if (*cc != OP_ALT) return length;+ cc += 1 + LINK_SIZE;+ branchlength = 0;+ break;++ /* A true recursion implies not fixed length, but a subroutine call may+ be OK. If the subroutine is a forward reference, we can't deal with+ it until the end of the pattern, so return -3. */++ case OP_RECURSE:+ if (!atend) return -3;+ cs = ce = (pcre_uchar *)cd->start_code + GET(cc, 1); /* Start subpattern */+ do ce += GET(ce, 1); while (*ce == OP_ALT); /* End subpattern */+ if (cc > cs && cc < ce) return -1; /* Recursion */+ else /* Check for mutual recursion */+ {+ recurse_check *r = recurses;+ for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;+ if (r != NULL) return -1; /* Mutual recursion */+ }+ this_recurse.prev = recurses;+ this_recurse.group = cs;+ d = find_fixedlength(cs + IMM2_SIZE, utf, atend, cd, &this_recurse);+ if (d < 0) return d;+ branchlength += d;+ cc += 1 + LINK_SIZE;+ break;++ /* Skip over assertive subpatterns */++ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ do cc += GET(cc, 1); while (*cc == OP_ALT);+ cc += 1 + LINK_SIZE;+ break;++ /* Skip over things that don't match chars */++ case OP_MARK:+ case OP_PRUNE_ARG:+ case OP_SKIP_ARG:+ case OP_THEN_ARG:+ cc += cc[1] + PRIV(OP_lengths)[*cc];+ break;++ case OP_CALLOUT:+ case OP_CIRC:+ case OP_CIRCM:+ case OP_CLOSE:+ case OP_COMMIT:+ case OP_CREF:+ case OP_DEF:+ case OP_DNCREF:+ case OP_DNRREF:+ case OP_DOLL:+ case OP_DOLLM:+ case OP_EOD:+ case OP_EODN:+ case OP_FAIL:+ case OP_NOT_WORD_BOUNDARY:+ case OP_PRUNE:+ case OP_REVERSE:+ case OP_RREF:+ case OP_SET_SOM:+ case OP_SKIP:+ case OP_SOD:+ case OP_SOM:+ case OP_THEN:+ case OP_WORD_BOUNDARY:+ cc += PRIV(OP_lengths)[*cc];+ break;++ /* Handle literal characters */++ case OP_CHAR:+ case OP_CHARI:+ case OP_NOT:+ case OP_NOTI:+ branchlength++;+ cc += 2;+#ifdef SUPPORT_UTF+ if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ break;++ /* Handle exact repetitions. The count is already in characters, but we+ need to skip over a multibyte character in UTF8 mode. */++ case OP_EXACT:+ case OP_EXACTI:+ case OP_NOTEXACT:+ case OP_NOTEXACTI:+ branchlength += (int)GET2(cc,1);+ cc += 2 + IMM2_SIZE;+#ifdef SUPPORT_UTF+ if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ break;++ case OP_TYPEEXACT:+ branchlength += GET2(cc,1);+ if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP)+ cc += 2;+ cc += 1 + IMM2_SIZE + 1;+ break;++ /* Handle single-char matchers */++ case OP_PROP:+ case OP_NOTPROP:+ cc += 2;+ /* Fall through */++ case OP_HSPACE:+ case OP_VSPACE:+ case OP_NOT_HSPACE:+ case OP_NOT_VSPACE:+ case OP_NOT_DIGIT:+ case OP_DIGIT:+ case OP_NOT_WHITESPACE:+ case OP_WHITESPACE:+ case OP_NOT_WORDCHAR:+ case OP_WORDCHAR:+ case OP_ANY:+ case OP_ALLANY:+ branchlength++;+ cc++;+ break;++ /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode;+ otherwise \C is coded as OP_ALLANY. */++ case OP_ANYBYTE:+ return -2;++ /* Check a class for variable quantification */++ case OP_CLASS:+ case OP_NCLASS:+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32+ case OP_XCLASS:+ /* The original code caused an unsigned overflow in 64 bit systems,+ so now we use a conditional statement. */+ if (op == OP_XCLASS)+ cc += GET(cc, 1);+ else+ cc += PRIV(OP_lengths)[OP_CLASS];+#else+ cc += PRIV(OP_lengths)[OP_CLASS];+#endif++ switch (*cc)+ {+ case OP_CRSTAR:+ case OP_CRMINSTAR:+ case OP_CRPLUS:+ case OP_CRMINPLUS:+ case OP_CRQUERY:+ case OP_CRMINQUERY:+ case OP_CRPOSSTAR:+ case OP_CRPOSPLUS:+ case OP_CRPOSQUERY:+ return -1;++ case OP_CRRANGE:+ case OP_CRMINRANGE:+ case OP_CRPOSRANGE:+ if (GET2(cc,1) != GET2(cc,1+IMM2_SIZE)) return -1;+ branchlength += (int)GET2(cc,1);+ cc += 1 + 2 * IMM2_SIZE;+ break;++ default:+ branchlength++;+ }+ break;++ /* Anything else is variable length */++ case OP_ANYNL:+ case OP_BRAMINZERO:+ case OP_BRAPOS:+ case OP_BRAPOSZERO:+ case OP_BRAZERO:+ case OP_CBRAPOS:+ case OP_EXTUNI:+ case OP_KETRMAX:+ case OP_KETRMIN:+ case OP_KETRPOS:+ case OP_MINPLUS:+ case OP_MINPLUSI:+ case OP_MINQUERY:+ case OP_MINQUERYI:+ case OP_MINSTAR:+ case OP_MINSTARI:+ case OP_MINUPTO:+ case OP_MINUPTOI:+ case OP_NOTMINPLUS:+ case OP_NOTMINPLUSI:+ case OP_NOTMINQUERY:+ case OP_NOTMINQUERYI:+ case OP_NOTMINSTAR:+ case OP_NOTMINSTARI:+ case OP_NOTMINUPTO:+ case OP_NOTMINUPTOI:+ case OP_NOTPLUS:+ case OP_NOTPLUSI:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSPLUSI:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSQUERYI:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSSTARI:+ case OP_NOTPOSUPTO:+ case OP_NOTPOSUPTOI:+ case OP_NOTQUERY:+ case OP_NOTQUERYI:+ case OP_NOTSTAR:+ case OP_NOTSTARI:+ case OP_NOTUPTO:+ case OP_NOTUPTOI:+ case OP_PLUS:+ case OP_PLUSI:+ case OP_POSPLUS:+ case OP_POSPLUSI:+ case OP_POSQUERY:+ case OP_POSQUERYI:+ case OP_POSSTAR:+ case OP_POSSTARI:+ case OP_POSUPTO:+ case OP_POSUPTOI:+ case OP_QUERY:+ case OP_QUERYI:+ case OP_REF:+ case OP_REFI:+ case OP_DNREF:+ case OP_DNREFI:+ case OP_SBRA:+ case OP_SBRAPOS:+ case OP_SCBRA:+ case OP_SCBRAPOS:+ case OP_SCOND:+ case OP_SKIPZERO:+ case OP_STAR:+ case OP_STARI:+ case OP_TYPEMINPLUS:+ case OP_TYPEMINQUERY:+ case OP_TYPEMINSTAR:+ case OP_TYPEMINUPTO:+ case OP_TYPEPLUS:+ case OP_TYPEPOSPLUS:+ case OP_TYPEPOSQUERY:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSUPTO:+ case OP_TYPEQUERY:+ case OP_TYPESTAR:+ case OP_TYPEUPTO:+ case OP_UPTO:+ case OP_UPTOI:+ return -1;++ /* Catch unrecognized opcodes so that when new ones are added they+ are not forgotten, as has happened in the past. */++ default:+ return -4;+ }+ }+/* Control never gets here */+}++++/*************************************************+* Scan compiled regex for specific bracket *+*************************************************/++/* This little function scans through a compiled pattern until it finds a+capturing bracket with the given number, or, if the number is negative, an+instance of OP_REVERSE for a lookbehind. The function is global in the C sense+so that it can be called from pcre_study() when finding the minimum matching+length.++Arguments:+ code points to start of expression+ utf TRUE in UTF-8 / UTF-16 / UTF-32 mode+ number the required bracket number or negative to find a lookbehind++Returns: pointer to the opcode for the bracket, or NULL if not found+*/++const pcre_uchar *+PRIV(find_bracket)(const pcre_uchar *code, BOOL utf, int number)+{+for (;;)+ {+ register pcre_uchar c = *code;++ if (c == OP_END) return NULL;++ /* XCLASS is used for classes that cannot be represented just by a bit+ map. This includes negated single high-valued characters. The length in+ the table is zero; the actual length is stored in the compiled code. */++ if (c == OP_XCLASS) code += GET(code, 1);++ /* Handle recursion */++ else if (c == OP_REVERSE)+ {+ if (number < 0) return (pcre_uchar *)code;+ code += PRIV(OP_lengths)[c];+ }++ /* Handle capturing bracket */++ else if (c == OP_CBRA || c == OP_SCBRA ||+ c == OP_CBRAPOS || c == OP_SCBRAPOS)+ {+ int n = (int)GET2(code, 1+LINK_SIZE);+ if (n == number) return (pcre_uchar *)code;+ code += PRIV(OP_lengths)[c];+ }++ /* Otherwise, we can get the item's length from the table, except that for+ repeated character types, we have to test for \p and \P, which have an extra+ two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we+ must add in its length. */++ else+ {+ switch(c)+ {+ case OP_TYPESTAR:+ case OP_TYPEMINSTAR:+ case OP_TYPEPLUS:+ case OP_TYPEMINPLUS:+ case OP_TYPEQUERY:+ case OP_TYPEMINQUERY:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSPLUS:+ case OP_TYPEPOSQUERY:+ if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;+ break;++ case OP_TYPEUPTO:+ case OP_TYPEMINUPTO:+ case OP_TYPEEXACT:+ case OP_TYPEPOSUPTO:+ if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)+ code += 2;+ break;++ case OP_MARK:+ case OP_PRUNE_ARG:+ case OP_SKIP_ARG:+ case OP_THEN_ARG:+ code += code[1];+ break;+ }++ /* Add in the fixed length from the table */++ code += PRIV(OP_lengths)[c];++ /* In UTF-8 mode, opcodes that are followed by a character may be followed by+ a multi-byte character. The length in the table is a minimum, so we have to+ arrange to skip the extra bytes. */++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf) switch(c)+ {+ case OP_CHAR:+ case OP_CHARI:+ case OP_NOT:+ case OP_NOTI:+ case OP_EXACT:+ case OP_EXACTI:+ case OP_NOTEXACT:+ case OP_NOTEXACTI:+ case OP_UPTO:+ case OP_UPTOI:+ case OP_NOTUPTO:+ case OP_NOTUPTOI:+ case OP_MINUPTO:+ case OP_MINUPTOI:+ case OP_NOTMINUPTO:+ case OP_NOTMINUPTOI:+ case OP_POSUPTO:+ case OP_POSUPTOI:+ case OP_NOTPOSUPTO:+ case OP_NOTPOSUPTOI:+ case OP_STAR:+ case OP_STARI:+ case OP_NOTSTAR:+ case OP_NOTSTARI:+ case OP_MINSTAR:+ case OP_MINSTARI:+ case OP_NOTMINSTAR:+ case OP_NOTMINSTARI:+ case OP_POSSTAR:+ case OP_POSSTARI:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSSTARI:+ case OP_PLUS:+ case OP_PLUSI:+ case OP_NOTPLUS:+ case OP_NOTPLUSI:+ case OP_MINPLUS:+ case OP_MINPLUSI:+ case OP_NOTMINPLUS:+ case OP_NOTMINPLUSI:+ case OP_POSPLUS:+ case OP_POSPLUSI:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSPLUSI:+ case OP_QUERY:+ case OP_QUERYI:+ case OP_NOTQUERY:+ case OP_NOTQUERYI:+ case OP_MINQUERY:+ case OP_MINQUERYI:+ case OP_NOTMINQUERY:+ case OP_NOTMINQUERYI:+ case OP_POSQUERY:+ case OP_POSQUERYI:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSQUERYI:+ if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);+ break;+ }+#else+ (void)(utf); /* Keep compiler happy by referencing function argument */+#endif+ }+ }+}++++/*************************************************+* Scan compiled regex for recursion reference *+*************************************************/++/* This little function scans through a compiled pattern until it finds an+instance of OP_RECURSE.++Arguments:+ code points to start of expression+ utf TRUE in UTF-8 / UTF-16 / UTF-32 mode++Returns: pointer to the opcode for OP_RECURSE, or NULL if not found+*/++static const pcre_uchar *+find_recurse(const pcre_uchar *code, BOOL utf)+{+for (;;)+ {+ register pcre_uchar c = *code;+ if (c == OP_END) return NULL;+ if (c == OP_RECURSE) return code;++ /* XCLASS is used for classes that cannot be represented just by a bit+ map. This includes negated single high-valued characters. The length in+ the table is zero; the actual length is stored in the compiled code. */++ if (c == OP_XCLASS) code += GET(code, 1);++ /* Otherwise, we can get the item's length from the table, except that for+ repeated character types, we have to test for \p and \P, which have an extra+ two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we+ must add in its length. */++ else+ {+ switch(c)+ {+ case OP_TYPESTAR:+ case OP_TYPEMINSTAR:+ case OP_TYPEPLUS:+ case OP_TYPEMINPLUS:+ case OP_TYPEQUERY:+ case OP_TYPEMINQUERY:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSPLUS:+ case OP_TYPEPOSQUERY:+ if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;+ break;++ case OP_TYPEPOSUPTO:+ case OP_TYPEUPTO:+ case OP_TYPEMINUPTO:+ case OP_TYPEEXACT:+ if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)+ code += 2;+ break;++ case OP_MARK:+ case OP_PRUNE_ARG:+ case OP_SKIP_ARG:+ case OP_THEN_ARG:+ code += code[1];+ break;+ }++ /* Add in the fixed length from the table */++ code += PRIV(OP_lengths)[c];++ /* In UTF-8 mode, opcodes that are followed by a character may be followed+ by a multi-byte character. The length in the table is a minimum, so we have+ to arrange to skip the extra bytes. */++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf) switch(c)+ {+ case OP_CHAR:+ case OP_CHARI:+ case OP_NOT:+ case OP_NOTI:+ case OP_EXACT:+ case OP_EXACTI:+ case OP_NOTEXACT:+ case OP_NOTEXACTI:+ case OP_UPTO:+ case OP_UPTOI:+ case OP_NOTUPTO:+ case OP_NOTUPTOI:+ case OP_MINUPTO:+ case OP_MINUPTOI:+ case OP_NOTMINUPTO:+ case OP_NOTMINUPTOI:+ case OP_POSUPTO:+ case OP_POSUPTOI:+ case OP_NOTPOSUPTO:+ case OP_NOTPOSUPTOI:+ case OP_STAR:+ case OP_STARI:+ case OP_NOTSTAR:+ case OP_NOTSTARI:+ case OP_MINSTAR:+ case OP_MINSTARI:+ case OP_NOTMINSTAR:+ case OP_NOTMINSTARI:+ case OP_POSSTAR:+ case OP_POSSTARI:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSSTARI:+ case OP_PLUS:+ case OP_PLUSI:+ case OP_NOTPLUS:+ case OP_NOTPLUSI:+ case OP_MINPLUS:+ case OP_MINPLUSI:+ case OP_NOTMINPLUS:+ case OP_NOTMINPLUSI:+ case OP_POSPLUS:+ case OP_POSPLUSI:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSPLUSI:+ case OP_QUERY:+ case OP_QUERYI:+ case OP_NOTQUERY:+ case OP_NOTQUERYI:+ case OP_MINQUERY:+ case OP_MINQUERYI:+ case OP_NOTMINQUERY:+ case OP_NOTMINQUERYI:+ case OP_POSQUERY:+ case OP_POSQUERYI:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSQUERYI:+ if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);+ break;+ }+#else+ (void)(utf); /* Keep compiler happy by referencing function argument */+#endif+ }+ }+}++++/*************************************************+* Scan compiled branch for non-emptiness *+*************************************************/++/* This function scans through a branch of a compiled pattern to see whether it+can match the empty string or not. It is called from could_be_empty()+below and from compile_branch() when checking for an unlimited repeat of a+group that can match nothing. Note that first_significant_code() skips over+backward and negative forward assertions when its final argument is TRUE. If we+hit an unclosed bracket, we return "empty" - this means we've struck an inner+bracket whose current branch will already have been scanned.++Arguments:+ code points to start of search+ endcode points to where to stop+ utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode+ cd contains pointers to tables etc.+ recurses chain of recurse_check to catch mutual recursion++Returns: TRUE if what is matched could be empty+*/++static BOOL+could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,+ BOOL utf, compile_data *cd, recurse_check *recurses)+{+register pcre_uchar c;+recurse_check this_recurse;++for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);+ code < endcode;+ code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))+ {+ const pcre_uchar *ccode;++ c = *code;++ /* Skip over forward assertions; the other assertions are skipped by+ first_significant_code() with a TRUE final argument. */++ if (c == OP_ASSERT)+ {+ do code += GET(code, 1); while (*code == OP_ALT);+ c = *code;+ continue;+ }++ /* For a recursion/subroutine call, if its end has been reached, which+ implies a backward reference subroutine call, we can scan it. If it's a+ forward reference subroutine call, we can't. To detect forward reference+ we have to scan up the list that is kept in the workspace. This function is+ called only when doing the real compile, not during the pre-compile that+ measures the size of the compiled pattern. */++ if (c == OP_RECURSE)+ {+ const pcre_uchar *scode = cd->start_code + GET(code, 1);+ const pcre_uchar *endgroup = scode;+ BOOL empty_branch;++ /* Test for forward reference or uncompleted reference. This is disabled+ when called to scan a completed pattern by setting cd->start_workspace to+ NULL. */++ if (cd->start_workspace != NULL)+ {+ const pcre_uchar *tcode;+ for (tcode = cd->start_workspace; tcode < cd->hwm; tcode += LINK_SIZE)+ if ((int)GET(tcode, 0) == (int)(code + 1 - cd->start_code)) return TRUE;+ if (GET(scode, 1) == 0) return TRUE; /* Unclosed */+ }++ /* If the reference is to a completed group, we need to detect whether this+ is a recursive call, as otherwise there will be an infinite loop. If it is+ a recursion, just skip over it. Simple recursions are easily detected. For+ mutual recursions we keep a chain on the stack. */++ do endgroup += GET(endgroup, 1); while (*endgroup == OP_ALT);+ if (code >= scode && code <= endgroup) continue; /* Simple recursion */+ else+ {+ recurse_check *r = recurses;+ for (r = recurses; r != NULL; r = r->prev)+ if (r->group == scode) break;+ if (r != NULL) continue; /* Mutual recursion */+ }++ /* Completed reference; scan the referenced group, remembering it on the+ stack chain to detect mutual recursions. */++ empty_branch = FALSE;+ this_recurse.prev = recurses;+ this_recurse.group = scode;++ do+ {+ if (could_be_empty_branch(scode, endcode, utf, cd, &this_recurse))+ {+ empty_branch = TRUE;+ break;+ }+ scode += GET(scode, 1);+ }+ while (*scode == OP_ALT);++ if (!empty_branch) return FALSE; /* All branches are non-empty */+ continue;+ }++ /* Groups with zero repeats can of course be empty; skip them. */++ if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO ||+ c == OP_BRAPOSZERO)+ {+ code += PRIV(OP_lengths)[c];+ do code += GET(code, 1); while (*code == OP_ALT);+ c = *code;+ continue;+ }++ /* A nested group that is already marked as "could be empty" can just be+ skipped. */++ if (c == OP_SBRA || c == OP_SBRAPOS ||+ c == OP_SCBRA || c == OP_SCBRAPOS)+ {+ do code += GET(code, 1); while (*code == OP_ALT);+ c = *code;+ continue;+ }++ /* For other groups, scan the branches. */++ if (c == OP_BRA || c == OP_BRAPOS ||+ c == OP_CBRA || c == OP_CBRAPOS ||+ c == OP_ONCE || c == OP_ONCE_NC ||+ c == OP_COND || c == OP_SCOND)+ {+ BOOL empty_branch;+ if (GET(code, 1) == 0) return TRUE; /* Hit unclosed bracket */++ /* If a conditional group has only one branch, there is a second, implied,+ empty branch, so just skip over the conditional, because it could be empty.+ Otherwise, scan the individual branches of the group. */++ if (c == OP_COND && code[GET(code, 1)] != OP_ALT)+ code += GET(code, 1);+ else+ {+ empty_branch = FALSE;+ do+ {+ if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd,+ recurses)) empty_branch = TRUE;+ code += GET(code, 1);+ }+ while (*code == OP_ALT);+ if (!empty_branch) return FALSE; /* All branches are non-empty */+ }++ c = *code;+ continue;+ }++ /* Handle the other opcodes */++ switch (c)+ {+ /* Check for quantifiers after a class. XCLASS is used for classes that+ cannot be represented just by a bit map. This includes negated single+ high-valued characters. The length in PRIV(OP_lengths)[] is zero; the+ actual length is stored in the compiled code, so we must update "code"+ here. */++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ ccode = code += GET(code, 1);+ goto CHECK_CLASS_REPEAT;+#endif++ case OP_CLASS:+ case OP_NCLASS:+ ccode = code + PRIV(OP_lengths)[OP_CLASS];++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ CHECK_CLASS_REPEAT:+#endif++ switch (*ccode)+ {+ case OP_CRSTAR: /* These could be empty; continue */+ case OP_CRMINSTAR:+ case OP_CRQUERY:+ case OP_CRMINQUERY:+ case OP_CRPOSSTAR:+ case OP_CRPOSQUERY:+ break;++ default: /* Non-repeat => class must match */+ case OP_CRPLUS: /* These repeats aren't empty */+ case OP_CRMINPLUS:+ case OP_CRPOSPLUS:+ return FALSE;++ case OP_CRRANGE:+ case OP_CRMINRANGE:+ case OP_CRPOSRANGE:+ if (GET2(ccode, 1) > 0) return FALSE; /* Minimum > 0 */+ break;+ }+ break;++ /* Opcodes that must match a character */++ case OP_ANY:+ case OP_ALLANY:+ case OP_ANYBYTE:++ case OP_PROP:+ case OP_NOTPROP:+ case OP_ANYNL:++ case OP_NOT_HSPACE:+ case OP_HSPACE:+ case OP_NOT_VSPACE:+ case OP_VSPACE:+ case OP_EXTUNI:++ case OP_NOT_DIGIT:+ case OP_DIGIT:+ case OP_NOT_WHITESPACE:+ case OP_WHITESPACE:+ case OP_NOT_WORDCHAR:+ case OP_WORDCHAR:++ case OP_CHAR:+ case OP_CHARI:+ case OP_NOT:+ case OP_NOTI:++ case OP_PLUS:+ case OP_PLUSI:+ case OP_MINPLUS:+ case OP_MINPLUSI:++ case OP_NOTPLUS:+ case OP_NOTPLUSI:+ case OP_NOTMINPLUS:+ case OP_NOTMINPLUSI:++ case OP_POSPLUS:+ case OP_POSPLUSI:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSPLUSI:++ case OP_EXACT:+ case OP_EXACTI:+ case OP_NOTEXACT:+ case OP_NOTEXACTI:++ case OP_TYPEPLUS:+ case OP_TYPEMINPLUS:+ case OP_TYPEPOSPLUS:+ case OP_TYPEEXACT:++ return FALSE;++ /* These are going to continue, as they may be empty, but we have to+ fudge the length for the \p and \P cases. */++ case OP_TYPESTAR:+ case OP_TYPEMINSTAR:+ case OP_TYPEPOSSTAR:+ case OP_TYPEQUERY:+ case OP_TYPEMINQUERY:+ case OP_TYPEPOSQUERY:+ if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;+ break;++ /* Same for these */++ case OP_TYPEUPTO:+ case OP_TYPEMINUPTO:+ case OP_TYPEPOSUPTO:+ if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)+ code += 2;+ break;++ /* End of branch */++ case OP_KET:+ case OP_KETRMAX:+ case OP_KETRMIN:+ case OP_KETRPOS:+ case OP_ALT:+ return TRUE;++ /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,+ MINUPTO, and POSUPTO and their caseless and negative versions may be+ followed by a multibyte character. */++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ case OP_STAR:+ case OP_STARI:+ case OP_NOTSTAR:+ case OP_NOTSTARI:++ case OP_MINSTAR:+ case OP_MINSTARI:+ case OP_NOTMINSTAR:+ case OP_NOTMINSTARI:++ case OP_POSSTAR:+ case OP_POSSTARI:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSSTARI:++ case OP_QUERY:+ case OP_QUERYI:+ case OP_NOTQUERY:+ case OP_NOTQUERYI:++ case OP_MINQUERY:+ case OP_MINQUERYI:+ case OP_NOTMINQUERY:+ case OP_NOTMINQUERYI:++ case OP_POSQUERY:+ case OP_POSQUERYI:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSQUERYI:++ if (utf && HAS_EXTRALEN(code[1])) code += GET_EXTRALEN(code[1]);+ break;++ case OP_UPTO:+ case OP_UPTOI:+ case OP_NOTUPTO:+ case OP_NOTUPTOI:++ case OP_MINUPTO:+ case OP_MINUPTOI:+ case OP_NOTMINUPTO:+ case OP_NOTMINUPTOI:++ case OP_POSUPTO:+ case OP_POSUPTOI:+ case OP_NOTPOSUPTO:+ case OP_NOTPOSUPTOI:++ if (utf && HAS_EXTRALEN(code[1 + IMM2_SIZE])) code += GET_EXTRALEN(code[1 + IMM2_SIZE]);+ break;+#endif++ /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument+ string. */++ case OP_MARK:+ case OP_PRUNE_ARG:+ case OP_SKIP_ARG:+ case OP_THEN_ARG:+ code += code[1];+ break;++ /* None of the remaining opcodes are required to match a character. */++ default:+ break;+ }+ }++return TRUE;+}++++/*************************************************+* Scan compiled regex for non-emptiness *+*************************************************/++/* This function is called to check for left recursive calls. We want to check+the current branch of the current pattern to see if it could match the empty+string. If it could, we must look outwards for branches at other levels,+stopping when we pass beyond the bracket which is the subject of the recursion.+This function is called only during the real compile, not during the+pre-compile.++Arguments:+ code points to start of the recursion+ endcode points to where to stop (current RECURSE item)+ bcptr points to the chain of current (unclosed) branch starts+ utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode+ cd pointers to tables etc++Returns: TRUE if what is matched could be empty+*/++static BOOL+could_be_empty(const pcre_uchar *code, const pcre_uchar *endcode,+ branch_chain *bcptr, BOOL utf, compile_data *cd)+{+while (bcptr != NULL && bcptr->current_branch >= code)+ {+ if (!could_be_empty_branch(bcptr->current_branch, endcode, utf, cd, NULL))+ return FALSE;+ bcptr = bcptr->outer;+ }+return TRUE;+}++++/*************************************************+* Base opcode of repeated opcodes *+*************************************************/++/* Returns the base opcode for repeated single character type opcodes. If the+opcode is not a repeated character type, it returns with the original value.++Arguments: c opcode+Returns: base opcode for the type+*/++static pcre_uchar+get_repeat_base(pcre_uchar c)+{+return (c > OP_TYPEPOSUPTO)? c :+ (c >= OP_TYPESTAR)? OP_TYPESTAR :+ (c >= OP_NOTSTARI)? OP_NOTSTARI :+ (c >= OP_NOTSTAR)? OP_NOTSTAR :+ (c >= OP_STARI)? OP_STARI :+ OP_STAR;+}++++#ifdef SUPPORT_UCP+/*************************************************+* Check a character and a property *+*************************************************/++/* This function is called by check_auto_possessive() when a property item+is adjacent to a fixed character.++Arguments:+ c the character+ ptype the property type+ pdata the data for the type+ negated TRUE if it's a negated property (\P or \p{^)++Returns: TRUE if auto-possessifying is OK+*/++static BOOL+check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata,+ BOOL negated)+{+const pcre_uint32 *p;+const ucd_record *prop = GET_UCD(c);++switch(ptype)+ {+ case PT_LAMP:+ return (prop->chartype == ucp_Lu ||+ prop->chartype == ucp_Ll ||+ prop->chartype == ucp_Lt) == negated;++ case PT_GC:+ return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;++ case PT_PC:+ return (pdata == prop->chartype) == negated;++ case PT_SC:+ return (pdata == prop->script) == negated;++ /* These are specials */++ case PT_ALNUM:+ return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||+ PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;++ /* Perl space used to exclude VT, but from Perl 5.18 it is included, which+ means that Perl space and POSIX space are now identical. PCRE was changed+ at release 8.34. */++ case PT_SPACE: /* Perl space */+ case PT_PXSPACE: /* POSIX space */+ switch(c)+ {+ HSPACE_CASES:+ VSPACE_CASES:+ return negated;++ default:+ return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated;+ }+ break; /* Control never reaches here */++ case PT_WORD:+ return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||+ PRIV(ucp_gentype)[prop->chartype] == ucp_N ||+ c == CHAR_UNDERSCORE) == negated;++ case PT_CLIST:+ p = PRIV(ucd_caseless_sets) + prop->caseset;+ for (;;)+ {+ if (c < *p) return !negated;+ if (c == *p++) return negated;+ }+ break; /* Control never reaches here */+ }++return FALSE;+}+#endif /* SUPPORT_UCP */++++/*************************************************+* Fill the character property list *+*************************************************/++/* Checks whether the code points to an opcode that can take part in auto-+possessification, and if so, fills a list with its properties.++Arguments:+ code points to start of expression+ utf TRUE if in UTF-8 / UTF-16 / UTF-32 mode+ fcc points to case-flipping table+ list points to output list+ list[0] will be filled with the opcode+ list[1] will be non-zero if this opcode+ can match an empty character string+ list[2..7] depends on the opcode++Returns: points to the start of the next opcode if *code is accepted+ NULL if *code is not accepted+*/++static const pcre_uchar *+get_chr_property_list(const pcre_uchar *code, BOOL utf,+ const pcre_uint8 *fcc, pcre_uint32 *list)+{+pcre_uchar c = *code;+pcre_uchar base;+const pcre_uchar *end;+pcre_uint32 chr;++#ifdef SUPPORT_UCP+pcre_uint32 *clist_dest;+const pcre_uint32 *clist_src;+#else+utf = utf; /* Suppress "unused parameter" compiler warning */+#endif++list[0] = c;+list[1] = FALSE;+code++;++if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)+ {+ base = get_repeat_base(c);+ c -= (base - OP_STAR);++ if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO)+ code += IMM2_SIZE;++ list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT && c != OP_POSPLUS);++ switch(base)+ {+ case OP_STAR:+ list[0] = OP_CHAR;+ break;++ case OP_STARI:+ list[0] = OP_CHARI;+ break;++ case OP_NOTSTAR:+ list[0] = OP_NOT;+ break;++ case OP_NOTSTARI:+ list[0] = OP_NOTI;+ break;++ case OP_TYPESTAR:+ list[0] = *code;+ code++;+ break;+ }+ c = list[0];+ }++switch(c)+ {+ case OP_NOT_DIGIT:+ case OP_DIGIT:+ case OP_NOT_WHITESPACE:+ case OP_WHITESPACE:+ case OP_NOT_WORDCHAR:+ case OP_WORDCHAR:+ case OP_ANY:+ case OP_ALLANY:+ case OP_ANYNL:+ case OP_NOT_HSPACE:+ case OP_HSPACE:+ case OP_NOT_VSPACE:+ case OP_VSPACE:+ case OP_EXTUNI:+ case OP_EODN:+ case OP_EOD:+ case OP_DOLL:+ case OP_DOLLM:+ return code;++ case OP_CHAR:+ case OP_NOT:+ GETCHARINCTEST(chr, code);+ list[2] = chr;+ list[3] = NOTACHAR;+ return code;++ case OP_CHARI:+ case OP_NOTI:+ list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT;+ GETCHARINCTEST(chr, code);+ list[2] = chr;++#ifdef SUPPORT_UCP+ if (chr < 128 || (chr < 256 && !utf))+ list[3] = fcc[chr];+ else+ list[3] = UCD_OTHERCASE(chr);+#elif defined SUPPORT_UTF || !defined COMPILE_PCRE8+ list[3] = (chr < 256) ? fcc[chr] : chr;+#else+ list[3] = fcc[chr];+#endif++ /* The othercase might be the same value. */++ if (chr == list[3])+ list[3] = NOTACHAR;+ else+ list[4] = NOTACHAR;+ return code;++#ifdef SUPPORT_UCP+ case OP_PROP:+ case OP_NOTPROP:+ if (code[0] != PT_CLIST)+ {+ list[2] = code[0];+ list[3] = code[1];+ return code + 2;+ }++ /* Convert only if we have enough space. */++ clist_src = PRIV(ucd_caseless_sets) + code[1];+ clist_dest = list + 2;+ code += 2;++ do {+ if (clist_dest >= list + 8)+ {+ /* Early return if there is not enough space. This should never+ happen, since all clists are shorter than 5 character now. */+ list[2] = code[0];+ list[3] = code[1];+ return code;+ }+ *clist_dest++ = *clist_src;+ }+ while(*clist_src++ != NOTACHAR);++ /* All characters are stored. The terminating NOTACHAR+ is copied form the clist itself. */++ list[0] = (c == OP_PROP) ? OP_CHAR : OP_NOT;+ return code;+#endif++ case OP_NCLASS:+ case OP_CLASS:+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ if (c == OP_XCLASS)+ end = code + GET(code, 0) - 1;+ else+#endif+ end = code + 32 / sizeof(pcre_uchar);++ switch(*end)+ {+ case OP_CRSTAR:+ case OP_CRMINSTAR:+ case OP_CRQUERY:+ case OP_CRMINQUERY:+ case OP_CRPOSSTAR:+ case OP_CRPOSQUERY:+ list[1] = TRUE;+ end++;+ break;++ case OP_CRPLUS:+ case OP_CRMINPLUS:+ case OP_CRPOSPLUS:+ end++;+ break;++ case OP_CRRANGE:+ case OP_CRMINRANGE:+ case OP_CRPOSRANGE:+ list[1] = (GET2(end, 1) == 0);+ end += 1 + 2 * IMM2_SIZE;+ break;+ }+ list[2] = (pcre_uint32)(end - code);+ return end;+ }+return NULL; /* Opcode not accepted */+}++++/*************************************************+* Scan further character sets for match *+*************************************************/++/* Checks whether the base and the current opcode have a common character, in+which case the base cannot be possessified.++Arguments:+ code points to the byte code+ utf TRUE in UTF-8 / UTF-16 / UTF-32 mode+ cd static compile data+ base_list the data list of the base opcode++Returns: TRUE if the auto-possessification is possible+*/++static BOOL+compare_opcodes(const pcre_uchar *code, BOOL utf, const compile_data *cd,+ const pcre_uint32 *base_list, const pcre_uchar *base_end, int *rec_limit)+{+pcre_uchar c;+pcre_uint32 list[8];+const pcre_uint32 *chr_ptr;+const pcre_uint32 *ochr_ptr;+const pcre_uint32 *list_ptr;+const pcre_uchar *next_code;+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+const pcre_uchar *xclass_flags;+#endif+const pcre_uint8 *class_bitset;+const pcre_uint8 *set1, *set2, *set_end;+pcre_uint32 chr;+BOOL accepted, invert_bits;+BOOL entered_a_group = FALSE;++if (*rec_limit == 0) return FALSE;+--(*rec_limit);++/* Note: the base_list[1] contains whether the current opcode has greedy+(represented by a non-zero value) quantifier. This is a different from+other character type lists, which stores here that the character iterator+matches to an empty string (also represented by a non-zero value). */++for(;;)+ {+ /* All operations move the code pointer forward.+ Therefore infinite recursions are not possible. */++ c = *code;++ /* Skip over callouts */++ if (c == OP_CALLOUT)+ {+ code += PRIV(OP_lengths)[c];+ continue;+ }++ if (c == OP_ALT)+ {+ do code += GET(code, 1); while (*code == OP_ALT);+ c = *code;+ }++ switch(c)+ {+ case OP_END:+ case OP_KETRPOS:+ /* TRUE only in greedy case. The non-greedy case could be replaced by+ an OP_EXACT, but it is probably not worth it. (And note that OP_EXACT+ uses more memory, which we cannot get at this stage.) */++ return base_list[1] != 0;++ case OP_KET:+ /* If the bracket is capturing, and referenced by an OP_RECURSE, or+ it is an atomic sub-pattern (assert, once, etc.) the non-greedy case+ cannot be converted to a possessive form. */++ if (base_list[1] == 0) return FALSE;++ switch(*(code - GET(code, 1)))+ {+ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ case OP_ONCE:+ case OP_ONCE_NC:+ /* Atomic sub-patterns and assertions can always auto-possessify their+ last iterator. However, if the group was entered as a result of checking+ a previous iterator, this is not possible. */++ return !entered_a_group;+ }++ code += PRIV(OP_lengths)[c];+ continue;++ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_BRA:+ case OP_CBRA:+ next_code = code + GET(code, 1);+ code += PRIV(OP_lengths)[c];++ while (*next_code == OP_ALT)+ {+ if (!compare_opcodes(code, utf, cd, base_list, base_end, rec_limit))+ return FALSE;+ code = next_code + 1 + LINK_SIZE;+ next_code += GET(next_code, 1);+ }++ entered_a_group = TRUE;+ continue;++ case OP_BRAZERO:+ case OP_BRAMINZERO:++ next_code = code + 1;+ if (*next_code != OP_BRA && *next_code != OP_CBRA+ && *next_code != OP_ONCE && *next_code != OP_ONCE_NC) return FALSE;++ do next_code += GET(next_code, 1); while (*next_code == OP_ALT);++ /* The bracket content will be checked by the+ OP_BRA/OP_CBRA case above. */+ next_code += 1 + LINK_SIZE;+ if (!compare_opcodes(next_code, utf, cd, base_list, base_end, rec_limit))+ return FALSE;++ code += PRIV(OP_lengths)[c];+ continue;++ default:+ break;+ }++ /* Check for a supported opcode, and load its properties. */++ code = get_chr_property_list(code, utf, cd->fcc, list);+ if (code == NULL) return FALSE; /* Unsupported */++ /* If either opcode is a small character list, set pointers for comparing+ characters from that list with another list, or with a property. */++ if (base_list[0] == OP_CHAR)+ {+ chr_ptr = base_list + 2;+ list_ptr = list;+ }+ else if (list[0] == OP_CHAR)+ {+ chr_ptr = list + 2;+ list_ptr = base_list;+ }++ /* Character bitsets can also be compared to certain opcodes. */++ else if (base_list[0] == OP_CLASS || list[0] == OP_CLASS+#ifdef COMPILE_PCRE8+ /* In 8 bit, non-UTF mode, OP_CLASS and OP_NCLASS are the same. */+ || (!utf && (base_list[0] == OP_NCLASS || list[0] == OP_NCLASS))+#endif+ )+ {+#ifdef COMPILE_PCRE8+ if (base_list[0] == OP_CLASS || (!utf && base_list[0] == OP_NCLASS))+#else+ if (base_list[0] == OP_CLASS)+#endif+ {+ set1 = (pcre_uint8 *)(base_end - base_list[2]);+ list_ptr = list;+ }+ else+ {+ set1 = (pcre_uint8 *)(code - list[2]);+ list_ptr = base_list;+ }++ invert_bits = FALSE;+ switch(list_ptr[0])+ {+ case OP_CLASS:+ case OP_NCLASS:+ set2 = (pcre_uint8 *)+ ((list_ptr == list ? code : base_end) - list_ptr[2]);+ break;++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ xclass_flags = (list_ptr == list ? code : base_end) - list_ptr[2] + LINK_SIZE;+ if ((*xclass_flags & XCL_HASPROP) != 0) return FALSE;+ if ((*xclass_flags & XCL_MAP) == 0)+ {+ /* No bits are set for characters < 256. */+ if (list[1] == 0) return (*xclass_flags & XCL_NOT) == 0;+ /* Might be an empty repeat. */+ continue;+ }+ set2 = (pcre_uint8 *)(xclass_flags + 1);+ break;+#endif++ case OP_NOT_DIGIT:+ invert_bits = TRUE;+ /* Fall through */+ case OP_DIGIT:+ set2 = (pcre_uint8 *)(cd->cbits + cbit_digit);+ break;++ case OP_NOT_WHITESPACE:+ invert_bits = TRUE;+ /* Fall through */+ case OP_WHITESPACE:+ set2 = (pcre_uint8 *)(cd->cbits + cbit_space);+ break;++ case OP_NOT_WORDCHAR:+ invert_bits = TRUE;+ /* Fall through */+ case OP_WORDCHAR:+ set2 = (pcre_uint8 *)(cd->cbits + cbit_word);+ break;++ default:+ return FALSE;+ }++ /* Because the sets are unaligned, we need+ to perform byte comparison here. */+ set_end = set1 + 32;+ if (invert_bits)+ {+ do+ {+ if ((*set1++ & ~(*set2++)) != 0) return FALSE;+ }+ while (set1 < set_end);+ }+ else+ {+ do+ {+ if ((*set1++ & *set2++) != 0) return FALSE;+ }+ while (set1 < set_end);+ }++ if (list[1] == 0) return TRUE;+ /* Might be an empty repeat. */+ continue;+ }++ /* Some property combinations also acceptable. Unicode property opcodes are+ processed specially; the rest can be handled with a lookup table. */++ else+ {+ pcre_uint32 leftop, rightop;++ leftop = base_list[0];+ rightop = list[0];++#ifdef SUPPORT_UCP+ accepted = FALSE; /* Always set in non-unicode case. */+ if (leftop == OP_PROP || leftop == OP_NOTPROP)+ {+ if (rightop == OP_EOD)+ accepted = TRUE;+ else if (rightop == OP_PROP || rightop == OP_NOTPROP)+ {+ int n;+ const pcre_uint8 *p;+ BOOL same = leftop == rightop;+ BOOL lisprop = leftop == OP_PROP;+ BOOL risprop = rightop == OP_PROP;+ BOOL bothprop = lisprop && risprop;++ /* There's a table that specifies how each combination is to be+ processed:+ 0 Always return FALSE (never auto-possessify)+ 1 Character groups are distinct (possessify if both are OP_PROP)+ 2 Check character categories in the same group (general or particular)+ 3 Return TRUE if the two opcodes are not the same+ ... see comments below+ */++ n = propposstab[base_list[2]][list[2]];+ switch(n)+ {+ case 0: break;+ case 1: accepted = bothprop; break;+ case 2: accepted = (base_list[3] == list[3]) != same; break;+ case 3: accepted = !same; break;++ case 4: /* Left general category, right particular category */+ accepted = risprop && catposstab[base_list[3]][list[3]] == same;+ break;++ case 5: /* Right general category, left particular category */+ accepted = lisprop && catposstab[list[3]][base_list[3]] == same;+ break;++ /* This code is logically tricky. Think hard before fiddling with it.+ The posspropstab table has four entries per row. Each row relates to+ one of PCRE's special properties such as ALNUM or SPACE or WORD.+ Only WORD actually needs all four entries, but using repeats for the+ others means they can all use the same code below.++ The first two entries in each row are Unicode general categories, and+ apply always, because all the characters they include are part of the+ PCRE character set. The third and fourth entries are a general and a+ particular category, respectively, that include one or more relevant+ characters. One or the other is used, depending on whether the check+ is for a general or a particular category. However, in both cases the+ category contains more characters than the specials that are defined+ for the property being tested against. Therefore, it cannot be used+ in a NOTPROP case.++ Example: the row for WORD contains ucp_L, ucp_N, ucp_P, ucp_Po.+ Underscore is covered by ucp_P or ucp_Po. */++ case 6: /* Left alphanum vs right general category */+ case 7: /* Left space vs right general category */+ case 8: /* Left word vs right general category */+ p = posspropstab[n-6];+ accepted = risprop && lisprop ==+ (list[3] != p[0] &&+ list[3] != p[1] &&+ (list[3] != p[2] || !lisprop));+ break;++ case 9: /* Right alphanum vs left general category */+ case 10: /* Right space vs left general category */+ case 11: /* Right word vs left general category */+ p = posspropstab[n-9];+ accepted = lisprop && risprop ==+ (base_list[3] != p[0] &&+ base_list[3] != p[1] &&+ (base_list[3] != p[2] || !risprop));+ break;++ case 12: /* Left alphanum vs right particular category */+ case 13: /* Left space vs right particular category */+ case 14: /* Left word vs right particular category */+ p = posspropstab[n-12];+ accepted = risprop && lisprop ==+ (catposstab[p[0]][list[3]] &&+ catposstab[p[1]][list[3]] &&+ (list[3] != p[3] || !lisprop));+ break;++ case 15: /* Right alphanum vs left particular category */+ case 16: /* Right space vs left particular category */+ case 17: /* Right word vs left particular category */+ p = posspropstab[n-15];+ accepted = lisprop && risprop ==+ (catposstab[p[0]][base_list[3]] &&+ catposstab[p[1]][base_list[3]] &&+ (base_list[3] != p[3] || !risprop));+ break;+ }+ }+ }++ else+#endif /* SUPPORT_UCP */++ accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP &&+ rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP &&+ autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP];++ if (!accepted) return FALSE;++ if (list[1] == 0) return TRUE;+ /* Might be an empty repeat. */+ continue;+ }++ /* Control reaches here only if one of the items is a small character list.+ All characters are checked against the other side. */++ do+ {+ chr = *chr_ptr;++ switch(list_ptr[0])+ {+ case OP_CHAR:+ ochr_ptr = list_ptr + 2;+ do+ {+ if (chr == *ochr_ptr) return FALSE;+ ochr_ptr++;+ }+ while(*ochr_ptr != NOTACHAR);+ break;++ case OP_NOT:+ ochr_ptr = list_ptr + 2;+ do+ {+ if (chr == *ochr_ptr)+ break;+ ochr_ptr++;+ }+ while(*ochr_ptr != NOTACHAR);+ if (*ochr_ptr == NOTACHAR) return FALSE; /* Not found */+ break;++ /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not*+ set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */++ case OP_DIGIT:+ if (chr < 256 && (cd->ctypes[chr] & ctype_digit) != 0) return FALSE;+ break;++ case OP_NOT_DIGIT:+ if (chr > 255 || (cd->ctypes[chr] & ctype_digit) == 0) return FALSE;+ break;++ case OP_WHITESPACE:+ if (chr < 256 && (cd->ctypes[chr] & ctype_space) != 0) return FALSE;+ break;++ case OP_NOT_WHITESPACE:+ if (chr > 255 || (cd->ctypes[chr] & ctype_space) == 0) return FALSE;+ break;++ case OP_WORDCHAR:+ if (chr < 255 && (cd->ctypes[chr] & ctype_word) != 0) return FALSE;+ break;++ case OP_NOT_WORDCHAR:+ if (chr > 255 || (cd->ctypes[chr] & ctype_word) == 0) return FALSE;+ break;++ case OP_HSPACE:+ switch(chr)+ {+ HSPACE_CASES: return FALSE;+ default: break;+ }+ break;++ case OP_NOT_HSPACE:+ switch(chr)+ {+ HSPACE_CASES: break;+ default: return FALSE;+ }+ break;++ case OP_ANYNL:+ case OP_VSPACE:+ switch(chr)+ {+ VSPACE_CASES: return FALSE;+ default: break;+ }+ break;++ case OP_NOT_VSPACE:+ switch(chr)+ {+ VSPACE_CASES: break;+ default: return FALSE;+ }+ break;++ case OP_DOLL:+ case OP_EODN:+ switch (chr)+ {+ case CHAR_CR:+ case CHAR_LF:+ case CHAR_VT:+ case CHAR_FF:+ case CHAR_NEL:+#ifndef EBCDIC+ case 0x2028:+ case 0x2029:+#endif /* Not EBCDIC */+ return FALSE;+ }+ break;++ case OP_EOD: /* Can always possessify before \z */+ break;++#ifdef SUPPORT_UCP+ case OP_PROP:+ case OP_NOTPROP:+ if (!check_char_prop(chr, list_ptr[2], list_ptr[3],+ list_ptr[0] == OP_NOTPROP))+ return FALSE;+ break;+#endif++ case OP_NCLASS:+ if (chr > 255) return FALSE;+ /* Fall through */++ case OP_CLASS:+ if (chr > 255) break;+ class_bitset = (pcre_uint8 *)+ ((list_ptr == list ? code : base_end) - list_ptr[2]);+ if ((class_bitset[chr >> 3] & (1 << (chr & 7))) != 0) return FALSE;+ break;++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) -+ list_ptr[2] + LINK_SIZE, utf)) return FALSE;+ break;+#endif++ default:+ return FALSE;+ }++ chr_ptr++;+ }+ while(*chr_ptr != NOTACHAR);++ /* At least one character must be matched from this opcode. */++ if (list[1] == 0) return TRUE;+ }++/* Control never reaches here. There used to be a fail-save return FALSE; here,+but some compilers complain about an unreachable statement. */++}++++/*************************************************+* Scan compiled regex for auto-possession *+*************************************************/++/* Replaces single character iterations with their possessive alternatives+if appropriate. This function modifies the compiled opcode!++Arguments:+ code points to start of the byte code+ utf TRUE in UTF-8 / UTF-16 / UTF-32 mode+ cd static compile data++Returns: nothing+*/++static void+auto_possessify(pcre_uchar *code, BOOL utf, const compile_data *cd)+{+register pcre_uchar c;+const pcre_uchar *end;+pcre_uchar *repeat_opcode;+pcre_uint32 list[8];+int rec_limit;++for (;;)+ {+ c = *code;++ /* When a pattern with bad UTF-8 encoding is compiled with NO_UTF_CHECK,+ it may compile without complaining, but may get into a loop here if the code+ pointer points to a bad value. This is, of course a documentated possibility,+ when NO_UTF_CHECK is set, so it isn't a bug, but we can detect this case and+ just give up on this optimization. */++ if (c >= OP_TABLE_LENGTH) return;++ if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)+ {+ c -= get_repeat_base(c) - OP_STAR;+ end = (c <= OP_MINUPTO) ?+ get_chr_property_list(code, utf, cd->fcc, list) : NULL;+ list[1] = c == OP_STAR || c == OP_PLUS || c == OP_QUERY || c == OP_UPTO;++ rec_limit = 1000;+ if (end != NULL && compare_opcodes(end, utf, cd, list, end, &rec_limit))+ {+ switch(c)+ {+ case OP_STAR:+ *code += OP_POSSTAR - OP_STAR;+ break;++ case OP_MINSTAR:+ *code += OP_POSSTAR - OP_MINSTAR;+ break;++ case OP_PLUS:+ *code += OP_POSPLUS - OP_PLUS;+ break;++ case OP_MINPLUS:+ *code += OP_POSPLUS - OP_MINPLUS;+ break;++ case OP_QUERY:+ *code += OP_POSQUERY - OP_QUERY;+ break;++ case OP_MINQUERY:+ *code += OP_POSQUERY - OP_MINQUERY;+ break;++ case OP_UPTO:+ *code += OP_POSUPTO - OP_UPTO;+ break;++ case OP_MINUPTO:+ *code += OP_POSUPTO - OP_MINUPTO;+ break;+ }+ }+ c = *code;+ }+ else if (c == OP_CLASS || c == OP_NCLASS || c == OP_XCLASS)+ {+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ if (c == OP_XCLASS)+ repeat_opcode = code + GET(code, 1);+ else+#endif+ repeat_opcode = code + 1 + (32 / sizeof(pcre_uchar));++ c = *repeat_opcode;+ if (c >= OP_CRSTAR && c <= OP_CRMINRANGE)+ {+ /* end must not be NULL. */+ end = get_chr_property_list(code, utf, cd->fcc, list);++ list[1] = (c & 1) == 0;++ rec_limit = 1000;+ if (compare_opcodes(end, utf, cd, list, end, &rec_limit))+ {+ switch (c)+ {+ case OP_CRSTAR:+ case OP_CRMINSTAR:+ *repeat_opcode = OP_CRPOSSTAR;+ break;++ case OP_CRPLUS:+ case OP_CRMINPLUS:+ *repeat_opcode = OP_CRPOSPLUS;+ break;++ case OP_CRQUERY:+ case OP_CRMINQUERY:+ *repeat_opcode = OP_CRPOSQUERY;+ break;++ case OP_CRRANGE:+ case OP_CRMINRANGE:+ *repeat_opcode = OP_CRPOSRANGE;+ break;+ }+ }+ }+ c = *code;+ }++ switch(c)+ {+ case OP_END:+ return;++ case OP_TYPESTAR:+ case OP_TYPEMINSTAR:+ case OP_TYPEPLUS:+ case OP_TYPEMINPLUS:+ case OP_TYPEQUERY:+ case OP_TYPEMINQUERY:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSPLUS:+ case OP_TYPEPOSQUERY:+ if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;+ break;++ case OP_TYPEUPTO:+ case OP_TYPEMINUPTO:+ case OP_TYPEEXACT:+ case OP_TYPEPOSUPTO:+ if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)+ code += 2;+ break;++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ code += GET(code, 1);+ break;+#endif++ case OP_MARK:+ case OP_PRUNE_ARG:+ case OP_SKIP_ARG:+ case OP_THEN_ARG:+ code += code[1];+ break;+ }++ /* Add in the fixed length from the table */++ code += PRIV(OP_lengths)[c];++ /* In UTF-8 mode, opcodes that are followed by a character may be followed by+ a multi-byte character. The length in the table is a minimum, so we have to+ arrange to skip the extra bytes. */++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf) switch(c)+ {+ case OP_CHAR:+ case OP_CHARI:+ case OP_NOT:+ case OP_NOTI:+ case OP_STAR:+ case OP_MINSTAR:+ case OP_PLUS:+ case OP_MINPLUS:+ case OP_QUERY:+ case OP_MINQUERY:+ case OP_UPTO:+ case OP_MINUPTO:+ case OP_EXACT:+ case OP_POSSTAR:+ case OP_POSPLUS:+ case OP_POSQUERY:+ case OP_POSUPTO:+ case OP_STARI:+ case OP_MINSTARI:+ case OP_PLUSI:+ case OP_MINPLUSI:+ case OP_QUERYI:+ case OP_MINQUERYI:+ case OP_UPTOI:+ case OP_MINUPTOI:+ case OP_EXACTI:+ case OP_POSSTARI:+ case OP_POSPLUSI:+ case OP_POSQUERYI:+ case OP_POSUPTOI:+ case OP_NOTSTAR:+ case OP_NOTMINSTAR:+ case OP_NOTPLUS:+ case OP_NOTMINPLUS:+ case OP_NOTQUERY:+ case OP_NOTMINQUERY:+ case OP_NOTUPTO:+ case OP_NOTMINUPTO:+ case OP_NOTEXACT:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSUPTO:+ case OP_NOTSTARI:+ case OP_NOTMINSTARI:+ case OP_NOTPLUSI:+ case OP_NOTMINPLUSI:+ case OP_NOTQUERYI:+ case OP_NOTMINQUERYI:+ case OP_NOTUPTOI:+ case OP_NOTMINUPTOI:+ case OP_NOTEXACTI:+ case OP_NOTPOSSTARI:+ case OP_NOTPOSPLUSI:+ case OP_NOTPOSQUERYI:+ case OP_NOTPOSUPTOI:+ if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);+ break;+ }+#else+ (void)(utf); /* Keep compiler happy by referencing function argument */+#endif+ }+}++++/*************************************************+* Check for POSIX class syntax *+*************************************************/++/* This function is called when the sequence "[:" or "[." or "[=" is+encountered in a character class. It checks whether this is followed by a+sequence of characters terminated by a matching ":]" or ".]" or "=]". If we+reach an unescaped ']' without the special preceding character, return FALSE.++Originally, this function only recognized a sequence of letters between the+terminators, but it seems that Perl recognizes any sequence of characters,+though of course unknown POSIX names are subsequently rejected. Perl gives an+"Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE+didn't consider this to be a POSIX class. Likewise for [:1234:].++The problem in trying to be exactly like Perl is in the handling of escapes. We+have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX+class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code+below handles the special cases \\ and \], but does not try to do any other+escape processing. This makes it different from Perl for cases such as+[:l\ower:] where Perl recognizes it as the POSIX class "lower" but PCRE does+not recognize "l\ower". This is a lesser evil than not diagnosing bad classes+when Perl does, I think.++A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.+It seems that the appearance of a nested POSIX class supersedes an apparent+external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or+a digit.++In Perl, unescaped square brackets may also appear as part of class names. For+example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for+[:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not+seem right at all. PCRE does not allow closing square brackets in POSIX class+names.++Arguments:+ ptr pointer to the initial [+ endptr where to return the end pointer++Returns: TRUE or FALSE+*/++static BOOL+check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)+{+pcre_uchar terminator; /* Don't combine these lines; the Solaris cc */+terminator = *(++ptr); /* compiler warns about "non-constant" initializer. */+for (++ptr; *ptr != CHAR_NULL; ptr++)+ {+ if (*ptr == CHAR_BACKSLASH &&+ (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET ||+ ptr[1] == CHAR_BACKSLASH))+ ptr++;+ else if ((*ptr == CHAR_LEFT_SQUARE_BRACKET && ptr[1] == terminator) ||+ *ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;+ else if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)+ {+ *endptr = ptr;+ return TRUE;+ }+ }+return FALSE;+}+++++/*************************************************+* Check POSIX class name *+*************************************************/++/* This function is called to check the name given in a POSIX-style class entry+such as [:alnum:].++Arguments:+ ptr points to the first letter+ len the length of the name++Returns: a value representing the name, or -1 if unknown+*/++static int+check_posix_name(const pcre_uchar *ptr, int len)+{+const char *pn = posix_names;+register int yield = 0;+while (posix_name_lengths[yield] != 0)+ {+ if (len == posix_name_lengths[yield] &&+ STRNCMP_UC_C8(ptr, pn, (unsigned int)len) == 0) return yield;+ pn += posix_name_lengths[yield] + 1;+ yield++;+ }+return -1;+}+++/*************************************************+* Adjust OP_RECURSE items in repeated group *+*************************************************/++/* OP_RECURSE items contain an offset from the start of the regex to the group+that is referenced. This means that groups can be replicated for fixed+repetition simply by copying (because the recursion is allowed to refer to+earlier groups that are outside the current group). However, when a group is+optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is+inserted before it, after it has been compiled. This means that any OP_RECURSE+items within it that refer to the group itself or any contained groups have to+have their offsets adjusted. That one of the jobs of this function. Before it+is called, the partially compiled regex must be temporarily terminated with+OP_END.++This function has been extended to cope with forward references for recursions+and subroutine calls. It must check the list of such references for the+group we are dealing with. If it finds that one of the recursions in the+current group is on this list, it does not adjust the value in the reference+(which is a group number). After the group has been scanned, all the offsets in+the forward reference list for the group are adjusted.++Arguments:+ group points to the start of the group+ adjust the amount by which the group is to be moved+ utf TRUE in UTF-8 / UTF-16 / UTF-32 mode+ cd contains pointers to tables etc.+ save_hwm_offset the hwm forward reference offset at the start of the group++Returns: nothing+*/++static void+adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd,+ size_t save_hwm_offset)+{+int offset;+pcre_uchar *hc;+pcre_uchar *ptr = group;++while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)+ {+ for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset; hc < cd->hwm;+ hc += LINK_SIZE)+ {+ offset = (int)GET(hc, 0);+ if (cd->start_code + offset == ptr + 1) break;+ }++ /* If we have not found this recursion on the forward reference list, adjust+ the recursion's offset if it's after the start of this group. */++ if (hc >= cd->hwm)+ {+ offset = (int)GET(ptr, 1);+ if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);+ }++ ptr += 1 + LINK_SIZE;+ }++/* Now adjust all forward reference offsets for the group. */++for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset; hc < cd->hwm;+ hc += LINK_SIZE)+ {+ offset = (int)GET(hc, 0);+ PUT(hc, 0, offset + adjust);+ }+}++++/*************************************************+* Insert an automatic callout point *+*************************************************/++/* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert+callout points before each pattern item.++Arguments:+ code current code pointer+ ptr current pattern pointer+ cd pointers to tables etc++Returns: new code pointer+*/++static pcre_uchar *+auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd)+{+*code++ = OP_CALLOUT;+*code++ = 255;+PUT(code, 0, (int)(ptr - cd->start_pattern)); /* Pattern offset */+PUT(code, LINK_SIZE, 0); /* Default length */+return code + 2 * LINK_SIZE;+}++++/*************************************************+* Complete a callout item *+*************************************************/++/* A callout item contains the length of the next item in the pattern, which+we can't fill in till after we have reached the relevant point. This is used+for both automatic and manual callouts.++Arguments:+ previous_callout points to previous callout item+ ptr current pattern pointer+ cd pointers to tables etc++Returns: nothing+*/++static void+complete_callout(pcre_uchar *previous_callout, const pcre_uchar *ptr, compile_data *cd)+{+int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));+PUT(previous_callout, 2 + LINK_SIZE, length);+}++++#ifdef SUPPORT_UCP+/*************************************************+* Get othercase range *+*************************************************/++/* This function is passed the start and end of a class range, in UTF-8 mode+with UCP support. It searches up the characters, looking for ranges of+characters in the "other" case. Each call returns the next one, updating the+start address. A character with multiple other cases is returned on its own+with a special return value.++Arguments:+ cptr points to starting character value; updated+ d end value+ ocptr where to put start of othercase range+ odptr where to put end of othercase range++Yield: -1 when no more+ 0 when a range is returned+ >0 the CASESET offset for char with multiple other cases+ in this case, ocptr contains the original+*/++static int+get_othercase_range(pcre_uint32 *cptr, pcre_uint32 d, pcre_uint32 *ocptr,+ pcre_uint32 *odptr)+{+pcre_uint32 c, othercase, next;+unsigned int co;++/* Find the first character that has an other case. If it has multiple other+cases, return its case offset value. */++for (c = *cptr; c <= d; c++)+ {+ if ((co = UCD_CASESET(c)) != 0)+ {+ *ocptr = c++; /* Character that has the set */+ *cptr = c; /* Rest of input range */+ return (int)co;+ }+ if ((othercase = UCD_OTHERCASE(c)) != c) break;+ }++if (c > d) return -1; /* Reached end of range */++/* Found a character that has a single other case. Search for the end of the+range, which is either the end of the input range, or a character that has zero+or more than one other cases. */++*ocptr = othercase;+next = othercase + 1;++for (++c; c <= d; c++)+ {+ if ((co = UCD_CASESET(c)) != 0 || UCD_OTHERCASE(c) != next) break;+ next++;+ }++*odptr = next - 1; /* End of othercase range */+*cptr = c; /* Rest of input range */+return 0;+}+#endif /* SUPPORT_UCP */++++/*************************************************+* Add a character or range to a class *+*************************************************/++/* This function packages up the logic of adding a character or range of+characters to a class. The character values in the arguments will be within the+valid values for the current mode (8-bit, 16-bit, UTF, etc). This function is+mutually recursive with the function immediately below.++Arguments:+ classbits the bit map for characters < 256+ uchardptr points to the pointer for extra data+ options the options word+ cd contains pointers to tables etc.+ start start of range character+ end end of range character++Returns: the number of < 256 characters added+ the pointer to extra data is updated+*/++static int+add_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,+ compile_data *cd, pcre_uint32 start, pcre_uint32 end)+{+pcre_uint32 c;+pcre_uint32 classbits_end = (end <= 0xff ? end : 0xff);+int n8 = 0;++/* If caseless matching is required, scan the range and process alternate+cases. In Unicode, there are 8-bit characters that have alternate cases that+are greater than 255 and vice-versa. Sometimes we can just extend the original+range. */++if ((options & PCRE_CASELESS) != 0)+ {+#ifdef SUPPORT_UCP+ if ((options & PCRE_UTF8) != 0)+ {+ int rc;+ pcre_uint32 oc, od;++ options &= ~PCRE_CASELESS; /* Remove for recursive calls */+ c = start;++ while ((rc = get_othercase_range(&c, end, &oc, &od)) >= 0)+ {+ /* Handle a single character that has more than one other case. */++ if (rc > 0) n8 += add_list_to_class(classbits, uchardptr, options, cd,+ PRIV(ucd_caseless_sets) + rc, oc);++ /* Do nothing if the other case range is within the original range. */++ else if (oc >= start && od <= end) continue;++ /* Extend the original range if there is overlap, noting that if oc < c, we+ can't have od > end because a subrange is always shorter than the basic+ range. Otherwise, use a recursive call to add the additional range. */++ else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */+ else if (od > end && oc <= end + 1)+ {+ end = od; /* Extend upwards */+ if (end > classbits_end) classbits_end = (end <= 0xff ? end : 0xff);+ }+ else n8 += add_to_class(classbits, uchardptr, options, cd, oc, od);+ }+ }+ else+#endif /* SUPPORT_UCP */++ /* Not UTF-mode, or no UCP */++ for (c = start; c <= classbits_end; c++)+ {+ SETBIT(classbits, cd->fcc[c]);+ n8++;+ }+ }++/* Now handle the original range. Adjust the final value according to the bit+length - this means that the same lists of (e.g.) horizontal spaces can be used+in all cases. */++#if defined COMPILE_PCRE8+#ifdef SUPPORT_UTF+ if ((options & PCRE_UTF8) == 0)+#endif+ if (end > 0xff) end = 0xff;++#elif defined COMPILE_PCRE16+#ifdef SUPPORT_UTF+ if ((options & PCRE_UTF16) == 0)+#endif+ if (end > 0xffff) end = 0xffff;++#endif /* COMPILE_PCRE[8|16] */++/* Use the bitmap for characters < 256. Otherwise use extra data.*/++for (c = start; c <= classbits_end; c++)+ {+ /* Regardless of start, c will always be <= 255. */+ SETBIT(classbits, c);+ n8++;+ }++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+if (start <= 0xff) start = 0xff + 1;++if (end >= start)+ {+ pcre_uchar *uchardata = *uchardptr;+#ifdef SUPPORT_UTF+ if ((options & PCRE_UTF8) != 0) /* All UTFs use the same flag bit */+ {+ if (start < end)+ {+ *uchardata++ = XCL_RANGE;+ uchardata += PRIV(ord2utf)(start, uchardata);+ uchardata += PRIV(ord2utf)(end, uchardata);+ }+ else if (start == end)+ {+ *uchardata++ = XCL_SINGLE;+ uchardata += PRIV(ord2utf)(start, uchardata);+ }+ }+ else+#endif /* SUPPORT_UTF */++ /* Without UTF support, character values are constrained by the bit length,+ and can only be > 256 for 16-bit and 32-bit libraries. */++#ifdef COMPILE_PCRE8+ {}+#else+ if (start < end)+ {+ *uchardata++ = XCL_RANGE;+ *uchardata++ = start;+ *uchardata++ = end;+ }+ else if (start == end)+ {+ *uchardata++ = XCL_SINGLE;+ *uchardata++ = start;+ }+#endif++ *uchardptr = uchardata; /* Updata extra data pointer */+ }+#endif /* SUPPORT_UTF || !COMPILE_PCRE8 */++return n8; /* Number of 8-bit characters */+}+++++/*************************************************+* Add a list of characters to a class *+*************************************************/++/* This function is used for adding a list of case-equivalent characters to a+class, and also for adding a list of horizontal or vertical whitespace. If the+list is in order (which it should be), ranges of characters are detected and+handled appropriately. This function is mutually recursive with the function+above.++Arguments:+ classbits the bit map for characters < 256+ uchardptr points to the pointer for extra data+ options the options word+ cd contains pointers to tables etc.+ p points to row of 32-bit values, terminated by NOTACHAR+ except character to omit; this is used when adding lists of+ case-equivalent characters to avoid including the one we+ already know about++Returns: the number of < 256 characters added+ the pointer to extra data is updated+*/++static int+add_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,+ compile_data *cd, const pcre_uint32 *p, unsigned int except)+{+int n8 = 0;+while (p[0] < NOTACHAR)+ {+ int n = 0;+ if (p[0] != except)+ {+ while(p[n+1] == p[0] + n + 1) n++;+ n8 += add_to_class(classbits, uchardptr, options, cd, p[0], p[n]);+ }+ p += n + 1;+ }+return n8;+}++++/*************************************************+* Add characters not in a list to a class *+*************************************************/++/* This function is used for adding the complement of a list of horizontal or+vertical whitespace to a class. The list must be in order.++Arguments:+ classbits the bit map for characters < 256+ uchardptr points to the pointer for extra data+ options the options word+ cd contains pointers to tables etc.+ p points to row of 32-bit values, terminated by NOTACHAR++Returns: the number of < 256 characters added+ the pointer to extra data is updated+*/++static int+add_not_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr,+ int options, compile_data *cd, const pcre_uint32 *p)+{+BOOL utf = (options & PCRE_UTF8) != 0;+int n8 = 0;+if (p[0] > 0)+ n8 += add_to_class(classbits, uchardptr, options, cd, 0, p[0] - 1);+while (p[0] < NOTACHAR)+ {+ while (p[1] == p[0] + 1) p++;+ n8 += add_to_class(classbits, uchardptr, options, cd, p[0] + 1,+ (p[1] == NOTACHAR) ? (utf ? 0x10ffffu : 0xffffffffu) : p[1] - 1);+ p++;+ }+return n8;+}++++/*************************************************+* Compile one branch *+*************************************************/++/* Scan the pattern, compiling it into the a vector. If the options are+changed during the branch, the pointer is used to change the external options+bits. This function is used during the pre-compile phase when we are trying+to find out the amount of memory needed, as well as during the real compile+phase. The value of lengthptr distinguishes the two phases.++Arguments:+ optionsptr pointer to the option bits+ codeptr points to the pointer to the current code point+ ptrptr points to the current pattern pointer+ errorcodeptr points to error code variable+ firstcharptr place to put the first required character+ firstcharflagsptr place to put the first character flags, or a negative number+ reqcharptr place to put the last required character+ reqcharflagsptr place to put the last required character flags, or a negative number+ bcptr points to current branch chain+ cond_depth conditional nesting depth+ cd contains pointers to tables etc.+ lengthptr NULL during the real compile phase+ points to length accumulator during pre-compile phase++Returns: TRUE on success+ FALSE, with *errorcodeptr set non-zero on error+*/++static BOOL+compile_branch(int *optionsptr, pcre_uchar **codeptr,+ const pcre_uchar **ptrptr, int *errorcodeptr,+ pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,+ pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,+ branch_chain *bcptr, int cond_depth,+ compile_data *cd, int *lengthptr)+{+int repeat_type, op_type;+int repeat_min = 0, repeat_max = 0; /* To please picky compilers */+int bravalue = 0;+int greedy_default, greedy_non_default;+pcre_uint32 firstchar, reqchar;+pcre_int32 firstcharflags, reqcharflags;+pcre_uint32 zeroreqchar, zerofirstchar;+pcre_int32 zeroreqcharflags, zerofirstcharflags;+pcre_int32 req_caseopt, reqvary, tempreqvary;+int options = *optionsptr; /* May change dynamically */+int after_manual_callout = 0;+int length_prevgroup = 0;+register pcre_uint32 c;+int escape;+register pcre_uchar *code = *codeptr;+pcre_uchar *last_code = code;+pcre_uchar *orig_code = code;+pcre_uchar *tempcode;+BOOL inescq = FALSE;+BOOL groupsetfirstchar = FALSE;+const pcre_uchar *ptr = *ptrptr;+const pcre_uchar *tempptr;+const pcre_uchar *nestptr = NULL;+pcre_uchar *previous = NULL;+pcre_uchar *previous_callout = NULL;+size_t item_hwm_offset = 0;+pcre_uint8 classbits[32];++/* We can fish out the UTF-8 setting once and for all into a BOOL, but we+must not do this for other options (e.g. PCRE_EXTENDED) because they may change+dynamically as we process the pattern. */++#ifdef SUPPORT_UTF+/* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */+BOOL utf = (options & PCRE_UTF8) != 0;+#ifndef COMPILE_PCRE32+pcre_uchar utf_chars[6];+#endif+#else+BOOL utf = FALSE;+#endif++/* Helper variables for OP_XCLASS opcode (for characters > 255). We define+class_uchardata always so that it can be passed to add_to_class() always,+though it will not be used in non-UTF 8-bit cases. This avoids having to supply+alternative calls for the different cases. */++pcre_uchar *class_uchardata;+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+BOOL xclass;+pcre_uchar *class_uchardata_base;+#endif++#ifdef PCRE_DEBUG+if (lengthptr != NULL) DPRINTF((">> start branch\n"));+#endif++/* Set up the default and non-default settings for greediness */++greedy_default = ((options & PCRE_UNGREEDY) != 0);+greedy_non_default = greedy_default ^ 1;++/* Initialize no first byte, no required byte. REQ_UNSET means "no char+matching encountered yet". It gets changed to REQ_NONE if we hit something that+matches a non-fixed char first char; reqchar just remains unset if we never+find one.++When we hit a repeat whose minimum is zero, we may have to adjust these values+to take the zero repeat into account. This is implemented by setting them to+zerofirstbyte and zeroreqchar when such a repeat is encountered. The individual+item types that can be repeated set these backoff variables appropriately. */++firstchar = reqchar = zerofirstchar = zeroreqchar = 0;+firstcharflags = reqcharflags = zerofirstcharflags = zeroreqcharflags = REQ_UNSET;++/* The variable req_caseopt contains either the REQ_CASELESS value+or zero, according to the current setting of the caseless flag. The+REQ_CASELESS leaves the lower 28 bit empty. It is added into the+firstchar or reqchar variables to record the case status of the+value. This is used only for ASCII characters. */++req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS:0;++/* Switch on next character until the end of the branch */++for (;; ptr++)+ {+ BOOL negate_class;+ BOOL should_flip_negation;+ BOOL possessive_quantifier;+ BOOL is_quantifier;+ BOOL is_recurse;+ BOOL reset_bracount;+ int class_has_8bitchar;+ int class_one_char;+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ BOOL xclass_has_prop;+#endif+ int newoptions;+ int recno;+ int refsign;+ int skipbytes;+ pcre_uint32 subreqchar, subfirstchar;+ pcre_int32 subreqcharflags, subfirstcharflags;+ int terminator;+ unsigned int mclength;+ unsigned int tempbracount;+ pcre_uint32 ec;+ pcre_uchar mcbuffer[8];++ /* Come here to restart the loop without advancing the pointer. */++ REDO_LOOP:++ /* Get next character in the pattern */++ c = *ptr;++ /* If we are at the end of a nested substitution, revert to the outer level+ string. Nesting only happens one level deep. */++ if (c == CHAR_NULL && nestptr != NULL)+ {+ ptr = nestptr;+ nestptr = NULL;+ c = *ptr;+ }++ /* If we are in the pre-compile phase, accumulate the length used for the+ previous cycle of this loop. */++ if (lengthptr != NULL)+ {+#ifdef PCRE_DEBUG+ if (code > cd->hwm) cd->hwm = code; /* High water info */+#endif+ if (code > cd->start_workspace + cd->workspace_size -+ WORK_SIZE_SAFETY_MARGIN) /* Check for overrun */+ {+ *errorcodeptr = (code >= cd->start_workspace + cd->workspace_size)?+ ERR52 : ERR87;+ goto FAILED;+ }++ /* There is at least one situation where code goes backwards: this is the+ case of a zero quantifier after a class (e.g. [ab]{0}). At compile time,+ the class is simply eliminated. However, it is created first, so we have to+ allow memory for it. Therefore, don't ever reduce the length at this point.+ */++ if (code < last_code) code = last_code;++ /* Paranoid check for integer overflow */++ if (OFLOW_MAX - *lengthptr < code - last_code)+ {+ *errorcodeptr = ERR20;+ goto FAILED;+ }++ *lengthptr += (int)(code - last_code);+ DPRINTF(("length=%d added %d c=%c (0x%x)\n", *lengthptr,+ (int)(code - last_code), c, c));++ /* If "previous" is set and it is not at the start of the work space, move+ it back to there, in order to avoid filling up the work space. Otherwise,+ if "previous" is NULL, reset the current code pointer to the start. */++ if (previous != NULL)+ {+ if (previous > orig_code)+ {+ memmove(orig_code, previous, IN_UCHARS(code - previous));+ code -= previous - orig_code;+ previous = orig_code;+ }+ }+ else code = orig_code;++ /* Remember where this code item starts so we can pick up the length+ next time round. */++ last_code = code;+ }++ /* In the real compile phase, just check the workspace used by the forward+ reference list. */++ else if (cd->hwm > cd->start_workspace + cd->workspace_size)+ {+ *errorcodeptr = ERR52;+ goto FAILED;+ }++ /* If in \Q...\E, check for the end; if not, we have a literal. Otherwise an+ isolated \E is ignored. */++ if (c != CHAR_NULL)+ {+ if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)+ {+ inescq = FALSE;+ ptr++;+ continue;+ }+ else if (inescq)+ {+ if (previous_callout != NULL)+ {+ if (lengthptr == NULL) /* Don't attempt in pre-compile phase */+ complete_callout(previous_callout, ptr, cd);+ previous_callout = NULL;+ }+ if ((options & PCRE_AUTO_CALLOUT) != 0)+ {+ previous_callout = code;+ code = auto_callout(code, ptr, cd);+ }+ goto NORMAL_CHAR;+ }++ /* Check for the start of a \Q...\E sequence. We must do this here rather+ than later in case it is immediately followed by \E, which turns it into a+ "do nothing" sequence. */++ if (c == CHAR_BACKSLASH && ptr[1] == CHAR_Q)+ {+ inescq = TRUE;+ ptr++;+ continue;+ }+ }++ /* In extended mode, skip white space and comments. */++ if ((options & PCRE_EXTENDED) != 0)+ {+ const pcre_uchar *wscptr = ptr;+ while (MAX_255(c) && (cd->ctypes[c] & ctype_space) != 0) c = *(++ptr);+ if (c == CHAR_NUMBER_SIGN)+ {+ ptr++;+ while (*ptr != CHAR_NULL)+ {+ if (IS_NEWLINE(ptr)) /* For non-fixed-length newline cases, */+ { /* IS_NEWLINE sets cd->nllen. */+ ptr += cd->nllen;+ break;+ }+ ptr++;+#ifdef SUPPORT_UTF+ if (utf) FORWARDCHAR(ptr);+#endif+ }+ }++ /* If we skipped any characters, restart the loop. Otherwise, we didn't see+ a comment. */++ if (ptr > wscptr) goto REDO_LOOP;+ }++ /* Skip over (?# comments. We need to do this here because we want to know if+ the next thing is a quantifier, and these comments may come between an item+ and its quantifier. */++ if (c == CHAR_LEFT_PARENTHESIS && ptr[1] == CHAR_QUESTION_MARK &&+ ptr[2] == CHAR_NUMBER_SIGN)+ {+ ptr += 3;+ while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;+ if (*ptr == CHAR_NULL)+ {+ *errorcodeptr = ERR18;+ goto FAILED;+ }+ continue;+ }++ /* See if the next thing is a quantifier. */++ is_quantifier =+ c == CHAR_ASTERISK || c == CHAR_PLUS || c == CHAR_QUESTION_MARK ||+ (c == CHAR_LEFT_CURLY_BRACKET && is_counted_repeat(ptr+1));++ /* Fill in length of a previous callout, except when the next thing is a+ quantifier or when processing a property substitution string in UCP mode. */++ if (!is_quantifier && previous_callout != NULL && nestptr == NULL &&+ after_manual_callout-- <= 0)+ {+ if (lengthptr == NULL) /* Don't attempt in pre-compile phase */+ complete_callout(previous_callout, ptr, cd);+ previous_callout = NULL;+ }++ /* Create auto callout, except for quantifiers, or while processing property+ strings that are substituted for \w etc in UCP mode. */++ if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier && nestptr == NULL)+ {+ previous_callout = code;+ code = auto_callout(code, ptr, cd);+ }++ /* Process the next pattern item. */++ switch(c)+ {+ /* ===================================================================*/+ case CHAR_NULL: /* The branch terminates at string end */+ case CHAR_VERTICAL_LINE: /* or | or ) */+ case CHAR_RIGHT_PARENTHESIS:+ *firstcharptr = firstchar;+ *firstcharflagsptr = firstcharflags;+ *reqcharptr = reqchar;+ *reqcharflagsptr = reqcharflags;+ *codeptr = code;+ *ptrptr = ptr;+ if (lengthptr != NULL)+ {+ if (OFLOW_MAX - *lengthptr < code - last_code)+ {+ *errorcodeptr = ERR20;+ goto FAILED;+ }+ *lengthptr += (int)(code - last_code); /* To include callout length */+ DPRINTF((">> end branch\n"));+ }+ return TRUE;+++ /* ===================================================================*/+ /* Handle single-character metacharacters. In multiline mode, ^ disables+ the setting of any following char as a first character. */++ case CHAR_CIRCUMFLEX_ACCENT:+ previous = NULL;+ if ((options & PCRE_MULTILINE) != 0)+ {+ if (firstcharflags == REQ_UNSET)+ zerofirstcharflags = firstcharflags = REQ_NONE;+ *code++ = OP_CIRCM;+ }+ else *code++ = OP_CIRC;+ break;++ case CHAR_DOLLAR_SIGN:+ previous = NULL;+ *code++ = ((options & PCRE_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;+ break;++ /* There can never be a first char if '.' is first, whatever happens about+ repeats. The value of reqchar doesn't change either. */++ case CHAR_DOT:+ if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;+ zerofirstchar = firstchar;+ zerofirstcharflags = firstcharflags;+ zeroreqchar = reqchar;+ zeroreqcharflags = reqcharflags;+ previous = code;+ item_hwm_offset = cd->hwm - cd->start_workspace;+ *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;+ break;+++ /* ===================================================================*/+ /* Character classes. If the included characters are all < 256, we build a+ 32-byte bitmap of the permitted characters, except in the special case+ where there is only one such character. For negated classes, we build the+ map as usual, then invert it at the end. However, we use a different opcode+ so that data characters > 255 can be handled correctly.++ If the class contains characters outside the 0-255 range, a different+ opcode is compiled. It may optionally have a bit map for characters < 256,+ but those above are are explicitly listed afterwards. A flag byte tells+ whether the bitmap is present, and whether this is a negated class or not.++ In JavaScript compatibility mode, an isolated ']' causes an error. In+ default (Perl) mode, it is treated as a data character. */++ case CHAR_RIGHT_SQUARE_BRACKET:+ if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)+ {+ *errorcodeptr = ERR64;+ goto FAILED;+ }+ goto NORMAL_CHAR;++ /* In another (POSIX) regex library, the ugly syntax [[:<:]] and [[:>:]] is+ used for "start of word" and "end of word". As these are otherwise illegal+ sequences, we don't break anything by recognizing them. They are replaced+ by \b(?=\w) and \b(?<=\w) respectively. Sequences like [a[:<:]] are+ erroneous and are handled by the normal code below. */++ case CHAR_LEFT_SQUARE_BRACKET:+ if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_STARTWORD, 6) == 0)+ {+ nestptr = ptr + 7;+ ptr = sub_start_of_word;+ goto REDO_LOOP;+ }++ if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_ENDWORD, 6) == 0)+ {+ nestptr = ptr + 7;+ ptr = sub_end_of_word;+ goto REDO_LOOP;+ }++ /* Handle a real character class. */++ previous = code;+ item_hwm_offset = cd->hwm - cd->start_workspace;++ /* PCRE supports POSIX class stuff inside a class. Perl gives an error if+ they are encountered at the top level, so we'll do that too. */++ if ((ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||+ ptr[1] == CHAR_EQUALS_SIGN) &&+ check_posix_syntax(ptr, &tempptr))+ {+ *errorcodeptr = (ptr[1] == CHAR_COLON)? ERR13 : ERR31;+ goto FAILED;+ }++ /* If the first character is '^', set the negation flag and skip it. Also,+ if the first few characters (either before or after ^) are \Q\E or \E we+ skip them too. This makes for compatibility with Perl. */++ negate_class = FALSE;+ for (;;)+ {+ c = *(++ptr);+ if (c == CHAR_BACKSLASH)+ {+ if (ptr[1] == CHAR_E)+ ptr++;+ else if (STRNCMP_UC_C8(ptr + 1, STR_Q STR_BACKSLASH STR_E, 3) == 0)+ ptr += 3;+ else+ break;+ }+ else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)+ negate_class = TRUE;+ else break;+ }++ /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,+ an initial ']' is taken as a data character -- the code below handles+ that. In JS mode, [] must always fail, so generate OP_FAIL, whereas+ [^] must match any character, so generate OP_ALLANY. */++ if (c == CHAR_RIGHT_SQUARE_BRACKET &&+ (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)+ {+ *code++ = negate_class? OP_ALLANY : OP_FAIL;+ if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;+ zerofirstchar = firstchar;+ zerofirstcharflags = firstcharflags;+ break;+ }++ /* If a class contains a negative special such as \S, we need to flip the+ negation flag at the end, so that support for characters > 255 works+ correctly (they are all included in the class). */++ should_flip_negation = FALSE;++ /* Extended class (xclass) will be used when characters > 255+ might match. */++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ xclass = FALSE;+ class_uchardata = code + LINK_SIZE + 2; /* For XCLASS items */+ class_uchardata_base = class_uchardata; /* Save the start */+#endif++ /* For optimization purposes, we track some properties of the class:+ class_has_8bitchar will be non-zero if the class contains at least one <+ 256 character; class_one_char will be 1 if the class contains just one+ character; xclass_has_prop will be TRUE if unicode property checks+ are present in the class. */++ class_has_8bitchar = 0;+ class_one_char = 0;+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ xclass_has_prop = FALSE;+#endif++ /* Initialize the 32-char bit map to all zeros. We build the map in a+ temporary bit of memory, in case the class contains fewer than two+ 8-bit characters because in that case the compiled code doesn't use the bit+ map. */++ memset(classbits, 0, 32 * sizeof(pcre_uint8));++ /* Process characters until ] is reached. By writing this as a "do" it+ means that an initial ] is taken as a data character. At the start of the+ loop, c contains the first byte of the character. */++ if (c != CHAR_NULL) do+ {+ const pcre_uchar *oldptr;++#ifdef SUPPORT_UTF+ if (utf && HAS_EXTRALEN(c))+ { /* Braces are required because the */+ GETCHARLEN(c, ptr, ptr); /* macro generates multiple statements */+ }+#endif++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ /* In the pre-compile phase, accumulate the length of any extra+ data and reset the pointer. This is so that very large classes that+ contain a zillion > 255 characters no longer overwrite the work space+ (which is on the stack). We have to remember that there was XCLASS data,+ however. */++ if (class_uchardata > class_uchardata_base) xclass = TRUE;++ if (lengthptr != NULL && class_uchardata > class_uchardata_base)+ {+ *lengthptr += (int)(class_uchardata - class_uchardata_base);+ class_uchardata = class_uchardata_base;+ }+#endif++ /* Inside \Q...\E everything is literal except \E */++ if (inescq)+ {+ if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E) /* If we are at \E */+ {+ inescq = FALSE; /* Reset literal state */+ ptr++; /* Skip the 'E' */+ continue; /* Carry on with next */+ }+ goto CHECK_RANGE; /* Could be range if \E follows */+ }++ /* Handle POSIX class names. Perl allows a negation extension of the+ form [:^name:]. A square bracket that doesn't match the syntax is+ treated as a literal. We also recognize the POSIX constructions+ [.ch.] and [=ch=] ("collating elements") and fault them, as Perl+ 5.6 and 5.8 do. */++ if (c == CHAR_LEFT_SQUARE_BRACKET &&+ (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||+ ptr[1] == CHAR_EQUALS_SIGN) && check_posix_syntax(ptr, &tempptr))+ {+ BOOL local_negate = FALSE;+ int posix_class, taboffset, tabopt;+ register const pcre_uint8 *cbits = cd->cbits;+ pcre_uint8 pbits[32];++ if (ptr[1] != CHAR_COLON)+ {+ *errorcodeptr = ERR31;+ goto FAILED;+ }++ ptr += 2;+ if (*ptr == CHAR_CIRCUMFLEX_ACCENT)+ {+ local_negate = TRUE;+ should_flip_negation = TRUE; /* Note negative special */+ ptr++;+ }++ posix_class = check_posix_name(ptr, (int)(tempptr - ptr));+ if (posix_class < 0)+ {+ *errorcodeptr = ERR30;+ goto FAILED;+ }++ /* If matching is caseless, upper and lower are converted to+ alpha. This relies on the fact that the class table starts with+ alpha, lower, upper as the first 3 entries. */++ if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)+ posix_class = 0;++ /* When PCRE_UCP is set, some of the POSIX classes are converted to+ different escape sequences that use Unicode properties \p or \P. Others+ that are not available via \p or \P generate XCL_PROP/XCL_NOTPROP+ directly. */++#ifdef SUPPORT_UCP+ if ((options & PCRE_UCP) != 0)+ {+ unsigned int ptype = 0;+ int pc = posix_class + ((local_negate)? POSIX_SUBSIZE/2 : 0);++ /* The posix_substitutes table specifies which POSIX classes can be+ converted to \p or \P items. */++ if (posix_substitutes[pc] != NULL)+ {+ nestptr = tempptr + 1;+ ptr = posix_substitutes[pc] - 1;+ continue;+ }++ /* There are three other classes that generate special property calls+ that are recognized only in an XCLASS. */++ else switch(posix_class)+ {+ case PC_GRAPH:+ ptype = PT_PXGRAPH;+ /* Fall through */+ case PC_PRINT:+ if (ptype == 0) ptype = PT_PXPRINT;+ /* Fall through */+ case PC_PUNCT:+ if (ptype == 0) ptype = PT_PXPUNCT;+ *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP;+ *class_uchardata++ = ptype;+ *class_uchardata++ = 0;+ xclass_has_prop = TRUE;+ ptr = tempptr + 1;+ continue;++ /* For the other POSIX classes (ascii, cntrl, xdigit) we are going+ to fall through to the non-UCP case and build a bit map for+ characters with code points less than 256. If we are in a negated+ POSIX class, characters with code points greater than 255 must+ either all match or all not match. In the special case where we+ have not yet generated any xclass data, and this is the final item+ in the overall class, we need do nothing: later on, the opcode+ OP_NCLASS will be used to indicate that characters greater than 255+ are acceptable. If we have already seen an xclass item or one may+ follow (we have to assume that it might if this is not the end of+ the class), explicitly list all wide codepoints, which will then+ either not match or match, depending on whether the class is or is+ not negated. */++ default:+ if (local_negate &&+ (xclass || tempptr[2] != CHAR_RIGHT_SQUARE_BRACKET))+ {+ *class_uchardata++ = XCL_RANGE;+ class_uchardata += PRIV(ord2utf)(0x100, class_uchardata);+ class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);+ }+ break;+ }+ }+#endif+ /* In the non-UCP case, or when UCP makes no difference, we build the+ bit map for the POSIX class in a chunk of local store because we may be+ adding and subtracting from it, and we don't want to subtract bits that+ may be in the main map already. At the end we or the result into the+ bit map that is being built. */++ posix_class *= 3;++ /* Copy in the first table (always present) */++ memcpy(pbits, cbits + posix_class_maps[posix_class],+ 32 * sizeof(pcre_uint8));++ /* If there is a second table, add or remove it as required. */++ taboffset = posix_class_maps[posix_class + 1];+ tabopt = posix_class_maps[posix_class + 2];++ if (taboffset >= 0)+ {+ if (tabopt >= 0)+ for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];+ else+ for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];+ }++ /* Now see if we need to remove any special characters. An option+ value of 1 removes vertical space and 2 removes underscore. */++ if (tabopt < 0) tabopt = -tabopt;+ if (tabopt == 1) pbits[1] &= ~0x3c;+ else if (tabopt == 2) pbits[11] &= 0x7f;++ /* Add the POSIX table or its complement into the main table that is+ being built and we are done. */++ if (local_negate)+ for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];+ else+ for (c = 0; c < 32; c++) classbits[c] |= pbits[c];++ ptr = tempptr + 1;+ /* Every class contains at least one < 256 character. */+ class_has_8bitchar = 1;+ /* Every class contains at least two characters. */+ class_one_char = 2;+ continue; /* End of POSIX syntax handling */+ }++ /* Backslash may introduce a single character, or it may introduce one+ of the specials, which just set a flag. The sequence \b is a special+ case. Inside a class (and only there) it is treated as backspace. We+ assume that other escapes have more than one character in them, so+ speculatively set both class_has_8bitchar and class_one_char bigger+ than one. Unrecognized escapes fall through and are either treated+ as literal characters (by default), or are faulted if+ PCRE_EXTRA is set. */++ if (c == CHAR_BACKSLASH)+ {+ escape = check_escape(&ptr, &ec, errorcodeptr, cd->bracount, options,+ TRUE);+ if (*errorcodeptr != 0) goto FAILED;+ if (escape == 0) c = ec;+ else if (escape == ESC_b) c = CHAR_BS; /* \b is backspace in a class */+ else if (escape == ESC_N) /* \N is not supported in a class */+ {+ *errorcodeptr = ERR71;+ goto FAILED;+ }+ else if (escape == ESC_Q) /* Handle start of quoted string */+ {+ if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)+ {+ ptr += 2; /* avoid empty string */+ }+ else inescq = TRUE;+ continue;+ }+ else if (escape == ESC_E) continue; /* Ignore orphan \E */++ else+ {+ register const pcre_uint8 *cbits = cd->cbits;+ /* Every class contains at least two < 256 characters. */+ class_has_8bitchar++;+ /* Every class contains at least two characters. */+ class_one_char += 2;++ switch (escape)+ {+#ifdef SUPPORT_UCP+ case ESC_du: /* These are the values given for \d etc */+ case ESC_DU: /* when PCRE_UCP is set. We replace the */+ case ESC_wu: /* escape sequence with an appropriate \p */+ case ESC_WU: /* or \P to test Unicode properties instead */+ case ESC_su: /* of the default ASCII testing. */+ case ESC_SU:+ nestptr = ptr;+ ptr = substitutes[escape - ESC_DU] - 1; /* Just before substitute */+ class_has_8bitchar--; /* Undo! */+ continue;+#endif+ case ESC_d:+ for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];+ continue;++ case ESC_D:+ should_flip_negation = TRUE;+ for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];+ continue;++ case ESC_w:+ for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];+ continue;++ case ESC_W:+ should_flip_negation = TRUE;+ for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];+ continue;++ /* Perl 5.004 onwards omitted VT from \s, but restored it at Perl+ 5.18. Before PCRE 8.34, we had to preserve the VT bit if it was+ previously set by something earlier in the character class.+ Luckily, the value of CHAR_VT is 0x0b in both ASCII and EBCDIC, so+ we could just adjust the appropriate bit. From PCRE 8.34 we no+ longer treat \s and \S specially. */++ case ESC_s:+ for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];+ continue;++ case ESC_S:+ should_flip_negation = TRUE;+ for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];+ continue;++ /* The rest apply in both UCP and non-UCP cases. */++ case ESC_h:+ (void)add_list_to_class(classbits, &class_uchardata, options, cd,+ PRIV(hspace_list), NOTACHAR);+ continue;++ case ESC_H:+ (void)add_not_list_to_class(classbits, &class_uchardata, options,+ cd, PRIV(hspace_list));+ continue;++ case ESC_v:+ (void)add_list_to_class(classbits, &class_uchardata, options, cd,+ PRIV(vspace_list), NOTACHAR);+ continue;++ case ESC_V:+ (void)add_not_list_to_class(classbits, &class_uchardata, options,+ cd, PRIV(vspace_list));+ continue;++ case ESC_p:+ case ESC_P:+#ifdef SUPPORT_UCP+ {+ BOOL negated;+ unsigned int ptype = 0, pdata = 0;+ if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))+ goto FAILED;+ *class_uchardata++ = ((escape == ESC_p) != negated)?+ XCL_PROP : XCL_NOTPROP;+ *class_uchardata++ = ptype;+ *class_uchardata++ = pdata;+ xclass_has_prop = TRUE;+ class_has_8bitchar--; /* Undo! */+ continue;+ }+#else+ *errorcodeptr = ERR45;+ goto FAILED;+#endif+ /* Unrecognized escapes are faulted if PCRE is running in its+ strict mode. By default, for compatibility with Perl, they are+ treated as literals. */++ default:+ if ((options & PCRE_EXTRA) != 0)+ {+ *errorcodeptr = ERR7;+ goto FAILED;+ }+ class_has_8bitchar--; /* Undo the speculative increase. */+ class_one_char -= 2; /* Undo the speculative increase. */+ c = *ptr; /* Get the final character and fall through */+ break;+ }+ }++ /* Fall through if the escape just defined a single character (c >= 0).+ This may be greater than 256. */++ escape = 0;++ } /* End of backslash handling */++ /* A character may be followed by '-' to form a range. However, Perl does+ not permit ']' to be the end of the range. A '-' character at the end is+ treated as a literal. Perl ignores orphaned \E sequences entirely. The+ code for handling \Q and \E is messy. */++ CHECK_RANGE:+ while (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)+ {+ inescq = FALSE;+ ptr += 2;+ }+ oldptr = ptr;++ /* Remember if \r or \n were explicitly used */++ if (c == CHAR_CR || c == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;++ /* Check for range */++ if (!inescq && ptr[1] == CHAR_MINUS)+ {+ pcre_uint32 d;+ ptr += 2;+ while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E) ptr += 2;++ /* If we hit \Q (not followed by \E) at this point, go into escaped+ mode. */++ while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_Q)+ {+ ptr += 2;+ if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E)+ { ptr += 2; continue; }+ inescq = TRUE;+ break;+ }++ /* Minus (hyphen) at the end of a class is treated as a literal, so put+ back the pointer and jump to handle the character that preceded it. */++ if (*ptr == CHAR_NULL || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))+ {+ ptr = oldptr;+ goto CLASS_SINGLE_CHARACTER;+ }++ /* Otherwise, we have a potential range; pick up the next character */++#ifdef SUPPORT_UTF+ if (utf)+ { /* Braces are required because the */+ GETCHARLEN(d, ptr, ptr); /* macro generates multiple statements */+ }+ else+#endif+ d = *ptr; /* Not UTF-8 mode */++ /* The second part of a range can be a single-character escape+ sequence, but not any of the other escapes. Perl treats a hyphen as a+ literal in such circumstances. However, in Perl's warning mode, a+ warning is given, so PCRE now faults it as it is almost certainly a+ mistake on the user's part. */++ if (!inescq)+ {+ if (d == CHAR_BACKSLASH)+ {+ int descape;+ descape = check_escape(&ptr, &d, errorcodeptr, cd->bracount, options, TRUE);+ if (*errorcodeptr != 0) goto FAILED;++ /* 0 means a character was put into d; \b is backspace; any other+ special causes an error. */++ if (descape != 0)+ {+ if (descape == ESC_b) d = CHAR_BS; else+ {+ *errorcodeptr = ERR83;+ goto FAILED;+ }+ }+ }++ /* A hyphen followed by a POSIX class is treated in the same way. */++ else if (d == CHAR_LEFT_SQUARE_BRACKET &&+ (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||+ ptr[1] == CHAR_EQUALS_SIGN) &&+ check_posix_syntax(ptr, &tempptr))+ {+ *errorcodeptr = ERR83;+ goto FAILED;+ }+ }++ /* Check that the two values are in the correct order. Optimize+ one-character ranges. */++ if (d < c)+ {+ *errorcodeptr = ERR8;+ goto FAILED;+ }+ if (d == c) goto CLASS_SINGLE_CHARACTER; /* A few lines below */++ /* We have found a character range, so single character optimizations+ cannot be done anymore. Any value greater than 1 indicates that there+ is more than one character. */++ class_one_char = 2;++ /* Remember an explicit \r or \n, and add the range to the class. */++ if (d == CHAR_CR || d == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;++ class_has_8bitchar +=+ add_to_class(classbits, &class_uchardata, options, cd, c, d);++ continue; /* Go get the next char in the class */+ }++ /* Handle a single character - we can get here for a normal non-escape+ char, or after \ that introduces a single character or for an apparent+ range that isn't. Only the value 1 matters for class_one_char, so don't+ increase it if it is already 2 or more ... just in case there's a class+ with a zillion characters in it. */++ CLASS_SINGLE_CHARACTER:+ if (class_one_char < 2) class_one_char++;++ /* If xclass_has_prop is false and class_one_char is 1, we have the first+ single character in the class, and there have been no prior ranges, or+ XCLASS items generated by escapes. If this is the final character in the+ class, we can optimize by turning the item into a 1-character OP_CHAR[I]+ if it's positive, or OP_NOT[I] if it's negative. In the positive case, it+ can cause firstchar to be set. Otherwise, there can be no first char if+ this item is first, whatever repeat count may follow. In the case of+ reqchar, save the previous value for reinstating. */++ if (!inescq &&+#ifdef SUPPORT_UCP+ !xclass_has_prop &&+#endif+ class_one_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)+ {+ ptr++;+ zeroreqchar = reqchar;+ zeroreqcharflags = reqcharflags;++ if (negate_class)+ {+#ifdef SUPPORT_UCP+ int d;+#endif+ if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;+ zerofirstchar = firstchar;+ zerofirstcharflags = firstcharflags;++ /* For caseless UTF-8 mode when UCP support is available, check+ whether this character has more than one other case. If so, generate+ a special OP_NOTPROP item instead of OP_NOTI. */++#ifdef SUPPORT_UCP+ if (utf && (options & PCRE_CASELESS) != 0 &&+ (d = UCD_CASESET(c)) != 0)+ {+ *code++ = OP_NOTPROP;+ *code++ = PT_CLIST;+ *code++ = d;+ }+ else+#endif+ /* Char has only one other case, or UCP not available */++ {+ *code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)+ code += PRIV(ord2utf)(c, code);+ else+#endif+ *code++ = c;+ }++ /* We are finished with this character class */++ goto END_CLASS;+ }++ /* For a single, positive character, get the value into mcbuffer, and+ then we can handle this with the normal one-character code. */++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)+ mclength = PRIV(ord2utf)(c, mcbuffer);+ else+#endif+ {+ mcbuffer[0] = c;+ mclength = 1;+ }+ goto ONE_CHAR;+ } /* End of 1-char optimization */++ /* There is more than one character in the class, or an XCLASS item+ has been generated. Add this character to the class. */++ class_has_8bitchar +=+ add_to_class(classbits, &class_uchardata, options, cd, c, c);+ }++ /* Loop until ']' reached. This "while" is the end of the "do" far above.+ If we are at the end of an internal nested string, revert to the outer+ string. */++ while (((c = *(++ptr)) != CHAR_NULL ||+ (nestptr != NULL &&+ (ptr = nestptr, nestptr = NULL, c = *(++ptr)) != CHAR_NULL)) &&+ (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));++ /* Check for missing terminating ']' */++ if (c == CHAR_NULL)+ {+ *errorcodeptr = ERR6;+ goto FAILED;+ }++ /* We will need an XCLASS if data has been placed in class_uchardata. In+ the second phase this is a sufficient test. However, in the pre-compile+ phase, class_uchardata gets emptied to prevent workspace overflow, so it+ only if the very last character in the class needs XCLASS will it contain+ anything at this point. For this reason, xclass gets set TRUE above when+ uchar_classdata is emptied, and that's why this code is the way it is here+ instead of just doing a test on class_uchardata below. */++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ if (class_uchardata > class_uchardata_base) xclass = TRUE;+#endif++ /* If this is the first thing in the branch, there can be no first char+ setting, whatever the repeat count. Any reqchar setting must remain+ unchanged after any kind of repeat. */++ if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;+ zerofirstchar = firstchar;+ zerofirstcharflags = firstcharflags;+ zeroreqchar = reqchar;+ zeroreqcharflags = reqcharflags;++ /* If there are characters with values > 255, we have to compile an+ extended class, with its own opcode, unless there was a negated special+ such as \S in the class, and PCRE_UCP is not set, because in that case all+ characters > 255 are in the class, so any that were explicitly given as+ well can be ignored. If (when there are explicit characters > 255 that must+ be listed) there are no characters < 256, we can omit the bitmap in the+ actual compiled code. */++#ifdef SUPPORT_UTF+ if (xclass && (xclass_has_prop || !should_flip_negation ||+ (options & PCRE_UCP) != 0))+#elif !defined COMPILE_PCRE8+ if (xclass && (xclass_has_prop || !should_flip_negation))+#endif+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ {+ /* For non-UCP wide characters, in a non-negative class containing \S or+ similar (should_flip_negation is set), all characters greater than 255+ must be in the class. */++ if (+#if defined COMPILE_PCRE8+ utf &&+#endif+ should_flip_negation && !negate_class && (options & PCRE_UCP) == 0)+ {+ *class_uchardata++ = XCL_RANGE;+ if (utf) /* Will always be utf in the 8-bit library */+ {+ class_uchardata += PRIV(ord2utf)(0x100, class_uchardata);+ class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);+ }+ else /* Can only happen for the 16-bit & 32-bit libraries */+ {+#if defined COMPILE_PCRE16+ *class_uchardata++ = 0x100;+ *class_uchardata++ = 0xffffu;+#elif defined COMPILE_PCRE32+ *class_uchardata++ = 0x100;+ *class_uchardata++ = 0xffffffffu;+#endif+ }+ }++ *class_uchardata++ = XCL_END; /* Marks the end of extra data */+ *code++ = OP_XCLASS;+ code += LINK_SIZE;+ *code = negate_class? XCL_NOT:0;+ if (xclass_has_prop) *code |= XCL_HASPROP;++ /* If the map is required, move up the extra data to make room for it;+ otherwise just move the code pointer to the end of the extra data. */++ if (class_has_8bitchar > 0)+ {+ *code++ |= XCL_MAP;+ memmove(code + (32 / sizeof(pcre_uchar)), code,+ IN_UCHARS(class_uchardata - code));+ if (negate_class && !xclass_has_prop)+ for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];+ memcpy(code, classbits, 32);+ code = class_uchardata + (32 / sizeof(pcre_uchar));+ }+ else code = class_uchardata;++ /* Now fill in the complete length of the item */++ PUT(previous, 1, (int)(code - previous));+ break; /* End of class handling */+ }++ /* Even though any XCLASS list is now discarded, we must allow for+ its memory. */++ if (lengthptr != NULL)+ *lengthptr += (int)(class_uchardata - class_uchardata_base);+#endif++ /* If there are no characters > 255, or they are all to be included or+ excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the+ whole class was negated and whether there were negative specials such as \S+ (non-UCP) in the class. Then copy the 32-byte map into the code vector,+ negating it if necessary. */++ *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;+ if (lengthptr == NULL) /* Save time in the pre-compile phase */+ {+ if (negate_class)+ for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];+ memcpy(code, classbits, 32);+ }+ code += 32 / sizeof(pcre_uchar);++ END_CLASS:+ break;+++ /* ===================================================================*/+ /* Various kinds of repeat; '{' is not necessarily a quantifier, but this+ has been tested above. */++ case CHAR_LEFT_CURLY_BRACKET:+ if (!is_quantifier) goto NORMAL_CHAR;+ ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);+ if (*errorcodeptr != 0) goto FAILED;+ goto REPEAT;++ case CHAR_ASTERISK:+ repeat_min = 0;+ repeat_max = -1;+ goto REPEAT;++ case CHAR_PLUS:+ repeat_min = 1;+ repeat_max = -1;+ goto REPEAT;++ case CHAR_QUESTION_MARK:+ repeat_min = 0;+ repeat_max = 1;++ REPEAT:+ if (previous == NULL)+ {+ *errorcodeptr = ERR9;+ goto FAILED;+ }++ if (repeat_min == 0)+ {+ firstchar = zerofirstchar; /* Adjust for zero repeat */+ firstcharflags = zerofirstcharflags;+ reqchar = zeroreqchar; /* Ditto */+ reqcharflags = zeroreqcharflags;+ }++ /* Remember whether this is a variable length repeat */++ reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;++ op_type = 0; /* Default single-char op codes */+ possessive_quantifier = FALSE; /* Default not possessive quantifier */++ /* Save start of previous item, in case we have to move it up in order to+ insert something before it. */++ tempcode = previous;++ /* Before checking for a possessive quantifier, we must skip over+ whitespace and comments in extended mode because Perl allows white space at+ this point. */++ if ((options & PCRE_EXTENDED) != 0)+ {+ const pcre_uchar *p = ptr + 1;+ for (;;)+ {+ while (MAX_255(*p) && (cd->ctypes[*p] & ctype_space) != 0) p++;+ if (*p != CHAR_NUMBER_SIGN) break;+ p++;+ while (*p != CHAR_NULL)+ {+ if (IS_NEWLINE(p)) /* For non-fixed-length newline cases, */+ { /* IS_NEWLINE sets cd->nllen. */+ p += cd->nllen;+ break;+ }+ p++;+#ifdef SUPPORT_UTF+ if (utf) FORWARDCHAR(p);+#endif+ } /* Loop for comment characters */+ } /* Loop for multiple comments */+ ptr = p - 1; /* Character before the next significant one. */+ }++ /* We also need to skip over (?# comments, which are not dependent on+ extended mode. */++ if (ptr[1] == CHAR_LEFT_PARENTHESIS && ptr[2] == CHAR_QUESTION_MARK &&+ ptr[3] == CHAR_NUMBER_SIGN)+ {+ ptr += 4;+ while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;+ if (*ptr == CHAR_NULL)+ {+ *errorcodeptr = ERR18;+ goto FAILED;+ }+ }++ /* If the next character is '+', we have a possessive quantifier. This+ implies greediness, whatever the setting of the PCRE_UNGREEDY option.+ If the next character is '?' this is a minimizing repeat, by default,+ but if PCRE_UNGREEDY is set, it works the other way round. We change the+ repeat type to the non-default. */++ if (ptr[1] == CHAR_PLUS)+ {+ repeat_type = 0; /* Force greedy */+ possessive_quantifier = TRUE;+ ptr++;+ }+ else if (ptr[1] == CHAR_QUESTION_MARK)+ {+ repeat_type = greedy_non_default;+ ptr++;+ }+ else repeat_type = greedy_default;++ /* If previous was a recursion call, wrap it in atomic brackets so that+ previous becomes the atomic group. All recursions were so wrapped in the+ past, but it no longer happens for non-repeated recursions. In fact, the+ repeated ones could be re-implemented independently so as not to need this,+ but for the moment we rely on the code for repeating groups. */++ if (*previous == OP_RECURSE)+ {+ memmove(previous + 1 + LINK_SIZE, previous, IN_UCHARS(1 + LINK_SIZE));+ *previous = OP_ONCE;+ PUT(previous, 1, 2 + 2*LINK_SIZE);+ previous[2 + 2*LINK_SIZE] = OP_KET;+ PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);+ code += 2 + 2 * LINK_SIZE;+ length_prevgroup = 3 + 3*LINK_SIZE;++ /* When actually compiling, we need to check whether this was a forward+ reference, and if so, adjust the offset. */++ if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)+ {+ int offset = GET(cd->hwm, -LINK_SIZE);+ if (offset == previous + 1 - cd->start_code)+ PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);+ }+ }++ /* Now handle repetition for the different types of item. */++ /* If previous was a character or negated character match, abolish the item+ and generate a repeat item instead. If a char item has a minimum of more+ than one, ensure that it is set in reqchar - it might not be if a sequence+ such as x{3} is the first thing in a branch because the x will have gone+ into firstchar instead. */++ if (*previous == OP_CHAR || *previous == OP_CHARI+ || *previous == OP_NOT || *previous == OP_NOTI)+ {+ switch (*previous)+ {+ default: /* Make compiler happy. */+ case OP_CHAR: op_type = OP_STAR - OP_STAR; break;+ case OP_CHARI: op_type = OP_STARI - OP_STAR; break;+ case OP_NOT: op_type = OP_NOTSTAR - OP_STAR; break;+ case OP_NOTI: op_type = OP_NOTSTARI - OP_STAR; break;+ }++ /* Deal with UTF characters that take up more than one character. It's+ easier to write this out separately than try to macrify it. Use c to+ hold the length of the character in bytes, plus UTF_LENGTH to flag that+ it's a length rather than a small character. */++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf && NOT_FIRSTCHAR(code[-1]))+ {+ pcre_uchar *lastchar = code - 1;+ BACKCHAR(lastchar);+ c = (int)(code - lastchar); /* Length of UTF-8 character */+ memcpy(utf_chars, lastchar, IN_UCHARS(c)); /* Save the char */+ c |= UTF_LENGTH; /* Flag c as a length */+ }+ else+#endif /* SUPPORT_UTF */++ /* Handle the case of a single charater - either with no UTF support, or+ with UTF disabled, or for a single character UTF character. */+ {+ c = code[-1];+ if (*previous <= OP_CHARI && repeat_min > 1)+ {+ reqchar = c;+ reqcharflags = req_caseopt | cd->req_varyopt;+ }+ }++ goto OUTPUT_SINGLE_REPEAT; /* Code shared with single character types */+ }++ /* If previous was a character type match (\d or similar), abolish it and+ create a suitable repeat item. The code is shared with single-character+ repeats by setting op_type to add a suitable offset into repeat_type. Note+ the the Unicode property types will be present only when SUPPORT_UCP is+ defined, but we don't wrap the little bits of code here because it just+ makes it horribly messy. */++ else if (*previous < OP_EODN)+ {+ pcre_uchar *oldcode;+ int prop_type, prop_value;+ op_type = OP_TYPESTAR - OP_STAR; /* Use type opcodes */+ c = *previous;++ OUTPUT_SINGLE_REPEAT:+ if (*previous == OP_PROP || *previous == OP_NOTPROP)+ {+ prop_type = previous[1];+ prop_value = previous[2];+ }+ else prop_type = prop_value = -1;++ oldcode = code;+ code = previous; /* Usually overwrite previous item */++ /* If the maximum is zero then the minimum must also be zero; Perl allows+ this case, so we do too - by simply omitting the item altogether. */++ if (repeat_max == 0) goto END_REPEAT;++ /* Combine the op_type with the repeat_type */++ repeat_type += op_type;++ /* A minimum of zero is handled either as the special case * or ?, or as+ an UPTO, with the maximum given. */++ if (repeat_min == 0)+ {+ if (repeat_max == -1) *code++ = OP_STAR + repeat_type;+ else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;+ else+ {+ *code++ = OP_UPTO + repeat_type;+ PUT2INC(code, 0, repeat_max);+ }+ }++ /* A repeat minimum of 1 is optimized into some special cases. If the+ maximum is unlimited, we use OP_PLUS. Otherwise, the original item is+ left in place and, if the maximum is greater than 1, we use OP_UPTO with+ one less than the maximum. */++ else if (repeat_min == 1)+ {+ if (repeat_max == -1)+ *code++ = OP_PLUS + repeat_type;+ else+ {+ code = oldcode; /* leave previous item in place */+ if (repeat_max == 1) goto END_REPEAT;+ *code++ = OP_UPTO + repeat_type;+ PUT2INC(code, 0, repeat_max - 1);+ }+ }++ /* The case {n,n} is just an EXACT, while the general case {n,m} is+ handled as an EXACT followed by an UPTO. */++ else+ {+ *code++ = OP_EXACT + op_type; /* NB EXACT doesn't have repeat_type */+ PUT2INC(code, 0, repeat_min);++ /* If the maximum is unlimited, insert an OP_STAR. Before doing so,+ we have to insert the character for the previous code. For a repeated+ Unicode property match, there are two extra bytes that define the+ required property. In UTF-8 mode, long characters have their length in+ c, with the UTF_LENGTH bit as a flag. */++ if (repeat_max < 0)+ {+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf && (c & UTF_LENGTH) != 0)+ {+ memcpy(code, utf_chars, IN_UCHARS(c & 7));+ code += c & 7;+ }+ else+#endif+ {+ *code++ = c;+ if (prop_type >= 0)+ {+ *code++ = prop_type;+ *code++ = prop_value;+ }+ }+ *code++ = OP_STAR + repeat_type;+ }++ /* Else insert an UPTO if the max is greater than the min, again+ preceded by the character, for the previously inserted code. If the+ UPTO is just for 1 instance, we can use QUERY instead. */++ else if (repeat_max != repeat_min)+ {+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf && (c & UTF_LENGTH) != 0)+ {+ memcpy(code, utf_chars, IN_UCHARS(c & 7));+ code += c & 7;+ }+ else+#endif+ *code++ = c;+ if (prop_type >= 0)+ {+ *code++ = prop_type;+ *code++ = prop_value;+ }+ repeat_max -= repeat_min;++ if (repeat_max == 1)+ {+ *code++ = OP_QUERY + repeat_type;+ }+ else+ {+ *code++ = OP_UPTO + repeat_type;+ PUT2INC(code, 0, repeat_max);+ }+ }+ }++ /* The character or character type itself comes last in all cases. */++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf && (c & UTF_LENGTH) != 0)+ {+ memcpy(code, utf_chars, IN_UCHARS(c & 7));+ code += c & 7;+ }+ else+#endif+ *code++ = c;++ /* For a repeated Unicode property match, there are two extra bytes that+ define the required property. */++#ifdef SUPPORT_UCP+ if (prop_type >= 0)+ {+ *code++ = prop_type;+ *code++ = prop_value;+ }+#endif+ }++ /* If previous was a character class or a back reference, we put the repeat+ stuff after it, but just skip the item if the repeat was {0,0}. */++ else if (*previous == OP_CLASS || *previous == OP_NCLASS ||+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ *previous == OP_XCLASS ||+#endif+ *previous == OP_REF || *previous == OP_REFI ||+ *previous == OP_DNREF || *previous == OP_DNREFI)+ {+ if (repeat_max == 0)+ {+ code = previous;+ goto END_REPEAT;+ }++ if (repeat_min == 0 && repeat_max == -1)+ *code++ = OP_CRSTAR + repeat_type;+ else if (repeat_min == 1 && repeat_max == -1)+ *code++ = OP_CRPLUS + repeat_type;+ else if (repeat_min == 0 && repeat_max == 1)+ *code++ = OP_CRQUERY + repeat_type;+ else+ {+ *code++ = OP_CRRANGE + repeat_type;+ PUT2INC(code, 0, repeat_min);+ if (repeat_max == -1) repeat_max = 0; /* 2-byte encoding for max */+ PUT2INC(code, 0, repeat_max);+ }+ }++ /* If previous was a bracket group, we may have to replicate it in certain+ cases. Note that at this point we can encounter only the "basic" bracket+ opcodes such as BRA and CBRA, as this is the place where they get converted+ into the more special varieties such as BRAPOS and SBRA. A test for >=+ OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK,+ ASSERTBACK_NOT, ONCE, ONCE_NC, BRA, BRAPOS, CBRA, CBRAPOS, and COND.+ Originally, PCRE did not allow repetition of assertions, but now it does,+ for Perl compatibility. */++ else if (*previous >= OP_ASSERT && *previous <= OP_COND)+ {+ register int i;+ int len = (int)(code - previous);+ size_t base_hwm_offset = item_hwm_offset;+ pcre_uchar *bralink = NULL;+ pcre_uchar *brazeroptr = NULL;++ /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so+ we just ignore the repeat. */++ if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)+ goto END_REPEAT;++ /* There is no sense in actually repeating assertions. The only potential+ use of repetition is in cases when the assertion is optional. Therefore,+ if the minimum is greater than zero, just ignore the repeat. If the+ maximum is not zero or one, set it to 1. */++ if (*previous < OP_ONCE) /* Assertion */+ {+ if (repeat_min > 0) goto END_REPEAT;+ if (repeat_max < 0 || repeat_max > 1) repeat_max = 1;+ }++ /* The case of a zero minimum is special because of the need to stick+ OP_BRAZERO in front of it, and because the group appears once in the+ data, whereas in other cases it appears the minimum number of times. For+ this reason, it is simplest to treat this case separately, as otherwise+ the code gets far too messy. There are several special subcases when the+ minimum is zero. */++ if (repeat_min == 0)+ {+ /* If the maximum is also zero, we used to just omit the group from the+ output altogether, like this:++ ** if (repeat_max == 0)+ ** {+ ** code = previous;+ ** goto END_REPEAT;+ ** }++ However, that fails when a group or a subgroup within it is referenced+ as a subroutine from elsewhere in the pattern, so now we stick in+ OP_SKIPZERO in front of it so that it is skipped on execution. As we+ don't have a list of which groups are referenced, we cannot do this+ selectively.++ If the maximum is 1 or unlimited, we just have to stick in the BRAZERO+ and do no more at this point. However, we do need to adjust any+ OP_RECURSE calls inside the group that refer to the group itself or any+ internal or forward referenced group, because the offset is from the+ start of the whole regex. Temporarily terminate the pattern while doing+ this. */++ if (repeat_max <= 1) /* Covers 0, 1, and unlimited */+ {+ *code = OP_END;+ adjust_recurse(previous, 1, utf, cd, item_hwm_offset);+ memmove(previous + 1, previous, IN_UCHARS(len));+ code++;+ if (repeat_max == 0)+ {+ *previous++ = OP_SKIPZERO;+ goto END_REPEAT;+ }+ brazeroptr = previous; /* Save for possessive optimizing */+ *previous++ = OP_BRAZERO + repeat_type;+ }++ /* If the maximum is greater than 1 and limited, we have to replicate+ in a nested fashion, sticking OP_BRAZERO before each set of brackets.+ The first one has to be handled carefully because it's the original+ copy, which has to be moved up. The remainder can be handled by code+ that is common with the non-zero minimum case below. We have to+ adjust the value or repeat_max, since one less copy is required. Once+ again, we may have to adjust any OP_RECURSE calls inside the group. */++ else+ {+ int offset;+ *code = OP_END;+ adjust_recurse(previous, 2 + LINK_SIZE, utf, cd, item_hwm_offset);+ memmove(previous + 2 + LINK_SIZE, previous, IN_UCHARS(len));+ code += 2 + LINK_SIZE;+ *previous++ = OP_BRAZERO + repeat_type;+ *previous++ = OP_BRA;++ /* We chain together the bracket offset fields that have to be+ filled in later when the ends of the brackets are reached. */++ offset = (bralink == NULL)? 0 : (int)(previous - bralink);+ bralink = previous;+ PUTINC(previous, 0, offset);+ }++ repeat_max--;+ }++ /* If the minimum is greater than zero, replicate the group as many+ times as necessary, and adjust the maximum to the number of subsequent+ copies that we need. If we set a first char from the group, and didn't+ set a required char, copy the latter from the former. If there are any+ forward reference subroutine calls in the group, there will be entries on+ the workspace list; replicate these with an appropriate increment. */++ else+ {+ if (repeat_min > 1)+ {+ /* In the pre-compile phase, we don't actually do the replication. We+ just adjust the length as if we had. Do some paranoid checks for+ potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit+ integer type when available, otherwise double. */++ if (lengthptr != NULL)+ {+ int delta = (repeat_min - 1)*length_prevgroup;+ if ((INT64_OR_DOUBLE)(repeat_min - 1)*+ (INT64_OR_DOUBLE)length_prevgroup >+ (INT64_OR_DOUBLE)INT_MAX ||+ OFLOW_MAX - *lengthptr < delta)+ {+ *errorcodeptr = ERR20;+ goto FAILED;+ }+ *lengthptr += delta;+ }++ /* This is compiling for real. If there is a set first byte for+ the group, and we have not yet set a "required byte", set it. Make+ sure there is enough workspace for copying forward references before+ doing the copy. */++ else+ {+ if (groupsetfirstchar && reqcharflags < 0)+ {+ reqchar = firstchar;+ reqcharflags = firstcharflags;+ }++ for (i = 1; i < repeat_min; i++)+ {+ pcre_uchar *hc;+ size_t this_hwm_offset = cd->hwm - cd->start_workspace;+ memcpy(code, previous, IN_UCHARS(len));++ while (cd->hwm > cd->start_workspace + cd->workspace_size -+ WORK_SIZE_SAFETY_MARGIN -+ (this_hwm_offset - base_hwm_offset))+ {+ *errorcodeptr = expand_workspace(cd);+ if (*errorcodeptr != 0) goto FAILED;+ }++ for (hc = (pcre_uchar *)cd->start_workspace + base_hwm_offset;+ hc < (pcre_uchar *)cd->start_workspace + this_hwm_offset;+ hc += LINK_SIZE)+ {+ PUT(cd->hwm, 0, GET(hc, 0) + len);+ cd->hwm += LINK_SIZE;+ }+ base_hwm_offset = this_hwm_offset;+ code += len;+ }+ }+ }++ if (repeat_max > 0) repeat_max -= repeat_min;+ }++ /* This code is common to both the zero and non-zero minimum cases. If+ the maximum is limited, it replicates the group in a nested fashion,+ remembering the bracket starts on a stack. In the case of a zero minimum,+ the first one was set up above. In all cases the repeat_max now specifies+ the number of additional copies needed. Again, we must remember to+ replicate entries on the forward reference list. */++ if (repeat_max >= 0)+ {+ /* In the pre-compile phase, we don't actually do the replication. We+ just adjust the length as if we had. For each repetition we must add 1+ to the length for BRAZERO and for all but the last repetition we must+ add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some+ paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is+ a 64-bit integer type when available, otherwise double. */++ if (lengthptr != NULL && repeat_max > 0)+ {+ int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -+ 2 - 2*LINK_SIZE; /* Last one doesn't nest */+ if ((INT64_OR_DOUBLE)repeat_max *+ (INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)+ > (INT64_OR_DOUBLE)INT_MAX ||+ OFLOW_MAX - *lengthptr < delta)+ {+ *errorcodeptr = ERR20;+ goto FAILED;+ }+ *lengthptr += delta;+ }++ /* This is compiling for real */++ else for (i = repeat_max - 1; i >= 0; i--)+ {+ pcre_uchar *hc;+ size_t this_hwm_offset = cd->hwm - cd->start_workspace;++ *code++ = OP_BRAZERO + repeat_type;++ /* All but the final copy start a new nesting, maintaining the+ chain of brackets outstanding. */++ if (i != 0)+ {+ int offset;+ *code++ = OP_BRA;+ offset = (bralink == NULL)? 0 : (int)(code - bralink);+ bralink = code;+ PUTINC(code, 0, offset);+ }++ memcpy(code, previous, IN_UCHARS(len));++ /* Ensure there is enough workspace for forward references before+ copying them. */++ while (cd->hwm > cd->start_workspace + cd->workspace_size -+ WORK_SIZE_SAFETY_MARGIN -+ (this_hwm_offset - base_hwm_offset))+ {+ *errorcodeptr = expand_workspace(cd);+ if (*errorcodeptr != 0) goto FAILED;+ }++ for (hc = (pcre_uchar *)cd->start_workspace + base_hwm_offset;+ hc < (pcre_uchar *)cd->start_workspace + this_hwm_offset;+ hc += LINK_SIZE)+ {+ PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));+ cd->hwm += LINK_SIZE;+ }+ base_hwm_offset = this_hwm_offset;+ code += len;+ }++ /* Now chain through the pending brackets, and fill in their length+ fields (which are holding the chain links pro tem). */++ while (bralink != NULL)+ {+ int oldlinkoffset;+ int offset = (int)(code - bralink + 1);+ pcre_uchar *bra = code - offset;+ oldlinkoffset = GET(bra, 1);+ bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;+ *code++ = OP_KET;+ PUTINC(code, 0, offset);+ PUT(bra, 1, offset);+ }+ }++ /* If the maximum is unlimited, set a repeater in the final copy. For+ ONCE brackets, that's all we need to do. However, possessively repeated+ ONCE brackets can be converted into non-capturing brackets, as the+ behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to+ deal with possessive ONCEs specially.++ Otherwise, when we are doing the actual compile phase, check to see+ whether this group is one that could match an empty string. If so,+ convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so+ that runtime checking can be done. [This check is also applied to ONCE+ groups at runtime, but in a different way.]++ Then, if the quantifier was possessive and the bracket is not a+ conditional, we convert the BRA code to the POS form, and the KET code to+ KETRPOS. (It turns out to be convenient at runtime to detect this kind of+ subpattern at both the start and at the end.) The use of special opcodes+ makes it possible to reduce greatly the stack usage in pcre_exec(). If+ the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO.++ Then, if the minimum number of matches is 1 or 0, cancel the possessive+ flag so that the default action below, of wrapping everything inside+ atomic brackets, does not happen. When the minimum is greater than 1,+ there will be earlier copies of the group, and so we still have to wrap+ the whole thing. */++ else+ {+ pcre_uchar *ketcode = code - 1 - LINK_SIZE;+ pcre_uchar *bracode = ketcode - GET(ketcode, 1);++ /* Convert possessive ONCE brackets to non-capturing */++ if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) &&+ possessive_quantifier) *bracode = OP_BRA;++ /* For non-possessive ONCE brackets, all we need to do is to+ set the KET. */++ if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC)+ *ketcode = OP_KETRMAX + repeat_type;++ /* Handle non-ONCE brackets and possessive ONCEs (which have been+ converted to non-capturing above). */++ else+ {+ /* In the compile phase, check for empty string matching. */++ if (lengthptr == NULL)+ {+ pcre_uchar *scode = bracode;+ do+ {+ if (could_be_empty_branch(scode, ketcode, utf, cd, NULL))+ {+ *bracode += OP_SBRA - OP_BRA;+ break;+ }+ scode += GET(scode, 1);+ }+ while (*scode == OP_ALT);+ }++ /* A conditional group with only one branch has an implicit empty+ alternative branch. */++ if (*bracode == OP_COND && bracode[GET(bracode,1)] != OP_ALT)+ *bracode = OP_SCOND;++ /* Handle possessive quantifiers. */++ if (possessive_quantifier)+ {+ /* For COND brackets, we wrap the whole thing in a possessively+ repeated non-capturing bracket, because we have not invented POS+ versions of the COND opcodes. Because we are moving code along, we+ must ensure that any pending recursive references are updated. */++ if (*bracode == OP_COND || *bracode == OP_SCOND)+ {+ int nlen = (int)(code - bracode);+ *code = OP_END;+ adjust_recurse(bracode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);+ memmove(bracode + 1 + LINK_SIZE, bracode, IN_UCHARS(nlen));+ code += 1 + LINK_SIZE;+ nlen += 1 + LINK_SIZE;+ *bracode = (*bracode == OP_COND)? OP_BRAPOS : OP_SBRAPOS;+ *code++ = OP_KETRPOS;+ PUTINC(code, 0, nlen);+ PUT(bracode, 1, nlen);+ }++ /* For non-COND brackets, we modify the BRA code and use KETRPOS. */++ else+ {+ *bracode += 1; /* Switch to xxxPOS opcodes */+ *ketcode = OP_KETRPOS;+ }++ /* If the minimum is zero, mark it as possessive, then unset the+ possessive flag when the minimum is 0 or 1. */++ if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;+ if (repeat_min < 2) possessive_quantifier = FALSE;+ }++ /* Non-possessive quantifier */++ else *ketcode = OP_KETRMAX + repeat_type;+ }+ }+ }++ /* If previous is OP_FAIL, it was generated by an empty class [] in+ JavaScript mode. The other ways in which OP_FAIL can be generated, that is+ by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"+ error above. We can just ignore the repeat in JS case. */++ else if (*previous == OP_FAIL) goto END_REPEAT;++ /* Else there's some kind of shambles */++ else+ {+ *errorcodeptr = ERR11;+ goto FAILED;+ }++ /* If the character following a repeat is '+', possessive_quantifier is+ TRUE. For some opcodes, there are special alternative opcodes for this+ case. For anything else, we wrap the entire repeated item inside OP_ONCE+ brackets. Logically, the '+' notation is just syntactic sugar, taken from+ Sun's Java package, but the special opcodes can optimize it.++ Some (but not all) possessively repeated subpatterns have already been+ completely handled in the code just above. For them, possessive_quantifier+ is always FALSE at this stage. Note that the repeated item starts at+ tempcode, not at previous, which might be the first part of a string whose+ (former) last char we repeated. */++ if (possessive_quantifier)+ {+ int len;++ /* Possessifying an EXACT quantifier has no effect, so we can ignore it.+ However, QUERY, STAR, or UPTO may follow (for quantifiers such as {5,6},+ {5,}, or {5,10}). We skip over an EXACT item; if the length of what+ remains is greater than zero, there's a further opcode that can be+ handled. If not, do nothing, leaving the EXACT alone. */++ switch(*tempcode)+ {+ case OP_TYPEEXACT:+ tempcode += PRIV(OP_lengths)[*tempcode] ++ ((tempcode[1 + IMM2_SIZE] == OP_PROP+ || tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);+ break;++ /* CHAR opcodes are used for exacts whose count is 1. */++ case OP_CHAR:+ case OP_CHARI:+ case OP_NOT:+ case OP_NOTI:+ case OP_EXACT:+ case OP_EXACTI:+ case OP_NOTEXACT:+ case OP_NOTEXACTI:+ tempcode += PRIV(OP_lengths)[*tempcode];+#ifdef SUPPORT_UTF+ if (utf && HAS_EXTRALEN(tempcode[-1]))+ tempcode += GET_EXTRALEN(tempcode[-1]);+#endif+ break;++ /* For the class opcodes, the repeat operator appears at the end;+ adjust tempcode to point to it. */++ case OP_CLASS:+ case OP_NCLASS:+ tempcode += 1 + 32/sizeof(pcre_uchar);+ break;++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ tempcode += GET(tempcode, 1);+ break;+#endif+ }++ /* If tempcode is equal to code (which points to the end of the repeated+ item), it means we have skipped an EXACT item but there is no following+ QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In+ all other cases, tempcode will be pointing to the repeat opcode, and will+ be less than code, so the value of len will be greater than 0. */++ len = (int)(code - tempcode);+ if (len > 0)+ {+ unsigned int repcode = *tempcode;++ /* There is a table for possessifying opcodes, all of which are less+ than OP_CALLOUT. A zero entry means there is no possessified version.+ */++ if (repcode < OP_CALLOUT && opcode_possessify[repcode] > 0)+ *tempcode = opcode_possessify[repcode];++ /* For opcode without a special possessified version, wrap the item in+ ONCE brackets. Because we are moving code along, we must ensure that any+ pending recursive references are updated. */++ else+ {+ *code = OP_END;+ adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);+ memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));+ code += 1 + LINK_SIZE;+ len += 1 + LINK_SIZE;+ tempcode[0] = OP_ONCE;+ *code++ = OP_KET;+ PUTINC(code, 0, len);+ PUT(tempcode, 1, len);+ }+ }++#ifdef NEVER+ if (len > 0) switch (*tempcode)+ {+ case OP_STAR: *tempcode = OP_POSSTAR; break;+ case OP_PLUS: *tempcode = OP_POSPLUS; break;+ case OP_QUERY: *tempcode = OP_POSQUERY; break;+ case OP_UPTO: *tempcode = OP_POSUPTO; break;++ case OP_STARI: *tempcode = OP_POSSTARI; break;+ case OP_PLUSI: *tempcode = OP_POSPLUSI; break;+ case OP_QUERYI: *tempcode = OP_POSQUERYI; break;+ case OP_UPTOI: *tempcode = OP_POSUPTOI; break;++ case OP_NOTSTAR: *tempcode = OP_NOTPOSSTAR; break;+ case OP_NOTPLUS: *tempcode = OP_NOTPOSPLUS; break;+ case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;+ case OP_NOTUPTO: *tempcode = OP_NOTPOSUPTO; break;++ case OP_NOTSTARI: *tempcode = OP_NOTPOSSTARI; break;+ case OP_NOTPLUSI: *tempcode = OP_NOTPOSPLUSI; break;+ case OP_NOTQUERYI: *tempcode = OP_NOTPOSQUERYI; break;+ case OP_NOTUPTOI: *tempcode = OP_NOTPOSUPTOI; break;++ case OP_TYPESTAR: *tempcode = OP_TYPEPOSSTAR; break;+ case OP_TYPEPLUS: *tempcode = OP_TYPEPOSPLUS; break;+ case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;+ case OP_TYPEUPTO: *tempcode = OP_TYPEPOSUPTO; break;++ case OP_CRSTAR: *tempcode = OP_CRPOSSTAR; break;+ case OP_CRPLUS: *tempcode = OP_CRPOSPLUS; break;+ case OP_CRQUERY: *tempcode = OP_CRPOSQUERY; break;+ case OP_CRRANGE: *tempcode = OP_CRPOSRANGE; break;++ /* Because we are moving code along, we must ensure that any+ pending recursive references are updated. */++ default:+ *code = OP_END;+ adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);+ memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));+ code += 1 + LINK_SIZE;+ len += 1 + LINK_SIZE;+ tempcode[0] = OP_ONCE;+ *code++ = OP_KET;+ PUTINC(code, 0, len);+ PUT(tempcode, 1, len);+ break;+ }+#endif+ }++ /* In all case we no longer have a previous item. We also set the+ "follows varying string" flag for subsequently encountered reqchars if+ it isn't already set and we have just passed a varying length item. */++ END_REPEAT:+ previous = NULL;+ cd->req_varyopt |= reqvary;+ break;+++ /* ===================================================================*/+ /* Start of nested parenthesized sub-expression, or comment or lookahead or+ lookbehind or option setting or condition or all the other extended+ parenthesis forms. */++ case CHAR_LEFT_PARENTHESIS:+ ptr++;++ /* Now deal with various "verbs" that can be introduced by '*'. */++ if (ptr[0] == CHAR_ASTERISK && (ptr[1] == ':'+ || (MAX_255(ptr[1]) && ((cd->ctypes[ptr[1]] & ctype_letter) != 0))))+ {+ int i, namelen;+ int arglen = 0;+ const char *vn = verbnames;+ const pcre_uchar *name = ptr + 1;+ const pcre_uchar *arg = NULL;+ previous = NULL;+ ptr++;+ while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;+ namelen = (int)(ptr - name);++ /* It appears that Perl allows any characters whatsoever, other than+ a closing parenthesis, to appear in arguments, so we no longer insist on+ letters, digits, and underscores. */++ if (*ptr == CHAR_COLON)+ {+ arg = ++ptr;+ while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;+ arglen = (int)(ptr - arg);+ if ((unsigned int)arglen > MAX_MARK)+ {+ *errorcodeptr = ERR75;+ goto FAILED;+ }+ }++ if (*ptr != CHAR_RIGHT_PARENTHESIS)+ {+ *errorcodeptr = ERR60;+ goto FAILED;+ }++ /* Scan the table of verb names */++ for (i = 0; i < verbcount; i++)+ {+ if (namelen == verbs[i].len &&+ STRNCMP_UC_C8(name, vn, namelen) == 0)+ {+ int setverb;++ /* Check for open captures before ACCEPT and convert it to+ ASSERT_ACCEPT if in an assertion. */++ if (verbs[i].op == OP_ACCEPT)+ {+ open_capitem *oc;+ if (arglen != 0)+ {+ *errorcodeptr = ERR59;+ goto FAILED;+ }+ cd->had_accept = TRUE;+ for (oc = cd->open_caps; oc != NULL; oc = oc->next)+ {+ if (lengthptr != NULL)+ {+#ifdef COMPILE_PCRE8+ *lengthptr += 1 + IMM2_SIZE;+#elif defined COMPILE_PCRE16+ *lengthptr += 2 + IMM2_SIZE;+#elif defined COMPILE_PCRE32+ *lengthptr += 4 + IMM2_SIZE;+#endif+ }+ else+ {+ *code++ = OP_CLOSE;+ PUT2INC(code, 0, oc->number);+ }+ }+ setverb = *code++ =+ (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;++ /* Do not set firstchar after *ACCEPT */+ if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;+ }++ /* Handle other cases with/without an argument */++ else if (arglen == 0)+ {+ if (verbs[i].op < 0) /* Argument is mandatory */+ {+ *errorcodeptr = ERR66;+ goto FAILED;+ }+ setverb = *code++ = verbs[i].op;+ }++ else+ {+ if (verbs[i].op_arg < 0) /* Argument is forbidden */+ {+ *errorcodeptr = ERR59;+ goto FAILED;+ }+ setverb = *code++ = verbs[i].op_arg;+ if (lengthptr != NULL) /* In pass 1 just add in the length */+ { /* to avoid potential workspace */+ *lengthptr += arglen; /* overflow. */+ *code++ = 0;+ }+ else+ {+ *code++ = arglen;+ memcpy(code, arg, IN_UCHARS(arglen));+ code += arglen;+ }+ *code++ = 0;+ }++ switch (setverb)+ {+ case OP_THEN:+ case OP_THEN_ARG:+ cd->external_flags |= PCRE_HASTHEN;+ break;++ case OP_PRUNE:+ case OP_PRUNE_ARG:+ case OP_SKIP:+ case OP_SKIP_ARG:+ cd->had_pruneorskip = TRUE;+ break;+ }++ break; /* Found verb, exit loop */+ }++ vn += verbs[i].len + 1;+ }++ if (i < verbcount) continue; /* Successfully handled a verb */+ *errorcodeptr = ERR60; /* Verb not recognized */+ goto FAILED;+ }++ /* Initialize for "real" parentheses */++ newoptions = options;+ skipbytes = 0;+ bravalue = OP_CBRA;+ item_hwm_offset = cd->hwm - cd->start_workspace;+ reset_bracount = FALSE;++ /* Deal with the extended parentheses; all are introduced by '?', and the+ appearance of any of them means that this is not a capturing group. */++ if (*ptr == CHAR_QUESTION_MARK)+ {+ int i, set, unset, namelen;+ int *optset;+ const pcre_uchar *name;+ pcre_uchar *slot;++ switch (*(++ptr))+ {+ /* ------------------------------------------------------------ */+ case CHAR_VERTICAL_LINE: /* Reset capture count for each branch */+ reset_bracount = TRUE;+ cd->dupgroups = TRUE; /* Record (?| encountered */+ /* Fall through */++ /* ------------------------------------------------------------ */+ case CHAR_COLON: /* Non-capturing bracket */+ bravalue = OP_BRA;+ ptr++;+ break;+++ /* ------------------------------------------------------------ */+ case CHAR_LEFT_PARENTHESIS:+ bravalue = OP_COND; /* Conditional group */+ tempptr = ptr;++ /* A condition can be an assertion, a number (referring to a numbered+ group's having been set), a name (referring to a named group), or 'R',+ referring to recursion. R<digits> and R&name are also permitted for+ recursion tests.++ There are ways of testing a named group: (?(name)) is used by Python;+ Perl 5.10 onwards uses (?(<name>) or (?('name')).++ There is one unfortunate ambiguity, caused by history. 'R' can be the+ recursive thing or the name 'R' (and similarly for 'R' followed by+ digits). We look for a name first; if not found, we try the other case.++ For compatibility with auto-callouts, we allow a callout to be+ specified before a condition that is an assertion. First, check for the+ syntax of a callout; if found, adjust the temporary pointer that is+ used to check for an assertion condition. That's all that is needed! */++ if (ptr[1] == CHAR_QUESTION_MARK && ptr[2] == CHAR_C)+ {+ for (i = 3;; i++) if (!IS_DIGIT(ptr[i])) break;+ if (ptr[i] == CHAR_RIGHT_PARENTHESIS)+ tempptr += i + 1;++ /* tempptr should now be pointing to the opening parenthesis of the+ assertion condition. */++ if (*tempptr != CHAR_LEFT_PARENTHESIS)+ {+ *errorcodeptr = ERR28;+ goto FAILED;+ }+ }++ /* For conditions that are assertions, check the syntax, and then exit+ the switch. This will take control down to where bracketed groups,+ including assertions, are processed. */++ if (tempptr[1] == CHAR_QUESTION_MARK &&+ (tempptr[2] == CHAR_EQUALS_SIGN ||+ tempptr[2] == CHAR_EXCLAMATION_MARK ||+ (tempptr[2] == CHAR_LESS_THAN_SIGN &&+ (tempptr[3] == CHAR_EQUALS_SIGN ||+ tempptr[3] == CHAR_EXCLAMATION_MARK))))+ {+ cd->iscondassert = TRUE;+ break;+ }++ /* Other conditions use OP_CREF/OP_DNCREF/OP_RREF/OP_DNRREF, and all+ need to skip at least 1+IMM2_SIZE bytes at the start of the group. */++ code[1+LINK_SIZE] = OP_CREF;+ skipbytes = 1+IMM2_SIZE;+ refsign = -1; /* => not a number */+ namelen = -1; /* => not a name; must set to avoid warning */+ name = NULL; /* Always set to avoid warning */+ recno = 0; /* Always set to avoid warning */++ /* Check for a test for recursion in a named group. */++ ptr++;+ if (*ptr == CHAR_R && ptr[1] == CHAR_AMPERSAND)+ {+ terminator = -1;+ ptr += 2;+ code[1+LINK_SIZE] = OP_RREF; /* Change the type of test */+ }++ /* Check for a test for a named group's having been set, using the Perl+ syntax (?(<name>) or (?('name'), and also allow for the original PCRE+ syntax of (?(name) or for (?(+n), (?(-n), and just (?(n). */++ else if (*ptr == CHAR_LESS_THAN_SIGN)+ {+ terminator = CHAR_GREATER_THAN_SIGN;+ ptr++;+ }+ else if (*ptr == CHAR_APOSTROPHE)+ {+ terminator = CHAR_APOSTROPHE;+ ptr++;+ }+ else+ {+ terminator = CHAR_NULL;+ if (*ptr == CHAR_MINUS || *ptr == CHAR_PLUS) refsign = *ptr++;+ else if (IS_DIGIT(*ptr)) refsign = 0;+ }++ /* Handle a number */++ if (refsign >= 0)+ {+ while (IS_DIGIT(*ptr))+ {+ if (recno > INT_MAX / 10 - 1) /* Integer overflow */+ {+ while (IS_DIGIT(*ptr)) ptr++;+ *errorcodeptr = ERR61;+ goto FAILED;+ }+ recno = recno * 10 + (int)(*ptr - CHAR_0);+ ptr++;+ }+ }++ /* Otherwise we expect to read a name; anything else is an error. When+ a name is one of a number of duplicates, a different opcode is used and+ it needs more memory. Unfortunately we cannot tell whether a name is a+ duplicate in the first pass, so we have to allow for more memory. */++ else+ {+ if (IS_DIGIT(*ptr))+ {+ *errorcodeptr = ERR84;+ goto FAILED;+ }+ if (!MAX_255(*ptr) || (cd->ctypes[*ptr] & ctype_word) == 0)+ {+ *errorcodeptr = ERR28; /* Assertion expected */+ goto FAILED;+ }+ name = ptr++;+ while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0)+ {+ ptr++;+ }+ namelen = (int)(ptr - name);+ if (lengthptr != NULL) skipbytes += IMM2_SIZE;+ }++ /* Check the terminator */++ if ((terminator > 0 && *ptr++ != (pcre_uchar)terminator) ||+ *ptr++ != CHAR_RIGHT_PARENTHESIS)+ {+ ptr--; /* Error offset */+ *errorcodeptr = ERR26; /* Malformed number or name */+ goto FAILED;+ }++ /* Do no further checking in the pre-compile phase. */++ if (lengthptr != NULL) break;++ /* In the real compile we do the work of looking for the actual+ reference. If refsign is not negative, it means we have a number in+ recno. */++ if (refsign >= 0)+ {+ if (recno <= 0)+ {+ *errorcodeptr = ERR35;+ goto FAILED;+ }+ if (refsign != 0) recno = (refsign == CHAR_MINUS)?+ cd->bracount - recno + 1 : recno + cd->bracount;+ if (recno <= 0 || recno > cd->final_bracount)+ {+ *errorcodeptr = ERR15;+ goto FAILED;+ }+ PUT2(code, 2+LINK_SIZE, recno);+ if (recno > cd->top_backref) cd->top_backref = recno;+ break;+ }++ /* Otherwise look for the name. */++ slot = cd->name_table;+ for (i = 0; i < cd->names_found; i++)+ {+ if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&+ slot[IMM2_SIZE+namelen] == 0) break;+ slot += cd->name_entry_size;+ }++ /* Found the named subpattern. If the name is duplicated, add one to+ the opcode to change CREF/RREF into DNCREF/DNRREF and insert+ appropriate data values. Otherwise, just insert the unique subpattern+ number. */++ if (i < cd->names_found)+ {+ int offset = i++;+ int count = 1;+ recno = GET2(slot, 0); /* Number from first found */+ if (recno > cd->top_backref) cd->top_backref = recno;+ for (; i < cd->names_found; i++)+ {+ slot += cd->name_entry_size;+ if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) != 0 ||+ (slot+IMM2_SIZE)[namelen] != 0) break;+ count++;+ }++ if (count > 1)+ {+ PUT2(code, 2+LINK_SIZE, offset);+ PUT2(code, 2+LINK_SIZE+IMM2_SIZE, count);+ skipbytes += IMM2_SIZE;+ code[1+LINK_SIZE]++;+ }+ else /* Not a duplicated name */+ {+ PUT2(code, 2+LINK_SIZE, recno);+ }+ }++ /* If terminator == CHAR_NULL it means that the name followed directly+ after the opening parenthesis [e.g. (?(abc)...] and in this case there+ are some further alternatives to try. For the cases where terminator !=+ CHAR_NULL [things like (?(<name>... or (?('name')... or (?(R&name)... ]+ we have now checked all the possibilities, so give an error. */++ else if (terminator != CHAR_NULL)+ {+ *errorcodeptr = ERR15;+ goto FAILED;+ }++ /* Check for (?(R) for recursion. Allow digits after R to specify a+ specific group number. */++ else if (*name == CHAR_R)+ {+ recno = 0;+ for (i = 1; i < namelen; i++)+ {+ if (!IS_DIGIT(name[i]))+ {+ *errorcodeptr = ERR15;+ goto FAILED;+ }+ if (recno > INT_MAX / 10 - 1) /* Integer overflow */+ {+ *errorcodeptr = ERR61;+ goto FAILED;+ }+ recno = recno * 10 + name[i] - CHAR_0;+ }+ if (recno == 0) recno = RREF_ANY;+ code[1+LINK_SIZE] = OP_RREF; /* Change test type */+ PUT2(code, 2+LINK_SIZE, recno);+ }++ /* Similarly, check for the (?(DEFINE) "condition", which is always+ false. */++ else if (namelen == 6 && STRNCMP_UC_C8(name, STRING_DEFINE, 6) == 0)+ {+ code[1+LINK_SIZE] = OP_DEF;+ skipbytes = 1;+ }++ /* Reference to an unidentified subpattern. */++ else+ {+ *errorcodeptr = ERR15;+ goto FAILED;+ }+ break;+++ /* ------------------------------------------------------------ */+ case CHAR_EQUALS_SIGN: /* Positive lookahead */+ bravalue = OP_ASSERT;+ cd->assert_depth += 1;+ ptr++;+ break;++ /* Optimize (?!) to (*FAIL) unless it is quantified - which is a weird+ thing to do, but Perl allows all assertions to be quantified, and when+ they contain capturing parentheses there may be a potential use for+ this feature. Not that that applies to a quantified (?!) but we allow+ it for uniformity. */++ /* ------------------------------------------------------------ */+ case CHAR_EXCLAMATION_MARK: /* Negative lookahead */+ ptr++;+ if (*ptr == CHAR_RIGHT_PARENTHESIS && ptr[1] != CHAR_ASTERISK &&+ ptr[1] != CHAR_PLUS && ptr[1] != CHAR_QUESTION_MARK &&+ (ptr[1] != CHAR_LEFT_CURLY_BRACKET || !is_counted_repeat(ptr+2)))+ {+ *code++ = OP_FAIL;+ previous = NULL;+ continue;+ }+ bravalue = OP_ASSERT_NOT;+ cd->assert_depth += 1;+ break;+++ /* ------------------------------------------------------------ */+ case CHAR_LESS_THAN_SIGN: /* Lookbehind or named define */+ switch (ptr[1])+ {+ case CHAR_EQUALS_SIGN: /* Positive lookbehind */+ bravalue = OP_ASSERTBACK;+ cd->assert_depth += 1;+ ptr += 2;+ break;++ case CHAR_EXCLAMATION_MARK: /* Negative lookbehind */+ bravalue = OP_ASSERTBACK_NOT;+ cd->assert_depth += 1;+ ptr += 2;+ break;++ default: /* Could be name define, else bad */+ if (MAX_255(ptr[1]) && (cd->ctypes[ptr[1]] & ctype_word) != 0)+ goto DEFINE_NAME;+ ptr++; /* Correct offset for error */+ *errorcodeptr = ERR24;+ goto FAILED;+ }+ break;+++ /* ------------------------------------------------------------ */+ case CHAR_GREATER_THAN_SIGN: /* One-time brackets */+ bravalue = OP_ONCE;+ ptr++;+ break;+++ /* ------------------------------------------------------------ */+ case CHAR_C: /* Callout - may be followed by digits; */+ previous_callout = code; /* Save for later completion */+ after_manual_callout = 1; /* Skip one item before completing */+ *code++ = OP_CALLOUT;+ {+ int n = 0;+ ptr++;+ while(IS_DIGIT(*ptr))+ n = n * 10 + *ptr++ - CHAR_0;+ if (*ptr != CHAR_RIGHT_PARENTHESIS)+ {+ *errorcodeptr = ERR39;+ goto FAILED;+ }+ if (n > 255)+ {+ *errorcodeptr = ERR38;+ goto FAILED;+ }+ *code++ = n;+ PUT(code, 0, (int)(ptr - cd->start_pattern + 1)); /* Pattern offset */+ PUT(code, LINK_SIZE, 0); /* Default length */+ code += 2 * LINK_SIZE;+ }+ previous = NULL;+ continue;+++ /* ------------------------------------------------------------ */+ case CHAR_P: /* Python-style named subpattern handling */+ if (*(++ptr) == CHAR_EQUALS_SIGN ||+ *ptr == CHAR_GREATER_THAN_SIGN) /* Reference or recursion */+ {+ is_recurse = *ptr == CHAR_GREATER_THAN_SIGN;+ terminator = CHAR_RIGHT_PARENTHESIS;+ goto NAMED_REF_OR_RECURSE;+ }+ else if (*ptr != CHAR_LESS_THAN_SIGN) /* Test for Python-style defn */+ {+ *errorcodeptr = ERR41;+ goto FAILED;+ }+ /* Fall through to handle (?P< as (?< is handled */+++ /* ------------------------------------------------------------ */+ DEFINE_NAME: /* Come here from (?< handling */+ case CHAR_APOSTROPHE:+ terminator = (*ptr == CHAR_LESS_THAN_SIGN)?+ CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;+ name = ++ptr;+ if (IS_DIGIT(*ptr))+ {+ *errorcodeptr = ERR84; /* Group name must start with non-digit */+ goto FAILED;+ }+ while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;+ namelen = (int)(ptr - name);++ /* In the pre-compile phase, do a syntax check, remember the longest+ name, and then remember the group in a vector, expanding it if+ necessary. Duplicates for the same number are skipped; other duplicates+ are checked for validity. In the actual compile, there is nothing to+ do. */++ if (lengthptr != NULL)+ {+ named_group *ng;+ pcre_uint32 number = cd->bracount + 1;++ if (*ptr != (pcre_uchar)terminator)+ {+ *errorcodeptr = ERR42;+ goto FAILED;+ }++ if (cd->names_found >= MAX_NAME_COUNT)+ {+ *errorcodeptr = ERR49;+ goto FAILED;+ }++ if (namelen + IMM2_SIZE + 1 > cd->name_entry_size)+ {+ cd->name_entry_size = namelen + IMM2_SIZE + 1;+ if (namelen > MAX_NAME_SIZE)+ {+ *errorcodeptr = ERR48;+ goto FAILED;+ }+ }++ /* Scan the list to check for duplicates. For duplicate names, if the+ number is the same, break the loop, which causes the name to be+ discarded; otherwise, if DUPNAMES is not set, give an error.+ If it is set, allow the name with a different number, but continue+ scanning in case this is a duplicate with the same number. For+ non-duplicate names, give an error if the number is duplicated. */++ ng = cd->named_groups;+ for (i = 0; i < cd->names_found; i++, ng++)+ {+ if (namelen == ng->length &&+ STRNCMP_UC_UC(name, ng->name, namelen) == 0)+ {+ if (ng->number == number) break;+ if ((options & PCRE_DUPNAMES) == 0)+ {+ *errorcodeptr = ERR43;+ goto FAILED;+ }+ cd->dupnames = TRUE; /* Duplicate names exist */+ }+ else if (ng->number == number)+ {+ *errorcodeptr = ERR65;+ goto FAILED;+ }+ }++ if (i >= cd->names_found) /* Not a duplicate with same number */+ {+ /* Increase the list size if necessary */++ if (cd->names_found >= cd->named_group_list_size)+ {+ int newsize = cd->named_group_list_size * 2;+ named_group *newspace = (PUBL(malloc))+ (newsize * sizeof(named_group));++ if (newspace == NULL)+ {+ *errorcodeptr = ERR21;+ goto FAILED;+ }++ memcpy(newspace, cd->named_groups,+ cd->named_group_list_size * sizeof(named_group));+ if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE)+ (PUBL(free))((void *)cd->named_groups);+ cd->named_groups = newspace;+ cd->named_group_list_size = newsize;+ }++ cd->named_groups[cd->names_found].name = name;+ cd->named_groups[cd->names_found].length = namelen;+ cd->named_groups[cd->names_found].number = number;+ cd->names_found++;+ }+ }++ ptr++; /* Move past > or ' in both passes. */+ goto NUMBERED_GROUP;+++ /* ------------------------------------------------------------ */+ case CHAR_AMPERSAND: /* Perl recursion/subroutine syntax */+ terminator = CHAR_RIGHT_PARENTHESIS;+ is_recurse = TRUE;+ /* Fall through */++ /* We come here from the Python syntax above that handles both+ references (?P=name) and recursion (?P>name), as well as falling+ through from the Perl recursion syntax (?&name). We also come here from+ the Perl \k<name> or \k'name' back reference syntax and the \k{name}+ .NET syntax, and the Oniguruma \g<...> and \g'...' subroutine syntax. */++ NAMED_REF_OR_RECURSE:+ name = ++ptr;+ if (IS_DIGIT(*ptr))+ {+ *errorcodeptr = ERR84; /* Group name must start with non-digit */+ goto FAILED;+ }+ while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;+ namelen = (int)(ptr - name);++ /* In the pre-compile phase, do a syntax check. We used to just set+ a dummy reference number, because it was not used in the first pass.+ However, with the change of recursive back references to be atomic,+ we have to look for the number so that this state can be identified, as+ otherwise the incorrect length is computed. If it's not a backwards+ reference, the dummy number will do. */++ if (lengthptr != NULL)+ {+ named_group *ng;+ recno = 0;++ if (namelen == 0)+ {+ *errorcodeptr = ERR62;+ goto FAILED;+ }+ if (*ptr != (pcre_uchar)terminator)+ {+ *errorcodeptr = ERR42;+ goto FAILED;+ }+ if (namelen > MAX_NAME_SIZE)+ {+ *errorcodeptr = ERR48;+ goto FAILED;+ }++ /* Count named back references. */++ if (!is_recurse) cd->namedrefcount++;++ /* We have to allow for a named reference to a duplicated name (this+ cannot be determined until the second pass). This needs an extra+ 16-bit data item. */++ *lengthptr += IMM2_SIZE;++ /* If this is a forward reference and we are within a (?|...) group,+ the reference may end up as the number of a group which we are+ currently inside, that is, it could be a recursive reference. In the+ real compile this will be picked up and the reference wrapped with+ OP_ONCE to make it atomic, so we must space in case this occurs. */++ /* In fact, this can happen for a non-forward reference because+ another group with the same number might be created later. This+ issue is fixed "properly" in PCRE2. As PCRE1 is now in maintenance+ only mode, we finesse the bug by allowing more memory always. */++ *lengthptr += 4 + 4*LINK_SIZE;++ /* It is even worse than that. The current reference may be to an+ existing named group with a different number (so apparently not+ recursive) but which later on is also attached to a group with the+ current number. This can only happen if $(| has been previous+ encountered. In that case, we allow yet more memory, just in case.+ (Again, this is fixed "properly" in PCRE2. */++ if (cd->dupgroups) *lengthptr += 4 + 4*LINK_SIZE;++ /* Otherwise, check for recursion here. The name table does not exist+ in the first pass; instead we must scan the list of names encountered+ so far in order to get the number. If the name is not found, leave+ the value of recno as 0 for a forward reference. */++ /* This patch (removing "else") fixes a problem when a reference is+ to multiple identically named nested groups from within the nest.+ Once again, it is not the "proper" fix, and it results in an+ over-allocation of memory. */++ /* else */+ {+ ng = cd->named_groups;+ for (i = 0; i < cd->names_found; i++, ng++)+ {+ if (namelen == ng->length &&+ STRNCMP_UC_UC(name, ng->name, namelen) == 0)+ {+ open_capitem *oc;+ recno = ng->number;+ if (is_recurse) break;+ for (oc = cd->open_caps; oc != NULL; oc = oc->next)+ {+ if (oc->number == recno)+ {+ oc->flag = TRUE;+ break;+ }+ }+ }+ }+ }+ }++ /* In the real compile, search the name table. We check the name+ first, and then check that we have reached the end of the name in the+ table. That way, if the name is longer than any in the table, the+ comparison will fail without reading beyond the table entry. */++ else+ {+ slot = cd->name_table;+ for (i = 0; i < cd->names_found; i++)+ {+ if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&+ slot[IMM2_SIZE+namelen] == 0)+ break;+ slot += cd->name_entry_size;+ }++ if (i < cd->names_found)+ {+ recno = GET2(slot, 0);+ }+ else+ {+ *errorcodeptr = ERR15;+ goto FAILED;+ }+ }++ /* In both phases, for recursions, we can now go to the code than+ handles numerical recursion. */++ if (is_recurse) goto HANDLE_RECURSION;++ /* In the second pass we must see if the name is duplicated. If so, we+ generate a different opcode. */++ if (lengthptr == NULL && cd->dupnames)+ {+ int count = 1;+ unsigned int index = i;+ pcre_uchar *cslot = slot + cd->name_entry_size;++ for (i++; i < cd->names_found; i++)+ {+ if (STRCMP_UC_UC(slot + IMM2_SIZE, cslot + IMM2_SIZE) != 0) break;+ count++;+ cslot += cd->name_entry_size;+ }++ if (count > 1)+ {+ if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;+ previous = code;+ item_hwm_offset = cd->hwm - cd->start_workspace;+ *code++ = ((options & PCRE_CASELESS) != 0)? OP_DNREFI : OP_DNREF;+ PUT2INC(code, 0, index);+ PUT2INC(code, 0, count);++ /* Process each potentially referenced group. */++ for (; slot < cslot; slot += cd->name_entry_size)+ {+ open_capitem *oc;+ recno = GET2(slot, 0);+ cd->backref_map |= (recno < 32)? (1 << recno) : 1;+ if (recno > cd->top_backref) cd->top_backref = recno;++ /* Check to see if this back reference is recursive, that it, it+ is inside the group that it references. A flag is set so that the+ group can be made atomic. */++ for (oc = cd->open_caps; oc != NULL; oc = oc->next)+ {+ if (oc->number == recno)+ {+ oc->flag = TRUE;+ break;+ }+ }+ }++ continue; /* End of back ref handling */+ }+ }++ /* First pass, or a non-duplicated name. */++ goto HANDLE_REFERENCE;+++ /* ------------------------------------------------------------ */+ case CHAR_R: /* Recursion, same as (?0) */+ recno = 0;+ if (*(++ptr) != CHAR_RIGHT_PARENTHESIS)+ {+ *errorcodeptr = ERR29;+ goto FAILED;+ }+ goto HANDLE_RECURSION;+++ /* ------------------------------------------------------------ */+ case CHAR_MINUS: case CHAR_PLUS: /* Recursion or subroutine */+ case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:+ case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:+ {+ const pcre_uchar *called;+ terminator = CHAR_RIGHT_PARENTHESIS;++ /* Come here from the \g<...> and \g'...' code (Oniguruma+ compatibility). However, the syntax has been checked to ensure that+ the ... are a (signed) number, so that neither ERR63 nor ERR29 will+ be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY+ ever be taken. */++ HANDLE_NUMERICAL_RECURSION:++ if ((refsign = *ptr) == CHAR_PLUS)+ {+ ptr++;+ if (!IS_DIGIT(*ptr))+ {+ *errorcodeptr = ERR63;+ goto FAILED;+ }+ }+ else if (refsign == CHAR_MINUS)+ {+ if (!IS_DIGIT(ptr[1]))+ goto OTHER_CHAR_AFTER_QUERY;+ ptr++;+ }++ recno = 0;+ while(IS_DIGIT(*ptr))+ {+ if (recno > INT_MAX / 10 - 1) /* Integer overflow */+ {+ while (IS_DIGIT(*ptr)) ptr++;+ *errorcodeptr = ERR61;+ goto FAILED;+ }+ recno = recno * 10 + *ptr++ - CHAR_0;+ }++ if (*ptr != (pcre_uchar)terminator)+ {+ *errorcodeptr = ERR29;+ goto FAILED;+ }++ if (refsign == CHAR_MINUS)+ {+ if (recno == 0)+ {+ *errorcodeptr = ERR58;+ goto FAILED;+ }+ recno = cd->bracount - recno + 1;+ if (recno <= 0)+ {+ *errorcodeptr = ERR15;+ goto FAILED;+ }+ }+ else if (refsign == CHAR_PLUS)+ {+ if (recno == 0)+ {+ *errorcodeptr = ERR58;+ goto FAILED;+ }+ recno += cd->bracount;+ }++ /* Come here from code above that handles a named recursion */++ HANDLE_RECURSION:++ previous = code;+ item_hwm_offset = cd->hwm - cd->start_workspace;+ called = cd->start_code;++ /* When we are actually compiling, find the bracket that is being+ referenced. Temporarily end the regex in case it doesn't exist before+ this point. If we end up with a forward reference, first check that+ the bracket does occur later so we can give the error (and position)+ now. Then remember this forward reference in the workspace so it can+ be filled in at the end. */++ if (lengthptr == NULL)+ {+ *code = OP_END;+ if (recno != 0)+ called = PRIV(find_bracket)(cd->start_code, utf, recno);++ /* Forward reference */++ if (called == NULL)+ {+ if (recno > cd->final_bracount)+ {+ *errorcodeptr = ERR15;+ goto FAILED;+ }++ /* Fudge the value of "called" so that when it is inserted as an+ offset below, what it actually inserted is the reference number+ of the group. Then remember the forward reference. */++ called = cd->start_code + recno;+ if (cd->hwm >= cd->start_workspace + cd->workspace_size -+ WORK_SIZE_SAFETY_MARGIN)+ {+ *errorcodeptr = expand_workspace(cd);+ if (*errorcodeptr != 0) goto FAILED;+ }+ PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));+ }++ /* If not a forward reference, and the subpattern is still open,+ this is a recursive call. We check to see if this is a left+ recursion that could loop for ever, and diagnose that case. We+ must not, however, do this check if we are in a conditional+ subpattern because the condition might be testing for recursion in+ a pattern such as /(?(R)a+|(?R)b)/, which is perfectly valid.+ Forever loops are also detected at runtime, so those that occur in+ conditional subpatterns will be picked up then. */++ else if (GET(called, 1) == 0 && cond_depth <= 0 &&+ could_be_empty(called, code, bcptr, utf, cd))+ {+ *errorcodeptr = ERR40;+ goto FAILED;+ }+ }++ /* Insert the recursion/subroutine item. It does not have a set first+ character (relevant if it is repeated, because it will then be+ wrapped with ONCE brackets). */++ *code = OP_RECURSE;+ PUT(code, 1, (int)(called - cd->start_code));+ code += 1 + LINK_SIZE;+ groupsetfirstchar = FALSE;+ }++ /* Can't determine a first byte now */++ if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;+ zerofirstchar = firstchar;+ zerofirstcharflags = firstcharflags;+ continue;+++ /* ------------------------------------------------------------ */+ default: /* Other characters: check option setting */+ OTHER_CHAR_AFTER_QUERY:+ set = unset = 0;+ optset = &set;++ while (*ptr != CHAR_RIGHT_PARENTHESIS && *ptr != CHAR_COLON)+ {+ switch (*ptr++)+ {+ case CHAR_MINUS: optset = &unset; break;++ case CHAR_J: /* Record that it changed in the external options */+ *optset |= PCRE_DUPNAMES;+ cd->external_flags |= PCRE_JCHANGED;+ break;++ case CHAR_i: *optset |= PCRE_CASELESS; break;+ case CHAR_m: *optset |= PCRE_MULTILINE; break;+ case CHAR_s: *optset |= PCRE_DOTALL; break;+ case CHAR_x: *optset |= PCRE_EXTENDED; break;+ case CHAR_U: *optset |= PCRE_UNGREEDY; break;+ case CHAR_X: *optset |= PCRE_EXTRA; break;++ default: *errorcodeptr = ERR12;+ ptr--; /* Correct the offset */+ goto FAILED;+ }+ }++ /* Set up the changed option bits, but don't change anything yet. */++ newoptions = (options | set) & (~unset);++ /* If the options ended with ')' this is not the start of a nested+ group with option changes, so the options change at this level.+ If we are not at the pattern start, reset the greedy defaults and the+ case value for firstchar and reqchar. */++ if (*ptr == CHAR_RIGHT_PARENTHESIS)+ {+ greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);+ greedy_non_default = greedy_default ^ 1;+ req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS:0;++ /* Change options at this level, and pass them back for use+ in subsequent branches. */++ *optionsptr = options = newoptions;+ previous = NULL; /* This item can't be repeated */+ continue; /* It is complete */+ }++ /* If the options ended with ':' we are heading into a nested group+ with possible change of options. Such groups are non-capturing and are+ not assertions of any kind. All we need to do is skip over the ':';+ the newoptions value is handled below. */++ bravalue = OP_BRA;+ ptr++;+ } /* End of switch for character following (? */+ } /* End of (? handling */++ /* Opening parenthesis not followed by '*' or '?'. If PCRE_NO_AUTO_CAPTURE+ is set, all unadorned brackets become non-capturing and behave like (?:...)+ brackets. */++ else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)+ {+ bravalue = OP_BRA;+ }++ /* Else we have a capturing group. */++ else+ {+ NUMBERED_GROUP:+ cd->bracount += 1;+ PUT2(code, 1+LINK_SIZE, cd->bracount);+ skipbytes = IMM2_SIZE;+ }++ /* Process nested bracketed regex. First check for parentheses nested too+ deeply. */++ if ((cd->parens_depth += 1) > PARENS_NEST_LIMIT)+ {+ *errorcodeptr = ERR82;+ goto FAILED;+ }++ /* All assertions used not to be repeatable, but this was changed for Perl+ compatibility. All kinds can now be repeated except for assertions that are+ conditions (Perl also forbids these to be repeated). We copy code into a+ non-register variable (tempcode) in order to be able to pass its address+ because some compilers complain otherwise. At the start of a conditional+ group whose condition is an assertion, cd->iscondassert is set. We unset it+ here so as to allow assertions later in the group to be quantified. */++ if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT &&+ cd->iscondassert)+ {+ previous = NULL;+ cd->iscondassert = FALSE;+ }+ else+ {+ previous = code;+ item_hwm_offset = cd->hwm - cd->start_workspace;+ }++ *code = bravalue;+ tempcode = code;+ tempreqvary = cd->req_varyopt; /* Save value before bracket */+ tempbracount = cd->bracount; /* Save value before bracket */+ length_prevgroup = 0; /* Initialize for pre-compile phase */++ if (!compile_regex(+ newoptions, /* The complete new option state */+ &tempcode, /* Where to put code (updated) */+ &ptr, /* Input pointer (updated) */+ errorcodeptr, /* Where to put an error message */+ (bravalue == OP_ASSERTBACK ||+ bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */+ reset_bracount, /* True if (?| group */+ skipbytes, /* Skip over bracket number */+ cond_depth ++ ((bravalue == OP_COND)?1:0), /* Depth of condition subpatterns */+ &subfirstchar, /* For possible first char */+ &subfirstcharflags,+ &subreqchar, /* For possible last char */+ &subreqcharflags,+ bcptr, /* Current branch chain */+ cd, /* Tables block */+ (lengthptr == NULL)? NULL : /* Actual compile phase */+ &length_prevgroup /* Pre-compile phase */+ ))+ goto FAILED;++ cd->parens_depth -= 1;++ /* If this was an atomic group and there are no capturing groups within it,+ generate OP_ONCE_NC instead of OP_ONCE. */++ if (bravalue == OP_ONCE && cd->bracount <= tempbracount)+ *code = OP_ONCE_NC;++ if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)+ cd->assert_depth -= 1;++ /* At the end of compiling, code is still pointing to the start of the+ group, while tempcode has been updated to point past the end of the group.+ The pattern pointer (ptr) is on the bracket.++ If this is a conditional bracket, check that there are no more than+ two branches in the group, or just one if it's a DEFINE group. We do this+ in the real compile phase, not in the pre-pass, where the whole group may+ not be available. */++ if (bravalue == OP_COND && lengthptr == NULL)+ {+ pcre_uchar *tc = code;+ int condcount = 0;++ do {+ condcount++;+ tc += GET(tc,1);+ }+ while (*tc != OP_KET);++ /* A DEFINE group is never obeyed inline (the "condition" is always+ false). It must have only one branch. */++ if (code[LINK_SIZE+1] == OP_DEF)+ {+ if (condcount > 1)+ {+ *errorcodeptr = ERR54;+ goto FAILED;+ }+ bravalue = OP_DEF; /* Just a flag to suppress char handling below */+ }++ /* A "normal" conditional group. If there is just one branch, we must not+ make use of its firstchar or reqchar, because this is equivalent to an+ empty second branch. */++ else+ {+ if (condcount > 2)+ {+ *errorcodeptr = ERR27;+ goto FAILED;+ }+ if (condcount == 1) subfirstcharflags = subreqcharflags = REQ_NONE;+ }+ }++ /* Error if hit end of pattern */++ if (*ptr != CHAR_RIGHT_PARENTHESIS)+ {+ *errorcodeptr = ERR14;+ goto FAILED;+ }++ /* In the pre-compile phase, update the length by the length of the group,+ less the brackets at either end. Then reduce the compiled code to just a+ set of non-capturing brackets so that it doesn't use much memory if it is+ duplicated by a quantifier.*/++ if (lengthptr != NULL)+ {+ if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)+ {+ *errorcodeptr = ERR20;+ goto FAILED;+ }+ *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;+ code++; /* This already contains bravalue */+ PUTINC(code, 0, 1 + LINK_SIZE);+ *code++ = OP_KET;+ PUTINC(code, 0, 1 + LINK_SIZE);+ break; /* No need to waste time with special character handling */+ }++ /* Otherwise update the main code pointer to the end of the group. */++ code = tempcode;++ /* For a DEFINE group, required and first character settings are not+ relevant. */++ if (bravalue == OP_DEF) break;++ /* Handle updating of the required and first characters for other types of+ group. Update for normal brackets of all kinds, and conditions with two+ branches (see code above). If the bracket is followed by a quantifier with+ zero repeat, we have to back off. Hence the definition of zeroreqchar and+ zerofirstchar outside the main loop so that they can be accessed for the+ back off. */++ zeroreqchar = reqchar;+ zeroreqcharflags = reqcharflags;+ zerofirstchar = firstchar;+ zerofirstcharflags = firstcharflags;+ groupsetfirstchar = FALSE;++ if (bravalue >= OP_ONCE)+ {+ /* If we have not yet set a firstchar in this branch, take it from the+ subpattern, remembering that it was set here so that a repeat of more+ than one can replicate it as reqchar if necessary. If the subpattern has+ no firstchar, set "none" for the whole branch. In both cases, a zero+ repeat forces firstchar to "none". */++ if (firstcharflags == REQ_UNSET)+ {+ if (subfirstcharflags >= 0)+ {+ firstchar = subfirstchar;+ firstcharflags = subfirstcharflags;+ groupsetfirstchar = TRUE;+ }+ else firstcharflags = REQ_NONE;+ zerofirstcharflags = REQ_NONE;+ }++ /* If firstchar was previously set, convert the subpattern's firstchar+ into reqchar if there wasn't one, using the vary flag that was in+ existence beforehand. */++ else if (subfirstcharflags >= 0 && subreqcharflags < 0)+ {+ subreqchar = subfirstchar;+ subreqcharflags = subfirstcharflags | tempreqvary;+ }++ /* If the subpattern set a required byte (or set a first byte that isn't+ really the first byte - see above), set it. */++ if (subreqcharflags >= 0)+ {+ reqchar = subreqchar;+ reqcharflags = subreqcharflags;+ }+ }++ /* For a forward assertion, we take the reqchar, if set, provided that the+ group has also set a first char. This can be helpful if the pattern that+ follows the assertion doesn't set a different char. For example, it's+ useful for /(?=abcde).+/. We can't set firstchar for an assertion, however+ because it leads to incorrect effect for patterns such as /(?=a)a.+/ when+ the "real" "a" would then become a reqchar instead of a firstchar. This is+ overcome by a scan at the end if there's no firstchar, looking for an+ asserted first char. */++ else if (bravalue == OP_ASSERT && subreqcharflags >= 0 &&+ subfirstcharflags >= 0)+ {+ reqchar = subreqchar;+ reqcharflags = subreqcharflags;+ }+ break; /* End of processing '(' */+++ /* ===================================================================*/+ /* Handle metasequences introduced by \. For ones like \d, the ESC_ values+ are arranged to be the negation of the corresponding OP_values in the+ default case when PCRE_UCP is not set. For the back references, the values+ are negative the reference number. Only back references and those types+ that consume a character may be repeated. We can test for values between+ ESC_b and ESC_Z for the latter; this may have to change if any new ones are+ ever created. */++ case CHAR_BACKSLASH:+ tempptr = ptr;+ escape = check_escape(&ptr, &ec, errorcodeptr, cd->bracount, options, FALSE);+ if (*errorcodeptr != 0) goto FAILED;++ if (escape == 0) /* The escape coded a single character */+ c = ec;+ else+ {+ /* For metasequences that actually match a character, we disable the+ setting of a first character if it hasn't already been set. */++ if (firstcharflags == REQ_UNSET && escape > ESC_b && escape < ESC_Z)+ firstcharflags = REQ_NONE;++ /* Set values to reset to if this is followed by a zero repeat. */++ zerofirstchar = firstchar;+ zerofirstcharflags = firstcharflags;+ zeroreqchar = reqchar;+ zeroreqcharflags = reqcharflags;++ /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'+ is a subroutine call by number (Oniguruma syntax). In fact, the value+ ESC_g is returned only for these cases. So we don't need to check for <+ or ' if the value is ESC_g. For the Perl syntax \g{n} the value is+ -n, and for the Perl syntax \g{name} the result is ESC_k (as+ that is a synonym for a named back reference). */++ if (escape == ESC_g)+ {+ const pcre_uchar *p;+ pcre_uint32 cf;++ item_hwm_offset = cd->hwm - cd->start_workspace; /* Normally this is set when '(' is read */+ terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?+ CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;++ /* These two statements stop the compiler for warning about possibly+ unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In+ fact, because we do the check for a number below, the paths that+ would actually be in error are never taken. */++ skipbytes = 0;+ reset_bracount = FALSE;++ /* If it's not a signed or unsigned number, treat it as a name. */++ cf = ptr[1];+ if (cf != CHAR_PLUS && cf != CHAR_MINUS && !IS_DIGIT(cf))+ {+ is_recurse = TRUE;+ goto NAMED_REF_OR_RECURSE;+ }++ /* Signed or unsigned number (cf = ptr[1]) is known to be plus or minus+ or a digit. */++ p = ptr + 2;+ while (IS_DIGIT(*p)) p++;+ if (*p != (pcre_uchar)terminator)+ {+ *errorcodeptr = ERR57;+ goto FAILED;+ }+ ptr++;+ goto HANDLE_NUMERICAL_RECURSION;+ }++ /* \k<name> or \k'name' is a back reference by name (Perl syntax).+ We also support \k{name} (.NET syntax). */++ if (escape == ESC_k)+ {+ if ((ptr[1] != CHAR_LESS_THAN_SIGN &&+ ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))+ {+ *errorcodeptr = ERR69;+ goto FAILED;+ }+ is_recurse = FALSE;+ terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?+ CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?+ CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;+ goto NAMED_REF_OR_RECURSE;+ }++ /* Back references are handled specially; must disable firstchar if+ not set to cope with cases like (?=(\w+))\1: which would otherwise set+ ':' later. */++ if (escape < 0)+ {+ open_capitem *oc;+ recno = -escape;++ /* Come here from named backref handling when the reference is to a+ single group (i.e. not to a duplicated name. */++ HANDLE_REFERENCE:+ if (firstcharflags == REQ_UNSET) zerofirstcharflags = firstcharflags = REQ_NONE;+ previous = code;+ item_hwm_offset = cd->hwm - cd->start_workspace;+ *code++ = ((options & PCRE_CASELESS) != 0)? OP_REFI : OP_REF;+ PUT2INC(code, 0, recno);+ cd->backref_map |= (recno < 32)? (1 << recno) : 1;+ if (recno > cd->top_backref) cd->top_backref = recno;++ /* Check to see if this back reference is recursive, that it, it+ is inside the group that it references. A flag is set so that the+ group can be made atomic. */++ for (oc = cd->open_caps; oc != NULL; oc = oc->next)+ {+ if (oc->number == recno)+ {+ oc->flag = TRUE;+ break;+ }+ }+ }++ /* So are Unicode property matches, if supported. */++#ifdef SUPPORT_UCP+ else if (escape == ESC_P || escape == ESC_p)+ {+ BOOL negated;+ unsigned int ptype = 0, pdata = 0;+ if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))+ goto FAILED;+ previous = code;+ item_hwm_offset = cd->hwm - cd->start_workspace;+ *code++ = ((escape == ESC_p) != negated)? OP_PROP : OP_NOTPROP;+ *code++ = ptype;+ *code++ = pdata;+ }+#else++ /* If Unicode properties are not supported, \X, \P, and \p are not+ allowed. */++ else if (escape == ESC_X || escape == ESC_P || escape == ESC_p)+ {+ *errorcodeptr = ERR45;+ goto FAILED;+ }+#endif++ /* For the rest (including \X when Unicode properties are supported), we+ can obtain the OP value by negating the escape value in the default+ situation when PCRE_UCP is not set. When it *is* set, we substitute+ Unicode property tests. Note that \b and \B do a one-character+ lookbehind, and \A also behaves as if it does. */++ else+ {+ if ((escape == ESC_b || escape == ESC_B || escape == ESC_A) &&+ cd->max_lookbehind == 0)+ cd->max_lookbehind = 1;+#ifdef SUPPORT_UCP+ if (escape >= ESC_DU && escape <= ESC_wu)+ {+ nestptr = ptr + 1; /* Where to resume */+ ptr = substitutes[escape - ESC_DU] - 1; /* Just before substitute */+ }+ else+#endif+ /* In non-UTF-8 mode, we turn \C into OP_ALLANY instead of OP_ANYBYTE+ so that it works in DFA mode and in lookbehinds. */++ {+ previous = (escape > ESC_b && escape < ESC_Z)? code : NULL;+ item_hwm_offset = cd->hwm - cd->start_workspace;+ *code++ = (!utf && escape == ESC_C)? OP_ALLANY : escape;+ }+ }+ continue;+ }++ /* We have a data character whose value is in c. In UTF-8 mode it may have+ a value > 127. We set its representation in the length/buffer, and then+ handle it as a data character. */++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)+ mclength = PRIV(ord2utf)(c, mcbuffer);+ else+#endif++ {+ mcbuffer[0] = c;+ mclength = 1;+ }+ goto ONE_CHAR;+++ /* ===================================================================*/+ /* Handle a literal character. It is guaranteed not to be whitespace or #+ when the extended flag is set. If we are in a UTF mode, it may be a+ multi-unit literal character. */++ default:+ NORMAL_CHAR:+ mclength = 1;+ mcbuffer[0] = c;++#ifdef SUPPORT_UTF+ if (utf && HAS_EXTRALEN(c))+ ACROSSCHAR(TRUE, ptr[1], mcbuffer[mclength++] = *(++ptr));+#endif++ /* At this point we have the character's bytes in mcbuffer, and the length+ in mclength. When not in UTF-8 mode, the length is always 1. */++ ONE_CHAR:+ previous = code;+ item_hwm_offset = cd->hwm - cd->start_workspace;++ /* For caseless UTF-8 mode when UCP support is available, check whether+ this character has more than one other case. If so, generate a special+ OP_PROP item instead of OP_CHARI. */++#ifdef SUPPORT_UCP+ if (utf && (options & PCRE_CASELESS) != 0)+ {+ GETCHAR(c, mcbuffer);+ if ((c = UCD_CASESET(c)) != 0)+ {+ *code++ = OP_PROP;+ *code++ = PT_CLIST;+ *code++ = c;+ if (firstcharflags == REQ_UNSET)+ firstcharflags = zerofirstcharflags = REQ_NONE;+ break;+ }+ }+#endif++ /* Caseful matches, or not one of the multicase characters. */++ *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARI : OP_CHAR;+ for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];++ /* Remember if \r or \n were seen */++ if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)+ cd->external_flags |= PCRE_HASCRORLF;++ /* Set the first and required bytes appropriately. If no previous first+ byte, set it from this character, but revert to none on a zero repeat.+ Otherwise, leave the firstchar value alone, and don't change it on a zero+ repeat. */++ if (firstcharflags == REQ_UNSET)+ {+ zerofirstcharflags = REQ_NONE;+ zeroreqchar = reqchar;+ zeroreqcharflags = reqcharflags;++ /* If the character is more than one byte long, we can set firstchar+ only if it is not to be matched caselessly. */++ if (mclength == 1 || req_caseopt == 0)+ {+ firstchar = mcbuffer[0];+ firstcharflags = req_caseopt;++ if (mclength != 1)+ {+ reqchar = code[-1];+ reqcharflags = cd->req_varyopt;+ }+ }+ else firstcharflags = reqcharflags = REQ_NONE;+ }++ /* firstchar was previously set; we can set reqchar only if the length is+ 1 or the matching is caseful. */++ else+ {+ zerofirstchar = firstchar;+ zerofirstcharflags = firstcharflags;+ zeroreqchar = reqchar;+ zeroreqcharflags = reqcharflags;+ if (mclength == 1 || req_caseopt == 0)+ {+ reqchar = code[-1];+ reqcharflags = req_caseopt | cd->req_varyopt;+ }+ }++ break; /* End of literal character handling */+ }+ } /* end of big loop */+++/* Control never reaches here by falling through, only by a goto for all the+error states. Pass back the position in the pattern so that it can be displayed+to the user for diagnosing the error. */++FAILED:+*ptrptr = ptr;+return FALSE;+}++++/*************************************************+* Compile sequence of alternatives *+*************************************************/++/* On entry, ptr is pointing past the bracket character, but on return it+points to the closing bracket, or vertical bar, or end of string. The code+variable is pointing at the byte into which the BRA operator has been stored.+This function is used during the pre-compile phase when we are trying to find+out the amount of memory needed, as well as during the real compile phase. The+value of lengthptr distinguishes the two phases.++Arguments:+ options option bits, including any changes for this subpattern+ codeptr -> the address of the current code pointer+ ptrptr -> the address of the current pattern pointer+ errorcodeptr -> pointer to error code variable+ lookbehind TRUE if this is a lookbehind assertion+ reset_bracount TRUE to reset the count for each branch+ skipbytes skip this many bytes at start (for brackets and OP_COND)+ cond_depth depth of nesting for conditional subpatterns+ firstcharptr place to put the first required character+ firstcharflagsptr place to put the first character flags, or a negative number+ reqcharptr place to put the last required character+ reqcharflagsptr place to put the last required character flags, or a negative number+ bcptr pointer to the chain of currently open branches+ cd points to the data block with tables pointers etc.+ lengthptr NULL during the real compile phase+ points to length accumulator during pre-compile phase++Returns: TRUE on success+*/++static BOOL+compile_regex(int options, pcre_uchar **codeptr, const pcre_uchar **ptrptr,+ int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,+ int cond_depth,+ pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,+ pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,+ branch_chain *bcptr, compile_data *cd, int *lengthptr)+{+const pcre_uchar *ptr = *ptrptr;+pcre_uchar *code = *codeptr;+pcre_uchar *last_branch = code;+pcre_uchar *start_bracket = code;+pcre_uchar *reverse_count = NULL;+open_capitem capitem;+int capnumber = 0;+pcre_uint32 firstchar, reqchar;+pcre_int32 firstcharflags, reqcharflags;+pcre_uint32 branchfirstchar, branchreqchar;+pcre_int32 branchfirstcharflags, branchreqcharflags;+int length;+unsigned int orig_bracount;+unsigned int max_bracount;+branch_chain bc;+size_t save_hwm_offset;++/* If set, call the external function that checks for stack availability. */++if (PUBL(stack_guard) != NULL && PUBL(stack_guard)())+ {+ *errorcodeptr= ERR85;+ return FALSE;+ }++/* Miscellaneous initialization */++bc.outer = bcptr;+bc.current_branch = code;++firstchar = reqchar = 0;+firstcharflags = reqcharflags = REQ_UNSET;++save_hwm_offset = cd->hwm - cd->start_workspace;++/* Accumulate the length for use in the pre-compile phase. Start with the+length of the BRA and KET and any extra bytes that are required at the+beginning. We accumulate in a local variable to save frequent testing of+lenthptr for NULL. We cannot do this by looking at the value of code at the+start and end of each alternative, because compiled items are discarded during+the pre-compile phase so that the work space is not exceeded. */++length = 2 + 2*LINK_SIZE + skipbytes;++/* WARNING: If the above line is changed for any reason, you must also change+the code that abstracts option settings at the start of the pattern and makes+them global. It tests the value of length for (2 + 2*LINK_SIZE) in the+pre-compile phase to find out whether anything has yet been compiled or not. */++/* If this is a capturing subpattern, add to the chain of open capturing items+so that we can detect them if (*ACCEPT) is encountered. This is also used to+detect groups that contain recursive back references to themselves. Note that+only OP_CBRA need be tested here; changing this opcode to one of its variants,+e.g. OP_SCBRAPOS, happens later, after the group has been compiled. */++if (*code == OP_CBRA)+ {+ capnumber = GET2(code, 1 + LINK_SIZE);+ capitem.number = capnumber;+ capitem.next = cd->open_caps;+ capitem.flag = FALSE;+ cd->open_caps = &capitem;+ }++/* Offset is set zero to mark that this bracket is still open */++PUT(code, 1, 0);+code += 1 + LINK_SIZE + skipbytes;++/* Loop for each alternative branch */++orig_bracount = max_bracount = cd->bracount;+for (;;)+ {+ /* For a (?| group, reset the capturing bracket count so that each branch+ uses the same numbers. */++ if (reset_bracount) cd->bracount = orig_bracount;++ /* Set up dummy OP_REVERSE if lookbehind assertion */++ if (lookbehind)+ {+ *code++ = OP_REVERSE;+ reverse_count = code;+ PUTINC(code, 0, 0);+ length += 1 + LINK_SIZE;+ }++ /* Now compile the branch; in the pre-compile phase its length gets added+ into the length. */++ if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar,+ &branchfirstcharflags, &branchreqchar, &branchreqcharflags, &bc,+ cond_depth, cd, (lengthptr == NULL)? NULL : &length))+ {+ *ptrptr = ptr;+ return FALSE;+ }++ /* Keep the highest bracket count in case (?| was used and some branch+ has fewer than the rest. */++ if (cd->bracount > max_bracount) max_bracount = cd->bracount;++ /* In the real compile phase, there is some post-processing to be done. */++ if (lengthptr == NULL)+ {+ /* If this is the first branch, the firstchar and reqchar values for the+ branch become the values for the regex. */++ if (*last_branch != OP_ALT)+ {+ firstchar = branchfirstchar;+ firstcharflags = branchfirstcharflags;+ reqchar = branchreqchar;+ reqcharflags = branchreqcharflags;+ }++ /* If this is not the first branch, the first char and reqchar have to+ match the values from all the previous branches, except that if the+ previous value for reqchar didn't have REQ_VARY set, it can still match,+ and we set REQ_VARY for the regex. */++ else+ {+ /* If we previously had a firstchar, but it doesn't match the new branch,+ we have to abandon the firstchar for the regex, but if there was+ previously no reqchar, it takes on the value of the old firstchar. */++ if (firstcharflags >= 0 &&+ (firstcharflags != branchfirstcharflags || firstchar != branchfirstchar))+ {+ if (reqcharflags < 0)+ {+ reqchar = firstchar;+ reqcharflags = firstcharflags;+ }+ firstcharflags = REQ_NONE;+ }++ /* If we (now or from before) have no firstchar, a firstchar from the+ branch becomes a reqchar if there isn't a branch reqchar. */++ if (firstcharflags < 0 && branchfirstcharflags >= 0 && branchreqcharflags < 0)+ {+ branchreqchar = branchfirstchar;+ branchreqcharflags = branchfirstcharflags;+ }++ /* Now ensure that the reqchars match */++ if (((reqcharflags & ~REQ_VARY) != (branchreqcharflags & ~REQ_VARY)) ||+ reqchar != branchreqchar)+ reqcharflags = REQ_NONE;+ else+ {+ reqchar = branchreqchar;+ reqcharflags |= branchreqcharflags; /* To "or" REQ_VARY */+ }+ }++ /* If lookbehind, check that this branch matches a fixed-length string, and+ put the length into the OP_REVERSE item. Temporarily mark the end of the+ branch with OP_END. If the branch contains OP_RECURSE, the result is -3+ because there may be forward references that we can't check here. Set a+ flag to cause another lookbehind check at the end. Why not do it all at the+ end? Because common, erroneous checks are picked up here and the offset of+ the problem can be shown. */++ if (lookbehind)+ {+ int fixed_length;+ *code = OP_END;+ fixed_length = find_fixedlength(last_branch, (options & PCRE_UTF8) != 0,+ FALSE, cd, NULL);+ DPRINTF(("fixed length = %d\n", fixed_length));+ if (fixed_length == -3)+ {+ cd->check_lookbehind = TRUE;+ }+ else if (fixed_length < 0)+ {+ *errorcodeptr = (fixed_length == -2)? ERR36 :+ (fixed_length == -4)? ERR70: ERR25;+ *ptrptr = ptr;+ return FALSE;+ }+ else+ {+ if (fixed_length > cd->max_lookbehind)+ cd->max_lookbehind = fixed_length;+ PUT(reverse_count, 0, fixed_length);+ }+ }+ }++ /* Reached end of expression, either ')' or end of pattern. In the real+ compile phase, go back through the alternative branches and reverse the chain+ of offsets, with the field in the BRA item now becoming an offset to the+ first alternative. If there are no alternatives, it points to the end of the+ group. The length in the terminating ket is always the length of the whole+ bracketed item. Return leaving the pointer at the terminating char. */++ if (*ptr != CHAR_VERTICAL_LINE)+ {+ if (lengthptr == NULL)+ {+ int branch_length = (int)(code - last_branch);+ do+ {+ int prev_length = GET(last_branch, 1);+ PUT(last_branch, 1, branch_length);+ branch_length = prev_length;+ last_branch -= branch_length;+ }+ while (branch_length > 0);+ }++ /* Fill in the ket */++ *code = OP_KET;+ PUT(code, 1, (int)(code - start_bracket));+ code += 1 + LINK_SIZE;++ /* If it was a capturing subpattern, check to see if it contained any+ recursive back references. If so, we must wrap it in atomic brackets.+ Because we are moving code along, we must ensure that any pending recursive+ references are updated. In any event, remove the block from the chain. */++ if (capnumber > 0)+ {+ if (cd->open_caps->flag)+ {+ *code = OP_END;+ adjust_recurse(start_bracket, 1 + LINK_SIZE,+ (options & PCRE_UTF8) != 0, cd, save_hwm_offset);+ memmove(start_bracket + 1 + LINK_SIZE, start_bracket,+ IN_UCHARS(code - start_bracket));+ *start_bracket = OP_ONCE;+ code += 1 + LINK_SIZE;+ PUT(start_bracket, 1, (int)(code - start_bracket));+ *code = OP_KET;+ PUT(code, 1, (int)(code - start_bracket));+ code += 1 + LINK_SIZE;+ length += 2 + 2*LINK_SIZE;+ }+ cd->open_caps = cd->open_caps->next;+ }++ /* Retain the highest bracket number, in case resetting was used. */++ cd->bracount = max_bracount;++ /* Set values to pass back */++ *codeptr = code;+ *ptrptr = ptr;+ *firstcharptr = firstchar;+ *firstcharflagsptr = firstcharflags;+ *reqcharptr = reqchar;+ *reqcharflagsptr = reqcharflags;+ if (lengthptr != NULL)+ {+ if (OFLOW_MAX - *lengthptr < length)+ {+ *errorcodeptr = ERR20;+ return FALSE;+ }+ *lengthptr += length;+ }+ return TRUE;+ }++ /* Another branch follows. In the pre-compile phase, we can move the code+ pointer back to where it was for the start of the first branch. (That is,+ pretend that each branch is the only one.)++ In the real compile phase, insert an ALT node. Its length field points back+ to the previous branch while the bracket remains open. At the end the chain+ is reversed. It's done like this so that the start of the bracket has a+ zero offset until it is closed, making it possible to detect recursion. */++ if (lengthptr != NULL)+ {+ code = *codeptr + 1 + LINK_SIZE + skipbytes;+ length += 1 + LINK_SIZE;+ }+ else+ {+ *code = OP_ALT;+ PUT(code, 1, (int)(code - last_branch));+ bc.current_branch = last_branch = code;+ code += 1 + LINK_SIZE;+ }++ ptr++;+ }+/* Control never reaches here */+}+++++/*************************************************+* Check for anchored expression *+*************************************************/++/* Try to find out if this is an anchored regular expression. Consider each+alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket+all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then+it's anchored. However, if this is a multiline pattern, then only OP_SOD will+be found, because ^ generates OP_CIRCM in that mode.++We can also consider a regex to be anchored if OP_SOM starts all its branches.+This is the code for \G, which means "match at start of match position, taking+into account the match offset".++A branch is also implicitly anchored if it starts with .* and DOTALL is set,+because that will try the rest of the pattern at all possible matching points,+so there is no point trying again.... er ....++.... except when the .* appears inside capturing parentheses, and there is a+subsequent back reference to those parentheses. We haven't enough information+to catch that case precisely.++At first, the best we could do was to detect when .* was in capturing brackets+and the highest back reference was greater than or equal to that level.+However, by keeping a bitmap of the first 31 back references, we can catch some+of the more common cases more precisely.++... A second exception is when the .* appears inside an atomic group, because+this prevents the number of characters it matches from being adjusted.++Arguments:+ code points to start of expression (the bracket)+ bracket_map a bitmap of which brackets we are inside while testing; this+ handles up to substring 31; after that we just have to take+ the less precise approach+ cd points to the compile data block+ atomcount atomic group level++Returns: TRUE or FALSE+*/++static BOOL+is_anchored(register const pcre_uchar *code, unsigned int bracket_map,+ compile_data *cd, int atomcount)+{+do {+ const pcre_uchar *scode = first_significant_code(+ code + PRIV(OP_lengths)[*code], FALSE);+ register int op = *scode;++ /* Non-capturing brackets */++ if (op == OP_BRA || op == OP_BRAPOS ||+ op == OP_SBRA || op == OP_SBRAPOS)+ {+ if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;+ }++ /* Capturing brackets */++ else if (op == OP_CBRA || op == OP_CBRAPOS ||+ op == OP_SCBRA || op == OP_SCBRAPOS)+ {+ int n = GET2(scode, 1+LINK_SIZE);+ int new_map = bracket_map | ((n < 32)? (1 << n) : 1);+ if (!is_anchored(scode, new_map, cd, atomcount)) return FALSE;+ }++ /* Positive forward assertion */++ else if (op == OP_ASSERT)+ {+ if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;+ }++ /* Condition; not anchored if no second branch */++ else if (op == OP_COND)+ {+ if (scode[GET(scode,1)] != OP_ALT) return FALSE;+ if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;+ }++ /* Atomic groups */++ else if (op == OP_ONCE || op == OP_ONCE_NC)+ {+ if (!is_anchored(scode, bracket_map, cd, atomcount + 1))+ return FALSE;+ }++ /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and+ it isn't in brackets that are or may be referenced or inside an atomic+ group. */++ else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||+ op == OP_TYPEPOSSTAR))+ {+ if (scode[1] != OP_ALLANY || (bracket_map & cd->backref_map) != 0 ||+ atomcount > 0 || cd->had_pruneorskip)+ return FALSE;+ }++ /* Check for explicit anchoring */++ else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;++ code += GET(code, 1);+ }+while (*code == OP_ALT); /* Loop for each alternative */+return TRUE;+}++++/*************************************************+* Check for starting with ^ or .* *+*************************************************/++/* This is called to find out if every branch starts with ^ or .* so that+"first char" processing can be done to speed things up in multiline+matching and for non-DOTALL patterns that start with .* (which must start at+the beginning or after \n). As in the case of is_anchored() (see above), we+have to take account of back references to capturing brackets that contain .*+because in that case we can't make the assumption. Also, the appearance of .*+inside atomic brackets or in an assertion, or in a pattern that contains *PRUNE+or *SKIP does not count, because once again the assumption no longer holds.++Arguments:+ code points to start of expression (the bracket)+ bracket_map a bitmap of which brackets we are inside while testing; this+ handles up to substring 31; after that we just have to take+ the less precise approach+ cd points to the compile data+ atomcount atomic group level+ inassert TRUE if in an assertion++Returns: TRUE or FALSE+*/++static BOOL+is_startline(const pcre_uchar *code, unsigned int bracket_map,+ compile_data *cd, int atomcount, BOOL inassert)+{+do {+ const pcre_uchar *scode = first_significant_code(+ code + PRIV(OP_lengths)[*code], FALSE);+ register int op = *scode;++ /* If we are at the start of a conditional assertion group, *both* the+ conditional assertion *and* what follows the condition must satisfy the test+ for start of line. Other kinds of condition fail. Note that there may be an+ auto-callout at the start of a condition. */++ if (op == OP_COND)+ {+ scode += 1 + LINK_SIZE;+ if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];+ switch (*scode)+ {+ case OP_CREF:+ case OP_DNCREF:+ case OP_RREF:+ case OP_DNRREF:+ case OP_DEF:+ case OP_FAIL:+ return FALSE;++ default: /* Assertion */+ if (!is_startline(scode, bracket_map, cd, atomcount, TRUE)) return FALSE;+ do scode += GET(scode, 1); while (*scode == OP_ALT);+ scode += 1 + LINK_SIZE;+ break;+ }+ scode = first_significant_code(scode, FALSE);+ op = *scode;+ }++ /* Non-capturing brackets */++ if (op == OP_BRA || op == OP_BRAPOS ||+ op == OP_SBRA || op == OP_SBRAPOS)+ {+ if (!is_startline(scode, bracket_map, cd, atomcount, inassert)) return FALSE;+ }++ /* Capturing brackets */++ else if (op == OP_CBRA || op == OP_CBRAPOS ||+ op == OP_SCBRA || op == OP_SCBRAPOS)+ {+ int n = GET2(scode, 1+LINK_SIZE);+ int new_map = bracket_map | ((n < 32)? (1 << n) : 1);+ if (!is_startline(scode, new_map, cd, atomcount, inassert)) return FALSE;+ }++ /* Positive forward assertions */++ else if (op == OP_ASSERT)+ {+ if (!is_startline(scode, bracket_map, cd, atomcount, TRUE)) return FALSE;+ }++ /* Atomic brackets */++ else if (op == OP_ONCE || op == OP_ONCE_NC)+ {+ if (!is_startline(scode, bracket_map, cd, atomcount + 1, inassert)) return FALSE;+ }++ /* .* means "start at start or after \n" if it isn't in atomic brackets or+ brackets that may be referenced or an assertion, as long as the pattern does+ not contain *PRUNE or *SKIP, because these break the feature. Consider, for+ example, /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab", i.e.+ not at the start of a line. */++ else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)+ {+ if (scode[1] != OP_ANY || (bracket_map & cd->backref_map) != 0 ||+ atomcount > 0 || cd->had_pruneorskip || inassert)+ return FALSE;+ }++ /* Check for explicit circumflex; anything else gives a FALSE result. Note+ in particular that this includes atomic brackets OP_ONCE and OP_ONCE_NC+ because the number of characters matched by .* cannot be adjusted inside+ them. */++ else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;++ /* Move on to the next alternative */++ code += GET(code, 1);+ }+while (*code == OP_ALT); /* Loop for each alternative */+return TRUE;+}++++/*************************************************+* Check for asserted fixed first char *+*************************************************/++/* During compilation, the "first char" settings from forward assertions are+discarded, because they can cause conflicts with actual literals that follow.+However, if we end up without a first char setting for an unanchored pattern,+it is worth scanning the regex to see if there is an initial asserted first+char. If all branches start with the same asserted char, or with a+non-conditional bracket all of whose alternatives start with the same asserted+char (recurse ad lib), then we return that char, with the flags set to zero or+REQ_CASELESS; otherwise return zero with REQ_NONE in the flags.++Arguments:+ code points to start of expression (the bracket)+ flags points to the first char flags, or to REQ_NONE+ inassert TRUE if in an assertion++Returns: the fixed first char, or 0 with REQ_NONE in flags+*/++static pcre_uint32+find_firstassertedchar(const pcre_uchar *code, pcre_int32 *flags,+ BOOL inassert)+{+register pcre_uint32 c = 0;+int cflags = REQ_NONE;++*flags = REQ_NONE;+do {+ pcre_uint32 d;+ int dflags;+ int xl = (*code == OP_CBRA || *code == OP_SCBRA ||+ *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;+ const pcre_uchar *scode = first_significant_code(code + 1+LINK_SIZE + xl,+ TRUE);+ register pcre_uchar op = *scode;++ switch(op)+ {+ default:+ return 0;++ case OP_BRA:+ case OP_BRAPOS:+ case OP_CBRA:+ case OP_SCBRA:+ case OP_CBRAPOS:+ case OP_SCBRAPOS:+ case OP_ASSERT:+ case OP_ONCE:+ case OP_ONCE_NC:+ d = find_firstassertedchar(scode, &dflags, op == OP_ASSERT);+ if (dflags < 0)+ return 0;+ if (cflags < 0) { c = d; cflags = dflags; } else if (c != d || cflags != dflags) return 0;+ break;++ case OP_EXACT:+ scode += IMM2_SIZE;+ /* Fall through */++ case OP_CHAR:+ case OP_PLUS:+ case OP_MINPLUS:+ case OP_POSPLUS:+ if (!inassert) return 0;+ if (cflags < 0) { c = scode[1]; cflags = 0; }+ else if (c != scode[1]) return 0;+ break;++ case OP_EXACTI:+ scode += IMM2_SIZE;+ /* Fall through */++ case OP_CHARI:+ case OP_PLUSI:+ case OP_MINPLUSI:+ case OP_POSPLUSI:+ if (!inassert) return 0;+ if (cflags < 0) { c = scode[1]; cflags = REQ_CASELESS; }+ else if (c != scode[1]) return 0;+ break;+ }++ code += GET(code, 1);+ }+while (*code == OP_ALT);++*flags = cflags;+return c;+}++++/*************************************************+* Add an entry to the name/number table *+*************************************************/++/* This function is called between compiling passes to add an entry to the+name/number table, maintaining alphabetical order. Checking for permitted+and forbidden duplicates has already been done.++Arguments:+ cd the compile data block+ name the name to add+ length the length of the name+ groupno the group number++Returns: nothing+*/++static void+add_name(compile_data *cd, const pcre_uchar *name, int length,+ unsigned int groupno)+{+int i;+pcre_uchar *slot = cd->name_table;++for (i = 0; i < cd->names_found; i++)+ {+ int crc = memcmp(name, slot+IMM2_SIZE, IN_UCHARS(length));+ if (crc == 0 && slot[IMM2_SIZE+length] != 0)+ crc = -1; /* Current name is a substring */++ /* Make space in the table and break the loop for an earlier name. For a+ duplicate or later name, carry on. We do this for duplicates so that in the+ simple case (when ?(| is not used) they are in order of their numbers. In all+ cases they are in the order in which they appear in the pattern. */++ if (crc < 0)+ {+ memmove(slot + cd->name_entry_size, slot,+ IN_UCHARS((cd->names_found - i) * cd->name_entry_size));+ break;+ }++ /* Continue the loop for a later or duplicate name */++ slot += cd->name_entry_size;+ }++PUT2(slot, 0, groupno);+memcpy(slot + IMM2_SIZE, name, IN_UCHARS(length));+slot[IMM2_SIZE + length] = 0;+cd->names_found++;+}++++/*************************************************+* Compile a Regular Expression *+*************************************************/++/* This function takes a string and returns a pointer to a block of store+holding a compiled version of the expression. The original API for this+function had no error code return variable; it is retained for backwards+compatibility. The new function is given a new name.++Arguments:+ pattern the regular expression+ options various option bits+ errorcodeptr pointer to error code variable (pcre_compile2() only)+ can be NULL if you don't want a code value+ errorptr pointer to pointer to error text+ erroroffset ptr offset in pattern where error was detected+ tables pointer to character tables or NULL++Returns: pointer to compiled data block, or NULL on error,+ with errorptr and erroroffset set+*/++#if defined COMPILE_PCRE8+PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION+pcre_compile(const char *pattern, int options, const char **errorptr,+ int *erroroffset, const unsigned char *tables)+#elif defined COMPILE_PCRE16+PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION+pcre16_compile(PCRE_SPTR16 pattern, int options, const char **errorptr,+ int *erroroffset, const unsigned char *tables)+#elif defined COMPILE_PCRE32+PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION+pcre32_compile(PCRE_SPTR32 pattern, int options, const char **errorptr,+ int *erroroffset, const unsigned char *tables)+#endif+{+#if defined COMPILE_PCRE8+return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);+#elif defined COMPILE_PCRE16+return pcre16_compile2(pattern, options, NULL, errorptr, erroroffset, tables);+#elif defined COMPILE_PCRE32+return pcre32_compile2(pattern, options, NULL, errorptr, erroroffset, tables);+#endif+}+++#if defined COMPILE_PCRE8+PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION+pcre_compile2(const char *pattern, int options, int *errorcodeptr,+ const char **errorptr, int *erroroffset, const unsigned char *tables)+#elif defined COMPILE_PCRE16+PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION+pcre16_compile2(PCRE_SPTR16 pattern, int options, int *errorcodeptr,+ const char **errorptr, int *erroroffset, const unsigned char *tables)+#elif defined COMPILE_PCRE32+PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION+pcre32_compile2(PCRE_SPTR32 pattern, int options, int *errorcodeptr,+ const char **errorptr, int *erroroffset, const unsigned char *tables)+#endif+{+REAL_PCRE *re;+int length = 1; /* For final END opcode */+pcre_int32 firstcharflags, reqcharflags;+pcre_uint32 firstchar, reqchar;+pcre_uint32 limit_match = PCRE_UINT32_MAX;+pcre_uint32 limit_recursion = PCRE_UINT32_MAX;+int newline;+int errorcode = 0;+int skipatstart = 0;+BOOL utf;+BOOL never_utf = FALSE;+size_t size;+pcre_uchar *code;+const pcre_uchar *codestart;+const pcre_uchar *ptr;+compile_data compile_block;+compile_data *cd = &compile_block;++/* This space is used for "compiling" into during the first phase, when we are+computing the amount of memory that is needed. Compiled items are thrown away+as soon as possible, so that a fairly large buffer should be sufficient for+this purpose. The same space is used in the second phase for remembering where+to fill in forward references to subpatterns. That may overflow, in which case+new memory is obtained from malloc(). */++pcre_uchar cworkspace[COMPILE_WORK_SIZE];++/* This vector is used for remembering name groups during the pre-compile. In a+similar way to cworkspace, it can be expanded using malloc() if necessary. */++named_group named_groups[NAMED_GROUP_LIST_SIZE];++/* Set this early so that early errors get offset 0. */++ptr = (const pcre_uchar *)pattern;++/* We can't pass back an error message if errorptr is NULL; I guess the best we+can do is just return NULL, but we can set a code value if there is a code+pointer. */++if (errorptr == NULL)+ {+ if (errorcodeptr != NULL) *errorcodeptr = 99;+ return NULL;+ }++*errorptr = NULL;+if (errorcodeptr != NULL) *errorcodeptr = ERR0;++/* However, we can give a message for this error */++if (erroroffset == NULL)+ {+ errorcode = ERR16;+ goto PCRE_EARLY_ERROR_RETURN2;+ }++*erroroffset = 0;++/* Set up pointers to the individual character tables */++if (tables == NULL) tables = PRIV(default_tables);+cd->lcc = tables + lcc_offset;+cd->fcc = tables + fcc_offset;+cd->cbits = tables + cbits_offset;+cd->ctypes = tables + ctypes_offset;++/* Check that all undefined public option bits are zero */++if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0)+ {+ errorcode = ERR17;+ goto PCRE_EARLY_ERROR_RETURN;+ }++/* If PCRE_NEVER_UTF is set, remember it. */++if ((options & PCRE_NEVER_UTF) != 0) never_utf = TRUE;++/* Check for global one-time settings at the start of the pattern, and remember+the offset for later. */++cd->external_flags = 0; /* Initialize here for LIMIT_MATCH/RECURSION */++while (ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&+ ptr[skipatstart+1] == CHAR_ASTERISK)+ {+ int newnl = 0;+ int newbsr = 0;++/* For completeness and backward compatibility, (*UTFn) is supported in the+relevant libraries, but (*UTF) is generic and always supported. Note that+PCRE_UTF8 == PCRE_UTF16 == PCRE_UTF32. */++#ifdef COMPILE_PCRE8+ if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF8_RIGHTPAR, 5) == 0)+ { skipatstart += 7; options |= PCRE_UTF8; continue; }+#endif+#ifdef COMPILE_PCRE16+ if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF16_RIGHTPAR, 6) == 0)+ { skipatstart += 8; options |= PCRE_UTF16; continue; }+#endif+#ifdef COMPILE_PCRE32+ if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF32_RIGHTPAR, 6) == 0)+ { skipatstart += 8; options |= PCRE_UTF32; continue; }+#endif++ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 4) == 0)+ { skipatstart += 6; options |= PCRE_UTF8; continue; }+ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UCP_RIGHTPAR, 4) == 0)+ { skipatstart += 6; options |= PCRE_UCP; continue; }+ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_AUTO_POSSESS_RIGHTPAR, 16) == 0)+ { skipatstart += 18; options |= PCRE_NO_AUTO_POSSESS; continue; }+ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_START_OPT_RIGHTPAR, 13) == 0)+ { skipatstart += 15; options |= PCRE_NO_START_OPTIMIZE; continue; }++ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LIMIT_MATCH_EQ, 12) == 0)+ {+ pcre_uint32 c = 0;+ int p = skipatstart + 14;+ while (isdigit(ptr[p]))+ {+ if (c > PCRE_UINT32_MAX / 10 - 1) break; /* Integer overflow */+ c = c*10 + ptr[p++] - CHAR_0;+ }+ if (ptr[p++] != CHAR_RIGHT_PARENTHESIS) break;+ if (c < limit_match)+ {+ limit_match = c;+ cd->external_flags |= PCRE_MLSET;+ }+ skipatstart = p;+ continue;+ }++ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LIMIT_RECURSION_EQ, 16) == 0)+ {+ pcre_uint32 c = 0;+ int p = skipatstart + 18;+ while (isdigit(ptr[p]))+ {+ if (c > PCRE_UINT32_MAX / 10 - 1) break; /* Integer overflow check */+ c = c*10 + ptr[p++] - CHAR_0;+ }+ if (ptr[p++] != CHAR_RIGHT_PARENTHESIS) break;+ if (c < limit_recursion)+ {+ limit_recursion = c;+ cd->external_flags |= PCRE_RLSET;+ }+ skipatstart = p;+ continue;+ }++ if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CR_RIGHTPAR, 3) == 0)+ { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }+ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LF_RIGHTPAR, 3) == 0)+ { skipatstart += 5; newnl = PCRE_NEWLINE_LF; }+ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CRLF_RIGHTPAR, 5) == 0)+ { skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }+ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANY_RIGHTPAR, 4) == 0)+ { skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }+ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANYCRLF_RIGHTPAR, 8) == 0)+ { skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }++ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)+ { skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }+ else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)+ { skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }++ if (newnl != 0)+ options = (options & ~PCRE_NEWLINE_BITS) | newnl;+ else if (newbsr != 0)+ options = (options & ~(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) | newbsr;+ else break;+ }++/* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */+utf = (options & PCRE_UTF8) != 0;+if (utf && never_utf)+ {+ errorcode = ERR78;+ goto PCRE_EARLY_ERROR_RETURN2;+ }++/* Can't support UTF unless PCRE has been compiled to include the code. The+return of an error code from PRIV(valid_utf)() is a new feature, introduced in+release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is+not used here. */++#ifdef SUPPORT_UTF+if (utf && (options & PCRE_NO_UTF8_CHECK) == 0 &&+ (errorcode = PRIV(valid_utf)((PCRE_PUCHAR)pattern, -1, erroroffset)) != 0)+ {+#if defined COMPILE_PCRE8+ errorcode = ERR44;+#elif defined COMPILE_PCRE16+ errorcode = ERR74;+#elif defined COMPILE_PCRE32+ errorcode = ERR77;+#endif+ goto PCRE_EARLY_ERROR_RETURN2;+ }+#else+if (utf)+ {+ errorcode = ERR32;+ goto PCRE_EARLY_ERROR_RETURN;+ }+#endif++/* Can't support UCP unless PCRE has been compiled to include the code. */++#ifndef SUPPORT_UCP+if ((options & PCRE_UCP) != 0)+ {+ errorcode = ERR67;+ goto PCRE_EARLY_ERROR_RETURN;+ }+#endif++/* Check validity of \R options. */++if ((options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) ==+ (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))+ {+ errorcode = ERR56;+ goto PCRE_EARLY_ERROR_RETURN;+ }++/* Handle different types of newline. The three bits give seven cases. The+current code allows for fixed one- or two-byte sequences, plus "any" and+"anycrlf". */++switch (options & PCRE_NEWLINE_BITS)+ {+ case 0: newline = NEWLINE; break; /* Build-time default */+ case PCRE_NEWLINE_CR: newline = CHAR_CR; break;+ case PCRE_NEWLINE_LF: newline = CHAR_NL; break;+ case PCRE_NEWLINE_CR++ PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;+ case PCRE_NEWLINE_ANY: newline = -1; break;+ case PCRE_NEWLINE_ANYCRLF: newline = -2; break;+ default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;+ }++if (newline == -2)+ {+ cd->nltype = NLTYPE_ANYCRLF;+ }+else if (newline < 0)+ {+ cd->nltype = NLTYPE_ANY;+ }+else+ {+ cd->nltype = NLTYPE_FIXED;+ if (newline > 255)+ {+ cd->nllen = 2;+ cd->nl[0] = (newline >> 8) & 255;+ cd->nl[1] = newline & 255;+ }+ else+ {+ cd->nllen = 1;+ cd->nl[0] = newline;+ }+ }++/* Maximum back reference and backref bitmap. The bitmap records up to 31 back+references to help in deciding whether (.*) can be treated as anchored or not.+*/++cd->top_backref = 0;+cd->backref_map = 0;++/* Reflect pattern for debugging output */++DPRINTF(("------------------------------------------------------------------\n"));+#ifdef PCRE_DEBUG+print_puchar(stdout, (PCRE_PUCHAR)pattern);+#endif+DPRINTF(("\n"));++/* Pretend to compile the pattern while actually just accumulating the length+of memory required. This behaviour is triggered by passing a non-NULL final+argument to compile_regex(). We pass a block of workspace (cworkspace) for it+to compile parts of the pattern into; the compiled code is discarded when it is+no longer needed, so hopefully this workspace will never overflow, though there+is a test for its doing so. */++cd->bracount = cd->final_bracount = 0;+cd->names_found = 0;+cd->name_entry_size = 0;+cd->name_table = NULL;+cd->dupnames = FALSE;+cd->dupgroups = FALSE;+cd->namedrefcount = 0;+cd->start_code = cworkspace;+cd->hwm = cworkspace;+cd->iscondassert = FALSE;+cd->start_workspace = cworkspace;+cd->workspace_size = COMPILE_WORK_SIZE;+cd->named_groups = named_groups;+cd->named_group_list_size = NAMED_GROUP_LIST_SIZE;+cd->start_pattern = (const pcre_uchar *)pattern;+cd->end_pattern = (const pcre_uchar *)(pattern + STRLEN_UC((const pcre_uchar *)pattern));+cd->req_varyopt = 0;+cd->parens_depth = 0;+cd->assert_depth = 0;+cd->max_lookbehind = 0;+cd->external_options = options;+cd->open_caps = NULL;++/* Now do the pre-compile. On error, errorcode will be set non-zero, so we+don't need to look at the result of the function here. The initial options have+been put into the cd block so that they can be changed if an option setting is+found within the regex right at the beginning. Bringing initial option settings+outside can help speed up starting point checks. */++ptr += skipatstart;+code = cworkspace;+*code = OP_BRA;++(void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,+ FALSE, 0, 0, &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL,+ cd, &length);+if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;++DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,+ (int)(cd->hwm - cworkspace)));++if (length > MAX_PATTERN_SIZE)+ {+ errorcode = ERR20;+ goto PCRE_EARLY_ERROR_RETURN;+ }++/* Compute the size of the data block for storing the compiled pattern. Integer+overflow should no longer be possible because nowadays we limit the maximum+value of cd->names_found and cd->name_entry_size. */++size = sizeof(REAL_PCRE) ++ (length + cd->names_found * cd->name_entry_size) * sizeof(pcre_uchar);++/* Get the memory. */++re = (REAL_PCRE *)(PUBL(malloc))(size);+if (re == NULL)+ {+ errorcode = ERR21;+ goto PCRE_EARLY_ERROR_RETURN;+ }++/* Put in the magic number, and save the sizes, initial options, internal+flags, and character table pointer. NULL is used for the default character+tables. The nullpad field is at 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->magic_number = MAGIC_NUMBER;+re->size = (int)size;+re->options = cd->external_options;+re->flags = cd->external_flags;+re->limit_match = limit_match;+re->limit_recursion = limit_recursion;+re->first_char = 0;+re->req_char = 0;+re->name_table_offset = sizeof(REAL_PCRE) / sizeof(pcre_uchar);+re->name_entry_size = cd->name_entry_size;+re->name_count = cd->names_found;+re->ref_count = 0;+re->tables = (tables == PRIV(default_tables))? NULL : tables;+re->nullpad = NULL;+#ifdef COMPILE_PCRE32+re->dummy = 0;+#else+re->dummy1 = re->dummy2 = re->dummy3 = 0;+#endif++/* The starting points of the name/number translation table and of the code are+passed around in the compile data block. The start/end pattern and initial+options are already set from the pre-compile phase, as is the name_entry_size+field. Reset the bracket count and the names_found field. Also reset the hwm+field; this time it's used for remembering forward references to subpatterns.+*/++cd->final_bracount = cd->bracount; /* Save for checking forward references */+cd->parens_depth = 0;+cd->assert_depth = 0;+cd->bracount = 0;+cd->max_lookbehind = 0;+cd->name_table = (pcre_uchar *)re + re->name_table_offset;+codestart = cd->name_table + re->name_entry_size * re->name_count;+cd->start_code = codestart;+cd->hwm = (pcre_uchar *)(cd->start_workspace);+cd->iscondassert = FALSE;+cd->req_varyopt = 0;+cd->had_accept = FALSE;+cd->had_pruneorskip = FALSE;+cd->check_lookbehind = FALSE;+cd->open_caps = NULL;++/* If any named groups were found, create the name/number table from the list+created in the first pass. */++if (cd->names_found > 0)+ {+ int i = cd->names_found;+ named_group *ng = cd->named_groups;+ cd->names_found = 0;+ for (; i > 0; i--, ng++)+ add_name(cd, ng->name, ng->length, ng->number);+ if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE)+ (PUBL(free))((void *)cd->named_groups);+ }++/* Set up a starting, non-extracting bracket, then compile the expression. On+error, errorcode will be set non-zero, so we don't need to look at the result+of the function here. */++ptr = (const pcre_uchar *)pattern + skipatstart;+code = (pcre_uchar *)codestart;+*code = OP_BRA;+(void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,+ &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL, cd, NULL);+re->top_bracket = cd->bracount;+re->top_backref = cd->top_backref;+re->max_lookbehind = cd->max_lookbehind;+re->flags = cd->external_flags | PCRE_MODE;++if (cd->had_accept)+ {+ reqchar = 0; /* Must disable after (*ACCEPT) */+ reqcharflags = REQ_NONE;+ }++/* If not reached end of pattern on success, there's an excess bracket. */++if (errorcode == 0 && *ptr != CHAR_NULL) errorcode = ERR22;++/* Fill in the terminating state and check for disastrous overflow, but+if debugging, leave the test till after things are printed out. */++*code++ = OP_END;++#ifndef PCRE_DEBUG+if (code - codestart > length) errorcode = ERR23;+#endif++#ifdef SUPPORT_VALGRIND+/* If the estimated length exceeds the really used length, mark the extra+allocated memory as unaddressable, so that any out-of-bound reads can be+detected. */+VALGRIND_MAKE_MEM_NOACCESS(code, (length - (code - codestart)) * sizeof(pcre_uchar));+#endif++/* Fill in any forward references that are required. There may be repeated+references; optimize for them, as searching a large regex takes time. */++if (cd->hwm > cd->start_workspace)+ {+ int prev_recno = -1;+ const pcre_uchar *groupptr = NULL;+ while (errorcode == 0 && cd->hwm > cd->start_workspace)+ {+ int offset, recno;+ cd->hwm -= LINK_SIZE;+ offset = GET(cd->hwm, 0);++ /* Check that the hwm handling hasn't gone wrong. This whole area is+ rewritten in PCRE2 because there are some obscure cases. */++ if (offset == 0 || codestart[offset-1] != OP_RECURSE)+ {+ errorcode = ERR10;+ break;+ }++ recno = GET(codestart, offset);+ if (recno != prev_recno)+ {+ groupptr = PRIV(find_bracket)(codestart, utf, recno);+ prev_recno = recno;+ }+ if (groupptr == NULL) errorcode = ERR53;+ else PUT(((pcre_uchar *)codestart), offset, (int)(groupptr - codestart));+ }+ }++/* If the workspace had to be expanded, free the new memory. Set the pointer to+NULL to indicate that forward references have been filled in. */++if (cd->workspace_size > COMPILE_WORK_SIZE)+ (PUBL(free))((void *)cd->start_workspace);+cd->start_workspace = NULL;++/* Give an error if there's back reference to a non-existent capturing+subpattern. */++if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;++/* Unless disabled, check whether any single character iterators can be+auto-possessified. The function overwrites the appropriate opcode values, so+the type of the pointer must be cast. NOTE: the intermediate variable "temp" is+used in this code because at least one compiler gives a warning about loss of+"const" attribute if the cast (pcre_uchar *)codestart is used directly in the+function call. */++if (errorcode == 0 && (options & PCRE_NO_AUTO_POSSESS) == 0)+ {+ pcre_uchar *temp = (pcre_uchar *)codestart;+ auto_possessify(temp, utf, cd);+ }++/* If there were any lookbehind assertions that contained OP_RECURSE+(recursions or subroutine calls), a flag is set for them to be checked here,+because they may contain forward references. Actual recursions cannot be fixed+length, but subroutine calls can. It is done like this so that those without+OP_RECURSE that are not fixed length get a diagnosic with a useful offset. The+exceptional ones forgo this. We scan the pattern to check that they are fixed+length, and set their lengths. */++if (errorcode == 0 && cd->check_lookbehind)+ {+ pcre_uchar *cc = (pcre_uchar *)codestart;++ /* Loop, searching for OP_REVERSE items, and process those that do not have+ their length set. (Actually, it will also re-process any that have a length+ of zero, but that is a pathological case, and it does no harm.) When we find+ one, we temporarily terminate the branch it is in while we scan it. */++ for (cc = (pcre_uchar *)PRIV(find_bracket)(codestart, utf, -1);+ cc != NULL;+ cc = (pcre_uchar *)PRIV(find_bracket)(cc, utf, -1))+ {+ if (GET(cc, 1) == 0)+ {+ int fixed_length;+ pcre_uchar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);+ int end_op = *be;+ *be = OP_END;+ fixed_length = find_fixedlength(cc, (re->options & PCRE_UTF8) != 0, TRUE,+ cd, NULL);+ *be = end_op;+ DPRINTF(("fixed length = %d\n", fixed_length));+ if (fixed_length < 0)+ {+ errorcode = (fixed_length == -2)? ERR36 :+ (fixed_length == -4)? ERR70 : ERR25;+ break;+ }+ if (fixed_length > cd->max_lookbehind) cd->max_lookbehind = fixed_length;+ PUT(cc, 1, fixed_length);+ }+ cc += 1 + LINK_SIZE;+ }+ }++/* Failed to compile, or error while post-processing */++if (errorcode != 0)+ {+ (PUBL(free))(re);+ PCRE_EARLY_ERROR_RETURN:+ *erroroffset = (int)(ptr - (const pcre_uchar *)pattern);+ PCRE_EARLY_ERROR_RETURN2:+ *errorptr = find_error_text(errorcode);+ if (errorcodeptr != NULL) *errorcodeptr = errorcode;+ return NULL;+ }++/* If the anchored option was not passed, set the flag if we can determine that+the pattern is anchored by virtue of ^ characters or \A or anything else, such+as starting with non-atomic .* when DOTALL is set and there are no occurrences+of *PRUNE or *SKIP.++Otherwise, if we know what the first byte has to be, save it, because that+speeds up unanchored matches no end. If not, see if we can set the+PCRE_STARTLINE flag. This is helpful for multiline matches when all branches+start with ^. and also when all branches start with non-atomic .* for+non-DOTALL matches when *PRUNE and SKIP are not present. */++if ((re->options & PCRE_ANCHORED) == 0)+ {+ if (is_anchored(codestart, 0, cd, 0)) re->options |= PCRE_ANCHORED;+ else+ {+ if (firstcharflags < 0)+ firstchar = find_firstassertedchar(codestart, &firstcharflags, FALSE);+ if (firstcharflags >= 0) /* Remove caseless flag for non-caseable chars */+ {+#if defined COMPILE_PCRE8+ re->first_char = firstchar & 0xff;+#elif defined COMPILE_PCRE16+ re->first_char = firstchar & 0xffff;+#elif defined COMPILE_PCRE32+ re->first_char = firstchar;+#endif+ if ((firstcharflags & REQ_CASELESS) != 0)+ {+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)+ /* We ignore non-ASCII first chars in 8 bit mode. */+ if (utf)+ {+ if (re->first_char < 128)+ {+ if (cd->fcc[re->first_char] != re->first_char)+ re->flags |= PCRE_FCH_CASELESS;+ }+ else if (UCD_OTHERCASE(re->first_char) != re->first_char)+ re->flags |= PCRE_FCH_CASELESS;+ }+ else+#endif+ if (MAX_255(re->first_char)+ && cd->fcc[re->first_char] != re->first_char)+ re->flags |= PCRE_FCH_CASELESS;+ }++ re->flags |= PCRE_FIRSTSET;+ }++ else if (is_startline(codestart, 0, cd, 0, FALSE)) re->flags |= PCRE_STARTLINE;+ }+ }++/* For an anchored pattern, we use the "required byte" only if it follows a+variable length item in the regex. Remove the caseless flag for non-caseable+bytes. */++if (reqcharflags >= 0 &&+ ((re->options & PCRE_ANCHORED) == 0 || (reqcharflags & REQ_VARY) != 0))+ {+#if defined COMPILE_PCRE8+ re->req_char = reqchar & 0xff;+#elif defined COMPILE_PCRE16+ re->req_char = reqchar & 0xffff;+#elif defined COMPILE_PCRE32+ re->req_char = reqchar;+#endif+ if ((reqcharflags & REQ_CASELESS) != 0)+ {+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)+ /* We ignore non-ASCII first chars in 8 bit mode. */+ if (utf)+ {+ if (re->req_char < 128)+ {+ if (cd->fcc[re->req_char] != re->req_char)+ re->flags |= PCRE_RCH_CASELESS;+ }+ else if (UCD_OTHERCASE(re->req_char) != re->req_char)+ re->flags |= PCRE_RCH_CASELESS;+ }+ else+#endif+ if (MAX_255(re->req_char) && cd->fcc[re->req_char] != re->req_char)+ re->flags |= PCRE_RCH_CASELESS;+ }++ re->flags |= PCRE_REQCHSET;+ }++/* Print out the compiled data if debugging is enabled. This is never the+case when building a production library. */++#ifdef PCRE_DEBUG+printf("Length = %d top_bracket = %d top_backref = %d\n",+ length, re->top_bracket, re->top_backref);++printf("Options=%08x\n", re->options);++if ((re->flags & PCRE_FIRSTSET) != 0)+ {+ pcre_uchar ch = re->first_char;+ const char *caseless =+ ((re->flags & PCRE_FCH_CASELESS) == 0)? "" : " (caseless)";+ if (PRINTABLE(ch)) printf("First char = %c%s\n", ch, caseless);+ else printf("First char = \\x%02x%s\n", ch, caseless);+ }++if ((re->flags & PCRE_REQCHSET) != 0)+ {+ pcre_uchar ch = re->req_char;+ const char *caseless =+ ((re->flags & PCRE_RCH_CASELESS) == 0)? "" : " (caseless)";+ if (PRINTABLE(ch)) printf("Req char = %c%s\n", ch, caseless);+ else printf("Req char = \\x%02x%s\n", ch, caseless);+ }++#if defined COMPILE_PCRE8+pcre_printint((pcre *)re, stdout, TRUE);+#elif defined COMPILE_PCRE16+pcre16_printint((pcre *)re, stdout, TRUE);+#elif defined COMPILE_PCRE32+pcre32_printint((pcre *)re, stdout, TRUE);+#endif++/* This check is done here in the debugging case so that the code that+was compiled can be seen. */++if (code - codestart > length)+ {+ (PUBL(free))(re);+ *errorptr = find_error_text(ERR23);+ *erroroffset = ptr - (pcre_uchar *)pattern;+ if (errorcodeptr != NULL) *errorcodeptr = ERR23;+ return NULL;+ }+#endif /* PCRE_DEBUG */++/* Check for a pattern than can match an empty string, so that this information+can be provided to applications. */++do+ {+ if (could_be_empty_branch(codestart, code, utf, cd, NULL))+ {+ re->flags |= PCRE_MATCH_EMPTY;+ break;+ }+ codestart += GET(codestart, 1);+ }+while (*codestart == OP_ALT);++#if defined COMPILE_PCRE8+return (pcre *)re;+#elif defined COMPILE_PCRE16+return (pcre16 *)re;+#elif defined COMPILE_PCRE32+return (pcre32 *)re;+#endif+}++/* End of pcre_compile.c */
pcre/pcre_dfa_exec.c view
@@ -7,7 +7,7 @@ below for why this module is different). Written by Philip Hazel- Copyright (c) 1997-2013 University of Cambridge+ Copyright (c) 1997-2017 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without@@ -1473,7 +1473,7 @@ goto ANYNL01; case CHAR_CR:- if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;+ if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; /* Fall through */ ANYNL01:@@ -1742,7 +1742,7 @@ goto ANYNL02; case CHAR_CR:- if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;+ if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; /* Fall through */ ANYNL02:@@ -2012,7 +2012,7 @@ goto ANYNL03; case CHAR_CR:- if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;+ if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1; /* Fall through */ ANYNL03:@@ -2210,7 +2210,7 @@ if ((md->moptions & PCRE_PARTIAL_HARD) != 0) reset_could_continue = TRUE; }- else if (RAWUCHARTEST(ptr + 1) == CHAR_LF)+ else if (UCHAR21TEST(ptr + 1) == CHAR_LF) { ADD_NEW_DATA(-(state_offset + 1), 0, 1); }@@ -2287,12 +2287,14 @@ case OP_NOTI: if (clen > 0) {- unsigned int otherd;+ pcre_uint32 otherd; #ifdef SUPPORT_UTF if (utf && d >= 128) { #ifdef SUPPORT_UCP otherd = UCD_OTHERCASE(d);+#else+ otherd = d; #endif /* SUPPORT_UCP */ } else@@ -2625,7 +2627,7 @@ if (isinclass) { int max = (int)GET2(ecode, 1 + IMM2_SIZE);- if (*ecode == OP_CRPOSRANGE)+ if (*ecode == OP_CRPOSRANGE && count >= (int)GET2(ecode, 1)) { active_count--; /* Remove non-match possibility */ next_active_state--;@@ -2736,9 +2738,10 @@ condcode == OP_DNRREF) return PCRE_ERROR_DFA_UCOND; - /* The DEFINE condition is always false */+ /* The DEFINE condition is always false, and the assertion (?!) is+ converted to OP_FAIL. */ - if (condcode == OP_DEF)+ if (condcode == OP_DEF || condcode == OP_FAIL) { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); } /* The only supported version of OP_RREF is for the value RREF_ANY,@@ -3242,7 +3245,7 @@ if (extra_data != NULL) {- unsigned int flags = extra_data->flags;+ unsigned long int flags = extra_data->flags; if ((flags & PCRE_EXTRA_STUDY_DATA) != 0) study = (const pcre_study_data *)extra_data->study_data; if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0) return PCRE_ERROR_DFA_UMLIMIT;@@ -3466,7 +3469,7 @@ if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0) {- /* Advance to a known first char. */+ /* Advance to a known first pcre_uchar (i.e. data item) */ if (has_first_char) {@@ -3474,12 +3477,12 @@ { pcre_uchar csc; while (current_subject < end_subject &&- (csc = RAWUCHARTEST(current_subject)) != first_char && csc != first_char2)+ (csc = UCHAR21TEST(current_subject)) != first_char && csc != first_char2) current_subject++; } else while (current_subject < end_subject &&- RAWUCHARTEST(current_subject) != first_char)+ UCHAR21TEST(current_subject) != first_char) current_subject++; } @@ -3509,36 +3512,26 @@ ANYCRLF, and we are now at a LF, advance the match position by one more character. */ - if (RAWUCHARTEST(current_subject - 1) == CHAR_CR &&+ if (UCHAR21TEST(current_subject - 1) == CHAR_CR && (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) && current_subject < end_subject &&- RAWUCHARTEST(current_subject) == CHAR_NL)+ UCHAR21TEST(current_subject) == CHAR_NL) current_subject++; } } - /* Or to a non-unique first char after study */+ /* Advance to a non-unique first pcre_uchar after study */ else if (start_bits != NULL) { while (current_subject < end_subject) {- register pcre_uint32 c = RAWUCHARTEST(current_subject);+ register pcre_uint32 c = UCHAR21TEST(current_subject); #ifndef COMPILE_PCRE8 if (c > 255) c = 255; #endif- if ((start_bits[c/8] & (1 << (c&7))) == 0)- {- current_subject++;-#if defined SUPPORT_UTF && defined COMPILE_PCRE8- /* In non 8-bit mode, the iteration will stop for- characters > 255 at the beginning or not stop at all. */- if (utf)- ACROSSCHAR(current_subject < end_subject, *current_subject,- current_subject++);-#endif- }- else break;+ if ((start_bits[c/8] & (1 << (c&7))) != 0) break;+ current_subject++; } } }@@ -3557,19 +3550,20 @@ /* If the pattern was studied, a minimum subject length may be set. This is a lower bound; no actual string of that length may actually match the pattern. Although the value is, strictly, in characters, we treat it as- bytes to avoid spending too much time in this optimization. */+ in pcre_uchar units to avoid spending too much time in this optimization.+ */ if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 && (pcre_uint32)(end_subject - current_subject) < study->minlength) return PCRE_ERROR_NOMATCH; - /* If req_char is set, we know that that character must appear in the- subject for the match to succeed. If the first character is set, req_char- must be later in the subject; otherwise the test starts at the match- point. This optimization can save a huge amount of work in patterns with- nested unlimited repeats that aren't going to match. Writing separate- code for cased/caseless versions makes it go faster, as does using an- autoincrement and backing off on a match.+ /* If req_char is set, we know that that pcre_uchar must appear in the+ subject for the match to succeed. If the first pcre_uchar is set,+ req_char must be later in the subject; otherwise the test starts at the+ match point. This optimization can save a huge amount of work in patterns+ with nested unlimited repeats that aren't going to match. Writing+ separate code for cased/caseless versions makes it go faster, as does+ using an autoincrement and backing off on a match. HOWEVER: when the subject string is very, very long, searching to its end can take a long time, and give bad performance on quite ordinary@@ -3589,7 +3583,7 @@ { while (p < end_subject) {- register pcre_uint32 pp = RAWUCHARINCTEST(p);+ register pcre_uint32 pp = UCHAR21INCTEST(p); if (pp == req_char || pp == req_char2) { p--; break; } } }@@ -3597,18 +3591,18 @@ { while (p < end_subject) {- if (RAWUCHARINCTEST(p) == req_char) { p--; break; }+ if (UCHAR21INCTEST(p) == req_char) { p--; break; } } } - /* If we can't find the required character, break the matching loop,+ /* If we can't find the required pcre_uchar, break the matching loop, which will cause a return or PCRE_ERROR_NOMATCH. */ if (p >= end_subject) break; - /* If we have found the required character, save the point where we+ /* If we have found the required pcre_uchar, save the point where we found it, so that we don't search again next time round the loop if- the start hasn't passed this character yet. */+ the start hasn't passed this point yet. */ req_char_ptr = p; }@@ -3665,9 +3659,9 @@ not contain any explicit matches for \r or \n, and the newline option is CRLF or ANY or ANYCRLF, advance the match position by one more character. */ - if (RAWUCHARTEST(current_subject - 1) == CHAR_CR &&+ if (UCHAR21TEST(current_subject - 1) == CHAR_CR && current_subject < end_subject &&- RAWUCHARTEST(current_subject) == CHAR_NL &&+ UCHAR21TEST(current_subject) == CHAR_NL && (re->flags & PCRE_HASCRORLF) == 0 && (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF ||
pcre/pcre_exec.c view
@@ -6,7 +6,7 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel- Copyright (c) 1997-2013 University of Cambridge+ Copyright (c) 1997-2018 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without@@ -134,7 +134,7 @@ BOOL utf = md->utf; if (is_subject && length > md->end_subject - p) length = md->end_subject - p; while (length-- > 0)- if (isprint(c = RAWUCHARINCTEST(p))) printf("%c", (char)c); else printf("\\x{%02x}", c);+ if (isprint(c = UCHAR21INCTEST(p))) printf("%c", (char)c); else printf("\\x{%02x}", c); } #endif @@ -237,8 +237,8 @@ { pcre_uint32 cc, cp; if (eptr >= md->end_subject) return -2; /* Partial match */- cc = RAWUCHARTEST(eptr);- cp = RAWUCHARTEST(p);+ cc = UCHAR21TEST(eptr);+ cp = UCHAR21TEST(p); if (TABLE_GET(cp, md->lcc, cp) != TABLE_GET(cc, md->lcc, cc)) return -1; p++; eptr++;@@ -254,7 +254,7 @@ while (length-- > 0) { if (eptr >= md->end_subject) return -2; /* Partial match */- if (RAWUCHARINCTEST(p) != RAWUCHARINCTEST(eptr)) return -1;+ if (UCHAR21INCTEST(p) != UCHAR21INCTEST(eptr)) return -1; } } @@ -669,7 +669,7 @@ return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1); else {- int len = (char *)&rdepth - (char *)eptr;+ int len = (int)((char *)&rdepth - (char *)eptr); return (len > 0)? -len : len; } }@@ -1136,88 +1136,81 @@ printf("\n"); #endif - if (offset < md->offset_max)- {- matched_once = FALSE;- code_offset = (int)(ecode - md->start_code);-- save_offset1 = md->offset_vector[offset];- save_offset2 = md->offset_vector[offset+1];- save_offset3 = md->offset_vector[md->offset_end - number];- save_capture_last = md->capture_last;+ if (offset >= md->offset_max) goto POSSESSIVE_NON_CAPTURE; - DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));+ matched_once = FALSE;+ code_offset = (int)(ecode - md->start_code); - /* Each time round the loop, save the current subject position for use- when the group matches. For MATCH_MATCH, the group has matched, so we- restart it with a new subject starting position, remembering that we had- at least one match. For MATCH_NOMATCH, carry on with the alternatives, as- usual. If we haven't matched any alternatives in any iteration, check to- see if a previous iteration matched. If so, the group has matched;- continue from afterwards. Otherwise it has failed; restore the previous- capture values before returning NOMATCH. */+ save_offset1 = md->offset_vector[offset];+ save_offset2 = md->offset_vector[offset+1];+ save_offset3 = md->offset_vector[md->offset_end - number];+ save_capture_last = md->capture_last; - for (;;)- {- md->offset_vector[md->offset_end - number] =- (int)(eptr - md->start_subject);- if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;- RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,- eptrb, RM63);- if (rrc == MATCH_KETRPOS)- {- offset_top = md->end_offset_top;- eptr = md->end_match_ptr;- ecode = md->start_code + code_offset;- save_capture_last = md->capture_last;- matched_once = TRUE;- mstart = md->start_match_ptr; /* In case \K changed it */- continue;- }+ DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3)); - /* See comment in the code for capturing groups above about handling- THEN. */+ /* Each time round the loop, save the current subject position for use+ when the group matches. For MATCH_MATCH, the group has matched, so we+ restart it with a new subject starting position, remembering that we had+ at least one match. For MATCH_NOMATCH, carry on with the alternatives, as+ usual. If we haven't matched any alternatives in any iteration, check to+ see if a previous iteration matched. If so, the group has matched;+ continue from afterwards. Otherwise it has failed; restore the previous+ capture values before returning NOMATCH. */ - if (rrc == MATCH_THEN)+ for (;;)+ {+ md->offset_vector[md->offset_end - number] =+ (int)(eptr - md->start_subject);+ if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;+ RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,+ eptrb, RM63);+ if (rrc == MATCH_KETRPOS)+ {+ offset_top = md->end_offset_top;+ ecode = md->start_code + code_offset;+ save_capture_last = md->capture_last;+ matched_once = TRUE;+ mstart = md->start_match_ptr; /* In case \K changed it */+ if (eptr == md->end_match_ptr) /* Matched an empty string */ {- next = ecode + GET(ecode,1);- if (md->start_match_ptr < next &&- (*ecode == OP_ALT || *next == OP_ALT))- rrc = MATCH_NOMATCH;+ do ecode += GET(ecode, 1); while (*ecode == OP_ALT);+ break; }-- if (rrc != MATCH_NOMATCH) RRETURN(rrc);- md->capture_last = save_capture_last;- ecode += GET(ecode, 1);- if (*ecode != OP_ALT) break;+ eptr = md->end_match_ptr;+ continue; } - if (!matched_once)- {- md->offset_vector[offset] = save_offset1;- md->offset_vector[offset+1] = save_offset2;- md->offset_vector[md->offset_end - number] = save_offset3;- }+ /* See comment in the code for capturing groups above about handling+ THEN. */ - if (allow_zero || matched_once)+ if (rrc == MATCH_THEN) {- ecode += 1 + LINK_SIZE;- break;+ next = ecode + GET(ecode,1);+ if (md->start_match_ptr < next &&+ (*ecode == OP_ALT || *next == OP_ALT))+ rrc = MATCH_NOMATCH; } - RRETURN(MATCH_NOMATCH);+ if (rrc != MATCH_NOMATCH) RRETURN(rrc);+ md->capture_last = save_capture_last;+ ecode += GET(ecode, 1);+ if (*ecode != OP_ALT) break; } - /* FALL THROUGH ... Insufficient room for saving captured contents. Treat- as a non-capturing bracket. */-- /* VVVVVVVVVVVVVVVVVVVVVVVVV */- /* VVVVVVVVVVVVVVVVVVVVVVVVV */+ if (!matched_once)+ {+ md->offset_vector[offset] = save_offset1;+ md->offset_vector[offset+1] = save_offset2;+ md->offset_vector[md->offset_end - number] = save_offset3;+ } - DPRINTF(("insufficient capture room: treat as non-capturing\n"));+ if (allow_zero || matched_once)+ {+ ecode += 1 + LINK_SIZE;+ break;+ } - /* VVVVVVVVVVVVVVVVVVVVVVVVV */- /* VVVVVVVVVVVVVVVVVVVVVVVVV */+ RRETURN(MATCH_NOMATCH); /* Non-capturing possessive bracket with unlimited repeat. We come here from BRAZERO with allow_zero = TRUE. The code is similar to the above,@@ -1241,10 +1234,15 @@ if (rrc == MATCH_KETRPOS) { offset_top = md->end_offset_top;- eptr = md->end_match_ptr; ecode = md->start_code + code_offset; matched_once = TRUE; mstart = md->start_match_ptr; /* In case \K reset it */+ if (eptr == md->end_match_ptr) /* Matched an empty string */+ {+ do ecode += GET(ecode, 1); while (*ecode == OP_ALT);+ break;+ }+ eptr = md->end_match_ptr; continue; } @@ -1378,6 +1376,7 @@ break; case OP_DEF: /* DEFINE - always false */+ case OP_FAIL: /* From optimized (?!) condition */ break; /* The condition is an assertion. Call match() to evaluate it - setting@@ -1394,8 +1393,11 @@ condition = TRUE; /* Advance ecode past the assertion to the start of the first branch,- but adjust it so that the general choosing code below works. */+ but adjust it so that the general choosing code below works. If the+ assertion has a quantifier that allows zero repeats we must skip over+ the BRAZERO. This is a lunatic thing to do, but somebody did! */ + if (*ecode == OP_BRAZERO) ecode++; ecode += GET(ecode, 1); while (*ecode == OP_ALT) ecode += GET(ecode, 1); ecode += 1 + LINK_SIZE - PRIV(OP_lengths)[condcode];@@ -1464,7 +1466,18 @@ md->offset_vector[offset] = md->offset_vector[md->offset_end - number]; md->offset_vector[offset+1] = (int)(eptr - md->start_subject);- if (offset_top <= offset) offset_top = offset + 2;++ /* If this group is at or above the current highwater mark, ensure that+ any groups between the current high water mark and this group are marked+ unset and then update the high water mark. */++ if (offset >= offset_top)+ {+ register int *iptr = md->offset_vector + offset_top;+ register int *iend = md->offset_vector + offset;+ while (iptr < iend) *iptr++ = -1;+ offset_top = offset + 2;+ } } ecode += 1 + IMM2_SIZE; break;@@ -1816,7 +1829,11 @@ are defined in a range that can be tested for. */ if (rrc >= MATCH_BACKTRACK_MIN && rrc <= MATCH_BACKTRACK_MAX)+ {+ if (new_recursive.offset_save != stacksave)+ (PUBL(free))(new_recursive.offset_save); RRETURN(MATCH_NOMATCH);+ } /* Any return code other than NOMATCH is an error. */ @@ -1979,6 +1996,19 @@ } } + /* OP_KETRPOS is a possessive repeating ket. Remember the current position,+ and return the MATCH_KETRPOS. This makes it possible to do the repeats one+ at a time from the outer level, thus saving stack. This must precede the+ empty string test - in this case that test is done at the outer level. */++ if (*ecode == OP_KETRPOS)+ {+ md->start_match_ptr = mstart; /* In case \K reset it */+ md->end_match_ptr = eptr;+ md->end_offset_top = offset_top;+ RRETURN(MATCH_KETRPOS);+ }+ /* For an ordinary non-repeating ket, just continue at this level. This also happens for a repeating ket if no characters were matched in the group. This is the forcible breaking of infinite loops as implemented in@@ -2001,18 +2031,6 @@ break; } - /* OP_KETRPOS is a possessive repeating ket. Remember the current position,- and return the MATCH_KETRPOS. This makes it possible to do the repeats one- at a time from the outer level, thus saving stack. */-- if (*ecode == OP_KETRPOS)- {- md->start_match_ptr = mstart; /* In case \K reset it */- md->end_match_ptr = eptr;- md->end_offset_top = offset_top;- RRETURN(MATCH_KETRPOS);- }- /* The normal repeating kets try the rest of the pattern or restart from the preceding bracket, in the appropriate order. In the second case, we can use tail recursion to avoid using another stack frame, unless we have an@@ -2103,7 +2121,7 @@ eptr + 1 >= md->end_subject && NLBLOCK->nltype == NLTYPE_FIXED && NLBLOCK->nllen == 2 &&- RAWUCHARTEST(eptr) == NLBLOCK->nl[0])+ UCHAR21TEST(eptr) == NLBLOCK->nl[0]) { md->hitend = TRUE; if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);@@ -2147,7 +2165,7 @@ eptr + 1 >= md->end_subject && NLBLOCK->nltype == NLTYPE_FIXED && NLBLOCK->nllen == 2 &&- RAWUCHARTEST(eptr) == NLBLOCK->nl[0])+ UCHAR21TEST(eptr) == NLBLOCK->nl[0]) { md->hitend = TRUE; if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);@@ -2287,10 +2305,10 @@ case OP_ANY: if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); if (md->partial != 0 &&- eptr + 1 >= md->end_subject &&+ eptr == md->end_subject - 1 && NLBLOCK->nltype == NLTYPE_FIXED && NLBLOCK->nllen == 2 &&- RAWUCHARTEST(eptr) == NLBLOCK->nl[0])+ UCHAR21TEST(eptr) == NLBLOCK->nl[0]) { md->hitend = TRUE; if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);@@ -2444,7 +2462,7 @@ { SCHECK_PARTIAL(); }- else if (RAWUCHARTEST(eptr) == CHAR_LF) eptr++;+ else if (UCHAR21TEST(eptr) == CHAR_LF) eptr++; break; case CHAR_LF:@@ -2691,16 +2709,22 @@ pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size; ecode += 1 + 2*IMM2_SIZE; + /* Setting the default length first and initializing 'offset' avoids+ compiler warnings in the REF_REPEAT code. */++ length = (md->jscript_compat)? 0 : -1;+ offset = 0;+ while (count-- > 0) { offset = GET2(slot, 0) << 1;- if (offset < offset_top && md->offset_vector[offset] >= 0) break;+ if (offset < offset_top && md->offset_vector[offset] >= 0)+ {+ length = md->offset_vector[offset+1] - md->offset_vector[offset];+ break;+ } slot += md->name_entry_size; }- if (count < 0)- length = (md->jscript_compat)? 0 : -1;- else- length = md->offset_vector[offset+1] - md->offset_vector[offset]; } goto REF_REPEAT; @@ -3029,7 +3053,7 @@ { RMATCH(eptr, ecode, offset_top, md, eptrb, RM18); if (rrc != MATCH_NOMATCH) RRETURN(rrc);- if (eptr-- == pp) break; /* Stop if tried at original pos */+ if (eptr-- <= pp) break; /* Stop if tried at original pos */ BACKCHAR(eptr); } }@@ -3186,7 +3210,7 @@ { RMATCH(eptr, ecode, offset_top, md, eptrb, RM21); if (rrc != MATCH_NOMATCH) RRETURN(rrc);- if (eptr-- == pp) break; /* Stop if tried at original pos */+ if (eptr-- <= pp) break; /* Stop if tried at original pos */ #ifdef SUPPORT_UTF if (utf) BACKCHAR(eptr); #endif@@ -3212,7 +3236,7 @@ CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */ RRETURN(MATCH_NOMATCH); }- while (length-- > 0) if (*ecode++ != RAWUCHARINC(eptr)) RRETURN(MATCH_NOMATCH);+ while (length-- > 0) if (*ecode++ != UCHAR21INC(eptr)) RRETURN(MATCH_NOMATCH); } else #endif@@ -3252,7 +3276,7 @@ if (fc < 128) {- pcre_uint32 cc = RAWUCHAR(eptr);+ pcre_uint32 cc = UCHAR21(eptr); if (md->lcc[fc] != TABLE_GET(cc, md->lcc, cc)) RRETURN(MATCH_NOMATCH); ecode++; eptr++;@@ -3459,7 +3483,7 @@ if (possessive) continue; /* No backtracking */ for(;;) {- if (eptr == pp) goto TAIL_RECURSE;+ if (eptr <= pp) goto TAIL_RECURSE; RMATCH(eptr, ecode, offset_top, md, eptrb, RM23); if (rrc != MATCH_NOMATCH) RRETURN(rrc); #ifdef SUPPORT_UCP@@ -3521,7 +3545,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- cc = RAWUCHARTEST(eptr);+ cc = UCHAR21TEST(eptr); if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH); eptr++; }@@ -3539,7 +3563,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- cc = RAWUCHARTEST(eptr);+ cc = UCHAR21TEST(eptr); if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH); eptr++; }@@ -3556,7 +3580,7 @@ SCHECK_PARTIAL(); break; }- cc = RAWUCHARTEST(eptr);+ cc = UCHAR21TEST(eptr); if (fc != cc && foc != cc) break; eptr++; }@@ -3583,7 +3607,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- if (fc != RAWUCHARINCTEST(eptr)) RRETURN(MATCH_NOMATCH);+ if (fc != UCHAR21INCTEST(eptr)) RRETURN(MATCH_NOMATCH); } if (min == max) continue;@@ -3600,7 +3624,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- if (fc != RAWUCHARINCTEST(eptr)) RRETURN(MATCH_NOMATCH);+ if (fc != UCHAR21INCTEST(eptr)) RRETURN(MATCH_NOMATCH); } /* Control never gets here */ }@@ -3614,7 +3638,7 @@ SCHECK_PARTIAL(); break; }- if (fc != RAWUCHARTEST(eptr)) break;+ if (fc != UCHAR21TEST(eptr)) break; eptr++; } if (possessive) continue; /* No backtracking */@@ -3880,7 +3904,7 @@ if (possessive) continue; /* No backtracking */ for(;;) {- if (eptr == pp) goto TAIL_RECURSE;+ if (eptr <= pp) goto TAIL_RECURSE; RMATCH(eptr, ecode, offset_top, md, eptrb, RM30); if (rrc != MATCH_NOMATCH) RRETURN(rrc); eptr--;@@ -4015,7 +4039,7 @@ if (possessive) continue; /* No backtracking */ for(;;) {- if (eptr == pp) goto TAIL_RECURSE;+ if (eptr <= pp) goto TAIL_RECURSE; RMATCH(eptr, ecode, offset_top, md, eptrb, RM34); if (rrc != MATCH_NOMATCH) RRETURN(rrc); eptr--;@@ -4369,7 +4393,7 @@ eptr + 1 >= md->end_subject && NLBLOCK->nltype == NLTYPE_FIXED && NLBLOCK->nllen == 2 &&- RAWUCHAR(eptr) == NLBLOCK->nl[0])+ UCHAR21(eptr) == NLBLOCK->nl[0]) { md->hitend = TRUE; if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);@@ -4411,7 +4435,7 @@ default: RRETURN(MATCH_NOMATCH); case CHAR_CR:- if (eptr < md->end_subject && RAWUCHAR(eptr) == CHAR_LF) eptr++;+ if (eptr < md->end_subject && UCHAR21(eptr) == CHAR_LF) eptr++; break; case CHAR_LF:@@ -4521,7 +4545,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- cc = RAWUCHAR(eptr);+ cc = UCHAR21(eptr); if (cc >= 128 || (md->ctypes[cc] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH); eptr++;@@ -4538,7 +4562,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- cc = RAWUCHAR(eptr);+ cc = UCHAR21(eptr); if (cc < 128 && (md->ctypes[cc] & ctype_space) != 0) RRETURN(MATCH_NOMATCH); eptr++;@@ -4555,7 +4579,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- cc = RAWUCHAR(eptr);+ cc = UCHAR21(eptr); if (cc >= 128 || (md->ctypes[cc] & ctype_space) == 0) RRETURN(MATCH_NOMATCH); eptr++;@@ -4572,7 +4596,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- cc = RAWUCHAR(eptr);+ cc = UCHAR21(eptr); if (cc < 128 && (md->ctypes[cc] & ctype_word) != 0) RRETURN(MATCH_NOMATCH); eptr++;@@ -4589,7 +4613,7 @@ SCHECK_PARTIAL(); RRETURN(MATCH_NOMATCH); }- cc = RAWUCHAR(eptr);+ cc = UCHAR21(eptr); if (cc >= 128 || (md->ctypes[cc] & ctype_word) == 0) RRETURN(MATCH_NOMATCH); eptr++;@@ -5150,7 +5174,7 @@ { default: RRETURN(MATCH_NOMATCH); case CHAR_CR:- if (eptr < md->end_subject && RAWUCHAR(eptr) == CHAR_LF) eptr++;+ if (eptr < md->end_subject && UCHAR21(eptr) == CHAR_LF) eptr++; break; case CHAR_LF:@@ -5586,7 +5610,7 @@ if (possessive) continue; /* No backtracking */ for(;;) {- if (eptr == pp) goto TAIL_RECURSE;+ if (eptr <= pp) goto TAIL_RECURSE; RMATCH(eptr, ecode, offset_top, md, eptrb, RM44); if (rrc != MATCH_NOMATCH) RRETURN(rrc); eptr--;@@ -5628,12 +5652,17 @@ if (possessive) continue; /* No backtracking */ + /* We use <= pp rather than == pp to detect the start of the run while+ backtracking because the use of \C in UTF mode can cause BACKCHAR to+ move back past pp. This is just palliative; the use of \C in UTF mode+ is fraught with danger. */+ for(;;) { int lgb, rgb; PCRE_PUCHAR fptr; - if (eptr == pp) goto TAIL_RECURSE; /* At start of char run */+ if (eptr <= pp) goto TAIL_RECURSE; /* At start of char run */ RMATCH(eptr, ecode, offset_top, md, eptrb, RM45); if (rrc != MATCH_NOMATCH) RRETURN(rrc); @@ -5651,7 +5680,7 @@ for (;;) {- if (eptr == pp) goto TAIL_RECURSE; /* At start of char run */+ if (eptr <= pp) goto TAIL_RECURSE; /* At start of char run */ fptr = eptr - 1; if (!utf) c = *fptr; else {@@ -5675,54 +5704,25 @@ switch(ctype) { case OP_ANY:- if (max < INT_MAX)+ for (i = min; i < max; i++) {- for (i = min; i < max; i++)+ if (eptr >= md->end_subject) {- if (eptr >= md->end_subject)- {- SCHECK_PARTIAL();- break;- }- if (IS_NEWLINE(eptr)) break;- if (md->partial != 0 && /* Take care with CRLF partial */- eptr + 1 >= md->end_subject &&- NLBLOCK->nltype == NLTYPE_FIXED &&- NLBLOCK->nllen == 2 &&- RAWUCHAR(eptr) == NLBLOCK->nl[0])- {- md->hitend = TRUE;- if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);- }- eptr++;- ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);+ SCHECK_PARTIAL();+ break; }- }-- /* Handle unlimited UTF-8 repeat */-- else- {- for (i = min; i < max; i++)+ if (IS_NEWLINE(eptr)) break;+ if (md->partial != 0 && /* Take care with CRLF partial */+ eptr + 1 >= md->end_subject &&+ NLBLOCK->nltype == NLTYPE_FIXED &&+ NLBLOCK->nllen == 2 &&+ UCHAR21(eptr) == NLBLOCK->nl[0]) {- if (eptr >= md->end_subject)- {- SCHECK_PARTIAL();- break;- }- if (IS_NEWLINE(eptr)) break;- if (md->partial != 0 && /* Take care with CRLF partial */- eptr + 1 >= md->end_subject &&- NLBLOCK->nltype == NLTYPE_FIXED &&- NLBLOCK->nllen == 2 &&- RAWUCHAR(eptr) == NLBLOCK->nl[0])- {- md->hitend = TRUE;- if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);- }- eptr++;- ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);+ md->hitend = TRUE;+ if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); }+ eptr++;+ ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++); } break; @@ -5772,7 +5772,7 @@ if (c == CHAR_CR) { if (++eptr >= md->end_subject) break;- if (RAWUCHAR(eptr) == CHAR_LF) eptr++;+ if (UCHAR21(eptr) == CHAR_LF) eptr++; } else {@@ -5930,13 +5930,13 @@ if (possessive) continue; /* No backtracking */ for(;;) {- if (eptr == pp) goto TAIL_RECURSE;+ if (eptr <= pp) goto TAIL_RECURSE; RMATCH(eptr, ecode, offset_top, md, eptrb, RM46); if (rrc != MATCH_NOMATCH) RRETURN(rrc); eptr--; BACKCHAR(eptr);- if (ctype == OP_ANYNL && eptr > pp && RAWUCHAR(eptr) == CHAR_NL &&- RAWUCHAR(eptr - 1) == CHAR_CR) eptr--;+ if (ctype == OP_ANYNL && eptr > pp && UCHAR21(eptr) == CHAR_NL &&+ UCHAR21(eptr - 1) == CHAR_CR) eptr--; } } else@@ -6513,7 +6513,7 @@ if (extra_data != NULL) {- register unsigned int flags = extra_data->flags;+ unsigned long int flags = extra_data->flags; if ((flags & PCRE_EXTRA_STUDY_DATA) != 0) study = (const pcre_study_data *)extra_data->study_data; if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)@@ -6685,7 +6685,8 @@ register int *iend = iptr - re->top_bracket; if (iend < md->offset_vector + 2) iend = md->offset_vector + 2; while (--iptr >= iend) *iptr = -1;- md->offset_vector[0] = md->offset_vector[1] = -1;+ if (offsetcount > 0) md->offset_vector[0] = -1;+ if (offsetcount > 1) md->offset_vector[1] = -1; } /* Set up the first character to match, if available. The first_char value is@@ -6783,10 +6784,10 @@ if (first_char != first_char2) while (start_match < end_subject &&- (smc = RAWUCHARTEST(start_match)) != first_char && smc != first_char2)+ (smc = UCHAR21TEST(start_match)) != first_char && smc != first_char2) start_match++; else- while (start_match < end_subject && RAWUCHARTEST(start_match) != first_char)+ while (start_match < end_subject && UCHAR21TEST(start_match) != first_char) start_match++; } @@ -6818,7 +6819,7 @@ if (start_match[-1] == CHAR_CR && (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) && start_match < end_subject &&- RAWUCHARTEST(start_match) == CHAR_NL)+ UCHAR21TEST(start_match) == CHAR_NL) start_match++; } }@@ -6829,22 +6830,12 @@ { while (start_match < end_subject) {- register pcre_uint32 c = RAWUCHARTEST(start_match);+ register pcre_uint32 c = UCHAR21TEST(start_match); #ifndef COMPILE_PCRE8 if (c > 255) c = 255; #endif- if ((start_bits[c/8] & (1 << (c&7))) == 0)- {- start_match++;-#if defined SUPPORT_UTF && defined COMPILE_PCRE8- /* In non 8-bit mode, the iteration will stop for- characters > 255 at the beginning or not stop at all. */- if (utf)- ACROSSCHAR(start_match < end_subject, *start_match,- start_match++);-#endif- }- else break;+ if ((start_bits[c/8] & (1 << (c&7))) != 0) break;+ start_match++; } } } /* Starting optimizations */@@ -6897,7 +6888,7 @@ { while (p < end_subject) {- register pcre_uint32 pp = RAWUCHARINCTEST(p);+ register pcre_uint32 pp = UCHAR21INCTEST(p); if (pp == req_char || pp == req_char2) { p--; break; } } }@@ -6905,7 +6896,7 @@ { while (p < end_subject) {- if (RAWUCHARINCTEST(p) == req_char) { p--; break; }+ if (UCHAR21INCTEST(p) == req_char) { p--; break; } } }
pcre/pcre_get.c view
@@ -250,6 +250,7 @@ code the compiled regex stringname the name of the capturing substring ovector the vector of matched substrings+ stringcount number of captured substrings Returns: the number of the first that is set, or the number of the last one if none are set,@@ -258,13 +259,16 @@ #if defined COMPILE_PCRE8 static int-get_first_set(const pcre *code, const char *stringname, int *ovector)+get_first_set(const pcre *code, const char *stringname, int *ovector,+ int stringcount) #elif defined COMPILE_PCRE16 static int-get_first_set(const pcre16 *code, PCRE_SPTR16 stringname, int *ovector)+get_first_set(const pcre16 *code, PCRE_SPTR16 stringname, int *ovector,+ int stringcount) #elif defined COMPILE_PCRE32 static int-get_first_set(const pcre32 *code, PCRE_SPTR32 stringname, int *ovector)+get_first_set(const pcre32 *code, PCRE_SPTR32 stringname, int *ovector,+ int stringcount) #endif { const REAL_PCRE *re = (const REAL_PCRE *)code;@@ -295,7 +299,7 @@ for (entry = (pcre_uchar *)first; entry <= (pcre_uchar *)last; entry += entrysize) { int n = GET2(entry, 0);- if (ovector[n*2] >= 0) return n;+ if (n < stringcount && ovector[n*2] >= 0) return n; } return GET2(entry, 0); }@@ -402,7 +406,7 @@ PCRE_UCHAR32 *buffer, int size) #endif {-int n = get_first_set(code, stringname, ovector);+int n = get_first_set(code, stringname, ovector, stringcount); if (n <= 0) return n; #if defined COMPILE_PCRE8 return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);@@ -457,7 +461,10 @@ pcre_uchar *p; for (i = 0; i < double_count; i += 2)- size += sizeof(pcre_uchar *) + IN_UCHARS(ovector[i+1] - ovector[i] + 1);+ {+ size += sizeof(pcre_uchar *) + IN_UCHARS(1);+ if (ovector[i+1] > ovector[i]) size += IN_UCHARS(ovector[i+1] - ovector[i]);+ } stringlist = (pcre_uchar **)(PUBL(malloc))(size); if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;@@ -473,7 +480,7 @@ for (i = 0; i < double_count; i += 2) {- int len = ovector[i+1] - ovector[i];+ int len = (ovector[i+1] > ovector[i])? (ovector[i+1] - ovector[i]) : 0; memcpy(p, subject + ovector[i], IN_UCHARS(len)); *stringlist++ = p; p += len;@@ -619,7 +626,7 @@ PCRE_SPTR32 *stringptr) #endif {-int n = get_first_set(code, stringname, ovector);+int n = get_first_set(code, stringname, ovector, stringcount); if (n <= 0) return n; #if defined COMPILE_PCRE8 return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
pcre/pcre_globals.c view
@@ -6,7 +6,7 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel- Copyright (c) 1997-2012 University of Cambridge+ Copyright (c) 1997-2014 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without@@ -72,6 +72,7 @@ PCRE_EXP_DATA_DEFN void *(*PUBL(stack_malloc))(size_t) = LocalPcreMalloc; PCRE_EXP_DATA_DEFN void (*PUBL(stack_free))(void *) = LocalPcreFree; PCRE_EXP_DATA_DEFN int (*PUBL(callout))(PUBL(callout_block) *) = NULL;+PCRE_EXP_DATA_DEFN int (*PUBL(stack_guard))(void) = NULL; #elif !defined VPCOMPAT PCRE_EXP_DATA_DEFN void *(*PUBL(malloc))(size_t) = malloc;@@ -79,6 +80,7 @@ PCRE_EXP_DATA_DEFN void *(*PUBL(stack_malloc))(size_t) = malloc; PCRE_EXP_DATA_DEFN void (*PUBL(stack_free))(void *) = free; PCRE_EXP_DATA_DEFN int (*PUBL(callout))(PUBL(callout_block) *) = NULL;+PCRE_EXP_DATA_DEFN int (*PUBL(stack_guard))(void) = NULL; #endif /* End of pcre_globals.c */
pcre/pcre_internal.h view
@@ -7,7 +7,7 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel- Copyright (c) 1997-2013 University of Cambridge+ Copyright (c) 1997-2016 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without@@ -275,7 +275,7 @@ typedef pcre_uint16 pcre_uchar; #define UCHAR_SHIFT (1)-#define IN_UCHARS(x) ((x) << UCHAR_SHIFT)+#define IN_UCHARS(x) ((x) * 2) #define MAX_255(c) ((c) <= 255u) #define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default)) @@ -283,7 +283,7 @@ typedef pcre_uint32 pcre_uchar; #define UCHAR_SHIFT (2)-#define IN_UCHARS(x) ((x) << UCHAR_SHIFT)+#define IN_UCHARS(x) ((x) * 4) #define MAX_255(c) ((c) <= 255u) #define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default)) @@ -316,8 +316,8 @@ &(NLBLOCK->nllen), utf)) \ : \ ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \- RAWUCHARTEST(p) == NLBLOCK->nl[0] && \- (NLBLOCK->nllen == 1 || RAWUCHARTEST(p+1) == NLBLOCK->nl[1]) \+ UCHAR21TEST(p) == NLBLOCK->nl[0] && \+ (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1]) \ ) \ ) @@ -330,8 +330,8 @@ &(NLBLOCK->nllen), utf)) \ : \ ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \- RAWUCHARTEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \- (NLBLOCK->nllen == 1 || RAWUCHARTEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \+ UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] && \+ (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \ ) \ ) @@ -582,12 +582,27 @@ #define MAX_MARK ((1u << 8) - 1) #endif +/* There is a proposed future special "UTF-21" mode, in which only the lowest+21 bits of a 32-bit character are interpreted as UTF, with the remaining 11+high-order bits available to the application for other uses. In preparation for+the future implementation of this mode, there are macros that load a data item+and, if in this special mode, mask it to 21 bits. These macros all have names+starting with UCHAR21. In all other modes, including the normal 32-bit+library, the macros all have the same simple definitions. When the new mode is+implemented, it is expected that these definitions will be varied appropriately+using #ifdef when compiling the library that supports the special mode. */++#define UCHAR21(eptr) (*(eptr))+#define UCHAR21TEST(eptr) (*(eptr))+#define UCHAR21INC(eptr) (*(eptr)++)+#define UCHAR21INCTEST(eptr) (*(eptr)++)+ /* When UTF encoding is being used, a character is no longer just a single-byte. The macros for character handling generate simple sequences when used in-character-mode, and more complicated ones for UTF characters. GETCHARLENTEST-and other macros are not used when UTF is not supported, so they are not-defined. To make sure they can never even appear when UTF support is omitted,-we don't even define them. */+byte in 8-bit mode or a single short in 16-bit mode. The macros for character+handling generate simple sequences when used in the basic mode, and more+complicated ones for UTF characters. GETCHARLENTEST and other macros are not+used when UTF is not supported. To make sure they can never even appear when+UTF support is omitted, we don't even define them. */ #ifndef SUPPORT_UTF @@ -600,10 +615,6 @@ #define GETCHARINC(c, eptr) c = *eptr++; #define GETCHARINCTEST(c, eptr) c = *eptr++; #define GETCHARLEN(c, eptr, len) c = *eptr;-#define RAWUCHAR(eptr) (*(eptr))-#define RAWUCHARINC(eptr) (*(eptr)++)-#define RAWUCHARTEST(eptr) (*(eptr))-#define RAWUCHARINCTEST(eptr) (*(eptr)++) /* #define GETCHARLENTEST(c, eptr, len) */ /* #define BACKCHAR(eptr) */ /* #define FORWARDCHAR(eptr) */@@ -776,30 +787,6 @@ c = *eptr; \ if (utf && c >= 0xc0) GETUTF8LEN(c, eptr, len); -/* Returns the next uchar, not advancing the pointer. This is called when-we know we are in UTF mode. */--#define RAWUCHAR(eptr) \- (*(eptr))--/* Returns the next uchar, advancing the pointer. This is called when-we know we are in UTF mode. */--#define RAWUCHARINC(eptr) \- (*((eptr)++))--/* Returns the next uchar, testing for UTF mode, and not advancing the-pointer. */--#define RAWUCHARTEST(eptr) \- (*(eptr))--/* Returns the next uchar, testing for UTF mode, advancing the-pointer. */--#define RAWUCHARINCTEST(eptr) \- (*((eptr)++))- /* If the pointer is not at the start of a character, move it back until it is. This is called only in UTF-8 mode - we don't put a test within the macro because almost all calls are already within a block of UTF-8 only code. */@@ -895,30 +882,6 @@ c = *eptr; \ if (utf && (c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len); -/* Returns the next uchar, not advancing the pointer. This is called when-we know we are in UTF mode. */--#define RAWUCHAR(eptr) \- (*(eptr))--/* Returns the next uchar, advancing the pointer. This is called when-we know we are in UTF mode. */--#define RAWUCHARINC(eptr) \- (*((eptr)++))--/* Returns the next uchar, testing for UTF mode, and not advancing the-pointer. */--#define RAWUCHARTEST(eptr) \- (*(eptr))--/* Returns the next uchar, testing for UTF mode, advancing the-pointer. */--#define RAWUCHARINCTEST(eptr) \- (*((eptr)++))- /* If the pointer is not at the start of a character, move it back until it is. This is called only in UTF-16 mode - we don't put a test within the macro because almost all calls are already within a block of UTF-16 only@@ -980,30 +943,6 @@ #define GETCHARLENTEST(c, eptr, len) \ GETCHARTEST(c, eptr) -/* Returns the next uchar, not advancing the pointer. This is called when-we know we are in UTF mode. */--#define RAWUCHAR(eptr) \- (*(eptr))--/* Returns the next uchar, advancing the pointer. This is called when-we know we are in UTF mode. */--#define RAWUCHARINC(eptr) \- (*((eptr)++))--/* Returns the next uchar, testing for UTF mode, and not advancing the-pointer. */--#define RAWUCHARTEST(eptr) \- (*(eptr))--/* Returns the next uchar, testing for UTF mode, advancing the-pointer. */--#define RAWUCHARINCTEST(eptr) \- (*((eptr)++))- /* If the pointer is not at the start of a character, move it back until it is. This is called only in UTF-32 mode - we don't put a test within the macro because almost all calls are already within a block of UTF-32 only@@ -1045,7 +984,7 @@ #ifndef EBCDIC #define HSPACE_LIST \- CHAR_HT, CHAR_SPACE, 0xa0, \+ CHAR_HT, CHAR_SPACE, CHAR_NBSP, \ 0x1680, 0x180e, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, \ 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202f, 0x205f, 0x3000, \ NOTACHAR@@ -1071,7 +1010,7 @@ #define HSPACE_BYTE_CASES \ case CHAR_HT: \ case CHAR_SPACE: \- case 0xa0 /* NBSP */+ case CHAR_NBSP #define HSPACE_CASES \ HSPACE_BYTE_CASES: \@@ -1098,11 +1037,12 @@ /* ------ EBCDIC environments ------ */ #else-#define HSPACE_LIST CHAR_HT, CHAR_SPACE+#define HSPACE_LIST CHAR_HT, CHAR_SPACE, CHAR_NBSP, NOTACHAR #define HSPACE_BYTE_CASES \ case CHAR_HT: \- case CHAR_SPACE+ case CHAR_SPACE: \+ case CHAR_NBSP #define HSPACE_CASES HSPACE_BYTE_CASES @@ -1276,6 +1216,7 @@ #define CHAR_ESC '\047' #define CHAR_DEL '\007'+#define CHAR_NBSP '\x41' #define STR_ESC "\047" #define STR_DEL "\007" @@ -1290,6 +1231,7 @@ #define CHAR_NEL ((unsigned char)'\x85') #define CHAR_ESC '\033' #define CHAR_DEL '\177'+#define CHAR_NBSP ((unsigned char)'\xa0') #define STR_LF "\n" #define STR_NL STR_LF@@ -1667,6 +1609,7 @@ #define CHAR_VERTICAL_LINE '\174' #define CHAR_RIGHT_CURLY_BRACKET '\175' #define CHAR_TILDE '\176'+#define CHAR_NBSP ((unsigned char)'\xa0') #define STR_HT "\011" #define STR_VT "\013"@@ -1823,6 +1766,10 @@ /* Escape items that are just an encoding of a particular data value. */ +#ifndef ESC_a+#define ESC_a CHAR_BEL+#endif+ #ifndef ESC_e #define ESC_e CHAR_ESC #endif@@ -1874,8 +1821,9 @@ /* Flag bits and data types for the extended class (OP_XCLASS) for classes that contain characters with values greater than 255. */ -#define XCL_NOT 0x01 /* Flag: this is a negative class */-#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */+#define XCL_NOT 0x01 /* Flag: this is a negative class */+#define XCL_MAP 0x02 /* Flag: a 32-byte map is present */+#define XCL_HASPROP 0x04 /* Flag: property checks are present. */ #define XCL_END 0 /* Marks end of individual items */ #define XCL_SINGLE 1 /* Single item (one multibyte char) follows */@@ -2341,7 +2289,7 @@ ERR50, ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59, ERR60, ERR61, ERR62, ERR63, ERR64, ERR65, ERR66, ERR67, ERR68, ERR69, ERR70, ERR71, ERR72, ERR73, ERR74, ERR75, ERR76, ERR77, ERR78, ERR79,- ERR80, ERR81, ERR82, ERR83, ERR84, ERRCOUNT };+ ERR80, ERR81, ERR82, ERR83, ERR84, ERR85, ERR86, ERR87, ERRCOUNT }; /* JIT compiling modes. The function list is indexed by them. */ @@ -2506,6 +2454,8 @@ BOOL had_pruneorskip; /* (*PRUNE) or (*SKIP) encountered */ BOOL check_lookbehind; /* Lookbehinds need later checking */ BOOL dupnames; /* Duplicate names exist */+ BOOL dupgroups; /* Duplicate groups exist: (?| found */+ BOOL iscondassert; /* Next assert is a condition */ int nltype; /* Newline type */ int nllen; /* Newline string length */ pcre_uchar nl[4]; /* Newline string when fixed length */@@ -2519,6 +2469,13 @@ pcre_uchar *current_branch; } branch_chain; +/* Structure for mutual recursion detection. */++typedef struct recurse_check {+ struct recurse_check *prev;+ const pcre_uchar *group;+} recurse_check;+ /* Structure for items in a linked list that represents an explicit recursive call within the pattern; used by pcre_exec(). */ @@ -2815,6 +2772,9 @@ extern const pcre_uint16 PRIV(ucd_stage2)[]; extern const pcre_uint32 PRIV(ucp_gentype)[]; extern const pcre_uint32 PRIV(ucp_gbtable)[];+#ifdef COMPILE_PCRE32+extern const ucd_record PRIV(dummy_ucd_record)[];+#endif #ifdef SUPPORT_JIT extern const int PRIV(ucp_typerange)[]; #endif@@ -2823,9 +2783,15 @@ /* UCD access macros */ #define UCD_BLOCK_SIZE 128-#define GET_UCD(ch) (PRIV(ucd_records) + \+#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \ PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \ UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE])++#ifdef COMPILE_PCRE32+#define GET_UCD(ch) ((ch > 0x10ffff)? PRIV(dummy_ucd_record) : REAL_GET_UCD(ch))+#else+#define GET_UCD(ch) REAL_GET_UCD(ch)+#endif #define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype #define UCD_SCRIPT(ch) GET_UCD(ch)->script
pcre/pcre_jit_compile.c view
@@ -52,9713 +52,11760 @@ we just include it. This way we don't need to touch the build system files. */ -#define SLJIT_MALLOC(size) (PUBL(malloc))(size)-#define SLJIT_FREE(ptr) (PUBL(free))(ptr)-#define SLJIT_CONFIG_AUTO 1-#define SLJIT_CONFIG_STATIC 1-#define SLJIT_VERBOSE 0-#define SLJIT_DEBUG 0--#include "sljit/sljitLir.c"--#if defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED-#error Unsupported architecture-#endif--/* Defines for debugging purposes. */--/* 1 - Use unoptimized capturing brackets.- 2 - Enable capture_last_ptr (includes option 1). */-/* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */--/* 1 - Always have a control head. */-/* #define DEBUG_FORCE_CONTROL_HEAD 1 */--/* Allocate memory for the regex stack on the real machine stack.-Fast, but limited size. */-#define MACHINE_STACK_SIZE 32768--/* Growth rate for stack allocated by the OS. Should be the multiply-of page size. */-#define STACK_GROWTH_RATE 8192--/* Enable to check that the allocation could destroy temporaries. */-#if defined SLJIT_DEBUG && SLJIT_DEBUG-#define DESTROY_REGISTERS 1-#endif--/*-Short summary about the backtracking mechanism empolyed by the jit code generator:--The code generator follows the recursive nature of the PERL compatible regular-expressions. The basic blocks of regular expressions are condition checkers-whose execute different commands depending on the result of the condition check.-The relationship between the operators can be horizontal (concatenation) and-vertical (sub-expression) (See struct backtrack_common for more details).-- 'ab' - 'a' and 'b' regexps are concatenated- 'a+' - 'a' is the sub-expression of the '+' operator--The condition checkers are boolean (true/false) checkers. Machine code is generated-for the checker itself and for the actions depending on the result of the checker.-The 'true' case is called as the matching path (expected path), and the other is called as-the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken-branches on the matching path.-- Greedy star operator (*) :- Matching path: match happens.- Backtrack path: match failed.- Non-greedy star operator (*?) :- Matching path: no need to perform a match.- Backtrack path: match is required.--The following example shows how the code generated for a capturing bracket-with two alternatives. Let A, B, C, D are arbirary regular expressions, and-we have the following regular expression:-- A(B|C)D--The generated code will be the following:-- A matching path- '(' matching path (pushing arguments to the stack)- B matching path- ')' matching path (pushing arguments to the stack)- D matching path- return with successful match-- D backtrack path- ')' backtrack path (If we arrived from "C" jump to the backtrack of "C")- B backtrack path- C expected path- jump to D matching path- C backtrack path- A backtrack path-- Notice, that the order of backtrack code paths are the opposite of the fast- code paths. In this way the topmost value on the stack is always belong- to the current backtrack code path. The backtrack path must check- whether there is a next alternative. If so, it needs to jump back to- the matching path eventually. Otherwise it needs to clear out its own stack- frame and continue the execution on the backtrack code paths.-*/--/*-Saved stack frames:--Atomic blocks and asserts require reloading the values of private data-when the backtrack mechanism performed. Because of OP_RECURSE, the data-are not necessarly known in compile time, thus we need a dynamic restore-mechanism.--The stack frames are stored in a chain list, and have the following format:-([ capturing bracket offset ][ start value ][ end value ])+ ... [ 0 ] [ previous head ]--Thus we can restore the private data to a particular point in the stack.-*/--typedef struct jit_arguments {- /* Pointers first. */- struct sljit_stack *stack;- const pcre_uchar *str;- const pcre_uchar *begin;- const pcre_uchar *end;- int *offsets;- pcre_uchar *uchar_ptr;- pcre_uchar *mark_ptr;- void *callout_data;- /* Everything else after. */- pcre_uint32 limit_match;- int real_offset_count;- int offset_count;- pcre_uint8 notbol;- pcre_uint8 noteol;- pcre_uint8 notempty;- pcre_uint8 notempty_atstart;-} jit_arguments;--typedef struct executable_functions {- void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];- PUBL(jit_callback) callback;- void *userdata;- pcre_uint32 top_bracket;- pcre_uint32 limit_match;- sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];-} executable_functions;--typedef struct jump_list {- struct sljit_jump *jump;- struct jump_list *next;-} jump_list;--typedef struct stub_list {- struct sljit_jump *start;- struct sljit_label *quit;- struct stub_list *next;-} stub_list;--enum frame_types {- no_frame = -1,- no_stack = -2-};--enum control_types {- type_mark = 0,- type_then_trap = 1-};--typedef int (SLJIT_CALL *jit_function)(jit_arguments *args);--/* The following structure is the key data type for the recursive-code generator. It is allocated by compile_matchingpath, and contains-the arguments for compile_backtrackingpath. Must be the first member-of its descendants. */-typedef struct backtrack_common {- /* Concatenation stack. */- struct backtrack_common *prev;- jump_list *nextbacktracks;- /* Internal stack (for component operators). */- struct backtrack_common *top;- jump_list *topbacktracks;- /* Opcode pointer. */- pcre_uchar *cc;-} backtrack_common;--typedef struct assert_backtrack {- backtrack_common common;- jump_list *condfailed;- /* Less than 0 if a frame is not needed. */- int framesize;- /* Points to our private memory word on the stack. */- int private_data_ptr;- /* For iterators. */- struct sljit_label *matchingpath;-} assert_backtrack;--typedef struct bracket_backtrack {- backtrack_common common;- /* Where to coninue if an alternative is successfully matched. */- struct sljit_label *alternative_matchingpath;- /* For rmin and rmax iterators. */- struct sljit_label *recursive_matchingpath;- /* For greedy ? operator. */- struct sljit_label *zero_matchingpath;- /* Contains the branches of a failed condition. */- union {- /* Both for OP_COND, OP_SCOND. */- jump_list *condfailed;- assert_backtrack *assert;- /* For OP_ONCE. Less than 0 if not needed. */- int framesize;- } u;- /* Points to our private memory word on the stack. */- int private_data_ptr;-} bracket_backtrack;--typedef struct bracketpos_backtrack {- backtrack_common common;- /* Points to our private memory word on the stack. */- int private_data_ptr;- /* Reverting stack is needed. */- int framesize;- /* Allocated stack size. */- int stacksize;-} bracketpos_backtrack;--typedef struct braminzero_backtrack {- backtrack_common common;- struct sljit_label *matchingpath;-} braminzero_backtrack;--typedef struct iterator_backtrack {- backtrack_common common;- /* Next iteration. */- struct sljit_label *matchingpath;-} iterator_backtrack;--typedef struct recurse_entry {- struct recurse_entry *next;- /* Contains the function entry. */- struct sljit_label *entry;- /* Collects the calls until the function is not created. */- jump_list *calls;- /* Points to the starting opcode. */- sljit_sw start;-} recurse_entry;--typedef struct recurse_backtrack {- backtrack_common common;- BOOL inlined_pattern;-} recurse_backtrack;--#define OP_THEN_TRAP OP_TABLE_LENGTH--typedef struct then_trap_backtrack {- backtrack_common common;- /* If then_trap is not NULL, this structure contains the real- then_trap for the backtracking path. */- struct then_trap_backtrack *then_trap;- /* Points to the starting opcode. */- sljit_sw start;- /* Exit point for the then opcodes of this alternative. */- jump_list *quit;- /* Frame size of the current alternative. */- int framesize;-} then_trap_backtrack;--#define MAX_RANGE_SIZE 6--typedef struct compiler_common {- /* The sljit ceneric compiler. */- struct sljit_compiler *compiler;- /* First byte code. */- pcre_uchar *start;- /* Maps private data offset to each opcode. */- sljit_si *private_data_ptrs;- /* Tells whether the capturing bracket is optimized. */- pcre_uint8 *optimized_cbracket;- /* Tells whether the starting offset is a target of then. */- pcre_uint8 *then_offsets;- /* Current position where a THEN must jump. */- then_trap_backtrack *then_trap;- /* Starting offset of private data for capturing brackets. */- int cbra_ptr;- /* Output vector starting point. Must be divisible by 2. */- int ovector_start;- /* Last known position of the requested byte. */- int req_char_ptr;- /* Head of the last recursion. */- int recursive_head_ptr;- /* First inspected character for partial matching. */- int start_used_ptr;- /* Starting pointer for partial soft matches. */- int hit_start;- /* End pointer of the first line. */- int first_line_end;- /* Points to the marked string. */- int mark_ptr;- /* Recursive control verb management chain. */- int control_head_ptr;- /* Points to the last matched capture block index. */- int capture_last_ptr;- /* Points to the starting position of the current match. */- int start_ptr;-- /* Flipped and lower case tables. */- const pcre_uint8 *fcc;- sljit_sw lcc;- /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */- int mode;- /* \K is found in the pattern. */- BOOL has_set_som;- /* (*SKIP:arg) is found in the pattern. */- BOOL has_skip_arg;- /* (*THEN) is found in the pattern. */- BOOL has_then;- /* Needs to know the start position anytime. */- BOOL needs_start_ptr;- /* Currently in recurse or negative assert. */- BOOL local_exit;- /* Currently in a positive assert. */- BOOL positive_assert;- /* Newline control. */- int nltype;- int newline;- int bsr_nltype;- /* Dollar endonly. */- int endonly;- /* Tables. */- sljit_sw ctypes;- int digits[2 + MAX_RANGE_SIZE];- /* Named capturing brackets. */- pcre_uchar *name_table;- sljit_sw name_count;- sljit_sw name_entry_size;-- /* Labels and jump lists. */- struct sljit_label *partialmatchlabel;- struct sljit_label *quit_label;- struct sljit_label *forced_quit_label;- struct sljit_label *accept_label;- stub_list *stubs;- recurse_entry *entries;- recurse_entry *currententry;- jump_list *partialmatch;- jump_list *quit;- jump_list *positive_assert_quit;- jump_list *forced_quit;- jump_list *accept;- jump_list *calllimit;- jump_list *stackalloc;- jump_list *revertframes;- jump_list *wordboundary;- jump_list *anynewline;- jump_list *hspace;- jump_list *vspace;- jump_list *casefulcmp;- jump_list *caselesscmp;- jump_list *reset_match;- BOOL jscript_compat;-#ifdef SUPPORT_UTF- BOOL utf;-#ifdef SUPPORT_UCP- BOOL use_ucp;-#endif-#ifndef COMPILE_PCRE32- jump_list *utfreadchar;-#endif-#ifdef COMPILE_PCRE8- jump_list *utfreadtype8;-#endif-#endif /* SUPPORT_UTF */-#ifdef SUPPORT_UCP- jump_list *getucd;-#endif-} compiler_common;--/* For byte_sequence_compare. */--typedef struct compare_context {- int length;- int sourcereg;-#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED- int ucharptr;- union {- sljit_si asint;- sljit_uh asushort;-#if defined COMPILE_PCRE8- sljit_ub asbyte;- sljit_ub asuchars[4];-#elif defined COMPILE_PCRE16- sljit_uh asuchars[2];-#elif defined COMPILE_PCRE32- sljit_ui asuchars[1];-#endif- } c;- union {- sljit_si asint;- sljit_uh asushort;-#if defined COMPILE_PCRE8- sljit_ub asbyte;- sljit_ub asuchars[4];-#elif defined COMPILE_PCRE16- sljit_uh asuchars[2];-#elif defined COMPILE_PCRE32- sljit_ui asuchars[1];-#endif- } oc;-#endif-} compare_context;--/* Undefine sljit macros. */-#undef CMP--/* Used for accessing the elements of the stack. */-#define STACK(i) ((-(i) - 1) * (int)sizeof(sljit_sw))--#define TMP1 SLJIT_SCRATCH_REG1-#define TMP2 SLJIT_SCRATCH_REG3-#define TMP3 SLJIT_TEMPORARY_EREG2-#define STR_PTR SLJIT_SAVED_REG1-#define STR_END SLJIT_SAVED_REG2-#define STACK_TOP SLJIT_SCRATCH_REG2-#define STACK_LIMIT SLJIT_SAVED_REG3-#define ARGUMENTS SLJIT_SAVED_EREG1-#define COUNT_MATCH SLJIT_SAVED_EREG2-#define RETURN_ADDR SLJIT_TEMPORARY_EREG1--/* Local space layout. */-/* These two locals can be used by the current opcode. */-#define LOCALS0 (0 * sizeof(sljit_sw))-#define LOCALS1 (1 * sizeof(sljit_sw))-/* Two local variables for possessive quantifiers (char1 cannot use them). */-#define POSSESSIVE0 (2 * sizeof(sljit_sw))-#define POSSESSIVE1 (3 * sizeof(sljit_sw))-/* Max limit of recursions. */-#define LIMIT_MATCH (4 * sizeof(sljit_sw))-/* The output vector is stored on the stack, and contains pointers-to characters. The vector data is divided into two groups: the first-group contains the start / end character pointers, and the second is-the start pointers when the end of the capturing group has not yet reached. */-#define OVECTOR_START (common->ovector_start)-#define OVECTOR(i) (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw))-#define OVECTOR_PRIV(i) (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))-#define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])--#if defined COMPILE_PCRE8-#define MOV_UCHAR SLJIT_MOV_UB-#define MOVU_UCHAR SLJIT_MOVU_UB-#elif defined COMPILE_PCRE16-#define MOV_UCHAR SLJIT_MOV_UH-#define MOVU_UCHAR SLJIT_MOVU_UH-#elif defined COMPILE_PCRE32-#define MOV_UCHAR SLJIT_MOV_UI-#define MOVU_UCHAR SLJIT_MOVU_UI-#else-#error Unsupported compiling mode-#endif--/* Shortcuts. */-#define DEFINE_COMPILER \- struct sljit_compiler *compiler = common->compiler-#define OP1(op, dst, dstw, src, srcw) \- sljit_emit_op1(compiler, (op), (dst), (dstw), (src), (srcw))-#define OP2(op, dst, dstw, src1, src1w, src2, src2w) \- sljit_emit_op2(compiler, (op), (dst), (dstw), (src1), (src1w), (src2), (src2w))-#define LABEL() \- sljit_emit_label(compiler)-#define JUMP(type) \- sljit_emit_jump(compiler, (type))-#define JUMPTO(type, label) \- sljit_set_label(sljit_emit_jump(compiler, (type)), (label))-#define JUMPHERE(jump) \- sljit_set_label((jump), sljit_emit_label(compiler))-#define SET_LABEL(jump, label) \- sljit_set_label((jump), (label))-#define CMP(type, src1, src1w, src2, src2w) \- sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))-#define CMPTO(type, src1, src1w, src2, src2w, label) \- sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))-#define OP_FLAGS(op, dst, dstw, src, srcw, type) \- sljit_emit_op_flags(compiler, (op), (dst), (dstw), (src), (srcw), (type))-#define GET_LOCAL_BASE(dst, dstw, offset) \- sljit_get_local_base(compiler, (dst), (dstw), (offset))--static pcre_uchar* bracketend(pcre_uchar* cc)-{-SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));-do cc += GET(cc, 1); while (*cc == OP_ALT);-SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);-cc += 1 + LINK_SIZE;-return cc;-}--/* Functions whose might need modification for all new supported opcodes:- next_opcode- check_opcode_types- set_private_data_ptrs- get_framesize- init_frame- get_private_data_copy_length- copy_private_data- compile_matchingpath- compile_backtrackingpath-*/--static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)-{-SLJIT_UNUSED_ARG(common);-switch(*cc)- {- case OP_SOD:- case OP_SOM:- case OP_SET_SOM:- case OP_NOT_WORD_BOUNDARY:- case OP_WORD_BOUNDARY:- case OP_NOT_DIGIT:- case OP_DIGIT:- case OP_NOT_WHITESPACE:- case OP_WHITESPACE:- case OP_NOT_WORDCHAR:- case OP_WORDCHAR:- case OP_ANY:- case OP_ALLANY:- case OP_NOTPROP:- case OP_PROP:- case OP_ANYNL:- case OP_NOT_HSPACE:- case OP_HSPACE:- case OP_NOT_VSPACE:- case OP_VSPACE:- case OP_EXTUNI:- case OP_EODN:- case OP_EOD:- case OP_CIRC:- case OP_CIRCM:- case OP_DOLL:- case OP_DOLLM:- case OP_CRSTAR:- case OP_CRMINSTAR:- case OP_CRPLUS:- case OP_CRMINPLUS:- case OP_CRQUERY:- case OP_CRMINQUERY:- case OP_CRRANGE:- case OP_CRMINRANGE:- case OP_CRPOSSTAR:- case OP_CRPOSPLUS:- case OP_CRPOSQUERY:- case OP_CRPOSRANGE:- case OP_CLASS:- case OP_NCLASS:- case OP_REF:- case OP_REFI:- case OP_DNREF:- case OP_DNREFI:- case OP_RECURSE:- case OP_CALLOUT:- case OP_ALT:- case OP_KET:- case OP_KETRMAX:- case OP_KETRMIN:- case OP_KETRPOS:- case OP_REVERSE:- case OP_ASSERT:- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- case OP_ONCE:- case OP_ONCE_NC:- case OP_BRA:- case OP_BRAPOS:- case OP_CBRA:- case OP_CBRAPOS:- case OP_COND:- case OP_SBRA:- case OP_SBRAPOS:- case OP_SCBRA:- case OP_SCBRAPOS:- case OP_SCOND:- case OP_CREF:- case OP_DNCREF:- case OP_RREF:- case OP_DNRREF:- case OP_DEF:- case OP_BRAZERO:- case OP_BRAMINZERO:- case OP_BRAPOSZERO:- case OP_PRUNE:- case OP_SKIP:- case OP_THEN:- case OP_COMMIT:- case OP_FAIL:- case OP_ACCEPT:- case OP_ASSERT_ACCEPT:- case OP_CLOSE:- case OP_SKIPZERO:- return cc + PRIV(OP_lengths)[*cc];-- case OP_CHAR:- case OP_CHARI:- case OP_NOT:- case OP_NOTI:- case OP_STAR:- case OP_MINSTAR:- case OP_PLUS:- case OP_MINPLUS:- case OP_QUERY:- case OP_MINQUERY:- case OP_UPTO:- case OP_MINUPTO:- case OP_EXACT:- case OP_POSSTAR:- case OP_POSPLUS:- case OP_POSQUERY:- case OP_POSUPTO:- case OP_STARI:- case OP_MINSTARI:- case OP_PLUSI:- case OP_MINPLUSI:- case OP_QUERYI:- case OP_MINQUERYI:- case OP_UPTOI:- case OP_MINUPTOI:- case OP_EXACTI:- case OP_POSSTARI:- case OP_POSPLUSI:- case OP_POSQUERYI:- case OP_POSUPTOI:- case OP_NOTSTAR:- case OP_NOTMINSTAR:- case OP_NOTPLUS:- case OP_NOTMINPLUS:- case OP_NOTQUERY:- case OP_NOTMINQUERY:- case OP_NOTUPTO:- case OP_NOTMINUPTO:- case OP_NOTEXACT:- case OP_NOTPOSSTAR:- case OP_NOTPOSPLUS:- case OP_NOTPOSQUERY:- case OP_NOTPOSUPTO:- case OP_NOTSTARI:- case OP_NOTMINSTARI:- case OP_NOTPLUSI:- case OP_NOTMINPLUSI:- case OP_NOTQUERYI:- case OP_NOTMINQUERYI:- case OP_NOTUPTOI:- case OP_NOTMINUPTOI:- case OP_NOTEXACTI:- case OP_NOTPOSSTARI:- case OP_NOTPOSPLUSI:- case OP_NOTPOSQUERYI:- case OP_NOTPOSUPTOI:- cc += PRIV(OP_lengths)[*cc];-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- return cc;-- /* Special cases. */- case OP_TYPESTAR:- case OP_TYPEMINSTAR:- case OP_TYPEPLUS:- case OP_TYPEMINPLUS:- case OP_TYPEQUERY:- case OP_TYPEMINQUERY:- case OP_TYPEUPTO:- case OP_TYPEMINUPTO:- case OP_TYPEEXACT:- case OP_TYPEPOSSTAR:- case OP_TYPEPOSPLUS:- case OP_TYPEPOSQUERY:- case OP_TYPEPOSUPTO:- return cc + PRIV(OP_lengths)[*cc] - 1;-- case OP_ANYBYTE:-#ifdef SUPPORT_UTF- if (common->utf) return NULL;-#endif- return cc + 1;--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- return cc + GET(cc, 1);-#endif-- case OP_MARK:- case OP_PRUNE_ARG:- case OP_SKIP_ARG:- case OP_THEN_ARG:- return cc + 1 + 2 + cc[1];-- default:- /* All opcodes are supported now! */- SLJIT_ASSERT_STOP();- return NULL;- }-}--static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)-{-int count;-pcre_uchar *slot;--/* Calculate important variables (like stack size) and checks whether all opcodes are supported. */-while (cc < ccend)- {- switch(*cc)- {- case OP_SET_SOM:- common->has_set_som = TRUE;- cc += 1;- break;-- case OP_REF:- case OP_REFI:- common->optimized_cbracket[GET2(cc, 1)] = 0;- cc += 1 + IMM2_SIZE;- break;-- case OP_CBRAPOS:- case OP_SCBRAPOS:- common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;- cc += 1 + LINK_SIZE + IMM2_SIZE;- break;-- case OP_COND:- case OP_SCOND:- /* Only AUTO_CALLOUT can insert this opcode. We do- not intend to support this case. */- if (cc[1 + LINK_SIZE] == OP_CALLOUT)- return FALSE;- cc += 1 + LINK_SIZE;- break;-- case OP_CREF:- common->optimized_cbracket[GET2(cc, 1)] = 0;- cc += 1 + IMM2_SIZE;- break;-- case OP_DNREF:- case OP_DNREFI:- case OP_DNCREF:- count = GET2(cc, 1 + IMM2_SIZE);- slot = common->name_table + GET2(cc, 1) * common->name_entry_size;- while (count-- > 0)- {- common->optimized_cbracket[GET2(slot, 0)] = 0;- slot += common->name_entry_size;- }- cc += 1 + 2 * IMM2_SIZE;- break;-- case OP_RECURSE:- /* Set its value only once. */- if (common->recursive_head_ptr == 0)- {- common->recursive_head_ptr = common->ovector_start;- common->ovector_start += sizeof(sljit_sw);- }- cc += 1 + LINK_SIZE;- break;-- case OP_CALLOUT:- if (common->capture_last_ptr == 0)- {- common->capture_last_ptr = common->ovector_start;- common->ovector_start += sizeof(sljit_sw);- }- cc += 2 + 2 * LINK_SIZE;- break;-- case OP_THEN_ARG:- common->has_then = TRUE;- common->control_head_ptr = 1;- /* Fall through. */-- case OP_PRUNE_ARG:- common->needs_start_ptr = TRUE;- /* Fall through. */-- case OP_MARK:- if (common->mark_ptr == 0)- {- common->mark_ptr = common->ovector_start;- common->ovector_start += sizeof(sljit_sw);- }- cc += 1 + 2 + cc[1];- break;-- case OP_THEN:- common->has_then = TRUE;- common->control_head_ptr = 1;- /* Fall through. */-- case OP_PRUNE:- case OP_SKIP:- common->needs_start_ptr = TRUE;- cc += 1;- break;-- case OP_SKIP_ARG:- common->control_head_ptr = 1;- common->has_skip_arg = TRUE;- cc += 1 + 2 + cc[1];- break;-- default:- cc = next_opcode(common, cc);- if (cc == NULL)- return FALSE;- break;- }- }-return TRUE;-}--static int get_class_iterator_size(pcre_uchar *cc)-{-switch(*cc)- {- case OP_CRSTAR:- case OP_CRPLUS:- return 2;-- case OP_CRMINSTAR:- case OP_CRMINPLUS:- case OP_CRQUERY:- case OP_CRMINQUERY:- return 1;-- case OP_CRRANGE:- case OP_CRMINRANGE:- if (GET2(cc, 1) == GET2(cc, 1 + IMM2_SIZE))- return 0;- return 2;-- default:- return 0;- }-}--static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)-{-pcre_uchar *end = bracketend(begin);-pcre_uchar *next;-pcre_uchar *next_end;-pcre_uchar *max_end;-pcre_uchar type;-sljit_sw length = end - begin;-int min, max, i;--/* Detect fixed iterations first. */-if (end[-(1 + LINK_SIZE)] != OP_KET)- return FALSE;--/* Already detected repeat. */-if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)- return TRUE;--next = end;-min = 1;-while (1)- {- if (*next != *begin)- break;- next_end = bracketend(next);- if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)- break;- next = next_end;- min++;- }--if (min == 2)- return FALSE;--max = 0;-max_end = next;-if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)- {- type = *next;- while (1)- {- if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)- break;- next_end = bracketend(next + 2 + LINK_SIZE);- if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)- break;- next = next_end;- max++;- }-- if (next[0] == type && next[1] == *begin && max >= 1)- {- next_end = bracketend(next + 1);- if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)- {- for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)- if (*next_end != OP_KET)- break;-- if (i == max)- {- common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;- common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;- /* +2 the original and the last. */- common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;- if (min == 1)- return TRUE;- min--;- max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);- }- }- }- }--if (min >= 3)- {- common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;- common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;- common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;- return TRUE;- }--return FALSE;-}--#define CASE_ITERATOR_PRIVATE_DATA_1 \- case OP_MINSTAR: \- case OP_MINPLUS: \- case OP_QUERY: \- case OP_MINQUERY: \- case OP_MINSTARI: \- case OP_MINPLUSI: \- case OP_QUERYI: \- case OP_MINQUERYI: \- case OP_NOTMINSTAR: \- case OP_NOTMINPLUS: \- case OP_NOTQUERY: \- case OP_NOTMINQUERY: \- case OP_NOTMINSTARI: \- case OP_NOTMINPLUSI: \- case OP_NOTQUERYI: \- case OP_NOTMINQUERYI:--#define CASE_ITERATOR_PRIVATE_DATA_2A \- case OP_STAR: \- case OP_PLUS: \- case OP_STARI: \- case OP_PLUSI: \- case OP_NOTSTAR: \- case OP_NOTPLUS: \- case OP_NOTSTARI: \- case OP_NOTPLUSI:--#define CASE_ITERATOR_PRIVATE_DATA_2B \- case OP_UPTO: \- case OP_MINUPTO: \- case OP_UPTOI: \- case OP_MINUPTOI: \- case OP_NOTUPTO: \- case OP_NOTMINUPTO: \- case OP_NOTUPTOI: \- case OP_NOTMINUPTOI:--#define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \- case OP_TYPEMINSTAR: \- case OP_TYPEMINPLUS: \- case OP_TYPEQUERY: \- case OP_TYPEMINQUERY:--#define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \- case OP_TYPESTAR: \- case OP_TYPEPLUS:--#define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \- case OP_TYPEUPTO: \- case OP_TYPEMINUPTO:--static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)-{-pcre_uchar *cc = common->start;-pcre_uchar *alternative;-pcre_uchar *end = NULL;-int private_data_ptr = *private_data_start;-int space, size, bracketlen;--while (cc < ccend)- {- space = 0;- size = 0;- bracketlen = 0;- if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)- return;-- if (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND)- if (detect_repeat(common, cc))- {- /* These brackets are converted to repeats, so no global- based single character repeat is allowed. */- if (cc >= end)- end = bracketend(cc);- }-- switch(*cc)- {- case OP_KET:- if (common->private_data_ptrs[cc + 1 - common->start] != 0)- {- common->private_data_ptrs[cc - common->start] = private_data_ptr;- private_data_ptr += sizeof(sljit_sw);- cc += common->private_data_ptrs[cc + 1 - common->start];- }- cc += 1 + LINK_SIZE;- break;-- case OP_ASSERT:- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- case OP_ONCE:- case OP_ONCE_NC:- case OP_BRAPOS:- case OP_SBRA:- case OP_SBRAPOS:- case OP_SCOND:- common->private_data_ptrs[cc - common->start] = private_data_ptr;- private_data_ptr += sizeof(sljit_sw);- bracketlen = 1 + LINK_SIZE;- break;-- case OP_CBRAPOS:- case OP_SCBRAPOS:- common->private_data_ptrs[cc - common->start] = private_data_ptr;- private_data_ptr += sizeof(sljit_sw);- bracketlen = 1 + LINK_SIZE + IMM2_SIZE;- break;-- case OP_COND:- /* Might be a hidden SCOND. */- alternative = cc + GET(cc, 1);- if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)- {- common->private_data_ptrs[cc - common->start] = private_data_ptr;- private_data_ptr += sizeof(sljit_sw);- }- bracketlen = 1 + LINK_SIZE;- break;-- case OP_BRA:- bracketlen = 1 + LINK_SIZE;- break;-- case OP_CBRA:- case OP_SCBRA:- bracketlen = 1 + LINK_SIZE + IMM2_SIZE;- break;-- CASE_ITERATOR_PRIVATE_DATA_1- space = 1;- size = -2;- break;-- CASE_ITERATOR_PRIVATE_DATA_2A- space = 2;- size = -2;- break;-- CASE_ITERATOR_PRIVATE_DATA_2B- space = 2;- size = -(2 + IMM2_SIZE);- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_1- space = 1;- size = 1;- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_2A- if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)- space = 2;- size = 1;- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_2B- if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)- space = 2;- size = 1 + IMM2_SIZE;- break;-- case OP_CLASS:- case OP_NCLASS:- size += 1 + 32 / sizeof(pcre_uchar);- space = get_class_iterator_size(cc + size);- break;--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- size = GET(cc, 1);- space = get_class_iterator_size(cc + size);- break;-#endif-- default:- cc = next_opcode(common, cc);- SLJIT_ASSERT(cc != NULL);- break;- }-- /* Character iterators, which are not inside a repeated bracket,- gets a private slot instead of allocating it on the stack. */- if (space > 0 && cc >= end)- {- common->private_data_ptrs[cc - common->start] = private_data_ptr;- private_data_ptr += sizeof(sljit_sw) * space;- }-- if (size != 0)- {- if (size < 0)- {- cc += -size;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- }- else- cc += size;- }-- if (bracketlen > 0)- {- if (cc >= end)- {- end = bracketend(cc);- if (end[-1 - LINK_SIZE] == OP_KET)- end = NULL;- }- cc += bracketlen;- }- }-*private_data_start = private_data_ptr;-}--/* Returns with a frame_types (always < 0) if no need for frame. */-static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL* needs_control_head)-{-int length = 0;-int possessive = 0;-BOOL stack_restore = FALSE;-BOOL setsom_found = recursive;-BOOL setmark_found = recursive;-/* The last capture is a local variable even for recursions. */-BOOL capture_last_found = FALSE;--#if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD-SLJIT_ASSERT(common->control_head_ptr != 0);-*needs_control_head = TRUE;-#else-*needs_control_head = FALSE;-#endif--if (ccend == NULL)- {- ccend = bracketend(cc) - (1 + LINK_SIZE);- if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))- {- possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;- /* This is correct regardless of common->capture_last_ptr. */- capture_last_found = TRUE;- }- cc = next_opcode(common, cc);- }--SLJIT_ASSERT(cc != NULL);-while (cc < ccend)- switch(*cc)- {- case OP_SET_SOM:- SLJIT_ASSERT(common->has_set_som);- stack_restore = TRUE;- if (!setsom_found)- {- length += 2;- setsom_found = TRUE;- }- cc += 1;- break;-- case OP_MARK:- case OP_PRUNE_ARG:- case OP_THEN_ARG:- SLJIT_ASSERT(common->mark_ptr != 0);- stack_restore = TRUE;- if (!setmark_found)- {- length += 2;- setmark_found = TRUE;- }- if (common->control_head_ptr != 0)- *needs_control_head = TRUE;- cc += 1 + 2 + cc[1];- break;-- case OP_RECURSE:- stack_restore = TRUE;- if (common->has_set_som && !setsom_found)- {- length += 2;- setsom_found = TRUE;- }- if (common->mark_ptr != 0 && !setmark_found)- {- length += 2;- setmark_found = TRUE;- }- if (common->capture_last_ptr != 0 && !capture_last_found)- {- length += 2;- capture_last_found = TRUE;- }- cc += 1 + LINK_SIZE;- break;-- case OP_CBRA:- case OP_CBRAPOS:- case OP_SCBRA:- case OP_SCBRAPOS:- stack_restore = TRUE;- if (common->capture_last_ptr != 0 && !capture_last_found)- {- length += 2;- capture_last_found = TRUE;- }- length += 3;- cc += 1 + LINK_SIZE + IMM2_SIZE;- break;-- default:- stack_restore = TRUE;- /* Fall through. */-- case OP_NOT_WORD_BOUNDARY:- case OP_WORD_BOUNDARY:- case OP_NOT_DIGIT:- case OP_DIGIT:- case OP_NOT_WHITESPACE:- case OP_WHITESPACE:- case OP_NOT_WORDCHAR:- case OP_WORDCHAR:- case OP_ANY:- case OP_ALLANY:- case OP_ANYBYTE:- case OP_NOTPROP:- case OP_PROP:- case OP_ANYNL:- case OP_NOT_HSPACE:- case OP_HSPACE:- case OP_NOT_VSPACE:- case OP_VSPACE:- case OP_EXTUNI:- case OP_EODN:- case OP_EOD:- case OP_CIRC:- case OP_CIRCM:- case OP_DOLL:- case OP_DOLLM:- case OP_CHAR:- case OP_CHARI:- case OP_NOT:- case OP_NOTI:-- case OP_EXACT:- case OP_POSSTAR:- case OP_POSPLUS:- case OP_POSQUERY:- case OP_POSUPTO:-- case OP_EXACTI:- case OP_POSSTARI:- case OP_POSPLUSI:- case OP_POSQUERYI:- case OP_POSUPTOI:-- case OP_NOTEXACT:- case OP_NOTPOSSTAR:- case OP_NOTPOSPLUS:- case OP_NOTPOSQUERY:- case OP_NOTPOSUPTO:-- case OP_NOTEXACTI:- case OP_NOTPOSSTARI:- case OP_NOTPOSPLUSI:- case OP_NOTPOSQUERYI:- case OP_NOTPOSUPTOI:-- case OP_TYPEEXACT:- case OP_TYPEPOSSTAR:- case OP_TYPEPOSPLUS:- case OP_TYPEPOSQUERY:- case OP_TYPEPOSUPTO:-- case OP_CLASS:- case OP_NCLASS:- case OP_XCLASS:-- cc = next_opcode(common, cc);- SLJIT_ASSERT(cc != NULL);- break;- }--/* Possessive quantifiers can use a special case. */-if (SLJIT_UNLIKELY(possessive == length))- return stack_restore ? no_frame : no_stack;--if (length > 0)- return length + 1;-return stack_restore ? no_frame : no_stack;-}--static void init_frame(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, int stackpos, int stacktop, BOOL recursive)-{-DEFINE_COMPILER;-BOOL setsom_found = recursive;-BOOL setmark_found = recursive;-/* The last capture is a local variable even for recursions. */-BOOL capture_last_found = FALSE;-int offset;--/* >= 1 + shortest item size (2) */-SLJIT_UNUSED_ARG(stacktop);-SLJIT_ASSERT(stackpos >= stacktop + 2);--stackpos = STACK(stackpos);-if (ccend == NULL)- {- ccend = bracketend(cc) - (1 + LINK_SIZE);- if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))- cc = next_opcode(common, cc);- }--SLJIT_ASSERT(cc != NULL);-while (cc < ccend)- switch(*cc)- {- case OP_SET_SOM:- SLJIT_ASSERT(common->has_set_som);- if (!setsom_found)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));- stackpos += (int)sizeof(sljit_sw);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);- stackpos += (int)sizeof(sljit_sw);- setsom_found = TRUE;- }- cc += 1;- break;-- case OP_MARK:- case OP_PRUNE_ARG:- case OP_THEN_ARG:- SLJIT_ASSERT(common->mark_ptr != 0);- if (!setmark_found)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);- stackpos += (int)sizeof(sljit_sw);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);- stackpos += (int)sizeof(sljit_sw);- setmark_found = TRUE;- }- cc += 1 + 2 + cc[1];- break;-- case OP_RECURSE:- if (common->has_set_som && !setsom_found)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));- stackpos += (int)sizeof(sljit_sw);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);- stackpos += (int)sizeof(sljit_sw);- setsom_found = TRUE;- }- if (common->mark_ptr != 0 && !setmark_found)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);- stackpos += (int)sizeof(sljit_sw);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);- stackpos += (int)sizeof(sljit_sw);- setmark_found = TRUE;- }- if (common->capture_last_ptr != 0 && !capture_last_found)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);- stackpos += (int)sizeof(sljit_sw);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);- stackpos += (int)sizeof(sljit_sw);- capture_last_found = TRUE;- }- cc += 1 + LINK_SIZE;- break;-- case OP_CBRA:- case OP_CBRAPOS:- case OP_SCBRA:- case OP_SCBRAPOS:- if (common->capture_last_ptr != 0 && !capture_last_found)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);- stackpos += (int)sizeof(sljit_sw);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);- stackpos += (int)sizeof(sljit_sw);- capture_last_found = TRUE;- }- offset = (GET2(cc, 1 + LINK_SIZE)) << 1;- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));- stackpos += (int)sizeof(sljit_sw);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);- stackpos += (int)sizeof(sljit_sw);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);- stackpos += (int)sizeof(sljit_sw);-- cc += 1 + LINK_SIZE + IMM2_SIZE;- break;-- default:- cc = next_opcode(common, cc);- SLJIT_ASSERT(cc != NULL);- break;- }--OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0);-SLJIT_ASSERT(stackpos == STACK(stacktop));-}--static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)-{-int private_data_length = needs_control_head ? 3 : 2;-int size;-pcre_uchar *alternative;-/* Calculate the sum of the private machine words. */-while (cc < ccend)- {- size = 0;- switch(*cc)- {- case OP_KET:- if (PRIVATE_DATA(cc) != 0)- private_data_length++;- cc += 1 + LINK_SIZE;- break;-- case OP_ASSERT:- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- case OP_ONCE:- case OP_ONCE_NC:- case OP_BRAPOS:- case OP_SBRA:- case OP_SBRAPOS:- case OP_SCOND:- private_data_length++;- cc += 1 + LINK_SIZE;- break;-- case OP_CBRA:- case OP_SCBRA:- if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)- private_data_length++;- cc += 1 + LINK_SIZE + IMM2_SIZE;- break;-- case OP_CBRAPOS:- case OP_SCBRAPOS:- private_data_length += 2;- cc += 1 + LINK_SIZE + IMM2_SIZE;- break;-- case OP_COND:- /* Might be a hidden SCOND. */- alternative = cc + GET(cc, 1);- if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)- private_data_length++;- cc += 1 + LINK_SIZE;- break;-- CASE_ITERATOR_PRIVATE_DATA_1- if (PRIVATE_DATA(cc))- private_data_length++;- cc += 2;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- break;-- CASE_ITERATOR_PRIVATE_DATA_2A- if (PRIVATE_DATA(cc))- private_data_length += 2;- cc += 2;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- break;-- CASE_ITERATOR_PRIVATE_DATA_2B- if (PRIVATE_DATA(cc))- private_data_length += 2;- cc += 2 + IMM2_SIZE;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_1- if (PRIVATE_DATA(cc))- private_data_length++;- cc += 1;- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_2A- if (PRIVATE_DATA(cc))- private_data_length += 2;- cc += 1;- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_2B- if (PRIVATE_DATA(cc))- private_data_length += 2;- cc += 1 + IMM2_SIZE;- break;-- case OP_CLASS:- case OP_NCLASS:-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);-#else- size = 1 + 32 / (int)sizeof(pcre_uchar);-#endif- if (PRIVATE_DATA(cc))- private_data_length += get_class_iterator_size(cc + size);- cc += size;- break;-- default:- cc = next_opcode(common, cc);- SLJIT_ASSERT(cc != NULL);- break;- }- }-SLJIT_ASSERT(cc == ccend);-return private_data_length;-}--static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,- BOOL save, int stackptr, int stacktop, BOOL needs_control_head)-{-DEFINE_COMPILER;-int srcw[2];-int count, size;-BOOL tmp1next = TRUE;-BOOL tmp1empty = TRUE;-BOOL tmp2empty = TRUE;-pcre_uchar *alternative;-enum {- start,- loop,- end-} status;--status = save ? start : loop;-stackptr = STACK(stackptr - 2);-stacktop = STACK(stacktop - 1);--if (!save)- {- stackptr += (needs_control_head ? 2 : 1) * sizeof(sljit_sw);- if (stackptr < stacktop)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);- stackptr += sizeof(sljit_sw);- tmp1empty = FALSE;- }- if (stackptr < stacktop)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);- stackptr += sizeof(sljit_sw);- tmp2empty = FALSE;- }- /* The tmp1next must be TRUE in either way. */- }--do- {- count = 0;- switch(status)- {- case start:- SLJIT_ASSERT(save && common->recursive_head_ptr != 0);- count = 1;- srcw[0] = common->recursive_head_ptr;- if (needs_control_head)- {- SLJIT_ASSERT(common->control_head_ptr != 0);- count = 2;- srcw[1] = common->control_head_ptr;- }- status = loop;- break;-- case loop:- if (cc >= ccend)- {- status = end;- break;- }-- switch(*cc)- {- case OP_KET:- if (PRIVATE_DATA(cc) != 0)- {- count = 1;- srcw[0] = PRIVATE_DATA(cc);- }- cc += 1 + LINK_SIZE;- break;-- case OP_ASSERT:- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- case OP_ONCE:- case OP_ONCE_NC:- case OP_BRAPOS:- case OP_SBRA:- case OP_SBRAPOS:- case OP_SCOND:- count = 1;- srcw[0] = PRIVATE_DATA(cc);- SLJIT_ASSERT(srcw[0] != 0);- cc += 1 + LINK_SIZE;- break;-- case OP_CBRA:- case OP_SCBRA:- if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)- {- count = 1;- srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));- }- cc += 1 + LINK_SIZE + IMM2_SIZE;- break;-- case OP_CBRAPOS:- case OP_SCBRAPOS:- count = 2;- srcw[0] = PRIVATE_DATA(cc);- srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));- SLJIT_ASSERT(srcw[0] != 0 && srcw[1] != 0);- cc += 1 + LINK_SIZE + IMM2_SIZE;- break;-- case OP_COND:- /* Might be a hidden SCOND. */- alternative = cc + GET(cc, 1);- if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)- {- count = 1;- srcw[0] = PRIVATE_DATA(cc);- SLJIT_ASSERT(srcw[0] != 0);- }- cc += 1 + LINK_SIZE;- break;-- CASE_ITERATOR_PRIVATE_DATA_1- if (PRIVATE_DATA(cc))- {- count = 1;- srcw[0] = PRIVATE_DATA(cc);- }- cc += 2;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- break;-- CASE_ITERATOR_PRIVATE_DATA_2A- if (PRIVATE_DATA(cc))- {- count = 2;- srcw[0] = PRIVATE_DATA(cc);- srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);- }- cc += 2;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- break;-- CASE_ITERATOR_PRIVATE_DATA_2B- if (PRIVATE_DATA(cc))- {- count = 2;- srcw[0] = PRIVATE_DATA(cc);- srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);- }- cc += 2 + IMM2_SIZE;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_1- if (PRIVATE_DATA(cc))- {- count = 1;- srcw[0] = PRIVATE_DATA(cc);- }- cc += 1;- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_2A- if (PRIVATE_DATA(cc))- {- count = 2;- srcw[0] = PRIVATE_DATA(cc);- srcw[1] = srcw[0] + sizeof(sljit_sw);- }- cc += 1;- break;-- CASE_ITERATOR_TYPE_PRIVATE_DATA_2B- if (PRIVATE_DATA(cc))- {- count = 2;- srcw[0] = PRIVATE_DATA(cc);- srcw[1] = srcw[0] + sizeof(sljit_sw);- }- cc += 1 + IMM2_SIZE;- break;-- case OP_CLASS:- case OP_NCLASS:-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:- size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);-#else- size = 1 + 32 / (int)sizeof(pcre_uchar);-#endif- if (PRIVATE_DATA(cc))- switch(get_class_iterator_size(cc + size))- {- case 1:- count = 1;- srcw[0] = PRIVATE_DATA(cc);- break;-- case 2:- count = 2;- srcw[0] = PRIVATE_DATA(cc);- srcw[1] = srcw[0] + sizeof(sljit_sw);- break;-- default:- SLJIT_ASSERT_STOP();- break;- }- cc += size;- break;-- default:- cc = next_opcode(common, cc);- SLJIT_ASSERT(cc != NULL);- break;- }- break;-- case end:- SLJIT_ASSERT_STOP();- break;- }-- while (count > 0)- {- count--;- if (save)- {- if (tmp1next)- {- if (!tmp1empty)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);- stackptr += sizeof(sljit_sw);- }- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);- tmp1empty = FALSE;- tmp1next = FALSE;- }- else- {- if (!tmp2empty)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);- stackptr += sizeof(sljit_sw);- }- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count]);- tmp2empty = FALSE;- tmp1next = TRUE;- }- }- else- {- if (tmp1next)- {- SLJIT_ASSERT(!tmp1empty);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP1, 0);- tmp1empty = stackptr >= stacktop;- if (!tmp1empty)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);- stackptr += sizeof(sljit_sw);- }- tmp1next = FALSE;- }- else- {- SLJIT_ASSERT(!tmp2empty);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), srcw[count], TMP2, 0);- tmp2empty = stackptr >= stacktop;- if (!tmp2empty)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);- stackptr += sizeof(sljit_sw);- }- tmp1next = TRUE;- }- }- }- }-while (status != end);--if (save)- {- if (tmp1next)- {- if (!tmp1empty)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);- stackptr += sizeof(sljit_sw);- }- if (!tmp2empty)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);- stackptr += sizeof(sljit_sw);- }- }- else- {- if (!tmp2empty)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);- stackptr += sizeof(sljit_sw);- }- if (!tmp1empty)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);- stackptr += sizeof(sljit_sw);- }- }- }-SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));-}--static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, pcre_uint8 *current_offset)-{-pcre_uchar *end = bracketend(cc);-BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;--/* Assert captures then. */-if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)- current_offset = NULL;-/* Conditional block does not. */-if (*cc == OP_COND || *cc == OP_SCOND)- has_alternatives = FALSE;--cc = next_opcode(common, cc);-if (has_alternatives)- current_offset = common->then_offsets + (cc - common->start);--while (cc < end)- {- if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))- cc = set_then_offsets(common, cc, current_offset);- else- {- if (*cc == OP_ALT && has_alternatives)- current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);- if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)- *current_offset = 1;- cc = next_opcode(common, cc);- }- }--return end;-}--#undef CASE_ITERATOR_PRIVATE_DATA_1-#undef CASE_ITERATOR_PRIVATE_DATA_2A-#undef CASE_ITERATOR_PRIVATE_DATA_2B-#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_1-#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2A-#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2B--static SLJIT_INLINE BOOL is_powerof2(unsigned int value)-{-return (value & (value - 1)) == 0;-}--static SLJIT_INLINE void set_jumps(jump_list *list, struct sljit_label *label)-{-while (list)- {- /* sljit_set_label is clever enough to do nothing- if either the jump or the label is NULL. */- SET_LABEL(list->jump, label);- list = list->next;- }-}--static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump* jump)-{-jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));-if (list_item)- {- list_item->next = *list;- list_item->jump = jump;- *list = list_item;- }-}--static void add_stub(compiler_common *common, struct sljit_jump *start)-{-DEFINE_COMPILER;-stub_list* list_item = sljit_alloc_memory(compiler, sizeof(stub_list));--if (list_item)- {- list_item->start = start;- list_item->quit = LABEL();- list_item->next = common->stubs;- common->stubs = list_item;- }-}--static void flush_stubs(compiler_common *common)-{-DEFINE_COMPILER;-stub_list* list_item = common->stubs;--while (list_item)- {- JUMPHERE(list_item->start);- add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));- JUMPTO(SLJIT_JUMP, list_item->quit);- list_item = list_item->next;- }-common->stubs = NULL;-}--static SLJIT_INLINE void count_match(compiler_common *common)-{-DEFINE_COMPILER;--OP2(SLJIT_SUB | SLJIT_SET_E, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);-add_jump(compiler, &common->calllimit, JUMP(SLJIT_C_ZERO));-}--static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)-{-/* May destroy all locals and registers except TMP2. */-DEFINE_COMPILER;--OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));-#ifdef DESTROY_REGISTERS-OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);-OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);-OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, TMP1, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);-#endif-add_stub(common, CMP(SLJIT_C_GREATER, STACK_TOP, 0, STACK_LIMIT, 0));-}--static SLJIT_INLINE void free_stack(compiler_common *common, int size)-{-DEFINE_COMPILER;-OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));-}--static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)-{-DEFINE_COMPILER;-struct sljit_label *loop;-int i;--/* At this point we can freely use all temporary registers. */-SLJIT_ASSERT(length > 1);-/* TMP1 returns with begin - 1. */-OP2(SLJIT_SUB, SLJIT_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));-if (length < 8)- {- for (i = 1; i < length; i++)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), SLJIT_SCRATCH_REG1, 0);- }-else- {- GET_LOCAL_BASE(SLJIT_SCRATCH_REG2, 0, OVECTOR_START);- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, length - 1);- loop = LABEL();- OP1(SLJIT_MOVU, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(sljit_sw), SLJIT_SCRATCH_REG1, 0);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, loop);- }-}--static SLJIT_INLINE void do_reset_match(compiler_common *common, int length)-{-DEFINE_COMPILER;-struct sljit_label *loop;-int i;--SLJIT_ASSERT(length > 1);-/* OVECTOR(1) contains the "string begin - 1" constant. */-if (length > 2)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));-if (length < 8)- {- for (i = 2; i < length; i++)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(i), TMP1, 0);- }-else- {- GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw));- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);- loop = LABEL();- OP1(SLJIT_MOVU, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);- OP2(SLJIT_SUB | SLJIT_SET_E, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, loop);- }--OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);-if (common->mark_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, SLJIT_IMM, 0);-if (common->control_head_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);-OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));-OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr);-OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, base));-}--static sljit_sw SLJIT_CALL do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)-{-while (current != NULL)- {- switch (current[-2])- {- case type_then_trap:- break;-- case type_mark:- if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[-3]) == 0)- return current[-4];- break;-- default:- SLJIT_ASSERT_STOP();- break;- }- current = (sljit_sw*)current[-1];- }-return -1;-}--static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)-{-DEFINE_COMPILER;-struct sljit_label *loop;-struct sljit_jump *early_quit;--/* At this point we can freely use all registers. */-OP1(SLJIT_MOV, SLJIT_SAVED_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1), STR_PTR, 0);--OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, ARGUMENTS, 0);-if (common->mark_ptr != 0)- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);-OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, offset_count));-if (common->mark_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_SCRATCH_REG3, 0);-OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));-OP1(SLJIT_MOV, SLJIT_SCRATCH_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), SLJIT_OFFSETOF(jit_arguments, begin));-GET_LOCAL_BASE(SLJIT_SAVED_REG1, 0, OVECTOR_START);-/* Unlikely, but possible */-early_quit = CMP(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 0);-loop = LABEL();-OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, SLJIT_MEM1(SLJIT_SAVED_REG1), 0, SLJIT_SCRATCH_REG1, 0);-OP2(SLJIT_ADD, SLJIT_SAVED_REG1, 0, SLJIT_SAVED_REG1, 0, SLJIT_IMM, sizeof(sljit_sw));-/* Copy the integer value to the output buffer */-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32-OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);-#endif-OP1(SLJIT_MOVU_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG3), sizeof(int), SLJIT_SAVED_REG2, 0);-OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 1);-JUMPTO(SLJIT_C_NOT_ZERO, loop);-JUMPHERE(early_quit);--/* Calculate the return value, which is the maximum ovector value. */-if (topbracket > 1)- {- GET_LOCAL_BASE(SLJIT_SCRATCH_REG1, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, topbracket + 1);-- /* OVECTOR(0) is never equal to SLJIT_SAVED_REG3. */- loop = LABEL();- OP1(SLJIT_MOVU, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG1), -(2 * (sljit_sw)sizeof(sljit_sw)));- OP2(SLJIT_SUB, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0, SLJIT_IMM, 1);- CMPTO(SLJIT_C_EQUAL, SLJIT_SCRATCH_REG3, 0, SLJIT_SAVED_REG3, 0, loop);- OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_SCRATCH_REG2, 0);- }-else- OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);-}--static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)-{-DEFINE_COMPILER;-struct sljit_jump *jump;--SLJIT_COMPILE_ASSERT(STR_END == SLJIT_SAVED_REG2, str_end_must_be_saved_reg2);-SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0- && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));--OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);-OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);-OP1(SLJIT_MOV_SI, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, real_offset_count));-CMPTO(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 2, quit);--/* Store match begin and end. */-OP1(SLJIT_MOV, SLJIT_SAVED_REG1, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, begin));-OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, offsets));--jump = CMP(SLJIT_C_SIG_LESS, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, 3);-OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + (int)sizeof(sljit_sw)), SLJIT_SAVED_REG1, 0);-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32-OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);-#endif-OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 2 * sizeof(int), SLJIT_SCRATCH_REG3, 0);-JUMPHERE(jump);--OP1(SLJIT_MOV, SLJIT_SCRATCH_REG3, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);-OP2(SLJIT_SUB, SLJIT_SAVED_REG2, 0, STR_END, 0, SLJIT_SAVED_REG1, 0);-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32-OP2(SLJIT_ASHR, SLJIT_SAVED_REG2, 0, SLJIT_SAVED_REG2, 0, SLJIT_IMM, UCHAR_SHIFT);-#endif-OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), sizeof(int), SLJIT_SAVED_REG2, 0);--OP2(SLJIT_SUB, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_SAVED_REG1, 0);-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32-OP2(SLJIT_ASHR, SLJIT_SCRATCH_REG3, 0, SLJIT_SCRATCH_REG3, 0, SLJIT_IMM, UCHAR_SHIFT);-#endif-OP1(SLJIT_MOV_SI, SLJIT_MEM1(SLJIT_SCRATCH_REG2), 0, SLJIT_SCRATCH_REG3, 0);--JUMPTO(SLJIT_JUMP, quit);-}--static SLJIT_INLINE void check_start_used_ptr(compiler_common *common)-{-/* May destroy TMP1. */-DEFINE_COMPILER;-struct sljit_jump *jump;--if (common->mode == JIT_PARTIAL_SOFT_COMPILE)- {- /* The value of -1 must be kept for start_used_ptr! */- OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, 1);- /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting- is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */- jump = CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);- JUMPHERE(jump);- }-else if (common->mode == JIT_PARTIAL_HARD_COMPILE)- {- jump = CMP(SLJIT_C_LESS_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);- JUMPHERE(jump);- }-}--static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar* cc)-{-/* Detects if the character has an othercase. */-unsigned int c;--#ifdef SUPPORT_UTF-if (common->utf)- {- GETCHAR(c, cc);- if (c > 127)- {-#ifdef SUPPORT_UCP- return c != UCD_OTHERCASE(c);-#else- return FALSE;-#endif- }-#ifndef COMPILE_PCRE8- return common->fcc[c] != c;-#endif- }-else-#endif- c = *cc;-return MAX_255(c) ? common->fcc[c] != c : FALSE;-}--static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigned int c)-{-/* Returns with the othercase. */-#ifdef SUPPORT_UTF-if (common->utf && c > 127)- {-#ifdef SUPPORT_UCP- return UCD_OTHERCASE(c);-#else- return c;-#endif- }-#endif-return TABLE_GET(c, common->fcc, c);-}--static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar* cc)-{-/* Detects if the character and its othercase has only 1 bit difference. */-unsigned int c, oc, bit;-#if defined SUPPORT_UTF && defined COMPILE_PCRE8-int n;-#endif--#ifdef SUPPORT_UTF-if (common->utf)- {- GETCHAR(c, cc);- if (c <= 127)- oc = common->fcc[c];- else- {-#ifdef SUPPORT_UCP- oc = UCD_OTHERCASE(c);-#else- oc = c;-#endif- }- }-else- {- c = *cc;- oc = TABLE_GET(c, common->fcc, c);- }-#else-c = *cc;-oc = TABLE_GET(c, common->fcc, c);-#endif--SLJIT_ASSERT(c != oc);--bit = c ^ oc;-/* Optimized for English alphabet. */-if (c <= 127 && bit == 0x20)- return (0 << 8) | 0x20;--/* Since c != oc, they must have at least 1 bit difference. */-if (!is_powerof2(bit))- return 0;--#if defined COMPILE_PCRE8--#ifdef SUPPORT_UTF-if (common->utf && c > 127)- {- n = GET_EXTRALEN(*cc);- while ((bit & 0x3f) == 0)- {- n--;- bit >>= 6;- }- return (n << 8) | bit;- }-#endif /* SUPPORT_UTF */-return (0 << 8) | bit;--#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32--#ifdef SUPPORT_UTF-if (common->utf && c > 65535)- {- if (bit >= (1 << 10))- bit >>= 10;- else- return (bit < 256) ? ((2 << 8) | bit) : ((3 << 8) | (bit >> 8));- }-#endif /* SUPPORT_UTF */-return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));--#endif /* COMPILE_PCRE[8|16|32] */-}--static void check_partial(compiler_common *common, BOOL force)-{-/* Checks whether a partial matching is occurred. Does not modify registers. */-DEFINE_COMPILER;-struct sljit_jump *jump = NULL;--SLJIT_ASSERT(!force || common->mode != JIT_COMPILE);--if (common->mode == JIT_COMPILE)- return;--if (!force)- jump = CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);-else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)- jump = CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);--if (common->mode == JIT_PARTIAL_SOFT_COMPILE)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);-else- {- if (common->partialmatchlabel != NULL)- JUMPTO(SLJIT_JUMP, common->partialmatchlabel);- else- add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));- }--if (jump != NULL)- JUMPHERE(jump);-}--static void check_str_end(compiler_common *common, jump_list **end_reached)-{-/* Does not affect registers. Usually used in a tight spot. */-DEFINE_COMPILER;-struct sljit_jump *jump;--if (common->mode == JIT_COMPILE)- {- add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));- return;- }--jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);-if (common->mode == JIT_PARTIAL_SOFT_COMPILE)- {- add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);- add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));- }-else- {- add_jump(compiler, end_reached, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));- if (common->partialmatchlabel != NULL)- JUMPTO(SLJIT_JUMP, common->partialmatchlabel);- else- add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));- }-JUMPHERE(jump);-}--static void detect_partial_match(compiler_common *common, jump_list **backtracks)-{-DEFINE_COMPILER;-struct sljit_jump *jump;--if (common->mode == JIT_COMPILE)- {- add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));- return;- }--/* Partial matching mode. */-jump = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);-add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0));-if (common->mode == JIT_PARTIAL_SOFT_COMPILE)- {- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);- add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));- }-else- {- if (common->partialmatchlabel != NULL)- JUMPTO(SLJIT_JUMP, common->partialmatchlabel);- else- add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));- }-JUMPHERE(jump);-}--static void read_char(compiler_common *common)-{-/* Reads the character into TMP1, updates STR_PTR.-Does not check STR_END. TMP2 Destroyed. */-DEFINE_COMPILER;-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32-struct sljit_jump *jump;-#endif--OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32-if (common->utf)- {-#if defined COMPILE_PCRE8- jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);-#elif defined COMPILE_PCRE16- jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);-#endif /* COMPILE_PCRE[8|16] */- add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));- JUMPHERE(jump);- }-#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-}--static void peek_char(compiler_common *common)-{-/* Reads the character into TMP1, keeps STR_PTR.-Does not check STR_END. TMP2 Destroyed. */-DEFINE_COMPILER;-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32-struct sljit_jump *jump;-#endif--OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32-if (common->utf)- {-#if defined COMPILE_PCRE8- jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);-#elif defined COMPILE_PCRE16- jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);-#endif /* COMPILE_PCRE[8|16] */- add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);- JUMPHERE(jump);- }-#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */-}--static void read_char8_type(compiler_common *common)-{-/* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */-DEFINE_COMPILER;-#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32-struct sljit_jump *jump;-#endif--#ifdef SUPPORT_UTF-if (common->utf)- {- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-#if defined COMPILE_PCRE8- /* This can be an extra read in some situations, but hopefully- it is needed in most cases. */- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);- jump = CMP(SLJIT_C_LESS, TMP2, 0, SLJIT_IMM, 0xc0);- add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));- JUMPHERE(jump);-#elif defined COMPILE_PCRE16- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);- jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);- JUMPHERE(jump);- /* Skip low surrogate if necessary. */- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xfc00);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0xd800);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);-#elif defined COMPILE_PCRE32- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);- jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);- JUMPHERE(jump);-#endif /* COMPILE_PCRE[8|16|32] */- return;- }-#endif /* SUPPORT_UTF */-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32-/* The ctypes array contains only 256 values. */-OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);-jump = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);-#endif-OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32-JUMPHERE(jump);-#endif-}--static void skip_char_back(compiler_common *common)-{-/* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */-DEFINE_COMPILER;-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32-#if defined COMPILE_PCRE8-struct sljit_label *label;--if (common->utf)- {- label = LABEL();- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);- CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);- return;- }-#elif defined COMPILE_PCRE16-if (common->utf)- {- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- /* Skip low surrogate if necessary. */- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);- OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);- return;- }-#endif /* COMPILE_PCRE[8|16] */-#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */-OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-}--static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpiftrue)-{-/* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */-DEFINE_COMPILER;--if (nltype == NLTYPE_ANY)- {- add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));- add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));- }-else if (nltype == NLTYPE_ANYCRLF)- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_CR);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- add_jump(compiler, backtracks, JUMP(jumpiftrue ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));- }-else- {- SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);- add_jump(compiler, backtracks, CMP(jumpiftrue ? SLJIT_C_EQUAL : SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));- }-}--#ifdef SUPPORT_UTF--#if defined COMPILE_PCRE8-static void do_utfreadchar(compiler_common *common)-{-/* Fast decoding a UTF-8 character. TMP1 contains the first byte-of the character (>= 0xc0). Return char value in TMP1, length - 1 in TMP2. */-DEFINE_COMPILER;-struct sljit_jump *jump;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);-/* Searching for the first zero. */-OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);-jump = JUMP(SLJIT_C_NOT_ZERO);-/* Two byte sequence. */-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1f);-OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);-OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);-OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-JUMPHERE(jump);--OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10);-jump = JUMP(SLJIT_C_NOT_ZERO);-/* Three byte sequence. */-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));-OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0f);-OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 12);-OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);-OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);-OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));-OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);-OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-JUMPHERE(jump);--/* Four byte sequence. */-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));-OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x07);-OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 18);-OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);-OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 12);-OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));-OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);-OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);-OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(3));-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));-OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);-OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}--static void do_utfreadtype8(compiler_common *common)-{-/* Fast decoding a UTF-8 character type. TMP2 contains the first byte-of the character (>= 0xc0). Return value in TMP1. */-DEFINE_COMPILER;-struct sljit_jump *jump;-struct sljit_jump *compare;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);--OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);-jump = JUMP(SLJIT_C_NOT_ZERO);-/* Two byte sequence. */-OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);-OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);-OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);-OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);-compare = CMP(SLJIT_C_GREATER, TMP2, 0, SLJIT_IMM, 255);-OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);--JUMPHERE(compare);-OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-JUMPHERE(jump);--/* We only have types for characters less than 256. */-OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);-OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}--#elif defined COMPILE_PCRE16--static void do_utfreadchar(compiler_common *common)-{-/* Fast decoding a UTF-16 character. TMP1 contains the first 16 bit char-of the character (>= 0xd800). Return char value in TMP1, length - 1 in TMP2. */-DEFINE_COMPILER;-struct sljit_jump *jump;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);-jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xdc00);-/* Do nothing, only return. */-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);--JUMPHERE(jump);-/* Combine two 16 bit characters. */-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);-OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 10);-OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3ff);-OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));-OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}--#endif /* COMPILE_PCRE[8|16] */--#endif /* SUPPORT_UTF */--#ifdef SUPPORT_UCP--/* UCD_BLOCK_SIZE must be 128 (see the assert below). */-#define UCD_BLOCK_MASK 127-#define UCD_BLOCK_SHIFT 7--static void do_getucd(compiler_common *common)-{-/* Search the UCD record for the character comes in TMP1.-Returns chartype in TMP1 and UCD offset in TMP2. */-DEFINE_COMPILER;--SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8);--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);-OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);-OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1));-OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);-OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);-OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2));-OP1(SLJIT_MOV_UH, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);-OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));-OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}-#endif--static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf, BOOL firstline)-{-DEFINE_COMPILER;-struct sljit_label *mainloop;-struct sljit_label *newlinelabel = NULL;-struct sljit_jump *start;-struct sljit_jump *end = NULL;-struct sljit_jump *nl = NULL;-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32-struct sljit_jump *singlechar;-#endif-jump_list *newline = NULL;-BOOL newlinecheck = FALSE;-BOOL readuchar = FALSE;--if (!(hascrorlf || firstline) && (common->nltype == NLTYPE_ANY ||- common->nltype == NLTYPE_ANYCRLF || common->newline > 255))- newlinecheck = TRUE;--if (firstline)- {- /* Search for the end of the first line. */- SLJIT_ASSERT(common->first_line_end != 0);- OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);-- if (common->nltype == NLTYPE_FIXED && common->newline > 255)- {- mainloop = LABEL();- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));- CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);- CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);- JUMPHERE(end);- OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- }- else- {- end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);- mainloop = LABEL();- /* Continual stores does not cause data dependency. */- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);- read_char(common);- check_newlinechar(common, common->nltype, &newline, TRUE);- CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop);- JUMPHERE(end);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, STR_PTR, 0);- set_jumps(newline, LABEL());- }-- OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);- }--start = JUMP(SLJIT_JUMP);--if (newlinecheck)- {- newlinelabel = LABEL();- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- end = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);- OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);-#endif- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);- nl = JUMP(SLJIT_JUMP);- }--mainloop = LABEL();--/* Increasing the STR_PTR here requires one less jump in the most common case. */-#ifdef SUPPORT_UTF-if (common->utf) readuchar = TRUE;-#endif-if (newlinecheck) readuchar = TRUE;--if (readuchar)- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);--if (newlinecheck)- CMPTO(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);--OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-#if defined SUPPORT_UTF && !defined COMPILE_PCRE32-#if defined COMPILE_PCRE8-if (common->utf)- {- singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);- JUMPHERE(singlechar);- }-#elif defined COMPILE_PCRE16-if (common->utf)- {- singlechar = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);- OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);- JUMPHERE(singlechar);- }-#endif /* COMPILE_PCRE[8|16] */-#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */-JUMPHERE(start);--if (newlinecheck)- {- JUMPHERE(end);- JUMPHERE(nl);- }--return mainloop;-}--#define MAX_N_CHARS 3--static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)-{-DEFINE_COMPILER;-struct sljit_label *start;-struct sljit_jump *quit;-pcre_uint32 chars[MAX_N_CHARS * 2];-pcre_uchar *cc = common->start + 1 + LINK_SIZE;-int location = 0;-pcre_int32 len, c, bit, caseless;-int must_stop;--/* We do not support alternatives now. */-if (*(common->start + GET(common->start, 1)) == OP_ALT)- return FALSE;--while (TRUE)- {- caseless = 0;- must_stop = 1;- switch(*cc)- {- case OP_CHAR:- must_stop = 0;- cc++;- break;-- case OP_CHARI:- caseless = 1;- must_stop = 0;- cc++;- break;-- case OP_SOD:- case OP_SOM:- case OP_SET_SOM:- case OP_NOT_WORD_BOUNDARY:- case OP_WORD_BOUNDARY:- case OP_EODN:- case OP_EOD:- case OP_CIRC:- case OP_CIRCM:- case OP_DOLL:- case OP_DOLLM:- /* Zero width assertions. */- cc++;- continue;-- case OP_PLUS:- case OP_MINPLUS:- case OP_POSPLUS:- cc++;- break;-- case OP_EXACT:- cc += 1 + IMM2_SIZE;- break;-- case OP_PLUSI:- case OP_MINPLUSI:- case OP_POSPLUSI:- caseless = 1;- cc++;- break;-- case OP_EXACTI:- caseless = 1;- cc += 1 + IMM2_SIZE;- break;-- default:- must_stop = 2;- break;- }-- if (must_stop == 2)- break;-- len = 1;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[0])) len += GET_EXTRALEN(cc[0]);-#endif-- if (caseless && char_has_othercase(common, cc))- {- caseless = char_get_othercase_bit(common, cc);- if (caseless == 0)- return FALSE;-#ifdef COMPILE_PCRE8- caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));-#else- if ((caseless & 0x100) != 0)- caseless = ((caseless & 0xff) << 16) | (len - (caseless >> 9));- else- caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 9));-#endif- }- else- caseless = 0;-- while (len > 0 && location < MAX_N_CHARS * 2)- {- c = *cc;- bit = 0;- if (len == (caseless & 0xff))- {- bit = caseless >> 8;- c |= bit;- }-- chars[location] = c;- chars[location + 1] = bit;-- len--;- location += 2;- cc++;- }-- if (location >= MAX_N_CHARS * 2 || must_stop != 0)- break;- }--/* At least two characters are required. */-if (location < 2 * 2)- return FALSE;--if (firstline)- {- SLJIT_ASSERT(common->first_line_end != 0);- OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);- OP2(SLJIT_SUB, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));- }-else- OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));--start = LABEL();-quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);--OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));-OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-if (chars[1] != 0)- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);-CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);-if (location > 2 * 2)- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));-if (chars[3] != 0)- OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[3]);-CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[2], start);-if (location > 2 * 2)- {- if (chars[5] != 0)- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[5]);- CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[4], start);- }-OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));--JUMPHERE(quit);--if (firstline)- OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);-else- OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS((location >> 1) - 1));-return TRUE;-}--#undef MAX_N_CHARS--static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)-{-DEFINE_COMPILER;-struct sljit_label *start;-struct sljit_jump *quit;-struct sljit_jump *found;-pcre_uchar oc, bit;--if (firstline)- {- SLJIT_ASSERT(common->first_line_end != 0);- OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);- OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);- }--start = LABEL();-quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);-OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);--oc = first_char;-if (caseless)- {- oc = TABLE_GET(first_char, common->fcc, first_char);-#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)- if (first_char > 127 && common->utf)- oc = UCD_OTHERCASE(first_char);-#endif- }-if (first_char == oc)- found = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, first_char);-else- {- bit = first_char ^ oc;- if (is_powerof2(bit))- {- OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, bit);- found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, first_char | bit);- }- else- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, first_char);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- found = JUMP(SLJIT_C_NOT_ZERO);- }- }--OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-JUMPTO(SLJIT_JUMP, start);-JUMPHERE(found);-JUMPHERE(quit);--if (firstline)- OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);-}--static SLJIT_INLINE void fast_forward_newline(compiler_common *common, BOOL firstline)-{-DEFINE_COMPILER;-struct sljit_label *loop;-struct sljit_jump *lastchar;-struct sljit_jump *firstchar;-struct sljit_jump *quit;-struct sljit_jump *foundcr = NULL;-struct sljit_jump *notfoundnl;-jump_list *newline = NULL;--if (firstline)- {- SLJIT_ASSERT(common->first_line_end != 0);- OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);- OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);- }--if (common->nltype == NLTYPE_FIXED && common->newline > 255)- {- lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);- OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));- firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);-- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER_EQUAL);-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);-#endif- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);-- loop = LABEL();- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));- CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);- CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);-- JUMPHERE(quit);- JUMPHERE(firstchar);- JUMPHERE(lastchar);-- if (firstline)- OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);- return;- }--OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));-firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP2, 0);-skip_char_back(common);--loop = LABEL();-read_char(common);-lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);-if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)- foundcr = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);-check_newlinechar(common, common->nltype, &newline, FALSE);-set_jumps(newline, loop);--if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)- {- quit = JUMP(SLJIT_JUMP);- JUMPHERE(foundcr);- notfoundnl = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);- OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);-#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);-#endif- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);- JUMPHERE(notfoundnl);- JUMPHERE(quit);- }-JUMPHERE(lastchar);-JUMPHERE(firstchar);--if (firstline)- OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);-}--static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks);--static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, sljit_uw start_bits, BOOL firstline)-{-DEFINE_COMPILER;-struct sljit_label *start;-struct sljit_jump *quit;-struct sljit_jump *found = NULL;-jump_list *matches = NULL;-pcre_uint8 inverted_start_bits[32];-int i;-#ifndef COMPILE_PCRE8-struct sljit_jump *jump;-#endif--for (i = 0; i < 32; ++i)- inverted_start_bits[i] = ~(((pcre_uint8*)start_bits)[i]);--if (firstline)- {- SLJIT_ASSERT(common->first_line_end != 0);- OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);- OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);- }--start = LABEL();-quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);-OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);-#ifdef SUPPORT_UTF-if (common->utf)- OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);-#endif--if (!check_class_ranges(common, inverted_start_bits, (inverted_start_bits[31] & 0x80) != 0, &matches))- {-#ifndef COMPILE_PCRE8- jump = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 255);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);- JUMPHERE(jump);-#endif- OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);- OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), start_bits);- OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);- found = JUMP(SLJIT_C_NOT_ZERO);- }--#ifdef SUPPORT_UTF-if (common->utf)- OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);-#endif-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-#ifdef SUPPORT_UTF-#if defined COMPILE_PCRE8-if (common->utf)- {- CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);- }-#elif defined COMPILE_PCRE16-if (common->utf)- {- CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);- OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);- }-#endif /* COMPILE_PCRE[8|16] */-#endif /* SUPPORT_UTF */-JUMPTO(SLJIT_JUMP, start);-if (found != NULL)- JUMPHERE(found);-if (matches != NULL)- set_jumps(matches, LABEL());-JUMPHERE(quit);--if (firstline)- OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0);-}--static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uchar req_char, BOOL caseless, BOOL has_firstchar)-{-DEFINE_COMPILER;-struct sljit_label *loop;-struct sljit_jump *toolong;-struct sljit_jump *alreadyfound;-struct sljit_jump *found;-struct sljit_jump *foundoc = NULL;-struct sljit_jump *notfound;-pcre_uint32 oc, bit;--SLJIT_ASSERT(common->req_char_ptr != 0);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr);-OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);-toolong = CMP(SLJIT_C_LESS, TMP1, 0, STR_END, 0);-alreadyfound = CMP(SLJIT_C_LESS, STR_PTR, 0, TMP2, 0);--if (has_firstchar)- OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-else- OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);--loop = LABEL();-notfound = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, STR_END, 0);--OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);-oc = req_char;-if (caseless)- {- oc = TABLE_GET(req_char, common->fcc, req_char);-#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)- if (req_char > 127 && common->utf)- oc = UCD_OTHERCASE(req_char);-#endif- }-if (req_char == oc)- found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);-else- {- bit = req_char ^ oc;- if (is_powerof2(bit))- {- OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);- found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);- }- else- {- found = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, req_char);- foundoc = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, oc);- }- }-OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));-JUMPTO(SLJIT_JUMP, loop);--JUMPHERE(found);-if (foundoc)- JUMPHERE(foundoc);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr, TMP1, 0);-JUMPHERE(alreadyfound);-JUMPHERE(toolong);-return notfound;-}--static void do_revertframes(compiler_common *common)-{-DEFINE_COMPILER;-struct sljit_jump *jump;-struct sljit_label *mainloop;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);-OP1(SLJIT_MOV, TMP1, 0, STACK_TOP, 0);-GET_LOCAL_BASE(TMP3, 0, 0);--/* Drop frames until we reach STACK_TOP. */-mainloop = LABEL();-OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), 0);-OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0);-jump = JUMP(SLJIT_C_SIG_LESS_EQUAL);--OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));-OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(TMP1), 2 * sizeof(sljit_sw));-OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_sw));-JUMPTO(SLJIT_JUMP, mainloop);--JUMPHERE(jump);-jump = JUMP(SLJIT_C_SIG_LESS);-/* End of dropping frames. */-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);--JUMPHERE(jump);-OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);-OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP3, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(TMP1), sizeof(sljit_sw));-OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));-JUMPTO(SLJIT_JUMP, mainloop);-}--static void check_wordboundary(compiler_common *common)-{-DEFINE_COMPILER;-struct sljit_jump *skipread;-jump_list *skipread_list = NULL;-#if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF-struct sljit_jump *jump;-#endif--SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);--sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);-/* Get type of the previous char, and put it to LOCALS1. */-OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);-OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, SLJIT_IMM, 0);-skipread = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);-skip_char_back(common);-check_start_used_ptr(common);-read_char(common);--/* Testing char type. */-#ifdef SUPPORT_UCP-if (common->use_ucp)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);- jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);- add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);- JUMPHERE(jump);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP2, 0);- }-else-#endif- {-#ifndef COMPILE_PCRE8- jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);-#elif defined SUPPORT_UTF- /* Here LOCALS1 has already been zeroed. */- jump = NULL;- if (common->utf)- jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);-#endif /* COMPILE_PCRE8 */- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);- OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP1, 0);-#ifndef COMPILE_PCRE8- JUMPHERE(jump);-#elif defined SUPPORT_UTF- if (jump != NULL)- JUMPHERE(jump);-#endif /* COMPILE_PCRE8 */- }-JUMPHERE(skipread);--OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);-check_str_end(common, &skipread_list);-peek_char(common);--/* Testing char type. This is a code duplication. */-#ifdef SUPPORT_UCP-if (common->use_ucp)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);- jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);- add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);- JUMPHERE(jump);- }-else-#endif- {-#ifndef COMPILE_PCRE8- /* TMP2 may be destroyed by peek_char. */- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);- jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);-#elif defined SUPPORT_UTF- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);- jump = NULL;- if (common->utf)- jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);-#endif- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);- OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);- OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);-#ifndef COMPILE_PCRE8- JUMPHERE(jump);-#elif defined SUPPORT_UTF- if (jump != NULL)- JUMPHERE(jump);-#endif /* COMPILE_PCRE8 */- }-set_jumps(skipread_list, LABEL());--OP2(SLJIT_XOR | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);-sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);-}--/*- range format:-- ranges[0] = length of the range (max MAX_RANGE_SIZE, -1 means invalid range).- ranges[1] = first bit (0 or 1)- ranges[2-length] = position of the bit change (when the current bit is not equal to the previous)-*/--static BOOL check_ranges(compiler_common *common, int *ranges, jump_list **backtracks, BOOL readch)-{-DEFINE_COMPILER;-struct sljit_jump *jump;--if (ranges[0] < 0)- return FALSE;--switch(ranges[0])- {- case 1:- if (readch)- read_char(common);- add_jump(compiler, backtracks, CMP(ranges[1] == 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));- return TRUE;-- case 2:- if (readch)- read_char(common);- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);- add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));- return TRUE;-- case 4:- if (ranges[2] + 1 == ranges[3] && ranges[4] + 1 == ranges[5])- {- if (readch)- read_char(common);- if (ranges[1] != 0)- {- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));- }- else- {- jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]);- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[4]));- JUMPHERE(jump);- }- return TRUE;- }- if ((ranges[3] - ranges[2]) == (ranges[5] - ranges[4]) && is_powerof2(ranges[4] - ranges[2]))- {- if (readch)- read_char(common);- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4] - ranges[2]);- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[4]);- add_jump(compiler, backtracks, CMP(ranges[1] != 0 ? SLJIT_C_LESS : SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[5] - ranges[4]));- return TRUE;- }- return FALSE;-- default:- return FALSE;- }-}--static void get_ctype_ranges(compiler_common *common, int flag, int *ranges)-{-int i, bit, length;-const pcre_uint8 *ctypes = (const pcre_uint8*)common->ctypes;--bit = ctypes[0] & flag;-ranges[0] = -1;-ranges[1] = bit != 0 ? 1 : 0;-length = 0;--for (i = 1; i < 256; i++)- if ((ctypes[i] & flag) != bit)- {- if (length >= MAX_RANGE_SIZE)- return;- ranges[2 + length] = i;- length++;- bit ^= flag;- }--if (bit != 0)- {- if (length >= MAX_RANGE_SIZE)- return;- ranges[2 + length] = 256;- length++;- }-ranges[0] = length;-}--static BOOL check_class_ranges(compiler_common *common, const pcre_uint8 *bits, BOOL nclass, jump_list **backtracks)-{-int ranges[2 + MAX_RANGE_SIZE];-pcre_uint8 bit, cbit, all;-int i, byte, length = 0;--bit = bits[0] & 0x1;-ranges[1] = bit;-/* Can be 0 or 255. */-all = -bit;--for (i = 0; i < 256; )- {- byte = i >> 3;- if ((i & 0x7) == 0 && bits[byte] == all)- i += 8;- else- {- cbit = (bits[byte] >> (i & 0x7)) & 0x1;- if (cbit != bit)- {- if (length >= MAX_RANGE_SIZE)- return FALSE;- ranges[2 + length] = i;- length++;- bit = cbit;- all = -cbit;- }- i++;- }- }--if (((bit == 0) && nclass) || ((bit == 1) && !nclass))- {- if (length >= MAX_RANGE_SIZE)- return FALSE;- ranges[2 + length] = 256;- length++;- }-ranges[0] = length;--return check_ranges(common, ranges, backtracks, FALSE);-}--static void check_anynewline(compiler_common *common)-{-/* Check whether TMP1 contains a newline character. TMP2 destroyed. */-DEFINE_COMPILER;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);--OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);-OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);-OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);-OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);-#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32-#ifdef COMPILE_PCRE8-if (common->utf)- {-#endif- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);-#ifdef COMPILE_PCRE8- }-#endif-#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */-OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}--static void check_hspace(compiler_common *common)-{-/* Check whether TMP1 contains a newline character. TMP2 destroyed. */-DEFINE_COMPILER;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);--OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);-OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);-OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);-OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);-#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32-#ifdef COMPILE_PCRE8-if (common->utf)- {-#endif- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);-#ifdef COMPILE_PCRE8- }-#endif-#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */-OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);--sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}--static void check_vspace(compiler_common *common)-{-/* Check whether TMP1 contains a newline character. TMP2 destroyed. */-DEFINE_COMPILER;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);--OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);-OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);-OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);-OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);-#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32-#ifdef COMPILE_PCRE8-if (common->utf)- {-#endif- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);-#ifdef COMPILE_PCRE8- }-#endif-#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */-OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);--sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}--#define CHAR1 STR_END-#define CHAR2 STACK_TOP--static void do_casefulcmp(compiler_common *common)-{-DEFINE_COMPILER;-struct sljit_jump *jump;-struct sljit_label *label;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);-OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);-OP1(SLJIT_MOV, TMP3, 0, CHAR1, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR2, 0);-OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));-OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));--label = LABEL();-OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));-OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));-jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);-OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));-JUMPTO(SLJIT_C_NOT_ZERO, label);--JUMPHERE(jump);-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-OP1(SLJIT_MOV, CHAR1, 0, TMP3, 0);-OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}--#define LCC_TABLE STACK_LIMIT--static void do_caselesscmp(compiler_common *common)-{-DEFINE_COMPILER;-struct sljit_jump *jump;-struct sljit_label *label;--sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);-OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);--OP1(SLJIT_MOV, TMP3, 0, LCC_TABLE, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, CHAR1, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, CHAR2, 0);-OP1(SLJIT_MOV, LCC_TABLE, 0, SLJIT_IMM, common->lcc);-OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));-OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));--label = LABEL();-OP1(MOVU_UCHAR, CHAR1, 0, SLJIT_MEM1(TMP1), IN_UCHARS(1));-OP1(MOVU_UCHAR, CHAR2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));-#ifndef COMPILE_PCRE8-jump = CMP(SLJIT_C_GREATER, CHAR1, 0, SLJIT_IMM, 255);-#endif-OP1(SLJIT_MOV_UB, CHAR1, 0, SLJIT_MEM2(LCC_TABLE, CHAR1), 0);-#ifndef COMPILE_PCRE8-JUMPHERE(jump);-jump = CMP(SLJIT_C_GREATER, CHAR2, 0, SLJIT_IMM, 255);-#endif-OP1(SLJIT_MOV_UB, CHAR2, 0, SLJIT_MEM2(LCC_TABLE, CHAR2), 0);-#ifndef COMPILE_PCRE8-JUMPHERE(jump);-#endif-jump = CMP(SLJIT_C_NOT_EQUAL, CHAR1, 0, CHAR2, 0);-OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));-JUMPTO(SLJIT_C_NOT_ZERO, label);--JUMPHERE(jump);-OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-OP1(SLJIT_MOV, LCC_TABLE, 0, TMP3, 0);-OP1(SLJIT_MOV, CHAR1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);-OP1(SLJIT_MOV, CHAR2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);-sljit_emit_fast_return(compiler, RETURN_ADDR, 0);-}--#undef LCC_TABLE-#undef CHAR1-#undef CHAR2--#if defined SUPPORT_UTF && defined SUPPORT_UCP--static const pcre_uchar * SLJIT_CALL do_utf_caselesscmp(pcre_uchar *src1, jit_arguments *args, pcre_uchar *end1)-{-/* This function would be ineffective to do in JIT level. */-pcre_uint32 c1, c2;-const pcre_uchar *src2 = args->uchar_ptr;-const pcre_uchar *end2 = args->end;-const ucd_record *ur;-const pcre_uint32 *pp;--while (src1 < end1)- {- if (src2 >= end2)- return (pcre_uchar*)1;- GETCHARINC(c1, src1);- GETCHARINC(c2, src2);- ur = GET_UCD(c2);- if (c1 != c2 && c1 != c2 + ur->other_case)- {- pp = PRIV(ucd_caseless_sets) + ur->caseset;- for (;;)- {- if (c1 < *pp) return NULL;- if (c1 == *pp++) break;- }- }- }-return src2;-}--#endif /* SUPPORT_UTF && SUPPORT_UCP */--static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,- compare_context* context, jump_list **backtracks)-{-DEFINE_COMPILER;-unsigned int othercasebit = 0;-pcre_uchar *othercasechar = NULL;-#ifdef SUPPORT_UTF-int utflength;-#endif--if (caseless && char_has_othercase(common, cc))- {- othercasebit = char_get_othercase_bit(common, cc);- SLJIT_ASSERT(othercasebit);- /* Extracting bit difference info. */-#if defined COMPILE_PCRE8- othercasechar = cc + (othercasebit >> 8);- othercasebit &= 0xff;-#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32- /* Note that this code only handles characters in the BMP. If there- ever are characters outside the BMP whose othercase differs in only one- bit from itself (there currently are none), this code will need to be- revised for COMPILE_PCRE32. */- othercasechar = cc + (othercasebit >> 9);- if ((othercasebit & 0x100) != 0)- othercasebit = (othercasebit & 0xff) << 8;- else- othercasebit &= 0xff;-#endif /* COMPILE_PCRE[8|16|32] */- }--if (context->sourcereg == -1)- {-#if defined COMPILE_PCRE8-#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED- if (context->length >= 4)- OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);- else if (context->length >= 2)- OP1(SLJIT_MOV_UH, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);- else-#endif- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);-#elif defined COMPILE_PCRE16-#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED- if (context->length >= 4)- OP1(SLJIT_MOV_SI, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);- else-#endif- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);-#elif defined COMPILE_PCRE32- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);-#endif /* COMPILE_PCRE[8|16|32] */- context->sourcereg = TMP2;- }--#ifdef SUPPORT_UTF-utflength = 1;-if (common->utf && HAS_EXTRALEN(*cc))- utflength += GET_EXTRALEN(*cc);--do- {-#endif-- context->length -= IN_UCHARS(1);-#if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED) && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)-- /* Unaligned read is supported. */- if (othercasebit != 0 && othercasechar == cc)- {- context->c.asuchars[context->ucharptr] = *cc | othercasebit;- context->oc.asuchars[context->ucharptr] = othercasebit;- }- else- {- context->c.asuchars[context->ucharptr] = *cc;- context->oc.asuchars[context->ucharptr] = 0;- }- context->ucharptr++;--#if defined COMPILE_PCRE8- if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1))-#else- if (context->ucharptr >= 2 || context->length == 0)-#endif- {- if (context->length >= 4)- OP1(SLJIT_MOV_SI, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);- else if (context->length >= 2)- OP1(SLJIT_MOV_UH, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);-#if defined COMPILE_PCRE8- else if (context->length >= 1)- OP1(SLJIT_MOV_UB, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);-#endif /* COMPILE_PCRE8 */- context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;-- switch(context->ucharptr)- {- case 4 / sizeof(pcre_uchar):- if (context->oc.asint != 0)- OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));- break;-- case 2 / sizeof(pcre_uchar):- if (context->oc.asushort != 0)- OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));- break;--#ifdef COMPILE_PCRE8- case 1:- if (context->oc.asbyte != 0)- OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));- break;-#endif-- default:- SLJIT_ASSERT_STOP();- break;- }- context->ucharptr = 0;- }--#else-- /* Unaligned read is unsupported or in 32 bit mode. */- if (context->length >= 1)- OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);-- context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;-- if (othercasebit != 0 && othercasechar == cc)- {- OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));- }- else- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));--#endif-- cc++;-#ifdef SUPPORT_UTF- utflength--;- }-while (utflength > 0);-#endif--return cc;-}--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8--#define SET_TYPE_OFFSET(value) \- if ((value) != typeoffset) \- { \- if ((value) > typeoffset) \- OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \- else \- OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \- } \- typeoffset = (value);--#define SET_CHAR_OFFSET(value) \- if ((value) != charoffset) \- { \- if ((value) > charoffset) \- OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (value) - charoffset); \- else \- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, charoffset - (value)); \- } \- charoffset = (value);--static void compile_xclass_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)-{-DEFINE_COMPILER;-jump_list *found = NULL;-jump_list **list = (*cc & XCL_NOT) == 0 ? &found : backtracks;-pcre_int32 c, charoffset;-struct sljit_jump *jump = NULL;-pcre_uchar *ccbegin;-int compares, invertcmp, numberofcmps;--#ifdef SUPPORT_UCP-BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;-BOOL charsaved = FALSE;-int typereg = TMP1, scriptreg = TMP1;-const pcre_uint32 *other_cases;-pcre_int32 typeoffset;-#endif--/* Although SUPPORT_UTF must be defined, we are- not necessary in utf mode even in 8 bit mode. */-detect_partial_match(common, backtracks);-read_char(common);--if ((*cc++ & XCL_MAP) != 0)- {- OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);-#ifndef COMPILE_PCRE8- jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);-#elif defined SUPPORT_UTF- if (common->utf)- jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);-#endif-- if (!check_class_ranges(common, (const pcre_uint8 *)cc, TRUE, list))- {- OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);- OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);- OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);- add_jump(compiler, list, JUMP(SLJIT_C_NOT_ZERO));- }--#ifndef COMPILE_PCRE8- JUMPHERE(jump);-#elif defined SUPPORT_UTF- if (common->utf)- JUMPHERE(jump);-#endif- OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);-#ifdef SUPPORT_UCP- charsaved = TRUE;-#endif- cc += 32 / sizeof(pcre_uchar);- }--/* Scanning the necessary info. */-ccbegin = cc;-compares = 0;-while (*cc != XCL_END)- {- compares++;- if (*cc == XCL_SINGLE)- {- cc += 2;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif-#ifdef SUPPORT_UCP- needschar = TRUE;-#endif- }- else if (*cc == XCL_RANGE)- {- cc += 2;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif- cc++;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);-#endif-#ifdef SUPPORT_UCP- needschar = TRUE;-#endif- }-#ifdef SUPPORT_UCP- else- {- SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);- cc++;- switch(*cc)- {- case PT_ANY:- break;-- case PT_LAMP:- case PT_GC:- case PT_PC:- case PT_ALNUM:- needstype = TRUE;- break;-- case PT_SC:- needsscript = TRUE;- break;-- case PT_SPACE:- case PT_PXSPACE:- case PT_WORD:- case PT_PXGRAPH:- case PT_PXPRINT:- case PT_PXPUNCT:- needstype = TRUE;- needschar = TRUE;- break;-- case PT_CLIST:- case PT_UCNC:- needschar = TRUE;- break;-- default:- SLJIT_ASSERT_STOP();- break;- }- cc += 2;- }-#endif- }--#ifdef SUPPORT_UCP-/* Simple register allocation. TMP1 is preferred if possible. */-if (needstype || needsscript)- {- if (needschar && !charsaved)- OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);- add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));- if (needschar)- {- if (needstype)- {- OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);- typereg = RETURN_ADDR;- }-- if (needsscript)- scriptreg = TMP3;- OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);- }- else if (needstype && needsscript)- scriptreg = TMP3;- /* In all other cases only one of them was specified, and that can goes to TMP1. */-- if (needsscript)- {- if (scriptreg == TMP1)- {- OP1(SLJIT_MOV, scriptreg, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));- OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM2(scriptreg, TMP2), 3);- }- else- {- OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);- OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));- OP1(SLJIT_MOV_UB, scriptreg, 0, SLJIT_MEM1(TMP2), 0);- }- }- }-#endif--/* Generating code. */-cc = ccbegin;-charoffset = 0;-numberofcmps = 0;-#ifdef SUPPORT_UCP-typeoffset = 0;-#endif--while (*cc != XCL_END)- {- compares--;- invertcmp = (compares == 0 && list != backtracks);- jump = NULL;-- if (*cc == XCL_SINGLE)- {- cc ++;-#ifdef SUPPORT_UTF- if (common->utf)- {- GETCHARINC(c, cc);- }- else-#endif- c = *cc++;-- if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);- OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_EQUAL);- numberofcmps++;- }- else if (numberofcmps > 0)- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);- numberofcmps = 0;- }- else- {- jump = CMP(SLJIT_C_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, c - charoffset);- numberofcmps = 0;- }- }- else if (*cc == XCL_RANGE)- {- cc ++;-#ifdef SUPPORT_UTF- if (common->utf)- {- GETCHARINC(c, cc);- }- else-#endif- c = *cc++;- SET_CHAR_OFFSET(c);-#ifdef SUPPORT_UTF- if (common->utf)- {- GETCHARINC(c, cc);- }- else-#endif- c = *cc++;- if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))- {- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);- OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, numberofcmps == 0 ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_LESS_EQUAL);- numberofcmps++;- }- else if (numberofcmps > 0)- {- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c - charoffset);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);- jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);- numberofcmps = 0;- }- else- {- jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, c - charoffset);- numberofcmps = 0;- }- }-#ifdef SUPPORT_UCP- else- {- if (*cc == XCL_NOTPROP)- invertcmp ^= 0x1;- cc++;- switch(*cc)- {- case PT_ANY:- if (list != backtracks)- {- if ((cc[-1] == XCL_NOTPROP && compares > 0) || (cc[-1] == XCL_PROP && compares == 0))- continue;- }- else if (cc[-1] == XCL_NOTPROP)- continue;- jump = JUMP(SLJIT_JUMP);- break;-- case PT_LAMP:- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - typeoffset);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ll - typeoffset);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lt - typeoffset);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);- break;-- case PT_GC:- c = PRIV(ucp_typerange)[(int)cc[1] * 2];- SET_TYPE_OFFSET(c);- jump = CMP(SLJIT_C_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c);- break;-- case PT_PC:- jump = CMP(SLJIT_C_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset);- break;-- case PT_SC:- jump = CMP(SLJIT_C_EQUAL ^ invertcmp, scriptreg, 0, SLJIT_IMM, (int)cc[1]);- break;-- case PT_SPACE:- case PT_PXSPACE:- SET_CHAR_OFFSET(9);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd - 0x9);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);-- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x9);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x9);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-- SET_TYPE_OFFSET(ucp_Zl);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);- jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);- break;-- case PT_WORD:- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE - charoffset);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- /* Fall through. */-- case PT_ALNUM:- SET_TYPE_OFFSET(ucp_Ll);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);- OP_FLAGS((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, (*cc == PT_ALNUM) ? SLJIT_UNUSED : TMP2, 0, SLJIT_C_LESS_EQUAL);- SET_TYPE_OFFSET(ucp_Nd);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_No - ucp_Nd);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);- jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);- break;-- case PT_CLIST:- other_cases = PRIV(ucd_caseless_sets) + cc[1];-- /* At least three characters are required.- Otherwise this case would be handled by the normal code path. */- SLJIT_ASSERT(other_cases[0] != NOTACHAR && other_cases[1] != NOTACHAR && other_cases[2] != NOTACHAR);- SLJIT_ASSERT(other_cases[0] < other_cases[1] && other_cases[1] < other_cases[2]);-- /* Optimizing character pairs, if their difference is power of 2. */- if (is_powerof2(other_cases[1] ^ other_cases[0]))- {- if (charoffset == 0)- OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);- else- {- OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);- OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);- }- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[1]);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- other_cases += 2;- }- else if (is_powerof2(other_cases[2] ^ other_cases[1]))- {- if (charoffset == 0)- OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[2] ^ other_cases[1]);- else- {- OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);- OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);- }- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);-- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, other_cases[0] - charoffset);- OP_FLAGS(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-- other_cases += 3;- }- else- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, *other_cases++ - charoffset);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- }-- while (*other_cases != NOTACHAR)- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, *other_cases++ - charoffset);- OP_FLAGS(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_E : 0), TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- }- jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);- break;-- case PT_UCNC:- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_DOLLAR_SIGN - charoffset);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_COMMERCIAL_AT - charoffset);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_GRAVE_ACCENT - charoffset);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-- SET_CHAR_OFFSET(0xa0);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd7ff - charoffset);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);- SET_CHAR_OFFSET(0);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_GREATER_EQUAL);- jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);- break;-- case PT_PXGRAPH:- /* C and Z groups are the farthest two groups. */- SET_TYPE_OFFSET(ucp_Ll);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER);-- jump = CMP(SLJIT_C_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);-- /* In case of ucp_Cf, we overwrite the result. */- SET_CHAR_OFFSET(0x2066);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);-- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x2066);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-- JUMPHERE(jump);- jump = CMP(SLJIT_C_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);- break;-- case PT_PXPRINT:- /* C and Z groups are the farthest two groups. */- SET_TYPE_OFFSET(ucp_Ll);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_GREATER);-- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Ll);- OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_C_NOT_EQUAL);-- jump = CMP(SLJIT_C_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);-- /* In case of ucp_Cf, we overwrite the result. */- SET_CHAR_OFFSET(0x2066);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);-- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);- OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);-- JUMPHERE(jump);- jump = CMP(SLJIT_C_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);- break;-- case PT_PXPUNCT:- SET_TYPE_OFFSET(ucp_Sc);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Sc);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL);-- SET_CHAR_OFFSET(0);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xff);- OP_FLAGS(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);-- SET_TYPE_OFFSET(ucp_Pc);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ps - ucp_Pc);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL);- jump = JUMP(SLJIT_C_NOT_ZERO ^ invertcmp);- break;- }- cc += 2;- }-#endif-- if (jump != NULL)- add_jump(compiler, compares > 0 ? list : backtracks, jump);- }--if (found != NULL)- set_jumps(found, LABEL());-}--#undef SET_TYPE_OFFSET-#undef SET_CHAR_OFFSET--#endif--static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)-{-DEFINE_COMPILER;-int length;-unsigned int c, oc, bit;-compare_context context;-struct sljit_jump *jump[4];-jump_list *end_list;-#ifdef SUPPORT_UTF-struct sljit_label *label;-#ifdef SUPPORT_UCP-pcre_uchar propdata[5];-#endif-#endif--switch(type)- {- case OP_SOD:- OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));- return cc;-- case OP_SOM:- OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, TMP1, 0));- return cc;-- case OP_NOT_WORD_BOUNDARY:- case OP_WORD_BOUNDARY:- add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL));- add_jump(compiler, backtracks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));- return cc;-- case OP_NOT_DIGIT:- case OP_DIGIT:- /* Digits are usually 0-9, so it is worth to optimize them. */- if (common->digits[0] == -2)- get_ctype_ranges(common, ctype_digit, common->digits);- detect_partial_match(common, backtracks);- /* Flip the starting bit in the negative case. */- if (type == OP_NOT_DIGIT)- common->digits[1] ^= 1;- if (!check_ranges(common, common->digits, backtracks, TRUE))- {- read_char8_type(common);- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);- add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));- }- if (type == OP_NOT_DIGIT)- common->digits[1] ^= 1;- return cc;-- case OP_NOT_WHITESPACE:- case OP_WHITESPACE:- detect_partial_match(common, backtracks);- read_char8_type(common);- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);- add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));- return cc;-- case OP_NOT_WORDCHAR:- case OP_WORDCHAR:- detect_partial_match(common, backtracks);- read_char8_type(common);- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);- add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_C_ZERO : SLJIT_C_NOT_ZERO));- return cc;-- case OP_ANY:- detect_partial_match(common, backtracks);- read_char(common);- if (common->nltype == NLTYPE_FIXED && common->newline > 255)- {- jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);- end_list = NULL;- if (common->mode != JIT_PARTIAL_HARD_COMPILE)- add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));- else- check_str_end(common, &end_list);-- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));- set_jumps(end_list, LABEL());- JUMPHERE(jump[0]);- }- else- check_newlinechar(common, common->nltype, backtracks, TRUE);- return cc;-- case OP_ALLANY:- detect_partial_match(common, backtracks);-#ifdef SUPPORT_UTF- if (common->utf)- {- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));-#if defined COMPILE_PCRE8 || defined COMPILE_PCRE16-#if defined COMPILE_PCRE8- jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);-#elif defined COMPILE_PCRE16- jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xd800);- OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);- OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);-#endif- JUMPHERE(jump[0]);-#endif /* COMPILE_PCRE[8|16] */- return cc;- }-#endif- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- return cc;-- case OP_ANYBYTE:- detect_partial_match(common, backtracks);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- return cc;--#ifdef SUPPORT_UTF-#ifdef SUPPORT_UCP- case OP_NOTPROP:- case OP_PROP:- propdata[0] = 0;- propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;- propdata[2] = cc[0];- propdata[3] = cc[1];- propdata[4] = XCL_END;- compile_xclass_matchingpath(common, propdata, backtracks);- return cc + 2;-#endif-#endif-- case OP_ANYNL:- detect_partial_match(common, backtracks);- read_char(common);- jump[0] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);- /* We don't need to handle soft partial matching case. */- end_list = NULL;- if (common->mode != JIT_PARTIAL_HARD_COMPILE)- add_jump(compiler, &end_list, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));- else- check_str_end(common, &end_list);- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);- jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- jump[2] = JUMP(SLJIT_JUMP);- JUMPHERE(jump[0]);- check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);- set_jumps(end_list, LABEL());- JUMPHERE(jump[1]);- JUMPHERE(jump[2]);- return cc;-- case OP_NOT_HSPACE:- case OP_HSPACE:- detect_partial_match(common, backtracks);- read_char(common);- add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));- add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));- return cc;-- case OP_NOT_VSPACE:- case OP_VSPACE:- detect_partial_match(common, backtracks);- read_char(common);- add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));- add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_C_NOT_ZERO : SLJIT_C_ZERO));- return cc;--#ifdef SUPPORT_UCP- case OP_EXTUNI:- detect_partial_match(common, backtracks);- read_char(common);- add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));- /* Optimize register allocation: use a real register. */- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);- OP1(SLJIT_MOV_UB, STACK_TOP, 0, SLJIT_MEM2(TMP1, TMP2), 3);-- label = LABEL();- jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);- OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);- read_char(common);- add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM2(TMP1, TMP2), 3);-- OP2(SLJIT_SHL, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 2);- OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(STACK_TOP), (sljit_sw)PRIV(ucp_gbtable));- OP1(SLJIT_MOV, STACK_TOP, 0, TMP2, 0);- OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);- JUMPTO(SLJIT_C_NOT_ZERO, label);-- OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);- JUMPHERE(jump[0]);- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);-- if (common->mode == JIT_PARTIAL_HARD_COMPILE)- {- jump[0] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);- /* Since we successfully read a char above, partial matching must occure. */- check_partial(common, TRUE);- JUMPHERE(jump[0]);- }- return cc;-#endif-- case OP_EODN:- /* Requires rather complex checks. */- jump[0] = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);- if (common->nltype == NLTYPE_FIXED && common->newline > 255)- {- OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));- if (common->mode == JIT_COMPILE)- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));- else- {- jump[1] = CMP(SLJIT_C_EQUAL, TMP2, 0, STR_END, 0);- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_NOT_EQUAL);- add_jump(compiler, backtracks, JUMP(SLJIT_C_NOT_EQUAL));- check_partial(common, TRUE);- add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));- JUMPHERE(jump[1]);- }- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));- }- else if (common->nltype == NLTYPE_FIXED)- {- OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_END, 0));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));- }- else- {- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));- jump[1] = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);- OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));- OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);- jump[2] = JUMP(SLJIT_C_GREATER);- add_jump(compiler, backtracks, JUMP(SLJIT_C_LESS));- /* Equal. */- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));- jump[3] = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);- add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));-- JUMPHERE(jump[1]);- if (common->nltype == NLTYPE_ANYCRLF)- {- OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP2, 0, STR_END, 0));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));- }- else- {- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, STR_PTR, 0);- read_char(common);- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, STR_END, 0));- add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));- add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);- }- JUMPHERE(jump[2]);- JUMPHERE(jump[3]);- }- JUMPHERE(jump[0]);- check_partial(common, FALSE);- return cc;-- case OP_EOD:- add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));- check_partial(common, FALSE);- return cc;-- case OP_CIRC:- OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));- add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0));- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));- return cc;-- case OP_CIRCM:- OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));- jump[1] = CMP(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0);- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));- jump[0] = JUMP(SLJIT_JUMP);- JUMPHERE(jump[1]);-- add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));- if (common->nltype == NLTYPE_FIXED && common->newline > 255)- {- OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));- add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, TMP2, 0, TMP1, 0));- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));- }- else- {- skip_char_back(common);- read_char(common);- check_newlinechar(common, common->nltype, backtracks, FALSE);- }- JUMPHERE(jump[0]);- return cc;-- case OP_DOLL:- OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));-- if (!common->endonly)- compile_char1_matchingpath(common, OP_EODN, cc, backtracks);- else- {- add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0));- check_partial(common, FALSE);- }- return cc;-- case OP_DOLLM:- jump[1] = CMP(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0);- OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));- check_partial(common, FALSE);- jump[0] = JUMP(SLJIT_JUMP);- JUMPHERE(jump[1]);-- if (common->nltype == NLTYPE_FIXED && common->newline > 255)- {- OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));- if (common->mode == JIT_COMPILE)- add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0));- else- {- jump[1] = CMP(SLJIT_C_LESS_EQUAL, TMP2, 0, STR_END, 0);- /* STR_PTR = STR_END - IN_UCHARS(1) */- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));- check_partial(common, TRUE);- add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));- JUMPHERE(jump[1]);- }-- OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));- }- else- {- peek_char(common);- check_newlinechar(common, common->nltype, backtracks, FALSE);- }- JUMPHERE(jump[0]);- return cc;-- case OP_CHAR:- case OP_CHARI:- length = 1;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);-#endif- if (common->mode == JIT_COMPILE && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))- {- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));- add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));-- context.length = IN_UCHARS(length);- context.sourcereg = -1;-#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED- context.ucharptr = 0;-#endif- return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);- }- detect_partial_match(common, backtracks);- read_char(common);-#ifdef SUPPORT_UTF- if (common->utf)- {- GETCHAR(c, cc);- }- else-#endif- c = *cc;- if (type == OP_CHAR || !char_has_othercase(common, cc))- {- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));- return cc + length;- }- oc = char_othercase(common, c);- bit = c ^ oc;- if (is_powerof2(bit))- {- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));- return cc + length;- }- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, c);- OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_EQUAL);- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, oc);- OP_FLAGS(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_C_EQUAL);- add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));- return cc + length;-- case OP_NOT:- case OP_NOTI:- detect_partial_match(common, backtracks);- length = 1;-#ifdef SUPPORT_UTF- if (common->utf)- {-#ifdef COMPILE_PCRE8- c = *cc;- if (c < 128)- {- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);- if (type == OP_NOT || !char_has_othercase(common, cc))- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));- else- {- /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */- OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20);- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));- }- /* Skip the variable-length character. */- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));- jump[0] = CMP(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, 0xc0);- OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);- JUMPHERE(jump[0]);- return cc + 1;- }- else-#endif /* COMPILE_PCRE8 */- {- GETCHARLEN(c, cc, length);- read_char(common);- }- }- else-#endif /* SUPPORT_UTF */- {- read_char(common);- c = *cc;- }-- if (type == OP_NOT || !char_has_othercase(common, cc))- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));- else- {- oc = char_othercase(common, c);- bit = c ^ oc;- if (is_powerof2(bit))- {- OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));- }- else- {- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, c));- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, oc));- }- }- return cc + length;-- case OP_CLASS:- case OP_NCLASS:- detect_partial_match(common, backtracks);- read_char(common);- if (check_class_ranges(common, (const pcre_uint8 *)cc, type == OP_NCLASS, backtracks))- return cc + 32 / sizeof(pcre_uchar);--#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- jump[0] = NULL;-#ifdef COMPILE_PCRE8- /* This check only affects 8 bit mode. In other modes, we- always need to compare the value with 255. */- if (common->utf)-#endif /* COMPILE_PCRE8 */- {- jump[0] = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255);- if (type == OP_CLASS)- {- add_jump(compiler, backtracks, jump[0]);- jump[0] = NULL;- }- }-#endif /* SUPPORT_UTF || !COMPILE_PCRE8 */- OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);- OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);- OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);- OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);- OP2(SLJIT_AND | SLJIT_SET_E, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);- add_jump(compiler, backtracks, JUMP(SLJIT_C_ZERO));-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- if (jump[0] != NULL)- JUMPHERE(jump[0]);-#endif /* SUPPORT_UTF || !COMPILE_PCRE8 */- return cc + 32 / sizeof(pcre_uchar);--#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32- case OP_XCLASS:- compile_xclass_matchingpath(common, cc + LINK_SIZE, backtracks);- return cc + GET(cc, 0) - 1;-#endif-- case OP_REVERSE:- length = GET(cc, 0);- if (length == 0)- return cc + LINK_SIZE;- OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);-#ifdef SUPPORT_UTF- if (common->utf)- {- OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);- label = LABEL();- add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP3, 0));- skip_char_back(common);- OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, label);- }- else-#endif- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));- OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));- add_jump(compiler, backtracks, CMP(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0));- }- check_start_used_ptr(common);- return cc + LINK_SIZE;- }-SLJIT_ASSERT_STOP();-return cc;-}--static SLJIT_INLINE pcre_uchar *compile_charn_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **backtracks)-{-/* This function consumes at least one input character. */-/* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */-DEFINE_COMPILER;-pcre_uchar *ccbegin = cc;-compare_context context;-int size;--context.length = 0;-do- {- if (cc >= ccend)- break;-- if (*cc == OP_CHAR)- {- size = 1;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(cc[1]))- size += GET_EXTRALEN(cc[1]);-#endif- }- else if (*cc == OP_CHARI)- {- size = 1;-#ifdef SUPPORT_UTF- if (common->utf)- {- if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)- size = 0;- else if (HAS_EXTRALEN(cc[1]))- size += GET_EXTRALEN(cc[1]);- }- else-#endif- if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)- size = 0;- }- else- size = 0;-- cc += 1 + size;- context.length += IN_UCHARS(size);- }-while (size > 0 && context.length <= 128);--cc = ccbegin;-if (context.length > 0)- {- /* We have a fixed-length byte sequence. */- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, context.length);- add_jump(compiler, backtracks, CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0));-- context.sourcereg = -1;-#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED- context.ucharptr = 0;-#endif- do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, backtracks); while (context.length > 0);- return cc;- }--/* A non-fixed length character will be checked if length == 0. */-return compile_char1_matchingpath(common, *cc, cc + 1, backtracks);-}--/* Forward definitions. */-static void compile_matchingpath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);-static void compile_backtrackingpath(compiler_common *, struct backtrack_common *);--#define PUSH_BACKTRACK(size, ccstart, error) \- do \- { \- backtrack = sljit_alloc_memory(compiler, (size)); \- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \- return error; \- memset(backtrack, 0, size); \- backtrack->prev = parent->top; \- backtrack->cc = (ccstart); \- parent->top = backtrack; \- } \- while (0)--#define PUSH_BACKTRACK_NOVALUE(size, ccstart) \- do \- { \- backtrack = sljit_alloc_memory(compiler, (size)); \- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \- return; \- memset(backtrack, 0, size); \- backtrack->prev = parent->top; \- backtrack->cc = (ccstart); \- parent->top = backtrack; \- } \- while (0)--#define BACKTRACK_AS(type) ((type *)backtrack)--static void compile_dnref_search(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)-{-/* The OVECTOR offset goes to TMP2. */-DEFINE_COMPILER;-int count = GET2(cc, 1 + IMM2_SIZE);-pcre_uchar *slot = common->name_table + GET2(cc, 1) * common->name_entry_size;-unsigned int offset;-jump_list *found = NULL;--SLJIT_ASSERT(*cc == OP_DNREF || *cc == OP_DNREFI);--OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));--count--;-while (count-- > 0)- {- offset = GET2(slot, 0) << 1;- GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));- add_jump(compiler, &found, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0));- slot += common->name_entry_size;- }--offset = GET2(slot, 0) << 1;-GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));-if (backtracks != NULL && !common->jscript_compat)- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0));--set_jumps(found, LABEL());-}--static void compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)-{-DEFINE_COMPILER;-BOOL ref = (*cc == OP_REF || *cc == OP_REFI);-int offset = 0;-struct sljit_jump *jump = NULL;-struct sljit_jump *partial;-struct sljit_jump *nopartial;--if (ref)- {- offset = GET2(cc, 1) << 1;- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));- /* OVECTOR(1) contains the "string begin - 1" constant. */- if (withchecks && !common->jscript_compat)- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));- }-else- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);--#if defined SUPPORT_UTF && defined SUPPORT_UCP-if (common->utf && *cc == OP_REFI)- {- SLJIT_ASSERT(TMP1 == SLJIT_SCRATCH_REG1 && STACK_TOP == SLJIT_SCRATCH_REG2 && TMP2 == SLJIT_SCRATCH_REG3);- if (ref)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));- else- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));-- if (withchecks)- jump = CMP(SLJIT_C_EQUAL, TMP1, 0, TMP2, 0);-- /* Needed to save important temporary registers. */- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);- OP1(SLJIT_MOV, SLJIT_SCRATCH_REG2, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SCRATCH_REG2), SLJIT_OFFSETOF(jit_arguments, uchar_ptr), STR_PTR, 0);- sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);- if (common->mode == JIT_COMPILE)- add_jump(compiler, backtracks, CMP(SLJIT_C_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));- else- {- add_jump(compiler, backtracks, CMP(SLJIT_C_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0));- nopartial = CMP(SLJIT_C_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);- check_partial(common, FALSE);- add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));- JUMPHERE(nopartial);- }- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);- }-else-#endif /* SUPPORT_UTF && SUPPORT_UCP */- {- if (ref)- OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);- else- OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);-- if (withchecks)- jump = JUMP(SLJIT_C_ZERO);-- OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);- partial = CMP(SLJIT_C_GREATER, STR_PTR, 0, STR_END, 0);- if (common->mode == JIT_COMPILE)- add_jump(compiler, backtracks, partial);-- add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));-- if (common->mode != JIT_COMPILE)- {- nopartial = JUMP(SLJIT_JUMP);- JUMPHERE(partial);- /* TMP2 -= STR_END - STR_PTR */- OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, STR_PTR, 0);- OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, STR_END, 0);- partial = CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0);- OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);- add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));- add_jump(compiler, backtracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));- JUMPHERE(partial);- check_partial(common, FALSE);- add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));- JUMPHERE(nopartial);- }- }--if (jump != NULL)- {- if (emptyfail)- add_jump(compiler, backtracks, jump);- else- JUMPHERE(jump);- }-}--static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)-{-DEFINE_COMPILER;-BOOL ref = (*cc == OP_REF || *cc == OP_REFI);-backtrack_common *backtrack;-pcre_uchar type;-int offset = 0;-struct sljit_label *label;-struct sljit_jump *zerolength;-struct sljit_jump *jump = NULL;-pcre_uchar *ccbegin = cc;-int min = 0, max = 0;-BOOL minimize;--PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);--if (ref)- offset = GET2(cc, 1) << 1;-else- cc += IMM2_SIZE;-type = cc[1 + IMM2_SIZE];--SLJIT_COMPILE_ASSERT((OP_CRSTAR & 0x1) == 0, crstar_opcode_must_be_even);-minimize = (type & 0x1) != 0;-switch(type)- {- case OP_CRSTAR:- case OP_CRMINSTAR:- min = 0;- max = 0;- cc += 1 + IMM2_SIZE + 1;- break;- case OP_CRPLUS:- case OP_CRMINPLUS:- min = 1;- max = 0;- cc += 1 + IMM2_SIZE + 1;- break;- case OP_CRQUERY:- case OP_CRMINQUERY:- min = 0;- max = 1;- cc += 1 + IMM2_SIZE + 1;- break;- case OP_CRRANGE:- case OP_CRMINRANGE:- min = GET2(cc, 1 + IMM2_SIZE + 1);- max = GET2(cc, 1 + IMM2_SIZE + 1 + IMM2_SIZE);- cc += 1 + IMM2_SIZE + 1 + 2 * IMM2_SIZE;- break;- default:- SLJIT_ASSERT_STOP();- break;- }--if (!minimize)- {- if (min == 0)- {- allocate_stack(common, 2);- if (ref)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);- /* Temporary release of STR_PTR. */- OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));- /* Handles both invalid and empty cases. Since the minimum repeat,- is zero the invalid case is basically the same as an empty case. */- if (ref)- zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));- else- {- compile_dnref_search(common, ccbegin, NULL);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, TMP2, 0);- zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));- }- /* Restore if not zero length. */- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));- }- else- {- allocate_stack(common, 1);- if (ref)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- if (ref)- {- add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));- zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));- }- else- {- compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, TMP2, 0);- zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));- }- }-- if (min > 1 || max > 1)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);-- label = LABEL();- if (!ref)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1);- compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);-- if (min > 1 || max > 1)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);- if (min > 1)- CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, label);- if (max > 1)- {- jump = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- JUMPTO(SLJIT_JUMP, label);- JUMPHERE(jump);- }- }-- if (max == 0)- {- /* Includes min > 1 case as well. */- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- JUMPTO(SLJIT_JUMP, label);- }-- JUMPHERE(zerolength);- BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();-- count_match(common);- return cc;- }--allocate_stack(common, ref ? 2 : 3);-if (ref)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);-if (type != OP_CRMINSTAR)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);--if (min == 0)- {- /* Handles both invalid and empty cases. Since the minimum repeat,- is zero the invalid case is basically the same as an empty case. */- if (ref)- zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));- else- {- compile_dnref_search(common, ccbegin, NULL);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);- zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));- }- /* Length is non-zero, we can match real repeats. */- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- jump = JUMP(SLJIT_JUMP);- }-else- {- if (ref)- {- add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));- zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));- }- else- {- compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);- zerolength = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));- }- }--BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();-if (max > 0)- add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));--if (!ref)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(2));-compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);--if (min > 1)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);- CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, BACKTRACK_AS(iterator_backtrack)->matchingpath);- }-else if (max > 0)- OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);--if (jump != NULL)- JUMPHERE(jump);-JUMPHERE(zerolength);--count_match(common);-return cc;-}--static SLJIT_INLINE pcre_uchar *compile_recurse_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;-recurse_entry *entry = common->entries;-recurse_entry *prev = NULL;-sljit_sw start = GET(cc, 1);-pcre_uchar *start_cc;-BOOL needs_control_head;--PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);--/* Inlining simple patterns. */-if (get_framesize(common, common->start + start, NULL, TRUE, &needs_control_head) == no_stack)- {- start_cc = common->start + start;- compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);- BACKTRACK_AS(recurse_backtrack)->inlined_pattern = TRUE;- return cc + 1 + LINK_SIZE;- }--while (entry != NULL)- {- if (entry->start == start)- break;- prev = entry;- entry = entry->next;- }--if (entry == NULL)- {- entry = sljit_alloc_memory(compiler, sizeof(recurse_entry));- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- return NULL;- entry->next = NULL;- entry->entry = NULL;- entry->calls = NULL;- entry->start = start;-- if (prev != NULL)- prev->next = entry;- else- common->entries = entry;- }--if (common->has_set_som && common->mark_ptr != 0)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));- allocate_stack(common, 2);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);- }-else if (common->has_set_som || common->mark_ptr != 0)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr);- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);- }--if (entry->entry == NULL)- add_jump(compiler, &entry->calls, JUMP(SLJIT_FAST_CALL));-else- JUMPTO(SLJIT_FAST_CALL, entry->entry);-/* Leave if the match is failed. */-add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0));-return cc + 1 + LINK_SIZE;-}--static int SLJIT_CALL do_callout(struct jit_arguments* arguments, PUBL(callout_block) *callout_block, pcre_uchar **jit_ovector)-{-const pcre_uchar *begin = arguments->begin;-int *offset_vector = arguments->offsets;-int offset_count = arguments->offset_count;-int i;--if (PUBL(callout) == NULL)- return 0;--callout_block->version = 2;-callout_block->callout_data = arguments->callout_data;--/* Offsets in subject. */-callout_block->subject_length = arguments->end - arguments->begin;-callout_block->start_match = (pcre_uchar*)callout_block->subject - arguments->begin;-callout_block->current_position = (pcre_uchar*)callout_block->offset_vector - arguments->begin;-#if defined COMPILE_PCRE8-callout_block->subject = (PCRE_SPTR)begin;-#elif defined COMPILE_PCRE16-callout_block->subject = (PCRE_SPTR16)begin;-#elif defined COMPILE_PCRE32-callout_block->subject = (PCRE_SPTR32)begin;-#endif--/* Convert and copy the JIT offset vector to the offset_vector array. */-callout_block->capture_top = 0;-callout_block->offset_vector = offset_vector;-for (i = 2; i < offset_count; i += 2)- {- offset_vector[i] = jit_ovector[i] - begin;- offset_vector[i + 1] = jit_ovector[i + 1] - begin;- if (jit_ovector[i] >= begin)- callout_block->capture_top = i;- }--callout_block->capture_top = (callout_block->capture_top >> 1) + 1;-if (offset_count > 0)- offset_vector[0] = -1;-if (offset_count > 1)- offset_vector[1] = -1;-return (*PUBL(callout))(callout_block);-}--/* Aligning to 8 byte. */-#define CALLOUT_ARG_SIZE \- (((int)sizeof(PUBL(callout_block)) + 7) & ~7)--#define CALLOUT_ARG_OFFSET(arg) \- (-CALLOUT_ARG_SIZE + SLJIT_OFFSETOF(PUBL(callout_block), arg))--static SLJIT_INLINE pcre_uchar *compile_callout_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;--PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);--allocate_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));--OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);-OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);-SLJIT_ASSERT(common->capture_last_ptr != 0);-OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);-OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(capture_last), TMP2, 0);--/* These pointer sized fields temporarly stores internal variables. */-OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(offset_vector), STR_PTR, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(subject), TMP2, 0);--if (common->mark_ptr != 0)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr));-OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 2));-OP1(SLJIT_MOV_SI, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(next_item_length), SLJIT_IMM, GET(cc, 2 + LINK_SIZE));-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(mark), (common->mark_ptr != 0) ? TMP2 : SLJIT_IMM, 0);--/* Needed to save important temporary registers. */-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);-OP2(SLJIT_SUB, SLJIT_SCRATCH_REG2, 0, STACK_TOP, 0, SLJIT_IMM, CALLOUT_ARG_SIZE);-GET_LOCAL_BASE(SLJIT_SCRATCH_REG3, 0, OVECTOR_START);-sljit_emit_ijump(compiler, SLJIT_CALL3, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_callout));-OP1(SLJIT_MOV_SI, SLJIT_RETURN_REG, 0, SLJIT_RETURN_REG, 0);-OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);-free_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));--/* Check return value. */-OP2(SLJIT_SUB | SLJIT_SET_S, SLJIT_UNUSED, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);-add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_C_SIG_GREATER));-if (common->forced_quit_label == NULL)- add_jump(compiler, &common->forced_quit, JUMP(SLJIT_C_SIG_LESS));-else- JUMPTO(SLJIT_C_SIG_LESS, common->forced_quit_label);-return cc + 2 + 2 * LINK_SIZE;-}--#undef CALLOUT_ARG_SIZE-#undef CALLOUT_ARG_OFFSET--static pcre_uchar *compile_assert_matchingpath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)-{-DEFINE_COMPILER;-int framesize;-int extrasize;-BOOL needs_control_head;-int private_data_ptr;-backtrack_common altbacktrack;-pcre_uchar *ccbegin;-pcre_uchar opcode;-pcre_uchar bra = OP_BRA;-jump_list *tmp = NULL;-jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;-jump_list **found;-/* Saving previous accept variables. */-BOOL save_local_exit = common->local_exit;-BOOL save_positive_assert = common->positive_assert;-then_trap_backtrack *save_then_trap = common->then_trap;-struct sljit_label *save_quit_label = common->quit_label;-struct sljit_label *save_accept_label = common->accept_label;-jump_list *save_quit = common->quit;-jump_list *save_positive_assert_quit = common->positive_assert_quit;-jump_list *save_accept = common->accept;-struct sljit_jump *jump;-struct sljit_jump *brajump = NULL;--/* Assert captures then. */-common->then_trap = NULL;--if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)- {- SLJIT_ASSERT(!conditional);- bra = *cc;- cc++;- }-private_data_ptr = PRIVATE_DATA(cc);-SLJIT_ASSERT(private_data_ptr != 0);-framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);-backtrack->framesize = framesize;-backtrack->private_data_ptr = private_data_ptr;-opcode = *cc;-SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);-found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;-ccbegin = cc;-cc += GET(cc, 1);--if (bra == OP_BRAMINZERO)- {- /* This is a braminzero backtrack path. */- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- brajump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);- }--if (framesize < 0)- {- extrasize = needs_control_head ? 2 : 1;- if (framesize == no_frame)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);- allocate_stack(common, extrasize);- if (needs_control_head)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- if (needs_control_head)- {- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);- }- }-else- {- extrasize = needs_control_head ? 3 : 2;- allocate_stack(common, framesize + extrasize);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);- if (needs_control_head)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- if (needs_control_head)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);- }- else- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);- init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);- }--memset(&altbacktrack, 0, sizeof(backtrack_common));-if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)- {- /* Negative assert is stronger than positive assert. */- common->local_exit = TRUE;- common->quit_label = NULL;- common->quit = NULL;- common->positive_assert = FALSE;- }-else- common->positive_assert = TRUE;-common->positive_assert_quit = NULL;--while (1)- {- common->accept_label = NULL;- common->accept = NULL;- altbacktrack.top = NULL;- altbacktrack.topbacktracks = NULL;-- if (*ccbegin == OP_ALT)- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));-- altbacktrack.cc = ccbegin;- compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- {- if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)- {- common->local_exit = save_local_exit;- common->quit_label = save_quit_label;- common->quit = save_quit;- }- common->positive_assert = save_positive_assert;- common->then_trap = save_then_trap;- common->accept_label = save_accept_label;- common->positive_assert_quit = save_positive_assert_quit;- common->accept = save_accept;- return NULL;- }- common->accept_label = LABEL();- if (common->accept != NULL)- set_jumps(common->accept, common->accept_label);-- /* Reset stack. */- if (framesize < 0)- {- if (framesize == no_frame)- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- else- free_stack(common, extrasize);- if (needs_control_head)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);- }- else- {- if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)- {- /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */- OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));- if (needs_control_head)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), 0);- }- else- {- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- if (needs_control_head)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), (framesize + 1) * sizeof(sljit_sw));- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- }- }-- if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)- {- /* We know that STR_PTR was stored on the top of the stack. */- if (conditional)- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), needs_control_head ? sizeof(sljit_sw) : 0);- else if (bra == OP_BRAZERO)- {- if (framesize < 0)- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 1) * sizeof(sljit_sw));- else- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (framesize + extrasize - 1) * sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);- }- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }- else if (framesize >= 0)- {- /* For OP_BRA and OP_BRAMINZERO. */- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));- }- }- add_jump(compiler, found, JUMP(SLJIT_JUMP));-- compile_backtrackingpath(common, altbacktrack.top);- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- {- if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)- {- common->local_exit = save_local_exit;- common->quit_label = save_quit_label;- common->quit = save_quit;- }- common->positive_assert = save_positive_assert;- common->then_trap = save_then_trap;- common->accept_label = save_accept_label;- common->positive_assert_quit = save_positive_assert_quit;- common->accept = save_accept;- return NULL;- }- set_jumps(altbacktrack.topbacktracks, LABEL());-- if (*cc != OP_ALT)- break;-- ccbegin = cc;- cc += GET(cc, 1);- }--if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)- {- SLJIT_ASSERT(common->positive_assert_quit == NULL);- /* Makes the check less complicated below. */- common->positive_assert_quit = common->quit;- }--/* None of them matched. */-if (common->positive_assert_quit != NULL)- {- jump = JUMP(SLJIT_JUMP);- set_jumps(common->positive_assert_quit, LABEL());- SLJIT_ASSERT(framesize != no_stack);- if (framesize < 0)- OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, extrasize * sizeof(sljit_sw));- else- {- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));- }- JUMPHERE(jump);- }--if (needs_control_head)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(1));--if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)- {- /* Assert is failed. */- if (conditional || bra == OP_BRAZERO)- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));-- if (framesize < 0)- {- /* The topmost item should be 0. */- if (bra == OP_BRAZERO)- {- if (extrasize == 2)- free_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }- else- free_stack(common, extrasize);- }- else- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));- /* The topmost item should be 0. */- if (bra == OP_BRAZERO)- {- free_stack(common, framesize + extrasize - 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }- else- free_stack(common, framesize + extrasize);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);- }- jump = JUMP(SLJIT_JUMP);- if (bra != OP_BRAZERO)- add_jump(compiler, target, jump);-- /* Assert is successful. */- set_jumps(tmp, LABEL());- if (framesize < 0)- {- /* We know that STR_PTR was stored on the top of the stack. */- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 1) * sizeof(sljit_sw));- /* Keep the STR_PTR on the top of the stack. */- if (bra == OP_BRAZERO)- {- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));- if (extrasize == 2)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- }- else if (bra == OP_BRAMINZERO)- {- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }- }- else- {- if (bra == OP_BRA)- {- /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */- OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), (extrasize - 2) * sizeof(sljit_sw));- }- else- {- /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */- OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_sw));- if (extrasize == 2)- {- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- if (bra == OP_BRAMINZERO)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }- else- {- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);- }- }- }-- if (bra == OP_BRAZERO)- {- backtrack->matchingpath = LABEL();- SET_LABEL(jump, backtrack->matchingpath);- }- else if (bra == OP_BRAMINZERO)- {- JUMPTO(SLJIT_JUMP, backtrack->matchingpath);- JUMPHERE(brajump);- if (framesize >= 0)- {- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), framesize * sizeof(sljit_sw));- }- set_jumps(backtrack->common.topbacktracks, LABEL());- }- }-else- {- /* AssertNot is successful. */- if (framesize < 0)- {- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- if (bra != OP_BRA)- {- if (extrasize == 2)- free_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }- else- free_stack(common, extrasize);- }- else- {- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));- /* The topmost item should be 0. */- if (bra != OP_BRA)- {- free_stack(common, framesize + extrasize - 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }- else- free_stack(common, framesize + extrasize);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);- }-- if (bra == OP_BRAZERO)- backtrack->matchingpath = LABEL();- else if (bra == OP_BRAMINZERO)- {- JUMPTO(SLJIT_JUMP, backtrack->matchingpath);- JUMPHERE(brajump);- }-- if (bra != OP_BRA)- {- SLJIT_ASSERT(found == &backtrack->common.topbacktracks);- set_jumps(backtrack->common.topbacktracks, LABEL());- backtrack->common.topbacktracks = NULL;- }- }--if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)- {- common->local_exit = save_local_exit;- common->quit_label = save_quit_label;- common->quit = save_quit;- }-common->positive_assert = save_positive_assert;-common->then_trap = save_then_trap;-common->accept_label = save_accept_label;-common->positive_assert_quit = save_positive_assert_quit;-common->accept = save_accept;-return cc + 1 + LINK_SIZE;-}--static SLJIT_INLINE void match_once_common(compiler_common *common, pcre_uchar ket, int framesize, int private_data_ptr, BOOL has_alternatives, BOOL needs_control_head)-{-DEFINE_COMPILER;-int stacksize;--if (framesize < 0)- {- if (framesize == no_frame)- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- else- {- stacksize = needs_control_head ? 1 : 0;- if (ket != OP_KET || has_alternatives)- stacksize++;- free_stack(common, stacksize);- }-- if (needs_control_head)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (ket != OP_KET || has_alternatives) ? sizeof(sljit_sw) : 0);-- /* TMP2 which is set here used by OP_KETRMAX below. */- if (ket == OP_KETRMAX)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), 0);- else if (ket == OP_KETRMIN)- {- /* Move the STR_PTR to the private_data_ptr. */- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), 0);- }- }-else- {- stacksize = (ket != OP_KET || has_alternatives) ? 2 : 1;- OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, (framesize + stacksize) * sizeof(sljit_sw));- if (needs_control_head)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 0);-- if (ket == OP_KETRMAX)- {- /* TMP2 which is set here used by OP_KETRMAX below. */- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- }- }-if (needs_control_head)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP1, 0);-}--static SLJIT_INLINE int match_capture_common(compiler_common *common, int stacksize, int offset, int private_data_ptr)-{-DEFINE_COMPILER;--if (common->capture_last_ptr != 0)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);- stacksize++;- }-if (common->optimized_cbracket[offset >> 1] == 0)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);- stacksize += 2;- }-return stacksize;-}--/*- Handling bracketed expressions is probably the most complex part.-- Stack layout naming characters:- S - Push the current STR_PTR- 0 - Push a 0 (NULL)- A - Push the current STR_PTR. Needed for restoring the STR_PTR- before the next alternative. Not pushed if there are no alternatives.- M - Any values pushed by the current alternative. Can be empty, or anything.- C - Push the previous OVECTOR(i), OVECTOR(i+1) and OVECTOR_PRIV(i) to the stack.- L - Push the previous local (pointed by localptr) to the stack- () - opional values stored on the stack- ()* - optonal, can be stored multiple times-- The following list shows the regular expression templates, their PCRE byte codes- and stack layout supported by pcre-sljit.-- (?:) OP_BRA | OP_KET A M- () OP_CBRA | OP_KET C M- (?:)+ OP_BRA | OP_KETRMAX 0 A M S ( A M S )*- OP_SBRA | OP_KETRMAX 0 L M S ( L M S )*- (?:)+? OP_BRA | OP_KETRMIN 0 A M S ( A M S )*- OP_SBRA | OP_KETRMIN 0 L M S ( L M S )*- ()+ OP_CBRA | OP_KETRMAX 0 C M S ( C M S )*- OP_SCBRA | OP_KETRMAX 0 C M S ( C M S )*- ()+? OP_CBRA | OP_KETRMIN 0 C M S ( C M S )*- OP_SCBRA | OP_KETRMIN 0 C M S ( C M S )*- (?:)? OP_BRAZERO | OP_BRA | OP_KET S ( A M 0 )- (?:)?? OP_BRAMINZERO | OP_BRA | OP_KET S ( A M 0 )- ()? OP_BRAZERO | OP_CBRA | OP_KET S ( C M 0 )- ()?? OP_BRAMINZERO | OP_CBRA | OP_KET S ( C M 0 )- (?:)* OP_BRAZERO | OP_BRA | OP_KETRMAX S 0 ( A M S )*- OP_BRAZERO | OP_SBRA | OP_KETRMAX S 0 ( L M S )*- (?:)*? OP_BRAMINZERO | OP_BRA | OP_KETRMIN S 0 ( A M S )*- OP_BRAMINZERO | OP_SBRA | OP_KETRMIN S 0 ( L M S )*- ()* OP_BRAZERO | OP_CBRA | OP_KETRMAX S 0 ( C M S )*- OP_BRAZERO | OP_SCBRA | OP_KETRMAX S 0 ( C M S )*- ()*? OP_BRAMINZERO | OP_CBRA | OP_KETRMIN S 0 ( C M S )*- OP_BRAMINZERO | OP_SCBRA | OP_KETRMIN S 0 ( C M S )*--- Stack layout naming characters:- A - Push the alternative index (starting from 0) on the stack.- Not pushed if there is no alternatives.- M - Any values pushed by the current alternative. Can be empty, or anything.-- The next list shows the possible content of a bracket:- (|) OP_*BRA | OP_ALT ... M A- (?()|) OP_*COND | OP_ALT M A- (?>|) OP_ONCE | OP_ALT ... [stack trace] M A- (?>|) OP_ONCE_NC | OP_ALT ... [stack trace] M A- Or nothing, if trace is unnecessary-*/--static pcre_uchar *compile_bracket_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;-pcre_uchar opcode;-int private_data_ptr = 0;-int offset = 0;-int i, stacksize;-int repeat_ptr = 0, repeat_length = 0;-int repeat_type = 0, repeat_count = 0;-pcre_uchar *ccbegin;-pcre_uchar *matchingpath;-pcre_uchar *slot;-pcre_uchar bra = OP_BRA;-pcre_uchar ket;-assert_backtrack *assert;-BOOL has_alternatives;-BOOL needs_control_head = FALSE;-struct sljit_jump *jump;-struct sljit_jump *skip;-struct sljit_label *rmax_label = NULL;-struct sljit_jump *braminzero = NULL;--PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);--if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)- {- bra = *cc;- cc++;- opcode = *cc;- }--opcode = *cc;-ccbegin = cc;-matchingpath = bracketend(cc) - 1 - LINK_SIZE;-ket = *matchingpath;-if (ket == OP_KET && PRIVATE_DATA(matchingpath) != 0)- {- repeat_ptr = PRIVATE_DATA(matchingpath);- repeat_length = PRIVATE_DATA(matchingpath + 1);- repeat_type = PRIVATE_DATA(matchingpath + 2);- repeat_count = PRIVATE_DATA(matchingpath + 3);- SLJIT_ASSERT(repeat_length != 0 && repeat_type != 0 && repeat_count != 0);- if (repeat_type == OP_UPTO)- ket = OP_KETRMAX;- if (repeat_type == OP_MINUPTO)- ket = OP_KETRMIN;- }--if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)- {- /* Drop this bracket_backtrack. */- parent->top = backtrack->prev;- return matchingpath + 1 + LINK_SIZE + repeat_length;- }--matchingpath = ccbegin + 1 + LINK_SIZE;-SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);-SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));-cc += GET(cc, 1);--has_alternatives = *cc == OP_ALT;-if (SLJIT_UNLIKELY(opcode == OP_COND || opcode == OP_SCOND))- has_alternatives = (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF) ? FALSE : TRUE;--if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))- opcode = OP_SCOND;-if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))- opcode = OP_ONCE;--if (opcode == OP_CBRA || opcode == OP_SCBRA)- {- /* Capturing brackets has a pre-allocated space. */- offset = GET2(ccbegin, 1 + LINK_SIZE);- if (common->optimized_cbracket[offset] == 0)- {- private_data_ptr = OVECTOR_PRIV(offset);- offset <<= 1;- }- else- {- offset <<= 1;- private_data_ptr = OVECTOR(offset);- }- BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;- matchingpath += IMM2_SIZE;- }-else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)- {- /* Other brackets simply allocate the next entry. */- private_data_ptr = PRIVATE_DATA(ccbegin);- SLJIT_ASSERT(private_data_ptr != 0);- BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;- if (opcode == OP_ONCE)- BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, NULL, FALSE, &needs_control_head);- }--/* Instructions before the first alternative. */-stacksize = 0;-if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))- stacksize++;-if (bra == OP_BRAZERO)- stacksize++;--if (stacksize > 0)- allocate_stack(common, stacksize);--stacksize = 0;-if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);- stacksize++;- }--if (bra == OP_BRAZERO)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);--if (bra == OP_BRAMINZERO)- {- /* This is a backtrack path! (Since the try-path of OP_BRAMINZERO matches to the empty string) */- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- if (ket != OP_KETRMIN)- {- free_stack(common, 1);- braminzero = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);- }- else- {- if (opcode == OP_ONCE || opcode >= OP_SBRA)- {- jump = CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- /* Nothing stored during the first run. */- skip = JUMP(SLJIT_JUMP);- JUMPHERE(jump);- /* Checking zero-length iteration. */- if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)- {- /* When we come from outside, private_data_ptr contains the previous STR_PTR. */- braminzero = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- }- else- {- /* Except when the whole stack frame must be saved. */- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- braminzero = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (BACKTRACK_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw));- }- JUMPHERE(skip);- }- else- {- jump = CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- JUMPHERE(jump);- }- }- }--if (repeat_type != 0)- {- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, repeat_count);- if (repeat_type == OP_EXACT)- rmax_label = LABEL();- }--if (ket == OP_KETRMIN)- BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();--if (ket == OP_KETRMAX)- {- rmax_label = LABEL();- if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA && repeat_type == 0)- BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmax_label;- }--/* Handling capturing brackets and alternatives. */-if (opcode == OP_ONCE)- {- stacksize = 0;- if (needs_control_head)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- stacksize++;- }-- if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)- {- /* Neither capturing brackets nor recursions are found in the block. */- if (ket == OP_KETRMIN)- {- stacksize += 2;- if (!needs_control_head)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- }- else- {- if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);- if (ket == OP_KETRMAX || has_alternatives)- stacksize++;- }-- if (stacksize > 0)- allocate_stack(common, stacksize);-- stacksize = 0;- if (needs_control_head)- {- stacksize++;- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);- }-- if (ket == OP_KETRMIN)- {- if (needs_control_head)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);- if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)- OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, needs_control_head ? (2 * sizeof(sljit_sw)) : sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);- }- else if (ket == OP_KETRMAX || has_alternatives)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);- }- else- {- if (ket != OP_KET || has_alternatives)- stacksize++;-- stacksize += BACKTRACK_AS(bracket_backtrack)->u.framesize + 1;- allocate_stack(common, stacksize);-- if (needs_control_head)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);-- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- OP2(SLJIT_SUB, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));-- stacksize = needs_control_head ? 1 : 0;- if (ket != OP_KET || has_alternatives)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);- stacksize++;- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);- }- else- {- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP2, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);- }- init_frame(common, ccbegin, NULL, BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize, stacksize + 1, FALSE);- }- }-else if (opcode == OP_CBRA || opcode == OP_SCBRA)- {- /* Saving the previous values. */- if (common->optimized_cbracket[offset >> 1] != 0)- {- SLJIT_ASSERT(private_data_ptr == OVECTOR(offset));- allocate_stack(common, 2);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr + sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);- }- else- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);- }- }-else if (opcode == OP_SBRA || opcode == OP_SCOND)- {- /* Saving the previous value. */- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);- }-else if (has_alternatives)- {- /* Pushing the starting string pointer. */- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- }--/* Generating code for the first alternative. */-if (opcode == OP_COND || opcode == OP_SCOND)- {- if (*matchingpath == OP_CREF)- {- SLJIT_ASSERT(has_alternatives);- add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed),- CMP(SLJIT_C_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1)));- matchingpath += 1 + IMM2_SIZE;- }- else if (*matchingpath == OP_DNCREF)- {- SLJIT_ASSERT(has_alternatives);-- i = GET2(matchingpath, 1 + IMM2_SIZE);- slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;- OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(1));- OP2(SLJIT_SUB | SLJIT_SET_E, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);- slot += common->name_entry_size;- i--;- while (i-- > 0)- {- OP2(SLJIT_SUB, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);- OP2(SLJIT_OR | SLJIT_SET_E, TMP2, 0, TMP2, 0, STR_PTR, 0);- slot += common->name_entry_size;- }- OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);- add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), JUMP(SLJIT_C_ZERO));- matchingpath += 1 + 2 * IMM2_SIZE;- }- else if (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF)- {- /* Never has other case. */- BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;- SLJIT_ASSERT(!has_alternatives);-- if (*matchingpath == OP_RREF)- {- stacksize = GET2(matchingpath, 1);- if (common->currententry == NULL)- stacksize = 0;- else if (stacksize == RREF_ANY)- stacksize = 1;- else if (common->currententry->start == 0)- stacksize = stacksize == 0;- else- stacksize = stacksize == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);-- if (stacksize != 0)- matchingpath += 1 + IMM2_SIZE;- }- else- {- if (common->currententry == NULL || common->currententry->start == 0)- stacksize = 0;- else- {- stacksize = GET2(matchingpath, 1 + IMM2_SIZE);- slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;- i = (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);- while (stacksize > 0)- {- if ((int)GET2(slot, 0) == i)- break;- slot += common->name_entry_size;- stacksize--;- }- }-- if (stacksize != 0)- matchingpath += 1 + 2 * IMM2_SIZE;- }-- /* The stacksize == 0 is a common "else" case. */- if (stacksize == 0)- {- if (*cc == OP_ALT)- {- matchingpath = cc + 1 + LINK_SIZE;- cc += GET(cc, 1);- }- else- matchingpath = cc;- }- }- else- {- SLJIT_ASSERT(has_alternatives && *matchingpath >= OP_ASSERT && *matchingpath <= OP_ASSERTBACK_NOT);- /* Similar code as PUSH_BACKTRACK macro. */- assert = sljit_alloc_memory(compiler, sizeof(assert_backtrack));- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- return NULL;- memset(assert, 0, sizeof(assert_backtrack));- assert->common.cc = matchingpath;- BACKTRACK_AS(bracket_backtrack)->u.assert = assert;- matchingpath = compile_assert_matchingpath(common, matchingpath, assert, TRUE);- }- }--compile_matchingpath(common, matchingpath, cc, backtrack);-if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- return NULL;--if (opcode == OP_ONCE)- match_once_common(common, ket, BACKTRACK_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);--stacksize = 0;-if (repeat_type == OP_MINUPTO)- {- /* We need to preserve the counter. TMP2 will be used below. */- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);- stacksize++;- }-if (ket != OP_KET || bra != OP_BRA)- stacksize++;-if (offset != 0)- {- if (common->capture_last_ptr != 0)- stacksize++;- if (common->optimized_cbracket[offset >> 1] == 0)- stacksize += 2;- }-if (has_alternatives && opcode != OP_ONCE)- stacksize++;--if (stacksize > 0)- allocate_stack(common, stacksize);--stacksize = 0;-if (repeat_type == OP_MINUPTO)- {- /* TMP2 was set above. */- OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);- stacksize++;- }--if (ket != OP_KET || bra != OP_BRA)- {- if (ket != OP_KET)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);- else- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);- stacksize++;- }--if (offset != 0)- stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);--if (has_alternatives)- {- if (opcode != OP_ONCE)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);- if (ket != OP_KETRMAX)- BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();- }--/* Must be after the matchingpath label. */-if (offset != 0 && common->optimized_cbracket[offset >> 1] != 0)- {- SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);- }--if (ket == OP_KETRMAX)- {- if (repeat_type != 0)- {- if (has_alternatives)- BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, rmax_label);- /* Drop STR_PTR for greedy plus quantifier. */- if (opcode != OP_ONCE)- free_stack(common, 1);- }- else if (opcode == OP_ONCE || opcode >= OP_SBRA)- {- if (has_alternatives)- BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();- /* Checking zero-length iteration. */- if (opcode != OP_ONCE)- {- CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STR_PTR, 0, rmax_label);- /* Drop STR_PTR for greedy plus quantifier. */- if (bra != OP_BRAZERO)- free_stack(common, 1);- }- else- /* TMP2 must contain the starting STR_PTR. */- CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmax_label);- }- else- JUMPTO(SLJIT_JUMP, rmax_label);- BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();- }--if (repeat_type == OP_EXACT)- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, rmax_label);- }-else if (repeat_type == OP_UPTO)- {- /* We need to preserve the counter. */- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);- }--if (bra == OP_BRAZERO)- BACKTRACK_AS(bracket_backtrack)->zero_matchingpath = LABEL();--if (bra == OP_BRAMINZERO)- {- /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */- JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->matchingpath);- if (braminzero != NULL)- {- JUMPHERE(braminzero);- /* We need to release the end pointer to perform the- backtrack for the zero-length iteration. When- framesize is < 0, OP_ONCE will do the release itself. */- if (opcode == OP_ONCE && BACKTRACK_AS(bracket_backtrack)->u.framesize >= 0)- {- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- }- else if (ket == OP_KETRMIN && opcode != OP_ONCE)- free_stack(common, 1);- }- /* Continue to the normal backtrack. */- }--if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)- count_match(common);--/* Skip the other alternatives. */-while (*cc == OP_ALT)- cc += GET(cc, 1);-cc += 1 + LINK_SIZE;--/* Temporarily encoding the needs_control_head in framesize. */-if (opcode == OP_ONCE)- BACKTRACK_AS(bracket_backtrack)->u.framesize = (BACKTRACK_AS(bracket_backtrack)->u.framesize << 1) | (needs_control_head ? 1 : 0);-return cc + repeat_length;-}--static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;-pcre_uchar opcode;-int private_data_ptr;-int cbraprivptr = 0;-BOOL needs_control_head;-int framesize;-int stacksize;-int offset = 0;-BOOL zero = FALSE;-pcre_uchar *ccbegin = NULL;-int stack; /* Also contains the offset of control head. */-struct sljit_label *loop = NULL;-struct jump_list *emptymatch = NULL;--PUSH_BACKTRACK(sizeof(bracketpos_backtrack), cc, NULL);-if (*cc == OP_BRAPOSZERO)- {- zero = TRUE;- cc++;- }--opcode = *cc;-private_data_ptr = PRIVATE_DATA(cc);-SLJIT_ASSERT(private_data_ptr != 0);-BACKTRACK_AS(bracketpos_backtrack)->private_data_ptr = private_data_ptr;-switch(opcode)- {- case OP_BRAPOS:- case OP_SBRAPOS:- ccbegin = cc + 1 + LINK_SIZE;- break;-- case OP_CBRAPOS:- case OP_SCBRAPOS:- offset = GET2(cc, 1 + LINK_SIZE);- /* This case cannot be optimized in the same was as- normal capturing brackets. */- SLJIT_ASSERT(common->optimized_cbracket[offset] == 0);- cbraprivptr = OVECTOR_PRIV(offset);- offset <<= 1;- ccbegin = cc + 1 + LINK_SIZE + IMM2_SIZE;- break;-- default:- SLJIT_ASSERT_STOP();- break;- }--framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);-BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;-if (framesize < 0)- {- if (offset != 0)- {- stacksize = 2;- if (common->capture_last_ptr != 0)- stacksize++;- }- else- stacksize = 1;-- if (needs_control_head)- stacksize++;- if (!zero)- stacksize++;-- BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;- allocate_stack(common, stacksize);- if (framesize == no_frame)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0);-- stack = 0;- if (offset != 0)- {- stack = 2;- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);- if (common->capture_last_ptr != 0)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);- if (needs_control_head)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- if (common->capture_last_ptr != 0)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);- stack = 3;- }- }- else- {- if (needs_control_head)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- stack = 1;- }-- if (needs_control_head)- stack++;- if (!zero)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), SLJIT_IMM, 1);- if (needs_control_head)- {- stack--;- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);- }- }-else- {- stacksize = framesize + 1;- if (!zero)- stacksize++;- if (needs_control_head)- stacksize++;- if (offset == 0)- stacksize++;- BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;-- allocate_stack(common, stacksize);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- if (needs_control_head)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, -STACK(stacksize - 1));-- stack = 0;- if (!zero)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);- stack = 1;- }- if (needs_control_head)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);- stack++;- }- if (offset == 0)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);- stack++;- }- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);- init_frame(common, cc, NULL, stacksize - 1, stacksize - framesize, FALSE);- stack -= 1 + (offset == 0);- }--if (offset != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);--loop = LABEL();-while (*cc != OP_KETRPOS)- {- backtrack->top = NULL;- backtrack->topbacktracks = NULL;- cc += GET(cc, 1);-- compile_matchingpath(common, ccbegin, cc, backtrack);- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- return NULL;-- if (framesize < 0)- {- if (framesize == no_frame)- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);-- if (offset != 0)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);- if (common->capture_last_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);- }- else- {- if (opcode == OP_SBRAPOS)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- }-- if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)- add_jump(compiler, &emptymatch, CMP(SLJIT_C_EQUAL, TMP1, 0, STR_PTR, 0));-- if (!zero)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);- }- else- {- if (offset != 0)- {- OP2(SLJIT_ADD, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr, STR_PTR, 0);- if (common->capture_last_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, offset >> 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);- }- else- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- OP2(SLJIT_ADD, STACK_TOP, 0, TMP2, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));- if (opcode == OP_SBRAPOS)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_sw), STR_PTR, 0);- }-- if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)- add_jump(compiler, &emptymatch, CMP(SLJIT_C_EQUAL, TMP1, 0, STR_PTR, 0));-- if (!zero)- {- if (framesize < 0)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);- else- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }- }-- if (needs_control_head)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));-- JUMPTO(SLJIT_JUMP, loop);- flush_stubs(common);-- compile_backtrackingpath(common, backtrack->top);- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- return NULL;- set_jumps(backtrack->topbacktracks, LABEL());-- if (framesize < 0)- {- if (offset != 0)- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);- else- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- }- else- {- if (offset != 0)- {- /* Last alternative. */- if (*cc == OP_KETRPOS)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), cbraprivptr);- }- else- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP2), (framesize + 1) * sizeof(sljit_sw));- }- }-- if (*cc == OP_KETRPOS)- break;- ccbegin = cc + 1 + LINK_SIZE;- }--/* We don't have to restore the control head in case of a failed match. */--backtrack->topbacktracks = NULL;-if (!zero)- {- if (framesize < 0)- add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));- else /* TMP2 is set to [private_data_ptr] above. */- add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(TMP2), (stacksize - 1) * sizeof(sljit_sw), SLJIT_IMM, 0));- }--/* None of them matched. */-set_jumps(emptymatch, LABEL());-count_match(common);-return cc + 1 + LINK_SIZE;-}--static SLJIT_INLINE pcre_uchar *get_iterator_parameters(compiler_common *common, pcre_uchar *cc, pcre_uchar *opcode, pcre_uchar *type, int *max, int *min, pcre_uchar **end)-{-int class_len;--*opcode = *cc;-if (*opcode >= OP_STAR && *opcode <= OP_POSUPTO)- {- cc++;- *type = OP_CHAR;- }-else if (*opcode >= OP_STARI && *opcode <= OP_POSUPTOI)- {- cc++;- *type = OP_CHARI;- *opcode -= OP_STARI - OP_STAR;- }-else if (*opcode >= OP_NOTSTAR && *opcode <= OP_NOTPOSUPTO)- {- cc++;- *type = OP_NOT;- *opcode -= OP_NOTSTAR - OP_STAR;- }-else if (*opcode >= OP_NOTSTARI && *opcode <= OP_NOTPOSUPTOI)- {- cc++;- *type = OP_NOTI;- *opcode -= OP_NOTSTARI - OP_STAR;- }-else if (*opcode >= OP_TYPESTAR && *opcode <= OP_TYPEPOSUPTO)- {- cc++;- *opcode -= OP_TYPESTAR - OP_STAR;- *type = 0;- }-else- {- SLJIT_ASSERT(*opcode == OP_CLASS || *opcode == OP_NCLASS || *opcode == OP_XCLASS);- *type = *opcode;- cc++;- class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);- *opcode = cc[class_len - 1];- if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)- {- *opcode -= OP_CRSTAR - OP_STAR;- if (end != NULL)- *end = cc + class_len;- }- else if (*opcode >= OP_CRPOSSTAR && *opcode <= OP_CRPOSQUERY)- {- *opcode -= OP_CRPOSSTAR - OP_POSSTAR;- if (end != NULL)- *end = cc + class_len;- }- else- {- SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE || *opcode == OP_CRPOSRANGE);- *max = GET2(cc, (class_len + IMM2_SIZE));- *min = GET2(cc, class_len);-- if (*min == 0)- {- SLJIT_ASSERT(*max != 0);- *opcode = (*opcode == OP_CRRANGE) ? OP_UPTO : (*opcode == OP_CRMINRANGE ? OP_MINUPTO : OP_POSUPTO);- }- if (*max == *min)- *opcode = OP_EXACT;-- if (end != NULL)- *end = cc + class_len + 2 * IMM2_SIZE;- }- return cc;- }--if (*opcode == OP_UPTO || *opcode == OP_MINUPTO || *opcode == OP_EXACT || *opcode == OP_POSUPTO)- {- *max = GET2(cc, 0);- cc += IMM2_SIZE;- }--if (*type == 0)- {- *type = *cc;- if (end != NULL)- *end = next_opcode(common, cc);- cc++;- return cc;- }--if (end != NULL)- {- *end = cc + 1;-#ifdef SUPPORT_UTF- if (common->utf && HAS_EXTRALEN(*cc)) *end += GET_EXTRALEN(*cc);-#endif- }-return cc;-}--static pcre_uchar *compile_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;-pcre_uchar opcode;-pcre_uchar type;-int max = -1, min = -1;-pcre_uchar* end;-jump_list *nomatch = NULL;-struct sljit_jump *jump = NULL;-struct sljit_label *label;-int private_data_ptr = PRIVATE_DATA(cc);-int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_LOCALS_REG);-int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;-int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);-int tmp_base, tmp_offset;--PUSH_BACKTRACK(sizeof(iterator_backtrack), cc, NULL);--cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, &end);--switch(type)- {- case OP_NOT_DIGIT:- case OP_DIGIT:- case OP_NOT_WHITESPACE:- case OP_WHITESPACE:- case OP_NOT_WORDCHAR:- case OP_WORDCHAR:- case OP_ANY:- case OP_ALLANY:- case OP_ANYBYTE:- case OP_ANYNL:- case OP_NOT_HSPACE:- case OP_HSPACE:- case OP_NOT_VSPACE:- case OP_VSPACE:- case OP_CHAR:- case OP_CHARI:- case OP_NOT:- case OP_NOTI:- case OP_CLASS:- case OP_NCLASS:- tmp_base = TMP3;- tmp_offset = 0;- break;-- default:- SLJIT_ASSERT_STOP();- /* Fall through. */-- case OP_EXTUNI:- case OP_XCLASS:- case OP_NOTPROP:- case OP_PROP:- tmp_base = SLJIT_MEM1(SLJIT_LOCALS_REG);- tmp_offset = POSSESSIVE0;- break;- }--switch(opcode)- {- case OP_STAR:- case OP_PLUS:- case OP_UPTO:- case OP_CRRANGE:- if (type == OP_ANYNL || type == OP_EXTUNI)- {- SLJIT_ASSERT(private_data_ptr == 0);- if (opcode == OP_STAR || opcode == OP_UPTO)- {- allocate_stack(common, 2);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);- }- else- {- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- }-- if (opcode == OP_UPTO || opcode == OP_CRRANGE)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, SLJIT_IMM, 0);-- label = LABEL();- compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);- if (opcode == OP_UPTO || opcode == OP_CRRANGE)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- if (opcode == OP_CRRANGE && min > 0)- CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min, label);- if (opcode == OP_UPTO || (opcode == OP_CRRANGE && max > 0))- jump = CMP(SLJIT_C_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0, TMP1, 0);- }-- /* We cannot use TMP3 because of this allocate_stack. */- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- JUMPTO(SLJIT_JUMP, label);- if (jump != NULL)- JUMPHERE(jump);- }- else- {- if (opcode == OP_PLUS)- compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);- if (private_data_ptr == 0)- allocate_stack(common, 2);- OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);- if (opcode <= OP_PLUS)- OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);- else- OP1(SLJIT_MOV, base, offset1, SLJIT_IMM, 1);- label = LABEL();- compile_char1_matchingpath(common, type, cc, &nomatch);- OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);- if (opcode <= OP_PLUS)- JUMPTO(SLJIT_JUMP, label);- else if (opcode == OP_CRRANGE && max == 0)- {- OP2(SLJIT_ADD, base, offset1, base, offset1, SLJIT_IMM, 1);- JUMPTO(SLJIT_JUMP, label);- }- else- {- OP1(SLJIT_MOV, TMP1, 0, base, offset1);- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP1(SLJIT_MOV, base, offset1, TMP1, 0);- CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, max + 1, label);- }- set_jumps(nomatch, LABEL());- if (opcode == OP_CRRANGE)- add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_LESS, base, offset1, SLJIT_IMM, min + 1));- OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);- }- BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();- break;-- case OP_MINSTAR:- case OP_MINPLUS:- if (opcode == OP_MINPLUS)- compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);- if (private_data_ptr == 0)- allocate_stack(common, 1);- OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);- BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();- break;-- case OP_MINUPTO:- case OP_CRMINRANGE:- if (private_data_ptr == 0)- allocate_stack(common, 2);- OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);- OP1(SLJIT_MOV, base, offset1, SLJIT_IMM, 1);- if (opcode == OP_CRMINRANGE)- add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));- BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();- break;-- case OP_QUERY:- case OP_MINQUERY:- if (private_data_ptr == 0)- allocate_stack(common, 1);- OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);- if (opcode == OP_QUERY)- compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);- BACKTRACK_AS(iterator_backtrack)->matchingpath = LABEL();- break;-- case OP_EXACT:- OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);- label = LABEL();- compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);- OP2(SLJIT_SUB | SLJIT_SET_E, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, label);- break;-- case OP_POSSTAR:- case OP_POSPLUS:- case OP_POSUPTO:- if (opcode == OP_POSPLUS)- compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);- if (opcode == OP_POSUPTO)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, max);- OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);- label = LABEL();- compile_char1_matchingpath(common, type, cc, &nomatch);- OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);- if (opcode != OP_POSUPTO)- JUMPTO(SLJIT_JUMP, label);- else- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, label);- }- set_jumps(nomatch, LABEL());- OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);- break;-- case OP_POSQUERY:- OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);- compile_char1_matchingpath(common, type, cc, &nomatch);- OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);- set_jumps(nomatch, LABEL());- OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);- break;-- case OP_CRPOSRANGE:- /* Combination of OP_EXACT and OP_POSSTAR or OP_POSUPTO */- OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, min);- label = LABEL();- compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks);- OP2(SLJIT_SUB | SLJIT_SET_E, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, label);-- if (max != 0)- {- SLJIT_ASSERT(max - min > 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, max - min);- }- OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);- label = LABEL();- compile_char1_matchingpath(common, type, cc, &nomatch);- OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);- if (max == 0)- JUMPTO(SLJIT_JUMP, label);- else- {- OP2(SLJIT_SUB | SLJIT_SET_E, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE1, SLJIT_IMM, 1);- JUMPTO(SLJIT_C_NOT_ZERO, label);- }- set_jumps(nomatch, LABEL());- OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);- break;-- default:- SLJIT_ASSERT_STOP();- break;- }--count_match(common);-return end;-}--static SLJIT_INLINE pcre_uchar *compile_fail_accept_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;--PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);--if (*cc == OP_FAIL)- {- add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));- return cc + 1;- }--if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL)- {- /* No need to check notempty conditions. */- if (common->accept_label == NULL)- add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));- else- JUMPTO(SLJIT_JUMP, common->accept_label);- return cc + 1;- }--if (common->accept_label == NULL)- add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0)));-else- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), common->accept_label);-OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);-OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));-add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));-OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));-if (common->accept_label == NULL)- add_jump(compiler, &common->accept, CMP(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0));-else- CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, common->accept_label);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));-if (common->accept_label == NULL)- add_jump(compiler, &common->accept, CMP(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0));-else- CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->accept_label);-add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));-return cc + 1;-}--static SLJIT_INLINE pcre_uchar *compile_close_matchingpath(compiler_common *common, pcre_uchar *cc)-{-DEFINE_COMPILER;-int offset = GET2(cc, 1);-BOOL optimized_cbracket = common->optimized_cbracket[offset] != 0;--/* Data will be discarded anyway... */-if (common->currententry != NULL)- return cc + 1 + IMM2_SIZE;--if (!optimized_cbracket)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR_PRIV(offset));-offset <<= 1;-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);-if (!optimized_cbracket)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);-return cc + 1 + IMM2_SIZE;-}--static SLJIT_INLINE pcre_uchar *compile_control_verb_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;-pcre_uchar opcode = *cc;-pcre_uchar *ccend = cc + 1;--if (opcode == OP_PRUNE_ARG || opcode == OP_SKIP_ARG || opcode == OP_THEN_ARG)- ccend += 2 + cc[1];--PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);--if (opcode == OP_SKIP)- {- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- return ccend;- }--if (opcode == OP_PRUNE_ARG || opcode == OP_THEN_ARG)- {- OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);- }--return ccend;-}--static pcre_uchar then_trap_opcode[1] = { OP_THEN_TRAP };--static SLJIT_INLINE void compile_then_trap_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;-BOOL needs_control_head;-int size;--PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);-common->then_trap = BACKTRACK_AS(then_trap_backtrack);-BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;-BACKTRACK_AS(then_trap_backtrack)->start = (sljit_sw)(cc - common->start);-BACKTRACK_AS(then_trap_backtrack)->framesize = get_framesize(common, cc, ccend, FALSE, &needs_control_head);--size = BACKTRACK_AS(then_trap_backtrack)->framesize;-size = 3 + (size < 0 ? 0 : size);--OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);-allocate_stack(common, size);-if (size > 3)- OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0, SLJIT_IMM, (size - 3) * sizeof(sljit_sw));-else- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 1), SLJIT_IMM, BACKTRACK_AS(then_trap_backtrack)->start);-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 2), SLJIT_IMM, type_then_trap);-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 3), TMP2, 0);--size = BACKTRACK_AS(then_trap_backtrack)->framesize;-if (size >= 0)- init_frame(common, cc, ccend, size - 1, 0, FALSE);-}--static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)-{-DEFINE_COMPILER;-backtrack_common *backtrack;-BOOL has_then_trap = FALSE;-then_trap_backtrack *save_then_trap = NULL;--SLJIT_ASSERT(*ccend == OP_END || (*ccend >= OP_ALT && *ccend <= OP_KETRPOS));--if (common->has_then && common->then_offsets[cc - common->start] != 0)- {- SLJIT_ASSERT(*ccend != OP_END && common->control_head_ptr != 0);- has_then_trap = TRUE;- save_then_trap = common->then_trap;- /* Tail item on backtrack. */- compile_then_trap_matchingpath(common, cc, ccend, parent);- }--while (cc < ccend)- {- switch(*cc)- {- case OP_SOD:- case OP_SOM:- case OP_NOT_WORD_BOUNDARY:- case OP_WORD_BOUNDARY:- case OP_NOT_DIGIT:- case OP_DIGIT:- case OP_NOT_WHITESPACE:- case OP_WHITESPACE:- case OP_NOT_WORDCHAR:- case OP_WORDCHAR:- case OP_ANY:- case OP_ALLANY:- case OP_ANYBYTE:- case OP_NOTPROP:- case OP_PROP:- case OP_ANYNL:- case OP_NOT_HSPACE:- case OP_HSPACE:- case OP_NOT_VSPACE:- case OP_VSPACE:- case OP_EXTUNI:- case OP_EODN:- case OP_EOD:- case OP_CIRC:- case OP_CIRCM:- case OP_DOLL:- case OP_DOLLM:- case OP_NOT:- case OP_NOTI:- case OP_REVERSE:- cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);- break;-- case OP_SET_SOM:- PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);- cc++;- break;-- case OP_CHAR:- case OP_CHARI:- if (common->mode == JIT_COMPILE)- cc = compile_charn_matchingpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);- else- cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);- break;-- case OP_STAR:- case OP_MINSTAR:- case OP_PLUS:- case OP_MINPLUS:- case OP_QUERY:- case OP_MINQUERY:- case OP_UPTO:- case OP_MINUPTO:- case OP_EXACT:- case OP_POSSTAR:- case OP_POSPLUS:- case OP_POSQUERY:- case OP_POSUPTO:- case OP_STARI:- case OP_MINSTARI:- case OP_PLUSI:- case OP_MINPLUSI:- case OP_QUERYI:- case OP_MINQUERYI:- case OP_UPTOI:- case OP_MINUPTOI:- case OP_EXACTI:- case OP_POSSTARI:- case OP_POSPLUSI:- case OP_POSQUERYI:- case OP_POSUPTOI:- case OP_NOTSTAR:- case OP_NOTMINSTAR:- case OP_NOTPLUS:- case OP_NOTMINPLUS:- case OP_NOTQUERY:- case OP_NOTMINQUERY:- case OP_NOTUPTO:- case OP_NOTMINUPTO:- case OP_NOTEXACT:- case OP_NOTPOSSTAR:- case OP_NOTPOSPLUS:- case OP_NOTPOSQUERY:- case OP_NOTPOSUPTO:- case OP_NOTSTARI:- case OP_NOTMINSTARI:- case OP_NOTPLUSI:- case OP_NOTMINPLUSI:- case OP_NOTQUERYI:- case OP_NOTMINQUERYI:- case OP_NOTUPTOI:- case OP_NOTMINUPTOI:- case OP_NOTEXACTI:- case OP_NOTPOSSTARI:- case OP_NOTPOSPLUSI:- case OP_NOTPOSQUERYI:- case OP_NOTPOSUPTOI:- case OP_TYPESTAR:- case OP_TYPEMINSTAR:- case OP_TYPEPLUS:- case OP_TYPEMINPLUS:- case OP_TYPEQUERY:- case OP_TYPEMINQUERY:- case OP_TYPEUPTO:- case OP_TYPEMINUPTO:- case OP_TYPEEXACT:- case OP_TYPEPOSSTAR:- case OP_TYPEPOSPLUS:- case OP_TYPEPOSQUERY:- case OP_TYPEPOSUPTO:- cc = compile_iterator_matchingpath(common, cc, parent);- break;-- case OP_CLASS:- case OP_NCLASS:- if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRPOSRANGE)- cc = compile_iterator_matchingpath(common, cc, parent);- else- cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);- break;--#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32- case OP_XCLASS:- if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRPOSRANGE)- cc = compile_iterator_matchingpath(common, cc, parent);- else- cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);- break;-#endif-- case OP_REF:- case OP_REFI:- if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRPOSRANGE)- cc = compile_ref_iterator_matchingpath(common, cc, parent);- else- {- compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);- cc += 1 + IMM2_SIZE;- }- break;-- case OP_DNREF:- case OP_DNREFI:- if (cc[1 + 2 * IMM2_SIZE] >= OP_CRSTAR && cc[1 + 2 * IMM2_SIZE] <= OP_CRPOSRANGE)- cc = compile_ref_iterator_matchingpath(common, cc, parent);- else- {- compile_dnref_search(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);- compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);- cc += 1 + 2 * IMM2_SIZE;- }- break;-- case OP_RECURSE:- cc = compile_recurse_matchingpath(common, cc, parent);- break;-- case OP_CALLOUT:- cc = compile_callout_matchingpath(common, cc, parent);- break;-- case OP_ASSERT:- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);- cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);- break;-- case OP_BRAMINZERO:- PUSH_BACKTRACK_NOVALUE(sizeof(braminzero_backtrack), cc);- cc = bracketend(cc + 1);- if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)- {- allocate_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);- }- else- {- allocate_stack(common, 2);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), STR_PTR, 0);- }- BACKTRACK_AS(braminzero_backtrack)->matchingpath = LABEL();- if (cc[1] > OP_ASSERTBACK_NOT)- count_match(common);- break;-- case OP_ONCE:- case OP_ONCE_NC:- case OP_BRA:- case OP_CBRA:- case OP_COND:- case OP_SBRA:- case OP_SCBRA:- case OP_SCOND:- cc = compile_bracket_matchingpath(common, cc, parent);- break;-- case OP_BRAZERO:- if (cc[1] > OP_ASSERTBACK_NOT)- cc = compile_bracket_matchingpath(common, cc, parent);- else- {- PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);- cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);- }- break;-- case OP_BRAPOS:- case OP_CBRAPOS:- case OP_SBRAPOS:- case OP_SCBRAPOS:- case OP_BRAPOSZERO:- cc = compile_bracketpos_matchingpath(common, cc, parent);- break;-- case OP_MARK:- PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);- SLJIT_ASSERT(common->mark_ptr != 0);- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr);- allocate_stack(common, common->has_skip_arg ? 5 : 1);- OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0), TMP2, 0);- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP2, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);- if (common->has_skip_arg)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, STACK_TOP, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, type_mark);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), SLJIT_IMM, (sljit_sw)(cc + 2));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(3), STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);- }- cc += 1 + 2 + cc[1];- break;-- case OP_PRUNE:- case OP_PRUNE_ARG:- case OP_SKIP:- case OP_SKIP_ARG:- case OP_THEN:- case OP_THEN_ARG:- case OP_COMMIT:- cc = compile_control_verb_matchingpath(common, cc, parent);- break;-- case OP_FAIL:- case OP_ACCEPT:- case OP_ASSERT_ACCEPT:- cc = compile_fail_accept_matchingpath(common, cc, parent);- break;-- case OP_CLOSE:- cc = compile_close_matchingpath(common, cc);- break;-- case OP_SKIPZERO:- cc = bracketend(cc + 1);- break;-- default:- SLJIT_ASSERT_STOP();- return;- }- if (cc == NULL)- return;- }--if (has_then_trap)- {- /* Head item on backtrack. */- PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);- BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;- BACKTRACK_AS(then_trap_backtrack)->then_trap = common->then_trap;- common->then_trap = save_then_trap;- }-SLJIT_ASSERT(cc == ccend);-}--#undef PUSH_BACKTRACK-#undef PUSH_BACKTRACK_NOVALUE-#undef BACKTRACK_AS--#define COMPILE_BACKTRACKINGPATH(current) \- do \- { \- compile_backtrackingpath(common, (current)); \- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \- return; \- } \- while (0)--#define CURRENT_AS(type) ((type *)current)--static void compile_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;-pcre_uchar *cc = current->cc;-pcre_uchar opcode;-pcre_uchar type;-int max = -1, min = -1;-struct sljit_label *label = NULL;-struct sljit_jump *jump = NULL;-jump_list *jumplist = NULL;-int private_data_ptr = PRIVATE_DATA(cc);-int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_LOCALS_REG);-int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;-int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);--cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &min, NULL);--switch(opcode)- {- case OP_STAR:- case OP_PLUS:- case OP_UPTO:- case OP_CRRANGE:- if (type == OP_ANYNL || type == OP_EXTUNI)- {- SLJIT_ASSERT(private_data_ptr == 0);- set_jumps(current->topbacktracks, LABEL());- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);- }- else- {- if (opcode == OP_UPTO)- min = 0;- if (opcode <= OP_PLUS)- {- OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);- jump = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, base, offset1);- }- else- {- OP1(SLJIT_MOV, TMP1, 0, base, offset1);- OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);- jump = CMP(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, min + 1);- OP2(SLJIT_SUB, base, offset1, TMP1, 0, SLJIT_IMM, 1);- }- skip_char_back(common);- OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);- JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);- if (opcode == OP_CRRANGE)- set_jumps(current->topbacktracks, LABEL());- JUMPHERE(jump);- if (private_data_ptr == 0)- free_stack(common, 2);- if (opcode == OP_PLUS)- set_jumps(current->topbacktracks, LABEL());- }- break;-- case OP_MINSTAR:- case OP_MINPLUS:- OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);- compile_char1_matchingpath(common, type, cc, &jumplist);- OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);- JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);- set_jumps(jumplist, LABEL());- if (private_data_ptr == 0)- free_stack(common, 1);- if (opcode == OP_MINPLUS)- set_jumps(current->topbacktracks, LABEL());- break;-- case OP_MINUPTO:- case OP_CRMINRANGE:- if (opcode == OP_CRMINRANGE)- {- label = LABEL();- set_jumps(current->topbacktracks, label);- }- OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);- compile_char1_matchingpath(common, type, cc, &jumplist);-- OP1(SLJIT_MOV, TMP1, 0, base, offset1);- OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);- OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);- OP1(SLJIT_MOV, base, offset1, TMP1, 0);-- if (opcode == OP_CRMINRANGE)- CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, min + 1, label);-- if (opcode == OP_CRMINRANGE && max == 0)- JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);- else- CMPTO(SLJIT_C_LESS, TMP1, 0, SLJIT_IMM, max + 2, CURRENT_AS(iterator_backtrack)->matchingpath);-- set_jumps(jumplist, LABEL());- if (private_data_ptr == 0)- free_stack(common, 2);- break;-- case OP_QUERY:- OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);- OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);- jump = JUMP(SLJIT_JUMP);- set_jumps(current->topbacktracks, LABEL());- OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);- OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);- JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);- JUMPHERE(jump);- if (private_data_ptr == 0)- free_stack(common, 1);- break;-- case OP_MINQUERY:- OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);- OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);- jump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);- compile_char1_matchingpath(common, type, cc, &jumplist);- JUMPTO(SLJIT_JUMP, CURRENT_AS(iterator_backtrack)->matchingpath);- set_jumps(jumplist, LABEL());- JUMPHERE(jump);- if (private_data_ptr == 0)- free_stack(common, 1);- break;-- case OP_EXACT:- case OP_POSPLUS:- case OP_CRPOSRANGE:- set_jumps(current->topbacktracks, LABEL());- break;-- case OP_POSSTAR:- case OP_POSQUERY:- case OP_POSUPTO:- break;-- default:- SLJIT_ASSERT_STOP();- break;- }-}--static SLJIT_INLINE void compile_ref_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;-pcre_uchar *cc = current->cc;-BOOL ref = (*cc == OP_REF || *cc == OP_REFI);-pcre_uchar type;--type = cc[ref ? 1 + IMM2_SIZE : 1 + 2 * IMM2_SIZE];--if ((type & 0x1) == 0)- {- /* Maximize case. */- set_jumps(current->topbacktracks, LABEL());- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);- return;- }--OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));-CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(iterator_backtrack)->matchingpath);-set_jumps(current->topbacktracks, LABEL());-free_stack(common, ref ? 2 : 3);-}--static SLJIT_INLINE void compile_recurse_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;--if (CURRENT_AS(recurse_backtrack)->inlined_pattern)- compile_backtrackingpath(common, current->top);-set_jumps(current->topbacktracks, LABEL());-if (CURRENT_AS(recurse_backtrack)->inlined_pattern)- return;--if (common->has_set_som && common->mark_ptr != 0)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- free_stack(common, 2);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP2, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP1, 0);- }-else if (common->has_set_som || common->mark_ptr != 0)- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr, TMP2, 0);- }-}--static void compile_assert_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;-pcre_uchar *cc = current->cc;-pcre_uchar bra = OP_BRA;-struct sljit_jump *brajump = NULL;--SLJIT_ASSERT(*cc != OP_BRAMINZERO);-if (*cc == OP_BRAZERO)- {- bra = *cc;- cc++;- }--if (bra == OP_BRAZERO)- {- SLJIT_ASSERT(current->topbacktracks == NULL);- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- }--if (CURRENT_AS(assert_backtrack)->framesize < 0)- {- set_jumps(current->topbacktracks, LABEL());-- if (bra == OP_BRAZERO)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->matchingpath);- free_stack(common, 1);- }- return;- }--if (bra == OP_BRAZERO)- {- if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)- {- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->matchingpath);- free_stack(common, 1);- return;- }- free_stack(common, 1);- brajump = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);- }--if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)- {- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_backtrack)->private_data_ptr);- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(assert_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(assert_backtrack)->framesize * sizeof(sljit_sw));-- set_jumps(current->topbacktracks, LABEL());- }-else- set_jumps(current->topbacktracks, LABEL());--if (bra == OP_BRAZERO)- {- /* We know there is enough place on the stack. */- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);- JUMPTO(SLJIT_JUMP, CURRENT_AS(assert_backtrack)->matchingpath);- JUMPHERE(brajump);- }-}--static void compile_bracket_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;-int opcode, stacksize, count;-int offset = 0;-int private_data_ptr = CURRENT_AS(bracket_backtrack)->private_data_ptr;-int repeat_ptr = 0, repeat_type = 0, repeat_count = 0;-pcre_uchar *cc = current->cc;-pcre_uchar *ccbegin;-pcre_uchar *ccprev;-jump_list *jumplist = NULL;-jump_list *jumplistitem = NULL;-pcre_uchar bra = OP_BRA;-pcre_uchar ket;-assert_backtrack *assert;-BOOL has_alternatives;-BOOL needs_control_head = FALSE;-struct sljit_jump *brazero = NULL;-struct sljit_jump *once = NULL;-struct sljit_jump *cond = NULL;-struct sljit_label *rmin_label = NULL;-struct sljit_label *exact_label = NULL;--if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)- {- bra = *cc;- cc++;- }--opcode = *cc;-ccbegin = bracketend(cc) - 1 - LINK_SIZE;-ket = *ccbegin;-if (ket == OP_KET && PRIVATE_DATA(ccbegin) != 0)- {- repeat_ptr = PRIVATE_DATA(ccbegin);- repeat_type = PRIVATE_DATA(ccbegin + 2);- repeat_count = PRIVATE_DATA(ccbegin + 3);- SLJIT_ASSERT(repeat_type != 0 && repeat_count != 0);- if (repeat_type == OP_UPTO)- ket = OP_KETRMAX;- if (repeat_type == OP_MINUPTO)- ket = OP_KETRMIN;- }-ccbegin = cc;-cc += GET(cc, 1);-has_alternatives = *cc == OP_ALT;-if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))- has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_backtrack)->u.condfailed != NULL;-if (opcode == OP_CBRA || opcode == OP_SCBRA)- offset = (GET2(ccbegin, 1 + LINK_SIZE)) << 1;-if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))- opcode = OP_SCOND;-if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))- opcode = OP_ONCE;--/* Decoding the needs_control_head in framesize. */-if (opcode == OP_ONCE)- {- needs_control_head = (CURRENT_AS(bracket_backtrack)->u.framesize & 0x1) != 0;- CURRENT_AS(bracket_backtrack)->u.framesize >>= 1;- }--if (ket != OP_KET && repeat_type != 0)- {- /* TMP1 is used in OP_KETRMIN below. */- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- if (repeat_type == OP_UPTO)- OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0, SLJIT_IMM, 1);- else- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0);- }--if (ket == OP_KETRMAX)- {- if (bra == OP_BRAZERO)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- brazero = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 0);- }- }-else if (ket == OP_KETRMIN)- {- if (bra != OP_BRAMINZERO)- {- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- if (repeat_type != 0)- {- /* TMP1 was set a few lines above. */- CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);- /* Drop STR_PTR for non-greedy plus quantifier. */- if (opcode != OP_ONCE)- free_stack(common, 1);- }- else if (opcode >= OP_SBRA || opcode == OP_ONCE)- {- /* Checking zero-length iteration. */- if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);- else- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), (CURRENT_AS(bracket_backtrack)->u.framesize + 1) * sizeof(sljit_sw), CURRENT_AS(bracket_backtrack)->recursive_matchingpath);- }- /* Drop STR_PTR for non-greedy plus quantifier. */- if (opcode != OP_ONCE)- free_stack(common, 1);- }- else- JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);- }- rmin_label = LABEL();- if (repeat_type != 0)- OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);- }-else if (bra == OP_BRAZERO)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- brazero = CMP(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);- }-else if (repeat_type == OP_EXACT)- {- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);- exact_label = LABEL();- }--if (offset != 0)- {- if (common->capture_last_ptr != 0)- {- SLJIT_ASSERT(common->optimized_cbracket[offset >> 1] == 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));- free_stack(common, 3);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP2, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP1, 0);- }- else if (common->optimized_cbracket[offset >> 1] == 0)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- free_stack(common, 2);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);- }- }--if (SLJIT_UNLIKELY(opcode == OP_ONCE))- {- if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)- {- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- }- once = JUMP(SLJIT_JUMP);- }-else if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))- {- if (has_alternatives)- {- /* Always exactly one alternative. */- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);-- jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));- if (SLJIT_UNLIKELY(!jumplistitem))- return;- jumplist = jumplistitem;- jumplistitem->next = NULL;- jumplistitem->jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, 1);- }- }-else if (*cc == OP_ALT)- {- /* Build a jump list. Get the last successfully matched branch index. */- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- count = 1;- do- {- /* Append as the last item. */- if (jumplist != NULL)- {- jumplistitem->next = sljit_alloc_memory(compiler, sizeof(jump_list));- jumplistitem = jumplistitem->next;- }- else- {- jumplistitem = sljit_alloc_memory(compiler, sizeof(jump_list));- jumplist = jumplistitem;- }-- if (SLJIT_UNLIKELY(!jumplistitem))- return;-- jumplistitem->next = NULL;- jumplistitem->jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, count++);- cc += GET(cc, 1);- }- while (*cc == OP_ALT);-- cc = ccbegin + GET(ccbegin, 1);- }--COMPILE_BACKTRACKINGPATH(current->top);-if (current->topbacktracks)- set_jumps(current->topbacktracks, LABEL());--if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))- {- /* Conditional block always has at most one alternative. */- if (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT)- {- SLJIT_ASSERT(has_alternatives);- assert = CURRENT_AS(bracket_backtrack)->u.assert;- if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK))- {- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->private_data_ptr);- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->private_data_ptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_sw));- }- cond = JUMP(SLJIT_JUMP);- set_jumps(CURRENT_AS(bracket_backtrack)->u.assert->condfailed, LABEL());- }- else if (CURRENT_AS(bracket_backtrack)->u.condfailed != NULL)- {- SLJIT_ASSERT(has_alternatives);- cond = JUMP(SLJIT_JUMP);- set_jumps(CURRENT_AS(bracket_backtrack)->u.condfailed, LABEL());- }- else- SLJIT_ASSERT(!has_alternatives);- }--if (has_alternatives)- {- count = 1;- do- {- current->top = NULL;- current->topbacktracks = NULL;- current->nextbacktracks = NULL;- /* Conditional blocks always have an additional alternative, even if it is empty. */- if (*cc == OP_ALT)- {- ccprev = cc + 1 + LINK_SIZE;- cc += GET(cc, 1);- if (opcode != OP_COND && opcode != OP_SCOND)- {- if (opcode != OP_ONCE)- {- if (private_data_ptr != 0)- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr);- else- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- }- else- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(needs_control_head ? 1 : 0));- }- compile_matchingpath(common, ccprev, cc, current);- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- return;- }-- /* Instructions after the current alternative is successfully matched. */- /* There is a similar code in compile_bracket_matchingpath. */- if (opcode == OP_ONCE)- match_once_common(common, ket, CURRENT_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);-- stacksize = 0;- if (repeat_type == OP_MINUPTO)- {- /* We need to preserve the counter. TMP2 will be used below. */- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr);- stacksize++;- }- if (ket != OP_KET || bra != OP_BRA)- stacksize++;- if (offset != 0)- {- if (common->capture_last_ptr != 0)- stacksize++;- if (common->optimized_cbracket[offset >> 1] == 0)- stacksize += 2;- }- if (opcode != OP_ONCE)- stacksize++;-- if (stacksize > 0)- allocate_stack(common, stacksize);-- stacksize = 0;- if (repeat_type == OP_MINUPTO)- {- /* TMP2 was set above. */- OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);- stacksize++;- }-- if (ket != OP_KET || bra != OP_BRA)- {- if (ket != OP_KET)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);- else- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);- stacksize++;- }-- if (offset != 0)- stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);-- if (opcode != OP_ONCE)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, count++);-- if (offset != 0 && ket == OP_KETRMAX && common->optimized_cbracket[offset >> 1] != 0)- {- /* If ket is not OP_KETRMAX, this code path is executed after the jump to alternative_matchingpath. */- SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), STR_PTR, 0);- }-- JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->alternative_matchingpath);-- if (opcode != OP_ONCE)- {- SLJIT_ASSERT(jumplist);- JUMPHERE(jumplist->jump);- jumplist = jumplist->next;- }-- COMPILE_BACKTRACKINGPATH(current->top);- if (current->topbacktracks)- set_jumps(current->topbacktracks, LABEL());- SLJIT_ASSERT(!current->nextbacktracks);- }- while (*cc == OP_ALT);- SLJIT_ASSERT(!jumplist);-- if (cond != NULL)- {- SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);- assert = CURRENT_AS(bracket_backtrack)->u.assert;- if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)- {- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->private_data_ptr);- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), assert->private_data_ptr, SLJIT_MEM1(STACK_TOP), assert->framesize * sizeof(sljit_sw));- }- JUMPHERE(cond);- }-- /* Free the STR_PTR. */- if (private_data_ptr == 0)- free_stack(common, 1);- }--if (offset != 0)- {- /* Using both tmp register is better for instruction scheduling. */- if (common->optimized_cbracket[offset >> 1] != 0)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- free_stack(common, 2);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);- }- else- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);- }- }-else if (opcode == OP_SBRA || opcode == OP_SCOND)- {- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- }-else if (opcode == OP_ONCE)- {- cc = ccbegin + GET(ccbegin, 1);- stacksize = needs_control_head ? 1 : 0;-- if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)- {- /* Reset head and drop saved frame. */- stacksize += CURRENT_AS(bracket_backtrack)->u.framesize + ((ket != OP_KET || *cc == OP_ALT) ? 2 : 1);- }- else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))- {- /* The STR_PTR must be released. */- stacksize++;- }- free_stack(common, stacksize);-- JUMPHERE(once);- /* Restore previous private_data_ptr */- if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracket_backtrack)->u.framesize * sizeof(sljit_sw));- else if (ket == OP_KETRMIN)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- /* See the comment below. */- free_stack(common, 2);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), private_data_ptr, TMP1, 0);- }- }--if (repeat_type == OP_EXACT)- {- OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, SLJIT_IMM, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), repeat_ptr, TMP1, 0);- CMPTO(SLJIT_C_LESS_EQUAL, TMP1, 0, SLJIT_IMM, repeat_count, exact_label);- }-else if (ket == OP_KETRMAX)- {- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- if (bra != OP_BRAZERO)- free_stack(common, 1);-- CMPTO(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);- if (bra == OP_BRAZERO)- {- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zero_matchingpath);- JUMPHERE(brazero);- free_stack(common, 1);- }- }-else if (ket == OP_KETRMIN)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));-- /* OP_ONCE removes everything in case of a backtrack, so we don't- need to explicitly release the STR_PTR. The extra release would- affect badly the free_stack(2) above. */- if (opcode != OP_ONCE)- free_stack(common, 1);- CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rmin_label);- if (opcode == OP_ONCE)- free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);- else if (bra == OP_BRAMINZERO)- free_stack(common, 1);- }-else if (bra == OP_BRAZERO)- {- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zero_matchingpath);- JUMPHERE(brazero);- }-}--static SLJIT_INLINE void compile_bracketpos_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;-int offset;-struct sljit_jump *jump;--if (CURRENT_AS(bracketpos_backtrack)->framesize < 0)- {- if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)- {- offset = (GET2(current->cc, 1 + LINK_SIZE)) << 1;- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset), TMP1, 0);- if (common->capture_last_ptr != 0)- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(offset + 1), TMP2, 0);- if (common->capture_last_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, TMP1, 0);- }- set_jumps(current->topbacktracks, LABEL());- free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);- return;- }--OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_backtrack)->private_data_ptr);-add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));--if (current->topbacktracks)- {- jump = JUMP(SLJIT_JUMP);- set_jumps(current->topbacktracks, LABEL());- /* Drop the stack frame. */- free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);- JUMPHERE(jump);- }-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), CURRENT_AS(bracketpos_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), CURRENT_AS(bracketpos_backtrack)->framesize * sizeof(sljit_sw));-}--static SLJIT_INLINE void compile_braminzero_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-assert_backtrack backtrack;--current->top = NULL;-current->topbacktracks = NULL;-current->nextbacktracks = NULL;-if (current->cc[1] > OP_ASSERTBACK_NOT)- {- /* Manual call of compile_bracket_matchingpath and compile_bracket_backtrackingpath. */- compile_bracket_matchingpath(common, current->cc, current);- compile_bracket_backtrackingpath(common, current->top);- }-else- {- memset(&backtrack, 0, sizeof(backtrack));- backtrack.common.cc = current->cc;- backtrack.matchingpath = CURRENT_AS(braminzero_backtrack)->matchingpath;- /* Manual call of compile_assert_matchingpath. */- compile_assert_matchingpath(common, current->cc, &backtrack, FALSE);- }-SLJIT_ASSERT(!current->nextbacktracks && !current->topbacktracks);-}--static SLJIT_INLINE void compile_control_verb_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;-pcre_uchar opcode = *current->cc;-struct sljit_label *loop;-struct sljit_jump *jump;--if (opcode == OP_THEN || opcode == OP_THEN_ARG)- {- if (common->then_trap != NULL)- {- SLJIT_ASSERT(common->control_head_ptr != 0);-- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, type_then_trap);- OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, common->then_trap->start);- jump = JUMP(SLJIT_JUMP);-- loop = LABEL();- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), -(int)sizeof(sljit_sw));- JUMPHERE(jump);- CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), -(int)(2 * sizeof(sljit_sw)), TMP1, 0, loop);- CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), -(int)(3 * sizeof(sljit_sw)), TMP2, 0, loop);- add_jump(compiler, &common->then_trap->quit, JUMP(SLJIT_JUMP));- return;- }- else if (common->positive_assert)- {- add_jump(compiler, &common->positive_assert_quit, JUMP(SLJIT_JUMP));- return;- }- }--if (common->local_exit)- {- if (common->quit_label == NULL)- add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));- else- JUMPTO(SLJIT_JUMP, common->quit_label);- return;- }--if (opcode == OP_SKIP_ARG)- {- SLJIT_ASSERT(common->control_head_ptr != 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0, STACK_TOP, 0);- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, (sljit_sw)(current->cc + 2));- sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(do_search_mark));- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);-- OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);- add_jump(compiler, &common->reset_match, CMP(SLJIT_C_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, -1));- return;- }--if (opcode == OP_SKIP)- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));-else- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_IMM, 0);-add_jump(compiler, &common->reset_match, JUMP(SLJIT_JUMP));-}--static SLJIT_INLINE void compile_then_trap_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;-struct sljit_jump *jump;-int size;--if (CURRENT_AS(then_trap_backtrack)->then_trap)- {- common->then_trap = CURRENT_AS(then_trap_backtrack)->then_trap;- return;- }--size = CURRENT_AS(then_trap_backtrack)->framesize;-size = 3 + (size < 0 ? 0 : size);--OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(size - 3));-free_stack(common, size);-jump = JUMP(SLJIT_JUMP);--set_jumps(CURRENT_AS(then_trap_backtrack)->quit, LABEL());-/* STACK_TOP is set by THEN. */-if (CURRENT_AS(then_trap_backtrack)->framesize >= 0)- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));-OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));-free_stack(common, 3);--JUMPHERE(jump);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP1, 0);-}--static void compile_backtrackingpath(compiler_common *common, struct backtrack_common *current)-{-DEFINE_COMPILER;-then_trap_backtrack *save_then_trap = common->then_trap;--while (current)- {- if (current->nextbacktracks != NULL)- set_jumps(current->nextbacktracks, LABEL());- switch(*current->cc)- {- case OP_SET_SOM:- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), TMP1, 0);- break;-- case OP_STAR:- case OP_MINSTAR:- case OP_PLUS:- case OP_MINPLUS:- case OP_QUERY:- case OP_MINQUERY:- case OP_UPTO:- case OP_MINUPTO:- case OP_EXACT:- case OP_POSSTAR:- case OP_POSPLUS:- case OP_POSQUERY:- case OP_POSUPTO:- case OP_STARI:- case OP_MINSTARI:- case OP_PLUSI:- case OP_MINPLUSI:- case OP_QUERYI:- case OP_MINQUERYI:- case OP_UPTOI:- case OP_MINUPTOI:- case OP_EXACTI:- case OP_POSSTARI:- case OP_POSPLUSI:- case OP_POSQUERYI:- case OP_POSUPTOI:- case OP_NOTSTAR:- case OP_NOTMINSTAR:- case OP_NOTPLUS:- case OP_NOTMINPLUS:- case OP_NOTQUERY:- case OP_NOTMINQUERY:- case OP_NOTUPTO:- case OP_NOTMINUPTO:- case OP_NOTEXACT:- case OP_NOTPOSSTAR:- case OP_NOTPOSPLUS:- case OP_NOTPOSQUERY:- case OP_NOTPOSUPTO:- case OP_NOTSTARI:- case OP_NOTMINSTARI:- case OP_NOTPLUSI:- case OP_NOTMINPLUSI:- case OP_NOTQUERYI:- case OP_NOTMINQUERYI:- case OP_NOTUPTOI:- case OP_NOTMINUPTOI:- case OP_NOTEXACTI:- case OP_NOTPOSSTARI:- case OP_NOTPOSPLUSI:- case OP_NOTPOSQUERYI:- case OP_NOTPOSUPTOI:- case OP_TYPESTAR:- case OP_TYPEMINSTAR:- case OP_TYPEPLUS:- case OP_TYPEMINPLUS:- case OP_TYPEQUERY:- case OP_TYPEMINQUERY:- case OP_TYPEUPTO:- case OP_TYPEMINUPTO:- case OP_TYPEEXACT:- case OP_TYPEPOSSTAR:- case OP_TYPEPOSPLUS:- case OP_TYPEPOSQUERY:- case OP_TYPEPOSUPTO:- case OP_CLASS:- case OP_NCLASS:-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:-#endif- compile_iterator_backtrackingpath(common, current);- break;-- case OP_REF:- case OP_REFI:- case OP_DNREF:- case OP_DNREFI:- compile_ref_iterator_backtrackingpath(common, current);- break;-- case OP_RECURSE:- compile_recurse_backtrackingpath(common, current);- break;-- case OP_ASSERT:- case OP_ASSERT_NOT:- case OP_ASSERTBACK:- case OP_ASSERTBACK_NOT:- compile_assert_backtrackingpath(common, current);- break;-- case OP_ONCE:- case OP_ONCE_NC:- case OP_BRA:- case OP_CBRA:- case OP_COND:- case OP_SBRA:- case OP_SCBRA:- case OP_SCOND:- compile_bracket_backtrackingpath(common, current);- break;-- case OP_BRAZERO:- if (current->cc[1] > OP_ASSERTBACK_NOT)- compile_bracket_backtrackingpath(common, current);- else- compile_assert_backtrackingpath(common, current);- break;-- case OP_BRAPOS:- case OP_CBRAPOS:- case OP_SBRAPOS:- case OP_SCBRAPOS:- case OP_BRAPOSZERO:- compile_bracketpos_backtrackingpath(common, current);- break;-- case OP_BRAMINZERO:- compile_braminzero_backtrackingpath(common, current);- break;-- case OP_MARK:- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0));- if (common->has_skip_arg)- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));- free_stack(common, common->has_skip_arg ? 5 : 1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, TMP1, 0);- if (common->has_skip_arg)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP2, 0);- break;-- case OP_THEN:- case OP_THEN_ARG:- case OP_PRUNE:- case OP_PRUNE_ARG:- case OP_SKIP:- case OP_SKIP_ARG:- compile_control_verb_backtrackingpath(common, current);- break;-- case OP_COMMIT:- if (!common->local_exit)- OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);- if (common->quit_label == NULL)- add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));- else- JUMPTO(SLJIT_JUMP, common->quit_label);- break;-- case OP_CALLOUT:- case OP_FAIL:- case OP_ACCEPT:- case OP_ASSERT_ACCEPT:- set_jumps(current->topbacktracks, LABEL());- break;-- case OP_THEN_TRAP:- /* A virtual opcode for then traps. */- compile_then_trap_backtrackingpath(common, current);- break;-- default:- SLJIT_ASSERT_STOP();- break;- }- current = current->prev;- }-common->then_trap = save_then_trap;-}--static SLJIT_INLINE void compile_recurse(compiler_common *common)-{-DEFINE_COMPILER;-pcre_uchar *cc = common->start + common->currententry->start;-pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);-pcre_uchar *ccend = bracketend(cc);-BOOL needs_control_head;-int framesize = get_framesize(common, cc, NULL, TRUE, &needs_control_head);-int private_data_size = get_private_data_copy_length(common, ccbegin, ccend, needs_control_head);-int alternativesize;-BOOL needs_frame;-backtrack_common altbacktrack;-struct sljit_jump *jump;--/* Recurse captures then. */-common->then_trap = NULL;--SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);-needs_frame = framesize >= 0;-if (!needs_frame)- framesize = 0;-alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;--SLJIT_ASSERT(common->currententry->entry == NULL && common->recursive_head_ptr != 0);-common->currententry->entry = LABEL();-set_jumps(common->currententry->calls, common->currententry->entry);--sljit_emit_fast_enter(compiler, TMP2, 0);-allocate_stack(common, private_data_size + framesize + alternativesize);-OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(private_data_size + framesize + alternativesize - 1), TMP2, 0);-copy_private_data(common, ccbegin, ccend, TRUE, private_data_size + framesize + alternativesize, framesize + alternativesize, needs_control_head);-if (needs_control_head)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr, STACK_TOP, 0);-if (needs_frame)- init_frame(common, cc, NULL, framesize + alternativesize - 1, alternativesize, TRUE);--if (alternativesize > 0)- OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);--memset(&altbacktrack, 0, sizeof(backtrack_common));-common->quit_label = NULL;-common->accept_label = NULL;-common->quit = NULL;-common->accept = NULL;-altbacktrack.cc = ccbegin;-cc += GET(cc, 1);-while (1)- {- altbacktrack.top = NULL;- altbacktrack.topbacktracks = NULL;-- if (altbacktrack.cc != ccbegin)- OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));-- compile_matchingpath(common, altbacktrack.cc, cc, &altbacktrack);- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- return;-- add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));-- compile_backtrackingpath(common, altbacktrack.top);- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- return;- set_jumps(altbacktrack.topbacktracks, LABEL());-- if (*cc != OP_ALT)- break;-- altbacktrack.cc = cc + 1 + LINK_SIZE;- cc += GET(cc, 1);- }--/* None of them matched. */-OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);-jump = JUMP(SLJIT_JUMP);--if (common->quit != NULL)- {- set_jumps(common->quit, LABEL());- OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr);- if (needs_frame)- {- OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));- }- OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);- common->quit = NULL;- add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));- }--set_jumps(common->accept, LABEL());-OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr);-if (needs_frame)- {- OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));- add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));- OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));- }-OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);--JUMPHERE(jump);-if (common->quit != NULL)- set_jumps(common->quit, LABEL());-copy_private_data(common, ccbegin, ccend, FALSE, private_data_size + framesize + alternativesize, framesize + alternativesize, needs_control_head);-free_stack(common, private_data_size + framesize + alternativesize);-if (needs_control_head)- {- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), 2 * sizeof(sljit_sw));- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_sw));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr, TMP1, 0);- OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, TMP2, 0);- }-else- {- OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), sizeof(sljit_sw));- OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->recursive_head_ptr, TMP2, 0);- }-sljit_emit_fast_return(compiler, SLJIT_MEM1(STACK_TOP), 0);-}--#undef COMPILE_BACKTRACKINGPATH-#undef CURRENT_AS--void-PRIV(jit_compile)(const REAL_PCRE *re, PUBL(extra) *extra, int mode)-{-struct sljit_compiler *compiler;-backtrack_common rootbacktrack;-compiler_common common_data;-compiler_common *common = &common_data;-const pcre_uint8 *tables = re->tables;-pcre_study_data *study;-int private_data_size;-pcre_uchar *ccend;-executable_functions *functions;-void *executable_func;-sljit_uw executable_size;-struct sljit_label *mainloop_label = NULL;-struct sljit_label *continue_match_label;-struct sljit_label *empty_match_found_label;-struct sljit_label *empty_match_backtrack_label;-struct sljit_label *reset_match_label;-struct sljit_jump *jump;-struct sljit_jump *minlength_check_failed = NULL;-struct sljit_jump *reqbyte_notfound = NULL;-struct sljit_jump *empty_match;-struct sljit_label *quit_label;--SLJIT_ASSERT((extra->flags & PCRE_EXTRA_STUDY_DATA) != 0);-study = extra->study_data;--if (!tables)- tables = PRIV(default_tables);--memset(&rootbacktrack, 0, sizeof(backtrack_common));-memset(common, 0, sizeof(compiler_common));-rootbacktrack.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;--common->start = rootbacktrack.cc;-common->fcc = tables + fcc_offset;-common->lcc = (sljit_sw)(tables + lcc_offset);-common->mode = mode;-common->nltype = NLTYPE_FIXED;-switch(re->options & PCRE_NEWLINE_BITS)- {- case 0:- /* Compile-time default */- switch(NEWLINE)- {- case -1: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;- case -2: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;- default: common->newline = NEWLINE; break;- }- break;- case PCRE_NEWLINE_CR: common->newline = CHAR_CR; break;- case PCRE_NEWLINE_LF: common->newline = CHAR_NL; break;- case PCRE_NEWLINE_CR+- PCRE_NEWLINE_LF: common->newline = (CHAR_CR << 8) | CHAR_NL; break;- case PCRE_NEWLINE_ANY: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;- case PCRE_NEWLINE_ANYCRLF: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;- default: return;- }-if ((re->options & PCRE_BSR_ANYCRLF) != 0)- common->bsr_nltype = NLTYPE_ANYCRLF;-else if ((re->options & PCRE_BSR_UNICODE) != 0)- common->bsr_nltype = NLTYPE_ANY;-else- {-#ifdef BSR_ANYCRLF- common->bsr_nltype = NLTYPE_ANYCRLF;-#else- common->bsr_nltype = NLTYPE_ANY;-#endif- }-common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;-common->ctypes = (sljit_sw)(tables + ctypes_offset);-common->digits[0] = -2;-common->name_table = ((pcre_uchar *)re) + re->name_table_offset;-common->name_count = re->name_count;-common->name_entry_size = re->name_entry_size;-common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;-#ifdef SUPPORT_UTF-/* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */-common->utf = (re->options & PCRE_UTF8) != 0;-#ifdef SUPPORT_UCP-common->use_ucp = (re->options & PCRE_UCP) != 0;-#endif-#endif /* SUPPORT_UTF */-ccend = bracketend(rootbacktrack.cc);--/* Calculate the local space size on the stack. */-common->ovector_start = LIMIT_MATCH + sizeof(sljit_sw);-common->optimized_cbracket = (pcre_uint8 *)SLJIT_MALLOC(re->top_bracket + 1);-if (!common->optimized_cbracket)- return;-#if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 1-memset(common->optimized_cbracket, 0, re->top_bracket + 1);-#else-memset(common->optimized_cbracket, 1, re->top_bracket + 1);-#endif--SLJIT_ASSERT(*rootbacktrack.cc == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);-#if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 2-common->capture_last_ptr = common->ovector_start;-common->ovector_start += sizeof(sljit_sw);-#endif-if (!check_opcode_types(common, rootbacktrack.cc, ccend))- {- SLJIT_FREE(common->optimized_cbracket);- return;- }--/* Checking flags and updating ovector_start. */-if (mode == JIT_COMPILE && (re->flags & PCRE_REQCHSET) != 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)- {- common->req_char_ptr = common->ovector_start;- common->ovector_start += sizeof(sljit_sw);- }-if (mode != JIT_COMPILE)- {- common->start_used_ptr = common->ovector_start;- common->ovector_start += sizeof(sljit_sw);- if (mode == JIT_PARTIAL_SOFT_COMPILE)- {- common->hit_start = common->ovector_start;- common->ovector_start += 2 * sizeof(sljit_sw);- }- else- {- SLJIT_ASSERT(mode == JIT_PARTIAL_HARD_COMPILE);- common->needs_start_ptr = TRUE;- }- }-if ((re->options & PCRE_FIRSTLINE) != 0)- {- common->first_line_end = common->ovector_start;- common->ovector_start += sizeof(sljit_sw);- }-#if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD-common->control_head_ptr = 1;-#endif-if (common->control_head_ptr != 0)- {- common->control_head_ptr = common->ovector_start;- common->ovector_start += sizeof(sljit_sw);- }-if (common->needs_start_ptr && common->has_set_som)- {- /* Saving the real start pointer is necessary. */- common->start_ptr = common->ovector_start;- common->ovector_start += sizeof(sljit_sw);- }-else- common->needs_start_ptr = FALSE;--/* Aligning ovector to even number of sljit words. */-if ((common->ovector_start & sizeof(sljit_sw)) != 0)- common->ovector_start += sizeof(sljit_sw);--if (common->start_ptr == 0)- common->start_ptr = OVECTOR(0);--/* Capturing brackets cannot be optimized if callouts are allowed. */-if (common->capture_last_ptr != 0)- memset(common->optimized_cbracket, 0, re->top_bracket + 1);--SLJIT_ASSERT(!(common->req_char_ptr != 0 && common->start_used_ptr != 0));-common->cbra_ptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_sw);--common->private_data_ptrs = (int *)SLJIT_MALLOC((ccend - rootbacktrack.cc) * sizeof(sljit_si));-if (!common->private_data_ptrs)- {- SLJIT_FREE(common->optimized_cbracket);- return;- }-memset(common->private_data_ptrs, 0, (ccend - rootbacktrack.cc) * sizeof(int));--private_data_size = common->cbra_ptr + (re->top_bracket + 1) * sizeof(sljit_sw);-set_private_data_ptrs(common, &private_data_size, ccend);-if (private_data_size > SLJIT_MAX_LOCAL_SIZE)- {- SLJIT_FREE(common->private_data_ptrs);- SLJIT_FREE(common->optimized_cbracket);- return;- }--if (common->has_then)- {- common->then_offsets = (pcre_uint8 *)SLJIT_MALLOC(ccend - rootbacktrack.cc);- if (!common->then_offsets)- {- SLJIT_FREE(common->optimized_cbracket);- SLJIT_FREE(common->private_data_ptrs);- return;- }- memset(common->then_offsets, 0, ccend - rootbacktrack.cc);- set_then_offsets(common, rootbacktrack.cc, NULL);- }--compiler = sljit_create_compiler();-if (!compiler)- {- SLJIT_FREE(common->optimized_cbracket);- SLJIT_FREE(common->private_data_ptrs);- if (common->has_then)- SLJIT_FREE(common->then_offsets);- return;- }-common->compiler = compiler;--/* Main pcre_jit_exec entry. */-sljit_emit_enter(compiler, 1, 5, 5, private_data_size);--/* Register init. */-reset_ovector(common, (re->top_bracket + 1) * 2);-if (common->req_char_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->req_char_ptr, SLJIT_SCRATCH_REG1, 0);--OP1(SLJIT_MOV, ARGUMENTS, 0, SLJIT_SAVED_REG1, 0);-OP1(SLJIT_MOV, TMP1, 0, SLJIT_SAVED_REG1, 0);-OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));-OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, end));-OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));-OP1(SLJIT_MOV_UI, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, limit_match));-OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, base));-OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, limit));-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LIMIT_MATCH, TMP1, 0);--if (mode == JIT_PARTIAL_SOFT_COMPILE)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);-if (common->mark_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->mark_ptr, SLJIT_IMM, 0);-if (common->control_head_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->control_head_ptr, SLJIT_IMM, 0);--/* Main part of the matching */-if ((re->options & PCRE_ANCHORED) == 0)- {- mainloop_label = mainloop_entry(common, (re->flags & PCRE_HASCRORLF) != 0, (re->options & PCRE_FIRSTLINE) != 0);- continue_match_label = LABEL();- /* Forward search if possible. */- if ((re->options & PCRE_NO_START_OPTIMIZE) == 0)- {- if (mode == JIT_COMPILE && fast_forward_first_n_chars(common, (re->options & PCRE_FIRSTLINE) != 0))- { /* Do nothing */ }- else if ((re->flags & PCRE_FIRSTSET) != 0)- fast_forward_first_char(common, (pcre_uchar)re->first_char, (re->flags & PCRE_FCH_CASELESS) != 0, (re->options & PCRE_FIRSTLINE) != 0);- else if ((re->flags & PCRE_STARTLINE) != 0)- fast_forward_newline(common, (re->options & PCRE_FIRSTLINE) != 0);- else if ((re->flags & PCRE_STARTLINE) == 0 && study != NULL && (study->flags & PCRE_STUDY_MAPPED) != 0)- fast_forward_start_bits(common, (sljit_uw)study->start_bits, (re->options & PCRE_FIRSTLINE) != 0);- }- }-else- continue_match_label = LABEL();--if (mode == JIT_COMPILE && study->minlength > 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)- {- OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);- OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(study->minlength));- minlength_check_failed = CMP(SLJIT_C_GREATER, TMP2, 0, STR_END, 0);- }-if (common->req_char_ptr != 0)- reqbyte_notfound = search_requested_char(common, (pcre_uchar)re->req_char, (re->flags & PCRE_RCH_CASELESS) != 0, (re->flags & PCRE_FIRSTSET) != 0);--/* Store the current STR_PTR in OVECTOR(0). */-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0), STR_PTR, 0);-/* Copy the limit of allowed recursions. */-OP1(SLJIT_MOV, COUNT_MATCH, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LIMIT_MATCH);-if (common->capture_last_ptr != 0)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->capture_last_ptr, SLJIT_IMM, -1);--if (common->needs_start_ptr)- {- SLJIT_ASSERT(common->start_ptr != OVECTOR(0));- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr, STR_PTR, 0);- }-else- SLJIT_ASSERT(common->start_ptr == OVECTOR(0));--/* Copy the beginning of the string. */-if (mode == JIT_PARTIAL_SOFT_COMPILE)- {- jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start + sizeof(sljit_sw), STR_PTR, 0);- JUMPHERE(jump);- }-else if (mode == JIT_PARTIAL_HARD_COMPILE)- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, STR_PTR, 0);--compile_matchingpath(common, rootbacktrack.cc, ccend, &rootbacktrack);-if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- {- sljit_free_compiler(compiler);- SLJIT_FREE(common->optimized_cbracket);- SLJIT_FREE(common->private_data_ptrs);- if (common->has_then)- SLJIT_FREE(common->then_offsets);- return;- }--empty_match = CMP(SLJIT_C_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), OVECTOR(0));-empty_match_found_label = LABEL();--common->accept_label = LABEL();-if (common->accept != NULL)- set_jumps(common->accept, common->accept_label);--/* This means we have a match. Update the ovector. */-copy_ovector(common, re->top_bracket + 1);-common->quit_label = common->forced_quit_label = LABEL();-if (common->quit != NULL)- set_jumps(common->quit, common->quit_label);-if (common->forced_quit != NULL)- set_jumps(common->forced_quit, common->forced_quit_label);-if (minlength_check_failed != NULL)- SET_LABEL(minlength_check_failed, common->forced_quit_label);-sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);--if (mode != JIT_COMPILE)- {- common->partialmatchlabel = LABEL();- set_jumps(common->partialmatch, common->partialmatchlabel);- return_with_partial_match(common, common->quit_label);- }--empty_match_backtrack_label = LABEL();-compile_backtrackingpath(common, rootbacktrack.top);-if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- {- sljit_free_compiler(compiler);- SLJIT_FREE(common->optimized_cbracket);- SLJIT_FREE(common->private_data_ptrs);- if (common->has_then)- SLJIT_FREE(common->then_offsets);- return;- }--SLJIT_ASSERT(rootbacktrack.prev == NULL);-reset_match_label = LABEL();--if (mode == JIT_PARTIAL_SOFT_COMPILE)- {- /* Update hit_start only in the first time. */- jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_used_ptr, SLJIT_IMM, -1);- OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, TMP1, 0);- JUMPHERE(jump);- }--/* Check we have remaining characters. */-if ((re->options & PCRE_ANCHORED) == 0 && (re->options & PCRE_FIRSTLINE) != 0)- {- SLJIT_ASSERT(common->first_line_end != 0);- OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);- }--OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->start_ptr);--if ((re->options & PCRE_ANCHORED) == 0)- {- if ((re->options & PCRE_FIRSTLINE) == 0)- CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop_label);- else- CMPTO(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0, mainloop_label);- }--/* No more remaining characters. */-if (reqbyte_notfound != NULL)- JUMPHERE(reqbyte_notfound);--if (mode == JIT_PARTIAL_SOFT_COMPILE)- CMPTO(SLJIT_C_NOT_EQUAL, SLJIT_MEM1(SLJIT_LOCALS_REG), common->hit_start, SLJIT_IMM, -1, common->partialmatchlabel);--OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);-JUMPTO(SLJIT_JUMP, common->quit_label);--flush_stubs(common);--JUMPHERE(empty_match);-OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);-OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));-CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_backtrack_label);-OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));-CMPTO(SLJIT_C_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_found_label);-OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));-CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, STR_PTR, 0, empty_match_found_label);-JUMPTO(SLJIT_JUMP, empty_match_backtrack_label);--common->currententry = common->entries;-common->local_exit = TRUE;-quit_label = common->quit_label;-while (common->currententry != NULL)- {- /* Might add new entries. */- compile_recurse(common);- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))- {- sljit_free_compiler(compiler);- SLJIT_FREE(common->optimized_cbracket);- SLJIT_FREE(common->private_data_ptrs);- if (common->has_then)- SLJIT_FREE(common->then_offsets);- return;- }- flush_stubs(common);- common->currententry = common->currententry->next;- }-common->local_exit = FALSE;-common->quit_label = quit_label;--/* Allocating stack, returns with PCRE_ERROR_JIT_STACKLIMIT if fails. */-/* This is a (really) rare case. */-set_jumps(common->stackalloc, LABEL());-/* RETURN_ADDR is not a saved register. */-sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);-OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1, TMP2, 0);-OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);-OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));-OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, top), STACK_TOP, 0);-OP2(SLJIT_ADD, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, limit), SLJIT_IMM, STACK_GROWTH_RATE);--sljit_emit_ijump(compiler, SLJIT_CALL2, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_stack_resize));-jump = CMP(SLJIT_C_NOT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);-OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);-OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));-OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, top));-OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(struct sljit_stack, limit));-OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS1);-sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), LOCALS0);--/* Allocation failed. */-JUMPHERE(jump);-/* We break the return address cache here, but this is a really rare case. */-OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_JIT_STACKLIMIT);-JUMPTO(SLJIT_JUMP, common->quit_label);--/* Call limit reached. */-set_jumps(common->calllimit, LABEL());-OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_MATCHLIMIT);-JUMPTO(SLJIT_JUMP, common->quit_label);--if (common->revertframes != NULL)- {- set_jumps(common->revertframes, LABEL());- do_revertframes(common);- }-if (common->wordboundary != NULL)- {- set_jumps(common->wordboundary, LABEL());- check_wordboundary(common);- }-if (common->anynewline != NULL)- {- set_jumps(common->anynewline, LABEL());- check_anynewline(common);- }-if (common->hspace != NULL)- {- set_jumps(common->hspace, LABEL());- check_hspace(common);- }-if (common->vspace != NULL)- {- set_jumps(common->vspace, LABEL());- check_vspace(common);- }-if (common->casefulcmp != NULL)- {- set_jumps(common->casefulcmp, LABEL());- do_casefulcmp(common);- }-if (common->caselesscmp != NULL)- {- set_jumps(common->caselesscmp, LABEL());- do_caselesscmp(common);- }-if (common->reset_match != NULL)- {- set_jumps(common->reset_match, LABEL());- do_reset_match(common, (re->top_bracket + 1) * 2);- CMPTO(SLJIT_C_GREATER, STR_PTR, 0, TMP1, 0, continue_match_label);- OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);- JUMPTO(SLJIT_JUMP, reset_match_label);- }-#ifdef SUPPORT_UTF-#ifndef COMPILE_PCRE32-if (common->utfreadchar != NULL)- {- set_jumps(common->utfreadchar, LABEL());- do_utfreadchar(common);- }-#endif /* !COMPILE_PCRE32 */-#ifdef COMPILE_PCRE8-if (common->utfreadtype8 != NULL)- {- set_jumps(common->utfreadtype8, LABEL());- do_utfreadtype8(common);- }-#endif /* COMPILE_PCRE8 */-#endif /* SUPPORT_UTF */-#ifdef SUPPORT_UCP-if (common->getucd != NULL)- {- set_jumps(common->getucd, LABEL());- do_getucd(common);- }-#endif--SLJIT_FREE(common->optimized_cbracket);-SLJIT_FREE(common->private_data_ptrs);-if (common->has_then)- SLJIT_FREE(common->then_offsets);--executable_func = sljit_generate_code(compiler);-executable_size = sljit_get_generated_code_size(compiler);-sljit_free_compiler(compiler);-if (executable_func == NULL)- return;--/* Reuse the function descriptor if possible. */-if ((extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 && extra->executable_jit != NULL)- functions = (executable_functions *)extra->executable_jit;-else- {- /* Note: If your memory-checker has flagged the allocation below as a- * memory leak, it is probably because you either forgot to call- * pcre_free_study() (or pcre16_free_study()) on the pcre_extra (or- * pcre16_extra) object, or you called said function after having- * cleared the PCRE_EXTRA_EXECUTABLE_JIT bit from the "flags" field- * of the object. (The function will only free the JIT data if the- * bit remains set, as the bit indicates that the pointer to the data- * is valid.)- */- functions = SLJIT_MALLOC(sizeof(executable_functions));- if (functions == NULL)- {- /* This case is highly unlikely since we just recently- freed a lot of memory. Although not impossible. */- sljit_free_code(executable_func);- return;- }- memset(functions, 0, sizeof(executable_functions));- functions->top_bracket = (re->top_bracket + 1) * 2;- functions->limit_match = (re->flags & PCRE_MLSET) != 0 ? re->limit_match : 0;- extra->executable_jit = functions;- extra->flags |= PCRE_EXTRA_EXECUTABLE_JIT;- }--functions->executable_funcs[mode] = executable_func;-functions->executable_sizes[mode] = executable_size;-}--static int jit_machine_stack_exec(jit_arguments *arguments, void* executable_func)-{-union {- void* executable_func;- jit_function call_executable_func;-} convert_executable_func;-pcre_uint8 local_space[MACHINE_STACK_SIZE];-struct sljit_stack local_stack;--local_stack.top = (sljit_sw)&local_space;-local_stack.base = local_stack.top;-local_stack.limit = local_stack.base + MACHINE_STACK_SIZE;-local_stack.max_limit = local_stack.limit;-arguments->stack = &local_stack;-convert_executable_func.executable_func = executable_func;-return convert_executable_func.call_executable_func(arguments);-}--int-PRIV(jit_exec)(const PUBL(extra) *extra_data, const pcre_uchar *subject,- int length, int start_offset, int options, int *offsets, int offset_count)-{-executable_functions *functions = (executable_functions *)extra_data->executable_jit;-union {- void* executable_func;- jit_function call_executable_func;-} convert_executable_func;-jit_arguments arguments;-int max_offset_count;-int retval;-int mode = JIT_COMPILE;--if ((options & PCRE_PARTIAL_HARD) != 0)- mode = JIT_PARTIAL_HARD_COMPILE;-else if ((options & PCRE_PARTIAL_SOFT) != 0)- mode = JIT_PARTIAL_SOFT_COMPILE;--if (functions->executable_funcs[mode] == NULL)- return PCRE_ERROR_JIT_BADOPTION;--/* Sanity checks should be handled by pcre_exec. */-arguments.str = subject + start_offset;-arguments.begin = subject;-arguments.end = subject + length;-arguments.mark_ptr = NULL;-/* JIT decreases this value less frequently than the interpreter. */-arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (pcre_uint32)(extra_data->match_limit);-if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)- arguments.limit_match = functions->limit_match;-arguments.notbol = (options & PCRE_NOTBOL) != 0;-arguments.noteol = (options & PCRE_NOTEOL) != 0;-arguments.notempty = (options & PCRE_NOTEMPTY) != 0;-arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;-arguments.offsets = offsets;-arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;-arguments.real_offset_count = offset_count;--/* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of-the output vector for storing captured strings, with the remainder used as-workspace. We don't need the workspace here. For compatibility, we limit the-number of captured strings in the same way as pcre_exec(), so that the user-gets the same result with and without JIT. */--if (offset_count != 2)- offset_count = ((offset_count - (offset_count % 3)) * 2) / 3;-max_offset_count = functions->top_bracket;-if (offset_count > max_offset_count)- offset_count = max_offset_count;-arguments.offset_count = offset_count;--if (functions->callback)- arguments.stack = (struct sljit_stack *)functions->callback(functions->userdata);-else- arguments.stack = (struct sljit_stack *)functions->userdata;--if (arguments.stack == NULL)- retval = jit_machine_stack_exec(&arguments, functions->executable_funcs[mode]);-else- {- convert_executable_func.executable_func = functions->executable_funcs[mode];- retval = convert_executable_func.call_executable_func(&arguments);- }--if (retval * 2 > offset_count)- retval = 0;-if ((extra_data->flags & PCRE_EXTRA_MARK) != 0)- *(extra_data->mark) = arguments.mark_ptr;--return retval;-}--#if defined COMPILE_PCRE8-PCRE_EXP_DEFN int PCRE_CALL_CONVENTION-pcre_jit_exec(const pcre *argument_re, const pcre_extra *extra_data,- PCRE_SPTR subject, int length, int start_offset, int options,- int *offsets, int offset_count, pcre_jit_stack *stack)-#elif defined COMPILE_PCRE16-PCRE_EXP_DEFN int PCRE_CALL_CONVENTION-pcre16_jit_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,- PCRE_SPTR16 subject, int length, int start_offset, int options,- int *offsets, int offset_count, pcre16_jit_stack *stack)-#elif defined COMPILE_PCRE32-PCRE_EXP_DEFN int PCRE_CALL_CONVENTION-pcre32_jit_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,- PCRE_SPTR32 subject, int length, int start_offset, int options,- int *offsets, int offset_count, pcre32_jit_stack *stack)-#endif-{-pcre_uchar *subject_ptr = (pcre_uchar *)subject;-executable_functions *functions = (executable_functions *)extra_data->executable_jit;-union {- void* executable_func;- jit_function call_executable_func;-} convert_executable_func;-jit_arguments arguments;-int max_offset_count;-int retval;-int mode = JIT_COMPILE;--SLJIT_UNUSED_ARG(argument_re);--/* Plausibility checks */-if ((options & ~PUBLIC_JIT_EXEC_OPTIONS) != 0) return PCRE_ERROR_JIT_BADOPTION;--if ((options & PCRE_PARTIAL_HARD) != 0)- mode = JIT_PARTIAL_HARD_COMPILE;-else if ((options & PCRE_PARTIAL_SOFT) != 0)- mode = JIT_PARTIAL_SOFT_COMPILE;--if (functions->executable_funcs[mode] == NULL)- return PCRE_ERROR_JIT_BADOPTION;--/* Sanity checks should be handled by pcre_exec. */-arguments.stack = (struct sljit_stack *)stack;-arguments.str = subject_ptr + start_offset;-arguments.begin = subject_ptr;-arguments.end = subject_ptr + length;-arguments.mark_ptr = NULL;-/* JIT decreases this value less frequently than the interpreter. */-arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (pcre_uint32)(extra_data->match_limit);-if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)- arguments.limit_match = functions->limit_match;-arguments.notbol = (options & PCRE_NOTBOL) != 0;-arguments.noteol = (options & PCRE_NOTEOL) != 0;-arguments.notempty = (options & PCRE_NOTEMPTY) != 0;-arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;-arguments.offsets = offsets;-arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;-arguments.real_offset_count = offset_count;--/* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of-the output vector for storing captured strings, with the remainder used as-workspace. We don't need the workspace here. For compatibility, we limit the-number of captured strings in the same way as pcre_exec(), so that the user-gets the same result with and without JIT. */--if (offset_count != 2)- offset_count = ((offset_count - (offset_count % 3)) * 2) / 3;-max_offset_count = functions->top_bracket;-if (offset_count > max_offset_count)- offset_count = max_offset_count;-arguments.offset_count = offset_count;--convert_executable_func.executable_func = functions->executable_funcs[mode];-retval = convert_executable_func.call_executable_func(&arguments);--if (retval * 2 > offset_count)- retval = 0;-if ((extra_data->flags & PCRE_EXTRA_MARK) != 0)- *(extra_data->mark) = arguments.mark_ptr;--return retval;-}--void-PRIV(jit_free)(void *executable_funcs)-{-int i;-executable_functions *functions = (executable_functions *)executable_funcs;-for (i = 0; i < JIT_NUMBER_OF_COMPILE_MODES; i++)- {- if (functions->executable_funcs[i] != NULL)- sljit_free_code(functions->executable_funcs[i]);- }-SLJIT_FREE(functions);-}--int-PRIV(jit_get_size)(void *executable_funcs)-{-int i;-sljit_uw size = 0;-sljit_uw *executable_sizes = ((executable_functions *)executable_funcs)->executable_sizes;-for (i = 0; i < JIT_NUMBER_OF_COMPILE_MODES; i++)- size += executable_sizes[i];-return (int)size;-}--const char*-PRIV(jit_get_target)(void)-{-return sljit_get_platform_name();-}--#if defined COMPILE_PCRE8-PCRE_EXP_DECL pcre_jit_stack *-pcre_jit_stack_alloc(int startsize, int maxsize)-#elif defined COMPILE_PCRE16-PCRE_EXP_DECL pcre16_jit_stack *-pcre16_jit_stack_alloc(int startsize, int maxsize)-#elif defined COMPILE_PCRE32-PCRE_EXP_DECL pcre32_jit_stack *-pcre32_jit_stack_alloc(int startsize, int maxsize)-#endif-{-if (startsize < 1 || maxsize < 1)- return NULL;-if (startsize > maxsize)- startsize = maxsize;-startsize = (startsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);-maxsize = (maxsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);-return (PUBL(jit_stack)*)sljit_allocate_stack(startsize, maxsize);-}--#if defined COMPILE_PCRE8-PCRE_EXP_DECL void-pcre_jit_stack_free(pcre_jit_stack *stack)-#elif defined COMPILE_PCRE16-PCRE_EXP_DECL void-pcre16_jit_stack_free(pcre16_jit_stack *stack)-#elif defined COMPILE_PCRE32-PCRE_EXP_DECL void-pcre32_jit_stack_free(pcre32_jit_stack *stack)-#endif-{-sljit_free_stack((struct sljit_stack *)stack);+#define SLJIT_MALLOC(size, allocator_data) (PUBL(malloc))(size)+#define SLJIT_FREE(ptr, allocator_data) (PUBL(free))(ptr)+#define SLJIT_CONFIG_AUTO 1+#define SLJIT_CONFIG_STATIC 1+#define SLJIT_VERBOSE 0+#define SLJIT_DEBUG 0++#include "sljit/sljitLir.c"++#if defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED+#error Unsupported architecture+#endif++/* Defines for debugging purposes. */++/* 1 - Use unoptimized capturing brackets.+ 2 - Enable capture_last_ptr (includes option 1). */+/* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */++/* 1 - Always have a control head. */+/* #define DEBUG_FORCE_CONTROL_HEAD 1 */++/* Allocate memory for the regex stack on the real machine stack.+Fast, but limited size. */+#define MACHINE_STACK_SIZE 32768++/* Growth rate for stack allocated by the OS. Should be the multiply+of page size. */+#define STACK_GROWTH_RATE 8192++/* Enable to check that the allocation could destroy temporaries. */+#if defined SLJIT_DEBUG && SLJIT_DEBUG+#define DESTROY_REGISTERS 1+#endif++/*+Short summary about the backtracking mechanism empolyed by the jit code generator:++The code generator follows the recursive nature of the PERL compatible regular+expressions. The basic blocks of regular expressions are condition checkers+whose execute different commands depending on the result of the condition check.+The relationship between the operators can be horizontal (concatenation) and+vertical (sub-expression) (See struct backtrack_common for more details).++ 'ab' - 'a' and 'b' regexps are concatenated+ 'a+' - 'a' is the sub-expression of the '+' operator++The condition checkers are boolean (true/false) checkers. Machine code is generated+for the checker itself and for the actions depending on the result of the checker.+The 'true' case is called as the matching path (expected path), and the other is called as+the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken+branches on the matching path.++ Greedy star operator (*) :+ Matching path: match happens.+ Backtrack path: match failed.+ Non-greedy star operator (*?) :+ Matching path: no need to perform a match.+ Backtrack path: match is required.++The following example shows how the code generated for a capturing bracket+with two alternatives. Let A, B, C, D are arbirary regular expressions, and+we have the following regular expression:++ A(B|C)D++The generated code will be the following:++ A matching path+ '(' matching path (pushing arguments to the stack)+ B matching path+ ')' matching path (pushing arguments to the stack)+ D matching path+ return with successful match++ D backtrack path+ ')' backtrack path (If we arrived from "C" jump to the backtrack of "C")+ B backtrack path+ C expected path+ jump to D matching path+ C backtrack path+ A backtrack path++ Notice, that the order of backtrack code paths are the opposite of the fast+ code paths. In this way the topmost value on the stack is always belong+ to the current backtrack code path. The backtrack path must check+ whether there is a next alternative. If so, it needs to jump back to+ the matching path eventually. Otherwise it needs to clear out its own stack+ frame and continue the execution on the backtrack code paths.+*/++/*+Saved stack frames:++Atomic blocks and asserts require reloading the values of private data+when the backtrack mechanism performed. Because of OP_RECURSE, the data+are not necessarly known in compile time, thus we need a dynamic restore+mechanism.++The stack frames are stored in a chain list, and have the following format:+([ capturing bracket offset ][ start value ][ end value ])+ ... [ 0 ] [ previous head ]++Thus we can restore the private data to a particular point in the stack.+*/++typedef struct jit_arguments {+ /* Pointers first. */+ struct sljit_stack *stack;+ const pcre_uchar *str;+ const pcre_uchar *begin;+ const pcre_uchar *end;+ int *offsets;+ pcre_uchar *mark_ptr;+ void *callout_data;+ /* Everything else after. */+ sljit_u32 limit_match;+ int real_offset_count;+ int offset_count;+ sljit_u8 notbol;+ sljit_u8 noteol;+ sljit_u8 notempty;+ sljit_u8 notempty_atstart;+} jit_arguments;++typedef struct executable_functions {+ void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];+ void *read_only_data_heads[JIT_NUMBER_OF_COMPILE_MODES];+ sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];+ PUBL(jit_callback) callback;+ void *userdata;+ sljit_u32 top_bracket;+ sljit_u32 limit_match;+} executable_functions;++typedef struct jump_list {+ struct sljit_jump *jump;+ struct jump_list *next;+} jump_list;++typedef struct stub_list {+ struct sljit_jump *start;+ struct sljit_label *quit;+ struct stub_list *next;+} stub_list;++typedef struct label_addr_list {+ struct sljit_label *label;+ sljit_uw *update_addr;+ struct label_addr_list *next;+} label_addr_list;++enum frame_types {+ no_frame = -1,+ no_stack = -2+};++enum control_types {+ type_mark = 0,+ type_then_trap = 1+};++typedef int (SLJIT_FUNC *jit_function)(jit_arguments *args);++/* The following structure is the key data type for the recursive+code generator. It is allocated by compile_matchingpath, and contains+the arguments for compile_backtrackingpath. Must be the first member+of its descendants. */+typedef struct backtrack_common {+ /* Concatenation stack. */+ struct backtrack_common *prev;+ jump_list *nextbacktracks;+ /* Internal stack (for component operators). */+ struct backtrack_common *top;+ jump_list *topbacktracks;+ /* Opcode pointer. */+ pcre_uchar *cc;+} backtrack_common;++typedef struct assert_backtrack {+ backtrack_common common;+ jump_list *condfailed;+ /* Less than 0 if a frame is not needed. */+ int framesize;+ /* Points to our private memory word on the stack. */+ int private_data_ptr;+ /* For iterators. */+ struct sljit_label *matchingpath;+} assert_backtrack;++typedef struct bracket_backtrack {+ backtrack_common common;+ /* Where to coninue if an alternative is successfully matched. */+ struct sljit_label *alternative_matchingpath;+ /* For rmin and rmax iterators. */+ struct sljit_label *recursive_matchingpath;+ /* For greedy ? operator. */+ struct sljit_label *zero_matchingpath;+ /* Contains the branches of a failed condition. */+ union {+ /* Both for OP_COND, OP_SCOND. */+ jump_list *condfailed;+ assert_backtrack *assert;+ /* For OP_ONCE. Less than 0 if not needed. */+ int framesize;+ } u;+ /* Points to our private memory word on the stack. */+ int private_data_ptr;+} bracket_backtrack;++typedef struct bracketpos_backtrack {+ backtrack_common common;+ /* Points to our private memory word on the stack. */+ int private_data_ptr;+ /* Reverting stack is needed. */+ int framesize;+ /* Allocated stack size. */+ int stacksize;+} bracketpos_backtrack;++typedef struct braminzero_backtrack {+ backtrack_common common;+ struct sljit_label *matchingpath;+} braminzero_backtrack;++typedef struct char_iterator_backtrack {+ backtrack_common common;+ /* Next iteration. */+ struct sljit_label *matchingpath;+ union {+ jump_list *backtracks;+ struct {+ unsigned int othercasebit;+ pcre_uchar chr;+ BOOL enabled;+ } charpos;+ } u;+} char_iterator_backtrack;++typedef struct ref_iterator_backtrack {+ backtrack_common common;+ /* Next iteration. */+ struct sljit_label *matchingpath;+} ref_iterator_backtrack;++typedef struct recurse_entry {+ struct recurse_entry *next;+ /* Contains the function entry. */+ struct sljit_label *entry;+ /* Collects the calls until the function is not created. */+ jump_list *calls;+ /* Points to the starting opcode. */+ sljit_sw start;+} recurse_entry;++typedef struct recurse_backtrack {+ backtrack_common common;+ BOOL inlined_pattern;+} recurse_backtrack;++#define OP_THEN_TRAP OP_TABLE_LENGTH++typedef struct then_trap_backtrack {+ backtrack_common common;+ /* If then_trap is not NULL, this structure contains the real+ then_trap for the backtracking path. */+ struct then_trap_backtrack *then_trap;+ /* Points to the starting opcode. */+ sljit_sw start;+ /* Exit point for the then opcodes of this alternative. */+ jump_list *quit;+ /* Frame size of the current alternative. */+ int framesize;+} then_trap_backtrack;++#define MAX_RANGE_SIZE 4++typedef struct compiler_common {+ /* The sljit ceneric compiler. */+ struct sljit_compiler *compiler;+ /* First byte code. */+ pcre_uchar *start;+ /* Maps private data offset to each opcode. */+ sljit_s32 *private_data_ptrs;+ /* Chain list of read-only data ptrs. */+ void *read_only_data_head;+ /* Tells whether the capturing bracket is optimized. */+ sljit_u8 *optimized_cbracket;+ /* Tells whether the starting offset is a target of then. */+ sljit_u8 *then_offsets;+ /* Current position where a THEN must jump. */+ then_trap_backtrack *then_trap;+ /* Starting offset of private data for capturing brackets. */+ sljit_s32 cbra_ptr;+ /* Output vector starting point. Must be divisible by 2. */+ sljit_s32 ovector_start;+ /* Points to the starting character of the current match. */+ sljit_s32 start_ptr;+ /* Last known position of the requested byte. */+ sljit_s32 req_char_ptr;+ /* Head of the last recursion. */+ sljit_s32 recursive_head_ptr;+ /* First inspected character for partial matching.+ (Needed for avoiding zero length partial matches.) */+ sljit_s32 start_used_ptr;+ /* Starting pointer for partial soft matches. */+ sljit_s32 hit_start;+ /* Pointer of the match end position. */+ sljit_s32 match_end_ptr;+ /* Points to the marked string. */+ sljit_s32 mark_ptr;+ /* Recursive control verb management chain. */+ sljit_s32 control_head_ptr;+ /* Points to the last matched capture block index. */+ sljit_s32 capture_last_ptr;+ /* Fast forward skipping byte code pointer. */+ pcre_uchar *fast_forward_bc_ptr;+ /* Locals used by fast fail optimization. */+ sljit_s32 fast_fail_start_ptr;+ sljit_s32 fast_fail_end_ptr;++ /* Flipped and lower case tables. */+ const sljit_u8 *fcc;+ sljit_sw lcc;+ /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */+ int mode;+ /* TRUE, when minlength is greater than 0. */+ BOOL might_be_empty;+ /* \K is found in the pattern. */+ BOOL has_set_som;+ /* (*SKIP:arg) is found in the pattern. */+ BOOL has_skip_arg;+ /* (*THEN) is found in the pattern. */+ BOOL has_then;+ /* (*SKIP) or (*SKIP:arg) is found in lookbehind assertion. */+ BOOL has_skip_in_assert_back;+ /* Currently in recurse or negative assert. */+ BOOL local_exit;+ /* Currently in a positive assert. */+ BOOL positive_assert;+ /* Newline control. */+ int nltype;+ sljit_u32 nlmax;+ sljit_u32 nlmin;+ int newline;+ int bsr_nltype;+ sljit_u32 bsr_nlmax;+ sljit_u32 bsr_nlmin;+ /* Dollar endonly. */+ int endonly;+ /* Tables. */+ sljit_sw ctypes;+ /* Named capturing brackets. */+ pcre_uchar *name_table;+ sljit_sw name_count;+ sljit_sw name_entry_size;++ /* Labels and jump lists. */+ struct sljit_label *partialmatchlabel;+ struct sljit_label *quit_label;+ struct sljit_label *forced_quit_label;+ struct sljit_label *accept_label;+ struct sljit_label *ff_newline_shortcut;+ stub_list *stubs;+ label_addr_list *label_addrs;+ recurse_entry *entries;+ recurse_entry *currententry;+ jump_list *partialmatch;+ jump_list *quit;+ jump_list *positive_assert_quit;+ jump_list *forced_quit;+ jump_list *accept;+ jump_list *calllimit;+ jump_list *stackalloc;+ jump_list *revertframes;+ jump_list *wordboundary;+ jump_list *anynewline;+ jump_list *hspace;+ jump_list *vspace;+ jump_list *casefulcmp;+ jump_list *caselesscmp;+ jump_list *reset_match;+ BOOL jscript_compat;+#ifdef SUPPORT_UTF+ BOOL utf;+#ifdef SUPPORT_UCP+ BOOL use_ucp;+ jump_list *getucd;+#endif+#ifdef COMPILE_PCRE8+ jump_list *utfreadchar;+ jump_list *utfreadchar16;+ jump_list *utfreadtype8;+#endif+#endif /* SUPPORT_UTF */+} compiler_common;++/* For byte_sequence_compare. */++typedef struct compare_context {+ int length;+ int sourcereg;+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED+ int ucharptr;+ union {+ sljit_s32 asint;+ sljit_u16 asushort;+#if defined COMPILE_PCRE8+ sljit_u8 asbyte;+ sljit_u8 asuchars[4];+#elif defined COMPILE_PCRE16+ sljit_u16 asuchars[2];+#elif defined COMPILE_PCRE32+ sljit_u32 asuchars[1];+#endif+ } c;+ union {+ sljit_s32 asint;+ sljit_u16 asushort;+#if defined COMPILE_PCRE8+ sljit_u8 asbyte;+ sljit_u8 asuchars[4];+#elif defined COMPILE_PCRE16+ sljit_u16 asuchars[2];+#elif defined COMPILE_PCRE32+ sljit_u32 asuchars[1];+#endif+ } oc;+#endif+} compare_context;++/* Undefine sljit macros. */+#undef CMP++/* Used for accessing the elements of the stack. */+#define STACK(i) ((i) * (int)sizeof(sljit_sw))++#ifdef SLJIT_PREF_SHIFT_REG+#if SLJIT_PREF_SHIFT_REG == SLJIT_R2+/* Nothing. */+#elif SLJIT_PREF_SHIFT_REG == SLJIT_R3+#define SHIFT_REG_IS_R3+#else+#error "Unsupported shift register"+#endif+#endif++#define TMP1 SLJIT_R0+#ifdef SHIFT_REG_IS_R3+#define TMP2 SLJIT_R3+#define TMP3 SLJIT_R2+#else+#define TMP2 SLJIT_R2+#define TMP3 SLJIT_R3+#endif+#define STR_PTR SLJIT_S0+#define STR_END SLJIT_S1+#define STACK_TOP SLJIT_R1+#define STACK_LIMIT SLJIT_S2+#define COUNT_MATCH SLJIT_S3+#define ARGUMENTS SLJIT_S4+#define RETURN_ADDR SLJIT_R4++/* Local space layout. */+/* These two locals can be used by the current opcode. */+#define LOCALS0 (0 * sizeof(sljit_sw))+#define LOCALS1 (1 * sizeof(sljit_sw))+/* Two local variables for possessive quantifiers (char1 cannot use them). */+#define POSSESSIVE0 (2 * sizeof(sljit_sw))+#define POSSESSIVE1 (3 * sizeof(sljit_sw))+/* Max limit of recursions. */+#define LIMIT_MATCH (4 * sizeof(sljit_sw))+/* The output vector is stored on the stack, and contains pointers+to characters. The vector data is divided into two groups: the first+group contains the start / end character pointers, and the second is+the start pointers when the end of the capturing group has not yet reached. */+#define OVECTOR_START (common->ovector_start)+#define OVECTOR(i) (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw))+#define OVECTOR_PRIV(i) (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))+#define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])++#if defined COMPILE_PCRE8+#define MOV_UCHAR SLJIT_MOV_U8+#elif defined COMPILE_PCRE16+#define MOV_UCHAR SLJIT_MOV_U16+#elif defined COMPILE_PCRE32+#define MOV_UCHAR SLJIT_MOV_U32+#else+#error Unsupported compiling mode+#endif++/* Shortcuts. */+#define DEFINE_COMPILER \+ struct sljit_compiler *compiler = common->compiler+#define OP1(op, dst, dstw, src, srcw) \+ sljit_emit_op1(compiler, (op), (dst), (dstw), (src), (srcw))+#define OP2(op, dst, dstw, src1, src1w, src2, src2w) \+ sljit_emit_op2(compiler, (op), (dst), (dstw), (src1), (src1w), (src2), (src2w))+#define LABEL() \+ sljit_emit_label(compiler)+#define JUMP(type) \+ sljit_emit_jump(compiler, (type))+#define JUMPTO(type, label) \+ sljit_set_label(sljit_emit_jump(compiler, (type)), (label))+#define JUMPHERE(jump) \+ sljit_set_label((jump), sljit_emit_label(compiler))+#define SET_LABEL(jump, label) \+ sljit_set_label((jump), (label))+#define CMP(type, src1, src1w, src2, src2w) \+ sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))+#define CMPTO(type, src1, src1w, src2, src2w, label) \+ sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))+#define OP_FLAGS(op, dst, dstw, type) \+ sljit_emit_op_flags(compiler, (op), (dst), (dstw), (type))+#define GET_LOCAL_BASE(dst, dstw, offset) \+ sljit_get_local_base(compiler, (dst), (dstw), (offset))++#define READ_CHAR_MAX 0x7fffffff++#define INVALID_UTF_CHAR 888++static pcre_uchar *bracketend(pcre_uchar *cc)+{+SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));+do cc += GET(cc, 1); while (*cc == OP_ALT);+SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);+cc += 1 + LINK_SIZE;+return cc;+}++static int no_alternatives(pcre_uchar *cc)+{+int count = 0;+SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));+do+ {+ cc += GET(cc, 1);+ count++;+ }+while (*cc == OP_ALT);+SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);+return count;+}++/* Functions whose might need modification for all new supported opcodes:+ next_opcode+ check_opcode_types+ set_private_data_ptrs+ get_framesize+ init_frame+ get_private_data_copy_length+ copy_private_data+ compile_matchingpath+ compile_backtrackingpath+*/++static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)+{+SLJIT_UNUSED_ARG(common);+switch(*cc)+ {+ case OP_SOD:+ case OP_SOM:+ case OP_SET_SOM:+ case OP_NOT_WORD_BOUNDARY:+ case OP_WORD_BOUNDARY:+ case OP_NOT_DIGIT:+ case OP_DIGIT:+ case OP_NOT_WHITESPACE:+ case OP_WHITESPACE:+ case OP_NOT_WORDCHAR:+ case OP_WORDCHAR:+ case OP_ANY:+ case OP_ALLANY:+ case OP_NOTPROP:+ case OP_PROP:+ case OP_ANYNL:+ case OP_NOT_HSPACE:+ case OP_HSPACE:+ case OP_NOT_VSPACE:+ case OP_VSPACE:+ case OP_EXTUNI:+ case OP_EODN:+ case OP_EOD:+ case OP_CIRC:+ case OP_CIRCM:+ case OP_DOLL:+ case OP_DOLLM:+ case OP_CRSTAR:+ case OP_CRMINSTAR:+ case OP_CRPLUS:+ case OP_CRMINPLUS:+ case OP_CRQUERY:+ case OP_CRMINQUERY:+ case OP_CRRANGE:+ case OP_CRMINRANGE:+ case OP_CRPOSSTAR:+ case OP_CRPOSPLUS:+ case OP_CRPOSQUERY:+ case OP_CRPOSRANGE:+ case OP_CLASS:+ case OP_NCLASS:+ case OP_REF:+ case OP_REFI:+ case OP_DNREF:+ case OP_DNREFI:+ case OP_RECURSE:+ case OP_CALLOUT:+ case OP_ALT:+ case OP_KET:+ case OP_KETRMAX:+ case OP_KETRMIN:+ case OP_KETRPOS:+ case OP_REVERSE:+ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_BRA:+ case OP_BRAPOS:+ case OP_CBRA:+ case OP_CBRAPOS:+ case OP_COND:+ case OP_SBRA:+ case OP_SBRAPOS:+ case OP_SCBRA:+ case OP_SCBRAPOS:+ case OP_SCOND:+ case OP_CREF:+ case OP_DNCREF:+ case OP_RREF:+ case OP_DNRREF:+ case OP_DEF:+ case OP_BRAZERO:+ case OP_BRAMINZERO:+ case OP_BRAPOSZERO:+ case OP_PRUNE:+ case OP_SKIP:+ case OP_THEN:+ case OP_COMMIT:+ case OP_FAIL:+ case OP_ACCEPT:+ case OP_ASSERT_ACCEPT:+ case OP_CLOSE:+ case OP_SKIPZERO:+ return cc + PRIV(OP_lengths)[*cc];++ case OP_CHAR:+ case OP_CHARI:+ case OP_NOT:+ case OP_NOTI:+ case OP_STAR:+ case OP_MINSTAR:+ case OP_PLUS:+ case OP_MINPLUS:+ case OP_QUERY:+ case OP_MINQUERY:+ case OP_UPTO:+ case OP_MINUPTO:+ case OP_EXACT:+ case OP_POSSTAR:+ case OP_POSPLUS:+ case OP_POSQUERY:+ case OP_POSUPTO:+ case OP_STARI:+ case OP_MINSTARI:+ case OP_PLUSI:+ case OP_MINPLUSI:+ case OP_QUERYI:+ case OP_MINQUERYI:+ case OP_UPTOI:+ case OP_MINUPTOI:+ case OP_EXACTI:+ case OP_POSSTARI:+ case OP_POSPLUSI:+ case OP_POSQUERYI:+ case OP_POSUPTOI:+ case OP_NOTSTAR:+ case OP_NOTMINSTAR:+ case OP_NOTPLUS:+ case OP_NOTMINPLUS:+ case OP_NOTQUERY:+ case OP_NOTMINQUERY:+ case OP_NOTUPTO:+ case OP_NOTMINUPTO:+ case OP_NOTEXACT:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSUPTO:+ case OP_NOTSTARI:+ case OP_NOTMINSTARI:+ case OP_NOTPLUSI:+ case OP_NOTMINPLUSI:+ case OP_NOTQUERYI:+ case OP_NOTMINQUERYI:+ case OP_NOTUPTOI:+ case OP_NOTMINUPTOI:+ case OP_NOTEXACTI:+ case OP_NOTPOSSTARI:+ case OP_NOTPOSPLUSI:+ case OP_NOTPOSQUERYI:+ case OP_NOTPOSUPTOI:+ cc += PRIV(OP_lengths)[*cc];+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ return cc;++ /* Special cases. */+ case OP_TYPESTAR:+ case OP_TYPEMINSTAR:+ case OP_TYPEPLUS:+ case OP_TYPEMINPLUS:+ case OP_TYPEQUERY:+ case OP_TYPEMINQUERY:+ case OP_TYPEUPTO:+ case OP_TYPEMINUPTO:+ case OP_TYPEEXACT:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSPLUS:+ case OP_TYPEPOSQUERY:+ case OP_TYPEPOSUPTO:+ return cc + PRIV(OP_lengths)[*cc] - 1;++ case OP_ANYBYTE:+#ifdef SUPPORT_UTF+ if (common->utf) return NULL;+#endif+ return cc + 1;++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ return cc + GET(cc, 1);+#endif++ case OP_MARK:+ case OP_PRUNE_ARG:+ case OP_SKIP_ARG:+ case OP_THEN_ARG:+ return cc + 1 + 2 + cc[1];++ default:+ /* All opcodes are supported now! */+ SLJIT_UNREACHABLE();+ return NULL;+ }+}++static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)+{+int count;+pcre_uchar *slot;+pcre_uchar *assert_back_end = cc - 1;++/* Calculate important variables (like stack size) and checks whether all opcodes are supported. */+while (cc < ccend)+ {+ switch(*cc)+ {+ case OP_SET_SOM:+ common->has_set_som = TRUE;+ common->might_be_empty = TRUE;+ cc += 1;+ break;++ case OP_REF:+ case OP_REFI:+ common->optimized_cbracket[GET2(cc, 1)] = 0;+ cc += 1 + IMM2_SIZE;+ break;++ case OP_CBRAPOS:+ case OP_SCBRAPOS:+ common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;+ cc += 1 + LINK_SIZE + IMM2_SIZE;+ break;++ case OP_COND:+ case OP_SCOND:+ /* Only AUTO_CALLOUT can insert this opcode. We do+ not intend to support this case. */+ if (cc[1 + LINK_SIZE] == OP_CALLOUT)+ return FALSE;+ cc += 1 + LINK_SIZE;+ break;++ case OP_CREF:+ common->optimized_cbracket[GET2(cc, 1)] = 0;+ cc += 1 + IMM2_SIZE;+ break;++ case OP_DNREF:+ case OP_DNREFI:+ case OP_DNCREF:+ count = GET2(cc, 1 + IMM2_SIZE);+ slot = common->name_table + GET2(cc, 1) * common->name_entry_size;+ while (count-- > 0)+ {+ common->optimized_cbracket[GET2(slot, 0)] = 0;+ slot += common->name_entry_size;+ }+ cc += 1 + 2 * IMM2_SIZE;+ break;++ case OP_RECURSE:+ /* Set its value only once. */+ if (common->recursive_head_ptr == 0)+ {+ common->recursive_head_ptr = common->ovector_start;+ common->ovector_start += sizeof(sljit_sw);+ }+ cc += 1 + LINK_SIZE;+ break;++ case OP_CALLOUT:+ if (common->capture_last_ptr == 0)+ {+ common->capture_last_ptr = common->ovector_start;+ common->ovector_start += sizeof(sljit_sw);+ }+ cc += 2 + 2 * LINK_SIZE;+ break;++ case OP_ASSERTBACK:+ slot = bracketend(cc);+ if (slot > assert_back_end)+ assert_back_end = slot;+ cc += 1 + LINK_SIZE;+ break;++ case OP_THEN_ARG:+ common->has_then = TRUE;+ common->control_head_ptr = 1;+ /* Fall through. */++ case OP_PRUNE_ARG:+ case OP_MARK:+ if (common->mark_ptr == 0)+ {+ common->mark_ptr = common->ovector_start;+ common->ovector_start += sizeof(sljit_sw);+ }+ cc += 1 + 2 + cc[1];+ break;++ case OP_THEN:+ common->has_then = TRUE;+ common->control_head_ptr = 1;+ cc += 1;+ break;++ case OP_SKIP:+ if (cc < assert_back_end)+ common->has_skip_in_assert_back = TRUE;+ cc += 1;+ break;++ case OP_SKIP_ARG:+ common->control_head_ptr = 1;+ common->has_skip_arg = TRUE;+ if (cc < assert_back_end)+ common->has_skip_in_assert_back = TRUE;+ cc += 1 + 2 + cc[1];+ break;++ default:+ cc = next_opcode(common, cc);+ if (cc == NULL)+ return FALSE;+ break;+ }+ }+return TRUE;+}++static BOOL is_accelerated_repeat(pcre_uchar *cc)+{+switch(*cc)+ {+ case OP_TYPESTAR:+ case OP_TYPEMINSTAR:+ case OP_TYPEPLUS:+ case OP_TYPEMINPLUS:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSPLUS:+ return (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI);++ case OP_STAR:+ case OP_MINSTAR:+ case OP_PLUS:+ case OP_MINPLUS:+ case OP_POSSTAR:+ case OP_POSPLUS:++ case OP_STARI:+ case OP_MINSTARI:+ case OP_PLUSI:+ case OP_MINPLUSI:+ case OP_POSSTARI:+ case OP_POSPLUSI:++ case OP_NOTSTAR:+ case OP_NOTMINSTAR:+ case OP_NOTPLUS:+ case OP_NOTMINPLUS:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSPLUS:++ case OP_NOTSTARI:+ case OP_NOTMINSTARI:+ case OP_NOTPLUSI:+ case OP_NOTMINPLUSI:+ case OP_NOTPOSSTARI:+ case OP_NOTPOSPLUSI:+ return TRUE;++ case OP_CLASS:+ case OP_NCLASS:+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ cc += (*cc == OP_XCLASS) ? GET(cc, 1) : (int)(1 + (32 / sizeof(pcre_uchar)));+#else+ cc += (1 + (32 / sizeof(pcre_uchar)));+#endif++ switch(*cc)+ {+ case OP_CRSTAR:+ case OP_CRMINSTAR:+ case OP_CRPLUS:+ case OP_CRMINPLUS:+ case OP_CRPOSSTAR:+ case OP_CRPOSPLUS:+ return TRUE;+ }+ break;+ }+return FALSE;+}++static SLJIT_INLINE BOOL detect_fast_forward_skip(compiler_common *common, int *private_data_start)+{+pcre_uchar *cc = common->start;+pcre_uchar *end;++/* Skip not repeated brackets. */+while (TRUE)+ {+ switch(*cc)+ {+ case OP_SOD:+ case OP_SOM:+ case OP_SET_SOM:+ case OP_NOT_WORD_BOUNDARY:+ case OP_WORD_BOUNDARY:+ case OP_EODN:+ case OP_EOD:+ case OP_CIRC:+ case OP_CIRCM:+ case OP_DOLL:+ case OP_DOLLM:+ /* Zero width assertions. */+ cc++;+ continue;+ }++ if (*cc != OP_BRA && *cc != OP_CBRA)+ break;++ end = cc + GET(cc, 1);+ if (*end != OP_KET || PRIVATE_DATA(end) != 0)+ return FALSE;+ if (*cc == OP_CBRA)+ {+ if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)+ return FALSE;+ cc += IMM2_SIZE;+ }+ cc += 1 + LINK_SIZE;+ }++if (is_accelerated_repeat(cc))+ {+ common->fast_forward_bc_ptr = cc;+ common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;+ *private_data_start += sizeof(sljit_sw);+ return TRUE;+ }+return FALSE;+}++static SLJIT_INLINE void detect_fast_fail(compiler_common *common, pcre_uchar *cc, int *private_data_start, sljit_s32 depth)+{+ pcre_uchar *next_alt;++ SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA);++ if (*cc == OP_CBRA && common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)+ return;++ next_alt = bracketend(cc) - (1 + LINK_SIZE);+ if (*next_alt != OP_KET || PRIVATE_DATA(next_alt) != 0)+ return;++ do+ {+ next_alt = cc + GET(cc, 1);++ cc += 1 + LINK_SIZE + ((*cc == OP_CBRA) ? IMM2_SIZE : 0);++ while (TRUE)+ {+ switch(*cc)+ {+ case OP_SOD:+ case OP_SOM:+ case OP_SET_SOM:+ case OP_NOT_WORD_BOUNDARY:+ case OP_WORD_BOUNDARY:+ case OP_EODN:+ case OP_EOD:+ case OP_CIRC:+ case OP_CIRCM:+ case OP_DOLL:+ case OP_DOLLM:+ /* Zero width assertions. */+ cc++;+ continue;+ }+ break;+ }++ if (depth > 0 && (*cc == OP_BRA || *cc == OP_CBRA))+ detect_fast_fail(common, cc, private_data_start, depth - 1);++ if (is_accelerated_repeat(cc))+ {+ common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;++ if (common->fast_fail_start_ptr == 0)+ common->fast_fail_start_ptr = *private_data_start;++ *private_data_start += sizeof(sljit_sw);+ common->fast_fail_end_ptr = *private_data_start;++ if (*private_data_start > SLJIT_MAX_LOCAL_SIZE)+ return;+ }++ cc = next_alt;+ }+ while (*cc == OP_ALT);+}++static int get_class_iterator_size(pcre_uchar *cc)+{+sljit_u32 min;+sljit_u32 max;+switch(*cc)+ {+ case OP_CRSTAR:+ case OP_CRPLUS:+ return 2;++ case OP_CRMINSTAR:+ case OP_CRMINPLUS:+ case OP_CRQUERY:+ case OP_CRMINQUERY:+ return 1;++ case OP_CRRANGE:+ case OP_CRMINRANGE:+ min = GET2(cc, 1);+ max = GET2(cc, 1 + IMM2_SIZE);+ if (max == 0)+ return (*cc == OP_CRRANGE) ? 2 : 1;+ max -= min;+ if (max > 2)+ max = 2;+ return max;++ default:+ return 0;+ }+}++static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)+{+pcre_uchar *end = bracketend(begin);+pcre_uchar *next;+pcre_uchar *next_end;+pcre_uchar *max_end;+pcre_uchar type;+sljit_sw length = end - begin;+int min, max, i;++/* Detect fixed iterations first. */+if (end[-(1 + LINK_SIZE)] != OP_KET)+ return FALSE;++/* Already detected repeat. */+if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)+ return TRUE;++next = end;+min = 1;+while (1)+ {+ if (*next != *begin)+ break;+ next_end = bracketend(next);+ if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)+ break;+ next = next_end;+ min++;+ }++if (min == 2)+ return FALSE;++max = 0;+max_end = next;+if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)+ {+ type = *next;+ while (1)+ {+ if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)+ break;+ next_end = bracketend(next + 2 + LINK_SIZE);+ if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)+ break;+ next = next_end;+ max++;+ }++ if (next[0] == type && next[1] == *begin && max >= 1)+ {+ next_end = bracketend(next + 1);+ if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)+ {+ for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)+ if (*next_end != OP_KET)+ break;++ if (i == max)+ {+ common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;+ common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;+ /* +2 the original and the last. */+ common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;+ if (min == 1)+ return TRUE;+ min--;+ max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);+ }+ }+ }+ }++if (min >= 3)+ {+ common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;+ common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;+ common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;+ return TRUE;+ }++return FALSE;+}++#define CASE_ITERATOR_PRIVATE_DATA_1 \+ case OP_MINSTAR: \+ case OP_MINPLUS: \+ case OP_QUERY: \+ case OP_MINQUERY: \+ case OP_MINSTARI: \+ case OP_MINPLUSI: \+ case OP_QUERYI: \+ case OP_MINQUERYI: \+ case OP_NOTMINSTAR: \+ case OP_NOTMINPLUS: \+ case OP_NOTQUERY: \+ case OP_NOTMINQUERY: \+ case OP_NOTMINSTARI: \+ case OP_NOTMINPLUSI: \+ case OP_NOTQUERYI: \+ case OP_NOTMINQUERYI:++#define CASE_ITERATOR_PRIVATE_DATA_2A \+ case OP_STAR: \+ case OP_PLUS: \+ case OP_STARI: \+ case OP_PLUSI: \+ case OP_NOTSTAR: \+ case OP_NOTPLUS: \+ case OP_NOTSTARI: \+ case OP_NOTPLUSI:++#define CASE_ITERATOR_PRIVATE_DATA_2B \+ case OP_UPTO: \+ case OP_MINUPTO: \+ case OP_UPTOI: \+ case OP_MINUPTOI: \+ case OP_NOTUPTO: \+ case OP_NOTMINUPTO: \+ case OP_NOTUPTOI: \+ case OP_NOTMINUPTOI:++#define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \+ case OP_TYPEMINSTAR: \+ case OP_TYPEMINPLUS: \+ case OP_TYPEQUERY: \+ case OP_TYPEMINQUERY:++#define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \+ case OP_TYPESTAR: \+ case OP_TYPEPLUS:++#define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \+ case OP_TYPEUPTO: \+ case OP_TYPEMINUPTO:++static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)+{+pcre_uchar *cc = common->start;+pcre_uchar *alternative;+pcre_uchar *end = NULL;+int private_data_ptr = *private_data_start;+int space, size, bracketlen;+BOOL repeat_check = TRUE;++while (cc < ccend)+ {+ space = 0;+ size = 0;+ bracketlen = 0;+ if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)+ break;++ if (repeat_check && (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND))+ {+ if (detect_repeat(common, cc))+ {+ /* These brackets are converted to repeats, so no global+ based single character repeat is allowed. */+ if (cc >= end)+ end = bracketend(cc);+ }+ }+ repeat_check = TRUE;++ switch(*cc)+ {+ case OP_KET:+ if (common->private_data_ptrs[cc + 1 - common->start] != 0)+ {+ common->private_data_ptrs[cc - common->start] = private_data_ptr;+ private_data_ptr += sizeof(sljit_sw);+ cc += common->private_data_ptrs[cc + 1 - common->start];+ }+ cc += 1 + LINK_SIZE;+ break;++ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_BRAPOS:+ case OP_SBRA:+ case OP_SBRAPOS:+ case OP_SCOND:+ common->private_data_ptrs[cc - common->start] = private_data_ptr;+ private_data_ptr += sizeof(sljit_sw);+ bracketlen = 1 + LINK_SIZE;+ break;++ case OP_CBRAPOS:+ case OP_SCBRAPOS:+ common->private_data_ptrs[cc - common->start] = private_data_ptr;+ private_data_ptr += sizeof(sljit_sw);+ bracketlen = 1 + LINK_SIZE + IMM2_SIZE;+ break;++ case OP_COND:+ /* Might be a hidden SCOND. */+ alternative = cc + GET(cc, 1);+ if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)+ {+ common->private_data_ptrs[cc - common->start] = private_data_ptr;+ private_data_ptr += sizeof(sljit_sw);+ }+ bracketlen = 1 + LINK_SIZE;+ break;++ case OP_BRA:+ bracketlen = 1 + LINK_SIZE;+ break;++ case OP_CBRA:+ case OP_SCBRA:+ bracketlen = 1 + LINK_SIZE + IMM2_SIZE;+ break;++ case OP_BRAZERO:+ case OP_BRAMINZERO:+ case OP_BRAPOSZERO:+ repeat_check = FALSE;+ size = 1;+ break;++ CASE_ITERATOR_PRIVATE_DATA_1+ space = 1;+ size = -2;+ break;++ CASE_ITERATOR_PRIVATE_DATA_2A+ space = 2;+ size = -2;+ break;++ CASE_ITERATOR_PRIVATE_DATA_2B+ space = 2;+ size = -(2 + IMM2_SIZE);+ break;++ CASE_ITERATOR_TYPE_PRIVATE_DATA_1+ space = 1;+ size = 1;+ break;++ CASE_ITERATOR_TYPE_PRIVATE_DATA_2A+ if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)+ space = 2;+ size = 1;+ break;++ case OP_TYPEUPTO:+ if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)+ space = 2;+ size = 1 + IMM2_SIZE;+ break;++ case OP_TYPEMINUPTO:+ space = 2;+ size = 1 + IMM2_SIZE;+ break;++ case OP_CLASS:+ case OP_NCLASS:+ space = get_class_iterator_size(cc + size);+ size = 1 + 32 / sizeof(pcre_uchar);+ break;++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ space = get_class_iterator_size(cc + size);+ size = GET(cc, 1);+ break;+#endif++ default:+ cc = next_opcode(common, cc);+ SLJIT_ASSERT(cc != NULL);+ break;+ }++ /* Character iterators, which are not inside a repeated bracket,+ gets a private slot instead of allocating it on the stack. */+ if (space > 0 && cc >= end)+ {+ common->private_data_ptrs[cc - common->start] = private_data_ptr;+ private_data_ptr += sizeof(sljit_sw) * space;+ }++ if (size != 0)+ {+ if (size < 0)+ {+ cc += -size;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ }+ else+ cc += size;+ }++ if (bracketlen > 0)+ {+ if (cc >= end)+ {+ end = bracketend(cc);+ if (end[-1 - LINK_SIZE] == OP_KET)+ end = NULL;+ }+ cc += bracketlen;+ }+ }+*private_data_start = private_data_ptr;+}++/* Returns with a frame_types (always < 0) if no need for frame. */+static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL *needs_control_head)+{+int length = 0;+int possessive = 0;+BOOL stack_restore = FALSE;+BOOL setsom_found = recursive;+BOOL setmark_found = recursive;+/* The last capture is a local variable even for recursions. */+BOOL capture_last_found = FALSE;++#if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD+SLJIT_ASSERT(common->control_head_ptr != 0);+*needs_control_head = TRUE;+#else+*needs_control_head = FALSE;+#endif++if (ccend == NULL)+ {+ ccend = bracketend(cc) - (1 + LINK_SIZE);+ if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))+ {+ possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;+ /* This is correct regardless of common->capture_last_ptr. */+ capture_last_found = TRUE;+ }+ cc = next_opcode(common, cc);+ }++SLJIT_ASSERT(cc != NULL);+while (cc < ccend)+ switch(*cc)+ {+ case OP_SET_SOM:+ SLJIT_ASSERT(common->has_set_som);+ stack_restore = TRUE;+ if (!setsom_found)+ {+ length += 2;+ setsom_found = TRUE;+ }+ cc += 1;+ break;++ case OP_MARK:+ case OP_PRUNE_ARG:+ case OP_THEN_ARG:+ SLJIT_ASSERT(common->mark_ptr != 0);+ stack_restore = TRUE;+ if (!setmark_found)+ {+ length += 2;+ setmark_found = TRUE;+ }+ if (common->control_head_ptr != 0)+ *needs_control_head = TRUE;+ cc += 1 + 2 + cc[1];+ break;++ case OP_RECURSE:+ stack_restore = TRUE;+ if (common->has_set_som && !setsom_found)+ {+ length += 2;+ setsom_found = TRUE;+ }+ if (common->mark_ptr != 0 && !setmark_found)+ {+ length += 2;+ setmark_found = TRUE;+ }+ if (common->capture_last_ptr != 0 && !capture_last_found)+ {+ length += 2;+ capture_last_found = TRUE;+ }+ cc += 1 + LINK_SIZE;+ break;++ case OP_CBRA:+ case OP_CBRAPOS:+ case OP_SCBRA:+ case OP_SCBRAPOS:+ stack_restore = TRUE;+ if (common->capture_last_ptr != 0 && !capture_last_found)+ {+ length += 2;+ capture_last_found = TRUE;+ }+ length += 3;+ cc += 1 + LINK_SIZE + IMM2_SIZE;+ break;++ case OP_THEN:+ stack_restore = TRUE;+ if (common->control_head_ptr != 0)+ *needs_control_head = TRUE;+ cc ++;+ break;++ default:+ stack_restore = TRUE;+ /* Fall through. */++ case OP_NOT_WORD_BOUNDARY:+ case OP_WORD_BOUNDARY:+ case OP_NOT_DIGIT:+ case OP_DIGIT:+ case OP_NOT_WHITESPACE:+ case OP_WHITESPACE:+ case OP_NOT_WORDCHAR:+ case OP_WORDCHAR:+ case OP_ANY:+ case OP_ALLANY:+ case OP_ANYBYTE:+ case OP_NOTPROP:+ case OP_PROP:+ case OP_ANYNL:+ case OP_NOT_HSPACE:+ case OP_HSPACE:+ case OP_NOT_VSPACE:+ case OP_VSPACE:+ case OP_EXTUNI:+ case OP_EODN:+ case OP_EOD:+ case OP_CIRC:+ case OP_CIRCM:+ case OP_DOLL:+ case OP_DOLLM:+ case OP_CHAR:+ case OP_CHARI:+ case OP_NOT:+ case OP_NOTI:++ case OP_EXACT:+ case OP_POSSTAR:+ case OP_POSPLUS:+ case OP_POSQUERY:+ case OP_POSUPTO:++ case OP_EXACTI:+ case OP_POSSTARI:+ case OP_POSPLUSI:+ case OP_POSQUERYI:+ case OP_POSUPTOI:++ case OP_NOTEXACT:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSUPTO:++ case OP_NOTEXACTI:+ case OP_NOTPOSSTARI:+ case OP_NOTPOSPLUSI:+ case OP_NOTPOSQUERYI:+ case OP_NOTPOSUPTOI:++ case OP_TYPEEXACT:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSPLUS:+ case OP_TYPEPOSQUERY:+ case OP_TYPEPOSUPTO:++ case OP_CLASS:+ case OP_NCLASS:+ case OP_XCLASS:+ case OP_CALLOUT:++ cc = next_opcode(common, cc);+ SLJIT_ASSERT(cc != NULL);+ break;+ }++/* Possessive quantifiers can use a special case. */+if (SLJIT_UNLIKELY(possessive == length))+ return stack_restore ? no_frame : no_stack;++if (length > 0)+ return length + 1;+return stack_restore ? no_frame : no_stack;+}++static void init_frame(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, int stackpos, int stacktop, BOOL recursive)+{+DEFINE_COMPILER;+BOOL setsom_found = recursive;+BOOL setmark_found = recursive;+/* The last capture is a local variable even for recursions. */+BOOL capture_last_found = FALSE;+int offset;++/* >= 1 + shortest item size (2) */+SLJIT_UNUSED_ARG(stacktop);+SLJIT_ASSERT(stackpos >= stacktop + 2);++stackpos = STACK(stackpos);+if (ccend == NULL)+ {+ ccend = bracketend(cc) - (1 + LINK_SIZE);+ if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))+ cc = next_opcode(common, cc);+ }++SLJIT_ASSERT(cc != NULL);+while (cc < ccend)+ switch(*cc)+ {+ case OP_SET_SOM:+ SLJIT_ASSERT(common->has_set_som);+ if (!setsom_found)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));+ stackpos -= (int)sizeof(sljit_sw);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);+ stackpos -= (int)sizeof(sljit_sw);+ setsom_found = TRUE;+ }+ cc += 1;+ break;++ case OP_MARK:+ case OP_PRUNE_ARG:+ case OP_THEN_ARG:+ SLJIT_ASSERT(common->mark_ptr != 0);+ if (!setmark_found)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);+ stackpos -= (int)sizeof(sljit_sw);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);+ stackpos -= (int)sizeof(sljit_sw);+ setmark_found = TRUE;+ }+ cc += 1 + 2 + cc[1];+ break;++ case OP_RECURSE:+ if (common->has_set_som && !setsom_found)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));+ stackpos -= (int)sizeof(sljit_sw);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);+ stackpos -= (int)sizeof(sljit_sw);+ setsom_found = TRUE;+ }+ if (common->mark_ptr != 0 && !setmark_found)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);+ stackpos -= (int)sizeof(sljit_sw);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);+ stackpos -= (int)sizeof(sljit_sw);+ setmark_found = TRUE;+ }+ if (common->capture_last_ptr != 0 && !capture_last_found)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);+ stackpos -= (int)sizeof(sljit_sw);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);+ stackpos -= (int)sizeof(sljit_sw);+ capture_last_found = TRUE;+ }+ cc += 1 + LINK_SIZE;+ break;++ case OP_CBRA:+ case OP_CBRAPOS:+ case OP_SCBRA:+ case OP_SCBRAPOS:+ if (common->capture_last_ptr != 0 && !capture_last_found)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);+ stackpos -= (int)sizeof(sljit_sw);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);+ stackpos -= (int)sizeof(sljit_sw);+ capture_last_found = TRUE;+ }+ offset = (GET2(cc, 1 + LINK_SIZE)) << 1;+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));+ stackpos -= (int)sizeof(sljit_sw);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);+ stackpos -= (int)sizeof(sljit_sw);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);+ stackpos -= (int)sizeof(sljit_sw);++ cc += 1 + LINK_SIZE + IMM2_SIZE;+ break;++ default:+ cc = next_opcode(common, cc);+ SLJIT_ASSERT(cc != NULL);+ break;+ }++OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0);+SLJIT_ASSERT(stackpos == STACK(stacktop));+}++static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)+{+int private_data_length = needs_control_head ? 3 : 2;+int size;+pcre_uchar *alternative;+/* Calculate the sum of the private machine words. */+while (cc < ccend)+ {+ size = 0;+ switch(*cc)+ {+ case OP_KET:+ if (PRIVATE_DATA(cc) != 0)+ {+ private_data_length++;+ SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);+ cc += PRIVATE_DATA(cc + 1);+ }+ cc += 1 + LINK_SIZE;+ break;++ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_BRAPOS:+ case OP_SBRA:+ case OP_SBRAPOS:+ case OP_SCOND:+ private_data_length++;+ SLJIT_ASSERT(PRIVATE_DATA(cc) != 0);+ cc += 1 + LINK_SIZE;+ break;++ case OP_CBRA:+ case OP_SCBRA:+ if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)+ private_data_length++;+ cc += 1 + LINK_SIZE + IMM2_SIZE;+ break;++ case OP_CBRAPOS:+ case OP_SCBRAPOS:+ private_data_length += 2;+ cc += 1 + LINK_SIZE + IMM2_SIZE;+ break;++ case OP_COND:+ /* Might be a hidden SCOND. */+ alternative = cc + GET(cc, 1);+ if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)+ private_data_length++;+ cc += 1 + LINK_SIZE;+ break;++ CASE_ITERATOR_PRIVATE_DATA_1+ if (PRIVATE_DATA(cc))+ private_data_length++;+ cc += 2;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ break;++ CASE_ITERATOR_PRIVATE_DATA_2A+ if (PRIVATE_DATA(cc))+ private_data_length += 2;+ cc += 2;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ break;++ CASE_ITERATOR_PRIVATE_DATA_2B+ if (PRIVATE_DATA(cc))+ private_data_length += 2;+ cc += 2 + IMM2_SIZE;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ break;++ CASE_ITERATOR_TYPE_PRIVATE_DATA_1+ if (PRIVATE_DATA(cc))+ private_data_length++;+ cc += 1;+ break;++ CASE_ITERATOR_TYPE_PRIVATE_DATA_2A+ if (PRIVATE_DATA(cc))+ private_data_length += 2;+ cc += 1;+ break;++ CASE_ITERATOR_TYPE_PRIVATE_DATA_2B+ if (PRIVATE_DATA(cc))+ private_data_length += 2;+ cc += 1 + IMM2_SIZE;+ break;++ case OP_CLASS:+ case OP_NCLASS:+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);+#else+ size = 1 + 32 / (int)sizeof(pcre_uchar);+#endif+ if (PRIVATE_DATA(cc))+ private_data_length += get_class_iterator_size(cc + size);+ cc += size;+ break;++ default:+ cc = next_opcode(common, cc);+ SLJIT_ASSERT(cc != NULL);+ break;+ }+ }+SLJIT_ASSERT(cc == ccend);+return private_data_length;+}++static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,+ BOOL save, int stackptr, int stacktop, BOOL needs_control_head)+{+DEFINE_COMPILER;+int srcw[2];+int count, size;+BOOL tmp1next = TRUE;+BOOL tmp1empty = TRUE;+BOOL tmp2empty = TRUE;+pcre_uchar *alternative;+enum {+ loop,+ end+} status;++status = loop;+stackptr = STACK(stackptr);+stacktop = STACK(stacktop - 1);++if (!save)+ {+ stacktop -= (needs_control_head ? 2 : 1) * sizeof(sljit_sw);+ if (stackptr < stacktop)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);+ stackptr += sizeof(sljit_sw);+ tmp1empty = FALSE;+ }+ if (stackptr < stacktop)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);+ stackptr += sizeof(sljit_sw);+ tmp2empty = FALSE;+ }+ /* The tmp1next must be TRUE in either way. */+ }++SLJIT_ASSERT(common->recursive_head_ptr != 0);++do+ {+ count = 0;+ if (cc >= ccend)+ {+ if (!save)+ break;++ count = 1;+ srcw[0] = common->recursive_head_ptr;+ if (needs_control_head)+ {+ SLJIT_ASSERT(common->control_head_ptr != 0);+ count = 2;+ srcw[0] = common->control_head_ptr;+ srcw[1] = common->recursive_head_ptr;+ }+ status = end;+ }+ else switch(*cc)+ {+ case OP_KET:+ if (PRIVATE_DATA(cc) != 0)+ {+ count = 1;+ srcw[0] = PRIVATE_DATA(cc);+ SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);+ cc += PRIVATE_DATA(cc + 1);+ }+ cc += 1 + LINK_SIZE;+ break;++ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_BRAPOS:+ case OP_SBRA:+ case OP_SBRAPOS:+ case OP_SCOND:+ count = 1;+ srcw[0] = PRIVATE_DATA(cc);+ SLJIT_ASSERT(srcw[0] != 0);+ cc += 1 + LINK_SIZE;+ break;++ case OP_CBRA:+ case OP_SCBRA:+ if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)+ {+ count = 1;+ srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));+ }+ cc += 1 + LINK_SIZE + IMM2_SIZE;+ break;++ case OP_CBRAPOS:+ case OP_SCBRAPOS:+ count = 2;+ srcw[0] = PRIVATE_DATA(cc);+ srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));+ SLJIT_ASSERT(srcw[0] != 0 && srcw[1] != 0);+ cc += 1 + LINK_SIZE + IMM2_SIZE;+ break;++ case OP_COND:+ /* Might be a hidden SCOND. */+ alternative = cc + GET(cc, 1);+ if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)+ {+ count = 1;+ srcw[0] = PRIVATE_DATA(cc);+ SLJIT_ASSERT(srcw[0] != 0);+ }+ cc += 1 + LINK_SIZE;+ break;++ CASE_ITERATOR_PRIVATE_DATA_1+ if (PRIVATE_DATA(cc))+ {+ count = 1;+ srcw[0] = PRIVATE_DATA(cc);+ }+ cc += 2;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ break;++ CASE_ITERATOR_PRIVATE_DATA_2A+ if (PRIVATE_DATA(cc))+ {+ count = 2;+ srcw[0] = PRIVATE_DATA(cc);+ srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);+ }+ cc += 2;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ break;++ CASE_ITERATOR_PRIVATE_DATA_2B+ if (PRIVATE_DATA(cc))+ {+ count = 2;+ srcw[0] = PRIVATE_DATA(cc);+ srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);+ }+ cc += 2 + IMM2_SIZE;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);+#endif+ break;++ CASE_ITERATOR_TYPE_PRIVATE_DATA_1+ if (PRIVATE_DATA(cc))+ {+ count = 1;+ srcw[0] = PRIVATE_DATA(cc);+ }+ cc += 1;+ break;++ CASE_ITERATOR_TYPE_PRIVATE_DATA_2A+ if (PRIVATE_DATA(cc))+ {+ count = 2;+ srcw[0] = PRIVATE_DATA(cc);+ srcw[1] = srcw[0] + sizeof(sljit_sw);+ }+ cc += 1;+ break;++ CASE_ITERATOR_TYPE_PRIVATE_DATA_2B+ if (PRIVATE_DATA(cc))+ {+ count = 2;+ srcw[0] = PRIVATE_DATA(cc);+ srcw[1] = srcw[0] + sizeof(sljit_sw);+ }+ cc += 1 + IMM2_SIZE;+ break;++ case OP_CLASS:+ case OP_NCLASS:+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);+#else+ size = 1 + 32 / (int)sizeof(pcre_uchar);+#endif+ if (PRIVATE_DATA(cc))+ switch(get_class_iterator_size(cc + size))+ {+ case 1:+ count = 1;+ srcw[0] = PRIVATE_DATA(cc);+ break;++ case 2:+ count = 2;+ srcw[0] = PRIVATE_DATA(cc);+ srcw[1] = srcw[0] + sizeof(sljit_sw);+ break;++ default:+ SLJIT_UNREACHABLE();+ break;+ }+ cc += size;+ break;++ default:+ cc = next_opcode(common, cc);+ SLJIT_ASSERT(cc != NULL);+ break;+ }++ while (count > 0)+ {+ count--;+ if (save)+ {+ if (tmp1next)+ {+ if (!tmp1empty)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);+ stackptr += sizeof(sljit_sw);+ }+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);+ tmp1empty = FALSE;+ tmp1next = FALSE;+ }+ else+ {+ if (!tmp2empty)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);+ stackptr += sizeof(sljit_sw);+ }+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);+ tmp2empty = FALSE;+ tmp1next = TRUE;+ }+ }+ else+ {+ if (tmp1next)+ {+ SLJIT_ASSERT(!tmp1empty);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP1, 0);+ tmp1empty = stackptr >= stacktop;+ if (!tmp1empty)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);+ stackptr += sizeof(sljit_sw);+ }+ tmp1next = FALSE;+ }+ else+ {+ SLJIT_ASSERT(!tmp2empty);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP2, 0);+ tmp2empty = stackptr >= stacktop;+ if (!tmp2empty)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);+ stackptr += sizeof(sljit_sw);+ }+ tmp1next = TRUE;+ }+ }+ }+ }+while (status != end);++if (save)+ {+ if (tmp1next)+ {+ if (!tmp1empty)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);+ stackptr += sizeof(sljit_sw);+ }+ if (!tmp2empty)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);+ stackptr += sizeof(sljit_sw);+ }+ }+ else+ {+ if (!tmp2empty)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);+ stackptr += sizeof(sljit_sw);+ }+ if (!tmp1empty)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);+ stackptr += sizeof(sljit_sw);+ }+ }+ }+SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));+}++static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, sljit_u8 *current_offset)+{+pcre_uchar *end = bracketend(cc);+BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;++/* Assert captures then. */+if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)+ current_offset = NULL;+/* Conditional block does not. */+if (*cc == OP_COND || *cc == OP_SCOND)+ has_alternatives = FALSE;++cc = next_opcode(common, cc);+if (has_alternatives)+ current_offset = common->then_offsets + (cc - common->start);++while (cc < end)+ {+ if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))+ cc = set_then_offsets(common, cc, current_offset);+ else+ {+ if (*cc == OP_ALT && has_alternatives)+ current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);+ if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)+ *current_offset = 1;+ cc = next_opcode(common, cc);+ }+ }++return end;+}++#undef CASE_ITERATOR_PRIVATE_DATA_1+#undef CASE_ITERATOR_PRIVATE_DATA_2A+#undef CASE_ITERATOR_PRIVATE_DATA_2B+#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_1+#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2A+#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2B++static SLJIT_INLINE BOOL is_powerof2(unsigned int value)+{+return (value & (value - 1)) == 0;+}++static SLJIT_INLINE void set_jumps(jump_list *list, struct sljit_label *label)+{+while (list)+ {+ /* sljit_set_label is clever enough to do nothing+ if either the jump or the label is NULL. */+ SET_LABEL(list->jump, label);+ list = list->next;+ }+}++static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump *jump)+{+jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));+if (list_item)+ {+ list_item->next = *list;+ list_item->jump = jump;+ *list = list_item;+ }+}++static void add_stub(compiler_common *common, struct sljit_jump *start)+{+DEFINE_COMPILER;+stub_list *list_item = sljit_alloc_memory(compiler, sizeof(stub_list));++if (list_item)+ {+ list_item->start = start;+ list_item->quit = LABEL();+ list_item->next = common->stubs;+ common->stubs = list_item;+ }+}++static void flush_stubs(compiler_common *common)+{+DEFINE_COMPILER;+stub_list *list_item = common->stubs;++while (list_item)+ {+ JUMPHERE(list_item->start);+ add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));+ JUMPTO(SLJIT_JUMP, list_item->quit);+ list_item = list_item->next;+ }+common->stubs = NULL;+}++static void add_label_addr(compiler_common *common, sljit_uw *update_addr)+{+DEFINE_COMPILER;+label_addr_list *label_addr;++label_addr = sljit_alloc_memory(compiler, sizeof(label_addr_list));+if (label_addr == NULL)+ return;+label_addr->label = LABEL();+label_addr->update_addr = update_addr;+label_addr->next = common->label_addrs;+common->label_addrs = label_addr;+}++static SLJIT_INLINE void count_match(compiler_common *common)+{+DEFINE_COMPILER;++OP2(SLJIT_SUB | SLJIT_SET_Z, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);+add_jump(compiler, &common->calllimit, JUMP(SLJIT_ZERO));+}++static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)+{+/* May destroy all locals and registers except TMP2. */+DEFINE_COMPILER;++SLJIT_ASSERT(size > 0);+OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));+#ifdef DESTROY_REGISTERS+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);+OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);+OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, TMP1, 0);+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);+#endif+add_stub(common, CMP(SLJIT_LESS, STACK_TOP, 0, STACK_LIMIT, 0));+}++static SLJIT_INLINE void free_stack(compiler_common *common, int size)+{+DEFINE_COMPILER;++SLJIT_ASSERT(size > 0);+OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));+}++static sljit_uw * allocate_read_only_data(compiler_common *common, sljit_uw size)+{+DEFINE_COMPILER;+sljit_uw *result;++if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return NULL;++result = (sljit_uw *)SLJIT_MALLOC(size + sizeof(sljit_uw), compiler->allocator_data);+if (SLJIT_UNLIKELY(result == NULL))+ {+ sljit_set_compiler_memory_error(compiler);+ return NULL;+ }++*(void**)result = common->read_only_data_head;+common->read_only_data_head = (void *)result;+return result + 1;+}++static void free_read_only_data(void *current, void *allocator_data)+{+void *next;++SLJIT_UNUSED_ARG(allocator_data);++while (current != NULL)+ {+ next = *(void**)current;+ SLJIT_FREE(current, allocator_data);+ current = next;+ }+}++static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)+{+DEFINE_COMPILER;+struct sljit_label *loop;+int i;++/* At this point we can freely use all temporary registers. */+SLJIT_ASSERT(length > 1);+/* TMP1 returns with begin - 1. */+OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));+if (length < 8)+ {+ for (i = 1; i < length; i++)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), SLJIT_R0, 0);+ }+else+ {+ if (sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw)) == SLJIT_SUCCESS)+ {+ GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START);+ OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1);+ loop = LABEL();+ sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw));+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, loop);+ }+ else+ {+ GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START + sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1);+ loop = LABEL();+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);+ OP2(SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, loop);+ }+ }+}++static SLJIT_INLINE void reset_fast_fail(compiler_common *common)+{+DEFINE_COMPILER;+sljit_s32 i;++SLJIT_ASSERT(common->fast_fail_start_ptr < common->fast_fail_end_ptr);++OP2(SLJIT_SUB, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+for (i = common->fast_fail_start_ptr; i < common->fast_fail_end_ptr; i += sizeof(sljit_sw))+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), i, TMP1, 0);+}++static SLJIT_INLINE void do_reset_match(compiler_common *common, int length)+{+DEFINE_COMPILER;+struct sljit_label *loop;+int i;++SLJIT_ASSERT(length > 1);+/* OVECTOR(1) contains the "string begin - 1" constant. */+if (length > 2)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));+if (length < 8)+ {+ for (i = 2; i < length; i++)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), TMP1, 0);+ }+else+ {+ if (sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, TMP1, SLJIT_MEM1(TMP2), sizeof(sljit_sw)) == SLJIT_SUCCESS)+ {+ GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw));+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);+ loop = LABEL();+ sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_PRE, TMP1, SLJIT_MEM1(TMP2), sizeof(sljit_sw));+ OP2(SLJIT_SUB | SLJIT_SET_Z, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, loop);+ }+ else+ {+ GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + 2 * sizeof(sljit_sw));+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);+ loop = LABEL();+ OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, TMP1, 0);+ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, sizeof(sljit_sw));+ OP2(SLJIT_SUB | SLJIT_SET_Z, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, loop);+ }+ }++OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);+if (common->mark_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0);+if (common->control_head_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_ptr);+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, end));+}++static sljit_sw SLJIT_FUNC do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)+{+while (current != NULL)+ {+ switch (current[1])+ {+ case type_then_trap:+ break;++ case type_mark:+ if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[2]) == 0)+ return current[3];+ break;++ default:+ SLJIT_UNREACHABLE();+ break;+ }+ SLJIT_ASSERT(current[0] == 0 || current < (sljit_sw*)current[0]);+ current = (sljit_sw*)current[0];+ }+return 0;+}++static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)+{+DEFINE_COMPILER;+struct sljit_label *loop;+struct sljit_jump *early_quit;+BOOL has_pre;++/* At this point we can freely use all registers. */+OP1(SLJIT_MOV, SLJIT_S2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(1), STR_PTR, 0);++OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0);+if (common->mark_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);+OP1(SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offset_count));+if (common->mark_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_R2, 0);+OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));+OP1(SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, begin));++has_pre = sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_S1, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw)) == SLJIT_SUCCESS;+GET_LOCAL_BASE(SLJIT_S0, 0, OVECTOR_START - (has_pre ? sizeof(sljit_sw) : 0));++/* Unlikely, but possible */+early_quit = CMP(SLJIT_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0);+loop = LABEL();++if (has_pre)+ sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_PRE, SLJIT_S1, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));+else+ {+ OP1(SLJIT_MOV, SLJIT_S1, 0, SLJIT_MEM1(SLJIT_S0), 0);+ OP2(SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_sw));+ }++OP2(SLJIT_ADD, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, sizeof(int));+OP2(SLJIT_SUB, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_R0, 0);+/* Copy the integer value to the output buffer */+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32+OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);+#endif++OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R2), 0, SLJIT_S1, 0);+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);+JUMPTO(SLJIT_NOT_ZERO, loop);+JUMPHERE(early_quit);++/* Calculate the return value, which is the maximum ovector value. */+if (topbracket > 1)+ {+ if (sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R2, SLJIT_MEM1(SLJIT_R0), -(2 * (sljit_sw)sizeof(sljit_sw))) == SLJIT_SUCCESS)+ {+ GET_LOCAL_BASE(SLJIT_R0, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, topbracket + 1);++ /* OVECTOR(0) is never equal to SLJIT_S2. */+ loop = LABEL();+ sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_PRE, SLJIT_R2, SLJIT_MEM1(SLJIT_R0), -(2 * (sljit_sw)sizeof(sljit_sw)));+ OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);+ CMPTO(SLJIT_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop);+ }+ else+ {+ GET_LOCAL_BASE(SLJIT_R0, 0, OVECTOR_START + (topbracket - 1) * 2 * sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, topbracket + 1);++ /* OVECTOR(0) is never equal to SLJIT_S2. */+ loop = LABEL();+ OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), 0);+ OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2 * (sljit_sw)sizeof(sljit_sw));+ OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);+ CMPTO(SLJIT_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop);+ }+ OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_R1, 0);+ }+else+ OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);+}++static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)+{+DEFINE_COMPILER;+struct sljit_jump *jump;++SLJIT_COMPILE_ASSERT(STR_END == SLJIT_S1, str_end_must_be_saved_reg2);+SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0+ && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));++OP1(SLJIT_MOV, SLJIT_R1, 0, ARGUMENTS, 0);+OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);+OP1(SLJIT_MOV_S32, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, real_offset_count));+CMPTO(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 2, quit);++/* Store match begin and end. */+OP1(SLJIT_MOV, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, begin));+OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, offsets));++jump = CMP(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 3);+OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + (int)sizeof(sljit_sw)), SLJIT_S0, 0);+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32+OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);+#endif+OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(int), SLJIT_R2, 0);+JUMPHERE(jump);++OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);+OP2(SLJIT_SUB, SLJIT_S1, 0, STR_END, 0, SLJIT_S0, 0);+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32+OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);+#endif+OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), sizeof(int), SLJIT_S1, 0);++OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_S0, 0);+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32+OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);+#endif+OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);++JUMPTO(SLJIT_JUMP, quit);+}++static SLJIT_INLINE void check_start_used_ptr(compiler_common *common)+{+/* May destroy TMP1. */+DEFINE_COMPILER;+struct sljit_jump *jump;++if (common->mode == JIT_PARTIAL_SOFT_COMPILE)+ {+ /* The value of -1 must be kept for start_used_ptr! */+ OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, 1);+ /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting+ is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */+ jump = CMP(SLJIT_LESS_EQUAL, TMP1, 0, STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);+ JUMPHERE(jump);+ }+else if (common->mode == JIT_PARTIAL_HARD_COMPILE)+ {+ jump = CMP(SLJIT_LESS_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);+ JUMPHERE(jump);+ }+}++static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar *cc)+{+/* Detects if the character has an othercase. */+unsigned int c;++#ifdef SUPPORT_UTF+if (common->utf)+ {+ GETCHAR(c, cc);+ if (c > 127)+ {+#ifdef SUPPORT_UCP+ return c != UCD_OTHERCASE(c);+#else+ return FALSE;+#endif+ }+#ifndef COMPILE_PCRE8+ return common->fcc[c] != c;+#endif+ }+else+#endif+ c = *cc;+return MAX_255(c) ? common->fcc[c] != c : FALSE;+}++static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigned int c)+{+/* Returns with the othercase. */+#ifdef SUPPORT_UTF+if (common->utf && c > 127)+ {+#ifdef SUPPORT_UCP+ return UCD_OTHERCASE(c);+#else+ return c;+#endif+ }+#endif+return TABLE_GET(c, common->fcc, c);+}++static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar *cc)+{+/* Detects if the character and its othercase has only 1 bit difference. */+unsigned int c, oc, bit;+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+int n;+#endif++#ifdef SUPPORT_UTF+if (common->utf)+ {+ GETCHAR(c, cc);+ if (c <= 127)+ oc = common->fcc[c];+ else+ {+#ifdef SUPPORT_UCP+ oc = UCD_OTHERCASE(c);+#else+ oc = c;+#endif+ }+ }+else+ {+ c = *cc;+ oc = TABLE_GET(c, common->fcc, c);+ }+#else+c = *cc;+oc = TABLE_GET(c, common->fcc, c);+#endif++SLJIT_ASSERT(c != oc);++bit = c ^ oc;+/* Optimized for English alphabet. */+if (c <= 127 && bit == 0x20)+ return (0 << 8) | 0x20;++/* Since c != oc, they must have at least 1 bit difference. */+if (!is_powerof2(bit))+ return 0;++#if defined COMPILE_PCRE8++#ifdef SUPPORT_UTF+if (common->utf && c > 127)+ {+ n = GET_EXTRALEN(*cc);+ while ((bit & 0x3f) == 0)+ {+ n--;+ bit >>= 6;+ }+ return (n << 8) | bit;+ }+#endif /* SUPPORT_UTF */+return (0 << 8) | bit;++#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32++#ifdef SUPPORT_UTF+if (common->utf && c > 65535)+ {+ if (bit >= (1 << 10))+ bit >>= 10;+ else+ return (bit < 256) ? ((2 << 8) | bit) : ((3 << 8) | (bit >> 8));+ }+#endif /* SUPPORT_UTF */+return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));++#endif /* COMPILE_PCRE[8|16|32] */+}++static void check_partial(compiler_common *common, BOOL force)+{+/* Checks whether a partial matching is occurred. Does not modify registers. */+DEFINE_COMPILER;+struct sljit_jump *jump = NULL;++SLJIT_ASSERT(!force || common->mode != JIT_COMPILE);++if (common->mode == JIT_COMPILE)+ return;++if (!force)+ jump = CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);+else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)+ jump = CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1);++if (common->mode == JIT_PARTIAL_SOFT_COMPILE)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);+else+ {+ if (common->partialmatchlabel != NULL)+ JUMPTO(SLJIT_JUMP, common->partialmatchlabel);+ else+ add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));+ }++if (jump != NULL)+ JUMPHERE(jump);+}++static void check_str_end(compiler_common *common, jump_list **end_reached)+{+/* Does not affect registers. Usually used in a tight spot. */+DEFINE_COMPILER;+struct sljit_jump *jump;++if (common->mode == JIT_COMPILE)+ {+ add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));+ return;+ }++jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);+if (common->mode == JIT_PARTIAL_SOFT_COMPILE)+ {+ add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);+ add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));+ }+else+ {+ add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));+ if (common->partialmatchlabel != NULL)+ JUMPTO(SLJIT_JUMP, common->partialmatchlabel);+ else+ add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));+ }+JUMPHERE(jump);+}++static void detect_partial_match(compiler_common *common, jump_list **backtracks)+{+DEFINE_COMPILER;+struct sljit_jump *jump;++if (common->mode == JIT_COMPILE)+ {+ add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));+ return;+ }++/* Partial matching mode. */+jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);+add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));+if (common->mode == JIT_PARTIAL_SOFT_COMPILE)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);+ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));+ }+else+ {+ if (common->partialmatchlabel != NULL)+ JUMPTO(SLJIT_JUMP, common->partialmatchlabel);+ else+ add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));+ }+JUMPHERE(jump);+}++static void peek_char(compiler_common *common, sljit_u32 max)+{+/* Reads the character into TMP1, keeps STR_PTR.+Does not check STR_END. TMP2 Destroyed. */+DEFINE_COMPILER;+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+struct sljit_jump *jump;+#endif++SLJIT_UNUSED_ARG(max);++OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+if (common->utf)+ {+ if (max < 128) return;++ jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);+ JUMPHERE(jump);+ }+#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */++#if defined SUPPORT_UTF && defined COMPILE_PCRE16+if (common->utf)+ {+ if (max < 0xd800) return;++ OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);+ jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);+ /* TMP2 contains the high surrogate. */+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ JUMPHERE(jump);+ }+#endif+}++#if defined SUPPORT_UTF && defined COMPILE_PCRE8++static BOOL is_char7_bitset(const sljit_u8 *bitset, BOOL nclass)+{+/* Tells whether the character codes below 128 are enough+to determine a match. */+const sljit_u8 value = nclass ? 0xff : 0;+const sljit_u8 *end = bitset + 32;++bitset += 16;+do+ {+ if (*bitset++ != value)+ return FALSE;+ }+while (bitset < end);+return TRUE;+}++static void read_char7_type(compiler_common *common, BOOL full_read)+{+/* Reads the precise character type of a character into TMP1, if the character+is less than 128. Otherwise it returns with zero. Does not check STR_END. The+full_read argument tells whether characters above max are accepted or not. */+DEFINE_COMPILER;+struct sljit_jump *jump;++SLJIT_ASSERT(common->utf);++OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);++if (full_read)+ {+ jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);+ JUMPHERE(jump);+ }+}++#endif /* SUPPORT_UTF && COMPILE_PCRE8 */++static void read_char_range(compiler_common *common, sljit_u32 min, sljit_u32 max, BOOL update_str_ptr)+{+/* Reads the precise value of a character into TMP1, if the character is+between min and max (c >= min && c <= max). Otherwise it returns with a value+outside the range. Does not check STR_END. */+DEFINE_COMPILER;+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+struct sljit_jump *jump;+#endif+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+struct sljit_jump *jump2;+#endif++SLJIT_UNUSED_ARG(update_str_ptr);+SLJIT_UNUSED_ARG(min);+SLJIT_UNUSED_ARG(max);+SLJIT_ASSERT(min <= max);++OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++#if defined SUPPORT_UTF && defined COMPILE_PCRE8+if (common->utf)+ {+ if (max < 128 && !update_str_ptr) return;++ jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);+ if (min >= 0x10000)+ {+ OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xf0);+ if (update_str_ptr)+ OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x7);+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+ OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));+ if (!update_str_ptr)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+ OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ JUMPHERE(jump2);+ if (update_str_ptr)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);+ }+ else if (min >= 0x800 && max <= 0xffff)+ {+ OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xe0);+ if (update_str_ptr)+ OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xf);+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ if (!update_str_ptr)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+ OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ JUMPHERE(jump2);+ if (update_str_ptr)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);+ }+ else if (max >= 0x800)+ add_jump(compiler, (max < 0x10000) ? &common->utfreadchar16 : &common->utfreadchar, JUMP(SLJIT_FAST_CALL));+ else if (max < 128)+ {+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);+ }+ else+ {+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ if (!update_str_ptr)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ else+ OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+ OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ if (update_str_ptr)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);+ }+ JUMPHERE(jump);+ }+#endif++#if defined SUPPORT_UTF && defined COMPILE_PCRE16+if (common->utf)+ {+ if (max >= 0x10000)+ {+ OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);+ jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);+ /* TMP2 contains the high surrogate. */+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ JUMPHERE(jump);+ return;+ }++ if (max < 0xd800 && !update_str_ptr) return;++ /* Skip low surrogate if necessary. */+ OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);+ jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);+ if (update_str_ptr)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ if (max >= 0xd800)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000);+ JUMPHERE(jump);+ }+#endif+}++static SLJIT_INLINE void read_char(compiler_common *common)+{+read_char_range(common, 0, READ_CHAR_MAX, TRUE);+}++static void read_char8_type(compiler_common *common, BOOL update_str_ptr)+{+/* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */+DEFINE_COMPILER;+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+struct sljit_jump *jump;+#endif+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+struct sljit_jump *jump2;+#endif++SLJIT_UNUSED_ARG(update_str_ptr);++OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++#if defined SUPPORT_UTF && defined COMPILE_PCRE8+if (common->utf)+ {+ /* This can be an extra read in some situations, but hopefully+ it is needed in most cases. */+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);+ jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);+ if (!update_str_ptr)+ {+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);+ OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);+ jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);+ JUMPHERE(jump2);+ }+ else+ add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));+ JUMPHERE(jump);+ return;+ }+#endif /* SUPPORT_UTF && COMPILE_PCRE8 */++#if !defined COMPILE_PCRE8+/* The ctypes array contains only 256 values. */+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);+jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);+#endif+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);+#if !defined COMPILE_PCRE8+JUMPHERE(jump);+#endif++#if defined SUPPORT_UTF && defined COMPILE_PCRE16+if (common->utf && update_str_ptr)+ {+ /* Skip low surrogate if necessary. */+ OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800);+ jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ JUMPHERE(jump);+ }+#endif /* SUPPORT_UTF && COMPILE_PCRE16 */+}++static void skip_char_back(compiler_common *common)+{+/* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */+DEFINE_COMPILER;+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+#if defined COMPILE_PCRE8+struct sljit_label *label;++if (common->utf)+ {+ label = LABEL();+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);+ return;+ }+#elif defined COMPILE_PCRE16+if (common->utf)+ {+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ /* Skip low surrogate if necessary. */+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);+ OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+ return;+ }+#endif /* COMPILE_PCRE[8|16] */+#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */+OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+}++static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpifmatch)+{+/* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */+DEFINE_COMPILER;+struct sljit_jump *jump;++if (nltype == NLTYPE_ANY)+ {+ add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));+ sljit_set_current_flags(compiler, SLJIT_SET_Z);+ add_jump(compiler, backtracks, JUMP(jumpifmatch ? SLJIT_NOT_ZERO : SLJIT_ZERO));+ }+else if (nltype == NLTYPE_ANYCRLF)+ {+ if (jumpifmatch)+ {+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR));+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));+ }+ else+ {+ jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));+ JUMPHERE(jump);+ }+ }+else+ {+ SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);+ add_jump(compiler, backtracks, CMP(jumpifmatch ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));+ }+}++#ifdef SUPPORT_UTF++#if defined COMPILE_PCRE8+static void do_utfreadchar(compiler_common *common)+{+/* Fast decoding a UTF-8 character. TMP1 contains the first byte+of the character (>= 0xc0). Return char value in TMP1, length in TMP2. */+DEFINE_COMPILER;+struct sljit_jump *jump;++sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);++/* Searching for the first zero. */+OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);+jump = JUMP(SLJIT_NOT_ZERO);+/* Two byte sequence. */+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);++JUMPHERE(jump);+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);++OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10000);+jump = JUMP(SLJIT_NOT_ZERO);+/* Three byte sequence. */+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);++/* Four byte sequence. */+JUMPHERE(jump);+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));+OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(4));+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);+}++static void do_utfreadchar16(compiler_common *common)+{+/* Fast decoding a UTF-8 character. TMP1 contains the first byte+of the character (>= 0xc0). Return value in TMP1. */+DEFINE_COMPILER;+struct sljit_jump *jump;++sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);++/* Searching for the first zero. */+OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);+jump = JUMP(SLJIT_NOT_ZERO);+/* Two byte sequence. */+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);++JUMPHERE(jump);+OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x400);+OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_NOT_ZERO);+/* This code runs only in 8 bit mode. No need to shift the value. */+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+/* Three byte sequence. */+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);+}++static void do_utfreadtype8(compiler_common *common)+{+/* Fast decoding a UTF-8 character type. TMP2 contains the first byte+of the character (>= 0xc0). Return value in TMP1. */+DEFINE_COMPILER;+struct sljit_jump *jump;+struct sljit_jump *compare;++sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);++OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);+jump = JUMP(SLJIT_NOT_ZERO);+/* Two byte sequence. */+OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);+/* The upper 5 bits are known at this point. */+compare = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x3);+OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);+OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);+OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);++JUMPHERE(compare);+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);++/* We only have types for characters less than 256. */+JUMPHERE(jump);+OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);+}++#endif /* COMPILE_PCRE8 */++#endif /* SUPPORT_UTF */++#ifdef SUPPORT_UCP++/* UCD_BLOCK_SIZE must be 128 (see the assert below). */+#define UCD_BLOCK_MASK 127+#define UCD_BLOCK_SHIFT 7++static void do_getucd(compiler_common *common)+{+/* Search the UCD record for the character comes in TMP1.+Returns chartype in TMP1 and UCD offset in TMP2. */+DEFINE_COMPILER;+#ifdef COMPILE_PCRE32+struct sljit_jump *jump;+#endif++#if defined SLJIT_DEBUG && SLJIT_DEBUG+/* dummy_ucd_record */+const ucd_record *record = GET_UCD(INVALID_UTF_CHAR);+SLJIT_ASSERT(record->script == ucp_Common && record->chartype == ucp_Cn && record->gbprop == ucp_gbOther);+SLJIT_ASSERT(record->caseset == 0 && record->other_case == 0);+#endif++SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8);++sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);++#ifdef COMPILE_PCRE32+if (!common->utf)+ {+ jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0x10ffff + 1);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);+ JUMPHERE(jump);+ }+#endif++OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);+OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1));+OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);+OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);+OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2));+OP1(SLJIT_MOV_U16, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);+}+#endif++static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf)+{+DEFINE_COMPILER;+struct sljit_label *mainloop;+struct sljit_label *newlinelabel = NULL;+struct sljit_jump *start;+struct sljit_jump *end = NULL;+struct sljit_jump *end2 = NULL;+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+struct sljit_jump *singlechar;+#endif+jump_list *newline = NULL;+BOOL newlinecheck = FALSE;+BOOL readuchar = FALSE;++if (!(hascrorlf || (common->match_end_ptr != 0)) &&+ (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF || common->newline > 255))+ newlinecheck = TRUE;++if (common->match_end_ptr != 0)+ {+ /* Search for the end of the first line. */+ OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);++ if (common->nltype == NLTYPE_FIXED && common->newline > 255)+ {+ mainloop = LABEL();+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);+ CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);+ JUMPHERE(end);+ OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ }+ else+ {+ end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+ mainloop = LABEL();+ /* Continual stores does not cause data dependency. */+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0);+ read_char_range(common, common->nlmin, common->nlmax, TRUE);+ check_newlinechar(common, common->nltype, &newline, TRUE);+ CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, mainloop);+ JUMPHERE(end);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0);+ set_jumps(newline, LABEL());+ }++ OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);+ }++start = JUMP(SLJIT_JUMP);++if (newlinecheck)+ {+ newlinelabel = LABEL();+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);+ OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);+#endif+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+ end2 = JUMP(SLJIT_JUMP);+ }++mainloop = LABEL();++/* Increasing the STR_PTR here requires one less jump in the most common case. */+#ifdef SUPPORT_UTF+if (common->utf) readuchar = TRUE;+#endif+if (newlinecheck) readuchar = TRUE;++if (readuchar)+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);++if (newlinecheck)+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);++OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+#if defined COMPILE_PCRE8+if (common->utf)+ {+ singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+ JUMPHERE(singlechar);+ }+#elif defined COMPILE_PCRE16+if (common->utf)+ {+ singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);+ OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+ JUMPHERE(singlechar);+ }+#endif /* COMPILE_PCRE[8|16] */+#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */+JUMPHERE(start);++if (newlinecheck)+ {+ JUMPHERE(end);+ JUMPHERE(end2);+ }++return mainloop;+}++#define MAX_N_CHARS 16+#define MAX_DIFF_CHARS 6++static SLJIT_INLINE void add_prefix_char(pcre_uchar chr, pcre_uchar *chars)+{+pcre_uchar i, len;++len = chars[0];+if (len == 255)+ return;++if (len == 0)+ {+ chars[0] = 1;+ chars[1] = chr;+ return;+ }++for (i = len; i > 0; i--)+ if (chars[i] == chr)+ return;++if (len >= MAX_DIFF_CHARS - 1)+ {+ chars[0] = 255;+ return;+ }++len++;+chars[len] = chr;+chars[0] = len;+}++static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uchar *chars, int max_chars, sljit_u32 *rec_count)+{+/* Recursive function, which scans prefix literals. */+BOOL last, any, class, caseless;+int len, repeat, len_save, consumed = 0;+sljit_u32 chr; /* Any unicode character. */+sljit_u8 *bytes, *bytes_end, byte;+pcre_uchar *alternative, *cc_save, *oc;+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+pcre_uchar othercase[8];+#elif defined SUPPORT_UTF && defined COMPILE_PCRE16+pcre_uchar othercase[2];+#else+pcre_uchar othercase[1];+#endif++repeat = 1;+while (TRUE)+ {+ if (*rec_count == 0)+ return 0;+ (*rec_count)--;++ last = TRUE;+ any = FALSE;+ class = FALSE;+ caseless = FALSE;++ switch (*cc)+ {+ case OP_CHARI:+ caseless = TRUE;+ case OP_CHAR:+ last = FALSE;+ cc++;+ break;++ case OP_SOD:+ case OP_SOM:+ case OP_SET_SOM:+ case OP_NOT_WORD_BOUNDARY:+ case OP_WORD_BOUNDARY:+ case OP_EODN:+ case OP_EOD:+ case OP_CIRC:+ case OP_CIRCM:+ case OP_DOLL:+ case OP_DOLLM:+ /* Zero width assertions. */+ cc++;+ continue;++ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ cc = bracketend(cc);+ continue;++ case OP_PLUSI:+ case OP_MINPLUSI:+ case OP_POSPLUSI:+ caseless = TRUE;+ case OP_PLUS:+ case OP_MINPLUS:+ case OP_POSPLUS:+ cc++;+ break;++ case OP_EXACTI:+ caseless = TRUE;+ case OP_EXACT:+ repeat = GET2(cc, 1);+ last = FALSE;+ cc += 1 + IMM2_SIZE;+ break;++ case OP_QUERYI:+ case OP_MINQUERYI:+ case OP_POSQUERYI:+ caseless = TRUE;+ case OP_QUERY:+ case OP_MINQUERY:+ case OP_POSQUERY:+ len = 1;+ cc++;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);+#endif+ max_chars = scan_prefix(common, cc + len, chars, max_chars, rec_count);+ if (max_chars == 0)+ return consumed;+ last = FALSE;+ break;++ case OP_KET:+ cc += 1 + LINK_SIZE;+ continue;++ case OP_ALT:+ cc += GET(cc, 1);+ continue;++ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_BRA:+ case OP_BRAPOS:+ case OP_CBRA:+ case OP_CBRAPOS:+ alternative = cc + GET(cc, 1);+ while (*alternative == OP_ALT)+ {+ max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, max_chars, rec_count);+ if (max_chars == 0)+ return consumed;+ alternative += GET(alternative, 1);+ }++ if (*cc == OP_CBRA || *cc == OP_CBRAPOS)+ cc += IMM2_SIZE;+ cc += 1 + LINK_SIZE;+ continue;++ case OP_CLASS:+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (common->utf && !is_char7_bitset((const sljit_u8 *)(cc + 1), FALSE))+ return consumed;+#endif+ class = TRUE;+ break;++ case OP_NCLASS:+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (common->utf) return consumed;+#endif+ class = TRUE;+ break;++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (common->utf) return consumed;+#endif+ any = TRUE;+ cc += GET(cc, 1);+ break;+#endif++ case OP_DIGIT:+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_digit, FALSE))+ return consumed;+#endif+ any = TRUE;+ cc++;+ break;++ case OP_WHITESPACE:+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_space, FALSE))+ return consumed;+#endif+ any = TRUE;+ cc++;+ break;++ case OP_WORDCHAR:+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_word, FALSE))+ return consumed;+#endif+ any = TRUE;+ cc++;+ break;++ case OP_NOT:+ case OP_NOTI:+ cc++;+ /* Fall through. */+ case OP_NOT_DIGIT:+ case OP_NOT_WHITESPACE:+ case OP_NOT_WORDCHAR:+ case OP_ANY:+ case OP_ALLANY:+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (common->utf) return consumed;+#endif+ any = TRUE;+ cc++;+ break;++#ifdef SUPPORT_UTF+ case OP_NOTPROP:+ case OP_PROP:+#ifndef COMPILE_PCRE32+ if (common->utf) return consumed;+#endif+ any = TRUE;+ cc += 1 + 2;+ break;+#endif++ case OP_TYPEEXACT:+ repeat = GET2(cc, 1);+ cc += 1 + IMM2_SIZE;+ continue;++ case OP_NOTEXACT:+ case OP_NOTEXACTI:+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (common->utf) return consumed;+#endif+ any = TRUE;+ repeat = GET2(cc, 1);+ cc += 1 + IMM2_SIZE + 1;+ break;++ default:+ return consumed;+ }++ if (any)+ {+ do+ {+ chars[0] = 255;++ consumed++;+ if (--max_chars == 0)+ return consumed;+ chars += MAX_DIFF_CHARS;+ }+ while (--repeat > 0);++ repeat = 1;+ continue;+ }++ if (class)+ {+ bytes = (sljit_u8*) (cc + 1);+ cc += 1 + 32 / sizeof(pcre_uchar);++ switch (*cc)+ {+ case OP_CRSTAR:+ case OP_CRMINSTAR:+ case OP_CRPOSSTAR:+ case OP_CRQUERY:+ case OP_CRMINQUERY:+ case OP_CRPOSQUERY:+ max_chars = scan_prefix(common, cc + 1, chars, max_chars, rec_count);+ if (max_chars == 0)+ return consumed;+ break;++ default:+ case OP_CRPLUS:+ case OP_CRMINPLUS:+ case OP_CRPOSPLUS:+ break;++ case OP_CRRANGE:+ case OP_CRMINRANGE:+ case OP_CRPOSRANGE:+ repeat = GET2(cc, 1);+ if (repeat <= 0)+ return consumed;+ break;+ }++ do+ {+ if (bytes[31] & 0x80)+ chars[0] = 255;+ else if (chars[0] != 255)+ {+ bytes_end = bytes + 32;+ chr = 0;+ do+ {+ byte = *bytes++;+ SLJIT_ASSERT((chr & 0x7) == 0);+ if (byte == 0)+ chr += 8;+ else+ {+ do+ {+ if ((byte & 0x1) != 0)+ add_prefix_char(chr, chars);+ byte >>= 1;+ chr++;+ }+ while (byte != 0);+ chr = (chr + 7) & ~7;+ }+ }+ while (chars[0] != 255 && bytes < bytes_end);+ bytes = bytes_end - 32;+ }++ consumed++;+ if (--max_chars == 0)+ return consumed;+ chars += MAX_DIFF_CHARS;+ }+ while (--repeat > 0);++ switch (*cc)+ {+ case OP_CRSTAR:+ case OP_CRMINSTAR:+ case OP_CRPOSSTAR:+ return consumed;++ case OP_CRQUERY:+ case OP_CRMINQUERY:+ case OP_CRPOSQUERY:+ cc++;+ break;++ case OP_CRRANGE:+ case OP_CRMINRANGE:+ case OP_CRPOSRANGE:+ if (GET2(cc, 1) != GET2(cc, 1 + IMM2_SIZE))+ return consumed;+ cc += 1 + 2 * IMM2_SIZE;+ break;+ }++ repeat = 1;+ continue;+ }++ len = 1;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);+#endif++ if (caseless && char_has_othercase(common, cc))+ {+#ifdef SUPPORT_UTF+ if (common->utf)+ {+ GETCHAR(chr, cc);+ if ((int)PRIV(ord2utf)(char_othercase(common, chr), othercase) != len)+ return consumed;+ }+ else+#endif+ {+ chr = *cc;+ othercase[0] = TABLE_GET(chr, common->fcc, chr);+ }+ }+ else+ {+ caseless = FALSE;+ othercase[0] = 0; /* Stops compiler warning - PH */+ }++ len_save = len;+ cc_save = cc;+ while (TRUE)+ {+ oc = othercase;+ do+ {+ chr = *cc;+ add_prefix_char(*cc, chars);++ if (caseless)+ add_prefix_char(*oc, chars);++ len--;+ consumed++;+ if (--max_chars == 0)+ return consumed;+ chars += MAX_DIFF_CHARS;+ cc++;+ oc++;+ }+ while (len > 0);++ if (--repeat == 0)+ break;++ len = len_save;+ cc = cc_save;+ }++ repeat = 1;+ if (last)+ return consumed;+ }+}++#if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) && !(defined SUPPORT_VALGRIND)++static sljit_s32 character_to_int32(pcre_uchar chr)+{+sljit_s32 value = (sljit_s32)chr;+#if defined COMPILE_PCRE8+#define SSE2_COMPARE_TYPE_INDEX 0+return (value << 24) | (value << 16) | (value << 8) | value;+#elif defined COMPILE_PCRE16+#define SSE2_COMPARE_TYPE_INDEX 1+return (value << 16) | value;+#elif defined COMPILE_PCRE32+#define SSE2_COMPARE_TYPE_INDEX 2+return value;+#else+#error "Unsupported unit width"+#endif+}++static SLJIT_INLINE void fast_forward_first_char2_sse2(compiler_common *common, pcre_uchar char1, pcre_uchar char2)+{+DEFINE_COMPILER;+struct sljit_label *start;+struct sljit_jump *quit[3];+struct sljit_jump *nomatch;+sljit_u8 instruction[8];+sljit_s32 tmp1_ind = sljit_get_register_index(TMP1);+sljit_s32 tmp2_ind = sljit_get_register_index(TMP2);+sljit_s32 str_ptr_ind = sljit_get_register_index(STR_PTR);+BOOL load_twice = FALSE;+pcre_uchar bit;++bit = char1 ^ char2;+if (!is_powerof2(bit))+ bit = 0;++if ((char1 != char2) && bit == 0)+ load_twice = TRUE;++quit[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);++/* First part (unaligned start) */++OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, character_to_int32(char1 | bit));++SLJIT_ASSERT(tmp1_ind < 8 && tmp2_ind == 1);++/* MOVD xmm, r/m32 */+instruction[0] = 0x66;+instruction[1] = 0x0f;+instruction[2] = 0x6e;+instruction[3] = 0xc0 | (2 << 3) | tmp1_ind;+sljit_emit_op_custom(compiler, instruction, 4);++if (char1 != char2)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, character_to_int32(bit != 0 ? bit : char2));++ /* MOVD xmm, r/m32 */+ instruction[3] = 0xc0 | (3 << 3) | tmp1_ind;+ sljit_emit_op_custom(compiler, instruction, 4);+ }++/* PSHUFD xmm1, xmm2/m128, imm8 */+instruction[2] = 0x70;+instruction[3] = 0xc0 | (2 << 3) | 2;+instruction[4] = 0;+sljit_emit_op_custom(compiler, instruction, 5);++if (char1 != char2)+ {+ /* PSHUFD xmm1, xmm2/m128, imm8 */+ instruction[3] = 0xc0 | (3 << 3) | 3;+ instruction[4] = 0;+ sljit_emit_op_custom(compiler, instruction, 5);+ }++OP2(SLJIT_AND, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 0xf);+OP2(SLJIT_AND, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, ~0xf);++/* MOVDQA xmm1, xmm2/m128 */+#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)++if (str_ptr_ind < 8)+ {+ instruction[2] = 0x6f;+ instruction[3] = (0 << 3) | str_ptr_ind;+ sljit_emit_op_custom(compiler, instruction, 4);++ if (load_twice)+ {+ instruction[3] = (1 << 3) | str_ptr_ind;+ sljit_emit_op_custom(compiler, instruction, 4);+ }+ }+else+ {+ instruction[1] = 0x41;+ instruction[2] = 0x0f;+ instruction[3] = 0x6f;+ instruction[4] = (0 << 3) | (str_ptr_ind & 0x7);+ sljit_emit_op_custom(compiler, instruction, 5);++ if (load_twice)+ {+ instruction[4] = (1 << 3) | str_ptr_ind;+ sljit_emit_op_custom(compiler, instruction, 5);+ }+ instruction[1] = 0x0f;+ }++#else++instruction[2] = 0x6f;+instruction[3] = (0 << 3) | str_ptr_ind;+sljit_emit_op_custom(compiler, instruction, 4);++if (load_twice)+ {+ instruction[3] = (1 << 3) | str_ptr_ind;+ sljit_emit_op_custom(compiler, instruction, 4);+ }++#endif++if (bit != 0)+ {+ /* POR xmm1, xmm2/m128 */+ instruction[2] = 0xeb;+ instruction[3] = 0xc0 | (0 << 3) | 3;+ sljit_emit_op_custom(compiler, instruction, 4);+ }++/* PCMPEQB/W/D xmm1, xmm2/m128 */+instruction[2] = 0x74 + SSE2_COMPARE_TYPE_INDEX;+instruction[3] = 0xc0 | (0 << 3) | 2;+sljit_emit_op_custom(compiler, instruction, 4);++if (load_twice)+ {+ instruction[3] = 0xc0 | (1 << 3) | 3;+ sljit_emit_op_custom(compiler, instruction, 4);+ }++/* PMOVMSKB reg, xmm */+instruction[2] = 0xd7;+instruction[3] = 0xc0 | (tmp1_ind << 3) | 0;+sljit_emit_op_custom(compiler, instruction, 4);++if (load_twice)+ {+ OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP2, 0);+ instruction[3] = 0xc0 | (tmp2_ind << 3) | 1;+ sljit_emit_op_custom(compiler, instruction, 4);++ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ OP1(SLJIT_MOV, TMP2, 0, RETURN_ADDR, 0);+ }++OP2(SLJIT_ASHR, TMP1, 0, TMP1, 0, TMP2, 0);++/* BSF r32, r/m32 */+instruction[0] = 0x0f;+instruction[1] = 0xbc;+instruction[2] = 0xc0 | (tmp1_ind << 3) | tmp1_ind;+sljit_emit_op_custom(compiler, instruction, 3);+sljit_set_current_flags(compiler, SLJIT_SET_Z);++nomatch = JUMP(SLJIT_ZERO);++OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+quit[1] = JUMP(SLJIT_JUMP);++JUMPHERE(nomatch);++start = LABEL();+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 16);+quit[2] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);++/* Second part (aligned) */++instruction[0] = 0x66;+instruction[1] = 0x0f;++/* MOVDQA xmm1, xmm2/m128 */+#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)++if (str_ptr_ind < 8)+ {+ instruction[2] = 0x6f;+ instruction[3] = (0 << 3) | str_ptr_ind;+ sljit_emit_op_custom(compiler, instruction, 4);++ if (load_twice)+ {+ instruction[3] = (1 << 3) | str_ptr_ind;+ sljit_emit_op_custom(compiler, instruction, 4);+ }+ }+else+ {+ instruction[1] = 0x41;+ instruction[2] = 0x0f;+ instruction[3] = 0x6f;+ instruction[4] = (0 << 3) | (str_ptr_ind & 0x7);+ sljit_emit_op_custom(compiler, instruction, 5);++ if (load_twice)+ {+ instruction[4] = (1 << 3) | str_ptr_ind;+ sljit_emit_op_custom(compiler, instruction, 5);+ }+ instruction[1] = 0x0f;+ }++#else++instruction[2] = 0x6f;+instruction[3] = (0 << 3) | str_ptr_ind;+sljit_emit_op_custom(compiler, instruction, 4);++if (load_twice)+ {+ instruction[3] = (1 << 3) | str_ptr_ind;+ sljit_emit_op_custom(compiler, instruction, 4);+ }++#endif++if (bit != 0)+ {+ /* POR xmm1, xmm2/m128 */+ instruction[2] = 0xeb;+ instruction[3] = 0xc0 | (0 << 3) | 3;+ sljit_emit_op_custom(compiler, instruction, 4);+ }++/* PCMPEQB/W/D xmm1, xmm2/m128 */+instruction[2] = 0x74 + SSE2_COMPARE_TYPE_INDEX;+instruction[3] = 0xc0 | (0 << 3) | 2;+sljit_emit_op_custom(compiler, instruction, 4);++if (load_twice)+ {+ instruction[3] = 0xc0 | (1 << 3) | 3;+ sljit_emit_op_custom(compiler, instruction, 4);+ }++/* PMOVMSKB reg, xmm */+instruction[2] = 0xd7;+instruction[3] = 0xc0 | (tmp1_ind << 3) | 0;+sljit_emit_op_custom(compiler, instruction, 4);++if (load_twice)+ {+ instruction[3] = 0xc0 | (tmp2_ind << 3) | 1;+ sljit_emit_op_custom(compiler, instruction, 4);++ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);+ }++/* BSF r32, r/m32 */+instruction[0] = 0x0f;+instruction[1] = 0xbc;+instruction[2] = 0xc0 | (tmp1_ind << 3) | tmp1_ind;+sljit_emit_op_custom(compiler, instruction, 3);+sljit_set_current_flags(compiler, SLJIT_SET_Z);++JUMPTO(SLJIT_ZERO, start);++OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);++start = LABEL();+SET_LABEL(quit[0], start);+SET_LABEL(quit[1], start);+SET_LABEL(quit[2], start);+}++#undef SSE2_COMPARE_TYPE_INDEX++#endif++static void fast_forward_first_char2(compiler_common *common, pcre_uchar char1, pcre_uchar char2, sljit_s32 offset)+{+DEFINE_COMPILER;+struct sljit_label *start;+struct sljit_jump *quit;+struct sljit_jump *found;+pcre_uchar mask;+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+struct sljit_label *utf_start = NULL;+struct sljit_jump *utf_quit = NULL;+#endif+BOOL has_match_end = (common->match_end_ptr != 0);++if (offset > 0)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));++if (has_match_end)+ {+ OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);++ OP2(SLJIT_ADD, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, SLJIT_IMM, IN_UCHARS(offset + 1));+ OP2(SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_UNUSED, 0, STR_END, 0, TMP3, 0);+ sljit_emit_cmov(compiler, SLJIT_GREATER, STR_END, TMP3, 0);+ }++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+if (common->utf && offset > 0)+ utf_start = LABEL();+#endif++#if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) && !(defined SUPPORT_VALGRIND)++/* SSE2 accelerated first character search. */++if (sljit_has_cpu_feature(SLJIT_HAS_SSE2))+ {+ fast_forward_first_char2_sse2(common, char1, char2);++ SLJIT_ASSERT(common->mode == JIT_COMPILE || offset == 0);+ if (common->mode == JIT_COMPILE)+ {+ /* In complete mode, we don't need to run a match when STR_PTR == STR_END. */+ SLJIT_ASSERT(common->forced_quit_label == NULL);+ OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);+ add_jump(compiler, &common->forced_quit, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (common->utf && offset > 0)+ {+ SLJIT_ASSERT(common->mode == JIT_COMPILE);++ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-offset));+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+#if defined COMPILE_PCRE8+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, utf_start);+#elif defined COMPILE_PCRE16+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, utf_start);+#else+#error "Unknown code width"+#endif+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ }+#endif++ if (offset > 0)+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));+ }+ else+ {+ OP2(SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_UNUSED, 0, STR_PTR, 0, STR_END, 0);+ if (has_match_end)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);+ sljit_emit_cmov(compiler, SLJIT_GREATER_EQUAL, STR_PTR, TMP1, 0);+ }+ else+ sljit_emit_cmov(compiler, SLJIT_GREATER_EQUAL, STR_PTR, STR_END, 0);+ }++ if (has_match_end)+ OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);+ return;+ }++#endif++quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);++start = LABEL();+OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);++if (char1 == char2)+ found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, char1);+else+ {+ mask = char1 ^ char2;+ if (is_powerof2(mask))+ {+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, mask);+ found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, char1 | mask);+ }+ else+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char1);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char2);+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);+ found = JUMP(SLJIT_NOT_ZERO);+ }+ }++OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, start);++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+if (common->utf && offset > 0)+ utf_quit = JUMP(SLJIT_JUMP);+#endif++JUMPHERE(found);++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+if (common->utf && offset > 0)+ {+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-offset));+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+#if defined COMPILE_PCRE8+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, utf_start);+#elif defined COMPILE_PCRE16+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, utf_start);+#else+#error "Unknown code width"+#endif+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ JUMPHERE(utf_quit);+ }+#endif++JUMPHERE(quit);++if (has_match_end)+ {+ quit = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);+ if (offset > 0)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));+ JUMPHERE(quit);+ OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);+ }++if (offset > 0)+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));+}++static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common)+{+DEFINE_COMPILER;+struct sljit_label *start;+struct sljit_jump *quit;+struct sljit_jump *match;+/* bytes[0] represent the number of characters between 0+and MAX_N_BYTES - 1, 255 represents any character. */+pcre_uchar chars[MAX_N_CHARS * MAX_DIFF_CHARS];+sljit_s32 offset;+pcre_uchar mask;+pcre_uchar *char_set, *char_set_end;+int i, max, from;+int range_right = -1, range_len;+sljit_u8 *update_table = NULL;+BOOL in_range;+sljit_u32 rec_count;++for (i = 0; i < MAX_N_CHARS; i++)+ chars[i * MAX_DIFF_CHARS] = 0;++rec_count = 10000;+max = scan_prefix(common, common->start, chars, MAX_N_CHARS, &rec_count);++if (max < 1)+ return FALSE;++in_range = FALSE;+/* Prevent compiler "uninitialized" warning */+from = 0;+range_len = 4 /* minimum length */ - 1;+for (i = 0; i <= max; i++)+ {+ if (in_range && (i - from) > range_len && (chars[(i - 1) * MAX_DIFF_CHARS] < 255))+ {+ range_len = i - from;+ range_right = i - 1;+ }++ if (i < max && chars[i * MAX_DIFF_CHARS] < 255)+ {+ SLJIT_ASSERT(chars[i * MAX_DIFF_CHARS] > 0);+ if (!in_range)+ {+ in_range = TRUE;+ from = i;+ }+ }+ else+ in_range = FALSE;+ }++if (range_right >= 0)+ {+ update_table = (sljit_u8 *)allocate_read_only_data(common, 256);+ if (update_table == NULL)+ return TRUE;+ memset(update_table, IN_UCHARS(range_len), 256);++ for (i = 0; i < range_len; i++)+ {+ char_set = chars + ((range_right - i) * MAX_DIFF_CHARS);+ SLJIT_ASSERT(char_set[0] > 0 && char_set[0] < 255);+ char_set_end = char_set + char_set[0];+ char_set++;+ while (char_set <= char_set_end)+ {+ if (update_table[(*char_set) & 0xff] > IN_UCHARS(i))+ update_table[(*char_set) & 0xff] = IN_UCHARS(i);+ char_set++;+ }+ }+ }++offset = -1;+/* Scan forward. */+for (i = 0; i < max; i++)+ {+ if (offset == -1)+ {+ if (chars[i * MAX_DIFF_CHARS] <= 2)+ offset = i;+ }+ else if (chars[offset * MAX_DIFF_CHARS] == 2 && chars[i * MAX_DIFF_CHARS] <= 2)+ {+ if (chars[i * MAX_DIFF_CHARS] == 1)+ offset = i;+ else+ {+ mask = chars[offset * MAX_DIFF_CHARS + 1] ^ chars[offset * MAX_DIFF_CHARS + 2];+ if (!is_powerof2(mask))+ {+ mask = chars[i * MAX_DIFF_CHARS + 1] ^ chars[i * MAX_DIFF_CHARS + 2];+ if (is_powerof2(mask))+ offset = i;+ }+ }+ }+ }++if (range_right < 0)+ {+ if (offset < 0)+ return FALSE;+ SLJIT_ASSERT(chars[offset * MAX_DIFF_CHARS] >= 1 && chars[offset * MAX_DIFF_CHARS] <= 2);+ /* Works regardless the value is 1 or 2. */+ mask = chars[offset * MAX_DIFF_CHARS + chars[offset * MAX_DIFF_CHARS]];+ fast_forward_first_char2(common, chars[offset * MAX_DIFF_CHARS + 1], mask, offset);+ return TRUE;+ }++if (range_right == offset)+ offset = -1;++SLJIT_ASSERT(offset == -1 || (chars[offset * MAX_DIFF_CHARS] >= 1 && chars[offset * MAX_DIFF_CHARS] <= 2));++max -= 1;+SLJIT_ASSERT(max > 0);+if (common->match_end_ptr != 0)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);+ OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);+ OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));+ quit = CMP(SLJIT_LESS_EQUAL, STR_END, 0, TMP1, 0);+ OP1(SLJIT_MOV, STR_END, 0, TMP1, 0);+ JUMPHERE(quit);+ }+else+ OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));++SLJIT_ASSERT(range_right >= 0);++#if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)+OP1(SLJIT_MOV, RETURN_ADDR, 0, SLJIT_IMM, (sljit_sw)update_table);+#endif++start = LABEL();+quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);++#if defined COMPILE_PCRE8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right));+#else+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right + 1) - 1);+#endif++#if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(RETURN_ADDR, TMP1), 0);+#else+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)update_table);+#endif+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start);++if (offset >= 0)+ {+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offset));+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++ if (chars[offset * MAX_DIFF_CHARS] == 1)+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1], start);+ else+ {+ mask = chars[offset * MAX_DIFF_CHARS + 1] ^ chars[offset * MAX_DIFF_CHARS + 2];+ if (is_powerof2(mask))+ {+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, mask);+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1] | mask, start);+ }+ else+ {+ match = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1]);+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 2], start);+ JUMPHERE(match);+ }+ }+ }++#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+if (common->utf && offset != 0)+ {+ if (offset < 0)+ {+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ }+ else+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));+#if defined COMPILE_PCRE8+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, start);+#elif defined COMPILE_PCRE16+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, start);+#else+#error "Unknown code width"+#endif+ if (offset < 0)+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ }+#endif++if (offset >= 0)+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++JUMPHERE(quit);++if (common->match_end_ptr != 0)+ {+ if (range_right >= 0)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);+ OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);+ if (range_right >= 0)+ {+ quit = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);+ OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);+ JUMPHERE(quit);+ }+ }+else+ OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));+return TRUE;+}++#undef MAX_N_CHARS+#undef MAX_DIFF_CHARS++static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless)+{+pcre_uchar oc;++oc = first_char;+if (caseless)+ {+ oc = TABLE_GET(first_char, common->fcc, first_char);+#if defined SUPPORT_UCP && !defined COMPILE_PCRE8+ if (first_char > 127 && common->utf)+ oc = UCD_OTHERCASE(first_char);+#endif+ }++fast_forward_first_char2(common, first_char, oc, 0);+}++static SLJIT_INLINE void fast_forward_newline(compiler_common *common)+{+DEFINE_COMPILER;+struct sljit_label *loop;+struct sljit_jump *lastchar;+struct sljit_jump *firstchar;+struct sljit_jump *quit;+struct sljit_jump *foundcr = NULL;+struct sljit_jump *notfoundnl;+jump_list *newline = NULL;++if (common->match_end_ptr != 0)+ {+ OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);+ OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);+ }++if (common->nltype == NLTYPE_FIXED && common->newline > 255)+ {+ lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));+ firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);++ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));+ OP2(SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_GREATER_EQUAL);+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);+#endif+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);++ loop = LABEL();+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);+ CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);++ JUMPHERE(quit);+ JUMPHERE(firstchar);+ JUMPHERE(lastchar);++ if (common->match_end_ptr != 0)+ OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);+ return;+ }++OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));+firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);+skip_char_back(common);++loop = LABEL();+common->ff_newline_shortcut = loop;++read_char_range(common, common->nlmin, common->nlmax, TRUE);+lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)+ foundcr = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);+check_newlinechar(common, common->nltype, &newline, FALSE);+set_jumps(newline, loop);++if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)+ {+ quit = JUMP(SLJIT_JUMP);+ JUMPHERE(foundcr);+ notfoundnl = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);+ OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);+#endif+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+ JUMPHERE(notfoundnl);+ JUMPHERE(quit);+ }+JUMPHERE(lastchar);+JUMPHERE(firstchar);++if (common->match_end_ptr != 0)+ OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);+}++static BOOL check_class_ranges(compiler_common *common, const sljit_u8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks);++static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, const sljit_u8 *start_bits)+{+DEFINE_COMPILER;+struct sljit_label *start;+struct sljit_jump *quit;+struct sljit_jump *found = NULL;+jump_list *matches = NULL;+#ifndef COMPILE_PCRE8+struct sljit_jump *jump;+#endif++if (common->match_end_ptr != 0)+ {+ OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);+ OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);+ }++start = LABEL();+quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+#ifdef SUPPORT_UTF+if (common->utf)+ OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);+#endif++if (!check_class_ranges(common, start_bits, (start_bits[31] & 0x80) != 0, TRUE, &matches))+ {+#ifndef COMPILE_PCRE8+ jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 255);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);+ JUMPHERE(jump);+#endif+ OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);+ OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)start_bits);+ OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);+ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);+ found = JUMP(SLJIT_NOT_ZERO);+ }++#ifdef SUPPORT_UTF+if (common->utf)+ OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);+#endif+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+#ifdef SUPPORT_UTF+#if defined COMPILE_PCRE8+if (common->utf)+ {+ CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+ }+#elif defined COMPILE_PCRE16+if (common->utf)+ {+ CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);+ OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+ }+#endif /* COMPILE_PCRE[8|16] */+#endif /* SUPPORT_UTF */+JUMPTO(SLJIT_JUMP, start);+if (found != NULL)+ JUMPHERE(found);+if (matches != NULL)+ set_jumps(matches, LABEL());+JUMPHERE(quit);++if (common->match_end_ptr != 0)+ OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0);+}++static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uchar req_char, BOOL caseless, BOOL has_firstchar)+{+DEFINE_COMPILER;+struct sljit_label *loop;+struct sljit_jump *toolong;+struct sljit_jump *alreadyfound;+struct sljit_jump *found;+struct sljit_jump *foundoc = NULL;+struct sljit_jump *notfound;+sljit_u32 oc, bit;++SLJIT_ASSERT(common->req_char_ptr != 0);+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr);+OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);+toolong = CMP(SLJIT_LESS, TMP1, 0, STR_END, 0);+alreadyfound = CMP(SLJIT_LESS, STR_PTR, 0, TMP2, 0);++if (has_firstchar)+ OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+else+ OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);++loop = LABEL();+notfound = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, STR_END, 0);++OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);+oc = req_char;+if (caseless)+ {+ oc = TABLE_GET(req_char, common->fcc, req_char);+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)+ if (req_char > 127 && common->utf)+ oc = UCD_OTHERCASE(req_char);+#endif+ }+if (req_char == oc)+ found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);+else+ {+ bit = req_char ^ oc;+ if (is_powerof2(bit))+ {+ OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);+ found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);+ }+ else+ {+ found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);+ foundoc = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, oc);+ }+ }+OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));+JUMPTO(SLJIT_JUMP, loop);++JUMPHERE(found);+if (foundoc)+ JUMPHERE(foundoc);+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, TMP1, 0);+JUMPHERE(alreadyfound);+JUMPHERE(toolong);+return notfound;+}++static void do_revertframes(compiler_common *common)+{+DEFINE_COMPILER;+struct sljit_jump *jump;+struct sljit_label *mainloop;++sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);+OP1(SLJIT_MOV, TMP3, 0, STACK_TOP, 0);+GET_LOCAL_BASE(TMP1, 0, 0);++/* Drop frames until we reach STACK_TOP. */+mainloop = LABEL();+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), -sizeof(sljit_sw));+jump = CMP(SLJIT_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, 0);++OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);+OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(STACK_TOP), -2 * sizeof(sljit_sw));+OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(STACK_TOP), -3 * sizeof(sljit_sw));+OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 3 * sizeof(sljit_sw));+JUMPTO(SLJIT_JUMP, mainloop);++JUMPHERE(jump);+jump = CMP(SLJIT_NOT_ZERO /* SIG_LESS */, TMP2, 0, SLJIT_IMM, 0);+/* End of reverting values. */+OP1(SLJIT_MOV, STACK_TOP, 0, TMP3, 0);+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);++JUMPHERE(jump);+OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);+OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);+OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(STACK_TOP), -2 * sizeof(sljit_sw));+OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));+JUMPTO(SLJIT_JUMP, mainloop);+}++static void check_wordboundary(compiler_common *common)+{+DEFINE_COMPILER;+struct sljit_jump *skipread;+jump_list *skipread_list = NULL;+#if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF+struct sljit_jump *jump;+#endif++SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);++sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);+/* Get type of the previous char, and put it to LOCALS1. */+OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, SLJIT_IMM, 0);+skipread = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);+skip_char_back(common);+check_start_used_ptr(common);+read_char(common);++/* Testing char type. */+#ifdef SUPPORT_UCP+if (common->use_ucp)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);+ jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);+ add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);+ JUMPHERE(jump);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP2, 0);+ }+else+#endif+ {+#ifndef COMPILE_PCRE8+ jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);+#elif defined SUPPORT_UTF+ /* Here LOCALS1 has already been zeroed. */+ jump = NULL;+ if (common->utf)+ jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);+#endif /* COMPILE_PCRE8 */+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);+ OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);+#ifndef COMPILE_PCRE8+ JUMPHERE(jump);+#elif defined SUPPORT_UTF+ if (jump != NULL)+ JUMPHERE(jump);+#endif /* COMPILE_PCRE8 */+ }+JUMPHERE(skipread);++OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);+check_str_end(common, &skipread_list);+peek_char(common, READ_CHAR_MAX);++/* Testing char type. This is a code duplication. */+#ifdef SUPPORT_UCP+if (common->use_ucp)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);+ jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);+ add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);+ JUMPHERE(jump);+ }+else+#endif+ {+#ifndef COMPILE_PCRE8+ /* TMP2 may be destroyed by peek_char. */+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);+ jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);+#elif defined SUPPORT_UTF+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);+ jump = NULL;+ if (common->utf)+ jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);+#endif+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);+ OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);+ OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);+#ifndef COMPILE_PCRE8+ JUMPHERE(jump);+#elif defined SUPPORT_UTF+ if (jump != NULL)+ JUMPHERE(jump);+#endif /* COMPILE_PCRE8 */+ }+set_jumps(skipread_list, LABEL());++OP2(SLJIT_XOR | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);+sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);+}++static BOOL check_class_ranges(compiler_common *common, const sljit_u8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks)+{+/* May destroy TMP1. */+DEFINE_COMPILER;+int ranges[MAX_RANGE_SIZE];+sljit_u8 bit, cbit, all;+int i, byte, length = 0;++bit = bits[0] & 0x1;+/* All bits will be zero or one (since bit is zero or one). */+all = -bit;++for (i = 0; i < 256; )+ {+ byte = i >> 3;+ if ((i & 0x7) == 0 && bits[byte] == all)+ i += 8;+ else+ {+ cbit = (bits[byte] >> (i & 0x7)) & 0x1;+ if (cbit != bit)+ {+ if (length >= MAX_RANGE_SIZE)+ return FALSE;+ ranges[length] = i;+ length++;+ bit = cbit;+ all = -cbit;+ }+ i++;+ }+ }++if (((bit == 0) && nclass) || ((bit == 1) && !nclass))+ {+ if (length >= MAX_RANGE_SIZE)+ return FALSE;+ ranges[length] = 256;+ length++;+ }++if (length < 0 || length > 4)+ return FALSE;++bit = bits[0] & 0x1;+if (invert) bit ^= 0x1;++/* No character is accepted. */+if (length == 0 && bit == 0)+ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));++switch(length)+ {+ case 0:+ /* When bit != 0, all characters are accepted. */+ return TRUE;++ case 1:+ add_jump(compiler, backtracks, CMP(bit == 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));+ return TRUE;++ case 2:+ if (ranges[0] + 1 != ranges[1])+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);+ add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));+ }+ else+ add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));+ return TRUE;++ case 3:+ if (bit != 0)+ {+ add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));+ if (ranges[0] + 1 != ranges[1])+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));+ }+ else+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));+ return TRUE;+ }++ add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[0]));+ if (ranges[1] + 1 != ranges[2])+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1]);+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));+ }+ else+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1]));+ return TRUE;++ case 4:+ if ((ranges[1] - ranges[0]) == (ranges[3] - ranges[2])+ && (ranges[0] | (ranges[2] - ranges[0])) == ranges[2]+ && (ranges[1] & (ranges[2] - ranges[0])) == 0+ && is_powerof2(ranges[2] - ranges[0]))+ {+ SLJIT_ASSERT((ranges[0] & (ranges[2] - ranges[0])) == 0 && (ranges[2] & ranges[3] & (ranges[2] - ranges[0])) != 0);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[0]);+ if (ranges[2] + 1 != ranges[3])+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);+ add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));+ }+ else+ add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));+ return TRUE;+ }++ if (bit != 0)+ {+ i = 0;+ if (ranges[0] + 1 != ranges[1])+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));+ i = ranges[0];+ }+ else+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));++ if (ranges[2] + 1 != ranges[3])+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - i);+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));+ }+ else+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2] - i));+ return TRUE;+ }++ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);+ add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[0]));+ if (ranges[1] + 1 != ranges[2])+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]);+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));+ }+ else+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));+ return TRUE;++ default:+ SLJIT_UNREACHABLE();+ return FALSE;+ }+}++static void check_anynewline(compiler_common *common)+{+/* Check whether TMP1 contains a newline character. TMP2 destroyed. */+DEFINE_COMPILER;++sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);++OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);+OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);+OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32+#ifdef COMPILE_PCRE8+if (common->utf)+ {+#endif+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);+#ifdef COMPILE_PCRE8+ }+#endif+#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */+OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);+}++static void check_hspace(compiler_common *common)+{+/* Check whether TMP1 contains a newline character. TMP2 destroyed. */+DEFINE_COMPILER;++sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);++OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);+OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);+OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32+#ifdef COMPILE_PCRE8+if (common->utf)+ {+#endif+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);+#ifdef COMPILE_PCRE8+ }+#endif+#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */+OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);++sljit_emit_fast_return(compiler, RETURN_ADDR, 0);+}++static void check_vspace(compiler_common *common)+{+/* Check whether TMP1 contains a newline character. TMP2 destroyed. */+DEFINE_COMPILER;++sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);++OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);+OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);+OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32+#ifdef COMPILE_PCRE8+if (common->utf)+ {+#endif+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);+#ifdef COMPILE_PCRE8+ }+#endif+#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */+OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);++sljit_emit_fast_return(compiler, RETURN_ADDR, 0);+}++static void do_casefulcmp(compiler_common *common)+{+DEFINE_COMPILER;+struct sljit_jump *jump;+struct sljit_label *label;+int char1_reg;+int char2_reg;++if (sljit_get_register_index(TMP3) < 0)+ {+ char1_reg = STR_END;+ char2_reg = STACK_TOP;+ }+else+ {+ char1_reg = TMP3;+ char2_reg = RETURN_ADDR;+ }++sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);+OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);++if (char1_reg == STR_END)+ {+ OP1(SLJIT_MOV, TMP3, 0, char1_reg, 0);+ OP1(SLJIT_MOV, RETURN_ADDR, 0, char2_reg, 0);+ }++if (sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_SUPP | SLJIT_MEM_POST, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1)) == SLJIT_SUCCESS)+ {+ label = LABEL();+ sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_POST, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1));+ sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_POST, char2_reg, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ jump = CMP(SLJIT_NOT_EQUAL, char1_reg, 0, char2_reg, 0);+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));+ JUMPTO(SLJIT_NOT_ZERO, label);++ JUMPHERE(jump);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);+ }+else if (sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1)) == SLJIT_SUCCESS)+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++ label = LABEL();+ sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_PRE, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1));+ sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_PRE, char2_reg, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ jump = CMP(SLJIT_NOT_EQUAL, char1_reg, 0, char2_reg, 0);+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));+ JUMPTO(SLJIT_NOT_ZERO, label);++ JUMPHERE(jump);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ }+else+ {+ label = LABEL();+ OP1(MOV_UCHAR, char1_reg, 0, SLJIT_MEM1(TMP1), 0);+ OP1(MOV_UCHAR, char2_reg, 0, SLJIT_MEM1(STR_PTR), 0);+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ jump = CMP(SLJIT_NOT_EQUAL, char1_reg, 0, char2_reg, 0);+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));+ JUMPTO(SLJIT_NOT_ZERO, label);++ JUMPHERE(jump);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);+ }++if (char1_reg == STR_END)+ {+ OP1(SLJIT_MOV, char1_reg, 0, TMP3, 0);+ OP1(SLJIT_MOV, char2_reg, 0, RETURN_ADDR, 0);+ }++sljit_emit_fast_return(compiler, TMP1, 0);+}++static void do_caselesscmp(compiler_common *common)+{+DEFINE_COMPILER;+struct sljit_jump *jump;+struct sljit_label *label;+int char1_reg = STR_END;+int char2_reg;+int lcc_table;+int opt_type = 0;++if (sljit_get_register_index(TMP3) < 0)+ {+ char2_reg = STACK_TOP;+ lcc_table = STACK_LIMIT;+ }+else+ {+ char2_reg = RETURN_ADDR;+ lcc_table = TMP3;+ }++if (sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_SUPP | SLJIT_MEM_POST, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1)) == SLJIT_SUCCESS)+ opt_type = 1;+else if (sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1)) == SLJIT_SUCCESS)+ opt_type = 2;++sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);+OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);++OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, char1_reg, 0);++if (char2_reg == STACK_TOP)+ {+ OP1(SLJIT_MOV, TMP3, 0, char2_reg, 0);+ OP1(SLJIT_MOV, RETURN_ADDR, 0, lcc_table, 0);+ }++OP1(SLJIT_MOV, lcc_table, 0, SLJIT_IMM, common->lcc);++if (opt_type == 1)+ {+ label = LABEL();+ sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_POST, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1));+ sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_POST, char2_reg, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ }+else if (opt_type == 2)+ {+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++ label = LABEL();+ sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_PRE, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1));+ sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_PRE, char2_reg, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ }+else+ {+ label = LABEL();+ OP1(MOV_UCHAR, char1_reg, 0, SLJIT_MEM1(TMP1), 0);+ OP1(MOV_UCHAR, char2_reg, 0, SLJIT_MEM1(STR_PTR), 0);+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));+ }++#ifndef COMPILE_PCRE8+jump = CMP(SLJIT_GREATER, char1_reg, 0, SLJIT_IMM, 255);+#endif+OP1(SLJIT_MOV_U8, char1_reg, 0, SLJIT_MEM2(lcc_table, char1_reg), 0);+#ifndef COMPILE_PCRE8+JUMPHERE(jump);+jump = CMP(SLJIT_GREATER, char2_reg, 0, SLJIT_IMM, 255);+#endif+OP1(SLJIT_MOV_U8, char2_reg, 0, SLJIT_MEM2(lcc_table, char2_reg), 0);+#ifndef COMPILE_PCRE8+JUMPHERE(jump);+#endif++if (opt_type == 0)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++jump = CMP(SLJIT_NOT_EQUAL, char1_reg, 0, char2_reg, 0);+OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));+JUMPTO(SLJIT_NOT_ZERO, label);++JUMPHERE(jump);+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);++if (opt_type == 2)+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++if (char2_reg == STACK_TOP)+ {+ OP1(SLJIT_MOV, char2_reg, 0, TMP3, 0);+ OP1(SLJIT_MOV, lcc_table, 0, RETURN_ADDR, 0);+ }++OP1(SLJIT_MOV, char1_reg, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);+sljit_emit_fast_return(compiler, TMP1, 0);+}++#if defined SUPPORT_UTF && defined SUPPORT_UCP++static const pcre_uchar * SLJIT_FUNC do_utf_caselesscmp(pcre_uchar *src1, pcre_uchar *src2, pcre_uchar *end1, pcre_uchar *end2)+{+/* This function would be ineffective to do in JIT level. */+sljit_u32 c1, c2;+const ucd_record *ur;+const sljit_u32 *pp;++while (src1 < end1)+ {+ if (src2 >= end2)+ return (pcre_uchar*)1;+ GETCHARINC(c1, src1);+ GETCHARINC(c2, src2);+ ur = GET_UCD(c2);+ if (c1 != c2 && c1 != c2 + ur->other_case)+ {+ pp = PRIV(ucd_caseless_sets) + ur->caseset;+ for (;;)+ {+ if (c1 < *pp) return NULL;+ if (c1 == *pp++) break;+ }+ }+ }+return src2;+}++#endif /* SUPPORT_UTF && SUPPORT_UCP */++static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,+ compare_context *context, jump_list **backtracks)+{+DEFINE_COMPILER;+unsigned int othercasebit = 0;+pcre_uchar *othercasechar = NULL;+#ifdef SUPPORT_UTF+int utflength;+#endif++if (caseless && char_has_othercase(common, cc))+ {+ othercasebit = char_get_othercase_bit(common, cc);+ SLJIT_ASSERT(othercasebit);+ /* Extracting bit difference info. */+#if defined COMPILE_PCRE8+ othercasechar = cc + (othercasebit >> 8);+ othercasebit &= 0xff;+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32+ /* Note that this code only handles characters in the BMP. If there+ ever are characters outside the BMP whose othercase differs in only one+ bit from itself (there currently are none), this code will need to be+ revised for COMPILE_PCRE32. */+ othercasechar = cc + (othercasebit >> 9);+ if ((othercasebit & 0x100) != 0)+ othercasebit = (othercasebit & 0xff) << 8;+ else+ othercasebit &= 0xff;+#endif /* COMPILE_PCRE[8|16|32] */+ }++if (context->sourcereg == -1)+ {+#if defined COMPILE_PCRE8+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED+ if (context->length >= 4)+ OP1(SLJIT_MOV_S32, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);+ else if (context->length >= 2)+ OP1(SLJIT_MOV_U16, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);+ else+#endif+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);+#elif defined COMPILE_PCRE16+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED+ if (context->length >= 4)+ OP1(SLJIT_MOV_S32, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);+ else+#endif+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);+#elif defined COMPILE_PCRE32+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);+#endif /* COMPILE_PCRE[8|16|32] */+ context->sourcereg = TMP2;+ }++#ifdef SUPPORT_UTF+utflength = 1;+if (common->utf && HAS_EXTRALEN(*cc))+ utflength += GET_EXTRALEN(*cc);++do+ {+#endif++ context->length -= IN_UCHARS(1);+#if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED) && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)++ /* Unaligned read is supported. */+ if (othercasebit != 0 && othercasechar == cc)+ {+ context->c.asuchars[context->ucharptr] = *cc | othercasebit;+ context->oc.asuchars[context->ucharptr] = othercasebit;+ }+ else+ {+ context->c.asuchars[context->ucharptr] = *cc;+ context->oc.asuchars[context->ucharptr] = 0;+ }+ context->ucharptr++;++#if defined COMPILE_PCRE8+ if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1))+#else+ if (context->ucharptr >= 2 || context->length == 0)+#endif+ {+ if (context->length >= 4)+ OP1(SLJIT_MOV_S32, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);+ else if (context->length >= 2)+ OP1(SLJIT_MOV_U16, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);+#if defined COMPILE_PCRE8+ else if (context->length >= 1)+ OP1(SLJIT_MOV_U8, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);+#endif /* COMPILE_PCRE8 */+ context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;++ switch(context->ucharptr)+ {+ case 4 / sizeof(pcre_uchar):+ if (context->oc.asint != 0)+ OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));+ break;++ case 2 / sizeof(pcre_uchar):+ if (context->oc.asushort != 0)+ OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));+ break;++#ifdef COMPILE_PCRE8+ case 1:+ if (context->oc.asbyte != 0)+ OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));+ break;+#endif++ default:+ SLJIT_UNREACHABLE();+ break;+ }+ context->ucharptr = 0;+ }++#else++ /* Unaligned read is unsupported or in 32 bit mode. */+ if (context->length >= 1)+ OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);++ context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;++ if (othercasebit != 0 && othercasechar == cc)+ {+ OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));+ }+ else+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));++#endif++ cc++;+#ifdef SUPPORT_UTF+ utflength--;+ }+while (utflength > 0);+#endif++return cc;+}++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8++#define SET_TYPE_OFFSET(value) \+ if ((value) != typeoffset) \+ { \+ if ((value) < typeoffset) \+ OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \+ else \+ OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \+ } \+ typeoffset = (value);++#define SET_CHAR_OFFSET(value) \+ if ((value) != charoffset) \+ { \+ if ((value) < charoffset) \+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(charoffset - (value))); \+ else \+ OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)((value) - charoffset)); \+ } \+ charoffset = (value);++static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks, BOOL check_str_ptr);++static void compile_xclass_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)+{+DEFINE_COMPILER;+jump_list *found = NULL;+jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks;+sljit_uw c, charoffset, max = 256, min = READ_CHAR_MAX;+struct sljit_jump *jump = NULL;+pcre_uchar *ccbegin;+int compares, invertcmp, numberofcmps;+#if defined SUPPORT_UTF && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)+BOOL utf = common->utf;+#endif++#ifdef SUPPORT_UCP+BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;+BOOL charsaved = FALSE;+int typereg = TMP1;+const sljit_u32 *other_cases;+sljit_uw typeoffset;+#endif++/* Scanning the necessary info. */+cc++;+ccbegin = cc;+compares = 0;+if (cc[-1] & XCL_MAP)+ {+ min = 0;+ cc += 32 / sizeof(pcre_uchar);+ }++while (*cc != XCL_END)+ {+ compares++;+ if (*cc == XCL_SINGLE)+ {+ cc ++;+ GETCHARINCTEST(c, cc);+ if (c > max) max = c;+ if (c < min) min = c;+#ifdef SUPPORT_UCP+ needschar = TRUE;+#endif+ }+ else if (*cc == XCL_RANGE)+ {+ cc ++;+ GETCHARINCTEST(c, cc);+ if (c < min) min = c;+ GETCHARINCTEST(c, cc);+ if (c > max) max = c;+#ifdef SUPPORT_UCP+ needschar = TRUE;+#endif+ }+#ifdef SUPPORT_UCP+ else+ {+ SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);+ cc++;+ if (*cc == PT_CLIST)+ {+ other_cases = PRIV(ucd_caseless_sets) + cc[1];+ while (*other_cases != NOTACHAR)+ {+ if (*other_cases > max) max = *other_cases;+ if (*other_cases < min) min = *other_cases;+ other_cases++;+ }+ }+ else+ {+ max = READ_CHAR_MAX;+ min = 0;+ }++ switch(*cc)+ {+ case PT_ANY:+ /* Any either accepts everything or ignored. */+ if (cc[-1] == XCL_PROP)+ {+ compile_char1_matchingpath(common, OP_ALLANY, cc, backtracks, FALSE);+ if (list == backtracks)+ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));+ return;+ }+ break;++ case PT_LAMP:+ case PT_GC:+ case PT_PC:+ case PT_ALNUM:+ needstype = TRUE;+ break;++ case PT_SC:+ needsscript = TRUE;+ break;++ case PT_SPACE:+ case PT_PXSPACE:+ case PT_WORD:+ case PT_PXGRAPH:+ case PT_PXPRINT:+ case PT_PXPUNCT:+ needstype = TRUE;+ needschar = TRUE;+ break;++ case PT_CLIST:+ case PT_UCNC:+ needschar = TRUE;+ break;++ default:+ SLJIT_UNREACHABLE();+ break;+ }+ cc += 2;+ }+#endif+ }+SLJIT_ASSERT(compares > 0);++/* We are not necessary in utf mode even in 8 bit mode. */+cc = ccbegin;+read_char_range(common, min, max, (cc[-1] & XCL_NOT) != 0);++if ((cc[-1] & XCL_HASPROP) == 0)+ {+ if ((cc[-1] & XCL_MAP) != 0)+ {+ jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);+ if (!check_class_ranges(common, (const sljit_u8 *)cc, (((const sljit_u8 *)cc)[31] & 0x80) != 0, TRUE, &found))+ {+ OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);+ OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);+ OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);+ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);+ add_jump(compiler, &found, JUMP(SLJIT_NOT_ZERO));+ }++ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));+ JUMPHERE(jump);++ cc += 32 / sizeof(pcre_uchar);+ }+ else+ {+ OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, min);+ add_jump(compiler, (cc[-1] & XCL_NOT) == 0 ? backtracks : &found, CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, max - min));+ }+ }+else if ((cc[-1] & XCL_MAP) != 0)+ {+ OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);+#ifdef SUPPORT_UCP+ charsaved = TRUE;+#endif+ if (!check_class_ranges(common, (const sljit_u8 *)cc, FALSE, TRUE, list))+ {+#ifdef COMPILE_PCRE8+ jump = NULL;+ if (common->utf)+#endif+ jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);++ OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);+ OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);+ OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);+ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);+ add_jump(compiler, list, JUMP(SLJIT_NOT_ZERO));++#ifdef COMPILE_PCRE8+ if (common->utf)+#endif+ JUMPHERE(jump);+ }++ OP1(SLJIT_MOV, TMP1, 0, RETURN_ADDR, 0);+ cc += 32 / sizeof(pcre_uchar);+ }++#ifdef SUPPORT_UCP+if (needstype || needsscript)+ {+ if (needschar && !charsaved)+ OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);++#ifdef COMPILE_PCRE32+ if (!common->utf)+ {+ jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0x10ffff + 1);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);+ JUMPHERE(jump);+ }+#endif++ OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1));+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2));+ OP1(SLJIT_MOV_U16, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);++ /* Before anything else, we deal with scripts. */+ if (needsscript)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);++ ccbegin = cc;++ while (*cc != XCL_END)+ {+ if (*cc == XCL_SINGLE)+ {+ cc ++;+ GETCHARINCTEST(c, cc);+ }+ else if (*cc == XCL_RANGE)+ {+ cc ++;+ GETCHARINCTEST(c, cc);+ GETCHARINCTEST(c, cc);+ }+ else+ {+ SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);+ cc++;+ if (*cc == PT_SC)+ {+ compares--;+ invertcmp = (compares == 0 && list != backtracks);+ if (cc[-1] == XCL_NOTPROP)+ invertcmp ^= 0x1;+ jump = CMP(SLJIT_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (int)cc[1]);+ add_jump(compiler, compares > 0 ? list : backtracks, jump);+ }+ cc += 2;+ }+ }++ cc = ccbegin;+ }++ if (needschar)+ {+ OP1(SLJIT_MOV, TMP1, 0, RETURN_ADDR, 0);+ }++ if (needstype)+ {+ if (!needschar)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);+ }+ else+ {+ OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);+ OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));+ typereg = RETURN_ADDR;+ }+ }+ }+#endif++/* Generating code. */+charoffset = 0;+numberofcmps = 0;+#ifdef SUPPORT_UCP+typeoffset = 0;+#endif++while (*cc != XCL_END)+ {+ compares--;+ invertcmp = (compares == 0 && list != backtracks);+ jump = NULL;++ if (*cc == XCL_SINGLE)+ {+ cc ++;+ GETCHARINCTEST(c, cc);++ if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));+ OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ numberofcmps++;+ }+ else if (numberofcmps > 0)+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);+ jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);+ numberofcmps = 0;+ }+ else+ {+ jump = CMP(SLJIT_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));+ numberofcmps = 0;+ }+ }+ else if (*cc == XCL_RANGE)+ {+ cc ++;+ GETCHARINCTEST(c, cc);+ SET_CHAR_OFFSET(c);+ GETCHARINCTEST(c, cc);++ if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))+ {+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));+ OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);+ numberofcmps++;+ }+ else if (numberofcmps > 0)+ {+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_LESS_EQUAL);+ jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);+ numberofcmps = 0;+ }+ else+ {+ jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));+ numberofcmps = 0;+ }+ }+#ifdef SUPPORT_UCP+ else+ {+ SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);+ if (*cc == XCL_NOTPROP)+ invertcmp ^= 0x1;+ cc++;+ switch(*cc)+ {+ case PT_ANY:+ if (!invertcmp)+ jump = JUMP(SLJIT_JUMP);+ break;++ case PT_LAMP:+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - typeoffset);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ll - typeoffset);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lt - typeoffset);+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);+ jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);+ break;++ case PT_GC:+ c = PRIV(ucp_typerange)[(int)cc[1] * 2];+ SET_TYPE_OFFSET(c);+ jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c);+ break;++ case PT_PC:+ jump = CMP(SLJIT_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset);+ break;++ case PT_SC:+ compares++;+ /* Do nothing. */+ break;++ case PT_SPACE:+ case PT_PXSPACE:+ SET_CHAR_OFFSET(9);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd - 0x9);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);++ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x9);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);++ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x9);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);++ SET_TYPE_OFFSET(ucp_Zl);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_LESS_EQUAL);+ jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);+ break;++ case PT_WORD:+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_UNDERSCORE - charoffset));+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);+ /* Fall through. */++ case PT_ALNUM:+ SET_TYPE_OFFSET(ucp_Ll);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);+ OP_FLAGS((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);+ SET_TYPE_OFFSET(ucp_Nd);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_No - ucp_Nd);+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_LESS_EQUAL);+ jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);+ break;++ case PT_CLIST:+ other_cases = PRIV(ucd_caseless_sets) + cc[1];++ /* At least three characters are required.+ Otherwise this case would be handled by the normal code path. */+ SLJIT_ASSERT(other_cases[0] != NOTACHAR && other_cases[1] != NOTACHAR && other_cases[2] != NOTACHAR);+ SLJIT_ASSERT(other_cases[0] < other_cases[1] && other_cases[1] < other_cases[2]);++ /* Optimizing character pairs, if their difference is power of 2. */+ if (is_powerof2(other_cases[1] ^ other_cases[0]))+ {+ if (charoffset == 0)+ OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);+ else+ {+ OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);+ OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);+ }+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[1]);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);+ other_cases += 2;+ }+ else if (is_powerof2(other_cases[2] ^ other_cases[1]))+ {+ if (charoffset == 0)+ OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[2] ^ other_cases[1]);+ else+ {+ OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);+ OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);+ }+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);++ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(other_cases[0] - charoffset));+ OP_FLAGS(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_Z : 0), TMP2, 0, SLJIT_EQUAL);++ other_cases += 3;+ }+ else+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset));+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);+ }++ while (*other_cases != NOTACHAR)+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset));+ OP_FLAGS(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_Z : 0), TMP2, 0, SLJIT_EQUAL);+ }+ jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);+ break;++ case PT_UCNC:+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_DOLLAR_SIGN - charoffset));+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_COMMERCIAL_AT - charoffset));+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_GRAVE_ACCENT - charoffset));+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);++ SET_CHAR_OFFSET(0xa0);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(0xd7ff - charoffset));+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);+ SET_CHAR_OFFSET(0);+ OP2(SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_GREATER_EQUAL);+ jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);+ break;++ case PT_PXGRAPH:+ /* C and Z groups are the farthest two groups. */+ SET_TYPE_OFFSET(ucp_Ll);+ OP2(SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_GREATER);++ jump = CMP(SLJIT_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);++ /* In case of ucp_Cf, we overwrite the result. */+ SET_CHAR_OFFSET(0x2066);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);++ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);++ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x2066);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);++ JUMPHERE(jump);+ jump = CMP(SLJIT_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);+ break;++ case PT_PXPRINT:+ /* C and Z groups are the farthest two groups. */+ SET_TYPE_OFFSET(ucp_Ll);+ OP2(SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_GREATER);++ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Ll);+ OP_FLAGS(SLJIT_AND, TMP2, 0, SLJIT_NOT_EQUAL);++ jump = CMP(SLJIT_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);++ /* In case of ucp_Cf, we overwrite the result. */+ SET_CHAR_OFFSET(0x2066);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);++ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);+ OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);++ JUMPHERE(jump);+ jump = CMP(SLJIT_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);+ break;++ case PT_PXPUNCT:+ SET_TYPE_OFFSET(ucp_Sc);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Sc);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);++ SET_CHAR_OFFSET(0);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x7f);+ OP_FLAGS(SLJIT_AND, TMP2, 0, SLJIT_LESS_EQUAL);++ SET_TYPE_OFFSET(ucp_Pc);+ OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ps - ucp_Pc);+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_LESS_EQUAL);+ jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);+ break;++ default:+ SLJIT_UNREACHABLE();+ break;+ }+ cc += 2;+ }+#endif++ if (jump != NULL)+ add_jump(compiler, compares > 0 ? list : backtracks, jump);+ }++if (found != NULL)+ set_jumps(found, LABEL());+}++#undef SET_TYPE_OFFSET+#undef SET_CHAR_OFFSET++#endif++static pcre_uchar *compile_simple_assertion_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)+{+DEFINE_COMPILER;+int length;+struct sljit_jump *jump[4];+#ifdef SUPPORT_UTF+struct sljit_label *label;+#endif /* SUPPORT_UTF */++switch(type)+ {+ case OP_SOD:+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, TMP1, 0));+ return cc;++ case OP_SOM:+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, TMP1, 0));+ return cc;++ case OP_NOT_WORD_BOUNDARY:+ case OP_WORD_BOUNDARY:+ add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL));+ sljit_set_current_flags(compiler, SLJIT_SET_Z);+ add_jump(compiler, backtracks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_NOT_ZERO : SLJIT_ZERO));+ return cc;++ case OP_EODN:+ /* Requires rather complex checks. */+ jump[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+ if (common->nltype == NLTYPE_FIXED && common->newline > 255)+ {+ OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ if (common->mode == JIT_COMPILE)+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_END, 0));+ else+ {+ jump[1] = CMP(SLJIT_EQUAL, TMP2, 0, STR_END, 0);+ OP2(SLJIT_SUB | SLJIT_SET_LESS, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);+ OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);+ OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_NOT_EQUAL);+ add_jump(compiler, backtracks, JUMP(SLJIT_NOT_EQUAL));+ check_partial(common, TRUE);+ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));+ JUMPHERE(jump[1]);+ }+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));+ }+ else if (common->nltype == NLTYPE_FIXED)+ {+ OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_END, 0));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));+ }+ else+ {+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ jump[1] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);+ OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));+ OP2(SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_GREATER, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);+ jump[2] = JUMP(SLJIT_GREATER);+ add_jump(compiler, backtracks, JUMP(SLJIT_NOT_EQUAL) /* LESS */);+ /* Equal. */+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ jump[3] = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);+ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));++ JUMPHERE(jump[1]);+ if (common->nltype == NLTYPE_ANYCRLF)+ {+ OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP2, 0, STR_END, 0));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));+ }+ else+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, STR_PTR, 0);+ read_char_range(common, common->nlmin, common->nlmax, TRUE);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, STR_END, 0));+ add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));+ sljit_set_current_flags(compiler, SLJIT_SET_Z);+ add_jump(compiler, backtracks, JUMP(SLJIT_ZERO));+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);+ }+ JUMPHERE(jump[2]);+ JUMPHERE(jump[3]);+ }+ JUMPHERE(jump[0]);+ check_partial(common, FALSE);+ return cc;++ case OP_EOD:+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0));+ check_partial(common, FALSE);+ return cc;++ case OP_DOLL:+ OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));++ if (!common->endonly)+ compile_simple_assertion_matchingpath(common, OP_EODN, cc, backtracks);+ else+ {+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0));+ check_partial(common, FALSE);+ }+ return cc;++ case OP_DOLLM:+ jump[1] = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);+ OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));+ check_partial(common, FALSE);+ jump[0] = JUMP(SLJIT_JUMP);+ JUMPHERE(jump[1]);++ if (common->nltype == NLTYPE_FIXED && common->newline > 255)+ {+ OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ if (common->mode == JIT_COMPILE)+ add_jump(compiler, backtracks, CMP(SLJIT_GREATER, TMP2, 0, STR_END, 0));+ else+ {+ jump[1] = CMP(SLJIT_LESS_EQUAL, TMP2, 0, STR_END, 0);+ /* STR_PTR = STR_END - IN_UCHARS(1) */+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));+ check_partial(common, TRUE);+ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));+ JUMPHERE(jump[1]);+ }++ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));+ }+ else+ {+ peek_char(common, common->nlmax);+ check_newlinechar(common, common->nltype, backtracks, FALSE);+ }+ JUMPHERE(jump[0]);+ return cc;++ case OP_CIRC:+ OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));+ add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, TMP1, 0));+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));+ return cc;++ case OP_CIRCM:+ OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));+ jump[1] = CMP(SLJIT_GREATER, STR_PTR, 0, TMP1, 0);+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));+ jump[0] = JUMP(SLJIT_JUMP);+ JUMPHERE(jump[1]);++ add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));+ if (common->nltype == NLTYPE_FIXED && common->newline > 255)+ {+ OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP2, 0, TMP1, 0));+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));+ OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));+ }+ else+ {+ skip_char_back(common);+ read_char_range(common, common->nlmin, common->nlmax, TRUE);+ check_newlinechar(common, common->nltype, backtracks, FALSE);+ }+ JUMPHERE(jump[0]);+ return cc;++ case OP_REVERSE:+ length = GET(cc, 0);+ if (length == 0)+ return cc + LINK_SIZE;+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+#ifdef SUPPORT_UTF+ if (common->utf)+ {+ OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);+ label = LABEL();+ add_jump(compiler, backtracks, CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP3, 0));+ skip_char_back(common);+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, label);+ }+ else+#endif+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));+ add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, TMP1, 0));+ }+ check_start_used_ptr(common);+ return cc + LINK_SIZE;+ }+SLJIT_UNREACHABLE();+return cc;+}++static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks, BOOL check_str_ptr)+{+DEFINE_COMPILER;+int length;+unsigned int c, oc, bit;+compare_context context;+struct sljit_jump *jump[3];+jump_list *end_list;+#ifdef SUPPORT_UTF+struct sljit_label *label;+#ifdef SUPPORT_UCP+pcre_uchar propdata[5];+#endif+#endif /* SUPPORT_UTF */++switch(type)+ {+ case OP_NOT_DIGIT:+ case OP_DIGIT:+ /* Digits are usually 0-9, so it is worth to optimize them. */+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (common->utf && is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_digit, FALSE))+ read_char7_type(common, type == OP_NOT_DIGIT);+ else+#endif+ read_char8_type(common, type == OP_NOT_DIGIT);+ /* Flip the starting bit in the negative case. */+ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);+ add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_ZERO : SLJIT_NOT_ZERO));+ return cc;++ case OP_NOT_WHITESPACE:+ case OP_WHITESPACE:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (common->utf && is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_space, FALSE))+ read_char7_type(common, type == OP_NOT_WHITESPACE);+ else+#endif+ read_char8_type(common, type == OP_NOT_WHITESPACE);+ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);+ add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_ZERO : SLJIT_NOT_ZERO));+ return cc;++ case OP_NOT_WORDCHAR:+ case OP_WORDCHAR:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (common->utf && is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_word, FALSE))+ read_char7_type(common, type == OP_NOT_WORDCHAR);+ else+#endif+ read_char8_type(common, type == OP_NOT_WORDCHAR);+ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);+ add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_ZERO : SLJIT_NOT_ZERO));+ return cc;++ case OP_ANY:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ read_char_range(common, common->nlmin, common->nlmax, TRUE);+ if (common->nltype == NLTYPE_FIXED && common->newline > 255)+ {+ jump[0] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);+ end_list = NULL;+ if (common->mode != JIT_PARTIAL_HARD_COMPILE)+ add_jump(compiler, &end_list, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));+ else+ check_str_end(common, &end_list);++ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));+ set_jumps(end_list, LABEL());+ JUMPHERE(jump[0]);+ }+ else+ check_newlinechar(common, common->nltype, backtracks, TRUE);+ return cc;++ case OP_ALLANY:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+#ifdef SUPPORT_UTF+ if (common->utf)+ {+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+#if defined COMPILE_PCRE8 || defined COMPILE_PCRE16+#if defined COMPILE_PCRE8+ jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+#elif defined COMPILE_PCRE16+ jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800);+ OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);+ OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);+ OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+#endif+ JUMPHERE(jump[0]);+#endif /* COMPILE_PCRE[8|16] */+ return cc;+ }+#endif+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ return cc;++ case OP_ANYBYTE:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ return cc;++#ifdef SUPPORT_UTF+#ifdef SUPPORT_UCP+ case OP_NOTPROP:+ case OP_PROP:+ propdata[0] = XCL_HASPROP;+ propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;+ propdata[2] = cc[0];+ propdata[3] = cc[1];+ propdata[4] = XCL_END;+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ compile_xclass_matchingpath(common, propdata, backtracks);+ return cc + 2;+#endif+#endif++ case OP_ANYNL:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ read_char_range(common, common->bsr_nlmin, common->bsr_nlmax, FALSE);+ jump[0] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);+ /* We don't need to handle soft partial matching case. */+ end_list = NULL;+ if (common->mode != JIT_PARTIAL_HARD_COMPILE)+ add_jump(compiler, &end_list, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));+ else+ check_str_end(common, &end_list);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+ jump[1] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ jump[2] = JUMP(SLJIT_JUMP);+ JUMPHERE(jump[0]);+ check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);+ set_jumps(end_list, LABEL());+ JUMPHERE(jump[1]);+ JUMPHERE(jump[2]);+ return cc;++ case OP_NOT_HSPACE:+ case OP_HSPACE:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ read_char_range(common, 0x9, 0x3000, type == OP_NOT_HSPACE);+ add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));+ sljit_set_current_flags(compiler, SLJIT_SET_Z);+ add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_NOT_ZERO : SLJIT_ZERO));+ return cc;++ case OP_NOT_VSPACE:+ case OP_VSPACE:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ read_char_range(common, 0xa, 0x2029, type == OP_NOT_VSPACE);+ add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));+ sljit_set_current_flags(compiler, SLJIT_SET_Z);+ add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_NOT_ZERO : SLJIT_ZERO));+ return cc;++#ifdef SUPPORT_UCP+ case OP_EXTUNI:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ read_char(common);+ add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));+ /* Optimize register allocation: use a real register. */+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);+ OP1(SLJIT_MOV_U8, STACK_TOP, 0, SLJIT_MEM2(TMP1, TMP2), 3);++ label = LABEL();+ jump[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);+ OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);+ read_char(common);+ add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM2(TMP1, TMP2), 3);++ OP2(SLJIT_SHL, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 2);+ OP1(SLJIT_MOV_U32, TMP1, 0, SLJIT_MEM1(STACK_TOP), (sljit_sw)PRIV(ucp_gbtable));+ OP1(SLJIT_MOV, STACK_TOP, 0, TMP2, 0);+ OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);+ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);+ JUMPTO(SLJIT_NOT_ZERO, label);++ OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);+ JUMPHERE(jump[0]);+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);++ if (common->mode == JIT_PARTIAL_HARD_COMPILE)+ {+ jump[0] = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);+ /* Since we successfully read a char above, partial matching must occure. */+ check_partial(common, TRUE);+ JUMPHERE(jump[0]);+ }+ return cc;+#endif++ case OP_CHAR:+ case OP_CHARI:+ length = 1;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);+#endif+ if (common->mode == JIT_COMPILE && check_str_ptr+ && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))+ {+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));+ add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0));++ context.length = IN_UCHARS(length);+ context.sourcereg = -1;+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED+ context.ucharptr = 0;+#endif+ return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);+ }++ if (check_str_ptr)+ detect_partial_match(common, backtracks);+#ifdef SUPPORT_UTF+ if (common->utf)+ {+ GETCHAR(c, cc);+ }+ else+#endif+ c = *cc;++ if (type == OP_CHAR || !char_has_othercase(common, cc))+ {+ read_char_range(common, c, c, FALSE);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));+ return cc + length;+ }+ oc = char_othercase(common, c);+ read_char_range(common, c < oc ? c : oc, c > oc ? c : oc, FALSE);+ bit = c ^ oc;+ if (is_powerof2(bit))+ {+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));+ return cc + length;+ }+ jump[0] = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c);+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, oc));+ JUMPHERE(jump[0]);+ return cc + length;++ case OP_NOT:+ case OP_NOTI:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ length = 1;+#ifdef SUPPORT_UTF+ if (common->utf)+ {+#ifdef COMPILE_PCRE8+ c = *cc;+ if (c < 128)+ {+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);+ if (type == OP_NOT || !char_has_othercase(common, cc))+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));+ else+ {+ /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */+ OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20);+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));+ }+ /* Skip the variable-length character. */+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);+ JUMPHERE(jump[0]);+ return cc + 1;+ }+ else+#endif /* COMPILE_PCRE8 */+ {+ GETCHARLEN(c, cc, length);+ }+ }+ else+#endif /* SUPPORT_UTF */+ c = *cc;++ if (type == OP_NOT || !char_has_othercase(common, cc))+ {+ read_char_range(common, c, c, TRUE);+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));+ }+ else+ {+ oc = char_othercase(common, c);+ read_char_range(common, c < oc ? c : oc, c > oc ? c : oc, TRUE);+ bit = c ^ oc;+ if (is_powerof2(bit))+ {+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));+ }+ else+ {+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, oc));+ }+ }+ return cc + length;++ case OP_CLASS:+ case OP_NCLASS:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);++#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ bit = (common->utf && is_char7_bitset((const sljit_u8 *)cc, type == OP_NCLASS)) ? 127 : 255;+ read_char_range(common, 0, bit, type == OP_NCLASS);+#else+ read_char_range(common, 0, 255, type == OP_NCLASS);+#endif++ if (check_class_ranges(common, (const sljit_u8 *)cc, type == OP_NCLASS, FALSE, backtracks))+ return cc + 32 / sizeof(pcre_uchar);++#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ jump[0] = NULL;+ if (common->utf)+ {+ jump[0] = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, bit);+ if (type == OP_CLASS)+ {+ add_jump(compiler, backtracks, jump[0]);+ jump[0] = NULL;+ }+ }+#elif !defined COMPILE_PCRE8+ jump[0] = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);+ if (type == OP_CLASS)+ {+ add_jump(compiler, backtracks, jump[0]);+ jump[0] = NULL;+ }+#endif /* SUPPORT_UTF && COMPILE_PCRE8 */++ OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);+ OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);+ OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);+ OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);+ OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);+ add_jump(compiler, backtracks, JUMP(SLJIT_ZERO));++#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ if (jump[0] != NULL)+ JUMPHERE(jump[0]);+#endif+ return cc + 32 / sizeof(pcre_uchar);++#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32+ case OP_XCLASS:+ if (check_str_ptr)+ detect_partial_match(common, backtracks);+ compile_xclass_matchingpath(common, cc + LINK_SIZE, backtracks);+ return cc + GET(cc, 0) - 1;+#endif+ }+SLJIT_UNREACHABLE();+return cc;+}++static SLJIT_INLINE pcre_uchar *compile_charn_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **backtracks)+{+/* This function consumes at least one input character. */+/* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */+DEFINE_COMPILER;+pcre_uchar *ccbegin = cc;+compare_context context;+int size;++context.length = 0;+do+ {+ if (cc >= ccend)+ break;++ if (*cc == OP_CHAR)+ {+ size = 1;+#ifdef SUPPORT_UTF+ if (common->utf && HAS_EXTRALEN(cc[1]))+ size += GET_EXTRALEN(cc[1]);+#endif+ }+ else if (*cc == OP_CHARI)+ {+ size = 1;+#ifdef SUPPORT_UTF+ if (common->utf)+ {+ if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)+ size = 0;+ else if (HAS_EXTRALEN(cc[1]))+ size += GET_EXTRALEN(cc[1]);+ }+ else+#endif+ if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)+ size = 0;+ }+ else+ size = 0;++ cc += 1 + size;+ context.length += IN_UCHARS(size);+ }+while (size > 0 && context.length <= 128);++cc = ccbegin;+if (context.length > 0)+ {+ /* We have a fixed-length byte sequence. */+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, context.length);+ add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0));++ context.sourcereg = -1;+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED+ context.ucharptr = 0;+#endif+ do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, backtracks); while (context.length > 0);+ return cc;+ }++/* A non-fixed length character will be checked if length == 0. */+return compile_char1_matchingpath(common, *cc, cc + 1, backtracks, TRUE);+}++/* Forward definitions. */+static void compile_matchingpath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);+static void compile_backtrackingpath(compiler_common *, struct backtrack_common *);++#define PUSH_BACKTRACK(size, ccstart, error) \+ do \+ { \+ backtrack = sljit_alloc_memory(compiler, (size)); \+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \+ return error; \+ memset(backtrack, 0, size); \+ backtrack->prev = parent->top; \+ backtrack->cc = (ccstart); \+ parent->top = backtrack; \+ } \+ while (0)++#define PUSH_BACKTRACK_NOVALUE(size, ccstart) \+ do \+ { \+ backtrack = sljit_alloc_memory(compiler, (size)); \+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \+ return; \+ memset(backtrack, 0, size); \+ backtrack->prev = parent->top; \+ backtrack->cc = (ccstart); \+ parent->top = backtrack; \+ } \+ while (0)++#define BACKTRACK_AS(type) ((type *)backtrack)++static void compile_dnref_search(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)+{+/* The OVECTOR offset goes to TMP2. */+DEFINE_COMPILER;+int count = GET2(cc, 1 + IMM2_SIZE);+pcre_uchar *slot = common->name_table + GET2(cc, 1) * common->name_entry_size;+unsigned int offset;+jump_list *found = NULL;++SLJIT_ASSERT(*cc == OP_DNREF || *cc == OP_DNREFI);++OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));++count--;+while (count-- > 0)+ {+ offset = GET2(slot, 0) << 1;+ GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));+ add_jump(compiler, &found, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0));+ slot += common->name_entry_size;+ }++offset = GET2(slot, 0) << 1;+GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));+if (backtracks != NULL && !common->jscript_compat)+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0));++set_jumps(found, LABEL());+}++static void compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)+{+DEFINE_COMPILER;+BOOL ref = (*cc == OP_REF || *cc == OP_REFI);+int offset = 0;+struct sljit_jump *jump = NULL;+struct sljit_jump *partial;+struct sljit_jump *nopartial;++if (ref)+ {+ offset = GET2(cc, 1) << 1;+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));+ /* OVECTOR(1) contains the "string begin - 1" constant. */+ if (withchecks && !common->jscript_compat)+ add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));+ }+else+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);++#if defined SUPPORT_UTF && defined SUPPORT_UCP+if (common->utf && *cc == OP_REFI)+ {+ SLJIT_ASSERT(TMP1 == SLJIT_R0 && STACK_TOP == SLJIT_R1);+ if (ref)+ OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));+ else+ OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));++ if (withchecks)+ jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_R2, 0);++ /* No free saved registers so save data on stack. */+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);+ OP1(SLJIT_MOV, SLJIT_R1, 0, STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_R3, 0, STR_END, 0);+ sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_RET(SW) | SLJIT_ARG1(SW) | SLJIT_ARG2(SW) | SLJIT_ARG3(SW) | SLJIT_ARG4(SW), SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);++ if (common->mode == JIT_COMPILE)+ add_jump(compiler, backtracks, CMP(SLJIT_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));+ else+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_UNUSED, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);++ add_jump(compiler, backtracks, JUMP(SLJIT_LESS));++ nopartial = JUMP(SLJIT_NOT_EQUAL);+ OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);+ check_partial(common, FALSE);+ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));+ JUMPHERE(nopartial);+ }+ }+else+#endif /* SUPPORT_UTF && SUPPORT_UCP */+ {+ if (ref)+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP1, 0);+ else+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);++ if (withchecks)+ jump = JUMP(SLJIT_ZERO);++ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);+ partial = CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0);+ if (common->mode == JIT_COMPILE)+ add_jump(compiler, backtracks, partial);++ add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));++ if (common->mode != JIT_COMPILE)+ {+ nopartial = JUMP(SLJIT_JUMP);+ JUMPHERE(partial);+ /* TMP2 -= STR_END - STR_PTR */+ OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, STR_PTR, 0);+ OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, STR_END, 0);+ partial = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0);+ OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);+ add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));+ add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));+ JUMPHERE(partial);+ check_partial(common, FALSE);+ add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));+ JUMPHERE(nopartial);+ }+ }++if (jump != NULL)+ {+ if (emptyfail)+ add_jump(compiler, backtracks, jump);+ else+ JUMPHERE(jump);+ }+}++static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)+{+DEFINE_COMPILER;+BOOL ref = (*cc == OP_REF || *cc == OP_REFI);+backtrack_common *backtrack;+pcre_uchar type;+int offset = 0;+struct sljit_label *label;+struct sljit_jump *zerolength;+struct sljit_jump *jump = NULL;+pcre_uchar *ccbegin = cc;+int min = 0, max = 0;+BOOL minimize;++PUSH_BACKTRACK(sizeof(ref_iterator_backtrack), cc, NULL);++if (ref)+ offset = GET2(cc, 1) << 1;+else+ cc += IMM2_SIZE;+type = cc[1 + IMM2_SIZE];++SLJIT_COMPILE_ASSERT((OP_CRSTAR & 0x1) == 0, crstar_opcode_must_be_even);+minimize = (type & 0x1) != 0;+switch(type)+ {+ case OP_CRSTAR:+ case OP_CRMINSTAR:+ min = 0;+ max = 0;+ cc += 1 + IMM2_SIZE + 1;+ break;+ case OP_CRPLUS:+ case OP_CRMINPLUS:+ min = 1;+ max = 0;+ cc += 1 + IMM2_SIZE + 1;+ break;+ case OP_CRQUERY:+ case OP_CRMINQUERY:+ min = 0;+ max = 1;+ cc += 1 + IMM2_SIZE + 1;+ break;+ case OP_CRRANGE:+ case OP_CRMINRANGE:+ min = GET2(cc, 1 + IMM2_SIZE + 1);+ max = GET2(cc, 1 + IMM2_SIZE + 1 + IMM2_SIZE);+ cc += 1 + IMM2_SIZE + 1 + 2 * IMM2_SIZE;+ break;+ default:+ SLJIT_UNREACHABLE();+ break;+ }++if (!minimize)+ {+ if (min == 0)+ {+ allocate_stack(common, 2);+ if (ref)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);+ /* Temporary release of STR_PTR. */+ OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));+ /* Handles both invalid and empty cases. Since the minimum repeat,+ is zero the invalid case is basically the same as an empty case. */+ if (ref)+ zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));+ else+ {+ compile_dnref_search(common, ccbegin, NULL);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, TMP2, 0);+ zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));+ }+ /* Restore if not zero length. */+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));+ }+ else+ {+ allocate_stack(common, 1);+ if (ref)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ if (ref)+ {+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));+ zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));+ }+ else+ {+ compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, TMP2, 0);+ zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));+ }+ }++ if (min > 1 || max > 1)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, SLJIT_IMM, 0);++ label = LABEL();+ if (!ref)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1);+ compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);++ if (min > 1 || max > 1)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0);+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, TMP1, 0);+ if (min > 1)+ CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, min, label);+ if (max > 1)+ {+ jump = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ JUMPTO(SLJIT_JUMP, label);+ JUMPHERE(jump);+ }+ }++ if (max == 0)+ {+ /* Includes min > 1 case as well. */+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ JUMPTO(SLJIT_JUMP, label);+ }++ JUMPHERE(zerolength);+ BACKTRACK_AS(ref_iterator_backtrack)->matchingpath = LABEL();++ count_match(common);+ return cc;+ }++allocate_stack(common, ref ? 2 : 3);+if (ref)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+if (type != OP_CRMINSTAR)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);++if (min == 0)+ {+ /* Handles both invalid and empty cases. Since the minimum repeat,+ is zero the invalid case is basically the same as an empty case. */+ if (ref)+ zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));+ else+ {+ compile_dnref_search(common, ccbegin, NULL);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);+ zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));+ }+ /* Length is non-zero, we can match real repeats. */+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ jump = JUMP(SLJIT_JUMP);+ }+else+ {+ if (ref)+ {+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));+ zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));+ }+ else+ {+ compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);+ zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));+ }+ }++BACKTRACK_AS(ref_iterator_backtrack)->matchingpath = LABEL();+if (max > 0)+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));++if (!ref)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(2));+compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);++if (min > 1)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);+ CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, min, BACKTRACK_AS(ref_iterator_backtrack)->matchingpath);+ }+else if (max > 0)+ OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);++if (jump != NULL)+ JUMPHERE(jump);+JUMPHERE(zerolength);++count_match(common);+return cc;+}++static SLJIT_INLINE pcre_uchar *compile_recurse_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;+recurse_entry *entry = common->entries;+recurse_entry *prev = NULL;+sljit_sw start = GET(cc, 1);+pcre_uchar *start_cc;+BOOL needs_control_head;++PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);++/* Inlining simple patterns. */+if (get_framesize(common, common->start + start, NULL, TRUE, &needs_control_head) == no_stack)+ {+ start_cc = common->start + start;+ compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);+ BACKTRACK_AS(recurse_backtrack)->inlined_pattern = TRUE;+ return cc + 1 + LINK_SIZE;+ }++while (entry != NULL)+ {+ if (entry->start == start)+ break;+ prev = entry;+ entry = entry->next;+ }++if (entry == NULL)+ {+ entry = sljit_alloc_memory(compiler, sizeof(recurse_entry));+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return NULL;+ entry->next = NULL;+ entry->entry = NULL;+ entry->calls = NULL;+ entry->start = start;++ if (prev != NULL)+ prev->next = entry;+ else+ common->entries = entry;+ }++if (common->has_set_som && common->mark_ptr != 0)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));+ allocate_stack(common, 2);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);+ }+else if (common->has_set_som || common->mark_ptr != 0)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr);+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);+ }++if (entry->entry == NULL)+ add_jump(compiler, &entry->calls, JUMP(SLJIT_FAST_CALL));+else+ JUMPTO(SLJIT_FAST_CALL, entry->entry);+/* Leave if the match is failed. */+add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0));+return cc + 1 + LINK_SIZE;+}++static sljit_s32 SLJIT_FUNC do_callout(struct jit_arguments *arguments, PUBL(callout_block) *callout_block, pcre_uchar **jit_ovector)+{+const pcre_uchar *begin = arguments->begin;+int *offset_vector = arguments->offsets;+int offset_count = arguments->offset_count;+int i;++if (PUBL(callout) == NULL)+ return 0;++callout_block->version = 2;+callout_block->callout_data = arguments->callout_data;++/* Offsets in subject. */+callout_block->subject_length = arguments->end - arguments->begin;+callout_block->start_match = (pcre_uchar*)callout_block->subject - arguments->begin;+callout_block->current_position = (pcre_uchar*)callout_block->offset_vector - arguments->begin;+#if defined COMPILE_PCRE8+callout_block->subject = (PCRE_SPTR)begin;+#elif defined COMPILE_PCRE16+callout_block->subject = (PCRE_SPTR16)begin;+#elif defined COMPILE_PCRE32+callout_block->subject = (PCRE_SPTR32)begin;+#endif++/* Convert and copy the JIT offset vector to the offset_vector array. */+callout_block->capture_top = 0;+callout_block->offset_vector = offset_vector;+for (i = 2; i < offset_count; i += 2)+ {+ offset_vector[i] = jit_ovector[i] - begin;+ offset_vector[i + 1] = jit_ovector[i + 1] - begin;+ if (jit_ovector[i] >= begin)+ callout_block->capture_top = i;+ }++callout_block->capture_top = (callout_block->capture_top >> 1) + 1;+if (offset_count > 0)+ offset_vector[0] = -1;+if (offset_count > 1)+ offset_vector[1] = -1;+return (*PUBL(callout))(callout_block);+}++/* Aligning to 8 byte. */+#define CALLOUT_ARG_SIZE \+ (((int)sizeof(PUBL(callout_block)) + 7) & ~7)++#define CALLOUT_ARG_OFFSET(arg) \+ SLJIT_OFFSETOF(PUBL(callout_block), arg)++static SLJIT_INLINE pcre_uchar *compile_callout_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;++PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);++allocate_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));++SLJIT_ASSERT(common->capture_last_ptr != 0);+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);+OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+OP1(SLJIT_MOV_S32, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);+OP1(SLJIT_MOV_S32, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(capture_last), TMP2, 0);++/* These pointer sized fields temporarly stores internal variables. */+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(offset_vector), STR_PTR, 0);+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(subject), TMP2, 0);++if (common->mark_ptr != 0)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr));+OP1(SLJIT_MOV_S32, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 2));+OP1(SLJIT_MOV_S32, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(next_item_length), SLJIT_IMM, GET(cc, 2 + LINK_SIZE));+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(mark), (common->mark_ptr != 0) ? TMP2 : SLJIT_IMM, 0);++/* Needed to save important temporary registers. */+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);+/* SLJIT_R0 = arguments */+OP1(SLJIT_MOV, SLJIT_R1, 0, STACK_TOP, 0);+GET_LOCAL_BASE(SLJIT_R2, 0, OVECTOR_START);+sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_RET(S32) | SLJIT_ARG1(SW) | SLJIT_ARG2(SW) | SLJIT_ARG3(SW), SLJIT_IMM, SLJIT_FUNC_OFFSET(do_callout));+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);+free_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));++/* Check return value. */+OP2(SLJIT_SUB32 | SLJIT_SET_Z | SLJIT_SET_SIG_GREATER, SLJIT_UNUSED, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);+add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_SIG_GREATER32));+if (common->forced_quit_label == NULL)+ add_jump(compiler, &common->forced_quit, JUMP(SLJIT_NOT_EQUAL32) /* SIG_LESS */);+else+ JUMPTO(SLJIT_NOT_EQUAL32 /* SIG_LESS */, common->forced_quit_label);+return cc + 2 + 2 * LINK_SIZE;+}++#undef CALLOUT_ARG_SIZE+#undef CALLOUT_ARG_OFFSET++static SLJIT_INLINE BOOL assert_needs_str_ptr_saving(pcre_uchar *cc)+{+while (TRUE)+ {+ switch (*cc)+ {+ case OP_NOT_WORD_BOUNDARY:+ case OP_WORD_BOUNDARY:+ case OP_CIRC:+ case OP_CIRCM:+ case OP_DOLL:+ case OP_DOLLM:+ case OP_CALLOUT:+ case OP_ALT:+ cc += PRIV(OP_lengths)[*cc];+ break;++ case OP_KET:+ return FALSE;++ default:+ return TRUE;+ }+ }+}++static pcre_uchar *compile_assert_matchingpath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)+{+DEFINE_COMPILER;+int framesize;+int extrasize;+BOOL needs_control_head;+int private_data_ptr;+backtrack_common altbacktrack;+pcre_uchar *ccbegin;+pcre_uchar opcode;+pcre_uchar bra = OP_BRA;+jump_list *tmp = NULL;+jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;+jump_list **found;+/* Saving previous accept variables. */+BOOL save_local_exit = common->local_exit;+BOOL save_positive_assert = common->positive_assert;+then_trap_backtrack *save_then_trap = common->then_trap;+struct sljit_label *save_quit_label = common->quit_label;+struct sljit_label *save_accept_label = common->accept_label;+jump_list *save_quit = common->quit;+jump_list *save_positive_assert_quit = common->positive_assert_quit;+jump_list *save_accept = common->accept;+struct sljit_jump *jump;+struct sljit_jump *brajump = NULL;++/* Assert captures then. */+common->then_trap = NULL;++if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)+ {+ SLJIT_ASSERT(!conditional);+ bra = *cc;+ cc++;+ }+private_data_ptr = PRIVATE_DATA(cc);+SLJIT_ASSERT(private_data_ptr != 0);+framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);+backtrack->framesize = framesize;+backtrack->private_data_ptr = private_data_ptr;+opcode = *cc;+SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);+found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;+ccbegin = cc;+cc += GET(cc, 1);++if (bra == OP_BRAMINZERO)+ {+ /* This is a braminzero backtrack path. */+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ brajump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);+ }++if (framesize < 0)+ {+ extrasize = 1;+ if (bra == OP_BRA && !assert_needs_str_ptr_saving(ccbegin + 1 + LINK_SIZE))+ extrasize = 0;++ if (needs_control_head)+ extrasize++;++ if (framesize == no_frame)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);++ if (extrasize > 0)+ allocate_stack(common, extrasize);++ if (needs_control_head)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);++ if (extrasize > 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);++ if (needs_control_head)+ {+ SLJIT_ASSERT(extrasize == 2);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);+ }+ }+else+ {+ extrasize = needs_control_head ? 3 : 2;+ allocate_stack(common, framesize + extrasize);++ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ OP2(SLJIT_ADD, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);+ if (needs_control_head)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);++ if (needs_control_head)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);+ }+ else+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);++ init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);+ }++memset(&altbacktrack, 0, sizeof(backtrack_common));+if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)+ {+ /* Negative assert is stronger than positive assert. */+ common->local_exit = TRUE;+ common->quit_label = NULL;+ common->quit = NULL;+ common->positive_assert = FALSE;+ }+else+ common->positive_assert = TRUE;+common->positive_assert_quit = NULL;++while (1)+ {+ common->accept_label = NULL;+ common->accept = NULL;+ altbacktrack.top = NULL;+ altbacktrack.topbacktracks = NULL;++ if (*ccbegin == OP_ALT && extrasize > 0)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));++ altbacktrack.cc = ccbegin;+ compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ {+ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)+ {+ common->local_exit = save_local_exit;+ common->quit_label = save_quit_label;+ common->quit = save_quit;+ }+ common->positive_assert = save_positive_assert;+ common->then_trap = save_then_trap;+ common->accept_label = save_accept_label;+ common->positive_assert_quit = save_positive_assert_quit;+ common->accept = save_accept;+ return NULL;+ }+ common->accept_label = LABEL();+ if (common->accept != NULL)+ set_jumps(common->accept, common->accept_label);++ /* Reset stack. */+ if (framesize < 0)+ {+ if (framesize == no_frame)+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ else if (extrasize > 0)+ free_stack(common, extrasize);++ if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(-1));+ }+ else+ {+ if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)+ {+ /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */+ OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));+ if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(-1));+ }+ else+ {+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(-framesize - 2));+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ }+ }++ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)+ {+ /* We know that STR_PTR was stored on the top of the stack. */+ if (conditional)+ {+ if (extrasize > 0)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), needs_control_head ? STACK(-2) : STACK(-1));+ }+ else if (bra == OP_BRAZERO)+ {+ if (framesize < 0)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-extrasize));+ else+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(-framesize - 1));+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-framesize - extrasize));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);+ }+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ }+ else if (framesize >= 0)+ {+ /* For OP_BRA and OP_BRAMINZERO. */+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-framesize - 1));+ }+ }+ add_jump(compiler, found, JUMP(SLJIT_JUMP));++ compile_backtrackingpath(common, altbacktrack.top);+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ {+ if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)+ {+ common->local_exit = save_local_exit;+ common->quit_label = save_quit_label;+ common->quit = save_quit;+ }+ common->positive_assert = save_positive_assert;+ common->then_trap = save_then_trap;+ common->accept_label = save_accept_label;+ common->positive_assert_quit = save_positive_assert_quit;+ common->accept = save_accept;+ return NULL;+ }+ set_jumps(altbacktrack.topbacktracks, LABEL());++ if (*cc != OP_ALT)+ break;++ ccbegin = cc;+ cc += GET(cc, 1);+ }++if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)+ {+ SLJIT_ASSERT(common->positive_assert_quit == NULL);+ /* Makes the check less complicated below. */+ common->positive_assert_quit = common->quit;+ }++/* None of them matched. */+if (common->positive_assert_quit != NULL)+ {+ jump = JUMP(SLJIT_JUMP);+ set_jumps(common->positive_assert_quit, LABEL());+ SLJIT_ASSERT(framesize != no_stack);+ if (framesize < 0)+ OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, extrasize * sizeof(sljit_sw));+ else+ {+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));+ }+ JUMPHERE(jump);+ }++if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(1));++if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)+ {+ /* Assert is failed. */+ if ((conditional && extrasize > 0) || bra == OP_BRAZERO)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));++ if (framesize < 0)+ {+ /* The topmost item should be 0. */+ if (bra == OP_BRAZERO)+ {+ if (extrasize == 2)+ free_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ }+ else if (extrasize > 0)+ free_stack(common, extrasize);+ }+ else+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));+ /* The topmost item should be 0. */+ if (bra == OP_BRAZERO)+ {+ free_stack(common, framesize + extrasize - 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ }+ else+ free_stack(common, framesize + extrasize);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);+ }+ jump = JUMP(SLJIT_JUMP);+ if (bra != OP_BRAZERO)+ add_jump(compiler, target, jump);++ /* Assert is successful. */+ set_jumps(tmp, LABEL());+ if (framesize < 0)+ {+ /* We know that STR_PTR was stored on the top of the stack. */+ if (extrasize > 0)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-extrasize));++ /* Keep the STR_PTR on the top of the stack. */+ if (bra == OP_BRAZERO)+ {+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));+ if (extrasize == 2)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ }+ else if (bra == OP_BRAMINZERO)+ {+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ }+ }+ else+ {+ if (bra == OP_BRA)+ {+ /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */+ OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-extrasize + 1));+ }+ else+ {+ /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */+ OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_sw));+ if (extrasize == 2)+ {+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ if (bra == OP_BRAMINZERO)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ }+ else+ {+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);+ }+ }+ }++ if (bra == OP_BRAZERO)+ {+ backtrack->matchingpath = LABEL();+ SET_LABEL(jump, backtrack->matchingpath);+ }+ else if (bra == OP_BRAMINZERO)+ {+ JUMPTO(SLJIT_JUMP, backtrack->matchingpath);+ JUMPHERE(brajump);+ if (framesize >= 0)+ {+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-framesize - 1));+ }+ set_jumps(backtrack->common.topbacktracks, LABEL());+ }+ }+else+ {+ /* AssertNot is successful. */+ if (framesize < 0)+ {+ if (extrasize > 0)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));++ if (bra != OP_BRA)+ {+ if (extrasize == 2)+ free_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ }+ else if (extrasize > 0)+ free_stack(common, extrasize);+ }+ else+ {+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));+ /* The topmost item should be 0. */+ if (bra != OP_BRA)+ {+ free_stack(common, framesize + extrasize - 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ }+ else+ free_stack(common, framesize + extrasize);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);+ }++ if (bra == OP_BRAZERO)+ backtrack->matchingpath = LABEL();+ else if (bra == OP_BRAMINZERO)+ {+ JUMPTO(SLJIT_JUMP, backtrack->matchingpath);+ JUMPHERE(brajump);+ }++ if (bra != OP_BRA)+ {+ SLJIT_ASSERT(found == &backtrack->common.topbacktracks);+ set_jumps(backtrack->common.topbacktracks, LABEL());+ backtrack->common.topbacktracks = NULL;+ }+ }++if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)+ {+ common->local_exit = save_local_exit;+ common->quit_label = save_quit_label;+ common->quit = save_quit;+ }+common->positive_assert = save_positive_assert;+common->then_trap = save_then_trap;+common->accept_label = save_accept_label;+common->positive_assert_quit = save_positive_assert_quit;+common->accept = save_accept;+return cc + 1 + LINK_SIZE;+}++static SLJIT_INLINE void match_once_common(compiler_common *common, pcre_uchar ket, int framesize, int private_data_ptr, BOOL has_alternatives, BOOL needs_control_head)+{+DEFINE_COMPILER;+int stacksize;++if (framesize < 0)+ {+ if (framesize == no_frame)+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ else+ {+ stacksize = needs_control_head ? 1 : 0;+ if (ket != OP_KET || has_alternatives)+ stacksize++;++ if (stacksize > 0)+ free_stack(common, stacksize);+ }++ if (needs_control_head)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (ket != OP_KET || has_alternatives) ? STACK(-2) : STACK(-1));++ /* TMP2 which is set here used by OP_KETRMAX below. */+ if (ket == OP_KETRMAX)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(-1));+ else if (ket == OP_KETRMIN)+ {+ /* Move the STR_PTR to the private_data_ptr. */+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-1));+ }+ }+else+ {+ stacksize = (ket != OP_KET || has_alternatives) ? 2 : 1;+ OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + stacksize) * sizeof(sljit_sw));+ if (needs_control_head)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(-1));++ if (ket == OP_KETRMAX)+ {+ /* TMP2 which is set here used by OP_KETRMAX below. */+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ }+ }+if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP1, 0);+}++static SLJIT_INLINE int match_capture_common(compiler_common *common, int stacksize, int offset, int private_data_ptr)+{+DEFINE_COMPILER;++if (common->capture_last_ptr != 0)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);+ stacksize++;+ }+if (common->optimized_cbracket[offset >> 1] == 0)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);+ stacksize += 2;+ }+return stacksize;+}++/*+ Handling bracketed expressions is probably the most complex part.++ Stack layout naming characters:+ S - Push the current STR_PTR+ 0 - Push a 0 (NULL)+ A - Push the current STR_PTR. Needed for restoring the STR_PTR+ before the next alternative. Not pushed if there are no alternatives.+ M - Any values pushed by the current alternative. Can be empty, or anything.+ C - Push the previous OVECTOR(i), OVECTOR(i+1) and OVECTOR_PRIV(i) to the stack.+ L - Push the previous local (pointed by localptr) to the stack+ () - opional values stored on the stack+ ()* - optonal, can be stored multiple times++ The following list shows the regular expression templates, their PCRE byte codes+ and stack layout supported by pcre-sljit.++ (?:) OP_BRA | OP_KET A M+ () OP_CBRA | OP_KET C M+ (?:)+ OP_BRA | OP_KETRMAX 0 A M S ( A M S )*+ OP_SBRA | OP_KETRMAX 0 L M S ( L M S )*+ (?:)+? OP_BRA | OP_KETRMIN 0 A M S ( A M S )*+ OP_SBRA | OP_KETRMIN 0 L M S ( L M S )*+ ()+ OP_CBRA | OP_KETRMAX 0 C M S ( C M S )*+ OP_SCBRA | OP_KETRMAX 0 C M S ( C M S )*+ ()+? OP_CBRA | OP_KETRMIN 0 C M S ( C M S )*+ OP_SCBRA | OP_KETRMIN 0 C M S ( C M S )*+ (?:)? OP_BRAZERO | OP_BRA | OP_KET S ( A M 0 )+ (?:)?? OP_BRAMINZERO | OP_BRA | OP_KET S ( A M 0 )+ ()? OP_BRAZERO | OP_CBRA | OP_KET S ( C M 0 )+ ()?? OP_BRAMINZERO | OP_CBRA | OP_KET S ( C M 0 )+ (?:)* OP_BRAZERO | OP_BRA | OP_KETRMAX S 0 ( A M S )*+ OP_BRAZERO | OP_SBRA | OP_KETRMAX S 0 ( L M S )*+ (?:)*? OP_BRAMINZERO | OP_BRA | OP_KETRMIN S 0 ( A M S )*+ OP_BRAMINZERO | OP_SBRA | OP_KETRMIN S 0 ( L M S )*+ ()* OP_BRAZERO | OP_CBRA | OP_KETRMAX S 0 ( C M S )*+ OP_BRAZERO | OP_SCBRA | OP_KETRMAX S 0 ( C M S )*+ ()*? OP_BRAMINZERO | OP_CBRA | OP_KETRMIN S 0 ( C M S )*+ OP_BRAMINZERO | OP_SCBRA | OP_KETRMIN S 0 ( C M S )*+++ Stack layout naming characters:+ A - Push the alternative index (starting from 0) on the stack.+ Not pushed if there is no alternatives.+ M - Any values pushed by the current alternative. Can be empty, or anything.++ The next list shows the possible content of a bracket:+ (|) OP_*BRA | OP_ALT ... M A+ (?()|) OP_*COND | OP_ALT M A+ (?>|) OP_ONCE | OP_ALT ... [stack trace] M A+ (?>|) OP_ONCE_NC | OP_ALT ... [stack trace] M A+ Or nothing, if trace is unnecessary+*/++static pcre_uchar *compile_bracket_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;+pcre_uchar opcode;+int private_data_ptr = 0;+int offset = 0;+int i, stacksize;+int repeat_ptr = 0, repeat_length = 0;+int repeat_type = 0, repeat_count = 0;+pcre_uchar *ccbegin;+pcre_uchar *matchingpath;+pcre_uchar *slot;+pcre_uchar bra = OP_BRA;+pcre_uchar ket;+assert_backtrack *assert;+BOOL has_alternatives;+BOOL needs_control_head = FALSE;+struct sljit_jump *jump;+struct sljit_jump *skip;+struct sljit_label *rmax_label = NULL;+struct sljit_jump *braminzero = NULL;++PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);++if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)+ {+ bra = *cc;+ cc++;+ opcode = *cc;+ }++opcode = *cc;+ccbegin = cc;+matchingpath = bracketend(cc) - 1 - LINK_SIZE;+ket = *matchingpath;+if (ket == OP_KET && PRIVATE_DATA(matchingpath) != 0)+ {+ repeat_ptr = PRIVATE_DATA(matchingpath);+ repeat_length = PRIVATE_DATA(matchingpath + 1);+ repeat_type = PRIVATE_DATA(matchingpath + 2);+ repeat_count = PRIVATE_DATA(matchingpath + 3);+ SLJIT_ASSERT(repeat_length != 0 && repeat_type != 0 && repeat_count != 0);+ if (repeat_type == OP_UPTO)+ ket = OP_KETRMAX;+ if (repeat_type == OP_MINUPTO)+ ket = OP_KETRMIN;+ }++if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)+ {+ /* Drop this bracket_backtrack. */+ parent->top = backtrack->prev;+ return matchingpath + 1 + LINK_SIZE + repeat_length;+ }++matchingpath = ccbegin + 1 + LINK_SIZE;+SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);+SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));+cc += GET(cc, 1);++has_alternatives = *cc == OP_ALT;+if (SLJIT_UNLIKELY(opcode == OP_COND || opcode == OP_SCOND))+ has_alternatives = (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF || *matchingpath == OP_FAIL) ? FALSE : TRUE;++if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))+ opcode = OP_SCOND;+if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))+ opcode = OP_ONCE;++if (opcode == OP_CBRA || opcode == OP_SCBRA)+ {+ /* Capturing brackets has a pre-allocated space. */+ offset = GET2(ccbegin, 1 + LINK_SIZE);+ if (common->optimized_cbracket[offset] == 0)+ {+ private_data_ptr = OVECTOR_PRIV(offset);+ offset <<= 1;+ }+ else+ {+ offset <<= 1;+ private_data_ptr = OVECTOR(offset);+ }+ BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;+ matchingpath += IMM2_SIZE;+ }+else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)+ {+ /* Other brackets simply allocate the next entry. */+ private_data_ptr = PRIVATE_DATA(ccbegin);+ SLJIT_ASSERT(private_data_ptr != 0);+ BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;+ if (opcode == OP_ONCE)+ BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, NULL, FALSE, &needs_control_head);+ }++/* Instructions before the first alternative. */+stacksize = 0;+if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))+ stacksize++;+if (bra == OP_BRAZERO)+ stacksize++;++if (stacksize > 0)+ allocate_stack(common, stacksize);++stacksize = 0;+if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);+ stacksize++;+ }++if (bra == OP_BRAZERO)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);++if (bra == OP_BRAMINZERO)+ {+ /* This is a backtrack path! (Since the try-path of OP_BRAMINZERO matches to the empty string) */+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ if (ket != OP_KETRMIN)+ {+ free_stack(common, 1);+ braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);+ }+ else+ {+ if (opcode == OP_ONCE || opcode >= OP_SBRA)+ {+ jump = CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ /* Nothing stored during the first run. */+ skip = JUMP(SLJIT_JUMP);+ JUMPHERE(jump);+ /* Checking zero-length iteration. */+ if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)+ {+ /* When we come from outside, private_data_ptr contains the previous STR_PTR. */+ braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ }+ else+ {+ /* Except when the whole stack frame must be saved. */+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), STACK(-BACKTRACK_AS(bracket_backtrack)->u.framesize - 2));+ }+ JUMPHERE(skip);+ }+ else+ {+ jump = CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ JUMPHERE(jump);+ }+ }+ }++if (repeat_type != 0)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, repeat_count);+ if (repeat_type == OP_EXACT)+ rmax_label = LABEL();+ }++if (ket == OP_KETRMIN)+ BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();++if (ket == OP_KETRMAX)+ {+ rmax_label = LABEL();+ if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA && repeat_type == 0)+ BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmax_label;+ }++/* Handling capturing brackets and alternatives. */+if (opcode == OP_ONCE)+ {+ stacksize = 0;+ if (needs_control_head)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+ stacksize++;+ }++ if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)+ {+ /* Neither capturing brackets nor recursions are found in the block. */+ if (ket == OP_KETRMIN)+ {+ stacksize += 2;+ if (!needs_control_head)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ }+ else+ {+ if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);+ if (ket == OP_KETRMAX || has_alternatives)+ stacksize++;+ }++ if (stacksize > 0)+ allocate_stack(common, stacksize);++ stacksize = 0;+ if (needs_control_head)+ {+ stacksize++;+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);+ }++ if (ket == OP_KETRMIN)+ {+ if (needs_control_head)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);+ if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)+ OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, needs_control_head ? (2 * sizeof(sljit_sw)) : sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);+ }+ else if (ket == OP_KETRMAX || has_alternatives)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);+ }+ else+ {+ if (ket != OP_KET || has_alternatives)+ stacksize++;++ stacksize += BACKTRACK_AS(bracket_backtrack)->u.framesize + 1;+ allocate_stack(common, stacksize);++ if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);++ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ OP2(SLJIT_ADD, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));++ stacksize = needs_control_head ? 1 : 0;+ if (ket != OP_KET || has_alternatives)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);+ stacksize++;+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);+ }+ else+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);+ }+ init_frame(common, ccbegin, NULL, BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize, stacksize + 1, FALSE);+ }+ }+else if (opcode == OP_CBRA || opcode == OP_SCBRA)+ {+ /* Saving the previous values. */+ if (common->optimized_cbracket[offset >> 1] != 0)+ {+ SLJIT_ASSERT(private_data_ptr == OVECTOR(offset));+ allocate_stack(common, 2);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr + sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);+ }+ else+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);+ }+ }+else if (opcode == OP_SBRA || opcode == OP_SCOND)+ {+ /* Saving the previous value. */+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);+ }+else if (has_alternatives)+ {+ /* Pushing the starting string pointer. */+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ }++/* Generating code for the first alternative. */+if (opcode == OP_COND || opcode == OP_SCOND)+ {+ if (*matchingpath == OP_CREF)+ {+ SLJIT_ASSERT(has_alternatives);+ add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed),+ CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));+ matchingpath += 1 + IMM2_SIZE;+ }+ else if (*matchingpath == OP_DNCREF)+ {+ SLJIT_ASSERT(has_alternatives);++ i = GET2(matchingpath, 1 + IMM2_SIZE);+ slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;+ OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);+ slot += common->name_entry_size;+ i--;+ while (i-- > 0)+ {+ OP2(SLJIT_SUB, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);+ OP2(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, TMP2, 0, STR_PTR, 0);+ slot += common->name_entry_size;+ }+ OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);+ add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), JUMP(SLJIT_ZERO));+ matchingpath += 1 + 2 * IMM2_SIZE;+ }+ else if (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF || *matchingpath == OP_FAIL)+ {+ /* Never has other case. */+ BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;+ SLJIT_ASSERT(!has_alternatives);++ if (*matchingpath == OP_FAIL)+ stacksize = 0;+ else if (*matchingpath == OP_RREF)+ {+ stacksize = GET2(matchingpath, 1);+ if (common->currententry == NULL)+ stacksize = 0;+ else if (stacksize == RREF_ANY)+ stacksize = 1;+ else if (common->currententry->start == 0)+ stacksize = stacksize == 0;+ else+ stacksize = stacksize == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);++ if (stacksize != 0)+ matchingpath += 1 + IMM2_SIZE;+ }+ else+ {+ if (common->currententry == NULL || common->currententry->start == 0)+ stacksize = 0;+ else+ {+ stacksize = GET2(matchingpath, 1 + IMM2_SIZE);+ slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;+ i = (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);+ while (stacksize > 0)+ {+ if ((int)GET2(slot, 0) == i)+ break;+ slot += common->name_entry_size;+ stacksize--;+ }+ }++ if (stacksize != 0)+ matchingpath += 1 + 2 * IMM2_SIZE;+ }++ /* The stacksize == 0 is a common "else" case. */+ if (stacksize == 0)+ {+ if (*cc == OP_ALT)+ {+ matchingpath = cc + 1 + LINK_SIZE;+ cc += GET(cc, 1);+ }+ else+ matchingpath = cc;+ }+ }+ else+ {+ SLJIT_ASSERT(has_alternatives && *matchingpath >= OP_ASSERT && *matchingpath <= OP_ASSERTBACK_NOT);+ /* Similar code as PUSH_BACKTRACK macro. */+ assert = sljit_alloc_memory(compiler, sizeof(assert_backtrack));+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return NULL;+ memset(assert, 0, sizeof(assert_backtrack));+ assert->common.cc = matchingpath;+ BACKTRACK_AS(bracket_backtrack)->u.assert = assert;+ matchingpath = compile_assert_matchingpath(common, matchingpath, assert, TRUE);+ }+ }++compile_matchingpath(common, matchingpath, cc, backtrack);+if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return NULL;++if (opcode == OP_ONCE)+ match_once_common(common, ket, BACKTRACK_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);++stacksize = 0;+if (repeat_type == OP_MINUPTO)+ {+ /* We need to preserve the counter. TMP2 will be used below. */+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);+ stacksize++;+ }+if (ket != OP_KET || bra != OP_BRA)+ stacksize++;+if (offset != 0)+ {+ if (common->capture_last_ptr != 0)+ stacksize++;+ if (common->optimized_cbracket[offset >> 1] == 0)+ stacksize += 2;+ }+if (has_alternatives && opcode != OP_ONCE)+ stacksize++;++if (stacksize > 0)+ allocate_stack(common, stacksize);++stacksize = 0;+if (repeat_type == OP_MINUPTO)+ {+ /* TMP2 was set above. */+ OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);+ stacksize++;+ }++if (ket != OP_KET || bra != OP_BRA)+ {+ if (ket != OP_KET)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);+ else+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);+ stacksize++;+ }++if (offset != 0)+ stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);++if (has_alternatives)+ {+ if (opcode != OP_ONCE)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);+ if (ket != OP_KETRMAX)+ BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();+ }++/* Must be after the matchingpath label. */+if (offset != 0 && common->optimized_cbracket[offset >> 1] != 0)+ {+ SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);+ }++if (ket == OP_KETRMAX)+ {+ if (repeat_type != 0)+ {+ if (has_alternatives)+ BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, rmax_label);+ /* Drop STR_PTR for greedy plus quantifier. */+ if (opcode != OP_ONCE)+ free_stack(common, 1);+ }+ else if (opcode == OP_ONCE || opcode >= OP_SBRA)+ {+ if (has_alternatives)+ BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();+ /* Checking zero-length iteration. */+ if (opcode != OP_ONCE)+ {+ CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0, rmax_label);+ /* Drop STR_PTR for greedy plus quantifier. */+ if (bra != OP_BRAZERO)+ free_stack(common, 1);+ }+ else+ /* TMP2 must contain the starting STR_PTR. */+ CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmax_label);+ }+ else+ JUMPTO(SLJIT_JUMP, rmax_label);+ BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();+ }++if (repeat_type == OP_EXACT)+ {+ count_match(common);+ OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, rmax_label);+ }+else if (repeat_type == OP_UPTO)+ {+ /* We need to preserve the counter. */+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);+ }++if (bra == OP_BRAZERO)+ BACKTRACK_AS(bracket_backtrack)->zero_matchingpath = LABEL();++if (bra == OP_BRAMINZERO)+ {+ /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */+ JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->matchingpath);+ if (braminzero != NULL)+ {+ JUMPHERE(braminzero);+ /* We need to release the end pointer to perform the+ backtrack for the zero-length iteration. When+ framesize is < 0, OP_ONCE will do the release itself. */+ if (opcode == OP_ONCE && BACKTRACK_AS(bracket_backtrack)->u.framesize >= 0)+ {+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ }+ else if (ket == OP_KETRMIN && opcode != OP_ONCE)+ free_stack(common, 1);+ }+ /* Continue to the normal backtrack. */+ }++if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)+ count_match(common);++/* Skip the other alternatives. */+while (*cc == OP_ALT)+ cc += GET(cc, 1);+cc += 1 + LINK_SIZE;++if (opcode == OP_ONCE)+ {+ /* We temporarily encode the needs_control_head in the lowest bit.+ Note: on the target architectures of SLJIT the ((x << 1) >> 1) returns+ the same value for small signed numbers (including negative numbers). */+ BACKTRACK_AS(bracket_backtrack)->u.framesize = (BACKTRACK_AS(bracket_backtrack)->u.framesize << 1) | (needs_control_head ? 1 : 0);+ }+return cc + repeat_length;+}++static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;+pcre_uchar opcode;+int private_data_ptr;+int cbraprivptr = 0;+BOOL needs_control_head;+int framesize;+int stacksize;+int offset = 0;+BOOL zero = FALSE;+pcre_uchar *ccbegin = NULL;+int stack; /* Also contains the offset of control head. */+struct sljit_label *loop = NULL;+struct jump_list *emptymatch = NULL;++PUSH_BACKTRACK(sizeof(bracketpos_backtrack), cc, NULL);+if (*cc == OP_BRAPOSZERO)+ {+ zero = TRUE;+ cc++;+ }++opcode = *cc;+private_data_ptr = PRIVATE_DATA(cc);+SLJIT_ASSERT(private_data_ptr != 0);+BACKTRACK_AS(bracketpos_backtrack)->private_data_ptr = private_data_ptr;+switch(opcode)+ {+ case OP_BRAPOS:+ case OP_SBRAPOS:+ ccbegin = cc + 1 + LINK_SIZE;+ break;++ case OP_CBRAPOS:+ case OP_SCBRAPOS:+ offset = GET2(cc, 1 + LINK_SIZE);+ /* This case cannot be optimized in the same was as+ normal capturing brackets. */+ SLJIT_ASSERT(common->optimized_cbracket[offset] == 0);+ cbraprivptr = OVECTOR_PRIV(offset);+ offset <<= 1;+ ccbegin = cc + 1 + LINK_SIZE + IMM2_SIZE;+ break;++ default:+ SLJIT_UNREACHABLE();+ break;+ }++framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);+BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;+if (framesize < 0)+ {+ if (offset != 0)+ {+ stacksize = 2;+ if (common->capture_last_ptr != 0)+ stacksize++;+ }+ else+ stacksize = 1;++ if (needs_control_head)+ stacksize++;+ if (!zero)+ stacksize++;++ BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;+ allocate_stack(common, stacksize);+ if (framesize == no_frame)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);++ stack = 0;+ if (offset != 0)+ {+ stack = 2;+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);+ if (common->capture_last_ptr != 0)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);+ if (needs_control_head)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+ if (common->capture_last_ptr != 0)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);+ stack = 3;+ }+ }+ else+ {+ if (needs_control_head)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ stack = 1;+ }++ if (needs_control_head)+ stack++;+ if (!zero)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), SLJIT_IMM, 1);+ if (needs_control_head)+ {+ stack--;+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);+ }+ }+else+ {+ stacksize = framesize + 1;+ if (!zero)+ stacksize++;+ if (needs_control_head)+ stacksize++;+ if (offset == 0)+ stacksize++;+ BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;++ allocate_stack(common, stacksize);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ if (needs_control_head)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+ OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));++ stack = 0;+ if (!zero)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);+ stack = 1;+ }+ if (needs_control_head)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);+ stack++;+ }+ if (offset == 0)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);+ stack++;+ }+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);+ init_frame(common, cc, NULL, stacksize - 1, stacksize - framesize, FALSE);+ stack -= 1 + (offset == 0);+ }++if (offset != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);++loop = LABEL();+while (*cc != OP_KETRPOS)+ {+ backtrack->top = NULL;+ backtrack->topbacktracks = NULL;+ cc += GET(cc, 1);++ compile_matchingpath(common, ccbegin, cc, backtrack);+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return NULL;++ if (framesize < 0)+ {+ if (framesize == no_frame)+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);++ if (offset != 0)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);+ if (common->capture_last_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);+ }+ else+ {+ if (opcode == OP_SBRAPOS)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ }++ /* Even if the match is empty, we need to reset the control head. */+ if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));++ if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)+ add_jump(compiler, &emptymatch, CMP(SLJIT_EQUAL, TMP1, 0, STR_PTR, 0));++ if (!zero)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);+ }+ else+ {+ if (offset != 0)+ {+ OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);+ if (common->capture_last_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);+ }+ else+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ OP2(SLJIT_SUB, STACK_TOP, 0, TMP2, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));+ if (opcode == OP_SBRAPOS)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), STACK(-framesize - 2));+ OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), STACK(-framesize - 2), STR_PTR, 0);+ }++ /* Even if the match is empty, we need to reset the control head. */+ if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));++ if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)+ add_jump(compiler, &emptymatch, CMP(SLJIT_EQUAL, TMP1, 0, STR_PTR, 0));++ if (!zero)+ {+ if (framesize < 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);+ else+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ }+ }++ JUMPTO(SLJIT_JUMP, loop);+ flush_stubs(common);++ compile_backtrackingpath(common, backtrack->top);+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return NULL;+ set_jumps(backtrack->topbacktracks, LABEL());++ if (framesize < 0)+ {+ if (offset != 0)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);+ else+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ }+ else+ {+ if (offset != 0)+ {+ /* Last alternative. */+ if (*cc == OP_KETRPOS)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);+ }+ else+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP2), STACK(-framesize - 2));+ }+ }++ if (*cc == OP_KETRPOS)+ break;+ ccbegin = cc + 1 + LINK_SIZE;+ }++/* We don't have to restore the control head in case of a failed match. */++backtrack->topbacktracks = NULL;+if (!zero)+ {+ if (framesize < 0)+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));+ else /* TMP2 is set to [private_data_ptr] above. */+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(TMP2), STACK(-stacksize), SLJIT_IMM, 0));+ }++/* None of them matched. */+set_jumps(emptymatch, LABEL());+count_match(common);+return cc + 1 + LINK_SIZE;+}++static SLJIT_INLINE pcre_uchar *get_iterator_parameters(compiler_common *common, pcre_uchar *cc, pcre_uchar *opcode, pcre_uchar *type, sljit_u32 *max, sljit_u32 *exact, pcre_uchar **end)+{+int class_len;++*opcode = *cc;+*exact = 0;++if (*opcode >= OP_STAR && *opcode <= OP_POSUPTO)+ {+ cc++;+ *type = OP_CHAR;+ }+else if (*opcode >= OP_STARI && *opcode <= OP_POSUPTOI)+ {+ cc++;+ *type = OP_CHARI;+ *opcode -= OP_STARI - OP_STAR;+ }+else if (*opcode >= OP_NOTSTAR && *opcode <= OP_NOTPOSUPTO)+ {+ cc++;+ *type = OP_NOT;+ *opcode -= OP_NOTSTAR - OP_STAR;+ }+else if (*opcode >= OP_NOTSTARI && *opcode <= OP_NOTPOSUPTOI)+ {+ cc++;+ *type = OP_NOTI;+ *opcode -= OP_NOTSTARI - OP_STAR;+ }+else if (*opcode >= OP_TYPESTAR && *opcode <= OP_TYPEPOSUPTO)+ {+ cc++;+ *opcode -= OP_TYPESTAR - OP_STAR;+ *type = OP_END;+ }+else+ {+ SLJIT_ASSERT(*opcode == OP_CLASS || *opcode == OP_NCLASS || *opcode == OP_XCLASS);+ *type = *opcode;+ cc++;+ class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);+ *opcode = cc[class_len - 1];++ if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)+ {+ *opcode -= OP_CRSTAR - OP_STAR;+ *end = cc + class_len;++ if (*opcode == OP_PLUS || *opcode == OP_MINPLUS)+ {+ *exact = 1;+ *opcode -= OP_PLUS - OP_STAR;+ }+ }+ else if (*opcode >= OP_CRPOSSTAR && *opcode <= OP_CRPOSQUERY)+ {+ *opcode -= OP_CRPOSSTAR - OP_POSSTAR;+ *end = cc + class_len;++ if (*opcode == OP_POSPLUS)+ {+ *exact = 1;+ *opcode = OP_POSSTAR;+ }+ }+ else+ {+ SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE || *opcode == OP_CRPOSRANGE);+ *max = GET2(cc, (class_len + IMM2_SIZE));+ *exact = GET2(cc, class_len);++ if (*max == 0)+ {+ if (*opcode == OP_CRPOSRANGE)+ *opcode = OP_POSSTAR;+ else+ *opcode -= OP_CRRANGE - OP_STAR;+ }+ else+ {+ *max -= *exact;+ if (*max == 0)+ *opcode = OP_EXACT;+ else if (*max == 1)+ {+ if (*opcode == OP_CRPOSRANGE)+ *opcode = OP_POSQUERY;+ else+ *opcode -= OP_CRRANGE - OP_QUERY;+ }+ else+ {+ if (*opcode == OP_CRPOSRANGE)+ *opcode = OP_POSUPTO;+ else+ *opcode -= OP_CRRANGE - OP_UPTO;+ }+ }+ *end = cc + class_len + 2 * IMM2_SIZE;+ }+ return cc;+ }++switch(*opcode)+ {+ case OP_EXACT:+ *exact = GET2(cc, 0);+ cc += IMM2_SIZE;+ break;++ case OP_PLUS:+ case OP_MINPLUS:+ *exact = 1;+ *opcode -= OP_PLUS - OP_STAR;+ break;++ case OP_POSPLUS:+ *exact = 1;+ *opcode = OP_POSSTAR;+ break;++ case OP_UPTO:+ case OP_MINUPTO:+ case OP_POSUPTO:+ *max = GET2(cc, 0);+ cc += IMM2_SIZE;+ break;+ }++if (*type == OP_END)+ {+ *type = *cc;+ *end = next_opcode(common, cc);+ cc++;+ return cc;+ }++*end = cc + 1;+#ifdef SUPPORT_UTF+if (common->utf && HAS_EXTRALEN(*cc)) *end += GET_EXTRALEN(*cc);+#endif+return cc;+}++static pcre_uchar *compile_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;+pcre_uchar opcode;+pcre_uchar type;+sljit_u32 max = 0, exact;+BOOL fast_fail;+sljit_s32 fast_str_ptr;+BOOL charpos_enabled;+pcre_uchar charpos_char;+unsigned int charpos_othercasebit;+pcre_uchar *end;+jump_list *no_match = NULL;+jump_list *no_char1_match = NULL;+struct sljit_jump *jump = NULL;+struct sljit_label *label;+int private_data_ptr = PRIVATE_DATA(cc);+int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_SP);+int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;+int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);+int tmp_base, tmp_offset;++PUSH_BACKTRACK(sizeof(char_iterator_backtrack), cc, NULL);++fast_str_ptr = PRIVATE_DATA(cc + 1);+fast_fail = TRUE;++SLJIT_ASSERT(common->fast_forward_bc_ptr == NULL || fast_str_ptr == 0 || cc == common->fast_forward_bc_ptr);++if (cc == common->fast_forward_bc_ptr)+ fast_fail = FALSE;+else if (common->fast_fail_start_ptr == 0)+ fast_str_ptr = 0;++SLJIT_ASSERT(common->fast_forward_bc_ptr != NULL || fast_str_ptr == 0+ || (fast_str_ptr >= common->fast_fail_start_ptr && fast_str_ptr <= common->fast_fail_end_ptr));++cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &exact, &end);++if (type != OP_EXTUNI)+ {+ tmp_base = TMP3;+ tmp_offset = 0;+ }+else+ {+ tmp_base = SLJIT_MEM1(SLJIT_SP);+ tmp_offset = POSSESSIVE0;+ }++if (fast_fail && fast_str_ptr != 0)+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), fast_str_ptr));++/* Handle fixed part first. */+if (exact > 1)+ {+ SLJIT_ASSERT(fast_str_ptr == 0);+ if (common->mode == JIT_COMPILE+#ifdef SUPPORT_UTF+ && !common->utf+#endif+ && type != OP_ANYNL && type != OP_EXTUNI)+ {+ OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(exact));+ add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_GREATER, TMP1, 0, STR_END, 0));+ OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, exact);+ label = LABEL();+ compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, FALSE);+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, label);+ }+ else+ {+ OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, exact);+ label = LABEL();+ compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, TRUE);+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, label);+ }+ }+else if (exact == 1)+ compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, TRUE);++switch(opcode)+ {+ case OP_STAR:+ case OP_UPTO:+ SLJIT_ASSERT(fast_str_ptr == 0 || opcode == OP_STAR);++ if (type == OP_ANYNL || type == OP_EXTUNI)+ {+ SLJIT_ASSERT(private_data_ptr == 0);+ SLJIT_ASSERT(fast_str_ptr == 0);++ allocate_stack(common, 2);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);++ if (opcode == OP_UPTO)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, SLJIT_IMM, max);++ label = LABEL();+ compile_char1_matchingpath(common, type, cc, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, TRUE);+ if (opcode == OP_UPTO)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0);+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ jump = JUMP(SLJIT_ZERO);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, TMP1, 0);+ }++ /* We cannot use TMP3 because of this allocate_stack. */+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ JUMPTO(SLJIT_JUMP, label);+ if (jump != NULL)+ JUMPHERE(jump);+ }+ else+ {+ charpos_enabled = FALSE;+ charpos_char = 0;+ charpos_othercasebit = 0;++ if ((type != OP_CHAR && type != OP_CHARI) && (*end == OP_CHAR || *end == OP_CHARI))+ {+ charpos_enabled = TRUE;+#ifdef SUPPORT_UTF+ charpos_enabled = !common->utf || !HAS_EXTRALEN(end[1]);+#endif+ if (charpos_enabled && *end == OP_CHARI && char_has_othercase(common, end + 1))+ {+ charpos_othercasebit = char_get_othercase_bit(common, end + 1);+ if (charpos_othercasebit == 0)+ charpos_enabled = FALSE;+ }++ if (charpos_enabled)+ {+ charpos_char = end[1];+ /* Consumpe the OP_CHAR opcode. */+ end += 2;+#if defined COMPILE_PCRE8+ SLJIT_ASSERT((charpos_othercasebit >> 8) == 0);+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32+ SLJIT_ASSERT((charpos_othercasebit >> 9) == 0);+ if ((charpos_othercasebit & 0x100) != 0)+ charpos_othercasebit = (charpos_othercasebit & 0xff) << 8;+#endif+ if (charpos_othercasebit != 0)+ charpos_char |= charpos_othercasebit;++ BACKTRACK_AS(char_iterator_backtrack)->u.charpos.enabled = TRUE;+ BACKTRACK_AS(char_iterator_backtrack)->u.charpos.chr = charpos_char;+ BACKTRACK_AS(char_iterator_backtrack)->u.charpos.othercasebit = charpos_othercasebit;+ }+ }++ if (charpos_enabled)+ {+ if (opcode == OP_UPTO)+ OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max + 1);++ /* Search the first instance of charpos_char. */+ jump = JUMP(SLJIT_JUMP);+ label = LABEL();+ if (opcode == OP_UPTO)+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_ZERO));+ }+ compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, FALSE);+ if (fast_str_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);+ JUMPHERE(jump);++ detect_partial_match(common, &backtrack->topbacktracks);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ if (charpos_othercasebit != 0)+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, charpos_othercasebit);+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char, label);++ if (private_data_ptr == 0)+ allocate_stack(common, 2);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);+ if (opcode == OP_UPTO)+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ add_jump(compiler, &no_match, JUMP(SLJIT_ZERO));+ }++ /* Search the last instance of charpos_char. */+ label = LABEL();+ compile_char1_matchingpath(common, type, cc, &no_match, FALSE);+ if (fast_str_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);+ detect_partial_match(common, &no_match);+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));+ if (charpos_othercasebit != 0)+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, charpos_othercasebit);+ if (opcode == OP_STAR)+ {+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char, label);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ }+ else+ {+ jump = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ JUMPHERE(jump);+ }++ if (opcode == OP_UPTO)+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, label);+ }+ else+ JUMPTO(SLJIT_JUMP, label);++ set_jumps(no_match, LABEL());+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ }+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ else if (common->utf)+ {+ if (private_data_ptr == 0)+ allocate_stack(common, 2);++ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);++ if (opcode == OP_UPTO)+ OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);++ label = LABEL();+ compile_char1_matchingpath(common, type, cc, &no_match, TRUE);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);++ if (opcode == OP_UPTO)+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, label);+ }+ else+ JUMPTO(SLJIT_JUMP, label);++ set_jumps(no_match, LABEL());+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ if (fast_str_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);+ }+#endif+ else+ {+ if (private_data_ptr == 0)+ allocate_stack(common, 2);++ OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);+ if (opcode == OP_UPTO)+ OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);++ label = LABEL();+ detect_partial_match(common, &no_match);+ compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);+ if (opcode == OP_UPTO)+ {+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, label);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ }+ else+ JUMPTO(SLJIT_JUMP, label);++ set_jumps(no_char1_match, LABEL());+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ set_jumps(no_match, LABEL());+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ if (fast_str_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);+ }+ }+ BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();+ break;++ case OP_MINSTAR:+ if (private_data_ptr == 0)+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();+ if (fast_str_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);+ break;++ case OP_MINUPTO:+ SLJIT_ASSERT(fast_str_ptr == 0);+ if (private_data_ptr == 0)+ allocate_stack(common, 2);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ OP1(SLJIT_MOV, base, offset1, SLJIT_IMM, max + 1);+ BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();+ break;++ case OP_QUERY:+ case OP_MINQUERY:+ SLJIT_ASSERT(fast_str_ptr == 0);+ if (private_data_ptr == 0)+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ if (opcode == OP_QUERY)+ compile_char1_matchingpath(common, type, cc, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, TRUE);+ BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();+ break;++ case OP_EXACT:+ break;++ case OP_POSSTAR:+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (common->utf)+ {+ OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);+ label = LABEL();+ compile_char1_matchingpath(common, type, cc, &no_match, TRUE);+ OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);+ JUMPTO(SLJIT_JUMP, label);+ set_jumps(no_match, LABEL());+ OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);+ if (fast_str_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);+ break;+ }+#endif+ label = LABEL();+ detect_partial_match(common, &no_match);+ compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);+ JUMPTO(SLJIT_JUMP, label);+ set_jumps(no_char1_match, LABEL());+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ set_jumps(no_match, LABEL());+ if (fast_str_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);+ break;++ case OP_POSUPTO:+ SLJIT_ASSERT(fast_str_ptr == 0);+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32+ if (common->utf)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, STR_PTR, 0);+ OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);+ label = LABEL();+ compile_char1_matchingpath(common, type, cc, &no_match, TRUE);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, STR_PTR, 0);+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, label);+ set_jumps(no_match, LABEL());+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1);+ break;+ }+#endif+ OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);+ label = LABEL();+ detect_partial_match(common, &no_match);+ compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);+ OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);+ JUMPTO(SLJIT_NOT_ZERO, label);+ OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ set_jumps(no_char1_match, LABEL());+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));+ set_jumps(no_match, LABEL());+ break;++ case OP_POSQUERY:+ SLJIT_ASSERT(fast_str_ptr == 0);+ OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);+ compile_char1_matchingpath(common, type, cc, &no_match, TRUE);+ OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);+ set_jumps(no_match, LABEL());+ OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);+ break;++ default:+ SLJIT_UNREACHABLE();+ break;+ }++count_match(common);+return end;+}++static SLJIT_INLINE pcre_uchar *compile_fail_accept_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;++PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);++if (*cc == OP_FAIL)+ {+ add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));+ return cc + 1;+ }++if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL || !common->might_be_empty)+ {+ /* No need to check notempty conditions. */+ if (common->accept_label == NULL)+ add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));+ else+ JUMPTO(SLJIT_JUMP, common->accept_label);+ return cc + 1;+ }++if (common->accept_label == NULL)+ add_jump(compiler, &common->accept, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0)));+else+ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), common->accept_label);+OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));+add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));+OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));+if (common->accept_label == NULL)+ add_jump(compiler, &common->accept, CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0));+else+ CMPTO(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0, common->accept_label);+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));+if (common->accept_label == NULL)+ add_jump(compiler, &common->accept, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0));+else+ CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->accept_label);+add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));+return cc + 1;+}++static SLJIT_INLINE pcre_uchar *compile_close_matchingpath(compiler_common *common, pcre_uchar *cc)+{+DEFINE_COMPILER;+int offset = GET2(cc, 1);+BOOL optimized_cbracket = common->optimized_cbracket[offset] != 0;++/* Data will be discarded anyway... */+if (common->currententry != NULL)+ return cc + 1 + IMM2_SIZE;++if (!optimized_cbracket)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR_PRIV(offset));+offset <<= 1;+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);+if (!optimized_cbracket)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);+return cc + 1 + IMM2_SIZE;+}++static SLJIT_INLINE pcre_uchar *compile_control_verb_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;+pcre_uchar opcode = *cc;+pcre_uchar *ccend = cc + 1;++if (opcode == OP_PRUNE_ARG || opcode == OP_SKIP_ARG || opcode == OP_THEN_ARG)+ ccend += 2 + cc[1];++PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);++if (opcode == OP_SKIP)+ {+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ return ccend;+ }++if (opcode == OP_PRUNE_ARG || opcode == OP_THEN_ARG)+ {+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP2, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);+ }++return ccend;+}++static pcre_uchar then_trap_opcode[1] = { OP_THEN_TRAP };++static SLJIT_INLINE void compile_then_trap_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;+BOOL needs_control_head;+int size;++PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);+common->then_trap = BACKTRACK_AS(then_trap_backtrack);+BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;+BACKTRACK_AS(then_trap_backtrack)->start = (sljit_sw)(cc - common->start);+BACKTRACK_AS(then_trap_backtrack)->framesize = get_framesize(common, cc, ccend, FALSE, &needs_control_head);++size = BACKTRACK_AS(then_trap_backtrack)->framesize;+size = 3 + (size < 0 ? 0 : size);++OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+allocate_stack(common, size);+if (size > 3)+ OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0, SLJIT_IMM, (size - 3) * sizeof(sljit_sw));+else+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0);+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 1), SLJIT_IMM, BACKTRACK_AS(then_trap_backtrack)->start);+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 2), SLJIT_IMM, type_then_trap);+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 3), TMP2, 0);++size = BACKTRACK_AS(then_trap_backtrack)->framesize;+if (size >= 0)+ init_frame(common, cc, ccend, size - 1, 0, FALSE);+}++static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)+{+DEFINE_COMPILER;+backtrack_common *backtrack;+BOOL has_then_trap = FALSE;+then_trap_backtrack *save_then_trap = NULL;++SLJIT_ASSERT(*ccend == OP_END || (*ccend >= OP_ALT && *ccend <= OP_KETRPOS));++if (common->has_then && common->then_offsets[cc - common->start] != 0)+ {+ SLJIT_ASSERT(*ccend != OP_END && common->control_head_ptr != 0);+ has_then_trap = TRUE;+ save_then_trap = common->then_trap;+ /* Tail item on backtrack. */+ compile_then_trap_matchingpath(common, cc, ccend, parent);+ }++while (cc < ccend)+ {+ switch(*cc)+ {+ case OP_SOD:+ case OP_SOM:+ case OP_NOT_WORD_BOUNDARY:+ case OP_WORD_BOUNDARY:+ case OP_EODN:+ case OP_EOD:+ case OP_DOLL:+ case OP_DOLLM:+ case OP_CIRC:+ case OP_CIRCM:+ case OP_REVERSE:+ cc = compile_simple_assertion_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);+ break;++ case OP_NOT_DIGIT:+ case OP_DIGIT:+ case OP_NOT_WHITESPACE:+ case OP_WHITESPACE:+ case OP_NOT_WORDCHAR:+ case OP_WORDCHAR:+ case OP_ANY:+ case OP_ALLANY:+ case OP_ANYBYTE:+ case OP_NOTPROP:+ case OP_PROP:+ case OP_ANYNL:+ case OP_NOT_HSPACE:+ case OP_HSPACE:+ case OP_NOT_VSPACE:+ case OP_VSPACE:+ case OP_EXTUNI:+ case OP_NOT:+ case OP_NOTI:+ cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);+ break;++ case OP_SET_SOM:+ PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);+ cc++;+ break;++ case OP_CHAR:+ case OP_CHARI:+ if (common->mode == JIT_COMPILE)+ cc = compile_charn_matchingpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);+ else+ cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);+ break;++ case OP_STAR:+ case OP_MINSTAR:+ case OP_PLUS:+ case OP_MINPLUS:+ case OP_QUERY:+ case OP_MINQUERY:+ case OP_UPTO:+ case OP_MINUPTO:+ case OP_EXACT:+ case OP_POSSTAR:+ case OP_POSPLUS:+ case OP_POSQUERY:+ case OP_POSUPTO:+ case OP_STARI:+ case OP_MINSTARI:+ case OP_PLUSI:+ case OP_MINPLUSI:+ case OP_QUERYI:+ case OP_MINQUERYI:+ case OP_UPTOI:+ case OP_MINUPTOI:+ case OP_EXACTI:+ case OP_POSSTARI:+ case OP_POSPLUSI:+ case OP_POSQUERYI:+ case OP_POSUPTOI:+ case OP_NOTSTAR:+ case OP_NOTMINSTAR:+ case OP_NOTPLUS:+ case OP_NOTMINPLUS:+ case OP_NOTQUERY:+ case OP_NOTMINQUERY:+ case OP_NOTUPTO:+ case OP_NOTMINUPTO:+ case OP_NOTEXACT:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSUPTO:+ case OP_NOTSTARI:+ case OP_NOTMINSTARI:+ case OP_NOTPLUSI:+ case OP_NOTMINPLUSI:+ case OP_NOTQUERYI:+ case OP_NOTMINQUERYI:+ case OP_NOTUPTOI:+ case OP_NOTMINUPTOI:+ case OP_NOTEXACTI:+ case OP_NOTPOSSTARI:+ case OP_NOTPOSPLUSI:+ case OP_NOTPOSQUERYI:+ case OP_NOTPOSUPTOI:+ case OP_TYPESTAR:+ case OP_TYPEMINSTAR:+ case OP_TYPEPLUS:+ case OP_TYPEMINPLUS:+ case OP_TYPEQUERY:+ case OP_TYPEMINQUERY:+ case OP_TYPEUPTO:+ case OP_TYPEMINUPTO:+ case OP_TYPEEXACT:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSPLUS:+ case OP_TYPEPOSQUERY:+ case OP_TYPEPOSUPTO:+ cc = compile_iterator_matchingpath(common, cc, parent);+ break;++ case OP_CLASS:+ case OP_NCLASS:+ if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRPOSRANGE)+ cc = compile_iterator_matchingpath(common, cc, parent);+ else+ cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);+ break;++#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32+ case OP_XCLASS:+ if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRPOSRANGE)+ cc = compile_iterator_matchingpath(common, cc, parent);+ else+ cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);+ break;+#endif++ case OP_REF:+ case OP_REFI:+ if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRPOSRANGE)+ cc = compile_ref_iterator_matchingpath(common, cc, parent);+ else+ {+ compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);+ cc += 1 + IMM2_SIZE;+ }+ break;++ case OP_DNREF:+ case OP_DNREFI:+ if (cc[1 + 2 * IMM2_SIZE] >= OP_CRSTAR && cc[1 + 2 * IMM2_SIZE] <= OP_CRPOSRANGE)+ cc = compile_ref_iterator_matchingpath(common, cc, parent);+ else+ {+ compile_dnref_search(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);+ compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);+ cc += 1 + 2 * IMM2_SIZE;+ }+ break;++ case OP_RECURSE:+ cc = compile_recurse_matchingpath(common, cc, parent);+ break;++ case OP_CALLOUT:+ cc = compile_callout_matchingpath(common, cc, parent);+ break;++ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);+ cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);+ break;++ case OP_BRAMINZERO:+ PUSH_BACKTRACK_NOVALUE(sizeof(braminzero_backtrack), cc);+ cc = bracketend(cc + 1);+ if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)+ {+ allocate_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);+ }+ else+ {+ allocate_stack(common, 2);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), STR_PTR, 0);+ }+ BACKTRACK_AS(braminzero_backtrack)->matchingpath = LABEL();+ count_match(common);+ break;++ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_BRA:+ case OP_CBRA:+ case OP_COND:+ case OP_SBRA:+ case OP_SCBRA:+ case OP_SCOND:+ cc = compile_bracket_matchingpath(common, cc, parent);+ break;++ case OP_BRAZERO:+ if (cc[1] > OP_ASSERTBACK_NOT)+ cc = compile_bracket_matchingpath(common, cc, parent);+ else+ {+ PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);+ cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);+ }+ break;++ case OP_BRAPOS:+ case OP_CBRAPOS:+ case OP_SBRAPOS:+ case OP_SCBRAPOS:+ case OP_BRAPOSZERO:+ cc = compile_bracketpos_matchingpath(common, cc, parent);+ break;++ case OP_MARK:+ PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);+ SLJIT_ASSERT(common->mark_ptr != 0);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);+ allocate_stack(common, common->has_skip_arg ? 5 : 1);+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0), TMP2, 0);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP2, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);+ if (common->has_skip_arg)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, type_mark);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), SLJIT_IMM, (sljit_sw)(cc + 2));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(3), STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);+ }+ cc += 1 + 2 + cc[1];+ break;++ case OP_PRUNE:+ case OP_PRUNE_ARG:+ case OP_SKIP:+ case OP_SKIP_ARG:+ case OP_THEN:+ case OP_THEN_ARG:+ case OP_COMMIT:+ cc = compile_control_verb_matchingpath(common, cc, parent);+ break;++ case OP_FAIL:+ case OP_ACCEPT:+ case OP_ASSERT_ACCEPT:+ cc = compile_fail_accept_matchingpath(common, cc, parent);+ break;++ case OP_CLOSE:+ cc = compile_close_matchingpath(common, cc);+ break;++ case OP_SKIPZERO:+ cc = bracketend(cc + 1);+ break;++ default:+ SLJIT_UNREACHABLE();+ return;+ }+ if (cc == NULL)+ return;+ }++if (has_then_trap)+ {+ /* Head item on backtrack. */+ PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);+ BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;+ BACKTRACK_AS(then_trap_backtrack)->then_trap = common->then_trap;+ common->then_trap = save_then_trap;+ }+SLJIT_ASSERT(cc == ccend);+}++#undef PUSH_BACKTRACK+#undef PUSH_BACKTRACK_NOVALUE+#undef BACKTRACK_AS++#define COMPILE_BACKTRACKINGPATH(current) \+ do \+ { \+ compile_backtrackingpath(common, (current)); \+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \+ return; \+ } \+ while (0)++#define CURRENT_AS(type) ((type *)current)++static void compile_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;+pcre_uchar *cc = current->cc;+pcre_uchar opcode;+pcre_uchar type;+sljit_u32 max = 0, exact;+struct sljit_label *label = NULL;+struct sljit_jump *jump = NULL;+jump_list *jumplist = NULL;+pcre_uchar *end;+int private_data_ptr = PRIVATE_DATA(cc);+int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_SP);+int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;+int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);++cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &exact, &end);++switch(opcode)+ {+ case OP_STAR:+ case OP_UPTO:+ if (type == OP_ANYNL || type == OP_EXTUNI)+ {+ SLJIT_ASSERT(private_data_ptr == 0);+ set_jumps(CURRENT_AS(char_iterator_backtrack)->u.backtracks, LABEL());+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(char_iterator_backtrack)->matchingpath);+ }+ else+ {+ if (CURRENT_AS(char_iterator_backtrack)->u.charpos.enabled)+ {+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ OP1(SLJIT_MOV, TMP2, 0, base, offset1);+ OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));++ jump = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);+ label = LABEL();+ OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ if (CURRENT_AS(char_iterator_backtrack)->u.charpos.othercasebit != 0)+ OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, CURRENT_AS(char_iterator_backtrack)->u.charpos.othercasebit);+ CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CURRENT_AS(char_iterator_backtrack)->u.charpos.chr, CURRENT_AS(char_iterator_backtrack)->matchingpath);+ skip_char_back(common);+ CMPTO(SLJIT_GREATER, STR_PTR, 0, TMP2, 0, label);+ }+ else+ {+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ jump = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, base, offset1);+ skip_char_back(common);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);+ }+ JUMPHERE(jump);+ if (private_data_ptr == 0)+ free_stack(common, 2);+ }+ break;++ case OP_MINSTAR:+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);+ set_jumps(jumplist, LABEL());+ if (private_data_ptr == 0)+ free_stack(common, 1);+ break;++ case OP_MINUPTO:+ OP1(SLJIT_MOV, TMP1, 0, base, offset1);+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ OP2(SLJIT_SUB | SLJIT_SET_Z, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+ add_jump(compiler, &jumplist, JUMP(SLJIT_ZERO));++ OP1(SLJIT_MOV, base, offset1, TMP1, 0);+ compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);+ OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);+ JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);++ set_jumps(jumplist, LABEL());+ if (private_data_ptr == 0)+ free_stack(common, 2);+ break;++ case OP_QUERY:+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);+ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(char_iterator_backtrack)->matchingpath);+ jump = JUMP(SLJIT_JUMP);+ set_jumps(CURRENT_AS(char_iterator_backtrack)->u.backtracks, LABEL());+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);+ JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);+ JUMPHERE(jump);+ if (private_data_ptr == 0)+ free_stack(common, 1);+ break;++ case OP_MINQUERY:+ OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);+ OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);+ jump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);+ compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);+ JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);+ set_jumps(jumplist, LABEL());+ JUMPHERE(jump);+ if (private_data_ptr == 0)+ free_stack(common, 1);+ break;++ case OP_EXACT:+ case OP_POSSTAR:+ case OP_POSQUERY:+ case OP_POSUPTO:+ break;++ default:+ SLJIT_UNREACHABLE();+ break;+ }++set_jumps(current->topbacktracks, LABEL());+}++static SLJIT_INLINE void compile_ref_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;+pcre_uchar *cc = current->cc;+BOOL ref = (*cc == OP_REF || *cc == OP_REFI);+pcre_uchar type;++type = cc[ref ? 1 + IMM2_SIZE : 1 + 2 * IMM2_SIZE];++if ((type & 0x1) == 0)+ {+ /* Maximize case. */+ set_jumps(current->topbacktracks, LABEL());+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(ref_iterator_backtrack)->matchingpath);+ return;+ }++OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(ref_iterator_backtrack)->matchingpath);+set_jumps(current->topbacktracks, LABEL());+free_stack(common, ref ? 2 : 3);+}++static SLJIT_INLINE void compile_recurse_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;++if (CURRENT_AS(recurse_backtrack)->inlined_pattern)+ compile_backtrackingpath(common, current->top);+set_jumps(current->topbacktracks, LABEL());+if (CURRENT_AS(recurse_backtrack)->inlined_pattern)+ return;++if (common->has_set_som && common->mark_ptr != 0)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ free_stack(common, 2);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), TMP2, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP1, 0);+ }+else if (common->has_set_som || common->mark_ptr != 0)+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr, TMP2, 0);+ }+}++static void compile_assert_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;+pcre_uchar *cc = current->cc;+pcre_uchar bra = OP_BRA;+struct sljit_jump *brajump = NULL;++SLJIT_ASSERT(*cc != OP_BRAMINZERO);+if (*cc == OP_BRAZERO)+ {+ bra = *cc;+ cc++;+ }++if (bra == OP_BRAZERO)+ {+ SLJIT_ASSERT(current->topbacktracks == NULL);+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ }++if (CURRENT_AS(assert_backtrack)->framesize < 0)+ {+ set_jumps(current->topbacktracks, LABEL());++ if (bra == OP_BRAZERO)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->matchingpath);+ free_stack(common, 1);+ }+ return;+ }++if (bra == OP_BRAZERO)+ {+ if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->matchingpath);+ free_stack(common, 1);+ return;+ }+ free_stack(common, 1);+ brajump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);+ }++if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)+ {+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(assert_backtrack)->private_data_ptr);+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(assert_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-CURRENT_AS(assert_backtrack)->framesize - 1));++ set_jumps(current->topbacktracks, LABEL());+ }+else+ set_jumps(current->topbacktracks, LABEL());++if (bra == OP_BRAZERO)+ {+ /* We know there is enough place on the stack. */+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);+ JUMPTO(SLJIT_JUMP, CURRENT_AS(assert_backtrack)->matchingpath);+ JUMPHERE(brajump);+ }+}++static void compile_bracket_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;+int opcode, stacksize, alt_count, alt_max;+int offset = 0;+int private_data_ptr = CURRENT_AS(bracket_backtrack)->private_data_ptr;+int repeat_ptr = 0, repeat_type = 0, repeat_count = 0;+pcre_uchar *cc = current->cc;+pcre_uchar *ccbegin;+pcre_uchar *ccprev;+pcre_uchar bra = OP_BRA;+pcre_uchar ket;+assert_backtrack *assert;+sljit_uw *next_update_addr = NULL;+BOOL has_alternatives;+BOOL needs_control_head = FALSE;+struct sljit_jump *brazero = NULL;+struct sljit_jump *alt1 = NULL;+struct sljit_jump *alt2 = NULL;+struct sljit_jump *once = NULL;+struct sljit_jump *cond = NULL;+struct sljit_label *rmin_label = NULL;+struct sljit_label *exact_label = NULL;++if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)+ {+ bra = *cc;+ cc++;+ }++opcode = *cc;+ccbegin = bracketend(cc) - 1 - LINK_SIZE;+ket = *ccbegin;+if (ket == OP_KET && PRIVATE_DATA(ccbegin) != 0)+ {+ repeat_ptr = PRIVATE_DATA(ccbegin);+ repeat_type = PRIVATE_DATA(ccbegin + 2);+ repeat_count = PRIVATE_DATA(ccbegin + 3);+ SLJIT_ASSERT(repeat_type != 0 && repeat_count != 0);+ if (repeat_type == OP_UPTO)+ ket = OP_KETRMAX;+ if (repeat_type == OP_MINUPTO)+ ket = OP_KETRMIN;+ }+ccbegin = cc;+cc += GET(cc, 1);+has_alternatives = *cc == OP_ALT;+if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))+ has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_backtrack)->u.condfailed != NULL;+if (opcode == OP_CBRA || opcode == OP_SCBRA)+ offset = (GET2(ccbegin, 1 + LINK_SIZE)) << 1;+if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))+ opcode = OP_SCOND;+if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))+ opcode = OP_ONCE;++alt_max = has_alternatives ? no_alternatives(ccbegin) : 0;++/* Decoding the needs_control_head in framesize. */+if (opcode == OP_ONCE)+ {+ needs_control_head = (CURRENT_AS(bracket_backtrack)->u.framesize & 0x1) != 0;+ CURRENT_AS(bracket_backtrack)->u.framesize >>= 1;+ }++if (ket != OP_KET && repeat_type != 0)+ {+ /* TMP1 is used in OP_KETRMIN below. */+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ if (repeat_type == OP_UPTO)+ OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0, SLJIT_IMM, 1);+ else+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0);+ }++if (ket == OP_KETRMAX)+ {+ if (bra == OP_BRAZERO)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ brazero = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0);+ }+ }+else if (ket == OP_KETRMIN)+ {+ if (bra != OP_BRAMINZERO)+ {+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ if (repeat_type != 0)+ {+ /* TMP1 was set a few lines above. */+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);+ /* Drop STR_PTR for non-greedy plus quantifier. */+ if (opcode != OP_ONCE)+ free_stack(common, 1);+ }+ else if (opcode >= OP_SBRA || opcode == OP_ONCE)+ {+ /* Checking zero-length iteration. */+ if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)+ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);+ else+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), STACK(-CURRENT_AS(bracket_backtrack)->u.framesize - 2), CURRENT_AS(bracket_backtrack)->recursive_matchingpath);+ }+ /* Drop STR_PTR for non-greedy plus quantifier. */+ if (opcode != OP_ONCE)+ free_stack(common, 1);+ }+ else+ JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);+ }+ rmin_label = LABEL();+ if (repeat_type != 0)+ OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);+ }+else if (bra == OP_BRAZERO)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ brazero = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);+ }+else if (repeat_type == OP_EXACT)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);+ exact_label = LABEL();+ }++if (offset != 0)+ {+ if (common->capture_last_ptr != 0)+ {+ SLJIT_ASSERT(common->optimized_cbracket[offset >> 1] == 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, TMP1, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));+ free_stack(common, 3);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP2, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP1, 0);+ }+ else if (common->optimized_cbracket[offset >> 1] == 0)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ free_stack(common, 2);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);+ }+ }++if (SLJIT_UNLIKELY(opcode == OP_ONCE))+ {+ if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)+ {+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ }+ once = JUMP(SLJIT_JUMP);+ }+else if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))+ {+ if (has_alternatives)+ {+ /* Always exactly one alternative. */+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);++ alt_max = 2;+ alt1 = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, sizeof(sljit_uw));+ }+ }+else if (has_alternatives)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);++ if (alt_max > 4)+ {+ /* Table jump if alt_max is greater than 4. */+ next_update_addr = allocate_read_only_data(common, alt_max * sizeof(sljit_uw));+ if (SLJIT_UNLIKELY(next_update_addr == NULL))+ return;+ sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM1(TMP1), (sljit_sw)next_update_addr);+ add_label_addr(common, next_update_addr++);+ }+ else+ {+ if (alt_max == 4)+ alt2 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_uw));+ alt1 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, sizeof(sljit_uw));+ }+ }++COMPILE_BACKTRACKINGPATH(current->top);+if (current->topbacktracks)+ set_jumps(current->topbacktracks, LABEL());++if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))+ {+ /* Conditional block always has at most one alternative. */+ if (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT)+ {+ SLJIT_ASSERT(has_alternatives);+ assert = CURRENT_AS(bracket_backtrack)->u.assert;+ if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK))+ {+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr);+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-assert->framesize - 1));+ }+ cond = JUMP(SLJIT_JUMP);+ set_jumps(CURRENT_AS(bracket_backtrack)->u.assert->condfailed, LABEL());+ }+ else if (CURRENT_AS(bracket_backtrack)->u.condfailed != NULL)+ {+ SLJIT_ASSERT(has_alternatives);+ cond = JUMP(SLJIT_JUMP);+ set_jumps(CURRENT_AS(bracket_backtrack)->u.condfailed, LABEL());+ }+ else+ SLJIT_ASSERT(!has_alternatives);+ }++if (has_alternatives)+ {+ alt_count = sizeof(sljit_uw);+ do+ {+ current->top = NULL;+ current->topbacktracks = NULL;+ current->nextbacktracks = NULL;+ /* Conditional blocks always have an additional alternative, even if it is empty. */+ if (*cc == OP_ALT)+ {+ ccprev = cc + 1 + LINK_SIZE;+ cc += GET(cc, 1);+ if (opcode != OP_COND && opcode != OP_SCOND)+ {+ if (opcode != OP_ONCE)+ {+ if (private_data_ptr != 0)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);+ else+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ }+ else+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(needs_control_head ? 1 : 0));+ }+ compile_matchingpath(common, ccprev, cc, current);+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return;+ }++ /* Instructions after the current alternative is successfully matched. */+ /* There is a similar code in compile_bracket_matchingpath. */+ if (opcode == OP_ONCE)+ match_once_common(common, ket, CURRENT_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);++ stacksize = 0;+ if (repeat_type == OP_MINUPTO)+ {+ /* We need to preserve the counter. TMP2 will be used below. */+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);+ stacksize++;+ }+ if (ket != OP_KET || bra != OP_BRA)+ stacksize++;+ if (offset != 0)+ {+ if (common->capture_last_ptr != 0)+ stacksize++;+ if (common->optimized_cbracket[offset >> 1] == 0)+ stacksize += 2;+ }+ if (opcode != OP_ONCE)+ stacksize++;++ if (stacksize > 0)+ allocate_stack(common, stacksize);++ stacksize = 0;+ if (repeat_type == OP_MINUPTO)+ {+ /* TMP2 was set above. */+ OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);+ stacksize++;+ }++ if (ket != OP_KET || bra != OP_BRA)+ {+ if (ket != OP_KET)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);+ else+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);+ stacksize++;+ }++ if (offset != 0)+ stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);++ if (opcode != OP_ONCE)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, alt_count);++ if (offset != 0 && ket == OP_KETRMAX && common->optimized_cbracket[offset >> 1] != 0)+ {+ /* If ket is not OP_KETRMAX, this code path is executed after the jump to alternative_matchingpath. */+ SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);+ }++ JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->alternative_matchingpath);++ if (opcode != OP_ONCE)+ {+ if (alt_max > 4)+ add_label_addr(common, next_update_addr++);+ else+ {+ if (alt_count != 2 * sizeof(sljit_uw))+ {+ JUMPHERE(alt1);+ if (alt_max == 3 && alt_count == sizeof(sljit_uw))+ alt2 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_uw));+ }+ else+ {+ JUMPHERE(alt2);+ if (alt_max == 4)+ alt1 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_uw));+ }+ }+ alt_count += sizeof(sljit_uw);+ }++ COMPILE_BACKTRACKINGPATH(current->top);+ if (current->topbacktracks)+ set_jumps(current->topbacktracks, LABEL());+ SLJIT_ASSERT(!current->nextbacktracks);+ }+ while (*cc == OP_ALT);++ if (cond != NULL)+ {+ SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);+ assert = CURRENT_AS(bracket_backtrack)->u.assert;+ if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)+ {+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr);+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-assert->framesize - 1));+ }+ JUMPHERE(cond);+ }++ /* Free the STR_PTR. */+ if (private_data_ptr == 0)+ free_stack(common, 1);+ }++if (offset != 0)+ {+ /* Using both tmp register is better for instruction scheduling. */+ if (common->optimized_cbracket[offset >> 1] != 0)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ free_stack(common, 2);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);+ }+ else+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);+ }+ }+else if (opcode == OP_SBRA || opcode == OP_SCOND)+ {+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ }+else if (opcode == OP_ONCE)+ {+ cc = ccbegin + GET(ccbegin, 1);+ stacksize = needs_control_head ? 1 : 0;++ if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)+ {+ /* Reset head and drop saved frame. */+ stacksize += CURRENT_AS(bracket_backtrack)->u.framesize + ((ket != OP_KET || *cc == OP_ALT) ? 2 : 1);+ }+ else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))+ {+ /* The STR_PTR must be released. */+ stacksize++;+ }++ if (stacksize > 0)+ free_stack(common, stacksize);++ JUMPHERE(once);+ /* Restore previous private_data_ptr */+ if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-CURRENT_AS(bracket_backtrack)->u.framesize - 1));+ else if (ket == OP_KETRMIN)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ /* See the comment below. */+ free_stack(common, 2);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);+ }+ }++if (repeat_type == OP_EXACT)+ {+ OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0);+ CMPTO(SLJIT_LESS_EQUAL, TMP1, 0, SLJIT_IMM, repeat_count, exact_label);+ }+else if (ket == OP_KETRMAX)+ {+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ if (bra != OP_BRAZERO)+ free_stack(common, 1);++ CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);+ if (bra == OP_BRAZERO)+ {+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zero_matchingpath);+ JUMPHERE(brazero);+ free_stack(common, 1);+ }+ }+else if (ket == OP_KETRMIN)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));++ /* OP_ONCE removes everything in case of a backtrack, so we don't+ need to explicitly release the STR_PTR. The extra release would+ affect badly the free_stack(2) above. */+ if (opcode != OP_ONCE)+ free_stack(common, 1);+ CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rmin_label);+ if (opcode == OP_ONCE)+ free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);+ else if (bra == OP_BRAMINZERO)+ free_stack(common, 1);+ }+else if (bra == OP_BRAZERO)+ {+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zero_matchingpath);+ JUMPHERE(brazero);+ }+}++static SLJIT_INLINE void compile_bracketpos_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;+int offset;+struct sljit_jump *jump;++if (CURRENT_AS(bracketpos_backtrack)->framesize < 0)+ {+ if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)+ {+ offset = (GET2(current->cc, 1 + LINK_SIZE)) << 1;+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);+ if (common->capture_last_ptr != 0)+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);+ if (common->capture_last_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, TMP1, 0);+ }+ set_jumps(current->topbacktracks, LABEL());+ free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);+ return;+ }++OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(bracketpos_backtrack)->private_data_ptr);+add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));++if (current->topbacktracks)+ {+ jump = JUMP(SLJIT_JUMP);+ set_jumps(current->topbacktracks, LABEL());+ /* Drop the stack frame. */+ free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);+ JUMPHERE(jump);+ }+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(bracketpos_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-CURRENT_AS(bracketpos_backtrack)->framesize - 1));+}++static SLJIT_INLINE void compile_braminzero_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+assert_backtrack backtrack;++current->top = NULL;+current->topbacktracks = NULL;+current->nextbacktracks = NULL;+if (current->cc[1] > OP_ASSERTBACK_NOT)+ {+ /* Manual call of compile_bracket_matchingpath and compile_bracket_backtrackingpath. */+ compile_bracket_matchingpath(common, current->cc, current);+ compile_bracket_backtrackingpath(common, current->top);+ }+else+ {+ memset(&backtrack, 0, sizeof(backtrack));+ backtrack.common.cc = current->cc;+ backtrack.matchingpath = CURRENT_AS(braminzero_backtrack)->matchingpath;+ /* Manual call of compile_assert_matchingpath. */+ compile_assert_matchingpath(common, current->cc, &backtrack, FALSE);+ }+SLJIT_ASSERT(!current->nextbacktracks && !current->topbacktracks);+}++static SLJIT_INLINE void compile_control_verb_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;+pcre_uchar opcode = *current->cc;+struct sljit_label *loop;+struct sljit_jump *jump;++if (opcode == OP_THEN || opcode == OP_THEN_ARG)+ {+ if (common->then_trap != NULL)+ {+ SLJIT_ASSERT(common->control_head_ptr != 0);++ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, type_then_trap);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, common->then_trap->start);+ jump = JUMP(SLJIT_JUMP);++ loop = LABEL();+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ JUMPHERE(jump);+ CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0, loop);+ CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0, loop);+ add_jump(compiler, &common->then_trap->quit, JUMP(SLJIT_JUMP));+ return;+ }+ else if (common->positive_assert)+ {+ add_jump(compiler, &common->positive_assert_quit, JUMP(SLJIT_JUMP));+ return;+ }+ }++if (common->local_exit)+ {+ if (common->quit_label == NULL)+ add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));+ else+ JUMPTO(SLJIT_JUMP, common->quit_label);+ return;+ }++if (opcode == OP_SKIP_ARG)+ {+ SLJIT_ASSERT(common->control_head_ptr != 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, (sljit_sw)(current->cc + 2));+ sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_RET(SW) | SLJIT_ARG1(SW) | SLJIT_ARG2(SW), SLJIT_IMM, SLJIT_FUNC_OFFSET(do_search_mark));+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);++ OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);+ add_jump(compiler, &common->reset_match, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0));+ return;+ }++if (opcode == OP_SKIP)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+else+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_IMM, 0);+add_jump(compiler, &common->reset_match, JUMP(SLJIT_JUMP));+}++static SLJIT_INLINE void compile_then_trap_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;+struct sljit_jump *jump;+int size;++if (CURRENT_AS(then_trap_backtrack)->then_trap)+ {+ common->then_trap = CURRENT_AS(then_trap_backtrack)->then_trap;+ return;+ }++size = CURRENT_AS(then_trap_backtrack)->framesize;+size = 3 + (size < 0 ? 0 : size);++OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(size - 3));+free_stack(common, size);+jump = JUMP(SLJIT_JUMP);++set_jumps(CURRENT_AS(then_trap_backtrack)->quit, LABEL());+/* STACK_TOP is set by THEN. */+if (CURRENT_AS(then_trap_backtrack)->framesize >= 0)+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+free_stack(common, 3);++JUMPHERE(jump);+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP1, 0);+}++static void compile_backtrackingpath(compiler_common *common, struct backtrack_common *current)+{+DEFINE_COMPILER;+then_trap_backtrack *save_then_trap = common->then_trap;++while (current)+ {+ if (current->nextbacktracks != NULL)+ set_jumps(current->nextbacktracks, LABEL());+ switch(*current->cc)+ {+ case OP_SET_SOM:+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), TMP1, 0);+ break;++ case OP_STAR:+ case OP_MINSTAR:+ case OP_PLUS:+ case OP_MINPLUS:+ case OP_QUERY:+ case OP_MINQUERY:+ case OP_UPTO:+ case OP_MINUPTO:+ case OP_EXACT:+ case OP_POSSTAR:+ case OP_POSPLUS:+ case OP_POSQUERY:+ case OP_POSUPTO:+ case OP_STARI:+ case OP_MINSTARI:+ case OP_PLUSI:+ case OP_MINPLUSI:+ case OP_QUERYI:+ case OP_MINQUERYI:+ case OP_UPTOI:+ case OP_MINUPTOI:+ case OP_EXACTI:+ case OP_POSSTARI:+ case OP_POSPLUSI:+ case OP_POSQUERYI:+ case OP_POSUPTOI:+ case OP_NOTSTAR:+ case OP_NOTMINSTAR:+ case OP_NOTPLUS:+ case OP_NOTMINPLUS:+ case OP_NOTQUERY:+ case OP_NOTMINQUERY:+ case OP_NOTUPTO:+ case OP_NOTMINUPTO:+ case OP_NOTEXACT:+ case OP_NOTPOSSTAR:+ case OP_NOTPOSPLUS:+ case OP_NOTPOSQUERY:+ case OP_NOTPOSUPTO:+ case OP_NOTSTARI:+ case OP_NOTMINSTARI:+ case OP_NOTPLUSI:+ case OP_NOTMINPLUSI:+ case OP_NOTQUERYI:+ case OP_NOTMINQUERYI:+ case OP_NOTUPTOI:+ case OP_NOTMINUPTOI:+ case OP_NOTEXACTI:+ case OP_NOTPOSSTARI:+ case OP_NOTPOSPLUSI:+ case OP_NOTPOSQUERYI:+ case OP_NOTPOSUPTOI:+ case OP_TYPESTAR:+ case OP_TYPEMINSTAR:+ case OP_TYPEPLUS:+ case OP_TYPEMINPLUS:+ case OP_TYPEQUERY:+ case OP_TYPEMINQUERY:+ case OP_TYPEUPTO:+ case OP_TYPEMINUPTO:+ case OP_TYPEEXACT:+ case OP_TYPEPOSSTAR:+ case OP_TYPEPOSPLUS:+ case OP_TYPEPOSQUERY:+ case OP_TYPEPOSUPTO:+ case OP_CLASS:+ case OP_NCLASS:+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+#endif+ compile_iterator_backtrackingpath(common, current);+ break;++ case OP_REF:+ case OP_REFI:+ case OP_DNREF:+ case OP_DNREFI:+ compile_ref_iterator_backtrackingpath(common, current);+ break;++ case OP_RECURSE:+ compile_recurse_backtrackingpath(common, current);+ break;++ case OP_ASSERT:+ case OP_ASSERT_NOT:+ case OP_ASSERTBACK:+ case OP_ASSERTBACK_NOT:+ compile_assert_backtrackingpath(common, current);+ break;++ case OP_ONCE:+ case OP_ONCE_NC:+ case OP_BRA:+ case OP_CBRA:+ case OP_COND:+ case OP_SBRA:+ case OP_SCBRA:+ case OP_SCOND:+ compile_bracket_backtrackingpath(common, current);+ break;++ case OP_BRAZERO:+ if (current->cc[1] > OP_ASSERTBACK_NOT)+ compile_bracket_backtrackingpath(common, current);+ else+ compile_assert_backtrackingpath(common, current);+ break;++ case OP_BRAPOS:+ case OP_CBRAPOS:+ case OP_SBRAPOS:+ case OP_SCBRAPOS:+ case OP_BRAPOSZERO:+ compile_bracketpos_backtrackingpath(common, current);+ break;++ case OP_BRAMINZERO:+ compile_braminzero_backtrackingpath(common, current);+ break;++ case OP_MARK:+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0));+ if (common->has_skip_arg)+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));+ free_stack(common, common->has_skip_arg ? 5 : 1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP1, 0);+ if (common->has_skip_arg)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP2, 0);+ break;++ case OP_THEN:+ case OP_THEN_ARG:+ case OP_PRUNE:+ case OP_PRUNE_ARG:+ case OP_SKIP:+ case OP_SKIP_ARG:+ compile_control_verb_backtrackingpath(common, current);+ break;++ case OP_COMMIT:+ if (!common->local_exit)+ OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);+ if (common->quit_label == NULL)+ add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));+ else+ JUMPTO(SLJIT_JUMP, common->quit_label);+ break;++ case OP_CALLOUT:+ case OP_FAIL:+ case OP_ACCEPT:+ case OP_ASSERT_ACCEPT:+ set_jumps(current->topbacktracks, LABEL());+ break;++ case OP_THEN_TRAP:+ /* A virtual opcode for then traps. */+ compile_then_trap_backtrackingpath(common, current);+ break;++ default:+ SLJIT_UNREACHABLE();+ break;+ }+ current = current->prev;+ }+common->then_trap = save_then_trap;+}++static SLJIT_INLINE void compile_recurse(compiler_common *common)+{+DEFINE_COMPILER;+pcre_uchar *cc = common->start + common->currententry->start;+pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);+pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);+BOOL needs_control_head;+int framesize = get_framesize(common, cc, NULL, TRUE, &needs_control_head);+int private_data_size = get_private_data_copy_length(common, ccbegin, ccend, needs_control_head);+int alternativesize;+BOOL needs_frame;+backtrack_common altbacktrack;+struct sljit_jump *jump;++/* Recurse captures then. */+common->then_trap = NULL;++SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);+needs_frame = framesize >= 0;+if (!needs_frame)+ framesize = 0;+alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;++SLJIT_ASSERT(common->currententry->entry == NULL && common->recursive_head_ptr != 0);+common->currententry->entry = LABEL();+set_jumps(common->currententry->calls, common->currententry->entry);++sljit_emit_fast_enter(compiler, TMP2, 0);+count_match(common);+allocate_stack(common, private_data_size + framesize + alternativesize);+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(private_data_size + framesize + alternativesize - 1), TMP2, 0);+copy_private_data(common, ccbegin, ccend, TRUE, framesize + alternativesize, private_data_size + framesize + alternativesize, needs_control_head);+if (needs_control_head)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, STACK_TOP, 0);+if (needs_frame)+ init_frame(common, cc, NULL, framesize + alternativesize - 1, alternativesize, TRUE);++if (alternativesize > 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);++memset(&altbacktrack, 0, sizeof(backtrack_common));+common->quit_label = NULL;+common->accept_label = NULL;+common->quit = NULL;+common->accept = NULL;+altbacktrack.cc = ccbegin;+cc += GET(cc, 1);+while (1)+ {+ altbacktrack.top = NULL;+ altbacktrack.topbacktracks = NULL;++ if (altbacktrack.cc != ccbegin)+ OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));++ compile_matchingpath(common, altbacktrack.cc, cc, &altbacktrack);+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return;++ add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));++ compile_backtrackingpath(common, altbacktrack.top);+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ return;+ set_jumps(altbacktrack.topbacktracks, LABEL());++ if (*cc != OP_ALT)+ break;++ altbacktrack.cc = cc + 1 + LINK_SIZE;+ cc += GET(cc, 1);+ }++/* None of them matched. */+OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);+jump = JUMP(SLJIT_JUMP);++if (common->quit != NULL)+ {+ set_jumps(common->quit, LABEL());+ OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr);+ if (needs_frame)+ {+ OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));+ }+ OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);+ common->quit = NULL;+ add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));+ }++set_jumps(common->accept, LABEL());+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr);+if (needs_frame)+ {+ OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));+ add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));+ OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));+ }+OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);++JUMPHERE(jump);+if (common->quit != NULL)+ set_jumps(common->quit, LABEL());+copy_private_data(common, ccbegin, ccend, FALSE, framesize + alternativesize, private_data_size + framesize + alternativesize, needs_control_head);+free_stack(common, private_data_size + framesize + alternativesize);+if (needs_control_head)+ {+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(-3));+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(-2));+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, TMP1, 0);+ OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP2, 0);+ }+else+ {+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(-2));+ OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, TMP2, 0);+ }+sljit_emit_fast_return(compiler, SLJIT_MEM1(STACK_TOP), STACK(-1));+}++#undef COMPILE_BACKTRACKINGPATH+#undef CURRENT_AS++void+PRIV(jit_compile)(const REAL_PCRE *re, PUBL(extra) *extra, int mode)+{+struct sljit_compiler *compiler;+backtrack_common rootbacktrack;+compiler_common common_data;+compiler_common *common = &common_data;+const sljit_u8 *tables = re->tables;+pcre_study_data *study;+int private_data_size;+pcre_uchar *ccend;+executable_functions *functions;+void *executable_func;+sljit_uw executable_size;+sljit_uw total_length;+label_addr_list *label_addr;+struct sljit_label *mainloop_label = NULL;+struct sljit_label *continue_match_label;+struct sljit_label *empty_match_found_label = NULL;+struct sljit_label *empty_match_backtrack_label = NULL;+struct sljit_label *reset_match_label;+struct sljit_label *quit_label;+struct sljit_jump *jump;+struct sljit_jump *minlength_check_failed = NULL;+struct sljit_jump *reqbyte_notfound = NULL;+struct sljit_jump *empty_match = NULL;++SLJIT_ASSERT((extra->flags & PCRE_EXTRA_STUDY_DATA) != 0);+study = extra->study_data;++if (!tables)+ tables = PRIV(default_tables);++memset(&rootbacktrack, 0, sizeof(backtrack_common));+memset(common, 0, sizeof(compiler_common));+rootbacktrack.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;++common->start = rootbacktrack.cc;+common->read_only_data_head = NULL;+common->fcc = tables + fcc_offset;+common->lcc = (sljit_sw)(tables + lcc_offset);+common->mode = mode;+common->might_be_empty = study->minlength == 0;+common->nltype = NLTYPE_FIXED;+switch(re->options & PCRE_NEWLINE_BITS)+ {+ case 0:+ /* Compile-time default */+ switch(NEWLINE)+ {+ case -1: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;+ case -2: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;+ default: common->newline = NEWLINE; break;+ }+ break;+ case PCRE_NEWLINE_CR: common->newline = CHAR_CR; break;+ case PCRE_NEWLINE_LF: common->newline = CHAR_NL; break;+ case PCRE_NEWLINE_CR++ PCRE_NEWLINE_LF: common->newline = (CHAR_CR << 8) | CHAR_NL; break;+ case PCRE_NEWLINE_ANY: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;+ case PCRE_NEWLINE_ANYCRLF: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;+ default: return;+ }+common->nlmax = READ_CHAR_MAX;+common->nlmin = 0;+if ((re->options & PCRE_BSR_ANYCRLF) != 0)+ common->bsr_nltype = NLTYPE_ANYCRLF;+else if ((re->options & PCRE_BSR_UNICODE) != 0)+ common->bsr_nltype = NLTYPE_ANY;+else+ {+#ifdef BSR_ANYCRLF+ common->bsr_nltype = NLTYPE_ANYCRLF;+#else+ common->bsr_nltype = NLTYPE_ANY;+#endif+ }+common->bsr_nlmax = READ_CHAR_MAX;+common->bsr_nlmin = 0;+common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;+common->ctypes = (sljit_sw)(tables + ctypes_offset);+common->name_table = ((pcre_uchar *)re) + re->name_table_offset;+common->name_count = re->name_count;+common->name_entry_size = re->name_entry_size;+common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;+#ifdef SUPPORT_UTF+/* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */+common->utf = (re->options & PCRE_UTF8) != 0;+#ifdef SUPPORT_UCP+common->use_ucp = (re->options & PCRE_UCP) != 0;+#endif+if (common->utf)+ {+ if (common->nltype == NLTYPE_ANY)+ common->nlmax = 0x2029;+ else if (common->nltype == NLTYPE_ANYCRLF)+ common->nlmax = (CHAR_CR > CHAR_NL) ? CHAR_CR : CHAR_NL;+ else+ {+ /* We only care about the first newline character. */+ common->nlmax = common->newline & 0xff;+ }++ if (common->nltype == NLTYPE_FIXED)+ common->nlmin = common->newline & 0xff;+ else+ common->nlmin = (CHAR_CR < CHAR_NL) ? CHAR_CR : CHAR_NL;++ if (common->bsr_nltype == NLTYPE_ANY)+ common->bsr_nlmax = 0x2029;+ else+ common->bsr_nlmax = (CHAR_CR > CHAR_NL) ? CHAR_CR : CHAR_NL;+ common->bsr_nlmin = (CHAR_CR < CHAR_NL) ? CHAR_CR : CHAR_NL;+ }+#endif /* SUPPORT_UTF */+ccend = bracketend(common->start);++/* Calculate the local space size on the stack. */+common->ovector_start = LIMIT_MATCH + sizeof(sljit_sw);+common->optimized_cbracket = (sljit_u8 *)SLJIT_MALLOC(re->top_bracket + 1, compiler->allocator_data);+if (!common->optimized_cbracket)+ return;+#if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 1+memset(common->optimized_cbracket, 0, re->top_bracket + 1);+#else+memset(common->optimized_cbracket, 1, re->top_bracket + 1);+#endif++SLJIT_ASSERT(*common->start == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);+#if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 2+common->capture_last_ptr = common->ovector_start;+common->ovector_start += sizeof(sljit_sw);+#endif+if (!check_opcode_types(common, common->start, ccend))+ {+ SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);+ return;+ }++/* Checking flags and updating ovector_start. */+if (mode == JIT_COMPILE && (re->flags & PCRE_REQCHSET) != 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)+ {+ common->req_char_ptr = common->ovector_start;+ common->ovector_start += sizeof(sljit_sw);+ }+if (mode != JIT_COMPILE)+ {+ common->start_used_ptr = common->ovector_start;+ common->ovector_start += sizeof(sljit_sw);+ if (mode == JIT_PARTIAL_SOFT_COMPILE)+ {+ common->hit_start = common->ovector_start;+ common->ovector_start += 2 * sizeof(sljit_sw);+ }+ }+if ((re->options & PCRE_FIRSTLINE) != 0)+ {+ common->match_end_ptr = common->ovector_start;+ common->ovector_start += sizeof(sljit_sw);+ }+#if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD+common->control_head_ptr = 1;+#endif+if (common->control_head_ptr != 0)+ {+ common->control_head_ptr = common->ovector_start;+ common->ovector_start += sizeof(sljit_sw);+ }+if (common->has_set_som)+ {+ /* Saving the real start pointer is necessary. */+ common->start_ptr = common->ovector_start;+ common->ovector_start += sizeof(sljit_sw);+ }++/* Aligning ovector to even number of sljit words. */+if ((common->ovector_start & sizeof(sljit_sw)) != 0)+ common->ovector_start += sizeof(sljit_sw);++if (common->start_ptr == 0)+ common->start_ptr = OVECTOR(0);++/* Capturing brackets cannot be optimized if callouts are allowed. */+if (common->capture_last_ptr != 0)+ memset(common->optimized_cbracket, 0, re->top_bracket + 1);++SLJIT_ASSERT(!(common->req_char_ptr != 0 && common->start_used_ptr != 0));+common->cbra_ptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_sw);++total_length = ccend - common->start;+common->private_data_ptrs = (sljit_s32 *)SLJIT_MALLOC(total_length * (sizeof(sljit_s32) + (common->has_then ? 1 : 0)), compiler->allocator_data);+if (!common->private_data_ptrs)+ {+ SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);+ return;+ }+memset(common->private_data_ptrs, 0, total_length * sizeof(sljit_s32));++private_data_size = common->cbra_ptr + (re->top_bracket + 1) * sizeof(sljit_sw);+set_private_data_ptrs(common, &private_data_size, ccend);+if ((re->options & PCRE_ANCHORED) == 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)+ {+ if (!detect_fast_forward_skip(common, &private_data_size) && !common->has_skip_in_assert_back)+ detect_fast_fail(common, common->start, &private_data_size, 4);+ }++SLJIT_ASSERT(common->fast_fail_start_ptr <= common->fast_fail_end_ptr);++if (private_data_size > SLJIT_MAX_LOCAL_SIZE)+ {+ SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);+ SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);+ return;+ }++if (common->has_then)+ {+ common->then_offsets = (sljit_u8 *)(common->private_data_ptrs + total_length);+ memset(common->then_offsets, 0, total_length);+ set_then_offsets(common, common->start, NULL);+ }++compiler = sljit_create_compiler(NULL);+if (!compiler)+ {+ SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);+ SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);+ return;+ }+common->compiler = compiler;++/* Main pcre_jit_exec entry. */+sljit_emit_enter(compiler, 0, SLJIT_ARG1(SW), 5, 5, 0, 0, private_data_size);++/* Register init. */+reset_ovector(common, (re->top_bracket + 1) * 2);+if (common->req_char_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, SLJIT_R0, 0);++OP1(SLJIT_MOV, ARGUMENTS, 0, SLJIT_S0, 0);+OP1(SLJIT_MOV, TMP1, 0, SLJIT_S0, 0);+OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));+OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, end));+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));+OP1(SLJIT_MOV_U32, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, limit_match));+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, end));+OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, start));+OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LIMIT_MATCH, TMP1, 0);++if (common->fast_fail_start_ptr < common->fast_fail_end_ptr)+ reset_fast_fail(common);++if (mode == JIT_PARTIAL_SOFT_COMPILE)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1);+if (common->mark_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0);+if (common->control_head_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);++/* Main part of the matching */+if ((re->options & PCRE_ANCHORED) == 0)+ {+ mainloop_label = mainloop_entry(common, (re->flags & PCRE_HASCRORLF) != 0);+ continue_match_label = LABEL();+ /* Forward search if possible. */+ if ((re->options & PCRE_NO_START_OPTIMIZE) == 0)+ {+ if (mode == JIT_COMPILE && fast_forward_first_n_chars(common))+ ;+ else if ((re->flags & PCRE_FIRSTSET) != 0)+ fast_forward_first_char(common, (pcre_uchar)re->first_char, (re->flags & PCRE_FCH_CASELESS) != 0);+ else if ((re->flags & PCRE_STARTLINE) != 0)+ fast_forward_newline(common);+ else if (study != NULL && (study->flags & PCRE_STUDY_MAPPED) != 0)+ fast_forward_start_bits(common, study->start_bits);+ }+ }+else+ continue_match_label = LABEL();++if (mode == JIT_COMPILE && study->minlength > 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)+ {+ OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);+ OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(study->minlength));+ minlength_check_failed = CMP(SLJIT_GREATER, TMP2, 0, STR_END, 0);+ }+if (common->req_char_ptr != 0)+ reqbyte_notfound = search_requested_char(common, (pcre_uchar)re->req_char, (re->flags & PCRE_RCH_CASELESS) != 0, (re->flags & PCRE_FIRSTSET) != 0);++/* Store the current STR_PTR in OVECTOR(0). */+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), STR_PTR, 0);+/* Copy the limit of allowed recursions. */+OP1(SLJIT_MOV, COUNT_MATCH, 0, SLJIT_MEM1(SLJIT_SP), LIMIT_MATCH);+if (common->capture_last_ptr != 0)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, -1);+if (common->fast_forward_bc_ptr != NULL)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), PRIVATE_DATA(common->fast_forward_bc_ptr + 1), STR_PTR, 0);++if (common->start_ptr != OVECTOR(0))+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_ptr, STR_PTR, 0);++/* Copy the beginning of the string. */+if (mode == JIT_PARTIAL_SOFT_COMPILE)+ {+ jump = CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start + sizeof(sljit_sw), STR_PTR, 0);+ JUMPHERE(jump);+ }+else if (mode == JIT_PARTIAL_HARD_COMPILE)+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);++compile_matchingpath(common, common->start, ccend, &rootbacktrack);+if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ {+ sljit_free_compiler(compiler);+ SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);+ SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);+ free_read_only_data(common->read_only_data_head, compiler->allocator_data);+ return;+ }++if (common->might_be_empty)+ {+ empty_match = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));+ empty_match_found_label = LABEL();+ }++common->accept_label = LABEL();+if (common->accept != NULL)+ set_jumps(common->accept, common->accept_label);++/* This means we have a match. Update the ovector. */+copy_ovector(common, re->top_bracket + 1);+common->quit_label = common->forced_quit_label = LABEL();+if (common->quit != NULL)+ set_jumps(common->quit, common->quit_label);+if (common->forced_quit != NULL)+ set_jumps(common->forced_quit, common->forced_quit_label);+if (minlength_check_failed != NULL)+ SET_LABEL(minlength_check_failed, common->forced_quit_label);+sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);++if (mode != JIT_COMPILE)+ {+ common->partialmatchlabel = LABEL();+ set_jumps(common->partialmatch, common->partialmatchlabel);+ return_with_partial_match(common, common->quit_label);+ }++if (common->might_be_empty)+ empty_match_backtrack_label = LABEL();+compile_backtrackingpath(common, rootbacktrack.top);+if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ {+ sljit_free_compiler(compiler);+ SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);+ SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);+ free_read_only_data(common->read_only_data_head, compiler->allocator_data);+ return;+ }++SLJIT_ASSERT(rootbacktrack.prev == NULL);+reset_match_label = LABEL();++if (mode == JIT_PARTIAL_SOFT_COMPILE)+ {+ /* Update hit_start only in the first time. */+ jump = CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1);+ OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, TMP1, 0);+ JUMPHERE(jump);+ }++/* Check we have remaining characters. */+if ((re->options & PCRE_ANCHORED) == 0 && (re->options & PCRE_FIRSTLINE) != 0)+ {+ SLJIT_ASSERT(common->match_end_ptr != 0);+ OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);+ }++OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP),+ (common->fast_forward_bc_ptr != NULL) ? (PRIVATE_DATA(common->fast_forward_bc_ptr + 1)) : common->start_ptr);++if ((re->options & PCRE_ANCHORED) == 0)+ {+ if (common->ff_newline_shortcut != NULL)+ {+ if ((re->options & PCRE_FIRSTLINE) == 0)+ CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, common->ff_newline_shortcut);+ /* There cannot be more newlines here. */+ }+ else+ CMPTO(SLJIT_LESS, STR_PTR, 0, ((re->options & PCRE_FIRSTLINE) == 0) ? STR_END : TMP1, 0, mainloop_label);+ }++/* No more remaining characters. */+if (reqbyte_notfound != NULL)+ JUMPHERE(reqbyte_notfound);++if (mode == JIT_PARTIAL_SOFT_COMPILE)+ CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1, common->partialmatchlabel);++OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);+JUMPTO(SLJIT_JUMP, common->quit_label);++flush_stubs(common);++if (common->might_be_empty)+ {+ JUMPHERE(empty_match);+ OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));+ CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_backtrack_label);+ OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));+ CMPTO(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_found_label);+ OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));+ CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, empty_match_found_label);+ JUMPTO(SLJIT_JUMP, empty_match_backtrack_label);+ }++common->fast_forward_bc_ptr = NULL;+common->fast_fail_start_ptr = 0;+common->fast_fail_end_ptr = 0;+common->currententry = common->entries;+common->local_exit = TRUE;+quit_label = common->quit_label;+while (common->currententry != NULL)+ {+ /* Might add new entries. */+ compile_recurse(common);+ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))+ {+ sljit_free_compiler(compiler);+ SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);+ SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);+ free_read_only_data(common->read_only_data_head, compiler->allocator_data);+ return;+ }+ flush_stubs(common);+ common->currententry = common->currententry->next;+ }+common->local_exit = FALSE;+common->quit_label = quit_label;++/* Allocating stack, returns with PCRE_ERROR_JIT_STACKLIMIT if fails. */+/* This is a (really) rare case. */+set_jumps(common->stackalloc, LABEL());+/* RETURN_ADDR is not a saved register. */+sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);++SLJIT_ASSERT(TMP1 == SLJIT_R0 && STACK_TOP == SLJIT_R1);++OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, STACK_TOP, 0);+OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0);+OP2(SLJIT_SUB, SLJIT_R1, 0, STACK_LIMIT, 0, SLJIT_IMM, STACK_GROWTH_RATE);+OP1(SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, stack));+OP1(SLJIT_MOV, STACK_LIMIT, 0, TMP2, 0);++sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_RET(SW) | SLJIT_ARG1(SW) | SLJIT_ARG2(SW), SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_stack_resize));+jump = CMP(SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);+OP1(SLJIT_MOV, TMP2, 0, STACK_LIMIT, 0);+OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_RETURN_REG, 0);+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);+sljit_emit_fast_return(compiler, TMP1, 0);++/* Allocation failed. */+JUMPHERE(jump);+/* We break the return address cache here, but this is a really rare case. */+OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_JIT_STACKLIMIT);+JUMPTO(SLJIT_JUMP, common->quit_label);++/* Call limit reached. */+set_jumps(common->calllimit, LABEL());+OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_MATCHLIMIT);+JUMPTO(SLJIT_JUMP, common->quit_label);++if (common->revertframes != NULL)+ {+ set_jumps(common->revertframes, LABEL());+ do_revertframes(common);+ }+if (common->wordboundary != NULL)+ {+ set_jumps(common->wordboundary, LABEL());+ check_wordboundary(common);+ }+if (common->anynewline != NULL)+ {+ set_jumps(common->anynewline, LABEL());+ check_anynewline(common);+ }+if (common->hspace != NULL)+ {+ set_jumps(common->hspace, LABEL());+ check_hspace(common);+ }+if (common->vspace != NULL)+ {+ set_jumps(common->vspace, LABEL());+ check_vspace(common);+ }+if (common->casefulcmp != NULL)+ {+ set_jumps(common->casefulcmp, LABEL());+ do_casefulcmp(common);+ }+if (common->caselesscmp != NULL)+ {+ set_jumps(common->caselesscmp, LABEL());+ do_caselesscmp(common);+ }+if (common->reset_match != NULL)+ {+ set_jumps(common->reset_match, LABEL());+ do_reset_match(common, (re->top_bracket + 1) * 2);+ CMPTO(SLJIT_GREATER, STR_PTR, 0, TMP1, 0, continue_match_label);+ OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);+ JUMPTO(SLJIT_JUMP, reset_match_label);+ }+#ifdef SUPPORT_UTF+#ifdef COMPILE_PCRE8+if (common->utfreadchar != NULL)+ {+ set_jumps(common->utfreadchar, LABEL());+ do_utfreadchar(common);+ }+if (common->utfreadchar16 != NULL)+ {+ set_jumps(common->utfreadchar16, LABEL());+ do_utfreadchar16(common);+ }+if (common->utfreadtype8 != NULL)+ {+ set_jumps(common->utfreadtype8, LABEL());+ do_utfreadtype8(common);+ }+#endif /* COMPILE_PCRE8 */+#endif /* SUPPORT_UTF */+#ifdef SUPPORT_UCP+if (common->getucd != NULL)+ {+ set_jumps(common->getucd, LABEL());+ do_getucd(common);+ }+#endif++SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);+SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);++executable_func = sljit_generate_code(compiler);+executable_size = sljit_get_generated_code_size(compiler);+label_addr = common->label_addrs;+while (label_addr != NULL)+ {+ *label_addr->update_addr = sljit_get_label_addr(label_addr->label);+ label_addr = label_addr->next;+ }+sljit_free_compiler(compiler);+if (executable_func == NULL)+ {+ free_read_only_data(common->read_only_data_head, compiler->allocator_data);+ return;+ }++/* Reuse the function descriptor if possible. */+if ((extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 && extra->executable_jit != NULL)+ functions = (executable_functions *)extra->executable_jit;+else+ {+ /* Note: If your memory-checker has flagged the allocation below as a+ * memory leak, it is probably because you either forgot to call+ * pcre_free_study() (or pcre16_free_study()) on the pcre_extra (or+ * pcre16_extra) object, or you called said function after having+ * cleared the PCRE_EXTRA_EXECUTABLE_JIT bit from the "flags" field+ * of the object. (The function will only free the JIT data if the+ * bit remains set, as the bit indicates that the pointer to the data+ * is valid.)+ */+ functions = SLJIT_MALLOC(sizeof(executable_functions), compiler->allocator_data);+ if (functions == NULL)+ {+ /* This case is highly unlikely since we just recently+ freed a lot of memory. Not impossible though. */+ sljit_free_code(executable_func);+ free_read_only_data(common->read_only_data_head, compiler->allocator_data);+ return;+ }+ memset(functions, 0, sizeof(executable_functions));+ functions->top_bracket = (re->top_bracket + 1) * 2;+ functions->limit_match = (re->flags & PCRE_MLSET) != 0 ? re->limit_match : 0;+ extra->executable_jit = functions;+ extra->flags |= PCRE_EXTRA_EXECUTABLE_JIT;+ }++functions->executable_funcs[mode] = executable_func;+functions->read_only_data_heads[mode] = common->read_only_data_head;+functions->executable_sizes[mode] = executable_size;+}++static SLJIT_NOINLINE int jit_machine_stack_exec(jit_arguments *arguments, void *executable_func)+{+union {+ void *executable_func;+ jit_function call_executable_func;+} convert_executable_func;+sljit_u8 local_space[MACHINE_STACK_SIZE];+struct sljit_stack local_stack;++local_stack.min_start = local_space;+local_stack.start = local_space;+local_stack.end = local_space + MACHINE_STACK_SIZE;+local_stack.top = local_space + MACHINE_STACK_SIZE;+arguments->stack = &local_stack;+convert_executable_func.executable_func = executable_func;+return convert_executable_func.call_executable_func(arguments);+}++int+PRIV(jit_exec)(const PUBL(extra) *extra_data, const pcre_uchar *subject,+ int length, int start_offset, int options, int *offsets, int offset_count)+{+executable_functions *functions = (executable_functions *)extra_data->executable_jit;+union {+ void *executable_func;+ jit_function call_executable_func;+} convert_executable_func;+jit_arguments arguments;+int max_offset_count;+int retval;+int mode = JIT_COMPILE;++if ((options & PCRE_PARTIAL_HARD) != 0)+ mode = JIT_PARTIAL_HARD_COMPILE;+else if ((options & PCRE_PARTIAL_SOFT) != 0)+ mode = JIT_PARTIAL_SOFT_COMPILE;++if (functions->executable_funcs[mode] == NULL)+ return PCRE_ERROR_JIT_BADOPTION;++/* Sanity checks should be handled by pcre_exec. */+arguments.str = subject + start_offset;+arguments.begin = subject;+arguments.end = subject + length;+arguments.mark_ptr = NULL;+/* JIT decreases this value less frequently than the interpreter. */+arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (sljit_u32)(extra_data->match_limit);+if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)+ arguments.limit_match = functions->limit_match;+arguments.notbol = (options & PCRE_NOTBOL) != 0;+arguments.noteol = (options & PCRE_NOTEOL) != 0;+arguments.notempty = (options & PCRE_NOTEMPTY) != 0;+arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;+arguments.offsets = offsets;+arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;+arguments.real_offset_count = offset_count;++/* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of+the output vector for storing captured strings, with the remainder used as+workspace. We don't need the workspace here. For compatibility, we limit the+number of captured strings in the same way as pcre_exec(), so that the user+gets the same result with and without JIT. */++if (offset_count != 2)+ offset_count = ((offset_count - (offset_count % 3)) * 2) / 3;+max_offset_count = functions->top_bracket;+if (offset_count > max_offset_count)+ offset_count = max_offset_count;+arguments.offset_count = offset_count;++if (functions->callback)+ arguments.stack = (struct sljit_stack *)functions->callback(functions->userdata);+else+ arguments.stack = (struct sljit_stack *)functions->userdata;++if (arguments.stack == NULL)+ retval = jit_machine_stack_exec(&arguments, functions->executable_funcs[mode]);+else+ {+ convert_executable_func.executable_func = functions->executable_funcs[mode];+ retval = convert_executable_func.call_executable_func(&arguments);+ }++if (retval * 2 > offset_count)+ retval = 0;+if ((extra_data->flags & PCRE_EXTRA_MARK) != 0)+ *(extra_data->mark) = arguments.mark_ptr;++return retval;+}++#if defined COMPILE_PCRE8+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION+pcre_jit_exec(const pcre *argument_re, const pcre_extra *extra_data,+ PCRE_SPTR subject, int length, int start_offset, int options,+ int *offsets, int offset_count, pcre_jit_stack *stack)+#elif defined COMPILE_PCRE16+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION+pcre16_jit_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,+ PCRE_SPTR16 subject, int length, int start_offset, int options,+ int *offsets, int offset_count, pcre16_jit_stack *stack)+#elif defined COMPILE_PCRE32+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION+pcre32_jit_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,+ PCRE_SPTR32 subject, int length, int start_offset, int options,+ int *offsets, int offset_count, pcre32_jit_stack *stack)+#endif+{+pcre_uchar *subject_ptr = (pcre_uchar *)subject;+executable_functions *functions = (executable_functions *)extra_data->executable_jit;+union {+ void *executable_func;+ jit_function call_executable_func;+} convert_executable_func;+jit_arguments arguments;+int max_offset_count;+int retval;+int mode = JIT_COMPILE;++SLJIT_UNUSED_ARG(argument_re);++/* Plausibility checks */+if ((options & ~PUBLIC_JIT_EXEC_OPTIONS) != 0) return PCRE_ERROR_JIT_BADOPTION;++if ((options & PCRE_PARTIAL_HARD) != 0)+ mode = JIT_PARTIAL_HARD_COMPILE;+else if ((options & PCRE_PARTIAL_SOFT) != 0)+ mode = JIT_PARTIAL_SOFT_COMPILE;++if (functions == NULL || functions->executable_funcs[mode] == NULL)+ return PCRE_ERROR_JIT_BADOPTION;++/* Sanity checks should be handled by pcre_exec. */+arguments.stack = (struct sljit_stack *)stack;+arguments.str = subject_ptr + start_offset;+arguments.begin = subject_ptr;+arguments.end = subject_ptr + length;+arguments.mark_ptr = NULL;+/* JIT decreases this value less frequently than the interpreter. */+arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (sljit_u32)(extra_data->match_limit);+if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)+ arguments.limit_match = functions->limit_match;+arguments.notbol = (options & PCRE_NOTBOL) != 0;+arguments.noteol = (options & PCRE_NOTEOL) != 0;+arguments.notempty = (options & PCRE_NOTEMPTY) != 0;+arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;+arguments.offsets = offsets;+arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;+arguments.real_offset_count = offset_count;++/* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of+the output vector for storing captured strings, with the remainder used as+workspace. We don't need the workspace here. For compatibility, we limit the+number of captured strings in the same way as pcre_exec(), so that the user+gets the same result with and without JIT. */++if (offset_count != 2)+ offset_count = ((offset_count - (offset_count % 3)) * 2) / 3;+max_offset_count = functions->top_bracket;+if (offset_count > max_offset_count)+ offset_count = max_offset_count;+arguments.offset_count = offset_count;++convert_executable_func.executable_func = functions->executable_funcs[mode];+retval = convert_executable_func.call_executable_func(&arguments);++if (retval * 2 > offset_count)+ retval = 0;+if ((extra_data->flags & PCRE_EXTRA_MARK) != 0)+ *(extra_data->mark) = arguments.mark_ptr;++return retval;+}++void+PRIV(jit_free)(void *executable_funcs)+{+int i;+executable_functions *functions = (executable_functions *)executable_funcs;+for (i = 0; i < JIT_NUMBER_OF_COMPILE_MODES; i++)+ {+ if (functions->executable_funcs[i] != NULL)+ sljit_free_code(functions->executable_funcs[i]);+ free_read_only_data(functions->read_only_data_heads[i], NULL);+ }+SLJIT_FREE(functions, compiler->allocator_data);+}++int+PRIV(jit_get_size)(void *executable_funcs)+{+int i;+sljit_uw size = 0;+sljit_uw *executable_sizes = ((executable_functions *)executable_funcs)->executable_sizes;+for (i = 0; i < JIT_NUMBER_OF_COMPILE_MODES; i++)+ size += executable_sizes[i];+return (int)size;+}++const char*+PRIV(jit_get_target)(void)+{+return sljit_get_platform_name();+}++#if defined COMPILE_PCRE8+PCRE_EXP_DECL pcre_jit_stack *+pcre_jit_stack_alloc(int startsize, int maxsize)+#elif defined COMPILE_PCRE16+PCRE_EXP_DECL pcre16_jit_stack *+pcre16_jit_stack_alloc(int startsize, int maxsize)+#elif defined COMPILE_PCRE32+PCRE_EXP_DECL pcre32_jit_stack *+pcre32_jit_stack_alloc(int startsize, int maxsize)+#endif+{+if (startsize < 1 || maxsize < 1)+ return NULL;+if (startsize > maxsize)+ startsize = maxsize;+startsize = (startsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);+maxsize = (maxsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);+return (PUBL(jit_stack)*)sljit_allocate_stack(startsize, maxsize, NULL);+}++#if defined COMPILE_PCRE8+PCRE_EXP_DECL void+pcre_jit_stack_free(pcre_jit_stack *stack)+#elif defined COMPILE_PCRE16+PCRE_EXP_DECL void+pcre16_jit_stack_free(pcre16_jit_stack *stack)+#elif defined COMPILE_PCRE32+PCRE_EXP_DECL void+pcre32_jit_stack_free(pcre32_jit_stack *stack)+#endif+{+sljit_free_stack((struct sljit_stack *)stack, NULL); } #if defined COMPILE_PCRE8
pcre/pcre_printint.c view
@@ -644,7 +644,9 @@ int i; unsigned int min, max; BOOL printmap;+ BOOL invertmap = FALSE; pcre_uint8 *map;+ pcre_uint8 inverted_map[32]; fprintf(f, " ["); @@ -653,7 +655,12 @@ extra = GET(code, 1); ccode = code + LINK_SIZE + 1; printmap = (*ccode & XCL_MAP) != 0;- if ((*ccode++ & XCL_NOT) != 0) fprintf(f, "^");+ if ((*ccode & XCL_NOT) != 0)+ {+ invertmap = (*ccode & XCL_HASPROP) == 0;+ fprintf(f, "^");+ }+ ccode++; } else {@@ -666,6 +673,12 @@ if (printmap) { map = (pcre_uint8 *)ccode;+ if (invertmap)+ {+ for (i = 0; i < 32; i++) inverted_map[i] = ~map[i];+ map = inverted_map;+ }+ for (i = 0; i < 256; i++) { if ((map[i/8] & (1 << (i&7))) != 0)
pcre/pcre_string_utils.c view
@@ -6,7 +6,7 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel- Copyright (c) 1997-2013 University of Cambridge+ Copyright (c) 1997-2014 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without@@ -91,8 +91,8 @@ while (*str1 != '\0' || *str2 != '\0') {- c1 = RAWUCHARINC(str1);- c2 = RAWUCHARINC(str2);+ c1 = UCHAR21INC(str1);+ c2 = UCHAR21INC(str2); if (c1 != c2) return ((c1 > c2) << 1) - 1; }@@ -131,7 +131,7 @@ while (*str1 != '\0' || *ustr2 != '\0') {- c1 = RAWUCHARINC(str1);+ c1 = UCHAR21INC(str1); c2 = (pcre_uchar)*ustr2++; if (c1 != c2) return ((c1 > c2) << 1) - 1;
pcre/pcre_study.c view
@@ -70,7 +70,8 @@ code pointer to start of group (the bracket) startcode pointer to start of the whole pattern's code options the compiling options- int RECURSE depth+ recurses chain of recurse_check to catch mutual recursion+ countptr pointer to call count (to catch over complexity) Returns: the minimum length -1 if \C in UTF-8 mode or (*ACCEPT) was encountered@@ -80,15 +81,19 @@ static int find_minlength(const REAL_PCRE *re, const pcre_uchar *code,- const pcre_uchar *startcode, int options, int recurse_depth)+ const pcre_uchar *startcode, int options, recurse_check *recurses,+ int *countptr) { int length = -1; /* PCRE_UTF16 has the same value as PCRE_UTF8. */ BOOL utf = (options & PCRE_UTF8) != 0; BOOL had_recurse = FALSE;+recurse_check this_recurse; register int branchlength = 0; register pcre_uchar *cc = (pcre_uchar *)code + 1 + LINK_SIZE; +if ((*countptr)++ > 1000) return -1; /* too complex */+ if (*code == OP_CBRA || *code == OP_SCBRA || *code == OP_CBRAPOS || *code == OP_SCBRAPOS) cc += IMM2_SIZE; @@ -130,7 +135,7 @@ case OP_SBRAPOS: case OP_ONCE: case OP_ONCE_NC:- d = find_minlength(re, cc, startcode, options, recurse_depth);+ d = find_minlength(re, cc, startcode, options, recurses, countptr); if (d < 0) return d; branchlength += d; do cc += GET(cc, 1); while (*cc == OP_ALT);@@ -393,7 +398,7 @@ ce = cs = (pcre_uchar *)PRIV(find_bracket)(startcode, utf, GET2(slot, 0)); if (cs == NULL) return -2; do ce += GET(ce, 1); while (*ce == OP_ALT);- if (cc > cs && cc < ce)+ if (cc > cs && cc < ce) /* Simple recursion */ { d = 0; had_recurse = TRUE;@@ -401,8 +406,23 @@ } else {- int dd = find_minlength(re, cs, startcode, options, recurse_depth);- if (dd < d) d = dd;+ recurse_check *r = recurses;+ for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;+ if (r != NULL) /* Mutual recursion */+ {+ d = 0;+ had_recurse = TRUE;+ break;+ }+ else+ {+ int dd;+ this_recurse.prev = recurses;+ this_recurse.group = cs;+ dd = find_minlength(re, cs, startcode, options, &this_recurse,+ countptr);+ if (dd < d) d = dd;+ } } slot += re->name_entry_size; }@@ -418,14 +438,27 @@ ce = cs = (pcre_uchar *)PRIV(find_bracket)(startcode, utf, GET2(cc, 1)); if (cs == NULL) return -2; do ce += GET(ce, 1); while (*ce == OP_ALT);- if (cc > cs && cc < ce)+ if (cc > cs && cc < ce) /* Simple recursion */ { d = 0; had_recurse = TRUE; } else {- d = find_minlength(re, cs, startcode, options, recurse_depth);+ recurse_check *r = recurses;+ for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;+ if (r != NULL) /* Mutual recursion */+ {+ d = 0;+ had_recurse = TRUE;+ }+ else+ {+ this_recurse.prev = recurses;+ this_recurse.group = cs;+ d = find_minlength(re, cs, startcode, options, &this_recurse,+ countptr);+ } } } else d = 0;@@ -474,12 +507,21 @@ case OP_RECURSE: cs = ce = (pcre_uchar *)startcode + GET(cc, 1); do ce += GET(ce, 1); while (*ce == OP_ALT);- if ((cc > cs && cc < ce) || recurse_depth > 10)+ if (cc > cs && cc < ce) /* Simple recursion */ had_recurse = TRUE; else {- branchlength += find_minlength(re, cs, startcode, options,- recurse_depth + 1);+ recurse_check *r = recurses;+ for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;+ if (r != NULL) /* Mutual recursion */+ had_recurse = TRUE;+ else+ {+ this_recurse.prev = recurses;+ this_recurse.group = cs;+ branchlength += find_minlength(re, cs, startcode, options,+ &this_recurse, countptr);+ } } cc += 1 + LINK_SIZE; break;@@ -863,7 +905,6 @@ case OP_NOTUPTOI: case OP_NOT_HSPACE: case OP_NOT_VSPACE:- case OP_PROP: case OP_PRUNE: case OP_PRUNE_ARG: case OP_RECURSE:@@ -879,11 +920,33 @@ case OP_SOM: case OP_THEN: case OP_THEN_ARG:-#if defined SUPPORT_UTF || !defined COMPILE_PCRE8- case OP_XCLASS:-#endif return SSB_FAIL; + /* A "real" property test implies no starting bits, but the fake property+ PT_CLIST identifies a list of characters. These lists are short, as they+ are used for characters with more than one "other case", so there is no+ point in recognizing them for OP_NOTPROP. */++ case OP_PROP:+ if (tcode[1] != PT_CLIST) return SSB_FAIL;+ {+ const pcre_uint32 *p = PRIV(ucd_caseless_sets) + tcode[2];+ while ((c = *p++) < NOTACHAR)+ {+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (utf)+ {+ pcre_uchar buff[6];+ (void)PRIV(ord2utf)(c, buff);+ c = buff[0];+ }+#endif+ if (c > 0xff) SET_BIT(0xff); else SET_BIT(c);+ }+ }+ try_next = FALSE;+ break;+ /* We can ignore word boundary tests. */ case OP_WORD_BOUNDARY:@@ -1109,24 +1172,17 @@ try_next = FALSE; break; - /* The cbit_space table has vertical tab as whitespace; we have to- ensure it is set as not whitespace. Luckily, the code value is the same- (0x0b) in ASCII and EBCDIC, so we can just adjust the appropriate bit. */+ /* The cbit_space table has vertical tab as whitespace; we no longer+ have to play fancy tricks because Perl added VT to its whitespace at+ release 5.18. PCRE added it at release 8.34. */ case OP_NOT_WHITESPACE: set_nottype_bits(start_bits, cbit_space, table_limit, cd);- start_bits[1] |= 0x08; try_next = FALSE; break; - /* The cbit_space table has vertical tab as whitespace; we have to not- set it from the table. Luckily, the code value is the same (0x0b) in- ASCII and EBCDIC, so we can just adjust the appropriate bit. */- case OP_WHITESPACE:- c = start_bits[1]; /* Save in case it was already set */ set_type_bits(start_bits, cbit_space, table_limit, cd);- start_bits[1] = (start_bits[1] & ~0x08) | c; try_next = FALSE; break; @@ -1257,6 +1313,16 @@ with a value >= 0xc4 is a potentially valid starter because it starts a character with a value > 255. */ +#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ case OP_XCLASS:+ if ((tcode[1 + LINK_SIZE] & XCL_HASPROP) != 0)+ return SSB_FAIL;+ /* All bits are set. */+ if ((tcode[1 + LINK_SIZE] & XCL_MAP) == 0 && (tcode[1 + LINK_SIZE] & XCL_NOT) != 0)+ return SSB_FAIL;+#endif+ /* Fall through */+ case OP_NCLASS: #if defined SUPPORT_UTF && defined COMPILE_PCRE8 if (utf)@@ -1273,8 +1339,21 @@ case OP_CLASS: { pcre_uint8 *map;- tcode++;- map = (pcre_uint8 *)tcode;+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ map = NULL;+ if (*tcode == OP_XCLASS)+ {+ if ((tcode[1 + LINK_SIZE] & XCL_MAP) != 0)+ map = (pcre_uint8 *)(tcode + 1 + LINK_SIZE + 1);+ tcode += GET(tcode, 1);+ }+ else+#endif+ {+ tcode++;+ map = (pcre_uint8 *)tcode;+ tcode += 32 / sizeof(pcre_uchar);+ } /* In UTF-8 mode, the bits in a bit map correspond to character values, not to byte values. However, the bit map we are constructing is@@ -1282,31 +1361,35 @@ value is > 127. In fact, there are only two possible starting bytes for characters in the range 128 - 255. */ -#if defined SUPPORT_UTF && defined COMPILE_PCRE8- if (utf)+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8+ if (map != NULL)+#endif {- for (c = 0; c < 16; c++) start_bits[c] |= map[c];- for (c = 128; c < 256; c++)+#if defined SUPPORT_UTF && defined COMPILE_PCRE8+ if (utf) {- if ((map[c/8] && (1 << (c&7))) != 0)+ for (c = 0; c < 16; c++) start_bits[c] |= map[c];+ for (c = 128; c < 256; c++) {- int d = (c >> 6) | 0xc0; /* Set bit for this starter */- start_bits[d/8] |= (1 << (d&7)); /* and then skip on to the */- c = (c & 0xc0) + 0x40 - 1; /* next relevant character. */+ if ((map[c/8] & (1 << (c&7))) != 0)+ {+ int d = (c >> 6) | 0xc0; /* Set bit for this starter */+ start_bits[d/8] |= (1 << (d&7)); /* and then skip on to the */+ c = (c & 0xc0) + 0x40 - 1; /* next relevant character. */+ } } }- }- else+ else #endif- {- /* In non-UTF-8 mode, the two bit maps are completely compatible. */- for (c = 0; c < 32; c++) start_bits[c] |= map[c];+ {+ /* In non-UTF-8 mode, the two bit maps are completely compatible. */+ for (c = 0; c < 32; c++) start_bits[c] |= map[c];+ } } /* Advance past the bit map, and act on what follows. For a zero minimum repeat, continue; otherwise stop processing. */ - tcode += 32 / sizeof(pcre_uchar); switch (*tcode) { case OP_CRSTAR:@@ -1376,6 +1459,7 @@ #endif { int min;+int count = 0; BOOL bits_set = FALSE; pcre_uint8 start_bits[32]; PUBL(extra) *extra = NULL;@@ -1462,7 +1546,7 @@ /* Find the minimum length of subject string. */ -switch(min = find_minlength(re, code, code, re->options, 0))+switch(min = find_minlength(re, code, code, re->options, NULL, &count)) { case -2: *errorptr = "internal error: missing capturing bracket"; return NULL; case -3: *errorptr = "internal error: opcode not recognized"; return NULL;
pcre/pcre_tables.c view
@@ -6,7 +6,7 @@ and semantics are as close as possible to those of the Perl 5 language. Written by Philip Hazel- Copyright (c) 1997-2012 University of Cambridge+ Copyright (c) 1997-2017 University of Cambridge ----------------------------------------------------------------------------- Redistribution and use in source and binary forms, with or without@@ -161,7 +161,7 @@ (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark), /* 5 SpacingMark */ (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)|(1<<ucp_gbL)| /* 6 L */- (1<<ucp_gbL)|(1<<ucp_gbV)|(1<<ucp_gbLV)|(1<<ucp_gbLVT),+ (1<<ucp_gbV)|(1<<ucp_gbLV)|(1<<ucp_gbLVT), (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)|(1<<ucp_gbV)| /* 7 V */ (1<<ucp_gbT),@@ -213,6 +213,7 @@ #define STRING_Avestan0 STR_A STR_v STR_e STR_s STR_t STR_a STR_n "\0" #define STRING_Balinese0 STR_B STR_a STR_l STR_i STR_n STR_e STR_s STR_e "\0" #define STRING_Bamum0 STR_B STR_a STR_m STR_u STR_m "\0"+#define STRING_Bassa_Vah0 STR_B STR_a STR_s STR_s STR_a STR_UNDERSCORE STR_V STR_a STR_h "\0" #define STRING_Batak0 STR_B STR_a STR_t STR_a STR_k "\0" #define STRING_Bengali0 STR_B STR_e STR_n STR_g STR_a STR_l STR_i "\0" #define STRING_Bopomofo0 STR_B STR_o STR_p STR_o STR_m STR_o STR_f STR_o "\0"@@ -223,6 +224,7 @@ #define STRING_C0 STR_C "\0" #define STRING_Canadian_Aboriginal0 STR_C STR_a STR_n STR_a STR_d STR_i STR_a STR_n STR_UNDERSCORE STR_A STR_b STR_o STR_r STR_i STR_g STR_i STR_n STR_a STR_l "\0" #define STRING_Carian0 STR_C STR_a STR_r STR_i STR_a STR_n "\0"+#define STRING_Caucasian_Albanian0 STR_C STR_a STR_u STR_c STR_a STR_s STR_i STR_a STR_n STR_UNDERSCORE STR_A STR_l STR_b STR_a STR_n STR_i STR_a STR_n "\0" #define STRING_Cc0 STR_C STR_c "\0" #define STRING_Cf0 STR_C STR_f "\0" #define STRING_Chakma0 STR_C STR_h STR_a STR_k STR_m STR_a "\0"@@ -238,11 +240,14 @@ #define STRING_Cyrillic0 STR_C STR_y STR_r STR_i STR_l STR_l STR_i STR_c "\0" #define STRING_Deseret0 STR_D STR_e STR_s STR_e STR_r STR_e STR_t "\0" #define STRING_Devanagari0 STR_D STR_e STR_v STR_a STR_n STR_a STR_g STR_a STR_r STR_i "\0"+#define STRING_Duployan0 STR_D STR_u STR_p STR_l STR_o STR_y STR_a STR_n "\0" #define STRING_Egyptian_Hieroglyphs0 STR_E STR_g STR_y STR_p STR_t STR_i STR_a STR_n STR_UNDERSCORE STR_H STR_i STR_e STR_r STR_o STR_g STR_l STR_y STR_p STR_h STR_s "\0"+#define STRING_Elbasan0 STR_E STR_l STR_b STR_a STR_s STR_a STR_n "\0" #define STRING_Ethiopic0 STR_E STR_t STR_h STR_i STR_o STR_p STR_i STR_c "\0" #define STRING_Georgian0 STR_G STR_e STR_o STR_r STR_g STR_i STR_a STR_n "\0" #define STRING_Glagolitic0 STR_G STR_l STR_a STR_g STR_o STR_l STR_i STR_t STR_i STR_c "\0" #define STRING_Gothic0 STR_G STR_o STR_t STR_h STR_i STR_c "\0"+#define STRING_Grantha0 STR_G STR_r STR_a STR_n STR_t STR_h STR_a "\0" #define STRING_Greek0 STR_G STR_r STR_e STR_e STR_k "\0" #define STRING_Gujarati0 STR_G STR_u STR_j STR_a STR_r STR_a STR_t STR_i "\0" #define STRING_Gurmukhi0 STR_G STR_u STR_r STR_m STR_u STR_k STR_h STR_i "\0"@@ -262,12 +267,15 @@ #define STRING_Kayah_Li0 STR_K STR_a STR_y STR_a STR_h STR_UNDERSCORE STR_L STR_i "\0" #define STRING_Kharoshthi0 STR_K STR_h STR_a STR_r STR_o STR_s STR_h STR_t STR_h STR_i "\0" #define STRING_Khmer0 STR_K STR_h STR_m STR_e STR_r "\0"+#define STRING_Khojki0 STR_K STR_h STR_o STR_j STR_k STR_i "\0"+#define STRING_Khudawadi0 STR_K STR_h STR_u STR_d STR_a STR_w STR_a STR_d STR_i "\0" #define STRING_L0 STR_L "\0" #define STRING_L_AMPERSAND0 STR_L STR_AMPERSAND "\0" #define STRING_Lao0 STR_L STR_a STR_o "\0" #define STRING_Latin0 STR_L STR_a STR_t STR_i STR_n "\0" #define STRING_Lepcha0 STR_L STR_e STR_p STR_c STR_h STR_a "\0" #define STRING_Limbu0 STR_L STR_i STR_m STR_b STR_u "\0"+#define STRING_Linear_A0 STR_L STR_i STR_n STR_e STR_a STR_r STR_UNDERSCORE STR_A "\0" #define STRING_Linear_B0 STR_L STR_i STR_n STR_e STR_a STR_r STR_UNDERSCORE STR_B "\0" #define STRING_Lisu0 STR_L STR_i STR_s STR_u "\0" #define STRING_Ll0 STR_L STR_l "\0"@@ -278,18 +286,24 @@ #define STRING_Lycian0 STR_L STR_y STR_c STR_i STR_a STR_n "\0" #define STRING_Lydian0 STR_L STR_y STR_d STR_i STR_a STR_n "\0" #define STRING_M0 STR_M "\0"+#define STRING_Mahajani0 STR_M STR_a STR_h STR_a STR_j STR_a STR_n STR_i "\0" #define STRING_Malayalam0 STR_M STR_a STR_l STR_a STR_y STR_a STR_l STR_a STR_m "\0" #define STRING_Mandaic0 STR_M STR_a STR_n STR_d STR_a STR_i STR_c "\0"+#define STRING_Manichaean0 STR_M STR_a STR_n STR_i STR_c STR_h STR_a STR_e STR_a STR_n "\0" #define STRING_Mc0 STR_M STR_c "\0" #define STRING_Me0 STR_M STR_e "\0" #define STRING_Meetei_Mayek0 STR_M STR_e STR_e STR_t STR_e STR_i STR_UNDERSCORE STR_M STR_a STR_y STR_e STR_k "\0"+#define STRING_Mende_Kikakui0 STR_M STR_e STR_n STR_d STR_e STR_UNDERSCORE STR_K STR_i STR_k STR_a STR_k STR_u STR_i "\0" #define STRING_Meroitic_Cursive0 STR_M STR_e STR_r STR_o STR_i STR_t STR_i STR_c STR_UNDERSCORE STR_C STR_u STR_r STR_s STR_i STR_v STR_e "\0" #define STRING_Meroitic_Hieroglyphs0 STR_M STR_e STR_r STR_o STR_i STR_t STR_i STR_c STR_UNDERSCORE STR_H STR_i STR_e STR_r STR_o STR_g STR_l STR_y STR_p STR_h STR_s "\0" #define STRING_Miao0 STR_M STR_i STR_a STR_o "\0" #define STRING_Mn0 STR_M STR_n "\0"+#define STRING_Modi0 STR_M STR_o STR_d STR_i "\0" #define STRING_Mongolian0 STR_M STR_o STR_n STR_g STR_o STR_l STR_i STR_a STR_n "\0"+#define STRING_Mro0 STR_M STR_r STR_o "\0" #define STRING_Myanmar0 STR_M STR_y STR_a STR_n STR_m STR_a STR_r "\0" #define STRING_N0 STR_N "\0"+#define STRING_Nabataean0 STR_N STR_a STR_b STR_a STR_t STR_a STR_e STR_a STR_n "\0" #define STRING_Nd0 STR_N STR_d "\0" #define STRING_New_Tai_Lue0 STR_N STR_e STR_w STR_UNDERSCORE STR_T STR_a STR_i STR_UNDERSCORE STR_L STR_u STR_e "\0" #define STRING_Nko0 STR_N STR_k STR_o "\0"@@ -298,12 +312,17 @@ #define STRING_Ogham0 STR_O STR_g STR_h STR_a STR_m "\0" #define STRING_Ol_Chiki0 STR_O STR_l STR_UNDERSCORE STR_C STR_h STR_i STR_k STR_i "\0" #define STRING_Old_Italic0 STR_O STR_l STR_d STR_UNDERSCORE STR_I STR_t STR_a STR_l STR_i STR_c "\0"+#define STRING_Old_North_Arabian0 STR_O STR_l STR_d STR_UNDERSCORE STR_N STR_o STR_r STR_t STR_h STR_UNDERSCORE STR_A STR_r STR_a STR_b STR_i STR_a STR_n "\0"+#define STRING_Old_Permic0 STR_O STR_l STR_d STR_UNDERSCORE STR_P STR_e STR_r STR_m STR_i STR_c "\0" #define STRING_Old_Persian0 STR_O STR_l STR_d STR_UNDERSCORE STR_P STR_e STR_r STR_s STR_i STR_a STR_n "\0" #define STRING_Old_South_Arabian0 STR_O STR_l STR_d STR_UNDERSCORE STR_S STR_o STR_u STR_t STR_h STR_UNDERSCORE STR_A STR_r STR_a STR_b STR_i STR_a STR_n "\0" #define STRING_Old_Turkic0 STR_O STR_l STR_d STR_UNDERSCORE STR_T STR_u STR_r STR_k STR_i STR_c "\0" #define STRING_Oriya0 STR_O STR_r STR_i STR_y STR_a "\0" #define STRING_Osmanya0 STR_O STR_s STR_m STR_a STR_n STR_y STR_a "\0" #define STRING_P0 STR_P "\0"+#define STRING_Pahawh_Hmong0 STR_P STR_a STR_h STR_a STR_w STR_h STR_UNDERSCORE STR_H STR_m STR_o STR_n STR_g "\0"+#define STRING_Palmyrene0 STR_P STR_a STR_l STR_m STR_y STR_r STR_e STR_n STR_e "\0"+#define STRING_Pau_Cin_Hau0 STR_P STR_a STR_u STR_UNDERSCORE STR_C STR_i STR_n STR_UNDERSCORE STR_H STR_a STR_u "\0" #define STRING_Pc0 STR_P STR_c "\0" #define STRING_Pd0 STR_P STR_d "\0" #define STRING_Pe0 STR_P STR_e "\0"@@ -313,6 +332,7 @@ #define STRING_Pi0 STR_P STR_i "\0" #define STRING_Po0 STR_P STR_o "\0" #define STRING_Ps0 STR_P STR_s "\0"+#define STRING_Psalter_Pahlavi0 STR_P STR_s STR_a STR_l STR_t STR_e STR_r STR_UNDERSCORE STR_P STR_a STR_h STR_l STR_a STR_v STR_i "\0" #define STRING_Rejang0 STR_R STR_e STR_j STR_a STR_n STR_g "\0" #define STRING_Runic0 STR_R STR_u STR_n STR_i STR_c "\0" #define STRING_S0 STR_S "\0"@@ -321,6 +341,7 @@ #define STRING_Sc0 STR_S STR_c "\0" #define STRING_Sharada0 STR_S STR_h STR_a STR_r STR_a STR_d STR_a "\0" #define STRING_Shavian0 STR_S STR_h STR_a STR_v STR_i STR_a STR_n "\0"+#define STRING_Siddham0 STR_S STR_i STR_d STR_d STR_h STR_a STR_m "\0" #define STRING_Sinhala0 STR_S STR_i STR_n STR_h STR_a STR_l STR_a "\0" #define STRING_Sk0 STR_S STR_k "\0" #define STRING_Sm0 STR_S STR_m "\0"@@ -341,8 +362,10 @@ #define STRING_Thai0 STR_T STR_h STR_a STR_i "\0" #define STRING_Tibetan0 STR_T STR_i STR_b STR_e STR_t STR_a STR_n "\0" #define STRING_Tifinagh0 STR_T STR_i STR_f STR_i STR_n STR_a STR_g STR_h "\0"+#define STRING_Tirhuta0 STR_T STR_i STR_r STR_h STR_u STR_t STR_a "\0" #define STRING_Ugaritic0 STR_U STR_g STR_a STR_r STR_i STR_t STR_i STR_c "\0" #define STRING_Vai0 STR_V STR_a STR_i "\0"+#define STRING_Warang_Citi0 STR_W STR_a STR_r STR_a STR_n STR_g STR_UNDERSCORE STR_C STR_i STR_t STR_i "\0" #define STRING_Xan0 STR_X STR_a STR_n "\0" #define STRING_Xps0 STR_X STR_p STR_s "\0" #define STRING_Xsp0 STR_X STR_s STR_p "\0"@@ -361,6 +384,7 @@ STRING_Avestan0 STRING_Balinese0 STRING_Bamum0+ STRING_Bassa_Vah0 STRING_Batak0 STRING_Bengali0 STRING_Bopomofo0@@ -371,6 +395,7 @@ STRING_C0 STRING_Canadian_Aboriginal0 STRING_Carian0+ STRING_Caucasian_Albanian0 STRING_Cc0 STRING_Cf0 STRING_Chakma0@@ -386,11 +411,14 @@ STRING_Cyrillic0 STRING_Deseret0 STRING_Devanagari0+ STRING_Duployan0 STRING_Egyptian_Hieroglyphs0+ STRING_Elbasan0 STRING_Ethiopic0 STRING_Georgian0 STRING_Glagolitic0 STRING_Gothic0+ STRING_Grantha0 STRING_Greek0 STRING_Gujarati0 STRING_Gurmukhi0@@ -410,12 +438,15 @@ STRING_Kayah_Li0 STRING_Kharoshthi0 STRING_Khmer0+ STRING_Khojki0+ STRING_Khudawadi0 STRING_L0 STRING_L_AMPERSAND0 STRING_Lao0 STRING_Latin0 STRING_Lepcha0 STRING_Limbu0+ STRING_Linear_A0 STRING_Linear_B0 STRING_Lisu0 STRING_Ll0@@ -426,18 +457,24 @@ STRING_Lycian0 STRING_Lydian0 STRING_M0+ STRING_Mahajani0 STRING_Malayalam0 STRING_Mandaic0+ STRING_Manichaean0 STRING_Mc0 STRING_Me0 STRING_Meetei_Mayek0+ STRING_Mende_Kikakui0 STRING_Meroitic_Cursive0 STRING_Meroitic_Hieroglyphs0 STRING_Miao0 STRING_Mn0+ STRING_Modi0 STRING_Mongolian0+ STRING_Mro0 STRING_Myanmar0 STRING_N0+ STRING_Nabataean0 STRING_Nd0 STRING_New_Tai_Lue0 STRING_Nko0@@ -446,12 +483,17 @@ STRING_Ogham0 STRING_Ol_Chiki0 STRING_Old_Italic0+ STRING_Old_North_Arabian0+ STRING_Old_Permic0 STRING_Old_Persian0 STRING_Old_South_Arabian0 STRING_Old_Turkic0 STRING_Oriya0 STRING_Osmanya0 STRING_P0+ STRING_Pahawh_Hmong0+ STRING_Palmyrene0+ STRING_Pau_Cin_Hau0 STRING_Pc0 STRING_Pd0 STRING_Pe0@@ -461,6 +503,7 @@ STRING_Pi0 STRING_Po0 STRING_Ps0+ STRING_Psalter_Pahlavi0 STRING_Rejang0 STRING_Runic0 STRING_S0@@ -469,6 +512,7 @@ STRING_Sc0 STRING_Sharada0 STRING_Shavian0+ STRING_Siddham0 STRING_Sinhala0 STRING_Sk0 STRING_Sm0@@ -489,8 +533,10 @@ STRING_Thai0 STRING_Tibetan0 STRING_Tifinagh0+ STRING_Tirhuta0 STRING_Ugaritic0 STRING_Vai0+ STRING_Warang_Citi0 STRING_Xan0 STRING_Xps0 STRING_Xsp0@@ -509,146 +555,169 @@ { 20, PT_SC, ucp_Avestan }, { 28, PT_SC, ucp_Balinese }, { 37, PT_SC, ucp_Bamum },- { 43, PT_SC, ucp_Batak },- { 49, PT_SC, ucp_Bengali },- { 57, PT_SC, ucp_Bopomofo },- { 66, PT_SC, ucp_Brahmi },- { 73, PT_SC, ucp_Braille },- { 81, PT_SC, ucp_Buginese },- { 90, PT_SC, ucp_Buhid },- { 96, PT_GC, ucp_C },- { 98, PT_SC, ucp_Canadian_Aboriginal },- { 118, PT_SC, ucp_Carian },- { 125, PT_PC, ucp_Cc },- { 128, PT_PC, ucp_Cf },- { 131, PT_SC, ucp_Chakma },- { 138, PT_SC, ucp_Cham },- { 143, PT_SC, ucp_Cherokee },- { 152, PT_PC, ucp_Cn },- { 155, PT_PC, ucp_Co },- { 158, PT_SC, ucp_Common },- { 165, PT_SC, ucp_Coptic },- { 172, PT_PC, ucp_Cs },- { 175, PT_SC, ucp_Cuneiform },- { 185, PT_SC, ucp_Cypriot },- { 193, PT_SC, ucp_Cyrillic },- { 202, PT_SC, ucp_Deseret },- { 210, PT_SC, ucp_Devanagari },- { 221, PT_SC, ucp_Egyptian_Hieroglyphs },- { 242, PT_SC, ucp_Ethiopic },- { 251, PT_SC, ucp_Georgian },- { 260, PT_SC, ucp_Glagolitic },- { 271, PT_SC, ucp_Gothic },- { 278, PT_SC, ucp_Greek },- { 284, PT_SC, ucp_Gujarati },- { 293, PT_SC, ucp_Gurmukhi },- { 302, PT_SC, ucp_Han },- { 306, PT_SC, ucp_Hangul },- { 313, PT_SC, ucp_Hanunoo },- { 321, PT_SC, ucp_Hebrew },- { 328, PT_SC, ucp_Hiragana },- { 337, PT_SC, ucp_Imperial_Aramaic },- { 354, PT_SC, ucp_Inherited },- { 364, PT_SC, ucp_Inscriptional_Pahlavi },- { 386, PT_SC, ucp_Inscriptional_Parthian },- { 409, PT_SC, ucp_Javanese },- { 418, PT_SC, ucp_Kaithi },- { 425, PT_SC, ucp_Kannada },- { 433, PT_SC, ucp_Katakana },- { 442, PT_SC, ucp_Kayah_Li },- { 451, PT_SC, ucp_Kharoshthi },- { 462, PT_SC, ucp_Khmer },- { 468, PT_GC, ucp_L },- { 470, PT_LAMP, 0 },- { 473, PT_SC, ucp_Lao },- { 477, PT_SC, ucp_Latin },- { 483, PT_SC, ucp_Lepcha },- { 490, PT_SC, ucp_Limbu },- { 496, PT_SC, ucp_Linear_B },- { 505, PT_SC, ucp_Lisu },- { 510, PT_PC, ucp_Ll },- { 513, PT_PC, ucp_Lm },- { 516, PT_PC, ucp_Lo },- { 519, PT_PC, ucp_Lt },- { 522, PT_PC, ucp_Lu },- { 525, PT_SC, ucp_Lycian },- { 532, PT_SC, ucp_Lydian },- { 539, PT_GC, ucp_M },- { 541, PT_SC, ucp_Malayalam },- { 551, PT_SC, ucp_Mandaic },- { 559, PT_PC, ucp_Mc },- { 562, PT_PC, ucp_Me },- { 565, PT_SC, ucp_Meetei_Mayek },- { 578, PT_SC, ucp_Meroitic_Cursive },- { 595, PT_SC, ucp_Meroitic_Hieroglyphs },- { 616, PT_SC, ucp_Miao },- { 621, PT_PC, ucp_Mn },- { 624, PT_SC, ucp_Mongolian },- { 634, PT_SC, ucp_Myanmar },- { 642, PT_GC, ucp_N },- { 644, PT_PC, ucp_Nd },- { 647, PT_SC, ucp_New_Tai_Lue },- { 659, PT_SC, ucp_Nko },- { 663, PT_PC, ucp_Nl },- { 666, PT_PC, ucp_No },- { 669, PT_SC, ucp_Ogham },- { 675, PT_SC, ucp_Ol_Chiki },- { 684, PT_SC, ucp_Old_Italic },- { 695, PT_SC, ucp_Old_Persian },- { 707, PT_SC, ucp_Old_South_Arabian },- { 725, PT_SC, ucp_Old_Turkic },- { 736, PT_SC, ucp_Oriya },- { 742, PT_SC, ucp_Osmanya },- { 750, PT_GC, ucp_P },- { 752, PT_PC, ucp_Pc },- { 755, PT_PC, ucp_Pd },- { 758, PT_PC, ucp_Pe },- { 761, PT_PC, ucp_Pf },- { 764, PT_SC, ucp_Phags_Pa },- { 773, PT_SC, ucp_Phoenician },- { 784, PT_PC, ucp_Pi },- { 787, PT_PC, ucp_Po },- { 790, PT_PC, ucp_Ps },- { 793, PT_SC, ucp_Rejang },- { 800, PT_SC, ucp_Runic },- { 806, PT_GC, ucp_S },- { 808, PT_SC, ucp_Samaritan },- { 818, PT_SC, ucp_Saurashtra },- { 829, PT_PC, ucp_Sc },- { 832, PT_SC, ucp_Sharada },- { 840, PT_SC, ucp_Shavian },- { 848, PT_SC, ucp_Sinhala },- { 856, PT_PC, ucp_Sk },- { 859, PT_PC, ucp_Sm },- { 862, PT_PC, ucp_So },- { 865, PT_SC, ucp_Sora_Sompeng },- { 878, PT_SC, ucp_Sundanese },- { 888, PT_SC, ucp_Syloti_Nagri },- { 901, PT_SC, ucp_Syriac },- { 908, PT_SC, ucp_Tagalog },- { 916, PT_SC, ucp_Tagbanwa },- { 925, PT_SC, ucp_Tai_Le },- { 932, PT_SC, ucp_Tai_Tham },- { 941, PT_SC, ucp_Tai_Viet },- { 950, PT_SC, ucp_Takri },- { 956, PT_SC, ucp_Tamil },- { 962, PT_SC, ucp_Telugu },- { 969, PT_SC, ucp_Thaana },- { 976, PT_SC, ucp_Thai },- { 981, PT_SC, ucp_Tibetan },- { 989, PT_SC, ucp_Tifinagh },- { 998, PT_SC, ucp_Ugaritic },- { 1007, PT_SC, ucp_Vai },- { 1011, PT_ALNUM, 0 },- { 1015, PT_PXSPACE, 0 },- { 1019, PT_SPACE, 0 },- { 1023, PT_UCNC, 0 },- { 1027, PT_WORD, 0 },- { 1031, PT_SC, ucp_Yi },- { 1034, PT_GC, ucp_Z },- { 1036, PT_PC, ucp_Zl },- { 1039, PT_PC, ucp_Zp },- { 1042, PT_PC, ucp_Zs }+ { 43, PT_SC, ucp_Bassa_Vah },+ { 53, PT_SC, ucp_Batak },+ { 59, PT_SC, ucp_Bengali },+ { 67, PT_SC, ucp_Bopomofo },+ { 76, PT_SC, ucp_Brahmi },+ { 83, PT_SC, ucp_Braille },+ { 91, PT_SC, ucp_Buginese },+ { 100, PT_SC, ucp_Buhid },+ { 106, PT_GC, ucp_C },+ { 108, PT_SC, ucp_Canadian_Aboriginal },+ { 128, PT_SC, ucp_Carian },+ { 135, PT_SC, ucp_Caucasian_Albanian },+ { 154, PT_PC, ucp_Cc },+ { 157, PT_PC, ucp_Cf },+ { 160, PT_SC, ucp_Chakma },+ { 167, PT_SC, ucp_Cham },+ { 172, PT_SC, ucp_Cherokee },+ { 181, PT_PC, ucp_Cn },+ { 184, PT_PC, ucp_Co },+ { 187, PT_SC, ucp_Common },+ { 194, PT_SC, ucp_Coptic },+ { 201, PT_PC, ucp_Cs },+ { 204, PT_SC, ucp_Cuneiform },+ { 214, PT_SC, ucp_Cypriot },+ { 222, PT_SC, ucp_Cyrillic },+ { 231, PT_SC, ucp_Deseret },+ { 239, PT_SC, ucp_Devanagari },+ { 250, PT_SC, ucp_Duployan },+ { 259, PT_SC, ucp_Egyptian_Hieroglyphs },+ { 280, PT_SC, ucp_Elbasan },+ { 288, PT_SC, ucp_Ethiopic },+ { 297, PT_SC, ucp_Georgian },+ { 306, PT_SC, ucp_Glagolitic },+ { 317, PT_SC, ucp_Gothic },+ { 324, PT_SC, ucp_Grantha },+ { 332, PT_SC, ucp_Greek },+ { 338, PT_SC, ucp_Gujarati },+ { 347, PT_SC, ucp_Gurmukhi },+ { 356, PT_SC, ucp_Han },+ { 360, PT_SC, ucp_Hangul },+ { 367, PT_SC, ucp_Hanunoo },+ { 375, PT_SC, ucp_Hebrew },+ { 382, PT_SC, ucp_Hiragana },+ { 391, PT_SC, ucp_Imperial_Aramaic },+ { 408, PT_SC, ucp_Inherited },+ { 418, PT_SC, ucp_Inscriptional_Pahlavi },+ { 440, PT_SC, ucp_Inscriptional_Parthian },+ { 463, PT_SC, ucp_Javanese },+ { 472, PT_SC, ucp_Kaithi },+ { 479, PT_SC, ucp_Kannada },+ { 487, PT_SC, ucp_Katakana },+ { 496, PT_SC, ucp_Kayah_Li },+ { 505, PT_SC, ucp_Kharoshthi },+ { 516, PT_SC, ucp_Khmer },+ { 522, PT_SC, ucp_Khojki },+ { 529, PT_SC, ucp_Khudawadi },+ { 539, PT_GC, ucp_L },+ { 541, PT_LAMP, 0 },+ { 544, PT_SC, ucp_Lao },+ { 548, PT_SC, ucp_Latin },+ { 554, PT_SC, ucp_Lepcha },+ { 561, PT_SC, ucp_Limbu },+ { 567, PT_SC, ucp_Linear_A },+ { 576, PT_SC, ucp_Linear_B },+ { 585, PT_SC, ucp_Lisu },+ { 590, PT_PC, ucp_Ll },+ { 593, PT_PC, ucp_Lm },+ { 596, PT_PC, ucp_Lo },+ { 599, PT_PC, ucp_Lt },+ { 602, PT_PC, ucp_Lu },+ { 605, PT_SC, ucp_Lycian },+ { 612, PT_SC, ucp_Lydian },+ { 619, PT_GC, ucp_M },+ { 621, PT_SC, ucp_Mahajani },+ { 630, PT_SC, ucp_Malayalam },+ { 640, PT_SC, ucp_Mandaic },+ { 648, PT_SC, ucp_Manichaean },+ { 659, PT_PC, ucp_Mc },+ { 662, PT_PC, ucp_Me },+ { 665, PT_SC, ucp_Meetei_Mayek },+ { 678, PT_SC, ucp_Mende_Kikakui },+ { 692, PT_SC, ucp_Meroitic_Cursive },+ { 709, PT_SC, ucp_Meroitic_Hieroglyphs },+ { 730, PT_SC, ucp_Miao },+ { 735, PT_PC, ucp_Mn },+ { 738, PT_SC, ucp_Modi },+ { 743, PT_SC, ucp_Mongolian },+ { 753, PT_SC, ucp_Mro },+ { 757, PT_SC, ucp_Myanmar },+ { 765, PT_GC, ucp_N },+ { 767, PT_SC, ucp_Nabataean },+ { 777, PT_PC, ucp_Nd },+ { 780, PT_SC, ucp_New_Tai_Lue },+ { 792, PT_SC, ucp_Nko },+ { 796, PT_PC, ucp_Nl },+ { 799, PT_PC, ucp_No },+ { 802, PT_SC, ucp_Ogham },+ { 808, PT_SC, ucp_Ol_Chiki },+ { 817, PT_SC, ucp_Old_Italic },+ { 828, PT_SC, ucp_Old_North_Arabian },+ { 846, PT_SC, ucp_Old_Permic },+ { 857, PT_SC, ucp_Old_Persian },+ { 869, PT_SC, ucp_Old_South_Arabian },+ { 887, PT_SC, ucp_Old_Turkic },+ { 898, PT_SC, ucp_Oriya },+ { 904, PT_SC, ucp_Osmanya },+ { 912, PT_GC, ucp_P },+ { 914, PT_SC, ucp_Pahawh_Hmong },+ { 927, PT_SC, ucp_Palmyrene },+ { 937, PT_SC, ucp_Pau_Cin_Hau },+ { 949, PT_PC, ucp_Pc },+ { 952, PT_PC, ucp_Pd },+ { 955, PT_PC, ucp_Pe },+ { 958, PT_PC, ucp_Pf },+ { 961, PT_SC, ucp_Phags_Pa },+ { 970, PT_SC, ucp_Phoenician },+ { 981, PT_PC, ucp_Pi },+ { 984, PT_PC, ucp_Po },+ { 987, PT_PC, ucp_Ps },+ { 990, PT_SC, ucp_Psalter_Pahlavi },+ { 1006, PT_SC, ucp_Rejang },+ { 1013, PT_SC, ucp_Runic },+ { 1019, PT_GC, ucp_S },+ { 1021, PT_SC, ucp_Samaritan },+ { 1031, PT_SC, ucp_Saurashtra },+ { 1042, PT_PC, ucp_Sc },+ { 1045, PT_SC, ucp_Sharada },+ { 1053, PT_SC, ucp_Shavian },+ { 1061, PT_SC, ucp_Siddham },+ { 1069, PT_SC, ucp_Sinhala },+ { 1077, PT_PC, ucp_Sk },+ { 1080, PT_PC, ucp_Sm },+ { 1083, PT_PC, ucp_So },+ { 1086, PT_SC, ucp_Sora_Sompeng },+ { 1099, PT_SC, ucp_Sundanese },+ { 1109, PT_SC, ucp_Syloti_Nagri },+ { 1122, PT_SC, ucp_Syriac },+ { 1129, PT_SC, ucp_Tagalog },+ { 1137, PT_SC, ucp_Tagbanwa },+ { 1146, PT_SC, ucp_Tai_Le },+ { 1153, PT_SC, ucp_Tai_Tham },+ { 1162, PT_SC, ucp_Tai_Viet },+ { 1171, PT_SC, ucp_Takri },+ { 1177, PT_SC, ucp_Tamil },+ { 1183, PT_SC, ucp_Telugu },+ { 1190, PT_SC, ucp_Thaana },+ { 1197, PT_SC, ucp_Thai },+ { 1202, PT_SC, ucp_Tibetan },+ { 1210, PT_SC, ucp_Tifinagh },+ { 1219, PT_SC, ucp_Tirhuta },+ { 1227, PT_SC, ucp_Ugaritic },+ { 1236, PT_SC, ucp_Vai },+ { 1240, PT_SC, ucp_Warang_Citi },+ { 1252, PT_ALNUM, 0 },+ { 1256, PT_PXSPACE, 0 },+ { 1260, PT_SPACE, 0 },+ { 1264, PT_UCNC, 0 },+ { 1268, PT_WORD, 0 },+ { 1272, PT_SC, ucp_Yi },+ { 1275, PT_GC, ucp_Z },+ { 1277, PT_PC, ucp_Zl },+ { 1280, PT_PC, ucp_Zp },+ { 1283, PT_PC, ucp_Zs } }; const int PRIV(utt_size) = sizeof(PRIV(utt)) / sizeof(ucp_type_table);
pcre/pcre_ucd.c view
@@ -20,3272 +20,3619 @@ /* Unicode character database. */ /* This file was autogenerated by the MultiStage2.py script. */-/* Total size: 65688 bytes, block size: 128. */--/* The tables herein are needed only when UCP support is built-into PCRE. This module should not be referenced otherwise, so-it should not matter whether it is compiled or not. However-a comment was received about space saving - maybe the guy linked-all the modules rather than using a library - so we include a-condition to cut out the tables when not needed. But don't leave-a totally empty module because some compilers barf at that.-Instead, just supply small dummy tables. */--#ifndef SUPPORT_UCP-const ucd_record PRIV(ucd_records)[] = {{0,0,0,0,0 }};-const pcre_uint8 PRIV(ucd_stage1)[] = {0};-const pcre_uint16 PRIV(ucd_stage2)[] = {0};-const pcre_uint32 PRIV(ucd_caseless_sets)[] = {0};-#else--/* When recompiling tables with a new Unicode version, please check the-types in this structure definition from pcre_internal.h (the actual-field names will be different):--typedef struct {-pcre_uint8 property_0;-pcre_uint8 property_1;-pcre_uint8 property_2;-pcre_uint8 property_3;-pcre_int32 property_4;-} ucd_record;-*/---const pcre_uint32 PRIV(ucd_caseless_sets)[] = {- NOTACHAR,- 0x0053, 0x0073, 0x017f, NOTACHAR,- 0x01c4, 0x01c5, 0x01c6, NOTACHAR,- 0x01c7, 0x01c8, 0x01c9, NOTACHAR,- 0x01ca, 0x01cb, 0x01cc, NOTACHAR,- 0x01f1, 0x01f2, 0x01f3, NOTACHAR,- 0x0345, 0x0399, 0x03b9, 0x1fbe, NOTACHAR,- 0x00b5, 0x039c, 0x03bc, NOTACHAR,- 0x03a3, 0x03c2, 0x03c3, NOTACHAR,- 0x0392, 0x03b2, 0x03d0, NOTACHAR,- 0x0398, 0x03b8, 0x03d1, 0x03f4, NOTACHAR,- 0x03a6, 0x03c6, 0x03d5, NOTACHAR,- 0x03a0, 0x03c0, 0x03d6, NOTACHAR,- 0x039a, 0x03ba, 0x03f0, NOTACHAR,- 0x03a1, 0x03c1, 0x03f1, NOTACHAR,- 0x0395, 0x03b5, 0x03f5, NOTACHAR,- 0x1e60, 0x1e61, 0x1e9b, NOTACHAR,- 0x03a9, 0x03c9, 0x2126, NOTACHAR,- 0x004b, 0x006b, 0x212a, NOTACHAR,- 0x00c5, 0x00e5, 0x212b, NOTACHAR,-};--/* When #included in pcretest, we don't need this large table. */--#ifndef PCRE_INCLUDED--const ucd_record PRIV(ucd_records)[] = { /* 5016 bytes, record size 8 */- { 9, 0, 2, 0, 0, }, /* 0 */- { 9, 0, 1, 0, 0, }, /* 1 */- { 9, 0, 0, 0, 0, }, /* 2 */- { 9, 29, 12, 0, 0, }, /* 3 */- { 9, 21, 12, 0, 0, }, /* 4 */- { 9, 23, 12, 0, 0, }, /* 5 */- { 9, 22, 12, 0, 0, }, /* 6 */- { 9, 18, 12, 0, 0, }, /* 7 */- { 9, 25, 12, 0, 0, }, /* 8 */- { 9, 17, 12, 0, 0, }, /* 9 */- { 9, 13, 12, 0, 0, }, /* 10 */- { 33, 9, 12, 0, 32, }, /* 11 */- { 33, 9, 12, 71, 32, }, /* 12 */- { 33, 9, 12, 1, 32, }, /* 13 */- { 9, 24, 12, 0, 0, }, /* 14 */- { 9, 16, 12, 0, 0, }, /* 15 */- { 33, 5, 12, 0, -32, }, /* 16 */- { 33, 5, 12, 71, -32, }, /* 17 */- { 33, 5, 12, 1, -32, }, /* 18 */- { 9, 26, 12, 0, 0, }, /* 19 */- { 33, 7, 12, 0, 0, }, /* 20 */- { 9, 20, 12, 0, 0, }, /* 21 */- { 9, 1, 2, 0, 0, }, /* 22 */- { 9, 15, 12, 0, 0, }, /* 23 */- { 9, 5, 12, 26, 775, }, /* 24 */- { 9, 19, 12, 0, 0, }, /* 25 */- { 33, 9, 12, 75, 32, }, /* 26 */- { 33, 5, 12, 0, 7615, }, /* 27 */- { 33, 5, 12, 75, -32, }, /* 28 */- { 33, 5, 12, 0, 121, }, /* 29 */- { 33, 9, 12, 0, 1, }, /* 30 */- { 33, 5, 12, 0, -1, }, /* 31 */- { 33, 9, 12, 0, 0, }, /* 32 */- { 33, 5, 12, 0, 0, }, /* 33 */- { 33, 9, 12, 0, -121, }, /* 34 */- { 33, 5, 12, 1, -268, }, /* 35 */- { 33, 5, 12, 0, 195, }, /* 36 */- { 33, 9, 12, 0, 210, }, /* 37 */- { 33, 9, 12, 0, 206, }, /* 38 */- { 33, 9, 12, 0, 205, }, /* 39 */- { 33, 9, 12, 0, 79, }, /* 40 */- { 33, 9, 12, 0, 202, }, /* 41 */- { 33, 9, 12, 0, 203, }, /* 42 */- { 33, 9, 12, 0, 207, }, /* 43 */- { 33, 5, 12, 0, 97, }, /* 44 */- { 33, 9, 12, 0, 211, }, /* 45 */- { 33, 9, 12, 0, 209, }, /* 46 */- { 33, 5, 12, 0, 163, }, /* 47 */- { 33, 9, 12, 0, 213, }, /* 48 */- { 33, 5, 12, 0, 130, }, /* 49 */- { 33, 9, 12, 0, 214, }, /* 50 */- { 33, 9, 12, 0, 218, }, /* 51 */- { 33, 9, 12, 0, 217, }, /* 52 */- { 33, 9, 12, 0, 219, }, /* 53 */- { 33, 5, 12, 0, 56, }, /* 54 */- { 33, 9, 12, 5, 2, }, /* 55 */- { 33, 8, 12, 5, 1, }, /* 56 */- { 33, 5, 12, 5, -2, }, /* 57 */- { 33, 9, 12, 9, 2, }, /* 58 */- { 33, 8, 12, 9, 1, }, /* 59 */- { 33, 5, 12, 9, -2, }, /* 60 */- { 33, 9, 12, 13, 2, }, /* 61 */- { 33, 8, 12, 13, 1, }, /* 62 */- { 33, 5, 12, 13, -2, }, /* 63 */- { 33, 5, 12, 0, -79, }, /* 64 */- { 33, 9, 12, 17, 2, }, /* 65 */- { 33, 8, 12, 17, 1, }, /* 66 */- { 33, 5, 12, 17, -2, }, /* 67 */- { 33, 9, 12, 0, -97, }, /* 68 */- { 33, 9, 12, 0, -56, }, /* 69 */- { 33, 9, 12, 0, -130, }, /* 70 */- { 33, 9, 12, 0, 10795, }, /* 71 */- { 33, 9, 12, 0, -163, }, /* 72 */- { 33, 9, 12, 0, 10792, }, /* 73 */- { 33, 5, 12, 0, 10815, }, /* 74 */- { 33, 9, 12, 0, -195, }, /* 75 */- { 33, 9, 12, 0, 69, }, /* 76 */- { 33, 9, 12, 0, 71, }, /* 77 */- { 33, 5, 12, 0, 10783, }, /* 78 */- { 33, 5, 12, 0, 10780, }, /* 79 */- { 33, 5, 12, 0, 10782, }, /* 80 */- { 33, 5, 12, 0, -210, }, /* 81 */- { 33, 5, 12, 0, -206, }, /* 82 */- { 33, 5, 12, 0, -205, }, /* 83 */- { 33, 5, 12, 0, -202, }, /* 84 */- { 33, 5, 12, 0, -203, }, /* 85 */- { 33, 5, 12, 0, -207, }, /* 86 */- { 33, 5, 12, 0, 42280, }, /* 87 */- { 33, 5, 12, 0, 42308, }, /* 88 */- { 33, 5, 12, 0, -209, }, /* 89 */- { 33, 5, 12, 0, -211, }, /* 90 */- { 33, 5, 12, 0, 10743, }, /* 91 */- { 33, 5, 12, 0, 10749, }, /* 92 */- { 33, 5, 12, 0, -213, }, /* 93 */- { 33, 5, 12, 0, -214, }, /* 94 */- { 33, 5, 12, 0, 10727, }, /* 95 */- { 33, 5, 12, 0, -218, }, /* 96 */- { 33, 5, 12, 0, -69, }, /* 97 */- { 33, 5, 12, 0, -217, }, /* 98 */- { 33, 5, 12, 0, -71, }, /* 99 */- { 33, 5, 12, 0, -219, }, /* 100 */- { 33, 6, 12, 0, 0, }, /* 101 */- { 9, 6, 12, 0, 0, }, /* 102 */- { 3, 24, 12, 0, 0, }, /* 103 */- { 27, 12, 3, 0, 0, }, /* 104 */- { 27, 12, 3, 21, 116, }, /* 105 */- { 19, 9, 12, 0, 1, }, /* 106 */- { 19, 5, 12, 0, -1, }, /* 107 */- { 19, 24, 12, 0, 0, }, /* 108 */- { 9, 2, 12, 0, 0, }, /* 109 */- { 19, 6, 12, 0, 0, }, /* 110 */- { 19, 5, 12, 0, 130, }, /* 111 */- { 19, 9, 12, 0, 38, }, /* 112 */- { 19, 9, 12, 0, 37, }, /* 113 */- { 19, 9, 12, 0, 64, }, /* 114 */- { 19, 9, 12, 0, 63, }, /* 115 */- { 19, 5, 12, 0, 0, }, /* 116 */- { 19, 9, 12, 0, 32, }, /* 117 */- { 19, 9, 12, 34, 32, }, /* 118 */- { 19, 9, 12, 59, 32, }, /* 119 */- { 19, 9, 12, 38, 32, }, /* 120 */- { 19, 9, 12, 21, 32, }, /* 121 */- { 19, 9, 12, 51, 32, }, /* 122 */- { 19, 9, 12, 26, 32, }, /* 123 */- { 19, 9, 12, 47, 32, }, /* 124 */- { 19, 9, 12, 55, 32, }, /* 125 */- { 19, 9, 12, 30, 32, }, /* 126 */- { 19, 9, 12, 43, 32, }, /* 127 */- { 19, 9, 12, 67, 32, }, /* 128 */- { 19, 5, 12, 0, -38, }, /* 129 */- { 19, 5, 12, 0, -37, }, /* 130 */- { 19, 5, 12, 0, -32, }, /* 131 */- { 19, 5, 12, 34, -32, }, /* 132 */- { 19, 5, 12, 59, -32, }, /* 133 */- { 19, 5, 12, 38, -32, }, /* 134 */- { 19, 5, 12, 21, -116, }, /* 135 */- { 19, 5, 12, 51, -32, }, /* 136 */- { 19, 5, 12, 26, -775, }, /* 137 */- { 19, 5, 12, 47, -32, }, /* 138 */- { 19, 5, 12, 55, -32, }, /* 139 */- { 19, 5, 12, 30, 1, }, /* 140 */- { 19, 5, 12, 30, -32, }, /* 141 */- { 19, 5, 12, 43, -32, }, /* 142 */- { 19, 5, 12, 67, -32, }, /* 143 */- { 19, 5, 12, 0, -64, }, /* 144 */- { 19, 5, 12, 0, -63, }, /* 145 */- { 19, 9, 12, 0, 8, }, /* 146 */- { 19, 5, 12, 34, -30, }, /* 147 */- { 19, 5, 12, 38, -25, }, /* 148 */- { 19, 9, 12, 0, 0, }, /* 149 */- { 19, 5, 12, 43, -15, }, /* 150 */- { 19, 5, 12, 47, -22, }, /* 151 */- { 19, 5, 12, 0, -8, }, /* 152 */- { 10, 9, 12, 0, 1, }, /* 153 */- { 10, 5, 12, 0, -1, }, /* 154 */- { 19, 5, 12, 51, -54, }, /* 155 */- { 19, 5, 12, 55, -48, }, /* 156 */- { 19, 5, 12, 0, 7, }, /* 157 */- { 19, 9, 12, 38, -60, }, /* 158 */- { 19, 5, 12, 59, -64, }, /* 159 */- { 19, 25, 12, 0, 0, }, /* 160 */- { 19, 9, 12, 0, -7, }, /* 161 */- { 19, 9, 12, 0, -130, }, /* 162 */- { 12, 9, 12, 0, 80, }, /* 163 */- { 12, 9, 12, 0, 32, }, /* 164 */- { 12, 5, 12, 0, -32, }, /* 165 */- { 12, 5, 12, 0, -80, }, /* 166 */- { 12, 9, 12, 0, 1, }, /* 167 */- { 12, 5, 12, 0, -1, }, /* 168 */- { 12, 26, 12, 0, 0, }, /* 169 */- { 12, 12, 3, 0, 0, }, /* 170 */- { 12, 11, 3, 0, 0, }, /* 171 */- { 12, 9, 12, 0, 15, }, /* 172 */- { 12, 5, 12, 0, -15, }, /* 173 */- { 1, 9, 12, 0, 48, }, /* 174 */- { 1, 6, 12, 0, 0, }, /* 175 */- { 1, 21, 12, 0, 0, }, /* 176 */- { 1, 5, 12, 0, -48, }, /* 177 */- { 1, 5, 12, 0, 0, }, /* 178 */- { 1, 17, 12, 0, 0, }, /* 179 */- { 1, 23, 12, 0, 0, }, /* 180 */- { 25, 12, 3, 0, 0, }, /* 181 */- { 25, 17, 12, 0, 0, }, /* 182 */- { 25, 21, 12, 0, 0, }, /* 183 */- { 25, 7, 12, 0, 0, }, /* 184 */- { 0, 1, 2, 0, 0, }, /* 185 */- { 0, 25, 12, 0, 0, }, /* 186 */- { 0, 21, 12, 0, 0, }, /* 187 */- { 0, 23, 12, 0, 0, }, /* 188 */- { 0, 26, 12, 0, 0, }, /* 189 */- { 0, 12, 3, 0, 0, }, /* 190 */- { 0, 7, 12, 0, 0, }, /* 191 */- { 0, 6, 12, 0, 0, }, /* 192 */- { 0, 13, 12, 0, 0, }, /* 193 */- { 49, 21, 12, 0, 0, }, /* 194 */- { 49, 1, 2, 0, 0, }, /* 195 */- { 49, 7, 12, 0, 0, }, /* 196 */- { 49, 12, 3, 0, 0, }, /* 197 */- { 55, 7, 12, 0, 0, }, /* 198 */- { 55, 12, 3, 0, 0, }, /* 199 */- { 63, 13, 12, 0, 0, }, /* 200 */- { 63, 7, 12, 0, 0, }, /* 201 */- { 63, 12, 3, 0, 0, }, /* 202 */- { 63, 6, 12, 0, 0, }, /* 203 */- { 63, 26, 12, 0, 0, }, /* 204 */- { 63, 21, 12, 0, 0, }, /* 205 */- { 89, 7, 12, 0, 0, }, /* 206 */- { 89, 12, 3, 0, 0, }, /* 207 */- { 89, 6, 12, 0, 0, }, /* 208 */- { 89, 21, 12, 0, 0, }, /* 209 */- { 94, 7, 12, 0, 0, }, /* 210 */- { 94, 12, 3, 0, 0, }, /* 211 */- { 94, 21, 12, 0, 0, }, /* 212 */- { 14, 12, 3, 0, 0, }, /* 213 */- { 14, 10, 5, 0, 0, }, /* 214 */- { 14, 7, 12, 0, 0, }, /* 215 */- { 14, 13, 12, 0, 0, }, /* 216 */- { 14, 21, 12, 0, 0, }, /* 217 */- { 14, 6, 12, 0, 0, }, /* 218 */- { 2, 12, 3, 0, 0, }, /* 219 */- { 2, 10, 5, 0, 0, }, /* 220 */- { 2, 7, 12, 0, 0, }, /* 221 */- { 2, 10, 3, 0, 0, }, /* 222 */- { 2, 13, 12, 0, 0, }, /* 223 */- { 2, 23, 12, 0, 0, }, /* 224 */- { 2, 15, 12, 0, 0, }, /* 225 */- { 2, 26, 12, 0, 0, }, /* 226 */- { 21, 12, 3, 0, 0, }, /* 227 */- { 21, 10, 5, 0, 0, }, /* 228 */- { 21, 7, 12, 0, 0, }, /* 229 */- { 21, 13, 12, 0, 0, }, /* 230 */- { 20, 12, 3, 0, 0, }, /* 231 */- { 20, 10, 5, 0, 0, }, /* 232 */- { 20, 7, 12, 0, 0, }, /* 233 */- { 20, 13, 12, 0, 0, }, /* 234 */- { 20, 21, 12, 0, 0, }, /* 235 */- { 20, 23, 12, 0, 0, }, /* 236 */- { 43, 12, 3, 0, 0, }, /* 237 */- { 43, 10, 5, 0, 0, }, /* 238 */- { 43, 7, 12, 0, 0, }, /* 239 */- { 43, 10, 3, 0, 0, }, /* 240 */- { 43, 13, 12, 0, 0, }, /* 241 */- { 43, 26, 12, 0, 0, }, /* 242 */- { 43, 15, 12, 0, 0, }, /* 243 */- { 53, 12, 3, 0, 0, }, /* 244 */- { 53, 7, 12, 0, 0, }, /* 245 */- { 53, 10, 3, 0, 0, }, /* 246 */- { 53, 10, 5, 0, 0, }, /* 247 */- { 53, 13, 12, 0, 0, }, /* 248 */- { 53, 15, 12, 0, 0, }, /* 249 */- { 53, 26, 12, 0, 0, }, /* 250 */- { 53, 23, 12, 0, 0, }, /* 251 */- { 54, 10, 5, 0, 0, }, /* 252 */- { 54, 7, 12, 0, 0, }, /* 253 */- { 54, 12, 3, 0, 0, }, /* 254 */- { 54, 13, 12, 0, 0, }, /* 255 */- { 54, 15, 12, 0, 0, }, /* 256 */- { 54, 26, 12, 0, 0, }, /* 257 */- { 28, 10, 5, 0, 0, }, /* 258 */- { 28, 7, 12, 0, 0, }, /* 259 */- { 28, 12, 3, 0, 0, }, /* 260 */- { 28, 10, 3, 0, 0, }, /* 261 */- { 28, 13, 12, 0, 0, }, /* 262 */- { 36, 10, 5, 0, 0, }, /* 263 */- { 36, 7, 12, 0, 0, }, /* 264 */- { 36, 10, 3, 0, 0, }, /* 265 */- { 36, 12, 3, 0, 0, }, /* 266 */- { 36, 13, 12, 0, 0, }, /* 267 */- { 36, 15, 12, 0, 0, }, /* 268 */- { 36, 26, 12, 0, 0, }, /* 269 */- { 47, 10, 5, 0, 0, }, /* 270 */- { 47, 7, 12, 0, 0, }, /* 271 */- { 47, 12, 3, 0, 0, }, /* 272 */- { 47, 10, 3, 0, 0, }, /* 273 */- { 47, 21, 12, 0, 0, }, /* 274 */- { 56, 7, 12, 0, 0, }, /* 275 */- { 56, 12, 3, 0, 0, }, /* 276 */- { 56, 7, 5, 0, 0, }, /* 277 */- { 56, 6, 12, 0, 0, }, /* 278 */- { 56, 21, 12, 0, 0, }, /* 279 */- { 56, 13, 12, 0, 0, }, /* 280 */- { 32, 7, 12, 0, 0, }, /* 281 */- { 32, 12, 3, 0, 0, }, /* 282 */- { 32, 7, 5, 0, 0, }, /* 283 */- { 32, 6, 12, 0, 0, }, /* 284 */- { 32, 13, 12, 0, 0, }, /* 285 */- { 57, 7, 12, 0, 0, }, /* 286 */- { 57, 26, 12, 0, 0, }, /* 287 */- { 57, 21, 12, 0, 0, }, /* 288 */- { 57, 12, 3, 0, 0, }, /* 289 */- { 57, 13, 12, 0, 0, }, /* 290 */- { 57, 15, 12, 0, 0, }, /* 291 */- { 57, 22, 12, 0, 0, }, /* 292 */- { 57, 18, 12, 0, 0, }, /* 293 */- { 57, 10, 5, 0, 0, }, /* 294 */- { 38, 7, 12, 0, 0, }, /* 295 */- { 38, 10, 12, 0, 0, }, /* 296 */- { 38, 12, 3, 0, 0, }, /* 297 */- { 38, 10, 5, 0, 0, }, /* 298 */- { 38, 13, 12, 0, 0, }, /* 299 */- { 38, 21, 12, 0, 0, }, /* 300 */- { 38, 26, 12, 0, 0, }, /* 301 */- { 16, 9, 12, 0, 7264, }, /* 302 */- { 16, 7, 12, 0, 0, }, /* 303 */- { 16, 6, 12, 0, 0, }, /* 304 */- { 23, 7, 6, 0, 0, }, /* 305 */- { 23, 7, 7, 0, 0, }, /* 306 */- { 23, 7, 8, 0, 0, }, /* 307 */- { 15, 7, 12, 0, 0, }, /* 308 */- { 15, 12, 3, 0, 0, }, /* 309 */- { 15, 21, 12, 0, 0, }, /* 310 */- { 15, 15, 12, 0, 0, }, /* 311 */- { 15, 26, 12, 0, 0, }, /* 312 */- { 8, 7, 12, 0, 0, }, /* 313 */- { 7, 17, 12, 0, 0, }, /* 314 */- { 7, 7, 12, 0, 0, }, /* 315 */- { 7, 21, 12, 0, 0, }, /* 316 */- { 40, 29, 12, 0, 0, }, /* 317 */- { 40, 7, 12, 0, 0, }, /* 318 */- { 40, 22, 12, 0, 0, }, /* 319 */- { 40, 18, 12, 0, 0, }, /* 320 */- { 45, 7, 12, 0, 0, }, /* 321 */- { 45, 14, 12, 0, 0, }, /* 322 */- { 50, 7, 12, 0, 0, }, /* 323 */- { 50, 12, 3, 0, 0, }, /* 324 */- { 24, 7, 12, 0, 0, }, /* 325 */- { 24, 12, 3, 0, 0, }, /* 326 */- { 6, 7, 12, 0, 0, }, /* 327 */- { 6, 12, 3, 0, 0, }, /* 328 */- { 51, 7, 12, 0, 0, }, /* 329 */- { 51, 12, 3, 0, 0, }, /* 330 */- { 31, 7, 12, 0, 0, }, /* 331 */- { 31, 12, 3, 0, 0, }, /* 332 */- { 31, 10, 5, 0, 0, }, /* 333 */- { 31, 21, 12, 0, 0, }, /* 334 */- { 31, 6, 12, 0, 0, }, /* 335 */- { 31, 23, 12, 0, 0, }, /* 336 */- { 31, 13, 12, 0, 0, }, /* 337 */- { 31, 15, 12, 0, 0, }, /* 338 */- { 37, 21, 12, 0, 0, }, /* 339 */- { 37, 17, 12, 0, 0, }, /* 340 */- { 37, 12, 3, 0, 0, }, /* 341 */- { 37, 1, 2, 0, 0, }, /* 342 */- { 37, 13, 12, 0, 0, }, /* 343 */- { 37, 7, 12, 0, 0, }, /* 344 */- { 37, 6, 12, 0, 0, }, /* 345 */- { 34, 7, 12, 0, 0, }, /* 346 */- { 34, 12, 3, 0, 0, }, /* 347 */- { 34, 10, 5, 0, 0, }, /* 348 */- { 34, 26, 12, 0, 0, }, /* 349 */- { 34, 21, 12, 0, 0, }, /* 350 */- { 34, 13, 12, 0, 0, }, /* 351 */- { 52, 7, 12, 0, 0, }, /* 352 */- { 39, 7, 12, 0, 0, }, /* 353 */- { 39, 10, 12, 0, 0, }, /* 354 */- { 39, 10, 5, 0, 0, }, /* 355 */- { 39, 13, 12, 0, 0, }, /* 356 */- { 39, 15, 12, 0, 0, }, /* 357 */- { 39, 26, 12, 0, 0, }, /* 358 */- { 31, 26, 12, 0, 0, }, /* 359 */- { 5, 7, 12, 0, 0, }, /* 360 */- { 5, 12, 3, 0, 0, }, /* 361 */- { 5, 10, 5, 0, 0, }, /* 362 */- { 5, 21, 12, 0, 0, }, /* 363 */- { 90, 7, 12, 0, 0, }, /* 364 */- { 90, 10, 5, 0, 0, }, /* 365 */- { 90, 12, 3, 0, 0, }, /* 366 */- { 90, 10, 12, 0, 0, }, /* 367 */- { 90, 13, 12, 0, 0, }, /* 368 */- { 90, 21, 12, 0, 0, }, /* 369 */- { 90, 6, 12, 0, 0, }, /* 370 */- { 61, 12, 3, 0, 0, }, /* 371 */- { 61, 10, 5, 0, 0, }, /* 372 */- { 61, 7, 12, 0, 0, }, /* 373 */- { 61, 13, 12, 0, 0, }, /* 374 */- { 61, 21, 12, 0, 0, }, /* 375 */- { 61, 26, 12, 0, 0, }, /* 376 */- { 75, 12, 3, 0, 0, }, /* 377 */- { 75, 10, 5, 0, 0, }, /* 378 */- { 75, 7, 12, 0, 0, }, /* 379 */- { 75, 13, 12, 0, 0, }, /* 380 */- { 92, 7, 12, 0, 0, }, /* 381 */- { 92, 12, 3, 0, 0, }, /* 382 */- { 92, 10, 5, 0, 0, }, /* 383 */- { 92, 21, 12, 0, 0, }, /* 384 */- { 69, 7, 12, 0, 0, }, /* 385 */- { 69, 10, 5, 0, 0, }, /* 386 */- { 69, 12, 3, 0, 0, }, /* 387 */- { 69, 21, 12, 0, 0, }, /* 388 */- { 69, 13, 12, 0, 0, }, /* 389 */- { 72, 13, 12, 0, 0, }, /* 390 */- { 72, 7, 12, 0, 0, }, /* 391 */- { 72, 6, 12, 0, 0, }, /* 392 */- { 72, 21, 12, 0, 0, }, /* 393 */- { 75, 21, 12, 0, 0, }, /* 394 */- { 9, 10, 5, 0, 0, }, /* 395 */- { 9, 7, 12, 0, 0, }, /* 396 */- { 12, 5, 12, 0, 0, }, /* 397 */- { 12, 6, 12, 0, 0, }, /* 398 */- { 33, 5, 12, 0, 35332, }, /* 399 */- { 33, 5, 12, 0, 3814, }, /* 400 */- { 33, 9, 12, 63, 1, }, /* 401 */- { 33, 5, 12, 63, -1, }, /* 402 */- { 33, 5, 12, 63, -58, }, /* 403 */- { 33, 9, 12, 0, -7615, }, /* 404 */- { 19, 5, 12, 0, 8, }, /* 405 */- { 19, 9, 12, 0, -8, }, /* 406 */- { 19, 5, 12, 0, 74, }, /* 407 */- { 19, 5, 12, 0, 86, }, /* 408 */- { 19, 5, 12, 0, 100, }, /* 409 */- { 19, 5, 12, 0, 128, }, /* 410 */- { 19, 5, 12, 0, 112, }, /* 411 */- { 19, 5, 12, 0, 126, }, /* 412 */- { 19, 8, 12, 0, -8, }, /* 413 */- { 19, 5, 12, 0, 9, }, /* 414 */- { 19, 9, 12, 0, -74, }, /* 415 */- { 19, 8, 12, 0, -9, }, /* 416 */- { 19, 5, 12, 21, -7173, }, /* 417 */- { 19, 9, 12, 0, -86, }, /* 418 */- { 19, 9, 12, 0, -100, }, /* 419 */- { 19, 9, 12, 0, -112, }, /* 420 */- { 19, 9, 12, 0, -128, }, /* 421 */- { 19, 9, 12, 0, -126, }, /* 422 */- { 27, 1, 3, 0, 0, }, /* 423 */- { 9, 27, 2, 0, 0, }, /* 424 */- { 9, 28, 2, 0, 0, }, /* 425 */- { 9, 2, 2, 0, 0, }, /* 426 */- { 27, 11, 3, 0, 0, }, /* 427 */- { 9, 9, 12, 0, 0, }, /* 428 */- { 9, 5, 12, 0, 0, }, /* 429 */- { 19, 9, 12, 67, -7517, }, /* 430 */- { 33, 9, 12, 71, -8383, }, /* 431 */- { 33, 9, 12, 75, -8262, }, /* 432 */- { 33, 9, 12, 0, 28, }, /* 433 */- { 33, 5, 12, 0, -28, }, /* 434 */- { 33, 14, 12, 0, 16, }, /* 435 */- { 33, 14, 12, 0, -16, }, /* 436 */- { 33, 14, 12, 0, 0, }, /* 437 */- { 9, 26, 12, 0, 26, }, /* 438 */- { 9, 26, 12, 0, -26, }, /* 439 */- { 4, 26, 12, 0, 0, }, /* 440 */- { 17, 9, 12, 0, 48, }, /* 441 */- { 17, 5, 12, 0, -48, }, /* 442 */- { 33, 9, 12, 0, -10743, }, /* 443 */- { 33, 9, 12, 0, -3814, }, /* 444 */- { 33, 9, 12, 0, -10727, }, /* 445 */- { 33, 5, 12, 0, -10795, }, /* 446 */- { 33, 5, 12, 0, -10792, }, /* 447 */- { 33, 9, 12, 0, -10780, }, /* 448 */- { 33, 9, 12, 0, -10749, }, /* 449 */- { 33, 9, 12, 0, -10783, }, /* 450 */- { 33, 9, 12, 0, -10782, }, /* 451 */- { 33, 9, 12, 0, -10815, }, /* 452 */- { 10, 5, 12, 0, 0, }, /* 453 */- { 10, 26, 12, 0, 0, }, /* 454 */- { 10, 12, 3, 0, 0, }, /* 455 */- { 10, 21, 12, 0, 0, }, /* 456 */- { 10, 15, 12, 0, 0, }, /* 457 */- { 16, 5, 12, 0, -7264, }, /* 458 */- { 58, 7, 12, 0, 0, }, /* 459 */- { 58, 6, 12, 0, 0, }, /* 460 */- { 58, 21, 12, 0, 0, }, /* 461 */- { 58, 12, 3, 0, 0, }, /* 462 */- { 22, 26, 12, 0, 0, }, /* 463 */- { 22, 6, 12, 0, 0, }, /* 464 */- { 22, 14, 12, 0, 0, }, /* 465 */- { 23, 10, 3, 0, 0, }, /* 466 */- { 26, 7, 12, 0, 0, }, /* 467 */- { 26, 6, 12, 0, 0, }, /* 468 */- { 29, 7, 12, 0, 0, }, /* 469 */- { 29, 6, 12, 0, 0, }, /* 470 */- { 3, 7, 12, 0, 0, }, /* 471 */- { 23, 7, 12, 0, 0, }, /* 472 */- { 23, 26, 12, 0, 0, }, /* 473 */- { 29, 26, 12, 0, 0, }, /* 474 */- { 22, 7, 12, 0, 0, }, /* 475 */- { 60, 7, 12, 0, 0, }, /* 476 */- { 60, 6, 12, 0, 0, }, /* 477 */- { 60, 26, 12, 0, 0, }, /* 478 */- { 85, 7, 12, 0, 0, }, /* 479 */- { 85, 6, 12, 0, 0, }, /* 480 */- { 85, 21, 12, 0, 0, }, /* 481 */- { 76, 7, 12, 0, 0, }, /* 482 */- { 76, 6, 12, 0, 0, }, /* 483 */- { 76, 21, 12, 0, 0, }, /* 484 */- { 76, 13, 12, 0, 0, }, /* 485 */- { 12, 7, 12, 0, 0, }, /* 486 */- { 12, 21, 12, 0, 0, }, /* 487 */- { 78, 7, 12, 0, 0, }, /* 488 */- { 78, 14, 12, 0, 0, }, /* 489 */- { 78, 12, 3, 0, 0, }, /* 490 */- { 78, 21, 12, 0, 0, }, /* 491 */- { 33, 9, 12, 0, -35332, }, /* 492 */- { 33, 9, 12, 0, -42280, }, /* 493 */- { 33, 9, 12, 0, -42308, }, /* 494 */- { 48, 7, 12, 0, 0, }, /* 495 */- { 48, 12, 3, 0, 0, }, /* 496 */- { 48, 10, 5, 0, 0, }, /* 497 */- { 48, 26, 12, 0, 0, }, /* 498 */- { 64, 7, 12, 0, 0, }, /* 499 */- { 64, 21, 12, 0, 0, }, /* 500 */- { 74, 10, 5, 0, 0, }, /* 501 */- { 74, 7, 12, 0, 0, }, /* 502 */- { 74, 12, 3, 0, 0, }, /* 503 */- { 74, 21, 12, 0, 0, }, /* 504 */- { 74, 13, 12, 0, 0, }, /* 505 */- { 68, 13, 12, 0, 0, }, /* 506 */- { 68, 7, 12, 0, 0, }, /* 507 */- { 68, 12, 3, 0, 0, }, /* 508 */- { 68, 21, 12, 0, 0, }, /* 509 */- { 73, 7, 12, 0, 0, }, /* 510 */- { 73, 12, 3, 0, 0, }, /* 511 */- { 73, 10, 5, 0, 0, }, /* 512 */- { 73, 21, 12, 0, 0, }, /* 513 */- { 83, 12, 3, 0, 0, }, /* 514 */- { 83, 10, 5, 0, 0, }, /* 515 */- { 83, 7, 12, 0, 0, }, /* 516 */- { 83, 21, 12, 0, 0, }, /* 517 */- { 83, 13, 12, 0, 0, }, /* 518 */- { 67, 7, 12, 0, 0, }, /* 519 */- { 67, 12, 3, 0, 0, }, /* 520 */- { 67, 10, 5, 0, 0, }, /* 521 */- { 67, 13, 12, 0, 0, }, /* 522 */- { 67, 21, 12, 0, 0, }, /* 523 */- { 38, 6, 12, 0, 0, }, /* 524 */- { 91, 7, 12, 0, 0, }, /* 525 */- { 91, 12, 3, 0, 0, }, /* 526 */- { 91, 6, 12, 0, 0, }, /* 527 */- { 91, 21, 12, 0, 0, }, /* 528 */- { 86, 7, 12, 0, 0, }, /* 529 */- { 86, 10, 5, 0, 0, }, /* 530 */- { 86, 12, 3, 0, 0, }, /* 531 */- { 86, 21, 12, 0, 0, }, /* 532 */- { 86, 6, 12, 0, 0, }, /* 533 */- { 86, 13, 12, 0, 0, }, /* 534 */- { 23, 7, 9, 0, 0, }, /* 535 */- { 23, 7, 10, 0, 0, }, /* 536 */- { 9, 4, 2, 0, 0, }, /* 537 */- { 9, 3, 12, 0, 0, }, /* 538 */- { 25, 25, 12, 0, 0, }, /* 539 */- { 0, 24, 12, 0, 0, }, /* 540 */- { 9, 6, 3, 0, 0, }, /* 541 */- { 35, 7, 12, 0, 0, }, /* 542 */- { 19, 14, 12, 0, 0, }, /* 543 */- { 19, 15, 12, 0, 0, }, /* 544 */- { 19, 26, 12, 0, 0, }, /* 545 */- { 70, 7, 12, 0, 0, }, /* 546 */- { 66, 7, 12, 0, 0, }, /* 547 */- { 41, 7, 12, 0, 0, }, /* 548 */- { 41, 15, 12, 0, 0, }, /* 549 */- { 18, 7, 12, 0, 0, }, /* 550 */- { 18, 14, 12, 0, 0, }, /* 551 */- { 59, 7, 12, 0, 0, }, /* 552 */- { 59, 21, 12, 0, 0, }, /* 553 */- { 42, 7, 12, 0, 0, }, /* 554 */- { 42, 21, 12, 0, 0, }, /* 555 */- { 42, 14, 12, 0, 0, }, /* 556 */- { 13, 9, 12, 0, 40, }, /* 557 */- { 13, 5, 12, 0, -40, }, /* 558 */- { 46, 7, 12, 0, 0, }, /* 559 */- { 44, 7, 12, 0, 0, }, /* 560 */- { 44, 13, 12, 0, 0, }, /* 561 */- { 11, 7, 12, 0, 0, }, /* 562 */- { 80, 7, 12, 0, 0, }, /* 563 */- { 80, 21, 12, 0, 0, }, /* 564 */- { 80, 15, 12, 0, 0, }, /* 565 */- { 65, 7, 12, 0, 0, }, /* 566 */- { 65, 15, 12, 0, 0, }, /* 567 */- { 65, 21, 12, 0, 0, }, /* 568 */- { 71, 7, 12, 0, 0, }, /* 569 */- { 71, 21, 12, 0, 0, }, /* 570 */- { 97, 7, 12, 0, 0, }, /* 571 */- { 96, 7, 12, 0, 0, }, /* 572 */- { 30, 7, 12, 0, 0, }, /* 573 */- { 30, 12, 3, 0, 0, }, /* 574 */- { 30, 15, 12, 0, 0, }, /* 575 */- { 30, 21, 12, 0, 0, }, /* 576 */- { 87, 7, 12, 0, 0, }, /* 577 */- { 87, 15, 12, 0, 0, }, /* 578 */- { 87, 21, 12, 0, 0, }, /* 579 */- { 77, 7, 12, 0, 0, }, /* 580 */- { 77, 21, 12, 0, 0, }, /* 581 */- { 82, 7, 12, 0, 0, }, /* 582 */- { 82, 15, 12, 0, 0, }, /* 583 */- { 81, 7, 12, 0, 0, }, /* 584 */- { 81, 15, 12, 0, 0, }, /* 585 */- { 88, 7, 12, 0, 0, }, /* 586 */- { 0, 15, 12, 0, 0, }, /* 587 */- { 93, 10, 5, 0, 0, }, /* 588 */- { 93, 12, 3, 0, 0, }, /* 589 */- { 93, 7, 12, 0, 0, }, /* 590 */- { 93, 21, 12, 0, 0, }, /* 591 */- { 93, 15, 12, 0, 0, }, /* 592 */- { 93, 13, 12, 0, 0, }, /* 593 */- { 84, 12, 3, 0, 0, }, /* 594 */- { 84, 10, 5, 0, 0, }, /* 595 */- { 84, 7, 12, 0, 0, }, /* 596 */- { 84, 21, 12, 0, 0, }, /* 597 */- { 84, 1, 2, 0, 0, }, /* 598 */- { 100, 7, 12, 0, 0, }, /* 599 */- { 100, 13, 12, 0, 0, }, /* 600 */- { 95, 12, 3, 0, 0, }, /* 601 */- { 95, 7, 12, 0, 0, }, /* 602 */- { 95, 10, 5, 0, 0, }, /* 603 */- { 95, 13, 12, 0, 0, }, /* 604 */- { 95, 21, 12, 0, 0, }, /* 605 */- { 99, 12, 3, 0, 0, }, /* 606 */- { 99, 10, 5, 0, 0, }, /* 607 */- { 99, 7, 12, 0, 0, }, /* 608 */- { 99, 21, 12, 0, 0, }, /* 609 */- { 99, 13, 12, 0, 0, }, /* 610 */- { 101, 7, 12, 0, 0, }, /* 611 */- { 101, 12, 3, 0, 0, }, /* 612 */- { 101, 10, 5, 0, 0, }, /* 613 */- { 101, 13, 12, 0, 0, }, /* 614 */- { 62, 7, 12, 0, 0, }, /* 615 */- { 62, 14, 12, 0, 0, }, /* 616 */- { 62, 21, 12, 0, 0, }, /* 617 */- { 79, 7, 12, 0, 0, }, /* 618 */- { 98, 7, 12, 0, 0, }, /* 619 */- { 98, 10, 5, 0, 0, }, /* 620 */- { 98, 12, 3, 0, 0, }, /* 621 */- { 98, 6, 12, 0, 0, }, /* 622 */- { 9, 10, 3, 0, 0, }, /* 623 */- { 19, 12, 3, 0, 0, }, /* 624 */- { 9, 26, 11, 0, 0, }, /* 625 */- { 26, 26, 12, 0, 0, }, /* 626 */-};--const pcre_uint8 PRIV(ucd_stage1)[] = { /* 8704 bytes */- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* U+0000 */- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* U+0800 */- 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 41, 41, 42, 43, 44, 45, /* U+1000 */- 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, /* U+1800 */- 62, 63, 64, 65, 66, 66, 67, 68, 69, 70, 71, 72, 73, 71, 74, 75, /* U+2000 */- 76, 76, 66, 77, 66, 66, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, /* U+2800 */- 88, 89, 90, 91, 92, 93, 94, 71, 95, 95, 95, 95, 95, 95, 95, 95, /* U+3000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+3800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+4000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 96, 95, 95, 95, 95, /* U+4800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+5000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+5800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+6000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+6800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+7000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+7800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+8000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+8800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+9000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 97, /* U+9800 */- 98, 99, 99, 99, 99, 99, 99, 99, 99,100,101,101,102,103,104,105, /* U+A000 */-106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,114, /* U+A800 */-115,116,117,118,119,120,114,115,116,117,118,119,120,114,115,116, /* U+B000 */-117,118,119,120,114,115,116,117,118,119,120,114,115,116,117,118, /* U+B800 */-119,120,114,115,116,117,118,119,120,114,115,116,117,118,119,120, /* U+C000 */-114,115,116,117,118,119,120,114,115,116,117,118,119,120,114,115, /* U+C800 */-116,117,118,119,120,114,115,116,117,118,119,120,114,115,116,121, /* U+D000 */-122,122,122,122,122,122,122,122,122,122,122,122,122,122,122,122, /* U+D800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+E000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+E800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F000 */-123,123, 95, 95,124,125,126,127,128,128,129,130,131,132,133,134, /* U+F800 */-135,136,137,138, 79,139,140,141,142,143, 79, 79, 79, 79, 79, 79, /* U+10000 */-144, 79,145,146,147, 79,148, 79,149, 79, 79, 79,150, 79, 79, 79, /* U+10800 */-151,152,153,154, 79, 79, 79, 79, 79, 79, 79, 79, 79,155, 79, 79, /* U+11000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+11800 */-156,156,156,156,156,156,157, 79,158, 79, 79, 79, 79, 79, 79, 79, /* U+12000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+12800 */-159,159,159,159,159,159,159,159,160, 79, 79, 79, 79, 79, 79, 79, /* U+13000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+13800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+14000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+14800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+15000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+15800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+16000 */-161,161,161,161,162, 79, 79, 79, 79, 79, 79, 79, 79, 79,163,164, /* U+16800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+17000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+17800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+18000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+18800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+19000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+19800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1A000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1A800 */-165, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1B000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1C800 */- 71,166,167,168,169, 79,170, 79,171,172,173,174,175,176,177,178, /* U+1D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,179,180, 79, 79, /* U+1E800 */-181,182,183,184,185, 79,186,187,188,189,190,191,192,193,194, 79, /* U+1F000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+1F800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+20000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+20800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+21000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+21800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+22000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+22800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+23000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+23800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+24000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+24800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+25000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+25800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+26000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+26800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+27000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+27800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+28000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+28800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+29000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+29800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95,195, 95, 95, /* U+2A000 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+2A800 */- 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95,196, 95, /* U+2B000 */-197, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2C800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2E800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2F000 */- 95, 95, 95, 95,197, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+2F800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+30000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+30800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+31000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+31800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+32000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+32800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+33000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+33800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+34000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+34800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+35000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+35800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+36000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+36800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+37000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+37800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+38000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+38800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+39000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+39800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3A000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3A800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3B000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3C800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3E800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3F000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+3F800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+40000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+40800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+41000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+41800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+42000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+42800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+43000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+43800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+44000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+44800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+45000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+45800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+46000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+46800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+47000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+47800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+48000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+48800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+49000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+49800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4A000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4A800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4B000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4C800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4E800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4F000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+4F800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+50000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+50800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+51000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+51800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+52000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+52800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+53000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+53800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+54000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+54800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+55000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+55800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+56000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+56800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+57000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+57800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+58000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+58800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+59000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+59800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5A000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5A800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5B000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5C800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5E800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5F000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+5F800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+60000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+60800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+61000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+61800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+62000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+62800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+63000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+63800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+64000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+64800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+65000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+65800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+66000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+66800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+67000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+67800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+68000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+68800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+69000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+69800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6A000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6A800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6B000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6C800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6E800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6F000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+6F800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+70000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+70800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+71000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+71800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+72000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+72800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+73000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+73800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+74000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+74800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+75000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+75800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+76000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+76800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+77000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+77800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+78000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+78800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+79000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+79800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7A000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7A800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7B000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7C800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7E800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7F000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+7F800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+80000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+80800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+81000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+81800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+82000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+82800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+83000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+83800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+84000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+84800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+85000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+85800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+86000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+86800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+87000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+87800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+88000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+88800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+89000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+89800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8A000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8A800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8B000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8C800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8E800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8F000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+8F800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+90000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+90800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+91000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+91800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+92000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+92800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+93000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+93800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+94000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+94800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+95000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+95800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+96000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+96800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+97000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+97800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+98000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+98800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+99000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+99800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9A000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9A800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9B000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9B800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9C000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9C800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9D000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9D800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9E000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9E800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9F000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+9F800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A0000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A0800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A1000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A1800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A2000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A2800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A3000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A3800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A4000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A4800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A5000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A5800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A6000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A6800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A7000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A7800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A8000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A8800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A9000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+A9800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AA000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AA800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AB000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AB800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AC000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AC800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AD000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AD800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AE000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AE800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AF000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+AF800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B0000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B0800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B1000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B1800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B2000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B2800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B3000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B3800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B4000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B4800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B5000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B5800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B6000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B6800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B7000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B7800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B8000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B8800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B9000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+B9800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BA000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BA800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BB000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BB800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BC000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BC800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BD000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BD800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BE000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BE800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BF000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+BF800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C0000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C0800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C1000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C1800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C2000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C2800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C3000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C3800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C4000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C4800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C5000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C5800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C6000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C6800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C7000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C7800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C8000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C8800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C9000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+C9800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CA000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CA800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CB000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CB800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CC000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CC800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CD000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CD800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CE000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CE800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CF000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+CF800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D0000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D0800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D1000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D1800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D2000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D2800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D3000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D3800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D4000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D4800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D5000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D5800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D6000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D6800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D7000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D7800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D8000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D8800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D9000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+D9800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DA000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DA800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DB000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DB800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DC000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DC800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DD000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DD800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DE000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DE800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DF000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+DF800 */-198,199,200,201,199,199,199,199,199,199,199,199,199,199,199,199, /* U+E0000 */-199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199, /* U+E0800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E1000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E1800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E2000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E2800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E3000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E3800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E4000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E4800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E5000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E5800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E6000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E6800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E7000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E7800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E8000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E8800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E9000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+E9800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EA000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EA800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EB000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EB800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EC000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EC800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+ED000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+ED800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EE000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EE800 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EF000 */- 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, /* U+EF800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F0000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F0800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F1000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F1800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F2000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F2800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F3000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F3800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F4000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F4800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F5000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F5800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F6000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F6800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F7000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F7800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F8000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F8800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F9000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F9800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FA000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FA800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FB000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FB800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FC000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FC800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FD000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FD800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FE000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FE800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FF000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,202, /* U+FF800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+100000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+100800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+101000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+101800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+102000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+102800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+103000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+103800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+104000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+104800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+105000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+105800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+106000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+106800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+107000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+107800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+108000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+108800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+109000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+109800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10A000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10A800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10B000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10B800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10C000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10C800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10D000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10D800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10E000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10E800 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10F000 */-123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,202, /* U+10F800 */-};--const pcre_uint16 PRIV(ucd_stage2)[] = { /* 51968 bytes, block = 128 */-/* block 0 */- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0,- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,- 3, 4, 4, 4, 5, 4, 4, 4, 6, 7, 4, 8, 4, 9, 4, 4,- 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 4, 4, 8, 8, 8, 4,- 4, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 11, 11, 11, 11,- 11, 11, 11, 13, 11, 11, 11, 11, 11, 11, 11, 6, 4, 7, 14, 15,- 14, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 16, 16, 16, 16,- 16, 16, 16, 18, 16, 16, 16, 16, 16, 16, 16, 6, 8, 7, 8, 0,--/* block 1 */- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,- 3, 4, 5, 5, 5, 5, 19, 4, 14, 19, 20, 21, 8, 22, 19, 14,- 19, 8, 23, 23, 14, 24, 4, 4, 14, 23, 20, 25, 23, 23, 23, 4,- 11, 11, 11, 11, 11, 26, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,- 11, 11, 11, 11, 11, 11, 11, 8, 11, 11, 11, 11, 11, 11, 11, 27,- 16, 16, 16, 16, 16, 28, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,- 16, 16, 16, 16, 16, 16, 16, 8, 16, 16, 16, 16, 16, 16, 16, 29,--/* block 2 */- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 32, 33, 30, 31, 30, 31, 30, 31, 33, 30, 31, 30, 31, 30, 31, 30,- 31, 30, 31, 30, 31, 30, 31, 30, 31, 33, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 34, 30, 31, 30, 31, 30, 31, 35,--/* block 3 */- 36, 37, 30, 31, 30, 31, 38, 30, 31, 39, 39, 30, 31, 33, 40, 41,- 42, 30, 31, 39, 43, 44, 45, 46, 30, 31, 47, 33, 45, 48, 49, 50,- 30, 31, 30, 31, 30, 31, 51, 30, 31, 51, 33, 33, 30, 31, 51, 30,- 31, 52, 52, 30, 31, 30, 31, 53, 30, 31, 33, 20, 30, 31, 33, 54,- 20, 20, 20, 20, 55, 56, 57, 58, 59, 60, 61, 62, 63, 30, 31, 30,- 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 64, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 33, 65, 66, 67, 30, 31, 68, 69, 30, 31, 30, 31, 30, 31, 30, 31,--/* block 4 */- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 70, 33, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 33, 33, 33, 33, 33, 33, 71, 30, 31, 72, 73, 74,- 74, 30, 31, 75, 76, 77, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 78, 79, 80, 81, 82, 33, 83, 83, 33, 84, 33, 85, 33, 33, 33, 33,- 83, 33, 33, 86, 33, 87, 88, 33, 89, 90, 33, 91, 33, 33, 33, 90,- 33, 92, 93, 33, 33, 94, 33, 33, 33, 33, 33, 33, 33, 95, 33, 33,--/* block 5 */- 96, 33, 33, 96, 33, 33, 33, 33, 96, 97, 98, 98, 99, 33, 33, 33,- 33, 33,100, 33, 20, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,-101,101,101,101,101,101,101,101,101,102,102,102,102,102,102,102,-102,102, 14, 14, 14, 14,102,102,102,102,102,102,102,102,102,102,-102,102, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,-101,101,101,101,101, 14, 14, 14, 14, 14,103,103,102, 14,102, 14,- 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,--/* block 6 */-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,105,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-106,107,106,107,102,108,106,107,109,109,110,111,111,111, 4,109,--/* block 7 */-109,109,109,109,108, 14,112, 4,113,113,113,109,114,109,115,115,-116,117,118,117,117,119,117,117,120,121,122,117,123,117,117,117,-124,125,109,126,117,117,127,117,117,128,117,117,129,130,130,130,-116,131,132,131,131,133,131,131,134,135,136,131,137,131,131,131,-138,139,140,141,131,131,142,131,131,143,131,131,144,145,145,146,-147,148,149,149,149,150,151,152,106,107,106,107,106,107,106,107,-106,107,153,154,153,154,153,154,153,154,153,154,153,154,153,154,-155,156,157,116,158,159,160,106,107,161,106,107,116,162,162,162,--/* block 8 */-163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,163,-164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,-164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,-165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,-165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,-166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,166,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,--/* block 9 */-167,168,169,170,170,104,104,170,171,171,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-172,167,168,167,168,167,168,167,168,167,168,167,168,167,168,173,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,--/* block 10 */-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,109,109,109,109,109,109,109,109,-109,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,-174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,174,-174,174,174,174,174,174,174,109,109,175,176,176,176,176,176,176,-109,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,-177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,--/* block 11 */-177,177,177,177,177,177,177,178,109, 4,179,109,109,109,109,180,-109,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,-181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,-181,181,181,181,181,181,181,181,181,181,181,181,181,181,182,181,-183,181,181,183,181,181,183,181,109,109,109,109,109,109,109,109,-184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,-184,184,184,184,184,184,184,184,184,184,184,109,109,109,109,109,-184,184,184,183,183,109,109,109,109,109,109,109,109,109,109,109,--/* block 12 */-185,185,185,185,185,109,186,186,186,187,187,188, 4,187,189,189,-190,190,190,190,190,190,190,190,190,190,190, 4,185,109,187, 4,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-102,191,191,191,191,191,191,191,191,191,191,104,104,104,104,104,-104,104,104,104,104,104,190,190,190,190,190,190,190,190,190,190,- 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,187,187,187,187,191,191,-104,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,--/* block 13 */-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,187,191,190,190,190,190,190,190,190, 22,189,190,-190,190,190,190,190,192,192,190,190,189,190,190,190,190,191,191,-193,193,193,193,193,193,193,193,193,193,191,191,191,189,189,191,--/* block 14 */-194,194,194,194,194,194,194,194,194,194,194,194,194,194,109,195,-196,197,196,196,196,196,196,196,196,196,196,196,196,196,196,196,-196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,-197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,-197,197,197,197,197,197,197,197,197,197,197,109,109,196,196,196,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,--/* block 15 */-198,198,198,198,198,198,198,198,198,198,198,198,198,198,198,198,-198,198,198,198,198,198,198,198,198,198,198,198,198,198,198,198,-198,198,198,198,198,198,199,199,199,199,199,199,199,199,199,199,-199,198,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-200,200,200,200,200,200,200,200,200,200,201,201,201,201,201,201,-201,201,201,201,201,201,201,201,201,201,201,201,201,201,201,201,-201,201,201,201,201,201,201,201,201,201,201,202,202,202,202,202,-202,202,202,202,203,203,204,205,205,205,203,109,109,109,109,109,--/* block 16 */-206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,-206,206,206,206,206,206,207,207,207,207,208,207,207,207,207,207,-207,207,207,207,208,207,207,207,208,207,207,207,207,207,109,109,-209,209,209,209,209,209,209,209,209,209,209,209,209,209,209,109,-210,210,210,210,210,210,210,210,210,210,210,210,210,210,210,210,-210,210,210,210,210,210,210,210,210,211,211,211,109,109,212,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 17 */-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-191,109,191,191,191,191,191,191,191,191,191,191,191,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,190,190,190,190,190,190,190,190,190,190,190,190,-190,190,190,190,190,190,190,190,190,190,190,190,190,190,190,109,--/* block 18 */-213,213,213,214,215,215,215,215,215,215,215,215,215,215,215,215,-215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,-215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,-215,215,215,215,215,215,215,215,215,215,213,214,213,215,214,214,-214,213,213,213,213,213,213,213,213,214,214,214,214,213,214,214,-215,104,104,213,213,213,213,213,215,215,215,215,215,215,215,215,-215,215,213,213, 4, 4,216,216,216,216,216,216,216,216,216,216,-217,218,215,215,215,215,215,215,109,215,215,215,215,215,215,215,--/* block 19 */-109,219,220,220,109,221,221,221,221,221,221,221,221,109,109,221,-221,109,109,221,221,221,221,221,221,221,221,221,221,221,221,221,-221,221,221,221,221,221,221,221,221,109,221,221,221,221,221,221,-221,109,221,109,109,109,221,221,221,221,109,109,219,221,222,220,-220,219,219,219,219,109,109,220,220,109,109,220,220,219,221,109,-109,109,109,109,109,109,109,222,109,109,109,109,221,221,109,221,-221,221,219,219,109,109,223,223,223,223,223,223,223,223,223,223,-221,221,224,224,225,225,225,225,225,225,226,224,109,109,109,109,--/* block 20 */-109,227,227,228,109,229,229,229,229,229,229,109,109,109,109,229,-229,109,109,229,229,229,229,229,229,229,229,229,229,229,229,229,-229,229,229,229,229,229,229,229,229,109,229,229,229,229,229,229,-229,109,229,229,109,229,229,109,229,229,109,109,227,109,228,228,-228,227,227,109,109,109,109,227,227,109,109,227,227,227,109,109,-109,227,109,109,109,109,109,109,109,229,229,229,229,109,229,109,-109,109,109,109,109,109,230,230,230,230,230,230,230,230,230,230,-227,227,229,229,229,227,109,109,109,109,109,109,109,109,109,109,--/* block 21 */-109,231,231,232,109,233,233,233,233,233,233,233,233,233,109,233,-233,233,109,233,233,233,233,233,233,233,233,233,233,233,233,233,-233,233,233,233,233,233,233,233,233,109,233,233,233,233,233,233,-233,109,233,233,109,233,233,233,233,233,109,109,231,233,232,232,-232,231,231,231,231,231,109,231,231,232,109,232,232,231,109,109,-233,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-233,233,231,231,109,109,234,234,234,234,234,234,234,234,234,234,-235,236,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 22 */-109,237,238,238,109,239,239,239,239,239,239,239,239,109,109,239,-239,109,109,239,239,239,239,239,239,239,239,239,239,239,239,239,-239,239,239,239,239,239,239,239,239,109,239,239,239,239,239,239,-239,109,239,239,109,239,239,239,239,239,109,109,237,239,240,237,-238,237,237,237,237,109,109,238,238,109,109,238,238,237,109,109,-109,109,109,109,109,109,237,240,109,109,109,109,239,239,109,239,-239,239,237,237,109,109,241,241,241,241,241,241,241,241,241,241,-242,239,243,243,243,243,243,243,109,109,109,109,109,109,109,109,--/* block 23 */-109,109,244,245,109,245,245,245,245,245,245,109,109,109,245,245,-245,109,245,245,245,245,109,109,109,245,245,109,245,109,245,245,-109,109,109,245,245,109,109,109,245,245,245,109,109,109,245,245,-245,245,245,245,245,245,245,245,245,245,109,109,109,109,246,247,-244,247,247,109,109,109,247,247,247,109,247,247,247,244,109,109,-245,109,109,109,109,109,109,246,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,248,248,248,248,248,248,248,248,248,248,-249,249,249,250,250,250,250,250,250,251,250,109,109,109,109,109,--/* block 24 */-109,252,252,252,109,253,253,253,253,253,253,253,253,109,253,253,-253,109,253,253,253,253,253,253,253,253,253,253,253,253,253,253,-253,253,253,253,253,253,253,253,253,109,253,253,253,253,253,253,-253,253,253,253,109,253,253,253,253,253,109,109,109,253,254,254,-254,252,252,252,252,109,254,254,254,109,254,254,254,254,109,109,-109,109,109,109,109,254,254,109,253,253,109,109,109,109,109,109,-253,253,254,254,109,109,255,255,255,255,255,255,255,255,255,255,-109,109,109,109,109,109,109,109,256,256,256,256,256,256,256,257,--/* block 25 */-109,109,258,258,109,259,259,259,259,259,259,259,259,109,259,259,-259,109,259,259,259,259,259,259,259,259,259,259,259,259,259,259,-259,259,259,259,259,259,259,259,259,109,259,259,259,259,259,259,-259,259,259,259,109,259,259,259,259,259,109,109,260,259,258,260,-258,258,261,258,258,109,260,258,258,109,258,258,260,260,109,109,-109,109,109,109,109,261,261,109,109,109,109,109,109,109,259,109,-259,259,260,260,109,109,262,262,262,262,262,262,262,262,262,262,-109,259,259,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 26 */-109,109,263,263,109,264,264,264,264,264,264,264,264,109,264,264,-264,109,264,264,264,264,264,264,264,264,264,264,264,264,264,264,-264,264,264,264,264,264,264,264,264,264,264,264,264,264,264,264,-264,264,264,264,264,264,264,264,264,264,264,109,109,264,265,263,-263,266,266,266,266,109,263,263,263,109,263,263,263,266,264,109,-109,109,109,109,109,109,109,265,109,109,109,109,109,109,109,109,-264,264,266,266,109,109,267,267,267,267,267,267,267,267,267,267,-268,268,268,268,268,268,109,109,109,269,264,264,264,264,264,264,--/* block 27 */-109,109,270,270,109,271,271,271,271,271,271,271,271,271,271,271,-271,271,271,271,271,271,271,109,109,109,271,271,271,271,271,271,-271,271,271,271,271,271,271,271,271,271,271,271,271,271,271,271,-271,271,109,271,271,271,271,271,271,271,271,271,109,271,109,109,-271,271,271,271,271,271,271,109,109,109,272,109,109,109,109,273,-270,270,272,272,272,109,272,109,270,270,270,270,270,270,270,273,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,270,270,274,109,109,109,109,109,109,109,109,109,109,109,--/* block 28 */-109,275,275,275,275,275,275,275,275,275,275,275,275,275,275,275,-275,275,275,275,275,275,275,275,275,275,275,275,275,275,275,275,-275,275,275,275,275,275,275,275,275,275,275,275,275,275,275,275,-275,276,275,277,276,276,276,276,276,276,276,109,109,109,109, 5,-275,275,275,275,275,275,278,276,276,276,276,276,276,276,276,279,-280,280,280,280,280,280,280,280,280,280,279,279,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 29 */-109,281,281,109,281,109,109,281,281,109,281,109,109,281,109,109,-109,109,109,109,281,281,281,281,109,281,281,281,281,281,281,281,-109,281,281,281,109,281,109,281,109,109,281,281,109,281,281,281,-281,282,281,283,282,282,282,282,282,282,109,282,282,281,109,109,-281,281,281,281,281,109,284,109,282,282,282,282,282,282,109,109,-285,285,285,285,285,285,285,285,285,285,109,109,281,281,281,281,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 30 */-286,287,287,287,288,288,288,288,288,288,288,288,288,288,288,288,-288,288,288,287,288,287,287,287,289,289,287,287,287,287,287,287,-290,290,290,290,290,290,290,290,290,290,291,291,291,291,291,291,-291,291,291,291,287,289,287,289,287,289,292,293,292,293,294,294,-286,286,286,286,286,286,286,286,109,286,286,286,286,286,286,286,-286,286,286,286,286,286,286,286,286,286,286,286,286,286,286,286,-286,286,286,286,286,286,286,286,286,286,286,286,286,109,109,109,-109,289,289,289,289,289,289,289,289,289,289,289,289,289,289,294,--/* block 31 */-289,289,289,289,289,288,289,289,286,286,286,286,286,289,289,289,-289,289,289,289,289,289,289,289,109,289,289,289,289,289,289,289,-289,289,289,289,289,289,289,289,289,289,289,289,289,289,289,289,-289,289,289,289,289,289,289,289,289,289,289,289,289,109,287,287,-287,287,287,287,287,287,289,287,287,287,287,287,287,109,287,287,-288,288,288,288,288, 19, 19, 19, 19,288,288,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 32 */-295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,-295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,-295,295,295,295,295,295,295,295,295,295,295,296,296,297,297,297,-297,298,297,297,297,297,297,297,296,297,297,298,298,297,297,295,-299,299,299,299,299,299,299,299,299,299,300,300,300,300,300,300,-295,295,295,295,295,295,298,298,297,297,295,295,295,295,297,297,-297,295,296,296,296,295,295,296,296,296,296,296,296,296,295,295,-295,297,297,297,297,295,295,295,295,295,295,295,295,295,295,295,--/* block 33 */-295,295,297,296,298,297,297,296,296,296,296,296,296,297,295,296,-299,299,299,299,299,299,299,299,299,299,296,296,296,297,301,301,-302,302,302,302,302,302,302,302,302,302,302,302,302,302,302,302,-302,302,302,302,302,302,302,302,302,302,302,302,302,302,302,302,-302,302,302,302,302,302,109,302,109,109,109,109,109,302,109,109,-303,303,303,303,303,303,303,303,303,303,303,303,303,303,303,303,-303,303,303,303,303,303,303,303,303,303,303,303,303,303,303,303,-303,303,303,303,303,303,303,303,303,303,303, 4,304,303,303,303,--/* block 34 */-305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,-305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,-305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,-305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,-305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,-305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,-306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,-306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,--/* block 35 */-306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,-306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,-306,306,306,306,306,306,306,306,307,307,307,307,307,307,307,307,-307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,-307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,-307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,-307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,-307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,--/* block 36 */-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,109,308,308,308,308,109,109,-308,308,308,308,308,308,308,109,308,109,308,308,308,308,109,109,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,--/* block 37 */-308,308,308,308,308,308,308,308,308,109,308,308,308,308,109,109,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,109,308,308,308,308,109,109,308,308,308,308,308,308,308,109,-308,109,308,308,308,308,109,109,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,109,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,--/* block 38 */-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,109,308,308,308,308,109,109,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,308,308,308,308,109,109,309,309,309,-310,310,310,310,310,310,310,310,310,311,311,311,311,311,311,311,-311,311,311,311,311,311,311,311,311,311,311,311,311,109,109,109,--/* block 39 */-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-312,312,312,312,312,312,312,312,312,312,109,109,109,109,109,109,-313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,-313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,-313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,-313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,-313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,313,-313,313,313,313,313,109,109,109,109,109,109,109,109,109,109,109,--/* block 40 */-314,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,--/* block 41 */-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,--/* block 42 */-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,316,316,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,--/* block 43 */-317,318,318,318,318,318,318,318,318,318,318,318,318,318,318,318,-318,318,318,318,318,318,318,318,318,318,318,319,320,109,109,109,-321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,-321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,-321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,-321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,321,-321,321,321,321,321,321,321,321,321,321,321, 4, 4, 4,322,322,-322,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 44 */-323,323,323,323,323,323,323,323,323,323,323,323,323,109,323,323,-323,323,324,324,324,109,109,109,109,109,109,109,109,109,109,109,-325,325,325,325,325,325,325,325,325,325,325,325,325,325,325,325,-325,325,326,326,326, 4, 4,109,109,109,109,109,109,109,109,109,-327,327,327,327,327,327,327,327,327,327,327,327,327,327,327,327,-327,327,328,328,109,109,109,109,109,109,109,109,109,109,109,109,-329,329,329,329,329,329,329,329,329,329,329,329,329,109,329,329,-329,109,330,330,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 45 */-331,331,331,331,331,331,331,331,331,331,331,331,331,331,331,331,-331,331,331,331,331,331,331,331,331,331,331,331,331,331,331,331,-331,331,331,331,331,331,331,331,331,331,331,331,331,331,331,331,-331,331,331,331,332,332,333,332,332,332,332,332,332,332,333,333,-333,333,333,333,333,333,332,333,333,332,332,332,332,332,332,332,-332,332,332,332,334,334,334,335,334,334,334,336,331,332,109,109,-337,337,337,337,337,337,337,337,337,337,109,109,109,109,109,109,-338,338,338,338,338,338,338,338,338,338,109,109,109,109,109,109,--/* block 46 */-339,339, 4, 4,339, 4,340,339,339,339,339,341,341,341,342,109,-343,343,343,343,343,343,343,343,343,343,109,109,109,109,109,109,-344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,-344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,-344,344,344,345,344,344,344,344,344,344,344,344,344,344,344,344,-344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,-344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,-344,344,344,344,344,344,344,344,109,109,109,109,109,109,109,109,--/* block 47 */-344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,-344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,344,-344,344,344,344,344,344,344,344,344,341,344,109,109,109,109,109,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,-315,315,315,315,315,315,109,109,109,109,109,109,109,109,109,109,--/* block 48 */-346,346,346,346,346,346,346,346,346,346,346,346,346,346,346,346,-346,346,346,346,346,346,346,346,346,346,346,346,346,109,109,109,-347,347,347,348,348,348,348,347,347,348,348,348,109,109,109,109,-348,348,347,348,348,348,348,348,348,347,347,347,109,109,109,109,-349,109,109,109,350,350,351,351,351,351,351,351,351,351,351,351,-352,352,352,352,352,352,352,352,352,352,352,352,352,352,352,352,-352,352,352,352,352,352,352,352,352,352,352,352,352,352,109,109,-352,352,352,352,352,109,109,109,109,109,109,109,109,109,109,109,--/* block 49 */-353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,-353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,-353,353,353,353,353,353,353,353,353,353,353,353,109,109,109,109,-354,354,354,354,354,355,355,355,354,354,355,354,354,354,354,354,-354,353,353,353,353,353,353,353,354,354,109,109,109,109,109,109,-356,356,356,356,356,356,356,356,356,356,357,109,109,109,358,358,-359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,-359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,359,--/* block 50 */-360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,360,-360,360,360,360,360,360,360,361,361,362,362,361,109,109,363,363,-364,364,364,364,364,364,364,364,364,364,364,364,364,364,364,364,-364,364,364,364,364,364,364,364,364,364,364,364,364,364,364,364,-364,364,364,364,364,364,364,364,364,364,364,364,364,364,364,364,-364,364,364,364,364,365,366,365,366,366,366,366,366,366,366,109,-366,367,366,367,367,366,366,366,366,366,366,366,366,365,365,365,-365,365,365,366,366,366,366,366,366,366,366,366,366,109,109,366,--/* block 51 */-368,368,368,368,368,368,368,368,368,368,109,109,109,109,109,109,-368,368,368,368,368,368,368,368,368,368,109,109,109,109,109,109,-369,369,369,369,369,369,369,370,369,369,369,369,369,369,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 52 */-371,371,371,371,372,373,373,373,373,373,373,373,373,373,373,373,-373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,-373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,-373,373,373,373,371,372,371,371,371,371,371,372,371,372,372,372,-372,372,371,372,372,373,373,373,373,373,373,373,109,109,109,109,-374,374,374,374,374,374,374,374,374,374,375,375,375,375,375,375,-375,376,376,376,376,376,376,376,376,376,376,371,371,371,371,371,-371,371,371,371,376,376,376,376,376,376,376,376,376,109,109,109,--/* block 53 */-377,377,378,379,379,379,379,379,379,379,379,379,379,379,379,379,-379,379,379,379,379,379,379,379,379,379,379,379,379,379,379,379,-379,378,377,377,377,377,378,378,377,377,378,377,378,378,379,379,-380,380,380,380,380,380,380,380,380,380,379,379,379,379,379,379,-381,381,381,381,381,381,381,381,381,381,381,381,381,381,381,381,-381,381,381,381,381,381,381,381,381,381,381,381,381,381,381,381,-381,381,381,381,381,381,382,383,382,382,383,383,383,382,383,382,-382,382,383,383,109,109,109,109,109,109,109,109,384,384,384,384,--/* block 54 */-385,385,385,385,385,385,385,385,385,385,385,385,385,385,385,385,-385,385,385,385,385,385,385,385,385,385,385,385,385,385,385,385,-385,385,385,385,386,386,386,386,386,386,386,386,387,387,387,387,-387,387,387,387,386,386,387,387,109,109,109,388,388,388,388,388,-389,389,389,389,389,389,389,389,389,389,109,109,109,385,385,385,-390,390,390,390,390,390,390,390,390,390,391,391,391,391,391,391,-391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,-391,391,391,391,391,391,391,391,392,392,392,392,392,392,393,393,--/* block 55 */-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-394,394,394,394,394,394,394,394,109,109,109,109,109,109,109,109,-104,104,104, 4,104,104,104,104,104,104,104,104,104,104,104,104,-104,395,104,104,104,104,104,104,104,396,396,396,396,104,396,396,-396,396,395,395,104,396,396,109,109,109,109,109,109,109,109,109,--/* block 56 */- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,- 33, 33, 33, 33, 33, 33,116,116,116,116,116,397,101,101,101,101,-101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,-101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,-101,101,101,101,101,101,101,101,101,101,101,101,101,110,110,110,-110,110,101,101,101,101,110,110,110,110,110, 33, 33, 33, 33, 33,- 33, 33, 33, 33, 33, 33, 33, 33,398,399, 33, 33, 33,400, 33, 33,--/* block 57 */- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,101,101,101,101,101,-101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,-101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,110,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,104,104,104,104,--/* block 58 */- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,-401,402, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,--/* block 59 */- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 33, 33, 33, 33, 33,403, 33, 33,404, 33,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,--/* block 60 */-405,405,405,405,405,405,405,405,406,406,406,406,406,406,406,406,-405,405,405,405,405,405,109,109,406,406,406,406,406,406,109,109,-405,405,405,405,405,405,405,405,406,406,406,406,406,406,406,406,-405,405,405,405,405,405,405,405,406,406,406,406,406,406,406,406,-405,405,405,405,405,405,109,109,406,406,406,406,406,406,109,109,-116,405,116,405,116,405,116,405,109,406,109,406,109,406,109,406,-405,405,405,405,405,405,405,405,406,406,406,406,406,406,406,406,-407,407,408,408,408,408,409,409,410,410,411,411,412,412,109,109,--/* block 61 */-405,405,405,405,405,405,405,405,413,413,413,413,413,413,413,413,-405,405,405,405,405,405,405,405,413,413,413,413,413,413,413,413,-405,405,405,405,405,405,405,405,413,413,413,413,413,413,413,413,-405,405,116,414,116,109,116,116,406,406,415,415,416,108,417,108,-108,108,116,414,116,109,116,116,418,418,418,418,416,108,108,108,-405,405,116,116,109,109,116,116,406,406,419,419,109,108,108,108,-405,405,116,116,116,157,116,116,406,406,420,420,161,108,108,108,-109,109,116,414,116,109,116,116,421,421,422,422,416,108,108,109,--/* block 62 */- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 22,423,423, 22, 22,- 9, 9, 9, 9, 9, 9, 4, 4, 21, 25, 6, 21, 21, 25, 6, 21,- 4, 4, 4, 4, 4, 4, 4, 4,424,425, 22, 22, 22, 22, 22, 3,- 4, 4, 4, 4, 4, 4, 4, 4, 4, 21, 25, 4, 4, 4, 4, 15,- 15, 4, 4, 4, 8, 6, 7, 4, 4, 4, 4, 4, 4, 4, 4, 4,- 4, 4, 8, 4, 15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3,- 22, 22, 22, 22, 22,426, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,- 23,101,109,109, 23, 23, 23, 23, 23, 23, 8, 8, 8, 6, 7,101,--/* block 63 */- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 8, 8, 8, 6, 7,109,-101,101,101,101,101,101,101,101,101,101,101,101,101,109,109,109,- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-104,104,104,104,104,104,104,104,104,104,104,104,104,427,427,427,-427,104,427,427,427,104,104,104,104,104,104,104,104,104,104,104,-104,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 64 */- 19, 19,428, 19, 19, 19, 19,428, 19, 19,429,428,428,428,429,429,-428,428,428,429, 19,428, 19, 19, 8,428,428,428,428,428, 19, 19,- 19, 19, 19, 19,428, 19,430, 19,428, 19,431,432,428,428, 19,429,-428,428,433,428,429,396,396,396,396,429, 19, 19,429,429,428,428,- 8, 8, 8, 8, 8,428,429,429,429,429, 19, 8, 19, 19,434, 19,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,-435,435,435,435,435,435,435,435,435,435,435,435,435,435,435,435,-436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,--/* block 65 */-437,437,437, 30, 31,437,437,437,437, 23,109,109,109,109,109,109,- 8, 8, 8, 8, 8, 19, 19, 19, 19, 19, 8, 8, 19, 19, 19, 19,- 8, 19, 19, 8, 19, 19, 8, 19, 19, 19, 19, 19, 19, 19, 8, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8, 8,- 19, 19, 8, 19, 8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,--/* block 66 */- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,--/* block 67 */- 19, 19, 19, 19, 19, 19, 19, 19, 6, 7, 6, 7, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 8, 8, 19, 19, 19, 19, 19, 19, 19, 6, 7, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8, 19, 19, 19,--/* block 68 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8, 8, 8, 8,- 8, 8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 69 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,--/* block 70 */- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19,438,438,438,438,438,438,438,438,438,438,-438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,-439,439,439,439,439,439,439,439,439,439,439,439,439,439,439,439,-439,439,439,439,439,439,439,439,439,439, 23, 23, 23, 23, 23, 23,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,--/* block 71 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,--/* block 72 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 8, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 8, 8, 8, 8, 8, 8, 8, 8,--/* block 73 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,--/* block 74 */-109, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 6, 7, 6, 7, 6, 7, 6, 7,- 6, 7, 6, 7, 6, 7, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,--/* block 75 */- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,- 23, 23, 23, 23, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 8, 8, 8, 8, 8, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,--/* block 76 */-440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,-440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,-440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,-440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,-440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,-440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,-440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,-440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,440,--/* block 77 */- 8, 8, 8, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6,- 7, 6, 7, 6, 7, 6, 7, 6, 7, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 6, 7, 6, 7, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 7, 8, 8,--/* block 78 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,- 8, 8, 8, 8, 8, 19, 19, 8, 8, 8, 8, 8, 8,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 79 */-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 80 */-441,441,441,441,441,441,441,441,441,441,441,441,441,441,441,441,-441,441,441,441,441,441,441,441,441,441,441,441,441,441,441,441,-441,441,441,441,441,441,441,441,441,441,441,441,441,441,441,109,-442,442,442,442,442,442,442,442,442,442,442,442,442,442,442,442,-442,442,442,442,442,442,442,442,442,442,442,442,442,442,442,442,-442,442,442,442,442,442,442,442,442,442,442,442,442,442,442,109,- 30, 31,443,444,445,446,447, 30, 31, 30, 31, 30, 31,448,449,450,-451, 33, 30, 31, 33, 30, 31, 33, 33, 33, 33, 33,101,101,452,452,--/* block 81 */-153,154,153,154,153,154,153,154,153,154,153,154,153,154,153,154,-153,154,153,154,153,154,153,154,153,154,153,154,153,154,153,154,-153,154,153,154,153,154,153,154,153,154,153,154,153,154,153,154,-153,154,153,154,153,154,153,154,153,154,153,154,153,154,153,154,-153,154,153,154,153,154,153,154,153,154,153,154,153,154,153,154,-153,154,153,154,153,154,153,154,153,154,153,154,153,154,153,154,-153,154,153,154,453,454,454,454,454,454,454,153,154,153,154,455,-455,455,153,154,109,109,109,109,109,456,456,456,456,457,456,456,--/* block 82 */-458,458,458,458,458,458,458,458,458,458,458,458,458,458,458,458,-458,458,458,458,458,458,458,458,458,458,458,458,458,458,458,458,-458,458,458,458,458,458,109,458,109,109,109,109,109,458,109,109,-459,459,459,459,459,459,459,459,459,459,459,459,459,459,459,459,-459,459,459,459,459,459,459,459,459,459,459,459,459,459,459,459,-459,459,459,459,459,459,459,459,459,459,459,459,459,459,459,459,-459,459,459,459,459,459,459,459,109,109,109,109,109,109,109,460,-461,109,109,109,109,109,109,109,109,109,109,109,109,109,109,462,--/* block 83 */-308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,308,-308,308,308,308,308,308,308,109,109,109,109,109,109,109,109,109,-308,308,308,308,308,308,308,109,308,308,308,308,308,308,308,109,-308,308,308,308,308,308,308,109,308,308,308,308,308,308,308,109,-308,308,308,308,308,308,308,109,308,308,308,308,308,308,308,109,-308,308,308,308,308,308,308,109,308,308,308,308,308,308,308,109,-170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,-170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,--/* block 84 */- 4, 4, 21, 25, 21, 25, 4, 4, 4, 21, 25, 4, 21, 25, 4, 4,- 4, 4, 4, 4, 4, 4, 4, 9, 4, 4, 9, 4, 21, 25, 4, 4,- 21, 25, 6, 7, 6, 7, 6, 7, 6, 7, 4, 4, 4, 4, 4,102,- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 9, 9,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 85 */-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,109,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 86 */-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,--/* block 87 */-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,463,-463,463,463,463,463,463,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,--/* block 88 */- 3, 4, 4, 4, 19,464,396,465, 6, 7, 6, 7, 6, 7, 6, 7,- 6, 7, 19, 19, 6, 7, 6, 7, 6, 7, 6, 7, 9, 6, 7, 7,- 19,465,465,465,465,465,465,465,465,465,104,104,104,104,466,466,- 9,102,102,102,102,102, 19, 19,465,465,465,464,396, 4, 19, 19,-109,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,-467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,-467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,-467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,--/* block 89 */-467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,-467,467,467,467,467,467,467,109,109,104,104, 14, 14,468,468,467,- 9,469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,-469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,-469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,-469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,-469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,-469,469,469,469,469,469,469,469,469,469,469, 4,102,470,470,469,--/* block 90 */-109,109,109,109,109,471,471,471,471,471,471,471,471,471,471,471,-471,471,471,471,471,471,471,471,471,471,471,471,471,471,471,471,-471,471,471,471,471,471,471,471,471,471,471,471,471,471,109,109,-109,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,-472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,-472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,-472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,-472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,--/* block 91 */-472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,109,- 19, 19, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,-471,471,471,471,471,471,471,471,471,471,471,471,471,471,471,471,-471,471,471,471,471,471,471,471,471,471,471,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,109,109,109,-469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,--/* block 92 */-473,473,473,473,473,473,473,473,473,473,473,473,473,473,473,473,-473,473,473,473,473,473,473,473,473,473,473,473,473,473,473,109,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 23, 23, 23, 23, 23, 23, 23, 23,- 19, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,-473,473,473,473,473,473,473,473,473,473,473,473,473,473,473,473,-473,473,473,473,473,473,473,473,473,473,473,473,473,473,473, 19,--/* block 93 */- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,-474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,-474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,-474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,109,--/* block 94 */-474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,-474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,-474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,-474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,-474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,474,-474,474,474,474,474,474,474,474, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,--/* block 95 */-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,--/* block 96 */-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,--/* block 97 */-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 98 */-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,477,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,--/* block 99 */-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,-476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,--/* block 100 */-476,476,476,476,476,476,476,476,476,476,476,476,476,109,109,109,-478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,-478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,-478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,-478,478,478,478,478,478,478,109,109,109,109,109,109,109,109,109,-479,479,479,479,479,479,479,479,479,479,479,479,479,479,479,479,-479,479,479,479,479,479,479,479,479,479,479,479,479,479,479,479,-479,479,479,479,479,479,479,479,480,480,480,480,480,480,481,481,--/* block 101 */-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,--/* block 102 */-482,482,482,482,482,482,482,482,482,482,482,482,483,484,484,484,-482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,-485,485,485,485,485,485,485,485,485,485,482,482,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,167,168,167,168,167,168,486,170,-171,171,171,487,170,170,170,170,170,170,170,170,170,170,487,398,--/* block 103 */-167,168,167,168,167,168,167,168,167,168,167,168,167,168,167,168,-167,168,167,168,167,168,167,168,109,109,109,109,109,109,109,170,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,489,489,489,489,489,489,489,489,489,489,-490,490,491,491,491,491,491,491,109,109,109,109,109,109,109,109,--/* block 104 */- 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,- 14, 14, 14, 14, 14, 14, 14,102,102,102,102,102,102,102,102,102,- 14, 14, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 33, 33, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,-101, 33, 33, 33, 33, 33, 33, 33, 33, 30, 31, 30, 31,492, 30, 31,--/* block 105 */- 30, 31, 30, 31, 30, 31, 30, 31,102, 14, 14, 30, 31,493, 33,109,- 30, 31, 30, 31,109,109,109,109,109,109,109,109,109,109,109,109,- 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,494,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,101,101, 33, 20, 20, 20, 20, 20,--/* block 106 */-495,495,496,495,495,495,496,495,495,495,495,496,495,495,495,495,-495,495,495,495,495,495,495,495,495,495,495,495,495,495,495,495,-495,495,495,497,497,496,496,497,498,498,498,498,109,109,109,109,- 23, 23, 23, 23, 23, 23, 19, 19, 5, 19,109,109,109,109,109,109,-499,499,499,499,499,499,499,499,499,499,499,499,499,499,499,499,-499,499,499,499,499,499,499,499,499,499,499,499,499,499,499,499,-499,499,499,499,499,499,499,499,499,499,499,499,499,499,499,499,-499,499,499,499,500,500,500,500,109,109,109,109,109,109,109,109,--/* block 107 */-501,501,502,502,502,502,502,502,502,502,502,502,502,502,502,502,-502,502,502,502,502,502,502,502,502,502,502,502,502,502,502,502,-502,502,502,502,502,502,502,502,502,502,502,502,502,502,502,502,-502,502,502,502,501,501,501,501,501,501,501,501,501,501,501,501,-501,501,501,501,503,109,109,109,109,109,109,109,109,109,504,504,-505,505,505,505,505,505,505,505,505,505,109,109,109,109,109,109,-213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,-213,213,215,215,215,215,215,215,217,217,217,215,109,109,109,109,--/* block 108 */-506,506,506,506,506,506,506,506,506,506,507,507,507,507,507,507,-507,507,507,507,507,507,507,507,507,507,507,507,507,507,507,507,-507,507,507,507,507,507,508,508,508,508,508,508,508,508,509,509,-510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,510,-510,510,510,510,510,510,510,511,511,511,511,511,511,511,511,511,-511,511,512,512,109,109,109,109,109,109,109,109,109,109,109,513,-305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,305,-305,305,305,305,305,305,305,305,305,305,305,305,305,109,109,109,--/* block 109 */-514,514,514,515,516,516,516,516,516,516,516,516,516,516,516,516,-516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,-516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,-516,516,516,514,515,515,514,514,514,514,515,515,514,515,515,515,-515,517,517,517,517,517,517,517,517,517,517,517,517,517,109,102,-518,518,518,518,518,518,518,518,518,518,109,109,109,109,517,517,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 110 */-519,519,519,519,519,519,519,519,519,519,519,519,519,519,519,519,-519,519,519,519,519,519,519,519,519,519,519,519,519,519,519,519,-519,519,519,519,519,519,519,519,519,520,520,520,520,520,520,521,-521,520,520,521,521,520,520,109,109,109,109,109,109,109,109,109,-519,519,519,520,519,519,519,519,519,519,519,519,520,521,109,109,-522,522,522,522,522,522,522,522,522,522,109,109,523,523,523,523,-295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,-524,295,295,295,295,295,295,301,301,301,295,296,109,109,109,109,--/* block 111 */-525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,-525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,-525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,525,-526,525,526,526,526,525,525,526,526,525,525,525,525,525,526,526,-525,526,525,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,525,525,527,528,528,-529,529,529,529,529,529,529,529,529,529,529,530,531,531,530,530,-532,532,529,533,533,530,531,109,109,109,109,109,109,109,109,109,--/* block 112 */-109,308,308,308,308,308,308,109,109,308,308,308,308,308,308,109,-109,308,308,308,308,308,308,109,109,109,109,109,109,109,109,109,-308,308,308,308,308,308,308,109,308,308,308,308,308,308,308,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 113 */-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-529,529,529,529,529,529,529,529,529,529,529,529,529,529,529,529,-529,529,529,529,529,529,529,529,529,529,529,529,529,529,529,529,-529,529,529,530,530,531,530,530,531,530,530,532,530,531,109,109,-534,534,534,534,534,534,534,534,534,534,109,109,109,109,109,109,--/* block 114 */-535,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,535,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,535,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-535,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,--/* block 115 */-536,536,536,536,536,536,536,536,536,536,536,536,535,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,535,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-535,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,535,536,536,536,--/* block 116 */-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,535,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-535,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,535,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,--/* block 117 */-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,535,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-535,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,535,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,--/* block 118 */-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,535,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-535,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,535,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,--/* block 119 */-536,536,536,536,535,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-535,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,535,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,535,536,536,536,536,536,536,536,536,536,536,536,--/* block 120 */-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-535,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,535,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,535,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,--/* block 121 */-536,536,536,536,536,536,536,536,535,536,536,536,536,536,536,536,-536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,536,-536,536,536,536,109,109,109,109,109,109,109,109,109,109,109,109,-306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,306,-306,306,306,306,306,306,306,109,109,109,109,307,307,307,307,307,-307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,-307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,307,-307,307,307,307,307,307,307,307,307,307,307,307,109,109,109,109,--/* block 122 */-537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,-537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,-537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,-537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,-537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,-537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,-537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,-537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,537,--/* block 123 */-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,--/* block 124 */-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,109,109,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,--/* block 125 */-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 126 */- 33, 33, 33, 33, 33, 33, 33,109,109,109,109,109,109,109,109,109,-109,109,109,178,178,178,178,178,109,109,109,109,109,184,181,184,-184,184,184,184,184,184,184,184,184,539,184,184,184,184,184,184,-184,184,184,184,184,184,184,109,184,184,184,184,184,109,184,109,-184,184,109,184,184,109,184,184,184,184,184,184,184,184,184,184,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,--/* block 127 */-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,540,540,540,540,540,540,540,540,540,540,540,540,540,540,-540,540,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,--/* block 128 */-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,--/* block 129 */-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191, 6, 7,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,--/* block 130 */-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-109,109,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-191,191,191,191,191,191,191,191,191,191,191,191,188, 19,109,109,--/* block 131 */-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,- 4, 4, 4, 4, 4, 4, 4, 6, 7, 4,109,109,109,109,109,109,-104,104,104,104,104,104,104,109,109,109,109,109,109,109,109,109,- 4, 9, 9, 15, 15, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6,- 7, 6, 7, 6, 7, 4, 4, 6, 7, 4, 4, 4, 4, 15, 15, 15,- 4, 4, 4,109, 4, 4, 4, 4, 9, 6, 7, 6, 7, 6, 7, 4,- 4, 4, 8, 9, 8, 8, 8,109, 4, 5, 4, 4,109,109,109,109,-191,191,191,191,191,109,191,191,191,191,191,191,191,191,191,191,--/* block 132 */-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,109,109, 22,--/* block 133 */-109, 4, 4, 4, 5, 4, 4, 4, 6, 7, 4, 8, 4, 9, 4, 4,- 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 4, 4, 8, 8, 8, 4,- 4, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,- 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 6, 4, 7, 14, 15,- 14, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 6, 8, 7, 8, 6,- 7, 4, 6, 7, 4, 4,469,469,469,469,469,469,469,469,469,469,-102,469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,--/* block 134 */-469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,469,-469,469,469,469,469,469,469,469,469,469,469,469,469,469,541,541,-472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,-472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,109,-109,109,472,472,472,472,472,472,109,109,472,472,472,472,472,472,-109,109,472,472,472,472,472,472,109,109,472,472,472,109,109,109,- 5, 5, 8, 14, 19, 5, 5,109, 19, 8, 8, 8, 8, 19, 19,109,-426,426,426,426,426,426,426,426,426, 22, 22, 22, 19, 19,109,109,--/* block 135 */-542,542,542,542,542,542,542,542,542,542,542,542,109,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,109,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,109,542,542,109,542,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,109,109,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 136 */-542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,542,-542,542,542,542,542,542,542,542,542,542,542,109,109,109,109,109,--/* block 137 */- 4, 4, 4,109,109,109,109, 23, 23, 23, 23, 23, 23, 23, 23, 23,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,- 23, 23, 23, 23,109,109,109, 19, 19, 19, 19, 19, 19, 19, 19, 19,-543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,-543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,-543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,-543,543,543,543,543,544,544,544,544,545,545,545,545,545,545,545,--/* block 138 */-545,545,545,545,545,545,545,545,545,545,544,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,104,109,109,--/* block 139 */-546,546,546,546,546,546,546,546,546,546,546,546,546,546,546,546,-546,546,546,546,546,546,546,546,546,546,546,546,546,109,109,109,-547,547,547,547,547,547,547,547,547,547,547,547,547,547,547,547,-547,547,547,547,547,547,547,547,547,547,547,547,547,547,547,547,-547,547,547,547,547,547,547,547,547,547,547,547,547,547,547,547,-547,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 140 */-548,548,548,548,548,548,548,548,548,548,548,548,548,548,548,548,-548,548,548,548,548,548,548,548,548,548,548,548,548,548,548,109,-549,549,549,549,109,109,109,109,109,109,109,109,109,109,109,109,-550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,-550,551,550,550,550,550,550,550,550,550,551,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 141 */-552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,-552,552,552,552,552,552,552,552,552,552,552,552,552,552,109,553,-554,554,554,554,554,554,554,554,554,554,554,554,554,554,554,554,-554,554,554,554,554,554,554,554,554,554,554,554,554,554,554,554,-554,554,554,554,109,109,109,109,554,554,554,554,554,554,554,554,-555,556,556,556,556,556,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 142 */-557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,-557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,-557,557,557,557,557,557,557,557,558,558,558,558,558,558,558,558,-558,558,558,558,558,558,558,558,558,558,558,558,558,558,558,558,-558,558,558,558,558,558,558,558,558,558,558,558,558,558,558,558,-559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,-559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,-559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,--/* block 143 */-560,560,560,560,560,560,560,560,560,560,560,560,560,560,560,560,-560,560,560,560,560,560,560,560,560,560,560,560,560,560,109,109,-561,561,561,561,561,561,561,561,561,561,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 144 */-562,562,562,562,562,562,109,109,562,109,562,562,562,562,562,562,-562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,-562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,-562,562,562,562,562,562,109,562,562,109,109,109,562,109,109,562,-563,563,563,563,563,563,563,563,563,563,563,563,563,563,563,563,-563,563,563,563,563,563,109,564,565,565,565,565,565,565,565,565,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 145 */-566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,-566,566,566,566,566,566,567,567,567,567,567,567,109,109,109,568,-569,569,569,569,569,569,569,569,569,569,569,569,569,569,569,569,-569,569,569,569,569,569,569,569,569,569,109,109,109,109,109,570,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 146 */-571,571,571,571,571,571,571,571,571,571,571,571,571,571,571,571,-571,571,571,571,571,571,571,571,571,571,571,571,571,571,571,571,-572,572,572,572,572,572,572,572,572,572,572,572,572,572,572,572,-572,572,572,572,572,572,572,572,109,109,109,109,109,109,572,572,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 147 */-573,574,574,574,109,574,574,109,109,109,109,109,574,574,574,574,-573,573,573,573,109,573,573,573,109,573,573,573,573,573,573,573,-573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,-573,573,573,573,109,109,109,109,574,574,574,109,109,109,109,574,-575,575,575,575,575,575,575,575,109,109,109,109,109,109,109,109,-576,576,576,576,576,576,576,576,576,109,109,109,109,109,109,109,-577,577,577,577,577,577,577,577,577,577,577,577,577,577,577,577,-577,577,577,577,577,577,577,577,577,577,577,577,577,578,578,579,--/* block 148 */-580,580,580,580,580,580,580,580,580,580,580,580,580,580,580,580,-580,580,580,580,580,580,580,580,580,580,580,580,580,580,580,580,-580,580,580,580,580,580,580,580,580,580,580,580,580,580,580,580,-580,580,580,580,580,580,109,109,109,581,581,581,581,581,581,581,-582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,-582,582,582,582,582,582,109,109,583,583,583,583,583,583,583,583,-584,584,584,584,584,584,584,584,584,584,584,584,584,584,584,584,-584,584,584,109,109,109,109,109,585,585,585,585,585,585,585,585,--/* block 149 */-586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,-586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,-586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,-586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,-586,586,586,586,586,586,586,586,586,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 150 */-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-587,587,587,587,587,587,587,587,587,587,587,587,587,587,587,587,-587,587,587,587,587,587,587,587,587,587,587,587,587,587,587,109,--/* block 151 */-588,589,588,590,590,590,590,590,590,590,590,590,590,590,590,590,-590,590,590,590,590,590,590,590,590,590,590,590,590,590,590,590,-590,590,590,590,590,590,590,590,590,590,590,590,590,590,590,590,-590,590,590,590,590,590,590,590,589,589,589,589,589,589,589,589,-589,589,589,589,589,589,589,591,591,591,591,591,591,591,109,109,-109,109,592,592,592,592,592,592,592,592,592,592,592,592,592,592,-592,592,592,592,592,592,593,593,593,593,593,593,593,593,593,593,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 152 */-594,594,595,596,596,596,596,596,596,596,596,596,596,596,596,596,-596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,-596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,-595,595,595,594,594,594,594,595,595,594,594,597,597,598,597,597,-597,597,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-599,599,599,599,599,599,599,599,599,599,599,599,599,599,599,599,-599,599,599,599,599,599,599,599,599,109,109,109,109,109,109,109,-600,600,600,600,600,600,600,600,600,600,109,109,109,109,109,109,--/* block 153 */-601,601,601,602,602,602,602,602,602,602,602,602,602,602,602,602,-602,602,602,602,602,602,602,602,602,602,602,602,602,602,602,602,-602,602,602,602,602,602,602,601,601,601,601,601,603,601,601,601,-601,601,601,601,601,109,604,604,604,604,604,604,604,604,604,604,-605,605,605,605,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 154 */-606,606,607,608,608,608,608,608,608,608,608,608,608,608,608,608,-608,608,608,608,608,608,608,608,608,608,608,608,608,608,608,608,-608,608,608,608,608,608,608,608,608,608,608,608,608,608,608,608,-608,608,608,607,607,607,606,606,606,606,606,606,606,606,606,607,-607,608,608,608,608,609,609,609,609,109,109,109,109,109,109,109,-610,610,610,610,610,610,610,610,610,610,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 155 */-611,611,611,611,611,611,611,611,611,611,611,611,611,611,611,611,-611,611,611,611,611,611,611,611,611,611,611,611,611,611,611,611,-611,611,611,611,611,611,611,611,611,611,611,612,613,612,613,613,-612,612,612,612,612,612,613,612,109,109,109,109,109,109,109,109,-614,614,614,614,614,614,614,614,614,614,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 156 */-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,--/* block 157 */-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,-615,615,615,615,615,615,615,615,615,615,615,615,615,615,615,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 158 */-616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,-616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,-616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,-616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,-616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,-616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,-616,616,616,109,109,109,109,109,109,109,109,109,109,109,109,109,-617,617,617,617,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 159 */-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,--/* block 160 */-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,-618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 161 */-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,--/* block 162 */-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,-488,488,488,488,488,488,488,488,488,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 163 */-619,619,619,619,619,619,619,619,619,619,619,619,619,619,619,619,-619,619,619,619,619,619,619,619,619,619,619,619,619,619,619,619,-619,619,619,619,619,619,619,619,619,619,619,619,619,619,619,619,-619,619,619,619,619,619,619,619,619,619,619,619,619,619,619,619,-619,619,619,619,619,109,109,109,109,109,109,109,109,109,109,109,-619,620,620,620,620,620,620,620,620,620,620,620,620,620,620,620,-620,620,620,620,620,620,620,620,620,620,620,620,620,620,620,620,-620,620,620,620,620,620,620,620,620,620,620,620,620,620,620,109,--/* block 164 */-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,621,-621,621,621,622,622,622,622,622,622,622,622,622,622,622,622,622,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 165 */-469,467,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 166 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,109,--/* block 167 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19,109,109, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19,623,395,104,104,104, 19, 19, 19,395,623,623,-623,623,623, 22, 22, 22, 22, 22, 22, 22, 22,104,104,104,104,104,--/* block 168 */-104,104,104, 19, 19,104,104,104,104,104,104,104, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,104,104,104,104, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 169 */-545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,-545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,-545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,-545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,545,-545,545,624,624,624,545,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 170 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,- 23, 23,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 171 */-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,429,429,-429,429,429,429,429,109,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,--/* block 172 */-428,428,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,428,109,428,428,-109,109,428,109,109,428,428,109,109,428,428,428,428,109,428,428,-428,428,428,428,428,428,429,429,429,429,109,429,109,429,429,429,-429,429,429,429,109,429,429,429,429,429,429,429,429,429,429,429,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,--/* block 173 */-429,429,429,429,428,428,109,428,428,428,428,109,109,428,428,428,-428,428,428,428,428,109,428,428,428,428,428,428,428,109,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,428,428,109,428,428,428,428,109,-428,428,428,428,428,109,428,109,109,109,428,428,428,428,428,428,-428,109,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,--/* block 174 */-428,428,428,428,428,428,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,--/* block 175 */-429,429,429,429,429,429,429,429,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,--/* block 176 */-428,428,428,428,428,428,428,428,428,428,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,109,109,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428, 8,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429, 8,429,429,429,429,-429,429,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428, 8,429,429,429,429,--/* block 177 */-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429, 8,429,429,429,429,429,429,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428, 8,429,429,429,429,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429, 8,-429,429,429,429,429,429,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428, 8,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,--/* block 178 */-429,429,429,429,429,429,429,429,429, 8,429,429,429,429,429,429,-428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,428,-428,428,428,428,428,428,428,428,428, 8,429,429,429,429,429,429,-429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,429,-429,429,429, 8,429,429,429,429,429,429,428,429,109,109, 10, 10,- 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,- 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,- 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,--/* block 179 */-191,191,191,191,109,191,191,191,191,191,191,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,191,-109,191,191,109,191,109,109,191,109,191,191,191,191,191,191,191,-191,191,191,109,191,191,191,191,109,191,109,191,109,109,109,109,-109,109,191,109,109,109,109,191,109,191,109,191,109,191,191,191,-109,191,191,109,191,109,109,191,109,191,109,191,109,191,109,191,-109,191,191,109,191,109,109,191,191,191,191,109,191,191,191,191,-191,191,191,109,191,191,191,191,109,191,191,191,191,109,191,109,--/* block 180 */-191,191,191,191,191,191,191,191,191,191,109,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,109,109,109,109,-109,191,191,191,109,191,191,191,191,191,109,191,191,191,191,191,-191,191,191,191,191,191,191,191,191,191,191,191,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-186,186,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 181 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,--/* block 182 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,-109, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,-109, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,-109, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 183 */- 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,--/* block 184 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,625,625,625,625,625,625,625,625,625,625,-625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,--/* block 185 */-626, 19, 19,109,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,109,109,109,- 19, 19,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 186 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19,109, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,--/* block 187 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19,109, 19, 19, 19, 19, 19,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 188 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,- 19,109, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,--/* block 189 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19,109, 19, 19, 19, 19,109,109,109,--/* block 190 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,- 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,109,109,109,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 191 */-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109, 19, 19, 19, 19, 19,--/* block 192 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19,109,109,109,109, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 193 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 194 */- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,- 19, 19, 19, 19,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 195 */-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 196 */-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,109,109,109,109,109,109,109,109,109,109,109,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,--/* block 197 */-475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,475,-475,475,475,475,475,475,475,475,475,475,475,475,475,475,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,-109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,--/* block 198 */-426, 22,426,426,426,426,426,426,426,426,426,426,426,426,426,426,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,- 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,--/* block 199 */-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,--/* block 200 */-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,--/* block 201 */-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,-426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,426,--/* block 202 */-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,538,-538,538,538,538,538,538,538,538,538,538,538,538,538,538,109,109,+/* Total size: 72576 bytes, block size: 128. */++/* The tables herein are needed only when UCP support is built+into PCRE. This module should not be referenced otherwise, so+it should not matter whether it is compiled or not. However+a comment was received about space saving - maybe the guy linked+all the modules rather than using a library - so we include a+condition to cut out the tables when not needed. But don't leave+a totally empty module because some compilers barf at that.+Instead, just supply small dummy tables. */++#ifndef SUPPORT_UCP+const ucd_record PRIV(ucd_records)[] = {{0,0,0,0,0 }};+const pcre_uint8 PRIV(ucd_stage1)[] = {0};+const pcre_uint16 PRIV(ucd_stage2)[] = {0};+const pcre_uint32 PRIV(ucd_caseless_sets)[] = {0};+#else++/* If the 32-bit library is run in non-32-bit mode, character values+greater than 0x10ffff may be encountered. For these we set up a+special record. */++#ifdef COMPILE_PCRE32+const ucd_record PRIV(dummy_ucd_record)[] = {{+ ucp_Common, /* script */+ ucp_Cn, /* type unassigned */+ ucp_gbOther, /* grapheme break property */+ 0, /* case set */+ 0, /* other case */+ }};+#endif++/* When recompiling tables with a new Unicode version, please check the+types in this structure definition from pcre_internal.h (the actual+field names will be different):++typedef struct {+pcre_uint8 property_0;+pcre_uint8 property_1;+pcre_uint8 property_2;+pcre_uint8 property_3;+pcre_int32 property_4;+} ucd_record;+*/+++const pcre_uint32 PRIV(ucd_caseless_sets)[] = {+ NOTACHAR,+ 0x0053, 0x0073, 0x017f, NOTACHAR,+ 0x01c4, 0x01c5, 0x01c6, NOTACHAR,+ 0x01c7, 0x01c8, 0x01c9, NOTACHAR,+ 0x01ca, 0x01cb, 0x01cc, NOTACHAR,+ 0x01f1, 0x01f2, 0x01f3, NOTACHAR,+ 0x0345, 0x0399, 0x03b9, 0x1fbe, NOTACHAR,+ 0x00b5, 0x039c, 0x03bc, NOTACHAR,+ 0x03a3, 0x03c2, 0x03c3, NOTACHAR,+ 0x0392, 0x03b2, 0x03d0, NOTACHAR,+ 0x0398, 0x03b8, 0x03d1, 0x03f4, NOTACHAR,+ 0x03a6, 0x03c6, 0x03d5, NOTACHAR,+ 0x03a0, 0x03c0, 0x03d6, NOTACHAR,+ 0x039a, 0x03ba, 0x03f0, NOTACHAR,+ 0x03a1, 0x03c1, 0x03f1, NOTACHAR,+ 0x0395, 0x03b5, 0x03f5, NOTACHAR,+ 0x1e60, 0x1e61, 0x1e9b, NOTACHAR,+ 0x03a9, 0x03c9, 0x2126, NOTACHAR,+ 0x004b, 0x006b, 0x212a, NOTACHAR,+ 0x00c5, 0x00e5, 0x212b, NOTACHAR,+};++/* When #included in pcretest, we don't need this large table. */++#ifndef PCRE_INCLUDED++const ucd_record PRIV(ucd_records)[] = { /* 5760 bytes, record size 8 */+ { 9, 0, 2, 0, 0, }, /* 0 */+ { 9, 0, 1, 0, 0, }, /* 1 */+ { 9, 0, 0, 0, 0, }, /* 2 */+ { 9, 29, 12, 0, 0, }, /* 3 */+ { 9, 21, 12, 0, 0, }, /* 4 */+ { 9, 23, 12, 0, 0, }, /* 5 */+ { 9, 22, 12, 0, 0, }, /* 6 */+ { 9, 18, 12, 0, 0, }, /* 7 */+ { 9, 25, 12, 0, 0, }, /* 8 */+ { 9, 17, 12, 0, 0, }, /* 9 */+ { 9, 13, 12, 0, 0, }, /* 10 */+ { 33, 9, 12, 0, 32, }, /* 11 */+ { 33, 9, 12, 71, 32, }, /* 12 */+ { 33, 9, 12, 1, 32, }, /* 13 */+ { 9, 24, 12, 0, 0, }, /* 14 */+ { 9, 16, 12, 0, 0, }, /* 15 */+ { 33, 5, 12, 0, -32, }, /* 16 */+ { 33, 5, 12, 71, -32, }, /* 17 */+ { 33, 5, 12, 1, -32, }, /* 18 */+ { 9, 26, 12, 0, 0, }, /* 19 */+ { 33, 7, 12, 0, 0, }, /* 20 */+ { 9, 20, 12, 0, 0, }, /* 21 */+ { 9, 1, 2, 0, 0, }, /* 22 */+ { 9, 15, 12, 0, 0, }, /* 23 */+ { 9, 5, 12, 26, 775, }, /* 24 */+ { 9, 19, 12, 0, 0, }, /* 25 */+ { 33, 9, 12, 75, 32, }, /* 26 */+ { 33, 5, 12, 0, 7615, }, /* 27 */+ { 33, 5, 12, 75, -32, }, /* 28 */+ { 33, 5, 12, 0, 121, }, /* 29 */+ { 33, 9, 12, 0, 1, }, /* 30 */+ { 33, 5, 12, 0, -1, }, /* 31 */+ { 33, 9, 12, 0, 0, }, /* 32 */+ { 33, 5, 12, 0, 0, }, /* 33 */+ { 33, 9, 12, 0, -121, }, /* 34 */+ { 33, 5, 12, 1, -268, }, /* 35 */+ { 33, 5, 12, 0, 195, }, /* 36 */+ { 33, 9, 12, 0, 210, }, /* 37 */+ { 33, 9, 12, 0, 206, }, /* 38 */+ { 33, 9, 12, 0, 205, }, /* 39 */+ { 33, 9, 12, 0, 79, }, /* 40 */+ { 33, 9, 12, 0, 202, }, /* 41 */+ { 33, 9, 12, 0, 203, }, /* 42 */+ { 33, 9, 12, 0, 207, }, /* 43 */+ { 33, 5, 12, 0, 97, }, /* 44 */+ { 33, 9, 12, 0, 211, }, /* 45 */+ { 33, 9, 12, 0, 209, }, /* 46 */+ { 33, 5, 12, 0, 163, }, /* 47 */+ { 33, 9, 12, 0, 213, }, /* 48 */+ { 33, 5, 12, 0, 130, }, /* 49 */+ { 33, 9, 12, 0, 214, }, /* 50 */+ { 33, 9, 12, 0, 218, }, /* 51 */+ { 33, 9, 12, 0, 217, }, /* 52 */+ { 33, 9, 12, 0, 219, }, /* 53 */+ { 33, 5, 12, 0, 56, }, /* 54 */+ { 33, 9, 12, 5, 2, }, /* 55 */+ { 33, 8, 12, 5, 1, }, /* 56 */+ { 33, 5, 12, 5, -2, }, /* 57 */+ { 33, 9, 12, 9, 2, }, /* 58 */+ { 33, 8, 12, 9, 1, }, /* 59 */+ { 33, 5, 12, 9, -2, }, /* 60 */+ { 33, 9, 12, 13, 2, }, /* 61 */+ { 33, 8, 12, 13, 1, }, /* 62 */+ { 33, 5, 12, 13, -2, }, /* 63 */+ { 33, 5, 12, 0, -79, }, /* 64 */+ { 33, 9, 12, 17, 2, }, /* 65 */+ { 33, 8, 12, 17, 1, }, /* 66 */+ { 33, 5, 12, 17, -2, }, /* 67 */+ { 33, 9, 12, 0, -97, }, /* 68 */+ { 33, 9, 12, 0, -56, }, /* 69 */+ { 33, 9, 12, 0, -130, }, /* 70 */+ { 33, 9, 12, 0, 10795, }, /* 71 */+ { 33, 9, 12, 0, -163, }, /* 72 */+ { 33, 9, 12, 0, 10792, }, /* 73 */+ { 33, 5, 12, 0, 10815, }, /* 74 */+ { 33, 9, 12, 0, -195, }, /* 75 */+ { 33, 9, 12, 0, 69, }, /* 76 */+ { 33, 9, 12, 0, 71, }, /* 77 */+ { 33, 5, 12, 0, 10783, }, /* 78 */+ { 33, 5, 12, 0, 10780, }, /* 79 */+ { 33, 5, 12, 0, 10782, }, /* 80 */+ { 33, 5, 12, 0, -210, }, /* 81 */+ { 33, 5, 12, 0, -206, }, /* 82 */+ { 33, 5, 12, 0, -205, }, /* 83 */+ { 33, 5, 12, 0, -202, }, /* 84 */+ { 33, 5, 12, 0, -203, }, /* 85 */+ { 33, 5, 12, 0, 42319, }, /* 86 */+ { 33, 5, 12, 0, 42315, }, /* 87 */+ { 33, 5, 12, 0, -207, }, /* 88 */+ { 33, 5, 12, 0, 42280, }, /* 89 */+ { 33, 5, 12, 0, 42308, }, /* 90 */+ { 33, 5, 12, 0, -209, }, /* 91 */+ { 33, 5, 12, 0, -211, }, /* 92 */+ { 33, 5, 12, 0, 10743, }, /* 93 */+ { 33, 5, 12, 0, 42305, }, /* 94 */+ { 33, 5, 12, 0, 10749, }, /* 95 */+ { 33, 5, 12, 0, -213, }, /* 96 */+ { 33, 5, 12, 0, -214, }, /* 97 */+ { 33, 5, 12, 0, 10727, }, /* 98 */+ { 33, 5, 12, 0, -218, }, /* 99 */+ { 33, 5, 12, 0, 42282, }, /* 100 */+ { 33, 5, 12, 0, -69, }, /* 101 */+ { 33, 5, 12, 0, -217, }, /* 102 */+ { 33, 5, 12, 0, -71, }, /* 103 */+ { 33, 5, 12, 0, -219, }, /* 104 */+ { 33, 5, 12, 0, 42258, }, /* 105 */+ { 33, 6, 12, 0, 0, }, /* 106 */+ { 9, 6, 12, 0, 0, }, /* 107 */+ { 3, 24, 12, 0, 0, }, /* 108 */+ { 27, 12, 3, 0, 0, }, /* 109 */+ { 27, 12, 3, 21, 116, }, /* 110 */+ { 19, 9, 12, 0, 1, }, /* 111 */+ { 19, 5, 12, 0, -1, }, /* 112 */+ { 19, 24, 12, 0, 0, }, /* 113 */+ { 9, 2, 12, 0, 0, }, /* 114 */+ { 19, 6, 12, 0, 0, }, /* 115 */+ { 19, 5, 12, 0, 130, }, /* 116 */+ { 19, 9, 12, 0, 116, }, /* 117 */+ { 19, 9, 12, 0, 38, }, /* 118 */+ { 19, 9, 12, 0, 37, }, /* 119 */+ { 19, 9, 12, 0, 64, }, /* 120 */+ { 19, 9, 12, 0, 63, }, /* 121 */+ { 19, 5, 12, 0, 0, }, /* 122 */+ { 19, 9, 12, 0, 32, }, /* 123 */+ { 19, 9, 12, 34, 32, }, /* 124 */+ { 19, 9, 12, 59, 32, }, /* 125 */+ { 19, 9, 12, 38, 32, }, /* 126 */+ { 19, 9, 12, 21, 32, }, /* 127 */+ { 19, 9, 12, 51, 32, }, /* 128 */+ { 19, 9, 12, 26, 32, }, /* 129 */+ { 19, 9, 12, 47, 32, }, /* 130 */+ { 19, 9, 12, 55, 32, }, /* 131 */+ { 19, 9, 12, 30, 32, }, /* 132 */+ { 19, 9, 12, 43, 32, }, /* 133 */+ { 19, 9, 12, 67, 32, }, /* 134 */+ { 19, 5, 12, 0, -38, }, /* 135 */+ { 19, 5, 12, 0, -37, }, /* 136 */+ { 19, 5, 12, 0, -32, }, /* 137 */+ { 19, 5, 12, 34, -32, }, /* 138 */+ { 19, 5, 12, 59, -32, }, /* 139 */+ { 19, 5, 12, 38, -32, }, /* 140 */+ { 19, 5, 12, 21, -116, }, /* 141 */+ { 19, 5, 12, 51, -32, }, /* 142 */+ { 19, 5, 12, 26, -775, }, /* 143 */+ { 19, 5, 12, 47, -32, }, /* 144 */+ { 19, 5, 12, 55, -32, }, /* 145 */+ { 19, 5, 12, 30, 1, }, /* 146 */+ { 19, 5, 12, 30, -32, }, /* 147 */+ { 19, 5, 12, 43, -32, }, /* 148 */+ { 19, 5, 12, 67, -32, }, /* 149 */+ { 19, 5, 12, 0, -64, }, /* 150 */+ { 19, 5, 12, 0, -63, }, /* 151 */+ { 19, 9, 12, 0, 8, }, /* 152 */+ { 19, 5, 12, 34, -30, }, /* 153 */+ { 19, 5, 12, 38, -25, }, /* 154 */+ { 19, 9, 12, 0, 0, }, /* 155 */+ { 19, 5, 12, 43, -15, }, /* 156 */+ { 19, 5, 12, 47, -22, }, /* 157 */+ { 19, 5, 12, 0, -8, }, /* 158 */+ { 10, 9, 12, 0, 1, }, /* 159 */+ { 10, 5, 12, 0, -1, }, /* 160 */+ { 19, 5, 12, 51, -54, }, /* 161 */+ { 19, 5, 12, 55, -48, }, /* 162 */+ { 19, 5, 12, 0, 7, }, /* 163 */+ { 19, 5, 12, 0, -116, }, /* 164 */+ { 19, 9, 12, 38, -60, }, /* 165 */+ { 19, 5, 12, 59, -64, }, /* 166 */+ { 19, 25, 12, 0, 0, }, /* 167 */+ { 19, 9, 12, 0, -7, }, /* 168 */+ { 19, 9, 12, 0, -130, }, /* 169 */+ { 12, 9, 12, 0, 80, }, /* 170 */+ { 12, 9, 12, 0, 32, }, /* 171 */+ { 12, 5, 12, 0, -32, }, /* 172 */+ { 12, 5, 12, 0, -80, }, /* 173 */+ { 12, 9, 12, 0, 1, }, /* 174 */+ { 12, 5, 12, 0, -1, }, /* 175 */+ { 12, 26, 12, 0, 0, }, /* 176 */+ { 12, 12, 3, 0, 0, }, /* 177 */+ { 12, 11, 3, 0, 0, }, /* 178 */+ { 12, 9, 12, 0, 15, }, /* 179 */+ { 12, 5, 12, 0, -15, }, /* 180 */+ { 1, 9, 12, 0, 48, }, /* 181 */+ { 1, 6, 12, 0, 0, }, /* 182 */+ { 1, 21, 12, 0, 0, }, /* 183 */+ { 1, 5, 12, 0, -48, }, /* 184 */+ { 1, 5, 12, 0, 0, }, /* 185 */+ { 1, 17, 12, 0, 0, }, /* 186 */+ { 1, 26, 12, 0, 0, }, /* 187 */+ { 1, 23, 12, 0, 0, }, /* 188 */+ { 25, 12, 3, 0, 0, }, /* 189 */+ { 25, 17, 12, 0, 0, }, /* 190 */+ { 25, 21, 12, 0, 0, }, /* 191 */+ { 25, 7, 12, 0, 0, }, /* 192 */+ { 0, 1, 2, 0, 0, }, /* 193 */+ { 0, 25, 12, 0, 0, }, /* 194 */+ { 0, 21, 12, 0, 0, }, /* 195 */+ { 0, 23, 12, 0, 0, }, /* 196 */+ { 0, 26, 12, 0, 0, }, /* 197 */+ { 0, 12, 3, 0, 0, }, /* 198 */+ { 0, 7, 12, 0, 0, }, /* 199 */+ { 0, 6, 12, 0, 0, }, /* 200 */+ { 0, 13, 12, 0, 0, }, /* 201 */+ { 49, 21, 12, 0, 0, }, /* 202 */+ { 49, 1, 2, 0, 0, }, /* 203 */+ { 49, 7, 12, 0, 0, }, /* 204 */+ { 49, 12, 3, 0, 0, }, /* 205 */+ { 55, 7, 12, 0, 0, }, /* 206 */+ { 55, 12, 3, 0, 0, }, /* 207 */+ { 63, 13, 12, 0, 0, }, /* 208 */+ { 63, 7, 12, 0, 0, }, /* 209 */+ { 63, 12, 3, 0, 0, }, /* 210 */+ { 63, 6, 12, 0, 0, }, /* 211 */+ { 63, 26, 12, 0, 0, }, /* 212 */+ { 63, 21, 12, 0, 0, }, /* 213 */+ { 89, 7, 12, 0, 0, }, /* 214 */+ { 89, 12, 3, 0, 0, }, /* 215 */+ { 89, 6, 12, 0, 0, }, /* 216 */+ { 89, 21, 12, 0, 0, }, /* 217 */+ { 94, 7, 12, 0, 0, }, /* 218 */+ { 94, 12, 3, 0, 0, }, /* 219 */+ { 94, 21, 12, 0, 0, }, /* 220 */+ { 14, 12, 3, 0, 0, }, /* 221 */+ { 14, 10, 5, 0, 0, }, /* 222 */+ { 14, 7, 12, 0, 0, }, /* 223 */+ { 14, 13, 12, 0, 0, }, /* 224 */+ { 14, 21, 12, 0, 0, }, /* 225 */+ { 14, 6, 12, 0, 0, }, /* 226 */+ { 2, 7, 12, 0, 0, }, /* 227 */+ { 2, 12, 3, 0, 0, }, /* 228 */+ { 2, 10, 5, 0, 0, }, /* 229 */+ { 2, 10, 3, 0, 0, }, /* 230 */+ { 2, 13, 12, 0, 0, }, /* 231 */+ { 2, 23, 12, 0, 0, }, /* 232 */+ { 2, 15, 12, 0, 0, }, /* 233 */+ { 2, 26, 12, 0, 0, }, /* 234 */+ { 21, 12, 3, 0, 0, }, /* 235 */+ { 21, 10, 5, 0, 0, }, /* 236 */+ { 21, 7, 12, 0, 0, }, /* 237 */+ { 21, 13, 12, 0, 0, }, /* 238 */+ { 20, 12, 3, 0, 0, }, /* 239 */+ { 20, 10, 5, 0, 0, }, /* 240 */+ { 20, 7, 12, 0, 0, }, /* 241 */+ { 20, 13, 12, 0, 0, }, /* 242 */+ { 20, 21, 12, 0, 0, }, /* 243 */+ { 20, 23, 12, 0, 0, }, /* 244 */+ { 43, 12, 3, 0, 0, }, /* 245 */+ { 43, 10, 5, 0, 0, }, /* 246 */+ { 43, 7, 12, 0, 0, }, /* 247 */+ { 43, 10, 3, 0, 0, }, /* 248 */+ { 43, 13, 12, 0, 0, }, /* 249 */+ { 43, 26, 12, 0, 0, }, /* 250 */+ { 43, 15, 12, 0, 0, }, /* 251 */+ { 53, 12, 3, 0, 0, }, /* 252 */+ { 53, 7, 12, 0, 0, }, /* 253 */+ { 53, 10, 3, 0, 0, }, /* 254 */+ { 53, 10, 5, 0, 0, }, /* 255 */+ { 53, 13, 12, 0, 0, }, /* 256 */+ { 53, 15, 12, 0, 0, }, /* 257 */+ { 53, 26, 12, 0, 0, }, /* 258 */+ { 53, 23, 12, 0, 0, }, /* 259 */+ { 54, 12, 3, 0, 0, }, /* 260 */+ { 54, 10, 5, 0, 0, }, /* 261 */+ { 54, 7, 12, 0, 0, }, /* 262 */+ { 54, 13, 12, 0, 0, }, /* 263 */+ { 54, 15, 12, 0, 0, }, /* 264 */+ { 54, 26, 12, 0, 0, }, /* 265 */+ { 28, 12, 3, 0, 0, }, /* 266 */+ { 28, 10, 5, 0, 0, }, /* 267 */+ { 28, 7, 12, 0, 0, }, /* 268 */+ { 28, 10, 3, 0, 0, }, /* 269 */+ { 28, 13, 12, 0, 0, }, /* 270 */+ { 36, 12, 3, 0, 0, }, /* 271 */+ { 36, 10, 5, 0, 0, }, /* 272 */+ { 36, 7, 12, 0, 0, }, /* 273 */+ { 36, 10, 3, 0, 0, }, /* 274 */+ { 36, 13, 12, 0, 0, }, /* 275 */+ { 36, 15, 12, 0, 0, }, /* 276 */+ { 36, 26, 12, 0, 0, }, /* 277 */+ { 47, 10, 5, 0, 0, }, /* 278 */+ { 47, 7, 12, 0, 0, }, /* 279 */+ { 47, 12, 3, 0, 0, }, /* 280 */+ { 47, 10, 3, 0, 0, }, /* 281 */+ { 47, 13, 12, 0, 0, }, /* 282 */+ { 47, 21, 12, 0, 0, }, /* 283 */+ { 56, 7, 12, 0, 0, }, /* 284 */+ { 56, 12, 3, 0, 0, }, /* 285 */+ { 56, 7, 5, 0, 0, }, /* 286 */+ { 56, 6, 12, 0, 0, }, /* 287 */+ { 56, 21, 12, 0, 0, }, /* 288 */+ { 56, 13, 12, 0, 0, }, /* 289 */+ { 32, 7, 12, 0, 0, }, /* 290 */+ { 32, 12, 3, 0, 0, }, /* 291 */+ { 32, 7, 5, 0, 0, }, /* 292 */+ { 32, 6, 12, 0, 0, }, /* 293 */+ { 32, 13, 12, 0, 0, }, /* 294 */+ { 57, 7, 12, 0, 0, }, /* 295 */+ { 57, 26, 12, 0, 0, }, /* 296 */+ { 57, 21, 12, 0, 0, }, /* 297 */+ { 57, 12, 3, 0, 0, }, /* 298 */+ { 57, 13, 12, 0, 0, }, /* 299 */+ { 57, 15, 12, 0, 0, }, /* 300 */+ { 57, 22, 12, 0, 0, }, /* 301 */+ { 57, 18, 12, 0, 0, }, /* 302 */+ { 57, 10, 5, 0, 0, }, /* 303 */+ { 38, 7, 12, 0, 0, }, /* 304 */+ { 38, 10, 12, 0, 0, }, /* 305 */+ { 38, 12, 3, 0, 0, }, /* 306 */+ { 38, 10, 5, 0, 0, }, /* 307 */+ { 38, 13, 12, 0, 0, }, /* 308 */+ { 38, 21, 12, 0, 0, }, /* 309 */+ { 38, 26, 12, 0, 0, }, /* 310 */+ { 16, 9, 12, 0, 7264, }, /* 311 */+ { 16, 7, 12, 0, 0, }, /* 312 */+ { 16, 6, 12, 0, 0, }, /* 313 */+ { 23, 7, 6, 0, 0, }, /* 314 */+ { 23, 7, 7, 0, 0, }, /* 315 */+ { 23, 7, 8, 0, 0, }, /* 316 */+ { 15, 7, 12, 0, 0, }, /* 317 */+ { 15, 12, 3, 0, 0, }, /* 318 */+ { 15, 21, 12, 0, 0, }, /* 319 */+ { 15, 15, 12, 0, 0, }, /* 320 */+ { 15, 26, 12, 0, 0, }, /* 321 */+ { 8, 7, 12, 0, 0, }, /* 322 */+ { 7, 17, 12, 0, 0, }, /* 323 */+ { 7, 7, 12, 0, 0, }, /* 324 */+ { 7, 21, 12, 0, 0, }, /* 325 */+ { 40, 29, 12, 0, 0, }, /* 326 */+ { 40, 7, 12, 0, 0, }, /* 327 */+ { 40, 22, 12, 0, 0, }, /* 328 */+ { 40, 18, 12, 0, 0, }, /* 329 */+ { 45, 7, 12, 0, 0, }, /* 330 */+ { 45, 14, 12, 0, 0, }, /* 331 */+ { 50, 7, 12, 0, 0, }, /* 332 */+ { 50, 12, 3, 0, 0, }, /* 333 */+ { 24, 7, 12, 0, 0, }, /* 334 */+ { 24, 12, 3, 0, 0, }, /* 335 */+ { 6, 7, 12, 0, 0, }, /* 336 */+ { 6, 12, 3, 0, 0, }, /* 337 */+ { 51, 7, 12, 0, 0, }, /* 338 */+ { 51, 12, 3, 0, 0, }, /* 339 */+ { 31, 7, 12, 0, 0, }, /* 340 */+ { 31, 12, 3, 0, 0, }, /* 341 */+ { 31, 10, 5, 0, 0, }, /* 342 */+ { 31, 21, 12, 0, 0, }, /* 343 */+ { 31, 6, 12, 0, 0, }, /* 344 */+ { 31, 23, 12, 0, 0, }, /* 345 */+ { 31, 13, 12, 0, 0, }, /* 346 */+ { 31, 15, 12, 0, 0, }, /* 347 */+ { 37, 21, 12, 0, 0, }, /* 348 */+ { 37, 17, 12, 0, 0, }, /* 349 */+ { 37, 12, 3, 0, 0, }, /* 350 */+ { 37, 1, 2, 0, 0, }, /* 351 */+ { 37, 13, 12, 0, 0, }, /* 352 */+ { 37, 7, 12, 0, 0, }, /* 353 */+ { 37, 6, 12, 0, 0, }, /* 354 */+ { 34, 7, 12, 0, 0, }, /* 355 */+ { 34, 12, 3, 0, 0, }, /* 356 */+ { 34, 10, 5, 0, 0, }, /* 357 */+ { 34, 26, 12, 0, 0, }, /* 358 */+ { 34, 21, 12, 0, 0, }, /* 359 */+ { 34, 13, 12, 0, 0, }, /* 360 */+ { 52, 7, 12, 0, 0, }, /* 361 */+ { 39, 7, 12, 0, 0, }, /* 362 */+ { 39, 10, 12, 0, 0, }, /* 363 */+ { 39, 10, 5, 0, 0, }, /* 364 */+ { 39, 13, 12, 0, 0, }, /* 365 */+ { 39, 15, 12, 0, 0, }, /* 366 */+ { 39, 26, 12, 0, 0, }, /* 367 */+ { 31, 26, 12, 0, 0, }, /* 368 */+ { 5, 7, 12, 0, 0, }, /* 369 */+ { 5, 12, 3, 0, 0, }, /* 370 */+ { 5, 10, 5, 0, 0, }, /* 371 */+ { 5, 21, 12, 0, 0, }, /* 372 */+ { 90, 7, 12, 0, 0, }, /* 373 */+ { 90, 10, 5, 0, 0, }, /* 374 */+ { 90, 12, 3, 0, 0, }, /* 375 */+ { 90, 10, 12, 0, 0, }, /* 376 */+ { 90, 13, 12, 0, 0, }, /* 377 */+ { 90, 21, 12, 0, 0, }, /* 378 */+ { 90, 6, 12, 0, 0, }, /* 379 */+ { 27, 11, 3, 0, 0, }, /* 380 */+ { 61, 12, 3, 0, 0, }, /* 381 */+ { 61, 10, 5, 0, 0, }, /* 382 */+ { 61, 7, 12, 0, 0, }, /* 383 */+ { 61, 13, 12, 0, 0, }, /* 384 */+ { 61, 21, 12, 0, 0, }, /* 385 */+ { 61, 26, 12, 0, 0, }, /* 386 */+ { 75, 12, 3, 0, 0, }, /* 387 */+ { 75, 10, 5, 0, 0, }, /* 388 */+ { 75, 7, 12, 0, 0, }, /* 389 */+ { 75, 13, 12, 0, 0, }, /* 390 */+ { 92, 7, 12, 0, 0, }, /* 391 */+ { 92, 12, 3, 0, 0, }, /* 392 */+ { 92, 10, 5, 0, 0, }, /* 393 */+ { 92, 21, 12, 0, 0, }, /* 394 */+ { 69, 7, 12, 0, 0, }, /* 395 */+ { 69, 10, 5, 0, 0, }, /* 396 */+ { 69, 12, 3, 0, 0, }, /* 397 */+ { 69, 21, 12, 0, 0, }, /* 398 */+ { 69, 13, 12, 0, 0, }, /* 399 */+ { 72, 13, 12, 0, 0, }, /* 400 */+ { 72, 7, 12, 0, 0, }, /* 401 */+ { 72, 6, 12, 0, 0, }, /* 402 */+ { 72, 21, 12, 0, 0, }, /* 403 */+ { 75, 21, 12, 0, 0, }, /* 404 */+ { 9, 10, 5, 0, 0, }, /* 405 */+ { 9, 7, 12, 0, 0, }, /* 406 */+ { 12, 5, 12, 0, 0, }, /* 407 */+ { 12, 6, 12, 0, 0, }, /* 408 */+ { 33, 5, 12, 0, 35332, }, /* 409 */+ { 33, 5, 12, 0, 3814, }, /* 410 */+ { 33, 9, 12, 63, 1, }, /* 411 */+ { 33, 5, 12, 63, -1, }, /* 412 */+ { 33, 5, 12, 63, -58, }, /* 413 */+ { 33, 9, 12, 0, -7615, }, /* 414 */+ { 19, 5, 12, 0, 8, }, /* 415 */+ { 19, 9, 12, 0, -8, }, /* 416 */+ { 19, 5, 12, 0, 74, }, /* 417 */+ { 19, 5, 12, 0, 86, }, /* 418 */+ { 19, 5, 12, 0, 100, }, /* 419 */+ { 19, 5, 12, 0, 128, }, /* 420 */+ { 19, 5, 12, 0, 112, }, /* 421 */+ { 19, 5, 12, 0, 126, }, /* 422 */+ { 19, 8, 12, 0, -8, }, /* 423 */+ { 19, 5, 12, 0, 9, }, /* 424 */+ { 19, 9, 12, 0, -74, }, /* 425 */+ { 19, 8, 12, 0, -9, }, /* 426 */+ { 19, 5, 12, 21, -7173, }, /* 427 */+ { 19, 9, 12, 0, -86, }, /* 428 */+ { 19, 9, 12, 0, -100, }, /* 429 */+ { 19, 9, 12, 0, -112, }, /* 430 */+ { 19, 9, 12, 0, -128, }, /* 431 */+ { 19, 9, 12, 0, -126, }, /* 432 */+ { 27, 1, 3, 0, 0, }, /* 433 */+ { 9, 27, 2, 0, 0, }, /* 434 */+ { 9, 28, 2, 0, 0, }, /* 435 */+ { 9, 2, 2, 0, 0, }, /* 436 */+ { 9, 9, 12, 0, 0, }, /* 437 */+ { 9, 5, 12, 0, 0, }, /* 438 */+ { 19, 9, 12, 67, -7517, }, /* 439 */+ { 33, 9, 12, 71, -8383, }, /* 440 */+ { 33, 9, 12, 75, -8262, }, /* 441 */+ { 33, 9, 12, 0, 28, }, /* 442 */+ { 33, 5, 12, 0, -28, }, /* 443 */+ { 33, 14, 12, 0, 16, }, /* 444 */+ { 33, 14, 12, 0, -16, }, /* 445 */+ { 33, 14, 12, 0, 0, }, /* 446 */+ { 9, 26, 12, 0, 26, }, /* 447 */+ { 9, 26, 12, 0, -26, }, /* 448 */+ { 4, 26, 12, 0, 0, }, /* 449 */+ { 17, 9, 12, 0, 48, }, /* 450 */+ { 17, 5, 12, 0, -48, }, /* 451 */+ { 33, 9, 12, 0, -10743, }, /* 452 */+ { 33, 9, 12, 0, -3814, }, /* 453 */+ { 33, 9, 12, 0, -10727, }, /* 454 */+ { 33, 5, 12, 0, -10795, }, /* 455 */+ { 33, 5, 12, 0, -10792, }, /* 456 */+ { 33, 9, 12, 0, -10780, }, /* 457 */+ { 33, 9, 12, 0, -10749, }, /* 458 */+ { 33, 9, 12, 0, -10783, }, /* 459 */+ { 33, 9, 12, 0, -10782, }, /* 460 */+ { 33, 9, 12, 0, -10815, }, /* 461 */+ { 10, 5, 12, 0, 0, }, /* 462 */+ { 10, 26, 12, 0, 0, }, /* 463 */+ { 10, 12, 3, 0, 0, }, /* 464 */+ { 10, 21, 12, 0, 0, }, /* 465 */+ { 10, 15, 12, 0, 0, }, /* 466 */+ { 16, 5, 12, 0, -7264, }, /* 467 */+ { 58, 7, 12, 0, 0, }, /* 468 */+ { 58, 6, 12, 0, 0, }, /* 469 */+ { 58, 21, 12, 0, 0, }, /* 470 */+ { 58, 12, 3, 0, 0, }, /* 471 */+ { 22, 26, 12, 0, 0, }, /* 472 */+ { 22, 6, 12, 0, 0, }, /* 473 */+ { 22, 14, 12, 0, 0, }, /* 474 */+ { 23, 10, 3, 0, 0, }, /* 475 */+ { 26, 7, 12, 0, 0, }, /* 476 */+ { 26, 6, 12, 0, 0, }, /* 477 */+ { 29, 7, 12, 0, 0, }, /* 478 */+ { 29, 6, 12, 0, 0, }, /* 479 */+ { 3, 7, 12, 0, 0, }, /* 480 */+ { 23, 7, 12, 0, 0, }, /* 481 */+ { 23, 26, 12, 0, 0, }, /* 482 */+ { 29, 26, 12, 0, 0, }, /* 483 */+ { 22, 7, 12, 0, 0, }, /* 484 */+ { 60, 7, 12, 0, 0, }, /* 485 */+ { 60, 6, 12, 0, 0, }, /* 486 */+ { 60, 26, 12, 0, 0, }, /* 487 */+ { 85, 7, 12, 0, 0, }, /* 488 */+ { 85, 6, 12, 0, 0, }, /* 489 */+ { 85, 21, 12, 0, 0, }, /* 490 */+ { 76, 7, 12, 0, 0, }, /* 491 */+ { 76, 6, 12, 0, 0, }, /* 492 */+ { 76, 21, 12, 0, 0, }, /* 493 */+ { 76, 13, 12, 0, 0, }, /* 494 */+ { 12, 7, 12, 0, 0, }, /* 495 */+ { 12, 21, 12, 0, 0, }, /* 496 */+ { 78, 7, 12, 0, 0, }, /* 497 */+ { 78, 14, 12, 0, 0, }, /* 498 */+ { 78, 12, 3, 0, 0, }, /* 499 */+ { 78, 21, 12, 0, 0, }, /* 500 */+ { 33, 9, 12, 0, -35332, }, /* 501 */+ { 33, 9, 12, 0, -42280, }, /* 502 */+ { 33, 9, 12, 0, -42308, }, /* 503 */+ { 33, 9, 12, 0, -42319, }, /* 504 */+ { 33, 9, 12, 0, -42315, }, /* 505 */+ { 33, 9, 12, 0, -42305, }, /* 506 */+ { 33, 9, 12, 0, -42258, }, /* 507 */+ { 33, 9, 12, 0, -42282, }, /* 508 */+ { 48, 7, 12, 0, 0, }, /* 509 */+ { 48, 12, 3, 0, 0, }, /* 510 */+ { 48, 10, 5, 0, 0, }, /* 511 */+ { 48, 26, 12, 0, 0, }, /* 512 */+ { 64, 7, 12, 0, 0, }, /* 513 */+ { 64, 21, 12, 0, 0, }, /* 514 */+ { 74, 10, 5, 0, 0, }, /* 515 */+ { 74, 7, 12, 0, 0, }, /* 516 */+ { 74, 12, 3, 0, 0, }, /* 517 */+ { 74, 21, 12, 0, 0, }, /* 518 */+ { 74, 13, 12, 0, 0, }, /* 519 */+ { 68, 13, 12, 0, 0, }, /* 520 */+ { 68, 7, 12, 0, 0, }, /* 521 */+ { 68, 12, 3, 0, 0, }, /* 522 */+ { 68, 21, 12, 0, 0, }, /* 523 */+ { 73, 7, 12, 0, 0, }, /* 524 */+ { 73, 12, 3, 0, 0, }, /* 525 */+ { 73, 10, 5, 0, 0, }, /* 526 */+ { 73, 21, 12, 0, 0, }, /* 527 */+ { 83, 12, 3, 0, 0, }, /* 528 */+ { 83, 10, 5, 0, 0, }, /* 529 */+ { 83, 7, 12, 0, 0, }, /* 530 */+ { 83, 21, 12, 0, 0, }, /* 531 */+ { 83, 13, 12, 0, 0, }, /* 532 */+ { 38, 6, 12, 0, 0, }, /* 533 */+ { 67, 7, 12, 0, 0, }, /* 534 */+ { 67, 12, 3, 0, 0, }, /* 535 */+ { 67, 10, 5, 0, 0, }, /* 536 */+ { 67, 13, 12, 0, 0, }, /* 537 */+ { 67, 21, 12, 0, 0, }, /* 538 */+ { 91, 7, 12, 0, 0, }, /* 539 */+ { 91, 12, 3, 0, 0, }, /* 540 */+ { 91, 6, 12, 0, 0, }, /* 541 */+ { 91, 21, 12, 0, 0, }, /* 542 */+ { 86, 7, 12, 0, 0, }, /* 543 */+ { 86, 10, 5, 0, 0, }, /* 544 */+ { 86, 12, 3, 0, 0, }, /* 545 */+ { 86, 21, 12, 0, 0, }, /* 546 */+ { 86, 6, 12, 0, 0, }, /* 547 */+ { 86, 13, 12, 0, 0, }, /* 548 */+ { 23, 7, 9, 0, 0, }, /* 549 */+ { 23, 7, 10, 0, 0, }, /* 550 */+ { 9, 4, 2, 0, 0, }, /* 551 */+ { 9, 3, 12, 0, 0, }, /* 552 */+ { 25, 25, 12, 0, 0, }, /* 553 */+ { 0, 24, 12, 0, 0, }, /* 554 */+ { 9, 6, 3, 0, 0, }, /* 555 */+ { 35, 7, 12, 0, 0, }, /* 556 */+ { 19, 14, 12, 0, 0, }, /* 557 */+ { 19, 15, 12, 0, 0, }, /* 558 */+ { 19, 26, 12, 0, 0, }, /* 559 */+ { 70, 7, 12, 0, 0, }, /* 560 */+ { 66, 7, 12, 0, 0, }, /* 561 */+ { 41, 7, 12, 0, 0, }, /* 562 */+ { 41, 15, 12, 0, 0, }, /* 563 */+ { 18, 7, 12, 0, 0, }, /* 564 */+ { 18, 14, 12, 0, 0, }, /* 565 */+ { 117, 7, 12, 0, 0, }, /* 566 */+ { 117, 12, 3, 0, 0, }, /* 567 */+ { 59, 7, 12, 0, 0, }, /* 568 */+ { 59, 21, 12, 0, 0, }, /* 569 */+ { 42, 7, 12, 0, 0, }, /* 570 */+ { 42, 21, 12, 0, 0, }, /* 571 */+ { 42, 14, 12, 0, 0, }, /* 572 */+ { 13, 9, 12, 0, 40, }, /* 573 */+ { 13, 5, 12, 0, -40, }, /* 574 */+ { 46, 7, 12, 0, 0, }, /* 575 */+ { 44, 7, 12, 0, 0, }, /* 576 */+ { 44, 13, 12, 0, 0, }, /* 577 */+ { 105, 7, 12, 0, 0, }, /* 578 */+ { 103, 7, 12, 0, 0, }, /* 579 */+ { 103, 21, 12, 0, 0, }, /* 580 */+ { 109, 7, 12, 0, 0, }, /* 581 */+ { 11, 7, 12, 0, 0, }, /* 582 */+ { 80, 7, 12, 0, 0, }, /* 583 */+ { 80, 21, 12, 0, 0, }, /* 584 */+ { 80, 15, 12, 0, 0, }, /* 585 */+ { 119, 7, 12, 0, 0, }, /* 586 */+ { 119, 26, 12, 0, 0, }, /* 587 */+ { 119, 15, 12, 0, 0, }, /* 588 */+ { 115, 7, 12, 0, 0, }, /* 589 */+ { 115, 15, 12, 0, 0, }, /* 590 */+ { 65, 7, 12, 0, 0, }, /* 591 */+ { 65, 15, 12, 0, 0, }, /* 592 */+ { 65, 21, 12, 0, 0, }, /* 593 */+ { 71, 7, 12, 0, 0, }, /* 594 */+ { 71, 21, 12, 0, 0, }, /* 595 */+ { 97, 7, 12, 0, 0, }, /* 596 */+ { 96, 7, 12, 0, 0, }, /* 597 */+ { 30, 7, 12, 0, 0, }, /* 598 */+ { 30, 12, 3, 0, 0, }, /* 599 */+ { 30, 15, 12, 0, 0, }, /* 600 */+ { 30, 21, 12, 0, 0, }, /* 601 */+ { 87, 7, 12, 0, 0, }, /* 602 */+ { 87, 15, 12, 0, 0, }, /* 603 */+ { 87, 21, 12, 0, 0, }, /* 604 */+ { 116, 7, 12, 0, 0, }, /* 605 */+ { 116, 15, 12, 0, 0, }, /* 606 */+ { 111, 7, 12, 0, 0, }, /* 607 */+ { 111, 26, 12, 0, 0, }, /* 608 */+ { 111, 12, 3, 0, 0, }, /* 609 */+ { 111, 15, 12, 0, 0, }, /* 610 */+ { 111, 21, 12, 0, 0, }, /* 611 */+ { 77, 7, 12, 0, 0, }, /* 612 */+ { 77, 21, 12, 0, 0, }, /* 613 */+ { 82, 7, 12, 0, 0, }, /* 614 */+ { 82, 15, 12, 0, 0, }, /* 615 */+ { 81, 7, 12, 0, 0, }, /* 616 */+ { 81, 15, 12, 0, 0, }, /* 617 */+ { 120, 7, 12, 0, 0, }, /* 618 */+ { 120, 21, 12, 0, 0, }, /* 619 */+ { 120, 15, 12, 0, 0, }, /* 620 */+ { 88, 7, 12, 0, 0, }, /* 621 */+ { 0, 15, 12, 0, 0, }, /* 622 */+ { 93, 10, 5, 0, 0, }, /* 623 */+ { 93, 12, 3, 0, 0, }, /* 624 */+ { 93, 7, 12, 0, 0, }, /* 625 */+ { 93, 21, 12, 0, 0, }, /* 626 */+ { 93, 15, 12, 0, 0, }, /* 627 */+ { 93, 13, 12, 0, 0, }, /* 628 */+ { 84, 12, 3, 0, 0, }, /* 629 */+ { 84, 10, 5, 0, 0, }, /* 630 */+ { 84, 7, 12, 0, 0, }, /* 631 */+ { 84, 21, 12, 0, 0, }, /* 632 */+ { 84, 1, 2, 0, 0, }, /* 633 */+ { 100, 7, 12, 0, 0, }, /* 634 */+ { 100, 13, 12, 0, 0, }, /* 635 */+ { 95, 12, 3, 0, 0, }, /* 636 */+ { 95, 7, 12, 0, 0, }, /* 637 */+ { 95, 10, 5, 0, 0, }, /* 638 */+ { 95, 13, 12, 0, 0, }, /* 639 */+ { 95, 21, 12, 0, 0, }, /* 640 */+ { 110, 7, 12, 0, 0, }, /* 641 */+ { 110, 12, 3, 0, 0, }, /* 642 */+ { 110, 21, 12, 0, 0, }, /* 643 */+ { 99, 12, 3, 0, 0, }, /* 644 */+ { 99, 10, 5, 0, 0, }, /* 645 */+ { 99, 7, 12, 0, 0, }, /* 646 */+ { 99, 21, 12, 0, 0, }, /* 647 */+ { 99, 13, 12, 0, 0, }, /* 648 */+ { 47, 15, 12, 0, 0, }, /* 649 */+ { 107, 7, 12, 0, 0, }, /* 650 */+ { 107, 10, 5, 0, 0, }, /* 651 */+ { 107, 12, 3, 0, 0, }, /* 652 */+ { 107, 21, 12, 0, 0, }, /* 653 */+ { 108, 7, 12, 0, 0, }, /* 654 */+ { 108, 12, 3, 0, 0, }, /* 655 */+ { 108, 10, 5, 0, 0, }, /* 656 */+ { 108, 13, 12, 0, 0, }, /* 657 */+ { 106, 12, 3, 0, 0, }, /* 658 */+ { 106, 10, 5, 0, 0, }, /* 659 */+ { 106, 7, 12, 0, 0, }, /* 660 */+ { 106, 10, 3, 0, 0, }, /* 661 */+ { 123, 7, 12, 0, 0, }, /* 662 */+ { 123, 10, 3, 0, 0, }, /* 663 */+ { 123, 10, 5, 0, 0, }, /* 664 */+ { 123, 12, 3, 0, 0, }, /* 665 */+ { 123, 21, 12, 0, 0, }, /* 666 */+ { 123, 13, 12, 0, 0, }, /* 667 */+ { 122, 7, 12, 0, 0, }, /* 668 */+ { 122, 10, 3, 0, 0, }, /* 669 */+ { 122, 10, 5, 0, 0, }, /* 670 */+ { 122, 12, 3, 0, 0, }, /* 671 */+ { 122, 21, 12, 0, 0, }, /* 672 */+ { 113, 7, 12, 0, 0, }, /* 673 */+ { 113, 10, 5, 0, 0, }, /* 674 */+ { 113, 12, 3, 0, 0, }, /* 675 */+ { 113, 21, 12, 0, 0, }, /* 676 */+ { 113, 13, 12, 0, 0, }, /* 677 */+ { 101, 7, 12, 0, 0, }, /* 678 */+ { 101, 12, 3, 0, 0, }, /* 679 */+ { 101, 10, 5, 0, 0, }, /* 680 */+ { 101, 13, 12, 0, 0, }, /* 681 */+ { 124, 9, 12, 0, 32, }, /* 682 */+ { 124, 5, 12, 0, -32, }, /* 683 */+ { 124, 13, 12, 0, 0, }, /* 684 */+ { 124, 15, 12, 0, 0, }, /* 685 */+ { 124, 7, 12, 0, 0, }, /* 686 */+ { 121, 7, 12, 0, 0, }, /* 687 */+ { 62, 7, 12, 0, 0, }, /* 688 */+ { 62, 14, 12, 0, 0, }, /* 689 */+ { 62, 21, 12, 0, 0, }, /* 690 */+ { 79, 7, 12, 0, 0, }, /* 691 */+ { 114, 7, 12, 0, 0, }, /* 692 */+ { 114, 13, 12, 0, 0, }, /* 693 */+ { 114, 21, 12, 0, 0, }, /* 694 */+ { 102, 7, 12, 0, 0, }, /* 695 */+ { 102, 12, 3, 0, 0, }, /* 696 */+ { 102, 21, 12, 0, 0, }, /* 697 */+ { 118, 7, 12, 0, 0, }, /* 698 */+ { 118, 12, 3, 0, 0, }, /* 699 */+ { 118, 21, 12, 0, 0, }, /* 700 */+ { 118, 26, 12, 0, 0, }, /* 701 */+ { 118, 6, 12, 0, 0, }, /* 702 */+ { 118, 13, 12, 0, 0, }, /* 703 */+ { 118, 15, 12, 0, 0, }, /* 704 */+ { 98, 7, 12, 0, 0, }, /* 705 */+ { 98, 10, 5, 0, 0, }, /* 706 */+ { 98, 12, 3, 0, 0, }, /* 707 */+ { 98, 6, 12, 0, 0, }, /* 708 */+ { 104, 7, 12, 0, 0, }, /* 709 */+ { 104, 26, 12, 0, 0, }, /* 710 */+ { 104, 12, 3, 0, 0, }, /* 711 */+ { 104, 21, 12, 0, 0, }, /* 712 */+ { 9, 10, 3, 0, 0, }, /* 713 */+ { 19, 12, 3, 0, 0, }, /* 714 */+ { 112, 7, 12, 0, 0, }, /* 715 */+ { 112, 15, 12, 0, 0, }, /* 716 */+ { 112, 12, 3, 0, 0, }, /* 717 */+ { 9, 26, 11, 0, 0, }, /* 718 */+ { 26, 26, 12, 0, 0, }, /* 719 */+};++const pcre_uint8 PRIV(ucd_stage1)[] = { /* 8704 bytes */+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* U+0000 */+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* U+0800 */+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 41, 41, 42, 43, 44, 45, /* U+1000 */+ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, /* U+1800 */+ 62, 63, 64, 65, 66, 66, 67, 68, 69, 70, 71, 72, 73, 71, 74, 75, /* U+2000 */+ 76, 76, 66, 77, 66, 66, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, /* U+2800 */+ 88, 89, 90, 91, 92, 93, 94, 71, 95, 95, 95, 95, 95, 95, 95, 95, /* U+3000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+3800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+4000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 96, 95, 95, 95, 95, /* U+4800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+5000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+5800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+6000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+6800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+7000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+7800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+8000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+8800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+9000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 97, /* U+9800 */+ 98, 99, 99, 99, 99, 99, 99, 99, 99,100,101,101,102,103,104,105, /* U+A000 */+106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,114, /* U+A800 */+115,116,117,118,119,120,114,115,116,117,118,119,120,114,115,116, /* U+B000 */+117,118,119,120,114,115,116,117,118,119,120,114,115,116,117,118, /* U+B800 */+119,120,114,115,116,117,118,119,120,114,115,116,117,118,119,120, /* U+C000 */+114,115,116,117,118,119,120,114,115,116,117,118,119,120,114,115, /* U+C800 */+116,117,118,119,120,114,115,116,117,118,119,120,114,115,116,121, /* U+D000 */+122,122,122,122,122,122,122,122,122,122,122,122,122,122,122,122, /* U+D800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+E000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+E800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F000 */+123,123, 95, 95,124,125,126,127,128,128,129,130,131,132,133,134, /* U+F800 */+135,136,137,138,139,140,141,142,143,144,145,139,146,146,147,139, /* U+10000 */+148,149,150,151,152,153,154,155,156,139,139,139,157,139,139,139, /* U+10800 */+158,159,160,161,162,163,164,139,139,165,139,166,167,168,139,139, /* U+11000 */+139,169,139,139,139,170,139,139,139,139,139,139,139,139,139,139, /* U+11800 */+171,171,171,171,171,171,171,172,173,139,139,139,139,139,139,139, /* U+12000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+12800 */+174,174,174,174,174,174,174,174,175,139,139,139,139,139,139,139, /* U+13000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+13800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+14000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+14800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+15000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+15800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+16000 */+176,176,176,176,177,178,179,180,139,139,139,139,139,139,181,182, /* U+16800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+17000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+17800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+18000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+18800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+19000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+19800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1A000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1A800 */+183,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1B000 */+139,139,139,139,139,139,139,139,184,185,139,139,139,139,139,139, /* U+1B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1C800 */+ 71,186,187,188,189,139,190,139,191,192,193,194,195,196,197,198, /* U+1D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1E000 */+199,200,139,139,139,139,139,139,139,139,139,139,201,202,139,139, /* U+1E800 */+203,204,205,206,207,139,208,209, 71,210,211,212,213,214,215,216, /* U+1F000 */+217,218,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1F800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+20000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+20800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+21000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+21800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+22000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+22800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+23000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+23800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+24000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+24800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+25000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+25800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+26000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+26800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+27000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+27800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+28000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+28800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+29000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+29800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95,219, 95, 95, /* U+2A000 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+2A800 */+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95,220, 95, /* U+2B000 */+221,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2C800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2E000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2E800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2F000 */+ 95, 95, 95, 95,221,139,139,139,139,139,139,139,139,139,139,139, /* U+2F800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+30000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+30800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+31000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+31800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+32000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+32800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+33000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+33800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+34000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+34800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+35000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+35800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+36000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+36800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+37000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+37800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+38000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+38800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+39000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+39800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3A000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3A800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3B000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3C800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3E000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3E800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3F000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3F800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+40000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+40800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+41000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+41800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+42000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+42800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+43000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+43800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+44000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+44800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+45000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+45800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+46000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+46800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+47000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+47800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+48000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+48800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+49000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+49800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4A000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4A800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4B000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4C800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4E000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4E800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4F000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4F800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+50000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+50800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+51000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+51800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+52000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+52800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+53000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+53800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+54000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+54800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+55000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+55800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+56000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+56800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+57000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+57800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+58000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+58800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+59000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+59800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5A000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5A800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5B000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5C800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5E000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5E800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5F000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5F800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+60000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+60800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+61000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+61800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+62000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+62800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+63000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+63800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+64000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+64800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+65000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+65800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+66000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+66800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+67000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+67800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+68000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+68800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+69000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+69800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6A000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6A800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6B000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6C800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6E000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6E800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6F000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6F800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+70000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+70800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+71000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+71800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+72000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+72800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+73000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+73800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+74000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+74800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+75000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+75800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+76000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+76800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+77000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+77800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+78000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+78800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+79000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+79800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7A000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7A800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7B000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7C800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7E000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7E800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7F000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7F800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+80000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+80800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+81000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+81800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+82000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+82800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+83000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+83800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+84000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+84800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+85000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+85800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+86000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+86800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+87000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+87800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+88000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+88800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+89000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+89800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8A000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8A800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8B000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8C800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8E000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8E800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8F000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8F800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+90000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+90800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+91000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+91800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+92000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+92800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+93000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+93800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+94000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+94800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+95000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+95800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+96000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+96800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+97000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+97800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+98000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+98800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+99000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+99800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9A000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9A800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9B000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9B800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9C000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9C800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9D000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9D800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9E000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9E800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9F000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9F800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A0000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A0800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A1000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A1800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A2000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A2800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A3000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A3800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A4000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A4800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A5000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A5800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A6000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A6800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A7000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A7800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A8000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A8800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A9000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A9800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AA000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AA800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AB000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AB800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AC000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AC800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AD000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AD800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AE000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AE800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AF000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AF800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B0000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B0800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B1000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B1800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B2000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B2800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B3000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B3800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B4000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B4800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B5000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B5800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B6000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B6800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B7000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B7800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B8000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B8800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B9000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B9800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BA000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BA800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BB000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BB800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BC000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BC800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BD000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BD800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BE000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BE800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BF000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BF800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C0000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C0800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C1000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C1800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C2000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C2800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C3000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C3800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C4000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C4800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C5000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C5800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C6000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C6800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C7000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C7800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C8000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C8800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C9000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C9800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CA000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CA800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CB000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CB800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CC000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CC800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CD000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CD800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CE000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CE800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CF000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CF800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D0000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D0800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D1000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D1800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D2000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D2800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D3000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D3800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D4000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D4800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D5000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D5800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D6000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D6800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D7000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D7800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D8000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D8800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D9000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D9800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DA000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DA800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DB000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DB800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DC000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DC800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DD000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DD800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DE000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DE800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DF000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DF800 */+222,223,224,225,223,223,223,223,223,223,223,223,223,223,223,223, /* U+E0000 */+223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223, /* U+E0800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E1000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E1800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E2000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E2800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E3000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E3800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E4000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E4800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E5000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E5800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E6000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E6800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E7000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E7800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E8000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E8800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E9000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E9800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EA000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EA800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EB000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EB800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EC000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EC800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+ED000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+ED800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EE000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EE800 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EF000 */+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EF800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F0000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F0800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F1000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F1800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F2000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F2800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F3000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F3800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F4000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F4800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F5000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F5800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F6000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F6800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F7000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F7800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F8000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F8800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F9000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F9800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FA000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FA800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FB000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FB800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FC000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FC800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FD000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FD800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FE000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FE800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FF000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,226, /* U+FF800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+100000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+100800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+101000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+101800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+102000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+102800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+103000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+103800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+104000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+104800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+105000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+105800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+106000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+106800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+107000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+107800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+108000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+108800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+109000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+109800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10A000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10A800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10B000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10B800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10C000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10C800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10D000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10D800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10E000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10E800 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10F000 */+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,226, /* U+10F800 */+};++const pcre_uint16 PRIV(ucd_stage2)[] = { /* 58112 bytes, block = 128 */+/* block 0 */+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0,+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,+ 3, 4, 4, 4, 5, 4, 4, 4, 6, 7, 4, 8, 4, 9, 4, 4,+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 4, 4, 8, 8, 8, 4,+ 4, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 11, 11, 11, 11,+ 11, 11, 11, 13, 11, 11, 11, 11, 11, 11, 11, 6, 4, 7, 14, 15,+ 14, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 16, 16, 16, 16,+ 16, 16, 16, 18, 16, 16, 16, 16, 16, 16, 16, 6, 8, 7, 8, 0,++/* block 1 */+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,+ 3, 4, 5, 5, 5, 5, 19, 4, 14, 19, 20, 21, 8, 22, 19, 14,+ 19, 8, 23, 23, 14, 24, 4, 4, 14, 23, 20, 25, 23, 23, 23, 4,+ 11, 11, 11, 11, 11, 26, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,+ 11, 11, 11, 11, 11, 11, 11, 8, 11, 11, 11, 11, 11, 11, 11, 27,+ 16, 16, 16, 16, 16, 28, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,+ 16, 16, 16, 16, 16, 16, 16, 8, 16, 16, 16, 16, 16, 16, 16, 29,++/* block 2 */+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 32, 33, 30, 31, 30, 31, 30, 31, 33, 30, 31, 30, 31, 30, 31, 30,+ 31, 30, 31, 30, 31, 30, 31, 30, 31, 33, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 34, 30, 31, 30, 31, 30, 31, 35,++/* block 3 */+ 36, 37, 30, 31, 30, 31, 38, 30, 31, 39, 39, 30, 31, 33, 40, 41,+ 42, 30, 31, 39, 43, 44, 45, 46, 30, 31, 47, 33, 45, 48, 49, 50,+ 30, 31, 30, 31, 30, 31, 51, 30, 31, 51, 33, 33, 30, 31, 51, 30,+ 31, 52, 52, 30, 31, 30, 31, 53, 30, 31, 33, 20, 30, 31, 33, 54,+ 20, 20, 20, 20, 55, 56, 57, 58, 59, 60, 61, 62, 63, 30, 31, 30,+ 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 64, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 33, 65, 66, 67, 30, 31, 68, 69, 30, 31, 30, 31, 30, 31, 30, 31,++/* block 4 */+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 70, 33, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 33, 33, 33, 33, 33, 33, 71, 30, 31, 72, 73, 74,+ 74, 30, 31, 75, 76, 77, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 78, 79, 80, 81, 82, 33, 83, 83, 33, 84, 33, 85, 86, 33, 33, 33,+ 83, 87, 33, 88, 33, 89, 90, 33, 91, 92, 33, 93, 94, 33, 33, 92,+ 33, 95, 96, 33, 33, 97, 33, 33, 33, 33, 33, 33, 33, 98, 33, 33,++/* block 5 */+ 99, 33, 33, 99, 33, 33, 33,100, 99,101,102,102,103, 33, 33, 33,+ 33, 33,104, 33, 20, 33, 33, 33, 33, 33, 33, 33, 33, 33,105, 33,+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,+106,106,106,106,106,106,106,106,106,107,107,107,107,107,107,107,+107,107, 14, 14, 14, 14,107,107,107,107,107,107,107,107,107,107,+107,107, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,+106,106,106,106,106, 14, 14, 14, 14, 14,108,108,107, 14,107, 14,+ 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,++/* block 6 */+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,110,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+111,112,111,112,107,113,111,112,114,114,115,116,116,116, 4,117,++/* block 7 */+114,114,114,114,113, 14,118, 4,119,119,119,114,120,114,121,121,+122,123,124,123,123,125,123,123,126,127,128,123,129,123,123,123,+130,131,114,132,123,123,133,123,123,134,123,123,135,136,136,136,+122,137,138,137,137,139,137,137,140,141,142,137,143,137,137,137,+144,145,146,147,137,137,148,137,137,149,137,137,150,151,151,152,+153,154,155,155,155,156,157,158,111,112,111,112,111,112,111,112,+111,112,159,160,159,160,159,160,159,160,159,160,159,160,159,160,+161,162,163,164,165,166,167,111,112,168,111,112,122,169,169,169,++/* block 8 */+170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,+171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,+171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,+172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,+172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,+173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,++/* block 9 */+174,175,176,177,177,109,109,177,178,178,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+179,174,175,174,175,174,175,174,175,174,175,174,175,174,175,180,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,++/* block 10 */+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+114,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,+181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,+181,181,181,181,181,181,181,114,114,182,183,183,183,183,183,183,+114,184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,+184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,++/* block 11 */+184,184,184,184,184,184,184,185,114, 4,186,114,114,187,187,188,+114,189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,+189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,+189,189,189,189,189,189,189,189,189,189,189,189,189,189,190,189,+191,189,189,191,189,189,191,189,114,114,114,114,114,114,114,114,+192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,+192,192,192,192,192,192,192,192,192,192,192,114,114,114,114,114,+192,192,192,191,191,114,114,114,114,114,114,114,114,114,114,114,++/* block 12 */+193,193,193,193,193, 22,194,194,194,195,195,196, 4,195,197,197,+198,198,198,198,198,198,198,198,198,198,198, 4, 22,114,195, 4,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+107,199,199,199,199,199,199,199,199,199,199,109,109,109,109,109,+109,109,109,109,109,109,198,198,198,198,198,198,198,198,198,198,+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,195,195,195,195,199,199,+109,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,++/* block 13 */+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,195,199,198,198,198,198,198,198,198, 22,197,198,+198,198,198,198,198,200,200,198,198,197,198,198,198,198,199,199,+201,201,201,201,201,201,201,201,201,201,199,199,199,197,197,199,++/* block 14 */+202,202,202,202,202,202,202,202,202,202,202,202,202,202,114,203,+204,205,204,204,204,204,204,204,204,204,204,204,204,204,204,204,+204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,+205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,+205,205,205,205,205,205,205,205,205,205,205,114,114,204,204,204,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,++/* block 15 */+206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,+206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,+206,206,206,206,206,206,207,207,207,207,207,207,207,207,207,207,+207,206,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+208,208,208,208,208,208,208,208,208,208,209,209,209,209,209,209,+209,209,209,209,209,209,209,209,209,209,209,209,209,209,209,209,+209,209,209,209,209,209,209,209,209,209,209,210,210,210,210,210,+210,210,210,210,211,211,212,213,213,213,211,114,114,114,114,114,++/* block 16 */+214,214,214,214,214,214,214,214,214,214,214,214,214,214,214,214,+214,214,214,214,214,214,215,215,215,215,216,215,215,215,215,215,+215,215,215,215,216,215,215,215,216,215,215,215,215,215,114,114,+217,217,217,217,217,217,217,217,217,217,217,217,217,217,217,114,+218,218,218,218,218,218,218,218,218,218,218,218,218,218,218,218,+218,218,218,218,218,218,218,218,218,219,219,219,114,114,220,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 17 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,198,198,198,198,198,198,198,198,198,198,198,198,+198,198,198,198,198,198,198,198,198,198,198,198,198,198,198,198,++/* block 18 */+221,221,221,222,223,223,223,223,223,223,223,223,223,223,223,223,+223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,+223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,+223,223,223,223,223,223,223,223,223,223,221,222,221,223,222,222,+222,221,221,221,221,221,221,221,221,222,222,222,222,221,222,222,+223,109,109,221,221,221,221,221,223,223,223,223,223,223,223,223,+223,223,221,221, 4, 4,224,224,224,224,224,224,224,224,224,224,+225,226,223,223,223,223,223,223,223,223,223,223,223,223,223,223,++/* block 19 */+227,228,229,229,114,227,227,227,227,227,227,227,227,114,114,227,+227,114,114,227,227,227,227,227,227,227,227,227,227,227,227,227,+227,227,227,227,227,227,227,227,227,114,227,227,227,227,227,227,+227,114,227,114,114,114,227,227,227,227,114,114,228,227,230,229,+229,228,228,228,228,114,114,229,229,114,114,229,229,228,227,114,+114,114,114,114,114,114,114,230,114,114,114,114,227,227,114,227,+227,227,228,228,114,114,231,231,231,231,231,231,231,231,231,231,+227,227,232,232,233,233,233,233,233,233,234,232,114,114,114,114,++/* block 20 */+114,235,235,236,114,237,237,237,237,237,237,114,114,114,114,237,+237,114,114,237,237,237,237,237,237,237,237,237,237,237,237,237,+237,237,237,237,237,237,237,237,237,114,237,237,237,237,237,237,+237,114,237,237,114,237,237,114,237,237,114,114,235,114,236,236,+236,235,235,114,114,114,114,235,235,114,114,235,235,235,114,114,+114,235,114,114,114,114,114,114,114,237,237,237,237,114,237,114,+114,114,114,114,114,114,238,238,238,238,238,238,238,238,238,238,+235,235,237,237,237,235,114,114,114,114,114,114,114,114,114,114,++/* block 21 */+114,239,239,240,114,241,241,241,241,241,241,241,241,241,114,241,+241,241,114,241,241,241,241,241,241,241,241,241,241,241,241,241,+241,241,241,241,241,241,241,241,241,114,241,241,241,241,241,241,+241,114,241,241,114,241,241,241,241,241,114,114,239,241,240,240,+240,239,239,239,239,239,114,239,239,240,114,240,240,239,114,114,+241,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+241,241,239,239,114,114,242,242,242,242,242,242,242,242,242,242,+243,244,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 22 */+114,245,246,246,114,247,247,247,247,247,247,247,247,114,114,247,+247,114,114,247,247,247,247,247,247,247,247,247,247,247,247,247,+247,247,247,247,247,247,247,247,247,114,247,247,247,247,247,247,+247,114,247,247,114,247,247,247,247,247,114,114,245,247,248,245,+246,245,245,245,245,114,114,246,246,114,114,246,246,245,114,114,+114,114,114,114,114,114,245,248,114,114,114,114,247,247,114,247,+247,247,245,245,114,114,249,249,249,249,249,249,249,249,249,249,+250,247,251,251,251,251,251,251,114,114,114,114,114,114,114,114,++/* block 23 */+114,114,252,253,114,253,253,253,253,253,253,114,114,114,253,253,+253,114,253,253,253,253,114,114,114,253,253,114,253,114,253,253,+114,114,114,253,253,114,114,114,253,253,253,114,114,114,253,253,+253,253,253,253,253,253,253,253,253,253,114,114,114,114,254,255,+252,255,255,114,114,114,255,255,255,114,255,255,255,252,114,114,+253,114,114,114,114,114,114,254,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,256,256,256,256,256,256,256,256,256,256,+257,257,257,258,258,258,258,258,258,259,258,114,114,114,114,114,++/* block 24 */+260,261,261,261,114,262,262,262,262,262,262,262,262,114,262,262,+262,114,262,262,262,262,262,262,262,262,262,262,262,262,262,262,+262,262,262,262,262,262,262,262,262,114,262,262,262,262,262,262,+262,262,262,262,262,262,262,262,262,262,114,114,114,262,260,260,+260,261,261,261,261,114,260,260,260,114,260,260,260,260,114,114,+114,114,114,114,114,260,260,114,262,262,114,114,114,114,114,114,+262,262,260,260,114,114,263,263,263,263,263,263,263,263,263,263,+114,114,114,114,114,114,114,114,264,264,264,264,264,264,264,265,++/* block 25 */+114,266,267,267,114,268,268,268,268,268,268,268,268,114,268,268,+268,114,268,268,268,268,268,268,268,268,268,268,268,268,268,268,+268,268,268,268,268,268,268,268,268,114,268,268,268,268,268,268,+268,268,268,268,114,268,268,268,268,268,114,114,266,268,267,266,+267,267,269,267,267,114,266,267,267,114,267,267,266,266,114,114,+114,114,114,114,114,269,269,114,114,114,114,114,114,114,268,114,+268,268,266,266,114,114,270,270,270,270,270,270,270,270,270,270,+114,268,268,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 26 */+114,271,272,272,114,273,273,273,273,273,273,273,273,114,273,273,+273,114,273,273,273,273,273,273,273,273,273,273,273,273,273,273,+273,273,273,273,273,273,273,273,273,273,273,273,273,273,273,273,+273,273,273,273,273,273,273,273,273,273,273,114,114,273,274,272,+272,271,271,271,271,114,272,272,272,114,272,272,272,271,273,114,+114,114,114,114,114,114,114,274,114,114,114,114,114,114,114,114,+273,273,271,271,114,114,275,275,275,275,275,275,275,275,275,275,+276,276,276,276,276,276,114,114,114,277,273,273,273,273,273,273,++/* block 27 */+114,114,278,278,114,279,279,279,279,279,279,279,279,279,279,279,+279,279,279,279,279,279,279,114,114,114,279,279,279,279,279,279,+279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,+279,279,114,279,279,279,279,279,279,279,279,279,114,279,114,114,+279,279,279,279,279,279,279,114,114,114,280,114,114,114,114,281,+278,278,280,280,280,114,280,114,278,278,278,278,278,278,278,281,+114,114,114,114,114,114,282,282,282,282,282,282,282,282,282,282,+114,114,278,278,283,114,114,114,114,114,114,114,114,114,114,114,++/* block 28 */+114,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,+284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,+284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,+284,285,284,286,285,285,285,285,285,285,285,114,114,114,114, 5,+284,284,284,284,284,284,287,285,285,285,285,285,285,285,285,288,+289,289,289,289,289,289,289,289,289,289,288,288,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 29 */+114,290,290,114,290,114,114,290,290,114,290,114,114,290,114,114,+114,114,114,114,290,290,290,290,114,290,290,290,290,290,290,290,+114,290,290,290,114,290,114,290,114,114,290,290,114,290,290,290,+290,291,290,292,291,291,291,291,291,291,114,291,291,290,114,114,+290,290,290,290,290,114,293,114,291,291,291,291,291,291,114,114,+294,294,294,294,294,294,294,294,294,294,114,114,290,290,290,290,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 30 */+295,296,296,296,297,297,297,297,297,297,297,297,297,297,297,297,+297,297,297,296,297,296,296,296,298,298,296,296,296,296,296,296,+299,299,299,299,299,299,299,299,299,299,300,300,300,300,300,300,+300,300,300,300,296,298,296,298,296,298,301,302,301,302,303,303,+295,295,295,295,295,295,295,295,114,295,295,295,295,295,295,295,+295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,+295,295,295,295,295,295,295,295,295,295,295,295,295,114,114,114,+114,298,298,298,298,298,298,298,298,298,298,298,298,298,298,303,++/* block 31 */+298,298,298,298,298,297,298,298,295,295,295,295,295,298,298,298,+298,298,298,298,298,298,298,298,114,298,298,298,298,298,298,298,+298,298,298,298,298,298,298,298,298,298,298,298,298,298,298,298,+298,298,298,298,298,298,298,298,298,298,298,298,298,114,296,296,+296,296,296,296,296,296,298,296,296,296,296,296,296,114,296,296,+297,297,297,297,297, 19, 19, 19, 19,297,297,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 32 */+304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,+304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,+304,304,304,304,304,304,304,304,304,304,304,305,305,306,306,306,+306,307,306,306,306,306,306,306,305,306,306,307,307,306,306,304,+308,308,308,308,308,308,308,308,308,308,309,309,309,309,309,309,+304,304,304,304,304,304,307,307,306,306,304,304,304,304,306,306,+306,304,305,305,305,304,304,305,305,305,305,305,305,305,304,304,+304,306,306,306,306,304,304,304,304,304,304,304,304,304,304,304,++/* block 33 */+304,304,306,305,307,306,306,305,305,305,305,305,305,306,304,305,+308,308,308,308,308,308,308,308,308,308,305,305,305,306,310,310,+311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,+311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,+311,311,311,311,311,311,114,311,114,114,114,114,114,311,114,114,+312,312,312,312,312,312,312,312,312,312,312,312,312,312,312,312,+312,312,312,312,312,312,312,312,312,312,312,312,312,312,312,312,+312,312,312,312,312,312,312,312,312,312,312, 4,313,312,312,312,++/* block 34 */+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,++/* block 35 */+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,+315,315,315,315,315,315,315,315,316,316,316,316,316,316,316,316,+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,++/* block 36 */+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,114,317,317,317,317,114,114,+317,317,317,317,317,317,317,114,317,114,317,317,317,317,114,114,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,++/* block 37 */+317,317,317,317,317,317,317,317,317,114,317,317,317,317,114,114,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,114,317,317,317,317,114,114,317,317,317,317,317,317,317,114,+317,114,317,317,317,317,114,114,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,++/* block 38 */+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,114,317,317,317,317,114,114,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,317,317,317,317,114,114,318,318,318,+319,319,319,319,319,319,319,319,319,320,320,320,320,320,320,320,+320,320,320,320,320,320,320,320,320,320,320,320,320,114,114,114,++/* block 39 */+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+321,321,321,321,321,321,321,321,321,321,114,114,114,114,114,114,+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,+322,322,322,322,322,114,114,114,114,114,114,114,114,114,114,114,++/* block 40 */+323,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,++/* block 41 */+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,++/* block 42 */+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,325,325,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,++/* block 43 */+326,327,327,327,327,327,327,327,327,327,327,327,327,327,327,327,+327,327,327,327,327,327,327,327,327,327,327,328,329,114,114,114,+330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,+330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,+330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,+330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,+330,330,330,330,330,330,330,330,330,330,330, 4, 4, 4,331,331,+331,330,330,330,330,330,330,330,330,114,114,114,114,114,114,114,++/* block 44 */+332,332,332,332,332,332,332,332,332,332,332,332,332,114,332,332,+332,332,333,333,333,114,114,114,114,114,114,114,114,114,114,114,+334,334,334,334,334,334,334,334,334,334,334,334,334,334,334,334,+334,334,335,335,335, 4, 4,114,114,114,114,114,114,114,114,114,+336,336,336,336,336,336,336,336,336,336,336,336,336,336,336,336,+336,336,337,337,114,114,114,114,114,114,114,114,114,114,114,114,+338,338,338,338,338,338,338,338,338,338,338,338,338,114,338,338,+338,114,339,339,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 45 */+340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,+340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,+340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,+340,340,340,340,341,341,342,341,341,341,341,341,341,341,342,342,+342,342,342,342,342,342,341,342,342,341,341,341,341,341,341,341,+341,341,341,341,343,343,343,344,343,343,343,345,340,341,114,114,+346,346,346,346,346,346,346,346,346,346,114,114,114,114,114,114,+347,347,347,347,347,347,347,347,347,347,114,114,114,114,114,114,++/* block 46 */+348,348, 4, 4,348, 4,349,348,348,348,348,350,350,350,351,114,+352,352,352,352,352,352,352,352,352,352,114,114,114,114,114,114,+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,+353,353,353,354,353,353,353,353,353,353,353,353,353,353,353,353,+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,+353,353,353,353,353,353,353,353,114,114,114,114,114,114,114,114,++/* block 47 */+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,+353,353,353,353,353,353,353,353,353,350,353,114,114,114,114,114,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,+324,324,324,324,324,324,114,114,114,114,114,114,114,114,114,114,++/* block 48 */+355,355,355,355,355,355,355,355,355,355,355,355,355,355,355,355,+355,355,355,355,355,355,355,355,355,355,355,355,355,355,355,114,+356,356,356,357,357,357,357,356,356,357,357,357,114,114,114,114,+357,357,356,357,357,357,357,357,357,356,356,356,114,114,114,114,+358,114,114,114,359,359,360,360,360,360,360,360,360,360,360,360,+361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,+361,361,361,361,361,361,361,361,361,361,361,361,361,361,114,114,+361,361,361,361,361,114,114,114,114,114,114,114,114,114,114,114,++/* block 49 */+362,362,362,362,362,362,362,362,362,362,362,362,362,362,362,362,+362,362,362,362,362,362,362,362,362,362,362,362,362,362,362,362,+362,362,362,362,362,362,362,362,362,362,362,362,114,114,114,114,+363,363,363,363,363,364,364,364,363,363,364,363,363,363,363,363,+363,362,362,362,362,362,362,362,363,363,114,114,114,114,114,114,+365,365,365,365,365,365,365,365,365,365,366,114,114,114,367,367,+368,368,368,368,368,368,368,368,368,368,368,368,368,368,368,368,+368,368,368,368,368,368,368,368,368,368,368,368,368,368,368,368,++/* block 50 */+369,369,369,369,369,369,369,369,369,369,369,369,369,369,369,369,+369,369,369,369,369,369,369,370,370,371,371,370,114,114,372,372,+373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,+373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,+373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,+373,373,373,373,373,374,375,374,375,375,375,375,375,375,375,114,+375,376,375,376,376,375,375,375,375,375,375,375,375,374,374,374,+374,374,374,375,375,375,375,375,375,375,375,375,375,114,114,375,++/* block 51 */+377,377,377,377,377,377,377,377,377,377,114,114,114,114,114,114,+377,377,377,377,377,377,377,377,377,377,114,114,114,114,114,114,+378,378,378,378,378,378,378,379,378,378,378,378,378,378,114,114,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,380,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 52 */+381,381,381,381,382,383,383,383,383,383,383,383,383,383,383,383,+383,383,383,383,383,383,383,383,383,383,383,383,383,383,383,383,+383,383,383,383,383,383,383,383,383,383,383,383,383,383,383,383,+383,383,383,383,381,382,381,381,381,381,381,382,381,382,382,382,+382,382,381,382,382,383,383,383,383,383,383,383,114,114,114,114,+384,384,384,384,384,384,384,384,384,384,385,385,385,385,385,385,+385,386,386,386,386,386,386,386,386,386,386,381,381,381,381,381,+381,381,381,381,386,386,386,386,386,386,386,386,386,114,114,114,++/* block 53 */+387,387,388,389,389,389,389,389,389,389,389,389,389,389,389,389,+389,389,389,389,389,389,389,389,389,389,389,389,389,389,389,389,+389,388,387,387,387,387,388,388,387,387,388,387,387,387,389,389,+390,390,390,390,390,390,390,390,390,390,389,389,389,389,389,389,+391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,+391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,+391,391,391,391,391,391,392,393,392,392,393,393,393,392,393,392,+392,392,393,393,114,114,114,114,114,114,114,114,394,394,394,394,++/* block 54 */+395,395,395,395,395,395,395,395,395,395,395,395,395,395,395,395,+395,395,395,395,395,395,395,395,395,395,395,395,395,395,395,395,+395,395,395,395,396,396,396,396,396,396,396,396,397,397,397,397,+397,397,397,397,396,396,397,397,114,114,114,398,398,398,398,398,+399,399,399,399,399,399,399,399,399,399,114,114,114,395,395,395,+400,400,400,400,400,400,400,400,400,400,401,401,401,401,401,401,+401,401,401,401,401,401,401,401,401,401,401,401,401,401,401,401,+401,401,401,401,401,401,401,401,402,402,402,402,402,402,403,403,++/* block 55 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+404,404,404,404,404,404,404,404,114,114,114,114,114,114,114,114,+109,109,109, 4,109,109,109,109,109,109,109,109,109,109,109,109,+109,405,109,109,109,109,109,109,109,406,406,406,406,109,406,406,+406,406,405,405,109,406,406,114,109,109,114,114,114,114,114,114,++/* block 56 */+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,+ 33, 33, 33, 33, 33, 33,122,122,122,122,122,407,106,106,106,106,+106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,+106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,+106,106,106,106,106,106,106,106,106,106,106,106,106,115,115,115,+115,115,106,106,106,106,115,115,115,115,115, 33, 33, 33, 33, 33,+ 33, 33, 33, 33, 33, 33, 33, 33,408,409, 33, 33, 33,410, 33, 33,++/* block 57 */+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,106,106,106,106,106,+106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,+106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,115,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,114,114,114,114,114,114,109,109,109,109,++/* block 58 */+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+411,412, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,++/* block 59 */+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 33, 33, 33, 33, 33,413, 33, 33,414, 33,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,++/* block 60 */+415,415,415,415,415,415,415,415,416,416,416,416,416,416,416,416,+415,415,415,415,415,415,114,114,416,416,416,416,416,416,114,114,+415,415,415,415,415,415,415,415,416,416,416,416,416,416,416,416,+415,415,415,415,415,415,415,415,416,416,416,416,416,416,416,416,+415,415,415,415,415,415,114,114,416,416,416,416,416,416,114,114,+122,415,122,415,122,415,122,415,114,416,114,416,114,416,114,416,+415,415,415,415,415,415,415,415,416,416,416,416,416,416,416,416,+417,417,418,418,418,418,419,419,420,420,421,421,422,422,114,114,++/* block 61 */+415,415,415,415,415,415,415,415,423,423,423,423,423,423,423,423,+415,415,415,415,415,415,415,415,423,423,423,423,423,423,423,423,+415,415,415,415,415,415,415,415,423,423,423,423,423,423,423,423,+415,415,122,424,122,114,122,122,416,416,425,425,426,113,427,113,+113,113,122,424,122,114,122,122,428,428,428,428,426,113,113,113,+415,415,122,122,114,114,122,122,416,416,429,429,114,113,113,113,+415,415,122,122,122,163,122,122,416,416,430,430,168,113,113,113,+114,114,122,424,122,114,122,122,431,431,432,432,426,113,113,114,++/* block 62 */+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 22,433,433, 22, 22,+ 9, 9, 9, 9, 9, 9, 4, 4, 21, 25, 6, 21, 21, 25, 6, 21,+ 4, 4, 4, 4, 4, 4, 4, 4,434,435, 22, 22, 22, 22, 22, 3,+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 21, 25, 4, 4, 4, 4, 15,+ 15, 4, 4, 4, 8, 6, 7, 4, 4, 4, 4, 4, 4, 4, 4, 4,+ 4, 4, 8, 4, 15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3,+ 22, 22, 22, 22, 22,436, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,+ 23,106,114,114, 23, 23, 23, 23, 23, 23, 8, 8, 8, 6, 7,106,++/* block 63 */+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 8, 8, 8, 6, 7,114,+106,106,106,106,106,106,106,106,106,106,106,106,106,114,114,114,+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+109,109,109,109,109,109,109,109,109,109,109,109,109,380,380,380,+380,109,380,380,380,109,109,109,109,109,109,109,109,109,109,109,+109,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 64 */+ 19, 19,437, 19, 19, 19, 19,437, 19, 19,438,437,437,437,438,438,+437,437,437,438, 19,437, 19, 19, 8,437,437,437,437,437, 19, 19,+ 19, 19, 19, 19,437, 19,439, 19,437, 19,440,441,437,437, 19,438,+437,437,442,437,438,406,406,406,406,438, 19, 19,438,438,437,437,+ 8, 8, 8, 8, 8,437,438,438,438,438, 19, 8, 19, 19,443, 19,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+444,444,444,444,444,444,444,444,444,444,444,444,444,444,444,444,+445,445,445,445,445,445,445,445,445,445,445,445,445,445,445,445,++/* block 65 */+446,446,446, 30, 31,446,446,446,446, 23,114,114,114,114,114,114,+ 8, 8, 8, 8, 8, 19, 19, 19, 19, 19, 8, 8, 19, 19, 19, 19,+ 8, 19, 19, 8, 19, 19, 8, 19, 19, 19, 19, 19, 19, 19, 8, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8, 8,+ 19, 19, 8, 19, 8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,++/* block 66 */+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,++/* block 67 */+ 19, 19, 19, 19, 19, 19, 19, 19, 6, 7, 6, 7, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 8, 8, 19, 19, 19, 19, 19, 19, 19, 6, 7, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8, 19, 19, 19,++/* block 68 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8, 8, 8, 8,+ 8, 8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,++/* block 69 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,++/* block 70 */+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19,447,447,447,447,447,447,447,447,447,447,+447,447,447,447,447,447,447,447,447,447,447,447,447,447,447,447,+448,448,448,448,448,448,448,448,448,448,448,448,448,448,448,448,+448,448,448,448,448,448,448,448,448,448, 23, 23, 23, 23, 23, 23,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,++/* block 71 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 72 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 8, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 8, 8, 8, 8, 8, 8, 8, 8,++/* block 73 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 8,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 74 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 6, 7, 6, 7, 6, 7, 6, 7,+ 6, 7, 6, 7, 6, 7, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,++/* block 75 */+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 23, 23, 23, 23, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 8, 8, 8, 8, 8, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,++/* block 76 */+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,++/* block 77 */+ 8, 8, 8, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6,+ 7, 6, 7, 6, 7, 6, 7, 6, 7, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 6, 7, 6, 7, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 7, 8, 8,++/* block 78 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,+ 8, 8, 8, 8, 8, 19, 19, 8, 8, 8, 8, 8, 8, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19,114,114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 79 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19,114,114, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19,114, 19, 19, 19, 19, 19, 19,+ 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 80 */+450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,+450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,+450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,114,+451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,+451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,+451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,114,+ 30, 31,452,453,454,455,456, 30, 31, 30, 31, 30, 31,457,458,459,+460, 33, 30, 31, 33, 30, 31, 33, 33, 33, 33, 33,106,106,461,461,++/* block 81 */+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,+159,160,159,160,462,463,463,463,463,463,463,159,160,159,160,464,+464,464,159,160,114,114,114,114,114,465,465,465,465,466,465,465,++/* block 82 */+467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,+467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,+467,467,467,467,467,467,114,467,114,114,114,114,114,467,114,114,+468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,+468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,+468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,+468,468,468,468,468,468,468,468,114,114,114,114,114,114,114,469,+470,114,114,114,114,114,114,114,114,114,114,114,114,114,114,471,++/* block 83 */+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,+317,317,317,317,317,317,317,114,114,114,114,114,114,114,114,114,+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,+177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,+177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,++/* block 84 */+ 4, 4, 21, 25, 21, 25, 4, 4, 4, 21, 25, 4, 21, 25, 4, 4,+ 4, 4, 4, 4, 4, 4, 4, 9, 4, 4, 9, 4, 21, 25, 4, 4,+ 21, 25, 6, 7, 6, 7, 6, 7, 6, 7, 4, 4, 4, 4, 4,107,+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 9, 9, 4, 4, 4, 4,+ 9, 4, 6,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 85 */+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,114,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 86 */+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,++/* block 87 */+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,+472,472,472,472,472,472,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,++/* block 88 */+ 3, 4, 4, 4, 19,473,406,474, 6, 7, 6, 7, 6, 7, 6, 7,+ 6, 7, 19, 19, 6, 7, 6, 7, 6, 7, 6, 7, 9, 6, 7, 7,+ 19,474,474,474,474,474,474,474,474,474,109,109,109,109,475,475,+ 9,107,107,107,107,107, 19, 19,474,474,474,473,406, 4, 19, 19,+114,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,+476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,+476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,+476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,++/* block 89 */+476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,+476,476,476,476,476,476,476,114,114,109,109, 14, 14,477,477,476,+ 9,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,+478,478,478,478,478,478,478,478,478,478,478, 4,107,479,479,478,++/* block 90 */+114,114,114,114,114,480,480,480,480,480,480,480,480,480,480,480,+480,480,480,480,480,480,480,480,480,480,480,480,480,480,480,480,+480,480,480,480,480,480,480,480,480,480,480,480,480,480,114,114,+114,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,++/* block 91 */+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,114,+ 19, 19, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+480,480,480,480,480,480,480,480,480,480,480,480,480,480,480,480,+480,480,480,480,480,480,480,480,480,480,480,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,++/* block 92 */+482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,+482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,114,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 23, 23, 23, 23, 23, 23, 23, 23,+ 19, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,+482,482,482,482,482,482,482,482,482,482,482,482,482,482,482, 19,++/* block 93 */+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,114,++/* block 94 */+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,+483,483,483,483,483,483,483,483, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 95 */+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,++/* block 96 */+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,114,114,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 97 */+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 98 */+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,486,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,++/* block 99 */+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,++/* block 100 */+485,485,485,485,485,485,485,485,485,485,485,485,485,114,114,114,+487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,+487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,+487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,+487,487,487,487,487,487,487,114,114,114,114,114,114,114,114,114,+488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,+488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,+488,488,488,488,488,488,488,488,489,489,489,489,489,489,490,490,++/* block 101 */+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,++/* block 102 */+491,491,491,491,491,491,491,491,491,491,491,491,492,493,493,493,+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,+494,494,494,494,494,494,494,494,494,494,491,491,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,174,175,495,177,+178,178,178,496,177,177,177,177,177,177,177,177,177,177,496,408,++/* block 103 */+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,+174,175,174,175,174,175,174,175,174,175,174,175,408,408,114,177,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,498,498,498,498,498,498,498,498,498,498,+499,499,500,500,500,500,500,500,114,114,114,114,114,114,114,114,++/* block 104 */+ 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,+ 14, 14, 14, 14, 14, 14, 14,107,107,107,107,107,107,107,107,107,+ 14, 14, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 33, 33, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+106, 33, 33, 33, 33, 33, 33, 33, 33, 30, 31, 30, 31,501, 30, 31,++/* block 105 */+ 30, 31, 30, 31, 30, 31, 30, 31,107, 14, 14, 30, 31,502, 33,114,+ 30, 31, 30, 31, 33, 33, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,503,504,505,506,114,114,+507,508,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114, 20,106,106, 33, 20, 20, 20, 20, 20,++/* block 106 */+509,509,510,509,509,509,510,509,509,509,509,510,509,509,509,509,+509,509,509,509,509,509,509,509,509,509,509,509,509,509,509,509,+509,509,509,511,511,510,510,511,512,512,512,512,114,114,114,114,+ 23, 23, 23, 23, 23, 23, 19, 19, 5, 19,114,114,114,114,114,114,+513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,+513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,+513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,+513,513,513,513,514,514,514,514,114,114,114,114,114,114,114,114,++/* block 107 */+515,515,516,516,516,516,516,516,516,516,516,516,516,516,516,516,+516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,+516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,+516,516,516,516,515,515,515,515,515,515,515,515,515,515,515,515,+515,515,515,515,517,114,114,114,114,114,114,114,114,114,518,518,+519,519,519,519,519,519,519,519,519,519,114,114,114,114,114,114,+221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,+221,221,223,223,223,223,223,223,225,225,225,223,114,114,114,114,++/* block 108 */+520,520,520,520,520,520,520,520,520,520,521,521,521,521,521,521,+521,521,521,521,521,521,521,521,521,521,521,521,521,521,521,521,+521,521,521,521,521,521,522,522,522,522,522,522,522,522, 4,523,+524,524,524,524,524,524,524,524,524,524,524,524,524,524,524,524,+524,524,524,524,524,524,524,525,525,525,525,525,525,525,525,525,+525,525,526,526,114,114,114,114,114,114,114,114,114,114,114,527,+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,+314,314,314,314,314,314,314,314,314,314,314,314,314,114,114,114,++/* block 109 */+528,528,528,529,530,530,530,530,530,530,530,530,530,530,530,530,+530,530,530,530,530,530,530,530,530,530,530,530,530,530,530,530,+530,530,530,530,530,530,530,530,530,530,530,530,530,530,530,530,+530,530,530,528,529,529,528,528,528,528,529,529,528,529,529,529,+529,531,531,531,531,531,531,531,531,531,531,531,531,531,114,107,+532,532,532,532,532,532,532,532,532,532,114,114,114,114,531,531,+304,304,304,304,304,306,533,304,304,304,304,304,304,304,304,304,+308,308,308,308,308,308,308,308,308,308,304,304,304,304,304,114,++/* block 110 */+534,534,534,534,534,534,534,534,534,534,534,534,534,534,534,534,+534,534,534,534,534,534,534,534,534,534,534,534,534,534,534,534,+534,534,534,534,534,534,534,534,534,535,535,535,535,535,535,536,+536,535,535,536,536,535,535,114,114,114,114,114,114,114,114,114,+534,534,534,535,534,534,534,534,534,534,534,534,535,536,114,114,+537,537,537,537,537,537,537,537,537,537,114,114,538,538,538,538,+304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,+533,304,304,304,304,304,304,310,310,310,304,305,306,305,304,304,++/* block 111 */+539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,+539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,+539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,+540,539,540,540,540,539,539,540,540,539,539,539,539,539,540,540,+539,540,539,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,539,539,541,542,542,+543,543,543,543,543,543,543,543,543,543,543,544,545,545,544,544,+546,546,543,547,547,544,545,114,114,114,114,114,114,114,114,114,++/* block 112 */+114,317,317,317,317,317,317,114,114,317,317,317,317,317,317,114,+114,317,317,317,317,317,317,114,114,114,114,114,114,114,114,114,+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 14,106,106,106,106,+114,114,114,114, 33,122,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 113 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,+543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,+543,543,543,544,544,545,544,544,545,544,544,546,544,545,114,114,+548,548,548,548,548,548,548,548,548,548,114,114,114,114,114,114,++/* block 114 */+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,++/* block 115 */+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,++/* block 116 */+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,++/* block 117 */+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,++/* block 118 */+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,++/* block 119 */+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,++/* block 120 */+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,++/* block 121 */+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,+550,550,550,550,114,114,114,114,114,114,114,114,114,114,114,114,+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,+315,315,315,315,315,315,315,114,114,114,114,316,316,316,316,316,+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,+316,316,316,316,316,316,316,316,316,316,316,316,114,114,114,114,++/* block 122 */+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,++/* block 123 */+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,++/* block 124 */+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,114,114,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,++/* block 125 */+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 126 */+ 33, 33, 33, 33, 33, 33, 33,114,114,114,114,114,114,114,114,114,+114,114,114,185,185,185,185,185,114,114,114,114,114,192,189,192,+192,192,192,192,192,192,192,192,192,553,192,192,192,192,192,192,+192,192,192,192,192,192,192,114,192,192,192,192,192,114,192,114,+192,192,114,192,192,114,192,192,192,192,192,192,192,192,192,192,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,++/* block 127 */+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,554,554,554,554,554,554,554,554,554,554,554,554,554,554,+554,554,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,++/* block 128 */+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,++/* block 129 */+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199, 7, 6,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,++/* block 130 */+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+114,114,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+199,199,199,199,199,199,199,199,199,199,199,199,196,197,114,114,++/* block 131 */+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+ 4, 4, 4, 4, 4, 4, 4, 6, 7, 4,114,114,114,114,114,114,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,114,114,+ 4, 9, 9, 15, 15, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6,+ 7, 6, 7, 6, 7, 4, 4, 6, 7, 4, 4, 4, 4, 15, 15, 15,+ 4, 4, 4,114, 4, 4, 4, 4, 9, 6, 7, 6, 7, 6, 7, 4,+ 4, 4, 8, 9, 8, 8, 8,114, 4, 5, 4, 4,114,114,114,114,+199,199,199,199,199,114,199,199,199,199,199,199,199,199,199,199,++/* block 132 */+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,114,114, 22,++/* block 133 */+114, 4, 4, 4, 5, 4, 4, 4, 6, 7, 4, 8, 4, 9, 4, 4,+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 4, 4, 8, 8, 8, 4,+ 4, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,+ 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 6, 4, 7, 14, 15,+ 14, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 6, 8, 7, 8, 6,+ 7, 4, 6, 7, 4, 4,478,478,478,478,478,478,478,478,478,478,+107,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,++/* block 134 */+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,+478,478,478,478,478,478,478,478,478,478,478,478,478,478,555,555,+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,114,+114,114,481,481,481,481,481,481,114,114,481,481,481,481,481,481,+114,114,481,481,481,481,481,481,114,114,481,481,481,114,114,114,+ 5, 5, 8, 14, 19, 5, 5,114, 19, 8, 8, 8, 8, 19, 19,114,+436,436,436,436,436,436,436,436,436, 22, 22, 22, 19, 19,114,114,++/* block 135 */+556,556,556,556,556,556,556,556,556,556,556,556,114,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,114,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,114,556,556,114,556,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,114,114,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 136 */+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,+556,556,556,556,556,556,556,556,556,556,556,114,114,114,114,114,++/* block 137 */+ 4, 4, 4,114,114,114,114, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 23, 23, 23, 23,114,114,114, 19, 19, 19, 19, 19, 19, 19, 19, 19,+557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,+557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,+557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,+557,557,557,557,557,558,558,558,558,559,559,559,559,559,559,559,++/* block 138 */+559,559,559,559,559,559,559,559,559,559,558,558,559,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,+559,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,114,114,++/* block 139 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 140 */+560,560,560,560,560,560,560,560,560,560,560,560,560,560,560,560,+560,560,560,560,560,560,560,560,560,560,560,560,560,114,114,114,+561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,+561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,+561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,+561,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+109, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,114,114,114,114,++/* block 141 */+562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,+562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,+563,563,563,563,114,114,114,114,114,114,114,114,114,114,114,114,+564,564,564,564,564,564,564,564,564,564,564,564,564,564,564,564,+564,565,564,564,564,564,564,564,564,564,565,114,114,114,114,114,+566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,+566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,+566,566,566,566,566,566,567,567,567,567,567,114,114,114,114,114,++/* block 142 */+568,568,568,568,568,568,568,568,568,568,568,568,568,568,568,568,+568,568,568,568,568,568,568,568,568,568,568,568,568,568,114,569,+570,570,570,570,570,570,570,570,570,570,570,570,570,570,570,570,+570,570,570,570,570,570,570,570,570,570,570,570,570,570,570,570,+570,570,570,570,114,114,114,114,570,570,570,570,570,570,570,570,+571,572,572,572,572,572,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 143 */+573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,+573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,+573,573,573,573,573,573,573,573,574,574,574,574,574,574,574,574,+574,574,574,574,574,574,574,574,574,574,574,574,574,574,574,574,+574,574,574,574,574,574,574,574,574,574,574,574,574,574,574,574,+575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,+575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,+575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,++/* block 144 */+576,576,576,576,576,576,576,576,576,576,576,576,576,576,576,576,+576,576,576,576,576,576,576,576,576,576,576,576,576,576,114,114,+577,577,577,577,577,577,577,577,577,577,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 145 */+578,578,578,578,578,578,578,578,578,578,578,578,578,578,578,578,+578,578,578,578,578,578,578,578,578,578,578,578,578,578,578,578,+578,578,578,578,578,578,578,578,114,114,114,114,114,114,114,114,+579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,+579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,+579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,+579,579,579,579,114,114,114,114,114,114,114,114,114,114,114,580,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 146 */+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,++/* block 147 */+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,581,114,114,114,114,114,114,114,114,114,+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,+581,581,581,581,581,581,114,114,114,114,114,114,114,114,114,114,+581,581,581,581,581,581,581,581,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 148 */+582,582,582,582,582,582,114,114,582,114,582,582,582,582,582,582,+582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,+582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,+582,582,582,582,582,582,114,582,582,114,114,114,582,114,114,582,+583,583,583,583,583,583,583,583,583,583,583,583,583,583,583,583,+583,583,583,583,583,583,114,584,585,585,585,585,585,585,585,585,+586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,+586,586,586,586,586,586,586,587,587,588,588,588,588,588,588,588,++/* block 149 */+589,589,589,589,589,589,589,589,589,589,589,589,589,589,589,589,+589,589,589,589,589,589,589,589,589,589,589,589,589,589,589,114,+114,114,114,114,114,114,114,590,590,590,590,590,590,590,590,590,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 150 */+591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,+591,591,591,591,591,591,592,592,592,592,592,592,114,114,114,593,+594,594,594,594,594,594,594,594,594,594,594,594,594,594,594,594,+594,594,594,594,594,594,594,594,594,594,114,114,114,114,114,595,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 151 */+596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,+596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,+597,597,597,597,597,597,597,597,597,597,597,597,597,597,597,597,+597,597,597,597,597,597,597,597,114,114,114,114,114,114,597,597,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 152 */+598,599,599,599,114,599,599,114,114,114,114,114,599,599,599,599,+598,598,598,598,114,598,598,598,114,598,598,598,598,598,598,598,+598,598,598,598,598,598,598,598,598,598,598,598,598,598,598,598,+598,598,598,598,114,114,114,114,599,599,599,114,114,114,114,599,+600,600,600,600,600,600,600,600,114,114,114,114,114,114,114,114,+601,601,601,601,601,601,601,601,601,114,114,114,114,114,114,114,+602,602,602,602,602,602,602,602,602,602,602,602,602,602,602,602,+602,602,602,602,602,602,602,602,602,602,602,602,602,603,603,604,++/* block 153 */+605,605,605,605,605,605,605,605,605,605,605,605,605,605,605,605,+605,605,605,605,605,605,605,605,605,605,605,605,605,606,606,606,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+607,607,607,607,607,607,607,607,608,607,607,607,607,607,607,607,+607,607,607,607,607,607,607,607,607,607,607,607,607,607,607,607,+607,607,607,607,607,609,609,114,114,114,114,610,610,610,610,610,+611,611,611,611,611,611,611,114,114,114,114,114,114,114,114,114,++/* block 154 */+612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,+612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,+612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,+612,612,612,612,612,612,114,114,114,613,613,613,613,613,613,613,+614,614,614,614,614,614,614,614,614,614,614,614,614,614,614,614,+614,614,614,614,614,614,114,114,615,615,615,615,615,615,615,615,+616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,+616,616,616,114,114,114,114,114,617,617,617,617,617,617,617,617,++/* block 155 */+618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,+618,618,114,114,114,114,114,114,114,619,619,619,619,114,114,114,+114,114,114,114,114,114,114,114,114,620,620,620,620,620,620,620,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 156 */+621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,+621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,+621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,+621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,+621,621,621,621,621,621,621,621,621,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 157 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+622,622,622,622,622,622,622,622,622,622,622,622,622,622,622,622,+622,622,622,622,622,622,622,622,622,622,622,622,622,622,622,114,++/* block 158 */+623,624,623,625,625,625,625,625,625,625,625,625,625,625,625,625,+625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,+625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,+625,625,625,625,625,625,625,625,624,624,624,624,624,624,624,624,+624,624,624,624,624,624,624,626,626,626,626,626,626,626,114,114,+114,114,627,627,627,627,627,627,627,627,627,627,627,627,627,627,+627,627,627,627,627,627,628,628,628,628,628,628,628,628,628,628,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,624,++/* block 159 */+629,629,630,631,631,631,631,631,631,631,631,631,631,631,631,631,+631,631,631,631,631,631,631,631,631,631,631,631,631,631,631,631,+631,631,631,631,631,631,631,631,631,631,631,631,631,631,631,631,+630,630,630,629,629,629,629,630,630,629,629,632,632,633,632,632,+632,632,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+634,634,634,634,634,634,634,634,634,634,634,634,634,634,634,634,+634,634,634,634,634,634,634,634,634,114,114,114,114,114,114,114,+635,635,635,635,635,635,635,635,635,635,114,114,114,114,114,114,++/* block 160 */+636,636,636,637,637,637,637,637,637,637,637,637,637,637,637,637,+637,637,637,637,637,637,637,637,637,637,637,637,637,637,637,637,+637,637,637,637,637,637,637,636,636,636,636,636,638,636,636,636,+636,636,636,636,636,114,639,639,639,639,639,639,639,639,639,639,+640,640,640,640,114,114,114,114,114,114,114,114,114,114,114,114,+641,641,641,641,641,641,641,641,641,641,641,641,641,641,641,641,+641,641,641,641,641,641,641,641,641,641,641,641,641,641,641,641,+641,641,641,642,643,643,641,114,114,114,114,114,114,114,114,114,++/* block 161 */+644,644,645,646,646,646,646,646,646,646,646,646,646,646,646,646,+646,646,646,646,646,646,646,646,646,646,646,646,646,646,646,646,+646,646,646,646,646,646,646,646,646,646,646,646,646,646,646,646,+646,646,646,645,645,645,644,644,644,644,644,644,644,644,644,645,+645,646,646,646,646,647,647,647,647,114,114,114,114,647,114,114,+648,648,648,648,648,648,648,648,648,648,646,114,114,114,114,114,+114,649,649,649,649,649,649,649,649,649,649,649,649,649,649,649,+649,649,649,649,649,114,114,114,114,114,114,114,114,114,114,114,++/* block 162 */+650,650,650,650,650,650,650,650,650,650,650,650,650,650,650,650,+650,650,114,650,650,650,650,650,650,650,650,650,650,650,650,650,+650,650,650,650,650,650,650,650,650,650,650,650,651,651,651,652,+652,652,651,651,652,651,652,652,653,653,653,653,653,653,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 163 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,+654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,+654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,655,+656,656,656,655,655,655,655,655,655,655,655,114,114,114,114,114,+657,657,657,657,657,657,657,657,657,657,114,114,114,114,114,114,++/* block 164 */+114,658,659,659,114,660,660,660,660,660,660,660,660,114,114,660,+660,114,114,660,660,660,660,660,660,660,660,660,660,660,660,660,+660,660,660,660,660,660,660,660,660,114,660,660,660,660,660,660,+660,114,660,660,114,660,660,660,660,660,114,114,658,660,661,659,+658,659,659,659,659,114,114,659,659,114,114,659,659,659,114,114,+114,114,114,114,114,114,114,661,114,114,114,114,114,660,660,660,+660,660,659,659,114,114,658,658,658,658,658,658,658,114,114,114,+658,658,658,658,658,114,114,114,114,114,114,114,114,114,114,114,++/* block 165 */+662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,+662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,+662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,+663,664,664,665,665,665,665,665,665,664,665,664,664,663,664,665,+665,664,665,665,662,662,666,662,114,114,114,114,114,114,114,114,+667,667,667,667,667,667,667,667,667,667,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 166 */+668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,+668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,+668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,669,+670,670,671,671,671,671,114,114,670,670,670,670,671,671,670,671,+671,672,672,672,672,672,672,672,672,672,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 167 */+673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,+673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,+673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,+674,674,674,675,675,675,675,675,675,675,675,674,674,675,674,675,+675,676,676,676,673,114,114,114,114,114,114,114,114,114,114,114,+677,677,677,677,677,677,677,677,677,677,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 168 */+678,678,678,678,678,678,678,678,678,678,678,678,678,678,678,678,+678,678,678,678,678,678,678,678,678,678,678,678,678,678,678,678,+678,678,678,678,678,678,678,678,678,678,678,679,680,679,680,680,+679,679,679,679,679,679,680,679,114,114,114,114,114,114,114,114,+681,681,681,681,681,681,681,681,681,681,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 169 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+682,682,682,682,682,682,682,682,682,682,682,682,682,682,682,682,+682,682,682,682,682,682,682,682,682,682,682,682,682,682,682,682,+683,683,683,683,683,683,683,683,683,683,683,683,683,683,683,683,+683,683,683,683,683,683,683,683,683,683,683,683,683,683,683,683,+684,684,684,684,684,684,684,684,684,684,685,685,685,685,685,685,+685,685,685,114,114,114,114,114,114,114,114,114,114,114,114,686,++/* block 170 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,+687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,+687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,+687,687,687,687,687,687,687,687,687,114,114,114,114,114,114,114,++/* block 171 */+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,++/* block 172 */+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,+688,688,688,688,688,688,688,688,688,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 173 */+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,114,+690,690,690,690,690,114,114,114,114,114,114,114,114,114,114,114,++/* block 174 */+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,++/* block 175 */+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 176 */+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,++/* block 177 */+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,+497,497,497,497,497,497,497,497,497,114,114,114,114,114,114,114,+692,692,692,692,692,692,692,692,692,692,692,692,692,692,692,692,+692,692,692,692,692,692,692,692,692,692,692,692,692,692,692,114,+693,693,693,693,693,693,693,693,693,693,114,114,114,114,694,694,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 178 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+695,695,695,695,695,695,695,695,695,695,695,695,695,695,695,695,+695,695,695,695,695,695,695,695,695,695,695,695,695,695,114,114,+696,696,696,696,696,697,114,114,114,114,114,114,114,114,114,114,++/* block 179 */+698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,+698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,+698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,+699,699,699,699,699,699,699,700,700,700,700,700,701,701,701,701,+702,702,702,702,700,701,114,114,114,114,114,114,114,114,114,114,+703,703,703,703,703,703,703,703,703,703,114,704,704,704,704,704,+704,704,114,698,698,698,698,698,698,698,698,698,698,698,698,698,+698,698,698,698,698,698,698,698,114,114,114,114,114,698,698,698,++/* block 180 */+698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 181 */+705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,+705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,+705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,+705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,+705,705,705,705,705,114,114,114,114,114,114,114,114,114,114,114,+705,706,706,706,706,706,706,706,706,706,706,706,706,706,706,706,+706,706,706,706,706,706,706,706,706,706,706,706,706,706,706,706,+706,706,706,706,706,706,706,706,706,706,706,706,706,706,706,114,++/* block 182 */+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,707,+707,707,707,708,708,708,708,708,708,708,708,708,708,708,708,708,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 183 */+478,476,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 184 */+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,+709,709,709,709,709,709,709,709,709,709,709,114,114,114,114,114,+709,709,709,709,709,709,709,709,709,709,709,709,709,114,114,114,++/* block 185 */+709,709,709,709,709,709,709,709,709,114,114,114,114,114,114,114,+709,709,709,709,709,709,709,709,709,709,114,114,710,711,711,712,+ 22, 22, 22, 22,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 186 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,++/* block 187 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19,114,114, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19,713,405,109,109,109, 19, 19, 19,405,713,713,+713,713,713, 22, 22, 22, 22, 22, 22, 22, 22,109,109,109,109,109,++/* block 188 */+109,109,109, 19, 19,109,109,109,109,109,109,109, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 189 */+559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,+559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,+559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,+559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,+559,559,714,714,714,559,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 190 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,+ 23, 23,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 191 */+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,438,438,+438,438,438,438,438,114,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,++/* block 192 */+437,437,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,437,114,437,437,+114,114,437,114,114,437,437,114,114,437,437,437,437,114,437,437,+437,437,437,437,437,437,438,438,438,438,114,438,114,438,438,438,+438,438,438,438,114,438,438,438,438,438,438,438,438,438,438,438,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,++/* block 193 */+438,438,438,438,437,437,114,437,437,437,437,114,114,437,437,437,+437,437,437,437,437,114,437,437,437,437,437,437,437,114,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,437,437,114,437,437,437,437,114,+437,437,437,437,437,114,437,114,114,114,437,437,437,437,437,437,+437,114,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,++/* block 194 */+437,437,437,437,437,437,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,++/* block 195 */+438,438,438,438,438,438,438,438,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,++/* block 196 */+437,437,437,437,437,437,437,437,437,437,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,114,114,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437, 8,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438, 8,438,438,438,438,+438,438,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437, 8,438,438,438,438,++/* block 197 */+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438, 8,438,438,438,438,438,438,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437, 8,438,438,438,438,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438, 8,+438,438,438,438,438,438,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437, 8,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,++/* block 198 */+438,438,438,438,438,438,438,438,438, 8,438,438,438,438,438,438,+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,+437,437,437,437,437,437,437,437,437, 8,438,438,438,438,438,438,+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,+438,438,438, 8,438,438,438,438,438,438,437,438,114,114, 10, 10,+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,++/* block 199 */+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,++/* block 200 */+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,+715,715,715,715,715,114,114,716,716,716,716,716,716,716,716,716,+717,717,717,717,717,717,717,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 201 */+199,199,199,199,114,199,199,199,199,199,199,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,+114,199,199,114,199,114,114,199,114,199,199,199,199,199,199,199,+199,199,199,114,199,199,199,199,114,199,114,199,114,114,114,114,+114,114,199,114,114,114,114,199,114,199,114,199,114,199,199,199,+114,199,199,114,199,114,114,199,114,199,114,199,114,199,114,199,+114,199,199,114,199,114,114,199,199,199,199,114,199,199,199,199,+199,199,199,114,199,199,199,199,114,199,199,199,199,114,199,114,++/* block 202 */+199,199,199,199,199,199,199,199,199,199,114,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,114,114,114,114,+114,199,199,199,114,199,199,199,199,199,114,199,199,199,199,199,+199,199,199,199,199,199,199,199,199,199,199,199,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+194,194,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 203 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 204 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,+114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,++/* block 205 */+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 206 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,718,718,718,718,718,718,718,718,718,718,+718,718,718,718,718,718,718,718,718,718,718,718,718,718,718,718,++/* block 207 */+719, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,+ 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 208 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,++/* block 209 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,+114,114,114,114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,++/* block 210 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,++/* block 211 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114, 19, 19, 19, 19, 19,++/* block 212 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19,114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 213 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19,114,114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 214 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,+ 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 215 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 216 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 217 */+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,++/* block 218 */+ 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 219 */+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 220 */+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,114,114,114,114,114,114,114,114,114,114,114,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,++/* block 221 */+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,+484,484,484,484,484,484,484,484,484,484,484,484,484,484,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,++/* block 222 */+436, 22,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,++/* block 223 */+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,++/* block 224 */+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,++/* block 225 */+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,++/* block 226 */+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,+552,552,552,552,552,552,552,552,552,552,552,552,552,552,114,114, };
pcre/pcre_xclass.c view
@@ -81,6 +81,11 @@ if (c < 256) {+ if ((*data & XCL_HASPROP) == 0)+ {+ if ((*data & XCL_MAP) == 0) return negated;+ return (((pcre_uint8 *)(data + 1))[c/8] & (1 << (c&7))) != 0;+ } if ((*data & XCL_MAP) != 0 && (((pcre_uint8 *)(data + 1))[c/8] & (1 << (c&7))) != 0) return !negated; /* char found */@@ -241,7 +246,7 @@ case PT_PXPUNCT: if ((PRIV(ucp_gentype)[prop->chartype] == ucp_P ||- (c < 256 && PRIV(ucp_gentype)[prop->chartype] == ucp_S)) == isprop)+ (c < 128 && PRIV(ucp_gentype)[prop->chartype] == ucp_S)) == isprop) return !negated; break;
pcre/ucp.h view
@@ -192,7 +192,31 @@ ucp_Miao, ucp_Sharada, ucp_Sora_Sompeng,- ucp_Takri+ ucp_Takri,+ /* New for Unicode 7.0.0: */+ ucp_Bassa_Vah,+ ucp_Caucasian_Albanian,+ ucp_Duployan,+ ucp_Elbasan,+ ucp_Grantha,+ ucp_Khojki,+ ucp_Khudawadi,+ ucp_Linear_A,+ ucp_Mahajani,+ ucp_Manichaean,+ ucp_Mende_Kikakui,+ ucp_Modi,+ ucp_Mro,+ ucp_Nabataean,+ ucp_Old_North_Arabian,+ ucp_Old_Permic,+ ucp_Pahawh_Hmong,+ ucp_Palmyrene,+ ucp_Psalter_Pahlavi,+ ucp_Pau_Cin_Hau,+ ucp_Siddham,+ ucp_Tirhuta,+ ucp_Warang_Citi }; #endif
regex-pcre-builtin.cabal view
@@ -1,76 +1,87 @@ Name: regex-pcre-builtin--- Keep the Version below in sync with ./Text/Regex/PCRE.hs value getVersion_Text_Regex_PCRE :: Version-Version: 0.94.6.8.8.35-Cabal-Version: >=1.2.3-License: BSD3-License-File: LICENSE-Copyright: See LICENSE file-Author: Audrey Tang-Maintainer: audreyt@audreyt.org-Stability: Seems to work, passes a few tests-Homepage: http://hackage.haskell.org/package/regex-pcre-Package-URL: http://code.haskell.org/regex-pcre/-Synopsis: Replaces/Enhances Text.Regex-Description: The PCRE backend to accompany regex-base, with bundled code from www.pcre.org-Category: Text-Tested-With: GHC-Build-Type: Simple-Extra-source-files:- pcre/config.h pcre/pcre.h pcre/pcre_byte_order.c pcre/pcre_compile.c pcre/pcre_config.c pcre/pcre_chartables.c pcre/pcre_dfa_exec.c pcre/pcre_exec.c pcre/pcre_fullinfo.c pcre/pcre_get.c pcre/pcre_globals.c pcre/pcre_internal.h pcre/pcre_jit_compile.c pcre/pcre_maketables.c pcre/pcre_newline.c pcre/pcre_ord2utf8.c pcre/pcre_printint.c pcre/pcre_refcount.c pcre/pcre_scanner.h pcre/pcre_string_utils.c pcre/pcre_study.c pcre/pcre_tables.c pcre/pcre_ucd.c pcre/pcre_valid_utf8.c pcre/pcre_version.c pcre/pcre_xclass.c pcre/pcrecpp.h pcre/pcrecpp_internal.h pcre/pcreposix.h pcre/ucp.h+Version: 0.95.2.3.8.44+Cabal-Version: >=1.10+stability: Seems to work, passes a few tests+build-type: Simple+license: BSD3+license-file: LICENSE+copyright: Copyright (c) 2006, Christopher Kuklewicz+author: Audrey Tang+maintainer: audreyt@audreyt.org+bug-reports: https://github.com/audreyt/regex-pcre-builtin/issues+category: Text -flag newBase- description: Choose base >= 4- default: True-flag splitBase- description: Choose the new smaller, split-up base package.- default: True+synopsis: PCRE Backend for "Text.Regex" (regex-base)+description:+ This package provides a <http://pcre.org/ PCRE> backend for the <//hackage.haskell.org/package/regex-base regex-base> API.+ .+ See also <https://wiki.haskell.org/Regular_expressions> for more information.+ .+ Includes bundled code from www.pcre.org++extra-source-files:+ ChangeLog.md+ pcre/config.h pcre/pcre.h pcre/pcre_byte_order.c pcre/pcre_compile.c pcre/pcre_config.c pcre/pcre_chartables.c pcre/pcre_dfa_exec.c pcre/pcre_exec.c pcre/pcre_fullinfo.c pcre/pcre_get.c pcre/pcre_globals.c pcre/pcre_internal.h pcre/pcre_jit_compile.c pcre/pcre_maketables.c pcre/pcre_newline.c pcre/pcre_ord2utf8.c pcre/pcre_printint.c pcre/pcre_refcount.c pcre/pcre_scanner.h pcre/pcre_string_utils.c pcre/pcre_study.c pcre/pcre_tables.c pcre/pcre_ucd.c pcre/pcre_valid_utf8.c pcre/pcre_version.c pcre/pcre_xclass.c pcre/pcrecpp.h pcre/pcrecpp_internal.h pcre/pcreposix.h pcre/ucp.h++tested-with:+ GHC == 9.2.0.20210821+ GHC == 9.0.1+ GHC == 8.10.7+ GHC == 8.8.4+ GHC == 8.6.5+ GHC == 8.4.4+ GHC == 8.2.2+ GHC == 8.0.2+ GHC == 7.10.3+ GHC == 7.8.4+ GHC == 7.6.3+ GHC == 7.4.2+ GHC == 7.0.4++source-repository head+ type: git+ location: https://github.com/audreyt/regex-pcre-builtin+ library- if flag(newBase)- Build-Depends: base >= 4 && < 5, regex-base >=0.93 && <0.95, array, containers, bytestring- -- Need the next symbol for using CPP to get Data.ByteString.Base|Unsafe in- -- ./Text/Regex/Posix/ByteString.hs and ./Text/Regex/Posix/ByteString/Lazy.hs- CPP-Options: "-DSPLIT_BASE=1"- Extensions: MultiParamTypeClasses, FunctionalDependencies, CPP, ForeignFunctionInterface, ScopedTypeVariables, GeneralizedNewtypeDeriving, FlexibleContexts, TypeSynonymInstances, FlexibleInstances- else- if flag(splitBase)- Build-Depends: base >= 3.0, regex-base >=0.93 && <0.95, array, containers, bytestring- -- Need the next symbol for using CPP to get Data.ByteString.Base|Unsafe in- -- ./Text/Regex/Posix/ByteString.hs and ./Text/Regex/Posix/ByteString/Lazy.hs- CPP-Options: "-DSPLIT_BASE=1"- Extensions: MultiParamTypeClasses, FunctionalDependencies, CPP, ForeignFunctionInterface, ScopedTypeVariables, GeneralizedNewtypeDeriving, FlexibleContexts, TypeSynonymInstances, FlexibleInstances- else- Build-Depends: base < 3.0, regex-base >=0.93 && <0.95- Extensions: MultiParamTypeClasses, FunctionalDependencies, CPP- if impl(ghc < 8)- Build-Depends: fail- Exposed-Modules: Text.Regex.PCRE- Text.Regex.PCRE.Wrap- Text.Regex.PCRE.String- Text.Regex.PCRE.Sequence- Text.Regex.PCRE.ByteString- Text.Regex.PCRE.ByteString.Lazy- Buildable: True- -- Other-Modules:- -- HS-Source-Dirs: "."- -- The CPP is for using -DSPLIT_BASE=1 to get Data.ByteString.Base|Unsafe- -- And the CPP is for using -DHAVE_PCRE_H to get the local posix library- -- GHC-Options: -Wall -Werror -O2- GHC-Options: -Wall -O2- -- GHC-Options: -Wall -ddump-minimal-imports- -- GHC-Prof-Options:- -- Hugs-Options:- -- NHC-Options:- -- C-Sources:- -- Includes:- -- LD-Options:- -- Frameworks:- -- The only reason to NOT define -DHAVE_PCRE_H is if you are on- -- a plotform without a regex library but want to compile this package- -- anyway. The resulting regex-posix will exist, but throw errors.- CC-Options: -DHAVE_PCRE_H -DHAVE_CONFIG_H -DPCRE_STATIC -DHAVE_INTTYPES_H -DHAVE_STDINT_H -DHAVE_STDLIB_H- --Include-Dirs: /opt/local/include- --Extra-Lib-Dirs: /opt/local/lib- Include-dirs: pcre- Includes: pcre.h config.h- C-sources:+ hs-source-dirs: src+ exposed-modules:+ Text.Regex.PCRE+ Text.Regex.PCRE.Wrap+ Text.Regex.PCRE.String+ Text.Regex.PCRE.Sequence+ Text.Regex.PCRE.ByteString+ Text.Regex.PCRE.ByteString.Lazy+ Text.Regex.PCRE.Text+ Text.Regex.PCRE.Text.Lazy++ other-modules:+ Paths_regex_pcre_builtin++ default-language: Haskell2010+ default-extensions:+ MultiParamTypeClasses+ FunctionalDependencies+ ForeignFunctionInterface+ ScopedTypeVariables+ GeneralizedNewtypeDeriving+ FlexibleContexts+ TypeSynonymInstances+ FlexibleInstances++ build-depends: regex-base == 0.94.*+ , base >= 4.3 && < 4.17+ , containers >= 0.4 && < 0.7+ , bytestring >= 0.9 && < 0.12+ , array >= 0.3 && < 0.6+ , text >= 1.2.3 && < 1.3++ if !impl(ghc >= 8)+ build-depends: fail == 4.9.*++ ghc-options: -O2+ -Wall -fno-warn-unused-imports+ cc-options: -DHAVE_CONFIG_H+ include-dirs: pcre+ includes: pcre.h config.h+ c-sources: pcre/pcre_byte_order.c pcre/pcre_compile.c pcre/pcre_config.c pcre/pcre_chartables.c pcre/pcre_dfa_exec.c pcre/pcre_exec.c pcre/pcre_fullinfo.c pcre/pcre_get.c pcre/pcre_globals.c pcre/pcre_jit_compile.c pcre/pcre_maketables.c pcre/pcre_newline.c pcre/pcre_ord2utf8.c pcre/pcre_refcount.c pcre/pcre_string_utils.c pcre/pcre_study.c pcre/pcre_tables.c pcre/pcre_ucd.c pcre/pcre_valid_utf8.c pcre/pcre_version.c pcre/pcre_xclass.c
+ src/Text/Regex/PCRE.hs view
@@ -0,0 +1,52 @@+{-|+The "Text.Regex.PCRE" module provides a backend for regular+expressions. If you import this along with other backends, then+you should do so with qualified imports, perhaps renamed for+convenience.++Using the provided 'CompOption' and 'ExecOption' values and if+'configUTF8' is True, then you might be able to send UTF8 encoded+ByteStrings to PCRE and get sensible results. This is currently+untested.++The regular expression can be provided as a 'ByteString', but it will+be copied and a NUL byte appended to make a 'CString' unless such a+byte is already present. Thus the regular expression cannot contain+an explicit NUL byte. The search string is passed as a 'CStringLen'+and may contain NUL bytes and does not need to end in a NUL+byte. 'ByteString's are searched in place (via unsafeUseAsCStringLen).++A 'String' will be converted into a 'CString' or 'CStringLen' for+processing. Doing this repeatedly will be very inefficient.++The "Text.Regex.PCRE.String", "Text.Regex.PCRE.ByteString", and+"Text.Regex.PCRE.Wrap" modules provides both the high level interface+exported by this module and medium- and low-level interfaces that+returns error using Either structures.+-}+{- Copyright : (c) Chris Kuklewicz 2007 -}+module Text.Regex.PCRE(getVersion_Text_Regex_PCRE+ ,module Text.Regex.Base+ -- ** Wrap, for '=~' and '=~~', types and constants+ ,module Text.Regex.PCRE.Wrap) where++import Prelude hiding (fail)++import Text.Regex.PCRE.Wrap(Regex, CompOption(CompOption), ExecOption(ExecOption), (=~), (=~~),+ unusedOffset, getNumSubs, configUTF8, getVersion,+ compBlank, compAnchored, compAutoCallout, compCaseless,+ compDollarEndOnly, compDotAll, compExtended, compExtra,+ compFirstLine, compMultiline, compNoAutoCapture, compUngreedy,+ compUTF8, compNoUTF8Check,+ execBlank, execAnchored, execNotBOL, execNotEOL, execNotEmpty,+ execNoUTF8Check, execPartial)+import Text.Regex.PCRE.String()+import Text.Regex.PCRE.Sequence()+import Text.Regex.PCRE.ByteString()+import Text.Regex.PCRE.ByteString.Lazy()+import Data.Version(Version(..))+import Text.Regex.Base+import Paths_regex_pcre_builtin++getVersion_Text_Regex_PCRE :: Version+getVersion_Text_Regex_PCRE = Paths_regex_pcre_builtin.version
+ src/Text/Regex/PCRE/ByteString.hs view
@@ -0,0 +1,144 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-|+This exports instances of the high level API and the medium level+API of 'compile','execute', and 'regexec'.+-}+{- Copyright : (c) Chris Kuklewicz 2007 -}+module Text.Regex.PCRE.ByteString(+ -- ** Types+ Regex,+ MatchOffset,+ MatchLength,+ CompOption(CompOption),+ ExecOption(ExecOption),+ ReturnCode,+ WrapError,+ -- ** Miscellaneous+ unusedOffset,+ getVersion,+ -- ** Medium level API functions+ compile,+ execute,+ regexec,+ -- ** CompOption flags+ compBlank,+ compAnchored,+ compAutoCallout,+ compCaseless,+ compDollarEndOnly,+ compDotAll,+ compExtended,+ compExtra,+ compFirstLine,+ compMultiline,+ compNoAutoCapture,+ compUngreedy,+ compUTF8,+ compNoUTF8Check,+ -- ** ExecOption flags+ execBlank,+ execAnchored,+ execNotBOL,+ execNotEOL,+ execNotEmpty,+ execNoUTF8Check,+ execPartial+ ) where++import Prelude hiding (fail)+import Control.Monad.Fail (MonadFail(fail))++import Text.Regex.PCRE.Wrap -- all+import Data.Array(Array,listArray)+import Data.ByteString(ByteString)+import qualified Data.ByteString as B(empty,useAsCString,last,take,drop,null,pack)+import qualified Data.ByteString.Unsafe as B(unsafeUseAsCString,unsafeUseAsCStringLen)+import System.IO.Unsafe(unsafePerformIO)+import Text.Regex.Base.RegexLike(RegexContext(..),RegexMaker(..),RegexLike(..),MatchOffset,MatchLength)+import Text.Regex.Base.Impl(polymatch,polymatchM)+import Foreign.C.String(CStringLen)+import Foreign(nullPtr)++instance RegexContext Regex ByteString ByteString where+ match = polymatch+ matchM = polymatchM++unwrap :: (Show e) => Either e v -> IO v+unwrap x = case x of Left err -> fail ("Text.Regex.PCRE.ByteString died: "++ show err)+ Right v -> return v++{-# INLINE asCStringLen #-}+asCStringLen :: ByteString -> (CStringLen -> IO a) -> IO a+asCStringLen s op = B.unsafeUseAsCStringLen s checked+ where checked cs@(ptr,_) | ptr == nullPtr = B.unsafeUseAsCStringLen myEmpty (op . trim)+ | otherwise = op cs+ myEmpty = B.pack [0]+ trim (ptr,_) = (ptr,0)++instance RegexMaker Regex CompOption ExecOption ByteString where+ makeRegexOpts c e pattern = unsafePerformIO $+ compile c e pattern >>= unwrap+ makeRegexOptsM c e pattern = either (fail.show) return $ unsafePerformIO $+ compile c e pattern++instance RegexLike Regex ByteString where+ matchTest regex bs = unsafePerformIO $+ asCStringLen bs (wrapTest 0 regex) >>= unwrap+ matchOnce regex bs = unsafePerformIO $+ execute regex bs >>= unwrap+ matchAll regex bs = unsafePerformIO $+ asCStringLen bs (wrapMatchAll regex) >>= unwrap+ matchCount regex bs = unsafePerformIO $+ asCStringLen bs (wrapCount regex) >>= unwrap++-- ---------------------------------------------------------------------+-- | Compiles a regular expression+--+compile :: CompOption -- ^ (summed together)+ -> ExecOption -- ^ (summed together)+ -> ByteString -- ^ The regular expression to compile+ -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: the compiled regular expression+compile c e pattern = do+ -- PCRE does not allow one to specify a length for the regular expression, it must by 0 terminated+ let asCString bs = if (not (B.null bs)) && (0==B.last bs)+ then B.unsafeUseAsCString bs+ else B.useAsCString bs+ asCString pattern (wrapCompile c e)++-- ---------------------------------------------------------------------+-- | Matches a regular expression against a buffer, returning the buffer+-- indicies of the match, and any submatches+--+-- | Matches a regular expression against a string+execute :: Regex -- ^ Compiled regular expression+ -> ByteString -- ^ String to match against+ -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))+ -- ^ Returns: 'Nothing' if the regex did not match the+ -- string, or:+ -- 'Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions.+execute regex bs = do+ maybeStartEnd <- asCStringLen bs (wrapMatch 0 regex)+ case maybeStartEnd of+ Right Nothing -> return (Right Nothing)+ Right (Just parts) ->+ return . Right . Just . listArray (0,pred (length parts))+ . map (\(s,e)->(fromIntegral s, fromIntegral (e-s))) $ parts+ Left err -> return (Left err)++regexec :: Regex -- ^ Compiled regular expression+ -> ByteString -- ^ String to match against+ -> IO (Either WrapError (Maybe (ByteString, ByteString, ByteString, [ByteString])))+regexec regex bs = do+ let getSub (start,stop) | start == unusedOffset = B.empty+ | otherwise = B.take (stop-start) . B.drop start $ bs+ matchedParts [] = (B.empty,B.empty,bs,[]) -- no information+ matchedParts (matchedStartStop@(start,stop):subStartStop) =+ (B.take start bs+ ,getSub matchedStartStop+ ,B.drop stop bs+ ,map getSub subStartStop)+ maybeStartEnd <- asCStringLen bs (wrapMatch 0 regex)+ case maybeStartEnd of+ Right Nothing -> return (Right Nothing)+ Right (Just parts) -> return . Right . Just . matchedParts $ parts+ Left err -> return (Left err)
+ src/Text/Regex/PCRE/ByteString/Lazy.hs view
@@ -0,0 +1,140 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-|+This exports instances of the high level API and the medium level+API of 'compile','execute', and 'regexec'.+-}+{- Copyright : (c) Chris Kuklewicz 2007 -}+module Text.Regex.PCRE.ByteString.Lazy(+ -- ** Types+ Regex,+ MatchOffset,+ MatchLength,+ CompOption(CompOption),+ ExecOption(ExecOption),+ ReturnCode,+ WrapError,+ -- ** Miscellaneous+ unusedOffset,+ getVersion,+ -- ** Medium level API functions+ compile,+ execute,+ regexec,+ -- ** CompOption flags+ compBlank,+ compAnchored,+ compAutoCallout,+ compCaseless,+ compDollarEndOnly,+ compDotAll,+ compExtended,+ compExtra,+ compFirstLine,+ compMultiline,+ compNoAutoCapture,+ compUngreedy,+ compUTF8,+ compNoUTF8Check,+ -- ** ExecOption flags+ execBlank,+ execAnchored,+ execNotBOL,+ execNotEOL,+ execNotEmpty,+ execNoUTF8Check,+ execPartial+ ) where++import Prelude hiding (fail)+import Control.Monad.Fail (MonadFail(fail))++import Text.Regex.PCRE.Wrap -- all+import Data.Array(Array)+import qualified Data.ByteString.Lazy as L(ByteString,toChunks,fromChunks,last,null,snoc)+import qualified Data.ByteString as B(ByteString,concat,pack)+import qualified Data.ByteString.Unsafe as B(unsafeUseAsCString,unsafeUseAsCStringLen)+import System.IO.Unsafe(unsafePerformIO)+import Text.Regex.Base.RegexLike(RegexContext(..),RegexMaker(..),RegexLike(..),MatchOffset,MatchLength)+import Text.Regex.Base.Impl(polymatch,polymatchM)+import qualified Text.Regex.PCRE.ByteString as BS(execute,regexec)+import Foreign.C.String(CString,CStringLen)+import Foreign(nullPtr)++instance RegexContext Regex L.ByteString L.ByteString where+ match = polymatch+ matchM = polymatchM++{-# INLINE fromLazy #-}+fromLazy :: L.ByteString -> B.ByteString+fromLazy = B.concat . L.toChunks++{-# INLINE toLazy #-}+toLazy :: B.ByteString -> L.ByteString+toLazy = L.fromChunks . return++unwrap :: (Show e) => Either e v -> IO v+unwrap x = case x of Left err -> fail ("Text.Regex.PCRE.ByteString.Lazy died: "++ show err)+ Right v -> return v++{-# INLINE asCString #-}+asCString :: L.ByteString -> (CString -> IO a) -> IO a+asCString s = if (not (L.null s)) && (0==L.last s)+ then B.unsafeUseAsCString (fromLazy s)+ else B.unsafeUseAsCString (fromLazy (L.snoc s 0))++{-# INLINE asCStringLen #-}+asCStringLen :: L.ByteString -> (CStringLen -> IO a) -> IO a+asCStringLen ls op = B.unsafeUseAsCStringLen (fromLazy ls) checked+ where checked cs@(ptr,_) | ptr == nullPtr = B.unsafeUseAsCStringLen myEmpty (op . trim)+ | otherwise = op cs+ myEmpty = B.pack [0]+ trim (ptr,_) = (ptr,0)++instance RegexMaker Regex CompOption ExecOption L.ByteString where+ makeRegexOpts c e pattern = unsafePerformIO $+ compile c e pattern >>= unwrap+ makeRegexOptsM c e pattern = either (fail.show) return $ unsafePerformIO $+ compile c e pattern++instance RegexLike Regex L.ByteString where+ matchTest regex bs = unsafePerformIO $+ asCStringLen bs (wrapTest 0 regex) >>= unwrap+ matchOnce regex bs = unsafePerformIO $+ execute regex bs >>= unwrap+ matchAll regex bs = unsafePerformIO $+ asCStringLen bs (wrapMatchAll regex) >>= unwrap+ matchCount regex bs = unsafePerformIO $+ asCStringLen bs (wrapCount regex) >>= unwrap++-- ---------------------------------------------------------------------+-- | Compiles a regular expression+--+compile :: CompOption -- ^ (summed together)+ -> ExecOption -- ^ (summed together)+ -> L.ByteString -- ^ The regular expression to compile+ -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: the compiled regular expression+compile c e pattern = do+ asCString pattern (wrapCompile c e)++-- ---------------------------------------------------------------------+-- | Matches a regular expression against a buffer, returning the buffer+-- indicies of the match, and any submatches+--+-- | Matches a regular expression against a string+execute :: Regex -- ^ Compiled regular expression+ -> L.ByteString -- ^ String to match against+ -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))+ -- ^ Returns: 'Nothing' if the regex did not match the+ -- string, or:+ -- 'Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions.+execute regex bs = BS.execute regex (fromLazy bs)++regexec :: Regex -- ^ Compiled regular expression+ -> L.ByteString -- ^ String to match against+ -> IO (Either WrapError (Maybe (L.ByteString, L.ByteString, L.ByteString, [L.ByteString])))+regexec regex bs = do+ x <- BS.regexec regex (fromLazy bs)+ return $ case x of+ Left e -> Left e+ Right Nothing -> Right Nothing+ Right (Just (a,b,c,ds)) -> Right (Just (toLazy a,toLazy b,toLazy c,map toLazy ds))
+ src/Text/Regex/PCRE/Sequence.hs view
@@ -0,0 +1,157 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-|+This exports instances of the high level API and the medium level+API of 'compile','execute', and 'regexec'.+-}+{- Copyright : (c) Chris Kuklewicz 2007 -}+module Text.Regex.PCRE.Sequence(+ -- ** Types+ Regex,+ MatchOffset,+ MatchLength,+ CompOption(CompOption),+ ExecOption(ExecOption),+ ReturnCode,+ WrapError,+ -- ** Miscellaneous+ unusedOffset,+ getVersion,+ -- ** Medium level API functions+ compile,+ execute,+ regexec,+ -- ** Constants for CompOption+ compBlank,+ compAnchored,+ compAutoCallout,+ compCaseless,+ compDollarEndOnly,+ compDotAll,+ compExtended,+ compExtra,+ compFirstLine,+ compMultiline,+ compNoAutoCapture,+ compUngreedy,+ compUTF8,+ compNoUTF8Check,+ -- ** Constants for ExecOption+ execBlank,+ execAnchored,+ execNotBOL,+ execNotEOL,+ execNotEmpty,+ execNoUTF8Check,+ execPartial+ ) where++import Prelude hiding (fail)+import Control.Monad.Fail (MonadFail(fail))++import Text.Regex.PCRE.Wrap -- all+--import Foreign.C.String(withCStringLen,withCString)+import Data.Array(Array,listArray)+import System.IO.Unsafe(unsafePerformIO)+import Text.Regex.Base.RegexLike(RegexMaker(..),RegexLike(..),RegexContext(..),MatchLength,MatchOffset,Extract(..))+import Text.Regex.Base.Impl(polymatch,polymatchM)+import Data.Sequence as S hiding (length)+import qualified Data.Sequence as S (length)+import Foreign.C.String+import Foreign.Marshal.Array+import Foreign.Marshal.Alloc+import Foreign.Storable++instance RegexContext Regex (Seq Char) (Seq Char) where+ match = polymatch+ matchM = polymatchM++unwrap :: (Show e) => Either e v -> IO v+unwrap x = case x of Left err -> fail ("Text.Regex.PCRE.Sequence died: "++ show err)+ Right v -> return v++instance RegexMaker Regex CompOption ExecOption (Seq Char) where+ makeRegexOpts c e pattern = unsafePerformIO $+ compile c e pattern >>= unwrap+ makeRegexOptsM c e pattern = either (fail.show) return $ unsafePerformIO $+ compile c e pattern++instance RegexLike Regex (Seq Char) where+ matchTest regex str = unsafePerformIO $+ withSeq str (wrapTest 0 regex) >>= unwrap+ matchOnce regex str = unsafePerformIO $+ execute regex str >>= unwrap+ matchAll regex str = unsafePerformIO $ + withSeq str (wrapMatchAll regex) >>= unwrap+ matchCount regex str = unsafePerformIO $ + withSeq str (wrapCount regex) >>= unwrap++-- | Compiles a regular expression+compile :: CompOption -- ^ Flags (summed together)+ -> ExecOption -- ^ Flags (summed together)+ -> (Seq Char) -- ^ The regular expression to compile+ -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: an error string and offset or the compiled regular expression+compile c e pattern = withSeq0 pattern (wrapCompile c e)++-- | Matches a regular expression against a string+execute :: Regex -- ^ Compiled regular expression+ -> (Seq Char) -- ^ (Seq Char) to match against+ -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))+ -- ^ Returns: 'Nothing' if the regex did not match the+ -- string, or:+ -- 'Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions.+execute regex str = do+ maybeStartEnd <- withSeq str (wrapMatch 0 regex)+ case maybeStartEnd of+ Right Nothing -> return (Right Nothing)+-- Right (Just []) -> fail "got [] back!" -- should never happen+ Right (Just parts) -> + return . Right . Just . listArray (0,pred (length parts))+ . map (\(s,e)->(fromIntegral s, fromIntegral (e-s))) $ parts+ Left err -> return (Left err)++-- | execute match and extract substrings rather than just offsets+regexec :: Regex -- ^ compiled regular expression+ -> (Seq Char) -- ^ string to match+ -> IO (Either WrapError (Maybe ((Seq Char), (Seq Char),(Seq Char), [(Seq Char)])))+ -- ^ Returns: Nothing if no match, else+ -- (text before match, text after match, array of matches with 0 being the whole match)+regexec regex str = do+ let getSub (start,stop) | start == unusedOffset = S.empty+ | otherwise = extract (start,stop-start) str+ matchedParts [] = (S.empty,S.empty,str,[]) -- no information+ matchedParts (matchedStartStop@(start,stop):subStartStop) = + (before start str+ ,getSub matchedStartStop+ ,after stop str+ ,map getSub subStartStop)+ maybeStartEnd <- withSeq str (wrapMatch 0 regex)+ case maybeStartEnd of+ Right Nothing -> return (Right Nothing)+-- Right (Just []) -> fail "got [] back!" -- should never happen+ Right (Just parts) -> return . Right . Just . matchedParts $ parts+ Left err -> return (Left err)++withSeq :: Seq Char -> (CStringLen -> IO a) -> IO a+withSeq s f =+ let -- Ensure null at end of s+ len = S.length s+ pokes p a | seq p (seq a False) = undefined+ | otherwise =+ case viewl a of+ EmptyL -> return ()+ c :< a' -> poke p (castCharToCChar c) >> pokes (advancePtr p 1) a'+ in allocaBytes (S.length s) (\ptr -> pokes ptr s >> f (ptr,len))++withSeq0 :: Seq Char -> (CString -> IO a) -> IO a+withSeq0 s f =+ let -- Ensure null at end of s+ s' = case viewr s of -- bang !s'+ EmptyR -> singleton '\0'+ _ :> '\0' -> s+ _ -> s |> '\0'+ pokes p a | seq p (seq a False) = undefined+ | otherwise =+ case viewl a of -- bang pokes !p !a+ EmptyL -> return ()+ c :< a' -> poke p (castCharToCChar c) >> pokes (advancePtr p 1) a'+ in allocaBytes (S.length s') (\ptr -> pokes ptr s' >> f ptr)
+ src/Text/Regex/PCRE/String.hs view
@@ -0,0 +1,126 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-|+This exports instances of the high level API and the medium level+API of 'compile','execute', and 'regexec'.+-}+{- Copyright : (c) Chris Kuklewicz 2007 -}+module Text.Regex.PCRE.String(+ -- ** Types+ Regex,+ MatchOffset,+ MatchLength,+ CompOption(CompOption),+ ExecOption(ExecOption),+ ReturnCode,+ WrapError,+ -- ** Miscellaneous+ unusedOffset,+ getVersion,+ -- ** Medium level API functions+ compile,+ execute,+ regexec,+ -- ** Constants for CompOption+ compBlank,+ compAnchored,+ compAutoCallout,+ compCaseless,+ compDollarEndOnly,+ compDotAll,+ compExtended,+ compExtra,+ compFirstLine,+ compMultiline,+ compNoAutoCapture,+ compUngreedy,+ compUTF8,+ compNoUTF8Check,+ -- ** Constants for ExecOption+ execBlank,+ execAnchored,+ execNotBOL,+ execNotEOL,+ execNotEmpty,+ execNoUTF8Check,+ execPartial+ ) where++import Prelude hiding (fail)+import Control.Monad.Fail (MonadFail(fail))++import Text.Regex.PCRE.Wrap -- all+import Foreign.C.String(withCStringLen,withCString)+import Data.Array(Array,listArray)+import System.IO.Unsafe(unsafePerformIO)+import Text.Regex.Base.RegexLike(RegexMaker(..),RegexLike(..),RegexContext(..),MatchLength,MatchOffset)+import Text.Regex.Base.Impl(polymatch,polymatchM)++instance RegexContext Regex String String where+ match = polymatch+ matchM = polymatchM++unwrap :: (Show e) => Either e v -> IO v+unwrap x = case x of Left err -> fail ("Text.Regex.PCRE.String died: "++ show err)+ Right v -> return v++instance RegexMaker Regex CompOption ExecOption String where+ makeRegexOpts c e pattern = unsafePerformIO $+ compile c e pattern >>= unwrap+ makeRegexOptsM c e pattern = either (fail.show) return $ unsafePerformIO $+ compile c e pattern++instance RegexLike Regex String where+ matchTest regex str = unsafePerformIO $+ withCStringLen str (wrapTest 0 regex) >>= unwrap+ matchOnce regex str = unsafePerformIO $+ execute regex str >>= unwrap+ matchAll regex str = unsafePerformIO $ + withCStringLen str (wrapMatchAll regex) >>= unwrap+ matchCount regex str = unsafePerformIO $ + withCStringLen str (wrapCount regex) >>= unwrap++-- | Compiles a regular expression+compile :: CompOption -- ^ Flags (summed together)+ -> ExecOption -- ^ Flags (summed together)+ -> String -- ^ The regular expression to compile+ -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: an error string and offset or the compiled regular expression+compile c e pattern = withCString pattern (wrapCompile c e)++-- | Matches a regular expression against a string+execute :: Regex -- ^ Compiled regular expression+ -> String -- ^ String to match against+ -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))+ -- ^ Returns: 'Nothing' if the regex did not match the+ -- string, or:+ -- 'Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions.+execute regex str = do+ maybeStartEnd <- withCStringLen str (wrapMatch 0 regex)+ case maybeStartEnd of+ Right Nothing -> return (Right Nothing)+-- Right (Just []) -> fail "got [] back!" -- should never happen+ Right (Just parts) -> + return . Right . Just . listArray (0,pred (length parts))+ . map (\(s,e)->(fromIntegral s, fromIntegral (e-s))) $ parts+ Left err -> return (Left err)++-- | execute match and extract substrings rather than just offsets+regexec :: Regex -- ^ compiled regular expression+ -> String -- ^ string to match+ -> IO (Either WrapError (Maybe (String, String,String, [String])))+ -- ^ Returns: Nothing if no match, else+ -- (text before match, text after match, array of matches with 0 being the whole match)+regexec regex str = do+ let getSub (start,stop) | start == unusedOffset = ""+ | otherwise = take (stop-start) . drop start $ str+ matchedParts [] = ("","",str,[]) -- no information+ matchedParts (matchedStartStop@(start,stop):subStartStop) = + (take start str+ ,getSub matchedStartStop+ ,drop stop str+ ,map getSub subStartStop)+ maybeStartEnd <- withCStringLen str (wrapMatch 0 regex)+ case maybeStartEnd of+ Right Nothing -> return (Right Nothing)+-- Right (Just []) -> fail "got [] back!" -- should never happen+ Right (Just parts) -> return . Right . Just . matchedParts $ parts+ Left err -> return (Left err)
+ src/Text/Regex/PCRE/Text.hs view
@@ -0,0 +1,175 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++-- |+-- Copyright: (c) 2006-2017, Chris Dornan and Christopher Kuklewicz+-- SPDX-License-Identifier: BSD-3-Clause+--+-- This exports instances of the high level API and the medium level API of 'compile','execute', and 'regexec'.+--+-- @since 0.95.0+module Text.Regex.PCRE.Text+ (+ -- * Types+ Regex+ , MatchOffset+ , MatchLength+ , CompOption(CompOption)+ , ExecOption(ExecOption)+ , ReturnCode+ , WrapError+ -- * Miscellaneous+ , unusedOffset+ , getVersion+ -- * Medium level API functions+ , compile+ , execute+ , regexec+ -- * CompOption flags+ , compBlank+ , compAnchored+ , compAutoCallout+ , compCaseless+ , compDollarEndOnly+ , compDotAll+ , compExtended+ , compExtra+ , compFirstLine+ , compMultiline+ , compNoAutoCapture+ , compUngreedy+ , compUTF8+ , compNoUTF8Check+ -- * ExecOption flags+ , execBlank+ , execAnchored+ , execNotBOL+ , execNotEOL+ , execNotEmpty+ , execNoUTF8Check+ , execPartial+ ) where++import Data.Array(Array,listArray)+import Data.Char(ord)+import Control.Monad.Fail (fail)+import Prelude hiding (fail)+import qualified Data.ByteString as B+import qualified Data.ByteString.Unsafe as B+import qualified Data.Text as T+import qualified Data.Text.Encoding as T+import Foreign.C.String(CStringLen,CString)+import Foreign(nullPtr)+import System.IO.Unsafe (unsafePerformIO)+import Text.Regex.Base.Impl+import Text.Regex.Base.RegexLike+import Text.Regex.PCRE.Wrap+++instance RegexContext Regex T.Text T.Text where+ match = polymatch+ matchM = polymatchM++instance RegexMaker Regex CompOption ExecOption T.Text where+ makeRegexOpts c e pat = unsafePerformIO $+ compile c e pat >>= unwrap++ makeRegexOptsM c e pat = either (fail.show) return $ unsafePerformIO $+ compile c e pat++instance RegexLike Regex T.Text where+ matchTest re tx = unsafePerformIO $+ asCStringLen tx (wrapTest 0 re) >>= unwrap++ matchOnce re tx = unsafePerformIO $+ execute re tx >>= unwrap++ matchAll re tx = unsafePerformIO $+ asCStringLen tx (wrapMatchAll re) >>= unwrap++ matchCount re tx = unsafePerformIO $+ asCStringLen tx (wrapCount re) >>= unwrap+++-- ---------------------------------------------------------------------+-- | Compiles a regular expression+compile :: CompOption -- ^ (summed together)+ -> ExecOption -- ^ (summed together)+ -> T.Text -- ^ The regular expression to compile+ -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: the compiled regular expression+compile c e pat =+ -- PCRE does not allow one to specify a length for the regular expression, it must by 0 terminated+ asCString pat $ wrapCompile c e+++-- ---------------------------------------------------------------------+-- | Matches a regular expression against a string+execute :: Regex -- ^ Compiled regular expression+ -> T.Text -- ^ Text to match against+ -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))+ -- ^ Returns: 'Nothing' if the regex did not match the+ -- string, or 'Just' an array of (offset,length) pairs+ -- where index 0 is whole match, and the rest are the+ -- captured subexpressions.+execute re tx = do+ maybeStartEnd <- asCStringLen tx (wrapMatch 0 re)+ case maybeStartEnd of+ Right Nothing -> return $ Right Nothing+ Right (Just parts) ->+ return $ Right $ Just $ listArray (0,pred $ length parts)+ [ (s,e-s) | (s,e) <- parts ]+ Left err -> return $ Left err+++-- ---------------------------------------------------------------------+-- | Matches a regular expression against a string+regexec :: Regex -- ^ Compiled regular expression+ -> T.Text -- ^ Text to match against+ -> IO (Either WrapError (Maybe (T.Text, T.Text, T.Text, [T.Text])))+ -- ^ Returns: 'Nothing' if the regex did not match the+ -- string, or 'Just' text including before and after text+regexec re tx = do+ mb <- asCStringLen tx $ wrapMatch 0 re+ case mb of+ Right Nothing -> return (Right Nothing)+ Right (Just parts) -> return . Right . Just . matchedParts $ parts+ Left err -> return (Left err)+ where+ matchedParts [] = (T.empty,T.empty,tx,[]) -- no information+ matchedParts (mtchd@(start,stop):rst) =+ ( T.take start tx+ , getSub mtchd+ , T.drop stop tx+ , map getSub rst+ )++ getSub (start,stop)+ | start == unusedOffset = T.empty+ | otherwise = T.take (stop-start) . T.drop start $ tx+++-- ---------------------------------------------------------------------+-- helpers++unwrap :: (Show e) => Either e v -> IO v+unwrap x = case x of+ Left e -> fail $ "Text.Regex.PCRE.Text died: " ++ show e+ Right v -> return v++{-# INLINE asCString #-}+asCString :: T.Text -> (CString->IO a) -> IO a+asCString t+ | T.null t || (ord (T.last t) /= 0) = B.useAsCString $ T.encodeUtf8 t+ | otherwise = B.unsafeUseAsCString $ T.encodeUtf8 t++{-# INLINE asCStringLen #-}+asCStringLen :: T.Text -> (CStringLen->IO a) -> IO a+asCStringLen s op = B.unsafeUseAsCStringLen (T.encodeUtf8 s) checked+ where+ checked cs@(ptr,_)+ | ptr == nullPtr = B.unsafeUseAsCStringLen myEmpty $ op . trim+ | otherwise = op cs++ trim (ptr,_) = (ptr,0)++myEmpty :: B.ByteString+myEmpty = B.pack [0]
+ src/Text/Regex/PCRE/Text/Lazy.hs view
@@ -0,0 +1,170 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++-- |+-- Copyright: (c) 2006-2017, Chris Dornan and Christopher Kuklewicz+-- SPDX-License-Identifier: BSD-3-Clause+--+-- This exports instances of the high level API and the medium level API of 'compile','execute', and 'regexec'.+--+-- @since 0.95.0+module Text.Regex.PCRE.Text.Lazy+ (+ -- * Types+ Regex+ , MatchOffset+ , MatchLength+ , CompOption(CompOption)+ , ExecOption(ExecOption)+ , ReturnCode+ , WrapError+ -- * Miscellaneous+ , unusedOffset+ , getVersion+ -- * Medium level API functions+ , compile+ , execute+ , regexec+ -- * CompOption flags+ , compBlank+ , compAnchored+ , compAutoCallout+ , compCaseless+ , compDollarEndOnly+ , compDotAll+ , compExtended+ , compExtra+ , compFirstLine+ , compMultiline+ , compNoAutoCapture+ , compUngreedy+ , compUTF8+ , compNoUTF8Check+ -- * ExecOption flags+ , execBlank+ , execAnchored+ , execNotBOL+ , execNotEOL+ , execNotEmpty+ , execNoUTF8Check+ , execPartial+ ) where++import Data.Array(Array,listArray)+import qualified Data.ByteString as B+import qualified Data.ByteString.Unsafe as B+import qualified Data.Text.Encoding as T+import qualified Data.Text.Lazy as TL+import Foreign.C.String(CStringLen,CString)+import Foreign(nullPtr)+import System.IO.Unsafe (unsafePerformIO)+import Text.Regex.Base.Impl+import Text.Regex.Base.RegexLike+import Text.Regex.PCRE.Wrap+++instance RegexContext Regex TL.Text TL.Text where+ match = polymatch+ matchM = polymatchM++instance RegexMaker Regex CompOption ExecOption TL.Text where+ makeRegexOpts c e pat = unsafePerformIO $+ compile c e pat >>= unwrap++ makeRegexOptsM c e pat = either (fail.show) return $ unsafePerformIO $+ compile c e pat++instance RegexLike Regex TL.Text where+ matchTest re tx = unsafePerformIO $+ asCStringLen tx (wrapTest 0 re) >>= unwrap++ matchOnce re tx = unsafePerformIO $+ execute re tx >>= unwrap++ matchAll re tx = unsafePerformIO $+ asCStringLen tx (wrapMatchAll re) >>= unwrap++ matchCount re tx = unsafePerformIO $+ asCStringLen tx (wrapCount re) >>= unwrap+++-- ---------------------------------------------------------------------+-- | Compiles a regular expression+compile :: CompOption -- ^ (summed together)+ -> ExecOption -- ^ (summed together)+ -> TL.Text -- ^ The regular expression to compile+ -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: the compiled regular expression+compile c e pat =+ -- PCRE does not allow one to specify a length for the regular expression, it must by 0 terminated+ asCString pat $ wrapCompile c e+++-- ---------------------------------------------------------------------+-- | Matches a regular expression against a string+execute :: Regex -- ^ Compiled regular expression+ -> TL.Text -- ^ Text to match against+ -> IO (Either WrapError (Maybe (Array Int (MatchOffset,MatchLength))))+ -- ^ Returns: 'Nothing' if the regex did not match the+ -- string, or 'Just' an array of (offset,length) pairs+ -- where index 0 is whole match, and the rest are the+ -- captured subexpressions.+execute re tx = do+ maybeStartEnd <- asCStringLen tx $ wrapMatch 0 re+ case maybeStartEnd of+ Right Nothing -> return $ Right Nothing+ Right (Just parts) ->+ return $ Right $ Just $ listArray (0,pred $ length parts)+ [ (s,e-s) | (s,e) <- parts ]+ Left err -> return $ Left err++-- ---------------------------------------------------------------------+-- | Matches a regular expression against a string+regexec :: Regex -- ^ Compiled regular expression+ -> TL.Text -- ^ Text to match against+ -> IO (Either WrapError (Maybe (TL.Text, TL.Text, TL.Text, [TL.Text])))+ -- ^ Returns: 'Nothing' if the regex did not match the+ -- string, or 'Just' text including before and after text+regexec re tx = do+ mb <- asCStringLen tx $ wrapMatch 0 re+ case mb of+ Right Nothing -> return $ Right Nothing+ Right (Just parts) -> return $ Right $ Just $ matchedParts parts+ Left err -> return $ Left err+ where+ matchedParts [] = (TL.empty,TL.empty,tx,[]) -- no information+ matchedParts (mtchd@(start,stop):rst) =+ ( TL.take (fromIntegral start) tx+ , getSub mtchd+ , TL.drop (fromIntegral stop) tx+ , map getSub rst+ )++ getSub (start,stop)+ | start == unusedOffset = TL.empty+ | otherwise = TL.take (fromIntegral $ stop-start) $+ TL.drop (fromIntegral start) tx+++-- ---------------------------------------------------------------------+-- helpers++unwrap :: (Show e) => Either e v -> IO v+unwrap x = case x of+ Left e -> fail $ "Text.Regex.PCRE.Text died: " ++ show e+ Right v -> return v++{-# INLINE asCString #-}+asCString :: TL.Text -> (CString->IO a) -> IO a+asCString = B.unsafeUseAsCString . T.encodeUtf8 . TL.toStrict++{-# INLINE asCStringLen #-}+asCStringLen :: TL.Text -> (CStringLen->IO a) -> IO a+asCStringLen s op = B.unsafeUseAsCStringLen (T.encodeUtf8 $ TL.toStrict s) checked+ where+ checked cs@(ptr,_)+ | ptr == nullPtr = B.unsafeUseAsCStringLen myEmpty $ op . trim+ | otherwise = op cs++ trim (ptr,_) = (ptr,0)++myEmpty :: B.ByteString+myEmpty = B.pack [0]
+ src/Text/Regex/PCRE/Wrap.hsc view
@@ -0,0 +1,421 @@+{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}+-- The exported symbols are the same whether HAVE_PCRE_H is defined,+-- but when if it is not defined then 'getVersion == Nothing' and all+-- other exported values will call error or fail.++-- | This will fail or error only if allocation fails or a nullPtr is passed in.++-- TODO :: Consider wrapMatchAll using list of start/end offsets and not MatchArray+--++{- Copyright : (c) Chris Kuklewicz 2007 -}+module Text.Regex.PCRE.Wrap(+ -- ** High-level interface+ Regex,+ CompOption(CompOption),+ ExecOption(ExecOption),+ (=~),+ (=~~),++ -- ** Low-level interface+ StartOffset,+ EndOffset,+ ReturnCode(ReturnCode),+ WrapError,+ wrapCompile,+ wrapTest,+ wrapMatch,+ wrapMatchAll,+ wrapCount,++ -- ** Miscellaneous+ getVersion,+ configUTF8,+ getNumSubs,+ unusedOffset,++ -- ** CompOption values+ compBlank,+ compAnchored,+ compAutoCallout,+ compCaseless,+ compDollarEndOnly,+ compDotAll,+ compExtended,+ compExtra,+ compFirstLine,+ compMultiline,+ compNoAutoCapture,+ compUngreedy,+ compUTF8,+ compNoUTF8Check,++ -- ** ExecOption values+ execBlank,+ execAnchored,+ execNotBOL,+ execNotEOL,+ execNotEmpty,+ execNoUTF8Check,+ execPartial,++ -- ** ReturnCode values+ retOk,+ retNoMatch,+ retNull,+ retBadOption,+ retBadMagic,+ retUnknownNode,+ retNoMemory,+ retNoSubstring+ ) where++import Prelude hiding (fail)+import Control.Monad.Fail (MonadFail(fail))++import Control.Monad(when)+import Data.Array(Array,accumArray)+import Data.Bits(Bits((.|.))) -- ((.&.),(.|.),complement))+import System.IO.Unsafe(unsafePerformIO)+import Foreign(Ptr,ForeignPtr,FinalizerPtr -- ,FunPtr+ ,alloca,allocaBytes,nullPtr+ ,peek,peekElemOff+ ,newForeignPtr,withForeignPtr)+import Foreign.C(CInt(..),CChar)+import Foreign.C.String(CString,CStringLen,peekCString)+import Text.Regex.Base.RegexLike(RegexOptions(..),RegexMaker(..),RegexContext(..),MatchArray,MatchOffset)++-- | Version string of PCRE library+--+-- __NOTE__: The 'Maybe' type is used for historic reasons; practically, 'getVersion' is never 'Nothing'.+{-# NOINLINE getVersion #-}+getVersion :: Maybe String++type PCRE = ()+type StartOffset = MatchOffset+type EndOffset = MatchOffset+type WrapError = (ReturnCode,String)++newtype CompOption = CompOption CInt deriving (Eq,Show,Num,Bits)+newtype ExecOption = ExecOption CInt deriving (Eq,Show,Num,Bits)+newtype ReturnCode = ReturnCode CInt deriving (Eq,Show)++-- | A compiled regular expression+data Regex = Regex (ForeignPtr PCRE) CompOption ExecOption++compBlank :: CompOption+execBlank :: ExecOption+unusedOffset :: MatchOffset+retOk :: ReturnCode++wrapCompile :: CompOption -- ^ Flags (summed together)+ -> ExecOption -- ^ Flags (summed together)+ -> CString -- ^ The regular expression to compile+ -> IO (Either (MatchOffset,String) Regex) -- ^ Returns: an error offset and string or the compiled regular expression+wrapTest :: StartOffset -- ^ Starting index in CStringLen+ -> Regex -- ^ Compiled regular expression+ -> CStringLen -- ^ String to match against and length in bytes+ -> IO (Either WrapError Bool)+wrapMatch :: StartOffset -- ^ Starting index in CStringLen+ -> Regex -- ^ Compiled regular expression+ -> CStringLen -- ^ String to match against and length in bytes+ -> IO (Either WrapError (Maybe [(StartOffset,EndOffset)]))+ -- ^ Returns: 'Right Nothing' if the regex did not match the+ -- string, or:+ -- 'Right Just' an array of (offset,length) pairs where index 0 is whole match, and the rest are the captured subexpressions, or:+ -- 'Left ReturnCode' if there is some strange error+wrapMatchAll :: Regex -> CStringLen -> IO (Either WrapError [ MatchArray ])+wrapCount :: Regex -> CStringLen -> IO (Either WrapError Int)++getNumSubs :: Regex -> Int++{-# NOINLINE configUTF8 #-}+configUTF8 :: Bool++(=~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target)+ => source1 -> source -> target+(=~~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target,MonadFail m)+ => source1 -> source -> m target++#include <sys/types.h>+#include <pcre.h>++instance RegexOptions Regex CompOption ExecOption where+ blankCompOpt = compBlank+ blankExecOpt = execBlank+ defaultCompOpt = compMultiline+ defaultExecOpt = execBlank+ setExecOpts e' (Regex r c _) = Regex r c e'+ getExecOpts (Regex _ _ e) = e++-- (=~) :: (RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target) => source1 -> source -> target+(=~) x r = let q :: Regex+ q = makeRegex r+ in match q x++-- (=~~) ::(RegexMaker Regex CompOption ExecOption source,RegexContext Regex source1 target,MonadFail m) => source1 -> source -> m target+(=~~) x r = do (q :: Regex) <- makeRegexM r+ matchM q x++type PCRE_Extra = ()++fi :: (Integral i,Num n ) => i -> n+fi x = fromIntegral x++compBlank = CompOption 0+execBlank = ExecOption 0+unusedOffset = (-1)+retOk = ReturnCode 0++retNeededMoreSpace :: ReturnCode+retNeededMoreSpace = ReturnCode 0++newtype InfoWhat = InfoWhat CInt deriving (Eq,Show)+newtype ConfigWhat = ConfigWhat CInt deriving (Eq,Show)++nullTest' :: Ptr a -> String -> IO (Either (MatchOffset,String) b) -> IO (Either (MatchOffset,String) b)+{-# INLINE nullTest' #-}+nullTest' ptr msg io = do+ if nullPtr == ptr+ then return (Left (0,"Ptr parameter was nullPtr in Text.Regex.PCRE.Wrap."++msg))+ else io++nullTest :: Ptr a -> String -> IO (Either WrapError b) -> IO (Either WrapError b)+{-# INLINE nullTest #-}+nullTest ptr msg io = do+ if nullPtr == ptr+ then return (Left (retOk,"Ptr parameter was nullPtr in Text.Regex.PCRE.Wrap."++msg))+ else io++wrapRC :: ReturnCode -> IO (Either WrapError b)+{-# INLINE wrapRC #-}+wrapRC r = return (Left (r,"Error in Text.Regex.PCRE.Wrap: "++show r))++-- | Compiles a regular expression+wrapCompile flags e pattern = do+ nullTest' pattern "wrapCompile pattern" $ do+ alloca $ \errOffset -> alloca $ \errPtr -> do+ nullTest' errPtr "wrapCompile errPtr" $ do+ pcre_ptr <- c_pcre_compile pattern flags errPtr errOffset nullPtr+ if pcre_ptr == nullPtr+ then do+ -- No need to use c_ptr_free in the error case (e.g. pcredemo.c)+ offset <- peek errOffset+ string <- peekCString =<< peek errPtr+ return (Left (fi offset,string))+ else do regex <- newForeignPtr c_ptr_free pcre_ptr+ return . Right $ Regex regex flags e++getNumSubs (Regex pcre_fptr _ _) = fi . unsafePerformIO $ withForeignPtr pcre_fptr getNumSubs'++getNumSubs' :: Ptr PCRE -> IO CInt+{-# INLINE getNumSubs' #-}+getNumSubs' pcre_ptr =+ alloca $ \st -> do -- (st :: Ptr CInt)+ when (st == nullPtr) (fail "Text.Regex.PCRE.Wrap.getNumSubs' could not allocate a CInt!!!")+ c_pcre_fullinfo pcre_ptr nullPtr pcreInfoCapturecount st+ peek st++wrapTest startOffset (Regex pcre_fptr _ flags) (cstr,len) = do+ nullTest cstr "wrapTest cstr" $ do+ withForeignPtr pcre_fptr $ \pcre_ptr -> do+ r@(ReturnCode r') <- c_pcre_exec pcre_ptr nullPtr cstr (fi len) (fi startOffset) flags nullPtr 0+ if r == retNoMatch+ then return (Right False)+ else if r' < 0+ then wrapRC r+ else return (Right True)++-- | Matches a regular expression against a string+--+-- Should never return (Right (Just []))+wrapMatch startOffset (Regex pcre_fptr _ flags) (cstr,len) = do+ nullTest cstr "wrapMatch cstr" $ do+ withForeignPtr pcre_fptr $ \pcre_ptr -> do+ nsub <- getNumSubs' pcre_ptr+ let nsub_int :: Int+ nsub_int = fi nsub+ ovec_size :: CInt+ ovec_size = ((nsub + 1) * 3) -- "man pcreapi" for explanation+ ovec_bytes :: Int+ ovec_bytes = (fi ovec_size) * (#const sizeof(int))+ allocaBytes ovec_bytes $ \ovec -> do+ nullTest ovec "wrapMatch ovec" $ do+ r@(ReturnCode r') <- c_pcre_exec pcre_ptr nullPtr cstr (fi len) (fi startOffset) flags ovec ovec_size+ if r == retNoMatch+ then return (Right Nothing)+ else if r' < 0+ then wrapRC r+ else do+ let pairsSet :: Int+ pairsSet = if r == retNeededMoreSpace -- if r == ReturnCode 0+ then nsub_int + 1 -- should not happen+ else fi r' -- implies pairsSet > 0+ extraPairs :: [(Int,Int)]+ extraPairs = replicate (nsub_int + 1 - pairsSet)+ (unusedOffset,unusedOffset)+ pairs <- return . toPairs =<< mapM (peekElemOff ovec) [0 .. ((pairsSet*2)-1)]+ return . Right . Just $ (pairs ++ extraPairs)++-- | wrapMatchAll is an improvement over wrapMatch since it only+-- allocates memory with allocaBytes once at the start.+--+--+wrapMatchAll (Regex pcre_fptr _ flags) (cstr,len) = do+ nullTest cstr "wrapMatchAll cstr" $ do+ withForeignPtr pcre_fptr $ \regex -> do+ nsub <- getNumSubs' regex+ let nsub_int :: Int+ nsub_int = fi nsub+ ovec_size :: CInt+ ovec_size = ((nsub + 1) * 3) -- "man pcreapi" for explanation+ ovec_bytes :: Int+ ovec_bytes = (fi ovec_size) * (#const sizeof(int))+ clen = fi len+ flags' = (execNotEmpty .|. execAnchored .|. flags)+ allocaBytes ovec_bytes $ \ovec ->+ nullTest ovec "wrapMatchAll ovec" $+ let loop acc flags_in_use pos = do+ r@(ReturnCode r') <- c_pcre_exec regex nullPtr cstr clen (fi pos) flags_in_use ovec ovec_size+ if r == retNoMatch+ then return (Right (acc []))+ else if r' < 0+ then wrapRC r+ else do+ let pairsSet = if r == retNeededMoreSpace then nsub_int+1 else fi r'+ pairs <- return . toPairs =<< mapM (peekElemOff ovec) [0 .. ((pairsSet*2)-1)]+ let acc' = acc . (toMatchArray nsub_int pairs:)+ case pairs of+ [] -> return (Right (acc' []))+ ((s,e):_) | s==e -> if s == len+ then return (Right (acc' []))+ else loop acc' flags' e+ | otherwise -> loop acc' flags e+ in loop id flags 0+toMatchArray :: Int -> [(Int,Int)] -> Array Int (Int,Int)+toMatchArray n pairs = accumArray (\_ (s,e) -> (s,(e-s))) (-1,0) (0,n) (zip [0..] pairs)++toPairs :: [CInt] -> [(Int,Int)]+toPairs [] = []+toPairs (a:b:rest) = (fi a,fi b):toPairs rest+toPairs [_] = error "Should not have just one element in WrapPCRE.wrapMatchAll.toPairs"++wrapCount (Regex pcre_fptr _ flags) (cstr,len) = do+ nullTest cstr "wrapCount cstr" $ do+ withForeignPtr pcre_fptr $ \pcre_ptr -> do+ nsub <- getNumSubs' pcre_ptr+ let ovec_size :: CInt+ ovec_size = ((nsub + 1) * 3) -- "man pcreapi" for explanation+ ovec_bytes :: Int+ ovec_bytes = (fi ovec_size) * (#const sizeof(int))+ clen = fi len+ allocaBytes ovec_bytes $ \ovec ->+ nullTest ovec "wrapCount ovec" $+ let act pos = c_pcre_exec pcre_ptr nullPtr cstr clen (fi pos) flags ovec ovec_size+ loop acc pos | acc `seq` pos `seq` False = undefined+ | otherwise = do+ r@(ReturnCode r') <- act pos+ if r == retNoMatch+ then return (Right acc)+ else if r' < 0+ then wrapRC r+ else do+ pairs <- return . toPairs =<< mapM (peekElemOff ovec) [0,1]+ case pairs of+ [] -> return (Right (succ acc))+ ((s,e):_) | s==e -> return (Right (succ acc))+ | otherwise -> loop (succ acc) e+ in loop 0 0++getVersion = unsafePerformIO $ do+ version <- c_pcre_version+ if version == nullPtr+ then return (Just "pcre_version was null")+ else return . Just =<< peekCString version++configUTF8 = unsafePerformIO $+ alloca $ \ptrVal -> do -- (ptrVal :: Ptr CInt)+ when (ptrVal == nullPtr) (fail "Text.Regex.PCRE.Wrap.configUTF8 could not alloca CInt!!!")+ c_pcre_config pcreConfigUtf8 ptrVal+ val <- peek ptrVal+ case val of+ (1 :: CInt) -> return True+ 0 -> return False+ _ -> return False -- should not happen++foreign import ccall unsafe "pcre.h pcre_compile"+ c_pcre_compile :: CString -> CompOption -> Ptr CString -> Ptr CInt -> CString -> IO (Ptr PCRE)+foreign import ccall unsafe "&free"+ c_ptr_free :: FinalizerPtr a -- FunPtr (Ptr a -> IO ())+foreign import ccall unsafe "pcre.h pcre_exec"+ c_pcre_exec :: Ptr PCRE -> Ptr PCRE_Extra -> CString -> CInt -> CInt -> ExecOption -> Ptr CInt -> CInt -> IO ReturnCode+foreign import ccall unsafe "pcre.h pcre_fullinfo"+ c_pcre_fullinfo :: Ptr PCRE -> Ptr PCRE_Extra -> InfoWhat -> Ptr a -> IO CInt+foreign import ccall unsafe "pcre.h pcre_version"+ c_pcre_version :: IO (Ptr CChar)+foreign import ccall unsafe "pcre.h pcre_config"+ c_pcre_config :: ConfigWhat -> Ptr a -> IO CInt+++#enum CompOption,CompOption, \+ compAnchored = PCRE_ANCHORED, \+ compAutoCallout = PCRE_AUTO_CALLOUT, \+ compCaseless = PCRE_CASELESS, \+ compDollarEndOnly = PCRE_DOLLAR_ENDONLY, \+ compDotAll = PCRE_DOTALL, \+ compExtended = PCRE_EXTENDED, \+ compExtra = PCRE_EXTRA, \+ compFirstLine = PCRE_FIRSTLINE, \+ compMultiline = PCRE_MULTILINE, \+ compNoAutoCapture = PCRE_NO_AUTO_CAPTURE, \+ compUngreedy = PCRE_UNGREEDY, \+ compUTF8 = PCRE_UTF8, \+ compNoUTF8Check = PCRE_NO_UTF8_CHECK++#enum ExecOption,ExecOption, \+ execAnchored = PCRE_ANCHORED, \+ execNotBOL = PCRE_NOTBOL, \+ execNotEOL = PCRE_NOTEOL, \+ execNotEmpty = PCRE_NOTEMPTY, \+ execNoUTF8Check = PCRE_NO_UTF8_CHECK, \+ execPartial = PCRE_PARTIAL++#enum ReturnCode,ReturnCode, \+ retNoMatch = PCRE_ERROR_NOMATCH, \+ retNull = PCRE_ERROR_NULL, \+ retBadOption = PCRE_ERROR_BADOPTION, \+ retBadMagic = PCRE_ERROR_BADMAGIC, \+ retUnknownNode = PCRE_ERROR_UNKNOWN_NODE, \+ retNoMemory = PCRE_ERROR_NOMEMORY, \+ retNoSubstring = PCRE_ERROR_NOSUBSTRING++-- Comment out most of these to avoid unused binding warnings++-- PCRE_INFO_FIRSTCHAR is deprecated, use PCRE_INFO_FIRSTBYTE instead.+#enum InfoWhat,InfoWhat, \+ PCRE_INFO_CAPTURECOUNT+{-+ PCRE_INFO_BACKREFMAX, \+ PCRE_INFO_DEFAULT_TABLES, \+ PCRE_INFO_FIRSTBYTE, \+ PCRE_INFO_FIRSTCHAR, \+ PCRE_INFO_FIRSTTABLE, \+ PCRE_INFO_LASTLITERAL, \+ PCRE_INFO_NAMECOUNT, \+ PCRE_INFO_NAMEENTRYSIZE, \+ PCRE_INFO_NAMETABLE, \+ PCRE_INFO_OPTIONS, \+ PCRE_INFO_SIZE, \+ PCRE_INFO_STUDYSIZE+-}+#enum ConfigWhat,ConfigWhat, \+ PCRE_CONFIG_UTF8+{-+ PCRE_CONFIG_UNICODE_PROPERTIES, \+ PCRE_CONFIG_NEWLINE, \+ PCRE_CONFIG_LINK_SIZE, \+ PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, \+ PCRE_CONFIG_MATCH_LIMIT, \+ PCRE_CONFIG_MATCH_LIMIT_RECURSION, \+ PCRE_CONFIG_STACKRECURSE+-}