
?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Screen Formatting: Process Variable' ??
MODULE fdm$process_variable;

{ PURPOSE:
{   This module creates, changes, and gets data about a form variable definition.
{
{ DESIGN:
{   All changes to a variable definition must be valid before the stored variable
{   definition is changed.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??

?? PUSH (LISTEXT := ON) ??
*copyc cyd$run_time_error_condition
*copyc fde$condition_identifiers
*copyc fdc$im_smart_capability
*copyc fdc$integer_length
*copyc fdc$real_length
*copyc fdc$system_input_format
*copyc fdc$system_io_mode
*copyc fdc$system_occurrence
*copyc fdc$system_unknown_entry
*copyc fdc$message_variable_length
*copyc fdt$comment_index
*copyc fdt$form_object_definition
*copyc fdt$form_objects
*copyc fdt$get_variable_attributes
*copyc fdt$object_attributes
*copyc fdt$object_definition
*copyc fdt$table_variable_index
*copyc fdt$valid_integer_index
*copyc fdt$valid_real_index
*copyc fdt$valid_string_index
*copyc fdt$variable_attribute_index
*copyc fdt$variable_attributes
*copyc ost$name
?? POP ??

*copyc clp$validate_name
*copyc fdp$add_comment
*copyc fdp$change_currency_symbols
*copyc fdp$create_cobol_description
*copyc fdp$find_change_form_definition
*copyc fdp$find_form_definition
*copyc fdp$find_object_definition
*copyc fdp$find_table_definition
*copyc fdp$find_variable_definition
*copyc fdp$get_message
*copyc fdp$locate_added_variable_facts
*copyc fdp$locate_variable_comments
*copyc fdp$ptr_comments
*copyc fdp$ptr_text
*copyc fdp$ptr_valid_integers
*copyc fdp$ptr_valid_reals
*copyc fdp$ptr_valid_strings
*copyc fdp$ptr_variable
*copyc fdp$ptr_variables
*copyc fdp$rel_comments
*copyc fdp$rel_text
*copyc fdp$rel_valid_integers
*copyc fdp$rel_valid_reals
*copyc fdp$rel_valid_strings
*copyc fdp$rel_variable
*copyc fdp$rel_variables
*copyc fdp$validate_name
*copyc i#move
*copyc pmp$continue_to_cause
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$disestablish_cond_handler
*copyc osp$establish_condition_handler
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition

?? TITLE := 'Global Declarations Declared by This Module', EJECT ??

  CONST
    fdc$valid_ranges_to_expand = 2,
    fdc$valid_strings_to_expand = 5,
    fdc$variables_to_expand = 7;

?? TITLE := 'fdp$change_variable', EJECT ??
*copyc fdh$change_variable

  PROCEDURE [XDCL] fdp$change_variable
    (    form_identifier: fdt$form_identifier;
         variable_name: ost$name;
     VAR variable_attributes: fdt$variable_attributes;
     VAR status: ost$status);

    VAR
      additional_definitions: fdt$additional_definitions,
      name_exists: boolean,
      name_is_valid: boolean,
      form_variable_definition: fdt$form_variable_definition,
      p_form_definition: ^fdt$form_definition,
      p_form_status: ^fdt$form_status,
      p_form_variable_definition: ^fdt$form_variable_definition,
      p_new_added_variable_definition:^fdt$added_variable_definition,
      p_new_sequence: ^SEQ (*),
      p_old_added_variable_definition:^fdt$added_variable_definition,
      p_old_sequence: ^SEQ (*),
      valid_name: ost$name,
      variable_index: fdt$variable_index;

?? NEWTITLE := 'condition_handler', EJECT ??

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

      CASE condition.selector OF

      = pmc$system_conditions =
        IF (condition.system_conditions * $pmt$system_conditions
              [pmc$instruction_specification, pmc$address_specification, pmc$access_violation,
              pmc$invalid_segment_ring_0, pmc$divide_fault, pmc$arithmetic_overflow, pmc$exponent_overflow,
              pmc$exponent_underflow, pmc$fp_significance_loss, pmc$fp_indefinite,
              pmc$arithmetic_significance, pmc$invalid_bdp_data]) <> $pmt$system_conditions [] THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT fdp$change_variable;
        IFEND;

      = pmc$user_defined_condition =
        IF condition.user_condition_name = cye$run_time_condition THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT fdp$change_variable;
        IFEND;

      ELSE
        ;
      CASEND;
      pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
    PROCEND condition_handler;

?? OLDTITLE, EJECT ??
    osp$establish_condition_handler (^condition_handler, FALSE);

    FOR variable_index := LOWERBOUND (variable_attributes) TO UPPERBOUND (variable_attributes) DO
      variable_attributes [variable_index].put_value_status := fdc$unprocessed_put_value;
    FOREND;

    fdp$find_change_form_definition (form_identifier, p_form_status, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    p_form_definition := p_form_status^.p_form_definition;
    fdp$validate_name (variable_name, p_form_definition^.processor, valid_name, name_is_valid);
    IF NOT name_is_valid THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_name, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

    fdp$find_variable_definition (valid_name, p_form_status^.p_form_variable_definitions,
          p_form_definition^.form_variable_definitions.active_number, p_form_variable_definition,
          variable_index, name_exists);
    IF NOT name_exists THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$unknown_variable_name, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

{ Makes changes to copy of variable definition.
{ All changes must be valid before any changes are made to original version.
{ Copy the additional area of form variable definition so that changes do not affect
{ the orginal.

    form_variable_definition := p_form_variable_definition^;
    NEXT p_new_sequence: [[REP #SIZE(fdt$added_variable_definition) OF cell]] IN
          p_form_status^.p_form_module;
    IF p_new_sequence = NIL THEN
      osp$set_status_condition (fde$no_space_available, status);
      RETURN;
    IFEND;

    RESET p_new_sequence;
    NEXT p_new_added_variable_definition IN p_new_sequence;
    form_variable_definition.additional_variable_facts.additional_definitions :=
          #REL (p_new_sequence, p_form_status^.p_form_module^);
    fdp$locate_added_variable_facts (p_form_status^.p_form_module, p_form_variable_definition,
          p_old_added_variable_definition);
    p_new_added_variable_definition^ := p_old_added_variable_definition^;

    change_variable (p_form_status, p_form_definition, ^form_variable_definition, variable_attributes,
          status);
    IF status.normal THEN

{ The changes are all good. Move the new form variable definition to the old one.
{ The new variable definition points to the new additional area for the form variable definition.

      p_form_variable_definition^ := form_variable_definition;
    IFEND;

  PROCEND fdp$change_variable;

?? TITLE := 'fdp$create_variable', EJECT ??
*copyc fdh$create_variable

  PROCEDURE [XDCL] fdp$create_variable
    (    form_identifier: fdt$form_identifier;
         variable_name: ost$name;
     VAR variable_attributes: fdt$variable_attributes;
     VAR status: ost$status);

    VAR
      additional_definitions: fdt$additional_definitions,
      display_attribute_set: fdt$display_attribute_set,
      form_variable_definition: fdt$form_variable_definition,
      name_exists: boolean,
      name_is_valid: boolean,
      p_added_variable_definition: ^fdt$added_variable_definition,
      p_form_definition: ^fdt$form_definition,
      p_form_object_definition: ^fdt$form_object_definition,
      p_form_status: ^fdt$form_status,
      p_form_table_definition: ^fdt$form_table_definition,
      p_form_variable_definition: ^fdt$form_variable_definition,
      p_sequence: ^SEQ ( * ),
      table_index: fdt$table_index,
      valid_name: ost$name,
      variable_index: fdt$variable_index;

?? NEWTITLE := 'allocate_variable', EJECT ??

    PROCEDURE allocate_variable
      (VAR p_form_variable_definition: ^fdt$form_variable_definition);

      VAR
        i: fdt$variable_index,
        number_variables: fdt$number_variables,
        p_new_variable_definitions: ^array [1 .. * ] of fdt$form_variable_definition,
        p_old_variable_definitions: ^array [1 .. * ] of fdt$form_variable_definition;

      status.normal := TRUE;
      p_old_variable_definitions := p_form_status^.p_form_variable_definitions;
      IF p_old_variable_definitions = NIL THEN
        NEXT p_new_variable_definitions: [1 .. fdc$variables_to_expand] IN p_form_status^.p_form_module;
        IF p_new_variable_definitions = NIL THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
          RETURN;
        IFEND;

        fdp$rel_variables (p_new_variable_definitions, p_form_status);
        p_form_variable_definition := ^p_new_variable_definitions^ [1];
        p_form_definition^.form_variable_definitions.active_number := 1;
        RETURN;
      IFEND;

{ Minimize allocates/deallocates of tables.
{ An array for variables exists. Try to find an inactive entry.

      number_variables := p_form_definition^.form_variable_definitions.active_number;
      IF number_variables < p_form_definition^.form_variable_definitions.total_number THEN
        number_variables := number_variables + 1;
        p_form_definition^.form_variable_definitions.active_number := number_variables;
        p_form_variable_definition := ^p_old_variable_definitions^ [number_variables];
        RETURN;

      IFEND;

{ Expand the array for variables.

      NEXT p_new_variable_definitions: [1 .. fdc$variables_to_expand + number_variables] IN
            p_form_status^.p_form_module;
      IF p_new_variable_definitions = NIL THEN
        osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
        RETURN;
      IFEND;

{ Copy old variables to new array.

      FOR i := 1 TO number_variables DO
        p_new_variable_definitions^ [i] := p_old_variable_definitions^ [i];
      FOREND;

      fdp$rel_variables (p_new_variable_definitions, p_form_status);
      number_variables := number_variables + 1;
      p_form_definition^.form_variable_definitions.active_number := number_variables;
      p_form_variable_definition := ^p_new_variable_definitions^ [number_variables];

    PROCEND allocate_variable;

?? OLDTITLE ??
?? NEWTITLE := 'condition_handler', EJECT ??

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

      CASE condition.selector OF

      = pmc$system_conditions =
        IF (condition.system_conditions * $pmt$system_conditions
              [pmc$instruction_specification, pmc$address_specification, pmc$access_violation,
              pmc$invalid_segment_ring_0, pmc$divide_fault, pmc$arithmetic_overflow, pmc$exponent_overflow,
              pmc$exponent_underflow, pmc$fp_significance_loss, pmc$fp_indefinite,
              pmc$arithmetic_significance, pmc$invalid_bdp_data]) <> $pmt$system_conditions [] THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT fdp$create_variable;
        IFEND;

      = pmc$user_defined_condition =
        IF condition.user_condition_name = cye$run_time_condition THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT fdp$create_variable;
        IFEND;

      ELSE
        ;
      CASEND;
      pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
    PROCEND condition_handler;

?? OLDTITLE, EJECT ??
    osp$establish_condition_handler (^condition_handler, FALSE);
    status.normal := TRUE;

{ Initialize all attributes as unprocessed so that user can determine what
{ attributes were processed when an abnormal condition occurs.

    FOR variable_index := LOWERBOUND (variable_attributes) TO UPPERBOUND (variable_attributes) DO
      variable_attributes [variable_index].put_value_status := fdc$unprocessed_put_value;
    FOREND;

    fdp$find_change_form_definition (form_identifier, p_form_status, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    p_form_definition := p_form_status^.p_form_definition;
    fdp$validate_name (variable_name, p_form_definition^.processor, valid_name, name_is_valid);
    IF NOT name_is_valid THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_name, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

{ The new variable name must not currently exist as a variable or table name.

    fdp$find_variable_definition (valid_name, p_form_status^.p_form_variable_definitions,
          p_form_definition^.form_variable_definitions.active_number, p_form_variable_definition,
          variable_index, name_exists);
    IF name_exists THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$variable_name_exists, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

    fdp$find_table_definition (valid_name, p_form_status^.p_form_table_definitions,
          p_form_definition^.form_table_definitions.active_number, p_form_table_definition, table_index,
          name_exists);
    IF name_exists THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$variable_name_exists, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

{ Set default definitions for the variable.

    form_variable_definition.error_displays := $fdt$display_attribute_set [fdc$inverse_video];
    form_variable_definition.error_definition.key := fdc$no_error_response;
    form_variable_definition.help_definition.key := fdc$no_help_response;
    form_variable_definition.input_format.key := fdc$system_input_format;
    form_variable_definition.io_mode := fdc$system_io_mode;
    form_variable_definition.name := valid_name;
    form_variable_definition.object_exists := FALSE;
    form_variable_definition.output_format.key := fdc$character_output_format;
    form_variable_definition.program_data_type := fdc$program_upper_case_type;
    form_variable_definition.program_variable_length := 0;
    form_variable_definition.process_as_event := FALSE;
    form_variable_definition.table_exists := FALSE;
    form_variable_definition.terminal_user_entry := $fdt$terminal_user_entry [fdc$entry_optional];
    form_variable_definition.screen_variable_length := 0;
    form_variable_definition.unknown_entry_character := fdc$system_unknown_entry;
    form_variable_definition.valid := FALSE;
    form_variable_definition.valid_integer_ranges.total_number := 0;
    form_variable_definition.valid_integer_ranges.active_number := 0;
    form_variable_definition.valid_real_ranges.total_number := 0;
    form_variable_definition.valid_real_ranges.active_number := 0;
    form_variable_definition.valid_strings.total_number := 0;
    form_variable_definition.valid_strings.active_number := 0;
    form_variable_definition.valid_strings.compare_in_upper_case := FALSE;
    form_variable_definition.valid_strings.compare_to_unique_substring := FALSE;

{ Initialize additional area of data for form variable definition. The additional
{ area contains data for supporting COBOL PICTURE, USAGE, and SIGN clauses introduced
{ by the IM_SMART_ENHANCEMENT feature.  Form definitions with a version less than
{ fdc$im_smart_capability do not have an additional area for the form variable definition.
{ The comment field of the form variable definition is replaced by a pointer to
{ to the additional area. The additional area also contains data previously contained in
{ in the comment field.

    NEXT p_sequence: [[REP #SIZE(fdt$added_variable_definition) OF cell]] IN
          p_form_status^.p_form_module;
    IF p_sequence = NIL THEN
      osp$set_status_abnormal (fdc$format_display_identifier,
           fde$no_space_available, '', status);
      RETURN;
    IFEND;

    RESET p_sequence;
    NEXT p_added_variable_definition IN p_sequence;
    form_variable_definition.additional_variable_facts.additional_definitions :=
          #REL(p_sequence, p_form_status^.p_form_module^);
    p_added_variable_definition^.comment_definitions.active_number := 0;
    p_added_variable_definition^.comment_definitions.total_number := 0;
    p_added_variable_definition^.form_cobol_display_clause.defined := FALSE;
    p_added_variable_definition^.form_cobol_program_clause.defined := FALSE;

{ Set user definitions for the variable.

    change_variable (p_form_status, p_form_definition, ^form_variable_definition, variable_attributes,
          status);

{ If all attributes for the variable are valid, then save the new variable definition.
{ Otherwise, no new variable definition exists.  Before the form is saved on a object code library
{the form is copied.  The copy removes all unused space due to bad definitions.

    IF NOT status.normal THEN
      RETURN;
    IFEND;

    allocate_variable (p_form_variable_definition);
    IF status.normal THEN
      p_form_variable_definition^ := form_variable_definition;
    IFEND;
  PROCEND fdp$create_variable;

?? TITLE := 'fdp$delete_variable', EJECT ??
*copyc fdh$delete_variable

  PROCEDURE [XDCL] fdp$delete_variable
    (    form_identifier: fdt$form_identifier;
         variable_name: ost$name;
     VAR status: ost$status);

    VAR
      name_exists: boolean,
      name_is_valid: boolean,
      p_form_definition: ^fdt$form_definition,
      p_form_status: ^fdt$form_status,
      p_form_variable_definition: ^fdt$form_variable_definition,
      p_form_variable_definitions: ^array [1 .. * ] of fdt$form_variable_definition,
      valid_name: ost$name,
      variable_index: fdt$variable_index;

?? NEWTITLE := 'condition_handler', EJECT ??

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

      CASE condition.selector OF

      = pmc$system_conditions =
        IF (condition.system_conditions * $pmt$system_conditions
              [pmc$instruction_specification, pmc$address_specification, pmc$access_violation,
              pmc$invalid_segment_ring_0, pmc$divide_fault, pmc$arithmetic_overflow, pmc$exponent_overflow,
              pmc$exponent_underflow, pmc$fp_significance_loss, pmc$fp_indefinite,
              pmc$arithmetic_significance, pmc$invalid_bdp_data]) <> $pmt$system_conditions [] THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT fdp$delete_variable;
        IFEND;

      = pmc$user_defined_condition =
        IF condition.user_condition_name = cye$run_time_condition THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT fdp$delete_variable;
        IFEND;

      ELSE
        ;
      CASEND;
      pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
    PROCEND condition_handler;

?? OLDTITLE, EJECT ??

    osp$establish_condition_handler (^condition_handler, FALSE);
    fdp$find_change_form_definition (form_identifier, p_form_status, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    p_form_definition := p_form_status^.p_form_definition;
    p_form_variable_definitions := p_form_status^.p_form_variable_definitions;
    fdp$validate_name (variable_name, p_form_definition^.processor, valid_name, name_is_valid);
    IF NOT name_is_valid THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_name, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

    p_form_variable_definitions := p_form_status^.p_form_variable_definitions;
    fdp$find_variable_definition (valid_name, p_form_variable_definitions,
          p_form_definition^.form_variable_definitions.active_number, p_form_variable_definition,
          variable_index, name_exists);
    IF NOT name_exists THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$unknown_variable_name, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

{ Delete variable by moving last defined variable to location occupied by deleted variable
{ and reducing the number of active variables by one.

    p_form_variable_definitions^ [variable_index] := p_form_variable_definitions^
          [p_form_definition^.form_variable_definitions.active_number];
    p_form_definition^.form_variable_definitions.active_number :=
          p_form_definition^.form_variable_definitions.active_number - 1;

  PROCEND fdp$delete_variable;

?? TITLE := 'fdp$get_variable_attributes', EJECT ??
*copyc fdh$get_variable_attributes

  PROCEDURE [XDCL] fdp$get_variable_attributes
    (    form_identifier: fdt$form_identifier;
         variable_name: ost$name;
     VAR get_variable_attributes: fdt$get_variable_attributes;
     VAR status: ost$status);

    VAR
      additional_definitions:  fdt$additional_definitions,
      comment_definitions: fdt$comment_definitions,
      comment_index: fdt$comment_index,
      current_comment_index: fdt$comment_index,
      current_comment_length_index: fdt$comment_index,
      current_integer_index: fdt$valid_integer_index,
      current_real_index: fdt$valid_real_index,
      current_string_index: fdt$valid_string_index,
      current_string_length_index: fdt$valid_string_index,
      initial_value_key: fdt$program_data_type,
      n: fdt$variable_attribute_index,
      name_exists: boolean,
      name_is_valid: boolean,
      number_display: fdt$number_object_displays,
      number_valid_integers: fdt$number_valid_integers,
      number_valid_reals: fdt$number_valid_reals,
      number_valid_strings: fdt$number_valid_strings,
      number_var_comments: fdt$number_comments,
      p_added_variable_definition: ^fdt$added_variable_definition,
      p_comment: ^fdt$comment,
      p_comment_definition: ^fdt$comment_definition,
      p_comment_definitions: ^array [1 .. * ] of fdt$comment_definition,
      p_error_message: ^fdt$error_message,
      p_form_definition: ^fdt$form_definition,
      p_form_module: ^fdt$form_module,
      p_form_status: ^fdt$form_status,
      p_form_variable_definition: ^fdt$form_variable_definition,
      p_help_message: ^fdt$help_message,
      p_sequence: ^SEQ (*),
      p_text: ^fdt$text,
      p_valid_integer_range: ^fdt$valid_integer_range,
      p_valid_integer_ranges: ^array [1 .. * ] of fdt$valid_integer_range,
      p_valid_real_range: ^fdt$valid_real_range,
      p_valid_real_ranges: ^array [1 .. * ] of fdt$valid_real_range,
      p_valid_string_definition: ^fdt$valid_string_definition,
      p_valid_string: ^fdt$valid_string,
      p_valid_strings: ^array [1 .. * ] of fdt$valid_string_definition,
      valid_integer_index: fdt$valid_integer_index,
      valid_name: ost$name,
      valid_real_index: fdt$valid_real_index,
      valid_string_index: fdt$valid_string_index,
      variable_index: fdt$variable_index;

?? NEWTITLE := 'condition_handler', EJECT ??

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

      CASE condition.selector OF

      = pmc$system_conditions =
        IF (condition.system_conditions * $pmt$system_conditions
              [pmc$instruction_specification, pmc$address_specification, pmc$access_violation,
              pmc$invalid_segment_ring_0, pmc$divide_fault, pmc$arithmetic_overflow, pmc$exponent_overflow,
              pmc$exponent_underflow, pmc$fp_significance_loss, pmc$fp_indefinite,
              pmc$arithmetic_significance, pmc$invalid_bdp_data]) <> $pmt$system_conditions [] THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT fdp$get_variable_attributes;
        IFEND;

      = pmc$user_defined_condition =
        IF condition.user_condition_name = cye$run_time_condition THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT fdp$get_variable_attributes;
        IFEND;

      ELSE
        ;
      CASEND;
      pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
    PROCEND condition_handler;

?? OLDTITLE, EJECT ??
    osp$establish_condition_handler (^condition_handler, FALSE);
    status.normal := TRUE;

{ Initialize all attributes as unprocessed so user can determined processed attributes
{ if an abnormal condition occurs.

    FOR n := LOWERBOUND (get_variable_attributes) TO UPPERBOUND (get_variable_attributes) DO
      get_variable_attributes [n].get_value_status := fdc$unprocessed_get_value;
    FOREND;

    fdp$find_form_definition (form_identifier, p_form_status, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    p_form_definition := p_form_status^.p_form_definition;
    fdp$validate_name (variable_name, p_form_definition^.processor, valid_name, name_is_valid);
    IF NOT name_is_valid THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_name, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

    fdp$find_variable_definition (valid_name, p_form_status^.p_form_variable_definitions,
          p_form_definition^.form_variable_definitions.active_number, p_form_variable_definition,
          variable_index, name_exists);
    IF NOT name_exists THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$unknown_variable_name, variable_name,
            status);
      osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
      RETURN;
    IFEND;

    p_form_module := p_form_status^.p_form_module;
    fdp$locate_variable_comments (p_form_status, p_form_variable_definition, comment_definitions);
    p_valid_integer_ranges := fdp$ptr_valid_integers (p_form_variable_definition^.valid_integer_ranges,
          p_form_module);
    p_valid_real_ranges := fdp$ptr_valid_reals (p_form_variable_definition^.valid_real_ranges, p_form_module);
    p_valid_strings := fdp$ptr_valid_strings (p_form_variable_definition^.valid_strings, p_form_module);
    p_comment_definitions := fdp$ptr_comments (comment_definitions, p_form_module);
    current_comment_index := 1;
    current_comment_length_index := 1;
    current_integer_index := 1;
    current_real_index := 1;
    current_string_index := 1;
    current_string_length_index := 1;

  /process_variable_attributes/
    FOR n := LOWERBOUND (get_variable_attributes) TO UPPERBOUND (get_variable_attributes) DO
      CASE get_variable_attributes [n].key OF

      = fdc$get_cobol_display_clause =
        get_variable_attributes [n].get_value_status := fdc$undefined_value;
        IF p_form_definition^.screen_formatting_version < fdc$im_smart_capability THEN
          CYCLE /process_variable_attributes/;
        IFEND;

        fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
             p_added_variable_definition);
        IF NOT p_added_variable_definition^.form_cobol_display_clause.defined THEN
          CYCLE /process_variable_attributes/;
        IFEND;

        IF (get_variable_attributes [n].p_cobol_display_clause = NIL) THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address,
                p_form_definition^.form_name, status);
          RETURN;
        IFEND;

        get_variable_attributes [n].p_cobol_display_clause^ :=  p_added_variable_definition^.
              form_cobol_display_clause.cobol_display_clause;
        get_variable_attributes [n].get_value_status := fdc$user_defined_value;

      = fdc$get_cobol_program_clause =
        get_variable_attributes [n].get_value_status := fdc$undefined_value;
        IF p_form_definition^.screen_formatting_version < fdc$im_smart_capability THEN
          CYCLE /process_variable_attributes/;
        IFEND;

        fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
             p_added_variable_definition);
        IF NOT p_added_variable_definition^.form_cobol_program_clause.defined THEN
           CYCLE /process_variable_attributes/;
        IFEND;

        IF (get_variable_attributes [n].p_cobol_program_clause = NIL) THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address,
                p_form_definition^.form_name, status);
          RETURN;
        IFEND;

        get_variable_attributes [n].p_cobol_program_clause^ :=  p_added_variable_definition^.
              form_cobol_program_clause.cobol_program_clause;
        get_variable_attributes [n].get_value_status := fdc$user_defined_value;

      = fdc$get_input_format =
        get_variable_attributes [n].input_format := p_form_variable_definition^.input_format;
        IF p_form_variable_definition^.input_format.key = fdc$system_input_format THEN
          get_variable_attributes [n].get_value_status := fdc$system_default_value;
        ELSE
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      = fdc$get_io_mode =
        get_variable_attributes [n].io_mode := p_form_variable_definition^.io_mode;
        IF p_form_variable_definition^.io_mode = fdc$system_io_mode THEN
          get_variable_attributes [n].get_value_status := fdc$system_default_value;
        ELSE
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      = fdc$get_error_display =
        get_variable_attributes [n].display_attribute := p_form_variable_definition^.error_displays;
        IF p_form_variable_definition^.error_displays = $fdt$display_attribute_set [] THEN
          get_variable_attributes [n].get_value_status := fdc$undefined_value;
        ELSEIF p_form_variable_definition^.error_displays = $fdt$display_attribute_set
              [fdc$inverse_video] THEN
          get_variable_attributes [n].get_value_status := fdc$system_default_value;
        ELSE
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      = fdc$get_next_valid_real_range =
        get_variable_attributes [n].get_value_status := fdc$undefined_value;

      /get_valid_real/
        FOR valid_real_index := current_real_index TO p_form_variable_definition^.valid_real_ranges.
              active_number DO
          p_valid_real_range := ^p_valid_real_ranges^ [valid_real_index];
          current_real_index := valid_real_index + 1;
          get_variable_attributes [n].minimum_real := p_valid_real_range^.minimum_real;
          get_variable_attributes [n].maximum_real := p_valid_real_range^.maximum_real;
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
          EXIT /get_valid_real/;
        FOREND /get_valid_real/;

      = fdc$get_next_valid_string =
        IF (get_variable_attributes [n].p_valid_string = NIL) THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address,
                p_form_definition^.form_name, status);
          RETURN;
        IFEND;

        get_variable_attributes [n].get_value_status := fdc$undefined_value;

      /get_string/
        FOR valid_string_index := current_string_index TO p_form_variable_definition^.valid_strings.
              active_number DO
          p_valid_string_definition := ^p_valid_strings^ [valid_string_index];
          current_string_index := valid_string_index + 1;
          p_valid_string := #PTR (p_valid_string_definition^.p_valid_string, p_form_module^);
          IF STRLENGTH (get_variable_attributes [n].p_valid_string^) >= STRLENGTH (p_valid_string^) THEN
            get_variable_attributes [n].p_valid_string^ := p_valid_string^;
            get_variable_attributes [n].get_value_status := fdc$user_defined_value;
            EXIT /get_string/;

          ELSE

{ The user did not an area large enough to contain the valid string.

            osp$set_status_abnormal (fdc$format_display_identifier, fde$string_too_small, '', status);
            RETURN;
          IFEND;
        FOREND /get_string/;

      = fdc$get_next_var_comment =
        IF (get_variable_attributes [n].p_var_comment = NIL) THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address,
                p_form_definition^.form_name, status);
          RETURN;
        IFEND;

        get_variable_attributes [n].get_value_status := fdc$undefined_value;

      /get_comment/
        FOR comment_index := current_comment_index TO comment_definitions.
              active_number DO
          p_comment_definition := ^p_comment_definitions^ [comment_index];
          current_comment_index := comment_index + 1;
          p_comment := #PTR (p_comment_definition^.p_comment, p_form_module^);
          IF STRLENGTH (get_variable_attributes [n].p_var_comment^) >= STRLENGTH (p_comment^) THEN
            get_variable_attributes [n].p_var_comment^ := p_comment^;
            get_variable_attributes [n].get_value_status := fdc$user_defined_value;
            EXIT /get_comment/;

          ELSE

{ The user did not specify an area large enough to contain the comment.

            osp$set_status_abnormal (fdc$format_display_identifier, fde$string_too_small, '', status);
            RETURN;
          IFEND;
        FOREND /get_comment/;

      = fdc$get_number_valid_integers =
        get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        get_variable_attributes [n].number_valid_integers :=
              p_form_variable_definition^.valid_integer_ranges.active_number;

      = fdc$get_number_valid_reals =
        get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        get_variable_attributes [n].number_valid_integers :=
              p_form_variable_definition^.valid_real_ranges.active_number;

      = fdc$get_number_valid_strings =
        get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        get_variable_attributes [n].number_valid_strings :=
              p_form_variable_definition^.valid_strings.active_number;

      = fdc$get_number_var_comments =
        get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        get_variable_attributes [n].number_var_comments := comment_definitions.
              active_number;

      = fdc$get_output_format =

        IF p_form_variable_definition^.output_format.key = fdc$undefined_output_format THEN
          get_variable_attributes [n].get_value_status := fdc$undefined_value;
        ELSE
          get_variable_attributes [n].output_format := p_form_variable_definition^.output_format;
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      = fdc$get_process_as_event =
        get_variable_attributes [n].process_as_event := p_form_variable_definition^.process_as_event;
        IF p_form_variable_definition^.process_as_event = FALSE THEN
          get_variable_attributes [n].get_value_status := fdc$system_default_value;
        ELSE
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      = fdc$get_program_data_type =
        get_variable_attributes [n].program_data_type := p_form_variable_definition^.program_data_type;
        IF p_form_variable_definition^.program_data_type <> fdc$program_upper_case_type THEN
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        ELSE
          get_variable_attributes [n].get_value_status := fdc$system_default_value;
        IFEND;

      = fdc$get_string_compare_rules =
        get_variable_attributes [n].compare_in_upper_case :=
              p_form_variable_definition^.valid_strings.compare_in_upper_case;
        get_variable_attributes [n].compare_to_unique_substring :=
              p_form_variable_definition^.valid_strings.compare_to_unique_substring;
        IF ((NOT p_form_variable_definition^.valid_strings.compare_in_upper_case) AND
              (NOT p_form_variable_definition^.valid_strings.compare_to_unique_substring)) THEN
          get_variable_attributes [n].get_value_status := fdc$system_default_value;
        ELSE
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      = fdc$get_terminal_user_entry =
        get_variable_attributes [n].terminal_user_entry := p_form_variable_definition^.terminal_user_entry;
        IF p_form_variable_definition^.terminal_user_entry = $fdt$terminal_user_entry
              [fdc$entry_optional] THEN
          get_variable_attributes [n].get_value_status := fdc$system_default_value;
        ELSE
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      = fdc$get_unknown_entry_character =
        get_variable_attributes [n].unknown_entry_character :=
              p_form_variable_definition^.unknown_entry_character;
        IF p_form_variable_definition^.unknown_entry_character = fdc$system_unknown_entry THEN
          get_variable_attributes [n].get_value_status := fdc$system_default_value;
        ELSE
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      = fdc$get_unused_variable_entry =
        get_variable_attributes [n].get_value_status := fdc$undefined_value;

      = fdc$get_valid_integer_range =
        get_variable_attributes [n].get_value_status := fdc$undefined_value;

      /get_valid_integer/
        FOR valid_integer_index := current_integer_index TO p_form_variable_definition^.valid_integer_ranges.
              active_number DO
          p_valid_integer_range := ^p_valid_integer_ranges^ [valid_integer_index];
          current_integer_index := valid_integer_index + 1;
          get_variable_attributes [n].minimum_integer := p_valid_integer_range^.minimum_integer;
          get_variable_attributes [n].maximum_integer := p_valid_integer_range^.maximum_integer;
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
          EXIT /get_valid_integer/;
        FOREND /get_valid_integer/;

      = fdc$get_valid_string_length =
        get_variable_attributes [n].get_value_status := fdc$undefined_value;

      /get_string_length/
        FOR valid_string_index := current_string_length_index TO p_form_variable_definition^.valid_strings.
              active_number DO
          p_valid_string_definition := ^p_valid_strings^ [valid_string_index];
          current_string_length_index := valid_string_index + 1;
          p_valid_string := #PTR (p_valid_string_definition^.p_valid_string, p_form_module^);
          get_variable_attributes [n].valid_string_length := STRLENGTH (p_valid_string^);
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
          EXIT /get_string_length/;
        FOREND /get_string_length/;

      = fdc$get_var_comment_length =
        get_variable_attributes [n].get_value_status := fdc$undefined_value;

      /get_comment_length/
        FOR comment_index := current_comment_length_index TO comment_definitions.
              active_number DO
          p_comment_definition := ^p_comment_definitions^ [comment_index];
          current_comment_length_index := comment_index + 1;
          p_comment := #PTR (p_comment_definition^.p_comment, p_form_module^);
          get_variable_attributes [n].var_comment_length := STRLENGTH (p_comment^);

          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
          EXIT /get_comment_length/;
        FOREND /get_comment_length/;

      = fdc$get_var_error_message =
         CASE p_form_variable_definition^.error_definition.key OF
         = fdc$error_message =
           IF (get_variable_attributes [n].p_error_message = NIL) THEN
             osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address, '', status);
             RETURN;
           IFEND;

            p_error_message := #PTR (p_form_variable_definition^.error_definition.p_error_message,
                p_form_module^);
            IF STRLENGTH (get_variable_attributes [n].p_error_message^) >= STRLENGTH (p_error_message^) THEN
              get_variable_attributes [n].p_error_message^ := p_error_message^;
              get_variable_attributes [n].get_value_status := fdc$user_defined_value;

            ELSE

{ The user's area will not hold the error message.

              osp$set_status_abnormal (fdc$format_display_identifier, fde$string_too_small, '', status);
              RETURN;
            IFEND;

          = fdc$system_default_error =
            IF (get_variable_attributes [n].p_error_message = NIL) THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address, '', status);
              RETURN;
            IFEND;

            IF STRLENGTH (get_variable_attributes [n].p_error_message^) >=
                  fdc$message_variable_length THEN
              fdp$get_message (fde$system_error_message,
                    get_variable_attributes [n].p_error_message^);
              get_variable_attributes [n].get_value_status := fdc$system_default_value;

            ELSE

{ The user's area will not hold the error message.

              osp$set_status_abnormal (fdc$format_display_identifier, fde$string_too_small, '', status);
              RETURN;
            IFEND;

           ELSE

{ The user did not specify an error message.

          get_variable_attributes [n].get_value_status := fdc$undefined_value;
          CASEND;

      = fdc$get_var_help_message =
        CASE p_form_variable_definition^.help_definition.key OF

          = fdc$help_message =
            IF (get_variable_attributes [n].p_help_message = NIL) THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address, '', status);
              RETURN;
            IFEND;

            p_help_message := #PTR (p_form_variable_definition^.help_definition.p_help_message,
                  p_form_module^);
            IF STRLENGTH (get_variable_attributes [n].p_help_message^) >= STRLENGTH (p_help_message^) THEN
              get_variable_attributes [n].p_help_message^ := p_help_message^;
              get_variable_attributes [n].get_value_status := fdc$user_defined_value;

            ELSE

{ The user's area will not hold the help message.

              osp$set_status_abnormal (fdc$format_display_identifier, fde$string_too_small, '', status);
              RETURN;
            IFEND;

          = fdc$system_default_help =
            IF (get_variable_attributes [n].p_help_message = NIL) THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address, '', status);
              RETURN;
            IFEND;

            IF STRLENGTH (get_variable_attributes [n].p_help_message^) >=
                  fdc$message_variable_length THEN
              fdp$get_message (fde$system_help_message,
                    get_variable_attributes [n].p_help_message^);
              get_variable_attributes [n].get_value_status := fdc$system_default_value;

            ELSE

{ The user's area will not hold the help message.

              osp$set_status_abnormal (fdc$format_display_identifier, fde$string_too_small, '', status);
              RETURN;
            IFEND;

           ELSE

{ The user did not specify a help message.

          get_variable_attributes [n].get_value_status := fdc$undefined_value;
          CASEND;

      = fdc$get_variable_error =
        CASE p_form_variable_definition^.error_definition.key OF

        = fdc$no_error_response =
          get_variable_attributes [n].variable_error.key := fdc$get_no_error_response;
          get_variable_attributes [n].get_value_status := fdc$system_default_value;

        = fdc$error_form =
          get_variable_attributes [n].variable_error.key := fdc$get_error_form;
          get_variable_attributes [n].variable_error.error_form :=
                p_form_variable_definition^.error_definition.error_form;
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;

        = fdc$error_message =
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
          get_variable_attributes [n].variable_error.key := fdc$get_error_message;
          p_error_message := #PTR (p_form_variable_definition^.error_definition.p_error_message,
                p_form_module^);
          get_variable_attributes [n].variable_error.error_message_length := STRLENGTH (p_error_message^);

        = fdc$system_default_error =
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
          get_variable_attributes [n].variable_error.key := fdc$get_system_default_error;
          get_variable_attributes [n].variable_error.error_message_length :=
               fdc$message_variable_length;

        ELSE

{ Invalid error processing case.

          osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_error_key,
                p_form_definition^.form_name, status);
          RETURN;
        CASEND;

      = fdc$get_variable_help =
        CASE p_form_variable_definition^.help_definition.key OF

        = fdc$no_help_response =
          get_variable_attributes [n].variable_help.key := fdc$get_no_help_response;
          get_variable_attributes [n].get_value_status := fdc$system_default_value;

        = fdc$help_form =
          get_variable_attributes [n].variable_help.key := fdc$get_help_form;
          get_variable_attributes [n].variable_help.help_form :=
                p_form_variable_definition^.help_definition.help_form;
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;


        = fdc$help_message =
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
          get_variable_attributes [n].variable_help.key := fdc$get_help_message;
          p_help_message := #PTR (p_form_variable_definition^.help_definition.p_help_message, p_form_module^);
          get_variable_attributes [n].variable_help.help_message_length := STRLENGTH (p_help_message^);

        = fdc$system_default_help =
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
          get_variable_attributes [n].variable_help.key := fdc$get_system_default_help;
          get_variable_attributes [n].variable_help.help_message_length :=
                fdc$message_variable_length;

        ELSE

{ Invalid help processing case.

          osp$set_status_abnormal (fdc$format_display_identifier, fde$system_error, '', status);
          RETURN;
        CASEND;

      = fdc$get_variable_length =
        IF p_form_variable_definition^.program_variable_length = 0 THEN
          get_variable_attributes [n].get_value_status := fdc$undefined_value;
        ELSE
          get_variable_attributes [n].variable_length := p_form_variable_definition^.program_variable_length;
          get_variable_attributes [n].get_value_status := fdc$user_defined_value;
        IFEND;

      ELSE

{ Invalid attribute.

        osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_attribute,
              p_form_definition^.form_name, status);
        RETURN;

      CASEND;
    FOREND /process_variable_attributes/;

  PROCEND fdp$get_variable_attributes;

?? TITLE := 'change_variable', EJECT ??

  PROCEDURE change_variable
    (    p_form_status: ^fdt$form_status;
         p_form_definition: ^fdt$form_definition;
         p_form_variable_definition: ^fdt$form_variable_definition;
     VAR variable_attributes: fdt$variable_attributes;
     VAR status: ost$status);

    VAR
      additional_definitions:  fdt$additional_definitions,
      cobol_clause_changed: boolean,
      cobol_description: fdt$cobol_description,
      comment_index: fdt$comment_index,
      b_edit_character: [READ] packed array [char] of boolean := [
          {---} REP  66 of FALSE,
          {B  } REP   1 of TRUE,
          {---} REP  31 of FALSE,
          {b  } REP   1 of TRUE,
          {---} REP 157 of FALSE],
      error_key: fdt$error_key,
      help_key: fdt$help_key,
      initial_value_key: fdt$program_data_type,
      n: fdt$variable_attribute_index,
      name_exists: boolean,
      name_is_valid: boolean,
      new_array: boolean,
      output_format_key: fdt$output_format_key,
      p_added_variable_definition: ^fdt$added_variable_definition,
      p_duplicate_variable: ^fdt$form_variable_definition,
      p_error_message: ^fdt$error_message,
      p_form_module: ^fdt$form_module,
      p_form_table_definition: ^fdt$form_table_definition,
      p_help_message: ^fdt$help_message,
      p_comment_definitions: ^array [1 .. * ] of fdt$comment_definition,
      p_new_valid_string: ^fdt$valid_string,
      p_sequence: ^SEQ (*),
      p_text: ^fdt$text,
      p_valid_integer_range: ^fdt$valid_integer_range,
      p_valid_integer_ranges: ^array [1 .. * ] of fdt$valid_integer_range,
      p_valid_string: ^fdt$valid_string,
      p_valid_strings: ^array [1 .. * ] of fdt$valid_string_definition,
      p_valid_string_definition: ^fdt$valid_string_definition,
      p_valid_real_range: ^fdt$valid_real_range,
      p_valid_real_ranges: ^array [1 .. * ] of fdt$valid_real_range,
      real_length: integer,
      real_string: string (10),
      scan_found_character: boolean,
      scan_index: integer,
      table_index: fdt$table_index,
      valid_integer_index: fdt$valid_integer_index,
      valid_name: ost$name,
      valid_real_index: fdt$valid_real_index,
      valid_string_index: fdt$valid_string_index,
      variable_index: fdt$variable_index;

?? NEWTITLE := 'allocate_valid_integer', EJECT ??

    PROCEDURE allocate_valid_integer
      (VAR valid_integer_ranges: fdt$valid_integer_ranges;
       VAR p_valid_integer_range: ^fdt$valid_integer_range);

      VAR
        i: fdt$valid_integer_index,
        number_valid_integers: fdt$number_valid_integers,
        p_new_valid_integers: ^array [1 .. * ] of fdt$valid_integer_range,
        p_old_valid_integers: ^array [1 .. * ] of fdt$valid_integer_range;

      p_old_valid_integers := fdp$ptr_valid_integers (valid_integer_ranges, p_form_module);
      IF p_old_valid_integers = NIL THEN
        NEXT p_new_valid_integers: [1 .. fdc$valid_ranges_to_expand] IN p_form_status^.p_form_module;
        IF p_new_valid_integers = NIL THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
          RETURN;
        IFEND;

        fdp$rel_valid_integers (p_new_valid_integers, p_form_module, valid_integer_ranges);
        p_valid_integer_range := ^p_new_valid_integers^ [1];
        valid_integer_ranges.active_number := 1;
        RETURN;
      IFEND;

{ Minimize allocates/deallocates of tables.
{ Entries have already been allocated. Try to find an inactive entry.

      number_valid_integers := valid_integer_ranges.active_number;

      IF number_valid_integers < valid_integer_ranges.total_number THEN
        number_valid_integers := number_valid_integers + 1;
        valid_integer_ranges.active_number := number_valid_integers;
        p_valid_integer_range := ^p_old_valid_integers^ [number_valid_integers];
        RETURN;
      IFEND;

{ Expand the array for valid integers.

      NEXT p_new_valid_integers: [1 .. number_valid_integers + fdc$valid_ranges_to_expand] IN
            p_form_status^.p_form_module;
      IF p_new_valid_integers = NIL THEN
        osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
        RETURN;
      IFEND;

{ Copy old entries to new array.

      FOR i := 1 TO number_valid_integers DO
        p_new_valid_integers^ [i] := p_old_valid_integers^ [i];
      FOREND;

      fdp$rel_valid_integers (p_new_valid_integers, p_form_module, valid_integer_ranges);
      number_valid_integers := number_valid_integers + 1;
      valid_integer_ranges.active_number := number_valid_integers;
      p_valid_integer_range := ^p_new_valid_integers^ [number_valid_integers];
    PROCEND allocate_valid_integer;

?? OLDTITLE ??
?? NEWTITLE := 'allocate_valid_real', EJECT ??

    PROCEDURE allocate_valid_real
      (VAR valid_real_ranges: fdt$valid_real_ranges;
       VAR p_valid_real_range: ^fdt$valid_real_range);

      VAR
        i: fdt$valid_real_index,
        number_valid_reals: fdt$number_valid_reals,
        p_new_valid_reals: ^array [1 .. * ] of fdt$valid_real_range,
        p_old_valid_reals: ^array [1 .. * ] of fdt$valid_real_range;

      p_old_valid_reals := fdp$ptr_valid_reals (valid_real_ranges, p_form_module);
      IF p_old_valid_reals = NIL THEN
        NEXT p_new_valid_reals: [1 .. fdc$valid_ranges_to_expand] IN p_form_status^.p_form_module;
        IF p_new_valid_reals = NIL THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
          RETURN;
        IFEND;

        fdp$rel_valid_reals (p_new_valid_reals, p_form_module, valid_real_ranges);
        p_valid_real_range := ^p_new_valid_reals^ [1];
        valid_real_ranges.active_number := 1;
        RETURN;
      IFEND;

{ Minimize allocates/deallocates of tables.
{ Entries have already been allocated. Try to find an inactive entry.

      number_valid_reals := valid_real_ranges.active_number;
      IF number_valid_reals < valid_real_ranges.total_number THEN
        number_valid_reals := number_valid_reals + 1;
        valid_real_ranges.active_number := number_valid_reals;
        p_valid_real_range := ^p_old_valid_reals^ [number_valid_reals];
        RETURN;
      IFEND;

{ Expand the array for valid reals.

      NEXT p_new_valid_reals: [1 .. number_valid_reals + fdc$valid_ranges_to_expand] IN
            p_form_status^.p_form_module;
      IF p_new_valid_reals = NIL THEN
        osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
        RETURN;
      IFEND;

      FOR i := 1 TO number_valid_reals DO
        p_new_valid_reals^ [i] := p_old_valid_reals^ [i];
      FOREND;

      fdp$rel_valid_reals (p_new_valid_reals, p_form_module, valid_real_ranges);
      number_valid_reals := number_valid_reals + 1;
      valid_real_ranges.active_number := number_valid_reals;
      p_valid_real_range := ^p_new_valid_reals^ [number_valid_reals];
    PROCEND allocate_valid_real;

?? OLDTITLE ??
?? NEWTITLE := 'allocate_valid_string', EJECT ??

    PROCEDURE allocate_valid_string
      (VAR valid_strings: fdt$valid_strings;
       VAR p_valid_string_definition: ^fdt$valid_string_definition);

      VAR
        n: fdt$valid_string_index,
        number_valid_strings: fdt$number_valid_strings,
        p_new_valid_strings: ^array [1 .. * ] of fdt$valid_string_definition,
        p_old_valid_strings: ^array [1 .. * ] of fdt$valid_string_definition;

      p_old_valid_strings := fdp$ptr_valid_strings (valid_strings, p_form_module);
      IF p_old_valid_strings = NIL THEN
        NEXT p_new_valid_strings: [1 .. fdc$valid_strings_to_expand] IN p_form_status^.p_form_module;
        IF p_new_valid_strings = NIL THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
          RETURN;
        IFEND;

        fdp$rel_valid_strings (p_new_valid_strings, p_form_module, valid_strings);
        p_valid_string_definition := ^p_new_valid_strings^ [1];
        valid_strings.active_number := 1;
        RETURN;
      IFEND;

{ Entries have already been allocated. Try to find an inactive entry.

      number_valid_strings := valid_strings.active_number;
      IF number_valid_strings < valid_strings.total_number THEN
        number_valid_strings := number_valid_strings + 1;
        valid_strings.active_number := number_valid_strings;
        p_valid_string_definition := ^p_old_valid_strings^ [number_valid_strings];
        RETURN;
      IFEND;

{ Expand the array for valid strings.

      NEXT p_new_valid_strings: [1 .. number_valid_strings + fdc$valid_strings_to_expand] IN
            p_form_status^.p_form_module;
      IF p_new_valid_strings = NIL THEN
        osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
        RETURN;
      IFEND;

      FOR n := 1 TO number_valid_strings DO
        p_new_valid_strings^ [n] := p_old_valid_strings^ [n];
      FOREND;

      fdp$rel_valid_strings (p_new_valid_strings, p_form_module, valid_strings);
      number_valid_strings := number_valid_strings + 1;
      valid_strings.active_number := number_valid_strings;
      p_valid_string_definition := ^p_new_valid_strings^ [number_valid_strings];
    PROCEND allocate_valid_string;

?? OLDTITLE ??
?? NEWTITLE := 'check_object_size', EJECT ??

  PROCEDURE check_object_size
    (    p_form_status: ^fdt$form_status;
         cobol_size: 0 .. fdc$cobol_item_size_maximum;
         variable_name: ost$name;
     VAR status: ost$status);

    VAR
      object_index: fdt$object_index,
      object_name_exists: boolean,
      object_occurrence_exists: boolean,
      p_form_object_definition: ^fdt$form_object_definition,
      screen_variable_length: fdt$screen_variable_length;

    status.normal := TRUE;
    fdp$find_object_definition (variable_name, 1, p_form_status^.p_form_object_definitions,
          p_form_status^.p_form_definition^.form_object_definitions.active_number,
          p_form_object_definition, object_index, object_name_exists,
          object_occurrence_exists);
    IF NOT object_name_exists THEN
      RETURN;
    IFEND;

    CASE p_form_object_definition^.key OF

    = fdc$form_variable_text =
      screen_variable_length := p_form_object_definition^.text_variable_width;

    = fdc$form_variable_text_box =
      screen_variable_length := p_form_object_definition^.variable_box_width *
            p_form_object_definition^.variable_box_height;
    ELSE
      RETURN;
    CASEND;

    IF cobol_size > screen_variable_length THEN
      osp$set_status_abnormal (fdc$format_display_identifier, fde$object_size_coboL_mismatch, '', status);
      osp$append_status_integer (osc$status_parameter_delimiter,
            $INTEGER (cobol_size), 10, FALSE,  status);
      osp$append_status_integer (osc$status_parameter_delimiter, $INTEGER (screen_variable_length),
            10, FALSE, status);
      osp$append_status_parameter (osc$status_parameter_delimiter, variable_name, status);
      osp$append_status_parameter (osc$status_parameter_delimiter,
           p_form_status^.p_form_definition^.form_name, status);
    IFEND;

    PROCEND check_object_size;

?? OLDTITLE ??
?? NEWTITLE := 'condition_handler', EJECT ??

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

      CASE condition.selector OF

      = pmc$system_conditions =
        IF (condition.system_conditions * $pmt$system_conditions
              [pmc$instruction_specification, pmc$address_specification, pmc$access_violation,
              pmc$invalid_segment_ring_0, pmc$divide_fault, pmc$arithmetic_overflow, pmc$exponent_overflow,
              pmc$exponent_underflow, pmc$fp_significance_loss, pmc$fp_indefinite,
              pmc$arithmetic_significance, pmc$invalid_bdp_data]) <> $pmt$system_conditions [] THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT change_variable;
        IFEND;

      = pmc$user_defined_condition =
        IF condition.user_condition_name = cye$run_time_condition THEN
          osp$set_status_abnormal (fdc$format_display_identifier, fde$bad_data_value, '', status);
          EXIT change_variable;
        IFEND;

      ELSE
        ;
      CASEND;
      pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
    PROCEND condition_handler;

?? OLDTITLE ??
?? NEWTITLE := 'convert_cobol_status', EJECT ??

{ PURPOSE:
{   This procedure converts a status from fdp$create_cobol_description
{   to a Screen Formatting status.
{ DESIGN:
{   To help the user locate errors more easily, the name of the variable and
{   and the name of the form is added to the cobol status message.
{ NOTES:
{   This procedure never returns to its caller.  It always exits change_variable.

   PROCEDURE convert_cobol_status;

     VAR
       status_condition_code: ost$status_condition_code;

     CASE status.condition OF
     = fde$cobol_too_many_digits =
       status_condition_code := fde$too_many_digits;
     = fde$cobol_bad_picture =
       status_condition_code := fde$invalid_picture;
     = fde$cobol_binary_means_numeric =
       status_condition_code := fde$binary_requires_numeric;
     = fde$cobol_comp_1_means_no_pic =
       status_condition_code := fde$picture_invalid_for_comp_1;
     = fde$cobol_comp_2_means_no_pic =
       status_condition_code := fde$picture_invalid_for_comp_2;
     = fde$cobol_CR_DB_must_be_right =
       status_condition_code := fde$cr_db_must_be_rightmost;
     = fde$cobol_float_must_be_left =
       status_condition_code := fde$floating_symbols_invalid;
     = fde$cobol_illegal_pic_char =
       status_condition_code := fde$invalid_picture_character;
     = fde$cobol_insert_left_of_float =
       status_condition_code := fde$insertion_symbols_invalid;
     = fde$cobol_item_too_big =
       status_condition_code := fde$picture_item_too_big;
     = fde$cobol_no_multiple_points =
       status_condition_code := fde$too_many_decimal_points;
     = fde$cobol_no_rep_after_point =
       status_condition_code := fde$no_repetition_after_point;
     = fde$cobol_no_rep_for_cr_db =
       status_condition_code := fde$no_repetition_for_cr_db;
     = fde$cobol_nondigit_rep_count =
       status_condition_code := fde$nondigit_repetition;
     = fde$cobol_not_both_v_and_p =
       status_condition_code := fde$v_and_p_invalid;
     = fde$cobol_not_9p9 =
       status_condition_code := fde$p_between_9_invalid;
     = fde$cobol_not_p9p =
       status_condition_code := fde$9_between_p_invalid;
     = fde$cobol_packed_means_num_pic =
       status_condition_code := fde$packed_requires_numeric;
     = fde$cobol_right_flt_means_all =
       status_condition_code := fde$invalid_right_floating;
     = fde$cobol_s_must_be_first =
       status_condition_code := fde$s_must_be_first;
     = fde$cobol_sign_needs_s =
       status_condition_code := fde$picture_requires_sign;
     = fde$cobol_too_many_vs =
       status_condition_code := fde$too_many_vs;
     = fde$cobol_two_signs =
       status_condition_code := fde$too_many_sign_symbols;
    = fde$cobol_two_floating =
      status_condition_code := fde$too_many_floating_symbols;
     = fde$cobol_unbal_parens =
       status_condition_code := fde$unbalanced_parentheses;
     = fde$cobol_unknown_usage =
       status_condition_code := fde$invalid_usage;
     = fde$cobol_wrong_sign_vs_usage =
       status_condition_code := fde$invalid_sign_for_usage;
     = fde$cobol_p_not_supported =
       status_condition_code := fde$p_invalid_for_picture;
     ELSE
       osp$set_status_abnormal (fdc$format_display_identifier, fde$system_error,
            'Unknown status from fdp$create_cobol_definition', status);
       EXIT change_variable;
     CASEND;

     osp$set_status_abnormal (fdc$format_display_identifier, status_condition_code,
            p_form_variable_definition^.name, status);
     osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
           status);
     EXIT change_variable;

   PROCEND convert_cobol_status;

?? OLDTITLE, EJECT ??

    osp$establish_condition_handler (^condition_handler, FALSE);
    status.normal := TRUE;
    cobol_clause_changed := FALSE;
    p_form_module := p_form_status^.p_form_module;

  /process_variable_attributes/
    FOR n := LOWERBOUND (variable_attributes) TO UPPERBOUND (variable_attributes) DO

    /process_variable_attribute/
      BEGIN
        CASE variable_attributes [n].key OF

        = fdc$add_valid_integer_range =
          IF variable_attributes [n].minimum_integer > variable_attributes [n].maximum_integer THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_integer_range, '', status);
            osp$append_status_integer (osc$status_parameter_delimiter, variable_attributes [n].
                  minimum_integer, 10, FALSE, status);
            osp$append_status_integer (osc$status_parameter_delimiter, variable_attributes [n].
                  maximum_integer, 10, FALSE, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_variable_definition^.name,
                  status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          IFEND;

          p_valid_integer_ranges := fdp$ptr_valid_integers (p_form_variable_definition^.valid_integer_ranges,
                p_form_module);

{ The ranges of valid integers must not overlap.

        /check_integer_range_overlap/
          FOR valid_integer_index := 1 TO p_form_variable_definition^.valid_integer_ranges.active_number DO
            p_valid_integer_range := ^p_valid_integer_ranges^ [valid_integer_index];
            IF variable_attributes [n].maximum_integer < p_valid_integer_range^.minimum_integer THEN
              CYCLE /check_integer_range_overlap/;
            IFEND;

            IF variable_attributes [n].minimum_integer > p_valid_integer_range^.maximum_integer THEN
              CYCLE /check_integer_range_overlap/;
            IFEND;

            osp$set_status_abnormal (fdc$format_display_identifier, fde$range_overlap, '', status);
            osp$append_status_integer (osc$status_parameter_delimiter, variable_attributes [n].
                  minimum_integer, 10, FALSE, status);
            osp$append_status_integer (osc$status_parameter_delimiter, variable_attributes [n].
                  maximum_integer, 10, FALSE, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_variable_definition^.name,
                  status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          FOREND /check_integer_range_overlap/;

{ The new range is valid.

          allocate_valid_integer (p_form_variable_definition^.valid_integer_ranges, p_valid_integer_range);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

          p_valid_integer_range^.minimum_integer := variable_attributes [n].minimum_integer;
          p_valid_integer_range^.maximum_integer := variable_attributes [n].maximum_integer;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$add_valid_real_range =
          IF variable_attributes [n].minimum_real > variable_attributes [n].maximum_real THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_real_range, '', status);
            STRINGREP (real_string, real_length, variable_attributes [n].minimum_real: 10);
            osp$append_status_parameter (osc$status_parameter_delimiter, real_string, status);
            STRINGREP (real_string, real_length, variable_attributes [n].maximum_real: 10);
            osp$append_status_parameter (osc$status_parameter_delimiter, real_string, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_variable_definition^.name,
                  status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          IFEND;

          p_valid_real_ranges := fdp$ptr_valid_reals (p_form_variable_definition^.valid_real_ranges,
                p_form_module);

{ The range of reals must not overlap.

        /check_real_range_overlap/
          FOR valid_real_index := 1 TO p_form_variable_definition^.valid_real_ranges.active_number DO
            p_valid_real_range := ^p_valid_real_ranges^ [valid_real_index];
            IF variable_attributes [n].maximum_real < p_valid_real_range^.minimum_real THEN
              CYCLE /check_real_range_overlap/;
            IFEND;

            IF variable_attributes [n].minimum_real > p_valid_real_range^.maximum_real THEN
              CYCLE /check_real_range_overlap/;
            IFEND;

            osp$set_status_abnormal (fdc$format_display_identifier, fde$range_overlap, '', status);
            STRINGREP (real_string, real_length, variable_attributes [n].minimum_real: 10);
            osp$append_status_parameter (osc$status_parameter_delimiter, real_string, status);
            STRINGREP (real_string, real_length, variable_attributes [n].maximum_real: 10);
            osp$append_status_parameter (osc$status_parameter_delimiter, real_string, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_variable_definition^.name,
                  status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          FOREND /check_real_range_overlap/;

{ The new real range is valid.

          allocate_valid_real (p_form_variable_definition^.valid_real_ranges, p_valid_real_range);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

          p_valid_real_range^.minimum_real := variable_attributes [n].minimum_real;
          p_valid_real_range^.maximum_real := variable_attributes [n].maximum_real;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$add_valid_string =
          IF (variable_attributes [n].p_valid_string = NIL) THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address, '', status);
            RETURN;
          IFEND;

          NEXT p_new_valid_string: [STRLENGTH (variable_attributes [n].p_valid_string^)] IN
                p_form_status^.p_form_module;

          IF p_new_valid_string <> NIL THEN
            IF p_form_variable_definition^.valid_strings.compare_in_upper_case THEN
              #TRANSLATE (osv$lower_to_upper, variable_attributes [n].p_valid_string^, p_new_valid_string^);
            ELSE
              p_new_valid_string^ := variable_attributes [n].p_valid_string^;
            IFEND;

            p_valid_strings := fdp$ptr_valid_strings (p_form_variable_definition^.valid_strings,
                  p_form_module);

{ The added string must be unique.

          /check_duplicate_valid_string/
            FOR valid_string_index := 1 TO p_form_variable_definition^.valid_strings.active_number DO
              p_valid_string_definition := ^p_valid_strings^ [valid_string_index];
              p_valid_string := #PTR (p_valid_string_definition^.p_valid_string, p_form_module^);
              IF p_valid_string^ = p_new_valid_string^ THEN
                osp$set_status_abnormal (fdc$format_display_identifier, fde$valid_string_exists,
                      variable_attributes [n].p_valid_string^, status);
                osp$append_status_parameter (osc$status_parameter_delimiter, p_form_variable_definition^.name,
                      status);
                osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                      status);
                RETURN;
              IFEND;
            FOREND /check_duplicate_valid_string/;

{ The added valid string is unique.

            allocate_valid_string (p_form_variable_definition^.valid_strings, p_valid_string_definition);
            IF NOT status.normal THEN
              RETURN;
            IFEND;

            p_valid_string_definition^.p_valid_string := #REL (p_new_valid_string, p_form_module^);
            variable_attributes [n].put_value_status := fdc$put_value_accepted;

          ELSE

{ No space could be allocated for added valid string.

            osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
            RETURN;
          IFEND;

        = fdc$add_var_comment =
          IF (variable_attributes [n].p_var_comment = NIL) THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address, '', status);
            RETURN;
          IFEND;

          fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
                p_added_variable_definition);
          fdp$add_comment (p_form_status, p_form_definition, variable_attributes [n].p_var_comment,
                p_added_variable_definition^.comment_definitions, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;

          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$cobol_display_clause=
          IF p_form_definition^.processor <> fdc$cobol_processor THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_cobol_data_type,
                p_form_variable_definition^.name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                status);
            RETURN;
          IFEND;

          IF p_form_definition^.processor <> fdc$cobol_processor THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_cobol_data_type,
                p_form_variable_definition^.name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                status);
            RETURN;
          IFEND;

          IF p_form_variable_definition^.output_format.key = fdc$currency_output_format THEN
            fdp$change_currency_symbols (p_form_variable_definition^.output_format.
                  output_currency_format.currency_sybmol,
                  p_form_variable_definition^.output_format.
                  output_currency_format.currency_sybmol, p_form_variable_definition^.output_format.
                  output_currency_format.thousands_separator,
                  p_form_variable_definition^.output_format.output_currency_format.decimal_point);
          ELSE
            fdp$change_currency_symbols (fdc$dollar_currency_symbol, fdc$pound_currency_symbol,
                  fdc$thousands_currency_symbol, fdc$decimal_currency_symbol);
          IFEND;

          fdp$create_cobol_description (variable_attributes [n].p_cobol_display_clause^.
                 picture, fdc$display_usage, cobol_description, status);
          IF NOT status.normal THEN
            convert_cobol_status;
            RETURN;
          IFEND;

          fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
               p_added_variable_definition);
          CASE cobol_description.cobol_category OF

{ Alphanumeric edited or signed numeric clauses are not allowed.

          = fdc$cobol_alphanumeric_edited, fdc$cobol_numeric_signed =
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_cobol_category,
                p_form_variable_definition^.name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                status);
            RETURN;

{ A display alphabetic PICTURE clause cannot have a "B" editing character.

         = fdc$cobol_alphabetic =
           #SCAN (b_edit_character, variable_attributes [n].p_cobol_program_clause^.
                 picture, scan_index, scan_found_character);
            IF scan_found_character THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$b_invalid_for_picture,
                  p_form_variable_definition^.name, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
              RETURN;
            IFEND;

          ELSE
          CASEND;

         check_object_size (p_form_status, cobol_description.size,
                p_form_variable_definition^.name, status);
         IF NOT status.normal THEN
           RETURN;
         IFEND;

          #TRANSLATE (osv$lower_to_upper, variable_attributes [n].p_cobol_display_clause^.
                picture, p_added_variable_definition^.form_cobol_display_clause.
                cobol_display_clause.picture);
          p_added_variable_definition^.form_cobol_display_clause.defined := TRUE;
          p_form_variable_definition^.program_data_type := fdc$program_cobol_type;
          p_added_variable_definition^.display_cobol_description := cobol_description;
          cobol_clause_changed := TRUE;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$cobol_program_clause=
          IF p_form_definition^.processor <> fdc$cobol_processor THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_cobol_data_type,
                p_form_variable_definition^.name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                status);
            RETURN;
          IFEND;

          IF p_form_variable_definition^.input_format.key = fdc$currency_input_format THEN
            fdp$change_currency_symbols (p_form_variable_definition^.input_format.
                  input_currency_format.currency_sybmol,
                  p_form_variable_definition^.input_format.
                  input_currency_format.currency_sybmol, p_form_variable_definition^.input_format.
                  input_currency_format.thousands_separator,
                  p_form_variable_definition^.input_format.input_currency_format.decimal_point);
          ELSE
            fdp$change_currency_symbols (fdc$dollar_currency_symbol, fdc$pound_currency_symbol,
                  fdc$thousands_currency_symbol, fdc$decimal_currency_symbol);
          IFEND;

          fdp$create_cobol_description (variable_attributes [n].p_cobol_program_clause^.
                 picture, variable_attributes [n].p_cobol_program_clause^.usage,
                 cobol_description, status);
          IF NOT status.normal THEN
            convert_cobol_status;
            RETURN;
          IFEND;

          fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
               p_added_variable_definition);

          CASE cobol_description.cobol_category OF

{ Edited data cannot be manipulated in the COBOL program.

          = fdc$cobol_numeric_edited, fdc$cobol_alphanumeric_edited =
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_cobol_category,
                p_form_variable_definition^.name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                status);
            RETURN;

{ A program alphabetic PICTURE clause cannot have a "B" editing character.

          = fdc$cobol_alphabetic =
            #SCAN (b_edit_character, variable_attributes [n].p_cobol_program_clause^.
                 picture, scan_index, scan_found_character);

            IF scan_found_character THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$b_invalid_for_picture,
                  p_form_variable_definition^.name, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
              RETURN;
            IFEND;
          ELSE { All other categories are valid.}
          CASEND;

          p_added_variable_definition^.form_cobol_program_clause.defined := TRUE;
          p_form_variable_definition^.program_data_type := fdc$program_cobol_type;
          p_form_variable_definition^.program_variable_length := cobol_description.size;
          p_added_variable_definition^.form_cobol_program_clause.
                cobol_program_clause.usage := variable_attributes [n].
                p_cobol_program_clause^.usage;
          #TRANSLATE (osv$lower_to_upper, variable_attributes [n].p_cobol_program_clause^.
                picture, p_added_variable_definition^.form_cobol_program_clause.
                cobol_program_clause.picture);
          p_added_variable_definition^.program_cobol_description := cobol_description;
          cobol_clause_changed := TRUE;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$delete_valid_integer_range =
          p_valid_integer_ranges := fdp$ptr_valid_integers (p_form_variable_definition^.valid_integer_ranges,
                p_form_module);
          FOR valid_integer_index := 1 TO p_form_variable_definition^.valid_integer_ranges.active_number DO
            p_valid_integer_range := ^p_valid_integer_ranges^ [valid_integer_index];
            IF p_valid_integer_range^.minimum_integer = variable_attributes [n].minimum_integer THEN
              IF p_valid_integer_range^.maximum_integer = variable_attributes [n].maximum_integer THEN
                p_valid_integer_range^ := p_valid_integer_ranges^
                      [p_form_variable_definition^.valid_integer_ranges.active_number];
                p_form_variable_definition^.valid_integer_ranges.active_number :=
                      p_form_variable_definition^.valid_integer_ranges.active_number - 1;
                variable_attributes [n].put_value_status := fdc$put_value_accepted;
                EXIT /process_variable_attribute/;
              IFEND;
            IFEND;
          FOREND;

{ The specified integer range was not created.

          osp$set_status_abnormal (fdc$format_display_identifier, fde$unknown_integer_range, '', status);
          osp$append_status_integer (osc$status_parameter_delimiter, variable_attributes [n].minimum_integer,
                10, FALSE, status);
          osp$append_status_integer (osc$status_parameter_delimiter, variable_attributes [n].maximum_integer,
                10, FALSE, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, p_form_variable_definition^.name,
                status);
          osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
          RETURN;

        = fdc$delete_valid_real_range =
          p_valid_real_ranges := fdp$ptr_valid_reals (p_form_variable_definition^.valid_real_ranges,
                p_form_module);
          FOR valid_real_index := 1 TO p_form_variable_definition^.valid_real_ranges.active_number DO
            p_valid_real_range := ^p_valid_real_ranges^ [valid_real_index];
            IF p_valid_real_range^.minimum_real = variable_attributes [n].minimum_real THEN
              IF p_valid_real_range^.maximum_real = variable_attributes [n].maximum_real THEN
                p_valid_real_range^ := p_valid_real_ranges^ [p_form_variable_definition^.valid_real_ranges.
                      active_number];
                p_form_variable_definition^.valid_real_ranges.active_number :=
                      p_form_variable_definition^.valid_real_ranges.active_number - 1;
                variable_attributes [n].put_value_status := fdc$put_value_accepted;
                EXIT /process_variable_attribute/;
              IFEND;
            IFEND;
          FOREND;

{ The specified real range was not created.

          osp$set_status_abnormal (fdc$format_display_identifier, fde$unknown_real_range, '', status);
          STRINGREP (real_string, real_length, variable_attributes [n].minimum_real: 10);
          osp$append_status_parameter (osc$status_parameter_delimiter, real_string, status);
          STRINGREP (real_string, real_length, variable_attributes [n].maximum_real: 10);
          osp$append_status_parameter (osc$status_parameter_delimiter, p_form_variable_definition^.name,
                status);
          osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
          RETURN;

        = fdc$delete_valid_string =
          IF (variable_attributes [n].p_valid_string = NIL) THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address,
                  p_form_definition^.form_name, status);
            RETURN;
          IFEND;

          p_valid_strings := fdp$ptr_valid_strings (p_form_variable_definition^.valid_strings, p_form_module);
          FOR valid_string_index := 1 TO p_form_variable_definition^.valid_strings.active_number DO
            p_valid_string_definition := ^p_valid_strings^ [valid_string_index];
            p_valid_string := #PTR (p_valid_string_definition^.p_valid_string, p_form_module^);
            IF p_valid_string^ = variable_attributes [n].p_valid_string^ THEN
              p_valid_string_definition^ := p_valid_strings^ [p_form_variable_definition^.valid_strings.
                    active_number];
              p_form_variable_definition^.valid_strings.active_number :=
                    p_form_variable_definition^.valid_strings.active_number - 1;
              variable_attributes [n].put_value_status := fdc$put_value_accepted;
              EXIT /process_variable_attribute/;
            IFEND;
          FOREND;

{ The specified valid string was not created.

          osp$set_status_abnormal (fdc$format_display_identifier, fde$unknown_valid_string,
                p_form_variable_definition^.name, status);
          osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name, status);
          RETURN;

        = fdc$delete_var_comments =
          fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
               p_added_variable_definition);
          p_comment_definitions := fdp$ptr_comments (p_added_variable_definition^.comment_definitions,
                p_form_module);
          IF p_comment_definitions = NIL THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$no_comments_to_delete,
                  p_form_variable_definition^.name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          IFEND;

          fdp$rel_comments (NIL, p_form_module, p_added_variable_definition^.comment_definitions);
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$error_display =
          p_form_variable_definition^.error_displays := variable_attributes [n].display_attribute;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$program_data_type =
          CASE variable_attributes [n].program_data_type OF

          = fdc$program_real_type =
            IF p_form_definition^.processor = fdc$cobol_processor THEN
              fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
                    p_added_variable_definition);
              p_added_variable_definition^.form_cobol_program_clause.defined := FALSE;
              p_added_variable_definition^.form_cobol_display_clause.defined := FALSE;
            IFEND;

            p_form_variable_definition^.program_data_type := fdc$program_real_type;
            p_form_variable_definition^.program_variable_length := fdc$real_length;

          = fdc$program_integer_type =
            IF p_form_definition^.processor = fdc$cobol_processor THEN
              fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
                    p_added_variable_definition);
              p_added_variable_definition^.form_cobol_program_clause.defined := FALSE;
              p_added_variable_definition^.form_cobol_display_clause.defined := FALSE;
            IFEND;

            p_form_variable_definition^.program_data_type := fdc$program_integer_type;
            p_form_variable_definition^.program_variable_length := fdc$integer_length;

          = fdc$program_character_type, fdc$program_upper_case_type =
            IF p_form_definition^.processor = fdc$cobol_processor THEN
              fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
                    p_added_variable_definition);
              p_added_variable_definition^.form_cobol_program_clause.defined := FALSE;
              p_added_variable_definition^.form_cobol_display_clause.defined := FALSE;
            IFEND;

            p_form_variable_definition^.program_data_type := variable_attributes [n].program_data_type;

          = fdc$program_cobol_type =
            p_form_variable_definition^.program_data_type := variable_attributes [n].program_data_type;

          ELSE

{ Invalid initial value key.

            osp$set_status_abnormal (fdc$format_display_identifier, fde$program_data_type,
                  p_form_definition^.form_name, status);
            RETURN;
          CASEND;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$input_format =
            IF ((p_form_variable_definition^.program_data_type =
                  fdc$program_cobol_type) AND
                  (variable_attributes [n].input_format.key <> fdc$currency_input_format)) THEN
              osp$set_status_abnormal (fdc$format_display_identifier,
                    fde$input_format_invalid_cobol,
                    p_form_definition^.form_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
                  p_form_variable_definition^.name,
                  status);
              RETURN;
            IFEND;

          CASE variable_attributes [n].input_format.key OF

          = fdc$alphabetic_input_format, fdc$character_input_format, fdc$real_input_format,
                fdc$dmy_format, fdc$mdy_format, fdc$month_dd_yyyy_format, fdc$iso_date_format, fdc$ydm_format,
                fdc$signed_input_format, fdc$digits_input_format, fdc$currency_input_format =
            p_form_variable_definition^.input_format := variable_attributes [n].input_format;
            variable_attributes [n].put_value_status := fdc$put_value_accepted;

          ELSE
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_input_format_key,
                  p_form_variable_definition^.name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          CASEND;

        = fdc$io_mode =

          CASE variable_attributes [n].io_mode OF

          = fdc$program_input_output, fdc$terminal_input, fdc$terminal_input_output, fdc$terminal_output =
            p_form_variable_definition^.io_mode := variable_attributes [n].io_mode;
            variable_attributes [n].put_value_status := fdc$put_value_accepted;
            IF p_form_variable_definition^.io_mode = fdc$program_input_output THEN
              p_form_variable_definition^.screen_variable_length := 0;
            IFEND;

          ELSE
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_mode,
                  p_form_variable_definition^.name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          CASEND;

        = fdc$new_variable_name =
          fdp$validate_name (variable_attributes [n].new_variable_name, p_form_definition^.processor,
                valid_name, name_is_valid);
          IF NOT name_is_valid THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_name,
                  variable_attributes [n].new_variable_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          IFEND;

          fdp$find_variable_definition (valid_name, p_form_status^.p_form_variable_definitions,
                p_form_definition^.form_variable_definitions.active_number, p_duplicate_variable,
                variable_index, name_exists);
          IF name_exists THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$variable_name_exists,
                  variable_attributes [n].new_variable_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          IFEND;

          fdp$find_table_definition (valid_name, p_form_status^.p_form_table_definitions,
                p_form_definition^.form_table_definitions.active_number, p_form_table_definition, table_index,
                name_exists);
          IF name_exists THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$variable_name_exists,
                  variable_attributes [n].new_variable_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          IFEND;

          p_form_variable_definition^.name := valid_name;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$output_format =
          IF ((p_form_variable_definition^.program_data_type =
                fdc$program_cobol_type) AND
                  (variable_attributes [n].output_format.key <> fdc$currency_output_format)) THEN
            osp$set_status_abnormal (fdc$format_display_identifier,
                  fde$output_format_invalid_cobol,
                  p_form_definition^.form_name, status);
            osp$append_status_parameter (osc$status_parameter_delimiter,
                  p_form_variable_definition^.name,
                  status);
            RETURN;
          IFEND;

{ Compute visual area on form needed to display variable in output format.

          output_format_key := variable_attributes [n].output_format.key;
          CASE output_format_key OF

          = fdc$character_output_format, fdc$currency_output_format =

{ Do nothing.

          = fdc$ydm_output_format =
            p_form_variable_definition^.screen_variable_length := 8;

          = fdc$mdy_output_format =
            p_form_variable_definition^.screen_variable_length := 8;

          = fdc$dmy_output_format =
            p_form_variable_definition^.screen_variable_length := 8;

          = fdc$iso_output_format =
            p_form_variable_definition^.screen_variable_length := 10;

          = fdc$month_dd_yyyy_out_format =
            p_form_variable_definition^.screen_variable_length := 18;

          = fdc$integer_output_format =
            p_form_variable_definition^.screen_variable_length :=
                  variable_attributes [n].output_format.integer_output_format.field_width;

          = fdc$f_output_format, fdc$e_output_format, fdc$g_output_format =
            p_form_variable_definition^.screen_variable_length :=
                  variable_attributes [n].output_format.float_output_format.field_width;

          = fdc$e_e_output_format, fdc$g_e_output_format =
            p_form_variable_definition^.screen_variable_length :=
                  variable_attributes [n].output_format.exponent_output_format.field_width;

          ELSE

{ Invalid output format key.

            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_output_format_key,
                  p_form_definition^.form_name, status);
            RETURN;
          CASEND;

          p_form_variable_definition^.output_format := variable_attributes [n].output_format;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$process_as_event =
          osp$set_status_abnormal (fdc$format_display_identifier, fde$feature_not_implemented,
                p_form_definition^.form_name, status);
          RETURN;

        = fdc$string_compare_rules =
          p_form_variable_definition^.valid_strings.compare_in_upper_case :=
                variable_attributes [n].compare_in_upper_case;
          p_form_variable_definition^.valid_strings.compare_to_unique_substring :=
                variable_attributes [n].compare_to_unique_substring;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$terminal_user_entry =
          p_form_variable_definition^.terminal_user_entry := variable_attributes [n].terminal_user_entry;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$unused_variable_entry =
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$variable_error =
          error_key := variable_attributes [n].variable_error.key;
          CASE error_key OF

          = fdc$no_error_response, fdc$system_default_error =
            p_form_variable_definition^.error_definition.key := variable_attributes [n].variable_error.key;

          = fdc$error_form =
            clp$validate_name (variable_attributes [n].variable_error.error_form, valid_name, name_is_valid);
            IF NOT name_is_valid THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_error_form_name,
                    variable_attributes [n].variable_error.error_form, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                    status);
              RETURN;
            IFEND;

            p_form_variable_definition^.error_definition.key := fdc$error_form;
            p_form_variable_definition^.error_definition.error_form := valid_name;

          = fdc$error_message =
            IF (variable_attributes [n].variable_error.p_error_message = NIL) THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address,
                    p_form_definition^.form_name, status);
              RETURN;
            IFEND;

            NEXT p_error_message: [STRLENGTH (variable_attributes [n].variable_error.p_error_message^)] IN
                  p_form_status^.p_form_module;
            IF p_error_message = NIL THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
              RETURN;
            IFEND;

            p_form_variable_definition^.error_definition.key := fdc$error_message;
            p_form_variable_definition^.error_definition.p_error_message :=
                  #REL (p_error_message, p_form_module^);
            p_error_message^ := variable_attributes [n].variable_error.p_error_message^;

          ELSE

{ Invalid error key.

            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_error_key,
                  p_form_definition^.form_name, status);
            RETURN;
          CASEND;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$variable_help =
          help_key := variable_attributes [n].variable_help.key;
          CASE help_key OF

          = fdc$no_help_response, fdc$system_default_help =
            p_form_variable_definition^.help_definition.key := variable_attributes [n].variable_help.key;

          = fdc$help_form =
            clp$validate_name (variable_attributes [n].variable_help.help_form, valid_name, name_is_valid);
            IF NOT name_is_valid THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_help_form_name,
                    variable_attributes [n].variable_help.help_form, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                    status);
              RETURN;
            IFEND;

            p_form_variable_definition^.help_definition.key := fdc$help_form;
            p_form_variable_definition^.help_definition.help_form := valid_name;

          = fdc$help_message =
            IF (variable_attributes [n].variable_help.p_help_message = NIL) THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_address,
                    p_form_definition^.form_name, status);
              RETURN;
            IFEND;

            NEXT p_help_message: [STRLENGTH (variable_attributes [n].variable_help.p_help_message^)] IN
                  p_form_status^.p_form_module;
            IF p_help_message = NIL THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$no_space_available, '', status);
              RETURN;
            IFEND;

            p_form_variable_definition^.help_definition.key := fdc$help_message;
            p_form_variable_definition^.help_definition.p_help_message :=
                  #REL (p_help_message, p_form_module^);
            p_help_message^ := variable_attributes [n].variable_help.p_help_message^;

          ELSE

{ Invalid help.

            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_help_key,
                  p_form_definition^.form_name, status);
            RETURN;
          CASEND;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        = fdc$variable_length =
          CASE p_form_variable_definition^.program_data_type OF

          = fdc$program_real_type =
            IF variable_attributes [n].variable_length <> fdc$real_length THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_length,
                    p_form_variable_definition^.name, status);
              osp$append_status_integer (osc$status_parameter_delimiter,
                    $INTEGER (variable_attributes [n].variable_length), 10, FALSE, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                    status);
              RETURN;
            IFEND;

          = fdc$program_integer_type =
            IF variable_attributes [n].variable_length <> fdc$integer_length THEN
              osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_length,
                    p_form_variable_definition^.name, status);
              osp$append_status_integer (osc$status_parameter_delimiter,
                    $INTEGER (variable_attributes [n].variable_length), 10, FALSE, status);
              osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                    status);
              RETURN;
            IFEND;

          ELSE { Character data type. }
          CASEND;

          IF ((variable_attributes [n].variable_length < 1) OR
                (variable_attributes [n].variable_length > fdc$maximum_variable_length)) THEN
            osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_length,
                  p_form_variable_definition^.name, status);
            osp$append_status_integer (osc$status_parameter_delimiter,
                  $INTEGER (variable_attributes [n].variable_length), 10, FALSE, status);
            osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
                  status);
            RETURN;
          IFEND;

          p_form_variable_definition^.program_variable_length := variable_attributes [n].variable_length;
          variable_attributes [n].put_value_status := fdc$put_value_accepted;

        ELSE

{ Invalid change variable attribute key.

          osp$set_status_abnormal (fdc$format_display_identifier, fde$invalid_variable_attribute,
                p_form_definition^.form_name, status);
          RETURN;

        CASEND;
      END /process_variable_attribute/;

    FOREND /process_variable_attributes/;


{ Check consistency of COBOL program and display clauses.

    IF NOT cobol_clause_changed THEN
      RETURN;
    IFEND;


    fdp$locate_added_variable_facts (p_form_module, p_form_variable_definition,
          p_added_variable_definition);

    IF ((NOT p_added_variable_definition^.form_cobol_program_clause.defined) OR
          (NOT p_added_variable_definition^.form_cobol_display_clause.defined)) THEN
      RETURN;
    IFEND;

    CASE p_added_variable_definition^.display_cobol_description.cobol_category OF


{ A numeric display clause cannot have a alphabetic or alphanumeric program clause.

    = fdc$cobol_numeric_unsigned, fdc$cobol_numeric_edited =
      CASE p_added_variable_definition^.program_cobol_description.cobol_category OF
      = fdc$cobol_alphabetic, fdc$cobol_alphanumeric =
        osp$set_status_abnormal (fdc$format_display_identifier, fde$incompatible_display_clause,
            p_form_variable_definition^.name, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
              status);
        RETURN;
      ELSE
      CASEND;

    = fdc$cobol_alphabetic =

{ An alphabetic display clause cannot have a numeric program clause.

      CASE p_added_variable_definition^.program_cobol_description.cobol_category OF

      = fdc$cobol_numeric_signed, fdc$cobol_numeric_unsigned =
        osp$set_status_abnormal (fdc$format_display_identifier, fde$incompatible_program_clause,
              p_form_variable_definition^.name, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
              status);
        RETURN;
       ELSE { Other categories are compatible. }
       CASEND;

{ An alphanumeric display clause cannot have a numeric program clause.

    = fdc$cobol_alphanumeric =
      CASE p_added_variable_definition^.program_cobol_description.cobol_category OF

      = fdc$cobol_numeric_signed, fdc$cobol_numeric_unsigned =
        osp$set_status_abnormal (fdc$format_display_identifier, fde$incompatible_program_clause,
              p_form_variable_definition^.name, status);
        osp$append_status_parameter (osc$status_parameter_delimiter, p_form_definition^.form_name,
              status);
        RETURN;
      ELSE { Other categories are compatible. }
      CASEND;

    ELSE { Other categories are compatible. }
    CASEND;

  PROCEND change_variable;

MODEND fdm$process_variable;
