z80asm.c File Reference

#include "z80asm.h"
#include <rz_util.h>
#include "expressions.c"

Go to the source code of this file.

Macros
#define	RZ_API_I
#define	write_one_byte(x, y)   obuf[obuflen++] = x
#define	wrtb(x)   obuf[obuflen++] = x
#define	DE   2
#define	AF   3
#define	A   8
#define	C   1
#define	HL   2
#define	ldBC   1
#define	ldDE   2
#define	ldHL   3
#define	ldSP   4
#define	ldIX   5
#define	ldIY   6
#define	ldB   7
#define	ldC   8
#define	ldD   9
#define	ldE   10
#define	ldH   11
#define	ldL   12
#define	ld_HL   13
#define	ldA   14
#define	ldI   15
#define	ldR   16
#define	ld_BC   17
#define	ld_DE   18
#define	ld_IX   19
#define	ld_IY   20
#define	ld_NN   21
#define	addHL   15
#define	ld_nnHL   5
#define	ld_nnA   6
#define	A_N   7
#define	A_I   9
#define	A_R   10
#define	A_NN   11
#define	_NN   1
#define	SPNN   0
#define	SPHL   1

Functions
static void	printerr (int error, const char *fmt,...)
static const char *	delspc (const char *ptr)
static void	rd_comma (const char **p)
static int	has_argument (const char **p)
static void	skipword (const char **pos, char delimiter)
static int	indx (const char **ptr, const char **list, int error, const char **expr)
static int	readcommand (const char **p)
static void	readlabel (const char **p, int store)
static int	compute_ref (struct reference *ref, int allow_invalid)
static int	rd_word (const char **p, char delimiter)
static int	rd_byte (const char **p, char delimiter)
static int	rd_ex1 (const char **p)
static int	rd_in (const char **p)
static int	rd_out (const char **p)
static int	rd_nnc (const char **p)
static int	rd_c (const char **p)
static int	rd_a_hl (const char **p)
static int	rd_ld (const char **p)
static int	rd_jp (const char **p)
static int	rd_jr (const char **p)
static int	rd_a (const char **p)
static int	rd_stack (const char **p)
static int	rd_r_add (const char **p)
static int	rd_rr_ (const char **p)
static int	rd_rrxx (const char **p)
static int	rd_r (const char **p)
static int	rd_r_ (const char **p)
static int	rd_0_7 (const char **p)
static int	rd_cc (const char **p)
static int	rd_r_rr (const char **p)
static int	rd_hl (const char **p)
static int	rd_hlx (const char **p)
static int	rd_af_ (const char **p)
static int	rd_0_2 (const char **p)
static int	rd_ld_hl (const char **p)
static int	rd_ld_nn (const char **p)
static int	rd_lda (const char **p)
static int	rd_ldbcdehla (const char **p)
static int	rd_nn_nn (const char **p)
static int	rd_sp (const char **p)
static int	assemble (const char *str, unsigned char *_obuf)
RZ_API_I int	z80asm (unsigned char *outbuf, const char *s)

Variables
static unsigned char *	obuf
static int	obuflen = 0
static const char *	mnemonics []
static int	addr = 0
static int	file
static int	writebyte
static const char *	readbyte
static const char *	readword
static const char *	indexjmp
static const char *	bitsetres
static int	indexed
static int	verbose = 0
static int	comma
static int	baseaddr
static char	mem_delimiter
static char *	z80buffer = NULL
static int	define_macro = 0
static int	sp
static struct stack	stack [MAX_INCLUDE]

Macro Definition Documentation

_NN

#define _NN   1

A

#define A   8

A_I

#define A_I   9

A_N

#define A_N   7

A_NN

#define A_NN   11

A_R

#define A_R   10

addHL

#define addHL   15

AF

#define AF   3

C

#define C   1

DE

#define DE   2

HL

#define HL   2

ld_BC

#define ld_BC   17

ld_DE

#define ld_DE   18

ld_HL

#define ld_HL   13

ld_IX

#define ld_IX   19

ld_IY

#define ld_IY   20

ld_NN

#define ld_NN   21

ld_nnA

#define ld_nnA   6

ld_nnHL

#define ld_nnHL   5

ldA

#define ldA   14

ldB

#define ldB   7

ldBC

#define ldBC   1

ldC

#define ldC   8

ldD

#define ldD   9

ldDE

#define ldDE   2

ldE

#define ldE   10

ldH

#define ldH   11

ldHL

#define ldHL   3

ldI

#define ldI   15

ldIX

#define ldIX   5

ldIY

#define ldIY   6

ldL

#define ldL   12

ldR

#define ldR   16

ldSP

#define ldSP   4

RZ_API_I

#define RZ_API_I

Definition at line 28 of file z80asm.c.

SPHL

#define SPHL   1

SPNN

#define SPNN   0

write_one_byte

#define write_one_byte	(		x,
			y
	)		obuf[obuflen++] = x

Definition at line 38 of file z80asm.c.

wrtb

#define wrtb

(

x

)

obuf[obuflen++] = x

Definition at line 39 of file z80asm.c.

Function Documentation

assemble()

static int assemble ( const char *  str, unsigned char *  _obuf  )

static

