?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Accounting and Validation: Family Commands' ??
MODULE avm$family_commands;

{ PURPOSE:
{   This module contains the command processors for the commands used to
{   create, change, and display families.

{ DESIGN:
{   The command processors in this module simply convert the parameter values
{   specified on the command into their internal formats (when necessary) and call
{   the appropriate family program interface.(In AVM$FAMILY_INTERFACES)

?? PUSH (LISTEXT := ON) ??
?? NEWTITLE := 'Declarations', EJECT ??
*copyc avc$max_number_of_families
*copyc ave$family_errors
*copyc cle$all_must_be_used_alone
*copyc jmc$system_family
*copyc pme$program_services_exceptions
?? POP ??
?? OLDTITLE ??
?? NEWTITLE := 'XREF Procedures', EJECT ??
*copyc avp$change_family_interface
*copyc avp$create_family_interface
*copyc avp$system_administrator
*copyc avp$get_set_name
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_integer_to_string
*copyc clp$evaluate_parameters
*copyc clp$new_display_line
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$put_partial_display
*copyc clp$reset_for_next_display_page
*copyc dfp$get_served_family_names
*copyc dfp$get_server_state_string
*copyc dfp$locate_served_family
*copyc osp$set_status_abnormal
*copyc pmp$convert_binary_mainframe_id
*copyc pmp$get_family_names
?? OLDTITLE ??
?? NEWTITLE := 'avp$change_family_command', EJECT ??

{ PURPOSE:
{   This procedure is the command processor for the CHANGE_FAMILY command.

  PROCEDURE [XDCL,#GATE] avp$change_family_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$change_family) change_family, chaf (
{   family_name, fn: name = $required
{   new_family_name, nfn: name = $required
{   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 5] of clt$pdt_parameter_name,
        parameters: array [1 .. 3] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        type2: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        type3: record
          header: clt$type_specification_header,
        recend,
      recend := [[1, [88, 5, 18, 12, 21, 34, 978], clc$command, 5, 3, 2, 0, 0, 0, 3, 'OSM$CHANGE_FAMILY'],
            [['FAMILY_NAME                    ', clc$nominal_entry, 1],
            ['FN                             ', clc$abbreviation_entry, 1],
            ['NEW_FAMILY_NAME                ', clc$nominal_entry, 2],
            ['NFN                            ', clc$abbreviation_entry, 2],
            ['STATUS                         ', clc$nominal_entry, 3]], [

{ PARAMETER 1

      [1, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 5, clc$required_parameter, 0, 0],

{ PARAMETER 2

      [3, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 5, clc$required_parameter, 0, 0],

{ PARAMETER 3

      [5, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods [clc$specify_by_name],
            clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
            clc$optional_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$name_type], [1, osc$max_name_size]],

{ PARAMETER 2

      [[1, 0, clc$name_type], [1, osc$max_name_size]],

{ PARAMETER 3

      [[1, 0, clc$status_type]]];

?? POP ??

    CONST
      p$family_name = 1,
      p$new_family_name = 2,
      p$status = 3;

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

    status.normal := TRUE;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF pvt [p$family_name].value^.name_value <> jmc$system_family THEN
      avp$change_family_interface (pvt [p$family_name].value^.name_value,
            pvt [p$new_family_name].value^.name_value, status);
    ELSE
      osp$set_status_abnormal ('AV', ave$cannot_change_family, jmc$system_family, status);
    IFEND;

  PROCEND avp$change_family_command;
?? OLDTITLE ??
?? NEWTITLE := 'avp$create_family_command', EJECT ??

{ PURPOSE:
{   This procedure is the command processor for the CREATE_FAMILY command.

  PROCEDURE [XDCL,#GATE] avp$create_family_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$create_family) create_family, cref (
{   family_name, fn: name = $required
{   family_administrator, family_user_administrator, fua, fa: name = $required
{   account, account_name, an, a: name = ACCOUNT
{   project, pn, project_name, p: name = PROJECT
{   password, pw: (SECURE) name = PLEASE_CHANGE_THIS_PASSWORD_NOW
{   permanent_file_set, pfs: name = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 19] of clt$pdt_parameter_name,
      parameters: array [1 .. 7] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
        default_value: string (7),
      recend,
      type4: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
        default_value: string (7),
      recend,
      type5: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
        default_value: string (31),
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$name_type_qualifier,
      recend,
      type7: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [91, 1, 31, 13, 51, 50, 525],
    clc$command, 19, 7, 2, 0, 0, 0, 7, 'OSM$CREATE_FAMILY'], [
    ['A                              ',clc$abbreviation_entry, 3],
    ['ACCOUNT                        ',clc$nominal_entry, 3],
    ['ACCOUNT_NAME                   ',clc$alias_entry, 3],
    ['AN                             ',clc$alias_entry, 3],
    ['FA                             ',clc$abbreviation_entry, 2],
    ['FAMILY_ADMINISTRATOR           ',clc$nominal_entry, 2],
    ['FAMILY_NAME                    ',clc$nominal_entry, 1],
    ['FAMILY_USER_ADMINISTRATOR      ',clc$alias_entry, 2],
    ['FN                             ',clc$abbreviation_entry, 1],
    ['FUA                            ',clc$alias_entry, 2],
    ['P                              ',clc$abbreviation_entry, 4],
    ['PASSWORD                       ',clc$nominal_entry, 5],
    ['PERMANENT_FILE_SET             ',clc$nominal_entry, 6],
    ['PFS                            ',clc$abbreviation_entry, 6],
    ['PN                             ',clc$alias_entry, 4],
    ['PROJECT                        ',clc$nominal_entry, 4],
    ['PROJECT_NAME                   ',clc$alias_entry, 4],
    ['PW                             ',clc$abbreviation_entry, 5],
    ['STATUS                         ',clc$nominal_entry, 7]],
    [
{ PARAMETER 1
    [7, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 5, clc$required_parameter, 0, 0],
{ PARAMETER 2
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 5, clc$required_parameter, 0, 0],
{ PARAMETER 3
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 5, clc$optional_default_parameter, 0, 7],
{ PARAMETER 4
    [16, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 5, clc$optional_default_parameter, 0, 7],
{ PARAMETER 5
    [12, clc$normal_usage_entry, clc$secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 5, clc$optional_default_parameter, 0, 31],
{ PARAMETER 6
    [13, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 5, clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [19, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 2
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 3
    [[1, 0, clc$name_type], [1, osc$max_name_size],
    'ACCOUNT'],
{ PARAMETER 4
    [[1, 0, clc$name_type], [1, osc$max_name_size],
    'PROJECT'],
{ PARAMETER 5
    [[1, 0, clc$name_type], [1, osc$max_name_size],
    'PLEASE_CHANGE_THIS_PASSWORD_NOW'],
{ PARAMETER 6
    [[1, 0, clc$name_type], [1, osc$max_name_size]],
{ PARAMETER 7
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$family_name = 1,
      p$family_administrator = 2,
      p$account = 3,
      p$project = 4,
      p$password = 5,
      p$permanent_file_set = 6,
      p$status = 7;

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

    VAR
      permanent_file_set: ost$name;

    status.normal := TRUE;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF pvt [p$permanent_file_set].specified THEN
      permanent_file_set := pvt [p$permanent_file_set].value^.name_value;
    ELSE

{ A null permanent file set value specifes that the create family interface
{ should use the system default set name.

      permanent_file_set := osc$null_name;
    IFEND;

    avp$create_family_interface (pvt [p$family_name].value^.name_value,
          pvt [p$family_administrator].value^.name_value, pvt [p$account].value^.name_value,
          pvt [p$project].value^.name_value, pvt [p$password].value^.name_value, permanent_file_set, status);
    pvt [p$password].value^.name_value := osc$null_name;
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  PROCEND avp$create_family_command;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] avp$display_family_command', EJECT ??

{ PURPOSE:
{   This procedure is the command processor for the DISPLAY_FAMILY command.

  PROCEDURE [XDCL, #GATE] avp$display_family_command
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);


{ PROCEDURE (osm$display_family) display_family, display_families, disf (
{   family_name, fn: (CHECK) any of
{       key
{         all
{       keyend
{       list 1..999 of name
{     anyend = all
{   output, o: file = $output
{   display_option, display_options, do: key
{       (brief, b)
{       (full, f)
{     keyend = brief
{   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 8] of clt$pdt_parameter_name,
        parameters: array [1 .. 4] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
          qualifier: clt$union_type_qualifier,
          type_size_1: clt$type_specification_size,
          element_type_spec_1: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 1] of clt$keyword_specification,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
            qualifier: clt$list_type_qualifier,
            element_type_spec: record
              header: clt$type_specification_header,
              qualifier: clt$name_type_qualifier,
            recend,
          recend,
          default_value: string (3),
        recend,
        type2: record
          header: clt$type_specification_header,
          default_value: string (7),
        recend,
        type3: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 4] of clt$keyword_specification,
          default_value: string (5),
        recend,
        type4: record
          header: clt$type_specification_header,
        recend,
      recend := [[1, [88, 5, 18, 14, 20, 30, 675], clc$command, 8, 4, 0, 0, 0, 0, 4, 'OSM$DISPLAY_FAMILY'],
            [['DISPLAY_OPTION                 ', clc$nominal_entry, 3],
            ['DISPLAY_OPTIONS                ', clc$alias_entry, 3],
            ['DO                             ', clc$abbreviation_entry, 3],
            ['FAMILY_NAME                    ', clc$nominal_entry, 1],
            ['FN                             ', clc$abbreviation_entry, 1],
            ['O                              ', clc$abbreviation_entry, 2],
            ['OUTPUT                         ', clc$nominal_entry, 2],
            ['STATUS                         ', clc$nominal_entry, 4]], [

{ PARAMETER 1

      [4, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$extended_parameter_checking, 85, clc$optional_default_parameter, 0, 3],

{ PARAMETER 2

      [7, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_default_parameter, 0, 7],

{ PARAMETER 3

      [1, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 155, clc$optional_default_parameter, 0, 5],

{ PARAMETER 4

      [8, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods [clc$specify_by_name],
            clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
            clc$optional_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type], FALSE, 2], 44,
            [[1, 0, clc$keyword_type], [1], [['ALL                            ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]], 21, [[1, 0, clc$list_type],
            [5, 1, 999, FALSE], [[1, 0, clc$name_type], [1, osc$max_name_size]]], 'all'],

{ PARAMETER 2

      [[1, 0, clc$file_type], '$output'],

{ PARAMETER 3

      [[1, 0, clc$keyword_type], [4], [['B                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['BRIEF                          ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['F                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['FULL                           ', clc$nominal_entry,
            clc$normal_usage_entry, 2]], 'brief'],

{ PARAMETER 4

      [[1, 0, clc$status_type]]];

?? POP ??

    CONST
      p$family_name = 1,
      p$output = 2,
      p$display_option = 3,
      p$status = 4;

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

    VAR
      active_family_list: ^pmt$family_name_list,
      current_parameter_value: ^clt$data_value,
      display_control: clt$display_control,
      display_options_brief: boolean,
      family_counter: integer,
      file_contents: amt$file_contents,
      number_of_families: pmt$family_name_count,
      ring_attributes: amt$ring_attributes,
      served_family_found: boolean,
      server_mainframe_id: pmt$binary_mainframe_id,
      server_state: dft$server_state,
      set_name: stt$set_name;

*copy clv$display_variables
?? NEWTITLE := 'Dummy title because of error in clp$new_page_procedure' ??
*copyc clp$new_page_procedure

    PROCEDURE put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);

{ Dummy subtitle procedure

      status.normal := TRUE;

    PROCEND put_subtitle;
?? OLDTITLE ??
?? NEWTITLE := 'check_parameters', EJECT ??

    PROCEDURE check_parameters
      (    parameter_value_table: ^clt$parameter_value_table;
           which_parameter: clt$which_parameter;
       VAR status: ost$status);

      VAR
        current_parameter_value: ^clt$data_value,
        family_found: boolean,
        unused_smid: pmt$binary_mainframe_id,
        unused_ss: dft$server_state,
        set_name: stt$set_name;

      status.normal := TRUE;

{ Make sure the user has not specified ALL along with specific family names.

      IF (which_parameter.specific) AND (which_parameter.number = p$family_name) THEN
        IF parameter_value_table^ [p$family_name].value^.kind = clc$list THEN
          current_parameter_value := parameter_value_table^ [p$family_name].value;
          REPEAT
            IF current_parameter_value^.element_value^.name_value = 'ALL' THEN
              osp$set_status_abnormal ('AV', cle$all_must_be_used_alone, 'FAMILY_NAME', status);
              RETURN;
            ELSE
              avp$get_set_name (current_parameter_value^.element_value^.name_value, set_name, status);
              IF NOT status.normal THEN
                get_served_family_state (current_parameter_value^.element_value^.name_value,
                       family_found, unused_smid, unused_ss);
                IF NOT family_found THEN
                  RETURN;
                IFEND;
                status.normal := TRUE;
              IFEND;
            IFEND;
            current_parameter_value := current_parameter_value^.link;
          UNTIL current_parameter_value = NIL;
        IFEND;
      IFEND;

    PROCEND check_parameters;
?? OLDTITLE ??
?? NEWTITLE := 'display_family', EJECT ??

{ PURPOSE:
{   This procedure displays a specified family.

    PROCEDURE display_family
      (    display_options_brief: boolean;
           family_name: ost$family_name;
           set_name: stt$set_name;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

      VAR
        first: boolean;

      status.normal := TRUE;

      clp$put_partial_display (display_control, ' Family name:  ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, family_name, clc$no_trim, amc$terminate, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF NOT display_options_brief THEN
        clp$put_partial_display (display_control, '    Set Name:  ', clc$no_trim, amc$start, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        clp$put_partial_display (display_control, set_name, clc$no_trim, amc$terminate, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;

    PROCEND display_family;
?? OLDTITLE ??
?? NEWTITLE := 'display_served_family', EJECT ??

{ PURPOSE:
{   This procedure displays a specified served family.

    PROCEDURE display_served_family
      (    display_options_brief: boolean;
           family_name: ost$family_name;
           server_mainframe_id: pmt$binary_mainframe_id;
           server_state: dft$server_state;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

      VAR
        mainframe_id: pmt$mainframe_id,
        server_state_string: string (17);

      status.normal := TRUE;

      clp$put_partial_display (display_control, ' Served Family Name:  ', clc$no_trim, amc$start, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      clp$put_partial_display (display_control, family_name, clc$no_trim, amc$terminate, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      IF NOT display_options_brief THEN
        clp$put_partial_display (display_control, '    Mainframe Name:  ', clc$no_trim, amc$start, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        pmp$convert_binary_mainframe_id (server_mainframe_id, mainframe_id, status);
        clp$put_partial_display (display_control, mainframe_id, clc$no_trim, amc$terminate, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        dfp$get_server_state_string (server_state, server_state_string);
        clp$put_partial_display (display_control, '    Server State:  ', clc$no_trim, amc$start, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        clp$put_partial_display (display_control, server_state_string, clc$no_trim, amc$terminate, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

      IFEND;

    PROCEND display_served_family;
?? OLDTITLE ??
?? NEWTITLE := 'get_served_family_state', EJECT ??

    PROCEDURE get_served_family_state
      (    family_name: ost$family_name;
       VAR family_found: boolean;
       VAR server_mainframe_id: pmt$binary_mainframe_id;
       VAR server_state: dft$server_state);

      VAR
        served_family_table_index: dft$served_family_table_index,
        p_queue_interface_table: dft$p_queue_interface_table,
        queue_index: dft$queue_index;

      family_found := FALSE;
      dfp$locate_served_family (family_name, family_found, served_family_table_index,
             server_mainframe_id, p_queue_interface_table, queue_index, server_state);
    PROCEND get_served_family_state;
?? OLDTITLE, EJECT ??
    status.normal := TRUE;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), ^check_parameters, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF (pvt [p$display_option].value^.keyword_value = 'BRIEF') THEN
      display_options_brief := TRUE;
    ELSE
      display_options_brief := FALSE;
    IFEND;

{ Open the output file.

    clv$titles_built := FALSE;
    clv$command_name := 'display_family';
    ring_attributes.r1 := #RING (^ring_attributes);
    ring_attributes.r2 := #RING (^ring_attributes);
    ring_attributes.r3 := #RING (^ring_attributes);
    file_contents := amc$list;

    clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, file_contents,
          ring_attributes, display_control, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

{ If ALL families specifed retrieve a list of all families then display them.

    IF pvt [p$family_name].value^.kind = clc$keyword THEN {ALL specified}

{ Allocate space to hold a reasonable number of family names.
{ Try to place the current families into this list.
{ If they do not fit allocate space for the actual number of families
{ returned by the get family names call and retry.

      number_of_families := 100;
      REPEAT
        PUSH active_family_list: [1 .. number_of_families];
        pmp$get_family_names (active_family_list^, number_of_families, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      UNTIL number_of_families <= UPPERBOUND (active_family_list^);

      FOR family_counter := 1 TO number_of_families DO
        avp$get_set_name (active_family_list^ [family_counter], set_name, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        display_family (display_options_brief, active_family_list^ [family_counter], set_name,
              display_control, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      FOREND;

      /get_served_families/
      REPEAT
        dfp$get_served_family_names (active_family_list^, number_of_families, status);
        IF NOT status.normal THEN
          IF status.condition = pme$result_array_too_small THEN
            PUSH active_family_list: [1 .. number_of_families];
            CYCLE /get_served_families/;
          ELSE
            RETURN;
          IFEND;
        IFEND;
      UNTIL number_of_families <= UPPERBOUND (active_family_list^);

      /display_served_families/
      FOR family_counter := 1 TO number_of_families DO
        get_served_family_state (active_family_list^ [family_counter],
               served_family_found, server_mainframe_id, server_state);
        IF NOT served_family_found THEN
          CYCLE /display_served_families/;
        IFEND;
        display_served_family (display_options_brief, active_family_list^ [family_counter],
               server_mainframe_id, server_state, display_control, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      FOREND /display_served_families/;

    ELSE

{ Display the specified families.

      current_parameter_value := pvt [p$family_name].value;
      REPEAT
        avp$get_set_name (current_parameter_value^.element_value^.name_value, set_name, status);
        IF NOT status.normal THEN
          get_served_family_state (current_parameter_value^.element_value^.name_value,
                 served_family_found, server_mainframe_id, server_state);
          IF served_family_found THEN
            display_served_family (display_options_brief,
                   current_parameter_value^.element_value^.name_value,
                   server_mainframe_id, server_state, display_control, status);
            IF NOT status.normal THEN
              RETURN;
            IFEND;
          ELSE
            RETURN;
          IFEND;
        ELSE
          display_family (display_options_brief, current_parameter_value^.element_value^.name_value, set_name,
                display_control, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        IFEND;
        current_parameter_value := current_parameter_value^.link;
      UNTIL current_parameter_value = NIL;
    IFEND;

    clp$close_display (display_control, status);

  PROCEND avp$display_family_command;
?? OLDTITLE ??
MODEND avm$family_commands;

