public int BeginCall(int funcid, Packers.AbstractPacker packer)
{
int seq = getSeq ();
transport.BeginWrite (seq);
Packers.Int8.pack (CMD_INVOKE, transport);
Packers.Int32.pack (funcid, transport);
replies[seq] = new ReplySlot (packer);
return seq;
}
public void FromConfuserProject(ConfuserProject prj)
{
output = prj.OutputPath;
snKey = prj.SNKeyPath;
seed = prj.Seed;
dbg = prj.Debug;
foreach (var i in prj.Plugins)
{
LoadAssembly(Assembly.LoadFrom(i), false);
}
if (prj.Packer != null)
{
this.packer = new PrjConfig <Packer>(Packers.Single(_ => _.ID == prj.Packer.Id), this);
foreach (var j in prj.Packer.AllKeys)
{
this.packer.Add(new PrjArgument(this)
{
Name = j, Value = prj.Packer[j]
});
}
}
foreach (var i in prj)
{
PrjAssembly asm = new PrjAssembly(this);
asm.FromCrAssembly(this, i);
Assemblies.Add(asm);
}
foreach (var i in prj.Rules)
{
PrjRule rule = new PrjRule(this);
rule.FromCrRule(this, i);
Rules.Add(rule);
}
}
public void LoadAssembly(Assembly asm, bool interact)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Loaded type :");
bool h = false;
foreach (Type type in asm.GetTypes())
{
if (typeof(Core.IConfusion).IsAssignableFrom(type) && type != typeof(Core.IConfusion))
{
Confusions.Add(Activator.CreateInstance(type) as Core.IConfusion);
sb.AppendLine(type.FullName);
h = true;
}
if (typeof(Core.Packer).IsAssignableFrom(type) && type != typeof(Core.Packer))
{
Packers.Add(Activator.CreateInstance(type) as Core.Packer);
sb.AppendLine(type.FullName);
h = true;
}
}
if (!h)
{
sb.AppendLine("NONE!");
}
else
{
Plugins.Add(asm.Location);
Sort();
}
if (interact)
{
MessageBox.Show(sb.ToString(), "Confuser", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
public ReplySlot(Packers.AbstractPacker packer)
{
type = ReplySlotType.SLOT_EMPTY;
value = packer;
}
public FieldInfo(Packers.AbstractPacker keypacker, Packers.AbstractPacker valpacker)
{
this.keypacker = keypacker;
this.valpacker = valpacker;
}
/// <summary>
/// specialized version of Add that attempts to infer the packer for
/// the key, but the packer for the value must be provided
/// </summary>
public void Add(Object key, Object value, Packers.AbstractPacker valpacker)
{
Packers.AbstractPacker keypacker = getPackerForBuiltinType (key);
if (keypacker == null) {
keypacker = getKeyPacker (key);
}
if (keypacker == null) {
throw new ArgumentException ("cannot deduce key packer, use 4-argument Add()");
}
Add (key, keypacker, value, valpacker);
}
/// <summary>
/// Adds the given given value (with the given value-packer) under the
/// given key (with the given key packer)
/// </summary>
/// <param name="key">
/// The key (any object)
/// </param>
/// <param name="keypacker">
/// The packer for the key (an AbstractPacker)
/// </param>
/// <param name="value">
/// The value (any object)
/// </param>
/// <param name="valpacker">
/// The packer for the value (an AbstractPacker)
/// </param>
public void Add(Object key, Packers.AbstractPacker keypacker, Object value, Packers.AbstractPacker valpacker)
{
//System.Console.Error.WriteLine("Add: {0}, {1}, {2}, {3}", key, keypacker, value, valpacker);
if (keypacker == null || valpacker == null) {
throw new ArgumentNullException ("keypacker and valpacker cannot be null");
}
FieldInfo fi = null;
if (fields.TryGetValue (key, out fi)) {
fi.keypacker = keypacker;
fi.valpacker = valpacker;
} else {
fields.Add (key, new FieldInfo (keypacker, valpacker));
}
data.Add (key, value);
}
