//## FILE FILE.new(String path, String mode);
static KMETHOD File_new(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char buffer[K_PATHMAX];
kString *path = sfp[1].asString;
const char *systemPath = I18NAPI formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace);
const char *mode = kString_text(sfp[2].asString);
FILE *fp = fopen(systemPath, mode);
kFile *file = (kFile *) sfp[0].asObject;
if(fp == NULL) {
int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|SystemError, trace);
KTraceErrorPoint(trace, fault, "fopen",
LogText("filename", kString_text(path)), LogText("mode", mode), LogErrno);
KLIB KRuntime_raise(kctx, KException_("IO"), fault, NULL, sfp);
}
if(mode[0] == 'w' || mode[0] == 'a' || mode[1] == '+') {
KTraceChangeSystemPoint(trace, "fopen", LogFileName(kString_text(path)), LogText("mode", mode));
}
file->fp = fp;
KFieldInit(file, file->PathInfoNULL, path);
if(!I18NAPI isSystemCharsetUTF8(kctx)) {
if(mode[0] == 'w' || mode[0] == 'a' || mode[1] == '+') {
file->writerIconv = I18NAPI iconvUTF8ToSystemCharset(kctx, trace);
}
else {
file->readerIconv = I18NAPI iconvSystemCharsetToUTF8(kctx, trace);
}
}
KReturn(file);
}
//## int System.fchdir(int fd)
static KMETHOD System_fchdir(KonohaContext *kctx, KonohaStack *sfp)
{
int fd = fchdir(sfp[1].intValue);
if(fd == -1) {
// TODO: throw
KMakeTrace(trace, sfp);
int fault = KLIB DiagnosisFaultType(kctx, SystemError, trace);
KTraceErrorPoint(trace, fault, "fchdir", LogUint("fd", fd));
}
KReturnUnboxValue(fd == 0);
}
//## String System.ttyname(int fd);
static KMETHOD System_ttyname(KonohaContext *kctx, KonohaStack *sfp)
{
int fd = sfp[1].intValue;
char buf[K_PAGESIZE];
int ret = ttyname_r(fd, buf, sizeof(buf));
if(ret != 0) {
KMakeTrace(trace, sfp);
int fault = KLIB DiagnosisFaultType(kctx, SystemError, trace);
KTraceErrorPoint(trace, fault, "ttyname", LogUint("fd", fd), LogErrno);
}
KReturn(KLIB new_kString(kctx, OnStack, buf, strlen(buf), 0));
}
//## Stat System.stat(String path)
static KMETHOD System_stat(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char buffer[K_PATHMAX];
kString *path = sfp[1].asString;
const char *systemPath = PLATAPI I18NModule.formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace);
struct stat buf = {}; /* zero */
int ret = stat(systemPath, &buf);
if(ret == -1) {
int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|SystemError, trace);
KTraceErrorPoint(trace, fault, "stat", LogText("path", kString_text(path)), LogErrno);
}
KReturn(KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), (uintptr_t)&buf));
}
//## boolean System.rmdir(String path)
static KMETHOD System_rmdir(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char buffer[K_PATHMAX];
kString *path = sfp[1].asString;
const char *systemPath = PLATAPI I18NModule.formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace);
int ret = rmdir(systemPath);
if(ret == -1) {
int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|SystemError, trace);
KTraceErrorPoint(trace, fault, "rmdir", LogFileName(kString_text(path)), LogErrno);
}
else {
KTraceChangeSystemPoint(trace, "rmdir", LogFileName(kString_text(path)));
}
KReturnUnboxValue(ret != -1);
}
//## boolean System.fchmod(int fd, int length)
static KMETHOD System_fchmod(KonohaContext *kctx, KonohaStack *sfp)
{
int fd = sfp[1].intValue;
int mode = sfp[2].intValue;
int ret = fchmod(fd, mode);
if(ret != 0) {
// TODO: throw
KMakeTrace(trace, sfp);
int fault = KLIB DiagnosisFaultType(kctx, SystemError, trace);
KTraceErrorPoint(trace, fault, "fchmod",
LogUint("fd", fd),
LogUint("mode", mode)
);
}
KReturnUnboxValue(ret == 0);
}
//## boolean System.ftruncate(int fd, int length)
static KMETHOD System_ftruncate(KonohaContext *kctx, KonohaStack *sfp)
{
int fd = sfp[1].intValue;
int length = sfp[2].intValue;
int ret = ftruncate(fd, length);
if(ret != 0) {
// TODO: throw
KMakeTrace(trace, sfp);
int fault = KLIB DiagnosisFaultType(kctx, SystemError, trace);
KTraceErrorPoint(trace, fault, "ftruncate",
LogUint("fd", fd),
LogUint("length", length)
);
}
KReturnUnboxValue(ret == 0);
}
// NOTE: sys_flock can use for a file, only for
//## @Native boolean System.flock(int fd, int opretaion);
static KMETHOD System_flock(KonohaContext *kctx, KonohaStack *sfp)
{
int fd = sfp[1].intValue;
int operation = sfp[2].intValue;
int ret = flock(fd, operation);
if(ret == -1) {
// TODO: throw
KMakeTrace(trace, sfp);
int fault = KLIB DiagnosisFaultType(kctx, SystemError, trace);
KTraceErrorPoint(trace, fault, "flock",
LogUint("fd", fd),
LogUint("operation", operation)
);
}
KReturnUnboxValue(ret == 0);
}
static KMETHOD System_symlink(KonohaContext *kctx, KonohaStack *sfp)
{
char buffer[K_PATHMAX], buffer2[K_PATHMAX];
kString *path = sfp[1].asString, *path2 = sfp[2].asString;
KMakeTrace(trace, sfp);
const char *oldpath = PLATAPI I18NModule.formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace);
const char *newpath = PLATAPI I18NModule.formatSystemPath(kctx, buffer2, sizeof(buffer2), kString_text(path2), kString_size(path2), trace);
int ret = symlink(oldpath, newpath);
if(ret == -1) {
int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|kString_GuessUserFault(path2)|SystemError, trace);
KTraceErrorPoint(trace, fault, "symlink", LogFileName(kString_text(path)), LogFileName2(kString_text(path2)), LogErrno);
}
else {
KTraceChangeSystemPoint(trace, "symlink", LogFileName(kString_text(path)), LogFileName2(kString_text(path2)), LogErrno);
}
KReturnUnboxValue(ret != -1);
}
//## boolean System.truncate(String path, int length)
static KMETHOD System_truncate(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char buffer[K_PATHMAX];
kString *path = sfp[1].asString;
const char *systemPath = PLATAPI formatSystemPath(kctx, buffer, sizeof(buffer), S_text(path), S_size(path), trace);
off_t length = (off_t)sfp[2].intValue;
int ret = truncate(systemPath, length);
if(ret == -1) {
int fault = KLIB DiagnosisFaultType(kctx, kString_guessUserFault(path)|SystemError, trace);
KTraceErrorPoint(trace, fault, "truncate", LogFileName(S_text(path)), LogUint("length", length), LogErrno);
}
else {
KTraceChangeSystemPoint(trace, "truncate", LogFileName(S_text(path)), LogUint("length", length));
}
KReturnUnboxValue(ret != -1);
}
//## @Native int System.lseek(int fd, int offset, int whence)
static KMETHOD System_lseek(KonohaContext *kctx, KonohaStack *sfp)
{
int fd = sfp[1].intValue;
int offset = sfp[2].intValue;
int whence = sfp[3].intValue;
off_t ret_offset = lseek(fd, offset, whence);
if(ret_offset == -1) {
// TODO: throw
KMakeTrace(trace, sfp);
int fault = KLIB DiagnosisFaultType(kctx, SystemError, trace);
KTraceErrorPoint(trace, fault, "lseek",
LogUint("offset", offset),
LogUint("whence", whence)
);
}
KReturnUnboxValue((int)ret_offset);
}
//## int System.open(String pathname, int flags)
static KMETHOD System_open(KonohaContext *kctx, KonohaStack *sfp)
{
kString *s = sfp[1].asString;
const char *pathname = S_text(s);
int flags = sfp[2].intValue;
int ret = open(pathname, flags);
if(ret == -1) {
// TODO: throw
KMakeTrace(trace, sfp);
int fault = KLIB DiagnosisFaultType(kctx, kString_guessUserFault(s)|SystemError, trace);
KTraceErrorPoint(trace, fault, "open",
LogText("pathname", pathname),
LogUint("flags", flags)
);
}
KReturnUnboxValue(ret);
}
static KMETHOD System_readlink(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char buffer[K_PATHMAX];
kString *path = sfp[1].asString;
const char *systemPath = PLATAPI I18NModule.formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace);
char pathbuf[K_PATHMAX];
ssize_t ret = readlink(systemPath, pathbuf, K_PATHMAX);
if(ret == -1) {
int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|SystemError, trace);
KTraceErrorPoint(trace, fault, "readlink", LogFileName(kString_text(path)), LogErrno);
KReturn(KNULL(String));
}
else {
const char *konohaPath = PLATAPI I18NModule.formatKonohaPath(kctx, buffer, sizeof(buffer), pathbuf, strlen(pathbuf), trace);
KReturn(KLIB new_kString(kctx, OnStack, konohaPath, strlen(konohaPath), 0));
}
}
static KMETHOD System_fchown(KonohaContext *kctx, KonohaStack *sfp)
{
int fd = sfp[1].intValue;
uid_t owner = sfp[2].intValue;
gid_t group = sfp[3].intValue;
int ret = fchown(fd, owner, group);
if(ret == -1) {
// TODO: throw
KMakeTrace(trace, sfp);
int fault = KLIB DiagnosisFaultType(kctx, SystemError, trace);
KTraceErrorPoint(trace, fault, "fchown",
LogUint("fd", fd),
LogUint("owner", owner),
LogUint("group", group)
);
}
KReturnUnboxValue(ret == 0);
}
//## DIR System.opendir(String path)
static KMETHOD System_opendir(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char buffer[K_PATHMAX];
kString *path = sfp[1].asString;
const char *systemPath = PLATAPI I18NModule.formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace);
DIR *d = opendir(systemPath);
if(d == NULL) {
int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|SystemError, trace);
KTraceErrorPoint(trace, fault, "opendir", LogText("dirname", kString_text(path)), LogErrno);
KLIB KRuntime_raise(kctx, KException_("IO"), fault, NULL, sfp);
}
kDir *dir = (kDir *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), (uintptr_t)d);
KFieldSet(dir, dir->PathInfoNULL, path);
if(!PLATAPI I18NModule.isSystemCharsetUTF8(kctx)) {
dir->readerIconv = PLATAPI I18NModule.iconvSystemCharsetToUTF8(kctx, trace);
}
KReturn(dir);
}
