mirrors
/
netsurf
mirror of https://github.com/netsurf-browser/netsurf
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
netsurf/amiga/os3support.c

428 lines
8.2 KiB
C
Raw Blame History

/*
* Copyright 2014 Chris Young <chris@unsatisfactorysoftware.co.uk>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf 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; version 2 of the License.
*
* NetSurf 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/>.
*/
/** \file
* Minimal compatibility header for AmigaOS 3
*/
#ifndef __amigaos4__
#include "os3support.h"
#include <inttypes.h>
#include <stdarg.h>
#include <stdio.h>
#include <proto/bullet.h>
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/dos.h>
#include <proto/utility.h>
#include <diskfont/diskfont.h>
#include <diskfont/diskfonttag.h>
#include <intuition/gadgetclass.h>
#include "utils/log.h"
#define SUCCESS (TRUE)
#define FAILURE (FALSE)
#define NO !
/* Diskfont */
struct OutlineFont *OpenOutlineFont(STRPTR fileName, struct List *list, ULONG flags)
{
BPTR fh = 0;
int64 size = 0;
struct TagItem *ti;
UBYTE *buffer;
STRPTR fname, otagpath, fontpath;
struct BulletBase *BulletBase;
struct OutlineFont *of = NULL;
struct GlyphEngine *gengine;
char *p = 0;
struct FontContentsHeader fch;
if(p = strrchr(fileName, '.'))
*p = '\0';
fontpath = (STRPTR)ASPrintf("FONTS:%s.font", fileName);
fh = Open(fontpath, MODE_OLDFILE);
if(fh == 0) {
LOG("Unable to open FONT %s", fontpath);
FreeVec(fontpath);
return NULL;
}
if(Read(fh, &fch, sizeof(struct FontContentsHeader)) != sizeof(struct FontContentsHeader)) {
LOG("Unable to read FONT %s", fontpath);
FreeVec(fontpath);
Close(fh);
return NULL;
}
Close(fh);
if(fch.fch_FileID != OFCH_ID) {
LOG("%s is not an outline font!", fontpath);
FreeVec(fontpath);
return NULL;
}
otagpath = (STRPTR)ASPrintf("FONTS:%s.otag", fileName);
fh = Open(otagpath, MODE_OLDFILE);
if(p) *p = '.';
if(fh == 0) {
LOG("Unable to open OTAG %s", otagpath);
FreeVec(otagpath);
return NULL;
}
size = GetFileSize(fh);
buffer = (struct TagItem *)AllocVec(size, MEMF_ANY);
if(buffer == NULL) {
LOG("Unable to allocate memory");
Close(fh);
FreeVec(otagpath);
return NULL;
}
Read(fh, buffer, size);
Close(fh);
/* The first tag is supposed to be OT_FileIdent and should equal 'size' */
struct TagItem *tag = (struct TagItem *)buffer;
if((tag->ti_Tag != OT_FileIdent) || (tag->ti_Data != (ULONG)size)) {
LOG("Invalid OTAG file");
FreeVec(buffer);
FreeVec(otagpath);
return NULL;
}
/* Relocate all the OT_Indirect tags */
while (ti = NextTagItem(&tag)) {
if(ti->ti_Tag & OT_Indirect) {
ti->ti_Data += buffer;
}
}
/* Find OT_Engine and open the font engine */
if(ti = FindTagItem(OT_Engine, buffer)) {
LOG("Using font engine %s", ti->ti_Data);
fname = ASPrintf("%s.library", ti->ti_Data);
} else {
LOG("Cannot find OT_Engine tag");
FreeVec(buffer);
FreeVec(otagpath);
return NULL;
}
BulletBase = OpenLibrary(fname, 0L);
if(BulletBase == NULL) {
LOG("Unable to open font engine %s", fname);
FreeVec(buffer);
FreeVec(fname);
FreeVec(otagpath);
}
FreeVec(fname);
gengine = OpenEngine();
SetInfo(gengine,
OT_OTagPath, otagpath,
OT_OTagList, buffer,
TAG_DONE);
of = AllocVec(sizeof(struct OutlineFont), MEMF_CLEAR);
if(of == NULL) return NULL;
of->BulletBase = BulletBase;
of->GEngine = gengine;
of->OTagPath = otagpath;
of->olf_OTagList = buffer;
return of;
}
void CloseOutlineFont(struct OutlineFont *of, struct List *list)
{
struct BulletBase *BulletBase = of->BulletBase;
CloseEngine(of->GEngine);
CloseLibrary(BulletBase);
FreeVec(of->OTagPath);
FreeVec(of->olf_OTagList);
FreeVec(of);
}
/* DOS */
int64 GetFileSize(BPTR fh)
{
int32 size = 0;
struct FileInfoBlock *fib = AllocVec(sizeof(struct FileInfoBlock), MEMF_ANY);
if(fib == NULL) return 0;
ExamineFH(fh, fib);
size = fib->fib_Size;
FreeVec(fib);
return (int64)size;
}
void FreeSysObject(ULONG type, APTR obj)
{
switch(type) {
case ASOT_PORT:
DeleteMsgPort(obj);
break;
case ASOT_IOREQUEST:
DeleteIORequest(obj);
break;
}
}
/* Exec */
struct Node *GetHead(struct List *list)
{
struct Node *res = NULL;
if ((NULL != list) && (NULL != list->lh_Head->ln_Succ))
{
res = list->lh_Head;
}
return res;
}
struct Node *GetPred(struct Node *node)
{
if (node->ln_Pred->ln_Pred == NULL) return NULL;
return node->ln_Pred;
}
struct Node *GetSucc(struct Node *node)
{
if (node->ln_Succ->ln_Succ == NULL) return NULL;
return node->ln_Succ;
}
/* Intuition */
uint32 GetAttrs(Object *obj, Tag tag1, ...)
{
va_list ap;
Tag tag = tag1;
ULONG data = 0;
int i = 0;
va_start(ap, tag1);
while(tag != TAG_DONE) {
data = va_arg(ap, ULONG);
i += GetAttr(tag, obj, (void *)data);
tag = va_arg(ap, Tag);
}
va_end(ap);
return i;
}
ULONG RefreshSetGadgetAttrsA(struct Gadget *g, struct Window *w, struct Requester *r, struct TagItem *tags)
{
ULONG retval;
BOOL changedisabled = FALSE;
BOOL disabled;
if (w) {
if (FindTagItem(GA_Disabled,tags)) {
changedisabled = TRUE;
disabled = g->Flags & GFLG_DISABLED;
}
}
retval = SetGadgetAttrsA(g,w,r,tags);
if (w && (retval || (changedisabled && disabled != (g->Flags & GFLG_DISABLED)))) {
RefreshGList(g,w,r,1);
retval = 1;
}
return retval;
}
ULONG RefreshSetGadgetAttrs(struct Gadget *g, struct Window *w, struct Requester *r, Tag tag1, ...)
{
return RefreshSetGadgetAttrsA(g,w,r,(struct TagItem *) &tag1);
}
/* Utility */
struct FormatContext
{
STRPTR Index;
LONG Size;
BOOL Overflow;
};
STATIC VOID ASM
StuffChar(
REG(a3, struct FormatContext * Context),
REG(d0, UBYTE Char))
{
/* Is there still room? */
if(Context->Size > 0)
{
(*Context->Index) = Char;
Context->Index++;
Context->Size--;
/* Is there only a single character left? */
if(Context->Size == 1)
{
/* Provide null-termination. */
(*Context->Index) = '\0';
/* Don't store any further characters. */
Context->Size = 0;
}
}
else
{
Context->Overflow = TRUE;
}
}
BOOL
VSPrintfN(
LONG MaxLen,
STRPTR Buffer,
const STRPTR FormatString,
const va_list VarArgs)
{
BOOL result = FAILURE;
/* format a text, but place only up to MaxLen
* characters in the output buffer (including
* the terminating NUL)
*/
if (Buffer == NULL || FormatString == NULL) return(result);
if(MaxLen > 1)
{
struct FormatContext Context;
Context.Index = Buffer;
Context.Size = MaxLen;
Context.Overflow = FALSE;
RawDoFmt(FormatString,(APTR)VarArgs,(VOID (*)())StuffChar,(APTR)&Context);
if(NO Context.Overflow)
result = SUCCESS;
}
return(result);
}
BOOL
SPrintfN(
LONG MaxLen,
STRPTR Buffer,
const STRPTR FormatString,
...)
{
va_list VarArgs;
BOOL result = FAILURE;
/* format a text, varargs version */
if (Buffer == NULL && FormatString == NULL) return result;
va_start(VarArgs,FormatString);
result = VSPrintfN(MaxLen,Buffer,FormatString,VarArgs);
va_end(VarArgs);
return(result);
}
char *ASPrintf(const char *fmt, ...)
{
int r;
va_list ap;
static char buffer[2048];
char *rbuf;
va_start(ap, fmt);
r = VSPrintfN(2048, buffer, (const STRPTR)fmt, ap);
va_end(ap);
r = strlen(buffer);
rbuf = AllocVec(r+1, MEMF_CLEAR);
if (rbuf != NULL)
{
strncpy(rbuf, buffer, r);
}
return rbuf;
}
/* C */
char *strlwr(char *str)
{
size_t i;
size_t len = strlen(str);
for(i=0; i<len; i++)
str[i] = tolower((unsigned char)str[i]);
return str;
}
char *strsep(char **s1, const char *s2)
{
char *const p1 = *s1;
if (p1 != NULL) {
*s1 = strpbrk(p1, s2);
if (*s1 != NULL) {
*(*s1)++ = '\0';
}
}
return p1;
}
int scandir(const char *dir, struct dirent ***namelist,
int (*filter)(const struct dirent *),
int (*compar)(const struct dirent **, const struct dirent **))
{
/*\todo stub function, needs writing, preferably into clib2 */
return 0;
}
long long int strtoll(const char *nptr, char **endptr, int base)
{
return (long long int)strtol(nptr, endptr, base);
}
#endif
Reference in New Issue View Git Blame Copy Permalink