public static extern liq_error liq_write_remapped_image(liq_result_ptr res, liq_image_ptr input_image, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, size_t buffer_size);
public unsafe static extern size_t LZ4F_decompress(void* ctx, void* dstBuffer, size_t* dstMaxSize, void* srcBuffer, size_t* srcSize, Lz4DecompressOptions* decompressOptions = null);
public static extern int zmq_setsockopt( IntPtr socket, int option, [In]ref ulong optval, size_t optvallen );
public extern static void dsn_msg_read_commit(dsn_message_t msg, size_t size);
public static extern unsafe size_t LZ4F_compressBegin(void* ctx, void* dstBuffer, size_t dstMaxSize, LZ4Preferences* preferences = null);
extern static IntPtr _lua_pushlstring(lua_State L, String s, size_t len);
public extern static UInt32 dsn_crc32_compute(IntPtr ptr, size_t size, UInt32 init_crc);
public extern static void lua_pushlstring(lua_State L, string s, size_t l);
public extern static IntPtr lua_newuserdata(lua_State L, size_t sz);
public extern static int luaL_loadbuffer(lua_State L, string buff, size_t sz, string name);
public extern static void luaL_addlstring(ref luaL_Buffer B, string s, size_t l);
public extern static string luaL_optlstring(lua_State L, int numArg, string def, ref size_t l);
public extern static string luaL_checklstring(lua_State L, int numArg, ref size_t l);
public static extern void dsn_msg_write_commit(dsn_message_t msg, size_t size);
unsafe static extern struct_pointer_t coco_suite_get_problem(struct_pointer_t suite, size_t problem_index);
extern public static void jpeg_CreateDecompress (ref jpeg_decompress_struct cinfo, Int version, size_t structsize);
extern static IntPtr _lua_tolstring(lua_State L, int idx, out size_t len);
private static node parsetok(tok_state tok, grammar g, int start, perrdetail err_ret, int flags)
{
parser_state ps;
node n;
int started = 0;
if ((ps = PyParser_New(g, start)) == null)
{
fprintf(stderr, "no mem for new parser\n");
err_ret.error = E_NOMEM;
return(null);
}
if (0 != (flags & PyPARSE_YIELD_IS_KEYWORD))
{
ps.p_generators = 1;
}
for (;;)
{
CharPtr a = null, b = null;
int type;
size_t len;
CharPtr str;
type = PyTokenizer_Get(tok, ref a, ref b);
if (type == ERRORTOKEN)
{
err_ret.error = tok.done;
break;
}
if (type == ENDMARKER && 0 != started)
{
type = NEWLINE;
started = 0;
}
else
{
started = 1;
}
len = (size_t)(b - a);
str = PyMem_NEW_char2((int)(len + 1));
if (str == null)
{
fprintf(stderr, "no mem for next token\n");
err_ret.error = E_NOMEM;
break;
}
if (len > 0)
{
strncpy(str, a, (int)len);
}
str[len] = '\0';
if (type == NAME && 0 == ps.p_generators &&
len == 5 && str[0] == 'y' && strcmp(str, "yield") == 0)
{
PySys_WriteStderr(yield_msg,
err_ret.filename == null ?
"<string>" : err_ret.filename,
tok.lineno);
}
if ((err_ret.error =
PyParser_AddToken(ps, (int)type, str, tok.lineno,
ref err_ret.expected)) != E_OK)
{
if (err_ret.error != E_DONE)
{
PyMem_DEL(str);
}
break;
}
}
if (err_ret.error == E_DONE)
{
n = ps.p_tree;
ps.p_tree = null;
}
else
{
n = null;
}
PyParser_Delete(ps);
if (n == null)
{
if (tok.lineno <= 1 && tok.done == E_EOF)
{
err_ret.error = E_EOF;
}
err_ret.lineno = tok.lineno;
err_ret.offset = tok.cur - tok.buf;
if (tok.buf != null)
{
size_t len = (size_t)(tok.inp - tok.buf);
err_ret.text = PyMem_NEW_char2((int)(len + 1));
if (err_ret.text != null)
{
if (len > 0)
{
strncpy(err_ret.text, tok.buf, (int)len);
}
err_ret.text[len] = '\0';
}
}
}
PyTokenizer_Free(tok);
return(n);
}
public extern static IntPtr lua_newuserdata(lua_State L, size_t sz);
public static extern string obs_property_list_item_string(obs_property_t p, size_t idx);
public extern static void dsn_msg_write_next(dsn_message_t msg, out IntPtr ptr, out size_t size, size_t min_size);
public static extern int64_t obs_property_list_item_int(obs_property_t p, size_t idx);
public extern static void dsn_file_task_enqueue(dsn_task_t cb_task, dsn_error_t err, size_t size);
public static extern double obs_property_list_item_float(obs_property_t p, size_t idx);
public unsafe static extern size_t LZ4F_compressUpdate(void* ctx, void* dstBuffer, size_t dstMaxSize, void* srcBuffer, size_t srcSize, Lz4CompressOptions* options = null);
get => LLVMGetModuleInlineAsm(ModuleHandle, out size_t _);
public unsafe static extern sbyte* LZ4F_getErrorName(size_t code);
/// <summary>
/// Creates a variable list of arguments in unmanaged memory.
/// </summary>
/// <param name="args">The list of arguments.</param>
public va_list(params object[] args)
{
va_args = new va_arg[args[args.Length - 1] == null ? args.Length - 1 : args.Length];
for (int j = 0; j < va_args.Length; j++)
{
string name = args[j].GetType().Name;
if (name == "ptr`1")
{
name = name.Replace("`1", "<" + args[j].GetType().GetGenericArguments()[0].Name + ">");
}
va_args[j].arg_offset = args_size;
va_args[j].data_offset = data_size;
switch (name)
{
case "Char":
args_size += 1;
va_args[j].write = (i) => Marshal.WriteByte(arguments, va_args[i].arg_offset, System.Text.Encoding.ASCII.GetBytes(new Char[] { (Char)args[i] })[0]);
break;
case "Byte":
case "SByte":
args_size += 1;
va_args[j].write = (i) => Marshal.WriteByte(arguments, va_args[i].arg_offset, (Byte)args[i]);
break;
case "Int16":
case "UInt16":
args_size += 2;
va_args[j].write = (i) => Marshal.WriteInt16(arguments, va_args[i].arg_offset, (Int16)args[i]);
break;
case "Int32":
case "UInt32":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "Single":
args_size += 8;
va_args[j].write = (i) => Marshal.Copy(BitConverter.GetBytes((Double)(Single)args[i]), 0, (IntPtr)(arguments.ToInt64() + va_args[i].arg_offset), 8);
break;
case "mp_bitcnt_t":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mp_bitcnt_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "mpfr_prec_t":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mpfr_prec_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "mp_size_t":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mp_size_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "mp_exp_t":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mp_exp_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "mpfr_exp_t":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mpfr_exp_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "mpfr_sign_t":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mpfr_sign_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "mpfr_rnd_t":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mpfr_rnd_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "mpfr_kind_t":
args_size += 4;
va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mpfr_kind_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
break;
case "Int64":
case "UInt64":
args_size += 8;
va_args[j].write = (i) => Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)args[i]);
break;
case "Double":
args_size += 8;
va_args[j].write = (i) => Marshal.Copy(BitConverter.GetBytes((Double)args[i]), 0, (IntPtr)(arguments.ToInt64() + va_args[i].arg_offset), 8);
break;
case "IntPtr":
case "UIntPtr":
args_size += IntPtr.Size;
va_args[j].write = (i) => Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, (IntPtr)args[i]);
break;
case "mpz_t":
args_size += IntPtr.Size;
va_args[j].write = (i) => Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, ((mpz_t)args[i]).ToIntPtr());
break;
case "mpq_t":
args_size += IntPtr.Size;
va_args[j].write = (i) => Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, ((mpq_t)args[i]).ToIntPtr());
break;
case "mpf_t":
args_size += IntPtr.Size;
va_args[j].write = (i) => Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, ((mpf_t)args[i]).ToIntPtr());
break;
case "mpfr_t":
args_size += IntPtr.Size;
va_args[j].write = (i) => Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, ((mpfr_t)args[i]).ToIntPtr());
break;
case "mp_ptr":
args_size += IntPtr.Size;
va_args[j].write = (i) => Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, ((mp_ptr)args[i]).ToIntPtr());
break;
case "mp_limb_t":
args_size += IntPtr.Size;
va_args[j].write = (i) =>
{
if (IntPtr.Size == 4)
{
Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(mp_limb_t)args[i]);
}
//Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
else
{
Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)(mp_limb_t)args[i]);
}
//Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)args[i]);
};
break;
case "char_ptr":
args_size += IntPtr.Size;
va_args[j].write = (i) => Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, ((char_ptr)args[i]).ToIntPtr());
break;
case "size_t":
args_size += IntPtr.Size;
va_args[j].write = (i) =>
{
if (IntPtr.Size == 4)
{
Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)(size_t)args[i]);
}
//Marshal.WriteInt32(arguments, va_args[i].arg_offset, (Int32)args[i]);
else
{
Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)(size_t)args[i]);
}
//Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)args[i]);
};
break;
case "intmax_t":
args_size += 8;
va_args[j].write = (i) => Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)(intmax_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)args[i]);
break;
case "uintmax_t":
args_size += 8;
va_args[j].write = (i) => Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)(uintmax_t)args[i]);
//va_args[j].write = (i) => Marshal.WriteInt64(arguments, va_args[i].arg_offset, (Int64)args[i]);
break;
case "String":
args_size += IntPtr.Size;
data_size += ((string)args[j]).Length + 1;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
string data = (string)args[i];
Marshal.Copy(Encoding.ASCII.GetBytes(data), 0, data_ptr, data.Length);
data_ptr = (IntPtr)((Int64)data_ptr + data.Length);
Marshal.Copy(new Byte[] { 0 }, 0, data_ptr, 1);
};
break;
case "StringBuilder":
args_size += IntPtr.Size;
data_size += ((StringBuilder)args[j]).Capacity + 1;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
StringBuilder data = (StringBuilder)args[i];
Marshal.Copy(Encoding.ASCII.GetBytes(data.ToString()), 0, data_ptr, data.Length);
Marshal.Copy(new Byte[] { 0 }, 0, (IntPtr)((Int64)data_ptr + data.Length), 1);
data_ptr = (IntPtr)((Int64)data_ptr + data.Capacity + 1);
};
va_args[j].read = (i) =>
{
StringBuilder data = (StringBuilder)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Remove(0, data.Length);
data.Append(Marshal.PtrToStringAnsi(data_ptr));
};
readables.Push(j);
break;
case "ptr<Char>":
args_size += IntPtr.Size;
data_size += 1;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
Char data = ((ptr <Char>)args[i]).Value;
Marshal.WriteByte(data_ptr, 0, Encoding.ASCII.GetBytes(new Char[] { data })[0]);
};
va_args[j].read = (i) =>
{
ptr <Char> data = (ptr <Char>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = Encoding.ASCII.GetChars(new byte[] { Marshal.ReadByte(data_ptr) })[0];
};
readables.Push(j);
break;
case "ptr<Byte>":
args_size += IntPtr.Size;
data_size += 1;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
Byte data = ((ptr <Byte>)args[i]).Value;
Marshal.WriteByte(data_ptr, 0, data);
};
va_args[j].read = (i) =>
{
ptr <Byte> data = (ptr <Byte>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = (Byte)Marshal.ReadByte(data_ptr);
};
readables.Push(j);
break;
case "ptr<SByte>":
args_size += IntPtr.Size;
data_size += 1;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
SByte data = ((ptr <SByte>)args[i]).Value;
Marshal.WriteByte(data_ptr, 0, (Byte)data);
};
va_args[j].read = (i) =>
{
ptr <SByte> data = (ptr <SByte>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = (SByte)Marshal.ReadByte(data_ptr);
};
readables.Push(j);
break;
case "ptr<Int16>":
args_size += IntPtr.Size;
data_size += 2;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
Int16 data = ((ptr <Int16>)args[i]).Value;
Marshal.WriteInt16(data_ptr, 0, data);
};
va_args[j].read = (i) =>
{
ptr <Int16> data = (ptr <Int16>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = (Int16)Marshal.ReadInt16(data_ptr);
};
readables.Push(j);
break;
case "ptr<UInt16>":
args_size += IntPtr.Size;
data_size += 2;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
UInt16 data = ((ptr <UInt16>)args[i]).Value;
Marshal.WriteInt16(data_ptr, 0, (Int16)data);
};
va_args[j].read = (i) =>
{
ptr <UInt16> data = (ptr <UInt16>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = (UInt16)Marshal.ReadInt16(data_ptr);
};
readables.Push(j);
break;
case "ptr<Int32>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
Int32 data = ((ptr <Int32>)args[i]).Value;
Marshal.WriteInt32(data_ptr, 0, data);
};
va_args[j].read = (i) =>
{
ptr <Int32> data = (ptr <Int32>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = (Int32)Marshal.ReadInt32(data_ptr);
};
readables.Push(j);
break;
case "ptr<UInt32>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
UInt32 data = ((ptr <UInt32>)args[i]).Value;
Marshal.WriteInt32(data_ptr, 0, (Int32)data);
};
va_args[j].read = (i) =>
{
ptr <UInt32> data = (ptr <UInt32>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = (UInt32)Marshal.ReadInt32(data_ptr);
};
readables.Push(j);
break;
case "ptr<Single>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
Single data = ((ptr <Single>)args[i]).Value;
Marshal.Copy(BitConverter.GetBytes((Single)data), 0, data_ptr, 4);
};
va_args[j].read = (i) =>
{
ptr <Single> data = (ptr <Single>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Byte[] bytes = new Byte[4];
Marshal.Copy(data_ptr, bytes, 0, 4);
data.Value = BitConverter.ToSingle(bytes, 0);
};
readables.Push(j);
break;
case "ptr<mp_bitcnt_t>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
mp_bitcnt_t data = ((ptr <mp_bitcnt_t>)args[i]).Value;
Marshal.WriteInt32(data_ptr, 0, (Int32)data.Value);
};
va_args[j].read = (i) =>
{
ptr <mp_bitcnt_t> data = (ptr <mp_bitcnt_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value.Value = (uint)Marshal.ReadInt32(data_ptr);
};
readables.Push(j);
break;
case "ptr<mpfr_prec_t>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
mpfr_prec_t data = ((ptr <mpfr_prec_t>)args[i]).Value;
Marshal.WriteInt32(data_ptr, 0, (Int32)data.Value);
};
va_args[j].read = (i) =>
{
ptr <mpfr_prec_t> data = (ptr <mpfr_prec_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value.Value = (uint)Marshal.ReadInt32(data_ptr);
};
readables.Push(j);
break;
case "ptr<mp_size_t>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
mp_size_t data = ((ptr <mp_size_t>)args[i]).Value;
Marshal.WriteInt32(data_ptr, 0, data.Value);
};
va_args[j].read = (i) =>
{
ptr <mp_size_t> data = (ptr <mp_size_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value.Value = Marshal.ReadInt32(data_ptr);
};
readables.Push(j);
break;
case "ptr<mp_exp_t>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
mp_exp_t data = ((ptr <mp_exp_t>)args[i]).Value;
Marshal.WriteInt32(data_ptr, 0, data.Value);
};
va_args[j].read = (i) =>
{
ptr <mp_exp_t> data = (ptr <mp_exp_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value.Value = Marshal.ReadInt32(data_ptr);
};
readables.Push(j);
break;
case "ptr<mpfr_exp_t>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
mpfr_exp_t data = ((ptr <mpfr_exp_t>)args[i]).Value;
Marshal.WriteInt32(data_ptr, 0, data.Value);
};
va_args[j].read = (i) =>
{
ptr <mpfr_exp_t> data = (ptr <mpfr_exp_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value.Value = Marshal.ReadInt32(data_ptr);
};
readables.Push(j);
break;
case "ptr<mpfr_sign_t>":
args_size += IntPtr.Size;
data_size += 4;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
mpfr_sign_t data = ((ptr <mpfr_sign_t>)args[i]).Value;
Marshal.WriteInt32(data_ptr, 0, data.Value);
};
va_args[j].read = (i) =>
{
ptr <mpfr_sign_t> data = (ptr <mpfr_sign_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value.Value = Marshal.ReadInt32(data_ptr);
};
readables.Push(j);
break;
case "ptr<Int64>":
args_size += IntPtr.Size;
data_size += 8;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
Int64 data = ((ptr <Int64>)args[i]).Value;
Marshal.WriteInt64(data_ptr, 0, data);
};
va_args[j].read = (i) =>
{
ptr <Int64> data = (ptr <Int64>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = (Int64)Marshal.ReadInt64(data_ptr);
};
readables.Push(j);
break;
case "ptr<UInt64>":
args_size += IntPtr.Size;
data_size += 8;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
UInt64 data = ((ptr <UInt64>)args[i]).Value;
Marshal.WriteInt64(data_ptr, 0, (Int64)data);
};
va_args[j].read = (i) =>
{
ptr <UInt64> data = (ptr <UInt64>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = (UInt64)Marshal.ReadInt64(data_ptr);
};
readables.Push(j);
break;
case "ptr<Double>":
args_size += IntPtr.Size;
data_size += 8;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
Double data = ((ptr <Double>)args[i]).Value;
Marshal.Copy(BitConverter.GetBytes(data), 0, data_ptr, 8);
};
va_args[j].read = (i) =>
{
ptr <Double> data = (ptr <Double>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Byte[] bytes = new Byte[8];
Marshal.Copy(data_ptr, bytes, 0, 8);
data.Value = BitConverter.ToDouble(bytes, 0);
};
readables.Push(j);
break;
case "ptr<mp_limb_t>":
args_size += IntPtr.Size;
data_size += IntPtr.Size;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
mp_limb_t data = ((ptr <mp_limb_t>)args[i]).Value;
if (IntPtr.Size == 4)
{
Marshal.WriteInt32(data_ptr, 0, (Int32)data.Value);
}
else
{
Marshal.WriteInt64(data_ptr, 0, (Int64)data.Value);
}
};
va_args[j].read = (i) =>
{
ptr <mp_limb_t> data = (ptr <mp_limb_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
if (IntPtr.Size == 4)
{
data.Value.Value = (UInt32)Marshal.ReadInt32(data_ptr);
}
else
{
data.Value.Value = (UInt64)Marshal.ReadInt64(data_ptr);
}
};
readables.Push(j);
break;
case "ptr<size_t>":
args_size += IntPtr.Size;
data_size += IntPtr.Size;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
size_t data = ((ptr <size_t>)args[i]).Value;
if (IntPtr.Size == 4)
{
Marshal.WriteInt32(data_ptr, 0, (Int32)data.Value);
}
else
{
Marshal.WriteInt64(data_ptr, 0, (Int64)data.Value);
}
};
va_args[j].read = (i) =>
{
ptr <size_t> data = (ptr <size_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
if (IntPtr.Size == 4)
{
data.Value.Value = (UInt32)Marshal.ReadInt32(data_ptr);
}
else
{
data.Value.Value = (UInt64)Marshal.ReadInt64(data_ptr);
}
};
readables.Push(j);
break;
case "ptr<uintmax_t>":
args_size += IntPtr.Size;
data_size += 8;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
uintmax_t data = ((ptr <uintmax_t>)args[i]).Value;
Marshal.WriteInt64(data_ptr, 0, (long)data.Value);
};
va_args[j].read = (i) =>
{
ptr <uintmax_t> data = (ptr <uintmax_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value.Value = (ulong)Marshal.ReadInt64(data_ptr);
};
readables.Push(j);
break;
case "ptr<intmax_t>":
args_size += IntPtr.Size;
data_size += 8;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
intmax_t data = ((ptr <intmax_t>)args[i]).Value;
Marshal.WriteInt64(data_ptr, 0, data.Value);
};
va_args[j].read = (i) =>
{
ptr <intmax_t> data = (ptr <intmax_t>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value.Value = Marshal.ReadInt64(data_ptr);
};
readables.Push(j);
break;
case "ptr<IntPtr>":
args_size += IntPtr.Size;
data_size += IntPtr.Size;
va_args[j].write = (i) =>
{
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
Marshal.WriteIntPtr(arguments, va_args[i].arg_offset, data_ptr);
IntPtr data = ((ptr <IntPtr>)args[i]).Value;
Marshal.WriteIntPtr(data_ptr, 0, data);
};
va_args[j].read = (i) =>
{
ptr <IntPtr> data = (ptr <IntPtr>)args[i];
IntPtr data_ptr = (IntPtr)(arguments.ToInt64() + args_size + va_args[i].data_offset);
data.Value = Marshal.ReadIntPtr(data_ptr);
};
readables.Push(j);
break;
default:
throw new System.InvalidOperationException("Unsupported variable argument type '" + name + "'");
}
}
// Write arguments to unmanaged memory.
arguments = gmp_lib.allocate((size_t)(args_size + data_size)).ToIntPtr();
for (int i = 0; i < va_args.Length; i++)
{
va_args[i].write(i);
}
}
public static extern uint dsn_crc32_concatenate(uint xy_init, uint x_init, uint x_final, size_t x_size, uint y_init, uint y_final, size_t y_size);
static extern IntPtr calloc(size_t num, size_t size);
public unsafe long cocoSuiteGetProblem(long suitePointer, size_t problemIndex)
{
return(coco_suite_get_problem(suitePointer, problemIndex));
}
public static extern void lua_pushlstring(lua_StatePtr L, string s, size_t l);
unsafe static extern double *coco_allocate_vector(size_t size);
public static extern IntPtr lua_newuserdata(lua_StatePtr L, size_t sz);
public static String lua_tolstring(lua_State L, int idx, out size_t len)
{
return(Marshal.PtrToStringAnsi(_lua_tolstring(L, idx, out len)));
}
get => Context.IsDisposed ? string.Empty : LLVMGetValueName2(ValueHandle, out size_t _);
public static String lua_pushlstring(lua_State L, String s, size_t len)
{
return(Marshal.PtrToStringAnsi(_lua_pushlstring(L, s, len)));
}
public static extern bool obs_enum_filter_types(size_t idx,
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8StringMarshaler))] out string id);
public static extern obs_encoder_t obs_audio_encoder_create(
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8StringMarshaler))] string id,
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8StringMarshaler))] string name,
obs_data_t settings, size_t mixer_idx, obs_data_t hotkey_data);
public static extern obs_data_t obs_data_array_item(obs_data_array_t array, size_t idx);
public extern static UInt32 dsn_crc32_concatenate(UInt32 xy_init, UInt32 x_init, UInt32 x_final, size_t x_size, UInt32 y_init, UInt32 y_final, size_t y_size);
public static extern void obs_data_array_insert(obs_data_array_t array, size_t idx, obs_data_t obj);
public extern static bool dsn_msg_read_next(dsn_message_t msg, out IntPtr ptr, out size_t size);
public static extern void obs_data_array_erase(obs_data_array_t array, size_t idx);
public extern static IntPtr dsn_msg_rw_ptr(dsn_message_t msg, size_t offset_begin);
//int main(int argc, const char * argv[])
static int Main()
{
int[,] a = new int[6, MAXBC]; // the bytes of the AES state
int[,] k = new int[6, MAXKC]; // the bytes of the AES key
int[,,] rk = new int[MAXROUNDS + 1, 6, MAXBC]; // AES round keys
tmp = tmpfile();
Console.Write("\\ AES keysize: {0:D}, rounds: {1:D}\n", keyBits, ROUNDS);
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < KC; j++)
{ // initialize variable indices
atleast_one.push_back(next);
k[i, j] = next++;
}
}
KeySchedule(k, keyBits, blockBits, rk);
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < BC; j++)
{ // initialize variable indices
atleast_one.push_back(next);
a[i, j] = next++;
}
}
KeyAddition(a, rk[0], BC);
/* ROUNDS-1 ordinary rounds */
for (int r = 1; r < ROUNDS; r++)
{
Substitution(a, BC);
ShiftRows(a, 0, BC);
MixColumns(a, BC);
KeyAddition(a, rk[r], BC);
}
Substitution(a, BC);
ShiftRows(a, 0, BC);
KeyAddition(a, rk[ROUNDS], BC);
/* at least one S-box must be active */
for (size_t i = 0; i != atleast_one.size() - 1; i++)
{
fprintf(tmp, "x%i + ", atleast_one.at(i));
}
fprintf(tmp, "x%i >= 1\n\n", atleast_one.back());
fprintf(tmp, "Binary\n"); // binary constraints
for (int i = 0; i < next; i++)
{
fprintf(tmp, "x%i\n", i);
}
for (int i = 0; i < dummy; i++)
{
fprintf(tmp, "d%i\n", i);
}
fprintf(tmp, "End\n");
Console.Write("Minimize\n"); // print objective function
for (size_t i = 0; i != sbox_input.Count - 1; i++)
{
Console.Write("x{0:D} + ", sbox_input[i]);
}
Console.Write("x{0:D}\n\n", sbox_input[sbox_input.Count - 1]);
Console.Write("Subject To\n"); // round function constraints
{
string buf = new string(new char[4096]);
rewind(tmp);
while (fgets(buf, sizeof(sbyte), tmp) != null)
{
Console.Write("{0}", buf);
}
}
fclose(tmp);
return(0);
}
public unsafe static extern size_t LZ4F_compressFrame(byte* dstBuffer, size_t dstMaxSize, byte* srcBuffer, size_t srcSize, LZ4Preferences *preferences = null);
/// <summary>Casts a <see cref="size_t"/> to an <see cref="Int32"/>, returning <see cref="Int32.MaxValue"/> if it is too large.</summary>
public static int ToMaxInt32(this size_t value)
{
return(value.ToPointer() > (void *)int.MaxValue
? Int32.MaxValue
: unchecked ((int)value.ToPointer()));
}
public unsafe static extern size_t LZ4F_compressBound(size_t srcSize, LZ4Preferences *preferences = null);
/// <summary>Casts a <see cref="size_t"/> to an <see cref="Int32"/>, throwing <see cref="OverflowException"/> if it is too large.</summary>
public static int ToInt32(this size_t value)
{
return(checked ((int)value.ToPointer()));
}
public unsafe static extern size_t LZ4F_compressEnd(void* ctx, void* dstBuffer, size_t dstMaxSize, Lz4CompressOptions* compressOptions = null);
public static int _callback(lws wsi, lws_callback_reasons reason, IntPtr user, IntPtr @in, size_t len)
{
var context = WSApi.lws_get_context(wsi);
var websocket = GetWebSocket(context);
if (websocket == null)
{
return(-1);
}
switch (reason)
{
case lws_callback_reasons.LWS_CALLBACK_CHANGE_MODE_POLL_FD:
{
return(0);
}
case lws_callback_reasons.LWS_CALLBACK_CLIENT_RECEIVE:
{
websocket._is_servicing = true;
return(websocket.OnReceive(@in, len));
}
case lws_callback_reasons.LWS_CALLBACK_CLIENT_WRITEABLE:
{
websocket._is_servicing = true;
if (websocket._is_closing)
{
WSApi.lws_close_reason(wsi, lws_close_status.LWS_CLOSE_STATUS_NORMAL, "");
return(-1);
}
websocket.OnWrite();
return(0);
}
case lws_callback_reasons.LWS_CALLBACK_OPENSSL_LOAD_EXTRA_CLIENT_VERIFY_CERTS:
{
return(0);
}
case lws_callback_reasons.LWS_CALLBACK_CLIENT_ESTABLISHED:
{
websocket._is_servicing = true;
websocket._wsi = wsi;
websocket.OnConnect(); // _on_connect(websocket, lws_get_protocol(wsi)->name);
return(0);
}
case lws_callback_reasons.LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
{
websocket._is_servicing = true;
websocket.OnError(@in, len);
websocket.Destroy();
return(-1);
}
case lws_callback_reasons.LWS_CALLBACK_WS_PEER_INITIATED_CLOSE:
{
websocket._is_servicing = true;
websocket.OnCloseRequest(@in, len);
return(0);
}
case lws_callback_reasons.LWS_CALLBACK_CLIENT_CLOSED:
{
websocket.SetClose(); // _duk_lws_close(websocket);
websocket.Destroy();
websocket.OnClose();
return(0);
}
default:
{
return(0);
}
}
}
public static extern bool LZ4F_isError(size_t code);
public static voidptr_t lua_newuserdata(lua_State L, size_t size) => lua_newuserdatauv(L, size, 1);
public static unsafe string GetErrorName(size_t code) => new string(LZ4F_getErrorName(code));
private ulong_t(size_t value) => __value = value;
public static extern int zmq_getsockopt( IntPtr socket, int option, IntPtr optval, ref size_t optvallen );
public static extern uint dsn_crc32_compute(IntPtr ptr, size_t size, uint init_crc);
