!****************************************************************************** ******************************************************************************* P8000-Firmware (C) ZFT/KEAW Abt. Basissoftware - 1987 U8000-Softwaremonitor (MON16) Modul: p_term Bearbeiter: J. Zabel Datum: 27.01.1989 Version: 3.1 ******************************************************************************* ******************************************************************************! !============================================================================== Inhaltsuebersicht Modul p_term ------------------------------ Dieser Modul umfasst: - Routinen zur Terminalein- und -ausgabe, - Routinen zur Ein- und Ausgabe fuer den Dateitransfer von/zu UDOS ueber die 8-Bit-/16-Bit-Koppelschnittstelle, - Konvertierungsroutinen (Binaer <--> ASCII-Hexa) - Routinen zur Arbeit mit dem Eingabepuffer INBFF und dem Ausgabepuffer OUTBFF. Routinen, die direkte Eingaben von den Interrupt-Eingabepuffern PTYBFF/UDOSBFF bzw. direkte Ausgaben auf den Terminal-Kanal/Koppelschnittstelle durchfuehren, sind i.A. mit RD bzw. WR gekennzeichnet. Routinen, die Eingaben vom Eingabepuffer INBFF bzw. Ausgaben in den Ausgabepuffer OUTBFF durchfuehren, sind i.A. mit GET bzw. PUT gekennzeichnet. Prozeduren ---------- PTY_INT PTY_ERR KOPPEL_INT INCPTR TYRD TYWR TYRD_UDOS_INT TYRD_UDOS_POL TYWR_UDOS_INT TYWR_UDOS_POL TYWR_KOPPEL_INT TYWR_KOPPEL_POL KP_OUTB KP_INB TYRDWR RD_LINE_BFF RD_LINE_INBFF CLRCHR WR_CRLF WR_NULL WR_MSG WR_OUTBFF_CR WR_OUTBFF HTOB BTOH16 BTOH8 BTOH4 GET_CHR GET_SIGN GET_SIGNW GET_SGNR GET_HEXZ GET_ADR GET_PAR RD_DATA GET_DATA WR_R5_RDDATA WR_OBF_RDDATA PUT_CHR PUT_3C PUT_1CHR PUT_2CHR PUT_SEGNR PUT_SGNR ==============================================================================! p_term module $SECTION PROM !anfang mon16.include! !****************************************************************************** allgemeine Vereinbarungen (Stand: 27.01.1989) ******************************************************************************! !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ externe Prozeduren und Marken ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! EXTERNAL !INIT_CTC0_0 procedure Modul p_init! INIT_CTC0_1 procedure !Modul p_init! !INIT_SIO0_A procedure Modul p_init! INIT_SIO0_B procedure !Modul p_init! CMDLOP procedure !Modul p_init! ERROR procedure !Modul p_init! NMI_INT procedure !Modul p_init! PTY_INT procedure !Modul p_term! PTY_ERR procedure !Modul p_term! KOPPEL_INT procedure !Modul p_term! INCPTR procedure !Modul p_term! TYRD procedure !Modul p_term! TYWR procedure !Modul p_term! TYRD_UDOS_INT procedure !Modul p_term! TYRD_UDOS_POL procedure !Modul p_term! TYWR_UDOS_INT procedure !Modul p_term! TYWR_UDOS_POL procedure !Modul p_term! TYWR_KOPPEL_INT procedure !Modul p_term! TYWR_KOPPEL_POL procedure !Modul p_term! KP_OUTB procedure !Modul p_term! KP_INB procedure !Modul p_term! RD_LINE_BFF procedure !Modul p_term! RD_LINE_INBFF procedure !Modul p_term! WR_CRLF procedure !Modul p_term! WR_MSG procedure !Modul p_term! WR_OUTBFF_CR procedure !Modul p_term! WR_OUTBFF procedure !Modul p_term! HTOB procedure !Modul p_term! BTOH16 procedure !Modul p_term! BTOH8 procedure !Modul p_term! GET_CHR procedure !Modul p_term! GET_SIGN procedure !Modul p_term! GET_SIGNW procedure !Modul p_term! GET_SGNR procedure !Modul p_term! GET_HEXZ procedure !Modul p_term! GET_ADR procedure !Modul p_term! GET_PAR procedure !Modul p_term! RD_DATA procedure !Modul p_term! GET_DATA procedure !Modul p_term! WR_R5_RDDATA procedure !Modul p_term! WR_OBF_RDDATA procedure !Modul p_term! PUT_CHR procedure !Modul p_term! PUT_3C procedure !Modul p_term! PUT_2CHR procedure !Modul p_term! PUT_SEGNR procedure !Modul p_term! PUT_SGNR procedure !Modul p_term! DISPLAY procedure !Modul p_comm! COMPARE procedure !Modul p_comm! FILL procedure !Modul p_comm! MOVE procedure !Modul p_comm! PORT_READ procedure !Modul p_comm! PORT_WRITE procedure !Modul p_comm! PORT_READ_SPECIAL procedure !Modul p_comm! PORT_WRITE_SPECIAL procedure !Modul p_comm! HARD_DISK_READ procedure !Modul p_comm! HARD_DISK_WRITE procedure !Modul p_comm! FLOPPY_FORMAT procedure !Modul p_comm! FLOPPY_READ procedure !Modul p_comm! FLOPPY_WRITE procedure !Modul p_comm! REGISTER procedure !Modul p_brk! SAVREG procedure !Modul p_brk! BREAK procedure !Modul p_brk! GO procedure !Modul p_brk! GO_NXT procedure !Modul p_brk! NEXT procedure !Modul p_brk! RETI_CTC0_3 procedure !Modul p_brk! TEST_ procedure !Modul p_test! GET procedure !Modul p_gesa! SAVE procedure !Modul p_gesa! QUIT8 procedure !Modul p_gesa! QUIT8_RESET procedure !Modul p_gesa! FLOPPY procedure !Modul p.gesa! RM_GET procedure !Modul p_gesa! RM_SAVE procedure !Modul p_gesa! RM_QUIT procedure !Modul p_gesa! OS_BOOT procedure !Modul p_boot! AUTOBOOT procedure !Modul p_boot! DISK procedure !Modul p_disk! ! QUIT procedure Modul p_ldsd LOAD procedure Modul p_ldsd MCZ_INT procedure Modul p_ldsd MCZ_ERR procedure Modul p_ldsd TYWR_MCZ procedure Modul p_ldsd WOCF_MCZ procedure Modul p_ldsd SEND procedure Modul p_ldsd ! MON16_1H word !Modul p.crc! N_MON16_1H word !Modul p.crc! MON16_1L word !Modul p.crc! N_MON16_1L word !Modul p.crc! MON16_2H word !Modul p.crc! N_MON16_2H word !Modul p.crc! MON16_2L word !Modul p.crc! N_MON16_2L word !Modul p.crc! !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Werte aus dem Arbeitsspeicher (Modul p_ram) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! EXTERNAL RAM_ANF ARRAY [%10 WORD] NSP_OFF WORD ARRAY [%3F WORD] !Stackbereich! STACK WORD ARRAY [4 WORD] _numterm WORD !Anzahl der Terminals! PTYPORT BYTE !Terminalkanal: 00 - SIO0_B (16-Bit-Teil) 01 - SIO0_B (8-Bit-Teil) ueber Koppelschnittstelle! XEMPTY BYTE !fuer interruptgesyeuerten Terminal- betrieb ueber Koppelschnittstelle: 00 - Sendepuffer SIO0_B (8-Bit-Teil) leer FF - Sendepuffer SIO0_B (8-Bit-Teil) nicht leer! BYTE KONV BYTE !Hilfsbyte zur Konvertierung! INBFF ARRAY [%80 BYTE] !Eingabepuffer! OUTBFF ARRAY [%80 BYTE] !Ausgabepuffer! PTYBFF ARRAY [%100 BYTE] !Eingabepuffer fuer interrupt- gesteuerte Eingabe vom Terminal- kanal! MCZBFF ARRAY [%0EA BYTE] !Ein-/Ausgabepuffer fuer LOAD/SEND! MAXLEN WORD !maximale Zeilenlaenge! INPTR WORD !Zeiger fuer Eingabepuffer INBFF! OUTPTR WORD !Zeiger fuer Ausgabepuffer OUTBFF (Pufferlaenge)! COUNT_PTY WORD !aktuelle Anzahl der Zeichen in PTYBFF! INPTR_PTY WORD !Eingabezeiger fuer PTYBFF (naechster freier Platz)! OUTPTR_PTY WORD !Ausgabezeiger fuer PTYBFF (naechstes auszulesende Zeichen)! INPTR_MCZ WORD !Eingabezeiger fuer MCZBFF! OUTPTR_MCZ WORD !Ausgabezeiger fuer MCZBFF! B_WORD WORD !Speicherinhalt auf der BREAK-Adresse! B_ADR_S WORD !Segmentnummer der BREAK-Adresse! B_ADR_O WORD !Offset der BREAK-Adresse! RR14_V LONG !VARIABLER STACK, FUER NEXT UND BREAK! W23B4 WORD FCW_V WORD !VARIABLES FCW FUER NEXT UND BREAK! PORT_BF WORD !Puffer fuer gelesenen bzw. zu schreibenden PORT-Datenwert! PORT_IO WORD !Adresse des PORT-I/O-Programms! WORD !unbenutzt! SV_R ARRAY [14 WORD] !Registerrettungsbereich! SVSTK LONG PC_SEG WORD !Programmcounter (Segmentnummer)! PC_OFF WORD !Programmcounter (Offsetadresse)! FCW_ WORD !FCW im Registerrettungsbereich! RF_CTR WORD !Merker: Refresh Control Register! N4_ WORD !Normalstack R14! N5_ WORD !Normalstack R15! PS_ WORD !Program-Status-Area Segment! PO_ WORD !Program-Status-Area Offset! WORD !unbenutzt! !Flags! FLAG0 BYTE FLAG1 BYTE !Variablen (initialisiert bei Systemstart)! CHRDEL BYTE !Zeichen loeschen (Backspace %08)! LINDEL BYTE !Zeile loeschen (Line delete %7F)! XONCHR BYTE !Terminalausgabe fortsetzen (^Q %11)! XOFCHR BYTE !Terminalausgabe anhalten (^S %13)! NULLCT WORD !Anzahl der Nullen nach CR bei Terminalausgabe (%0000)! B_CODE WORD !Unterbrechungscode Z8000 (7F00)! STKCTR WORD !Zaehler der Stackoperationen fuer NEXT (%0004)! NXTCTR WORD !SCHRITTZAEHLER FUER NEXT (%0001)! PROMT WORD !Promt-Zeichen (%2000)! !---------------------------------------------------! !Program Status Area (initialisiert bei Systemstart)! PSAREA ! ID FCW PCSEG PCOFF! ARRAY [4 WORD] !:= [%0000 %0000 %0000 %0000] RESERVED! ARRAY [4 WORD] !:= [%0000 %4000 %8000 VI_ERR] UNIMLEMENTED INSTRUCTIONS! ARRAY [4 WORD] !:= [%0000 %4000 %8000 VI_ERR] PRIVILEGED INSTRUCTIONS! PSA_SC ARRAY [4 WORD] !:= [%0000 %C000 %8000 SC_ENTRY] SYSTEM_CALL INSTRUCTIONS! ARRAY [4 WORD] !:= [%0000 %4000 %8000 MMU_ERR] SEGMENT TRAP! PSA_NMI ARRAY [4 WORD] !:= [%0000 %4000 %8000 AUTOBOOT bzw. NMI_INT] NONMASKABLE INTERRUPT (AUTOBOOT vor erster Terminaleingabe; NMI_INT nach erster Terminaleingabe)! ARRAY [4 WORD] !:= [%0000 %4000 %8000 VI_ERR] NONVECTORED INTERRUPT! ! VECTORED INTERRUPT! ARRAY [2 WORD] !:= [%0000 %4000] VECTORED INTERRUPT (ID, FCW)! ! VI - Sprung-Tabelle (128 Eintraege) ! ! SEG OFFSET! !CTC0! VI_CTC0_0 ARRAY [2 WORD] !:= [%8000 VI_ERR] ! VI_CTC0_1 ARRAY [2 WORD] !:= [%8000 VI_ERR] ! VI_CTC0_2 ARRAY [2 WORD] !:= [%8000 VI_ERR] ! VI_CTC0_3 ARRAY [2 WORD] !:= [%8000 VI_ERR bzw. GO_INT bzw. NXT_INT] fuer GO bzw. NEXT! !PIO1! VI_PIO1_B ARRAY [2 WORD] !:= [%8000 KOPPEL_INT] VI Zeichen empfangen (von Koppelschnittstelle)! ARRAY [2 WORD] !:= [%8000 VI_ERR] ! ARRAY [2 WORD] !:= [%8000 VI_ERR] ! ARRAY [2 WORD] !:= [%8000 VI_ERR] ! !SIO0! VI_SIO0_B ARRAY [2 WORD] !:= [%8000 VI_ERR] ! ARRAY [2 WORD] !:= [%8000 VI_ERR] ! ARRAY [2 WORD] !:= [%8000 PTY_INT] VI Zeichen empfangen (fuer Terminaleingabe)! ARRAY [2 WORD] !:= [%8000 PTY_ERR] VI Empfangssonderfall (fuer Empfangsfehler)! VI_SIO0_A ARRAY [2 WORD] !:= [%8000 VI_ERR] ! ARRAY [2 WORD] !:= [%8000 VI_ERR] ! ARRAY [2 WORD] !:= [%8000 VI_ERR] (vorher MCZ_INT) VI Zeichen empfangen (fuer MCZ-Eingabe)! ARRAY [2 WORD] !:= [%8000 VI_ERR] (vorher MCZ_ERR) VI Empfangssonderfall (fuer Empfangsfehler)! ! Rest der 128 Eintraege der VI-Sprung-Tabelle! VI_TAB_REST ARRAY [224 WORD] !:= [%8000 VI_ERR] ! !---------------------------------------------------! !Arbeitsspeicher fuer Kommando "T" (Hardwareeigentest)! RG_FELD ARRAY [%1A WORD] !Feld zur Registerrettung! REM_MMU_BCSR BYTE !Merker: Inhalt BUS CYCLE STATUS REGISTER! REM_MMU_VTR BYTE !Merker: Inhalt VIOLATION TYPE REGISTER! REM_MMU_ID WORD !Merker: MMU-Identifikation! REM_ERR_CNT WORD !Merker: Stand Fehlerzaehler! REM_SEGMENT_TRAP WORD !Merker: urspruengliche Offsetadresse fuer Segmenttrap! REM_PRIVINSTR_TRAP WORD !Merker: urspruengl. Offsetadr. fuer Priv.-Instr.-Trap! REM_MMU_SINOUT WORD !Merker: MMU-Ein-/Ausgabewerte! ERR_CNT WORD !Fehlerzaehler! ERR_WDC WORD !Fehlerzaehler fuer WDC-Test! MAX_SEGNR WORD !Merker: hoechste vorhandene Segmentnummer! REM_PARNMI WORD !Merker: Paritaets-NMI aufgetreten (%0000-->nein / %FFFF-->ja)! ERRPAR_ID WORD !Spezifizierung der 4 Parameter der auszugebenden Fehlerzeile (Prozedur MSG_ERROR)! REM_MMU1 WORD REM_MMU2 WORD REM_INT WORD !Merker: Interrupt aufgetreten (0-->nein)! REM_WDC1 WORD !Speicherplatz fuer Testdatenwert! REM_WDC2 WORD !Speicherplatz fuer rueckgelesenen datenwert! !Arbeitsspeicher fuer Kommandos "GE"/"S"/"O U" und Floppytreiber! FILENAME_PTR WORD !Anfangsadresse Dateiname! COUNT_UDOS WORD !akt. Anzahl der Zeichen in UDOSBFF! INPTR_UDOS WORD !Eingabezeiger fuer UDOSBFF (naechster freier Platz)! OUTPTR_UDOS WORD !Ausgabezeiger fuer UDOSBFF naechstes auszulesende Zeichen)! UDOSBFF ARRAY [%100 BYTE] !Eingabepuffer fuer interrupt- gesteuerte Eingabe bei Dateitransfer von/zu UDOS bzw. Blocktransfer! !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ System Calls ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! CONSTANT SC_SEGV := %01 !Modul p.term! SC_NSEGV := %02 !Modul p.term! SC_TYRD := %04 !Modul p.term! SC_TYWR := %06 !Modul p.term! SC_RD_LINE_BFF := %08 !Modul p.term! SC_WR_CRLF := %0A !Modul p.term! SC_WR_MSG := %0C !Modul p.term! SC_BTOH16 := %0E !Modul p.term! SC_WR_OUTBFF_CR := %10 !Modul p.term! SC_BTOH8 := %12 !Modul p.term! SC_PUT_SEGNR := %14 !Modul p.term! SC_PUT_CHR := %16 !Modul p.term! ! SC_WOCF_MCZ := %18 Modul p.ldsd SC_TYWR_MCZ := %1A Modul p.ldsd ! SC_CMDLOP := %1C !Modul p.init! SC_DISK := %1E !Modul p.disk! SC_TYRD_UDOS_INT := %20 !Modul p.term! SC_TYWR_UDOS_INT := %22 !Modul p.term! SC_FLOPPY := %24 !Modul p.gesa! SC_WR_OUTBFF := %26 !Modul p.term! !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ spezielle ASCII-Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! CONSTANT SOH := %01 STX := %02 ETX := %03 EOT := %04 ACK := %06 BEL := %07 BS := %08 LF := %0A CR := %0D NAK := %15 CAN := %18 ESC := %1B !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Hardwareadressen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! CONSTANT !8-Bit-Teil! SIO0D_B_8 := %26 !SIO fuer Terminal! SIO0C_B_8 := %27 !16-Bit-Teil! SIO0 := %FF81 !Kanal A (XB1/TTY4): unbenutzt (vorher LOAD/SEND/QUIT); Kanal B (XB2/TTY5): Terminal, wenn 8-Bit-Teil inaktiv! SIO0D_A := SIO0 + 0 SIO0D_B := SIO0 + 2 SIO0C_A := SIO0 + 4 SIO0C_B := SIO0 + 6 SIO1 := %FF89 !Kanal A (XB3/TTY6): unbenutzt Kanal B (XB4/TTY7): unbenutzt! SIO1D_A := SIO1 + 0 SIO1D_B := SIO1 + 2 SIO1C_A := SIO1 + 4 SIO1C_B := SIO1 + 6 PIO0 := %FF91 !Koppel-PIO zum 8-Bit-Teil fuer Terminal und Kommandos "GE", "S", "Q", "QRES", "O U" und Floppytreiber Kanal A: Datenausgabe Kanal B: Statusausgabe/Steuerport! PIO0D_A := PIO0 + 0 PIO0D_B := PIO0 + 2 PIO0C_A := PIO0 + 4 PIO0C_B := PIO0 + 6 PIO1 := %FF99 !Koppel-PIO zum 8-Bit-Teil fuer Terminal und Kommandos "GE", "S", "Q", "QRES", "O U" und Floppytreiber Kanal A: Dateneingabe Kanal B: Statuseingabe/Steuerport! PIO1D_A := PIO1 + 0 PIO1D_B := PIO1 + 2 PIO1C_A := PIO1 + 4 PIO1C_B := PIO1 + 6 PIO2 := %FFA1 !(XB5): Winchester Kanal A: Datenein-/-ausgabe; Kanal B: Steuerport! PIO2D_A := PIO2 + 0 PIO2D_B := PIO2 + 2 PIO2C_A := PIO2 + 4 PIO2C_B := PIO2 + 6 CTC0 := %FFA9 CTC0_0 := CTC0 + 0 ! Baud 0 - SIO0, Kanal A! CTC0_1 := CTC0 + 2 ! Baud 1 - SIO0, Kanal B! CTC0_2 := CTC0 + 4 ! Baud 2 - SIO1, Kanal A! CTC0_3 := CTC0 + 6 ! Next ! CTC1 := %FFB1 CTC1_0 := CTC1 + 0 ! Baud 3 - SIO1, Kanal B! CTC1_1 := CTC1 + 2 CTC1_2 := CTC1 + 4 CTC1_3 := CTC1 + 6 LON := %FFD9 !RUN16-Lampe ein! LOFF := %FFB9 !RUN16-Lampe aus! S_BNK := %FFC1 !SWITCH-BANK: Bit0-3 Ausgabebits; Bit4-7 Eingabebits (DIL-Schalter): Bit 0: =0 - Monitor PROM+RAM einschalten =1 - Monitor PROM+RAM ausschalten Bit 1: =0 - MMU's ausschalten; =1 - MMU's einschalten Bit 2: Seg. Usr. Bit 3: =0 - Paritaetspruefung ausgeschaltet bzw. Paritaetsfehler loeschen =1 - Paritaetspruefung eingeschaltet Bit 5,4: Baudrate Terminal (unbenutzt) Bit 7,6: Autoboot Device (unbenutzt)! SBREAK := %FFC9 !System Break Register! NBREAK := %FFD1 !Normal Break Register! RETI_P := %FFE1 !RETI-Port fuer Schaltkreise des U880-Systems! ALL_MMU := %F0 STACK_MMU := %F6 DATA_MMU := %FA CODE_MMU := %FC !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Moegliche Statusausgaben an 8-Bit-Teil von 16-Bit-Teil fuer 8-Bit-/16-Bit-Koppelschnittstelle (PIO0_B) (INT8-Bit jeweils = 0) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! CONSTANT STAT8_ENDE := %00 !Ende eines Write-Requests! STAT8_READ := %02 !Read-Request an einen Peripheriebaustein 8-Bit-Teil! STAT8_WRITE := %04 !Write-Request an einen Peripheriebaustein 8-Bit-Teil! STAT8_UDOS := %10 !Datenbyte ist Bestandteil eines Dateitransfers bzw. eines Blocktransfers von/zu UDOS! STAT8_QUIT := %1E !Rueckkehr zum 8-Bit-Teil (Datenbyte "Q" oder "R")! !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Moegliche Statuseingaben von 8-Bit-Teil an 16-Bit-Teil fuer 8-Bit-/16-Bit-Koppelschnittstelle (PIO1_B) (INT16-Bit jeweils = 0) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! CONSTANT STAT16_ENDE := %00 !Beantwortung eines Read-Requests! STAT16_SIO0_B_R := %04 !REC INT (SIO0_B-Empfaengerinterrupt)! STAT16_SIO0_B_X := %24 !TRANS INT (SIO0_B-Interrupt Sendepuffer leer)! STAT16_SIO0_B_E := %44 !EXT STAT INT (SIO0_B-Externer-Statusinterrupt)! STAT16_SIO0_B_S := %64 !SPEC REC INT (SIO0_B-Interrupt Empfangssonderfall)! STAT16_UDOS := %10 !Datenbyte ist Bestandteil eines Dateitransfers bzw. eines Blocktransfers von/zu UDOS! !ende mon16.include! !****************************************************************************** Prozeduren ******************************************************************************! !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE PTY_INT VI-Routine fuer Dateneingabe vom Terminalkanal SIO0_B des 16-Bit-Teils; Abspeicherung des Zeichens im Interrupt-Eingabepuffer PTYBFF; Aktualisierung von INPTR_PTY und COUNT_PTY; Test auf Sonderzeichen (^S, ^Q, ESC) bei Terminaleingaben ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL PTY_INT procedure entry push @r15, r0 push @r15, r1 push @r15, r2 !bei erster TerminaleingabeNMI-Entry in PSAREA aendern und PROMT setzen! cp PSA_NMI+6, #AUTOBOOT !NMI_ENTRY in PSAREA: - nach RESET steht dort #AUTOBOOT, d.h. bei NMI erfolgt Abarbeitung von #AUTOBOOT - nach Eingabe des ersten Zeichens vom Terminal (Abarbeitung von PTY_INT oder KOPPEL_INT) bzw. nach Abarbeitung von #AUTOBOOT wird #AUTOBOOT durch #NMI_INT ersetzt, d.h. bei NMI erfolgt jetzt Abarbeitung von #NMI_INT ! jr nz, PTY_RD ld PROMT, #'* ' !Promt-Zeichen eintragen (d.h. die Zelle PROMT wird erst nach der 1. Zeicheneingabe geladen)! ld PSA_NMI+6, #NMI_INT !#AUTOBOOT durch #NMI_INT ersetzen in PSAREA! !Zeichen vom SIO einlesen! PTY_RD: inb rl1, SIO0D_B !Zeichen vom SIO einlesen! !Test, ob eingelesenes Zeichen vom Terminalkanal als ASCII-Zeichen oder als beliebiges Datenbyte zu interpretieren ist! bitb FLAG0, #%00 jr nz, PTY_WR !keine ASCII-Zeichen einzulesen --> Zeichen in PTYBFF abspeichern! resb rl1, #%07 !RES BIT7 DES ASCII-ZEICHENS! !Test auf ^Q! cpb rl1, XONCHR !Test auf ^Q (Terminalausgabe nicht gesperrt)! jr nz, PTY1 !Zeichen nicht ^Q! resb FLAG0, #%02 !Bit2/FLAG0=0: Terminalausgabe nicht gesperrt! jr PTYEND !Test auf ^S! PTY1: cpb rl1, XOFCHR !Test auf ^S (Terminalausgabe gesperrt)! jr nz, PTY2 !Zeichen nicht ^S! setb FLAG0, #%02 !Bit2/FLAG0=1: Terminalausgabe nicht gesperrt! jr PTYEND !Test auf ESC! PTY2: cpb rl1, #ESC !Test auf ESC (Abbruchtaste)! jr nz, PTY_WR !Zeichen nicht ESC! bitb FLAG0, #%03 !wenn Bit3/FLAG0 und Bit4/FLAG0 = 0, dann wird ESC als normales ASCII-Zeichen in PTYBFF abgespeichert und nicht als Abbruchtaste behandelt! jr nz, PTY3 bitb FLAG0, #%04 jr z, PTY_WR !ESC in PTYBFF eintragen! !ESC als Abbruchtaste behandeln! PTY3: setb FLAG0, #%05 !Bit5/FLAG0=1: Abbruchtaste gedrueckt! jr PTYEND !Zeichen in PTYBFF abspeichern! PTY_WR: ld r0, INPTR_PTY calr INCPTR !r2:=r0; r0:=ro+1! ld INPTR_PTY, r0 !incr Eingabezeiger (Zeiger zum naechsten freien Platz in PTYBFF)! ldb PTYBFF(r2), rl1 !Zeichen in PTYBFF abspeichern! incb COUNT_PTY, #%01 !Zeichenzaehler incr.! !SIO ruecksetzen! PTYEND: ldb rl1, #%38 !RETI an SIO ausgeben! outb SIO0C_A, rl1 pop r2, @r15 pop r1, @r15 pop r0, @r15 sc #SC_SEGV nop iret end PTY_INT !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE PTY_ERR VI-Routine fuer Empfangsfehler von Terminalkanal SIO0_B des 16-Bit-Teils ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL PTY_ERR procedure entry push @r15, r1 ldb rl1, #%30 outb SIO0C_B, rl1 !SIO-Error-Reset! ldb rl1, #%38 outb SIO0C_A, rl1 !RETI an SIO senden! pop r1, @r15 sc #SC_SEGV iret end PTY_ERR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE KOPPEL_INT VI-Routine fuer Dateneingabe von Koppelschnittstelle PIO1 von Terminalkanal SIO0_B des 8-Bit Teils bzw. bei Datei-/Blocktransfer von/zu UDOS; Abspeicherung des Zeichens im Interrupt-Eingabepuffer PTYBFF bzw. UDOSBFF; Aktualisierung von INPTR_PTY/COUNT_PTY bzw. INPTR_UDOS/COUNT_UDOS; Test auf Sonderzeichen (^S, ^Q, ESC) bei Terminaleingaben ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL KOPPEL_INT procedure entry push @r15, r0 push @r15, r1 push @r15, r2 !Warten, bis Datenbyte anliegt! KP_0: inb rl1, PIO0D_B bitb rl1, #5 !DATEN DA?! jr nz, KP_0 !nein! !Status/Datenbyte von Koppelschnittstelle einlesen! inb rh1, PIO1D_B !Statuseingabe! andb rh1, #%7E !Statusbits sind Bit1-6! inb rl1, PIO1D_A !Dateneingabe! !Statusauswertung! cpb rh1, #STAT16_SIO0_B_R !REC INT! !(SIO0_B_8 Empfaengerinterrupt)! jr z, KOPPEL_PTY !Datenbyte fuer PTY_BFF! cpb rh1, #STAT16_SIO0_B_X !TRANS INT! jr nz, KP_1 !(SIO0_B_8 Interrupt Sendepuffer leer)! ldb XEMPTY, #0 !Kennzeichnung: Sendepuffer leer! jr KOPPEL_END KP_1: cpb rh1, #STAT16_SIO0_B_E !EXT STAT INT! jr z, KOPPEL_END !(SIO0_B_8 externer Status-Interrupt)! cpb rh1, #STAT16_SIO0_B_S !SPEC REC COND INT! jr z, KOPPEL_END !(SIO0_B_8 Int. Empfangssonderfall)! cpb rh1, #STAT16_UDOS !Dateitransfer bzw. Blocktransfer! jr z, KOPPEL_UDOS !Datenbyte fuer UDOS_BFF! jr KOPPEL_END !falscher Status --> Zeichen wird uebergangen! !*** Datenbyte kam vom Terminal und ist in PTY_BFF abzuspeichern ***! KOPPEL_PTY: !bei erster Terminaleingabe NMI-Entry in PSAREA aendern und PROMT setzen! cp PSA_NMI+6, #AUTOBOOT !NMI_ENTRY in PSAREA: - nach RESET steht dort #AUTOBOOT, d.h. bei NMI erfolgt Abarbeitung von #AUTOBOOT - nach Eingabe des ersten Zeichens vom Terminal (Abarbeitung von PTY_INT oder KOPPEL_INT) bzw. nach Abarbeitung von #AUTOBOOT wird #AUTOBOOT durch #NMI_INT ersetzt, d.h. bei NMI erfolgt jetzt Abarbeitung von #NMI_INT ! jr nz, KP_PTY_0 ld PROMT, #'* ' !Promt-Zeichen eintragen (d.h. die Zelle PROMT wird erst nach der 1. Zeicheneingabe geladen)! ld PSA_NMI+6, #NMI_INT !#AUTOBOOT durch #NMI_INT ersetzen in PSAREA! !Test, ob eingelesenes Zeichen vom Terminalkanal als ASCII-Zeichen oder als beliebiges Datenbyte zu interpretieren ist! KP_PTY_0: bitb FLAG0, #%00 jr nz, KP_PTY_WR !keine ASCII-Zeichen einzulesen --> Zeichen in PTYBFF abspeichern! resb rl1, #%07 !RES BIT7 DES ASCII-ZEICHENS! !Test auf ^Q! cpb rl1, XONCHR !Test auf ^Q (Terminalausgabe nicht gesperrt)! jr nz, KP_PTY_1 !Zeichen nicht ^Q! resb FLAG0, #%02 !Bit2/FLAG0=0: Terminalausgabe nicht gesperrt! jr KOPPEL_END !Test auf ^S! KP_PTY_1: cpb rl1, XOFCHR !Test auf ^S (Terminalausgabe gesperrt)! jr nz, KP_PTY_2 !Zeichen nicht ^S! setb FLAG0, #%02 !Bit2/FLAG0=1: Terminalausgabe nicht gesperrt! jr KOPPEL_END !Test auf ESC! KP_PTY_2: cpb rl1, #ESC !Test auf ESC (Abbruchtaste)! jr nz, KP_PTY_WR !Zeichen nicht ESC! bitb FLAG0, #%03 !wenn Bit3/FLAG0 und Bit4/FLAG0 = 0, dann wird ESC als normales ASCII-Zeichen in PTYBFF abgespeichert und nicht als Abbruchtaste behandelt! jr nz, KP_PTY_3 bitb FLAG0, #%04 jr z, KP_PTY_WR !ESC in PTYBFF eintragen! !ESC als Abbruchtaste behandeln! KP_PTY_3: setb FLAG0, #%05 !Bit5/FLAG0=1: Abbruchtaste gedrueckt! jr KOPPEL_END !Zeichen in PTYBFF abspeichern! KP_PTY_WR: ld r0, INPTR_PTY calr INCPTR !r2:=r0; r0:=r0+1! ld INPTR_PTY, r0 !incr Eingabezeiger (Zeiger zum naechsten freien Platz in PTYBFF)! ldb PTYBFF(r2), rl1 !Zeichen in PTYBFF abspeichern! incb COUNT_PTY, #%01 !Zeichenzaehler incr! jr KOPPEL_END !*** Datenbyte kam vom Dateitransfer bzw. Blocktransfer von/zu UDOS und ist in UDOS_BFF abzuspeichern ***! KOPPEL_UDOS: !Zeichen in UDOSBFF abspeichern! ld r0, INPTR_UDOS calr INCPTR !r2:=r0; r0:=r0+1! ld INPTR_UDOS, r0 !incr Eingabezeiger (Zeiger zum naechsten freien Platz in UDOSBFF)! ldb UDOSBFF(r2), rl1 !Zeichen in UDOSBFF abspeichern! incb COUNT_UDOS, #%01 !Zeichenzaehler incr! jr KOPPEL_END KOPPEL_END: !U880-RETI (ED4D) an PIO ausgeben! ldb rl1, #%ED outb RETI_P, rl1 ldb rl1, #%4D outb RETI_P, rl1 pop r2, @r15 pop r1, @r15 pop r0, @r15 sc #SC_SEGV nop iret end KOPPEL_INT !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE INCPTR Pufferzeiger (der Puffer PTYBFF bzw. UDOSBFF) inkrementieren und auf Ueberlauf testen Input: r0 - Pufferzeiger Output: r2 := r0 (alter Stand des Pufferzeigers) r0 := r0 + 1, wenn C=1, d.h. r0+1 < 256 r0 := 0, wenn C=0, d.h. r0+1 >= 256 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL INCPTR procedure entry ld r2, r0 inc r0, #%01 cp r0, #%0100 ret c clr r0 ret end INCPTR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYRD Einlesen eines Zeichens aus Interrupt-Eingabepuffer PTYBFF Output: rl0 - eingelesenes Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL TYRD procedure entry outb LOFF, rl0 !RUN16-Lampe aus! TYRD1: testb COUNT_PTY !Zeichen in PTYBFF vorhanden?! jr z, TYRD1 !nein --> warten bis Zeichen empfangen wird! push @r15, r2 ld r0, OUTPTR_PTY calr INCPTR !Ausgabezeiger fuer PTYBFF incr.! ld OUTPTR_PTY, r0 ldb rl0, PTYBFF(r2) !rl0 := Zeichen aus PTYBFF! decb COUNT_PTY, #%01 !Zeichenzaehler decr.! pop r2, @r15 outb LON, rl0 !RUN16-Lampe ein! ret end TYRD !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYWR Ausgabe eines Zeichens auf Terminalkanal (im Pollingbetrieb - Interruptbetrieb moeglich) (ueber Koppelschnittstelle PIO0 (an SIO0_B des 8-Bit-Teils) bzw. ueber SIO0_B des 16-Bit-Teils) Input: rl0 - Zeichen Output: Z=1, wenn Zeichen = CR ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL TYWR procedure entry push @r15, r0 testb PTYPORT jr nz, TYWR_PIO !Terminalbetrieb ueber Koppelschnittstelle! !Ausgabe ueber SIO0_B! TYWR_SIO: bitb FLAG0, #%02 !Terminal gesperrt?! jr nz, TYWR_SIO !ja! inb rh0, SIO0C_B bitb rh0, #%02 !Sendepuffer leer?! jr z, TYWR_SIO !nein! outb SIO0D_B, rl0 !Datenbyte ausgeben! jr TYWR_END !Ausgabe ueber Koppelschnittstelle (PIO0) an SIO0_B des 8-Bit-Teils! TYWR_PIO: bitb FLAG0, #%02 !Terminal gesperrt?! jr nz, TYWR_PIO !ja! !Test, ob Sendepuffer SIO0_B des 8-Bit-Teils leer ist! ! 1. bei Interruptbetrieb! ! testb XEMPTY |Sendepuffer leer? (XEMPTY wird in KOPPEL_INT auf %00 gesetzt wenn Int. "Sendepuffer leer" erfolgte)| jr nz, TYWR_PIO |nein| ! ! 2. bei Pollingbetrieb! ldb rl0, #SIO0C_B_8 !Adresse SIO0C_B auf 8-Bit-Teil! calr KP_INB !rh0 := eingelesenes Byte von SIO0C_B! bitb rh0, #%02 !Sendepuffer leer?! jr z, TYWR_PIO !nein! !Datenbyte an SIO0D_B des 8-Bit-Teils ausgeben! ldb XEMPTY, #%FF !Kennzeichnung: Sendepuffer nicht leer! pop r0, @r15 push @r15, r0 ldb rh0, rl0 !rh0:=auszugebendes Zeichen! ldb rl0, #SIO0D_B_8 !Adresse SIO0D_B auf 8-Bit-Teil! calr KP_OUTB TYWR_END: pop r0, @r15 cpb rl0, #CR !Z=1, wenn Zeichen CR war! ret end TYWR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYRD_UDOS_INT Einlesen eines Zeichens von Dateitransfer von/zu UDOS bzw. Floppy-Blocktransfer aus Interrupt-Eingabepuffer UDOSBFF (Status STAT16_UDOS) Output: rl0 - eingelesenes Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL TYRD_UDOS_INT procedure entry testb COUNT_UDOS !Zeichen in UDOSBFF vorhanden?! jr z, TYRD_UDOS_INT !nein --> warten bis Zeichen empfangen wird! push @r15, r2 ld r0, OUTPTR_UDOS calr INCPTR !Ausgabezeiger fuer UDOSBFF incr.! ld OUTPTR_UDOS, r0 ldb rl0, UDOSBFF(r2) !rl0 := Zeichen aus UDOSBFF! decb COUNT_UDOS, #%01 !Zeichenzaehler decr.! pop r2, @r15 ret end TYRD_UDOS_INT !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYRD_UDOS_POL Einlesen eines Zeichens von Dateitransfer von/zu UDOS bzw. Floppy-Blocktransfer im Polling (Status STAT16_UDOS) Output: rl0 - eingelesenes Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL TYRD_UDOS_POL procedure entry di vi inb rh0, PIO0D_B bitb rh0, #5 !DATEN DA?! jr nz, TYRD_UDOS_POL !nein! inb rh0, PIO1D_B !Statuseingabe! andb rh0, #%7E cpb rh0, #STAT16_UDOS jr nz, TYRD_UDOS_POL !falscher Status! inb rl0, PIO1D_A !Dateneingabe! ei vi ret end TYRD_UDOS_POL !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYWR_UDOS_INT Ausgabe eines Zeichens fuer Dateitransfer von/zu UDOS bzw. Floppy-Blocktransfer (ueber Koppelschnittstelle PIO0) --- mit Interruptausloesung auf 8-Bit-Teil (INT8-Bit=1) --- Input: rl0 - Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL TYWR_UDOS_INT procedure entry di vi ldb rh0, #STAT8_UDOS !Status! calr TYWR_KOPPEL_INT !Zeichen+Status/INT8 an Koppelschnittstelle senden! ei vi ret end TYWR_UDOS_INT !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYWR_UDOS_POL Ausgabe eines Zeichens fuer Dateitransfer von/zu UDOS bzw. Floppy-Blocktransfer (ueber Koppelschnittstelle PIO0) --- ohne Interruptausloesung auf 8-Bit-Teil (INT8-Bit=0) --- Input: rl0 - Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL TYWR_UDOS_POL procedure entry di vi ldb rh0, #STAT8_UDOS !Status! calr TYWR_KOPPEL_POL !Zeichen+Status an Koppelschnittstelle senden! ei vi ret end TYWR_UDOS_POL !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYWR_KOPPEL_INT allgemeine Ausgabe eines Zeichens und zugehoerigen Status an 8-Bit-/16-Bit-Koppelschnittstelle (PIO0) --- mit Interruptausloesung auf 8-Bit-Teil (INT8-Bit=1) --- Input: rl0 - Zeichen rh0 - Status ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL TYWR_KOPPEL_INT procedure entry push @r15, r0 TKI1: inb rh0, PIO0D_B bitb rh0, #%06 !ENABLE OUTPUT?! jr nz, TKI1 !nein! outb PIO0D_A, rl0 !Datenbyte ausgeben! pop r0, @r15 resb rh0, #0 !Bit0=0: INT8-Bit auf 0 setzen! outb PIO0D_B, rh0 setb rh0, #0 !Bit0=1: INT8-Bit auf 1 setzen! outb PIO0D_B, rh0 !INT8/Status ausgeben! ret end TYWR_KOPPEL_INT !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYWR_KOPPEL_POL allgemeine Ausgabe eines Zeichens und zugehoerigen Status an 8-Bit-/16-Bit-Koppelschnittstelle (PIO0) --- ohne Interruptausloesung auf 8-Bit-Teil (INT8-Bit = 0) --- Input: rl0 - Zeichen rh0 - Status ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL TYWR_KOPPEL_POL procedure entry push @r15, r0 TKP1: inb rh0, PIO0D_B bitb rh0, #%06 !ENABLE OUTPUT?! jr nz, TKP1 !nein! pop r0, @r15 resb rh0, #0 !Bit0=0: INT8-Bit auf 0 setzen! outb PIO0D_B, rh0 !Status ausgeben! outb PIO0D_A, rl0 !Datenbyte ausgeben! ret end TYWR_KOPPEL_POL !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE KP_OUTB Ausgabe eines Bytes an einen I/O-Port des 8-Bit-Teils (ueber 8-Bit-/16-Bit-Koppelschnittstelle (PIO0)) Input: rl0 - Portadresse rh0 - auszugebendes Datenbyte ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL KP_OUTB procedure entry di vi push @r15, r0 ldb rh0, #STAT8_WRITE calr TYWR_KOPPEL_INT !Portadresse und Write-Status ausgeben! pop r0, @r15 push @r15, r0 ldb rl0, rh0 !auszugebendes Datenbyte! ldb rh0, #STAT8_ENDE !Ende-Status! calr TYWR_KOPPEL_POL !Datenbyte und Ende-Status ausgeben! pop r0, @r15 ei vi ret end KP_OUTB !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE KP_INB Eingabe eines Bytes von einem I/O-Port des 8-Bit-Teils (ueber 8-Bit-/16-Bit-Koppelschnittstelle (PIO1)) Input: rl0 - Portadresse Output: rh0 - eingelesenes Datenbyte ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL KP_INB procedure entry di vi ldb rh0, #STAT8_READ calr TYWR_KOPPEL_INT !Portadresse und Read-Status ausgeben! KPINB1: inb rh0, PIO0D_B bitb rh0, #5 !DATEN DA?! jr nz, KPINB1 !nein! inb rh0, PIO1D_B !Status-Eingabe! andb rh0, #%7E cpb rh0, #STAT16_ENDE jr nz, KPINB1 inb rh0, PIO1D_A !eingelesenes Datenbyte! ei vi ret end KP_INB !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE TYRDWR Einlesen eines Zeichens aus Interrupt-Eingabepuffer (PTYBFF) und Ausgabe auf Terminal Output: rl0 - eingelesenes Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! INTERNAL TYRDWR procedure entry calr TYRD calr TYWR ret end TYRDWR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE RD_LINE_BFF Zeile aus Interrupt-Eingabepuffer PTYBFF lesen, in Zwischenpuffer abspeichern und auf Terminal ausgeben Input: r1 - max. Zeilenlaenge r2 - Anfangsadresse Zwischenpuffer Output: r1 - Anzahl der uebertragenen Zeichen r2 - zeigt auf Zeilenende Z=1, wenn max. Zeilenlaenge erreicht wurde ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL RD_LINE_BFF procedure entry ld MAXLEN, r1 RDL_NEU: clr r1 RDL_LOOP: calr TYRDWR !ZEICHEN LESEN UND AUSGEBEN! bitb FLAG1, #%03 !NUR GROSSBUCHSTABEN ERLAUBT ?! jr nz, RDL_TST !nein! cpb rl0, #'a' jr c, RDL_TST cpb rl0, #'{' jr nc, RDL_TST resb rl0, #%05 !KLEINBUCHST. IN GROSSBUCHST. WANDELN ! RDL_TST: ldb r2(r1), rl0 !Zeichen in Zwischenpuffer abspeichern! cpb rl0, CHRDEL jr z, _CL cpb rl0, LINDEL jr z, _CR cpb rl0, #CR jr z, RDL_END inc r1, #%01 cp r1, MAXLEN !MAXIMALE ZEILENLAENGE ERREICHT ?! JR C,RDL_LOOP !SPRUNG WENN NICHT! setflg z ret _CL: calr CLRCHR jr pl, RDL_LOOP ldb rl0, PROMT !PROMT-Zeichen wurde durch CHRDEL geloescht --> PROMT-Zeichen neu ausgeben! calr TYWR jr RDL_NEU !ZEILE NEU EINGEBEN! _CR: test r1 !EINGEGEBEN ZEICHENKETTE LOESCHEN! jr z, RDL_LOOP ldb rl0, #BS calr TYWR calr CLRCHR jr _CR RDL_END: ldb rl0, #LF calr TYWR lda r2, r2(r1) !R2 AUF Zeilenende STELLEN! resflg z ret end RD_LINE_BFF !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE RD_LINE_INBFF Einlesen einer Kommandozeile bis CR aus Interrupt-Eingabepuffer (PTYBFF) in Eingabepuffer (INBFF) und Ausgabe auf Terminal Output: rl0 - 1. Zeichen der Eingabezeile ungleich Space INPTR zeigt auf dieses Zeichen Z=1, wenn dieses Zeichen = CR Fehler, wenn Zeile laenger als 128 Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL RD_LINE_INBFF procedure entry ld r2, #INBFF ld r1, #%80 !MAXLEN LADEN! ld INPTR, #0 !EINGABEZEIGER LOESCHEN! calr RD_LINE_BFF !Zeile aus PTYBFF in INBFF speichern und auf Terminal ausgeben! jp z, ERROR !Pufferende erreicht! calr GET_SIGNW !rl0:=1.Zeichen aus INBFF ungleich Space! dec INPTR, #%01 !INPTR zeigt auf dieses Zeichen! cpb rl0, #CR !Z=1, wenn Zeichen = CR! ret end RD_LINE_INBFF !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE CLRCHR Loeschen eines Zeichens ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! INTERNAL CLRCHR procedure entry ldb rl0, #' ' calr TYWR ldb rl0, #BS calr TYWR dec r1, #%01 ret end CLRCHR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE WR_CRLF Ausgabe CR LF auf Terminal ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL WR_CRLF procedure entry ldb rl0, #CR calr TYWR ldb rl0, #LF calr TYWR calr WR_NULL ret end WR_CRLF !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE WR_NULL Ausgabe einer bestimmten Anzahl Nullen auf Terminal (entsprechend NULLCT) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! INTERNAL WR_NULL procedure entry test NULLCT ret z ld r1, NULLCT clr r0 WR_NULL1: calr TYWR dec r1, #1 jr nz, WR_NULL1 ret end WR_NULL !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE WR_MSG Zeichenketten-Ausgabe auf Terminal Ausgabe wird bei CR beendet Input: r2 - Adresse der Zeichenkette (Zeichenkette beginnt mit Angabe der Laenge (WORD) gefolgt von der Zeichenkette selbst) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL WR_MSG procedure entry ld r0, @r2 cp r0, #%0 !LAENGE = 0? ! ret z ld OUTPTR, r0 inc r2, #%02 !ADRESSE DES 1. CHAR.! ld r4, #OUTBFF !OUTBFF_ADRESSE LADEN! ldirb @r4, @r2, r0 !MESSAGE TRANSFERIEREN! calr WR_OUTBFF ret end WR_MSG !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE WR_OUTBFF_CR Ausgabe des Inhaltes des Ausgabepuffers (OUTBFF) mit CR auf Terminal; Loeschen des Ausgabepuffers ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL WR_OUTBFF_CR procedure entry ld r3, OUTPTR ldb OUTBFF(r3), #%0D inc OUTPTR, #1 calr WR_OUTBFF ret end WR_OUTBFF_CR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE WR_OUTBFF Ausgabe des Inhaltes des Ausgabepuffers (OUTBFF) auf Terminal; Loeschen des Ausgabepuffers ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL WR_OUTBFF procedure entry clr r3 !ZEICHENZAEHLER LOESCHEN! TX_1: ldb rl0, OUTBFF(r3) inc r3, #1 calr TYWR jr z, TX_2 !SPRUNG WENN CR AUSGEGEBEN WURDE! cp r3, OUTPTR !ALLE ZEICHEN AUSGEBEN ? ! jr c, TX_1 !SPRUNG WENN PUFFER NICHT LEER! jr BF_EMPTY TX_2: ldb rl0, #LF !LINE FEED NACH MSG SENDEN! calr TYWR calr WR_NULL !NULLCT Nullen senden! bitb FLAG1, #%04 !AUSGABE BEI CR ABBRECHEN ? ! jr nz, TX_1 BF_EMPTY: ld OUTPTR, #0 ! OUTPTR RUECKSETZTEN ! ld r0, #%0040 ld OUTBFF, #' ' ld r2, #OUTBFF !OUTBFF LOESCHEN ! ld r4, #OUTBFF + 2 ldir @r4, @r2, r0 ret end WR_OUTBFF !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE HTOB Konvertierung Hexaziffer (ASCII) in Binaerwert Input: rl0 - Hexaziffer (ASCII) Output: rl0 - Binaerwert C=1 --> keine Hexaziffer (Fehler) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL HTOB procedure entry cpb rl0, #'0' ret c !FEHLER := KEINE ZAHL! cpb rl0, #'9' + 1 jr c, HTOB1 !SPRUNG WENN ZAHL! cpb rl0, #'A' ret c !FEHLER := KEIN BUCHSTABE! cpb rl0, #'F' + 1 jr nc, HTOB2 !FEHLER := KEIN BUCHSTABE A...F! subb rl0, #%07 HTOB1: andb rl0, #%0F !FEHLERFREI! resflg c ret HTOB2: setflg c !FEHLER := KEINE HEXADEZIMALZAHL! ret end HTOB !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE BTOH16 Konvertierung Binaer in Hexaziffern (ASCII) und Eintragung in Ausgabepuffer (OUTBFF) Input: r5 - 16-Bit-Wert (--> 4 Hexaziffern) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL BTOH16 procedure entry ldb rh0, rh5 !HIGH ADRESSE LADEN! calr BTH calr BTOH8 ret end BTOH16 !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE BTOH8 Konvertierung Binaer in Hexaziffern (ASCII) und Eintragung in Ausgabepuffer (OUTBFF) Input: rl5 - 8-Bit-Wert (--> 2 Hexaziffern) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL BTOH8 procedure entry ldb rh0, rl5 !LOW ADRESSE ODER 8-BIT WERT LADEN! BTH: rldb rl0, rh0 calr BTOH4 !BINAER TO HEX KONVERTIERUNG! rldb rl0, rh0 calr BTOH4 ret end BTOH8 !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE BTOH4 Konvertierung Binaer in Hexaziffer (ASCII) und Eintragung in Ausgabepuffer (OUTBFF) Input: rl0 (Bit0-3) - 4-Bit-Wert (--> 1 Hexaziffer) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! INTERNAL BTOH4 procedure entry push @r15, r1 andb rl0, #%0F ldb rl1, KONV addb rl1, rl0 ldb KONV, rl1 cpb rl0, #%0A jr c, BTOH41 addb rl0, #%07 BTOH41: addb rl0, #%30 push @r15, r6 ld r6, OUTPTR ldb OUTBFF(r6), rl0 inc OUTPTR, #1 pop r6, @r15 pop r1, @r15 ret end BTOH4 !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE GET_CHR aus Eingabepuffer INBFF das Zeichen in rl0 bereitstellen, auf das INPTR zeigt Output: rl0 - Zeichen INPTR zeigt auf darauffolgendes Zeichen Z=1 --> Zeichen=CR ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL GET_CHR procedure entry push @r15, r2 ld r2, INPTR ldb rl0, INBFF(r2) inc INPTR, #1 !INPTR := INPTR + 1! cpb rl0, #CR pop r2, @r15 ret end GET_CHR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE GET_SIGN aus Eingabepuffer INBFF ab Position INPTR (einschl.) Space suchen und naechstes Zeichen ungleich Space in rl0 bereitstellen Output: rl0 - Zeichen INPTR zeigt auf darauffolgendes Zeichen Z=1 --> CR gelesen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL GET_SIGN procedure entry calr GET_CHR ret z !RUECKSPRUNG WENN ENDEKENNUNG (CR)! cpb rl0, #' ' jr nz, GET_SIGN !1. SPACE NACH DEM KOMMANDO SUCHEN! calr GET_SIGNW ret end GET_SIGN !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE GET_SIGNW aus Eingabepuffer INBFF ab Position INPTR (einschl.) erstes Zeichen ungleich Space in rl0 bereitstellen Output: rl0 - Zeichen INPTR zeigt auf darauffolgendes Zeichen Z=1 --> CR gelesen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL GET_SIGNW procedure entry calr GET_CHR !1. ZEICHEN DER PARAMETERFOLGE LESEN! ret z !Zeichen=CR! cpb rl0, #' ' jr z, GET_SIGNW ret !Z=0! end GET_SIGNW !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE GET_SGNR Einlesen (aus Eingabepuffer INBFF) und Konvertierung der Segmentnummer Input: rl0 - 1. Zeichen der eingegebenen Adresse INPTR zeigt auf darauffolgendes Zeichen Output: r2 - Segmentnummer (Bit0-7=0 / Bit8-14=segnr / Bit15=1) (falls kein Segmentnummer angegeben, dann r2=PC_SEG) rl0 - 1. Zeichen der Offsetadresse INPTR zeigt auf darauffolgendes Zeichen Fehler, wenn unzulaessige Segmentnummer angegeben ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL GET_SGNR procedure entry ld r2, PC_SEG !implizite segnr! set r2, #%0F !Setzen Bit15! resb FLAG1, #%0 !Flag=0 --> keine Segmentnummer angegeben ???! cpb rl0, #CR ret z !Ende der Eingabezeile! cpb rl0, #'<' !#SEGMENT IDENTIFIER ANF. ! ret nz !keine Segmentnummer angegeben! clr r3 EKSN_N: calr GET_CHR !rl0:=naechstes Zeichen aus INBFF! jp z, ERROR !Zeichen=CR! calr HTOB !Konvertierung rl0 hexa (ASCII)-->binaer! jr c, EKSN_NHZ !keine Hexaziffer! rldb rl0, rl3 !Binaerwert in rl3 schieben! jr EKSN_N !naechstes Zeichen! EKSN_NHZ: cpb rl0, #'>' !#SEGMENT IDENTIFIER ENDE! jp nz, ERROR !segnr enthaelt unzulaessiges Zeichen! calr GET_SIGNW !rl0:=Zeichen nach segnr ungleich Space! ldb rh2, rl3 clrb rl2 set r2, #%0F !r2 := segnr! setb FLAG1, #%0 !Flag=1 --> Segmentnummer angegeben ???! ret end GET_SGNR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE GET_HEXZ Einlesen (aus Eingabepuffer INBFF) und Konvertierung einer Hexazahl Input: rl0 - 1. Ziffer der eingegebenen Hexazahl INPTR zeigt auf darauffolgendes Zeichen Output: r3 - Hexazahl (binaer) - wurden mehr als 4 Ziffern angegeben, so werden die letzten 4 Ziffern ausgewertet rl0 - naechstes Zeichen aus Eingabepuffer ungleich Space nach ausgewerteter Hexazahl INPTR zeigt auf darauffolgendes Zeichen C=1 --> keine Hexazahl angegeben Z=1 --> CR gelesen Fehler, wenn unzulaessige Hexazahl angegeben ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL GET_HEXZ procedure entry clr r3 cpb rl0, #CR setflg c ret z RD_HX: calr HTOB !Konvertierung rl0 in Binaerwert! jp c, ERROR !unzulaessige Hexaziffer! rldb rl0, rl3 rldb rl0, rh3 calr GET_CHR !rl0 := naechste Ziffer! ret z !CR gelesen (C=0 aus GET_CHR)! cpb rl0, #' ' jr nz, RD_HX !naechste Ziffer! calr GET_SIGNW !rl0:= naechstes Zeichen ungleich Space! resflg c ret !Z=1, wenn CR gelesen; sonst Z=0 (aus GET_SIGNW)! end GET_HEXZ !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE GET_ADR Einlesen (aus Eingabepuffer INBFF) und Konvertierung einer Adresse (eingegebene Adresse muss folgenden Aufbau haben: 'offset', wobei die Segmentnummer fehlen kann) Input: rl0 - 1. Zeichen der Adresse INPTR zeigt auf darauffolgendes Zeichen Output: rr2 - Adresse (binaer) rl0 - naechstes Zeichen ungleich Space aus Eingabepuffer nach ausgewerteter Adresse INPTR zeigt auf darauffolgendes Zeichen C=1 --> keine Adresse angegeben Z=1 --> CR gelesen Fehler, wenn ungueltige Hexaziffer angegeben ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL GET_ADR procedure entry calr GET_SGNR !r2 := Segmentnummer! calr GET_HEXZ !r3 := Offset! ret end GET_ADR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE GET_PAR Einlesen (aus Eingabepuffer INBFF) und Konvertierung der Parameterfolge: 'offset1 offset2 word', wobei fehlen kann Output: c=1 wenn Parameterfolge unvollst. oder fehlerhaft rr6 - 1. Adresse (binaer) rr4 - 2. Adresse (binaer) r3 - word (binaer) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL GET_PAR procedure entry calr GET_SIGN !1. ASCII-ZEICHEN IN RL0! calr GET_ADR !rr2 := 1. Adresse! jr z, RD_P2 !CR wurde gelesen! ldl rr6, rr2 !rr6 := 1. Adresse! calr GET_ADR !rr2 := 2. Adresse! jr z, RD_P2 !CR wurde gelesen! ldl rr4, rr2 !rr4 := 2. Adresse! calr GET_HEXZ !r3 := word! ret nc !kein Fehler! RD_P2: setflg c !C=1, d.h. Fehler! ret end GET_PAR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE RD_DATA Dateneingabe (PROMT-Zeichen (':') ausgeben, eingegebene Zeile aus PTYBFF in INBFF speichern, auf Terminal ausgeben und 1. Datenwert der Zeile auswerten) Output: rr2 enthaelt Datenwert Z=1, wenn keine Dateneingabe erfolgte bzw. 'Q' oder '-' eingegeben C=1, wenn 'Q' oder '-' eingegeben (rl0 enthaelt dann 'Q' oder '-') Z=0, wenn Dateneingabe erfolgte (rr2 enthaelt dann Datenwert) mit: P/V=1, wenn CR nach Datenwert, C=0, wenn Space nach Datenwert INPTR zeigt auf 2 Zeichen nach der letzten Ziffer des Datenwertes Fehler, wenn ungueltige Hexazahl eingegeben wurde ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL RD_DATA procedure entry ldb rl0, #':' calr TYWR !Ausgabe ':' auf Terminal! calr RD_LINE_INBFF !Zeile aus PTYBFF in INBFF speichern und auf Terminal ausgeben! calr GET_DATA ret end RD_DATA !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE GET_DATA Dateneingabe (Einlesen des naechsten Datenwertes aus Eingabepuffer INBFF) Input: INPTR zeigt auf das erste auszuwertende Zeichen des Datenwertes bzw. auf Space davor Output: rr2 enthaelt Datenwert Z=1, wenn keine Dateneingabe erfolgte bzw. 'Q' oder '-' eingegeben C=1, wenn 'Q' oder '-' eingegeben (rl0 enthaelt dann 'Q' oder '-') Z=0, wenn Dateneingabe erfolgte (rr2 enthaelt dann Datenwert) mit: P/V=1, wenn CR nach Datenwert, C=0, wenn Space nach Datenwert INPTR zeigt auf 2 Zeichen nach der letzten Ziffer des Datenwertes Fehler, wenn ungueltige Hexazahl eingegeben wurde ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL GET_DATA procedure entry clr r2 clr r3 calr GET_SIGNW !rl0:=1. Zeichen des Datenwertes! ret z !Z=1, kein Datenwert (CR)! cpb rl0, #'Q' !QUIT ? ! jr z, K_Q cpb rl0, #'-' jr nz, K_LOOP K_Q: setflg c ret !Z=1, C=1: 'Q' oder '-' eingegeben! K_LOOP: calr HTOB !Konv. rl0 (Hexa-ASCII) --> rl0 (binaer)! jp c, ERROR !keine Hexaziffer! rldb rl0, rl3 rldb rl0, rh3 rldb rl0, rl2 rldb rl0, rh2 !Hexaziffer (binaer) in rr2 schieben! calr GET_CHR !rl0:=naechstes Zeichen aus INBFF! jr nz, K_1 !kein CR! setflg p, v jr K_END !Z=0, P/V=1, wenn CR nach Datenwert! K_1: cpb rl0, #' ' jr nz, K_LOOP !naechste Ziffer des Datenwertes! resflg c !Z=0, C=1, wenn Space nach Datenwert! K_END: resflg z ret end GET_DATA !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE WR_R5_RDDATA Eintragung des ASCII-konvertierten Inhaltes von r5 in Ausgabepuffer (OUTBFF); Ausgabe des Ausgabepuffers auf Terminal; Ausgabe ':'; Eingabe des Datenwertes Input: r5 - Adresse Output: siehe Prozedur RD_DATA ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL WR_R5_RDDATA procedure entry calr BTOH16 !Eintragung r5 (ASCII) in OUTBFF! inc OUTPTR, #1 !1 Leerzeichen! calr WR_OBF_RDDATA ret end WR_R5_RDDATA !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE WR_OBF_RDDATA Ausgabe des Ausgabepuffers auf Terminal; Ausgabe ':'; Eingabe des Datenwertes Output: siehe Prozedur RD_DATA ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL WR_OBF_RDDATA procedure entry calr WR_OUTBFF !Ausgabe Inhalt OUTBFF! calr RD_DATA !AUSGABE ':' + EINGABE NEUER INHALT! ret end WR_OBF_RDDATA !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE PUT_CHR Eintragung eines Zeichens in Ausgabepuffer (OUTBFF) Input: rl1 - einzutragendes Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL PUT_CHR procedure entry ld r2, OUTPTR ldb OUTBFF(r2), rl1 inc OUTPTR, #1 ret end PUT_CHR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE PUT_3C Eintragung des Zeichens '<' in Ausgabepuffer (OUTBFF) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL PUT_3C procedure entry ld r1, #'< ' calr PUT_1CHR ret end PUT_3C !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE PUT_1CHR Eintragung eines Zeichens in Ausgabepuffer (OUTBFF) Input: r1 - Zeichenkette aus 'Zeichen, Space' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! INTERNAL PUT_1CHR procedure entry calr PUT_2CHR !2 ZEICHEN IN DEN OUTPUT_PUFFER LADEN! dec OUTPTR, #1 !PUFFERLAENGE DEKREMENTIEREN! ret end PUT_1CHR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE PUT_2CHR 2 Zeichen in Ausgabepuffer (OUTBFF) eintragen Input: rh1 - 1. Zeichen rl1 - 2. Zeichen ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL PUT_2CHR procedure entry push @r15, r4 ld r4, OUTPTR ldb OUTBFF(r4), rh1 inc r4, #1 ldb OUTBFF(r4), rl1 inc OUTPTR, #%02 pop r4, @r15 ret end PUT_2CHR !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE PUT_SEGNR Konvertierung der Segmentnummer in HEXA-ASCII-Zahl (xx); Eintragung von '' in Ausgabepuffer OUTBFF Input: rl5 - Segmentnummer (binaer) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL PUT_SEGNR PROCEDURE ENTRY calr PUT_3C !Zeichen '<' in OUTBFF eintragen! calr PUT_SGNR ret end PUT_SEGNR !Weiterlauf bei PUT_SGNR! !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ PROCEDURE PUT_SGNR Konvertierung der Segmentnummer in HEXA-ASCII-Zahl (xx); Eintragung von 'xx>' in Ausgabepuffer OUTBFF Input: rl5 - Segmentnummer (binaer) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++! GLOBAL PUT_SGNR PROCEDURE ENTRY resb rl5, #%07 calr BTOH8 !Segmentnummer in OUTBFF eintragen! ld r1, #'> ' calr PUT_1CHR !Zeichen '>' in OUTBFF eintragen! ret end PUT_SGNR end p_term