Attachment #46130 for bug #74477

View | Details | Raw Unified | Return to bug 74477
Collapse All | Expand All




	    fname++;
	fnlen = strcspn(fname, "\"");
	line = nasm_malloc(20 + fnlen);
	snprintf(line, 20+fnlen,"%%line %d %.*s", lineno, fnlen, fname);
	nasm_free(oldline);
    }
    if (tasm_compatible_mode)

		char *p, *q = t->text + 2;

		q += strspn(q, "$");
		snprintf(buffer, sizeof(buffer), "..@%lu.", ctx->number);
		p = nasm_strcat(buffer, q);
		nasm_free(t->text);
		t->text = p;

		    t = t->next;
		    continue;
		}
		if (tt->type == TOK_WHITESPACE)
		{
		    tt = tt->next;
		    continue;
		}
		if (tt->type != t->type)
			mstrcmp(tt->text, t->text, casesense))
		{
		    j = FALSE;	/* found mismatching tokens */
		    break;
		}
		/* Unify surrounding quotes for strings */
		if (t->type == TOK_STRING)
		{
		    tt->text[0] = t->text[0];
		    tt->text[strlen(tt->text) - 1] = t->text[0];
		    continue;
		}
		if (mstrcmp(tt->text, t->text, casesense) != 0)
		{
		    j = FALSE;	/* found mismatching tokens */
		    break;
		}

		t = t->next;
		tt = tt->next;
	    }
	    if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
		j = FALSE;	/* trailing gunk on one end or other */

		free_tlist(tt);

		/* Now define the macro for the argument */
		snprintf(directive, sizeof(directive), "%%define %s (%s+%d)", arg, StackPointer,
			offset);
		do_directive(tokenise(directive));
		offset += size;

		free_tlist(tt);

		/* Now define the macro for the argument */
		snprintf(directive, sizeof(directive), "%%define %s (%s-%d)", local, StackPointer,
			offset);
		do_directive(tokenise(directive));
		offset += size;

		/* Now define the assign to setup the enter_c macro correctly */
		snprintf(directive, sizeof(directive), "%%assign %%$localsize %%$localsize+%d",
			size);
		do_directive(tokenise(directive));


			 */
		    case '0':
			type = TOK_NUMBER;
			snprintf(tmpbuf, sizeof(tmpbuf), "%d", mac->nparam);
			text = nasm_strdup(tmpbuf);
			break;
		    case '%':
			type = TOK_ID;
			snprintf(tmpbuf, sizeof(tmpbuf), "..@%lu.", mac->unique);
			text = nasm_strcat(tmpbuf, t->text + 2);
			break;
		    case '-':

	return;

    va_start(arg, fmt);
    vsnprintf(buff, sizeof(buff), fmt, arg);
    va_end(arg);

    if (istk && istk->mstk && istk->mstk->name)

make_tok_num(Token * tok, long val)
{
    char numbuf[20];
    snprintf(numbuf, sizeof(numbuf), "%ld", val);
    tok->text = nasm_strdup(numbuf);
    tok->type = TOK_NUMBER;
}




    return data - origdata;
}

