cleanup, and use bool in place of int in one place

mpictor · mpictor · commit 485cfa85d4a0 · 2012-06-24T11:22:18.000-04:00
diff --git a/include/express/stmt.h b/include/express/stmt.h
@@ -131,7 +131,7 @@ struct Compound_Statement_ {
 
 struct Conditional_ {
     Expression test;
-    Linked_List code;       /**< list of statements */
+    Linked_List code;           /**< list of statements */
     Linked_List otherwise;      /**< list of statements */
 };
 
diff --git a/src/clstepcore/STEPcomplex.cc b/src/clstepcore/STEPcomplex.cc
@@ -69,7 +69,7 @@ void STEPcomplex::Initialize( const char ** names, const char * schnm ) {
     *eptr = ents, *prev = NULL, *enext;
     const EntityDescriptor * enDesc;
     char nm[BUFSIZ];
-    int invalid = 0, outOfOrder = 0;
+    bool invalid = false, outOfOrder = false;
 
     // Splice out the invalid names from our list:
     while( eptr ) {
@@ -88,11 +88,11 @@ void STEPcomplex::Initialize( const char ** names, const char * schnm ) {
                 // support structs only deal with the original names) and have
                 // ents re-ort eptr properly in the list:
                 eptr->Name( StrToLower( enDesc->Name(), nm ) );
-                outOfOrder = 1;
+                outOfOrder = true;
             }
             prev = eptr;
         } else {
-            invalid = 1;
+            invalid = true;
             cerr << "ERROR: Invalid entity \"" << eptr->Name()
                  << "\" found in complex entity.\n";
             if( !prev ) {
diff --git a/src/express/entity.c b/src/express/entity.c
@@ -227,6 +227,9 @@ Variable ENTITY_find_inherited_attribute( Entity entity, char * name, int * down
     return 0;
 }
 
+/** find a (possibly inherited) attribute
+ * \sa ENTITY_find_inherited_attribute
+ */
 Variable ENTITYfind_inherited_attribute( struct Scope_ *entity, char * name,
                                 struct Symbol_ ** down_sym ) {
     extern int __SCOPE_search_id;
diff --git a/src/express/expr.c b/src/express/expr.c
@@ -396,12 +396,12 @@ Type EXPresolve_op_dot( Expression expr, Scope scope ) {
             resolved_all( expr );
             return( op2->return_type );
         case enumeration_:
+            /* enumerations within a select will be handled by `case select_` above,
+             * which calls EXP_resolve_op_dot_fuzzy(). */
             item = ( Expression )DICTlookup( TYPEget_enum_tags( op1type ), op2->symbol.name );
-            /*  item = (Expression )DICTlookup(TYPEget_enum_tags(op1->return_type),op2->symbol.name);*/
             if( !item ) {
                 ERRORreport_with_symbol( ERROR_enum_no_such_item, &op2->symbol,
                                          op1type->symbol.name, op2->symbol.name );
-                /*      ERRORreport_with_symbol(ERROR_enum_no_such_item,&op2->symbol,op1->return_type->symbol.name,op2->symbol.name);*/
                 resolve_failed( expr );
                 return( Type_Bad );
             }
@@ -784,10 +784,14 @@ Type EXPresolve_op_unary_minus( Expression e, Scope s ) {
     return e->e.op1->return_type;
 }
 
-/**
+/** Initialize one entry in EXPop_table
+ * This table's function pointers are resolved in \sa EXP_resolve()
+ * , at approx resolve.c:520
+ * \sa EXPop_init()
+ *
+ * \param token_number operator value, usually in macro form
+ * \param string human-readable description
  * \param resolve_func   resolves an expression of this type
- * \param type_func  returns final type of expression of this type
- * avoids resolution if possible
  */
 void EXPop_create( int token_number, char * string, Resolve_expr_func * resolve_func ) {
     EXPop_table[token_number].token = string;
diff --git a/src/express/resolve.c b/src/express/resolve.c
@@ -930,7 +930,7 @@ void STMTresolve( Statement statement, Scope scope ) {
             break;
         case STMT_SKIP:
         case STMT_ESCAPE:
-            /* do nothing */
+            /* do nothing */ //WARNING should we really *not* do anything for these?
             ;
     }
 }
@@ -1066,12 +1066,12 @@ void ENTITYcheck_missing_supertypes( Entity ent ) {
 void ENTITYcalculate_inheritance( Entity e ) {
     e->u.entity->inheritance = 0;
 
-    LISTdo( e->u.entity->supertypes, super, Entity )
-    if( super->u.entity->inheritance == ENTITY_INHERITANCE_UNINITIALIZED ) {
-        ENTITYcalculate_inheritance( super );
-    }
-    e->u.entity->inheritance += ENTITYget_size( super );
-    LISTod
+    LISTdo( e->u.entity->supertypes, super, Entity ) {
+        if( super->u.entity->inheritance == ENTITY_INHERITANCE_UNINITIALIZED ) {
+            ENTITYcalculate_inheritance( super );
+        }
+        e->u.entity->inheritance += ENTITYget_size( super );
+    } LISTod
 }
 
 /** returns 1 if entity is involved in circularity, else 0 */

Original file line number	Diff line number	Diff line change
`@@ -227,6 +227,9 @@ Variable ENTITY_find_inherited_attribute( Entity entity, char * name, int * down`
`227`	`227`	`return 0;`
`228`	`228`	`}`
`229`	`229`
	`230`	`+/** find a (possibly inherited) attribute`
	`231`	`+ * \sa ENTITY_find_inherited_attribute`
	`232`	`+ */`
`230`	`233`	`Variable ENTITYfind_inherited_attribute( struct Scope_ entity, char name,`
`231`	`234`	`struct Symbol_ ** down_sym ) {`
`232`	`235`	`extern int __SCOPE_search_id;`