?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE SCL Interpreter: Convert Value to String' ??
MODULE clm$convert_value_to_string ALIAS 'clmv2s';

{
{ PURPOSE:
{   This module contains the procedure that converts the internal representation of a command language
{   value to its string representation.
{

?? NEWTITLE := 'Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clt$value
*copyc cle$unknown_variable
*copyc clt$external_radix_spec
*copyc oss$job_paged_literal
*copyc ost$status
?? POP ??
*copyc clp$check_name_for_boolean
*copyc clp$convert_integer_to_string
*copyc clp$convert_real_to_string
*copyc clp$convert_to_ost$status
*copyc clp$get_path_name
*copyc clp$read_variable
*copyc clp$trimmed_string_size
*copyc osp$format_message

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

  PROCEDURE [XDCL, #GATE] clp$convert_value_to_string ALIAS 'clpcv2s'
    (    value: clt$value;
     VAR str: ost$string;
     VAR status: ost$status);

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

    status.normal := TRUE;
    external_radix_spec.override_radix_in_value := FALSE;
    clp$value_to_string (value, external_radix_spec, str, local_status);
    status := local_status;

  PROCEND clp$convert_value_to_string;
?? TITLE := 'clp$value_to_string', EJECT ??

  PROCEDURE [XDCL] clp$value_to_string
    (    value: clt$value;
         external_radix_spec: clt$external_radix_spec;
     VAR str: ost$string;
     VAR status: ost$status);

    VAR
      booleans: [STATIC, READ, oss$job_paged_literal] array [boolean] of array [clt$boolean_kinds] of record
        size: 2 .. 5,
        value: string (5),
      recend := [[{} [5, 'FALSE'], {} [2, 'NO   '], {} [3, 'OFF  ']],
            [{} [4, 'TRUE '], {} [3, 'YES  '], {} [2, 'ON   ']]];

?? NEWTITLE := 'convert_status_to_string', EJECT ??

    PROCEDURE convert_status_to_string
      (    status_value: ost$status;
       VAR str: ost$string;
       VAR status: ost$status);

      VAR
        message: ost$status_message,
        message_area: ^ost$status_message,
        message_line_count: ^ost$status_message_line_count,
        message_line_size: ^ost$status_message_line_size,
        message_line: ^string ( * );

      osp$format_message (status_value, osc$current_message_level, osc$max_string_size, message, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      message_area := ^message;
      RESET message_area;
      NEXT message_line_count IN message_area;
      IF message_line_count^ = 0 THEN
        str.size := 13;
        str.value := 'NORMAL STATUS';
        RETURN;
      IFEND;
      NEXT message_line_size IN message_area;
      NEXT message_line: [message_line_size^] IN message_area;
      str.size := message_line_size^;
      str.value := message_line^;
      IF (message_line_count^ = 1) OR (str.size > (osc$max_string_size - 2)) THEN
        RETURN;
      IFEND;
      str.value (str.size + 1, 2) := '..';
      str.size := str.size + 2;

    PROCEND convert_status_to_string;
?? TITLE := 'convert_variable_to_string', EJECT ??

    PROCEDURE convert_variable_to_string
      (    variable: clt$variable_reference;
       VAR str: ost$string;
       VAR status: ost$status);

      VAR
        boolean_kind: clt$boolean_kinds,
        radix: 2 .. 16,
        include_radix_specifier: boolean,
        status_value: ost$status,
        string_ptr: ^ost$string;

      status.normal := TRUE;
      IF variable.upper_bound > variable.lower_bound THEN
        str.size := 7 + variable.reference.size;
        str.value (1, 7) := 'ARRAY: ';
        str.value (8, * ) := variable.reference.value (1, variable.reference.size);
      ELSE
        CASE variable.value.kind OF
        = clc$string_value =
          string_ptr := #LOC (variable.value.string_value^ [1]);
          str.size := string_ptr^.size;
          str.value := string_ptr^.value (1, str.size);
        = clc$real_value =
          clp$convert_real_to_string (variable.value.real_value^ [1].value,
                variable.value.real_value^ [1].number_of_digits, str, status);
        = clc$integer_value =
          IF external_radix_spec.override_radix_in_value THEN
            radix := external_radix_spec.radix;
            include_radix_specifier := external_radix_spec.include_radix_specifier;
          ELSE
            radix := variable.value.integer_value^ [1].radix;
            include_radix_specifier := variable.value.integer_value^ [1].radix_specified;
          IFEND;
          clp$convert_integer_to_string (variable.value.integer_value^ [1].value, radix,
                include_radix_specifier, str, status);
        = clc$boolean_value =
          IF (LOWERVALUE (clt$boolean_kinds) <= variable.value.boolean_value^ [1].kind) AND
                (variable.value.boolean_value^ [1].kind <= UPPERVALUE (clt$boolean_kinds)) THEN
            boolean_kind := variable.value.boolean_value^ [1].kind;
          ELSE
            boolean_kind := clc$true_false_boolean;
          IFEND;
          str.size := booleans [variable.value.boolean_value^ [1].value = TRUE] [boolean_kind].size;
          str.value := booleans [variable.value.boolean_value^ [1].value = TRUE] [boolean_kind].value;
        = clc$status_value =
          clp$convert_to_ost$status (variable.value.status_value^ [1], status_value);
          convert_status_to_string (status_value, str, status);
        CASEND;
      IFEND;

    PROCEND convert_variable_to_string;
?? OLDTITLE, EJECT ??

    VAR
      boolean_kind: clt$boolean_kinds,
      radix: 2 .. 16,
      include_radix_specifier: boolean,
      file_reference: fst$path,
      variable: clt$variable_reference,
      bool: clt$boolean,
      name_is_boolean: boolean;

    status.normal := TRUE;
    CASE value.kind OF

    = clc$file_value =
      clp$get_path_name (value.file.local_file_name, osc$current_message_level, file_reference);
      str.value := file_reference;
      str.size := clp$trimmed_string_size (str.value);

    = clc$name_value =
      clp$check_name_for_boolean (value.name.value, bool, name_is_boolean);
      IF name_is_boolean THEN
        str.size := booleans [bool.value] [bool.kind].size;
        str.value := booleans [bool.value] [bool.kind].value;
      ELSE
        clp$read_variable (value.name.value, variable, status);
        IF status.normal THEN
          convert_variable_to_string (variable, str, status);
        ELSEIF status.condition = cle$unknown_variable THEN
          status.normal := TRUE;
          str.size := value.name.size;
          str.value := value.name.value;
        IFEND;
      IFEND;

    = clc$boolean_value =
      IF (LOWERVALUE (clt$boolean_kinds) <= value.bool.kind) AND
            (value.bool.kind <= UPPERVALUE (clt$boolean_kinds)) THEN
        boolean_kind := value.bool.kind;
      ELSE
        boolean_kind := clc$true_false_boolean;
      IFEND;
      str.size := booleans [value.bool.value = TRUE] [boolean_kind].size;
      str.value := booleans [value.bool.value = TRUE] [boolean_kind].value;

    = clc$integer_value =
      IF external_radix_spec.override_radix_in_value THEN
        radix := external_radix_spec.radix;
        include_radix_specifier := external_radix_spec.include_radix_specifier;
      ELSE
        radix := value.int.radix;
        include_radix_specifier := value.int.radix_specified;
      IFEND;
      clp$convert_integer_to_string (value.int.value, radix, include_radix_specifier, str, status);

    = clc$status_value =
      convert_status_to_string (value.status, str, status);

    = clc$unknown_value =
      str.size := 23;
      str.value := 'UNKNOWN VALUE.';

    = clc$variable_reference =
      convert_variable_to_string (value.var_ref, str, status);

    = clc$real_value =
      clp$convert_real_to_string (value.rnum.value, value.rnum.number_of_digits, str, status);

    = clc$string_value =
      str.size := value.str.size;
      str.value := value.str.value (1, value.str.size);

    = clc$application_value =
      str.size := STRLENGTH (value.descriptor);
      str.value := value.descriptor;
      WHILE (str.size > 0) AND (str.value (str.size) = ' ') DO
        str.size := str.size - 1;
      WHILEND;
      IF str.size = 0 THEN
        str.size := 18;
        str.value := 'APPLICATION VALUE.';
      IFEND;

    CASEND;

  PROCEND clp$value_to_string;

MODEND clm$convert_value_to_string;
