static int
csb_enable(struct TestContext *ctx)
{
struct nmreq_option saveopt;
struct nmreq_opt_csb opt;
struct nmreq_header hdr;
int ret;
ret = push_csb_option(ctx, &opt);
if (ret != 0) {
return ret;
}
saveopt = opt.nro_opt;
saveopt.nro_status = 0;
nmreq_hdr_init(&hdr, ctx->ifname_ext);
hdr.nr_reqtype = NETMAP_REQ_CSB_ENABLE;
hdr.nr_options = (uintptr_t)ctx->nr_opt;
hdr.nr_body = (uintptr_t)NULL;
printf("Testing NETMAP_REQ_CSB_ENABLE on '%s'\n", ctx->ifname_ext);
ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
if (ret != 0) {
perror("ioctl(/dev/netmap, NIOCCTRL, CSB_ENABLE)");
return ret;
}
ret = checkoption(&opt.nro_opt, &saveopt);
clear_options(ctx);
return ret;
}
static int
pop_extmem_option(struct TestContext *ctx, struct nmreq_opt_extmem *exp)
{
struct nmreq_opt_extmem *e;
int ret;
e = (struct nmreq_opt_extmem *)(uintptr_t)ctx->nr_opt;
ctx->nr_opt = (struct nmreq_option *)(uintptr_t)ctx->nr_opt->nro_next;
if ((ret = checkoption(&e->nro_opt, &exp->nro_opt))) {
return ret;
}
if (e->nro_usrptr != exp->nro_usrptr) {
printf("usrptr %" PRIu64 " expected %" PRIu64 "\n",
e->nro_usrptr, exp->nro_usrptr);
return -1;
}
if (e->nro_info.nr_memsize != exp->nro_info.nr_memsize) {
printf("memsize %" PRIu64 " expected %" PRIu64 "\n",
e->nro_info.nr_memsize, exp->nro_info.nr_memsize);
return -1;
}
if ((ret = munmap((void *)(uintptr_t)e->nro_usrptr,
e->nro_info.nr_memsize)))
return ret;
return 0;
}
static int InitContextProfile(lua_State *L)
{
int i, n, rc;
int opt, val, arg = 1;
if(!lua_isnoneornil(L, 1)) /* set */
{
val = 0;
while(!lua_isnoneornil(L, arg))
{
opt = checkoption(L, arg, NULL, ProfileStrings);
val |= ProfileCodes[opt];
arg++;
}
glutInitContextProfile(val);
}
/* get */
n = sizeof(ProfileCodes)/sizeof(ProfileCodes[0]);
rc = 0;
val = glutGet(GLUT_INIT_PROFILE);
for(i = 0; i <n; i ++)
{
if(val & ProfileCodes[i])
{ lua_pushstring(L, ProfileStrings[i]); rc++; }
}
return rc;
}
GLbitfield bitfieldCheck(lua_State *L, int arg, int mandatory, bitfield_t *b)
/* Assuming all args from arg to end are bitfield strings */
/* returns the OR of the corresponding codes */
{
int first = arg;
GLbitfield val = 0;
while(!lua_isnoneornil(L, arg))
val |= b->codes[checkoption(L, arg++, NULL, b->strings)];
if(mandatory && (arg==first))
return luaL_argerror(L, first, "string expected");
return val;
}
static int
sync_kloop_eventfds(struct TestContext *ctx)
{
struct nmreq_opt_sync_kloop_eventfds *evopt = NULL;
struct nmreq_opt_sync_kloop_mode modeopt;
struct nmreq_option evsave;
int num_entries;
size_t opt_size;
int ret, i;
memset(&modeopt, 0, sizeof(modeopt));
modeopt.nro_opt.nro_reqtype = NETMAP_REQ_OPT_SYNC_KLOOP_MODE;
modeopt.mode = ctx->sync_kloop_mode;
push_option(&modeopt.nro_opt, ctx);
num_entries = num_registered_rings(ctx);
opt_size = sizeof(*evopt) + num_entries * sizeof(evopt->eventfds[0]);
evopt = calloc(1, opt_size);
evopt->nro_opt.nro_next = 0;
evopt->nro_opt.nro_reqtype = NETMAP_REQ_OPT_SYNC_KLOOP_EVENTFDS;
evopt->nro_opt.nro_status = 0;
evopt->nro_opt.nro_size = opt_size;
for (i = 0; i < num_entries; i++) {
int efd = eventfd(0, 0);
evopt->eventfds[i].ioeventfd = efd;
efd = eventfd(0, 0);
evopt->eventfds[i].irqfd = efd;
}
push_option(&evopt->nro_opt, ctx);
evsave = evopt->nro_opt;
ret = sync_kloop_start_stop(ctx);
if (ret != 0) {
free(evopt);
clear_options(ctx);
return ret;
}
#ifdef __linux__
evsave.nro_status = 0;
#else /* !__linux__ */
evsave.nro_status = EOPNOTSUPP;
#endif /* !__linux__ */
ret = checkoption(&evopt->nro_opt, &evsave);
free(evopt);
clear_options(ctx);
return ret;
}
static int os_date (LuaThread *L) {
THREAD_CHECK(L);
const char *s = luaL_optstring(L, 1, "%c");
time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));
struct tm tmr, *stm;
if (*s == '!') { /* UTC? */
stm = l_gmtime(&t, &tmr);
s++; /* skip `!' */
}
else
stm = l_localtime(&t, &tmr);
if (stm == NULL) {
/* invalid date? */
L->stack_.push(LuaValue::Nil());
}
else if (strcmp(s, "*t") == 0) {
lua_createtable(L, 0, 9); /* 9 = number of fields */
setfield(L, "sec", stm->tm_sec);
setfield(L, "min", stm->tm_min);
setfield(L, "hour", stm->tm_hour);
setfield(L, "day", stm->tm_mday);
setfield(L, "month", stm->tm_mon+1);
setfield(L, "year", stm->tm_year+1900);
setfield(L, "wday", stm->tm_wday+1);
setfield(L, "yday", stm->tm_yday+1);
setboolfield(L, "isdst", stm->tm_isdst);
}
else {
char cc[4];
luaL_Buffer b;
cc[0] = '%';
luaL_buffinit(L, &b);
while (*s) {
if (*s != '%') /* no conversion specifier? */
luaL_addchar(&b, *s++);
else {
size_t reslen;
char buff[200]; /* should be big enough for any conversion result */
s = checkoption(L, s + 1, cc);
reslen = strftime(buff, sizeof(buff), cc, stm);
luaL_addlstring(&b, buff, reslen);
}
}
luaL_pushresult(&b);
}
return 1;
}
static int Cursor(lua_State *L)
{
int opt, i, n, val;
if(!lua_isnoneornil(L, 1)) /* set */
{
opt = checkoption(L, 1, NULL, CursorStrings);
glutSetCursor(CursorCodes[opt]);
}
n = sizeof(CursorCodes)/sizeof(CursorCodes[0]);
val = glutGet(GLUT_WINDOW_CURSOR);
for(i = 0; i <n; i ++)
{
if(val == CursorCodes[i])
{ lua_pushstring(L, CursorStrings[i]); return 1; }
}
lua_pushstring(L, "????");
return 1;
}
static int os_date (LUA_State *L) {
const char *s = LUAL_optstring(L, 1, "%c");
time_t t = LUAL_opt(L, (time_t)LUAL_checknumber, 2, time(NULL));
struct tm tmr, *stm;
if (*s == '!') { /* UTC? */
stm = l_gmtime(&t, &tmr);
s++; /* skip `!' */
}
else
stm = l_localtime(&t, &tmr);
if (stm == NULL) /* invalid date? */
LUA_pushnil(L);
else if (strcmp(s, "*t") == 0) {
LUA_createtable(L, 0, 9); /* 9 = number of fields */
setfield(L, "SEC", stm->tm_sec);
setfield(L, "MIN", stm->tm_min);
setfield(L, "HOUR", stm->tm_hour);
setfield(L, "DAY", stm->tm_mday);
setfield(L, "MONTH", stm->tm_mon+1);
setfield(L, "YEAR", stm->tm_year+1900);
setfield(L, "WDAY", stm->tm_wday+1);
setfield(L, "YDAY", stm->tm_yday+1);
setboolfield(L, "ISDST", stm->tm_isdst);
}
else {
char cc[4];
LUAL_Buffer b;
cc[0] = '%';
LUAL_buffinit(L, &b);
while (*s) {
if (*s != '%') /* no conversion specifier? */
LUAL_addchar(&b, *s++);
else {
size_t reslen;
char buff[200]; /* should be big enough for any conversion result */
s = checkoption(L, s + 1, cc);
reslen = strftime(buff, sizeof(buff), cc, stm);
LUAL_addlstring(&b, buff, reslen);
}
}
LUAL_pushresult(&b);
}
return 1;
}
static int os_date (lua_State *L) {
const char *s = luaL_optstring(L, 1, "%c");
time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
struct tm tmr, *stm;
if (*s == '!') { /* UTC? */
stm = l_gmtime(&t, &tmr);
s++; /* skip '!' */
}
else
stm = l_localtime(&t, &tmr);
if (stm == NULL) /* invalid date? */
luaL_error(L, "time result cannot be represented in this installation");
if (strcmp(s, "*t") == 0) {
lua_createtable(L, 0, 9); /* 9 = number of fields */
setfield(L, "sec", stm->tm_sec);
setfield(L, "min", stm->tm_min);
setfield(L, "hour", stm->tm_hour);
setfield(L, "day", stm->tm_mday);
setfield(L, "month", stm->tm_mon+1);
setfield(L, "year", stm->tm_year+1900);
setfield(L, "wday", stm->tm_wday+1);
setfield(L, "yday", stm->tm_yday+1);
setboolfield(L, "isdst", stm->tm_isdst);
}
else {
char cc[4];
luaL_Buffer b;
cc[0] = '%';
luaL_buffinit(L, &b);
while (*s) {
if (*s != '%') /* not a conversion specifier? */
luaL_addchar(&b, *s++);
else {
size_t reslen;
char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT);
s = checkoption(L, s + 1, cc);
reslen = strftime(buff, SIZETIMEFMT, cc, stm);
luaL_addsize(&b, reslen);
}
}
luaL_pushresult(&b);
}
return 1;
}
static int
unsupported_option(struct TestContext *ctx)
{
struct nmreq_option opt, save;
printf("Testing unsupported option on %s\n", ctx->ifname_ext);
memset(&opt, 0, sizeof(opt));
opt.nro_reqtype = 1234;
push_option(&opt, ctx);
save = opt;
if (port_register_hwall(ctx) >= 0)
return -1;
clear_options(ctx);
save.nro_status = EOPNOTSUPP;
return checkoption(&opt, &save);
}
int main(int argc, char **argv) {
int dev_fd;
int timeInterval;
int num;
int option;
unsigned int gdata;
int i;
unsigned int bit=1;
if(argc != 4) {
printf("Usage : %s [TimeInterval,1-100] [Num,1-100] [Option,0001-8000]\n",argv[0]);
return -1;
}
timeInterval = atoi(argv[1]);
num = atoi(argv[2]);
option = atoi(argv[3]);
dev_fd = open("/dev/dev_driver", O_RDWR);
if ( dev_fd < 0) {
printf("DEV Driver Open Failured!\n");
return -1;
}
if ( (1 <= timeInterval && timeInterval <= 100) &&
(1 <= num && num <= 100) &&
(1 == checkoption(option)))
{
printf("./app %d %d %d\n",timeInterval, num, option);
gdata = syscall(369, timeInterval,num,option);
// printf("gdata = %x\n",gdata);
write(dev_fd, &gdata);
} else {
printf("Invalid Value!\n");
}
return 0;
}
static int os_date (lua_State *L) {
size_t slen;
const char *s = luaL_optlstring(L, 1, "%c", &slen);
time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
const char *se = s + slen; /* 's' end */
struct tm tmr, *stm;
if (*s == '!') { /* UTC? */
stm = l_gmtime(&t, &tmr);
s++; /* skip '!' */
}
else
stm = l_localtime(&t, &tmr);
if (stm == NULL) /* invalid date? */
return luaL_error(L,
"time result cannot be represented in this installation");
if (strcmp(s, "*t") == 0) {
lua_createtable(L, 0, 9); /* 9 = number of fields */
setallfields(L, stm);
}
else {
char cc[4]; /* buffer for individual conversion specifiers */
luaL_Buffer b;
cc[0] = '%';
luaL_buffinit(L, &b);
while (s < se) {
if (*s != '%') /* not a conversion specifier? */
luaL_addchar(&b, *s++);
else {
size_t reslen;
char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT);
s++; /* skip '%' */
s = checkoption(L, s, se - s, cc + 1); /* copy specifier to 'cc' */
reslen = strftime(buff, SIZETIMEFMT, cc, stm);
luaL_addsize(&b, reslen);
}
}
luaL_pushresult(&b);
}
return 1;
}
static int SetKeyRepeat(lua_State *L)
{
int mode = KeyCodes[checkoption(L, 1, NULL, KeyStrings)];
glutSetKeyRepeat(mode);
return 0;
}
static int InitContext(lua_State *L)
/* init_context([major, minor, context, debug])
*
* type | profile | features
* ---------------------------------------------------------
* core full | core | current release
* compatible full | compatible | all ever
* forward compatible f.c. | core | non-deprecated
*/
{
int major, minor, context, flags, profile;
if(!lua_isnoneornil(L, 1)) /* set */
{
major = luaL_checkinteger(L, 1);
minor = luaL_checkinteger(L, 2);
flags = profile = 0;
context = ContextCodes[checkoption(L, 3, NULL, ContextStrings)];
switch(context)
{
case MOONGL_CORE:
profile |= GLUT_CORE_PROFILE;
break;
case MOONGL_COMPATIBLE:
profile |= GLUT_COMPATIBILITY_PROFILE;
break;
case MOONGL_FORWARD_COMPATIBLE:
flags |= GLUT_FORWARD_COMPATIBLE;
profile |= GLUT_CORE_PROFILE;
break;
default:
return luaL_error(L, UNEXPECTED_ERROR);
}
if(lua_isboolean(L, 4))
{
if(lua_toboolean(L, 4))
flags |= GLUT_DEBUG;
}
else if(!lua_isnoneornil(L, 4))
return luaL_argerror(L, 4, "boolean expected");
glutInitContextVersion(major, minor);
glutInitContextFlags(flags);
glutInitContextProfile(profile);
}
major = glutGet(GLUT_INIT_MAJOR_VERSION);
minor = glutGet(GLUT_INIT_MINOR_VERSION);
profile = glutGet(GLUT_INIT_PROFILE);
flags = glutGet(GLUT_INIT_FLAGS);
lua_pushinteger(L, major);
lua_pushinteger(L, minor);
if(profile & GLUT_CORE_PROFILE)
{
if(flags & GLUT_FORWARD_COMPATIBLE)
lua_pushstring(L, "forward compatible");
else
lua_pushstring(L, "core");
}
else if(profile & GLUT_COMPATIBILITY_PROFILE)
lua_pushstring(L, "compatible");
else
lua_pushstring(L, "default");
lua_pushboolean(L, (flags & GLUT_DEBUG));
return 4;
}
// main entry into parser
void encode_rpn()
{
statement *stmt, *tempstmt = gprog->firststmt;
struct labelset *label;
unsigned int x = 0, y = 0;
int channum = 0, lastfnc = 0, lastvar = 0, ifcount = 0;
byte display = 0, watchchannel = 0, special = 0;
char *cont;
symbol *sym;
begin:
stmt = SafeMalloc(sizeof(statement));
stmtinit(stmt);
for (x=0; x<MAX_STMT_METAS; x++) {
stmt->metalist[x].operation = 0;
stmt->metalist[x].floatarg.mantisa.i = 0;
stmt->metalist[x].floatarg.exp = 0;
stmt->metalist[x].shortarg = 0;
for (y=0; y<MAX_STRING_LENGTH; y++)
stmt->metalist[x].stringarg[y] = 0;
}
special = 0;
foundequals = 0;
firstvar = 1;
numlabels = 0;
envinfo.stmttype = 0;
tokenpos = 0;
token_type = 1;
lastopcode = 0;
for (x=0; x<32; x++) { numargs[x] = 0; parenstack[x] = 0; }
do {
get_token();
tokenpos += strlen(token);
if(!checkoption(get_cmdindex(get_opname(stmt->opcode)), token, token_type))
lineerror(stmt, __FILE__, __LINE__);
// hack to avoid using runtime system
// using runtime system would change the last executed line info.
// if ((!strcmp(token, "PBSTEP")) && (token_type == TOK_COMMAND))
// dbg_step();
switch (token_type) {
case TOK_ERROR:
lineerror(stmt, __FILE__, __LINE__);
break;
case TOK_COMMAND:
lastopcode = get_opcode(token);
if (cmdtable[get_cmdindex(token)].options & IO_CHANNEL)
watchchannel = 1;
else watchchannel = 0;
stmt->opcode = get_opcode(token);
if (stmt->opcode == CMD_LET) goto loop2;
else goto loop;
case TOK_NUMBER:
stmt->opcode = 0;
stmt->linenum = atoi(token);
break;
default:
buffermeta(stmt, token_type, token);
goto loop2;
}
buffermeta(stmt, token_type, token);
loop:
get_token();
if (checkerr == 2) checkerr = 1;
else if (checkerr == 1) {
if (token[0] == '=') {
if (stmt->metalist[stmt->metapos-2].operation == 0xEC)
stmt->metapos-=2;
else stmt->metapos--;
push("ERR", TOK_OPERATOR);
} else if (token[0] == '(') {
prog--;
stmt->metapos--;
strcpy(token, "ERR");
token_type = TOK_FUNCTION;
}
checkerr = 0;
}
if (lastopcode == CMD_SETERR) {
if (!strcmp(token, "ON")) lastopcode = CMD_SETERRON;
if (!strcmp(token, "OFF")) lastopcode = CMD_SETERROFF;
}
if (!strcmp(token, "RECORD")) {
if (stmt->opcode == CMD_READ) lastopcode = CMD_READRECORD;
if (stmt->opcode == CMD_WRITE) lastopcode = CMD_WRITERECORD;
if (stmt->opcode == CMD_EXTRACT) lastopcode = CMD_EXTRACTRECORD;
if (stmt->opcode == CMD_FIND) lastopcode = CMD_FINDRECORD;
if (stmt->opcode == CMD_PRINT) lastopcode = CMD_PRINTRECORD;
token_type = lasttype;
goto loop;
}
if (lastopcode == CMD_REM) {
stmt->metalist[1].operation = 0xF5;
tokenpos -= 2;
if (input[tokenpos] == '\"') x = tokenpos; else x = tokenpos+2;
stmt->metalist[1].shortarg = strlen(input) - x;
y = 0;
for (x=x; x<strlen(input); x++)
{ stmt->metalist[1].stringarg[y] = input[x]; y++; }
stmt->metalist[1].stringarg[y] = '\0';
stmt->metapos++;
if (stmt->linenum) insertstmt(gprog, stmt);
return;
}
tokenpos += strlen(token);
if(!checkoption(get_cmdindex(get_opname(lastopcode)), token, token_type))
lineerror(stmt, __FILE__, __LINE__);
loop2:
switch (token_type) {
case TOK_SEMICOLON:
popstack(stmt, -1);
if (!stmt->linenum) { execline(gprog, stmt); stmtinit(stmt); }
break;
case TOK_COLON:
if ((stmt->metalist[stmt->metapos-1].operation == SETVAL_NUMERIC) ||
(stmt->metalist[stmt->metapos-1].operation == GETVAL_NUMERIC) ||
(stmt->metalist[stmt->metapos-1].operation == LABELREF)) {
label = SafeMalloc(sizeof(struct labelset));
sym = idx2sym(gprog, stmt->metalist[stmt->metapos-1].shortarg);
label->labelnum = addlabel(gprog, sym->name, stmt->linenum);
for (x=0; x<MAX_STRING_LENGTH; x++)
sym->name[x] = '\0';
x = 0;
stmt->metapos--;
stmt->metalist[stmt->metapos].shortarg = 0;
stmt->opcode = 0;
stmt->labelset[stmt->numlabels] = label;
stmt->numlabels++;
firstvar = 1;
} else {
do {
if (stmt->linenum == tempstmt->linenum) {
for (x=0; x<strlen(input); x++)
if (input[x] == ':') break;
y = x;
for (x=0; x<=y; x++) input[x] = ' ';
cont = SafeMalloc(1024*64);
*cont = 0;
listline(cont, tempstmt, 1);
strcat(cont, input);
*prog = 0;
prog = cont;
display = 1;
goto begin;
}
tempstmt = tempstmt->nextstmt;
} while (tempstmt != NULL);
numlabels++;
}
goto loop;
case TOK_COMMA:
if (parencount > 0) {
// comma being delimiter for system functions
popstack(stmt, -2);
push("(", TOK_OPERATOR);
if (chaninfo == 1) {
if (!channum) {
channum = 1;
stmt->metalist[stmt->metapos].operation = 0xE1;
stmt->metapos++;
}
} else {
if (special == 1) numargs[parencount-1]+=10;
else numargs[parencount-1]++;
envinfo.stmttype = 0;
}
} else {
// comma being delimiter for verbs
popstack(stmt, -1);
buffermeta(stmt, TOK_COMMA, token);
for (x=0; x<32; x++) numargs[x] = 0;
envinfo.stmttype = 0;
foundequals = 0;
firstvar = 1;
}
goto loop;
case TOK_ERROR:
lineerror(stmt, __FILE__, __LINE__);
return;
case TOK_COMMAND:
lastopcode = get_opcode(token);
if (cmdtable[get_cmdindex(token)].options & IO_CHANNEL)
watchchannel = 1;
else watchchannel = 0;
if (!strcmp(token, "IF")) ifcount++;
if (!stmt->opcode) {
stmt->opcode = get_opcode(token);
envinfo.stmttype = 0;
goto loop;
} else {
popstack(stmt, -1);
envinfo.stmttype = 0;
if (ifcount > 0) {
stmt->metalist[stmt->metapos].operation = 0xE7;
stmt->metalist[stmt->metapos].shortarg = 0;
stmt->metalist[stmt->metapos].intarg = 0;
stmt->metapos++;
stmt->length++;
// watchchannel = 0;
chaninfo = 0;
channum = 0;
ifcount--;
}
if (lastopcode == CMD_ON) {
special = 1;
if (!strcmp(token, "GOTO"))
stmt->metalist[stmt->metapos].operation = 0x00F4;
else stmt->metalist[stmt->metapos].operation = 0x01F4;
stmt->length += 2;
stmt->metapos++;
} else
buffermeta(stmt, TOK_COMMAND, token);
goto loop;
}
break;
case TOK_RESERVED:
popstack(stmt, -1);
envinfo.stmttype = 0;
lineref = 0;
if (!strcmp(token, "ELSE")) {
stmt->metalist[stmt->metapos].operation = 0xE7;
stmt->metalist[stmt->metapos].intarg = 0;
stmt->metalist[stmt->metapos].shortarg = 0;
stmt->metapos++;
stmt->metalist[stmt->metapos].operation = 0xE2;
stmt->metalist[stmt->metapos].intarg = 0;
stmt->metalist[stmt->metapos].shortarg = 0;
stmt->metapos++;
stmt->length+=2;
envinfo.stmttype = 0;
chaninfo = 0;
channum = 0;
}
goto loop;
case TOK_DONE:
if ((stmt->linenum) && (!stmt->opcode)) deletestmt(gprog,stmt->linenum);
else {
popstack(stmt, -1);
if (stmt->opcode == CMD_LET && foundequals == 0) lineerror(stmt, __FILE__, __LINE__);
if (parencount > 0 || numlabels < 0) lineerror(stmt, __FILE__, __LINE__);
if (stmt->linenum) { if (!stmt->errorflag) insertstmt(gprog, stmt); }
else if (stmt->opcode) { if (!stmt->errorflag)
{ execline(gprog, stmt); } }
}
if (display) {
GC_realloc(cont, strlen(cont));
listprog(gprog, stmt->linenum, stmt->linenum);
}
return;
case TOK_USERFUNCTION:
if (lastopcode == CMD_DEFFN)
addfunction(gprog, token, stmt->linenum, 1);
else addfunction(gprog, token, stmt->linenum, 0);
if (token[strlen(token)-1] == '$') parenstack[parencount] = 8;
else parenstack[parencount] = 7;
buffermeta(stmt, TOK_USERFUNCTION, token);
break;
case TOK_FUNCTION:
lastfnc = get_fnc(token);
numlabels++;
case TOK_OPERATOR:
if (token[0] == '[') {
special = 1;
cont = get_symname(lastvar);
if (cont[strlen(cont)-1] == '$')
parenstack[parencount] = 2;
else parenstack[parencount] = 1;
numlabels++;
goto openparen;
} else if (token[0] == ']') {
numargs[parencount-1] += 9;
popstack(stmt, -2);
envinfo.stmttype = parenstack[parencount];
token_type = TOK_ARRAY;
special = 0;
goto loop;
} else if (token[0] == '-') {
// placeholder
if ((lasttype == TOK_OPERATOR) || (lasttype == TOK_RESERVED))
token[0] = '_';
evalstack(stmt);
goto loop;
} else if (token[0] == '(') {
openparen:
if (lasttype == TOK_COMMAND) {
if (watchchannel == 1)
chaninfo = 1;
} else if (lasttype == TOK_ARRAY) {
envinfo.stmttype = 0;
numargs[parencount]++;
push(token, token_type);
goto loop;
} else if (lasttype == TOK_SETVAL) {
push(get_symname(lastvar), TOK_SETVAL);
stmt->metapos--;
stmt->metalist[stmt->metapos].shortarg = 0;
numlabels++;
cont = get_symname(lastvar);
if (cont[strlen(cont)-1] == '$')
parenstack[parencount] = 2;
else parenstack[parencount] = 1;
} else if (lasttype == TOK_VARIABLE) {
push(get_symname(lastvar), TOK_VARIABLE);
numlabels++;
stmt->metapos--;
stmt->metalist[stmt->metapos].shortarg = 0;
cont = get_symname(lastvar);
if (cont[strlen(cont)-1] == '$')
parenstack[parencount] = 2;
else parenstack[parencount] = 1;
} else if (lasttype == TOK_USERFUNCTION) {
stmt->metapos--;
stmt->metalist[stmt->metapos].operation = 0xF5;
stmt->metapos++;
stmt->length++;
} else if (lasttype == TOK_FUNCTION) {
if ((envinfo.stmttype != fnctable[lastfnc].returntype) &&
(envinfo.stmttype != 0))
lineerror(stmt, __FILE__, __LINE__);
else parenstack[parencount] = fnctable[lastfnc].returntype;
} else parenstack[parencount] = 1;
envinfo.stmttype = 0;
numargs[parencount] = 1;
push(token, token_type);
goto loop;
} else if (token[0] == ')') {
if (parencount == 0) lineerror(stmt, __FILE__, __LINE__);
popstack(stmt, -2);
if (parenstack[parencount] == 7) {
stmt->metalist[stmt->metapos].operation = 0xF8;
stmt->metapos++;
stmt->length++;
envinfo.stmttype = 1;
} else if (parenstack[parencount] == 8) {
stmt->metalist[stmt->metapos].operation = 0xF8;
stmt->metapos++;
stmt->length++;
envinfo.stmttype = 2;
} else envinfo.stmttype = parenstack[parencount];
if (lastopcode == CMD_DEFFN && foundequals == 0) {
stmt->metapos--;
stmt->metalist[stmt->metapos].operation = 0xF8;
stmt->metapos++;
}
if (chaninfo == 1) {
chaninfo = 0;
if (!channum) {
stmt->metalist[stmt->metapos].operation = 0xE1;
stmt->metapos++;
}
stmt->metalist[stmt->metapos].operation = 0xF4F1;
stmt->metapos++;
numargs[parencount] = 0;
}
goto loop;
} else {
evalstack(stmt);
goto loop;
}
break;
case TOK_VARIABLE:
if (get_sysvar(token)) {
buffermeta(stmt, TOK_SYSVAR, token);
numlabels++;
goto loop;
} else { addsymbol(gprog, token); lastvar = get_symref(token); }
case TOK_NUMBER:
default:
if(!stmt->opcode) { envinfo.stmttype = 0; lastopcode = stmt->opcode = CMD_LET; }
if ((firstvar == 1) && (token_type == TOK_VARIABLE) &&
(lastopcode == CMD_LET || lastopcode == CMD_FOR ||
lastopcode == CMD_FOR || lastopcode == CMD_NEXT ||
lastopcode == CMD_DIM || lastopcode == CMD_INPUT)) {
buffermeta(stmt, TOK_SETVAL, token);
firstvar = 0;
token_type = TOK_SETVAL;
} else { numlabels++; buffermeta(stmt, token_type, token); }
goto loop;
}
} while (1);
}
