/[jscoverage]/trunk/js/jsregexp.cpp

Diff of /trunk/js/jsregexp.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 459 by siliconforks,
Tue Dec  9 03:37:47 2008 UTC
+revision 460 by siliconforks,
Sat Sep 26 23:15:22 2009 UTC
 Line 64
  #include "jsregexp.h"
  #include "jsscan.h"
  #include "jsscope.h"
+ #include "jsstaticcheck.h"
  #include "jsstr.h"
  #ifdef JS_TRACER
  #include "jstracer.h"
  using namespace avmplus;
  using namespace nanojit;
- /*
-  * FIXME  Duplicated with jstracer.cpp, doing it this way for now
-  *        to keep it private to files that need it.
-  */
- #ifdef JS_JIT_SPEW
- static bool verbose_debug = getenv("TRACEMONKEY") && strstr(getenv("TRACEMONKEY"), "verbose");
- #define debug_only_v(x) if (verbose_debug) { x; }
- #else
- #define debug_only_v(x)
- #endif
  #endif
  typedef enum REOp {
-Line 1277
+Line 1267
                  /* Treat this as an octal escape. */
                  goto doOctal;
              }
-             JS_ASSERT(1 <= num && num <= 0x10000);
+             /*
+              * When FindParenCount calls the regex parser recursively (to find
+              * the number of backrefs) num can be arbitrary and the maximum
+              * supported number of backrefs does not bound it.
+              */
+             JS_ASSERT_IF(!(state->flags & JSREG_FIND_PAREN_COUNT),
+<= num && num <= 0x10000);
              state->result = NewRENode(state, REOP_BACKREF);
              if (!state->result)
                  return JS_FALSE;
-Line 1960
+Line 1957
      goto cleanup;
  }
+ static JSBool
+ CompileRegExpToAST(JSContext* cx, JSTokenStream* ts,
+                    JSString* str, uintN flags, CompilerState& state)
+ {
+     uintN i;
+     size_t len;
+     len = JSSTRING_LENGTH(str);
+     state.context = cx;
+     state.tokenStream = ts;
+     state.cp = js_UndependString(cx, str);
+     if (!state.cp)
+         return JS_FALSE;
+     state.cpbegin = state.cp;
+     state.cpend = state.cp + len;
+     state.flags = flags;
+     state.parenCount = 0;
+     state.classCount = 0;
+     state.progLength = 0;
+     state.treeDepth = 0;
+     state.classBitmapsMem = 0;
+     for (i = 0; i < CLASS_CACHE_SIZE; i++)
+         state.classCache[i].start = NULL;
+     if (len != 0 && (flags & JSREG_FLAT)) {
+         state.result = NewRENode(&state, REOP_FLAT);
+         if (!state.result)
+             return JS_FALSE;
+         state.result->u.flat.chr = *state.cpbegin;
+         state.result->u.flat.length = len;
+         state.result->kid = (void *) state.cpbegin;
+         /* Flat bytecode: REOP_FLAT compact(string_offset) compact(len). */
+         state.progLength += 1 + GetCompactIndexWidth(0)
+                           + GetCompactIndexWidth(len);
+         return JS_TRUE;
+     }
+     return ParseRegExp(&state);
+ }
  #ifdef JS_TRACER
  typedef List<LIns*, LIST_NonGCObjects> LInsList;
  /* Dummy GC for nanojit placement new. */
  static GC gc;