long disasm (unsigned char *data, char *output, int outbufsize, int segsize, 
	     long offset, int autosync, unsigned long prefer)
{
    struct itemplate **p, **best_p;
    int length, best_length = 0;

    slen = 0;

    if (lock)
	slen += snprintf(output+slen, outbufsize-slen, "lock ");
    for (i = 0; i < ins.nprefix; i++)
	switch (ins.prefixes[i]) {
	  case P_REP:   slen += snprintf(output+slen, outbufsize-slen, "rep "); break;
	  case P_REPE:  slen += snprintf(output+slen, outbufsize-slen, "repe "); break;
	  case P_REPNE: slen += snprintf(output+slen, outbufsize-slen, "repne "); break;
	  case P_A16:   slen += snprintf(output+slen, outbufsize-slen, "a16 "); break;
	  case P_A32:   slen += snprintf(output+slen, outbufsize-slen, "a32 "); break;
	  case P_O16:   slen += snprintf(output+slen, outbufsize-slen, "o16 "); break;
	  case P_O32:   slen += snprintf(output+slen, outbufsize-slen, "o32 "); break;
	}

    for (i = 0; i < elements(ico); i++)
	if ((*p)->opcode == ico[i]) {
	    slen += snprintf(output+slen, outbufsize-slen, "%s%s", icn[i],
			    whichcond(ins.condition));
	    break;
	}
    if (i >= elements(ico))
	slen += snprintf(output+slen, outbufsize-slen, "%s", insn_names[(*p)->opcode]);
    colon = FALSE;
    length += data - origdata;	       /* fix up for prefixes */
    for (i=0; i<(*p)->operands; i++) {

	    ins.oprs[i].basereg = whichreg ((*p)->opd[i],
					    ins.oprs[i].basereg);
	    if ( (*p)->opd[i] & TO )
		slen += snprintf(output+slen, outbufsize-slen, "to ");
	    slen += snprintf(output+slen, outbufsize-slen, "%s",
			    reg_names[ins.oprs[i].basereg-EXPR_REG_START]);
	} else if (!(UNITY & ~(*p)->opd[i])) {
	    output[slen++] = '1';
	} else if ( (*p)->opd[i] & IMMEDIATE ) {
	    if ( (*p)->opd[i] & BITS8 ) {
		slen += snprintf(output+slen, outbufsize-slen, "byte ");
		if (ins.oprs[i].segment & SEG_SIGNED) {
		    if (ins.oprs[i].offset < 0) {
			ins.oprs[i].offset *= -1;

			output[slen++] = '+';
		}
	    } else if ( (*p)->opd[i] & BITS16 ) {
		slen += snprintf(output+slen, outbufsize-slen, "word ");
	    } else if ( (*p)->opd[i] & BITS32 ) {
		slen += snprintf(output+slen, outbufsize-slen, "dword ");
	    } else if ( (*p)->opd[i] & NEAR ) {
		slen += snprintf(output+slen, outbufsize-slen, "near ");
	    } else if ( (*p)->opd[i] & SHORT ) {
		slen += snprintf(output+slen, outbufsize-slen, "short ");
	    }
	    slen += snprintf(output+slen, outbufsize-slen, "0x%lx", ins.oprs[i].offset);
	} else if ( !(MEM_OFFS & ~(*p)->opd[i]) ) {
	    slen += snprintf(output+slen, outbufsize-slen, "[%s%s%s0x%lx]",
			    (segover ? segover : ""),
			    (segover ? ":" : ""),
			    (ins.oprs[i].addr_size == 32 ? "dword " :

	} else if ( !(REGMEM & ~(*p)->opd[i]) ) {
	    int started = FALSE;
	    if ( (*p)->opd[i] & BITS8 )
		slen += snprintf(output+slen, outbufsize-slen, "byte ");
	    if ( (*p)->opd[i] & BITS16 )
		slen += snprintf(output+slen, outbufsize-slen, "word ");
	    if ( (*p)->opd[i] & BITS32 )
		slen += snprintf(output+slen, outbufsize-slen, "dword ");
	    if ( (*p)->opd[i] & BITS64 )
		slen += snprintf(output+slen, outbufsize-slen, "qword ");
	    if ( (*p)->opd[i] & BITS80 )
		slen += snprintf(output+slen, outbufsize-slen, "tword ");
	    if ( (*p)->opd[i] & FAR )
		slen += snprintf(output+slen, outbufsize-slen, "far ");
	    if ( (*p)->opd[i] & NEAR )
		slen += snprintf(output+slen, outbufsize-slen, "near ");
	    output[slen++] = '[';
	    if (ins.oprs[i].addr_size)
		slen += snprintf(output+slen, outbufsize-slen, "%s",
				(ins.oprs[i].addr_size == 32 ? "dword " :
				 ins.oprs[i].addr_size == 16 ? "word " : ""));
	    if (segover) {
		slen += snprintf(output+slen, outbufsize-slen, "%s:", segover);
		segover = NULL;
	    }
	    if (ins.oprs[i].basereg != -1) {
		slen += snprintf(output+slen, outbufsize-slen, "%s",
				reg_names[(ins.oprs[i].basereg -
					   EXPR_REG_START)]);
		started = TRUE;

	    if (ins.oprs[i].indexreg != -1) {
		if (started)
		    output[slen++] = '+';
		slen += snprintf(output+slen, outbufsize-slen, "%s",
				reg_names[(ins.oprs[i].indexreg -
					   EXPR_REG_START)]);
		if (ins.oprs[i].scale > 1)
		    slen += snprintf(output+slen, outbufsize-slen, "*%d", ins.oprs[i].scale);
		started = TRUE;
	    }
	    if (ins.oprs[i].segment & SEG_DISP8) {

		    ins.oprs[i].offset = - (signed char) ins.oprs[i].offset;
		    sign = '-';
		}
		slen += snprintf(output+slen, outbufsize-slen, "%c0x%lx", sign,
				ins.oprs[i].offset);
	    } else if (ins.oprs[i].segment & SEG_DISP16) {
		if (started)
		    output[slen++] = '+';
		slen += snprintf(output+slen, outbufsize-slen, "0x%lx", ins.oprs[i].offset);
	    } else if (ins.oprs[i].segment & SEG_DISP32) {
		if (started)
		    output[slen++] = '+';
		slen += snprintf(output+slen, outbufsize-slen, "0x%lx", ins.oprs[i].offset);
	    }
	    output[slen++] = ']';
	} else {
	    slen += snprintf(output+slen, outbufsize-slen, "<operand%d>", i);
	}
    }
    output[slen] = '\0';

    return length;
}

long eatbyte (unsigned char *data, char *output, int outbufsize) 
{
    snprintf(output, outbufsize, "db 0x%02X", *data);
    return 1;
}

Lines 243-252 Link Here

(-)ndisasm.c.orig (-2 / +2 lines)
243	nextsync = next_sync (offset, &synclen);	243	nextsync = next_sync (offset, &synclen);
244	}	244	}
245	while (p > q && (p - q >= INSN_MAX \|\| lenread == 0)) {	245	while (p > q && (p - q >= INSN_MAX \|\| lenread == 0)) {
246	lendis = disasm (q, outbuf, bits, offset, autosync, prefer);	246	lendis = disasm (q, outbuf, sizeof(outbuf), bits, offset, autosync, prefer);
247	if (!lendis \|\| lendis > (p - q) \|\|	247	if (!lendis \|\| lendis > (p - q) \|\|
248	(unsigned long)lendis > nextsync-offset)	248	(unsigned long)lendis > nextsync-offset)
249	lendis = eatbyte (q, outbuf);	249	lendis = eatbyte (q, outbuf, sizeof(outbuf));
250	output_ins (offset, q, lendis, outbuf);	250	output_ins (offset, q, lendis, outbuf);
251	q += lendis;	251	q += lendis;
252	offset += lendis;	252	offset += lendis;

Lines 192-198 Link Here

(-)listing.c.orig (-1 / +1 lines)
192	else if (typ == OUT_RESERVE)	192	else if (typ == OUT_RESERVE)
193	{	193	{
194	char q[20];	194	char q[20];
195	sprintf(q, "<res %08lX>", size);	195	snprintf(q, sizeof(q), "<res %08lX>", size);
196	list_out (offset, q);	196	list_out (offset, q);
197	}	197	}
198	}	198	}

