public override ArcFile TryOpen(ArcView file)
{
if (!file.View.AsciiEqual(0, "CWS") &&
!file.View.AsciiEqual(0, "FWS"))
{
return(null);
}
bool is_compressed = file.View.ReadByte(0) == 'C';
int version = file.View.ReadByte(3);
using (var reader = new SwfReader(file.CreateStream(), version, is_compressed))
{
var chunks = reader.Parse();
var base_name = Path.GetFileNameWithoutExtension(file.Name);
var dir = chunks.Where(t => t.Length > 2 && TypeMap.ContainsKey(t.Type))
.Select(t => new SwfEntry {
Name = string.Format("{0}#{1:D5}", base_name, t.Id),
Type = GetTypeFromId(t.Type),
Chunk = t,
Offset = 0,
Size = (uint)t.Length
} as Entry).ToList();
SwfSoundEntry current_stream = null;
foreach (var chunk in chunks.Where(t => IsSoundStream(t)))
{
switch (chunk.Type)
{
case Types.SoundStreamHead:
case Types.SoundStreamHead2:
if ((chunk.Data[1] & 0x30) != 0x20) // not mp3 stream
{
current_stream = null;
continue;
}
current_stream = new SwfSoundEntry {
Name = string.Format("{0}#{1:D5}", base_name, chunk.Id),
Type = "audio",
Chunk = chunk,
Offset = 0,
};
dir.Add(current_stream);
break;
case Types.SoundStreamBlock:
if (current_stream != null)
{
current_stream.Size += (uint)(chunk.Data.Length - 4);
current_stream.SoundStream.Add(chunk);
}
break;
}
}
return(new ArcFile(file, this, dir));
}
}
public static void KeysMatch(TypeMap analyzed, TypeMap test)
{
foreach (string key in analyzed.Keys)
{
Assert.IsTrue(TestTypeMaps.P3TypeMap.ContainsKey(key));
}
foreach (string key in TestTypeMaps.P3TypeMap.Keys)
{
Assert.IsTrue(analyzed.ContainsKey(key));
}
}
public string GetCardDesc(int val)
{
var value = val >> Digit;
if (!TypeMap.ContainsKey(value))
{
return("");
}
return(TypeMap[value]);
}
public static IMessage ReadMessage(BinaryReader reader)
{
var typeId = reader.ReadInt32();
if (!TypeMap.ContainsKey(typeId))
{
return(null);
}
var messageType = TypeMap[typeId];
var message = Activator.CreateInstance(messageType) as IMessage;
message.Read(reader);
return(message);
}
private void _populateTypeMaps(NodeProperties props, string key, bool overwrite = false)
{
if (key.Length > KeyLengthLimit)
{
KeyLengthLimitSurpassed = true;
}
if (!TypeMap.ContainsKey(key))
{
props.Name = key;
TypeMap[key] = props;
return;
}
TypeMap[key].Update(props);
}
public string GetTypeFromMap(string type)
{
if (TypeMap == null)
{
InitTypeMap();
}
if (TypeMap.ContainsKey(type))
{
return(TypeMap[type]);
}
else
{
if (ItemTypes.ContainsKey(type))
{
return(ItemTypes[type].Type);
}
}
return("");
}
public static void Set <T>(this RegistryKey key, T value, [CallerMemberName] string name = null)
{
if (value == null)
{
if (name != null && key.GetValue(name) != null)
{
key.DeleteValue(name);
}
return;
}
if (typeof(T) == typeof(bool))
{
key.SetValue(name, (bool)(object)value ? 1 : 0, RegistryValueKind.DWord);
return;
}
if (!TypeMap.ContainsKey(typeof(T)))
{
return;
}
key.SetValue(name, value, TypeMap[typeof(T)]);
}
private static void AddType(Type type)
{
string shortName = type.Name;
if (TypeMap.ContainsKey(shortName))
{
shortName = type.FullName;
if (TypeMap.ContainsKey(shortName))
{
return;
}
}
ShortNames.Add(type, shortName);
TypeMap.Add(shortName, type);
if (!type.IsGenericType)
{
return;
}
GenericTypeMap.Add(shortName.Replace("`1", ""), type);
GenericShortNames.Add(type, shortName.Replace("`1", ""));
}
public bool ContainsType(IType type)
{
return(TypeMap.ContainsKey(type));
}
public bool Exists(Type type) => TypeMap.ContainsKey(type.FullName);
/// <summary>
/// checks if a type is supported via the TypeMap table.
/// </summary>
/// <param name="dataType">type to check</param>
/// <returns></returns>
public static bool IsSupported(Type dataType)
{
return(TypeMap.ContainsKey(Type.GetTypeCode(dataType)));
}
private Type VisitAnonymous(Type type)
{
Debug.Assert(type.IsAnonymousType());
var newType = default(Type);
var getNewCtor = default(Func <NewExpression, Func <Expression, Expression>, Expression>);
var getNewMember = default(Func <MemberExpression, Func <Expression, Expression>, Expression>);
var convertConstant = default(Func <object, Func <object, object>, object>);
var oldCtor = type.GetConstructors().Single();
var oldPars = oldCtor.GetParameters();
var n = oldPars.Length;
if (n == 0)
{
newType = _unit.Type;
getNewCtor = (ne, _) => _unit;
convertConstant = (ce, _) => _unit.Evaluate <object>();
}
else
{
var ctors = new List <ConstructorInfo>();
var props = new Dictionary <MemberInfo, Stack <PropertyInfo> >();
var convp = Expression.Parameter(type);
var convr = Expression.Parameter(typeof(Func <object, object>));
var conve = default(Expression);
var oldProps = type.GetProperties().ToDictionary(p => p.Name, p => p);
var max = ExpressionTupletizer.TupleTypeCount - 2 /* T1..T7 */;
var fst = (n / max) * max;
var rem = n - fst;
if (rem == 0)
{
fst = n - max;
rem = max;
}
for (var i = fst; i >= 0; i -= max)
{
var tupleArgs = default(Type[]);
var constArgs = default(Expression[]);
if (newType == null)
{
tupleArgs = new Type[rem];
constArgs = new Expression[rem];
}
else
{
tupleArgs = new Type[rem + 1];
tupleArgs[rem] = newType;
constArgs = new Expression[rem + 1];
constArgs[rem] = conve;
}
var originalProps = new List <PropertyInfo>(rem);
for (var j = 0; j < rem; j++)
{
var par = oldPars[i + j];
var prop = oldProps[par.Name];
tupleArgs[j] = Visit(par.ParameterType);
originalProps.Add(prop);
}
newType = ExpressionTupletizer.TupleTypes[tupleArgs.Length].MakeGenericType(tupleArgs);
var ctor = newType.GetConstructor(tupleArgs);
ctors.Add(ctor);
if (rem == max)
{
var rest = newType.GetProperty("Rest");
foreach (var kv in props)
{
kv.Value.Push(rest);
}
}
var ctorPars = ctor.GetParameters();
for (var j = 0; j < originalProps.Count; j++)
{
var prop = originalProps[j];
var newProp = new Stack <PropertyInfo>();
var item = newType.GetProperty("Item" + (j + 1));
newProp.Push(item);
props[prop] = newProp;
var member = (Expression)Expression.MakeMemberAccess(convp, prop);
if (TypeMap.ContainsKey(prop.PropertyType))
{
member = Expression.Convert(Expression.Invoke(convr, member), item.PropertyType);
}
else
{
var ctorParameterType = ctorPars[j].ParameterType;
var argType = member.Type;
if (!ctorParameterType.IsAssignableFrom(argType))
{
var cantConvertMsg = string.Format(CultureInfo.InvariantCulture, "Can't convert constant of type '{0}' to '{1}'.", argType, ctorParameterType);
var cantConvertException = Expression.New(InvalidOperationExceptionCtor, Expression.Constant(cantConvertMsg));
member = Expression.Throw(cantConvertException, ctorParameterType);
}
}
constArgs[j] = member;
}
conve = Expression.New(ctor, constArgs);
rem = max;
}
getNewCtor = (ne, visit) =>
{
var res = default(Expression);
var args = ne.Arguments.Select(visit).ToArray();
var k = args.Length;
foreach (var c in ctors)
{
var paras = c.GetParameters();
var m = paras.Length;
var bundle = new Expression[m];
if (res != null)
{
bundle[m - 1] = res;
m--;
}
k -= m;
for (var j = 0; j < m; j++)
{
bundle[j] = args[k + j];
}
res = Expression.New(c, bundle);
}
return(res);
};
getNewMember = (me, visit) =>
{
var expr = visit(me.Expression);
foreach (var p in props[me.Member])
{
expr = Expression.MakeMemberAccess(expr, p);
}
return(expr);
};
var convf = Expression.Lambda(conve, convp, convr);
var convd = default(Delegate);
convertConstant = (cst, visit) =>
{
if (convd == null)
{
convd = convf.Compile();
}
return(convd.DynamicInvoke(cst, visit));
};
}
TypeMap[type] = newType;
ConstructorMap[type] = getNewCtor;
PropertyMap[type] = getNewMember;
ConstantConverters[type] = convertConstant;
return(newType);
}
