void print (align *myal, int *first, int *last, int len){
int *start, *end, i, j, s = 0, e = 0;
start = (int *) malloc (sizeof (int) * myal->numseq); assert (start);
end = (int *) malloc (sizeof (int) * myal->numseq); assert (end);
for (i = 0; i < myal->numseq; i++) start[i] = end[i] = 0;
for (i = 0; i < len; i++){
skipto (myal, first[i], &s, start);
skipto (myal, last[i], &e, end);
printf ("(%d %d) --> ", first[i] + s1shift, last[i] + s1shift);
if (myal->numseq == 2){
printf ("(%d %d)%s", start[0] + s1shift, end[0] + s1shift, (0 == myal->numseq - 1) ? "\n" : ", ");
printf ("(%d %d)%s", start[1] + s2shift, end[1] + s2shift, (1 == myal->numseq - 1) ? "\n" : ", ");
}
else {
for (j = 0; j < myal->numseq; j++){
printf ("(%d %d)%s", start[0], end[0], (j == myal->numseq - 1) ? "\n" : ", ");
}
}
// this is a hack -- can't handle multiple seq's
/*
for (j = 0; j < myal->numseq; j++){
printf ("(%d %d)%s", start[j], end[j], (j == myal->numseq - 1) ? "\n" : ", ");
}
*/
}
free (start);
free (end);
}
static void
skipto(unsigned char endch)
{
/*
* skip chars up to }
*/
unsigned int c;
while ((c = readwc()) && c != endch)
{
switch (c)
{
case SQUOTE:
skipto(SQUOTE);
break;
case DQUOTE:
skipto(DQUOTE);
break;
case DOLLAR:
if (readwc() == BRACE)
skipto('}');
}
}
if (c != endch)
error(badsub);
}
void SyntaxAnalyzer::endcheck(std::set<symboltype> &followers)
{
if (followers.find(symbol) == followers.end()) {
syntaxerror(othersy);
skipto(followers);
}
}
static int chkskip(struct rnc_source *sp,int symc,int syms) {
if(CUR(sp).sym!=symc) {
error(0,sp,RNC_ER_SEXP,sp->fn,CUR(sp).line,CUR(sp).col,sym2str(symc),sym2str(CUR(sp).sym));
skipto(sp,syms);
return 0;
} else {
return 1;
}
}
void test(int tok, char set[]) {
if (t == tok)
t = gettok();
else {
expect(tok);
skipto(tok, set);
if (t == tok)
t = gettok();
}
}
void SyntaxAnalyzer::skipto(std::set<symboltype> &starters,
std::set<symboltype> &followers)
{
std::set<symboltype> skipsymbols;
std::set_union(starters.begin(), starters.end(),
followers.begin(), followers.end(),
std::inserter(skipsymbols, skipsymbols.begin())
);
skipto(skipsymbols);
}
bool SyntaxAnalyzer::startcheck(
std::set<symboltype> &starters,
std::set<symboltype> &followers
) {
if (starters.find(symbol) == starters.end()) {
syntaxerror(othersy);
skipto(starters, followers);
return false; //symbol not in starters
} else {
return true; //symbol in starters
}
}
static int skipto(char endch)
{
/* skip chars up to } */
register char c;
while ((c = readc()) && c != endch) {
switch (c) {
case SQUOTE:
skipto(SQUOTE);
break;
case DQUOTE:
skipto(DQUOTE);
break;
case DOLLAR:
if (readc() == BRACE)
skipto('}');
}
}
if (c != endch) {
error(badsub);
}
}
void statement(int loop, Swtch swp, int lev) {
float ref = refinc;
if (Aflag >= 2 && lev == 15)
warning("more than 15 levels of nested statements\n");
switch (t) {
case IF: ifstmt(genlabel(2), loop, swp, lev + 1);
break;
case WHILE: whilestmt(genlabel(3), swp, lev + 1); break;
case DO: dostmt(genlabel(3), swp, lev + 1); expect(';');
break;
case FOR: forstmt(genlabel(4), swp, lev + 1);
break;
case BREAK: walk(NULL, 0, 0);
definept(NULL);
if (swp && swp->lab > loop)
branch(swp->lab + 1);
else if (loop)
branch(loop + 2);
else
error("illegal break statement\n");
t = gettok(); expect(';');
break;
case CONTINUE: walk(NULL, 0, 0);
definept(NULL);
if (loop)
branch(loop + 1);
else
error("illegal continue statement\n");
t = gettok(); expect(';');
break;
case SWITCH: swstmt(loop, genlabel(2), lev + 1);
break;
case CASE: {
int lab = genlabel(1);
if (swp == NULL)
error("illegal case label\n");
definelab(lab);
while (t == CASE) {
static char stop[] = { IF, ID, 0 };
Tree p;
t = gettok();
p = constexpr(0);
if (generic(p->op) == CNST && isint(p->type)) {
if (swp) {
needconst++;
p = cast(p, swp->sym->type);
if (p->type->op == UNSIGNED)
p->u.v.i = extend(p->u.v.u, p->type);
needconst--;
caselabel(swp, p->u.v.i, lab);
}
} else
error("case label must be a constant integer expression\n");
test(':', stop);
}
statement(loop, swp, lev);
} break;
case DEFAULT: if (swp == NULL)
error("illegal default label\n");
else if (swp->deflab)
error("extra default label\n");
else {
swp->deflab = findlabel(swp->lab);
definelab(swp->deflab->u.l.label);
}
t = gettok();
expect(':');
statement(loop, swp, lev); break;
case RETURN: {
Type rty = freturn(cfunc->type);
t = gettok();
definept(NULL);
if (t != ';')
if (rty == voidtype) {
error("extraneous return value\n");
expr(0);
retcode(NULL);
} else
retcode(expr(0));
else {
if (rty != voidtype)
warning("missing return value\n");
retcode(NULL);
}
branch(cfunc->u.f.label);
} expect(';');
break;
case '{': compound(loop, swp, lev + 1); break;
case ';': definept(NULL); t = gettok(); break;
case GOTO: walk(NULL, 0, 0);
definept(NULL);
t = gettok();
if (t == ID) {
Symbol p = lookup(token, stmtlabs);
if (p == NULL) {
p = install(token, &stmtlabs, 0, FUNC);
p->scope = LABELS;
p->u.l.label = genlabel(1);
p->src = src;
}
use(p, src);
branch(p->u.l.label);
t = gettok();
} else
error("missing label in goto\n"); expect(';');
break;
case ID: if (getchr() == ':') {
stmtlabel();
statement(loop, swp, lev);
break;
}
default: definept(NULL);
if (kind[t] != ID) {
error("unrecognized statement\n");
t = gettok();
} else {
Tree e = expr0(0);
listnodes(e, 0, 0);
if (nodecount == 0 || nodecount > 200)
walk(NULL, 0, 0);
else if (glevel) walk(NULL, 0, 0);
deallocate(STMT);
} expect(';');
break;
}
if (kind[t] != IF && kind[t] != ID
&& t != '}' && t != EOI) {
static char stop[] = { IF, ID, '}', 0 };
error("illegal statement termination\n");
skipto(0, stop);
}
refinc = ref;
}
void sbbs_t::skipto(csi_t *csi, uchar inst)
{
int i,j;
while(csi->ip<csi->cs+csi->length && ((inst&0x80) || *csi->ip!=inst)) {
if(*csi->ip==CS_IF_TRUE || *csi->ip==CS_IF_FALSE
|| (*csi->ip>=CS_IF_GREATER && *csi->ip<=CS_IF_LESS_OR_EQUAL)) {
csi->ip++;
skipto(csi,CS_ENDIF);
csi->ip++;
continue;
}
if(inst==CS_ELSEORENDIF
&& (*csi->ip==CS_ELSE || *csi->ip==CS_ENDIF))
break;
if(inst==CS_NEXTCASE
&& (*csi->ip==CS_CASE || *csi->ip==CS_DEFAULT
|| *csi->ip==CS_END_SWITCH))
break;
if(*csi->ip==CS_SWITCH) {
csi->ip++;
csi->ip+=4; /* Skip variable name */
skipto(csi,CS_END_SWITCH);
csi->ip++;
continue;
}
if(*csi->ip==CS_CASE) {
csi->ip++;
csi->ip+=4; /* Skip value */
skipto(csi,CS_NEXTCASE);
continue;
}
if(*csi->ip==CS_CMDKEY || *csi->ip==CS_CMDCHAR) {
csi->ip+=2;
skipto(csi,CS_END_CMD);
csi->ip++;
continue;
}
if(*csi->ip==CS_CMDSTR || *csi->ip==CS_CMDKEYS) {
csi->ip++; /* skip inst */
while(*(csi->ip++)); /* skip string */
skipto(csi,CS_END_CMD);
csi->ip++;
continue;
}
if(*csi->ip>=CS_FUNCTIONS) {
csi->ip++;
continue;
}
if(*csi->ip>=CS_MISC) {
switch(*csi->ip) {
case CS_VAR_INSTRUCTION:
csi->ip++;
switch(*(csi->ip++)) {
case SHOW_VARS:
continue;
case PRINT_VAR:
case DEFINE_STR_VAR:
case DEFINE_INT_VAR:
case DEFINE_GLOBAL_STR_VAR:
case DEFINE_GLOBAL_INT_VAR:
case TIME_INT_VAR:
case STRUPR_VAR:
case STRLWR_VAR:
case TRUNCSP_STR_VAR:
case CHKFILE_VAR:
case COPY_CHAR:
case STRIP_CTRL_STR_VAR:
csi->ip+=4; /* Skip variable name */
continue;
case GETSTR_VAR:
case GETNAME_VAR:
case GETLINE_VAR:
case GETSTRUPR_VAR:
case SHIFT_STR_VAR:
case SEND_FILE_VIA_VAR:
case RECEIVE_FILE_VIA_VAR:
case COMPARE_FIRST_CHAR:
case SHIFT_TO_FIRST_CHAR:
case SHIFT_TO_LAST_CHAR:
csi->ip+=4; /* Skip variable name */
csi->ip++; /* Skip char */
continue;
case PRINTTAIL_VAR_MODE:
csi->ip++; /* Skip length */
case PRINTFILE_VAR_MODE:
case GETNUM_VAR:
csi->ip+=4; /* Skip variable name */
csi->ip+=2; /* Skip max num */
continue;
case STRNCMP_VAR:
csi->ip++; /* Skip length */
case SET_STR_VAR:
case COMPARE_STR_VAR:
case CAT_STR_VAR:
case STRSTR_VAR:
case TELNET_GATE_STR:
csi->ip+=4; /* Skip variable name */
while(*(csi->ip++)); /* skip string */
continue;
case FORMAT_TIME_STR:
csi->ip+=4; /* Skip destination variable */
while(*(csi->ip++)); /* Skip string */
csi->ip+=4; /* Skip int variable */
continue;
case FORMAT_STR_VAR: /* SPRINTF */
csi->ip+=4; /* Skip destination variable */
case VAR_PRINTF:
case VAR_PRINTF_LOCAL:
while(*(csi->ip++)); /* Skip string */
j=*(csi->ip++); /* Skip number of arguments */
for(i=0;i<j;i++)
csi->ip+=4; /* Skip arguments */
continue;
case SEND_FILE_VIA:
case RECEIVE_FILE_VIA:
csi->ip++; /* Skip prot */
while(*(csi->ip++)); /* Skip filepath */
continue;
case GETSTR_MODE:
case STRNCMP_VARS:
csi->ip++; /* Skip length */
default:
csi->ip+=8; /* Skip two variable names or var & val */
continue;
}
case CS_FIO_FUNCTION:
csi->ip++;
switch(*(csi->ip++)) {
case FIO_OPEN:
csi->ip+=4; /* File handle */
csi->ip+=2; /* Access */
while(*(csi->ip++)); /* path/filename */
continue;
case FIO_CLOSE:
case FIO_FLUSH:
case FIO_EOF:
case REMOVE_FILE:
case REMOVE_DIR:
case CHANGE_DIR:
case MAKE_DIR:
case REWIND_DIR:
case CLOSE_DIR:
csi->ip+=4; /* File handle */
continue;
case FIO_SET_ETX:
csi->ip++;
continue;
case FIO_PRINTF:
csi->ip+=4; /* File handle */
while(*(csi->ip++)); /* String */
j=*(csi->ip++); /* Number of arguments */
for(i=0;i<j;i++)
csi->ip+=4; /* Arguments */
continue;
case FIO_READ:
case FIO_WRITE:
case FIO_SEEK:
case FIO_SEEK_VAR:
case FIO_OPEN_VAR:
csi->ip+=4; /* File handle */
csi->ip+=4; /* Variable */
csi->ip+=2; /* Length/access */
continue;
case FIO_READ_VAR:
case FIO_WRITE_VAR:
csi->ip+=4; /* File handle */
csi->ip+=4; /* Buf Variable */
csi->ip+=4; /* Length Variable */
continue;
default:
csi->ip+=4; /* File handle */
csi->ip+=4; /* Variable */
continue;
}
case CS_NET_FUNCTION:
csi->ip++;
switch(*(csi->ip++)) {
case CS_SOCKET_CONNECT:
csi->ip+=4; /* socket */
csi->ip+=4; /* address */
csi->ip+=2; /* port */
continue;
case CS_SOCKET_NREAD:
csi->ip+=4; /* socket */
csi->ip+=4; /* intvar */
continue;
case CS_SOCKET_READ:
case CS_SOCKET_READLINE:
case CS_SOCKET_PEEK:
csi->ip+=4; /* socket */
csi->ip+=4; /* buffer */
csi->ip+=2; /* length */
continue;
case CS_SOCKET_WRITE:
csi->ip+=4; /* socket */
csi->ip+=4; /* strvar */
continue;
case CS_FTP_LOGIN:
case CS_FTP_GET:
case CS_FTP_PUT:
case CS_FTP_RENAME:
csi->ip+=4; /* socket */
csi->ip+=4; /* username/path */
csi->ip+=4; /* password/path */
continue;
case CS_FTP_DIR:
case CS_FTP_CWD:
case CS_FTP_DELETE:
csi->ip+=4; /* socket */
csi->ip+=4; /* path */
continue;
default:
csi->ip+=4; /* socket */
continue;
}
case CS_COMPARE_ARS:
csi->ip++;
csi->ip+=(*csi->ip);
csi->ip++;
break;
case CS_TOGGLE_USER_MISC:
case CS_COMPARE_USER_MISC:
case CS_TOGGLE_USER_CHAT:
case CS_COMPARE_USER_CHAT:
case CS_TOGGLE_USER_QWK:
case CS_COMPARE_USER_QWK:
csi->ip+=5;
break;
case CS_REPLACE_TEXT:
csi->ip+=3; /* skip inst and text # */
while(*(csi->ip++)); /* skip string */
break;
case CS_USE_INT_VAR:
csi->ip+=7; // inst, var, offset, len
break;
default:
csi->ip++;
}
continue;
}
if(*csi->ip==CS_ONE_MORE_BYTE) {
if(inst==CS_END_LOOP && *(csi->ip+1)==CS_END_LOOP)
break;
csi->ip++; /* skip extension */
csi->ip++; /* skip instruction */
if(*(csi->ip-1)==CS_LOOP_BEGIN) { /* nested loop */
skipto(csi,CS_END_LOOP);
csi->ip+=2;
}
continue;
}
if(*csi->ip==CS_TWO_MORE_BYTES) {
csi->ip++; /* skip extension */
csi->ip++; /* skip instruction */
csi->ip++; /* skip argument */
continue;
}
if(*csi->ip==CS_THREE_MORE_BYTES) {
csi->ip++; /* skip extension */
csi->ip++; /* skip instruction */
csi->ip+=2; /* skip argument */
continue;
}
if(*csi->ip==CS_STR_FUNCTION) {
csi->ip++; /* skip extension */
csi->ip++; /* skip instruction */
while(*(csi->ip++)); /* skip string */
continue;
}
if(*csi->ip>=CS_ASCIIZ) {
csi->ip++; /* skip inst */
while(*(csi->ip++)); /* skip string */
continue;
}
if(*csi->ip>=CS_THREE_BYTE) {
csi->ip+=3;
continue;
}
if(*csi->ip>=CS_TWO_BYTE) {
csi->ip+=2;
continue;
}
csi->ip++;
}
}
int sbbs_t::exec(csi_t *csi)
{
char str[256],*path;
char tmp[512];
uchar buf[1025],ch;
int i,j,file;
long l;
FILE *stream;
if(usrgrps)
cursubnum=usrsub[curgrp][cursub[curgrp]]; /* Used for ARS */
else
cursubnum=INVALID_SUB;
if(usrlibs) {
curdirnum=usrdir[curlib][curdir[curlib]]; /* Used for ARS */
path=cfg.dir[usrdir[curlib][curdir[curlib]]]->path;
}
else {
curdirnum=INVALID_DIR;
path=nulstr;
}
now=time(NULL);
if(csi->ip>=csi->cs+csi->length)
return(1);
if(*csi->ip>=CS_FUNCTIONS)
return(exec_function(csi));
/**********************************************/
/* Miscellaneous variable length instructions */
/**********************************************/
if(*csi->ip>=CS_MISC)
return(exec_misc(csi,path));
/********************************/
/* ASCIIZ argument instructions */
/********************************/
if(*csi->ip>=CS_ASCIIZ) {
switch(*(csi->ip++)) {
case CS_STR_FUNCTION:
switch(*(csi->ip++)) {
case CS_LOGIN:
csi->logic=login(csi->str,(char*)csi->ip);
break;
case CS_LOAD_TEXT:
csi->logic=LOGIC_FALSE;
for(i=0;i<TOTAL_TEXT;i++)
if(text[i]!=text_sav[i]) {
if(text[i]!=nulstr)
free(text[i]);
text[i]=text_sav[i];
}
SAFEPRINTF2(str,"%s%s.dat"
,cfg.ctrl_dir,cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
break;
}
for(i=0;i<TOTAL_TEXT && !feof(stream);i++) {
if((text[i]=readtext((long *)NULL,stream,i))==NULL) {
i--;
continue;
}
if(!strcmp(text[i],text_sav[i])) { /* If identical */
free(text[i]); /* Don't alloc */
text[i]=text_sav[i];
}
else if(text[i][0]==0) {
free(text[i]);
text[i]=nulstr;
}
}
if(i<TOTAL_TEXT) {
fclose(stream);
errormsg(WHERE,ERR_READ,str,TOTAL_TEXT);
break;
}
fclose(stream);
csi->logic=LOGIC_TRUE;
break;
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
break;
}
while(*(csi->ip++)); /* Find NULL */
return(0);
case CS_LOG:
log(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_GETCMD:
csi->cmd=(uchar)getkeys((char*)csi->ip,0);
if((char)csi->cmd==-1)
csi->cmd=3;
break;
case CS_CMDSTR:
if(stricmp(csi->str,(char*)csi->ip)) {
while(*(csi->ip++)); /* Find NULL */
skipto(csi,CS_END_CMD);
csi->ip++;
return(0);
}
break;
case CS_CMDKEYS:
for(i=0;csi->ip[i];i++)
if(csi->cmd==csi->ip[i])
break;
if(!csi->ip[i]) {
while(*(csi->ip++)); /* Find NULL */
skipto(csi,CS_END_CMD);
csi->ip++;
return(0);
}
break;
case CS_GET_TEMPLATE:
gettmplt(csi->str,(char*)csi->ip,K_LINE);
if(sys_status&SS_ABORT)
csi->str[0]=0;
csi->cmd=csi->str[0];
break;
case CS_TRASHCAN:
csi->logic=!trashcan(csi->str,(char*)csi->ip);
break;
case CS_CREATE_SIF:
create_sif_dat((char*)csi->ip,csi->str);
break;
case CS_READ_SIF:
read_sif_dat((char*)csi->ip,csi->str);
break;
case CS_MNEMONICS:
mnemonics((char*)csi->ip);
break;
case CS_PRINT:
putmsg(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),P_SAVEATR|P_NOABORT);
break;
case CS_PRINT_LOCAL:
if(online==ON_LOCAL)
eprintf(LOG_INFO,"%s",cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
else
lputs(LOG_INFO,cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_PRINT_REMOTE:
putcom(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_PRINTFILE:
printfile(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),P_SAVEATR);
break;
case CS_PRINTFILE_REMOTE:
if(online!=ON_REMOTE || !(console&CON_R_ECHO))
break;
console&=~CON_L_ECHO;
printfile(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),P_SAVEATR);
console|=CON_L_ECHO;
break;
case CS_PRINTFILE_LOCAL:
if(!(console&CON_L_ECHO))
break;
console&=~CON_R_ECHO;
printfile(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),P_SAVEATR);
console|=CON_R_ECHO;
break;
case CS_CHKFILE:
csi->logic=!fexistcase(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_EXEC:
external(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),0);
break;
case CS_EXEC_INT:
external(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),EX_STDIO);
break;
case CS_EXEC_XTRN:
for(i=0;i<cfg.total_xtrns;i++)
if(!stricmp(cfg.xtrn[i]->code,(char*)csi->ip))
break;
if(i<cfg.total_xtrns)
exec_xtrn(i);
break;
case CS_EXEC_BIN:
exec_bin(cmdstr((char*)csi->ip,path,csi->str,(char*)buf),csi,/* startup_dir: */NULL);
break;
case CS_YES_NO:
csi->logic=!yesno(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_NO_YES:
csi->logic=!noyes(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_MENU:
menu(cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_SETSTR:
strcpy(csi->str,cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_SET_MENU_DIR:
cmdstr((char*)csi->ip,path,csi->str,menu_dir);
break;
case CS_SET_MENU_FILE:
cmdstr((char*)csi->ip,path,csi->str,menu_file);
break;
case CS_COMPARE_STR:
csi->logic=stricmp(csi->str,cmdstr((char*)csi->ip,path,csi->str,(char*)buf));
break;
case CS_COMPARE_KEYS:
for(i=0;csi->ip[i];i++)
if(csi->cmd==csi->ip[i])
break;
if(csi->ip[i])
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
break;
case CS_COMPARE_WORD:
csi->logic=strnicmp(csi->str,(char*)csi->ip,strlen((char*)csi->ip));
break;
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
break;
}
while(*(csi->ip++)); /* Find NULL */
return(0);
}
if(*csi->ip>=CS_THREE_BYTE) {
switch(*(csi->ip++)) {
case CS_THREE_MORE_BYTES:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
case CS_GOTO:
csi->ip=csi->cs+*((ushort *)(csi->ip));
return(0);
case CS_CALL:
if(csi->rets<MAX_RETS) {
csi->ret[csi->rets++]=csi->ip+2;
csi->ip=csi->cs+*((ushort *)(csi->ip));
}
return(0);
case CS_MSWAIT:
mswait(*(ushort *)csi->ip);
csi->ip+=2;
return(0);
case CS_TOGGLE_NODE_MISC:
if(getnodedat(cfg.node_num,&thisnode,true)==0) {
thisnode.misc^=*(ushort *)csi->ip;
putnodedat(cfg.node_num,&thisnode);
}
csi->ip+=2;
return(0);
case CS_COMPARE_NODE_MISC:
getnodedat(cfg.node_num,&thisnode,0);
if((thisnode.misc&*(ushort *)csi->ip)==*(ushort *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=2;
return(0);
case CS_ADJUST_USER_CREDITS:
i=*(short *)csi->ip;
l=i*1024L;
if(l<0)
subtract_cdt(&cfg,&useron,-l);
else
useron.cdt=adjustuserrec(&cfg,useron.number,U_CDT,10,l);
csi->ip+=2;
return(0);
case CS_ADJUST_USER_MINUTES:
i=*(short *)csi->ip;
useron.min=adjustuserrec(&cfg,useron.number,U_MIN,10,i);
csi->ip+=2;
return(0);
case CS_GETNUM:
i=*(short *)csi->ip;
csi->ip+=2;
l=getnum(i);
if(l<=0) {
csi->str[0]=0;
csi->logic=LOGIC_FALSE;
}
else {
sprintf(csi->str,"%lu",l);
csi->logic=LOGIC_TRUE;
}
return(0);
case CS_TOGGLE_USER_FLAG:
i=*(csi->ip++);
ch=*(csi->ip++);
switch(i) {
case '1':
useron.flags1^=FLAG(ch);
putuserrec(&cfg,useron.number,U_FLAGS1,8
,ultoa(useron.flags1,tmp,16));
break;
case '2':
useron.flags2^=FLAG(ch);
putuserrec(&cfg,useron.number,U_FLAGS2,8
,ultoa(useron.flags2,tmp,16));
break;
case '3':
useron.flags3^=FLAG(ch);
putuserrec(&cfg,useron.number,U_FLAGS3,8
,ultoa(useron.flags3,tmp,16));
break;
case '4':
useron.flags4^=FLAG(ch);
putuserrec(&cfg,useron.number,U_FLAGS4,8
,ultoa(useron.flags4,tmp,16));
break;
case 'R':
useron.rest^=FLAG(ch);
putuserrec(&cfg,useron.number,U_REST,8
,ultoa(useron.rest,tmp,16));
break;
case 'E':
useron.exempt^=FLAG(ch);
putuserrec(&cfg,useron.number,U_EXEMPT,8
,ultoa(useron.exempt,tmp,16));
break;
default:
errormsg(WHERE,ERR_CHK,"user flag type",*(csi->ip-2));
return(0);
}
return(0);
case CS_REVERT_TEXT:
i=*(ushort *)csi->ip;
csi->ip+=2;
if((ushort)i==0xffff) {
for(i=0;i<TOTAL_TEXT;i++) {
if(text[i]!=text_sav[i] && text[i]!=nulstr)
free(text[i]);
text[i]=text_sav[i];
}
return(0);
}
i--;
if(i>=TOTAL_TEXT) {
errormsg(WHERE,ERR_CHK,"revert text #",i);
return(0);
}
if(text[i]!=text_sav[i] && text[i]!=nulstr)
free(text[i]);
text[i]=text_sav[i];
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
}
}
if(*csi->ip>=CS_TWO_BYTE) {
switch(*(csi->ip++)) {
case CS_TWO_MORE_BYTES:
switch(*(csi->ip++)) {
case CS_USER_EVENT:
user_event((user_event_t)*(csi->ip++));
return(0);
}
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
case CS_SETLOGIC:
csi->logic=*csi->ip++;
return(0);
case CS_CMDKEY:
if( ((*csi->ip)==CS_DIGIT && isdigit(csi->cmd))
|| ((*csi->ip)==CS_EDIGIT && csi->cmd&0x80
&& isdigit(csi->cmd&0x7f))) {
csi->ip++;
return(0);
}
if(csi->cmd!=*csi->ip) {
csi->ip++;
skipto(csi,CS_END_CMD); /* skip code */
}
csi->ip++; /* skip key */
return(0);
case CS_CMDCHAR:
if(csi->cmd!=*csi->ip) {
csi->ip++;
skipto(csi,CS_END_CMD); /* skip code */
}
csi->ip++; /* skip key */
return(0);
case CS_NODE_ACTION:
action=*csi->ip++;
return(0);
case CS_NODE_STATUS:
if(getnodedat(cfg.node_num,&thisnode,true)==0) {
thisnode.status=*csi->ip++;
putnodedat(cfg.node_num,&thisnode);
} else
csi->ip++;
return(0);
case CS_MULTINODE_CHAT:
multinodechat(*csi->ip++);
return(0);
case CS_GETSTR:
csi->logic=LOGIC_TRUE;
getstr(csi->str,*csi->ip++,0);
if(sys_status&SS_ABORT) {
csi->str[0]=0;
csi->logic=LOGIC_FALSE;
}
if(csi->str[0]=='/' && csi->str[1])
csi->cmd=csi->str[1]|0x80;
else
csi->cmd=csi->str[0];
return(0);
case CS_GETLINE:
getstr(csi->str,*csi->ip++,K_LINE);
if(sys_status&SS_ABORT)
csi->str[0]=0;
if(csi->str[0]=='/' && csi->str[1])
csi->cmd=csi->str[1]|0x80;
else
csi->cmd=csi->str[0];
return(0);
case CS_GETSTRUPR:
getstr(csi->str,*csi->ip++,K_UPPER);
if(sys_status&SS_ABORT)
csi->str[0]=0;
if(csi->str[0]=='/' && csi->str[1])
csi->cmd=csi->str[1]|0x80;
else
csi->cmd=csi->str[0];
return(0);
case CS_GETNAME:
getstr(csi->str,*csi->ip++,K_UPRLWR);
if(sys_status&SS_ABORT)
csi->str[0]=0;
return(0);
case CS_SHIFT_STR:
i=*(csi->ip++);
j=strlen(csi->str);
if(i>j)
i=j;
if(i)
memmove(csi->str,csi->str+i,j+1);
return(0);
case CS_COMPARE_KEY:
if( ((*csi->ip)==CS_DIGIT && isdigit(csi->cmd))
|| ((*csi->ip)==CS_EDIGIT && csi->cmd&0x80
&& isdigit(csi->cmd&0x7f))) {
csi->ip++;
csi->logic=LOGIC_TRUE;
}
else {
if(csi->cmd==*(csi->ip++))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
}
return(0);
case CS_COMPARE_CHAR:
if(csi->cmd==*(csi->ip++))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_SET_USER_LEVEL:
useron.level=*(csi->ip++);
putuserrec(&cfg,useron.number,U_LEVEL,2,ultoa(useron.level,tmp,10));
return(0);
case CS_SET_USER_STRING:
csi->logic=LOGIC_FALSE;
if(!csi->str[0]) {
csi->ip++;
return(0);
}
switch(*(csi->ip++)) {
case USER_STRING_ALIAS:
if(!isalpha(csi->str[0]) || trashcan(csi->str,"name"))
break;
i=matchuser(&cfg,csi->str,TRUE /*sysop_alias*/);
if(i && i!=useron.number)
break;
sprintf(useron.alias,"%.*s",LEN_ALIAS,csi->str);
putuserrec(&cfg,useron.number,U_ALIAS,LEN_ALIAS,useron.alias);
putusername(&cfg,useron.number,useron.alias);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_REALNAME:
if(trashcan(csi->str,"name"))
break;
if(cfg.uq&UQ_DUPREAL
&& userdatdupe(useron.number,U_NAME,LEN_NAME,csi->str))
break;
sprintf(useron.name,"%.*s",LEN_NAME,csi->str);
putuserrec(&cfg,useron.number,U_NAME,LEN_NAME
,useron.name);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_HANDLE:
if(trashcan(csi->str,"name"))
break;
if(cfg.uq&UQ_DUPHAND
&& userdatdupe(useron.number,U_HANDLE,LEN_HANDLE,csi->str))
break;
sprintf(useron.handle,"%.*s",LEN_HANDLE,csi->str);
putuserrec(&cfg,useron.number,U_HANDLE,LEN_HANDLE
,useron.handle);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_COMPUTER:
sprintf(useron.comp,"%.*s",LEN_COMP,csi->str);
putuserrec(&cfg,useron.number,U_COMP,LEN_COMP
,useron.comp);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_NOTE:
sprintf(useron.note,"%.*s",LEN_NOTE,csi->str);
putuserrec(&cfg,useron.number,U_NOTE,LEN_NOTE
,useron.note);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_ADDRESS:
sprintf(useron.address,"%.*s",LEN_ADDRESS,csi->str);
putuserrec(&cfg,useron.number,U_ADDRESS,LEN_ADDRESS
,useron.address);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_LOCATION:
sprintf(useron.location,"%.*s",LEN_LOCATION,csi->str);
putuserrec(&cfg,useron.number,U_LOCATION,LEN_LOCATION
,useron.location);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_ZIPCODE:
sprintf(useron.zipcode,"%.*s",LEN_ZIPCODE,csi->str);
putuserrec(&cfg,useron.number,U_ZIPCODE,LEN_ZIPCODE
,useron.zipcode);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_PASSWORD:
sprintf(useron.pass,"%.*s",LEN_PASS,csi->str);
putuserrec(&cfg,useron.number,U_PASS,LEN_PASS
,useron.pass);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_BIRTHDAY:
if(!getage(&cfg,csi->str))
break;
sprintf(useron.birth,"%.*s",LEN_BIRTH,csi->str);
putuserrec(&cfg,useron.number,U_BIRTH,LEN_BIRTH
,useron.birth);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_PHONE:
if(trashcan(csi->str,"phone"))
break;
sprintf(useron.phone,"%.*s",LEN_PHONE,csi->str);
putuserrec(&cfg,useron.number,U_PHONE,LEN_PHONE
,useron.phone);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_MODEM:
sprintf(useron.modem,"%.*s",LEN_MODEM,csi->str);
putuserrec(&cfg,useron.number,U_MODEM,LEN_MODEM
,useron.phone);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_COMMENT:
sprintf(useron.comment,"%.*s",LEN_COMMENT,csi->str);
putuserrec(&cfg,useron.number,U_COMMENT,LEN_COMMENT
,useron.comment);
csi->logic=LOGIC_TRUE;
break;
case USER_STRING_NETMAIL:
sprintf(useron.netmail,"%.*s",LEN_NETMAIL,csi->str);
putuserrec(&cfg,useron.number,U_NETMAIL,LEN_NETMAIL
,useron.netmail);
csi->logic=LOGIC_TRUE;
break;
default:
errormsg(WHERE,ERR_CHK,"user string type",*(csi->ip-1));
return(0);
}
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
}
}
/*********************************/
/* Single Byte Instrcutions ONLY */
/*********************************/
switch(*(csi->ip++)) {
case CS_ONE_MORE_BYTE: /* Just one MORE byte */
switch(*(csi->ip++)) {
case CS_OFFLINE:
csi->misc|=CS_OFFLINE_EXEC;
return(0);
case CS_ONLINE:
csi->misc&=~CS_OFFLINE_EXEC;
return(0);
case CS_NEWUSER:
if(newuser())
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_LOGON:
if(logon())
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_LOGOUT:
logout();
return(0);
case CS_EXIT:
return(1);
case CS_LOOP_BEGIN:
if(csi->loops<MAX_LOOPDEPTH)
csi->loop_home[csi->loops++]=(csi->ip-1);
return(0);
case CS_BREAK_LOOP:
if(csi->loops) {
skipto(csi,CS_END_LOOP);
csi->ip+=2;
csi->loops--;
}
return(0);
case CS_END_LOOP:
case CS_CONTINUE_LOOP:
if(csi->loops)
csi->ip=csi->loop_home[csi->loops-1];
return(0);
default:
errormsg(WHERE,ERR_CHK,"one byte extended function"
,*(csi->ip-1));
return(0);
}
case CS_CRLF:
CRLF;
return(0);
case CS_CLS:
CLS;
return(0);
case CS_PAUSE:
pause();
return(0);
case CS_PAUSE_RESET:
lncntr=0;
return(0);
case CS_GETLINES:
ansi_getlines();
return(0);
case CS_HANGUP:
hangup();
return(0);
case CS_LOGKEY:
logch(csi->cmd,0);
return(0);
case CS_LOGKEY_COMMA:
logch(csi->cmd,1);
return(0);
case CS_LOGSTR:
log(csi->str);
return(0);
case CS_CHKSYSPASS:
csi->logic=!chksyspass();
return(0);
case CS_PUT_NODE:
if(getnodedat(cfg.node_num,&thisnode,true)==0)
putnodedat(cfg.node_num,&thisnode);
return(0);
case CS_SYNC:
SYNC;
return(0);
case CS_ASYNC:
ASYNC;
return(0);
case CS_GETTIMELEFT:
gettimeleft();
return(0);
case CS_RETURN:
if(!csi->rets)
return(1);
csi->ip=csi->ret[--csi->rets];
return(0);
case CS_GETKEY:
csi->cmd=getkey(K_UPPER);
return(0);
case CS_GETCHAR:
csi->cmd=getkey(0);
return(0);
case CS_INKEY:
csi->cmd=toupper(inkey(K_NONE,1));
if(csi->cmd)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_INCHAR:
csi->cmd=inkey(K_NONE,1);
if(csi->cmd)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_GETKEYE:
csi->cmd=getkey(K_UPPER);
if(csi->cmd=='/') {
outchar('/');
csi->cmd=getkey(K_UPPER);
csi->cmd|=0x80;
}
return(0);
case CS_GETFILESPEC:
if(getfilespec(csi->str))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_SAVELINE:
SAVELINE;
return(0);
case CS_RESTORELINE:
RESTORELINE;
return(0);
case CS_SELECT_SHELL:
csi->logic=select_shell() ? LOGIC_TRUE:LOGIC_FALSE;
return(0);
case CS_SET_SHELL:
csi->logic=LOGIC_TRUE;
for(i=0;i<cfg.total_shells;i++)
if(!stricmp(csi->str,cfg.shell[i]->code)
&& chk_ar(cfg.shell[i]->ar,&useron,&client))
break;
if(i<cfg.total_shells) {
useron.shell=i;
putuserrec(&cfg,useron.number,U_SHELL,8,cfg.shell[i]->code);
}
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_SELECT_EDITOR:
csi->logic=select_editor() ? LOGIC_TRUE:LOGIC_FALSE;
return(0);
case CS_SET_EDITOR:
csi->logic=LOGIC_TRUE;
for(i=0;i<cfg.total_xedits;i++)
if(!stricmp(csi->str,cfg.xedit[i]->code)
&& chk_ar(cfg.xedit[i]->ar,&useron,&client))
break;
if(i<cfg.total_xedits) {
useron.xedit=i+1;
putuserrec(&cfg,useron.number,U_XEDIT,8,cfg.xedit[i]->code);
}
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_CLEAR_ABORT:
sys_status&=~SS_ABORT;
return(0);
case CS_FINDUSER:
i=finduser(csi->str);
if(i) {
csi->logic=LOGIC_TRUE;
username(&cfg,i,csi->str);
}
else
csi->logic=LOGIC_FALSE;
return(0);
case CS_UNGETKEY:
ungetkey(csi->cmd&0x7f);
return(0);
case CS_UNGETSTR:
j=strlen(csi->str);
for(i=0;i<j;i++)
ungetkey(csi->str[i]);
return(0);
case CS_PRINTKEY:
if((csi->cmd&0x7f)>=' ')
outchar(csi->cmd&0x7f);
return(0);
case CS_PRINTSTR:
putmsg(csi->str,P_SAVEATR|P_NOABORT|P_NOATCODES);
return(0);
case CS_CMD_HOME:
if(csi->cmdrets<MAX_CMDRETS)
csi->cmdret[csi->cmdrets++]=(csi->ip-1);
return(0);
case CS_END_CMD:
if(csi->cmdrets)
csi->ip=csi->cmdret[--csi->cmdrets];
return(0);
case CS_CMD_POP:
if(csi->cmdrets)
csi->cmdrets--;
return(0);
case CS_IF_TRUE:
if(csi->logic!=LOGIC_TRUE) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_GREATER:
if(csi->logic!=LOGIC_GREATER) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_GREATER_OR_EQUAL:
if(csi->logic!=LOGIC_GREATER && csi->logic!=LOGIC_EQUAL) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_LESS:
if(csi->logic!=LOGIC_LESS) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_LESS_OR_EQUAL:
if(csi->logic!=LOGIC_LESS && csi->logic!=LOGIC_EQUAL) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_IF_FALSE:
if(csi->logic==LOGIC_TRUE) {
skipto(csi,CS_ELSEORENDIF);
csi->ip++;
}
return(0);
case CS_ELSE:
skipto(csi,CS_ENDIF);
csi->ip++;
return(0);
case CS_END_CASE:
skipto(csi,CS_END_SWITCH);
csi->misc&=~CS_IN_SWITCH;
csi->ip++;
return(0);
case CS_DEFAULT:
case CS_END_SWITCH:
csi->misc&=~CS_IN_SWITCH;
return(0);
case CS_ENDIF:
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0);
}
}
void error(char *fmt, ...) {
#else
void error(fmt, va_alist) char *fmt; va_dcl {
#endif
va_list ap;
va_init(ap, fmt);
if (firstfile != file && firstfile && *firstfile)
fprint(2, "%s: ", firstfile); /* omit */
fprint(2, "%w: ", &src);
vfprint(2, fmt, ap);
if (++errcnt >= errlimit) {
errcnt = -1;
error("too many errors\n");
exit(1);
}
va_end(ap);
}
/* expect - advance if t is tok, otherwise issue message */
int expect(tok) {
if (t == tok) {
t = gettok();
return t;
}
errcnt--;
error("syntax error; found");
printtoken();
fprint(2, " expecting `%k'\n", tok);
return 0;
}
/* fatal - issue fatal error message and exit */
int fatal(name, fmt, n) char *name, *fmt; {
*bp++ = '\n';
outflush();
error("compiler error in %s--", name);
fprint(2, fmt, n);
exit(1);
return 0;
}
/* printtoken - print current token preceeded by a space */
static void printtoken() {
switch (t) {
case ID: fprint(2, " `%s'", token); break;
case ICON:
if (*token == '\'') {
char *s;
case SCON: fprint(2, " ");
for (s = token; *s && s - token < 20; s++)
if (*s < ' ' || *s >= 0177)
fprint(2, "\\%o", *s);
else
fprint(2, "%c", *s);
if (*s)
fprint(2, " ...");
else
fprint(2, "%c", *token);
break;
} /* else fall thru */
case FCON: {
char c = *cp;
*cp = 0;
fprint(2, " `%s'", token);
*cp = c;
break;
}
case '`': case '\'': fprint(2, " \"%k\"", t); break;
default: fprint(2, " `%k'", t);
}
}
/* skipto - skip input up to tok U set, for a token where kind[t] is in set */
void skipto(tok, set) char set[]; {
int n;
char *s;
for (n = 0; t != EOI && t != tok; t = gettok()) {
if (set) {
for (s = set; *s && kind[t] != *s; s++)
;
if (kind[t] == *s)
break;
}
if (n++ == 0) {
errcnt--;
error("skipping", 0, 0, 0, 0);
}
if (n <= 8)
printtoken();
else if (n == 9)
fprint(2, " ...\n");
}
if (n > 8) {
errcnt--;
error("up to", 0, 0, 0, 0);
printtoken();
}
if (n > 0)
fprint(2, "\n");
}
/* test - check for token tok, skip to tok U set, if necessary */
void test(tok, set) char set[]; {
if (t == tok)
t = gettok();
else {
expect(tok);
skipto(tok, set);
if (t == tok)
t = gettok();
}
}
/* warning - issue warning error message */
#ifdef __STDC__
void warning(char *fmt, ...) {
#else
void warning(fmt, va_alist) char *fmt; va_dcl {
#endif
va_list ap;
va_init(ap, fmt);
if (wflag == 0) {
errcnt--; /* compensate for increment in error */
error("warning: ");
vfprint(2, fmt, ap);
}
va_end(ap);
}
int sbbs_t::exec_misc(csi_t* csi, char *path)
{
char str[512],tmp[512],buf[1025],ch,op,*p,**pp,**pp1,**pp2;
ushort w;
uint i=0,j;
long l,*lp=NULL,*lp1=NULL,*lp2=NULL;
void *vp;
struct dirent *de;
struct tm tm;
switch(*(csi->ip++)) {
case CS_VAR_INSTRUCTION:
switch(*(csi->ip++)) { /* sub-op-code stored as next byte */
case PRINT_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp || !*pp) {
lp=getintvar(csi,*(long *)csi->ip);
if(lp)
bprintf("%ld",*lp); }
else
putmsg(cmdstr(*pp,path,csi->str,buf)
,P_SAVEATR|P_NOABORT|P_NOATCODES);
csi->ip+=4;
return(0);
case VAR_PRINTF:
case VAR_PRINTF_LOCAL:
op=*(csi->ip-1);
p=format_string(this, csi);
if(op==VAR_PRINTF)
putmsg(cmdstr(p,path,csi->str,buf),P_SAVEATR|P_NOABORT|P_NOATCODES);
else {
if(online==ON_LOCAL)
eprintf(LOG_INFO,"%s",cmdstr(p,path,csi->str,buf));
else
lputs(LOG_INFO,cmdstr(p,path,csi->str,buf));
}
free(p);
return(0);
case SHOW_VARS:
bprintf("shell str=(%08lX) %s\r\n"
,csi->str,csi->str);
for(i=0;i<csi->str_vars;i++)
bprintf("local str[%d]=(%08lX) (%08lX) %s\r\n"
,i,csi->str_var_name[i]
,csi->str_var[i]
,csi->str_var[i]);
for(i=0;i<csi->int_vars;i++)
bprintf("local int[%d]=(%08lX) (%08lX) %ld\r\n"
,i,csi->int_var_name[i]
,csi->int_var[i]
,csi->int_var[i]);
for(i=0;i<global_str_vars;i++)
bprintf("global str[%d]=(%08lX) (%08lX) %s\r\n"
,i,global_str_var_name[i]
,global_str_var[i]
,global_str_var[i]);
for(i=0;i<global_int_vars;i++)
bprintf("global int[%d]=(%08lX) (%08lX) %ld\r\n"
,i,global_int_var_name[i]
,global_int_var[i]
,global_int_var[i]);
return(0);
case DEFINE_STR_VAR:
if(getstrvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
csi->str_vars++;
csi->str_var=(char **)realloc(csi->str_var
,sizeof(char *)*csi->str_vars);
csi->str_var_name=(long *)realloc(csi->str_var_name
,sizeof(long)*csi->str_vars);
if(csi->str_var==NULL
|| csi->str_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local str var"
,sizeof(char *)*csi->str_vars);
if(csi->str_var_name) {
free(csi->str_var_name);
csi->str_var_name=0; }
if(csi->str_var) {
free(csi->str_var);
csi->str_var=0; }
csi->str_vars=0; }
else {
csi->str_var_name[csi->str_vars-1]=*(long *)csi->ip;
csi->str_var[csi->str_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_INT_VAR:
if(getintvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
csi->int_vars++;
csi->int_var=(long *)realloc(csi->int_var
,sizeof(char *)*csi->int_vars);
csi->int_var_name=(long *)realloc(csi->int_var_name
,sizeof(long)*csi->int_vars);
if(csi->int_var==NULL
|| csi->int_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local int var"
,sizeof(char *)*csi->int_vars);
if(csi->int_var_name) {
free(csi->int_var_name);
csi->int_var_name=0; }
if(csi->int_var) {
free(csi->int_var);
csi->int_var=0; }
csi->int_vars=0; }
else {
csi->int_var_name[csi->int_vars-1]=*(long *)csi->ip;
csi->int_var[csi->int_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_GLOBAL_STR_VAR:
if(getstrvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
global_str_vars++;
global_str_var=(char **)realloc(global_str_var
,sizeof(char *)*global_str_vars);
global_str_var_name=(long *)realloc(global_str_var_name
,sizeof(long)*global_str_vars);
if(global_str_var==NULL
|| global_str_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"global str var"
,sizeof(char *)*global_str_vars);
if(global_str_var_name) {
free(global_str_var_name);
global_str_var_name=0; }
if(global_str_var) {
free(global_str_var);
global_str_var=0; }
global_str_vars=0; }
else {
global_str_var_name[global_str_vars-1]=
*(long *)csi->ip;
global_str_var[global_str_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case DEFINE_GLOBAL_INT_VAR:
if(getintvar(csi,*(long *)csi->ip)) {
csi->ip+=4;
return(0); }
global_int_vars++;
global_int_var=(long *)realloc(global_int_var
,sizeof(char *)*global_int_vars);
global_int_var_name=(long *)realloc(global_int_var_name
,sizeof(long)*global_int_vars);
if(global_int_var==NULL
|| global_int_var_name==NULL) { /* REALLOC failed */
errormsg(WHERE,ERR_ALLOC,"local int var"
,sizeof(char *)*global_int_vars);
if(global_int_var_name) {
free(global_int_var_name);
global_int_var_name=0; }
if(global_int_var) {
free(global_int_var);
global_int_var=0; }
global_int_vars=0; }
else {
global_int_var_name[global_int_vars-1]
=*(long *)csi->ip;
global_int_var[global_int_vars-1]=0; }
csi->ip+=4; /* Skip variable name */
return(0);
case SET_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp)
*pp=copystrvar(csi,*pp
,cmdstr((char *)csi->ip,path,csi->str,buf));
while(*(csi->ip++)); /* Find NULL */
return(0);
case SET_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(lp)
*lp=*(long *)csi->ip;
csi->ip+=4; /* Skip value */
return(0);
case COMPARE_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp)
csi->logic=stricmp(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf));
else { /* Uninitialized str var */
if(*(csi->ip)==0) /* Blank static str */
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE; }
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRSTR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp && strstr(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf)))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRNCMP_VAR:
i=*csi->ip++;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(pp && *pp)
csi->logic=strnicmp(*pp
,cmdstr((char *)csi->ip,path,csi->str,buf),i);
else
csi->logic=LOGIC_FALSE;
while(*(csi->ip++)); /* Find NULL */
return(0);
case STRNCMP_VARS:
i=*csi->ip++;
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2)
csi->logic=strnicmp(*pp1,*pp2,i);
else
csi->logic=LOGIC_FALSE;
return(0);
case STRSTR_VARS:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2 && strstr(*pp1,*pp2))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case COMPARE_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
l=*(long *)csi->ip;
csi->ip+=4; /* Skip static value */
if(!lp) { /* Unknown variable */
csi->logic=LOGIC_FALSE;
return(0); }
if(*lp>l)
csi->logic=LOGIC_GREATER;
else if(*lp<l)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0);
case COMPARE_VARS:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(((!pp1 || !*pp1) && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
if(pp1 && pp2) /* Both unitialized or blank */
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0); }
if(pp1) { /* ASCII */
if(!pp2) {
ultoa(*lp2,tmp,10);
csi->logic=stricmp(*pp1,tmp); }
else
csi->logic=stricmp(*pp1,*pp2);
return(0); }
/* Binary */
if(!lp2) {
l=strtol(*pp2,0,0);
if(*lp1>l)
csi->logic=LOGIC_GREATER;
else if(*lp1<l)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0); }
if(*lp1>*lp2)
csi->logic=LOGIC_GREATER;
else if(*lp1<*lp2)
csi->logic=LOGIC_LESS;
else
csi->logic=LOGIC_EQUAL;
return(0);
case COPY_VAR:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if((!pp1 && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(pp1) { /* ASCII */
if(!pp2)
ultoa(*lp2,tmp,10);
else
strcpy(tmp,*pp2);
*pp1=copystrvar(csi,*pp1,tmp);
return(0); }
if(!lp2)
*lp1=strtol(*pp2,0,0);
else
*lp1=*lp2;
return(0);
case SWAP_VARS:
lp1=lp2=0;
pp1=getstrvar(csi,*(long *)csi->ip);
if(!pp1)
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
if(!pp2)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
if(((!pp1 || !*pp1) && !lp1)
|| ((!pp2 || !*pp2) && !lp2)) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(pp1) { /* ASCII */
if(!pp2) {
if(!strnicmp(*pp2,"0x",2)) {
l=strtol((*pp1)+2,0,16);
ultoa(*lp2,tmp,16); }
else {
l=atol(*pp1);
ultoa(*lp2,tmp,10); }
*pp1=copystrvar(csi,*pp1,tmp);
*lp2=l; }
else {
p=*pp1;
*pp1=*pp2;
*pp2=p; }
return(0); }
/* Binary */
if(!lp2) {
if(!strnicmp(*pp2,"0x",2)) {
l=strtol((*pp2)+2,0,16);
ultoa(*lp1,tmp,16); }
else {
l=atol(*pp2);
ultoa(*lp1,tmp,10); }
*pp2=copystrvar(csi,*pp2,tmp);
*lp1=l; }
else {
l=*lp1;
*lp1=*lp2;
*lp2=l; }
return(0);
case CAT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
strcpy(tmp,(char *)csi->ip);
while(*(csi->ip++));
if(pp && *pp)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp==sysvar_p[i])
break;
if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
if(*pp)
*pp=(char *)realloc(*pp,strlen(*pp)+strlen(tmp)+1);
else
*pp=(char *)realloc(*pp,strlen(tmp)+1); }
if(pp && *pp)
strcat(*pp,tmp);
return(0);
case CAT_STR_VARS:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip dest variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip source variable name */
/* Concatenate an int var to a str var (as char) */
if(pp2==NULL) {
lp=getintvar(csi,*(long *)(csi->ip-4));
if(lp==NULL) {
csi->logic=LOGIC_FALSE;
return(0);
}
pp=pp1;
tmp[0]=(uchar)*lp;
tmp[1]=0;
if(pp && *pp)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp==sysvar_p[i])
break;
if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
if(*pp)
*pp=(char *)realloc(*pp,strlen(*pp)+strlen(tmp)+1);
else
*pp=(char *)realloc(*pp,strlen(tmp)+1); }
if(pp && *pp)
strcat(*pp,tmp);
return(0);
}
if(!pp1 || !pp2 || !*pp2) {
csi->logic=LOGIC_FALSE;
return(0); }
csi->logic=LOGIC_TRUE;
if(*pp1)
for(i=0;i<MAX_SYSVARS;i++)
if(*pp1==sysvar_p[i])
break;
if(*pp1!=csi->str && (!*pp1 || i==MAX_SYSVARS)) {
if(*pp1)
*pp1=(char *)realloc(*pp1,strlen(*pp1)+strlen(*pp2)+1);
else
*pp1=(char *)realloc(*pp1,strlen(*pp2)+1); }
strcat(*pp1,*pp2);
return(0);
case FORMAT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
p=format_string(this, csi);
cmdstr(p,path,csi->str,str);
if(pp)
*pp=copystrvar(csi,*pp,str);
free(p);
return(0);
case FORMAT_TIME_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
strcpy(str,(char *)csi->ip);
while(*(csi->ip++)); /* Find NULL */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && lp) {
if(localtime_r((time_t *)lp,&tm)!=NULL) {
strftime(buf,128,str,&tm);
*pp=copystrvar(csi,*pp,buf);
}
}
return(0);
case TIME_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
strcpy(str,timestr((time_t *)lp));
*pp=copystrvar(csi,*pp,str); }
return(0);
case DATE_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
unixtodstr(&cfg,*lp,str);
*pp=copystrvar(csi,*pp,str); }
return(0);
case SECOND_STR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip str variable name */
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip int variable name */
if(pp && lp) {
sectostr(*lp,str);
*pp=copystrvar(csi,*pp,str); }
return(0);
case STRUPR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strupr(*pp);
return(0);
case STRLWR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strlwr(*pp);
return(0);
case TRUNCSP_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
truncsp(*pp);
return(0);
case STRIP_CTRL_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
strip_ctrl(*pp);
return(0);
case ADD_INT_VAR:
case SUB_INT_VAR:
case MUL_INT_VAR:
case DIV_INT_VAR:
case MOD_INT_VAR:
case AND_INT_VAR:
case OR_INT_VAR:
case NOT_INT_VAR:
case XOR_INT_VAR:
i=*(csi->ip-1);
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
if(!lp)
return(0);
switch(i) {
case ADD_INT_VAR:
*lp+=l;
break;
case SUB_INT_VAR:
*lp-=l;
break;
case MUL_INT_VAR:
*lp*=l;
break;
case DIV_INT_VAR:
*lp/=l;
break;
case MOD_INT_VAR:
*lp%=l;
break;
case AND_INT_VAR:
*lp&=l;
break;
case OR_INT_VAR:
*lp|=l;
break;
case NOT_INT_VAR:
*lp&=~l;
break;
case XOR_INT_VAR:
*lp^=l;
break; }
return(0);
case COMPARE_ANY_BITS:
case COMPARE_ALL_BITS:
i=*(csi->ip-1);
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(!lp)
return(0);
if(i==COMPARE_ANY_BITS) {
if(((*lp)&l)!=0)
csi->logic=LOGIC_TRUE;
} else {
if(((*lp)&l)==l)
csi->logic=LOGIC_TRUE;
}
return(0);
case ADD_INT_VARS:
case SUB_INT_VARS:
case MUL_INT_VARS:
case DIV_INT_VARS:
case MOD_INT_VARS:
case AND_INT_VARS:
case OR_INT_VARS:
case NOT_INT_VARS:
case XOR_INT_VARS:
i=*(csi->ip-1);
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
if(!lp2) {
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp || !*pp)
return(0);
l=strtol(*pp,0,0); }
else
l=*lp2;
csi->ip+=4;
if(!lp1)
return(0);
switch(i) {
case ADD_INT_VARS:
*lp1+=l;
break;
case SUB_INT_VARS:
*lp1-=l;
break;
case MUL_INT_VARS:
*lp1*=l;
break;
case DIV_INT_VARS:
*lp1/=l;
break;
case MOD_INT_VARS:
*lp1%=l;
break;
case AND_INT_VARS:
*lp1&=l;
break;
case OR_INT_VARS:
*lp1|=l;
break;
case NOT_INT_VARS:
*lp1&=~l;
break;
case XOR_INT_VARS:
*lp1^=l;
break; }
return(0);
case RANDOM_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
l=*(long *)csi->ip;
csi->ip+=4;
if(lp)
*lp=sbbs_random(l);
return(0);
case TIME_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp)
*lp=time(NULL);
return(0);
case DATE_STR_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && pp && *pp)
*lp=dstrtounix(&cfg,*pp);
return(0);
case STRLEN_INT_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=strlen(*pp);
else
*lp=0; }
return(0);
case CRC16_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=crc16(*pp,0);
else
*lp=0; }
return(0);
case CRC32_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=crc32(*pp,0);
else
*lp=0; }
return(0);
case CHKSUM_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
*lp=0;
if(pp && *pp) {
i=0;
while(*((*pp)+i))
*lp+=(uchar)*((*pp)+(i++)); } }
return(0);
case FLENGTH_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=flength(*pp);
else
*lp=0; }
return(0);
case FTIME_TO_INT:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=fdate(*pp);
else
*lp=0; }
return(0);
case CHARVAL_TO_INT:
case COPY_FIRST_CHAR: // duplicate functionality - doh!
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=**pp;
else
*lp=0; }
return(0);
case GETSTR_VAR:
case GETLINE_VAR:
case GETNAME_VAR:
case GETSTRUPR_VAR:
case GETSTR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(csi->ip++);
csi->logic=LOGIC_FALSE;
switch(*(csi->ip-6)) {
case GETNAME_VAR:
getstr(buf,i,K_UPRLWR);
break;
case GETSTRUPR_VAR:
getstr(buf,i,K_UPPER);
break;
case GETLINE_VAR:
getstr(buf,i,K_LINE);
break;
case GETSTR_MODE:
l=*(long *)csi->ip;
csi->ip+=4;
if(l&K_EDIT) {
if(pp && *pp)
strcpy(buf,*pp);
else
buf[0]=0; }
getstr(buf,i,l);
break;
default:
getstr(buf,i,0); }
if(sys_status&SS_ABORT)
return(0);
if(pp) {
*pp=copystrvar(csi,*pp,buf);
csi->logic=LOGIC_TRUE; }
return(0);
case GETNUM_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)csi->ip;
csi->ip+=2;
csi->logic=LOGIC_FALSE;
l=getnum(i);
if(!pp && !lp)
return(0);
if(pp) {
if(l<=0)
str[0]=0;
else
ultoa(l,str,10);
*pp=copystrvar(csi,*pp,str);
csi->logic=LOGIC_TRUE;
return(0); }
if(lp) {
*lp=l;
csi->logic=LOGIC_TRUE; }
return(0);
case SHIFT_STR_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(csi->ip++);
if(!pp || !*pp)
return(0);
if(strlen(*pp)>=i)
memmove(*pp,*pp+i,strlen(*pp)+1);
return(0);
case SHIFT_TO_FIRST_CHAR:
case SHIFT_TO_LAST_CHAR:
i=*(csi->ip-1);
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
ch=*(csi->ip++);
csi->logic=LOGIC_FALSE;
if(!pp || !*pp)
return(0);
if(i==SHIFT_TO_FIRST_CHAR)
p=strchr(*pp,ch);
else /* _TO_LAST_CHAR */
p=strrchr(*pp,ch);
if(p==NULL)
return(0);
csi->logic=LOGIC_TRUE;
i=p-*pp;
if(i>0)
memmove(*pp,*pp+i,strlen(p)+1);
return(0);
case CHKFILE_VAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && fexistcase(cmdstr(*pp,path,csi->str,buf)))
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case PRINTFILE_VAR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)(csi->ip);
csi->ip+=2;
if(pp && *pp)
printfile(*pp,i);
return(0);
case PRINTTAIL_VAR_MODE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
i=*(short *)(csi->ip);
csi->ip+=2;
j=*csi->ip;
csi->ip++;
if(pp && *pp)
printtail(*pp,j,i);
return(0);
case TELNET_GATE_VAR:
l=*(ulong *)(csi->ip); // Mode
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
telnet_gate(*pp,l);
return(0);
case TELNET_GATE_STR:
l=*(ulong *)(csi->ip); // Mode
csi->ip+=4;
strcpy(str,(char *)csi->ip);
while(*(csi->ip++)); /* Find NULL */
telnet_gate(str,l);
return(0);
case COPY_CHAR:
pp=getstrvar(csi,*(long *)csi->ip);
if(pp==NULL)
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp==NULL && lp!=NULL)
*lp=csi->cmd;
else if(pp!=NULL) {
sprintf(tmp,"%c",csi->cmd);
*pp=copystrvar(csi,*pp,tmp);
}
return(0);
case COMPARE_FIRST_CHAR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
ch=*(csi->ip++); /* char const */
if(pp==NULL || *pp==NULL)
csi->logic=LOGIC_FALSE;
else {
if(**pp==ch)
csi->logic=LOGIC_EQUAL;
else if(**pp>ch)
csi->logic=LOGIC_GREATER;
else
csi->logic=LOGIC_LESS;
}
return(0);
case SEND_FILE_VIA:
case RECEIVE_FILE_VIA:
j=*(csi->ip-1);
ch=*(csi->ip++); /* Protocol */
cmdstr((char *)csi->ip,csi->str,csi->str,str);
while(*(csi->ip++)); /* Find NULL */
for(i=0;i<cfg.total_prots;i++)
if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
break;
csi->logic=LOGIC_FALSE;
if(i<cfg.total_prots)
if(protocol(cfg.prot[i],j==SEND_FILE_VIA ? XFER_DOWNLOAD : XFER_UPLOAD
,str,str,true)==0)
csi->logic=LOGIC_TRUE;
return(0);
case SEND_FILE_VIA_VAR:
case RECEIVE_FILE_VIA_VAR:
j=*(csi->ip-1);
ch=*(csi->ip++); /* Protocol */
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
for(i=0;i<cfg.total_prots;i++)
if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
break;
csi->logic=LOGIC_FALSE;
if(!pp || !(*pp))
return(0);
if(i<cfg.total_prots)
if(protocol(cfg.prot[i]
,j==SEND_FILE_VIA_VAR ? XFER_DOWNLOAD : XFER_UPLOAD
,*pp,*pp,true)==0)
csi->logic=LOGIC_TRUE;
return(0);
case MATCHUSER:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
if(pp && *pp)
*lp=matchuser(&cfg, *pp, TRUE /*sysop_alias*/);
else
*lp=0;
}
return(0);
default:
errormsg(WHERE,ERR_CHK,"var sub-instruction",*(csi->ip-1));
return(0); }
case CS_FIO_FUNCTION:
switch(*(csi->ip++)) { /* sub-op-code stored as next byte */
case FIO_OPEN:
case FIO_OPEN_VAR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
w=*(ushort *)csi->ip;
csi->ip+=2;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-7)==FIO_OPEN) {
cmdstr((char *)csi->ip,path,csi->str,str);
while(*(csi->ip++)); } /* skip filename */
else {
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!pp || !*pp)
return(0);
strcpy(str,*pp); }
if(csi->files>=MAX_FOPENS)
return(0);
if(lp) {
/* Access flags are not cross-platform, so convert */
i=0;
if(w&0x001) i|=O_RDONLY;
if(w&0x002) i|=O_WRONLY;
if(w&0x004) i|=O_RDWR;
if(w&0x040) i|=O_DENYNONE;
if(w&0x100) i|=O_CREAT;
if(w&0x200) i|=O_TRUNC;
if(w&0x400) i|=O_EXCL;
if(w&0x800) i|=O_APPEND;
*lp=(long)fnopen((int *)&j,str,i);
if(*lp) {
for(i=0;i<csi->files;i++)
if(!csi->file[i])
break;
csi->file[i]=(FILE *)*lp;
if(i==csi->files)
csi->files++;
csi->logic=LOGIC_TRUE; } }
return(0);
case FIO_CLOSE:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && *lp) {
csi->logic=fclose((FILE *)*lp);
for(i=0;i<csi->files;i++)
if(csi->file[i]==(FILE *)*lp)
csi->file[i]=0;
*lp=0;
}
else
csi->logic=LOGIC_FALSE;
return(0);
case FIO_FLUSH:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && *lp)
csi->logic=fflush((FILE *)*lp);
else
csi->logic=LOGIC_FALSE;
return(0);
case FIO_READ:
case FIO_READ_VAR:
lp1=getintvar(csi,*(long *)csi->ip); /* Handle */
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-9)==FIO_READ) {
i=*(short *)csi->ip;
csi->ip+=2; /* Length */ }
else { /* FIO_READ_VAR */
vp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!vp)
return(0);
i=*(short *)vp; }
if(i>sizeof(buf)-1)
i=sizeof(buf)-1;
if(!lp1 || !(*lp1) || (!pp && !lp2))
return(0);
if(pp) {
if(i<1) {
if(*pp && **pp)
i=strlen(*pp);
else
i=128; }
if((j=fread(buf,1,i,(FILE *)*lp1))==i)
csi->logic=LOGIC_TRUE;
buf[j]=0;
if(csi->etx) {
p=strchr(buf,csi->etx);
if(p) *p=0; }
*pp=copystrvar(csi,*pp,buf); }
else {
*lp2=0;
if(i>4 || i<1) i=4;
if(fread(lp2,1,i,(FILE *)*lp1)==i)
csi->logic=LOGIC_TRUE; }
return(0);
case FIO_READ_LINE:
lp1=getintvar(csi,*(long *)csi->ip); /* Handle */
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(!lp1 || !(*lp1) || feof((FILE *)*lp1) || (!pp && !lp2))
return(0);
csi->logic=LOGIC_TRUE;
for(i=0;i<sizeof(buf)-1;i++) {
if(!fread(buf+i,1,1,(FILE *)*lp1))
break;
if(*(buf+i)==LF) {
i++;
break; } }
buf[i]=0;
if(csi->etx) {
p=strchr(buf,csi->etx);
if(p) *p=0; }
if(pp)
*pp=copystrvar(csi,*pp,buf);
else
*lp2=strtol(buf,0,0);
return(0);
case FIO_WRITE:
case FIO_WRITE_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
if(!pp)
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-9)==FIO_WRITE) {
i=*(short *)csi->ip;
csi->ip+=2; /* Length */ }
else { /* FIO_WRITE_VAR */
vp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!vp)
return(0);
i=*(short *)vp; }
if(i>sizeof(buf)-1)
i=sizeof(buf)-1;
if(!lp1 || !(*lp1) || (!pp && !lp2) || (pp && !*pp))
return(0);
if(pp) {
j=strlen(*pp);
if(i<1) i=j;
if(j>i) j=i;
if(fwrite(*pp,1,j,(FILE *)*lp1)!=j)
csi->logic=LOGIC_FALSE;
else {
if(j<i) {
memset(buf,csi->etx,i-j);
fwrite(buf,1,i-j,(FILE *)*lp1);
}
csi->logic=LOGIC_TRUE;
}
} else {
if(i<1 || i>4) i=4;
if(fwrite(lp2,1,i,(FILE *)*lp1)==i)
csi->logic=LOGIC_TRUE; }
return(0);
case FIO_GET_LENGTH:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=filelength(fileno((FILE *)*lp1));
return(0);
case FIO_GET_TIME:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=filetime(fileno((FILE *)*lp1));
return(0);
case FIO_SET_TIME:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
#if 0 /* ftime */
if(lp1 && *lp1 && lp2) {
ft=unixtoftime(*lp2);
setftime(fileno((FILE *)*lp1),&ft); }
#endif
return(0);
case FIO_EOF:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(lp && *lp)
if(ftell((FILE *)*lp)>=filelength(fileno((FILE *)*lp)))
csi->logic=LOGIC_TRUE;
return(0);
case FIO_GET_POS:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp1 && *lp1 && lp2)
*lp2=ftell((FILE *)*lp1);
return(0);
case FIO_SEEK:
case FIO_SEEK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_SEEK) {
l=*(long *)csi->ip;
csi->ip+=4; }
else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2) {
csi->ip+=2;
return(0); }
l=*lp2; }
i=*(short *)csi->ip;
csi->ip+=2;
if(lp1 && *lp1)
if(fseek((FILE *)*lp1,l,i)!=-1)
csi->logic=LOGIC_TRUE;
return(0);
case FIO_LOCK:
case FIO_LOCK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_LOCK) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2;
}
if(lp1 && *lp1) {
fflush((FILE *)*lp1);
csi->logic=!lock(fileno((FILE *)*lp1),ftell((FILE*)*lp1),l);
}
return(0);
case FIO_UNLOCK:
case FIO_UNLOCK_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_UNLOCK) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2;
}
if(lp1 && *lp1) {
fflush((FILE *)*lp1);
csi->logic=!unlock(fileno((FILE *)*lp1),ftell((FILE*)*lp1),l);
}
return(0);
case FIO_SET_LENGTH:
case FIO_SET_LENGTH_VAR:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(*(csi->ip-5)==FIO_SET_LENGTH) {
l=*(long *)csi->ip;
csi->ip+=4;
} else {
lp2=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp2)
return(0);
l=*lp2; }
if(lp1 && *lp1)
csi->logic=chsize(fileno((FILE *)*lp1),l);
return(0);
case FIO_PRINTF:
lp1=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
p=format_string(this, csi);
if(lp1 && *lp1) {
cmdstr(p,path,csi->str,str);
fwrite(str,1,strlen(str),(FILE *)*lp1);
}
free(p);
return(0);
case FIO_SET_ETX:
csi->etx=*(csi->ip++);
return(0);
case REMOVE_FILE:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && remove(*pp)==0)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
case RENAME_FILE:
case COPY_FILE:
case MOVE_FILE:
pp1=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4; /* Skip variable name */
pp2=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp1 && *pp1 && pp2 && *pp2)
switch(*(csi->ip-9)) {
case RENAME_FILE:
csi->logic=rename(*pp1,*pp2);
break;
case COPY_FILE:
csi->logic=mv(*pp1,*pp2,1);
break;
case MOVE_FILE:
csi->logic=mv(*pp1,*pp2,0);
break; }
else
csi->logic=LOGIC_FALSE;
return(0);
case GET_FILE_ATTRIB:
case SET_FILE_ATTRIB:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp && lp) {
if(*(csi->ip-9)==GET_FILE_ATTRIB)
*lp=getfattr(*pp);
else
*lp=CHMOD(*pp,(int)*lp);
}
return(0);
case MAKE_DIR:
case REMOVE_DIR:
case CHANGE_DIR:
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(pp && *pp)
switch(*(csi->ip-5)) {
case MAKE_DIR:
csi->logic=MKDIR(*pp);
break;
case REMOVE_DIR:
csi->logic=rmdir(*pp);
break;
case CHANGE_DIR:
csi->logic=chdir(*pp);
break; }
else
csi->logic=LOGIC_FALSE;
return(0);
case OPEN_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(pp && *pp && lp) {
*lp=(long)opendir((char *)*pp);
if(*lp)
csi->logic=LOGIC_TRUE; }
return(0);
case READ_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
pp=getstrvar(csi,*(long *)csi->ip);
csi->ip+=4;
csi->logic=LOGIC_FALSE;
if(pp && lp) {
de=readdir((DIR *)(*lp));
if(de!=NULL) {
csi->logic=LOGIC_TRUE;
*pp=copystrvar(csi,*pp,de->d_name); } }
return(0);
case REWIND_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp) {
rewinddir((DIR *)(*lp));
csi->logic=LOGIC_TRUE; }
else
csi->logic=LOGIC_FALSE;
return(0);
case CLOSE_DIR:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(lp && closedir((DIR *)(*lp))==0)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
return(0);
default:
errormsg(WHERE,ERR_CHK,"fio sub-instruction",*(csi->ip-1));
return(0); }
case CS_NET_FUNCTION:
return(exec_net(csi));
case CS_SWITCH:
lp=getintvar(csi,*(long *)csi->ip);
csi->ip+=4;
if(!lp) {
skipto(csi,CS_END_SWITCH);
csi->ip++; }
else {
csi->misc|=CS_IN_SWITCH;
csi->switch_val=*lp; }
return(0);
case CS_CASE:
l=*(long *)csi->ip;
csi->ip+=4;
if(csi->misc&CS_IN_SWITCH && csi->switch_val!=l)
skipto(csi,CS_NEXTCASE);
else
csi->misc&=~CS_IN_SWITCH;
return(0);
case CS_COMPARE_ARS:
i=*(csi->ip++); /* Length of ARS stored as byte before ARS */
csi->logic=!chk_ar(csi->ip,&useron);
csi->ip+=i;
return(0);
case CS_TOGGLE_USER_MISC:
useron.misc^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_MISC,8,ultoa(useron.misc,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_MISC:
if((useron.misc&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_TOGGLE_USER_CHAT:
useron.chat^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_CHAT,8,ultoa(useron.chat,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_CHAT:
if((useron.chat&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_TOGGLE_USER_QWK:
useron.qwk^=*(ulong *)csi->ip;
putuserrec(&cfg,useron.number,U_QWK,8,ultoa(useron.qwk,tmp,16));
csi->ip+=4;
return(0);
case CS_COMPARE_USER_QWK:
if((useron.qwk&*(ulong *)csi->ip)==*(ulong *)csi->ip)
csi->logic=LOGIC_TRUE;
else
csi->logic=LOGIC_FALSE;
csi->ip+=4;
return(0);
case CS_REPLACE_TEXT:
i=*(ushort *)csi->ip;
csi->ip+=2;
i--;
if(i>=TOTAL_TEXT) {
errormsg(WHERE,ERR_CHK,"replace text #",i);
while(*(csi->ip++)); /* Find NULL */
return(0); }
if(text[i]!=text_sav[i] && text[i]!=nulstr)
free(text[i]);
j=strlen(cmdstr((char *)csi->ip,path,csi->str,buf));
if(!j)
text[i]=nulstr;
else
text[i]=(char *)malloc(j+1);
if(!text[i]) {
errormsg(WHERE,ERR_ALLOC,"replacement text",j);
while(*(csi->ip++)); /* Find NULL */
text[i]=text_sav[i];
return(0); }
if(j)
strcpy(text[i],buf);
while(*(csi->ip++)); /* Find NULL */
return(0);
case CS_USE_INT_VAR: // Self-modifying code!
pp=getstrvar(csi,*(long *)csi->ip);
if(pp && *pp)
l=strtol(*pp,0,0);
else {
lp=getintvar(csi,*(long *)csi->ip);
if(lp)
l=*lp;
else
l=0; }
csi->ip+=4; // Variable
i=*(csi->ip++); // Offset
if(i<1 || csi->ip+1+i>=csi->cs+csi->length) {
errormsg(WHERE,ERR_CHK,"offset",i);
csi->ip++;
return(0); }
switch(*(csi->ip++)) { // Length
case sizeof(char):
*(csi->ip+i)=(char)l;
break;
case sizeof(short):
*((short *)(csi->ip+i))=(short)l;
break;
case sizeof(long):
*((long *)(csi->ip+i))=l;
break;
default:
errormsg(WHERE,ERR_CHK,"length",*(csi->ip-1));
break; }
return(0);
default:
errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
return(0); }
}
void
exec_runserver(int ppid)
{
int i, j;
char *s, *p, *q, *name;
char params[] = "";
char server[0x20];
char *srv, *to;
int timeout = 30000;
l4_threadid_t tid;
struct t_os2process *proc; // server PTDA/proc
for (i = 0; i < 5; i++)
{
name = (char *)type[i].name;
io_log("name=%s\n", name);
if (!strcmp(name, "RUNSERVER"))
{
for (j = 0; j < type[i].ip; j++)
{
s = type[i].sp[j].string;
p = getcmd (s);
s = skipto(0, s);
q = strdup(p);
// create proc/PTDA structure
proc = PrcCreate(ppid, // ppid
basename(q), // pPrg
NULL, // pArg
NULL); // pEnv
free(q);
l4os3_exec (p, params, &tid);
io_log("started task: %x.%x\n", tid.id.task, tid.id.lthread);
/* set task number */
proc->task = tid;
if (strstr(p, "os2fs"))
{
io_log("os2fs started\n");
if (!names_waitfor_name("os2fs", &fs, 30000))
{
io_log("Can't find os2fs on name server!\n");
return;
}
}
srv = getcmd (skipto(0, strstr(s, "-LOOKFOR")));
/* skip spaces and quotes */
for (p = srv; *p == '"' || *p == ' '; p++) ;
srv = p;
for (p = srv + strlen(srv) - 1; *p == '"' || *p == ' '; p--) *p = '\0';
strcpy (server, srv);
to = getcmd (skipto(0, strstr(s, "-TIMEOUT")));
timeout = atoi (to);
io_log("LOOKFOR:%s, TIMEOUT:%d\n", server, timeout);
if (*server && !names_waitfor_name(server, &tid, timeout))
{
io_log("Timeout waiting for %s\n", server);
return;
}
}
io_log("Server %s started\n", server);
}
}
return;
}
iterator::iterator(uint64_t start, uint64_t stop_hint)
{
skipto(start, stop_hint);
}
static int getch(char endch)
{
register char d;
retry:
d = readc();
if (!subchar(d))
return (d);
if (d == DOLLAR) {
register int c;
if ((c = readc(), dolchar(c))) {
NAMPTR n = (NAMPTR) NIL;
int dolg = 0;
BOOL bra;
register const char *argp;
register const char *v;
CHAR idb[2];
char *id = idb;
if (bra = (c == BRACE))
c = readc();
if (letter(c)) {
argp = (STRING) relstak();
while (alphanum(c)) {
pushstak(c);
c = readc();
}
zerostak();
n = lookup(absstak(argp));
setstak(argp);
v = n->namval;
id = (char *)n->namid;
peekc = c | MARK;;
} else if (digchar(c)) {
*id = c;
idb[1] = 0;
if (astchar(c)) {
dolg = 1;
c = '1';
}
c -= '0';
v = ((c == 0) ? (const char *)cmdadr :
(c <= dolc) ? dolv[c]
: (dolg = 0, NULL));
} else if (c == '$') {
v = pidadr;
} else if (c == '!') {
v = pcsadr;
} else if (c == '#') {
v = dolladr;
} else if (c == '?') {
v = exitadr;
} else if (c == '-') {
v = flagadr;
} else if (bra) {
error(badsub);
} else {
goto retry;
}
c = readc();
if (!defchar(c) && bra)
error(badsub);
argp = 0;
if (bra) {
if (c != '}') {
argp = (STRING) relstak();
if ((v == 0) ^ (setchar(c)))
copyto('}');
else
skipto('}');
argp = absstak(argp);
}
} else {
peekc = c | MARK;
c = 0;
}
if (v) {
if (c != '+') {
for (;;) {
while (c = *v++)
pushstak(c | quote);
if (dolg == 0 || (++dolg > dolc))
break;
else {
v = dolv[dolg];
pushstak(SP | (*id == '*' ? quote : 0));
}
}
}
} else if (argp) {
if (c == '?') {
failed(id,
*argp ? argp : badparam);
} else if (c == '=') {
if (n)
assign(n, argp);
else
error(badsub);
}
} else if (flags & setflg) {
failed(id, badparam);
}
goto retry;
} else {
peekc = c | MARK;
}
} else if (d == endch) {
return (d);
} else if (d == SQUOTE) {
comsubst();
goto retry;
} else if (d == DQUOTE) {
quoted++;
quote ^= QUOTE;
goto retry;
}
return d;
}
