Exemple #1
0
int
ok_player_name(const char *name)
{
	const char *scan;

	if (!ok_name(name) || strlen(name) > PLAYER_NAME_LIMIT)
		return 0;
	

	for (scan = name; *scan; scan++) {
		if (!(isprint(*scan)
			 && !isspace(*scan))
			 && *scan != '('
			 && *scan != ')'
			 && *scan != '\''
			 && *scan != ',') {	
		    /* was isgraph(*scan) */
			return 0;
		}
	}

	/* Check the name isn't reserved */
	if (*tp_reserved_player_names && equalstr((char*)tp_reserved_player_names, (char*)name))
		return 0;

	/* lookup name to avoid conflicts */
	return (lookup_player(name) == NOTHING);
}
Exemple #2
0
/* checks if object has property, returns 1 if it has the property */
int
has_property_strict(int descr, dbref player, dbref what, const char *type,
                    const char *pclass, int value)
{
    PropPtr p;
    const char *str;
    char *ptr;
    char buf[BUFFER_LEN];

    p = get_property(what, type);

    if (p) {
#ifdef DISKBASE
        propfetch(what, p);
#endif
        if (PropType(p) == PROP_STRTYP) {
            str = DoNull(PropDataUNCStr(p));
            ptr = do_parse_mesg(descr, player, what, str, "(Lock)",
                                buf, (MPI_ISPRIVATE | MPI_ISLOCK));
            return (equalstr((char *) pclass, ptr));
        } else if (PropType(p) == PROP_INTTYP) {
            return (value == PropDataVal(p));
        } else {
            return 0;
        }
    }
    return 0;
}
Exemple #3
0
const char *
mfn_smatch(MFUNARGS)
{
    if (equalstr(argv[1], argv[0])) {
	return "1";
    } else {
	return "0";
    }
}
Exemple #4
0
int
blessprops_wildcard(dbref player, dbref thing, const char *dir, const char *wild, int blessp)
{
	char propname[BUFFER_LEN];
	char wld[BUFFER_LEN];
	char buf[BUFFER_LEN];
	char buf2[BUFFER_LEN];
	char *ptr, *wldcrd = wld;
	PropPtr propadr, pptr;
	int i, cnt = 0;
	int recurse = 0;

#ifdef GOD_PRIV
	if(tp_strict_god_priv && !God(player) && God(OWNER(thing))) {
		notify(player,"Only God may touch what is God's.");
		return 0;
	}
#endif

	strcpyn(wld, sizeof(wld), wild);
	i = strlen(wld);
	if (i && wld[i - 1] == PROPDIR_DELIMITER)
		strcatn(wld, sizeof(wld), "*");
	for (wldcrd = wld; *wldcrd == PROPDIR_DELIMITER; wldcrd++) ;
	if (!strcmp(wldcrd, "**"))
		recurse = 1;

	for (ptr = wldcrd; *ptr && *ptr != PROPDIR_DELIMITER; ptr++) ;
	if (*ptr)
		*ptr++ = '\0';

	propadr = first_prop(thing, (char *) dir, &pptr, propname, sizeof(propname));
	while (propadr) {
		if (equalstr(wldcrd, propname)) {
			snprintf(buf, sizeof(buf), "%s%c%s", dir, PROPDIR_DELIMITER, propname);
			if (!Prop_System(buf) && ((!Prop_Hidden(buf) && !(PropFlags(propadr) & PROP_SYSPERMS))
				|| Wizard(OWNER(player)))) {
				if (!*ptr || recurse) {
					cnt++;
					if (blessp) {
						set_property_flags(thing, buf, PROP_BLESSED);
						snprintf(buf2, sizeof(buf2), "Blessed %s", buf);
					} else {
						clear_property_flags(thing, buf, PROP_BLESSED);
						snprintf(buf2, sizeof(buf2), "Unblessed %s", buf);
					}
					notify(player, buf2);
				}
				if (recurse)
					ptr = "**";
				cnt += blessprops_wildcard(player, thing, buf, ptr, blessp);
			}
		}
		propadr = next_prop(pptr, propadr, propname, sizeof(propname));
	}
	return cnt;
}
Exemple #5
0
void
list_program_functions(dbref player, dbref program, char *arg)
{
    struct inst *ptr;
    int count;

    ptr = DBFETCH(program)->sp.program.code;
    count = DBFETCH(program)->sp.program.siz;
    anotify_nolisten(player, CINFO "*function words*", 1);
    while (count-- > 0) {
	if (ptr->type == PROG_FUNCTION) {
	    if (ptr->data.string) {
		if (!*arg || equalstr(arg, ptr->data.string->data)) {
		    notify_nolisten(player, ptr->data.string->data, 1);
		}
	    }
	}
	ptr++;
    }
    anotify_nolisten(player, CINFO "Done.", 1);
}
Exemple #6
0
int
ok_name(const char *name)
{
	return (name
			&& *name
			&& *name != LOOKUP_TOKEN
			&& *name != REGISTERED_TOKEN
			&& *name != NUMBER_TOKEN
			&& !index(name, ARG_DELIMITER)
			&& !index(name, AND_TOKEN)
			&& !index(name, OR_TOKEN)
			&& !index(name, '\r')
			&& !index(name, ESCAPE_CHAR)
			&& !word_start(name, NOT_TOKEN)
			&& string_compare(name, "me")
			&& string_compare(name, "home")
			&& string_compare(name, "here")
			&& (
				!*tp_reserved_names ||
				!equalstr((char*)tp_reserved_names, (char*)name)
			));
}
Exemple #7
0
/**
 * List the functions in a program
 *
 * Optionally provide a filter string that will match functions using
 * equalstr
 *
 * @see equalstr
 *
 * You cannot pass NULL into arg, you can pass empty string if you wish to
 * show all functions.
 *
 * @private
 * @param player the person to show the list of functions to
 * @param program the program to list functions from
 * @param arg a filter string or ""
 */
