21.6.5 Transforming SELECT CASE

SELECT CASE poses a few interesting problems for code generation, if efficiency and frugal stack management are important.

Consider `SELECT CASE (I('PREFIX'//A))', where `A' is CHARACTER*(*). In a case like this—basically, in any case where largish temporaries are needed to evaluate the expression—those temporaries should not be “live” during execution of any of the CASE blocks.

So, evaluation of the expression is best done within its own block, which in turn is within the SELECT CASE block itself (which contains the code for the CASE blocks as well, though each within their own block).

Otherwise, we'd have the rough equivalent of this pseudo-code:

     {
       char temp[large];
     
       libg77_catenate (temp, 'prefix', a);
     
       switch (i (temp))
         {
         case 0:
           ...
         }
     }

And that would leave temp[large] in scope during the CASE blocks (although a clever back end *could* see that it isn't referenced in them, and thus free that temp before executing the blocks).

So this approach is used instead:

     {
       int temp0;
     
       {
         char temp1[large];
     
         libg77_catenate (temp1, 'prefix', a);
         temp0 = i (temp1);
       }
     
       switch (temp0)
         {
         case 0:
           ...
         }
     }

Note how `temp1' goes out of scope before starting the switch, thus making it easy for a back end to free it.

The problem that solution has, however, is with `SELECT CASE('prefix'//A)' (which is currently not supported).

Unless the GBEL is extended to support arbitrarily long character strings in its case facility, the FFE has to implement SELECT CASE on CHARACTER (probably excepting CHARACTER*1) using a cascade of if, elseif, else, and endif constructs in GBEL.

To prevent the (potentially large) temporary, needed to hold the selected expression itself (`'prefix'//A'), from being in scope during execution of the CASE blocks, two approaches are available:

• Pre-evaluate all the CASE tests, producing an integer ordinal that is used, a la `temp0' in the earlier example, as if `SELECT CASE(temp0)' had been written.

  Each corresponding CASE is replaced with `CASE(i)', where i is the ordinal for that case, determined while, or before, generating the cascade of if-related constructs to cope with CHARACTER selection.

• Make `temp0' above just large enough to hold the longest CASE string that'll actually be compared against the expression (in this case, `'prefix'//A').

  Since that length must be constant (because CASE expressions are all constant), it won't be so large, and, further, `temp1' need not be dynamically allocated, since normal CHARACTER assignment can be used into the fixed-length `temp0'.

Both of these solutions require SELECT CASE implementation to be changed so all the corresponding CASE statements are seen during the actual code generation for SELECT CASE.