in case labels, handle selects with enum supertypes

mpictor · mpictor · commit 357bdc3374a8 · 2012-06-24T13:59:53.000-04:00
diff --git a/src/express/expr.c b/src/express/expr.c
@@ -234,12 +234,19 @@ void EXPcleanup( void ) {
 }
 
 /**
+ * \param selection the Type to look in (i.e. an enum)
+ * \param ref the Symbol to be found
+ * \param e set to the Expression found, when an enum is found
+ * \param v set to the Variable found, when a variable is found
+ * \param dt set to DICT_type when a match is found (use to determine whether to use e or v)
+ * \param where used by ENTITYfind_inherited_attribute, not sure of purpose
  * \param s_id the search id, a parameter to avoid colliding with ENTITYfind...
  * there will be no ambiguities, since we're looking at (and marking)
  * only types, and it's marking only entities
  */
-static int EXP_resolve_op_dot_fuzzy( Type selection, Symbol ref, Variable * v, char * dt,
-                          struct Symbol_ ** where, int s_id ) {
+static int EXP_resolve_op_dot_fuzzy( Type selection, Symbol ref, Expression * e,
+                      Variable * v, char * dt, struct Symbol_ ** where, int s_id ) {
+    Expression item;
     Variable tmp;
     int options = 0;
     struct Symbol_ *w = NULL;
@@ -265,7 +272,7 @@ static int EXP_resolve_op_dot_fuzzy( Type selection, Symbol ref, Variable * v, c
         case select_:
             selection->search_id = s_id;
             LISTdo( selection->u.type->body->list, t, Type )
-            if( EXP_resolve_op_dot_fuzzy( t, ref, v, dt, &w, s_id ) ) {
+            if( EXP_resolve_op_dot_fuzzy( t, ref, e, v, dt, &w, s_id ) ) {
                 if( w != NULL ) {
                     *where = w;
                 }
@@ -282,6 +289,13 @@ static int EXP_resolve_op_dot_fuzzy( Type selection, Symbol ref, Variable * v, c
                     *v = VARIABLE_NULL;
                     return 1;
             }
+        case enumeration_:
+            item = ( Expression )DICTlookup( TYPEget_enum_tags( selection ), ref.name );
+            if( item ) {
+                *e = item;
+                *dt = DICT_type;
+                return 1;
+            }
         default:
             return 0;
     }
@@ -293,6 +307,7 @@ Type EXPresolve_op_dot( Expression expr, Scope scope ) {
     Variable v;
     Expression item;
     Type op1type;
+    bool all_enums = true; //used by 'case select_'
 
     /* stuff for dealing with select_ */
     int options = 0;
@@ -319,34 +334,50 @@ Type EXPresolve_op_dot( Expression expr, Scope scope ) {
             /* don't think this actually actually catches anything on the */
             /* first go-round, but let's be consistent */
             op1type->search_id = __SCOPE_search_id;
-            LISTdo( op1type->u.type->body->list, t, Type )
-            if( EXP_resolve_op_dot_fuzzy( t, op2->symbol, &v, &dt, &where,
-                                          __SCOPE_search_id ) ) {
-                ++options;
-            }
-            LISTod;
-
+            LISTdo( op1type->u.type->body->list, t, Type ) {
+                if( EXP_resolve_op_dot_fuzzy( t, op2->symbol, &item, &v, &dt, &where,
+                                                __SCOPE_search_id ) ) {
+                    ++options;
+                }
+            } LISTod;
             switch( options ) {
                 case 0:
-                    /* no possible resolutions */
-                    ERRORreport_with_symbol( ERROR_undefined_attribute,
-                                             &op2->symbol, op2->symbol.name );
+                    LISTdo( op1type->u.type->body->list, t, Type ) {
+                        if( t->u.type->body->type != enumeration_ ) {
+                            all_enums = false;
+                        }
+                    } LISTod;
+
+                    if( all_enums ) {
+                        ERRORreport_with_symbol( WARNING_case_skip_label, &op2->symbol, op2->symbol.name );
+                    } else {
+                        /* no possible resolutions */
+                        ERRORreport_with_symbol( ERROR_undefined_attribute,
+                                                &op2->symbol, op2->symbol.name );
+                    }
                     resolve_failed( expr );
                     return( Type_Bad );
                 case 1:
                     /* only one possible resolution */
-                    if( dt != OBJ_VARIABLE ) {
+                    if( dt == OBJ_VARIABLE ) {
+                        if( where ) {
+                            ERRORreport_with_symbol( ERROR_implicit_downcast, &op2->symbol,
+                                                    where->name );
+                        }
+
+                        op2->u.variable = v;
+                        op2->return_type = v->type;
+                        resolved_all( expr );
+                        return( v->type );
+                    } else if ( dt == OBJ_ENUM ) {
+                        op2->u.expression = item;
+                        op2->return_type = item->type;
+                        resolved_all( expr );
+                        return( item->type );
+                    } else {
                         printf( "EXPresolved_op_dot: attribute not an attribute?\n" );
                         ERRORabort( 0 );
-                    } else if( where ) {
-                        ERRORreport_with_symbol( ERROR_implicit_downcast, &op2->symbol,
-                                                 where->name );
                     }
-
-                    op2->u.variable = v;
-                    op2->return_type = v->type;
-                    resolved_all( expr );
-                    return( v->type );
                 default:
                     /* compile-time ambiguous */
                     if( where ) {
diff --git a/src/express/resolve.c b/src/express/resolve.c
@@ -836,21 +836,30 @@ void STMTlist_resolve( Linked_List list, Scope scope ) {
 }
 
 /**
-** \param item case item to resolve
-** \param scope scope in which to resolve
-**
-** Resolve all references in a case item
-*/
-void CASE_ITresolve( Case_Item item, Scope scope, Type type ) {
-    LISTdo( item->labels, e, Expression )
-    EXPresolve( e, scope, type );
-    LISTod;
-    STMTresolve( item->action, scope );
+ * \param item case item to resolve
+ * \param scope scope in which to resolve
+ * \param statement the CASE statement (for return type, etc)
+ *
+ * Resolve all references in a case item
+ */
+void CASE_ITresolve( Case_Item item, Scope scope, Statement statement ) {
+    int validLabels = 0;
+    LISTdo( item->labels, e, Expression ) {
+        EXPresolve( e, scope, statement->u.Case->selector->return_type );
+        if ( e->return_type != Type_Bad ) {
+            validLabels++;
+        }
+    } LISTod;
+    if( validLabels ) {
+        STMTresolve( item->action, scope );
+    }
 }
 
 void STMTresolve( Statement statement, Scope scope ) {
-    Type type;
+    //scope is always the function/procedure/rule from SCOPEresolve_expressions_statements();
     Scope proc;
+    Logical eval;
+    bool skipped = false;
 
     if( !statement ) {
         return;    /* could be null statement */
@@ -871,10 +880,9 @@ void STMTresolve( Statement statement, Scope scope ) {
             break;
         case STMT_CASE:
             EXPresolve( statement->u.Case->selector, scope, Type_Dont_Care );
-            type = statement->u.Case->selector->return_type;
-            LISTdo( statement->u.Case->cases, c, Case_Item )
-            CASE_ITresolve( c, scope, type );
-            LISTod;
+            LISTdo( statement->u.Case->cases, c, Case_Item ) {
+                CASE_ITresolve( c, scope, statement );
+            } LISTod;
             break;
         case STMT_COMPOUND:
             STMTlist_resolve( statement->u.compound->statements, scope );