Lines 221-227 Link Here

(-)labels.c.orig (-2 / +2 lines)
221	slen += strlen(lpostfix);	221	slen += strlen(lpostfix);
222	slen++; /* room for that null char */	222	slen++; /* room for that null char */
223	xsymbol = nasm_malloc(slen);	223	xsymbol = nasm_malloc(slen);
224	sprintf(xsymbol,"%s%s%s",lprefix,lptr->defn.label,lpostfix);	224	snprintf(xsymbol,slen,"%s%s%s",lprefix,lptr->defn.label,lpostfix);
225		225
226	ofmt->symdef (xsymbol, segment, offset, exi,	226	ofmt->symdef (xsymbol, segment, offset, exi,
227	special ? special : lptr->defn.special);	227	special ? special : lptr->defn.special);
Lines 286-292 Link Here
286	slen += strlen(lpostfix);	286	slen += strlen(lpostfix);
287	slen++; /* room for that null char */	287	slen++; /* room for that null char */
288	xsymbol = nasm_malloc(slen);	288	xsymbol = nasm_malloc(slen);
289	sprintf(xsymbol,"%s%s%s",lprefix,lptr->defn.label,lpostfix);	289	snprintf(xsymbol,slen,"%s%s%s",lprefix,lptr->defn.label,lpostfix);
290		290
291	ofmt->symdef (xsymbol, segment, offset, exi,	291	ofmt->symdef (xsymbol, segment, offset, exi,
292	special ? special : lptr->defn.special);	292	special ? special : lptr->defn.special);

