JavaScriptCore-1218.34.tar.gz

[apple/javascriptcore.git] / yarr / YarrPattern.h

diff --git a/yarr/YarrPattern.h b/yarr/YarrPattern.h
index 97c3870425efc67da54194ceabd73c26b17351e9..e7d187c2b30fed251654bd174e3299f0fef437a9 100644 (file)
--- a/yarr/YarrPattern.h
+++ b/yarr/YarrPattern.h
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (C) 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2009, 2013 Apple Inc. All rights reserved.

  * Copyright (C) 2010 Peter Varga (pvarga@inf.u-szeged.hu), University of Szeged
  *
  * Redistribution and use in source and binary forms, with or without
  * Copyright (C) 2010 Peter Varga (pvarga@inf.u-szeged.hu), University of Szeged
  *
  * Redistribution and use in source and binary forms, with or without


@@ -27,8 +27,12 @@
 #ifndef YarrPattern_h
 #define YarrPattern_h
 
 #ifndef YarrPattern_h
 #define YarrPattern_h
 

-#include <runtime/UString.h>
+#include <wtf/CheckedArithmetic.h>
+#include <wtf/OwnPtr.h>
+#include <wtf/PassOwnPtr.h>
+#include <wtf/RefCounted.h>

 #include <wtf/Vector.h>
 #include <wtf/Vector.h>

+#include <wtf/text/WTFString.h>

 #include <wtf/unicode/Unicode.h>
 
 namespace JSC { namespace Yarr {
 #include <wtf/unicode/Unicode.h>
 
 namespace JSC { namespace Yarr {


@@ -46,37 +50,28 @@ struct CharacterRange {
     }
 };
 
     }
 };
 

-struct CharacterClassTable : RefCounted<CharacterClassTable> {
-    const char* m_table;
-    bool m_inverted;
-    static PassRefPtr<CharacterClassTable> create(const char* table, bool inverted)
-    {
-        return adoptRef(new CharacterClassTable(table, inverted));
-    }
-
-private:
-    CharacterClassTable(const char* table, bool inverted)
-        : m_table(table)
-        , m_inverted(inverted)
-    {
-    }
-};
-

 struct CharacterClass {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     // All CharacterClass instances have to have the full set of matches and ranges,
 struct CharacterClass {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     // All CharacterClass instances have to have the full set of matches and ranges,

-    // they may have an optional table for faster lookups (which must match the
+    // they may have an optional m_table for faster lookups (which must match the

     // specified matches and ranges)
     // specified matches and ranges)

-    CharacterClass(PassRefPtr<CharacterClassTable> table)
+    CharacterClass()
+        : m_table(0)
+    {
+    }
+    CharacterClass(const char* table, bool inverted)

         : m_table(table)
         : m_table(table)

+        , m_tableInverted(inverted)

     {
     }
     Vector<UChar> m_matches;
     Vector<CharacterRange> m_ranges;
     Vector<UChar> m_matchesUnicode;
     Vector<CharacterRange> m_rangesUnicode;
     {
     }
     Vector<UChar> m_matches;
     Vector<CharacterRange> m_ranges;
     Vector<UChar> m_matchesUnicode;
     Vector<CharacterRange> m_rangesUnicode;

-    RefPtr<CharacterClassTable> m_table;
+
+    const char* m_table;
+    bool m_tableInverted;

 };
 
 enum QuantifierType {
 };
 
 enum QuantifierType {


@@ -117,7 +112,7 @@ struct PatternTerm {
         } anchors;
     };
     QuantifierType quantityType;
         } anchors;
     };
     QuantifierType quantityType;

-    unsigned quantityCount;
+    Checked<unsigned> quantityCount;

     int inputPosition;
     unsigned frameLocation;
 
     int inputPosition;
     unsigned frameLocation;
 


@@ -273,19 +268,14 @@ public:
     {
     }
     
     {
     }
     

-    ~PatternDisjunction()
-    {
-        deleteAllValues(m_alternatives);
-    }
-

     PatternAlternative* addNewAlternative()
     {
         PatternAlternative* alternative = new PatternAlternative(this);
     PatternAlternative* addNewAlternative()
     {
         PatternAlternative* alternative = new PatternAlternative(this);

-        m_alternatives.append(alternative);
+        m_alternatives.append(adoptPtr(alternative));

         return alternative;
     }
 
         return alternative;
     }
 

-    Vector<PatternAlternative*> m_alternatives;
+    Vector<OwnPtr<PatternAlternative> > m_alternatives;

     PatternAlternative* m_parent;
     unsigned m_minimumSize;
     unsigned m_callFrameSize;
     PatternAlternative* m_parent;
     unsigned m_minimumSize;
     unsigned m_callFrameSize;


