github.com/Interlisp.maiko
1
0
Fork 0
mirror of https://github.com/Interlisp/maiko.git synced 2026-01-11 23:43:19 +00:00
Code Issues Projects Releases Wiki Activity
Interlisp.maiko/inc/locfile.h
Nick Briggs 67f8cc0cf0 Cleanup UnixVersionToLispVersion and LispVersionToUnixVersion 
* implements these as functions rather than #define macros
  * moves definitions to ufs.c
  * adds parameter to UnixVersionToLispVersion for the storage
    size of the buffer being passed
  * removes inc/lispver2.h
  * adjusts makefile-dos an makefile-tail to update dependencies
2025-10-20 14:31:18 -07:00

464 lines
14 KiB
C
Raw Permalink Blame History

#ifndef LOCFILE_H
#define LOCFILE_H 1
/* $Id: locfile.h,v 1.2 1999/01/03 02:06:13 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved */
/************************************************************************/
/* */
/* (C) Copyright 1989-94 Venue. All Rights Reserved. */
/* Manufactured in the United States of America. */
/* */
/************************************************************************/
#include <errno.h>
#include <limits.h> /* for NAME_MAX */
#include <dirent.h> /* for MAXNAMLEN */
#include "lispemul.h" /* for DLword */
#include "commondefs.h" /* for error */
#define FDEV_PAGE_SIZE 512 /* 1 page == 512 byte */
#define RECOG_OLD (S_POSITIVE | 0)
#define RECOG_OLDEST (S_POSITIVE | 1)
#define RECOG_NEW (S_POSITIVE | 2)
#define RECOG_OLD_NEW (S_POSITIVE | 3)
#define RECOG_NON (S_POSITIVE | 5)
#define ACCESS_INPUT (S_POSITIVE | 0)
#define ACCESS_OUTPUT (S_POSITIVE | 1)
#define ACCESS_BOTH (S_POSITIVE | 2)
#define ACCESS_APPEND (S_POSITIVE | 3)
/* For getfileinfo */
#define LENGTH (S_POSITIVE | 1)
#define WDATE (S_POSITIVE | 2)
#define RDATE (S_POSITIVE | 3)
#define AUTHOR (S_POSITIVE | 5)
#define PROTECTION (S_POSITIVE | 6)
#define EOL (S_POSITIVE | 7)
#define ALL (S_POSITIVE | 8)
#define INODE_LO (S_POSITIVE | 9)
#define INODE_HI (S_POSITIVE | 10)
#define ToLispTime(x) ((int)(x) + 29969152)
/* For getfileinfo. For WDATE&RDATE */
/* 29969152 == (timer.c)LISP_UNIX_TIME_DIFF */
/* - 61200 == - 17hours */
#define ToUnixTime(x) ((int)(x) - 29969152)
/* For getfileinfo. For WDATE&RDATE */
/* 29969152 == (timer.c)LISP_UNIX_TIME_DIFF */
/*
* Copy memory between native memory locations accounting for potential
* byte-swapping necessary when then destination is within Lisp memory space
* though the provided destination pointer is a native address within the
* Lisp space.
*/
#define MemCpyToLispFromNative(lispbuf, cbuf, len) \
do { \
char *lf_sptr = (cbuf); \
char *lf_dptr = (lispbuf); \
for (size_t lf_i = 0; lf_i < (len); lf_i++) *BYTEPTR(lf_dptr++) = *lf_sptr++; \
} while (0)
#define FGetNum(ptr, place) do { \
if(((ptr) & SEGMASK)== S_POSITIVE) {(place) = ((ptr) & 0xffff);}\
else if(((ptr) & SEGMASK)== S_NEGATIVE) {(place) = (int)((ptr)| 0xffff0000);}\
else {return(NIL);}} while (0)
#ifndef min
#define min(a, b) (((a) <= (b))?(a):(b))
#endif /* min */
/************************************************************************/
/* */
/* L i s p S t r i n g T o C S t r i n g */
/* */
/* Convert the Lisp string in Lisp into a null-terminated C */
/* string in C. MaxLen is, for safety, the maximum length of */
/* the resulting string, so the buffer doesn't overflow and */
/* smash memory. */
/* */
/* WARNINGS: The Lisp string is truncated to fit the C string */
/* without warning to the user. FAT Lisp strings have only */
/* the low 8 bits of each character copied over. */
/* */
/************************************************************************/
#ifndef BYTESWAP
static void LispStringToCString(LispPTR Lisp, char *C, size_t MaxLen) {
OneDArray *lf_arrayp;
char *lf_base, *lf_dp;
short *lf_sbase;
size_t lf_length;
lf_arrayp = (OneDArray *)NativeAligned4FromLAddr(Lisp);
lf_length = min(MaxLen - 1, lf_arrayp->fillpointer);
lf_dp = (C);
switch (lf_arrayp->typenumber) {
case THIN_CHAR_TYPENUMBER:
lf_base = ((char *)(NativeAligned2FromLAddr(lf_arrayp->base))) + ((int)(lf_arrayp->offset));
strncpy(lf_dp, lf_base, lf_length);
lf_dp[lf_length] = '\0';
break;
case FAT_CHAR_TYPENUMBER:
lf_sbase = ((short *)(NativeAligned2FromLAddr(lf_arrayp->base))) + ((int)(lf_arrayp->offset));
for (size_t lf_i = 0; lf_i < (lf_length); lf_i++) *lf_dp++ = (char)(*lf_sbase++);
*lf_dp = '\0';
break;
default: error("LispStringToCString: Not a character array.\n");
}
}
#else /* BYTESWAP == T CHANGED-BY-TAKE */
static void LispStringToCString(LispPTR Lisp, char *C, size_t MaxLen) {
OneDArray *lf_arrayp;
char *lf_base, *lf_dp;
short *lf_sbase;
size_t lf_length;
lf_arrayp = (OneDArray *)(NativeAligned4FromLAddr(Lisp));
lf_length = min(MaxLen - 1, lf_arrayp->fillpointer);
lf_dp = (C);
switch (lf_arrayp->typenumber) {
case THIN_CHAR_TYPENUMBER:
lf_base = ((char *)(NativeAligned2FromLAddr(lf_arrayp->base))) + ((int)(lf_arrayp->offset));
for (size_t lf_i = 0; lf_i < lf_length; lf_i++) *lf_dp++ = GETBYTE(lf_base++);
break;
case FAT_CHAR_TYPENUMBER:
lf_sbase = ((short *)(NativeAligned2FromLAddr(lf_arrayp->base))) + ((int)(lf_arrayp->offset));
for (size_t lf_ii = 0; lf_ii < lf_length; lf_ii++) *lf_dp++ = (char)(GETWORD(lf_sbase++));
break;
default: error("LispStringToCString: Not a character array.\n");
}
*lf_dp = '\0';
}
#endif /* BYTESWAP */
/************************************************************************/
/* */
/* L i s p S t r i n g L e n g t h */
/* */
/* Get the byte length of the string in Lisp. */
/* */
/* As a side effect, sets FatP to 1 if LispString is fat, 0 otherwise */
/* Errors if LispString isn't a string (1-d array of characters) */
/* */
/************************************************************************/
#define LispStringLength(LispString, Length, FatP) \
do { \
OneDArray *lf_arrayp; \
lf_arrayp = (OneDArray *)(NativeAligned4FromLAddr(LispString)); \
switch(lf_arrayp->typenumber) \
{ \
case THIN_CHAR_TYPENUMBER: \
(Length) = lf_arrayp->fillpointer; \
(FatP) = 0; \
break; \
\
case FAT_CHAR_TYPENUMBER: \
(Length) = lf_arrayp->fillpointer * 2; \
(FatP) = 1; \
break; \
default: \
error("LispStringLength: Not a character array.\n"); \
} \
} while (0)
/************************************************************************/
/* */
/* S T R I N G _ B A S E */
/* */
/* Return (C-pointer) to the characters in lstringp, in cstringp. */
/* */
/************************************************************************/
#define STRING_BASE(lstringp, cstringp) \
do { \
LispPTR *lf_naddress; \
lf_naddress = (LispPTR *)(NativeAligned4FromLAddr(lstringp)); \
(cstringp) = (char *)(NativeAligned2FromLAddr(((OneDArray *)lf_naddress)->base)); \
} while (0)
#define LispNumToCInt(Lisp) \
( (((Lisp) & SEGMASK) == S_POSITIVE) ? ((Lisp) & 0xFFFF) : \
(((Lisp) & SEGMASK) == S_NEGATIVE) ? ((Lisp) | 0xFFFF0000) : \
(*((int *)(NativeAligned4FromLAddr(Lisp)))) )
#define UPLOWDIFF 0x20
#define DOWNCASE(name) do { \
\
char *lf_cp; \
\
for(lf_cp = (name); *lf_cp!='\0'; ++lf_cp) \
if((*lf_cp >= 'A') && (*lf_cp <= 'Z')) *lf_cp += UPLOWDIFF; \
} while (0)
#define UPCASE(name) do { \
\
char *lf_cp; \
\
for(lf_cp = (name); *lf_cp!='\0'; ++lf_cp) \
if((*lf_cp >= 'a') && (*lf_cp <= 'z')) *lf_cp -= UPLOWDIFF; \
} while (0)
#define DIR_OR_FILE_P(name, type) do { \
int lf_result; \
struct stat lf_statbuf; \
\
TIMEOUT(lf_result = stat(name, &lf_statbuf)); \
if (lf_result < 0) { \
*Lisp_errno = errno; \
(type) = 0; \
} else { \
switch (lf_statbuf.st_mode & S_IFMT) { \
\
case S_IFDIR: \
(type) = -1; \
break; \
\
case S_IFREG: \
(type) = 1; \
break; \
\
default: \
/* \
* Should we deal with the other \
* types? \
*/ \
(type) = 0; \
break; \
} \
} \
} while (0)
#define DIRP(path, dir, buf) do { \
int lf_rval; \
struct stat lf_statbuf; \
strcpy(buf, path); \
strcat(buf, dir); \
TIMEOUT( lf_rval=stat(buf, &lf_statbuf) ); \
if( lf_rval == 0){ \
if( (lf_statbuf.st_mode & S_IFMT) == S_IFDIR ){ \
strcat(path, dir); \
return(1); \
} \
} \
if( lf_rval == -1 && errno == 60){ \
*Lisp_errno = 60; \
return(0); \
} \
} while (0)
#define FILEP(path, file, buf) do { \
int lf_rval; \
strcpy(buf, path); \
strcat(buf, file); \
TIMEOUT( lf_rval=access(buf, F_OK) ); \
if( access(buf, F_OK) == 0){ \
strcat(path, file); \
return(1); \
} \
} while (0)
#define STREQ(name1, name2)( \
(*(name1) == *(name2)) && (strcmp(name1, name2) == 0) \
)
#define SPECIALFILEMARK (-1)
#define NumericStringP(str, truetag, falsetag) do { \
char *lfn_cp; \
\
/* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
if (*(str) == '\0') goto falsetag; \
\
for(lfn_cp = str; *lfn_cp!='\0'; ++lfn_cp) \
if(*lfn_cp < '0' || '9' < *lfn_cp) \
goto falsetag; /* NOLINT(bugprone-macro-parentheses) */ \
goto truetag; /* NOLINT(bugprone-macro-parentheses) */ \
} while (0)
/*
* Name: LispVersionToUnixVersion
*
* Argument: char *pathname
* Xerox Lisp syntax pathname.
*
* Value: On success returns 1, otherwise 0.
*
* Side Effect: The version part of pathname is destructively modified.
*
* Description:
*
* Destructively modify the version part of pathname which is following the
* Xerox Lisp file naming convention to UNIX one.
* If the file name which is passed from Lisp has the version part, it must be
* a valid one (i.e. constructed with only number). This is guaranteed by Lisp
* code.
* This macro should be called at the top of the routines which accept the
* file name from lisp before converting it into UNIX file name, because
* locating the version part, the information about quoted characters are needed.
* They might be lost in the course of the conversion.
*
*/
#ifdef DOS
/* DOS version of LispVersionToUnixVersion */
/* * * * * This is done this way because DOS can't handle the non-DOS version -- */
/* * * * * it gave "Too many characters in a character constant" errors! */
#include "lispver1.h"
#else /* DOS */
/* NON-DOS version is inline in ufs.c */
#endif /* DOS */
#define VERSIONLEN 24
#define MAXVERSION 999999999
#define LASTVERSIONARRAY ((unsigned) -1)
#define VERSIONARRAYCHUNKLENGTH 200
#define VERSIONARRAYMAXLENGTH 2000
#define NoFileP(varray) \
(((varray)->version_no == LASTVERSIONARRAY)? 1 : 0)
#ifdef DOS
#define OnlyVersionlessP(varray) 0
#else
#define OnlyVersionlessP(varray) \
(((varray)->version_no == 0 && ((varray) + 1)->version_no == LASTVERSIONARRAY) ? \
1 : 0)
#endif /* DOS */
/* An argument of AddDotNoExtension must be LispVersion convention */
/* Like "foo/fee.fee;3" or "/foo/foo;3" */
/* AddDotNoExtension must be put after UnixVersionToLispVersion */
#define AddDotNoExtension(file) do { \
char *lf_cp; \
char *lf_cp1; \
if( (strrchr(file,'.')== 0) && ((lf_cp=strrchr(file,';'))!=0) ){ \
for(lf_cp1=lf_cp;*lf_cp1!='\0';lf_cp1++); \
*(lf_cp1+1) = '\0'; \
for(;lf_cp!=lf_cp1;lf_cp1--) \
*lf_cp1 = *(lf_cp1-1); \
*lf_cp = '.'; \
} \
} while (0)
/* An argument of RemoveDotNoExtension must be LispVersion convention */
/* Like "foo/fee.fee;3" or "/foo/foo.;3" */
/* RemoveDotNoExtension must be put before LispVersionToUnixVersion */
#define RemoveDotNoExtension(file) do { \
char *lf_cp; \
if( ((lf_cp=strrchr(file, ';'))!=0) && (*(lf_cp-1)=='.') ){ \
for(;*lf_cp!='\0';++lf_cp) \
*(lf_cp-1) = *lf_cp; \
*(lf_cp-1) = '\0'; \
} \
} while (0)
#define ChangeToVersionless(pathname) do { \
char *lf_cp; \
if( (lf_cp=strrchr(pathname, ';')) != 0) \
*lf_cp = '\0'; \
} while (0)
#define UNLINK(x) do { \
TIMEOUT(lf_rval=unlink(x)); \
if(lf_rval == -1){ \
err_mess("unlink", errno); \
*Lisp_errno = errno; \
return(0); \
} \
} while (0)
#define LINK(x,y) do { \
TIMEOUT(lf_rval=link(x, y)); \
if(lf_rval == -1){ \
if(errno == 2) \
return(1); \
else{ \
err_mess("link", errno);\
*Lisp_errno = errno; \
return(0); \
} \
} \
} while (0)
#define RENAME(x,y) do { \
TIMEOUT(lf_rval=rename(x, y)); \
if(lf_rval == -1){ \
switch(errno){ \
case 2: \
return(1); \
case 18: \
*Lisp_errno = errno; \
return(0); \
default: \
err_mess("rename", errno);\
*Lisp_errno = errno; \
return(0); \
} \
} \
} while (0)
#define STAT(x,y) do { \
TIMEOUT(lf_rval=stat(x, y)); \
if(lf_rval != 0){ \
err_mess("stat", errno); \
*Lisp_errno = errno; \
return(-1); \
} \
} while (0)
/*
* For file name length check
*/
#define FNAMETOOLONG 200
#define FileNameTooLong(val) do { \
*Lisp_errno = FNAMETOOLONG; \
return((val)); \
} while (0)
/********************************************************/
/* file-system-specific defns */
/* */
/* DIRSEP = OS-specific directory separator character. */
/* UNIXDIRSEP = UNIX's " */
/* DRIVESEP = OS-specific drive separator character. */
/* (only used with DOS as of 3/93) */
/********************************************************/
#ifdef DOS
#define DIRSEP '\\'
#define DIRSEPSTR "\\"
#define DRIVESEP ':'
#define UNIXDIRSEP '/'
#define MAXNAMLEN _MAX_PATH
#else
#define DIRSEPSTR "/"
#define DIRSEP '/'
#define UNIXDIRSEP '/'
/* system includes may already define MAXNAMLEN */
#if !defined(MAXNAMLEN)
#define MAXNAMLEN NAME_MAX
#endif
#endif
#endif /* LOCFILE_H */
Reference in New Issue View Git Blame Copy Permalink