Lines 185-191 Link Here

(-)nasm.c.orig (-1 / +1 lines)
185	/* define some macros dependent of command-line */	185	/* define some macros dependent of command-line */
186	{	186	{
187	char temp [64];	187	char temp [64];
188	sprintf (temp, "__OUTPUT_FORMAT__=%s\n", ofmt->shortname);	188	snprintf (temp, sizeof(temp), "__OUTPUT_FORMAT__=%s\n", ofmt->shortname);
189	pp_pre_define (temp);	189	pp_pre_define (temp);
190	}	190	}
191		191

Lines 11-18 Link Here

(-)disasm.h.orig (-3 / +3 lines)
11		11
12	#define INSN_MAX 32 /* one instruction can't be longer than this */	12	#define INSN_MAX 32 /* one instruction can't be longer than this */
13		13
14	long disasm (unsigned char data, char output, int segsize, long offset,	14	long disasm (unsigned char data, char output, int outbufsize, int segsize,
15	int autosync, unsigned long prefer);	15	long offset, int autosync, unsigned long prefer);
16	long eatbyte (unsigned char data, char output);	16	long eatbyte (unsigned char data, char output, int outbufsize);
17		17
18	#endif	18	#endif

Return to bug 74477

Lines 528-534 Link Here

(-)preproc.c.orig (-16 / +23 lines)
528	fname++;	528	fname++;
529	fnlen = strcspn(fname, "\"");	529	fnlen = strcspn(fname, "\"");
530	line = nasm_malloc(20 + fnlen);	530	line = nasm_malloc(20 + fnlen);
531	sprintf(line, "%%line %d %.*s", lineno, fnlen, fname);	531	snprintf(line, 20+fnlen,"%%line %d %.*s", lineno, fnlen, fname);
532	nasm_free(oldline);	532	nasm_free(oldline);
533	}	533	}
534	if (tasm_compatible_mode)	534	if (tasm_compatible_mode)
Lines 1043-1049 Link Here
1043	char p, q = t->text + 2;	1043	char p, q = t->text + 2;
1044		1044
1045	q += strspn(q, "$");	1045	q += strspn(q, "$");
1046	sprintf(buffer, "..@%lu.", ctx->number);	1046	snprintf(buffer, sizeof(buffer), "..@%lu.", ctx->number);
1047	p = nasm_strcat(buffer, q);	1047	p = nasm_strcat(buffer, q);
1048	nasm_free(t->text);	1048	nasm_free(t->text);
1049	t->text = p;	1049	t->text = p;
Lines 1520-1542 Link Here
1520	t = t->next;	1520	t = t->next;
1521	continue;	1521	continue;
1522	}	1522	}
1523	else if (tt->type == TOK_WHITESPACE)	1523	if (tt->type == TOK_WHITESPACE)
1524	{	1524	{
1525	tt = tt->next;	1525	tt = tt->next;
1526	continue;	1526	continue;
1527	}	1527	}
1528	else if (tt->type != t->type \|\|	1528	if (tt->type != t->type)
1529	mstrcmp(tt->text, t->text, casesense))
1530	{	1529	{
1531	j = FALSE; /* found mismatching tokens */	1530	j = FALSE; /* found mismatching tokens */
1532	break;	1531	break;
1533	}	1532	}
1534	else	1533	/* Unify surrounding quotes for strings */
		1534	if (t->type == TOK_STRING)
1535	{	1535	{
1536	t = t->next;	1536	tt->text[0] = t->text[0];
1537	tt = tt->next;	1537	tt->text[strlen(tt->text) - 1] = t->text[0];
1538	continue;
1539	}	1538	}
		1539	if (mstrcmp(tt->text, t->text, casesense) != 0)
		1540	{
		1541	j = FALSE; /* found mismatching tokens */
		1542	break;
		1543	}
		1544
		1545	t = t->next;
		1546	tt = tt->next;
