/[pcre]/code/branches/pcre16/pcre_compile.c
ViewVC logotype

Diff of /code/branches/pcre16/pcre_compile.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 455 by ph10, Sat Sep 26 19:12:32 2009 UTC revision 459 by ph10, Sun Oct 4 09:21:39 2009 UTC
# Line 341  static const char error_texts[] = Line 341  static const char error_texts[] =
341    "number is too big\0"    "number is too big\0"
342    "subpattern name expected\0"    "subpattern name expected\0"
343    "digit expected after (?+\0"    "digit expected after (?+\0"
344    "] is an invalid data character in JavaScript compatibility mode";    "] is an invalid data character in JavaScript compatibility mode\0"
345      /* 65 */
346      "different names for subpatterns of the same number are not allowed";
347    
348    
349  /* Table to identify digits and hex digits. This is used when compiling  /* Table to identify digits and hex digits. This is used when compiling
# Line 1315  for (;;) Line 1317  for (;;)
1317    
1318      case OP_CALLOUT:      case OP_CALLOUT:
1319      case OP_CREF:      case OP_CREF:
1320        case OP_NCREF:
1321      case OP_RREF:      case OP_RREF:
1322        case OP_NRREF:
1323      case OP_DEF:      case OP_DEF:
1324      code += _pcre_OP_lengths[*code];      code += _pcre_OP_lengths[*code];
1325      break;      break;
# Line 1430  for (;;) Line 1434  for (;;)
1434    
1435      case OP_REVERSE:      case OP_REVERSE:
1436      case OP_CREF:      case OP_CREF:
1437        case OP_NCREF:
1438      case OP_RREF:      case OP_RREF:
1439        case OP_NRREF:
1440      case OP_DEF:      case OP_DEF:
1441      case OP_OPT:      case OP_OPT:
1442      case OP_CALLOUT:      case OP_CALLOUT:
# Line 4652  we set the flag only if there is a liter Line 4658  we set the flag only if there is a liter
4658            }            }
4659    
4660          /* Otherwise (did not start with "+" or "-"), start by looking for the          /* Otherwise (did not start with "+" or "-"), start by looking for the
4661          name. */          name. If we find a name, add one to the opcode to change OP_CREF or
4662            OP_RREF into OP_NCREF or OP_NRREF. These behave exactly the same,
4663            except they record that the reference was originally to a name. The
4664            information is used to check duplicate names. */
4665    
4666          slot = cd->name_table;          slot = cd->name_table;
4667          for (i = 0; i < cd->names_found; i++)          for (i = 0; i < cd->names_found; i++)
# Line 4667  we set the flag only if there is a liter Line 4676  we set the flag only if there is a liter
4676            {            {
4677            recno = GET2(slot, 0);            recno = GET2(slot, 0);
4678            PUT2(code, 2+LINK_SIZE, recno);            PUT2(code, 2+LINK_SIZE, recno);
4679              code[1+LINK_SIZE]++;
4680            }            }
4681    
4682          /* Search the pattern for a forward reference */          /* Search the pattern for a forward reference */
# Line 4675  we set the flag only if there is a liter Line 4685  we set the flag only if there is a liter
4685                          (options & PCRE_EXTENDED) != 0)) > 0)                          (options & PCRE_EXTENDED) != 0)) > 0)
4686            {            {
4687            PUT2(code, 2+LINK_SIZE, i);            PUT2(code, 2+LINK_SIZE, i);
4688              code[1+LINK_SIZE]++;
4689            }            }
4690    
4691          /* If terminator == 0 it means that the name followed directly after          /* If terminator == 0 it means that the name followed directly after
# Line 4867  we set the flag only if there is a liter Line 4878  we set the flag only if there is a liter
4878                }                }
4879              }              }
4880    
4881            /* In the real compile, create the entry in the table */            /* In the real compile, create the entry in the table, maintaining
4882              alphabetical order. Duplicate names for different numbers are
4883              permitted only if PCRE_DUPNAMES is set. Duplicate names for the same
4884              number are always OK. (An existing number can be re-used if (?|
4885              appears in the pattern.) In either event, a duplicate name results in
4886              a duplicate entry in the table, even if the number is the same. This
4887              is because the number of names, and hence the table size, is computed
4888              in the pre-compile, and it affects various numbers and pointers which
4889              would all have to be modified, and the compiled code moved down, if
4890              duplicates with the same number were omitted from the table. This
4891              doesn't seem worth the hassle. However, *different* names for the
4892              same number are not permitted. */
4893    
4894            else            else
4895              {              {
4896                BOOL dupname = FALSE;
4897              slot = cd->name_table;              slot = cd->name_table;
4898    
4899              for (i = 0; i < cd->names_found; i++)              for (i = 0; i < cd->names_found; i++)
4900                {                {
4901                int crc = memcmp(name, slot+2, namelen);                int crc = memcmp(name, slot+2, namelen);
# Line 4879  we set the flag only if there is a liter Line 4903  we set the flag only if there is a liter
4903                  {                  {
4904                  if (slot[2+namelen] == 0)                  if (slot[2+namelen] == 0)
4905                    {                    {
4906                    if ((options & PCRE_DUPNAMES) == 0)                    if (GET2(slot, 0) != cd->bracount + 1 &&
4907                          (options & PCRE_DUPNAMES) == 0)
4908                      {                      {
4909                      *errorcodeptr = ERR43;                      *errorcodeptr = ERR43;
4910                      goto FAILED;                      goto FAILED;
4911                      }                      }
4912                      else dupname = TRUE;
4913                    }                    }
4914                  else crc = -1;      /* Current name is substring */                  else crc = -1;      /* Current name is a substring */
4915                  }                  }
4916    
4917                  /* Make space in the table and break the loop for an earlier
4918                  name. For a duplicate or later name, carry on. We do this for
4919                  duplicates so that in the simple case (when ?(| is not used) they
4920                  are in order of their numbers. */
4921    
4922                if (crc < 0)                if (crc < 0)
4923                  {                  {
4924                  memmove(slot + cd->name_entry_size, slot,                  memmove(slot + cd->name_entry_size, slot,
4925                    (cd->names_found - i) * cd->name_entry_size);                    (cd->names_found - i) * cd->name_entry_size);
4926                  break;                  break;
4927                  }                  }
4928    
4929                  /* Continue the loop for a later or duplicate name */
4930    
4931                slot += cd->name_entry_size;                slot += cd->name_entry_size;
4932                }                }
4933    
4934                /* For non-duplicate names, check for a duplicate number before
4935                adding the new name. */
4936    
4937                if (!dupname)
4938                  {
4939                  uschar *cslot = cd->name_table;
4940                  for (i = 0; i < cd->names_found; i++)
4941                    {
4942                    if (cslot != slot)
4943                      {
4944                      if (GET2(cslot, 0) == cd->bracount + 1)
4945                        {
4946                        *errorcodeptr = ERR65;
4947                        goto FAILED;
4948                        }
4949                      }
4950                    else i--;
4951                    cslot += cd->name_entry_size;
4952                    }
4953                  }
4954    
4955              PUT2(slot, 0, cd->bracount + 1);              PUT2(slot, 0, cd->bracount + 1);
4956              memcpy(slot + 2, name, namelen);              memcpy(slot + 2, name, namelen);
# Line 4902  we set the flag only if there is a liter Line 4958  we set the flag only if there is a liter
4958              }              }
4959            }            }
4960    
4961          /* In both cases, count the number of names we've encountered. */          /* In both pre-compile and compile, count the number of names we've
4962            encountered. */
4963    
         ptr++;                    /* Move past > or ' */  
4964          cd->names_found++;          cd->names_found++;
4965            ptr++;                    /* Move past > or ' */
4966          goto NUMBERED_GROUP;          goto NUMBERED_GROUP;
4967    
4968    
# Line 6108  do { Line 6165  do {
6165       switch (*scode)       switch (*scode)
6166         {         {
6167         case OP_CREF:         case OP_CREF:
6168           case OP_NCREF:
6169         case OP_RREF:         case OP_RREF:
6170           case OP_NRREF:
6171         case OP_DEF:         case OP_DEF:
6172         return FALSE;         return FALSE;
6173    

Legend:
Removed from v.455  
changed lines
  Added in v.459

  ViewVC Help
Powered by ViewVC 1.1.5