//--------------------------------------------------------------
void draw_circle(int xC, int yC, int radius)
   {
   double theta, increment, xF, pi=3.14159;
   int x, xN, yN;

   increment = 0.8 / static_cast<double>(radius);
   for(theta=0; theta<=pi/2; theta+=increment)  //quarter circle
      {
      xF = radius * cos(theta);  
      xN = static_cast<int>(xF * 2 / 1); //pixels not square
      yN = static_cast<int>(radius * sin(theta) + 0.5);
      x = xC-xN;
      while(x <= xC+xN)          //fill two horizontal lines
         {                       //one for each half circle
         set_cursor_pos(x,   yC-yN); putch(fill_char);  //top
         set_cursor_pos(x++, yC+yN); putch(fill_char);  //bottom
         }
      }  //end for
   }

void putstr(const char *str)
{
	int i;
	if (!str)
		return;
	i = 0;
	while (str[i]) {
		putch(str[i++]);
	}
}

void
worm_draw(worm_t *worm)
{
    int w;

    for (w = 0; w < worm->nsegs; w++) {
        position(worm->row[w], worm->col[w]);
        putch('*');
    }
}

int
plodput(int c)
{

	if (plodflg) {
		plodcnt--;
		return 0;
	} else
		return putch(c);
}

static
void
flush_delay_buf(void)
{
	size_t i;
	for (i=0; i<delayed_outbuf_pos; i++) {
		putch(delayed_outbuf[i]);
	}
	delayed_outbuf_pos = 0;
}

void puts(char *text)
    /// Output a string to the screen
{
    int i;

    for (i = 0; i < strlen(text); i++)  // Repeat until null charecter
    {
        putch(text[i]);                 // Put a charecter on the screen
    }
}

void putHexNibble(unsigned char value)
{
   value &= 0xf;
   if(value > 9)
     value +=  'A' - 10;
 else
    value += '0';
   putch(value);

}

void readstring(char *buf)
{
while (*(buf-1) != 13)
{
*(buf++) = toupper(getch());
putch(*(buf-1));
if (*(buf-1) == 8) buf -= 2;
}
*(buf-1) = 0;
}

/*----------------------------------------------------------------------*
                             rtp_term_putc
 *----------------------------------------------------------------------*/
void rtp_term_putc (char ch)
{
    // Do ASCII translation.  Make sure that \n gets translated to \r\n.
	if (ch == '\n')
	{
		rtp_term_putc('\r');
	}
	
	putch(ch);
}

ssize_t vfs_console_write(struct vfs_file_s *file, const void *src, size_t len)
{
	if (stdout_hook)
		stdout_hook(src, len);
	size_t i;
	for (i = 0; i < len; ++i)
		putch(((const char*)src)[i]);
        
	return len;
}

void puts(char *str) {
	pt_s = 1;
	int length = str_len(str);
	int i =0;
	while(i < length) {
		putch(str[i]);
		i++;
	}
	pt_s = 0;
}

int
plodput(int c)
{

	if (plodflg)
		plodcnt--;
	else
		putch(c);
	return c;
}

uint8_t read_pass()
{
  for(uint8_t inchar = getch(); inchar != 0 && inchar != 0xa && inchar != 0xd; inchar = getch())
  {
#if PASS_VULN_TRIVIAL
    if (n_received >= passwlen || inchar != password[n_received])
    {
      putch(n_received);
      putch(inchar);
      putch(password[n_received]);
      return 1;
    }
    n_received++;
#else
    received[n_received++] = inchar;
#endif
  }
  return 0;
}

CAMLprim value caml_ml_output_char(value vchannel, value ch)
{
  CAMLparam2 (vchannel, ch);
  struct channel * channel = Channel(vchannel);

  Lock(channel);
  putch(channel, Long_val(ch));
  Unlock(channel);
  CAMLreturn (Val_unit);
}

void textlineh(int row, int start, int finish)
{
int count;

	for(count = start; count <= finish; count++)
	{
	gotoxy(count,row);
	putch(HLINE);
	}
}

char *Sys_ConsoleInput(void)
{
	static char	text[256];
	static int	len = 0;
	char		ch;

	if (!isDedicated)
		return NULL;

	if (! kbhit())
		return NULL;

	ch = getche();

	switch (ch)
	{
		case '\r':
			putch('\n');
			if (len)
			{
				text[len] = 0;
				len = 0;
				return text;
			}
			break;

		case '\b':
			putch(' ');
			if (len)
			{
				len--;
				putch('\b');
			}
			break;

		default:
			text[len] = ch;
			len = (len + 1) & 0xff;
			break;
	}

	return NULL;
}

static void flush_console()
{
	char * p=text;
	while(*p){
		putch(*p);
		console_putch(*p++);
	}

	text[0]='\0';
}

/* PMU interrupt service routine */
void PMU_ISR(void)
{
#ifdef DEBUG
    putch('I');
#endif
    /* send msg to main loop */
    Task_Push(MSG_ID_PMU_IND, 0, 0);

    INTF = 0;
}

/* -------------------------------------------------------------------- */
void outCon(char c)
{
    unsigned char row, col;
    static char escape = FALSE;

    if (!console)
        return;

    if (c == '\a' /* BELL */ && cfg.noBells)
        return;
    if (c == 27 || escape) {    /* ESC || ANSI sequence */
        escape = ansi(c);
        return;
    }
    if (c == 0x1a)      /* CT-Z */
        return;

    if (!anyEcho)
        return;

    /* if we dont have carrier then count what goes to console */
    if (!gotCarrier())
        transmitted++;

    if (c == '\n')
        doccr();
    else if (c == '\r') {
        putch(c);
    } else {
        readpos(&row, &col);
        if (c == '\b' || c == 7) {
            if (c == '\b' && col == 0 && prevChar != '\n')
                position(row - 1, 80);
            putch(c);
        } else {
            (*charattr) (c, ansiattr);
            if (col == 79) {
                position(row, col);
                doccr();
            }
        }
    }
}

void 
RingBell(void)
{
#ifdef UNIX
    refresh();
    beep();
#else
    putch('\a');
#endif
}