[fusl] Remove some more tabs

fusl/src/regex/regexec.c

 /*
   regexec.c - TRE POSIX compatible matching functions (and more).
 
   Copyright (c) 2001-2009 Ville Laurikari <vl@iki.fi>
   All rights reserved.
 
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
 
@@ skipping 119 matching lines @@
       classes++;
   return 0; /* No match. */
 }
 
 /***********************************************************************
  from tre-match-parallel.c
 ***********************************************************************/
 
 /*
   This algorithm searches for matches basically by reading characters
-  in the searched string one by one, starting at the beginning.  All
-  matching paths in the TNFA are traversed in parallel.  When two or
+  in the searched string one by one, starting at the beginning. All
+  matching paths in the TNFA are traversed in parallel. When two or
   more paths reach the same state, exactly one is chosen according to
   tag ordering rules; if returning submatches is not required it does
   not matter which path is chosen.
 
   The worst case time required for finding the leftmost and longest
   match, or determining that there is no match, is always linearly
   dependent on the length of the text being searched.
 
   This algorithm cannot handle TNFAs with back referencing nodes.
   See `tre-match-backtrack.c'.
@@ skipping 41 matching lines @@
 
 #ifdef TRE_MBSTATE
   memset(&mbstate, '\0', sizeof(mbstate));
 #endif /* TRE_MBSTATE */
 
   if (!match_tags)
     num_tags = 0;
   else
     num_tags = tnfa->num_tags;
 
-  /* Allocate memory for temporary data required for matching.  This needs to
+  /* Allocate memory for temporary data required for matching. This needs to
      be done for every matching operation to be thread safe.  This allocates
      everything in a single large block from the stack frame using alloca()
      or with malloc() if alloca is unavailable. */
   {
     int tbytes, rbytes, pbytes, xbytes, total_bytes;
     char* tmp_buf;
     /* Compute the length of the block we need. */
     tbytes = sizeof(*tmp_tags) * num_tags;
     rbytes = sizeof(*reach_next) * (tnfa->num_states + 1);
     pbytes = sizeof(*reach_pos) * tnfa->num_states;
@@ skipping 202 matching lines @@
  from tre-match-backtrack.c
 ***********************************************************************/
 
 /*
   This matcher is for regexps that use back referencing.  Regexp matching
   with back referencing is an NP-complete problem on the number of back
   references.  The easiest way to match them is to use a backtracking
   routine which basically goes through all possible paths in the TNFA
   and chooses the one which results in the best (leftmost and longest)
   match.  This can be spectacularly expensive and may run out of stack
-  space, but there really is no better known generic algorithm.  Quoting
+  space, but there really is no better known generic algorithm. Quoting
   Henry Spencer from comp.compilers:
   <URL: http://compilers.iecc.com/comparch/article/93-03-102>
 
     POSIX.2 REs require longest match, which is really exciting to
     implement since the obsolete ("basic") variant also includes
     \<digit>.  I haven't found a better way of tackling this than doing
     a preliminary match using a DFA (or simulation) on a modified RE
     that just replicates subREs for \<digit>, and then doing a
     backtracking match to determine whether the subRE matches were
     right.  This can be rather slow, but I console myself with the
@@ skipping 312 matching lines @@
              to take this transition instead of the first one, so we
              push this transition in the backtracking stack so we can
              jump back here if needed. */
           BT_STACK_PUSH(pos, str_byte, 0, trans_i->state, trans_i->state_id,
                         next_c, tags, mbstate);
           {
             int* tmp;
             for (tmp = trans_i->tags; tmp && *tmp >= 0; tmp++)
               stack->item.tags[*tmp] = pos;
           }
-#if 0 /* XXX - it's important not to look at all transitions here to keep \
-         the stack small! */
-                  break;
-#endif
         }
       }
     }
 
     if (next_state != NULL) {
       /* Matching transitions were found.  Take the first one. */
       state = next_state;
 
       /* Update the tag values. */
       if (next_tags)
@@ skipping 136 matching lines @@
     status = tre_tnfa_run_parallel(tnfa, string, tags, eflags, &eo);
   }
 
   if (status == REG_OK)
     /* A match was found, so fill the submatch registers. */
     tre_fill_pmatch(nmatch, pmatch, tnfa->cflags, tnfa, tags, eo);
   if (tags)
     xfree(tags);
   return status;
 }