nihilazo
/
rockbox
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

initial work on varvara plugin

This commit is contained in:
Nico 2021-10-28 18:21:27 +01:00
parent 1cec2c7a73
commit 4c679e8ac5
18 changed files with 5974 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
apps/plugin.h
View File

@ -7,7 +7,7 @@
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 Björn Stenberg
* Copyright (C) 2002 Bj<EFBFBD>rn Stenberg
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License

1
apps/plugins/CATEGORIES
View File

@ -189,3 +189,4 @@ wormlet,games
xobox,games
xworld,games
zxbox,viewers
varvara,apps

1
apps/plugins/SUBDIRS
View File

@ -1,6 +1,7 @@
/* For all targets */
shortcuts
text_viewer
varvara
/* For various targets... */

41
apps/plugins/helloworld.c
View File

@ -1,41 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 Björn Stenberg
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
/* welcome to the example rockbox plugin */
/* mandatory include for all plugins */
#include "plugin.h"
/* this is the plugin entry point */
enum plugin_status plugin_start(const void* parameter)
{
/* if you don't use the parameter, you can do like
this to avoid the compiler warning about it */
(void)parameter;
/* "rb->" marks a plugin api call. Rockbox offers many of its built-in
* functions to plugins */
/* now go ahead and have fun! */
rb->splash(HZ*2, "Hello world!");
/* tell Rockbox that we have completed successfully */
return PLUGIN_OK;
}

5
apps/plugins/varvara/SOURCES Normal file
View File

@ -0,0 +1,5 @@
uxn.h
uxn.c
devices/ppu.h
devices/ppu.c
varvara.c

17
apps/plugins/varvara/console.tal Normal file
View File

@ -0,0 +1,17 @@
( dev/console )
|10 @Console $8 &write
( init )
|0100 ( -> )
;hello-word
&while
( send ) LDAk .Console/write DEO
INC2 LDAk ,&while JCN
POP2
BRK
@hello-word "Hello 20 "Uxn!

97
apps/plugins/varvara/devices/apu.c Normal file
View File

@ -0,0 +1,97 @@
#include "../uxn.h"
#include "apu.h"
/*
Copyright (c) 2021 Devine Lu Linvega
Copyright (c) 2021 Andrew Alderwick
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
#define NOTE_PERIOD (SAMPLE_FREQUENCY * 0x4000 / 11025)
#define ADSR_STEP (SAMPLE_FREQUENCY / 0xf)
/* clang-format off */
static Uint32 advances[12] = {
0x80000, 0x879c8, 0x8facd, 0x9837f, 0xa1451, 0xaadc1,
0xb504f, 0xbfc88, 0xcb2ff, 0xd7450, 0xe411f, 0xf1a1c
};
/* clang-format on */
static Sint32
envelope(Apu *c, Uint32 age)
{
if(!c->r) return 0x0888;
if(age < c->a) return 0x0888 * age / c->a;
if(age < c->d) return 0x0444 * (2 * c->d - c->a - age) / (c->d - c->a);
if(age < c->s) return 0x0444;
if(age < c->r) return 0x0444 * (c->r - age) / (c->r - c->s);
c->advance = 0;
return 0x0000;
}
int
apu_render(Apu *c, Sint16 *sample, Sint16 *end)
{
Sint32 s;
if(!c->advance || !c->period) return 0;
while(sample < end) {
c->count += c->advance;
c->i += c->count / c->period;
c->count %= c->period;
if(c->i >= c->len) {
if(!c->repeat) {
c->advance = 0;
break;
}
c->i %= c->len;
}
s = (Sint8)(c->addr[c->i] + 0x80) * envelope(c, c->age++);
*sample++ += s * c->volume[0] / 0x180;
*sample++ += s * c->volume[1] / 0x180;
}
if(!c->advance) apu_finished_handler(c);
return 1;
}
void
apu_start(Apu *c, Uint16 adsr, Uint8 pitch)
{
if(pitch < 108 && c->len)
c->advance = advances[pitch % 12] >> (8 - pitch / 12);
else {
c->advance = 0;
return;
}
c->a = ADSR_STEP * (adsr >> 12);
c->d = ADSR_STEP * (adsr >> 8 & 0xf) + c->a;
c->s = ADSR_STEP * (adsr >> 4 & 0xf) + c->d;
c->r = ADSR_STEP * (adsr >> 0 & 0xf) + c->s;
c->age = 0;
c->i = 0;
if(c->len <= 0x100) /* single cycle mode */
c->period = NOTE_PERIOD * 337 / 2 / c->len;
else /* sample repeat mode */
c->period = NOTE_PERIOD;
}
Uint8
apu_get_vu(Apu *c)
{
int i;
Sint32 sum[2] = {0, 0};
if(!c->advance || !c->period) return 0;
for(i = 0; i < 2; ++i) {
if(!c->volume[i]) continue;
sum[i] = 1 + envelope(c, c->age) * c->volume[i] / 0x800;
if(sum[i] > 0xf) sum[i] = 0xf;
}
return (sum[0] << 4) | sum[1];
}

29
apps/plugins/varvara/devices/apu.h Normal file
View File

