public override void Execute(ParserStateValues state, string trimmedLine)
{
if (trimmedLine.StartsWith(".class", StringComparison.Ordinal))
{
state.State = ParserState.ClassDeclaration;
state.AddLine = true;
state.ClassDeclaration = trimmedLine;
}
else if (trimmedLine.StartsWith(".method", StringComparison.Ordinal))
{
ExportedClass exportedClass;
if (state.ClassNames.Count == 0 || !this.Parser.Exports.ClassesByName.TryGetValue(state.ClassNames.Peek(), out exportedClass))
{
return;
}
state.Method.Reset();
state.Method.Declaration = trimmedLine;
state.AddLine = false;
state.State = ParserState.MethodDeclaration;
}
else
{
if (!trimmedLine.StartsWith("} // end of class", StringComparison.Ordinal))
{
return;
}
state.ClassNames.Pop();
state.State = state.ClassNames.Count > 0 ? ParserState.Class : ParserState.Normal;
}
}
private string ExtractPinvokeimpl(ParserStateValues state)
{
string data = state?.Method?.Result;
if (String.IsNullOrWhiteSpace(data))
{
return(null);
}
const string sign = "pinvokeimpl";
int op = data.IndexOf(sign, StringComparison.InvariantCulture);
if (op == -1)
{
return(null);
}
int ed = data.IndexOf(')', op);
if (ed == -1)
{
throw new MissingMethodException($"Failed {sign} signature.");
}
return(data.Substring(op, ed - op + 1));
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (trimmedLine.StartsWith(".corflags", StringComparison.Ordinal))
{
state.Result.Add(string.Format((IFormatProvider)CultureInfo.InvariantCulture, ".corflags 0x{0}", new object[1]
{
(object)Utilities.GetCoreFlagsForPlatform(state.Cpu).ToString("X8", (IFormatProvider)CultureInfo.InvariantCulture)
}));
state.AddLine = false;
}
else if (trimmedLine.StartsWith(".class", StringComparison.Ordinal))
{
state.State = ParserState.ClassDeclaration;
state.AddLine = true;
state.ClassDeclaration = trimmedLine;
}
else
{
string assemblyName;
string aliasName;
if (!this.IsExternalAssemblyReference(trimmedLine, out assemblyName, out aliasName))
{
return;
}
state.RegisterMsCorelibAlias(assemblyName, aliasName);
}
}
private bool TreatIL(ParserStateValues state, ref string raw)
{
if ((Parser.InputValues.Patches & PatchesType.InfToken) == PatchesType.InfToken)
{
// ldc.r8 inf
// ldc.r8 -inf
// ldc.r4 inf
// ldc.r4 -inf
Match m = Regex.Match
(
raw,
@"
ldc.r(?:(?'x64'8)|4)
\s*
(?'sign'-?)
inf
",
RegexOptions.IgnorePatternWhitespace
);
if (m.Success)
{
raw = new string(' ', 4) + raw.Substring(0, m.Index) + GetFloatDef(m);
return(true);
}
}
return(false);
}
private static string GetClassName(ParserStateValues state)
{
bool hadClassName = false;
StringBuilder classNameBuilder = new StringBuilder(state.ClassDeclaration.Length);
IlParsingUtils.ParseIlSnippet(state.ClassDeclaration, ParsingDirection.Forward, (Func <IlParsingUtils.IlSnippetLocation, bool>)(s =>
{
if (s.WithinString)
{
hadClassName = true;
if (s.CurrentChar != '\'')
{
classNameBuilder.Append(s.CurrentChar);
}
}
else if (hadClassName)
{
if (s.CurrentChar == '.' || s.CurrentChar == '/')
{
classNameBuilder.Append(s.CurrentChar);
}
else if (s.CurrentChar != '\'')
{
return(false);
}
}
return(true);
}), (Action <IlParsingUtils.IlSnippetFinalizaton>)null);
return(classNameBuilder.ToString());
}
/// <param name="state"></param>
/// <param name="raw">raw definition of the .field</param>
/// <returns>true if processed</returns>
private bool TreatField(ParserStateValues state, ref string raw)
{
if ((Parser.InputValues.Patches & PatchesType.InfToken) == PatchesType.InfToken)
{
// .field public static literal float32 'Infinity' = float32(inf)
// .field public static literal float32 'NegativeInfinity' = float32(-inf)
// .field public static literal float64 'Infinity' = float64(inf)
// .field public static literal float64 'NegativeInfinity' = float64(-inf)
Match m = Regex.Match
(
raw,
@"=\s*
float(?:(?'x64'64)|32)
\(
(?'sign'-?)
inf
\)
",
RegexOptions.IgnorePatternWhitespace
);
if (m.Success)
{
raw = new string(' ', 2) + raw.Substring(0, m.Index) + GetFloatDef(m);
return(true);
}
}
return(false);
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (!trimmedLine.StartsWith("} // end of method", StringComparison.Ordinal))
{
return;
}
state.State = ParserState.Class;
}
private bool GetIsExport(ParserStateValues state, out ExportedClass exportedClass)
{
if (!this.ExtractMethodParts(state))
{
exportedClass = (ExportedClass)null;
return(false);
}
bool flag1 = this.Exports.ClassesByName.TryGetValue(state.ClassNames.Peek(), out exportedClass) && exportedClass != null;
List <ExportedMethod> exportedMethodList1 = (List <ExportedMethod>)null;
if (flag1 && exportedClass.HasGenericContext)
{
if (exportedClass.MethodsByName.TryGetValue(state.Method.Name, out exportedMethodList1))
{
exportedMethodList1.ForEach((Action <ExportedMethod>)(method => this.Notify(2, DllExportLogginCodes.ExportInGenericType, Resources.The_type_1_cannot_export_the_method_2_as_0_because_it_is_generic_or_is_nested_within_a_generic_type, (object)method.ExportName, (object)method.ExportedClass.FullTypeName, (object)method.MemberName)));
}
return(false);
}
bool flag2 = flag1 && exportedClass.MethodsByName.TryGetValue(state.Method.Name, out exportedMethodList1);
if (flag1 && !flag2)
{
ExportedMethod duplicateExport = this.Exports.GetDuplicateExport(exportedClass.FullTypeName, state.Method.Name);
this.ValidateExportNameAndLogError(duplicateExport, state);
if (duplicateExport != null)
{
this.Notify(state, 1, DllExportLogginCodes.AmbigiguousExportName, Resources.Ambiguous_export_name_0_on_1_2_, (object)duplicateExport.ExportName, (object)duplicateExport.ExportedClass.FullTypeName, (object)duplicateExport.MemberName);
}
}
else
{
List <ExportedMethod> exportedMethodList2;
if ((exportedMethodList2 = exportedMethodList1 ?? exportedClass.NullSafeCall <ExportedClass, List <ExportedMethod> >((Func <ExportedClass, List <ExportedMethod> >)(i => i.Methods))) != null)
{
foreach (ExportedMethod exportedMethod in exportedMethodList2)
{
if (!exportedMethod.IsStatic)
{
flag2 = false;
this.Notify(state, 2, DllExportLogginCodes.MethodIsNotStatic, Resources.The_method_1_2_is_not_static_export_name_0_, (object)exportedMethod.ExportName, (object)exportedMethod.ExportedClass.FullTypeName, (object)exportedMethod.MemberName);
}
if (exportedMethod.IsGeneric)
{
flag2 = false;
this.Notify(state, 2, DllExportLogginCodes.ExportOnGenericMethod, Resources.The_method_1_2_is_generic_export_name_0_Generic_methods_cannot_be_exported_, (object)exportedMethod.ExportName, (object)exportedMethod.ExportedClass.FullTypeName, (object)exportedMethod.MemberName);
}
}
}
}
return(flag2);
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (trimmedLine.StartsWith(".custom", StringComparison.Ordinal) || trimmedLine.StartsWith("// Code", StringComparison.Ordinal))
{
ExportedClass exportedClass;
if (this.Exports.ClassesByName.TryGetValue(state.ClassNames.Peek(), out exportedClass))
{
ExportedMethod exportMethod = exportedClass.MethodsByName[state.Method.Name][0];
string declaration = state.Method.Declaration;
StringBuilder stringBuilder = new StringBuilder(250);
stringBuilder.Append(".method ").Append(state.Method.Attributes.NullSafeTrim()).Append(" ");
stringBuilder.Append(state.Method.Result.NullSafeTrim());
stringBuilder.Append(" modopt(['mscorlib']'").Append(AssemblyExports.ConventionTypeNames[exportMethod.CallingConvention]).Append("') ");
if (!string.IsNullOrEmpty(state.Method.ResultAttributes))
{
stringBuilder.Append(" ").Append(state.Method.ResultAttributes);
}
stringBuilder.Append(" '").Append(state.Method.Name).Append("'").Append(state.Method.After.NullSafeTrim());
bool flag = this.ValidateExportNameAndLogError(exportMethod, state);
if (flag)
{
state.Method.Declaration = stringBuilder.ToString();
}
if (state.MethodPos != 0)
{
state.Result.Insert(state.MethodPos, state.Method.Declaration);
}
if (flag)
{
this.Notifier.Notify(-2, DllExportLogginCodes.OldDeclaration, "\t" + Resources.OldDeclaration_0_, (object)declaration);
this.Notifier.Notify(-2, DllExportLogginCodes.NewDeclaration, "\t" + Resources.NewDeclaration_0_, (object)state.Method.Declaration);
state.Result.Add(string.Format((IFormatProvider)CultureInfo.InvariantCulture, " .export [{0}] as '{1}'", new object[2]
{
(object)exportMethod.VTableOffset,
(object)exportMethod.ExportName
}));
this.Notifier.Notify(-1, DllExportLogginCodes.AddingVtEntry, "\t" + Resources.AddingVtEntry_0_export_1_, (object)exportMethod.VTableOffset, (object)exportMethod.ExportName);
}
}
else
{
state.AddLine = false;
}
state.State = ParserState.Method;
}
else
{
state.AddLine = false;
}
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (state.Method.Pinvokeimpl != null && trimmedLine == "}")
{
state.State = ParserState.Class;
return;
}
if (trimmedLine.StartsWith("} // end of method", StringComparison.Ordinal))
{
state.State = ParserState.Class;
return;
}
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (trimmedLine.StartsWith("{"))
{
state.State = ParserState.Class;
string str = ClassDeclarationParserAction.GetClassName(state);
if (state.ClassNames.Count > 0)
{
str = state.ClassNames.Peek() + "/" + str;
}
state.ClassNames.Push(str);
}
else
{
state.ClassDeclaration = state.ClassDeclaration + " " + trimmedLine;
state.AddLine = true;
}
}
private bool ExtractMethodParts(ParserStateValues state)
{
string methodName;
string afterMethodName;
string foundResult;
string foundResultModifier;
string foundMethodAttributes;
if (!this.GetPartBeforeParameters(state.Method.Declaration, out methodName, out afterMethodName, out foundResult, out foundResultModifier, out foundMethodAttributes))
{
return(false);
}
state.Method.After = afterMethodName;
state.Method.Name = methodName;
state.Method.Attributes = foundMethodAttributes;
state.Method.Result = foundResult;
state.Method.ResultAttributes = foundResultModifier;
return(true);
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (trimmedLine.StartsWith(".custom instance void ", StringComparison.Ordinal) && trimmedLine.Contains(this.Parser.DllExportAttributeIlAsmFullName))
{
state.AddLine = false;
state.State = ParserState.DeleteExportAttribute;
this.Notifier.Notify(-2, DllExportLogginCodes.RemovingDllExportAttribute, Resources.Removing_0_from_1_, (object)Utilities.DllExportAttributeFullName, (object)(state.ClassNames.Peek() + "." + state.Method.Name));
}
else
{
if (!trimmedLine.StartsWith("// Code", StringComparison.Ordinal))
{
return;
}
state.State = ParserState.Method;
if (state.MethodPos == 0)
{
return;
}
state.Result.Insert(state.MethodPos, state.Method.Declaration);
}
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (trimmedLine.StartsWith(".class", StringComparison.Ordinal))
{
state.State = ParserState.ClassDeclaration;
state.AddLine = true;
state.ClassDeclaration = trimmedLine;
}
else if (trimmedLine.StartsWith(".method", StringComparison.Ordinal))
{
if (state.ClassNames.Count == 0 || !Parser.Exports.ClassesByName.TryGetValue(state.ClassNames.Peek(), out _))
{
state.State = ParserState.Method; // https://github.com/3F/DllExport/issues/174
return;
}
state.Method.Reset();
state.Method.Declaration = trimmedLine;
state.AddLine = false;
state.State = ParserState.MethodDeclaration;
}
else if (trimmedLine.StartsWith(".field", StringComparison.Ordinal))
{
if (TreatField(state, ref trimmedLine))
{
state.AddLine = false;
state.Result.Add(trimmedLine);
}
return;
}
else
{
if (!trimmedLine.StartsWith("} // end of class", StringComparison.Ordinal))
{
return;
}
state.ClassNames.Pop();
state.State = state.ClassNames.Count > 0 ? ParserState.Class : ParserState.Normal;
}
}
private bool ExtractMethodParts(ParserStateValues state)
{
if (!GetPartBeforeParameters
(
state.Method.Declaration,
out string name,
out string afterName,
out string result,
out string resultAttrs,
out string attributes
))
{
return(false);
}
state.Method.Name = name;
state.Method.After = afterName;
state.Method.Attributes = attributes;
state.Method.Result = result;
state.Method.ResultAttributes = resultAttrs;
state.Method.Pinvokeimpl = ExtractPinvokeimpl(state);
return(true);
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (state.Method.Pinvokeimpl != null && trimmedLine == "}")
{
state.State = ParserState.Class;
return;
}
if (trimmedLine.StartsWith("} // end of method", StringComparison.Ordinal))
{
state.State = ParserState.Class;
return;
}
if (trimmedLine.StartsWith("IL_", StringComparison.Ordinal))
{
if (TreatIL(state, ref trimmedLine))
{
state.AddLine = false;
state.Result.Add(trimmedLine);
}
return;
}
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (trimmedLine.StartsWith("{", StringComparison.Ordinal))
{
ExportedClass exportedClass;
if (this.GetIsExport(state, out exportedClass))
{
this.Notify(-1, DllExportLogginCodes.MethodFound, string.Format(Resources.Found_method_0_1_, (object)exportedClass.FullTypeName, (object)state.Method.Declaration));
state.MethodPos = state.Result.Count;
state.State = ParserState.MethodProperties;
}
else
{
state.Result.Add(state.Method.Declaration);
state.State = ParserState.Method;
state.MethodPos = 0;
}
}
else
{
state.Method.Declaration = state.Method.Declaration + " " + trimmedLine;
state.AddLine = false;
}
}
private ExportedMethod GetExportedMethod(ParserStateValues state, ExportedClass exportedClass)
{
//TODO: see details in NextExportedMethod()
return(exportedClass.NextExportedMethod(state.Method.Name));
}
public override void Execute(ParserStateValues state, string trimmedLine)
{
if (!trimmedLine.StartsWith(".custom", StringComparison.InvariantCulture) && // .custom instance void ['DllExport']'...'.'DllExportAttribute'::.ctor(string) = ( 01 00 06 50 72 69 6E 74 31 00 00 ) // ...Print1..
!trimmedLine.StartsWith(".maxstack", StringComparison.InvariantCulture))
{
state.AddLine = false;
return;
}
state.State = ParserState.Method;
ExportedClass exportedClass;
if (!Exports.ClassesByName.TryGetValue(state.ClassNames.Peek(), out exportedClass))
{
state.AddLine = false;
return;
}
ExportedMethod exportMethod = GetExportedMethod(state, exportedClass);
string declaration = state.Method.Declaration;
StringBuilder stringBuilder = new StringBuilder(250);
stringBuilder.Append(".method ").Append(state.Method.Attributes.NullSafeTrim()).Append(" ");
stringBuilder.Append(state.Method.Result.NullSafeTrim());
stringBuilder.Append(" modopt(['mscorlib']'").Append(AssemblyExports.ConventionTypeNames[exportMethod.CallingConvention]).Append("') ");
if (!String.IsNullOrEmpty(state.Method.ResultAttributes))
{
stringBuilder.Append(" ").Append(state.Method.ResultAttributes);
}
stringBuilder.Append(" '").Append(state.Method.Name).Append("'").Append(state.Method.After.NullSafeTrim());
bool flag = ValidateExportNameAndLogError(exportMethod, state);
if (flag)
{
state.Method.Declaration = stringBuilder.ToString();
}
if (state.MethodPos != 0)
{
state.Result.Insert(state.MethodPos, state.Method.Declaration);
}
if (flag)
{
Notifier.Notify(-2, DllExportLogginCodes.OldDeclaration, "\t" + Resources.OldDeclaration_0_, declaration);
Notifier.Notify(-2, DllExportLogginCodes.NewDeclaration, "\t" + Resources.NewDeclaration_0_, state.Method.Declaration);
state.Result.Add(
String.Format(
CultureInfo.InvariantCulture,
" .export [{0}] as '{1}'",
exportMethod.VTableOffset,
exportMethod.ExportName
)
);
Notifier.Notify(-1, DllExportLogginCodes.AddingVtEntry, "\t" + Resources.AddingVtEntry_0_export_1_, exportMethod.VTableOffset, exportMethod.ExportName);
}
}
