?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE SCL Interpreter : PROC parameter accessing functions' ??
MODULE clm$parameter_access_functions;

{
{ PURPOSE:
{   This module contains the "built-in" functions used to access the parameters of an SCL PROC.
{

?? NEWTITLE := 'Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clt$value
*copyc cle$bad_data_value
*copyc cle$not_supported
*copyc cle$unexpected_value_type
*copyc clt$name
*copyc clt$work_area
*copyc clv$value_descriptors
*copyc oss$job_paged_literal
*copyc ost$status
?? POP ??
*copyc clp$evaluate_parameters
*copyc clp$get_proc_parameter
*copyc clp$get_proc_parameter_list
*copyc clp$get_proc_set_count
*copyc clp$get_proc_value_count
*copyc clp$get_proc_value_kind
*copyc clp$make_boolean_value
*copyc clp$make_integer_value
*copyc clp$make_string_value
*copyc clp$test_proc_parameter
*copyc clp$test_proc_range
*copyc osp$append_status_parameter
*copyc clp$append_status_value_type
*copyc osp$set_status_abnormal

?? TITLE := 'clp$$specified', EJECT ??

  PROCEDURE [XDCL] clp$$specified
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$specified) $specified (
{   parameter: data_name = $required
{   )

?? PUSH (LISTEXT := ON) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [87, 11, 8, 13, 23, 55, 445],
    clc$function, 1, 1, 1, 0, 0, 0, 0, 'OSM$$SPECIFIED'], [
    ['PARAMETER                      ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0]],
{ PARAMETER 1
    [[1, 0, clc$data_name_type]]];

?? POP ??

    CONST
      p$parameter = 1;

    VAR
      pvt: array [1 .. 1] of clt$parameter_value;

    VAR
      parameter_specified: boolean;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$test_proc_parameter (pvt [p$parameter].value^.data_name_value, parameter_specified, status);
    IF status.normal THEN
      clp$make_boolean_value (parameter_specified, clc$true_false_boolean, work_area, result);
    IFEND;

  PROCEND clp$$specified;
?? TITLE := 'clp$$set_count', EJECT ??

  PROCEDURE [XDCL] clp$$set_count
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$set_count) $set_count (
{   parameter: data_name = $required
{   )

?? PUSH (LISTEXT := ON) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [87, 11, 8, 13, 25, 57, 609],
    clc$function, 1, 1, 1, 0, 0, 0, 0, 'OSM$$SET_COUNT'], [
    ['PARAMETER                      ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0]],
{ PARAMETER 1
    [[1, 0, clc$data_name_type]]];

?? POP ??

    CONST
      p$parameter = 1;

    VAR
      pvt: array [1 .. 1] of clt$parameter_value;

    VAR
      value_set_count: 0 .. clc$max_value_sets;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$get_proc_set_count (pvt [p$parameter].value^.data_name_value, work_area, value_set_count, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$make_integer_value (value_set_count, 10, FALSE, work_area, result);

  PROCEND clp$$set_count;
?? TITLE := 'clp$$value_count', EJECT ??

  PROCEDURE [XDCL] clp$$value_count
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$value_count) $value_count (
{   parameter: data_name = $required
{   value_set_number: integer 1 .. clc$max_value_sets = 1
{   )

?? PUSH (LISTEXT := ON) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 2] of clt$pdt_parameter_name,
      parameters: array [1 .. 2] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
    recend := [
    [1,
    [87, 11, 8, 13, 28, 56, 295],
    clc$function, 2, 2, 1, 0, 0, 0, 0, 'OSM$$VALUE_COUNT'], [
    ['PARAMETER                      ',clc$nominal_entry, 1],
    ['VALUE_SET_NUMBER               ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1]],
{ PARAMETER 1
    [[1, 0, clc$data_name_type]],
{ PARAMETER 2
    [[1, 0, clc$integer_type], [1, clc$max_value_sets, 10],
    '1']];

?? POP ??

    CONST
      p$parameter = 1,
      p$value_set_number = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;

    VAR
      value_count: 0 .. clc$max_values_per_set;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$get_proc_value_count (pvt [p$parameter].value^.data_name_value,
          pvt [p$value_set_number].value^.integer_value.value, work_area, value_count, status);
    IF status.normal THEN
      clp$make_integer_value (value_count, 10, FALSE, work_area, result);
    IFEND;

  PROCEND clp$$value_count;
?? TITLE := 'clp$$range', EJECT ??

  PROCEDURE [XDCL] clp$$range
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$range) $range (
{   parameter: data_name = $required
{   value_set_number: integer 1 .. clc$max_value_sets = 1
{   value_number: integer 1 .. clc$max_values_per_set = 1
{   )

?? PUSH (LISTEXT := ON) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] of clt$pdt_parameter_name,
      parameters: array [1 .. 3] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
    recend := [
    [1,
    [87, 11, 8, 13, 32, 9, 876],
    clc$function, 3, 3, 1, 0, 0, 0, 0, 'OSM$$RANGE'], [
    ['PARAMETER                      ',clc$nominal_entry, 1],
    ['VALUE_NUMBER                   ',clc$nominal_entry, 3],
    ['VALUE_SET_NUMBER               ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 3
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1]],
{ PARAMETER 1
    [[1, 0, clc$data_name_type]],
{ PARAMETER 2
    [[1, 0, clc$integer_type], [1, clc$max_value_sets, 10],
    '1'],
{ PARAMETER 3
    [[1, 0, clc$integer_type], [1, clc$max_values_per_set, 10],
    '1']];

?? POP ??

    CONST
      p$parameter = 1,
      p$value_set_number = 2,
      p$value_number = 3;

    VAR
      pvt: array [1 .. 3] of clt$parameter_value;

    VAR
      range_specified: boolean;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$test_proc_range (pvt [p$parameter].value^.data_name_value,
          pvt [p$value_set_number].value^.integer_value.value, pvt [p$value_number].value^.integer_value.
          value, work_area, range_specified, status);
    IF status.normal THEN
      clp$make_boolean_value (range_specified, clc$true_false_boolean, work_area, result);
    IFEND;

  PROCEND clp$$range;
?? TITLE := 'clp$$value_kind', EJECT ??

  PROCEDURE [XDCL] clp$$value_kind
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);


{ FUNCTION (osm$$value_kind) $value_kind (
{   parameter: data_name = $required
{   value_set_number: integer 1 .. clc$max_value_sets = 1
{   value_number: integer 1 .. clc$max_values_per_set = 1
{   range_specification: key
{       low, high
{     keyend = low
{   )

?? PUSH (LISTEXT := ON) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 4] of clt$pdt_parameter_name,
      parameters: array [1 .. 4] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (1),
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 2] of clt$keyword_specification,
        default_value: string (3),
      recend,
    recend := [
    [1,
    [87, 11, 8, 13, 33, 5, 802],
    clc$function, 4, 4, 1, 0, 0, 0, 0, 'OSM$$VALUE_KIND'], [
    ['PARAMETER                      ',clc$nominal_entry, 1],
    ['RANGE_SPECIFICATION            ',clc$nominal_entry, 4],
    ['VALUE_NUMBER                   ',clc$nominal_entry, 3],
    ['VALUE_SET_NUMBER               ',clc$nominal_entry, 2]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0],
{ PARAMETER 2
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 3
    [3, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 20,
  clc$optional_default_parameter, 0, 1],
{ PARAMETER 4
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 81,
  clc$optional_default_parameter, 0, 3]],
{ PARAMETER 1
    [[1, 0, clc$data_name_type]],
{ PARAMETER 2
    [[1, 0, clc$integer_type], [1, clc$max_value_sets, 10],
    '1'],
{ PARAMETER 3
    [[1, 0, clc$integer_type], [1, clc$max_values_per_set, 10],
    '1'],
{ PARAMETER 4
    [[1, 0, clc$keyword_type], [2], [
    ['HIGH                           ', clc$nominal_entry, clc$normal_usage_entry, 2],
    ['LOW                            ', clc$nominal_entry, clc$normal_usage_entry, 1]]
    ,
    'low']];

?? POP ??

    CONST
      p$parameter = 1,
      p$value_set_number = 2,
      p$value_number = 3,
      p$range_specification = 4;

    VAR
      pvt: array [1 .. 4] of clt$parameter_value;

    VAR
      low_or_high: [STATIC, READ, oss$job_paged_literal] array [boolean] of
            clt$low_or_high := [clc$low, clc$high];


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$get_proc_value_kind (pvt [p$parameter].value^.data_name_value,
          pvt [p$value_set_number].value^.integer_value.value, pvt [p$value_number].value^.integer_value.
          value, low_or_high [pvt [p$range_specification].value^.keyword_value = 'HIGH'], work_area, result,
          status);

  PROCEND clp$$value_kind;
?? TITLE := 'clp$$parameter', EJECT ??

  PROCEDURE [XDCL] clp$$parameter
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$parameter) $parameter (
{   parameter: data_name = $required
{   )

?? PUSH (LISTEXT := ON) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [87, 11, 8, 13, 34, 3, 242],
    clc$function, 1, 1, 1, 0, 0, 0, 0, 'OSM$$PARAMETER'], [
    ['PARAMETER                      ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$required_parameter, 0
  , 0]],
{ PARAMETER 1
    [[1, 0, clc$data_name_type]]];

?? POP ??

    CONST
      p$parameter = 1;

    VAR
      pvt: array [1 .. 1] of clt$parameter_value;


    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF status.normal THEN
      clp$get_proc_parameter (pvt [p$parameter].value^.data_name_value, work_area, result, status);
    IFEND;

  PROCEND clp$$parameter;
?? TITLE := 'clp$$parameter_list', EJECT ??

  PROCEDURE [XDCL] clp$$parameter_list
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$parameter_list) $parameter_list

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
      recend := [[1, [87, 10, 20, 15, 4, 31, 353], clc$function, 0, 0, 0, 0, 0, 0, 0, 'OSM$$PARAMETER_LIST']];

?? POP ??

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);
    IF status.normal THEN
      clp$get_proc_parameter_list (work_area, result, status);
    IFEND;

  PROCEND clp$$parameter_list;

?? TITLE := 'clp$$max_value_sets', EJECT ??

  PROCEDURE [XDCL] clp$$max_value_sets
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$max_value_sets) $max_value_sets

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
      recend := [[1, [87, 10, 20, 15, 5, 56, 877], clc$function, 0, 0, 0, 0, 0, 0, 0, 'OSM$$MAX_VALUE_SETS']];

?? POP ??

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);
    IF status.normal THEN
      clp$make_integer_value (clc$max_value_sets, 10, FALSE, work_area, result);
    IFEND;

  PROCEND clp$$max_value_sets;

?? TITLE := 'clp$$max_values', EJECT ??

  PROCEDURE [XDCL] clp$$max_values
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$$max_values) $max_values

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
      recend := [[1, [87, 10, 20, 15, 6, 45, 741], clc$function, 0, 0, 0, 0, 0, 0, 0, 'OSM$$MAX_VALUES']];

?? POP ??

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);
    IF status.normal THEN
      clp$make_integer_value (clc$max_values_per_set, 10, FALSE, work_area, result);
    IFEND;

  PROCEND clp$$max_values;

MODEND clm$parameter_access_functions;
