195 lines
1.9 KiB
Plaintext
195 lines
1.9 KiB
Plaintext
int
|
|
myaccess(char *f)
|
|
{
|
|
return access(f, AEXIST);
|
|
}
|
|
|
|
int
|
|
mycreat(char *n, int p)
|
|
{
|
|
|
|
return create(n, 1, p);
|
|
}
|
|
|
|
int
|
|
mywait(int *s)
|
|
{
|
|
int p;
|
|
Waitmsg *w;
|
|
|
|
if((w = wait()) == nil)
|
|
return -1;
|
|
else{
|
|
p = w->pid;
|
|
*s = 0;
|
|
if(w->msg[0])
|
|
*s = 1;
|
|
free(w);
|
|
return p;
|
|
}
|
|
}
|
|
|
|
int
|
|
mydup(int f1, int f2)
|
|
{
|
|
return dup(f1,f2);
|
|
}
|
|
|
|
int
|
|
mypipe(int *fd)
|
|
{
|
|
return pipe(fd);
|
|
}
|
|
|
|
int
|
|
systemtype(int sys)
|
|
{
|
|
return sys & Plan9;
|
|
}
|
|
|
|
int
|
|
pathchar(void)
|
|
{
|
|
return '/';
|
|
}
|
|
|
|
char*
|
|
mygetwd(char *path, int len)
|
|
{
|
|
return getwd(path, len);
|
|
}
|
|
|
|
int
|
|
myexec(char *path, char *argv[])
|
|
{
|
|
return exec(path, argv);
|
|
}
|
|
|
|
int
|
|
myfork(void)
|
|
{
|
|
return fork();
|
|
}
|
|
|
|
|
|
/*
|
|
* real allocs
|
|
*/
|
|
|
|
extern char end[];
|
|
|
|
static char* hunk = end;
|
|
static long nhunk;
|
|
static uintptr thunk;
|
|
|
|
static void
|
|
gethunk(void)
|
|
{
|
|
long nh;
|
|
|
|
if(thunk < NHUNK)
|
|
nh = NHUNK;
|
|
else if(thunk < 1000*NHUNK)
|
|
nh = thunk;
|
|
else
|
|
nh = 1000*NHUNK;
|
|
|
|
if(nhunk < 0)
|
|
nhunk = 0;
|
|
nhunk += nh;
|
|
thunk += nh;
|
|
if(brk(hunk+nhunk) < 0)
|
|
sysfatal("out of memory");
|
|
}
|
|
|
|
void*
|
|
alloc(long n)
|
|
{
|
|
void *p;
|
|
|
|
while((uintptr)hunk & 7) {
|
|
hunk++;
|
|
nhunk--;
|
|
}
|
|
while(nhunk < n)
|
|
gethunk();
|
|
p = hunk;
|
|
nhunk -= n;
|
|
hunk += n;
|
|
return p;
|
|
}
|
|
|
|
void*
|
|
allocn(void *p, long on, long n)
|
|
{
|
|
void *q;
|
|
|
|
q = (uchar*)p + on;
|
|
if(q != hunk || nhunk < n) {
|
|
while(nhunk < on+n)
|
|
gethunk();
|
|
memmove(hunk, p, on);
|
|
p = hunk;
|
|
hunk += on;
|
|
nhunk -= on;
|
|
}
|
|
hunk += n;
|
|
nhunk -= n;
|
|
return p;
|
|
}
|
|
|
|
/*
|
|
* fake mallocs
|
|
*/
|
|
void*
|
|
malloc(ulong n)
|
|
{
|
|
return alloc(n);
|
|
}
|
|
|
|
void*
|
|
calloc(ulong m, ulong n)
|
|
{
|
|
return alloc(m*n);
|
|
}
|
|
|
|
void*
|
|
realloc(void *o, ulong n)
|
|
{
|
|
ulong m;
|
|
void *a;
|
|
|
|
if(n == 0)
|
|
return nil;
|
|
if(o == nil)
|
|
return alloc(n);
|
|
a = alloc(n);
|
|
m = (char*)a - (char*)o;
|
|
if(m < n)
|
|
n = m;
|
|
memmove(a, o, n);
|
|
return a;
|
|
}
|
|
|
|
void
|
|
free(void*)
|
|
{
|
|
}
|
|
|
|
/* needed when profiling */
|
|
void*
|
|
mallocz(ulong size, int)
|
|
{
|
|
return alloc(size);
|
|
}
|
|
|
|
void
|
|
setmalloctag(void*, uintptr)
|
|
{
|
|
}
|
|
|
|
void
|
|
setrealloctag(void*, uintptr)
|
|
{
|
|
}
|