@ -0,0 +1,29 @@
/*
Copyright (c) 2021 Devine Lu Linvega
Copyright (c) 2021 Andrew Alderwick
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
typedef unsigned int Uint32;
typedef signed int Sint32;
#define SAMPLE_FREQUENCY 44100
typedef struct {
Uint8 *addr;
Uint32 count, advance, period, age, a, d, s, r;
Uint16 i, len;
Sint8 volume[2];
Uint8 pitch, repeat;
} Apu;
int apu_render(Apu *c, Sint16 *sample, Sint16 *end);
void apu_start(Apu *c, Uint16 adsr, Uint8 pitch);
Uint8 apu_get_vu(Apu *c);
void apu_finished_handler(Apu *c);

103
apps/plugins/varvara/devices/ppu.c Normal file
View File

@ -0,0 +1,103 @@
#include "ppu.h"
/*
Copyright (c) 2021 Devine Lu Linvega
Copyright (c) 2021 Andrew Alderwick
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
static Uint8 blending[5][16] = {
{0, 0, 0, 0, 1, 0, 1, 1, 2, 2, 0, 2, 3, 3, 3, 0},
{0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3},
{1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1},
{2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2},
{1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0}};
static void
ppu_clear(Ppu *p)
{
Uint32 row, bound = p->height * p->width / 2;
for(row = 0; row < bound; ++row)
p->pixels[row] = 0;
}
Uint8
ppu_set_size(Ppu *p, Uint16 width, Uint16 height)
{
ppu_clear(p);
p->width = width;
p->height = height;
p->pixels = realloc(p->pixels, p->width * p->height * sizeof(Uint8) / 2);
ppu_clear(p);
return !!p->pixels;
}
Uint8
ppu_read(Ppu *p, Uint16 x, Uint16 y)
{
if(x < p->width && y < p->height) {
Uint32 row = (x + y * p->width) / 0x2;
Uint8 shift = !(x & 0x1) << 2;
Uint8 pix = p->pixels[row] >> shift;
if(pix & 0x0c)
pix = pix >> 2;
return pix & 0x3;
}
return 0x0;
}
void
ppu_write(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 color)
{
if(x < p->width && y < p->height) {
Uint32 row = (x + y * p->width) / 0x2;
Uint8 shift = (!(x & 0x1) << 2) + (layer << 1);
Uint8 pix = p->pixels[row];
Uint8 mask = ~(0x3 << shift);
Uint8 pixnew = (pix & mask) + (color << shift);
if(x < p->width && y < p->height)
p->pixels[row] = pixnew;
if(pix != pixnew)
p->reqdraw = 1;
}
}
void
ppu_1bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy)
{
Uint16 v, h;
for(v = 0; v < 8; v++)
for(h = 0; h < 8; h++) {
Uint8 ch1 = (sprite[v] >> (7 - h)) & 0x1;
if(ch1 || blending[4][color])
ppu_write(p,
layer,
x + (flipx ? 7 - h : h),
y + (flipy ? 7 - v : v),
blending[ch1][color]);
}
}
void
ppu_2bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy)
{
Uint16 v, h;
for(v = 0; v < 8; v++)
for(h = 0; h < 8; h++) {
Uint8 ch1 = ((sprite[v] >> (7 - h)) & 0x1);
Uint8 ch2 = ((sprite[v + 8] >> (7 - h)) & 0x1);
Uint8 ch = ch1 + ch2 * 2;
if(ch || blending[4][color])
ppu_write(p,
layer,
x + (flipx ? 7 - h : h),
y + (flipy ? 7 - v : v),
blending[ch][color]);
}
}

30
apps/plugins/varvara/devices/ppu.h Normal file
View File

@ -0,0 +1,30 @@
#include <stdio.h>
#include <stdlib.h>
/*
Copyright (c) 2021 Devine Lu Linvega
Copyright (c) 2021 Andrew Alderwick
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
typedef unsigned char Uint8;
typedef unsigned short Uint16;
typedef unsigned int Uint32;
typedef struct Ppu {
Uint8 *pixels, reqdraw;
Uint16 width, height;
} Ppu;
Uint8 ppu_set_size(Ppu *p, Uint16 width, Uint16 height);
Uint8 ppu_read(Ppu *p, Uint16 x, Uint16 y);
void ppu_write(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 color);
void ppu_frame(Ppu *p);
void ppu_1bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy);
void ppu_2bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy);

4048
apps/plugins/varvara/uxn-fast.c Normal file
View File

File diff suppressed because it is too large Load Diff

157
apps/plugins/varvara/uxn.c Normal file
View File

@ -0,0 +1,157 @@
#include "uxn.h"
#include <stdio.h>
/*
Copyright (u) 2021 Devine Lu Linvega
Copyright (u) 2021 Andrew Alderwick
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
#define MODE_SHORT 0x20
#define MODE_RETURN 0x40
#define MODE_KEEP 0x80
#pragma mark - Operations
/* clang-format off */
/* Utilities */
static void (*push)(Stack *s, Uint16 a);
static Uint16 (*pop8)(Stack *s);
static Uint16 (*pop)(Stack *s);
static void (*poke)(Uint8 *m, Uint16 a, Uint16 b);
static Uint16 (*peek)(Uint8 *m, Uint16 a);
static int (*devw)(Device *d, Uint8 a, Uint16 b);
static Uint16 (*devr)(Device *d, Uint8 a);
static void (*warp)(Uxn *u, Uint16 a);
static void (*pull)(Uxn *u);
/* byte mode */
static void push8(Stack *s, Uint16 a) { if(s->ptr == 0xff) { s->error = 2; return; } s->dat[s->ptr++] = a; }
static Uint16 pop8k(Stack *s) { if(s->kptr == 0) { s->error = 1; return 0; } return s->dat[--s->kptr]; }
static Uint16 pop8d(Stack *s) { if(s->ptr == 0) { s->error = 1; return 0; } return s->dat[--s->ptr]; }
static void poke8(Uint8 *m, Uint16 a, Uint16 b) { m[a] = b; }
static Uint16 peek8(Uint8 *m, Uint16 a) { return m[a]; }
static int devw8(Device *d, Uint8 a, Uint16 b) { d->dat[a & 0xf] = b; return d->talk(d, a & 0x0f, 1); }
static Uint16 devr8(Device *d, Uint8 a) { d->talk(d, a & 0x0f, 0); return d->dat[a & 0xf]; }
static void warp8(Uxn *u, Uint16 a){ u->ram.ptr += (Sint8)a; }
static void pull8(Uxn *u){ push8(u->src, peek8(u->ram.dat, u->ram.ptr++)); }
/* short mode */
static void push16(Stack *s, Uint16 a) { push8(s, a >> 8); push8(s, a); }
static Uint16 pop16(Stack *s) { Uint8 a = pop8(s), b = pop8(s); return a + (b << 8); }
void poke16(Uint8 *m, Uint16 a, Uint16 b) { poke8(m, a, b >> 8); poke8(m, a + 1, b); }
Uint16 peek16(Uint8 *m, Uint16 a) { return (peek8(m, a) << 8) + peek8(m, a + 1); }
static int devw16(Device *d, Uint8 a, Uint16 b) { return devw8(d, a, b >> 8) && devw8(d, a + 1, b); }
static Uint16 devr16(Device *d, Uint8 a) { return (devr8(d, a) << 8) + devr8(d, a + 1); }
static void warp16(Uxn *u, Uint16 a){ u->ram.ptr = a; }
static void pull16(Uxn *u){ push16(u->src, peek16(u->ram.dat, u->ram.ptr++)); u->ram.ptr++; }
#pragma mark - Core
int
uxn_eval(Uxn *u, Uint16 vec)
{
Uint8 instr;
Uint16 a,b,c;
if(!vec || u->dev[0].dat[0xf])
return 0;
u->ram.ptr = vec;
if(u->wst.ptr > 0xf8) u->wst.ptr = 0xf8;
while((instr = u->ram.dat[u->ram.ptr++])) {
/* Return Mode */
if(instr & MODE_RETURN) {
u->src = &u->rst;
u->dst = &u->wst;
} else {
u->src = &u->wst;
u->dst = &u->rst;
}
/* Keep Mode */
if(instr & MODE_KEEP) {
pop8 = pop8k;
u->src->kptr = u->src->ptr;
} else {
pop8 = pop8d;
}
/* Short Mode */
if(instr & MODE_SHORT) {
push = push16; pop = pop16;
poke = poke16; peek = peek16;
devw = devw16; devr = devr16;
warp = warp16; pull = pull16;
} else {
push = push8; pop = pop8;
poke = poke8; peek = peek8;
devw = devw8; devr = devr8;
warp = warp8; pull = pull8;
}
switch(instr & 0x1f){
/* Stack */
case 0x00: /* LIT */ pull(u); break;
case 0x01: /* INC */ a = pop(u->src); push(u->src, a + 1); break;
case 0x02: /* POP */ pop(u->src); break;
case 0x03: /* DUP */ a = pop(u->src); push(u->src, a); push(u->src, a); break;
case 0x04: /* NIP */ a = pop(u->src); pop(u->src); push(u->src, a); break;
case 0x05: /* SWP */ a = pop(u->src), b = pop(u->src); push(u->src, a); push(u->src, b); break;
case 0x06: /* OVR */ a = pop(u->src), b = pop(u->src); push(u->src, b); push(u->src, a); push(u->src, b); break;
case 0x07: /* ROT */ a = pop(u->src), b = pop(u->src), c = pop(u->src); push(u->src, b); push(u->src, a); push(u->src, c); break;
/* Logic */
case 0x08: /* EQU */ a = pop(u->src), b = pop(u->src); push8(u->src, b == a); break;
case 0x09: /* NEQ */ a = pop(u->src), b = pop(u->src); push8(u->src, b != a); break;
case 0x0a: /* GTH */ a = pop(u->src), b = pop(u->src); push8(u->src, b > a); break;
case 0x0b: /* LTH */ a = pop(u->src), b = pop(u->src); push8(u->src, b < a); break;
case 0x0c: /* JMP */ a = pop(u->src); warp(u, a); break;
case 0x0d: /* JCN */ a = pop(u->src); if(pop8(u->src)) warp(u, a); break;
case 0x0e: /* JSR */ a = pop(u->src); push16(u->dst, u->ram.ptr); warp(u, a); break;
case 0x0f: /* STH */ a = pop(u->src); push(u->dst, a); break;
/* Memory */
case 0x10: /* LDZ */ a = pop8(u->src); push(u->src, peek(u->ram.dat, a)); break;
case 0x11: /* STZ */ a = pop8(u->src); b = pop(u->src); poke(u->ram.dat, a, b); break;
case 0x12: /* LDR */ a = pop8(u->src); push(u->src, peek(u->ram.dat, u->ram.ptr + (Sint8)a)); break;
case 0x13: /* STR */ a = pop8(u->src); b = pop(u->src); poke(u->ram.dat, u->ram.ptr + (Sint8)a, b); break;
case 0x14: /* LDA */ a = pop16(u->src); push(u->src, peek(u->ram.dat, a)); break;
case 0x15: /* STA */ a = pop16(u->src); b = pop(u->src); poke(u->ram.dat, a, b); break;
case 0x16: /* DEI */ a = pop8(u->src); push(u->src, devr(&u->dev[a >> 4], a)); break;
case 0x17: /* DEO */ a = pop8(u->src); b = pop(u->src); if (!devw(&u->dev[a >> 4], a, b)) return 1; break;
/* Arithmetic */
case 0x18: /* ADD */ a = pop(u->src), b = pop(u->src); push(u->src, b + a); break;
case 0x19: /* SUB */ a = pop(u->src), b = pop(u->src); push(u->src, b - a); break;
case 0x1a: /* MUL */ a = pop(u->src), b = pop(u->src); push(u->src, b * a); break;
case 0x1b: /* DIV */ a = pop(u->src), b = pop(u->src); if(a == 0) { u->src->error = 3; a = 1; } push(u->src, b / a); break;
case 0x1c: /* AND */ a = pop(u->src), b = pop(u->src); push(u->src, b & a); break;
case 0x1d: /* ORA */ a = pop(u->src), b = pop(u->src); push(u->src, b | a); break;
case 0x1e: /* EOR */ a = pop(u->src), b = pop(u->src); push(u->src, b ^ a); break;
case 0x1f: /* SFT */ a = pop8(u->src), b = pop(u->src); push(u->src, b >> (a & 0x0f) << ((a & 0xf0) >> 4)); break;
}
if(u->wst.error) return uxn_halt(u, u->wst.error, "Working-stack", instr);
if(u->rst.error) return uxn_halt(u, u->rst.error, "Return-stack", instr);
}
return 1;
}
/* clang-format on */
int
uxn_boot(Uxn *u)
{
unsigned int i;
char *cptr = (char *)u;
for(i = 0; i < sizeof(*u); i++)
cptr[i] = 0x00;
return 1;
}
Device *
uxn_port(Uxn *u, Uint8 id, int (*talkfn)(Device *d, Uint8 b0, Uint8 w))
{
Device *d = &u->dev[id];
d->addr = id * 0x10;
d->u = u;
d->mem = u->ram.dat;
d->talk = talkfn;
return d;
}

