Import Ebitor 0.1.1 upstream source snapshot

Original author: Pierre Sarrazin.
Source: http://sarrazip.com/dev/ebitor-0.1.1.tar.gz
Archive SHA-256: 6911a9d2ee80925622f1d82db1b77710a1f896865e63d29a04dc16489b150e83
This commit is contained in:
Brian Holman committed 2026-11-09 23:45:41 -07:00
commit 53bf6abdd5
19 files changed
+5400

No files matched your search

+939
View File
@@ -0,0 +1,939 @@
/* Ebitor.c
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
This file uses the terms "terminal" and "window" interchangeably.
*/
#include "Ebitor_private.h"
enum
{
MODE_COMMAND,
MODE_INSERTION,
};
Ebitor Ebitor_instance;
void
Ebitor_init(char *bufferBegin, size_t bufferSize,
byte termWidth, byte termHeight,
ebitor_clear clear,
ebitor_locateFunc locate,
ebitor_getCursorPosFunc getCursorPos,
ebitor_printFunc print,
ebitor_printPrefixFunc printPrefix,
ebitor_clrtoeolFunc clrtoeol,
ebitor_scrollTerminalUpFunc scrollTerminalUp,
ebitor_scrollTerminalDownFunc scrollTerminalDown,
ebitor_waitKeyFunc waitKey)
{
Ebitor *self = &Ebitor_instance;
self->termWidth = termWidth;
self->termHeight = termHeight;
self->bufferBegin = bufferBegin;
self->bufferEnd = bufferBegin + bufferSize;
self->bufferFilledSize = 0;
self->cursorOffset = 0;
self->savedCursorCol = 0;
self->savedCursorRow = 0;
self->mode = MODE_COMMAND;
self->insertBuffer.size = 0;
self->clear = clear;
self->locate = locate;
self->getCursorPos = getCursorPos;
self->print = print;
self->printPrefix = printPrefix;
self->clrtoeol = clrtoeol;
self->scrollTerminalUp = scrollTerminalUp;
self->scrollTerminalDown = scrollTerminalDown;
self->waitKey = waitKey;
}
void
Ebitor_shutdown(void)
{
}
Ebitor *
Ebitor_getInstance(void)
{
return &Ebitor_instance;
}
void
Ebitor_setContentLength(size_t newLength)
{
size_t max = Ebitor_instance.bufferEnd - Ebitor_instance.bufferBegin;
Ebitor_instance.bufferFilledSize = min(newLength, max);
Ebitor_setLogicalCursorAtBeginning();
Ebitor_instance.mode = MODE_COMMAND;
Ebitor_instance.insertBuffer.size = 0;
}
size_t
Ebitor_getContentLength(void)
{
return Ebitor_instance.bufferFilledSize;
}
// Move the contents of insert buffer to the cursor position in the edit buffer.
// Insert buffer ends up empty.
// Cursor offset updated to point to after the copied characters.
//
void
Ebitor_flushInsertBuffer(void)
{
Ebitor *self = &Ebitor_instance;
if (self->insertBuffer.size == 0)
return;
// Check if there is room in the edit buffer for the contents of the insert buffer.
//
size_t availRoom = self->bufferEnd - self->bufferBegin - self->bufferFilledSize;
if (self->insertBuffer.size > availRoom)
self->insertBuffer.size = availRoom;
// Create a hole in the edit buffer where to copy the insert buffer.
//
memmove(self->bufferBegin + self->cursorOffset + self->insertBuffer.size,
self->bufferBegin + self->cursorOffset,
self->bufferFilledSize - self->cursorOffset);
memcpy(self->bufferBegin + self->cursorOffset, self->insertBuffer.buffer, self->insertBuffer.size);
self->bufferFilledSize += self->insertBuffer.size;
self->cursorOffset += self->insertBuffer.size;
self->insertBuffer.size = 0;
}
void
Ebitor_startCommandMode(void)
{
Ebitor *self = &Ebitor_instance;
if (self->mode != MODE_COMMAND)
{
Ebitor_flushInsertBuffer();
self->mode = MODE_COMMAND;
}
}
void
Ebitor_insertChar(char c)
{
Ebitor *self = &Ebitor_instance;
if (self->mode == MODE_COMMAND)
{
// Go to insertion mode.
self->mode = MODE_INSERTION;
self->insertBuffer.buffer[0] = c;
self->insertBuffer.size = 1;
}
else // already in insertion mode
{
self->insertBuffer.buffer[self->insertBuffer.size++] = c;
if (self->insertBuffer.size == INSERT_BUFFER_SIZE) // if full
{
Ebitor_flushInsertBuffer();
assert(self->insertBuffer.size == 0);
}
}
}
// If no \r is found, returns the end of the filled part of the edit buffer.
//
size_t
Ebitor_findEOL(size_t startOffset)
{
const Ebitor *self = &Ebitor_instance;
char *p = (char *) memchr(self->bufferBegin + startOffset, '\r', self->bufferFilledSize - startOffset);
return p ? p - self->bufferBegin : self->bufferFilledSize;
}
size_t
Ebitor_findSOL(size_t startOffset)
{
const Ebitor *self = &Ebitor_instance;
char *p = self->bufferBegin + startOffset;
while (p > self->bufferBegin) // while possible to go back
{
--p;
if (*p == '\r')
return p + 1 - self->bufferBegin;
}
return p - self->bufferBegin;
}
size_t
Ebitor_findPreviousSOL(size_t solOffset)
{
const Ebitor *self = &Ebitor_instance;
if (solOffset == 0)
return solOffset;
assert(self->bufferBegin[solOffset - 1] == '\r');
return Ebitor_findSOL(solOffset - 1);
}
void
Ebitor_fillTerminalToBottom(size_t firstLogicalCharOffsetToPrint, byte firstRowToFill)
{
const Ebitor *self = &Ebitor_instance;
//printf("(%u,%u;%u)", firstLogicalCharOffsetToPrint, firstRowToFill, self->bufferFilledSize);
assert(firstLogicalCharOffsetToPrint <= self->bufferFilledSize);
if (firstRowToFill >= self->termHeight)
return; // failsafe -- nothing to do
self->locate(0, firstRowToFill);
if (firstLogicalCharOffsetToPrint == self->bufferFilledSize) // if nothing to print
{
self->clrtoeol(); // erase a line that may have been merged up
return;
}
// Reprint the rest of the window, while preserving the cursor position.
// The portion to print starts at self->cursorOffset and ends either at
// the end of the filled edit buffer, or at the bottom of the window.
//
const char *begin = self->bufferBegin + firstLogicalCharOffsetToPrint;
const char *end = self->bufferBegin + self->bufferFilledSize;
byte c = 0, r = firstRowToFill;
const char *p = begin;
for ( ; r < self->termHeight && p < end; ++p)
{
if (*p == '\r')
{
c = 0;
++r;
}
else // printable char
{
++c;
if (c == self->termWidth)
{
c = 0;
++r;
}
}
}
// p points to the first char NOT to be printed.
self->printPrefix(begin, p - begin);
if (r < self->termHeight)
self->clrtoeol();
if (r < self->termHeight - 1)
{
self->locate(0, r + 1);
self->clrtoeol();
}
}
void
Ebitor_fillWindowFromHomeToRow(size_t firstLogicalCharOffsetToPrint, byte numRowsToFill)
{
Ebitor *self = &Ebitor_instance;
if (numRowsToFill == 0)
return;
self->locate(0, 0);
size_t offset = firstLogicalCharOffsetToPrint;
for (;;)
{
size_t eolOffset = Ebitor_findEOL(offset);
while (eolOffset - offset >= self->termWidth) // if current row to be filled completely
{
self->printPrefix(self->bufferBegin + offset, self->termWidth);
if (--numRowsToFill == 0)
return;
offset += self->termWidth;
}
if (offset != eolOffset)
self->printPrefix(self->bufferBegin + offset, eolOffset - offset);
self->print("\r");
if (--numRowsToFill == 0)
return;
if (eolOffset == self->bufferFilledSize) // if EOF instead of \r
break; // go blank remaining rows to fill
offset = eolOffset + 1; // pass \r
}
for ( ; numRowsToFill--; )
self->print("\r");
}
void
Ebitor_setLogicalCursorAtBeginning(void)
{
Ebitor_instance.cursorOffset = 0;
Ebitor_instance.savedCursorCol = 0;
Ebitor_instance.savedCursorRow = 0;
}
size_t
Ebitor_getLogicalCursorOffset(void)
{
return Ebitor_instance.cursorOffset;
}
static void
Ebitor_refresh(byte cursorCol, byte cursorRow)
{
Ebitor_instance.clear();
// Reprint the window starting at the logical offset that corresponds to
// the top-left corner of the terminal.
//
size_t homeOffset = Ebitor_getLogicalOffsetAtHome(cursorCol, cursorRow);
Ebitor_fillTerminalToBottom(homeOffset, 0);
}
static void
Ebitor_processLeftArrow(byte cursorCol, byte cursorRow)
{
assert(Ebitor_instance.mode == MODE_COMMAND);
if (Ebitor_instance.cursorOffset == 0) // if already at start of edit buffer
return; // nothing to do
if (cursorCol > 0) // if not at leftmost window column
{
Ebitor_instance.locate(cursorCol - 1, cursorRow);
}
else
{
// Cursor at leftmost window column.
// If at start of logical line, go to end of previous logical line.
// Otherwise, scroll up if needed, then go to rightmost window column
// on previous window row.
//
size_t solOffset = Ebitor_findSOL(Ebitor_instance.cursorOffset);
if (solOffset == Ebitor_instance.cursorOffset) // if at start of logical line
{
size_t prevSOLOffset = Ebitor_findPreviousSOL(Ebitor_instance.cursorOffset);
assert(prevSOLOffset != Ebitor_instance.cursorOffset); // previous line found, because cursorOffset not 0
size_t prevLineLen = solOffset - prevSOLOffset - 1; // minus one to exclude \r
byte lastRowLen = (byte) (prevLineLen % Ebitor_instance.termWidth); // e.g., if 37-char logical line on 32-column terminal, then 5
if (cursorRow == 0)
{
// At top row of window. There is a line before the current one, b/c cursorOffset > 0.
// Scroll the window down one row.
// Print the last 'lastRowLen' chars of that line. Leave the cursor after these.
size_t offsetToPrint = Ebitor_instance.cursorOffset - 1 - lastRowLen;
Ebitor_instance.scrollTerminalDown(1);
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + offsetToPrint, lastRowLen);
}
else
--cursorRow;
Ebitor_instance.locate(lastRowLen, cursorRow);
}
else // not at start of logical line
{
// Current logical line starts before cursorOffset.
if (cursorRow == 0)
{
// Cursor is home. Print full window row of chars from current logical line.
Ebitor_instance.scrollTerminalDown(1);
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + (Ebitor_instance.cursorOffset - Ebitor_instance.termWidth), Ebitor_instance.termWidth);
}
else
--cursorRow;
Ebitor_instance.locate(Ebitor_instance.termWidth - 1, cursorRow);
}
}
--Ebitor_instance.cursorOffset;
}
static void
Ebitor_processRightArrow(byte cursorCol, byte cursorRow)
{
assert(Ebitor_instance.mode == MODE_COMMAND);
if (Ebitor_instance.cursorOffset == Ebitor_instance.bufferFilledSize) // if already at EOF
return; // nothing to do
size_t eolOffset = Ebitor_findEOL(Ebitor_instance.cursorOffset);
if (Ebitor_instance.cursorOffset == eolOffset // if at end of logical line
|| cursorCol + 1 == Ebitor_instance.termWidth) // or if at rightmost window column
{
if (cursorRow == Ebitor_instance.termHeight - 1) // if starting on last window row
{
Ebitor_instance.scrollTerminalUp(1);
Ebitor_instance.locate(0, cursorRow);
// If the move still leaves the logical cursor in the current logical line,
// then print then the next row of the current logical line.
// Otherwise, print the first row of the next logical line.
//
if (Ebitor_instance.cursorOffset < eolOffset)
{
size_t nextCharOffset = Ebitor_instance.cursorOffset + 1;
size_t lineLenFromNextChar = eolOffset - nextCharOffset;
byte toPrint = (byte) min(lineLenFromNextChar, (size_t) Ebitor_instance.termWidth);
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + nextCharOffset, toPrint);
}
else
{
size_t nextLineOffset = eolOffset + 1; // after the \r
size_t nextLineLen = Ebitor_findEOL(nextLineOffset) - nextLineOffset;
byte charsOnFirstRow = (byte) min(nextLineLen, (size_t) Ebitor_instance.termWidth);
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + nextLineOffset, charsOnFirstRow);
}
}
else
++cursorRow;
cursorCol = 0;
}
else
++cursorCol; // move cursor right
assert(cursorRow < Ebitor_instance.termHeight);
Ebitor_instance.locate(cursorCol, cursorRow);
++Ebitor_instance.cursorOffset;
assert(Ebitor_instance.cursorOffset <= Ebitor_instance.bufferFilledSize);
}
// May change *cursorCol and *cursorRow.
// Does not change any fields of Ebitor_instance.
//
static void
Ebitor_scrollDownAndPrintRow(byte *cursorRow, size_t newOffsetToPrintFrom, size_t numCharsToPrint, BOOL affectTerminal)
{
if (*cursorRow == 0) // if cursor is on top row of terminal
{
Ebitor_instance.scrollTerminalDown(1); // scroll terminal down to free top row
if (affectTerminal)
{
// Print the previous logical line on the top terminal row,
// or a portion of that line if it is longer than a terminal row.
//
Ebitor_instance.locate(0, *cursorRow);
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + newOffsetToPrintFrom, numCharsToPrint);
}
}
else
{
assert(*cursorRow > 0);
--*cursorRow;
}
}
static void
Ebitor_processUpArrow(byte cursorCol, byte cursorRow, BOOL affectTerminal)
{
assert(Ebitor_instance.mode == MODE_COMMAND);
// Do nothing if already on 1st logical line.
//
size_t solOffset = Ebitor_findSOL(Ebitor_instance.cursorOffset);
// If the current logical line starts before the cursor row, go up in that logical line.
//
size_t newCursorOffset;
if (Ebitor_instance.cursorOffset - solOffset >= Ebitor_instance.termWidth)
{
// Current logical line starts before cursor row.
// Place cursor earlier in current logical line.
//
newCursorOffset = Ebitor_instance.cursorOffset - Ebitor_instance.termWidth;
Ebitor_scrollDownAndPrintRow(&cursorRow, newCursorOffset, Ebitor_instance.termWidth, affectTerminal);
}
else
{
// Cursor is on first window row of current logical line.
// Place cursor on last window row of preceding logical line, if any.
//
if (solOffset == 0)
return;
size_t prevSOLOffset = Ebitor_findPreviousSOL(solOffset);
assert(prevSOLOffset < solOffset);
size_t prevLineLen = solOffset - prevSOLOffset - 1; // exclude \r
byte charsOnLastRow = (byte) (prevLineLen % Ebitor_instance.termWidth); // after last char of previous line
size_t offsetOfLastRowOfPrevLine = solOffset - 1 - charsOnLastRow;
Ebitor_scrollDownAndPrintRow(&cursorRow, offsetOfLastRowOfPrevLine, charsOnLastRow, affectTerminal);
if (charsOnLastRow < cursorCol) // avoid putting cursor in empty space
cursorCol = charsOnLastRow;
newCursorOffset = offsetOfLastRowOfPrevLine + cursorCol;
}
Ebitor_instance.cursorOffset = newCursorOffset; // move the logical cursor
Ebitor_instance.locate(cursorCol, cursorRow);
}
// May change *cursorCol and *cursorRow.
// Does not change any fields of Ebitor_instance.
//
static void
Ebitor_scrollUpAndPrintRow(byte *cursorCol, byte *cursorRow, size_t newOffsetToPrintFrom, byte numCharsToPrint, BOOL affectTerminal)
{
if (*cursorRow == Ebitor_instance.termHeight - 1) // scroll if cursor on last window row
{
if (affectTerminal)
{
Ebitor_instance.scrollTerminalUp(1);
Ebitor_instance.locate(0, *cursorRow);
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + newOffsetToPrintFrom, numCharsToPrint);
}
}
else
++*cursorRow;
assert(*cursorRow < Ebitor_instance.termHeight);
if (*cursorCol > numCharsToPrint) // avoid putting cursor in empty space
*cursorCol = numCharsToPrint;
}
static void
Ebitor_processDownArrow(byte cursorCol, byte cursorRow, BOOL affectTerminal)
{
assert(Ebitor_instance.mode == MODE_COMMAND);
size_t eolOffset = Ebitor_findEOL(Ebitor_instance.cursorOffset);
// If the current logical line has characters beyond the current cursor row,
// move down this logical line.
//
size_t newCursorOffset;
if (cursorCol + (eolOffset - Ebitor_instance.cursorOffset) >= Ebitor_instance.termWidth)
{
const size_t newOffsetToPrintFrom = Ebitor_instance.cursorOffset - cursorCol + Ebitor_instance.termWidth;
const byte charsOnNewRow = (byte) min(eolOffset - newOffsetToPrintFrom, (size_t) Ebitor_instance.termWidth);
Ebitor_scrollUpAndPrintRow(&cursorCol, &cursorRow, newOffsetToPrintFrom, charsOnNewRow, affectTerminal);
newCursorOffset = min(Ebitor_instance.cursorOffset + Ebitor_instance.termWidth, eolOffset);
}
else if (eolOffset < Ebitor_instance.bufferFilledSize) // logical line ends on current window row, so if it has a \r:
{
assert(Ebitor_instance.bufferBegin[eolOffset] == '\r');
const size_t newOffsetToPrintFrom = eolOffset + 1; // after the \r
assert(newOffsetToPrintFrom <= Ebitor_instance.bufferFilledSize);
const size_t nextLineLen = Ebitor_findEOL(newOffsetToPrintFrom) - newOffsetToPrintFrom;
const byte charsOnNewRow = (byte) min(nextLineLen, (size_t) Ebitor_instance.termWidth);
Ebitor_scrollUpAndPrintRow(&cursorCol, &cursorRow, newOffsetToPrintFrom, charsOnNewRow, affectTerminal);
newCursorOffset = newOffsetToPrintFrom + cursorCol; // move the logical cursor
}
else
return;
Ebitor_instance.cursorOffset = newCursorOffset;
if (affectTerminal)
Ebitor_instance.locate(cursorCol, cursorRow);
}
void
Ebitor_processUpOrDownArrowsAndRefresh(BOOL isUpArrow, size_t numRepetitions)
{
Ebitor_locateCursorAtSavedPosition();
byte cursorCol, cursorRow;
Ebitor_instance.getCursorPos(&cursorCol, &cursorRow);
Ebitor_startCommandMode();
// Point to the right arrow processing function, depending on isUpArrow.
void (*processArrow)(byte cursorCol, byte cursorRow, BOOL affectTerminal) = isUpArrow ? Ebitor_processUpArrow : Ebitor_processDownArrow;
for ( ; numRepetitions--; )
(*processArrow)(cursorCol, cursorRow, FALSE); // do not affect terminal
Ebitor_scrollToShowLogicalOffset(Ebitor_instance.cursorOffset, 0);
Ebitor_saveCursorPosition();
Ebitor_refresh(Ebitor_instance.savedCursorCol, Ebitor_instance.savedCursorRow);
}
// key: Value returned by a function of type ebitor_waitKeyFunc.
//
void
Ebitor_processKey(word key)
{
byte cursorCol, cursorRow;
Ebitor_instance.getCursorPos(&cursorCol, &cursorRow);
switch (key)
{
case '\b': // erase previous char
Ebitor_processBackspace(cursorCol, cursorRow);
break;
case '\r':
{
Ebitor_instance.clrtoeol();
if (cursorRow < Ebitor_instance.termHeight - 1) // if not on last window row
++cursorRow;
else // on last window row
Ebitor_instance.scrollTerminalUp(1);
Ebitor_fillTerminalToBottom(Ebitor_instance.cursorOffset, cursorRow);
Ebitor_instance.locate(0, cursorRow);
Ebitor_insertChar('\r');
}
break;
case ebitor_KEY_ARROW_LEFT:
// Go to command mode if not already in it.
// This flushes the insert buffer, if any.
//
Ebitor_startCommandMode();
Ebitor_processLeftArrow(cursorCol, cursorRow);
break;
case ebitor_KEY_ARROW_RIGHT:
Ebitor_startCommandMode();
Ebitor_processRightArrow(cursorCol, cursorRow);
break;
case ebitor_KEY_ARROW_UP:
Ebitor_startCommandMode();
Ebitor_processUpArrow(cursorCol, cursorRow, TRUE);
break;
case ebitor_KEY_ARROW_DOWN:
Ebitor_startCommandMode();
Ebitor_processDownArrow(cursorCol, cursorRow, TRUE);
break;
default:
Ebitor_processPrintableChar(key, cursorCol, cursorRow);
}
}
void
Ebitor_locateCursorAtSavedPosition(void)
{
Ebitor_instance.locate(Ebitor_instance.savedCursorCol, Ebitor_instance.savedCursorRow);
}
void
Ebitor_saveCursorPosition(void)
{
Ebitor_instance.getCursorPos(&Ebitor_instance.savedCursorCol, &Ebitor_instance.savedCursorRow);
}
void
Ebitor_processEditing(BOOL startWithRefresh)
{
if (startWithRefresh)
Ebitor_refresh(Ebitor_instance.savedCursorCol, Ebitor_instance.savedCursorRow);
Ebitor_locateCursorAtSavedPosition();
for (;;)
{
assert(Ebitor_instance.cursorOffset <= Ebitor_instance.bufferFilledSize);
word key = Ebitor_instance.waitKey();
if (key == ebitor_KEY_ESCAPE)
break;
Ebitor_processKey(key);
}
Ebitor_startCommandMode(); // put inserted chars in edit buffer
// Remember the cursor position for the next time this method is called.
//
Ebitor_saveCursorPosition();
}
// Determines which logical offset is currently at position (0, 0) on the terminal,
// assuming that the current logical cursor is at terminal position (cursorCol, cursorRow).
//
size_t
Ebitor_getLogicalOffsetAtHome(byte cursorCol, byte cursorRow)
{
Ebitor *self = &Ebitor_instance;
Ebitor_startCommandMode(); // put insert buffer into edit buffer, so that all the text is contiguous
assert(self->cursorOffset >= cursorCol);
size_t offset = self->cursorOffset - cursorCol; // initialize at start of terminal row
//printf("[gLOAH(%u,%u):co=%u,o=%u]", cursorCol, cursorRow, self->cursorOffset, offset);
for (;;) // bring 'offset' back to the logical offset that is at (0, 0) on the terminal
{
//printf("(cr=%u,o=%u)", cursorRow, offset);
if (cursorRow == 0)
return offset;
if (offset == 0)
return 0;
//printf("(CHAR %u)", self->bufferBegin[offset - 1]);
if (self->bufferBegin[offset - 1] != '\r')
{
offset -= self->termWidth; // go back to start of terminal row
--cursorRow;
}
else // if offset is at the start of a logical line
{
//printf("(FOR)");
for (;;)
{
size_t startOfLogicalLine = Ebitor_findSOL(offset - 1); // start of previous line
size_t logicalLineLen = offset - 1 - startOfLogicalLine;
//printf("(soll=%u,lll=%u)", startOfLogicalLine, logicalLineLen);
offset -= 1 + logicalLineLen % self->termWidth; // go back to \r, then back to start of row
--cursorRow;
for (;;)
{
if (cursorRow == 0)
return offset;
if (offset == startOfLogicalLine)
break; // reached start of logical line
// In the current logical line, terminal location (0, cursorRow) is now preceded by
// a number of logical chars divisible by termWidth.
assert((offset - startOfLogicalLine) % self->termWidth == 0);
offset -= self->termWidth;
--cursorRow;
}
//printf("[cr=%u,o=%u]", cursorRow, offset);
assert(cursorRow > 0);
if (offset == 0)
return 0;
//printf("[%u]", self->bufferBegin[offset - 1]);
assert(self->bufferBegin[offset - 1] == '\r');
}
}
}
}
void
Ebitor_getLogicalOffsetBelowWindow(size_t homeOffset, size_t *resultOffset, BOOL *isInWindow)
{
Ebitor *self = &Ebitor_instance;
byte termRow = 0;
size_t offset = homeOffset;
byte numEditorLines = self->termHeight;
for (;;)
{
const size_t eolOffset = Ebitor_findEOL(offset);
while (eolOffset - offset >= self->termWidth)
{
offset += self->termWidth;
++termRow;
if (termRow >= numEditorLines) // if off window
{
*resultOffset = offset;
*isInWindow = FALSE;
return;
}
}
if (eolOffset == self->bufferFilledSize)
{
*resultOffset = eolOffset;
*isInWindow = TRUE;
return;
}
assert(self->bufferBegin[eolOffset] == '\r');
offset = eolOffset + 1; // pass '\r', which goes to next row
++termRow;
if (termRow >= numEditorLines) // if off window
{
*resultOffset = offset;
*isInWindow = FALSE;
return;
}
}
}
char
Ebitor_isRegionVisible(size_t regionOffset, size_t regionLength, byte cursorCol, byte cursorRow,
size_t *homeOffset, size_t *firstOffWindowOffset)
{
Ebitor *self = &Ebitor_instance;
//printf("[iRV(%u,%u,%u,%u): BFS=%u]",
// regionOffset, regionLength, cursorCol, cursorRow, self->bufferFilledSize);
assert(regionOffset + regionLength <= self->bufferFilledSize);
assert(self->insertBuffer.size == 0);
*homeOffset = Ebitor_getLogicalOffsetAtHome(cursorCol, cursorRow);
if (regionOffset < *homeOffset) // if region is entirely or partly before the text that starts at home
return -1; // region is (entirely or partly) before displayed text
// Get the offset of the first character that is below the bottom of the terminal.
//
BOOL isInWindow;
Ebitor_getLogicalOffsetBelowWindow(*homeOffset, firstOffWindowOffset, &isInWindow);
if (!isInWindow && regionOffset + regionLength > *firstOffWindowOffset)
return +1; // region is (entirely or partly) after displayed text
return 0; // region is entirely in the displayed text
}
size_t
Ebitor_countRowsToScrollDown(size_t logicalOffsetToShow, size_t homeOffset,
size_t *logicalOffsetAtStartOfTermRow)
{
// Count the number of terminal rows from logicalOffsetToShow to homeOffset.
// This is how many rows we need to scroll the terminal down.
//
assert(logicalOffsetToShow < homeOffset);
Ebitor *self = &Ebitor_instance;
size_t solOffset = Ebitor_findSOL(logicalOffsetToShow);
// Bring logicalOffsetToShow back to the preceding logical position that is displayed
// at the start of a window row.
// We have: logicalOffsetToShow == solOffset + R * termWidth + C, where R >= 0 and C < termWidth.
// We replace logicalOffsetToShow with solOffset + R * termWidth.
// Example: A line has 67 chars and the terminal width is 32
// We have logicalOffsetToShow - solOffset == 67.
// 67 % 32 == 3, so we bring logicalOffsetToShow to 64.
//
*logicalOffsetAtStartOfTermRow = logicalOffsetToShow - (logicalOffsetToShow - solOffset) % self->termWidth;
size_t numTermRows = 0;
size_t offset = *logicalOffsetAtStartOfTermRow;
for (;;)
{
const size_t eolOffset = Ebitor_findEOL(offset);
while (eolOffset - offset >= self->termWidth)
{
offset += self->termWidth;
++numTermRows;
if (offset == homeOffset)
return numTermRows;
}
offset = eolOffset + 1; // pass \r
++numTermRows;
if (offset == homeOffset)
return numTermRows;
}
}
size_t
Ebitor_countRowsToScrollUp(size_t logicalOffsetToShow, size_t firstOffWindowOffset)
{
Ebitor *self = &Ebitor_instance;
assert(firstOffWindowOffset <= logicalOffsetToShow);
assert((firstOffWindowOffset - Ebitor_findSOL(firstOffWindowOffset)) % self->termWidth == 0);
size_t numTermRows = 1;
size_t offset = firstOffWindowOffset;
for (;;)
{
assert((offset - Ebitor_findSOL(offset)) % self->termWidth == 0);
if (offset == logicalOffsetToShow) // if target reached
return numTermRows;
const size_t eolOffset = Ebitor_findEOL(offset);
while (eolOffset - offset >= self->termWidth) // as long as term row at 'offset' is filled
{
if (logicalOffsetToShow - offset < self->termWidth)
return numTermRows; // logicalOffsetToShow is on current row
++numTermRows; // logicalOffsetToShow is on next row or later
offset += self->termWidth;
}
// Term row at 'offset' is not filled completely, so the current logical line ends on this row.
//
if (logicalOffsetToShow <= eolOffset) // if target logical position is on current row
return numTermRows;
offset = eolOffset;
if (offset == self->bufferFilledSize) // if EOF
return numTermRows; // can't scroll more than this
++offset; // pass the \r; now at position that would be at start of window row
++numTermRows;
}
}
void
Ebitor_locateAndSavePos(byte col, byte row)
{
Ebitor_instance.locate(col, row);
Ebitor_instance.savedCursorCol = col;
Ebitor_instance.savedCursorRow = row;
}
// startOfRowOffset: Logical offset of a character that is in column 0.
// Returns the logical offset of another character down the text that is also in column 0.
// If there are not enough rows, stops at the last row.
//
size_t
Ebitor_goDownRows(size_t startOfRowOffset, size_t numRows)
{
size_t offset = startOfRowOffset;
for (;;)
{
size_t eolOffset = Ebitor_findEOL(offset);
while (eolOffset - offset >= Ebitor_instance.termWidth) // while terminal row filled
{
offset += Ebitor_instance.termWidth;
if (--numRows == 0)
return offset;
}
// EOL is on current row.
if (eolOffset == Ebitor_instance.bufferFilledSize) // if EOL is EOF
return offset;
offset = eolOffset + 1; // pass \r
// 'offset' is now at start of next logical line, which is displayed at column 0.
if (--numRows == 0)
return offset;
}
}
+285
View File
@@ -0,0 +1,285 @@
/* Ebitor.h
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _H_Ebitor
#define _H_Ebitor
#ifdef _CMOC_VERSION_ /* If compiling with CMOC. */
#include <coco.h>
#else /* To compile with GCC (useful to get more warnings). */
#include <stdint.h>
#include <string.h>
#include <stdio.h>
typedef uint8_t byte;
typedef uint16_t word;
typedef uint8_t BOOL;
enum { FALSE, TRUE };
void *memichr(const void *s, int c, size_t n);
int memicmp(const void *s1, const void *s2, size_t n);
#endif
// Control codes, >= 256.
// Characters in 32..126 and 128..255 are assumed to be printable.
//
enum
{
ebitor_KEY_ARROW_LEFT = 256,
ebitor_KEY_ARROW_RIGHT,
ebitor_KEY_ARROW_UP,
ebitor_KEY_ARROW_DOWN,
ebitor_KEY_ESCAPE,
};
struct Ebitor;
// Clear the entire terminal.
// Does not move the cursor.
//
typedef void (*ebitor_clear)(void);
// Position the terminal's cursor.
// column, row: Start at 0.
//
typedef void (*ebitor_locateFunc)(byte column, byte row);
// Obtains the current position of the terminal's cursor.
// *column, *row: Will start at 0.
//
typedef void (*ebitor_getCursorPosFunc)(byte *column, byte *row);
// Prints an ASCIIZ to the terminal.
// Character '\r' does a carriage return and line feed AND clears
// the rest of the row it is applied to (with spaces).
// Returns FALSE if the printing reached the end of the terminal.
// In this case, the cursor can be assumed to be at the first
// position of the last row of the window.
//
typedef BOOL (*ebitor_printFunc)(const char *str);
// Prints a given number of characters to the terminal.
// Character '\r' does a carriage return and line feed AND clears
// the rest of the row it is applied to (with spaces).
// No other control code is supported.
// Returns FALSE if the printing reached the end of the terminal.
//
typedef BOOL (*ebitor_printPrefixFunc)(const char *str, size_t prefixLength);
// Clears the current terminal line from the cursor position to the end of the terminal line.
// Does not move the terminal's cursor.
//
typedef void (*ebitor_clrtoeolFunc)(void);
// Moves the contents of the terminal up by the given number of rows.
// Fills the bottom row(s) of the terminal with spaces.
// Does not move the terminal's cursor.
//
typedef void (*ebitor_scrollTerminalUpFunc)(byte numRows);
// Moves the contents of the terminal down by the given number of rows.
// Fills the top row(s) of the terminal with spaces.
// Does not move the terminal's cursor.
//
typedef void (*ebitor_scrollTerminalDownFunc)(byte numRows);
// Blocks while waiting for a key press on the terminal.
// Returns a printable character, or a control character (e.g., '\b', '\r') or
// a control code (see the ebitor_KEY_* enum).
//
typedef word (*ebitor_waitKeyFunc)(void);
enum
{
INSERT_BUFFER_SIZE = 64, // Must be >= 2.
};
typedef struct InsertBuffer
{
char buffer[INSERT_BUFFER_SIZE];
size_t size; // prefix of buffer[] that is filled
} InsertBuffer;
typedef struct Ebitor
{
byte termWidth; // number of columns of the terminal (all the columns used)
byte termHeight; // number of rows of the terminal (all the rows are used)
char *bufferBegin;
char *bufferEnd;
size_t bufferFilledSize; // prefix of [bufferBegin, bufferEnd) that is filled
size_t cursorOffset; // in [bufferBegin, bufferEnd); does not count the chars in insertBuffer
byte savedCursorCol; // cursor column when editing stopped
byte savedCursorRow; // cursor row when editing stopped
byte mode; // MODE_* enum value
InsertBuffer insertBuffer;
// Terminal-specific functions.
ebitor_clear clear;
ebitor_locateFunc locate;
ebitor_printFunc print;
ebitor_printPrefixFunc printPrefix;
ebitor_clrtoeolFunc clrtoeol;
ebitor_scrollTerminalUpFunc scrollTerminalUp;
ebitor_scrollTerminalDownFunc scrollTerminalDown;
ebitor_waitKeyFunc waitKey;
ebitor_getCursorPosFunc getCursorPos;
} Ebitor;
// termWidth: Number of columns of the terminal (all the columns are used).
// termHeight: Number of rows of the terminal (all the rows are used).
// See the comments above concerning the behavior expected of the callbacks.
//
void Ebitor_init(char *bufferBegin, size_t bufferSize,
byte termWidth, byte termHeight,
ebitor_clear clear,
ebitor_locateFunc locate,
ebitor_getCursorPosFunc getCursorPos,
ebitor_printFunc print,
ebitor_printPrefixFunc printPrefix,
ebitor_clrtoeolFunc clrtoeol,
ebitor_scrollTerminalUpFunc scrollTerminalUp,
ebitor_scrollTerminalDownFunc scrollTerminalDown,
ebitor_waitKeyFunc waitKey);
// Return the address of the lone instance of struct Ebitor.
// Should be used only for self-testing code and/or debugging.
//
Ebitor *Ebitor_getInstance(void);
// Tells the editor how much text is currently in its buffer.
// Typically called after filling the buffer passed to Ebitor_init()
// from a file.
// Also puts the cursor at the beginning.
// newLength: Must not exceed the bufferSize parameter passed
// to Ebitor_init().
//
void Ebitor_setContentLength(size_t newLength);
size_t Ebitor_getContentLength(void);
// Processes the user's keyboard commands to edit the text.
// Invokes the callbacks given to Ebitor_init().
// Saves the terminal cursor position upon exiting.
// The next call will start by restoring the terminal cursor to the saved position.
// Other functions can affect the saved position, e.g., Ebitor_findStringAndScrollToShow().
// startWithRefresh: Start by filling the terminal with what is currently supposed to appear,
// depending on the position of the logical cursor and of the terminal cursor.
//
void Ebitor_processEditing(BOOL startWithRefresh);
// Processes the given key as if it had been typed by the user.
//
// key: Must be a printable character or an ebitor_KEY_* value, but NOT ebitor_KEY_ESCAPE.
//
// Ebitor_locateCursorAtSavedPosition() must be called before calling this function;
// then, this function can be called one or more times; when this sequence of calls
// is done, Ebitor_saveCursorPosition() must be called.
//
void Ebitor_processKey(word key);
// Simulate a user pressing the up or down arrow multiple times, then refreshes the terminal.
// When the number of repetitions is large, this function is more efficient than calling
// Ebitor_processKey() multiple times, because the terminal would get updated with each call
// to Ebitor_processKey().
// isUpArrow: TRUE to simulate an up arrow key, FALSE for a down arrow.
// numRepetitions: The number of times to repeat the specified arrow key.
// Allowed to be zero.
//
void Ebitor_processUpOrDownArrowsAndRefresh(BOOL isUpArrow, size_t numRepetitions);
// Remembers the current position of the cursor.
// The cursor can later be restored to that position by a call to Ebitor_locateCursorAtSavedPosition().
//
void Ebitor_saveCursorPosition(void);
// Puts the cursor at the position saved by the most recent call to Ebitor_saveCursorPosition().
// The latter must have been called at least once.
//
void Ebitor_locateCursorAtSavedPosition(void);
size_t Ebitor_getLogicalCursorOffset(void);
// Determines which logical offset is currently at position (0, 0) on the terminal.
//
size_t Ebitor_getLogicalOffsetAtHome(byte cursorCol, byte cursorRow);
// Also puts the terminal cursor at the home position.
//
void Ebitor_setLogicalCursorAtBeginning(void);
// Searches for the string in strSearchedFor and if found, scrolls the terminal and
// positions the cursor so that the the found string is visible.
// If the string is not found, the terminal is not scrolled and the cursor is not moved.
// startLogicalOffset: Position in the text where to start the search.
// strSearchedFor: Non empty, NUL-terminated.
// foundLogicalOffset: (Must not be null.) Receives the logical position where the string
// was found, if TRUE is returned. Not filled if FALSE is returned.
// Returns TRUE if found, FALSE if not.
//
BOOL Ebitor_findStringAndScrollToShow(size_t startLogicalOffset, const char *strSearchedFor,
size_t *foundLogicalOffset);
// Locates the terminal cursor at the terminal location equivalent to logicalOffsetToShow.
// Makes this terminal cursor the currently saved one.
// Scrolls enough to make sure that 'lengthToShow' characters from logicalOffsetToShow
// are visible in the terminal.
// lengthToShow is allowed to be zero.
// This saved position will be used by the next call to Ebitor_processEditing().
// Puts the logical cursor at logicalOffsetToShow.
// Scrolls and/or redraws lines as necessary.
//
void Ebitor_scrollToShowLogicalOffset(size_t logicalOffsetToShow, size_t lengthToShow);
// Returns the offset of the start of the line that contains the given offset.
//
size_t Ebitor_findSOL(size_t startOffset);
// Returns the offset of the end-of-line delimiter of the line that contains the given offset.
// If the current line is the last one and has no such delimiter, then the length of the
// filled buffer is returned.
//
size_t Ebitor_findEOL(size_t startOffset);
void Ebitor_shutdown(void);
#endif /* _H_Ebitor */
+105
View File
@@ -0,0 +1,105 @@
/* Ebitor_private.h
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _H_Ebitor_private
#define _H_Ebitor_private
#include "Ebitor.h"
#include <assert.h>
#define min(a, b) ((a) < (b) ? (a) : (b))
extern Ebitor Ebitor_instance;
void Ebitor_startCommandMode(void);
// key: Must be a printable character in 32..255.
//
void Ebitor_processPrintableChar(word key, byte cursorCol, byte cursorRow);
// Prints the edit buffer starting from firstLogicalCharOffsetToPrint and stopping
// when the end of the edit buffer or the end of the window has been reached.
// The printing starts at column 0 of firstRowToFill.
//
void Ebitor_fillTerminalToBottom(size_t firstLogicalCharOffsetToPrint, byte firstRowToFill);
// Does not move the logical cursor.
//
void Ebitor_insertChar(char c);
// Determines if the region of the text at 'regionOffset' and of the given 'regionLength'
// is entirely visible in the terminal, assuming that the cursor offset is at (cursorCol, cursorRow)
// on the terminal.
// Assumes that the region specification is valid, i.e., it is within the filled buffer.
// Assumes that the insert buffer is empty.
//
// *homeOffset gets filled by Ebitor_getLogicalOffsetAtHome().
// Returns -1 if region is (entirely or partly) before displayed text (*firstOffWindowOffset does NOT get filled).
// Returns +1 if region is (entirely or partly) after displayed text (*firstOffWindowOffset gets filled).
// Returns 0 if region is entirely in the displayed text (*firstOffWindowOffset gets filled).
//
char Ebitor_isRegionVisible(size_t regionOffset, size_t regionLength, byte cursorCol, byte cursorRow,
size_t *homeOffset, size_t *firstOffWindowOffset);
// firstOffWindowOffset: Must designate a position that would be displayed at the start of a window row.
//
size_t Ebitor_countRowsToScrollUp(size_t logicalOffsetToShow, size_t firstOffWindowOffset);
// Stores in *logicalOffsetAtStartOfTermRow the number rows by which the terminal
// must be scrolled down to show the given logical offset (logicalOffsetToShow) in the first row.
// homeOffset: Value obtained from Ebitor_getLogicalOffsetAtHome().
//
size_t Ebitor_countRowsToScrollDown(size_t logicalOffsetToShow, size_t homeOffset,
size_t *logicalOffsetAtStartOfTermRow);
void Ebitor_processBackspace(byte cursorCol, byte cursorRow);
// solOffset: Must be the start of the edit buffer or be preceded by an EOL terminator.
// Returns solOffset itself if no previous line.
//
size_t Ebitor_findPreviousSOL(size_t solOffset);
// firstLogicalCharOffsetToPrint: Must designate a character that is to appear at the start of a terminal row.
//
void Ebitor_fillWindowFromHomeToRow(size_t firstLogicalCharOffsetToPrint, byte numRowsToFill);
// startOfRowOffset: Logical offset of a character that is in column 0.
// Returns the logical offset of another character down the text that is also in column 0.
// If there are not enough rows, stops at the last row.
//
size_t Ebitor_goDownRows(size_t startOfRowOffset, size_t numRows);
void Ebitor_locateAndSavePos(byte col, byte row);
#endif /* _H_Ebitor_private */
+216
View File
@@ -0,0 +1,216 @@
# By Pierre Sarrazin <http://sarrazip.com/>
#
# This file is in the public domain.
#
# To compile the demo program and the test program, do "make" or "make all".
# To make a DECB floppy disk image with those programs, do "make dsk".
#
# The OS-9 version needs the BControl library, available from the CMOC home page.
# Before building, create a symlink named 'bcontrol' that points to the
# BControl source code.
# Then to build, do "make TARGET=os9".
# To deploy to the OS-9 hard disk image designtaed by OS9_DSK, make sure that
# the "os9" command of the ToolShed package (version 2.2. or later) is in the path,
# then do "make TARGET=os9 deploy".
PACKAGE = ebitor
VERSION = 0.1.1
TARGET = coco
# Sources and headers of the library.
CORELIBSRC = \
Ebitor.c \
findStringAndScrollToShow.c \
processPrintableChar.c \
processBackspace.c \
scrollToShowLogicalOffset.c
COCOLIBSRC = sg4term.c gimeterm.c
OS9LIBSRC = os9term.c
LIBSRC = $(CORELIBSRC)
CORELIBHEADERS = \
Ebitor.h \
Ebitor_private.h \
Window.h
COCOLIBHEADERS = sg4term.h gimeterm.h
OS9LIBHEADERS = os9term.h
LIBHEADERS = $(CORELIBHEADERS)
# Add platform-specific sources and headers.
ifeq "$(TARGET)" "coco"
LIBSRC += $(COCOLIBSRC)
LIBHEADERS += $(COCOLIBHEADERS)
else ifeq "$(TARGET)" "os9"
LIBSRC += $(OS9LIBSRC)
LIBHEADERS += $(OS9LIBHEADERS)
else ifeq "$(TARGET)" "usim"
LIBSRC += $(COCOLIBSRC)
LIBHEADERS += $(COCOLIBHEADERS)
endif
STATICLIB = lib$(PACKAGE).a
ifeq "$(TARGET)" "coco"
EXEEXT = .bin
else ifeq "$(TARGET)" "usim"
EXEEXT = .srec
else ifeq "$(TARGET)" "os9"
EXEEXT =
endif
# Interactive demo program where the user can use the editor.
ifneq "$(TARGET)" "usim"
DEMOSRC = ebitdemo.c
DEMOBIN = ebitdemo$(EXEEXT)
endif
ifeq "$(TARGET)" "coco"
# Minimal interactive demo that only runs in 32x16 under DECB.
SMOLDEMOSRC = smoldemo.c
SMOLDEMOBIN = smoldemo$(EXEEXT)
endif
ifneq "$(TARGET)" "os9"
# Non-interactive self-test suite (uses sg4term.c).
TESTSRC = ebittest.c
TESTBIN = ebittest$(EXEEXT)
endif
# List of sources and headers across all supported platforms.
DISTLIBSRC = $(CORELIBSRC) $(COCOLIBSRC) $(OS9LIBSRC)
DISTLIBHEADERS = $(CORELIBHEADERS) $(COCOLIBHEADERS) $(OS9LIBHEADERS)
DISTFILES = README.md Makefile $(DISTLIBHEADERS) $(DISTLIBSRC) $(DEMOSRC) $(SMOLDEMOSRC) $(TESTSRC)
DSK = $(PACKAGE)-$(VERSION)-$(TARGET).dsk
# Compilation and linking flags. Left empty under OS-9.
# With no --org option, the DECB .bin entry point is $2800.
ifneq "$(TARGET)" "os9"
DEMOORG = --limit=7F00
SMOLDEMOORG = --limit=7F00
TESTORG = --limit=7F00
endif
INTERMEDIATE = #--intermediate
# Omit -DNDEBUG to enable the assert statements in the library.
NDEBUG = -DNDEBUG
OPTIM = -fomit-frame-pointer
WARNINGS = -Wfor-condition-sizes #-Wgives-byte
WERROR = -Werror #-Wno-uncalled-static
STACKSPACE = 2048
CFLAGS = --$(TARGET) $(NDEBUG) $(INTERMEDIATE) $(OPTIM) $(WARNINGS) $(WERROR) \
-DVERSION=\"$(VERSION)\" --stack-space=$(STACKSPACE)
LDFLAGS = --$(TARGET) $(INTERMEDIATE)
DEMOOBJ = $(DEMOSRC:.c=.o)
SMOLDEMOOBJ = $(SMOLDEMOSRC:.c=.o)
TESTOBJ = $(TESTSRC:.c=.o)
LIBOBJ = $(LIBSRC:.c=.o)
# Libraries possibly needed by this package.
ifeq "$(TARGET)" "os9"
BCONTROL_LIB = bcontrol
BCONTROL_LIB_DIR = bcontrol
DEMO_CFLAGS = -I $(BCONTROL_LIB_DIR)
DEMO_LDFLAGS = -L $(BCONTROL_LIB_DIR) -l$(BCONTROL_LIB)
endif
# Tools.
CMOC = cmoc
LWAR = lwar
PERL = perl
TAR = tar
WRITECOCOFILE = writecocofile
INSTALL_LOADER = install-coco-boot-loader
XROAR = xroar
all: $(DEMOBIN) $(SMOLDEMOBIN) $(TESTBIN)
$(DEMOBIN): $(DEMOOBJ) $(STATICLIB)
$(CMOC) -o $(DEMOBIN) $(LDFLAGS) $(DEMOORG) $(DEMOOBJ) -L. -l$(PACKAGE) $(DEMO_LDFLAGS)
ifeq "$(TARGET)" "coco"
$(SMOLDEMOBIN): $(SMOLDEMOOBJ) $(STATICLIB)
$(CMOC) -o $(SMOLDEMOBIN) $(LDFLAGS) $(SMOLDEMOORG) $(SMOLDEMOOBJ) -L. -l$(PACKAGE)
endif
ifneq "$(TARGET)" "os9"
$(TESTBIN): $(TESTOBJ) $(STATICLIB)
$(CMOC) -o $(TESTBIN) $(LDFLAGS) $(TESTORG) $(TESTOBJ) -L. -l$(PACKAGE)
endif
$(STATICLIB): $(LIBOBJ)
$(LWAR) --create $(STATICLIB) $(LIBOBJ)
ifeq "$(TARGET)" "coco"
$(DSK): dsk
.PHONY: dsk
dsk: $(DEMOBIN) $(SMOLDEMOBIN) $(TESTBIN)
$(PERL) -e 'print chr(255) x (35*18*256)' > $(DSK)
$(WRITECOCOFILE) $(DSK) $(DEMOBIN)
$(WRITECOCOFILE) $(DSK) $(SMOLDEMOBIN)
$(WRITECOCOFILE) $(DSK) $(TESTBIN)
endif
ifeq "$(TARGET)" "os9"
OS9_DSK = 68sdc.vhd
OS9COPY = os9 copy
OS9ATTR = os9 attr -q
.PHONY: deploy
deploy: $(DEMOBIN)
$(OS9COPY) $(DEMOBIN) $(OS9_DSK),CMDS -r
$(OS9ATTR) -epe $(OS9_DSK),CMDS/$(DEMOBIN)
endif
%.o: %.c
$(CMOC) -c $(CFLAGS) $(DEMO_CFLAGS) -o $@ $<
clean:
rm -f $(DEMOBIN) $(DEMOOBJ) \
$(SMOLDEMOBIN) $(SMOLDEMOOBJ) \
$(TESTBIN) $(TESTOBJ) \
$(STATICLIB) $(LIBOBJ)
distclean: clean
rm -f $(DEMOSRC:.c=.d) $(SMOLDEMOSRC:.c=.d) $(LIBSRC:.c=.d)
.PHONY: dist distcheck
dist:
$(TAR) -czf $(PACKAGE)-$(VERSION).tar.gz --transform 's,^,$(PACKAGE)-$(VERSION)/,' $(DISTFILES)
# To do a distcheck with TARGET=os9, also pass BCONTROL_LIB_DIR=FIXME.
#
distcheck: dist
mkdir ,distcheck
$(TAR) -C ,distcheck -xzf $(PACKAGE)-$(VERSION).tar.gz
$(MAKE) -C ,distcheck/$(PACKAGE)-$(VERSION) all dsk
rm -fr ,distcheck
@echo "SUCCESS: $(PACKAGE)-$(VERSION).tar.gz ready for distribution"
# Automatic prerequisite generation.
%.d: %.c
$(CMOC) --deps-only $(CFLAGS) $(DEMO_CFLAGS) $<
.PHONY: cleandeps
cleandeps:
rm -f $(DEMOSRC:.c=.d) $(SMOLDEMOSRC:.c=.d) $(TESTSRC:.c=.d) $(LIBSRC:.c=.d)
include $(DEMOSRC:.c=.d)
include $(SMOLDEMOSRC:.c=.d)
include $(TESTSRC:.c=.d)
include $(LIBSRC:.c=.d)
+150
View File
@@ -0,0 +1,150 @@
# Ebitor: A reusable text editor C library for 8-bit systems
Ebitor is a C library that implements a bare bones text editor
that can be adapted to work in any terminal. It features text
search and can be extended by the client program.
Copyright © 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
This code comes with ABSOLUTELY NO WARRANTY.
It is recommended to make backups of any files whose contents
are subjected to this editor.
## License: GPLv3
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
See file COPYING.
## Introduction
This is NOT an editor application, it is only a **C library**.
It is intended for programmers who want to integrate a full-screen
editor into their own application.
This library implements a bare bones editor: It has very few features.
More features can be implemented by the client program. They would
typically be invoked by the user by typing the escape key followed by
another key. For example, the Break key followed by A could be used to
put the cursor at the start of the current line.
## Features
- Used as a library, not a program.
- Terminal functions are entirely provided by the client program.
This allows this editor to be used with any terminal type.
- CoCo 32x16, 40x25, 64x25, 80x25 terminal drivers provided.
- OS-9 40- and 80-column driver provided.
The 32-column terminal is not supported.
(The OS-9 version needs the BControl library, available from
the CMOC home page.)
- Does not require dynamic memory allocation.
- Folds lines that are longer than the terminal width.
Does not support non-folding with horizontal scrolling.
- Only one editor can be operated at a given time.
- Should be compiled with the CMOC compiler.
See <http://sarrazip.com/dev/cmoc.html>.
The code assumes a 64k addressable space.
- The only controls provided are moving the cursor with the arrow
keys, and a backspace key to erase the previous character.
Other controls like page-up, page-down and string search must be
implemented by the client program.
The library offers function Ebitor_findStringAndScrollToShow()
to facilitate the latter.
## Building Ebitor
In a Unix-like development environment, do `make` to compile
for the CoCo, or `make TARGET=os9` to compile for OS-9.
See `Makefile` for details.
## Programming for Ebitor
See `smoldemo.c` for a minimal example and `ebitdemo.c` for a
substantial one. To compile these demos, do `make`, then run
`smoldemo.bin` or `ebitdemo.bin` on a CoCo or an emulator.
Either of these demos first #includes header files for one or
more terminal structs, e.g., `sgterm.h` for SG-4 mode (32x16),
`gimeterm.h` for the CoCo 3 text modes, or `os9term.h` for an
OS-9 40- or 80-character terminal.
Then it #includes `Ebitor.h` to use the editor structs and functions.
The demo's first step is to fill an ebitor_Window object that defines
the text window that the editor will use. Then it calls Ebitor's
`sg4term_init()` function, in the case of ,`smoldemo.c` to initialize
the 32x16 screen terminal.
Then `Ebitor_init()` is called to initialize the editor. This call
receives several pointers to several functions that Ebitor will need,
e.g., clearing the terminal, locating the cursor, etc. In the case of
the 32x16 screen, `sg4term_clear` and `sg4term_locate` are passed.
Then the demo enters its main editing loop. This loop must call
`Ebitor_processEditing()`. This function will operate until the user
presses the escape key, typically Break on a CoCo.
Then the editing loop shows a prompt to ask the user what to do after
pressing the escape key. Both demos offer to quit the program or to
show a help page. `ebitdemo.c` also offers to find some text.
If the user presses the escape key again instead of choosing one
of those options, the editing loop just goes back to the call to
`Ebitor_processEditing()`.
When exiting the editor loop, `Ebitor_shutdown()` must be called.
## Porting to other environments
`Ebitor_init()` accepts pointers to functions that handle the
terminal operations needed by the editor. Porting to a different
type of terminal mainly involves writing functions that fill the
same roles, and passing the addresses of those functions to
`Ebitor_init()`.
A good starting point can be to make a copy of sg4term.h and
sg4term.c under new names, then reworking the code for the new
terminal type.
## Memory requirements
The Ebitor library code should take about 5100 bytes in memory under DECB,
but about 5400 under OS-9.
The SG4 (32x16) terminal code (sg4term.c) should take about 1300 bytes.
The GIME (CoCo 3) terminal code (gimeterm.c) should take about 1300 bytes.
The OS-9 terminal code should take about 1000 bytes.
These sizes do not count:
* the text buffer in which the edited text is stored;
* the stack space needed during operation;
* the space that would be used if the assert() statements were enabled
by compiling without NDEBUG.
## Version history
0.1.0 - 2027-07-27 - First public release.
+36
View File
@@ -0,0 +1,36 @@
/* Window.h
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _H_EbitorWindow
#define _H_EbitorWindow
#include <coco.h>
typedef struct ebitor_Window
{
byte width;
byte height;
byte leftCol;
byte topRow;
byte cursorCol;
byte cursorRow;
} ebitor_Window;
#endif /* _H_EbitorWindow */
+1041
View File
File diff suppressed because it is too large. Load diff
+818
View File
@@ -0,0 +1,818 @@
/* ebittest.c
This file is in the public domain.
*/
#undef NDEBUG /* enable asserts */
#include "sg4term.h"
#include "Ebitor_private.h"
///////////////////////////////////////////////////////////////
static const char *predefinedKeyPresses = "";
static byte
readPredefinedKeyOrKeyboard(void)
{
if (*predefinedKeyPresses != '\0')
return *predefinedKeyPresses++;
return 0; // not supposed to be reached
}
static const ebitor_Window testWindow = { 32, 15, 0, 0, 0, 0 };
static size_t currentTestIndex;
static byte
inkey1(void *cookie)
{
byte code = readPredefinedKeyOrKeyboard();
return code;
}
// Declarations of private functions used by the self tests.
//
// char Ebitor_isRegionVisible(size_t regionOffset, size_t regionLength, byte cursorCol, byte cursorRow,
// size_t *homeOffset, size_t *firstOffScreenOffset);
// size_t Ebitor_countRowsToScrollUp(size_t logicalOffsetToShow, size_t firstOffScreenOffset);
// size_t Ebitor_countRowsToScrollDown(size_t logicalOffsetToShow, size_t homeOffset, size_t *logicalOffsetAtStartOfTermRow);
static char textBuffer[600];
static const char *initContents = ""
"ABCDEFGHIJKLMNOPQRSTUVWXYZ01234\r"
"L0\r"
"L1\r"
"L2\r"
"L3\r"
"L4\r"
"L5\r"
"L6\r"
"L7\r"
"L8\r"
"L9\r"
"L10\r"
"L11\r"
"L12\r"
"L13\r"
"L14ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz\r"
"L15\r"
"L16\r"
"L17\r"
;
// Uses initContents. Fills textBuffer. Calls Ebitor_setContentLength().
//
static void
setRepeatedTestContent(size_t numRepetitions)
{
size_t initContentLength = strlen(initContents);
assert(initContentLength < sizeof(textBuffer) / numRepetitions);
char *dest = textBuffer;
for (size_t i = numRepetitions; i--; dest += initContentLength)
memcpy(dest, initContents, initContentLength);
Ebitor_setContentLength(initContentLength * numRepetitions);
}
//: Tested: Ebitor_setContentLength
//
static void
setTestContent(void)
{
setRepeatedTestContent(1);
}
static void
test_scrollWindowUp(void)
{
Ebitor *editor = Ebitor_getInstance();
setTestContent();
// Show the text.
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
char text[3];
sg4term_getChars(0, 14, text, sizeof(text));
assert(memcmp(text, "L13", sizeof(text)) == 0);
sg4term_scrollWindowUp(1);
sg4term_getChars(0, 13, text, sizeof(text));
assert(memcmp(text, "L13", sizeof(text)) == 0); // L13 moved one row up
sg4term_getChars(0, 14, text, sizeof(text));
assert(memcmp(text, " ", sizeof(text)) == 0); // bottom row cleared
}
static void
test_scrollWindowDown(void)
{
Ebitor *editor = Ebitor_getInstance();
setTestContent();
// Show the text.
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
char text[3];
sg4term_getChars(0, 0, text, sizeof(text));
assert(memcmp(text, "ABC", sizeof(text)) == 0);
sg4term_scrollWindowDown(1);
sg4term_getChars(0, 1, text, sizeof(text));
assert(memcmp(text, "ABC", sizeof(text)) == 0); // ABC moved one row down
sg4term_getChars(0, 0, text, sizeof(text));
assert(memcmp(text, " ", sizeof(text)) == 0); // top row cleared
}
//: Tested: Ebitor_isRegionVisible
//: Tested: Ebitor_countRowsToScrollUp
//
static void
test_countRowsToScrollUp(void)
{
Ebitor *editor = Ebitor_getInstance();
setTestContent();
size_t homeOffset = 0xFEDC, firstOffScreenOffset = 0xEDCB; // dummy values to be overwritten
// Check that a substring near the end of the text is not displayed.
//
char *p = strstr(editor->bufferBegin, "L16\r");
assert(p);
size_t regionOffset = p - editor->bufferBegin;
printf("[regionOffset=%u]", regionOffset);
char code = Ebitor_isRegionVisible(regionOffset, 3, editor->savedCursorCol, editor->savedCursorRow,
&homeOffset, &firstOffScreenOffset);
printf("[C=%d,H=%u,F=%u]", code, homeOffset, firstOffScreenOffset);
assert(code == 1); // substring comes after the displayed text
assert(homeOffset == 0); // top of screen shows top of text
size_t expectedFirstOffScreenOffset = strstr(editor->bufferBegin, "L14ABC") - editor->bufferBegin;
assert(firstOffScreenOffset == expectedFirstOffScreenOffset);
// Test that a character not at the start of a terminal row can be scrolled up to.
//
size_t logicalOffsetToShow = regionOffset + 1;
size_t numTermRows = Ebitor_countRowsToScrollUp(logicalOffsetToShow, firstOffScreenOffset);
printf("[N=%u]", numTermRows);
assert(numTermRows == 5);
}
//: Tested: Ebitor_isRegionVisible
//: Tested: Ebitor_countRowsToScrollDown
//
static void
test_countRowsToScrollDown(void)
{
Ebitor *editor = Ebitor_getInstance();
setTestContent();
// Show the text and move the cursor below the initially displayed text.
predefinedKeyPresses = "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\x03";
Ebitor_processEditing(TRUE);
// Cursor is at bottom left of editable area.
assert(editor->savedCursorCol == 0);
assert(editor->savedCursorRow == 14);
// Logical cursor is at end of text.
assert(editor->cursorOffset == editor->bufferFilledSize);
size_t homeOffset = 0, firstOffScreenOffset = 0xFEDC;
// Check that a substring near the beginning of the text is not displayed.
//
char *p = strstr(editor->bufferBegin, "L2\r");
assert(p);
size_t regionOffset = p - editor->bufferBegin;
printf("[regionOffset=%u]", regionOffset);
char code = Ebitor_isRegionVisible(regionOffset, 2, editor->savedCursorCol, editor->savedCursorRow,
&homeOffset, &firstOffScreenOffset);
printf("[C=%d,H=%u,F=%u]", code, homeOffset, firstOffScreenOffset);
assert(code == -1); // substring comes before the displayed text
assert(homeOffset == strstr(editor->bufferBegin, "L6\r") - editor->bufferBegin);
assert(firstOffScreenOffset == 0xFEDC); // dummy value not touched
size_t logicalOffsetToShow = regionOffset + 1;
size_t logicalOffsetAtStartOfTermRow = 0;
size_t numTermRows = Ebitor_countRowsToScrollDown(logicalOffsetToShow, homeOffset, &logicalOffsetAtStartOfTermRow);
printf("[N=%u,A=%u]", numTermRows, logicalOffsetAtStartOfTermRow);
assert(numTermRows == 4);
assert(logicalOffsetAtStartOfTermRow == regionOffset); // b/c regionOffset is at start of line ("L2")
}
//: Tested: Ebitor_scrollToShowLogicalOffset
//: Tested: Ebitor_getLogicalOffsetAtHome
//: Tested: Ebitor_isRegionVisible
//
static void
test_scrollToShowLogicalOffset(void)
{
Ebitor *editor = Ebitor_getInstance();
setTestContent();
// Initial screen shows top of text.
// Target a line that is below the screen.
//
char *p = strstr(editor->bufferBegin, "L16\r");
assert(p);
size_t offsetInLine = 1;
size_t regionOffset = p - editor->bufferBegin + offsetInLine;
size_t regionLen = 2;
//printf("[regionOffset=%u]", regionOffset);
// Show the text.
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
Ebitor_scrollToShowLogicalOffset(regionOffset, regionLen);
byte cursorCol, cursorRow;
editor->getCursorPos(&cursorCol, &cursorRow);
//printf("[%u,%u]", cursorCol, cursorRow);
assert(cursorCol == offsetInLine);
assert(cursorRow == editor->termHeight - 1); // last window row
size_t h = Ebitor_getLogicalOffsetAtHome(cursorCol, cursorRow);
//printf("[HO=%u]", h);
assert(h == strstr(editor->bufferBegin, "L4\r") - editor->bufferBegin);
size_t homeOffset = 0xFFFF, firstOffScreenOffset = 0xFFFF;
char code = Ebitor_isRegionVisible(regionOffset, regionLen, cursorCol, cursorRow,
&homeOffset, &firstOffScreenOffset);
//printf("[%d,%u,%u]", code, homeOffset, firstOffScreenOffset);
assert(code == 0); // region now visible
assert(homeOffset == h);
assert(firstOffScreenOffset == strstr(editor->bufferBegin, "L17\r") - editor->bufferBegin);
// Check that terminal contents got scrolled up.
char text[3];
sg4term_getChars(0, 7, text, sizeof(text));
assert(memcmp(text, "L11", sizeof(text)) == 0);
// Now scroll up to a line that is currently above the displayed text.
//
regionOffset = strstr(editor->bufferBegin, "L2\r") - editor->bufferBegin + offsetInLine;
regionLen = 1; // just the "2"
//printf("[regionOffset=%u]", regionOffset);
code = Ebitor_isRegionVisible(regionOffset, regionLen, cursorCol, cursorRow,
&homeOffset, &firstOffScreenOffset);
//printf("[%d,%u,%u]", code, homeOffset, firstOffScreenOffset);
assert(code == -1); // "L2" line is above the displayed text
assert(homeOffset == h);
assert(firstOffScreenOffset == strstr(editor->bufferBegin, "L17\r") - editor->bufferBegin);
Ebitor_scrollToShowLogicalOffset(regionOffset, regionLen);
editor->getCursorPos(&cursorCol, &cursorRow);
//printf("[%u,%u]", cursorCol, cursorRow);
assert(cursorCol == offsetInLine);
assert(cursorRow == 0);
homeOffset = 0xFFFF, firstOffScreenOffset = 0xFFFF;
code = Ebitor_isRegionVisible(regionOffset, regionLen, cursorCol, cursorRow,
&homeOffset, &firstOffScreenOffset);
//printf("[%d,%u,%u]", code, homeOffset, firstOffScreenOffset);
assert(code == 0); // region now visible
assert(homeOffset == regionOffset - offsetInLine);
assert(firstOffScreenOffset == strstr(editor->bufferBegin, "L15\r") - editor->bufferBegin);
// Check that terminal contents got scrolled down.
sg4term_getChars(0, 7, text, sizeof(text));
assert(memcmp(text, "L9 ", sizeof(text)) == 0);
}
//: Tested: Ebitor_findStringAndScrollToShow
//
static void
test_findStringAndScrollToShow(void)
{
Ebitor *editor = Ebitor_getInstance();
setTestContent();
// Show the text.
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
BOOL found;
size_t foundLogicalOffset;
// Search for a string below the displayed text.
found = Ebitor_findStringAndScrollToShow(0, "l16", &foundLogicalOffset);
assert(found);
char text[3];
sg4term_getChars(0, 14, text, sizeof(text));
assert(memcmp(text, "L16", sizeof(text)) == 0);
byte cursorCol, cursorRow;
editor->getCursorPos(&cursorCol, &cursorRow);
assert(cursorCol == 0 && cursorRow == 14);
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "L16\r", 4) == 0);
// Search for a string above the displayed text.
found = Ebitor_findStringAndScrollToShow(0, "l2", &foundLogicalOffset);
assert(found);
sg4term_getChars(0, 0, text, sizeof(text));
assert(memcmp(text, "L2 ", sizeof(text)) == 0);
editor->getCursorPos(&cursorCol, &cursorRow);
assert(cursorCol == 0 && cursorRow == 0);
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "L2\r", 3) == 0);
// Search for a string already in the displayed text.
found = Ebitor_findStringAndScrollToShow(0, "678", &foundLogicalOffset);
assert(found);
sg4term_getChars(3, 13, text, sizeof(text));
assert(memcmp(text, "678", sizeof(text)) == 0);
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "678", 3) == 0);
// Search for a string that is not in the text.
found = Ebitor_findStringAndScrollToShow(0, "ABSENT", &foundLogicalOffset);
assert(!found);
sg4term_getChars(3, 13, text, sizeof(text));
assert(memcmp(text, "678", sizeof(text)) == 0);
editor->getCursorPos(&cursorCol, &cursorRow);
assert(cursorCol == 3 && cursorRow == 13);
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "678", 3) == 0);
size_t homeOffset = Ebitor_getLogicalOffsetAtHome(cursorCol, cursorRow);
//printf("[homeOffset=%u]", homeOffset);
assert(homeOffset == strlen("ABCDEFGHIJKLMNOPQRSTUVWXYZ01234\r" "L0\r" "L1\r"));
// Search for a string that appears more than once.
size_t numOccurrences = 0;
size_t startLogicalOffset = 0;
for (;;)
{
found = Ebitor_findStringAndScrollToShow(startLogicalOffset, "L1", &foundLogicalOffset);
//printf("[%d,%u]", found, foundLogicalOffset); waitkey(1);
if (!found)
break;
assert(startLogicalOffset <= foundLogicalOffset);
assert(foundLogicalOffset <= editor->bufferFilledSize - 2);
++numOccurrences;
assert(numOccurrences <= 9);
editor->getCursorPos(&cursorCol, &cursorRow);
assert(memcmp(editor->bufferBegin + editor->cursorOffset, "L1", 2) == 0);
// Try to find another occurrence.
startLogicalOffset = foundLogicalOffset + 1;
}
assert(numOccurrences == 9);
}
//: Tested: Ebitor_findStringAndScrollToShow
//: Tested: Ebitor_processEditing
//
static void
test_findDisplayedLineAfterScrollDown(void)
{
Ebitor *editor = Ebitor_getInstance();
setTestContent();
// Show the text.
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == 0);
// Find "L3", which is displayed.
//
size_t foundLogicalOffset = 0xFFFF;
BOOL found = Ebitor_findStringAndScrollToShow(0, "L3", &foundLogicalOffset);
assert(found);
assert(foundLogicalOffset == 41);
assert(editor->cursorOffset == 41);
byte cursorCol, cursorRow;
sg4term_getCursorPos(&cursorCol, &cursorRow);
assert(cursorCol == 0);
assert(cursorRow == 4);
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == 4);
// Go down enough to screen window up one row.
// FALSE means no refresh, to check that Ebitor_findStringAndScrollToShow()
// did NOT scroll the window.
//
predefinedKeyPresses = "\n\n\n\n\n\n\n\n\n\n\n\x03";
Ebitor_processEditing(FALSE);
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == testWindow.height - 1);
char text[3];
sg4term_getChars(0, testWindow.height - 1, text, sizeof(text));
assert(memcmp(text, "L14", sizeof(text)) == 0);
// Find "L3" again and check that the screen has not scrolled.
//
found = Ebitor_findStringAndScrollToShow(0, "L3", &foundLogicalOffset);
assert(found);
assert(foundLogicalOffset == 41);
assert(editor->cursorOffset == 41);
sg4term_getCursorPos(&cursorCol, &cursorRow);
assert(cursorCol == 0);
assert(cursorRow == 3);
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == 3);
sg4term_getChars(0, testWindow.height - 1, text, sizeof(text));
assert(memcmp(text, "L14", sizeof(text)) == 0);
// Process nothing, but check that the screen has been redisplayed correctly.
//
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
sg4term_getChars(0, testWindow.height - 1, text, sizeof(text));
assert(memcmp(text, "L14", sizeof(text)) == 0);
}
//: Tested: Ebitor_processUpOrDownArrowsAndRefresh
//
static void
test_goPageUpOnEmptyBuffer(void)
{
Ebitor *editor = Ebitor_getInstance();
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
// Page up:
Ebitor_processUpOrDownArrowsAndRefresh(TRUE, testWindow.height);
}
//: Tested: Ebitor_processUpOrDownArrowsAndRefresh
//
static void
test_goPageUpOnSingleLine(void)
{
Ebitor *editor = Ebitor_getInstance();
predefinedKeyPresses = "\r\x03";
Ebitor_processEditing(TRUE);
// Page up:
Ebitor_processUpOrDownArrowsAndRefresh(TRUE, testWindow.height);
}
//: Tested: Ebitor_scrollToShowLogicalOffset
//
static void
test_goTwoPagesUp(void)
{
Ebitor *editor = Ebitor_getInstance();
setRepeatedTestContent(2);
// Show the text.
predefinedKeyPresses =
"\n\n\n\n\n\n\n\n\n\n" // go to bottom of text (scrolls down 2 pages)
"\n\n\n\n\n\n\n\n\n\n"
"\n\n\n\n\n\n\n\n\n\n"
"\n\n\n\n\n\n\n\n\n\n"
"\n\n"
"\x03";
Ebitor_processEditing(TRUE);
// Go back up to the first "L2" line.
size_t targetOffset = 32 + 3 + 3;
Ebitor_scrollToShowLogicalOffset(targetOffset, 2);
assert(editor->cursorOffset == targetOffset);
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == 0);
}
//: Tested: Ebitor_scrollToShowLogicalOffset
//
static void
test_goTwoPagesDown(void)
{
Ebitor *editor = Ebitor_getInstance();
setRepeatedTestContent(2);
// Show the text.
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
// Scroll down to the second "L13" line.
//
const char *target = strstr(textBuffer, "L11\r");
assert(target);
target = strstr(target + 1, "L11\r");
assert(target);
size_t targetOffset = target - textBuffer;
Ebitor_scrollToShowLogicalOffset(targetOffset, 3);
assert(editor->cursorOffset == targetOffset);
assert(editor->savedCursorCol == 0 && editor->savedCursorRow == testWindow.height - 1);
// Check that the scrolling was correct.
//
char text[3];
sg4term_getChars(0, testWindow.height - 1, text, sizeof(text));
assert(memcmp(text, "L11", sizeof(text)) == 0);
sg4term_getChars(0, 2, text, sizeof(text));
assert(memcmp(text, "ABC", sizeof(text)) == 0);
}
// Checks that the terminal cursor goes down when the user presses the down arrow key.
//
static void
test_goOneRowDown(void)
{
setRepeatedTestContent(2);
// Show the text.
predefinedKeyPresses = "\x03";
Ebitor_processEditing(TRUE);
// Down arrow, then return from Ebitor_processEditing().
predefinedKeyPresses = "\x0A\x03";
Ebitor_processEditing(FALSE);
// Check that cursor went down one row.
byte column, row;
sg4term_getCursorPos(&column, &row);
assert(column == 0);
assert(row == 1);
// Check that logical offset is at start of 2nd logical line.
assert(Ebitor_getLogicalCursorOffset() == strstr(textBuffer, "\r") + 1 - textBuffer);
}
//: Tested: Ebitor_setContentLength
//: Tested: Ebitor_processEditing
//
static void
test_bufferFill(void)
{
Ebitor *editor = Ebitor_getInstance();
// Fill textBuffer (with letters) almost to the limit.
//
size_t filledSize = sizeof(textBuffer) - 5;
for (size_t i = 0; i < filledSize; ++i)
textBuffer[i] = 'A' + (char) (i % 26);
Ebitor_setContentLength(filledSize);
assert(editor->bufferFilledSize == sizeof(textBuffer) - 5);
// Interactively add too many chars.
//
predefinedKeyPresses = "12345678\x03";
Ebitor_processEditing(TRUE);
assert(editor->bufferFilledSize == sizeof(textBuffer)); // no room for "678"
char text[7];
sg4term_getChars(0, 0, text, sizeof(text));
assert(memcmp(text, "12345AB", sizeof(text)) == 0);
// Backspace.
//
predefinedKeyPresses = "\f\x03";
Ebitor_processEditing(FALSE);
assert(editor->bufferFilledSize == sizeof(textBuffer) - 1);
sg4term_getChars(0, 0, text, sizeof(text));
assert(memcmp(text, "1234ABC", sizeof(text)) == 0);
// Backspace too much.
//
predefinedKeyPresses = "\f\f\f\f\f\f\f\x03";
Ebitor_processEditing(FALSE);
assert(editor->bufferFilledSize == sizeof(textBuffer) - 5);
sg4term_getChars(0, 0, text, sizeof(text));
assert(memcmp(text, "ABCDEFG", sizeof(text)) == 0);
}
// Tests a fix made in Ebitor_processPrintableChar() on 2025-01-09
// re: not calling Ebitor_fillTerminalToBottom() with firstRowToFill
// equal to Ebitor_instance.termHeight.
// In this test, the last visible row has 1 character less than the
// terminal width, then the user adds a character to the start of
// that row.
//
//: Tested: Ebitor_setContentLength
//: Tested: Ebitor_processEditing
//
static void
test_addCharToLastVisibleRowWithAlmostFullLine(void)
{
Ebitor *editor = Ebitor_getInstance();
// Fill textBuffer (with letters) almost to the limit.
//
strcpy(textBuffer,
"L0\r"
"L1\r"
"L2\r"
"L3\r"
"L4\r"
"L5\r"
"L6\r"
"L7\r"
"L8\r"
"L9\r"
"L10\r"
"L11\r"
"L12\r"
"L13\r"
"L14--+----1----+----2----+----3\r" // last visible row, initially; 1 char short of filling row
"L15\r");
Ebitor_setContentLength(strlen(textBuffer));
// Interactively add a char at start of last visible row.
//
predefinedKeyPresses =
"\n\n\n\n\n\n\n\n\n\n\n\n\n\n" // go from row 0 to row 14
"*" // add printable char
"\x03" // return from Ebitor_processEditing()
;
Ebitor_processEditing(TRUE);
// Check content of last 3 visible rows.
//
char text[32 * 3 + 1];
sg4term_getChars(0, testWindow.height - 3, text, sizeof(text) - 1);
text[32 * 3] = '\0';
assert(strcmp(text,
"L13 "
"*L14--+----1----+----2----+----3"
" ") == 0);
// 2 down arrows, then check that L15 appears.
//
predefinedKeyPresses = "\n\n\x03";
Ebitor_processEditing(FALSE);
sg4term_getChars(0, testWindow.height - 3, text, sizeof(text) - 1);
assert(strcmp(text,
"*L14--+----1----+----2----+----3"
" "
"L15 ") == 0);
}
#ifdef USIM
char screenBuffer[512];
word timer;
#define TIMER_ADDRESS (&timer)
#else /* CoCo: */
char *screenBuffer = (char *) 0x0400;
#define TIMER_ADDRESS ((word *) 0x112)
#endif
// screenMode: 32, 40, 64, 80.
//
static void
initEbitor(byte screenMode, const ebitor_Window *window)
{
Ebitor *editor = Ebitor_getInstance();
word irqServiceRoutineAddress = * (word *) 0xFFF8;
BOOL isCoCo3 = (irqServiceRoutineAddress == 0xFEF7);
if (screenMode != 32 && !isCoCo3)
{
printf("MODE %u IS ONLY SUPPORTED ON\nA COCO 3.\n", screenMode);
return;
}
switch (screenMode)
{
case 32:
#ifdef _COCO_BASIC_
width(32); // by SECB
cls(3);
#endif
sg4term_init(screenBuffer, window, inkey1, NULL, TIMER_ADDRESS);
Ebitor_init(textBuffer, sizeof(textBuffer),
window->width, window->height,
sg4term_clear,
sg4term_locate,
sg4term_getCursorPos,
sg4term_print,
sg4term_printPrefix,
sg4term_clrtoeol,
sg4term_scrollWindowUp,
sg4term_scrollWindowDown,
sg4term_waitEditorKey);
break;
default:
assert(0);
}
}
typedef void (*TestFunction)(void);
static void
runTest(TestFunction testFunc)
{
byte screenMode = 32;
#ifdef _COCO_BASIC_
width(32);
locate(0, 0);
#endif
initEbitor(screenMode, &testWindow);
testFunc();
Ebitor_shutdown();
}
TestFunction tests[] =
{
test_scrollWindowUp,
test_scrollWindowDown,
test_countRowsToScrollUp,
test_countRowsToScrollDown,
test_scrollToShowLogicalOffset,
test_findStringAndScrollToShow,
test_findDisplayedLineAfterScrollDown,
test_goPageUpOnEmptyBuffer,
test_goPageUpOnSingleLine,
test_goTwoPagesUp,
test_goTwoPagesDown,
test_bufferFill,
test_goOneRowDown,
test_addCharToLastVisibleRowWithAlmostFullLine,
};
static void
runSelfTests(void)
{
size_t numTests = sizeof(tests) / sizeof(tests[0]);
for (currentTestIndex = 0; currentTestIndex < numTests; ++currentTestIndex)
runTest(tests[currentTestIndex]);
#ifdef _COCO_BASIC_
cls(255);
#endif
printf("\n* RAN %u TEST(S) *\n", numTests);
}
static void
failedAssertHandler(const char *file, int lineno, const char *condition)
{
printf("[***FAILED ASSERT IN TEST #%u: %s:%d: %s]",
currentTestIndex, file, lineno, condition);
for (;;)
;
}
int
main()
{
#ifdef _COCO_BASIC_
rgb();
#endif
_SetFailedAssertHandler(failedAssertHandler);
runSelfTests();
return 0;
}
+49
View File
@@ -0,0 +1,49 @@
/* findStringAndScrollToShow.c
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Ebitor_private.h"
BOOL
Ebitor_findStringAndScrollToShow(size_t startLogicalOffset, const char *strSearchedFor,
size_t *foundLogicalOffset)
{
Ebitor *self = &Ebitor_instance;
Ebitor_startCommandMode(); // put insert buffer into edit buffer, so that all the text is contiguous
size_t lenStrSearchedFor = strlen(strSearchedFor);
if (lenStrSearchedFor == 0 || startLogicalOffset >= self->bufferFilledSize)
return FALSE;
const char * const bufferEnd = self->bufferBegin + self->bufferFilledSize;
const char *startPtr = self->bufferBegin + startLogicalOffset;
const char *foundPtr;
do
{
foundPtr = (char *) memichr(startPtr, strSearchedFor[0], bufferEnd - startPtr);
if (!foundPtr)
return FALSE;
if (memicmp(foundPtr + 1, strSearchedFor + 1, lenStrSearchedFor - 1) == 0)
break;
startPtr = foundPtr + 1;
} while (startPtr < bufferEnd);
*foundLogicalOffset = foundPtr - self->bufferBegin;
Ebitor_scrollToShowLogicalOffset(*foundLogicalOffset, lenStrSearchedFor);
return TRUE;
}
+319
View File
@@ -0,0 +1,319 @@
/* gimeterm.c - CoCo 3 GIME hardware text mode terminal functions.
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "gimeterm.h"
#include "Ebitor.h"
struct Ebitor;
static byte gimeterm_width, gimeterm_height; // max 80x24
static byte gimeterm_winLeftCol, gimeterm_winTopRow; // 0..79, 0..24
static word *gimeterm_screenBuffer; // address of 40/64/80x24/25 screen buffer
static byte gimeterm_screenColumns; // 40, 64 or 80 (regardless of gimeterm_width)
static byte gimeterm_cursorCol, gimeterm_cursorRow; // lower than gimeterm_width, gimeterm_cursorRow
static byte (*gimeterm_inkeyFuncPtr)(void *cookie); // returns 0 if no key pressed
static void *gimeterm_inkeyFuncCookie; // passed to gimeterm_inkeyFuncPtr
static word *gimeterm_timerPtr; // points to a word that gets incremented 60 times per second
static byte gimeterm_textAttribute;
static byte gimeterm_invertedTextAttribute;
static word *
getPosInWindow(byte col, byte row)
{
return gimeterm_screenBuffer + ((word) (gimeterm_winTopRow + row) * gimeterm_screenColumns + gimeterm_winLeftCol + col);
}
#define getCursorAddress() (getPosInWindow(gimeterm_cursorCol, gimeterm_cursorRow))
static void
gimeterm_clearRowsAt(word *rowStartDest, byte numRows)
{
word w = 0x2000 | gimeterm_textAttribute;
for (byte i = numRows; i--; rowStartDest += gimeterm_screenColumns) // for each window row to clear
memset16(rowStartDest, w, gimeterm_width);
}
void
gimeterm_clear(void)
{
gimeterm_clearRowsAt(getPosInWindow(0, 0), gimeterm_height);
}
void
gimeterm_init(void *screenBuffer, byte screenMode, const gimeterm_Window *window,
byte (*inkeyFuncPtr)(void *), void *inkeyFuncCookie,
word *timerPtr)
{
gimeterm_screenBuffer = (word *) screenBuffer;
gimeterm_screenColumns = screenMode;
gimeterm_inkeyFuncPtr = inkeyFuncPtr;
gimeterm_inkeyFuncCookie = inkeyFuncCookie;
gimeterm_timerPtr = timerPtr;
gimeterm_setWindow(window);
}
void
gimeterm_setWindow(const gimeterm_Window *window)
{
gimeterm_width = window->window.width;
gimeterm_height = window->window.height;
gimeterm_winLeftCol = window->window.leftCol;
gimeterm_winTopRow = window->window.topRow;
gimeterm_cursorCol = window->window.cursorCol;
gimeterm_cursorRow = window->window.cursorRow;
gimeterm_textAttribute = window->textAttribute;
gimeterm_invertedTextAttribute = window->invertedTextAttribute;
}
void
gimeterm_getWindow(gimeterm_Window *dest)
{
dest->window.width = gimeterm_width;
dest->window.height = gimeterm_height;
dest->window.leftCol = gimeterm_winLeftCol;
dest->window.topRow = gimeterm_winTopRow;
dest->window.cursorCol = gimeterm_cursorCol;
dest->window.cursorRow = gimeterm_cursorRow;
dest->textAttribute = gimeterm_textAttribute;
dest->invertedTextAttribute = gimeterm_invertedTextAttribute;
}
void
gimeterm_locate(byte column, byte row)
{
gimeterm_cursorCol = column;
gimeterm_cursorRow = row;
}
void
gimeterm_getCursorPos(byte *column, byte *row)
{
*column = gimeterm_cursorCol;
*row = gimeterm_cursorRow;
}
BOOL
gimeterm_newline(void)
{
gimeterm_cursorCol = 0; // back to start of window row
if (++gimeterm_cursorRow >= gimeterm_height)
{
--gimeterm_cursorRow;
gimeterm_cursorCol = 0; // back to start of last row (avoid writing outside window)
return FALSE; // reached end of window
}
return TRUE;
}
BOOL
gimeterm_putchar(int c)
{
word *cursor = getCursorAddress();
if (c == '\r')
{
word w = 0x2000 | gimeterm_textAttribute;
for ( ; gimeterm_cursorCol < gimeterm_width; ++gimeterm_cursorCol)
*cursor++ = w;
return gimeterm_newline();
}
((byte *) cursor)[0] = (byte) c;
((byte *) cursor)[1] = gimeterm_textAttribute;
if (++gimeterm_cursorCol >= gimeterm_width) // if past end of window row
return gimeterm_newline();
return TRUE;
}
BOOL
gimeterm_print(const char *str)
{
for ( ; *str; ++str)
if (!gimeterm_putchar(*str))
return FALSE; // reached end of window
return TRUE;
}
BOOL
gimeterm_printPrefix(const char *str, size_t prefixLength)
{
for (size_t i = 0; i < prefixLength; ++i)
if (!gimeterm_putchar(str[i]))
return FALSE; // reached end of window
return TRUE;
}
// Use inverted colors for the next print operations.
//
void
gimeterm_invertColors(void)
{
byte temp = gimeterm_textAttribute;
gimeterm_textAttribute = gimeterm_invertedTextAttribute;
gimeterm_invertedTextAttribute = temp;
}
// Does not move the cursor.
//
void
gimeterm_clrtoeol(void)
{
memset16(getCursorAddress(), 0x2000 | gimeterm_textAttribute, gimeterm_width - gimeterm_cursorCol);
}
void
gimeterm_scrollWindowUp(byte numRows)
{
if (numRows == 0)
return;
word *rowStartDest = getPosInWindow(0, 0); // top window row
const word *rowStartSrc = rowStartDest + ((word) numRows * gimeterm_screenColumns);
size_t bytesPerWindowRow = gimeterm_width << 1;
for (byte i = gimeterm_height - numRows; i--; rowStartSrc += gimeterm_screenColumns, rowStartDest += gimeterm_screenColumns) // for each window row to scroll
memcpy(rowStartDest, rowStartSrc, bytesPerWindowRow);
gimeterm_clearRowsAt(rowStartDest, numRows);
}
void
gimeterm_scrollWindowDown(byte numRows)
{
if (numRows == 0)
return;
word *rowStartDest = getPosInWindow(0, gimeterm_height - 1); // bottom window row
const word *rowStartSrc = rowStartDest - ((word) numRows * gimeterm_screenColumns);
size_t bytesPerWindowRow = gimeterm_width << 1;
for (byte i = gimeterm_height - numRows; i--; rowStartSrc -= gimeterm_screenColumns, rowStartDest -= gimeterm_screenColumns) // for each window row to scroll
memmove(rowStartDest, rowStartSrc, bytesPerWindowRow);
const word w = 0x2000 | gimeterm_textAttribute;
for (byte i = numRows; i--; rowStartDest -= gimeterm_screenColumns) // for each window row to clear
memset16(rowStartDest, w, gimeterm_width);
}
void
gimeterm_eraseCurrentLine(void)
{
memset16(getPosInWindow(0, gimeterm_cursorRow), 0x2000 | gimeterm_textAttribute, gimeterm_width);
gimeterm_cursorCol = 0;
}
// Animates a cursor using the timerPtr passed to gimeterm_init().
// Uses the inkeyFuncPtr and inkeyFuncCookie passed to gimeterm_init() to poll the keyboard.
// attributeByte: Address of a GIME 40/80-column screen attribute byte.
// cursorAttribute: Byte to put at *attributeByte to animate the cursor.
// Returns the key pressed, without interpretation.
//
static byte
gimeterm_waitKeyAtPosition(byte *attributeByte, byte cursorAttribute)
{
byte origByteOnScreen = *attributeByte;
// Wait for key with animated cursor.
byte key;
for (word startTime = *gimeterm_timerPtr; ; )
{
key = (*gimeterm_inkeyFuncPtr)(gimeterm_inkeyFuncCookie);
if (key)
break;
*attributeByte = (((*gimeterm_timerPtr - startTime) & 0x38) == 0x38 ? origByteOnScreen : cursorAttribute);
}
*attributeByte = origByteOnScreen;
return key;
}
byte
gimeterm_waitKey(void)
{
byte *cursor = (byte *) getCursorAddress() + 1; // point to attribute byte
return gimeterm_waitKeyAtPosition(cursor, gimeterm_invertedTextAttribute);
}
word
gimeterm_waitEditorKey(void)
{
for (;;)
{
byte key = gimeterm_waitKey();
switch (key)
{
case 3: // Break
return ebitor_KEY_ESCAPE;
case 8: // left arrow
return ebitor_KEY_ARROW_LEFT;
case 9: // right arrow
return ebitor_KEY_ARROW_RIGHT;
case '^': // up arrow
return ebitor_KEY_ARROW_UP;
case 10: // down arrow
return ebitor_KEY_ARROW_DOWN;
case 12: // Clear used as backspace
return '\b'; // backspace
case 13: // Enter
return '\r';
default:
if (key >= ' ' && key != 127)
return key;
}
}
}
byte
gimeterm_setTextAttribute(byte newAttribute)
{
byte orig = gimeterm_textAttribute;
gimeterm_textAttribute = newAttribute;
return orig;
}
byte
gimeterm_setInvertedTextAttribute(byte newAttribute)
{
byte orig = gimeterm_invertedTextAttribute;
gimeterm_invertedTextAttribute = newAttribute;
return orig;
}
+146
View File
@@ -0,0 +1,146 @@
/* gimeterm.h - CoCo 3 GIME hardware text mode terminal functions.
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
These functions implement a terminal compliant with the specs in Ebitor.h.
Each screen cell is a character byte followed by an attribute byte,
i.e., 2 bytes per screen character.
*/
#ifndef _H_gimeterm
#define _H_gimeterm
#include "Window.h"
typedef struct gimeterm_Window
{
ebitor_Window window;
// Default text attribute used by functions that put characters on the screen.
// See gimeterm_setTextAttribute().
//
byte textAttribute;
// Attribute to use to show characters with inverted colors.
// See gimeterm_setInvertedTextAttribute().
//
byte invertedTextAttribute;
} gimeterm_Window;
// Defines a window in a GIME hardware text screen.
// Does NOT clear the window.
// Does NOT change the video mode.
//
// screenBuffer: Address of the screen.
// screenMode: 40, 64 or 80.
// window: Initial window in the given screen.
// inkeyFuncPtr: Must return 0 (and not block) if no key pressed.
// inkeyFuncCookie: Will be passed to inkeyFuncPtr.
// timerPtr: Address of an unsigned 16-bit integer that gets incremented 60 times per second.
//
void gimeterm_init(void *screenBuffer, byte screenMode,
const gimeterm_Window *window,
byte (*inkeyFuncPtr)(void *cookie), void *inkeyFuncCookie,
word *timerPtr);
// Changes the current window.
//
void gimeterm_setWindow(const gimeterm_Window *state);
// Copies the state of the current window into the designated object.
//
void gimeterm_getWindow(gimeterm_Window *dest);
// Fills the window defined by gimeterm_init() with spaces and the 'textAttribute'
// passed to gimeterm_init().
// Does not move the cursor.
//
void gimeterm_clear(void);
// column, row: Coordinates relative to the window defined by gimeterm_init().
// Does not check if the parameters are valid.
// This may be useful to write outside the window, as long as no carriage return is written.
//
void gimeterm_locate(byte column, byte row);
// column, row: Receive coordinates relative to the window defined by gimeterm_init().
//
void gimeterm_getCursorPos(byte *column, byte *row);
// CAUTION: This function does NOT scroll when it reaches the end of the window.
// Character 13 does a carriage return and line feed AND clears
// the rest of the row it is applied to (with spaces and gimeterm_textAttribute).
// No other control code is supported.
//
// Returns FALSE if the cursor has fallen off the bottom of the window.
// The caller should scroll the window up and reposition the cursor.
//
BOOL gimeterm_putchar(int c);
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
//
BOOL gimeterm_print(const char *str);
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
//
BOOL gimeterm_printPrefix(const char *str, size_t prefixLength);
// Returns FALSE if the cursor has fallen off the bottom of the window.
// The caller should scroll the window up and reposition the cursor.
//
BOOL gimeterm_newline(void);
// Use inverted colors for the next print operations.
//
void gimeterm_invertColors(void);
void gimeterm_clrtoeol(void);
void gimeterm_scrollWindowUp(byte numRows);
void gimeterm_scrollWindowDown(byte numRows);
// Fills the line where the cursor is with spaces and puts the cursor at the start of this line.
//
void gimeterm_eraseCurrentLine(void);
// Animates a cursor while waiting.
// Returns an ASCII code or an ebitor_KEY_* code.
//
word gimeterm_waitEditorKey(void);
// The following functions are not part of the Ebitor terminal function set.
byte gimeterm_waitKey(void);
// Returns the attribute used up to now.
//
byte gimeterm_setTextAttribute(byte newAttribute);
// Returns the inverted text attribute used up to now.
//
byte gimeterm_setInvertedTextAttribute(byte newAttribute);
#endif /* _H_gimeterm */
+296
View File
@@ -0,0 +1,296 @@
/* os9term.c - OS-9 terminal functions.
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "os9term.h"
#include "Ebitor_private.h"
struct Ebitor;
static byte os9term_width, os9term_height;
static byte os9term_winLeftCol, os9term_winTopRow;
static byte os9term_cursorCol, os9term_cursorRow; // lower than os9term_winLeftCol, os9term_winTopRow
static byte (*os9term_waitKeyFuncPtr)(void *cookie); // blocks until key available
static void *os9term_waitKeyFuncCookie; // argument passed to sg4term_inkeyFuncPtr
// Changes the OS-9 terminal's working area.
// Sends the CWArea sequence to standard output.
// Source: "NitrOS-9 EOU Level 2 Windowing System Manual".
// Only works in 40- and 80-column modes.
// This puts the OS-9 terminal cursor at the home position of the window.
//
static void
setWorkingAreaExtraHeight(byte increment)
{
byte buf[] = { 0x1B, 0x25, os9term_winLeftCol, os9term_winTopRow, os9term_width, os9term_height + increment };
putstr((char *) buf, sizeof(buf));
}
void
os9term_clear(void)
{
byte c, r;
os9term_getCursorPos(&c, &r);
// Tell OS-9 to work in a window that only contains the text editing area, not the status line.
// This way, the status line does not get cleared.
setWorkingAreaExtraHeight(0);
putchar(12);
// Restore the OS-9 window that includes the status line.
setWorkingAreaExtraHeight(1);
os9term_locate(c, r);
}
asm byte *
os9term_get32x16ScreenBuffer(void)
{
asm
{
pshs y ; protect global variable segment pointer
lda #1 ; path number
ldb #$1C ; SS.AlfaS (Return Alfa Display Status)
os9 $8D ; I$GetStt
bcs @error
tfr x,d ; return screen buffer address in D
bra @done
@error
clra ; return 0 in D
clrb
@done
puls y
}
}
asm byte
os9term_getGIMEScreenType(byte *screenTypeCode)
{
asm
{
lda #1 ; path number
ldb #$93 ; SS.ScTyp: Returns the type of a screen to a calling program
os9 $8D ; I$GetStt
bcs @error
clrb
sta [2,s] ; put code in *screenTypeCode
@error
; Error code returned in B, as per CMOC calling convention.
}
}
byte
os9term_init(byte width, byte height,
byte winLeftCol, byte winTopRow,
byte (*waitKeyFuncPtr)(void *), void *waitKeyFuncCookie)
{
os9term_width = width;
os9term_height = height;
os9term_winLeftCol = winLeftCol;
os9term_winTopRow = winTopRow;
os9term_cursorCol = 0;
os9term_cursorRow = 0;
os9term_waitKeyFuncPtr = waitKeyFuncPtr;
os9term_waitKeyFuncCookie = waitKeyFuncCookie;
return 0; // success
}
void
os9term_locate(byte column, byte row)
{
char str[] = { 2, 32 + column, 32 + row };
putstr(str, sizeof(str));
os9term_cursorCol = column;
os9term_cursorRow = row;
}
void
os9term_getCursorPos(byte *column, byte *row)
{
*column = os9term_cursorCol;
*row = os9term_cursorRow;
}
// Character 13 does a carriage return and line feed AND clears
// the rest of the row it is applied to (with spaces).
// No other control code is supported.
// Updates os9term_cursorCol and os9term_cursorRow.
//
static BOOL
os9term_putchar(int c) //FIXME: Does not check against window height. Should return FALSE. See gimeterm.c.
{
if (c == '\r')
{
os9term_cursorCol = 0;
++os9term_cursorRow;
putchar(4); // clears to end of line
}
else
{
++os9term_cursorCol;
if (os9term_cursorCol >= os9term_width)
{
os9term_cursorCol = 0;
if (os9term_cursorRow < os9term_height - 1)
++os9term_cursorRow;
}
}
putchar((char) c);
return TRUE;
}
BOOL
os9term_print(const char *str)
{
for ( ; *str; ++str)
if (!os9term_putchar(*str))
return FALSE; // reached end of window
return TRUE;
}
BOOL
os9term_printPrefix(const char *str, size_t prefixLength)
{
for (size_t i = 0; i < prefixLength; ++i)
if (!os9term_putchar(str[i]))
return FALSE; // reached end of window
return TRUE;
}
void
os9term_invertColors(void)
{
// Not supported.
}
// Does not move the cursor.
//
void
os9term_clrtoeol(void)
{
for (byte c = os9term_cursorCol; c < os9term_width; ++c)
putchar(' ');
}
void
os9term_scrollWindowUp(byte numRows)
{
if (numRows == 0)
return;
// Tell OS-9 to work in a window that only contains the text editing area, not the status line.
// This way, the status line does not get scrolled up.
setWorkingAreaExtraHeight(0);
// Move cursor to bottom row if not already on that row.
char goBottom[] = { 2, 32, (32 - 1) + os9term_height };
putstr(goBottom, sizeof(goBottom));
for ( ; numRows--; )
putchar(10); // cursor down
// Restore the OS-9 window that includes the status line.
setWorkingAreaExtraHeight(1);
// Restore original cursor position.
char restore[] = { 2, 32 + os9term_cursorCol, 32 + os9term_cursorRow };
putstr(restore, sizeof(restore));
}
void
os9term_scrollWindowDown(byte numRows)
{
if (numRows == 0)
return;
// Tell OS-9 to work in a window that only contains the text editing area, not the status line.
// This way, the status line does not get scrolled down.
// This puts the OS-9 cursor at the home position.
setWorkingAreaExtraHeight(0);
for ( ; numRows--; )
putstr("\x1F\x30", 2); // insert line, scroll the following lines down
// Restore the OS-9 window that includes the status line.
setWorkingAreaExtraHeight(1);
// Restore original cursor position.
char restore[] = { 2, 32 + os9term_cursorCol, 32 + os9term_cursorRow };
putstr(restore, sizeof(restore));
}
void
os9term_eraseCurrentLine(void)
{
putchar(3);
}
word
os9term_waitEditorKey(void)
{
for (;;)
{
byte key = (*os9term_waitKeyFuncPtr)(os9term_waitKeyFuncCookie);
switch (key)
{
case 177: // F1
// N.B.: If 'key' is 123 when pressing F1, it may be because
// the BControl library has been compiled for DECB
// instead of OS-9. In that case, recompile it by
// passing TARGET=os9 to make.
return ebitor_KEY_ESCAPE;
case 8: // left arrow
return ebitor_KEY_ARROW_LEFT;
case 9: // right arrow
return ebitor_KEY_ARROW_RIGHT;
case 12: // up arrow
return ebitor_KEY_ARROW_UP;
case 10: // down arrow
return ebitor_KEY_ARROW_DOWN;
case 16: // Ctrl-Left
return '\b'; // backspace
case 13: // Enter
return '\r';
default:
if (key >= ' ' && key != 127) // if not control char (127 = Delete)
return key;
}
}
}
+111
View File
@@ -0,0 +1,111 @@
/* os9term.h - OS-9 terminal functions.
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
These functions implement a terminal compliant with the specs in Ebitor.h.
*/
#ifndef _H_os9term
#define _H_os9term
#include "Window.h"
// Returns the address of the 32x16 screen buffer is standard out
// is current in that mode. Otherwise, returns NULL.
//
byte *os9term_get32x16ScreenBuffer(void);
// Returns an OS-9 error code upon failure, or 0 upon success
// (*screenTypeCode is then 1, 2 or 5..8).
// Suitable to be called when the terminal uses a GIME mode.
// Returns error code 208 when run in a 32x16 terminal.
//
byte os9term_getGIMEScreenType(byte *screenTypeCode);
// Defines a window in an OS-9 terminal.
//
// Assumes that there is an extra row below the designated window.
// For example, on a 40x25 screen, the window would be (40, 24, 0, 0),
// and the 25th row would be the status line.
//
// Does NOT clear the window (see os9term_clear()).
//
// width, height: Dimensions in characters of the window.
// winLeftCol, winTopRow: Zero-based coordinates of the top left of the window.
// waitKeyFuncPtr: Pointer to a function that waits until a key is pressed and
// returns its ASCII code, e.g., 65 for 'A', 12 for the up arrow.
// waitKeyFuncCookie: Value to be passed to (*waitKeyFuncPtr)().
//
// Returns 0 upon success, or an error code upon failure:
// 1: Terminal type not supported (e.g., the current terminal is 32x16).
// 2: Failed to determine is the screen is a GIME text screen.
// 3: The screen is in a GIME mode but not in a 40- or 80-column mode.
//
byte os9term_init(byte width, byte height,
byte winLeftCol, byte winTopRow,
byte (*waitKeyFuncPtr)(void *), void *waitKeyFuncCookie);
// Must be called before leaving the process.
//
void os9term_shutdown(void);
// Fills the window defined by os9term_init() with spaces.
// Does not move the cursor.
//
void os9term_clear(void);
// column, row: Coordinates relative to the window defined by os9term_init().
// Does not check if the parameters are valid.
// This may be useful to write outside the window, as long as no carriage return is written.
//
void os9term_locate(byte column, byte row);
// column, row: Receive coordinates relative to the window defined by os9term_init().
//
void os9term_getCursorPos(byte *column, byte *row);
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
//
BOOL os9term_print(const char *str);
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
//
BOOL os9term_printPrefix(const char *str, size_t prefixLength);
// Use inverted colors for the next print operations.
//
void os9term_invertColors(void);
void os9term_clrtoeol(void);
void os9term_scrollWindowUp(byte numRows);
void os9term_scrollWindowDown(byte numRows);
// Fills the line where the cursor is with spaces and puts the cursor at the start of this line.
//
void os9term_eraseCurrentLine(void);
// Returns an ASCII code or an ebitor_KEY_* code.
//
word os9term_waitEditorKey(void);
#endif /* _H_os9term */
+109
View File
@@ -0,0 +1,109 @@
/* processBackspace.c
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Ebitor_private.h"
void
Ebitor_processBackspace(byte cursorCol, byte cursorRow)
{
Ebitor_startCommandMode();
// This check must be done after Ebitor_startCommandMode(), which can update cursorOffset
if (Ebitor_instance.cursorOffset == 0) // if at start of edit buffer
return; // nothing to do
size_t solOffset = Ebitor_findSOL(Ebitor_instance.cursorOffset);
size_t eolOffset = Ebitor_findEOL(Ebitor_instance.cursorOffset);
// E.g.: ...ABCDEF..............FOOBAR
// ^ ^ ^ ^bufferFilledSize
// | | `eolOffset
// | `cursorOffset
// `solOffset
// Print rest of line at preceding position.
//
BOOL erasingPrevCR = (cursorCol == 0);
if (!erasingPrevCR)
{
--cursorCol;
}
else // at column 0:
{
if (Ebitor_instance.cursorOffset == solOffset) // if at start of logical line
{
// About to erase previous line's terminator.
assert(Ebitor_instance.bufferBegin[solOffset - 1] == '\r'); // b/c cursorOffset > 0, there must be a line before
size_t prevSOLOffset = Ebitor_findPreviousSOL(solOffset);
assert(prevSOLOffset < solOffset);
size_t prevLineLen = solOffset - prevSOLOffset - 1; // exclude \r
cursorCol = (byte) (prevLineLen % Ebitor_instance.termWidth); // after last char of previous line
if (cursorRow == 0)
{
Ebitor_instance.scrollTerminalDown(1);
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + (solOffset - 1 - prevLineLen), prevLineLen);
}
else
--cursorRow;
}
else // inside a logical line:
{
cursorCol = Ebitor_instance.termWidth - 1;
if (cursorRow == 0)
{
Ebitor_instance.scrollTerminalDown(1);
Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + (Ebitor_instance.cursorOffset - Ebitor_instance.termWidth), Ebitor_instance.termWidth);
}
else
--cursorRow;
}
}
assert(cursorRow < Ebitor_instance.termHeight);
Ebitor_instance.locate(cursorCol, cursorRow);
char *cursorPtr = Ebitor_instance.bufferBegin + Ebitor_instance.cursorOffset;
assert(Ebitor_instance.cursorOffset <= eolOffset);
size_t numCharsToPrint = eolOffset - Ebitor_instance.cursorOffset;
if (Ebitor_instance.printPrefix(cursorPtr, numCharsToPrint))
{
// We have not reached the end of the window.
Ebitor_instance.clrtoeol(); // erase last char of logical line
if (erasingPrevCR)
{
// Print the lines that follow the cursor row.
// This will make a new line visible at the bottom, if the text is long enough.
// TODO: This might be optimized by only writing the bottom row.
//
size_t firstLogicalCharOffsetToPrint = (eolOffset == Ebitor_instance.bufferFilledSize ? eolOffset : eolOffset + 1);
byte dummy, r;
Ebitor_instance.getCursorPos(&dummy, &r);
Ebitor_fillTerminalToBottom(firstLogicalCharOffsetToPrint, r + 1);
}
}
Ebitor_instance.locate(cursorCol, cursorRow);
memmove(cursorPtr - 1, cursorPtr, Ebitor_instance.bufferFilledSize - Ebitor_instance.cursorOffset);
--Ebitor_instance.cursorOffset;
--Ebitor_instance.bufferFilledSize;
}
+110
View File
@@ -0,0 +1,110 @@
/* processPrintableChar.c
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Ebitor_private.h"
void
Ebitor_processPrintableChar(word key, byte cursorCol, byte cursorRow)
{
if (key < 256)
{
// Reject if no room in edit buffer.
//
if (Ebitor_instance.bufferFilledSize + Ebitor_instance.insertBuffer.size + 1 > Ebitor_instance.bufferEnd - Ebitor_instance.bufferBegin)
return;
size_t eolOffset = Ebitor_findEOL(Ebitor_instance.cursorOffset);
// eolOffset either designates a \r, or the end of the filled edit buffer.
// If the character is about to be printed on the last row, check if scrolling up is needed.
// Count the number of times a printable character will be printed in the last window column
// plus the number of carriage returns that will be printed, when printing the rest of the
// affected line.
// If a scroll is done, the cursor is moved one row up.
//
if (cursorRow == Ebitor_instance.termHeight - 1)
{
BOOL needScroll = FALSE;
byte col = cursorCol;
++col; // cursor position after printing 'key'
if (col == Ebitor_instance.termWidth) // if past last column
needScroll = TRUE;
const char *p = Ebitor_instance.bufferBegin + Ebitor_instance.cursorOffset;
const char *end = Ebitor_instance.bufferBegin + eolOffset;
//locate(0, 8); printf("[%u,%u]", Ebitor_instance.cursorOffset, eolOffset);
for ( ; p < end; ++p)
{
if (*p == '\r')
{
col = 0;
needScroll = TRUE;
}
else // *p is printable
{
++col;
if (col == Ebitor_instance.termWidth)
needScroll = TRUE;
}
}
if (needScroll)
{
Ebitor_instance.scrollTerminalUp(1);
--cursorRow;
assert(cursorRow >= 0);
assert(cursorRow < Ebitor_instance.termHeight);
Ebitor_instance.locate(cursorCol, cursorRow);
}
}
// Print the character just typed.
//
char c = (char) key;
Ebitor_instance.printPrefix(&c, 1);
// Reprint the rest of the line, if any, while preserving the new cursor position.
//
size_t lenRest = eolOffset - Ebitor_instance.cursorOffset;
if (lenRest > 0)
{
Ebitor_instance.getCursorPos(&cursorCol, &cursorRow);
assert(cursorRow < Ebitor_instance.termHeight);
if (Ebitor_instance.printPrefix(Ebitor_instance.bufferBegin + Ebitor_instance.cursorOffset, lenRest))
{
// We did not reach the end of the window.
byte afterPrintCol, afterPrintRow;
Ebitor_instance.getCursorPos(&afterPrintCol, &afterPrintRow);
if (afterPrintCol == 0) // if printing ends at column 0
{
Ebitor_instance.print("\r"); // show an empty row
if (eolOffset < Ebitor_instance.bufferFilledSize // if something after current EOL
&& afterPrintRow + 1 < Ebitor_instance.termHeight) // and there is room in the terminal window
Ebitor_fillTerminalToBottom(eolOffset + 1, afterPrintRow + 1);
}
}
Ebitor_instance.locate(cursorCol, cursorRow);
}
// Ebitor_instance.cursorOffset is not incremented here b/c 'c' is only
// added to the insert buffer. When the latter will be moved
// to the edit buffer, Ebitor_instance.cursorOffset will be incremented.
//
Ebitor_insertChar(c);
}
}
+104
View File
@@ -0,0 +1,104 @@
/* scrollToShowLogicalOffset.c
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Ebitor_private.h"
void
Ebitor_scrollToShowLogicalOffset(size_t logicalOffsetToShow, size_t lengthToShow)
{
Ebitor *self = &Ebitor_instance;
byte cursorCol = self->savedCursorCol, cursorRow = self->savedCursorRow;
size_t homeOffset, firstOffWindowOffset;
char code = Ebitor_isRegionVisible(logicalOffsetToShow, lengthToShow, cursorCol, cursorRow,
&homeOffset, &firstOffWindowOffset);
//printf("(%u,%u,%u->CODE=%d,HO=%u,F=%u)",
// logicalOffsetToShow, cursorCol, cursorRow, code, homeOffset, firstOffWindowOffset);
if (code < 0) // if region to show is before displayed text
{
size_t logicalOffsetAtStartOfTermRow;
size_t numTermRows = Ebitor_countRowsToScrollDown(logicalOffsetToShow, homeOffset, &logicalOffsetAtStartOfTermRow);
assert(numTermRows > 0);
if (numTermRows < self->termHeight) // if NOT scrolling all current rows off
{
assert(logicalOffsetAtStartOfTermRow <= logicalOffsetToShow);
assert(logicalOffsetToShow - logicalOffsetAtStartOfTermRow < self->termWidth);
self->scrollTerminalDown((byte) numTermRows);
}
else // redraw whole window
numTermRows = self->termHeight;
Ebitor_fillWindowFromHomeToRow(logicalOffsetAtStartOfTermRow, (byte) numTermRows);
byte cursorCol = (byte) (logicalOffsetToShow - logicalOffsetAtStartOfTermRow);
Ebitor_locateAndSavePos(cursorCol, 0);
}
else if (code > 0) // region to show is after displayed text
{
size_t numTermRows = Ebitor_countRowsToScrollUp(logicalOffsetToShow, firstOffWindowOffset);
assert(numTermRows > 0);
if (numTermRows < self->termHeight) // if NOT scrolling all current rows off
{
self->scrollTerminalUp((byte) numTermRows);
Ebitor_fillTerminalToBottom(firstOffWindowOffset, self->termHeight - (byte) numTermRows);
}
else // redraw whole window
{
size_t newHomeOffset = Ebitor_goDownRows(homeOffset, numTermRows);
assert(newHomeOffset <= self->bufferFilledSize);
Ebitor_fillWindowFromHomeToRow(newHomeOffset, self->termHeight);
}
size_t solOffset = Ebitor_findSOL(logicalOffsetToShow);
byte cursorCol = (byte) ((logicalOffsetToShow - solOffset) % self->termWidth);
Ebitor_locateAndSavePos(cursorCol, self->termHeight - 1);
}
else // code == 0: region is complete in displayed text
{
// Locate the cursor at logicalOffsetToShow.
byte cursorCol = 0, cursorRow = 0; // position of homeOffset
size_t offset = homeOffset;
for (;;)
{
// Here, offset is in column 0 of the terminal.
//
size_t eolOffset = Ebitor_findEOL(offset);
if (logicalOffsetToShow <= eolOffset) // if target position is on current logical line
{
cursorCol = (byte) ((logicalOffsetToShow - offset) % self->termWidth);
cursorRow += (byte) ((logicalOffsetToShow - offset) / self->termWidth);
// No overflow possible b/c we know logicalOffsetToShow is on window
assert(cursorRow < self->termHeight);
Ebitor_locateAndSavePos(cursorCol, cursorRow);
break;
}
assert(eolOffset < self->bufferFilledSize); // b/c logicalOffsetToShow is after eolOffset
size_t numRowsInLine = (eolOffset - offset) / self->termWidth + 1;
assert(cursorRow + numRowsInLine < self->termHeight);
// No overflow possible b/c we know logicalOffsetToShow is on window
offset = eolOffset + 1; // go to char after \r; this char is at column 0
cursorRow += (byte) numRowsInLine;
}
}
self->cursorOffset = logicalOffsetToShow;
}
+318
View File
@@ -0,0 +1,318 @@
/* sg4term.c - CoCo 32x16 SG4 mode (6847) terminal functions.
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "sg4term.h"
#include "Ebitor_private.h"
enum
{
sg4term_SPACE_CODE = 0x60,
};
struct Ebitor;
static byte sg4term_width, sg4term_height; // max 32x16
static byte sg4term_winLeftCol, sg4term_winTopRow; // 0..31, 0..15
static char *sg4term_screenBuffer; // address of 32x16 screen buffer
static byte sg4term_cursorCol, sg4term_cursorRow; // lower than sg4term_winLeftCol, sg4term_winTopRow
static byte (*sg4term_inkeyFuncPtr)(void *cookie); // returns 0 if no key pressed
static void *sg4term_inkeyFuncCookie; // argument passed to sg4term_inkeyFuncPtr
static word *sg4term_timerPtr; // points to a word that gets incremented 60 times per second
static char sg4term_attributeInversionFlag;
static char *
getPosInWindow(byte col, byte row)
{
return sg4term_screenBuffer + ((word) (sg4term_winTopRow + row) << 5) + (sg4term_winLeftCol + col);
}
#define getCursorAddress() (getPosInWindow(sg4term_cursorCol, sg4term_cursorRow))
static void
sg4term_clearRowsAt(char *rowStartDest, byte numRows)
{
char value = sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag;
for (byte i = numRows; i--; rowStartDest += 32) // for each window row to clear
memset(rowStartDest, value, sg4term_width);
}
void
sg4term_clear(void)
{
sg4term_clearRowsAt(getPosInWindow(0, 0), sg4term_height);
}
void
sg4term_init(char *screenBuffer, const ebitor_Window *window,
byte (*inkeyFuncPtr)(void *), void *inkeyFuncCookie, word *timerPtr)
{
sg4term_screenBuffer = screenBuffer;
sg4term_width = window->width;
sg4term_height = window->height;
sg4term_winLeftCol = window->leftCol;
sg4term_winTopRow = window->topRow;
sg4term_cursorCol = window->cursorCol;
sg4term_cursorRow = window->cursorRow;
sg4term_inkeyFuncPtr = inkeyFuncPtr;
sg4term_inkeyFuncCookie = inkeyFuncCookie;
sg4term_timerPtr = timerPtr;
sg4term_attributeInversionFlag = 0;
}
void
sg4term_locate(byte column, byte row)
{
sg4term_cursorCol = column;
sg4term_cursorRow = row;
}
void
sg4term_getCursorPos(byte *column, byte *row)
{
*column = sg4term_cursorCol;
*row = sg4term_cursorRow;
}
static BOOL
sg4term_newline(void)
{
sg4term_cursorCol = 0; // back to start of window row
if (++sg4term_cursorRow >= sg4term_height)
{
--sg4term_cursorRow;
sg4term_cursorCol = 0; // back to start of last row (avoid writing outside window)
return FALSE; // reached end of window
}
return TRUE;
}
asm char
sg4term_convertASCIIToScreenByte(char c)
{
asm
{
ldb 3,s // low byte of 'c' (big endian)
cmpb #64
blo @typo // typographical char
cmpb #96
blo @done // upper-case letter
cmpb #128
bhs @done // graphical char
subb #96 // lower-case letter
bra @store
@typo
addb #64
@store
stb 3,s
@done
}
}
// CAUTION: This function does NOT scroll when it reaches the end of the window.
// Character 13 does a carriage return and line feed AND clears
// the rest of the row it is applied to (with spaces).
// No other control code is supported.
//
static BOOL
sg4term_putchar(int c)
{
char *cursor = getCursorAddress();
if (c == '\r')
{
char charToWrite = sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag;
for ( ; sg4term_cursorCol < sg4term_width; ++sg4term_cursorCol)
*cursor++ = charToWrite;
return sg4term_newline();
}
*cursor++ = sg4term_convertASCIIToScreenByte((char) c) ^ sg4term_attributeInversionFlag;
if (++sg4term_cursorCol >= sg4term_width) // if past end of window row
return sg4term_newline();
return TRUE;
}
BOOL
sg4term_print(const char *str)
{
for ( ; *str; ++str)
if (!sg4term_putchar(*str))
return FALSE; // reached end of window
return TRUE;
}
BOOL
sg4term_printPrefix(const char *str, size_t prefixLength)
{
for (size_t i = 0; i < prefixLength; ++i)
if (!sg4term_putchar(str[i]))
return FALSE; // reached end of window
return TRUE;
}
void
sg4term_invertColors(void)
{
sg4term_attributeInversionFlag ^= 0x40;
}
// Does not move the cursor.
//
void
sg4term_clrtoeol(void)
{
memset(getCursorAddress(), sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag, sg4term_width - sg4term_cursorCol);
}
void
sg4term_scrollWindowUp(byte numRows)
{
if (numRows == 0)
return;
char *rowStartDest = getPosInWindow(0, 0); // top window row
const char *rowStartSrc = rowStartDest + ((word) numRows << 5);
for (byte i = sg4term_height - numRows; i--; rowStartSrc += 32, rowStartDest += 32) // for each window row to scroll
memmove(rowStartDest, rowStartSrc, sg4term_width);
sg4term_clearRowsAt(rowStartDest, numRows);
}
void
sg4term_scrollWindowDown(byte numRows)
{
if (numRows == 0)
return;
char *rowStartDest = getPosInWindow(0, sg4term_height - 1); // bottom window row
const char *rowStartSrc = rowStartDest - ((word) numRows << 5);
for (byte i = sg4term_height - numRows; i--; rowStartSrc -= 32, rowStartDest -= 32) // for each window row to scroll
memmove(rowStartDest, rowStartSrc, sg4term_width);
byte c = sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag;
for (byte i = numRows; i--; rowStartDest -= 32) // for each window row to clear
memset(rowStartDest, c, sg4term_width);
}
void
sg4term_eraseCurrentLine(void)
{
memset(getPosInWindow(0, sg4term_cursorRow), sg4term_SPACE_CODE ^ sg4term_attributeInversionFlag, sg4term_width);
sg4term_cursorCol = 0;
}
word
sg4term_waitEditorKey(void)
{
char *cursor = getCursorAddress();
for (;;)
{
byte origByteOnScreen = *cursor;
// Wait for key with animated cursor if sg4term_timerPtr is not null.
// Otherwise, wait for key with inverted character at cursor.
byte key;
if (sg4term_timerPtr == NULL)
{
*cursor = origByteOnScreen ^ 0x40;
do
key = (*sg4term_inkeyFuncPtr)(sg4term_inkeyFuncCookie);
while (key == 0);
}
else
{
for (word startTime = *sg4term_timerPtr; ; )
{
key = (*sg4term_inkeyFuncPtr)(sg4term_inkeyFuncCookie);
if (key)
break;
*cursor = origByteOnScreen ^ (((*sg4term_timerPtr - startTime) & 0x38) == 0x38 ? 0x00 : 0x40);
}
}
*cursor = origByteOnScreen;
switch (key)
{
case 3: // Break
return ebitor_KEY_ESCAPE;
case 8: // left arrow
return ebitor_KEY_ARROW_LEFT;
case 9: // right arrow
return ebitor_KEY_ARROW_RIGHT;
case '^': // up arrow
return ebitor_KEY_ARROW_UP;
case 10: // down arrow
return ebitor_KEY_ARROW_DOWN;
case 12: // Clear used as backspace
return '\b'; // backspace
case 13: // Enter
return '\r';
default:
if (key >= ' ' && key != 127)
return key;
}
}
}
static char
sg4term_convertScreenByteToASCII(char b)
{
if ((byte) b >= 128)
return 0; // 128..255: no equivalent in ASCII
if (b < 32)
return b + 96;
if (b < 64) // 32..63
return 0; // no equivalent in ASCII
if (b < 96) // 64..95
return b;
return b - 64; // 96..127
}
void
sg4term_getChars(byte column, byte row, char *dest, size_t len)
{
assert(column < sg4term_width && row < sg4term_height);
const char *p = getPosInWindow(column, row);
for (size_t i = len; i--; )
*dest++ = sg4term_convertScreenByteToASCII(*p++);
}
+95
View File
@@ -0,0 +1,95 @@
/* sg4term.h - CoCo 32x16 SG4 mode (6847) terminal functions.
Copyright (C) 2021-2025 Pierre Sarrazin <http://sarrazip.com/>
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 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
These functions implement a terminal compliant with the specs in Ebitor.h
in a sub-window of a CoCo 32x16 screen (SG4 mode).
*/
#ifndef _H_sg4term
#define _H_sg4term
#include "Window.h"
// Defines a window in a 6847 screen in 32x16 (SG4) mode.
// Does NOT clear the window.
// screenBuffer: Address of the 32x16 screen.
// width: 2..32.
// height: 2..16.
// winLeftCol: 0..30.
// winTopRow: 0..14.
// inkeyFuncPtr: Must return 0 (and not block) if no key pressed.
// inkeyFuncCookie: Will be passed to inkeyFuncPtr.
// timerPtr: Address of an unsigned 16-bit integer that gets incremented 60 times per second.
// If NULL, the cursor will not be animated.
//
void sg4term_init(char *screenBuffer, const ebitor_Window *window,
byte (*inkeyFuncPtr)(void *cookie), void *inkeyFuncCookie, word *timerPtr);
// Fills the window defined by sg4term_init() with spaces.
//
void sg4term_clear(void);
// column, row: Coordinates relative to the window defined by sg4term_init().
// Does not check if the parameters are valid.
// This may be useful to write outside the window, as long as no carriage return is written.
//
void sg4term_locate(byte column, byte row);
// column, row: Receive coordinates relative to the window defined by sg4term_init().
//
void sg4term_getCursorPos(byte *column, byte *row);
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
//
BOOL sg4term_print(const char *str);
// Returns FALSE the string could not be printed entirely because the printing reached end of window.
//
BOOL sg4term_printPrefix(const char *str, size_t prefixLength);
// Use inverted colors for the next print operations.
//
void sg4term_invertColors(void);
void sg4term_clrtoeol(void);
void sg4term_scrollWindowUp(byte numRows);
void sg4term_scrollWindowDown(byte numRows);
// Fills the line where the cursor is with spaces and puts the cursor at the start of this line.
//
void sg4term_eraseCurrentLine(void);
// Animates a cursor while waiting.
// Returns an ASCII code or an ebitor_KEY_* code.
//
word sg4term_waitEditorKey(void);
// Converts an ASCII code to a 6847 SG4 character code.
// Negative codes (graphics characters) are returned unmodified.
//
char sg4term_convertASCIIToScreenByte(char c);
// Returns ASCII codes in dest[0..len-1]. Does nothing if len is 0.
//
void sg4term_getChars(byte column, byte row, char *dest, size_t len);
#endif /* _H_sg4term */
+153
View File
@@ -0,0 +1,153 @@
/* smoldemo.c - Minimal demo of the Ebitor full screen text editor.
By Pierre Sarrazin <http://sarrazip.com/>
This file is in the public domain.
*/
#include "sg4term.h" /* 32x16 terminal to be used by the editor */
#include "Ebitor.h" /* the editor */
#include <assert.h>
///////////////////////////////////////////////////////////////
enum
{
BASIC_TIMER_ADDRESS = 0x112, // incremented 60 times per second by Basic IRQ routine
BASIC_32X16_SCREEN = 0x0400, // address of 32x16 screen buffer
};
// Contains the edited text.
//
char textBuffer[600];
// newStatus: Must be shorter than the terminal width.
// Does not move the terminal cursor.
//
static void
setStatus(const ebitor_Window *window, const char *newStatus)
{
byte origCursorCol, origCursorRow;
sg4term_getCursorPos(&origCursorCol, &origCursorRow);
sg4term_locate(0, window->height); // cursor deliberately on row below window
sg4term_invertColors();
sg4term_eraseCurrentLine(); // also puts cursor at start of line
sg4term_print(newStatus);
sg4term_invertColors();
sg4term_locate(origCursorCol, origCursorRow);
}
static void
showHelp(const ebitor_Window *window)
{
sg4term_clear();
setStatus(window, "HELP PAGE");
sg4term_locate(0, 0);
sg4term_print(
"BACKSPACE IS THE CLEAR KEY.\r"
"\r"
"COMMANDS AFTER PRESSING BREAK:"
"\r"
"Q: QUIT THIS EDITOR\r"
"H: SHOW THIS HELP PAGE\r"
"\r"
"PRESS A KEY TO CONTINUE: ");
sg4term_waitEditorKey();
}
static byte
inkey1(void *cookie)
{
return inkey();
}
// Does not animate a cursor.
//
byte
waitUpperCaseKey(void)
{
byte key;
while ((key = (byte) toupper(inkey())) == 0)
;
return key;
}
int
main()
{
width(32); // on a CoCo 3, switches to 32x16 if not already in that mode
rgb(); // on a CoCo 3, resets the palette in case it is not at the default
ebitor_Window window;
window.cursorCol = window.cursorRow = 0;
// Specify a window for the editor.
// A border is left unused, to show that the sg4 driver
// can use a subwindow of the screen.
// Excludes the status line, which this demo renders below this window.
window.width = 32 - 2;
window.height = 16 - 3;
window.leftCol = 1;
window.topRow = 1;
width(32); // by SECB
cls(3);
sg4term_init((char *) BASIC_32X16_SCREEN, &window,
inkey1, NULL, (word *) BASIC_TIMER_ADDRESS);
Ebitor_init(textBuffer, sizeof(textBuffer),
window.width, window.height,
sg4term_clear,
sg4term_locate,
sg4term_getCursorPos,
sg4term_print,
sg4term_printPrefix,
sg4term_clrtoeol,
sg4term_scrollWindowUp,
sg4term_scrollWindowDown,
sg4term_waitEditorKey);
// Main editing loop.
//
for (BOOL refresh = TRUE, resetStatus = TRUE; ; )
{
if (resetStatus)
setStatus(&window, "PRESS BREAK FOR MENU");
else
resetStatus = TRUE;
Ebitor_processEditing(refresh);
refresh = FALSE;
setStatus(&window, "Q=QUIT, H=HELP");
byte key = waitUpperCaseKey();
if (key == 3) // if break key
continue; // back to processing
if (key == 'Q')
break; // quit
switch ((char) key)
{
case 'H':
showHelp(&window);
refresh = TRUE;
break;
}
}
Ebitor_shutdown();
cls(255); // equivalent to Basic's CLS command without an argument
printf("FINAL TEXT:\n\n%s\n", textBuffer);
return 0;
}