/**
* Write a string on screen
*
* \param str String
*/
void kprint(char *str)
{
unsigned int i = 0;
char c;
while((c = str[i]) != '\0') {
switch(c) {
case '\n':
if(py <= VIDEO_ROWS) {
py++;
if(py >= VIDEO_ROWS) {
scroll_screen();
py = VIDEO_ROWS-1;
}
}
px = 0;
break;
case '\r':
if(px > 0) px--;
break;
case '\b':
if(px > 0) px--;
writechar(' ', c_attr);
px--;
break;
default:
writechar(str[i], c_attr);
}
i++;
}
return;
}
/* composite ports */
void compputc(Obj p, int c){
int i, l;
Obj cp = CDR(p);
switch (SUBSUBPORT(p)){
case COMP_T:
writechar( CAR( cp ), c);
writechar( CDR( cp ), c);
break;
case COMP_BCAST:
l = CLENGTH(cp);
for(i=0; i<l; i++)
writechar( CVECTOR(cp)[i], c);
break;
case COMP_ECHO:
case COMP_2WAY:
writechar( CDR(cp), c);
break;
case COMP_SYNO:
Fputc( MAKCHAR(c), getvalue(cp) );
break;
case COMP_FUNC:
funcall_1("#<internal:compputc>", CVECTOR(cp)[1], MAKCHAR(c));
break;
default:
break;
}
}
static
void _print_line( int fd, const char* file, int line ) {
int filefd;
writestring(fd, "in file ");
writestring(fd, file);
writestring(fd, " at line ");
writeint(fd, line);
writechar(fd, ':');
#ifndef O_TEXT
#define O_TEXT 0
#endif
if ( (filefd = open(file, O_RDONLY | O_TEXT )) != -1 ) {
char c;
for ( ; line > 1; line -- ) {
while ( readchar(filefd) != '\n' )
;
}
do {
writechar(fd, c = readchar(filefd));
} while ( c != '\n' );
} else {
writestring(2, "Couldn't open ");
writestring(2, file);
writechar(2, '\n');
}
}
//debug things
static int uart_putchar(char c, _UNUSED_ FILE *stream){
if(c == '\n') writechar('\r');
writechar(c);
return 0;
}
int prnport(Obj p, Obj s, int h){
int (*fnc)(Obj,Obj,int);
int t = SUBPORT(p);
fnc = pdesc[t].print;
if(fnc)
return fnc(p, s, h);
else{
writestr(s, "#<ioport:");
if( RPORTP(p))
writechar(s, 'R');
if( WPORTP(p))
writechar(s, 'W');
if( SUBPORT(p)){
writechar(s, '_');
printnum(s, SUBPORT(p), 16, 0, 0);
if( SUBSUBPORT(p)){
writechar(s, ':');
printnum(s, SUBSUBPORT(p), 16, 0, 0);
}
}
writechar(s, '>');
return 1;
}
}
void LCD_Init()
{
writechar(UART_LCD,LCD_CMD);
writechar(UART_LCD,LCD_ON);
writechar(UART_LCD, LCD_SPECCMD);
writechar(UART_LCD, 157);
}
void UnPackSLZ(unsigned char *inbuffer, register FILE *outfile)
{
short myTAG, mycount, myoffset;
long int loop1;
for(;;) // loop forever (until goto occurs to break out of loop)
{
myTAG=*inbuffer++;
for(loop1=0;(loop1!=8);loop1++)
{
if(myTAG&0x80)
{
if((mycount=*inbuffer++)==0) // Check EXIT
{ goto skip2; } // goto's are gross but it's efficient :(
else
{
myoffset=HISTORY_SIZE-(((MASK_upper&mycount)*SHIFT_UPPER)+(*inbuffer++));
mycount&=MASK_lower;
mycount+=2;
while(mycount!=0)
{
writechar(LZ_history[(lzhist_offset+myoffset)&MASK_history],outfile);
mycount--;
}
}
}
else
{ writechar(*inbuffer++,outfile); }
myTAG+=myTAG;
}
}
skip2:
return;
}
int puts(const char *s)
{
while(*s) {
writechar(*s);
s++;
}
writechar('\n');
return 1;
}
void print_on_lcd(char number)
{
char highnumber = number >> 4;
highnumber = highnumber & 0b00001111;
char lownumber = number & 0b00001111;
writechar(what_lcd_number(highnumber));
writechar(what_lcd_number(lownumber));
writechar(lcdspace);
}
int puts(const char *s)
{
unsigned int oldmask;
oldmask = irq_getmask();
irq_setmask(IRQ_UART); // HACK: prevent UART data loss
while(*s) {
writechar(*s);
s++;
}
writechar('\n');
irq_setmask(oldmask);
return 1;
}
void readstr(char *s, int size)
{
char c;
int ptr;
ptr = 0;
while(1) {
c = readchar();
switch(c) {
case 0x7f:
case 0x08:
if(ptr > 0) {
ptr--;
putsnonl("\x08 \x08");
}
break;
case '\r':
case '\n':
s[ptr] = 0x00;
putsnonl("\n");
return;
default:
writechar(c);
s[ptr] = c;
ptr++;
break;
}
}
}
void putsnonl(const char *s)
{
while(*s) {
writechar(*s);
s++;
}
}
/** Write a single character <code>c</code> and return the character
* just written (or <code>EOF</code> on error.
*/
int overflow (int c = EOF) {
if ( c == EOF )
return EOF;
else {
writechar(static_cast<char>(c));
return traits_type::to_int_type(c);
}
}
int write(int file, char *ptr, int len) {
int todo;
for (todo = len; todo; --todo) {
writechar(*ptr++);
}
return(len);
}
static
void writeint (int fd, int i ) {
int place = 10000;
if ( i < 0 ) {
writechar(fd, '-');
i = -i;
}
while ( place > 0 ) {
int digit = i / place;
writechar(fd, '0' + (char) digit );
i -= digit * place;
place /= 10;
}
}
void loop(int c)
{
int d;
for (d=0; d<c; d++)
{
writeint(d);
writechar('\n');
}
}
void
flushsector(int c)
{
int i;
for (i = (bufptr - buf); i < SECTORSIZE; i++) writechar(c);
writesector(buf);
bufptr = buf;
}
W
__putc (W ch, FILE *port)
{
UB buf[1];
buf[0] = ch;
writechar (port->device, dev_recv, buf, 1);
return (ch);
}
int main(int argc, char* argv[])
{
char* x = "Hello world\n";
writestring(x);
writeint(12345);
writechar('\n');
loop(1000);
return 0;
}
W
putc (W ch, FILE *port)
{
port->buf[port->count] = ch;
port->count++;
if (ch == '\n')
{
writechar (port->device, dev_recv, port->buf, port->count);
port->count = 0;
}
else if (port->count >= port->bufsize)
{
writechar (port->device, dev_recv, port->buf, port->count);
port->count = 0;
}
return (ch);
}
int prnstr(Obj a, Obj stream, int how){
int i, c;
char *foo, buf[8];
if(how){
writestr(stream, "\"");
for(i=0; i< CLENGTH(a); i++){
c = CCHARS(a)[i];
foo = spec_repr(c, 1);
if(foo)
writestr(stream, foo);
else
writechar(stream, c);
}
writestr(stream, "\"");
}else{
for(i=0; i< CLENGTH(a); i++)
writechar(stream, CCHARS(a)[i]);
}
return 1;
}
void bootcompile( void )
{
for( skip_space(); flag; skip_space() ) {
get_name();
find();
// if( !flag ) {printf( "not found \n"); exit(1);}
if( !flag ) { writechar( 'Z' ); for(;;); }
*--sp = (cell) &cptr; append();
}
ascii_to_literal( "exit" );
find(); *--sp = (cell) &cptr ; append();
}
int
main(void)
{
int c;
bool leading = true;
while ((c = readchar()) != EOF) {
if (isspace(c))
/* Save whitespace. */
savewhite(c, leading);
else {
/* Reprint whitespace and print regular character. */
printwhite();
writechar(c);
leading = false;
}
}
/* Terminate non-empty files with a newline. */
if (!leading)
writechar('\n');
return (0);
}
void putsnonl(const char *s)
{
unsigned int oldmask;
oldmask = irq_getmask();
irq_setmask(IRQ_UART); // HACK: prevent UART data loss
while(*s) {
writechar(*s);
s++;
}
irq_setmask(oldmask);
}
int compgetc(Obj p){
int c;
Obj cp = CDR(p), r;
switch (SUBSUBPORT(p)){
case COMP_T:
case COMP_ECHO:
c = readchar( CAR(cp));
writechar( CDR(cp), c);
break;
case COMP_2WAY:
c = readchar( CAR(cp));
break;
case COMP_CONCAT:
c = readchar( CAR(cp));
if( c == EOF ){
/* go to next component */
CDR(p) = CDR(cp);
if( NULLP(CDR(p))){
CAR(p) = IC_NIL;
c = EOF;
}else{
c = compgetc(p);
}
}
break;
case COMP_SYNO:
r = Fgetc( getvalue(cp));
if( r == IC_EOF )
return EOF;
if( !ICHARP(r) )
return JLERROR("#<internal:compgetc>", r, "synonym-port returned a non-char");
c = CCHAR(r);
break;
case COMP_FUNC:
r = funcall_0("#<internal:compgetc>", CVECTOR(cp)[0]);
if( r == IC_EOF )
return EOF;
if( !ICHARP(r) )
return JLERROR("#<internal:compgetc>", r, "function-port returned a non-char");
c = CCHAR(r);
break;
default:
c = EOF;
break;
}
return c;
}
bool ShootingPrintHitGraphic(COORD location, int timeshit)
{
COORD consize = getconsize();
if (location.X < 0 || location.X >= consize.X || location.Y < 0 || location.Y > consize.Y)
return false;
if(timeshit >= SHOOTING_SILHOUETTE_HITMARKERSNUM)
{
timeshit = SHOOTING_SILHOUETTE_HITMARKERSNUM - 1;
}
char toprint = g_Shooting_HitMarkers[timeshit];
setcursor(location.X, location.Y);
writechar(toprint);
return true;
}
/*
* Write bytes into the buffer
* (buffer, string) -> integer
*/
int rb_write(lua_State *L) {
size_t l, w = 0;
ringbuffer *b = luaL_checkudata(L, 1, "ringbuffer_mt");
const char *s = luaL_checklstring(L, 2, &l);
/* Does `l` bytes fit? */
if((l + b->blen) > b->alen) {
lua_pushnil(L);
return 1;
}
while(l-- > 0) {
writechar(b, *s++);
w++;
}
modpos(b);
lua_pushinteger(L, w);
return 1;
}
int main(int argc, char **argv)
{
int numbits = 6;
int digit;
const char *digits = base64digits;
char *p, *pd, string[BUFSIZ];
if (argc != 2) {
printf("usage: %s file\n", argv[0]);
exit(0);
}
if (freopen(argv[1], "r", stdin) == NULL) {
fprintf(stderr, "file %s not found\n", argv[1]);
exit(1);
}
strcpy(string, argv[1]);
pd = p = string;
while ((p = strchr(p, '/')) != NULL)
pd=p++;
p = strchr(pd, '.');
if (p != NULL)
*p = '\0';
printf("const char *%s_au = \"\\\n", pd);
digit = readbits (numbits, &numbits);
while (numbits > 0) {
writechar (digits[digit]);
digit = readbits (numbits, &numbits);
}
padoutput();
printf("\";\n");
return 0;
}
void get_nowait( void )
{
extern char * const init_source[];
static char * const *source_block = init_source;
static char *source_char;
static char inbuf[INBUFSZ];
static char *ibp;
static char *const inbuf_source[] = { inbuf, 0 };
flag = 1; /* assume success */
if( abort_input ) {
have_ungotten = 0;
source_block = inbuf_source + 1; /* null */
ibp = 0;
abort_input = 0;
}
if( have_ungotten ) {
*--sp = ungotten;
have_ungotten = 0;
return;
}
while( *source_block ) { /* get input from memory */
if( !source_char ) { /* point to start of block */
source_char = *source_block;
}
if( *source_char ) { /* hey, we got one! */
*--sp = *source_char++;
return;
}
/*
at this point, we have a null character, so
attempt to move to next block.
*/
source_block += 1;
source_char = 0;
}
/* If we get here, there is no more input in memory,
so grab a line from the input stream */
if( ibp == 0 ) { /* start new line */
ibp = inbuf;
if( FlowPrompt >= 0 ) writechar( FlowPrompt );
}
if( char_ready() ) {
char c = readchar();
if( c == '\n' ) { /* end of line */
*ibp++ = c;
*ibp++ = 0;
ibp = 0;
source_block = inbuf_source;
get_nowait(); /* tail recursion */
return;
}
/* if we reach here, we won't have a char to return */
flag = 0;
if( c == '\b' ) {
writechar( ' ' );
if( ibp > inbuf ) { /* backspace, erase last */
writechar( '\b' );
ibp -= 1;
}
return;
}
if( ibp >= inbuf + INBUFSZ - 3 ) { /* buffer full */
writechar( 7 ); /* bell */
return;
}
*ibp++ = c;
}
flag = 0; /* fail */
}
void put( void )
{
writechar( *sp++ );
flag = 1;
}
