static HashNode
getlanginfo(UNUSED(HashTable ht), const char *name)
{
int len, *elem;
char *listr, *nameu;
Param pm = NULL;
nameu = dupstring(name);
unmetafy(nameu, &len);
pm = (Param) hcalloc(sizeof(struct param));
pm->node.nam = nameu;
pm->node.flags = PM_READONLY | PM_SCALAR;
pm->gsu.s = &nullsetscalar_gsu;
if(name)
elem = liitem(name);
else
elem = NULL;
if (elem && (listr = nl_langinfo(*elem))) {
pm->u.str = dupstring(listr);
}
else
{
/* zwarn("no such lang info: %s", name); */
pm->u.str = dupstring("");
pm->node.flags |= PM_UNSET;
}
return &pm->node;
}
static void
init_gconf (void)
{
#if defined (HAVE_GCONF)
char *s;
#if ! GLIB_CHECK_VERSION (2, 36, 0)
g_type_init ();
#endif
gconf_client = gconf_client_get_default ();
gconf_client_set_error_handling (gconf_client, GCONF_CLIENT_HANDLE_NONE);
gconf_client_add_dir (gconf_client,
GCONF_TOOL_BAR_STYLE,
GCONF_CLIENT_PRELOAD_ONELEVEL,
NULL);
gconf_client_notify_add (gconf_client,
GCONF_TOOL_BAR_STYLE,
something_changed_gconfCB,
NULL, NULL, NULL);
s = gconf_client_get_string (gconf_client, GCONF_TOOL_BAR_STYLE, NULL);
if (s)
{
current_tool_bar_style = map_tool_bar_style (s);
g_free (s);
}
#ifdef HAVE_XFT
s = gconf_client_get_string (gconf_client, GCONF_MONO_FONT, NULL);
if (s)
{
dupstring (¤t_mono_font, s);
g_free (s);
}
s = gconf_client_get_string (gconf_client, GCONF_FONT_NAME, NULL);
if (s)
{
dupstring (¤t_font, s);
g_free (s);
}
gconf_client_add_dir (gconf_client,
GCONF_MONO_FONT,
GCONF_CLIENT_PRELOAD_ONELEVEL,
NULL);
gconf_client_notify_add (gconf_client,
GCONF_MONO_FONT,
something_changed_gconfCB,
NULL, NULL, NULL);
gconf_client_add_dir (gconf_client,
GCONF_FONT_NAME,
GCONF_CLIENT_PRELOAD_ONELEVEL,
NULL);
gconf_client_notify_add (gconf_client,
GCONF_FONT_NAME,
something_changed_gconfCB,
NULL, NULL, NULL);
#endif /* HAVE_XFT */
#endif /* HAVE_GCONF */
}
char *
zgetcwd(void)
{
char *ret = zgetdir(NULL);
#ifdef HAVE_GETCWD
if (!ret) {
#ifdef GETCWD_CALLS_MALLOC
char *cwd = getcwd(NULL, 0);
if (cwd) {
ret = dupstring(cwd);
free(cwd);
}
#else
char *cwdbuf = zalloc(PATH_MAX);
ret = getcwd(cwdbuf, PATH_MAX);
if (ret)
ret = dupstring(ret);
free(cwdbuf);
#endif /* GETCWD_CALLS_MALLOC */
}
#endif /* HAVE_GETCWD */
if (!ret)
ret = pwd;
if (!ret)
ret = dupstring(".");
return ret;
}
static HashNode
gettermcap(UNUSED(HashTable ht), char *name)
{
int len, num;
char *tcstr, buf[2048], *u;
Param pm = NULL;
/* This depends on the termcap stuff in init.c */
if (termflags & TERM_BAD)
return NULL;
if ((termflags & TERM_UNKNOWN) && (isset(INTERACTIVE) || !init_term()))
return NULL;
unmetafy(name, &len);
pm = (Param) hcalloc(sizeof(struct param));
pm->nam = dupstring(name);
pm->flags = PM_READONLY;
u = buf;
/* logic in the following cascade copied from echotc, above */
if ((num = tgetnum(name)) != -1) {
pm->gsu.i = &nullsetinteger_gsu;
pm->u.val = num;
pm->flags |= PM_INTEGER;
return (HashNode) pm;
}
pm->gsu.s = &nullsetscalar_gsu;
switch (ztgetflag(name)) {
case -1:
break;
case 0:
pm->u.str = dupstring("no");
pm->flags |= PM_SCALAR;
return (HashNode) pm;
default:
pm->u.str = dupstring("yes");
pm->flags |= PM_SCALAR;
return (HashNode) pm;
}
if ((tcstr = (char*)tgetstr(name, &u)) != NULL && tcstr != (char *)-1)
{
pm->u.str = dupstring(tcstr);
pm->flags |= PM_SCALAR;
}
else
{
/* zwarn("no such capability: %s", name, 0); */
pm->u.str = dupstring("");
pm->flags |= PM_UNSET;
}
return (HashNode) pm;
}
static void
read_and_apply_settings (struct x_display_info *dpyinfo, bool send_event_p)
{
struct xsettings settings;
if (!read_settings (dpyinfo, &settings))
return;
apply_xft_settings (dpyinfo, &settings);
if (settings.seen & SEEN_TB_STYLE)
{
if (send_event_p)
store_tool_bar_style_changed (settings.tb_style, dpyinfo);
else
current_tool_bar_style = map_tool_bar_style (settings.tb_style);
xfree (settings.tb_style);
}
#ifdef HAVE_XFT
if (settings.seen & SEEN_FONT)
{
if (send_event_p)
store_font_name_changed (settings.font);
else
dupstring (¤t_font, settings.font);
xfree (settings.font);
}
#endif
}
static int
ptywrite(Ptycmd cmd, char **args, int nonl)
{
if (*args) {
char sp = ' ', *tmp;
int len;
while (*args) {
unmetafy((tmp = dupstring(*args)), &len);
if (ptywritestr(cmd, tmp, len) ||
(*++args && ptywritestr(cmd, &sp, 1)))
return 1;
}
if (!nonl) {
sp = '\n';
if (ptywritestr(cmd, &sp, 1))
return 1;
}
} else {
int n;
char buf[BUFSIZ];
while ((n = read(0, buf, BUFSIZ)) > 0)
if (ptywritestr(cmd, buf, n))
return 1;
}
return 0;
}
mod_export int
optlookup(char const *name)
{
char *s, *t;
Optname n;
s = t = dupstring(name);
/* exorcise underscores, and change to lowercase */
while (*t)
if (*t == '_')
chuck(t);
else {
/*
* Some locales (in particular tr_TR.UTF-8) may
* have non-standard mappings of ASCII characters,
* so be careful. Option names must be ASCII so
* we don't need to be too clever.
*/
if (*t >= 'A' && *t <= 'Z')
*t = (*t - 'A') + 'a';
t++;
}
/* look up name in the table */
if (s[0] == 'n' && s[1] == 'o' &&
(n = (Optname) optiontab->getnode(optiontab, s + 2))) {
return -n->optno;
} else if ((n = (Optname) optiontab->getnode(optiontab, s)))
return n->optno;
else
return OPT_INVALID;
}
mod_export char *
parse_subscript(char *s, int sub, int endchar)
{
int l = strlen(s), err;
char *t;
if (!*s || *s == endchar)
return 0;
zcontext_save();
untokenize(t = dupstring(s));
inpush(t, 0, NULL);
strinbeg(0);
lexbuf.len = 0;
lexbuf.ptr = tokstr = s;
lexbuf.siz = l + 1;
err = dquote_parse(endchar, sub);
if (err) {
err = *lexbuf.ptr;
*lexbuf.ptr = '\0';
untokenize(s);
*lexbuf.ptr = err;
s = NULL;
} else {
s = lexbuf.ptr;
}
strinend();
inpop();
DPUTS(cmdsp, "BUG: parse_subscript: cmdstack not empty.");
zcontext_restore();
return s;
}
mod_export int
optlookup(char const *name)
{
char *s, *t;
Optname n;
s = t = dupstring(name);
/* exorcise underscores, and change to lowercase */
while (*t)
if (*t == '_')
chuck(t);
else {
*t = tulower(*t);
t++;
}
/* look up name in the table */
if (s[0] == 'n' && s[1] == 'o' &&
(n = (Optname) optiontab->getnode(optiontab, s + 2))) {
return -n->optno;
} else if ((n = (Optname) optiontab->getnode(optiontab, s)))
return n->optno;
else
return OPT_INVALID;
}
static void
scanpmmapfile(UNUSED(HashTable ht), ScanFunc func, int flags)
{
struct param pm;
DIR *dir;
if (!(dir = opendir(".")))
return;
memset((void *)&pm, 0, sizeof(struct param));
pm.flags = PM_SCALAR;
pm.gsu.s = &mapfile_gsu;
pm.flags |= (mapfile_pm->flags & PM_READONLY);
/* Here we scan the current directory, calling func() for each file */
while ((pm.nam = zreaddir(dir, 1))) {
/*
* Hmmm, it's rather wasteful always to read the contents.
* In fact, it's grotesequely wasteful, since that would mean
* we always read the entire contents of every single file
* in the directory into memory. Hence just leave it empty.
*/
pm.nam = dupstring(pm.nam);
pm.u.str = "";
func((HashNode) &pm, flags);
}
closedir(dir);
}
static char *
get_buffer(UNUSED(Param pm))
{
if (zlemetaline != 0)
return dupstring(zlemetaline);
return zlelineasstring(zleline, zlell, 0, NULL, NULL, 1);
}
void MConsole::AddCommand(SMJS_Plugin *pl, const char *cmdName, v8::Handle<v8::Function> func, bool serverOnly){
std::string stdCmdName(cmdName);
std::transform(stdCmdName.begin(), stdCmdName.end(), stdCmdName.begin(), ::tolower);
CommandHook *wrapper = new CommandHook;
wrapper->pl = pl;
wrapper->func = v8::Persistent<v8::Function>::New(func);
wrapper->serverOnly = serverOnly;
auto infoIt = g_MConsole->pluginCmds2.find(stdCmdName);
if(infoIt == g_MConsole->pluginCmds2.end()){
CommandHookInfo *info = new CommandHookInfo();
g_MConsole->pluginCmds2.insert(std::make_pair(stdCmdName, info));
infoIt = g_MConsole->pluginCmds2.find(stdCmdName);
ConCommand *conCmd = icvar->FindCommand(cmdName);
if(!conCmd){
conCmd = new ConCommand(dupstring(cmdName), MConsole::CommandCallback2);
icvar->RegisterConCommand(conCmd);
info->isSMJS = true;
}else{
SH_ADD_HOOK(ConCommand, Dispatch, conCmd, SH_STATIC(MConsole::CommandCallback), false);
info->isSMJS = false;
}
}
infoIt->second->hooks.push_back(wrapper);
}
mod_export char *
parse_subscript(char *s, int sub)
{
int l = strlen(s), err;
char *t;
if (!*s || *s == ']')
return 0;
lexsave();
untokenize(t = dupstring(s));
inpush(t, 0, NULL);
strinbeg(0);
len = 0;
bptr = tokstr = s;
bsiz = l + 1;
err = dquote_parse(']', sub);
if (err) {
err = *bptr;
*bptr = 0;
untokenize(s);
*bptr = err;
s = 0;
} else
s = bptr;
strinend();
inpop();
DPUTS(cmdsp, "BUG: parse_subscript: cmdstack not empty.");
lexrestore();
return s;
}
int
get_intarg(char **s)
{
char *t = get_strarg(*s + 1);
char *p, sav;
long ret;
if (!*t)
return -1;
sav = *t;
*t = '\0';
p = dupstring(*s + 2);
*s = t;
*t = sav;
if (parsestr(p))
return -1;
singsub(&p);
if (errflag)
return -1;
ret = matheval(p);
if (errflag)
return -1;
if (ret < 0)
ret = -ret;
return ret < 0 ? -ret : ret;
}
mod_export char *
parse_subscript(char *s, int sub, int endchar)
{
int l = strlen(s), err, toklen;
char *t;
if (!*s || *s == endchar)
return 0;
zcontext_save();
untokenize(t = dupstring(s));
inpush(t, 0, NULL);
strinbeg(0);
/*
* Warning to Future Generations:
*
* This way of passing the subscript through the lexer is brittle.
* Code above this for several layers assumes that when we tokenise
* the input it goes into the same place as the original string.
* However, the lexer may overwrite later bits of the string or
* reallocate it, in particular when expanding aliaes. To get
* around this, we copy the string and then copy it back. This is a
* bit more robust but still relies on the underlying assumption of
* length preservation.
*/
lexbuf.len = 0;
lexbuf.ptr = tokstr = dupstring(s);
lexbuf.siz = l + 1;
err = dquote_parse(endchar, sub);
toklen = (int)(lexbuf.ptr - tokstr);
DPUTS(toklen > l, "Bad length for parsed subscript");
memcpy(s, tokstr, toklen);
if (err) {
char *strend = s + toklen;
err = *strend;
*strend = '\0';
untokenize(s);
*strend = err;
s = NULL;
} else {
s += toklen;
}
strinend();
inpop();
DPUTS(cmdsp, "BUG: parse_subscript: cmdstack not empty.");
zcontext_restore();
return s;
}
void CString::Tokenize(char ***tokens, int *iNumTokens, char *szDelimiters) {
char *szBuf = dupstring(m_szString);
char *p;
int NumTokens = 0;
for (p = strtok(szBuf, szDelimiters); p; p = strtok(NULL, szDelimiters), NumTokens++);
char **tokenArray = NumTokens ? new char *[NumTokens] : NULL;
strcpy(szBuf, m_szString);
for (p = strtok(szBuf, szDelimiters), NumTokens = 0; p; p = strtok(NULL, szDelimiters))
tokenArray[NumTokens++] = dupstring(p);
*tokens = tokenArray;
*iNumTokens = NumTokens;
delete szBuf;
}
static char *
get_prebuffer(UNUSED(Param pm))
{
/*
* Use the editing current history line, not necessarily the
* history line that's currently in the history mechanism
* since our line may have been stacked.
*/
if (zle_chline) {
/* zle_chline was NULL terminated when pushed onto the stack */
return dupstring(zle_chline);
}
if (chline) {
/* hptr is valid */
return dupstrpfx(chline, hptr - chline);
}
return dupstring("");
}
CString &CString::operator = (const CString &source) {
m_iStringLength = source.m_iStringLength;
if (m_szString)
delete m_szString;
m_szString = dupstring(source.m_szString);
return *this;
}
static void
scanlanginfo(UNUSED(HashTable ht), ScanFunc func, int flags)
{
Param pm = NULL;
char **element, *langstr;
nl_item *nlcode;
pm = (Param) hcalloc(sizeof(struct param));
pm->gsu.s = &nullsetscalar_gsu;
pm->node.flags = PM_READONLY | PM_SCALAR;
nlcode = &nl_vals[0];
for (element = (char **)nl_names; *element; element++, nlcode++) {
if ((langstr = nl_langinfo(*nlcode)) != NULL) {
pm->u.str = dupstring(langstr);
pm->node.nam = dupstring(*element);
func(&pm->node, flags);
}
}
}
static HashNode
getterminfo(UNUSED(HashTable ht), const char *name)
{
int len, num;
char *tistr, *nameu;
Param pm = NULL;
/* This depends on the termcap stuff in init.c */
if (termflags & TERM_BAD)
return NULL;
if ((termflags & TERM_UNKNOWN) && (isset(INTERACTIVE) || !init_term()))
return NULL;
nameu = dupstring(name);
unmetafy(nameu, &len);
pm = (Param) hcalloc(sizeof(struct param));
pm->node.nam = nameu;
pm->node.flags = PM_READONLY;
if (((num = tigetnum(nameu)) != -1) && (num != -2)) {
pm->u.val = num;
pm->node.flags |= PM_INTEGER;
pm->gsu.i = &nullsetinteger_gsu;
} else if ((num = tigetflag(nameu)) != -1) {
pm->u.str = num ? dupstring("yes") : dupstring("no");
pm->node.flags |= PM_SCALAR;
pm->gsu.s = &nullsetscalar_gsu;
} else if ((tistr = (char *)tigetstr(nameu)) != NULL && tistr != (char *)-1) {
pm->u.str = dupstring(tistr);
pm->node.flags |= PM_SCALAR;
pm->gsu.s = &nullsetscalar_gsu;
} else {
/* zwarn("no such capability: %s", name); */
pm->u.str = dupstring("");
pm->node.flags |= PM_UNSET;
pm->gsu.s = &nullsetscalar_gsu;
}
return &pm->node;
}
static void
fillpmsysparams(Param pm, const char *name)
{
char buf[DIGBUFSIZE];
int num;
pm->node.nam = dupstring(name);
pm->node.flags = PM_SCALAR | PM_READONLY;
pm->gsu.s = &nullsetscalar_gsu;
if (!strcmp(name, "pid")) {
num = (int)getpid();
} else if (!strcmp(name, "ppid")) {
num = (int)getppid();
} else {
pm->u.str = dupstring("");
pm->node.flags |= PM_UNSET;
return;
}
sprintf(buf, "%d", num);
pm->u.str = dupstring(buf);
}
static void
store_monospaced_changed (const char *newfont)
{
if (current_mono_font != NULL && strcmp (newfont, current_mono_font) == 0)
return; /* No change. */
dupstring (¤t_mono_font, newfont);
if (dpyinfo_valid (first_dpyinfo) && use_system_font)
{
store_config_changed_event (Qmonospace_font_name,
XCAR (first_dpyinfo->name_list_element));
}
}
void
zshlex(void)
{
if (tok == LEXERR)
return;
do {
if (inrepeat_)
++inrepeat_;
if (inrepeat_ == 3 && isset(SHORTLOOPS))
incmdpos = 1;
tok = gettok();
} while (tok != ENDINPUT && exalias());
nocorrect &= 1;
if (tok == NEWLIN || tok == ENDINPUT) {
while (hdocs) {
struct heredocs *next = hdocs->next;
char *doc, *munged_term;
hwbegin(0);
cmdpush(hdocs->type == REDIR_HEREDOC ? CS_HEREDOC : CS_HEREDOCD);
munged_term = dupstring(hdocs->str);
STOPHIST
doc = gethere(&munged_term, hdocs->type);
ALLOWHIST
cmdpop();
hwend();
if (!doc) {
zerr("here document too large");
while (hdocs) {
next = hdocs->next;
zfree(hdocs, sizeof(struct heredocs));
hdocs = next;
}
tok = LEXERR;
break;
}
setheredoc(hdocs->pc, REDIR_HERESTR, doc, hdocs->str,
munged_term);
zfree(hdocs, sizeof(struct heredocs));
hdocs = next;
}
}
if (tok != NEWLIN)
isnewlin = 0;
else
isnewlin = (inbufct) ? -1 : 1;
if (tok == SEMI || (tok == NEWLIN && !(lexflags & LEXFLAGS_NEWLINE)))
tok = SEPER;
}
static int
checkalias(void)
{
Alias an;
if (!zshlextext)
return 0;
if (!noaliases && isset(ALIASESOPT) &&
(!isset(POSIXALIASES) ||
(tok == STRING && !reswdtab->getnode(reswdtab, zshlextext)))) {
char *suf;
an = (Alias) aliastab->getnode(aliastab, zshlextext);
if (an && !an->inuse &&
((an->node.flags & ALIAS_GLOBAL) ||
(incmdpos && tok == STRING) || inalmore)) {
if (!lexstop) {
/*
* Tokens that don't require a space after, get one,
* because they are treated as if preceded by one.
*/
int c = hgetc();
hungetc(c);
if (!iblank(c))
inpush(" ", INP_ALIAS, 0);
}
inpush(an->text, INP_ALIAS, an);
if (an->text[0] == ' ' && !(an->node.flags & ALIAS_GLOBAL))
aliasspaceflag = 1;
lexstop = 0;
return 1;
}
if ((suf = strrchr(zshlextext, '.')) && suf[1] &&
suf > zshlextext && suf[-1] != Meta &&
(an = (Alias)sufaliastab->getnode(sufaliastab, suf+1)) &&
!an->inuse && incmdpos) {
inpush(dupstring(zshlextext), INP_ALIAS, NULL);
inpush(" ", INP_ALIAS, NULL);
inpush(an->text, INP_ALIAS, an);
lexstop = 0;
return 1;
}
}
return 0;
}
static HashNode
getgdbmnode(HashTable ht, const char *name)
{
int len;
char *nameu;
Param pm = NULL;
nameu = dupstring(name);
unmetafy(nameu, &len);
pm = (Param) hcalloc(sizeof(struct param));
pm->node.nam = nameu;
pm->node.flags = PM_SCALAR;
pm->gsu.s = &gdbm_gsu;
pm->u.hash = ht;
return &pm->node;
}
mod_export int
parsestrnoerr(char *s)
{
int l = strlen(s), err;
lexsave();
untokenize(s);
inpush(dupstring(s), 0, NULL);
strinbeg(0);
len = 0;
bptr = tokstr = s;
bsiz = l + 1;
err = dquote_parse('\0', 1);
*bptr = '\0';
strinend();
inpop();
DPUTS(cmdsp, "BUG: parsestr: cmdstack not empty.");
lexrestore();
return err;
}
static char *
gdbmgetfn(Param pm)
{
datum key, content;
int ret;
GDBM_FILE dbf;
key.dptr = pm->node.nam;
key.dsize = strlen(key.dptr) + 1;
dbf = (GDBM_FILE)(pm->u.hash->tmpdata);
ret = gdbm_exists(dbf, key);
if(ret) {
content = gdbm_fetch(dbf, key);
} else {
content.dptr = dupstring("");
}
return content.dptr;
}
static HashNode
getpmmapfile(UNUSED(HashTable ht), char *name)
{
char *contents;
Param pm = NULL;
pm = (Param) hcalloc(sizeof(struct param));
pm->nam = dupstring(name);
pm->flags = PM_SCALAR;
pm->gsu.s = &mapfile_gsu;
pm->flags |= (mapfile_pm->flags & PM_READONLY);
/* Set u.str to contents of file given by name */
if ((contents = get_contents(pm->nam)))
pm->u.str = contents;
else {
pm->u.str = "";
pm->flags |= PM_UNSET;
}
return (HashNode) pm;
}
static int
bin_setcap(char *nam, char **argv, UNUSED(Options ops), UNUSED(int func))
{
cap_t caps;
int ret = 0;
unmetafy(*argv, NULL);
caps = cap_from_text(*argv++);
if(!caps) {
zwarnnam(nam, "invalid capability string");
return 1;
}
do {
if(cap_set_file(unmetafy(dupstring(*argv), NULL), caps)) {
zwarnnam(nam, "%s: %e", *argv, errno);
ret = 1;
}
} while(*++argv);
cap_free(caps);
return ret;
}
mod_export int
parsestrnoerr(char **s)
{
int l = strlen(*s), err;
zcontext_save();
untokenize(*s);
inpush(dupstring(*s), 0, NULL);
strinbeg(0);
lexbuf.len = 0;
lexbuf.ptr = tokstr = *s;
lexbuf.siz = l + 1;
err = dquote_parse('\0', 1);
if (tokstr)
*s = tokstr;
*lexbuf.ptr = '\0';
strinend();
inpop();
DPUTS(cmdsp, "BUG: parsestr: cmdstack not empty.");
zcontext_restore();
return err;
}