int sys_stat(void)
{
char *path, *buf;
argstr(0, &path);
argstr(1, &buf);
return sf_stat(path, (struct sfs_stat *)buf);
}
/*
* Perform expansions on an argument, placing the resulting list of arguments
* in arglist. Parameter expansion, command substitution and arithmetic
* expansion are always performed; additional expansions can be requested
* via flag (EXP_*).
* The result is left in the stack string.
* When arglist is NULL, perform here document expansion.
*
* When doing something that may cause this to be re-entered, make sure
* the stack string is empty via grabstackstr() and do not assume expdest
* remains valid.
*/
void
expandarg(union node *arg, struct arglist *arglist, int flag)
{
struct worddest exparg;
struct nodelist *argbackq;
if (fflag)
flag &= ~EXP_GLOB;
argbackq = arg->narg.backquote;
exparg.list = arglist;
exparg.state = WORD_IDLE;
STARTSTACKSTR(expdest);
argstr(arg->narg.text, &argbackq, flag, &exparg);
if (arglist == NULL) {
STACKSTRNUL(expdest);
return; /* here document expanded */
}
if ((flag & EXP_SPLIT) == 0 || expdest != stackblock() ||
exparg.state == WORD_QUOTEMARK) {
STPUTC('\0', expdest);
if (flag & EXP_SPLIT) {
if (flag & EXP_GLOB)
expandmeta(grabstackstr(expdest), exparg.list);
else
appendarglist(exparg.list, grabstackstr(expdest));
}
}
if ((flag & EXP_SPLIT) == 0)
appendarglist(arglist, grabstackstr(expdest));
}
/*
* Expand arithmetic expression.
* Note that flag is not required as digits never require CTLESC characters.
*/
static char *
expari(char *p)
{
char *q, *start;
arith_t result;
int begoff;
int quoted;
int adj;
quoted = *p++ == '"';
begoff = expdest - stackblock();
p = argstr(p, 0);
removerecordregions(begoff);
STPUTC('\0', expdest);
start = stackblock() + begoff;
q = grabstackstr(expdest);
result = arith(start);
ungrabstackstr(q, expdest);
start = stackblock() + begoff;
adj = start - expdest;
STADJUST(adj, expdest);
CHECKSTRSPACE((int)(DIGITS(result) + 1), expdest);
fmtstr(expdest, DIGITS(result), ARITH_FORMAT_STR, result);
adj = strlen(expdest);
STADJUST(adj, expdest);
if (!quoted)
recordregion(begoff, expdest - stackblock(), 0);
return p;
}
int sys_exec(void)
{
char *path, *argv[MAXARGS];
uint32_t uarg, uargv, i;
char **p;
argstr(0, &path);
uargv = (uint32_t)argint(1);
memset(argv, 0, sizeof(argv));
for(i=0; ; i++){
if(i >= MAXARGS)
return -1;
if(uargv == 0) // no arguments
break;
uarg = (uint32_t)getint(current, uargv + i * 4);
if(uarg < 0)
return -1;
if(uarg == 0){ // the last element of passed argv[]
argv[i] = 0;
break;
}
if(getstr(current, uarg, &argv[i]) < 0)
return -1;
}
return exec(path, argv);
}
static int
subevalvar_misc(char *p, const char *var, int subtype, int startloc,
int varflags)
{
char *startp;
struct nodelist *saveargbackq = argbackq;
int amount;
argstr(p, EXP_TILDE, NULL);
STACKSTRNUL(expdest);
argbackq = saveargbackq;
startp = stackblock() + startloc;
switch (subtype) {
case VSASSIGN:
setvar(var, startp, 0);
amount = startp - expdest;
STADJUST(amount, expdest);
return 1;
case VSQUESTION:
if (*p != CTLENDVAR) {
outfmt(out2, "%s\n", startp);
error((char *)NULL);
}
error("%.*s: parameter %snot set", (int)(p - var - 1),
var, (varflags & VSNUL) ? "null or " : "");
return 0;
default:
abort();
}
}
/*
* Expand arithmetic expression.
*/
static char *
expari(char *p, int flag, struct worddest *dst)
{
char *q, *start;
arith_t result;
int begoff;
int quoted;
int adj;
quoted = *p++ == '"';
begoff = expdest - stackblock();
p = argstr(p, 0, NULL);
STPUTC('\0', expdest);
start = stackblock() + begoff;
q = grabstackstr(expdest);
result = arith(start);
ungrabstackstr(q, expdest);
start = stackblock() + begoff;
adj = start - expdest;
STADJUST(adj, expdest);
CHECKSTRSPACE((int)(DIGITS(result) + 1), expdest);
fmtstr(expdest, DIGITS(result), ARITH_FORMAT_STR, result);
adj = strlen(expdest);
STADJUST(adj, expdest);
if (!quoted)
reprocess(expdest - adj - stackblock(), flag, VSNORMAL, 0, dst);
return p;
}
bool ChatHandler::HandleGMHaxCommand(char* args)
{
if(!*args)
{
if(m_session->GetPlayer()->isGMHax())
m_session->SendNotification(LANG_GM_HAX_ON);
else
m_session->SendNotification(LANG_GM_HAX_OFF);
return true;
}
std::string argstr(args);
if (argstr == "on")
{
m_session->GetPlayer()->SetGMHax(true);
m_session->SendNotification(LANG_GM_HAX_ON);
return true;
}
if (argstr == "off")
{
m_session->GetPlayer()->SetGMHax(false);
m_session->SendNotification(LANG_GM_HAX_OFF);
return true;
}
SendSysMessage(LANG_USE_BOL);
SetSentErrorMessage(true);
return false;
}
int sys_exec()
{
char *path, **argv;
if(argstr(0, &path) < 0 || argptr(1, (char **)&argv, 4) < 0) {
return -1;
}
return exec(path, argv);
}
int sys_load_proc(void)
{
char *name = 0;
char *p = 0;
if (argstr(0, &name) < 0)
return -1;
if (argptr(1, &p, sizeof(struct proc)) < 0)
return -1;
return load_proc(name, (struct proc *)p);
}
int sys_creat(void)
{
int flag;
char *path;
argstr(0, &path);
flag = argint(1);
return sf_creat(path, flag);
}
int
sys_mount(void)
{
char *path;
int partition_number;
if(argstr(0, &path) < 0 || argint(1, &partition_number) < 0){
return -1;
}
return mount(path, partition_number);
}
/*
* Perform expansions on an argument, placing the resulting list of arguments
* in arglist. Parameter expansion, command substitution and arithmetic
* expansion are always performed; additional expansions can be requested
* via flag (EXP_*).
* The result is left in the stack string.
* When arglist is NULL, perform here document expansion.
*
* Caution: this function uses global state and is not reentrant.
* However, a new invocation after an interrupted invocation is safe
* and will reset the global state for the new call.
*/
void
expandarg(union node* arg, struct arglist* arglist, int32_t flag)
{
struct strlist* sp;
cstring_t p;
argbackq = arg->narg.backquote;
STARTSTACKSTR(expdest);
ifsfirst.next = NULL;
ifslastp = NULL;
argstr(arg->narg.text, flag);
if (arglist == NULL)
{
STACKSTRNUL(expdest);
return; /* here document expanded */
}
STPUTC('\0', expdest);
p = grabstackstr(expdest);
exparg.lastp = &exparg.list;
/*
* TODO - EXP_REDIR
*/
if (flag & EXP_FULL)
{
ifsbreakup(p, &exparg);
*exparg.lastp = NULL;
exparg.lastp = &exparg.list;
expandmeta(exparg.list, flag);
}
else
{
if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
rmescapes(p);
sp = (struct strlist*)stalloc(sizeof(struct strlist));
sp->text = p;
*exparg.lastp = sp;
exparg.lastp = &sp->next;
}
while (ifsfirst.next != NULL)
{
pifsregion_t ifsp;
INTOFF;
ifsp = ifsfirst.next->next;
ckfree(ifsfirst.next);
ifsfirst.next = ifsp;
INTON;
}
*exparg.lastp = NULL;
if (exparg.list)
{
*arglist->lastp = exparg.list;
arglist->lastp = exparg.lastp;
}
}
int
sys_rakib(void){
char *buf, art [] = "This is my system call output";
int buf_size;
if(argstr(0,&buf) < 0 || argint(1,&buf_size) < 0)
return -1;
if(buf_size < sizeof(art)/sizeof(char))
return -1;
else{
safestrcpy(buf,art,sizeof(art)/sizeof(char));
return sizeof(art)/sizeof(char);
}
}
/*
* Expand arithmetic expression.
* Note that flag is not required as digits never require CTLESC characters.
*/
static char *
expari(char *p)
{
char *q, *start;
arith_t result;
int begoff;
int quoted;
int c;
int nesting;
int adj;
quoted = *p++ == '"';
begoff = expdest - stackblock();
argstr(p, 0);
removerecordregions(begoff);
STPUTC('\0', expdest);
start = stackblock() + begoff;
q = grabstackstr(expdest);
result = arith(start);
ungrabstackstr(q, expdest);
start = stackblock() + begoff;
adj = start - expdest;
STADJUST(adj, expdest);
CHECKSTRSPACE((int)(DIGITS(result) + 1), expdest);
fmtstr(expdest, DIGITS(result), ARITH_FORMAT_STR, result);
adj = strlen(expdest);
STADJUST(adj, expdest);
if (!quoted)
recordregion(begoff, expdest - stackblock(), 0);
nesting = 1;
while (nesting > 0) {
c = *p++;
if (c == CTLESC)
p++;
else if (c == CTLARI)
nesting++;
else if (c == CTLENDARI)
nesting--;
else if (c == CTLVAR)
p++; /* ignore variable substitution byte */
else if (c == '\0')
return p - 1;
}
return p;
}
int sys_read(void)
{
int fd, len;
char *p;
int s;
fd = argint(0);
argstr(1, &p);
len = argint(2);
if(fd == 0){ // get data from stdin
return stdin_read(p, len);
} else {
return sf_read(fd, p, len);
}
}
JsValueRef Debugger::Evaluate(JsValueRef callee, bool isConstructCall, JsValueRef *arguments, unsigned short argumentCount, void *callbackState)
{
int stackFrameIndex;
JsValueRef result = JS_INVALID_REFERENCE;
if (argumentCount > 2)
{
IfJsErrorFailLogAndRet(ChakraRTInterface::JsNumberToInt(arguments[1], &stackFrameIndex));
AutoString argstr(arguments[2]);
IfJsErrorFailLogAndRet(argstr.GetError());
ChakraRTInterface::JsDiagEvaluateUtf8(argstr.GetString(), stackFrameIndex, &result);
}
return result;
}
int
casematch(union node *pattern, const char *val)
{
struct stackmark smark;
int result;
char *p;
setstackmark(&smark);
argbackq = pattern->narg.backquote;
STARTSTACKSTR(expdest);
argstr(pattern->narg.text, EXP_TILDE | EXP_CASE, NULL);
STPUTC('\0', expdest);
p = grabstackstr(expdest);
result = patmatch(p, val);
popstackmark(&smark);
return result;
}
int32_t
casematch(union node* pattern, const_cstring_t val)
{
struct stackmark smark;
int32_t result;
cstring_t p;
setstackmark(&smark);
argbackq = pattern->narg.backquote;
STARTSTACKSTR(expdest);
ifslastp = NULL;
argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
STPUTC('\0', expdest);
p = grabstackstr(expdest);
result = patmatch(p, val, 0);
popstackmark(&smark);
return result;
}
int
casematch(shinstance *psh, union node *pattern, char *val)
{
struct stackmark smark;
int result;
char *p;
setstackmark(psh, &smark);
psh->argbackq = pattern->narg.backquote;
STARTSTACKSTR(psh, psh->expdest);
psh->ifslastp = NULL;
argstr(psh, pattern->narg.text, EXP_TILDE | EXP_CASE);
STPUTC(psh, '\0', psh->expdest);
p = grabstackstr(psh, psh->expdest);
result = patmatch(psh, p, val, 0);
popstackmark(psh, &smark);
return result;
}
void SDLAppParseArgs(int argc, char *argv[], int* xres, int* yres, bool* fullscreen, std::vector<std::string>* otherargs) {
SDLAppInit();
for (int i=1; i<argc; i++) {
debugLog("argv[%d] = %s\n", i, argv[i]);
if (!strcmp(argv[i],"-f")) {
*fullscreen = 1;
continue;
}
else if (!strcmp(argv[i],"-w")) {
*fullscreen = 0;
continue;
}
//get video mode
if(strchr(argv[i], '-') != 0 && strlen(argv[i])>1) {
std::string argstr(argv[i], 1, strlen(argv[i])-1);
debugLog("%s\n", argstr.c_str());
size_t x = argstr.rfind("x");
if(x != std::string::npos) {
std::string widthstr = argstr.substr(0, x);
std::string heightstr = argstr.substr(x+1);
int width = atoi(widthstr.c_str());
int height = atoi(heightstr.c_str());
if(width!=0 && height!=0) {
debugLog("w=%d, h=%d\n",width,height);
*xres = width;
*yres = height;
continue;
}
}
}
// non display argument
if(otherargs != 0) {
otherargs->push_back(std::string(argv[i]));
}
}
}
int main(int argc, char** argv) {
int err;
char* buf;
char* args;
char* msg;
setneuronhome();
nh = hoc_dos2unixpath(nrnhome);
args = argstr(argc, argv);
buf = new char[strlen(args) + 3*strlen(nh) + 200];
sprintf(buf, "%s\\bin\\sh %s/lib/mos2nrn.sh %s %s", nrnhome, nh, nh, args);
msg = new char[strlen(buf) + 100];
err = WinExec(buf, SW_SHOW);
if (err < 32) {
sprintf(msg, "Cannot WinExec %s\n", buf);
MessageBox(0, msg, "NEURON", MB_OK);
}
return 0;
}
/*
* Perform expansions on an argument, placing the resulting list of arguments
* in arglist. Parameter expansion, command substitution and arithmetic
* expansion are always performed; additional expansions can be requested
* via flag (EXP_*).
* The result is left in the stack string.
* When arglist is NULL, perform here document expansion.
*
* Caution: this function uses global state and is not reentrant.
* However, a new invocation after an interrupted invocation is safe
* and will reset the global state for the new call.
*/
void
expandarg(union node *arg, struct arglist *arglist, int flag)
{
struct strlist *sp;
char *p;
argbackq = arg->narg.backquote;
STARTSTACKSTR(expdest);
ifsfirst.next = NULL;
ifslastp = NULL;
argstr(arg->narg.text, flag);
if (arglist == NULL) {
STACKSTRNUL(expdest);
return; /* here document expanded */
}
STPUTC('\0', expdest);
p = grabstackstr(expdest);
exparg.lastp = &exparg.list;
if (flag & EXP_FULL) {
ifsbreakup(p, &exparg);
*exparg.lastp = NULL;
exparg.lastp = &exparg.list;
expandmeta(exparg.list);
} else {
sp = (struct strlist *)stalloc(sizeof (struct strlist));
sp->text = p;
*exparg.lastp = sp;
exparg.lastp = &sp->next;
}
while (ifsfirst.next != NULL) {
struct ifsregion *ifsp;
INTOFF;
ifsp = ifsfirst.next->next;
ckfree(ifsfirst.next);
ifsfirst.next = ifsp;
INTON;
}
*exparg.lastp = NULL;
if (exparg.list) {
*arglist->lastp = exparg.list;
arglist->lastp = exparg.lastp;
}
}
int
sys_open(SyscallFrame *f)
{
char *fname;
long l;
int omode, fd;
File *file;
if (argstr(f, 0, &fname) < 0)
return -1;
if (arglong(f, 1, &l) < 0)
return -1;
omode = (long)l;
if (omode & (OEXEC | OTRUNC | OCEXEC | ORCLOSE)) {
// todo errstr
return -1;
}
if (omode & (OWRITE | ORDWR) && !canwrite(fname)) {
// todo errstr
return -1;
}
file = getfile(fname);
if (file == nil)
return -1;
file->omode = omode;
fd = allocfd(proc, file);
if (fd == -1) {
// todo errstr
releasefile(file);
return -1;
}
return fd;
}
void
expandarg(shinstance *psh, union node *arg, struct arglist *arglist, int flag)
{
struct strlist *sp;
char *p;
psh->argbackq = arg->narg.backquote;
STARTSTACKSTR(psh, psh->expdest);
psh->ifsfirst.next = NULL;
psh->ifslastp = NULL;
argstr(psh, arg->narg.text, flag);
if (arglist == NULL) {
return; /* here document expanded */
}
STPUTC(psh, '\0', psh->expdest);
p = grabstackstr(psh, psh->expdest);
TRACE2((psh, "expandarg: p='%s'\n", p));
psh->exparg.lastp = &psh->exparg.list;
/*
* TODO - EXP_REDIR
*/
if (flag & EXP_FULL) {
ifsbreakup(psh, p, &psh->exparg);
*psh->exparg.lastp = NULL;
psh->exparg.lastp = &psh->exparg.list;
expandmeta(psh, psh->exparg.list, flag);
} else {
if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
rmescapes(psh, p);
sp = (struct strlist *)stalloc(psh, sizeof (struct strlist));
sp->text = p;
*psh->exparg.lastp = sp;
psh->exparg.lastp = &sp->next;
}
ifsfree(psh);
*psh->exparg.lastp = NULL;
if (psh->exparg.list) {
*arglist->lastp = psh->exparg.list;
arglist->lastp = psh->exparg.lastp;
}
}
int sys_write(void)
{
int fd, len;
char *p;
int s;
fd = argint(0);
argstr(1, &p);
len = argint(2);
if(fd == 1 || fd == 2){ // print to stdout
if(len == 1)
put_c(*p);
else
printk("%s", p);
} else {
sf_write(fd, p, len);
}
return 0;
}
static char *
evalvar(char *p, int flag)
{
int subtype;
int varflags;
char *var;
const char *val;
int patloc;
int c;
int set;
int special;
int startloc;
int varlen;
int varlenb;
int easy;
int quotes = flag & (EXP_FULL | EXP_CASE);
int record = 0;
varflags = (unsigned char)*p++;
subtype = varflags & VSTYPE;
var = p;
special = 0;
if (! is_name(*p))
special = 1;
p = strchr(p, '=') + 1;
again: /* jump here after setting a variable with ${var=text} */
if (varflags & VSLINENO) {
set = 1;
special = 1;
val = NULL;
} else if (special) {
set = varisset(var, varflags & VSNUL);
val = NULL;
} else {
val = bltinlookup(var, 1);
if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
val = NULL;
set = 0;
} else
set = 1;
}
varlen = 0;
startloc = expdest - stackblock();
if (!set && uflag && *var != '@' && *var != '*') {
switch (subtype) {
case VSNORMAL:
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
case VSLENGTH:
error("%.*s: parameter not set", (int)(p - var - 1),
var);
}
}
if (set && subtype != VSPLUS) {
/* insert the value of the variable */
if (special) {
if (varflags & VSLINENO)
STPUTBIN(var, p - var - 1, expdest);
else
varvalue(var, varflags & VSQUOTE, subtype, flag);
if (subtype == VSLENGTH) {
varlenb = expdest - stackblock() - startloc;
varlen = varlenb;
if (localeisutf8) {
val = stackblock() + startloc;
for (;val != expdest; val++)
if ((*val & 0xC0) == 0x80)
varlen--;
}
STADJUST(-varlenb, expdest);
}
} else {
if (subtype == VSLENGTH) {
for (;*val; val++)
if (!localeisutf8 ||
(*val & 0xC0) != 0x80)
varlen++;
}
else
strtodest(val, flag, subtype,
varflags & VSQUOTE);
}
}
if (subtype == VSPLUS)
set = ! set;
easy = ((varflags & VSQUOTE) == 0 ||
(*var == '@' && shellparam.nparam != 1));
switch (subtype) {
case VSLENGTH:
expdest = cvtnum(varlen, expdest);
record = 1;
break;
case VSNORMAL:
record = easy;
break;
case VSPLUS:
case VSMINUS:
if (!set) {
argstr(p, flag | (flag & EXP_FULL ? EXP_SPLIT_LIT : 0) |
(varflags & VSQUOTE ? EXP_LIT_QUOTED : 0));
break;
}
record = easy;
break;
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
if (!set)
break;
/*
* Terminate the string and start recording the pattern
* right after it
*/
STPUTC('\0', expdest);
patloc = expdest - stackblock();
if (subevalvar(p, NULL, patloc, subtype,
startloc, varflags, quotes) == 0) {
int amount = (expdest - stackblock() - patloc) + 1;
STADJUST(-amount, expdest);
}
/* Remove any recorded regions beyond start of variable */
removerecordregions(startloc);
record = 1;
break;
case VSASSIGN:
case VSQUESTION:
if (!set) {
if (subevalvar(p, var, 0, subtype, startloc, varflags,
quotes)) {
varflags &= ~VSNUL;
/*
* Remove any recorded regions beyond
* start of variable
*/
removerecordregions(startloc);
goto again;
}
break;
}
record = easy;
break;
case VSERROR:
c = p - var - 1;
error("${%.*s%s}: Bad substitution", c, var,
(c > 0 && *p != CTLENDVAR) ? "..." : "");
default:
abort();
}
if (record)
recordregion(startloc, expdest - stackblock(),
varflags & VSQUOTE || (ifsset() && ifsval()[0] == '\0' &&
(*var == '@' || *var == '*')));
if (subtype != VSNORMAL) { /* skip to end of alternative */
int nesting = 1;
for (;;) {
if ((c = *p++) == CTLESC)
p++;
else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
if (set)
argbackq = argbackq->next;
} else if (c == CTLVAR) {
if ((*p++ & VSTYPE) != VSNORMAL)
nesting++;
} else if (c == CTLENDVAR) {
if (--nesting == 0)
break;
}
}
}
return p;
}
static int
subevalvar(char *p, char *str, int strloc, int subtype, int startloc,
int varflags, int quotes)
{
char *startp;
char *loc = NULL;
char *q;
int c = 0;
struct nodelist *saveargbackq = argbackq;
int amount;
argstr(p, (subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX ||
subtype == VSTRIMRIGHT || subtype == VSTRIMRIGHTMAX ?
EXP_CASE : 0) | EXP_TILDE);
STACKSTRNUL(expdest);
argbackq = saveargbackq;
startp = stackblock() + startloc;
if (str == NULL)
str = stackblock() + strloc;
switch (subtype) {
case VSASSIGN:
setvar(str, startp, 0);
amount = startp - expdest;
STADJUST(amount, expdest);
varflags &= ~VSNUL;
return 1;
case VSQUESTION:
if (*p != CTLENDVAR) {
outfmt(out2, "%s\n", startp);
error((char *)NULL);
}
error("%.*s: parameter %snot set", (int)(p - str - 1),
str, (varflags & VSNUL) ? "null or " : "");
return 0;
case VSTRIMLEFT:
for (loc = startp; loc < str; loc++) {
c = *loc;
*loc = '\0';
if (patmatch(str, startp, quotes)) {
*loc = c;
recordleft(str, loc, startp);
return 1;
}
*loc = c;
if (quotes && *loc == CTLESC)
loc++;
}
return 0;
case VSTRIMLEFTMAX:
for (loc = str - 1; loc >= startp;) {
c = *loc;
*loc = '\0';
if (patmatch(str, startp, quotes)) {
*loc = c;
recordleft(str, loc, startp);
return 1;
}
*loc = c;
loc--;
if (quotes && loc > startp && *(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHT:
for (loc = str - 1; loc >= startp;) {
if (patmatch(str, loc, quotes)) {
amount = loc - expdest;
STADJUST(amount, expdest);
return 1;
}
loc--;
if (quotes && loc > startp && *(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHTMAX:
for (loc = startp; loc < str - 1; loc++) {
if (patmatch(str, loc, quotes)) {
amount = loc - expdest;
STADJUST(amount, expdest);
return 1;
}
if (quotes && *loc == CTLESC)
loc++;
}
return 0;
default:
abort();
}
}
STATIC int
subevalvar(shinstance *psh, char *p, char *str, int strloc, int subtype, int startloc, int varflags)
{
char *startp;
char *loc = NULL;
char *q;
int c = 0;
int saveherefd = psh->herefd;
struct nodelist *saveargbackq = psh->argbackq;
int amount;
psh->herefd = -1;
argstr(psh, p, 0);
STACKSTRNUL(psh, psh->expdest);
psh->herefd = saveherefd;
psh->argbackq = saveargbackq;
startp = stackblock(psh) + startloc;
if (str == NULL)
str = stackblock(psh) + strloc;
switch (subtype) {
case VSASSIGN:
setvar(psh, str, startp, 0);
amount = (int)(startp - psh->expdest);
STADJUST(psh, amount, psh->expdest);
varflags &= ~VSNUL;
if (c != 0)
*loc = c;
return 1;
case VSQUESTION:
if (*p != CTLENDVAR) {
outfmt(&psh->errout, "%s\n", startp);
error(psh, (char *)NULL);
}
error(psh, "%.*s: parameter %snot set", p - str - 1,
str, (varflags & VSNUL) ? "null or "
: nullstr);
/* NOTREACHED */
case VSTRIMLEFT:
for (loc = startp; loc < str; loc++) {
c = *loc;
*loc = '\0';
if (patmatch(psh, str, startp, varflags & VSQUOTE))
goto recordleft;
*loc = c;
if ((varflags & VSQUOTE) && *loc == CTLESC)
loc++;
}
return 0;
case VSTRIMLEFTMAX:
for (loc = str - 1; loc >= startp;) {
c = *loc;
*loc = '\0';
if (patmatch(psh, str, startp, varflags & VSQUOTE))
goto recordleft;
*loc = c;
loc--;
if ((varflags & VSQUOTE) && loc > startp &&
*(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHT:
for (loc = str - 1; loc >= startp;) {
if (patmatch(psh, str, loc, varflags & VSQUOTE))
goto recordright;
loc--;
if ((varflags & VSQUOTE) && loc > startp &&
*(loc - 1) == CTLESC) {
for (q = startp; q < loc; q++)
if (*q == CTLESC)
q++;
if (q > loc)
loc--;
}
}
return 0;
case VSTRIMRIGHTMAX:
for (loc = startp; loc < str - 1; loc++) {
if (patmatch(psh, str, loc, varflags & VSQUOTE))
goto recordright;
if ((varflags & VSQUOTE) && *loc == CTLESC)
loc++;
}
return 0;
default:
sh_abort(psh);
}
recordleft:
*loc = c;
amount = (int)(((str - 1) - (loc - startp)) - psh->expdest);
STADJUST(psh, amount, psh->expdest);
while (loc != str - 1)
*startp++ = *loc++;
return 1;
recordright:
amount = (int)(loc - psh->expdest);
STADJUST(psh, amount, psh->expdest);
STPUTC(psh, '\0', psh->expdest);
STADJUST(psh, -1, psh->expdest);
return 1;
}
/**
* Main. Creates Application window.
*/
int main(int argc, char** argv)
{
RS_DEBUG->setLevel(RS_Debug::D_WARNING);
QApplication app(argc, argv);
QCoreApplication::setOrganizationName("LibreCAD");
QCoreApplication::setApplicationName("LibreCAD");
QCoreApplication::setApplicationVersion(XSTR(LC_VERSION));
QSettings settings;
bool first_load = settings.value("Startup/FirstLoad", 1).toBool();
const QString lpDebugSwitch0("-d"),lpDebugSwitch1("--debug") ;
const QString help0("-h"), help1("--help");
bool allowOptions=true;
QList<int> argClean;
for (int i=0; i<argc; i++)
{
QString argstr(argv[i]);
if(allowOptions&&QString::compare("--", argstr)==0)
{
allowOptions=false;
continue;
}
if (allowOptions && (help0.compare(argstr, Qt::CaseInsensitive)==0 ||
help1.compare(argstr, Qt::CaseInsensitive)==0 ))
{
qDebug()<<"librecad::usage: <options> <dxf file>";
qDebug()<<"-h, --help\tdisplay this message";
qDebug()<<"";
qDebug()<<" --help\tdisplay this message";
qDebug()<<"-d, --debug <level>";
RS_DEBUG->print( RS_Debug::D_NOTHING, "possible debug levels:");
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Nothing", RS_Debug::D_NOTHING);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Critical", RS_Debug::D_CRITICAL);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Error", RS_Debug::D_ERROR);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Warning", RS_Debug::D_WARNING);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Notice", RS_Debug::D_NOTICE);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Informational", RS_Debug::D_INFORMATIONAL);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Debugging", RS_Debug::D_DEBUGGING);
exit(0);
}
if ( allowOptions&& (argstr.startsWith(lpDebugSwitch0, Qt::CaseInsensitive) ||
argstr.startsWith(lpDebugSwitch1, Qt::CaseInsensitive) ))
{
argClean<<i;
// to control the level of debugging output use --debug with level 0-6, e.g. --debug3
// for a list of debug levels use --debug?
// if no level follows, the debugging level is set
argstr.remove(QRegExp("^"+lpDebugSwitch0));
argstr.remove(QRegExp("^"+lpDebugSwitch1));
char level;
if(argstr.size()==0)
{
if(i+1<argc)
{
if(QRegExp("\\d*").exactMatch(argv[i+1]))
{
++i;
qDebug()<<"reading "<<argv[i]<<" as debugging level";
level=argv[i][0];
argClean<<i;
}
else
level='3';
}
else
level='3'; //default to D_WARNING
}
else
level=argstr.toStdString()[0];
switch(level)
{
case '?' :
RS_DEBUG->print( RS_Debug::D_NOTHING, "possible debug levels:");
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Nothing", RS_Debug::D_NOTHING);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Critical", RS_Debug::D_CRITICAL);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Error", RS_Debug::D_ERROR);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Warning", RS_Debug::D_WARNING);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Notice", RS_Debug::D_NOTICE);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Informational", RS_Debug::D_INFORMATIONAL);
RS_DEBUG->print( RS_Debug::D_NOTHING, " %d Debugging", RS_Debug::D_DEBUGGING);
return 0;
case '0' + RS_Debug::D_NOTHING :
RS_DEBUG->setLevel( RS_Debug::D_NOTHING);
++i;
break;
case '0' + RS_Debug::D_CRITICAL :
RS_DEBUG->setLevel( RS_Debug::D_CRITICAL);
++i;
break;
case '0' + RS_Debug::D_ERROR :
RS_DEBUG->setLevel( RS_Debug::D_ERROR);
++i;
break;
case '0' + RS_Debug::D_WARNING :
RS_DEBUG->setLevel( RS_Debug::D_WARNING);
++i;
break;
case '0' + RS_Debug::D_NOTICE :
RS_DEBUG->setLevel( RS_Debug::D_NOTICE);
++i;
break;
case '0' + RS_Debug::D_INFORMATIONAL :
RS_DEBUG->setLevel( RS_Debug::D_INFORMATIONAL);
++i;
break;
case '0' + RS_Debug::D_DEBUGGING :
RS_DEBUG->setLevel( RS_Debug::D_DEBUGGING);
++i;
break;
default :
RS_DEBUG->setLevel(RS_Debug::D_DEBUGGING);
break;
}
}
}
RS_DEBUG->print("param 0: %s", argv[0]);
QFileInfo prgInfo( QFile::decodeName(argv[0]) );
QString prgDir(prgInfo.absolutePath());
RS_SETTINGS->init(app.organizationName(), app.applicationName());
RS_SYSTEM->init(app.applicationName(), app.applicationVersion(), XSTR(QC_APPDIR), prgDir);
// parse command line arguments that might not need a launched program:
QStringList fileList = handleArgs(argc, argv, argClean);
QString unit = settings.value("Defaults/Unit", "Invalid").toString();
// show initial config dialog:
if (first_load)
{
RS_DEBUG->print("main: show initial config dialog..");
QG_DlgInitial di(nullptr);
QPixmap pxm(":/main/intro_librecad.png");
di.setPixmap(pxm);
if (di.exec())
{
RS_SETTINGS->beginGroup("/Defaults");
unit = RS_SETTINGS->readEntry("/Unit", "None");
RS_SETTINGS->endGroup();
}
RS_DEBUG->print("main: show initial config dialog: OK");
}
auto splash = new QSplashScreen;
bool show_splash = settings.value("Startup/ShowSplash", 1).toBool();
if (show_splash)
{
QPixmap pixmap(":/main/splash_librecad.png");
splash->setPixmap(pixmap);
splash->setAttribute(Qt::WA_DeleteOnClose);
splash->show();
splash->showMessage(QObject::tr("Loading.."),
Qt::AlignRight|Qt::AlignBottom, Qt::black);
app.processEvents();
RS_DEBUG->print("main: splashscreen: OK");
}
RS_DEBUG->print("main: init fontlist..");
RS_FONTLIST->init();
RS_DEBUG->print("main: init fontlist: OK");
RS_DEBUG->print("main: init patternlist..");
RS_PATTERNLIST->init();
RS_DEBUG->print("main: init patternlist: OK");
RS_DEBUG->print("main: loading translation..");
settings.beginGroup("Appearance");
QString lang = settings.value("Language", "en").toString();
QString langCmd = settings.value("LanguageCmd", "en").toString();
settings.endGroup();
RS_SYSTEM->loadTranslation(lang, langCmd);
RS_DEBUG->print("main: loading translation: OK");
RS_DEBUG->print("main: creating main window..");
QC_ApplicationWindow appWin;
RS_DEBUG->print("main: setting caption");
appWin.setWindowTitle(app.applicationName());
RS_DEBUG->print("main: show main window");
settings.beginGroup("Geometry");
int windowWidth = settings.value("WindowWidth", 1024).toInt();
int windowHeight = settings.value("WindowHeight", 1024).toInt();
int windowX = settings.value("WindowX", 32).toInt();
int windowY = settings.value("WindowY", 32).toInt();
settings.endGroup();
if (!first_load)
appWin.resize(windowWidth, windowHeight);
appWin.move(windowX, windowY);
bool maximize = settings.value("Startup/Maximize", 0).toBool();
if (maximize || first_load)
appWin.showMaximized();
else
appWin.show();
RS_DEBUG->print("main: set focus");
appWin.setFocus();
RS_DEBUG->print("main: creating main window: OK");
if (show_splash)
{
RS_DEBUG->print("main: updating splash");
splash->raise();
splash->showMessage(QObject::tr("Loading..."),
Qt::AlignRight|Qt::AlignBottom, Qt::black);
RS_DEBUG->print("main: processing events");
qApp->processEvents();
RS_DEBUG->print("main: updating splash: OK");
}
// Set LC_NUMERIC so that entering numeric values uses . as the decimal seperator
setlocale(LC_NUMERIC, "C");
RS_DEBUG->print("main: loading files..");
bool files_loaded = false;
for (QStringList::Iterator it = fileList.begin(); it != fileList.end(); ++it )
{
if (show_splash)
{
splash->showMessage(QObject::tr("Loading File %1..")
.arg(QDir::toNativeSeparators(*it)),
Qt::AlignRight|Qt::AlignBottom, Qt::black);
qApp->processEvents();
}
appWin.slotFileOpen(*it, RS2::FormatUnknown);
files_loaded = true;
}
RS_DEBUG->print("main: loading files: OK");
if (!files_loaded)
{
appWin.slotFileNewNew();
}
if (show_splash)
splash->finish(&appWin);
else
delete splash;
if (first_load)
settings.setValue("Startup/FirstLoad", 0);
RS_DEBUG->print("main: entering Qt event loop");
int return_code = app.exec();
RS_DEBUG->print("main: exited Qt event loop");
return return_code;
}
STATIC char *
evalvar(shinstance *psh, char *p, int flag)
{
int subtype;
int varflags;
char *var;
char *val;
int patloc;
int c;
int set;
int special;
int startloc;
int varlen;
int apply_ifs;
int quotes = flag & (EXP_FULL | EXP_CASE);
varflags = (unsigned char)*p++;
subtype = varflags & VSTYPE;
var = p;
special = !is_name(*p);
p = strchr(p, '=') + 1;
again: /* jump here after setting a variable with ${var=text} */
if (special) {
set = varisset(psh, var, varflags & VSNUL);
val = NULL;
} else {
val = lookupvar(psh, var);
if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
val = NULL;
set = 0;
} else
set = 1;
}
varlen = 0;
startloc = (int)(psh->expdest - stackblock(psh));
if (!set && uflag(psh)) {
switch (subtype) {
case VSNORMAL:
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
case VSLENGTH:
error(psh, "%.*s: parameter not set", p - var - 1, var);
/* NOTREACHED */
}
}
if (set && subtype != VSPLUS) {
/* insert the value of the variable */
if (special) {
varvalue(psh, var, varflags & VSQUOTE, subtype, flag);
if (subtype == VSLENGTH) {
varlen = (int)(psh->expdest - stackblock(psh) - startloc);
STADJUST(psh, -varlen, psh->expdest);
}
} else {
char const *syntax = (varflags & VSQUOTE) ? DQSYNTAX
: BASESYNTAX;
if (subtype == VSLENGTH) {
for (;*val; val++)
varlen++;
} else {
while (*val) {
if (quotes && syntax[(int)*val] == CCTL)
STPUTC(psh, CTLESC, psh->expdest);
STPUTC(psh, *val++, psh->expdest);
}
}
}
}
apply_ifs = ((varflags & VSQUOTE) == 0 ||
(*var == '@' && psh->shellparam.nparam != 1));
switch (subtype) {
case VSLENGTH:
psh->expdest = cvtnum(psh, varlen, psh->expdest);
break;
case VSNORMAL:
break;
case VSPLUS:
set = !set;
/* FALLTHROUGH */
case VSMINUS:
if (!set) {
argstr(psh, p, flag | (apply_ifs ? EXP_IFS_SPLIT : 0));
/*
* ${x-a b c} doesn't get split, but removing the
* 'apply_ifs = 0' apparantly breaks ${1+"$@"}..
* ${x-'a b' c} should generate 2 args.
*/
/* We should have marked stuff already */
apply_ifs = 0;
}
break;
case VSTRIMLEFT:
case VSTRIMLEFTMAX:
case VSTRIMRIGHT:
case VSTRIMRIGHTMAX:
if (!set)
break;
/*
* Terminate the string and start recording the pattern
* right after it
*/
STPUTC(psh, '\0', psh->expdest);
patloc = (int)(psh->expdest - stackblock(psh));
if (subevalvar(psh, p, NULL, patloc, subtype,
startloc, varflags) == 0) {
int amount = (int)(psh->expdest - stackblock(psh) - patloc) + 1;
STADJUST(psh, -amount, psh->expdest);
}
/* Remove any recorded regions beyond start of variable */
removerecordregions(psh, startloc);
apply_ifs = 1;
break;
case VSASSIGN:
case VSQUESTION:
if (set)
break;
if (subevalvar(psh, p, var, 0, subtype, startloc, varflags)) {
varflags &= ~VSNUL;
/*
* Remove any recorded regions beyond
* start of variable
*/
removerecordregions(psh, startloc);
goto again;
}
apply_ifs = 0;
break;
default:
sh_abort(psh);
}
if (apply_ifs)
recordregion(psh, startloc, (int)(psh->expdest - stackblock(psh)),
varflags & VSQUOTE);
if (subtype != VSNORMAL) { /* skip to end of alternative */
int nesting = 1;
for (;;) {
if ((c = *p++) == CTLESC)
p++;
else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
if (set)
psh->argbackq = psh->argbackq->next;
} else if (c == CTLVAR) {
if ((*p++ & VSTYPE) != VSNORMAL)
nesting++;
} else if (c == CTLENDVAR) {
if (--nesting == 0)
break;
}
}
}
return p;
}
