home *** CD-ROM | disk | FTP | other *** search
/ Champak 48 / cdrom_image.iso / Games / alex_trax.swf / scripts / __Packages / com / neodelight / std / RegExp.as < prev    next >
Encoding:
Text File  |  2007-10-01  |  33.6 KB  |  1,004 lines
  1. class com.neodelight.std.RegExp
  2. {
  3.    var old_split;
  4.    var const = null;
  5.    var source = null;
  6.    var global = false;
  7.    var ignoreCase = false;
  8.    var multiline = false;
  9.    var lastIndex = null;
  10.    static var _xrStatic = null;
  11.    var _xr = null;
  12.    static var _xp = null;
  13.    static var _xxa = null;
  14.    static var _xxlp = null;
  15.    var _xq = null;
  16.    var _xqc = null;
  17.    static var d = null;
  18.    static var _xiStatic = null;
  19.    var _xi = 0;
  20.    static var _xxlm = null;
  21.    static var _xxlc = null;
  22.    static var _xxrc = null;
  23.    static var lastMatch = null;
  24.    static var leftContext = null;
  25.    static var rightContext = null;
  26.    static var _xa = new Array();
  27.    static var lastParen = null;
  28.    static var _xaStatic = new Array();
  29.    static var $1 = null;
  30.    static var $2 = null;
  31.    static var $3 = null;
  32.    static var $4 = null;
  33.    static var $5 = null;
  34.    static var $6 = null;
  35.    static var $7 = null;
  36.    static var $8 = null;
  37.    static var $9 = null;
  38.    static var _setString = com.neodelight.std.RegExp.setStringMethods();
  39.    function RegExp()
  40.    {
  41.       if(arguments[0] != null)
  42.       {
  43.          this.const = "RegExp";
  44.          this.compile.apply(this,arguments);
  45.       }
  46.    }
  47.    function invStr(sVal)
  48.    {
  49.       var _loc5_ = sVal;
  50.       var _loc4_ = _loc5_.length;
  51.       var _loc1_ = undefined;
  52.       var _loc3_ = undefined;
  53.       var _loc6_ = "";
  54.       var _loc2_ = 1;
  55.       while(_loc2_ < 255)
  56.       {
  57.          _loc3_ = chr(_loc2_);
  58.          _loc1_ = 0;
  59.          while(_loc1_ <= _loc4_ && _loc5_.substring(1 + _loc1_++,1) != _loc3_)
  60.          {
  61.          }
  62.          if(_loc1_ > _loc4_)
  63.          {
  64.             _loc6_ += _loc3_;
  65.          }
  66.          _loc2_ = _loc2_ + 1;
  67.       }
  68.       return _loc5_;
  69.    }
  70.    function compile()
  71.    {
  72.       this.source = arguments[0];
  73.       var _loc7_ = undefined;
  74.       var _loc20_ = undefined;
  75.       if(arguments.length > 1)
  76.       {
  77.          var _loc17_ = (arguments[1] + "").toLowerCase();
  78.          _loc7_ = 0;
  79.          while(_loc7_ < _loc17_.length)
  80.          {
  81.             if(_loc17_.substring(_loc7_ + 1,1) == "g")
  82.             {
  83.                this.global = true;
  84.             }
  85.             if(_loc17_.substring(_loc7_ + 1,1) == "i")
  86.             {
  87.                this.ignoreCase = true;
  88.             }
  89.             if(_loc17_.substring(_loc7_ + 1,1) == "m")
  90.             {
  91.                this.multiline = true;
  92.             }
  93.             _loc7_ = _loc7_ + 1;
  94.          }
  95.       }
  96.       if(arguments.length < 3)
  97.       {
  98.          _loc20_ = true;
  99.          com.neodelight.std.RegExp._xrStatic = 1;
  100.          _loc7_ = 0;
  101.       }
  102.       else
  103.       {
  104.          _loc20_ = false;
  105.          this._xr = com.neodelight.std.RegExp._xrStatic++;
  106.          _loc7_ = arguments[2];
  107.       }
  108.       this.lastIndex = 0;
  109.       var _loc10_ = this.source;
  110.       var _loc21_ = undefined;
  111.       var _loc14_ = _loc10_.length;
  112.       var _loc6_ = [];
  113.       var _loc4_ = 0;
  114.       var _loc5_ = undefined;
  115.       var _loc9_ = false;
  116.       var _loc16_ = undefined;
  117.       var _loc15_ = undefined;
  118.       var _loc18_ = false;
  119.       var _loc19_ = undefined;
  120.       _loc7_;
  121.       for(; _loc7_ < _loc14_; _loc7_ = _loc7_ + 1)
  122.       {
  123.          var _loc3_ = _loc10_.substring(_loc7_ + 1,1);
  124.          if(_loc3_ == "\\")
  125.          {
  126.             _loc7_ = _loc7_ + 1;
  127.             _loc19_ = false;
  128.             _loc3_ = _loc10_.substring(_loc7_ + 1,1);
  129.          }
  130.          else
  131.          {
  132.             _loc19_ = true;
  133.          }
  134.          var _loc12_ = _loc10_.substring(_loc7_ + 2,1);
  135.          _loc6_[_loc4_] = new Object();
  136.          _loc6_[_loc4_].t = 0;
  137.          _loc6_[_loc4_].a = 0;
  138.          _loc6_[_loc4_].b = 999;
  139.          _loc6_[_loc4_].c = -10;
  140.          if(_loc19_)
  141.          {
  142.             if(_loc3_ == "(")
  143.             {
  144.                _loc21_ = new com.neodelight.std.RegExp(_loc10_,!this.ignoreCase ? "g" : "gi",_loc7_ + 1);
  145.                _loc7_ = com.neodelight.std.RegExp._xiStatic;
  146.                _loc6_[_loc4_].t = 3;
  147.                _loc3_ = _loc21_;
  148.                _loc12_ = _loc10_.substring(_loc7_ + 2,1);
  149.             }
  150.             else
  151.             {
  152.                if(!_loc20_ && _loc3_ == ")")
  153.                {
  154.                   break;
  155.                }
  156.                if(_loc3_ == "^")
  157.                {
  158.                   if(_loc4_ == 0 || _loc6_[_loc4_ - 1].t == 7)
  159.                   {
  160.                      _loc6_[_loc4_].t = 9;
  161.                      _loc6_[_loc4_].a = 1;
  162.                      _loc6_[_loc4_].b = 1;
  163.                      _loc4_ = _loc4_ + 1;
  164.                   }
  165.                   continue;
  166.                }
  167.                if(_loc3_ == "$")
  168.                {
  169.                   if(_loc20_)
  170.                   {
  171.                      _loc18_ = true;
  172.                   }
  173.                   continue;
  174.                }
  175.                if(_loc3_ == "[")
  176.                {
  177.                   _loc7_ = _loc7_ + 1;
  178.                   if(_loc12_ == "^")
  179.                   {
  180.                      _loc6_[_loc4_].t = 2;
  181.                      _loc7_ = _loc7_ + 1;
  182.                   }
  183.                   else
  184.                   {
  185.                      _loc6_[_loc4_].t = 1;
  186.                   }
  187.                   _loc3_ = "";
  188.                   _loc9_ = false;
  189.                   while(_loc7_ < _loc14_ && (_loc5_ = _loc10_.substring(1 + _loc7_++,1)) != "]")
  190.                   {
  191.                      if(_loc9_)
  192.                      {
  193.                         if(_loc5_ == "\\")
  194.                         {
  195.                         }
  196.                         _loc15_ = _loc5_ != "\\" ? _loc5_ : (_loc5_ != "b" ? (_loc7_, _loc10_.substring(1 + _loc7_++,1)) : "\b");
  197.                         _loc16_ = ord(_loc3_.substring(_loc3_.length,1)) + 1;
  198.                         while(true)
  199.                         {
  200.                            _loc16_;
  201.                            if(_loc15_ < (_loc5_ = chr(_loc16_++)))
  202.                            {
  203.                               break;
  204.                            }
  205.                            _loc3_ += _loc5_;
  206.                         }
  207.                         _loc9_ = false;
  208.                      }
  209.                      else if(_loc5_ == "-" && _loc3_.length > 0)
  210.                      {
  211.                         _loc9_ = true;
  212.                      }
  213.                      else if(_loc5_ == "\\")
  214.                      {
  215.                         _loc7_;
  216.                         _loc5_ = _loc10_.substring(1 + _loc7_++,1);
  217.                         if(_loc5_ == "d")
  218.                         {
  219.                            _loc3_ += "0123456789";
  220.                         }
  221.                         else if(_loc5_ == "D")
  222.                         {
  223.                            _loc3_ += this.invStr("0123456789");
  224.                         }
  225.                         else if(_loc5_ == "s")
  226.                         {
  227.                            _loc3_ += " \f\n\r\t";
  228.                         }
  229.                         else if(_loc5_ == "S")
  230.                         {
  231.                            _loc3_ += this.invStr(" \f\n\r\t");
  232.                         }
  233.                         else if(_loc5_ == "w")
  234.                         {
  235.                            _loc3_ += "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
  236.                         }
  237.                         else if(_loc5_ == "W")
  238.                         {
  239.                            _loc3_ += this.invStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_");
  240.                         }
  241.                         else if(_loc5_ == "b")
  242.                         {
  243.                            _loc3_ += "\b";
  244.                         }
  245.                         else if(_loc5_ == "\\")
  246.                         {
  247.                            _loc3_ += _loc5_;
  248.                         }
  249.                      }
  250.                      else
  251.                      {
  252.                         _loc3_ += _loc5_;
  253.                      }
  254.                   }
  255.                   if(_loc9_)
  256.                   {
  257.                      _loc3_ += "-";
  258.                   }
  259.                   _loc7_ = _loc7_ - 1;
  260.                   _loc12_ = _loc10_.substring(_loc7_ + 2,1);
  261.                }
  262.                else
  263.                {
  264.                   if(_loc3_ == "|")
  265.                   {
  266.                      if(_loc18_)
  267.                      {
  268.                         _loc6_[_loc4_].t = 10;
  269.                         _loc6_[_loc4_].a = 1;
  270.                         _loc6_[_loc4_].b = 1;
  271.                         _loc4_ = _loc4_ + 1;
  272.                         _loc6_[_loc4_] = new Object();
  273.                         _loc18_ = false;
  274.                      }
  275.                      _loc6_[_loc4_].t = 7;
  276.                      _loc6_[_loc4_].a = 1;
  277.                      _loc6_[_loc4_].b = 1;
  278.                      _loc4_ = _loc4_ + 1;
  279.                      continue;
  280.                   }
  281.                   if(_loc3_ == ".")
  282.                   {
  283.                      _loc6_[_loc4_].t = 2;
  284.                      _loc3_ = "\n";
  285.                   }
  286.                   else if(_loc3_ == "*" || _loc3_ == "?" || _loc3_ == "+")
  287.                   {
  288.                      continue;
  289.                   }
  290.                }
  291.             }
  292.          }
  293.          else if(_loc3_ >= "1" && _loc3_ <= "9")
  294.          {
  295.             _loc6_[_loc4_].t = 4;
  296.          }
  297.          else if(_loc3_ == "b")
  298.          {
  299.             _loc6_[_loc4_].t = 1;
  300.             _loc3_ = "--wb--";
  301.          }
  302.          else if(_loc3_ == "B")
  303.          {
  304.             _loc6_[_loc4_].t = 2;
  305.             _loc3_ = "--wb--";
  306.          }
  307.          else if(_loc3_ == "d")
  308.          {
  309.             _loc6_[_loc4_].t = 1;
  310.             _loc3_ = "0123456789";
  311.          }
  312.          else if(_loc3_ == "D")
  313.          {
  314.             _loc6_[_loc4_].t = 2;
  315.             _loc3_ = "0123456789";
  316.          }
  317.          else if(_loc3_ == "s")
  318.          {
  319.             _loc6_[_loc4_].t = 1;
  320.             _loc3_ = " \f\n\r\t";
  321.          }
  322.          else if(_loc3_ == "S")
  323.          {
  324.             _loc6_[_loc4_].t = 2;
  325.             _loc3_ = " \f\n\r\t";
  326.          }
  327.          else if(_loc3_ == "w")
  328.          {
  329.             _loc6_[_loc4_].t = 1;
  330.             _loc3_ = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
  331.          }
  332.          else if(_loc3_ == "W")
  333.          {
  334.             _loc6_[_loc4_].t = 2;
  335.             _loc3_ = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
  336.          }
  337.          if(_loc12_ == "*")
  338.          {
  339.             _loc6_[_loc4_].s = _loc3_;
  340.             _loc4_ = _loc4_ + 1;
  341.             _loc7_ = _loc7_ + 1;
  342.          }
  343.          else if(_loc12_ == "?")
  344.          {
  345.             _loc6_[_loc4_].s = _loc3_;
  346.             _loc6_[_loc4_].b = 1;
  347.             _loc4_ = _loc4_ + 1;
  348.             _loc7_ = _loc7_ + 1;
  349.          }
  350.          else if(_loc12_ == "+")
  351.          {
  352.             _loc6_[_loc4_].s = _loc3_;
  353.             _loc6_[_loc4_].a = 1;
  354.             _loc4_ = _loc4_ + 1;
  355.             _loc7_ = _loc7_ + 1;
  356.          }
  357.          else if(_loc12_ == "{")
  358.          {
  359.             var _loc13_ = false;
  360.             var _loc8_ = 0;
  361.             _loc9_ = "";
  362.             _loc7_ = _loc7_ + 1;
  363.             while(_loc7_ + 1 < _loc14_ && (_loc5_ = _loc10_.substring(2 + _loc7_++,1)) != "}")
  364.             {
  365.                if(!_loc13_ && _loc5_ == ",")
  366.                {
  367.                   _loc13_ = true;
  368.                   _loc8_ = Number(_loc9_);
  369.                   _loc8_ = Math.floor(!isNaN(_loc8_) ? _loc8_ : 0);
  370.                   if(_loc8_ < 0)
  371.                   {
  372.                      _loc8_ = 0;
  373.                   }
  374.                   _loc9_ = "";
  375.                }
  376.                else
  377.                {
  378.                   _loc9_ += _loc5_;
  379.                }
  380.             }
  381.             var _loc11_ = Number(_loc9_);
  382.             _loc11_ = Math.floor(!isNaN(_loc11_) ? _loc11_ : 0);
  383.             if(_loc11_ < 1)
  384.             {
  385.                _loc11_ = 999;
  386.             }
  387.             if(_loc11_ < _loc8_)
  388.             {
  389.                _loc11_ = _loc8_;
  390.             }
  391.             _loc6_[_loc4_].s = _loc3_;
  392.             _loc6_[_loc4_].b = _loc11_;
  393.             _loc6_[_loc4_].a = !_loc13_ ? _loc11_ : _loc8_;
  394.             _loc4_ = _loc4_ + 1;
  395.          }
  396.          else
  397.          {
  398.             _loc6_[_loc4_].s = _loc3_;
  399.             _loc6_[_loc4_].a = 1;
  400.             _loc6_[_loc4_].b = 1;
  401.             _loc4_ = _loc4_ + 1;
  402.          }
  403.       }
  404.       if(_loc20_ && _loc18_)
  405.       {
  406.          _loc6_[_loc4_] = new Object();
  407.          _loc6_[_loc4_].t = 10;
  408.          _loc6_[_loc4_].a = 1;
  409.          _loc6_[_loc4_].b = 1;
  410.          _loc4_ = _loc4_ + 1;
  411.       }
  412.       if(!_loc20_)
  413.       {
  414.          com.neodelight.std.RegExp._xiStatic = _loc7_;
  415.          this.source = _loc10_.substring(arguments[2] + 1,_loc7_ - arguments[2]);
  416.       }
  417.       if(com.neodelight.std.RegExp.d)
  418.       {
  419.          _loc7_ = 0;
  420.          while(_loc7_ < _loc4_)
  421.          {
  422.             trace("xr" + this._xr + " " + _loc6_[_loc7_].t + " : " + _loc6_[_loc7_].a + " : " + _loc6_[_loc7_].b + " : " + _loc6_[_loc7_].s);
  423.             _loc7_ = _loc7_ + 1;
  424.          }
  425.       }
  426.       this._xq = _loc6_;
  427.       this._xqc = _loc4_;
  428.       com.neodelight.std.RegExp._xp = 0;
  429.    }
  430.    function test()
  431.    {
  432.       if(com.neodelight.std.RegExp._xp++ == 0)
  433.       {
  434.          com.neodelight.std.RegExp._xxa = [];
  435.          com.neodelight.std.RegExp._xxlp = 0;
  436.       }
  437.       var _loc10_ = arguments[0] + "";
  438.       var _loc15_ = undefined;
  439.       var _loc4_ = this._xq;
  440.       var _loc17_ = this._xqc;
  441.       var _loc14_ = undefined;
  442.       var _loc7_ = undefined;
  443.       var _loc8_ = undefined;
  444.       var _loc9_ = undefined;
  445.       var _loc11_ = undefined;
  446.       var _loc13_ = undefined;
  447.       var _loc18_ = undefined;
  448.       var _loc12_ = _loc10_.length;
  449.       var _loc5_ = !this.global ? 0 : this.lastIndex;
  450.       var _loc21_ = _loc5_;
  451.       var _loc19_ = _loc10_;
  452.       if(this.ignoreCase)
  453.       {
  454.          _loc10_ = _loc10_.toLowerCase();
  455.       }
  456.       var _loc16_ = new Object();
  457.       _loc16_.i = -1;
  458.       var _loc3_ = -1;
  459.       while(_loc3_ < _loc17_ - 1)
  460.       {
  461.          _loc3_ = _loc3_ + 1;
  462.          if(com.neodelight.std.RegExp.d)
  463.          {
  464.             trace("New section started at i=" + _loc3_);
  465.          }
  466.          _loc5_ = _loc21_;
  467.          _loc14_ = _loc3_;
  468.          _loc4_[_loc14_].c = -10;
  469.          var _loc20_ = false;
  470.          while(_loc3_ > _loc14_ || _loc5_ < _loc12_ + 1)
  471.          {
  472.             if(_loc4_[_loc3_].t == 7)
  473.             {
  474.                break;
  475.             }
  476.             if(_loc4_[_loc3_].t == 9)
  477.             {
  478.                _loc3_ = _loc3_ + 1;
  479.                if(_loc3_ == _loc14_ + 1)
  480.                {
  481.                   _loc18_ = true;
  482.                   _loc14_ = _loc3_;
  483.                }
  484.                _loc4_[_loc14_].c = -10;
  485.             }
  486.             else
  487.             {
  488.                if(_loc16_.i >= 0 && _loc5_ >= _loc16_.i)
  489.                {
  490.                   break;
  491.                }
  492.                if(_loc4_[_loc3_].c == -10)
  493.                {
  494.                   if(com.neodelight.std.RegExp.d)
  495.                   {
  496.                      trace("Lookup #" + _loc3_ + " at index " + _loc5_ + " for \\\\\\\\\\\\\\\\\'" + _loc4_[_loc3_].s + "\\\\\\\\\\\\\\\\\' type " + _loc4_[_loc3_].t);
  497.                   }
  498.                   var _loc6_ = 0;
  499.                   _loc4_[_loc3_].i = _loc5_;
  500.                   if(_loc4_[_loc3_].t == 0)
  501.                   {
  502.                      _loc7_ = !this.ignoreCase ? _loc4_[_loc3_].s : _loc4_[_loc3_].s.toLowerCase();
  503.                      while(_loc6_ < _loc4_[_loc3_].b && _loc5_ < _loc12_)
  504.                      {
  505.                         if(_loc10_.substring(1 + _loc5_,1) != _loc7_)
  506.                         {
  507.                            break;
  508.                         }
  509.                         _loc6_ = _loc6_ + 1;
  510.                         _loc5_ = _loc5_ + 1;
  511.                      }
  512.                   }
  513.                   else if(_loc4_[_loc3_].t == 1)
  514.                   {
  515.                      if(_loc4_[_loc3_].s == "--wb--")
  516.                      {
  517.                         _loc4_[_loc3_].a = 1;
  518.                         if(_loc5_ > 0 && _loc5_ < _loc12_)
  519.                         {
  520.                            _loc9_ = _loc10_.substring(_loc5_,1);
  521.                            if(_loc9_ == " " || _loc9_ == "\\\\\\\\\\\\\\\\n")
  522.                            {
  523.                               _loc6_ = 1;
  524.                            }
  525.                            if(_loc6_ == 0)
  526.                            {
  527.                               _loc9_ = _loc10_.substring(1 + _loc5_,1);
  528.                               if(_loc9_ == " " || _loc9_ == "\\\\\\\\\\\\\\\\n")
  529.                               {
  530.                                  _loc6_ = 1;
  531.                               }
  532.                            }
  533.                         }
  534.                         else
  535.                         {
  536.                            _loc6_ = 1;
  537.                         }
  538.                      }
  539.                      else
  540.                      {
  541.                         _loc7_ = !this.ignoreCase ? _loc4_[_loc3_].s : _loc4_[_loc3_].s.toLowerCase();
  542.                         _loc8_ = _loc7_.length;
  543.                         while(_loc6_ < _loc4_[_loc3_].b && _loc5_ < _loc12_)
  544.                         {
  545.                            _loc9_ = _loc10_.substring(1 + _loc5_,1);
  546.                            _loc11_ = 0;
  547.                            while(_loc11_ <= _loc8_ && _loc7_.substring(1 + _loc11_++,1) != _loc9_)
  548.                            {
  549.                            }
  550.                            if(_loc11_ > _loc8_)
  551.                            {
  552.                               break;
  553.                            }
  554.                            _loc6_ = _loc6_ + 1;
  555.                            _loc5_ = _loc5_ + 1;
  556.                         }
  557.                      }
  558.                   }
  559.                   else if(_loc4_[_loc3_].t == 2)
  560.                   {
  561.                      _loc7_ = !this.ignoreCase ? _loc4_[_loc3_].s : _loc4_[_loc3_].s.toLowerCase();
  562.                      _loc8_ = _loc7_.length;
  563.                      if(_loc4_[_loc3_].s == "--wb--")
  564.                      {
  565.                         _loc4_[_loc3_].a = 1;
  566.                         if(_loc5_ > 0 && _loc5_ < _loc12_)
  567.                         {
  568.                            _loc9_ = _loc10_.substring(_loc5_,1);
  569.                            _loc13_ = _loc10_.substring(1 + _loc5_,1);
  570.                            if(_loc9_ != " " && _loc9_ != "\\\\\\\\\\\\\\\\n" && _loc13_ != " " && _loc13_ != "\\\\\\\\\\\\\\\\n")
  571.                            {
  572.                               _loc6_ = 1;
  573.                            }
  574.                         }
  575.                         else
  576.                         {
  577.                            _loc6_ = 0;
  578.                         }
  579.                      }
  580.                      else
  581.                      {
  582.                         while(_loc6_ < _loc4_[_loc3_].b && _loc5_ < _loc12_)
  583.                         {
  584.                            _loc9_ = _loc10_.substring(1 + _loc5_,1);
  585.                            _loc11_ = 0;
  586.                            while(_loc11_ <= _loc8_ && _loc7_.substring(1 + _loc11_++,1) != _loc9_)
  587.                            {
  588.                            }
  589.                            if(_loc11_ <= _loc8_)
  590.                            {
  591.                               break;
  592.                            }
  593.                            _loc6_ = _loc6_ + 1;
  594.                            _loc5_ = _loc5_ + 1;
  595.                         }
  596.                      }
  597.                   }
  598.                   else if(_loc4_[_loc3_].t == 10)
  599.                   {
  600.                      _loc13_ = _loc10_.substring(1 + _loc5_,1);
  601.                      _loc6_ = !(this.multiline && (_loc13_ == "\\\\\\\\\\\\\\\\n" || _loc13_ == "\\\\\\\\\\\\\\\\r") || _loc5_ == _loc12_) ? 0 : 1;
  602.                   }
  603.                   else if(_loc4_[_loc3_].t == 3)
  604.                   {
  605.                      _loc15_ = _loc4_[_loc3_].s;
  606.                      _loc4_[_loc3_].ix = [];
  607.                      _loc4_[_loc3_].ix[_loc6_] = _loc5_;
  608.                      _loc15_.lastIndex = _loc5_;
  609.                      while(_loc6_ < _loc4_[_loc3_].b && _loc15_.test(_loc19_))
  610.                      {
  611.                         _loc8_ = com.neodelight.std.RegExp._xxlm.length;
  612.                         if(_loc8_ <= 0)
  613.                         {
  614.                            _loc6_ = _loc4_[_loc3_].a;
  615.                            _loc4_[_loc3_].ix[_loc6_ - 1] = _loc5_;
  616.                            break;
  617.                         }
  618.                         _loc5_ += _loc8_;
  619.                         _loc6_ = _loc6_ + 1;
  620.                         _loc4_[_loc3_].ix[_loc6_] = _loc5_;
  621.                      }
  622.                      if(_loc6_ == 0)
  623.                      {
  624.                         com.neodelight.std.RegExp._xxlm = "";
  625.                      }
  626.                      if(_loc15_._xr > com.neodelight.std.RegExp._xxlp)
  627.                      {
  628.                         com.neodelight.std.RegExp._xxlp = _loc15_._xr;
  629.                      }
  630.                      com.neodelight.std.RegExp._xxa[Number(_loc15_._xr)] = com.neodelight.std.RegExp._xxlm;
  631.                   }
  632.                   else if(_loc4_[_loc3_].t == 4)
  633.                   {
  634.                      if(com.neodelight.std.RegExp._xp >= (_loc7_ = Number(_loc4_[_loc3_].s)))
  635.                      {
  636.                         _loc7_ = com.neodelight.std.RegExp._xxa[_loc7_];
  637.                         _loc7_ = !this.ignoreCase ? _loc7_ : _loc7_.toLowerCase();
  638.                         _loc8_ = _loc7_.length;
  639.                         _loc4_[_loc3_].ix = [];
  640.                         _loc4_[_loc3_].ix[_loc6_] = _loc5_;
  641.                         if(_loc8_ > 0)
  642.                         {
  643.                            while(_loc6_ < _loc4_[_loc3_].b && _loc5_ < _loc12_)
  644.                            {
  645.                               if(_loc10_.substring(1 + _loc5_,_loc8_) != _loc7_)
  646.                               {
  647.                                  break;
  648.                               }
  649.                               _loc6_ = _loc6_ + 1;
  650.                               _loc5_ += _loc8_;
  651.                               _loc4_[_loc3_].ix[_loc6_] = _loc5_;
  652.                            }
  653.                         }
  654.                         else
  655.                         {
  656.                            _loc6_ = 0;
  657.                            _loc4_[_loc3_].a = 0;
  658.                         }
  659.                      }
  660.                      else
  661.                      {
  662.                         _loc7_ = chr(_loc7_);
  663.                         _loc4_[_loc3_].ix = [];
  664.                         _loc4_[_loc3_].ix[_loc6_] = _loc5_;
  665.                         while(_loc6_ < _loc4_[_loc3_].b && _loc5_ < _loc12_)
  666.                         {
  667.                            if(_loc10_.substring(1 + _loc5_,1) != _loc7_)
  668.                            {
  669.                               break;
  670.                            }
  671.                            _loc6_ = _loc6_ + 1;
  672.                            _loc5_ = _loc5_ + 1;
  673.                            _loc4_[_loc3_].ix[_loc6_] = _loc5_;
  674.                         }
  675.                      }
  676.                   }
  677.                   _loc4_[_loc3_].c = _loc6_;
  678.                   if(com.neodelight.std.RegExp.d)
  679.                   {
  680.                      trace("   " + _loc6_ + " matches found");
  681.                   }
  682.                }
  683.                if(_loc4_[_loc3_].c < _loc4_[_loc3_].a)
  684.                {
  685.                   if(com.neodelight.std.RegExp.d)
  686.                   {
  687.                      trace("   not enough matches");
  688.                   }
  689.                   if(_loc3_ > _loc14_)
  690.                   {
  691.                      _loc3_ = _loc3_ - 1;
  692.                      _loc4_[_loc3_].c--;
  693.                      if(_loc4_[_loc3_].c >= 0)
  694.                      {
  695.                         _loc5_ = !(_loc4_[_loc3_].t == 3 || _loc4_[_loc3_].t == 4) ? _loc4_[_loc3_].i + _loc4_[_loc3_].c : _loc4_[_loc3_].ix[_loc4_[_loc3_].c];
  696.                      }
  697.                      if(com.neodelight.std.RegExp.d)
  698.                      {
  699.                         trace("Retreat to #" + _loc3_ + " c=" + _loc4_[_loc3_].c + " index=" + _loc5_);
  700.                      }
  701.                   }
  702.                   else
  703.                   {
  704.                      if(com.neodelight.std.RegExp._xp > 1)
  705.                      {
  706.                         break;
  707.                      }
  708.                      if(_loc18_)
  709.                      {
  710.                         if(!this.multiline)
  711.                         {
  712.                            break;
  713.                         }
  714.                         while(_loc5_ <= _loc12_)
  715.                         {
  716.                            _loc5_;
  717.                            _loc13_ = _loc10_.substring(1 + _loc5_++,1);
  718.                            if(_loc13_ == "\\\\\\\\\\\\\\\\n" || _loc13_ == "\\\\\\\\\\\\\\\\r")
  719.                            {
  720.                               break;
  721.                            }
  722.                         }
  723.                         _loc4_[_loc3_].c = -10;
  724.                      }
  725.                      else
  726.                      {
  727.                         _loc5_ = _loc5_ + 1;
  728.                         _loc4_[_loc3_].c = -10;
  729.                      }
  730.                   }
  731.                }
  732.                else
  733.                {
  734.                   if(com.neodelight.std.RegExp.d)
  735.                   {
  736.                      trace("   enough matches!");
  737.                   }
  738.                   _loc3_ = _loc3_ + 1;
  739.                   if(_loc3_ == _loc17_ || _loc4_[_loc3_].t == 7)
  740.                   {
  741.                      if(com.neodelight.std.RegExp.d)
  742.                      {
  743.                         trace("Saving better result: r.i = q[" + _loc14_ + "].i = " + _loc4_[_loc14_].i);
  744.                      }
  745.                      _loc16_.i = _loc4_[_loc14_].i;
  746.                      _loc16_.li = _loc5_;
  747.                      break;
  748.                   }
  749.                   _loc4_[_loc3_].c = -10;
  750.                }
  751.             }
  752.          }
  753.          while(_loc3_ < _loc17_ && _loc4_[_loc3_].t != 7)
  754.          {
  755.             _loc3_ = _loc3_ + 1;
  756.          }
  757.       }
  758.       if(_loc16_.i < 0)
  759.       {
  760.          this.lastIndex = 0;
  761.          if(com.neodelight.std.RegExp._xp-- == 1)
  762.          {
  763.             com.neodelight.std.RegExp._xxa = [];
  764.             com.neodelight.std.RegExp._xxlp = 0;
  765.          }
  766.          return false;
  767.       }
  768.       _loc5_ = _loc16_.li;
  769.       this._xi = _loc16_.i;
  770.       com.neodelight.std.RegExp._xxlm = _loc19_.substring(_loc16_.i + 1,_loc5_ - _loc16_.i);
  771.       com.neodelight.std.RegExp._xxlc = _loc19_.substring(1,_loc16_.i);
  772.       com.neodelight.std.RegExp._xxrc = _loc19_.substring(_loc5_ + 1,_loc12_ - _loc5_);
  773.       if(_loc5_ == _loc16_.i)
  774.       {
  775.          _loc5_ = _loc5_ + 1;
  776.       }
  777.       this.lastIndex = _loc5_;
  778.       if(com.neodelight.std.RegExp._xp-- == 1)
  779.       {
  780.          com.neodelight.std.RegExp.lastMatch = com.neodelight.std.RegExp._xxlm;
  781.          com.neodelight.std.RegExp.leftContext = com.neodelight.std.RegExp._xxlc;
  782.          com.neodelight.std.RegExp.rightContext = com.neodelight.std.RegExp._xxrc;
  783.          com.neodelight.std.RegExp._xaStatic = com.neodelight.std.RegExp._xxa;
  784.          com.neodelight.std.RegExp.lastParen = com.neodelight.std.RegExp._xxa[Number(com.neodelight.std.RegExp._xxlp)];
  785.          _loc3_ = 1;
  786.          while(_loc3_ < 10)
  787.          {
  788.             com.neodelight.std.RegExp["$" + _loc3_] = com.neodelight.std.RegExp._xaStatic[Number(_loc3_)];
  789.             _loc3_ = _loc3_ + 1;
  790.          }
  791.       }
  792.       return true;
  793.    }
  794.    function exec()
  795.    {
  796.       var _loc6_ = arguments[0] + "";
  797.       var _loc4_ = undefined;
  798.       if(_loc6_ == "")
  799.       {
  800.          return false;
  801.       }
  802.       var _loc7_ = this.test(_loc6_);
  803.       if(_loc7_)
  804.       {
  805.          _loc4_ = new Array();
  806.          _loc4_.index = this._xi;
  807.          _loc4_.input = _loc6_;
  808.          _loc4_[0] = com.neodelight.std.RegExp.lastMatch;
  809.          var _loc5_ = com.neodelight.std.RegExp._xaStatic.length;
  810.          var _loc3_ = 1;
  811.          while(_loc3_ < _loc5_)
  812.          {
  813.             _loc4_[_loc3_] = com.neodelight.std.RegExp._xaStatic[Number(_loc3_)];
  814.             _loc3_ = _loc3_ + 1;
  815.          }
  816.       }
  817.       else
  818.       {
  819.          _loc4_ = null;
  820.       }
  821.       return _loc4_;
  822.    }
  823.    static function setStringMethods()
  824.    {
  825.       if(String.prototype.match != undefined)
  826.       {
  827.          return undefined;
  828.       }
  829.       String.prototype.match = function()
  830.       {
  831.          if(typeof arguments[0] != "object")
  832.          {
  833.             return null;
  834.          }
  835.          if(arguments[0].const != "RegExp")
  836.          {
  837.             return null;
  838.          }
  839.          var _loc3_ = arguments[0];
  840.          var _loc6_ = this.valueOf();
  841.          var _loc7_ = 0;
  842.          var _loc4_ = 0;
  843.          var _loc5_ = undefined;
  844.          if(_loc3_.global)
  845.          {
  846.             _loc3_.lastIndex = 0;
  847.             while(_loc3_.test(_loc6_))
  848.             {
  849.                if(_loc4_ == 0)
  850.                {
  851.                   _loc5_ = new Array();
  852.                }
  853.                _loc4_;
  854.                _loc5_[_loc4_++] = com.neodelight.std.RegExp.lastMatch;
  855.                _loc7_ = _loc3_.lastIndex;
  856.             }
  857.             _loc3_.lastIndex = _loc7_;
  858.          }
  859.          else
  860.          {
  861.             _loc5_ = _loc3_.exec(_loc6_);
  862.             _loc4_ = _loc4_ + 1;
  863.          }
  864.          return _loc4_ != 0 ? _loc5_ : null;
  865.       };
  866.       String.prototype.replace = function()
  867.       {
  868.          if(typeof arguments[0] != "object")
  869.          {
  870.             return null;
  871.          }
  872.          if(arguments[0].const != "RegExp")
  873.          {
  874.             return null;
  875.          }
  876.          var _loc8_ = arguments[0];
  877.          var _loc7_ = arguments[1] + "";
  878.          var _loc11_ = this;
  879.          var _loc12_ = "";
  880.          _loc8_.lastIndex = 0;
  881.          if(_loc8_.global)
  882.          {
  883.             var _loc13_ = 0;
  884.             var _loc10_ = 0;
  885.             while(_loc8_.test(_loc11_))
  886.             {
  887.                var _loc5_ = 0;
  888.                var _loc9_ = _loc7_.length;
  889.                var _loc3_ = "";
  890.                var _loc6_ = "";
  891.                var _loc4_ = "";
  892.                while(_loc5_ < _loc9_)
  893.                {
  894.                   _loc5_;
  895.                   _loc3_ = _loc7_.substring(1 + _loc5_++,1);
  896.                   if(_loc3_ == "$" && _loc6_ != "\\")
  897.                   {
  898.                      _loc5_;
  899.                      _loc3_ = _loc7_.substring(1 + _loc5_++,1);
  900.                      if(isNaN(Number(_loc3_)) || Number(_loc3_) > 9)
  901.                      {
  902.                         _loc4_ += "$" + _loc3_;
  903.                      }
  904.                      else
  905.                      {
  906.                         _loc4_ += com.neodelight.std.RegExp._xaStatic[Number(_loc3_)];
  907.                      }
  908.                   }
  909.                   else
  910.                   {
  911.                      _loc4_ += _loc3_;
  912.                   }
  913.                   _loc6_ = _loc3_;
  914.                }
  915.                _loc12_ += _loc11_.substring(_loc10_ + 1,_loc8_._xi - _loc10_) + _loc4_;
  916.                _loc10_ = _loc8_._xi + com.neodelight.std.RegExp.lastMatch.length;
  917.                _loc13_ = _loc8_.lastIndex;
  918.             }
  919.             _loc8_.lastIndex = _loc13_;
  920.          }
  921.          else if(_loc8_.test(_loc11_))
  922.          {
  923.             _loc12_ += com.neodelight.std.RegExp.leftContext + _loc7_;
  924.          }
  925.          _loc12_ += _loc8_.lastIndex != 0 ? com.neodelight.std.RegExp.rightContext : _loc11_;
  926.          return _loc12_;
  927.       };
  928.       String.prototype.search = function()
  929.       {
  930.          if(typeof arguments[0] != "object")
  931.          {
  932.             return null;
  933.          }
  934.          if(arguments[0].const != "RegExp")
  935.          {
  936.             return null;
  937.          }
  938.          var _loc3_ = arguments[0];
  939.          var _loc5_ = this;
  940.          _loc3_.lastIndex = 0;
  941.          var _loc4_ = _loc3_.test(_loc5_);
  942.          return !_loc4_ ? -1 : _loc3_._xi;
  943.       };
  944.       String.prototype.old_split = String.prototype.split;
  945.       String.prototype.split = function()
  946.       {
  947.          if(typeof arguments[0] == "object" && arguments[0].const == "RegExp")
  948.          {
  949.             var _loc3_ = arguments[0];
  950.             var _loc8_ = arguments[1] != null ? Number(arguments[1]) : 9999;
  951.             if(isNaN(_loc8_))
  952.             {
  953.                _loc8_ = 9999;
  954.             }
  955.             var _loc6_ = this;
  956.             var _loc9_ = new Array();
  957.             var _loc5_ = 0;
  958.             var _loc11_ = _loc3_.global;
  959.             _loc3_.global = true;
  960.             _loc3_.lastIndex = 0;
  961.             var _loc7_ = 0;
  962.             var _loc10_ = 0;
  963.             var _loc4_ = 0;
  964.             while(_loc5_ < _loc8_ && _loc3_.test(_loc6_))
  965.             {
  966.                if(_loc3_._xi != _loc4_)
  967.                {
  968.                   _loc5_;
  969.                   _loc9_[_loc5_++] = _loc6_.substring(_loc4_ + 1,_loc3_._xi - _loc4_);
  970.                }
  971.                _loc4_ = _loc3_._xi + com.neodelight.std.RegExp.lastMatch.length;
  972.                _loc10_ = _loc7_;
  973.                _loc7_ = _loc3_.lastIndex;
  974.             }
  975.             if(_loc5_ == _loc8_)
  976.             {
  977.                _loc3_.lastIndex = _loc10_;
  978.             }
  979.             else
  980.             {
  981.                _loc3_.lastIndex = _loc7_;
  982.             }
  983.             if(_loc5_ == 0)
  984.             {
  985.                _loc9_[_loc5_] = _loc6_;
  986.             }
  987.             else if(_loc5_ < _loc8_ && com.neodelight.std.RegExp.rightContext.length > 0)
  988.             {
  989.                _loc5_;
  990.                _loc9_[_loc5_++] = com.neodelight.std.RegExp.rightContext;
  991.             }
  992.             _loc3_.global = _loc11_;
  993.             return _loc9_;
  994.          }
  995.          return this.old_split(arguments[0],arguments[1]);
  996.       };
  997.       return true;
  998.    }
  999.    function toString()
  1000.    {
  1001.       return "[RegExp \"" + this.source + "\"]";
  1002.    }
  1003. }
  1004.