head     56.3;
access   paws bayes jws quist brad dew jwh;
symbols  ;
locks    ; strict;
comment  @# @;


56.3
date     93.01.27.13.19.02;  author jwh;  state Exp;
branches ;
next     56.2;

56.2
date     93.01.27.12.00.02;  author jwh;  state Exp;
branches ;
next     56.1;

56.1
date     91.11.05.09.56.23;  author jwh;  state Exp;
branches ;
next     55.1;

55.1
date     91.08.25.10.31.51;  author jwh;  state Exp;
branches ;
next     54.3;

54.3
date     91.08.21.10.39.53;  author jwh;  state Exp;
branches ;
next     54.2;

54.2
date     91.08.21.09.43.16;  author jwh;  state Exp;
branches ;
next     54.1;

54.1
date     91.03.18.15.33.08;  author jwh;  state Exp;
branches ;
next     53.1;

53.1
date     91.03.11.19.32.59;  author jwh;  state Exp;
branches ;
next     52.1;

52.1
date     91.02.19.09.18.30;  author jwh;  state Exp;
branches ;
next     51.1;

51.1
date     91.01.30.16.17.33;  author jwh;  state Exp;
branches ;
next     50.1;

50.1
date     90.10.29.16.31.36;  author jwh;  state Exp;
branches ;
next     49.1;

49.1
date     90.08.14.14.15.21;  author jwh;  state Exp;
branches ;
next     48.1;

48.1
date     90.07.26.11.21.50;  author jwh;  state Exp;
branches ;
next     47.1;

47.1
date     90.05.14.11.06.50;  author dew;  state Exp;
branches ;
next     46.1;

46.1
date     90.05.07.08.53.49;  author jwh;  state Exp;
branches ;
next     45.1;

45.1
date     90.04.19.16.01.48;  author jwh;  state Exp;
branches ;
next     44.1;

44.1
date     90.04.01.22.18.57;  author jwh;  state Exp;
branches ;
next     43.1;

43.1
date     90.03.20.14.11.39;  author jwh;  state Exp;
branches ;
next     42.1;

42.1
date     90.01.23.17.55.52;  author jwh;  state Exp;
branches ;
next     41.1;

41.1
date     89.12.22.11.38.00;  author jwh;  state Exp;
branches ;
next     40.1;

40.1
date     89.09.29.11.59.04;  author jwh;  state Exp;
branches ;
next     39.1;

39.1
date     89.09.26.16.43.55;  author dew;  state Exp;
branches ;
next     38.1;

38.1
date     89.08.29.11.35.53;  author jwh;  state Exp;
branches ;
next     37.1;

37.1
date     89.05.12.11.49.43;  author dew;  state Exp;
branches ;
next     36.1;

36.1
date     89.02.06.10.27.21;  author dew;  state Exp;
branches ;
next     35.1;

35.1
date     89.02.02.13.43.00;  author dew;  state Exp;
branches ;
next     34.1;

34.1
date     89.01.23.16.18.11;  author jwh;  state Exp;
branches ;
next     33.1;

33.1
date     89.01.16.11.49.34;  author dew;  state Exp;
branches ;
next     32.1;

32.1
date     89.01.10.11.59.00;  author bayes;  state Exp;
branches ;
next     31.1;

31.1
date     88.12.14.18.19.43;  author bayes;  state Exp;
branches ;
next     30.1;

30.1
date     88.12.09.13.56.51;  author dew;  state Exp;
branches ;
next     29.1;

29.1
date     88.10.31.15.41.22;  author bayes;  state Exp;
branches ;
next     28.1;

28.1
date     88.10.06.11.07.35;  author dew;  state Exp;
branches ;
next     27.1;

27.1
date     88.09.29.11.50.24;  author bayes;  state Exp;
branches ;
next     26.4;

26.4
date     88.09.28.13.41.43;  author bayes;  state Exp;
branches ;
next     26.3;

26.3
date     88.09.28.13.41.27;  author bayes;  state Exp;
branches ;
next     26.2;

26.2
date     88.09.28.13.41.11;  author bayes;  state Exp;
branches ;
next     26.1;

26.1
date     88.09.28.13.40.56;  author bayes;  state Exp;
branches ;
next     24.1;

24.1
date     87.08.31.10.16.48;  author jws;  state Exp;
branches ;
next     23.1;

23.1
date     87.08.26.11.03.15;  author bayes;  state Exp;
branches ;
next     22.1;

22.1
date     87.08.17.11.42.20;  author bayes;  state Exp;
branches ;
next     21.1;

21.1
date     87.08.12.14.26.08;  author bayes;  state Exp;
branches ;
next     20.1;

20.1
date     87.07.30.11.38.02;  author bayes;  state Exp;
branches ;
next     19.1;

19.1
date     87.06.01.08.51.59;  author jws;  state Exp;
branches ;
next     18.1;

18.1
date     87.05.20.15.57.15;  author bayes;  state Exp;
branches ;
next     17.1;

17.1
date     87.04.30.11.01.14;  author jws;  state Exp;
branches ;
next     16.1;

16.1
date     87.04.26.16.11.17;  author jws;  state Exp;
branches ;
next     15.1;

15.1
date     87.04.13.09.52.11;  author jws;  state Exp;
branches ;
next     14.1;

14.1
date     87.04.01.16.02.44;  author jws;  state Exp;
branches ;
next     13.1;

13.1
date     87.02.28.18.54.32;  author jws;  state Exp;
branches ;
next     12.1;

12.1
date     87.02.02.13.48.16;  author jws;  state Exp;
branches ;
next     11.1;

11.1
date     87.01.19.10.14.29;  author jws;  state Exp;
branches ;
next     10.1;

10.1
date     86.12.24.11.29.45;  author jws;  state Exp;
branches ;
next     9.1;

9.1
date     86.12.12.15.13.46;  author bayes;  state Exp;
branches ;
next     8.1;

8.1
date     86.11.27.12.22.44;  author jws;  state Exp;
branches ;
next     7.1;

7.1
date     86.11.20.14.35.41;  author hal;  state Exp;
branches ;
next     6.1;

6.1
date     86.11.04.18.28.03;  author paws;  state Exp;
branches ;
next     5.1;

5.1
date     86.10.28.17.17.34;  author hal;  state Exp;
branches ;
next     4.1;

4.1
date     86.10.13.15.22.13;  author geli;  state Exp;
branches ;
next     3.2;

3.2
date     86.10.13.15.20.17;  author geli;  state Exp;
branches ;
next     3.1;

3.1
date     86.10.13.15.17.55;  author geli;  state Exp;
branches ;
next     2.1;

2.1
date     86.10.13.15.15.23;  author geli;  state Exp;
branches ;
next     1.2;

1.2
date     86.10.13.15.11.34;  author geli;  state Exp;
branches ;
next     1.1;

1.1
date     86.10.13.15.08.31;  author geli;  state tmp;
branches ;
next     ;


desc
@Base file for PWS 3.2 release.

@


56.3
log
@
pws2rcs automatic delta on Wed Jan 27 13:14:25 MST 1993
@
text
@(*

 (c) Copyright Hewlett-Packard Company, 1986.
All rights are reserved.  Copying or other
reproduction of this program except for archival
purposes is prohibited without the prior
written consent of Hewlett-Packard Company.


	    RESTRICTED RIGHTS LEGEND

Use, duplication, or disclosure by the Government
is subject to restrictions as set forth in
paragraph (b) (3) (B) of the Rights in Technical
Data and Computer Software clause in
DAR 7-104.9(a).

HEWLETT-PACKARD COMPANY
Fort Collins, Colorado                         *)

$SYSPROG$
$heap_dispose off$
$iocheck off$
$range off$ $ovflcheck off$
$debug off$
$stackcheck off$

PROGRAM SYSDEVICES;
MODULE SYSDEVS;

$SEARCH 'INITLOAD'$


IMPORT SYSGLOBALS;
EXPORT
 {* DUMMY DECLARATIONS **********************************}
 TYPE
   KBDHOOKTYPE  = PROCEDURE(VAR STATBYTE,DATABYTE: BYTE;
			    VAR DOIT: BOOLEAN);
   OUT2TYPE     = PROCEDURE(VALUE1,VALUE2: BYTE);
   REQUEST1TYPE = PROCEDURE(CMD: BYTE; VAR VALUE: BYTE);
   BOOLPROC     = PROCEDURE(B:BOOLEAN);