Definition at line 784 of file z80asm.c.

                                                           {
    const char *ptr;
    char *bufptr;
    int r, s;           /* registers */
 
    obuflen = 0;
    obuf = _obuf;
    int cmd, cont = 1;
    // XXX: must free
    z80buffer = strdup (str);
    if (!cont) {
        return obuflen;
    }
    // if (havelist)
    // fprintf (listfile, "%04x", addr);
    for (bufptr = z80buffer; (bufptr = strchr (bufptr, '\n'));) {
        *bufptr = ' ';
    }
    for (bufptr = z80buffer; (bufptr = strchr (bufptr, '\r'));) {
        *bufptr = ' ';
    }
    ptr = z80buffer;
    // lastlabel = NULL;
    baseaddr = addr;
    ++stack[sp].line;
    ptr = delspc (ptr);
    if (!*ptr) {
        return obuflen;
    }
    if (!define_macro) {
        readlabel (&ptr, 1);
    } else {
        readlabel (&ptr, 0);
    }
    ptr = delspc (ptr);
    if (!*ptr) {
        return obuflen;
    }
    comma = 0;
    indexed = 0;
    indexjmp = 0;
    writebyte = 0;
    readbyte = 0;
    readword = 0;
    cmd = readcommand (&ptr) - 1;
    int i, have_quote;
    switch (cmd) {
        case Z80_ADC:
            if (!(r = rd_a_hl (&ptr))) {
                break;
            }
            if (r == HL) {
                if (!(r = rd_rr_(&ptr))) {
                    break;
                }
                wrtb (0xED);
                r--;
                wrtb (0x4A + 0x10 * r);
                break;
            }
            if (!(r = rd_r (&ptr))) {
                break;
            }
            r--;
            wrtb (0x88 + r);
            break;
        case Z80_ADD:
            if (!(r = rd_r_add (&ptr))) {
                break;
            }
            if (r == addHL) {
                if (!(r = rd_rrxx (&ptr))) {
                    break;
                }
                r--;
                wrtb (0x09 + 0x10 * r);     /* ADD HL/IX/IY, qq  */
                break;
            }
            if (has_argument (&ptr)) {
                if (r != A) {
                    RZ_LOG_ERROR("assembler: z80: parse error before: %s\n", ptr);
                    break;
                }
                if (!(r = rd_r (&ptr))) {
                    break;
                }
                r--;
                wrtb (0x80 + r);        /* ADD A,r  */
                break;
            }
            r--;
            wrtb (0x80 + r);        /* ADD r  */
            break;
        case Z80_AND:
            if (!(r = rd_r (&ptr))) {
                break;
            }
            r--;
            wrtb (0xA0 + r);
            break;
        case Z80_BIT:
            if (!rd_0_7 (&ptr)) {
                break;
            }
            rd_comma (&ptr);
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            wrtb (0x40 + (r - 1));
            break;
        case Z80_CALL:
            if ((r = rd_cc (&ptr))) {
                r--;
                wrtb (0xC4 + 8 * r);
                rd_comma (&ptr);
            } else {
                wrtb (0xCD);
            }
            break;
        case Z80_CCF:
            wrtb (0x3F);
            break;
        case Z80_CP:
            if (!(r = rd_r (&ptr))) {
                break;
            }
            r--;
            wrtb (0xB8 + r);
            break;
        case Z80_CPD:
            wrtb (0xED);
            wrtb (0xA9);
            break;
        case Z80_CPDR:
            wrtb (0xED);
            wrtb (0xB9);
            break;
        case Z80_CPI:
            wrtb (0xED);
            wrtb (0xA1);
            break;
        case Z80_CPIR:
            wrtb (0xED);
            wrtb (0xB1);
            break;
        case Z80_CPL:
            wrtb (0x2F);
            break;
        case Z80_DAA:
            wrtb (0x27);
            break;
        case Z80_DEC:
            if (!(r = rd_r_rr (&ptr))) {
                break;
            }
            if (r < 0) {
                r--;
                wrtb (0x05 - 8 * r);
                break;
            }
            r--;
            wrtb (0x0B + 0x10 * r);
            break;
        case Z80_DI:
            wrtb (0xF3);
            break;
        case Z80_DJNZ:
            wrtb (0x10);
            // rd_wrt_jr (&ptr, '\0');
            break;
        case Z80_EI:
            wrtb (0xFB);
            break;
        case Z80_EX:
            if (!(r = rd_ex1 (&ptr))) {
                break;
            }
            switch (r) {
                case DE:
                    if (!rd_hl (&ptr)) {
                        break;
                    }
                    wrtb (0xEB);
                    break;
                case AF:
                    if (!rd_af_(&ptr)) {
                        break;
                    }
                    wrtb (0x08);
                    break;
                default:
                    if (!rd_hlx (&ptr)) {
                        break;
                    }
                    wrtb (0xE3);
            }
            break;
        case Z80_EXX:
            wrtb (0xD9);
            break;
        case Z80_HALT:
            wrtb (0x76);
            break;
        case Z80_IM:
            if (!(r = rd_0_2 (&ptr))) {
                break;
            }
            wrtb (0xED);
            r--;
            wrtb (0x46 + 8 * r);
            break;
        case Z80_IN:
            if (!(r = rd_in (&ptr))) {
                break;
            }
            if (r == A) {
                if (!(r = rd_nnc (&ptr))) {
                    break;
                }
                if (r == C) {
                    wrtb (0xED);
                    wrtb (0x40 + 8 * (A - 1));
                    break;
                }
                wrtb (0xDB);
                break;
            }
            if (!rd_c (&ptr)) {
                break;
            }
            wrtb (0xED);
            r--;
            wrtb (0x40 + 8 * r);
            break;
        case Z80_INC:
            if (!(r = rd_r_rr (&ptr))) {
                break;
            }
            if (r < 0) {
                r++;
                wrtb (0x04 - 8 * r);
                break;
            }
            r--;
            wrtb (0x03 + 0x10 * r);
            break;
        case Z80_IND:
            wrtb (0xED);
            wrtb (0xAA);
            break;
        case Z80_INDR:
            wrtb (0xED);
            wrtb (0xBA);
            break;
        case Z80_INI:
            wrtb (0xED);
            wrtb (0xA2);
            break;
        case Z80_INIR:
            wrtb (0xED);
            wrtb (0xB2);
            break;
        case Z80_JP:
            r = rd_jp (&ptr);
            if (r < 0) {
                wrtb (0xE9);
                break;
            }
            if (r) {
                r--;
                wrtb (0xC2 + 8 * r);
                rd_comma (&ptr);
            } else {
                wrtb (0xC3);
            }
            break;
        case Z80_JR:
            r = rd_jr (&ptr);
            if (r) {
                rd_comma (&ptr);
            }
            wrtb (0x18 + 8 * r);
            break;
        case Z80_LD:
            if (!(r = rd_ld (&ptr))) {
                break;
            }
            switch (r) {
                case ld_BC:
                case ld_DE:
                    if (!rd_a (&ptr)) {
                        break;
                    }
                    wrtb (0x02 + 0x10 * (r == ld_DE ? 1 : 0));
                    break;
                case ld_HL:
                    r = rd_ld_hl (&ptr) - 1;
                    wrtb (0x70 + r);
                    break;
                case ld_NN:
                    if (!(r = rd_ld_nn (&ptr))) {
                        break;
                    }
                    if (r == ld_nnA || r == ld_nnHL) {
                        wrtb (0x22 + 0x10 * (r == ld_nnA ? 1 : 0));
                        break;
                    }
                    wrtb (0xED);
                    wrtb (0x43 + 0x10 * --r);
                    break;
                case ldA:
                    if (!(r = rd_lda (&ptr))) {
                        break;
                    }
                    if (r == A_NN) {
                        wrtb (0x3A);
                        break;
                    }
                    if (r == A_I || r == A_R) {
                        wrtb (0xED);
                        wrtb (0x57 + 8 * (r == A_R ? 1 : 0));
                        break;
                    }
                    if (r == A_N) {
                        char n = rz_num_math (NULL, readbyte);
                        wrtb (0x3E);
                        wrtb (n);
                        break;
                    }
                    if (r < 0) {
                        r++;
                        wrtb (0x0A - 0x10 * r);
                        break;
                    }
                    wrtb (0x78 + --r);
                    break;
                case ldB:
                case ldC:
                case ldD:
                case ldE:
                case ldH:
                case ldL:
                    if (!(s = rd_ldbcdehla (&ptr))) {
                        break;
                    }
                    if (s == 7) {
                        char n = rz_num_math(NULL, readbyte);
                        wrtb (0x08 * (r - 7) + 0x6);
                        wrtb (n);
                    } else {
                        wrtb (0x40 + 0x08 * (r -7) + (s - 1));
                    }
                    break;
                case ldBC:
                case ldDE:
                    s = rd_nn_nn (&ptr);
                    if (s == _NN) {
                        wrtb (0xED);
                        wrtb (0x4B + 0x10 * (r == ldDE ? 1 : 0));
                        break;
                    }
                    wrtb (0x01 + (r == ldDE ? 1 : 0) * 0x10);
                    break;
                case ldHL:
                    r = rd_nn_nn (&ptr);
                    wrtb (0x21 + (r == _NN ? 1 : 0) * 9);
                    break;
                case ldI:
                case ldR:
                    if (!rd_a (&ptr)) {
                        break;
                    }
                    wrtb (0xED);
                    wrtb (0x47 + 0x08 * (r == ldR ? 1 : 0));
                    break;
                case ldSP:
                    r = rd_sp (&ptr);
                    if (r == SPHL) {
                        wrtb (0xF9);
                        break;
                    }
                    if (r == SPNN) {
                        wrtb (0x31);
                        break;
                    }
                    wrtb (0xED);
                    wrtb (0x7B);
                    break;
            }
            break;
        case Z80_LDD:
            wrtb (0xED);
            wrtb (0xA8);
            break;
        case Z80_LDDR:
            wrtb (0xED);
            wrtb (0xB8);
            break;
        case Z80_LDI:
            wrtb (0xED);
            wrtb (0xA0);
            break;
        case Z80_LDIR:
            wrtb (0xED);
            wrtb (0xB0);
            break;
        case Z80_NEG:
            wrtb (0xED);
            wrtb (0x44);
            break;
        case Z80_NOP:
            wrtb (0x00);
            break;
        case Z80_OR:
            if (!(r = rd_r (&ptr))) {
                break;
            }
            r--;
            wrtb (0xB0 + r);
            break;
        case Z80_OTDR:
            wrtb (0xED);
            wrtb (0xBB);
            break;
        case Z80_OTIR:
            wrtb (0xED);
            wrtb (0xB3);
            break;
        case Z80_OUT:
            if (!(r = rd_nnc (&ptr))) {
                break;
            }
            if (r == C) {
                if (!(r = rd_out (&ptr))) {
                    break;
                }
                wrtb (0xED);
                r--;
                wrtb (0x41 + 8 * r);
                break;
            }
            if (!rd_a (&ptr)) {
                break;
            }
            wrtb (0xD3);
            break;
        case Z80_OUTD:
            wrtb (0xED);
            wrtb (0xAB);
            break;
        case Z80_OUTI:
            wrtb (0xED);
            wrtb (0xA3);
            break;
        case Z80_POP:
            if (!(r = rd_stack (&ptr))) {
                break;
            }
            r--;
            wrtb (0xC1 + 0x10 * r);
            break;
        case Z80_PUSH:
            if (!(r = rd_stack (&ptr))) {
                break;
            }
            r--;
            wrtb (0xC5 + 0x10 * r);
            break;
        case Z80_RES:
            if (!rd_0_7 (&ptr)) {
                break;
            }
            rd_comma (&ptr);
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x80 + r);
            break;
        case Z80_RET:
            if (!(r = rd_cc (&ptr))) {
                wrtb (0xC9);
                break;
            }
            r--;
            wrtb (0xC0 + 8 * r);
            break;
        case Z80_RETI:
            wrtb (0xED);
            wrtb (0x4D);
            break;
        case Z80_RETN:
            wrtb (0xED);
            wrtb (0x45);
            break;
        case Z80_RL:
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x10 + r);
            break;
        case Z80_RLA:
            wrtb (0x17);
            break;
        case Z80_RLC:
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x00 + r);
            break;
        case Z80_RLCA:
            wrtb (0x07);
            break;
        case Z80_RLD:
            wrtb (0xED);
            wrtb (0x6F);
            break;
        case Z80_RR:
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x18 + r);
            break;
        case Z80_RRA:
            wrtb (0x1F);
            break;
        case Z80_RRC:
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x08 + r);
            break;
        case Z80_RRCA:
            wrtb (0x0F);
            break;
        case Z80_RRD:
            wrtb (0xED);
            wrtb (0x67);
            break;
        case Z80_RST:
            ptr = "";
            break;
        case Z80_SBC:
            if (!(r = rd_a_hl (&ptr))) {
                break;
            }
            if (r == HL) {
                if (!(r = rd_rr_(&ptr))) {
                    break;
                }
                wrtb (0xED);
                r--;
                wrtb (0x42 + 0x10 * r);
                break;
            }
            if (!(r = rd_r (&ptr))) {
                break;
            }
            r--;
            wrtb (0x98 + r);
            break;
        case Z80_SCF:
            wrtb (0x37);
            break;
        case Z80_SET:
            if (!rd_0_7 (&ptr)) {
                break;
            }
            rd_comma (&ptr);
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0xC0 + r);
            break;
        case Z80_SLA:
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x20 + r);
            break;
        case Z80_SLI:
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x30 + r);
            break;
        case Z80_SRA:
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x28 + r);
            break;
        case Z80_SRL:
            if (!(r = rd_r_(&ptr))) {
                break;
            }
            wrtb (0xCB);
            r--;
            wrtb (0x38 + r);
            break;
        case Z80_SUB:
            if (!(r = rd_r (&ptr))) {
                break;
            }
            if (has_argument (&ptr)) {      /* SUB A,r ?  */
                if (r != A) {
                    RZ_LOG_ERROR("assembler: z80: parse error before: %s\n", ptr);
                    break;
                }
                if (!(r = rd_r (&ptr))) {
                    break;
                }
            }
            r--;
            wrtb (0x90 + r);
            break;
        case Z80_XOR:
            if (!(r = rd_r (&ptr))) {
                break;
            }
            r--;
            wrtb (0xA8 + r);
            break;
        case Z80_DEFB:
        case Z80_DB:
        case Z80_DEFM:
        case Z80_DM:
            ptr = delspc (ptr);
            while (1) {
                have_quote = (*ptr == '"' || *ptr == '\'');
                if (have_quote) {
                    /* Read string.  */
                    int quote = *ptr;
                    ++ptr;
                    while (*ptr != quote) {
                        write_one_byte (rd_character (&ptr, NULL, 1), 0);
                        if (*ptr == 0) {
                            RZ_LOG_ERROR("assembler: z80: end of line in quoted string\n");
                            break;
                        }
                    }
                    ++ptr;
                } else {
                    /* Read expression.  */
                    skipword (&ptr, ',');
                }
                ptr = delspc (ptr);
                if (*ptr == ',') {
                    ++ptr;
                    continue;
                }
                if (*ptr != 0) {
                    RZ_LOG_ERROR("assembler: z80: junk in byte definition: %s\n", ptr);
                }
                break;
            }
            break;
        case Z80_DEFW:
        case Z80_DW:
            if (!rd_word (&ptr, ',')) {
                RZ_LOG_ERROR("assembler: z80: No data for word definition\n");
                break;
            }
            while (1) {
                ptr = delspc (ptr);
                if (*ptr != ',') {
                    break;
                }
                ++ptr;
                if (!rd_word (&ptr, ',')) {
                    RZ_LOG_ERROR("assembler: z80: Missing expression in defw\n");
                }
            }
            break;
        case Z80_DEFS:
        case Z80_DS:
            r = rd_expr (&ptr, ',', NULL, sp, 1);
            if (r < 0) {
                RZ_LOG_ERROR("assembler: z80: ds should have its first argument >=0"
                        " (not -0x%x)\n", -r);
                break;
            }
            ptr = delspc (ptr);
            if (*ptr) {
                rd_comma (&ptr);
                readbyte = 0;
                rd_byte (&ptr, '\0');
                writebyte = 0;
                break;
            }
            for (i = 0; i < r; i++) {
                write_one_byte (0, 0);
            }
            break;
        case Z80_END:
            break;
        case Z80_ORG:
            addr = rd_expr (&ptr, '\0', NULL, sp, 1) & 0xffff;
            break;
        case Z80_IF:
            break;
        case Z80_ELSE:
            RZ_LOG_ERROR("assembler: z80: else without if\n");
            break;
        case Z80_ENDIF:
            RZ_LOG_ERROR("assembler: z80: endif without if\n");
            break;
        case Z80_ENDM:
            if (stack[sp].file) {
                RZ_LOG_ERROR("assembler: z80: endm outside macro definition\n");
            }
            break;
        case Z80_SEEK:
            RZ_LOG_ERROR("assembler: z80: seek error\n");
            break;
        default:
            // RZ_LOG_ERROR("assembler: z80: command or comment expected (was %s)\n", ptr);
            return 0;
    }
 
    return obuflen;
}

