mirror of
https://github.com/idris-lang/Idris2.git
synced 2024-12-24 20:23:11 +03:00
238 lines
4.3 KiB
C
238 lines
4.3 KiB
C
#include "getline.h"
|
|
#include "idris_file.h"
|
|
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <sys/time.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
#ifdef _WIN32
|
|
#include "windows/win_utils.h"
|
|
#else
|
|
#include <sys/select.h>
|
|
#endif
|
|
|
|
#include "idris_util.h"
|
|
|
|
FILE* idris2_openFile(char* name, char* mode) {
|
|
#ifdef _WIN32
|
|
FILE *f = win32_u8fopen(name, mode);
|
|
#else
|
|
FILE *f = fopen(name, mode);
|
|
#endif
|
|
return (void *)f;
|
|
}
|
|
|
|
void idris2_closeFile(FILE* f) {
|
|
IDRIS2_VERIFY(fclose(f) == 0, "fclose failed: %s", strerror(errno));
|
|
}
|
|
|
|
int idris2_getFileNo(FILE* f) {
|
|
#ifdef _WIN32
|
|
return win32_getFileNo(f);
|
|
#else
|
|
return fileno(f);
|
|
#endif
|
|
}
|
|
|
|
int idris2_fileError(FILE* f) {
|
|
return ferror(f);
|
|
}
|
|
|
|
int idris2_fileErrno() {
|
|
switch(errno) {
|
|
case ENOENT:
|
|
return 2;
|
|
case EACCES:
|
|
return 3;
|
|
case EEXIST:
|
|
return 4;
|
|
default:
|
|
return (errno + 5);
|
|
}
|
|
}
|
|
|
|
int idris2_chmod(const char* path, mode_t mode) {
|
|
#ifdef _WIN32
|
|
// return _chmod(path, mode);
|
|
return 0; /* ??? (from win_hack.c) */
|
|
#else
|
|
return chmod(path, mode);
|
|
#endif
|
|
}
|
|
|
|
int idris2_removeFile(const char *filename) {
|
|
return remove(filename);
|
|
}
|
|
|
|
int idris2_fileSize(FILE* f) {
|
|
int fd = idris2_getFileNo(f);
|
|
|
|
struct stat buf;
|
|
if (fstat(fd, &buf) == 0) {
|
|
return (int)(buf.st_size);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int idris2_fpoll(FILE* f)
|
|
{
|
|
#ifdef _WIN32
|
|
return win_fpoll(f);
|
|
#else
|
|
fd_set x;
|
|
struct timeval timeout;
|
|
timeout.tv_sec = 1;
|
|
timeout.tv_usec = 0;
|
|
int fd = idris2_getFileNo(f);
|
|
|
|
FD_ZERO(&x);
|
|
FD_SET(fd, &x);
|
|
|
|
int r = select(fd+1, &x, 0, 0, &timeout);
|
|
return r;
|
|
#endif
|
|
}
|
|
|
|
void *idris2_popen(const char *cmd, const char *mode) {
|
|
#ifdef _WIN32
|
|
FILE *f = win32_u8popen(cmd, mode);
|
|
#else
|
|
FILE *f = popen(cmd, mode);
|
|
#endif
|
|
return f;
|
|
}
|
|
|
|
int idris2_pclose(void *stream) {
|
|
#ifdef _WIN32
|
|
int r = _pclose(stream);
|
|
IDRIS2_VERIFY(r != -1, "pclose failed");
|
|
return r;
|
|
#else
|
|
int r = pclose(stream);
|
|
IDRIS2_VERIFY(WIFEXITED(r), "pclose failed");
|
|
return WEXITSTATUS(r);
|
|
#endif
|
|
}
|
|
|
|
// seek through the next newline, consuming and
|
|
// throwing away anything until then.
|
|
int idris2_seekLine(FILE *f)
|
|
{
|
|
while (1) {
|
|
int c = fgetc(f);
|
|
if (c == -1) {
|
|
if (feof(f)) {
|
|
return 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
if (c == '\n') {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
char* idris2_readLine(FILE* f) {
|
|
char *buffer = NULL;
|
|
size_t n = 0;
|
|
ssize_t len;
|
|
len = getline(&buffer, &n, f);
|
|
if (len < 0 && buffer != NULL) {
|
|
buffer[0] = '\0'; // Copy Idris 1 behaviour - empty string if nothing read
|
|
}
|
|
return buffer; // freed by RTS if not NULL
|
|
}
|
|
|
|
char* idris2_readChars(int num, FILE* f) {
|
|
char *buffer = malloc((num+1)*sizeof(char));
|
|
size_t len;
|
|
len = fread(buffer, sizeof(char), (size_t)num, f);
|
|
buffer[len] = '\0';
|
|
|
|
if (len <= 0) {
|
|
return NULL;
|
|
} else {
|
|
return buffer; // freed by RTS
|
|
}
|
|
}
|
|
|
|
size_t idris2_readBufferData(FILE* h, char* buffer, size_t loc, size_t max) {
|
|
return fread(buffer + loc, sizeof(uint8_t), max, h);
|
|
}
|
|
|
|
int idris2_writeLine(FILE* f, char* str) {
|
|
if (fputs(str, f) == EOF) {
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
size_t idris2_writeBufferData(FILE* h, const char* buffer, size_t loc, size_t len) {
|
|
return fwrite(buffer + loc, sizeof(uint8_t), len, h);
|
|
}
|
|
|
|
int idris2_eof(FILE* f) {
|
|
return feof(f);
|
|
}
|
|
|
|
int idris2_fileAccessTime(FILE* f) {
|
|
int fd = idris2_getFileNo(f);
|
|
|
|
struct stat buf;
|
|
if (fstat(fd, &buf) == 0) {
|
|
return buf.st_atime;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int idris2_fileModifiedTime(FILE* f) {
|
|
int fd = idris2_getFileNo(f);
|
|
|
|
struct stat buf;
|
|
if (fstat(fd, &buf) == 0) {
|
|
return buf.st_mtime;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int idris2_fileStatusTime(FILE* f) {
|
|
int fd = idris2_getFileNo(f);
|
|
|
|
struct stat buf;
|
|
if (fstat(fd, &buf) == 0) {
|
|
return buf.st_ctime;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int idris2_fileIsTTY(FILE* f) {
|
|
int fd = idris2_getFileNo(f);
|
|
#ifdef _WIN32
|
|
return win32_isTTY(fd);
|
|
#else
|
|
return isatty(fd);
|
|
#endif
|
|
}
|
|
|
|
FILE* idris2_stdin() {
|
|
return stdin;
|
|
}
|
|
|
|
FILE* idris2_stdout() {
|
|
return stdout;
|
|
}
|
|
|
|
FILE* idris2_stderr() {
|
|
return stderr;
|
|
}
|