sbpad.c

smallbasic for linux

/*
*	SmallBASIC IDE
*
*	2000-05-26, Nicholas Christopoulos
*
*	This program is distributed under the terms of the GPL v2.0 or later
*	Download the GNU Public License (GPL) from www.gnu.org
*/

/*
*	Each DOC is a basic module
*	Each module has 
*		record 0 - type: info_t, the header
*		record 1 - type: sec_t,  the main code section
*		record n - type: sec_t,  code section
*
* 	Each section can be a function or a procedure.
* 	The maximum size of each section is 32KB (FIELD limit).
*/

#include "sys.h"
#include "sbpad.h"
#include "smbas.h"
#include "panic.h"
#include "str.h"
#include "ui.h"
#include "device.h"

#define	APPL	0x6170706C
#define	SmBa	0x536D4261

#define	idBASC	0x42415343
#define	idTEXT	0x54455854
#define	idDATA	0x44415441
#define idUFST  0x55465354

#define	idLNCH	0x6C6E6368

#define	MAXTEXTSIZE		0x7fff		// 32K
#define	MAXSTR			256

typedef char*		char_p;
typedef DmOpenRef	file_t;
#define	fatal(c,m)	ErrNonFatalDisplayIf((c), (m))

void savePrefs() SEC(IDE);

////////////////
extern byte os_charset;
//extern word os_cclabs1;
//extern word os_ccpass2;
////////////////

DWord	OldScreenDepth;

//#ifndef SysAppLaunchCmdOpenDBType
//typedef struct {
//	word	cardNo;
//	LocalID dbID;
//	} SysAppLaunchCmdOpenDBType;
//
//#define sysAppLaunchCmdOpenDB	52
//#endif

/*
*	sbpad prefs
*/
typedef struct {
	char	lastFileName[64];
	word	lastCat;
	word	lastDocSec;
	word	lastDocPos;
	word	lastDocFont;
	word	lastDocForm;
	word	font;
	word	charset;
	word	flags;
	word	cclabs1;
	word	ccpass2;
	char	reserver[64-20];
	} sbpref_t;

/*
*	doc header 
*/
typedef struct {
		byte	sign;				// always 'H'
		byte	version;			// 
		byte	unsued;
		byte	category;			//
		} info_t;

/*
*	doc section
*/
typedef struct {
	byte	sign;					// always = 'S'
	byte	unused;					//
	word	version;				// 
	word	flags;					// 1 for main section
	char	name[64];
	} sec_t;

//
static sbpref_t		sbpref;

/* current doc (for editor) */
static file_t		curFile;
static info_t		curFileHeader;
static char			curFileName[64];			// current filename (source file)
static char			curFSVName[64];				// current filename (file viewer)
static int			curSection;
static byte			modified = 0;

/* current doc section list */
static char_p		*secListStr;
static sec_t		*secList;
static int			secCount;

/* doc list variable */
static char_p *docTable;
static int	docCount;

/* user-file list  */
static char_p *ufstTable = NULL;
static int	ufstCount = 0;

static char	lastSearchString[MAXSTR];		// last search string
static int  autoReturnToForm;	  			// 

static char	temp[MAXSTR];

/// globals of ViewForm
static int	lastDocFont;
static int	lastDocPageSize;
static word	lastDocPos;
static word lastDocSec;
static word lastFSV;
static char	smtitle[64];

