/*
	dbXX - util.c	
	utility routines
*/

#include	"defs.h"
#include "ctype.h"

unsigned char	atohex( char c )
{
	if( (c >= '0' ) && (c <= '9') )
		return (unsigned char) (c - '0');
	if( (c >= 'a' ) && (c <= 'f') )
		return (unsigned char) (c - 'a' +10);
	if( (c >= 'A' ) && (c <= 'F') )
		return (unsigned char) (c - 'A' +10);
	return 0;
}


/*
	noteol -
	returns 1 if parameter is not an EOL character ...
*/

int	noteol( char c )
{
	if( c == 0 )
		return 0;
	if( c == '\n')
		return 0;
	if( c == '\r')	// for example within the simulator ...
		return 0;
	return 1;
}



/*
	putsnnl -
	put a non NL-terminated string to console ...
*/

void	putsnnl( char * s)
{
//	while( *s )
//		_outchar( *s++ );
	smallprintf( "%s", s );
}


/* 
	strcmpi -
	lexically compare of strings where uppercase, 
	lowercase are considered equal 
*/


int	strcmpi( char *s1 , char *s2 )
{
  while (1) {
	if (toupper(*s1) != toupper(*s2) ) 
		return(*s1 - *s2);
	if (*s1 == 0) 
		return(0);
	s1++;
	s2++;
  }
}

char *	skipblanc( char *str )
{
	while( *str )
	{
		if( *str == '\n' || *str > ' ' )
			break;
		str++;
	}
	return str;
}

char *	skipnonblanc( char *str )
{
	while( *str )
	{
		if( *str <= ' ' )
			break;
		str++;
	}
	return str;
}


/* 
	getstring -
	get a newline terminated string into 'ptr', 
	no more than 'max' chars
	if 'hot' also terminate on '.','+' and '-'
*/

void	getstring( char *ptr , int max, int hot )
{ 
	int i = max;
 	char *p = ptr;
	/*  Take care of leading blanks */
   	while(1){
		*p= (char) _inchar();
		if((*p!=' ')&&(*p!='\t')) goto get;
   	}
   	do{
		*p=(char) _inchar();
get:
		/* take care of editing keys */

		// if 'hottrace' is on, we terminate on a leading '.'
		if( (!hot) && (i==max) && ( hottrace )&&(*p=='.') ){
			p[1]='\n'; p[2]='\0'; return;
		}
		if( hot )
		{  
			if(( *p == '.')||(*p=='+')||(*p=='-') )
			{
				_outchar( *p );
				p++;
				*p='\0'; 
				return;
			}
		}
		switch( *p ){
		case '\r': 	*p = '\n';
					*++p='\0'; return;
		
		case '\n': 	*++p='\0'; return;
		case '\b': if( i < max ){
				i++; /* place for one more */
				p--;
			   	_outchar('\b');
			   	_outchar(' ');	/* rubout */
			   	_outchar('\b');
			   }
			break;
		default:	/* any other key */
			_outchar( *p++ ); /* don't echo NL */
			i--;
 		}
   	} while( i > 0 );
}



/* 
	printable -
	prints an ascii string ('length' asciis) 
	or "." if non printable 
*/
void printable(char * start, int length)
{
	int	i;
	int 	c;

  	_outchar(' ');
  	for (i=0; i<length; i++) {
		c=isprint( start[i] );
		if( c )
			_outchar( start[i] );
		else
			_outchar('.');
  	}
}


/*
	strtoint - translate character string to binary
	'start' - start of textstring
	'base' - desired base (2,8,10 or 16)
	'newnum' - ptr to result value
	'page' - ptr to result value (high word)
	'complain' - if 1, complain on illegal value, 0 keep quiet
	returns 1 if successfull, 0 otherwise

*/


int	strtoint(char * start, int base, int complain, int *newnum, int *page)
{ 
	int	this;
	unsigned long 	number = 0;
	char 	*thisc = start;

      while ((*thisc!='\0')&&(*thisc!='\n') ){
		this= atohex(*thisc++) ;
		/* check digit against base */
		if( (this == -1) || (this >= base ) ){
			if( complain ){
				smallprintf("\nIllegal Value: %s", start );
				restart();
			}
			return 0;
		}
	    	number = this + base * number;
 	}
	*page = (int) (number >> 16);
	*newnum = number;
      return(1);
}

