/[pcre]/code/trunk/pcre_printint.c
ViewVC logotype

Diff of /code/trunk/pcre_printint.c

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

revision 1046 by ph10, Tue Sep 25 16:27:58 2012 UTC revision 1414 by zherczeg, Sun Dec 22 16:27:35 2013 UTC
# Line 78  having a separate .h file just for this. Line 78  having a separate .h file just for this.
78  #ifdef PCRE_INCLUDED  #ifdef PCRE_INCLUDED
79  static /* Keep the following function as private. */  static /* Keep the following function as private. */
80  #endif  #endif
81  #ifdef COMPILE_PCRE8  
82    #if defined COMPILE_PCRE8
83  void pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths);  void pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths);
84  #else  #elif defined COMPILE_PCRE16
85  void pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths);  void pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths);
86    #elif defined COMPILE_PCRE32
87    void pcre32_printint(pcre *external_re, FILE *f, BOOL print_lengths);
88  #endif  #endif
89    
90  /* Macro that decides whether a character should be output as a literal or in  /* Macro that decides whether a character should be output as a literal or in
# Line 111  static const pcre_uint8 priv_OP_lengths[ Line 114  static const pcre_uint8 priv_OP_lengths[
114  *       Print single- or multi-byte character    *  *       Print single- or multi-byte character    *
115  *************************************************/  *************************************************/
116    
117  static int  static unsigned int
118  print_char(FILE *f, pcre_uchar *ptr, BOOL utf)  print_char(FILE *f, pcre_uchar *ptr, BOOL utf)
119  {  {
120  int c = *ptr;  pcre_uint32 c = *ptr;
121    
122  #ifndef SUPPORT_UTF  #ifndef SUPPORT_UTF
123    
124  (void)utf;  /* Avoid compiler warning */  (void)utf;  /* Avoid compiler warning */
125  if (PRINTABLE(c)) fprintf(f, "%c", c);  if (PRINTABLE(c)) fprintf(f, "%c", (char)c);
126  else if (c <= 0x80) fprintf(f, "\\x%02x", c);  else if (c <= 0x80) fprintf(f, "\\x%02x", c);
127  else fprintf(f, "\\x{%x}", c);  else fprintf(f, "\\x{%x}", c);
128  return 0;  return 0;
129    
130  #else  #else
131    
132  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
133    
134  if (!utf || (c & 0xc0) != 0xc0)  if (!utf || (c & 0xc0) != 0xc0)
135    {    {
136    if (PRINTABLE(c)) fprintf(f, "%c", c);    if (PRINTABLE(c)) fprintf(f, "%c", (char)c);
137    else if (c < 0x80) fprintf(f, "\\x%02x", c);    else if (c < 0x80) fprintf(f, "\\x%02x", c);
138    else fprintf(f, "\\x{%02x}", c);    else fprintf(f, "\\x{%02x}", c);
139    return 0;    return 0;
# Line 162  else Line 165  else
165    return a;    return a;
166    }    }
167    
168  #else  #elif defined COMPILE_PCRE16
   
 #ifdef COMPILE_PCRE16  
169    
170  if (!utf || (c & 0xfc00) != 0xd800)  if (!utf || (c & 0xfc00) != 0xd800)
171    {    {
172    if (PRINTABLE(c)) fprintf(f, "%c", c);    if (PRINTABLE(c)) fprintf(f, "%c", (char)c);
173    else if (c <= 0x80) fprintf(f, "\\x%02x", c);    else if (c <= 0x80) fprintf(f, "\\x%02x", c);
174    else fprintf(f, "\\x{%02x}", c);    else fprintf(f, "\\x{%02x}", c);
175    return 0;    return 0;
# Line 190  else Line 191  else
191    return 1;    return 1;
192    }    }
193    
194  #endif /* COMPILE_PCRE16 */  #elif defined COMPILE_PCRE32
195    
196    if (!utf || (c & 0xfffff800u) != 0xd800u)
197      {
198      if (PRINTABLE(c)) fprintf(f, "%c", (char)c);
199      else if (c <= 0x80) fprintf(f, "\\x%02x", c);
200      else fprintf(f, "\\x{%x}", c);
201      return 0;
202      }
203    else
204      {
205      /* This is a check for malformed UTF-32; it should only occur if the sanity
206      check has been turned off. Rather than swallow a surrogate, just stop if
207      we hit one. Print it with \X instead of \x as an indication. */
208      fprintf(f, "\\X{%x}", c);
209      return 0;
210      }
211    
212  #endif /* COMPILE_PCRE8 */  #endif /* COMPILE_PCRE[8|16|32] */
213    
214  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
215  }  }
# Line 206  print_puchar(FILE *f, PCRE_PUCHAR ptr) Line 223  print_puchar(FILE *f, PCRE_PUCHAR ptr)
223  {  {
224  while (*ptr != '\0')  while (*ptr != '\0')
225    {    {
226    register int c = *ptr++;    register pcre_uint32 c = *ptr++;
227    if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x{%x}", c);    if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x{%x}", c);
228    }    }
229  }  }
# Line 216  while (*ptr != '\0') Line 233  while (*ptr != '\0')
233  *************************************************/  *************************************************/
234    
235  static const char *  static const char *
236  get_ucpname(int ptype, int pvalue)  get_ucpname(unsigned int ptype, unsigned int pvalue)
237  {  {
238  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
239  int i;  int i;
# Line 237  return (ptype == pvalue)? "??" : "??"; Line 254  return (ptype == pvalue)? "??" : "??";
254  *       Print Unicode property value             *  *       Print Unicode property value             *
255  *************************************************/  *************************************************/
256    
257  /* "Normal" properties can be printed from tables. The PT_CLIST property is a  /* "Normal" properties can be printed from tables. The PT_CLIST property is a
258  pseudo-property that contains a pointer to a list of case-equivalent  pseudo-property that contains a pointer to a list of case-equivalent
259  characters. This is used only when UCP support is available and UTF mode is  characters. This is used only when UCP support is available and UTF mode is
260  selected. It should never occur otherwise, but just in case it does, have  selected. It should never occur otherwise, but just in case it does, have
261  something ready to print. */  something ready to print. */
262    
263  static void  static void
# Line 248  print_prop(FILE *f, pcre_uchar *code, co Line 265  print_prop(FILE *f, pcre_uchar *code, co
265  {  {
266  if (code[1] != PT_CLIST)  if (code[1] != PT_CLIST)
267    {    {
268    fprintf(f, "%s%s %s%s", before, priv_OP_names[*code], get_ucpname(code[1],    fprintf(f, "%s%s %s%s", before, priv_OP_names[*code], get_ucpname(code[1],
269      code[2]), after);      code[2]), after);
270    }    }
271  else  else
272    {    {
273    const char *not = (*code == OP_PROP)? "" : "not ";    const char *not = (*code == OP_PROP)? "" : "not ";
274  #ifndef SUPPORT_UCP  #ifndef SUPPORT_UCP
275    fprintf(f, "%s%sclist %d%s", before, not, code[2], after);    fprintf(f, "%s%sclist %d%s", before, not, code[2], after);
276  #else  #else
277    const pcre_uint32 *p = PRIV(ucd_caseless_sets) + code[2];    const pcre_uint32 *p = PRIV(ucd_caseless_sets) + code[2];
278    fprintf (f, "%s%sclist", before, not);    fprintf (f, "%s%sclist", before, not);
279    while (*p < NOTACHAR) fprintf(f, " %04x", *p++);    while (*p < NOTACHAR) fprintf(f, " %04x", *p++);
280    fprintf(f, "%s", after);    fprintf(f, "%s", after);
281  #endif  #endif
282    }    }
283  }  }
284    
285    
# Line 281  written that do not depend on the value Line 298  written that do not depend on the value
298  #ifdef PCRE_INCLUDED  #ifdef PCRE_INCLUDED
299  static /* Keep the following function as private. */  static /* Keep the following function as private. */
300  #endif  #endif
301  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
302  void  void
303  pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths)  pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths)
304  #else  #elif defined COMPILE_PCRE16
305  void  void
306  pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths)  pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths)
307    #elif defined COMPILE_PCRE32
308    void
309    pcre32_printint(pcre *external_re, FILE *f, BOOL print_lengths)
310  #endif  #endif
311  {  {
312  REAL_PCRE *re = (REAL_PCRE *)external_re;  REAL_PCRE *re = (REAL_PCRE *)external_re;
# Line 310  if (re->magic_number != MAGIC_NUMBER) Line 330  if (re->magic_number != MAGIC_NUMBER)
330    }    }
331    
332  code = codestart = (pcre_uchar *)re + offset + count * size;  code = codestart = (pcre_uchar *)re + offset + count * size;
333  /* PCRE_UTF16 has the same value as PCRE_UTF8. */  /* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */
334  utf = (options & PCRE_UTF8) != 0;  utf = (options & PCRE_UTF8) != 0;
335    
336  for(;;)  for(;;)
337    {    {
338    pcre_uchar *ccode;    pcre_uchar *ccode;
339    const char *flag = "  ";    const char *flag = "  ";
340    int c;    pcre_uint32 c;
341    int extra = 0;    unsigned int extra = 0;
342    
343    if (print_lengths)    if (print_lengths)
344      fprintf(f, "%3d ", (int)(code - codestart));      fprintf(f, "%3d ", (int)(code - codestart));
# Line 405  for(;;) Line 425  for(;;)
425      break;      break;
426    
427      case OP_CREF:      case OP_CREF:
     case OP_NCREF:  
428      fprintf(f, "%3d %s", GET2(code,1), priv_OP_names[*code]);      fprintf(f, "%3d %s", GET2(code,1), priv_OP_names[*code]);
429      break;      break;
430    
431        case OP_DNCREF:
432          {
433          pcre_uchar *entry = (pcre_uchar *)re + offset + (GET2(code, 1) * size) +
434            IMM2_SIZE;
435          fprintf(f, " %s Cond ref <", flag);
436          print_puchar(f, entry);
437          fprintf(f, ">%d", GET2(code, 1 + IMM2_SIZE));
438          }
439        break;
440    
441      case OP_RREF:      case OP_RREF:
442      c = GET2(code, 1);      c = GET2(code, 1);
443      if (c == RREF_ANY)      if (c == RREF_ANY)
# Line 417  for(;;) Line 446  for(;;)
446        fprintf(f, "    Cond recurse %d", c);        fprintf(f, "    Cond recurse %d", c);
447      break;      break;
448    
449      case OP_NRREF:      case OP_DNRREF:
450      c = GET2(code, 1);        {
451      if (c == RREF_ANY)        pcre_uchar *entry = (pcre_uchar *)re + offset + (GET2(code, 1) * size) +
452        fprintf(f, "    Cond nrecurse any");          IMM2_SIZE;
453      else        fprintf(f, " %s Cond recurse <", flag);
454        fprintf(f, "    Cond nrecurse %d", c);        print_puchar(f, entry);
455          fprintf(f, ">%d", GET2(code, 1 + IMM2_SIZE));
456          }
457      break;      break;
458    
459      case OP_DEF:      case OP_DEF:
# Line 578  for(;;) Line 609  for(;;)
609      ccode = code + priv_OP_lengths[*code];      ccode = code + priv_OP_lengths[*code];
610      goto CLASS_REF_REPEAT;      goto CLASS_REF_REPEAT;
611    
612        case OP_DNREFI:
613        flag = "/i";
614        /* Fall through */
615        case OP_DNREF:
616          {
617          pcre_uchar *entry = (pcre_uchar *)re + offset + (GET2(code, 1) * size) +
618            IMM2_SIZE;
619          fprintf(f, " %s \\k<", flag);
620          print_puchar(f, entry);
621          fprintf(f, ">%d", GET2(code, 1 + IMM2_SIZE));
622          }
623        ccode = code + priv_OP_lengths[*code];
624        goto CLASS_REF_REPEAT;
625    
626      case OP_CALLOUT:      case OP_CALLOUT:
627      fprintf(f, "    %s %d %d %d", priv_OP_names[*code], code[1], GET(code,2),      fprintf(f, "    %s %d %d %d", priv_OP_names[*code], code[1], GET(code,2),
628        GET(code, 2 + LINK_SIZE));        GET(code, 2 + LINK_SIZE));
# Line 588  for(;;) Line 633  for(;;)
633      print_prop(f, code, "    ", "");      print_prop(f, code, "    ", "");
634      break;      break;
635    
636      /* OP_XCLASS can only occur in UTF or PCRE16 modes. However, there's no      /* OP_XCLASS cannot occur in 8-bit, non-UTF mode. However, there's no harm
637      harm in having this code always here, and it makes it less messy without      in having this code always here, and it makes it less messy without all
638      all those #ifdefs. */      those #ifdefs. */
639    
640      case OP_CLASS:      case OP_CLASS:
641      case OP_NCLASS:      case OP_NCLASS:
642      case OP_XCLASS:      case OP_XCLASS:
643        {        {
644        int i, min, max;        int i;
645          unsigned int min, max;
646        BOOL printmap;        BOOL printmap;
647          BOOL invertmap = FALSE;
648        pcre_uint8 *map;        pcre_uint8 *map;
649          pcre_uint8 inverted_map[32];
650    
651        fprintf(f, "    [");        fprintf(f, "    [");
652    
# Line 607  for(;;) Line 655  for(;;)
655          extra = GET(code, 1);          extra = GET(code, 1);
656          ccode = code + LINK_SIZE + 1;          ccode = code + LINK_SIZE + 1;
657          printmap = (*ccode & XCL_MAP) != 0;          printmap = (*ccode & XCL_MAP) != 0;
658          if ((*ccode++ & XCL_NOT) != 0) fprintf(f, "^");          if ((*ccode & XCL_NOT) != 0)
659              {
660              invertmap = (*ccode & XCL_HASPROP) == 0;
661              fprintf(f, "^");
662              }
663            ccode++;
664          }          }
665        else        else
666          {          {
# Line 620  for(;;) Line 673  for(;;)
673        if (printmap)        if (printmap)
674          {          {
675          map = (pcre_uint8 *)ccode;          map = (pcre_uint8 *)ccode;
676            if (invertmap)
677              {
678              for (i = 0; i < 32; i++) inverted_map[i] = ~map[i];
679              map = inverted_map;
680              }
681    
682          for (i = 0; i < 256; i++)          for (i = 0; i < 256; i++)
683            {            {
684            if ((map[i/8] & (1 << (i&7))) != 0)            if ((map[i/8] & (1 << (i&7))) != 0)
# Line 647  for(;;) Line 706  for(;;)
706    
707        if (*code == OP_XCLASS)        if (*code == OP_XCLASS)
708          {          {
709          int ch;          pcre_uchar ch;
710          while ((ch = *ccode++) != XCL_END)          while ((ch = *ccode++) != XCL_END)
711            {            {
712            if (ch == XCL_PROP)            BOOL not = FALSE;
713              {            const char *notch = "";
714              int ptype = *ccode++;  
715              int pvalue = *ccode++;            switch(ch)
             fprintf(f, "\\p{%s}", get_ucpname(ptype, pvalue));  
             }  
           else if (ch == XCL_NOTPROP)  
             {  
             int ptype = *ccode++;  
             int pvalue = *ccode++;  
             fprintf(f, "\\P{%s}", get_ucpname(ptype, pvalue));  
             }  
           else  
716              {              {
717                case XCL_NOTPROP:
718                not = TRUE;
719                notch = "^";
720                /* Fall through */
721    
722                case XCL_PROP:
723                  {
724                  unsigned int ptype = *ccode++;
725                  unsigned int pvalue = *ccode++;
726    
727                  switch(ptype)
728                    {
729                    case PT_PXGRAPH:
730                    fprintf(f, "[:%sgraph:]", notch);
731                    break;
732    
733                    case PT_PXPRINT:
734                    fprintf(f, "[:%sprint:]", notch);
735                    break;
736    
737                    case PT_PXPUNCT:
738                    fprintf(f, "[:%spunct:]", notch);
739                    break;
740    
741                    default:
742                    fprintf(f, "\\%c{%s}", (not? 'P':'p'),
743                      get_ucpname(ptype, pvalue));
744                    break;
745                    }
746                  }
747                break;
748    
749                default:
750              ccode += 1 + print_char(f, ccode, utf);              ccode += 1 + print_char(f, ccode, utf);
751              if (ch == XCL_RANGE)              if (ch == XCL_RANGE)
752                {                {
753                fprintf(f, "-");                fprintf(f, "-");
754                ccode += 1 + print_char(f, ccode, utf);                ccode += 1 + print_char(f, ccode, utf);
755                }                }
756                break;
757              }              }
758            }            }
759          }          }
# Line 689  for(;;) Line 773  for(;;)
773          case OP_CRMINPLUS:          case OP_CRMINPLUS:
774          case OP_CRQUERY:          case OP_CRQUERY:
775          case OP_CRMINQUERY:          case OP_CRMINQUERY:
776            case OP_CRPOSSTAR:
777            case OP_CRPOSPLUS:
778            case OP_CRPOSQUERY:
779          fprintf(f, "%s", priv_OP_names[*ccode]);          fprintf(f, "%s", priv_OP_names[*ccode]);
780          extra += priv_OP_lengths[*ccode];          extra += priv_OP_lengths[*ccode];
781          break;          break;
782    
783          case OP_CRRANGE:          case OP_CRRANGE:
784          case OP_CRMINRANGE:          case OP_CRMINRANGE:
785            case OP_CRPOSRANGE:
786          min = GET2(ccode,1);          min = GET2(ccode,1);
787          max = GET2(ccode,1 + IMM2_SIZE);          max = GET2(ccode,1 + IMM2_SIZE);
788          if (max == 0) fprintf(f, "{%d,}", min);          if (max == 0) fprintf(f, "{%u,}", min);
789          else fprintf(f, "{%d,%d}", min, max);          else fprintf(f, "{%u,%u}", min, max);
790          if (*ccode == OP_CRMINRANGE) fprintf(f, "?");          if (*ccode == OP_CRMINRANGE) fprintf(f, "?");
791            else if (*ccode == OP_CRPOSRANGE) fprintf(f, "+");
792          extra += priv_OP_lengths[*ccode];          extra += priv_OP_lengths[*ccode];
793          break;          break;
794    

Legend:
Removed from v.1046  
changed lines
  Added in v.1414

  ViewVC Help
Powered by ViewVC 1.1.5