/// globals for categories
static char_p	*catList;
static int		catCount;
static dword	catUnfiledID;
static dword	curCat;
static MemHandle gHK40FontHandle;
static MemHandle gSM10FontHandle;
static MemHandle gDOSFontHandle;
static MemHandle gDOS4FontHandle;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int	BasicInputBox(char *title, char *dest, int size)
{
	FormPtr		frm, prv_frm;
	FieldPtr  	text_box;
	FormActiveStateType	stateP;
	VoidHand	text_h;
	char		*text_p;
	int			r, l;

	*dest = '\0';
	prv_frm = FrmGetActiveForm();
	FrmSaveActiveState(&stateP);


	frm = FrmInitForm(InputBoxForm);
	text_box = (FieldPtr) FrmGetObjectPtr(frm, FrmGetObjectIndex(frm, fldInputBox));
	FrmSetActiveForm(frm);
	FrmSetTitle(frm, title);
	FrmSetFocus(frm, FrmGetObjectIndex(frm, fldInputBox));
	FldSetInsPtPosition(text_box, 0);
	InsPtEnable(true);
	FldGrabFocus(text_box);

	// set value	
	if	( (r = FrmDoDialog(frm)) == btnOK )	{

		text_h = (VoidHand) FldGetTextHandle(text_box);
		if	( text_h )	{
			text_p = (char *) MemHandleLock(text_h);
												   
			if	( text_p )	{
				l = strlen(text_p);

				if	( l )	{
					if	( l >= size )	{
						StrNCopy(dest, text_p, size-1);
						dest[size] = '\0';
						}
					else
						StrCopy(dest, text_p);
					}

				MemHandleUnlock(text_h);
				}
			}
		}

	if ( prv_frm)	{
		FrmRestoreActiveState(&stateP);
		FrmSetActiveForm(prv_frm);
		}

	FrmDeleteForm(frm);
	return ( r == btnOK );
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////// BEAM
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Err	beamSendData(const void *data, dword *size, void *userdata)
{
	Err		err;

	*size = ExgSend((ExgSocketPtr) userdata, (void *) data, *size, &err);
	return err;
}

void beamSendDB(const char *file)
{
	char	*name;
	ExgSocketType	exsock;
	Err		err;
	LocalID	lid;

	lid = DmFindDatabase(0, (char *) file);
	if	( !lid )
		return;

	name = tmp_alloc(128);
	strcpy(name, file);
    DmDatabaseInfo(0, lid, name, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

	MemSet(&exsock, sizeof(exsock), 0);
	exsock.description = name;
	exsock.name = name;
	exsock.target = SmBa;
	err = ExgPut(&exsock);
	if	( !err )	{
		err = ExgDBWrite(beamSendData, &exsock, NULL, lid, 0);
		err = ExgDisconnect(&exsock, err);
		}
	tmp_free(name);
}

/*
*	BEAM: get database
*/

Err		readthunk(void *datap, unsigned long *sizep, void *rock)
{
	Err 			err = 0;
	ExgSocketType	*sock = rock;
	dword			count;

	count = *sizep;
	count = ExgReceive(sock, datap, count, &err);
	*sizep = count;
	return err;
}

Boolean	deletethunk(const char *name, Word version, word card, LocalID lid, void *rock)
{
	Err		err;
	unsigned short attr;

	err = DmDatabaseInfo(card, lid, NULL, &attr, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	if ( !err )	{
		DmDeleteDatabase(0, lid);
		return 1;
		}
	return 0;
}

Err		beamGetDB(ExgSocketPtr sock, byte gavail)
{
	Err		err = 0;
	LocalID lid;
	unsigned short card = 0;
	byte	wantreset = 0;

	err = ExgDBRead(readthunk, deletethunk, sock, &lid, card, &wantreset, 1);
	err = ExgDisconnect(sock, err);

	sock->goToCreator = 0;

	if ( !err )	{
		if ( wantreset ) {
		    int res = FrmAlert(AlertWantReset);
		    if (res == 1)
		      SysReset();
			}
		}

	if ( gavail )	{
//		refresh doc list
		if	( sbpref.lastDocForm == MainForm )	{
			EventType	ev;

			ev.eType = evtRefreshDOCs;
			EvtAddEventToQueue(&ev);
			}
		} 
	return err;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int		dbExist(const char *file) SEC(IDE);
int		dbExist(const char *file)
{
	return (DmFindDatabase(0, (char*) file) != 0);
}

/*
*/
file_t	dbOpen(const char *fileName) SEC(IDE);
file_t	dbOpen(const char *fileName)
{
	LocalID		lid;
	file_t		ref;
	
	// open
	lid = DmFindDatabase(0, (char *) fileName);
	ref = DmOpenDatabase(0, lid, dmModeReadWrite);
	fatal(ref == 0, "dbOpen(): can't open file");
	return ref;
}

/*
*/
file_t	dbOpenAlw(const char *fileName, dword creator, dword type) SEC(IDE);
file_t	dbOpenAlw(const char *fileName, dword creator, dword type)
{
	LocalID		lid;
	file_t		ref;
	int			d;
	
	// open
	lid = DmFindDatabase(0, (char *) fileName);
	if	( !lid )	{ // create
		d = DmCreateDatabase(0, fileName, creator, type, false);
		fatal(d != 0, "dbOpwnAlw(): can't create file");
		lid = DmFindDatabase(0, (char *) fileName);
		}

	ref = DmOpenDatabase(0, lid, dmModeReadWrite);
	fatal(ref == 0, "dbOpenAlw(): can't open file");
	return ref;
}

/*
*/
void	dbClose(file_t f) SEC(IDE);
void	dbClose(file_t f)
{
	DmCloseDatabase(f);
}

/*
*	writes a new record at the end of the file
*/
word	dbWrite(file_t f, word record, void *new_rec, word size) SEC(IDE);
word	dbWrite(file_t f, word record, void *new_rec, word size)
{
	word		recIndex;
	mem_t		rec_h;
	void		*pre_rec;
	int		src_sz;
	int		d;

	if	( record >= DmNumRecords(f) )		{	// new record
		recIndex = dmMaxRecordIndex;
		rec_h = DmNewRecord(f, &recIndex, size);
		fatal(rec_h == 0, "dbWrite(): Can't create record");
		}
	else	{	// Update record
		recIndex = record;
		rec_h = DmGetRecord(f, recIndex);
		fatal(rec_h == 0, "dbWrite(): Can't open record");
		src_sz = MemHandleSize(rec_h);
		if	( src_sz != size )
			MemHandleResize(rec_h, size);
		}

	pre_rec = mem_lock(rec_h);
	fatal( pre_rec == 0,        "dbWrite(): Can't lock record!");
	d = DmWrite(pre_rec, 0, new_rec, size);
	fatal(d != 0, "dbWrite(): DmWrite return error.");
	mem_unlock(rec_h);
	d = DmReleaseRecord(f, recIndex, 1);
	fatal(d != 0, "dbWrite(): Can't release record.");
	return recIndex;
}

/*
*	writes a new record at the end of the file
*/
word	dbWriteSeg(file_t f, word record, word offset, void *ptr, word size) SEC(IDE);
word	dbWriteSeg(file_t f, word record, word offset, void *ptr, word size)
{
	word		recIndex;
	mem_t		rec_h;
	void		*pre_rec;
	int		src_sz;
	int		d;

	if	( record >= DmNumRecords(f) )		{	// new record
		recIndex = dmMaxRecordIndex;
		rec_h = DmNewRecord(f, &recIndex, size);
		fatal(rec_h == 0, "dbWriteSeg(): Can't create record");
		}
	else	{	// Update record
		recIndex = record;
		rec_h = DmGetRecord(f, recIndex);
		fatal(rec_h == 0, "dbWriteSeg(): Can't open record");
		src_sz = MemHandleSize(rec_h);
		if	( src_sz < (size+offset) )
			MemHandleResize(rec_h, (size+offset));
		}

	pre_rec = mem_lock(rec_h);
	fatal( pre_rec, "dbWriteSeg(): Can't lock record!");
	d = DmWrite(pre_rec, offset, ptr, size);
	fatal( d != 0, "dbWriteSeg(): DmWrite return error.");
	mem_unlock(rec_h);
	d = DmReleaseRecord(f, recIndex, 1);
	fatal(d != 0, "dbWriteSeg(): Can't release record.");
	return recIndex;
}

/*
*/
word	dbRecSize(file_t f, word record) SEC(IDE);
word	dbRecSize(file_t f, word record)
{
	VoidPtr		rec_p = NULL;
	VoidHand	rec_h = NULL;
	word		len;

	rec_h = DmGetRecord(f, record);
	fatal(d == 0, "dbRecSize(): can't get record");
	rec_p = mem_lock(rec_h);
	fatal(rec_p == NULL, "dbRecSize(): can't lock record");

	len = MemHandleSize(rec_h);
	mem_unlock(rec_h);
	DmReleaseRecord(f, record, 0);
	return len;
}

/*
*/
word	dbRead(file_t f, word record, void *buff, word size) SEC(IDE);
word	dbRead(file_t f, word record, void *buff, word size)
{
	VoidPtr		rec_p = NULL;
	VoidHand	rec_h = NULL;
	word		len;

	rec_h = DmGetRecord(f, record);
	fatal(rec_h == 0, "dbRead(): can't get record");
	rec_p = mem_lock(rec_h);
	fatal(rec_p == NULL, "dbRead(): can't lock record");

	len = MemHandleSize(rec_h);
	if	( len > size )
		len = size;

	MemMove(buff, rec_p, len);

	mem_unlock(rec_h);
	DmReleaseRecord(f, record, 0);
	return len;
}

/*
*/
word	dbReadSeg(file_t f, word record, void *buff, word offset, word size) SEC(IDE);
word	dbReadSeg(file_t f, word record, void *buff, word offset, word size)
{
	VoidPtr		rec_p = NULL;
	VoidHand	rec_h = NULL;
	word		len;

	rec_h = DmGetRecord(f, record);
	fatal(rec_h == 0, "dbReadSeg(): can't get record");
	rec_p = mem_lock(rec_h);
	fatal(rec_p == NULL, "dbReadSeg(): can't lock record");

	len = MemHandleSize(rec_h);
	if	( len > size )
		len = size;

	MemMove(buff, rec_p+offset, len);

	mem_unlock(rec_h);
	DmReleaseRecord(f, record, 0);
	return len;
}

/*
*/
int		dbRemove(const char *fileName) SEC(IDE);
int		dbRemove(const char *fileName)
{
	LocalID		lid;

	lid = DmFindDatabase(0, (char *) fileName);
	if	( !lid )
		return 0;
	return DmDeleteDatabase(0, lid);
}

/*
*/
word	dbRecCount(file_t f) SEC(IDE);
word	dbRecCount(file_t f)
{
	return DmNumRecords(f);
}

/*
*/
int		dbCopy(const char *oldName, const char *newName) SEC(IDE);
int		dbCopy(const char *oldName, const char *newName)
{
	file_t		fin, fout;
	word		recs, i, len;
	char		*ptr;

	fin = dbOpen(oldName);
	if	( dbExist(newName) ) dbRemove(newName);
	fout = dbOpenAlw(newName, SmBa /* idBASC */, idTEXT);

	// copy
	recs = dbRecCount(fin);
	for ( i = 0; i < recs; i ++ )	{
		len = dbRecSize(fin, i);
		ptr = tmp_alloc(len);
		dbRead(fin, i, ptr, len);

		dbWrite(fout, 0xFFFF, ptr, len);
		tmp_free(ptr);
		}

	// clean up
	dbClose(fin);
	dbClose(fout);
	return 1;
}

/*
*/
void	dbRename(const char *oldName, const char *newName) SEC(IDE);
void	dbRename(const char *oldName, const char *newName)
{
	if	( dbCopy(oldName, newName) )
		dbRemove(oldName);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void	mkSmallTitle(char *src, char *dst, int size, int font) SEC(IDE);
void	mkSmallTitle(char *src, char *dst, int size, int font)
{
	int		l, x, f;

	f = FntGetFont();
	FntSetFont(font);
	x = FntWordWrap(src, size);
	FntSetFont(f);

	l = StrLen(src);
	if	( l > x )	{
		MemMove(dst, src, x);
		dst[x] = '\x85';
		dst[x+1] = '\0';
		}
	else
		StrCopy(dst, src);
}

/*
*/
static void buildSecList() SEC(IDE);
static void buildSecList()
{
	byte	   	*ptr;