/*
 *      Z80 - Assembler
 *      Copyright (C) 1987-1992 by Udo Munk
 *
 *	History:
 *	17-SEP-1987 Development under Digital Research CP/M 2.2
 *      28-JUN-1988 Switched to Unix System V.3
 */

/*
 *      Dieses Modul enthaelt die numerischen
 *      Rechen- und Umwandlungsfunktionen.
 */

#include <stdio.h>
#include <ctype.h>
#include "z80a.h"
#include "z80aglb.h"

#ifndef isxdigit
#define isxdigit(c) (isdigit(c) || (c>='a' && c<='f') || (c>='A' && c<='F'))
#endif

/*
 *      Definition Operatoren-Symbole fuer den Expression-Parser
 */
#define OPEDEC          1       /* Dezimalzahl */
#define OPEHEX          2       /* Hexzahl */
#define OPEOCT          3       /* Octalzahl */
#define OPEBIN          4       /* Binaerzahl */
#define OPESUB          5       /* arithmetisches - */
#define OPEADD          6       /* arithmetisches + */
#define OPEMUL          7       /* arithmetisches * */
#define OPEDIV          8       /* arithmetisches / */
#define OPEMOD          9       /* arithmetisches Modulo */
#define OPESHL          10      /* logisches shift left */
#define OPESHR          11      /* logisches shift right */
#define OPELOR          12      /* logisches OR */
#define OPELAN          13      /* logisches AND */
#define OPEXOR          14      /* logisches XOR */
#define OPECOM          15      /* logisches Komplement */
#define OPESYM          99      /* Symbol */

/*
 *      Rekursiver Expression-Parser
 *
 *	Input:	Pointer auf den restlichen Argument-String
 *
 *      Output: berechneter Wert
 */
eval(s)
register char *s;
{
	register char *p;
	register int val;
	char word[MAXLINE];
	struct sym *sp, *get_sym();

	val = 0;
	while (*s) {
		p = word;
		if (*s == '(') {
			s++;
			while (*s != ')') {
				if (*s == '\0') {
					asmerr(E_MISPAR);
					goto eval_break;
				}
				*p++ = *s++;
			}
			*p = '\0';
			s++;
			val = eval(word);
			continue;
		}
		if (*s == STRSEP) {
			s++;
			while (*s != STRSEP) {
				if (*s == '\n' || *s == '\0') {
					asmerr(E_MISHYP);
					goto hyp_error;
				}
				*p++ = *s++;
			}
			s++;
hyp_error:
			*p = '\0';
			val = strval(word);
			continue;
		}
		if (isari(*s))
			*p++ = *s++;
		else
			while (!isspace(*s) && !isari(*s) && (*s != '\0'))
				*p++ = *s++;
		*p = '\0';
		switch (get_type(word)) {
		case OPESYM:                    /* Symbol */
			if (strcmp(word, "$") == 0) {
				val = pc;
				break;
			}
			if (strlen(word) > SYMSIZE)
				word[SYMSIZE] = '\0';
			if ((sp = get_sym(word)) != NULL)
				val = sp->sym_wert;
			else
				asmerr(E_UNDSYM);
			break;
		case OPEDEC:                    /* Dezimalzahl */
			val = atoi(word);
			break;
		case OPEHEX:                    /* Hexzahl */
			val = axtoi(word);
			break;
		case OPEBIN:                    /* Binaerzahl */
			val = abtoi(word);
			break;
		case OPEOCT:                    /* Oktalzahl */
			val = aotoi(word);
			break;
		case OPESUB:                    /* arithmetisches - */
			val -= eval(s);
			goto eval_break;
		case OPEADD:                    /* arithmetisches + */
			val += eval(s);
			goto eval_break;
		case OPEMUL:                    /* arithmetisches * */
			val *= eval(s);
			goto eval_break;
		case OPEDIV:                    /* arithmetisches / */
			val /= eval(s);
			goto eval_break;
		case OPEMOD:                    /* arithmetisches Modulo */
			val %= eval(s);
			goto eval_break;
		case OPESHL:                    /* logisches shift left */
			val <<= eval(s);
			goto eval_break;
		case OPESHR:                    /* logisches shift right */
			val >>= eval(s);
			goto eval_break;
		case OPELOR:                    /* logisches OR */
			val |= eval(s);
			goto eval_break;
		case OPELAN:                    /* logisches AND */
			val &= eval(s);
			goto eval_break;
		case OPEXOR:                    /* logisches XOR */
			val ^= eval(s);
			goto eval_break;
		case OPECOM:                    /* logisches Komplement */
			val = ~(eval(s));
			goto eval_break;
		}
	}
	eval_break:
	return(val);
}