@@ -314,13 +304,7 @@ struct TermChain {
 };
 
 struct YarrPattern {
 };
 
 struct YarrPattern {

-    YarrPattern(const UString& pattern, bool ignoreCase, bool multiline, const char** error);
-
-    ~YarrPattern()
-    {
-        deleteAllValues(m_disjunctions);
-        deleteAllValues(m_userCharacterClasses);
-    }
+    JS_EXPORT_PRIVATE YarrPattern(const String& pattern, bool ignoreCase, bool multiline, const char** error);

 
     void reset()
     {
 
     void reset()
     {


@@ -338,9 +322,7 @@ struct YarrPattern {
         nonspacesCached = 0;
         nonwordcharCached = 0;
 
         nonspacesCached = 0;
         nonwordcharCached = 0;
 

-        deleteAllValues(m_disjunctions);

         m_disjunctions.clear();
         m_disjunctions.clear();

-        deleteAllValues(m_userCharacterClasses);

         m_userCharacterClasses.clear();
     }
 
         m_userCharacterClasses.clear();
     }
 


@@ -352,43 +334,43 @@ struct YarrPattern {
     CharacterClass* newlineCharacterClass()
     {
         if (!newlineCached)
     CharacterClass* newlineCharacterClass()
     {
         if (!newlineCached)

-            m_userCharacterClasses.append(newlineCached = newlineCreate());
+            m_userCharacterClasses.append(adoptPtr(newlineCached = newlineCreate()));

         return newlineCached;
     }
     CharacterClass* digitsCharacterClass()
     {
         if (!digitsCached)
         return newlineCached;
     }
     CharacterClass* digitsCharacterClass()
     {
         if (!digitsCached)

-            m_userCharacterClasses.append(digitsCached = digitsCreate());
+            m_userCharacterClasses.append(adoptPtr(digitsCached = digitsCreate()));

         return digitsCached;
     }
     CharacterClass* spacesCharacterClass()
     {
         if (!spacesCached)
         return digitsCached;
     }
     CharacterClass* spacesCharacterClass()
     {
         if (!spacesCached)

-            m_userCharacterClasses.append(spacesCached = spacesCreate());
+            m_userCharacterClasses.append(adoptPtr(spacesCached = spacesCreate()));

         return spacesCached;
     }
     CharacterClass* wordcharCharacterClass()
     {
         if (!wordcharCached)
         return spacesCached;
     }
     CharacterClass* wordcharCharacterClass()
     {
         if (!wordcharCached)

-            m_userCharacterClasses.append(wordcharCached = wordcharCreate());
+            m_userCharacterClasses.append(adoptPtr(wordcharCached = wordcharCreate()));

         return wordcharCached;
     }
     CharacterClass* nondigitsCharacterClass()
     {
         if (!nondigitsCached)
         return wordcharCached;
     }
     CharacterClass* nondigitsCharacterClass()
     {
         if (!nondigitsCached)

-            m_userCharacterClasses.append(nondigitsCached = nondigitsCreate());
+            m_userCharacterClasses.append(adoptPtr(nondigitsCached = nondigitsCreate()));

         return nondigitsCached;
     }
     CharacterClass* nonspacesCharacterClass()
     {
         if (!nonspacesCached)
         return nondigitsCached;
     }
     CharacterClass* nonspacesCharacterClass()
     {
         if (!nonspacesCached)

-            m_userCharacterClasses.append(nonspacesCached = nonspacesCreate());
+            m_userCharacterClasses.append(adoptPtr(nonspacesCached = nonspacesCreate()));

         return nonspacesCached;
     }
     CharacterClass* nonwordcharCharacterClass()
     {
         if (!nonwordcharCached)
         return nonspacesCached;
     }
     CharacterClass* nonwordcharCharacterClass()
     {
         if (!nonwordcharCached)

-            m_userCharacterClasses.append(nonwordcharCached = nonwordcharCreate());
+            m_userCharacterClasses.append(adoptPtr(nonwordcharCached = nonwordcharCreate()));

         return nonwordcharCached;
     }
 
         return nonwordcharCached;
     }
 


@@ -399,11 +381,11 @@ struct YarrPattern {
     unsigned m_numSubpatterns;
     unsigned m_maxBackReference;
     PatternDisjunction* m_body;
     unsigned m_numSubpatterns;
     unsigned m_maxBackReference;
     PatternDisjunction* m_body;

-    Vector<PatternDisjunction*, 4> m_disjunctions;
-    Vector<CharacterClass*> m_userCharacterClasses;
+    Vector<OwnPtr<PatternDisjunction>, 4> m_disjunctions;
+    Vector<OwnPtr<CharacterClass> > m_userCharacterClasses;

 
 private:
 
 private:

-    const char* compile(const UString& patternString);
+    const char* compile(const String& patternString);

 
     CharacterClass* newlineCached;
     CharacterClass* digitsCached;
 
     CharacterClass* newlineCached;
     CharacterClass* digitsCached;