;IMPLEMENTATION MODULE Bits;

.COMMENT $

from BITS.MOD,  bit manipulation module, BA June 13, 1985        

Adapted for Z80ASM assembly and Turbo Modula-2 Use

Jim Lill 7 Sep 87

$

MOD8   EQU     00000111B       ;Mask to calculate bit MOD 8

;   PROCEDURE Set (VAR arg1 : CHAR; bit : CARDINAL);
;
SET::
	POP	IY              ;Return Address
        POP     BC              ;bit #
        EX      (SP),IY         ;CHAR's address <---> Return Address
        LD      A,MOD8          ;Make sure bit
        AND     C               ; in range 0 --> 7
        LD      B,A             ;'Safe' bit # in B                       
        XOR     A               ;Clear Accum. & CY
        CCF                     ;Set CY to make mask
        INC     B               ;Adjust count
FINDS:  RLA                     ;Rotate mask 
        DJNZ    FINDS           ; until count is zero
        OR      (IY)            ;Set the bit
        LD      (IY),A          ;Return it to CHAR
        RET

;
;   PROCEDURE Reset (VAR arg1 : CHAR; bit : CARDINAL);
;
RESET::
	POP     IY              ;Return Address
        POP     BC              ;bit #
        EX      (SP),IY         ;CHAR's address <---> Return Address
        LD      A,MOD8          ;Make sure bit
        AND     C               ; in range 0 --> 7
        LD      B,A             ;'Safe' bit # in B                       
        XOR     A               ;Clear Accum. & CY
        CCF                     ;Set CY to make mask
        INC     B               ;Adjust count
FINDR:  RLA                     ;Rotate mask 
        DJNZ    FINDR           ; until count is zero
        CPL                     ;Invert mask
        AND     (IY)            ;Reset (clear) the bit
        LD      (IY),A          ;Return it to CHAR
        RET
				
;
;   PROCEDURE Test (A : CHAR; bit : CARDINAL) : BOOLEAN;
;
TRUE   EQU     00000001B       ;
                               ;
TEST::
	POP     HL              ;Return Address
       	POP     BC              ;bit #
       	EX      (SP),HL         ;CHAR <---> Return Address
       	LD      IY,0            ;Clear a Pointer
       	ADD     IY,SP           ;Make Copy of Stack Pointer
       	LD      A,MOD8          ;Make sure bit
       	AND     C               ; in range 0 --> 7
       	LD      B,A             ;'Safe' bit # in B                       
       	XOR     A               ;Clear Accum. & CY
       	CCF                     ;Set CY to make mask
       	INC     B               ;Adjust count
FINDT: 	RLA                     ;Rotate mask 
       	DJNZ    FINDT           ; until count is zero
       	AND     L               ;Check if bit set
       	JP      Z,FALSE         ;If zero, return FALSE
       	LD      A,TRUE          ; else, return TRUE
FALSE: 	LD      (IY+2),A        ;Store function Return Value
       	RET

;
;   PROCEDURE SHL (VAR arg1 : CHAR);
;
SHL::
	POP     HL              ;Return Address
       	EX      (SP),HL         ;CHAR's address <---> Return Address
       	SLA     (HL)            ;Shift Left (Arithmetic)
       	RET

;
;   PROCEDURE SHR (VAR arg1 : CHAR);
;
SHR::
	POP     HL              ;Return Address
       	EX      (SP),HL         ;CHAR's address <---> Return Address
       	SRL     (HL)            ;Shift Right (Logical)
       	RET

;
;   PROCEDURE AndB (arg1, arg2 : CHAR) : CHAR;
;
ANDB::
	POP     HL              ;Return Address
       	POP     DE              ;'B'
       	EX      (SP),HL         ;'A' <---> Return Address
       	LD      IY,0            ;Clear a Pointer
       	ADD     IY,SP           ;Make Copy of Stack Pointer
       	LD      A,L             ;Move 'A' to Accum.
       	AND     E               ;And with 'B'
       	LD      (IY+2),A        ;Store function return value
       	RET

;
;   PROCEDURE OrB (arg1, arg2 : CHAR) : CHAR;
;
ORB::
	POP     HL              ;Return Address
        POP     DE              ;'B'
        EX      (SP),HL         ;'A' <---> Return Address
        LD      IY,0            ;Clear a Pointer
        ADD     IY,SP           ;Make Copy of Stack Pointer
        LD      A,L             ;Move 'A' to Accum.
        OR      E               ;Or with 'B'
        LD      (IY+2),A        ;Store function return value
        RET

;
;   PROCEDURE XorB (arg1, arg2 : CHAR) : CHAR;
;
XORB::
	POP     HL              ;Return Address
        POP     DE              ;'B'
        EX      (SP),HL         ;'A' <---> Return Address
        LD      IY,0            ;Clear a Pointer
        ADD     IY,SP           ;Make Copy of Stack Pointer
        LD      A,L             ;Move 'A' to Accum.
        XOR     E               ;Xor with 'B'
        LD      (IY+2),A        ;Store function return value
        RET

;
;END Bits.
;
       END                     ;