18.05.04.08 Instrução case

 

Exemplo

 

 

case currChar of

  when {'A' .. 'Z'} | {'a' .. 'z'}:

    characterClass := LETTER;

  when {'0' .. '9'}:

    characterClass := DIGIT;

  when {'!', '$', '%', '&', '*', '+', ',', '-', '.', '/',

      ':', ';', '<', '=', '>', '?', '@', '\', '^', '`',

      '|', '~'}:

    characterClass := SPECIAL;

  when {'(', ')', '[', ']', '{', '}'}:

    characterClass := PAREN;

  when {'"'}:  # Also possible '\"'

    characterClass := APPOSTROPHE;

  when {'''}:  # Also possible '\''

    characterClass := QUOTE;

  otherwise:

    characterClass := ILLEGAL;

end case;

 

 

 

Semântica:

 

A expressão entre "case" e "of" é analisada.

Quando o resultado "casa" com algum elemento entre as várias instruções "when" as instruções logo após os : (dois-pontos) são executadas e a instrução "case" é finalizada.

Quando o valor não "casar" com nenhum elemento entre as várias instruções "when", então as instruções logo após os : (dois-pontos) do bloco "otherwise" são executadas e a instrução "case" é finalizada.

Quando o valor não "casar" com nenhum elemento entre as várias instruções "when" e não houver a instrução "otherwise" a instrução "case" é finalizada.

 

Sintaxe:

 

 

case_statement ::=

'case' expression 'of'

  { 'when' set_expression ':'

    statement }

  [ 'otherwise' ':'

    statement ]

'end' 'case' .

 

set_expression ::=

expression .

 

 

 

Declaration:

 

 

$ syntax expr: .case.().of.().end.case is                      -> 25;

$ syntax expr: .case.().of.().otherwise. : .().end.case is     -> 25;

$ syntax expr: .case.().of.end.case is                         -> 25;

 

$ syntax expr: .when.(). : .().() is              <- 60;

$ syntax expr: .when.(). : .() is                 <- 60;

 

const proc: CASE_DECLS (in type: aType) is func

  local

    var type: WHEN_RESULT is void;

    var type: WHEN_PROC is void;

    var type: SELECTOR_TYPE is void;

  begin

    WHEN_RESULT := newtype;

    WHEN_PROC := (func WHEN_RESULT);

    SELECTOR_TYPE := set of aType;

    const proc: case (ref aType param) of end case                       is noop;

    const proc: case (ref aType param) of

                  (ref WHEN_PROC param)

                end case                                                 is action "PRC_CASE";

    const proc: case (ref aType param) of

                  (ref WHEN_PROC param)

                  otherwise : (ref proc param)

                end case                                                 is action "PRC_CASE_DEF";

    const proc: (ref WHEN_RESULT param) ::= enumlit                      is action "ENU_GENLIT";

    const WHEN_RESULT: WHEN_EMPTY (attr aType) is enumlit;

    const proc: (ref WHEN_PROC param) ::= (ref WHEN_RESULT param)        is action "ENU_CREATE";

    const WHEN_PROC: when (ref SELECTOR_TYPE param) : (ref proc param)   is WHEN_EMPTY(aType);

    const WHEN_PROC: when (ref SELECTOR_TYPE param) : (ref proc param)

                       (ref WHEN_PROC param)                             is WHEN_EMPTY(aType);

  end func;

 

CASE_DECLS(integer);

CASE_DECLS(char);