From 45e57168fa0d33206731e391fb24759ddf179861 Mon Sep 17 00:00:00 2001 From: Ash Wolf Date: Wed, 12 Oct 2022 03:03:57 +0100 Subject: lots more reorganisation, done part of OSLib --- command_line/CmdLine/Src/OSLib/FileHandles.c | 29 + command_line/CmdLine/Src/OSLib/Generic.c | 93 +++ command_line/CmdLine/Src/OSLib/MacFileTypes.c | 29 + command_line/CmdLine/Src/OSLib/MacSpecs.c | 25 + command_line/CmdLine/Src/OSLib/MemUtils.c | 21 + command_line/CmdLine/Src/OSLib/Posix.c | 866 ++++++++++++++++++++++++++ command_line/CmdLine/Src/OSLib/StringExtras.c | 17 + command_line/CmdLine/Src/OSLib/StringUtils.c | 49 ++ 8 files changed, 1129 insertions(+) (limited to 'command_line') diff --git a/command_line/CmdLine/Src/OSLib/FileHandles.c b/command_line/CmdLine/Src/OSLib/FileHandles.c index e69de29..4609d77 100644 --- a/command_line/CmdLine/Src/OSLib/FileHandles.c +++ b/command_line/CmdLine/Src/OSLib/FileHandles.c @@ -0,0 +1,29 @@ +#include "oslib.h" + +static int OS_LoadFileHandle(OSFileHandle *hand) { + +} + +static int OS_WriteFileHandle(OSFileHandle *hand) { + +} + +int OS_NewFileHandle(const OSSpec *spec, OSHandle *src, Boolean writeable, OSFileHandle *hand) { + +} + +int OS_LockFileHandle(OSFileHandle *hand, Ptr *ptr, UInt32 *size) { + +} + +int OS_UnlockFileHandle(OSFileHandle *hand) { + +} + +int OS_FreeFileHandle(OSFileHandle *hand) { + +} + +void OS_GetFileHandleSpec(const OSFileHandle *hand, OSSpec *spec) { + +} diff --git a/command_line/CmdLine/Src/OSLib/Generic.c b/command_line/CmdLine/Src/OSLib/Generic.c index e69de29..4430790 100644 --- a/command_line/CmdLine/Src/OSLib/Generic.c +++ b/command_line/CmdLine/Src/OSLib/Generic.c @@ -0,0 +1,93 @@ +#include "oslib.h" + +static char wildname[63]; +static char wilddir[255]; +static OSOpenedDir wilddirref; +static OSSpec wildmatch; +char STSbuf[256]; + +int WildCardMatch(const char *wild, const char *name) { + char next; + const char *prev; +} + +OSSpec *OS_MatchPath(const char *path) { + char filename[64]; + Boolean isfile; + OSSpec spec; + const char *nptr; +} + +char *OS_GetFileNamePtr(char *path) { + char *ptr; +} + +char *OS_GetDirName(const OSPathSpec *spec, char *buf, int size) { + char *path; + char *pptr; +} + +int OS_MakeSpec2(const char *path, const char *filename, OSSpec *spec) { + char bpath[256]; + char *eptr; + int pthlen; + int fnlen; +} + +int OS_MakeSpecWithPath(OSPathSpec *path, const char *filename, Boolean noRelative, OSSpec *spec) { + Boolean relpath; + char buf[256]; + char *mptr; + char *eptr; +} + +int OS_NameSpecChangeExtension(OSNameSpec *spec, const char *ext, Boolean append) { + char tmp[64]; + char *per; +} + +int OS_NameSpecSetExtension(OSNameSpec *spec, const char *ext) { + char tmp[64]; + char *per; +} + +char *OS_CompactPaths(char *buf, const char *p, const char *n, int size) { + int plen; + int nlen; + char *ptr; + int bidx; +} + +char *OS_SpecToStringRelative(const OSSpec *spec, const OSPathSpec *cwdspec, char *path, int size) { + char fullbuf[256]; + char *full; + char cwfbuf[256]; + char *cwd; + OSPathSpec mycwdspec; + char *pptr; +} + +int OS_FindFileInPath(const char *filename, const char *plist, OSSpec *spec) { + char *next; + char path[256]; + int err; +} + +int OS_FindProgram(const char *filename, OSSpec *spec) { + char *plist; + int err; + char temp[256]; +} + +int OS_CopyHandle(OSHandle *hand, OSHandle *copy) { + int err; + UInt32 sz; + void *f; + void *t; +} + +int OS_AppendHandle(OSHandle *hand, const void *data, UInt32 len) { + int err; + UInt32 sz; + void *buffer; +} diff --git a/command_line/CmdLine/Src/OSLib/MacFileTypes.c b/command_line/CmdLine/Src/OSLib/MacFileTypes.c index e69de29..9d18723 100644 --- a/command_line/CmdLine/Src/OSLib/MacFileTypes.c +++ b/command_line/CmdLine/Src/OSLib/MacFileTypes.c @@ -0,0 +1,29 @@ +#include "oslib.h" + +void OS_AddFileTypeMappingList(OSFileTypeMappings **list, OSFileTypeMappingList *entry) { + +} + +void OS_UseFileTypeMappings(OSFileTypeMappings *list) { + +} + +void OS_MacType_To_OSType(OSType mactype, uOSTypePair *type) { + +} + +int OS_SetMacFileType(const OSSpec *spec, OSType mactype) { + +} + +Boolean OS_GetMacFileTypeMagic(const char *buffer, int count, OSType *mactype) { + +} + +int OS_GetMacFileType(const OSSpec *spec, OSType *mactype) { + +} + +int OS_SetMacFileCreatorAndType(const OSSpec *spec, OSType creator, OSType mactype) { + +} diff --git a/command_line/CmdLine/Src/OSLib/MacSpecs.c b/command_line/CmdLine/Src/OSLib/MacSpecs.c index e69de29..8648324 100644 --- a/command_line/CmdLine/Src/OSLib/MacSpecs.c +++ b/command_line/CmdLine/Src/OSLib/MacSpecs.c @@ -0,0 +1,25 @@ +#include "oslib.h" + +int OS_OSPathSpec_To_VolDir(const OSPathSpec *spec, SInt16 *vRefNum, SInt32 *dirID) { + +} + +int OS_OSSpec_To_FSSpec(const OSSpec *spec, FSSpec *fss) { + +} + +int OS_VolDir_To_OSNameSpec(SInt16 vRefNum, SInt32 dirID, OSNameSpec *spec, SInt32 *parID) { + +} + +int OS_VolDir_To_OSPathSpec(SInt16 vRefNum, SInt32 dirID, OSPathSpec *spec) { + +} + +int OS_FSSpec_To_OSSpec(const FSSpec *fss, OSSpec *spec) { + +} + +int OS_GetRsrcOSSpec(const OSSpec *spec, OSSpec *rspec, Boolean create) { + +} diff --git a/command_line/CmdLine/Src/OSLib/MemUtils.c b/command_line/CmdLine/Src/OSLib/MemUtils.c index e69de29..4eb611c 100644 --- a/command_line/CmdLine/Src/OSLib/MemUtils.c +++ b/command_line/CmdLine/Src/OSLib/MemUtils.c @@ -0,0 +1,21 @@ +#include "oslib.h" + +void *xmalloc(const char *what, int size) { + +} + +void *xcalloc(const char *what, int size) { + +} + +void *xrealloc(const char *what, void *old, int size) { + +} + +char *xstrdup(const char *str) { + +} + +void xfree(void *ptr) { + +} diff --git a/command_line/CmdLine/Src/OSLib/Posix.c b/command_line/CmdLine/Src/OSLib/Posix.c index e69de29..0711559 100644 --- a/command_line/CmdLine/Src/OSLib/Posix.c +++ b/command_line/CmdLine/Src/OSLib/Posix.c @@ -0,0 +1,866 @@ +#include "oslib.h" +#include +#include +#include +#include +#include +#include +#include +#include + +enum { + OSErrNeg2 = -2 +}; + +static char *lastdlerr; +static char intbuf[256]; +enum { MAX_PATH = 256 }; + +#define CONVERT_SPEC(spec, pathbuf) \ +do { \ +int _plen = strlen((spec)->path.s); \ +int _nlen = strlen((spec)->name.s); \ +if (_plen + _nlen >= sizeof(pathbuf)) return 63; \ +memcpy((pathbuf), (spec)->path.s, _plen); \ +memcpy((pathbuf) + _plen, (spec)->name.s, _nlen + 1); \ +} while (0) + +#define CONVERT_PATHSPEC(spec, pathbuf) \ +do { \ +int _plen = strlen((spec)->s); \ +if (_plen >= sizeof(pathbuf)) return 63;\ +memcpy((pathbuf), (spec)->s, _plen + 1);\ +if (_plen > 1) { \ +if ((pathbuf)[_plen - 1] == '/') \ +(pathbuf)[_plen - 1] = 0; \ +} \ +} while (0) + +const char *OS_GetErrText(int err) { + if (err == -2) { + return !lastdlerr ? "Shared library function failed" : lastdlerr; + } else { + return strerror(err); + } +} + +int OS_InitProgram(int *pArgc, const char ***pArgv) { + return 0; +} + +int OS_TermProgram() { + return 0; +} + +uOSTypePair OS_TEXTTYPE = {0666}; + +int OS_Create(const OSSpec *spec, const uOSTypePair *type) { + int h; + int err; + CONVERT_SPEC(spec, intbuf); + h = open(intbuf, O_CREAT | O_TRUNC, type->perm); + if (h < 0) + return errno; + close(h); + + err = OS_SetFileType(spec, type); + return (err < 1) ? EPERM : 0; +} + +int OS_Status(const OSSpec *spec) { + struct stat st; + CONVERT_SPEC(spec, intbuf); + if (stat(intbuf, &st)) + return errno; + else + return 0; +} + +int OS_GetFileType(const OSSpec *spec, uOSTypePair *type) { + struct stat st; + CONVERT_SPEC(spec, intbuf); + if (stat(intbuf, &st) < 0) + return errno; + type->perm = st.st_mode; + return 0; +} + +int OS_SetFileType(const OSSpec *spec, const uOSTypePair *type) { + int err, oldmask; + + CONVERT_SPEC(spec, intbuf); + oldmask = umask(0) & UF_SETTABLE; + err = chmod(intbuf, type->perm & ~oldmask); + umask(oldmask); + + if (err < 0) + return errno; + return 0; +} + +int OS_GetFileTime(const OSSpec *spec, time_t *crtm, time_t *chtm) { + struct stat st; + CONVERT_SPEC(spec, intbuf); + if (stat(intbuf, &st) < 0) + return errno; + if (crtm) + *crtm = st.st_ctimespec.tv_sec; + if (chtm) + *chtm = st.st_mtimespec.tv_sec; + return 0; +} + +int OS_SetFileTime(const OSSpec *spec, const time_t *crtm, const time_t *chtm) { + struct utimbuf buf; + struct stat st; + CONVERT_SPEC(spec, intbuf); + if (stat(intbuf, &st) < 0) + return errno; + buf.actime = chtm ? *chtm : st.st_atimespec.tv_sec; + buf.modtime = crtm ? *crtm : st.st_mtimespec.tv_sec; + if (utime(intbuf, &buf) < 0) + return errno; + return 0; +} + +int OS_Open(const OSSpec *spec, OSOpenMode mode, int *ref) { + static int modetrans[4] = { + O_RDONLY, + O_WRONLY, + O_RDWR, + O_RDONLY | O_APPEND + }; + CONVERT_SPEC(spec, intbuf); + *ref = open(intbuf, modetrans[mode]); + if (*ref < 0) { + *ref = -1; + return errno; + } + return 0; +} + +int OS_Write(int ref, const void *buffer, UInt32 *length) { + struct stat st; + UInt32 pos; + + if (fstat(ref, &st) < 0) + return errno; + + pos = lseek(ref, 0, SEEK_CUR); + if (pos > st.st_size && !*length) { + lseek(ref, -1, SEEK_CUR); + if (write(ref, "", 1) != 1) { + *length = 0; + return errno; + } + } + + *length = write(ref, buffer, *length); + if (((SInt32) *length) < 0) + return errno; + return 0; +} + +int OS_Read(int ref, void *buffer, UInt32 *length) { + *length = read(ref, buffer, *length); + if (((SInt32) *length) < 0) + return errno; + return 0; +} + +int OS_Seek(int ref, OSSeekMode how, SInt32 offset) { + static int howtrans[3] = { + SEEK_CUR, + SEEK_SET, + SEEK_END + }; + + return (lseek(ref, offset, howtrans[how]) < 0) ? errno : 0; +} + +int OS_Tell(int ref, SInt32 *offset) { + *offset = lseek(ref, 0, SEEK_CUR); + if (*offset < 0) + return errno; + else + return 0; +} + +int OS_Close(int ref) { + if (ref == -1) + return EBADF; + + if (close(ref)) + return errno; + else + return 0; +} + +int OS_GetSize(int ref, UInt32 *length) { + struct stat st; + if (fstat(ref, &st) < 0) { + return errno; + } else { + *length = st.st_size; + return 0; + } +} + +int OS_SetSize(int ref, UInt32 size) { + if (ftruncate(ref, size)) + return errno; + else + return 0; +} + +int OS_Delete(const OSSpec *spec) { + CONVERT_SPEC(spec, intbuf); + if (unlink(intbuf)) + return errno; + else + return 0; +} + +int OS_Rename(const OSSpec *oldspec, const OSSpec *newspec) { + char newbuf[256]; + CONVERT_SPEC(newspec, newbuf); + CONVERT_SPEC(oldspec, intbuf); + return rename(intbuf, newbuf) ? errno : 0; +} + +int OS_Mkdir(const OSSpec *spec) { + CONVERT_SPEC(spec, intbuf); + if (mkdir(intbuf, 0777)) + return errno; + else + return 0; +} + +int OS_Rmdir(const OSPathSpec *spec) { + CONVERT_PATHSPEC(spec, intbuf); + if (rmdir(intbuf)) + return errno; + else + return 0; +} + +int OS_Chdir(const OSPathSpec *spec) { + CONVERT_PATHSPEC(spec, intbuf); + if (chdir(intbuf)) + return errno; + else + return 0; +} + +int OS_GetCWD(OSPathSpec *spec) { + char *ptr; + if (!getcwd(spec->s, sizeof(spec->s))) + return errno; + + ptr = &spec->s[strlen(spec->s)]; + if (ptr[-1] != '/') + strcpy(ptr, "/"); + return 0; +} + +extern char **environ; +int OS_Execute(OSSpec *spec, char **argv, char **envp, const char *stdoutfile, const char *stderrfile, int *exitcode) { + int svstdout; + int svstderr; + pid_t kidpid; + int status; + int err; // not in stabs but i think this exists...? + + if (stdoutfile) { + svstdout = dup(1); + close(1); + if (open(stdoutfile, O_CREAT|O_TRUNC|O_WRONLY, 0666) < 0) { + status = errno; + dup2(svstdout, 1); + close(svstdout); + return status; + } + } + + if (stderrfile) { + svstderr = dup(2); + close(2); + if (open(stderrfile, O_CREAT|O_TRUNC|O_WRONLY, 0666) < 0) { + status = errno; + dup2(svstderr, 2); + close(svstderr); + return status; + } + } + + kidpid = fork(); + if (!kidpid) { + if (execve(argv[0], argv, (envp && envp[0]) ? envp : environ) < 0) + exit(-1); + return EINVAL; + } else { + if (stdoutfile) { + dup2(svstdout, 1); + close(svstdout); + } + if (stderrfile) { + dup2(svstderr, 2); + close(svstderr); + } + *exitcode = 0; + + err = (waitpid(kidpid, &status, 0) <= 0) ? errno : 0; + + if (!(status & 0x7F)) + *exitcode = status >> 8; + + if ((status & 0x7F) != 0x7F && (status & 0x7F) != 0) + *exitcode = -(status & 0x7F); + + return err; + } +} + +int OS_IsLegalPath(const char *path) { + const char *scan = path; + int pthlen; + int fnlen; + + pthlen = 0; + fnlen = 0; + + while (*scan) { + if (*scan == '/') + fnlen = 0; + else + fnlen++; + ++pthlen; + if (fnlen > 63 || pthlen > 255) + return ENAMETOOLONG; + //if ((fnlen = (*scan == '/') ? 0 : (fnlen + 1)) > 63 || ++pthlen > 255) + // return ENAMETOOLONG; + ++scan; + } + + return 0; +} + +int OS_IsFullPath(const char *path) { + return path[0] == '/'; +} + +char *OS_GetDirPtr(char *path) { + return path; +} + +static int OS_CompactPath(const char *src, char *dst) { + char buf[256]; + char *bptr; + char *to; + char *from; + char *start; + char *brk; +} + +int OS_EqualPath(const char *a, const char *b) { + return !strcmp(a, b); +} + +int OS_CanonPath(char *src, char *dst) { + int idx; + + if (strlen(src) > 255) + return ENAMETOOLONG; + + if (!dst) + dst = src; + + for (idx = 0; src[idx]; idx++) { + if (src[idx] == '\\') + dst[idx] = '/'; + else + dst[idx] = src[idx]; + } + + dst[idx] = 0; + return 0; +} + +int OS_MakeSpec(const char *path, OSSpec *spec, Boolean *isfile) { + char tmp[256]; + struct stat st; + char *ptr; + int len; + int err; + char *end; + char orig[256]; + + spec->name.s[0] = 0; + spec->path.s[0] = 0; + err = OS_CanonPath((char *) path, tmp); + if (err) + return err; + + if (!OS_IsFullPath(tmp)) { + strcpy(orig, tmp); + if (!getcwd(tmp, sizeof(tmp))) + return errno; + + ptr = tmp + strlen(tmp) - 1; + if (ptr[0] != '/') { + ptr[1] = '/'; + ptr[2] = 0; + ptr += 2; + } + + if (((ptr - tmp) + strlen(orig)) >= 256) + return ENAMETOOLONG; + + strcpy(ptr, orig); + } else { + if (strlen(tmp) >= 256) + return ENAMETOOLONG; + } + + err = OS_CompactPath(tmp, 0); + if (err) + return err; + err = OS_IsLegalPath(tmp); + if (err) + return err; + + if (!stat(tmp, &st)) { + ptr = tmp + strlen(tmp); + if (ptr[-1] == '/') + ptr--; + if ((st.st_mode & S_IFMT) == S_IFDIR) { + if (isfile) + *isfile = 0; + ptr[0] = '/'; + ptr++; + } else { + if (isfile) + *isfile = 1; + } + *ptr = 0; + } else { + if (errno != ENOENT) + return errno; + if (isfile) + *isfile = 1; + } + + ptr = strrchr(tmp, '/') + 1; + len = ptr - tmp; + if (len >= 256) { + spec->path.s[0] = 0; + return ENAMETOOLONG; + } + + memcpy(spec->path.s, tmp, len); + spec->path.s[len] = 0; + + len = strlen(ptr); + if (len >= 64) { + spec->name.s[0] = 0; + return ENAMETOOLONG; + } + + memcpy(spec->name.s, ptr, len); + spec->name.s[len] = 0; + + return 0; +} + +int OS_MakeFileSpec(const char *path, OSSpec *spec) { + Boolean isfile; + int err; + + err = OS_MakeSpec(path, spec, &isfile); + if (err) + return err; + else + return (isfile != 0) ? 0 : EISDIR; +} + +int OS_MakePathSpec(const char *vol, const char *dir, OSPathSpec *spec) { + Boolean isfile; + OSSpec tmp; + int err; + char path[256]; + + if (((vol ? strlen(vol) : 0) + (dir ? strlen(dir) : 0) + 2) > 256) + return ENAMETOOLONG; + + sprintf(path, + "%s%s%s", + vol ? (strchr("/\\:", vol[0]) ? "" : "/") : "", + vol ? vol : "", + dir ? dir : "" + ); + + err = OS_MakeSpec(path, &tmp, &isfile); + strcpy(spec->s, tmp.path.s); + if (err) + return err; + + if (isfile) + return !OS_Status(&tmp) ? ENOTDIR : ENOENT; + + return 0; +} + +int OS_MakeNameSpec(const char *name, OSNameSpec *spec) { + int len; + + len = strlen(name); + spec->s[0] = 0; + if (len > 63) + return ENAMETOOLONG; + if (strchr(name, '/')) + return EISDIR; + if (strlen(name) > 63) + return ENAMETOOLONG; + memcpy(spec->s, name, len + 1); + return 0; +} + +int OS_GetRootSpec(OSPathSpec *spec) { + strcpy(spec->s, "/"); + return 0; +} + +char *OS_SpecToString(const OSSpec *spec, char *path, int size) { + int plen; + int nlen; + + if (!size) + size = 256; + + if (!path) { + path = malloc(size); + if (!path) + return 0; + } + + plen = strlen(spec->path.s); + nlen = strlen(spec->name.s); + if ((plen + nlen) >= size) { + if (plen >= size) { + nlen = 0; + plen = size - 1; + } else { + nlen = (size - plen) - 1; + } + } + + memcpy(path, spec->path.s, plen); + memcpy(&path[plen], spec->name.s, nlen); + path[plen + nlen] = 0; + return path; +} + +char *OS_PathSpecToString(const OSPathSpec *pspec, char *path, int size) { + int plen; + + if (!size) + size = 256; + + if (!path) { + path = malloc(size); + if (!path) + return 0; + } + + plen = strlen(pspec->s); + if (plen >= size) + plen = size - 1; + + memcpy(path, pspec->s, plen); + path[plen] = 0; + return path; +} + +char *OS_NameSpecToString(const OSNameSpec *nspec, char *name, int size) { + int nlen; + + if (!size) + size = 64; + + if (!name) { + name = malloc(size); + if (!name) + return 0; + } + + nlen = strlen(nspec->s); + if (nlen >= size) + nlen = size - 1; + + memcpy(name, nspec->s, nlen); + name[nlen] = 0; + return name; +} + +int OS_SizeOfPathSpec(const OSPathSpec *spec) { + return strlen(spec->s) + 1; +} + +int OS_SizeOfNameSpec(const OSNameSpec *spec) { + return strlen(spec->s) + 1; +} + +int OS_EqualSpec(const OSSpec *a, const OSSpec *b) { + return OS_EqualPathSpec(&a->path, &b->path) && OS_EqualNameSpec(&a->name, &b->name); +} + +int OS_EqualPathSpec(const OSPathSpec *a, const OSPathSpec *b) { + return !strcmp(a->s, b->s); +} + +int OS_EqualNameSpec(const OSNameSpec *a, const OSNameSpec *b) { + return !strcmp(a->s, b->s); +} + +int OS_IsDir(const OSSpec *spec) { + struct stat st; + + if (!OS_SpecToString(spec, intbuf, sizeof(intbuf))) + return 0; + if (stat(intbuf, &st) < 0) + return 0; + return ((st.st_mode & S_IFMT) == S_IFDIR); +} + +int OS_IsFile(const OSSpec *spec) { + struct stat st; + + if (!OS_SpecToString(spec, intbuf, sizeof(intbuf))) + return 0; + if (stat(intbuf, &st) < 0) + return 0; + return ((st.st_mode & S_IFMT) != S_IFDIR); +} + +int OS_IsLink(const OSSpec *spec) { + struct stat st; + char *ptr; + + if (!OS_SpecToString(spec, intbuf, sizeof(intbuf))) + return 0; + + ptr = intbuf + strlen(intbuf) - 1; + if (*ptr == '/') + *ptr = 0; + + if (lstat(intbuf, &st) < 0) + return 0; + + return ((st.st_mode & S_IFMT) == S_IFLNK); +} + +int OS_ResolveLink(const OSSpec *link, OSSpec *target) { + char fn[64]; + char path[256]; + int len; + + if (!OS_SpecToString(link, intbuf, sizeof(intbuf))) + return ENAMETOOLONG; + + len = readlink(intbuf, fn, sizeof(fn)); + if (len < 0) + return errno; + fn[len] = 0; + + sprintf(path, "%s%s", (fn[0] != '/') ? link->path.s : "", fn); + return OS_MakeSpec(path, target, 0); +} + +int OS_OpenDir(const OSPathSpec *spec, OSOpenedDir *ref) { + DIR *dptr; + + CONVERT_PATHSPEC(spec, intbuf); + dptr = opendir(intbuf); + if (!dptr) { + ref->dir = 0; + return errno; + } + + ref->spec = *spec; + ref->dir = dptr; + return 0; +} + +int OS_ReadDir(OSOpenedDir *ref, OSSpec *spec, char *filename, Boolean *isfile) { + struct dirent *de; + char fn[256]; + int err; + int len; + + do { + de = readdir(ref->dir); + if (!de) + return ENOENT; + } while (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..") || (strlen(ref->spec.s) + strlen(de->d_name) >= 256)); + + len = strlen(ref->spec.s); + strncpy(fn, ref->spec.s, 255); + if (len < 256) { + strncpy(&fn[len], de->d_name, 255 - len); + fn[255] = 0; + } else { + return ENAMETOOLONG; + } + + strncpy(filename, de->d_name, 63); + filename[63] = 0; + + return OS_MakeSpec(fn, spec, isfile); +} + +int OS_CloseDir(OSOpenedDir *ref) { + if (ref->dir) + return closedir(ref->dir); + else + return 0; +} + +UInt32 OS_GetMilliseconds() { + struct tms tms; + return times(&tms) * 1000 / CLOCKS_PER_SEC; +} + +void OS_GetTime(time_t *p) { + time(p); +} + +int OS_NewHandle(UInt32 size, OSHandle *hand) { + hand->addr = 0; + hand->used = size; + hand->size = (size + 256) & ~255; + hand->addr = malloc(hand->size); + return !hand->addr ? ENOMEM : 0; +} + +int OS_ResizeHandle(OSHandle *hand, UInt32 size) { + UInt32 nsize; + void *naddr; + + nsize = (size + 256) & ~255; + naddr = realloc(hand->addr, nsize); + if (!naddr) + return ENOMEM; + + hand->addr = naddr; + hand->size = nsize; + hand->used = size; + return 0; +} + +void *OS_LockHandle(OSHandle *hand) { + return hand->addr; +} + +void OS_UnlockHandle(OSHandle *hand) { +} + +int OS_FreeHandle(OSHandle *hand) { + if (!hand->addr) + return ENOMEM; + + free(hand->addr); + hand->size = 0; + hand->used = 0; + hand->addr = 0; + return 0; +} + +int OS_GetHandleSize(OSHandle *hand, UInt32 *size) { + if (hand->addr) { + *size = hand->used; + return 0; + } else { + *size = 0; + return ENOMEM; + } +} + +void OS_InvalidateHandle(OSHandle *hand) { + hand->addr = 0; + hand->used = 0; +} + +Boolean OS_ValidHandle(OSHandle *hand) { + return (hand && hand->addr); +} + +OSErr OS_MacError(int err) { + switch (err) { + case 0: return noErr; + case ENOENT /*2*/: return fnfErr; + case EFAULT /*14*/: + case EINVAL /*22*/: return paramErr; + case ENOTDIR /*20*/: return dirNFErr; + case EISDIR /*21*/: return notAFileErr; + case ENAMETOOLONG /*63*/: return bdNamErr; + case EBUSY /*16*/: return memLockedErr; + case E2BIG /*7*/: + case ENOMEM /*12*/: return memFullErr; + case EACCES /*13*/: return permErr; + case EIO /*5*/: return ioErr; + case EEXIST /*17*/: return dupFNErr; + case EMFILE /*24*/: return tmfoErr; + case EFBIG /*27*/: return fsDataTooBigErr; + case EBADF /*9*/: return rfNumErr; + case EINTR /*4*/: return abortErr; + default: return (OSErr) (0xFFFF8000 | err); + } +} + +void OS_TimeToMac(time_t sectm, UInt32 *secs) { + struct tm *tmrec; + int years; + int ydays; + + tmrec = localtime(§m); + // this is horrendous lol +} + +void OS_MacToTime(UInt32 secs, time_t *sectm) { + struct tm tmrec; + int month; +} + +SInt16 OS_RefToMac(int ref) { + //return (ref >= -1) ? (ref + 1) : ref; + // wtf is going on here augh +} + +int OS_MacToRef(SInt16 refnum) { + return (refnum >= 0) ? (refnum - 1) : -1; +} + +int OS_OpenLibrary(const char *a, void **lib) { + *lib = 0; + lastdlerr = "No support for shared libraries"; + return OSErrNeg2; +} + +int OS_GetLibrarySymbol(void *a, void *b, void **sym) { + *sym = 0; + lastdlerr = "No support for shared libraries"; + return OSErrNeg2; +} + +int OS_CloseLibrary(void *a) { + lastdlerr = "No support for shared libraries"; + return OSErrNeg2; +} + +int OS_LoadMacResourceFork(const OSSpec *spec, void **file_data, SInt32 *file_len) { + return ENOENT; +} + +int OS_IsMultiByte(const char *str, int offset) { + return 0; +} diff --git a/command_line/CmdLine/Src/OSLib/StringExtras.c b/command_line/CmdLine/Src/OSLib/StringExtras.c index e69de29..04ef6b4 100644 --- a/command_line/CmdLine/Src/OSLib/StringExtras.c +++ b/command_line/CmdLine/Src/OSLib/StringExtras.c @@ -0,0 +1,17 @@ +#include "oslib.h" + +char *strcatn(char *d, const char *s, SInt32 max) { + +} + +char *strcpyn(char *d, const char *s, SInt32 len, SInt32 max) { + +} + +int ustrcmp(const char *src, const char *dst) { + +} + +int ustrncmp(const char *src, const char *dst, UInt32 len) { + +} diff --git a/command_line/CmdLine/Src/OSLib/StringUtils.c b/command_line/CmdLine/Src/OSLib/StringUtils.c index e69de29..5f0d5bd 100644 --- a/command_line/CmdLine/Src/OSLib/StringUtils.c +++ b/command_line/CmdLine/Src/OSLib/StringUtils.c @@ -0,0 +1,49 @@ +#include "oslib.h" + +StringPtr _pstrcpy(StringPtr dst, ConstStringPtr src) { + +} + +void _pstrcat(StringPtr dst, ConstStringPtr src) { + +} + +void _pstrcharcat(StringPtr to, char ch) { + +} + +void pstrncpy(StringPtr to, ConstStringPtr from, int max) { + +} + +void pstrncat(StringPtr to, ConstStringPtr append, int max) { + +} + +int pstrcmp(ConstStringPtr a, ConstStringPtr b) { + +} + +int pstrchr(ConstStringPtr str, char find) { + +} + +void c2pstrcpy(StringPtr dst, const char *src) { + +} + +void p2cstrcpy(char *dst, ConstStringPtr src) { + +} + +char *mvprintf(char *mybuf, unsigned int len, const char *format, va_list va) { + +} + +char *mprintf(char *mybuf, unsigned int len, const char *format, ...) { + +} + +int HPrintF(Handle text, const char *format, ...) { + +} -- cgit v1.2.3