(none)

[LOUBOUTIN@CLSEPF51.BITNET]

$@jan_sys:jsend INFO-ADA@ADA20.ISI.EDU 25-AUG-1987-17-54-41-87.TMP
Using CLI$DCL_PARSE of VAX/VMS
$exit!------------------------------------------------------------------------


      Problems using CLI$DCL_PARSE provided by VAX/VMS in an Ada program
      ==================================================================

      I've been working with VAX/VMS version 4.6 operating system and the DEC
    Ada compiler version 1.4. I've been trying to use, without much success,the
    utility routine CLI$DCL_PARSE when I provide it with an input routine
    written in Ada. Here are the listings of the compilation units making up a
    sample Ada program that doesn't work.

    The main program is

with COMMAND_TABLE;
with COMMAND_PROCEDURES;
with IO_ROUTINES;
with CONDITION_HANDLING;
with SYSTEM;

procedure CLI_BUG is

  INVALID_ROUTINE_ERROR: exception;
  ----------------------------------------------------------------------------
  procedure  DCL_PARSE (DCL_TABLE_ADDRESS   : in SYSTEM.ADDRESS;
                        INPUT_ROUTINE_ADDRESS: in SYSTEM.ADDRESS;
                        COMMAND_STRING       : in STRING ;
                        PROMPT_STRING        : in STRING ) is

     STATUS : CONDITION_HANDLING.COND_VALUE_TYPE;

     procedure  CLI_DCL_PARSE (STATUS      : out
                                 CONDITION_HANDLING.COND_VALUE_TYPE;
                               COMMAND_STR : in  STRING :=
                                 STRING'NULL_PARAMETER;
                               TABLE       : in  SYSTEM.ADDRESS;
                               PARAM_ROUT  : in  SYSTEM.ADDRESS;
                               PROMPT_ROUT : in  SYSTEM.ADDRESS;
                               PROMPT_STR  : in  STRING :=
                                  STRING'NULL_PARAMETER);

     --+ OVERVIEW    : For more information see CLI$DCL_PARSE routine in the
     --+               utility routines manual

     pragma INTERFACE (EXTERNAL, CLI_DCL_PARSE);
     pragma IMPORT_VALUED_PROCEDURE (CLI_DCL_PARSE,
                                     "CLI$DCL_PARSE",
                                     MECHANISM => (VALUE,
                                                   DESCRIPTOR(A),
                                                   VALUE,
                                                   VALUE,
                                                   VALUE,
                                                   DESCRIPTOR(S)));


  begin
    if COMMAND_STRING = "" then
      CLI_DCL_PARSE (STATUS      => STATUS,
                     TABLE       => DCL_TABLE_ADDRESS,
                     PROMPT_STR  => PROMPT_STRING,
                     PARAM_ROUT  => INPUT_ROUTINE_ADDRESS,
                     PROMPT_ROUT => INPUT_ROUTINE_ADDRESS);
    else
      CLI_DCL_PARSE (STATUS      => STATUS,
                     COMMAND_STR => COMMAND_STRING,
                     TABLE       => DCL_TABLE_ADDRESS,
                     PROMPT_STR  => PROMPT_STRING,
                     PARAM_ROUT  => INPUT_ROUTINE_ADDRESS,
                     PROMPT_ROUT => INPUT_ROUTINE_ADDRESS);
    end if ;
    if not CONDITION_HANDLING.SUCCESS(STATUS) then
      CONDITION_HANDLING.SIGNAL(STATUS);
    end if ;
  end DCL_PARSE;
  ---------------------------------------------------------------------------
  procedure DISPATCH is

    STATUS : CONDITION_HANDLING.COND_VALUE_TYPE := 1;
    CLI_INVROUT: constant CONDITION_HANDLING.COND_VALUE_TYPE := 16#38912#;

    procedure CLI_DISPATCH (STATUS : out CONDITION_HANDLING.COND_VALUE_TYPE);

    --+ OVERVIEW:
    --+   For more information see CLI$DISPATCH routine in the utility
    --+ routines manual.
    --+ STATUS:
    --+   If a routine is successfully invoked, the routine status is
    --+ the status returned by the action routine. Otherwise a staus of
    --+ CLI$_INVROUT is returned. This condition value is found in R0.
    --+ if a routine written in ADA is invoked the condition value returned
    --+ will be 0. CONDITION_VALUE.SUCCESS(0) = false. Thus
    --+ CONDITION_VALUE.MATCH_COND should be used.

    pragma INTERFACE (EXTERNAL, CLI_DISPATCH);
    pragma IMPORT_VALUED_PROCEDURE (CLI_DISPATCH,
                                    "CLI$DISPATCH",
                                    MECHANISM => (VALUE));

  begin
    CLI_DISPATCH(STATUS);
    if CONDITION_HANDLING.MATCH_COND(
      CONDITION_HANDLING.COND_VALUE_TYPE(STATUS), CLI_INVROUT) = 1 then
      raise INVALID_ROUTINE_ERROR;
    end if ;
  end DISPATCH;
  ---------------------------------------------------------------------------
begin
  loop
    DCL_PARSE(DCL_TABLE_ADDRESS => COMMAND_TABLE.COMMANDS'ADDRESS,
              INPUT_ROUTINE_ADDRESS => IO_ROUTINES.READ_ROUTINE'ADDRESS,
              PROMPT_STRING => ">>",
              COMMAND_STRING => "");
    DISPATCH;
  end loop;
end CLI_BUG;

================================================================================

          The input routine called by CLI$DCL_PARSE is declared in

package IO_ROUTINES is

  procedure READ_ROUTINE(GET_STR   : out STRING;
                         PROMPT_STR: STRING;
                         OUT_LEN   : out INTEGER);

  pragma EXPORT_PROCEDURE(READ_ROUTINE);

  --+ OVERVIEW:
  --+   This routine will be called by CLI$DCL_PARSE to read a command line.
  --+ The utility routinesmanual states that it should have the same three
  --+ argument calling format as the run time library routine LIB$GET_INPUT.

end IO_ROUTINES;

with TEXT_IO;
package body IO_ROUTINES is

  procedure READ_ROUTINE(GET_STR   : out STRING;
                         PROMPT_STR: STRING;
                         OUT_LEN   : out INTEGER) is
  begin
    TEXT_IO.PUT(PROMPT_STR); TEXT_IO.GET_LINE(GET_STR, OUT_LEN);
  end READ_ROUTINE;

end IO_ROUTINES;

================================================================================

      It is necessary to declare a package to interface the available
    commands. This package is declared as

package COMMAND_TABLE is

  procedure COMMANDS;
  pragma INTERFACE(CDU, COMMANDS);
  pragma IMPORT_PROCEDURE(COMMANDS,"COMMANDS");

end COMMAND_TABLE;

      The commands are declared in a non Ada file. Let's suppose that
  this file is called COMMAND_TABLE.CLD. It contains

MODULE COMMANDS

DEFINE VERB COMM1
  ROUTINE COMM1

   It must be compiled by the command

          $ set command/obj command_table

   This would create the file command_table.obj in the default directory.
   It must be entered in the acs library by the command

           $ acs copy foreign command_table command_table

================================================================================

    The procedure called by the command COMM1 is declared in

package COMMAND_PROCEDURES is

  procedure  COMM1;
  pragma EXPORT_PROCEDURE(COMM1);

  --+ OVERVIEW:
  --+   These procedures will be called when the commands COMM1 and COMM2
  --+ are input.

end COMMAND_PROCEDURES;

with TEXT_IO;
package body COMMAND_PROCEDURES is

  procedure  COMM1 is
  begin
    TEXT_IO.PUT_LINE("I'm COMM1");
  end COMM1;

end COMMAND_PROCEDURES;

================================================================================

      Once all these compilation units have been compiled and linked, the
    execution prompts

>>

    If COMM1 is typed

>>COMM1

    the following messages are output.

%NONAME-W-NOMSG, Message number 00000000
%TRACE-W-TRACEBACK, symbolic stack dump follows
module name     routine name                     line       rel PC    abs PC


                                                           7FF5F8FD  7FF5F8FD
                                                           00001215  00001215
CLI_BUG         DCL_PARSE                          45      000000A3  00000EF1
CLI_BUG         CLI_BUG                           100      00000084  00001092
ADA$ELAB_CLI_BU ADA$ELAB_CLI_BUG                           00000009  00000809
                                                           000012EE  000012EE
                                                           0000D9D2  0000D9D2
ADA$ELAB_CLI_BU ADA$ELAB_CLI_BUG                           0000001B  0000081B
                                                           000012C9  000012C9
%NONAME-W-NOMSG, Message number 00000000
%TRACE-W-TRACEBACK, symbolic stack dump follows
module name     routine name                     line       rel PC    abs PC


CLI_BUG         DCL_PARSE                          59      00000176  00000FC4
CLI_BUG         CLI_BUG                           100      00000084  00001092
ADA$ELAB_CLI_BU ADA$ELAB_CLI_BUG                           00000009  00000809
                                                           000012EE  000012EE
                                                           0000D9D2  0000D9D2
ADA$ELAB_CLI_BU ADA$ELAB_CLI_BUG                           0000001B  0000081B
                                                           000012C9  000012C9
%CLI-E-INVROUT, invalid routine specified in command tables - check .CLD file
%TRACE-E-TRACEBACK, symbolic stack dump follows
module name     routine name                     line       rel PC    abs PC


                                                           7FF613F0  7FF613F0
                                                           00001256  00001256
CLI_BUG         DISPATCH                           87      00000020  00000FE5
CLI_BUG         CLI_BUG                           102      0000008C  0000109A
ADA$ELAB_CLI_BU ADA$ELAB_CLI_BUG                           00000009  00000809
                                                           000012EE  000012EE
                                                           0000D9D2  0000D9D2
ADA$ELAB_CLI_BU ADA$ELAB_CLI_BUG                           0000001B  0000081B
                                                           000012C9  000012C9
%ADA-F-EXCEPTION, Exception INVALID_ROUTINE_ERROR
-ADA-I-EXCRAIPRI, Exception raised prior to PC = 0000100D
%TRACE-E-TRACEBACK, symbolic stack dump follows
module name     routine name                     line       rel PC    abs PC


                                                           0000DBD6  0000DBD6
----- above condition handler called with exception 0031800C:
%ADA-F-EXCEPTION, Exception INVALID_ROUTINE_ERROR
-ADA-I-EXCRAIPRI, Exception raised prior to PC = 0000100D
----- end of exception message
                                                           000117DB  000117DB
CLI_BUG         DISPATCH                           90      00000048  0000100D
CLI_BUG         CLI_BUG                           102      0000008C  0000109A
ADA$ELAB_CLI_BU ADA$ELAB_CLI_BUG                           00000009  00000809
                                                           000012EE  000012EE
                                                           0000D9D2  0000D9D2
ADA$ELAB_CLI_BU ADA$ELAB_CLI_BUG                           0000001B  0000081B
                                                           000012C9  000012C9

     I had the same messages even when I used a different body for the
   procedure READ_INPUT. Using the debugger I've  noticed that CLI$DCL_PARSE
   couldn't receive parameter GET_STR from READ_ROUTINE though this parameter
   is in mode "out". I wasn't able to find the reason. I would be very
   interested if anyone had any experience on the subject.

     Thanks for any help,

                                          Isak Maim
                                          Swiss Federal
                                          Institute of Technology

                                                       Lausanne,
                                                       -----------
                                                       Switzerland

                                          tel: (21) 47 42 37
                                          Email: MAIM@CLSEPF51 (EARN/BITNET)