🚀 go-pugleaf

In article <4hl8mt$4po@newshost.cyberramp.net> John Noland,
sinan@cyberramp.net writes:
>>Example for a good use of goto:
>>---                    ????
>>------------------------------------------------------------------------------
>>   HEV    hev1, hev2, hev3;     /* Event semaphores */
>>   HMTX   hmtx;                 /* Mutex semaphore  */ 
>>   void  *ptr;              
>
>>   if (!DosCreateEventSem(0, &hev1, 0, FALSE))
>>       goto hev1_failed;
>>
>>   if (!DosCreateEventSem(0, &hev2, 0, FALSE))
>>       goto hev2_failed;
>
>>   if (!DosCreateEventSem(0, &hev3, 0, FALSE))
>>       goto hev3_failed;
>>
>>   if (!DosCreateMutexSem(0, &hmtx, 0, FALSE))
>>       goto hmtx_failed;
>>
>>   if ((ptr = malloc(SOME_SIZE)) == NULL)
>>       goto malloc_failed;
>>
>>   /* Do some stuff here */
>>   return TRUE; /* We did okay */
>>
>>malloc_failed:
>>   DosCloseMutexSem(hmtx);
>>hmtx_failed:
>>   DosCloseEventSem(hev3);
>>hev3_failed:
>>   DosCloseEventSem(hev2);
>>hev2_failed:
>>   DosCloseEventSem(hev1);
>>hev1_failed:
>>   return FALSE;
>

One can introduce a flag and a subroutine. When the flag is non-zero
something has failed. The rightmost 4 bits indicate what was allocated
that needs to be released. Of course, in a real implementation, #defines
would be needed for the bits. (My C is rusty; hope I haven't written
anything too stupid.)

{
   HEV    hev1, hev2, hev3;     /* Event semaphores */
   HMTX   hmtx;                 /* Mutex semaphore  */ 
   void  *ptr; 
   int result = 0;              

   result = createStuff( &hev1, &hev2, &hev3, &htmx );
   
   if( !result )
       if ((ptr = malloc(SOME_SIZE)) == NULL)
           result = 0x100F;

   if( !result ) {
       if( result & 0x01 ) DosCloseEventSem(hev1);
       if( result & 0x02 ) DosCloseEventSem(hev2);
       if( result & 0x04 ) DosCloseEventSem(hev3);
       if( result & 0x08 ) DosCloseMutexSem(hmtx);
       return FALSE;
       }
 
   /* Do some stuff here */
   return TRUE; /* We did okay */
}


int createStuff( HEV *hev1, HEV *hev2, HEV *hev3, HMTX *htmx ) 
{
   if (!DosCreateEventSem(0, hev1, 0, FALSE))  return 0x1000;
   if (!DosCreateEventSem(0, hev2, 0, FALSE))  return 0x1001;
   if (!DosCreateEventSem(0, hev3, 0, FALSE))  return 0x1003;
   if (!DosCreateMutexSem(0, hmtx, 0, FALSE))  return 0x1007;
   return 0;
}

Now, is this better? It all depends upon how one defines 'better', I
guess. Such cascaded allocations are always a bit of a mess, and the
solution with GOTOs is clear and clean, provided it is isolated within a
subroutine so that this is ALL the code, and one can readily see the
scope of the GOTOs.

On the other hand, I've spent a lot of years writing code in a language
that doesn't have a goto at all and I sure haven't missed them, even
though I started out programming 30 years ago using FORTRAN IV and
Assembler, in which one cannot do anything without a GOTO. I wrote huge
amounts of C code a few years ago without a single GOTO and didn't miss
them then either, and think my code was better without them. 
 
However, I still think that clean code is far more important that how
well that code follows some arbitrary set of rules, even good rules.

Dave

__________________________________
David N. Smith
dnsmith@dnsmith.tjwslip.ny.k12.net (Preferred)
dnsmith@watson.ibm.com
70167.2274@compuserve.com
IBM T J Watson Research Center
Hawthorne, NY
__________________________________
Any opinions or recommendations
herein are those of the author  
and not of his employer.