References _NN, A, A_I, A_N, A_NN, A_R, addHL, addr, AF, baseaddr, C, cmd, comma, DE, define_macro, delspc(), has_argument(), HL, i, indexed, indexjmp, ld_BC, ld_DE, ld_HL, ld_NN, ld_nnA, ld_nnHL, ldA, ldB, ldBC, ldC, ldD, ldDE, ldE, ldH, ldHL, ldI, ldL, ldR, ldSP, stack::line, n, NULL, obuf, obuflen, r, rd_0_2(), rd_0_7(), rd_a(), rd_a_hl(), rd_af_(), rd_byte(), rd_c(), rd_cc(), rd_character(), rd_comma(), rd_ex1(), rd_expr(), rd_hl(), rd_hlx(), rd_in(), rd_jp(), rd_jr(), rd_ld(), rd_ld_hl(), rd_ld_nn(), rd_lda(), rd_ldbcdehla(), rd_nn_nn(), rd_nnc(), rd_out(), rd_r(), rd_r_(), rd_r_add(), rd_r_rr(), rd_rr_(), rd_rrxx(), rd_sp(), rd_stack(), rd_word(), readbyte, readcommand(), readlabel(), readword, RZ_LOG_ERROR, rz_num_math(), s, skipword(), sp, SPHL, SPNN, cmd_descs_generate::str, strdup(), write_one_byte, writebyte, wrtb, Z80_ADC, Z80_ADD, Z80_AND, Z80_BIT, Z80_CALL, Z80_CCF, Z80_CP, Z80_CPD, Z80_CPDR, Z80_CPI, Z80_CPIR, Z80_CPL, Z80_DAA, Z80_DB, Z80_DEC, Z80_DEFB, Z80_DEFM, Z80_DEFS, Z80_DEFW, Z80_DI, Z80_DJNZ, Z80_DM, Z80_DS, Z80_DW, Z80_EI, Z80_ELSE, Z80_END, Z80_ENDIF, Z80_ENDM, Z80_EX, Z80_EXX, Z80_HALT, Z80_IF, Z80_IM, Z80_IN, Z80_INC, Z80_IND, Z80_INDR, Z80_INI, Z80_INIR, Z80_JP, Z80_JR, Z80_LD, Z80_LDD, Z80_LDDR, Z80_LDI, Z80_LDIR, Z80_NEG, Z80_NOP, Z80_OR, Z80_ORG, Z80_OTDR, Z80_OTIR, Z80_OUT, Z80_OUTD, Z80_OUTI, Z80_POP, Z80_PUSH, Z80_RES, Z80_RET, Z80_RETI, Z80_RETN, Z80_RL, Z80_RLA, Z80_RLC, Z80_RLCA, Z80_RLD, Z80_RR, Z80_RRA, Z80_RRC, Z80_RRCA, Z80_RRD, Z80_RST, Z80_SBC, Z80_SCF, Z80_SEEK, Z80_SET, Z80_SLA, Z80_SLI, Z80_SRA, Z80_SRL, Z80_SUB, Z80_XOR, and z80buffer.

Referenced by z80asm().

compute_ref()

static int compute_ref ( struct reference *  ref, int  allow_invalid  )

static

Definition at line 255 of file z80asm.c.

                                                                 {
    const char *ptr;
    int valid = 0;
    int backup_addr = addr;
    int backup_baseaddr = baseaddr;
    int backup_comma = comma;
    int backup_file = file;
    int backup_sp = sp;
    sp = ref->level;
    addr = ref->addr;
    baseaddr = ref->baseaddr;
    comma = ref->comma;
    file = ref->infile;
    ptr = ref->input;
    if (!ref->done) {
        ref->computed_value = rd_expr (&ptr, ref->delimiter,
            allow_invalid? &valid: NULL,
            ref->level, 1);
        if (valid) {
            ref->done = 1;
        }
    }
    sp = backup_sp;
    addr = backup_addr;
    baseaddr = backup_baseaddr;
    comma = backup_comma;
    file = backup_file;
    return ref->computed_value;
}

References addr, reference::addr, baseaddr, reference::baseaddr, comma, reference::comma, reference::computed_value, reference::delimiter, reference::done, file, reference::infile, reference::input, reference::level, NULL, rd_expr(), label::ref, sp, and valid.

Referenced by check_label().

delspc()

static const char* delspc ( const char *  ptr )

static

Definition at line 117 of file z80asm.c.

                                           {
    while (*ptr && isspace ((const unsigned char) *ptr))
        ptr++;
    if (*ptr == ';') {
        ptr = "";
    }
    return ptr;
}

References isspace.

Referenced by assemble(), check_label(), do_rd_expr(), has_argument(), indx(), rd_0_7(), rd_byte(), rd_comma(), rd_expr_and(), rd_expr_equal(), rd_expr_or(), rd_expr_shift(), rd_expr_unequal(), rd_expr_xor(), rd_factor(), rd_number(), rd_term(), rd_value(), and rd_word().

has_argument()

static int has_argument ( const char **  p )

static

Definition at line 137 of file z80asm.c.

                                        {
    const char *q = delspc (*p);
    return *q == ',';
}

References delspc(), and p.

Referenced by assemble().

indx()

static int indx ( const char **  ptr, const char **  list, int  error, const char **  expr  )

static

Definition at line 154 of file z80asm.c.

                                                                                   {
    int i;
    *ptr = delspc (*ptr);
    if (!**ptr) {
        if (error) {
            RZ_LOG_ERROR("assembler: z80: unexpected end of line\n");
            return 0;
        } else {
            return 0;
        }
    }
    if (comma > 1) {
        rd_comma (ptr);
    }
    for (i = 0; list[i]; i++) {
        const char *input = *ptr;
        const char *check = list[i];
        int had_expr = 0;
        if (!list[i][0]) {
            continue;
        }
        while (*check) {
            if (*check == ' ') {
                input = delspc (input);
            } else if (*check == '*') {
                *expr = input;
                mem_delimiter = check[1];
                rd_expr (&input, mem_delimiter, NULL, sp, 0);
                had_expr = 1;
            } else if (*check == '+') {
                if (*input == '+' || *input == '-') {
                    *expr = input;
                    mem_delimiter = check[1];
                    rd_expr (&input, mem_delimiter, NULL, sp, 0);
                }
            } else if (*check == *input || (*check >= 'a' && *check <= 'z'
                            && *check - 'a' + 'A' == *input)) {
                ++input;
            } else {
                break;
            }
 
            ++check;
        }
        if (*check || (isalnum ((const unsigned char) check[-1]) && isalnum ((const unsigned char) input[0]))) {
            continue;
        }
        if (had_expr) {
            input = delspc (input);
            if (*input && *input != ',') {
                continue;
            }
        }
        *ptr = input;
        comma++;
        return i + 1;
    }
    // if (error) RZ_LOG_ERROR("assembler: z80: parse error. Remainder of line=%s\n", *ptr);
    return 0;
}

References check, comma, delspc(), error(), expr(), i, input(), isalnum, list(), mem_delimiter, NULL, rd_comma(), rd_expr(), RZ_LOG_ERROR, and sp.

Referenced by bin_pe_init_imports(), decode_cmpi(), decode_movi(), decode_movrel(), rd_0_2(), rd_a(), rd_a_hl(), rd_af_(), rd_c(), rd_cc(), rd_ex1(), rd_hl(), rd_hlx(), rd_in(), rd_jp(), rd_jr(), rd_ld(), rd_ld_hl(), rd_ld_nn(), rd_lda(), rd_ldbcdehla(), rd_nn_nn(), rd_nnc(), rd_out(), rd_r(), rd_r_(), rd_r_add(), rd_r_rr(), rd_rr_(), rd_rrxx(), rd_sp(), rd_stack(), and readcommand().

printerr()

static void printerr ( int  error, const char *  fmt,   ...  )

static

Definition at line 98 of file z80asm.c.

                                                      {
#if 0
    va_list l;
    va_start (l, fmt);
    if ((sp < 0) || (stack[sp].name == 0)) {
        fprintf (stderr, "internal assembler error, sp == %i\n", sp);
        vfprintf (stderr, fmt, l);
    }
    fprintf (stderr, "%s%s:%d: %s: ", stack[sp].dir? stack[sp].dir->name: "",
        stack[sp].name, stack[sp].line, error? "error": "warning");
    vfprintf (stderr, fmt, l);
    va_end (l);
    if (error) {
        errors++;
    }
#endif
}

References stack::dir, error(), stack::line, includedir::name, stack::name, and sp.

Referenced by do_rd_expr(), rd_character(), rd_expr(), rd_factor(), rd_label(), rd_otherbasenumber(), and rd_value().

rd_0_2()

static int rd_0_2 ( const char **  p )

static