50
apps/plugins/varvara/uxn.h Normal file
View File

@ -0,0 +1,50 @@
/*
Copyright (c) 2021 Devine Lu Linvega
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
typedef unsigned char Uint8;
typedef signed char Sint8;
typedef unsigned short Uint16;
typedef signed short Sint16;
#define PAGE_PROGRAM 0x0100
typedef struct {
Uint8 ptr, kptr, error;
Uint8 dat[256];
} Stack;
typedef struct {
Uint16 ptr;
Uint8 dat[65536];
} Memory;
typedef struct Device {
struct Uxn *u;
Uint8 addr, dat[16], *mem;
Uint16 vector;
int (*talk)(struct Device *d, Uint8, Uint8);
} Device;
typedef struct Uxn {
Stack wst, rst, *src, *dst;
Memory ram;
Device dev[16];
} Uxn;
struct Uxn;
void poke16(Uint8 *m, Uint16 a, Uint16 b);
Uint16 peek16(Uint8 *m, Uint16 a);
int uxn_boot(Uxn *c);
int uxn_eval(Uxn *u, Uint16 vec);
int uxn_halt(Uxn *u, Uint8 error, char *name, int id);
Device *uxn_port(Uxn *u, Uint8 id, int (*talkfn)(Device *, Uint8, Uint8));

426
apps/plugins/varvara/uxnasm.c Normal file
View File

@ -0,0 +1,426 @@
#include <stdio.h>
/*
Copyright (c) 2021 Devine Lu Linvega
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
#define TRIM 0x0100
#define LENGTH 0x10000
#define LABELS 512
#define MACROS 256
typedef unsigned char Uint8;
typedef signed char Sint8;
typedef unsigned short Uint16;
typedef struct {
char name[64], items[64][64];
Uint8 len;
} Macro;
typedef struct {
char name[64];
Uint16 addr, refs;
} Label;
typedef struct {
Uint8 data[LENGTH];
Uint16 ptr, length, llen, mlen;
Label labels[LABELS];
Macro macros[MACROS];
} Program;
Program p;
static Uint16 addr = 0;
/* clang-format off */
static char ops[][4] = {
"LIT", "INC", "POP", "DUP", "NIP", "SWP", "OVR", "ROT",
"EQU", "NEQ", "GTH", "LTH", "JMP", "JCN", "JSR", "STH",
"LDZ", "STZ", "LDR", "STR", "LDA", "STA", "DEI", "DEO",
"ADD", "SUB", "MUL", "DIV", "AND", "ORA", "EOR", "SFT"
};
static int cpos(char *s, char a){ int i = 0; char c; while((c = s[i++])) if(c == a) return i; return -1; }
static int scmp(char *a, char *b, int len) { int i = 0; while(a[i] == b[i]) if(!a[i] || ++i >= len) return 1; return 0; } /* string compare */
static int sihx(char *s) { int i = 0; char c; while((c = s[i++])) if(!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f')) return 0; return i > 1; } /* string is hexadecimal */
static int shex(char *s) { int n = 0, i = 0; char c; while((c = s[i++])) if(c >= '0' && c <= '9') n = n * 16 + (c - '0'); else if(c >= 'a' && c <= 'f') n = n * 16 + 10 + (c - 'a'); return n; } /* string to num */
static int slen(char *s) { int i = 0; while(s[i]) ++i; return i; } /* string length */
static char *scpy(char *src, char *dst, int len) { int i = 0; while((dst[i] = src[i]) && i < len - 2) i++; dst[i + 1] = '\0'; return dst; } /* string copy */
static char *scat(char *dst, const char *src) { char *ptr = dst + slen(dst); while(*src) *ptr++ = *src++; *ptr = '\0'; return dst; } /* string cat */
#pragma mark - Helpers
/* clang-format on */
#pragma mark - I/O
static Macro *
findmacro(char *name)
{
int i;
for(i = 0; i < p.mlen; ++i)
if(scmp(p.macros[i].name, name, 64))
return &p.macros[i];
return NULL;
}
static Label *
findlabel(char *name)
{
int i;
for(i = 0; i < p.llen; ++i)
if(scmp(p.labels[i].name, name, 64))
return &p.labels[i];
return NULL;
}
static Uint8
findopcode(char *s)
{
int i;
for(i = 0; i < 0x20; ++i) {
int m = 0;
if(!scmp(ops[i], s, 3))
continue;
while(s[3 + m]) {
if(s[3 + m] == '2')
i |= (1 << 5); /* mode: short */
else if(s[3 + m] == 'r')
i |= (1 << 6); /* mode: return */
else if(s[3 + m] == 'k')
i |= (1 << 7); /* mode: keep */
else
return 0; /* failed to match */
m++;
}
if(!i) i |= (1 << 7); /* force LIT nonzero (keep is ignored) */
return i;
}
return 0;
}
static void
pushbyte(Uint8 b, int lit)
{
if(lit) pushbyte(findopcode("LIT"), 0);
p.data[p.ptr++] = b;
p.length = p.ptr;
}
static void
pushshort(Uint16 s, int lit)
{
if(lit) pushbyte(findopcode("LIT2"), 0);
pushbyte((s >> 8) & 0xff, 0);
pushbyte(s & 0xff, 0);
}
static void
pushword(char *s)
{
int i = 0;
char c;
while((c = s[i++])) pushbyte(c, 0);
}
static char *
sublabel(char *src, char *scope, char *name)
{
return scat(scat(scpy(scope, src, 64), "/"), name);
}
#pragma mark - Parser
static int
error(char *name, char *msg)
{
fprintf(stderr, "%s: %s\n", name, msg);
return 0;
}
static int
makemacro(char *name, FILE *f)
{
Macro *m;
char word[64];
if(findmacro(name))
return error("Macro duplicate", name);
if(sihx(name) && slen(name) % 2 == 0)
return error("Macro name is hex number", name);
if(findopcode(name) || scmp(name, "BRK", 4) || !slen(name) || scmp(name, "include", 8))
return error("Macro name is invalid", name);
if(p.mlen == MACROS)
return error("Too many macros", name);
m = &p.macros[p.mlen++];
scpy(name, m->name, 64);
while(fscanf(f, "%63s", word) == 1) {
if(word[0] == '{') continue;
if(word[0] == '}') break;
if(m->len > 64)
return error("Macro too large", name);
scpy(word, m->items[m->len++], 64);
}
return 1;
}
static int
makelabel(char *name)
{
Label *l;
if(findlabel(name))
return error("Label duplicate", name);
if(sihx(name) && slen(name) % 2 == 0)
return error("Label name is hex number", name);
if(findopcode(name) || scmp(name, "BRK", 4) || !slen(name))
return error("Label name is invalid", name);
if(p.llen == LABELS)
return error("Too many labels", name);
l = &p.labels[p.llen++];
l->addr = addr;
l->refs = 0;
scpy(name, l->name, 64);
return 1;
}
static int
addref(Label *l, Uint8 rel)
{
if(rel) {
int pos = cpos(l->name, '/');
if(pos != -1) {
char parent[64];
Label *rl = findlabel(scpy(l->name, parent, pos));
if(rl)
++rl->refs;
}
}
return ++l->refs;
}
static int
skipblock(char *w, int *cap, char a, char b)
{
if(w[0] == b) {
*cap = 0;
return 1;
}
if(w[0] == a) *cap = 1;
if(*cap) return 1;
return 0;
}
static int
walktoken(char *w)
{
Macro *m;
if(findopcode(w) || scmp(w, "BRK", 4))
return 1;
switch(w[0]) {
case '[': return 0;
case ']': return 0;
case '\'': return 1;
case '.': return 2; /* zero-page: LIT addr-lb */
case ',': return 2; /* relative: LIT addr-rel */
case ':': return 2; /* absolute: addr-hb addr-lb */
case ';': return 3; /* absolute: LIT addr-hb addr-lb */
case '$': return shex(w + 1);
case '#': return slen(w + 1) == 4 ? 3 : 2;
case '"': return slen(w + 1);
}
if((m = findmacro(w))) {
int i, res = 0;
for(i = 0; i < m->len; ++i)
res += walktoken(m->items[i]);
return res;
}
if(sihx(w) && slen(w) == 2)
return 1;
else if(sihx(w) && slen(w) == 4)
return 2;
return error("Invalid token", w);
}
static int
parsetoken(char *w)
{
Label *l;
Macro *m;
if(w[0] == '.' && (l = findlabel(w + 1))) { /* zero-page */
if(l->addr > 0xff)
return error("Address is not in zero page", w);
pushbyte(l->addr, 1);
return addref(l, 1);
} else if(w[0] == ',' && (l = findlabel(w + 1))) { /* relative */
int off = l->addr - p.ptr - 3;
if(off < -126 || off > 126)
return error("Address is too far", w);
pushbyte((Sint8)off, 1);
return addref(l, 0);
} else if(w[0] == ':' && (l = findlabel(w + 1))) { /* raw */
pushshort(l->addr, 0);
return addref(l, 1);
} else if(w[0] == ';' && (l = findlabel(w + 1))) { /* absolute */
pushshort(l->addr, 1);
return addref(l, 1);
} else if(findopcode(w) || scmp(w, "BRK", 4)) { /* opcode */
pushbyte(findopcode(w), 0);
return 1;
} else if(w[0] == '"') { /* string */
pushword(w + 1);
return 1;
} else if(w[0] == '\'') { /* char */
pushbyte((Uint8)w[1], 0);
return 1;
} else if(w[0] == '#') { /* immediate */
if(slen(w + 1) == 1)
pushbyte((Uint8)w[1], 1);
if(sihx(w + 1) && slen(w + 1) == 2)
pushbyte(shex(w + 1), 1);
else if(sihx(w + 1) && slen(w + 1) == 4)
pushshort(shex(w + 1), 1);
else
return error("Invalid hexadecimal literal", w);
return 1;
} else if(sihx(w)) { /* raw */
if(slen(w) == 2)
pushbyte(shex(w), 0);
else if(slen(w) == 4)
pushshort(shex(w), 0);
else
return error("Invalid hexadecimal value", w);
return 1;
} else if((m = findmacro(w))) {
int i;
for(i = 0; i < m->len; ++i)
if(!parsetoken(m->items[i]))
return error("Invalid macro", m->name);
return 1;
}
return error("Invalid token", w);
}
static int
doinclude(FILE *f, int (*pass)(FILE *))
{
char word[64];
FILE *finc;
int ret;
if(fscanf(f, "%63s", word) != 1)
return error("End of input", "include");
if(!(finc = fopen(word, "r")))
return error("Include failed to open", word);
ret = pass(finc);
fclose(finc);
return ret;
}
static int
pass1(FILE *f)
{
int ccmnt = 0;
char w[64], scope[64], subw[64];
while(fscanf(f, "%63s", w) == 1) {
if(skipblock(w, &ccmnt, '(', ')')) continue;
if(slen(w) >= 63)
return error("Pass 1 - Invalid token", w);
if(w[0] == '|') {
if(!sihx(w + 1))
return error("Pass 1 - Invalid padding", w);
addr = shex(w + 1);
} else if(w[0] == '%') {
if(!makemacro(w + 1, f))
return error("Pass 1 - Invalid macro", w);
} else if(w[0] == '@') {
if(!makelabel(w + 1))
return error("Pass 1 - Invalid label", w);
scpy(w + 1, scope, 64);
} else if(w[0] == '&') {
if(!makelabel(sublabel(subw, scope, w + 1)))
return error("Pass 1 - Invalid sublabel", w);
} else if(scmp(w, "include", 8)) {
if(!doinclude(f, pass1))
return 0;
} else if(sihx(w))
addr += slen(w) / 2;
else
addr += walktoken(w);
}
rewind(f);
return 1;
}
static int
pass2(FILE *f)
{
int ccmnt = 0, cmacr = 0;
char w[64], scope[64], subw[64];
while(fscanf(f, "%63s", w) == 1) {
if(w[0] == '%') continue;
if(w[0] == '&') continue;
if(w[0] == '[') continue;
if(w[0] == ']') continue;
if(skipblock(w, &ccmnt, '(', ')')) continue;
if(skipblock(w, &cmacr, '{', '}')) continue;
if(w[0] == '|') {
if(p.length && (Uint16)shex(w + 1) < p.ptr)
return error("Pass 2 - Memory overwrite", w);
p.ptr = shex(w + 1);
continue;
} else if(w[0] == '$') {
if(p.length && (Uint16)(p.ptr + shex(w + 1)) < p.ptr)
return error("Pass 2 - Memory overwrite", w);
p.ptr += shex(w + 1);
continue;
} else if(w[0] == '@') {
scpy(w + 1, scope, 64);
continue;
} else if(scmp(w, "include", 8)) {
if(!doinclude(f, pass2))
return 0;
continue;
}
if(w[1] == '&' && (w[0] == '.' || w[0] == ',' || w[0] == ';' || w[0] == ':'))
scpy(sublabel(subw, scope, w + 2), w + 1, 64);
if(!parsetoken(w))
return error("Pass 2 - Unknown label", w);
}
return 1;
}
static void
cleanup(char *filename)
{
int i;
for(i = 0; i < p.llen; ++i)
if(p.labels[i].name[0] >= 'A' && p.labels[i].name[0] <= 'Z')
continue; /* Ignore capitalized labels(devices) */
else if(!p.labels[i].refs)
fprintf(stderr, "--- Unused label: %s\n", p.labels[i].name);
fprintf(stderr, "Assembled %s in %.2fkb(%.2f%% used), %d labels, %d macros.\n", filename, (p.length - TRIM) / 1024.0, p.length / 652.80, p.llen, p.mlen);
}
int
main(int argc, char *argv[])
{
FILE *f;
if(argc < 3)
return !error("usage", "input.tal output.rom");
if(!(f = fopen(argv[1], "r")))
return !error("Load", "Failed to open source.");
if(!pass1(f) || !pass2(f))
return !error("Assembly", "Failed to assemble rom.");
fwrite(p.data + TRIM, p.length - TRIM, 1, fopen(argv[2], "wb"));
fclose(f);
cleanup(argv[2]);
return 0;
}

211
apps/plugins/varvara/uxncli.c Normal file
View File

@ -0,0 +1,211 @@
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include "uxn.h"
/*
Copyright (c) 2021 Devine Lu Linvega
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
#pragma mark - Core
static Device *devsystem, *devconsole;
static int
error(char *msg, const char *err)
{
fprintf(stderr, "Error %s: %s\n", msg, err);
return 0;
}
static void
inspect(Stack *s, char *name)
{
Uint8 x, y;
fprintf(stderr, "\n%s\n", name);
for(y = 0; y < 0x04; ++y) {
for(x = 0; x < 0x08; ++x) {
Uint8 p = y * 0x08 + x;
fprintf(stderr,
p == s->ptr ? "[%02x]" : " %02x ",
s->dat[p]);
}
fprintf(stderr, "\n");
}
}
#pragma mark - Devices
static int
system_talk(Device *d, Uint8 b0, Uint8 w)
{
if(!w) { /* read */
switch(b0) {
case 0x2: d->dat[0x2] = d->u->wst.ptr; break;
case 0x3: d->dat[0x3] = d->u->rst.ptr; break;
}
} else { /* write */
switch(b0) {
case 0x2: d->u->wst.ptr = d->dat[0x2]; break;
case 0x3: d->u->rst.ptr = d->dat[0x3]; break;
case 0xe:
inspect(&d->u->wst, "Working-stack");
inspect(&d->u->rst, "Return-stack");
break;
case 0xf: return 0;
}
}
return 1;
}
static int
console_talk(Device *d, Uint8 b0, Uint8 w)
{
if(b0 == 0x1)
d->vector = peek16(d->dat, 0x0);
if(w && b0 > 0x7)
write(b0 - 0x7, (char *)&d->dat[b0], 1);
return 1;
}
static int
file_talk(Device *d, Uint8 b0, Uint8 w)
{
Uint8 read = b0 == 0xd;
if(w && (read || b0 == 0xf)) {
char *name = (char *)&d->mem[peek16(d->dat, 0x8)];
Uint16 result = 0, length = peek16(d->dat, 0xa);
long offset = (peek16(d->dat, 0x4) << 16) + peek16(d->dat, 0x6);
Uint16 addr = peek16(d->dat, b0 - 1);
FILE *f = fopen(name, read ? "rb" : (offset ? "ab" : "wb"));
if(f) {
if(fseek(f, offset, SEEK_SET) != -1)
result = read ? fread(&d->mem[addr], 1, length, f) : fwrite(&d->mem[addr], 1, length, f);
fclose(f);
}
poke16(d->dat, 0x2, result);
}
return 1;
}
static int
datetime_talk(Device *d, Uint8 b0, Uint8 w)
{
time_t seconds = time(NULL);
struct tm *t = localtime(&seconds);
t->tm_year += 1900;
poke16(d->dat, 0x0, t->tm_year);
d->dat[0x2] = t->tm_mon;
d->dat[0x3] = t->tm_mday;
d->dat[0x4] = t->tm_hour;
d->dat[0x5] = t->tm_min;
d->dat[0x6] = t->tm_sec;
d->dat[0x7] = t->tm_wday;
poke16(d->dat, 0x08, t->tm_yday);
d->dat[0xa] = t->tm_isdst;
(void)b0;
(void)w;
return 1;
}
static int
nil_talk(Device *d, Uint8 b0, Uint8 w)
{
(void)d;
(void)b0;
(void)w;
return 1;
}
#pragma mark - Generics
static const char *errors[] = {"underflow", "overflow", "division by zero"};
int
uxn_halt(Uxn *u, Uint8 error, char *name, int id)
{
fprintf(stderr, "Halted: %s %s#%04x, at 0x%04x\n", name, errors[error - 1], id, u->ram.ptr);
return 0;
}
static int
console_input(Uxn *u, char c)
{
devconsole->dat[0x2] = c;
return uxn_eval(u, devconsole->vector);
}
static void
run(Uxn *u)
{
Uint16 vec;
while((!u->dev[0].dat[0xf]) && (read(0, &devconsole->dat[0x2], 1) > 0)) {
vec = peek16(devconsole->dat, 0);
if(!vec) vec = u->ram.ptr; /* continue after last BRK */
uxn_eval(u, vec);
}
}
static int
load(Uxn *u, char *filepath)
{
FILE *f;
if(!(f = fopen(filepath, "rb")))
return 0;
fread(u->ram.dat + PAGE_PROGRAM, sizeof(u->ram.dat) - PAGE_PROGRAM, 1, f);
fprintf(stderr, "Loaded %s\n", filepath);
return 1;
}
int
main(int argc, char **argv)
{
Uxn u;
int i, loaded = 0;
if(!uxn_boot(&u))
return error("Boot", "Failed");
/* system */ devsystem = uxn_port(&u, 0x0, system_talk);
/* console */ devconsole = uxn_port(&u, 0x1, console_talk);
/* empty */ uxn_port(&u, 0x2, nil_talk);
/* empty */ uxn_port(&u, 0x3, nil_talk);
/* empty */ uxn_port(&u, 0x4, nil_talk);
/* empty */ uxn_port(&u, 0x5, nil_talk);
/* empty */ uxn_port(&u, 0x6, nil_talk);
/* empty */ uxn_port(&u, 0x7, nil_talk);
/* empty */ uxn_port(&u, 0x8, nil_talk);
/* empty */ uxn_port(&u, 0x9, nil_talk);
/* file */ uxn_port(&u, 0xa, file_talk);
/* datetime */ uxn_port(&u, 0xb, datetime_talk);
/* empty */ uxn_port(&u, 0xc, nil_talk);
/* empty */ uxn_port(&u, 0xd, nil_talk);
/* empty */ uxn_port(&u, 0xe, nil_talk);
/* empty */ uxn_port(&u, 0xf, nil_talk);
for(i = 1; i < argc; ++i) {
if(!loaded++) {
if(!load(&u, argv[i]))
return error("Load", "Failed");
if(!uxn_eval(&u, PAGE_PROGRAM))
return error("Init", "Failed");
} else {
char *p = argv[i];
while(*p) console_input(&u, *p++);
console_input(&u, '\n');
}
}
if(!loaded)
return error("Input", "Missing");
run(&u);
return 0;
}