1540	}	1547	}
1541	if ((t->type != TOK_OTHER \|\| strcmp(t->text, ",")) \|\| tt)	1548	if ((t->type != TOK_OTHER \|\| strcmp(t->text, ",")) \|\| tt)
1542	j = FALSE; /* trailing gunk on one end or other */	1549	j = FALSE; /* trailing gunk on one end or other */
Lines 1954-1960 Link Here
1954	free_tlist(tt);	1961	free_tlist(tt);
1955		1962
1956	/* Now define the macro for the argument */	1963	/* Now define the macro for the argument */
1957	sprintf(directive, "%%define %s (%s+%d)", arg, StackPointer,	1964	snprintf(directive, sizeof(directive), "%%define %s (%s+%d)", arg, StackPointer,
1958	offset);	1965	offset);
1959	do_directive(tokenise(directive));	1966	do_directive(tokenise(directive));
1960	offset += size;	1967	offset += size;
Lines 2051-2063 Link Here
2051	free_tlist(tt);	2058	free_tlist(tt);
2052		2059
2053	/* Now define the macro for the argument */	2060	/* Now define the macro for the argument */
2054	sprintf(directive, "%%define %s (%s-%d)", local, StackPointer,	2061	snprintf(directive, sizeof(directive), "%%define %s (%s-%d)", local, StackPointer,
2055	offset);	2062	offset);
2056	do_directive(tokenise(directive));	2063	do_directive(tokenise(directive));
2057	offset += size;	2064	offset += size;
2058		2065
2059	/* Now define the assign to setup the enter_c macro correctly */	2066	/* Now define the assign to setup the enter_c macro correctly */
2060	sprintf(directive, "%%assign %%$localsize %%$localsize+%d",	2067	snprintf(directive, sizeof(directive), "%%assign %%$localsize %%$localsize+%d",
2061	size);	2068	size);
2062	do_directive(tokenise(directive));	2069	do_directive(tokenise(directive));
2063		2070
Lines 3182-3193 Link Here
3182	*/	3189	*/
3183	case '0':	3190	case '0':
3184	type = TOK_NUMBER;	3191	type = TOK_NUMBER;
3185	sprintf(tmpbuf, "%d", mac->nparam);	3192	snprintf(tmpbuf, sizeof(tmpbuf), "%d", mac->nparam);
3186	text = nasm_strdup(tmpbuf);	3193	text = nasm_strdup(tmpbuf);
3187	break;	3194	break;
3188	case '%':	3195	case '%':
3189	type = TOK_ID;	3196	type = TOK_ID;
3190	sprintf(tmpbuf, "..@%lu.", mac->unique);	3197	snprintf(tmpbuf, sizeof(tmpbuf), "..@%lu.", mac->unique);
3191	text = nasm_strcat(tmpbuf, t->text + 2);	3198	text = nasm_strcat(tmpbuf, t->text + 2);
3192	break;	3199	break;
3193	case '-':	3200	case '-':
Lines 4067-4073 Link Here
4067	return;	4074	return;
4068		4075
4069	va_start(arg, fmt);	4076	va_start(arg, fmt);
4070	vsprintf(buff, fmt, arg);	4077	vsnprintf(buff, sizeof(buff), fmt, arg);
4071	va_end(arg);	4078	va_end(arg);
4072		4079
4073	if (istk && istk->mstk && istk->mstk->name)	4080	if (istk && istk->mstk && istk->mstk->name)
Lines 4530-4536 Link Here
4530	make_tok_num(Token * tok, long val)	4537	make_tok_num(Token * tok, long val)
4531	{	4538	{
4532	char numbuf[20];	4539	char numbuf[20];
4533	sprintf(numbuf, "%ld", val);	4540	snprintf(numbuf, sizeof(numbuf), "%ld", val);
4534	tok->text = nasm_strdup(numbuf);	4541	tok->text = nasm_strdup(numbuf);
4535	tok->type = TOK_NUMBER;	4542	tok->type = TOK_NUMBER;
4536	}	4543	}

Lines 484-491 Link Here