+ static void*
+ HashRegExp(uint16 flags, jschar* s, size_t n)
+ {
+     uint32 h;
+     for (h = 0; n; s++, n--)
+         h = JS_ROTATE_LEFT32(h, 4) ^ *s;
+     return (void*)(h + flags);
+ }
+ struct RESideExit : public SideExit {
+     size_t re_length;
+     uint16 re_flags;
+     jschar re_chars[1];
+ };
+ /* Return the cached fragment for the given regexp, or NULL. */
+ static Fragment*
+ LookupNativeRegExp(JSContext* cx, void* hash, uint16 re_flags,
+                    jschar* re_chars, size_t re_length)
+ {
+     Fragmento* fragmento = JS_TRACE_MONITOR(cx).reFragmento;
+     Fragment* fragment = fragmento->getLoop(hash);
+     while (fragment) {
+         if (fragment->lastIns) {
+             RESideExit* exit = (RESideExit*)fragment->lastIns->record()->exit;
+             if (exit->re_flags == re_flags &&
+                 exit->re_length == re_length &&
+                 !memcmp(exit->re_chars, re_chars, re_length * sizeof(jschar))) {
+                 return fragment;
+             }
+         }
+         fragment = fragment->peer;
+     }
+     return NULL;
+ }
+ static JSBool
+ ProcessCharSet(JSContext *cx, JSRegExp *re, RECharSet *charSet);
  class RegExpNativeCompiler {
   private:
-     JSRegExp*        re;   /* Careful: not fully initialized */
+     JSContext*       cx;
-     CompilerState*   cs;   /* RegExp to compile */
+     JSRegExp*        re;
+     CompilerState*   cs;            /* RegExp to compile */
      Fragment*        fragment;
      LirWriter*       lir;
+     LirBufWriter*    lirBufWriter;  /* for skip */
      LIns*            state;
      LIns*            gdata;
      LIns*            cpend;
-     JSBool isCaseInsensitive() const { return cs->flags & JSREG_FOLD; }
+     JSBool isCaseInsensitive() const { return (cs->flags & JSREG_FOLD) != 0; }
-     void targetCurrentPoint(LIns* ins) { ins->target(lir->ins0(LIR_label)); }
+     JSBool targetCurrentPoint(LIns* ins)
+     {
+         if (fragment->lirbuf->outOMem())
+             return JS_FALSE;
+         ins->target(lir->ins0(LIR_label));
+         return JS_TRUE;
+     }
-     void targetCurrentPoint(LInsList& fails)
+     JSBool targetCurrentPoint(LInsList& fails)
      {
+         if (fragment->lirbuf->outOMem())
+             return JS_FALSE;
          LIns* fail = lir->ins0(LIR_label);
          for (size_t i = 0; i < fails.size(); ++i) {
              fails[i]->target(fail);
          }
          fails.clear();
+         return JS_TRUE;
      }
      /*
-Line 1999
+Line 2088
          return pos;
      }
-     LIns* compileFlatSingleChar(RENode* node, LIns* pos, LInsList& fails)
+     LIns* compileFlatSingleChar(jschar ch, LIns* pos, LInsList& fails)
      {
          /*
           * Fast case-insensitive test for ASCII letters: convert text
           * char to lower case by bit-or-ing in 32 and compare.
           */
          JSBool useFastCI = JS_FALSE;
-         jschar ch = node->u.flat.chr; /* char to test for */
          jschar ch2 = ch;              /* 2nd char to test for if ci */
          if (cs->flags & JSREG_FOLD) {
-             if (L'A' <= ch && ch <= L'Z' || L'a' <= ch || ch <= L'z') {
+             if ((L'A' <= ch && ch <= L'Z') || (L'a' <= ch && ch <= L'z')) {
                  ch |= 32;
                  ch2 = ch;
                  useFastCI = JS_TRUE;
-Line 2030
+Line 2118
          } else {
              LIns* to_ok = lir->insBranch(LIR_jt, lir->ins2(LIR_eq, comp_ch, lir->insImm(ch)), 0);
              fails.add(lir->insBranch(LIR_jf, lir->ins2(LIR_eq, comp_ch, lir->insImm(ch2)), 0));
-             targetCurrentPoint(to_ok);
+             if (!targetCurrentPoint(to_ok))
+                 return NULL;
          }
          return lir->ins2(LIR_piadd, pos, lir->insImm(2));
      }
+     LIns* compileFlatDoubleChar(jschar ch1, jschar ch2, LIns* pos,
+                                 LInsList& fails)
+     {
+ #ifdef IS_BIG_ENDIAN
+         uint32 word = (ch1 << 16) | ch2;
+ #else
+         uint32 word = (ch2 << 16) | ch1;
+ #endif
+         /*
+          * Fast case-insensitive test for ASCII letters: convert text
+          * char to lower case by bit-or-ing in 32 and compare.
+          */
+         JSBool useFastCI = JS_FALSE;
+         union { jschar c[2]; uint32 i; } mask;
+         if (cs->flags & JSREG_FOLD) {
+             JSBool mask1 = (L'A' <= ch1 && ch1 <= L'Z') || (L'a' <= ch1 && ch1 <= L'z');
+             JSBool mask2 = (L'A' <= ch2 && ch2 <= L'Z') || (L'a' <= ch2 && ch2 <= L'z');
+             if ((!mask1 && JS_TOLOWER(ch1) != ch1) || (!mask2 && JS_TOLOWER(ch2) != ch2)) {
+                 pos = compileFlatSingleChar(ch1, pos, fails);
+                 if (!pos) return NULL;
+                 return compileFlatSingleChar(ch2, pos, fails);
+             }
+             mask.c[0] = mask1 ? 0x0020 : 0x0;
+             mask.c[1] = mask2 ? 0x0020 : 0x0;
+             if (mask.i) {
+                 word |= mask.i;
+                 useFastCI = JS_TRUE;
+             }
+         }
+         LIns* to_fail = lir->insBranch(LIR_jf, lir->ins2(LIR_lt, pos, lir->ins2(LIR_sub, cpend, lir->insImm(2))), 0);
+         fails.add(to_fail);
+         LIns* text_word = lir->insLoad(LIR_ld, pos, lir->insImm(0));
+         LIns* comp_word = useFastCI ?
+             lir->ins2(LIR_or, text_word, lir->insImm(mask.i)) :
+             text_word;
+         fails.add(lir->insBranch(LIR_jf, lir->ins2(LIR_eq, comp_word, lir->insImm(word)), 0));
+         return lir->ins2(LIR_piadd, pos, lir->insImm(4));
+     }
      LIns* compileClass(RENode* node, LIns* pos, LInsList& fails)
      {
          if (!node->u.ucclass.sense)
              return JS_FALSE;
+         /*
+          * If we share generated native code, we need to make a copy
+          * of the bitmap because the original regexp's copy is destroyed
+          * when that regexp is.
+          */
+         RECharSet *charSet = &re->classList[node->u.ucclass.index];
+         size_t bitmapLen = (charSet->length >> 3) + 1;
+         /* skip() can't hold large data blocks. */
+         if (bitmapLen > 1024)
+             return NULL;
+         /* The following line allocates charSet.u.bits if successful. */
+         if (!charSet->converted && !ProcessCharSet(cx, re, charSet))
+             return NULL;
+         LIns* skip = lirBufWriter->skip(bitmapLen);
+         if (fragment->lirbuf->outOMem())
+             return NULL;
+         void* bitmapData = skip->payload();
+         memcpy(bitmapData, charSet->u.bits, bitmapLen);
-         RECharSet* charSet = InitNodeCharSet(re, node);
          LIns* to_fail = lir->insBranch(LIR_jf, lir->ins2(LIR_lt, pos, cpend), 0);
          fails.add(to_fail);
          LIns* text_ch = lir->insLoad(LIR_ldcs, pos, lir->insImm(0));
          fails.add(lir->insBranch(LIR_jf, lir->ins2(LIR_le, text_ch, lir->insImm(charSet->length)), 0));
          LIns* byteIndex = lir->ins2(LIR_rsh, text_ch, lir->insImm(3));
-         LIns* bitmap = lir->insLoad(LIR_ld, lir->insImmPtr(charSet), (int) offsetof(RECharSet, u.bits));
+         LIns* bitmap = lir->insImmPtr(bitmapData);
          LIns* byte = lir->insLoad(LIR_ldcb, lir->ins2(LIR_piadd, bitmap, byteIndex), (int) 0);
          LIns* bitMask = lir->ins2(LIR_lsh, lir->insImm(1),
                                 lir->ins2(LIR_and, text_ch, lir->insImm(0x7)));
-Line 2062
+Line 2211
      {
          LInsList kidFails(NULL);
          if (!compileNode((RENode *) node->kid, pos, kidFails))
-             return JS_FALSE;
+             return NULL;
          if (!compileNode(node->next, pos, kidFails))
-             return JS_FALSE;
+             return NULL;
-         targetCurrentPoint(kidFails);
+         if (!targetCurrentPoint(kidFails))
+             return NULL;
          if (!compileNode(node->u.altprereq.kid2, pos, fails))
-             return JS_FALSE;
+             return NULL;
          /*
           * Disable compilation for any regexp where something follows an
           * alternation. To make this work, we need to redesign to either
-Line 2077
+Line 2227
           * code.
           */
          if (node->next)
-             return JS_FALSE;
+             return NULL;
          return pos;
      }
+ #if defined(AVMPLUS_ARM) || defined(AVMPLUS_SPARC)
+ /* We can't do this on ARM or SPARC, since it relies on doing a 32-bit load from
+  * a pointer which is only 2-byte aligned.
+  */
+ #undef USE_DOUBLE_CHAR_MATCH
+ #else
+ #define USE_DOUBLE_CHAR_MATCH
+ #endif
      JSBool compileNode(RENode* node, LIns* pos, LInsList& fails)
      {
          for (; node; node = node->next) {
-             if (fragment->lirbuf->outOmem())
+             if (fragment->lirbuf->outOMem())
                  return JS_FALSE;
              switch (node->op) {
-Line 2092
+Line 2251
                  pos = compileEmpty(node, pos, fails);
                  break;
              case REOP_FLAT:
-                 if (node->u.flat.length != 1)
+ #ifdef USE_DOUBLE_CHAR_MATCH
-                     return JS_FALSE;
+                 if (node->u.flat.length == 1) {
-                 pos = compileFlatSingleChar(node, pos, fails);
+                     if (node->next && node->next->op == REOP_FLAT &&
+                         node->next->u.flat.length == 1) {
+                         pos = compileFlatDoubleChar(node->u.flat.chr,
+                                                     node->next->u.flat.chr,
+                                                     pos, fails);
+                         node = node->next;
+                     } else {
+                         pos = compileFlatSingleChar(node->u.flat.chr, pos, fails);
+                     }
+                 } else {
+                    size_t i;
+                    for (i = 0; i < node->u.flat.length - 1; i += 2) {
+                        if (fragment->lirbuf->outOMem())
+                            return JS_FALSE;
+                        pos = compileFlatDoubleChar(((jschar*) node->kid)[i],
+                                                    ((jschar*) node->kid)[i+1],
+                                                    pos, fails);
+                        if (!pos) break;
+                    }
+                    if (pos && i == node->u.flat.length - 1)
+                        pos = compileFlatSingleChar(((jschar*) node->kid)[i], pos, fails);
+                 }
+ #else
+                 if (node->u.flat.length == 1) {
+                     pos = compileFlatSingleChar(node->u.flat.chr, pos, fails);
+                 } else {
+                     for (size_t i = 0; i < node->u.flat.length; i++) {
+                         if (fragment->lirbuf->outOMem())
+                             return JS_FALSE;
+                         pos = compileFlatSingleChar(((jschar*) node->kid)[i], pos, fails);
+                         if (!pos) break;
+                     }
+                 }
+ #endif
                  break;
              case REOP_ALT:
              case REOP_ALTPREREQ:
-Line 2120
+Line 2312
          LInsList fails(NULL);
          if (!compileNode(root, start, fails))
              return JS_FALSE;
-         targetCurrentPoint(fails);
+         if (!targetCurrentPoint(fails))
+             return JS_FALSE;
          lir->ins1(LIR_ret, lir->insImm(0));
          return JS_TRUE;
      }
-Line 2134
+Line 2327
          if (!compileNode(root, start, fails))
              return JS_FALSE;
-         targetCurrentPoint(to_next);
+         if (!targetCurrentPoint(to_next))
+             return JS_FALSE;
          lir->ins1(LIR_ret, lir->insImm(0));
-         targetCurrentPoint(fails);
+         if (!targetCurrentPoint(fails))
+             return JS_FALSE;
          lir->insStorei(lir->ins2(LIR_piadd, start, lir->insImm(2)), gdata,
                         (int) offsetof(REGlobalData, skipped));
-Line 2147
+Line 2342
      inline LIns*
      addName(LirBuffer* lirbuf, LIns* ins, const char* name)
      {
+ #ifdef NJ_VERBOSE
          debug_only_v(lirbuf->names->addName(ins, name);)
+ #endif
          return ins;
      }
+     /*
+      * Insert the side exit and guard record for a compiled regexp. Most
+      * of the fields are not used. The important part is the regexp source
+      * and flags, which we use as the fragment lookup key.
+      */
+     GuardRecord* insertGuard(jschar* re_chars, size_t re_length)
+     {
+         LIns* skip = lirBufWriter->skip(sizeof(GuardRecord) +
+                                         sizeof(RESideExit) +
+                                         (re_length-1) * sizeof(jschar));
+         GuardRecord* guard = (GuardRecord *) skip->payload();
+         memset(guard, 0, sizeof(*guard));
+         RESideExit* exit = (RESideExit*)(guard+1);
+         guard->exit = exit;
+         guard->exit->target = fragment;
+         exit->re_flags = re->flags;
+         exit->re_length = re_length;
+         memcpy(exit->re_chars, re_chars, re_length * sizeof(jschar));
+         fragment->lastIns = lir->insGuard(LIR_loop, lir->insImm(1), skip);
+         return guard;
+     }
   public:
-     RegExpNativeCompiler(JSRegExp *re, CompilerState *cs)
+  RegExpNativeCompiler(JSRegExp* re, CompilerState* cs, Fragment* fragment)
-         : re(re), cs(cs), fragment(NULL) {  }
+         : re(re), cs(cs), fragment(fragment), lir(NULL), lirBufWriter(NULL) {  }
      JSBool compile(JSContext* cx)
      {
-         GuardRecord* guard;
+         GuardRecord* guard = NULL;
-         LIns* skip;
          LIns* start;
          bool oom = false;
+         jschar* re_chars;
+         size_t re_length;
          Fragmento* fragmento = JS_TRACE_MONITOR(cx).reFragmento;
-         fragment = fragmento->getLoop(re);
-         if (!fragment) {
+         JSSTRING_CHARS_AND_LENGTH(re->source, re_chars, re_length);
-             fragment = fragmento->getAnchor(re);
+         /*
-             fragment->lirbuf = new (&gc) LirBuffer(fragmento, NULL);
+          * If the regexp is too long nanojit will assert when we
-             /* Scary: required to have the onDestroy method delete the lirbuf. */
+          * try to insert the guard record.
-             fragment->root = fragment;
+          */
-         }
+         if (re_length > 1024)
+             return JS_FALSE;
+         this->cx = cx;
+         /* At this point we have an empty fragment. */
          LirBuffer* lirbuf = fragment->lirbuf;
-         LirBufWriter* lirb;
+         if (lirbuf->outOMem())
-         if (lirbuf->outOmem()) goto fail2;
+             goto fail;
          /* FIXME Use bug 463260 smart pointer when available. */
-         lir = lirb = new (&gc) LirBufWriter(lirbuf);
+         lir = lirBufWriter = new (&gc) LirBufWriter(lirbuf);
          /* FIXME Use bug 463260 smart pointer when available. */
+ #ifdef NJ_VERBOSE
          debug_only_v(fragment->lirbuf->names = new (&gc) LirNameMap(&gc, NULL, fragmento->labels);)
+ #endif
          /* FIXME Use bug 463260 smart pointer when available. */
+ #ifdef NJ_VERBOSE
          debug_only_v(lir = new (&gc) VerboseWriter(&gc, lir, lirbuf->names);)
+ #endif
          lir->ins0(LIR_start);
          lirbuf->state = state = addName(lirbuf, lir->insParam(0, 0), "state");
-Line 2188
+Line 2415
          cpend = addName(lirbuf, lir->insLoad(LIR_ldp, lirbuf->param1, offsetof(REGlobalData, cpend)), "cpend");
          if (cs->flags & JSREG_STICKY) {
-             if (!compileSticky(cs->result, start)) goto fail;
+             if (!compileSticky(cs->result, start))
+                 goto fail;
          } else {
-             if (!compileAnchoring(cs->result, start)) goto fail;
+             if (!compileAnchoring(cs->result, start))
+                 goto fail;
          }
-         /* Create fake guard record for loop edge. */
+         guard = insertGuard(re_chars, re_length);
-         skip = lirb->skip(sizeof(GuardRecord) + sizeof(SideExit));
-         guard = (GuardRecord *) skip->payload();
-         memset(guard, 0, sizeof(*guard));
-         guard->exit = (SideExit *) guard+1;
-         guard->exit->target = fragment;
-         fragment->lastIns = lir->insGuard(LIR_loop, lir->insImm(1), skip);
+         if (lirbuf->outOMem())
+             goto fail;
          ::compile(fragmento->assm(), fragment);
          if (fragmento->assm()->error() != nanojit::None) {
              oom = fragmento->assm()->error() == nanojit::OutOMem;
              goto fail;
          }
-         delete lirb;
+         delete lirBufWriter;
+ #ifdef NJ_VERBOSE
          debug_only_v(delete lir;)
+ #endif
          return JS_TRUE;
      fail:
-         delete lirb;
+         if (lirbuf->outOMem() || oom ||
-         debug_only_v(delete lir;)
+             js_OverfullFragmento(&JS_TRACE_MONITOR(cx), fragmento)) {
-     fail2:
-         if (lirbuf->outOmem() || oom)
              fragmento->clearFrags();
+             lirbuf->rewind();
+         } else {
+             if (!guard) insertGuard(re_chars, re_length);
+             fragment->blacklist();
+         }
+         delete lirBufWriter;
+ #ifdef NJ_VERBOSE
+         debug_only_v(delete lir;)
+ #endif
          return JS_FALSE;
      }
  };
+ /*
+  * Compile a regexp to native code in the given fragment.
+  */
  static inline JSBool
- js_CompileRegExpToNative(JSContext *cx, JSRegExp *re, CompilerState *cs)
+ CompileRegExpToNative(JSContext* cx, JSRegExp* re, Fragment* fragment)
+ {
+     JSBool rv = JS_FALSE;
+     void* mark;
+     CompilerState state;
+     RegExpNativeCompiler rc(re, &state, fragment);
+     JS_ASSERT(!fragment->code());
+     JS_ASSERT(!fragment->isBlacklisted());
+     mark = JS_ARENA_MARK(&cx->tempPool);
+     if (!CompileRegExpToAST(cx, NULL, re->source, re->flags, state)) {
+         goto out;
+     }
+     rv = rc.compile(cx);
+  out:
+     JS_ARENA_RELEASE(&cx->tempPool, mark);
+     return rv;
+ }
+ /* Function type for a compiled native regexp. */
+ typedef REMatchState* (FASTCALL *NativeRegExp)(REMatchState*, REGlobalData*);
+ /*
+  * Return a compiled native regexp if one already exists or can be created
+  * now, or NULL otherwise.
+  */
+ static NativeRegExp
+ GetNativeRegExp(JSContext* cx, JSRegExp* re)
  {
-     RegExpNativeCompiler rc(re, cs);
+     Fragment *fragment;
-     return rc.compile(cx);
+     jschar* re_chars;
+     size_t re_length;
+     Fragmento* fragmento = JS_TRACE_MONITOR(cx).reFragmento;
+     JSSTRING_CHARS_AND_LENGTH(re->source, re_chars, re_length);
+     void* hash = HashRegExp(re->flags, re_chars, re_length);
+     fragment = LookupNativeRegExp(cx, hash, re->flags, re_chars, re_length);
+     if (fragment) {
+         if (fragment->code())
+             goto ok;
+         if (fragment->isBlacklisted())
+             return NULL;
+     } else {
+         fragment = fragmento->getAnchor(hash);
+         fragment->lirbuf = JS_TRACE_MONITOR(cx).reLirBuf;
+         fragment->root = fragment;
+     }
+     if (!CompileRegExpToNative(cx, re, fragment))
+         return NULL;
+  ok:
+     union { NIns *code; NativeRegExp func; } u;
+     u.code = fragment->code();
+     return u.func;
  }
  #endif
-Line 2238
+Line 2526
      size_t resize;
      jsbytecode *endPC;
      uintN i;
-     size_t len;
      re = NULL;
      mark = JS_ARENA_MARK(&cx->tempPool);
-     len = JSSTRING_LENGTH(str);
-     state.context = cx;
+     /*
-     state.tokenStream = ts;
+      * Parsing the string as flat is now expressed internally using
-     state.cp = js_UndependString(cx, str);
+      * a flag, so that we keep this information in the JSRegExp, but
-     if (!state.cp)
+      * we keep the 'flat' parameter for now for compatibility.
+      */
+     if (flat) flags |= JSREG_FLAT;
+     if (!CompileRegExpToAST(cx, ts, str, flags, state))
          goto out;
-     state.cpbegin = state.cp;
-     state.cpend = state.cp + len;
-     state.flags = flags;
-     state.parenCount = 0;
-     state.classCount = 0;
-     state.progLength = 0;
-     state.treeDepth = 0;
-     state.classBitmapsMem = 0;
-     for (i = 0; i < CLASS_CACHE_SIZE; i++)
-         state.classCache[i].start = NULL;
-     if (len != 0 && flat) {
-         state.result = NewRENode(&state, REOP_FLAT);
-         if (!state.result)
-             goto out;
-         state.result->u.flat.chr = *state.cpbegin;
-         state.result->u.flat.length = len;
-         state.result->kid = (void *) state.cpbegin;
-         /* Flat bytecode: REOP_FLAT compact(string_offset) compact(len). */
-         state.progLength += 1 + GetCompactIndexWidth(0)
-                           + GetCompactIndexWidth(len);
-     } else {
-         if (!ParseRegExp(&state))
-             goto out;
-     }
      resize = offsetof(JSRegExp, program) + state.progLength + 1;
      re = (JSRegExp *) JS_malloc(cx, resize);
-Line 2297
+Line 2561
          re->classList = NULL;
      }
- #ifdef JS_TRACER
-     /*
-      * Try compiling the native code version. For the time being we also
-      * compile the bytecode version in case we evict the native code
-      * version from the code cache.
-      */
-     if (TRACING_ENABLED(cx))
-         js_CompileRegExpToNative(cx, re, &state);
- #endif
      /* Compile the bytecode version. */
      endPC = EmitREBytecode(&state, re, state.treeDepth, re->program, state.result);
      if (!endPC) {
-Line 2319
+Line 2574
       * This is safe since no pointers to newly parsed regexp or its parts
       * besides re exist here.
       */
- #if 0
-     /*
-      * FIXME: Until bug 464866 is fixed, we can't move the re object so
-      * don't shrink it for now.
-      */
      if ((size_t)(endPC - re->program) != state.progLength + 1) {
          JSRegExp *tmp;
          JS_ASSERT((size_t)(endPC - re->program) < state.progLength + 1);
-Line 2332
+Line 2582
          if (tmp)
              re = tmp;
      }
- #endif
      re->flags = flags;
      re->parenCount = state.parenCount;
-Line 2355
+Line 2604
      if (opt) {
          JSSTRING_CHARS_AND_LENGTH(opt, s, n);
          for (i = 0; i < n; i++) {
+ #define HANDLE_FLAG(name)                                                     \
+             JS_BEGIN_MACRO                                                    \
+                 if (flags & (name))                                           \
+                     goto bad_flag;                                            \
+                 flags |= (name);                                              \
+             JS_END_MACRO
              switch (s[i]) {
                case 'g':
-                 flags |= JSREG_GLOB;
+                 HANDLE_FLAG(JSREG_GLOB);
                  break;
                case 'i':
-                 flags |= JSREG_FOLD;
+                 HANDLE_FLAG(JSREG_FOLD);
                  break;
                case 'm':
-                 flags |= JSREG_MULTILINE;
+                 HANDLE_FLAG(JSREG_MULTILINE);
                  break;
                case 'y':
-                 flags |= JSREG_STICKY;
+                 HANDLE_FLAG(JSREG_STICKY);
                  break;
                default:
+               bad_flag:
                  charBuf[0] = (char)s[i];
                  charBuf[1] = '\0';
                  JS_ReportErrorFlagsAndNumber(cx, JSREPORT_ERROR,
                                               js_GetErrorMessage, NULL,
-                                              JSMSG_BAD_FLAG, charBuf);
+                                              JSMSG_BAD_REGEXP_FLAG, charBuf);
                  return NULL;
              }
+ #undef HANDLE_FLAG
          }
      }
      return js_NewRegExp(cx, NULL, str, flags, flat);
-Line 2407
+Line 2664
      re_debug("\tBT_Push: %lu,%lu",
               (unsigned long) parenIndex, (unsigned long) parenCount);
-     JS_COUNT_OPERATION(gData->cx, JSOW_JUMP * (1 + parenCount));
      if (btincr > 0) {
          ptrdiff_t offset = (char *)result - (char *)gData->backTrackStack;
-         JS_COUNT_OPERATION(gData->cx, JSOW_ALLOCATION);
          btincr = JS_ROUNDUP(btincr, btsize);
          JS_ARENA_GROW_CAST(gData->backTrackStack, REBackTrackData *,
                             &gData->cx->regexpPool, btsize, btincr);
-Line 2637
+Line 2892
  /* Compile the source of the class into a RECharSet */
  static JSBool
- ProcessCharSet(REGlobalData *gData, RECharSet *charSet)
+ ProcessCharSet(JSContext *cx, JSRegExp *re, RECharSet *charSet)
  {
      const jschar *src, *end;
      JSBool inRange = JS_FALSE;
-Line 2653
+Line 2908
       */
      JS_ASSERT(1 <= charSet->u.src.startIndex);
      JS_ASSERT(charSet->u.src.startIndex
-               < JSSTRING_LENGTH(gData->regexp->source));
+               < JSSTRING_LENGTH(re->source));
-     JS_ASSERT(charSet->u.src.length <= JSSTRING_LENGTH(gData->regexp->source)
+     JS_ASSERT(charSet->u.src.length <= JSSTRING_LENGTH(re->source)
                                         - 1 - charSet->u.src.startIndex);
      charSet->converted = JS_TRUE;
-     src = JSSTRING_CHARS(gData->regexp->source) + charSet->u.src.startIndex;
+     src = JSSTRING_CHARS(re->source) + charSet->u.src.startIndex;
      end = src + charSet->u.src.length;
      JS_ASSERT(src[-1] == '[');
      JS_ASSERT(end[0] == ']');
      byteLength = (charSet->length >> 3) + 1;
-     charSet->u.bits = (uint8 *)JS_malloc(gData->cx, byteLength);
+     charSet->u.bits = (uint8 *)JS_malloc(cx, byteLength);
      if (!charSet->u.bits) {
-         JS_ReportOutOfMemory(gData->cx);
+         JS_ReportOutOfMemory(cx);
-         gData->ok = JS_FALSE;
          return JS_FALSE;
      }
      memset(charSet->u.bits, 0, byteLength);
-Line 2806
+Line 3060
          }
          if (inRange) {
-             if (gData->regexp->flags & JSREG_FOLD) {
+             if (re->flags & JSREG_FOLD) {
                  int i;
                  JS_ASSERT(rangeStart <= thisCh);
-Line 2826
+Line 3080
              }
              inRange = JS_FALSE;
          } else {
-             if (gData->regexp->flags & JSREG_FOLD) {
+             if (re->flags & JSREG_FOLD) {
                  AddCharacterToCharSet(charSet, upcase(thisCh));
                  AddCharacterToCharSet(charSet, downcase(thisCh));
              } else {
-Line 2844
+Line 3098
      return JS_TRUE;
  }
+ static inline JSBool
+ MatcherProcessCharSet(REGlobalData *gData, RECharSet *charSet) {
+     JSBool rv = ProcessCharSet(gData->cx, gData->regexp, charSet);
+     if (!rv) gData->ok = JS_FALSE;
+     return rv;
+ }
  void
  js_DestroyRegExp(JSContext *cx, JSRegExp *re)
  {
      if (JS_ATOMIC_DECREMENT(&re->nrefs) == 0) {
- #ifdef JS_TRACER
-         /* Don't reuse this compiled code for some new regexp at same addr. */
-         Fragment* fragment = JS_TRACE_MONITOR(cx).reFragmento->getLoop(re);
-         if (fragment)
-             fragment->blacklist();
- #endif
          if (re->classList) {
              uintN i;
              for (i = 0; i < re->classCount; i++) {
-Line 3178
+Line 3433
                          goto doAlt;
                      charSet = &gData->regexp->classList[k];
-                     if (!charSet->converted && !ProcessCharSet(gData, charSet))
+                     if (!charSet->converted && !MatcherProcessCharSet(gData, charSet))
                          goto bad;
                      matchCh1 = *x->cp;
                      k = matchCh1 >> 3;
-Line 3588
+Line 3843
          if (!result) {
              if (gData->cursz == 0)
                  return NULL;
-             if (!JS_CHECK_OPERATION_LIMIT(gData->cx, JSOW_JUMP)) {
+             if (!JS_CHECK_OPERATION_LIMIT(gData->cx)) {
                  gData->ok = JS_FALSE;
                  return NULL;
              }
-Line 3661
+Line 3916
      const jschar *cp2;
      uintN j;
  #ifdef JS_TRACER
-     Fragment *fragment;
+     NativeRegExp native;
      /* Run with native regexp if possible. */
      if (TRACING_ENABLED(gData->cx) &&
-         ((fragment = JS_TRACE_MONITOR(gData->cx).reFragmento->getLoop(gData->regexp)) != NULL)
+         (native = GetNativeRegExp(gData->cx, gData->regexp))) {
-         && fragment->code() && !fragment->isBlacklisted()) {
-         union { NIns *code; REMatchState* (FASTCALL *func)(void*, void*); } u;
-         u.code = fragment->code();
-         REMatchState *lr;
          gData->skipped = (ptrdiff_t) x->cp;
-         debug_only_v(printf("entering REGEXP trace at %s:%u@%u, code: %p\n",
+ #ifdef JS_JIT_SPEW
-                             gData->cx->fp->script->filename,
+         debug_only_v({
-                             js_FramePCToLineNumber(gData->cx, gData->cx->fp),
+             VOUCH_DOES_NOT_REQUIRE_STACK();
-                             FramePCOffset(gData->cx->fp),
+             JSStackFrame *caller = (JS_ON_TRACE(gData->cx))
-                             fragment->code()););
+                                    ? NULL
+                                    : js_GetScriptedCaller(gData->cx, NULL);
+             printf("entering REGEXP trace at %s:%u@%u, code: %p\n",
+                    caller ? caller->script->filename : "<unknown>",
+                    caller ? js_FramePCToLineNumber(gData->cx, caller) : 0,
+                    caller ? FramePCOffset(caller) : 0,
+                    JS_FUNC_TO_DATA_PTR(void *, native));
+         })
+ #endif
  #if defined(JS_NO_FASTCALL) && defined(NANOJIT_IA32)
-         SIMULATE_FASTCALL(lr, x, gData, u.func);
+         SIMULATE_FASTCALL(result, x, gData, native);
  #else
-         lr = u.func(x, gData);
+         result = native(x, gData);
  #endif
          debug_only_v(printf("leaving REGEXP trace\n"));
          gData->skipped = ((const jschar *) gData->skipped) - cp;
-         return lr;
+         return result;
      }
  #endif
      /*
-Line 3756
+Line 4015
      for (i = 0; i < re->classCount; i++) {
          if (!re->classList[i].converted &&
-             !ProcessCharSet(gData, &re->classList[i])) {
+             !MatcherProcessCharSet(gData, &re->classList[i])) {
              return NULL;
          }
      }
-Line 4096
+Line 4355
      REGEXP_STATIC_RIGHT_CONTEXT = -6
  };
- JSBool
+ void
- js_InitRegExpStatics(JSContext *cx, JSRegExpStatics *res)
+ js_InitRegExpStatics(JSContext *cx)
  {
+     /*
+      * To avoid multiple allocations in InitMatch(), the arena size parameter
+      * should be at least as big as:
+      *   INITIAL_BACKTRACK
+      *   + (sizeof(REProgState) * INITIAL_STATESTACK)
+      *   + (offsetof(REMatchState, parens) + avgParanSize * sizeof(RECapture))
+      */
+     JS_INIT_ARENA_POOL(&cx->regexpPool, "regexp",
+* 1024 - 40,  /* FIXME: bug 421435 */
+                        sizeof(void *), &cx->scriptStackQuota);
      JS_ClearRegExpStatics(cx);
-     return js_AddRoot(cx, &res->input, "res->input");
+ }
+ JS_FRIEND_API(void)
+ js_SaveRegExpStatics(JSContext *cx, JSRegExpStatics *statics,
+                      JSTempValueRooter *tvr)
+ {
+   *statics = cx->regExpStatics;
+   JS_PUSH_TEMP_ROOT_STRING(cx, statics->input, tvr);
+ }
+ JS_FRIEND_API(void)
+ js_RestoreRegExpStatics(JSContext *cx, JSRegExpStatics *statics,
+                         JSTempValueRooter *tvr)
+ {
+   cx->regExpStatics = *statics;
+   JS_POP_TEMP_ROOT(cx, tvr);
+ }
+ void
+ js_TraceRegExpStatics(JSTracer *trc, JSContext *acx)
+ {
+     JSRegExpStatics *res = &acx->regExpStatics;
+     if (res->input)
+         JS_CALL_STRING_TRACER(trc, res->input, "res->input");
  }
  void
- js_FreeRegExpStatics(JSContext *cx, JSRegExpStatics *res)
+ js_FreeRegExpStatics(JSContext *cx)
  {
+     JSRegExpStatics *res = &cx->regExpStatics;
      if (res->moreParens) {
          JS_free(cx, res->moreParens);
          res->moreParens = NULL;
      }
-     js_RemoveRoot(cx->runtime, &res->input);
+     JS_FinishArenaPool(&cx->regexpPool);
  }
  static JSBool
-Line 4259
+Line 4555
  #include "jsxdrapi.h"
- static JSBool
+ JSBool
- regexp_xdrObject(JSXDRState *xdr, JSObject **objp)
+ js_XDRRegExpObject(JSXDRState *xdr, JSObject **objp)
  {
      JSRegExp *re;
      JSString *source;
-Line 4299
+Line 4595
  #else  /* !JS_HAS_XDR */
- #define regexp_xdrObject NULL
+ #define js_XDRRegExpObject NULL
  #endif /* !JS_HAS_XDR */
-Line 4323
+Line 4619
      JS_ConvertStub,     regexp_finalize,
      NULL,               NULL,
      regexp_call,        NULL,
-     regexp_xdrObject,   NULL,
+     js_XDRRegExpObject, NULL,
      JS_CLASS_TRACE(regexp_trace), 0
  };
-Line 4619
+Line 4915
      return JS_TRUE;
  }
- #ifdef JS_TRACER
- static jsint FASTCALL
- Regexp_p_test(JSContext* cx, JSObject* regexp, JSString* str)
- {
-     jsval vp[3] = { JSVAL_NULL, OBJECT_TO_JSVAL(regexp), STRING_TO_JSVAL(str) };
-     if (!regexp_exec_sub(cx, regexp, 1, vp + 2, JS_TRUE, vp))
-         return JSVAL_TO_BOOLEAN(JSVAL_VOID);
-     return *vp == JSVAL_TRUE;
- }
- JS_DEFINE_TRCINFO_1(regexp_test,
-     (3, (static, BOOL_FAIL, Regexp_p_test, CONTEXT, THIS, STRING,  1, 1)))
- #endif
  static JSFunctionSpec regexp_methods[] = {
  #if JS_HAS_TOSOURCE
      JS_FN(js_toSource_str,  regexp_toString,    0,0),
-Line 4641
+Line 4922
      JS_FN(js_toString_str,  regexp_toString,    0,0),
      JS_FN("compile",        regexp_compile,     2,0),
      JS_FN("exec",           regexp_exec,        1,0),
-     JS_TN("test",           regexp_test,        1,0, regexp_test_trcinfo),
+     JS_FN("test",           regexp_test,        1,0),
      JS_FS_END
  };
  static JSBool
  RegExp(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
  {
-     if (!(cx->fp->flags & JSFRAME_CONSTRUCTING)) {
+     if (!JS_IsConstructing(cx)) {
          /*
           * If first arg is regexp and no flags are given, just return the arg.
           * (regexp_compile_sub detects the regexp + flags case and throws a
-Line 4678
+Line 4959
  JSObject *
  js_InitRegExpClass(JSContext *cx, JSObject *obj)
  {
-     JSObject *proto, *ctor;
+     JSObject *proto = js_InitClass(cx, obj, NULL, &js_RegExpClass, RegExp, 1,
-     jsval rval;
+                                    regexp_props, regexp_methods,
+                                    regexp_static_props, NULL);
-     proto = JS_InitClass(cx, obj, NULL, &js_RegExpClass, RegExp, 1,
+     if (!proto)
-                          regexp_props, regexp_methods,
+         return NULL;
-                          regexp_static_props, NULL);
-     if (!proto || !(ctor = JS_GetConstructor(cx, proto)))
+     JSObject *ctor = JS_GetConstructor(cx, proto);
+     if (!ctor)
          return NULL;
+     /* Give RegExp.prototype private data so it matches the empty string. */
+     jsval rval;
      if (!JS_AliasProperty(cx, ctor, "input",        "$_") ||
          !JS_AliasProperty(cx, ctor, "multiline",    "$*") ||
          !JS_AliasProperty(cx, ctor, "lastMatch",    "$&") ||
          !JS_AliasProperty(cx, ctor, "lastParen",    "$+") ||
          !JS_AliasProperty(cx, ctor, "leftContext",  "$`") ||
-         !JS_AliasProperty(cx, ctor, "rightContext", "$'")) {
+         !JS_AliasProperty(cx, ctor, "rightContext", "$'") ||
-         goto bad;
+         !regexp_compile_sub(cx, proto, 0, NULL, &rval)) {
+         return NULL;
      }
-     /* Give RegExp.prototype private data so it matches the empty string. */
-     if (!regexp_compile_sub(cx, proto, 0, NULL, &rval))
-         goto bad;
      return proto;
- bad:
-     JS_DeleteProperty(cx, obj, js_RegExpClass.name);
-     return NULL;
  }
  JSObject *
-Line 4713
+Line 4991
      JSString *str;
      JSObject *obj;
      JSRegExp *re;
-     JSTempValueRooter tvr;
      str = js_NewStringCopyN(cx, chars, length);
      if (!str)
          return NULL;
+     JSAutoTempValueRooter tvr(cx, str);
      re = js_NewRegExp(cx, ts,  str, flags, JS_FALSE);
      if (!re)
          return NULL;
-     JS_PUSH_TEMP_ROOT_STRING(cx, str, &tvr);
      obj = js_NewObject(cx, &js_RegExpClass, NULL, NULL, 0);
      if (!obj || !JS_SetPrivate(cx, obj, re)) {
          js_DestroyRegExp(cx, re);
-Line 4729
+Line 5006
      }
      if (obj && !js_SetLastIndex(cx, obj, 0))
          obj = NULL;
-     JS_POP_TEMP_ROOT(cx, &tvr);
      return obj;
  }

 Legend:



Removed from v.459
 


changed lines


 
Added in v.460
 Legend:



Removed from v.459
 


changed lines


 
Added in v.460
-Removed from v.459
+Added in v.460

	ViewVC Help
Powered by ViewVC 1.1.24