
  CONST
*IF $true(osv$unix)
    dfc$min_ecc = (($INTEGER ('D') * 100(16)) + $INTEGER ('F')) * 10000(16);
*ELSE
    dfc$min_ecc = (($INTEGER ('D') * 100(16)) + $INTEGER ('F')) * 1000000(16);
*IFEND

  CONST
    dfc$file_server_id = 'DF';

  CONST
  dfe$not_system_administrator =  dfc$min_ecc + 1,
   {E You must be at the system console to use the +P1 command +P2

  dfe$invalid_base_address = dfc$min_ecc + 2,
  {E STORNET memory base address must be expressed in multiples of 1000 octal.

  dfe$page_size_too_small = dfc$min_ecc + 3,
  {E File Server requires that the system page size be at least 4096 bytes.

  dfe$driver_cannot_form_adrs = dfc$min_ecc + 4,
  {E STORNET memory_size greater than 40000000(8) allowed only if half_ecs_switch is TRUE.

  dfe$stornet_memory_surpassed = dfc$min_ecc + 5,
  {E The total space required +P1 plus the BASE_ADDRESS of +P2
  { exceeds the total memory of the STORNET +P3.

  dfe$unknown_model_number  = dfc$min_ecc + 6,
  {E The specified model +P1 for mainframe_id +P2 is
  { not recognized as a valid CYBER 180 model.

  dfe$too_many_queue_entries = dfc$min_ecc + 7,
  {E The total size +P1 of queue entries must fit in a page of size +P2.

  dfe$id_number_in_use  = dfc$min_ecc + 8,
  {E The +P1_id_number has already been used to specify a different +P1 mainframe.

  dfe$unable_to_assign_q_entry = dfc$min_ecc + 9,
  {E Internal error: Unable to assign queue entry index, because +P1

  dfe$family_already_defined = dfc$min_ecc + 10,
  {E Family +P1 is already defined.

  dfe$maximum_families_configured  = dfc$min_ecc + 11,
  {E Family +P1 was NOT defined.  The maximum families is +P2.

  dfe$pp_active_during_define = dfc$min_ecc + 12,
  {E Define subcommand can only be issued when Client/Server is INACTIVE or TERMINATED.

  dfe$client_already_configured  = dfc$min_ecc + 13,
  {E The client mainframe +P1 is already configured.

  dfe$client_job_registered  = dfc$min_ecc + 14,
  {E Internal Error: The client job  +P1 is already registered on the server.

   dfe$maximum_jobs_connected  = dfc$min_ecc + 15,
   {E Only a maximum of +P1 client jobs may be connected to the server.

   dfe$bad_client_job_id = dfc$min_ecc + 16,
   {E Internal error: The client_job_id is invalid "+P1".

   dfe$release_q_entry_error = dfc$min_ecc + 17,
   {E Internal error: Unable to release queue entry +P1.

   dfe$improper_mainframe_id = dfc$min_ecc + 18,
   {E The specified mainframe_id +P1 is NOT of the form $SYSTEM_MMMM_NNNN,
   {  Where MMMM is the model number, and NNNN is the serial number. +P2

   dfe$protocol_error_version = dfc$min_ecc + 19,
   {E Internal error: An unexpected buffer version +P1 was received.  Expected +P2

   dfe$protocol_error_sequence = dfc$min_ecc + 20,
   {E Internal error: Queue entry sequence out of order (+P1).  Expecting transaction +P2, received +P3.

   dfe$path_to_stornet_broken = dfc$min_ecc + 21,
   {E File Server's PP driver cannot communicate with STORNET via element_name +P1,
   { iou_name +P2, channel_name +P3. Please verify physical channel connection to STORNET low speed port.

   dfe$invalid_served_family_index  = dfc$min_ecc + 22,
   {E Internal error: Invalid served family index on +P1, pointers index +P2, family_list +P3

   dfe$unknown_driver  = dfc$min_ecc + 23,
   {E  Internal error: Driver +P1 is unknown.

   dfe$driver_already_recorded  = dfc$min_ecc + 24,
   {E Internal error: Driver +P1 is already registered.

   dfe$mainframe_not_client = dfc$min_ecc + 25,
   {E Mainframe +P1 is not a Client.

   dfe$mainframe_not_server = dfc$min_ecc + 26,
   {E Mainframe +P1 is not a Server.

   dfe$client_active = dfc$min_ecc + 27,
   {E Client mainframe +P1 is already Active.

  dfe$server_active = dfc$min_ecc + 28,
  {E Server mainframe +P1 is already Active.

  dfe$client_not_active = dfc$min_ecc + 29,
  {E Client mainframe +P1 is not Active.

  dfe$server_not_active = dfc$min_ecc + 30,
  {E Server mainframe +P1 is not Active.

  dfe$client_not_deleteable = dfc$min_ecc + 31,
  {E Client mainframe +P1 is not deleteable. +P2

  dfe$server_not_deleteable = dfc$min_ecc + 32,
  {E Server mainframe +P1 is not deleteable. +P2

  dfe$server_already_defined = dfc$min_ecc + 33,
  {E Server mainframe +P1 is already defined.

  dfe$family_not_found = dfc$min_ecc+34,
  {E Internal Error: Family +P1 is not a served family.

  dfe$client_deactivated = dfc$min_ecc+35,
  {E Client +P1 is deactivating, you must wait for deactivation
  {  process to complete.

  dfe$server_deactivated = dfc$min_ecc+36,
  {E Server +P1 is deactivating, you must wait for deactivation
  {  process to complete.

  dfe$client_verification_error = dfc$min_ecc+37,
  {E Client +P1 verification error, +P2.

  dfe$server_verification_error = dfc$min_ecc+38,
  {E Server +P1 verification error, +P2.

  dfe$invalid_channel = dfc$min_ecc+39,
  {E The channel +P1 +P2 for mainframe +P3 is not listed in the element definition
  {  for element +P4.

  dfe$client_already_terminated = dfc$min_ecc+40,
  {E Client +P1 is already terminated.

   dfe$not_stornet_connection = dfc$min_ecc + 41,
   {E  Internal error: Connection +P1 is not an STORNET connection type.

   dfe$connection_not_changed = dfc$min_ecc + 42,
   {E Internal error: Connection +P1 must be deactivated before changing connection.

   dfe$invalid_stornet_product_id = dfc$min_ecc + 43,
   {E Either product number +P1 or model number +P2 is invalid for STORNET product identification.

   dfe$no_configured_channel = dfc$min_ecc + 44,
   {E No configured channel found in element definition for element +P1.

   dfe$no_configured_equipment = dfc$min_ecc + 45,
   {E Channel definition for +P1 has no configured equipment element +P2.

   dfe$server_has_terminated = dfc$min_ecc+46,
   {E Server +P1 has terminated.

   dfe$os_name_conflict = dfc$min_ecc+47,
   {W Server +P1 OS version "+P2" conflicts with Client's OS version "+P3".

   dfe$client_lifetime_error = dfc$min_ecc + 48,
   {E Client/Server -  +P1 - lifetime/birthdate mismatch, +P2.
   {+N3  Recovery not possible. Both client and server will be terminated and re-activated.

   dfe$element_still_reserved = dfc$min_ecc + 49,
   {E Mainframe +P1 cannot be deleted while element +P2 is still reserved.

   dfe$invalid_queue_entry_id  = dfc$min_ecc + 50,
   {E  Internal error: The remote procedure call queue entry location is invalid (+P1)
   { on the +P2 request.

   dfe$family_not_served  = dfc$min_ecc + 51,
   {E  Internal error: Family +P1 is not a served family.

   dfe$invalid_server_locator = dfc$min_ecc + 52,
   {E  Internal error: The server_location is invalid.+P1

   dfe$restart_server_request  = dfc$min_ecc + 53,
   {E internal: The remote procedure call request should be restarted.

   dfe$driver_error_occurred = dfc$min_ecc + 54,
   {E Internal error: An error (+P1) occurred in the file server driver.

   dfe$test_checksum_error  = dfc$min_ecc + 55,
   {E Internal error: A checksum error (+P1) occurred in the test code.

   dfe$data_length_error = dfc$min_ecc + 56,
   {E Internal error: Attempting to send more data than has been referenced.

   dfe$no_families_when_zero_nomqe = dfc$min_ecc + 57,
   {E A served family cannot be specified when the number of monitor queue entries
   { (specified on the DEFINE_SERVER subcommand) is zero.

   dfe$client_too_active_for_chaca = dfc$min_ecc + 58,
   {E CHANGE_CLIENT_ACCESS of an accessed family cannot be processed while
   { client +P1 is ACTIVE, ACTIVATING, or DEACTIVATED.

   dfe$max_families_or_clients = dfc$min_ecc + 59,
   {E The total number of of accessible +P1 (+P2) would exceed the
   { maximum (+P1) if CHANGE_CLIENT_ACCESS processed the given parameters.

   dfe$stornet_side_door_def_err = dfc$min_ecc + 60,
   {E Too many names specified for side_door_port parameter.

   dfe$send_channel_invalid_iou = dfc$min_ecc + 61,
   {E IOU name +P1 specified in SEND_CHANNEL parameter is invalid.

   dfe$too_many_low_speed_ports = dfc$min_ecc + 62,
   {E Internal error : STORNET element +P1 contains too many low_speed_ports.

   dfe$sfid_gfn_mismatch = dfc$min_ecc + 63,
   {E Internal error: Global_file_name on client does not match the
   { global_file_name on server for the remote system_file_id: +P1

   dfe$too_many_servers_or_clients = dfc$min_ecc + 64,
   {E Maximum mainframes for this connection has been reached and they
   { are all Servers or all Clients: definition for +P1 rejected.

   dfe$side_door_iou_name_err = dfc$min_ecc + 65,
   {E Specified STORNET side_door_port IOU name (+P1) is in error.

   dfe$stornet_already_defined = dfc$min_ecc + 66,
   {E STORNET element +P1 has already been defined.

   dfe$stornet_not_defined = dfc$min_ecc + 67,
   {E STORNET element +P1 has not been defined with Define_Stornet_Connection command.

   dfe$system_family_not_allowed = dfc$min_ecc + 68,
   {E System Family +P1 cannot be defined as Served Family.

   dfe$receive_channel_invalid_iou = dfc$min_ecc + 69,
   {E IOU name +P1 specified in RECEIVE_CHANNEL parameter is invalid.

   dfe$stornet_has_mainframes = dfc$min_ecc + 71,
   {E Client(s) and/or Server(s) are still defined with this
   { STORNET (+P1) connection.

   dfe$server_is_activating = dfc$min_ecc+72,
   {E Define_Served_Families cannot be issued while Server is Activating.

   dfe$incorrect_server_mainframe = dfc$min_ecc+73,
   {E Server Poll Reply contains incorrect mainframe, expected +P1,
   { received +P2.

   dfe$client_is_activating = dfc$min_ecc+75,
   {E The client mainframe is already activating.

   dfe$id_number_exceeds_nomf = dfc$min_ecc+76,
   {E +P1_ID_number of +P2 is greater than number_of_mainframes value of +P3.

   dfe$info_full = dfc$min_ecc+77,
   {E Internal Error:  Not enough room in the sequence to receive requested info.

   dfe$no_segment_reserved = dfc$min_ecc+78,
   {E Internal Error: Attempting to receive segment but none reserved on the server.

   dfe$task_not_established = dfc$min_ecc+79,
   {E Internal Error: Unable to establish +P task.

   dfe$force_server_recovery = dfc$min_ecc+80,
   {W The client mainframe +P1 is awaiting_recovery but the server is inactive.
   {+N3 Forcing the state on the server to awaiting_recovery and re-activating.

   dfe$job_needs_recovery  = dfc$min_ecc+81,
   {E Internal:  The job needs recovery for server +P1.

   dfe$client_mf_file_unrecovered = dfc$min_ecc+82,
   {E The client mainframe +P1 cannot be recovered +P2.

   dfe$server_request_terminated  = dfc$min_ecc+83,
   {E The +P1 request to server mainframe +P2 has been terminated due to a server failure.
   {+N3 It is unknown if the request was completed on the server mainframe.

   dfe$force_client_recovery = dfc$min_ecc+84,
   {W The client mainframe +P1 is inactive, but the server is awaiting_recovery.
   {+N3 Forcing the state on the client to awaiting_recovery and re-activating.

   dfe$no_space_for_server_pages = dfc$min_ecc+85,
   {E There was not enough disk space to write the pages for server +P1.
   { +N3 Please consider using the PREALLOCATE_IMAGE_SIZE parameter on DEFINE_SERVER.
   { +N3 +P2

   dfe$restart_server_task  = dfc$min_ecc+86,
   {E Internal: Automatically restarting the system task for server +P1.

   dfe$force_client_termination = dfc$min_ecc+87,
   {W The server mainframe is terminated but the client +P1 is not.
   {+N3 Issuing Terminate_server on the client +P1 and re-activating.

   dfe$force_server_termination = dfc$min_ecc+88,
   {W The client mainframe +P1 is terminated but the server is not.
   {+N3 Issuing Terminate_client on the server mainframe and re-activating.

   dfe$application_not_known = dfc$min_ecc+89,
   {E Application +P1 is not known.

   dfe$procedure_not_known = dfc$min_ecc+90,
   {E Procedure +P1 is not defined for application +P2.

   dfe$application_already_defined = dfc$min_ecc+91,
   {E Application +P1 has already been defined.

   dfe$procedure_already_defined = dfc$min_ecc+92,
   {E Procedure +P1 has already been defined for application +P2.

   dfe$callers_variable_too_large = dfc$min_ecc+93,
   {E +P1 callers +P2 variable is larger than the maximum +P3.

   dfe$callers_variable_too_small = dfc$min_ecc+94,
   {E +P1 callers +P2 variable is smaller than the returned size of +P3.

   dfe$client_terminate_break= dfc$min_ecc+95,
   {E Remote procedure +P1 has received a terminate-break issued by caller on client.

   dfe$remote_proc_load_failure = dfc$min_ecc+96,
   {E Remote procedure +P1 cannot be executed due to a problem encountered while loading.

   dfe$invalid_parameter_pva = dfc$min_ecc+97,
   {E Parameter +P1 for procedure +P2 specifies an invalid PVA.

   dfe$invalid_state_for_def_app = dfc$min_ecc+98,
   {E Subcommand +P1 can be executed only when the state of the partner
   { mainframe +P2 is TERMINATED or AWAITING RECOVERY.

   dfe$no_partner_mainframe = dfc$min_ecc+99,
   {E There is no partner mainframe associated with the caller of +P1.

   dfe$scp_par_requires_lib_par = dfc$min_ecc+100,
   {E A value for the LIBRARY parameter is required if the
   { STATE_CHANGE_PROCEDURE parameter is specified.

   dfe$max_remote_proc_count = dfc$min_ecc+101,
   {E Maximum remote procedure count of +P1 exceeded.

   dfe$max_application_count = dfc$min_ecc+102,
   {E Maximum application count of +P1 exceeded.

   dfe$out_of_range_value = dfc$min_ecc+103,
   {E The value of parameter +P1 +P2 is +P3 which is outside the
   { limits of +P4 to +P5.

   dfe$client_pause_break= dfc$min_ecc+104,
   {E Remote procedure +P1 has received a pause-break issued by caller on client.

   dfe$task_services_timeout = dfc$min_ecc+105,
   {E The mainframe +P1 is blocking a request to a queue a task services request
   { and is being timed out.

   dfe$stornet_channel_mismatch = dfc$min_ecc + 106,
   {E The +P1 channel specified does not match the corresponding channel
   { specified on previously entered DEFINE commands for this STORNET element.

   dfc$null_parameter = '',

   dfc$min_driver_test_errors = dfc$min_ecc + 200,

   dfe$test_startup_error = dfc$min_ecc + 333,
   {E Internal: Test error "+P1"

   dfc$min_cdcnet_errors = dfc$min_ecc + 400,

   dfc$min_mm_recovery_errors = dfc$min_ecc + 600;

*copyc dfe$cdcnet_errors
*copyc dfe$driver_test_errors
*copyc dfe$mm_recovery_errors
