andrew/akbasic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Let a program ask how big the text grid is

Browse Source 
`RGR(1)` and `RGR(2)` gave the window in pixels and nothing gave columns, rows
or the cell size -- so anything placing a character *and* a sprite at the same
spot had to hardcode a number measured by hand against whatever font the host
loaded. The Breakout in examples/ does exactly that, `CW# = 16`, and it is the
one thing in that listing that breaks on a different font or window.

**`RWINDOW` is BASIC 7.0's own answer and had never been implemented here.**
`RWINDOW(0)` is the current text window's rows and `RWINDOW(1)` its columns.
`RWINDOW(2)` reports a C128's 40 or 80 column screen mode, and this interpreter
has neither -- refused by name, because answering 0 would be a plausible lie,
which is worse than a refusal that says why.

The cell size in pixels is `RGR(3)` and `RGR(4)`, beside the surface's own
dimensions rather than on `RWINDOW`. Two reasons: a cell size is a fact about
the surface, and `RWINDOW` reports the *window*, so dividing `RGR(1)` by a
column count stops being right the moment a program calls `WINDOW`.

Both read a new optional `grid` entry point on `akbasic_TextSink` -- columns,
rows, cell width, cell height -- implemented by the akgl sink and forwarded by
the tee, in the shape `moveto` and `window` already had. NULL everywhere else,
so both verbs refuse by name against a sink with no grid. `akbasic_sink_init_
stdio()` clears it for the same reason it now clears the other two.

Measured on the standalone build: `RGR(3)` answers 16 and `RWINDOW` answers 50
columns by 37 rows -- the three numbers the Breakout listing had written out as
constants -- and `RWINDOW` follows a `WINDOW` call while `RGR(3)` does not.

tests/console_verbs.c drives the answers through a stand-in sink with a grid,
since the harness sink is stdio and has none; tests/graphics_verbs.c covers the
new `RGR` fields, their refusal, and the moved range bound. The `c excerpt=`
block in docs/10-embedding.md moves with the header, which is `docs_examples`
doing its job.

TODO.md section 6 item 31's second half, struck.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Andrew Kesterson
2026-08-02 00:05:17 -04:00
parent fd1f0d7c19
commit 694b446ce4
15 changed files with 361 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
src/runtime_console.c
View File

