! *** PREDECLARED TYPES
     
      %IF %DECLARED ( %BASIC$QUADWORD_DECLARED ) = 0 %THEN
         RECORD BASIC$QUADWORD
            LONG FILL ( 2 )
         END RECORD
         %LET %BASIC$QUADWORD_DECLARED = 1
      %END %IF
     
      %IF %DECLARED ( %BASIC$OCTAWORD_DECLARED ) = 0 %THEN
         RECORD BASIC$OCTAWORD
            LONG FILL ( 4 )
         END RECORD
         %LET %BASIC$OCTAWORD_DECLARED = 1
      %END %IF
     
      %IF %DECLARED ( %BASIC$HFLOAT_AXP_DECLARED ) = 0 %THEN
         RECORD BASIC$HFLOAT_AXP
            LONG FILL ( 4 )
         END RECORD
         %LET %BASIC$HFLOAT_AXP_DECLARED = 1
      %END %IF
     
      %IF %DECLARED ( %BASIC$F_FLOATING_COMPLEX_DECL ) = 0 %THEN
         RECORD BASIC$F_FLOATING_COMPLEX
            SINGLE REAL_PART
            SINGLE IMAGINARY_PART
         END RECORD
         %LET %BASIC$F_FLOATING_COMPLEX_DECL = 1
      %END %IF
     
      %IF %DECLARED ( %BASIC$D_FLOATING_COMPLEX_DECL ) = 0 %THEN
         RECORD BASIC$D_FLOATING_COMPLEX
            DOUBLE REAL_PART
            DOUBLE IMAGINARY_PART
         END RECORD
         %LET %BASIC$D_FLOATING_COMPLEX_DECL = 1
      %END %IF
     
      %IF %DECLARED ( %BASIC$G_FLOATING_COMPLEX_DECL ) = 0 %THEN
         RECORD BASIC$G_FLOATING_COMPLEX
            GFLOAT REAL_PART
            GFLOAT IMAGINARY_PART
         END RECORD
         %LET %BASIC$G_FLOATING_COMPLEX_DECL = 1
      %END %IF
     
      %IF %DECLARED ( %BASIC$H_FLOAT_AXP_CMPLX_DCL ) = 0 %THEN
         RECORD BASIC$H_FLOATING_COMPLEX_AXP
            BASIC$HFLOAT_AXP REAL_PART
            BASIC$HFLOAT_AXP IMAGINARY_PART
         END RECORD
         %LET %BASIC$H_FLOAT_AXP_CMPLX_DCL = 1
      %END %IF
    
    
      DECLARE LONG CONSTANT glock$c_nowait = 1  !  $acquire_lock will not auto-wait
      DECLARE LONG CONSTANT glock$c_nospin = 2  !  $acquire_lock will not spin
      DECLARE LONG CONSTANT glock$c_nobreak = 4  !  $acquire_lock will not break lock ownership
      DECLARE LONG CONSTANT glock$c_auto_wait = 8  !  kernel mode code waints an automatic wait 
      DECLARE LONG CONSTANT glock$c_num_nodes = 64  !  max number of gnodes supported
      DECLARE LONG CONSTANT glcktbl$c_process = 0  !  lock region is mapped in P2 space
      DECLARE LONG CONSTANT glcktbl$c_system = 1  !  lock region is mapped in S2 space
      DECLARE LONG CONSTANT glcktbl$c_private = 2  !  lock region is pre-allocated
      DECLARE LONG CONSTANT glock_hist$s_glock_hist = 12
      record glock_hist
         LONG glock_hist$l_pc
         BASIC$QUADWORD glock_hist$q_lock
      end record glock_hist
    
      DECLARE LONG CONSTANT glock_hist$c_entries = 10
      DECLARE LONG CONSTANT glock$m_owned = x'00000001'
      DECLARE LONG CONSTANT glock$m_broken = x'00000002'
      DECLARE LONG CONSTANT glock$m_waiters = x'00000004'
      DECLARE LONG CONSTANT glock$m_process = x'00000008'
      DECLARE LONG CONSTANT glock$m_reserved_4_7 = x'000000F0'
      DECLARE LONG CONSTANT glock$m_owner_count = x'0000FF00'
      DECLARE LONG CONSTANT glock$m_node = x'00FF0000'
      DECLARE LONG CONSTANT glock$m_node_seq = x'00000000'
      DECLARE LONG CONSTANT glock$m_owner = x'00000000'
      DECLARE LONG CONSTANT glock$S_GLOCK = 192
      record GLOCK
         LONG glock$l_flink                 !  Forward link (lock handle)
         LONG glock$l_spare1                !  not used
         WORD glock$w_size                  !  size of structure
         BYTE glock$b_type                  !  Structure type
         BYTE glock$b_subtype               !  subtype
         BYTE glock$b_ipl                   !  IPL to raise to on acquire
         BYTE glock$b_prev_ipl              !  IPL to lower to on release
         BYTE glock$b_rank                  !  Rank of lock
         BYTE glock$b_spare2                !  not used
         group glock$r_fill_6_
            variant
               case
                  BASIC$QUADWORD glock$q_lock  !  the lock
               case
                  group glock$r_fill_7_
                     group glock$r_fill_8_
                        variant
                        case
                            !  lock flags
                           BYTE flags_bits   ! COMMENT ADDED BY SDL - flags_bits contains bits flags through flags
                        case
                           group glock$r_fill_9_
                               !  lock is owned
                               !  lock ownership is broken
                               !  there are waiters
                               !  lock is owned in process context
                               !  the unused bits
                              BYTE owned_bits   ! COMMENT ADDED BY SDL - owned_bits contains bits owned through reserved_4_7
                           end group glock$r_fill_9_
                        end variant
                     end group glock$r_fill_8_
                      !  nested owner count
                      !  node where lock is owned
                      !  node sequence number
                      !  owner EPID or CPU #
                     BYTE owner_count_bits ( 7 )   ! COMMENT ADDED BY SDL - owner_count_bits contains bits owner_count through owner
                  end group glock$r_fill_7_
            end variant
         end group glock$r_fill_6_
         BASIC$QUADWORD glock$q_thread_id   !  thread id of lock owner
         BASIC$QUADWORD glock$q_waiters     !  bitmask of waiters
         LONG glock$l_timeout               !  wait timeout
         STRING glock$t_name = 16           !  lock name
         LONG glock$l_spare4                !  not used
         LONG glock$l_spare5                !  not used
         LONG glock$l_history_idx           !  next history longword to be used
         glock_hist glock$r_history ( 1 to 10 )  !  acquire - release history
      end record GLOCK
    
      DECLARE LONG CONSTANT glock$c_length = 64  !  Length 
      DECLARE LONG CONSTANT glock$k_length = 64  !  Length 
      DECLARE LONG CONSTANT glock$c_max_length = 192  !  max length 
      DECLARE LONG CONSTANT glock$k_max_length = 192  !  max length 
      DECLARE LONG CONSTANT glock_lock$m_owned = x'00000001'
      DECLARE LONG CONSTANT glock_lock$m_broken = x'00000002'
      DECLARE LONG CONSTANT glock_lock$m_waiters = x'00000004'
      DECLARE LONG CONSTANT glock_lock$m_process = x'00000008'
      DECLARE LONG CONSTANT glock_lock$m_reserved_4_7 = x'000000F0'
      DECLARE LONG CONSTANT glock_lock$m_owner_count = x'0000FF00'
      DECLARE LONG CONSTANT glock_lock$m_node = x'00FF0000'
      DECLARE LONG CONSTANT glock_lock$m_node_seq = x'00000000'
      DECLARE LONG CONSTANT glock_lock$m_owner = x'00000000'
      DECLARE LONG CONSTANT glock_lock$s_glock_lock = 8
      record glock_lock
         group glock_lock$r_fill_10_
            variant
               case
                  BASIC$QUADWORD glock_lock$q_lock  !  the lock
               case
                  group glock_lock$r_fill_11_
                     group glock_lock$r_fill_12_
                        variant
                        case
                            !  lock flags
                           BYTE flags_bits   ! COMMENT ADDED BY SDL - flags_bits contains bits flags through flags
                        case
                           group glock_lock$r_fill_13_
                               !  lock is owned
                               !  lock ownership is broken
                               !  there are waiters
                               !  lock is owned in process context
                               !  the unused bits
                              BYTE owned_bits   ! COMMENT ADDED BY SDL - owned_bits contains bits owned through reserved_4_7
                           end group glock_lock$r_fill_13_
                        end variant
                     end group glock_lock$r_fill_12_
                      !  nested owner count
                      !  node where lock is owned
                      !  node sequence number
                      !  owner EPID or CPU #
                     BYTE owner_count_bits ( 7 )   ! COMMENT ADDED BY SDL - owner_count_bits contains bits owner_count through owner
                  end group glock_lock$r_fill_11_
            end variant
         end group glock_lock$r_fill_10_
      end record glock_lock
    
      DECLARE LONG CONSTANT glcktbl$m_valid = x'00000001'
      DECLARE LONG CONSTANT glcktbl$m_private = x'00000002'
      DECLARE LONG CONSTANT glcktbl$m_space = x'00000004'
      DECLARE LONG CONSTANT glcktbl$m_reserved_3_7 = x'000000F8'
      DECLARE LONG CONSTANT glcktbl$S_GLCKTBL = 256
      record GLCKTBL
         LONG glcktbl$l_flink               !  Forward link (region offset)
         WORD glcktbl$w_lock_size           !  size of locks for the table
         group glcktbl$r_fill_14_
            variant
               case
                  BYTE glcktbl$b_flags      !  lock table flags
               case
                  group glcktbl$r_fill_15_
                      !  lock table is valid
                      !  user allocated lock memory
                      !  clear for process, set for system 
                      !  the unused bits
                     BYTE valid_bits   ! COMMENT ADDED BY SDL - valid_bits contains bits valid through reserved_3_7
                  end group glcktbl$r_fill_15_
            end variant
         end group glcktbl$r_fill_14_
         BYTE glcktbl$b_accmode             !  access mode of global section 
         BASIC$QUADWORD glcktbl$q_reg_id    !  ID of shared memory region
         BASIC$QUADWORD glcktbl$q_reg_phys_size  !  physical size of shared memory region
         BASIC$QUADWORD glcktbl$q_reg_virt_size  !  virtual size of shared memory region
         BASIC$QUADWORD glcktbl$q_num_locks  !  number of locks in the region
         LONG glcktbl$l_free_list           !  free glock list
         LONG glcktbl$l_used_list           !  used glock list
         BASIC$QUADWORD glcktbl$q_nodes     !  bitmask of connected nodes
         BASIC$QUADWORD glcktbl$q_glock_handle  !  handle of embedded glock
         BYTE glcktbl$b_glock ( 1 to 64 )      !  embedded GLOCK
         WORD glcktbl$w_ref_counts ( 1 to 64 )  !  per-node ref counters
      end record GLCKTBL
    
      DECLARE LONG CONSTANT glcktbl$c_length = 256  !  Length 
      DECLARE LONG CONSTANT glcktbl$k_length = 256  !  Length 
      DECLARE LONG CONSTANT glock_nodeb$s_glock_nodeb = 32
      record glock_nodeb
         BASIC$QUADWORD glock_nodeb$q_lock_handle  !  lockhandle for ipint
         BYTE glock_nodeb$b_spares ( 1 to 24 )  !  pad to 32 bytes
      end record glock_nodeb
    
      DECLARE LONG CONSTANT glock_nodeb$c_length = 32  !  length
      DECLARE LONG CONSTANT gmdb_glock$s_gmdb_glock = 2576
      record gmdb_glock
         BASIC$QUADWORD gmdb_glock$q_nodes  !  connected nodes
         BASIC$QUADWORD gmdb_glock$q_max_nodes  !  max nodes supported
         BASIC$QUADWORD gmdb_glock$q_flags  !  flags
         BASIC$QUADWORD gmdb_glock$q_handle  !  lock handle 
         BYTE gmdb_glock$b_lock ( 1 to 64 )    !  GLOCK for the locking portion of the GMDB
         BYTE gmdb_glock$b_lcktbl ( 1 to 256 )  !  embedded GLCKTBL for locks in the GMDB
         BASIC$QUADWORD gmdb_glock$q_num_tables ( 1 to 2 )  !  number of locktables in the regions
         LONG gmdb_glock$l_free_list ( 1 to 2 )  !  lists of free lock tables
         LONG gmdb_glock$l_used_list ( 1 to 2 )  !  lists of used lock tables
         BASIC$QUADWORD gmdb_glock$q_reg_handle ( 1 to 2 )  !  lock handles for locktable list locks
         BYTE gmdb_glock$b_prc_lock ( 1 to 64 )  !  GLOCK for process locktable lists
         BYTE gmdb_glock$b_sys_lock ( 1 to 64 )  !  GLOCK for system locktable lists
         glock_nodeb gmdb_glock$r_nodeb ( 1 to 64 )  !  per node cells
      end record gmdb_glock
    
      DECLARE LONG CONSTANT gmdb_glock$c_length = 2576  !  Length