* tads2/osifc.h.  Only functions needed by the TADS 3 compiler are

 * implemented here.

 *

 * The functions are "portable"; they don't make use of curses/ncurses.

 */

#include "common.h"

#include <stdio.h>

#include <string.h>

extern "C" {

#include <sys/stat.h>

#include <dirent.h>

}

#ifdef HAVE_GLOB_H

#include <glob.h>

#endif

#include "os.h"

/* Set the game title.

 *

 * Does nothing in the compiler.  This should actually be implemented in

 * tads3/os_stdio.cpp, but for some reason it's not.

 */

void

os_set_title( const char* )

{

}

/* Get the modification time for a file.

 */

int

os_get_file_mod_time( os_file_time_t* t, const char* fname )

{

	struct stat inf;

	if (stat(fname, &inf) != 0) return 1;

	t->t = inf.st_mtime;

	return 0;

}

/* Compare two file time values.

 */

int

os_cmp_file_times( const os_file_time_t* a, const os_file_time_t* b )

{

	if (a->t < b->t) return -1;

	if (a->t == b->t) return 0;

	return 1;

}

/* Install/uninstall the break handler.

 *

 * I don't think we need a break handler.

 */

void

os_instbrk( int )

{

}

/* We implement the file searching routines using <glob.h>.  It's not

 * available on all systems though, so we provide dummy fallbacks that

 * do nothing if <glob.h> doesn't exist.

 */

#ifdef HAVE_GLOB

/* Search context structure.

 */

struct oss_find_ctx_t

{

	glob_t* pglob;

	// Index of current filename in pglob->gl_pathv.

	size_t current;

	// Original search path prefix (we'll allocate more to fit the

	// string).

	char path[1];

};

/* Service routine for searching - build the full output path name.

 */

static void

oss_build_outpathbuf( char* outpathbuf, size_t outpathbufsiz, const char* path,

                      const char* fname )

{

	// If there's a full path buffer, build the full path.

	if (outpathbuf != 0) {

		size_t lp;

		size_t lf;

		// Copy the path prefix.

		lp = strlen(path);

		if (lp > outpathbufsiz - 1) {

			lp = outpathbufsiz - 1;

		}

		memcpy(outpathbuf, path, lp);

		// Add the filename if there's any room.

		lf = strlen(fname);

		if (lf > outpathbufsiz - lp - 1) {

			lf = outpathbufsiz - lp - 1;

		}

		memcpy(outpathbuf + lp, fname, lf);

		// Null-terminate the result.

		outpathbuf[lp + lf] = '\0';

	}

}

/* Find the first file matching a given pattern.

 */

void*

os_find_first_file( const char* dir, const char* pattern, char* outbuf, size_t outbufsiz,

                    int* isdir, char* outpathbuf, size_t outpathbufsiz)

{

	char realpat[OSFNMAX];

	size_t l;

	size_t path_len;

	const char* lastsep;

	const char* p;

	struct oss_find_ctx_t* ctx = 0;

	strcpy(realpat, dir);

	if ((l = strlen(realpat)) != 0 && realpat[l - 1] != '/') {

		realpat[l++] = '/';

	}

	if (pattern == 0) {

		strcpy(realpat + l, "*");

	} else {

		strcpy(realpat + l, pattern);

	}

	// Find the last separator in the original path.

	for (p = realpat, lastsep = 0 ; *p != '\0' ; ++p) {

		// If this is a separator, remember it.

		if (*p == '/') lastsep = p;

	}

	// If we found a separator, the path prefix is everything up to

	// and including the separator; otherwise, there's no path

	// prefix.

	if (lastsep != 0) {

		// The length of the path includes the separator.

		path_len = lastsep + 1 - realpat;

	} else {

		// There's no path prefix - everything is in the

		// current directory.

		path_len = 0;

	}

	// Allocate a context.

	ctx = static_cast(struct oss_find_ctx_t*)(malloc(sizeof(struct oss_find_ctx_t) + path_len));

	ctx->pglob = static_cast(glob_t *)(malloc(sizeof(glob_t)));

	ctx->current = -1;

	// Copy the path to the context. we may need it later to build

	// a full path.

	memcpy(ctx->path, realpat, path_len);

	ctx->path[path_len] = '\0';

	// Problem: before calling glob() we need to escape all [] in

	// realpat.  Count them first.

	int nbracket = 0;

	for (p = realpat; *p != '\0' ; ++p) {

		if (*p == '[' || *p == ']') ++nbracket;

	}

	// Allocate string for escaped pattern.

	char* escaped_realpat = static_cast(char*)(malloc(strlen(realpat) + nbracket + 1));

	// Copy pattern to new string, escaping all [ and ] with \.

	char* c = realpat;

	char* k = escaped_realpat;

	while (*c != '\0') {

		if (*c == '[' || *c == ']') {

			*k++ = '\\';

		}

		*k++ = *c++;

	}

	*k++ = '\0';

	int res = glob(escaped_realpat, GLOB_ERR | GLOB_MARK, NULL, ctx->pglob);

	if (res != 0) {

		// We don't really care what kind of error occured.

		// Just free the resources and return error. Note that

		// "no files found" is an error.

		if (ctx->pglob != 0) {

			globfree(ctx->pglob);

			free(ctx->pglob);

		}

		if (ctx != 0) {

			free(ctx);

		}

		free(escaped_realpat);

		*isdir = 0;

		return 0;

	}

	// If we get there, there was a match. set current index for

	// os_find_next().

	ctx->current = 0;

	// glob() returns filename with directory, but we need just the

	// basename. Copy first filename into the caller's buffer.

	char* ptr = &ctx->pglob->gl_pathv[0][path_len];

	l = strlen(ptr);

	if (l > outbufsiz - 1) {

		l = outbufsiz - 1;

	}

	memcpy(outbuf, ptr, l);

	outbuf[l] = '\0';

	// Build the full path, if desired.

	oss_build_outpathbuf(outpathbuf, outpathbufsiz, ctx->path, ptr);

	// Return the directory indication.

	*isdir = (ptr[l-1] == '/') ? true : false;

	free(escaped_realpat);

	return ctx;

}

