/**
* Creates an assignment using this value as the right hand side.
*/
public Expr createAssignFrom(QuercusParser parser,
AbstractVarExpr leftHandSide)
{
ExprFactory factory = parser.getExprFactory();
return(factory.createAssign(leftHandSide, this));
}
/**
* Creates an assignment using this value as the right hand side.
*/
public override Expr createAssignFrom(QuercusParser parser,
AbstractVarExpr leftHandSide)
{
ExprFactory factory = parser.getExprFactory();
return(factory.createAssignRef(leftHandSide, _expr));
}
/**
* Creates a class field $class::foo
*/
public override Expr createClassConst(QuercusParser parser, Expr name)
{
ExprFactory factory = parser.getExprFactory();
string className = _value.ToString();
if ("self".equals(className))
{
className = parser.getSelfClassName();
return(factory.createClassConst(className, name));
}
else if ("parent".equals(className))
{
className = parser.getParentClassName();
return(factory.createClassConst(className, name));
}
else if ("static".equals(className))
{
return(factory.createClassVirtualConst(name));
}
else
{
return(factory.createClassConst(className, name));
}
}
/**
* Creates the assignment.
*/
public override Expr createAssignRef(QuercusParser parser,
Expr value)
{
// _var.setAssigned();
return(super.createAssignRef(parser, value));
}
/**
* Creates a class field Foo::${bar}
*/
public override Expr createClassField(QuercusParser parser, Expr name)
{
ExprFactory factory = parser.getExprFactory();
string className = _var;
string specialClassName = getSpecialClassName();
if ("self".equals(specialClassName))
{
className = parser.getSelfClassName();
return(factory.createClassField(className, name));
}
else if ("parent".equals(specialClassName))
{
className = parser.getParentClassName();
return(factory.createClassField(className, name));
}
else if ("static".equals(specialClassName))
{
return(factory.createClassVirtualField(name));
}
else
{
return(factory.createClassField(className, name));
}
}
/**
* Creates the assignment.
*/
public Expr createAssign(QuercusParser parser, Expr value)
{
// php/03j2
return(new UnarySuppressErrorExpr(parser.getLocation(),
getExpr().createAssign(parser, value)));
}
//
// function call creation
//
/**
* Creates a function call expression
*/
public override Expr createCall(QuercusParser parser,
Location location,
ArrayList <Expr> args)
{
ExprFactory factory = parser.getExprFactory();
return(factory.createClassMethodCall(location, _className, _varName, args));
}
//
// function call creation
//
/**
* Creates a function call expression
*/
public override Expr createCall(QuercusParser parser,
Location location,
ArrayList <Expr> args)
{
ExprFactory factory = parser.getExprFactory();
return(factory.createThisMethod(location, _qThis, _nameExpr, args));
}
//
// function call creation
//
/**
* Creates a function call expression
*/
public Expr createCall(QuercusParser parser,
Location location,
ArrayList <Expr> args)
{
ExprFactory factory = parser.getExprFactory();
return(factory.createVarFunction(location, this, args));
}
/**
* Executes the script.
*/
public Value execute(Path path)
{
init();
ReadStream reader = path.openRead();
QuercusProgram program = QuercusParser.parse(_quercus, null, reader);
OutputStream os = _out;
WriteStream out;
if (os != null)
{
OutputStreamStream s = new OutputStreamStream(os);
WriteStream ws = new WriteStream(s);
ws.setNewlineString("\n");
try {
ws.setEncoding("iso-8859-1");
} catch (Exception e) {
}
@out = ws;
}
else
{
@out = new WriteStream(StdoutStream.create());
}
QuercusPage page = new InterpretedPage(program);
Env env = new Env(_quercus, page, @out, null, null);
Value value = NullValue.NULL;
try {
env.start();
value = program.execute(env);
}
catch (QuercusExitException e) {
}
@out.flushBuffer();
@out.free();
if (os != null)
{
os.flush();
}
return(value);
}
//
// function call creation
//
/**
* Creates a function call expression
*/
public override Expr createCall(QuercusParser parser,
Location location,
ArrayList <Expr> args)
{
ExprFactory factory = parser.getExprFactory();
Expr var = parser.createVar(_varName);
return(factory.createClassVirtualMethodCall(location, var, args));
}
//
// expression creation functions
//
public Expr createAssign(QuercusParser parser, Expr value)
{
string msg = (L.l("{0} @is an invalid left-hand side of an assignment.",
this));
if (parser != null)
{
throw parser.error(msg);
}
else
{
throw new IOException(msg);
}
}
/**
* Mark as an assignment for a list()
*/
public void assign(QuercusParser parser)
{
string msg = L.l("{0} @is an invalid left-hand side of an assignment.",
this);
if (parser != null)
{
throw parser.error(msg);
}
else
{
throw new IOException(msg);
}
}
//
// function call creation
//
/**
* Creates a function call expression
*/
public override Expr createCall(QuercusParser parser,
Location location,
ArrayList <Expr> args)
{
/*
* if (_className.equals(_name))
* return factory.createClassConstructor(location, _className, _name, args);
* else
* return factory.createClassMethodCall(location, _className, _name, args);
*/
ExprFactory factory = parser.getExprFactory();
return(factory.createClassMethodCall(location, _className, _name, args));
}
//
// expression creation
//
/**
* Creates a class field Foo::bar
*/
public override Expr createClassConst(QuercusParser parser, StringValue name)
{
ExprFactory factory = parser.getExprFactory();
string className = _var;
string specialClassName = getSpecialClassName();
if ("self".equals(specialClassName))
{
className = parser.getSelfClassName();
return(factory.createClassConst(className, name));
}
else if ("parent".equals(specialClassName))
{
className = parser.getParentClassName();
if (className != null)
{
return(factory.createClassConst(className, name));
}
else
{
// trait's parent @is not known at parse time
return(factory.createTraitParentClassConst(parser.getClassName(), name));
}
}
else if ("static".equals(specialClassName))
{
return(factory.createClassVirtualConst(name));
}
else
{
return(factory.createClassConst(className, name));
}
}
/**
* Returns the reference of the value.
* @param location
*/
public override Expr createRef(QuercusParser parser)
{
return(parser.getFactory().createRef(this));
}
public QuercusPage parseImpl(Path path, string fileName, int line)
{
try {
SoftReference <QuercusProgram> programRef = _programCache.get(path);
QuercusProgram program = programRef != null?programRef.get() : null;
bool isModified = false;
if (program != null)
{
isModified = program.isModified();
if (program.isCompilable())
{
}
else if (isModified)
{
program.setCompilable(true);
}
else
{
if (log.isLoggable(Level.FINE))
{
log.fine(L.l("Quercus[{0}] loading interpreted page", path));
}
return(new InterpretedPage(program));
}
}
if (program == null || isModified)
{
clearProgram(path, program);
program = preloadProgram(path, fileName);
if (program == null)
{
if (log.isLoggable(Level.FINE))
{
log.fine(L.l("Quercus[{0}] parsing page", path));
}
program = QuercusParser.parse(_quercus,
path,
_quercus.getScriptEncoding(),
fileName,
line);
}
_programCache.put(path, new SoftReference <QuercusProgram>(program));
}
if (program.getCompiledPage() != null)
{
return(program.getCompiledPage());
}
return(compilePage(program, path));
} catch (IOException e) {
throw e;
} catch (RuntimeException e) {
throw e;
} catch (Throwable e) {
throw new IOExceptionWrapper(e);
}
}
/**
* Creates a reference.
* @param location
*/
public Expr createRef(QuercusParser parser)
{
return(this);
}
/**
* Creates the assignment.
*/
public override Expr createAssignRef(QuercusParser parser,
Expr value)
{
return(parser.getExprFactory().createAssignRef(this, value));
}
/**
* Creates the assignment.
*/
public override Expr createAssign(QuercusParser parser, Expr value)
{
return(value.createAssignFrom(parser, this));
}
/**
* Marks the value as assigned
*/
public void assign(QuercusParser parser)
{
// XXX: used by list, e.g. quercus/03l8. need further tests
}
//
// class field refs $class::$bar
//
/**
* Creates a class field $class::foo
*/
public Expr createClassConst(QuercusParser parser, StringValue name)
{
ExprFactory factory = parser.getExprFactory();
return(factory.createClassConst(this, name));
}
/**
* Creates the assignment.
*/
public override void assign(QuercusParser parser)
{
// _var.setAssigned();
}
public FunGetClassExpr(QuercusParser parser)
{
super(parser.getLocation());
_className = parser.getClassName();
}
/**
* Creates a class field $class::${foo}
*/
public Expr createClassField(QuercusParser parser, Expr name)
{
ExprFactory factory = parser.getExprFactory();
return(factory.createClassField(this, name));
}
