[BACK]Return to ccl.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / lex

Diff for /src/usr.bin/lex/ccl.c between version 1.7 and 1.8

version 1.7, 2015/11/19 19:43:40 version 1.8, 2015/11/19 22:55:13
Line 10 
Line 10 
   
 /*  The United States Government has rights in this work pursuant */  /*  The United States Government has rights in this work pursuant */
 /*  to contract no. DE-AC03-76SF00098 between the United States */  /*  to contract no. DE-AC03-76SF00098 between the United States */
  /*  Department of Energy and the University of California. */   /* Department of Energy and the University of California. */
   
 /*  This file is part of flex. */  /*  This file is part of flex. */
   
Line 37 
Line 37 
   
 /* return true if the chr is in the ccl. Takes negation into account. */  /* return true if the chr is in the ccl. Takes negation into account. */
 static bool  static bool
 ccl_contains (const int cclp, const int ch)  ccl_contains(const int cclp, const int ch)
 {  {
         int     ind, len, i;          int ind, len, i;
   
         len = ccllen[cclp];          len = ccllen[cclp];
         ind = cclmap[cclp];          ind = cclmap[cclp];
Line 48 
Line 48 
                 if (ccltbl[ind + i] == ch)                  if (ccltbl[ind + i] == ch)
                         return !cclng[cclp];                          return !cclng[cclp];
   
     return cclng[cclp];          return cclng[cclp];
 }  }
   
   
 /* ccladd - add a single character to a ccl */  /* ccladd - add a single character to a ccl */
   
 void    ccladd (cclp, ch)  void
      int     cclp;  ccladd(cclp, ch)
      int     ch;          int cclp;
           int ch;
 {  {
         int     ind, len, newpos, i;          int ind, len, newpos, i;
   
         check_char (ch);          check_char(ch);
   
         len = ccllen[cclp];          len = ccllen[cclp];
         ind = cclmap[cclp];          ind = cclmap[cclp];
Line 82 
Line 83 
   
                 ++num_reallocs;                  ++num_reallocs;
   
                 ccltbl = reallocate_Character_array (ccltbl,                  ccltbl = reallocate_Character_array(ccltbl,
                                                      current_max_ccl_tbl_size);                      current_max_ccl_tbl_size);
         }          }
   
         ccllen[cclp] = len + 1;          ccllen[cclp] = len + 1;
         ccltbl[newpos] = ch;          ccltbl[newpos] = ch;
 }  }
   
 /* dump_cclp - same thing as list_character_set, but for cclps.  */  /* dump_cclp - same thing as list_character_set, but for cclps.  */
   
 static void    dump_cclp (FILE* file, int cclp)  static void
   dump_cclp(FILE * file, int cclp)
 {  {
         int i;          int i;
   
         putc ('[', file);          putc('[', file);
   
         for (i = 0; i < csize; ++i) {          for (i = 0; i < csize; ++i) {
                 if (ccl_contains(cclp, i)){                  if (ccl_contains(cclp, i)) {
                         int start_char = i;                          int start_char = i;
   
                         putc (' ', file);                          putc(' ', file);
   
                         fputs (readable_form (i), file);                          fputs(readable_form(i), file);
   
                         while (++i < csize && ccl_contains(cclp,i)) ;                          while (++i < csize && ccl_contains(cclp, i));
   
                         if (i - 1 > start_char)                          if (i - 1 > start_char)
                                 /* this was a run */                                  /* this was a run */
                                 fprintf (file, "-%s",                                  fprintf(file, "-%s",
                                          readable_form (i - 1));                                      readable_form(i - 1));
   
                         putc (' ', file);                          putc(' ', file);
                 }                  }
         }          }
   
         putc (']', file);          putc(']', file);
 }  }
   
   
   
 /* ccl_set_diff - create a new ccl as the set difference of the two given ccls. */  /* ccl_set_diff - create a new ccl as the set difference of the two given ccls. */
 int  int
 ccl_set_diff (int a, int b)  ccl_set_diff(int a, int b)
 {  {
     int  d, ch;          int d, ch;
   
     /* create new class  */          /* create new class  */
     d = cclinit();          d = cclinit();
   
     /* In order to handle negation, we spin through all possible chars,          /*
      * addding each char in a that is not in b.           * In order to handle negation, we spin through all possible chars,
      * (This could be O(n^2), but n is small and bounded.)           * addding each char in a that is not in b. (This could be O(n^2),
      */           * but n is small and bounded.)
         for ( ch = 0; ch < csize; ++ch )           */
         if (ccl_contains (a, ch) && !ccl_contains(b, ch))          for (ch = 0; ch < csize; ++ch)
             ccladd (d, ch);                  if (ccl_contains(a, ch) && !ccl_contains(b, ch))
                           ccladd(d, ch);
   
     /* debug */          /* debug */
     if (0){          if (0) {
         fprintf(stderr, "ccl_set_diff (");                  fprintf(stderr, "ccl_set_diff (");
             fprintf(stderr, "\n    ");                  fprintf(stderr, "\n    ");
             dump_cclp (stderr, a);                  dump_cclp(stderr, a);
             fprintf(stderr, "\n    ");                  fprintf(stderr, "\n    ");
             dump_cclp (stderr, b);                  dump_cclp(stderr, b);
             fprintf(stderr, "\n    ");                  fprintf(stderr, "\n    ");
             dump_cclp (stderr, d);                  dump_cclp(stderr, d);
         fprintf(stderr, "\n)\n");                  fprintf(stderr, "\n)\n");
     }          }
     return d;          return d;
 }  }
   
 /* ccl_set_union - create a new ccl as the set union of the two given ccls. */  /* ccl_set_union - create a new ccl as the set union of the two given ccls. */
 int  int
 ccl_set_union (int a, int b)  ccl_set_union(int a, int b)
 {  {
     int  d, i;          int d, i;
   
     /* create new class  */          /* create new class  */
     d = cclinit();          d = cclinit();
   
     /* Add all of a */          /* Add all of a */
     for (i = 0; i < ccllen[a]; ++i)          for (i = 0; i < ccllen[a]; ++i)
                 ccladd (d, ccltbl[cclmap[a] + i]);                  ccladd(d, ccltbl[cclmap[a] + i]);
   
     /* Add all of b */          /* Add all of b */
     for (i = 0; i < ccllen[b]; ++i)          for (i = 0; i < ccllen[b]; ++i)
                 ccladd (d, ccltbl[cclmap[b] + i]);                  ccladd(d, ccltbl[cclmap[b] + i]);
   
     /* debug */          /* debug */
     if (0){          if (0) {
         fprintf(stderr, "ccl_set_union (%d + %d = %d", a, b, d);                  fprintf(stderr, "ccl_set_union (%d + %d = %d", a, b, d);
             fprintf(stderr, "\n    ");                  fprintf(stderr, "\n    ");
             dump_cclp (stderr, a);                  dump_cclp(stderr, a);
             fprintf(stderr, "\n    ");                  fprintf(stderr, "\n    ");
             dump_cclp (stderr, b);                  dump_cclp(stderr, b);
             fprintf(stderr, "\n    ");                  fprintf(stderr, "\n    ");
             dump_cclp (stderr, d);                  dump_cclp(stderr, d);
         fprintf(stderr, "\n)\n");                  fprintf(stderr, "\n)\n");
     }          }
     return d;          return d;
 }  }
   
   
 /* cclinit - return an empty ccl */  /* cclinit - return an empty ccl */
   
 int     cclinit ()  int
   cclinit()
 {  {
         if (++lastccl >= current_maxccls) {          if (++lastccl >= current_maxccls) {
                 current_maxccls += MAX_CCLS_INCREMENT;                  current_maxccls += MAX_CCLS_INCREMENT;
Line 195 
Line 198 
                 ++num_reallocs;                  ++num_reallocs;
   
                 cclmap =                  cclmap =
                         reallocate_integer_array (cclmap, current_maxccls);                      reallocate_integer_array(cclmap, current_maxccls);
                 ccllen =                  ccllen =
                         reallocate_integer_array (ccllen, current_maxccls);                      reallocate_integer_array(ccllen, current_maxccls);
                 cclng = reallocate_integer_array (cclng, current_maxccls);                  cclng = reallocate_integer_array(cclng, current_maxccls);
                 ccl_has_nl =                  ccl_has_nl =
                         reallocate_bool_array (ccl_has_nl,                      reallocate_bool_array(ccl_has_nl,
                                                current_maxccls);                      current_maxccls);
         }          }
   
         if (lastccl == 1)          if (lastccl == 1)
                 /* we're making the first ccl */                  /* we're making the first ccl */
                 cclmap[lastccl] = 0;                  cclmap[lastccl] = 0;
   
         else          else
                 /* The new pointer is just past the end of the last ccl.                  /*
                  * Since the cclmap points to the \first/ character of a                   * The new pointer is just past the end of the last ccl.
                  * ccl, adding the length of the ccl to the cclmap pointer                   * Since the cclmap points to the \first/ character of a ccl,
                  * will produce a cursor to the first free space.                   * adding the length of the ccl to the cclmap pointer will
                    * produce a cursor to the first free space.
                  */                   */
                 cclmap[lastccl] =                  cclmap[lastccl] =
                         cclmap[lastccl - 1] + ccllen[lastccl - 1];                      cclmap[lastccl - 1] + ccllen[lastccl - 1];
   
         ccllen[lastccl] = 0;          ccllen[lastccl] = 0;
         cclng[lastccl] = 0;     /* ccl's start out life un-negated */          cclng[lastccl] = 0;     /* ccl's start out life un-negated */
Line 227 
Line 230 
   
 /* cclnegate - negate the given ccl */  /* cclnegate - negate the given ccl */
   
 void    cclnegate (cclp)  void
      int     cclp;  cclnegate(cclp)
           int cclp;
 {  {
         cclng[cclp] = 1;          cclng[cclp] = 1;
         ccl_has_nl[cclp] = !ccl_has_nl[cclp];          ccl_has_nl[cclp] = !ccl_has_nl[cclp];
Line 242 
Line 246 
  * has a non-zero value in the cset array.   * has a non-zero value in the cset array.
  */   */
   
 void    list_character_set (file, cset)  void
      FILE   *file;  list_character_set(file, cset)
      int     cset[];          FILE *file;
           int cset[];
 {  {
         int i;          int i;
   
         putc ('[', file);          putc('[', file);
   
         for (i = 0; i < csize; ++i) {          for (i = 0; i < csize; ++i) {
                 if (cset[i]) {                  if (cset[i]) {
                         int start_char = i;                          int start_char = i;
   
                         putc (' ', file);                          putc(' ', file);
   
                         fputs (readable_form (i), file);                          fputs(readable_form(i), file);
   
                         while (++i < csize && cset[i]) ;                          while (++i < csize && cset[i]);
   
                         if (i - 1 > start_char)                          if (i - 1 > start_char)
                                 /* this was a run */                                  /* this was a run */
                                 fprintf (file, "-%s",                                  fprintf(file, "-%s",
                                          readable_form (i - 1));                                      readable_form(i - 1));
   
                         putc (' ', file);                          putc(' ', file);
                 }                  }
         }          }
   
         putc (']', file);          putc(']', file);
 }  }
   
 /** Determines if the range [c1-c2] is unambiguous in a case-insensitive  /** Determines if the range [c1-c2] is unambiguous in a case-insensitive
Line 283 
Line 288 
  * @param c2 the upper end of the range   * @param c2 the upper end of the range
  * @return true if [c1-c2] is not ambiguous for a caseless scanner.   * @return true if [c1-c2] is not ambiguous for a caseless scanner.
  */   */
 bool range_covers_case (int c1, int c2)  bool
   range_covers_case(int c1, int c2)
 {  {
         int     i, o;          int i, o;
   
         for (i = c1; i <= c2; i++) {          for (i = c1; i <= c2; i++) {
                 if (has_case (i)) {                  if (has_case(i)) {
                         o = reverse_case (i);                          o = reverse_case(i);
                         if (o < c1 || c2 < o)                          if (o < c1 || c2 < o)
                                 return false;                                  return false;
                 }                  }
Line 300 
Line 306 
 /** Reverse the case of a character, if possible.  /** Reverse the case of a character, if possible.
  * @return c if case-reversal does not apply.   * @return c if case-reversal does not apply.
  */   */
 int reverse_case (int c)  int
   reverse_case(int c)
 {  {
         return isupper (c) ? tolower (c) : (islower (c) ? toupper (c) : c);          return isupper(c) ? tolower(c) : (islower(c) ? toupper(c) : c);
 }  }
   
 /** Return true if c is uppercase or lowercase. */  /** Return true if c is uppercase or lowercase. */
 bool has_case (int c)  bool
   has_case(int c)
 {  {
         return (isupper (c) || islower (c)) ? true : false;          return (isupper(c) || islower(c)) ? true : false;
 }  }
Legend:
Removed from v.1.7  
changed lines
  Added in v.1.8