public static int crypto_sign_keypair(
byte *pk,
byte *sk)
{
return(_is32bits
? X86.crypto_sign_keypair(pk, sk)
: X64.crypto_sign_keypair(pk, sk));
}
public static int crypto_sign_update(void * /* crypto_sign_state */ state,
byte *m,
ulong mlen)
{
return(_is32bits ?
X86.crypto_sign_update(state, m, mlen) :
X64.crypto_sign_update(state, m, mlen));
}
public static int crypto_generichash_init(void * /* crypto_generichash_state */ state,
byte *key,
UIntPtr keylen,
UIntPtr outlen)
{
return(_is32bits ?
X86.crypto_generichash_init(state, key, keylen, outlen) :
X64.crypto_generichash_init(state, key, keylen, outlen));
}
public static int crypto_sign_final_create(void * /* crypto_generichash_state */ state,
byte *sig,
ulong *siglen_p,
byte *sk)
{
return(_is32bits ?
X86.crypto_sign_final_create(state, sig, siglen_p, sk) :
X64.crypto_sign_final_create(state, sig, siglen_p, sk));
}
public static int crypto_generichash_final(
void * /* crypto_generichash_state */ state,
byte * @out,
UIntPtr outlen)
{
return(_is32bits ?
X86.crypto_generichash_final(state, @out, outlen) :
X64.crypto_generichash_final(state, @out, outlen));
}
public static int crypto_generichash_update(
void * /* crypto_generichash_state */ state,
byte * @in,
ulong inlen)
{
return(_is32bits ?
X86.crypto_generichash_update(state, @in, inlen) :
X64.crypto_generichash_update(state, @in, inlen));
}
public static int sodium_memcmp(
byte *b1,
byte *b2,
UIntPtr len)
{
return(_is32bits ?
X86.sodium_memcmp(b1, b2, len) :
X64.sodium_memcmp(b1, b2, len));
}
public static int crypto_box_seal(
byte *b,
byte *b1,
ulong mlen,
byte *pk)
{
return(_is32bits
? X86.crypto_box_seal(b, b1, mlen, pk)
: X64.crypto_box_seal(b, b1, mlen, pk));
}
public static int crypto_sign_verify_detached(
byte *sig,
byte *m,
ulong mlen,
byte *pk)
{
return(_is32bits
? X86.crypto_sign_verify_detached(sig, m, mlen, pk)
: X64.crypto_sign_verify_detached(sig, m, mlen, pk));
}
public static void ass_set_margins(IntPtr renderer, int top, int bottom, int left, int right)
{
if (Is64Bit)
{
X64.ass_set_margins(renderer, top, bottom, left, right);
}
else
{
X86.ass_set_margins(renderer, top, bottom, left, right);
}
}
public static void ass_set_message_cb(IntPtr library, IntPtr callback, IntPtr userData)
{
if (Is64Bit)
{
X64.ass_set_message_cb(library, callback, userData);
}
else
{
X86.ass_set_message_cb(library, callback, userData);
}
}
public static void ass_process_force_style(IntPtr track)
{
if (Is64Bit)
{
X64.ass_process_force_style(track);
}
else
{
X86.ass_process_force_style(track);
}
}
public static int ass_library_version()
{
if (Is64Bit)
{
return(X64.ass_library_version());
}
else
{
return(X86.ass_library_version());
}
}
public static void ass_set_use_margins(IntPtr renderer, bool use)
{
if (Is64Bit)
{
X64.ass_set_use_margins(renderer, use);
}
else
{
X86.ass_set_use_margins(renderer, use);
}
}
public static IntPtr ass_library_init()
{
if (Is64Bit)
{
return(X64.ass_library_init());
}
else
{
return(X86.ass_library_init());
}
}
public static void ass_set_hinting(IntPtr renderer, Hinting hinting)
{
if (Is64Bit)
{
X64.ass_set_hinting(renderer, hinting);
}
else
{
X86.ass_set_hinting(renderer, hinting);
}
}
public static IntPtr ass_library_done(IntPtr library)
{
if (Is64Bit)
{
return(X64.ass_library_done(library));
}
else
{
return(X86.ass_library_done(library));
}
}
public static void ass_set_pixel_aspect(IntPtr renderer, double pixelAspectRatio)
{
if (Is64Bit)
{
X64.ass_set_pixel_aspect(renderer, pixelAspectRatio);
}
else
{
X86.ass_set_pixel_aspect(renderer, pixelAspectRatio);
}
}
public static void ass_set_aspect_ratio(IntPtr renderer, double displayAspectRatio, double storageAspectRatio)
{
if (Is64Bit)
{
X64.ass_set_aspect_ratio(renderer, displayAspectRatio, storageAspectRatio);
}
else
{
X86.ass_set_aspect_ratio(renderer, displayAspectRatio, storageAspectRatio);
}
}
public static void ass_set_line_position(IntPtr renderer, double linePosition)
{
if (Is64Bit)
{
X64.ass_set_line_position(renderer, linePosition);
}
else
{
X86.ass_set_line_position(renderer, linePosition);
}
}
public static void ass_set_line_spacing(IntPtr renderer, double lineSpacing)
{
if (Is64Bit)
{
X64.ass_set_line_spacing(renderer, lineSpacing);
}
else
{
X86.ass_set_line_spacing(renderer, lineSpacing);
}
}
public static int crypto_kdf_derive_from_key(
byte *subkey,
UIntPtr subkeylen,
ulong subkeyid,
byte *ctx,
byte *key)
{
return(_is32bits
? X86.crypto_kdf_derive_from_key(subkey, subkeylen, subkeyid, ctx, key)
: X64.crypto_kdf_derive_from_key(subkey, subkeylen, subkeyid, ctx, key));
}
public static void ass_set_fonts_dir(IntPtr library, [CanBeNull] string fontsDir)
{
if (Is64Bit)
{
X64.ass_set_fonts_dir(library, fontsDir);
}
else
{
X86.ass_set_fonts_dir(library, fontsDir);
}
}
public static void ass_get_available_font_providers(IntPtr library, out IntPtr providers, out UIntPtr size)
{
if (Is64Bit)
{
X64.ass_get_available_font_providers(library, out providers, out size);
}
else
{
X86.ass_get_available_font_providers(library, out providers, out size);
}
}
public static void ass_set_font_scale(IntPtr renderer, double fontScale)
{
if (Is64Bit)
{
X64.ass_set_font_scale(renderer, fontScale);
}
else
{
X86.ass_set_font_scale(renderer, fontScale);
}
}
public static int crypto_sign_detached(
byte *sig,
ulong *siglen,
byte *m,
ulong mlen,
byte *sk)
{
return(_is32bits
? X86.crypto_sign_detached(sig, siglen, m, mlen, sk)
: X64.crypto_sign_detached(sig, siglen, m, mlen, sk));
}
public static void ass_set_fonts(IntPtr renderer, [CanBeNull] string defaultFont, [CanBeNull] string defaultFamily, DefaultFontProvider fontProvider, [CanBeNull] string config, bool update)
{
if (Is64Bit)
{
X64.ass_set_fonts(renderer, defaultFont, defaultFamily, fontProvider, config, update);
}
else
{
X86.ass_set_fonts(renderer, defaultFont, defaultFamily, fontProvider, config, update);
}
}
public static void ass_set_selective_style_override_enabled(IntPtr renderer, OverrideBits bits)
{
if (Is64Bit)
{
X64.ass_set_selective_style_override_enabled(renderer, bits);
}
else
{
X86.ass_set_selective_style_override_enabled(renderer, bits);
}
}
public static void ass_set_extract_fonts(IntPtr library, bool extract)
{
if (Is64Bit)
{
X64.ass_set_extract_fonts(library, extract);
}
else
{
X86.ass_set_extract_fonts(library, extract);
}
}
public static void ass_set_style_overrides(IntPtr library, IntPtr list)
{
if (Is64Bit)
{
X64.ass_set_style_overrides(library, list);
}
else
{
X86.ass_set_style_overrides(library, list);
}
}
internal void GetContext(uint flags, out X86.CONTEXT context) => process.service.GetThreadContext(id, flags, out context);
public void GetThreadContext(int id, uint flags, out X86.CONTEXT context)
{
context = default(X86.CONTEXT);
IntPtr handle;
if (!threadIDsToHandles.TryGetValue(id, out handle))
throw new InvalidOperationException();
context.ContextFlags = flags;
CheckWin32(Kernel32.GetThreadContext(handle, ref context));
}
protected void Ldsflda(MethodInfo aMethod, X86.IL.FieldInfo aFieldInfo)
{
X86.IL.Ldsflda.DoExecute(Assembler, aMethod, DataMember.GetStaticFieldName(aFieldInfo.Field), aMethod.MethodBase.DeclaringType, null);
}
protected void Ldflda(MethodInfo aMethod, X86.IL.FieldInfo aFieldInfo)
{
X86.IL.Ldflda.DoExecute(Assembler, aMethod, aMethod.MethodBase.DeclaringType, aFieldInfo, false, false);
}
private static string GetNameForField(X86.IL.FieldInfo inf) {
// First we need to separate out the
// actual name of field from the type of the field.
int loc = inf.Id.IndexOf(' ');
if (loc >= 0) {
string fName = inf.Id.Substring(loc, inf.Id.Length - loc);
return inf.DeclaringType.AssemblyQualifiedName + fName;
} else {
return inf.Id;
}
}
public static extern BOOL GetThreadContext(HANDLE hThread, ref X86.CONTEXT lpContext);
