public Construct exec(Target t, Env environment, Construct... args)
throws ConfigRuntimeException {
int x;
int z;
MCWorld w;
if (args.length == 2) {
MCWorld defaultWorld =
environment.GetPlayer() == null ? null : environment.GetPlayer().getWorld();
MCLocation l = ObjectGenerator.GetGenerator().location(args[0], defaultWorld, t);
x = l.getBlockX();
z = l.getBlockZ();
w = l.getWorld();
} else {
x = (int) Static.getInt(args[0]);
z = (int) Static.getInt(args[1]);
if (args.length == 3) {
w = environment.GetPlayer().getWorld();
} else {
w = Static.getServer().getWorld(args[2].val());
}
}
MCBiomeType bt;
try {
bt = MCBiomeType.valueOf(args[args.length - 1].val());
} catch (IllegalArgumentException e) {
throw new ConfigRuntimeException(
"The biome type \"" + args[1].val() + "\" does not exist.",
ExceptionType.FormatException,
t);
}
w.setBiome(x, z, bt);
return new CVoid(t);
}
public MCEntity.Velocity velocity(Construct c, Target t) {
CArray va;
double x, y, z, mag;
x = y = z = mag = 0;
if (c instanceof CArray) {
va = (CArray) c;
if (va.containsKey("x")) {
x = Static.getDouble(va.get("x"), t);
}
if (va.containsKey("y")) {
y = Static.getDouble(va.get("y"), t);
}
if (va.containsKey("z")) {
z = Static.getDouble(va.get("z"), t);
}
if (!va.containsKey("x") && !va.containsKey("y") && !va.containsKey("z")) {
switch ((int) va.size()) {
case 4:
z = Static.getDouble(va.get(3), t);
y = Static.getDouble(va.get(2), t);
x = Static.getDouble(va.get(1), t);
break;
case 3:
z = Static.getDouble(va.get(2), t);
case 2:
y = Static.getDouble(va.get(1), t);
case 1:
x = Static.getDouble(va.get(0), t);
}
}
return new MCEntity.Velocity(mag, x, y, z);
} else {
throw new Exceptions.FormatException("Expected an array but recieved " + c, t);
}
}
/**
* Returns an MCColor given a colorArray, which supports the following three format types (in this
* order of priority) array(r: 0, g: 0, b: 0) array(red: 0, green: 0, blue: 0) array(0, 0, 0)
*
* @param color
* @param t
* @return
*/
public MCColor color(CArray color, Target t) {
int red;
int green;
int blue;
if (color.containsKey("r")) {
red = Static.getInt32(color.get("r"), t);
} else if (color.containsKey("red")) {
red = Static.getInt32(color.get("red"), t);
} else {
red = Static.getInt32(color.get(0), t);
}
if (color.containsKey("g")) {
green = Static.getInt32(color.get("g"), t);
} else if (color.containsKey("green")) {
green = Static.getInt32(color.get("green"), t);
} else {
green = Static.getInt32(color.get(1), t);
}
if (color.containsKey("b")) {
blue = Static.getInt32(color.get("b"), t);
} else if (color.containsKey("blue")) {
blue = Static.getInt32(color.get("blue"), t);
} else {
blue = Static.getInt32(color.get(2), t);
}
return StaticLayer.GetConvertor().GetColor(red, green, blue);
}
public Construct exec(Target t, Env env, Construct... args)
throws CancelCommandException, ConfigRuntimeException {
double x = 0;
double y = 0;
double z = 0;
MCWorld w = null;
String world = null;
if (env.GetPlayer() instanceof MCPlayer) {
w = env.GetPlayer().getWorld();
}
if (args.length == 1 || args.length == 2) {
if (args[0] instanceof CArray) {
MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], w, t);
x = loc.getX();
y = loc.getY();
z = loc.getZ();
world = loc.getWorld().getName();
} else {
throw new ConfigRuntimeException(
"get_block_at expects param 1 to be an array", ExceptionType.CastException, t);
}
if (args.length == 2) {
world = args[1].val();
}
} else if (args.length == 3 || args.length == 4) {
x = Static.getDouble(args[0]);
y = Static.getDouble(args[1]);
z = Static.getDouble(args[2]);
if (args.length == 4) {
world = args[3].val();
}
}
if (world != null) {
w = Static.getServer().getWorld(world);
}
if (w == null) {
throw new ConfigRuntimeException(
"The specified world " + world + " doesn't exist",
ExceptionType.InvalidWorldException,
t);
}
x = java.lang.Math.floor(x);
y = java.lang.Math.floor(y);
z = java.lang.Math.floor(z);
MCBlock b = w.getBlockAt((int) x, (int) y, (int) z);
return new CString(b.getTypeId() + ":" + b.getData(), t);
}
public Construct exec(Target t, Env env, Construct... args)
throws CancelCommandException, ConfigRuntimeException {
double x = 0;
double y = 0;
double z = 0;
MCWorld w = null;
String world = null;
if (env.GetPlayer() instanceof MCPlayer) {
w = env.GetPlayer().getWorld();
}
if (args[0] instanceof CArray && !(args.length == 3)) {
MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], w, t);
x = loc.getX();
z = loc.getZ();
world = loc.getWorld().getName();
if (args.length == 2) {
world = args[1].val();
}
} else if (args.length == 2 || args.length == 3) {
x = Static.getDouble(args[0]);
z = Static.getDouble(args[1]);
if (args.length == 3) {
world = args[2].val();
}
}
if (world != null) {
w = Static.getServer().getWorld(world);
}
if (w == null) {
throw new ConfigRuntimeException(
"The specified world " + world + " doesn't exist",
ExceptionType.InvalidWorldException,
t);
}
x = java.lang.Math.floor(x);
y = java.lang.Math.floor(y) - 1;
z = java.lang.Math.floor(z);
MCBlock b = w.getHighestBlockAt((int) x, (int) z);
return new CArray(t, new CInt(b.getX(), t), new CInt(b.getY(), t), new CInt(b.getZ(), t));
}
public Construct exec(Target t, Env environment, Construct... args)
throws ConfigRuntimeException {
int x;
int z;
MCWorld w;
if (args.length == 1) {
MCWorld defaultWorld =
environment.GetPlayer() == null ? null : environment.GetPlayer().getWorld();
MCLocation l = ObjectGenerator.GetGenerator().location(args[0], defaultWorld, t);
x = l.getBlockX();
z = l.getBlockZ();
w = l.getWorld();
} else {
x = (int) Static.getInt(args[0]);
z = (int) Static.getInt(args[1]);
if (args.length == 2) {
w = environment.GetPlayer().getWorld();
} else {
w = Static.getServer().getWorld(args[2].val());
}
}
MCBiomeType bt = w.getBiome(x, z);
return new CString(bt.name(), t);
}
public Construct exec(Target t, Env environment, Construct... args)
throws ConfigRuntimeException {
MCLocation l;
MCPlayer p;
p = environment.GetPlayer();
MCWorld w = (p != null ? p.getWorld() : null);
l = ObjectGenerator.GetGenerator().location(args[0], w, t);
if (l.getWorld() instanceof CraftWorld) {
CraftWorld cw = (CraftWorld) l.getWorld();
net.minecraft.server.Block.byId[l.getBlock().getTypeId()].dropNaturally(
cw.getHandle(),
l.getBlockX(),
l.getBlockY(),
l.getBlockZ(),
l.getBlock().getData(),
1.0f,
0);
}
l.getBlock().setTypeId(0);
CraftServer cs = (CraftServer) ((BukkitMCServer) Static.getServer()).__Server();
cs.getHandle().a(new Packet0KeepAlive(), 0);
return new CVoid(t);
}
public void run(final List<Variable> vars, Environment myEnv, final MethodScriptComplete done) {
// Some things, such as the label are determined at compile time
this.CurrentEnv = myEnv;
this.CurrentEnv.getEnv(GlobalEnv.class).SetLabel(this.label);
MCCommandSender p = myEnv.getEnv(CommandHelperEnvironment.class).GetCommandSender();
if (!hasBeenCompiled || compilerError) {
Target target = Target.UNKNOWN;
if (left.size() >= 1) {
try {
target = new Target(left.get(0).line_num, left.get(0).file, left.get(0).column);
} catch (NullPointerException e) {
// Oh well, we tried to get more information
}
}
throw new ConfigRuntimeException(
"Unable to run command, script not yet compiled, or a compiler error occured for that command."
+ " To see the compile error, run /reloadaliases",
null,
target);
}
if (p instanceof MCPlayer) {
if (CurrentEnv.getEnv(GlobalEnv.class).GetLabel() != null) {
PermissionsResolver perms = CurrentEnv.getEnv(GlobalEnv.class).GetPermissionsResolver();
String[] groups = CurrentEnv.getEnv(GlobalEnv.class).GetLabel().split("/");
for (String group : groups) {
if (group.startsWith("-")
&& perms.inGroup(((MCPlayer) p).getName(), group.substring(1))) {
// negative permission
throw new ConfigRuntimeException(
"You do not have permission to use that command",
ExceptionType.InsufficientPermissionException,
Target.UNKNOWN);
} else if (perms.inGroup(((MCPlayer) p).getName(), group)) {
// They do have permission.
break;
}
}
}
}
try {
for (ParseTree rootNode : cright) {
for (Construct tempNode : rootNode.getAllData()) {
if (tempNode instanceof Variable) {
if (left_vars == null) {
throw new ConfigRuntimeException(
"$variables may not be used in this context. Only @variables may be.",
null,
tempNode.getTarget());
}
((Variable) tempNode)
.setVal(
new CString(
Static.resolveDollarVar(
left_vars.get(((Variable) tempNode).getName()), vars)
.toString(),
tempNode.getTarget()));
}
}
MethodScriptCompiler.registerAutoIncludes(CurrentEnv, this);
MethodScriptCompiler.execute(rootNode, CurrentEnv, done, this);
}
} catch (ConfigRuntimeException ex) {
// We don't know how to handle this really, so let's pass it up the chain.
throw ex;
} catch (CancelCommandException e) {
// p.sendMessage(e.getMessage());
// The message in the exception is actually empty
} catch (LoopBreakException e) {
if (p != null) {
p.sendMessage("The break() function must be used inside a for() or foreach() loop");
}
System.out.println("The break() function must be used inside a for() or foreach() loop");
} catch (LoopContinueException e) {
if (p != null) {
p.sendMessage("The continue() function must be used inside a for() or foreach() loop");
}
System.out.println("The continue() function must be used inside a for() or foreach() loop");
} catch (FunctionReturnException e) {
if (myEnv.getEnv(CommandHelperEnvironment.class).GetEvent() != null) {
// Oh, we're running in an event handler. Those know how to catch it too.
throw e;
}
if (p != null) {
p.sendMessage("The return() function must be used inside a procedure.");
}
System.out.println("The return() function must be used inside a procedure.");
} catch (Throwable t) {
System.out.println("An unexpected exception occured during the execution of a script.");
t.printStackTrace();
if (p != null) {
p.sendMessage(
"An unexpected exception occured during the execution of your script. Please check the console for more information.");
}
}
if (done != null) {
done.done(null);
}
}
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;
}
}
public Construct exec(Target t, Env env, Construct... args)
throws CancelCommandException, ConfigRuntimeException {
double x = 0;
double y = 0;
double z = 0;
String id = null;
String world = null;
MCWorld w = null;
if (env.GetPlayer() instanceof MCPlayer) {
w = env.GetPlayer().getWorld();
}
if ((args.length == 2 || args.length == 3) && args[0] instanceof CArray) {
MCLocation l =
ObjectGenerator.GetGenerator().location(args[0], env.GetPlayer().getWorld(), t);
x = l.getBlockX();
y = l.getBlockY();
z = l.getBlockZ();
world = l.getWorld().getName();
id = args[1].val();
if (args.length == 3) {
world = args[2].val();
}
} else {
x = Static.getNumber(args[0]);
y = Static.getNumber(args[1]);
z = Static.getNumber(args[2]);
id = args[3].val();
if (args.length == 5) {
world = args[4].val();
}
}
if (world != null) {
w = Static.getServer().getWorld(world);
}
if (w == null) {
throw new ConfigRuntimeException(
"The specified world " + world + " doesn't exist",
ExceptionType.InvalidWorldException,
t);
}
x = java.lang.Math.floor(x);
y = java.lang.Math.floor(y);
z = java.lang.Math.floor(z);
int ix = (int) x;
int iy = (int) y;
int iz = (int) z;
MCBlock b = w.getBlockAt(ix, iy, iz);
StringBuilder data = new StringBuilder();
StringBuilder meta = new StringBuilder();
boolean inMeta = false;
for (int i = 0; i < id.length(); i++) {
Character c = id.charAt(i);
if (!inMeta) {
if (!Character.isDigit(c) && c != ':') {
throw new ConfigRuntimeException(
"id must be formatted as such: 'x:y' where x and y are integers",
ExceptionType.FormatException,
t);
}
if (c == ':') {
inMeta = true;
continue;
}
data.append(c);
} else {
meta.append(c);
}
}
if (meta.length() == 0) {
meta.append("0");
}
int idata = Integer.parseInt(data.toString());
byte imeta = Byte.parseByte(meta.toString());
b.setTypeId(idata);
b.setData(imeta);
return new CVoid(t);
}
/**
* Given a Location Object, returns a MCLocation. If the optional world is not specified in the
* object, the world provided is used instead. Location "objects" are MethodScript arrays that
* represent a location in game. There are 4 usages:
*
* <ul>
* <li>(x, y, z)
* <li>(x, y, z, world)
* <li>(x, y, z, yaw, pitch)
* <li>(x, y, z, world, yaw, pitch)
* </ul>
*
* In all cases, the pitch and yaw default to 0, and the world defaults to the specified world.
* <em>More conveniently: ([world], x, y, z, [yaw, pitch])</em>
*/
public MCLocation location(Construct c, MCWorld w, Target t) {
if (!(c instanceof CArray)) {
throw new ConfigRuntimeException(
"Expecting an array, received " + c.getCType(), ExceptionType.FormatException, t);
}
CArray array = (CArray) c;
MCWorld world = w;
double x = 0;
double y = 0;
double z = 0;
float yaw = 0;
float pitch = 0;
if (!array.inAssociativeMode()) {
if (array.size() == 3) {
// Just the xyz, with default yaw and pitch, and given world
x = Static.getNumber(array.get(0, t), t);
y = Static.getNumber(array.get(1, t), t);
z = Static.getNumber(array.get(2, t), t);
} else if (array.size() == 4) {
// x, y, z, world
x = Static.getNumber(array.get(0, t), t);
y = Static.getNumber(array.get(1, t), t);
z = Static.getNumber(array.get(2, t), t);
world = Static.getServer().getWorld(array.get(3, t).val());
} else if (array.size() == 5) {
// x, y, z, yaw, pitch, with given world
x = Static.getNumber(array.get(0, t), t);
y = Static.getNumber(array.get(1, t), t);
z = Static.getNumber(array.get(2, t), t);
yaw = (float) Static.getNumber(array.get(3, t), t);
pitch = (float) Static.getNumber(array.get(4, t), t);
} else if (array.size() == 6) {
// All have been given
x = Static.getNumber(array.get(0, t), t);
y = Static.getNumber(array.get(1, t), t);
z = Static.getNumber(array.get(2, t), t);
world = Static.getServer().getWorld(array.get(3, t).val());
yaw = (float) Static.getNumber(array.get(4, t), t);
pitch = (float) Static.getNumber(array.get(5, t), t);
} else {
throw new ConfigRuntimeException(
"Expecting a Location array, but the array did not meet the format specifications",
ExceptionType.FormatException,
t);
}
}
if (array.containsKey("x")) {
x = Static.getNumber(array.get("x"), t);
}
if (array.containsKey("y")) {
y = Static.getNumber(array.get("y"), t);
}
if (array.containsKey("z")) {
z = Static.getNumber(array.get("z"), t);
}
if (array.containsKey("world")) {
world = Static.getServer().getWorld(array.get("world").val());
}
if (array.containsKey("yaw")) {
yaw = (float) Static.getDouble(array.get("yaw"), t);
}
if (array.containsKey("pitch")) {
pitch = (float) Static.getDouble(array.get("pitch"), t);
}
// If world is still null at this point, it's an error
if (world == null) {
throw new ConfigRuntimeException(
"The specified world doesn't exist, or no world was provided",
ExceptionType.InvalidWorldException,
t);
}
return StaticLayer.GetLocation(world, x, y, z, yaw, pitch);
}
public MCItemMeta itemMeta(Construct c, int i, Target t) {
MCItemMeta meta =
Static.getServer().getItemFactory().getItemMeta(StaticLayer.GetConvertor().getMaterial(i));
if (c instanceof CNull) {
return meta;
}
CArray ma = null;
if (c instanceof CArray) {
ma = (CArray) c;
try {
if (ma.containsKey("display")) {
Construct dni = ma.get("display");
if (!(dni instanceof CNull)) {
meta.setDisplayName(dni.val());
}
}
if (ma.containsKey("lore")) {
Construct li = ma.get("lore");
if (li instanceof CNull) {
// do nothing
} else if (li instanceof CArray) {
CArray la = (CArray) li;
List<String> ll = new ArrayList<String>();
for (int j = 0; j < la.size(); j++) {
ll.add(la.get(j).val());
}
meta.setLore(ll);
} else {
throw new Exceptions.FormatException("Lore was expected to be an array.", t);
}
}
if (meta instanceof MCLeatherArmorMeta) {
if (ma.containsKey("color")) {
Construct ci = ma.get("color");
if (ci instanceof CNull) {
// nothing
} else if (ci instanceof CArray) {
((MCLeatherArmorMeta) meta).setColor(color((CArray) ci, t));
} else {
throw new Exceptions.FormatException("Color was expected to be an array.", t);
}
}
}
if (meta instanceof MCBookMeta) {
if (ma.containsKey("title")) {
Construct title = ma.get("title");
if (!(title instanceof CNull)) {
((MCBookMeta) meta).setTitle(title.val());
}
}
if (ma.containsKey("author")) {
Construct author = ma.get("author");
if (!(author instanceof CNull)) {
((MCBookMeta) meta).setAuthor(author.val());
}
}
if (ma.containsKey("pages")) {
Construct pages = ma.get("pages");
if (pages instanceof CNull) {
// nothing
} else if (pages instanceof CArray) {
CArray pa = (CArray) pages;
List<String> pl = new ArrayList<String>();
for (int j = 0; j < pa.size(); j++) {
pl.add(pa.get(j).val());
}
((MCBookMeta) meta).setPages(pl);
} else {
throw new Exceptions.FormatException("Pages field was expected to be an array.", t);
}
}
}
if (meta instanceof MCSkullMeta) {
if (ma.containsKey("owner")) {
Construct owner = ma.get("owner");
if (!(owner instanceof CNull)) {
((MCSkullMeta) meta).setOwner(owner.val());
}
}
}
if (meta instanceof MCEnchantmentStorageMeta) {
if (ma.containsKey("stored")) {
Construct stored = ma.get("stored");
if (stored instanceof CNull) {
// Still doing nothing
} else if (stored instanceof CArray) {
for (String index : ((CArray) stored).keySet()) {
try {
CArray earray = (CArray) ((CArray) stored).get(index);
MCEnchantment etype =
StaticLayer.GetConvertor().GetEnchantmentByName(earray.get("etype").val());
int elevel = Static.getInt32(earray.get("elevel"), t);
((MCEnchantmentStorageMeta) meta).addStoredEnchant(etype, elevel, true);
} catch (Exception bade) {
throw new Exceptions.FormatException(
"Could not get enchantment data from index " + index, t);
}
}
} else {
throw new Exceptions.FormatException(
"Stored field was expected to be an array of Enchantment arrays", t);
}
}
}
} catch (Exception ex) {
throw new Exceptions.FormatException(
"Could not get ItemMeta from the given information.", t);
}
} else {
throw new Exceptions.FormatException(
"An array was expected but recieved " + c + " instead.", t);
}
return meta;
}
