{
{ CLP$SCAN_WILD_CARD_LEXICAL_UNIT updates its PARSE parameter to designate the
{ next lexical unit that may include "wild card" characters.  The unit kind
{ clc$lex_wild_card_name can be thought of as "compound" units comprised of one
{ or more of the "simple" units: clc$lex_name, clc$lex_long_name,
{ clc$lex_alpha_number, clc$lex_unsigned_decimal, clc$lex_query,
{ clc$lex_multiply, clc$lex_exponentiate, and clc$lex_subtract.
{ This procedure should be used in place of CLP$SCAN_ANY_LEXICAL_UNIT when
{ "wild card" characters are possible.
{ This procedure requires that the UNITS_ARRAY field of the PARSE parameter be
{ non-NIL.
{

  PROCEDURE [INLINE] clp$scan_wild_card_lexical_unit
    (VAR parse {input, output} : clt$parse_state);

?? PUSH (LISTEXT := ON) ??

    VAR
      wild_card_encountered: boolean;


    IF parse.unit_index < parse.index_limit THEN
      IF NOT parse.unit_is_space THEN
        parse.previous_non_space_unit := parse.unit;
        parse.previous_non_space_unit_index := parse.unit_index;
      IFEND;

      parse.previous_unit_is_space := parse.unit_is_space;
      parse.unit_index := parse.index;
      parse.units_array_index := parse.units_array_index + 1;
      parse.unit := parse.units_array^ [parse.units_array_index];
      parse.index := parse.index + parse.unit.size;

      CASE parse.unit.kind OF

      = clc$lex_space, clc$lex_comment, clc$lex_unterminated_comment =
        parse.unit_is_space := TRUE;

      = clc$lex_name, clc$lex_long_name, clc$lex_query,
              clc$lex_multiply, clc$lex_exponentiate =
        parse.unit_is_space := FALSE;
        wild_card_encountered := FALSE;

      /scan_wild_card_units/
        WHILE TRUE DO
          IF parse.unit.kind IN $clt$lexical_unit_kinds
                [clc$lex_query, clc$lex_multiply, clc$lex_exponentiate,
                clc$lex_subtract] THEN
            wild_card_encountered := TRUE;
          IFEND;

          IF parse.index >= parse.index_limit THEN
            EXIT /scan_wild_card_units/;
          ELSE
            CASE parse.units_array^ [parse.units_array_index + 1].kind OF
            = clc$lex_name, clc$lex_long_name, clc$lex_alpha_number,
                  clc$lex_unsigned_decimal, clc$lex_query, clc$lex_multiply,
                  clc$lex_exponentiate =
              ;
            = clc$lex_subtract =
              CASE parse.units_array^ [parse.units_array_index + 2].kind OF
              = clc$lex_name, clc$lex_long_name, clc$lex_alpha_number,
                    clc$lex_query, clc$lex_multiply, clc$lex_exponentiate =
                ;
              = clc$lex_unsigned_decimal =
                IF NOT (parse.units_array^ [parse.units_array_index + 3].kind
                      IN $clt$lexical_unit_kinds [clc$lex_name,
                      clc$lex_long_name, clc$lex_alpha_number, clc$lex_query,
                      clc$lex_multiply, clc$lex_exponentiate]) THEN
                  EXIT /scan_wild_card_units/;
                IFEND;
              ELSE
                EXIT /scan_wild_card_units/;
              CASEND;
            ELSE
              EXIT /scan_wild_card_units/;
            CASEND;
          IFEND;

          parse.units_array_index := parse.units_array_index + 1;
          parse.unit.kind := parse.units_array^ [parse.units_array_index].kind;
          parse.index := parse.index + parse.
                units_array^ [parse.units_array_index].size;
        WHILEND /scan_wild_card_units/;

        IF wild_card_encountered THEN
          parse.unit.kind := clc$lex_wild_card_name;
          parse.unit.size := parse.index - parse.unit_index;
        IFEND;

      ELSE
        parse.unit_is_space := FALSE;
      CASEND;

    ELSEIF parse.unit.kind = clc$lex_beginning_of_line THEN
      parse.units_array_index := 2;
      parse.unit.kind := clc$lex_end_of_line;
    IFEND;

  PROCEND clp$scan_wild_card_lexical_unit;

*copyc clt$lexical_unit_kinds
*copyc clt$parse_state
?? POP ??