Definition at line 652 of file z80asm.c.

                                  {
    const char *list[] = {
        "0", "", "1", "2", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_0_7()

static int rd_0_7 ( const char **  p )

static

Definition at line 581 of file z80asm.c.

                                  {
    *p = delspc (*p);
    if (**p == 0) {
        return 0;
    }
    bitsetres = *p;
    skipword (p, ',');
    return 1;
}

References bitsetres, delspc(), p, and skipword().

Referenced by assemble().

rd_a()

static int rd_a ( const char **  p )

static

Definition at line 453 of file z80asm.c.

                                {
    const char *list[] = {
        "a", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_a_hl()

static int rd_a_hl ( const char **  p )

static

Definition at line 360 of file z80asm.c.

                                   {
#define HL 2
    const char *list[] = {
        "a", "hl", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_af_()

static int rd_af_ ( const char **  p )

static

Definition at line 644 of file z80asm.c.

                                  {
    const char *list[] = {
        "af'", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_byte()

static int rd_byte ( const char **  p, char  delimiter  )

static

Definition at line 298 of file z80asm.c.

                                                   {
    *p = delspc (*p);
    if (**p == 0) {
        return 0;
    }
    readbyte = *p;
    writebyte = 1;
    mem_delimiter = delimiter;
    skipword (p, delimiter);
    return 1;
}

References delspc(), mem_delimiter, p, readbyte, skipword(), and writebyte.

Referenced by assemble().

rd_c()

static int rd_c ( const char **  p )

static

Definition at line 352 of file z80asm.c.

                                {
    const char *list[] = {
        "( c )", "( bc )", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_cc()

static int rd_cc ( const char **  p )

static

Definition at line 592 of file z80asm.c.

                                 {
    const char *list[] = {
        "nz", "z", "nc", "c", "po", "pe", "p", "m", NULL
    };
    return indx (p, list, 0, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_comma()

static void rd_comma ( const char **  p )

static

Definition at line 127 of file z80asm.c.

                                     {
    *p = delspc (*p);
    if (**p != ',') {
        RZ_LOG_ERROR("assembler: z80: `,' expected. Remainder of line: %s\n", *p);
        return;
    }
    *p = delspc ((*p) + 1);
}

References delspc(), p, and RZ_LOG_ERROR.

Referenced by assemble(), and indx().

rd_ex1()

static int rd_ex1 ( const char **  p )

static

Definition at line 311 of file z80asm.c.

                                  {
#define DE 2
#define AF 3
    const char *list[] = {
        "( sp )", "de", "af", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_hl()

static int rd_hl ( const char **  p )

static

Definition at line 622 of file z80asm.c.

                                 {
    const char *list[] = {
        "hl", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_hlx()

static int rd_hlx ( const char **  p )

static

Definition at line 630 of file z80asm.c.

                                  {
    int i;
    const char *list[] = {
        "hl", "ix", "iy", NULL
    };
    i = indx (p, list, 1, NULL);
    if (i < 2) {
        return i;
    }
    indexed = 0xDD + 0x20 * (i - 2);
    return 1;
}

References i, indexed, indx(), list(), NULL, and p.

Referenced by assemble().

rd_in()

static int rd_in ( const char **  p )

static

Definition at line 321 of file z80asm.c.

                                 {
#define A 8
    const char *list[] = {
        "b", "c", "d", "e", "h", "l", "f", "a", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_jp()

static int rd_jp ( const char **  p )

static

Definition at line 427 of file z80asm.c.

                                 {
    int i;
    const char *list[] = {
        "nz", "z", "nc", "c", "po", "pe", "p", "m", "( ix )", "( iy )",
        "(hl)", NULL
    };
    i = indx (p, list, 0, NULL);
    if (i < 9) {
        return i;
    }
    if (i == 11) {
        return -1;
    }
    indexed = 0xDD + 0x20 * (i - 9);
    return -1;
}

References i, indexed, indx(), list(), NULL, and p.

Referenced by assemble().

rd_jr()

static int rd_jr ( const char **  p )

static

Definition at line 445 of file z80asm.c.

                                 {
    const char *list[] = {
        "nz", "z", "nc", "c", NULL
    };
    return indx (p, list, 0, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_ld()

static int rd_ld ( const char **  p )

static

Definition at line 369 of file z80asm.c.

                                 {
#define ldBC    1
#define ldDE    2
#define ldHL    3
#define ldSP    4
#define ldIX    5
#define ldIY    6
#define ldB     7
#define ldC     8
#define ldD     9
#define ldE     10
#define ldH     11
#define ldL     12
#define ld_HL   13
#define ldA     14
#define ldI     15
#define ldR     16
#define ld_BC   17
#define ld_DE   18
#define ld_IX   19
#define ld_IY   20
#define ld_NN   21
    int i;
    const char *list[] = {
        "ixh", "ixl", "iyh", "iyl", "bc", "de", "hl", "sp", "ix",
        "iy", "b", "c", "d", "e", "h", "l", "( hl )", "a", "i",
        "r", "( bc )", "( de )", "( ix +)", "(iy +)", "(*)", NULL
    };
    const char *nn;
    i = indx (p, list, 1, &nn);
    if (!i) {
        return 0;
    }
    if (i <= 2) {
        indexed = 0xdd;
        return ldH + (i == 2);
    }
    if (i <= 4) {
        indexed = 0xfd;
        return ldH + (i == 4);
    }
    i -= 4;
    if (i == ldIX || i == ldIY) {
        indexed = i == ldIX? 0xDD: 0xFD;
        return ldHL;
    }
    if (i == ld_IX || i == ld_IY) {
        indexjmp = nn;
        indexed = i == ld_IX? 0xDD: 0xFD;
        return ld_HL;
    }
    if (i == ld_NN) {
        readword = nn;
    }
    return i;
}

References i, indexed, indexjmp, indx(), ld_HL, ld_IX, ld_IY, ld_NN, ldH, ldHL, ldIX, ldIY, list(), NULL, p, and readword.

Referenced by assemble().

rd_ld_hl()

static int rd_ld_hl ( const char **  p )

static

Definition at line 660 of file z80asm.c.

                                    {
    int i;
    const char *list[] = {
        "b", "c", "d", "e", "h", "l", "", "a", "*", NULL
    };
    i = indx (p, list, 0, &readbyte);
    if (i < 9) {
        return i;
    }
    writebyte = 1;
    return 7;
}

References i, indx(), list(), NULL, p, readbyte, and writebyte.

Referenced by assemble().

rd_ld_nn()

static int rd_ld_nn ( const char **  p )

static

Definition at line 674 of file z80asm.c.

                                    {
#define ld_nnHL 5
#define ld_nnA 6
    int i;
    const char *list[] = {
        "bc", "de", "", "sp", "hl", "a", "ix", "iy", NULL
    };
    i = indx (p, list, 1, NULL);
    if (i < 7) {
        return i;
    }
    indexed = 0xdd + 0x20 * (i == 8);
    return ld_nnHL;
}

References i, indexed, indx(), ld_nnHL, list(), NULL, and p.

Referenced by assemble().

rd_lda()

static int rd_lda ( const char **  p )

static

Definition at line 690 of file z80asm.c.

                                  {
#define A_N 7
#define A_I 9
#define A_R 10
#define A_NN 11
    int i;
    const char *list[] = {
        "( sp )", "( iy +)", "( de )", "( bc )", "( ix +)", "b", "c", "d", "e", "h",
        "l", "( hl )", "a", "i", "r", "(*)", "*", NULL
    };
    const char *nn;
    i = indx (p, list, 0, &nn);
    if (i == 2 || i == 5) {
        indexed = (i == 2)? 0xFD: 0xDD;
        indexjmp = nn;
        return 7;
    }
    if (i == 17) {
        readbyte = nn;
        writebyte = 1;
        return 7;
    }
    if (i == 16) {
        readword = nn;
    }
    return i - 5;
}

References i, indexed, indexjmp, indx(), list(), NULL, p, readbyte, readword, and writebyte.

Referenced by assemble().

rd_ldbcdehla()

static int rd_ldbcdehla ( const char **  p )

static

Definition at line 719 of file z80asm.c.

                                        {
    int i;
    const char *list[] = {
        "b", "c", "d", "e", "h", "l", "( hl )", "a", "( ix +)", "( iy +)", "ixh",
        "ixl", "iyh", "iyl", "*", NULL
    };
    const char *nn;
    i = indx (p, list, 0, &nn);
    if (i == 15) {
        readbyte = nn;
        writebyte = 1;
        return 7;
    }
    if (i > 10) {
        int x;
        x = 0xdd + 0x20 * (i > 12);
        if (indexed && indexed != x) {
            RZ_LOG_ERROR("assembler: z80: illegal use of index registers\n");
            return 0;
        }
        indexed = x;
        return 6 - (i & 1);
    }
    if (i > 8) {
        if (indexed) {
            RZ_LOG_ERROR("assembler: z80: illegal use of index registers\n");
            return 0;
        }
        indexed = 0xDD + 0x20 * (i == 10);
        indexjmp = nn;
        return 7;
    }
    return i;
}

References i, indexed, indexjmp, indx(), list(), NULL, p, readbyte, RZ_LOG_ERROR, writebyte, and x.

Referenced by assemble().

rd_nn_nn()

static int rd_nn_nn ( const char **  p )

static

Definition at line 755 of file z80asm.c.

                                    {
#define _NN 1
    const char *list[] = {
        "(*)", "*", NULL
    };
    return 2 - indx (p, list, 0, &readword);
}

References indx(), list(), NULL, p, and readword.

Referenced by assemble().

rd_nnc()

static int rd_nnc ( const char **  p )

static

Definition at line 338 of file z80asm.c.

                                  {
#define C 1
    int i;
    const char *list[] = {
        "( c )", "(*)", "a , (*)", NULL
    };
    i = indx (p, list, 1, &readbyte);
    if (i < 2) {
        return i;
    }
    return 2;
}

References i, indx(), list(), NULL, p, and readbyte.

Referenced by assemble().

rd_out()

static int rd_out ( const char **  p )

static

Definition at line 330 of file z80asm.c.

                                  {
    const char *list[] = {
        "b", "c", "d", "e", "h", "l", "0", "a", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_r()

static int rd_r ( const char **  p )

static

Definition at line 540 of file z80asm.c.

                                {
    int i;
    const char *nn;
    const char *list[] = {
        "ixl", "ixh", "iyl", "iyh", "b", "c", "d", "e", "h", "l", "( hl )",
        "a", "( ix +)", "( iy +)", "*", NULL
    };
    i = indx (p, list, 0, &nn);
    if (i == 15) {  /* expression */
        readbyte = nn;
        writebyte = 1;
        return 7;
    }
    if (i <= 4) {
        indexed = 0xdd + 0x20 * (i > 2);
        return 6 - (i & 1);
    }
    i -= 4;
    if (i < 9) {
        return i;
    }
    indexed = 0xDD + 0x20 * (i - 9);
    indexjmp = nn;
    return 7;
}

References i, indexed, indexjmp, indx(), list(), NULL, p, readbyte, and writebyte.

Referenced by assemble().

rd_r_()

static int rd_r_ ( const char **  p )

static

Definition at line 567 of file z80asm.c.

                                 {
    int i;
    const char *list[] = {
        "b", "c", "d", "e", "h", "l", "( hl )", "a", "( ix +)", "( iy +)", NULL
    };
    i = indx (p, list, 1, &indexjmp);
    if (i < 9) {
        return i;
    }
    indexed = 0xDD + 0x20 * (i - 9);
    return 7;
}

References i, indexed, indexjmp, indx(), list(), NULL, and p.

Referenced by assemble().

rd_r_add()

static int rd_r_add ( const char **  p )

static

Definition at line 477 of file z80asm.c.

                                    {
#define addHL   15
    int i;
    const char *list[] = {
        "ixl", "ixh", "iyl", "iyh", "b", "c", "d", "e", "h", "l",
        "( hl )", "a", "( ix +)", "( iy +)", "hl", "ix", "iy", "*", NULL
    };
    const char *nn;
    i = indx (p, list, 0, &nn);
    if (i == 18) {  /* expression */
        readbyte = nn;
        writebyte = 1;
        return 7;
    }
    if (i > 14) {   /* hl, ix, iy */
        if (i > 15) {
            indexed = 0xDD + 0x20 * (i - 16);
        }
        return addHL;
    }
    if (i <= 4) {   /* i[xy][hl]  */
        indexed = 0xdd + 0x20 * (i > 2);
        return 6 - (i & 1);
    }
    i -= 4;
    if (i < 9) {
        return i;
    }
    indexed = 0xDD + 0x20 * (i - 9);    /* (i[xy] +) */
    indexjmp = nn;
    return 7;
}

References addHL, i, indexed, indexjmp, indx(), list(), NULL, p, readbyte, and writebyte.

Referenced by assemble().

rd_r_rr()

static int rd_r_rr ( const char **  p )

static

Definition at line 600 of file z80asm.c.

                                   {
    int i;
    const char *list[] = {
        "iy", "ix", "sp", "hl", "de", "bc", "", "b", "c", "d", "e", "h",
        "l", "( hl )", "a", "( ix +)", "( iy +)", NULL
    };
    i = indx (p, list, 1, &indexjmp);
    if (!i) {
        return 0;
    }
    if (i < 16 && i > 2) {
        return 7 - i;
    }
    if (i > 15) {
        indexed = 0xDD + (i - 16) * 0x20;
        return -7;
    }
    indexed = 0xDD + (2 - i) * 0x20;
    return 3;
}

References i, indexed, indexjmp, indx(), list(), NULL, and p.

Referenced by assemble().

rd_rr_()

static int rd_rr_ ( const char **  p )

static

Definition at line 511 of file z80asm.c.

                                  {
    const char *list[] = {
        "bc", "de", "hl", "sp", NULL
    };
    return indx (p, list, 1, NULL);
}

References indx(), list(), NULL, and p.

Referenced by assemble().

rd_rrxx()

static int rd_rrxx ( const char **  p )

static

Definition at line 519 of file z80asm.c.

                                   {
    const char *listx[] = {
        "bc", "de", "ix", "sp", NULL
    };
    const char *listy[] = {
        "bc", "de", "iy", "sp", NULL
    };
    const char *list[] = {
        "bc", "de", "hl", "sp", NULL
    };
    if (indexed == 0xdd) {
        return indx (p, listx, 1, NULL);
    }
    if (indexed == 0xfd) {
        return indx (p, listy, 1, NULL);
    }
    return indx (p, list, 1, NULL);
}

References indexed, indx(), list(), NULL, and p.

Referenced by assemble().

rd_sp()

static int rd_sp ( const char **  p )

static

Definition at line 764 of file z80asm.c.

                                 {
#define SPNN 0
#define SPHL 1
    int i;
    const char *list[] = {
        "hl", "ix", "iy", "(*)", "*", NULL
    };
    const char *nn;
    i = indx (p, list, 0, &nn);
    if (i > 3) {
        readword = nn;
        return i == 4? 2: 0;
    }
    if (i != 1) {
        indexed = 0xDD + 0x20 * (i - 2);
    }
    return 1;
}

References i, indexed, indx(), list(), NULL, p, and readword.

Referenced by assemble().

rd_stack()

static int rd_stack ( const char **  p )

static

Definition at line 461 of file z80asm.c.

                                    {
    int i;
    const char *list[] = {
        "bc", "de", "hl", "af", "ix", "iy", NULL
    };
    i = indx (p, list, 1, NULL);
    if (i < 5) {
        return i;
    }
    indexed = 0xDD + 0x20 * (i - 5);
    return 3;
}

References i, indexed, indx(), list(), NULL, and p.

Referenced by assemble().

rd_word()

static int rd_word ( const char **  p, char  delimiter  )

static

Definition at line 286 of file z80asm.c.

                                                   {
    *p = delspc (*p);
    if (**p == 0) {
        return 0;
    }
    readword = *p;
    mem_delimiter = delimiter;
    skipword (p, delimiter);
    return 1;
}

References delspc(), mem_delimiter, p, readword, and skipword().

Referenced by assemble().

readcommand()

static int readcommand ( const char **  p )

static

Definition at line 216 of file z80asm.c.

                                       {
    return indx (p, mnemonics, 0, NULL);
}

References indx(), mnemonics, NULL, and p.

Referenced by assemble().

readlabel()

static void readlabel ( const char **  p, int  store  )

static

Definition at line 221 of file z80asm.c.

                                                 {
    const char *c, *d, *pos, *dummy;
    int i, j;
    struct label *previous;
    for (d = *p; *d && *d != ';'; d++) {
        ;
    }
    for (c = *p; !strchr (" \r\n\t", *c) && c < d; c++) {
        ;
    }
    pos = strchr (*p, ':');
    if (!pos || pos >= c) {
        return;
    }
    if (pos == *p) {
        RZ_LOG_ERROR("assembler: z80: `:' found without a label");
        return;
    }
    if (!store) {
        *p = pos + 1;
        return;
    }
    c = pos + 1;
    dummy = *p;
    j = rd_label (&dummy, &i, &previous, sp, 0);
    if (i || j) {
        RZ_LOG_ERROR("assembler: z80: duplicate definition of label %s\n", *p);
        *p = c;
        return;
    }
 
    *p = c;
}

References c, d, i, p, pos, rd_label(), RZ_LOG_ERROR, and sp.

Referenced by assemble().

skipword()

static void skipword ( const char **  pos, char  delimiter  )

static

Definition at line 145 of file z80asm.c.

                                                       {
    /* rd_expr will happily read the expression, and possibly return
     * an invalid result.  It will update pos, which is what we need.  */
    /* Pass valid to allow using undefined labels without errors.  */
    int valid;
    rd_expr (pos, delimiter, &valid, sp, 0);
}

References pos, rd_expr(), sp, and valid.

Referenced by assemble(), rd_0_7(), rd_byte(), and rd_word().

z80asm()

RZ_API_I int z80asm	(	unsigned char *	outbuf,
		const char *	s
	)

Definition at line 1526 of file z80asm.c.

                                                          {
    return assemble (s, outbuf);
}

References assemble(), outbuf, and s.

Referenced by do_assemble().

Variable Documentation

addr

int addr = 0

static

Definition at line 58 of file z80asm.c.

Referenced by _6502_op(), __add_menu(), __analysis_esil_function(), __bb_addr_cmp(), __break_points_cb(), __core_analysis_fcn(), __cursor_up(), __disasm(), __fcn_exists(), __handle_mouse_on_panel(), __handleComment(), __jmp_to_cursor_addr(), __opaddr(), __panels_process(), __prelude_cb_hit(), __read(), __refs(), __seek_all(), __set_addr_by_type(), __set_panel_addr(), __update_menu(), __watch_points_cb(), __write(), __xrefs(), _analysis_calls(), _cb_hit(), _CbInRangeSearchV(), _cs_disasm(), _pointer_table(), _server_handle_M(), _server_handle_m(), _server_handle_z(), aarch64_print_operand(), add_arch_platform_flag_comment_cb(), add_comment(), add_hit_to_hits(), add_hit_to_sorted_hits(), add_map(), add_mem_change(), add_mmio_extended_flag_cb(), add_mmio_flag_cb(), add_refline(), add_reg_change(), add_single_addr_xrefs(), add_trace_tree_child(), addptr(), addr_hint_acc_cb(), addr_hint_range_delete_cb(), addsym(), adr(), adrp(), agraph_refresh(), align_address_to_size(), alignCheck(), all_in(), all_intersect(), analize_addr_cb(), analop(), analop_vle(), analPathFollow(), analPaths(), analysis_block_cb(), analysis_branch(), analysis_call(), analysis_function_vars_getsetref(), analysis_graph_to(), analysis_jmpl(), analysis_op(), analysis_pic_midrange_op(), analysis_pic_op(), analysis_pic_pic18_op(), annotated_hexdump(), anop(), anop32(), anop64(), anop_esil(), apply_bank(), arc_op(), arcAnalyzeInstr(), arch_hint_acc_cb(), archbits(), arcompact_branch(), arcompact_genops(), arcompact_genops_jmp(), arcompact_jump(), arcompact_jump_cond(), arcompact_op(), ARCTangent_decodeInstr(), arg(), arm64ass(), array_add(), assemble(), autocomplete_breakpoints(), automerge_predecessor_successor_cb(), avr_custom_spm_page_erase(), avr_custom_spm_page_fill(), avr_custom_spm_page_write(), avr_il_load_reg(), avr_il_st(), avr_il_store_pure(), avr_il_store_reg(), avr_op(), backtrace_fuzzy(), backup_current_addr(), bb_info_print(), bbBegin(), bbFail(), bbget(), bbInstructions(), bbJump(), bbSize(), bdot(), bf_op(), bfd_get_bits(), bfd_getb16(), bfd_getb32(), bfd_getl16(), bfd_getl32(), bin_elf_versioninfo_versym(), binsym(), bits_hint_acc_cb(), block_new(), block_recurse_successor_cb(), bochs_read(), bp_bits_at(), bp_is_mapped(), branch(), buf_bytes_seek(), buf_file_seek(), buf_io_fd_seek(), buf_io_seek(), buf_move_back(), buf_ref_seek(), buf_seek(), buf_sparse_seek(), canWrite(), check_label(), checkHeader(), chip8_anop(), chunk_cmp(), chunk_index_in(), cil_analyze_op(), classes(), clear_bb_vars(), cmd_address_info(), cmd_aea(), cmd_analysis_esil(), cmd_analysis_graph(), cmd_analysis_ucall_ref(), cmd_debug_backtrace(), cmd_debug_current_modules(), cmd_pxr(), collect_nodes_at(), collect_nodes_in(), colorfor_cb(), compute_ref(), construct_rop_gadget(), core_analysis_bytes_desc(), core_analysis_bytes_esil(), core_analysis_bytes_size(), core_analysis_graph_label(), core_flg_class_set(), core_flg_fcn_set(), cpu_memory_map(), cr16_op(), create_section_from_phdr(), create_section_plt(), dalvik_op(), debug_gdb_read_at(), debug_gdb_write_at(), debug_qnx_read_at(), debug_qnx_write_at(), decode_jmp(), decode_ldr_set_addr(), DecodeLFHEntry(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), del(), deserialize_memory_cb(), deserialize_registers_cb(), diffrow(), disasm_strings(), disasm_until_ret(), do_debug_trace_calls(), do_esil_search(), do_iter_offsets(), do_rd_expr(), do_ref_search(), drx_get_at(), drx_list(), drx_set(), ds_build_op_str(), ds_init(), ds_pre_emulation(), ds_print_core_vmode(), ds_print_esil_analysis(), ds_print_shortcut(), ds_show_flags(), ds_sub_jumps(), dsmOneArcInst(), dump_maps(), ebc_analysis_call(), ebc_analysis_jmp(), ebc_analysis_jmp8(), ebc_op(), encode_addr16(), encode_addr32(), ensure_addr_hint_record(), ensure_ranged_hint_record(), entries(), esil_peek_n(), esil_poke_n(), esilbreak_mem_read(), esilbreak_mem_write(), exi_bit(), exi_dir1(), exprmatch(), exr_bit(), exr_dir1(), extract_addr_from_code(), extract_arg(), extract_reladdr(), extract_signed_integer(), extract_unsigned_integer(), exw_bit(), exw_dir1(), exw_dir2(), fcn_append_basic_block(), fcn_takeover_block_recursive_followthrough_cb(), fd_read_at_wrap(), fd_write_at_wrap(), fetch_data(), fields(), filter(), find_addr(), find_bb(), find_block_at_xref_addr(), find_core_reg(), find_matching_bracket(), find_node_at(), find_node_in(), fold_asm_trace(), follow_ref(), foreachOffset(), free_rz_addr(), function_rename(), gb_anop(), gb_op_calljump(), get_backtrace_info(), get_body(), get_closest_map(), get_comments_cb(), get_const_ext_from_addr(), get_corner_char(), get_dynamic_elf_symbols(), get_elf_intrp(), get_entrypoint(), get_esil_stack_name(), get_got_entry(), get_kernel_base(), get_main(), get_main_offset_linux_64_pie(), get_main_offset_x86_gcc(), get_main_offset_x86_non_pie(), get_module_timestamp(), get_ptr(), get_ptr_at(), get_ptr_ble(), get_reg_at(), get_relocs(), get_relocs_entry_from_dt_dynamic_aux(), get_section_name(), get_sections(), get_sections_from_dt_dynamic(), get_src_regname(), get_stubs_info(), get_symbols(), get_title(), getFunctionName(), getName(), getNameDelta(), getpcfromstack(), getref(), getRefPtr(), GH(), global_var_load_cb(), goto_asmqjmps(), gprobe_read(), gprobe_runcode(), gprobe_write(), graph_breakpoint(), h8300_analysis_jsr(), h8300_op(), handle_arm_hint(), handle_arm_special_symbol(), handle_skip_next_instruction(), handle_var_stack_access(), hasrefs_cb(), hex_disasm_with_templates(), hex_extend_op(), hex_get_instr_at_addr(), hex_get_pkt(), hexagon_disasm_instruction(), hexagon_get_pkt_index_of_addr(), hexagon_reverse_opcode(), hexagon_v6_op(), hints_acc_store_cb(), hints_at_addr(), hints_load_cb(), hit(), hook_mem_read(), hook_mem_write(), hook_NOP_mem_write(), i4004_op(), i8051_op(), i8080_op(), in_physical_phdr(), in_virtual_phdr(), inBetween(), init_dynstr_aux(), initialize_stack(), initializeEsil(), inRange(), insn_to_op(), INST_HANDLER(), inSymtab(), internal_esil_mem_read(), internal_esil_mem_read_no_null(), internal_esil_mem_write(), internal_esil_mem_write_no_null(), io_map_add(), io_map_new(), is_delta_pointer_table(), is_in_symbol_range(), is_repeatable_inst(), is_skippable_addr(), is_string_at(), is_x86_call(), is_x86_ret(), iscallret(), isInvalid(), isValid(), isValidAddress(), java_analysis(), jemalloc_get_chunks(), jmp(), jmp_dest(), ldr(), len_fixup(), libs(), lines(), listcb(), listxrefs(), load_effect(), loadGP(), lsop(), lua53_anal_op(), lua54_anal_op(), m68k_read_disassembler_16(), m68k_read_disassembler_32(), m68k_read_disassembler_64(), m68k_read_safe_16(), m68k_read_safe_32(), m68k_read_safe_64(), MACH0_(), mach_headerfields(), mal_analysis(), map_cpu_memory(), map_direct_addr(), mcore_analysis(), mcore_snprint(), meta_for_reloc(), meta_function_comment_remove(), meta_gb_bankswitch_cmt(), meta_get_flag(), meta_load_cb(), meta_remove(), meta_remove_size(), meta_set_flag(), meta_set_string(), meta_string_8bit_add(), meta_string_guess_add(), mips_j(), mips_op(), moduleAt(), msp430_op(), mymemread(), mymemwrite(), mymemwrite2(), myregwrite(), myvalid(), n_oper_to_addr(), need_add2history(), noreturn_recurse(), num_callback(), ocaml_cs_disasm(), ocaml_cs_disasm_internal(), on_fcn_delete(), on_fcn_new(), on_fcn_rename(), on_map_skyline(), op(), op0_memimmhandle(), op1_memimmhandle(), op_cache_get(), open_nobin_file(), opiscall(), or1k_op(), parse_bdot(), pdb_set_symbols(), perform_mapped_file_yank(), pic18_cond_branch(), post_address(), prepend_current_pc(), prevop_addr(), prevOpcode(), print_addr(), print_addr_hint_cb(), print_arch_hint_cb(), print_arena_stats(), print_bits_hint_cb(), print_cmd_analysis_after_traps_print(), print_debug_map_line(), print_debug_maps_ascii_art(), print_fcn_arg(), print_function_labels_cb(), print_insn_aarch64(), print_insn_arg(), print_insn_cris_generic(), print_insn_mode(), print_loop(), print_meta_list(), print_rop(), print_with_operands(), proc_mem_img(), process_reference_noreturn_cb(), propagate_return_type_pointer(), propeller_op(), prune_hits_in_addr_range(), ptrace_wrap(), pyc_op(), qnxr_read_memory(), qnxr_write_memory(), ranged_hint_record_cmp(), rasm_disasm(), raw_rtti_parse(), rd_character(), rd_expr_and(), rd_expr_equal(), rd_expr_or(), rd_expr_shift(), rd_expr_unequal(), rd_expr_xor(), rd_factor(), rd_label(), rd_number(), rd_otherbasenumber(), rd_term(), rd_value(), read_ahead(), read_desc(), read_elf_intrp(), read_entry(), read_image_clr_header(), read_image_debug_directory_entry(), read_image_delay_import_directory(), read_image_export_directory(), read_image_import_directory(), read_image_metadata_tilde_header(), read_image_resource_data_entry(), read_image_resource_directory(), read_image_resource_directory_entry(), read_image_section_header(), read_memory64_list(), read_module(), read_nt_headers(), read_tls_directory(), readDword(), readQword(), rebase_offset_to_paddr(), recovery_analysis_complete_object_locator(), recovery_analysis_type_descriptor(), recurse_bb(), refline_kept(), relocation_function_process_noreturn(), relocation_noreturn_process(), resolve_mig_subsystem(), resolve_n_register(), resolve_syscalls(), restore_current_addr(), retpoline_reg(), rfe(), riscv_op(), rjmp(), rjmp_dest(), rsp_mem_addr(), rsp_op(), rtti_itanium_class_type_info_init(), rtti_itanium_class_type_info_new(), rtti_itanium_read_type_name(), rtti_itanium_read_type_name_custom(), rtti_itanium_si_class_type_info_init(), rtti_itanium_si_class_type_info_new(), rtti_itanium_vmi_class_type_info_init(), rtti_itanium_vmi_class_type_info_new(), rtti_msvc_addr(), rtti_msvc_print_class_hierarchy_descriptor(), rtti_msvc_print_complete_object_locator(), rtti_msvc_print_type_descriptor(), rtti_msvc_read_base_class_array(), rtti_msvc_read_base_class_descriptor(), rtti_msvc_read_class_hierarchy_descriptor(), rtti_msvc_read_complete_object_locator(), rtti_msvc_read_type_descriptor(), run_basic_block_analysis(), run_old_command(), rz_analysis_addr_hints_at(), rz_analysis_basic_block_find_paths_handler(), rz_analysis_basic_block_list_handler(), rz_analysis_block_analyze_ops(), rz_analysis_block_chop_noreturn(), rz_analysis_block_op_starts_at(), rz_analysis_block_relocate(), rz_analysis_block_split(), rz_analysis_blocks_foreach_in(), rz_analysis_blocks_foreach_intersect(), rz_analysis_case_op_new(), rz_analysis_check_fcn(), rz_analysis_class_method_exists_by_addr(), rz_analysis_class_method_get_by_addr(), rz_analysis_class_rename_flag(), rz_analysis_class_set_flag(), rz_analysis_create_block(), rz_analysis_create_function(), rz_analysis_data(), rz_analysis_data_kind(), rz_analysis_data_new(), rz_analysis_data_new_string(), rz_analysis_esil_init_mem_handler(), rz_analysis_esil_init_mem_remove_handler(), rz_analysis_esil_mem_read(), rz_analysis_esil_mem_write(), rz_analysis_esil_set_pc(), rz_analysis_fcn(), rz_analysis_fcn_add_bb(), rz_analysis_fcn_bbget_at(), rz_analysis_fcn_bbget_in(), rz_analysis_fcn_del(), rz_analysis_fcn_del_locs(), rz_analysis_fcn_next(), rz_analysis_function_blocks_add_handler(), rz_analysis_function_blocks_color_handler(), rz_analysis_function_contains(), rz_analysis_function_del_handler(), rz_analysis_function_delete_label(), rz_analysis_function_delete_label_at(), rz_analysis_function_get_label(), rz_analysis_function_get_label_at(), rz_analysis_function_get_var_reg_at(), rz_analysis_function_get_var_stackptr_at(), rz_analysis_function_relocate(), rz_analysis_function_set_label(), rz_analysis_function_vars_bp_getref_handler(), rz_analysis_function_vars_bp_setref_handler(), rz_analysis_function_vars_regs_getref_handler(), rz_analysis_function_vars_regs_setref_handler(), rz_analysis_function_vars_sp_getref_handler(), rz_analysis_function_vars_sp_setref_handler(), rz_analysis_functions_merge_handler(), rz_analysis_get_block_at(), rz_analysis_get_blocks_in(), rz_analysis_get_blocks_intersect(), rz_analysis_get_fcn_in(), rz_analysis_get_fcn_in_bounds(), rz_analysis_get_function_at(), rz_analysis_get_functions_in(), rz_analysis_get_used_function_var(), rz_analysis_global_variable_add_handler(), rz_analysis_global_variable_delete_byaddr_handler(), rz_analysis_hint_arch_at(), rz_analysis_hint_bits_at(), rz_analysis_hint_del(), rz_analysis_hint_get(), rz_analysis_hint_set_arch(), rz_analysis_hint_set_bits(), rz_analysis_hint_set_immbase(), rz_analysis_hint_unset_arch(), rz_analysis_hint_unset_bits(), rz_analysis_hint_unset_esil(), rz_analysis_hint_unset_fail(), rz_analysis_hint_unset_high(), rz_analysis_hint_unset_immbase(), rz_analysis_hint_unset_jump(), rz_analysis_hint_unset_newbits(), rz_analysis_hint_unset_nword(), rz_analysis_hint_unset_offset(), rz_analysis_hint_unset_opcode(), rz_analysis_hint_unset_pointer(), rz_analysis_hint_unset_ret(), rz_analysis_hint_unset_size(), rz_analysis_hint_unset_stackframe(), rz_analysis_hint_unset_syntax(), rz_analysis_hint_unset_type(), rz_analysis_hint_unset_val(), rz_analysis_il_get_mem_op_trace(), rz_analysis_il_mem_trace_contains(), rz_analysis_il_trace_instruction_new(), rz_analysis_il_vm_step(), rz_analysis_noreturn_add(), rz_analysis_noreturn_at(), rz_analysis_noreturn_at_addr(), rz_analysis_noreturn_functions(), rz_analysis_op(), rz_analysis_op_hexstr(), rz_analysis_op_reg_delta(), rz_analysis_reflines_get(), rz_analysis_reflines_middle(), rz_analysis_reflines_str(), rz_analysis_rtti_itanium_print_at_vtable(), rz_analysis_rtti_msvc_print_base_class_descriptor(), rz_analysis_rtti_msvc_print_class_hierarchy_descriptor(), rz_analysis_rtti_msvc_print_complete_object_locator(), rz_analysis_rtti_msvc_print_type_descriptor(), rz_analysis_rtti_print_at_vtable(), rz_analysis_switch_op_add_case(), rz_analysis_switch_op_new(), rz_analysis_trace_bb(), rz_analysis_type_link_at(), rz_analysis_type_link_exists(), rz_analysis_type_paths_by_address(), rz_analysis_type_set_link(), rz_analysis_type_unlink(), rz_analysis_update_analysis_range(), rz_analysis_value_set_ut64(), rz_analysis_var_get_access_at(), rz_analysis_var_get_dst_var(), rz_analysis_var_global_delete_byaddr_at(), rz_analysis_var_global_delete_byaddr_in(), rz_analysis_var_global_get_byaddr_at(), rz_analysis_var_global_get_byaddr_in(), rz_analysis_var_global_list_show(), rz_analysis_var_global_new(), rz_analysis_vtable_parse_at(), rz_analysis_xrefs_get_from(), rz_analysis_xrefs_get_to(), rz_analysis_xrefs_to_graph_cmd_handler(), rz_arm_cs_analysis_op_32_esil(), rz_arm_it_apply_cond(), rz_asm_from_string(), rz_asm_to_string(), rz_avr_esil_opcode(), rz_bflt_get_entry(), rz_bin_addr2line(), rz_bin_addr2text(), rz_bin_elf_add_addr(), rz_bin_elf_add_off(), rz_bin_elf_fix_arm_thumb_addr(), rz_bin_elf_get_fini_offset(), rz_bin_elf_get_gnu_hash_table(), rz_bin_elf_get_hash_table(), rz_bin_elf_get_init_offset(), rz_bin_elf_is_thumb_addr(), rz_bin_elf_mul_addr(), rz_bin_elf_mul_off(), rz_bin_java_class_entrypoints(), rz_bin_java_class_methods_as_symbols(), rz_bin_java_class_resolve_symbol(), rz_bin_object_addr_with_base(), rz_bin_omf_get_entry(), rz_bin_relocs_patch_find_targets_map_base(), rz_bin_source_line_info_get_first_at(), rz_bin_string_filter(), rz_bin_strpurge(), rz_bin_te_get_main_paddr(), rz_bp_add(), rz_bp_add_hw(), rz_bp_add_sw(), rz_bp_del(), rz_bp_enable(), rz_bp_get_at(), rz_bp_get_bytes(), rz_bp_get_ending_at(), rz_bp_get_in(), rz_bp_get_index_at(), rz_bp_restore_except(), rz_bp_set_trace(), rz_bp_size_at(), rz_bp_traptrace_next(), rz_bp_watch_add(), rz_buf_fread_at(), rz_buf_fwd_scan(), rz_buf_fwrite_at(), rz_buf_get_nstring(), rz_buf_get_string(), rz_buf_insert_bytes(), rz_buf_read8_at(), rz_buf_read_at(), rz_buf_seek(), rz_buf_sleb128_at(), rz_buf_uleb128_at(), rz_buf_write8_at(), rz_buf_write_at(), rz_cmd_cmp_hex_block_handler(), rz_cmd_cmp_hex_diff_lines_handler(), rz_cmd_debug_allocate_maps_handler(), rz_cmd_debug_deallocate_map_handler(), rz_cmd_debug_dmi(), rz_cmd_debug_dml_handler(), rz_cmd_debug_dmL_handler(), rz_cmd_debug_dmS_handler(), rz_cmd_debug_map_current_handler(), rz_cmd_debug_remove_bp_index_handler(), rz_cmd_debug_step_prog_handler(), rz_cmd_debug_trace_add_addrs_handler(), rz_cmd_debug_trace_calls_handler(), rz_cmd_heap_chunk_print_handler(), rz_cmd_help(), rz_cmd_search(), rz_coff_get_entry(), rz_coff_rebase_sym(), rz_core_add_asmqjmp(), rz_core_analysis_address(), rz_core_analysis_all(), rz_core_analysis_bb_info_print(), rz_core_analysis_bb_seek(), rz_core_analysis_bytes(), rz_core_analysis_callgraph(), rz_core_analysis_calls(), rz_core_analysis_coderefs(), rz_core_analysis_codexrefs(), rz_core_analysis_continue_until_call(), rz_core_analysis_continue_until_syscall(), rz_core_analysis_cycles(), rz_core_analysis_data(), rz_core_analysis_datarefs(), rz_core_analysis_esil(), rz_core_analysis_esil_emulate(), rz_core_analysis_esil_init_mem(), rz_core_analysis_esil_init_mem_del(), rz_core_analysis_esil_init_mem_p(), rz_core_analysis_esil_step_over_until(), rz_core_analysis_fcn_clean(), rz_core_analysis_fcn_merge(), rz_core_analysis_function_add(), rz_core_analysis_function_rename(), rz_core_analysis_function_until(), rz_core_analysis_get_comments(), rz_core_analysis_graph(), rz_core_analysis_graph_to(), rz_core_analysis_hint_print(), rz_core_analysis_importxrefs(), rz_core_analysis_name(), rz_core_analysis_op(), rz_core_analysis_optype_colorfor(), rz_core_analysis_propagate_noreturn(), rz_core_analysis_read_at(), rz_core_analysis_rename(), rz_core_analysis_type_match(), rz_core_arch_bits_at(), rz_core_asm_back_disassemble(), rz_core_asm_back_disassemble_all(), rz_core_asm_back_disassemble_byte(), rz_core_asm_back_disassemble_instr(), rz_core_asm_bwdisassemble(), rz_core_asm_strsearch(), rz_core_bin_apply_imports(), rz_core_bin_apply_main(), rz_core_bin_apply_maps(), rz_core_bin_apply_relocs(), rz_core_bin_apply_sections(), rz_core_bin_apply_symbols(), rz_core_bin_export_info(), rz_core_bin_imports_print(), rz_core_bin_main_print(), rz_core_bin_relocs_print(), rz_core_cmd_foreach(), rz_core_cmd_foreach3(), rz_core_cmd_lastcmd_repeat(), rz_core_cmd_subst_i(), rz_core_cmp_mem_data(), rz_core_cmpwatch_add(), rz_core_cmpwatch_del(), rz_core_cmpwatch_get(), rz_core_cmpwatch_revert(), rz_core_cmpwatch_show(), rz_core_cmpwatch_update(), rz_core_debug_bp_add(), rz_core_debug_breakpoint_toggle(), rz_core_debug_continue_until(), rz_core_debug_esil(), rz_core_debug_map_print(), rz_core_debug_step_over(), rz_core_debug_step_skip(), rz_core_disasm_instruction(), rz_core_disassemble_bytes(), rz_core_disassemble_instr(), rz_core_dump(), rz_core_esil_step(), rz_core_extend_at(), rz_core_file_open_load(), rz_core_file_reopen_remote_debug(), rz_core_flag_describe(), rz_core_gdiff_function_1_file(), rz_core_gdiff_function_2_files(), rz_core_get_boundaries_prot(), rz_core_get_reloc_to(), rz_core_get_section_name(), rz_core_getreloc(), rz_core_link_stroff(), rz_core_magic(), rz_core_magic_at(), rz_core_meta_append(), rz_core_meta_comment_add(), rz_core_meta_editor(), rz_core_meta_pascal_string_add(), rz_core_meta_print_list_at(), rz_core_meta_print_list_in_function(), rz_core_meta_string_add(), rz_core_op_analysis(), rz_core_op_str(), rz_core_pava(), rz_core_print_disasm(), rz_core_print_disasm_all(), rz_core_print_disasm_json(), rz_core_print_dump(), rz_core_print_dump_str(), rz_core_print_examine(), rz_core_print_hexdump(), rz_core_print_hexdump_byline(), rz_core_print_hexdump_byline_str(), rz_core_print_hexdump_or_hexdiff(), rz_core_print_hexdump_or_hexdiff_str(), rz_core_print_offname(), rz_core_print_offsize(), rz_core_search_rop(), rz_core_search_value_in_range(), rz_core_seek(), rz_core_seek_analysis_bb(), rz_core_seek_and_save(), rz_core_seek_arch_bits(), rz_core_seek_base(), rz_core_seek_opcode_backward(), rz_core_seek_opt(), rz_core_shift_block(), rz_core_transform_op(), rz_core_types_link(), rz_core_types_link_print(), rz_core_types_link_show(), rz_core_visual_analysis(), rz_core_visual_analysis_refresh(), rz_core_visual_analysis_refresh_column(), rz_core_visual_cmd(), rz_core_visual_comments(), rz_core_visual_define(), rz_core_visual_hudclasses(), rz_core_visual_hudstuff(), rz_core_visual_mark_set(), rz_core_visual_offset(), rz_core_visual_prevopsz(), rz_core_visual_prompt_input(), rz_core_visual_seek_animation(), rz_core_visual_title(), rz_core_visual_trackflags(), rz_core_visual_view_rop(), rz_core_visual_xrefs(), rz_core_write_at(), rz_core_write_base64_at(), rz_core_write_base64d_at(), rz_core_write_block(), rz_core_write_block_op_at(), rz_core_write_duplicate_at(), rz_core_write_hexpair(), rz_core_write_length_string_at(), rz_core_write_random_at(), rz_core_write_seq_at(), rz_core_write_string_at(), rz_core_write_string_wide_at(), rz_core_write_string_zero_at(), rz_core_write_value_at(), rz_core_write_value_inc_at(), rz_core_yank(), rz_core_yank_file(), rz_core_yank_paste(), rz_core_yank_set(), rz_core_yank_set_str(), rz_core_yank_string(), rz_core_yank_to(), rz_debug_bochs_breakpoint(), rz_debug_bp_add(), rz_debug_continue_until(), rz_debug_continue_until_internal(), rz_debug_continue_until_nonblock(), rz_debug_desc_read(), rz_debug_desc_seek(), rz_debug_desc_write(), rz_debug_drx_at(), rz_debug_drx_set(), rz_debug_map_alloc(), rz_debug_map_dealloc(), rz_debug_map_get(), rz_debug_map_list_visual(), rz_debug_map_new(), rz_debug_map_protect(), rz_debug_memory_permission_handler(), rz_debug_session_add_mem_change(), rz_debug_snap_contains(), rz_debug_trace_add(), rz_debug_trace_get(), rz_debug_trace_ins_before(), rz_debug_trace_is_traceable(), rz_dyldcache_get_objc_opt_info(), rz_flag_zone_add(), rz_flag_zone_around(), rz_get_size(), rz_heap_chunk(), rz_heap_chunk_wrapper(), rz_heap_debug_block_win(), rz_il_event_mem_write_new(), rz_il_handler_load(), rz_il_handler_loadw(), rz_il_handler_store(), rz_il_handler_storew(), rz_il_vm_create_label(), rz_il_vm_update_label(), rz_io_cache_at(), rz_io_cache_read(), rz_io_cache_write(), rz_io_desc_read_at(), rz_io_desc_write_at(), rz_io_extend_at(), rz_io_fd_read_at(), rz_io_fd_seek(), rz_io_fd_write_at(), rz_io_map_add(), rz_io_map_add_batch(), rz_io_map_get(), rz_io_map_is_mapped(), rz_io_map_new(), rz_io_map_next_address(), rz_io_map_next_available(), rz_io_map_remap(), rz_io_map_remap_fd(), rz_io_map_resize(), rz_io_nread_at(), rz_io_plugin_read_at(), rz_io_plugin_write_at(), rz_io_read_at(), rz_io_read_at_mapped(), rz_io_read_i(), rz_io_write_at(), rz_io_write_i(), rz_itv_contain(), rz_itv_intersect(), rz_itv_new(), rz_itv_overlap2(), rz_lua_analysis_op(), rz_main_rizin(), rz_main_rz_bin(), rz_mem_count(), rz_meta_data_handler(), rz_meta_data_remove_handler(), rz_meta_del(), rz_meta_get_at(), rz_meta_get_in(), rz_meta_get_string(), rz_meta_set(), rz_meta_set_data_at(), rz_meta_set_string(), rz_meta_set_with_subtype(), rz_num_tail(), rz_num_tail_base(), rz_open_handler(), rz_open_maps_relocate_current_handler(), rz_open_maps_relocate_handler(), rz_open_nobin_handler(), rz_open_nobin_write_handler(), rz_open_write_handler(), RZ_PACKED(), rz_parse_filter(), rz_parse_filter_dup(), rz_print_addr(), rz_print_fill(), rz_print_hexdump_str(), rz_print_hexii(), rz_print_set_screenbounds(), rz_range_add_from_string(), rz_range_contains(), rz_range_get_data(), rz_range_item_get(), rz_range_set_data(), rz_regs_show_valgroup(), rz_reopen_debug_file_handler(), rz_run_start(), rz_search_find(), rz_search_hit_new(), rz_search_pattern(), rz_seek_asz_handler(), rz_seek_begin_handler(), rz_seek_end_handler(), rz_seek_function_handler(), rz_seek_handler(), rz_seek_offset(), rz_serialize_analysis_global_var_save(), rz_serialize_analysis_meta_save(), rz_serialize_analysis_switch_op_load(), rz_skyline_contains(), rz_skyline_get(), rz_skyline_get_intersect(), rz_skyline_get_item(), rz_skyline_get_item_intersect(), rz_str_range_in(), rz_type_format_10bytes(), rz_type_format_bitfield(), rz_type_format_data_internal(), rz_type_format_double(), rz_type_format_enum(), rz_type_format_float(), rz_type_format_hex(), rz_type_format_hexflag(), rz_type_format_int(), rz_type_format_nulltermstring(), rz_type_format_num(), rz_type_format_num_specifier(), rz_type_format_octal(), rz_type_format_string(), rz_type_format_time(), rz_type_format_word(), rz_type_link_del_handler(), rz_type_link_handler(), rz_type_link_show_handler(), rz_type_print_handler(), rz_type_xrefs_function_handler(), rz_write_extend_hexbytes_handler(), rz_write_extend_zero_handler(), rz_write_from_io_handler(), rz_yank_to_handler(), save_typelink(), search_similar_pattern_in(), sections(), sections_from_bin(), sections_from_mach0(), sections_print_json(), sections_print_table(), seek_check_save(), seek_save(), set_bin_relocs(), set_invalid_op(), set_jump_realname(), setup_new_instr(), sh_op(), shared_data_read_at(), shortest_path_successor_cb(), skip_hp(), snes_anop(), SOCKOPT_SETTER(), sparc_op(), sparse_write(), step_until(), str(), strex(), stringAt(), subvar(), symbols(), symbols_from_bin(), symbols_from_mach0(), symbols_from_stubs(), symbols_print(), tbb(), tms320_c55x_plus_op(), tms320_op(), trace_hook_mem_read(), trace_hook_mem_write(), try_loadlib(), type_format_print_variable(), type_match(), typelinks_load_sdb(), types_xrefs_function(), unset_addr_hint_record(), update_stat_for_op(), updateAddr(), uv__convert_to_localhost_if_unspecified(), uv__send(), uv__tcp_bind(), uv__tcp_connect(), uv__udp_bind(), uv__udp_check_before_send(), uv__udp_connect(), uv__udp_disconnect(), uv__udp_is_bound(), uv__udp_is_connected(), uv__udp_maybe_deferred_bind(), uv__udp_send(), uv__udp_try_send(), uv_getnameinfo(), uv_ip4_addr(), uv_ip6_addr(), uv_tcp_bind(), uv_tcp_connect(), uv_tcp_try_bind(), uv_tcp_try_connect(), uv_udp_bind(), uv_udp_connect(), uv_udp_maybe_bind(), uv_udp_send(), uv_udp_try_send(), uv_wsarecvfrom_workaround(), v810_op(), v850_op(), va2pa(), vaddr_to_paddr(), value_fill_addr_pc_disp(), var_accesses_list(), var_functions_show(), var_rename(), var_variables_show(), variable_rename(), variable_set_type(), visual_comma(), visual_seek_animation(), vle_snprint(), w32_map_alloc(), w32_map_dealloc(), w32_map_protect(), walkSymbols(), wasm_op(), winkd_bkpt(), winkd_query_mem(), write_image_section_header(), writeback(), xap_op(), xnu_dbg_modules(), xnu_map_alloc(), xnu_map_dealloc(), xnu_map_protect(), xrefs_graph(), xrefs_graph_fcn_start_json(), xtensa_accer_op(), xtensa_b_op(), xtensa_calln_op(), xtensa_fp0_op(), xtensa_fp1_op(), xtensa_imm12s(), xtensa_imm18s(), xtensa_imm6s(), xtensa_imm8s(), xtensa_imp_op(), xtensa_l32r_op(), xtensa_lsai_op(), xtensa_lsc4_op(), xtensa_lsci_op(), xtensa_lscx_op(), xtensa_offset(), xtensa_op(), xtensa_qrst_op(), xtensa_rfei_op(), xtensa_rst0_op(), xtensa_rst1_op(), xtensa_rst2_op(), xtensa_rt0_op(), xtensa_si_op(), xtensa_snm0_op(), xtensa_st0_op(), xtensa_st1_op(), xtensa_st2n_op(), xtensa_st3n_op(), xtensa_sync_op(), xtensa_tlb_op(), and z80_analysis_op().

baseaddr

int baseaddr

static

Definition at line 79 of file z80asm.c.

Referenced by assemble(), compute_ref(), core_bin_reload(), core_file_do_load_for_debug(), core_file_do_load_for_io_plugin(), get_bin_info(), GetHeapGlobalsOffset(), print_mips16_insn_arg(), rd_value(), rz_bin_options_init(), rz_bin_reload(), rz_core_bin_apply_all_info(), and rz_core_bin_options_init().

bitsetres

const char * bitsetres

static

Definition at line 67 of file z80asm.c.

Referenced by rd_0_7().

comma

int comma

static

Definition at line 76 of file z80asm.c.

Referenced by assemble(), callable_as_string(), cb_asmarch(), compute_ref(), ds_atabs_option(), ds_cdiv_optimization(), ds_show_flags(), get_check_names(), indx(), mount_oldstr(), riscv_op(), rz_analysis_fcn_format_sig(), rz_analysis_rtti_print_all(), rz_cmd_macro(), rz_hex_from_c_array(), rz_hex_from_py_array(), rz_table_tocsv(), rz_type_format_byte(), sh_op_movl_param_bits(), sh_op_param_bits(), and subvar().

define_macro

int define_macro = 0

static

Definition at line 88 of file z80asm.c.

Referenced by assemble().

file

int file

static

Definition at line 58 of file z80asm.c.

Referenced by __rap_open(), __system(), add_download(), cabd_read_headers(), compute_ref(), file_create(), fopen64_file_func(), fopen_file_func(), fs__mkstemp_func(), fs__open(), get_lib_name(), load_scripts_for(), main(), mpc_input_new_file(), pal_seek(), pids_sons_of_r(), process_cabinet(), rabin_do_operation(), recursive_search_glob(), rtr_dir_files(), run_commands(), rz_bin_fatmach0_new(), rz_bin_mz_new(), rz_bin_te_new(), rz_buf_new_file(), rz_core_file_close_fd(), rz_core_file_get_by_fd(), rz_core_file_reopen_remote_debug(), rz_core_loadlibs(), rz_core_magic_at(), rz_core_parse_rizinrc(), rz_diff_file_open(), rz_diff_io_open(), rz_file_path(), rz_main_rizin(), rz_project_load_file_raw(), rz_project_save_file(), rz_project_save_handler(), rz_reg_set_profile(), rz_subprocess_start(), rz_syscmd_cat(), rz_syscmd_head(), rz_syscmd_sort(), rz_syscmd_tail(), rz_syscmd_uniq(), rzfind_open_file(), search_path(), uv_fs_close(), uv_fs_fchmod(), uv_fs_fchown(), uv_fs_fdatasync(), uv_fs_fstat(), uv_fs_fsync(), uv_fs_ftruncate(), uv_fs_futime(), uv_fs_read(), uv_fs_write(), winkd_download_module_and_pdb(), and zip_source_file_common_new().

indexed

int indexed

static

Definition at line 70 of file z80asm.c.

Referenced by assemble(), rd_hlx(), rd_jp(), rd_ld(), rd_ld_nn(), rd_lda(), rd_ldbcdehla(), rd_r(), rd_r_(), rd_r_add(), rd_r_rr(), rd_rrxx(), rd_sp(), and rd_stack().

indexjmp

const char * indexjmp

static

Definition at line 67 of file z80asm.c.

Referenced by assemble(), rd_ld(), rd_lda(), rd_ldbcdehla(), rd_r(), rd_r_(), rd_r_add(), and rd_r_rr().

mem_delimiter

char mem_delimiter

static

Definition at line 82 of file z80asm.c.

Referenced by indx(), rd_byte(), and rd_word().

mnemonics

const char* mnemonics[]

static

Initial value:

= {
    "call", "cpdr", "cpir", "djnz", "halt", "indr", "inir", "lddr", "ldir",
    "otdr", "otir", "outd", "outi", "push", "reti", "retn", "rlca", "rrca",
    "defb", "defw", "defs", "defm",
    "adc", "add", "and", "bit", "ccf", "cpd", "cpi", "cpl", "daa", "dec", "equ",
    "exx", "inc", "ind", "ini", "ldd", "ldi", "neg", "nop", "out", "pop",
    "res", "ret", "rla", "rlc", "rld", "rra", "rrc", "rrd", "rst", "sbc",
    "scf", "set", "sla", "sll", "sli", "sra", "srl", "sub", "xor", "org",
    "cp", "di", "ei", "ex", "im", "in", "jp", "jr", "ld", "or", "rl", "rr",
    "db", "dw", "ds", "dm",
    "include", "incbin", "if", "else", "endif", "end", "macro", "endm",
    "seek", NULL
}

Definition at line 43 of file z80asm.c.

Referenced by readcommand().

obuf

unsigned char* obuf

static

Definition at line 36 of file z80asm.c.

Referenced by __cons_write(), assemble(), binutils_assemble(), goto_asmqjmps(), iob_net_read(), parse_abbrev_raw(), parse_aranges_raw(), parse_attr_value(), parse_ext_opcode(), parse_info_raw(), parse_line_raw(), parse_opcodes(), parse_std_opcode(), rz_debug_esil_stepi(), and update().

obuflen

int obuflen = 0

static

Definition at line 37 of file z80asm.c.

Referenced by assemble(), and file_vprintf().

readbyte

const char* readbyte

static

Definition at line 64 of file z80asm.c.

Referenced by assemble(), rd_byte(), rd_ld_hl(), rd_lda(), rd_ldbcdehla(), rd_nnc(), rd_r(), and rd_r_add().

readword

const char* readword

static

Definition at line 67 of file z80asm.c.

Referenced by assemble(), rd_ld(), rd_lda(), rd_nn_nn(), rd_sp(), and rd_word().

sp

int sp

static

Definition at line 91 of file z80asm.c.

Referenced by __init_panel_param(), __io_maps(), __panels_check_stackbase(), analysis_emul_init(), anop_esil(), asciiart_backtrace(), assemble(), backref(), backtrace_fuzzy(), backtrace_generic(), backtrace_vars(), check_label(), compute_ref(), count_flags_in_space(), dissect(), do_rd_expr(), ds_print_calls_hints(), ds_print_esil_analysis(), enlarge(), extract_arg(), false_positive(), fill_insn(), find_e_opts(), FUZ_unitTests(), get_state_pkt_index(), get_word_from_canvas(), indx(), internal_esil_reg_write_no_null(), p_b_cclass(), p_b_coll_elem(), printerr(), rd_character(), rd_expr_and(), rd_expr_equal(), rd_expr_or(), rd_expr_shift(), rd_expr_unequal(), rd_expr_xor(), rd_factor(), rd_label(), rd_number(), rd_otherbasenumber(), rd_term(), rd_value(), readlabel(), rz_analysis_appcall_handler(), rz_analysis_fcn_format_sig(), rz_arm_cs_analysis_op_32_esil(), rz_asm_massemble(), rz_cmd_kuery(), rz_cmd_panels(), rz_cmd_search(), rz_core_analysis_bytes(), rz_core_arg_get(), rz_core_debug_plugins_print(), rz_core_get_func_args(), rz_core_link_stroff(), rz_core_print_disasm_all(), rz_core_visual_view_rop(), rz_debug_step_soft(), rz_flag_space_remove_handler(), RZ_PACKED(), rz_socket_proc_close(), rz_socket_proc_gets(), rz_socket_proc_open(), rz_socket_proc_printf(), rz_socket_proc_read(), rz_socket_proc_ready(), rz_socket_proc_write(), rz_spaces_add(), rz_spaces_count(), rz_spaces_current(), rz_spaces_current_name(), rz_spaces_fini(), rz_spaces_free(), rz_spaces_get(), rz_spaces_init(), rz_spaces_is_empty(), rz_spaces_new(), rz_spaces_pop(), rz_spaces_purge(), rz_spaces_push(), rz_spaces_rename(), rz_spaces_set(), rz_spaces_unset(), rz_sys_pid_to_path(), selection_widget_select(), set_access_info(), skipword(), spaces_unset_single(), tms320_tokenize(), type_pos_hit(), unset_flagspace(), update_stat_for_op(), uv_uptime(), and winkd_get_profile().

stack

struct stack stack[MAX_INCLUDE]

static

Definition at line 91 of file z80asm.c.

Referenced by backtrace_fuzzy(), lunpipe(), and rz_core_get_stacksz().

verbose

int verbose = 0

static

Definition at line 73 of file z80asm.c.

Referenced by check_label(), colorfor_cb(), core_esil_init(), d_substitution(), diff_output_init(), do_rd_expr(), function_list_print_to_table(), help(), main(), parse_signature(), rd_character(), rd_expr_and(), rd_expr_equal(), rd_expr_or(), rd_expr_shift(), rd_expr_unequal(), rd_expr_xor(), rd_factor(), rd_label(), rd_number(), rd_otherbasenumber(), rd_term(), rd_value(), rz_analysis_var_rename(), rz_bin_coff_init(), rz_bin_coff_new_buf(), rz_bin_pe_new_buf(), rz_core_notify_begin(), rz_core_notify_done(), rz_core_notify_error(), rz_test_main(), rz_type_parse_string(), and type_match().

writebyte

int writebyte

static

Definition at line 63 of file z80asm.c.

Referenced by assemble(), rd_byte(), rd_ld_hl(), rd_lda(), rd_ldbcdehla(), rd_r(), and rd_r_add().

z80buffer

char* z80buffer = NULL

static

Definition at line 85 of file z80asm.c.

Referenced by assemble().