?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE SCL Interpreter : Parameter List Evaluators' ??
MODULE clm$evaluate_parameters;

{
{ PURPOSE:
{   This module contains the procedures that evaluate command and function
{   parameter lists under control of a Parameter Description Table (PDT - see
{   below).  The output of these procedures is a Parameter Value Table (PVT -
{   see below) that represents the evaluated parameter list.  The routines in
{   this module are also responsible for performing interactive prompting for
{   parameters and related information.  Also in this module is the routine
{   that prepares a PDT for processing (i.e., "unbundles" it).
{
{ DESIGN:
{   The parameter list is parsed using the technique known as "recursive
{   descent".  This means that "knowledge" of the syntax of parameter lists is
{   embodied in the code rather than in syntax tables and that, in general, for
{   each syntactic construct there is a corresponding procedure to process it.
{   Evaluation of parameter values is the job of the SCL expression evaluator
{   and is therefore to be found in module clm$evaluate_expression.
{
{ NOTE:
{   The internal parameter evaluation routine is used to evaluate an expression
{   for a "record" type.  This is because such expressions have the form and
{   many of the characteristics of a parameter list for a function.  In aid of
{   this, the "type description" for a "record" type is in the form of an
{   "unbundled" PDT.
{

?? NEWTITLE := 'Global Declarations' ??
?? NEWTITLE := 'Parameter List', EJECT ??
*copyc clt$parameter_list
*copyc clt$parameter_list_text
*copyc clt$parameter_list_text_index
*copyc clt$parameter_list_text_size
*copyc clt$i_parameter_list_contents
?? TITLE := 'Parameter Description Table (PDT)', EJECT ??
*copyc clt$parameter_description_table
?? TITLE := 'Unbundled Parameter Description Table', EJECT ??
*copyc clt$unbundled_pdt
?? TITLE := 'Parameter Value Table (PVT)', EJECT ??
*copyc clt$parameter_value_table
?? TITLE := 'clt$parameter_dialog_manager', EJECT ??
*copyc clh$parameter_dialog_manager
*copyc clt$parameter_dialog_manager
?? OLDTITLE, EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clc$standard_file_names
*copyc cle$bad_declaration_version
*copyc cle$bad_parameter_list
*copyc cle$bad_pdt
*copyc cle$bad_pvt
*copyc cle$command_cancelled
*copyc cle$command_terminated
*copyc cle$ecc_file_reference
*copyc cle$ecc_lexical
*copyc cle$ecc_parsing
*copyc cle$function_cancelled
*IF $true(osv$unix)
*copyc cle$not_supported
*IFEND
*copyc cle$param_dialog_not_privileged
*copyc cle$parameters_displayed
*copyc cle$unable_to_call_check_proc
*copyc cle$unable_to_call_parm_dlg_mgr
*copyc cle$unexpected_call_to
*copyc cle$var_sub_params_not_allowed
*IF $true(osv$unix)
*copyc cle$work_area_overflow
*IFEND
*copyc clk$pop_parameters
*copyc clk$push_parameters
*copyc clk$scan_parameter_list
*copyc clt$check_parameters_procedure
*copyc clt$command_line
*copyc clt$command_line_index
*copyc clt$command_line_size
*copyc clt$interpreter_modes
*copyc clt$parameter_index
*copyc clt$parameter_name_index
*copyc clt$parameter_reference
*copyc clt$pdt_changes
*copyc clt$scl_procedure
*copyc clt$scl_procedure_header
*copyc clt$work_area
*copyc ift$format_effectors
*copyc oss$job_paged_literal
*copyc oss$task_shared
*copyc ost$help_module
*copyc ost$status
?? POP ??
*IF NOT $true(osv$unix)
*copyc amp$fetch
*copyc amp$put_next
*copyc amp$put_partial
*copyc avp$ring_min
*IFEND
*copyc clp$append_status_parse_state
*IF NOT $true(osv$unix)
*copyc clp$append_status_type_desc
*copyc clp$change_type_specification
*IFEND
*copyc clp$convert_type_spec_to_desc
*IF NOT $true(osv$unix)
*copyc clp$copy_data_value
*IFEND
*copyc clp$data_representation_text
*copyc clp$display_cmnd_or_func_info
*IF NOT $true(osv$unix)
*copyc clp$echo_command
*copyc clp$evaluate_name
*copyc clp$evaluate_name_for_write
*copyc clp$find_current_block
*copyc clp$find_scl_options
*copyc clp$get_all_cmnd_or_func_names
*copyc clp$get_cmnd_or_func_source_str
*copyc clp$get_command_line
*copyc clp$get_parameter_list_parse
*copyc clp$get_system_file_id
*copyc clp$get_work_area
*ELSE
*copyc clc$declaration_version
*copyc cle$pdt_processor_mismatch
*copyc clp_getenv
*copyc clp$get_parameter_list_parse
*IFEND
*copyc clp$identify_lexical_units
*IF NOT $true(osv$unix)
*copyc clp$include_line
*IFEND
*copyc clp$initialize_parse_state
*IF NOT $true(osv$unix)
*copyc clp$internal_convert_to_string
*IFEND
*copyc clp$internal_evaluate_expr
*IF NOT $true(osv$unix)
*copyc clp$load_system_entry_point
*copyc clp$log_command_line
*IFEND
*copyc clp$make_deferred_value
*IF NOT $true(osv$unix)
*copyc clp$pass_variable_parameter
*copyc clp$pop_block_stack
*copyc clp$pop_interactive_input
*IFEND
*copyc clp$produce_variable_ref_expr
*IF NOT $true(osv$unix)
*copyc clp$push_interactive_input
*copyc clp$push_sub_parameters_block
*IFEND
*copyc clp$save_evaluated_parameters
*copyc clp$scan_any_lexical_unit
*IF NOT $true(osv$unix)
*copyc clp$scan_bal_paren_lexical_unit
*IFEND
*copyc clp$scan_non_space_lexical_unit
*copyc clp$scan_to_lexical_limit
*copyc clp$scan_unnested_sep_lex_unit
*copyc clp$search_parameter_names
*copyc clp$reset_input_state
*copyc clp$setup_parameter_evaluation
*IF NOT $true(osv$unix)
*copyc clp$set_prompting_input
*IFEND
*copyc clp$trimmed_string_size
*IF NOT $true(osv$unix)
*copyc clp$unpass_variable_parameter
*copyc clp$validate_var_conformance
*copyc clv$standard_files
*copyc ifp$change_terminal_attributes
*copyc ifp$discard_suspended_output
*copyc ifp$fetch_context
*copyc ifp$get_terminal_attributes
*IFEND
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*IF NOT $true(osv$unix)
*copyc osp$disestablish_cond_handler
*copyc osp$enforce_exception_policies
*copyc osp$establish_block_exit_hndlr
*copyc osp$establish_condition_handler
*copyc osp$file_access_condition
*copyc osp$find_brief_help_message
*copyc osp$find_full_help_message
*copyc osp$find_help_module
*copyc osp$find_parameter_prompt
*copyc osp$find_param_assist_prompt
*copyc osp$find_parameter_help_message
*copyc osp$format_help_message
*copyc osp$generate_message
*copyc osp$generate_output_message
*IFEND
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*IF NOT $true(osv$unix)
*copyc osv$initial_exception_context
*IFEND
*copyc osv$lower_to_upper
*copyc osv$upper_to_lower
*IF NOT $true(osv$unix)
*copyc pmp$change_term_error_level
*copyc pmp$continue_to_cause
*copyc pmp$load
?? EJECT ??
*copyc clc$system_messages_module

{
{ The following constants define the names of particular prompts within
{ the standard prompts and messages module.
{

  CONST
    clc$all_command_params_correct = 'CLC$ALL_COMMAND_PARAMS_CORRECT ',
    clc$confirm_new_param_version = 'CLC$CONFIRM_NEW_PARAM_VERSION  ',
    clc$confirm_param_default_value = 'CLC$CONFIRM_PARAM_DEFAULT_VALUE',
    clc$confirm_parameter_name = 'CLC$CONFIRM_PARAMETER_NAME     ',
    clc$correct_command_params_msg = 'CLC$CORRECT_COMMAND_PARAMS_MSG ',
    clc$correct_function_params_msg = 'CLC$CORRECT_FUNCTION_PARAMS_MSG',
    clc$correct_parameters_prompt = 'CLC$CORRECT_PARAMETERS_PROMPT  ',
    clc$default_param_assist_prompt = 'CLC$DEFAULT_PARAM_ASSIST_PROMPT',
    clc$default_parameter_prompt = 'CLC$DEFAULT_PARAMETER_PROMPT   ',
    clc$enter_command_params_msg = 'CLC$ENTER_COMMAND_PARAMS_MSG   ',
    clc$enter_function_params_msg = 'CLC$ENTER_FUNCTION_PARAMS_MSG  ',
    clc$no_command_params_msg = 'CLC$NO_COMMAND_PARAMS_MSG      ',
    clc$no_function_params_msg = 'CLC$NO_FUNCTION_PARAMS_MSG     ',
    clc$prompt_for_advanced_param = 'CLC$PROMPT_FOR_ADVANCED_PARAM  ',
    clc$prompt_for_parameter_name = 'CLC$PROMPT_FOR_PARAMETER_NAME  ';

{
{ The following constants define the entry point names for the dynamically
{ loaded parameter dialog managers.
{

  CONST
    clc$desktop_param_dialog_mgr = 'DEP$SCL_PARAMETER_DIALOG_MGR   ',
    clc$screen_param_dialog_mgr = 'CLP$SCL_PARAMETER_DIALOG_MGR   ';

?? TITLE := 'clp$get_parameter_list_text', EJECT ??
*copyc clh$get_parameter_list_text

  PROCEDURE [XDCL, #GATE] clp$get_parameter_list_text
    (    parameter_list: ^clt$parameter_list;
     VAR parameter_list_text: ^clt$parameter_list_text;
     VAR status: ost$status);

    VAR
      parameter_list_area: ^clt$parameter_list,
      parameter_list_contents: ^clt$i_parameter_list_contents;

?? NEWTITLE := 'get_text_from_block', EJECT ??

    PROCEDURE [INLINE] get_text_from_block
      (VAR parameter_list_text: ^clt$parameter_list_text);

      VAR
        block: ^clt$block,
        parameters_block: ^clt$block;


      parameter_list_text := NIL;

      clp$find_current_block (block);
      parameters_block := NIL;
      CASE block^.kind OF
      = clc$command_block, clc$function_block, clc$sub_parameters_block =
        parameters_block := block;
      = clc$task_block =
        IF block^.task_kind = clc$other_task THEN
          IF block^.synchronous_with_parent AND (block^.previous_block^.kind = clc$command_block) AND
                (block^.previous_block^.command_kind = clc$program_command) THEN
            parameters_block := block^.previous_block;
          ELSE
            parameters_block := block;
          IFEND;
        IFEND;
      ELSE
        ;
      CASEND;
      IF parameters_block = NIL THEN
        RETURN;
      IFEND;

      parameter_list_text := ^parameters_block^.line_parse.
            text^ (parameters_block^.line_parse.unit_index, parameters_block^.line_parse.index_limit -
            parameters_block^.line_parse.unit_index);

    PROCEND get_text_from_block;
?? OLDTITLE, EJECT ??

    status.normal := TRUE;
    parameter_list_text := NIL;

  /get_text/
    BEGIN
      IF parameter_list = NIL THEN
        EXIT /get_text/;
      IFEND;

      parameter_list_area := parameter_list;
      RESET parameter_list_area;
      NEXT parameter_list_contents IN parameter_list_area;

      IF parameter_list_contents = NIL THEN
        EXIT /get_text/;
      IFEND;

      IF (parameter_list_contents^.identifying_size_field =
            UPPERVALUE (parameter_list_contents^.identifying_size_field)) AND
            (#SIZE (parameter_list^) = #SIZE (clt$i_parameter_list_contents)) THEN
        get_text_from_block (parameter_list_text);
      ELSE
        NEXT parameter_list_text: [parameter_list_contents^.identifying_size_field] IN parameter_list_area;
      IFEND;
    END /get_text/;

    IF parameter_list_text = NIL THEN
      osp$set_status_condition (cle$bad_parameter_list, status);
    IFEND;

  PROCEND clp$get_parameter_list_text;
?? TITLE := 'clp$get_reason_for_call', EJECT ??
*copyc clh$get_reason_for_call

  PROCEDURE [XDCL, #GATE] clp$get_reason_for_call
    (VAR information_request: boolean;
     VAR display_file: fst$path;
     VAR prompting_activated: boolean;
     VAR status: ost$status);

    VAR
      evaluation_context: clt$parameter_eval_context,
      help_context: clt$parameter_help_context,
      ignore_parse: clt$parse_state,
      ignore_prompting_style: ost$interaction_style,
      ignore_work_area_ptr: ^^clt$work_area,
      local_status: ost$status;


    status.normal := TRUE;
    local_status.normal := TRUE;

  /get_reason_for_call/
    BEGIN
      clp$setup_parameter_evaluation (NIL, osc$null_name, FALSE, ignore_parse,
            ignore_work_area_ptr, evaluation_context, help_context, local_status);
      IF NOT local_status.normal THEN
        EXIT /get_reason_for_call/;
      IFEND;

      information_request := evaluation_context.interpreter_mode = clc$help_mode;

      IF help_context.help_output_file = NIL THEN
        display_file := '';
      ELSE
        display_file := help_context.help_output_file^;
      IFEND;

      determine_prompting_style (evaluation_context, prompting_activated, ignore_prompting_style,
            local_status);
      local_status.normal := TRUE;
    END /get_reason_for_call/;

    IF local_status.normal THEN
      status.normal := TRUE;
    ELSEIF local_status.condition = cle$unexpected_call_to THEN
      osp$set_status_abnormal ('CL', cle$unexpected_call_to, 'clp$get_reason_for_call', status);
    ELSE
      status := local_status;
    IFEND;

  PROCEND clp$get_reason_for_call;
?? TITLE := 'clp$log_and_or_echo_command', EJECT ??
*copyc clh$log_and_or_echo_command

  PROCEDURE [XDCL, #GATE] clp$log_and_or_echo_command
    (    edited_parameter_list_text: clt$parameter_list_text;
     VAR status: ost$status);

    VAR
      edited_command: ^clt$command_line,
      edited_command_size: integer,
      edited_parameter_list_text_size: clt$parameter_list_text_size,
      evaluation_context: clt$parameter_eval_context,
      help_context: clt$parameter_help_context,
      ignore_work_area_ptr: ^^clt$work_area,
      local_status: ost$status,
      parse: clt$parse_state;


    status.normal := TRUE;
    local_status.normal := TRUE;

  /log_and_or_echo_command/
    BEGIN
      clp$setup_parameter_evaluation (NIL, osc$null_name, TRUE, parse, ignore_work_area_ptr,
            evaluation_context, help_context, local_status);
      IF NOT local_status.normal THEN
        EXIT /log_and_or_echo_command/;
      IFEND;

      edited_parameter_list_text_size := clp$trimmed_string_size (edited_parameter_list_text);
      edited_command_size := evaluation_context.command_or_function_source^.reference_size + 1 +
            edited_parameter_list_text_size;
      IF edited_command_size > clc$max_command_line_size THEN
        edited_command_size := clc$max_command_line_size;
      IFEND;

      PUSH edited_command: [edited_command_size];
      edited_command^ (1, evaluation_context.command_or_function_source^.reference_size) :=
            parse.text^ (evaluation_context.command_or_function_source^.reference_index,
            evaluation_context.command_or_function_source^.reference_size);
      IF evaluation_context.command_or_function_source^.reference_size < edited_command_size THEN
        edited_command^ (evaluation_context.command_or_function_source^.reference_size + 1) := ' ';
        edited_command^ (evaluation_context.command_or_function_source^.reference_size + 2, * ) :=
              edited_parameter_list_text (1, edited_parameter_list_text_size);
      IFEND;

      IF NOT evaluation_context.command_logging_completed THEN
        clp$log_command_line (edited_command^, local_status);
        local_status.normal := TRUE;
      IFEND;

      IF NOT evaluation_context.command_echoing_completed THEN
        clp$echo_command (evaluation_context.interpreter_mode, edited_command^, {ignore} local_status);
        local_status.normal := TRUE;
      IFEND;
    END /log_and_or_echo_command/;

    IF local_status.normal THEN
      status.normal := TRUE;
    ELSEIF local_status.condition = cle$unexpected_call_to THEN
      osp$set_status_abnormal ('CL', cle$unexpected_call_to, 'clp$log_and_or_echo_command', status);
    ELSE
      status := local_status;
    IFEND;

  PROCEND clp$log_and_or_echo_command;
*IFEND
?? TITLE := 'clp$evaluate_parameters', EJECT ??
*copyc clh$evaluate_parameters

  PROCEDURE [XDCL, #GATE] clp$evaluate_parameters
    (    parameter_list: clt$parameter_list;
         parameter_description_table: ^clt$parameter_description_table;
         check_parameters_procedure: clt$check_parameters_procedure;
         parameter_value_table: ^clt$parameter_value_table;
     VAR status: ost$status);

    VAR
      command_reference_text: ^clt$command_line,
      edited_command: ^clt$command_line,
      evaluation_context: clt$parameter_eval_context,
      help_context: clt$parameter_help_context,
      ignore_status: ^ost$status,
      local_status: ost$status,
      parse: clt$parse_state,
      pdt: ^clt$unbundled_pdt,
      work_area_ptr: ^^clt$work_area;


    status.normal := TRUE;
    local_status.normal := TRUE;

  /evaluate/
    BEGIN
      clp$setup_parameter_evaluation (NIL, osc$null_name, TRUE, parse, work_area_ptr,
            evaluation_context, help_context, local_status);
      IF NOT local_status.normal THEN
        IF local_status.condition = cle$unexpected_call_to THEN
          local_status.text.size := 0;
          osp$append_status_parameter (osc$status_parameter_delimiter, 'clp$evaluate_parameters',
                local_status);
        IFEND;
        EXIT /evaluate/;
      IFEND;

      IF parse.text = NIL THEN
        command_reference_text := NIL;
      ELSE
        IF (evaluation_context.interpreter_mode = clc$interpret_mode) AND
              (evaluation_context.prompting_requested) THEN
          command_reference_text := ^parse.text^ (evaluation_context.command_or_function_source^.
                reference_index-1, evaluation_context.command_or_function_source^.reference_size+1);
        ELSE
          command_reference_text := ^parse.text^ (evaluation_context.command_or_function_source^.
                reference_index, evaluation_context.command_or_function_source^.reference_size);
        IFEND;
      IFEND;

      clp$get_parameter_list_parse (^parameter_list, work_area_ptr^, parse, local_status);
      IF NOT local_status.normal THEN
        EXIT /evaluate/;
      IFEND;

      NEXT pdt IN work_area_ptr^;
      clp$unbundle_pdt (parameter_description_table, work_area_ptr^, pdt^, local_status);
      IF NOT local_status.normal THEN
        EXIT /evaluate/;
      IFEND;

      IF evaluation_context.command_or_function <> pdt^.header^.command_or_function THEN
        osp$set_status_condition (cle$pdt_processor_mismatch, local_status);
        EXIT /evaluate/;
      IFEND;

      IF (evaluation_context.interpreter_mode = clc$help_mode) AND (help_context.help_output_file <> NIL) THEN
*IF NOT $true(osv$unix)
        clp$display_cmnd_or_func_info (fsc$list, help_context, evaluation_context.command_or_function_source^,
              evaluation_context.command_or_function_name, pdt^, local_status);
*ELSE
        clp$display_cmnd_or_func_info (fsc$legible_data, help_context,
              evaluation_context.command_or_function_source^,
              evaluation_context.command_or_function_name, pdt^, local_status);
*IFEND
        IF local_status.normal THEN
          osp$set_status_condition (cle$parameters_displayed, local_status);
        IFEND;
        EXIT /evaluate/;
      IFEND;

      clp$internal_evaluate_params (evaluation_context, pdt^, check_parameters_procedure, parse,
            work_area_ptr^, parameter_value_table, local_status);
      IF (NOT local_status.normal) AND (local_status.condition = cle$bad_pvt) THEN
        EXIT /evaluate/;
      IFEND;

      IF NOT (evaluation_context.command_logging_completed AND evaluation_context.command_echoing_completed)
            THEN
*IF NOT $true(osv$unix)
        clp$prepare_for_log_and_or_echo (command_reference_text, pdt, parameter_value_table, work_area_ptr^,
                edited_command);
        PUSH ignore_status;
        IF NOT evaluation_context.command_logging_completed THEN
          clp$log_command_line (edited_command^, ignore_status^);
        IFEND;
        IF NOT evaluation_context.command_echoing_completed THEN
          clp$echo_command (evaluation_context.interpreter_mode, edited_command^, ignore_status^);
        IFEND;
*IFEND
      IFEND;

      clp$save_evaluated_parameters (pdt, parameter_value_table, FALSE, work_area_ptr^, local_status);
    END /evaluate/;

    IF local_status.normal THEN
      status.normal := TRUE;
    ELSE
      status := local_status;
    IFEND;

  PROCEND clp$evaluate_parameters;
*IF NOT $true(osv$unix)
?? TITLE := 'clp$prepare_for_log_and_or_echo', EJECT ??

  PROCEDURE [XDCL] clp$prepare_for_log_and_or_echo
    (    command_reference_text: ^clt$command_line;
         pdt: ^clt$unbundled_pdt;
         pvt: ^clt$parameter_value_table;
     VAR work_area {input, output} : ^clt$work_area;
     VAR edited_command: ^clt$command_line);

    VAR
      representation: ^clt$data_representation,
      request: clt$convert_to_string_request,
      status: ost$status;


    edited_command := command_reference_text;

    request.initial_indentation := 0;
    request.continuation_indentation := 0;
    request.max_string := clc$max_command_line_size;
    request.include_advanced_items := TRUE;
    request.include_hidden_items := TRUE;
    request.kind := clc$convert_parameters;
    request.initial_text := command_reference_text;
    request.include_secure_parameters := FALSE;
    request.evaluated_pdt := pdt;
    request.evaluated_pvt := pvt;
    request.parameter_substitutions := NIL;

    clp$internal_convert_to_string (request, work_area, representation, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    edited_command := clp$data_representation_text (representation);

  PROCEND clp$prepare_for_log_and_or_echo;
*IFEND
?? TITLE := 'clp$get_parameter_number', EJECT ??
*copyc clh$get_parameter_number

  PROCEDURE [XDCL, #GATE] clp$get_parameter_number
    (    parameter_description_table: ^clt$parameter_description_table;
         parameter_name: clt$parameter_reference;
     VAR parameter_number: clt$parameter_number;
     VAR status: ost$status);

    VAR
      found: boolean,
      header: ^clt$pdt_header,
      index: clt$parameter_name_index,
      names: ^clt$pdt_parameter_names,
      pdt_area: ^clt$parameter_description_table,
      translated_name: clt$parameter_name;


    status.normal := TRUE;

  /get_parameter_number/
    BEGIN
      pdt_area := parameter_description_table;
      NEXT header IN pdt_area;
      IF header = NIL THEN
        osp$set_status_condition (cle$bad_pdt, status);
        EXIT /get_parameter_number/;
      IFEND;

      IF header^.number_of_parameter_names = 0 THEN
        found := FALSE;
      ELSE
        NEXT names: [1 .. header^.number_of_parameter_names] IN pdt_area;
        IF names = NIL THEN
          osp$set_status_condition (cle$bad_pdt, status);
          EXIT /get_parameter_number/;
        IFEND;
        #TRANSLATE (osv$lower_to_upper, parameter_name, translated_name);
        clp$search_parameter_names (translated_name, names, index, found);
      IFEND;

      IF NOT found THEN
        osp$set_status_abnormal ('CL', cle$unknown_parameter_name, parameter_name, status);
        EXIT /get_parameter_number/;
      IFEND;

      IF (names^ [index].position < 1) OR (names^ [index].position > header^.number_of_parameters) THEN
        osp$set_status_condition (cle$bad_pdt, status);
        EXIT /get_parameter_number/;
      IFEND;

      parameter_number := names^ [index].position;
    END /get_parameter_number/;

  PROCEND clp$get_parameter_number;
*IF NOT $true(osv$unix)
?? TITLE := 'clp$push_parameters', EJECT ??
*copyc clh$push_parameters

  PROCEDURE [XDCL, #GATE] clp$push_parameters
    (VAR status: ost$status);


    status.normal := TRUE;
    clp$push_sub_parameters_block (TRUE);

  PROCEND clp$push_parameters;
?? TITLE := 'clp$pop_parameters', EJECT ??
*copyc clh$pop_parameters

  PROCEDURE [XDCL, #GATE] clp$pop_parameters
    (VAR status: ost$status);

    VAR
      block: ^clt$block;


    status.normal := TRUE;
    clp$find_current_block (block);
    IF block^.kind <> clc$sub_parameters_block THEN
      osp$set_status_abnormal ('CL', cle$unexpected_call_to, 'clp$pop_parameters', status);
    ELSE
      clp$pop_block_stack (block);
    IFEND;

  PROCEND clp$pop_parameters;
?? TITLE := 'clp$evaluate_sub_parameters', EJECT ??
*copyc clh$evaluate_sub_parameters

  PROCEDURE [XDCL, #GATE] clp$evaluate_sub_parameters
    (    parameter_list_text: clt$parameter_list_text;
         parameter_description_table: ^clt$parameter_description_table;
     VAR work_area {input, output} : ^clt$work_area;
         parameter_value_table: ^clt$parameter_value_table;
     VAR status: ost$status);

    VAR
      i: clt$parameter_number,
      lexical_units: ^clt$lexical_units,
      local_status: ost$status,
      local_work_area: ^^clt$work_area,
      local_value: ^clt$data_value,
      local_variable: ^clt$variable_ref_expression,
      original_local_work_area: ^clt$work_area,
      parse: clt$parse_state;


    status.normal := TRUE;
    local_status.normal := TRUE;

  /evaluate/
    BEGIN
*IF NOT $true(osv$unix)
      clp$get_work_area (#RING (^local_work_area), local_work_area, local_status);
*ELSE
      clp$get_work_area (osc$user_ring, local_work_area, local_status);
*IFEND
      IF NOT local_status.normal THEN
        EXIT /evaluate/;
      IFEND;
      original_local_work_area := local_work_area^;

      clp$identify_lexical_units (^parameter_list_text, local_work_area^, lexical_units, local_status);
      IF NOT local_status.normal THEN
        EXIT /evaluate/;
      IFEND;
      clp$initialize_parse_state (^parameter_list_text, lexical_units, parse);
      clp$scan_non_space_lexical_unit (parse);

      clp$internal_evaluate_sub_param (parse, parameter_description_table, local_work_area^,
            parameter_value_table, local_status);
      IF NOT local_status.normal THEN
        EXIT /evaluate/;
      IFEND;

*IF NOT $true(osv$unix)
      IF #SEGMENT (work_area) = #SEGMENT (local_work_area^) THEN
*ELSE
      IF #LOC (work_area^) = #LOC (local_work_area^^) THEN
*IFEND
        EXIT /evaluate/;
      IFEND;

    /copy_values/
      FOR i := 1 TO UPPERBOUND (parameter_value_table^) DO
        IF parameter_value_table^ [i].passing_method = clc$pass_by_value THEN
          local_value := parameter_value_table^ [i].value;
          IF local_value <> NIL THEN
            clp$copy_data_value (local_value, work_area, parameter_value_table^ [i].value, local_status);
            IF NOT local_status.normal THEN
              EXIT /copy_values/;
            IFEND;
          IFEND;
        ELSE {clc$pass_by_reference }
          local_variable := parameter_value_table^ [i].variable;
          IF local_variable <> NIL THEN
            NEXT parameter_value_table^ [i].variable: [STRLENGTH (local_variable^)] IN work_area;
            IF parameter_value_table^ [i].variable = NIL THEN
              osp$set_status_condition (cle$work_area_overflow, local_status);
              EXIT /copy_values/;
            IFEND;
            parameter_value_table^ [i].variable^ := local_variable^;
          IFEND;
        IFEND;
      FOREND /copy_values/;

      local_work_area^ := original_local_work_area;
    END /evaluate/;

    IF NOT local_status.normal THEN
      IF local_status.condition = cle$work_area_overflow THEN
        local_status.text.size := 0;
        osp$append_status_parameter (osc$status_parameter_delimiter, 'clp$evaluate_sub_parameters',
              local_status);
      IFEND;
      status := local_status;
    IFEND;

  PROCEND clp$evaluate_sub_parameters;
?? TITLE := 'clp$internal_evaluate_sub_param', EJECT ??

  PROCEDURE [XDCL, #GATE] clp$internal_evaluate_sub_param
    (VAR parse {input, output} : clt$parse_state;
         parameter_description_table: ^clt$parameter_description_table;
     VAR work_area {input, output} : ^clt$work_area;
         parameter_value_table: ^clt$parameter_value_table;
     VAR status: ost$status);

    VAR
      evaluation_context: clt$parameter_eval_context,
      pdt: clt$unbundled_pdt;


    clp$unbundle_pdt (parameter_description_table, work_area, pdt, status);
    IF NOT status.normal THEN
      RETURN;
    ELSEIF pdt.header^.number_of_var_parameters > 0 THEN
      osp$set_status_condition (cle$var_sub_params_not_allowed, status);
      RETURN;
    IFEND;

    evaluation_context.interpreter_mode := clc$interpret_mode;
    evaluation_context.interactive_origin := FALSE;
    evaluation_context.interaction_style := osc$line_interaction;
    evaluation_context.prompting_requested := FALSE;
    evaluation_context.command_or_function_name := osc$null_name;
    evaluation_context.command_or_function := clc$command;
    evaluation_context.procedure_parameters := FALSE;
    evaluation_context.command_logging_completed := TRUE;
    evaluation_context.command_echoing_completed := TRUE;

    clp$internal_evaluate_params (evaluation_context, pdt, NIL, parse, work_area, parameter_value_table,
          status);

  PROCEND clp$internal_evaluate_sub_param;
*IFEND
?? TITLE := 'clp$internal_evaluate_params', EJECT ??

  PROCEDURE [XDCL] clp$internal_evaluate_params
    (    evaluation_context: clt$parameter_eval_context;
         pdt: clt$unbundled_pdt;
         check_parameters_procedure: clt$check_parameters_procedure;
     VAR parse {input, output} : clt$parse_state;
     VAR work_area {input, output} : ^clt$work_area;
         pvt: ^clt$parameter_value_table;
     VAR status: ost$status);

    CONST
      clc$escape_prefix = '/',
      clc$help_request = '?',
      clc$terminator_suffix = ';';

    TYPE
      clt$dialog_control = record
        prompted_for_parameter: ^array [1 .. * ] of boolean,
        parameters_to_prompt_for: boolean,
        activated: boolean,
        command_or_function_name: clt$command_name,
        cancelled_status_code: ost$status_condition_code,
        searched_for_help_module: boolean,
        help_module: ^ost$help_module,
        online_manual_name: ost$online_manual_name,
        default_help_module: ^ost$help_module,
        open: boolean,
        case interaction_style: ost$interaction_style of
        = osc$line_interaction =
          reply_parse: clt$parse_state,
          null_reply: boolean,
          terminator_in_reply: boolean,
          output_file_id: amt$file_identifier,
          page_width: ost$max_status_message_line,
          prompting_for_advanced_params: boolean,
        = osc$screen_interaction =
          ,
        = osc$desktop_interaction =
          ,
        casend,
      recend;

    VAR
      check_procedure_called: boolean,
      dialog_control: clt$dialog_control,
      general_param_checks_performed: boolean,
      ignore_terminate_breaks: boolean,
      ignore_status: ost$status,
      parameter_defaults_evaluated: boolean,
      prompt_for_all_parameters: boolean,
      required_parameters_checked: boolean,
      save_source_of_expressions: boolean;

*IF NOT $true(osv$unix)
?? NEWTITLE := 'abort_handler', EJECT ??

    PROCEDURE abort_handler
      (    condition: pmt$condition;
           condition_information: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);


      CASE condition.selector OF

      = pmc$block_exit_processing =
        close_dialog;
        RETURN;

      = ifc$interactive_condition =
        IF (condition.interactive_condition = ifc$terminate_break) AND ignore_terminate_breaks THEN
          RETURN;
        IFEND;

      ELSE
        ;
      CASEND;

      pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);

    PROCEND abort_handler;
*IFEND
?? TITLE := 'check_reply_for_name', EJECT ??

    PROCEDURE check_reply_for_name
      (VAR name: ost$name;
       VAR local_status: ost$status);


      local_status.normal := TRUE;

      clp$scan_non_space_lexical_unit (dialog_control.reply_parse);
      CASE dialog_control.reply_parse.unit.kind OF

      = clc$lex_name =
        #TRANSLATE (osv$lower_to_upper, dialog_control.reply_parse.
              text^ (dialog_control.reply_parse.unit_index, dialog_control.reply_parse.unit.size), name);
        clp$scan_non_space_lexical_unit (dialog_control.reply_parse);
        IF dialog_control.reply_parse.unit_index >= dialog_control.reply_parse.index_limit THEN
          RETURN;
        IFEND;

      = clc$lex_long_name =
        osp$set_status_abnormal ('CL', cle$name_too_long, dialog_control.reply_parse.
              text^ (dialog_control.reply_parse.unit_index, dialog_control.reply_parse.unit.size),
              local_status);
        RETURN;

      ELSE
        ;
      CASEND;

      osp$set_status_abnormal ('CL', cle$improper_name, dialog_control.reply_parse.
            text^ (1, dialog_control.reply_parse.index_limit - 1), local_status);

    PROCEND check_reply_for_name;
?? TITLE := 'check_required_parameters_given', EJECT ??

    PROCEDURE check_required_parameters_given
      (VAR which_parameter: clt$which_parameter;
       VAR local_status: ost$status);

      VAR
        parameter_number: clt$parameter_number;

*IF NOT $true(osv$unix)
?? NEWTITLE := 'prompt_for_required_parameter', EJECT ??

      PROCEDURE [INLINE] prompt_for_required_parameter;

        VAR
          message: ost$status_message,
          which_parameter: clt$which_parameter;


        open_line_style_dialog;
        get_parameter_prompt (parameter_number, dialog_control.page_width, message);
        REPEAT
          which_parameter.specific := TRUE;
          which_parameter.number := parameter_number;
          put_prompt_and_get_reply (message, which_parameter);
          dialog_control.prompted_for_parameter^ [parameter_number] := TRUE;
          IF NOT dialog_control.null_reply THEN
            evaluate_nested_parameters (parameter_number);
          IFEND;
        UNTIL pvt^ [parameter_number].specified;

      PROCEND prompt_for_required_parameter;
?? OLDTITLE, EJECT ??
*IFEND

      local_status.normal := TRUE;

      FOR parameter_number := 1 TO pdt.header^.number_of_parameters DO
        IF (NOT pvt^ [parameter_number].specified) AND (pdt.parameters^ [parameter_number].requirement =
              clc$required_parameter) THEN

*IF NOT $true(osv$unix)
          IF (NOT dialog_control.activated) OR (dialog_control.interaction_style <> osc$line_interaction) THEN
*IFEND
            which_parameter.specific := TRUE;
            which_parameter.number := parameter_number;
            osp$set_status_abnormal ('CL', cle$required_parameter_omitted, pdt.
                  names^ [pdt.parameters^ [parameter_number].name_index].name, local_status);
            RETURN;
*IF NOT $true(osv$unix)
          IFEND;
          REPEAT
            prompt_for_required_parameter;
          UNTIL pvt^ [parameter_number].specified;
*IFEND

        IFEND;
      FOREND;

      required_parameters_checked := TRUE;

    PROCEND check_required_parameters_given;
*IF NOT $true(osv$unix)
?? TITLE := 'close_dialog', EJECT ??

    PROCEDURE [INLINE] close_dialog;


      IF NOT dialog_control.open THEN
        RETURN;
      IFEND;

      clp$pop_interactive_input (ignore_status);

      dialog_control.open := FALSE;

    PROCEND close_dialog;
?? TITLE := 'convert_name_to_message_param', EJECT ??

    PROCEDURE [INLINE] convert_name_to_message_param
      (VAR name {input, output} : ost$name);

      VAR
        i: 1 .. osc$max_name_size,
        new_word: boolean;


      new_word := TRUE;
      FOR i := 1 TO osc$max_name_size DO
        IF name (i) = ' ' THEN
          RETURN;
        ELSEIF name (i) = '_' THEN
          name (i) := ' ';
          new_word := TRUE;
        ELSEIF new_word THEN
          new_word := FALSE;
        ELSE
          name (i) := osv$upper_to_lower ($INTEGER (name (i)) + 1);
        IFEND;
      FOREND;

    PROCEND convert_name_to_message_param;
*IFEND
?? TITLE := 'evaluate_nested_parameters', EJECT ??

    PROCEDURE evaluate_nested_parameters
      (    first_parameter_number: clt$parameter_number);

      VAR
        local_status: ost$status,
        parse: clt$parse_state;


      local_status.normal := TRUE;

      parse := dialog_control.reply_parse;
      PUSH parse.text: [STRLENGTH (dialog_control.reply_parse.text^)];
      parse.text^ := dialog_control.reply_parse.text^;
      PUSH parse.units_array: [1 .. UPPERBOUND (dialog_control.reply_parse.units_array^)];
      parse.units_array^ := dialog_control.reply_parse.units_array^;

      clp$scan_non_space_lexical_unit (parse);

      evaluate_parameters (FALSE, first_parameter_number, parse, local_status);
*IF NOT $true(osv$unix)
      IF NOT local_status.normal THEN
        put_status (local_status);
      IFEND;
*IFEND

    PROCEND evaluate_nested_parameters;
?? TITLE := 'evaluate_parameters', EJECT ??

    PROCEDURE evaluate_parameters
      (    original_parameters: boolean;
           first_parameter_number: clt$parameter_number;
       VAR parse {input, output} : clt$parse_state;
       VAR local_status: ost$status);

      VAR
        parameter_number: clt$parameter_index,
        error_found: boolean,
        evaluating_first_parameter: boolean;

?? NEWTITLE := 'evaluate_parameter', EJECT ??

      PROCEDURE evaluate_parameter;

        VAR
          expression_parse: clt$parse_state,
          expression_text: ^clt$expression_text,
          confirmed: boolean,
          list_rest_parameter: boolean,
          parameter_given_by_name: boolean,
          parameter_name: clt$parameter_name,
          which_parameter: clt$which_parameter;

*IF NOT $true(osv$unix)
?? NEWTITLE := 'confirm_parameter_name', EJECT ??

        PROCEDURE confirm_parameter_name;

          VAR
            message: ost$status_message;

?? NEWTITLE := 'get_confirm_param_name_prompt', EJECT ??

          PROCEDURE [INLINE] get_confirm_param_name_prompt;

            VAR
              message_parameters: array [1 .. 1] of ^ost$message_parameter,
              message_template: ^ost$message_template;


            find_default_help_module;

            osp$find_param_assist_prompt (dialog_control.default_help_module, clc$confirm_parameter_name,
                  message_template, ignore_status);

            message_parameters [1] := ^parameter_name;
            format_message (message_template, dialog_control.page_width, ^message_parameters, message);

          PROCEND get_confirm_param_name_prompt;
?? OLDTITLE, EJECT ??

          open_line_style_dialog;
          get_confirm_param_name_prompt;
          put_status (local_status);
          put_prompt_and_get_yn_reply (message, which_parameter, confirmed);

        PROCEND confirm_parameter_name;
*IFEND
?? TITLE := 'evaluate_parameter_name', EJECT ??

        PROCEDURE evaluate_parameter_name;

?? NEWTITLE := 'prompt_for_parameter_name', EJECT ??

          PROCEDURE prompt_for_parameter_name;

*IF NOT $true(osv$unix)
            VAR
              message: ost$status_message,
              message_template: ^ost$message_template,
              which_parameter: clt$which_parameter;


            open_line_style_dialog;

            find_default_help_module;
            osp$find_param_assist_prompt (dialog_control.default_help_module, clc$prompt_for_parameter_name,
                  message_template, ignore_status);
            format_message (message_template, dialog_control.page_width, NIL, message);

            REPEAT
              IF NOT local_status.normal THEN
                put_status (local_status);
              IFEND;
              which_parameter.specific := FALSE;
              put_prompt_and_get_reply (message, which_parameter);
              IF dialog_control.null_reply THEN
                local_status.normal := TRUE;
*IFEND
                EXIT evaluate_parameter;
*IF NOT $true(osv$unix)
              IFEND;
              check_reply_for_name (parameter_name, local_status);
            UNTIL local_status.normal;
*IFEND

          PROCEND prompt_for_parameter_name;
?? OLDTITLE, EJECT ??

          VAR
            name_is_parameter_name: boolean,
            parameter_name_index: clt$parameter_name_index;


          WHILE TRUE DO
            IF parameter_name <> '' THEN
              clp$search_parameter_names (parameter_name, pdt.names, parameter_name_index,
                    name_is_parameter_name);
              IF name_is_parameter_name THEN
                parameter_number := pdt.names^ [parameter_name_index].position;
                which_parameter.specific := TRUE;
                which_parameter.number := parameter_number;
                parameter_name := pdt.names^ [pdt.parameters^ [parameter_number].name_index].name;
                RETURN;
              IFEND;

              osp$set_status_abnormal ('CL', cle$unknown_parameter_name, parameter_name, local_status);
*IF NOT $true(osv$unix)
              IF (NOT dialog_control.activated) OR (dialog_control.interaction_style <> osc$line_interaction)
                    THEN
*IFEND
                EXIT evaluate_parameter;
*IF NOT $true(osv$unix)
              IFEND;
*IFEND
            IFEND;

            prompt_for_parameter_name;
          WHILEND;

        PROCEND evaluate_parameter_name;
*IF NOT $true(osv$unix)
?? TITLE := 'resolve_redundancy', EJECT ??

        PROCEDURE resolve_redundancy;

?? NEWTITLE := 'confirm_new_version', EJECT ??

          PROCEDURE confirm_new_version;

            VAR
              message: ost$status_message,
              message_template: ^ost$message_template;


            open_line_style_dialog;

            find_default_help_module;
            osp$find_param_assist_prompt (dialog_control.default_help_module, clc$confirm_new_param_version,
                  message_template, ignore_status);
            format_message (message_template, dialog_control.page_width, NIL, message);

            put_status (local_status);
            put_prompt_and_get_yn_reply (message, which_parameter, confirmed);
            confirmed := dialog_control.null_reply OR confirmed;

          PROCEND confirm_new_version;
?? OLDTITLE, EJECT ??

          confirm_new_version;

          IF confirmed THEN
            unspecify_parameter (parameter_number);

          ELSE
            local_status.normal := TRUE;
            parameter_name := '';
            evaluate_parameter_name;
          IFEND;

        PROCEND resolve_redundancy;
?? OLDTITLE, EJECT ??
*IFEND

        parameter_given_by_name := FALSE;
        IF (pdt.header^.command_or_function = clc$command) AND (parse.unit.kind = clc$lex_name) THEN
          expression_parse := parse;
          #TRANSLATE (osv$lower_to_upper, parse.text^ (parse.unit_index, parse.unit.size), parameter_name);
          clp$scan_non_space_lexical_unit (parse);
          IF parse.unit.kind <> clc$lex_equal THEN
            parse := expression_parse;
          ELSE
            clp$scan_non_space_lexical_unit (parse);
            parameter_given_by_name := TRUE;
          IFEND;
        IFEND;

        list_rest_parameter := (NOT parameter_given_by_name) AND
              (parameter_number <= pdt.header^.number_of_parameters) AND
              (pdt.type_descriptions^ [parameter_number].kind = clc$list_type) AND
              pdt.type_descriptions^ [parameter_number].list_rest;

        expression_parse := parse;
        REPEAT
          clp$scan_unnested_sep_lex_unit (clc$ignore_ellipsis, parse);
          expression_parse.index_limit := parse.unit_index;
        UNTIL (parse.unit_index >= parse.index_limit) OR (NOT list_rest_parameter);
        expression_text := ^expression_parse.text^ (expression_parse.unit_index,
              expression_parse.index_limit - expression_parse.unit_index);

        IF parameter_given_by_name THEN
          evaluate_parameter_name;

        ELSEIF parameter_number > pdt.header^.number_of_parameters THEN
          IF (NOT dialog_control.activated) OR (dialog_control.interaction_style <> osc$line_interaction) THEN
            osp$set_status_condition (cle$too_many_parameters, local_status);
            RETURN;
          IFEND;
          osp$set_status_abnormal ('CL', cle$value_given_positionally, expression_text^, local_status);
          parameter_name := '';
          evaluate_parameter_name;

        ELSE
          which_parameter.specific := TRUE;
          which_parameter.number := parameter_number;
          parameter_name := pdt.names^ [pdt.parameters^ [parameter_number].name_index].name;
          IF (NOT (clc$specify_positionally IN pdt.parameters^ [parameter_number].specification_methods)) AND
                (original_parameters OR (NOT evaluating_first_parameter)) THEN
            IF pdt.parameters^ [parameter_number].availability = clc$hidden_entry THEN
              osp$set_status_condition (cle$by_name_not_by_name, local_status);
              RETURN;
            ELSE
              osp$set_status_abnormal ('CL', cle$param_not_spec_by_name, parameter_name, local_status);
              osp$append_status_parameter (osc$status_parameter_delimiter, expression_text^, local_status);
            IFEND;
*IF NOT $true(osv$unix)
            IF (NOT dialog_control.activated) OR (dialog_control.interaction_style <> osc$line_interaction)
                  THEN
              RETURN;
            IFEND;
            confirm_parameter_name;
            local_status.normal := TRUE;
            IF dialog_control.null_reply THEN
              EXIT evaluate_parameter;
            ELSEIF NOT confirmed THEN
              parameter_name := '';
              evaluate_parameter_name;
            IFEND;
*ELSE
            RETURN;
*IFEND
          IFEND;
        IFEND;

        WHILE pvt^ [parameter_number].specified DO
          osp$set_status_abnormal ('CL', cle$doubly_defined_parameter, parameter_name, local_status);
*IF NOT $true(osv$unix)
          IF (NOT dialog_control.activated) OR (dialog_control.interaction_style <> osc$line_interaction) THEN
            RETURN;
          IFEND;
          resolve_redundancy;
*ELSE
          RETURN;
*IFEND
        WHILEND;

        evaluate_value (which_parameter, expression_parse, parse, pvt^ [parameter_number].specified,
              local_status);
*IF NOT $true(osv$unix)
        IF local_status.normal OR (NOT dialog_control.activated) OR
              (dialog_control.interaction_style <> osc$line_interaction) OR
              (pdt.parameters^ [parameter_number].availability = clc$hidden_entry) THEN
          RETURN;
        IFEND;

        prompt_for_correction (which_parameter, local_status);
        local_status.normal := TRUE;
*IFEND;

      PROCEND evaluate_parameter;
?? OLDTITLE, EJECT ??

      local_status.normal := TRUE;
      error_found := FALSE;
      parameter_number := first_parameter_number;
      evaluating_first_parameter := TRUE;

    /evaluate/
      WHILE TRUE DO
        CASE parse.unit.kind OF

        = clc$lex_end_of_line =
          EXIT /evaluate/;

        = clc$lex_semicolon =
          IF local_status.normal AND ((parse.unit_index < parse.index_limit) OR
                (original_parameters AND (pdt.header^.command_or_function = clc$function))) THEN
            osp$set_status_condition (cle$unexpected_in_param_list, local_status);
            clp$append_status_parse_state (osc$status_parameter_delimiter, parse, local_status);
            IF status.normal THEN
              status := local_status;
            IFEND;
          IFEND;
          clp$scan_non_space_lexical_unit (parse);
          EXIT /evaluate/;

        = clc$lex_right_parenthesis =
          IF local_status.normal AND ((parse.unit_index < parse.index_limit) OR (NOT original_parameters) OR
                (pdt.header^.command_or_function = clc$command)) THEN
            osp$set_status_condition (cle$unexpected_in_param_list, local_status);
            clp$append_status_parse_state (osc$status_parameter_delimiter, parse, local_status);
            IF status.normal THEN
              status := local_status;
            IFEND;
          IFEND;
          clp$scan_non_space_lexical_unit (parse);
          EXIT /evaluate/;

        = clc$lex_comma =
          evaluating_first_parameter := FALSE;
          REPEAT
            parameter_number := parameter_number + 1;
            clp$scan_non_space_lexical_unit (parse);
          UNTIL parse.unit.kind <> clc$lex_comma;

        ELSE
          evaluate_parameter;
          evaluating_first_parameter := FALSE;
          IF parse.unit_is_space THEN
            clp$scan_non_space_lexical_unit (parse);
          IFEND;
          IF parse.unit.kind = clc$lex_comma THEN
            clp$scan_non_space_lexical_unit (parse);
          IFEND;

          IF NOT local_status.normal THEN
            IF evaluation_context.interpreter_mode = clc$help_mode THEN
              local_status.normal := TRUE;
            ELSE
              IF status.normal THEN
                status := local_status;
              IFEND;
              error_found := TRUE;
            IFEND;
          IFEND;

          IF parameter_number <= pdt.header^.number_of_parameters THEN
            parameter_number := parameter_number + 1;
          IFEND;
        CASEND;
      WHILEND /evaluate/;

      IF error_found AND local_status.normal THEN
        local_status := status;
      IFEND;

    PROCEND evaluate_parameters;
?? TITLE := 'evaluate_parameter_defaults', EJECT ??

    PROCEDURE evaluate_parameter_defaults
      (VAR which_parameter: clt$which_parameter;
       VAR local_status: ost$status);

      VAR
        confirmed: boolean,
        parameter_number: clt$parameter_number;

*IF NOT $true(osv$unix)
?? NEWTITLE := 'confirm_default_value', EJECT ??

      PROCEDURE confirm_default_value;

        VAR
          message: ost$status_message;

?? NEWTITLE := 'get_confirm_default_prompt', EJECT ??

        PROCEDURE [INLINE] get_confirm_default_prompt;

          VAR
            message_parameters: array [1 .. 2] of ^ost$message_parameter,
            message_template: ^ost$message_template,
            parameter_name: clt$parameter_name,
            representation: ^clt$data_representation;


          find_default_help_module;

          osp$find_param_assist_prompt (dialog_control.default_help_module, clc$confirm_param_default_value,
                message_template, ignore_status);

          parameter_name := pdt.names^ [pdt.parameters^ [parameter_number].name_index].name;
          convert_name_to_message_param (parameter_name);
          message_parameters [1] := ^parameter_name;

          get_parameter_value_rep (parameter_number, dialog_control.page_width, representation, local_status);
          IF local_status.normal THEN
            message_parameters [2] := clp$data_representation_text (representation);
          ELSE
            message_parameters [2] := NIL;
            local_status.normal := TRUE;
          IFEND;

          format_message (message_template, dialog_control.page_width, ^message_parameters, message);

        PROCEND get_confirm_default_prompt;
?? OLDTITLE, EJECT ??

        open_line_style_dialog;
        get_confirm_default_prompt;
        put_prompt_and_get_yn_reply (message, which_parameter, confirmed);
        confirmed := dialog_control.null_reply OR confirmed;

      PROCEND confirm_default_value;
?? OLDTITLE, EJECT ??
*IFEND

      VAR
        default_value: ^clt$expression_text,
        default_value_from_name: ^clt$expression_text,
        default_value_specified: boolean,
        expression_parse: clt$parse_state,
        lexical_units: ^clt$lexical_units,
        parse: clt$parse_state,
        value_from_default_name: boolean;


      local_status.normal := TRUE;

      IF evaluation_context.interpreter_mode = clc$help_mode THEN
        parameter_defaults_evaluated := TRUE;
        RETURN;
      IFEND;

      FOR parameter_number := 1 TO pdt.header^.number_of_parameters DO
        IF (NOT pvt^ [parameter_number].specified) AND (pdt.parameters^ [parameter_number].requirement >=
              clc$optional_default_parameter) THEN
          which_parameter.specific := TRUE;
          which_parameter.number := parameter_number;

          get_parameter_default (parameter_number, default_value, value_from_default_name, local_status);
          IF NOT local_status.normal THEN
            RETURN;
          IFEND;

          IF value_from_default_name THEN
            default_value_from_name := default_value;
            PUSH default_value: [STRLENGTH (default_value_from_name^)];
            default_value^ := default_value_from_name^;
          IFEND;

          clp$identify_lexical_units (default_value, work_area, lexical_units, local_status);
          IF NOT local_status.normal THEN
            RETURN;
          IFEND;
          clp$initialize_parse_state (default_value, lexical_units, parse);
          clp$scan_non_space_lexical_unit (parse);
          expression_parse := parse;
          clp$scan_to_lexical_limit (parse);

          evaluate_value (which_parameter, expression_parse, parse, default_value_specified, local_status);
          IF NOT local_status.normal THEN
            RETURN;
          ELSEIF parse.unit.kind <> clc$lex_end_of_line THEN
            osp$set_status_abnormal ('CL', cle$expecting_default_term, pdt.
                  names^ [pdt.parameters^ [parameter_number].name_index].name, local_status);
            clp$append_status_parse_state (osc$status_parameter_delimiter, parse, local_status);
            RETURN;
          ELSEIF NOT default_value_specified THEN
            osp$set_status_abnormal ('CL', cle$defaulted_parameter_unspec, pdt.
                  names^ [pdt.parameters^ [parameter_number].name_index].name, local_status);
            RETURN;
*IF NOT $true(osv$unix)
          ELSEIF dialog_control.activated AND (dialog_control.interaction_style = osc$line_interaction) AND
                (pdt.parameters^ [parameter_number].requirement = clc$confirm_default_parameter) THEN
            confirm_default_value;
            IF NOT confirmed THEN
              local_status.normal := TRUE;
              prompt_for_correction (which_parameter, local_status);
              local_status.normal := TRUE;
            IFEND;
*IFEND
          IFEND;

        IFEND;
      FOREND;

      parameter_defaults_evaluated := TRUE;

    PROCEND evaluate_parameter_defaults;
?? TITLE := 'evaluate_value', EJECT ??

    PROCEDURE evaluate_value
      (    which_parameter: clt$which_parameter;
       VAR expression_parse {input} : clt$parse_state;
       VAR parse {input, output} : clt$parse_state;
       VAR parameter_specified: boolean;
       VAR status: ost$status);

      VAR
        bad_expression_text: ^clt$expression_text,
        expression_text: ^clt$expression_text,
        ignore_result_type_description: ^clt$type_description,
        parameter_passed: boolean;

?? NEWTITLE := 'save_parameter_value_source', EJECT ??

      PROCEDURE save_parameter_value_source;


        IF pvt^ [which_parameter.number].passing_method = clc$pass_by_value THEN
          clp$make_deferred_value (expression_text^, pdt.type_descriptions^ [which_parameter.number].
                specification, work_area, pvt^ [which_parameter.number].value);
          IF pvt^ [which_parameter.number].value = NIL THEN
            osp$set_status_condition (cle$work_area_overflow, status);
            EXIT clp$internal_evaluate_params;
          IFEND;

        ELSE
          NEXT pvt^ [which_parameter.number].variable: [STRLENGTH (expression_text^)] IN work_area;
          IF pvt^ [which_parameter.number].variable = NIL THEN
            osp$set_status_condition (cle$work_area_overflow, status);
            EXIT clp$internal_evaluate_params;
          IFEND;
          pvt^ [which_parameter.number].variable^ := expression_text^;
        IFEND;

        parameter_specified := TRUE;

      PROCEND save_parameter_value_source;
?? TITLE := 'pass_variable_parameter', EJECT ??

      PROCEDURE pass_variable_parameter;

        VAR
*IF NOT $true(osv$unix)
          access_handle: clt$variable_access_handle,
          access_variable_requests: clt$access_variable_requests,
          ignore_type_description: ^clt$type_description,
          i: 1 .. clc$max_union_members,
          found: boolean,
*IFEND
          name: clt$variable_name,
*IF NOT $true(osv$unix)
          variable_conforms: boolean,
          variable_information: clt$variable_information,
*IFEND
          variable_name: clt$variable_name;

        parameter_passed := TRUE;

        CASE expression_parse.unit.kind OF
        = clc$lex_name =
          ;
        = clc$lex_long_name =
          osp$set_status_abnormal ('CL', cle$name_too_long, expression_parse.
                text^ (expression_parse.unit_index, expression_parse.unit.size), status);
          RETURN;
        ELSE
          osp$set_status_abnormal ('CL', cle$expecting_var_for_param, pdt.
                names^ [pdt.parameters^ [which_parameter.number].name_index].name, status);
          clp$append_status_parse_state (osc$status_parameter_delimiter, expression_parse, status);
          RETURN;
        CASEND;

        #TRANSLATE (osv$lower_to_upper, expression_parse.text^
              (expression_parse.unit_index, expression_parse.unit.size), name);

        clp$scan_any_lexical_unit (expression_parse);
*IF NOT $true(osv$unix)
        access_variable_requests := $clt$access_variable_requests[clc$return_type_description,
              clc$return_value_qualifiers];
        clp$evaluate_name_for_write (name, access_variable_requests, TRUE, expression_parse, work_area,
              variable_name, variable_information, access_handle, ignore_type_description, found,
              status);
        IF NOT status.normal THEN
          RETURN;
        ELSEIF NOT found THEN
          osp$set_status_abnormal ('CL', cle$unknown_variable, variable_name, status);
          RETURN;
        ELSEIF variable_information.type_description = NIL THEN
          osp$set_status_abnormal ('CL', cle$indeterminate_param_var, variable_name, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, pdt.
                names^ [pdt.parameters^ [which_parameter.number].name_index].name, status);
          RETURN;
        ELSEIF (NOT variable_information.parameter_passed) AND variable_information.value_qualifiers_present
              THEN
          osp$set_status_abnormal ('CL', cle$omited_param_cant_have_qual, variable_name, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, pdt.
                names^ [pdt.parameters^ [which_parameter.number].name_index].name, status);
        IFEND;

        clp$validate_var_conformance (variable_information.type_description, ^pdt.
              type_descriptions^ [which_parameter.number], status);
        IF NOT status.normal THEN
          translate_status (pdt.names^ [pdt.parameters^ [which_parameter.number].name_index].name, status);
          RETURN;
        IFEND;

*ELSE
        variable_name := name;

*IFEND
        IF expression_parse.unit_index < expression_parse.index_limit THEN
          osp$set_status_condition (cle$expecting_end_of_expression, status);
          clp$append_status_parse_state (osc$status_parameter_delimiter, expression_parse, status);
          RETURN;
        IFEND;

*IF NOT $true(osv$unix)
        IF NOT variable_information.parameter_passed THEN

{ Passing an omitted parameter results in the receiving parameter being omitted.

          parameter_passed := FALSE;
          RETURN;
        IFEND;
*IFEND

*IF NOT $true(osv$unix)
        clp$produce_variable_ref_expr (variable_information.class, variable_name,
              variable_information.value_qualifiers, work_area, pvt^ [which_parameter.number].variable,
*ELSE
        clp$produce_variable_ref_expr (clc$param_variable, variable_name,
              NIL, work_area, pvt^ [which_parameter.number].variable,
*IFEND
              status);

*IF NOT $true(osv$unix)
        IF status.normal AND evaluation_context.procedure_parameters THEN
          clp$pass_variable_parameter (which_parameter.number, access_handle,
                variable_information.value_qualifiers, variable_name, work_area, status);
        IFEND;
*IFEND

      PROCEND pass_variable_parameter;
?? TITLE := 'translate_status', EJECT ??

      PROCEDURE [INLINE] translate_status
        (    parameter_name: ost$name;
         VAR status: {input, output} ost$status);


        CASE status.condition OF
        = cle$application_name_mismatch =
          status.condition := cle$p_application_name_mismatch;
        = cle$array_bounds_dont_match =
          status.condition := cle$p_array_bounds_dont_match;
        = cle$balance_brackets_dont_match =
          status.condition := cle$p_balance_brackets_mismatch;
        = cle$date_time_tenses_dont_match =
          status.condition := cle$p_date_time_tenses_mismatch;
        = cle$date_time_types_dont_match =
          status.condition := cle$p_date_time_types_mismatch;
        = cle$field_names_dont_match =
          status.condition := cle$p_field_names_dont_match;
        = cle$field_requirements_mismatch =
          status.condition := cle$p_field_requiremnt_mismatch;
        = cle$field_types_dont_match =
          status.condition := cle$p_field_types_dont_match;
        = cle$integer_radices_dont_match =
          status.condition := cle$p_integer_radices_mismatch;
        = cle$integer_ranges_dont_match =
          status.condition := cle$p_integer_ranges_dont_match;
        = cle$keywords_dont_match =
          status.condition := cle$p_keywords_dont_match;
        = cle$list_rest_doesnt_match =
          status.condition := cle$p_list_rest_doesnt_match;
        = cle$list_sizes_dont_match =
          status.condition := cle$p_list_sizes_dont_match;
        = cle$name_sizes_dont_match =
          status.condition := cle$p_name_sizes_dont_match;
        = cle$number_of_fields_dont_match =
          status.condition := cle$p_number_of_fields_mismatch;
        = cle$only_string_literal_allowed =
          status.condition := cle$only_string_literal_for_par;
        = cle$range_types_dont_match =
          status.condition := cle$p_range_types_dont_match;
        = cle$real_subranges_dont_match =
          status.condition := cle$p_real_subranges_dont_match;
        = cle$string_literals_dont_match =
          status.condition := cle$p_string_literals_mismatch;
        = cle$string_sizes_dont_match =
          status.condition := cle$p_string_sizes_dont_match;
        = cle$undefined_type =
          status.condition := cle$p_undefined_type;
        = cle$undefined_value =
          status.condition := cle$p_undefined_value;
        = cle$unexpected_oper_for_unspec =
          status.condition := cle$p_unexpect_oper_for_unspec;
        = cle$unknown_array_element_type =
          status.condition := cle$p_unknown_array_elem_type;
        = cle$unknown_keyword =
          status.condition := cle$unknown_parameter_keyword;
        = cle$unknown_list_element_type =
          status.condition := cle$p_unknown_list_element_type;
        = cle$unknown_range_element_type =
          status.condition := cle$p_unknown_range_elem_type;
        = cle$value_not_union_type =
          status.condition := cle$p_value_not_union_type;
        = cle$variable_not_union_type =
          ;
        = cle$wrong_kind_of_element_type =
          status.condition := cle$p_wrong_kind_of_elem_type;
        = cle$wrong_kind_of_value =
          status.condition := cle$wrong_kind_of_param_value;
        ELSE
          RETURN;
        CASEND;

        osp$append_status_parameter (osc$status_parameter_delimiter, parameter_name, status);

      PROCEND translate_status;
?? OLDTITLE, EJECT ??

      status.normal := TRUE;
      parameter_specified := FALSE;
      expression_text := ^expression_parse.text^ (expression_parse.unit_index,
            expression_parse.index_limit - expression_parse.unit_index);

      IF pdt.parameters^ [which_parameter.number].evaluation_method = clc$deferred_evaluation THEN
        save_parameter_value_source;

      ELSEIF pvt^ [which_parameter.number].passing_method = clc$pass_by_reference THEN
*IF $true(osv$unix)
        IF which_parameter.number = pdt.header^.status_parameter_number THEN
*IFEND
        pass_variable_parameter;
*IF NOT $true(osv$unix)
        IF parameter_passed THEN
          parameter_specified := status.normal OR (evaluation_context.interpreter_mode = clc$skip_mode) OR
              (NOT dialog_control.activated);
*ELSE
          parameter_specified := status.normal;
        ELSE
          osp$set_status_abnormal ('CL', cle$not_supported, 'VAR parameters are', status);
          parameter_specified := FALSE;
        IFEND;
*IFEND
*IF NOT $true(osv$unix)
        ELSE
          parameter_specified := FALSE;
        IFEND;
*IFEND
      ELSE
        clp$internal_evaluate_expr (expression_parse, ^pdt.type_descriptions^ [which_parameter.number],
              work_area, ignore_result_type_description, pvt^ [which_parameter.number].value, status);
        IF NOT status.normal THEN
          IF pdt.parameters^ [which_parameter.number].security = clc$secure_parameter THEN
            osp$set_status_abnormal ('CL', cle$secure_parameter_incorrect, pdt.
                  names^ [pdt.parameters^ [which_parameter.number].name_index].name, status);
          ELSEIF status.condition = cle$expression_not_union_type THEN
            IF status.text.size > 0 THEN
              PUSH bad_expression_text: [status.text.size - 1];
              bad_expression_text^ := status.text.value (2, status.text.size - 1);
            ELSE
              bad_expression_text := NIL;
            IFEND;
            osp$set_status_abnormal ('CL', cle$param_expr_not_union_type, pdt.
                  names^ [pdt.parameters^ [which_parameter.number].name_index].name, status);
            IF bad_expression_text <> NIL THEN
              osp$append_status_parameter (osc$status_parameter_delimiter, bad_expression_text^, status);
            IFEND;
          ELSE
            translate_status (pdt.names^ [pdt.parameters^ [which_parameter.number].name_index].name, status);
          IFEND;
        ELSEIF expression_parse.unit_index < expression_parse.index_limit THEN
          osp$set_status_condition (cle$expecting_end_of_expression, status);
          clp$append_status_parse_state (osc$status_parameter_delimiter, expression_parse, status);
        ELSEIF expression_parse.index_limit > parse.unit_index THEN
          parse := expression_parse;
        IFEND;

        IF NOT status.normal THEN
          CASE evaluation_context.interpreter_mode OF
          = clc$help_mode =
            save_parameter_value_source;
          = clc$skip_mode =

{  In interpret or skip mode, if we have a bad status we signal a bad, SPECIFIED
{  parameter by setting the value to NIL.

            pvt^ [which_parameter.number].value := NIL;
            parameter_specified := TRUE;
          ELSE {clc$interpret_mode}

{  If we are in interpret mode we want to indicate that the parameter was
{  specified ONLY if parameter prompting is turned off; otherwise, we want
{  to reprompt the user for a correct parameter.

            pvt^ [which_parameter.number].value := NIL;
            parameter_specified := NOT dialog_control.activated;
          CASEND;
        ELSEIF pvt^ [which_parameter.number].value^.kind = clc$unspecified THEN
          pvt^ [which_parameter.number].value := NIL;
          parameter_specified := FALSE;
        ELSE
          parameter_specified := pvt^ [which_parameter.number].value <> NIL;
        IFEND;
      IFEND;

*IF NOT $true(osv$unix)
      IF status.normal AND parameter_specified AND (check_parameters_procedure <> NIL) AND
            (pdt.parameters^ [which_parameter.number].checking_level = clc$extended_parameter_checking) THEN
        perform_parameter_checks (which_parameter, status);
      IFEND;
*IFEND

      IF ((NOT status.normal) AND (evaluation_context.interpreter_mode = clc$help_mode)) OR
            save_source_of_expressions THEN
        save_parameter_value_source;
      IFEND;

      CASE pdt.parameters^ [which_parameter.number].requirement OF
      = clc$required_parameter =
        required_parameters_checked := FALSE;
      = clc$optional_default_parameter, clc$confirm_default_parameter =
        parameter_defaults_evaluated := FALSE;
      ELSE
        ;
      CASEND;

      IF parameter_specified THEN
        general_param_checks_performed := FALSE;
      IFEND;

    PROCEND evaluate_value;
*IF NOT $true(osv$unix)
?? TITLE := 'explain_command_or_function', EJECT ??

    PROCEDURE explain_command_or_function
      (VAR explanation_available: boolean;
       VAR local_status: ost$status);

      CONST
        disable_echoing = FALSE,
        max_explain_command_size = 88;

      VAR
        explain_command: string (max_explain_command_size),
        explain_command_size: integer;


      local_status.normal := TRUE;
      explanation_available := FALSE;

      IF dialog_control.online_manual_name <> '' THEN
        STRINGREP (explain_command, explain_command_size, 'EXPLAIN SUBJECT=''',
              evaluation_context.command_or_function_name (1, clp$trimmed_string_size
              (evaluation_context.command_or_function_name)), ''' MANUAL=',
              dialog_control.online_manual_name);
        clp$include_line (explain_command (1, explain_command_size), disable_echoing, osc$null_name,
              local_status);
        explanation_available := local_status.normal;
      IFEND;

    PROCEND explain_command_or_function;
?? TITLE := 'find_default_help_module', EJECT ??

    PROCEDURE [INLINE] find_default_help_module;

      VAR
        ignore_natural_language: ost$natural_language,
        ignore_online_manual_name: ost$online_manual_name;


      IF dialog_control.default_help_module <> NIL THEN
        RETURN;
      IFEND;

      osp$find_help_module (clc$system_messages_module, dialog_control.default_help_module,
            ignore_online_manual_name, ignore_natural_language, ignore_status);

    PROCEND find_default_help_module;
?? TITLE := 'find_help_module', EJECT ??

    PROCEDURE [INLINE] find_help_module;

      VAR
        ignore_natural_language: ost$natural_language;


      IF dialog_control.searched_for_help_module THEN
        RETURN;
      IFEND;

      dialog_control.searched_for_help_module := TRUE;

      osp$find_help_module (pdt.header^.help_module_name, dialog_control.help_module,
            dialog_control.online_manual_name, ignore_natural_language, ignore_status);

    PROCEND find_help_module;
?? TITLE := 'format_message', EJECT ??

    PROCEDURE [INLINE] format_message
      (    message_template: ^ost$message_template;
           max_message_line: ost$max_status_message_line;
           message_parameters: ^ost$message_parameters;
       VAR message: ost$status_message);


      osp$format_help_message (message_template, message_parameters, max_message_line, message, status);
      IF NOT status.normal THEN
        EXIT clp$internal_evaluate_params;
      IFEND;

    PROCEND format_message;
*IFEND
?? TITLE := 'get_parameter_default', EJECT ??

    PROCEDURE [INLINE] get_parameter_default
      (    parameter_number: clt$parameter_number;
       VAR default_value: ^clt$expression_text;
       VAR value_from_default_name: boolean;
       VAR local_status: ost$status);

      VAR
*IF NOT $true(osv$unix)
        access_variable_requests: clt$access_variable_requests,
*IFEND
        default_name: clt$variable_name,
        default_name_parse: clt$parse_state,
        default_name_result: ^clt$data_value,
        default_name_text: ^clt$string_value,
*IF $true(osv$unix)
        env_name: ost_c_name,
        env_name_length: integer,
        env_value: ost_c_fixed_string,
        env_value_length: ost_c_integer,
*IFEND
        lexical_units: ^clt$lexical_units;


      local_status.normal := TRUE;
      value_from_default_name := FALSE;
      default_value := NIL;
      IF pdt.default_names = NIL THEN
        default_name := '';
      ELSE
        default_name := pdt.default_names^ [parameter_number]^;
      IFEND;

      IF default_name <> '' THEN
*IF $true(osv$unix)
        STRINGREP (env_name, env_name_length, default_name, $CHAR(0));
        env_name (4) := '_';
        clp_getenv (env_name, env_value, env_value_length);
        IF env_value_length > 0 THEN
          default_value := ^env_value (1, env_value_length);
          value_from_default_name := TRUE;
        IFEND;
*ELSE
        PUSH default_name_text: [0];
        clp$identify_lexical_units (default_name_text, work_area, lexical_units, local_status);
        IF NOT local_status.normal THEN
          RETURN;
        IFEND;
        clp$initialize_parse_state (default_name_text, lexical_units, default_name_parse);
        clp$scan_non_space_lexical_unit (default_name_parse);
        access_variable_requests := $clt$access_variable_requests[];
        clp$evaluate_name (default_name, access_variable_requests, default_name_parse, work_area,
              default_name_result, value_from_default_name, local_status);
        IF NOT local_status.normal THEN
          RETURN;
        IFEND;
        IF value_from_default_name THEN
          IF default_name_result^.kind <> clc$string THEN
            osp$set_status_abnormal ('CL', cle$default_name_not_string, default_name, local_status);
            osp$append_status_parameter (osc$status_parameter_delimiter, pdt.
                  names^ [pdt.parameters^ [parameter_number].name_index].name, local_status);
            RETURN;
          IFEND;
          default_value := default_name_result^.string_value;
        IFEND;
*IFEND
      IFEND;

      IF default_value = NIL THEN
        value_from_default_name := FALSE;
        default_value := pdt.default_values^ [parameter_number];
      IFEND;

      default_value := ^default_value^ (1, clp$trimmed_string_size (default_value^));


    PROCEND get_parameter_default;
*IF NOT $true(osv$unix)
?? TITLE := 'get_parameter_prompt', EJECT ??

    PROCEDURE [INLINE] get_parameter_prompt
      (    parameter_number: clt$parameter_number;
           max_message_line: ost$max_status_message_line;
       VAR message: ost$status_message);

      VAR
        message_parameters: array [1 .. 1] of ^ost$message_parameter,
        message_template: ^ost$message_template,
        parameter_name: clt$parameter_name;


      parameter_name := pdt.names^ [pdt.parameters^ [parameter_number].name_index].name;

    /find_parameter_prompt/
      BEGIN
        find_help_module;

        IF dialog_control.help_module <> NIL THEN
          osp$find_parameter_prompt (dialog_control.help_module, parameter_name, message_template,
                ignore_status);
          IF message_template <> NIL THEN
            EXIT /find_parameter_prompt/;
          IFEND;
        IFEND;

        find_default_help_module;

        osp$find_parameter_prompt (dialog_control.default_help_module, clc$default_parameter_prompt,
              message_template, ignore_status);
      END /find_parameter_prompt/;

      convert_name_to_message_param (parameter_name);
      message_parameters [1] := ^parameter_name;
      format_message (message_template, max_message_line, ^message_parameters, message);

    PROCEND get_parameter_prompt;
?? TITLE := 'get_parameter_value_rep', EJECT ??

    PROCEDURE [INLINE] get_parameter_value_rep
      (    parameter_number: clt$parameter_number;
           max_representation_line: clt$string_size;
       VAR representation: ^clt$data_representation;
       VAR local_status: ost$status);

      VAR
        request: clt$convert_to_string_request;


      local_status.normal := TRUE;

      request.initial_indentation := 0;
      request.continuation_indentation := 0;
      request.max_string := max_representation_line;
      request.include_advanced_items := TRUE;
      request.include_hidden_items := TRUE;
      request.kind := clc$convert_data_value;
      request.representation_option := clc$data_source_representation;
      IF pvt^ [parameter_number].passing_method = clc$pass_by_value THEN
        request.value := pvt^ [parameter_number].value;
      ELSE { pvt^ [parameter_number].passing_method = clc$pass_by_reference

{ Use "dummy" application value to get the variable reference in the desired format.

        PUSH request.value;
        request.value^.kind := clc$application;
        request.value^.application_value := pvt^ [parameter_number].variable;
      IFEND;

      clp$internal_convert_to_string (request, work_area, representation, local_status);

    PROCEND get_parameter_value_rep;
?? TITLE := 'initialize_dialog_control', EJECT ??

    PROCEDURE [INLINE] initialize_dialog_control;

      VAR
        p: clt$parameter_number,
        parameters_not_supplied_on_call: boolean;


      dialog_control.parameters_to_prompt_for := TRUE;

      determine_prompting_style (evaluation_context, dialog_control.activated,
            dialog_control.interaction_style, ignore_status);

      IF evaluation_context.command_or_function = clc$command THEN
        dialog_control.cancelled_status_code := cle$command_cancelled;
      ELSE
        dialog_control.cancelled_status_code := cle$function_cancelled;
      IFEND;

      dialog_control.searched_for_help_module := FALSE;
      dialog_control.help_module := NIL;
      dialog_control.online_manual_name := '';
      dialog_control.default_help_module := NIL;
      dialog_control.open := FALSE;

      FOR p := 1 TO pdt.header^.number_of_parameters DO
        dialog_control.prompted_for_parameter^ [p] := FALSE;
      FOREND;

      IF NOT dialog_control.activated THEN
        prompt_for_all_parameters := FALSE;
      ELSE
        parameters_not_supplied_on_call := parse.unit_index >= parse.index_limit;
        prompt_for_all_parameters := (evaluation_context.prompting_requested AND
              ((evaluation_context.command_or_function = clc$command) OR
              (evaluation_context.command_or_function_source = NIL))) OR
              ((pdt.header^.number_of_required_parameters > 0) AND parameters_not_supplied_on_call);
      IFEND;

    PROCEND initialize_dialog_control;
?? TITLE := 'initialize_line_style_dialog', EJECT ??

    PROCEDURE initialize_line_style_dialog;

      VAR
        file_attributes: array [1 .. 1] of amt$fetch_item,
        file_id: amt$file_identifier,
        ignore_last_line_of_message: ^ost$status_message_line,
        message: ost$status_message,
        message_name: ost$name,
        message_parameters: array [1 .. 1] of ^ost$message_parameter,
        message_template: ^ost$message_template;


      dialog_control.open := TRUE;
      dialog_control.null_reply := TRUE;
      dialog_control.terminator_in_reply := FALSE;
      dialog_control.prompting_for_advanced_params := FALSE;

      clp$get_system_file_id (clc$job_output, dialog_control.output_file_id, status);
      IF NOT status.normal THEN
        EXIT clp$internal_evaluate_params;
      IFEND;
      file_attributes [1].key := amc$page_width;
      amp$fetch (dialog_control.output_file_id, file_attributes, status);
      IF NOT status.normal THEN
        EXIT clp$internal_evaluate_params;
      IFEND;
      IF file_attributes [1].page_width < osc$min_status_message_line THEN
        dialog_control.page_width := osc$min_status_message_line;
      ELSEIF file_attributes [1].page_width > osc$max_status_message_line THEN
        dialog_control.page_width := osc$max_status_message_line;
      ELSE
        dialog_control.page_width := file_attributes [1].page_width;
      IFEND;

      clp$push_interactive_input (status);
      IF NOT status.normal THEN
        EXIT clp$internal_evaluate_params;
      IFEND;

      clp$set_prompting_input;

      IF dialog_control.parameters_to_prompt_for AND (NOT evaluation_context.prompting_requested) THEN
        IF prompt_for_all_parameters THEN
          IF evaluation_context.command_or_function = clc$command THEN
            message_name := clc$enter_command_params_msg;
          ELSE
            message_name := clc$enter_function_params_msg;
          IFEND;
        ELSE
          IF evaluation_context.command_or_function = clc$command THEN
            message_name := clc$correct_command_params_msg;
          ELSE
            message_name := clc$correct_function_params_msg;
          IFEND;
        IFEND;
        find_default_help_module;
        osp$find_param_assist_prompt (dialog_control.default_help_module, message_name, message_template,
              ignore_status);
        message_parameters [1] := ^evaluation_context.command_or_function_name;
        format_message (message_template, dialog_control.page_width, ^message_parameters, message);
        put_message (message, ignore_last_line_of_message);
      IFEND;

    PROCEND initialize_line_style_dialog;
*IFEND
?? TITLE := 'initialize_pvt', EJECT ??

    PROCEDURE [INLINE] initialize_pvt;

      VAR
        p: clt$parameter_number;


      FOR p := 1 TO pdt.header^.number_of_parameters DO
        pvt^ [p].specified := FALSE;
        pvt^ [p].passing_method := pdt.parameters^ [p].passing_method;
        IF pvt^ [p].passing_method = clc$pass_by_value THEN
          pvt^ [p].value := NIL;
        ELSE
          pvt^ [p].variable := NIL;
        IFEND;
      FOREND;

    PROCEND initialize_pvt;
*IF NOT $true(osv$unix)
?? TITLE := 'invoke_parameter_dialog_manager', EJECT ??

    PROCEDURE invoke_parameter_dialog_manager
      (    dialog_manager_name: pmt$program_name;
           load_from_system: boolean;
       VAR local_status: ost$status);

      VAR
        callers_save_area: ^ost$stack_frame_save_area,
        ignore_term_error_level: ost$status_severity,
        original_term_error_level: ost$status_severity;

?? NEWTITLE := 'abort_handler', EJECT ??

      PROCEDURE abort_handler
        (    condition: pmt$condition;
             ignore_info: ^pmt$condition_information;
             save_area: ^ost$stack_frame_save_area;
         VAR handler_status: ost$status);


        IF condition.selector = pmc$block_exit_processing THEN
          pmp$change_term_error_level (original_term_error_level, ignore_term_error_level, handler_status);
          handler_status.normal := TRUE;
          RETURN;
        IFEND;

        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);

      PROCEND abort_handler;
?? TITLE := 'invoke_condition_handler', EJECT ??

      PROCEDURE invoke_condition_handler
        (    condition: pmt$condition;
             ignore_info: ^pmt$condition_information;
             save_area: ^ost$stack_frame_save_area;
         VAR handler_status: ost$status);


        IF (condition.selector = pmc$system_conditions) AND
              (($pmt$system_conditions [pmc$instruction_specification, pmc$address_specification,
              pmc$access_violation, pmc$environment_specification, pmc$invalid_segment_ring_0,
              pmc$out_call_in_return] * condition.system_conditions) <> $pmt$system_conditions []) AND
              (save_area^.minimum_save_area.a2_previous_save_area = callers_save_area) THEN
          osp$set_status_condition (cle$unable_to_call_parm_dlg_mgr, local_status);
          EXIT invoke_parameter_dialog_manager;
        IFEND;

        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);

      PROCEND invoke_condition_handler;
?? TITLE := 'support_change_expression_save', EJECT ??

      PROCEDURE support_change_expression_save
        (    save_expression_source: boolean;
         VAR support_status: ost$status);


        status.normal := TRUE;

        save_source_of_expressions := save_expression_source;

      PROCEND support_change_expression_save;
?? TITLE := 'support_evaluate_parameter', EJECT ??

      PROCEDURE support_evaluate_parameter
        (    parameter_number: clt$parameter_number;
             text: clt$expression_text;
         VAR support_status: ost$status);

        VAR
          expression_parse: clt$parse_state,
          expression_text: ^clt$expression_text,
          ignore_parameter_specified: boolean,
          lexical_units: ^clt$lexical_units,
          parse: clt$parse_state,
          which_parameter: clt$which_parameter;


        support_status.normal := TRUE;

        unspecify_parameter (parameter_number);

        expression_text := ^text (1, clp$trimmed_string_size (text));
        clp$identify_lexical_units (expression_text, work_area, lexical_units, support_status);
        clp$initialize_parse_state (expression_text, lexical_units, parse);
        clp$scan_non_space_lexical_unit (parse);
        expression_parse := parse;
        clp$scan_to_lexical_limit (parse);

        which_parameter.specific := TRUE;
        which_parameter.number := parameter_number;
        evaluate_value (which_parameter, expression_parse, parse, pvt^ [parameter_number].specified,
              support_status);

      PROCEND support_evaluate_parameter;
?? TITLE := 'support_explain', EJECT ??

      PROCEDURE support_explain
        (VAR explanation_available: boolean;
         VAR support_status: ost$status);


        explain_command_or_function (explanation_available, support_status);

      PROCEND support_explain;
?? TITLE := 'support_get_all_names', EJECT ??

      PROCEDURE support_get_all_names
        (VAR names: ^array [1 .. * ] of clt$command_name;
         VAR support_status: ost$status);


        clp$get_all_cmnd_or_func_names (pdt.header^.command_or_function,
              evaluation_context.command_or_function_source^, evaluation_context.command_or_function_name,
              work_area, names, support_status);
        IF NOT support_status.normal THEN
          RETURN;
        IFEND;

        RESET work_area TO names;

      PROCEND support_get_all_names;
?? TITLE := 'support_get_all_parameter_specs', EJECT ??

      PROCEDURE support_get_all_parameter_specs
        (    include_advanced_items: boolean;
             max_representation_line: clt$string_size;
         VAR representation: ^clt$data_representation;
         VAR support_status: ost$status);

        VAR
          request: clt$convert_to_string_request;


        support_status.normal := TRUE;

        request.initial_indentation := 0;
        request.continuation_indentation := 6;
        request.max_string := max_representation_line;
        request.include_advanced_items := include_advanced_items;
        request.include_hidden_items := FALSE;
        request.kind := clc$convert_unbundled_pdt;
        request.multi_line_pdt_format := TRUE;
        request.parameter_starts_line := TRUE;
        request.individual_parameter := FALSE;
        request.individual_parameter_number := LOWERVALUE (clt$parameter_number);
        request.include_header := FALSE;
        request.command_or_function_name := evaluation_context.command_or_function_name;
        request.aliases := NIL;
        request.availability := clc$normal_usage_entry;
        request.command_or_function_scope := clc$xdcl_command_or_function;
        request.pdt := ^pdt;
        request.pvt := NIL;
        request.symbolic_pdt_qualifiers_area := NIL;
        request.include_implementation_info := FALSE;

        clp$internal_convert_to_string (request, work_area, representation, support_status);
        IF NOT support_status.normal THEN
          RETURN;
        IFEND;

        RESET work_area TO representation;

      PROCEND support_get_all_parameter_specs;
?? TITLE := 'support_get_brief_help', EJECT ??

      PROCEDURE support_get_brief_help
        (    max_message_line: ost$max_status_message_line;
         VAR message: ^ost$status_message;
         VAR support_status: ost$status);

        VAR
          message_template: ^ost$message_template;


        support_status.normal := TRUE;
        message := NIL;

        find_help_module;
        IF dialog_control.help_module <> NIL THEN
          osp$find_brief_help_message (dialog_control.help_module, message_template, ignore_status);
          IF message_template <> NIL THEN
            NEXT message IN work_area;
            IF message = NIL THEN
              osp$set_status_condition (cle$work_area_overflow, support_status);
              RETURN;
            IFEND;
            RESET message;
            format_message (message_template, max_message_line, NIL, message^);
            RESET work_area TO message;
          IFEND;
        IFEND;

      PROCEND support_get_brief_help;
?? TITLE := 'support_get_full_help', EJECT ??

      PROCEDURE support_get_full_help
        (    max_message_line: ost$max_status_message_line;
         VAR message: ^ost$status_message;
         VAR support_status: ost$status);

        VAR
          message_template: ^ost$message_template;


        support_status.normal := TRUE;
        message := NIL;

        find_help_module;
        IF dialog_control.help_module <> NIL THEN
          osp$find_full_help_message (dialog_control.help_module, message_template, ignore_status);
          IF message_template <> NIL THEN
            NEXT message IN work_area;
            IF message = NIL THEN
              osp$set_status_condition (cle$work_area_overflow, support_status);
              RETURN;
            IFEND;
            RESET message;
            format_message (message_template, max_message_line, NIL, message^);
            RESET work_area TO message;
          IFEND;
        IFEND;

      PROCEND support_get_full_help;
?? TITLE := 'support_get_param_assist_prompt', EJECT ??

      PROCEDURE support_get_param_assist_prompt
        (    parameter_number: clt$parameter_number;
             max_message_line: ost$max_status_message_line;
         VAR message: ^ost$status_message;
         VAR support_status: ost$status);

        VAR
          message_parameters: array [1 .. 1] of ^ost$message_parameter,
          message_template: ^ost$message_template,
          parameter_name: clt$parameter_name;


        support_status.normal := TRUE;
        message := NIL;

        find_help_module;
        IF dialog_control.help_module <> NIL THEN
          parameter_name := pdt.names^ [pdt.parameters^ [parameter_number].name_index].name;
          osp$find_param_assist_prompt (dialog_control.help_module, parameter_name, message_template,
                ignore_status);
          IF message_template <> NIL THEN
            convert_name_to_message_param (parameter_name);
            message_parameters [1] := ^parameter_name;
            NEXT message IN work_area;
            IF message = NIL THEN
              osp$set_status_condition (cle$work_area_overflow, support_status);
              RETURN;
            IFEND;
            RESET message;
            format_message (message_template, max_message_line, ^message_parameters, message^);
            RESET work_area TO message;
          IFEND;
        IFEND;

      PROCEND support_get_param_assist_prompt;
?? TITLE := 'support_get_parameter_default', EJECT ??

      PROCEDURE support_get_parameter_default
        (    parameter_number: clt$parameter_number;
         VAR text: ^clt$expression_text;
         VAR support_status: ost$status);

        VAR
          ignore_value_from_default_name: boolean;


        get_parameter_default (parameter_number, text, ignore_value_from_default_name, support_status);

      PROCEND support_get_parameter_default;
?? TITLE := 'support_get_parameter_help', EJECT ??

      PROCEDURE support_get_parameter_help
        (    parameter_number: clt$parameter_number;
             max_message_line: ost$max_status_message_line;
         VAR message: ^ost$status_message;
         VAR support_status: ost$status);

        VAR
          message_parameters: array [1 .. 1] of ^ost$message_parameter,
          message_template: ^ost$message_template,
          parameter_name: clt$parameter_name;


        support_status.normal := TRUE;
        message := NIL;

        find_help_module;
        IF dialog_control.help_module <> NIL THEN
          parameter_name := pdt.names^ [pdt.parameters^ [parameter_number].name_index].name;
          osp$find_parameter_help_message (dialog_control.help_module, parameter_name, message_template,
                ignore_status);
          IF message_template <> NIL THEN
            convert_name_to_message_param (parameter_name);
            message_parameters [1] := ^parameter_name;
            NEXT message IN work_area;
            IF message = NIL THEN
              osp$set_status_condition (cle$work_area_overflow, support_status);
              RETURN;
            IFEND;
            RESET message;
            format_message (message_template, max_message_line, ^message_parameters, message^);
            RESET work_area TO message;
          IFEND;
        IFEND;

      PROCEND support_get_parameter_help;
?? TITLE := 'support_get_parameter_prompt', EJECT ??

      PROCEDURE support_get_parameter_prompt
        (    parameter_number: clt$parameter_number;
             max_message_line: ost$max_status_message_line;
         VAR message: ^ost$status_message;
         VAR support_status: ost$status);


        support_status.normal := TRUE;

        NEXT message IN work_area;
        IF message = NIL THEN
          osp$set_status_condition (cle$work_area_overflow, support_status);
          RETURN;
        IFEND;
        RESET message;
        get_parameter_prompt (parameter_number, max_message_line, message^);
        RESET work_area TO message;

      PROCEND support_get_parameter_prompt;
?? TITLE := 'support_get_parameter_spec', EJECT ??

      PROCEDURE support_get_parameter_spec
        (    parameter_number: clt$parameter_number;
             include_advanced_keywords: boolean;
             max_representation_line: clt$string_size;
         VAR representation: ^clt$data_representation;
         VAR support_status: ost$status);

        VAR
          request: clt$convert_to_string_request;


        support_status.normal := TRUE;

        request.initial_indentation := 0;
        request.continuation_indentation := 6;
        request.max_string := max_representation_line;
        request.include_advanced_items := include_advanced_keywords;
        request.include_hidden_items := FALSE;
        request.kind := clc$convert_unbundled_pdt;
        request.multi_line_pdt_format := TRUE;
        request.parameter_starts_line := TRUE;
        request.individual_parameter := TRUE;
        request.individual_parameter_number := parameter_number;
        request.include_header := FALSE;
        request.command_or_function_name := evaluation_context.command_or_function_name;
        request.aliases := NIL;
        request.availability := clc$normal_usage_entry;
        request.command_or_function_scope := clc$xdcl_command_or_function;
        request.pdt := ^pdt;
        request.pvt := NIL;
        request.symbolic_pdt_qualifiers_area := NIL;
        request.include_implementation_info := FALSE;

        clp$internal_convert_to_string (request, work_area, representation, support_status);
        IF NOT support_status.normal THEN
          RETURN;
        IFEND;

        RESET work_area TO representation;

      PROCEND support_get_parameter_spec;
?? TITLE := 'support_get_parameter_value', EJECT ??

      PROCEDURE support_get_parameter_value
        (    parameter_number: clt$parameter_number;
         VAR value: clt$parameter_value;
         VAR support_status: ost$status);


        support_status.normal := TRUE;

        value := pvt^ [parameter_number];

      PROCEND support_get_parameter_value;
?? TITLE := 'support_get_param_value_source', EJECT ??

      PROCEDURE support_get_param_value_source
        (    parameter_number: clt$parameter_number;
             max_representation_line: clt$string_size;
         VAR representation: ^clt$data_representation;
         VAR support_status: ost$status);


        get_parameter_value_rep (parameter_number, max_representation_line, representation, support_status);
        IF NOT support_status.normal THEN
          RETURN;
        IFEND;

        RESET work_area TO representation;

      PROCEND support_get_param_value_source;
?? TITLE := 'support_get_source', EJECT ??

      PROCEDURE support_get_source
        (VAR source_string: fst$path;
         VAR source_string_size: fst$path_size;
         VAR support_status: ost$status);


        clp$get_cmnd_or_func_source_str (evaluation_context.command_or_function_source^, source_string,
              source_string_size, support_status);

      PROCEND support_get_source;
?? TITLE := 'support_nested_dialog', EJECT ??

      PROCEDURE support_nested_dialog
        (    text: clt$expression_text;
             dialog_pdt: clt$unbundled_pdt;
             dialog_title: clt$string_value;
             max_representation_line: clt$string_size;
         VAR representation: ^clt$data_representation;
         VAR support_status: ost$status);

        VAR
          dialog_evaluation_context: clt$parameter_eval_context,
          dialog_pvt: ^clt$parameter_value_table,
          lexical_units: ^clt$lexical_units,
          original_work_area: ^clt$work_area,
          parameters_parse: clt$parse_state,
          parameters_text: ^clt$expression_text,
          parse: clt$parse_state,
          request: clt$convert_to_string_request;


        support_status.normal := TRUE;
        original_work_area := work_area;

        parameters_text := ^text (1, clp$trimmed_string_size (text));
        clp$identify_lexical_units (parameters_text, work_area, lexical_units, support_status);
        clp$initialize_parse_state (parameters_text, lexical_units, parse);
        clp$scan_non_space_lexical_unit (parse);
        parameters_parse := parse;
        IF parse.unit.kind = clc$lex_left_parenthesis THEN
          clp$scan_bal_paren_lexical_unit (parse);
          parameters_parse.index_limit := parse.unit_index;
          clp$scan_non_space_lexical_unit (parameters_parse);
        IFEND;

        PUSH dialog_pvt: [1 .. dialog_pdt.header^.number_of_parameters];

        dialog_evaluation_context.interpreter_mode := clc$interpret_mode;
        dialog_evaluation_context.interactive_origin := TRUE;
        dialog_evaluation_context.interaction_style := dialog_control.interaction_style;
        dialog_evaluation_context.prompting_requested := TRUE;
        dialog_evaluation_context.command_or_function_name := dialog_title;
        dialog_evaluation_context.command_or_function := clc$function;
        dialog_evaluation_context.procedure_parameters := FALSE;
        dialog_evaluation_context.command_or_function_source := NIL;

        clp$internal_evaluate_params (dialog_evaluation_context, dialog_pdt, NIL, parameters_parse, work_area,
              dialog_pvt, support_status);
        IF NOT support_status.normal THEN
          work_area := original_work_area;
          RETURN;
        IFEND;

        request.initial_indentation := 0;
        request.continuation_indentation := 6;
        request.max_string := max_representation_line;
        request.include_advanced_items := TRUE;
        request.include_hidden_items := TRUE;
        request.kind := clc$convert_parameters;
        request.initial_text := NIL;
        request.include_secure_parameters := TRUE;
        request.evaluated_pdt := ^dialog_pdt;
        request.evaluated_pvt := dialog_pvt;
        request.parameter_substitutions := NIL;

        clp$internal_convert_to_string (request, work_area, representation, support_status);

        work_area := original_work_area;

      PROCEND support_nested_dialog;
?? TITLE := 'support_restore_param_default', EJECT ??

      PROCEDURE support_restore_param_default
        (    parameter_number: clt$parameter_number;
         VAR support_status: ost$status);


        support_status.normal := TRUE;

        unspecify_parameter (parameter_number);

      PROCEND support_restore_param_default;
?? TITLE := 'support_verify_all_parameters', EJECT ??

      PROCEDURE support_verify_all_parameters
        (VAR which_parameter: clt$which_parameter;
         VAR support_status: ost$status);


        support_status.normal := TRUE;

        IF pdt.header^.number_of_parameters = 0 THEN
          RETURN;
        IFEND;

        IF (pdt.header^.number_of_required_parameters > 0) AND (NOT required_parameters_checked) THEN
          check_required_parameters_given (which_parameter, support_status);
          IF NOT support_status.normal THEN
            RETURN;
          IFEND;
        IFEND;

        IF NOT parameter_defaults_evaluated THEN
          evaluate_parameter_defaults (which_parameter, support_status);
          IF NOT support_status.normal THEN
            RETURN;
          IFEND;
        IFEND;

        IF (NOT general_param_checks_performed) AND (check_parameters_procedure <> NIL) THEN
          which_parameter.specific := FALSE;
          perform_parameter_checks (which_parameter, support_status);
        IFEND;

      PROCEND support_verify_all_parameters;
?? OLDTITLE, EJECT ??

      VAR
        cancel: boolean,
        context: ^ost$ecp_exception_context,
        initial_status: ^ost$status,
        loaded_address: pmt$loaded_address,
        parameter_dialog_manager: clt$parameter_dialog_manager,
        support: clt$parameter_dialog_support;

      context := NIL;

      IF local_status.normal THEN
        initial_status := NIL;
      ELSE
        PUSH initial_status;
        initial_status^ := local_status;
        local_status.normal := TRUE;
      IFEND;

      loaded_address.kind := pmc$procedure_address;
      loaded_address.pointer_to_procedure := NIL;

    /load_dialog_manager/
      BEGIN
        original_term_error_level := osc$fatal_status;
        #SPOIL (original_term_error_level);
        osp$establish_block_exit_hndlr (^abort_handler);

        pmp$change_term_error_level (osc$fatal_status, original_term_error_level, local_status);
        IF NOT local_status.normal THEN
          EXIT /load_dialog_manager/;
        IFEND;

        IF load_from_system THEN
          REPEAT
            clp$load_system_entry_point (dialog_manager_name, pmc$procedure_address, loaded_address,
                  local_status);
            IF osp$file_access_condition (local_status) THEN
              IF context = NIL THEN
                PUSH context;
                context^ := osv$initial_exception_context;
              IFEND;
              context^.condition_status := local_status;
              osp$enforce_exception_policies (context^);
              local_status := context^.condition_status;
            IFEND;
          UNTIL local_status.normal OR (NOT osp$file_access_condition (local_status)) OR (NOT context^.wait);
        ELSE
          pmp$load (dialog_manager_name, pmc$procedure_address, loaded_address, local_status);
        IFEND;
        IF NOT local_status.normal THEN
          loaded_address.pointer_to_procedure := NIL;
        IFEND;

        pmp$change_term_error_level (original_term_error_level, ignore_term_error_level, local_status);

        osp$disestablish_cond_handler;
      END /load_dialog_manager/;

      IF (NOT local_status.normal) OR (loaded_address.pointer_to_procedure = NIL) THEN
        osp$set_status_abnormal ('CL', cle$unable_to_call_parm_dlg_mgr, dialog_manager_name, local_status);
        RETURN;
      IFEND;

      #CONVERT_POINTER_TO_PROCEDURE (loaded_address.pointer_to_procedure, parameter_dialog_manager);

      cancel := FALSE;

      find_help_module;

      support.get_brief_help := ^support_get_brief_help;
      support.get_full_help := ^support_get_full_help;
      support.get_parameter_prompt := ^support_get_parameter_prompt;
      support.get_parameter_assist_prompt := ^support_get_param_assist_prompt;
      support.get_parameter_help := ^support_get_parameter_help;
      support.get_all_parameter_specs := ^support_get_all_parameter_specs;
      support.get_parameter_spec := ^support_get_parameter_spec;
      support.get_parameter_default := ^support_get_parameter_default;
      support.get_parameter_value := ^support_get_parameter_value;
      support.get_parameter_value_source := ^support_get_param_value_source;
      support.evaluate_parameter := ^support_evaluate_parameter;
      support.restore_parameter_default := ^support_restore_param_default;
      support.verify_all_parameters := ^support_verify_all_parameters;
      support.explain := ^support_explain;
      support.get_all_names := ^support_get_all_names;
      support.get_source := ^support_get_source;
      support.help_module := dialog_control.help_module;
      IF evaluation_context.interpreter_mode = clc$help_mode THEN
        support.change_expression_save := ^support_change_expression_save;
      ELSE
        support.change_expression_save := NIL;
      IFEND;
      support.nested_dialog := ^support_nested_dialog;
      IF evaluation_context.command_or_function_source = NIL THEN
        support.nested_dialog_title := ^evaluation_context.command_or_function_name;
      ELSE
        support.nested_dialog_title := NIL;
      IFEND;

      IF initial_status <> NIL THEN
        local_status := initial_status^;
      IFEND;

      save_source_of_expressions := FALSE;
*IF NOT $true(osv$unix)
      callers_save_area := #PREVIOUS_SAVE_AREA ();
*ELSE
      callers_save_area := NIL;
*IFEND
      #SPOIL (save_source_of_expressions, callers_save_area);
      osp$establish_condition_handler (^invoke_condition_handler, FALSE);

      parameter_dialog_manager^ (support, evaluation_context.command_or_function_name,
            dialog_control.online_manual_name, pdt, cancel, local_status);

      osp$disestablish_cond_handler;

      save_source_of_expressions := evaluation_context.interpreter_mode = clc$help_mode;

      IF local_status.normal AND cancel THEN
        osp$set_status_abnormal ('CL', dialog_control.cancelled_status_code,
              evaluation_context.command_or_function_name, status);
        EXIT clp$internal_evaluate_params;
      IFEND;

    PROCEND invoke_parameter_dialog_manager;
?? TITLE := 'open_line_style_dialog', EJECT ??

    PROCEDURE [INLINE] open_line_style_dialog;


      IF NOT dialog_control.open THEN
        initialize_line_style_dialog;
      IFEND;

    PROCEND open_line_style_dialog;
?? TITLE := 'perform_parameter_checks', EJECT ??

    PROCEDURE perform_parameter_checks
      (    which_parameter: clt$which_parameter;
       VAR local_status: ost$status);

      VAR
        callers_save_area: ^ost$stack_frame_save_area;

?? NEWTITLE := 'bad_check_proc_pointer_handler', EJECT ??

      PROCEDURE bad_check_proc_pointer_handler
        (    condition: pmt$condition;
             ignore_info: ^pmt$condition_information;
             save_area: ^ost$stack_frame_save_area;
         VAR handler_status: ost$status);


        IF (condition.selector = pmc$system_conditions) AND
              (($pmt$system_conditions [pmc$instruction_specification, pmc$address_specification,
              pmc$access_violation, pmc$environment_specification, pmc$invalid_segment_ring_0,
              pmc$out_call_in_return] * condition.system_conditions) <> $pmt$system_conditions []) AND
              (save_area^.minimum_save_area.a2_previous_save_area = callers_save_area) THEN
          osp$set_status_condition (cle$unable_to_call_check_proc, status);
          EXIT clp$internal_evaluate_params;
        IFEND;

        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);

      PROCEND bad_check_proc_pointer_handler;
?? OLDTITLE, EJECT ??

      local_status.normal := TRUE;

      IF (evaluation_context.interpreter_mode = clc$help_mode) AND (NOT which_parameter.specific) THEN
        general_param_checks_performed := TRUE;
        RETURN;
      IFEND;

      IF NOT check_procedure_called THEN
*IF NOT $true(osv$unix)
        callers_save_area := #PREVIOUS_SAVE_AREA ();
*ELSE
        callers_save_area := NIL;
*IFEND
        #SPOIL (callers_save_area);
        osp$establish_condition_handler (^bad_check_proc_pointer_handler, FALSE);
      IFEND;

      WHILE TRUE DO
        check_parameters_procedure^ (pvt, which_parameter, local_status);

        IF NOT check_procedure_called THEN
          osp$disestablish_cond_handler;
          check_procedure_called := TRUE;
        IFEND;

        IF local_status.normal OR (NOT dialog_control.activated) OR
              (dialog_control.interaction_style <> osc$line_interaction) OR
              (which_parameter.specific AND (pdt.parameters^ [which_parameter.number].availability =
              clc$hidden_entry)) THEN
          general_param_checks_performed := NOT which_parameter.specific;
          RETURN;
        IFEND;

        prompt_for_correction (which_parameter, local_status);
        local_status.normal := TRUE;

        IF which_parameter.specific THEN
          RETURN;
        IFEND;
      WHILEND;

    PROCEND perform_parameter_checks;
?? TITLE := 'prompt_for_all_desktop_style', EJECT ??

    PROCEDURE [INLINE] prompt_for_all_desktop_style
      (VAR local_status: ost$status);


      invoke_parameter_dialog_manager (clc$desktop_param_dialog_mgr, FALSE, local_status);

    PROCEND prompt_for_all_desktop_style;
?? TITLE := 'prompt_for_all_line_style', EJECT ??

    PROCEDURE prompt_for_all_line_style
      (VAR local_status: ost$status);

      VAR
        message: ost$status_message,
        parameter_number: clt$parameter_number;

?? NEWTITLE := 'prompt_for_parameter', EJECT ??

      PROCEDURE [INLINE] prompt_for_parameter;

        VAR
          which_parameter: clt$which_parameter;


        open_line_style_dialog;
        get_parameter_prompt (parameter_number, dialog_control.page_width, message);
        WHILE TRUE DO
          which_parameter.specific := TRUE;
          which_parameter.number := parameter_number;
          put_prompt_and_get_reply (message, which_parameter);
          dialog_control.prompted_for_parameter^ [parameter_number] := TRUE;
          IF NOT dialog_control.null_reply THEN
            evaluate_nested_parameters (parameter_number);
          IFEND;
          IF pdt.parameters^ [parameter_number].requirement = clc$required_parameter THEN
            IF pvt^ [parameter_number].specified THEN
              IF dialog_control.terminator_in_reply THEN
                EXIT prompt_for_all_line_style;
              IFEND;
              RETURN;
            IFEND;
          ELSEIF dialog_control.terminator_in_reply THEN
            EXIT prompt_for_all_line_style;
          ELSEIF dialog_control.null_reply OR pvt^ [parameter_number].specified THEN
            RETURN;
          IFEND;
        WHILEND;

      PROCEND prompt_for_parameter;
?? OLDTITLE, EJECT ??

      VAR
        message_name: ost$name,
        message_parameters: array [1 .. 1] of ^ost$message_parameter,
        message_template: ^ost$message_template,
        which_parameter: clt$which_parameter;


      IF (pdt.header^.number_of_parameters - pdt.header^.number_of_hidden_parameters -
            $INTEGER (pdt.header^.status_parameter_number <> 0)) <= 0 THEN

        IF (NOT general_param_checks_performed) AND (check_parameters_procedure <> NIL) THEN
          which_parameter.specific := FALSE;
          perform_parameter_checks (which_parameter, local_status);
          IF NOT local_status.normal THEN
            RETURN;
          IFEND;
        IFEND;

        dialog_control.parameters_to_prompt_for := FALSE;
        open_line_style_dialog;
        IF evaluation_context.command_or_function = clc$command THEN
          message_name := clc$no_command_params_msg;
        ELSE
          message_name := clc$no_function_params_msg;
        IFEND;
        find_default_help_module;
        osp$find_param_assist_prompt (dialog_control.default_help_module, message_name, message_template,
              ignore_status);
        message_parameters [1] := ^evaluation_context.command_or_function_name;
        format_message (message_template, dialog_control.page_width, ^message_parameters, message);
        which_parameter.specific := FALSE;
        put_prompt_and_get_reply (message, which_parameter);

{ Ignore the reply to the above prompt.

        RETURN;
      IFEND;

      FOR parameter_number := 1 TO pdt.header^.number_of_parameters DO
        IF (NOT pvt^ [parameter_number].specified) AND (pdt.parameters^ [parameter_number].availability =
              clc$normal_usage_entry) AND (parameter_number <> pdt.header^.status_parameter_number) AND
              (NOT dialog_control.prompted_for_parameter^ [parameter_number]) THEN
          prompt_for_parameter;
        IFEND;
      FOREND;

      IF pdt.header^.number_of_advanced_parameters > 0 THEN
        FOR parameter_number := 1 TO pdt.header^.number_of_parameters DO
          IF (NOT pvt^ [parameter_number].specified) AND (pdt.parameters^ [parameter_number].availability =
                clc$advanced_usage_entry) AND (NOT dialog_control.prompted_for_parameter^ [parameter_number])
                THEN

            IF NOT dialog_control.prompting_for_advanced_params THEN
              open_line_style_dialog;

              find_default_help_module;
              osp$find_param_assist_prompt (dialog_control.default_help_module, clc$prompt_for_advanced_param,
                    message_template, ignore_status);
              format_message (message_template, dialog_control.page_width, NIL, message);

              which_parameter.specific := FALSE;
              put_prompt_and_get_yn_reply (message, which_parameter,
                    dialog_control.prompting_for_advanced_params);
              IF NOT dialog_control.prompting_for_advanced_params THEN
                RETURN;
              IFEND;
            IFEND;

            prompt_for_parameter;
          IFEND;
        FOREND;
      IFEND;

      IF (pdt.header^.number_of_required_parameters > 0) AND (NOT required_parameters_checked) THEN
        check_required_parameters_given (which_parameter, local_status);
        IF NOT local_status.normal THEN
          RETURN;
        IFEND;
      IFEND;

      IF NOT parameter_defaults_evaluated THEN
        evaluate_parameter_defaults (which_parameter, local_status);
        IF NOT local_status.normal THEN
          RETURN;
        IFEND;
      IFEND;

      IF (NOT general_param_checks_performed) AND (check_parameters_procedure <> NIL) THEN
        which_parameter.specific := FALSE;
        perform_parameter_checks (which_parameter, local_status);
        IF NOT local_status.normal THEN
          RETURN;
        IFEND;
      IFEND;

      IF evaluation_context.prompting_requested AND (NOT dialog_control.open) THEN
        dialog_control.parameters_to_prompt_for := FALSE;
        initialize_line_style_dialog;
        message_name := clc$all_command_params_correct;
        find_default_help_module;
        osp$find_param_assist_prompt (dialog_control.default_help_module, message_name, message_template,
              ignore_status);
        message_parameters [1] := ^evaluation_context.command_or_function_name;
        format_message (message_template, dialog_control.page_width, ^message_parameters, message);
        which_parameter.specific := FALSE;
        put_prompt_and_get_reply (message, which_parameter);

{ Ignore the reply to the above prompt.

      IFEND;

    PROCEND prompt_for_all_line_style;
?? TITLE := 'prompt_for_all_screen_style', EJECT ??

    PROCEDURE [INLINE] prompt_for_all_screen_style
      (VAR local_status: ost$status);


      invoke_parameter_dialog_manager (clc$screen_param_dialog_mgr, TRUE, local_status);

    PROCEND prompt_for_all_screen_style;
?? TITLE := 'prompt_for_correction', EJECT ??

    PROCEDURE prompt_for_correction
      (    which_parameter: clt$which_parameter;
           local_status: ost$status);

      VAR
        message: ost$status_message,
        parameter_number: clt$parameter_number;

?? NEWTITLE := 'get_correct_parameters_prompt', EJECT ??

      PROCEDURE get_correct_parameters_prompt;

        VAR
          message_template: ^ost$message_template;


        find_default_help_module;
        osp$find_param_assist_prompt (dialog_control.default_help_module, clc$correct_parameters_prompt,
              message_template, ignore_status);
        format_message (message_template, dialog_control.page_width, NIL, message);

      PROCEND get_correct_parameters_prompt;
?? TITLE := 'get_param_assist_prompt', EJECT ??

      PROCEDURE get_param_assist_prompt;

        VAR
          converted_parameter_name: clt$parameter_name,
          ignore_last_line_of_message: ^ost$status_message_line,
          message_parameters: array [1 .. 1] of ^ost$message_parameter,
          message_template: ^ost$message_template,
          parameter_name: clt$parameter_name;


        parameter_name := pdt.names^ [pdt.parameters^ [parameter_number].name_index].name;
        converted_parameter_name := parameter_name;
        convert_name_to_message_param (converted_parameter_name);
        message_parameters [1] := ^converted_parameter_name;

      /find_param_assist_prompt/
        BEGIN
          find_help_module;

          IF dialog_control.help_module <> NIL THEN
            osp$find_param_assist_prompt (dialog_control.help_module, parameter_name, message_template,
                  ignore_status);
            IF message_template <> NIL THEN
              format_message (message_template, dialog_control.page_width, ^message_parameters, message);
              put_message (message, ignore_last_line_of_message);
            IFEND;

            osp$find_parameter_prompt (dialog_control.help_module, parameter_name, message_template,
                  ignore_status);
            IF message_template <> NIL THEN
              EXIT /find_param_assist_prompt/;
            IFEND;
          IFEND;

          find_default_help_module;

          osp$find_parameter_prompt (dialog_control.default_help_module, clc$default_parameter_prompt,
                message_template, ignore_status);
        END /find_param_assist_prompt/;

        format_message (message_template, dialog_control.page_width, ^message_parameters, message);

      PROCEND get_param_assist_prompt;
?? OLDTITLE, EJECT ??

      VAR
        correction_supplied: boolean;


      open_line_style_dialog;

      IF NOT local_status.normal THEN
        put_status (local_status);
      IFEND;

      IF which_parameter.specific THEN
        parameter_number := which_parameter.number;
        unspecify_parameter (parameter_number);
        get_param_assist_prompt;
        dialog_control.prompted_for_parameter^ [parameter_number] := TRUE;
      ELSE
        parameter_number := 1;
        get_correct_parameters_prompt;
      IFEND;

      correction_supplied := FALSE;
      REPEAT
        put_prompt_and_get_reply (message, which_parameter);
        IF NOT dialog_control.null_reply THEN
          correction_supplied := TRUE;
          evaluate_nested_parameters (parameter_number);
        IFEND;
      UNTIL which_parameter.specific OR correction_supplied OR
            (evaluation_context.interpreter_mode = clc$help_mode);

    PROCEND prompt_for_correction;
?? TITLE := 'put_line', EJECT ??

    PROCEDURE [INLINE] put_line
      (    line: string ( * ));

      VAR
        ignore_byte_address: amt$file_byte_address;


      amp$put_next (dialog_control.output_file_id, ^line, STRLENGTH (line), ignore_byte_address, status);
      IF NOT status.normal THEN
        EXIT clp$internal_evaluate_params;
      IFEND;

    PROCEND put_line;
?? TITLE := 'put_message', EJECT ??

    PROCEDURE [INLINE] put_message
      (    message: ost$status_message;
       VAR last_line_of_message: ^ost$status_message_line);

      VAR
        message_area: ^ost$status_message,
        message_line_count: ^ost$status_message_line_count,
        message_line_index: 1 .. osc$max_status_message_lines,
        message_line_size: ^ost$status_message_line_size;


      message_area := ^message;
      RESET message_area;
      NEXT message_line_count IN message_area;

      IF message_line_count^ = 0 THEN
        last_line_of_message := NIL;
      ELSE
        FOR message_line_index := 1 TO message_line_count^ DO
          NEXT message_line_size IN message_area;
          NEXT last_line_of_message: [message_line_size^] IN message_area;
          put_line (last_line_of_message^);
        FOREND;
      IFEND;

    PROCEND put_message;
?? TITLE := 'put_prompt_and_get_reply', EJECT ??

    PROCEDURE put_prompt_and_get_reply
      (    prompt: ost$status_message;
           which_parameter: clt$which_parameter);

      VAR
        help_level: (clc$parameter_help, clc$advanced_parameter_help, clc$brief_help, clc$full_help,
              clc$advanced_help, clc$online_manual_help),
        last_line_of_prompt: ^ost$status_message_line,
        local_status: ost$status,
        original_terminal_attributes: array [1 .. 2] of ift$terminal_attribute,
        retry_get: boolean,
        secure_prompt: ^ost$status_message_line,
        secure_terminal_attributes: array [1 .. 2] of ift$terminal_attribute;

?? NEWTITLE := 'get_prompting_reply', EJECT ??

      PROCEDURE get_prompting_reply;

?? NEWTITLE := 'get_reply_break_handler', EJECT ??

        PROCEDURE get_reply_break_handler
          (    condition: pmt$condition;
               ignore_condition_information: ^pmt$condition_information;
               ignore_save_area: ^ost$stack_frame_save_area;
           VAR handler_status: ost$status);


          CASE condition.selector OF

          = pmc$block_exit_processing =
            IF (secure_prompt <> NIL) AND (NOT retry_get) THEN
              ifp$change_terminal_attributes (clv$standard_files [clc$sf_command_file].path_handle_name,
                    original_terminal_attributes, ignore_status);
            IFEND;
            RETURN;

          = ifc$interactive_condition =
            IF condition.interactive_condition = ifc$terminate_break THEN
              IF evaluation_context.prompting_requested THEN
                osp$set_status_abnormal ('CL', dialog_control.cancelled_status_code,
                      evaluation_context.command_or_function_name, status);
                EXIT clp$internal_evaluate_params;
              IFEND;
              ignore_terminate_breaks := FALSE;
              #SPOIL (ignore_terminate_breaks);
            IFEND;

          ELSE
            ;
          CASEND;

          IF secure_prompt <> NIL THEN
            ifp$change_terminal_attributes (clv$standard_files [clc$sf_command_file].path_handle_name,
                  original_terminal_attributes, ignore_status);
          IFEND;

          pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);

          ignore_terminate_breaks := TRUE;
          #SPOIL (ignore_terminate_breaks);

          IF handler_status.normal AND (condition.selector = ifc$interactive_condition) THEN
            IF condition.interactive_condition = ifc$pause_break THEN
              retry_get := TRUE;
              #SPOIL (retry_get);
              EXIT get_prompting_reply;
            ELSEIF condition.interactive_condition = ifc$terminate_break THEN
              osp$set_status_abnormal ('CL', dialog_control.cancelled_status_code,
                    evaluation_context.command_or_function_name, status);
              EXIT clp$internal_evaluate_params;
            IFEND;
          IFEND;

          IF secure_prompt <> NIL THEN
            ifp$change_terminal_attributes (clv$standard_files [clc$sf_command_file].path_handle_name,
                  secure_terminal_attributes, ignore_status);
          IFEND;

        PROCEND get_reply_break_handler;
?? TITLE := 'overwrite_secure_reply', EJECT ??

        CONST
          overwrite_multiple = 3,
          overwrite_pattern_size = overwrite_multiple * (osc$max_name_size - 1);

        VAR
          blank_overwrite: [STATIC, READ, oss$job_paged_literal] string (overwrite_pattern_size) := ' ',
          overwrite_pattern: [STATIC, READ, oss$job_paged_literal] string
                (overwrite_pattern_size + overwrite_multiple - 1) :=
                'HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI#HI' CAT
                '#HI#HI';

?? SKIP := 3 ??

        PROCEDURE [INLINE] overwrite_secure_reply;

          VAR
            i: integer,
            ignore_byte_address: amt$file_byte_address,
            j: integer,
            overwrite_size: clt$command_line_size;


          overwrite_size := STRLENGTH (dialog_control.reply_parse.text^);
          IF overwrite_size < osc$max_name_size THEN
            overwrite_size := osc$max_name_size;
          IFEND;

          FOR i := 1 TO overwrite_multiple DO
            amp$put_partial (dialog_control.output_file_id, secure_prompt, STRLENGTH (secure_prompt^),
                  ignore_byte_address, amc$start, ignore_status);
            FOR j := 1 TO (overwrite_size DIV overwrite_pattern_size) DO
              amp$put_partial (dialog_control.output_file_id, ^overwrite_pattern (i), overwrite_pattern_size,
                    ignore_byte_address, amc$continue, ignore_status);
            FOREND;
            amp$put_partial (dialog_control.output_file_id, ^overwrite_pattern (i),
                  overwrite_size MOD overwrite_pattern_size, ignore_byte_address, amc$terminate,
                  ignore_status);
          FOREND;

          amp$put_partial (dialog_control.output_file_id, secure_prompt, STRLENGTH (secure_prompt^),
                ignore_byte_address, amc$start, ignore_status);
          FOR j := 1 TO (overwrite_size DIV overwrite_pattern_size) DO
            amp$put_partial (dialog_control.output_file_id, ^blank_overwrite, overwrite_pattern_size,
                  ignore_byte_address, amc$continue, ignore_status);
          FOREND;
          amp$put_partial (dialog_control.output_file_id, ^blank_overwrite,
                overwrite_size MOD overwrite_pattern_size, ignore_byte_address, amc$terminate, ignore_status);

        PROCEND overwrite_secure_reply;
?? OLDTITLE, EJECT ??

        VAR
          end_of_input: boolean;


        osp$establish_condition_handler (^get_reply_break_handler, TRUE);

        IF secure_prompt <> NIL THEN
          ifp$change_terminal_attributes (clv$standard_files [clc$sf_command_file].path_handle_name,
                secure_terminal_attributes, ignore_status);
        IFEND;

        clp$get_command_line (dialog_control.reply_parse, end_of_input, local_status);

        IF end_of_input AND local_status.normal THEN
          IF status.normal THEN
            osp$set_status_abnormal ('CL', cle$interactive_eoi_ignored, '', status);
            osp$generate_output_message(status,ignore_status);
            clp$reset_input_state;
            retry_get := TRUE;
            status.normal := TRUE;
          IFEND;
        IFEND;

        IF secure_prompt <> NIL THEN
          ifp$change_terminal_attributes (clv$standard_files [clc$sf_command_file].path_handle_name,
                original_terminal_attributes, ignore_status);
        IFEND;

        osp$disestablish_cond_handler;

        IF secure_prompt <> NIL THEN
          overwrite_secure_reply;
        IFEND;

        IF NOT local_status.normal THEN
          status := local_status;
          EXIT clp$internal_evaluate_params;
        IFEND;

      PROCEND get_prompting_reply;
?? TITLE := 'process_command_line', EJECT ??

      PROCEDURE process_command_line;

        VAR
          terminate_break_detected: boolean;

?? NEWTITLE := 'terminate_command_handler', EJECT ??

        PROCEDURE terminate_command_handler
          (    condition: pmt$condition;
               ignore_condition_information: ^pmt$condition_information;
               ignore_save_area: ^ost$stack_frame_save_area;
           VAR handler_status: ost$status);


          CASE condition.selector OF

          = pmc$block_exit_processing =
            IF terminate_break_detected THEN
              ifp$discard_suspended_output;
              osp$set_status_condition (cle$command_terminated, local_status);
              put_status (local_status);
            IFEND;
            RETURN;

          = ifc$interactive_condition =
            IF condition.interactive_condition = ifc$terminate_break THEN
              terminate_break_detected := TRUE;
              EXIT process_command_line;
            IFEND;

          ELSE
            ;
          CASEND;

          pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);

        PROCEND terminate_command_handler;
?? OLDTITLE, EJECT ??

        CONST
          enable_echoing = TRUE;


*IF NOT $true(osv$unix)
        IF #RING (^dialog_control) < avp$ring_min () THEN
          osp$set_status_condition (cle$param_dialog_not_privileged, local_status);
          put_status (local_status);
          RETURN;
        IFEND;
*IFEND

        terminate_break_detected := FALSE;
        #SPOIL (terminate_break_detected);
        osp$establish_condition_handler (^terminate_command_handler, TRUE);

        clp$include_line (dialog_control.reply_parse.text^ (2, * ), enable_echoing, osc$null_name,
              local_status);
        IF NOT local_status.normal THEN
          put_status (local_status);
        IFEND;

      PROCEND process_command_line;
?? TITLE := 'process_help_request', EJECT ??

      PROCEDURE process_help_request;

        VAR
          request: clt$convert_to_string_request,
          representation: ^clt$data_representation,
          terminate_break_detected: boolean;

?? NEWTITLE := 'display_all_parameters', EJECT ??

        PROCEDURE display_all_parameters
          (    include_advanced_items: boolean);


          request.initial_indentation := 1;
          request.continuation_indentation := 7;
          request.max_string := dialog_control.page_width + 1;
          request.include_advanced_items := include_advanced_items;
          request.include_hidden_items := FALSE;
          request.kind := clc$convert_unbundled_pdt;
          request.multi_line_pdt_format := FALSE;
          request.parameter_starts_line := TRUE;
          request.individual_parameter := FALSE;
          request.individual_parameter_number := LOWERVALUE (clt$parameter_number);
          request.include_header := FALSE;
          request.command_or_function_name := evaluation_context.command_or_function_name;
          request.aliases := NIL;
          request.availability := clc$normal_usage_entry;
          request.command_or_function_scope := clc$xdcl_command_or_function;
          request.pdt := ^pdt;
          request.pvt := pvt;
          request.symbolic_pdt_qualifiers_area := NIL;
          request.include_implementation_info := FALSE;

          clp$internal_convert_to_string (request, work_area, representation, local_status);
          IF NOT local_status.normal THEN
            RETURN;
          IFEND;

          put_representation;

          RESET work_area TO representation;

        PROCEND display_all_parameters;
?? TITLE := 'display_current_parameter', EJECT ??

        PROCEDURE display_current_parameter
          (    include_advanced_items: boolean);


          request.initial_indentation := 1;
          request.continuation_indentation := 7;
          request.max_string := dialog_control.page_width + 1;
          request.include_advanced_items := include_advanced_items;
          request.include_hidden_items := FALSE;
          request.kind := clc$convert_unbundled_pdt;
          request.multi_line_pdt_format := TRUE;
          request.parameter_starts_line := TRUE;
          request.individual_parameter := TRUE;
          request.individual_parameter_number := which_parameter.number;
          request.include_header := FALSE;
          request.command_or_function_name := evaluation_context.command_or_function_name;
          request.aliases := NIL;
          request.availability := clc$normal_usage_entry;
          request.command_or_function_scope := clc$xdcl_command_or_function;
          request.pdt := ^pdt;
          request.pvt := pvt;
          request.symbolic_pdt_qualifiers_area := NIL;
          request.include_implementation_info := FALSE;

          clp$internal_convert_to_string (request, work_area, representation, local_status);
          IF NOT local_status.normal THEN
            RETURN;
          IFEND;

          put_representation;

          RESET work_area TO representation;

        PROCEND display_current_parameter;
?? TITLE := 'put_representation', EJECT ??

        PROCEDURE [INLINE] put_representation;

          VAR
            representation_line: ^clt$string_value,
            representation_line_count: ^clt$data_representation_count,
            representation_line_index: clt$data_representation_count,
            representation_line_size: ^clt$string_size;


          RESET representation;
          NEXT representation_line_count IN representation;

          FOR representation_line_index := 1 TO representation_line_count^ DO
            NEXT representation_line_size IN representation;
            NEXT representation_line: [representation_line_size^] IN representation;
            put_line (representation_line^);
          FOREND;

        PROCEND put_representation;
?? TITLE := 'terminate_help_handler', EJECT ??

        PROCEDURE terminate_help_handler
          (    condition: pmt$condition;
               ignore_condition_information: ^pmt$condition_information;
               ignore_save_area: ^ost$stack_frame_save_area;
           VAR handler_status: ost$status);


          CASE condition.selector OF

          = pmc$block_exit_processing =
            IF terminate_break_detected THEN
              ifp$discard_suspended_output;
            IFEND;
            RETURN;

          = ifc$interactive_condition =
            IF condition.interactive_condition = ifc$terminate_break THEN
              terminate_break_detected := TRUE;
              EXIT process_help_request;
            IFEND;

          ELSE
            ;
          CASEND;

          pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);

        PROCEND terminate_help_handler;
?? OLDTITLE, EJECT ??

        VAR
          help_given: boolean,
          ignore_last_line_of_message: ^ost$status_message_line,
          message: ost$status_message,
          message_parameters: array [1 .. 1] of ^ost$message_parameter,
          message_template: ^ost$message_template,
          parameter_name: clt$parameter_name;


        terminate_break_detected := FALSE;
        #SPOIL (terminate_break_detected);
        osp$establish_condition_handler (^terminate_help_handler, TRUE);

        help_given := FALSE;
        REPEAT
          CASE help_level OF

          = clc$parameter_help =
            IF which_parameter.specific THEN

            /process_parameter_help_request/
              BEGIN
                find_help_module;
                IF dialog_control.help_module <> NIL THEN
                  parameter_name := pdt.names^ [pdt.parameters^ [which_parameter.number].name_index].name;
                  osp$find_parameter_help_message (dialog_control.help_module, parameter_name,
                        message_template, ignore_status);
                  IF message_template <> NIL THEN
                    convert_name_to_message_param (parameter_name);
                    message_parameters [1] := ^parameter_name;
                    format_message (message_template, dialog_control.page_width, ^message_parameters,
                          message);
                    put_message (message, ignore_last_line_of_message);
                    EXIT /process_parameter_help_request/;
                  IFEND;
                IFEND;

                display_current_parameter (FALSE);
              END /process_parameter_help_request/;
              help_given := TRUE;
            IFEND;

          = clc$advanced_parameter_help =

            IF which_parameter.specific AND pdt.type_descriptions^ [which_parameter.number].
                  advanced_keywords_present THEN
              display_current_parameter (TRUE);
              help_given := TRUE;
            IFEND;

          = clc$brief_help =

            find_help_module;
            IF dialog_control.help_module <> NIL THEN
              osp$find_brief_help_message (dialog_control.help_module, message_template, ignore_status);
              IF message_template <> NIL THEN
                format_message (message_template, dialog_control.page_width, NIL, message);
                put_message (message, ignore_last_line_of_message);
                help_given := TRUE;
              IFEND;
            IFEND;

          = clc$full_help =

            find_help_module;
            IF dialog_control.help_module <> NIL THEN
              osp$find_full_help_message (dialog_control.help_module, message_template, ignore_status);
              IF message_template <> NIL THEN
                format_message (message_template, dialog_control.page_width, NIL, message);
                put_message (message, ignore_last_line_of_message);
              IFEND;
            IFEND;

            display_all_parameters (dialog_control.prompting_for_advanced_params);
            help_given := TRUE;

          = clc$advanced_help =

            IF (pdt.header^.number_of_advanced_parameters > 0) AND
                  (NOT dialog_control.prompting_for_advanced_params) THEN
              display_all_parameters (TRUE);
              help_given := TRUE;
            IFEND;

          = clc$online_manual_help =

            explain_command_or_function (help_given, local_status);
            help_given := local_status.normal AND help_given;

          CASEND;
          IF help_level < UPPERVALUE (help_level) THEN
            help_level := SUCC (help_level);
          ELSE
            help_level := LOWERVALUE (help_level);
          IFEND;
        UNTIL help_given;

        osp$disestablish_cond_handler;

      PROCEND process_help_request;
?? OLDTITLE, EJECT ??

      IF which_parameter.specific THEN
        help_level := clc$parameter_help;
      ELSE
        help_level := clc$full_help;
      IFEND;

      secure_prompt := NIL;
      ignore_terminate_breaks := TRUE;
      #SPOIL (secure_prompt, ignore_terminate_breaks);

    /put_prompt_and_get_reply_loop/
      WHILE TRUE DO
        put_message (prompt, last_line_of_prompt);

        IF which_parameter.specific AND (pdt.parameters^ [which_parameter.number].security =
              clc$secure_parameter) AND (secure_prompt = NIL) THEN
          IF last_line_of_prompt = NIL THEN
            PUSH secure_prompt: [2];
            secure_prompt^ (2) := ' ';
          ELSE
            PUSH secure_prompt: [STRLENGTH (last_line_of_prompt^) + 1];
            secure_prompt^ := last_line_of_prompt^;
          IFEND;
          secure_prompt^ (1) := ifc$pre_print_start_of_line;
          #SPOIL (secure_prompt, secure_prompt^);

          original_terminal_attributes [1].key := ifc$echoplex;
          original_terminal_attributes [2].key := ifc$end_line_positioning;
          ifp$get_terminal_attributes (clv$standard_files [clc$sf_command_file].path_handle_name,
                original_terminal_attributes, local_status);
          IF NOT local_status.normal THEN
            status := local_status;
            EXIT clp$internal_evaluate_params;
          IFEND;

          secure_terminal_attributes [1].key := ifc$echoplex;
          secure_terminal_attributes [1].echoplex := FALSE;
          secure_terminal_attributes [2].key := ifc$end_line_positioning;
          secure_terminal_attributes [2].end_line_positioning := ifc$elp_none;
          #SPOIL (secure_terminal_attributes);
        IFEND;

        retry_get := FALSE;
        #SPOIL (retry_get);

        get_prompting_reply;

        IF retry_get THEN
          CYCLE /put_prompt_and_get_reply_loop/;

        ELSEIF STRLENGTH (dialog_control.reply_parse.text^) = 0 THEN
          dialog_control.null_reply := TRUE;
          dialog_control.terminator_in_reply := FALSE;
          EXIT /put_prompt_and_get_reply_loop/;

        ELSEIF (STRLENGTH (dialog_control.reply_parse.text^) = 1) AND
              (dialog_control.reply_parse.text^ (1) = clc$help_request) THEN
          process_help_request;

        ELSEIF dialog_control.reply_parse.text^ (1) = clc$escape_prefix THEN
          process_command_line;

        ELSE
          dialog_control.terminator_in_reply := dialog_control.reply_parse.
                text^ (STRLENGTH (dialog_control.reply_parse.text^)) = clc$terminator_suffix;
          IF dialog_control.terminator_in_reply THEN
            dialog_control.reply_parse.index_limit := dialog_control.reply_parse.index_limit - 1;
          IFEND;
          dialog_control.null_reply := STRLENGTH (dialog_control.reply_parse.text^) =
                $INTEGER (dialog_control.terminator_in_reply);
          EXIT /put_prompt_and_get_reply_loop/;

        IFEND;
      WHILEND /put_prompt_and_get_reply_loop/;

      ignore_terminate_breaks := FALSE;

    PROCEND put_prompt_and_get_reply;
?? TITLE := 'put_prompt_and_get_yn_reply', EJECT ??

    PROCEDURE put_prompt_and_get_yn_reply
      (    prompt: ost$status_message;
           which_parameter: clt$which_parameter;
       VAR yes_or_no: boolean);

      VAR
        local_status: ost$status,
        name: ost$name;


      WHILE TRUE DO
        put_prompt_and_get_reply (prompt, which_parameter);
        IF dialog_control.null_reply THEN
          RETURN;
        IFEND;
        check_reply_for_name (name, local_status);
        IF local_status.normal THEN
          IF (name = 'YES') OR (name = 'Y') THEN
            yes_or_no := TRUE;
            RETURN;
          ELSEIF (name = 'NO') OR (name = 'N') THEN
            yes_or_no := FALSE;
            RETURN;
          IFEND;
        IFEND;
      WHILEND;

    PROCEND put_prompt_and_get_yn_reply;
?? TITLE := 'put_status', EJECT ??

    PROCEDURE [INLINE] put_status
      (    message_status: ost$status);

      osp$generate_output_message (message_status, ignore_status);

    PROCEND put_status;
?? TITLE := 'unspecify_parameter', EJECT ??

    PROCEDURE [INLINE] unspecify_parameter
      (    parameter_number: clt$parameter_number);


      pvt^ [parameter_number].specified := FALSE;
      IF pvt^ [parameter_number].passing_method = clc$pass_by_value THEN
        pvt^ [parameter_number].value := NIL;
      ELSE
        pvt^ [parameter_number].variable := NIL;
        IF evaluation_context.procedure_parameters THEN
          clp$unpass_variable_parameter (parameter_number);
        IFEND;
      IFEND;

      CASE pdt.parameters^ [parameter_number].requirement OF
      = clc$required_parameter =
        required_parameters_checked := FALSE;
      = clc$optional_default_parameter, clc$confirm_default_parameter =
        parameter_defaults_evaluated := FALSE;
      ELSE
        ;
      CASEND;

      general_param_checks_performed := FALSE;

    PROCEND unspecify_parameter;
?? OLDTITLE, EJECT ??
*IFEND

    VAR
      local_status: ost$status,
      which_parameter: clt$which_parameter;


    status.normal := TRUE;
    local_status.normal := TRUE;

    parameter_defaults_evaluated := FALSE;
    required_parameters_checked := FALSE;
    check_procedure_called := FALSE;
    general_param_checks_performed := FALSE;
    save_source_of_expressions := evaluation_context.interpreter_mode = clc$help_mode;

  /evaluate/
    BEGIN
      IF ((pdt.header^.number_of_parameters = 0) AND (pvt <> NIL)) OR
            ((pdt.header^.number_of_parameters > 0) AND ((pvt = NIL) OR
            (UPPERBOUND (pvt^) <> pdt.header^.number_of_parameters))) THEN
        osp$set_status_condition (cle$bad_pvt, status);
        EXIT /evaluate/;
      IFEND;

      initialize_pvt;

*IF NOT $true(osv$unix)
      IF pdt.header^.number_of_parameters = 0 THEN
        dialog_control.prompted_for_parameter := NIL;
      ELSE
        PUSH dialog_control.prompted_for_parameter: [1 .. pdt.header^.number_of_parameters];
      IFEND;
      initialize_dialog_control;

      IF dialog_control.activated THEN
        ignore_terminate_breaks := FALSE;
        #SPOIL (ignore_terminate_breaks);
        osp$establish_condition_handler (^abort_handler, TRUE);
      IFEND;
*IFEND

      IF parse.unit_index < parse.index_limit THEN
        evaluate_parameters (TRUE, 1, parse, local_status);
        IF local_status.normal AND (NOT prompt_for_all_parameters) AND
              (pdt.header^.number_of_required_parameters > 0) AND (NOT required_parameters_checked) THEN
          check_required_parameters_given (which_parameter, local_status);
        IFEND;
      IFEND;

*IF NOT $true(osv$unix)
      IF prompt_for_all_parameters OR ((NOT local_status.normal) AND
            (dialog_control.interaction_style <> osc$line_interaction)) THEN
        CASE dialog_control.interaction_style OF
        = osc$line_interaction =
          IF local_status.normal AND (NOT (dialog_control.open AND dialog_control.terminator_in_reply)) THEN
            prompt_for_all_line_style (local_status);
          IFEND;
        = osc$screen_interaction =
          prompt_for_all_screen_style (local_status);
          dialog_control.interaction_style := osc$line_interaction;
          IF (NOT local_status.normal) AND (local_status.condition = cle$unable_to_call_parm_dlg_mgr) THEN
            local_status.normal := TRUE;
            prompt_for_all_line_style (local_status);
          IFEND;
        = osc$desktop_interaction =
          prompt_for_all_desktop_style (local_status);
          dialog_control.activated := FALSE;
        CASEND;
      IFEND;
*IFEND

      IF (NOT local_status.normal) OR (pdt.header^.number_of_parameters = 0) THEN
        EXIT /evaluate/;
      IFEND;

      IF (pdt.header^.number_of_required_parameters > 0) AND (NOT required_parameters_checked) THEN
        check_required_parameters_given (which_parameter, local_status);
        IF NOT local_status.normal THEN
          EXIT /evaluate/;
        IFEND;
      IFEND;

      IF NOT parameter_defaults_evaluated THEN
        evaluate_parameter_defaults (which_parameter, local_status);
        IF NOT local_status.normal THEN
          EXIT /evaluate/;
        IFEND;
      IFEND;

*IF NOT $true(osv$unix)
      IF (NOT general_param_checks_performed) AND (check_parameters_procedure <> NIL) THEN
        which_parameter.specific := FALSE;
        perform_parameter_checks (which_parameter, local_status);
      IFEND;
*IFEND
    END /evaluate/;

    IF status.normal AND (NOT local_status.normal) THEN
      status := local_status;
    IFEND;

*IF NOT $true(osv$unix)
    IF dialog_control.activated THEN
      close_dialog;
      osp$disestablish_cond_handler;
    IFEND;
*IFEND

  PROCEND clp$internal_evaluate_params;
?? TITLE := 'clp$unbundle_pdt', EJECT ??

  PROCEDURE [XDCL, #GATE] clp$unbundle_pdt
    (    parameter_description_table: ^clt$parameter_description_table;
     VAR work_area {input, output} : ^clt$work_area;
     VAR unbundled_pdt: clt$unbundled_pdt;
     VAR status: ost$status);

    VAR
      i: clt$parameter_number,
      pdt: ^clt$parameter_description_table,
*IF $true(osv$unix)
      kludge_type_spec: ^ array [*] of cell,
*IFEND
      type_specification: ^clt$type_specification;


    status.normal := TRUE;

  /ok/
    BEGIN
      IF parameter_description_table = NIL THEN
        EXIT /ok/;
      IFEND;
      pdt := parameter_description_table;
      RESET pdt;
      NEXT unbundled_pdt.header IN pdt;
      IF unbundled_pdt.header = NIL THEN
        EXIT /ok/;
      IFEND;

*IF NOT $true(osv$unix)
      IF unbundled_pdt.header^.version <> clc$declaration_version THEN
*ELSE
      IF (unbundled_pdt.header^.version < 1) OR
            (unbundled_pdt.header^.version > clc$declaration_version) THEN
*IFEND
        osp$set_status_condition (cle$bad_declaration_version, status);
        osp$append_status_integer (osc$status_parameter_delimiter, unbundled_pdt.header^.version, 10, FALSE,
              status);
        RETURN;
      IFEND;

      IF (unbundled_pdt.header^.number_of_parameter_names > clc$max_parameter_names) OR
            (unbundled_pdt.header^.number_of_parameters > unbundled_pdt.header^.number_of_parameter_names)
            THEN
        EXIT /ok/;
      IFEND;

      IF unbundled_pdt.header^.number_of_parameter_names = 0 THEN
        IF unbundled_pdt.header^.number_of_parameters <> 0 THEN
          EXIT /ok/;
        IFEND;
        unbundled_pdt.names := NIL;
        unbundled_pdt.parameters := NIL;
        unbundled_pdt.type_descriptions := NIL;
        unbundled_pdt.default_names := NIL;
        unbundled_pdt.default_values := NIL;
        RETURN;
      IFEND;

      IF unbundled_pdt.header^.number_of_parameters <= 0 THEN
        EXIT /ok/;
      IFEND;
      NEXT unbundled_pdt.names: [1 .. unbundled_pdt.header^.number_of_parameter_names] IN pdt;
      NEXT unbundled_pdt.parameters: [1 .. unbundled_pdt.header^.number_of_parameters] IN pdt;
      IF (unbundled_pdt.names = NIL) OR (unbundled_pdt.parameters = NIL) THEN
        EXIT /ok/;
      IFEND;
      NEXT unbundled_pdt.type_descriptions: [1 .. unbundled_pdt.header^.number_of_parameters] IN work_area;
      NEXT unbundled_pdt.default_names: [1 .. unbundled_pdt.header^.number_of_parameters] IN work_area;
      NEXT unbundled_pdt.default_values: [1 .. unbundled_pdt.header^.number_of_parameters] IN work_area;
      FOR i := 1 TO unbundled_pdt.header^.number_of_parameters DO
*IF NOT $true(osv$unix)
        NEXT type_specification: [[REP unbundled_pdt.parameters^ [i].type_specification_size OF cell]] IN pdt;
        NEXT unbundled_pdt.default_names^ [i]: [unbundled_pdt.parameters^ [i].default_name_size] IN pdt;
        NEXT unbundled_pdt.default_values^ [i]: [unbundled_pdt.parameters^ [i].default_value_size] IN pdt;
        IF (unbundled_pdt.default_names^ [i] = NIL) OR (unbundled_pdt.default_values^ [i] = NIL) THEN
          EXIT /ok/;
        IFEND;
*ELSE
        NEXT kludge_type_spec: [1 .. unbundled_pdt.parameters^ [i].type_specification_size] IN pdt;
        type_specification := #SEQ (kludge_type_spec^);
        NEXT unbundled_pdt.default_names^ [i]: [unbundled_pdt.parameters^ [i].default_name_size] IN pdt;
        NEXT unbundled_pdt.default_values^ [i]: [unbundled_pdt.parameters^ [i].default_value_size] IN pdt;
*IFEND
        clp$convert_type_spec_to_desc (type_specification, work_area, unbundled_pdt.type_descriptions^ [i],
              status);
        IF NOT status.normal THEN
          EXIT /ok/;
        IFEND;
      FOREND;

      RETURN;
    END /ok/;

    osp$set_status_condition (cle$bad_pdt, status);

  PROCEND clp$unbundle_pdt;
*IF NOT $true(osv$unix)
?? TITLE := 'clp$change_pdt', EJECT ??
*copyc clh$change_pdt

  PROCEDURE [XDCL, #GATE] clp$change_pdt
    (    parameter_description_table: ^clt$parameter_description_table;
         pdt_changes: clt$pdt_changes;
     VAR status: ost$status);

    VAR
      default_name: ^clt$variable_name_reference,
      default_values: ^array [1 .. * ] of ^clt$expression_text,
      header: ^clt$pdt_header,
      i: clt$parameter_number,
      names: ^clt$pdt_parameter_names,
      parameters: ^clt$pdt_parameters,
      pdt: ^clt$parameter_description_table,
      type_specifications: ^array [1 .. * ] of ^clt$type_specification;


    status.normal := TRUE;

  /ok/
    BEGIN
      IF parameter_description_table = NIL THEN
        EXIT /ok/;
      IFEND;
      pdt := parameter_description_table;
      RESET pdt;
      NEXT header IN pdt;
      IF header = NIL THEN
        EXIT /ok/;
      IFEND;

*IF NOT $true(osv$unix)
      IF header^.version <> clc$declaration_version THEN
*ELSE
      IF (header^.version < 1) OR (header^.version > clc$declaration_version) THEN
*IFEND
        osp$set_status_condition (cle$bad_declaration_version, status);
        osp$append_status_integer (osc$status_parameter_delimiter, header^.version, 10, FALSE, status);
        RETURN;
      IFEND;

      IF (header^.number_of_parameter_names > clc$max_parameter_names) OR
            (header^.number_of_parameters > header^.number_of_parameter_names) THEN
        EXIT /ok/;
      IFEND;

      IF header^.number_of_parameter_names = 0 THEN
        IF header^.number_of_parameters <> 0 THEN
          EXIT /ok/;
        IFEND;
        RETURN;
      IFEND;

      IF header^.number_of_parameters <= 0 THEN
        EXIT /ok/;
      IFEND;
      NEXT names: [1 .. header^.number_of_parameter_names] IN pdt;
      NEXT parameters: [1 .. header^.number_of_parameters] IN pdt;
      IF (names = NIL) OR (parameters = NIL) THEN
        EXIT /ok/;
      IFEND;
      PUSH type_specifications: [1 .. header^.number_of_parameters];
      PUSH default_values: [1 .. header^.number_of_parameters];
      FOR i := 1 TO header^.number_of_parameters DO
        NEXT type_specifications^ [i]: [[REP parameters^ [i].type_specification_size OF cell]] IN pdt;
        NEXT default_name: [parameters^ [i].default_name_size] IN pdt;
        NEXT default_values^ [i]: [parameters^ [i].default_value_size] IN pdt;
        IF (type_specifications^ [i] = NIL) OR (default_name = NIL) OR (default_values^ [i] = NIL) THEN
          EXIT /ok/;
        IFEND;
      FOREND;

      FOR i := 1 TO UPPERBOUND (pdt_changes) DO
        IF pdt_changes [i].number > header^.number_of_parameters THEN
          EXIT /ok/;
        IFEND;
        CASE pdt_changes [i].kind OF

        = clc$pdtc_availability =
          CASE parameters^ [pdt_changes [i].number].availability OF
          = clc$hidden_entry =
            header^.number_of_hidden_parameters := header^.number_of_hidden_parameters - 1;
          = clc$advanced_usage_entry =
            header^.number_of_advanced_parameters := header^.number_of_advanced_parameters - 1;
          ELSE
            ;
          CASEND;
          parameters^ [pdt_changes [i].number].availability := pdt_changes [i].availability;
          CASE parameters^ [pdt_changes [i].number].availability OF
          = clc$hidden_entry =
            header^.number_of_hidden_parameters := header^.number_of_hidden_parameters + 1;
          = clc$advanced_usage_entry =
            header^.number_of_advanced_parameters := header^.number_of_advanced_parameters + 1;
          ELSE
            ;
          CASEND;

        = clc$pdtc_security =
          parameters^ [pdt_changes [i].number].security := pdt_changes [i].security;

        = clc$pdtc_type =
          clp$change_type_specification (type_specifications^ [pdt_changes [i].number],
                pdt_changes [i].type_changes^, status);

        = clc$pdtc_default_value =
          default_values^ [pdt_changes [i].number]^ := pdt_changes [i].default_value^;

        = clc$pdtc_null =
          ;

        ELSE
          EXIT /ok/;
        CASEND;
      FOREND;

      RETURN;
    END /ok/;

    osp$set_status_condition (cle$bad_pdt, status);

  PROCEND clp$change_pdt;
?? TITLE := 'determine_prompting_style', EJECT ??

  PROCEDURE [INLINE] determine_prompting_style
    (    evaluation_context: clt$parameter_eval_context;
     VAR prompting_activated: boolean;
     VAR prompting_style: ost$interaction_style;
     VAR ignore_status: ost$status);

    VAR
      interactive_context: array [1 .. 1] of ift$fetch_context_attribute,
      scl_options: ^clt$scl_options;


    prompting_activated := FALSE;
    prompting_style := osc$line_interaction;

    IF evaluation_context.prompting_requested OR evaluation_context.interactive_origin THEN
      IF evaluation_context.prompting_requested OR
            (evaluation_context.interaction_style = osc$desktop_interaction) THEN
        prompting_activated := TRUE;
        prompting_style := evaluation_context.interaction_style;
      ELSE
        interactive_context [1].key := ifc$previous_mode;
        interactive_context [1].previous_mode := ifc$line;
        ifp$fetch_context (interactive_context, ignore_status);
        clp$find_scl_options (scl_options);
        IF interactive_context [1].previous_mode = ifc$screen THEN
          IF scl_options^.screen_style_correction_prompts.selected THEN
            prompting_activated := TRUE;
            prompting_style := osc$screen_interaction;
          IFEND;
        ELSE {ifc$line}
          IF scl_options^.line_style_correction_prompts.selected THEN
            prompting_activated := TRUE;
            prompting_style := scl_options^.line_style_correction_prompts.prompting_style;
          IFEND;
        IFEND;
      IFEND;
    IFEND;

  PROCEND determine_prompting_style;
*IFEND

MODEND clm$evaluate_parameters;
