glsl2: Fix spelling of "sentinel."

src/glsl/ast_function.cpp

@@ -398,7 +398,7 @@ constant_record_constructor(const glsl_type *constructor_type,
    for (unsigned i = 0; i < constructor_type->length; i++) {
       ir_instruction *ir = (ir_instruction *) node;
 
-      if (node->is_tail_sentinal()) {
+      if (node->is_tail_sentinel()) {
 	 _mesa_glsl_error(loc, state,
 			  "insufficient parameters to constructor for `%s'",
 			  constructor_type->name);
@@ -531,7 +531,7 @@ single_scalar_parameter(exec_list *parameters)
    const ir_rvalue *const p = (ir_rvalue *) parameters->head;
    assert(((ir_rvalue *)p)->as_rvalue() != NULL);
 
-   return (p->type->is_scalar() && p->next->is_tail_sentinal());
+   return (p->type->is_scalar() && p->next->is_tail_sentinel());
 }
 
 
@@ -763,7 +763,7 @@ emit_inline_matrix_constructor(const glsl_type *type,
        *     identity matrix. If a matrix argument is given to a matrix
        *     constructor, it is an error to have any other arguments."
        */
-      assert(first_param->next->is_tail_sentinal());
+      assert(first_param->next->is_tail_sentinel());
       ir_rvalue *const src_matrix = first_param;
 
       /* If the source matrix is smaller, pre-initialize the relavent parts of

src/glsl/ir.cpp

@@ -295,7 +295,7 @@ ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
     */
    for (unsigned i = 0; i < type->components(); /* empty */) {
       assert(value->as_constant() != NULL);
-      assert(!value->is_tail_sentinal());
+      assert(!value->is_tail_sentinel());
 
       for (unsigned j = 0; j < value->type->components(); j++) {
 	 switch (type->base_type) {
@@ -433,7 +433,7 @@ ir_constant::get_record_field(const char *name)
       /* If the end of the list is encountered before the element matching the
        * requested field is found, return NULL.
        */
-      if (node->is_tail_sentinal())
+      if (node->is_tail_sentinel())
 	 return NULL;
    }
 
@@ -459,8 +459,8 @@ ir_constant::has_value(const ir_constant *c) const
       const exec_node *a_node = this->components.head;
       const exec_node *b_node = c->components.head;
 
-      while (!a_node->is_tail_sentinal()) {
-	 assert(!b_node->is_tail_sentinal());
+      while (!a_node->is_tail_sentinel()) {
+	 assert(!b_node->is_tail_sentinel());
 
 	 const ir_constant *const a_field = (ir_constant *) a_node;
 	 const ir_constant *const b_field = (ir_constant *) b_node;

src/glsl/ir_clone.cpp

@@ -330,7 +330,7 @@ ir_constant::clone(struct hash_table *ht) const
 
       c->type = this->type;
       for (exec_node *node = this->components.head
-	      ; !node->is_tail_sentinal()
+	      ; !node->is_tail_sentinel()
 	      ; node = node->next) {
 	 ir_constant *const orig = (ir_constant *) node;
 

src/glsl/ir_function.cpp

@@ -94,13 +94,13 @@ parameter_lists_match(const exec_list *list_a, const exec_list *list_b)
    int total_score = 0;
 
    for (/* empty */
-	; !node_a->is_tail_sentinal()
+	; !node_a->is_tail_sentinel()
 	; node_a = node_a->next, node_b = node_b->next) {
       /* If all of the parameters from the other parameter list have been
        * exhausted, the lists have different length and, by definition,
        * do not match.
        */
-      if (node_b->is_tail_sentinal())
+      if (node_b->is_tail_sentinel())
 	 return -1;
 
 
@@ -151,7 +151,7 @@ parameter_lists_match(const exec_list *list_a, const exec_list *list_b)
     * exhausted, the lists have different length and, by definition, do not
     * match.
     */
-   if (!node_b->is_tail_sentinal())
+   if (!node_b->is_tail_sentinel())
       return -1;
 
    return total_score;
@@ -192,7 +192,7 @@ parameter_lists_match_exact(const exec_list *list_a, const exec_list *list_b)
    const exec_node *node_b = list_b->head;
 
    for (/* empty */
-	; !node_a->is_tail_sentinal() && !node_b->is_tail_sentinal()
+	; !node_a->is_tail_sentinel() && !node_b->is_tail_sentinel()
 	; node_a = node_a->next, node_b = node_b->next) {
       ir_variable *a = (ir_variable *) node_a;
       ir_variable *b = (ir_variable *) node_b;
@@ -207,7 +207,7 @@ parameter_lists_match_exact(const exec_list *list_a, const exec_list *list_b)
    /* Unless both lists are exhausted, they differ in length and, by
     * definition, do not match.
     */
-   return (node_a->is_tail_sentinal() == node_b->is_tail_sentinal());
+   return (node_a->is_tail_sentinel() == node_b->is_tail_sentinel());
 }
 
 ir_function_signature *

src/glsl/ir_function_inlining.cpp

@@ -96,7 +96,7 @@ replace_return_with_assignment(ir_instruction *ir, void *data)
 	 /* un-valued return has to be the last return, or we shouldn't
 	  * have reached here. (see can_inline()).
 	  */
-	 assert(!ret->next->is_tail_sentinal());
+	 assert(!ret->next->is_tail_sentinel());
 	 ret->remove();
       }
    }

src/glsl/linker.cpp

@@ -542,7 +542,7 @@ remap_variables(ir_instruction *inst, glsl_symbol_table *symbols,
  * Move non-declarations from one instruction stream to another
  *
  * The intended usage pattern of this function is to pass the pointer to the
- * head sentinal of a list (i.e., a pointer to the list cast to an \c exec_node
+ * head sentinel of a list (i.e., a pointer to the list cast to an \c exec_node
  * pointer) for \c last and \c false for \c make_copies on the first
  * call.  Successive calls pass the return value of the previous call for
  * \c last and \c true for \c make_copies.

src/glsl/list.h

@@ -25,28 +25,28 @@
  * \file list.h
  * \brief Doubly-linked list abstract container type.
  *
- * Each doubly-linked list has a sentinal head and tail node.  These nodes
- * contain no data.  The head sentinal can be identified by its \c prev
- * pointer being \c NULL.  The tail sentinal can be identified by its
+ * Each doubly-linked list has a sentinel head and tail node.  These nodes
+ * contain no data.  The head sentinel can be identified by its \c prev
+ * pointer being \c NULL.  The tail sentinel can be identified by its
  * \c next pointer being \c NULL.
  *
- * A list is empty if either the head sentinal's \c next pointer points to the
- * tail sentinal or the tail sentinal's \c prev poiner points to the head
- * sentinal.
+ * A list is empty if either the head sentinel's \c next pointer points to the
+ * tail sentinel or the tail sentinel's \c prev poiner points to the head
+ * sentinel.
  *
  * Instead of tracking two separate \c node structures and a \c list structure
- * that points to them, the sentinal nodes are in a single structure.  Noting
- * that each sentinal node always has one \c NULL pointer, the \c NULL
+ * that points to them, the sentinel nodes are in a single structure.  Noting
+ * that each sentinel node always has one \c NULL pointer, the \c NULL
  * pointers occupy the same memory location.  In the \c list structure
  * contains a the following:
  *
  *   - A \c head pointer that represents the \c next pointer of the
- *     head sentinal node.
+ *     head sentinel node.
  *   - A \c tail pointer that represents the \c prev pointer of the head
- *     sentinal node and the \c next pointer of the tail sentinal node.  This
+ *     sentinel node and the \c next pointer of the tail sentinel node.  This
  *     pointer is \b always \c NULL.
  *   - A \c tail_prev pointer that represents the \c prev pointer of the
- *     tail sentinal node.
+ *     tail sentinel node.
  *
  * Therefore, if \c head->next is \c NULL or \c tail_prev->prev is \c NULL,
  * the list is empty.
@@ -178,17 +178,17 @@ struct exec_node {
    }
 
    /**
-    * Is this the sentinal at the tail of the list?
+    * Is this the sentinel at the tail of the list?
     */
-   bool is_tail_sentinal() const
+   bool is_tail_sentinel() const
    {
       return this->next == NULL;
    }
 
    /**
-    * Is this the sentinal at the head of the list?
+    * Is this the sentinel at the head of the list?
     */
-   bool is_head_sentinal() const
+   bool is_head_sentinel() const
    {
       return this->prev == NULL;
    }
@@ -320,7 +320,7 @@ struct exec_list {
        *
        * - Check to see if the \c head points to the \c tail.
        * - Check to see if the \c tail_pred points to the \c head.
-       * - Check to see if the \c head is the sentinal node by test whether its
+       * - Check to see if the \c head is the sentinel node by test whether its
        *   \c next pointer is \c NULL.
        *
        * The first two methods tend to generate better code on modern systems