const char *
mfn_with(MFUNARGS)
{
char vbuf[BUFFER_LEN];
char *ptr, *valptr;
int v, cnt;
ptr = MesgParse(argv[0], argv[0]);
CHECKRETURN(ptr,"WITH","arg 1");
v = new_mvar(ptr, vbuf);
if (v == 1)
ABORT_MPI("WITH","Variable name too long");
if (v == 2)
ABORT_MPI("WITH","Too many variables already defined");
valptr = MesgParse(argv[1], argv[1]);
CHECKRETURN(valptr,"WITH","arg 2");
*buf = '\0';
strcpy(vbuf, valptr);
for (cnt = 2; cnt < argc; cnt++) {
ptr = MesgParse(argv[cnt],argv[cnt]);
if (!ptr) {
sprintf(buf, "%s %cWITH%c (%d)", get_mvar("how"),
MFUN_LEADCHAR, MFUN_ARGEND, cnt);
notify(player, buf);
return NULL;
}
}
free_top_mvar();
return ptr;
}
const char *
mfn_func(MFUNARGS)
{
char *funcname;
char *ptr=NULL, *def;
char namebuf[BUFFER_LEN];
char argbuf[BUFFER_LEN];
char defbuf[BUFFER_LEN];
int i;
funcname = MesgParse(argv[0], namebuf, sizeof(namebuf));
CHECKRETURN(funcname, "FUNC", "name argument (1)");
def = argv[argc - 1];
for (i = 1; i < argc - 1; i++) {
ptr = MesgParse(argv[i], argbuf, sizeof(argbuf));
CHECKRETURN(ptr, "FUNC", "variable name argument");
snprintf(defbuf, sizeof(defbuf), "{with:%.*s,{:%d},%.*s}", MAX_MFUN_NAME_LEN, ptr, i,
(BUFFER_LEN - MAX_MFUN_NAME_LEN - 20), def);
}
i = new_mfunc(funcname, defbuf);
if (i == 1)
ABORT_MPI("FUNC", "Function Name too long.");
if (i == 2)
ABORT_MPI("FUNC", "Too many functions defined.");
return "";
}
const char *
mfn_commas(MFUNARGS)
{
int v, i, count;
char *ptr;
char buf2[BUFFER_LEN];
char tmp[BUFFER_LEN];
if (argc == 3)
ABORT_MPI("COMMAS","Takes 1, 2, or 4 arguments");
ptr = MesgParse(argv[0], argv[0]);
CHECKRETURN(ptr,"COMMAS","arg 1");
count = countlitems(argv[0], "\r");
if (count == 0) return "";
if (argc > 1) {
ptr = MesgParse(argv[1], argv[1]);
CHECKRETURN(ptr,"COMMAS","arg 2");
} else {
strcpy(argv[1], " and ");
}
if (argc > 2) {
ptr = MesgParse(argv[2], buf2);
CHECKRETURN(ptr,"COMMAS","arg 3");
v = new_mvar(ptr, tmp);
if (v == 1)
ABORT_MPI("COMMAS","Variable name too long");
if (v == 2)
ABORT_MPI("COMMAS","Too many variables already defined");
}
*buf = '\0';
for (i = 1; i <= count; i++) {
ptr = getlitem(buf2, argv[0], "\r", i);
if (argc > 2) {
strcpy(tmp, ptr);
ptr = MesgParse(argv[3], buf2);
CHECKRETURN(ptr,"COMMAS","arg 3");
}
strcat(buf, ptr);
switch (count - i) {
case 0:
if (argc > 2) free_top_mvar();
return buf;
break;
case 1:
strcat(buf, argv[1]);
break;
default:
strcat(buf, ", ");
break;
}
}
if (argc > 2) free_top_mvar();
return buf;
}
const char *
mfn_filter(MFUNARGS)
{
int iter_limit = MAX_MFUN_LIST_LEN;
char buf2[BUFFER_LEN];
char tmp[BUFFER_LEN];
char *ptr, *ptr2, *dptr;
char *sepin = argv[3];
char *sepbuf = argv[4];
int seplen, v;
ptr = MesgParse(argv[0],argv[0]);
CHECKRETURN(ptr,"FILTER","arg 1");
v = new_mvar(ptr, tmp);
if (v == 1)
ABORT_MPI("FILTER","Variable name too long.");
if (v == 2)
ABORT_MPI("FILTER","Too many variables already defined.");
dptr = MesgParse(argv[1],argv[1]);
CHECKRETURN(dptr,"FILTER","arg 2");
if (argc > 3) {
ptr = MesgParse(sepin,sepin);
CHECKRETURN(ptr,"FILTER","arg 4");
if (!*ptr)
ABORT_MPI("FILTER","Can't use Null seperator string");
} else {
strcpy(sepin, "\r");
}
if (argc > 4) {
ptr = MesgParse(sepbuf,sepbuf);
CHECKRETURN(ptr,"FILTER","arg 5");
} else {
strcpy(sepbuf, sepin);
}
seplen = strlen(sepin);
*buf = '\0';
ptr = dptr;
while (*ptr) {
for (ptr2 = ptr; *ptr2 && strncmp(ptr2, sepin, seplen); ptr2++);
if (*ptr2) {
*ptr2 = '\0';
ptr2 += seplen;
}
strcpy(tmp, ptr);
dptr = MesgParse(argv[2],buf2);
CHECKRETURN(dptr,"FILTER","arg 3");
if (truestr(buf2)) {
if (*buf) strcat(buf, sepbuf);
strcat(buf, ptr);
}
ptr = ptr2;
if (!(--iter_limit))
ABORT_MPI("FILTER","Iteration limit exceeded");
}
free_top_mvar();
return buf;
}
const char *
mfn_debugif(MFUNARGS)
{
char *ptr = MesgParse(argv[0], argv[0]);
CHECKRETURN(ptr,"DEBUGIF","arg 1");
if (truestr(argv[0])) {
ptr = mesg_parse(player, what, perms, argv[1],
buf, BUFFER_LEN, (mesgtyp | MPI_ISDEBUG));
} else {
ptr = MesgParse(argv[1], buf);
}
CHECKRETURN(ptr,"DEBUGIF","arg 2");
return buf;
}
const char *
mfn_default(MFUNARGS)
{
char *ptr;
*buf = '\0';
ptr = MesgParse(argv[0], buf, buflen);
CHECKRETURN(ptr, "DEFAULT", "arg 1");
if (ptr && truestr(buf)) {
if (!ptr)
ptr = "";
} else {
ptr = MesgParse(argv[1], buf, buflen);
CHECKRETURN(ptr, "DEFAULT", "arg 2");
}
return ptr;
}
const char *
mfn_while(MFUNARGS)
{
int iter_limit = MAX_MFUN_LIST_LEN;
char buf2[BUFFER_LEN];
char *ptr;
*buf = '\0';
while (1) {
ptr = MesgParse(argv[0], buf2, sizeof(buf2));
CHECKRETURN(ptr, "WHILE", "arg 1");
if (!truestr(ptr))
break;
ptr = MesgParse(argv[1], buf, buflen);
CHECKRETURN(ptr, "WHILE", "arg 2");
if (!(--iter_limit))
ABORT_MPI("WHILE", "Iteration limit exceeded");
}
return buf;
}
char *
do_parse_mesg_2(int descr, dbref player, dbref what, dbref perms, const char *inbuf,
const char *abuf, char *outbuf, int mesgtyp)
{
char howvar[BUFFER_LEN];
char cmdvar[BUFFER_LEN];
char argvar[BUFFER_LEN];
char tmparg[BUFFER_LEN];
char tmpcmd[BUFFER_LEN];
char *dptr;
int mvarcnt = varc;
int mfunccnt = funcc;
int tmprec_cnt = mesg_rec_cnt;
int tmpinst_cnt = mesg_instr_cnt;
#ifdef COMPRESS
abuf = uncompress(abuf);
#endif /* COMPRESS */
*outbuf = '\0';
if (new_mvar("how", howvar)) return outbuf;
strcpy(howvar, abuf);
if (new_mvar("cmd", cmdvar)) return outbuf;
strcpy(cmdvar, match_cmdname);
strcpy(tmpcmd, match_cmdname);
if (new_mvar("arg", argvar)) return outbuf;
strcpy(argvar, match_args);
strcpy(tmparg, match_args);
#ifdef COMPRESS
inbuf = uncompress(inbuf);
#endif /* COMPRESS */
dptr = MesgParse(inbuf, outbuf);
if (!dptr) {
*outbuf = '\0';
}
varc = mvarcnt;
free_mfuncs(mfunccnt);
mesg_rec_cnt = tmprec_cnt;
mesg_instr_cnt = tmpinst_cnt;
strcpy(match_cmdname, tmpcmd);
strcpy(match_args, tmparg);
return outbuf;
}
const char *
mfn_for(MFUNARGS)
{
int iter_limit = MAX_MFUN_LIST_LEN;
char tmp[BUFFER_LEN];
char *ptr, *dptr;
int v, i, start, end, incr;
ptr = MesgParse(argv[0],argv[0]);
CHECKRETURN(ptr,"FOR","arg 1 (varname)");
v = new_mvar(ptr, tmp);
if (v == 1)
ABORT_MPI("FOR","Variable name too long");
if (v == 2)
ABORT_MPI("FOR","Too many variables already defined");
dptr = MesgParse(argv[1],argv[1]);
CHECKRETURN(dptr,"FOR","arg 2 (start num)");
start = atoi(dptr);
dptr = MesgParse(argv[2],argv[2]);
CHECKRETURN(dptr,"FOR","arg 3 (end num)");
end = atoi(dptr);
dptr = MesgParse(argv[3],argv[3]);
CHECKRETURN(dptr,"FOR","arg 4 (increment)");
incr = atoi(dptr);
*buf = '\0';
for (i = start; ((incr>=0 && i<=end) || (incr<0 && i>=end)); i += incr) {
sprintf(tmp, "%d", i);
dptr = MesgParse(argv[4],buf);
CHECKRETURN(dptr,"FOR","arg 5 (repeated command)");
if (!(--iter_limit))
ABORT_MPI("FOR","Iteration limit exceeded");
}
free_top_mvar();
return buf;
}
const char *
mfn_if(MFUNARGS)
{
char *fbr, *ptr;
if (argc == 3) {
fbr = argv[2];
} else {
fbr = "";
}
ptr = MesgParse(argv[0], buf, buflen);
CHECKRETURN(ptr, "IF", "arg 1");
if (ptr && truestr(buf)) {
ptr = MesgParse(argv[1], buf, buflen);
CHECKRETURN(ptr, "IF", "arg 2");
} else if (*fbr) {
ptr = MesgParse(fbr, buf, buflen);
CHECKRETURN(ptr, "IF", "arg 3");
} else {
*buf = '\0';
ptr = "";
}
return ptr;
}
const char *
mfn_and(MFUNARGS)
{
char *ptr;
char buf2[16];
int i;
for (i = 0; i < argc; i++) {
ptr = MesgParse(argv[i], buf, buflen);
snprintf(buf2, sizeof(buf2), "arg %d", i + 1);
CHECKRETURN(ptr, "AND", buf2);
if (!truestr(ptr)) {
return "0";
}
}
return "1";
}
/******** HOOK ********/
char *
mesg_parse(int descr, dbref player, dbref what, dbref perms,
const char *inbuf, char *outbuf, int maxchars, int mesgtyp)
{
char wbuf[BUFFER_LEN];
char buf[BUFFER_LEN];
char buf2[BUFFER_LEN];
char dbuf[BUFFER_LEN];
char ebuf[BUFFER_LEN];
char cmdbuf[MAX_MFUN_NAME_LEN + 1];
const char *ptr;
char *dptr;
int p, q, s;
int i;
char *argv[10] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
int argc = 0;
int showtextflag = 0;
int literalflag = 0;
mesg_rec_cnt++;
if (mesg_rec_cnt > 26) {
char *zptr = get_mvar("how");
snprintf(dbuf, sizeof(dbuf), "%s Recursion limit exceeded.", zptr);
notify_nolisten(player, dbuf, 1);
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
if (Typeof(player) == TYPE_GARBAGE) {
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
if (Typeof(what) == TYPE_GARBAGE) {
notify_nolisten(player, "MPI Error: Garbage trigger.", 1);
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
strcpyn(wbuf, sizeof(wbuf), inbuf);
for (p = q = 0; wbuf[p] && (p < maxchars - 1) && q < (maxchars - 1); p++) {
if (wbuf[p] == '\\') {
p++;
showtextflag = 1;
if (wbuf[p] == 'r') {
outbuf[q++] = '\r';
} else if (wbuf[p] == '[') {
outbuf[q++] = ESCAPE_CHAR;
} else {
outbuf[q++] = wbuf[p];
}
} else if (wbuf[p] == MFUN_LITCHAR) {
literalflag = (!literalflag);
} else if (!literalflag && wbuf[p] == MFUN_LEADCHAR) {
if (wbuf[p + 1] == MFUN_LEADCHAR) {
showtextflag = 1;
outbuf[q++] = wbuf[p++];
ptr = "";
} else {
ptr = wbuf + (++p);
s = 0;
while (wbuf[p] && wbuf[p] != MFUN_LEADCHAR &&
!isspace(wbuf[p]) && wbuf[p] != MFUN_ARGSTART &&
wbuf[p] != MFUN_ARGEND && s < MAX_MFUN_NAME_LEN) {
p++;
s++;
}
if (s < MAX_MFUN_NAME_LEN &&
(wbuf[p] == MFUN_ARGSTART || wbuf[p] == MFUN_ARGEND)) {
int varflag;
strncpy(cmdbuf, ptr, s);
cmdbuf[s] = '\0';
varflag = 0;
if (*cmdbuf == '&') {
s = find_mfn("sublist");
varflag = 1;
} else if (*cmdbuf) {
s = find_mfn(cmdbuf);
} else {
s = 0;
}
if (s) {
s--;
if (++mesg_instr_cnt > tp_mpi_max_commands) {
char *zptr = get_mvar("how");
snprintf(dbuf, sizeof(dbuf), "%s %c%s%c: Instruction limit exceeded.",
zptr, MFUN_LEADCHAR,
(varflag ? cmdbuf : mfun_list[s].name), MFUN_ARGEND);
notify_nolisten(player, dbuf, 1);
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
for (i = 0; i < argc; i++) {
free(argv[i]);
argv[i] = NULL;
}
if (wbuf[p] == MFUN_ARGEND) {
argc = 0;
} else {
argc = mfun_list[s].maxargs;
if (argc < 0) {
argc = mesg_args((wbuf + p + 1), (sizeof(wbuf) - p - 1),
&argv[(varflag ? 1 : 0)],
MFUN_LEADCHAR, MFUN_ARGSEP,
MFUN_ARGEND, MFUN_LITCHAR,
(-argc) + (varflag ? 1 : 0));
} else {
argc = mesg_args((wbuf + p + 1), (sizeof(wbuf) - p - 1),
&argv[(varflag ? 1 : 0)],
MFUN_LEADCHAR, MFUN_ARGSEP,
MFUN_ARGEND, MFUN_LITCHAR, (varflag ? 8 : 9));
}
if (argc == -1) {
char *zptr = get_mvar("how");
snprintf(ebuf, sizeof(ebuf), "%s %c%s%c: End brace not found.",
zptr, MFUN_LEADCHAR, cmdbuf, MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
for (i = 0; i < argc; i++) {
free(argv[i + (varflag? 1 : 0)]);
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
}
if (varflag) {
char *zptr;
zptr = get_mvar(cmdbuf + 1);
if (!zptr) {
zptr = get_mvar("how");
snprintf(ebuf, sizeof(ebuf), "%s %c%s%c: Unrecognized variable.",
zptr, MFUN_LEADCHAR, cmdbuf, MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
for (i = 0; i < argc; i++) {
if (argv[i + (varflag? 1 : 0)]) {
free(argv[i + (varflag? 1 : 0)]);
}
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
if (argv[0]) {
free(argv[0]);
argv[0] = NULL;
}
argv[0] = string_dup(zptr);
argc++;
}
if (mesgtyp & MPI_ISDEBUG) {
char *zptr = get_mvar("how");
snprintf(dbuf, sizeof(dbuf), "%s %*s%c%s%c", zptr,
(mesg_rec_cnt * 2 - 4), "", MFUN_LEADCHAR,
(varflag ? cmdbuf : mfun_list[s].name), MFUN_ARGSTART);
for (i = (varflag ? 1 : 0); i < argc; i++) {
if (i) {
const char tbuf[] = { MFUN_ARGSEP, '\0' };
strcatn(dbuf, sizeof(dbuf), tbuf);
}
cr2slash(ebuf, sizeof(ebuf)/8, argv[i]);
strcatn(dbuf, sizeof(dbuf), "`");
strcatn(dbuf, sizeof(dbuf), ebuf);
if (strlen(ebuf) >= (sizeof(ebuf)/8)-2) {
strcatn(dbuf, sizeof(dbuf), "...");
}
strcatn(dbuf, sizeof(dbuf), "`");
}
{
const char tbuf[] = { MFUN_ARGEND, '\0' };
strcatn(dbuf, sizeof(dbuf), tbuf);
}
notify_nolisten(player, dbuf, 1);
}
if (mfun_list[s].stripp) {
for (i = (varflag ? 1 : 0); i < argc; i++) {
stripspaces(buf, sizeof(buf), argv[i]);
/*
* stripspaces() can only shorten a string.
* The argv[i] buffer will therefore always
* be large enough.
*/
strcpyn(argv[i], strlen(buf)+1, buf);
}
}
if (mfun_list[s].parsep) {
for (i = (varflag ? 1 : 0); i < argc; i++) {
ptr = MesgParse(argv[i], buf, sizeof(buf));
if (!ptr) {
char *zptr = get_mvar("how");
snprintf(dbuf, sizeof(dbuf), "%s %c%s%c (arg %d)", zptr,
MFUN_LEADCHAR,
(varflag ? cmdbuf : mfun_list[s].name),
MFUN_ARGEND, i + 1);
notify_nolisten(player, dbuf, 1);
for (i = 0; i < argc; i++) {
free(argv[i]);
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
argv[i] = (char*)realloc(argv[i], strlen(buf) + 1);
strcpyn(argv[i], strlen(buf)+1, buf);
}
}
if (mesgtyp & MPI_ISDEBUG) {
char *zptr = get_mvar("how");
snprintf(dbuf, sizeof(dbuf), "%.512s %*s%c%.512s%c", zptr,
(mesg_rec_cnt * 2 - 4), "", MFUN_LEADCHAR,
(varflag ? cmdbuf : mfun_list[s].name), MFUN_ARGSTART);
for (i = (varflag ? 1 : 0); i < argc; i++) {
if (i) {
const char tbuf[] = { MFUN_ARGSEP, '\0' };
strcatn(dbuf, sizeof(dbuf), tbuf);
}
cr2slash(ebuf, sizeof(ebuf)/8, argv[i]);
strcatn(dbuf, sizeof(dbuf), "`");
strcatn(dbuf, sizeof(dbuf), ebuf);
if (strlen(ebuf) >= (sizeof(ebuf)/8)-2) {
strcatn(dbuf, sizeof(dbuf), "...");
}
strcatn(dbuf, sizeof(dbuf), "`");
}
{
const char tbuf[] = { MFUN_ARGEND, '\0' };
strcatn(dbuf, sizeof(dbuf), tbuf);
}
}
if (argc < mfun_list[s].minargs) {
char *zptr = get_mvar("how");
snprintf(ebuf, sizeof(ebuf), "%s %c%s%c: Too few arguments",
zptr, MFUN_LEADCHAR,
(varflag ? cmdbuf : mfun_list[s].name), MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
for (i = 0; i < argc; i++) {
free(argv[i]);
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
} else if (mfun_list[s].maxargs > 0 && argc > mfun_list[s].maxargs) {
char *zptr = get_mvar("how");
snprintf(ebuf, sizeof(ebuf), "%s %c%s%c: Too many arguments",
zptr, MFUN_LEADCHAR,
(varflag ? cmdbuf : mfun_list[s].name), MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
for (i = 0; i < argc; i++) {
free(argv[i]);
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
} else {
ptr = mfun_list[s].mfn(descr, player, what, perms,
argc, argv, buf, sizeof(buf), mesgtyp);
if (!ptr) {
outbuf[q] = '\0';
for (i = 0; i < argc; i++) {
free(argv[i]);
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
if (mfun_list[s].postp) {
dptr = MesgParse(ptr, buf, sizeof(buf));
if (!dptr) {
char *zptr = get_mvar("how");
snprintf(ebuf, sizeof(ebuf), "%s %c%s%c (returned string)",
zptr, MFUN_LEADCHAR,
(varflag ? cmdbuf : mfun_list[s].name),
MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
for (i = 0; i < argc; i++) {
free(argv[i]);
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
ptr = dptr;
}
}
if (mesgtyp & MPI_ISDEBUG) {
strcatn(dbuf, sizeof(dbuf), " = `");
cr2slash(ebuf, sizeof(ebuf)/8, ptr);
strcatn(dbuf, sizeof(dbuf), ebuf);
if (strlen(ebuf) >= (sizeof(ebuf)/8)-2) {
strcatn(dbuf, sizeof(dbuf), "...");
}
strcatn(dbuf, sizeof(dbuf), "`");
notify_nolisten(player, dbuf, 1);
}
} else if (msg_is_macro(player, what, perms, cmdbuf, mesgtyp)) {
for (i = 0; i < argc; i++) {
free(argv[i]);
argv[i] = NULL;
}
if (wbuf[p] == MFUN_ARGEND) {
argc = 0;
p++;
} else {
p++;
argc = mesg_args(wbuf + p, (sizeof(wbuf) - p), argv, MFUN_LEADCHAR,
MFUN_ARGSEP, MFUN_ARGEND, MFUN_LITCHAR, 9);
if (argc == -1) {
char *zptr = get_mvar("how");
snprintf(ebuf, sizeof(ebuf), "%s %c%s%c: End brace not found.",
zptr, MFUN_LEADCHAR, cmdbuf, MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
for (i = 0; i < argc; i++) {
free(argv[i]);
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
}
msg_unparse_macro(player, what, perms, cmdbuf, argc,
argv, (wbuf + p), (BUFFER_LEN - p),
mesgtyp);
p--;
ptr = NULL;
} else {
/* unknown function */
char *zptr = get_mvar("how");
snprintf(ebuf, sizeof(ebuf), "%s %c%s%c: Unrecognized function.",
zptr, MFUN_LEADCHAR, cmdbuf, MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
for (i = 0; i < argc; i++) {
free(argv[i]);
}
mesg_rec_cnt--;
outbuf[0] = '\0';
return NULL;
}
} else {
showtextflag = 1;
ptr--;
i = s + 1;
while (ptr && *ptr && i-- && q < (maxchars - 1)) {
outbuf[q++] = *(ptr++);
}
outbuf[q] = '\0';
p = (int) (ptr - wbuf) - 1;
ptr = ""; /* unknown substitution type */
}
while (ptr && *ptr && q < (maxchars - 1)) {
outbuf[q++] = *(ptr++);
}
}
} else {
outbuf[q++] = wbuf[p];
showtextflag = 1;
}
}
outbuf[q] = '\0';
if ((mesgtyp & MPI_ISDEBUG) && showtextflag) {
char *zptr = get_mvar("how");
snprintf(dbuf, sizeof(dbuf), "%s %*s`%.512s`",
zptr, (mesg_rec_cnt * 2 - 4), "",
cr2slash(buf2, sizeof(buf2), outbuf));
notify_nolisten(player, dbuf, 1);
}
for (i = 0; i < argc; i++) {
free(argv[i]);
}
mesg_rec_cnt--;
outbuf[maxchars - 1] = '\0';
return (outbuf);
}
char *
do_parse_mesg_2(int descr, dbref player, dbref what, dbref perms,
const char *inbuf, const char *abuf, char *outbuf, int outbuflen,
int mesgtyp)
{
char howvar[BUFFER_LEN];
char cmdvar[BUFFER_LEN];
char argvar[BUFFER_LEN];
char tmparg[BUFFER_LEN];
char tmpcmd[BUFFER_LEN];
char *dptr;
int mvarcnt = varc;
int mfunccnt = funcc;
int tmprec_cnt = mesg_rec_cnt;
int tmpinst_cnt = mesg_instr_cnt;
*outbuf = '\0';
if ((mesgtyp & MPI_NOHOW) == 0)
{
if (new_mvar("how", howvar))
{
snprintf(howvar, sizeof(howvar), "%s Out of MPI variables.", abuf);
notify_nolisten(player, howvar, 1);
varc = mvarcnt;
return outbuf;
}
strcpyn(howvar, sizeof(howvar), abuf);
}
if (new_mvar("cmd", cmdvar))
{
snprintf(cmdvar, sizeof(cmdvar), "%s Out of MPI variables.", abuf);
notify_nolisten(player, cmdvar, 1);
varc = mvarcnt;
return outbuf;
}
strcpyn(cmdvar, sizeof(cmdvar), match_cmdname);
strcpyn(tmpcmd, sizeof(tmpcmd), match_cmdname);
if (new_mvar("arg", argvar))
{
snprintf(argvar, sizeof(argvar), "%s Out of MPI variables.", abuf);
notify_nolisten(player, argvar, 1);
varc = mvarcnt;
return outbuf;
}
strcpyn(argvar, sizeof(argvar), match_args);
strcpyn(tmparg, sizeof(tmparg), match_args);
dptr = MesgParse(inbuf, outbuf, outbuflen);
if (!dptr) {
*outbuf = '\0';
}
varc = mvarcnt;
free_mfuncs(mfunccnt);
mesg_rec_cnt = tmprec_cnt;
mesg_instr_cnt = tmpinst_cnt;
strcpyn(match_cmdname, sizeof(match_cmdname), tmpcmd);
strcpyn(match_args, sizeof(match_args), tmparg);
return outbuf;
}
/******** HOOK ********/
char *
mesg_parse(dbref player, dbref what, dbref perms, const char *inbuf, char *outbuf, int maxchars, int mesgtyp)
{
char wbuf[BUFFER_LEN];
char buf[BUFFER_LEN];
char buf2[BUFFER_LEN];
char dbuf[BUFFER_LEN];
char ebuf[BUFFER_LEN];
char cmdbuf[MAX_MFUN_NAME_LEN + 1];
const char *ptr;
char *dptr;
int p, q, s;
int i;
char argv[9][BUFFER_LEN];
int argc;
int showtextflag = 0;
int literalflag = 0;
mesg_rec_cnt++;
if (mesg_rec_cnt > 26) {
mesg_rec_cnt--;
strncpy(outbuf, inbuf, maxchars);
outbuf[maxchars - 1] = '\0';
return outbuf;
}
if (Typeof(player) == TYPE_GARBAGE) {
return NULL;
}
if (Typeof(what) == TYPE_GARBAGE) {
notify_nolisten(player, "MPI Error: Garbage trigger.", 1);
return NULL;
}
strcpy(wbuf, inbuf);
for (p = q = 0; wbuf[p] && (p < maxchars - 1) && q < (maxchars - 1); p++) {
if (wbuf[p] == '\\') {
p++;
showtextflag = 1;
if (wbuf[p] == 'r') {
outbuf[q++] = '\r';
} else {
outbuf[q++] = wbuf[p];
}
} else if (wbuf[p] == MFUN_LITCHAR) {
literalflag = (!literalflag);
} else if (!literalflag && wbuf[p] == MFUN_LEADCHAR) {
if (wbuf[p + 1] == MFUN_LEADCHAR) {
showtextflag = 1;
outbuf[q++] = wbuf[p++];
ptr = "";
} else {
ptr = wbuf + (++p);
s = 0;
while (wbuf[p] && wbuf[p] != MFUN_LEADCHAR &&
!isspace(wbuf[p]) && wbuf[p] != MFUN_ARGSTART &&
wbuf[p] != MFUN_ARGEND && s < MAX_MFUN_NAME_LEN) {
p++; s++;
}
if (s < MAX_MFUN_NAME_LEN &&
(wbuf[p] == MFUN_ARGSTART || wbuf[p] == MFUN_ARGEND)) {
int varflag;
strncpy(cmdbuf,ptr,s);
cmdbuf[s] = '\0';
varflag = 0;
if (*cmdbuf == '&') {
s = find_mfn("sublist");
varflag = 1;
} else if (*cmdbuf) {
s = find_mfn(cmdbuf);
} else {
s = 0;
}
if (s) {
s--;
if (++mesg_instr_cnt > tp_mpi_max_commands) {
char *zptr = get_mvar("how");
sprintf(dbuf, "%s %c%s%c: Instruction limit exceeded.",
zptr, MFUN_LEADCHAR,
(varflag? cmdbuf : mfun_list[s].name),
MFUN_ARGEND);
notify_nolisten(player, dbuf, 1);
return NULL;
}
if (wbuf[p] == MFUN_ARGEND) {
argc = 0;
} else {
argc = mfun_list[s].maxargs;
if (argc < 0) {
argc = mesg_args((wbuf+p+1),
&argv[(varflag? 1 : 0)],
MFUN_LEADCHAR, MFUN_ARGSEP,
MFUN_ARGEND, MFUN_LITCHAR,
(-argc) + (varflag? 1 : 0));
} else {
argc = mesg_args((wbuf+p+1),
&argv[(varflag? 1 : 0)],
MFUN_LEADCHAR, MFUN_ARGSEP,
MFUN_ARGEND, MFUN_LITCHAR,
(varflag? 8 : 9));
}
if (argc == -1) {
char *zptr = get_mvar("how");
sprintf(ebuf, "%s %c%s%c: End brace not found.",
zptr, MFUN_LEADCHAR, cmdbuf,
MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
return NULL;
}
}
if (varflag) {
char *zptr;
argc++;
zptr = get_mvar(cmdbuf + 1);
if (!zptr) {
zptr = get_mvar("how");
sprintf(ebuf, "%s %c%s%c: Unrecognized variable.",
zptr, MFUN_LEADCHAR, cmdbuf, MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
return NULL;
}
strcpy(argv[0], zptr);
}
if (mesgtyp & MPI_ISDEBUG) {
char *zptr = get_mvar("how");
sprintf(dbuf, "%s %*s%c%s%c", zptr,
(mesg_rec_cnt*2-4), "", MFUN_LEADCHAR,
(varflag? cmdbuf : mfun_list[s].name),
MFUN_ARGSTART);
for (i = (varflag? 1 : 0); i < argc; i++) {
if (i) {
sprintf(dbuf, "%.512s%c ", dbuf,
MFUN_ARGSEP);
}
cr2slash(ebuf, argv[i]);
if (strlen(ebuf) > 512) {
sprintf(dbuf, "%.512s\"%.512s...\"",
dbuf, ebuf);
} else {
sprintf(dbuf, "%.512s\"%s\"", dbuf, ebuf);
}
}
sprintf(dbuf, "%.512s%c", dbuf, MFUN_ARGEND);
notify_nolisten(player, dbuf, 1);
}
if (mfun_list[s].stripp) {
for (i = (varflag? 1 : 0); i < argc; i++) {
strcpy(argv[i], stripspaces(buf, argv[i]));
}
}
if (mfun_list[s].parsep) {
for (i = (varflag? 1 : 0); i < argc; i++) {
ptr = MesgParse(argv[i], argv[i]);
if (!ptr) {
char *zptr = get_mvar("how");
sprintf(dbuf, "%s %c%s%c (arg %d)", zptr,
MFUN_LEADCHAR,
(varflag?cmdbuf:mfun_list[s].name),
MFUN_ARGEND, i+1);
notify_nolisten(player, dbuf, 1);
return NULL;
}
}
}
if (mesgtyp & MPI_ISDEBUG) {
char *zptr = get_mvar("how");
sprintf(dbuf, "%.512s %*s%c%.512s%c", zptr,
(mesg_rec_cnt*2-4), "", MFUN_LEADCHAR,
(varflag? cmdbuf : mfun_list[s].name),
MFUN_ARGSTART);
for (i = (varflag? 1 : 0); i < argc; i++) {
if (i) {
sprintf(dbuf, "%.512s%c ", dbuf,
MFUN_ARGSEP);
}
cr2slash(ebuf, argv[i]);
if (strlen(ebuf) > 128) {
sprintf(dbuf, "%.512s\"%.128s...\"",
dbuf, ebuf);
} else {
sprintf(dbuf, "%.512s\"%s\"", dbuf, ebuf);
}
}
sprintf(dbuf, "%s%c", dbuf, MFUN_ARGEND);
}
if (argc < mfun_list[s].minargs) {
char *zptr = get_mvar("how");
sprintf(ebuf, "%s %c%s%c: Too few arguments",
zptr, MFUN_LEADCHAR,
(varflag? cmdbuf : mfun_list[s].name),
MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
return NULL;
} else if (mfun_list[s].maxargs > 0 &&
argc > mfun_list[s].maxargs) {
char *zptr = get_mvar("how");
sprintf(ebuf, "%s %c%s%c: Too many arguments",
zptr, MFUN_LEADCHAR,
(varflag? cmdbuf : mfun_list[s].name),
MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
return NULL;
} else {
ptr = mfun_list[s].mfn(player, what, perms, argc,
argv, buf, mesgtyp);
if (!ptr) {
outbuf[q] = '\0';
return NULL;
}
if (mfun_list[s].postp) {
dptr = MesgParse(ptr, buf);
if (!dptr) {
char *zptr = get_mvar("how");
sprintf(ebuf, "%s %c%s%c (returned string)",
zptr, MFUN_LEADCHAR,
(varflag?cmdbuf:mfun_list[s].name),
MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
return NULL;
}
ptr = dptr;
}
}
if (mesgtyp & MPI_ISDEBUG) {
sprintf(dbuf, "%.512s = \"%.512s\"", dbuf,
cr2slash(ebuf, ptr));
notify_nolisten(player, dbuf, 1);
}
} else if (msg_is_macro(player, what, perms, cmdbuf)) {
if (wbuf[p] == MFUN_ARGEND) {
argc = 0;
p++;
} else {
p++;
argc = mesg_args(wbuf+p, argv, MFUN_LEADCHAR,
MFUN_ARGSEP, MFUN_ARGEND, MFUN_LITCHAR, 9);
if (argc == -1) {
char *zptr = get_mvar("how");
sprintf(ebuf, "%s %c%s%c: End brace not found.",
zptr, MFUN_LEADCHAR, cmdbuf,
MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
return NULL;
}
}
msg_unparse_macro(player, what, perms, cmdbuf, argc,
argv, (wbuf+p), (BUFFER_LEN - p));
p--;
ptr = NULL;
} else {
/* unknown function */
char *zptr = get_mvar("how");
sprintf(ebuf, "%s %c%s%c: Unrecognized function.",
zptr, MFUN_LEADCHAR, cmdbuf, MFUN_ARGEND);
notify_nolisten(player, ebuf, 1);
return NULL;
}
} else {
showtextflag = 1;
p = (int) (ptr - wbuf);
if (q < (maxchars - 1))
outbuf[q++] = MFUN_LEADCHAR;
ptr = ""; /* unknown substitution type */
}
while (ptr && *ptr && q < (maxchars -1))
outbuf[q++] = *(ptr++);
}
} else {
outbuf[q++] = wbuf[p];
showtextflag = 1;
}
}
outbuf[q] = '\0';
if ((mesgtyp & MPI_ISDEBUG) && showtextflag) {
char *zptr = get_mvar("how");
sprintf(dbuf, "%s %*s\"%.512s\"", zptr, (mesg_rec_cnt*2-4), "",
cr2slash(buf2, outbuf));
notify_nolisten(player, dbuf, 1);
}
mesg_rec_cnt--;
return (outbuf);
}
const char *
mfn_lsort(MFUNARGS)
{
char *litem[MAX_MFUN_LIST_LEN];
char vbuf[BUFFER_LEN];
char vbuf2[BUFFER_LEN];
char *ptr, *ptr2, *tmp;
int i, j, count;
if (argc > 1 && argc < 4)
ABORT_MPI("LSORT","Takes 1 or 4 arguments");
for (i = 0; i < MAX_MFUN_LIST_LEN; i++)
litem[i] = NULL;
ptr = MesgParse(argv[0],argv[0]);
CHECKRETURN(ptr,"LSORT","arg 1");
if (argc > 1) {
ptr2 = MesgParse(argv[1], argv[1]);
CHECKRETURN(ptr2,"LSORT","arg 2");
j = new_mvar(ptr2, vbuf);
if (j == 1)
ABORT_MPI("LSORT","Variable name too long");
if (j == 2)
ABORT_MPI("LSORT","Too many variables already defined");
ptr2 = MesgParse(argv[2],argv[2]);
CHECKRETURN(ptr2,"LSORT","arg 3");
j = new_mvar(ptr2, vbuf2);
if (j == 1)
ABORT_MPI("LSORT","Variable name too long");
if (j == 2)
ABORT_MPI("LSORT","Too many variables already defined");
}
count = 0;
while (*ptr) {
for (ptr2 = ptr; *ptr2 && *ptr2 != '\r'; ptr2++);
if (*ptr2 == '\r') *(ptr2++) = '\0';
litem[count++] = ptr;
ptr = ptr2;
if (count >= MAX_MFUN_LIST_LEN)
ABORT_MPI("LSORT","Iteration limit exceeded");
}
for (i = 0; i < count; i++) {
for (j = i + 1; j < count; j++) {
if (argc > 1) {
strcpy(vbuf, litem[i]);
strcpy(vbuf2, litem[j]);
ptr = MesgParse(argv[3],buf);
CHECKRETURN(ptr,"LSORT","arg 4");
if (truestr(buf)) {
tmp = litem[i];
litem[i] = litem[j];
litem[j] = tmp;
}
} else {
if (alphanum_compare(litem[i], litem[j]) > 0) {
tmp = litem[i];
litem[i] = litem[j];
litem[j] = tmp;
}
}
}
}
*buf = '\0';
for (i = 0; i < count; i++) {
if (*buf) strcat(buf, "\r");
strcat(buf, litem[i]);
}
if (argc > 1) {
free_top_mvar();
free_top_mvar();
}
return buf;
}