624
apps/plugins/varvara/uxnemu.c Normal file
View File

@ -0,0 +1,624 @@
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include "uxn.h"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#include <SDL.h>
#include "devices/ppu.h"
#include "devices/apu.h"
#pragma GCC diagnostic pop
/*
Copyright (c) 2021 Devine Lu Linvega
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/
#define WIDTH 64 * 8
#define HEIGHT 40 * 8
#define PAD 4
#define FIXED_SIZE 0
#define POLYPHONY 4
#define BENCH 0
static SDL_Window *gWindow;
static SDL_Texture *gTexture;
static SDL_Renderer *gRenderer;
static SDL_AudioDeviceID audio_id;
static SDL_Rect gRect;
/* devices */
static Ppu ppu;
static Apu apu[POLYPHONY];
static Device *devsystem, *devscreen, *devmouse, *devctrl, *devaudio0, *devconsole;
static Uint8 zoom = 1;
static Uint32 *ppu_screen, stdin_event, audio0_event, palette[16];
static Uint8 font[][8] = {
{0x00, 0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c},
{0x00, 0x30, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10},
{0x00, 0x7c, 0x82, 0x02, 0x7c, 0x80, 0x80, 0xfe},
{0x00, 0x7c, 0x82, 0x02, 0x1c, 0x02, 0x82, 0x7c},
{0x00, 0x0c, 0x14, 0x24, 0x44, 0x84, 0xfe, 0x04},
{0x00, 0xfe, 0x80, 0x80, 0x7c, 0x02, 0x82, 0x7c},
{0x00, 0x7c, 0x82, 0x80, 0xfc, 0x82, 0x82, 0x7c},
{0x00, 0x7c, 0x82, 0x02, 0x1e, 0x02, 0x02, 0x02},
{0x00, 0x7c, 0x82, 0x82, 0x7c, 0x82, 0x82, 0x7c},
{0x00, 0x7c, 0x82, 0x82, 0x7e, 0x02, 0x82, 0x7c},
{0x00, 0x7c, 0x82, 0x02, 0x7e, 0x82, 0x82, 0x7e},
{0x00, 0xfc, 0x82, 0x82, 0xfc, 0x82, 0x82, 0xfc},
{0x00, 0x7c, 0x82, 0x80, 0x80, 0x80, 0x82, 0x7c},
{0x00, 0xfc, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfc},
{0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x82, 0x7c},
{0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x80, 0x80}};
static int
clamp(int val, int min, int max)
{
return (val >= min) ? (val <= max) ? val : max : min;
}
static int
error(char *msg, const char *err)
{
fprintf(stderr, "%s: %s\n", msg, err);
return 0;
}
#pragma mark - Generics
static void
audio_callback(void *u, Uint8 *stream, int len)
{
int i, running = 0;
Sint16 *samples = (Sint16 *)stream;
SDL_memset(stream, 0, len);
for(i = 0; i < POLYPHONY; ++i)
running += apu_render(&apu[i], samples, samples + len / 2);
if(!running)
SDL_PauseAudioDevice(audio_id, 1);
(void)u;
}
void
apu_finished_handler(Apu *c)
{
SDL_Event event;
event.type = audio0_event + (c - apu);
SDL_PushEvent(&event);
}
static int
stdin_handler(void *p)
{
SDL_Event event;
event.type = stdin_event;
while(read(0, &event.cbutton.button, 1) > 0)
SDL_PushEvent(&event);
return 0;
(void)p;
}
void
set_palette(Uint8 *addr)
{
int i;
for(i = 0; i < 4; ++i) {
Uint8
r = (*(addr + i / 2) >> (!(i % 2) << 2)) & 0x0f,
g = (*(addr + 2 + i / 2) >> (!(i % 2) << 2)) & 0x0f,
b = (*(addr + 4 + i / 2) >> (!(i % 2) << 2)) & 0x0f;
palette[i] = 0xff000000 | (r << 20) | (r << 16) | (g << 12) | (g << 8) | (b << 4) | b;
}
for(i = 4; i < 16; ++i)
palette[i] = palette[i / 4];
ppu.reqdraw = 1;
}
static void
set_window_size(SDL_Window *window, int w, int h)
{
SDL_Point win, win_old;
SDL_GetWindowPosition(window, &win.x, &win.y);
SDL_GetWindowSize(window, &win_old.x, &win_old.y);
SDL_SetWindowPosition(window, (win.x + win_old.x / 2) - w / 2, (win.y + win_old.y / 2) - h / 2);
SDL_SetWindowSize(window, w, h);
}
static void
set_zoom(Uint8 scale)
{
zoom = clamp(scale, 1, 3);
if(!gWindow)
return;
set_window_size(gWindow, (ppu.width + PAD * 2) * zoom, (ppu.height + PAD * 2) * zoom);
ppu.reqdraw = 1;
}
static int
set_size(Uint16 width, Uint16 height, int is_resize)
{
ppu_set_size(&ppu, width, height);
gRect.x = PAD;
gRect.y = PAD;
gRect.w = ppu.width;
gRect.h = ppu.height;
if(!(ppu_screen = realloc(ppu_screen, ppu.width * ppu.height * sizeof(Uint32))))
return error("ppu_screen", "Memory failure");
memset(ppu_screen, 0, ppu.width * ppu.height * sizeof(Uint32));
if(gTexture != NULL) SDL_DestroyTexture(gTexture);
SDL_RenderSetLogicalSize(gRenderer, ppu.width + PAD * 2, ppu.height + PAD * 2);
gTexture = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, ppu.width + PAD * 2, ppu.height + PAD * 2);
if(gTexture == NULL || SDL_SetTextureBlendMode(gTexture, SDL_BLENDMODE_NONE))
return error("gTexture", SDL_GetError());
if(SDL_UpdateTexture(gTexture, NULL, ppu_screen, sizeof(Uint32)) != 0)
return error("SDL_UpdateTexture", SDL_GetError());
if(is_resize)
set_window_size(gWindow, (ppu.width + PAD * 2) * zoom, (ppu.height + PAD * 2) * zoom);
ppu.reqdraw = 1;
return 1;
}
static void
capture_screen(void)
{
const Uint32 format = SDL_PIXELFORMAT_RGB24;
time_t t = time(NULL);
char fname[64];
int w, h;
SDL_Surface *surface;
SDL_GetRendererOutputSize(gRenderer, &w, &h);
surface = SDL_CreateRGBSurfaceWithFormat(0, w, h, 24, format);
SDL_RenderReadPixels(gRenderer, NULL, format, surface->pixels, surface->pitch);
strftime(fname, sizeof(fname), "screenshot-%Y%m%d-%H%M%S.bmp", localtime(&t));
SDL_SaveBMP(surface, fname);
SDL_FreeSurface(surface);
fprintf(stderr, "Saved %s\n", fname);
}
static void
draw_inspect(Ppu *p, Uint8 *stack, Uint8 wptr, Uint8 rptr, Uint8 *memory)
{
Uint8 i, x, y, b;
for(i = 0; i < 0x20; ++i) {
x = ((i % 8) * 3 + 1) * 8, y = (i / 8 + 1) * 8, b = stack[i];
/* working stack */
ppu_1bpp(p, 1, x, y, font[(b >> 4) & 0xf], 1 + (wptr == i) * 0x7, 0, 0);
ppu_1bpp(p, 1, x + 8, y, font[b & 0xf], 1 + (wptr == i) * 0x7, 0, 0);
y = 0x28 + (i / 8 + 1) * 8;
b = memory[i];
/* return stack */
ppu_1bpp(p, 1, x, y, font[(b >> 4) & 0xf], 3, 0, 0);
ppu_1bpp(p, 1, x + 8, y, font[b & 0xf], 3, 0, 0);
}
/* return pointer */
ppu_1bpp(p, 1, 0x8, y + 0x10, font[(rptr >> 4) & 0xf], 0x2, 0, 0);
ppu_1bpp(p, 1, 0x10, y + 0x10, font[rptr & 0xf], 0x2, 0, 0);
/* guides */
for(x = 0; x < 0x10; ++x) {
ppu_write(p, 1, x, p->height / 2, 2);
ppu_write(p, 1, p->width - x, p->height / 2, 2);
ppu_write(p, 1, p->width / 2, p->height - x, 2);
ppu_write(p, 1, p->width / 2, x, 2);
ppu_write(p, 1, p->width / 2 - 0x10 / 2 + x, p->height / 2, 2);
ppu_write(p, 1, p->width / 2, p->height / 2 - 0x10 / 2 + x, 2);
}
}
static void
redraw(Uxn *u)
{
Uint16 x, y;
if(devsystem->dat[0xe])
draw_inspect(&ppu, u->wst.dat, u->wst.ptr, u->rst.ptr, u->ram.dat);
for(y = 0; y < ppu.height; ++y)
for(x = 0; x < ppu.width; ++x)
ppu_screen[x + y * ppu.width] = palette[ppu_read(&ppu, x, y)];
if(SDL_UpdateTexture(gTexture, &gRect, ppu_screen, ppu.width * sizeof(Uint32)) != 0)
error("SDL_UpdateTexture", SDL_GetError());
SDL_RenderClear(gRenderer);
SDL_RenderCopy(gRenderer, gTexture, NULL, NULL);
SDL_RenderPresent(gRenderer);
ppu.reqdraw = 0;
}
static void
quit(void)
{
if(audio_id)
SDL_CloseAudioDevice(audio_id);
SDL_DestroyTexture(gTexture);
gTexture = NULL;
SDL_DestroyRenderer(gRenderer);
gRenderer = NULL;
SDL_DestroyWindow(gWindow);
SDL_Quit();
exit(0);
}
static int
init(void)
{
SDL_AudioSpec as;
SDL_zero(as);
as.freq = SAMPLE_FREQUENCY;
as.format = AUDIO_S16;
as.channels = 2;
as.callback = audio_callback;
as.samples = 512;
as.userdata = NULL;
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
error("sdl", SDL_GetError());
if(SDL_Init(SDL_INIT_VIDEO) < 0)
return error("sdl", SDL_GetError());
} else {
audio_id = SDL_OpenAudioDevice(NULL, 0, &as, NULL, 0);
if(!audio_id)
error("sdl_audio", SDL_GetError());
}
gWindow = SDL_CreateWindow("Uxn", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, (WIDTH + PAD * 2) * zoom, (HEIGHT + PAD * 2) * zoom, SDL_WINDOW_SHOWN);
if(gWindow == NULL)
return error("sdl_window", SDL_GetError());
gRenderer = SDL_CreateRenderer(gWindow, -1, 0);
if(gRenderer == NULL)
return error("sdl_renderer", SDL_GetError());
stdin_event = SDL_RegisterEvents(1);
audio0_event = SDL_RegisterEvents(POLYPHONY);
SDL_CreateThread(stdin_handler, "stdin", NULL);
SDL_StartTextInput();
SDL_ShowCursor(SDL_DISABLE);
return 1;
}
static void
domouse(SDL_Event *event)
{
Uint8 flag = 0x00;
Uint16 x = clamp(event->motion.x - PAD, 0, ppu.width - 1);
Uint16 y = clamp(event->motion.y - PAD, 0, ppu.height - 1);
if(event->type == SDL_MOUSEWHEEL) {
devmouse->dat[7] = event->wheel.y;
return;
}
poke16(devmouse->dat, 0x2, x);
poke16(devmouse->dat, 0x4, y);
devmouse->dat[7] = 0x00;
switch(event->button.button) {
case SDL_BUTTON_LEFT: flag = 0x01; break;
case SDL_BUTTON_RIGHT: flag = 0x10; break;
}
switch(event->type) {
case SDL_MOUSEBUTTONDOWN:
devmouse->dat[6] |= flag;
break;
case SDL_MOUSEBUTTONUP:
devmouse->dat[6] &= (~flag);
break;
}
}
static void
doctrl(SDL_Event *event, int z)
{
Uint8 flag = 0x00;
SDL_Keymod mods = SDL_GetModState();
devctrl->dat[2] &= 0xf8;
if(mods & KMOD_CTRL) devctrl->dat[2] |= 0x01;
if(mods & KMOD_ALT) devctrl->dat[2] |= 0x02;
if(mods & KMOD_SHIFT) devctrl->dat[2] |= 0x04;
/* clang-format off */
switch(event->key.keysym.sym) {
case SDLK_ESCAPE: flag = 0x08; break;
case SDLK_UP: flag = 0x10; break;
case SDLK_DOWN: flag = 0x20; break;
case SDLK_LEFT: flag = 0x40; break;
case SDLK_RIGHT: flag = 0x80; break;
case SDLK_F1: if(z) set_zoom(zoom > 2 ? 1 : zoom + 1); break;
case SDLK_F2: if(z) devsystem->dat[0xe] = !devsystem->dat[0xe]; break;
case SDLK_F3: if(z) capture_screen(); break;
}
/* clang-format on */
if(z) {
devctrl->dat[2] |= flag;
if(event->key.keysym.sym < 0x20 || event->key.keysym.sym == SDLK_DELETE)
devctrl->dat[3] = event->key.keysym.sym;
else if((mods & KMOD_CTRL) && event->key.keysym.sym >= SDLK_a && event->key.keysym.sym <= SDLK_z)
devctrl->dat[3] = event->key.keysym.sym - (mods & KMOD_SHIFT) * 0x20;
} else
devctrl->dat[2] &= ~flag;
}
#pragma mark - Devices
static int
system_talk(Device *d, Uint8 b0, Uint8 w)
{
if(!w) { /* read */
switch(b0) {
case 0x2: d->dat[0x2] = d->u->wst.ptr; break;
case 0x3: d->dat[0x3] = d->u->rst.ptr; break;
}
} else { /* write */
switch(b0) {
case 0x2: d->u->wst.ptr = d->dat[0x2]; break;
case 0x3: d->u->rst.ptr = d->dat[0x3]; break;
case 0xf: return 0;
}
if(b0 > 0x7 && b0 < 0xe)
set_palette(&d->dat[0x8]);
}
return 1;
}
static int
console_talk(Device *d, Uint8 b0, Uint8 w)
{
if(w) {
if(b0 == 0x1)
d->vector = peek16(d->dat, 0x0);
if(b0 > 0x7)
write(b0 - 0x7, (char *)&d->dat[b0], 1);
}
return 1;
}
static int
screen_talk(Device *d, Uint8 b0, Uint8 w)
{
if(!w) switch(b0) {
case 0x2: d->dat[0x2] = ppu.width >> 8; break;
case 0x3: d->dat[0x3] = ppu.width; break;
case 0x4: d->dat[0x4] = ppu.height >> 8; break;
case 0x5: d->dat[0x5] = ppu.height; break;
}
else
switch(b0) {
case 0x1: d->vector = peek16(d->dat, 0x0); break;
case 0x5:
if(!FIXED_SIZE) return set_size(peek16(d->dat, 0x2), peek16(d->dat, 0x4), 1);
break;
case 0xe: {
Uint16 x = peek16(d->dat, 0x8);
Uint16 y = peek16(d->dat, 0xa);
Uint8 layer = d->dat[0xe] & 0x40;
ppu_write(&ppu, !!layer, x, y, d->dat[0xe] & 0x3);
if(d->dat[0x6] & 0x01) poke16(d->dat, 0x8, x + 1); /* auto x+1 */
if(d->dat[0x6] & 0x02) poke16(d->dat, 0xa, y + 1); /* auto y+1 */
break;
}
case 0xf: {
Uint16 x = peek16(d->dat, 0x8);
Uint16 y = peek16(d->dat, 0xa);
Uint8 layer = d->dat[0xf] & 0x40;
Uint8 *addr = &d->mem[peek16(d->dat, 0xc)];
if(d->dat[0xf] & 0x80) {
ppu_2bpp(&ppu, !!layer, x, y, addr, d->dat[0xf] & 0xf, d->dat[0xf] & 0x10, d->dat[0xf] & 0x20);
if(d->dat[0x6] & 0x04) poke16(d->dat, 0xc, peek16(d->dat, 0xc) + 16); /* auto addr+16 */
} else {
ppu_1bpp(&ppu, !!layer, x, y, addr, d->dat[0xf] & 0xf, d->dat[0xf] & 0x10, d->dat[0xf] & 0x20);
if(d->dat[0x6] & 0x04) poke16(d->dat, 0xc, peek16(d->dat, 0xc) + 8); /* auto addr+8 */
}
if(d->dat[0x6] & 0x01) poke16(d->dat, 0x8, x + 8); /* auto x+8 */
if(d->dat[0x6] & 0x02) poke16(d->dat, 0xa, y + 8); /* auto y+8 */
break;
}
}
return 1;
}
static int
file_talk(Device *d, Uint8 b0, Uint8 w)
{
Uint8 read = b0 == 0xd;
if(w && (read || b0 == 0xf)) {
char *name = (char *)&d->mem[peek16(d->dat, 0x8)];
Uint16 result = 0, length = peek16(d->dat, 0xa);
long offset = (peek16(d->dat, 0x4) << 16) + peek16(d->dat, 0x6);
Uint16 addr = peek16(d->dat, b0 - 1);
FILE *f = fopen(name, read ? "rb" : (offset ? "ab" : "wb"));
if(f) {
if(fseek(f, offset, SEEK_SET) != -1)
result = read ? fread(&d->mem[addr], 1, length, f) : fwrite(&d->mem[addr], 1, length, f);
fclose(f);
}
poke16(d->dat, 0x2, result);
}
return 1;
}
static int
audio_talk(Device *d, Uint8 b0, Uint8 w)
{
Apu *c = &apu[d - devaudio0];
if(!audio_id) return 1;
if(!w) {
if(b0 == 0x2)
poke16(d->dat, 0x2, c->i);
else if(b0 == 0x4)
d->dat[0x4] = apu_get_vu(c);
} else if(b0 == 0xf) {
SDL_LockAudioDevice(audio_id);
c->len = peek16(d->dat, 0xa);
c->addr = &d->mem[peek16(d->dat, 0xc)];
c->volume[0] = d->dat[0xe] >> 4;
c->volume[1] = d->dat[0xe] & 0xf;
c->repeat = !(d->dat[0xf] & 0x80);
apu_start(c, peek16(d->dat, 0x8), d->dat[0xf] & 0x7f);
SDL_UnlockAudioDevice(audio_id);
SDL_PauseAudioDevice(audio_id, 0);
}
return 1;
}
static int
datetime_talk(Device *d, Uint8 b0, Uint8 w)
{
time_t seconds = time(NULL);
struct tm *t = localtime(&seconds);
t->tm_year += 1900;
poke16(d->dat, 0x0, t->tm_year);
d->dat[0x2] = t->tm_mon;
d->dat[0x3] = t->tm_mday;
d->dat[0x4] = t->tm_hour;
d->dat[0x5] = t->tm_min;
d->dat[0x6] = t->tm_sec;
d->dat[0x7] = t->tm_wday;
poke16(d->dat, 0x08, t->tm_yday);
d->dat[0xa] = t->tm_isdst;
(void)b0;
(void)w;
return 1;
}
static int
nil_talk(Device *d, Uint8 b0, Uint8 w)
{
if(w && b0 == 0x1)
d->vector = peek16(d->dat, 0x0);
(void)d;
(void)b0;
(void)w;
return 1;
}
static const char *errors[] = {"underflow", "overflow", "division by zero"};
int
uxn_halt(Uxn *u, Uint8 error, char *name, int id)
{
fprintf(stderr, "Halted: %s %s#%04x, at 0x%04x\n", name, errors[error - 1], id, u->ram.ptr);
return 0;
}
static int
console_input(Uxn *u, char c)
{
devconsole->dat[0x2] = c;
return uxn_eval(u, devconsole->vector);
}
static int
run(Uxn *u)
{
redraw(u);
while(!devsystem->dat[0xf]) {
SDL_Event event;
double elapsed, start = 0;
if(!BENCH)
start = SDL_GetPerformanceCounter();
while(SDL_PollEvent(&event) != 0) {
switch(event.type) {
case SDL_QUIT:
return error("Run", "Quit.");
case SDL_TEXTINPUT:
devctrl->dat[3] = event.text.text[0]; /* fall-thru */
case SDL_KEYDOWN:
case SDL_KEYUP:
doctrl(&event, event.type == SDL_KEYDOWN);
uxn_eval(u, devctrl->vector);
devctrl->dat[3] = 0;
break;
case SDL_MOUSEWHEEL:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEMOTION:
domouse(&event);
uxn_eval(u, devmouse->vector);
break;
case SDL_WINDOWEVENT:
if(event.window.event == SDL_WINDOWEVENT_EXPOSED)
redraw(u);
break;
default:
if(event.type == stdin_event) {
console_input(u, event.cbutton.button);
} else if(event.type >= audio0_event && event.type < audio0_event + POLYPHONY)
uxn_eval(u, peek16((devaudio0 + (event.type - audio0_event))->dat, 0));
}
}
uxn_eval(u, devscreen->vector);
if(ppu.reqdraw || devsystem->dat[0xe])
redraw(u);
if(!BENCH) {
elapsed = (SDL_GetPerformanceCounter() - start) / (double)SDL_GetPerformanceFrequency() * 1000.0f;
SDL_Delay(clamp(16.666f - elapsed, 0, 1000));
}
}
return error("Run", "Ended.");
}
static int
load(Uxn *u, char *filepath)
{
FILE *f;
if(!(f = fopen(filepath, "rb"))) return 0;
fread(u->ram.dat + PAGE_PROGRAM, sizeof(u->ram.dat) - PAGE_PROGRAM, 1, f);
fprintf(stderr, "Loaded %s\n", filepath);
return 1;
}
int
main(int argc, char **argv)
{
SDL_DisplayMode DM;
Uxn u;
int i, loaded = 0;
if(!uxn_boot(&u))
return error("Boot", "Failed to start uxn.");
/* system */ devsystem = uxn_port(&u, 0x0, system_talk);
/* console */ devconsole = uxn_port(&u, 0x1, console_talk);
/* screen */ devscreen = uxn_port(&u, 0x2, screen_talk);
/* audio0 */ devaudio0 = uxn_port(&u, 0x3, audio_talk);
/* audio1 */ uxn_port(&u, 0x4, audio_talk);
/* audio2 */ uxn_port(&u, 0x5, audio_talk);
/* audio3 */ uxn_port(&u, 0x6, audio_talk);
/* unused */ uxn_port(&u, 0x7, nil_talk);
/* control */ devctrl = uxn_port(&u, 0x8, nil_talk);
/* mouse */ devmouse = uxn_port(&u, 0x9, nil_talk);
/* file */ uxn_port(&u, 0xa, file_talk);
/* datetime */ uxn_port(&u, 0xb, datetime_talk);
/* unused */ uxn_port(&u, 0xc, nil_talk);
/* unused */ uxn_port(&u, 0xd, nil_talk);
/* unused */ uxn_port(&u, 0xe, nil_talk);
/* unused */ uxn_port(&u, 0xf, nil_talk);
/* set default zoom */
if(SDL_GetCurrentDisplayMode(0, &DM) == 0)
set_zoom(DM.w / 1280);
for(i = 1; i < argc; ++i) {
/* get default zoom from flags */
if(strcmp(argv[i], "-s") == 0) {
if(i < argc - 1)
set_zoom(atoi(argv[++i]));
else
return error("Opt", "-s No scale provided.");
} else if(!loaded++) {
if(!load(&u, argv[i]))
return error("Load", "Failed to open rom.");
if(!init())
return error("Init", "Failed to initialize emulator.");
if(!set_size(WIDTH, HEIGHT, 0))
return error("Window", "Failed to set window size.");
if(!uxn_eval(&u, PAGE_PROGRAM))
return error("Init", "Failed");
} else {
char *p = argv[i];
while(*p) console_input(&u, *p++);
console_input(&u, '\n');
}
}
if(!loaded)
return error("usage", "uxnemu file.rom");
run(&u);
quit();
return 0;
}