/*
	decval - decode a string to binary
*/
int decval( char * s, int complain )
{ 
	int value,page;
	switch( toupper(*s) ){
	  case '%': (void) strtoint(++s , (int) 2 ,complain, &value,&page); break;
	  case '@': (void) strtoint(++s , (int) 8 ,complain, &value,&page); break;
	  case 't': (void) strtoint(++s , (int) 10 ,complain, &value,&page); break;
	  case 'T': (void) strtoint(++s , (int) 10 ,complain, &value,&page); break;
	  case '$': (void) strtoint(++s , (int) 16 ,complain, &value,&page); break;
	  default : (void) strtoint( s, (int) 16 ,complain, &value,&page); break;
	}
	return value;
}



/*
	puthex - write 2 hexadecimal digits to console
*/
void puthex( char i )
{
	char pp;
	pp = (char) ( (i >> 4) & 0xf );
	if( pp < 10 )
		_outchar( pp+'0' );
	else
		_outchar( pp+'A'-10 );
	pp =  i & 0xf ; 
	if( pp < 10 )
		_outchar( pp+'0' );
	else
		_outchar( pp+'A'-10 );
}


void	puthex2( short int i)
{
	puthex( (char)  (i >> 8) );
	puthex( (char) i );
}

int	getsize( char * s, int complain )
{
	// expect -b -B -w -W -l or -L ...
	if( *s == '-' ) s++;
	switch ( *s )
	{
		case 'b': case 'B': return 1;
		case 'h': case 'H': return 2;
		case 'w': case 'W': return 4;
		default:
		if( complain )
			smallprintf("Illegal size" );
		return 1;
	}	
}

/*
 * Print an integer in base b
 */


static void printn(int n, int b)
{
	int a;

	if( b == 10 ){
		if (n<0) {	
			_outchar('-');
			n = -n;
		}
	}
	a = n/b;
	if ( a )
		printn(a, b);
	_outchar("0123456789ABCDEF"[(int)(n%b)]);
}
/*
 * Print an hexadecimal number, d digits
 */

static void printX(int n, int d)
{
	d--;
	printn((n>>d*4)&15, 16);
	while (d-- >0)
		printn((n>>d*4)&15, 16);
}

/*
 * Print an octal number, d digits
 */

static void printO(int n, int d)
{
	d--;
	printn((n>>d*3)&7, 8);
	while (d-- >0)
		printn((n>>d*3)&7, 8);
}


static void print2s( unsigned short number )
{	/* print "number" as binary 16 bits */
	int i = 1;
	unsigned short mask = 0x8000;
  	for( i = 1;i < 17 ; i++ ){
   		if( mask & number )
			_outchar('1'); 
		else 
			_outchar('0');
		mask = mask >> 1;
  	}
}
/*
	don't assume any standard headers
	use old fashion 'VARARGS' style ...
*/
void smallprintf( char *fmt , ... )	
{
	char	c;
	int *adx;
	char *s;


	adx = (int *) (&fmt + 1);
	long value;


loop:
	while ((c = *fmt++) != '%')
	{
		if (c == '\0')
			return;
		_outchar(c);
		/* Added \n -> \n\r in Version 2.0 */
//		if( c == '\n')
//			_outchar('\r');
	}
	c = *fmt++;
	switch (c)
	{
		case	'%':
			_outchar(c);
			goto loop;

		case 'd':
			printn((short)*adx, 10);
			break;
		case 'x':
			printX((short)*adx&0xFFFF, 4);
			break;
		case 'X':
			printX((long)*adx, 8);
			break;
		case 'o':
			printO((short)*adx&0xFFFF, 6);
			break;
		case 's':
			s = (char *)*adx;
			while (c = *s++)
				_outchar(c);
			break;
		case 'c':
			_outchar( (char) (*adx&0xFF) );
			break;
		case 'b':
			print2s((short)*adx&0xFFFF);
			break;

		case 'B':
			value =  (long) *adx;
			print2s((short) ((value>>16)&0xFFFF));
			print2s((short) (value&0xFFFF));
			break;

        }
	adx++;
	goto loop;
}