/* Find the next matching file, continuing a search started with

 * os_find_first_file().

 */

void*

os_find_next_file( void* ctx0, char* outbuf, size_t outbufsiz, int* isdir, char* outpathbuf,

                   size_t outpathbufsiz )

{

	struct oss_find_ctx_t* ctx = static_cast(struct oss_find_ctx_t*)(ctx0);

	size_t l;

	// If the search has already ended, do nothing.

	if (ctx == 0) return 0;

	if (++ctx->current > ctx->pglob->gl_pathc - 1) {

		// No more files - delete the context and give up.

		globfree(ctx->pglob);

		free(ctx->pglob);

		free(ctx);

		// Indicate that the search is finished.

		return 0;

	}

	// Return the name. See comments in os_find_first_file().

	l = strlen(ctx->path);

	char* ptr = &ctx->pglob->gl_pathv[ctx->current][l];

	l = strlen(ptr);

	if (l > outbufsiz - 1) {

		l = outbufsiz - 1;

	}

	memcpy(outbuf, ptr, l);

	outbuf[l] = '\0';

	// Return the directory indication.

	*isdir = (ptr[l-1] == '/') ? true : false;

	// Build the full path, if desired.

	oss_build_outpathbuf(outpathbuf, outpathbufsiz, ctx->path, ptr);

	// Indicate that the search was successful by returning the

	// non-null context pointer -- the context has been updated for

	// the new position in the search, so we just return the same

	// context structure that we've been using all along.

	return ctx;

}

/* Cancel a search.

 */

void

os_find_close( void* ctx0 )

{

	struct oss_find_ctx_t* ctx = static_cast(struct oss_find_ctx_t*)(ctx0);

	// If the search was already cancelled, do nothing.

	if (ctx == 0) return;

	// Delete the search context.

	if (ctx->pglob != 0) {

		globfree(ctx->pglob);

		free(ctx->pglob);

	}

	free(ctx);

}

#else

/* <glob.h> isn't available.  We just provide do-nothing dummies.

 */

void*

os_find_first_file( const char* /*dir*/, const char* /*pattern*/, char* /*outbuf*/, size_t /*outbufsiz*/,

                    int* /*isdir*/, char* /*outpathbuf*/, size_t /*outpathbufsiz*/ )

{

	return 0;

}

void*

os_find_next_file( void* /*ctx*/, char* /*outbuf*/, size_t /*outbufsiz*/, int* /*isdir*/,

                   char* /*outpathbuf*/, size_t /*outpathbufsiz*/ )

{

	return 0;

}

void

os_find_close( void* /*ctx*/ )

{

}

#endif // HAVE_GLOB

/* Determine if the given filename refers to a special file.

 *

 * tads2/osnoui.c defines its own version when MSDOS is defined.

 */

#ifndef MSDOS

os_specfile_t

os_is_special_file( const char* fname )

{

	// We also check for "./" and "../" instead of just "." and

	// "..".  (We use OSPATHCHAR instead of '/' though.)

	const char selfWithSep[3] = {'.', OSPATHCHAR, '\0'};

	const char parentWithSep[4] = {'.', '.', OSPATHCHAR, '\0'};

	if ((strcmp(fname, ".") == 0) or (strcmp(fname, selfWithSep) == 0)) return OS_SPECFILE_SELF;

	if ((strcmp(fname, "..") == 0) or (strcmp(fname, parentWithSep) == 0)) return OS_SPECFILE_PARENT;

	return OS_SPECFILE_NONE;

}

#endif

/* Initialize.

 */

int

os_init( int*, char**, const char*, char*, int )

{

	return 0;

}

/* Uninitialize.

 */

void

os_uninit( void )

{

}

/* =====================================================================

 * These functions are currently not used by the compiler.  If the

 * linker barks, we must implement them.

 */

/* Get the creation time for a file.

 */

/*

int

os_get_file_cre_time( os_file_time_t* t, const char* fname )

{

}

*/

/* Get the access time for a file.

 */

/*

int

os_get_file_acc_time( os_file_time_t* t, const char* fname )

{

}

*/

/* Switch to a new working directory.

 */

/*

oid

os_set_pwd( const char* dir )

{

}

*/

/* Switch the working directory to the directory containing the given

 * file.

 */

/*

void

os_set_pwd_file( const char* filename )

{

}