<?
if {[info exists ::xvfs::xvfsCoreH]} {
?><?= $::xvfs::xvfsCoreH ?><?
} else {
?>#include <xvfs-core.h><? } ?>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <tcl.h>
#define XVFS_NAME_LOOKUP_ERROR (-1)
#define XVFS_FILE_BLOCKSIZE 1024
/*
* XXX:TODO: Determine this automatically rather than
* by heuristics
*/
#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
#define HAVE_STRUCT_STAT_ST_BLOCKS 1
#ifdef WIN32
# undef HAVE_STRUCT_STAT_ST_BLKSIZE
# undef HAVE_STRUCT_STAT_ST_BLOCKS
#endif
#ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef HAVE_DEFINED_XVFS_FILE_TYPE_T
#define HAVE_DEFINED_XVFS_FILE_TYPE_T 1
typedef enum {
XVFS_FILE_TYPE_REG,
XVFS_FILE_TYPE_DIR
} xvfs_file_type_t;
#endif
#ifndef HAVE_DEFINED_XVFS_SIZE_T
#define HAVE_DEFINED_XVFS_SIZE_T 1
typedef Tcl_WideInt xvfs_size_t;
#endif
#ifndef HAVE_DEFINED_XVFS_FILE_DATA
#define HAVE_DEFINED_XVFS_FILE_DATA 1
struct xvfs_file_data {
const char * const name;
const xvfs_file_type_t type;
const xvfs_size_t size;
union {
const unsigned char * const fileContents;
const char **dirChildren;
} data;
};
#endif
<?
package require xvfs
xvfs::main $::xvfs::argv
?>
static long xvfs_<?= $::xvfs::fsName ?>_nameToIndex(const char *path) {
<?
if {[llength $::xvfs::outputFiles] < 3} {
set hashMode perfectHashFunction
} else {
set hashMode hashTable
}
if {$hashMode eq "hashTable"} {
set hashTable [::xvfs::generateHashTable pathIndex path pathLen XVFS_NAME_LOOKUP_ERROR $::xvfs::outputFiles prefix "\t" hashTableSize 30 validate "strcmp(path, xvfs_${::xvfs::fsName}_data\[pathIndex\].name) == 0" onValidated "return(pathIndex);"]
set hashTableHeader [dict get $hashTable header]
puts $hashTableHeader
}
?> long pathIndex;
ssize_t pathLen;
if (path == NULL) {
return(XVFS_NAME_LOOKUP_ERROR);
}
pathLen = strlen(path);
<?
if {$hashMode eq "perfectHashFunction"} {
?>
pathIndex = <?= [::xvfs::generatePerfectHashFunctionCall "path" pathLen XVFS_NAME_LOOKUP_ERROR $::xvfs::outputFiles] ?>;
if (pathIndex < 0 || pathIndex >= <?= [llength $::xvfs::outputFiles] ?>) {
pathIndex = XVFS_NAME_LOOKUP_ERROR;
}
if (pathIndex != XVFS_NAME_LOOKUP_ERROR) {
if (strcmp(path, xvfs_<?= $::xvfs::fsName ?>_data[pathIndex].name) == 0) {
return(pathIndex);
}
}
<?
} else {
puts [dict get $hashTable body]
}
?>
return(XVFS_NAME_LOOKUP_ERROR);
}
static const char **xvfs_<?= $::xvfs::fsName ?>_getChildren(const char *path, Tcl_WideInt *count) {
const struct xvfs_file_data *fileInfo;
long inode;
/*
* Validate input parameters
*/
if (count == NULL) {
return(NULL);
}
/*
* Get the inode from the lookup function
*/
inode = xvfs_<?= $::xvfs::fsName ?>_nameToIndex(path);
if (inode == XVFS_NAME_LOOKUP_ERROR) {
*count = XVFS_RV_ERR_ENOENT;
return(NULL);
}
fileInfo = &xvfs_<?= $::xvfs::fsName ?>_data[inode];
/*
* Ensure this is a directory
*/
if (fileInfo->type != XVFS_FILE_TYPE_DIR) {
*count = XVFS_RV_ERR_ENOTDIR;
return(NULL);
}
*count = fileInfo->size;
return(fileInfo->data.dirChildren);
}
static const unsigned char *xvfs_<?= $::xvfs::fsName ?>_getData(const char *path, Tcl_WideInt start, Tcl_WideInt *length) {
const struct xvfs_file_data *fileInfo;
Tcl_WideInt resultLength;
long inode;
/*
* Validate input parameters
*/
if (length == NULL) {
return(NULL);
}
if (start < 0) {
*length = XVFS_RV_ERR_EINVAL;
return(NULL);
}
if (*length < 0) {
*length = XVFS_RV_ERR_EINVAL;
return(NULL);
}
/*
* Get the inode from the lookup function
*/
inode = xvfs_<?= $::xvfs::fsName ?>_nameToIndex(path);
if (inode == XVFS_NAME_LOOKUP_ERROR) {
*length = XVFS_RV_ERR_ENOENT;
return(NULL);
}
fileInfo = &xvfs_<?= $::xvfs::fsName ?>_data[inode];
/*
* Ensure this is a file that can be read
*/
if (fileInfo->type != XVFS_FILE_TYPE_REG) {
*length = XVFS_RV_ERR_EISDIR;
return(NULL);
}
/*
* Validate the length
*/
if (start > fileInfo->size) {
*length = XVFS_RV_ERR_EFAULT;
return(NULL);
}
if (*length == 0) {
resultLength = fileInfo->size - start;
} else {
resultLength = MIN(fileInfo->size - start, *length);
}
*length = resultLength;
/*
* Return the data
*/
return(fileInfo->data.fileContents + start);
}
static int xvfs_<?= $::xvfs::fsName ?>_getStat(const char *path, Tcl_StatBuf *statBuf) {
const struct xvfs_file_data *fileInfo;
long inode;
/*
* Validate input parameters
*/
if (!statBuf) {
return(XVFS_RV_ERR_EINVAL);
}
/*
* Get the inode from the lookup function
*/
inode = xvfs_<?= $::xvfs::fsName ?>_nameToIndex(path);
if (inode == XVFS_NAME_LOOKUP_ERROR) {
return(XVFS_RV_ERR_ENOENT);
}
fileInfo = &xvfs_<?= $::xvfs::fsName ?>_data[inode];
statBuf->st_dev = <?= [zlib adler32 $::xvfs::fsName] ?>;
statBuf->st_rdev = <?= [zlib adler32 $::xvfs::fsName] ?>;
statBuf->st_ino = inode;
statBuf->st_uid = 0;
statBuf->st_gid = 0;
statBuf->st_atime = 0;
statBuf->st_ctime = 0;
statBuf->st_mtime = 0;
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
statBuf->st_blksize = XVFS_FILE_BLOCKSIZE;
#endif
if (fileInfo->type == XVFS_FILE_TYPE_REG) {
statBuf->st_mode = 0100444;
statBuf->st_nlink = 1;
statBuf->st_size = fileInfo->size;
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
statBuf->st_blocks = (fileInfo->size + statBuf->st_blksize - 1) / statBuf->st_blksize;
#endif
} else if (fileInfo->type == XVFS_FILE_TYPE_DIR) {
statBuf->st_mode = 040555;
statBuf->st_nlink = fileInfo->size;
statBuf->st_size = fileInfo->size;
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
statBuf->st_blocks = 1;
#endif
}
return(0);
}
static struct Xvfs_FSInfo xvfs_<?= $::xvfs::fsName ?>_fsInfo = {
.protocolVersion = XVFS_PROTOCOL_VERSION,
.name = "<?= $::xvfs::fsName ?>",
.getChildrenProc = xvfs_<?= $::xvfs::fsName ?>_getChildren,
.getDataProc = xvfs_<?= $::xvfs::fsName ?>_getData,
.getStatProc = xvfs_<?= $::xvfs::fsName ?>_getStat
};
int Xvfs_<?= $::xvfs::fsName ?>_Init(Tcl_Interp *interp) {
int register_ret;
#ifdef USE_TCL_STUBS
const char *tclInitStubs_ret;
/* Initialize Stubs */
tclInitStubs_ret = Tcl_InitStubs(interp, TCL_PATCH_LEVEL, 0);
if (!tclInitStubs_ret) {
return(TCL_ERROR);
}
#endif
register_ret = Xvfs_Register(interp, &xvfs_<?= $::xvfs::fsName ?>_fsInfo);
if (register_ret != TCL_OK) {
return(register_ret);
}
return(TCL_OK);
}
#undef XVFS_NAME_LOOKUP_ERROR
#undef XVFS_FILE_BLOCKSIZE