/** * Runs eval on the code tree, and if it returns an ival, resolves it. * * @param c * @param env * @return */ public Construct seval(ParseTree c, final Environment env) { Construct ret = eval(c, env); while (ret instanceof IVariable) { IVariable cur = (IVariable) ret; ret = env.getEnv(GlobalEnv.class).GetVarList().get(cur.getName(), cur.getTarget()).ival(); } return ret; }
/** * Returns the ivariable from the lowest stack element. If the IVariable is not defined, null is * returned. * * @param name * @return */ public IVariable getIVariableFromStack(String name) { ListIterator<Set<IVariable>> stackIterator = variableStack.listIterator(variableStack.size()); while (stackIterator.hasPrevious()) { Set<IVariable> set = stackIterator.previous(); for (IVariable v : set) { if (v.getVariableName().equals(name)) { return v; } } } return null; }
@Test(timeout = 10000) public void testInc() throws ConfigCompileException { Math.inc a = new Math.inc(); IVariable v = (IVariable) a.exec(Target.UNKNOWN, env, new IVariable("var", C.onstruct(1), Target.UNKNOWN)); IVariable v2 = (IVariable) a.exec(Target.UNKNOWN, env, new IVariable("var2", C.onstruct(2.5), Target.UNKNOWN)); assertCEquals(C.onstruct(2), v.ival()); assertCEquals(C.onstruct(3.5), v2.ival()); StaticTest.SRun("assign(@var, 0) inc(@var, 2) msg(@var)", fakePlayer); verify(fakePlayer).sendMessage("2"); }
public Construct eval(ParseTree c, final Environment env) throws CancelCommandException { final Construct m = c.getData(); CurrentEnv = env; // TODO: Reevaluate if this line is needed. The script doesn't know the label inherently, the // environment does, and setting it this way taints the environment. CurrentEnv.getEnv(GlobalEnv.class).SetLabel(this.label); if (m.getCType() == ConstructType.FUNCTION) { env.getEnv(GlobalEnv.class).SetScript(this); if (m.val().matches("^_[^_].*")) { // Not really a function, so we can't put it in Function. Procedure p = getProc(m.val()); if (p == null) { throw new ConfigRuntimeException( "Unknown procedure \"" + m.val() + "\"", ExceptionType.InvalidProcedureException, m.getTarget()); } Environment newEnv = env; try { newEnv = env.clone(); } catch (Exception e) { } ProfilePoint pp = env.getEnv(GlobalEnv.class).GetProfiler().start(m.val() + " execution", LogLevel.INFO); Construct ret = p.cexecute(c.getChildren(), newEnv, m.getTarget()); pp.stop(); return ret; } final Function f; try { f = (Function) FunctionList.getFunction(m); } catch (ConfigCompileException e) { // Turn it into a config runtime exception. This shouldn't ever happen though. throw new ConfigRuntimeException("Unable to find function " + m.val(), m.getTarget()); } // We have special handling for loop and other control flow functions if (f instanceof assign) { if (c.getChildAt(0).getData() instanceof CFunction) { CFunction test = (CFunction) c.getChildAt(0).getData(); if (test.val().equals("array_get")) { env.getEnv(GlobalEnv.class).SetFlag("array_get_alt_mode", true); Construct arrayAndIndex = eval(c.getChildAt(0), env); env.getEnv(GlobalEnv.class).ClearFlag("array_get_alt_mode"); return ((assign) f) .array_assign(m.getTarget(), env, arrayAndIndex, eval(c.getChildAt(1), env)); } } } if (f.useSpecialExec()) { ProfilePoint p = null; if (f.shouldProfile() && env.getEnv(GlobalEnv.class).GetProfiler() != null && env.getEnv(GlobalEnv.class).GetProfiler().isLoggable(f.profileAt())) { p = env.getEnv(GlobalEnv.class) .GetProfiler() .start(f.profileMessageS(c.getChildren()), f.profileAt()); } Construct ret = f.execs(m.getTarget(), env, this, c.getChildren().toArray(new ParseTree[] {})); if (p != null) { p.stop(); } return ret; } ArrayList<Construct> args = new ArrayList<Construct>(); for (ParseTree c2 : c.getChildren()) { args.add(eval(c2, env)); } if (f.isRestricted()) { boolean perm = Static.hasCHPermission(f.getName(), env); if (!perm) { throw new ConfigRuntimeException( "You do not have permission to use the " + f.getName() + " function.", ExceptionType.InsufficientPermissionException, m.getTarget()); } } Object[] a = args.toArray(); Construct[] ca = new Construct[a.length]; for (int i = 0; i < a.length; i++) { ca[i] = (Construct) a[i]; // CArray, CBoolean, CDouble, CInt, CNull, CString, CVoid, CEntry, CLabel (only to sconcat). if (!(ca[i] instanceof CArray || ca[i] instanceof CBoolean || ca[i] instanceof CDouble || ca[i] instanceof CInt || ca[i] instanceof CNull || ca[i] instanceof CString || ca[i] instanceof CVoid || ca[i] instanceof IVariable || ca[i] instanceof CEntry || ca[i] instanceof CLabel) && (!f.getName().equals("__autoconcat__") && (ca[i] instanceof CLabel))) { throw new ConfigRuntimeException( "Invalid Construct (" + ca[i].getClass() + ") being passed as an argument to a function (" + f.getName() + ")", null, m.getTarget()); } if (env.getEnv(GlobalEnv.class).GetFlag("array_get_alt_mode") == Boolean.TRUE && i == 0) { continue; } while (f.preResolveVariables() && ca[i] instanceof IVariable) { IVariable cur = (IVariable) ca[i]; ca[i] = env.getEnv(GlobalEnv.class).GetVarList().get(cur.getName(), cur.getTarget()).ival(); } } { // It takes a moment to generate the toString of some things, so lets not do it // if we actually aren't going to profile ProfilePoint p = null; if (f.shouldProfile() && env.getEnv(GlobalEnv.class).GetProfiler() != null && env.getEnv(GlobalEnv.class).GetProfiler().isLoggable(f.profileAt())) { p = env.getEnv(GlobalEnv.class).GetProfiler().start(f.profileMessage(ca), f.profileAt()); } Construct ret = f.exec(m.getTarget(), env, ca); if (p != null) { p.stop(); } return ret; } } else if (m.getCType() == ConstructType.VARIABLE) { return new CString(m.val(), m.getTarget()); } else { return m; } }
@Override public Construct execs(Target t, Environment env, Script parent, ParseTree... nodes) { if (nodes.length < 5) { throw new ConfigRuntimeException( "bind accepts 5 or more parameters", ExceptionType.InsufficientArgumentsException, t); } Construct name = parent.seval(nodes[0], env); Construct options = parent.seval(nodes[1], env); Construct prefilter = parent.seval(nodes[2], env); Construct event_obj = parent.eval(nodes[3], env); IVariableList custom_params = new IVariableList(); for (int a = 0; a < nodes.length - 5; a++) { Construct var = parent.eval(nodes[4 + a], env); if (!(var instanceof IVariable)) { throw new ConfigRuntimeException( "The custom parameters must be ivariables", ExceptionType.CastException, t); } IVariable cur = (IVariable) var; custom_params.set( env.getEnv(GlobalEnv.class).GetVarList().get(cur.getName(), cur.getTarget())); } Environment newEnv = env; try { newEnv = env.clone(); } catch (Exception e) { } newEnv.getEnv(GlobalEnv.class).SetVarList(custom_params); ParseTree tree = nodes[nodes.length - 1]; // Check to see if our arguments are correct if (!(options instanceof CNull || options instanceof CArray)) { throw new ConfigRuntimeException( "The options must be an array or null", ExceptionType.CastException, t); } if (!(prefilter instanceof CNull || prefilter instanceof CArray)) { throw new ConfigRuntimeException( "The prefilters must be an array or null", ExceptionType.CastException, t); } if (!(event_obj instanceof IVariable)) { throw new ConfigRuntimeException( "The event object must be an IVariable", ExceptionType.CastException, t); } CString id; if (options instanceof CNull) { options = null; } if (prefilter instanceof CNull) { prefilter = null; } Event event; try { BoundEvent be = new BoundEvent( name.val(), (CArray) options, (CArray) prefilter, ((IVariable) event_obj).getName(), newEnv, tree, t); EventUtils.RegisterEvent(be); id = new CString(be.getId(), t); event = EventList.getEvent(be.getEventName()); } catch (EventException ex) { throw new ConfigRuntimeException(ex.getMessage(), ExceptionType.BindException, t); } // Set up our bind counter, but only if the event is supposed to be added to the counter if (event.addCounter()) { synchronized (bindCounter) { if (bindCounter.get() == 0) { env.getEnv(GlobalEnv.class).GetDaemonManager().activateThread(null); StaticLayer.GetConvertor() .addShutdownHook( new Runnable() { @Override public void run() { synchronized (bindCounter) { bindCounter.set(0); } } }); } bindCounter.incrementAndGet(); } } return id; }