static void
list_program_functions(dbref player, dbref program, char *arg)
{
    struct inst *ptr;
    int count;

    ptr = PROGRAM_CODE(program);
    count = PROGRAM_SIZ(program);
    notify_nolisten(player, "*function words*", 1);

    while (count-- > 0) {
        if (ptr->type == PROG_FUNCTION) {
            if (ptr->data.mufproc) {
                if (!*arg || equalstr(arg, ptr->data.mufproc->procname)) {
                    notify_nolisten(player, ptr->data.mufproc->procname, 1);
                }
            }
        }

        ptr++;
    }

    notify_nolisten(player, "*done*", 1);
}
Exemple #8
0
const char *
mfn_listprops(MFUNARGS)
{
	dbref obj = what;
	char *ptr, *pname;
	char *endbuf, *pattern;
	char tmpbuf[BUFFER_LEN];
	char patbuf[BUFFER_LEN];
	char pnamebuf[BUFFER_LEN];
	int flag;

	strcpyn(pnamebuf, sizeof(pnamebuf), argv[0]);
	pname = pnamebuf;
	if (argc > 1) {
		obj = mesg_dbref(descr, player, what, perms, argv[1], mesgtyp);
	}
	if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
		ABORT_MPI("LISTPROPS", "Match failed.");
	if (obj == PERMDENIED)
		ABORT_MPI("LISTPROPS", "Permission denied.");

	if (argc > 2) {
		pattern = argv[2];
	} else {
		pattern = NULL;
	}

	endbuf = pname + strlen(pname);
	if (endbuf != pname) {
		endbuf--;
	}
	if (*endbuf != PROPDIR_DELIMITER && (endbuf - pname) < (BUFFER_LEN - 2)) {
		if (*endbuf != '\0')
			endbuf++;
		*endbuf++ = PROPDIR_DELIMITER;
		*endbuf++ = '\0';
	}

	*buf = '\0';
	endbuf = buf;
	do {
		ptr = next_prop_name(obj, tmpbuf, (int) sizeof(tmpbuf), pname);
		if (ptr && *ptr) {
			flag = 1;
			if (Prop_System(ptr)) {
				flag = 0;
			} else if (!(mesgtyp & MPI_ISBLESSED)) {
				if (Prop_Hidden(ptr)) {
					flag = 0;
				}
				if (Prop_Private(ptr) && OWNER(what) != OWNER(obj)) {
					flag = 0;
				}
				if (obj != player && OWNER(obj) != OWNER(what)) {
					flag = 0;
				}
			}
			if ((flag != 0) && (pattern != NULL)) {
				char *nptr;

				nptr = rindex(ptr, PROPDIR_DELIMITER);
				if (nptr && *nptr) {
					strcpyn(patbuf, sizeof(patbuf), ++nptr);
					if (!equalstr(pattern, patbuf)) {
						flag = 0;
					}
				}
			}
			if (flag) {
				int entrylen = strlen(ptr);
				if ((endbuf - buf) + entrylen + 2 < BUFFER_LEN) {
					if (*buf != '\0') {
						*endbuf++ = '\r';
					}
					strcpyn(endbuf, BUFFER_LEN - (endbuf - buf), ptr);
					endbuf += entrylen;
				}
			}
		}
		pname = ptr;
	} while (ptr && *ptr);

	return buf;
}
Exemple #9
0
void
tune_display_parms(dbref player, char *name)
{
    int total = 0;
    const char *lastname = NULL;
    char buf[BUFFER_LEN + 50], tbuf[BUFFER_LEN];
    struct tune_str_entry *tstr = tune_str_list;
    struct tune_time_entry *ttim = tune_time_list;
    struct tune_val_entry *tval = tune_val_list;
    struct tune_ref_entry *tref = tune_ref_list;
    struct tune_bool_entry *tbool = tune_bool_list;

    while (tstr->name) {
        strcpy(buf, tstr->name);
        if ((MLevel(OWNER(player)) >= tstr->readmlev) &&
            (!*name || equalstr(name, buf))) {
            sprintf(buf, SYSCYAN "(str)  " SYSRED "%c" SYSGREEN "%-24s"
                    SYSRED " = " SYSCYAN "%.4096s",
                    (WLevel(OWNER(player)) >= tstr->writemlev) ? ' ' : '-',
                    tstr->name, tct(*tstr->str, tbuf));
            lastname = tstr->name;
            anotify_nolisten2(player, buf);
            total++;
        }
        tstr++;
    }

    while (ttim->name) {
        strcpy(buf, ttim->name);
        if ((MLevel(OWNER(player)) >= ttim->readmlev) &&
            (!*name || equalstr(name, buf))) {
            sprintf(buf, SYSPURPLE "(time) " SYSRED "%c" SYSGREEN "%-24s"
                    SYSRED " = " SYSPURPLE "%s",
                    (WLevel(OWNER(player)) >= ttim->writemlev) ? ' ' : '-',
                    ttim->name, timestr_full(*ttim->tim));
            lastname = ttim->name;
            anotify_nolisten2(player, buf);
            total++;
        }
        ttim++;
    }

    while (tval->name) {
        strcpy(buf, tval->name);
        if ((MLevel(OWNER(player)) >= tval->readmlev) &&
            (!*name || equalstr(name, buf))) {
            sprintf(buf, SYSGREEN "(int)  " SYSRED "%c" SYSGREEN "%-24s"
                    SYSRED " = " SYSYELLOW "%d",
                    (WLevel(OWNER(player)) >= tval->writemlev) ? ' ' : '-',
                    tval->name, *tval->val);
            lastname = tval->name;
            anotify_nolisten2(player, buf);
            total++;
        }
        tval++;
    }
    while (tref->name) {
        strcpy(buf, tref->name);
        if ((MLevel(OWNER(player)) >= tref->readmlev) &&
            (!*name || equalstr(name, buf))) {
            sprintf(buf, SYSYELLOW "(ref)  " SYSRED "%c" SYSGREEN "%-24s"
                    SYSRED " = %s",
                    (WLevel(OWNER(player)) >= tref->writemlev) ? ' ' : '-',
                    tref->name, ansi_unparse_object(player, *tref->ref));
            lastname = tref->name;
            anotify_nolisten2(player, buf);
            total++;
        }
        tref++;
    }

    while (tbool->name) {
        strcpy(buf, tbool->name);
        if ((MLevel(OWNER(player)) >= tbool->readmlev) &&
            (!*name || equalstr(name, buf))) {
            sprintf(buf, SYSWHITE "(bool) " SYSRED "%c" SYSGREEN "%-24s" SYSRED
                    " = " SYSBLUE "%s",
                    (WLevel(OWNER(player)) >= tbool->writemlev) ? ' ' : '-',
                    tbool->name, ((*tbool->boolv) ? "yes" : "no"));
            lastname = tbool->name;
            anotify_nolisten2(player, buf);
            total++;
        }
        tbool++;
    }
    if ((total == 1) && lastname && *lastname) {
        do_sysparm(player, lastname);
    } else {
        anotify_fmt(player, CINFO "%d sysparm%s listed.", total,
                    (total == 1) ? "" : "s");
        anotify(player,
                SYSYELLOW
                "@tune str, time, int, ref, or bool to list by data types.");
    }
}
Exemple #10
0
stk_array *
tune_parms_array(const char *pattern, int mlev)
{
    struct tune_str_entry *tstr = tune_str_list;
    struct tune_time_entry *ttim = tune_time_list;
    struct tune_val_entry *tval = tune_val_list;
    struct tune_ref_entry *tref = tune_ref_list;
    struct tune_bool_entry *tbool = tune_bool_list;
    stk_array *nu = new_array_packed(0);
    struct inst temp1;
    char pat[BUFFER_LEN];
    char buf[BUFFER_LEN];
    int i = 0;

    strcpy(pat, pattern);
    while (tbool->name) {
        if (tbool->readmlev <= mlev) {
            strcpy(buf, tbool->name);
            if (!*pattern || equalstr(pat, buf)) {
                stk_array *item = new_array_dictionary();

                array_set_strkey_strval(&item, "type", "boolean");
                array_set_strkey_strval(&item, "group", tbool->group);
                array_set_strkey_strval(&item, "name", tbool->name);
                array_set_strkey_intval(&item, "value", *tbool->boolv ? 1 : 0);
                array_set_strkey_intval(&item, "readmlev", tbool->readmlev);
                array_set_strkey_intval(&item, "writemlev", tbool->writemlev);
                temp1.type = PROG_ARRAY;
                temp1.data.array = item;
                array_set_intkey(&nu, i++, &temp1);
                CLEAR(&temp1);
            }
        }
        tbool++;
    }

    while (ttim->name) {
        if (ttim->readmlev <= mlev) {
            strcpy(buf, ttim->name);
            if (!*pattern || equalstr(pat, buf)) {
                stk_array *item = new_array_dictionary();

                array_set_strkey_strval(&item, "type", "timespan");
                array_set_strkey_strval(&item, "group", ttim->group);
                array_set_strkey_strval(&item, "name", ttim->name);
                array_set_strkey_intval(&item, "value", *ttim->tim);
                array_set_strkey_intval(&item, "readmlev", ttim->readmlev);
                array_set_strkey_intval(&item, "writemlev", ttim->writemlev);
                temp1.type = PROG_ARRAY;
                temp1.data.array = item;
                array_set_intkey(&nu, i++, &temp1);
                CLEAR(&temp1);
            }
        }
        ttim++;
    }

    while (tval->name) {
        if (tval->readmlev <= mlev) {
            strcpy(buf, tval->name);
            if (!*pattern || equalstr(pat, buf)) {
                stk_array *item = new_array_dictionary();

                array_set_strkey_strval(&item, "type", "integer");
                array_set_strkey_strval(&item, "group", tval->group);
                array_set_strkey_strval(&item, "name", tval->name);
                array_set_strkey_intval(&item, "value", *tval->val);
                array_set_strkey_intval(&item, "readmlev", tval->readmlev);
                array_set_strkey_intval(&item, "writemlev", tval->writemlev);
                temp1.type = PROG_ARRAY;
                temp1.data.array = item;
                array_set_intkey(&nu, i++, &temp1);
                CLEAR(&temp1);
            }
        }
        tval++;
    }

    while (tref->name) {
        if (tref->readmlev <= mlev) {
            strcpy(buf, tref->name);
            if (!*pattern || equalstr(pat, buf)) {
                stk_array *item = new_array_dictionary();

                array_set_strkey_strval(&item, "type", "dbref");
                array_set_strkey_strval(&item, "group", tref->group);
                array_set_strkey_strval(&item, "name", tref->name);
                array_set_strkey_refval(&item, "value", *tref->ref);
                array_set_strkey_intval(&item, "readmlev", tref->readmlev);
                array_set_strkey_intval(&item, "writemlev", tref->writemlev);
                switch (tref->typ) {
                case NOTYPE:
                    array_set_strkey_strval(&item, "objtype", "any");
                    break;
                case TYPE_PLAYER:
                    array_set_strkey_strval(&item, "objtype", "player");
                    break;
                case TYPE_THING:
                    array_set_strkey_strval(&item, "objtype", "thing");
                    break;
                case TYPE_ROOM:
                    array_set_strkey_strval(&item, "objtype", "room");
                    break;
                case TYPE_EXIT:
                    array_set_strkey_strval(&item, "objtype", "exit");
                    break;
                case TYPE_PROGRAM:
                    array_set_strkey_strval(&item, "objtype", "program");
                    break;
                case TYPE_GARBAGE:
                    array_set_strkey_strval(&item, "objtype", "garbage");
                    break;
                default:
                    array_set_strkey_strval(&item, "objtype", "unknown");
                    break;
                }
                temp1.type = PROG_ARRAY;
                temp1.data.array = item;
                array_set_intkey(&nu, i++, &temp1);
                CLEAR(&temp1);
            }
        }
        tref++;
    }

    while (tstr->name) {
        if (tstr->readmlev <= mlev) {
            strcpy(buf, tstr->name);
            if (!*pattern || equalstr(pat, buf)) {
                stk_array *item = new_array_dictionary();

                array_set_strkey_strval(&item, "type", "string");
                array_set_strkey_strval(&item, "group", tstr->group);
                array_set_strkey_strval(&item, "name", tstr->name);
                array_set_strkey_strval(&item, "value", *tstr->str);
                array_set_strkey_intval(&item, "readmlev", tstr->readmlev);
                array_set_strkey_intval(&item, "writemlev", tstr->writemlev);
                temp1.type = PROG_ARRAY;
                temp1.data.array = item;
                array_set_intkey(&nu, i++, &temp1);
                CLEAR(&temp1);
            }
        }
        tstr++;
    }
    return nu;
}
Exemple #11
0
void
listenqueue(int descr, dbref player, dbref where, dbref trigger, dbref what, dbref xclude,
			const char *propname, const char *toparg, int mlev, int mt, int mpi_p)
{
	const char *tmpchar;
	const char *pname, *sep, *ptr;
	dbref the_prog = NOTHING;
	char buf[BUFFER_LEN];
	char exbuf[BUFFER_LEN];
	char *ptr2;

	if (!(FLAGS(what) & LISTENER) && !(FLAGS(OWNER(what)) & ZOMBIE))
		return;

	the_prog = NOTHING;
	tmpchar = NULL;

	/* queue up program referred to by the given property */
	if (((the_prog = get_property_dbref(what, propname)) != NOTHING) ||
		(tmpchar = get_property_class(what, propname))) {

		if (tmpchar) {
			sep = tmpchar;
			while (*sep) {
				if (*sep == '\\') {
					sep++;
				} else if (*sep == '=') {
					break;
				}
				if (*sep)
					sep++;
			}
			if (*sep == '=') {
				for (ptr = tmpchar, ptr2 = buf; ptr < sep; *ptr2++ = *ptr++) ;
				*ptr2 = '\0';
				strcpyn(exbuf, sizeof(exbuf), toparg);
				if (!equalstr(buf, exbuf)) {
					tmpchar = NULL;
				} else {
					tmpchar = ++sep;
				}
			}
		}

		if ((tmpchar && *tmpchar) || the_prog != NOTHING) {
			if (tmpchar) {
				if (*tmpchar == '&') {
					the_prog = AMBIGUOUS;
				} else if (*tmpchar == NUMBER_TOKEN && number(tmpchar + 1)) {
					the_prog = (dbref) atoi(++tmpchar);
				} else if (*tmpchar == REGISTERED_TOKEN) {
					the_prog = find_registered_obj(what, tmpchar);
				} else if (number(tmpchar)) {
					the_prog = (dbref) atoi(tmpchar);
				} else {
					the_prog = NOTHING;
				}
			} else {
				if (the_prog == AMBIGUOUS)
					the_prog = NOTHING;
			}
			if (the_prog != AMBIGUOUS) {
				if (the_prog < 0 || the_prog >= db_top) {
					the_prog = NOTHING;
				} else if (Typeof(the_prog) != TYPE_PROGRAM) {
					the_prog = NOTHING;
				} else if (OWNER(the_prog) != OWNER(player) && !(FLAGS(the_prog) & LINK_OK)) {
					the_prog = NOTHING;
				} else if (MLevel(the_prog) < mlev) {
					the_prog = NOTHING;
				} else if (MLevel(OWNER(the_prog)) < mlev) {
					the_prog = NOTHING;
				} else if (the_prog == xclude) {
					the_prog = NOTHING;
				}
			}
			if (the_prog == AMBIGUOUS) {
				if (mpi_p) {
					add_mpi_event(1, descr, player, where, trigger, tmpchar + 1,
								  (mt ? "Listen" : "Olisten"), toparg, 1, (mt == 0),
								  Prop_Blessed(what, propname));
				}
			} else if (the_prog != NOTHING) {
				add_muf_queue_event(descr, player, where, trigger, the_prog, toparg,
									"(_Listen)", 1);
			}
		}
	}
	strcpyn(buf, sizeof(buf), propname);
	if (is_propdir(what, buf)) {
		strcatn(buf, sizeof(buf), "/");
		while ((pname = next_prop_name(what, exbuf, sizeof(exbuf), buf))) {
			*buf = '\0';
			strcatn(buf, sizeof(buf), pname);
			listenqueue(descr, player, where, trigger, what, xclude, buf,
						toparg, mlev, mt, mpi_p);
		}
	}
}
Exemple #12
0
void
prim_array_filter_prop(PRIM_PROTOTYPE)
{
	char pattern[BUFFER_LEN];
	char tname[BUFFER_LEN];
	struct inst *in;
	struct inst temp1;
	stk_array *arr;
	stk_array *nu;
	char* prop;
	int len;

	CHECKOP(3);
	oper3 = POP();				/* str     pattern */
	oper2 = POP();				/* str     propname */
	oper1 = POP();				/* refarr  Array */
	if (oper1->type != PROG_ARRAY)
		abort_interp("Argument not an array. (1)");
	if (!array_is_homogenous(oper1->data.array, PROG_OBJECT))
		abort_interp("Argument not an array of dbrefs. (1)");
	if (oper2->type != PROG_STRING || !oper2->data.string)
		abort_interp("Argument not a non-null string. (2)");
	if (oper3->type != PROG_STRING)
		abort_interp("Argument not a string pattern. (3)");

	len = oper2->data.string ? oper2->data.string->length : 0;
	strcpyn(tname, sizeof(tname), DoNullInd(oper2->data.string));
	while (len-- > 0 && tname[len] == PROPDIR_DELIMITER) {
		tname[len] = '\0';
	}

	nu = new_array_packed(0);
	arr = oper1->data.array;
	prop = tname;
	strcpyn(pattern, sizeof(pattern), DoNullInd(oper3->data.string));
	if (array_first(arr, &temp1)) {
		do {
			in = array_getitem(arr, &temp1);
			if (valid_object(in)) {
				ref = in->data.objref;
				CHECKREMOTE(ref);
				if (prop_read_perms(ProgUID, ref, prop, mlev)) {
					PropPtr pptr = get_property(ref, prop);

					if (pptr)
					{
						switch(PropType(pptr))
						{
							case PROP_STRTYP:
								strncpy(buf, PropDataStr(pptr), BUFFER_LEN);
							break;

							case PROP_LOKTYP:
								if (PropFlags(pptr) & PROP_ISUNLOADED) {
									strncpy(buf, "*UNLOCKED*", BUFFER_LEN);
								} else {
									strncpy(buf, unparse_boolexp(ProgUID, PropDataLok(pptr), 0), BUFFER_LEN);
								}
							break;

							case PROP_REFTYP:
								snprintf(buf, BUFFER_LEN, "#%i", PropDataRef(pptr));
							break;

							case PROP_INTTYP:
								snprintf(buf, BUFFER_LEN, "%i", PropDataVal(pptr));
							break;

							case PROP_FLTTYP:
								snprintf(buf, BUFFER_LEN, "%g", PropDataFVal(pptr));
							break;

							default:
								strncpy(buf, "", BUFFER_LEN);
							break;
						}
					}
					else
						strncpy(buf, "", BUFFER_LEN);

					if (equalstr(pattern, buf)) {
						array_appenditem(&nu, in);
					}
				}
			}
		} while (array_next(arr, &temp1));
	}

	CLEAR(oper3);
	CLEAR(oper2);
	CLEAR(oper1);

	PushArrayRaw(nu);
}