{ *************************************************************************** }
MODULE mod_test ;
{ *************************************************************************** }
{ *************************************************************************** }
INCLUDE 
  mod_common_global_flags,
  mod_common_soft_conn,
  mod_common_parse, 
  mod_parse_global,
  mod_handle_console,
  mod_handle_tracing,
  mod_def_hardware_tables,
  mod_def_physics_tables, 
  mod_handle_registers,
  mod_common_hard_io,
  mod_tcs_io_prescaler_handling,      {from the TRICS hardware IO library     }
  mod_tcs_io_spy_handling ;           {from the TRICS hardware IO library     }
{ *************************************************************************** }
EXPORT 
  test_scan_card_reg ;
{ *************************************************************************** }
{ *************************************************************************** }

  %INCLUDE 'SITE_DEPENDENT.CST/LIST'

TYPE 
  bit  = [BIT(1)] 0..1     ;
  byte = [BYTE]   0..255   ;
{ *************************************************************************** }
{ *************************************************************************** }
{PROGRAM test ;
{
{VAR
{
{  eta, phi : Integer ;
{  e_pol : eta_polarity ;
{  e_fe  : magn_eta_per_fe_cell ;
{  p_fe : phi_value ;
{  
{{BEGIN
{
{  def_hardware_table ;
{  test_size ; }
{  test_scan_card_reg ;
{
{again:
{
{  READLN ( eta, phi ) ;
{  IF ( eta < 0 ) 
{  THEN BEGIN
{    e_pol := neg_e ;
{    e_fe := CONVERT ( magn_eta_per_fe_cell, (-eta-1) DIV 4  ) ;
{  END 
{  ELSE BEGIN
{    e_pol := pos_e ;
{    e_fe := CONVERT ( magn_eta_per_fe_cell, (eta-1) DIV 4  ) ;
{  END ;
{
{  p_fe := CONVERT ( phi_value, phi ) ;
{  WRITELN ( 'cbus: ', ctfe_data[e_pol,e_fe,p_fe].cbus:4, '/',  ctfe_ctrl[e_pol,e_fe,p_fe].cbus:4 ) ;  
{  WRITELN ( 'mba:  ', ctfe_data[e_pol,e_fe,p_fe].mba:4,  '/',  ctfe_ctrl[e_pol,e_fe,p_fe].mba:4  ) ;
{  WRITELN ( 'ca:   ', ctfe_data[e_pol,e_fe,p_fe].ca:4,   '/',  ctfe_ctrl[e_pol,e_fe,p_fe].ca:4   ) ;
{
{  GOTO again ;
{}
{END ;
{ *************************************************************************** }
{ *************************************************************************** }
[INLINE] FUNCTION inline_byte_and ( op1 , op2 : byte ) : byte ;
VAR bool1, bool2, bool3 : BOOLEAN ;
BEGIN
 bool1::BYTE_DATA := op1::BYTE_DATA ; bool2::BYTE_DATA := op2::BYTE_DATA ;
 bool3 := bool1 AND bool2 ;
 inline_byte_and::BYTE_DATA := bool3::BYTE_DATA ;
END ;
{ *************************************************************************** }
[INLINE] FUNCTION inline_byte_or ( op1 , op2 : byte ) : byte ;
VAR bool1, bool2, bool3 : BOOLEAN ;
BEGIN
 bool1::BYTE_DATA := op1::BYTE_DATA ; bool2::BYTE_DATA := op2::BYTE_DATA ;
 bool3 := bool1 OR bool2 ;
 inline_byte_or::BYTE_DATA := bool3::BYTE_DATA ;
END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE test_size ;

BEGIN

  WRITELN ;

  WRITELN ( ' cbus_register ', SIZE ( cbus_register ) ) ;

  WRITELN ;

  WRITELN ( ' bbb_card      ', SIZE ( bbb_card ) ) ;
  WRITELN ( ' mbd_card      ', SIZE ( mbd_card ) ) ;
  WRITELN ( ' iml_card      ', SIZE ( iml_card ) ) ;
  WRITELN ( ' imlro_card    ', SIZE ( imlro_card ) ) ;
  WRITELN ( ' andor_card    ', SIZE ( andor_card ) ) ;
  WRITELN ( ' fstd_card     ', SIZE ( fstd_card ) ) ;
  WRITELN ( ' dbsc_card     ', SIZE ( dbsc_card ) ) ;
  WRITELN ( ' sbsc_card     ', SIZE ( sbsc_card ) ) ;
  WRITELN ( ' tlm_card      ', SIZE ( tlm_card ) ) ;
  WRITELN ( ' dgm_stdig_card', SIZE ( dgm_stdig_card ) ) ;
  WRITELN ( ' mtg_card      ', SIZE ( mtg_card ) ) ;
  WRITELN ( ' ctfe_low      ', SIZE ( ctfe_card_low_half ) ) ;
  WRITELN ( ' ctfe_hig      ', SIZE ( ctfe_card_high_half ) ) ;

  WRITELN ;

  WRITELN ( ' bbb           ', SIZE ( bbb_frw     ) ) ;
  WRITELN ( ' mbd           ', SIZE ( mbd_frw     ) ) ;
  WRITELN ;
  WRITELN ( ' imlinput      ', SIZE ( imlinput    ) ) ;
  WRITELN ( ' imlroinput    ', SIZE ( imlroinput  ) ) ;
  WRITELN ( ' andor         ', SIZE ( andor       ) ) ;
  WRITELN ;
  WRITELN ( ' fstd          ', SIZE ( fstd        ) ) ;
  WRITELN ( ' dbsc          ', SIZE ( dbsc        ) ) ;
  WRITELN ( ' sbscdis       ', SIZE ( sbscdis     ) ) ;
  WRITELN ( ' sbscaofired   ', SIZE ( sbscaofired ) ) ;
  WRITELN ;
  WRITELN ( ' tlmfired      ', SIZE ( tlmfired    ) ) ;
  WRITELN ( ' imlrofired    ', SIZE ( imlrofired  ) ) ;
  WRITELN ( ' dgmstdig      ', SIZE ( dgmstdig    ) ) ;
  WRITELN ;
  WRITELN ( ' tlmbusy       ', SIZE ( tlmbusy     ) ) ;
  WRITELN ( ' imlrobusy     ', SIZE ( imlrobusy   ) ) ;
  WRITELN ( ' dgmbzdis      ', SIZE ( dgmbzdis    ) ) ;
  WRITELN ;
  WRITELN ( ' tlmtrgnum     ', SIZE ( tlmtrgnum   ) ) ;
  WRITELN ( ' tlmstdig      ', SIZE ( tlmstdig    ) ) ;
  WRITELN ( ' tlmfiredstb   ', SIZE ( tlmfiredstb ) ) ;
  WRITELN ( ' tlmfiredout   ', SIZE ( tlmfiredout ) ) ;
  WRITELN ( ' imlroaux      ', SIZE ( imlroaux    ) ) ;
  WRITELN ;
  WRITELN ( ' mtgdirin      ', SIZE ( mtgdirin    ) ) ;
  WRITELN ( ' mtgholdtx     ', SIZE ( mtgholdtx   ) ) ;
  WRITELN ( ' mtgstdig      ', SIZE ( mtgstdig    ) ) ;
  WRITELN ( ' mtgbusy       ', SIZE ( mtgbusy     ) ) ;
  WRITELN ( ' mtgtss        ', SIZE ( mtgfwtss    ) ) ;
  WRITELN ( ' dbsctrgnum    ', SIZE ( dbsctrgnum  ) ) ;
  WRITELN ( ' '                                     ) ;
  WRITELN ( ' bbb_calfe     ', SIZE ( bbb_calfe   ) ) ;
  WRITELN ( ' mbd_calfe     ', SIZE ( mbd_calfe   ) ) ;
  WRITELN ( ' ctfe_data     ', SIZE ( ctfe_data   ) ) ;
  WRITELN ( ' ctfe_ctrl     ', SIZE ( ctfe_ctrl   ) ) ;

  WRITELN ( '                ----------'            ) ;
  WRITELN ( ' total         ', SIZE ( bbb_frw     )
                             + SIZE ( mbd_frw     )

                             + SIZE ( imlinput    )
                             + SIZE ( imlroinput  )
                             + SIZE ( andor       )

                             + SIZE ( fstd        )
                             + SIZE ( dbsc        )
                             + SIZE ( sbscdis     )
                             + SIZE ( sbscaofired )

                             + SIZE ( tlmfired    )
                             + SIZE ( imlrofired  )
                             + SIZE ( dgmstdig    )

                             + SIZE ( tlmbusy     )
                             + SIZE ( imlrobusy   )
                             + SIZE ( dgmbzdis    )

                             + SIZE ( tlmtrgnum   )
                             + SIZE ( tlmstdig    )
                             + SIZE ( tlmfiredstb )
                             + SIZE ( tlmfiredout )
                             + SIZE ( imlroaux    )

                             + SIZE ( mtgdirin    )
                             + SIZE ( mtgholdtx   )
                             + SIZE ( mtgstdig    )
                             + SIZE ( mtgbusy     )
                             + SIZE ( mtgfwtss    )
                             + SIZE ( dbsctrgnum  )

                             + SIZE ( bbb_calfe   )
                             + SIZE ( mbd_calfe   )
                             + SIZE ( ctfe_data   )
                             + SIZE ( ctfe_ctrl   )

                                                    ) ;
END;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE test_scan_card_reg ;

VAR

  i : INTEGER ;
  current_card : INTEGER ;
  reg_count : INTEGER ;
  dumpfile : TEXT ;
  ini_status : INTEGER ;
  dumpfile_name : VARYING_STRING(50) := 'DUA0:[TRIGGER]CARD_DUMP.DMP' ;

BEGIN 

  OPEN ( dumpfile, FILE_NAME := dumpfile_name,
                     HISTORY := HISTORY$NEW,      
            CARRIAGE_CONTROL := CARRIAGE$LIST,    
                 DISPOSITION := DISPOSITION$SAVE, 
                      APPEND := TRUE,
                   BUFFERING := TRUE,
                  BUFFERSIZE := 4096,
                  CONTIGUOUS := FALSE,
                  EXTENDSIZE := 10,
                    FILESIZE := 10,
                    TRUNCATE := TRUE,
                       OWNER := %O00040001,
                      STATUS := ini_status ) ;

  IF ( ( ini_status MOD 8 ) = 1 ) 
  THEN BEGIN
    handle_trc_inf ( TAG := 'OPN/DMP%', MESSAGE := ' Dump File Opened ' ) ;
    WRITELN ( dumpfile, '*** TRICS V' + version_number
                    + ' OPENED DUMP FILE, ' + dumpfile_name ) ;
  END 
  ELSE BEGIN
    handle_trc_sta ( TAG := 'OPN/DMP%', STATUS := ini_status ) ;
    GOTO quit_dump ;
  END ;

  current_card := 0 ;
  reg_count := 0 ;

  handle_trc_inf ( TAG := 'WRT/DMP%', 
               MESSAGE := ' This Dump takes about 3 mn 30 s... ' ) ;

  REPEAT

    WRITELN ( dumpfile, 'CARD ',  CONVERT(STRING(4),current_card), 
              '  cbus: ', CONVERT(STRING(1),cardscanner[current_card]^.cbus), 
              '  mba: ', CONVERT(STRING(3),cardscanner[current_card]^.mba),  
              '  ca: ', CONVERT(STRING(2),cardscanner[current_card]^.ca),
              '  has ', CONVERT(STRING(3),cardscanner[current_card]^.regtotal),
              ' registers' ) ;

    reg_count := reg_count + cardscanner[current_card]^.regtotal ;

    FOR i := 0  TO  cardscanner[current_card]^.regtotal-1  DO
      BEGIN
        WRITELN ( dumpfile, 
            '  REG ', 
            CONVERT(STRING(3),i), 
            '  fa: ', 
            CONVERT(STRING(2),cardscanner[current_card]^.register[i].fa), 
            '  content: ', 
            CONVERT(STRING(3),cardscanner[current_card]^.register[i].content), 
            '  class: ', 
            BIN(cardscanner[current_card]^.register[i].class::BYTE), 
            '  read mask: ',  
            BIN(cardscanner[current_card]^.register[i].rmsk::BYTE), 
            '  write mask: ', 
            BIN(cardscanner[current_card]^.register[i].wmsk::BYTE), 
            '  pipeline ', 
            CONVERT(STRING(2),cardscanner[current_card]^.register[i].pipelen),
            ' step(s)'
                 ) ;
      END ;  

    current_card := current_card + 1 ;

  UNTIL ( cardscanner[current_card] = NIL ) ;

  WRITELN ( dumpfile ) ;
  WRITELN ( dumpfile, 'TOTAL OF ', current_card, ' CARDS ' ) ;
  WRITELN ( dumpfile, '         ', reg_count,    ' REGISTERS ' ) ;
  WRITELN ( dumpfile ) ;

  handle_trc_inf ( TAG := 'WRT/DMP%', 
               MESSAGE := ' Total of ' 
                        + CONVERT(STRING,current_card) 
                        + ' Cards and ' 
                        + CONVERT(STRING,reg_count)
                        + ' Registers ' ) ;

  CLOSE ( dumpfile ) ;
  handle_trc_inf ( TAG := 'CLS/DMP%', MESSAGE := ' Dump File Closed ' ) ;

quit_dump:
END;
{ *************************************************************************** }
{ *************************************************************************** }
END.
{ DEC/CMS REPLACEMENT HISTORY, Element MOD233_TEST.PAS}
{ *1    26-MAR-1990 09:03:22 TRIGGER "original loading of pascal source"}
{ DEC/CMS REPLACEMENT HISTORY, Element MOD233_TEST.PAS}