?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Accounting and Validation: Make SCL data values.' ??
MODULE avm$make_scl_data_values;

{ PURPOSE:
{   This module contains the code used to construct the SCL data values for SCL function processors that
{   return the values for validation fields.
?? NEWTITLE := 'Global declarations referenced by this module.', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc avt$account_name
*copyc avt$date_time
*copyc avt$job_limit_information
*copyc avt$labeled_names_list
*copyc avt$name_list
*copyc avt$numeric_display_format
*copyc avt$project_name
*copyc avt$total_limit_information
*copyc cle$work_area_overflow
*copyc clt$work_area
*copyc osd$virtual_address
?? POP ??
*copyc clp$convert_string_to_file_ref
*copyc clp$make_boolean_value
*copyc clp$make_date_time_value
*copyc clp$make_file_value
*copyc clp$make_integer_value
*copyc clp$make_list_value
*copyc clp$make_name_value
*copyc clp$make_range_value
*copyc clp$make_real_value
*copyc clp$make_record_value
*copyc clp$make_string_value
*copyc clp$make_unspecified_value
*copyc osp$set_status_abnormal
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_acct_proj_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for an account project validation field.

  PROCEDURE [XDCL, #GATE] avp$make_acct_proj_scl_value
    (    account: avt$account_name;
         project: avt$project_name;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    status.normal := TRUE;

    clp$make_record_value (2, work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [1].name := 'ACCOUNT';
    clp$make_name_value (account, work_area, result^.field_values^ [1].value);
    IF result^.field_values^ [1].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [2].name := 'PROJECT';
    clp$make_name_value (project, work_area, result^.field_values^ [2].value);
    IF result^.field_values^ [2].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

  PROCEND avp$make_acct_proj_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_accum_limit_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for an accumulating limit validation field.

  PROCEDURE [XDCL, #GATE] avp$make_accum_limit_scl_value
    (    job_limit_information: avt$job_limit_information;
         total_limit_information: avt$total_limit_information;
         numeric_display_format: avt$numeric_display_format;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      display_radix: boolean,
      radix: 2 .. 16;

    status.normal := TRUE;

    IF numeric_display_format.kind = avc$integer_format THEN
      radix := numeric_display_format.radix;
      display_radix := numeric_display_format.display_radix;
    ELSE
      radix := 10;
      display_radix := FALSE;
    IFEND;

    clp$make_record_value (4, work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [1].name := 'JOB_WARNING_LIMIT';
    result^.field_values^ [2].name := 'JOB_MAXIMUM_LIMIT';
    result^.field_values^ [3].name := 'TOTAL_LIMIT';
    result^.field_values^ [4].name := 'TOTAL_ACCUMULATION';

    IF job_limit_information.job_limits_apply THEN
      clp$make_integer_value (job_limit_information.job_warning_limit, radix, display_radix, work_area,
            result^.field_values^ [1].value);
      IF result^.field_values^ [1].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;

      clp$make_integer_value (job_limit_information.job_maximum_limit, radix, display_radix, work_area,
            result^.field_values^ [2].value);
      IF result^.field_values^ [2].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;
    ELSE
      clp$make_unspecified_value (work_area, result^.field_values^ [1].value);
      IF result^.field_values^ [1].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;

      clp$make_unspecified_value (work_area, result^.field_values^ [2].value);
      IF result^.field_values^ [2].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;
    IFEND;

    IF total_limit_information.total_limit_applies THEN
      clp$make_integer_value (total_limit_information.total_limit, radix, display_radix, work_area,
            result^.field_values^ [3].value);
      IF result^.field_values^ [3].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;

      clp$make_integer_value (total_limit_information.total_accumulation, radix, display_radix, work_area,
            result^.field_values^ [4].value);
      IF result^.field_values^ [4].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;
    ELSE
      clp$make_unspecified_value (work_area, result^.field_values^ [3].value);
      IF result^.field_values^ [3].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;

      clp$make_unspecified_value (work_area, result^.field_values^ [4].value);
      IF result^.field_values^ [4].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;
    IFEND;

  PROCEND avp$make_accum_limit_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_capability_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a capability validation field.

  PROCEDURE [XDCL, #GATE] avp$make_capability_scl_value
    (    capability: boolean;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    status.normal := TRUE;

    clp$make_boolean_value (capability, clc$true_false_boolean, work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

  PROCEND avp$make_capability_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_date_time_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a date_time validation field.

  PROCEDURE [XDCL, #GATE] avp$make_date_time_scl_value
    (    date_time: avt$date_time;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      scl_date_time: clt$date_time;

    status.normal := TRUE;

    IF date_time.range THEN
      clp$make_range_value (work_area, result);
      IF result = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;

      scl_date_time.value := date_time.starting_value;
      scl_date_time.date_specified := date_time.date_specified;
      scl_date_time.time_specified := date_time.time_specified;
      clp$make_date_time_value (scl_date_time, work_area, result^.low_value);
      IF result^.low_value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;

      scl_date_time.value := date_time.ending_value;
      clp$make_date_time_value (scl_date_time, work_area, result^.high_value);
      IF result^.high_value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;
    ELSE
      scl_date_time.value := date_time.value;
      scl_date_time.date_specified := date_time.date_specified;
      scl_date_time.time_specified := date_time.time_specified;
      clp$make_date_time_value (scl_date_time, work_area, result);
      IF result = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      IFEND;
    IFEND;

  PROCEND avp$make_date_time_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_file_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a file validation field.

  PROCEDURE [XDCL, #GATE] avp$make_file_scl_value
    (    file_reference: fst$file_reference;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      parsed_file_reference: fst$parsed_file_reference;

    status.normal := TRUE;

    clp$convert_string_to_file_ref (file_reference, parsed_file_reference, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$make_file_value (parsed_file_reference.path (1, parsed_file_reference.complete_path_size), work_area,
          result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      RETURN;
    IFEND;

  PROCEND avp$make_file_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_integer_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for an integer validation field.

  PROCEDURE [XDCL, #GATE] avp$make_integer_scl_value
    (    integer_value: integer;
         numeric_display_format: avt$numeric_display_format;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      display_radix: boolean,
      radix: 2 .. 16;

    status.normal := TRUE;

    IF numeric_display_format.kind = avc$integer_format THEN
      radix := numeric_display_format.radix;
      display_radix := numeric_display_format.display_radix;
    ELSE
      radix := 10;
      display_radix := FALSE;
    IFEND;

    clp$make_integer_value (integer_value, radix, display_radix, work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      RETURN;
    IFEND;

  PROCEND avp$make_integer_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_job_class_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a job class validation field.

  PROCEDURE [XDCL, #GATE] avp$make_job_class_scl_value
    (    batch_default: ost$name;
         interactive_default: ost$name;
         job_class_list: avt$name_list;
         job_class_list_size: avt$name_list_size;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      index: avt$name_list_size,
      new_list_entry: ^clt$data_value,
      previous_list_entry: ^clt$data_value;

    status.normal := TRUE;

    clp$make_record_value (3, work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [1].name := 'BATCH_DEFAULT';
    clp$make_name_value (batch_default, work_area, result^.field_values^ [1].value);
    IF result^.field_values^ [1].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [2].name := 'INTERACTIVE_DEFAULT';
    clp$make_name_value (interactive_default, work_area, result^.field_values^ [2].value);
    IF result^.field_values^ [2].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [3].name := 'JOB_CLASSES';
    FOR index := 1 TO job_class_list_size DO
      clp$make_list_value (work_area, new_list_entry);
      IF new_list_entry = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      clp$make_name_value (job_class_list [index], work_area, new_list_entry^.element_value);
      IF new_list_entry^.element_value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      IF index = 1 THEN
        result^.field_values^ [3].value := new_list_entry;
        previous_list_entry := new_list_entry;
      ELSE
        previous_list_entry^.link := new_list_entry;
        previous_list_entry := new_list_entry;
      IFEND;
    FOREND;

  PROCEND avp$make_job_class_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_labeled_names_scl_valu', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a labeled names validation field.

  PROCEDURE [XDCL, #GATE] avp$make_labeled_names_scl_valu
    (    labeled_names: ^avt$labeled_names_list;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      index: avt$name_list_size,
      new_list_entry: ^clt$data_value,
      previous_list_entry: ^clt$data_value;

    status.normal := TRUE;

    FOR index := 1 TO UPPERBOUND (labeled_names^) DO
      clp$make_list_value (work_area, new_list_entry);
      IF new_list_entry = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      clp$make_record_value (2, work_area, new_list_entry^.element_value);
      IF new_list_entry^.element_value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      new_list_entry^.element_value^.field_values^ [1].name := 'LABEL';
      clp$make_name_value (labeled_names^ [index].label^, work_area,
            new_list_entry^.element_value^.field_values^ [1].value);
      IF new_list_entry^.element_value^.field_values^ [1].value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      new_list_entry^.element_value^.field_values^ [2].name := 'NAMES';
      avp$make_name_scl_value (labeled_names^ [index].names^,
            UPPERBOUND (labeled_names^ [index].names^), work_area,
            new_list_entry^.element_value^.field_values^ [2].value, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF index = 1 THEN
        result := new_list_entry;
      ELSE
        previous_list_entry^.link := new_list_entry;
      IFEND;
      previous_list_entry := new_list_entry;

    FOREND;

  PROCEND avp$make_labeled_names_scl_valu;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_limit_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a limit validation field.

  PROCEDURE [XDCL, #GATE] avp$make_limit_scl_value
    (    limit_value: integer;
         numeric_display_format: avt$numeric_display_format;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      display_radix: boolean,
      radix: 2 .. 16;

    status.normal := TRUE;

    IF numeric_display_format.kind = avc$integer_format THEN
      radix := numeric_display_format.radix;
      display_radix := numeric_display_format.display_radix;
    ELSE
      radix := 10;
      display_radix := FALSE;
    IFEND;

    clp$make_integer_value (limit_value, radix, display_radix, work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      RETURN;
    IFEND;

  PROCEND avp$make_limit_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_login_pw_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a login password validation field.

  PROCEDURE [XDCL, #GATE] avp$make_login_pw_scl_value
    (    expiration_date: ost$date_time;
         expiration_interval: pmt$time_increment;
         maximum_expiration_interval: pmt$time_increment;
         expiration_warning_interval: pmt$time_increment;
         expired_password_chg_interval: pmt$time_increment;
         change_date: ost$date_time;
         attribute_list: avt$name_list;
         attribute_list_size: avt$name_list_size;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      date_time: clt$date_time,
      index: avt$name_list_size,
      new_list_entry: ^clt$data_value,
      previous_list_entry: ^clt$data_value;

    status.normal := TRUE;

    clp$make_record_value (7, work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [1].name := 'EXPIRATION_DATE';
    date_time.value := expiration_date;
    date_time.date_specified := TRUE;
    date_time.time_specified := TRUE;
    clp$make_date_time_value (date_time, work_area, result^.field_values^ [1].value);
    IF result^.field_values^ [1].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [2].name := 'EXPIRATION_INTERVAL';
    clp$make_integer_value (expiration_interval.day, 10, FALSE, work_area, result^.field_values^ [2].value);
    IF result^.field_values^ [2].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [3].name := 'MAXIMUM_EXPIRATION_INTERVAL';
    clp$make_integer_value (maximum_expiration_interval.day, 10, FALSE, work_area,
          result^.field_values^ [3].value);
    IF result^.field_values^ [3].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [4].name := 'EXPIRATION_WARNING_INTERVAL';
    clp$make_integer_value (expiration_warning_interval.day, 10, FALSE, work_area,
          result^.field_values^ [4].value);
    IF result^.field_values^ [4].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [5].name := 'EXPIRED_PASSWORD_CHG_INTERVAL';
    clp$make_integer_value (expired_password_chg_interval.day, 10, FALSE, work_area, result^.
          field_values^ [5].value);
    IF result^.field_values^ [5].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [6].name := 'CHANGE_DATE';
    date_time.value := change_date;
    date_time.date_specified := TRUE;
    date_time.time_specified := TRUE;
    clp$make_date_time_value (date_time, work_area, result^.field_values^ [6].value);
    IF result^.field_values^ [6].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [7].name := 'ATTRIBUTES';
    FOR index := 1 TO attribute_list_size DO
      clp$make_list_value (work_area, new_list_entry);
      IF new_list_entry = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      clp$make_name_value (attribute_list [index], work_area, new_list_entry^.element_value);
      IF new_list_entry^.element_value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      IF index = 1 THEN
        result^.field_values^ [7].value := new_list_entry;
        previous_list_entry := new_list_entry;
      ELSE
        previous_list_entry^.link := new_list_entry;
        previous_list_entry := new_list_entry;
      IFEND;
    FOREND;

  PROCEND avp$make_login_pw_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_name_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a name validation field.

  PROCEDURE [XDCL, #GATE] avp$make_name_scl_value
    (    name_list: avt$name_list;
         name_list_size: avt$name_list_size;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    VAR
      index: avt$name_list_size,
      new_list_entry: ^clt$data_value,
      previous_list_entry: ^clt$data_value;

    status.normal := TRUE;

    FOR index := 1 TO name_list_size DO
      clp$make_list_value (work_area, new_list_entry);
      IF new_list_entry = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      clp$make_name_value (name_list [index], work_area, new_list_entry^.element_value);
      IF new_list_entry^.element_value = NIL THEN
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        RETURN;
      IFEND;

      IF index = 1 THEN
        result := new_list_entry;
        previous_list_entry := new_list_entry;
      ELSE
        previous_list_entry^.link := new_list_entry;
        previous_list_entry := new_list_entry;
      IFEND;
    FOREND;

  PROCEND avp$make_name_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_real_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a real validation field.

  PROCEDURE [XDCL, #GATE] avp$make_real_scl_value
    (    real_value: real;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    status.normal := TRUE;

    clp$make_real_value ($LONGREAL (real_value), UPPERVALUE (clt$real_number_digit_count), work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      RETURN;
    IFEND;

  PROCEND avp$make_real_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_ring_priv_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a ring privilege validation field.

  PROCEDURE [XDCL, #GATE] avp$make_ring_priv_scl_value
    (    minimum_ring: ost$ring;
         nominal_ring: ost$ring;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    status.normal := TRUE;

    clp$make_record_value (2, work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [1].name := 'MINIMUM_RING';
    clp$make_integer_value (minimum_ring, 10, FALSE, work_area, result^.field_values^ [1].value);
    IF result^.field_values^ [1].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

    result^.field_values^ [2].name := 'NOMINAL_RING';
    clp$make_integer_value (nominal_ring, 10, FALSE, work_area, result^.field_values^ [2].value);
    IF result^.field_values^ [2].value = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
    IFEND;

  PROCEND avp$make_ring_priv_scl_value;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] avp$make_string_scl_value', EJECT ??
{ PURPOSE:
{  Constructs an SCL data value for a string validation field.

  PROCEDURE [XDCL, #GATE] avp$make_string_scl_value
    (    string_value: ost$string;
     VAR work_area: ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

    status.normal := TRUE;

    clp$make_string_value (string_value.value (1, string_value.size), work_area, result);
    IF result = NIL THEN
      osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
      RETURN;
    IFEND;

  PROCEND avp$make_string_scl_value;
?? OLDTITLE ??
MODEND avm$make_scl_data_values;


