[fusl] Remove some more tabs

fusl/src/regex/regcomp.c

 /*
   regcomp.c - TRE POSIX compatible regex compilation functions.
 
   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 80 matching lines @@
    tags, matching parameter settings, and all expressions that match one
    character. */
 typedef struct {
   long code_min;
   long code_max;
   int position;
   tre_ctype_t class;
   tre_ctype_t* neg_classes;
 } tre_literal_t;
 
-/* A "catenation" node.  These are created when two regexps are concatenated.
+/* A "catenation" node. These are created when two regexps are concatenated.
    If there are more than one subexpressions in sequence, the `left' part
    holds all but the last, and `right' part holds the last subexpression
    (catenation is left associative). */
 typedef struct {
   tre_ast_node_t* left;
   tre_ast_node_t* right;
 } tre_catenation_t;
 
-/* An "iteration" node.  These are created for the "*", "+", "?", and "{m,n}"
+/* An "iteration" node. These are created for the "*", "+", "?", and "{m,n}"
    operators. */
 typedef struct {
   /* Subexpression to match. */
   tre_ast_node_t* arg;
   /* Minimum number of consecutive matches. */
   int min;
   /* Maximum number of consecutive matches. */
   int max;
   /* If 0, match as many characters as possible, if 1 match as few as
-     possible.  Note that this does not always mean the same thing as
+     possible. Note that this does not always mean the same thing as
      matching as many/few repetitions as possible. */
   unsigned int minimal : 1;
 } tre_iteration_t;
 
 /* An "union" node.  These are created for the "|" operator. */
 typedef struct {
   tre_ast_node_t* left;
   tre_ast_node_t* right;
 } tre_union_t;
 
@@ skipping 80 matching lines @@
   node->num_submatches = left->num_submatches + right->num_submatches;
   return node;
 }
 
 /***********************************************************************
  from tre-stack.c and tre-stack.h
 ***********************************************************************/
 
 typedef struct tre_stack_rec tre_stack_t;
 
