int
main(int argc, char *argv[])
{
int ch, i;
args = NULL;
cargs = nargs = 0;
while ((ch = getopt(argc, argv, "cD:EgI:L:o:O:sU:l:")) != -1) {
if (ch == 'l') {
/* Gone too far. Back up and get out. */
if (argv[optind - 1][0] == '-')
optind -= 1;
else
optind -= 2;
break;
} else if (ch == '?')
usage();
}
addarg("/usr/bin/cc");
addarg("-std=iso9899:1999");
addarg("-pedantic");
for (i = 1; i < optind; i++)
addarg(argv[i]);
while (i < argc) {
if (strncmp(argv[i], "-l", 2) == 0) {
if (argv[i][2] != '\0')
addlib(argv[i++] + 2);
else {
if (argv[++i] == NULL)
usage();
addlib(argv[i++]);
}
} else
addarg(argv[i++]);
}
execv("/usr/bin/cc", args);
err(1, "/usr/bin/cc");
}
void
ldobj1(Biobuf *f, char *pkg, int64 len, char *pn)
{
int32 ipc;
Prog *p;
int v, o, r, skip;
Sym *h[NSYM], *s;
uint32 sig;
int ntext;
int32 eof;
char *name, *x;
char src[1024];
Prog *lastp;
lastp = nil;
ntext = 0;
eof = Boffset(f) + len;
src[0] = 0;
newloop:
memset(h, 0, sizeof(h));
version++;
histfrogp = 0;
ipc = pc;
skip = 0;
loop:
if(f->state == Bracteof || Boffset(f) >= eof)
goto eof;
o = Bgetc(f);
if(o == Beof)
goto eof;
o |= Bgetc(f) << 8;
if(o <= AXXX || o >= ALAST) {
if(o < 0)
goto eof;
diag("%s:#%lld: opcode out of range: %#ux", pn, Boffset(f), o);
print(" probably not a .%c file\n", thechar);
errorexit();
}
if(o == ANAME || o == ASIGNAME) {
sig = 0;
if(o == ASIGNAME)
sig = Bget4(f);
v = Bgetc(f); /* type */
o = Bgetc(f); /* sym */
r = 0;
if(v == D_STATIC)
r = version;
name = Brdline(f, '\0');
if(name == nil) {
if(Blinelen(f) > 0) {
fprint(2, "%s: name too long\n", pn);
errorexit();
}
goto eof;
}
x = expandpkg(name, pkg);
s = lookup(x, r);
if(x != name)
free(x);
if(debug['S'] && r == 0)
sig = 1729;
if(sig != 0){
if(s->sig != 0 && s->sig != sig)
diag("incompatible type signatures"
"%ux(%s) and %ux(%s) for %s",
s->sig, s->file, sig, pn, s->name);
s->sig = sig;
s->file = pn;
}
if(debug['W'])
print(" ANAME %s\n", s->name);
if(o < 0 || o >= nelem(h))
mangle(pn);
h[o] = s;
if((v == D_EXTERN || v == D_STATIC) && s->type == 0)
s->type = SXREF;
if(v == D_FILE) {
if(s->type != SFILE) {
histgen++;
s->type = SFILE;
s->value = histgen;
}
if(histfrogp < MAXHIST) {
histfrog[histfrogp] = s;
histfrogp++;
} else
collapsefrog(s);
dwarfaddfrag(s->value, s->name);
}
goto loop;
}
p = mal(sizeof(*p));
p->as = o;
p->line = Bget4(f);
p->back = 2;
p->ft = 0;
p->tt = 0;
zaddr(pn, f, &p->from, h);
fromgotype = adrgotype;
zaddr(pn, f, &p->to, h);
if(debug['W'])
print("%P\n", p);
switch(p->as) {
case AHISTORY:
if(p->to.offset == -1) {
addlib(src, pn);
histfrogp = 0;
goto loop;
}
if(src[0] == '\0')
copyhistfrog(src, sizeof src);
addhist(p->line, D_FILE); /* 'z' */
if(p->to.offset)
addhist(p->to.offset, D_FILE1); /* 'Z' */
histfrogp = 0;
goto loop;
case AEND:
histtoauto();
if(cursym != nil && cursym->text)
cursym->autom = curauto;
curauto = 0;
cursym = nil;
if(Boffset(f) == eof)
return;
goto newloop;
case AGLOBL:
s = p->from.sym;
if(s->type == 0 || s->type == SXREF) {
s->type = SBSS;
s->size = 0;
}
if(s->type != SBSS && !s->dupok) {
diag("%s: redefinition: %s in %s",
pn, s->name, TNAME);
s->type = SBSS;
s->size = 0;
}
if(p->to.offset > s->size)
s->size = p->to.offset;
if(p->from.scale & DUPOK)
s->dupok = 1;
if(p->from.scale & RODATA)
s->type = SRODATA;
goto loop;
case ADATA:
// Assume that AGLOBL comes after ADATA.
// If we've seen an AGLOBL that said this sym was DUPOK,
// ignore any more ADATA we see, which must be
// redefinitions.
s = p->from.sym;
if(s->dupok) {
// if(debug['v'])
// Bprint(&bso, "skipping %s in %s: dupok\n", s->name, pn);
goto loop;
}
if(s->file == nil)
s->file = pn;
else if(s->file != pn) {
diag("multiple initialization for %s: in both %s and %s", s->name, s->file, pn);
errorexit();
}
savedata(s, p, pn);
unmal(p, sizeof *p);
goto loop;
case AGOK:
diag("%s: GOK opcode in %s", pn, TNAME);
pc++;
goto loop;
case ATEXT:
s = p->from.sym;
if(s->text != nil) {
diag("%s: %s: redefinition", pn, s->name);
return;
}
if(ntext++ == 0 && s->type != 0 && s->type != SXREF) {
/* redefinition, so file has probably been seen before */
if(debug['v'])
diag("skipping: %s: redefinition: %s", pn, s->name);
return;
}
if(cursym != nil && cursym->text) {
histtoauto();
cursym->autom = curauto;
curauto = 0;
}
skip = 0;
if(etextp)
etextp->next = s;
else
textp = s;
etextp = s;
s->text = p;
cursym = s;
if(s->type != 0 && s->type != SXREF) {
if(p->from.scale & DUPOK) {
skip = 1;
goto casdef;
}
diag("%s: redefinition: %s\n%P", pn, s->name, p);
}
s->type = STEXT;
s->value = pc;
lastp = p;
p->pc = pc++;
goto loop;
case AFMOVF:
case AFADDF:
case AFSUBF:
case AFSUBRF:
case AFMULF:
case AFDIVF:
case AFDIVRF:
case AFCOMF:
case AFCOMFP:
if(skip)
goto casdef;
if(p->from.type == D_FCONST) {
/* size sb 9 max */
sprint(literal, "$%ux", ieeedtof(&p->from.ieee));
s = lookup(literal, 0);
if(s->type == 0) {
s->type = SDATA;
adduint32(s, ieeedtof(&p->from.ieee));
s->reachable = 0;
}
p->from.type = D_EXTERN;
p->from.sym = s;
p->from.offset = 0;
}
goto casdef;
case AFMOVD:
case AFADDD:
case AFSUBD:
case AFSUBRD:
case AFMULD:
case AFDIVD:
case AFDIVRD:
case AFCOMD:
case AFCOMDP:
if(skip)
goto casdef;
if(p->from.type == D_FCONST) {
/* size sb 18 max */
sprint(literal, "$%ux.%ux",
p->from.ieee.l, p->from.ieee.h);
s = lookup(literal, 0);
if(s->type == 0) {
s->type = SDATA;
adduint32(s, p->from.ieee.l);
adduint32(s, p->from.ieee.h);
s->reachable = 0;
}
p->from.type = D_EXTERN;
p->from.sym = s;
p->from.offset = 0;
}
goto casdef;
casdef:
default:
if(skip)
nopout(p);
p->pc = pc;
pc++;
if(p->to.type == D_BRANCH)
p->to.offset += ipc;
if(lastp == nil) {
if(p->as != ANOP)
diag("unexpected instruction: %P", p);
goto loop;
}
lastp->link = p;
lastp = p;
goto loop;
}
eof:
diag("truncated object file: %s", pn);
}
void
ldobj1(Biobuf *f, char *pkg, int64 len, char *pn)
{
int32 ipc;
Prog *p;
Sym *h[NSYM], *s;
int v, o, r, skip;
uint32 sig;
char *name;
int ntext;
int32 eof;
char src[1024], *x;
Prog *lastp;
lastp = nil;
ntext = 0;
eof = Boffset(f) + len;
src[0] = 0;
newloop:
memset(h, 0, sizeof(h));
version++;
histfrogp = 0;
ipc = pc;
skip = 0;
loop:
if(f->state == Bracteof || Boffset(f) >= eof)
goto eof;
o = BGETC(f);
if(o == Beof)
goto eof;
if(o <= AXXX || o >= ALAST) {
diag("%s:#%lld: opcode out of range: %#ux", pn, Boffset(f), o);
print(" probably not a .5 file\n");
errorexit();
}
if(o == ANAME || o == ASIGNAME) {
sig = 0;
if(o == ASIGNAME)
sig = Bget4(f);
v = BGETC(f); /* type */
o = BGETC(f); /* sym */
r = 0;
if(v == D_STATIC)
r = version;
name = Brdline(f, '\0');
if(name == nil) {
if(Blinelen(f) > 0) {
fprint(2, "%s: name too long\n", pn);
errorexit();
}
goto eof;
}
x = expandpkg(name, pkg);
s = lookup(x, r);
if(x != name)
free(x);
if(sig != 0){
if(s->sig != 0 && s->sig != sig)
diag("incompatible type signatures %ux(%s) and %ux(%s) for %s", s->sig, s->file, sig, pn, s->name);
s->sig = sig;
s->file = pn;
}
if(debug['W'])
print(" ANAME %s\n", s->name);
if(o < 0 || o >= nelem(h)) {
fprint(2, "%s: mangled input file\n", pn);
errorexit();
}
h[o] = s;
if((v == D_EXTERN || v == D_STATIC) && s->type == 0)
s->type = SXREF;
if(v == D_FILE) {
if(s->type != SFILE) {
histgen++;
s->type = SFILE;
s->value = histgen;
}
if(histfrogp < MAXHIST) {
histfrog[histfrogp] = s;
histfrogp++;
} else
collapsefrog(s);
}
goto loop;
}
p = mal(sizeof(Prog));
p->as = o;
p->scond = BGETC(f);
p->reg = BGETC(f);
p->line = Bget4(f);
zaddr(f, &p->from, h);
zaddr(f, &p->to, h);
if(p->as != ATEXT && p->as != AGLOBL && p->reg > NREG)
diag("register out of range %A %d", p->as, p->reg);
p->link = P;
p->cond = P;
if(debug['W'])
print("%P\n", p);
switch(o) {
case AHISTORY:
if(p->to.offset == -1) {
addlib(src, pn);
histfrogp = 0;
goto loop;
}
if(src[0] == '\0')
copyhistfrog(src, sizeof src);
addhist(p->line, D_FILE); /* 'z' */
if(p->to.offset)
addhist(p->to.offset, D_FILE1); /* 'Z' */
histfrogp = 0;
goto loop;
case AEND:
histtoauto();
if(cursym != nil && cursym->text)
cursym->autom = curauto;
curauto = 0;
cursym = nil;
if(Boffset(f) == eof)
return;
goto newloop;
case AGLOBL:
s = p->from.sym;
if(s == S) {
diag("GLOBL must have a name\n%P", p);
errorexit();
}
if(s->type == 0 || s->type == SXREF) {
s->type = SBSS;
s->value = 0;
}
if(s->type != SBSS && s->type != SNOPTRBSS && !s->dupok) {
diag("redefinition: %s\n%P", s->name, p);
s->type = SBSS;
s->value = 0;
}
if(p->to.offset > s->size)
s->size = p->to.offset;
if(p->reg & DUPOK)
s->dupok = 1;
if(p->reg & RODATA)
s->type = SRODATA;
else if(p->reg & NOPTR)
s->type = SNOPTRBSS;
break;
case ADATA:
// Assume that AGLOBL comes after ADATA.
// If we've seen an AGLOBL that said this sym was DUPOK,
// ignore any more ADATA we see, which must be
// redefinitions.
s = p->from.sym;
if(s->dupok) {
// if(debug['v'])
// Bprint(&bso, "skipping %s in %s: dupok\n", s->name, pn);
goto loop;
}
if(s->file == nil)
s->file = pn;
else if(s->file != pn) {
diag("multiple initialization for %s: in both %s and %s", s->name, s->file, pn);
errorexit();
}
savedata(s, p, pn);
unmal(p, sizeof *p);
break;
case AGOK:
diag("unknown opcode\n%P", p);
p->pc = pc;
pc++;
break;
case ATEXT:
if(cursym != nil && cursym->text) {
histtoauto();
cursym->autom = curauto;
curauto = 0;
}
s = p->from.sym;
if(s == S) {
diag("TEXT must have a name\n%P", p);
errorexit();
}
cursym = s;
if(s->type != 0 && s->type != SXREF && (p->reg & DUPOK)) {
skip = 1;
goto casedef;
}
if(ntext++ == 0 && s->type != 0 && s->type != SXREF) {
/* redefinition, so file has probably been seen before */
if(debug['v'])
Bprint(&bso, "skipping: %s: redefinition: %s", pn, s->name);
return;
}
skip = 0;
if(s->type != 0 && s->type != SXREF)
diag("redefinition: %s\n%P", s->name, p);
if(etextp)
etextp->next = s;
else
textp = s;
etextp = s;
p->align = 4;
autosize = (p->to.offset+3L) & ~3L;
p->to.offset = autosize;
autosize += 4;
s->type = STEXT;
s->text = p;
s->value = pc;
lastp = p;
p->pc = pc;
pc++;
break;
case ASUB:
if(p->from.type == D_CONST)
if(p->from.name == D_NONE)
if(p->from.offset < 0) {
p->from.offset = -p->from.offset;
p->as = AADD;
}
goto casedef;
case AADD:
if(p->from.type == D_CONST)
if(p->from.name == D_NONE)
if(p->from.offset < 0) {
p->from.offset = -p->from.offset;
p->as = ASUB;
}
goto casedef;
case AMOVWD:
case AMOVWF:
case AMOVDW:
case AMOVFW:
case AMOVFD:
case AMOVDF:
// case AMOVF:
// case AMOVD:
case ACMPF:
case ACMPD:
case AADDF:
case AADDD:
case ASUBF:
case ASUBD:
case AMULF:
case AMULD:
case ADIVF:
case ADIVD:
goto casedef;
case AMOVF:
if(skip)
goto casedef;
if(p->from.type == D_FCONST && chipfloat(&p->from.ieee) < 0 &&
(chipzero(&p->from.ieee) < 0 || (p->scond & C_SCOND) != C_SCOND_NONE)) {
/* size sb 9 max */
sprint(literal, "$%ux", ieeedtof(&p->from.ieee));
s = lookup(literal, 0);
if(s->type == 0) {
s->type = SBSS;
adduint32(s, ieeedtof(&p->from.ieee));
s->reachable = 0;
}
p->from.type = D_OREG;
p->from.sym = s;
p->from.name = D_EXTERN;
p->from.offset = 0;
}
goto casedef;
case AMOVD:
if(skip)
goto casedef;
if(p->from.type == D_FCONST && chipfloat(&p->from.ieee) < 0 &&
(chipzero(&p->from.ieee) < 0 || (p->scond & C_SCOND) != C_SCOND_NONE)) {
/* size sb 18 max */
sprint(literal, "$%ux.%ux",
p->from.ieee.l, p->from.ieee.h);
s = lookup(literal, 0);
if(s->type == 0) {
s->type = SBSS;
adduint32(s, p->from.ieee.l);
adduint32(s, p->from.ieee.h);
s->reachable = 0;
}
p->from.type = D_OREG;
p->from.sym = s;
p->from.name = D_EXTERN;
p->from.offset = 0;
}
goto casedef;
default:
casedef:
if(skip)
nopout(p);
p->pc = pc;
pc++;
if(p->to.type == D_BRANCH)
p->to.offset += ipc;
if(lastp == nil) {
if(p->as != ANOP)
diag("unexpected instruction: %P", p);
break;
}
lastp->link = p;
lastp = p;
break;
}
goto loop;
eof:
diag("truncated object file: %s", pn);
}
/* libcall(const libname[], const funcname[], const typestring[], ...)
*
* Loads the DLL or shared library if not yet loaded (the name comparison is
* case sensitive).
*
* typestring format:
* Whitespace is permitted between the types, but not inside the type
* specification. The string "ii[4]&u16s" is equivalent to "i i[4] &u16 s",
* but the latter is easier on the eye.
*
* types:
* i = signed integer, 16-bit in Windows 3.x, else 32-bit in Win32 and Linux
* u = unsigned integer, 16-bit in Windows 3.x, else 32-bit in Win32 and Linux
* f = IEEE floating point, 32-bit
* p = packed string
* s = unpacked string
* The difference between packed and unpacked strings is only relevant when
* the parameter is passed by reference (see below).
*
* pass-by-value and pass-by-reference:
* By default, parameters are passed by value. To pass a parameter by
* reference, prefix the type letter with an "&":
* &i = signed integer passed by reference
* i = signed integer passed by value
* Same for '&u' versus 'u' and '&f' versus 'f'.
*
* Arrays are passed by "copy & copy-back". That is, libcall() allocates a
* block of dynamic memory to copy the array into. On return from the foreign
* function, libcall() copies the array back to the abstract machine. The
* net effect is similar to pass by reference, but the foreign function does
* not work in the AMX stack directly. During the copy and the copy-back
* operations, libcall() may also transform the array elements, for example
* between 16-bit and 32-bit elements. This is done because Pawn only
* supports a single cell size, which may not fit the required integer size
* of the foreign function.
*
* See "element ranges" for the syntax of passing an array.
*
* Strings may either be passed by copy, or by "copy & copy-back". When the
* string is an output parameter (for the foreign function), the size of the
* array that will hold the return string must be indicated between square
* brackets behind the type letter (see "element ranges"). When the string
* is "input only", this is not needed --libcall() will determine the length
* of the input string itself.
*
* The tokens 'p' and 's' are equivalent, but 'p[10]' and 's[10]' are not
* equivalent: the latter syntaxes determine whether the output from the
* foreign function will be stored as a packed or an unpacked string.
*
* element sizes:
* Add an integer behind the type letter; for example, 'i16' refers to a
* 16-bit signed integer. Note that the value behind the type letter must
* be either 8, 16 or 32.
*
* You should only use element size specifiers on the 'i' and 'u' types. That
* is, do not use these specifiers on 'f', 's' and 'p'.
*
* element ranges:
* For passing arrays, the size of the array may be given behind the type
* letter and optional element size. The token 'u[4]' indicates an array of
* four unsigned integers, which are typically 32-bit. The token 'i16[8]'
* is an array of 8 signed 16-bit integers. Arrays are always passed by
* "copy & copy-back"
*
* When compiled as Unicode, this library converts all strings to Unicode
* strings.
*
* The calling convention for the foreign functions is assumed:
* - "__stdcall" for Win32,
* - "far pascal" for Win16
* - and the GCC default for Unix/Linux (_cdecl)
*
* C++ name mangling of the called function is not handled (there is no standard
* convention for name mangling, so there is no portable way to convert C++
* function names to mangled names). Win32 name mangling (used by default by
* Microsoft compilers on functions declared as __stdcall) is also not handled.
*
* Returns the value of the called function.
*/
static cell AMX_NATIVE_CALL n_libcall(AMX *amx, const cell *params)
{
const TCHAR *libname, *funcname, *typestring;
MODLIST *item;
int paramidx, typeidx, idx;
PARAM ps[MAXPARAMS];
cell *cptr,result;
LIBFUNC LibFunc;
amx_StrParam(amx, params[1], libname);
item = findlib(&ModRoot, amx, libname);
if (item == NULL)
item = addlib(&ModRoot, amx, libname);
if (item == NULL) {
amx_RaiseError(amx, AMX_ERR_NATIVE);
return 0;
} /* if */
/* library is loaded, get the function */
amx_StrParam(amx, params[2], funcname);
LibFunc=(LIBFUNC)SearchProcAddress(item->inst, funcname);
if (LibFunc==NULL) {
amx_RaiseError(amx, AMX_ERR_NATIVE);
return 0;
} /* if */
#if defined HAVE_DYNCALL_H
/* (re-)initialize the dyncall library */
if (dcVM==NULL) {
dcVM=dcNewCallVM(4096);
dcMode(dcVM,DC_CALL_C_X86_WIN32_STD);
} /* if */
dcReset(dcVM);
#endif
/* decode the parameters */
paramidx=typeidx=0;
amx_StrParam(amx, params[3], typestring);
while (paramidx < MAXPARAMS && typestring[typeidx]!=__T('\0')) {
/* skip white space */
while (typestring[typeidx]!=__T('\0') && typestring[typeidx]<=__T(' '))
typeidx++;
if (typestring[typeidx]==__T('\0'))
break;
/* save "pass-by-reference" token */
ps[paramidx].type=0;
if (typestring[typeidx]==__T('&')) {
ps[paramidx].type=BYREF;
typeidx++;
} /* if */
/* store type character */
ps[paramidx].type |= (unsigned char)typestring[typeidx];
typeidx++;
/* set default size, then check for an explicit size */
#if defined __WIN32__ || defined _WIN32 || defined WIN32
ps[paramidx].size=32;
#elif defined _Windows
ps[paramidx].size=16;
#endif
if (_istdigit(typestring[typeidx])) {
ps[paramidx].size=(unsigned char)_tcstol(&typestring[typeidx],NULL,10);
while (_istdigit(typestring[typeidx]))
typeidx++;
} /* if */
/* set default range, then check for an explicit range */
ps[paramidx].range=1;
if (typestring[typeidx]=='[') {
ps[paramidx].range=_tcstol(&typestring[typeidx+1],NULL,10);
while (typestring[typeidx]!=']' && typestring[typeidx]!='\0')
typeidx++;
ps[paramidx].type |= BYREF; /* arrays are always passed by reference */
typeidx++; /* skip closing ']' too */
} /* if */
/* get pointer to parameter */
cptr=amx_Address(amx,params[paramidx+4]);
switch (ps[paramidx].type) {
case 'i': /* signed integer */
case 'u': /* unsigned integer */
case 'f': /* floating point */
assert(ps[paramidx].range==1);
ps[paramidx].v.val=(int)*cptr;
break;
case 'i' | BYREF:
case 'u' | BYREF:
case 'f' | BYREF:
ps[paramidx].v.ptr=cptr;
if (ps[paramidx].range>1) {
/* convert array and pass by address */
ps[paramidx].v.ptr = fillarray(amx, &ps[paramidx], cptr);
} /* if */
break;
case 'p':
case 's':
case 'p' | BYREF:
case 's' | BYREF:
if (ps[paramidx].type=='s' || ps[paramidx].type=='p') {
int len;
/* get length of input string */
amx_StrLen(cptr,&len);
len++; /* include '\0' */
/* check max. size */
if (len<ps[paramidx].range)
len=ps[paramidx].range;
ps[paramidx].range=len;
} /* if */
ps[paramidx].v.ptr=malloc(ps[paramidx].range*sizeof(TCHAR));
if (ps[paramidx].v.ptr==NULL)
return amx_RaiseError(amx, AMX_ERR_NATIVE);
amx_GetString((char *)ps[paramidx].v.ptr,cptr,sizeof(TCHAR)>1,UNLIMITED);
break;
default:
/* invalid parameter type */
return amx_RaiseError(amx, AMX_ERR_NATIVE);
} /* switch */
paramidx++;
} /* while */
if ((params[0]/sizeof(cell)) - 3 != (size_t)paramidx)
return amx_RaiseError(amx, AMX_ERR_NATIVE); /* format string does not match number of parameters */
#if defined HAVE_DYNCALL_H
for (idx = 0; idx < paramidx; idx++) {
if ((ps[idx].type=='i' || ps[idx].type=='u' || ps[idx].type=='f') && ps[idx].range==1) {
switch (ps[idx].size) {
case 8:
dcArgChar(dcVM,(unsigned char)(ps[idx].v.val & 0xff));
break;
case 16:
dcArgShort(dcVM,(unsigned short)(ps[idx].v.val & 0xffff));
break;
default:
dcArgLong(dcVM,ps[idx].v.val);
} /* switch */
} else {
dcArgPointer(dcVM,ps[idx].v.ptr);
} /* if */
} /* for */
result=(cell)dcCallPointer(dcVM,(void*)LibFunc);
#else /* HAVE_DYNCALL_H */
/* push the parameters to the stack (left-to-right in 16-bit; right-to-left
* in 32-bit)
*/
#if defined __WIN32__ || defined _WIN32 || defined WIN32
for (idx=paramidx-1; idx>=0; idx--) {
#else
for (idx=0; idx<paramidx; idx++) {
#endif
if ((ps[idx].type=='i' || ps[idx].type=='u' || ps[idx].type=='f') && ps[idx].range==1) {
switch (ps[idx].size) {
case 8:
push((unsigned char)(ps[idx].v.val & 0xff));
break;
case 16:
push((unsigned short)(ps[idx].v.val & 0xffff));
break;
default:
push(ps[idx].v.val);
} /* switch */
} else {
push(ps[idx].v.ptr);
} /* if */
} /* for */
/* call the function; all parameters are already pushed to the stack (the
* function should remove the parameters from the stack)
*/
result=LibFunc();
#endif /* HAVE_DYNCALL_H */
/* store return values and free allocated memory */
for (idx=0; idx<paramidx; idx++) {
switch (ps[idx].type) {
case 'p':
case 's':
free(ps[idx].v.ptr);
break;
case 'p' | BYREF:
case 's' | BYREF:
cptr=amx_Address(amx,params[idx+4]);
amx_SetString(cptr,(char *)ps[idx].v.ptr,ps[idx].type==('p'|BYREF),sizeof(TCHAR)>1,UNLIMITED);
free(ps[idx].v.ptr);
break;
case 'i':
case 'u':
case 'f':
assert(ps[idx].range==1);
break;
case 'i' | BYREF:
case 'u' | BYREF:
case 'f' | BYREF:
cptr=amx_Address(amx,params[idx+4]);
if (ps[idx].range==1) {
/* modify directly in the AMX (no memory block was allocated */
switch (ps[idx].size) {
case 8:
*cptr= (ps[idx].type==('i' | BYREF)) ? (long)((signed char)*cptr) : (*cptr & 0xff);
break;
case 16:
*cptr= (ps[idx].type==('i' | BYREF)) ? (long)((short)*cptr) : (*cptr & 0xffff);
break;
} /* switch */
} else {
int i;
for (i=0; i<ps[idx].range; i++) {
switch (ps[idx].size) {
case 8:
*cptr= (ps[idx].type==('i' | BYREF)) ? ((signed char*)ps[idx].v.ptr)[i] : ((unsigned char*)ps[idx].v.ptr)[i];
break;
case 16:
*cptr= (ps[idx].type==('i' | BYREF)) ? ((short*)ps[idx].v.ptr)[i] : ((unsigned short*)ps[idx].v.ptr)[i];
break;
default:
*cptr= (ps[idx].type==('i' | BYREF)) ? ((long*)ps[idx].v.ptr)[i] : ((unsigned long*)ps[idx].v.ptr)[i];
} /* switch */
} /* for */
free((char *)ps[idx].v.ptr);
} /* if */
break;
default:
assert(0);
} /* switch */
} /* for */
return result;
}
/* bool: libfree(const libname[]="")
* When the name is an empty string, this function frees all libraries (for this
* abstract machine). The name comparison is case sensitive.
* Returns true if one or more libraries were freed.
*/
static cell AMX_NATIVE_CALL n_libfree(AMX *amx, const cell *params)
{
const TCHAR *libname;
amx_StrParam(amx,params[1],libname);
return freelib(&ModRoot,amx,libname) > 0;
}
#else /* HAVE_DYNCALL_H || WIN32_FFI */
static cell AMX_NATIVE_CALL n_libcall(AMX *amx, const cell *params)
{
(void)amx;
(void)params;
return 0;
}
int
main(int argc, char *argv[])
{
char exec_path[PATH_MAX];
char link_path[PATH_MAX];
uint32_t exec_path_size = sizeof(exec_path);
char *compiler_path = exec_path;
char *lastslash;
int link = 1;
int inputs = 0;
int verbose = 0;
int m_32_64_set = 0;
/* Find the path to this executable. */
if (_NSGetExecutablePath(exec_path, &exec_path_size))
memcpy(exec_path, "/usr/bin/c99", sizeof("/usr/bin/c99"));
if (realpath(exec_path, link_path))
compiler_path = link_path;
/* Chop off c99 and replace it with clang. */
lastslash = strrchr(compiler_path, '/');
if (!lastslash)
err(EX_OSERR, "unexpected path name: %s", compiler_path);
strcpy(lastslash+1, "clang");
addarg(compiler_path);
addarg("-std=iso9899:1999");
addarg("-pedantic");
addarg("-Wextra-tokens"); /* Radar 4205857 */
addarg("-Wno-error=return-type"); /* Radar 13535926 */
addarg("-Wstatic-in-inline"); /* Radar 12866627 */
addarg("-Wignored-qualifiers"); /* Radar 13535742 */
addarg("-fmath-errno"); /* Radar 4011622 */
addarg("-fno-blocks"); /* Radar 13118788 */
for (;;)
{
int ch = getopt(argc, argv, "cD:EgI:L:o:O:sU:W:l:");
if (optind >= argc && ch == -1)
break;
switch (ch)
{
case 'c':
addarg ("-c");
link = 0;
break;
case 'D':
add_def (optarg);
break;
case 'E':
addarg ("-E");
link = 0;
break;
case 'g':
addarg ("-g");
break;
case 'I':
combine_and_addarg ("-I", optarg);
break;
case 'L':
combine_and_addarg ("-L", optarg);
break;
case 'o':
addarg ("-o");
addarg (optarg);
break;
case 'O':
combine_and_addarg ("-O", optarg);
break;
case 's':
addarg ("-s");
break;
case 'U':
record_undef (optarg);
combine_and_addarg ("-U", optarg);
break;
case 'W':
if (strcmp (optarg, "32") == 0) {
addarg ("-m32");
m_32_64_set = 1;
} else if (strcmp (optarg, "64") == 0) {
addarg ("-m64");
m_32_64_set = 1;
} else if (strcmp (optarg, "verbose") == 0)
{
addarg ("-v");
verbose = 1;
}
else
errx(EX_USAGE, "invalid argument `%s' to -W", optarg);
break;
case 'l':
addlib (optarg);
break;
case -1:
if (strcmp (argv[optind-1], "--") == 0)
{
while (optind < argc)
{
if (argv[optind][0] == '-')
combine_and_addarg ("./", argv[optind]);
else
addarg (argv[optind]);
inputs++;
optind++;
}
}
else
{
addarg (argv[optind++]);
inputs++;
}
break;
case '?':
usage ();
break;
}
}
/* If the user didn't set the width, set it from the current
host architecture. */
#ifdef __LP64__
if (!m_32_64_set)
addarg("-m64");
#else
if (!m_32_64_set)
addarg("-m32");
#endif
if (link && inputs > 0) {
addarg("-liconv");
}
if (verbose)
{
int i;
for (i = 0; args[i]; i++)
printf ("\"%s\" ", args[i]);
putchar ('\n');
}
/* Exec clang. */
execv(compiler_path, args);
err(EX_OSERR, "failed to exec compiler %s", compiler_path);
}
int
main(int argc, char *argv[])
{
int ch, i;
args = NULL;
cargs = nargs = 0;
while ((ch = getopt(argc, argv, "cD:EgI:L:o:O:sU:l:")) != -1) {
if (ch == 'l') {
/* Gone too far. Back up and get out. */
if (argv[optind - 1][0] == '-')
optind -= 1;
else
optind -= 2;
break;
} else if (ch == '?')
usage();
}
addarg("cc");
addarg("-std=iso9899:1990");
addarg("-pedantic");
addarg("-m32");
for (i = 1; i < optind; i++) {
/* "--" indicates end of options. Radar 3761967. */
if (strcmp (argv[i], "--") == 0)
dash_dash_seen = 1;
/* White space is OK between -O and 1 or 2. Radar 3762315. */
else if (strcmp (argv[i], "-O") == 0) {
if (i+1 < argc) {
if (strcmp (argv[i+1], "1") == 0 || strcmp (argv[i+1], "0") == 0) {
combine_and_addarg(argv[i], argv[i+1]);
i++;
} else
addarg(argv[i]);
}
} else if (strcmp (argv[i], "-U") == 0) {
/* Record undefined macros. */
record_undef (argv[i+1]);
addarg(argv[i]);
addarg(argv[i+1]);
i++;
} else if (strncmp (argv[i], "-U", 2) == 0) {
/* Record undefined macros. */
record_undef (argv[i]+2);
addarg(argv[i]);
} else if (strcmp (argv[i], "-L") == 0 && i+1 < argc) {
combine_and_addarg(argv[i], argv[i+1]);
i++;
} else if (strcmp (argv[i], "-D") == 0) {
add_def (argv[i+1]);
i++;
} else if (strncmp (argv[i], "-D", 2) == 0)
add_def (argv[i]+2);
else
addarg(argv[i]);
}
while (i < argc) {
if (strncmp(argv[i], "-l", 2) == 0) {
if (argv[i][2] != '\0')
addlib(argv[i++] + 2);
else {
if (argv[++i] == NULL)
usage();
addlib(argv[i++]);
}
}
else if (strcmp (argv[i], "-L") == 0 && i+1 < argc) {
combine_and_addarg(argv[i], argv[i+1]);
i+=2;
}
else if (strcmp (argv[i], "--") == 0) {
dash_dash_seen = 1;
} else
addarg(argv[i++]);
}
execv("/usr/bin/cc", args);
err(1, "/usr/bin/cc");
}