Class sz390

All Implemented Interfaces:
Runnable

public class sz390 extends Object implements Runnable
sz390 is the SVC component of z390 which handles SVC calls and associated functions
  • Field Details

    • max_tiot_files

      int max_tiot_files
      variable
    • max_cde_pgms

      int max_cde_pgms
      variable
    • max_cmd_out

      int max_cmd_out
      variable
    • max_cmd_proc

      int max_cmd_proc
      variable
    • max_lsn_spec

      int max_lsn_spec
      variable
    • max_dir_list

      int max_dir_list
      variable
    • max_guam_buff

      int max_guam_buff
      variable
    • max_ecb_count

      int max_ecb_count
      variable
    • max_env_name_len

      int max_env_name_len
      variable
    • max_env_value_len

      int max_env_value_len
      variable
    • env_name_addr

      int env_name_addr
      variable
    • env_value_addr

      int env_value_addr
      variable
    • env_name

      String env_name
      variable
    • env_value

      String env_value
      variable
    • tz390

      tz390 tz390
      variable
    • pz390

      pz390 pz390
      variable
    • vz390

      vz390 vz390
      variable
    • msg_id

      String msg_id
      variable
    • pz390_running

      boolean pz390_running
      variable
    • put_stats_running

      boolean put_stats_running
      variable
    • ez390_pgm

      String ez390_pgm
      variable
    • ez390_rc

      int ez390_rc
      variable
    • ez390_errors

      int ez390_errors
      variable
    • ez390_recursive_abort

      boolean ez390_recursive_abort
      variable
    • load_file_name

      String load_file_name
      variable
    • z390_file

      RandomAccessFile z390_file
      variable
    • log_file

      File log_file
      variable
    • log_file_buff

      BufferedWriter log_file_buff
      variable
    • opt_parms

      String opt_parms
      variable
    • opt_ok

      boolean opt_ok
      variable
    • exit_request

      boolean exit_request
      variable
    • system_abend

      boolean system_abend
      variable
    • user_abend

      boolean user_abend
      variable
    • svc_abend_type

      boolean svc_abend_type
      variable
    • svc_req_dump

      boolean svc_req_dump
      variable
    • dump_taken

      boolean dump_taken
      variable
    • long_psw_amode31_bit

      long long_psw_amode31_bit
      variable
    • stimer_exit_time

      long stimer_exit_time
      variable
    • stimer_exit_addr

      int stimer_exit_addr
      variable
    • stimer_exit_request

      boolean stimer_exit_request
      variable
    • stimer_exit_running

      boolean stimer_exit_running
      variable
    • stimer_save_r13

      int stimer_save_r13
      variable
    • stimer_save_r14

      int stimer_save_r14
      variable
    • stimer_save_r15

      int stimer_save_r15
      variable
    • stimer_save_psw

      int stimer_save_psw
      variable
    • gz390

      gz390 gz390
      variable
    • guam_major

      int guam_major
      variable
    • guam_minor

      int guam_minor
      variable
    • guam_args

      int guam_args
      variable
    • guam_view_mcs

      int guam_view_mcs
      variable
    • guam_view_tn3270

      int guam_view_tn3270
      variable
    • guam_view_graph

      int guam_view_graph
      variable
    • guam_view

      int guam_view
      variable
    • guam_x

      int guam_x
      variable
    • guam_y

      int guam_y
      variable
    • guam_x2

      int guam_x2
      variable
    • guam_y2

      int guam_y2
      variable
    • guam_color

      int guam_color
      variable
    • guam_width

      int guam_width
      variable
    • guam_height

      int guam_height
      variable
    • guam_row

      int guam_row
      variable
    • guam_col

      int guam_col
      variable
    • guam_bg_rgb

      int guam_bg_rgb
      variable
    • guam_text_rgb

      int guam_text_rgb
      variable
    • guam_lfield

      int guam_lfield
      variable
    • guam_cursor_type

      int guam_cursor_type
      variable
    • guam_font

      int guam_font
      variable
    • guam_abuff

      int guam_abuff
      variable
    • guam_lbuff

      int guam_lbuff
      variable
    • guam_key_amod

      int guam_key_amod
      variable
    • guam_key_achar

      int guam_key_achar
      variable
    • guam_key

      int guam_key
      variable
    • guam_mouse

      int[] guam_mouse
      variable
    • guam_left

      int guam_left
      variable
    • guam_right

      int guam_right
      variable
    • guam_wait

      boolean guam_wait
      variable
    • tpg_flags

      int tpg_flags
      variable
    • tpg_op_mask

      int tpg_op_mask
      variable
    • tpg_op_tget

      int tpg_op_tget
      variable
    • tpg_op_tput

      int tpg_op_tput
      variable
    • tpg_wait_mask

      int tpg_wait_mask
      variable
    • tpg_wait

      int tpg_wait
      variable
    • tpg_nowait

      int tpg_nowait
      variable
    • tpg_type_mask

      int tpg_type_mask
      variable
    • tpg_type_edit

      int tpg_type_edit
      variable
    • tpg_type_asis

      int tpg_type_asis
      variable
    • tpg_type_control

      int tpg_type_control
      variable
    • tpg_type_fullscr

      int tpg_type_fullscr
      variable
    • tget_byte

      byte[] tget_byte
      variable
    • tget_buff

      ByteBuffer tget_buff
      variable
    • tput_byte

      byte[] tput_byte
      variable
    • tput_buff

      ByteBuffer tput_buff
      variable
    • guam_text

      String guam_text
      variable
    • ins_count

      int ins_count
      variable
    • io_count

      int io_count
      variable
    • monitor_timer

      Timer monitor_timer
      variable
    • monitor_cmd_time_total

      long monitor_cmd_time_total
      variable
    • monitor_last_time

      long monitor_last_time
      variable
    • monitor_next_time

      long monitor_next_time
      variable
    • monitor_cur_interval

      long monitor_cur_interval
      variable
    • monitor_last_ins_count

      int monitor_last_ins_count
      variable
    • monitor_next_ins_count

      int monitor_next_ins_count
      variable
    • monitor_last_io_count

      int monitor_last_io_count
      variable
    • monitor_next_io_count

      int monitor_next_io_count
      variable
    • monitor_cur_ins

      long monitor_cur_ins
      variable
    • monitor_cur_int

      long monitor_cur_int
      variable
    • monitor_cur_rate

      long monitor_cur_rate
      variable
    • wto_fld

      int wto_fld
      variable
    • wto_len

      int wto_len
      variable
    • wtor_reply_buff

      BufferedReader wtor_reply_buff
      variable
    • wtor_reply_pending

      boolean wtor_reply_pending
      variable
    • wtor_reply_string

      String wtor_reply_string
      variable
    • wtor_reply_addr

      int wtor_reply_addr
      variable
    • wtor_reply_len

      int wtor_reply_len
      variable
    • wtor_ecb_addr

      int wtor_ecb_addr
      variable
    • ecb_waiting

      int ecb_waiting
      variable
    • ecb_posted

      int ecb_posted
      variable
    • wait_count

      int wait_count
      variable
    • wait_addr

      int wait_addr
      variable
    • wait_retry

      boolean wait_retry
      variable
    • cmd_proc

      Process[] cmd_proc
      variable
    • cmd_proc_thread

      Thread[] cmd_proc_thread
      variable
    • cmd_error_thread

      Thread[] cmd_error_thread
      variable
    • cmd_output_thread

      Thread[] cmd_output_thread
      variable
    • cmd_error_reader

      BufferedReader[] cmd_error_reader
      variable
    • cmd_output_reader

      BufferedReader[] cmd_output_reader
      variable
    • cmd_input_writer

      PrintStream[] cmd_input_writer
      variable
    • cmd_output_queue

      LinkedList<String>[] cmd_output_queue
      variable
    • cmd_proc_running

      boolean[] cmd_proc_running
      variable
    • cmd_proc_cmdlog

      boolean[] cmd_proc_cmdlog
      variable
    • cmd_proc_rc

      int[] cmd_proc_rc
      variable
    • cmd_proc_io

      int[] cmd_proc_io
      variable
    • cmd_proc_start_time

      long[] cmd_proc_start_time
      variable
    • cmd_error_msg

      String[] cmd_error_msg
      variable
    • cmd_output_msg

      String[] cmd_output_msg
      variable
    • cmd_read_line

      String[] cmd_read_line
      variable
    • tot_cmd

      int tot_cmd
      variable
    • cmd_io_total

      int cmd_io_total
      variable
    • tot_log_queue

      int tot_log_queue
      variable
    • test_first_cmd

      boolean test_first_cmd
      variable
    • test_file_name

      String test_file_name
      variable
    • test_cmd_abort

      boolean test_cmd_abort
      variable
    • test_loop_count

      int test_loop_count
      variable
    • test_cmd_file

      BufferedReader test_cmd_file
      variable
    • test_cmd

      String test_cmd
      variable
    • test_pattern

      Pattern test_pattern
      variable
    • test_match

      Matcher test_match
      variable
    • test_token

      String test_token
      variable
    • test_bias

      char test_bias
      variable
    • test_token_len

      int test_token_len
      variable
    • test_opcode

      char test_opcode
      variable
    • test_addr

      int test_addr
      variable
    • test_next_addr

      int test_next_addr
      variable
    • test_sdt

      String test_sdt
      variable
    • test_addr_type

      byte test_addr_type
      variable
    • test_addr_mem

      byte test_addr_mem
      variable
    • test_addr_reg

      byte test_addr_reg
      variable
    • test_addr_sdt

      byte test_addr_sdt
      variable
    • test_addr_psw

      byte test_addr_psw
      variable
    • test_compare

      byte test_compare
      variable
    • test_base_addr

      int test_base_addr
      variable
    • test_mem_loc

      int test_mem_loc
      variable
    • test_mem_len

      int test_mem_len
      variable
    • test_reg_loc

      int test_reg_loc
      variable
    • test_reg_sdt

      long test_reg_sdt
      variable
    • test_mem_sdt

      byte[] test_mem_sdt
      variable
    • test_v_retcode

      int test_v_retcode
      variable
    • test_script_mode_batch

      boolean test_script_mode_batch
      variable
    • test_break_addr_mode

      boolean test_break_addr_mode
      variable
    • test_break_reg_mode

      boolean test_break_reg_mode
      variable
    • test_break_mem_mode

      boolean test_break_mem_mode
      variable
    • test_break_op_mode

      boolean test_break_op_mode
      variable
    • tot_test_break_addr

      int tot_test_break_addr
      variable
    • max_break_addr

      int max_break_addr
      variable
    • test_break_addr

      int[] test_break_addr
      variable
    • test_break_op_ins

      long test_break_op_ins
      variable
    • test_break_addr_cmd

      String[] test_break_addr_cmd
      variable
    • test_break_reg_cmd

      String test_break_reg_cmd
      variable
    • test_break_mem_cmd

      String test_break_mem_cmd
      variable
    • test_break_op_cmd

      String test_break_op_cmd
      variable
    • test_break_reg

      boolean test_break_reg
      variable
    • test_break_mem

      boolean test_break_mem
      variable
    • test_break_reg_loc

      int test_break_reg_loc
      variable
    • test_break_reg_compare

      int test_break_reg_compare
      variable
    • test_break_reg_val

      long test_break_reg_val
      variable
    • test_break_reg_sdt

      long test_break_reg_sdt
      variable
    • test_break_mem_loc

      int test_break_mem_loc
      variable
    • test_break_mem_byte

      byte test_break_mem_byte
      variable
    • test_break_mem_compare

      int test_break_mem_compare
      variable
    • test_break_mem_equal

      int test_break_mem_equal
      variable
    • test_break_mem_sdt

      byte[] test_break_mem_sdt
      variable
    • test_break_op1

      int test_break_op1
      variable
    • test_break_op2

      int test_break_op2
      variable
    • test_break_op2_index

      int test_break_op2_index
      variable
    • test_break_op2_mask

      int test_break_op2_mask
      variable
    • cur_date_MMddyy

      SimpleDateFormat cur_date_MMddyy
      variable
    • cur_tod_hhmmss

      SimpleDateFormat cur_tod_hhmmss
      variable
    • cur_tod_hhmmss00

      SimpleDateFormat cur_tod_hhmmss00
      variable
    • cur_date_yyyy

      SimpleDateFormat cur_date_yyyy
      variable
    • cur_date_MM

      SimpleDateFormat cur_date_MM
      variable
    • cur_date_dd

      SimpleDateFormat cur_date_dd
      variable
    • cur_date_HH

      SimpleDateFormat cur_date_HH
      variable
    • cur_date_mm

      SimpleDateFormat cur_date_mm
      variable
    • cur_date_ss

      SimpleDateFormat cur_date_ss
      variable
    • cur_date_ms

      SimpleDateFormat cur_date_ms
      variable
    • cur_date_yyddd

      SimpleDateFormat cur_date_yyddd
      variable
    • cur_date_yyyyddd

      SimpleDateFormat cur_date_yyyyddd
      variable
    • cur_date_MMddyyyy

      SimpleDateFormat cur_date_MMddyyyy
      variable
    • cur_date_ddMMyyyy

      SimpleDateFormat cur_date_ddMMyyyy
      variable
    • cur_date_yyyyMMdd

      SimpleDateFormat cur_date_yyyyMMdd
      variable
    • cur_date_year

      int cur_date_year
      variable
    • cur_date_month

      int cur_date_month
      variable
    • cur_date_day

      int cur_date_day
      variable
    • tod_hour

      int tod_hour
      variable
    • tod_min

      int tod_min
      variable
    • tod_sec

      int tod_sec
      variable
    • tod_msec

      int tod_msec
      variable
    • time_mil

      long time_mil
      variable
    • cur_date_cal

      Calendar cur_date_cal
      variable
    • tod_start_day

      long tod_start_day
      variable
    • tod_start_pgm

      long tod_start_pgm
      variable
    • tod_end_pgm

      long tod_end_pgm
      variable
    • tot_sec

      long tot_sec
      variable
    • tod_time_limit

      long tod_time_limit
      variable
    • next_time_ins

      int next_time_ins
      variable
    • next_time_check

      int next_time_check
      variable
    • log_tod

      boolean log_tod
      variable
    • z390_log_text

      JTextArea z390_log_text
      variable
    • z390_command_text

      JTextField z390_command_text
      variable
    • ez390_startup

      boolean ez390_startup
      variable
    • load_code_ver

      char[] load_code_ver
      variable
    • z390_flags

      char[] z390_flags
      variable
    • z390_flags_amode31

      int z390_flags_amode31
      variable
    • z390_flags_rmode31

      int z390_flags_rmode31
      variable
    • load_dsn

      String load_dsn
      variable
    • load_dsn_addr

      int load_dsn_addr
      variable
    • load_pgm_dir

      String load_pgm_dir
      variable
    • load_pgm_name

      String load_pgm_name
      variable
    • alias_name_byte

      byte[] alias_name_byte
      variable
    • load_pgm_type

      String load_pgm_type
      variable
    • load_vcdt_entry

      String load_vcdt_entry
      variable
    • load_vcdt_mode

      boolean load_vcdt_mode
      variable
    • load_code_load

      int load_code_load
      variable
    • load_code_len

      int load_code_len
      variable
    • load_code_ent

      int load_code_ent
      variable
    • load_code_rlds

      int load_code_rlds
      variable
    • tot_cde

      int tot_cde
      variable
    • cur_cde

      int cur_cde
      variable
    • cde_name

      String[] cde_name
      variable
    • cde_file

      String[] cde_file
      variable
    • cde_use

      short[] cde_use
      variable
    • cde_loc

      int[] cde_loc
      variable
    • cde_len

      int[] cde_len
      variable
    • cde_ent

      int[] cde_ent
      variable
    • cde_addr

      int[] cde_addr
      variable
    • cded_len

      int cded_len
      variable
    • rld_loc

      int rld_loc
      variable
    • rld_len

      byte rld_len
      variable
    • ctd_display_len

      int ctd_display_len
      variable
    • ctd_e

      float ctd_e
      variable
    • ctd_d

      double ctd_d
      variable
    • ctd_byte

      byte[] ctd_byte
      variable
    • ctd_bi

      BigInteger ctd_bi
      variable
    • ctd_bd

      BigDecimal ctd_bd
      variable
    • ctd_text

      String ctd_text
      variable
    • cfd_e

      float cfd_e
      variable
    • cfd_d

      double cfd_d
      variable
    • cfd_byte

      byte[] cfd_byte
      variable
    • cfd_bi

      BigInteger cfd_bi
      variable
    • cfd_bd

      BigDecimal cfd_bd
      variable
    • cfd_text

      String cfd_text
      variable
    • lock

      final Lock lock
      variable
    • lock_condition

      final Condition lock_condition
      variable
    • tcpio_server_running

      boolean tcpio_server_running
      variable
    • tcpio_conn_ready_count

      int tcpio_conn_ready_count
      variable
    • max_tcp_server_port

      int max_tcp_server_port
      variable
    • cur_tcp_server_index

      int cur_tcp_server_index
      variable
    • tcp_server_port

      int[] tcp_server_port
      variable
    • tcp_server_open

      boolean[] tcp_server_open
      variable
    • tcp_server_thread

      Thread[] tcp_server_thread
      variable
    • tcp_server_conn_index

      int[] tcp_server_conn_index
      variable
    • tcp_server_socket

      ServerSocket[] tcp_server_socket
      variable
    • tcp_server_host_text

      String[] tcp_server_host_text
      variable
    • tcp_server_host_ip

      InetAddress[] tcp_server_host_ip
      variable
    • max_tcp_conn

      int max_tcp_conn
      variable
    • cur_tcp_conn

      int cur_tcp_conn
      variable
    • tcp_conn_thread

      Thread[] tcp_conn_thread
      variable
    • tcp_conn_socket

      Socket[] tcp_conn_socket
      variable
    • tcp_conn_server_port

      int[] tcp_conn_server_port
      variable
    • tcp_conn_server_index

      int[] tcp_conn_server_index
      variable
    • tcp_conn_msg_ready

      boolean[] tcp_conn_msg_ready
      variable
    • tcp_conn_read

      boolean[] tcp_conn_read
      variable
    • tcp_conn_byte

      byte[] tcp_conn_byte
      variable
    • tcp_conn_input

      DataInputStream[] tcp_conn_input
      variable
    • tcp_conn_output

      PrintStream[] tcp_conn_output
      variable
    • max_tcp_client_port

      int max_tcp_client_port
      variable
    • cur_tcp_client_index

      int cur_tcp_client_index
      variable
    • tcp_client_port

      int[] tcp_client_port
      variable
    • tcp_client_socket

      Socket[] tcp_client_socket
      variable
    • tcp_client_host_text

      String[] tcp_client_host_text
      variable
    • tcp_client_host_ip

      InetAddress[] tcp_client_host_ip
      variable
    • tcp_client_input

      DataInputStream[] tcp_client_input
      variable
    • tcp_client_output

      PrintStream[] tcp_client_output
      variable
    • tcpio_op

      int tcpio_op
      variable
    • tcpio_flags

      int tcpio_flags
      variable
    • tcpio_wait

      boolean tcpio_wait
      variable
    • tcpio_conn

      int tcpio_conn
      variable
    • tcpio_amsg

      int tcpio_amsg
      variable
    • tcpio_lmsg

      int tcpio_lmsg
      variable
    • tcpio_lmax

      int tcpio_lmax
      variable
    • tcpio_lmin

      int tcpio_lmin
      variable
    • tcpio_host_ip_addr

      int tcpio_host_ip_addr
      variable
    • tcpio_host_ip_text

      String tcpio_host_ip_text
      variable
    • tcpio_host_name

      String tcpio_host_name
      variable
    • tcpio_host_ip

      InetAddress tcpio_host_ip
      variable
    • tcpio_port

      int tcpio_port
      variable
    • tot_tcpio_oper

      int tot_tcpio_oper
      variable
    • tot_tcpio_openc

      int tot_tcpio_openc
      variable
    • tot_tcpio_opens

      int tot_tcpio_opens
      variable
    • tot_tcpio_closec

      int tot_tcpio_closec
      variable
    • tot_tcpio_closes

      int tot_tcpio_closes
      variable
    • tot_tcpio_send

      int tot_tcpio_send
      variable
    • tot_tcpio_recv

      int tot_tcpio_recv
      variable
    • tot_tiot_files

      int tot_tiot_files
      variable
    • cur_tiot_index

      int cur_tiot_index
      variable
    • tot_dcb_oper

      int tot_dcb_oper
      variable
    • tot_dcb_open

      int tot_dcb_open
      variable
    • tot_dcb_close

      int tot_dcb_close
      variable
    • tot_dcb_get

      int tot_dcb_get
      variable
    • tot_dcb_put

      int tot_dcb_put
      variable
    • tot_dcb_read

      int tot_dcb_read
      variable
    • tot_dcb_write

      int tot_dcb_write
      variable
    • cur_decb_addr

      int cur_decb_addr
      variable
    • cur_ecb

      int cur_ecb
      variable
    • decb_ecb

      int decb_ecb
      variable
    • decb_type

      int decb_type
      variable
    • decb_dcb

      int decb_dcb
      variable
    • decb_area

      int decb_area
      variable
    • cur_rba

      long cur_rba
      variable
    • cur_dcb_addr

      int cur_dcb_addr
      variable
    • cur_open_opt

      int cur_open_opt
      variable
    • cur_dcbe_addr

      int cur_dcbe_addr
      variable
    • cur_dcb_ddnam

      String cur_dcb_ddnam
      variable
    • cur_dcb_file_name

      String cur_dcb_file_name
      variable
    • cur_dcb_oflgs

      int cur_dcb_oflgs
      variable
    • cur_dcb_synad

      int cur_dcb_synad
      variable
    • cur_dcb_eodad

      int cur_dcb_eodad
      variable
    • cur_dcb_macrf

      int cur_dcb_macrf
      variable
    • cur_dcb_recfm

      int cur_dcb_recfm
      variable
    • cur_dcb_area

      int cur_dcb_area
      variable
    • cur_dcb_lrecl_f

      int cur_dcb_lrecl_f
      variable
    • cur_dcb_blksi_f

      int cur_dcb_blksi_f
      variable
    • cur_vrec_lrecl

      int cur_vrec_lrecl
      variable
    • cur_rec_text

      String cur_rec_text
      variable
    • cur_rec_len

      int cur_rec_len
      variable
    • dcb_dsorg

      int dcb_dsorg
      variable
    • dcb_dsorg_ps

      int dcb_dsorg_ps
      variable
    • dcb_dsorg_da

      int dcb_dsorg_da
      variable
    • dcb_iobad

      int dcb_iobad
      variable
    • dcb_eodad

      int dcb_eodad
      variable
    • dcb_recfm

      int dcb_recfm
      variable
    • dcb_recfm_f

      int dcb_recfm_f
      variable
    • dcb_recfm_v

      int dcb_recfm_v
      variable
    • dcb_recfm_fb

      int dcb_recfm_fb
      variable
    • dcb_recfm_vb

      int dcb_recfm_vb
      variable
    • dcb_recfm_ft

      int dcb_recfm_ft
      variable
    • dcb_recfm_vt

      int dcb_recfm_vt
      variable
    • dcb_ddnam

      int dcb_ddnam
      variable
    • dcb_id

      int dcb_id
      variable
    • dcb_oflgs

      int dcb_oflgs
      variable
    • dcb_oflgs_open

      int dcb_oflgs_open
      variable
    • dcb_oflgs_r

      int dcb_oflgs_r
      variable
    • dcb_oflgs_w

      int dcb_oflgs_w
      variable
    • dcb_oflgs_rw

      int dcb_oflgs_rw
      variable
    • dcb_macrf

      int dcb_macrf
      variable
    • dcb_macrf_gm

      int dcb_macrf_gm
      variable
    • dcb_macrf_pm

      int dcb_macrf_pm
      variable
    • dcb_macrf_gl

      int dcb_macrf_gl
      variable
    • dcb_macrf_pl

      int dcb_macrf_pl
      variable
    • dcb_macrf_r

      int dcb_macrf_r
      variable
    • dcb_macrf_w

      int dcb_macrf_w
      variable
    • dcb_macrf_rw

      int dcb_macrf_rw
      variable
    • dcb_synad

      int dcb_synad
      variable
    • dcb_blksi_f

      int dcb_blksi_f
      variable
    • dcb_lrecl_f

      int dcb_lrecl_f
      variable
    • dcb_rec

      int dcb_rec
      variable
    • dcb_dsnam

      int dcb_dsnam
      variable
    • dcb_dcbe

      int dcb_dcbe
      variable
    • dcb_io

      int dcb_io
      variable
    • dcb_len

      int dcb_len
      variable
    • dcbe_flg1

      int dcbe_flg1
      variable
    • dcbeulbi

      int dcbeulbi
      variable
    • dcbe_eodad

      int dcbe_eodad
      variable
    • dcbe_synad

      int dcbe_synad
      variable
    • dcb_synad_recur

      boolean dcb_synad_recur
      variable
    • tiot_dcb_open

      boolean[] tiot_dcb_open
      variable
    • tiot_ddnam

      String[] tiot_ddnam
      variable
    • tiot_dsn

      String[] tiot_dsn
      variable
    • tiot_dcb_addr

      int[] tiot_dcb_addr
      variable
    • tiot_vrec_blksi

      int[] tiot_vrec_blksi
      variable
    • tiot_cur_rba

      long[] tiot_cur_rba
      variable
    • tiot_eof_rba

      long[] tiot_eof_rba
      variable
    • tiot_file

      RandomAccessFile[] tiot_file
      variable
    • ascii_lf

      int ascii_lf
      variable
    • ascii_cr

      int ascii_cr
      variable
    • ascii_period

      int ascii_period
      variable
    • ascii_space

      int ascii_space
      variable
    • ebcdic_period

      int ebcdic_period
      variable
    • ebcdic_space

      int ebcdic_space
      variable
    • req_addr

      int req_addr
      variable
    • req_len

      int req_len
      variable
    • req_opt

      int req_opt
      variable
    • cur_fqe

      int cur_fqe
      variable
    • cur_fqe_len

      int cur_fqe_len
      variable
    • prev_fqe

      int prev_fqe
      variable
    • next_fqe

      int next_fqe
      variable
    • next_fqe_len

      int next_fqe_len
      variable
    • best_cur_fqe

      int best_cur_fqe
      variable
    • best_prev_fqe

      int best_prev_fqe
      variable
    • best_fqe_len

      int best_fqe_len
      variable
    • max_mem_blk

      int max_mem_blk
      variable
    • opt_getmain_amode31

      int opt_getmain_amode31
      variable
    • opt_getmain_cond

      int opt_getmain_cond
      variable
    • cur_vsam_op

      int cur_vsam_op
      variable
    • vsam_op_open

      int vsam_op_open
      variable
    • vsam_op_clsoe

      int vsam_op_clsoe
      variable
    • zsort_pfx

      String zsort_pfx
      variable
    • zsort_start

      String zsort_start
      variable
    • zsort_ended

      String zsort_ended
      variable
    • zsort_elapsed

      String zsort_elapsed
      variable
    • zsort_id

      int zsort_id
      variable
    • zsort_abort

      boolean zsort_abort
      variable
    • zsort_put

      boolean zsort_put
      variable
    • zsort_get

      boolean zsort_get
      variable
    • zsort_parm_addr

      int zsort_parm_addr
      variable
    • zsort_lrecl

      int zsort_lrecl
      variable
    • zsort_mem

      int zsort_mem
      variable
    • zsort_min_blk_rec

      int zsort_min_blk_rec
      variable
    • zsort_max_keys

      int zsort_max_keys
      variable
    • zsort_tot_keys

      int zsort_tot_keys
      variable
    • zsort_key_off

      int[] zsort_key_off
      variable
    • zsort_key_len

      int[] zsort_key_len
      variable
    • zsort_key_type

      byte[] zsort_key_type
      variable
    • zsort_key_order

      byte[] zsort_key_order
      variable
    • zsort_psw_cc

      int zsort_psw_cc
      variable
    • zsort_tot_sorts

      int zsort_tot_sorts
      variable
    • zsort_tot_passes

      int zsort_tot_passes
      variable
    • zsort_sortwk01_dsn

      String zsort_sortwk01_dsn
      variable
    • zsort_sortwk02_dsn

      String zsort_sortwk02_dsn
      variable
    • zsort_sortwk01_file

      RandomAccessFile zsort_sortwk01_file
      variable
    • zsort_sortwk02_file

      RandomAccessFile zsort_sortwk02_file
      variable
    • zsort_sortwk_len

      long zsort_sortwk_len
      variable
    • zsort_tot_read

      int zsort_tot_read
      variable
    • zsort_tot_write

      int zsort_tot_write
      variable
    • zsort_tot_svc_put

      int zsort_tot_svc_put
      variable
    • zsort_tot_svc_get

      int zsort_tot_svc_get
      variable
    • zsort_tot_comp

      int zsort_tot_comp
      variable
    • zsort_tot_move

      int zsort_tot_move
      variable
    • zsort_fm_len

      int zsort_fm_len
      variable
    • zsort_blk_len

      int zsort_blk_len
      variable
    • zsort_blk_addr

      int zsort_blk_addr
      variable
    • zsort_blk_end

      int zsort_blk_end
      variable
    • zsort_blk_ptr

      int zsort_blk_ptr
      variable
    • zsort_blk1_addr

      int zsort_blk1_addr
      variable
    • zsort_blk1_ptr

      int zsort_blk1_ptr
      variable
    • zsort_blk1_ptr_end

      int zsort_blk1_ptr_end
      variable
    • zsort_blk2_addr

      int zsort_blk2_addr
      variable
    • zsort_blk2_ptr

      int zsort_blk2_ptr
      variable
    • zsort_blk2_ptr_end

      int zsort_blk2_ptr_end
      variable
    • zsort_blk3_addr

      int zsort_blk3_addr
      variable
    • zsort_blk3_ptr

      int zsort_blk3_ptr
      variable
    • zsort_blk3_ptr_end

      int zsort_blk3_ptr_end
      variable
    • zsort_blk1_xrba

      long zsort_blk1_xrba
      variable
    • zsort_blk2_xrba

      long zsort_blk2_xrba
      variable
    • zsort_blk1_xrba_end

      long zsort_blk1_xrba_end
      variable
    • zsort_blk2_xrba_end

      long zsort_blk2_xrba_end
      variable
    • zsort_read_len

      int zsort_read_len
      variable
    • zsort_write_len

      int zsort_write_len
      variable
    • zsort_merge_wk01

      boolean zsort_merge_wk01
      variable
    • zsort_wk_name

      String zsort_wk_name
      variable
    • zsort_merge_mem_blk_len

      int zsort_merge_mem_blk_len
      variable
    • zsort_merge_wk_blk_len

      long zsort_merge_wk_blk_len
      variable
    • zsort_merge_pass

      int zsort_merge_pass
      variable
    • cc_descriptions

      String[] cc_descriptions
      variable
    • maskbit_descriptions

      String[] maskbit_descriptions
      variable
    • on_off

      String[] on_off
      variable
    • byte_mask_bit

      final byte[] byte_mask_bit
      variable
    • mask_name

      final String[] mask_name
      variable
    • flag_name

      final String[] flag_name
      variable
    • DFPRoundingMode_name

      final String[] DFPRoundingMode_name
      variable
    • BFPRoundingMode_name

      final String[] BFPRoundingMode_name
      variable
    • zACB_list

      LinkedList<zACB> zACB_list
      variable
  • Constructor Details

    • sz390

      public sz390()
      Dummy constructor - no initialization needed
  • Method Details

    • svc

      public void svc(int svc_id)
      execute supervisor call using mem and regs for data transfer
      Parameters:
      svc_id - - SVC number, can be different from MVS assignment
    • put_log

      public void put_log(String msg)
      Write message to z390_log_text and/or con if running standalone
      Parameters:
      msg - - text of message to be logged
    • put_log_line

      private void put_log_line(String msg)
      put line to listing file
      Parameters:
      msg - - text of message to be written
    • put_con

      private void put_con(String msg)
      put msg to console or cmd process output and yield to let parent process m
      Parameters:
      msg - - text of message to be written
    • log_error

      public void log_error(int error, String msg)
      issue error msg to log with prefix and increment error total Yet suppress if not gen_obj and not trace
      Parameters:
      error - - error code
      msg - - text of error message
    • abort_error

      public void abort_error(int error, String msg)
      issue error msg to log with prefix and increment error total
      Parameters:
      error - - error number
      msg - - error message
    • exit_ez390

      public void exit_ez390()
      display total errors close files and exit
    • close_z390_guam

      private void close_z390_guam()
      if exit request, send shutdown request to z390 GUI via the sysout queue
    • put_stats

      private void put_stats()
      display statistics as comments at end of bal
    • put_stat_line

      public void put_stat_line(String msg)
      routine statistics line to LOG or STATS(file)
      Parameters:
      msg - - message text
    • close_files

      private void close_files()
      close log, err, tre, xrd, xpr, xph, xgt, and xpt Assist files
    • close_cmd

      private void close_cmd()
      cancel all active cmd processes
    • init_time

      public void init_time()
      init pz390.cur_date and calendar with current time and date or force fixed time if NOTIMING option set.
      Notes:
      1. This NOTTIMING option is used in regression testing timing functions for repeatable results.
    • init_test

      public void init_test()
      1. init test regular expression parser
      2. init optional test=ddname file for batch input else init test_cmd_file which is also used for wtor replies when not in GUAM GUI mode
      expression pattern:
      1. self defining terms
        1. B'01'
        2. C'ABC'
        3. F'nnn'
        4. H'nnn'
        5. X'0F'
      2. register
        1. nr or nR
      3. memory address
        1. hex. for absolute memory address
        2. dec for decimal addr (for list len)
        3. +hex or -hex for rel base address
        4. *+hex or *-hex for rel instr. addr
        5. nnr% for 24 bit indirect reg addr
        6. nnR& for 31 bit indirect reg addr
      4. break compare operators
        1. =, <, >, !=, >=, <=
      5. test commands (b,g,h,l,m,q,t)
      6. test break opcode names
      7. set operator =
    • open_files

      public void open_files()
      1. Set trace file for TRACE and TRACEALL
      2. Open 390 and lst files
    • svc_exit

      private void svc_exit()
      1. If stimer_exit_running then restore r13-r15 and exit to saved psw
      2. If stae exit running, restore psw and regs from zcvt_stae.
      3. If spie exit running, restore psw and regs from zcvt_epie
      4. exit to prev link return address or exit ez390 if none.
    • svc_extract

      private void svc_extract()
      extract svc supports the following functions requires function code in R0. Supported function code values:
      1. GETENV get environment variable
        • input r1=name with null terminator
        • output r2=getmain'd area value and null terminator
    • svc_load

      public void svc_load()
      load 390 load module into virtual memory Input regs:
      1. r0 = 8 byte pgm name padded with spaces
      2. r15 = 0 use SYS390 default path search
      3. r15 = addr dsname if high bit off
      4. r15 = addr ddname if high bit on
      Output regs:
      1. r0 = address of 390 program entry based on lz390 rmode option and with high bit indicating amode
      2. r1 = length of 390 file loaded in doubleword count for OS compatiblity. Length in bytes if not 390 file
      3. r15 = return code 0 ok or 4 if not found
      4. Add CDE to chain from CVTCDE else increment CVTUSE for access by user programs
      Notes:
      1. Amode is taken from load module's amode option as set by lz390
      2. If not 390 file, r0 = load address
      3. Add CDE entry for new entry else if already loaded, increment cde_use and return existing load address.
    • svc_load_set_regs

      private void svc_load_set_regs()
      set r0, r1, and r15 for load
    • svc_load_390

      private void svc_load_390()
      load 390 file, relocate, and set r1 lenght in double words
    • svc_load_rlds

      private void svc_load_rlds()
      read and apply rld records at end of 390 file.
    • svc_load_file

      private void svc_load_file()
      1. Load non 390 file
      2. Set cde_pgm to file_name
      3. Set cde_loc to load address
      4. Set cde_len to length in bytes
      5. Set cde_ent to -1
      6. Set R0 to load address
      7. Set r1 to length in bytes
    • svc_xctl

      private void svc_xctl()
      delete current module and then load and then balr to 390 load module Input:
      1. r0 = addr pgm name
      2. r1 = user parms
      3. r15 = 0 use SYS390 default path search
      4. r15 = addr dsname if high bit off
      5. r15 = addr ddname if high bit on
      Output:
      1. r15 = user pgm return code if call ok
      2. abend s106
    • get_load_dsn

      public boolean get_load_dsn(int dd_dsn_addr)
      Set DSN from addr DDNAM with high bit or from addr DSNAM.
      1. If vcdt_load then strip .xxx and set vcdt_entry = xxx else set to ACBNAME
      2. Set following from ddname/dsname:
        1. load_pgm_dir (overrides dir_390 default)
        2. load_pgm_name
        3. load_pgm_type
      3. Return true if ok else false
      Notes:
      • If dir_addr high bit on, get user list from 8 byte ddname env. var. at dir_addr
      • else get user list from dir_addr with null delimited or double quote delimiter
      Parameters:
      dd_dsn_addr - = pointer to DD or DSN
      Returns:
      boolean
    • get_eploc_pgm_name

      private boolean get_eploc_pgm_name()
      set load_pgm_name from r0 else error
      Returns:
      true if successful, false otherwise
    • svc_delete

      private void svc_delete()
      delete loaded pgm/dsn from irtual memory if use count 0 after decrement.
      Input regs:
      1. r0 = 8 byte pgm name padded with spaces
      2. r15 = 0 use SYS390 default path search
      3. r15 = addr dsname if high bit off
      4. r15 = addr ddname if high bit on
      Output regs:
      1. r15 = 0 if successfully deleted
      2. r15 = 4 if not found in memory
    • delete_cur_cde

      private boolean delete_cur_cde()
       if cur_cde not -1 and cde_loc not 0                  #714
          decrement use count for cur_cde
          if use count 0
             freemain memory
             set cde_loc to 0 to release cde entry
             if remove CDE from CVTCDE queue is successful  #714
                freemain CDE storage                        #714
                set cde_addr to 0 to indicate no cde        #714
             endif                                          #714
             return true
       else if cur_cde not -1 and cde_addr = 0              #714
          return false                                      #714
       else
          abort: delete cde system error                    #714
          return false
       endif                                             
       
      Returns:
      true if successful, false otherwise
    • remove_cde

      private boolean remove_cde(int cde)
      Remove CDE from CVTCDE chain
      Parameters:
      cde - address of CDE to remove
      Returns:
      true if CDE removed, else false
    • add_cde

      private void add_cde()
      add new 390 load module to cde entry table and set usage to 1
    • svc_link

      public void svc_link()
      load and then balr to 390 load module Input:
      1. r0 = addr pgm name
      2. r1 = user parms
      3. r15 = 0 use SYS390 default path search
      4. r15 = addr dsname if high bit off
      5. r15 = addr ddname if high bit on
      Output:
      1. r15 = user pgm return code if call ok
      2. abend s106
      3. On first load with option GUAM on, the gz390 GUAM GUI window will be started with default title using program name
    • svc_getmain

      public void svc_getmain()
      Input:
      1. R1 = length to allocate
      2. R0 = options: bit 0 allocate memory above the line
      3. If tz390.opt_loadhigh alloc from top down else bottom up
      Output:
      1. Set r0 to length of allocated area rounded to doublewords
      2. set r1 to address of area
      3. set r15 to 0 of ok, else nz
      4. set max_mem_blk to largest contig blk for use by sort etc.
      Notes:
      1. Use TRACEMEM option to trace FQE's
      2. If no 31 bit memory then allocate from 24 bit memory else abort if requested memory type no available.
      3. Select best fit from available blocks:
        1. Same size block to reduce fragmentation
        2. Smallest block > requested len to save largest
    • alloc_from_fqe

      private void alloc_from_fqe()
      alloc memory for GETMAIN from current FQE
    • svc_freemain

      public void svc_freemain()
      Input:
      1. r0 = length to return
      2. r1 = address to return
      Output:
      1. set r15 to 0 of ok, else abort
    • check_fqe_ok

      private boolean check_fqe_ok()
      trace fqe if option tracemem on and verify address and length ok
      Returns:
      true if okay, false otherwise
    • trace_mem

      private void trace_mem(String mem_type, int mem_addr, int mem_len, int mem_nxt)
      trace memory allocation
      Parameters:
      mem_type - memory type
      mem_addr - starting address
      mem_len - length in bytes
      mem_nxt - pointer to next chunk
    • svc_time

      private void svc_time()
      return time and date in requested format See TIME.MAC for additional information.
      • R0 LH = date type
      • R0 LL = time type
      • R1 = storage address for MIC,STCK,STCKE
      Notes:
      • When option NOTIMING is specified, the time and date are fixed at:
        • TOD = 22:33:44:567 milliseconds
        • DATE = 2005.002 (Jan 2, 2005)
        This is used for regression testing date and time functions by comparing expected time and date output.
      • See mac\TIME.MAC for documentation
    • svc_ttimer

      private void svc_ttimer()
      process TTIMER cancel, tu, or mic request:
      • R0 BIT 0 = return MIC at R1 addr else TU om R0
      • R0 BIT 1 = CANCEL else just return time
    • svc_stimer

      private void svc_stimer()
      process timer interval request
    • start_stimer_exit

      public void start_stimer_exit()
      Start stimer exit when stimer_exit_request found true by instruction loop or wait loop
    • get_ccyydddf

      private int get_ccyydddf()
      return ccyydddf for r1 linkage=svc calls
      Returns:
      an integer value is returned whose bit pattern represents the date ccyyddd as a packed decimal with X'F' sign nibble
    • svc_bldl

      private void svc_bldl()
      search for members specified in BLDL list passed in R1 using SYS390 direcotory list and set return code:
      • 0 - all members found
      • 4 - one or more not found entry field R (offset if all found else 4 if not)
      • 8 - invalid entry count or entry length
      The R field in entries found is set to 1 and set to 0 if not found. If entry length exceeds 13 then set Z to 1 if found in memory else 0.
    • svc_abend

      public void svc_abend(int pic, boolean type, boolean req_dump)
      1. Display trace table, abend code, psw, instr,and gpr's
      2. If dump_reguested:
        • display gpr's
        • display fpr'ss
        • display tiot dcbs
        • dump all storage
      3. Abort if not in test mode
      Parameters:
      pic - program interrupt code
      type - true if System abend, false for user abends
      req_dump - true if memory dump requested
    • list_trace_table

      private void list_trace_table()
      list last 10 instructions in trable table
    • dump_psw

      private String dump_psw()
      in amode24/amode31: return 16 character hex PSW with the following bit settings:
      1. bits 0-7 x'07' translation, I/O interrupts, and external interrupts enabled.
      2. Bits 8-14 x'84' key eight, machine checks enabled
      3. Bit 15: Problem state (should be on: no SVC mode in z390)
      4. Bits 16-23 AS(2),CC(2),MASK(4)
        • AS - translation mode zeros
        • CC - condition code 0=CC8, 1=CC4, 2=CC2, 3=CC1
        • MASK - fixed, decimal, HFP exp, HFP sig.
      5. Bits 24-31 zeros (64 bit addressing if 31 and 32 are one)
      6. Bit 31 basic addressing mode 0=24, 1=31
      7. Bits 32-63 - address of next instruction
      in amode64: return 32 character hex PSW in format as definde by z-POP:
      1. bits 0-7 x'07' PER disabled, DAT enabled, I/O and external interrupts enabled
      2. Bits 8-14 x'84' key eight, machine checks enabled; No Wait state
      3. Bit 15: Problem state (should be on: no SVC mode in z390)
      4. Bits 16-23 AS(2),CC(2),MASK(4)
        • AS - Address Space control: zero
        • CC - condition code 0=CC8, 1=CC4, 2=CC2, 3=CC1
        • MASK - fixed, decimal, HFP exp, HFP significance
      5. Bits 24-31 x'01' Amode64 enabled
      6. Bits 32-63 x'80000000' Amode 64 requires amode31 on
      7. Bits 64-95 x'00000000' High word of PSW address always 0
      8. Bits 96-127: next sequential instruction address
      Returns:
      formatted PSW for current amode
    • dump_psw16

      private String dump_psw16()
      return 32 character PSW in format as defined by z-PoP:
      1. bits 0-7 x'07' PER disabled, DAT enabled, I/O and external interrupts enabled
      2. Bits 8-14 x'84' key eight, machine check enabled, no wait state
      3. Bit 15: Problem state (should be on: no SVC mode in z390)
      4. Bits 16-23 AS(2),CC(2),MASK(4)
        • AS - Address Space control: zero
        • CC - condition code 0=CC8, 1=CC4, 2=CC2, 3=CC1
        • MASK - fixed, decimal, HFP exp, HFP significance
      5. Bits 24-31 x'01' Amode64 enabled
      6. Bits 32-63 x'80000000' Amode 64 requires amode31 on
      7. Bits 64-95 x'00000000' High word of PSW address always 0
      8. Bits 96-127: next sequential instruction address
      Returns:
      formatted 32-bit psw
    • dump_req

      private void dump_req(boolean req_dump)
      dump regs and optionals dump everything
      Parameters:
      req_dump - true to request a dump, false to suppress dumping
    • dump_gpr

      public void dump_gpr(int reg_offset)
      dump specified register or all if -1
      Parameters:
      reg_offset - Offset in bytes in register array of register to be dumped
    • dump_ar

      public void dump_ar(int ar_reg_num)
      dump specified access register or all if -1
      Parameters:
      ar_reg_num - access register number
    • get_fpc

      public int get_fpc()
      Get the FPC (floating-point-control register) value
      Returns:
      the FPC value
    • dump_fpc

      public void dump_fpc(String cmd)
      Dump the FPC (floating-point-control register)
      Parameters:
      cmd - the command; "FPC" or "FPC+"
    • dump_fpc

      public void dump_fpc(boolean fpcplus)
      Dump the FPC (floating-point-control register) Summary dump (just the value); if fpcplus is true, a verbose dump is also done.
      Parameters:
      fpcplus - true means verbose FPC; false means summary FPC
    • dump_fpcplus

      public void dump_fpcplus(int fpc)
      Verbose dump of the FPC (floating-point-control register)
      Parameters:
      fpc - the FPC
    • dump_fpr

      public void dump_fpr(int reg_offset)
      dump specified fp register or all if -1
      Parameters:
      reg_offset - offset in bytes within register array; negative to dump all
    • dump_mem

      public void dump_mem(ByteBuffer memory, int mem_addr, int mem_len)
      dump specified area of memory
      Parameters:
      memory - array that implements memory to be dumped
      mem_addr - offset where dump should start
      mem_len - length in bytes of area to dump
    • bytes_to_hex

      private String bytes_to_hex(byte[] bytes, int byte_start, int byte_length, int chunk)
      Format bytes into hex string. If chunk > 0 insert space after each chunk except the last chunk.
      Parameters:
      bytes - byte array from which to take the input data
      byte_start - starting offset within the byte array
      byte_length - nr of bytes to format
      chunk - chunk size in bytes
      Returns:
      formatted dunp - hex string of contents of the byte array
    • put_dump

      private void put_dump(String text)
      route dump lines to LOG file unless TRACE or TRACET is on in which case route to TRE file.
      Parameters:
      text - specifies the text to be logged/traced
    • dump_mem_stat

      private void dump_mem_stat()
      display total allocated and free memory totals on log
    • svc_open

      private void svc_open()
      check for DCB or ACB and route accordingly
    • svc_open_dcb

      public void svc_open_dcb(String dsnam_path)
      open DCB file for sequential or random I/O and use dsnam_path prefix for dcbdsnam option
      Notes:
      1. R1 = DCB
      2. R0 = OPEN OPTION
        • x'40' - input only - dcb_oflgs_r
        • x'20' - output only - dcb_oflgs_w
        • x'60' - update - dcb_oflgs_rw
      3. DDNAME points to:
        • environment variable with file path and name
        • if DCBDSNAM has pointer to DSN null or " delimited file spec in EBCDIC/ASCII depending on mode
      4. See DCBD macro for DCB fields and see DCB macro for generation of DCB
      5. TIOT table with unique entry for each DDNAME holds open files.
      6. Take synad exit if defined else issue error message and abort.
      Output registers:
      • R0 - 64 bit file length
      Parameters:
      dsnam_path - dsname or path string
    • get_dcb_locate_buffer

      private void get_dcb_locate_buffer()
      set dcb_rec to address of get/put locate buffer else abort
    • get_dcb_file_name

      private String get_dcb_file_name(String dsnam_path)
      Get file name from DCBDSNAM if not zero and append dsnam_path else get file from DCBDDNAM environment variable.
      Notes:
      1. DCBDSNAM is EBCDIC uless in ASCII mode.
      2. File spec up to 265 long spacey name with drive and path.
      Parameters:
      dsnam_path - dsname or path string
      Returns:
      file name; empty string on failure
    • get_tiot_file_name

      private String get_tiot_file_name(int tiot_index)
      return file name for tiot using ddname for tiot
      Parameters:
      tiot_index - tiot table index
      Returns:
      file path and name with correct separators for current environment
    • svc_close

      private void svc_close()
      check for DCB or ACB and route accordingly
    • svc_close_dcb

      public void svc_close_dcb()
      close file if open else synad error
    • svc_get

      private void svc_get()
      get next record into area from dcb gm/gl
      Notes:
      1. Translate to EBCDIC unless ASCII mode
      2. If GL, move to dcb_area and return addr in R1
    • svc_put

      private void svc_put()
      put next record from area to dcb pm/pl file
    • svc_read

      private void svc_read()
      read next record forward or backward into area from dcb macrf r/rw file
    • svc_write

      private void svc_write()
      write next record forward or backward into area from dcb macrf r/rw file
    • svc_check

      private void svc_check()
      check decb ecb and process as follows:
      • ecb = x'40' exit normally
      • ecb = x'41' take synad error exit
      • ecb = x'42' take eodad exit
    • svc_point

      private void svc_point()
      set dcb file pointer
      • r1 = address of dcb
      • r0 = 64 bit rba
    • dcb_synad_error

      private void dcb_synad_error(int error_num, String error_msg)
      take synad exit if defined else issue error message and issue pgm check
      Parameters:
      error_num - error number
      error_msg - error message
    • dcb_eodad_exit

      private void dcb_eodad_exit()
      take eodad exit if defined else issue error message and abort
    • check_dcb_addr

      private void check_dcb_addr()
      validate that cur_dcb_addr is on full word bound and that DCBID = EBCDIC or ASCII C'DCB1' else abort.
      Notes:
      1. Also reset dcb_synad_recur
      2. Incr DCB I/O request counter
    • get_cur_tiot_index

      private void get_cur_tiot_index()
      1. Using cur_dcb addr from R1 or DECB get cur_tiot index from DCBIOBAD (x'1C').
      2. reduce index in DCBIOBAD by 1.
      3. If index not -1, verify tiot_dcb_addr and that dcb is open.
      4. If index = -1 or dcb's don't match add new entry for DCBDDNAM.
    • get_new_tiot_index

      private int get_new_tiot_index(String ddname, int dcb_addr)
      return new tiot index or abort (used by DCB I/O and ASSIST)
      Parameters:
      ddname - DDname to store
      dcb_addr - DCB address to store
      Returns:
      tiot index value if successful, -1 otherwise
    • get_ascii_env_var_string

      public String get_ascii_env_var_string(String env_var_name)
      return environment variable string with leading and trailing spaces removed or return "" if not found.
      Parameters:
      env_var_name - name of environment variable
      Returns:
      value of environment variable
    • get_ascii_string

      public String get_ascii_string(int mem_addr, int mem_len, boolean null_term)
      get ascii string with no trailing spaces from memory address and length
      Notes:
      1. Translates from EBCDIC to ASCII unless in ASCII mode.
      2. Terminate string at first 0 byte if requested or at end of field.
      Parameters:
      mem_addr - start location of string in memory
      mem_len - length in bytes of string to extract
      null_term - true indicates string ends at null character, when false embedded nulls are allowed
      Returns:
      ascii string value
    • put_ascii_string

      public void put_ascii_string(String text, int mem_addr, int mem_len, char pad_char)
      put ascii string with trailing spaces to memory address and length
      Notes:
      1. Translates from ASCII to EBCDIC unless ASCII mode
      Parameters:
      text - text to store
      mem_addr - start location in memory for stored string
      mem_len - length of string in memory
      pad_char - padding character to be used if text parm is short
    • svc_cmd

      private void svc_cmd()
      exec OS command process
      • r0+1 = CMDLOG x'00', NOCMDLOG x'01'
      • r0+2 = cmd process id 0-9
      • r0+3 = cmd operation type
      • r1 = A(command)
      • r2 = command length
      • r3 = timeout wait limit in milli-sec
    • cmd_startup

      private int cmd_startup(int cmd_id)
      start Windows command processer with synchronized buffered output.
      Notes:
      1. Start process cmd_id
      2. Send input commands via cmd_input(id,msg)
      3. Retrieve output from cmd_output_queue
      4. Cancel via cmd_cancel(cur_id);
      Parameters:
      cmd_id - identifier
      Returns:
      return code
    • cmd_proc_start

      public int cmd_proc_start(int cmd_id, String[] exec_cmd)
      1. Terminate any prior cmd process with error if non zero completion.
      2. Start new process running on separate thread.
      Note: cmd monitor will issue exec_term if timeout limit is reached before next start command does it. Error will be issued by exec_term if non zero return code or if process had to be cancelled.
      Parameters:
      cmd_id - identifier
      exec_cmd - array of strings - each string being a command to be executed
      Returns:
      0 if okay; -1 if error occurs
    • cmd_input

      private void cmd_input(int cmd_id, String cmd_line)
      send input to exec command in process
      Parameters:
      cmd_id - identifier
      cmd_line - command to execute
    • cmd_proc_rc

      public int cmd_proc_rc(int cmd_id)
      return ending rc else -1 return 0 if no process defined
      Parameters:
      cmd_id - identifier
      Returns:
      0 if okay, -1 otherwise
    • cmd_cancel

      public void cmd_cancel(int cmd_id)
      cancel exec process
      Parameters:
      cmd_id - identifier
    • run

      public void run()
      wait for comproc threads to end normally or issue error if abnormal termination
      Specified by:
      run in interface Runnable
    • copy_cmd_output_to_queue

      public void copy_cmd_output_to_queue(int cmd_id)
      copy cmd output lines to output queue
      Parameters:
      cmd_id - identifier
    • copy_cmd_error_to_queue

      public void copy_cmd_error_to_queue(int cmd_id)
      copy cmd error lines to output queue
      Parameters:
      cmd_id - identifier
    • cmd_put_queue

      private void cmd_put_queue(int cmd_id, String msg)
      add output to linklist queue synchronized so output and main thread retrieval via CMDPROC READ are safe.
      Parameters:
      cmd_id - identifier
      msg - message to add
    • cmd_get_queue

      public String cmd_get_queue(int cmd_id)
      retrieve next FIFO line from linklist queue synchronized so output and main thread retrieval via CMDPROC READ are safe. If no string ready, return null
      Parameters:
      cmd_id - identifier
      Returns:
      command from queue or null string
    • svc_tget_tput

      private void svc_tget_tput()
      Read or write to TN3270 terminal
      Notes:
      1. If GUAM GUI Access Method enabled, read or write to the GUAM GUI dialog.
      2. If no GUAM interface and EDIT mode use WTO/WTOR to MCS console, else error.
    • svc_guam

      private void svc_guam()
      GUAM Graphical User Access Method for user I/O vua GUAM GUI dialog window with 3 views:
      1. MCS - view for WTO and WTOR I/O
      2. SCREEN - view for TPUT and TGET I/O
      3. GRAPH - view for graphics
      Input registers:
      • r1 = major/minor opcode bytes
    • svc_snap

      private void svc_snap()
      snap dump control blocks and/or memory. Input registers:
      • r0 - flags
        • x'8000' - dump storage range (r14,r15)
        • x'4000' - dump gpr r0-r15
        • x'2000' - dump fpr f0-f15
        • x'1000' - dump cde program info
        • x'0800' - dump dcb file info
        • x'0400' - dump all memory
    • dump_cde_pgms

      private void dump_cde_pgms()
      dump cde entries for all loaded pgms and files
    • dump_cde

      private void dump_cde()
      dump current program cde entries
    • dump_tiot

      public void dump_tiot()
      dump content of tiot entries
    • wto_msg

      private void wto_msg(String wto_pfx, int msg_addr, int msg_len)
      1. Log msg on z390 system log
      2. If QUAM GUI option on, display msg on gz390 mcs window view
      Parameters:
      wto_pfx - Prefix for WTO message
      msg_addr - Address of message text in memory
      msg_len - Length of message text
    • svc_wait

      private void svc_wait()
      wait for ecb posting or stimer exit request. Retry the wait after stimer exit assuming r1 restored to wait ecb parm.
      Notes:
      1. WTOR ecb's are posted by gz390 wtor thread at which time reply is fetched and stored.
      2. Don't wait on a user defined ecb unless another process or an stimer exit will post it.
    • check_wait_ecbs

      private boolean check_wait_ecbs()
      check wait ecbs and return true if required # of ecbs have been posted
      Returns:
      true when all ECBs posted; false if any ECB still waiting
    • reset_wait_list

      private void reset_wait_list()
      reset wait bit in ecblist
    • svc_post

      private void svc_post()
      post ecb complete
    • svc_wtor

      private void svc_wtor()
      request WTOR reply as follows:
      1. Save r0=reply, r14 length,r15=ecb
      2. Issue wtor message
      3. if QUAM GUI option, check for gz390 cmd reply else check for z390 cmd input reply
      4. if reply found, post ecb else repeat check at every monitor_update interval until reply found.
    • svc_espie

      private void svc_espie()
      set/reset program interruption exit
      1. if r0=0 cancel last espie added else add new espie exit
      2. if r0 negative replace exit else add
      3. if r1 not zero, save parm address
    • svc_estae

      private void svc_estae()
      set/reset task abend exit
      1. if r0=0 cancel last estae added else add new estae exit
      2. if r0 negative replace exit else add
      3. if r1 not zero, save parm address
    • svc_xlate

      private void svc_xlate()
      translate between ascii/ebcdic. Input registers:
      • r0 = area address
        • high bit on for EBCDIC to ASCII
        • high bit off for ASCII to EBCDIC
      • r1 = length
    • svc_ctd

      private void svc_ctd()
      convert to display. Input registers:
      • r1=a(type,in,out)
      conversion type code:
      1. 128 bit integer to 45 byte decimal display
      2. EH short to 45 byte scientific notation
      3. EB short to 45 byte scientific notation
      4. DH long to 45 byte scientific notation
      5. DB long to 45 byte scientific notation
      6. LH extended to 45 byte scientific notation
      7. LB extended to 45 byte scientific notation
      8. DD long to 45 byte scientific notation
      9. ED short to 45 byte scientific notation
      10. LD extended to 45 byte scientific notation
    • ctd_trunc

      private void ctd_trunc(byte max_digits)
      trunc to max digits plus exponent and strip trailing zeros on fraction
      Parameters:
      max_digits - max digit count
    • svc_cfd

      private void svc_cfd()
      convert from display input registers:
      • r1=a(type,out,in)
      conversion type code:
      1. 128 bit integer from 45 byte decimal display
      2. EH short from 45 byte scientific notation
      3. EB short from 45 byte scientific notation
      4. DH long from 45 byte scientific notation
      5. DB long from 45 byte scientific notation
      6. LH extended from 45 byte scientific notation
      7. LB extended from 45 byte scientific notation
      8. DD long from 45 byte scientific notation
      9. ED short from 45 byte scientific notation
      10. LD extended from 45 byte scientific notation
    • process_test_cmd

      public void process_test_cmd()
      process test option interactive debug commands
      1. Check for reg, memory, or opcode break and set count = 0 if hit.
      2. Decrement go count if positive.
      3. if go count = 0
        • read, parse, and execute test commands
        • until go or quit command executed.
      Notes:
      1. Get next command from z390 GUI cmd line, system command_line, or from ddname file specified in test option test(ddname)
    • get_test_cmd

      private void get_test_cmd()
      get next test command from Z390 GUI command line or system command line or file specified with the test(ddname) option
    • check_test_break_addr

      private void check_test_break_addr()
      check for psw = break addr
    • check_test_break_reg

      private void check_test_break_reg()
      check for test mode break on register value
    • check_test_break_mem

      private void check_test_break_mem()
      check for test break on memory value change
    • check_test_break_op

      private void check_test_break_op()
      check for test mode break on opcode at current psw address
    • exec_test_cmd

      private void exec_test_cmd()
      parse and execute current test command
    • get_test_int

      private int get_test_int(String token)
      return integer value of token and just issue ivalid int error if error and return -1.
      Parameters:
      token - token to be processed
      Returns:
      integer value of token; -1 if not a valid integer
    • get_next_test_token

      private String get_next_test_token()
      Get next token for test command
      Returns:
      next test command token or null
    • get_next_test_addr

      private int get_next_test_addr()
      return memory address of [addr][+-addr] start with current test_token and continue until next test_token not +, -, ?, % or valid address If invalid return -1
      Notes:
      1. EPA returns last program load address
      Returns:
      result address; -1 if invalid
    • test_error

      private void test_error(String text)
      issue test error message and return to prompt
      Parameters:
      text - Text to be traced
    • go_test

      private void go_test()
      set count and go execute instructions until count 0 or break found or exit
    • set_test_break_addr

      private void set_test_break_addr(int addr)
      set break on specified instruction address
      Parameters:
      addr - Instruction address for breakpoint
    • set_test_break_reg

      private void set_test_break_reg()
      set test break on register change
    • set_test_break_mem

      private void set_test_break_mem()
      set test break on memory change
    • set_test_break_op

      private void set_test_break_op()
      set break on opcode at current psw
    • get_test_addr

      private int get_test_addr(String text)
      get test address and set type memory type address forms:
      • dec = absolute decimal address
      • hex. = absolute hex address
      • +hex = base + hex offset
      • -hex = base - hex offset
      • * = pz390.psw_loc
      • nr% indirect 24 bit
      • nr? indirect 31 bit
      • ? indirect address
      • EPA last load address // RPI 395
      register type address forms:
      • nnr or rnn
      Parameters:
      text - command text
      Returns:
      address; -1 if invalid
    • get_test_compare

      private byte get_test_compare(String compare)
      set test compare code or issue error
      • 0 - =
      • 1 - !=
      • 2 - ><
      • 3 - >=
      • 4 - <
      • 5 - <=
      Parameters:
      compare - Compare command text
      Returns:
      comparator index 0-5; -1 if invalid
    • get_test_reg_sdt

      private long get_test_reg_sdt(String text)
      return long sdt value for register
      • b'...'
      • c'...'
      • c"..."
      • f'...'
      • h'...'
      • x'...'
      • or address hex., dec, nr%, nr?, +hex, -hex, *+hex, *-hex
      Parameters:
      text - command text
      Returns:
      evaluation result; -1 if invalid
    • get_long_from_hex_string

      private long get_long_from_hex_string(String data)
      Convert string of hexadecimal digits to long Returns:
      • The converted number if successful;
      • -1 if an error occurs; also sets global test_cmd_abort to true
      Note: Code is a workaround to a bug in Long.valueOf(string,16) when string is 16 digits that begins with x'8' - x'F' (Supposedly fixed in java 8)
      Parameters:
      data - input string value
      Returns:
      evaluation result
    • get_test_mem_sdt

      private byte[] get_test_mem_sdt(String text)
      return memory sdt byte array
      • b'...'
      • c'...'
      • c"..."
      • f'...'
      • h'...'
      • x'...'
      Parameters:
      text - input string to evaluate
      Returns:
      byte array
    • init_sz390

      public void init_sz390(tz390 shared_tz390, pz390 shared_pz390, vz390 shared_vz390)
      init tz390
      Parameters:
      shared_tz390 - tz390 instance to be created
      shared_pz390 - pz390 instance to be created
      shared_vz390 - vz390 instance to be created
    • get_feature_bits

      public long get_feature_bits()
      return current os feature bits for use by STFLE instruction
       byte  bit
         0   0 - Y zos and 390 instructions avail.
             1 - Y zos mode installed
             2 - Y zos mode active
             7 - Y STFLE facility installed
         2  16 - N extended translation 2 
            18 - N long displacement         
            19 - N long displacement performance
            20 - Y HFP multiply and add/subtract
            21 - Y extended immediate
            22 - N extended translation 3
            23 - Y HFP unnormailized
         3  24 - Y extended timer 2
            25 - Y store clock fast
            28 - N extended TOD steering
            30 - N extended timer 3
       
      Returns:
      fixed bit string as a long value
    • svc_tcpio

      private void svc_tcpio()
      tcp/ip sockets I/O
       Inputs:
         r0 = operation
            1 - open server port
                  r1=port
            2 - open client port connection
                  r1=port
                  r14=host ip addr or 0 (HOST=*)
            3 - close port connection
                  r1=port
            4 - send message
                  r1=port
                  r2=connection id
                  r14=msg addr
                  r15=msg length
            5 - receive message 
                  r1=port
                  r2=connection id or -1
                  r14=buffer address
                  r15=max msg length
       Output:
         r1 = message length for receive
         r2 = connection id for receive
         r15= return code
               0 - ok
               4 - no msg and nowait
               12- error on last operation
       
    • tcpio_find_server_port

      private boolean tcpio_find_server_port()
       set cur_tcp_server_index to allocated
       server port and return true else
       set cur_tcp_server_index to first free port
       and return true else
       set cur_tcp_server_index to -1
       and return false indicating no ports avail.
       
      Returns:
      true if successful; false otherwise
    • tcpio_find_client_port

      private boolean tcpio_find_client_port()
      set cur_tcp_client_index to allocated client port and return true else set cur_tcp_client_index to first free client port and return false else set cur_tcp_client index to -1 and return false
      Returns:
      true if successful; false otherwise
    • tcpio_close_ports

      private void tcpio_close_ports()
      close all client and server ports
    • tcpio_close_client_port

      private void tcpio_close_client_port()
      close all open TCP/IP ports
    • tcpio_close_server_port

      private void tcpio_close_server_port()
      close open TCP/IP server port
    • tcpio_close_conn

      private void tcpio_close_conn(int conn_index)
      close connection
      Parameters:
      conn_index - index for connection to close
    • tcpio_receive_client_port

      private void tcpio_receive_client_port()
      receive message from client port if nowait and message not ready RC=4 else wait for message
    • tcpio_receive_server_port

      private void tcpio_receive_server_port()
       receive message from server port connection.
       If no connection id is specified (-1),
       then next message from any conncetion.
       if nowait and message not ready RC=4
       else wait for next message..
       
      Notes:
      1. Connection # returned in R2
    • tcpio_conn_store_msg

      private void tcpio_conn_store_msg(int conn_index)
      1. store msg from conn input buffer up to specified lmsg length and return actual length stored in R1.
      2. Turn off tcp_conn_msg_ready if 0 available.
      Notes:
      1. First byte may be in conn_byte if conn_read = true
      Parameters:
      conn_index - index for connection to use
    • tcpio_set_conn_msg_ready

      private boolean tcpio_set_conn_msg_ready(int conn_index, boolean state)
       if state true
          set conn msg ready
          (byte has been read by conn thread)
       else if no msg data available 
          reset conn msg ready
          (will force read on conn thread)
       else
          leave conn ready set to true
          (allows main user thread to read
          mult msgs without switching back
          to conn thread for a read)
       
      Parameters:
      conn_index - index of connection to use
      state - connection status
      Returns:
      true if data was found; false otherwise
    • tcp_alloc_conn

      private boolean tcp_alloc_conn(int port_index)
      allocate next conn for server port use
      Parameters:
      port_index - port index number
      Returns:
      true if successful; false otherwise
    • tcp_free_conn

      private void tcp_free_conn(int conn_index)
      release tcp connecntion for reuse
      Parameters:
      conn_index - index of connection to free
    • check_dfp_finite

      private boolean check_dfp_finite(byte[] dfp_bytes, int dfp_byte_index)
      return true if DFP value finite based on CF5 field value common to all DFP types
      Parameters:
      dfp_bytes - byte array holding DFP value
      dfp_byte_index - offset in array where DFP value is to be checked
      Returns:
      true if finite; false otherwise
    • get_bdw_len

      private int get_bdw_len(int len)
      if BDW high bit on return len = bits 1-31 else return len = bits 1-15
      Parameters:
      len - BDW
      Returns:
      block lenth in bytes
    • put_bdw_len

      private int put_bdw_len(int len)
      if DCBEFLG1 LBI bit x'04' on return len with high bit on else return len in bits 1-15
      Parameters:
      len - length
      Returns:
      length formatted as a BDW
    • check_mem_area

      private void check_mem_area(int addr, int len)
      check area start end and abort S0C5 if invalid.
      Parameters:
      addr - start address of range
      len - length of range in bytes
    • ast_open_file

      public int ast_open_file(String ddname, boolean input_type, int dcb_addr)
      open ASSIST file by ddname and return TIOT index if open successful else return -1
      Parameters:
      ddname - DDname
      input_type - input type code: true for read-only, false for read/write
      dcb_addr - pointer to DCB
      Returns:
      index of tiot entry in tiot array
    • ast_close_file

      public void ast_close_file(int tiot_index)
      close assist file
      Parameters:
      tiot_index - index in tiot array
    • svc_zsort

      private void svc_zsort()
      z390 internal sort
       r0  = operation type:
             1 - intenal sort
             2 - file sort
             3 - put record to internal sort
             4 - get record from internal sort
       r1  = address parm list for op 1 and 2 a(rec) for get/put
                0 4 - LRECL
                4 4 - max memory or 0 for max avail from MEM option
                8 4 - key field N offset from 0
               12 4 - key field N length
               16 2 - key type code and VL bit for last key
               18 2 - ascending = 0, descending 1 (also VL bit for last key)
       r15 = return code
             0  ok
             4  eof for get
             16 abort due to error
       
    • zsort_move_rec

      private void zsort_move_rec(int from_ptr, int to_ptr)
      move record of length zsort_lrecl in memory
      Parameters:
      from_ptr - Pointer to source location
      to_ptr - Pointer to destination location
    • zsort_open_sortwk

      private void zsort_open_sortwk()
      open sort work files and reset rbas to 0
    • zsort_write_blk

      private void zsort_write_blk(RandomAccessFile file, int rec_ptr, int end_ptr)
      write blk from zsort_blk_addr to zsort_blk_ptr at current addr on file
      Parameters:
      file - instance of RandomAccessFile
      rec_ptr - start address of block to be written
      end_ptr - end address+1 of block to be written
    • zsort_write_merge_blk

      private void zsort_write_merge_blk(int rec_ptr, int end_ptr)
      write merged blk to output merge file
      Parameters:
      rec_ptr - pointer to record
      end_ptr - points after record
    • zsort_read_merge_blk

      private void zsort_read_merge_blk(long file_xrba, long file_xrba_end, int blk_ptr, int blk_end_ptr)
      read blk into blk_ptr to blk_end_ptr at current merge file_xrba. Return bytes read up to blk size or end of file, or 0 if at end
      Parameters:
      file_xrba - offset in work file
      file_xrba_end - end of block in work file
      blk_ptr - start of block in storage
      blk_end_ptr - end of block in storage
    • zsort_init_parms

      private void zsort_init_parms()
      init isort or fsort parms
    • zsort_init_isort

      private void zsort_init_isort()
      initialize for internal sort
    • zsort_put

      private void zsort_put()
      pass unsorted record to zsort
    • zsort_get

      private void zsort_get()
      get sorted record from zsort
    • zsort_alloc_blk

      private void zsort_alloc_blk()
      allocate block using zsort_mem or max avail.
    • zsort_term

      private void zsort_term()
      terminate zsort
      1. freemain allocated memory
      2. close/delete sortwk1 and sortwk2
    • zsort_freemain

      private void zsort_freemain()
      release storage if allocted
    • zsort_close_wk

      private void zsort_close_wk()
      close and delete sortwk01 and sortwk02
    • zsort_put_stats

      private void zsort_put_stats()
      write zsort statistics to sta file
    • zsort_error

      private void zsort_error(String msg)
      issue error and set return code 16
      Parameters:
      msg - Error message
    • zsort_sort_blk

      private void zsort_sort_blk()
      sort fixed length records in zsort_blk up to zsort_blk_ptr
    • zsort_comp

      private boolean zsort_comp(int rec1, int rec2)
      compare record key fields at mem(rec1) to mem(rec2) and return true if swap required
      Parameters:
      rec1 - record 1 location
      rec2 - record 2 location
      Returns:
      true if swap[ required; false otherwise
    • zsort_merge

      private void zsort_merge()
      merge sorted blocks from sortwk01 to sortwk02 and back again doubling sorted block size each time until there is 1 sorted block
    • zsort_init_merge_pass

      private void zsort_init_merge_pass()
      init for merge of wk01/wk02
    • zsort_get_merge_blk1

      private void zsort_get_merge_blk1()
      read next full or partial blk1 from current merge blk1_xrba to blk1_xrba_end
    • zsort_get_merge_blk2

      private void zsort_get_merge_blk2()
      read next full or partial blk2 from current merge blk2_xrba to blk2_xrba_end
    • zsort_merge_blk_rec

      private void zsort_merge_blk_rec()
      merge records from 2 blks into 1 output blk
    • zsort_next_merge_blks

      private void zsort_next_merge_blks()
      position to next merge blks in curr pass
    • svc_systrace

      private void svc_systrace()
      reset ez390 trace options from string at R1 with trailing space