@@ -187,6 +187,65 @@ akerr_ErrorContext *akbasic_cmd_window(akbasic_Runtime *obj, akbasic_ASTLeaf *ex
SUCCEED_RETURN(errctx);
}
/* --------------------------------------------------------------- RWINDOW -- */
/**
* @brief How big the current text window is, in characters.
*
* BASIC 7.0's own answer to the question, and it had never been implemented
* here: `RWINDOW(0)` is the number of lines and `RWINDOW(1)` the number of
* columns. Without it a program had no way to find out, so anything placing a
* character *and* a sprite at the same spot had to hardcode a cell size measured
* against whatever font the host loaded. The Breakout in `examples/` did exactly
* that, and it was the one thing in that listing that broke on a different
* window. TODO.md section 6 item 31.
*
* **`RWINDOW(2)` is refused by name.** On a C128 it answers 0 for 40-column mode
* and 1 for 80-column, and this interpreter has no such mode -- the grid is
* whatever the window divided by the font gives. Answering 0 would be a
* plausible lie, which is worse than a refusal that says why.
*
* The cell size in pixels is `RGR(3)` and `RGR(4)` rather than a field here: it
* is a question about the drawing surface, and it belongs beside the surface's
* own dimensions.
*/
akerr_ErrorContext *akbasic_fn_rwindow(akbasic_Runtime *obj, akbasic_ASTLeaf *expr, akbasic_Value *lval, akbasic_Value *rval, akbasic_Value **dest)
{
PREPARE_ERROR(errctx);
akbasic_Value *out = NULL;
double args[1];
int count = 0;
int field = 0;
int columns = 0;
int rows = 0;
int cellw = 0;
int cellh = 0;
(void)lval; (void)rval;
FAIL_ZERO_RETURN(errctx, (obj != NULL && dest != NULL), AKERR_NULLPOINTER,
"NULL argument in RWINDOW");
PASS(errctx, akbasic_args_numbers(obj, expr, "RWINDOW", args, 1, &count));
FAIL_ZERO_RETURN(errctx, (count >= 1), AKBASIC_ERR_SYNTAX, "RWINDOW expected a field number");
field = (int)args[0];
FAIL_NONZERO_RETURN(errctx, (field == 2), AKBASIC_ERR_DEVICE,
"RWINDOW(2) reports a C128's 40 or 80 column mode, and this interpreter has neither");
FAIL_ZERO_RETURN(errctx, (field == 0 || field == 1), AKBASIC_ERR_BOUNDS,
"RWINDOW: field %d is outside 0..1", field);
FAIL_ZERO_RETURN(errctx, (obj->sink != NULL), AKBASIC_ERR_DEVICE,
"RWINDOW needs a text device and this runtime has none");
FAIL_ZERO_RETURN(errctx, (obj->sink->grid != NULL), AKBASIC_ERR_DEVICE,
"RWINDOW needs a text device with a character grid, and this one has none");
PASS(errctx, obj->sink->grid(obj->sink, &columns, &rows, &cellw, &cellh));
PASS(errctx, akbasic_environment_new_value(obj->environment, &out));
PASS(errctx, akbasic_value_zero(out));
out->valuetype = AKBASIC_TYPE_INTEGER;
out->intval = (field == 0 ? (int64_t)rows : (int64_t)columns);
*dest = out;
SUCCEED_RETURN(errctx);
}
/* ---------------------------------------------------------------- service -- */
akerr_ErrorContext *akbasic_console_state_init(akbasic_ConsoleState *obj)

32
src/runtime_graphics.c
View File