{* CRT *************************************************}
{***** THIS SECTION HAS HARD OFFSET REFERENCES *********}
{      IN MODULES CRTB (ASSY FILE GASSM)                }
TYPE
  CRTWORD = RECORD CASE INTEGER OF
	    1:(HIGHLIGHTBYTE,CHARACTER: CHAR);
	    2:(WHOLEWORD: SHORTINT);
	    END;
  CRTLLOPS =(CLLPUT,CLLSHIFTL,CLLSHIFTR,CLLCLEAR,CLLDISPLAY,PUTSTATUS);
  CRTLLTYPE=PROCEDURE(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
  DBCRTOPS =(DBINFO,DBEXCG,DBGOTOXY,DBPUT,DBINIT,DBCLEAR,DBCLINE,DBSCROLLUP,
	     DBSCROLLDN,DBSCROLLL,DBSCROLLR,DBHIGHL);
  DBCINFO  = RECORD
	       SAVEAREA : WINDOWP;
	       SAVESIZE : INTEGER;
	       DCURSORADDR : INTEGER;
	       XMIN,XMAX,YMIN,YMAX : SHORTINT;
	       CURSX,CURSY         : SHORTINT;
	       C : CHAR;
	       AREAISDBCRT : BOOLEAN;
	       CHARISMAPPED: BOOLEAN; { 3/25/85 }
	       DEBUGHIGHLIGHT: SHORTINT;  { 3/25/85 }
	     END;
  DBCRTTYPE=PROCEDURE(OP:DBCRTOPS; VAR DBCRT:DBCINFO);

  crtconsttype = packed array [0..11] of byte;

  crtfrec = packed record
	       nobreak,stupid,slowterm,hasxycrt,
	       haslccrt{built in crt},hasclock,
	       canupscroll,candownscroll      :    boolean;
	     end;

  b9 = packed array[0..8] of boolean;
  b14= packed array[0..13] of boolean;
  crtcrec = packed record                               (* CRT CONTROL CHARS *)
	       rlf,ndfs,eraseeol,
	       eraseeos,home,
	       escape             : char;
	       backspace          : char;
	       fillcount          : 0..255;
	       clearscreen,
	       clearline          : char;
	       prefixed           : b9
	    end;

  crtirec = packed record                          (* CRT INFO & INPUT CHARS *)
	       width,height      : shortint;
	       crtmemaddr,crtcontroladdr,
	       keybufferaddr,progstateinfoaddr:integer;
	       keybuffersize: shortint;
	       crtcon            : crtconsttype;
	       right,left,down,up: char;
	       badch,chardel,stop,
	       break,flush,eof   : char;
	       altmode,linedel   : char;
	       backspace,
	       etx,prefix        : char;
	       prefixed          : b14 ;
	       cursormask        : integer;
	       spare             : integer;
	    end;

  environ = record
	      miscinfo: crtfrec;
	      crttype: integer;
	      crtctrl: crtcrec;
	      crtinfo: crtirec;
	    end;

  environptr    = ^environ;

  crtkinds = (NOCRT, ALPHATYPE, BITMAPTYPE, SPECIALCRT1, SPECIALCRT2);

  dumpstyle = 0..255;

VAR
  SYSCOM: ENVIRONPTR;
  ALPHASTATE['ALPHAFLAG']       : BOOLEAN;
  GRAPHICSTATE['GRAPHICSFLAG']  : BOOLEAN;
  CRTIOHOOK             : AMTYPE;
  TOGGLEALPHAHOOK       : PROCEDURE;
  TOGGLEGRAPHICSHOOK    : PROCEDURE;
  DUMPALPHAHOOK         : PROCEDURE;
  DUMPGRAPHICSHOOK      : PROCEDURE;
  UPDATECURSORHOOK      : PROCEDURE;
  CRTINITHOOK           : PROCEDURE;
  CRTLLHOOK             : CRTLLTYPE;
  DBCRTHOOK             : DBCRTTYPE;
  XPOS                  : SHORTINT; { CURSOR X POSITION }
  YPOS                  : SHORTINT; { CURSOR Y POSITION }
  CURRENTCRT            : CRTKINDS; { ACTIVE ALPHA DRIVER TYPE }
  BITMAPADDR            : INTEGER;  { ADDRESS OF BITMAP CONTROL SPACE }
  FRAMEADDR             : INTEGER;  { ADDRESS OF BITMAP FRAME BUFFER }
  REPLREGCOPY           : SHORTINT; { REGISTER COPIES FOR BITMAP DISPLAY }
  WINDOWREGCOPY         : SHORTINT; { MUST BE IN GLOBALS BECAUSE REGISTERS }
  WRITEREGCOPY          : SHORTINT; { ARE NOT READABLE -- MAY BE UNDEFINED }

 {* KEYBOARD *******************************************}
 CONST
   KBD_ENABLE     = 0; KBD_DISABLE    = 1;
   SET_AUTO_DELAY = 2; SET_AUTO_REPEAT= 3;
   GET_AUTO_DELAY = 4; GET_AUTO_REPEAT= 5;
   SET_KBDTYPE    = 6; SET_KBDLANG    = 7;
 TYPE
   STRING80PTR = ^STRING80;
   KEYBOARDTYPE = (NOKBD,LARGEKBD,SMALLKBD,ITFKBD,SPECIALKBD1,SPECIALKBD2);
   LANGTYPE = (NO_KBD,FINISH_KBD,BELGIAN_KBD,CDN_ENG_KBD,CDN_FR_KBD,
	       NORWEGIAN_KBD,DANISH_KBD,DUTCH_KBD,SWISS_GR_KBD,SWISS_FR_KBD,
	       SPANISH_EUR_KBD,SPANISH_LATIN_KBD,UK_KBD,ITALIAN_KBD,
	       FRENCH_KBD,GERMAN_KBD,SWEDISH_KBD,SPANISH_KBD,
	       KATAKANA_KBD,US_KBD,ROMAN8_KBD,NS1_KBD,NS2_KBD,NS3_KBD,
	       SWISS_GR_B_KBD,SWISS_FR_B_KBD {ADDED FOR 3.1--SFB-5/22/85} );
   MENUTYPE = (M_NONE,M_SYSNORM,M_SYSSHIFT,M_U1,M_U2,M_U3,M_U4);
 VAR
   KBDREQHOOK   : REQUEST1TYPE;
   KBDIOHOOK    : AMTYPE;
   KBDISRHOOK   : KBDHOOKTYPE;
   KBDPOLLHOOK  : BOOLPROC;
   KBDTYPE      : KEYBOARDTYPE;
   KBDCONFIG    : BYTE;         { KEYBOARD CONFIGURATION JUMPER }
   KBDLANG      : LANGTYPE;
   SYSMENU      : STRING80PTR;
   SYSMENUSHIFT : STRING80PTR;
   MENUSTATE    : MENUTYPE;

{* ENABLE / DISABLE ************************************}
 CONST
   KBDMASK=1;RESETMASK=2;TIMERMASK=4;PSIMASK=8;FHIMASK=16;
 VAR
   MASKOPSHOOK : OUT2TYPE; { ENABLE, DISABLE }

{* BEEPER **********************************************}
 VAR
   BEEPERHOOK: OUT2TYPE;
   BFREQUENCY, BDURATION: BYTE;

{* RPG *************************************************}
 CONST
   RPG_ENABLE   = 0; RPG_DISABLE = 1;
   SET_RPG_RATE = 2; GET_RPG_RATE =3;
 VAR
   RPGREQHOOK: REQUEST1TYPE;
   RPGISRHOOK: KBDHOOKTYPE;

{* BATTERY *********************************************}
TYPE
  BATCMDTYPE = PROCEDURE(CMD: BYTE; NUMDATA: INTEGER;
			 B1, B2, B3, B4, B5: BYTE);
  BATREADTYPE= PROCEDURE(VAR DATA: BYTE);
VAR
  BATTERYPRESENT[-563]: BOOLEAN;
  BATCMDHOOK : BATCMDTYPE;
  BATREADHOOK: BATREADTYPE;

{* CLOCK ***********************************************}
TYPE
  RTCTIME = PACKED RECORD
	       PACKEDTIME,PACKEDDATE:INTEGER;
	    END;
  CLOCKFUNC = (CGETDATE,CGETTIME,CSETDATE,CSETTIME,CSETZONE);
	      {CSETZONE ADDED BY JWS 4/17/86}

  CLOCKOP   = (CGET,CSET,CUPDATE,CTZ);   {CUPDATE ADDED FOR BOBCAT 4/11/85 SFB}
					 {CTZ ADDED 4/17/86 JWS}
  CLOCKDATA = RECORD
		CASE BOOLEAN OF
		TRUE :(TIMETYPE:TIMEREC);
		FALSE:(DATETYPE:DATEREC);
	      END;
  CLOCKREQTYPE = PROCEDURE(CMD:CLOCKFUNC; ANYVAR DATA:CLOCKDATA);
  CLOCKIOTYPE  = PROCEDURE(CMD:CLOCKOP  ; VAR DATA:RTCTIME);
VAR
  CLOCKREQHOOK : CLOCKREQTYPE;  { CLOCK MODULE INTERFACE }
  CLOCKIOHOOK  : CLOCKIOTYPE;   { CARD DRIVER INTERFACE }

{* TIMER ***********************************************}
TYPE
  TIMERTYPES = (CYCLICT,PERIODICT,DELAYT,DELAY7T,MATCHT);
  TIMEROPTYPE = (SETT,READT,GETTINFO);
  TIMERDATA = RECORD
	       CASE INTEGER OF
	       0: (COUNT: INTEGER);
	       1: (MATCH: TIMEREC);
	       2: (RESOLUTION,RANGE:INTEGER);
	       END;
  TIMERIOTYPE = PROCEDURE(TIMER: TIMERTYPES;OP: TIMEROPTYPE;VAR TD: TIMERDATA);
VAR
  TIMERIOHOOK  : TIMERIOTYPE;
  TIMERISRHOOK : KBDHOOKTYPE;


{* KEYBUFFER *******************************************}
CONST
  KMAXBUFSIZE = 255;
TYPE

  KOPTYPE = (KGETCHAR,KAPPEND,KNONADVANCE,KCLEAR,KDISPLAY,
	     KGETLAST,KPUTFIRST);
  KBUFTYPE= PACKED ARRAY[0..KMAXBUFSIZE] OF CHAR;
  KBUFPTR = ^KBUFTYPE;
  KBUFRECPTR = ^KBUFREC;
  KBUFREC = RECORD
	      ECHO: BOOLEAN;
	      NON_CHAR: CHAR;
	      MAXSIZE,SIZE,INP,OUTP: INTEGER;
	      BUFFER: KBUFPTR;
	    END;

VAR
  KEYBUFFER : KBUFRECPTR;
  KBDWAITHOOK: PROCEDURE;
  KBDRELEASEHOOK: PROCEDURE;
  STATUSLINE: PACKED ARRAY[0..7] OF CHAR;
  {0  s or f = STEP/FLASH IN PROGRESS (WAITING FOR TRAP #0)}
  {1..5  last executed/current line number }
  {6  S=SYSTEM  U=USER  DEFINITION FOR ITF SOFT KEYS}
  {   BLANK FOR NON ITF KEYBOARDS }
  {7  RUNLIGHT }

{* KEY TRANSLATION SERVICES ********************************}
TYPE
  KEYTRANSTYPE =(KPASSTHRU,KSHIFT_EXTC,KPASS_EXTC);
  KEYTYPE = (ALPHA_KEY,NONADV_KEY,SPECIAL_KEY,IGNORED_KEY,NONA_ALPHA_KEY);
  { ADDED NONA_ALPHA_KEY 5/9/84 RQ/SFB }

  LANGCOMREC = RECORD
		 STATUS : BYTE;
		 DATA   : BYTE;
		 KEY    : CHAR;
		 RESULT : KEYTYPE;
		 SHIFT,CONTROL,EXTENSION: BOOLEAN;
	       END;
  LANGKEYREC = RECORD
		 NO_CAPSLOCK: BOOLEAN;
		 NO_SHIFT   : BOOLEAN;
		 NO_CONTROL : BOOLEAN;
		 NO_EXTENSION : BOOLEAN;
		 KEYCLASS   : KEYTYPE;
		 KEYS : ARRAY[BOOLEAN] OF CHAR;
	       END;
  LANGRECORD= RECORD
		CAN_NONADV: BOOLEAN;
		LANGCODE  : LANGTYPE;
		SEMANTICS : PROCEDURE;
		KEYTABLE  : ARRAY[0..127] OF LANGKEYREC;
	      END;
  LANGPTR   = ^LANGRECORD;
VAR
  LANGCOM   : LANGCOMREC;
  LANGTABLE : ARRAY[0..1] OF LANGPTR;
  LANGINDEX : 0..1;
  KBDTRANSHOOK : KBDHOOKTYPE;
  TRANSMODE : KEYTRANSTYPE;
  KBDSYSMODE, KBDALTLOCK, KBDCAPSLOCK : BOOLEAN;

{* HPHIL ***********************************************}
{MOVED INTO SYSDEVS 4/6/84 SFB}
const
  le_configured = hex('80');
  le_error      = hex('81');
  le_timeout    = hex('82');
  le_loopdown   = hex('84');

  lmaxdevices   = 7;

type
  loopdvrop   = (datastarting,dataended,resetdevice,uninitdevice);
		 {UNINIT ADDED 4/8/85 SFB}
  loopdvrproc = procedure(op:loopdvrop);

  {HPHILOP DEFINED AS NEW TYPE 4/6/84 SFB}
  HPHILOP      = (RAWSHIFTOP,NORMSHIFTOP,CHECKLOOPOP,CONFIGUREOP,LCOMMANDOP);
  {5 PROCEDURES HOOKED AS TYPE HPHILCMDPROC 4/6/84 SFB}
  HPHILCMDPROC = PROCEDURE(OP : HPHILOP);


  descriprec = packed record    { DEVICE DESCRIBE RECORD }
		 case boolean of
		 true :(id       : byte;
			twosets  : boolean;
			abscoords: boolean;
			size16   : boolean;
			hasprompts:boolean;
		      { reserved : 0..3;        {DELETED 3/25/85 SFB}
			ext_desc : boolean;     {3/27/85 SFB}
			security : boolean;     {3/26/85 SFB}
			numaxes  : 0..3;
			counts   : shortint;
			maxcountx: shortint;
			maxcounty: shortint;
			maxcountz: shortint;
			promptack: boolean;     {ADDED 3/15/85 SFB}
			nprompts : 0..7;
			proximity: boolean;     {ADDED 3/15/85 SFB}
			nbuttons : 0..7);
		 false:(darray : array[1..11] of char);
	       end;

  devicerec = record
		devstate : integer;
		descrip : descriprec;
		opsproc  : loopdvrproc;
		dataproc : kbdhooktype;
	      end;

  loopdvrptr = ^loopdriverrec;
  loopdriverrec = record
		    lowid,highid,daddr : byte;
		    opsproc  : loopdvrproc;
		    dataproc : kbdhooktype;
		    next     : loopdvrptr;
		  end;

  LOOPCONTROLREC = RECORD                   {REDEFINED AS RECORD - 4/6/84 SFB}
	rawmode : boolean;
	loopdevices : array[1..lmaxdevices] of devicerec;
	loopdevice : 1..lmaxdevices;
	loopcmd    : byte;    { last loop command sent }
	loopdata   : byte;    { data bye in / out }
	looperror  : boolean; { error occured on last operation }
	loopinconfig:boolean; { now doing reconfigure }
	loopcmddone: boolean; { last sent command is done }
	loopisok   : boolean; { loop is configured }
	loopdevreading: boolean; { reading poll data }  { 3.0 BUG #39 3/17/84 }
  END;

  CONST                         {NEW TO END OF HPHIL_COMM_REC TYPE 3/26/85 SFB}


  {DRIVER TYPES}
  NODRIVER   =  0;
  ABSLOCATOR =  1;        {range 1..15 reserved for DGL}
  RELLOCATOR =  2;


  {CODETYPES FROM POLLBLOCK (OR OTHER HPHIL OPCODE)}
  NOCODES       = 0;
  ASCIICODES    = 1;
  SET1CODES     = 2;
  SET2CODES     = 3;

  TYPE

  HPHIL_COMM_REC_PTR_TYPE = ^hphil_comm_rec_type;  {3/25/85 SFB}

  HPHIL_COMM_REC_TYPE = RECORD CASE BOOLEAN OF              {3/25/85 SFB}
   TRUE :
	 (dvr_type        : shortint;
	  dev_addr        : 0..7;
	  latch,                  {stop updating data after button press/event}
	  active,                 {capture data in ISR}
	  reading         : boolean;  {dvr_comm_rec busy, delay update from ISR}
	  devices         : byte; {bit/loopaddress that driver should service
				   put 0 where driver should NOT service device
				   with this dvr_comm_rec !}
	  update          : procedure(recptr : hphil_comm_rec_ptr_type);
				  {call update to flush delayed poll data update}
	  link            : hphil_comm_rec_ptr_type;  {next comm record}
	  extend          : integer; {for extensibility use as pointer/datarec}

	  xloc,                   {HPHIL intrinsic data types from poll/command}
	  yloc,
	  zloc            : shortint;
	  codetype        : shortint;     {describes content of codes}
	  ncodes          : shortint;
	  codes           : packed array [1..16] of char
			       {extensible for variant} );
   FALSE:
	 (barray          : array[0..53] of char);
  END;

var

  loopdriverlist : loopdvrptr;
  LOOPCONTROL    : ^LOOPCONTROLREC;     {4/6/84 SFB}
  HPHILCMDHOOK   : HPHILCMDPROC;        {4/6/84 SFB}

  HPHIL_DATA_LINK : hphil_comm_rec_ptr_type;  {3/13/85 SFB}
  HIL_PRESENT:      BOOLEAN;             {8/28/86 JWS}

  TIMEZONE: INTEGER; {LOCAL + TIMEZONE = GMT} { JWS 4/17/86 }

  alphadumpstyle   : dumpstyle;
  graphicsdumpstyle: dumpstyle;


{-----------------------------------------------------------------------------}
PROCEDURE SYSDEV_INIT;
{* BEEPER **********************************************}
PROCEDURE BEEP;
PROCEDURE BEEPER(FREQUENCY,DURATION:BYTE);
{* RPG *************************************************}
PROCEDURE SETRPGRATE(RATE : BYTE);
{* KEYBOARD ********************************************}
PROCEDURE KBDSETUP(CMD,VALUE:BYTE);
PROCEDURE KBDIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
procedure lockedaction(a: action);
{* CRT *************************************************}
PROCEDURE CRTIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
PROCEDURE DUMMYCRTLL(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
{* BATTERY *********************************************}
PROCEDURE BATCOMMAND(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
FUNCTION  BATBYTERECEIVED:BYTE;
{* CLOCK ***********************************************}
function  sysclock: integer;   {centiseconds from midnight}
procedure sysdate (var thedate: daterec);
procedure systime (var thetime: timerec);
procedure setsysdate ( thedate: daterec);
procedure setsystime ( thetime: timerec);
function  sysgmttime: integer; {seconds from 1 Jan 1970 GMT}
procedure settimezone(tz: integer);
function isleap(y: integer): integer;
procedure secs_to_timedate(secs:integer;
			   var date:daterec; var time:timerec);
function timedate_to_secs(date : daterec; time : timerec) : integer;
{* KEYBUFFER *******************************************}
PROCEDURE KEYBUFOPS(OP:KOPTYPE; VAR C: CHAR);
{* STATUSLINE ******************************************}
PROCEDURE SETSTATUS(N:INTEGER; C:CHAR);
FUNCTION  RUNLIGHT:CHAR;
PROCEDURE SETRUNLIGHT(C:CHAR);

IMPLEMENT

{* GENERAL PURPOSE DUMMY PROCEDURES ********************}
  PROCEDURE DUMMYPROC;
  BEGIN END;
  PROCEDURE DUMMYOUT2(VALUE1, VALUE2 : BYTE);
  BEGIN END;
  PROCEDURE DUMMYKBD(VAR STATBYTE,DATABYTE : BYTE;
		     VAR DOIT:BOOLEAN);
  BEGIN END;
  PROCEDURE DUMMYREQ1(CMD : BYTE; VAR VALUE:BYTE);
  BEGIN END;
  PROCEDURE DUMMYTM(FP: FIBP; REQUEST: AMREQUESTTYPE;
		    ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN END;
  PROCEDURE DUMMYBOOLPROC(B:BOOLEAN);
  BEGIN END;
{* BEEPER **********************************************}
  PROCEDURE BEEP;
  BEGIN CALL(BEEPERHOOK,BFREQUENCY,BDURATION);
  END;
  PROCEDURE BEEPER(FREQUENCY,DURATION:BYTE);
  BEGIN CALL(BEEPERHOOK,FREQUENCY,DURATION);
  END;

{* RPG *************************************************}
  PROCEDURE SETRPGRATE(RATE:BYTE);
  VAR   IRATE : BYTE;
  BEGIN
    IRATE := RATE; CALL(RPGREQHOOK,SET_RPG_RATE,IRATE);
  END;

{* KEYBOARD ********************************************}
  PROCEDURE KBDSETUP(CMD,VALUE :BYTE);
  VAR IVALUE : BYTE;
  BEGIN IVALUE := VALUE; CALL(KBDREQHOOK,CMD,IVALUE);
  END;
  PROCEDURE KBDIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		  ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN CALL(KBDIOHOOK,FP,REQUEST,BUFFER,BUFSIZE,POSITION); END;

{* BATTERY *********************************************}
  PROCEDURE BATCOMMAND(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
  BEGIN CALL(BATCMDHOOK, CMD, NUMDATA, B1, B2, B3, B4, B5);
  END;
  FUNCTION  BATBYTERECEIVED:BYTE;
  VAR DATA : BYTE;
  BEGIN CALL(BATREADHOOK,DATA); BATBYTERECEIVED := DATA;
  END;

  PROCEDURE DUMMYBATCMD(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
  BEGIN END;
  PROCEDURE DUMMYBATREAD(VAR DATA:BYTE);
  BEGIN END;

{* CLOCK ***********************************************}
  PROCEDURE DUMMYCLOCKSYS(VAR STIME:INTEGER);
  BEGIN END;
  PROCEDURE DUMMYCLOCKREQ(CMD:CLOCKFUNC; ANYVAR DATA:CLOCKDATA);
  BEGIN END;
  PROCEDURE DUMMYCLOCKIO(CMD:CLOCKOP  ; VAR DATA:RTCTIME);
  BEGIN END;
  function sysclock:integer;
  var ltime: rtctime;
  begin
    CALL(CLOCKIOHOOK,CGET,LTIME); sysclock := ltime.packedtime;
  end;

  procedure sysdate (var thedate: daterec);
  BEGIN CALL(CLOCKREQHOOK,CGETDATE,THEDATE);
  END;
  procedure systime (var thetime: timerec);
  BEGIN CALL(CLOCKREQHOOK,CGETTIME,THETIME);
  END;
  procedure setsysdate ( thedate: daterec);
  VAR D:DATEREC;
  BEGIN D:=THEDATE; CALL(CLOCKREQHOOK,CSETDATE,D);
  END;
  procedure setsystime ( thetime: timerec);
  VAR T:TIMEREC;
  BEGIN T:=THETIME; CALL(CLOCKREQHOOK,CSETTIME,T);
  END;
  PROCEDURE DUMMYTIMERIO(TIMER: TIMERTYPES;OP: TIMEROPTYPE;VAR TD: TIMERDATA);
  BEGIN IF OP=READT THEN TD.COUNT:=-1
	ELSE
	IF OP=GETTINFO THEN TD.RESOLUTION:=0;
  END;

{******************* NEW FOR 3.2 ******************************************}

  procedure settimezone(tz: integer);
  var ltime: timerec;
      ldate: daterec;
      negative: boolean;
  begin
   if tz<0 then begin {Awful kludge for tz<0}
     tz:=-tz;
     negative:=true;
   end
   else
     negative:=false;
   secs_to_timedate(tz, ldate, ltime);
   if negative then ltime.centisecond:=ltime.centisecond+1;
   call(clockreqhook, csetzone, ltime);
  end;

  function sysgmttime: integer;
  var ltime: rtctime;
  begin
    ltime.packedtime:=0;
    ltime.packeddate:=0;
    call (clockiohook, cget, ltime);
    with ltime do
      sysgmttime:=packeddate*86400+(packedtime+50) div 100
		  +timezone;
  end;


(*************************************************************
*
*  secs_to_timedate: Convert a time in seconds from Jan 1, 1970
*                   to PWS time and date records.
*
*  Assumes that time is > 0.
*
**************************************************************)

procedure secs_to_timedate(secs:integer;
			   var date:daterec; var time:timerec);

type
  day_month = array[0..12] of integer;
const
  day_tab = day_month[0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];


var hms: integer;
    days: integer;
    daysinmonth: integer;
    daysinyear: integer;
    done: boolean;

begin
with time,date do begin
  hms:= secs mod 86400;
  days:= secs div 86400;

  {Generate the year from date number}
  {RDQ 14MAR88 recoded the loop to correct
       1 JAN  two years after leap year bug
       and to isleap function }
  year:=70;
  daysinyear := 365+isleap(year);
  while days>=daysinyear do
  begin
    days:=days-daysinyear;
    year:=year+1;
    daysinyear := 365+isleap(year);
  end;

  {LAF 880101 proper range is now 0..127}
  {year:=year mod 100; {get it into proper range}

  {Generate month from remaining days}
  {RDQ recoded to use isleap function}
  month:=0;
  done:=false;
  repeat
    daysinmonth:=day_tab[month];
    if (month=2) then daysinmonth:=daysinmonth+isleap(year);
    if days>= daysinmonth then
    begin
      days:=days-daysinmonth;
      month:=month+1
    end
    else done:=true;
  until done;

  {days is now offset into month}
  day:=days+1;

  {Now convert hms in seconds to hh:mm:centisecs}

  hour:=hms div 3600;
  minute:=(hms-hour*3600) div 60;
  centisecond:=(hms mod 60)*100;

end; {of with}
end; {of procedure}

(****************************************************************************)
(* This routine transfers the 'date' + 'time' values into seconds since     *)
(* 00:00:00 , January 1 1970                                                *)
(****************************************************************************)
{RDQ 14MAR88 isleap now exported}
function isleap(y: integer): integer;
begin
  if (y mod 4 = 0) then isleap := 1
		    else isleap := 0;
end;


function timedate_to_secs(date : daterec; time : timerec) : integer;

type
  day_month = array [0..12] of integer;
  table = array[0..1] of day_month;
const
  day_tab = table[ day_month[0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
		   day_month[0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]];
var ttime :integer;
    i : integer;

begin
  timedate_to_secs:= 0;
  ttime := 0;
  if ( date.month <> 0 ) and ( date.year >= 70 ) then
  begin
    for i:=70 to (date.year-1) do
    begin
      ttime := ttime + 365*24*3600 + isleap(i)*24*3600;
    end;
    for i:=1 to (date.month-1) do
    begin
      ttime := ttime + day_tab[isleap(date.year)][i]*24*3600;
    end;
    ttime := ttime + (date.day-1)*24*3600;
    ttime := ttime + time.hour*3600+time.minute*60
		    +((time.centisecond +50) DIV 100);
  end;
  timedate_to_secs:= ttime;
end; {function}


{******************* end of new 3.2 clock procedures *****************}


{* CRT *************************************************}
  PROCEDURE CRTIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		  ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN CALL(CRTIOHOOK,FP,REQUEST,BUFFER,BUFSIZE,POSITION); END;
  PROCEDURE DUMMYCRTLL(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
  BEGIN END;
  PROCEDURE DUMMYDBCRT(OP:DBCRTOPS; VAR DBCRT:DBCINFO);
  BEGIN END;

  procedure lockedaction(a: action);
  label 1;
  var i: integer;
  begin
   if locklevel = 0 then call(a)
   else
   begin
     i := actionspending;
     while i>0 do if deferredaction[i]=a then goto 1 else i := i - 1;
     if actionspending = 10 then beep
     else
     begin
       actionspending := actionspending + 1;
       deferredaction[actionspending] := a;
     end;
   end;
  1:
  end;

{* KEYBUFFER *******************************************}
  PROCEDURE KEYBUFOPS(OP:KOPTYPE; VAR C: CHAR);
  VAR
    POSITION,TEMP1 : INTEGER;

    PROCEDURE ADVANCE(VAR P:INTEGER);
    BEGIN P:=(P+1) MOD KEYBUFFER^.MAXSIZE; END;

    PROCEDURE BACKUP(VAR P:INTEGER);
    BEGIN IF P=0 THEN P:=KEYBUFFER^.MAXSIZE-1 ELSE P:=P-1;
    END;

  BEGIN { KEYBUFOPS }
    WITH KEYBUFFER^ DO
    CASE OP OF
    KGETCHAR:
      BEGIN     { MUST NOT CALL IF SIZE=0 }
	IF ECHO THEN CALL(CRTLLHOOK,CLLSHIFTL,POSITION,' ');
	C:=BUFFER^[OUTP]; SIZE:=SIZE-1; ADVANCE(OUTP);
      END;
    KAPPEND,KNONADVANCE:
      BEGIN     { MUST NOT CALL IF SIZE>=MAXSIZE }
	IF ECHO THEN CALL(CRTLLHOOK,CLLPUT,SIZE,C);
	IF OP=KAPPEND THEN
	BEGIN
	  SIZE:=SIZE+1; BUFFER^[INP]:=C ;ADVANCE(INP); NON_CHAR:=' ';
	END
	ELSE NON_CHAR:=C;
      END;
    KCLEAR:
      BEGIN
	IF ECHO THEN CALL(CRTLLHOOK,CLLCLEAR,POSITION,' ');
	SIZE:=0; INP:=OUTP; NON_CHAR:=' ';
      END;
    KDISPLAY:
      IF ECHO THEN
      BEGIN
	CALL(CRTLLHOOK,CLLCLEAR,POSITION,' ');
	POSITION:= 0; TEMP1:=OUTP;
	WHILE POSITION<SIZE DO
	BEGIN
	  CALL(CRTLLHOOK,CLLPUT,POSITION,BUFFER^[TEMP1]);
	  ADVANCE(TEMP1); POSITION:=POSITION+1;
	END;
	IF NON_CHAR<>' ' THEN
	  CALL(CRTLLHOOK,CLLPUT,POSITION,NON_CHAR);
      END;
    KGETLAST:
      BEGIN
	IF ECHO AND (NON_CHAR<>' ') THEN CALL(CRTLLHOOK,CLLPUT,SIZE,' ');
	IF SIZE>0 THEN
	BEGIN
	  BACKUP(INP); C:=BUFFER^[INP]; SIZE:=SIZE-1; NON_CHAR:=' ';
	  IF ECHO THEN CALL(CRTLLHOOK,CLLPUT,SIZE,' ');
	END;
      END;
    KPUTFIRST:
      BEGIN     { CALL ONLY IF SIZE<=MAXSIZE }
	IF ECHO THEN
	BEGIN
	  POSITION:=0;
	  CALL(CRTLLHOOK,CLLSHIFTR,POSITION,' ');
	  CALL(CRTLLHOOK,CLLPUT,POSITION,C);
	END;
	BACKUP(OUTP); BUFFER^[OUTP]:=C; SIZE:=SIZE+1;
      END;
    END; { CASE }
  END; { KEYBUFOPS }

  PROCEDURE SETSTATUS(N:INTEGER; C:CHAR);
  VAR C1:CHAR;
  BEGIN STATUSLINE[N]:=C; C1:=C; CALL(CRTLLHOOK,PUTSTATUS,N,C1);
  END;
  FUNCTION  RUNLIGHT:CHAR;
  BEGIN RUNLIGHT:=STATUSLINE[7];
  END;
  PROCEDURE SETRUNLIGHT(C:CHAR);
  BEGIN SETSTATUS(7,C);
  END;

{* HPHIL ***********************************************}
{DUMMY ADDED 4/6/84 SFB}
  PROCEDURE DUMMYHPHILCMD(OP : HPHILOP);
  BEGIN  END;

{* INITIALIZE ALL HOOKS *****************************************************}
  PROCEDURE SYSDEV_INIT;
  VAR I : SHORTINT;
  BEGIN {SYSDEV_INIT}
    MASKOPSHOOK:= DUMMYOUT2;
    BEEPERHOOK := DUMMYOUT2;

    RPGREQHOOK := DUMMYREQ1;
    RPGISRHOOK := DUMMYKBD;

    BATREADHOOK:= DUMMYBATREAD;
    BATCMDHOOK := DUMMYBATCMD;

    CLOCKREQHOOK := DUMMYCLOCKREQ;
    CLOCKIOHOOK  := DUMMYCLOCKIO;
    TIMERIOHOOK  := DUMMYTIMERIO;
    TIMERISRHOOK := DUMMYKBD;

    KBDREQHOOK := DUMMYREQ1;
    KBDISRHOOK := DUMMYKBD;
    KBDTYPE    := NOKBD;
    KBDLANG    := NO_KBD;
    KBDIOHOOK  := DUMMYTM;
    KBDPOLLHOOK:= DUMMYBOOLPROC;
    MENUSTATE  := M_NONE;

    TOGGLEALPHAHOOK       := DUMMYPROC;
    TOGGLEGRAPHICSHOOK    := DUMMYPROC;
    DUMPALPHAHOOK         := DUMMYPROC;
    DUMPGRAPHICSHOOK      := DUMMYPROC;
    UPDATECURSORHOOK      := DUMMYPROC;
    CRTINITHOOK           := DUMMYPROC;
    CRTIOHOOK  := DUMMYTM;
    CRTLLHOOK  := DUMMYCRTLL;
    DBCRTHOOK  := DUMMYDBCRT;
    CURRENTCRT            := NOCRT;
    NEW(SYSCOM);

    NEW(KEYBUFFER);
    WITH KEYBUFFER^ DO
    BEGIN
      NEW(BUFFER);
      ECHO      :=TRUE;
      MAXSIZE   :=KMAXBUFSIZE;
      INP:=0; OUTP:=0; SIZE:=0;
      NON_CHAR  :=' ';
    END;

    FOR I:=0 TO 7 DO STATUSLINE[I]:=' ';
    KBDWAITHOOK    := DUMMYPROC;
    KBDRELEASEHOOK := DUMMYPROC;

    FOR I:=0 TO 1 DO LANGTABLE[I]:=NIL;
    LANGINDEX:=0;
    KBDSYSMODE:=TRUE; KBDALTLOCK:=FALSE; KBDCAPSLOCK:=FALSE;
    KBDTRANSHOOK := DUMMYKBD; TRANSMODE :=KPASSTHRU;

    HPHILCMDHOOK   := DUMMYHPHILCMD;    {4/6/84 SFB}
    LOOPCONTROL    := NIL;              {4/9/84 SFB}
    LOOPDRIVERLIST := NIL;              {4/9/84 SFB}

    HPHIL_DATA_LINK := NIL;              {3/13/85 SFB}

    TIMEZONE:=0;                         { 4/17/86 JWS}

  END; {SYSDEV_INIT}

END; {MODULE}

IMPORT SYSDEVS;
BEGIN
  SYSDEV_INIT;
  {MARKUSER}
END. {PROGRAM}
@


56.2
log
@
pws2rcs automatic delta on Wed Jan 27 11:57:27 MST 1993
@
text
@d1 892
@


56.1
log
@Automatic bump of revision number for PWS version 3.25
@
text
@a0 892
(*

 (c) Copyright Hewlett-Packard Company, 1986.
All rights are reserved.  Copying or other
reproduction of this program except for archival
purposes is prohibited without the prior
written consent of Hewlett-Packard Company.


	    RESTRICTED RIGHTS LEGEND

Use, duplication, or disclosure by the Government
is subject to restrictions as set forth in
paragraph (b) (3) (B) of the Rights in Technical
Data and Computer Software clause in
DAR 7-104.9(a).

HEWLETT-PACKARD COMPANY
Fort Collins, Colorado                         *)

$SYSPROG$
$heap_dispose off$
$iocheck off$
$range off$ $ovflcheck off$
$debug off$
$stackcheck off$

PROGRAM SYSDEVICES;
MODULE SYSDEVS;

$SEARCH 'INITLOAD'$


IMPORT SYSGLOBALS;
EXPORT
 {* DUMMY DECLARATIONS **********************************}
 TYPE
   KBDHOOKTYPE  = PROCEDURE(VAR STATBYTE,DATABYTE: BYTE;
			    VAR DOIT: BOOLEAN);
   OUT2TYPE     = PROCEDURE(VALUE1,VALUE2: BYTE);
   REQUEST1TYPE = PROCEDURE(CMD: BYTE; VAR VALUE: BYTE);
   BOOLPROC     = PROCEDURE(B:BOOLEAN);

{* CRT *************************************************}
{***** THIS SECTION HAS HARD OFFSET REFERENCES *********}
{      IN MODULES CRTB (ASSY FILE GASSM)                }
TYPE
  CRTWORD = RECORD CASE INTEGER OF
	    1:(HIGHLIGHTBYTE,CHARACTER: CHAR);
	    2:(WHOLEWORD: SHORTINT);
	    END;
  CRTLLOPS =(CLLPUT,CLLSHIFTL,CLLSHIFTR,CLLCLEAR,CLLDISPLAY,PUTSTATUS);
  CRTLLTYPE=PROCEDURE(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
  DBCRTOPS =(DBINFO,DBEXCG,DBGOTOXY,DBPUT,DBINIT,DBCLEAR,DBCLINE,DBSCROLLUP,
	     DBSCROLLDN,DBSCROLLL,DBSCROLLR,DBHIGHL);
  DBCINFO  = RECORD
	       SAVEAREA : WINDOWP;
	       SAVESIZE : INTEGER;
	       DCURSORADDR : INTEGER;
	       XMIN,XMAX,YMIN,YMAX : SHORTINT;
	       CURSX,CURSY         : SHORTINT;
	       C : CHAR;
	       AREAISDBCRT : BOOLEAN;
	       CHARISMAPPED: BOOLEAN; { 3/25/85 }
	       DEBUGHIGHLIGHT: SHORTINT;  { 3/25/85 }
	     END;
  DBCRTTYPE=PROCEDURE(OP:DBCRTOPS; VAR DBCRT:DBCINFO);

  crtconsttype = packed array [0..11] of byte;

  crtfrec = packed record
	       nobreak,stupid,slowterm,hasxycrt,
	       haslccrt{built in crt},hasclock,
	       canupscroll,candownscroll      :    boolean;
	     end;

  b9 = packed array[0..8] of boolean;
  b14= packed array[0..13] of boolean;
  crtcrec = packed record                               (* CRT CONTROL CHARS *)
	       rlf,ndfs,eraseeol,
	       eraseeos,home,
	       escape             : char;
	       backspace          : char;
	       fillcount          : 0..255;
	       clearscreen,
	       clearline          : char;
	       prefixed           : b9
	    end;

  crtirec = packed record                          (* CRT INFO & INPUT CHARS *)
	       width,height      : shortint;
	       crtmemaddr,crtcontroladdr,
	       keybufferaddr,progstateinfoaddr:integer;
	       keybuffersize: shortint;
	       crtcon            : crtconsttype;
	       right,left,down,up: char;
	       badch,chardel,stop,
	       break,flush,eof   : char;
	       altmode,linedel   : char;
	       backspace,
	       etx,prefix        : char;
	       prefixed          : b14 ;
	       cursormask        : integer;
	       spare             : integer;
	    end;

  environ = record
	      miscinfo: crtfrec;
	      crttype: integer;
	      crtctrl: crtcrec;
	      crtinfo: crtirec;
	    end;

  environptr    = ^environ;

  crtkinds = (NOCRT, ALPHATYPE, BITMAPTYPE, SPECIALCRT1, SPECIALCRT2);

  dumpstyle = 0..255;

VAR
  SYSCOM: ENVIRONPTR;
  ALPHASTATE['ALPHAFLAG']       : BOOLEAN;
  GRAPHICSTATE['GRAPHICSFLAG']  : BOOLEAN;
  CRTIOHOOK             : AMTYPE;
  TOGGLEALPHAHOOK       : PROCEDURE;
  TOGGLEGRAPHICSHOOK    : PROCEDURE;
  DUMPALPHAHOOK         : PROCEDURE;
  DUMPGRAPHICSHOOK      : PROCEDURE;
  UPDATECURSORHOOK      : PROCEDURE;
  CRTINITHOOK           : PROCEDURE;
  CRTLLHOOK             : CRTLLTYPE;
  DBCRTHOOK             : DBCRTTYPE;
  XPOS                  : SHORTINT; { CURSOR X POSITION }
  YPOS                  : SHORTINT; { CURSOR Y POSITION }
  CURRENTCRT            : CRTKINDS; { ACTIVE ALPHA DRIVER TYPE }
  BITMAPADDR            : INTEGER;  { ADDRESS OF BITMAP CONTROL SPACE }
  FRAMEADDR             : INTEGER;  { ADDRESS OF BITMAP FRAME BUFFER }
  REPLREGCOPY           : SHORTINT; { REGISTER COPIES FOR BITMAP DISPLAY }
  WINDOWREGCOPY         : SHORTINT; { MUST BE IN GLOBALS BECAUSE REGISTERS }
  WRITEREGCOPY          : SHORTINT; { ARE NOT READABLE -- MAY BE UNDEFINED }

 {* KEYBOARD *******************************************}
 CONST
   KBD_ENABLE     = 0; KBD_DISABLE    = 1;
   SET_AUTO_DELAY = 2; SET_AUTO_REPEAT= 3;
   GET_AUTO_DELAY = 4; GET_AUTO_REPEAT= 5;
   SET_KBDTYPE    = 6; SET_KBDLANG    = 7;
 TYPE
   STRING80PTR = ^STRING80;
   KEYBOARDTYPE = (NOKBD,LARGEKBD,SMALLKBD,ITFKBD,SPECIALKBD1,SPECIALKBD2);
   LANGTYPE = (NO_KBD,FINISH_KBD,BELGIAN_KBD,CDN_ENG_KBD,CDN_FR_KBD,
	       NORWEGIAN_KBD,DANISH_KBD,DUTCH_KBD,SWISS_GR_KBD,SWISS_FR_KBD,
	       SPANISH_EUR_KBD,SPANISH_LATIN_KBD,UK_KBD,ITALIAN_KBD,
	       FRENCH_KBD,GERMAN_KBD,SWEDISH_KBD,SPANISH_KBD,
	       KATAKANA_KBD,US_KBD,ROMAN8_KBD,NS1_KBD,NS2_KBD,NS3_KBD,
	       SWISS_GR_B_KBD,SWISS_FR_B_KBD {ADDED FOR 3.1--SFB-5/22/85} );
   MENUTYPE = (M_NONE,M_SYSNORM,M_SYSSHIFT,M_U1,M_U2,M_U3,M_U4);
 VAR
   KBDREQHOOK   : REQUEST1TYPE;
   KBDIOHOOK    : AMTYPE;
   KBDISRHOOK   : KBDHOOKTYPE;
   KBDPOLLHOOK  : BOOLPROC;
   KBDTYPE      : KEYBOARDTYPE;
   KBDCONFIG    : BYTE;         { KEYBOARD CONFIGURATION JUMPER }
   KBDLANG      : LANGTYPE;
   SYSMENU      : STRING80PTR;
   SYSMENUSHIFT : STRING80PTR;
   MENUSTATE    : MENUTYPE;

{* ENABLE / DISABLE ************************************}
 CONST
   KBDMASK=1;RESETMASK=2;TIMERMASK=4;PSIMASK=8;FHIMASK=16;
 VAR
   MASKOPSHOOK : OUT2TYPE; { ENABLE, DISABLE }

{* BEEPER **********************************************}
 VAR
   BEEPERHOOK: OUT2TYPE;
   BFREQUENCY, BDURATION: BYTE;

{* RPG *************************************************}
 CONST
   RPG_ENABLE   = 0; RPG_DISABLE = 1;
   SET_RPG_RATE = 2; GET_RPG_RATE =3;
 VAR
   RPGREQHOOK: REQUEST1TYPE;
   RPGISRHOOK: KBDHOOKTYPE;

{* BATTERY *********************************************}
TYPE
  BATCMDTYPE = PROCEDURE(CMD: BYTE; NUMDATA: INTEGER;
			 B1, B2, B3, B4, B5: BYTE);
  BATREADTYPE= PROCEDURE(VAR DATA: BYTE);
VAR
  BATTERYPRESENT[-563]: BOOLEAN;
  BATCMDHOOK : BATCMDTYPE;
  BATREADHOOK: BATREADTYPE;

{* CLOCK ***********************************************}
TYPE
  RTCTIME = PACKED RECORD
	       PACKEDTIME,PACKEDDATE:INTEGER;
	    END;
  CLOCKFUNC = (CGETDATE,CGETTIME,CSETDATE,CSETTIME,CSETZONE);
	      {CSETZONE ADDED BY JWS 4/17/86}

  CLOCKOP   = (CGET,CSET,CUPDATE,CTZ);   {CUPDATE ADDED FOR BOBCAT 4/11/85 SFB}
					 {CTZ ADDED 4/17/86 JWS}
  CLOCKDATA = RECORD
		CASE BOOLEAN OF
		TRUE :(TIMETYPE:TIMEREC);
		FALSE:(DATETYPE:DATEREC);
	      END;
  CLOCKREQTYPE = PROCEDURE(CMD:CLOCKFUNC; ANYVAR DATA:CLOCKDATA);
  CLOCKIOTYPE  = PROCEDURE(CMD:CLOCKOP  ; VAR DATA:RTCTIME);
VAR
  CLOCKREQHOOK : CLOCKREQTYPE;  { CLOCK MODULE INTERFACE }
  CLOCKIOHOOK  : CLOCKIOTYPE;   { CARD DRIVER INTERFACE }

{* TIMER ***********************************************}
TYPE
  TIMERTYPES = (CYCLICT,PERIODICT,DELAYT,DELAY7T,MATCHT);
  TIMEROPTYPE = (SETT,READT,GETTINFO);
  TIMERDATA = RECORD
	       CASE INTEGER OF
	       0: (COUNT: INTEGER);
	       1: (MATCH: TIMEREC);
	       2: (RESOLUTION,RANGE:INTEGER);
	       END;
  TIMERIOTYPE = PROCEDURE(TIMER: TIMERTYPES;OP: TIMEROPTYPE;VAR TD: TIMERDATA);
VAR
  TIMERIOHOOK  : TIMERIOTYPE;
  TIMERISRHOOK : KBDHOOKTYPE;


{* KEYBUFFER *******************************************}
CONST
  KMAXBUFSIZE = 255;
TYPE

  KOPTYPE = (KGETCHAR,KAPPEND,KNONADVANCE,KCLEAR,KDISPLAY,
	     KGETLAST,KPUTFIRST);
  KBUFTYPE= PACKED ARRAY[0..KMAXBUFSIZE] OF CHAR;
  KBUFPTR = ^KBUFTYPE;
  KBUFRECPTR = ^KBUFREC;
  KBUFREC = RECORD
	      ECHO: BOOLEAN;
	      NON_CHAR: CHAR;
	      MAXSIZE,SIZE,INP,OUTP: INTEGER;
	      BUFFER: KBUFPTR;
	    END;

VAR
  KEYBUFFER : KBUFRECPTR;
  KBDWAITHOOK: PROCEDURE;
  KBDRELEASEHOOK: PROCEDURE;
  STATUSLINE: PACKED ARRAY[0..7] OF CHAR;
  {0  s or f = STEP/FLASH IN PROGRESS (WAITING FOR TRAP #0)}
  {1..5  last executed/current line number }
  {6  S=SYSTEM  U=USER  DEFINITION FOR ITF SOFT KEYS}
  {   BLANK FOR NON ITF KEYBOARDS }
  {7  RUNLIGHT }

{* KEY TRANSLATION SERVICES ********************************}
TYPE
  KEYTRANSTYPE =(KPASSTHRU,KSHIFT_EXTC,KPASS_EXTC);
  KEYTYPE = (ALPHA_KEY,NONADV_KEY,SPECIAL_KEY,IGNORED_KEY,NONA_ALPHA_KEY);
  { ADDED NONA_ALPHA_KEY 5/9/84 RQ/SFB }

  LANGCOMREC = RECORD
		 STATUS : BYTE;
		 DATA   : BYTE;
		 KEY    : CHAR;
		 RESULT : KEYTYPE;
		 SHIFT,CONTROL,EXTENSION: BOOLEAN;
	       END;
  LANGKEYREC = RECORD
		 NO_CAPSLOCK: BOOLEAN;
		 NO_SHIFT   : BOOLEAN;
		 NO_CONTROL : BOOLEAN;
		 NO_EXTENSION : BOOLEAN;
		 KEYCLASS   : KEYTYPE;
		 KEYS : ARRAY[BOOLEAN] OF CHAR;
	       END;
  LANGRECORD= RECORD
		CAN_NONADV: BOOLEAN;
		LANGCODE  : LANGTYPE;
		SEMANTICS : PROCEDURE;
		KEYTABLE  : ARRAY[0..127] OF LANGKEYREC;
	      END;
  LANGPTR   = ^LANGRECORD;
VAR
  LANGCOM   : LANGCOMREC;
  LANGTABLE : ARRAY[0..1] OF LANGPTR;
  LANGINDEX : 0..1;
  KBDTRANSHOOK : KBDHOOKTYPE;
  TRANSMODE : KEYTRANSTYPE;
  KBDSYSMODE, KBDALTLOCK, KBDCAPSLOCK : BOOLEAN;

{* HPHIL ***********************************************}
{MOVED INTO SYSDEVS 4/6/84 SFB}
const
  le_configured = hex('80');
  le_error      = hex('81');
  le_timeout    = hex('82');
  le_loopdown   = hex('84');

  lmaxdevices   = 7;

type
  loopdvrop   = (datastarting,dataended,resetdevice,uninitdevice);
		 {UNINIT ADDED 4/8/85 SFB}
  loopdvrproc = procedure(op:loopdvrop);

  {HPHILOP DEFINED AS NEW TYPE 4/6/84 SFB}
  HPHILOP      = (RAWSHIFTOP,NORMSHIFTOP,CHECKLOOPOP,CONFIGUREOP,LCOMMANDOP);
  {5 PROCEDURES HOOKED AS TYPE HPHILCMDPROC 4/6/84 SFB}
  HPHILCMDPROC = PROCEDURE(OP : HPHILOP);


  descriprec = packed record    { DEVICE DESCRIBE RECORD }
		 case boolean of
		 true :(id       : byte;
			twosets  : boolean;
			abscoords: boolean;
			size16   : boolean;
			hasprompts:boolean;
		      { reserved : 0..3;        {DELETED 3/25/85 SFB}
			ext_desc : boolean;     {3/27/85 SFB}
			security : boolean;     {3/26/85 SFB}
			numaxes  : 0..3;
			counts   : shortint;
			maxcountx: shortint;
			maxcounty: shortint;
			maxcountz: shortint;
			promptack: boolean;     {ADDED 3/15/85 SFB}
			nprompts : 0..7;
			proximity: boolean;     {ADDED 3/15/85 SFB}
			nbuttons : 0..7);
		 false:(darray : array[1..11] of char);
	       end;

  devicerec = record
		devstate : integer;
		descrip : descriprec;
		opsproc  : loopdvrproc;
		dataproc : kbdhooktype;
	      end;

  loopdvrptr = ^loopdriverrec;
  loopdriverrec = record
		    lowid,highid,daddr : byte;
		    opsproc  : loopdvrproc;
		    dataproc : kbdhooktype;
		    next     : loopdvrptr;
		  end;

  LOOPCONTROLREC = RECORD                   {REDEFINED AS RECORD - 4/6/84 SFB}
	rawmode : boolean;
	loopdevices : array[1..lmaxdevices] of devicerec;
	loopdevice : 1..lmaxdevices;
	loopcmd    : byte;    { last loop command sent }
	loopdata   : byte;    { data bye in / out }
	looperror  : boolean; { error occured on last operation }
	loopinconfig:boolean; { now doing reconfigure }
	loopcmddone: boolean; { last sent command is done }
	loopisok   : boolean; { loop is configured }
	loopdevreading: boolean; { reading poll data }  { 3.0 BUG #39 3/17/84 }
  END;

  CONST                         {NEW TO END OF HPHIL_COMM_REC TYPE 3/26/85 SFB}


  {DRIVER TYPES}
  NODRIVER   =  0;
  ABSLOCATOR =  1;        {range 1..15 reserved for DGL}
  RELLOCATOR =  2;


  {CODETYPES FROM POLLBLOCK (OR OTHER HPHIL OPCODE)}
  NOCODES       = 0;
  ASCIICODES    = 1;
  SET1CODES     = 2;
  SET2CODES     = 3;

  TYPE

  HPHIL_COMM_REC_PTR_TYPE = ^hphil_comm_rec_type;  {3/25/85 SFB}

  HPHIL_COMM_REC_TYPE = RECORD CASE BOOLEAN OF              {3/25/85 SFB}
   TRUE :
	 (dvr_type        : shortint;
	  dev_addr        : 0..7;
	  latch,                  {stop updating data after button press/event}
	  active,                 {capture data in ISR}
	  reading         : boolean;  {dvr_comm_rec busy, delay update from ISR}
	  devices         : byte; {bit/loopaddress that driver should service
				   put 0 where driver should NOT service device
				   with this dvr_comm_rec !}
	  update          : procedure(recptr : hphil_comm_rec_ptr_type);
				  {call update to flush delayed poll data update}
	  link            : hphil_comm_rec_ptr_type;  {next comm record}
	  extend          : integer; {for extensibility use as pointer/datarec}

	  xloc,                   {HPHIL intrinsic data types from poll/command}
	  yloc,
	  zloc            : shortint;
	  codetype        : shortint;     {describes content of codes}
	  ncodes          : shortint;
	  codes           : packed array [1..16] of char
			       {extensible for variant} );
   FALSE:
	 (barray          : array[0..53] of char);
  END;

var

  loopdriverlist : loopdvrptr;
  LOOPCONTROL    : ^LOOPCONTROLREC;     {4/6/84 SFB}
  HPHILCMDHOOK   : HPHILCMDPROC;        {4/6/84 SFB}

  HPHIL_DATA_LINK : hphil_comm_rec_ptr_type;  {3/13/85 SFB}
  HIL_PRESENT:      BOOLEAN;             {8/28/86 JWS}

  TIMEZONE: INTEGER; {LOCAL + TIMEZONE = GMT} { JWS 4/17/86 }

  alphadumpstyle   : dumpstyle;
  graphicsdumpstyle: dumpstyle;


{-----------------------------------------------------------------------------}
PROCEDURE SYSDEV_INIT;
{* BEEPER **********************************************}
PROCEDURE BEEP;
PROCEDURE BEEPER(FREQUENCY,DURATION:BYTE);
{* RPG *************************************************}
PROCEDURE SETRPGRATE(RATE : BYTE);
{* KEYBOARD ********************************************}
PROCEDURE KBDSETUP(CMD,VALUE:BYTE);
PROCEDURE KBDIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
procedure lockedaction(a: action);
{* CRT *************************************************}
PROCEDURE CRTIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
PROCEDURE DUMMYCRTLL(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
{* BATTERY *********************************************}
PROCEDURE BATCOMMAND(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
FUNCTION  BATBYTERECEIVED:BYTE;
{* CLOCK ***********************************************}
function  sysclock: integer;   {centiseconds from midnight}
procedure sysdate (var thedate: daterec);
procedure systime (var thetime: timerec);
procedure setsysdate ( thedate: daterec);
procedure setsystime ( thetime: timerec);
function  sysgmttime: integer; {seconds from 1 Jan 1970 GMT}
procedure settimezone(tz: integer);
function isleap(y: integer): integer;
procedure secs_to_timedate(secs:integer;
			   var date:daterec; var time:timerec);
function timedate_to_secs(date : daterec; time : timerec) : integer;
{* KEYBUFFER *******************************************}
PROCEDURE KEYBUFOPS(OP:KOPTYPE; VAR C: CHAR);
{* STATUSLINE ******************************************}
PROCEDURE SETSTATUS(N:INTEGER; C:CHAR);
FUNCTION  RUNLIGHT:CHAR;
PROCEDURE SETRUNLIGHT(C:CHAR);

IMPLEMENT

{* GENERAL PURPOSE DUMMY PROCEDURES ********************}
  PROCEDURE DUMMYPROC;
  BEGIN END;
  PROCEDURE DUMMYOUT2(VALUE1, VALUE2 : BYTE);
  BEGIN END;
  PROCEDURE DUMMYKBD(VAR STATBYTE,DATABYTE : BYTE;
		     VAR DOIT:BOOLEAN);
  BEGIN END;
  PROCEDURE DUMMYREQ1(CMD : BYTE; VAR VALUE:BYTE);
  BEGIN END;
  PROCEDURE DUMMYTM(FP: FIBP; REQUEST: AMREQUESTTYPE;
		    ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN END;
  PROCEDURE DUMMYBOOLPROC(B:BOOLEAN);
  BEGIN END;
{* BEEPER **********************************************}
  PROCEDURE BEEP;
  BEGIN CALL(BEEPERHOOK,BFREQUENCY,BDURATION);
  END;
  PROCEDURE BEEPER(FREQUENCY,DURATION:BYTE);
  BEGIN CALL(BEEPERHOOK,FREQUENCY,DURATION);
  END;

{* RPG *************************************************}
  PROCEDURE SETRPGRATE(RATE:BYTE);
  VAR   IRATE : BYTE;
  BEGIN
    IRATE := RATE; CALL(RPGREQHOOK,SET_RPG_RATE,IRATE);
  END;

{* KEYBOARD ********************************************}
  PROCEDURE KBDSETUP(CMD,VALUE :BYTE);
  VAR IVALUE : BYTE;
  BEGIN IVALUE := VALUE; CALL(KBDREQHOOK,CMD,IVALUE);
  END;
  PROCEDURE KBDIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		  ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN CALL(KBDIOHOOK,FP,REQUEST,BUFFER,BUFSIZE,POSITION); END;

{* BATTERY *********************************************}
  PROCEDURE BATCOMMAND(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
  BEGIN CALL(BATCMDHOOK, CMD, NUMDATA, B1, B2, B3, B4, B5);
  END;
  FUNCTION  BATBYTERECEIVED:BYTE;
  VAR DATA : BYTE;
  BEGIN CALL(BATREADHOOK,DATA); BATBYTERECEIVED := DATA;
  END;

  PROCEDURE DUMMYBATCMD(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
  BEGIN END;
  PROCEDURE DUMMYBATREAD(VAR DATA:BYTE);
  BEGIN END;

{* CLOCK ***********************************************}
  PROCEDURE DUMMYCLOCKSYS(VAR STIME:INTEGER);
  BEGIN END;
  PROCEDURE DUMMYCLOCKREQ(CMD:CLOCKFUNC; ANYVAR DATA:CLOCKDATA);
  BEGIN END;
  PROCEDURE DUMMYCLOCKIO(CMD:CLOCKOP  ; VAR DATA:RTCTIME);
  BEGIN END;
  function sysclock:integer;
  var ltime: rtctime;
  begin
    CALL(CLOCKIOHOOK,CGET,LTIME); sysclock := ltime.packedtime;
  end;

  procedure sysdate (var thedate: daterec);
  BEGIN CALL(CLOCKREQHOOK,CGETDATE,THEDATE);
  END;
  procedure systime (var thetime: timerec);
  BEGIN CALL(CLOCKREQHOOK,CGETTIME,THETIME);
  END;
  procedure setsysdate ( thedate: daterec);
  VAR D:DATEREC;
  BEGIN D:=THEDATE; CALL(CLOCKREQHOOK,CSETDATE,D);
  END;
  procedure setsystime ( thetime: timerec);
  VAR T:TIMEREC;
  BEGIN T:=THETIME; CALL(CLOCKREQHOOK,CSETTIME,T);
  END;
  PROCEDURE DUMMYTIMERIO(TIMER: TIMERTYPES;OP: TIMEROPTYPE;VAR TD: TIMERDATA);
  BEGIN IF OP=READT THEN TD.COUNT:=-1
	ELSE
	IF OP=GETTINFO THEN TD.RESOLUTION:=0;
  END;

{******************* NEW FOR 3.2 ******************************************}

  procedure settimezone(tz: integer);
  var ltime: timerec;
      ldate: daterec;
      negative: boolean;
  begin
   if tz<0 then begin {Awful kludge for tz<0}
     tz:=-tz;
     negative:=true;
   end
   else
     negative:=false;
   secs_to_timedate(tz, ldate, ltime);
   if negative then ltime.centisecond:=ltime.centisecond+1;
   call(clockreqhook, csetzone, ltime);
  end;

  function sysgmttime: integer;
  var ltime: rtctime;
  begin
    ltime.packedtime:=0;
    ltime.packeddate:=0;
    call (clockiohook, cget, ltime);
    with ltime do
      sysgmttime:=packeddate*86400+(packedtime+50) div 100
		  +timezone;
  end;


(*************************************************************
*
*  secs_to_timedate: Convert a time in seconds from Jan 1, 1970
*                   to PWS time and date records.
*
*  Assumes that time is > 0.
*
**************************************************************)

procedure secs_to_timedate(secs:integer;
			   var date:daterec; var time:timerec);

type
  day_month = array[0..12] of integer;
const
  day_tab = day_month[0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];


var hms: integer;
    days: integer;
    daysinmonth: integer;
    daysinyear: integer;
    done: boolean;

begin
with time,date do begin
  hms:= secs mod 86400;
  days:= secs div 86400;

  {Generate the year from date number}
  {RDQ 14MAR88 recoded the loop to correct
       1 JAN  two years after leap year bug
       and to isleap function }
  year:=70;
  daysinyear := 365+isleap(year);
  while days>=daysinyear do
  begin
    days:=days-daysinyear;
    year:=year+1;
    daysinyear := 365+isleap(year);
  end;

  {LAF 880101 proper range is now 0..127}
  {year:=year mod 100; {get it into proper range}

  {Generate month from remaining days}
  {RDQ recoded to use isleap function}
  month:=0;
  done:=false;
  repeat
    daysinmonth:=day_tab[month];
    if (month=2) then daysinmonth:=daysinmonth+isleap(year);
    if days>= daysinmonth then
    begin
      days:=days-daysinmonth;
      month:=month+1
    end
    else done:=true;
  until done;

  {days is now offset into month}
  day:=days+1;

  {Now convert hms in seconds to hh:mm:centisecs}

  hour:=hms div 3600;
  minute:=(hms-hour*3600) div 60;
  centisecond:=(hms mod 60)*100;

end; {of with}
end; {of procedure}

(****************************************************************************)
(* This routine transfers the 'date' + 'time' values into seconds since     *)
(* 00:00:00 , January 1 1970                                                *)
(****************************************************************************)
{RDQ 14MAR88 isleap now exported}
function isleap(y: integer): integer;
begin
  if (y mod 4 = 0) then isleap := 1
		    else isleap := 0;
end;


function timedate_to_secs(date : daterec; time : timerec) : integer;

type
  day_month = array [0..12] of integer;
  table = array[0..1] of day_month;
const
  day_tab = table[ day_month[0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
		   day_month[0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]];
var ttime :integer;
    i : integer;

begin
  timedate_to_secs:= 0;
  ttime := 0;
  if ( date.month <> 0 ) and ( date.year >= 70 ) then
  begin
    for i:=70 to (date.year-1) do
    begin
      ttime := ttime + 365*24*3600 + isleap(i)*24*3600;
    end;
    for i:=1 to (date.month-1) do
    begin
      ttime := ttime + day_tab[isleap(date.year)][i]*24*3600;
    end;
    ttime := ttime + (date.day-1)*24*3600;
    ttime := ttime + time.hour*3600+time.minute*60
		    +((time.centisecond +50) DIV 100);
  end;
  timedate_to_secs:= ttime;
end; {function}


{******************* end of new 3.2 clock procedures *****************}


{* CRT *************************************************}
  PROCEDURE CRTIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		  ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN CALL(CRTIOHOOK,FP,REQUEST,BUFFER,BUFSIZE,POSITION); END;
  PROCEDURE DUMMYCRTLL(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
  BEGIN END;
  PROCEDURE DUMMYDBCRT(OP:DBCRTOPS; VAR DBCRT:DBCINFO);
  BEGIN END;

  procedure lockedaction(a: action);
  label 1;
  var i: integer;
  begin
   if locklevel = 0 then call(a)
   else
   begin
     i := actionspending;
     while i>0 do if deferredaction[i]=a then goto 1 else i := i - 1;
     if actionspending = 10 then beep
     else
     begin
       actionspending := actionspending + 1;
       deferredaction[actionspending] := a;
     end;
   end;
  1:
  end;

{* KEYBUFFER *******************************************}
  PROCEDURE KEYBUFOPS(OP:KOPTYPE; VAR C: CHAR);
  VAR
    POSITION,TEMP1 : INTEGER;

    PROCEDURE ADVANCE(VAR P:INTEGER);
    BEGIN P:=(P+1) MOD KEYBUFFER^.MAXSIZE; END;

    PROCEDURE BACKUP(VAR P:INTEGER);
    BEGIN IF P=0 THEN P:=KEYBUFFER^.MAXSIZE-1 ELSE P:=P-1;
    END;

  BEGIN { KEYBUFOPS }
    WITH KEYBUFFER^ DO
    CASE OP OF
    KGETCHAR:
      BEGIN     { MUST NOT CALL IF SIZE=0 }
	IF ECHO THEN CALL(CRTLLHOOK,CLLSHIFTL,POSITION,' ');
	C:=BUFFER^[OUTP]; SIZE:=SIZE-1; ADVANCE(OUTP);
      END;
    KAPPEND,KNONADVANCE:
      BEGIN     { MUST NOT CALL IF SIZE>=MAXSIZE }
	IF ECHO THEN CALL(CRTLLHOOK,CLLPUT,SIZE,C);
	IF OP=KAPPEND THEN
	BEGIN
	  SIZE:=SIZE+1; BUFFER^[INP]:=C ;ADVANCE(INP); NON_CHAR:=' ';
	END
	ELSE NON_CHAR:=C;
      END;
    KCLEAR:
      BEGIN
	IF ECHO THEN CALL(CRTLLHOOK,CLLCLEAR,POSITION,' ');
	SIZE:=0; INP:=OUTP; NON_CHAR:=' ';
      END;
    KDISPLAY:
      IF ECHO THEN
      BEGIN
	CALL(CRTLLHOOK,CLLCLEAR,POSITION,' ');
	POSITION:= 0; TEMP1:=OUTP;
	WHILE POSITION<SIZE DO
	BEGIN
	  CALL(CRTLLHOOK,CLLPUT,POSITION,BUFFER^[TEMP1]);
	  ADVANCE(TEMP1); POSITION:=POSITION+1;
	END;
	IF NON_CHAR<>' ' THEN
	  CALL(CRTLLHOOK,CLLPUT,POSITION,NON_CHAR);
      END;
    KGETLAST:
      BEGIN
	IF ECHO AND (NON_CHAR<>' ') THEN CALL(CRTLLHOOK,CLLPUT,SIZE,' ');
	IF SIZE>0 THEN
	BEGIN
	  BACKUP(INP); C:=BUFFER^[INP]; SIZE:=SIZE-1; NON_CHAR:=' ';
	  IF ECHO THEN CALL(CRTLLHOOK,CLLPUT,SIZE,' ');
	END;
      END;
    KPUTFIRST:
      BEGIN     { CALL ONLY IF SIZE<=MAXSIZE }
	IF ECHO THEN
	BEGIN
	  POSITION:=0;
	  CALL(CRTLLHOOK,CLLSHIFTR,POSITION,' ');
	  CALL(CRTLLHOOK,CLLPUT,POSITION,C);
	END;
	BACKUP(OUTP); BUFFER^[OUTP]:=C; SIZE:=SIZE+1;
      END;
    END; { CASE }
  END; { KEYBUFOPS }

  PROCEDURE SETSTATUS(N:INTEGER; C:CHAR);
  VAR C1:CHAR;
  BEGIN STATUSLINE[N]:=C; C1:=C; CALL(CRTLLHOOK,PUTSTATUS,N,C1);
  END;
  FUNCTION  RUNLIGHT:CHAR;
  BEGIN RUNLIGHT:=STATUSLINE[7];
  END;
  PROCEDURE SETRUNLIGHT(C:CHAR);
  BEGIN SETSTATUS(7,C);
  END;

{* HPHIL ***********************************************}
{DUMMY ADDED 4/6/84 SFB}
  PROCEDURE DUMMYHPHILCMD(OP : HPHILOP);
  BEGIN  END;

{* INITIALIZE ALL HOOKS *****************************************************}
  PROCEDURE SYSDEV_INIT;
  VAR I : SHORTINT;
  BEGIN {SYSDEV_INIT}
    MASKOPSHOOK:= DUMMYOUT2;
    BEEPERHOOK := DUMMYOUT2;

    RPGREQHOOK := DUMMYREQ1;
    RPGISRHOOK := DUMMYKBD;

    BATREADHOOK:= DUMMYBATREAD;
    BATCMDHOOK := DUMMYBATCMD;

    CLOCKREQHOOK := DUMMYCLOCKREQ;
    CLOCKIOHOOK  := DUMMYCLOCKIO;
    TIMERIOHOOK  := DUMMYTIMERIO;
    TIMERISRHOOK := DUMMYKBD;

    KBDREQHOOK := DUMMYREQ1;
    KBDISRHOOK := DUMMYKBD;
    KBDTYPE    := NOKBD;
    KBDLANG    := NO_KBD;
    KBDIOHOOK  := DUMMYTM;
    KBDPOLLHOOK:= DUMMYBOOLPROC;
    MENUSTATE  := M_NONE;

    TOGGLEALPHAHOOK       := DUMMYPROC;
    TOGGLEGRAPHICSHOOK    := DUMMYPROC;
    DUMPALPHAHOOK         := DUMMYPROC;
    DUMPGRAPHICSHOOK      := DUMMYPROC;
    UPDATECURSORHOOK      := DUMMYPROC;
    CRTINITHOOK           := DUMMYPROC;
    CRTIOHOOK  := DUMMYTM;
    CRTLLHOOK  := DUMMYCRTLL;
    DBCRTHOOK  := DUMMYDBCRT;
    CURRENTCRT            := NOCRT;
    NEW(SYSCOM);

    NEW(KEYBUFFER);
    WITH KEYBUFFER^ DO
    BEGIN
      NEW(BUFFER);
      ECHO      :=TRUE;
      MAXSIZE   :=KMAXBUFSIZE;
      INP:=0; OUTP:=0; SIZE:=0;
      NON_CHAR  :=' ';
    END;

    FOR I:=0 TO 7 DO STATUSLINE[I]:=' ';
    KBDWAITHOOK    := DUMMYPROC;
    KBDRELEASEHOOK := DUMMYPROC;

    FOR I:=0 TO 1 DO LANGTABLE[I]:=NIL;
    LANGINDEX:=0;
    KBDSYSMODE:=TRUE; KBDALTLOCK:=FALSE; KBDCAPSLOCK:=FALSE;
    KBDTRANSHOOK := DUMMYKBD; TRANSMODE :=KPASSTHRU;

    HPHILCMDHOOK   := DUMMYHPHILCMD;    {4/6/84 SFB}
    LOOPCONTROL    := NIL;              {4/9/84 SFB}
    LOOPDRIVERLIST := NIL;              {4/9/84 SFB}

    HPHIL_DATA_LINK := NIL;              {3/13/85 SFB}

    TIMEZONE:=0;                         { 4/17/86 JWS}

  END; {SYSDEV_INIT}

END; {MODULE}

IMPORT SYSDEVS;
BEGIN
  SYSDEV_INIT;
  {MARKUSER}
END. {PROGRAM}
@


55.1
log
@Automatic bump of revision number for PWS version 3.25A
@
text
@@


54.3
log
@
pws2rcs automatic delta on Wed Aug 21 10:27:27 MDT 1991
@
text
@@


54.2
log
@
pws2rcs automatic delta on Wed Aug 21 09:35:48 MDT 1991
@
text
@d1 892
@


54.1
log
@Automatic bump of revision number for PWS version 3.24
@
text
@a0 892
(*

 (c) Copyright Hewlett-Packard Company, 1986.
All rights are reserved.  Copying or other
reproduction of this program except for archival
purposes is prohibited without the prior
written consent of Hewlett-Packard Company.


	    RESTRICTED RIGHTS LEGEND

Use, duplication, or disclosure by the Government
is subject to restrictions as set forth in
paragraph (b) (3) (B) of the Rights in Technical
Data and Computer Software clause in
DAR 7-104.9(a).

HEWLETT-PACKARD COMPANY
Fort Collins, Colorado                         *)

$SYSPROG$
$heap_dispose off$
$iocheck off$
$range off$ $ovflcheck off$
$debug off$
$stackcheck off$

PROGRAM SYSDEVICES;
MODULE SYSDEVS;

$SEARCH 'INITLOAD'$


IMPORT SYSGLOBALS;
EXPORT
 {* DUMMY DECLARATIONS **********************************}
 TYPE
   KBDHOOKTYPE  = PROCEDURE(VAR STATBYTE,DATABYTE: BYTE;
			    VAR DOIT: BOOLEAN);
   OUT2TYPE     = PROCEDURE(VALUE1,VALUE2: BYTE);
   REQUEST1TYPE = PROCEDURE(CMD: BYTE; VAR VALUE: BYTE);
   BOOLPROC     = PROCEDURE(B:BOOLEAN);

{* CRT *************************************************}
{***** THIS SECTION HAS HARD OFFSET REFERENCES *********}
{      IN MODULES CRTB (ASSY FILE GASSM)                }
TYPE
  CRTWORD = RECORD CASE INTEGER OF
	    1:(HIGHLIGHTBYTE,CHARACTER: CHAR);
	    2:(WHOLEWORD: SHORTINT);
	    END;
  CRTLLOPS =(CLLPUT,CLLSHIFTL,CLLSHIFTR,CLLCLEAR,CLLDISPLAY,PUTSTATUS);
  CRTLLTYPE=PROCEDURE(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
  DBCRTOPS =(DBINFO,DBEXCG,DBGOTOXY,DBPUT,DBINIT,DBCLEAR,DBCLINE,DBSCROLLUP,
	     DBSCROLLDN,DBSCROLLL,DBSCROLLR,DBHIGHL);
  DBCINFO  = RECORD
	       SAVEAREA : WINDOWP;
	       SAVESIZE : INTEGER;
	       DCURSORADDR : INTEGER;
	       XMIN,XMAX,YMIN,YMAX : SHORTINT;
	       CURSX,CURSY         : SHORTINT;
	       C : CHAR;
	       AREAISDBCRT : BOOLEAN;
	       CHARISMAPPED: BOOLEAN; { 3/25/85 }
	       DEBUGHIGHLIGHT: SHORTINT;  { 3/25/85 }
	     END;
  DBCRTTYPE=PROCEDURE(OP:DBCRTOPS; VAR DBCRT:DBCINFO);

  crtconsttype = packed array [0..11] of byte;

  crtfrec = packed record
	       nobreak,stupid,slowterm,hasxycrt,
	       haslccrt{built in crt},hasclock,
	       canupscroll,candownscroll      :    boolean;
	     end;

  b9 = packed array[0..8] of boolean;
  b14= packed array[0..13] of boolean;
  crtcrec = packed record                               (* CRT CONTROL CHARS *)
	       rlf,ndfs,eraseeol,
	       eraseeos,home,
	       escape             : char;
	       backspace          : char;
	       fillcount          : 0..255;
	       clearscreen,
	       clearline          : char;
	       prefixed           : b9
	    end;

  crtirec = packed record                          (* CRT INFO & INPUT CHARS *)
	       width,height      : shortint;
	       crtmemaddr,crtcontroladdr,
	       keybufferaddr,progstateinfoaddr:integer;
	       keybuffersize: shortint;
	       crtcon            : crtconsttype;
	       right,left,down,up: char;
	       badch,chardel,stop,
	       break,flush,eof   : char;
	       altmode,linedel   : char;
	       backspace,
	       etx,prefix        : char;
	       prefixed          : b14 ;
	       cursormask        : integer;
	       spare             : integer;
	    end;

  environ = record
	      miscinfo: crtfrec;
	      crttype: integer;
	      crtctrl: crtcrec;
	      crtinfo: crtirec;
	    end;

  environptr    = ^environ;

  crtkinds = (NOCRT, ALPHATYPE, BITMAPTYPE, SPECIALCRT1, SPECIALCRT2);

  dumpstyle = 0..255;

VAR
  SYSCOM: ENVIRONPTR;
  ALPHASTATE['ALPHAFLAG']       : BOOLEAN;
  GRAPHICSTATE['GRAPHICSFLAG']  : BOOLEAN;
  CRTIOHOOK             : AMTYPE;
  TOGGLEALPHAHOOK       : PROCEDURE;
  TOGGLEGRAPHICSHOOK    : PROCEDURE;
  DUMPALPHAHOOK         : PROCEDURE;
  DUMPGRAPHICSHOOK      : PROCEDURE;
  UPDATECURSORHOOK      : PROCEDURE;
  CRTINITHOOK           : PROCEDURE;
  CRTLLHOOK             : CRTLLTYPE;
  DBCRTHOOK             : DBCRTTYPE;
  XPOS                  : SHORTINT; { CURSOR X POSITION }
  YPOS                  : SHORTINT; { CURSOR Y POSITION }
  CURRENTCRT            : CRTKINDS; { ACTIVE ALPHA DRIVER TYPE }
  BITMAPADDR            : INTEGER;  { ADDRESS OF BITMAP CONTROL SPACE }
  FRAMEADDR             : INTEGER;  { ADDRESS OF BITMAP FRAME BUFFER }
  REPLREGCOPY           : SHORTINT; { REGISTER COPIES FOR BITMAP DISPLAY }
  WINDOWREGCOPY         : SHORTINT; { MUST BE IN GLOBALS BECAUSE REGISTERS }
  WRITEREGCOPY          : SHORTINT; { ARE NOT READABLE -- MAY BE UNDEFINED }

 {* KEYBOARD *******************************************}
 CONST
   KBD_ENABLE     = 0; KBD_DISABLE    = 1;
   SET_AUTO_DELAY = 2; SET_AUTO_REPEAT= 3;
   GET_AUTO_DELAY = 4; GET_AUTO_REPEAT= 5;
   SET_KBDTYPE    = 6; SET_KBDLANG    = 7;
 TYPE
   STRING80PTR = ^STRING80;
   KEYBOARDTYPE = (NOKBD,LARGEKBD,SMALLKBD,ITFKBD,SPECIALKBD1,SPECIALKBD2);
   LANGTYPE = (NO_KBD,FINISH_KBD,BELGIAN_KBD,CDN_ENG_KBD,CDN_FR_KBD,
	       NORWEGIAN_KBD,DANISH_KBD,DUTCH_KBD,SWISS_GR_KBD,SWISS_FR_KBD,
	       SPANISH_EUR_KBD,SPANISH_LATIN_KBD,UK_KBD,ITALIAN_KBD,
	       FRENCH_KBD,GERMAN_KBD,SWEDISH_KBD,SPANISH_KBD,
	       KATAKANA_KBD,US_KBD,ROMAN8_KBD,NS1_KBD,NS2_KBD,NS3_KBD,
	       SWISS_GR_B_KBD,SWISS_FR_B_KBD {ADDED FOR 3.1--SFB-5/22/85} );
   MENUTYPE = (M_NONE,M_SYSNORM,M_SYSSHIFT,M_U1,M_U2,M_U3,M_U4);
 VAR
   KBDREQHOOK   : REQUEST1TYPE;
   KBDIOHOOK    : AMTYPE;
   KBDISRHOOK   : KBDHOOKTYPE;
   KBDPOLLHOOK  : BOOLPROC;
   KBDTYPE      : KEYBOARDTYPE;
   KBDCONFIG    : BYTE;         { KEYBOARD CONFIGURATION JUMPER }
   KBDLANG      : LANGTYPE;
   SYSMENU      : STRING80PTR;
   SYSMENUSHIFT : STRING80PTR;
   MENUSTATE    : MENUTYPE;

{* ENABLE / DISABLE ************************************}
 CONST
   KBDMASK=1;RESETMASK=2;TIMERMASK=4;PSIMASK=8;FHIMASK=16;
 VAR
   MASKOPSHOOK : OUT2TYPE; { ENABLE, DISABLE }

{* BEEPER **********************************************}
 VAR
   BEEPERHOOK: OUT2TYPE;
   BFREQUENCY, BDURATION: BYTE;

{* RPG *************************************************}
 CONST
   RPG_ENABLE   = 0; RPG_DISABLE = 1;
   SET_RPG_RATE = 2; GET_RPG_RATE =3;
 VAR
   RPGREQHOOK: REQUEST1TYPE;
   RPGISRHOOK: KBDHOOKTYPE;

{* BATTERY *********************************************}
TYPE
  BATCMDTYPE = PROCEDURE(CMD: BYTE; NUMDATA: INTEGER;
			 B1, B2, B3, B4, B5: BYTE);
  BATREADTYPE= PROCEDURE(VAR DATA: BYTE);
VAR
  BATTERYPRESENT[-563]: BOOLEAN;
  BATCMDHOOK : BATCMDTYPE;
  BATREADHOOK: BATREADTYPE;

{* CLOCK ***********************************************}
TYPE
  RTCTIME = PACKED RECORD
	       PACKEDTIME,PACKEDDATE:INTEGER;
	    END;
  CLOCKFUNC = (CGETDATE,CGETTIME,CSETDATE,CSETTIME,CSETZONE);
	      {CSETZONE ADDED BY JWS 4/17/86}

  CLOCKOP   = (CGET,CSET,CUPDATE,CTZ);   {CUPDATE ADDED FOR BOBCAT 4/11/85 SFB}
					 {CTZ ADDED 4/17/86 JWS}
  CLOCKDATA = RECORD
		CASE BOOLEAN OF
		TRUE :(TIMETYPE:TIMEREC);
		FALSE:(DATETYPE:DATEREC);
	      END;
  CLOCKREQTYPE = PROCEDURE(CMD:CLOCKFUNC; ANYVAR DATA:CLOCKDATA);
  CLOCKIOTYPE  = PROCEDURE(CMD:CLOCKOP  ; VAR DATA:RTCTIME);
VAR
  CLOCKREQHOOK : CLOCKREQTYPE;  { CLOCK MODULE INTERFACE }
  CLOCKIOHOOK  : CLOCKIOTYPE;   { CARD DRIVER INTERFACE }

{* TIMER ***********************************************}
TYPE
  TIMERTYPES = (CYCLICT,PERIODICT,DELAYT,DELAY7T,MATCHT);
  TIMEROPTYPE = (SETT,READT,GETTINFO);
  TIMERDATA = RECORD
	       CASE INTEGER OF
	       0: (COUNT: INTEGER);
	       1: (MATCH: TIMEREC);
	       2: (RESOLUTION,RANGE:INTEGER);
	       END;
  TIMERIOTYPE = PROCEDURE(TIMER: TIMERTYPES;OP: TIMEROPTYPE;VAR TD: TIMERDATA);
VAR
  TIMERIOHOOK  : TIMERIOTYPE;
  TIMERISRHOOK : KBDHOOKTYPE;


{* KEYBUFFER *******************************************}
CONST
  KMAXBUFSIZE = 255;
TYPE

  KOPTYPE = (KGETCHAR,KAPPEND,KNONADVANCE,KCLEAR,KDISPLAY,
	     KGETLAST,KPUTFIRST);
  KBUFTYPE= PACKED ARRAY[0..KMAXBUFSIZE] OF CHAR;
  KBUFPTR = ^KBUFTYPE;
  KBUFRECPTR = ^KBUFREC;
  KBUFREC = RECORD
	      ECHO: BOOLEAN;
	      NON_CHAR: CHAR;
	      MAXSIZE,SIZE,INP,OUTP: INTEGER;
	      BUFFER: KBUFPTR;
	    END;

VAR
  KEYBUFFER : KBUFRECPTR;
  KBDWAITHOOK: PROCEDURE;
  KBDRELEASEHOOK: PROCEDURE;
  STATUSLINE: PACKED ARRAY[0..7] OF CHAR;
  {0  s or f = STEP/FLASH IN PROGRESS (WAITING FOR TRAP #0)}
  {1..5  last executed/current line number }
  {6  S=SYSTEM  U=USER  DEFINITION FOR ITF SOFT KEYS}
  {   BLANK FOR NON ITF KEYBOARDS }
  {7  RUNLIGHT }

{* KEY TRANSLATION SERVICES ********************************}
TYPE
  KEYTRANSTYPE =(KPASSTHRU,KSHIFT_EXTC,KPASS_EXTC);
  KEYTYPE = (ALPHA_KEY,NONADV_KEY,SPECIAL_KEY,IGNORED_KEY,NONA_ALPHA_KEY);
  { ADDED NONA_ALPHA_KEY 5/9/84 RQ/SFB }

  LANGCOMREC = RECORD
		 STATUS : BYTE;
		 DATA   : BYTE;
		 KEY    : CHAR;
		 RESULT : KEYTYPE;
		 SHIFT,CONTROL,EXTENSION: BOOLEAN;
	       END;
  LANGKEYREC = RECORD
		 NO_CAPSLOCK: BOOLEAN;
		 NO_SHIFT   : BOOLEAN;
		 NO_CONTROL : BOOLEAN;
		 NO_EXTENSION : BOOLEAN;
		 KEYCLASS   : KEYTYPE;
		 KEYS : ARRAY[BOOLEAN] OF CHAR;
	       END;
  LANGRECORD= RECORD
		CAN_NONADV: BOOLEAN;
		LANGCODE  : LANGTYPE;
		SEMANTICS : PROCEDURE;
		KEYTABLE  : ARRAY[0..127] OF LANGKEYREC;
	      END;
  LANGPTR   = ^LANGRECORD;
VAR
  LANGCOM   : LANGCOMREC;
  LANGTABLE : ARRAY[0..1] OF LANGPTR;
  LANGINDEX : 0..1;
  KBDTRANSHOOK : KBDHOOKTYPE;
  TRANSMODE : KEYTRANSTYPE;
  KBDSYSMODE, KBDALTLOCK, KBDCAPSLOCK : BOOLEAN;

{* HPHIL ***********************************************}
{MOVED INTO SYSDEVS 4/6/84 SFB}
const
  le_configured = hex('80');
  le_error      = hex('81');
  le_timeout    = hex('82');
  le_loopdown   = hex('84');

  lmaxdevices   = 7;

type
  loopdvrop   = (datastarting,dataended,resetdevice,uninitdevice);
		 {UNINIT ADDED 4/8/85 SFB}
  loopdvrproc = procedure(op:loopdvrop);

  {HPHILOP DEFINED AS NEW TYPE 4/6/84 SFB}
  HPHILOP      = (RAWSHIFTOP,NORMSHIFTOP,CHECKLOOPOP,CONFIGUREOP,LCOMMANDOP);
  {5 PROCEDURES HOOKED AS TYPE HPHILCMDPROC 4/6/84 SFB}
  HPHILCMDPROC = PROCEDURE(OP : HPHILOP);


  descriprec = packed record    { DEVICE DESCRIBE RECORD }
		 case boolean of
		 true :(id       : byte;
			twosets  : boolean;
			abscoords: boolean;
			size16   : boolean;
			hasprompts:boolean;
		      { reserved : 0..3;        {DELETED 3/25/85 SFB}
			ext_desc : boolean;     {3/27/85 SFB}
			security : boolean;     {3/26/85 SFB}
			numaxes  : 0..3;
			counts   : shortint;
			maxcountx: shortint;
			maxcounty: shortint;
			maxcountz: shortint;
			promptack: boolean;     {ADDED 3/15/85 SFB}
			nprompts : 0..7;
			proximity: boolean;     {ADDED 3/15/85 SFB}
			nbuttons : 0..7);
		 false:(darray : array[1..11] of char);
	       end;

  devicerec = record
		devstate : integer;
		descrip : descriprec;
		opsproc  : loopdvrproc;
		dataproc : kbdhooktype;
	      end;

  loopdvrptr = ^loopdriverrec;
  loopdriverrec = record
		    lowid,highid,daddr : byte;
		    opsproc  : loopdvrproc;
		    dataproc : kbdhooktype;
		    next     : loopdvrptr;
		  end;

  LOOPCONTROLREC = RECORD                   {REDEFINED AS RECORD - 4/6/84 SFB}
	rawmode : boolean;
	loopdevices : array[1..lmaxdevices] of devicerec;
	loopdevice : 1..lmaxdevices;
	loopcmd    : byte;    { last loop command sent }
	loopdata   : byte;    { data bye in / out }
	looperror  : boolean; { error occured on last operation }
	loopinconfig:boolean; { now doing reconfigure }
	loopcmddone: boolean; { last sent command is done }
	loopisok   : boolean; { loop is configured }
	loopdevreading: boolean; { reading poll data }  { 3.0 BUG #39 3/17/84 }
  END;

  CONST                         {NEW TO END OF HPHIL_COMM_REC TYPE 3/26/85 SFB}


  {DRIVER TYPES}
  NODRIVER   =  0;
  ABSLOCATOR =  1;        {range 1..15 reserved for DGL}
  RELLOCATOR =  2;


  {CODETYPES FROM POLLBLOCK (OR OTHER HPHIL OPCODE)}
  NOCODES       = 0;
  ASCIICODES    = 1;
  SET1CODES     = 2;
  SET2CODES     = 3;

  TYPE

  HPHIL_COMM_REC_PTR_TYPE = ^hphil_comm_rec_type;  {3/25/85 SFB}

  HPHIL_COMM_REC_TYPE = RECORD CASE BOOLEAN OF              {3/25/85 SFB}
   TRUE :
	 (dvr_type        : shortint;
	  dev_addr        : 0..7;
	  latch,                  {stop updating data after button press/event}
	  active,                 {capture data in ISR}
	  reading         : boolean;  {dvr_comm_rec busy, delay update from ISR}
	  devices         : byte; {bit/loopaddress that driver should service
				   put 0 where driver should NOT service device
				   with this dvr_comm_rec !}
	  update          : procedure(recptr : hphil_comm_rec_ptr_type);
				  {call update to flush delayed poll data update}
	  link            : hphil_comm_rec_ptr_type;  {next comm record}
	  extend          : integer; {for extensibility use as pointer/datarec}

	  xloc,                   {HPHIL intrinsic data types from poll/command}
	  yloc,
	  zloc            : shortint;
	  codetype        : shortint;     {describes content of codes}
	  ncodes          : shortint;
	  codes           : packed array [1..16] of char
			       {extensible for variant} );
   FALSE:
	 (barray          : array[0..53] of char);
  END;

var

  loopdriverlist : loopdvrptr;
  LOOPCONTROL    : ^LOOPCONTROLREC;     {4/6/84 SFB}
  HPHILCMDHOOK   : HPHILCMDPROC;        {4/6/84 SFB}

  HPHIL_DATA_LINK : hphil_comm_rec_ptr_type;  {3/13/85 SFB}
  HIL_PRESENT:      BOOLEAN;             {8/28/86 JWS}

  TIMEZONE: INTEGER; {LOCAL + TIMEZONE = GMT} { JWS 4/17/86 }

  alphadumpstyle   : dumpstyle;
  graphicsdumpstyle: dumpstyle;


{-----------------------------------------------------------------------------}
PROCEDURE SYSDEV_INIT;
{* BEEPER **********************************************}
PROCEDURE BEEP;
PROCEDURE BEEPER(FREQUENCY,DURATION:BYTE);
{* RPG *************************************************}
PROCEDURE SETRPGRATE(RATE : BYTE);
{* KEYBOARD ********************************************}
PROCEDURE KBDSETUP(CMD,VALUE:BYTE);
PROCEDURE KBDIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
procedure lockedaction(a: action);
{* CRT *************************************************}
PROCEDURE CRTIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
PROCEDURE DUMMYCRTLL(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
{* BATTERY *********************************************}
PROCEDURE BATCOMMAND(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
FUNCTION  BATBYTERECEIVED:BYTE;
{* CLOCK ***********************************************}
function  sysclock: integer;   {centiseconds from midnight}
procedure sysdate (var thedate: daterec);
procedure systime (var thetime: timerec);
procedure setsysdate ( thedate: daterec);
procedure setsystime ( thetime: timerec);
function  sysgmttime: integer; {seconds from 1 Jan 1970 GMT}
procedure settimezone(tz: integer);
function isleap(y: integer): integer;
procedure secs_to_timedate(secs:integer;
			   var date:daterec; var time:timerec);
function timedate_to_secs(date : daterec; time : timerec) : integer;
{* KEYBUFFER *******************************************}
PROCEDURE KEYBUFOPS(OP:KOPTYPE; VAR C: CHAR);
{* STATUSLINE ******************************************}
PROCEDURE SETSTATUS(N:INTEGER; C:CHAR);
FUNCTION  RUNLIGHT:CHAR;
PROCEDURE SETRUNLIGHT(C:CHAR);

IMPLEMENT

{* GENERAL PURPOSE DUMMY PROCEDURES ********************}
  PROCEDURE DUMMYPROC;
  BEGIN END;
  PROCEDURE DUMMYOUT2(VALUE1, VALUE2 : BYTE);
  BEGIN END;
  PROCEDURE DUMMYKBD(VAR STATBYTE,DATABYTE : BYTE;
		     VAR DOIT:BOOLEAN);
  BEGIN END;
  PROCEDURE DUMMYREQ1(CMD : BYTE; VAR VALUE:BYTE);
  BEGIN END;
  PROCEDURE DUMMYTM(FP: FIBP; REQUEST: AMREQUESTTYPE;
		    ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN END;
  PROCEDURE DUMMYBOOLPROC(B:BOOLEAN);
  BEGIN END;
{* BEEPER **********************************************}
  PROCEDURE BEEP;
  BEGIN CALL(BEEPERHOOK,BFREQUENCY,BDURATION);
  END;
  PROCEDURE BEEPER(FREQUENCY,DURATION:BYTE);
  BEGIN CALL(BEEPERHOOK,FREQUENCY,DURATION);
  END;

{* RPG *************************************************}
  PROCEDURE SETRPGRATE(RATE:BYTE);
  VAR   IRATE : BYTE;
  BEGIN
    IRATE := RATE; CALL(RPGREQHOOK,SET_RPG_RATE,IRATE);
  END;

{* KEYBOARD ********************************************}
  PROCEDURE KBDSETUP(CMD,VALUE :BYTE);
  VAR IVALUE : BYTE;
  BEGIN IVALUE := VALUE; CALL(KBDREQHOOK,CMD,IVALUE);
  END;
  PROCEDURE KBDIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		  ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN CALL(KBDIOHOOK,FP,REQUEST,BUFFER,BUFSIZE,POSITION); END;

{* BATTERY *********************************************}
  PROCEDURE BATCOMMAND(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
  BEGIN CALL(BATCMDHOOK, CMD, NUMDATA, B1, B2, B3, B4, B5);
  END;
  FUNCTION  BATBYTERECEIVED:BYTE;
  VAR DATA : BYTE;
  BEGIN CALL(BATREADHOOK,DATA); BATBYTERECEIVED := DATA;
  END;

  PROCEDURE DUMMYBATCMD(CMD:BYTE; NUMDATA:INTEGER; B1, B2, B3, B4, B5: BYTE);
  BEGIN END;
  PROCEDURE DUMMYBATREAD(VAR DATA:BYTE);
  BEGIN END;

{* CLOCK ***********************************************}
  PROCEDURE DUMMYCLOCKSYS(VAR STIME:INTEGER);
  BEGIN END;
  PROCEDURE DUMMYCLOCKREQ(CMD:CLOCKFUNC; ANYVAR DATA:CLOCKDATA);
  BEGIN END;
  PROCEDURE DUMMYCLOCKIO(CMD:CLOCKOP  ; VAR DATA:RTCTIME);
  BEGIN END;
  function sysclock:integer;
  var ltime: rtctime;
  begin
    CALL(CLOCKIOHOOK,CGET,LTIME); sysclock := ltime.packedtime;
  end;

  procedure sysdate (var thedate: daterec);
  BEGIN CALL(CLOCKREQHOOK,CGETDATE,THEDATE);
  END;
  procedure systime (var thetime: timerec);
  BEGIN CALL(CLOCKREQHOOK,CGETTIME,THETIME);
  END;
  procedure setsysdate ( thedate: daterec);
  VAR D:DATEREC;
  BEGIN D:=THEDATE; CALL(CLOCKREQHOOK,CSETDATE,D);
  END;
  procedure setsystime ( thetime: timerec);
  VAR T:TIMEREC;
  BEGIN T:=THETIME; CALL(CLOCKREQHOOK,CSETTIME,T);
  END;
  PROCEDURE DUMMYTIMERIO(TIMER: TIMERTYPES;OP: TIMEROPTYPE;VAR TD: TIMERDATA);
  BEGIN IF OP=READT THEN TD.COUNT:=-1
	ELSE
	IF OP=GETTINFO THEN TD.RESOLUTION:=0;
  END;

{******************* NEW FOR 3.2 ******************************************}

  procedure settimezone(tz: integer);
  var ltime: timerec;
      ldate: daterec;
      negative: boolean;
  begin
   if tz<0 then begin {Awful kludge for tz<0}
     tz:=-tz;
     negative:=true;
   end
   else
     negative:=false;
   secs_to_timedate(tz, ldate, ltime);
   if negative then ltime.centisecond:=ltime.centisecond+1;
   call(clockreqhook, csetzone, ltime);
  end;

  function sysgmttime: integer;
  var ltime: rtctime;
  begin
    ltime.packedtime:=0;
    ltime.packeddate:=0;
    call (clockiohook, cget, ltime);
    with ltime do
      sysgmttime:=packeddate*86400+(packedtime+50) div 100
		  +timezone;
  end;


(*************************************************************
*
*  secs_to_timedate: Convert a time in seconds from Jan 1, 1970
*                   to PWS time and date records.
*
*  Assumes that time is > 0.
*
**************************************************************)

procedure secs_to_timedate(secs:integer;
			   var date:daterec; var time:timerec);

type
  day_month = array[0..12] of integer;
const
  day_tab = day_month[0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];


var hms: integer;
    days: integer;
    daysinmonth: integer;
    daysinyear: integer;
    done: boolean;

begin
with time,date do begin
  hms:= secs mod 86400;
  days:= secs div 86400;

  {Generate the year from date number}
  {RDQ 14MAR88 recoded the loop to correct
       1 JAN  two years after leap year bug
       and to isleap function }
  year:=70;
  daysinyear := 365+isleap(year);
  while days>=daysinyear do
  begin
    days:=days-daysinyear;
    year:=year+1;
    daysinyear := 365+isleap(year);
  end;

  {LAF 880101 proper range is now 0..127}
  {year:=year mod 100; {get it into proper range}

  {Generate month from remaining days}
  {RDQ recoded to use isleap function}
  month:=0;
  done:=false;
  repeat
    daysinmonth:=day_tab[month];
    if (month=2) then daysinmonth:=daysinmonth+isleap(year);
    if days>= daysinmonth then
    begin
      days:=days-daysinmonth;
      month:=month+1
    end
    else done:=true;
  until done;

  {days is now offset into month}
  day:=days+1;

  {Now convert hms in seconds to hh:mm:centisecs}

  hour:=hms div 3600;
  minute:=(hms-hour*3600) div 60;
  centisecond:=(hms mod 60)*100;

end; {of with}
end; {of procedure}

(****************************************************************************)
(* This routine transfers the 'date' + 'time' values into seconds since     *)
(* 00:00:00 , January 1 1970                                                *)
(****************************************************************************)
{RDQ 14MAR88 isleap now exported}
function isleap(y: integer): integer;
begin
  if (y mod 4 = 0) then isleap := 1
		    else isleap := 0;
end;


function timedate_to_secs(date : daterec; time : timerec) : integer;

type
  day_month = array [0..12] of integer;
  table = array[0..1] of day_month;
const
  day_tab = table[ day_month[0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
		   day_month[0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]];
var ttime :integer;
    i : integer;

begin
  timedate_to_secs:= 0;
  ttime := 0;
  if ( date.month <> 0 ) and ( date.year >= 70 ) then
  begin
    for i:=70 to (date.year-1) do
    begin
      ttime := ttime + 365*24*3600 + isleap(i)*24*3600;
    end;
    for i:=1 to (date.month-1) do
    begin
      ttime := ttime + day_tab[isleap(date.year)][i]*24*3600;
    end;
    ttime := ttime + (date.day-1)*24*3600;
    ttime := ttime + time.hour*3600+time.minute*60
		    +((time.centisecond +50) DIV 100);
  end;
  timedate_to_secs:= ttime;
end; {function}


{******************* end of new 3.2 clock procedures *****************}


{* CRT *************************************************}
  PROCEDURE CRTIO(FP: FIBP; REQUEST: AMREQUESTTYPE;
		  ANYVAR BUFFER: WINDOW; BUFSIZE,POSITION: INTEGER);
  BEGIN CALL(CRTIOHOOK,FP,REQUEST,BUFFER,BUFSIZE,POSITION); END;
  PROCEDURE DUMMYCRTLL(OP:CRTLLOPS; ANYVAR POSITION:INTEGER; C:CHAR);
  BEGIN END;
  PROCEDURE DUMMYDBCRT(OP:DBCRTOPS; VAR DBCRT:DBCINFO);
  BEGIN END;

  procedure lockedaction(a: action);
  label 1;
  var i: integer;
  begin
   if locklevel = 0 then call(a)
   else
   begin
     i := actionspending;
     while i>0 do if deferredaction[i]=a then goto 1 else i := i - 1;
     if actionspending = 10 then beep
     else
     begin
       actionspending := actionspending + 1;
       deferredaction[actionspending] := a;
     end;
   end;
  1:
  end;

{* KEYBUFFER *******************************************}
  PROCEDURE KEYBUFOPS(OP:KOPTYPE; VAR C: CHAR);
  VAR
    POSITION,TEMP1 : INTEGER;

    PROCEDURE ADVANCE(VAR P:INTEGER);
    BEGIN P:=(P+1) MOD KEYBUFFER^.MAXSIZE; END;

    PROCEDURE BACKUP(VAR P:INTEGER);
    BEGIN IF P=0 THEN P:=KEYBUFFER^.MAXSIZE-1 ELSE P:=P-1;
    END;

  BEGIN { KEYBUFOPS }
    WITH KEYBUFFER^ DO
    CASE OP OF
    KGETCHAR:
      BEGIN     { MUST NOT CALL IF SIZE=0 }
	IF ECHO THEN CALL(CRTLLHOOK,CLLSHIFTL,POSITION,' ');
	C:=BUFFER^[OUTP]; SIZE:=SIZE-1; ADVANCE(OUTP);
      END;
    KAPPEND,KNONADVANCE:
      BEGIN     { MUST NOT CALL IF SIZE>=MAXSIZE }
	IF ECHO THEN CALL(CRTLLHOOK,CLLPUT,SIZE,C);
	IF OP=KAPPEND THEN
	BEGIN
	  SIZE:=SIZE+1; BUFFER^[INP]:=C ;ADVANCE(INP); NON_CHAR:=' ';
	END
	ELSE NON_CHAR:=C;
      END;
    KCLEAR:
      BEGIN
	IF ECHO THEN CALL(CRTLLHOOK,CLLCLEAR,POSITION,' ');
	SIZE:=0; INP:=OUTP; NON_CHAR:=' ';
      END;
    KDISPLAY:
      IF ECHO THEN
      BEGIN
	CALL(CRTLLHOOK,CLLCLEAR,POSITION,' ');
	POSITION:= 0; TEMP1:=OUTP;
	WHILE POSITION<SIZE DO
	BEGIN
	  CALL(CRTLLHOOK,CLLPUT,POSITION,BUFFER^[TEMP1]);
	  ADVANCE(TEMP1); POSITION:=POSITION+1;
	END;
	IF NON_CHAR<>' ' THEN
	  CALL(CRTLLHOOK,CLLPUT,POSITION,NON_CHAR);
      END;
    KGETLAST:
      BEGIN
	IF ECHO AND (NON_CHAR<>' ') THEN CALL(CRTLLHOOK,CLLPUT,SIZE,' ');
	IF SIZE>0 THEN
	BEGIN
	  BACKUP(INP); C:=BUFFER^[INP]; SIZE:=SIZE-1; NON_CHAR:=' ';
	  IF ECHO THEN CALL(CRTLLHOOK,CLLPUT,SIZE,' ');
	END;
      END;
    KPUTFIRST:
      BEGIN     { CALL ONLY IF SIZE<=MAXSIZE }
	IF ECHO THEN
	BEGIN
	  POSITION:=0;
	  CALL(CRTLLHOOK,CLLSHIFTR,POSITION,' ');
	  CALL(CRTLLHOOK,CLLPUT,POSITION,C);
	END;
	BACKUP(OUTP); BUFFER^[OUTP]:=C; SIZE:=SIZE+1;
      END;
    END; { CASE }
  END; { KEYBUFOPS }

  PROCEDURE SETSTATUS(N:INTEGER; C:CHAR);
  VAR C1:CHAR;
  BEGIN STATUSLINE[N]:=C; C1:=C; CALL(CRTLLHOOK,PUTSTATUS,N,C1);
  END;
  FUNCTION  RUNLIGHT:CHAR;
  BEGIN RUNLIGHT:=STATUSLINE[7];
  END;
  PROCEDURE SETRUNLIGHT(C:CHAR);
  BEGIN SETSTATUS(7,C);
  END;

{* HPHIL ***********************************************}
{DUMMY ADDED 4/6/84 SFB}
  PROCEDURE DUMMYHPHILCMD(OP : HPHILOP);
  BEGIN  END;

{* INITIALIZE ALL HOOKS *****************************************************}
  PROCEDURE SYSDEV_INIT;
  VAR I : SHORTINT;
  BEGIN {SYSDEV_INIT}
    MASKOPSHOOK:= DUMMYOUT2;
    BEEPERHOOK := DUMMYOUT2;

    RPGREQHOOK := DUMMYREQ1;
    RPGISRHOOK := DUMMYKBD;

    BATREADHOOK:= DUMMYBATREAD;
    BATCMDHOOK := DUMMYBATCMD;

    CLOCKREQHOOK := DUMMYCLOCKREQ;
    CLOCKIOHOOK  := DUMMYCLOCKIO;
    TIMERIOHOOK  := DUMMYTIMERIO;
    TIMERISRHOOK := DUMMYKBD;

    KBDREQHOOK := DUMMYREQ1;
    KBDISRHOOK := DUMMYKBD;
    KBDTYPE    := NOKBD;
    KBDLANG    := NO_KBD;
    KBDIOHOOK  := DUMMYTM;
    KBDPOLLHOOK:= DUMMYBOOLPROC;
    MENUSTATE  := M_NONE;

    TOGGLEALPHAHOOK       := DUMMYPROC;
    TOGGLEGRAPHICSHOOK    := DUMMYPROC;
    DUMPALPHAHOOK         := DUMMYPROC;
    DUMPGRAPHICSHOOK      := DUMMYPROC;
    UPDATECURSORHOOK      := DUMMYPROC;
    CRTINITHOOK           := DUMMYPROC;
    CRTIOHOOK  := DUMMYTM;
    CRTLLHOOK  := DUMMYCRTLL;
    DBCRTHOOK  := DUMMYDBCRT;
    CURRENTCRT            := NOCRT;
    NEW(SYSCOM);

    NEW(KEYBUFFER);
    WITH KEYBUFFER^ DO
    BEGIN
      NEW(BUFFER);
      ECHO      :=TRUE;
      MAXSIZE   :=KMAXBUFSIZE;
      INP:=0; OUTP:=0; SIZE:=0;
      NON_CHAR  :=' ';
    END;

    FOR I:=0 TO 7 DO STATUSLINE[I]:=' ';
    KBDWAITHOOK    := DUMMYPROC;
    KBDRELEASEHOOK := DUMMYPROC;

    FOR I:=0 TO 1 DO LANGTABLE[I]:=NIL;
    LANGINDEX:=0;
    KBDSYSMODE:=TRUE; KBDALTLOCK:=FALSE; KBDCAPSLOCK:=FALSE;
    KBDTRANSHOOK := DUMMYKBD; TRANSMODE :=KPASSTHRU;

    HPHILCMDHOOK   := DUMMYHPHILCMD;    {4/6/84 SFB}
    LOOPCONTROL    := NIL;              {4/9/84 SFB}
    LOOPDRIVERLIST := NIL;              {4/9/84 SFB}

    HPHIL_DATA_LINK := NIL;              {3/13/85 SFB}

    TIMEZONE:=0;                         { 4/17/86 JWS}

  END; {SYSDEV_INIT}

END; {MODULE}

IMPORT SYSDEVS;
BEGIN
  SYSDEV_INIT;
  {MARKUSER}
END. {PROGRAM}
@


53.1
log
@Automatic bump of revision number for PWS version 3.24B
@
text
@@


52.1
log
@Automatic bump of revision number for PWS version 3.24A
@
text
@@


51.1
log
@Automatic bump of revision number for PWS version 3.24d
@
text
@@


50.1
log
@Automatic bump of revision number for PWS version 3.23c
@
text
@@


49.1
log
@Automatic bump of revision number for PWS version 3.24b
@
text
@@


48.1
log
@Automatic bump of revision number for PWS version 3.24a
@
text
@@


47.1
log
@Automatic bump of revision number for PWS version 3.23
@
text
@@


46.1
log
@Automatic bump of revision number for PWS version 3.23
@
text
@@


45.1
log
@Automatic bump of revision number for PWS version 3.23C
@
text
@@


44.1
log
@Automatic bump of revision number for PWS version 3.23B
@
text
@@


43.1
log
@Automatic bump of revision number for PWS version 3.23aA
@
text
@@


42.1
log
@Automatic bump of revision number for PWS version 3.23e
@
text
@@


41.1
log
@Automatic bump of revision number for PWS version 3.23d
@
text
@@


40.1
log
@Automatic bump of revision number for PWS version 3.23c
@
text
@@


39.1
log
@Automatic bump of revision number for PWS version 3.23b
@
text
@@


38.1
log
@Automatic bump of revision number for PWS version 3.23a
@
text
@@


37.1
log
@Automatic bump of revision number for PWS version 3.3a
@
text
@@


36.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


35.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


34.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


33.1
log
@Automatic bump of revision number for PWS version 3.22D
@
text
@@


32.1
log
@Automatic bump of revision number for PWS version 3.22C
@
text
@@


31.1
log
@Automatic bump of revision number for PWS version 3.22B
@
text
@@


30.1
log
@Automatic bump of revision number for PWS version 3.22A
@
text
@@


29.1
log
@Automatic bump of revision number for PWS version 3.22b
@
text
@@


28.1
log
@Automatic bump of revision number for PWS version 3.3b
@
text
@@


27.1
log
@Automatic bump of revision number for PWS version 3.3a
@
text
@@


26.4
log
@
Comment from auto synch of clock fix:
date: 88/03/15 14:25:59;  author: quist;  state: Exp;  lines added/del: 23/20
leap year fix
@
text
@@


26.3
log
@
Comment from auto synch of clock fix:
date: 88/03/02 17:15:25;  author: quist;  state: Exp;  lines added/del: 2/1
SYSDATE fixes. RDQ
@
text
@d458 1
d617 3
d621 7
a627 10
  repeat
    if (year mod 4)=0  then
      daysinyear:=366
    else
      daysinyear:=365;
    if days>=daysinyear then begin
      days:=days-daysinyear;
      year:=year+1
    end;
  until days<daysinyear;
d633 1
d638 3
a640 2
    if ((year mod 4)=0) and (month=2) then daysinmonth:=29;
    if days>= daysinmonth then begin
d644 1
a644 2
    else
      done:=true;
d663 6
d670 1
a680 6

function isleap(y: integer): integer;
begin
  if (y mod 4 = 0) then isleap := 1
		    else isleap := 0;
end;
@


26.2
log
@
Comment from auto synch of clock fix:
date: 88/03/02 09:45:24;  author: bayes;  state: Exp;  lines added/del: 0/0
Automatic bump of revision number for PWS version 3.2Y
@
text
@d628 2
a629 1
  year:=year mod 100; {get it into proper range}
@


26.1
log
@Automatic bump of revision number for PWS version 3.3 Synch
@
text
@@


24.1
log
@Automatic bump of revision number for PWS version 3.2
@
text
@@


23.1
log
@Automatic bump of revision number for PWS version 3.2P
@
text
@@


22.1
log
@Automatic bump of revision number for PWS version 3.2N
@
text
@@


21.1
log
@Automatic bump of revision number for PWS version 3.2M
@
text
@@


20.1
log
@Automatic bump of revision number for PWS version 3.2L
@
text
@@


19.1
log
@Automatic bump of revision number for PWS version 3.2K
@
text
@@


18.1
log
@Automatic bump of revision number for PWS version 3.2J
@
text
@@


17.1
log
@Automatic bump of revision number for PWS version 3.2I+
@
text
@@


16.1
log
@Automatic bump of revision number for PWS version 3.2I
@
text
@@


15.1
log
@Automatic bump of revision number for PWS version 3.2H
@
text
@@


14.1
log
@Automatic bump of revision number for PWS version 3.2G
@
text
@@


13.1
log
@Automatic bump of revision number for PWS version 3.2F
@
text
@@


12.1
log
@Automatic bump of revision number for PWS version 3.2E
@
text
@@


11.1
log
@Automatic bump of revision number for PWS version 3.2D
@
text
@@


10.1
log
@Automatic bump of revision number for PWS version 3.2C
@
text
@@


9.1
log
@Automatic bump of revision number for PWS version 3.2B
@
text
@@


8.1
log
@Automatic bump of revision number for PWS version 3.2A
@
text
@@


7.1
log
@Automatic bump of revision number for PWS version 3.2l
@
text
@@


6.1
log
@Automatic bump of revision number for PWS version 3.2k
@
text
@@


5.1
log
@Automatic bump of revision number for PWS version 3.2j
@
text
@@


4.1
log
@actual check in:
date: 86/09/30 20:11:32; author: hal; state: Exp
Automatic bump of revision number for PWS version 3.2i
@
text
@@


3.2
log
@actual check in:
date: 86/09/03 10:08:35; author: hal; state: Exp
Change sent from Scott Bayes and John Schmidt.
@
text
@@


3.1
log
@actual check in:
date: 86/09/01 12:22:57; author: hal; state: Exp
Automatic bump of revision number for PWS version 3.2h
@
text
@d423 1
@


2.1
log
@actual check in:
date: 86/07/30 15:11:24; author: hal; state: Exp
Auto bump rev number to 2.1 for sys 3.2e.
@
text
@@


1.2
log
@actual check in:
date: 86/06/30 16:52:56; author: danm; state:tmp
changes made by John Schmidt; timezone and time converting routines.
@
text
@@


1.1
log
@Initial revision
@
text
@d3 1
a3 1
 (c) Copyright Hewlett-Packard Company, 1984.
d118 2
d204 5
a208 2
  CLOCKFUNC = (CGETDATE,CGETTIME,CSETDATE,CSETTIME);
  CLOCKOP   = (CGET,CSET,CUPDATE);      {CUPDATE ADDED FOR BOBCAT 4/11/85 SFB}
d377 1
d379 1
d424 6
d455 5
d555 146
d876 2
@
