|
DataMuseum.dkPresents historical artifacts from the history of: CR80 Hard and Floppy Disks |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about CR80 Hard and Floppy Disks Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - download
Length: 25344 (0x6300)
Types: TextFile
Names: »PLIST1«
└─⟦9975dd352⟧ Bits:30005088 8" CR80 Floppy CR80FD_0043 ( CR/D/1032 PROMGEN (HBA) 790917 HBA PROMGEN BACKUP )
└─⟦69b0db55a⟧
└─ ⟦this⟧ »HBA.PLIST1«
\f
0001 %SUMMARY
0002 %LIST
0003 %WORKAREA=25000
0004
0005 "PAGE" \f
0006 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0007 " "
0008 " MODULE NUMBER CSS/103/L-D/0100 NAME PROMGEN PROGRAM LISTING "
0009 " "
0010 " GENERAL PURPOSE PROM GENERATING PROGRAM "
0011 " "
0012 " ROVSING FH/790822 RELEASE 01 VERSION 001 "
0013 " "
0014 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0015 " "
0016 " FUNCTION "
0017 " "
0018 " THE PROMGEN PROGRAM GENERATES PROMDESCRIPTIONS FROM A GIVEN "
0019 " HEXADECIMAL INPUT DISC FILE. "
0020 " THE PROMDESCRIPTIONS DEFINES THE CONTENT OF A NUMBER OF "
0021 " PROMS EACH CONTAINED IN ITS OWN DISCFILE. "
0022 " THESE DISCFILES HAVE TO BE CREATED PRIOR TO PROMGEN EXECUTION "
0023 " THE PROMDESCRIPTION IS AFTER A COPY TO A MAGNETIC TAPE , "
0024 " DIRECT USABLE AS INPUT TO A 'DATA I/O' PROM PROGRAMMER. "
0025 " PROMGEN TAKES FIXED INPUT PARAMETERS FROM A DISCFILE( "
0026 " SPECIFIED IN THE PROMGEN CALL) AND DYNAMIC PARAMETERS FROM "
0027 " THE OPERATORS CONSOLE. "
0028 " "
0029 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0030 "PAGE" \f
0031 " "
0032 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0033 " "
0034 " INTERFACE "
0035 " INVOCATION "
0036 " PROGRAM CALL: PROMGEN S:<PDATA> P:<PARAM> "
0037 " PROMGEN: THE ASSEMBLED PROGRAM. "
0038 " PDATA : THE HEXADECIMAL INPUTFILE TO BE PROMMED. "
0039 " PARAM : FIXED INPUT PARAMETER FILE. "
0040 " "
0041 " THE PROGRAM REQUIRES INPUT PARAMETERS FROM OC: "
0042 " "
0043 " ORIGINATED BY: <IDENTIFIER> "
0044 " PROJECT NO: <LONG INTEGER> "
0045 " DATE: <LONG INTEGER> "
0046 " FLOPPY DISC NO,CR/D/: <INTEGER> "
0047 " SOURCETEXT AND VERSION: <TEXT> "
0048 " AREASIZE: <INTEGER> "
0049 " AREASTART ADDRESS: <INTEGER> "
0050 " WHERE THE TEXT BEFORE : IS SUPPLIED BY THE PROGRAM. "
0051 " THE < > IS SUPPLIED AS AN ANSWER BY THE OPERATOR. "
0052 " "
0053 " FORMAT OF THE PARAM DISCFILE: "
0054 " "
0055 " # MODULE <TEXT> "
0056 " # WORDSIZE <INTEGER> "
0057 " # PROMSIZE <INTEGER> "
0058 " # PROMWIDTH <INTEGER> "
0059 " # PARITYPROMS <INTEGER> "
0060 " [ # <SEQNO> <PROMFILE> <PROMID> <VERSION> <PARITYBIT> ]X "
0061 " [ # <SEQNO> <PARITYFILE> <PROMID> <VERSION> ]Y "
0062 " WHERE X= NUMBER OF PROMS(PARITY PROMS EXCLUDED). "
0063 " Y= NUMBER OF PARITY PROMS. "
0064 " X AND Y ARE REPETITIONS FACTORS. "
0065 " "
0066 " OUTPUT "
0067 " "
0068 " FOR EACH GENERATED PROM , THE PROGRAM WRITES ON THE "
0069 " OPERATORS CONSOLE: "
0070 " "
0071 " PROMID: <INTEGER> VERSION: <INTEGER> "
0072 " CHECKSUM: <HEXADECIMAL NUMBER> "
0073 " "
0074 " EXIT "
0075 " THE PROGRAM RELINQUISHES CONTROL, WHEN ALL THE SPECIFIED "
0076 " PROMS ARE CREATED OR IF A PARAMETER ERROR IS FOUND. "
0077 " "
0078 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0079 " "
0080 " EXCEPTIONS "
0081 " "
0082 " IF A PARAMETER IS ILLEGAL, THE PROGRAM STOPS AND "
0083 " ISSUES AN APPROPRIATE ERRORMESSAGE. "
0084 " "
0085 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0086 "PAGE" \f
0087 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0088 " "
0089 " PROGRAM GENERATION "
0090 " THE SOURCE PROGRAM CONSISTS OF THE FOLLOWING FILES: "
0091 " "
0092 " PMODULE : MODULE HEADER "
0093 " PREFIX : PREFIX ROUTINES "
0094 " IODEC : IO DECLARATIONS AND CONSTANTS "
0095 " PDEC : PROMGEN DECLARATIONS AND CONSTANTS "
0096 " IO : IO PROCEDURES "
0097 " PPROC : PROMGEN PROCEDURES "
0098 " PPROG : PROMGEN MAIN PROGRAM "
0099 " "
0100 " THESE SOURCE PROGRAMS ARE MERGED: "
0101 " MERGE S: PMERGE1 O:PS1 "
0102 " "
0103 " HEREAFTER THE COMPILER IS CALLED: "
0104 " COMPILE S:PS1 O:GENOBJ P:PLIST1 "
0105 " "
0106 " THE BLOCKSIZE IS CHANGED: "
0107 " CONV41 S:GENOBJ O:PROMGEN.BIN "
0108 " "
0109 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0110 " "
0111 " PROGRAM STORAGE "
0112 " "
0113 " CR/D/1327 "
0114 " "
0115 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0116 " "
0117 " REFERENCE DOCUMENTS "
0118 " VERSION DESCRIPTION DOCUMENT: CSS/103/VDD/0018 "
0119 " USERS MANUAL: CSS/103/USM/0025 "
0120 " LISTING : CSS/103/LST/0001 "
0121 " "
0122 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
0123 "PAGE" \f
0124 %NOLIST
0271 "PAGE"\f
0272 "****************************
0273 * PASCAL I/O DECLARATIONS *
0274 ****************************"
0275
0276 CONST TEXT_SIZE=132;
0277 TYPE TEXT=ARRAY[1..TEXT_SIZE] OF CHAR;
0278
0279 TYPE STREAM=(INOC,OUTOC,INFILE,OUTFILE);
0280 TYPE DIRECTION=(INPUT,OUTPUT);
0281 TYPE BYTE=0..255;
0282 "**********************************************************************"
0283 " CONSTANTS "
0284 "**********************************************************************"
0285
0286 CONST MAX_PARITY_PROMS = 4 ; "20"
0287 MAX_PROMS = 64 ; "30"
0288 STX = '(:2:)' ; "40"
0289 ETX = '(:3:)' ; "50"
0290 MIN_AREASIZE = 8 ; "60"
0291 MIN_PROMSIZE = 8 ; "80"
0292 MAX_AREASIZE = 16384 ; "70"
0293 MAX_PROMSIZE = 16384 ; "90"
0294 MIN_PROMWIDTH = 4 ; "100"
0295 MAX_PROMWIDTH = 16 ; "110"
0296 MIN_WORDSIZE = 4 ; "120"
0297 MAX_WORDSIZE = 16 ; "130"
0298
0299 "**********************************************************************"
0300 " MAIN VARIABLES "
0301 "**********************************************************************"
0302
0303 TYPE PROMTYPE = RECORD "10"
0304 FILE : IDENTIFIER ; "20"
0305 IDNO : INTEGER ; "30"
0306 VERSION : INTEGER ; "40"
0307 PARITY_BIT : INTEGER ; "50"
0308 CHECKSUM : LONG_INTEGER "60"
0309 END; "70"
0310
0311
0312 TYPE LONG1 = RECORD
0313 LSB : INTEGER ;
0314 MSB : INTEGER
0315 END;
0316
0317 TYPE ID_RECORD_TYPE = RECORD "100"
0318 ORIGINATOR : IDENTIFIER ; "110"
0319 PROJECT_NO : LONG_INTEGER ; "120"
0320 DATE : LONG_INTEGER ; "130"
0321 MODULE : TEXT ; "140"
0322 FLOPPY_DISC_NO : INTEGER ; "150"
0323 SOURCE_TEXT : TEXT "160"
0324 END; "170"
0325
0326 TYPE PROM_AREA_TYPE = RECORD "190"
0327 SIZE : LONG_INTEGER ; "200"
0328 START_ADDRESS : LONG_INTEGER ; "210"
0329 WIDTH : INTEGER ; "220"
0330 PARITY_BITS_IN_USE : INTEGER "230"
0331 END; "240"
0332
0333 TYPE PHYS_PROM_TYPE = RECORD "260"
0334 SIZE : LONG_INTEGER ; "270"
0335 WIDTH : INTEGER "280"
0336 END; "290"
0337 VAR PROM : ARRAY [1..MAX_PROMS] OF PROMTYPE ; "292"
0338 ID_RECORD : ID_RECORD_TYPE ; "296"
0339 PROM_AREA : PROM_AREA_TYPE ; "298"
0340 PHYS_PROM : PHYS_PROM_TYPE ; "300"
0341 PARITY_AREA : ARRAY [0..MAX_PROMSIZE] OF INTEGER ; "310"
0342 S_IN , S_OUT : STREAM ; "320"
0343 PROM_INPUT_FILE : IDENTIFIER ; "330"
0344 PARAM_INPUT_FILE : IDENTIFIER ; "340"
0345 PROMS_PR_ROW , "350"
0346 PROMS_PR_COLOUMN , "360"
0347 NO_OF_PROMS , "370"
0348 PARITY_BITS_IN_USE , "315"
0349 NO_OF_PARITY_PROMS , "375"
0350 HEXA_PR_ROW , "380"
0351 HEXA_PR_PROM_ROW , "390"
0352 HEXA_PR_SINGLE_PROM , "400"
0353 HEXA_NO , "410"
0354 ROW_NO , "420"
0355 COLOUMN_NO , "430"
0356 I , J : INTEGER ; "440"
0357
0358 "PAGE" \f
0359 %NOLIST
0736 "PAGE" \f
0737 "**********************************************************************"
0738 " MAIN PROCEDURES "
0739 "**********************************************************************"
0740
0741 PROCEDURE DEFINE_CONSTANTS ; "10"
0742 VAR L : LONG_INTEGER ; "15"
0743 I : INTEGER ; "16"
0744 BEGIN "20"
0745 PROMS_PR_ROW := PROM_AREA.WIDTH DIV PHYS_PROM.WIDTH ; "30"
0746 PROMS_PR_COLOUMN := SHORT(( PROM_AREA.SIZE / "40"
0747 PHYS_PROM.SIZE ) ); "45"
0748 NO_OF_PROMS := PROMS_PR_ROW * PROMS_PR_COLOUMN ; "50"
0749 HEXA_PR_ROW := PROM_AREA.WIDTH DIV 4 ; "60"
0750 HEXA_PR_SINGLE_PROM := PHYS_PROM.WIDTH DIV 4 ; "70"
0751 L := LONG(HEXA_PR_ROW) * PHYS_PROM.SIZE ; "75"
0752 HEXA_PR_PROM_ROW := SHORT( L ); "80"
0753 FOR I := 0 TO SHORT( PHYS_PROM.SIZE ) - 1 DO "82"
0754 PARITY_AREA[ I ] := -1 ; "84"
0755 PARITY_BITS_IN_USE := 0 ; "86"
0756
0757 FOR I:= 1 TO (NO_OF_PROMS + NO_OF_PARITY_PROMS ) DO "100"
0758 PROM[ I ].CHECKSUM := 0L ; "110"
0759 END ; "90"
0760
0761 "**********************************************************************"
0762
0763 "PAGE" \f
0764 PROCEDURE READ_FROM_PARITY_AREA( LEFT_BIT , "10"
0765 ROW : INTEGER ; "20"
0766 VAR HEXA : CHAR ) ; "40"
0767 VAR BIN : INTEGER ; "50"
0768 BEGIN "60"
0769 BIN := GETBITS( PARITY_AREA[ ROW ] , "70"
0770 LEFT_BIT , "80"
0771 4 ) ; "90"
0772 HEXA := BIN_TO_ASCII( BIN ) ; "100"
0773 END "READ FROM PARITY AREA" ; "110"
0774
0775
0776
0777 PROCEDURE READ_HEXA( S : STREAM ; "10"
0778 VAR HEXA : CHAR ; "20"
0779 VAR NO : INTEGER ) ; "30"
0780 VAR CH : CHAR ; "40"
0781 BEGIN "50"
0782 IF NO MOD 32 = 0 "60"
0783 THEN "70"
0784 BEGIN "80"
0785 REPEAT "90"
0786 INBYTE( S , CH ); "100"
0787 UNTIL "110"
0788 CH = 'L' ; "120"
0789 END; "130"
0790
0791 REPEAT "140"
0792 INBYTE( S , CH ) "150"
0793 UNTIL "160"
0794 XXXHEXADIGIT( CH ); "170"
0795
0796 HEXA := CH ; "180"
0797 NO := NO + 1 ; "190"
0798 END "READ HEXA"; "200"
0799
0800
0801 PROCEDURE IN_IDENT( S: STREAM ; "10"
0802 VAR IDF: IDENTIFIER ); "20"
0803 VAR CH: CHAR; "30"
0804 I : INTEGER; "40"
0805 BEGIN "50"
0806 FOR I:= 1 TO IDLENGTH DO "60"
0807 IDF[I] := NULL; "70"
0808 REPEAT "80"
0809 INBYTE( S , CH ); "90"
0810 UNTIL "100"
0811 NOT ( (CH=NL) OR (CH=SP) OR (CH=EM)) ; "110"
0812 IDF[1] := CH ; "120"
0813 I:=1; "130"
0814 REPEAT "140"
0815 INBYTE( S , CH ); "150"
0816 I:= I + 1 ; "160"
0817 IDF[ I ] := CH ; "170"
0818 UNTIL "180"
0819 (CH=NL) OR (CH=SP) OR (CH=EM) OR (I>=IDLENGTH) ; "190"
0820 IDF[ I ] := NULL ; "195"
0821 END "IN_IDENT" ; "200"
0822
0823
0824
0825 "PAGE" \f
0826 PROCEDURE GET_OC_PARAMS( OC_IN , OC_OUT : STREAM ); "10"
0827 BEGIN "20"
0828 OUTNL( OC_OUT ); "30"
0829 OUTSTRING( OC_OUT, 'ORIGINATED BY: (:0:)'); "40"
0830 OUTNL( OC_OUT ); "50"
0831
0832 IN_IDENT( OC_IN , ID_RECORD.ORIGINATOR ); "60"
0833
0834 OUTNL(OC_OUT); "70"
0835 OUTSTRING( OC_OUT, 'PROJECT NO: (:0:)' ); "80"
0836 OUTNL(OC_OUT); "90"
0837 IN_LONG_INTEGER( OC_IN , ID_RECORD.PROJECT_NO); "100"
0838
0839 OUTNL(OC_OUT); "110"
0840 OUTSTRING( OC_OUT , 'DATE: (:0:)' ); "120"
0841 OUTNL(OC_OUT); "130"
0842 IN_LONG_INTEGER( OC_IN , ID_RECORD.DATE ); "140"
0843
0844 OUTNL(OC_OUT); "150"
0845 OUTSTRING(OC_OUT, 'FLOPPY DISC NO, CR/D: (:0:)' ); "160"
0846 OUTNL(OC_OUT); "170"
0847 ININTEGER( OC_IN , ID_RECORD.FLOPPY_DISC_NO ); "180"
0848
0849 OUTNL(OC_OUT); "190"
0850 OUTSTRING( OC_OUT ,'SOURCE TEXT AND VERSION: (:0:)' ); "200"
0851 OUTNL(OC_OUT); "210"
0852 INLINE(OC_IN , ID_RECORD.SOURCE_TEXT ); "220"
0853
0854 OUTNL(OC_OUT); "230"
0855 OUTSTRING( OC_OUT, 'AREASIZE: (:0:)' ); "240"
0856 OUTNL(OC_OUT); "250"
0857 IN_LONG_INTEGER( OC_IN , PROM_AREA.SIZE ); "260"
0858
0859 OUTNL(OC_OUT); "270"
0860 OUTSTRING( OC_OUT, 'AREA STARTADDRESS: (:0:)' ); "280"
0861 OUTNL(OC_OUT); "290"
0862 IN_LONG_INTEGER( OC_IN, PROM_AREA.START_ADDRESS); "300"
0863
0864 END "GET_OC_PARAMS" ; "310"
0865
0866
0867 "PAGE" \f
0868 PROCEDURE GET_DISC_PARAMS( S: STREAM ); "10"
0869 VAR I , SEQ_NO, PROM_NO, "20"
0870 P_NO : INTEGER ; "25"
0871 CH : CHAR ; "30"
0872 TXT : TEXT ; "40"
0873 IDF : IDENTIFIER ; "50"
0874 BEGIN "60"
0875 FOR I:= 1 TO 5 DO "70"
0876 BEGIN "80"
0877 REPEAT "90"
0878 INBYTE( S , CH ); "100"
0879 UNTIL "110"
0880 CH= '#'; "120"
0881
0882 IN_IDENT( S , IDF ) ; "130"
0883
0884 CASE I OF "140"
0885 1: BEGIN "150"
0886 IF IDF <> 'MODULE(:0:)(:0:)(:0:)(:0:)(:0:)(:0:)' "160"
0887 THEN XXXERROR('MODULE PARAM(:0:)') "170"
0888 ELSE INLINE( S , ID_RECORD.MODULE ); "180"
0889 END; "190"
0890 2: BEGIN "200"
0891 IF IDF <> 'WORDSIZE(:0:)(:0:)(:0:)(:0:)' "210"
0892 THEN XXXERROR('WORDSIZE PARAM(:0:)') "220"
0893 ELSE ININTEGER( S , PROM_AREA.WIDTH ); "230"
0894 END; "240"
0895 3: BEGIN "250"
0896 IF IDF <> 'PROMSIZE(:0:)(:0:)(:0:)(:0:)' "260"
0897 THEN XXXERROR('PROMSIZE PARAM(:0:)' ) "270"
0898 ELSE IN_LONG_INTEGER( S , PHYS_PROM.SIZE ); "280"
0899 END; "290"
0900 4: BEGIN "300"
0901 IF IDF <> 'PROMWIDTH(:0:)(:0:)(:0:)' "310"
0902 THEN XXXERROR('PROMWIDTH PARAM(:0:)' ) "320"
0903 ELSE ININTEGER( S , PHYS_PROM.WIDTH ); "330"
0904 END ; "340"
0905 5: BEGIN "341"
0906 IF IDF <> 'PARITYPROMS(:0:)' "342"
0907 THEN XXXERROR('PARITY PROM PARAM(:0:)' ) "343"
0908 ELSE ININTEGER( S , NO_OF_PARITY_PROMS ) ; "344"
0909 END "345"
0910 END "CASE"; "350"
0911 END "FOR I"; "360"
0912 NO_OF_PROMS := ( PROM_AREA.WIDTH DIV PHYS_PROM.WIDTH) * "320"
0913 SHORT( PROM_AREA.SIZE / PHYS_PROM.SIZE ); "380"
0914 PROM_NO := 0; "390"
0915 P_NO := 0 ; "395"
0916
0917 REPEAT "400"
0918 PROM_NO := PROM_NO + 1 ; "410"
0919 IF PROM_NO = NO_OF_PROMS + 1 "412"
0920 THEN P_NO := 0; "414"
0921 P_NO := P_NO + 1 ; "416"
0922
0923 REPEAT "420"
0924 INBYTE( S , CH ); "430"
0925 UNTIL "440"
0926 CH='#'; "450"
0927
0928 ININTEGER( S , SEQ_NO ); "460"
0929 IF SEQ_NO <> P_NO "470"
0930 THEN XXXERROR('PARAM PROM SEQUENCE ERROR(:0:)' ); "475"
0931 IN_IDENT( S , PROM[ PROM_NO ].FILE ); "480"
0932 ININTEGER( S, PROM[ PROM_NO ].IDNO ); "490"
0933 ININTEGER( S , PROM[ PROM_NO ].VERSION ); "500"
0934 IF PROM_NO <= NO_OF_PROMS "504"
0935 THEN ININTEGER( S , PROM[ PROM_NO ].PARITY_BIT ) ; "510"
0936 UNTIL "520"
0937 PROM_NO >= NO_OF_PROMS + NO_OF_PARITY_PROMS ; "530"
0938 END "GET DISC PARAMS"; "540"
0939
0940 "PAGE" \f
0941 PROCEDURE CHECK_PARAMS;
0942 VAR TEST : INTEGER ;
0943 BEGIN
0944
0945 TEST := SHORT( PROM_AREA.SIZE ) ; "40"
0946 IF ( TEST < MIN_AREASIZE )
0947 OR ( TEST > MAX_AREASIZE )
0948 THEN XXXERROR('AREASIZE CONTENT(:0:)' );
0949
0950
0951 TEST := SHORT( PHYS_PROM.SIZE ) ; "80"
0952 IF ( TEST < MIN_PROMSIZE ) OR ( TEST > MAX_PROMSIZE )
0953 OR ( TEST > SHORT( PROM_AREA.SIZE ) ) "100"
0954 OR ( SHORT( PROM_AREA.SIZE) MOD TEST <> 0 ) "110"
0955 THEN XXXERROR( 'PROMSIZE CONTENT(:0:)' );
0956
0957
0958 TEST := SHORT( PROM_AREA.START_ADDRESS ) ; "130"
0959 IF ( TEST < 0 ) OR ( TEST >= SHORT( PROM_AREA.SIZE ) ) "140"
0960 THEN XXXERROR( ' START ADDRESS CONTENT(:0:)' );
0961
0962
0963 TEST := PROM_AREA.WIDTH ;
0964 IF ( TEST < MIN_WORDSIZE ) OR (TEST > MAX_WORDSIZE )
0965 OR (TEST MOD 4 <>0 )
0966 THEN XXXERROR( 'WORDSIZE CONTENT(:0:)' );
0967
0968 TEST := PHYS_PROM.WIDTH ;
0969 IF ( TEST < MIN_PROMWIDTH ) OR (TEST > MAX_PROMWIDTH )
0970 OR ( TEST MOD 4 <> 0 )
0971 OR ( TEST > PROM_AREA.WIDTH ) "230"
0972 THEN XXXERROR( 'PROMWIDTH CONTENT(:0:)' );
0973
0974 END " CHECK PARAMS";
0975
0976 "PAGE" \f
0977
0978 PROCEDURE PROM_WORD_TREATMENT( F_OUT , F_IN : STREAM ; "10"
0979 ROW, "20"
0980 PROM_NO : INTEGER ; "40"
0981 VAR HEXA_NO : INTEGER ) ; "50"
0982 CONST CR = '(:10:)' ;
0983 VAR I, "60"
0984 J , "62"
0985 ADDR , "66"
0986 LEFT_BIT , "68"
0987 HEXAS_OUTPUT, "70"
0988 BIN, "80"
0989 WORD, "90"
0990 P_BIT , "95"
0991 ONES : INTEGER ; "100"
0992 HEXA : CHAR ; "110"
0993 BEGIN "120"
0994 ADDR := SHORT( PROM_AREA.START_ADDRESS ) ; "130"
0995 IF ( ROW= ADDR ) AND ( ADDR > 0 ) AND ( PROM_NO <= PROMS_PR_ROW ) "135"
0996 THEN "140"
0997 BEGIN "150"
0998
0999 I:= PHYS_PROM.WIDTH ;
1000 IF I=4 THEN WORD := #F
1001 ELSE IF I=8 THEN WORD:= #FF
1002 ELSE WORD := #FFFF ;
1003
1004 FOR I :=0 TO (ADDR - 1 ) DO
1005 PROM[PROM_NO].CHECKSUM := PROM[PROM_NO].CHECKSUM +
1006 LONG( WORD ) ;
1007
1008 OUTBYTE(F_OUT , STX ) ; "151"
1009 OUTBYTE( F_OUT , CR ) ; "152"
1010
1011 ADDR := ADDR*HEXA_PR_SINGLE_PROM ; "153"
1012
1013 FOR J := 1 TO ADDR DIV 32 DO "154"
1014 BEGIN "155"
1015 FOR I:= 1 TO 32 DO "156"
1016 BEGIN "157"
1017 OUTBYTE( F_OUT , 'F' ); "158"
1018 IF ( I MOD HEXA_PR_SINGLE_PROM = 0 ) "158.5"
1019 THEN OUTBYTE( F_OUT , SP ) ; "159"
1020 END; "160"
1021 OUTBYTE( F_OUT , CR ); "161"
1022 OUTBYTES( F_OUT , NULL , 7 ); "162"
1023 END; "163"
1024
1025 FOR J:= 1 TO ADDR MOD 32 DO "165"
1026 BEGIN "166"
1027 OUTBYTE( F_OUT , 'F' ) ; "167"
1028 IF ( J MOD HEXA_PR_SINGLE_PROM = 0 ) "168"
1029 THEN OUTBYTE( F_OUT , SP ) ; "169"
1030 END; "170"
1031 END; "195"
1032
1033 WORD := 0 ; "200"
1034 FOR I:= 1 TO HEXA_PR_SINGLE_PROM DO "210"
1035 BEGIN "220"
1036 IF PROM_NO > NO_OF_PROMS "230"
1037 THEN "231"
1038 BEGIN "232"
1039 LEFT_BIT := "233"
1040 (PROM_NO-NO_OF_PROMS)*PHYS_PROM.WIDTH -4*(I-1) - 1 ; "234"
1041 READ_FROM_PARITY_AREA( LEFT_BIT , ROW , HEXA ) ; "235"
1042 END "237"
1043 ELSE READ_HEXA( F_IN , HEXA , HEXA_NO ) ; "236"
1044
1045 IF (I=1) AND (ROW=0 ) THEN "240"
1046 BEGIN "250"
1047 OUTBYTE( F_OUT , STX ) ; "260"
1048 OUTBYTE( F_OUT , CR ); "270"
1049 END; "280"
1050 OUTBYTE( F_OUT , HEXA ); "290"
1051 HEXAS_OUTPUT := ROW*HEXA_PR_SINGLE_PROM + I ; "300"
1052 IF ( LONG( ROW ) = PHYS_PROM.SIZE - 1L ) AND "310"
1053 ( I = HEXA_PR_SINGLE_PROM ) "320"
1054 THEN "325"
1055 BEGIN "330"
1056 OUTBYTE( F_OUT , SP ) ; "335"
1057 OUTBYTE(F_OUT , ETX ); "350"
1058 OUTBYTES( F_OUT , NULL , 7 ) ; "354"
1059 OUTNL( F_OUT ) ; "356"
1060 END "360"
1061 ELSE "370"
1062 BEGIN "380"
1063 IF ((HEXAS_OUTPUT MOD 32) = 0 ) "400"
1064 THEN "410"
1065 BEGIN "420"
1066 OUTBYTE( F_OUT , SP ) ; "425"
1067 OUTBYTE( F_OUT , CR ); "430"
1068 OUTBYTES( F_OUT , NULL , 7 ); "440"
1069 END "450"
1070 ELSE "460"
1071 BEGIN "470"
1072 IF HEXAS_OUTPUT MOD HEXA_PR_SINGLE_PROM = 0 "480"
1073 THEN OUTBYTE( F_OUT , SP ); "490"
1074 END; "500"
1075 END; "510"
1076
1077 BIN := ASCII_TO_BIN( HEXA ) ; "520"
1078 WORD := LEFTSHIFT( WORD , 4 ) + BIN ; "530"
1079 END "FOR I " ; "540"
1080
1081 PROM[ PROM_NO].CHECKSUM := "600"
1082 PROM[PROM_NO].CHECKSUM + LONG( WORD ) ; "610"
1083
1084 IF PROM_NO <= NO_OF_PROMS "612"
1085 THEN "613"
1086 P_BIT := PROM[ PROM_NO ].PARITY_BIT ; "614"
1087
1088 IF (PROM_NO <= NO_OF_PROMS ) AND ( P_BIT >=0) AND ( P_BIT <= 15) "620"
1089 THEN "630"
1090 BEGIN "640"
1091 ONES := 0; "650"
1092 FOR I := 0 TO PHYS_PROM.WIDTH -1 DO "660"
1093 IF TESTBIT( WORD , I ) "670"
1094 THEN ONES := ONES + 1 ; "680"
1095 IF TESTBIT(PARITY_BITS_IN_USE , P_BIT ) "690"
1096 THEN "700"
1097 BEGIN "710"
1098 IF GETBITS( ONES , 0 , 1 ) <> "720"
1099 GETBITS( PARITY_AREA[ROW] , P_BIT , 1 ) "730"
1100 THEN SETBIT( PARITY_AREA[ ROW ] , P_BIT ) "740"
1101 ELSE CLEARBIT(PARITY_AREA[ROW ] , P_BIT ) "750"
1102 END "760"
1103 ELSE "770"
1104 BEGIN "780"
1105 IF TESTBIT( ONES , 0 ) "790"
1106 THEN CLEARBIT( PARITY_AREA[ROW], P_BIT ) "800"
1107 ELSE SETBIT( PARITY_AREA[ROW] , P_BIT ) "810"
1108 END; "820"
1109 END; "830"
1110 END "PROMWORD TREATMENT" ; "840"
1111
1112 "PAGE" \f
1113
1114 FUNCTION SHORT1( L_INT: UNIV LONG1 ) : INTEGER ; "10"
1115 BEGIN "20"
1116 SHORT1 := L_INT.LSB ; "30"
1117 END; "40"
1118
1119
1120 "PAGE" \f
1121
1122 PROCEDURE EXTRACT_PARITY_PROM( F_OUT : STREAM ; "10"
1123 PROM_NO : INTEGER ) ; "20"
1124 VAR J, "30"
1125 COL : INTEGER ; "40"
1126 BEGIN "50"
1127 COL := 16 DIV PHYS_PROM.WIDTH - PROM_NO ; "60"
1128 J:= 0 ; "70"
1129 REPEAT "80"
1130 PROM_WORD_TREATMENT( F_OUT , S_IN , J , "110"
1131 PROM_NO , HEXA_NO ) ; "115"
1132 J := J + 1 ; "120"
1133 UNTIL "130"
1134 J >=SHORT( PHYS_PROM.SIZE ) ; "140"
1135
1136 OUTNL( F_OUT ) ; "142"
1137 OUTSTRING( F_OUT , 'CHECKSUM: (:0:)' );
1138 OUTHEXA( F_OUT ,SHORT1( PROM[ PROM_NO ].CHECKSUM ) , 5 ) ; "146"
1139 OUTNL( F_OUT ) ;
1140 OUTBYTE( F_OUT , EM ); "149"
1141 END " EXTRACT PARITY PROM" ; "150"
1142
1143
1144 "PAGE" \f
1145 PROCEDURE EXTRACT_PROM( F_OUT,F_IN : STREAM ; "10"
1146 PROM_NO : INTEGER ); "20"
1147
1148 VAR ROW , COL , I , S : INTEGER ; "30"
1149 HEXA : CHAR ; "40"
1150 START,J ,OFFSET_NO : LONG_INTEGER ; "50"
1151 BEGIN "60"
1152 HEXA_NO := 0 ; "70"
1153 ROW := ( PROM_NO - 1 ) DIV PROMS_PR_ROW ; "80"
1154 COL := ( PROM_NO - 1 ) MOD PROMS_PR_ROW ; "90"
1155
1156 IF ROW=0 "110"
1157 THEN START := PROM_AREA.START_ADDRESS "120"
1158 ELSE START := 0L ; "130"
1159
1160 IF ROW >= 1 "140"
1161 THEN "150"
1162 BEGIN "160"
1163 J := PHYS_PROM.SIZE - PROM_AREA.START_ADDRESS ; "170"
1164 " ROW POSITIONING " "175"
1165 OFFSET_NO := J * LONG( HEXA_PR_ROW ) "180"
1166 + LONG( HEXA_PR_PROM_ROW * ( ROW-1 ) ); "185"
1167 J := 0L ; "190"
1168 REPEAT "200"
1169 J:= J + 1L ; "205"
1170 READ_HEXA( F_IN , HEXA , HEXA_NO ) ; "210"
1171 UNTIL "215"
1172 J >= OFFSET_NO ; "218"
1173 END " ROW > 1 " ; "220"
1174
1175 J := START ; "230"
1176 WHILE "235"
1177 J < PHYS_PROM.SIZE DO "240"
1178 BEGIN "245"
1179 "POSITION IN THE PROMAREA WORD " "250"
1180 FOR S := 1 TO COL*HEXA_PR_SINGLE_PROM DO "260"
1181 READ_HEXA( F_IN , HEXA , HEXA_NO ); "270"
1182
1183 PROM_WORD_TREATMENT( "280"
1184 F_OUT , F_IN , SHORT(J) , PROM_NO , HEXA_NO ); "285"
1185
1186 " SKIP THE REST OF THE LINE " "290"
1187 FOR S := 1 TO "300"
1188 (PROMS_PR_ROW - COL - 1 )* HEXA_PR_SINGLE_PROM DO "305"
1189 READ_HEXA( F_IN , HEXA, HEXA_NO ); "310"
1190 J := J + 1L ; "320"
1191 END; "330"
1192 OUTNL( F_OUT ) ; "331"
1193 OUTSTRING( F_OUT , 'CHECKSUM: (:0:)' ); "332"
1194 OUTHEXA( F_OUT ,SHORT1( PROM[ PROM_NO ].CHECKSUM ) , 5 ) ; "334"
1195 OUTNL( F_OUT ) ; "336"
1196 OUTBYTE( F_OUT , EM ) ; "340"
1197
1198 I := PROM[ PROM_NO ].PARITY_BIT ; "342"
1199 IF ( I>=0) AND ( I<=15 ) "344"
1200 THEN SETBIT( PARITY_BITS_IN_USE , I ) ; "346"
1201 END " EXTRACT PROM" ; "350"
1202
1203 "PAGE" \f
1204 PROCEDURE PRINT_ID_RECORD( S: STREAM; "10"
1205 PROM_NO: INTEGER ); "20"
1206 BEGIN "30"
1207 OUTNL(S); "40"
1208 OUTSTRING( S , 'ORIGINATED BY: (:0:)' ); "50"
1209 OUTSTRING( S , ID_RECORD.ORIGINATOR ); "60"
1210
1211 OUTNL(S); "70"
1212 OUTSTRING( S , 'PROJECT NO: (:0:)' ); "80"
1213 OUT_LONG_INTEGER( S , ID_RECORD.PROJECT_NO , 8 ); "90"
1214
1215 OUTNL(S); "100"
1216 OUTSTRING( S , 'DATE: (:0:)' ); "110"
1217 OUT_LONG_INTEGER( S , ID_RECORD.DATE , 8 ); "120"
1218
1219 OUTNL( S ) ; "130"
1220 OUTSTRING( S , 'MODULE: (:0:)' ); "140"
1221 OUTTEXT( S , ID_RECORD.MODULE , 60 ) ; "150"
1222
1223 OUTNL(S); "160"
1224 OUTSTRING( S , 'FLOPPY DISC NO CR/D/(:0:)' ); "170"
1225 OUTINTEGER( S , ID_RECORD.FLOPPY_DISC_NO , 4 ); "180"
1226
1227 OUTNL(S); "190"
1228 OUTSTRING( S, 'SOURCE TEXT AND VERSION: (:0:)' ); "200"
1229 OUTTEXT( S , ID_RECORD.SOURCE_TEXT ,60 ); "210"
1230
1231 OUTNL(S); "220"
1232 OUTSTRING( S , 'AREASIZE: (:0:)' ); "230"
1233 OUT_LONG_INTEGER( S , PROM_AREA.SIZE , 7 ); "240"
1234
1235 OUTNL(S); "250"
1236 OUTSTRING( S , 'AREA START ADDRESS: (:0:)' ); "260"
1237 OUT_LONG_INTEGER( S , PROM_AREA.START_ADDRESS , 7 ); "270"
1238
1239 OUTNL(S); "280"
1240 OUTSTRING( S , 'PROMSIZE: (:0:)' ); "290"
1241 OUT_LONG_INTEGER( S , PHYS_PROM.SIZE , 6) ; "300"
1242
1243 OUTNL(S); "310"
1244 OUTSTRING( S , 'PROMWIDTH: (:0:)' ); "320"
1245 OUTINTEGER( S , PHYS_PROM.WIDTH , 4 ); "330"
1246
1247 OUTNL(S); "340"
1248 OUTSTRING( S , 'PROM FILE: (:0:)' ); "350"
1249 OUTSTRING( S , PROM[ PROM_NO ].FILE ); "360"
1250
1251 OUTNL(S); "370"
1252 OUTSTRING( S , 'PROMID: (:0:)' ); "380"
1253 OUTINTEGER( S ,PROM[ PROM_NO ].IDNO , 5 ); "390"
1254
1255 OUTSTRING( S , ' VERSION: (:0:)' ); "400"
1256 OUTINTEGER( S , PROM[ PROM_NO ].VERSION , 3 ); "410"
1257
1258 IF PROM_NO <= NO_OF_PROMS "420"
1259 THEN "422"
1260 BEGIN "423"
1261 OUTSTRING( S , ' PARITY BIT: (:0:)' ); "424"
1262 OUTINTEGER( S , PROM[ PROM_NO ].PARITY_BIT , 2 ); "425"
1263 END; "427"
1264
1265 OUTNL(S); "440"
1266 OUTSTRING( S , 'PROM INPUT FILE: (:0:)' ); "450"
1267 OUTTEXT( S , PROM_INPUT_FILE , IDLENGTH ) ; "460"
1268
1269 OUTNL( S ); "465"
1270 OUTSTRING( S , 'PARAM INPUT FILE: (:0:)' ); "470"
1271 OUTTEXT( S , PARAM_INPUT_FILE , IDLENGTH ) ; "480"
1272
1273 OUTNL(S); "540"
1274 END "PRINT_ID_RECORD"; "550"
1275
1276
1277 "PAGE" \f
1278 PROCEDURE OC_CHECKSUM( PROM_NO : INTEGER ) ; "10"
1279 VAR S : STREAM ; "15"
1280 BEGIN "20"
1281 OPEN( S , 'OC(:0:)' , OUTPUT ) ; "30"
1282 OUTNL(S); "500"
1283 OUTSTRING( S , 'PROMID: (:0:)' ); "380"
1284 OUTINTEGER( S ,PROM[ PROM_NO ].IDNO , 5 ); "390"
1285
1286 OUTSTRING( S , ' VERSION: (:0:)' ); "400"
1287 OUTINTEGER( S , PROM[ PROM_NO ].VERSION , 3 ); "410"
1288 OUTNL(S); "370"
1289 OUTSTRING( S , 'CHECKSUM: (:0:)' ); "520"
1290 OUTHEXA( S , SHORT1( PROM[ PROM_NO ].CHECKSUM ) , 5 ) ; "530"
1291
1292 OUTNL( S ) ; "535"
1293 CLOSE( S ) ; "536"
1294 END "OC CHECKSUM" ; "540"
1295 "PAGE" \f
1296 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
1297 " MAIN PROGRAM "
1298 "**********************************************************************"
1299
1300 BEGIN "10"
1301 OPEN( S_IN , 'OC(:0:)' , INPUT ); "20"
1302 OPEN( S_OUT, 'OC(:0:)' , OUTPUT ); "30"
1303 GET_OC_PARAMS( S_IN , S_OUT ) ; "40"
1304 CLOSE( S_IN); "50"
1305 CLOSE( S_OUT ) ; "60"
1306 IF PARAM[P].TAG = IDTYPE "62"
1307 THEN PARAM_INPUT_FILE := PARAM[ P ].ID "63"
1308 ELSE PARAM_INPUT_FILE := 'OC(:0:) ' ; "65"
1309 IF PARAM[S].TAG = IDTYPE "66"
1310 THEN PROM_INPUT_FILE := PARAM[S].ID "67"
1311 ELSE PROM_INPUT_FILE := 'OC(:0:) ' ; "69"
1312 OPEN( S_IN , PARAM_INPUT_FILE , INPUT ) ; "70"
1313 GET_DISC_PARAMS( S_IN ); "80"
1314 CLOSE( S_IN ) ; "90"
1315 CHECK_PARAMS ; "95"
1316 DEFINE_CONSTANTS ; "100"
1317 FOR I:=1 TO ( NO_OF_PROMS + NO_OF_PARITY_PROMS ) DO "110"
1318 BEGIN "120"
1319 OPEN( S_IN , PROM_INPUT_FILE , INPUT ); "130"
1320 OPEN( S_OUT , PROM[I].FILE , OUTPUT ) ; "140"
1321 PRINT_ID_RECORD( S_OUT , I ); "150"
1322 IF I <= NO_OF_PROMS "162"
1323 THEN EXTRACT_PROM( S_OUT , S_IN , I ) "164"
1324 ELSE EXTRACT_PARITY_PROM( S_OUT , I); "166"
1325 CLOSE( S_IN ) ; "170"
1326 CLOSE( S_OUT ) ; "180"
1327 OC_CHECKSUM( I ); "185"
1328 END; "190"
1329 END. "200"
SUMMARY
COMPILER RELEASE: 2
PROGRAM PART: 7363
DATA PART: 6407
PASCAL CODE SIZE: 7106
OVERLAY AREA SIZE: 0
SYSTEM AREA SIZE: 2820
LINE STATISTICS: 2660
SIZE OF CONSTANTS: 927
WORK AREA CLAIM: 25000
PROGRAM STATE: REENTRANT
"190"
1329 END. "200"
SUMMARY
COMPILER RELEASE: