?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Logging : Periodic Statistics Management' ??
MODULE lgm$manage_periodic_stats;

{ PURPOSE:
{   Command utility to manage OS periodic statistics emission sets and the
{   statistics assigned to them.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clt$parameter_value
*copyc clt$utility_attributes
*copyc clt$utility_name
*copyc lge$condition_codes
*copyc nac$statistics_codes
*copyc osc$statistics
*copyc ost$data_id
*copyc ost$emission_sets
*copyc ost$name
*copyc sfd$type_declarations
?? POP ??
*copyc amp$close
*copyc amp$open
*copyc amp$put_next
*copyc clp$begin_utility
*copyc clp$convert_integer_to_string
*copyc clp$convert_string_to_integer
*copyc clp$end_include
*copyc clp$end_utility
*copyc clp$evaluate_parameters
*copyc clp$get_set_count
*copyc clp$get_value
*copyc clp$get_value_count
*copyc clp$include_file
*copyc clp$scan_parameter_list
*copyc clp$test_parameter
*copyc clp$trimmed_string_size
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$generate_message
*copyc osp$read_emission_sets
*copyc osp$release_manps_lock
*copyc osp$reserve_manps_lock
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc osp$status_condition_code
*copyc osp$status_condition_number
*copyc osp$write_emission_sets
*copyc pmp$exit
*copyc sfp$convert_stat_code_to_name
*copyc sfp$convert_stat_name_to_code

?? EJECT ??
?? TITLE := 'Global Variable Declarations' ??

  CONST
    lg_error_ident = 'LG',
    mps_utility_name = 'MPS_UTILITY                    ';

  VAR
    emission_sets_copy: array [ost$emission_set_names] of ost$emission_set := [REP $INTEGER (UPPERVALUE
      (ost$emission_set_names)) + 1 of [FALSE, [0, 0, 0, 23, 59, 59, 0 ],
      (23*3600+59*60+59)*100000,
      osc$max_emit_time, 0, * ]];

  VAR
    emission_set_labels: [READ] array [ost$emission_set_names] of string (20) := ['SET_1', 'SET_2', 'SET_3',
      'SET_4', 'IMMEDIATE_EMISSION'];

  VAR
    cleared_emission_set: [READ] ost$emission_set := [FALSE, [0, 0, 0, 23, 59, 59, 0 ],
      (23*3600+59*60+59)*100000,
      osc$max_emit_time, 0, * ];

  VAR
    emission_set_time_increment: pmt$time_increment;

  VAR
    emission_sets_modified: boolean := FALSE;

  VAR
    write_privilege_reserved: boolean := FALSE;

?? EJECT ??
?? TITLE := 'Secondary procedures' ??
?? NEWTITLE := 'assign_emission_set_id' ??

  PROCEDURE assign_emission_set_id (keyword: ost$name;
     VAR emission_set_id: ost$emission_set_names;
     VAR status: ost$status);

    IF (keyword = 'S1') OR (keyword = 'SET_1') THEN
      emission_set_id := osc$set_1;
    ELSEIF (keyword = 'S2') OR (keyword = 'SET_2') THEN
      emission_set_id := osc$set_2;
    ELSEIF (keyword = 'S3') OR (keyword = 'SET_3') THEN
      emission_set_id := osc$set_3;
    ELSEIF (keyword = 'S4') OR (keyword = 'SET_4') THEN
      emission_set_id := osc$set_4;
    ELSEIF (keyword = 'IE') OR (keyword = 'IMMEDIATE_EMISSION') THEN
      emission_set_id := osc$immediate_emission_set;
    ELSE
      status.normal := FALSE;
    IFEND;

  PROCEND assign_emission_set_id;

?? EJECT ??
?? TITLE := 'convert_to_stat_entry' ??

  PROCEDURE convert_to_stat_entry (stat_name: ost$name;
    VAR stat_entry: ost$stat_entry;
    VAR status: ost$status);

    VAR
      combined_statistic_code: sft$statistic_code,
      dummy_integer: clt$integer,
      error_string: string (132),
      length: integer;


    sfp$convert_stat_name_to_code (stat_name, combined_statistic_code, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF NOT (((combined_statistic_code >= nac$min_statistic) AND
          (combined_statistic_code <= nac$max_statistic)) OR
          ((combined_statistic_code >= osc$min_statistic) AND (combined_statistic_code <= osc$max_statistic)))
          THEN
      osp$set_status_abnormal (lg_error_ident, lge$incorrect_statistic, '', status);
      RETURN;
    IFEND;

    stat_entry.stat := combined_statistic_code;

    CASE stat_entry.stat OF
    = osc$swap_state_stats =
      stat_entry.from_index := jmc$iss_null;
      stat_entry.to_index := jmc$iss_null;
    ELSE
      stat_entry.first_index := osc$all_stats;
      stat_entry.second_index := osc$all_stats;
    CASEND;

  PROCEND convert_to_stat_entry;

  ?? EJECT ??
  ?? TITLE := 'format_emission_set' ??

  PROCEDURE format_emission_set (emission_set_id: ost$emission_set_names,
        output_file_id: amt$file_identifier;
    VAR status: ost$status);

    VAR
      stat: 1 .. osc$max_stats_in_set,
      stat_name: ost$name,
      line: string (80),
      line_loc: ^cell,
      length: integer,
      byte_address: amt$file_byte_address;

    line := '  ';
    line_loc := #LOC (line);
    amp$put_next (output_file_id, line_loc, 2, byte_address, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    STRINGREP (line, length, '      NAME            : ', emission_set_labels [emission_set_id]);
    amp$put_next (output_file_id, line_loc, length, byte_address, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF emission_sets_copy [emission_set_id].enabled THEN
      line := '      STATE           : ENABLED ';
    ELSE
      line := '      STATE           : DISABLED';
    IFEND;
    length := 32;
    amp$put_next (output_file_id, line_loc, length, byte_address, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    line := '';
    STRINGREP (line, length, '      PERIOD          : ',
          emission_sets_copy[emission_set_id].period.hour, ':',
          emission_sets_copy[emission_set_id].period.minute, ':',
          emission_sets_copy[emission_set_id].period.second);
    amp$put_next (output_file_id, line_loc, length, byte_address, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    line := '      STATISTICS LIST : ';
    IF emission_sets_copy [emission_set_id].stat_count = 0 THEN
      line (25, 22) := 'No statistics assigned';
      length := 46;
    ELSE
      sfp$convert_stat_code_to_name (emission_sets_copy [emission_set_id].stat_list [1].stat, stat_name,
            status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      line (25, *) := stat_name (1, clp$trimmed_string_size (stat_name));
      length := 24 + clp$trimmed_string_size(stat_name);
    IFEND;
    amp$put_next (output_file_id, line_loc, length, byte_address, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    IF emission_sets_copy [emission_set_id].stat_count > 1 THEN
      line (1, 24) := '                        ';
      FOR stat := 2 TO emission_sets_copy [emission_set_id].stat_count DO
        sfp$convert_stat_code_to_name (emission_sets_copy [emission_set_id].stat_list [stat].stat, stat_name,
              status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

        line (25, *) := stat_name (1, clp$trimmed_string_size (stat_name));
        length := 24 + clp$trimmed_string_size(stat_name);
        amp$put_next (output_file_id, line_loc, length, byte_address, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      FOREND;
    IFEND;

  PROCEND format_emission_set;
?? EJECT ??
?? OLDTITLE ??
?? TITLE := 'Subcommands' ??
?? EJECT ??
?? NEWTITLE := 'add_statistics' ??

  PROCEDURE add_statistics (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{          pdt add_stat_pdt (
{            emission_set,emission_sets,es: KEY ..
{            set_1,s1,..
{            set_2,s2,..
{            set_3,s3,..
{            set_4,s4,..
{            immediate_emission,ie = $required
{            statistic,statistics,s: LIST 1..osc$max_stats_in_set OF NAME = $required
{            status)

?? PUSH (LISTEXT := ON) ??

  VAR
    add_stat_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^add_stat_pdt_names,
      ^add_stat_pdt_params];

  VAR
    add_stat_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 7] of
      clt$parameter_name_descriptor := [['EMISSION_SET', 1], ['EMISSION_SETS', 1], ['ES', 1], ['STATISTIC', 2]
      , ['STATISTICS', 2], ['S', 2], ['STATUS', 3]];

  VAR
    add_stat_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of clt$parameter_descriptor := [

{ EMISSION_SET EMISSION_SETS ES }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [^add_stat_pdt_kv1, clc$keyword_value]],

{ STATISTIC STATISTICS S }
    [[clc$required], 1, osc$max_stats_in_set, 1, 1, clc$value_range_not_allowed, [NIL, clc$name_value, 1,
      osc$max_name_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

  VAR
    add_stat_pdt_kv1: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 10] of ost$name := ['SET_1','S1',
      'SET_2','S2','SET_3','S3','SET_4','S4','IMMEDIATE_EMISSION','IE'];

?? POP ??

    VAR
      emission_set_id: ost$emission_set_names,
      emission_set_name: clt$value,
      error_string: string (132),
      index: integer,
      length: integer,
      stat_entry: ost$stat_entry,
      statistic: clt$value,
      statistic_in_emission_set: boolean,
      statistic_set: 0 .. clc$max_value_sets,
      statistic_set_count: 0 .. clc$max_value_sets;

    IF NOT write_privilege_reserved THEN
      osp$set_status_condition (lge$write_privilege_required, status);
      RETURN;
    IFEND;

    clp$scan_parameter_list (parameter_list, add_stat_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('emission_set', 1, 1, clc$low, emission_set_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    assign_emission_set_id (emission_set_name.name.value, emission_set_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_set_count ('statistics', statistic_set_count, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    FOR statistic_set := 1 TO statistic_set_count DO
      clp$get_value ('statistics', statistic_set, 1, clc$low, statistic, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      convert_to_stat_entry (statistic.name.value, stat_entry, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      statistic_in_emission_set :=FALSE;
      /check_for_statistic/
      FOR index := 1 to emission_sets_copy[emission_set_id].stat_count DO
        IF emission_sets_copy[emission_set_id].stat_list[index].stat = stat_entry.stat THEN
          statistic_in_emission_set :=TRUE;
          EXIT /check_for_statistic/;
        IFEND;
      FOREND /check_for_statistic/;

      IF NOT statistic_in_emission_set THEN

        IF emission_sets_copy [emission_set_id].stat_count >= osc$max_stats_in_set THEN
          osp$set_status_abnormal (lg_error_ident, lge$emission_set_overflow, '', status);
          RETURN;
        IFEND;

        emission_sets_copy [emission_set_id].stat_count := emission_sets_copy [emission_set_id].stat_count
            + 1;
        emission_sets_copy [emission_set_id].stat_list [emission_sets_copy [emission_set_id].stat_count] :=
            stat_entry;

      IFEND;
    FOREND;
    emission_sets_modified := TRUE;

  PROCEND add_statistics;
?? EJECT ??
?? TITLE := 'delete_statistics' ??

  PROCEDURE delete_statistics (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{         PDT delete_stat_pdt (
{           emission_set,emission_sets,es: KEY ..
{           set_1,s1,..
{           set_2,s2,..
{           set_3,s3,..
{           set_4,s4,..
{           immediate_emission,ie = $required
{           statistic,statistics,s: LIST 1..osc$max_stats_in_set OF NAME OR KEY all = $required
{           status)

?? PUSH (LISTEXT := ON) ??

  VAR
    delete_stat_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^delete_stat_pdt_names,
      ^delete_stat_pdt_params];

  VAR
    delete_stat_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 7] of
      clt$parameter_name_descriptor := [['EMISSION_SET', 1], ['EMISSION_SETS', 1], ['ES', 1], ['STATISTIC', 2]
      , ['STATISTICS', 2], ['S', 2], ['STATUS', 3]];

  VAR
    delete_stat_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of clt$parameter_descriptor := [

{ EMISSION_SET EMISSION_SETS ES }
    [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [^delete_stat_pdt_kv1, clc$keyword_value]],

{ STATISTIC STATISTICS S }
    [[clc$required], 1, osc$max_stats_in_set, 1, 1, clc$value_range_not_allowed, [^delete_stat_pdt_kv2,
      clc$name_value, 1, osc$max_name_size]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
      clc$array_not_allowed, clc$status_value]]];

  VAR
    delete_stat_pdt_kv1: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 10] of ost$name := ['SET_1',
      'S1','SET_2','S2','SET_3','S3','SET_4','S4','IMMEDIATE_EMISSION','IE'];

  VAR
    delete_stat_pdt_kv2: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 1] of ost$name := ['ALL'];

?? POP ??

    VAR
      i: integer,
      statistic: clt$value,
      statistic_set,
      statistic_set_count: 0 .. clc$max_value_sets,
      statistic_set_value,
      statistic_set_value_count: 0 .. clc$max_values_per_set,
      stat_entry: ost$stat_entry,
      stat_line: 1 .. osc$max_stats_in_set,
      emission_set_name: clt$value,
      emission_set_id: ost$emission_set_names;

    IF NOT write_privilege_reserved THEN
      osp$set_status_condition (lge$write_privilege_required, status);
      RETURN;
    IFEND;

    clp$scan_parameter_list (parameter_list, delete_stat_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('emission_set', 1, 1, clc$low, emission_set_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    assign_emission_set_id (emission_set_name.name.value, emission_set_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_set_count ('statistics', statistic_set_count, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  /delete_stat_for/
    FOR statistic_set := 1 TO statistic_set_count DO
      clp$get_value ('statistics', statistic_set, 1, clc$low, statistic, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF statistic.name.value = 'ALL' THEN
        emission_sets_copy [emission_set_id].stat_count := 0;
      ELSE
        convert_to_stat_entry (statistic.name.value, stat_entry, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        FOR stat_line := 1 TO emission_sets_copy [emission_set_id].stat_count DO
          IF emission_sets_copy [emission_set_id].stat_list [stat_line].stat = stat_entry.stat THEN
            FOR i := stat_line TO emission_sets_copy [emission_set_id].stat_count - 1 DO
              emission_sets_copy [emission_set_id].stat_list [i] := emission_sets_copy [emission_set_id].
                    stat_list [i + 1];
            FOREND;
            emission_sets_copy [emission_set_id].stat_count := emission_sets_copy [emission_set_id].stat_count
                  - 1;
            CYCLE /delete_stat_for/;
          IFEND;
        FOREND;
      IFEND;
    FOREND /delete_stat_for/;
    emission_sets_modified := TRUE;

  PROCEND delete_statistics;
?? EJECT ??
?? TITLE := 'change_period' ??

  PROCEDURE change_period (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{   PROCEDURE change_period, chap (
{     emission_set, emission_sets, es: KEY
{       (set_1,s1)
{       (set_2,s2)
{       (set_3,s3)
{       (set_4,s4)
{     KEYEND = $required
{     period, p: (CHECK) ANY of
{       integer 1..osc$max_emit_time
{       time_increment
{     ANYEND = $required
{     status)

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 6] of clt$pdt_parameter_name,
        parameters: array [1 .. 3] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 8] of clt$keyword_specification,
        recend,
        type2: 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$integer_type_qualifier,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
          recend,
        recend,
        type3: record
          header: clt$type_specification_header,
        recend,
      recend := [[1, [88, 5, 17, 15, 47, 47, 288], clc$command, 6, 3, 2, 0, 0, 0, 3, 'CHAP'],
            [['EMISSION_SET                   ', clc$nominal_entry, 1],
            ['EMISSION_SETS                  ', clc$alias_entry, 1],
            ['ES                             ', clc$abbreviation_entry, 1],
            ['P                              ', clc$abbreviation_entry, 2],
            ['PERIOD                         ', clc$nominal_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, 303, clc$required_parameter, 0, 0],
{ PARAMETER 2
      [5, 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, 43, clc$required_parameter, 0, 0],
{ PARAMETER 3
      [6, 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$keyword_type], [8], [['S1                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['S2                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['S3                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['S4                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 4], ['SET_1                          ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['SET_2                          ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['SET_3                          ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['SET_4                          ', clc$nominal_entry,
            clc$normal_usage_entry, 4]]],
{ PARAMETER 2
      [[1, 0, clc$union_type], [[clc$integer_type, clc$time_increment_type], FALSE, 2], 20,
            [[1, 0, clc$integer_type], [1, osc$max_emit_time, 10]], 3, [[1, 0, clc$time_increment_type]]],
{ PARAMETER 3
      [[1, 0, clc$status_type]]];

?? POP ??

    CONST
      p$emission_set = 1,
      p$period = 2,
      p$status = 3;

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

?? NEWTITLE := 'check parameters for change_period subcommand', EJECT ??
{
{   This procedure is called by clp$evaluate_parameters.  It validates that
{   a time_increment period specifies only the hour, minute, and seconds
{   fields, and that a non-zero time_increment has been specified.
{

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

      IF which_parameter.specific AND (which_parameter.number = p$period) AND
            (pvt [p$period].value^.kind = clc$time_increment) THEN
        IF (pvt [p$period].value^.time_increment_value^.year <> 0) OR
              (pvt [p$period].value^.time_increment_value^.month <> 0) OR
              (pvt [p$period].value^.time_increment_value^.day <> 0) OR
              (pvt [p$period].value^.time_increment_value^.millisecond <> 0) THEN
          osp$set_status_abnormal (lg_error_ident, lge$incorrect_time_increment, '', status);
          RETURN;
        IFEND;
        IF (pvt [p$period].value^.time_increment_value^.hour = 0) AND
              (pvt [p$period].value^.time_increment_value^.minute = 0) AND
              (pvt [p$period].value^.time_increment_value^.second = 0) THEN
          osp$set_status_abnormal (lg_error_ident, lge$zero_period, '', status);
          RETURN;
        IFEND;
      IFEND;

    PROCEND check;
?? OLDTITLE, EJECT ??

    CONST
      microseconds_per_second = 1000000,
      microseconds_per_minute = microseconds_per_second * 60,
      microseconds_per_hour = microseconds_per_minute * 60;

    VAR
      emission_set_id: ost$emission_set_names;

    IF NOT write_privilege_reserved THEN
      osp$set_status_condition (lge$write_privilege_required, status);
      RETURN;
    IFEND;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), ^check, ^pvt, status);

    IF NOT status.normal THEN
      RETURN;
    IFEND;

    assign_emission_set_id (pvt [p$emission_set].value^.keyword_value, emission_set_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF pvt [p$period].value^.kind = clc$time_increment THEN
      emission_set_time_increment := pvt [p$period].value^.time_increment_value^;
    ELSE
      emission_set_time_increment.year := 0;
      emission_set_time_increment.month := 0;
      emission_set_time_increment.day := 0;
      emission_set_time_increment.hour := 0;
      emission_set_time_increment.minute := pvt [p$period].value^.integer_value.value;
      emission_set_time_increment.second := 0;
      emission_set_time_increment.millisecond := 0;
    IFEND;

    emission_sets_copy [emission_set_id].period := emission_set_time_increment;
    emission_sets_copy [emission_set_id].microsecond_period :=
             emission_sets_copy [emission_set_id].period.hour * microseconds_per_hour +
             emission_sets_copy [emission_set_id].period.minute * microseconds_per_minute +
             emission_sets_copy [emission_set_id].period.second * microseconds_per_second;
    emission_sets_modified := TRUE;

  PROCEND change_period;
?? EJECT ??
?? TITLE := 'change_state' ??

  PROCEDURE change_state (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{         pdt chas_pdt (
{             emission_set,emission_sets,es: KEY ..
{             set_1,s1,..
{             set_2,s2,..
{             set_3,s3,..
{             set_4,s4,..
{             immediate_emission,ie = $required
{             state,s: key enable,enabled,disable,disabled
{             status)

?? PUSH (LISTEXT := ON) ??

    VAR
      chas_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^chas_pdt_names, ^chas_pdt_params];

    VAR
      chas_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 6] of
        clt$parameter_name_descriptor := [['EMISSION_SET', 1], ['EMISSION_SETS', 1], ['ES', 1], ['STATE', 2],
        ['S', 2], ['STATUS', 3]];

    VAR
      chas_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of clt$parameter_descriptor := [

{ EMISSION_SET EMISSION_SETS ES }
      [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [^chas_pdt_kv1, clc$keyword_value]],

{ STATE S }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [^chas_pdt_kv2, clc$keyword_value]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
        clc$array_not_allowed, clc$status_value]]];

    VAR
      chas_pdt_kv1: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 10] of ost$name := ['SET_1', 'S1',
        'SET_2', 'S2', 'SET_3', 'S3', 'SET_4', 'S4', 'IMMEDIATE_EMISSION', 'IE'];

    VAR
      chas_pdt_kv2: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 4] of ost$name := ['ENABLE',
        'ENABLED', 'DISABLE', 'DISABLED'];

?? POP ??

    VAR
      emission_set_name: clt$value,
      emission_set_state: clt$value,
      emission_set_id: ost$emission_set_names;

    IF NOT write_privilege_reserved THEN
      osp$set_status_condition (lge$write_privilege_required, status);
      RETURN;
    IFEND;

    clp$scan_parameter_list (parameter_list, chas_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('emission_set', 1, 1, clc$low, emission_set_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    assign_emission_set_id (emission_set_name.name.value, emission_set_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('state', 1, 1, clc$low, emission_set_state, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF (emission_set_state.name.value = 'ENABLE') OR (emission_set_state.name.value = 'ENABLED') THEN
      emission_sets_copy [emission_set_id].enabled := TRUE;
    ELSE
      emission_sets_copy [emission_set_id].enabled := FALSE;
      emission_sets_copy [emission_set_id].next_emit_time := osc$max_emit_time;
    IFEND;
    emission_sets_modified := TRUE;

  PROCEND change_state;
?? EJECT ??
?? TITLE := 'display_emission_sets' ??

  PROCEDURE display_emission_sets (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{               pdt display_sets_pdt (
{                   emission_set,emission_sets,es: LIST OF KEY ..
{                   set_1,s1,..
{                   set_2,s2,..
{                   set_3,s3,..
{                   set_4,s4,..
{                   immediate_emission,ie,..
{                   all = all
{                   output,o: file = $OUTPUT
{                   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      display_sets_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^display_sets_pdt_names,
        ^display_sets_pdt_params];

    VAR
      display_sets_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 6] of
        clt$parameter_name_descriptor := [['EMISSION_SET', 1], ['EMISSION_SETS', 1], ['ES', 1], ['OUTPUT', 2],
        ['O', 2], ['STATUS', 3]];

    VAR
      display_sets_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of clt$parameter_descriptor
        := [

{ EMISSION_SET EMISSION_SETS ES }
      [[clc$optional_with_default, ^display_sets_pdt_dv1], 1, clc$max_value_sets, 1, 1,
        clc$value_range_not_allowed, [^display_sets_pdt_kv1, clc$keyword_value]],

{ OUTPUT O }
      [[clc$optional_with_default, ^display_sets_pdt_dv2], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL,
        clc$file_value]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
        clc$array_not_allowed, clc$status_value]]];

    VAR
      display_sets_pdt_kv1: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 11] of ost$name := [
        'SET_1', 'S1', 'SET_2', 'S2', 'SET_3', 'S3', 'SET_4', 'S4', 'IMMEDIATE_EMISSION', 'IE', 'ALL'];

    VAR
      display_sets_pdt_dv1: [STATIC, READ, cls$pdt_names_and_defaults] string (3) := 'all';

    VAR
      display_sets_pdt_dv2: [STATIC, READ, cls$pdt_names_and_defaults] string (7) := '$OUTPUT';

?? POP ??

    VAR
      line: string (80),
      line_loc: ^cell,
      length: integer,
      byte_address: amt$file_byte_address,
      i: 0 .. clc$max_value_sets,
      emission_set_name: clt$value,
      emission_set_id: ost$emission_set_names,
      emission_set_count: 0 .. clc$max_value_sets,
      output_file_id: amt$file_identifier,
      output_file: clt$value;

    clp$scan_parameter_list (parameter_list, display_sets_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('output', 1, 1, clc$low, output_file, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    amp$open (output_file.file.local_file_name, amc$record, NIL, output_file_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_set_count ('emission_sets', emission_set_count, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    line := '  ';
    line_loc := #LOC (line);
    amp$put_next (output_file_id, line_loc, 2, byte_address, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    line := '  EMISSION SET ATTRIBUTES  ';
    length := 27;
    amp$put_next (output_file_id, line_loc, length, byte_address, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    FOR i := 1 TO emission_set_count DO
      clp$get_value ('emission_sets', i, 1, clc$low, emission_set_name, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF emission_set_name.name.value = 'ALL' THEN
        FOR emission_set_id := LOWERVALUE (ost$emission_set_names) TO UPPERVALUE (ost$emission_set_names) DO
          format_emission_set (emission_set_id, output_file_id, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
        FOREND;
      ELSE
        assign_emission_set_id (emission_set_name.name.value, emission_set_id, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        format_emission_set (emission_set_id, output_file_id, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      IFEND;
    FOREND;

    amp$close (output_file_id, status);

  PROCEND display_emission_sets;
?? EJECT ??
?? TITLE := 'read_emission_sets' ??

  PROCEDURE read_emission_sets (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{       pdt read_sets_pdt (
{           emission_set,emission_sets,es: LIST OF KEY ..
{             set_1,s1,..
{             set_2,s2,..
{             set_3,s3,..
{             set_4,s4,..
{             immediate_emission,ie,..
{             all = $required
{             status)

?? PUSH (LISTEXT := ON) ??

    VAR
      read_sets_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^read_sets_pdt_names,
        ^read_sets_pdt_params];

    VAR
      read_sets_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 4] of
        clt$parameter_name_descriptor := [['EMISSION_SET', 1], ['EMISSION_SETS', 1], ['ES', 1], ['STATUS',
        2]];

    VAR
      read_sets_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of clt$parameter_descriptor := [

{ EMISSION_SET EMISSION_SETS ES }
      [[clc$required], 1, clc$max_value_sets, 1, 1, clc$value_range_not_allowed, [^read_sets_pdt_kv1,
        clc$keyword_value]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
        clc$array_not_allowed, clc$status_value]]];

    VAR
      read_sets_pdt_kv1: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 11] of ost$name := ['SET_1',
        'S1', 'SET_2', 'S2', 'SET_3', 'S3', 'SET_4', 'S4', 'IMMEDIATE_EMISSION', 'IE', 'ALL'];

?? POP ??

    VAR
      i: 0 .. clc$max_value_sets,
      emission_set_name: clt$value,
      emission_set_id: ost$emission_set_names,
      emission_set_count: 0 .. clc$max_value_sets,
      local_emission_sets_copy: array [ost$emission_set_names] of ost$emission_set;

    clp$scan_parameter_list (parameter_list, read_sets_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    osp$read_emission_sets (local_emission_sets_copy, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_set_count ('emission_sets', emission_set_count, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    FOR i := 1 TO emission_set_count DO
      clp$get_value ('emission_sets', i, 1, clc$low, emission_set_name, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF emission_set_name.name.value = 'ALL' THEN
        emission_sets_copy := local_emission_sets_copy;
      ELSE
        assign_emission_set_id (emission_set_name.name.value, emission_set_id, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

        emission_sets_copy [emission_set_id] := local_emission_sets_copy [emission_set_id];
      IFEND;
    FOREND;

  PROCEND read_emission_sets;
?? EJECT ??
?? TITLE := 'clear_emission_sets' ??

  PROCEDURE clear_emission_sets (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{       pdt clear_sets_pdt (
{           emission_set,emission_sets,es: LIST OF KEY ..
{             set_1,s1,..
{             set_2,s2,..
{             set_3,s3,..
{             set_4,s4,..
{             immediate_emission,ie,..
{             all = $required
{             status)

?? PUSH (LISTEXT := ON) ??

    VAR
      clear_sets_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^clear_sets_pdt_names,
        ^clear_sets_pdt_params];

    VAR
      clear_sets_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 4] of
        clt$parameter_name_descriptor := [['EMISSION_SET', 1], ['EMISSION_SETS', 1], ['ES', 1], ['STATUS',
        2]];

    VAR
      clear_sets_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 2] of clt$parameter_descriptor :=
        [

{ EMISSION_SET EMISSION_SETS ES }
      [[clc$required], 1, clc$max_value_sets, 1, 1, clc$value_range_not_allowed, [^clear_sets_pdt_kv1,
        clc$keyword_value]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
        clc$array_not_allowed, clc$status_value]]];

    VAR
      clear_sets_pdt_kv1: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 11] of ost$name := ['SET_1',
        'S1', 'SET_2', 'S2', 'SET_3', 'S3', 'SET_4', 'S4', 'IMMEDIATE_EMISSION', 'IE', 'ALL'];

?? POP ??

    VAR
      i: 0 .. clc$max_value_sets,
      emission_set_name: clt$value,
      emission_set_id: ost$emission_set_names,
      emission_set_count: 0 .. clc$max_value_sets;

    IF NOT write_privilege_reserved THEN
      osp$set_status_condition (lge$write_privilege_required, status);
      RETURN;
    IFEND;

    clp$scan_parameter_list (parameter_list, clear_sets_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_set_count ('emission_sets', emission_set_count, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    FOR i := 1 TO emission_set_count DO
      clp$get_value ('emission_sets', i, 1, clc$low, emission_set_name, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      IF emission_set_name.name.value = 'ALL' THEN
        FOR emission_set_id := LOWERVALUE (ost$emission_set_names) TO UPPERVALUE (ost$emission_set_names) DO
          emission_sets_copy [emission_set_id] := cleared_emission_set;
        FOREND;
      ELSE
        assign_emission_set_id (emission_set_name.name.value, emission_set_id, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;

        emission_sets_copy [emission_set_id] := cleared_emission_set;
      IFEND;
    FOREND;
    emission_sets_modified := TRUE;

  PROCEND clear_emission_sets;
  ?? EJECT ??
  ?? TITLE := 'end_mps' ??

  PROCEDURE end_mps (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{    PROCEDURE quit, qui (
{      write_emission_sets, wes: boolean = $optional
{      status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 3] 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,
      recend,
    recend := [
    [1,
    [89, 8, 22, 15, 28, 7, 528],
    clc$command, 3, 2, 0, 0, 0, 0, 2, ''], [
    ['STATUS                         ',clc$nominal_entry, 2],
    ['WES                            ',clc$abbreviation_entry, 1],
    ['WRITE_EMISSION_SETS            ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [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, 3, clc$optional_parameter, 0, 0],
{ PARAMETER 2
    [1, 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$boolean_type]],
{ PARAMETER 2
    [[1, 0, clc$status_type]]];

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

    CONST
      p$write_emission_sets = 1,
      p$status = 2;

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

    VAR
      ignore_status: ost$status;

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

    IF ((pvt[p$write_emission_sets].specified AND
          (pvt[p$write_emission_sets].value^.boolean_value.value = TRUE)) OR
          ((NOT pvt[p$write_emission_sets].specified) AND emission_sets_modified)) THEN
      osp$write_emission_sets (emission_sets_copy, status);
      IF NOT status.normal THEN
        osp$generate_message (status, ignore_status);
        status.normal := TRUE;
      IFEND;
    IFEND;

    clp$end_include (mps_utility_name, status);
    IF NOT status.normal THEN
      pmp$exit (status);
    IFEND;

  PROCEND end_mps;
  ?? EJECT ??
  ?? OLDTITLE ??
  ?? TITLE := 'Main Program' ??
  ?? NEWTITLE := '[XDCL, #GATE] lgp$manage_periodic_statistics' ??

  PROCEDURE [XDCL, #GATE] lgp$manage_periodic_statistics (parameter_list: clt$parameter_list;
    VAR status: ost$status);
?? NEWTITLE := 'abort_handler', EJECT ??

{ PURPOSE:
{   The purpose of this request is to release the osv$manps_user_lock if the
{   task terminates abnormally (i.e. without a QUIT command).

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

      osp$release_manps_lock;

    PROCEND abort_handler;
?? OLDTITLE, EJECT ??
{            pdt mps_pdt (
{                read_emission_sets,res: boolean = TRUE
{                reserve_write_privilege,rwp: boolean = TRUE
{                status)

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

  VAR
    mps_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table := [^mps_pdt_names, ^mps_pdt_params];

  VAR
    mps_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 5] of clt$parameter_name_descriptor
  := [['READ_EMISSION_SETS', 1], ['RES', 1], ['RESERVE_WRITE_PRIVILEGE', 2], ['RWP', 2], ['STATUS', 3]];

  VAR
    mps_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of clt$parameter_descriptor := [

{ READ_EMISSION_SETS RES }
    [[clc$optional_with_default, ^mps_pdt_dv1], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL,
  clc$boolean_value]],

{ RESERVE_WRITE_PRIVILEGE RWP }
    [[clc$optional_with_default, ^mps_pdt_dv2], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL,
  clc$boolean_value]],

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$variable_reference,
  clc$array_not_allowed, clc$status_value]]];

  VAR
    mps_pdt_dv1: [STATIC, READ, cls$pdt_names_and_defaults] string (4) := 'TRUE';

  VAR
    mps_pdt_dv2: [STATIC, READ, cls$pdt_names_and_defaults] string (4) := 'TRUE';

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

{ table mps_command_list t=c s=local
{ command (add_statistics,add_statistic,adds) add_statistics
{ command (delete_statistics,delete_statistic,dels) delete_statistics
{ command (change_period,chap) change_period
{ command (change_state,chas) change_state
{ command (display_emission_sets,display_emission_set,dises) display_emission_sets
{ command (read_emission_sets,read_emission_set,reaes) read_emission_sets
{ command (clear_emission_sets,clear_emission_set,clees) clear_emission_sets
{ command (quit,qui) end_mps
{ tablend

?? PUSH (LISTEXT := ON) ??

    VAR
      mps_command_list: [STATIC, READ] ^clt$command_table := ^mps_command_list_entries,

      mps_command_list_entries: [STATIC, READ] array [1 .. 21] of clt$command_table_entry := [
        {} ['ADDS                           ', clc$abbreviation_entry, clc$advertised_entry, 1,
        clc$automatically_log, clc$linked_call, ^add_statistics],
        {} ['ADD_STATISTIC                  ', clc$alias_entry, clc$advertised_entry, 1,
        clc$automatically_log, clc$linked_call, ^add_statistics],
        {} ['ADD_STATISTICS                 ', clc$nominal_entry, clc$advertised_entry, 1,
        clc$automatically_log, clc$linked_call, ^add_statistics],
        {} ['CHANGE_PERIOD                  ', clc$nominal_entry, clc$advertised_entry, 3,
        clc$automatically_log, clc$linked_call, ^change_period],
        {} ['CHANGE_STATE                   ', clc$nominal_entry, clc$advertised_entry, 4,
        clc$automatically_log, clc$linked_call, ^change_state],
        {} ['CHAP                           ', clc$abbreviation_entry, clc$advertised_entry, 3,
        clc$automatically_log, clc$linked_call, ^change_period],
        {} ['CHAS                           ', clc$abbreviation_entry, clc$advertised_entry, 4,
        clc$automatically_log, clc$linked_call, ^change_state],
        {} ['CLEAR_EMISSION_SET             ', clc$alias_entry, clc$advertised_entry, 7,
        clc$automatically_log, clc$linked_call, ^clear_emission_sets],
        {} ['CLEAR_EMISSION_SETS            ', clc$nominal_entry, clc$advertised_entry, 7,
        clc$automatically_log, clc$linked_call, ^clear_emission_sets],
        {} ['CLEES                          ', clc$abbreviation_entry, clc$advertised_entry, 7,
        clc$automatically_log, clc$linked_call, ^clear_emission_sets],
        {} ['DELETE_STATISTIC               ', clc$alias_entry, clc$advertised_entry, 2,
        clc$automatically_log, clc$linked_call, ^delete_statistics],
        {} ['DELETE_STATISTICS              ', clc$nominal_entry, clc$advertised_entry, 2,
        clc$automatically_log, clc$linked_call, ^delete_statistics],
        {} ['DELS                           ', clc$abbreviation_entry, clc$advertised_entry, 2,
        clc$automatically_log, clc$linked_call, ^delete_statistics],
        {} ['DISES                          ', clc$abbreviation_entry, clc$advertised_entry, 5,
        clc$automatically_log, clc$linked_call, ^display_emission_sets],
        {} ['DISPLAY_EMISSION_SET           ', clc$alias_entry, clc$advertised_entry, 5,
        clc$automatically_log, clc$linked_call, ^display_emission_sets],
        {} ['DISPLAY_EMISSION_SETS          ', clc$nominal_entry, clc$advertised_entry, 5,
        clc$automatically_log, clc$linked_call, ^display_emission_sets],
        {} ['QUI                            ', clc$abbreviation_entry, clc$advertised_entry, 9,
        clc$automatically_log, clc$linked_call, ^end_mps],
        {} ['QUIT                           ', clc$nominal_entry, clc$advertised_entry, 9,
        clc$automatically_log, clc$linked_call, ^end_mps],
        {} ['READ_EMISSION_SET              ', clc$alias_entry, clc$advertised_entry, 6,
        clc$automatically_log, clc$linked_call, ^read_emission_sets],
        {} ['READ_EMISSION_SETS             ', clc$nominal_entry, clc$advertised_entry, 6,
        clc$automatically_log, clc$linked_call, ^read_emission_sets],
        {} ['REAES                          ', clc$abbreviation_entry, clc$advertised_entry, 6,
        clc$automatically_log, clc$linked_call, ^read_emission_sets]];

?? POP ??

    VAR
      attributes: array [1 .. 4] of clt$utility_attribute,
      get_emission_sets: clt$value,
      reserve_write_privilege: clt$value;

    clp$scan_parameter_list (parameter_list, mps_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('read_emission_sets', 1, 1, clc$low, get_emission_sets, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('reserve_write_privilege', 1, 1, clc$low, reserve_write_privilege, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    IF get_emission_sets.bool.value THEN
      osp$read_emission_sets (emission_sets_copy, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

    IF reserve_write_privilege.bool.value THEN
      osp$establish_block_exit_hndlr (^abort_handler);
      osp$reserve_manps_lock (status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      write_privilege_reserved := TRUE;
    IFEND;

    attributes [1].key := clc$utility_command_search_mode;
    attributes [1].command_search_mode := clc$global_command_search;
    attributes [2].key := clc$utility_command_table;
    attributes [2].command_table := mps_command_list;
    attributes [3].key := clc$utility_function_table;
    attributes [3].function_table := NIL;
    attributes [4].key := clc$utility_prompt;
    attributes [4].prompt.size := 3;
    attributes [4].prompt.value := 'mps';

    clp$begin_utility (mps_utility_name, attributes, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$include_file (clc$current_command_input, '', mps_utility_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$end_utility (mps_utility_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    osp$release_manps_lock;
    osp$disestablish_cond_handler;

  PROCEND lgp$manage_periodic_statistics;
?? OLDTITLE ??
?? OLDTITLE ??
?? OLDTITLE ??
MODEND lgm$manage_periodic_statistics;
