runtime/RegExp.h

   1 /*
   2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
   4  *  Copyright (C) 2009 Torch Mobile, Inc.
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Lesser General Public
   8  *  License as published by the Free Software Foundation; either
   9  *  version 2 of the License, or (at your option) any later version.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Lesser General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Lesser General Public
  17  *  License along with this library; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifndef RegExp_h
  23 #define RegExp_h
  24
  25 #include "ExecutableAllocator.h"
  26 #include "MatchResult.h"
  27 #include "RegExpKey.h"
  28 #include "Structure.h"
  29 #include "yarr/Yarr.h"
  30 #include <wtf/Forward.h>
  31 #include <wtf/RefCounted.h>
  32 #include <wtf/text/WTFString.h>
  33
  34 #if ENABLE(YARR_JIT)
  35 #include "yarr/YarrJIT.h"
  36 #endif
  37
  38 namespace JSC {
  39
  40     struct RegExpRepresentation;
  41     class VM;
  42
  43     JS_EXPORT_PRIVATE RegExpFlags regExpFlags(const String&);
  44
  45     class RegExp : public JSCell {
  46     public:
  47         typedef JSCell Base;
  48
  49         JS_EXPORT_PRIVATE static RegExp* create(VM&, const String& pattern, RegExpFlags);
  50         static const bool needsDestruction = true;
  51         static const bool hasImmortalStructure = true;
  52         static void destroy(JSCell*);
  53
  54         bool global() const { return m_flags & FlagGlobal; }
  55         bool ignoreCase() const { return m_flags & FlagIgnoreCase; }
  56         bool multiline() const { return m_flags & FlagMultiline; }
  57
  58         const String& pattern() const { return m_patternString; }
  59
  60         bool isValid() const { return !m_constructionError && m_flags != InvalidFlags; }
  61         const char* errorMessage() const { return m_constructionError; }
  62
  63         JS_EXPORT_PRIVATE int match(VM&, const String&, unsigned startOffset, Vector<int, 32>& ovector);
  64         MatchResult match(VM&, const String&, unsigned startOffset);
  65         unsigned numSubpatterns() const { return m_numSubpatterns; }
  66
  67         bool hasCode()
  68         {
  69             return m_state != NotCompiled;
  70         }
  71
  72         void invalidateCode();
  73
  74 #if ENABLE(REGEXP_TRACING)
  75         void printTraceData();
  76 #endif
  77
  78         static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
  79         {
  80             return Structure::create(vm, globalObject, prototype, TypeInfo(LeafType, 0), &s_info);
  81         }
  82
  83         static const ClassInfo s_info;
  84
  85         RegExpKey key() { return RegExpKey(m_flags, m_patternString); }
  86
  87     protected:
  88         void finishCreation(VM&);
  89
  90     private:
  91         friend class RegExpCache;
  92         RegExp(VM&, const String&, RegExpFlags);
  93
  94         static RegExp* createWithoutCaching(VM&, const String&, RegExpFlags);
  95
  96         enum RegExpState {
  97             ParseError,
  98             JITCode,
  99             ByteCode,
 100             NotCompiled
 101         } m_state;
 102
 103         void compile(VM*, Yarr::YarrCharSize);
 104         void compileIfNecessary(VM&, Yarr::YarrCharSize);
 105
 106         void compileMatchOnly(VM*, Yarr::YarrCharSize);
 107         void compileIfNecessaryMatchOnly(VM&, Yarr::YarrCharSize);
 108
 109 #if ENABLE(YARR_JIT_DEBUG)
 110         void matchCompareWithInterpreter(const String&, int startOffset, int* offsetVector, int jitResult);
 111 #endif
 112
 113         String m_patternString;
 114         RegExpFlags m_flags;
 115         const char* m_constructionError;
 116         unsigned m_numSubpatterns;
 117 #if ENABLE(REGEXP_TRACING)
 118         unsigned m_rtMatchCallCount;
 119         unsigned m_rtMatchFoundCount;
 120 #endif
 121
 122 #if ENABLE(YARR_JIT)
 123         Yarr::YarrCodeBlock m_regExpJITCode;
 124 #endif
 125         OwnPtr<Yarr::BytecodePattern> m_regExpBytecode;
 126     };
 127
 128 } // namespace JSC
 129
 130 #endif // RegExp_h