/*
 *      Operanden Typ-Bestimmung
 *
 *      Input:  Pointer auf zu bestimmenden String
 *
 *      Output: Operanden Typ
 */
get_type(s)
char *s;
{
	if (isdigit(*s)) {              /* numerischer Operand */
		if (isdigit(*(s + strlen(s) - 1)))      /* Dezimalzahl */
			return(OPEDEC);
		else if (*(s + strlen(s) - 1) == 'H')   /* Hexzahl */
			return(OPEHEX);
		else if (*(s + strlen(s) - 1) == 'B')   /* Binaerzahl */
			return(OPEBIN);
		else if (*(s + strlen(s) - 1) == 'O')   /* Oktalzahl */
			return(OPEOCT);
	} else if (*s == '-')           /* arithmetischer Operand - */
		return(OPESUB);
	else if (*s == '+')             /* arithmetischer Operand + */
		return(OPEADD);
	else if (*s == '*')             /* arithmetischer Operand * */
		return(OPEMUL);
	else if (*s == '/')             /* arithmetischer Operand / */
		return(OPEDIV);
	else if (*s == '%')             /* arithmetisches Modulo */
		return(OPEMOD);
	else if (*s == '<')             /* logisches shift left */
		return(OPESHL);
	else if (*s == '>')             /* logisches shift rigth */
		return(OPESHR);
	else if (*s == '|')             /* logisches OR */
		return(OPELOR);
	else if (*s == '&')             /* logisches AND */
		return(OPELAN);
	else if (*s == '^')             /* logisches XOR */
		return(OPEXOR);
	else if (*s == '~')             /* logisches Komplement */
		return(OPECOM);
	return(OPESYM);                 /* Operand ist ein Symbol */
}

/*
 *      Die Funktion prueft einen Character auf die arithmetischen
 *      Operatoren +, -, *, /, %, <, >, |, &, ~ und ^.
 */
isari(c)
register int c;
{
	return((c) == '+' || (c) == '-' || (c) == '*' ||
	       (c) == '/' || (c) == '%' || (c) == '<' ||
	       (c) == '>' || (c) == '|' || (c) == '&' ||
	       (c) == '~' || (c) == '^');
}

/*
 *      Umwandlung eines ASCII-Strings mit einer Hexzahl in
 *      einen Integer.
 *      Format: nnnnH oder 0nnnnH wenn 1.Ziffer > 9
 */
axtoi(str)
register char *str;
{
	register int num;

	num = 0;
	while (isxdigit(*str)) {
		num *= 16;
		num += *str - ((*str <= '9') ? '0' : '7');
		str++;
	}
	return(num);
}

/*
 *      Umwandlung eines ASCII-Strings mit einer Oktalzahl in
 *      einen Integer.
 *      Format: nnnnO
 */
aotoi(str)
register char *str;
{
	register int num;

	num = 0;
	while ('0' <= *str && *str <= '7') {
		num *= 8;
		num += (*str++) - '0';
	}
	return(num);
}

/*
 *      Umwandlung eines ASCII-Strings mit einer Binaerzahl in
 *      einen Integer.
 *      Format: nnnnnnnnnnnnnnnnB
 */
abtoi(str)
register char *str;
{
	register int num;

	num = 0;
	while ('0' <= *str && *str <= '1') {
		num *= 2;
		num += (*str++) - '0';
	}
	return(num);
}

/*
 *      Umwandlung eines ASCII-Strings in einen Integer.
 */
strval(str)
register char *str;
{
	register int num;

	num = 0;
	while (*str) {
		num <<= 8;
		num += (int) *str++;
	}
	return(num);
}

/*
 *      Die Funktion prueft einen Wert auf -256 < Wert < 256
 *      Output: Wert wenn im Bereich, sonst 0 und Fehlermeldung
 */
chk_v1(i)
register int i;
{
	if (i >= -255 && i <= 255)
		return(i);
	else {
		asmerr(E_VALOUT);
		return(0);
	}
}

/*
 *      Die Funktion prueft einen Wert auf -128 < Wert < 128
 *      Output: Wert wenn im Bereich, sonst 0 und Fehlermeldung
 */
chk_v2(i)
register int i;
{
	if (i >= -127 && i <= 127)
		return(i);
	else {
		asmerr(E_VALOUT);
		return(0);
	}
}