public int read(char [] buffer, int offset, int length)
{
// XXX: should be reimplemented
Value output;
if (_env.isUnicodeSemantics())
{
output = _wrapper.callMethod(_env, STREAM_READ_U,
LongValue.create(length));
}
else
{
output = _wrapper.callMethod(_env, STREAM_READ,
LongValue.create(length));
}
if (output.length() == 0)
{
return(-1);
}
byte [] outputBytes = output.ToString().getBytes();
if (outputBytes.length < length)
{
length = outputBytes.length;
}
System.arraycopy(outputBytes, 0, buffer, offset, length);
return(length);
}
/**
* Add an unsupported ini default for an ini that has a long value.
*/
public IniDefinition addUnsupported(String name, long deflt, int scope)
{
return(addUnsupported(name,
IniDefinition.Type.LONG,
LongValue.create(deflt),
scope));
}
public void writeTo(Env env, OutputStream os)
{
long length = _length;
long totalWritten = 0;
LongValue lengthV = LongValue.create(length);
while (totalWritten < length)
{
StringValue str
= _callback.call(env, _curl, _fileV, lengthV).ToStringValue(env);
int count = str.length();
if (count == 0)
{
break;
}
str.writeTo(os);
totalWritten += count;
}
}
public Value unmarshal(Env env, Object value)
{
if (value == null)
return LongValue.ZERO;
else
return LongValue.create(((Number) value).longValue());
}
/**
* Prepares this statement with the given query.
*
* @param query SQL query
* @return true on success or false on failure
*/
public override bool prepare(Env env, string query)
{
string queryStr = query.ToString();
_preparedMapping.clear();
// Map any unsorted or duplicated params.
// Ex: INSERT INTO test VALUES($2, $1) or
// INSERT INTO test VALUES($1, $1)
Pattern pattern = Pattern.compile("\\$([0-9]+)");
Matcher matcher = pattern.matcher(queryStr);
while (matcher.find())
{
int phpParam;
try {
phpParam = Integer.parseInt(matcher.group(1));
} catch (Exception ex) {
_preparedMapping.clear();
return(false);
}
_preparedMapping.add(LongValue.create(phpParam));
}
// Make the PHP query a JDBC like query
// replacing ($1 -> ?) with question marks.
// XXX: replace this with Matcher.appendReplacement
// above when StringBuilder @is supported.
queryStr = queryStr.replaceAll("\\$[0-9]+", "?");
// Prepare the JDBC query
return(super.prepare(env, queryStr));
}
public int execute(Env env, Value stillRunning)
{
if (_runningCount == 0)
{
stillRunning.set(LongValue.ZERO);
return(CurlModule.CURLM_OK);
}
else if (_runningCount < 0)
{
_runningCount = _curlList.size();
for (CurlResource curl : _curlList)
{
curl.execute(env, false);
_msgQueue.add(curl);
}
}
_runningCount--;
stillRunning.set(LongValue.create(_runningCount));
if (_runningCount == 0)
{
return(CurlModule.CURLM_OK);
}
else
{
return(CurlModule.CURLM_CALL_MULTI_PERFORM);
}
}
/**
* Returns the error code for xml parser
*/
public Value xml_get_error_code(Xml parser)
{
if (parser == null)
{
return(BooleanValue.FALSE);
}
return(LongValue.create(parser.getErrorCode()));
}
/**
* Returns the parser's byte
*/
public Value xml_get_current_byte_index(Xml parser)
{
if (parser == null)
{
return(BooleanValue.FALSE);
}
return(LongValue.create(parser.getByteIndex()));
}
/**
* Returns the file's uncompressed size.
*
* @return false if zipEntry @is null
*/
public Value zip_entry_filesize(@NotNull QuercusZipEntry entry)
{
if (entry == null)
{
return(BooleanValue.FALSE);
}
return(LongValue.create(entry.zip_entry_filesize()));
}
/**
* Returns the parser's column
*/
public Value xml_get_current_column_number(Xml parser)
{
if (parser == null)
{
return(BooleanValue.FALSE);
}
return(LongValue.create(parser.getColumn()));
}
/**
* Returns the error code from the last operation.
*
* @param env
* @param curl
*/
public static Value curl_errno(Env env,
@NotNull CurlResource curl)
{
if (curl == null)
{
return(BooleanValue.FALSE);
}
return(LongValue.create(curl.getErrorCode()));
}
public Value mhash_get_block_size(int hash)
{
MhashAlgorithm algorithm = _algorithmMap.get(hash);
if (algorithm == null || algorithm.createMessageDigest() == null)
{
return(BooleanValue.FALSE);
}
return(LongValue.create(512)); // XXX: stubbed
}
public Value unmarshal(Env env, Object value)
{
if (value == null)
{
return(LongValue.ZERO);
}
else
{
return(LongValue.create(((Number)value).longValue()));
}
}
public void write(int b)
{
if (_env.isUnicodeSemantics())
{
_wrapper.callMethod(_env, STREAM_WRITE_U, LongValue.create(b));
}
else
{
_wrapper.callMethod(_env, STREAM_WRITE, LongValue.create(b));
}
}
public ListHeadExpr(ArrayList <Expr> varList)
{
_varList = new Expr[varList.size()];
varList.toArray(_varList);
_keyList = new Value[varList.size()];
for (int i = 0; i < varList.size(); i++)
{
_keyList[i] = LongValue.create(i);
}
}
public static Value func_num_args(Env env)
{
Value [] args = env.getFunctionArgs();
if (args != null && args.length > 0)
{
return(LongValue.create(args.length));
}
else
{
return(LongValue.ZERO);
}
}
/**
* Sets the position.
*/
public bool setPosition(long offset)
{
LongValue offsetValue = LongValue.create(offset);
LongValue whenceValue = LongValue.create(SEEK_SET);
if (_env.isUnicodeSemantics())
{
return(_wrapper.callMethod(_env, STREAM_SEEK_U,
offsetValue, whenceValue).toBoolean());
}
else
{
return(_wrapper.callMethod(_env, STREAM_SEEK,
offsetValue, whenceValue).toBoolean());
}
}
public long seek(long offset, int whence)
{
LongValue offsetValue = LongValue.create(offset);
LongValue whenceValue = LongValue.create(whence);
if (_env.isUnicodeSemantics())
{
return(_wrapper.callMethod(_env, STREAM_SEEK_U,
offsetValue, whenceValue).toLong());
}
else
{
return(_wrapper.callMethod(_env, STREAM_SEEK,
offsetValue, whenceValue).toLong());
}
}
/**
* Reads a Binary string.
*/
public StringValue read(int length)
{
Value output;
if (_env.isUnicodeSemantics())
{
output = _wrapper.callMethod(_env, STREAM_READ_U,
LongValue.create(length));
}
else
{
output = _wrapper.callMethod(_env, STREAM_READ,
LongValue.create(length));
}
return(output.toBinaryValue(_env));
}
public Value readInfo(Env env, Value msgsInQueue)
{
if (_msgQueue.size() == 0)
{
return(BooleanValue.FALSE);
}
StringValue msgStr = env.createString("msg");
StringValue resultStr = env.createString("result");
StringValue handleStr = env.createString("handle");
CurlResource curl = _msgQueue.remove(0);
ArrayValue array = new ArrayValueImpl();
array.put(msgStr, LongValue.create(CurlModule.CURLMSG_DONE));
array.put(resultStr, LongValue.create(CurlModule.CURLE_OK));
array.put(handleStr, curl);
msgsInQueue.set(LongValue.create(_msgQueue.size()));
return(array);
}
/**
* Parses the string.
*/
public static ArrayValue token_get_all(Env env, StringValue s)
{
ArrayValue result = new ArrayValueImpl();
Token lexer = new Token(env, s);
int token;
while ((token = lexer.nextToken()) >= 0)
{
if (0x20 <= token && token <= 0x7f)
{
result.put(env.createString((char)token));
}
else
{
result.put(new ArrayValueImpl()
.append(LongValue.create(token))
.append(lexer.getLexeme()));
}
}
return(result);
}
/**
* Returns an object with the following fields: name, table, max_length,
* not_null, primary_key, multiple_key, numeric,
* blob, type, unsigned, zerofill.
* <p/>
* NOTE: does not have a field for unique_key.
*
* @param env the PHP executing environment
* @param maxLength the field maximum length
* @param tableName the field table name
* @param type the field type
* @return the next field in the result set or
* false if no information @is available
*/
public Value fetchField(Env env,
int maxLength,
string tableName,
string type)
{
if (_rs == null)
{
return(BooleanValue.FALSE);
}
ObjectValue result = env.createObject();
try {
if (!_isValid)
{
_isValid = true;
_rs.next();
}
result.putField(env, "name", env.createString(_rs.getString(1)));
result.putField(env, "table", env.createString(tableName));
result.putField(env, "max_length", LongValue.create(maxLength));
if (!isInResultString(4, "YES"))
{
result.putField(env, "not_null", LongValue.ONE);
}
else
{
result.putField(env, "not_null", LongValue.ZERO);
}
if (isInResultString(5, "PRI"))
{
result.putField(env, "primary_key", LongValue.ONE);
}
else
{
result.putField(env, "primary_key", LongValue.ZERO);
}
if (isInResultString(5, "MUL"))
{
result.putField(env, "multiple_key", LongValue.ONE);
}
else
{
result.putField(env, "multiple_key", LongValue.ZERO);
}
if (isInResultString(2, "int") || isInResultString(2, "real"))
{
result.putField(env, "numeric", LongValue.ONE);
}
else
{
result.putField(env, "numeric", LongValue.ZERO);
}
if (isInResultString(2, "blob"))
{
result.putField(env, "blob", LongValue.ONE);
}
else
{
result.putField(env, "blob", LongValue.ZERO);
}
result.putField(env, "type", env.createString(type));
if (isInResultString(2, "unsigned"))
{
result.putField(env, "unsigned", LongValue.ONE);
}
else
{
result.putField(env, "unsigned", LongValue.ZERO);
}
if (isInResultString(2, "zerofill"))
{
result.putField(env, "zerofill", LongValue.ONE);
}
else
{
result.putField(env, "zerofill", LongValue.ZERO);
}
return(result);
}
catch (SQLException e) {
log.log(Level.FINE, e.ToString(), e);
return(BooleanValue.FALSE);
}
}
/**
* Returns cache information.
*/
public Value apc_cache_info(Env env,
@Optional string type,
@Optional bool limited)
{
ArrayValue value = new ArrayValueImpl();
if (_cache != null)
{
value.put("num_slots", _cache.getCapacity());
value.put("ttl", 0);
value.put("num_hits", _cache.getHitCount());
value.put("num_misses", _cache.getMissCount());
value.put("start_time", 0);
}
else
{
value.put("num_slots", 0);
value.put("ttl", 0);
value.put("num_hits", 0);
value.put("num_misses", 0);
value.put("start_time", 0);
}
ArrayValueImpl cacheList = new ArrayValueImpl();
value.put(env.createString("cache_list"), cacheList);
if ("user".equals(type) && _cache != null && !limited)
{
ArrayList <String> keys = new ArrayList <String>();
ArrayList <Entry> values = new ArrayList <Entry>();
synchronized(_cache)
{
Iterator <LruCache.Entry <String, Entry> > iter = _cache.iterator();
while (iter.hasNext())
{
LruCache.Entry <String, Entry> lruEntry = iter.next();
keys.add(lruEntry.getKey());
values.add(lruEntry.getValue());
}
}
for (int i = 0; i < keys.size(); i++)
{
string key = keys.get(i);
Entry entryValue = values.get(i);
if (entryValue.isValid(env))
{
ArrayValueImpl array = new ArrayValueImpl();
cacheList.put(array);
array.put(env.createString("info"), env.createString(key));
array.put(env.createString("ttl"),
LongValue.create(entryValue.getTTL(env)));
array.put(env.createString("type"), env.createString("user"));
array.put(env.createString("num_hits"),
LongValue.create(entryValue.getHitCount()));
}
}
}
return(value);
}
/**
* Transfer data to the server.
*/
protected void transfer(Env env)
{
super.transfer(env);
CurlHttpConnection conn = getHttpConnection();
OutputStream @out = conn.getOutputStream();
CurlResource curl = getCurlResource();
try {
BinaryInput in = curl.getUploadFile();
long length = curl.getUploadFileSize();
long totalWritten = 0;
if (curl.getReadCallback() != null)
{
Callable callback = curl.getReadCallback();
Value fileV = env.wrapJava(in);
LongValue lengthV = LongValue.create(length);
while (totalWritten < length)
{
StringValue str
= callback.call(env, fileV, lengthV).ToStringValue(env);
int count = str.length();
if (count == 0)
{
break;
}
str.writeTo(out);
totalWritten += count;
}
}
else
{
byte [] buffer = new byte[1024 * 4];
while (totalWritten < length)
{
int count = in.read(buffer, 0, buffer.length);
if (count < 0)
{
break;
}
@out.write(buffer, 0, count);
totalWritten += count;
}
}
}
finally {
@out.close();
}
}
/**
* Evaluates the expression.
*
* @param env the calling environment.
*
* @return the expression value.
*/
public Value eval(Env env)
{
return(LongValue.create(_expr.evalLong(env)));
}
public override Value key(Env env)
{
return(LongValue.create(_iterCount));
}
protected static void addConstant(Map <StringValue, Value> map,
string name, long value)
{
map.put(new ConstStringValue(name), LongValue.create(value));
}
public override Value toValue(Env env, string encoding)
{
return(LongValue.create(_index));
}
public LiteralLongExpr(Location location, long value)
{
super(location);
_value = value;
_objValue = LongValue.create(_value);
}
public StreamBucket(Env env, BinaryValue data)
{
putField(env, "data", data);
putField(env, "datalen", LongValue.create(data.length()));
}
