/* ebitdemo.c - Demo of the Ebitor full screen text editor.
By Pierre Sarrazin
This file is in the public domain.
The OS-9 version of this demo shows how to save the editor buffer to a file.
*/
#include "sg4term.h" /* 32x16 terminal to be used by the editor */
#include "gimeterm.h" /* 40/64/80x25 terminal to be used by the editor */
#include "Ebitor.h" /* the editor */
#include
#ifdef OS9
#include "Keyboard.h" /* bcontrol */
#include "os9term.h"
#define ESCAPE_KEY_NAME "F1" /* See os9term_waitEditorKey() in os9term.c. */
// Key codes.
enum
{
KEY_CODE_UP_ARROW = 12,
KEY_CODE_DOWN_ARROW = 10,
};
Keyboard keyboard;
// Keyboard_init() must have been called on 'keyboard'.
//
#define inkey() (Keyboard_poll(&keyboard))
byte
waitKeyOS9(void *cookie)
{
// A way to block while waiting, instead of polling repeatedly, would be good
// to save CPU time for other processes.
byte key;
do
key = inkey();
while (key == 0);
return key;
}
// Returns a screen mode (32, 40, 80), or 0 upon failure to determine the terminal type.
//
byte
determineOS9ScreenMode(void)
{
if (os9term_get32x16ScreenBuffer() != NULL) // if 32x16
return 32;
byte screenTypeCode;
byte err = os9term_getGIMEScreenType(&screenTypeCode);
if (err != 0)
return 0;
return screenTypeCode * 40;
}
#else /* not OS9: */
#define ESCAPE_KEY_NAME "BREAK"
// Key codes.
enum
{
KEY_CODE_UP_ARROW = '^',
KEY_CODE_DOWN_ARROW = 10,
};
#endif /* not OS9: */
///////////////////////////////////////////////////////////////
enum
{
BASIC_TIMER_ADDRESS = 0x112, // incremented 60 times per second by Basic IRQ routine
BASIC_32X16_SCREEN = 0x0400, // address of 32x16 screen buffer
// CoCo 3 only:
GIME_SCREEN_BLOCK = 0x36,
GIME_SCREEN_BUFFER = 0x6000, // in 64k addressable space; see setupCoCo3MMU()
GIME_SCREEN_VERT_OFFSET = GIME_SCREEN_BLOCK * 1024, // where screen is in 512k space (abs. addr. / 8)
GIME_EDITOR_BG_COLOR = 2,
DEFAULT_TEXT_ATTR = 3 * 8 + GIME_EDITOR_BG_COLOR, // foreground * 8 + background
INVERTED_TEXT_ATTR = 0 * 8 + 4,
};
// Function pointers that depend on the screen mode.
//
static ebitor_clear clearFunc;
static ebitor_locateFunc locateFunc;
static ebitor_printFunc printFunc;
static ebitor_waitKeyFunc waitKeyFunc;
static ebitor_getCursorPosFunc getCursorPosFunc;
static void (*invertColorsFunc)(void);
static void (*eraseCurrentLineFunc)(void);
// Contains the edited text.
//
char textBuffer[600];
typedef union WindowUnion
{
#ifdef _COCO_BASIC_
ebitor_Window sg4;
gimeterm_Window gime;
#elif defined(OS9)
ebitor_Window os9;
#endif
} WindowUnion;
#ifdef _COCO_BASIC_
// Sets the screen mode to a CoCo 3 text screen, with 25 rows.
// Clears the screen to spaces of the background color specified by bgColor.
// numColumns: 40, 64, 80.
// bgColor: CLS color number 1..8 for the screen background.
// borderColor: 0..63 color number.
//
static void
setGimeHiResTextMode(byte numColumns, byte bgColor, byte borderColor)
{
byte widthField;
switch (numColumns)
{
default:
case 40: widthField = 0x04; break;
case 64: widthField = 0x10; break;
case 80: widthField = 0x14; break;
}
* (byte *) 0xFF90 = 0x4C; // reset CoCo 2 compatible bit
* (byte *) 0xFF98 = 0x03; // text mode
* (byte *) 0xFF99 = 0x21 | widthField; // 200 lines per field,
// width specified by variable,
// 25 rows,
// color attributes enabled
* (byte *) 0xFF9A = borderColor;
* (word *) 0xFF9D = GIME_SCREEN_VERT_OFFSET;
memset16(GIME_SCREEN_BUFFER, 0x2000 | (bgColor - 1), numColumns * (word) 25);
}
#endif /* _COCO_BASIC_ */
// newStatus: Must be shorter than the terminal width.
// Does not move the terminal cursor.
//
static void
setStatus(const ebitor_Window *window, const char *newStatus)
{
assert(getCursorPosFunc < 0xFF00); // check for corruption of data segment
byte origCursorCol, origCursorRow;
(*getCursorPosFunc)(&origCursorCol, &origCursorRow);
(*locateFunc)(0, window->height); // cursor deliberately on row below window
(*invertColorsFunc)();
(*eraseCurrentLineFunc)(); // also puts cursor at start of line
(*printFunc)(newStatus);
(*invertColorsFunc)();
(*locateFunc)(origCursorCol, origCursorRow);
}
static void
showHelp(const ebitor_Window *window)
{
assert(window);
assert(clearFunc);
assert(locateFunc);
assert(printFunc);
assert(waitKeyFunc);
(*clearFunc)();
setStatus(window, "HELP PAGE");
(*locateFunc)(0, 0);
(*printFunc)(
"BACKSPACE IS "
#ifdef OS9
"CTRL+LEFT ARROW"
#else
"THE CLEAR KEY"
#endif
".\r"
"\r"
"AFTER PRESSING " ESCAPE_KEY_NAME ":\r"
"\r"
"F: FIND SOME TEXT\r"
"N: FIND THE NEXT OCCURRENCE\r"
" OF THE SEARCHED TEXT\r"
"UP/DOWN ARROW: PAGE UP/DOWN\r"
#ifdef OS9
"L: LOAD FROM A FILE\r"
"S: SAVE TO A FILE\r"
#endif
"Q: QUIT THIS EDITOR\r"
"H: SHOW THIS HELP PAGE\r"
"\r"
"PRESS A KEY TO CONTINUE: ");
(*waitKeyFunc)();
}
// Lets the user type a single line, displayed in inverted colors.
// Returns an ASCIIZ in dest[].
// The cursor is restored to its original position upon exit.
//
// fieldCol, fieldRow: Relative to the window (fieldRow allowed to be 1 row below window).
// maxLen: Maximum number of characters to accept;
// dest[] must have room for a subsequent NUL terminator.
// Returns TRUE if the user pressed Enter (then dest[] contains the entered ASCIIZ),
// or FALSE if the user pressed Break.
//
static BOOL
getLine(byte fieldCol, byte fieldRow, byte maxLen, char dest[])
{
byte origCursorCol, origCursorRow;
(*getCursorPosFunc)(&origCursorCol, &origCursorRow);
// Print the initial contents of dest[] to the screen field.
//
(*invertColorsFunc)();
(*locateFunc)(fieldCol, fieldRow);
(*printFunc)(dest);
byte writer = (byte) strlen(dest); // offset to end of string
word key;
for (;;)
{
key = (*waitKeyFunc)();
if (key == ebitor_KEY_ESCAPE)
break;
if (key == '\r') // Enter
break;
switch (key)
{
case '\b':
if (writer == 0)
break;
--writer;
(*locateFunc)(fieldCol + writer, fieldRow);
(*printFunc)(" ");
(*locateFunc)(fieldCol + writer, fieldRow);
break;
default:
// Add character if printable and there is still room.
if (key < 128 && (byte) key > 32 && (byte) key != 127 && writer < maxLen)
{
char keyString[2] = { (char) key, '\0' };
(*printFunc)(keyString);
dest[writer] = (char) key;
++writer;
}
}
}
(*invertColorsFunc)();
(*locateFunc)(origCursorCol, origCursorRow);
if (key == ebitor_KEY_ESCAPE)
return FALSE;
dest[writer] = '\0';
return TRUE;
}
static size_t searchStartOffset; // position where handleFind() starts searching for string
static size_t foundLogicalOffset; // position where handleFind() last found its target string
const char findPrompt[] = "FIND: ";
const char filenamePrompt[] = "FILENAME: ";
enum
{
MAX_WINDOW_WIDTH = 80, // of all screen modes supported by this demo
FIND_PROMPT_LEN = sizeof(findPrompt) - 1,
TARGET_STRING_MAX_LEN = MAX_WINDOW_WIDTH - FIND_PROMPT_LEN - 1, // leaves one column for the cursor
#ifdef OS9
FILENAME_PROMPT_LEN = sizeof(filenamePrompt) - 1,
FILENAME_MAX_LEN = MAX_WINDOW_WIDTH - FILENAME_PROMPT_LEN - 1, // leaves one column for the cursor
#endif
};
// These buffers are global so that the previously entered string is remembered
// the next find Find or Save is used.
// These buffers are initialized to all NULs before main().
//
static char strSearchedFor[TARGET_STRING_MAX_LEN + 1];
#ifdef OS9
static char filename[FILENAME_MAX_LEN + 1];
#endif
// Returns TRUE if this function set a status that should be left visible for the user.
// Reads findPrompt.
// Modifies searchStartOffset, strSearchedFor[].
//
static BOOL
handleFind(const ebitor_Window *window, BOOL newFind)
{
if (newFind)
{
setStatus(window, findPrompt);
if (!getLine(FIND_PROMPT_LEN, window->height, window->width - FIND_PROMPT_LEN - 1, strSearchedFor))
return FALSE;
searchStartOffset = Ebitor_getLogicalCursorOffset();
}
else
{
size_t curOffset = Ebitor_getLogicalCursorOffset();
if (curOffset == foundLogicalOffset) // if cursor did not move since last find
searchStartOffset = foundLogicalOffset + 1; // start "next find" after current find
else
searchStartOffset = curOffset; // cursor moved, so find "next" from new cursor pos
}
BOOL found = Ebitor_findStringAndScrollToShow(searchStartOffset, strSearchedFor, &foundLogicalOffset);
if (found)
{
setStatus(window, "FOUND");
return TRUE;
}
setStatus(window, "NOT FOUND");
return TRUE;
}
#ifdef OS9
byte
getOpenFileSize(unsigned char fd, unsigned long *sizeInBytes)
{
unsigned long tmp;
unsigned char errorCode;
asm
{
pshs u,y ; protect data segment pointer (Y) and frame pointer (U) against OS-9 call;
; cannot refer to local C vars when U modified
lda :fd ; path number
ldb #2 ; function code 2
os9 $8D ; I$GetStt
bcs @error
clrb
@error
tfr u,y ; save low word of file size in Y; free up U
ldu 2,s ; restore ability to refer to C local vars
stx :tmp[0] ; store high word of file size in local C var
sty :tmp[2] ; store low word
stb :errorCode
puls y,u ; restore Y, U already restored (discards the 4 bytes pushed)
}
if (errorCode == 0) // if success
*sizeInBytes = tmp;
return errorCode;
}
// filePath: Must end with '\r'.
// Returns an error code upon failure, 0 upon success.
// *errorPhase receives:
// 1 if error happened on file open;
// 2 on reading;
// 3 on closing;
// 4 if the file size could not be obtained;
// 5 if the file is too large for maxBufferLength.
// *numBytesRead receives the number of bytes effectively read, upon success.
// *fileSizeInBytes receives the file size upon success and error codes 2 to 5.
//
byte
loadFileToBuffer(const char *filePath, void *buffer, size_t maxBufferLength,
unsigned long *fileSizeInBytes, byte *errorPhase, size_t *numBytesRead)
{
unsigned char fd, errorCode;
// Open the file in read mode.
asm
{
lda #$01 ; A = read mode
ldx :filePath
os9 $84 ; I$Open
bcs @error
clrb
sta :fd
@error
stb :errorCode
}
if (errorCode != 0) // if open failed
{
*errorPhase = 1;
return errorCode;
}
errorCode = getOpenFileSize(fd, fileSizeInBytes);
if (errorCode != 0)
{
*errorPhase = 4;
return errorCode;
}
if (*fileSizeInBytes > maxBufferLength)
{
*errorPhase = 5;
return 207; // hack: return E$MemFul
}
// Load bytes from the file to the buffer.
*numBytesRead = 0;
asm
{
lda :fd ; path number
ldx :buffer ; address where to store the bytes
pshs y ; save global data ptr; cannot refer to globals for now
ldy :maxBufferLength ; number of bytes to read
os9 $89 ; I$Read
bcs @error
clrb
sty [:numBytesRead] ; store in *numBytesRead
@error
stb :errorCode
puls y ; restore global data ptr; can refer to globals again
}
if (errorCode != 0)
{
*errorPhase = 2;
// Do not return because we need to close the file.
}
unsigned char closeErrorCode;
asm
{
lda :fd ; path number
os9 $8F ; I$Close
bcs @error
clrb
@error
stb :closeErrorCode
}
if (errorCode != 0) // if read error
return errorCode;
if (closeErrorCode != 0)
{
*errorPhase = 3;
return closeErrorCode;
}
*errorPhase = 0; // success
return 0;
}
// Calls setStatus() before returning.
//
static void
loadFromFile(const ebitor_Window *window)
{
setStatus(window, filenamePrompt);
if (!getLine(FILENAME_PROMPT_LEN, window->height, window->width - FILENAME_PROMPT_LEN - 1, filename))
{
setStatus(window, "TEXT NOT LOADED");
return;
}
size_t filenameLen = strlen(filename);
filename[filenameLen] = '\r'; // terminator required by OS-9 I$Open
byte errorPhase;
unsigned long fileSizeInBytes;
size_t numBytesRead;
byte errorCode = loadFileToBuffer(filename, textBuffer, sizeof(textBuffer) - 1,
&fileSizeInBytes, &errorPhase, &numBytesRead);
filename[filenameLen] = '\0'; // restore terminator (required by next call to getLine())
char status[MAX_WINDOW_WIDTH];
if (errorCode != 0)
{
if (errorPhase == 4)
sprintf(status, "FAILED TO GET FILE SIZE");
else if (errorPhase == 5)
sprintf(status, "FILE TOO BIG (%lu VS MAX %u)", fileSizeInBytes, sizeof(textBuffer) - 1);
else
sprintf(status, "ERROR #%u WHEN %sING [%lu]",
errorCode,
errorPhase == 1 ? "OPEN" : (errorPhase == 2 ? "READ" : "CLOS"),
fileSizeInBytes);
}
else
{
sprintf(status, "READ ALL %u CHARACTERS", numBytesRead);
// Tell the editor that it now has text.
Ebitor_setContentLength(numBytesRead);
}
setStatus(window, status);
}
// filePath: Must end with '\r'.
// Returns an error code upon failure, 0 upon success.
// *errorPhase receives:
// 1 if error happened on file creation;
// 2 on reading;
// 3 on closing.
// *numBytesWritten receives the number of bytes effectively written, upon success.
//
byte
createFileFromBuffer(const char *filePath, const void *buffer, size_t bufferLength, byte *errorPhase, size_t *numBytesWritten)
{
unsigned char fd, errorCode;
asm
{
ldd #$0203 ; A = write mode; B = readable, writable, sharable
ldx :filePath
os9 $83 ; I$Create
bcs @error
clrb
sta :fd
@error
stb :errorCode
}
if (errorCode != 0)
{
*errorPhase = 1;
return errorCode;
}
*numBytesWritten = 0;
asm
{
lda :fd ; path number
ldx :buffer ; address of bytes to write
pshs y ; save global data ptr; cannot refer to globals for now
ldy :bufferLength ; number of bytes to write
os9 $8A ; I$Write
bcs @error
clrb
sty [:numBytesWritten] ; store in *numBytesWritten
@error
stb :errorCode
puls y ; restore global data ptr; can refer to globals again
}
if (errorCode != 0)
{
*errorPhase = 2;
// Do not return because we need to close the file.
}
unsigned char closeErrorCode;
asm
{
lda :fd ; path number
os9 $8F ; I$Close
bcs @error
clrb
@error
stb :closeErrorCode
}
if (errorCode != 0) // if write error
return errorCode;
if (closeErrorCode != 0)
{
*errorPhase = 3;
return closeErrorCode;
}
*errorPhase = 0; // success
return 0;
}
// Calls setStatus() before returning.
//
static void
saveToFile(const ebitor_Window *window)
{
setStatus(window, filenamePrompt);
if (!getLine(FILENAME_PROMPT_LEN, window->height, window->width - FILENAME_PROMPT_LEN - 1, filename))
{
setStatus(window, "TEXT NOT SAVED");
return;
}
//FIXME: Check if file already exists, prompt for overwrite.
setStatus(window, "SAVING...");
size_t saveFilenameLen = strlen(filename);
filename[saveFilenameLen] = '\r'; // terminator required by OS-9 I$Create
byte errorPhase;
size_t numBytesWritten;
byte errorCode = createFileFromBuffer(filename, textBuffer, Ebitor_getContentLength(), &errorPhase, &numBytesWritten);
filename[saveFilenameLen] = '\0'; // restore terminator (required by next call to getLine())
char status[MAX_WINDOW_WIDTH];
if (errorCode != 0)
sprintf(status, "SAVE FAILED: ERROR #%u WHEN %sING",
errorCode,
errorPhase == 1 ? "CREAT" : (errorPhase == 2 ? "WRIT" : "CLOS"));
else if (numBytesWritten != Ebitor_getContentLength())
sprintf(status, "FAILED: WROTE %u of %u", numBytesWritten, Ebitor_getContentLength());
else
sprintf(status, "WROTE ALL %u CHARACTERS", numBytesWritten);
setStatus(window, status);
}
#endif /* OS9 */
#ifdef _COCO_BASIC_
static byte
inkey1(void *cookie)
{
return inkey();
}
#ifndef NDEBUG /* Condition need to avoid warning on failedAssertHandler_gime() not getting called. */
static void
failedAssertHandler_gime(const char *file, int lineno, const char *condition)
{
char temp[256];
sprintf(temp, "[ASSERT FAILED at %s:%d: %s]", file, lineno, condition);
gimeterm_locate(0, 0);
gimeterm_print(temp);
for (;;)
;
}
#endif
#endif
// screenMode: Must be 32, 40, 64 or 80.
// window: Pointer to an object that gets filled with the definition of
// the text window.
// Must be the appropriate ebitor_Window field of *windowUnion.
// Returns TRUE upon success.
// Fills globals, locateFunc, getCursorPosFunc, etc.
//
static BOOL
initEbitor(byte screenMode, WindowUnion *windowUnion, ebitor_Window *window)
{
window->cursorCol = window->cursorRow = 0;
// Specify a window for the editor.
// Excludes the status line, which this demo renders below this window.
//
#ifdef _COCO_BASIC_
byte numRows = screenMode == 32 ? 16 : 25;
// A border is left unused, to show that the sg4 and gime drivers
// can use a subwindow of the screen.
window->width = screenMode - 2;
window->height = numRows - 3;
window->leftCol = 1;
window->topRow = 1;
if (screenMode != 32)
{
if (!isCoCo3)
{
printf("MODE %u NOT SUPPORTED ON A COCO 1 OR 2\n", screenMode);
return FALSE;
}
windowUnion->gime.textAttribute = DEFAULT_TEXT_ATTR;
windowUnion->gime.invertedTextAttribute = INVERTED_TEXT_ATTR;
}
switch (screenMode)
{
case 32:
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,
clearFunc = sg4term_clear,
locateFunc = sg4term_locate,
getCursorPosFunc = sg4term_getCursorPos,
printFunc = sg4term_print,
sg4term_printPrefix,
sg4term_clrtoeol,
sg4term_scrollWindowUp,
sg4term_scrollWindowDown,
waitKeyFunc = sg4term_waitEditorKey);
invertColorsFunc = sg4term_invertColors;
eraseCurrentLineFunc = sg4term_eraseCurrentLine;
return TRUE;
case 40:
case 64:
case 80:
setGimeHiResTextMode(screenMode, 8, 7);
gimeterm_init(GIME_SCREEN_BUFFER, screenMode, &windowUnion->gime,
inkey1, NULL, (word *) BASIC_TIMER_ADDRESS);
_SetFailedAssertHandler(failedAssertHandler_gime);
Ebitor_init(textBuffer, sizeof(textBuffer),
window->width, window->height,
clearFunc = gimeterm_clear,
locateFunc = gimeterm_locate,
getCursorPosFunc = gimeterm_getCursorPos,
printFunc = gimeterm_print,
gimeterm_printPrefix,
gimeterm_clrtoeol,
gimeterm_scrollWindowUp,
gimeterm_scrollWindowDown,
waitKeyFunc = gimeterm_waitEditorKey);
invertColorsFunc = gimeterm_invertColors;
eraseCurrentLineFunc = gimeterm_eraseCurrentLine;
return TRUE;
default:
printf("UNSUPPORTED SCREEN MODE %u\n", screenMode);
return FALSE;
}
#elif defined(OS9)
window->width = screenMode;
window->height = 24;
window->leftCol = 0;
window->topRow = 0;
byte err = os9term_init(window->width, window->height,
window->leftCol, window->topRow,
waitKeyOS9, NULL);
if (err != 0)
{
printf("Failed to initialize support for this terminal: error #%u.\n", err);
return FALSE;
}
Ebitor_init(textBuffer, sizeof(textBuffer),
window->width, window->height,
clearFunc = os9term_clear,
locateFunc = os9term_locate,
getCursorPosFunc = os9term_getCursorPos,
printFunc = os9term_print,
os9term_printPrefix,
os9term_clrtoeol,
os9term_scrollWindowUp,
os9term_scrollWindowDown,
waitKeyFunc = os9term_waitEditorKey);
invertColorsFunc = os9term_invertColors;
eraseCurrentLineFunc = os9term_eraseCurrentLine;
return TRUE;
#endif
}
// Does not animate a cursor.
//
byte
waitUpperCaseKey(void)
{
byte key;
while ((key = (byte) toupper(inkey())) == 0)
;
return key;
}
BOOL
askConfirmation(const ebitor_Window *window)
{
setStatus(window, "REALLY QUIT? (Y/N)");
byte key = waitUpperCaseKey();
return key == 'Y';
}
BOOL
work(byte screenMode)
{
Ebitor *editor = Ebitor_getInstance();
WindowUnion windowUnion;
ebitor_Window *window =
#ifdef _COCO_BASIC_
(screenMode == 32 ? &windowUnion.sg4 : &windowUnion.gime.window)
#elif defined(OS9)
&windowUnion.os9
#endif
;
if (!initEbitor(screenMode, &windowUnion, window))
return FALSE;
// Main editing loop.
//
for (BOOL refresh = TRUE, resetStatus = TRUE; ; )
{
if (resetStatus)
setStatus(window, "PRESS " ESCAPE_KEY_NAME " FOR MENU");
else
resetStatus = TRUE;
Ebitor_processEditing(refresh);
refresh = FALSE;
setStatus(window, "F=FIND, Q=QUIT, H=HELP");
byte key = waitUpperCaseKey();
if (key == 3) // "escape" key
continue; // back to processing
if (key == 'Q')
{
if (askConfirmation(window))
break; // quit
continue; // back to processing
}
switch ((char) key)
{
case KEY_CODE_UP_ARROW:
Ebitor_processUpOrDownArrowsAndRefresh(TRUE, window->height);
break;
case KEY_CODE_DOWN_ARROW:
Ebitor_processUpOrDownArrowsAndRefresh(FALSE, window->height);
break;
case 'F':
resetStatus = ! handleFind(window, TRUE);
break;
case 'N':
resetStatus = ! handleFind(window, FALSE);
break;
#ifdef OS9
case 'L':
loadFromFile(window);
refresh = TRUE;
resetStatus = FALSE;
break;
case 'S':
saveToFile(window);
resetStatus = FALSE;
break;
#endif
case 'H':
showHelp(window);
refresh = TRUE;
break;
}
}
Ebitor_shutdown();
return TRUE;
}
#ifdef _COCO_BASIC_
void
delay(unsigned ticks)
{
for (unsigned limit = getTimer() + ticks; getTimer() != limit; )
;
}
// Returns 32, 40, 64, 80.
//
byte
chooseScreenMode(void)
{
printf("[3] 32X16\n"
"[4] 40X25\n"
"[6] 64X25\n"
"[8] 80X25\n"
"MODE? ");
for (;;)
{
byte screenMode;
word key = waitkey(TRUE);
switch (key)
{
case '3': screenMode = 32; break;
case '4': screenMode = 40; break;
case '6': screenMode = 64; break;
case '8': screenMode = 80; break;
default: key = 0;
}
if (key == 0) // if invalid response
continue;
printf("%c\n", (char) key);
delay(30);
return screenMode;
}
}
static void *originalS;
BOOL
setupCoCo3MMU(void)
{
/*
Assume that PCLEAR 1 has been done before executing this program.
S is assumed to be in $7Fxx.
Save S in a global.
Put S at the end of the graphics page.
At $6000 (GIME_SCREEN_BUFFER), map in an 8k MMU page that will contain the GIME text screen.
(This will preserve the page that contains the Basic stack space.)
Run the editor.
When it ends, map the original MMU page at $6000, restoring the Basic stack space.
Load S from the global.
Quit the program.
*/
disableInterrupts();
asm
{
sts :originalS ; uses U register to refer to C local variable
lds <$BC ; GRPRAM: Start of graphics page
leas 1536,s ; skip 1 PMODE page (assuming PCLEAR 1)
ldb #GIME_SCREEN_BLOCK ; block used by SECB to store 40/80-column screen
stb $FFA3 ; bank at $6000
}
enableInterrupts();
byte screenMode = chooseScreenMode();
BOOL success = work(screenMode);
disableInterrupts();
asm
{
ldb #$3B ; block that is normally mapped at $6000
stb $FFA3 ; bank at $6000
lds :originalS ; uses U register to refer to C local variable
}
enableInterrupts();
width(32);
return success;
}
#endif /* _COCO_BASIC_ */
int
main()
{
BOOL success = FALSE;
#ifdef OS9
// This reference to OS9RawTerminal_init() helps prove that the bcontrol library
// was compiled with TARGET=os9.
// If it was compiled for the wrong target platform, then building this program
// will fail with this linking error:
// External symbol _OS9RawTerminal_init not found in ebitdemo.o:code
//
assert(OS9RawTerminal_init != NULL);
//printf("main: %s %s\n", __DATE__, __TIME__);
Keyboard_init(&keyboard);
byte screenMode = determineOS9ScreenMode();
if (screenMode != 40 && screenMode != 80)
{
printf("Error: This terminal type is\n"
"not supported by this editor.\n");
return FALSE;
}
success = work(screenMode);
#else
initCoCoSupport(); // initializes 'isCoCo3'
width(32);
rgb();
if (isCoCo3)
success = setupCoCo3MMU(); // calls work()
else
success = work(32);
#endif
#ifdef _COCO_BASIC_
cls(255);
#elif defined(OS9)
if (success) // don't clear screen upon error, b/c error msg has just been printed
putchar(12); // clear whole screen
Keyboard_shutdown(&keyboard);
#endif
return 0; // returning 1 on OS-9 causes "Unconditional Abort" error message
}