-/* Creates a new stack object.  `size' is initial size in bytes, `max_size'
+/* Creates a new stack object. `size' is initial size in bytes, `max_size'
    is maximum size, and `increment' specifies how much more space will be
-   allocated with realloc() if all space gets used up.  Returns the stack
+   allocated with realloc() if all space gets used up. Returns the stack
    object or NULL if out of memory. */
 static tre_stack_t* tre_stack_new(int size, int max_size, int increment);
 
 /* Frees the stack object. */
 static void tre_stack_destroy(tre_stack_t* s);
 
 /* Returns the current number of objects in the stack. */
 static int tre_stack_num_objects(tre_stack_t* s);
 
 /* Each tre_stack_push_*(tre_stack_t *s, <type> value) function pushes
@@ skipping 1245 matching lines @@
       case ADDTAGS_AFTER_CAT_RIGHT:
         node = tre_stack_pop_voidptr(stack);
         if (first_pass)
           node->num_tags = ((tre_catenation_t*)node->obj)->left->num_tags +
                            ((tre_catenation_t*)node->obj)->right->num_tags;
         break;
 
       case ADDTAGS_AFTER_UNION_LEFT:
         /* Lift the bottom of the `regset' array so that when processing
            the right operand the items currently in the array are
-           invisible.    The original bottom was saved at ADDTAGS_UNION and
+           invisible. The original bottom was saved at ADDTAGS_UNION and
            will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */
         while (*regset >= 0)
           regset++;
         break;
 
       case ADDTAGS_AFTER_UNION_RIGHT: {
         int added_tags, tag_left, tag_right;
         tre_ast_node_t* left = tre_stack_pop_voidptr(stack);
         tre_ast_node_t* right = tre_stack_pop_voidptr(stack);
         node = tre_stack_pop_voidptr(stack);
         added_tags = tre_stack_pop_int(stack);
         if (first_pass) {
           node->num_tags = ((tre_union_t*)node->obj)->left->num_tags +
                            ((tre_union_t*)node->obj)->right->num_tags +
                            added_tags + ((node->num_submatches > 0) ? 2 : 0);
         }
         regset = tre_stack_pop_voidptr(stack);
         tag_left = tre_stack_pop_int(stack);
         tag_right = tre_stack_pop_int(stack);
 
         /* Add tags after both children, the left child gets a smaller
            tag than the right child.  This guarantees that we prefer
            the left child over the right child. */
         /* XXX - This is not always necessary (if the children have
            tags which must be seen for every match of that child). */
         /* XXX - Check if this is the only place where tre_add_tag_right
-           is used.      If so, use tre_add_tag_left (putting the tag before
+           is used. If so, use tre_add_tag_left (putting the tag before
            the child as opposed after the child) and throw away
            tre_add_tag_right. */
         if (node->num_submatches > 0) {
           if (!first_pass) {
             status = tre_add_tag_right(mem, left, tag_left);
             tnfa->tag_directions[tag_left] = TRE_TAG_MAXIMIZE;
             if (status == REG_OK)
               status = tre_add_tag_right(mem, right, tag_right);
             tnfa->tag_directions[tag_right] = TRE_TAG_MAXIMIZE;
           }
@@ skipping 777 matching lines @@
         /* Optimization: if this position was already handled, skip it. */
         if (p2->position == prev_p2_pos) {
           p2++;
           continue;
         }
         prev_p2_pos = p2->position;
         /* Set `trans' to point to the next unused transition from
            position `p1->position'. */
         trans = transitions + offs[p1->position];
         while (trans->state != NULL) {
-#if 0
-                /* If we find a previous transition from `p1->position' to
-                   `p2->position', it is overwritten.  This can happen only
-                   if there are nested loops in the regexp, like in "((a)*)*".
-                   In POSIX.2 repetition using the outer loop is always
-                   preferred over using the inner loop.  Therefore the
-                   transition for the inner loop is useless and can be thrown
-                   away. */
-                /* XXX - The same position is used for all nodes in a bracket
-                   expression, so this optimization cannot be used (it will
-                   break bracket expressions) unless I figure out a way to
-                   detect it here. */
-                if (trans->state_id == p2->position)
-                  {
-                    break;
-                  }
-#endif
           trans++;
         }
 
         if (trans->state == NULL)
           (trans + 1)->state = NULL;
         /* Use the character ranges, assertions, etc. from `p1' for
            the transition from `p1' to `p2'. */
         trans->code_min = p1->code_min;
         trans->code_max = p1->code_max;
         trans->state = transitions + offs[p2->position];
@@ skipping 76 matching lines @@
       p2 = orig_p2;
       while (p2->position >= 0) {
         counts[p1->position]++;
         p2++;
       }
       p1++;
     }
   return REG_OK;
 }
 
-/* Converts the syntax tree to a TNFA.  All the transitions in the TNFA are
+/* Converts the syntax tree to a TNFA. All the transitions in the TNFA are
    labelled with one character range (there are no transitions on empty
    strings).  The TNFA takes O(n^2) space in the worst case, `n' is size of
    the regexp. */
 static reg_errcode_t tre_ast_to_tnfa(tre_ast_node_t* node,
                                      tre_tnfa_transition_t* transitions,
                                      int* counts,
                                      int* offs) {
   tre_union_t* uni;
   tre_catenation_t* cat;
   tre_iteration_t* iter;
@@ skipping 141 matching lines @@
   }
 
   /* Expand iteration nodes. */
   errcode =
       tre_expand_ast(mem, stack, tree, &parse_ctx.position, tag_directions);
   if (errcode != REG_OK)
     ERROR_EXIT(errcode);
 
   /* Add a dummy node for the final state.
      XXX - For certain patterns this dummy node can be optimized away,
-           for example "a*" or "ab*".   Figure out a simple way to detect
+           for example "a*" or "ab*". Figure out a simple way to detect
            this possibility. */
   tmp_ast_l = tree;
   tmp_ast_r = tre_ast_new_literal(mem, 0, 0, parse_ctx.position++);
   if (tmp_ast_r == NULL)
     ERROR_EXIT(REG_ESPACE);
 
   tree = tre_ast_new_catenation(mem, tmp_ast_l, tmp_ast_r);
   if (tree == NULL)
     ERROR_EXIT(REG_ESPACE);
 
@@ skipping 126 matching lines @@
   }
 
   if (tnfa->tag_directions)
     xfree(tnfa->tag_directions);
   if (tnfa->firstpos_chars)
     xfree(tnfa->firstpos_chars);
   if (tnfa->minimal_tags)
     xfree(tnfa->minimal_tags);
   xfree(tnfa);
 }