#include "node.h"

#include "node_file.h"

#include "node_buffer.h"

#ifdef __POSIX__

# include "node_stat_watcher.h"

#endif

#include "req_wrap.h"

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <assert.h>

#include <string.h>

#include <errno.h>

#include <limits.h>

#if defined(__MINGW32__) || defined(_MSC_VER)

# include <io.h>

# include <platform_win32.h>

#endif

namespace node {

using namespace v8;

#define MIN(a,b) ((a) < (b) ? (a) : (b))

#define THROW_BAD_ARGS \

ThrowException(Exception::TypeError(String::New("Bad argument")))

typedef class ReqWrap<uv_fs_t> FSReqWrap;

static Persistent<String> encoding_symbol;

static Persistent<String> errno_symbol;

static Persistent<String> buf_symbol;

static Persistent<String> oncomplete_sym;

Local<Value> FSError(int errorno,

const char *syscall = NULL,

const char *msg = NULL,

const char *path = NULL);

#ifdef _LARGEFILE_SOURCE

static inline int IsInt64(double x) {

return x == static_cast<double>(static_cast<int64_t>(x));

}

#endif

static void After(uv_fs_t *req) {

}

struct fs_req_wrap {

};

const char* errno_string(int errorno) {

uv_err_t err;

memset(&err, 0, sizeof err);

err.code = (uv_err_code)errorno;

return uv_err_name(err);

}

const char* errno_message(int errorno) {

uv_err_t err;

memset(&err, 0, sizeof err);

err.code = (uv_err_code)errorno;

return uv_strerror(err);

}

Local<Value> FSError(int errorno,

}

#define ASYNC_CALL(func, callback, ...) \

FSReqWrap* req_wrap = new FSReqWrap(); \

int r = uv_fs_##func(uv_default_loop(), &req_wrap->req_, \

__VA_ARGS__, After); \

assert(r == 0); \

req_wrap->object_->Set(oncomplete_sym, callback); \

req_wrap->Dispatched(); \

return scope.Close(req_wrap->object_);

#define SYNC_CALL(func, path, ...) \

fs_req_wrap req_wrap; \

int result = uv_fs_##func(uv_default_loop(), &req_wrap.req, __VA_ARGS__, NULL); \

if (result < 0) { \

int code = uv_last_error(uv_default_loop()).code; \

return ThrowException(FSError(code, #func, "", path)); \

}

#define SYNC_REQ req_wrap.req

#define SYNC_RESULT result

static Handle<Value> Close(const Arguments& args) {

}

static Persistent<FunctionTemplate> stats_constructor_template;

static Persistent<String> dev_symbol;

static Persistent<String> ino_symbol;

static Persistent<String> mode_symbol;

static Persistent<String> nlink_symbol;

static Persistent<String> uid_symbol;

static Persistent<String> gid_symbol;

static Persistent<String> rdev_symbol;

static Persistent<String> size_symbol;

static Persistent<String> blksize_symbol;

static Persistent<String> blocks_symbol;

static Persistent<String> atime_symbol;

static Persistent<String> mtime_symbol;

static Persistent<String> ctime_symbol;

Local<Object> BuildStatsObject(NODE_STAT_STRUCT *s) {

}

static Handle<Value> Stat(const Arguments& args) {

}

static Handle<Value> LStat(const Arguments& args) {

}

static Handle<Value> FStat(const Arguments& args) {

}

static Handle<Value> Symlink(const Arguments& args) {

}

static Handle<Value> Link(const Arguments& args) {

}

static Handle<Value> ReadLink(const Arguments& args) {

}

static Handle<Value> Rename(const Arguments& args) {

}

#ifndef _LARGEFILE_SOURCE

#define ASSERT_TRUNCATE_LENGTH(a) \

if (!(a)->IsUndefined() && !(a)->IsNull() && !(a)->IsUInt32()) { \

return ThrowException(Exception::TypeError(String::New("Not an integer"))); \

}

#define GET_TRUNCATE_LENGTH(a) ((a)->UInt32Value())

#else

#define ASSERT_TRUNCATE_LENGTH(a) \

if (!(a)->IsUndefined() && !(a)->IsNull() && !IsInt64((a)->NumberValue())) { \

return ThrowException(Exception::TypeError(String::New("Not an integer"))); \

}

#define GET_TRUNCATE_LENGTH(a) ((a)->IntegerValue())

#endif

static Handle<Value> Truncate(const Arguments& args) {

}

static Handle<Value> Fdatasync(const Arguments& args) {

}

static Handle<Value> Fsync(const Arguments& args) {

}

static Handle<Value> Unlink(const Arguments& args) {

}

static Handle<Value> RMDir(const Arguments& args) {

}

static Handle<Value> MKDir(const Arguments& args) {

}

static Handle<Value> SendFile(const Arguments& args) {

}

static Handle<Value> ReadDir(const Arguments& args) {

}

static Handle<Value> Open(const Arguments& args) {

}

#ifndef _LARGEFILE_SOURCE

#define ASSERT_OFFSET(a) \

if (!(a)->IsUndefined() && !(a)->IsNull() && !(a)->IsInt32()) { \

return ThrowException(Exception::TypeError(String::New("Not an integer"))); \

}

#define GET_OFFSET(a) ((a)->IsNumber() ? (a)->Int32Value() : -1)

#else

#define ASSERT_OFFSET(a) \

if (!(a)->IsUndefined() && !(a)->IsNull() && !IsInt64((a)->NumberValue())) { \

return ThrowException(Exception::TypeError(String::New("Not an integer"))); \

}

#define GET_OFFSET(a) ((a)->IsNumber() ? (a)->IntegerValue() : -1)

#endif

static Handle<Value> Write(const Arguments& args) {

}

static Handle<Value> Read(const Arguments& args) {

}

static Handle<Value> Chmod(const Arguments& args) {

}

static Handle<Value> FChmod(const Arguments& args) {

}

static Handle<Value> Chown(const Arguments& args) {

}

static Handle<Value> FChown(const Arguments& args) {

}

static Handle<Value> UTimes(const Arguments& args) {

}

static Handle<Value> FUTimes(const Arguments& args) {

}