Here is a tip for users of 8080 macro assemblers which I've never seen in print, but which I've found to be useful. It pertains to the use of the standard condition codes (Z, NZ, C, NC, M, P, PO, PE) as parameters of a macro instruction. Let's say you've written a useful macro to do something or other. As an example most CP/M programmers are familiar with, let's consider the CPM macro. It usually goes something like this: CPM MACRO FUNC,VALUE IF NOT NUL VALUE LXI D,VALUE ;;Load D&E with value. ENDIF IF NOT NUL FUNC MVI C,FUNC ;;Load C reg with Function. ENDIF CALL BDOS ENDM The examples are written for the Digital Research MAC assembler, but would probably be similar for others. To use the macro, one might say: CPM CON,CR ;Send carriage return to console Assuming that CON had been EQUated to 2, the CP/M function for console output, and CR had been EQUated to 0DH, the macro would expand to: LXI D,0DH MVI C,02H CALL 0005H which would send a carriage return to the console. Similarly, if KEY had been EQUated to 1, the console input function, the macro call CPM KEY would expand to: MVI C,01H CALL 0005H which would get a keyboard character into register A. This macro is in fact used quite frequently by many programmers who work with CP/M. Note that the IF's prevent unneeded code from being assembled where the parameter is not supplied. Now consider a case where we want to read a console character only when the carry flag is set. Perhaps the carry flag indicates an error condition, and we want the program to pause. The usual way of doing this is: ... ;Code to set carry on error JNC OK ;Jump around input routine CPM KEY ;Get a character from console. OK: ... ;Continue with operation. To save programmer time, we can modify the CPM macro to allow a condition code to be specified as a third parameter. Then we could write lines like: CPM KEY,,C ;Get char if Carry set ...or... PUSH PSW ;Save output char. MOV E,A ;Move to E for output CPM CON ;Output it POP PSW ;Get back character CPI CR ;Was it a carriage return? CPM CON,LF,Z ;If so, follow with Line Feed. ... without having to code the jump instructions which are necessary to avoid executing the macro code. We do this by coding the jump instruction into the macro itself. This is made easier by the fact that most macro assemblers will allow us to use the value of an opcode as data. For compatability with Intel standards, it should be coded within parentheses (required by some assemblers) and if we're using MAC, should have spaces around the opcode to avoid a little-known glitch in MAC. Let's work with an even simpler macro to see how this might operate. We'll invent the JUMPIF macro, which does nothing but cause a conditional jump. JUMPIF MACRO COND,ADDR DB ( J&COND ) DW ADDR ENDM In this simple example, coding the line: JUMPIF NC,EOJ would expand to: DB ( JNC ) DW EOJ "Big deal!", you say. Why not just code: JNC EOJ Well, we want to work the condition code into a larger macro, and generate a jump around the inline code if the condition is false. Ah, but there's the rub. In order for the macro to work properly, the jump instruction has to jump if the condition given is NOT true, and fall through to the inline code if it IS true. To illustrate, let's invent the opposite of the JUMPIF macro, the JMPUNLES (Jump Unless) macro. We could do something like this: JMPUNLES MACRO COND,ADDR J&COND LABL1 ;Jump around the next instr. JMP ADDR ;Do the real jump. LABL1: ENDM But this requires the use of two jump instructions where we know only one is required. In practice, of course, LABL1 would be declared LOCAL or we could only use this macro once per program without getting duplicate label errors. There is a way out. In all 8080 instructions involving condition codes, there is a one bit difference between a condition code and it's opposite, and it is always the same bit. The bit used is the bit with a value of 8. Compare the JZ instruction with the JNZ instruction: 1 1 0 0 1 0 1 0 Jump If Zero 1 1 0 0 0 0 1 0 Jump If Not Zero --- --- --- --- --- --- --- --- 128 64 32 16 *8* 4 2 1 Bit Values Changing this one bit changes a JC to a JNC, a JP to a JM, and a JPO to a JPE. The bit has the same function in the conditional call and return instructions as well. Combining all these facts, we can write our CPM macro with the condition code parameter. It comes out looking like this: CPM MACRO FUNC,VALUE,COND LOCAL LABLX ;Generate one-time label IF NOT NUL COND ;Generate jump only when needed DB ( J&COND ) XOR 8 ;Change condition code to its ; opposite. DW LABLX ;Address field of jump instr. ENDIF IF NOT NUL VALUE LXI D,VALUE ENDIF IF NOT NUL FUNC MVI C,FUNC ENDIF CALL BDOS LABLX: ;Jump here if COND wasn't true. Continue... ENDM Coding CPM CON,LF,NZ would cause the opcode to be expanded as: DB ( JNZ ) XOR 8 which is the same as: DB ( JZ ) Note that the COND parameter could have been any of the valid 8080 condition codes: Z, NZ, C, NC, P, M, PO, PE. Also, we could use conditional calls ( C&COND ) or conditional returns ( R&COND) and changed the sense of the condition by XORing the opcode with 8 to change the necessary bit. This technique can be quite useful in macros of all types to allow the use of condition codes on the same line as the macro call, saving programmer time, and lessening the chances of error. For your information, here is a list of 8080 opcodes which are changed into their opposites by XORing with 8. Although the ones with condition codes will probably be the most useful, some of the others may come in handy some day. The instruction on the left has the "8's" bit as a 0, on the right as a 1. STAX LDAX RLC RRC RAL RAR INX DCX SHLD LHLD JNC JC JNZ JZ JP JM JPO JPE CNC CC CNZ CZ CP CM CPO CPE RNC RC RNZ RZ RP RM RPO RPE DI EI OUT IN Do yourself a favor and use this trick only where it will genuinely improve efficiency, not just to make simple code hard to read. Happy Hacking! Gary P. Novosielski (201) 935-4087 Eve's.