(-)disasm.c.orig (-39 / +39 lines)
484	return data - origdata;	484	return data - origdata;
485	}	485	}
486		486
487	long disasm (unsigned char data, char output, int segsize, long offset,	487	long disasm (unsigned char data, char output, int outbufsize, int segsize,
488	int autosync, unsigned long prefer)	488	long offset, int autosync, unsigned long prefer)
489	{	489	{
490	struct itemplate p, best_p;	490	struct itemplate p, best_p;
491	int length, best_length = 0;	491	int length, best_length = 0;
Lines 583-608 Link Here
583	slen = 0;	583	slen = 0;
584		584
585	if (lock)	585	if (lock)
586	slen += sprintf(output+slen, "lock ");	586	slen += snprintf(output+slen, outbufsize-slen, "lock ");
587	for (i = 0; i < ins.nprefix; i++)	587	for (i = 0; i < ins.nprefix; i++)
588	switch (ins.prefixes[i]) {	588	switch (ins.prefixes[i]) {
589	case P_REP: slen += sprintf(output+slen, "rep "); break;	589	case P_REP: slen += snprintf(output+slen, outbufsize-slen, "rep "); break;
590	case P_REPE: slen += sprintf(output+slen, "repe "); break;	590	case P_REPE: slen += snprintf(output+slen, outbufsize-slen, "repe "); break;
591	case P_REPNE: slen += sprintf(output+slen, "repne "); break;	591	case P_REPNE: slen += snprintf(output+slen, outbufsize-slen, "repne "); break;
592	case P_A16: slen += sprintf(output+slen, "a16 "); break;	592	case P_A16: slen += snprintf(output+slen, outbufsize-slen, "a16 "); break;
593	case P_A32: slen += sprintf(output+slen, "a32 "); break;	593	case P_A32: slen += snprintf(output+slen, outbufsize-slen, "a32 "); break;
594	case P_O16: slen += sprintf(output+slen, "o16 "); break;	594	case P_O16: slen += snprintf(output+slen, outbufsize-slen, "o16 "); break;
595	case P_O32: slen += sprintf(output+slen, "o32 "); break;	595	case P_O32: slen += snprintf(output+slen, outbufsize-slen, "o32 "); break;
596	}	596	}
597		597
598	for (i = 0; i < elements(ico); i++)	598	for (i = 0; i < elements(ico); i++)
599	if ((*p)->opcode == ico[i]) {	599	if ((*p)->opcode == ico[i]) {
600	slen += sprintf(output+slen, "%s%s", icn[i],	600	slen += snprintf(output+slen, outbufsize-slen, "%s%s", icn[i],
601	whichcond(ins.condition));	601	whichcond(ins.condition));
602	break;	602	break;
603	}	603	}
604	if (i >= elements(ico))	604	if (i >= elements(ico))
605	slen += sprintf(output+slen, "%s", insn_names[(*p)->opcode]);	605	slen += snprintf(output+slen, outbufsize-slen, "%s", insn_names[(*p)->opcode]);
606	colon = FALSE;	606	colon = FALSE;
607	length += data - origdata; /* fix up for prefixes */	607	length += data - origdata; /* fix up for prefixes */
608	for (i=0; i<(*p)->operands; i++) {	608	for (i=0; i<(*p)->operands; i++) {
Lines 633-646 Link Here
633	ins.oprs[i].basereg = whichreg ((*p)->opd[i],	633	ins.oprs[i].basereg = whichreg ((*p)->opd[i],
634	ins.oprs[i].basereg);	634	ins.oprs[i].basereg);
635	if ( (*p)->opd[i] & TO )	635	if ( (*p)->opd[i] & TO )
636	slen += sprintf(output+slen, "to ");	636	slen += snprintf(output+slen, outbufsize-slen, "to ");
637	slen += sprintf(output+slen, "%s",	637	slen += snprintf(output+slen, outbufsize-slen, "%s",
638	reg_names[ins.oprs[i].basereg-EXPR_REG_START]);	638	reg_names[ins.oprs[i].basereg-EXPR_REG_START]);
639	} else if (!(UNITY & ~(*p)->opd[i])) {	639	} else if (!(UNITY & ~(*p)->opd[i])) {
640	output[slen++] = '1';	640	output[slen++] = '1';
641	} else if ( (*p)->opd[i] & IMMEDIATE ) {	641	} else if ( (*p)->opd[i] & IMMEDIATE ) {
642	if ( (*p)->opd[i] & BITS8 ) {	642	if ( (*p)->opd[i] & BITS8 ) {
643	slen += sprintf(output+slen, "byte ");	643	slen += snprintf(output+slen, outbufsize-slen, "byte ");
644	if (ins.oprs[i].segment & SEG_SIGNED) {	644	if (ins.oprs[i].segment & SEG_SIGNED) {
645	if (ins.oprs[i].offset < 0) {	645	if (ins.oprs[i].offset < 0) {
646	ins.oprs[i].offset *= -1;	646	ins.oprs[i].offset *= -1;
Lines 649-665 Link Here
649	output[slen++] = '+';	649	output[slen++] = '+';
650	}	650	}
651	} else if ( (*p)->opd[i] & BITS16 ) {	651	} else if ( (*p)->opd[i] & BITS16 ) {
652	slen += sprintf(output+slen, "word ");	652	slen += snprintf(output+slen, outbufsize-slen, "word ");
653	} else if ( (*p)->opd[i] & BITS32 ) {	653	} else if ( (*p)->opd[i] & BITS32 ) {
654	slen += sprintf(output+slen, "dword ");	654	slen += snprintf(output+slen, outbufsize-slen, "dword ");
655	} else if ( (*p)->opd[i] & NEAR ) {	655	} else if ( (*p)->opd[i] & NEAR ) {
656	slen += sprintf(output+slen, "near ");	656	slen += snprintf(output+slen, outbufsize-slen, "near ");
657	} else if ( (*p)->opd[i] & SHORT ) {	657	} else if ( (*p)->opd[i] & SHORT ) {
658	slen += sprintf(output+slen, "short ");	658	slen += snprintf(output+slen, outbufsize-slen, "short ");
659	}	659	}
660	slen += sprintf(output+slen, "0x%lx", ins.oprs[i].offset);	660	slen += snprintf(output+slen, outbufsize-slen, "0x%lx", ins.oprs[i].offset);
661	} else if ( !(MEM_OFFS & ~(*p)->opd[i]) ) {	661	} else if ( !(MEM_OFFS & ~(*p)->opd[i]) ) {
662	slen += sprintf(output+slen, "[%s%s%s0x%lx]",	662	slen += snprintf(output+slen, outbufsize-slen, "[%s%s%s0x%lx]",
663	(segover ? segover : ""),	663	(segover ? segover : ""),
664	(segover ? ":" : ""),	664	(segover ? ":" : ""),
665	(ins.oprs[i].addr_size == 32 ? "dword " :	665	(ins.oprs[i].addr_size == 32 ? "dword " :
Lines 669-698 Link Here
669	} else if ( !(REGMEM & ~(*p)->opd[i]) ) {	669	} else if ( !(REGMEM & ~(*p)->opd[i]) ) {
670	int started = FALSE;	670	int started = FALSE;
671	if ( (*p)->opd[i] & BITS8 )	671	if ( (*p)->opd[i] & BITS8 )
672	slen += sprintf(output+slen, "byte ");	672	slen += snprintf(output+slen, outbufsize-slen, "byte ");
673	if ( (*p)->opd[i] & BITS16 )	673	if ( (*p)->opd[i] & BITS16 )
674	slen += sprintf(output+slen, "word ");	674	slen += snprintf(output+slen, outbufsize-slen, "word ");
675	if ( (*p)->opd[i] & BITS32 )	675	if ( (*p)->opd[i] & BITS32 )
676	slen += sprintf(output+slen, "dword ");	676	slen += snprintf(output+slen, outbufsize-slen, "dword ");
677	if ( (*p)->opd[i] & BITS64 )	677	if ( (*p)->opd[i] & BITS64 )
678	slen += sprintf(output+slen, "qword ");	678	slen += snprintf(output+slen, outbufsize-slen, "qword ");
679	if ( (*p)->opd[i] & BITS80 )	679	if ( (*p)->opd[i] & BITS80 )
680	slen += sprintf(output+slen, "tword ");	680	slen += snprintf(output+slen, outbufsize-slen, "tword ");
681	if ( (*p)->opd[i] & FAR )	681	if ( (*p)->opd[i] & FAR )
682	slen += sprintf(output+slen, "far ");	682	slen += snprintf(output+slen, outbufsize-slen, "far ");
683	if ( (*p)->opd[i] & NEAR )	683	if ( (*p)->opd[i] & NEAR )
684	slen += sprintf(output+slen, "near ");	684	slen += snprintf(output+slen, outbufsize-slen, "near ");
685	output[slen++] = '[';	685	output[slen++] = '[';
686	if (ins.oprs[i].addr_size)	686	if (ins.oprs[i].addr_size)
687	slen += sprintf(output+slen, "%s",	687	slen += snprintf(output+slen, outbufsize-slen, "%s",
688	(ins.oprs[i].addr_size == 32 ? "dword " :	688	(ins.oprs[i].addr_size == 32 ? "dword " :
689	ins.oprs[i].addr_size == 16 ? "word " : ""));	689	ins.oprs[i].addr_size == 16 ? "word " : ""));
690	if (segover) {	690	if (segover) {
691	slen += sprintf(output+slen, "%s:", segover);	691	slen += snprintf(output+slen, outbufsize-slen, "%s:", segover);
692	segover = NULL;	692	segover = NULL;
693	}	693	}
694	if (ins.oprs[i].basereg != -1) {	694	if (ins.oprs[i].basereg != -1) {
695	slen += sprintf(output+slen, "%s",	695	slen += snprintf(output+slen, outbufsize-slen, "%s",
696	reg_names[(ins.oprs[i].basereg -	696	reg_names[(ins.oprs[i].basereg -
697	EXPR_REG_START)]);	697	EXPR_REG_START)]);
698	started = TRUE;	698	started = TRUE;
Lines 700-710 Link Here
700	if (ins.oprs[i].indexreg != -1) {	700	if (ins.oprs[i].indexreg != -1) {
701	if (started)	701	if (started)
702	output[slen++] = '+';	702	output[slen++] = '+';
703	slen += sprintf(output+slen, "%s",	703	slen += snprintf(output+slen, outbufsize-slen, "%s",
704	reg_names[(ins.oprs[i].indexreg -	704	reg_names[(ins.oprs[i].indexreg -
705	EXPR_REG_START)]);	705	EXPR_REG_START)]);
706	if (ins.oprs[i].scale > 1)	706	if (ins.oprs[i].scale > 1)
707	slen += sprintf(output+slen, "*%d", ins.oprs[i].scale);	707	slen += snprintf(output+slen, outbufsize-slen, "*%d", ins.oprs[i].scale);
708	started = TRUE;	708	started = TRUE;
709	}	709	}
710	if (ins.oprs[i].segment & SEG_DISP8) {	710	if (ins.oprs[i].segment & SEG_DISP8) {
Lines 713-732 Link Here
713	ins.oprs[i].offset = - (signed char) ins.oprs[i].offset;	713	ins.oprs[i].offset = - (signed char) ins.oprs[i].offset;
714	sign = '-';	714	sign = '-';
715	}	715	}
716	slen += sprintf(output+slen, "%c0x%lx", sign,	716	slen += snprintf(output+slen, outbufsize-slen, "%c0x%lx", sign,
717	ins.oprs[i].offset);	717	ins.oprs[i].offset);
718	} else if (ins.oprs[i].segment & SEG_DISP16) {	718	} else if (ins.oprs[i].segment & SEG_DISP16) {
719	if (started)	719	if (started)
720	output[slen++] = '+';	720	output[slen++] = '+';
721	slen += sprintf(output+slen, "0x%lx", ins.oprs[i].offset);	721	slen += snprintf(output+slen, outbufsize-slen, "0x%lx", ins.oprs[i].offset);
722	} else if (ins.oprs[i].segment & SEG_DISP32) {	722	} else if (ins.oprs[i].segment & SEG_DISP32) {
723	if (started)	723	if (started)
724	output[slen++] = '+';	724	output[slen++] = '+';
725	slen += sprintf(output+slen, "0x%lx", ins.oprs[i].offset);	725	slen += snprintf(output+slen, outbufsize-slen, "0x%lx", ins.oprs[i].offset);
726	}	726	}
727	output[slen++] = ']';	727	output[slen++] = ']';
728	} else {	728	} else {
729	slen += sprintf(output+slen, "<operand%d>", i);	729	slen += snprintf(output+slen, outbufsize-slen, "<operand%d>", i);
730	}	730	}
731	}	731	}
732	output[slen] = '\0';	732	output[slen] = '\0';
Lines 741-748 Link Here
741	return length;	741	return length;
742	}	742	}
743		743
744	long eatbyte (unsigned char data, char output)	744	long eatbyte (unsigned char data, char output, int outbufsize)
745	{	745	{
746	sprintf(output, "db 0x%02X", *data);	746	snprintf(output, outbufsize, "db 0x%02X", *data);
747	return 1;	747	return 1;
748	}	748	}