static void
smopts_core(const char *sname, char **argv)
{
struct smopts_s *sp;
struct name *np;
struct name *t;
int h;
char **ap;
if ((sp = findsmopts(sname, 1)) != NULL) {
char *cp;
cp = detract(sp->s_smopts, GSMOPTS);
(void)printf("%s already defined as: %s\n", sname, cp);
return;
}
h = hashcase(sname);
sp = ecalloc(1, sizeof(*sp));
sp->s_name = vcopy(sname);
if (smoptstbl[h])
sp->s_link = smoptstbl[h];
smoptstbl[h] = sp;
np = NULL;
for (ap = argv + 1; *ap != NULL; ap++) {
t = ncalloc(*ap, GSMOPTS);
if (sp->s_smopts == NULL)
sp->s_smopts = t;
else
np->n_flink = t;
t->n_blink = np;
np = t;
}
}
char *
strcatsub(char **d, char *pb, char *pe, char *src, int l, char *s, int glbsub)
{
int pl = pe - pb;
char *dest = ncalloc(pl + l + (s ? strlen(s) : 0) + 1);
*d = dest;
strncpy(dest, pb, pl);
dest += pl;
strcpy(dest, src);
if (glbsub)
tokenize(dest);
dest += l;
if (s)
strcpy(dest, s);
return dest;
}
int
multsub(char **s, char ***a, int *isarr, char *sep)
{
LinkList foo;
int l;
char **r, **p;
foo = newlinklist();
addlinknode(foo, *s);
prefork(foo, 0);
if (errflag) {
if (isarr)
*isarr = 0;
return 0;
}
if ((l = countlinknodes(foo)) > 1) {
p = r = ncalloc((l + 1) * sizeof(char*));
while (nonempty(foo))
*p++ = (char *)ugetnode(foo);
*p = NULL;
if (a) {
*a = r;
*isarr = 1;
return 0;
}
*s = sepjoin(r, NULL);
return 0;
}
if (l)
*s = (char *) ugetnode(foo);
else
*s = dupstring("");
if (isarr)
*isarr = 0;
return !l;
}
LinkNode
stringsubst(LinkList list, LinkNode node, int ssub)
{
int qt;
char *str3 = (char *)getdata(node);
char *str = str3;
while (!errflag && *str) {
if ((qt = *str == Qstring) || *str == String)
if (str[1] == Inpar) {
str++;
goto comsub;
} else if (str[1] == Inbrack) {
/* $[...] */
char *str2 = str;
str2++;
if (skipparens(Inbrack, Outbrack, &str2)) {
zerr("closing bracket missing", NULL, 0);
return NULL;
}
str2[-1] = *str = '\0';
str = arithsubst(str + 2, &str3, str2);
setdata(node, (void *) str3);
continue;
} else {
node = paramsubst(list, node, &str, qt, ssub);
if (errflag || !node)
return NULL;
str3 = (char *)getdata(node);
continue;
}
else if ((qt = *str == Qtick) || *str == Tick)
comsub: {
LinkList pl;
char *s, *str2 = str;
char endchar;
int l1, l2;
if (*str == Inpar) {
endchar = Outpar;
str[-1] = '\0';
if (skipparens(Inpar, Outpar, &str))
DPUTS(1, "Oops. parse error in command substitution");
str--;
} else {
endchar = *str;
*str = '\0';
while (*++str != endchar)
DPUTS(!*str, "Oops. parse error in command substitution");
}
*str++ = '\0';
if (endchar == Outpar && str2[1] == '(' && str[-2] == ')') {
/* Math substitution of the form $((...)) */
str = arithsubst(str2 + 1, &str3, str);
setdata(node, (void *) str3);
continue;
}
/* It is a command substitution, which will be parsed again *
* by the lexer, so we untokenize it first, but we cannot use *
* untokenize() since in the case of `...` some Bnulls should *
* be left unchanged. Note that the lexer doesn't tokenize *
* the body of a command substitution so if there are some *
* tokens here they are from a ${(e)~...} substitution. */
for (str = str2; *++str; )
if (itok(*str) && *str != Nularg &&
!(endchar != Outpar && *str == Bnull &&
(str[1] == '$' || str[1] == '\\' || str[1] == '`' ||
(qt && str[1] == '"'))))
*str = ztokens[*str - Pound];
str++;
if (!(pl = getoutput(str2 + 1, qt || ssub))) {
zerr("parse error in command substitution", NULL, 0);
return NULL;
}
if (endchar == Outpar)
str2--;
if (!(s = (char *) ugetnode(pl))) {
str = strcpy(str2, str);
continue;
}
if (!qt && ssub && isset(GLOBSUBST))
tokenize(s);
l1 = str2 - str3;
l2 = strlen(s);
if (nonempty(pl)) {
LinkNode n = lastnode(pl);
str2 = (char *) ncalloc(l1 + l2 + 1);
strcpy(str2, str3);
strcpy(str2 + l1, s);
setdata(node, str2);
insertlinklist(pl, node, list);
s = (char *) getdata(node = n);
l1 = 0;
l2 = strlen(s);
}
str2 = (char *) ncalloc(l1 + l2 + strlen(str) + 1);
if (l1)
strcpy(str2, str3);
strcpy(str2 + l1, s);
str = strcpy(str2 + l1 + l2, str);
str3 = str2;
setdata(node, str3);
continue;
}
str++;
}
return errflag ? NULL : node;
}