@@ -291,6 +291,10 @@ akerr_ErrorContext *akbasic_fn_rgr(akbasic_Runtime *obj, akbasic_ASTLeaf *expr,
double args[1];
int count = 0;
int field = 0;
int columns = 0;
int rows = 0;
int cellw = 0;
int cellh = 0;
int64_t answer = 0;
(void)lval; (void)rval;
@@ -312,6 +316,9 @@ akerr_ErrorContext *akbasic_fn_rgr(akbasic_Runtime *obj, akbasic_ASTLeaf *expr,
* is no device -- asking how big the screen is when there is no screen is a
* program bug worth reporting -- and the refresh that makes the answer
* current rather than whatever it was at attach.
*
* Fields 3 and 4 are ours too, and come from the text sink rather than the
* graphics device; see the comment on them below.
*/
switch ( field ) {
case 0:
@@ -325,8 +332,31 @@ akerr_ErrorContext *akbasic_fn_rgr(akbasic_Runtime *obj, akbasic_ASTLeaf *expr,
PASS(errctx, require_graphics(obj, "RGR"));
answer = (int64_t)obj->gfx.devheight;
break;
/*
* Fields 3 and 4 are the character cell, in the same pixels fields 1 and 2
* are in -- so a program can place a character and a sprite at the same spot
* without hardcoding a size measured against the host's font. They come from
* the *sink*, which is where a grid lives, and the grid is a text device's
* property rather than a graphics one: hence a separate refusal, naming the
* text device rather than the graphics one.
*
* `RWINDOW` answers the other half -- how many columns and rows there are --
* and it is the C128's own function for that question. This is here rather
* than on RWINDOW because a cell size is a fact about the surface, and
* because RWINDOW reports the current *window*, which makes dividing the
* surface by the column count wrong the moment a program calls `WINDOW`.
*/
case 3:
case 4:
FAIL_ZERO_RETURN(errctx, (obj->sink != NULL), AKBASIC_ERR_DEVICE,
"RGR needs a text device and this runtime has none");
FAIL_ZERO_RETURN(errctx, (obj->sink->grid != NULL), AKBASIC_ERR_DEVICE,
"RGR needs a text device with a character grid, and this one has none");
PASS(errctx, obj->sink->grid(obj->sink, &columns, &rows, &cellw, &cellh));
answer = (field == 3 ? (int64_t)cellw : (int64_t)cellh);
break;
default:
FAIL_RETURN(errctx, AKBASIC_ERR_BOUNDS, "RGR: field %d is outside 0..2", field);
FAIL_RETURN(errctx, AKBASIC_ERR_BOUNDS, "RGR: field %d is outside 0..4", field);
}
PASS(errctx, akbasic_environment_new_value(obj->environment, &out));

30
src/sink_akgl.c
View File

@@ -410,6 +410,35 @@ static akerr_ErrorContext *sink_moveto(akbasic_TextSink *self, int col, int row)
* The full-screen geometry is remembered so a later WINDOW can grow back out;
* without it each call could only ever shrink.
*/
/**
* @brief Report the character grid, for RWINDOW and RGR.
*
* The four numbers a program cannot otherwise learn. Columns and rows are the
* *current* window rather than the whole screen, which is what RWINDOW means on
* a C128 and what a program placing text actually needs; the cell size is
* unaffected by windowing, which is what keeps a windowed program's text the
* same size as an unwindowed one's.
*/
static akerr_ErrorContext *sink_grid(akbasic_TextSink *self, int *columns, int *rows, int *cellw, int *cellh)
{
PREPARE_ERROR(errctx);
akbasic_AkglSink *state = NULL;
FAIL_ZERO_RETURN(errctx, (self != NULL), AKERR_NULLPOINTER, "NULL sink in grid");
FAIL_ZERO_RETURN(errctx, (columns != NULL && rows != NULL && cellw != NULL && cellh != NULL),
AKERR_NULLPOINTER, "NULL destination in grid");
state = (akbasic_AkglSink *)self->self;
FAIL_ZERO_RETURN(errctx, (state != NULL), AKERR_NULLPOINTER, "akgl sink has no state");
FAIL_ZERO_RETURN(errctx, (state->cellw > 0 && state->cellh > 0), AKBASIC_ERR_STATE,
"The sink has no character grid to measure");
*columns = state->columns;
*rows = state->rows;
*cellw = state->cellw;
*cellh = state->cellh;
SUCCEED_RETURN(errctx);
}
static akerr_ErrorContext *sink_window(akbasic_TextSink *self, int left, int top, int right, int bottom)
{
PREPARE_ERROR(errctx);
@@ -517,6 +546,7 @@ akerr_ErrorContext *akbasic_sink_init_akgl(akbasic_TextSink *obj, akbasic_AkglSi
obj->clear = sink_clear;
obj->moveto = sink_moveto;
obj->window = sink_window;
obj->grid = sink_grid;
SUCCEED_RETURN(errctx);
}

1
src/sink_stdio.c
View File

@@ -108,5 +108,6 @@ akerr_ErrorContext *akbasic_sink_init_stdio(akbasic_TextSink *obj, akbasic_Stdio
*/
obj->moveto = NULL;
obj->window = NULL;
obj->grid = NULL;
SUCCEED_RETURN(errctx);
}

30
src/sink_tee.c
View File

@@ -143,6 +143,30 @@ static akerr_ErrorContext *tee_window(akbasic_TextSink *self, int left, int top,
SUCCEED_RETURN(errctx);
}
/**
* @brief Report the grid of whichever half has one.
*
* The first half that answers wins rather than both being consulted, because
* there is one grid and only one half can have it -- the same reasoning
* tee_moveto() gives about there being one cursor.
*/
static akerr_ErrorContext *tee_grid(akbasic_TextSink *self, int *columns, int *rows, int *cellw, int *cellh)
{
PREPARE_ERROR(errctx);
akbasic_TeeSink *state = NULL;
PASS(errctx, tee_state(self, &state));
if ( state->primary != NULL && state->primary->grid != NULL ) {
PASS(errctx, state->primary->grid(state->primary, columns, rows, cellw, cellh));
SUCCEED_RETURN(errctx);
}
if ( state->mirror != NULL && state->mirror->grid != NULL ) {
PASS(errctx, state->mirror->grid(state->mirror, columns, rows, cellw, cellh));
SUCCEED_RETURN(errctx);
}
FAIL_RETURN(errctx, AKBASIC_ERR_STATE, "neither half of this tee has a character grid");
}
akerr_ErrorContext *akbasic_sink_init_tee(akbasic_TextSink *obj, akbasic_TeeSink *state, akbasic_TextSink *primary, akbasic_TextSink *mirror, akbasic_TextSink *reader)
{
PREPARE_ERROR(errctx);
@@ -177,6 +201,7 @@ akerr_ErrorContext *akbasic_sink_init_tee(akbasic_TextSink *obj, akbasic_TeeSink
*/
obj->moveto = NULL;
obj->window = NULL;
obj->grid = NULL;
/*
* Offered only when a half can actually do it, so CHAR's refusal against a
* stdio-only driver still reads correctly through a tee.
@@ -191,5 +216,10 @@ akerr_ErrorContext *akbasic_sink_init_tee(akbasic_TextSink *obj, akbasic_TeeSink
(mirror != NULL && mirror->window != NULL) ) {
obj->window = tee_window;
}
/* And for the grid RWINDOW and RGR read. */
if ( (primary != NULL && primary->grid != NULL) ||
(mirror != NULL && mirror->grid != NULL) ) {
obj->grid = tee_grid;
}
SUCCEED_RETURN(errctx);
}

1
src/verbs.c
View File

@@ -143,6 +143,7 @@ static const akbasic_Verb VERBS[] = {
{ "RSPPOS", AKBASIC_TOK_FUNCTION, 2, NULL, akbasic_fn_rsppos },
{ "RSPRITE", AKBASIC_TOK_FUNCTION, 2, NULL, akbasic_fn_rsprite },
{ "RUN", AKBASIC_TOK_COMMAND_IMMEDIATE, -1, NULL, akbasic_cmd_run },
{ "RWINDOW", AKBASIC_TOK_FUNCTION, 1, NULL, akbasic_fn_rwindow },
{ "SAVE", AKBASIC_TOK_COMMAND_IMMEDIATE, -1, NULL, akbasic_cmd_dsave },
{ "SCALE", AKBASIC_TOK_COMMAND, -1, akbasic_parse_arglist, akbasic_cmd_scale },
{ "SCNCLR", AKBASIC_TOK_COMMAND, -1, NULL, akbasic_cmd_scnclr },

1
src/verbs.h
View File

@@ -178,6 +178,7 @@ akerr_ErrorContext AKERR_NOIGNORE *akbasic_parse_type(struct akbasic_Parser *par
akerr_ErrorContext AKERR_NOIGNORE *akbasic_cmd_type(struct akbasic_Runtime *obj, akbasic_ASTLeaf *expr, akbasic_Value *lval, akbasic_Value *rval, akbasic_Value **dest);
akerr_ErrorContext AKERR_NOIGNORE *akbasic_fn_rgr(struct akbasic_Runtime *obj, akbasic_ASTLeaf *expr, akbasic_Value *lval, akbasic_Value *rval, akbasic_Value **dest);
akerr_ErrorContext AKERR_NOIGNORE *akbasic_fn_rwindow(struct akbasic_Runtime *obj, akbasic_ASTLeaf *expr, akbasic_Value *lval, akbasic_Value *rval, akbasic_Value **dest);
/* Group I sound verbs -- src/runtime_audio.c */
akerr_ErrorContext AKERR_NOIGNORE *akbasic_cmd_envelope(struct akbasic_Runtime *obj, akbasic_ASTLeaf *expr, akbasic_Value *lval, akbasic_Value *rval, akbasic_Value **dest);