mirror of
https://git.checksum.fail/alec/neinterm.git
synced 2025-12-10 13:09:54 +02:00
Add files to repository
This commit is contained in:
Alec Murphy
133
System/9P/Debug.HC
Normal file
133
System/9P/Debug.HC
Normal file
@@ -0,0 +1,133 @@
|
||||
// debugging drawterm
|
||||
|
||||
#define _TVERSION 100
|
||||
#define _TAUTH 102
|
||||
#define _TATTACH 104
|
||||
#define _TERROR 106
|
||||
#define _TFLUSH 108
|
||||
#define _TWALK 110
|
||||
#define _TOPEN 112
|
||||
#define _TCREATE 114
|
||||
#define _TREAD 116
|
||||
#define _TWRITE 118
|
||||
#define _TCLUNK 120
|
||||
#define _TREMOVE 122
|
||||
#define _TSTAT 124
|
||||
#define _TWSTAT 126
|
||||
|
||||
U0 @9p_debug_printf(U8* fmt, ...)
|
||||
{
|
||||
U8* buf;
|
||||
if (argc) {
|
||||
buf = StrPrintJoin(NULL, fmt, argc, argv);
|
||||
} else {
|
||||
buf = StrNew(fmt);
|
||||
}
|
||||
U8* s = buf;
|
||||
while (*s) {
|
||||
OutU8(0xe9, *s++);
|
||||
}
|
||||
Free(buf);
|
||||
}
|
||||
|
||||
U8* @9p_debug_get_code_str(I64 code)
|
||||
{
|
||||
switch (code) {
|
||||
case _TVERSION:
|
||||
return "Tversion";
|
||||
case _TAUTH:
|
||||
return "Tauth";
|
||||
case _TATTACH:
|
||||
return "Tattach";
|
||||
case _TERROR:
|
||||
return "Terror";
|
||||
case _TFLUSH:
|
||||
return "Tflush";
|
||||
case _TWALK:
|
||||
return "Twalk";
|
||||
case _TOPEN:
|
||||
return "Topen";
|
||||
case _TCREATE:
|
||||
return "Tcreate";
|
||||
case _TREAD:
|
||||
return "Tread";
|
||||
case _TWRITE:
|
||||
return "Twrite";
|
||||
case _TCLUNK:
|
||||
return "Tclunk";
|
||||
case _TREMOVE:
|
||||
return "Tremove";
|
||||
case _TSTAT:
|
||||
return "Tstat";
|
||||
case _TWSTAT:
|
||||
return "Twstat";
|
||||
case 1 + _TVERSION:
|
||||
return "Rversion";
|
||||
case 1 + _TAUTH:
|
||||
return "Rauth";
|
||||
case 1 + _TATTACH:
|
||||
return "Rattach";
|
||||
case 1 + _TERROR:
|
||||
return "Rerror";
|
||||
case 1 + _TFLUSH:
|
||||
return "Rflush";
|
||||
case 1 + _TWALK:
|
||||
return "Rwalk";
|
||||
case 1 + _TOPEN:
|
||||
return "Ropen";
|
||||
case 1 + _TCREATE:
|
||||
return "Rcreate";
|
||||
case 1 + _TREAD:
|
||||
return "Rread";
|
||||
case 1 + _TWRITE:
|
||||
return "Rwrite";
|
||||
case 1 + _TCLUNK:
|
||||
return "Rclunk";
|
||||
case 1 + _TREMOVE:
|
||||
return "Rremove";
|
||||
case 1 + _TSTAT:
|
||||
return "Rstat";
|
||||
case 1 + _TWSTAT:
|
||||
return "Rwstat";
|
||||
default:
|
||||
return "(unimplemented)";
|
||||
}
|
||||
}
|
||||
|
||||
U0 @9p_debug_dump(U8* dat, U64 ndat, I64 mode)
|
||||
{
|
||||
I64 i, j, step;
|
||||
U8 buf[17];
|
||||
buf[16] = 0;
|
||||
|
||||
@9p_debug_printf("dump: ptr=%p, length=%d, code: %s, mode=%s\n", dat, ndat, @9p_debug_get_code_str(dat[4]), @t(mode == 1, "tx", "rx"));
|
||||
for (i = 0; i < 32; i++)
|
||||
@9p_debug_printf("=");
|
||||
@9p_debug_printf("\n");
|
||||
|
||||
i = 0;
|
||||
|
||||
while (i < ndat) {
|
||||
@9p_debug_printf("%08x: ", i);
|
||||
step = @t(ndat - i > 16, 16, ndat - i);
|
||||
for (j = 0; j < 16; j++) {
|
||||
if (j > step - 1) {
|
||||
@9p_debug_printf(" ");
|
||||
buf[j] = 0;
|
||||
} else {
|
||||
@9p_debug_printf("%02x ", dat[i + j]);
|
||||
switch (dat[i + j]) {
|
||||
case ' ' ... 'z':
|
||||
buf[j] = dat[i + j];
|
||||
break;
|
||||
default:
|
||||
buf[j] = '.';
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@9p_debug_printf("%s\n", buf);
|
||||
i += step;
|
||||
}
|
||||
@9p_debug_printf("\n");
|
||||
}
|
||||
293
System/9P/Defs.HC
Normal file
293
System/9P/Defs.HC
Normal file
@@ -0,0 +1,293 @@
|
||||
#define TVERSION 100
|
||||
#define TAUTH 102
|
||||
#define TATTACH 104
|
||||
#define TERROR 106
|
||||
#define TFLUSH 108
|
||||
#define TWALK 110
|
||||
#define TOPEN 112
|
||||
#define TCREATE 114
|
||||
#define TREAD 116
|
||||
#define TWRITE 118
|
||||
#define TCLUNK 120
|
||||
#define TREMOVE 122
|
||||
#define TSTAT 124
|
||||
#define TWSTAT 126
|
||||
|
||||
#define NT_BUF_SIZE 65536
|
||||
#define NT_FIFO_SIZE 128
|
||||
#define SET_REQUEST_SIZE U32 request_size = *(data)(U32*);
|
||||
|
||||
#define NT_IS_DIR 0x80
|
||||
#define NT_IS_FILE 0x0
|
||||
|
||||
// #define SET_RESPONSE_SIZE *(nt->out)(U32*) = response_size;
|
||||
// #define CLEAR_RESPONSE_BUFFER MemSet(nt->out, NULL, response_size);
|
||||
// #define SEND_RESPONSE_BUFFER nt->s->send(nt->out, response_size);
|
||||
#define SET_RESPONSE_CMD nt->out[4] = data[4] + 1;
|
||||
#define SET_RESPONSE_TAG \
|
||||
nt->out[5] = data[5]; \
|
||||
nt->out[6] = data[6];
|
||||
|
||||
#define SET_MSGS \
|
||||
@9p_msg * Tmsg = data; \
|
||||
@9p_msg * Rmsg = nt->out;
|
||||
#define SEND_RMSG \
|
||||
SET_RESPONSE_CMD SET_RESPONSE_TAG @9p_debug_dump(Rmsg, Rmsg->length, 1); \
|
||||
nt->s->send(Rmsg, Rmsg->length);
|
||||
#define CLEAR_RMSG MemSet(Rmsg(U64) + 4, NULL, Rmsg->length - 4);
|
||||
|
||||
U8* @nt_msg_type_string(I64 req)
|
||||
{
|
||||
switch (req) {
|
||||
case TVERSION:
|
||||
return "Tversion";
|
||||
case TAUTH:
|
||||
return "Tauth";
|
||||
case TATTACH:
|
||||
return "Tattach";
|
||||
case TERROR:
|
||||
return "Terror";
|
||||
case TFLUSH:
|
||||
return "Tflush";
|
||||
case TWALK:
|
||||
return "Twalk";
|
||||
case TOPEN:
|
||||
return "Topen";
|
||||
case TCREATE:
|
||||
return "Tcreate";
|
||||
case TREAD:
|
||||
return "Tread";
|
||||
case TWRITE:
|
||||
return "Twrite";
|
||||
case TCLUNK:
|
||||
return "Tclunk";
|
||||
case TREMOVE:
|
||||
return "Tremove";
|
||||
case TSTAT:
|
||||
return "Tstat";
|
||||
case TWSTAT:
|
||||
return "Twstat";
|
||||
default:
|
||||
return "(unimplemented)";
|
||||
}
|
||||
}
|
||||
|
||||
class @9p_qid
|
||||
{
|
||||
U8 type;
|
||||
U32 version;
|
||||
U64 path;
|
||||
};
|
||||
|
||||
class @9p_str
|
||||
{
|
||||
U8 length;
|
||||
U8 data;
|
||||
};
|
||||
|
||||
class @9p_msg
|
||||
{
|
||||
U32 length;
|
||||
U8 type;
|
||||
U16 tag;
|
||||
U32 fid;
|
||||
};
|
||||
|
||||
class @9p_twalk : @9p_msg
|
||||
{
|
||||
U32 newfid;
|
||||
U16 nwname;
|
||||
U8 wname; // mem location for nwname*(wname[s])
|
||||
};
|
||||
|
||||
class @9p_stat
|
||||
{
|
||||
U16 size;
|
||||
U16 type;
|
||||
U32 dev;
|
||||
@9p_qid qid;
|
||||
U32 mode;
|
||||
U32 atime;
|
||||
U32 mtime;
|
||||
U64 length;
|
||||
U8 name;
|
||||
};
|
||||
|
||||
class @9p_direntry
|
||||
{
|
||||
U16 type;
|
||||
U32 dev;
|
||||
@9p_qid qid;
|
||||
U32 mode;
|
||||
U32 atime;
|
||||
U32 mtime;
|
||||
U64 length;
|
||||
U8 name;
|
||||
};
|
||||
|
||||
// The reply will contain a machine-independent directory entry, stat, laid out as follows:
|
||||
// size[2]total byte count of the following data
|
||||
// type[2]for kernel use
|
||||
// dev[4]for kernel use
|
||||
// qid.type[1]
|
||||
// the type of the file (directory, etc.), represented as a bit vector corresponding to the high 8 bits of the file’s mode word.
|
||||
// qid.vers[4]
|
||||
// version number for given path
|
||||
// qid.path[8]
|
||||
// the file server’s unique identification for the file
|
||||
// mode[4]
|
||||
// permissions and flags
|
||||
// atime[4]
|
||||
// last access time
|
||||
// mtime[4]
|
||||
// last modification time
|
||||
// length[8]
|
||||
// length of file in bytes
|
||||
// name[ s ]
|
||||
// file name; must be / if the file is the root directory of the server
|
||||
// uid[ s ]owner name
|
||||
// gid[ s ]group name
|
||||
// muid[ s ]
|
||||
// name of the user who last modified the file
|
||||
|
||||
U64 EndianU64(U64 s)
|
||||
{
|
||||
U64 d;
|
||||
d.u8[0] = s.u8[7];
|
||||
d.u8[1] = s.u8[6];
|
||||
d.u8[2] = s.u8[5];
|
||||
d.u8[3] = s.u8[4];
|
||||
d.u8[4] = s.u8[3];
|
||||
d.u8[5] = s.u8[2];
|
||||
d.u8[6] = s.u8[1];
|
||||
d.u8[7] = s.u8[0];
|
||||
return d;
|
||||
}
|
||||
|
||||
// Mouse Cursor
|
||||
CDC* @nt_cursor = DCNew(16, 16);
|
||||
Free(@nt_cursor->body);
|
||||
U8 @nt_cursor_data[16 * 16] = { 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x0f, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
||||
@nt_cursor->body = @nt_cursor_data;
|
||||
|
||||
class @nt
|
||||
{
|
||||
CDC* cursor;
|
||||
CTask* dbg_task;
|
||||
CTask* main_task;
|
||||
CTask* rx_task;
|
||||
CTask* tx_task;
|
||||
TcpSocket* s;
|
||||
U8* host;
|
||||
I64 port;
|
||||
U8* out;
|
||||
CFifoI64* rx_fifo;
|
||||
CFifoI64* rx_dbg_fifo;
|
||||
CFifoI64* tx_dbg_fifo;
|
||||
CFifoI64* kbd_fifo;
|
||||
I64 kbd_last_jiffies;
|
||||
U8* connect_script;
|
||||
U16 kbd_read_tag;
|
||||
// U8 last_kbd_read_request[23];
|
||||
JsonObject* fids;
|
||||
JsonObject* qids;
|
||||
JsonObject* drawobjs;
|
||||
CDC* screen;
|
||||
I64 attach_fid;
|
||||
};
|
||||
|
||||
class @nt_dbg_msg
|
||||
{
|
||||
I64 ts;
|
||||
U8* s;
|
||||
I64 dir;
|
||||
};
|
||||
|
||||
U0 @nt_dbg_out(@nt_dbg_msg* msg)
|
||||
{
|
||||
U8 ts[16];
|
||||
StrPrint(ts, "[%8d] %c ", msg->ts, @t(msg->dir, 'TX', 'RX'));
|
||||
U8* s = ts;
|
||||
while (*s) {
|
||||
OutU8(0xe9, *s++);
|
||||
}
|
||||
s = msg->s;
|
||||
while (*s) {
|
||||
OutU8(0xe9, *s++);
|
||||
}
|
||||
OutU8(0xe9, '\n');
|
||||
// Free(msg->s);
|
||||
// Free(msg);
|
||||
}
|
||||
|
||||
@9p_qid * @nt_qid_create(@nt* nt, U8* path, I64 type)
|
||||
{
|
||||
@9p_qid * qid = CAlloc(sizeof(@9p_qid), nt->main_task);
|
||||
qid->type = type;
|
||||
qid->path = StrNew(path, nt->main_task);
|
||||
nt->qids->set(path, qid, JSON_NUMBER);
|
||||
return qid;
|
||||
}
|
||||
|
||||
@9p_qid * @nt_lookup_qid_by_path(@nt* nt, U8* path)
|
||||
{
|
||||
return nt->qids->@(path);
|
||||
}
|
||||
|
||||
U0 @nt_pascal_to_c_strings(@nt* nt, U8** wname, U8* data, I64 nwname)
|
||||
{
|
||||
I64 i, j = 0;
|
||||
I64 len = 0;
|
||||
for (i = 0; i < nwname; i++) {
|
||||
len = *(data + j)(U16*);
|
||||
j += 2;
|
||||
wname[i] = CAlloc(len + 1, nt->main_task);
|
||||
MemCpy(wname[i], data + j, len);
|
||||
j += len;
|
||||
}
|
||||
}
|
||||
|
||||
U0 @nt_rx_dbg(@nt* nt, U8* fmt, ...)
|
||||
{
|
||||
U8* buf;
|
||||
if (argc) {
|
||||
buf = StrPrintJoin(NULL, fmt, argc, argv);
|
||||
} else {
|
||||
buf = StrNew(fmt);
|
||||
}
|
||||
@nt_dbg_msg* msg = CAlloc(sizeof(@nt_dbg_msg), nt->main_task);
|
||||
msg->ts = cnts.jiffies;
|
||||
msg->s = buf;
|
||||
msg->dir = 0;
|
||||
FifoI64Ins(nt->rx_dbg_fifo, msg);
|
||||
}
|
||||
|
||||
U0 @nt_tx_dbg(@nt* nt, U8* fmt, ...)
|
||||
{
|
||||
U8* buf;
|
||||
if (argc) {
|
||||
buf = StrPrintJoin(NULL, fmt, argc, argv);
|
||||
} else {
|
||||
buf = StrNew(fmt);
|
||||
}
|
||||
@nt_dbg_msg* msg = CAlloc(sizeof(@nt_dbg_msg), nt->main_task);
|
||||
msg->ts = cnts.jiffies;
|
||||
msg->s = buf;
|
||||
msg->dir = 1;
|
||||
FifoI64Ins(nt->tx_dbg_fifo, msg);
|
||||
}
|
||||
|
||||
U0 @nt_zrmsg(@nt* nt, I64 length)
|
||||
{
|
||||
// Zero Rmsg to length and set length
|
||||
@9p_msg * Rmsg = nt->out;
|
||||
MemSet(Rmsg, NULL, length);
|
||||
Rmsg->length = length;
|
||||
}
|
||||
|
||||
U0 @nt_fid_set(@nt* nt, U8* fidbuf, @9p_qid * qid)
|
||||
{
|
||||
JsonObject* fid = Json.CreateObject(nt->main_task);
|
||||
fid->set("qid", qid, JSON_NUMBER);
|
||||
nt->fids->set(fidbuf, fid, JSON_OBJECT);
|
||||
}
|
||||
503
System/9P/Draw.HC
Normal file
503
System/9P/Draw.HC
Normal file
@@ -0,0 +1,503 @@
|
||||
class @Rect
|
||||
{
|
||||
U32 x0;
|
||||
U32 y0;
|
||||
U32 x1;
|
||||
U32 y1;
|
||||
};
|
||||
|
||||
class @Point
|
||||
{
|
||||
U32 x;
|
||||
U32 y;
|
||||
}
|
||||
|
||||
class @draw_A
|
||||
{
|
||||
U32 id;
|
||||
U32 imageid;
|
||||
U32 fillid;
|
||||
U8 public;
|
||||
};
|
||||
|
||||
class @draw_P
|
||||
{
|
||||
U32 dstid;
|
||||
U16 n;
|
||||
U32 wind;
|
||||
@Point ignore;
|
||||
U32 srcid;
|
||||
@Point sp;
|
||||
// U16 sp[4];
|
||||
// dp[2*2*(n+1)];
|
||||
};
|
||||
|
||||
class @draw_b
|
||||
{
|
||||
U32 id;
|
||||
U32 screenid;
|
||||
U8 refresh;
|
||||
U32 chan;
|
||||
U8 repl;
|
||||
@Rect r;
|
||||
@Rect clipr;
|
||||
U32 color;
|
||||
};
|
||||
|
||||
class @draw_d
|
||||
{
|
||||
U32 dstid;
|
||||
U32 srcid;
|
||||
U32 maskid;
|
||||
@Rect dstr;
|
||||
@Point srcp;
|
||||
@Point maskp;
|
||||
};
|
||||
|
||||
class @draw_y
|
||||
{
|
||||
U32 id;
|
||||
@Rect r;
|
||||
};
|
||||
|
||||
I64 @image_cbgr24_to_4_bit(CBGR24* ptr, Bool dither_probability)
|
||||
{
|
||||
I64 res, k;
|
||||
if (dither_probability) {
|
||||
k = RandU32;
|
||||
if (SqrI64(ptr->r) + SqrI64(ptr->g) + SqrI64(ptr->b) >= 3 * SqrI64(k.u8[0]))
|
||||
res = 8;
|
||||
else
|
||||
res = 0;
|
||||
if (ptr->r >= k.u8[1])
|
||||
res |= RED;
|
||||
if (ptr->g >= k.u8[2])
|
||||
res |= GREEN;
|
||||
if (ptr->b >= k.u8[3])
|
||||
res |= BLUE;
|
||||
} else {
|
||||
if (SqrI64(ptr->r) + SqrI64(ptr->g) + SqrI64(ptr->b) >= SqrI64(0x80)) {
|
||||
res = 8;
|
||||
if (ptr->r >= 0x80)
|
||||
res |= RED;
|
||||
if (ptr->g >= 0x80)
|
||||
res |= GREEN;
|
||||
if (ptr->b >= 0x80)
|
||||
res |= BLUE;
|
||||
} else {
|
||||
res = 0;
|
||||
if (ptr->r >= 0x40)
|
||||
res |= RED;
|
||||
if (ptr->g >= 0x40)
|
||||
res |= GREEN;
|
||||
if (ptr->b >= 0x40)
|
||||
res |= BLUE;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
I64 @nt_draw_A(@nt* nt, @draw_A* d, JsonObject* dobj)
|
||||
{
|
||||
// FIXME: Implement this.
|
||||
@nt_tx_dbg(nt, "id: %d, imageid: %d, fillid: %d, public: %d",
|
||||
d->id, d->imageid, d->fillid, d->public);
|
||||
// PressAKey;
|
||||
return sizeof(@draw_A);
|
||||
}
|
||||
|
||||
I64 @nt_draw_b(@nt* nt, @draw_b* d, JsonObject* dobj)
|
||||
{
|
||||
// Allocate an image with a given id on the screen named by screenid.
|
||||
// b id[4] screenid[4] refresh[1] chan[4] repl[1] r[4 * 4] clipr[4 * 4] color[4]
|
||||
|
||||
@nt_tx_dbg(nt, "id: %d, screenid: %d, refresh: %d, chan: %d, repl: %d",
|
||||
d->id, d->screenid, d->refresh, d->chan, d->repl);
|
||||
@nt_tx_dbg(nt, "rect: x0: %d, y0: %d, x1: %d, y1: %d",
|
||||
d->r.x0, d->r.y0, d->r.x1, d->r.y1);
|
||||
@nt_tx_dbg(nt, "clip rect: x0: %d, y0: %d, x1: %d, y1: %d",
|
||||
d->clipr.x0, d->clipr.y0, d->clipr.x1, d->clipr.y1);
|
||||
@nt_tx_dbg(nt, "color: %08x",
|
||||
d->color);
|
||||
|
||||
U8 intbuf[16];
|
||||
StrPrint(intbuf, "%d", d->id);
|
||||
|
||||
if (dobj->o("imgs")->@(intbuf)) {
|
||||
@nt_tx_dbg(nt, "error: image id already exists");
|
||||
PressAKey;
|
||||
}
|
||||
|
||||
CDC* dc = NULL;
|
||||
if (!d->repl) {
|
||||
dc = DCNew(d->r.x1 - d->r.x0, d->r.y1 - d->r.y0);
|
||||
}
|
||||
|
||||
JsonObject* iobj = Json.CreateObject(nt->main_task);
|
||||
JsonObject* tmpr = NULL;
|
||||
|
||||
iobj->set("id", d->id, JSON_NUMBER);
|
||||
iobj->set("screenid", d->screenid, JSON_NUMBER);
|
||||
iobj->set("refresh", d->refresh, JSON_NUMBER);
|
||||
iobj->set("chan", d->chan, JSON_NUMBER);
|
||||
iobj->set("repl", d->repl, JSON_NUMBER);
|
||||
iobj->set("dc", dc, JSON_NUMBER);
|
||||
iobj->set("r", Json.CreateObject(nt->main_task), JSON_OBJECT);
|
||||
iobj->set("clipr", Json.CreateObject(nt->main_task), JSON_OBJECT);
|
||||
|
||||
tmpr = iobj->o("r");
|
||||
tmpr->set("x0", d->r.x0, JSON_NUMBER);
|
||||
tmpr->set("y0", d->r.x1, JSON_NUMBER);
|
||||
tmpr->set("x1", d->r.y0, JSON_NUMBER);
|
||||
tmpr->set("y1", d->r.y1, JSON_NUMBER);
|
||||
|
||||
tmpr = iobj->o("clipr");
|
||||
tmpr->set("x0", d->clipr.x0, JSON_NUMBER);
|
||||
tmpr->set("y0", d->clipr.x1, JSON_NUMBER);
|
||||
tmpr->set("x1", d->clipr.y0, JSON_NUMBER);
|
||||
tmpr->set("y1", d->clipr.y1, JSON_NUMBER);
|
||||
|
||||
if (dc) {
|
||||
CBGR24 bgr;
|
||||
bgr.b = d->color.u8[0];
|
||||
bgr.g = d->color.u8[1];
|
||||
bgr.r = d->color.u8[2];
|
||||
DCFill(dc, @image_cbgr24_to_4_bit(&bgr, 0));
|
||||
}
|
||||
|
||||
StrPrint(intbuf, "%d", d->id);
|
||||
dobj->o("imgs")->set(intbuf, iobj, JSON_OBJECT);
|
||||
|
||||
return sizeof(@draw_b);
|
||||
}
|
||||
|
||||
U0 @nt_draw_y_mono_1bit(CDC* dc, @draw_y* d)
|
||||
{
|
||||
U8* _c = d;
|
||||
I64 x = 0;
|
||||
I64 y = 0;
|
||||
I64 sx = 0;
|
||||
_c += sizeof(@draw_y);
|
||||
for (y = 0; y < d->r.y1; y++) {
|
||||
for (x = 0; x < d->r.x1; x++) {
|
||||
dc->color = @t((reverse_bits(*_c) >> sx) & 1, 15, 0);
|
||||
GrPlot(dc, x, y);
|
||||
sx++;
|
||||
if (sx > 7) {
|
||||
sx = 0;
|
||||
_c++;
|
||||
}
|
||||
}
|
||||
if (sx) {
|
||||
sx = 0;
|
||||
_c++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
I64 @nt_draw_y(@nt* nt, @draw_y* d, JsonObject* dobj)
|
||||
{
|
||||
// y id[4] r[4*4] buf[x*1]
|
||||
|
||||
// Replace the rectangle r of pixels in image id with the pixel data in buf.
|
||||
|
||||
@nt_tx_dbg(nt, "id: %d", d->id);
|
||||
@nt_tx_dbg(nt, "rect: x0: %d, y0: %d, x1: %d, y1: %d",
|
||||
d->r.x0, d->r.y0, d->r.x1, d->r.y1);
|
||||
|
||||
U32 int_w;
|
||||
U8 intbuf[16];
|
||||
StrPrint(intbuf, "%d", d->id);
|
||||
|
||||
JsonObject* iobj = dobj->o("imgs")->@(intbuf);
|
||||
|
||||
if (!iobj) {
|
||||
@nt_tx_dbg(nt, "imageid %d does not exist\n", d->id);
|
||||
PressAKey;
|
||||
}
|
||||
|
||||
CDC* dc = iobj->@("dc");
|
||||
|
||||
if (!dc) {
|
||||
@nt_tx_dbg(nt, "no device context for imageid %d\n", d->id);
|
||||
PressAKey;
|
||||
}
|
||||
|
||||
switch (iobj->@("chan")) {
|
||||
case 0x31:
|
||||
@nt_draw_y_mono_1bit(dc, d);
|
||||
int_w = d->r.x1;
|
||||
while (int_w % 8) {
|
||||
int_w++;
|
||||
}
|
||||
return sizeof(@draw_y) + ((int_w * d->r.y1) / 8);
|
||||
default:
|
||||
@nt_tx_dbg(nt, "unsupported chan value: 0x%04x", iobj->@("chan"));
|
||||
PressAKey;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// drawcoord(uchar *p, uchar *maxp, int oldx, int *newx)
|
||||
U8* @nt_drawcoord(@nt* nt, U8* p, U8* maxp, U32 oldx, U32* newx)
|
||||
{
|
||||
U32 b, x;
|
||||
|
||||
if (p >= maxp) {
|
||||
@nt_tx_dbg(nt, "error: Eshortdraw1: p = 0x%08x, maxp = 0x%08x", p, maxp);
|
||||
PressAKey;
|
||||
}
|
||||
b = *p++;
|
||||
x = b & 0x7F;
|
||||
if (b & 0x80) {
|
||||
if (p + 1 >= maxp) {
|
||||
@nt_tx_dbg(nt, "error: Eshortdraw2: p = 0x%08x", p);
|
||||
PressAKey;
|
||||
}
|
||||
x |= *p++ << 7;
|
||||
x |= *p++ << 15;
|
||||
if (x & (1 << 22))
|
||||
x |= ~0 << 23;
|
||||
} else {
|
||||
if (b & 0x40)
|
||||
x |= ~0 << 7;
|
||||
x += oldx;
|
||||
}
|
||||
*newx = x;
|
||||
return p;
|
||||
}
|
||||
|
||||
I64 @nt_draw_P(@nt* nt, @draw_P* d, JsonObject* dobj)
|
||||
{
|
||||
// P dstid[4] n[2] wind[4] ignore[2*4] srcid[4] sp[2*4] dp[2*2*(n+1)]
|
||||
|
||||
// Draw a polygon as the p message, but fill it rather than outlining it.
|
||||
|
||||
@nt_tx_dbg(nt, "dstid: %d, n: %d, srcid: %d",
|
||||
d->dstid, d->n, d->srcid);
|
||||
|
||||
// FIXME: Implement this.
|
||||
|
||||
JsonObject* iobj;
|
||||
U8 idbuf[16];
|
||||
I64 dx, dy;
|
||||
CDC* dst = NULL;
|
||||
CDC* src = NULL;
|
||||
|
||||
StrPrint(idbuf, "%d", d->dstid);
|
||||
iobj = dobj->o("imgs")->o(idbuf);
|
||||
if (iobj) {
|
||||
dst = iobj->@("dc");
|
||||
}
|
||||
|
||||
// StrPrint(idbuf, "%d", d->srcid);
|
||||
// iobj = dobj->o("imgs")->o(idbuf);
|
||||
// if (iobj) {
|
||||
// src = iobj->@("dc");
|
||||
// }
|
||||
|
||||
if (dst) {
|
||||
dx = 0 + d->sp.x;
|
||||
dy = 0 + d->sp.y;
|
||||
|
||||
// dy = d->sp.y;
|
||||
|
||||
// dst->color = BLUE;
|
||||
//@nt_tx_dbg(nt, "plot dst pixel: dx: %d, dy: %d", dx, dy);
|
||||
// GrPlot(dst, dx, dy);
|
||||
}
|
||||
|
||||
I64 i; //, j;
|
||||
I64 dp_length = 0;
|
||||
U8* dp_ptr = d;
|
||||
U8* maxp = 0x80000000000000;
|
||||
dp_ptr += 4 + 2 + 4 + 4 + 4 + 4 + 2 * 4;
|
||||
// d += sizeof(@draw_P);
|
||||
I64 b = 0;
|
||||
|
||||
// m = 1+4+2+4 +4+4 +4 +2*4
|
||||
|
||||
// U32 ox = 0;
|
||||
// U32 oy = 0;
|
||||
// p.x = d->sp.x;
|
||||
// p.y = d->sp.y;
|
||||
|
||||
U64 __p = d;
|
||||
__p += sizeof(@draw_P);
|
||||
|
||||
@Point p;
|
||||
p.x = (__p)(U32*)[0];
|
||||
p.y = (__p)(U32*)[1];
|
||||
|
||||
U32 ox = p.x;
|
||||
U32 oy = p.y;
|
||||
|
||||
for (i = 0; i < d->n + 1; i++) {
|
||||
dp_ptr = @nt_drawcoord(nt, dp_ptr, maxp, ox, &p.x);
|
||||
dp_ptr = @nt_drawcoord(nt, dp_ptr, maxp, oy, &p.y);
|
||||
|
||||
if (dst) {
|
||||
dst->color = BLACK;
|
||||
@nt_tx_dbg(nt, "plot line: x0: %d, y0: %d, x1: %d, y1: %d", ox, oy, p.x, p.y);
|
||||
if (!(ox > dst->width || oy > dst->height || p.x > dst->width || p.y > dst->height)) {
|
||||
GrLine(dst, ox, oy, p.x, p.y);
|
||||
}
|
||||
// GrPlot(dst, dx + p.x, dy + p.y);
|
||||
}
|
||||
|
||||
ox = p.x;
|
||||
oy = p.y;
|
||||
// for (j = 0; j < 2; j++) {
|
||||
// b = dp_ptr[dp_length++];
|
||||
// if (b & 0x80) {
|
||||
// dp_length += 2;
|
||||
// }
|
||||
// }
|
||||
}
|
||||
// Sleep(5000);
|
||||
// PressAKey;
|
||||
return sizeof(@draw_P) + dp_length - d(U8*);
|
||||
}
|
||||
|
||||
I64 @nt_draw_d(@nt* nt, @draw_d* d, JsonObject* dobj)
|
||||
{
|
||||
// m = 1+4+4+4+4*4+2*4+2*4;
|
||||
// d dstid[4] srcid[4] maskid[4] dstr[4*4] srcp[2*4] maskp[2*4]
|
||||
// Use the draw operator to combine the rectangle dstr of image dstid with a rectangle of image srcid ...
|
||||
// res = 4 + 4 + 4 + sizeof(@Rect) + sizeof(@Point) + sizeof(@Point);
|
||||
|
||||
I64 res = 4 + 4 + 4 + sizeof(@Rect) + sizeof(@Point) + sizeof(@Point);
|
||||
|
||||
@nt_tx_dbg(nt, "dstid: %d, srcid: %d, maskid: %d, dstr: (%d,%d, %d,%d), srcp: (%d,%d) maskp: (%d,%d)",
|
||||
d->dstid, d->srcid, d->maskid, d->dstr.x0, d->dstr.y0, d->dstr.x1, d->dstr.y1,
|
||||
d->srcp.x, d->srcp.y, d->maskp.x, d->maskp.y);
|
||||
|
||||
JsonObject* iobj;
|
||||
U8 idbuf[16];
|
||||
I64 dx, dy;
|
||||
CDC* dst;
|
||||
CDC* src;
|
||||
|
||||
StrPrint(idbuf, "%d", d->dstid);
|
||||
iobj = dobj->o("imgs")->o(idbuf);
|
||||
if (!iobj) {
|
||||
return res;
|
||||
}
|
||||
dst = iobj->@("dc");
|
||||
if (!dst) {
|
||||
return res;
|
||||
}
|
||||
|
||||
StrPrint(idbuf, "%d", d->srcid);
|
||||
iobj = dobj->o("imgs")->o(idbuf);
|
||||
if (!iobj) {
|
||||
return res;
|
||||
}
|
||||
src = iobj->@("dc");
|
||||
if (!src) {
|
||||
return res;
|
||||
}
|
||||
|
||||
dx = U32_MAX - d->srcp.x;
|
||||
dy = U32_MAX - d->srcp.y;
|
||||
|
||||
GrBlot(dst, dx, dy, src);
|
||||
|
||||
return res;
|
||||
|
||||
// if (dobj->o("imgs")->o(idbuf)) {
|
||||
// @nt_tx_dbg(nt, "image id %d exists for srcid", d->srcid);
|
||||
// src = dobj->o("imgs")->o(idbuf)->@("dc");
|
||||
//
|
||||
// if (src) {
|
||||
// @nt_tx_dbg(nt, "src dc: width: %d, height: %d", src->width, src->height);
|
||||
// if (d->dstr.x1 == 640 && d->dstr.y1 == 480 && src->width != 640) {
|
||||
// dx = U32_MAX - d->srcp.x;
|
||||
// dy = U32_MAX - d->srcp.y;
|
||||
// GrBlot(gr.dc, dx, dy, src);
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// return 4 + 4 + 4 + sizeof(@Rect) + sizeof(@Point) + sizeof(@Point);
|
||||
}
|
||||
I64 @nt_draw_cmd(@nt* nt, U8* data, JsonObject* dobj, U8* data_ptr, I64 i)
|
||||
{
|
||||
I64 cmd = data_ptr[i++];
|
||||
I64 res = 0;
|
||||
// size[4] Twrite tag[2] fid[4] offset[8] count[4]
|
||||
@nt_tx_dbg(nt, "draw cmd: %c, offset: 0x%04x", cmd, i - 1 + (4 + 1 + 2 + 4 + 8 + 4));
|
||||
|
||||
JsonKey* k;
|
||||
JsonObject* o;
|
||||
CDC* dc;
|
||||
|
||||
switch (cmd) {
|
||||
case 0:
|
||||
@nt_tx_dbg(nt, "ERROR: draw cmd is NULL, i: 0x%04x", i - 1 + (4 + 1 + 2 + 4 + 8 + 4));
|
||||
PressAKey;
|
||||
break;
|
||||
case 'A':
|
||||
res = @nt_draw_A(nt, data_ptr + i, dobj);
|
||||
break;
|
||||
case 'p':
|
||||
case 'P':
|
||||
res = @nt_draw_P(nt, data_ptr + i, dobj);
|
||||
break;
|
||||
case 'b':
|
||||
res = @nt_draw_b(nt, data_ptr + i, dobj);
|
||||
break;
|
||||
case 'v':
|
||||
k = dobj->o("imgs")->keys;
|
||||
while (k) {
|
||||
o = k->value;
|
||||
if (o && o->@("dc")) {
|
||||
dc = o->@("dc");
|
||||
if (dc->width == 640 && dc->height == 480) {
|
||||
GrBlot(nt->screen, 0, 0, dc);
|
||||
}
|
||||
}
|
||||
k = k->next;
|
||||
}
|
||||
// FIXME: update display buffer
|
||||
break;
|
||||
case 'y':
|
||||
res = @nt_draw_y(nt, data_ptr + i, dobj);
|
||||
break;
|
||||
case 'c':
|
||||
// c dstid[4] repl[1] clipr[4*4]
|
||||
// Change the replicate bit and clipping rectangle of the image dstid.
|
||||
res = 4 + 1 + sizeof(@Rect);
|
||||
break;
|
||||
case 'd':
|
||||
res = @nt_draw_d(nt, data_ptr + i, dobj);
|
||||
break;
|
||||
default:
|
||||
// Sleep(5000);
|
||||
@nt_tx_dbg(nt, "ERROR: unimplemented draw cmd: %c, offset: 0x%04x", cmd, i - 1 + (4 + 1 + 2 + 4 + 8 + 4));
|
||||
// Sleep(5000);
|
||||
PressAKey;
|
||||
break;
|
||||
}
|
||||
return ++res;
|
||||
}
|
||||
|
||||
U0 @nt_draw(@nt* nt, U8* data, @9p_qid * qid)
|
||||
{
|
||||
SET_MSGS
|
||||
|
||||
// size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count]
|
||||
|
||||
U8 dobjbuf[32];
|
||||
StrCpy(dobjbuf, StrFind("/dev/draw/", qid->path) + 10);
|
||||
StrFind("/data", dobjbuf)[0] = NULL;
|
||||
JsonObject* dobj = nt->drawobjs->@(dobjbuf);
|
||||
|
||||
U64 draw_ptr = data + (4 + 1 + 2 + 4 + 8 + 4);
|
||||
U32 length = *(data + (4 + 1 + 2 + 4 + 8))(U32*);
|
||||
|
||||
I64 i = 0;
|
||||
while (i < length) {
|
||||
i += @nt_draw_cmd(nt, data, dobj, draw_ptr, i);
|
||||
}
|
||||
}
|
||||
557
System/9P/Requests.HC
Normal file
557
System/9P/Requests.HC
Normal file
@@ -0,0 +1,557 @@
|
||||
U0 @nt_Rerror(@nt* nt, U8* data, U8* errormsg)
|
||||
{
|
||||
// size[4] Rerror tag[2] ename[s]
|
||||
|
||||
SET_MSGS
|
||||
|
||||
Rmsg->length = (4 + 1 + 2 + 2);
|
||||
nt->out[4] = TERROR + 1; // RERROR
|
||||
|
||||
MemCpy(nt->out + (4 + 1 + 2 + 2), errormsg, StrLen(errormsg));
|
||||
*(nt->out + (4 + 1 + 2))(U16*) = StrLen(errormsg);
|
||||
|
||||
SET_RESPONSE_TAG
|
||||
Rmsg->length += StrLen(errormsg);
|
||||
|
||||
@9p_debug_dump(Rmsg, Rmsg->length, 1);
|
||||
nt->s->send(Rmsg, Rmsg->length);
|
||||
}
|
||||
|
||||
U0 @nt_Tversion(@nt* nt, U8* data)
|
||||
{
|
||||
SET_MSGS
|
||||
|
||||
// Special case; just increment Tmsg tag to Rmsg and echo back to client
|
||||
data[4]++;
|
||||
@9p_debug_dump(data, Tmsg->length, 1);
|
||||
nt->s->send(data, Tmsg->length);
|
||||
}
|
||||
|
||||
U0 @nt_Tattach(@nt* nt, U8* data)
|
||||
{
|
||||
SET_MSGS
|
||||
@nt_zrmsg(nt, 20);
|
||||
//@nt_tx_dbg(nt, "Tattach fid: %d", Tmsg->fid);
|
||||
nt->attach_fid = Tmsg->fid;
|
||||
|
||||
// Map fid to qid
|
||||
U8 fidbuf[16];
|
||||
@9p_qid * qid = @nt_lookup_qid_by_path(nt, "/");
|
||||
StrPrint(fidbuf, "%d", Tmsg->fid);
|
||||
// nt->fids->set(fidbuf, qid, JSON_NUMBER);
|
||||
@nt_fid_set(nt, fidbuf, qid);
|
||||
|
||||
MemCpy(nt->out + 7, qid, sizeof(@9p_qid));
|
||||
SEND_RMSG
|
||||
}
|
||||
|
||||
U0 @nt_Twalk(@nt* nt, U8* data)
|
||||
{
|
||||
// https://9fans.github.io/plan9port/man/man9/walk.html
|
||||
|
||||
// size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s])
|
||||
// size[4] Rwalk tag[2] nwqid[2] nwqid*(qid[13])
|
||||
|
||||
// The fid must be valid in the current session and must not have been opened for I/O by an open or create message.
|
||||
// If the full sequence of nwname elements is walked successfully, newfid will represent the file that results.
|
||||
// If not, newfid (and fid) will be unaffected. However, if newfid is in use or otherwise illegal, an Rerror is returned.
|
||||
|
||||
// If the first element cannot be walked for any reason, Rerror is returned.
|
||||
// Otherwise, the walk will return an Rwalk message containing:
|
||||
// nwqid qids corresponding, in order, to the files that are visited by the nwqid successful elementwise walks;
|
||||
// nwqid is therefore either nwname or the index of the first elementwise walk that failed.
|
||||
|
||||
// size[4] Rwalk tag[2] nwqid[2] nwqid*(qid[13])
|
||||
|
||||
// The value of nwqid cannot be zero unless nwname is zero.
|
||||
// Also, nwqid will always be less than or equal to nwname.
|
||||
// Only if it is equal, however, will newfid be affected, in which case newfid will represent:
|
||||
// the file reached by the final elementwise walk requested in the message.
|
||||
|
||||
SET_MSGS
|
||||
@9p_twalk * Twalk = data;
|
||||
U8** wname = NULL;
|
||||
|
||||
I64 i, j;
|
||||
U16 fid = Twalk->fid;
|
||||
U16 newfid = Twalk->newfid;
|
||||
U16 nwname = Twalk->nwname;
|
||||
U16 nwqid = 0;
|
||||
@9p_qid * qid = NULL;
|
||||
|
||||
U8 basepath[512];
|
||||
U8 pathbuf[512];
|
||||
U8 fidbuf[16];
|
||||
|
||||
Rmsg->length = (4 + 1 + 2 + 2);
|
||||
//@nt_tx_dbg(nt, "Twalk fid: %d, newfid: %d, nwname: %d", fid, newfid, nwname);
|
||||
|
||||
if (fid != nt->attach_fid) {
|
||||
// FIXME: Lookup base path from fid
|
||||
StrPrint(fidbuf, "%d", fid);
|
||||
qid = nt->fids->o(fidbuf)->@("qid");
|
||||
if (!qid) {
|
||||
@nt_tx_dbg(nt, "ERROR: !qid");
|
||||
PressAKey;
|
||||
}
|
||||
StrCpy(basepath, qid->path);
|
||||
if (qid->type != NT_IS_DIR) {
|
||||
StrLastOcc(basepath, "/")[0] = NULL;
|
||||
}
|
||||
} else {
|
||||
StrCpy(basepath, "");
|
||||
}
|
||||
|
||||
if (nwname) {
|
||||
wname = CAlloc(sizeof(U8*) * nwname, nt->main_task);
|
||||
@nt_pascal_to_c_strings(nt, wname, &Twalk->wname, nwname);
|
||||
|
||||
for (i = 0; i < nwname; i++) {
|
||||
StrCpy(pathbuf, basepath);
|
||||
for (j = 0; j <= i; j++) {
|
||||
StrPrint(pathbuf + StrLen(pathbuf), "/%s", wname[j]);
|
||||
}
|
||||
qid = @nt_lookup_qid_by_path(nt, pathbuf);
|
||||
if (qid) {
|
||||
// Copy the qid to Rwalk and increment nwqid, Rwalk length
|
||||
MemCpy(nt->out + (4 + 1 + 2 + 2 + (nwqid * sizeof(@9p_qid))), qid, sizeof(@9p_qid));
|
||||
nwqid++;
|
||||
Rmsg->length += sizeof(@9p_qid);
|
||||
} else {
|
||||
|
||||
// Rerror
|
||||
Rmsg->length = (4 + 1 + 2 + 2);
|
||||
Rmsg->type = 0x6b; // Rerror
|
||||
SET_RESPONSE_TAG
|
||||
StrPrint(nt->out + (4 + 1 + 2 + 2), "file does not exist: '.%s'", pathbuf);
|
||||
//@nt_tx_dbg(nt, "newfid: %d, %s", newfid, nt->out + (4 + 1 + 2 + 2));
|
||||
*(nt->out + (4 + 1 + 2))(U16*) = StrLen(nt->out + (4 + 1 + 2 + 2));
|
||||
Rmsg->length += StrLen(nt->out + (4 + 1 + 2 + 2));
|
||||
@9p_debug_dump(Rmsg, Rmsg->length, 1);
|
||||
nt->s->send(Rmsg, Rmsg->length);
|
||||
return;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Map newfid to qid
|
||||
StrPrint(fidbuf, "%d", newfid);
|
||||
// nt->fids->set(fidbuf, qid, JSON_NUMBER);
|
||||
@nt_fid_set(nt, fidbuf, qid);
|
||||
|
||||
// Set nwqid
|
||||
*(nt->out + (4 + 1 + 2))(U16*) = nwqid;
|
||||
|
||||
//@nt_tx_dbg(nt, "newfid: %d, walked: %s", newfid, pathbuf);
|
||||
|
||||
SEND_RMSG
|
||||
}
|
||||
|
||||
U0 @nt_Topen(@nt* nt, U8* data)
|
||||
{
|
||||
// https://9fans.github.io/plan9port/man/man9/open.html
|
||||
|
||||
// size[4] Topen tag[2] fid[4] mode[1]
|
||||
// size[4] Ropen tag[2] qid[13] iounit[4]
|
||||
|
||||
SET_MSGS
|
||||
|
||||
U32 fid = *(data + (4 + 1 + 2))(U32*);
|
||||
I64 mode = data[4 + 1 + 2 + 4];
|
||||
|
||||
U8 fidbuf[16];
|
||||
StrPrint(fidbuf, "%d", fid);
|
||||
|
||||
Rmsg->length = (4 + 1 + 2 + 13 + 4);
|
||||
//@nt_tx_dbg(nt, "Topen fid: %d, mode: %d", fid, mode);
|
||||
|
||||
@9p_qid * qid = nt->fids->o(fidbuf)->@("qid");
|
||||
|
||||
if (!qid) {
|
||||
@nt_tx_dbg("ERROR: no qid for fid %d", fid);
|
||||
PressAKey;
|
||||
}
|
||||
|
||||
MemCpy(nt->out + 7, qid, sizeof(@9p_qid));
|
||||
*(nt->out + (4 + 1 + 2 + 13))(U32*) = NULL; // set iounit to NULL for now
|
||||
|
||||
SEND_RMSG
|
||||
}
|
||||
|
||||
U0 @nt_Tclunk(@nt* nt, U8* data)
|
||||
{
|
||||
// https://9fans.github.io/plan9port/man/man9/clunk.html
|
||||
|
||||
// size[4] Tclunk tag[2] fid[4]
|
||||
// size[4] Rclunk tag[2]
|
||||
|
||||
SET_MSGS
|
||||
|
||||
U32 fid = *(data + (4 + 1 + 2))(U32*);
|
||||
|
||||
U8 fidbuf[16];
|
||||
StrPrint(fidbuf, "%d", fid);
|
||||
|
||||
Rmsg->length = (4 + 1 + 2);
|
||||
//@nt_tx_dbg(nt, "Tclunk fid: %d", fid);
|
||||
|
||||
nt->fids->unset(fidbuf);
|
||||
|
||||
SEND_RMSG
|
||||
}
|
||||
|
||||
// I64 test_read_cnt = 0;
|
||||
|
||||
I64 test_read_cnt = 0;
|
||||
// I64 test_entry_size = 0x45;
|
||||
I64 test_entry_size = 0x41;
|
||||
|
||||
// U8 test_entry[test_entry_size] = { 0x3e, 0x00, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, 0x27, 0xab, 0xe2, 0x68, 0x1b, 0xab, 0xe2, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x64, 0x72, 0x61, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63 };
|
||||
U8 test_entry[test_entry_size] = { 0x3f, 0x00, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x01, 0x00, 0x80, 0x27, 0xab, 0xe2, 0x68, 0x1b, 0xab, 0xe2, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x64, 0x72, 0x61, 0x77, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63 };
|
||||
// U8 test_entry[test_entry_size] = { 0x3f, 0x00, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x01, 0x00, 0x80, 0x4d, 0xb2, 0xe2, 0x68, 0x47, 0xb2, 0xe2, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x64, 0x72, 0x61, 0x77, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63, 0x04, 0x00, 0x61, 0x6c, 0x65, 0x63, 0x42, 0x00, 0x69, 0x00 };
|
||||
|
||||
U0 @dev_draw_new_read(@nt* nt, U8* data)
|
||||
{
|
||||
SET_MSGS
|
||||
|
||||
U32 read_size = 144;
|
||||
|
||||
I64 i;
|
||||
U8 newbuf[144];
|
||||
U8 intbuf[16];
|
||||
U8 pathbuf[128];
|
||||
U8* chanstr = "x8r8g8b8";
|
||||
JsonObject* tmpr;
|
||||
I64 conn = nt->drawobjs->length + 1;
|
||||
|
||||
JsonObject* dobj = Json.CreateObject(nt->main_task);
|
||||
dobj->set("conn", conn, JSON_NUMBER);
|
||||
dobj->set("imageid", 0, JSON_NUMBER);
|
||||
dobj->set("chan", chanstr, JSON_STRING);
|
||||
dobj->set("r", Json.CreateObject(nt->main_task), JSON_OBJECT);
|
||||
dobj->set("clipr", Json.CreateObject(nt->main_task), JSON_OBJECT);
|
||||
|
||||
tmpr = dobj->o("r");
|
||||
tmpr->set("x0", 0, JSON_NUMBER);
|
||||
tmpr->set("y0", 0, JSON_NUMBER);
|
||||
tmpr->set("x1", GR_WIDTH, JSON_NUMBER);
|
||||
tmpr->set("y1", GR_HEIGHT, JSON_NUMBER);
|
||||
|
||||
tmpr = dobj->o("clipr");
|
||||
tmpr->set("x0", 0, JSON_NUMBER);
|
||||
tmpr->set("y0", 0, JSON_NUMBER);
|
||||
tmpr->set("x1", GR_WIDTH, JSON_NUMBER);
|
||||
tmpr->set("y1", GR_HEIGHT, JSON_NUMBER);
|
||||
|
||||
dobj->set("imgs", Json.CreateObject(nt->main_task), JSON_OBJECT);
|
||||
|
||||
// Insert new draw object [/dev/draw/[conn#] to nt->drawobjs]
|
||||
StrPrint(intbuf, "%d", conn);
|
||||
nt->drawobjs->set(intbuf, dobj, JSON_OBJECT);
|
||||
|
||||
// Create path objects
|
||||
StrPrint(pathbuf, "/dev/draw/%d", conn);
|
||||
@nt_qid_create(nt, pathbuf, NT_IS_DIR);
|
||||
StrPrint(pathbuf, "/dev/draw/%d/data", conn);
|
||||
@nt_qid_create(nt, pathbuf, NT_IS_FILE);
|
||||
StrPrint(pathbuf, "/dev/draw/%d/refresh", conn);
|
||||
@nt_qid_create(nt, pathbuf, NT_IS_FILE);
|
||||
|
||||
// ** not yet implemented
|
||||
// StrPrint(pathbuf, "/dev/draw/%d/colormap", conn);
|
||||
// @nt_qid_create(nt, pathbuf, NT_IS_FILE);
|
||||
// StrPrint(pathbuf, "/dev/draw/%d/ctl", conn);
|
||||
// @nt_qid_create(nt, pathbuf, NT_IS_FILE);
|
||||
|
||||
// *** Build payload for Rread
|
||||
|
||||
// Default; set all fields to 0
|
||||
MemSet(newbuf, ' ', read_size);
|
||||
for (i = 0; i < 12; i++) {
|
||||
newbuf[10 + (12 * i)] = '0';
|
||||
}
|
||||
|
||||
// Set connection number
|
||||
StrPrint(intbuf, "%d", conn);
|
||||
MemCpy(newbuf + 11 - StrLen(intbuf), intbuf, StrLen(intbuf));
|
||||
|
||||
// Set chan string
|
||||
MemCpy(newbuf + 11 - StrLen(chanstr) + (12 * 2), chanstr, StrLen(chanstr));
|
||||
|
||||
// Set max.x of display image and clipping rect
|
||||
StrPrint(intbuf, "%d", GR_WIDTH);
|
||||
MemCpy(newbuf + 11 - StrLen(intbuf) + (12 * 6), intbuf, StrLen(intbuf));
|
||||
MemCpy(newbuf + 11 - StrLen(intbuf) + (12 * 10), intbuf, StrLen(intbuf));
|
||||
|
||||
// Set max.y of display image and clipping rect
|
||||
StrPrint(intbuf, "%d", GR_HEIGHT);
|
||||
MemCpy(newbuf + 11 - StrLen(intbuf) + (12 * 7), intbuf, StrLen(intbuf));
|
||||
MemCpy(newbuf + 11 - StrLen(intbuf) + (12 * 11), intbuf, StrLen(intbuf));
|
||||
|
||||
Rmsg->length = (4 + 1 + 2 + 4);
|
||||
MemCpy(nt->out + (4 + 1 + 2 + 4), newbuf, read_size);
|
||||
*(nt->out + (4 + 1 + 2))(U32*) = read_size;
|
||||
Rmsg->length += read_size;
|
||||
|
||||
SEND_RMSG
|
||||
}
|
||||
|
||||
U0 @nt_Rread_dir(@nt* nt, U8* data, @9p_qid * qid)
|
||||
{
|
||||
SET_MSGS
|
||||
|
||||
Rmsg->length = (4 + 1 + 2 + 4);
|
||||
|
||||
if (test_read_cnt) {
|
||||
*(nt->out + (4 + 1 + 2))(U32*) = 0;
|
||||
SEND_RMSG
|
||||
return;
|
||||
}
|
||||
|
||||
U32 read_size = test_entry_size;
|
||||
MemCpy(nt->out + (4 + 1 + 2 + 4), test_entry, read_size);
|
||||
|
||||
*(nt->out + (4 + 1 + 2))(U32*) = read_size;
|
||||
Rmsg->length += read_size;
|
||||
SEND_RMSG
|
||||
|
||||
test_read_cnt++;
|
||||
}
|
||||
|
||||
// @9p_msg * Rmsg = nt->out;
|
||||
//
|
||||
// if (ev) {
|
||||
// Rmsg->length = 0x0e;
|
||||
// Rmsg->type = TREAD + 1; // RREAD
|
||||
// Rmsg->tag = nt->kbd_read_tag;
|
||||
// MemCpy(nt->out + (4 + 1 + 2), ev, 7);
|
||||
// // nt->kbd_read_tag = NULL;
|
||||
// nt->kbd_last_jiffies = cnts.jiffies;
|
||||
// nt->s->send(Rmsg, Rmsg->length);
|
||||
// Free(ev);
|
||||
// }
|
||||
|
||||
U0 @nt_Tread(@nt* nt, U8* data)
|
||||
{
|
||||
// https://9fans.github.io/plan9port/man/man9/read.html
|
||||
|
||||
// size[4] Tread tag[2] fid[4] offset[8] count[4]
|
||||
// size[4] Rread tag[2] count[4] data[count]
|
||||
|
||||
SET_MSGS
|
||||
|
||||
U32 _fid = *(data + (4 + 1 + 2))(U32*);
|
||||
U64 offset = *(data + (4 + 1 + 2 + 4))(U64*);
|
||||
U32 count = *(data + (4 + 1 + 2 + 4 + 8))(U32*);
|
||||
|
||||
//@nt_tx_dbg(nt, "Tread fid: %d, offset: %d, count: %d", fid, offset, count);
|
||||
|
||||
U8 fidbuf[16];
|
||||
StrPrint(fidbuf, "%d", _fid);
|
||||
|
||||
JsonObject* fid = nt->fids->o(fidbuf);
|
||||
|
||||
if (!fid)
|
||||
return;
|
||||
|
||||
@9p_qid * qid = fid->@("qid");
|
||||
|
||||
if (!qid)
|
||||
return;
|
||||
|
||||
I64 read_count = fid->@("read_count");
|
||||
|
||||
if (qid) {
|
||||
switch (qid->type) {
|
||||
case NT_IS_DIR:
|
||||
if (!StrCmp(qid->path, "/dev")) {
|
||||
@nt_Rread_dir(nt, data, qid);
|
||||
return;
|
||||
}
|
||||
//@nt_tx_dbg(nt, "got read on dir: %s", qid->path);
|
||||
break;
|
||||
default:
|
||||
if (!StrCmp(qid->path, "/dev/kbd")) {
|
||||
nt->kbd_read_tag = Tmsg->tag;
|
||||
//@nt_tx_dbg(nt, "Set nt->kbd_read_tag: 0x%04x", Tmsg->tag);
|
||||
}
|
||||
if (!StrCmp(qid->path, "/dev/draw/new")) {
|
||||
if (read_count) {
|
||||
@nt_Rerror(nt, data, "unknown id for draw image");
|
||||
} else {
|
||||
@dev_draw_new_read(nt, data);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
read_count++;
|
||||
fid->set("read_count", read_count, JSON_NUMBER);
|
||||
}
|
||||
|
||||
U0 @nt_Twrite(@nt* nt, U8* data)
|
||||
{
|
||||
// https://9fans.github.io/plan9port/man/man9/read.html
|
||||
|
||||
// size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count]
|
||||
// size[4] Rwrite tag[2] count[4]
|
||||
|
||||
SET_MSGS
|
||||
|
||||
U32 fid = *(data + (4 + 1 + 2))(U32*);
|
||||
U64 offset = *(data + (4 + 1 + 2 + 4))(U64*);
|
||||
U32 count = *(data + (4 + 1 + 2 + 4 + 8))(U32*);
|
||||
U8* p = data + (4 + 1 + 2 + 4 + 8 + 4);
|
||||
|
||||
Rmsg->length = (4 + 1 + 2 + 4);
|
||||
//@nt_tx_dbg(nt, "Twrite fid: %d, offset: %d, count: %d", fid, offset, count);
|
||||
|
||||
U8 fidbuf[16];
|
||||
U8 errmsgbuf[256];
|
||||
StrPrint(fidbuf, "%d", fid);
|
||||
@9p_qid * qid = nt->fids->o(fidbuf)->@("qid");
|
||||
|
||||
I64 i;
|
||||
|
||||
if (qid) {
|
||||
if (String.BeginsWith("/dev/draw", qid->path) && String.EndsWith("/data", qid->path)) {
|
||||
}
|
||||
if (!StrCmp(qid->path, "/dev/draw/1/data")) {
|
||||
@nt_draw(nt, data, qid);
|
||||
}
|
||||
if (!StrCmp(qid->path, "/dev/cons")) {
|
||||
for (i = 0; i < count; i++) {
|
||||
DocPrint(nt->main_task->put_doc, "%c", p[i]);
|
||||
}
|
||||
}
|
||||
if (!StrCmp(qid->path, "/dev/mousectl")) {
|
||||
p[count] = NULL;
|
||||
StrPrint(errmsgbuf, "unknown control message \"%s\"", p);
|
||||
@nt_Rerror(nt, data, errmsgbuf);
|
||||
return;
|
||||
}
|
||||
|
||||
//@nt_tx_dbg(nt, "got write for path: %s", qid->path);
|
||||
}
|
||||
|
||||
*(nt->out + (4 + 1 + 2))(U32*) = count;
|
||||
|
||||
SEND_RMSG
|
||||
}
|
||||
|
||||
U0 @nt_Tflush(@nt* nt, U8* data)
|
||||
{
|
||||
// https://9fans.github.io/plan9port/man/man9/flush.html
|
||||
|
||||
// size[4] Tflush tag[2] oldtag[2]
|
||||
// size[4] Rflush tag[2]
|
||||
|
||||
SET_MSGS
|
||||
|
||||
Rmsg->length = (4 + 1 + 2);
|
||||
SEND_RMSG
|
||||
}
|
||||
|
||||
U0 @nt_Tstat(@nt* nt, U8* data)
|
||||
{
|
||||
// https://9fans.github.io/plan9port/man/man9/stat.html
|
||||
|
||||
// size[4] Tstat tag[2] fid[4]
|
||||
// size[4] Rstat tag[2] stat[n]
|
||||
|
||||
// The reply will contain a machine-independent directory entry, stat, laid out as follows:
|
||||
// size[2]total byte count of the following data
|
||||
// type[2]for kernel use
|
||||
// dev[4]for kernel use
|
||||
// qid.type[1]
|
||||
// the type of the file (directory, etc.), represented as a bit vector corresponding to the high 8 bits of the file’s mode word.
|
||||
// qid.vers[4]
|
||||
// version number for given path
|
||||
// qid.path[8]
|
||||
// the file server’s unique identification for the file
|
||||
// mode[4]
|
||||
// permissions and flags
|
||||
// atime[4]
|
||||
// last access time
|
||||
// mtime[4]
|
||||
// last modification time
|
||||
// length[8]
|
||||
// length of file in bytes
|
||||
// name[ s ]
|
||||
// file name; must be / if the file is the root directory of the server
|
||||
// uid[ s ]owner name
|
||||
// gid[ s ]group name
|
||||
// muid[ s ]
|
||||
// name of the user who last modified the file
|
||||
|
||||
SET_MSGS
|
||||
|
||||
U32 fid = *(data + (4 + 1 + 2))(U32*);
|
||||
|
||||
Rmsg->length = (4 + 1 + 2 + sizeof(@9p_stat)); // set initial Rmsg length
|
||||
//@nt_tx_dbg(nt, "Tstat fid: %d", fid);
|
||||
// PressAKey;
|
||||
|
||||
U8 fidbuf[16];
|
||||
StrPrint(fidbuf, "%d", fid);
|
||||
|
||||
@9p_qid * qid = nt->fids->o(fidbuf)->@("qid");
|
||||
|
||||
@9p_stat * stat = nt->out + (4 + 1 + 2);
|
||||
stat->size = sizeof(@9p_stat) - 2;
|
||||
stat->type = 0;
|
||||
stat->dev = 0;
|
||||
MemCpy(&stat->qid, qid, sizeof(@9p_qid));
|
||||
stat->atime = 0;
|
||||
stat->mtime = 0;
|
||||
stat->length = 1024;
|
||||
|
||||
// add strings
|
||||
U8* p = NULL;
|
||||
U8* user = "alec";
|
||||
|
||||
// name[ s ]
|
||||
p = nt->out + Rmsg->length;
|
||||
U8* path = qid->path;
|
||||
if (StrCmp(path, "/")) {
|
||||
path = StrLastOcc(path, "/") + 1;
|
||||
}
|
||||
*(p)(U16*) = StrLen(path);
|
||||
p += 2;
|
||||
MemCpy(p, path, StrLen(path));
|
||||
p += StrLen(path);
|
||||
stat->size += StrLen(path) + 2;
|
||||
Rmsg->length += StrLen(path) + 2;
|
||||
|
||||
// uid[ s ]owner name
|
||||
p = nt->out + Rmsg->length;
|
||||
*(p)(U16*) = StrLen(user);
|
||||
p += 2;
|
||||
MemCpy(p, user, StrLen(user));
|
||||
p += StrLen(user);
|
||||
stat->size += StrLen(user) + 2;
|
||||
Rmsg->length += StrLen(user) + 2;
|
||||
|
||||
// uid[ s ]group name
|
||||
p = nt->out + Rmsg->length;
|
||||
*(p)(U16*) = StrLen(user);
|
||||
p += 2;
|
||||
MemCpy(p, user, StrLen(user));
|
||||
p += StrLen(user);
|
||||
stat->size += StrLen(user) + 2;
|
||||
Rmsg->length += StrLen(user) + 2;
|
||||
|
||||
// muid[ s ]
|
||||
p = nt->out + Rmsg->length;
|
||||
*(p)(U16*) = StrLen(user);
|
||||
p += 2;
|
||||
MemCpy(p, user, StrLen(user));
|
||||
p += StrLen(user);
|
||||
stat->size += StrLen(user) + 2;
|
||||
Rmsg->length += StrLen(user) + 2;
|
||||
|
||||
SEND_RMSG
|
||||
}
|
||||
25
System/Api/Dns.HC
Normal file
25
System/Api/Dns.HC
Normal file
@@ -0,0 +1,25 @@
|
||||
#define DNS_REQUEST_PTR 0x300010
|
||||
|
||||
MemSet(DNS_REQUEST_PTR, NULL, sizeof(U64));
|
||||
|
||||
class DnsRequest {
|
||||
U64 host;
|
||||
U64 pointer_to_u32;
|
||||
};
|
||||
|
||||
U32 @dns_query(U8* host)
|
||||
{
|
||||
U32 res = 0;
|
||||
if (!host)
|
||||
return U32_MAX;
|
||||
DnsRequest* request = CAlloc(sizeof(DnsRequest), Fs->code_heap);
|
||||
request->host = StrNew(host, adam_task);
|
||||
request->pointer_to_u32 = &res;
|
||||
U64* request_ptr = DNS_REQUEST_PTR;
|
||||
while (*request_ptr)
|
||||
Sleep(1);
|
||||
LXchgU32(request_ptr, request);
|
||||
while (!res)
|
||||
Sleep(1);
|
||||
return res;
|
||||
}
|
||||
32
System/Api/Icmp.HC
Normal file
32
System/Api/Icmp.HC
Normal file
@@ -0,0 +1,32 @@
|
||||
#define ICMP_REQUEST_PTR 0x300020
|
||||
|
||||
MemSet(ICMP_REQUEST_PTR, NULL, sizeof(U64));
|
||||
|
||||
class IcmpRequest {
|
||||
U64 addr;
|
||||
U64 iden;
|
||||
U64 seq;
|
||||
U64 pointer_to_u32;
|
||||
};
|
||||
|
||||
U32 @icmp_echo_request(U32 addr, U16 iden, U16 seq, IcmpRequest* request, I64 count)
|
||||
{
|
||||
U32 res = 0; // low 16 = ttl, hi 16 = payload size
|
||||
request->addr = addr;
|
||||
request->iden = iden;
|
||||
request->seq = seq;
|
||||
request->pointer_to_u32 = &res;
|
||||
I64 start_jiffies = cnts.jiffies;
|
||||
U64* request_ptr = ICMP_REQUEST_PTR;
|
||||
if (!count)
|
||||
*request_ptr = NULL;
|
||||
while (*request_ptr) {
|
||||
if (!(cnts.jiffies < start_jiffies + 1000))
|
||||
return res;
|
||||
Sleep(1);
|
||||
}
|
||||
LXchgU32(request_ptr, request);
|
||||
while (!res && cnts.jiffies < start_jiffies + 1000)
|
||||
Sleep(1);
|
||||
return res;
|
||||
}
|
||||
9
System/Api/Ipv4.HC
Normal file
9
System/Api/Ipv4.HC
Normal file
@@ -0,0 +1,9 @@
|
||||
U32 @ipv4_address(I64 o3, I64 o2, I64 o1, I64 o0)
|
||||
{
|
||||
U32 addr = NULL;
|
||||
addr.u8[3] = o3;
|
||||
addr.u8[2] = o2;
|
||||
addr.u8[1] = o1;
|
||||
addr.u8[0] = o0;
|
||||
return addr;
|
||||
}
|
||||
144
System/Api/MD5.HC
Normal file
144
System/Api/MD5.HC
Normal file
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* Simple MD5 implementation
|
||||
*
|
||||
* https://gist.github.com/creationix/4710780
|
||||
*/
|
||||
|
||||
U32 md5_r[64] = { 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
|
||||
5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
|
||||
4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
|
||||
6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 };
|
||||
// Use binary integer part of the sines of integers (in radians) as constants//
|
||||
// Initialize variables:
|
||||
U32 md5_k[64] = {
|
||||
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a,
|
||||
0xa8304613, 0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
|
||||
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, 0xf61e2562, 0xc040b340,
|
||||
0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
|
||||
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8,
|
||||
0x676f02d9, 0x8d2a4c8a, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
|
||||
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa,
|
||||
0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
|
||||
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92,
|
||||
0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
|
||||
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
|
||||
};
|
||||
|
||||
// leftrotate function
|
||||
U32 LEFTROTATE(U32 x, U32 c) { return (((x) << (c)) | ((x) >> (32 - (c)))); }
|
||||
|
||||
U0 md5(U8* initial_msg, U32 initial_len, U32* md5_h)
|
||||
{
|
||||
|
||||
// These vars will contain the hash
|
||||
U32 md5_h0, md5_h1, md5_h2, md5_h3;
|
||||
|
||||
// Message (to prepare)
|
||||
U8* msg = NULL;
|
||||
|
||||
// Note: All variables are unsigned 32 bit and wrap modulo 2^32 when
|
||||
// calculating
|
||||
|
||||
// r specifies the per-round shift amounts
|
||||
|
||||
md5_h0 = 0x67452301;
|
||||
md5_h1 = 0xefcdab89;
|
||||
md5_h2 = 0x98badcfe;
|
||||
md5_h3 = 0x10325476;
|
||||
|
||||
// Pre-processing: adding a single 1 bit
|
||||
// append "1" bit to message
|
||||
/* Notice: the input bytes are considered as bits strings,
|
||||
where the first bit is the most significant bit of the byte.[37] */
|
||||
|
||||
// Pre-processing: padding with zeros
|
||||
// append "0" bit until message length in bit ≡ 448 (mod 512)
|
||||
// append length mod (2 pow 64) to message
|
||||
|
||||
U32 new_len;
|
||||
for (new_len = initial_len * 8 + 1; new_len % 512 != 448; new_len++)
|
||||
;
|
||||
new_len /= 8;
|
||||
|
||||
msg = CAlloc(new_len + 64, adam_task); // also appends "0" bits
|
||||
// (we alloc also 64 extra bytes...)
|
||||
MemCpy(msg, initial_msg, initial_len);
|
||||
msg[initial_len] = 128; // write the "1" bit
|
||||
|
||||
U32 bits_len = 8 * initial_len; // note, we append the len
|
||||
MemCpy(msg + new_len, &bits_len, 4); // in bits at the end of the buffer
|
||||
|
||||
// Process the message in successive 512-bit chunks:
|
||||
// for each 512-bit chunk of message:
|
||||
U32 offset;
|
||||
for (offset = 0; offset < new_len; offset += (512 / 8)) {
|
||||
|
||||
// break chunk into sixteen 32-bit words w[j], 0 ≤ j ≤ 15
|
||||
U32* w = (msg + offset)(U32*);
|
||||
|
||||
// Initialize hash value for this chunk:
|
||||
U32 a = md5_h0;
|
||||
U32 b = md5_h1;
|
||||
U32 c = md5_h2;
|
||||
U32 d = md5_h3;
|
||||
|
||||
// Main loop:
|
||||
U32 i;
|
||||
for (i = 0; i < 64; i++) {
|
||||
|
||||
U32 f, g;
|
||||
|
||||
if (i < 16) {
|
||||
f = (b & c) | ((~b) & d);
|
||||
g = i;
|
||||
} else if (i < 32) {
|
||||
f = (d & b) | ((~d) & c);
|
||||
g = (5 * i + 1) % 16;
|
||||
} else if (i < 48) {
|
||||
f = b ^ c ^ d;
|
||||
g = (3 * i + 5) % 16;
|
||||
} else {
|
||||
f = c ^ (b | (~d));
|
||||
g = (7 * i) % 16;
|
||||
}
|
||||
|
||||
U32 temp = d;
|
||||
d = c;
|
||||
c = b;
|
||||
// printf("rotateLeft(%x + %x + %x + %x, %d)\n", a, f, k[i], w[g], r[i]);
|
||||
b = b + LEFTROTATE((a + f + md5_k[i] + w[g]), md5_r[i]);
|
||||
a = temp;
|
||||
}
|
||||
|
||||
// Add this chunk's hash to result so far:
|
||||
|
||||
md5_h0 += a;
|
||||
md5_h1 += b;
|
||||
md5_h2 += c;
|
||||
md5_h3 += d;
|
||||
}
|
||||
|
||||
md5_h[0] = md5_h0;
|
||||
md5_h[1] = md5_h1;
|
||||
md5_h[2] = md5_h2;
|
||||
md5_h[3] = md5_h3;
|
||||
|
||||
// cleanup
|
||||
Free(msg);
|
||||
}
|
||||
|
||||
U8* md5_string(U8* buf, I64 size)
|
||||
{
|
||||
U32 md5_h[4];
|
||||
md5(buf, size, &md5_h[0]);
|
||||
U8* str = CAlloc(33, adam_task);
|
||||
StrPrint(str + StrLen(str), "%02x%02x%02x%02x", md5_h[0].u8[0],
|
||||
md5_h[0].u8[1], md5_h[0].u8[2], md5_h[0].u8[3]);
|
||||
StrPrint(str + StrLen(str), "%02x%02x%02x%02x", md5_h[1].u8[0],
|
||||
md5_h[1].u8[1], md5_h[1].u8[2], md5_h[1].u8[3]);
|
||||
StrPrint(str + StrLen(str), "%02x%02x%02x%02x", md5_h[2].u8[0],
|
||||
md5_h[2].u8[1], md5_h[2].u8[2], md5_h[2].u8[3]);
|
||||
StrPrint(str + StrLen(str), "%02x%02x%02x%02x", md5_h[3].u8[0],
|
||||
md5_h[3].u8[1], md5_h[3].u8[2], md5_h[3].u8[3]);
|
||||
return str;
|
||||
}
|
||||
32
System/Api/NetInfo.HC
Normal file
32
System/Api/NetInfo.HC
Normal file
@@ -0,0 +1,32 @@
|
||||
#define NETINFO_REQUEST_PTR 0x300030
|
||||
|
||||
MemSet(NETINFO_REQUEST_PTR, NULL, sizeof(U64));
|
||||
|
||||
class NetInfoRequest {
|
||||
U64 mac_address;
|
||||
U64 ipv4_address;
|
||||
U64 ipv4_netmask;
|
||||
U64 ipv4_network;
|
||||
U64 ipv4_gateway;
|
||||
U64 dns_server_address;
|
||||
U64 dns_server_port;
|
||||
U64 rx_bytes;
|
||||
U64 rx_frames;
|
||||
U64 tx_bytes;
|
||||
U64 tx_frames;
|
||||
U64 pointer_to_u32;
|
||||
};
|
||||
|
||||
NetInfoRequest* @net_info_request()
|
||||
{
|
||||
U32 res = 0;
|
||||
NetInfoRequest* req = CAlloc(sizeof(NetInfoRequest), Fs->code_heap);
|
||||
req->pointer_to_u32 = &res;
|
||||
U64* request_ptr = NETINFO_REQUEST_PTR;
|
||||
while (*request_ptr)
|
||||
Sleep(1);
|
||||
LXchgU32(request_ptr, req);
|
||||
while (!res)
|
||||
Sleep(1);
|
||||
return req;
|
||||
}
|
||||
209
System/Api/Tcp.HC
Normal file
209
System/Api/Tcp.HC
Normal file
@@ -0,0 +1,209 @@
|
||||
#define TCP_SOCKET_REQUEST_PTR 0x300000
|
||||
#define TCP_BIND_REQUEST_PTR 0x300040
|
||||
#define TCP_ACCEPT_REQUEST_PTR 0x300050
|
||||
|
||||
MemSet(TCP_SOCKET_REQUEST_PTR, NULL, sizeof(U64));
|
||||
|
||||
// TcpSocket states
|
||||
|
||||
#define TCP_SOCKET_STATE_IDLE 0
|
||||
#define TCP_SOCKET_STATE_ESTABLISHED 1
|
||||
#define TCP_SOCKET_STATE_CLOSED 2
|
||||
#define TCP_SOCKET_STATE_CONNECTING 4
|
||||
|
||||
class TcpSocket {
|
||||
U64 remote_addr;
|
||||
U64 remote_port;
|
||||
U64 state;
|
||||
U64 receive_buffer_ptr; // Pointer to receive buffer in physical memory
|
||||
U64 receive_buffer_size;
|
||||
U64 receive_buffer_filled; // Number of bytes Net has put into buffer
|
||||
U64 receive_buffer_kick; // Net sets this to 1 when it has data available for
|
||||
// us, we set back to 0 when ready to receive
|
||||
U64 send_buffer_ptr;
|
||||
U64 send_buffer_size;
|
||||
U64 send_buffer_filled;
|
||||
U64 send_buffer_kick; // We set this to 1 when we have data available to net,
|
||||
// Net sets back to 0 when ready to receive
|
||||
U64 close_kick; // We set this to 1 to force close the connection
|
||||
U0 (*close)();
|
||||
U64 (*receive)(U64 buf, U64 length);
|
||||
U0 (*send)(U64 buf, U64 length);
|
||||
};
|
||||
|
||||
class TcpBind {
|
||||
U64 port;
|
||||
U64 function;
|
||||
U64 response_code;
|
||||
};
|
||||
|
||||
U8 @tcp_close_wrapper_function[16]
|
||||
= { 0x55, 0x48, 0x8B, 0xEC, 0x68, 0x78,
|
||||
0x56, 0x34, 0x12, 0xE8, 0x02, 0x6D,
|
||||
0x02, 0x00, 0x5D, 0xC3 };
|
||||
|
||||
U8 @tcp_receive_wrapper_function[32] = {
|
||||
0x55, 0x48, 0x8B, 0xEC, 0x56, 0x57, 0x48, 0x8B, 0x75, 0x18, 0x48,
|
||||
0x8B, 0x7D, 0x10, 0x56, 0x57, 0x68, 0x78, 0x56, 0x34, 0x12, 0xE8,
|
||||
0x5E, 0x62, 0x02, 0x00, 0x5F, 0x5E, 0x5D, 0xC2, 0x10, 0x00
|
||||
};
|
||||
|
||||
U8 @tcp_send_wrapper_function[32] = {
|
||||
0x55, 0x48, 0x8B, 0xEC, 0x56, 0x57, 0x48, 0x8B, 0x75, 0x18, 0x48,
|
||||
0x8B, 0x7D, 0x10, 0x56, 0x57, 0x68, 0x78, 0x56, 0x34, 0x12, 0xE8,
|
||||
0x5E, 0x62, 0x02, 0x00, 0x5F, 0x5E, 0x5D, 0xC2, 0x10, 0x00
|
||||
};
|
||||
|
||||
U0 @tcp_socket_send(TcpSocket* s, U64 buf, U64 length)
|
||||
{
|
||||
while (s->send_buffer_kick)
|
||||
Sleep(1);
|
||||
U64 pos = 0;
|
||||
U64 bytes_to_send = 0;
|
||||
while (pos < length) {
|
||||
if ((length - pos) > s->send_buffer_size)
|
||||
bytes_to_send = s->send_buffer_size;
|
||||
else
|
||||
bytes_to_send = length - pos;
|
||||
MemCpy(s->send_buffer_ptr, buf + pos, bytes_to_send);
|
||||
s->send_buffer_filled = bytes_to_send;
|
||||
s->send_buffer_kick = 1;
|
||||
pos += bytes_to_send;
|
||||
while (s->send_buffer_kick)
|
||||
Sleep(1);
|
||||
}
|
||||
}
|
||||
|
||||
U64 @tcp_socket_receive(TcpSocket* s, U64 buf, U64 size)
|
||||
{
|
||||
s->receive_buffer_size = size;
|
||||
s->receive_buffer_kick = 0;
|
||||
while (!s->receive_buffer_kick) {
|
||||
if (s->state == TCP_SOCKET_STATE_CLOSED)
|
||||
return NULL;
|
||||
Sleep(1);
|
||||
}
|
||||
U64 bytes_received = s->receive_buffer_filled;
|
||||
if (bytes_received > 0) {
|
||||
MemCpy(buf, s->receive_buffer_ptr, bytes_received);
|
||||
}
|
||||
return bytes_received;
|
||||
}
|
||||
|
||||
U0 @tcp_wait_for_connection_established(TcpSocket* s)
|
||||
{
|
||||
while (s->state != TCP_SOCKET_STATE_ESTABLISHED)
|
||||
Sleep(1);
|
||||
}
|
||||
|
||||
U0 @tcp_socket_close(TcpSocket* s)
|
||||
{
|
||||
if (s->close)
|
||||
Free(s->close);
|
||||
if (s->receive)
|
||||
Free(s->receive);
|
||||
if (s->send)
|
||||
Free(s->send);
|
||||
s->close_kick = 1;
|
||||
s->state = TCP_SOCKET_STATE_CLOSED;
|
||||
}
|
||||
|
||||
TcpSocket* @tcp_socket_create(U8* host, U64 port)
|
||||
{
|
||||
U64 addr = @dns_query(host);
|
||||
TcpSocket* s = CAlloc(sizeof(TcpSocket), adam_task->code_heap);
|
||||
s->remote_addr = addr;
|
||||
s->remote_port = port;
|
||||
|
||||
U64 a;
|
||||
|
||||
s->close = MAlloc(16, adam_task->code_heap);
|
||||
MemCpy(s->close, @tcp_close_wrapper_function, 16);
|
||||
a = s->close;
|
||||
a += 0x05;
|
||||
MemSetU32(a, s, 1);
|
||||
a = s->close;
|
||||
a += 0x09;
|
||||
@patch_call_rel32(a, &@tcp_socket_close);
|
||||
|
||||
s->receive = MAlloc(25, adam_task->code_heap);
|
||||
MemCpy(s->receive, @tcp_receive_wrapper_function, 32);
|
||||
a = s->receive;
|
||||
a += 0x11;
|
||||
MemSetU32(a, s, 1);
|
||||
a = s->receive;
|
||||
a += 0x15;
|
||||
@patch_call_rel32(a, &@tcp_socket_receive);
|
||||
|
||||
s->send = MAlloc(32, adam_task->code_heap);
|
||||
MemCpy(s->send, @tcp_send_wrapper_function, 32);
|
||||
a = s->send;
|
||||
a += 0x11;
|
||||
MemSetU32(a, s, 1);
|
||||
a = s->send;
|
||||
a += 0x15;
|
||||
@patch_call_rel32(a, &@tcp_socket_send);
|
||||
|
||||
U64* request_ptr = TCP_SOCKET_REQUEST_PTR;
|
||||
while (*request_ptr)
|
||||
Sleep(1);
|
||||
LXchgU32(request_ptr, s);
|
||||
return s;
|
||||
}
|
||||
|
||||
U64 @tcp_socket_bind(U64 port, U64 function)
|
||||
{
|
||||
if (!port || !function)
|
||||
return NULL;
|
||||
|
||||
TcpBind* b = CAlloc(sizeof(TcpBind), adam_task->code_heap);
|
||||
b->port = port;
|
||||
b->function = function; // U0 my_spawn_wrapper_function(TcpSocket* s)
|
||||
|
||||
U64* request_ptr = TCP_BIND_REQUEST_PTR;
|
||||
while (*request_ptr)
|
||||
Sleep(1);
|
||||
LXchgU32(request_ptr, b);
|
||||
while (*request_ptr)
|
||||
Sleep(1);
|
||||
U64 res = b->response_code;
|
||||
Free(b);
|
||||
return res;
|
||||
}
|
||||
|
||||
TcpSocket* @tcp_socket_accept(TcpSocket* s)
|
||||
{
|
||||
if (!s || !s->remote_addr || !s->remote_port)
|
||||
return NULL;
|
||||
|
||||
U64 a;
|
||||
|
||||
s->close = MAlloc(16, adam_task->code_heap);
|
||||
MemCpy(s->close, @tcp_close_wrapper_function, 16);
|
||||
a = s->close;
|
||||
a += 0x05;
|
||||
MemSetU32(a, s, 1);
|
||||
a = s->close;
|
||||
a += 0x09;
|
||||
@patch_call_rel32(a, &@tcp_socket_close);
|
||||
|
||||
s->receive = MAlloc(25, adam_task->code_heap);
|
||||
MemCpy(s->receive, @tcp_receive_wrapper_function, 32);
|
||||
a = s->receive;
|
||||
a += 0x11;
|
||||
MemSetU32(a, s, 1);
|
||||
a = s->receive;
|
||||
a += 0x15;
|
||||
@patch_call_rel32(a, &@tcp_socket_receive);
|
||||
|
||||
s->send = MAlloc(32, adam_task->code_heap);
|
||||
MemCpy(s->send, @tcp_send_wrapper_function, 32);
|
||||
a = s->send;
|
||||
a += 0x11;
|
||||
MemSetU32(a, s, 1);
|
||||
a = s->send;
|
||||
a += 0x15;
|
||||
@patch_call_rel32(a, &@tcp_socket_send);
|
||||
|
||||
return s;
|
||||
}
|
||||
10
System/Config/Net.json
Normal file
10
System/Config/Net.json
Normal file
@@ -0,0 +1,10 @@
|
||||
{
|
||||
"tcpip.ipv4_address": "10.20.0.10",
|
||||
"tcpip.ipv4_netmask": "255.255.255.0",
|
||||
"tcpip.ipv4_network": "10.20.0.0",
|
||||
"tcpip.ipv4_gateway": "10.20.0.254",
|
||||
"tcpip.ipv4_dns_server_address": "8.8.8.8",
|
||||
"tcpip.ipv4_dns_server_port": "53",
|
||||
"tcpip.mss_size": "1360",
|
||||
"eof": "eof"
|
||||
}
|
||||
51
System/FFI/Base.HC
Normal file
51
System/FFI/Base.HC
Normal file
@@ -0,0 +1,51 @@
|
||||
#define PUSH_SYSV_REGS \
|
||||
asm {PUSH RCX PUSH RDX PUSH RBX PUSH RBP PUSH RSI PUSH RDI PUSH R8 PUSH R9 PUSH \
|
||||
R10 PUSH R11 PUSH R12 PUSH R13 PUSH R14 PUSH R15}
|
||||
#define POP_SYSV_REGS \
|
||||
p0 = p0; \
|
||||
p1 = p1; \
|
||||
p2 = p2; \
|
||||
p3 = p3; \
|
||||
p4 = p4; \
|
||||
p5 = p5; \
|
||||
asm {POP R15 POP R14 POP R13 POP R12 POP R11 POP R10 POP R9 POP R8 POP RDI POP \
|
||||
RSI POP RBP POP RBX POP RDX POP RCX}
|
||||
#define GET_SYSV_ARGS \
|
||||
asm {PUSH R9 PUSH R8 PUSH RCX PUSH RDX PUSH RSI PUSH RDI} \
|
||||
I64 reg RDI p0; \
|
||||
I64 reg RSI p1; \
|
||||
I64 reg RDX p2; \
|
||||
I64 reg RCX p3; \
|
||||
I64 reg R8 p4; \
|
||||
I64 reg R9 p5; \
|
||||
asm {POP RDI POP RSI POP RDX POP RCX POP R8 POP R9}
|
||||
|
||||
#define MOV_ANS_RAX asm { MOV[&ans], RAX }
|
||||
#define MOV_PARAM0_RDI asm {MOV [¶m0], RDI}
|
||||
|
||||
I64 param0;
|
||||
I64 elf_argc;
|
||||
U8** elf_argv;
|
||||
|
||||
asm {
|
||||
_ELF_CALL::
|
||||
PUSH RBP
|
||||
MOV RBP,RSP
|
||||
MOV RAX,U64 SF_ARG1[RBP]
|
||||
MOV RDI,U64 SF_ARG2[RBP]
|
||||
MOV RSI,U64 SF_ARG3[RBP]
|
||||
TEST RAX,RAX
|
||||
JZ @@05
|
||||
CALL RAX
|
||||
@@05: POP RBP
|
||||
RET1 8
|
||||
}
|
||||
|
||||
U0 _main()
|
||||
{
|
||||
MOV_PARAM0_RDI
|
||||
CallInd(_ELF_CALL, param0, elf_argc, elf_argv);
|
||||
UserTaskCont;
|
||||
}
|
||||
|
||||
U0 _exit() { UserTaskCont; }
|
||||
300
System/FFI/ELF64.HC
Normal file
300
System/FFI/ELF64.HC
Normal file
@@ -0,0 +1,300 @@
|
||||
#define EI_NIDENT 16
|
||||
#define EM_X86_64 0x3E
|
||||
#define ET_EXEC 2
|
||||
#define ET_DYN 3
|
||||
|
||||
U0 @elf64_debug_print(U8 fmt, ...)
|
||||
{
|
||||
// FIXME: Remove unnecessary debug_print statements and PrintErr for errors.
|
||||
no_warn fmt, argc, argv;
|
||||
}
|
||||
|
||||
class Elf64_Ehdr {
|
||||
U8 e_ident[EI_NIDENT]; /* Magic number and other info */
|
||||
U16 e_type; /* Object file type */
|
||||
U16 e_machine; /* Architecture */
|
||||
U32 e_version; /* Object file version */
|
||||
U64 e_entry; /* Entry point virtual address */
|
||||
U64 e_phoff; /* Program header table file offset */
|
||||
U64 e_shoff; /* Section header table file offset */
|
||||
U32 e_flags; /* Processor-specific flags */
|
||||
U16 e_ehsize; /* ELF header size in bytes */
|
||||
U16 e_phentsize; /* Program header table entry size */
|
||||
U16 e_phnum; /* Program header table entry count */
|
||||
U16 e_shentsize; /* Section header table entry size */
|
||||
U16 e_shnum; /* Section header table entry count */
|
||||
U16 e_shstrndx; /* Section header string table index */
|
||||
};
|
||||
|
||||
class Elf64_Shdr {
|
||||
U32 sh_name; /* Section name (string tbl index) */
|
||||
U32 sh_type; /* Section type */
|
||||
U64 sh_flags; /* Section flags */
|
||||
U64 sh_addr; /* Section virtual addr at execution */
|
||||
U64 sh_offset; /* Section file offset */
|
||||
U64 sh_size; /* Section size in bytes */
|
||||
U32 sh_link; /* Link to another section */
|
||||
U32 sh_info; /* Additional section information */
|
||||
U64 sh_addralign; /* Section alignment */
|
||||
U64 sh_entsize; /* Entry size if section holds table */
|
||||
};
|
||||
|
||||
class Elf64_Sym {
|
||||
U32 st_name; /* Symbol name (string tbl index) */
|
||||
U8 st_info; /* Symbol type and binding */
|
||||
U8 st_other; /* Symbol visibility */
|
||||
U16 st_shndx; /* Section index */
|
||||
U64 st_value; /* Symbol value */
|
||||
U64 st_size; /* Symbol size */
|
||||
};
|
||||
|
||||
class PLT_entry {
|
||||
U8 pad[0x10];
|
||||
};
|
||||
|
||||
class RELA_entry {
|
||||
U64 r_offset;
|
||||
U64 r_info;
|
||||
I64 r_addend;
|
||||
};
|
||||
|
||||
class Elf {
|
||||
union {
|
||||
U8* u8;
|
||||
Elf64_Ehdr* ehdr;
|
||||
} I64 size;
|
||||
U8* dynstr;
|
||||
Elf64_Sym* dynsym;
|
||||
PLT_entry* plt;
|
||||
RELA_entry* rela_dyn;
|
||||
RELA_entry* rela_plt;
|
||||
Elf64_Sym* strtab;
|
||||
Elf64_Sym* symtab;
|
||||
I64 rela_dyn_size;
|
||||
I64 rela_plt_size;
|
||||
I64 strtab_size;
|
||||
I64 symtab_size;
|
||||
};
|
||||
|
||||
U0 (*_start)();
|
||||
|
||||
U0 unimplemented_symbol()
|
||||
{
|
||||
I32 s = 0xDEADF00D;
|
||||
PrintWarn("Unimplemented symbol: %s\n", s);
|
||||
Dbg;
|
||||
while (1)
|
||||
Sleep(1);
|
||||
}
|
||||
|
||||
Bool is_valid_elf(Elf* elf)
|
||||
{
|
||||
Bool res = TRUE;
|
||||
if (MemCmp(elf->u8 + 1, "ELF", 3)) {
|
||||
@elf64_debug_print("Invalid signature (not ELF).\n");
|
||||
res = FALSE;
|
||||
}
|
||||
if (elf->ehdr->e_type != ET_EXEC && elf->ehdr->e_type != ET_DYN) {
|
||||
@elf64_debug_print("Invalid object file type.\n");
|
||||
res = FALSE;
|
||||
}
|
||||
if (elf->ehdr->e_machine != EM_X86_64) {
|
||||
@elf64_debug_print("Invalid architecture.\n");
|
||||
res = FALSE;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
U0 process_elf_section_header_table(Elf* elf)
|
||||
{
|
||||
Elf64_Shdr* shdr = elf->u8 + elf->ehdr->e_shoff;
|
||||
Elf64_Shdr* shdr_shstrtab = shdr + elf->ehdr->e_shstrndx;
|
||||
U8* shstrtab = elf->u8 + shdr_shstrtab->sh_offset;
|
||||
I64 i = 0;
|
||||
while (i < elf->ehdr->e_shnum) {
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".symtab")) {
|
||||
@elf64_debug_print("found symtab at 0x%08x, size = %d\n", shdr->sh_offset,
|
||||
shdr->sh_size);
|
||||
elf->symtab = elf->u8 + shdr->sh_offset;
|
||||
elf->symtab_size = shdr->sh_size;
|
||||
}
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".strtab")) {
|
||||
@elf64_debug_print("found strtab at 0x%08x, size = %d\n", shdr->sh_offset,
|
||||
shdr->sh_size);
|
||||
elf->strtab = elf->u8 + shdr->sh_offset;
|
||||
elf->strtab_size = shdr->sh_size;
|
||||
}
|
||||
if (shdr->sh_addr) {
|
||||
MemCpy(shdr->sh_addr, elf->u8 + shdr->sh_offset, shdr->sh_size);
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".dynstr"))
|
||||
elf->dynstr = shdr->sh_addr;
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".dynsym"))
|
||||
elf->dynsym = shdr->sh_addr;
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".plt"))
|
||||
elf->plt = shdr->sh_addr;
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".rela.dyn")) {
|
||||
elf->rela_dyn = shdr->sh_addr;
|
||||
elf->rela_dyn_size = shdr->sh_size / shdr->sh_entsize;
|
||||
}
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".rela.plt")) {
|
||||
elf->rela_plt = shdr->sh_addr;
|
||||
elf->rela_plt_size = shdr->sh_size / shdr->sh_entsize;
|
||||
}
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".bss") || !StrCmp(shstrtab + shdr->sh_name, ".tbss")) {
|
||||
MemSet(shdr->sh_addr, NULL, shdr->sh_size);
|
||||
@elf64_debug_print(
|
||||
"Zeroed out section '%s' at physical address 0x%06x, size = %d bytes\n",
|
||||
shstrtab + shdr->sh_name, shdr->sh_addr, shdr->sh_size);
|
||||
} else
|
||||
@elf64_debug_print(
|
||||
"MemCpy section '%s' to physical address 0x%06x, size = %d bytes\n",
|
||||
shstrtab + shdr->sh_name, shdr->sh_addr, shdr->sh_size);
|
||||
if (!StrCmp(shstrtab + shdr->sh_name, ".bss")) {
|
||||
MemSet(shdr->sh_addr, NULL, shdr->sh_size);
|
||||
@elf64_debug_print("MemSet section '%s' at physical address 0x%06x to NULL, "
|
||||
"size = %d bytes\n",
|
||||
shstrtab + shdr->sh_name, shdr->sh_addr, shdr->sh_size);
|
||||
}
|
||||
}
|
||||
shdr++;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
U0 process_elf_rela_dyn_entries(Elf* elf)
|
||||
{
|
||||
I64 i;
|
||||
U8* entry_name;
|
||||
RELA_entry* rela_dyn = elf->rela_dyn;
|
||||
for (i = 0; i < elf->rela_dyn_size; i++) {
|
||||
entry_name = elf->dynstr + elf->dynsym[(rela_dyn->r_info >> 32)].st_name;
|
||||
@elf64_debug_print("rela_dyn->r_offset = %08x\n", rela_dyn->r_offset);
|
||||
@elf64_debug_print("entry name = '%s'\n", entry_name);
|
||||
if (!StrCmp(entry_name, "__libc_start_main")) {
|
||||
*(rela_dyn->r_offset)(U64*) = &_main;
|
||||
@elf64_debug_print("Set value for .rela.dyn entry '%s' to: &_main\n",
|
||||
entry_name);
|
||||
}
|
||||
if (!StrCmp(entry_name, "stdin")) {
|
||||
*(rela_dyn->r_offset)(U64*) = 0;
|
||||
@elf64_debug_print("Set value for .rela.dyn entry '%s' to: %d\n", entry_name, 0);
|
||||
}
|
||||
if (!StrCmp(entry_name, "stdout")) {
|
||||
*(rela_dyn->r_offset)(U64*) = 1;
|
||||
@elf64_debug_print("Set value for .rela.dyn entry '%s' to: %d\n", entry_name, 1);
|
||||
}
|
||||
if (!StrCmp(entry_name, "stderr")) {
|
||||
*(rela_dyn->r_offset)(U64*) = 2;
|
||||
@elf64_debug_print("Set value for .rela.dyn entry '%s' to: %d\n", entry_name, 2);
|
||||
}
|
||||
rela_dyn++;
|
||||
}
|
||||
}
|
||||
|
||||
CHashClass* get_symbol_hash_entry(U8* entry_name)
|
||||
{
|
||||
I64 i;
|
||||
CHashSrcSym* sym;
|
||||
CHashTable* tbl = Fs->hash_table;
|
||||
while (tbl) {
|
||||
for (i = 0; i < tbl->mask; i++) {
|
||||
sym = tbl->body[i];
|
||||
while (sym) {
|
||||
if (sym->type == HTT_CLASS)
|
||||
if (!StrCmp(sym->str, entry_name))
|
||||
return sym;
|
||||
sym = sym->next;
|
||||
}
|
||||
}
|
||||
tbl = tbl->next;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
U64 get_symbol_address(U8* entry_name)
|
||||
{
|
||||
CHash* h = HashFind(entry_name, Fs->hash_table, Fs->hash_table->mask);
|
||||
if (!h)
|
||||
return NULL;
|
||||
switch (h->type) {
|
||||
case HTT_GLBL_VAR:
|
||||
return h(CHashGlblVar*)->data_addr;
|
||||
break;
|
||||
case HTT_FUN:
|
||||
return h(CHashFun*)->exe_addr;
|
||||
break;
|
||||
default:
|
||||
return NULL;
|
||||
break;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
U0 process_elf_rela_plt_entries(Elf* elf)
|
||||
{
|
||||
I64 i;
|
||||
U32 handler;
|
||||
U32* patch;
|
||||
U8* entry_name;
|
||||
Bool symbol_exists;
|
||||
PLT_entry* plt = elf->plt;
|
||||
RELA_entry* rela_plt = elf->rela_plt;
|
||||
plt++;
|
||||
for (i = 0; i < elf->rela_plt_size; i++) {
|
||||
symbol_exists = FALSE;
|
||||
entry_name = elf->dynstr + elf->dynsym[(rela_plt->r_info >> 32)].st_name;
|
||||
handler = MAlloc(sizeof(unimplemented_symbol), adam_task->code_heap);
|
||||
MemCpy(handler, &unimplemented_symbol, sizeof(unimplemented_symbol));
|
||||
patch = handler + 0x0A;
|
||||
*patch = entry_name;
|
||||
@patch_jmp_rel32(plt, handler);
|
||||
@patch_call_rel32(handler + 0x16, &PrintErr);
|
||||
//@patch_call_rel32(handler + 0x21, &_exit);
|
||||
if (!StrCmp(entry_name, "__libc_start_main")) {
|
||||
symbol_exists = TRUE;
|
||||
@patch_jmp_rel32(plt, &_main);
|
||||
@elf64_debug_print("Set value for .rela.plt entry '%s' to &_main\n", entry_name);
|
||||
}
|
||||
if (get_symbol_address(entry_name)) {
|
||||
symbol_exists = TRUE;
|
||||
@patch_jmp_rel32(plt, get_symbol_address(entry_name));
|
||||
@elf64_debug_print("Set value for .rela.plt entry '%s' to &%s\n", entry_name,
|
||||
entry_name);
|
||||
}
|
||||
if (!symbol_exists)
|
||||
@elf64_debug_print(
|
||||
"Set value for .rela.plt entry '%s' to &unimplemented_symbol\n",
|
||||
entry_name);
|
||||
rela_plt++;
|
||||
plt++;
|
||||
}
|
||||
}
|
||||
|
||||
U0 load_elf(...)
|
||||
{
|
||||
if (argc < 1) {
|
||||
PrintErr("Not enough arguments.\n");
|
||||
return;
|
||||
}
|
||||
if (!FileFind(argv[0])) {
|
||||
PrintErr("File not found: %s\n", argv[0]);
|
||||
return;
|
||||
}
|
||||
|
||||
Elf elf;
|
||||
elf.u8 = FileRead(argv[0], &elf.size);
|
||||
@elf64_debug_print("Load file '%s', size = %d bytes\n", argv[0], elf.size);
|
||||
|
||||
if (!is_valid_elf(&elf)) {
|
||||
PrintErr("File is not a valid ELF x86-64 executable.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
process_elf_section_header_table(&elf);
|
||||
process_elf_rela_dyn_entries(&elf);
|
||||
process_elf_rela_plt_entries(&elf);
|
||||
|
||||
_start = elf.ehdr->e_entry;
|
||||
elf_argc = argc;
|
||||
elf_argv = argv;
|
||||
}
|
||||
327
System/FFI/LibC.HC
Normal file
327
System/FFI/LibC.HC
Normal file
@@ -0,0 +1,327 @@
|
||||
#define stdin 0
|
||||
#define stdout 1
|
||||
#define stderr 2
|
||||
|
||||
U0 bcmp()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
MemCmp(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U64 @calloc(I64 size)
|
||||
{
|
||||
return CAlloc(size, adam_task->code_heap);
|
||||
}
|
||||
|
||||
U0 calloc()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@calloc(p0 * p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 free()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
Free(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @isatty()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
U0 isatty()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
// Dbg;
|
||||
@isatty;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @fwrite(U8* ptr, I64 size, I64 nmemb, U64 stream)
|
||||
{
|
||||
U8* tmp;
|
||||
switch (stream) {
|
||||
case stdout:
|
||||
case stderr:
|
||||
tmp = CAlloc((size * nmemb) + 1, adam_task->code_heap);
|
||||
MemCpy(tmp, ptr, (size * nmemb));
|
||||
#ifdef QEMU_RUN_TESTS
|
||||
QemuDebugMsg(tmp);
|
||||
#endif
|
||||
DocPutS(adam_task->put_doc, tmp);
|
||||
Free(tmp);
|
||||
// if (!MemCmp(tmp, "VERIFICATION FAILED", 19))
|
||||
// Break;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return size * nmemb;
|
||||
}
|
||||
|
||||
U0 fwrite()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@fwrite(p0, p1, p2, p3);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U64 @getentropy(U8* buffer, U64 length)
|
||||
{
|
||||
I64 i;
|
||||
for (i = 0; i < length; i++)
|
||||
buffer[i] = RandU64;
|
||||
return 0;
|
||||
}
|
||||
|
||||
U0 getentropy()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@getentropy(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 htonl()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
EndianU32(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 ntohl()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
EndianU32(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 htons()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
EndianU16(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 ntohs()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
EndianU16(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U64 @malloc(I64 size)
|
||||
{
|
||||
return MAlloc(size, adam_task->code_heap);
|
||||
}
|
||||
|
||||
U0 malloc()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@malloc(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 memcmp()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
MemCmp(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 memcpy()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
MemCpy(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U8* @memmove(U8* dest, U8* src, I64 n)
|
||||
{
|
||||
I64 i;
|
||||
U8* from = src;
|
||||
U8* to = dest;
|
||||
if (from == to || n == 0)
|
||||
return dest;
|
||||
if (to > from && to - from < n) {
|
||||
/* to overlaps with from */
|
||||
/* <from......> */
|
||||
/* <to........> */
|
||||
/* copy in reverse, to avoid overwriting from */
|
||||
for (i = n - 1; i >= 0; i--)
|
||||
to[i] = from[i];
|
||||
return dest;
|
||||
}
|
||||
if (from > to && from - to < n) {
|
||||
/* to overlaps with from */
|
||||
/* <from......> */
|
||||
/* <to........> */
|
||||
/* copy forwards, to avoid overwriting from */
|
||||
for (i = 0; i < n; i++)
|
||||
to[i] = from[i];
|
||||
return dest;
|
||||
}
|
||||
MemCpy(dest, src, n);
|
||||
return dest;
|
||||
}
|
||||
|
||||
U0 memmove()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@memmove(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 memset()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
MemSet(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 putc()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PutChars(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 rand()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
RandU64;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U8* @realloc(U8* ptr, I64 size)
|
||||
{
|
||||
U8* new;
|
||||
if (!ptr) {
|
||||
new = MAlloc(size, adam_task->code_heap);
|
||||
} else {
|
||||
new = MAlloc(size, adam_task->code_heap);
|
||||
MemCpy(new, ptr, size);
|
||||
Free(ptr);
|
||||
}
|
||||
return new;
|
||||
}
|
||||
|
||||
U0 realloc()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@realloc(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
// FIXME: It is non-obvious how to take a [u8] and convert it to a
|
||||
// formatted string in Jakt, so we have to do this hack for
|
||||
// now. Hopefully, this will change soon.
|
||||
U0 sprintf()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
StrPrint(p0, p1, p2, p3, p4, p5);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @strncmp(U8* s1, U8* s2, I32 n)
|
||||
{
|
||||
U64 u1, u2;
|
||||
|
||||
while (n-- > 0) {
|
||||
u1 = *s1++;
|
||||
u2 = *s2++;
|
||||
u1 = u1 & 0xff;
|
||||
u2 = u2 & 0xff;
|
||||
if (u1 != u2)
|
||||
return u1 - u2;
|
||||
if (u1 == '\0')
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
U0 strncmp()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@strncmp(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 strcmp()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
StrCmp(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 strlen()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
StrLen(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 tos_nist_offset = 5020;
|
||||
#define NIST_TIME_OFFSET (tos_nist_offset - local_time_offset / CDATE_FREQ)
|
||||
|
||||
public
|
||||
I64 CDate2Unix(CDate dt)
|
||||
{ // TempleOS datetime to Unix timestamp.
|
||||
return ToI64((dt - Str2Date("1/1/1970")) / CDATE_FREQ + NIST_TIME_OFFSET);
|
||||
}
|
||||
|
||||
I64 @time(I64* ptr)
|
||||
{
|
||||
no_warn ptr;
|
||||
return CDate2Unix(Now);
|
||||
}
|
||||
|
||||
U0 time()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@time(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 toupper()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
ToUpper(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 __assert_fail()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
"%s:%d: %s: %s\n", p1, p2, p3, p0;
|
||||
Break;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
35
System/FFI/New.HC
Normal file
35
System/FFI/New.HC
Normal file
@@ -0,0 +1,35 @@
|
||||
U0 _ZdlPv()
|
||||
{
|
||||
// operator delete(void*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
Free(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _ZdlPvm()
|
||||
{
|
||||
// operator delete(void*, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
Free(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Znwm()
|
||||
{
|
||||
// operator new(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
MAlloc(p0, adam_task);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _ZnwmRKSt9nothrow_t()
|
||||
{
|
||||
// operator new(unsigned long, std::nothrow_t const&)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
MAlloc(p0, adam_task);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
288
System/Jakt/DC.HC
Normal file
288
System/Jakt/DC.HC
Normal file
@@ -0,0 +1,288 @@
|
||||
U0 _Z8dc_aliasm()
|
||||
{
|
||||
// dc_alias(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
DCAlias(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z7dc_blotmmmm()
|
||||
{
|
||||
// dc_blot(unsigned long, unsigned long, unsigned long, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GrBlot(p0, p1, p2, p3);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U8* @dc_buffer(CDC* dc) { return dc->body; }
|
||||
|
||||
U0 _Z9dc_bufferm()
|
||||
{
|
||||
// dc_buffer(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_buffer(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @dc_color(CDC* dc) { return dc->color; }
|
||||
|
||||
U0 _Z8dc_colorm()
|
||||
{
|
||||
// dc_color(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_color(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 @dc_copy(CDC* dest, I64 x, I64 y, CDC* src)
|
||||
{
|
||||
|
||||
// If position is off-screen, return
|
||||
if (x > dest->width - 1 || y > dest->height - 1)
|
||||
return;
|
||||
|
||||
// If device context dimensions match, MemCpy and return
|
||||
if (dest->width_internal == src->width_internal && dest->height == src->height) {
|
||||
MemCpy(dest->body, src->body, dest->width_internal * dest->height);
|
||||
return;
|
||||
}
|
||||
|
||||
CDC* dc1 = DCAlias(dest);
|
||||
CDC* dc2 = DCAlias(src);
|
||||
|
||||
I64 src_line = 0;
|
||||
I64 src_row = 0;
|
||||
I64 clip_y = 0;
|
||||
|
||||
// Handle horizontal clipping left
|
||||
while (x < 0) {
|
||||
dc2->x0++;
|
||||
x++;
|
||||
}
|
||||
|
||||
// Handle vertical clipping top
|
||||
while (y < 0) {
|
||||
dc2->body += src->width_internal;
|
||||
dc2->y0++;
|
||||
y++;
|
||||
}
|
||||
|
||||
// default, clip line to copy as width-left off screen
|
||||
src_line = src->width - dc2->x0;
|
||||
|
||||
if (-dc2->x0 + x + src->width >= dest->width) {
|
||||
src_line -= ((-dc2->x0 + x + src->width) - dest->width);
|
||||
}
|
||||
|
||||
dc2->body += dc2->x0;
|
||||
clip_y = y;
|
||||
|
||||
while (src_row < (src->height - dc2->y0) && clip_y < dest->height) {
|
||||
MemCpy(dc1->body + (y * dest->width) + x, dc2->body, src_line);
|
||||
dc2->body += src->width_internal;
|
||||
dc1->body += dest->width_internal;
|
||||
clip_y++;
|
||||
src_row++;
|
||||
}
|
||||
|
||||
Free(dc2);
|
||||
Free(dc1);
|
||||
}
|
||||
|
||||
U0 _Z7dc_copymmmm()
|
||||
{
|
||||
// dc_copy(unsigned long, unsigned long, unsigned long, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_copy(p0, p1, p2, p3);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z10dc_destroym()
|
||||
{
|
||||
// dc_destroy(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
DCDel(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z14dc_draw_circlemlll()
|
||||
{
|
||||
// dc_draw_circle(unsigned long, long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GrCircle3(p0, p1, p2, 0, p3);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z19dc_draw_filled_rectmllll()
|
||||
{
|
||||
// dc_draw_filled_rect(unsigned long, long, long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GrRect(p0, p1, p2, p3, p4);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z12dc_draw_linemllll()
|
||||
{
|
||||
// dc_draw_line(unsigned long, long, long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GrLine3(p0, p1, p2, 0, p3, p4, 0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z13dc_draw_pixelmll()
|
||||
{
|
||||
// dc_draw_pixel(unsigned long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GrPlot(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z7dc_fillmm()
|
||||
{
|
||||
// dc_fill(unsigned long, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
DCFill(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
CDC* @dc_gr_dc() { return gr.dc; }
|
||||
|
||||
U0 _Z8dc_gr_dcv()
|
||||
{
|
||||
// dc_gr_dc()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_gr_dc();
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @dc_height(CDC* dc) { return dc->height; }
|
||||
|
||||
U0 _Z9dc_heightm()
|
||||
{
|
||||
// dc_height(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_height(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z17dc_load_from_filePKc()
|
||||
{
|
||||
// dc_load_from_file(char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GRRead(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z6dc_newmm()
|
||||
{
|
||||
// dc_new(unsigned long, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
DCNew(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z11dc_pixel_atmll()
|
||||
{
|
||||
// dc_pixel_at(unsigned long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GrPeek(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z16dc_replace_colormmm()
|
||||
{
|
||||
// dc_replace_color(unsigned long, unsigned long, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
DCColorChg(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z13dc_screenshotv()
|
||||
{
|
||||
// dc_screenshot()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
DCScrnCapture(1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z15dc_save_to_filePKcm()
|
||||
{
|
||||
// dc_save_to_file(char const*, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GRWrite(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 @dc_set_color(CDC* dc, I64 color) { dc->color = color; }
|
||||
|
||||
U0 _Z12dc_set_colorml()
|
||||
{
|
||||
// dc_set_color(unsigned long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_set_color(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 @dc_set_thickness(CDC* dc, I64 thickness) { dc->thick = thickness; }
|
||||
|
||||
U0 _Z16dc_set_thicknessml()
|
||||
{
|
||||
// dc_set_thickness(unsigned long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_set_thickness(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @dc_thickness(CDC* dc) { return dc->thick; }
|
||||
|
||||
U0 _Z12dc_thicknessm()
|
||||
{
|
||||
// dc_thickness(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_thickness(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @dc_width(CDC* dc) { return dc->width; }
|
||||
|
||||
U0 _Z8dc_widthm()
|
||||
{
|
||||
// dc_width(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_width(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @dc_width_internal(CDC* dc) { return dc->width_internal; }
|
||||
|
||||
U0 _Z17dc_width_internalm()
|
||||
{
|
||||
// dc_width_internal(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@dc_width_internal(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
53
System/Jakt/IOPort.HC
Normal file
53
System/Jakt/IOPort.HC
Normal file
@@ -0,0 +1,53 @@
|
||||
U0 _Z14ioport_read_u8t()
|
||||
{
|
||||
// ioport_read_u8(unsigned short)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
InU8(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z15ioport_read_u16t()
|
||||
{
|
||||
// ioport_read_u16(unsigned short)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
InU16(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z15ioport_read_u32t()
|
||||
{
|
||||
// ioport_read_u32(unsigned short)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
InU32(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z15ioport_write_u8th()
|
||||
{
|
||||
// ioport_write_u8(unsigned short, unsigned char)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
OutU8(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z16ioport_write_u16tt()
|
||||
{
|
||||
// ioport_write_u16(unsigned short, unsigned short)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
OutU16(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z16ioport_write_u32tj()
|
||||
{
|
||||
// ioport_write_u32(unsigned short, unsigned int)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
OutU32(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
72
System/Jakt/Input.HC
Normal file
72
System/Jakt/Input.HC
Normal file
@@ -0,0 +1,72 @@
|
||||
U0 _Z16input_get_stringPKc()
|
||||
{
|
||||
// input_get_string(char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
GetStr(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
Bool @input_key_down(U8 scancode) { return Bt(kbd.down_bitmap, scancode); }
|
||||
|
||||
U0 _Z14input_key_downh()
|
||||
{
|
||||
// input_key_down(unsigned char)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@input_key_down(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
Bool @input_mouse_left() { return ms.lb; }
|
||||
|
||||
U0 _Z16input_mouse_leftv()
|
||||
{
|
||||
// input_mouse_left()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@input_mouse_left();
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
Bool @input_mouse_right() { return ms.rb; }
|
||||
|
||||
U0 _Z17input_mouse_rightv()
|
||||
{
|
||||
// input_mouse_right()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@input_mouse_right();
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @input_mouse_x() { return ms.pos.x; }
|
||||
|
||||
U0 _Z13input_mouse_xv()
|
||||
{
|
||||
// input_mouse_x()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@input_mouse_x();
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @input_mouse_y() { return ms.pos.y; }
|
||||
|
||||
U0 _Z13input_mouse_yv()
|
||||
{
|
||||
// input_mouse_y()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@input_mouse_y();
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z17input_press_a_keyv()
|
||||
{
|
||||
// input_press_a_key()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PressAKey;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
282
System/Jakt/OS.HC
Normal file
282
System/Jakt/OS.HC
Normal file
@@ -0,0 +1,282 @@
|
||||
U0 _Z8os_blinkPKc()
|
||||
{
|
||||
// os_blink(char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
F64 frequency = Str2F64(p0);
|
||||
Print("called os_blink(%.1f)\n", frequency);
|
||||
Blink(frequency);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U64 @os_call(U64 addr, U64 val)
|
||||
{
|
||||
if (!addr || !val)
|
||||
return NULL;
|
||||
U64 (*func)(U64 arg);
|
||||
func = addr;
|
||||
return func(val);
|
||||
}
|
||||
|
||||
U0 _Z7os_callmm()
|
||||
{
|
||||
// os_call(unsigned long, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@os_call(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z16os_device_callocj()
|
||||
{
|
||||
// os_device_calloc(unsigned int)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
CAllocAligned(p0, 4096, adam_task->code_heap);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z7os_exitv()
|
||||
{
|
||||
// os_exit()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
UserTaskCont;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U8* @os_file_picker(U8* path, U8* glob)
|
||||
{
|
||||
U8* full_path = CAlloc(StrLen(path) + StrLen(glob) + 4, adam_task);
|
||||
CatPrint(full_path, "%s/%s", path, glob);
|
||||
|
||||
CDirEntry* de = FilesFind(full_path);
|
||||
Free(full_path);
|
||||
|
||||
CDirEntry* tmpde;
|
||||
U8* file_list = NULL;
|
||||
U8* selected_file = NULL;
|
||||
I64 list_pos = 0;
|
||||
I64 list_size = 0;
|
||||
|
||||
tmpde = de;
|
||||
while (tmpde) {
|
||||
list_size += StrLen(tmpde->name) + 2;
|
||||
tmpde = tmpde->next;
|
||||
}
|
||||
|
||||
file_list = CAlloc(list_size, adam_task);
|
||||
|
||||
tmpde = de;
|
||||
while (tmpde) {
|
||||
StrCpy(file_list + list_pos, tmpde->name);
|
||||
list_pos += StrLen(tmpde->name) + 1;
|
||||
tmpde = tmpde->next;
|
||||
}
|
||||
|
||||
I64 list_index = Adam("PopUpPickLst(0x%08x);\n", file_list);
|
||||
Free(file_list);
|
||||
list_pos = 0;
|
||||
|
||||
if (list_index < 0) {
|
||||
DirTreeDel(de);
|
||||
return StrNew("", adam_task);
|
||||
}
|
||||
|
||||
tmpde = de;
|
||||
while (tmpde) {
|
||||
if (list_index == list_pos) {
|
||||
selected_file = CAlloc(StrLen(path) + StrLen(tmpde->name) + 4, adam_task);
|
||||
CatPrint(selected_file, "%s/%s", path, tmpde->name);
|
||||
break;
|
||||
}
|
||||
StrCpy(file_list + list_pos, tmpde->name);
|
||||
list_pos++;
|
||||
tmpde = tmpde->next;
|
||||
}
|
||||
|
||||
DirTreeDel(de);
|
||||
return selected_file;
|
||||
}
|
||||
|
||||
U0 _Z14os_file_pickerPKcS0_()
|
||||
{
|
||||
// os_file_picker(char const*, char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@os_file_picker(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U8* @os_files_list(U8* path)
|
||||
{
|
||||
U8* full_path = CAlloc(StrLen(path) + 4, adam_task);
|
||||
CatPrint(full_path, "%s", path);
|
||||
|
||||
CDirEntry* de = FilesFind(full_path);
|
||||
Free(full_path);
|
||||
|
||||
CDateStruct ds;
|
||||
CDirEntry* tmpde;
|
||||
U8* file_list = NULL;
|
||||
I64 list_size = 0;
|
||||
|
||||
tmpde = de;
|
||||
while (tmpde) {
|
||||
list_size += StrLen(tmpde->name) + 48; // Should be enough for filename, date,
|
||||
// filesize + semicolon separators
|
||||
tmpde = tmpde->next;
|
||||
}
|
||||
|
||||
if (!list_size)
|
||||
return NULL;
|
||||
|
||||
file_list = CAlloc(list_size, adam_task);
|
||||
|
||||
tmpde = de;
|
||||
I64 counter = 0;
|
||||
|
||||
while (tmpde) {
|
||||
if (counter > 0) {
|
||||
StrCpy(file_list + StrLen(file_list), "|");
|
||||
}
|
||||
StrCpy(file_list + StrLen(file_list), tmpde->name);
|
||||
if (tmpde->attr & RS_ATTR_DIR)
|
||||
StrCpy(file_list + StrLen(file_list), "/");
|
||||
StrCpy(file_list + StrLen(file_list), ";");
|
||||
Date2Struct(&ds, tmpde->datetime);
|
||||
StrPrint(file_list + StrLen(file_list), "%04d-%02d-%02d %02d:%02d", ds.year,
|
||||
ds.mon, ds.day_of_mon, ds.hour, ds.min);
|
||||
StrCpy(file_list + StrLen(file_list), ";");
|
||||
StrPrint(file_list + StrLen(file_list), "%d", tmpde->size);
|
||||
tmpde = tmpde->next;
|
||||
counter++;
|
||||
}
|
||||
|
||||
DirTreeDel(de);
|
||||
return file_list;
|
||||
}
|
||||
|
||||
U0 _Z14os_path_existsPKc()
|
||||
{
|
||||
// os_path_exists(char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
FileFind(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z13os_files_listPKc()
|
||||
{
|
||||
// os_files_list(char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@os_files_list(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
Bool @os_is_vm()
|
||||
{
|
||||
CRAXRBCRCXRDX res;
|
||||
CPUId(0x40000000, &res);
|
||||
if (res.rbx == 0x4B4D564B)
|
||||
return TRUE;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
U0 _Z8os_is_vmv()
|
||||
{
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@os_is_vm;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 @os_pc_speaker(F64 frequency)
|
||||
{
|
||||
I64 period;
|
||||
if (!frequency)
|
||||
OutU8(0x61, InU8(0x61) & ~3);
|
||||
else {
|
||||
period = ClampI64(SYS_TIMER_FREQ / frequency, 1, U16_MAX);
|
||||
OutU8(0x43, 0xB6);
|
||||
OutU8(0x42, period);
|
||||
OutU8(0x42, period.u8[1]);
|
||||
OutU8(0x61, 3 | InU8(0x61));
|
||||
}
|
||||
}
|
||||
|
||||
U0 _Z13os_pc_speakerPKc()
|
||||
{
|
||||
// os_pc_speaker(char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
F64 frequency = Str2F64(p0);
|
||||
@os_pc_speaker(frequency);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z9os_randomv()
|
||||
{
|
||||
// os_random()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
RandU64;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z19os_read_entire_filePKcPl()
|
||||
{
|
||||
// os_read_entire_file(char const*, long*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
FileRead(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 @os_screenshot()
|
||||
{
|
||||
CDC* dc = DCScrnCapture(, adam_task);
|
||||
// Image.Write("B:/screenshot.png", dc);
|
||||
DCDel(dc);
|
||||
}
|
||||
|
||||
U0 _Z13os_screenshotv()
|
||||
{
|
||||
// os_screenshot()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@os_screenshot;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U8* @os_to_uppercase(U8* instr)
|
||||
{
|
||||
if (!instr)
|
||||
return NULL;
|
||||
if (!StrLen(instr))
|
||||
return NULL;
|
||||
U8* outstr = CAlloc(StrLen(instr) + 1, adam_task);
|
||||
I64 i;
|
||||
for (i = 0; i < StrLen(instr); i++)
|
||||
outstr[i] = ToUpper(instr[i]);
|
||||
return outstr;
|
||||
}
|
||||
|
||||
U0 _Z15os_to_uppercasePKc()
|
||||
{
|
||||
// os_to_uppercase(char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@os_to_uppercase(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z20os_write_entire_filePKcPhl()
|
||||
{
|
||||
// os_write_entire_file(char const*, unsigned char*, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
FileWrite(p0, p1, p2);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
62
System/Jakt/PCI.HC
Normal file
62
System/Jakt/PCI.HC
Normal file
@@ -0,0 +1,62 @@
|
||||
U0 _Z8pci_findl()
|
||||
{
|
||||
// pci_find(long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PCIClassFind(p0, 0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z11pci_read_u8llll()
|
||||
{
|
||||
// pci_read_u8(long, long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PCIReadU8(p0, p1, p2, p3);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z12pci_read_u16llll()
|
||||
{
|
||||
// pci_read_u16(long, long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PCIReadU16(p0, p1, p2, p3);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z12pci_read_u32llll()
|
||||
{
|
||||
// pci_read_u32(long, long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PCIReadU32(p0, p1, p2, p3);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z12pci_write_u8llllh()
|
||||
{
|
||||
// pci_write_u8(long, long, long, long, unsigned char)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PCIWriteU8(p0, p1, p2, p3, p4);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z13pci_write_u16llllt()
|
||||
{
|
||||
// pci_write_u16(long, long, long, long, unsigned short)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PCIWriteU16(p0, p1, p2, p3, p4);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z13pci_write_u32llllj()
|
||||
{
|
||||
// pci_write_u32(long, long, long, long, unsigned int)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
PCIWriteU32(p0, p1, p2, p3, p4);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
37
System/Jakt/Time.HC
Normal file
37
System/Jakt/Time.HC
Normal file
@@ -0,0 +1,37 @@
|
||||
U0 _Z9time_busyl()
|
||||
{
|
||||
// time_busy(long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
Busy(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
I64 @time_jiffies() { return cnts.jiffies; }
|
||||
|
||||
U0 _Z12time_jiffiesv()
|
||||
{
|
||||
// time_jiffies()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@time_jiffies;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z8time_nowv()
|
||||
{
|
||||
// time_now()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
Now;
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z10time_sleepl()
|
||||
{
|
||||
// time_sleep(long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
Sleep(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
94
System/Jakt/Window.HC
Normal file
94
System/Jakt/Window.HC
Normal file
@@ -0,0 +1,94 @@
|
||||
U0 @window_draw_it(CTask* task, CDC* dc)
|
||||
{
|
||||
if (task->user_data)
|
||||
@dc_copy(dc, task->pix_left, task->pix_top, task->user_data);
|
||||
}
|
||||
|
||||
CTask* @window_user()
|
||||
{
|
||||
CTask* task = Spawn(&UserCmdLine, , , 0);
|
||||
TaskWait(task);
|
||||
XTalk(task,
|
||||
"while (1) { StrCpy(Fs->task_title, Fs->task_name); Sleep(1); };\n");
|
||||
return task;
|
||||
}
|
||||
|
||||
CTask* @window_create()
|
||||
{
|
||||
CTask* task = @window_user;
|
||||
task->draw_it = &@window_draw_it;
|
||||
return task;
|
||||
}
|
||||
|
||||
U0 _Z13window_createv()
|
||||
{
|
||||
// window_create()
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@window_create();
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 _Z14window_destroym()
|
||||
{
|
||||
// window_destroy(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
Kill(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
Bool @window_is_focused(CTask* task) { return task == sys_focus_task; }
|
||||
|
||||
U0 _Z17window_is_focusedm()
|
||||
{
|
||||
// window_is_focused(unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@window_is_focused(p0);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 @window_set_coordinates(CTask* task, I64 top, I64 left, I64 bottom,
|
||||
I64 right)
|
||||
{
|
||||
task->win_top = top;
|
||||
task->win_left = left;
|
||||
task->win_bottom = bottom;
|
||||
task->win_right = right;
|
||||
}
|
||||
|
||||
U0 _Z22window_set_coordinatesmllll()
|
||||
{
|
||||
// window_set_coordinates(unsigned long, long, long, long, long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@window_set_coordinates(p0, p1, p2, p3, p4);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 @window_set_context(CTask* task, CDC* dc) { task->user_data = dc; }
|
||||
|
||||
U0 _Z18window_set_contextmm()
|
||||
{
|
||||
// window_set_context(unsigned long, unsigned long)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@window_set_context(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
|
||||
U0 @window_set_title(CTask* task, U8* title)
|
||||
{
|
||||
StrCpy(task->task_name, title);
|
||||
StrCpy(task->task_title, title);
|
||||
}
|
||||
|
||||
U0 _Z16window_set_titlemPKc()
|
||||
{
|
||||
// window_set_title(unsigned long, char const*)
|
||||
PUSH_SYSV_REGS
|
||||
GET_SYSV_ARGS
|
||||
@window_set_title(p0, p1);
|
||||
POP_SYSV_REGS
|
||||
}
|
||||
1573
System/Libraries/Json.HC
Normal file
1573
System/Libraries/Json.HC
Normal file
File diff suppressed because it is too large
Load Diff
196
System/Libraries/String.HC
Normal file
196
System/Libraries/String.HC
Normal file
@@ -0,0 +1,196 @@
|
||||
#define TRIM_BOTH 0
|
||||
#define TRIM_LEFT 1
|
||||
#define TRIM_RIGHT 2
|
||||
|
||||
I64 StrLenI32(I32* str)
|
||||
{
|
||||
I64 res = 0;
|
||||
while (*str) {
|
||||
++res;
|
||||
++str;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
U0 @string_append(U8* dst, U8* fmt, ...)
|
||||
{
|
||||
U8* buf;
|
||||
if (argc) {
|
||||
buf = StrPrintJoin(NULL, fmt, argc, argv);
|
||||
} else {
|
||||
buf = StrNew(fmt, adam_task);
|
||||
}
|
||||
U8* src = buf;
|
||||
StrCpy(dst + StrLen(dst), src);
|
||||
Free(buf);
|
||||
}
|
||||
|
||||
Bool @string_is_number(U8* s)
|
||||
{
|
||||
while (*s) {
|
||||
switch (*s) {
|
||||
case '-':
|
||||
case '.':
|
||||
case '0' ... '9':
|
||||
break;
|
||||
default:
|
||||
return FALSE;
|
||||
break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
Bool @string_begins_with(U8* fragment, U8* str)
|
||||
{
|
||||
if (!fragment || !str)
|
||||
return FALSE;
|
||||
if (StrLen(fragment) > StrLen(str))
|
||||
return FALSE;
|
||||
return !MemCmp(fragment, str, StrLen(fragment));
|
||||
}
|
||||
|
||||
Bool @string_ends_with(U8* fragment, U8* str)
|
||||
{
|
||||
if (!fragment || !str)
|
||||
return FALSE;
|
||||
if (StrLen(fragment) > StrLen(str))
|
||||
return FALSE;
|
||||
return !MemCmp(fragment, str + StrLen(str) - StrLen(fragment), StrLen(fragment));
|
||||
}
|
||||
|
||||
U0 @string_lower(U8* s)
|
||||
{
|
||||
while (*s) {
|
||||
switch (*s) {
|
||||
case 'A' ... 'Z':
|
||||
*s += 32;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
++s;
|
||||
}
|
||||
}
|
||||
|
||||
U8* @string_replace(U8* s, U8* oldW, U8* newW)
|
||||
{
|
||||
if (!StrFind(oldW, s)) {
|
||||
return StrNew(s, adam_task);
|
||||
}
|
||||
U8* result;
|
||||
I64 i, cnt = 0;
|
||||
I64 newWlen = StrLen(newW);
|
||||
I64 oldWlen = StrLen(oldW);
|
||||
for (i = 0; s[i] != NULL; i++) {
|
||||
if (StrFind(oldW, &s[i]) == &s[i]) {
|
||||
cnt++;
|
||||
|
||||
i += oldWlen - 1;
|
||||
}
|
||||
}
|
||||
result = MAlloc(i + cnt * (newWlen - oldWlen) + 1, adam_task);
|
||||
i = 0;
|
||||
while (*s) {
|
||||
if (StrFind(oldW, s) == s) {
|
||||
StrCpy(&result[i], newW);
|
||||
i += newWlen;
|
||||
s += oldWlen;
|
||||
} else
|
||||
result[i++] = *s++;
|
||||
}
|
||||
result[i] = NULL;
|
||||
return result;
|
||||
}
|
||||
|
||||
U8** @string_split(U8* s, U8 ch = '\n', I64* cnt)
|
||||
{
|
||||
U8 check_buf[4];
|
||||
StrPrint(check_buf, "%c", ch);
|
||||
if (!StrFind(check_buf, s)) {
|
||||
U8** same_arr = CAlloc(sizeof(U8*) * 1, adam_task);
|
||||
same_arr[0] = s;
|
||||
*cnt = 1;
|
||||
return same_arr;
|
||||
}
|
||||
U8* p = s;
|
||||
cnt[0] = 0;
|
||||
while (*p) {
|
||||
if (*p == ch)
|
||||
cnt[0]++;
|
||||
p++;
|
||||
}
|
||||
if (!(cnt[0]))
|
||||
return NULL;
|
||||
cnt[0]++;
|
||||
I64 i = -1;
|
||||
U8** arr = CAlloc(sizeof(U8*) * cnt[0], adam_task);
|
||||
p = s;
|
||||
while (*p) {
|
||||
if (*p == ch || i < 0) {
|
||||
i++;
|
||||
arr[i] = p;
|
||||
if (*p == ch) {
|
||||
arr[i]++;
|
||||
*p = NULL;
|
||||
}
|
||||
}
|
||||
p++;
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
Bool @string_trim_ch(U8 s_ch, U8 trim_ch)
|
||||
{
|
||||
if (!s_ch) {
|
||||
return FALSE;
|
||||
}
|
||||
if (!trim_ch) {
|
||||
return (s_ch == ' ' || s_ch == '\r' || s_ch == '\n' || s_ch == '\t');
|
||||
} else {
|
||||
return (s_ch == trim_ch);
|
||||
}
|
||||
}
|
||||
|
||||
U0 @string_trim(U8* s, U8 ch = NULL, I64 mode = TRIM_BOTH)
|
||||
{
|
||||
Bool trim_ch = @string_trim_ch(*s, ch);
|
||||
if (mode == TRIM_BOTH || mode == TRIM_LEFT) {
|
||||
while (trim_ch) {
|
||||
StrCpy(s, s + 1);
|
||||
trim_ch = @string_trim_ch(*s, ch);
|
||||
}
|
||||
}
|
||||
trim_ch = @string_trim_ch(s[StrLen(s) - 1], ch);
|
||||
if (mode == TRIM_BOTH || mode == TRIM_RIGHT) {
|
||||
while (trim_ch) {
|
||||
s[StrLen(s) - 1] = NULL;
|
||||
trim_ch = @string_trim_ch(s[StrLen(s) - 1], ch);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class @string
|
||||
{
|
||||
U0 (*Append)(U8* dst, U8* fmt, ...);
|
||||
Bool (*BeginsWith)(U8* fragment, U8* str);
|
||||
Bool (*EndsWith)(U8* fragment, U8* str);
|
||||
Bool (*IsNumber)(U8* s);
|
||||
U0 (*Lower)(U8* s);
|
||||
U8* (*Replace)(U8* s, U8* oldW, U8* newW);
|
||||
U8** (*Split)(U8* s, U8 ch = '\n', I64 * cnt);
|
||||
U0 (*Trim)(U8* s, U8 ch = NULL, I64 mode = TRIM_BOTH);
|
||||
};
|
||||
|
||||
@string String;
|
||||
String.Append = &@string_append;
|
||||
String.BeginsWith = &@string_begins_with;
|
||||
String.EndsWith = &@string_ends_with;
|
||||
String.IsNumber = &@string_is_number;
|
||||
String.Lower = &@string_lower;
|
||||
String.Replace = &@string_replace;
|
||||
String.Split = &@string_split;
|
||||
String.Trim = &@string_trim;
|
||||
|
||||
"string ";
|
||||
56
System/MakeSystem.HC
Normal file
56
System/MakeSystem.HC
Normal file
@@ -0,0 +1,56 @@
|
||||
/* clang-format off */
|
||||
|
||||
#include "Setup/Util";
|
||||
//#include "Setup/MAlloc";
|
||||
#include "Setup/Environment";
|
||||
|
||||
// FFI support files
|
||||
#include "FFI/Base";
|
||||
#include "FFI/LibC";
|
||||
#include "FFI/New";
|
||||
#include "FFI/ELF64";
|
||||
|
||||
// stb_image library
|
||||
#include "Utilities/Image";
|
||||
load_elf("M:/build/bin/image");
|
||||
|
||||
// Jakt support files
|
||||
#include "Jakt/OS";
|
||||
#include "Jakt/IOPort";
|
||||
#include "Jakt/PCI";
|
||||
#include "Jakt/Time";
|
||||
|
||||
// Networking APIs
|
||||
#include "Api/Dns.HC";
|
||||
#include "Api/Icmp.HC";
|
||||
#include "Api/Ipv4.HC";
|
||||
#include "Api/MD5.HC";
|
||||
#include "Api/NetInfo.HC";
|
||||
#include "Api/Tcp.HC";
|
||||
//#include "Api/Tls.HC";
|
||||
|
||||
#include "Libraries/Json";
|
||||
#include "Libraries/String";
|
||||
|
||||
load_elf("M:/build/bin/net");
|
||||
|
||||
// Networking Utilities
|
||||
#include "Utilities/Dns";
|
||||
#include "Utilities/NetRep";
|
||||
#include "Utilities/Ping";
|
||||
//#include "Utilities/Time";
|
||||
|
||||
Spawn(_start, , "Net Task", NET_TASK_CPU);
|
||||
|
||||
#include "9P/Debug";
|
||||
#include "9P/Defs";
|
||||
#include "9P/Draw";
|
||||
#include "9P/Requests";
|
||||
|
||||
#include "NeinTerm";
|
||||
|
||||
//#include "NeinTask";
|
||||
|
||||
//TimeSync;
|
||||
|
||||
/* clang-format on */
|
||||
23
System/Setup/Environment.HC
Normal file
23
System/Setup/Environment.HC
Normal file
@@ -0,0 +1,23 @@
|
||||
#define NET_TASK_CPU 3
|
||||
|
||||
// Before continuing, we:
|
||||
|
||||
// 1. Mark memory in code heap below 0x1000000 as used.
|
||||
sys_code_bp->mem_free_lst->next->pags = 0;
|
||||
|
||||
// 2. Free up 64MB at bottom of code heap for non-HolyC programs
|
||||
sys_code_bp->mem_free_lst = ShrinkMemBlkByPags(sys_code_bp->mem_free_lst, 131072);
|
||||
|
||||
U0 NoBeep(I8, Bool) {};
|
||||
@patch_jmp_rel32(&Beep, &NoBeep); // Don't delay on beep when entering debugger
|
||||
//@patch_jmp_rel32(&Fault2, &Reboot); // Reboot instead of crashing to the debugger
|
||||
|
||||
// 4. Disable exclusive access to BlkDev and Drv
|
||||
|
||||
Bool FakeLock(U64)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@patch_jmp_rel32(&BlkDevLock, &FakeLock);
|
||||
@patch_jmp_rel32(&DrvLock, &FakeLock);
|
||||
180
System/Setup/Util.HC
Normal file
180
System/Setup/Util.HC
Normal file
@@ -0,0 +1,180 @@
|
||||
AutoComplete(0);
|
||||
|
||||
U0 @sse_enable()
|
||||
{
|
||||
/* clang-format off */
|
||||
asm
|
||||
{
|
||||
MOV_EAX_CR0
|
||||
AND AX, 0xFFFB // clear coprocessor emulation CR0.EM
|
||||
OR AX, 0x2 // set coprocessor monitoring CR0.MP
|
||||
MOV_CR0_EAX
|
||||
MOV_EAX_CR4
|
||||
OR AX, 3 << 9 // set CR4.OSFXSR and CR4.OSXMMEXCPT at the same time
|
||||
MOV_CR4_EAX
|
||||
}
|
||||
/* clang-format on */
|
||||
}
|
||||
|
||||
U0 @sse_enable_on_all_cores()
|
||||
{
|
||||
I64 i;
|
||||
for (i = 1; i < mp_cnt; i++)
|
||||
Spawn(&@sse_enable, , , i);
|
||||
}
|
||||
|
||||
// Enable SSE
|
||||
@sse_enable;
|
||||
@sse_enable_on_all_cores;
|
||||
|
||||
U0 @patch_call_rel32(U32 from, U32 to)
|
||||
{
|
||||
*(from(U8*)) = 0xE8;
|
||||
*((from + 1)(I32*)) = to - from - 5;
|
||||
}
|
||||
|
||||
U0 @patch_jmp_rel32(U32 from, U32 to)
|
||||
{
|
||||
*(from(U8*)) = 0xE9;
|
||||
*((from + 1)(I32*)) = to - from - 5;
|
||||
}
|
||||
|
||||
I64 tos_nist_offset = 5603; // UTC -4
|
||||
#define NIST_TIME_OFFSET (tos_nist_offset - local_time_offset / CDATE_FREQ)
|
||||
|
||||
public
|
||||
I64 CDate2Unix(CDate dt)
|
||||
{ // TempleOS datetime to Unix timestamp.
|
||||
return ToI64((dt - Str2Date("1/1/1970")) / CDATE_FREQ + NIST_TIME_OFFSET);
|
||||
}
|
||||
|
||||
public
|
||||
CDate Unix2CDate(I64 timestamp)
|
||||
{ // Unix timestamp to TempleOS datetime.
|
||||
return (timestamp - NIST_TIME_OFFSET) * CDATE_FREQ + Str2Date("1/1/1970");
|
||||
}
|
||||
|
||||
// FIXME: Put these in a "Builtin" library?
|
||||
U0 FifoU8Cpy(CFifoU8* f, U8* s)
|
||||
{
|
||||
if (!f || !s)
|
||||
return;
|
||||
while (*s)
|
||||
FifoU8Ins(f, *s++);
|
||||
}
|
||||
Bool KeyDown(I64 sc) return Bt(kbd.down_bitmap, sc);
|
||||
I64 T(Bool _condition, I64 _true, I64 _false)
|
||||
{
|
||||
if (_condition)
|
||||
return _true;
|
||||
return _false;
|
||||
}
|
||||
|
||||
asm
|
||||
{
|
||||
_MEMCPY_U16::
|
||||
PUSH RBP
|
||||
MOV RBP,RSP
|
||||
PUSH RSI
|
||||
PUSH RDI
|
||||
CLD
|
||||
MOV RDI,U64 SF_ARG1[RBP]
|
||||
MOV RSI,U64 SF_ARG2[RBP]
|
||||
MOV RCX,U64 SF_ARG3[RBP]
|
||||
REP_MOVSW
|
||||
MOV RAX,RDI
|
||||
POP RDI
|
||||
POP RSI
|
||||
POP RBP
|
||||
RET1 24
|
||||
_MEMCPY_U32::
|
||||
PUSH RBP
|
||||
MOV RBP,RSP
|
||||
PUSH RSI
|
||||
PUSH RDI
|
||||
CLD
|
||||
MOV RDI,U64 SF_ARG1[RBP]
|
||||
MOV RSI,U64 SF_ARG2[RBP]
|
||||
MOV RCX,U64 SF_ARG3[RBP]
|
||||
REP_MOVSD
|
||||
MOV RAX,RDI
|
||||
POP RDI
|
||||
POP RSI
|
||||
POP RBP
|
||||
RET1 24
|
||||
_MEMCPY_U64::
|
||||
PUSH RBP
|
||||
MOV RBP,RSP
|
||||
PUSH RSI
|
||||
PUSH RDI
|
||||
CLD
|
||||
MOV RDI,U64 SF_ARG1[RBP]
|
||||
MOV RSI,U64 SF_ARG2[RBP]
|
||||
MOV RCX,U64 SF_ARG3[RBP]
|
||||
REP_MOVSQ
|
||||
MOV RAX,RDI
|
||||
POP RDI
|
||||
POP RSI
|
||||
POP RBP
|
||||
RET1 24
|
||||
}
|
||||
|
||||
public _extern _MEMCPY_U16 U16* MemCpyU16(U16* dst, U16* src, I64 cnt);
|
||||
public
|
||||
_extern _MEMCPY_U32 U32* MemCpyU32(U32* dst, U32* src, I64 cnt);
|
||||
public
|
||||
_extern _MEMCPY_U64 U64* MemCpyU64(U64* dst, U64* src, I64 cnt);
|
||||
|
||||
I64 @lerp(U32 val, U32 mx1, U32 mx2)
|
||||
{
|
||||
F64 r = (val & mx1) / ToF64(mx1);
|
||||
return ToI64(r * mx2);
|
||||
}
|
||||
|
||||
CMemBlk* ShrinkMemBlkByPags(CMemBlk* from, I64 count)
|
||||
{
|
||||
from->pags -= count;
|
||||
U64 to = from;
|
||||
to += count * MEM_PAG_SIZE;
|
||||
MemCpy(to, from, MEM_PAG_SIZE);
|
||||
return to;
|
||||
}
|
||||
|
||||
I64 @t(Bool _condition, I64 _true, I64 _false)
|
||||
{
|
||||
if (_condition)
|
||||
return _true;
|
||||
return _false;
|
||||
}
|
||||
|
||||
U0 dd() { DocDump(adam_task->put_doc); }
|
||||
|
||||
Bool FifoU8Last(CFifoU8* f, U8* _b)
|
||||
{ // Peek at back of fifo and don't remove.
|
||||
PUSHFD
|
||||
CLI if (f->in_ptr == f->out_ptr)
|
||||
{
|
||||
POPFD
|
||||
return FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
I64 last_ptr = f->in_ptr - 1;
|
||||
if (last_ptr < 0)
|
||||
last_ptr = FifoU8Cnt(f) - 1;
|
||||
*_b = f->buf[last_ptr];
|
||||
POPFD
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
U8 reverse_bits(U8 n)
|
||||
{
|
||||
// Swap nibbles
|
||||
n = ((n >> 4) & 0x0F) | ((n & 0x0F) << 4);
|
||||
// Swap adjacent pairs
|
||||
n = ((n >> 2) & 0x33) | ((n & 0x33) << 2);
|
||||
// Swap adjacent bits
|
||||
n = ((n >> 1) & 0x55) | ((n & 0x55) << 1);
|
||||
return n;
|
||||
}
|
||||
10
System/Utilities/Dns.HC
Normal file
10
System/Utilities/Dns.HC
Normal file
@@ -0,0 +1,10 @@
|
||||
U0 DnsQuery(U8* host)
|
||||
{
|
||||
U32 result = @dns_query(host);
|
||||
if (result == U32_MAX) {
|
||||
"Error looking up host %s\n", host;
|
||||
return;
|
||||
}
|
||||
"Query for %s: %d.%d.%d.%d\n", host, result.u8[3], result.u8[2], result.u8[1],
|
||||
result.u8[0];
|
||||
}
|
||||
414
System/Utilities/Image.HC
Normal file
414
System/Utilities/Image.HC
Normal file
@@ -0,0 +1,414 @@
|
||||
Silent(1); // This is needed to suppress "Function should return val" warnings for wrappers to non-HolyC functions
|
||||
|
||||
// class @image
|
||||
// {
|
||||
// CDC* (*FromBuffer)(U8* buffer, I64 len);
|
||||
// CDC* (*Load)(U8* filename);
|
||||
// CDC* (*Write)(U8* filename, CDC* dc);
|
||||
// };
|
||||
//
|
||||
// @image Image;
|
||||
|
||||
class @image_frame
|
||||
{
|
||||
CDC* dc;
|
||||
CSprite* sprite;
|
||||
I64 delay;
|
||||
};
|
||||
|
||||
class @image_collection
|
||||
{
|
||||
@image_frame** frames;
|
||||
I64 count;
|
||||
I64 current;
|
||||
I64 jiffies;
|
||||
I64 index;
|
||||
@image_collection* next;
|
||||
};
|
||||
|
||||
I64 @image_cbgr24_to_4_bit(CBGR24* ptr, Bool dither_probability)
|
||||
{
|
||||
I64 res, k;
|
||||
if (dither_probability) {
|
||||
k = RandU32;
|
||||
if (SqrI64(ptr->r) + SqrI64(ptr->g) + SqrI64(ptr->b) >= 3 * SqrI64(k.u8[0]))
|
||||
res = 8;
|
||||
else
|
||||
res = 0;
|
||||
if (ptr->r >= k.u8[1])
|
||||
res |= RED;
|
||||
if (ptr->g >= k.u8[2])
|
||||
res |= GREEN;
|
||||
if (ptr->b >= k.u8[3])
|
||||
res |= BLUE;
|
||||
} else {
|
||||
if (SqrI64(ptr->r) + SqrI64(ptr->g) + SqrI64(ptr->b) >= SqrI64(0x80)) {
|
||||
res = 8;
|
||||
if (ptr->r >= 0x80)
|
||||
res |= RED;
|
||||
if (ptr->g >= 0x80)
|
||||
res |= GREEN;
|
||||
if (ptr->b >= 0x80)
|
||||
res |= BLUE;
|
||||
} else {
|
||||
res = 0;
|
||||
if (ptr->r >= 0x40)
|
||||
res |= RED;
|
||||
if (ptr->g >= 0x40)
|
||||
res |= GREEN;
|
||||
if (ptr->b >= 0x40)
|
||||
res |= BLUE;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
#define IMAGE_DITHER_NONE 0
|
||||
#define IMAGE_DITHER_NATIVE 1
|
||||
#define IMAGE_DITHER_FLOYDSTEINBERG 2
|
||||
|
||||
U0 @image_render_4bit_floydstein(U8* buffer, I32 width, I32 height)
|
||||
{
|
||||
U64 reg RDI rdi = buffer;
|
||||
U64 reg RSI rsi = width;
|
||||
U64 reg RDX rdx = height;
|
||||
no_warn rdi, rsi, rdx;
|
||||
asm {
|
||||
MOV RAX, RENDER_4BIT_FLOYDSTEIN
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
CDC* @image_render_16color_native(U8* pixels, I32 x, I32 y, Bool dither)
|
||||
{
|
||||
I64 i;
|
||||
I64 j;
|
||||
I64 cnt = 0;
|
||||
CBGR24 cbgr24;
|
||||
CDC* dc = DCNew(x, y);
|
||||
for (i = 0; i < y; i++)
|
||||
for (j = 0; j < x; j++) {
|
||||
cbgr24.r = pixels[cnt];
|
||||
cbgr24.g = pixels[cnt + 1];
|
||||
cbgr24.b = pixels[cnt + 2];
|
||||
if (!pixels[cnt + 3])
|
||||
dc->color = TRANSPARENT;
|
||||
else
|
||||
dc->color = @image_cbgr24_to_4_bit(&cbgr24, dither);
|
||||
GrPlot(dc, j, y - i - 1);
|
||||
cnt += 4;
|
||||
}
|
||||
return dc;
|
||||
}
|
||||
|
||||
CBGR24 @image_palette_std[COLORS_NUM] = {
|
||||
0x000000, 0x0000AA, 0x00AA00, 0x00AAAA,
|
||||
0xAA0000, 0xAA00AA, 0xAA5500, 0xAAAAAA,
|
||||
0x555555, 0x5555FF, 0x55FF55, 0x55FFFF,
|
||||
0xFF5555, 0xFF55FF, 0xFFFF55, 0xFFFFFF
|
||||
};
|
||||
|
||||
CBGR24 @image_dif_rgb(CBGR24 from, CBGR24 to)
|
||||
{
|
||||
CBGR24 dif;
|
||||
dif.r = to.r - from.r;
|
||||
dif.g = to.g - from.g;
|
||||
dif.b = to.b - from.b;
|
||||
return dif;
|
||||
}
|
||||
|
||||
F64 @image_dist_rgb(CBGR24 from, CBGR24 to)
|
||||
{
|
||||
CBGR24 dif = @image_dif_rgb(from, to);
|
||||
F64 dist = dif.r * dif.r + dif.g * dif.g + dif.b * dif.b;
|
||||
return dist;
|
||||
}
|
||||
|
||||
I64 @image_get_4bit_color(CBGR24* cbgr24)
|
||||
{
|
||||
F64 dist = -1, tempDist;
|
||||
I64 i;
|
||||
I64 color = TRANSPARENT;
|
||||
for (i = 0; i < COLORS_NUM; i++) {
|
||||
tempDist = @image_dist_rgb(*cbgr24, @image_palette_std[i]);
|
||||
if (tempDist < dist || dist < 0) {
|
||||
dist = tempDist;
|
||||
color = i;
|
||||
}
|
||||
}
|
||||
return color;
|
||||
}
|
||||
|
||||
CDC* @image_render_16color_floydsteinberg(U8* pixels, I32 width, I32 height)
|
||||
{
|
||||
@image_render_4bit_floydstein(pixels, width, height);
|
||||
I64 i;
|
||||
I64 j;
|
||||
I64 cnt = 0;
|
||||
CBGR24 cbgr24;
|
||||
CDC* dc = DCNew(width, height);
|
||||
for (i = 0; i < height; i++)
|
||||
for (j = 0; j < width; j++) {
|
||||
cbgr24.r = pixels[cnt];
|
||||
cbgr24.g = pixels[cnt + 1];
|
||||
cbgr24.b = pixels[cnt + 2];
|
||||
if (!pixels[cnt + 3])
|
||||
dc->color = TRANSPARENT;
|
||||
else
|
||||
dc->color = @image_get_4bit_color(&cbgr24);
|
||||
GrPlot(dc, j, height - i - 1);
|
||||
cnt += 4;
|
||||
}
|
||||
return dc;
|
||||
}
|
||||
|
||||
CDC* @image_generate_dc_from_pixels(U8* pixels, I32 width, I32 height, Bool dither = IMAGE_DITHER_FLOYDSTEINBERG)
|
||||
{
|
||||
switch (dither) {
|
||||
case IMAGE_DITHER_NONE:
|
||||
case IMAGE_DITHER_NATIVE:
|
||||
return @image_render_16color_native(pixels, width, height, dither);
|
||||
break;
|
||||
case IMAGE_DITHER_FLOYDSTEINBERG:
|
||||
return @image_render_16color_floydsteinberg(pixels, width, height);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
U8* @image_load_gif_from_memory(U8* buffer, I64 len, I64** delays, I64* x, I64* y,
|
||||
I64* z)
|
||||
{
|
||||
U64 reg RDI rdi = buffer;
|
||||
U64 reg RSI rsi = len;
|
||||
U64 reg RDX rdx = delays;
|
||||
U64 reg RCX rcx = x;
|
||||
U64 reg R8 r8 = y;
|
||||
U64 reg R9 r9 = z;
|
||||
no_warn rdi, rsi, rdx, rcx, r8, r9;
|
||||
asm {
|
||||
MOV RAX, IMAGE_LOAD_GIF_FROM_MEMORY
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
U8* @stbi_failure_reason()
|
||||
{
|
||||
asm {
|
||||
MOV RAX, STBI_FAILURE_REASON
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
I32 @stbi_info_from_memory(U8* buffer, I64 len, I64* x, I64* y, I64* comp)
|
||||
{
|
||||
U64 reg RDI rdi = buffer;
|
||||
U64 reg RSI rsi = len;
|
||||
U64 reg RDX rdx = x;
|
||||
U64 reg RCX rcx = y;
|
||||
U64 reg R8 r8 = comp;
|
||||
no_warn rdi, rsi, rdx, rcx, r8;
|
||||
asm {
|
||||
MOV RAX, STBI_INFO_FROM_MEMORY
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
U8* @stbi_load_from_memory(U8* buffer, I64 len, I64* x, I64* y,
|
||||
I64* channels_in_file, I64 desired_channels)
|
||||
{
|
||||
U64 reg RDI rdi = buffer;
|
||||
U64 reg RSI rsi = len;
|
||||
U64 reg RDX rdx = x;
|
||||
U64 reg RCX rcx = y;
|
||||
U64 reg R8 r8 = channels_in_file;
|
||||
U64 reg R9 r9 = desired_channels;
|
||||
no_warn rdi, rsi, rdx, rcx, r8, r9;
|
||||
asm {
|
||||
MOV RAX, STBI_LOAD_FROM_MEMORY
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
U32* @stbi_write_png_to_mem(U32* pixels, I32 stride_bytes, I32 x, I32 y, I32 n, I32* out_len)
|
||||
{
|
||||
U64 reg RDI rdi = pixels;
|
||||
U64 reg RSI rsi = stride_bytes;
|
||||
U64 reg RDX rdx = x;
|
||||
U64 reg RCX rcx = y;
|
||||
U64 reg R8 r8 = n;
|
||||
U64 reg R9 r9 = out_len;
|
||||
no_warn rdi, rsi, rdx, rcx, r8, r9;
|
||||
asm {
|
||||
MOV RAX, STBI_WRITE_PNG_TO_MEM
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
CDC* @image_load(U8* filename)
|
||||
{
|
||||
if (!filename || !FileFind(filename)) {
|
||||
// PrintErr("Image file not found.\n");
|
||||
return NULL;
|
||||
}
|
||||
I64 len;
|
||||
I32 x;
|
||||
I32 y;
|
||||
I32 comp;
|
||||
U8* buffer = FileRead(filename, &len);
|
||||
I32 code = @stbi_info_from_memory(buffer, len, &x, &y, &comp);
|
||||
if (code != 1) {
|
||||
Free(buffer);
|
||||
return NULL;
|
||||
}
|
||||
U8* pixels = @stbi_load_from_memory(buffer, len, &x, &y, &comp, 4);
|
||||
Free(buffer);
|
||||
CDC* dc = @image_generate_dc_from_pixels(pixels, x, y);
|
||||
Free(pixels);
|
||||
return dc;
|
||||
}
|
||||
|
||||
U32 @image_rgba_color_table[16] = {
|
||||
0xff000000, 0xffaa0000, 0xff00aa00, 0xffaaaa00,
|
||||
0xff0000aa, 0xffaa00aa, 0xff0055aa, 0xffaaaaaa,
|
||||
0xff555555, 0xffff5555, 0xff55ff55, 0xffffff55,
|
||||
0xff5555ff, 0xffff55ff, 0xff55ffff, 0xffffffff
|
||||
};
|
||||
|
||||
U32 @image_get_rgba_color(I64 color)
|
||||
{
|
||||
if (color > 15)
|
||||
return 0;
|
||||
return @image_rgba_color_table[color];
|
||||
}
|
||||
|
||||
U32* @image_get_rgba_buffer_from_dc_body(CDC* dc)
|
||||
{
|
||||
if (!dc)
|
||||
return NULL;
|
||||
U32* pixels = CAlloc((dc->width * dc->height) * 4, adam_task);
|
||||
I64 x;
|
||||
I64 y;
|
||||
I64 p = 0;
|
||||
for (y = 0; y < dc->height; y++)
|
||||
for (x = 0; x < dc->width; x++)
|
||||
pixels[p++] = @image_get_rgba_color(GrPeek(dc, x, y));
|
||||
return pixels;
|
||||
}
|
||||
|
||||
U0 @image_write(U8* filename, CDC* dc)
|
||||
{
|
||||
if (!dc) {
|
||||
PrintErr("Device context is NULL.\n");
|
||||
return;
|
||||
}
|
||||
I32 out_len;
|
||||
U32* rgba_buffer = @image_get_rgba_buffer_from_dc_body(dc);
|
||||
if (!rgba_buffer) {
|
||||
PrintErr("RGBA buffer is NULL.\n");
|
||||
return;
|
||||
}
|
||||
U8* png_buffer = @stbi_write_png_to_mem(rgba_buffer, dc->width * 4, dc->width, dc->height, 4, &out_len);
|
||||
if (!png_buffer) {
|
||||
PrintErr("PNG buffer is NULL.\n");
|
||||
Free(rgba_buffer);
|
||||
return;
|
||||
}
|
||||
FileWrite(filename, png_buffer, out_len);
|
||||
Free(rgba_buffer);
|
||||
Free(png_buffer);
|
||||
}
|
||||
|
||||
U32 @image_pixel_flip_rgb_bgr(U32 src)
|
||||
{
|
||||
U32 dst;
|
||||
dst.u8[0] = src.u8[2];
|
||||
dst.u8[1] = src.u8[1];
|
||||
dst.u8[2] = src.u8[0];
|
||||
dst.u8[3] = src.u8[3];
|
||||
return dst;
|
||||
}
|
||||
|
||||
CDC* @image_from_buffer(U8* buffer, I64 len)
|
||||
{
|
||||
I32 x = 0;
|
||||
I32 y = 0;
|
||||
U8* pixels = NULL;
|
||||
CDC* dc = NULL;
|
||||
|
||||
I32 comp;
|
||||
I32 code = @stbi_info_from_memory(buffer, len, &x, &y, &comp);
|
||||
if (code != 1) {
|
||||
return NULL;
|
||||
}
|
||||
pixels = @stbi_load_from_memory(buffer, len, &x, &y, &comp, 4);
|
||||
if (!pixels)
|
||||
PopUpOk(@stbi_failure_reason);
|
||||
dc = @image_generate_dc_from_pixels(pixels, x, y);
|
||||
Free(pixels);
|
||||
return dc;
|
||||
}
|
||||
|
||||
@image_collection* @image_collection_from_buffer(U8* buffer, I64 len)
|
||||
{
|
||||
I64 i;
|
||||
I32* delays;
|
||||
I32 x;
|
||||
I32 y;
|
||||
I32 z;
|
||||
I32 comp;
|
||||
I32 code = @stbi_info_from_memory(buffer, len, &x, &y, &comp);
|
||||
if (code != 1) {
|
||||
return NULL;
|
||||
}
|
||||
U64 pixels = @image_load_gif_from_memory(buffer, len, &delays, &x, &y, &z);
|
||||
if (!pixels)
|
||||
PopUpOk(@stbi_failure_reason);
|
||||
if (!z)
|
||||
return NULL; // no frames?
|
||||
@image_collection* collection = CAlloc(sizeof(@image_collection), adam_task);
|
||||
@image_frame* frame;
|
||||
collection->frames = CAlloc(sizeof(@image_frame*) * z, adam_task);
|
||||
collection->count = z;
|
||||
for (i = 0; i < z; i++) {
|
||||
frame = CAlloc(sizeof(@image_frame), adam_task);
|
||||
frame->dc = @image_generate_dc_from_pixels(pixels, x, y);
|
||||
frame->sprite = DC2Sprite(frame->dc);
|
||||
frame->delay = delays[i];
|
||||
collection->frames[i] = frame;
|
||||
pixels += (x * y) * 4;
|
||||
}
|
||||
return collection;
|
||||
}
|
||||
|
||||
// Image.FromBuffer = &@image_from_buffer;
|
||||
// Image.Load = &@image_load;
|
||||
// Image.Write = &@image_write;
|
||||
|
||||
Silent(0);
|
||||
|
||||
U0 Screenshot(U8* custom_filename = NULL, Bool output_filename_to_focus_task = FALSE)
|
||||
{
|
||||
CDC* dc = DCScrnCapture;
|
||||
U8 filename[256];
|
||||
CDateStruct ds;
|
||||
if (custom_filename)
|
||||
StrCpy(filename, custom_filename);
|
||||
else {
|
||||
Date2Struct(&ds, Now);
|
||||
StrPrint(filename, "C:/Tmp/ScrnShots/%04d-%02d-%02d-%02d-%02d-%02d.png", ds.year, ds.mon, ds.day_of_mon, ds.hour, ds.min, ds.sec);
|
||||
}
|
||||
@image_write(filename, dc);
|
||||
DCDel(dc);
|
||||
if (output_filename_to_focus_task)
|
||||
XTalk(sys_focus_task, filename);
|
||||
};
|
||||
|
||||
U0 @screenshot_hotkey(I64)
|
||||
{
|
||||
Screenshot("C:/Home/Screenshot.png", TRUE);
|
||||
}
|
||||
|
||||
CtrlAltCBSet('S', &@screenshot_hotkey, "", , FALSE);
|
||||
22
System/Utilities/NetRep.HC
Normal file
22
System/Utilities/NetRep.HC
Normal file
@@ -0,0 +1,22 @@
|
||||
U0 NetRep()
|
||||
{
|
||||
NetInfoRequest* req = @net_info_request;
|
||||
"MAC address : %02x:%02x:%02x:%02x:%02x:%02x\n", req->mac_address.u8[5], req->mac_address.u8[4],
|
||||
req->mac_address.u8[3], req->mac_address.u8[2],
|
||||
req->mac_address.u8[1], req->mac_address.u8[0];
|
||||
"IPv4 address : %d.%d.%d.%d\n", req->ipv4_address.u8[3], req->ipv4_address.u8[2],
|
||||
req->ipv4_address.u8[1], req->ipv4_address.u8[0];
|
||||
"IPv4 netmask : %d.%d.%d.%d\n", req->ipv4_netmask.u8[3], req->ipv4_netmask.u8[2],
|
||||
req->ipv4_netmask.u8[1], req->ipv4_netmask.u8[0];
|
||||
"IPv4 network : %d.%d.%d.%d\n", req->ipv4_network.u8[3], req->ipv4_network.u8[2],
|
||||
req->ipv4_network.u8[1], req->ipv4_network.u8[0];
|
||||
"IPv4 gateway : %d.%d.%d.%d\n", req->ipv4_gateway.u8[3], req->ipv4_gateway.u8[2],
|
||||
req->ipv4_gateway.u8[1], req->ipv4_gateway.u8[0];
|
||||
"DNS server (port) : %d.%d.%d.%d (%d)\n", req->dns_server_address.u8[3], req->dns_server_address.u8[2],
|
||||
req->dns_server_address.u8[1], req->dns_server_address.u8[0], req->dns_server_port;
|
||||
"RX bytes : %d\n", req->rx_bytes;
|
||||
"RX frames : %d\n", req->rx_frames;
|
||||
"TX bytes : %d\n", req->tx_bytes;
|
||||
"TX frames : %d\n", req->tx_frames;
|
||||
Free(req);
|
||||
}
|
||||
72
System/Utilities/Ping.HC
Normal file
72
System/Utilities/Ping.HC
Normal file
@@ -0,0 +1,72 @@
|
||||
#define PING_ERR_INVALID_HOST 1
|
||||
#define PING_ERR_HOST_NOT_FOUND 2
|
||||
|
||||
#define PING_PAYLOAD_SIZE 56
|
||||
|
||||
I64 @ping_err(I64 code)
|
||||
{
|
||||
switch (code) {
|
||||
case PING_ERR_INVALID_HOST:
|
||||
"Invalid host specified\n";
|
||||
return 1;
|
||||
break;
|
||||
case PING_ERR_HOST_NOT_FOUND:
|
||||
"Host not found\n";
|
||||
return 2;
|
||||
break;
|
||||
default:
|
||||
"Unspecified error\n";
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
I64 Ping(U8* host, I64 count = 4)
|
||||
{
|
||||
if (!host)
|
||||
return @ping_err(PING_ERR_INVALID_HOST);
|
||||
if (!StrLen(host))
|
||||
return @ping_err(PING_ERR_INVALID_HOST);
|
||||
|
||||
U32 addr = @dns_query(host);
|
||||
if (addr == U32_MAX)
|
||||
return @ping_err(PING_ERR_HOST_NOT_FOUND);
|
||||
|
||||
U16 iden = (RandU16 * SysTimerRead) & 0xFFFF;
|
||||
I64 start_jiffies;
|
||||
U32 reply = NULL;
|
||||
I64 res = 0;
|
||||
U16 seq = 0;
|
||||
I64 loss = 0;
|
||||
|
||||
IcmpRequest* request = CAlloc(sizeof(IcmpRequest), Fs->code_heap);
|
||||
|
||||
"PING %s (%d.%d.%d.%d): %d data bytes\n",
|
||||
host, addr.u8[3], addr.u8[2], addr.u8[1], addr.u8[0], PING_PAYLOAD_SIZE;
|
||||
|
||||
I64 i;
|
||||
for (i = 0; i < count; i++) {
|
||||
start_jiffies = cnts.jiffies;
|
||||
reply = @icmp_echo_request(addr, iden, seq, request, i);
|
||||
if (!reply) {
|
||||
"Request timeout for icmp_seq %d\n", seq;
|
||||
++loss;
|
||||
res = 1;
|
||||
} else {
|
||||
"%d bytes from %d.%d.%d.%d: icmp_seq=%d ttl=%d time=%d ms\n",
|
||||
reply.u16[1], addr.u8[3], addr.u8[2], addr.u8[1], addr.u8[0], seq, reply.u16[0], cnts.jiffies - start_jiffies;
|
||||
}
|
||||
while (cnts.jiffies < start_jiffies + 1000 && i < (count - 1))
|
||||
Sleep(1);
|
||||
++seq;
|
||||
}
|
||||
|
||||
Free(request);
|
||||
|
||||
"--- %d.%d.%d.%d ping statistics ---\n", addr.u8[3], addr.u8[2], addr.u8[1], addr.u8[0];
|
||||
"%d packets transmitted, %d packets received, %0f",
|
||||
seq, seq - loss, (loss * 1.0 / seq * 1.0) * 100;
|
||||
PutChars(37);
|
||||
" packet loss\n";
|
||||
|
||||
return res;
|
||||
}
|
||||
92
System/Utilities/Time.HC
Normal file
92
System/Utilities/Time.HC
Normal file
@@ -0,0 +1,92 @@
|
||||
U0 @time_cmos_update_byte(I64 time_reg, I64 val)
|
||||
{
|
||||
OutU8(0x70, time_reg);
|
||||
OutU8(0x71, val);
|
||||
}
|
||||
|
||||
I64 @time_dec_to_bcd(I64 val)
|
||||
{
|
||||
return (((val / 10) << 4) | (val % 10));
|
||||
}
|
||||
|
||||
U0 @time_update(U8* date_str, I64 mS_delta, I64 hour_offset)
|
||||
{
|
||||
no_warn mS_delta;
|
||||
Bool is_bcd;
|
||||
OutU8(0x70, 0x0B);
|
||||
if (InU8(0x71) & 4)
|
||||
is_bcd = FALSE;
|
||||
else
|
||||
is_bcd = TRUE;
|
||||
|
||||
I64 date_argc;
|
||||
U8** date_argv = String.Split(date_str, ' ', &date_argc);
|
||||
|
||||
I64 month = DefineMatch(date_argv[2], "ST_MONTHS") + 1;
|
||||
I64 day = Str2I64(date_argv[1]);
|
||||
I64 year = Str2I64(date_argv[3] + 2);
|
||||
I64 century = 20;
|
||||
|
||||
date_argv[4][2] = NULL;
|
||||
date_argv[4][5] = NULL;
|
||||
|
||||
I64 hour = Str2I64(date_argv[4]);
|
||||
I64 minute = Str2I64(date_argv[4] + 3);
|
||||
I64 second = Str2I64(date_argv[4] + 6);
|
||||
|
||||
// FIXME: Handle month boundaries, and 12 hour time
|
||||
hour += hour_offset;
|
||||
if (hour < 0) {
|
||||
hour += 24;
|
||||
--day;
|
||||
} else if (hour > 23) {
|
||||
hour -= 24;
|
||||
++day;
|
||||
}
|
||||
|
||||
if (is_bcd) {
|
||||
century = @time_dec_to_bcd(century);
|
||||
year = @time_dec_to_bcd(year);
|
||||
month = @time_dec_to_bcd(month);
|
||||
day = @time_dec_to_bcd(day);
|
||||
hour = @time_dec_to_bcd(hour);
|
||||
minute = @time_dec_to_bcd(minute);
|
||||
second = @time_dec_to_bcd(second);
|
||||
}
|
||||
|
||||
@time_cmos_update_byte(0x32, century);
|
||||
@time_cmos_update_byte(0x09, year);
|
||||
@time_cmos_update_byte(0x08, month);
|
||||
@time_cmos_update_byte(0x07, day);
|
||||
@time_cmos_update_byte(0x04, hour);
|
||||
@time_cmos_update_byte(0x02, minute);
|
||||
@time_cmos_update_byte(0x00, second);
|
||||
}
|
||||
|
||||
I64 @time_tz_offset()
|
||||
{
|
||||
return -4;
|
||||
}
|
||||
|
||||
U0 @time_query(Bool set = FALSE)
|
||||
{
|
||||
U8 buf[1024];
|
||||
@http_url* url = @http_parse_url("http://time.google.com");
|
||||
@http_response* resp = Http.Head(url, &buf);
|
||||
while (resp->state != HTTP_STATE_DONE)
|
||||
Sleep(1);
|
||||
I64 mS_delta = cnts.jiffies;
|
||||
"Set current date and time to %s ", resp->headers->@("Date");
|
||||
if (!set)
|
||||
set = YorN;
|
||||
else
|
||||
"\n";
|
||||
if (set)
|
||||
@time_update(resp->headers->@("Date"), mS_delta, @time_tz_offset);
|
||||
}
|
||||
|
||||
U0 TimeSync()
|
||||
{
|
||||
Sleep(500);
|
||||
@time_query(1);
|
||||
}
|
||||
80
System/Utilities/TrueType.HC
Normal file
80
System/Utilities/TrueType.HC
Normal file
@@ -0,0 +1,80 @@
|
||||
Silent(1); // This is needed to suppress "Function should return val" warnings for wrappers to non-HolyC functions
|
||||
|
||||
class stbtt__buf {
|
||||
U8* data;
|
||||
I32 cursor;
|
||||
I32 size;
|
||||
};
|
||||
|
||||
class stbtt_fontinfo {
|
||||
U8* userdata;
|
||||
U8* data; // pointer to .ttf file
|
||||
I32 fontstart; // offset of start of font
|
||||
I32 numGlyphs; // number of glyphs, needed for range checking
|
||||
I32 loca, head, glyf, hhea, hmtx, kern, gpos, svg; // table locations as offset from start of .ttf
|
||||
I32 index_map; // a cmap mapping for our chosen character encoding
|
||||
I32 indexToLocFormat; // format needed to map from glyph index to glyph
|
||||
|
||||
stbtt__buf cff; // cff font data
|
||||
stbtt__buf charstrings; // the charstring index
|
||||
stbtt__buf gsubrs; // global charstring subroutines index
|
||||
stbtt__buf subrs; // private charstring subroutines index
|
||||
stbtt__buf fontdicts; // array of font dicts
|
||||
stbtt__buf fdselect; // map from glyph to fontdict
|
||||
};
|
||||
|
||||
I32 @stbtt_InitFont(stbtt_fontinfo* info, U8* data, I32 offset)
|
||||
{
|
||||
U64 reg RDI rdi = info;
|
||||
U64 reg RSI rsi = data;
|
||||
U64 reg RDX rdx = offset;
|
||||
no_warn rdi, rsi, rdx;
|
||||
asm {
|
||||
MOV RAX, STBTT_INITFONT
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
U8* @stbtt_RenderText(stbtt_fontinfo* info, I32 b_w, I32 b_h, I32 l_h, I32* word, I32* advance = NULL)
|
||||
{
|
||||
U64 reg RDI rdi = info;
|
||||
U64 reg RSI rsi = b_w;
|
||||
U64 reg RDX rdx = b_h;
|
||||
U64 reg RCX rcx = l_h;
|
||||
U64 reg R8 r8 = word;
|
||||
U64 reg R9 r9 = advance;
|
||||
no_warn rdi, rsi, rdx, rcx, r8, r9;
|
||||
stbtt_pos = 0;
|
||||
asm {
|
||||
MOV RAX, STBTT_RENDERTEXT
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
I32 @stbtt_GetTextWidth(stbtt_fontinfo* info, I32 l_h, I32* word, I32* advance = NULL)
|
||||
{
|
||||
U64 reg RDI rdi = info;
|
||||
U64 reg RSI rsi = l_h;
|
||||
U64 reg RDX rdx = word;
|
||||
U64 reg RCX rcx = advance;
|
||||
no_warn rdi, rsi, rdx, rcx;
|
||||
asm {
|
||||
MOV RAX, STBTT_GETTEXTWIDTH
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
U8* @stbtt_GetFontNameDefault(stbtt_fontinfo* font, I32* length)
|
||||
{
|
||||
U64 reg RDI rdi = font;
|
||||
U64 reg RSI rsi = length;
|
||||
no_warn rdi, rsi;
|
||||
asm {
|
||||
MOV RAX, STBTT_GETFONTNAMEDEFAULT
|
||||
CALL RAX
|
||||
}
|
||||
}
|
||||
|
||||
Silent(0);
|
||||
|
||||
"truetype ";
|
||||
Reference in New Issue
Block a user