public void checkCanInstance(Environment env) { if (isAbstract) { env.error(trace, "Cannot instantiate abstract class %s", name); } else if (type == Type.INTERFACE) { env.error(trace, "Cannot instantiate interface %s", name); } else if (type == Type.TRAIT) { env.error(trace, "Cannot instantiate trait %s", name); } }
@Override public Void call(Void param) { error(trace, Messages.ERR_REQUIRE_FAILED.fetch("require_once", fileName)); return null; } });
@Signature({@Arg("prop"), @Arg("value")}) public Memory __set(Environment env, Memory... args){ env.error(ErrorType.E_ERROR, "Closure object cannot have properties"); return Memory.NULL; }
protected static boolean expectingReference(Environment env, TraceInfo trace, Memory memory, String funcName) { if (!memory.isReference()) { env.error(trace, (funcName == null ? "" : funcName + "() - ") + "Only variables can be passed by reference"); return false; } return true; }
public boolean canAccessAsNonStatic(Environment env, TraceInfo trace){ if (isStatic){ env.error( trace, ErrorType.E_STRICT, Messages.ERR_ACCESSING_STATIC_PROPERTY_AS_NON_STATIC, getClazz().getName(), name ); return false; } return true; }
public static void checkYieldReference(Memory memory, Environment env, TraceInfo trace) { if (memory.isImmutable()) { env.error(trace, ErrorType.E_NOTICE, Messages.ERR_YIELD_NOT_REFERENCE.fetch()); } } }
public <T extends IObject> T newMock(Environment env) throws Throwable { if (nativeConstructor == null) { env.error(env.trace(), ErrorType.E_CORE_ERROR, "Cannot find a java constructor %s(Environment, ClassEntity)", getName()); } try { IObject object = (IObject) nativeConstructor.newInstance(env, this); object.setAsMock(); return (T) object; } catch (InstantiationException e) { return null; } }
private static IObject fetchObject(Memory object, String property, Environment env, TraceInfo trace) { object = object.toValue(); if (!object.isObject()) { env.error(trace, Messages.ERR_CANNOT_SET_PROPERTY_OF_NON_OBJECT.fetch(property)); return null; } return ((ObjectMemory) object).value; }
@Signature final public Memory __clone(Environment env, Memory... args){ env.error(ErrorType.E_ERROR, "Trying to clone an uncloneable object of class %s", getReflection().getName()); return null; }
public static Memory issetStaticProperty(String className, String lowerClassName, String property, Environment env, TraceInfo trace, PropertyCallCache callCache, int cacheIndex, boolean lateStaticCall) throws Throwable { ClassEntity entity = env.fetchClass(className, lowerClassName, true); if (entity == null) { env.error(trace, Messages.ERR_CLASS_NOT_FOUND.fetch(className)); return Memory.NULL; } return entity.getStaticProperty(env, trace, property, false, true, entity, callCache, cacheIndex, lateStaticCall); }
@Signature final public Memory __clone(Environment env, Memory... args) { env.error(ErrorType.E_ERROR, "Trying to clone an uncloneable object of class " + getReflection().getName()); return Memory.NULL; }
protected void unexpectedEnd(Token token){ analyzer.getEnvironment().error( token.toTraceInfo(analyzer.getContext()), ErrorType.E_PARSE, Messages.ERR_PARSE_UNEXPECTED_END_OF_FILE ); }
public static boolean ob_clean(Environment env, TraceInfo trace) throws Throwable { OutputBuffer buffer = env.peekOutputBuffer(); if (buffer != null && !buffer.isRoot()){ buffer.setTrace(trace); buffer.clean(); return true; } else { env.error(trace, ErrorType.E_NOTICE, "ob_clean(): failed to delete buffer. No buffer to delete"); return false; } }
public void checkAssignableVar(VariableExprToken var) { if (method.clazz.isClosure() || !method.clazz.isSystem()) { if (var.getName().equals("this")) compiler.getEnvironment().error(var.toTraceInfo(compiler.getContext()), "Cannot re-assign $this"); } }
protected Memory yield(Environment env, TraceInfo trace, Memory value) { if (closed == ClosedType.MANUAL) { env.error(trace, "Cannot yield from finally in a force-closed generator"); } checkNewThrow(); Bucket current = setCurrent(value); gen.yield(current); checkNewThrow(); return current.getValue(); }
public static boolean ob_end_flush(Environment env, TraceInfo trace) throws Throwable { OutputBuffer buffer = env.peekOutputBuffer(); if (buffer != null && !buffer.isRoot()){ buffer.setTrace(trace); buffer.flush(); env.popOutputBuffer(); return true; } else { env.error(trace, ErrorType.E_NOTICE, "ob_end_flush(): failed to delete and flush buffer. No buffer to delete or flush"); return false; } }
public static void unsetProperty(Memory object, String property, Environment env, TraceInfo trace, PropertyCallCache callCache, int cacheIndex) throws Throwable { object = object.toValue(); if (!object.isObject()) { env.error(trace, Messages.ERR_CANNOT_GET_PROPERTY_OF_NON_OBJECT.fetch(property)); } IObject iObject = ((ObjectMemory) object).value; iObject.getReflection().unsetProperty(env, trace, iObject, property, callCache, cacheIndex); }
private void invalidUseAsArray(TraceInfo trace) { Environment env = value.getEnvironment(); if (env != null) { env.error(trace == null ? getReflection().getTrace() : trace, ErrorType.E_ERROR, Messages.ERR_CANNOT_USE_OBJECT_AS_ARRAY, getReflection().getName() ); } }
/** * @throws ParseException * @param token */ protected void unexpectedToken(Token token){ analyzer.getEnvironment().error( token.toTraceInfo(analyzer.getContext()), ErrorType.E_PARSE, Messages.ERR_PARSE_UNEXPECTED_X.fetch(token.getWord()) ); }
public static Memory makeValue(ParameterEntity param, Memory arg, Environment env, TraceInfo trace) { if (param.isReference()) { if (!arg.isReference() && !arg.isObject()) { env.error(trace, ErrorType.E_ERROR, "Only variables can be passed by reference"); arg = new ReferenceMemory(arg); } } else { arg = param.isMutable() ? arg.toImmutable() : arg.toValue(); } return arg; }