public static void PrintC(ArrayValue pThis, StreamWriterLevel c, int lev)
{
c.WriteLine("{");
lev++;
int cnt = pThis.m_children.Count;
c.P(lev); c.WriteLine("{0},", cnt);
c.P(lev); c.WriteLine("{");
for (int i = 0; i < cnt; i++)
{
c.P(lev + 1);
((ISCCVariable)pThis.m_children[i]).PrintC(c, lev + 1);
if (i != cnt - 1)
c.WriteLine(",");
else
c.WriteLine();
}
c.P(lev); c.WriteLine("}");
lev--;
c.P(lev);
c.Write("}");
}
public void FlattenChildArrayTables()
{
foreach (var group in this.childArrayTables.GroupBy(x => x.Item1))
{
var array = new ArrayValue<TableValue>(group.Select(x => x.Item2).ToArray());
this.AddKeyValuePair(group.Key, array);
}
this.childArrayTables.Clear();
}
public void It_Should_Return_An_Error_If_Array_Is_Empty() // TODO: Check if this is the case
{
// Arrange
ArrayValue arrayValue = new ArrayValue(new List<IExpressionConstant>());
var filter = new LastFilter();
// Act
var result = filter.Apply(new TemplateContext(), arrayValue);
// Assert
Assert.That(result.IsError, Is.True);
}
public void An_Array_With_No_Value_Should_Have_Zero_Length()
{
// Arrange
ArrayValue arrayValue = new ArrayValue(new List<IExpressionConstant>());
var filter = new SizeFilter();
// Act
var result = filter.Apply(new TemplateContext(), arrayValue).SuccessValue<NumericValue>();
// Assert
Assert.That(result.Value, Is.EqualTo(0));
}
public void It_Should_Format_An_Array_By_Concatenating_Each_Elements_STring_Value()
{
// Arrange
var num = new ArrayValue(new List<IExpressionConstant> { new StringValue("a"), new StringValue("b"), new StringValue("c") });
// Act
var result1 = ValueCaster.Cast<ArrayValue, StringValue>(num);
var stringliteral = result1.SuccessValue<StringValue>()
.StringVal;
// Assert
Assert.That(stringliteral, Is.EqualTo("abc"));
}
public void It_Should_Save_Meta_Data()
{
// Arrange
var expected = "Hello";
ArrayValue arrayValue = new ArrayValue(new List<IExpressionConstant>());
// Act
arrayValue.MetaData["test"] = expected;
// Assert
Assert.That(arrayValue.MetaData.ContainsKey("test"));
Assert.That(arrayValue.MetaData["test"], Is.EqualTo(expected));
}
public void It_Should_Dereference_An_Array_Element()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
new StringValue("a string"),
NumericValue.Create(123),
NumericValue.Create(456m),
new BooleanValue(false)
};
ArrayValue arrayValue = new ArrayValue(objlist);
// Assert
var valueAt = arrayValue.ValueAt(0);
Assert.That(valueAt.Value, Is.EqualTo(objlist[0].Value));
}
public void It_Should_Return_An_Element_At_Position_0()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
new StringValue("a string"),
NumericValue.Create(123),
NumericValue.Create(456m),
new BooleanValue(false)
};
ArrayValue arrayValue = new ArrayValue(objlist);
var filter = new PositionFilter(NumericValue.Create(0));
// Act
var result = filter.Apply(new TemplateContext(), arrayValue).SuccessValue<StringValue>();
// Assert
Assert.That(result, Is.EqualTo(objlist[0]));
}
public void It_Should_Measure_The_Size_Of_An_Array()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
new StringValue("a string"),
NumericValue.Create(123),
NumericValue.Create(456m),
new BooleanValue(false)
};
ArrayValue arrayValue = new ArrayValue(objlist);
var filter = new SizeFilter();
// Act
var result = filter.Apply(new TemplateContext(), arrayValue).SuccessValue<NumericValue>();
// Assert
Assert.That(result.Value, Is.EqualTo(4));
}
public void It_Should_Access_Size_Property_Of_An_Array()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
new StringValue("a string"),
NumericValue.Create(123),
NumericValue.Create(456m),
new BooleanValue(false)
};
ArrayValue arrayValue = new ArrayValue(objlist);
var ctx = new TemplateContext().WithAllFilters();
ctx.DefineLocalVariable("myarray", arrayValue);
// Act
var result = RenderingHelper.RenderTemplate("Result : {{ myarray.size }}", ctx);
// Assert
Assert.That(result, Is.EqualTo("Result : 4" ));
}
public void It_Should_Join_An_Array_With_A_String()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
new StringValue("a string"),
NumericValue.Create(123),
NumericValue.Create(456m),
new BooleanValue(false)
};
ArrayValue arrayValue = new ArrayValue(objlist);
var filter = new JoinFilter(new StringValue(", "));
// Act
var result = filter.Apply(new TemplateContext(), arrayValue).SuccessValue<StringValue>();
//Logger.Log(result.ToString());
// Assert
Assert.That(result.StringVal, Is.EqualTo("a string, 123, 456.0, false"));
}
public void It_Should_Filter_Out_Unique_Simple_Objects()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
new StringValue("123"),
NumericValue.Create(456m),
NumericValue.Create(123),
NumericValue.Create(123),
new BooleanValue(false)
};
ArrayValue arrayValue = new ArrayValue(objlist);
var filter = new UniqFilter();
// Act
var result = filter.Apply(new TemplateContext(), arrayValue).SuccessValue<ArrayValue>();
// Assert
Assert.That(result.Select(ValueCaster.RenderAsString), Is.EquivalentTo(new List<String>{"123", "456.0", "123", "false"}));
}
public void It_Should_Sort_An_Array_By_StringValues()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
new StringValue("a string"),
NumericValue.Create(123),
NumericValue.Create(456m),
new BooleanValue(false)
};
ArrayValue arrayValue = new ArrayValue(objlist);
var filter = new SortFilter(new StringValue(""));
// Act
var result = filter.Apply(new TemplateContext(), arrayValue);
var resultStrings = result.SuccessValue<ArrayValue>().Select(ValueCaster.RenderAsString);
// Assert
Assert.That(resultStrings, Is.EqualTo(new List<String>{"123", "456.0", "a string", "false"}));
}
private LiquidExpressionResult DoLookup(ITemplateContext ctx, ArrayValue arrayValue, IExpressionConstant indexProperty)
{
String propertyNameString = ValueCaster.RenderAsString(indexProperty);
int index;
if (propertyNameString.ToLower().Equals("first"))
{
index = 0;
}
else if (propertyNameString.ToLower().Equals("last"))
{
index = arrayValue.ArrValue.Count - 1;
}
else if (propertyNameString.ToLower().Equals("size"))
{
return LiquidExpressionResult.Success(NumericValue.Create(arrayValue.ArrValue.Count));
}
else
{
var maybeIndexResult = ValueCaster.Cast<IExpressionConstant, NumericValue>(indexProperty);
if (maybeIndexResult.IsError || !maybeIndexResult.SuccessResult.HasValue)
{
return LiquidExpressionResult.Error("invalid array index: " + propertyNameString);
}
else
{
index = maybeIndexResult.SuccessValue<NumericValue>().IntValue;
}
}
if (arrayValue.ArrValue.Count == 0)
{
//return LiquidExpressionResult.Error("array is empty: " + propertyNameString);
return LiquidExpressionResult.Success(new None<IExpressionConstant>()); // not an error in Ruby liquid.
}
var result = arrayValue.ValueAt(index);
return LiquidExpressionResult.Success(result);
}
public void It_Should_Sort_Dictionaries_By_Field()
{
// Arrange
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
DataFixtures.CreateDictionary(1, "Aa", "Value 1 B"),
DataFixtures.CreateDictionary(2, "Z", "Value 2 B"),
DataFixtures.CreateDictionary(3, "ab", "Value 3 B"),
DataFixtures.CreateDictionary(4, "b", "Value 4 B"),
};
ArrayValue arrayValue = new ArrayValue(objlist);
SortFilter sizeFilter = new SortFilter(new StringValue("field1"));
// Act
var result = sizeFilter.Apply(new TemplateContext(), arrayValue);
// Assert
Assert.That(IdAt(result.SuccessValue<ArrayValue>(), 0, "field1").Value, Is.EqualTo("Aa"));
Assert.That(IdAt(result.SuccessValue<ArrayValue>(), 1, "field1").Value, Is.EqualTo("ab"));
Assert.That(IdAt(result.SuccessValue<ArrayValue>(), 2, "field1").Value, Is.EqualTo("b"));
Assert.That(IdAt(result.SuccessValue<ArrayValue>(), 3, "field1").Value, Is.EqualTo("Z"));
}
public void It_Should_Allow_Tags_To_Span_Lines()
{
// Arrange
var templateContext = new TemplateContext();
IList<IExpressionConstant> objlist = new List<IExpressionConstant>
{
DataFixtures.CreateDictionary(1, "Title 1", "Value 1 B"),
DataFixtures.CreateDictionary(2, "Title 2", "Value 2 B"),
DataFixtures.CreateDictionary(3, "Title 3", "Value 3 B"),
DataFixtures.CreateDictionary(4, "Title 4", "Value 4 B"),
};
ArrayValue arrayValue = new ArrayValue(objlist);
templateContext.DefineLocalVariable("posts", arrayValue);
const string tmpl = @"{%
for post in posts %}{{
post.field1 }}{%
endfor
%}";
var ast = _generator.Generate(tmpl);
// Act
String result = Render(templateContext, ast);
Logger.Log("result is " + result);
// Assert
Assert.That(result, Is.EqualTo("Title 1Title 2Title 3Title 4"));
}
/**
* Defines constants
*/
public bool apc_define_constants(Env env,
string key,
ArrayValue values,
@Optional("true") bool caseSensitive)
public void It_Should_Render_An_Array_Element_From_A_Variable_in_A_Nested_Element_In_a_Tag()
{
// Arrange
TemplateContext templateContext = new TemplateContext();
var arrayofbool = new ArrayValue(new List<IExpressionConstant> { new BooleanValue(true), new BooleanValue(false) });
var array1 = new ArrayValue(new List<IExpressionConstant> { arrayofbool });
var array2 = new ArrayValue(new List<IExpressionConstant> { array1 });
templateContext.DefineLocalVariable("idx1", NumericValue.Create(0));
templateContext.DefineLocalVariable("idx2", NumericValue.Create(1));
templateContext.DefineLocalVariable("array1", array1);
templateContext.DefineLocalVariable("array2", array2);
templateContext.DefineLocalVariable("arrayofbool", arrayofbool);
// Act
var ast = _generator.Generate("Result : {% if array2[0][0][idx1] %}first is TRUE{% endif %}{%if array2[0][0][idx2] %}second is TRUE{% endif %}");
String result = Render(templateContext, ast);
Logger.Log(result);
// Assert
Assert.That(result, Is.EqualTo("Result : first is TRUE"));
}
public void It_Should_Return_Empty_When_Index_Is_Empty()
{
// Arrange
TemplateContext templateContext = new TemplateContext();
var arrayofnums = new ArrayValue(new List<IExpressionConstant> { NumericValue.Create(0), NumericValue.Create(1) });
templateContext.DefineLocalVariable("arrayofnums", arrayofnums);
// Arrange
var ast = _generator.Generate("Result : {{ arrayofnums[4][arrayofnums[4]] }}");
// Act
String result = Render(templateContext, ast);
// Act
// Assert
Assert.That(result, Is.EqualTo("Result : "));
}
static void Main(string[] args)
{
try
{
var assemblyPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
var commandLine = new CommandLineParser();
commandLine.Parse(args);
if (commandLine.Has("help"))
{
Console.WriteLine("编译器可使用下列参数：");
Console.Write("-S");
Console.WriteLine("\t[编译选项][必选]，输入的源程序路径。");
Console.WriteLine();
Console.Write("-RUN");
Console.WriteLine("\t[运行选项][可选]，使用该选项后，源程序将不会被编译（忽略编译参数），直接解析运行源程序。");
Console.WriteLine();
Console.Write("-ARCH");
Console.WriteLine("\t[编译选项][可选][默认值：x86]，选择目标运行平台的机器架构，可用架构系统：");
{
var files = Directory.GetFiles(assemblyPath, "*.Loader");
var archs = files.Select((s) =>
{
var temp = Path.GetFileNameWithoutExtension(s).Split('.');
if (temp.Length == 3)
{
return(temp[2]);
}
return(string.Empty);
}).Distinct();
foreach (var a in archs)
{
Console.WriteLine($"\t\t{a}");
}
}
Console.WriteLine();
Console.Write("-OS");
Console.WriteLine("\t[编译选项][可选][默认值：windows]，选择目标运行平台的操作系统，可用系统名称：");
{
var files = Directory.GetFiles(assemblyPath, "*.Loader");
var archs = files.Select((s) =>
{
var temp = Path.GetFileNameWithoutExtension(s).Split('.');
if (temp.Length == 3)
{
return(temp[1]);
}
return(string.Empty);
}).Distinct();
foreach (var a in archs)
{
Console.WriteLine($"\t\t{a}");
}
}
Console.WriteLine();
Console.Write("-I");
Console.WriteLine("\t[链接选项][可选][默认值：根据选择的OS和ARCH自动选择]，选择函数导入表文件，可用名称：");
{
var files = Directory.GetFiles(assemblyPath, "*.def");
var archs = files.Select((s) => Path.GetFileName(s)).Distinct();
foreach (var a in archs)
{
Console.WriteLine($"\t\t{a}");
}
}
Console.WriteLine();
Console.Write("-T");
Console.WriteLine("\t[链接选项][可选][默认值：EXE]，选择输出文件类型，可用类型：");
{
Console.WriteLine("\t\tASM\t字节码汇编文件。");
Console.WriteLine("\t\tBIN\t字节码文件。");
Console.WriteLine("\t\tEXE\t可执行文件。");
}
Console.WriteLine();
Console.Write("-O");
Console.WriteLine("\t[链接选项][可选][默认值：output]，选择输出文件路径。");
Console.WriteLine();
Console.Write("-help");
Console.WriteLine("\t[帮助选项][可选]，显示本页信息。");
Console.WriteLine();
}
else if (commandLine.Has("S"))
{
var source = commandLine.GetValue("S", "");
if (!Path.IsPathRooted(source))
{
source = Path.GetFullPath(source);
}
Lexer lexer = new Lexer(new SourceInputStream(source));
GrammarParser parser = new GrammarParser();
var ast = parser.ParseProgram(lexer);
if (commandLine.Has("RUN"))
{
Console.Clear();
DemoActuator vm = new DemoActuator();
var vargs = new ArrayValue(args.Length, 1);
for (int i = 0; i < args.Length; ++i)//命令行参数
{
vargs.SetValue(i, 0, new StringValue(args[i]));
}
vm.GVariableTable["命令行参数"] = vargs;
ast.Execute(vm);
}
else
{
Compiler compiler = new Compiler();
var arch = commandLine.GetValue("ARCH", "x86");
var os = commandLine.GetValue("OS", "windows");
var importFile = commandLine.GetValue("I", $"import.{arch}.{os}.def");
var type = commandLine.GetValue("T", "EXE");
var output = commandLine.GetValue("O", "output");
if (!Path.IsPathRooted(importFile))
{
importFile = Path.Combine(assemblyPath, importFile);
}
if (!Path.IsPathRooted(output))
{
output = Path.Combine(Path.GetDirectoryName(source), output);
}
compiler.LoadImportDefine(importFile);
ast.Compile(compiler);
if (string.Compare(type, "ASM") == 0)
{
if (!Path.HasExtension(output))
{
output += ".asm";
}
compiler.LinkProgram(output, Compiler.OutputType.ASM, string.Empty);
}
else if (string.Compare(type, "BIN", true) == 0)
{
if (!Path.HasExtension(output))
{
output += ".bin";
}
compiler.LinkProgram(output, Compiler.OutputType.BIN, string.Empty);
}
else
{
if (!Path.HasExtension(output))
{
if (os == "windows")
{
output += ".exe";
}
else if (os == "linux")
{
output += ".elf";
}
}
string loaderPath = Path.Combine(assemblyPath, $"link.{os}.{arch}.Loader");
compiler.LinkProgram(output, Compiler.OutputType.EXE, loaderPath);
}
}
}
else
{
throw new ArgumentNullException("S", "必需输入源程序路径.");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void It_Should_Render_An_Array_Element()
{
// Arrange
TemplateContext templateContext = new TemplateContext();
var list = new ArrayValue(new List<IExpressionConstant> { new StringValue("aaa"), NumericValue.Create(123m) });
templateContext.DefineLocalVariable("myarray", list);
// Arrange
var ast = _generator.Generate("Result : {{ myarray[1] }}");
// Act
String result = Render(templateContext, ast);
// Act
// Assert
Assert.That(result, Is.EqualTo("Result : 123.0"));
}
static void fillPost(Env env,
ArrayValue postArray,
ArrayValue files,
InputStream @is,
string contentType,
string encoding,
int contentLength,
bool addSlashesToValues,
bool isAllowUploads)
{
long maxPostSize = env.getIniBytes("post_max_size", 0);
try {
if (encoding == null)
{
encoding = env.getHttpInputEncoding();
}
if (contentType != null &&
contentType.startsWith("multipart/form-data"))
{
string boundary = getBoundary(contentType);
ReadStream rs = new ReadStream(new VfsStream(@is, null));
if (boundary == null)
{
env.warning(L.l("multipart/form-data POST @is missing boundary"));
return;
}
MultipartStream ms = new MultipartStream(rs, boundary);
if (encoding != null)
{
ms.setEncoding(encoding);
}
readMultipartStream(env, ms, postArray, files,
addSlashesToValues, isAllowUploads);
rs.close();
if (rs.getLength() > maxPostSize)
{
env.warning(L.l("POST length of {0} exceeds max size of {1}",
rs.getLength(),
maxPostSize));
postArray.clear();
files.clear();
return;
}
}
else
{
StringValue bb = env.createBinaryBuilder();
bb.appendReadAll(@is, Integer.MAX_VALUE);
if (bb.length() > maxPostSize)
{
env.warning(L.l("POST length of {0} exceeds max size of {1}",
bb.length(),
maxPostSize));
return;
}
env.setInputData(bb);
if (contentType != null &&
contentType.startsWith("application/x-www-form-urlencoded"))
{
StringUtility.parseStr(env, bb, postArray, true, encoding, true);
}
}
}
catch (IOException e) {
env.warning(e);
}
}
public ArrayValue GetAllIndices(ArrayValue array)
{
this.log.AppendLine($"Array.GetAllIndices(array: '{array.ToDisplayString()}')");
return(new ArrayValue());
}
private static IExpressionConstant IdAt(ArrayValue result, int index, String field)
{
return ((DictionaryValue)result.ArrValue[index].Value).DictValue[field].Value;
}
private LiquidExpressionResult Contains(ArrayValue arrayValue, IExpressionConstant expressionConstant)
{
return LiquidExpressionResult.Success(new BooleanValue(arrayValue.ArrValue.Any(IsEqual(expressionConstant))));
}
private static void addFormFile(Env env,
ArrayValue files,
string name,
string fileName,
string tmpName,
string mimeType,
long fileLength,
bool addSlashesToValues,
long maxFileSize)
{
int p = name.indexOf('[');
string index = "";
if (p >= 0)
{
index = name.substring(p);
name = name.substring(0, p);
}
// php/085j
name = name.replace("\u0000", "");
StringValue nameValue = env.createString(name);
Value v = files.get(nameValue).toValue();
ArrayValue entry = null;
if (v instanceof ArrayValue)
{
entry = (ArrayValue)v;
}
if (entry == null)
{
entry = new ArrayValueImpl();
files.put(nameValue, entry);
}
int error;
// php/1667
long uploadMaxFilesize
= env.getIniBytes("upload_max_filesize", 2 * 1024 * 1024);
// php/085j
fileName = fileName.replace("\u0000", "");
if (fileName.length() == 0)
{
// php/0864
error = FileModule.UPLOAD_ERR_NO_FILE;
}
else if (fileLength > uploadMaxFilesize)
{
error = FileModule.UPLOAD_ERR_INI_SIZE;
}
else if (fileLength > maxFileSize)
{
error = FileModule.UPLOAD_ERR_FORM_SIZE;
}
else
{
error = FileModule.UPLOAD_ERR_OK;
}
addFormValue(env, entry, "name" + index, env.createString(fileName),
null, addSlashesToValues, true);
long size;
if (error == FileModule.UPLOAD_ERR_OK)
{
size = fileLength;
}
else
{
mimeType = "";
tmpName = "";
size = 0;
}
if (mimeType != null)
{
addFormValue(env, entry, "type" + index, env.createString(mimeType),
null, addSlashesToValues, true);
}
addFormValue(env, entry, "tmp_name" + index, env.createString(tmpName),
null, addSlashesToValues, true);
addFormValue(env, entry, "error" + index, LongValue.create(error),
null, addSlashesToValues, true);
addFormValue(env, entry, "size" + index, LongValue.create(size),
null, addSlashesToValues, true);
addFormValue(env, files, name, entry, null, addSlashesToValues, true);
}
public ArrayValue GetAllIndices(ArrayValue array)
{
int i = 1;
return(new ArrayValue(array.Values.ToDictionary(value => (i++).ToString(CultureInfo.CurrentCulture))));
}
public abstract bool CompareArrayToString(ArrayValue <StringValue> itemValue, StringValue value);
public bool setOptions(Env env, ArrayValue array)
{
return(false);
}
protected Object FromArrayValue(ArrayValue av)
{
return(av.GetArray());
}
/// <summary>
/// Serialises the specified object into a value node
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public ValueNode Serialise(object obj)
{
// Sanity check
if (obj == null) return null;
Type t = obj.GetType();
// Is it a map type?
if (typeof(IDictionary).IsAssignableFrom(t))
{
// Create a map type
MapValue mapVal = new MapValue();
IDictionary dict = obj as IDictionary;
foreach (var key in dict.Keys)
{
if (key is string)
{
ValueNode tmp;
if (translateOpts.Serialise(dict[key], out tmp))
mapVal.Add(key as string, tmp);
else
mapVal.Add(key as string, null);
}
}
return mapVal;
}
// Is it an array type?
else if (t.IsArray)
{
// Create an array type
ArrayValue arrVal = new ArrayValue();
var arr = obj as Array;
for (int i = 0; i < arr.Length; i++)
{
ValueNode tmp;
if (translateOpts.Serialise(arr.GetValue(i), out tmp))
arrVal.Add(tmp);
else
arrVal.Add(null);
}
return arrVal;
}
else if (typeof(IList).IsAssignableFrom(t))
{
// Create an array type
ArrayValue arrVal = new ArrayValue();
var list = obj as IList;
for (int i = 0; i < list.Count; i++)
{
ValueNode tmp;
if (translateOpts.Serialise(list[i], out tmp))
arrVal.Add(tmp);
else
arrVal.Add(null);
}
return arrVal;
}
else if (typeof(ICollection).IsAssignableFrom(t))
{
// Create an array type
ArrayValue arrVal = new ArrayValue();
var collection = obj as ICollection;
foreach (object item in collection)
{
ValueNode tmp;
if (translateOpts.Serialise(item, out tmp))
arrVal.Add(tmp);
else
arrVal.Add(null);
}
return arrVal;
}
// Fill a map via reflection
MapValue mapValue = new MapValue();
foreach (var field in t.GetFields(BindingFlags.Public | BindingFlags.Instance))
{
ValueNode tmp;
if (translateOpts.Serialise(field.GetValue(obj), out tmp) && tmp != null)
mapValue.Add(field.Name, tmp);
}
foreach (var property in t.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (property.GetGetMethod() != null)
{
ValueNode tmp;
if (translateOpts.Serialise(property.GetValue(obj, null), out tmp) && tmp != null)
mapValue.Add(property.Name, tmp);
}
}
return mapValue;
}
public static Value parseStr(Env env,
CharSequence str,
ArrayValue result,
bool isRef,
string encoding,
bool isMagicQuotes,
bool isReplaceSpacesWithUnderscores,
int [] querySeparatorMap)
{
try {
ByteToChar byteToChar = env.getByteToChar();
if (encoding != null)
{
byteToChar.setEncoding(encoding);
}
int len = str.length();
for (int i = 0; i < len; i++)
{
int ch = 0;
byteToChar.clear();
for (;
i < len && isSeparator(querySeparatorMap, ch = str[i]);
i++)
{
}
for (; i < len &&
(ch = str[i]) != '=' &&
!isSeparator(querySeparatorMap, ch);
i++)
{
i = addQueryChar(byteToChar, str, len, i, ch, querySeparatorMap);
}
string key = byteToChar.getConvertedString();
byteToChar.clear();
string value;
if (ch == '=')
{
for (i++; i < len &&
!isSeparator(querySeparatorMap, (ch = str[i])); i++)
{
i = addQueryChar(byteToChar, str, len, i, ch, querySeparatorMap);
}
value = byteToChar.getConvertedString();
}
else
{
value = "";
}
if (key.length() == 0)
{
// php/php/080d
// http://bugs.caucho.com/view.php?id=4998
continue;
}
else if (isRef)
{
Post.addFormValue(env, result, key,
new String[] { value },
isMagicQuotes, isReplaceSpacesWithUnderscores);
}
else
{
// If key @is an exsiting array, then append
// this value to existing array
// Only use extract(EXTR_OVERWRITE) on non-array variables or
// non-existing arrays
int openBracketIndex = key.indexOf('[');
int closeBracketIndex = key.indexOf(']');
if (openBracketIndex == 0)
{
// http://bugs.caucho.com/view.php?id=4998
continue;
}
else if (openBracketIndex > 0)
{
string arrayName = key.substring(0, openBracketIndex);
arrayName = arrayName.replace('.', '_');
Value v = env.getVar(arrayName).getRawValue();
if (v instanceof ArrayValue)
{
//Check to make sure valid string (ie: foo[...])
if (closeBracketIndex < 0)
{
env.warning(L.l("invalid array {0}", key));
return(NullValue.NULL);
}
if (closeBracketIndex > openBracketIndex + 1)
{
string index = key.substring(key.indexOf('[') + 1,
key.indexOf(']'));
v.put(env.createString(index), env.createString(value));
}
else
{
v.put(env.createString(value));
}
}
else
{
Post.addFormValue(env, result, key,
new String[] { value },
isMagicQuotes, isReplaceSpacesWithUnderscores);
}
}
else
{
Post.addFormValue(env, result, key,
new String[] { value },
isMagicQuotes, isReplaceSpacesWithUnderscores);
}
}
public void It_Should_Iterate_Through_A_Nested_Collection()
{
// Arrange
const string templateString = "Result : {% for subarray in array1 %}"
+ "<tr>{% for item in subarray %}"
+ "<td>{{item}}</td>"
+ "{% endfor %}"
+ "</tr>{% endfor %}";
TemplateContext ctx = new TemplateContext();
var numericValues = Enumerable.Range(0, 3).Select(x => (IExpressionConstant) NumericValue.Create(x)).ToList();
var array2 = new ArrayValue(numericValues);
//var array1 = Enumerable.Range(0, 3).Select(x => new ArrayValue(array2);
var array1 = new ArrayValue(new List<IExpressionConstant> { array2, array2, array2 });
ctx.DefineLocalVariable("array1", array1);
var template = LiquidTemplate.Create(templateString);
// Act
String result = template.Render(ctx);
// Assert
String row = "<tr><td>0</td><td>1</td><td>2</td></tr>";
Assert.That(result, Is.EqualTo("Result : "+row + row + row));
}
public override bool CompareArrayToString(ArrayValue <StringValue> itemValue, StringValue value)
{
return(itemValue.Values.All(x => !Compare(x, value)));
}
private static void putRequestMap(Env env,
ArrayValue post,
ArrayValue files,
QuercusHttpServletRequest request,
bool addSlashesToValues,
bool isAllowUploads)
{
// this call consumes the inputstream
Map <String, String[]> map = request.getParameterMap();
if (map == null)
{
return;
}
long maxFileSize = Long.MAX_VALUE;
Value maxFileSizeV = post.get(env.createString("MAX_FILE_SIZE"));
if (maxFileSizeV.isNull())
{
maxFileSize = maxFileSizeV.toLong();
}
if (isAllowUploads)
{
for (Map.Entry <String, String[]> entry : map.entrySet())
{
string key = entry.getKey();
int len = key.length();
if (len < 10 || !key.endsWith(".filename"))
{
continue;
}
string name = key.substring(0, len - 9);
string [] fileNames = request.getParameterValues(name + ".filename");
string [] tmpNames = request.getParameterValues(name + ".file");
string [] mimeTypes
= request.getParameterValues(name + ".content-type");
for (int i = 0; i < fileNames.length; i++)
{
long fileLength = new FilePath(tmpNames[i]).getLength();
addFormFile(env, files, name, fileNames[i], tmpNames[i],
mimeTypes[i],
fileLength,
addSlashesToValues,
maxFileSize);
}
}
}
ArrayList <String> keys = new ArrayList <String>();
keys.addAll(request.getParameterMap().keySet());
Collections.sort(keys);
for (String key : keys)
{
string [] value = request.getParameterValues(key);
Post.addFormValue(env, post, key, value, addSlashesToValues, true);
}
}
/// <summary>
/// Returns true if a ValueNode graph contains a cycle
/// </summary>
/// <param name="node">Node to evaluate</param>
/// <param name="seenNodes">Set of nodes previously seen on the current arc. Callers may pass a non-empty set
/// to test whether adding that set to this node would create a cycle. Contents will be modified by the walk
/// and should not be used by the caller after returning</param>
/// <param name="allNodesSeen">Optional. The set of all nodes encountered during a walk after DetectCycle returns</param>
/// <returns></returns>
public static bool DetectCycle(this SingleValue node, HashSet <SingleValue> seenNodes, HashSet <SingleValue>?allNodesSeen)
{
if (node == null)
{
return(false);
}
if (seenNodes.Contains(node))
{
return(true);
}
seenNodes.Add(node);
if (allNodesSeen != null)
{
allNodesSeen.Add(node);
}
bool foundCycle = false;
switch (node)
{
//
// Leaf nodes
//
case UnknownValue:
case NullValue:
case SystemTypeValue:
case RuntimeTypeHandleValue:
case KnownStringValue:
case ConstIntValue:
case MethodParameterValue:
case MethodThisParameterValue:
case MethodReturnValue:
case GenericParameterValue:
case RuntimeTypeHandleForGenericParameterValue:
case SystemReflectionMethodBaseValue:
case RuntimeMethodHandleValue:
case FieldValue:
break;
//
// Nodes with children
//
case ArrayValue:
ArrayValue av = (ArrayValue)node;
foundCycle = av.Size.DetectCycle(seenNodes, allNodesSeen);
foreach (ValueBasicBlockPair pair in av.IndexValues.Values)
{
foreach (var v in pair.Value)
{
foundCycle |= v.DetectCycle(seenNodes, allNodesSeen);
}
}
break;
case RuntimeTypeHandleForNullableValueWithDynamicallyAccessedMembers value:
foundCycle = value.UnderlyingTypeValue.DetectCycle(seenNodes, allNodesSeen);
break;
case NullableValueWithDynamicallyAccessedMembers value:
foundCycle = value.UnderlyingTypeValue.DetectCycle(seenNodes, allNodesSeen);
break;
default:
throw new Exception(String.Format("Unknown node type: {0}", node.GetType().Name));
}
seenNodes.Remove(node);
return(foundCycle);
}
public decimal GetItemCount(ArrayValue array)
{
this.log.AppendLine($"Array.GetItemCount(array: '{array.ToDisplayString()}')");
return(0m);
}
public bool ContainsIndex(ArrayValue array, string index) => array.ContainsKey(index);
public void It_Should_Render_An_Array_In_A_Dictionary()
{
// Arrange
TemplateContext templateContext = new TemplateContext();
var list = new ArrayValue(new List<IExpressionConstant>{ new StringValue("aaa"), NumericValue.Create(123m) } );
var dict = new Dictionary<String, IExpressionConstant> { { "test", list } };
templateContext.DefineLocalVariable("mydict", new DictionaryValue(dict));
// Arrange
var ast = _generator.Generate("Result : {{ mydict.test[0] }}");
// Act
String result = Render(templateContext, ast);
// Act
// Assert
Assert.That(result, Is.EqualTo("Result : aaa"));
}
public bool ContainsValue(ArrayValue array, string value) => array.Values.Any(existing => existing.ToString() == value);
public void It_Should_Render_An_Array_Element_From_A_Nested_Index()
{
// Arrange
TemplateContext templateContext = new TemplateContext();
var indexlist = new ArrayValue(new List<IExpressionConstant> { NumericValue.Create(0), NumericValue.Create(1) });
var list = new ArrayValue(new List<IExpressionConstant> { new StringValue("aaa"), new StringValue("bbb") });
templateContext.DefineLocalVariable("indexes", indexlist);
templateContext.DefineLocalVariable("myarray", list);
// Arrange
var ast = _generator.Generate("Result : {{ myarray[indexes[1]] }}");
// Act
String result = Render(templateContext, ast);
// Act
// Assert
Assert.That(result, Is.EqualTo("Result : bbb"));
}
public ArrayValue GetAllIndices(ArrayValue array)
{
int i = 1;
return(new ArrayValue(array.Keys.Select(k => StringValue.Create(k)).ToDictionary(value => (i++).ToString(CultureInfo.CurrentCulture))));
}
public void It_Should_Render_An_Array_Element_From_A_Crazy_Chain_of_Nested_Indexes()
{
// Arrange
TemplateContext templateContext = new TemplateContext();
var arrayofnums = new ArrayValue(new List<IExpressionConstant> { NumericValue.Create(0), NumericValue.Create(1) });
var array1 = new ArrayValue(new List<IExpressionConstant> { arrayofnums });
var array2 = new ArrayValue(new List<IExpressionConstant> { array1 });
var arrayofstr = new ArrayValue(new List<IExpressionConstant> { new StringValue("aaa"), new StringValue("bbb") });
//templateContext.Define("arrayofnums", new NumericValue(1));
templateContext.DefineLocalVariable("arrayofnums", arrayofnums);
templateContext.DefineLocalVariable("array1", array1);
templateContext.DefineLocalVariable("array2", array2);
templateContext.DefineLocalVariable("arrayofstr", arrayofstr);
// Arrange
var ast = _generator.Generate("Result : {{ arrayofstr[array2[0][0][arrayofnums[arrayofnums[1]]]] }}");
// Act
String result = Render(templateContext, ast);
// Act
// Assert
Assert.That(result, Is.EqualTo("Result : bbb"));
}
public decimal GetItemCount(ArrayValue array) => array.Count;
public void It_Should_Return_An_Error_If_A_Number_Is_Treated_Like_An_Array()
{
// Arrange
TemplateContext templateContext = new TemplateContext();
var arrayofnums = new ArrayValue(new List<IExpressionConstant> { NumericValue.Create(0), NumericValue.Create(1) });
templateContext.DefineLocalVariable("arrayofnums", arrayofnums);
templateContext.DefineLocalVariable("numeric", NumericValue.Create(1));
// Arrange
var ast = _generator.Generate("Result : {{ arrayofnums[4][numeric[4]] }}");
// Act
String result = Render(templateContext, ast);
// Act
// Assert
Assert.That(result, Is.StringContaining("cannot apply an index to a numeric."));
}
public override Value GetValue(UserItem item)
{
return(ArrayValue <StringValue> .Create(item.Item.Tags?.Select(StringValue.Create).ToArray()));
}
// Generalized n-argument map
public static Value Map(Value[] vs)
{
int n = vs.Length - 1;
if (n < 1)
return ErrorValue.argCountError;
if (vs[0] is ErrorValue) return vs[0];
FunctionValue fv = vs[0] as FunctionValue;
if (fv == null)
return ErrorValue.argTypeError;
if (fv.Arity != n)
return ErrorValue.argCountError;
ArrayValue[] arrs = new ArrayValue[n];
for (int i = 0; i < n; i++) {
Value vi = vs[i + 1];
if (vi is ArrayValue)
arrs[i] = vi as ArrayValue;
else if (vi is ErrorValue)
return vi;
else
return ErrorValue.argTypeError;
}
int cols = arrs[0].Cols, rows = arrs[0].Rows;
for (int i=1; i<n; i++)
if (arrs[i].Cols != cols || arrs[i].Rows != rows)
return ErrorValue.Make("#ERR: Array shapes differ");
Value[] args = new Value[n];
Value[,] result = new Value[cols, rows];
for (int c = 0; c < cols; c++)
for (int r = 0; r < rows; r++) {
for (int i = 0; i < n; i++)
args[i] = arrs[i][c, r];
result[c, r] = fv.Apply(args);
}
return new ArrayExplicit(result);
}
private static void addFormFile(Env env,
ArrayValue files,
string fileName,
string tmpName,
string mimeType,
long fileLength,
bool addSlashesToValues,
long maxFileSize)
{
ArrayValue entry = new ArrayValueImpl();
int error;
// php/1667
long uploadMaxFilesize
= env.getIniBytes("upload_max_filesize", 2 * 1024 * 1024);
// php/085j
fileName = fileName.replace("\u0000", "");
if (fileName.length() == 0)
{
// php/0864
error = FileModule.UPLOAD_ERR_NO_FILE;
}
else if (fileLength > uploadMaxFilesize)
{
error = FileModule.UPLOAD_ERR_INI_SIZE;
}
else if (fileLength > maxFileSize)
{
error = FileModule.UPLOAD_ERR_FORM_SIZE;
}
else
{
error = FileModule.UPLOAD_ERR_OK;
}
addFormValue(env, entry, "name", env.createString(fileName),
null, addSlashesToValues, true);
long size;
if (error != FileModule.UPLOAD_ERR_INI_SIZE)
{
size = fileLength;
}
else
{
mimeType = "";
tmpName = "";
size = 0;
}
if (mimeType != null)
{
addFormValue(env, entry, "type", env.createString(mimeType),
null, addSlashesToValues, true);
entry.put("type", mimeType);
}
addFormValue(env, entry, "tmp_name", env.createString(tmpName),
null, addSlashesToValues, true);
addFormValue(env, entry, "error", LongValue.create(error),
null, addSlashesToValues, true);
addFormValue(env, entry, "size", LongValue.create(size),
null, addSlashesToValues, true);
addFormValue(env, files, null, entry, null, addSlashesToValues, true);
}
private static void readMultipartStream(Env env,
MultipartStream ms,
ArrayValue postArray,
ArrayValue files,
bool addSlashesToValues,
bool isAllowUploads)
{
ReadStream is;
while ((@is = ms.openRead()) != null)
{
string attr = (String)ms.getAttribute("content-disposition");
if (attr == null || !attr.startsWith("form-data"))
{
// XXX: @is this an error?
continue;
}
string name = getAttribute(attr, "name", addSlashesToValues);
string filename = getAttribute(attr, "filename", addSlashesToValues);
if (filename != null)
{
int slashIndex = filename.lastIndexOf('/');
int slashIndex2 = filename.lastIndexOf('\\');
slashIndex = Math.max(slashIndex, slashIndex2);
if (slashIndex >= 0)
{
filename = filename.substring(slashIndex + 1);
}
}
int bracketIndex = -1;
if (name != null)
{
bracketIndex = name.lastIndexOf(']');
}
if (bracketIndex >= 0 && bracketIndex < name.length() - 1)
{
// php/085c
}
else if (filename == null)
{
StringValue value = env.createStringBuilder();
value.appendReadAll(@is, Integer.MAX_VALUE);
if (name != null)
{
addFormValue(env, postArray, name, value, null, addSlashesToValues, true);
}
else
{
env.warning(L.l("file upload @is missing name and filename"));
}
}
else
{
if (!isAllowUploads)
{
continue;
}
string tmpName = "";
long tmpLength = 0;
// A POST file upload with an empty string as the filename does not
// create a temp file in the upload directory.
if (filename.length() > 0)
{
string tmpPath = env.getUploadDirectory().createTempFile("php", ".tmp");
env.addRemovePath(tmpPath);
WriteStream os = tmpPath.openWrite();
try {
os.writeStream(is);
} finally {
os.close();
}
tmpName = tmpPath.getFullPath();
tmpLength = tmpPath.getLength();
}
// php/0865
//
// A header like "Content-Type: image/gif" indicates the mime type
// for an uploaded file.
string mimeType = getAttribute(attr, "mime-type", addSlashesToValues);
if (mimeType == null)
{
mimeType = (String)ms.getAttribute("content-type");
// php/085f
if (mimeType != null && mimeType.endsWith(";"))
{
mimeType = mimeType.substring(0, mimeType.length() - 1);
}
}
// php/0864
//
// mime type @is empty string when no file @is uploaded.
if (filename.length() == 0)
{
mimeType = "";
}
long maxFileSize = Long.MAX_VALUE;
Value maxFileSizeV = postArray.get(env.createString("MAX_FILE_SIZE"));
if (!maxFileSizeV.isNull())
{
maxFileSize = maxFileSizeV.toLong();
}
if (name != null)
{
addFormFile(env, files, name, filename, tmpName,
mimeType, tmpLength, addSlashesToValues, maxFileSize);
}
else
{
addFormFile(env, files, filename, tmpName,
mimeType, tmpLength, addSlashesToValues, maxFileSize);
}
}
}
}
public static void generate(PrintWriter @out, ArrayValue array)
{
int size = array.getSize();
int bins = size / MAX_SIZE;
if (size % MAX_SIZE > 0)
{
bins++;
}
int bin = 0;
Value [] keys = array.keysToArray();
Value [] values = array.valuesToArray();
@out.print("new ArrayValueComponent[] {");
while (bin < bins)
{
int binSize = MAX_SIZE;
if (bin != 0)
{
@out.print(", ");
}
if (bin + 1 == bins)
{
binSize = size - bin * MAX_SIZE;
}
@out.println("new ArrayValueComponent() {");
@out.println(" public void init() {");
@out.print(" _keys = new Value[] {");
for (int i = 0; i < binSize; i++)
{
if (i != 0)
{
@out.print(", ");
}
keys[i + bin * MAX_SIZE].generate(out);
}
@out.println("};");
@out.print(" _values = new Value[] {");
for (int i = 0; i < binSize; i++)
{
if (i != 0)
{
@out.print(", ");
}
values[i + bin * MAX_SIZE].generate(out);
}
@out.println("};");
@out.println(" }");
@out.println(" }");
bin++;
}
@out.print("}");
}
/// <summary cref="IValueVisitor.Visit(ArrayValue)"/> public void Visit(ArrayValue value) => throw new InvalidCodeGenerationException();
/**
* Splices.
*/
public ArrayValue splice(int start, int end, ArrayValue replace)
{
return(getCopyArray().splice(start, end, replace));
}
public override bool CompareArrayToString(ArrayValue <StringValue> itemValue, StringValue value)
{
return(itemValue.Values.Any(x => x.Equals(value)));
}
internal ArrayValueListValue(ArrayValue array)
{
this.Array = array;
}
/// <summary>
/// Populates the a .NET object with the specified value node
/// </summary>
/// <param name="obj"></param>
/// <param name="node"></param>
public void Deserialise(object obj, ValueNode node)
{
// Sanity check
if (obj == null)
{
return;
}
Type t = obj.GetType();
// Is it a map type?
if (typeof(IDictionary).IsAssignableFrom(t) && node is MapValue)
{
IDictionary dict = obj as IDictionary;
MapValue mapVal = node.As <MapValue>();
// Is it a generic dict?
if (TranslateOptions.IsGenericType(typeof(IDictionary <,>), t))
{
Type[] genArgs = t.GetGenericArguments();
if (genArgs[0] != typeof(string))
{
return; // TODO: Throw error?
}
foreach (var pair in mapVal)
{
object val;
if (translateOpts.Deserialise(genArgs[1], pair.Value, out val))
{
dict[pair.Key] = val;
}
}
}
else
{
foreach (var pair in mapVal)
{
object val;
if (translateOpts.Deserialise(null, pair.Value, out val))
{
dict.Add(pair.Key, val);
}
}
}
}
// Is it an array type?
else if (t.IsArray)
{
Array arr = obj as Array;
ArrayValue arrVal = node.As <ArrayValue>();
Type elementType = t.GetElementType();
for (int i = 0; i < Math.Min(arrVal.Count, arr.Length); i++)
{
object val;
translateOpts.Deserialise(elementType == typeof(object) ? null : elementType, arrVal[i], out val);
arr.SetValue(val, i);
}
}
else if (typeof(IList).IsAssignableFrom(t))
{
var list = obj as IList;
ArrayValue arrVal = node.As <ArrayValue>();
list.Clear();
// Is it a generic list?
if (TranslateOptions.IsGenericType(typeof(IList <>), t))
{
Type elementType = t.GetGenericArguments()[0];
for (int i = 0; i < arrVal.Count; i++)
{
object val;
translateOpts.Deserialise(elementType == typeof(object) ? null : elementType, arrVal[i], out val);
list.Add(val);
}
}
else
{
for (int i = 0; i < arrVal.Count; i++)
{
object val;
translateOpts.Deserialise(null, arrVal[i], out val);
list.Add(val);
}
}
}
else if (typeof(ICollection).IsAssignableFrom(t))
{
throw new NotImplementedException("Can't deserialise into an ICollection");
}
MapValue mapValue = node as MapValue;
if (mapValue == null)
{
return; // Throw error?
}
foreach (var pair in mapValue)
{
MemberInfo member = t.GetMember(pair.Key, BindingFlags.Public | BindingFlags.Instance)
.Where(m => m is FieldInfo || m is PropertyInfo)
.SingleOrDefault();
if (member != null)
{
FieldInfo fieldInfo = member as FieldInfo;
if (fieldInfo != null)
{
object val;
translateOpts.Deserialise(fieldInfo.FieldType, pair.Value, out val);
if ((val == null && !fieldInfo.FieldType.IsValueType) || fieldInfo.FieldType.IsAssignableFrom(val.GetType()))
{
fieldInfo.SetValue(obj, val);
}
}
PropertyInfo propertyInfo = member as PropertyInfo;
if (propertyInfo != null)
{
object val;
translateOpts.Deserialise(propertyInfo.PropertyType, pair.Value, out val);
if ((val == null && !propertyInfo.PropertyType.IsValueType) || propertyInfo.PropertyType.IsAssignableFrom(val.GetType()))
{
propertyInfo.SetValue(obj, val, null);
}
}
}
}
}
public bool ContainsIndex(ArrayValue array, string index)
{
this.log.AppendLine($"Array.ContainsIndex(array: '{array.ToDisplayString()}', index: '{index}')");
return(false);
}
public void It_Should_Remove_The_Upper_For_Limit()
{
// Arrange
const string templateString = "Result : {% for item in array%}<li>{{ item }}</li>{% endfor %}";
ITemplateContext ctx = new TemplateContext()
.WithNoForLimit();
var list = new ArrayValue(
Enumerable.Range(1, 100)
.Select(NumericValue.Create)
.Cast<IExpressionConstant>().ToList());
ctx.DefineLocalVariable("array", list);
var template = LiquidTemplate.Create(templateString);
// Act
String result = template.Render(ctx);
// Assert
Assert.That(result, Is.StringContaining("<li>100</li>"));
}
public bool ContainsValue(ArrayValue array, string value)
{
this.log.AppendLine($"Array.ContainsValue(array: '{array.ToDisplayString()}', value: '{value}')");
return(false);
}
public void It_Should_Return_The_Same_Object_If_Src_And_Dest_Are_The_Same()
{
// Arrange
var original = new ArrayValue(new List<IExpressionConstant>{NumericValue.Create(123.4m), NumericValue.Create(5)});
// Act
var result = ValueCaster.Cast<ArrayValue, ArrayValue>(original).SuccessValue<ArrayValue>();
// Assert
Assert.That(result, Is.EqualTo(original));
}
public static void addFormValue(Env env,
ArrayValue array,
string key,
Value formValue,
string [] formValueList,
bool addSlashesToValues,
bool isReplaceSpacesWithUnderscores)
{
int p = -1;
int q = -1;
if (key != null)
{
p = key.indexOf('[');
q = key.indexOf(']', p);
}
if (p >= 0 && p < q)
{
if (p == 0)
{
// php/080e
return;
}
int keyStart = 0;
int keyEnd = p;
while (p > 0 && p < q)
{
string currentKey = key.substring(keyStart, keyEnd);
if (keyStart == 0)
{
// php/081p
currentKey = currentKey.replace('.', '_');
}
if (isReplaceSpacesWithUnderscores)
{
// php/080h
currentKey = currentKey.replace(' ', '_');
// php/080k
isReplaceSpacesWithUnderscores = false;
}
StringValue currentKeyValue = env.createString(currentKey);
Value currentArray = array.get(currentKeyValue);
if (!currentArray.isArray())
{
currentArray = new ArrayValueImpl();
}
if (currentKeyValue.length() == 0)
{
array.append(currentArray);
}
else
{
array.put(currentKeyValue, currentArray);
}
array = currentArray.toArrayValue(env);
keyStart = p + 1;
keyEnd = q;
p = key.indexOf('[', q + 1);
q = key.indexOf(']', p + 1);
}
if (keyEnd > 0)
{
key = key.substring(keyStart, keyEnd);
}
else
{
key = key.substring(keyStart);
}
if (isReplaceSpacesWithUnderscores)
{
// php/080h
key = key.replace(' ', '_');
}
if (key.length() == 0)
{
if (formValueList != null)
{
for (int i = 0; i < formValueList.length; i++)
{
Value value;
if (formValueList[i] != null)
{
value = env.createString(formValueList[i]);
}
else
{
value = NullValue.NULL;
}
put(array, null, value, addSlashesToValues);
}
}
else
{
array.put(formValue);
}
}
else if ('0' <= key[0] && key[0] <= '9')
{
put(array,
LongValue.create(StringValue.toLong(key)),
formValue,
addSlashesToValues);
}
else
{
put(array, env.createString(key), formValue, addSlashesToValues);
}
}
else
{
if (key != null)
{
key = key.replace('.', '_');
if (isReplaceSpacesWithUnderscores)
{
// php/080h
key = key.replace(' ', '_');
}
put(array, env.createString(key), formValue, addSlashesToValues);
}
else
{
put(array, null, formValue, addSlashesToValues);
}
}
}
