void test_msg (void)
{
l2net_154 *l2 ;
printf ("STEP 1: create 2 empty messages\n") ;
Msg *m1 = initMsg(l2) ;
printMsg (m1) ;
Msg *m2 = initMsg(l2) ;
printMsg (m2) ;
printf ("STEP 2: create options\n") ;
option *oup1 = initOptionOpaque(MO_Uri_Path, (void *) PATH1, sizeof PATH1-1) ;
option *oup2 = initOptionOpaque(MO_Uri_Path, (void *) PATH2, sizeof PATH2-1) ;
option *ouq1 = initOptionOpaque(MO_Uri_Query, (void *) URIQUERY1, sizeof URIQUERY1-1) ;
option *ouq2 = initOptionOpaque(MO_Uri_Query, (void *) URIQUERY2, sizeof URIQUERY2-1) ;
option *ouq3 = initOptionOpaque(MO_Uri_Query, (void *) URIQUERY3, sizeof URIQUERY3-1) ;
// REGISTER message
set_type (m1, COAP_TYPE_CON) ;
set_code (m1, COAP_CODE_GET) ;
set_id (m1, 10) ;
printf ("STEP 3a: M1 add uriquery2\n") ;
push_option (m1, ouq2) ;
printMsg (m1) ; printf("\n") ;
printf ("STEP 3b: M1 add uripath1\n") ;
push_option (m1, oup1) ;
printMsg (m1) ; printf("\n") ;
printf ("STEP 3c: M1 add uripath2\n") ;
push_option (m1, oup2) ;
printMsg (m1) ; printf("\n") ;
printf ("STEP 3d: M1 add uriquery1\n") ;
push_option (m1, ouq1) ;
printMsg (m1) ; printf("\n") ;
printf("STEP 3e: M1 add uriquery3\n") ;
push_option (m1, ouq3) ;
printMsg (m1) ; printf("\n") ;
set_type (m2, COAP_TYPE_NON) ;
set_code (m2, COAP_CODE_POST) ;
set_id (m2, 11) ;
printf ("STEP 3f: M2 add oriquery2\n") ;
push_option (m2, ouq2) ;
printMsg (m2) ; printf("\n") ;
if (get_errno () != 0)
{
printf ("ERROR : ERRNO => ") ;
printf ("%d\n",get_errno ()) ;
reset_errno () ;
}
clock_delay (1000) ;
}
void Shader::_set_code(const Dictionary& p_string) {
ERR_FAIL_COND(!p_string.has("fragment"));
ERR_FAIL_COND(!p_string.has("vertex"));
set_code(p_string["vertex"],p_string["fragment"]);
}
void Shutdown_Res::MergeFrom(const Shutdown_Res& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from.has_code()) {
set_code(from.code());
}
}
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void Shader::_set_code(const Dictionary& p_string) {
ERR_FAIL_COND(!p_string.has("fragment"));
ERR_FAIL_COND(!p_string.has("vertex"));
String light;
if (p_string.has("light"))
light=p_string["light"];
set_code(p_string["vertex"],p_string["fragment"],light);
}
void ProtoMessage::setCode(int32_t code, const std::string& errorMsg /*= ""*/)
{
auto rspCode = m_protoMsg->mutable_rspcode();
if (rspCode == nullptr)
{
return;
}
rspCode->set_code(code);
rspCode->set_errormessage(errorMsg);
}
void configure() {
Map_Base::configure();
trader::configure();
set_short("Agin's Dragon Emporium");
set_code("Agin's Dragon Emporium");
add_exit(Direction_East);
add_exit(Direction_West);
add_description(([
Description_Type : Description_Type_Simple,
Description_Content : ({
"this is the Dragon Emporium, a shop where one can find anything and everything relating to dragons.",
}),
/**********************************************************************
* キースキャン: 押されたキー値に対するアクション(信号送信)を実行
**********************************************************************
*/
void keybd_exec(uchar key)
{
if(key == 27) { // CH
maker_id ^= 1;
print_maker();
return;
}
set_code(ild_data,maker_id,key);
led_on();
ILD_send();
led_off();
}
void Shader::_set_code(const Dictionary& p_string) {
ERR_FAIL_COND(!p_string.has("fragment"));
ERR_FAIL_COND(!p_string.has("vertex"));
String light;
if (p_string.has("light"))
light=p_string["light"];
set_code(p_string["vertex"],p_string["fragment"],light);
if (p_string.has("default_tex")) {
Array arr=p_string["default_tex"];
if ((arr.size()&1)==0) {
for(int i=0;i<arr.size();i+=2)
set_default_texture_param(arr[i],arr[i+1]);
}
}
}
void
VolumeDriverError::report(events::VolumeDriverErrorCode code,
const std::string& desc,
const boost::optional<VolumeId>& volume) noexcept
{
try
{
events::Event ev;
auto msg = ev.MutableExtension(events::volumedriver_error);
msg->set_code(code);
msg->set_info(desc);
if (volume)
{
msg->set_volume_name(volume->str());
}
report(ev);
}
CATCH_STD_ALL_LOG_IGNORE("Failed to report event code " << code <<
", volume " << volume <<
", info " << desc);
TODO("AR: the logging could emit an exception, violating noexcept?");
}
void Sub29::actual_read(const std::string & data) {
if (data.size()) {
set_code(data[0]);
set_reason(data.substr(1, data.size() - 1));
}
}
void Expand_TestHarness(::AST::Crate& crate)
{
// Create the following module:
// ```
// mod `#test` {
// extern crate std;
// extern crate test;
// fn main() {
// self::test::test_main_static(&::`#test`::TESTS);
// }
// static TESTS: [test::TestDescAndFn; _] = [
// test::TestDescAndFn { desc: test::TestDesc { name: "foo", ignore: false, should_panic: test::ShouldPanic::No }, testfn: ::path::to::foo },
// ];
// }
// ```
// ---- main function ----
auto main_fn = ::AST::Function { Span(), {}, ABI_RUST, false, false, false, TypeRef(TypeRef::TagUnit(), Span()), {} };
{
auto call_node = NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode("test_main_static") }),
::make_vec1(
NEWNODE(_UniOp, ::AST::ExprNode_UniOp::REF,
NEWNODE(_NamedValue, ::AST::Path("", { ::AST::PathNode("test#"), ::AST::PathNode("TESTS") }))
)
)
);
main_fn.set_code( mv$(call_node) );
}
// ---- test list ----
::std::vector< ::AST::ExprNodeP> test_nodes;
for(const auto& test : crate.m_tests)
{
// HACK: Don't emit should_panic tests
if( test.panic_type != ::AST::TestDesc::ShouldPanic::No )
continue ;
::AST::ExprNode_StructLiteral::t_values desc_vals;
// `name: "foo",`
desc_vals.push_back({ {}, "name", NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode("StaticTestName") }),
::make_vec1( NEWNODE(_String, test.name) )
) });
// `ignore: false,`
desc_vals.push_back({ {}, "ignore", NEWNODE(_Bool, test.ignore) });
// `should_panic: ShouldPanic::No,`
{
::AST::ExprNodeP should_panic_val;
switch(test.panic_type)
{
case ::AST::TestDesc::ShouldPanic::No:
should_panic_val = NEWNODE(_NamedValue, ::AST::Path("test", { ::AST::PathNode("ShouldPanic"), ::AST::PathNode("No") }));
break;
case ::AST::TestDesc::ShouldPanic::Yes:
should_panic_val = NEWNODE(_NamedValue, ::AST::Path("test", { ::AST::PathNode("ShouldPanic"), ::AST::PathNode("Yes") }));
break;
case ::AST::TestDesc::ShouldPanic::YesWithMessage:
should_panic_val = NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode("ShouldPanic"), ::AST::PathNode("YesWithMessage") }),
make_vec1( NEWNODE(_String, test.expected_panic_message) )
);
break;
}
desc_vals.push_back({ {}, "should_panic", mv$(should_panic_val) });
}
auto desc_expr = NEWNODE(_StructLiteral, ::AST::Path("test", { ::AST::PathNode("TestDesc")}), nullptr, mv$(desc_vals));
::AST::ExprNode_StructLiteral::t_values descandfn_vals;
descandfn_vals.push_back({ {}, ::std::string("desc"), mv$(desc_expr) });
auto test_type_var_name = test.is_benchmark ? "StaticBenchFn" : "StaticTestFn";
descandfn_vals.push_back({ {}, ::std::string("testfn"), NEWNODE(_CallPath,
::AST::Path("test", { ::AST::PathNode(test_type_var_name) }),
::make_vec1( NEWNODE(_NamedValue, AST::Path(test.path)) )
) });
test_nodes.push_back( NEWNODE(_StructLiteral, ::AST::Path("test", { ::AST::PathNode("TestDescAndFn")}), nullptr, mv$(descandfn_vals) ) );
}
auto* tests_array = new ::AST::ExprNode_Array(mv$(test_nodes));
size_t test_count = tests_array->m_values.size();
auto tests_list = ::AST::Static { ::AST::Static::Class::STATIC,
TypeRef(TypeRef::TagSizedArray(), Span(),
TypeRef(Span(), ::AST::Path("test", { ::AST::PathNode("TestDescAndFn") })),
::std::shared_ptr<::AST::ExprNode>( new ::AST::ExprNode_Integer(test_count, CORETYPE_UINT) )
),
::AST::Expr( mv$(tests_array) )
};
// ---- module ----
auto newmod = ::AST::Module { ::AST::Path("", { ::AST::PathNode("test#") }) };
// - TODO: These need to be loaded too.
// > They don't actually need to exist here, just be loaded (and use absolute paths)
newmod.add_ext_crate(false, "std", "std", {});
newmod.add_ext_crate(false, "test", "test", {});
newmod.add_item(false, "main", mv$(main_fn), {});
newmod.add_item(false, "TESTS", mv$(tests_list), {});
crate.m_root_module.add_item(false, "test#", mv$(newmod), {});
crate.m_lang_items["mrustc-main"] = ::AST::Path("", { AST::PathNode("test#"), AST::PathNode("main") });
}