153
apps/plugins/varvara/varvara.c Normal file
View File

@ -0,0 +1,153 @@
/* Varvara plugin for rockbox. I have no idea what I'm doing. */
#include "uxn.h"
#include "devices/ppu.h"
#include "plugin.h"
#include <stdio.h>
#include <stdint.h>
#include <time.h>
const uint8_t uxn_rom[] = { /* hello world ROM */
0x20, 0x01, 0x0e, 0x94, 0x80, 0x18, 0x17, 0x21,
0x94, 0x80, 0xf7, 0x0d, 0x22, 0x00, 0x48, 0x65,
0x6c, 0x6c, 0x6f, 0x20, 0x55, 0x78, 0x6e, 0x21,
0x21,
};
static Uxn u;
static Device *devsystem, *devconsole;
static void
memzero8(void *src, uint64_t n)
{
uint8_t * ptr = src;
for (size_t i = 0; i < n; i++) {
ptr[i] = 0;
}
}
/* taken from uxncli */
static void
inspect(Stack *s, char *name)
{
Uint8 x, y;
DEBUGF("\n%s\n", name);
for(y = 0; y < 0x04; ++y) {
for(x = 0; x < 0x08; ++x) {
Uint8 p = y * 0x08 + x;
DEBUGF(p == s->ptr ? "[%02x]" : " %02x ",
s->dat[p]);
}
DEBUGF("\n");
}
}
/* taken from uxncli */
static int
system_talk(Device *d, Uint8 b0, Uint8 w)
{
if(!w) { /* read */
switch(b0) {
case 0x2: d->dat[0x2] = d->u->wst.ptr; break;
case 0x3: d->dat[0x3] = d->u->rst.ptr; break;
}
} else { /* write */
switch(b0) {
case 0x2: d->u->wst.ptr = d->dat[0x2]; break;
case 0x3: d->u->rst.ptr = d->dat[0x3]; break;
case 0xe:
inspect(&d->u->wst, "Working-stack");
inspect(&d->u->rst, "Return-stack");
break;
case 0xf: return 0;
}
}
return 1;
}
/* taken from uxncli */
static int
console_talk(Device *d, Uint8 b0, Uint8 w)
{
if(b0 == 0x1)
d->vector = peek16(d->dat, 0x0);
if(w && b0 > 0x7)
DEBUGF("%c",(char *)&d->dat[b0]);
return 1;
}
static int
nil_talk(Device *d, Uint8 b0, Uint8 w)
{
(void)d;
(void)b0;
(void)w;
return 1;
}
int
uxn_halt(Uxn *u, Uint8 error, char *name, int id)
{
DEBUGF("Halted");
return 0;
}
/* this is the plugin entry point */
enum plugin_status plugin_start(const void* parameter)
{
/* if you don't use the parameter, you can do like
this to avoid the compiler warning about it */
(void)parameter;
/* "rb->" marks a plugin api call. Rockbox offers many of its built-in
* functions to plugins */
/* now go ahead and have fun! */
DEBUGF("UXN init\n");
// Clear RAM and copy rom to VM.
DEBUGF("zeroing\n");
memzero8(&u, sizeof(Uxn));
DEBUGF("copying ROM\n");
memcpy(u.ram.dat + PAGE_PROGRAM, uxn_rom, sizeof(uxn_rom));
DEBUGF("registering ports\n");
// Register ports
/* system */ devsystem = uxn_port(&u, 0x0, system_talk);
/* console */ devconsole = uxn_port(&u, 0x1, console_talk);
/* screen */ uxn_port(&u, 0x2, nil_talk);
/* audio0 */ uxn_port(&u, 0x3, nil_talk);
/* audio1 */ uxn_port(&u, 0x4, nil_talk);
/* audio2 */ uxn_port(&u, 0x5, nil_talk);
/* audio3 */ uxn_port(&u, 0x6, nil_talk);
/* empty */ uxn_port(&u, 0x7, nil_talk);
/* control */ uxn_port(&u, 0x8, nil_talk);
/* mouse */ uxn_port(&u, 0x9, nil_talk);
/* file */ uxn_port(&u, 0xa, nil_talk);
/* datetime */ uxn_port(&u, 0xb, nil_talk);
/* empty */ uxn_port(&u, 0xc, nil_talk);
/* empty */ uxn_port(&u, 0xd, nil_talk);
/* empty */ uxn_port(&u, 0xe, nil_talk);
/* empty */ uxn_port(&u, 0xf, nil_talk);
// Boot
// if(!uxn_boot(&u))
// return -1;
// Run
DEBUGF("eval\n");
uxn_eval(&u, 0x0100);
rb->lcd_clear_display();
// 0x000f: blue, 0x00f0:
//rb->lcd_set_foreground(LCD_RGBPACK(0,0,255));
rb->lcd_fillrect(0,0,10,10);
//rb->lcd_set_foreground(0x00f0);
rb->lcd_fillrect(10,0,10,10);
//rb->lcd_set_foreground(0x0f00);
rb->lcd_fillrect(20,0,10,10);
//rb->lcd_set_foreground(0xf000);
rb->lcd_fillrect(30,0,10,10);
rb->lcd_update();
rb->button_get(true);
return PLUGIN_OK;
}

21
apps/plugins/varvara/varvara.make Normal file
View File

@ -0,0 +1,21 @@
# __________ __ ___.
# Open \______ \ ____ ____ | | _\_ |__ _______ ___
# Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
# Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
# Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
# \/ \/ \/ \/ \/
# $Id$
#
VARVARASRCDIR := $(APPSDIR)/plugins/varvara
VARVARABUILDDIR := $(BUILDDIR)/apps/plugins/varvara
ROCKS += $(VARVARABUILDDIR)/varvara.rock
VARVARA_SRC := $(call preprocess, $(VARVARASRCDIR)/SOURCES)
VARVARA_OBJ := $(call c2obj, $(VARVARA_SRC))
# add source files to OTHER_SRC to get automatic dependencies
OTHER_SRC += $(VARVARA_SRC)
$(VARVARABUILDDIR)/varvara.rock: $(VARVARA_OBJ)