Datasets:

AISE-TUDelft

/

Capybara

like 3

Follow

AISE research lab at TU Delft 44

[ "Allocates", "one", "element", "from", "the", "pool", "specified" ]

[ "'void", "*", "pool_alloc", "(", "alloc_pool", "pool", ")", "{", "alloc_pool_list", "header", ";", "#", "ifdef", "ENABLE_VALGRIND_CHECKING", "int", "size", ";", "#", "endif", "if", "(", "GATHER_STATISTICS", ")", "{", "struct", "alloc_pool_descriptor", "*", "desc", "=", "allocate_pool_descriptor", "(", "pool", "->", "name", ")", ";", "desc", "->", "allocated", "+=", "pool", "->", "elt_size", ";", "desc", "->", "current", "+=", "pool", "->", "elt_size", ";", "if", "(", "desc", "->", "peak", "<", "desc", "->", "current", ")", "desc", "->", "peak", "=", "desc", "->", "current", ";", "}", "gcc_checking_assert", "(", "pool", ")", ";", "#", "ifdef", "ENABLE_VALGRIND_CHECKING", "size", "=", "pool", "->", "elt_size", "-", "offsetof", "(", "allocation_object", ",", "u", ".", "data", ")", ";", "#", "endif", "/*", "If", "there", "are", "no", "more", "free", "elements,", "make", "some", "more!.", "*/", "if", "(", "!", "pool", "->", "returned_free_list", ")", "{", "char", "*", "block", ";", "if", "(", "!", "pool", "->", "virgin_elts_remaining", ")", "{", "alloc_pool_list", "block_header", ";", "/*", "Make", "the", "block.", "*/", "block", "=", "XNEWVEC", "(", "char", ",", "pool", "->", "block_size", ")", ";", "block_header", "=", "(", "alloc_pool_list", ")", "block", ";", "block", "+=", "align_eight", "(", "sizeof", "(", "struct", "alloc_pool_list_def", ")", ")", ";", "/*", "Throw", "it", "on", "the", "block", "list.", "*/", "block_header", "->", "next", "=", "pool", "->", "block_list", ";", "pool", "->", "block_list", "=", "block_header", ";", "/*", "Make", "the", "block", "available", "for", "allocation.", "*/", "pool", "->", "virgin_free_list", "=", "block", ";", "pool", "->", "virgin_elts_remaining", "=", "pool", "->", "elts_per_block", ";", "/*", "Also", "update", "the", "number", "of", "elements", "we", "have", "free/allocated,", "and", "increment", "the", "allocated", "block", "count.", "*/", "pool", "->", "elts_allocated", "+=", "pool", "->", "elts_per_block", ";", "pool", "->", "elts_free", "+=", "pool", "->", "elts_per_block", ";", "pool", "->", "blocks_allocated", "+=", "1", ";", "}", "/*", "We", "now", "know", "that", "we", "can", "take", "the", "first", "elt", "off", "the", "virgin", "list", "and", "put", "it", "on", "the", "returned", "list.", "*/", "block", "=", "pool", "->", "virgin_free_list", ";", "header", "=", "(", "alloc_pool_list", ")", "USER_PTR_FROM_ALLOCATION_OBJECT_PTR", "(", "block", ")", ";", "header", "->", "next", "=", "NULL", ";", "#", "ifdef", "ENABLE_CHECKING", "/*", "Mark", "the", "element", "to", "be", "free.", "*/", "(", "(", "allocation_object", "*", ")", "block", ")", "->", "id", "=", "0", ";", "#", "endif", "VALGRIND_DISCARD", "(", "VALGRIND_MAKE_MEM_NOACCESS", "(", "header", ",", "size", ")", ")", ";", "pool", "->", "returned_free_list", "=", "header", ";", "pool", "->", "virgin_free_list", "+=", "pool", "->", "elt_size", ";", "pool", "->", "virgin_elts_remaining", "--", ";", "}", "/*", "Pull", "the", "first", "free", "element", "from", "the", "free", "list,", "and", "return", "it.", "*/", "header", "=", "pool", "->", "returned_free_list", ";", "VALGRIND_DISCARD", "(", "VALGRIND_MAKE_MEM_DEFINED", "(", "header", ",", "sizeof", "(", "*", "header", ")", ")", ")", ";", "pool", "->", "returned_free_list", "=", "header", "->", "next", ";", "pool", "->", "elts_free", "--", ";", "#", "ifdef", "ENABLE_CHECKING", "/*", "Set", "the", "ID", "for", "element.", "*/", "ALLOCATION_OBJECT_PTR_FROM_USER_PTR", "(", "header", ")", "->", "id", "=", "pool", "->", "id", ";", "#", "endif", "VALGRIND_DISCARD", "(", "VALGRIND_MAKE_MEM_UNDEFINED", "(", "header", ",", "size", ")", ")", ";", "return", "(", "(", "void", "*", ")", "header", ")", ";", "}'" ]

[ "Free", "all", "memory", "allocated", "for", "the", "given", "memory", "pool" ]

[ "'void", "empty_alloc_pool", "(", "alloc_pool", "pool", ")", "{", "alloc_pool_list", "block", ",", "<type", "ref=\"prev\"/>", "next_block", ";", "gcc_checking_assert", "(", "pool", ")", ";", "/*", "Free", "each", "block", "allocated", "to", "the", "pool.", "*/", "for", "(", "block", "=", "pool", "->", "block_list", ";", "block", "!=", "NULL", ";", "block", "=", "next_block", ")", "{", "next_block", "=", "block", "->", "next", ";", "free", "(", "block", ")", ";", "}", "if", "(", "GATHER_STATISTICS", ")", "{", "struct", "alloc_pool_descriptor", "*", "desc", "=", "allocate_pool_descriptor", "(", "pool", "->", "name", ")", ";", "desc", "->", "current", "-=", "(", "pool", "->", "elts_allocated", "-", "pool", "->", "elts_free", ")", "*", "pool", "->", "elt_size", ";", "}", "pool", "->", "returned_free_list", "=", "NULL", ";", "pool", "->", "virgin_free_list", "=", "NULL", ";", "pool", "->", "virgin_elts_remaining", "=", "0", ";", "pool", "->", "elts_allocated", "=", "0", ";", "pool", "->", "elts_free", "=", "0", ";", "pool", "->", "blocks_allocated", "=", "0", ";", "pool", "->", "block_list", "=", "NULL", ";", "}'" ]

[ "Output", "peralloc_pool", "memory", "usage", "statistics" ]

[ "'void", "dump_alloc_pool_statistics", "(", "void", ")", "{", "struct", "output_info", "info", ";", "if", "(", "!", "GATHER_STATISTICS", ")", "return", ";", "if", "(", "!", "alloc_pool_hash", ".", "is_created", "()", ")", "return", ";", "fprintf", "(", "stderr", ",", "\"\\Alloc-pool", "Kind", "Elt", "size", "Pools", "Allocated", "(elts)", "Peak", "(elts)", "Leak", "(elts)\\\"", ")", ";", "fprintf", "(", "stderr", ",", "\"--------------------------------------------------------------------------------------------------------------\\\"", ")", ";", "info", ".", "total_created", "=", "0", ";", "info", ".", "total_allocated", "=", "0", ";", "alloc_pool_hash", ".", "traverse", "<", "struct", "output_info", "*", ",", "print_alloc_pool_statistics", ">", "(", "&", "info", ")", ";", "fprintf", "(", "stderr", ",", "\"--------------------------------------------------------------------------------------------------------------\\\"", ")", ";", "fprintf", "(", "stderr", ",", "\"%-22s", "%7lu", "%10lu\\\"", ",", "\"Total\"", ",", "info", ".", "total_created", ",", "info", ".", "total_allocated", ")", ";", "fprintf", "(", "stderr", ",", "\"--------------------------------------------------------------------------------------------------------------\\\"", ")", ";", "}'" ]

[ "mangle", "the", "instruction", "that", "reference", "memory", "via", "segment", "register" ]

[ "'void", "mangle_seg_ref", "(", "dcontext_t", "*", "dcontext", ",", "instrlist_t", "*", "ilist", ",", "instr_t", "*", "instr", ",", "instr_t", "*", "next_instr", ")", "{", "int", "si", "=", "-", "1", ",", "<type", "ref=\"prev\"/>", "di", "=", "-", "1", ";", "opnd_t", "segop", ",", "<type", "ref=\"prev\"/>", "newop", ";", "bool", "spill", "=", "true", ";", "reg_id_t", "scratch_reg", "=", "REG_XAX", ",", "<type", "ref=\"prev\"/>", "seg", "=", "REG_NULL", ";", "/*", "exit", "cti", "won\\'t", "be", "seg", "ref", "*/", "if", "(", "instr_is_exit_cti", "(", "instr", ")", ")", "return", ";", "/*", "mbr", "will", "be", "handled", "separatly", "*/", "if", "(", "instr_is_mbr", "(", "instr", ")", ")", "return", ";", "if", "(", "instr_get_opcode", "(", "instr", ")", "==", "OP_lea", ")", "return", ";", "/*", "XXX:", "maybe", "using", "decode_cti", "and", "then", "a", "check", "on", "prefix", "could", "be", "*", "more", "efficient", "as", "it", "only", "examines", "a", "few", "byte", "and", "avoid", "fully", "decoding", "*", "the", "instruction.", "For", "simplicity,", "we", "examine", "every", "operands", "instead.", "*/", "/*", "1.", "get", "ref", "opnd", "*/", "si", "=", "instr_get_seg_ref_src_idx", "(", "instr", ")", ";", "di", "=", "instr_get_seg_ref_dst_idx", "(", "instr", ")", ";", "if", "(", "si", "<", "0", "&&", "di", "<", "0", ")", "return", ";", "if", "(", "si", ">=", "0", ")", "{", "segop", "=", "instr_get_src", "(", "instr", ",", "si", ")", ";", "ASSERT", "(", "di", "<", "0", "||", "opnd_same", "(", "segop", ",", "instr_get_dst", "(", "instr", ",", "di", ")", ")", ")", ";", "}", "else", "{", "segop", "=", "instr_get_dst", "(", "instr", ",", "di", ")", ";", "}", "seg", "=", "opnd_get_segment", "(", "segop", ")", ";", "if", "(", "seg", "!=", "SEG_GS", "&&", "seg", "!=", "SEG_FS", ")", "return", ";", "#", "ifdef", "CLIENT_INTERFACE", "if", "(", "seg", "==", "LIB_SEG_TLS", "&&", "!", "INTERNAL_OPTION", "(", "private_loader", ")", ")", "return", ";", "#", "endif", "STATS_INC", "(", "app_seg_refs_mangled", ")", ";", "DOLOG", "(", "3", ",", "LOG_INTERP", ",", "{", "d_r_loginst(dcontext,", "3", ",", "instr,", "\"reference", "with", "fs/gs", "segment\"", ");", "}", ")", ";", "/*", "2.", "decide", "the", "scratch", "reg", "*/", "/*", "Opt:", "if", "it\\'s", "a", "load", "(OP_mov_ld,", "or", "OP_movzx,", "etc.),", "use", "dead", "reg", "*/", "if", "(", "si", ">=", "0", "&&", "instr_num_srcs", "(", "instr", ")", "==", "1", "&&", "/*", "src", "is", "the", "seg", "ref", "opnd", "*/", "instr_num_dsts", "(", "instr", ")", "==", "1", "&&", "/*", "only", "one", "dest:", "a", "register", "*/", "opnd_is_reg", "(", "instr_get_dst", "(", "instr", ",", "0", ")", ")", "&&", "!", "instr_is_predicated", "(", "instr", ")", ")", "{", "reg_id_t", "reg", "=", "opnd_get_reg", "(", "instr_get_dst", "(", "instr", ",", "0", ")", ")", ";", "/*", "if", "target", "is", "16", "or", "8", "bit", "sub-register", "the", "whole", "reg", "is", "not", "dead", "*", "(for", "32-bit,", "top", "32", "bits", "are", "cleared)", "*/", "if", "(", "reg_is_gpr", "(", "reg", ")", "&&", "(", "reg_is_32bit", "(", "reg", ")", "||", "reg_is_64bit", "(", "reg", ")", ")", "&&", "/*", "mov", "[%fs:%xax]", "=>", "%xax", "*/", "!", "instr_reads_from_reg", "(", "instr", ",", "reg", ",", "DR_QUERY_DEFAULT", ")", ")", "{", "spill", "=", "false", ";", "scratch_reg", "=", "reg", ";", "#", "ifdef", "X64", "if", "(", "opnd_get_size", "(", "instr_get_dst", "(", "instr", ",", "0", ")", ")", "==", "OPSZ_4", ")", "scratch_reg", "=", "reg_32_to_64", "(", "reg", ")", ";", "#", "endif", "}", "}", "if", "(", "spill", ")", "{", "/*", "we", "pick", "a", "scratch", "register", "from", "XAX,", "XBX,", "XCX,", "or", "XDX", "*", "that", "has", "direct", "TLS", "slots.", "*/", "for", "(", "scratch_reg", "=", "REG_XAX", ";", "scratch_reg", "<=", "REG_XBX", ";", "scratch_reg", "++", ")", "{", "/*", "the", "register", "must", "not", "be", "used", "by", "the", "instr,", "either", "read", "or", "write,", "*", "because", "we", "will", "mangle", "it", "when", "executing", "the", "instr", "(no", "read", "from),", "*", "and", "restore", "it", "after", "that", "instr", "(no", "write", "to).", "*/", "if", "(", "!", "instr_uses_reg", "(", "instr", ",", "scratch_reg", ")", ")", "break;", "}", "ASSERT", "(", "scratch_reg", "<=", "REG_XBX", ")", ";", "PRE", "(", "ilist", ",", "instr", ",", "instr_create_save_to_tls", "(", "dcontext", ",", "scratch_reg", ",", "tls_slots", "[", "scratch_reg", "-", "REG_XAX", "]", ")", ")", ";", "}", "newop", "=", "mangle_seg_ref_opnd", "(", "dcontext", ",", "ilist", ",", "instr", ",", "segop", ",", "scratch_reg", ")", ";", "if", "(", "si", ">=", "0", ")", "instr_set_src", "(", "instr", ",", "si", ",", "newop", ")", ";", "if", "(", "di", ">=", "0", ")", "instr_set_dst", "(", "instr", ",", "di", ",", "newop", ")", ";", "/*", "we", "need", "the", "whole", "spill...restore", "region", "to", "all", "be", "marked", "mangle", "*/", "instr_set_our_mangling", "(", "instr", ",", "true", ")", ";", "/*", "FIXME:", "i#107", "we", "should", "check", "the", "bound", "and", "raise", "signal", "if", "out", "of", "bound.", "*/", "DOLOG", "(", "3", ",", "LOG_INTERP", ",", "{", "d_r_loginst(dcontext,", "3", ",", "instr,", "\"re-wrote", "app", "tls", "reference\"", ");", "}", ")", ";", "if", "(", "spill", ")", "{", "PRE", "(", "ilist", ",", "next_instr", ",", "/*", "XXX", "i#3307:", "needs", "test.", "*/", "instr_set_translation_mangling_epilogue", "(", "dcontext", ",", "ilist", ",", "instr_create_restore_from_tls", "(", "dcontext", ",", "scratch_reg", ",", "tls_slots", "[", "scratch_reg", "-", "REG_XAX", "]", ")", ")", ")", ";", "}", "}'" ]

[ "Used", "for", "fault", "translation" ]

[ "'bool", "instr_check_xsp_mangling", "(", "dcontext_t", "*", "dcontext", ",", "instr_t", "*", "inst", ",", "int", "*", "xsp_adjust", ")", "{", "ASSERT", "(", "xsp_adjust", "!=", "NULL", ")", ";", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_push", "||", "instr_get_opcode", "(", "inst", ")", "==", "OP_push_imm", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "push", "or", "push_imm\\\"", ")", ";", "*", "xsp_adjust", "-=", "opnd_size_in_bytes", "(", "opnd_get_size", "(", "instr_get_dst", "(", "inst", ",", "1", ")", ")", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_pop", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "pop\\\"", ")", ";", "*", "xsp_adjust", "+=", "opnd_size_in_bytes", "(", "opnd_get_size", "(", "instr_get_src", "(", "inst", ",", "1", ")", ")", ")", ";", "}", "/*", "1st", "part", "of", "push", "emulation", "from", "insert_push_retaddr", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_lea", "&&", "opnd_get_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "==", "REG_XSP", "&&", "opnd_get_base", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", "==", "REG_XSP", "&&", "opnd_get_index", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", "==", "REG_NULL", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "lea", "xsp", "adjust\\\"", ")", ";", "*", "xsp_adjust", "+=", "opnd_get_disp", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ";", "}", "/*", "2nd", "part", "of", "push", "emulation", "from", "insert_push_retaddr", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_mov_st", "&&", "opnd_is_base_disp", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "&&", "opnd_get_base", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "==", "REG_XSP", "&&", "opnd_get_index", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "==", "REG_NULL", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "store", "to", "stack\\\"", ")", ";", "/*", "nothing", "to", "track:", "paired", "lea", "is", "what", "we", "undo", "*/", "}", "/*", "retrieval", "of", "target", "for", "call*", "or", "jmp*", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_movzx", "&&", "reg_overlap", "(", "opnd_get_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", ",", "REG_XCX", ")", ")", "||", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_mov_ld", "&&", "reg_overlap", "(", "opnd_get_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", ",", "REG_XCX", ")", ")", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "ib", "tgt", "to", "*cx\\\"", ")", ";", "/*", "nothing:", "our", "xcx", "spill", "restore", "will", "undo", "*/", "}", "/*", "part", "of", "pop", "emulation", "for", "iretd/lretd", "in", "x64", "mode", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_mov_ld", "&&", "opnd_is_base_disp", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", "&&", "opnd_get_base", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", "==", "REG_XSP", "&&", "opnd_get_index", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", "==", "REG_NULL", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "load", "from", "stack\\\"", ")", ";", "/*", "nothing", "to", "track:", "paired", "lea", "is", "what", "we", "undo", "*/", "}", "/*", "part", "of", "data16", "ret.", "once", "we", "have", "cs", "preservation", "(PR", "271317)", "we\\'ll", "*", "need", "to", "not", "fail", "when", "walking", "over", "a", "movzx", "to", "a", "pop", "cs", "(right", "now", "we", "*", "do", "not", "read", "the", "stack", "for", "the", "pop", "cs).", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_movzx", "&&", "opnd_get_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "==", "REG_CX", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "movzx", "to", "cx\\\"", ")", ";", "/*", "nothing:", "our", "xcx", "spill", "restore", "will", "undo", "*/", "}", "/*", "fake", "pop", "of", "cs", "for", "iret", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_add", "&&", "opnd_is_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "&&", "opnd_get_reg", "(", "instr_get_dst", "(", "inst", ",", "0", ")", ")", "==", "REG_XSP", "&&", "opnd_is_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "add", "to", "xsp\\\"", ")", ";", "ASSERT", "(", "CHECK_TRUNCATE_TYPE_int", "(", "opnd_get_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ")", ")", ";", "*", "xsp_adjust", "+=", "(", "int", ")", "opnd_get_immed_int", "(", "instr_get_src", "(", "inst", ",", "0", ")", ")", ";", "}", "/*", "popf", "for", "iret", "*/", "<if", "type=\"elseif\">", "else", "if", "(", "instr_get_opcode", "(", "inst", ")", "==", "OP_popf", ")", "{", "LOG", "(", "THREAD_GET", ",", "LOG_INTERP", ",", "4", ",", "\"\\\\tstate", "track:", "popf\\\"", ")", ";", "*", "xsp_adjust", "+=", "opnd_size_in_bytes", "(", "opnd_get_size", "(", "instr_get_src", "(", "inst", ",", "1", ")", ")", ")", ";", "}", "else", "{", "return", "false", ";", "}", "return", "true", ";", "}'" ]

[ "repeatme", "should", "be", "reexecuted", "5", "times", "with", "arg", "15" ]

[ "'EXPORT", "void", "repeatme", "(", "int", "i", ")", "{", "printf", "(", "\"hello", "%d\\\"", ",", "i", ")", ";", "}'" ]

[ "internal", "utility", "function", "that", "calls", "the", "appropriate", "routine", "for", "the", "wildcard", "passed", "in" ]

[ "\"int", "dotconf_handle_wild_card", "(", "command_t", "*", "cmd", ",", "char", "wild_card", ",", "char", "*", "path", ",", "char", "*", "pre", ",", "char", "*", "ext", ")", "{", "int", "retval", "=", "0", ";", "switch", "(", "wild_card", ")", "{", "case", "'*'", ":", "retval", "=", "dotconf_handle_star", "(", "cmd", ",", "path", ",", "pre", ",", "ext", ")", ";", "break;", "case", "'?'", ":", "retval", "=", "dotconf_handle_question_mark", "(", "cmd", ",", "path", ",", "pre", ",", "ext", ")", ";", "break;", "default:", "retval", "=", "-", "1", ";", "}", "return", "retval", ";", "}\"" ]

[ "internal", "utility", "function", "that", "determins", "if", "a", "string", "matches", "the", "''", "criteria" ]

[ "'int", "dotconf_star_match", "(", "char", "*", "dir_name", ",", "char", "*", "pre", ",", "char", "*", "ext", ")", "{", "int", "retval", "=", "-", "1", ";", "int", "dir_name_len", "=", "strlen", "(", "dir_name", ")", ";", "int", "pre_len", "=", "strlen", "(", "pre", ")", ";", "int", "ext_len", "=", "strlen", "(", "ext", ")", ";", "int", "w_card_check", "=", "strcspn", "(", "ext", ",", "WILDCARDS", ")", ";", "if", "(", "(", "w_card_check", "<", "ext_len", ")", "&&", "(", "strncmp", "(", "dir_name", ",", "pre", ",", "pre_len", ")", "==", "0", ")", "&&", "(", "strcmp", "(", "dir_name", ",", "\".\"", ")", "!=", "0", ")", "&&", "(", "strcmp", "(", "dir_name", ",", "\"..\"", ")", "!=", "0", ")", ")", "{", "retval", "=", "1", ";", "/*", "Another", "wildcard", "found", "*/", "}", "else", "{", "if", "(", "(", "dir_name_len", ">=", "(", "ext_len", "+", "pre_len", ")", ")", "&&", "(", "dotconf_strcmp_from_back", "(", "dir_name", ",", "ext", ")", "==", "0", ")", "&&", "(", "strncmp", "(", "dir_name", ",", "pre", ",", "pre_len", ")", "==", "0", ")", "&&", "(", "strcmp", "(", "dir_name", ",", "\".\"", ")", "!=", "0", ")", "&&", "(", "strcmp", "(", "dir_name", ",", "\"..\"", ")", "!=", "0", ")", ")", "{", "retval", "=", "0", ";", "/*", "Matches", "no", "other", "wildcards", "*/", "}", "}", "return", "retval", ";", "}'" ]

[ "internal", "utility", "function", "that", "determins", "if", "a", "string", "matches", "the", "'?'", "criteria" ]

[ "'int", "dotconf_question_mark_match", "(", "char", "*", "dir_name", ",", "char", "*", "pre", ",", "char", "*", "ext", ")", "{", "int", "retval", "=", "-", "1", ";", "int", "dir_name_len", "=", "strlen", "(", "dir_name", ")", ";", "int", "pre_len", "=", "strlen", "(", "pre", ")", ";", "int", "ext_len", "=", "strlen", "(", "ext", ")", ";", "int", "w_card_check", "=", "strcspn", "(", "ext", ",", "WILDCARDS", ")", ";", "if", "(", "(", "w_card_check", "<", "ext_len", ")", "&&", "(", "strncmp", "(", "dir_name", ",", "pre", ",", "pre_len", ")", "==", "0", ")", "&&", "(", "strcmp", "(", "dir_name", ",", "\".\"", ")", "!=", "0", ")", "&&", "(", "strcmp", "(", "dir_name", ",", "\"..\"", ")", "!=", "0", ")", ")", "{", "retval", "=", "1", ";", "/*", "Another", "wildcard", "found", "*/", "}", "else", "{", "if", "(", "(", "dir_name_len", ">=", "pre_len", ")", "&&", "(", "strncmp", "(", "dir_name", ",", "pre", ",", "pre_len", ")", "==", "0", ")", "&&", "(", "strcmp", "(", "dir_name", ",", "\".\"", ")", "!=", "0", ")", "&&", "(", "strcmp", "(", "dir_name", ",", "\"..\"", ")", "!=", "0", ")", ")", "{", "retval", "=", "0", ";", "/*", "Matches", "no", "other", "wildcards", "*/", "}", "}", "return", "retval", ";", "}'" ]

[ "internal", "utility", "function", "that", "compares", "two", "stings", "from", "back", "to", "front" ]

[ "'int", "dotconf_strcmp_from_back", "(", "const", "char", "*", "s1", ",", "const", "char", "*", "s2", ")", "{", "int", "retval", "=", "0", ";", "int", "i", ",", "<type", "ref=\"prev\"/>", "j", ";", "int", "len_1", "=", "strlen", "(", "s1", ")", ";", "int", "len_2", "=", "strlen", "(", "s2", ")", ";", "for", "(", "i", "=", "len_1", ",", "j", "=", "len_2", ";", "(", "i", ">=", "0", "&&", "j", ">=", "0", ")", ";", "i", "--", ",", "j", "--", ")", "{", "if", "(", "s1", "[", "i", "]", "!=", "s2", "[", "j", "]", ")", "{", "retval", "=", "-", "1", ";", "break;", "}", "}", "return", "retval", ";", "}'" ]

[ "internal", "utility", "function", "that", "verifies", "if", "a", "character", "is", "in", "the", "WILDCARDS", "list" ]

[ "'int", "dotconf_is_wild_card", "(", "char", "value", ")", "{", "int", "retval", "=", "0", ";", "int", "i", ";", "int", "wildcards_len", "=", "strlen", "(", "WILDCARDS", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "wildcards_len", ";", "i", "++", ")", "{", "if", "(", "value", "==", "WILDCARDS", "[", "i", "]", ")", "{", "retval", "=", "1", ";", "break;", "}", "}", "return", "retval", ";", "}'" ]

[ "Configures", "the", "Timers", "clocks", "prescalers", "selection" ]

[ "'void", "RCC_TIMCLKPresConfig", "(", "uint32_t", "RCC_TIMCLKPrescaler", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_RCC_TIMCLK_PRESCALER", "(", "RCC_TIMCLKPrescaler", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "DCKCFGR_TIMPRE_BB", "=", "RCC_TIMCLKPrescaler", ";", "}'" ]

[ "Enables", "or", "disables", "the", "main", "PLL" ]

[ "'void", "RCC_PLLCmd", "(", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "CR_PLLON_BB", "=", "(", "uint32_t", ")", "NewState", ";", "}'" ]

[ "Clears", "the", "RCC's", "interrupt", "pending", "bits" ]

[ "'void", "RCC_ClearITPendingBit", "(", "uint8_t", "RCC_IT", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_RCC_CLEAR_IT", "(", "RCC_IT", ")", ")", ";", "/*", "Perform", "Byte", "access", "to", "RCC_CIR[23:16]", "bits", "to", "clear", "the", "selected", "interrupt", "pending", "bits", "*/", "*", "(", "__IO", "uint8_t", "*", ")", "CIR_BYTE3_ADDRESS", "=", "RCC_IT", ";", "}'" ]

[ "Enables", "or", "disables", "the", "Internal", "High", "Speed", "oscillator", "(HSI)" ]

[ "'void", "RCC_HSICmd", "(", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "CR_HSION_BB", "=", "(", "uint32_t", ")", "NewState", ";", "}'" ]

[ "Configures", "the", "I2S", "clock", "source", "(I2SCLK)" ]

[ "'void", "RCC_I2SCLKConfig", "(", "uint32_t", "RCC_I2SCLKSource", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_RCC_I2SCLK_SOURCE", "(", "RCC_I2SCLKSource", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "CFGR_I2SSRC_BB", "=", "RCC_I2SCLKSource", ";", "}'" ]

[ "Internal", "and", "external", "clocks,", "PLL,", "CSS", "and", "MCO", "configuration", "functions" ]

[ "'void", "RCC_DeInit", "(", "void", ")", "{", "/*", "Set", "HSION", "bit", "*/", "RCC", "->", "CR", "|=", "(", "uint32_t", ")", "0x00000001", ";", "/*", "Reset", "CFGR", "register", "*/", "RCC", "->", "CFGR", "=", "0x00000000", ";", "/*", "Reset", "HSEON,", "CSSON,", "PLLON,", "PLLI2S", "and", "PLLSAI(STM32F42/43xxx", "devices)", "bits", "*/", "RCC", "->", "CR", "&=", "(", "uint32_t", ")", "0xEAF6FFFF", ";", "/*", "Reset", "PLLCFGR", "register", "*/", "RCC", "->", "PLLCFGR", "=", "0x24003010", ";", "/*", "Reset", "PLLI2SCFGR", "register", "*/", "RCC", "->", "PLLI2SCFGR", "=", "0x20003000", ";", "/*", "Reset", "PLLSAICFGR", "register,", "only", "available", "for", "STM32F42/43xxx", "devices", "*/", "RCC", "->", "PLLSAICFGR", "=", "0x24003000", ";", "/*", "Reset", "HSEBYP", "bit", "*/", "RCC", "->", "CR", "&=", "(", "uint32_t", ")", "0xFFFBFFFF", ";", "/*", "Disable", "all", "interrupts", "*/", "RCC", "->", "CIR", "=", "0x00000000", ";", "/*", "Disable", "Timers", "clock", "prescalers", "selection,", "only", "available", "for", "STM32F42/43xxx", "devices", "*/", "RCC", "->", "DCKCFGR", "=", "0x00000000", ";", "}'" ]

[ "Forces", "or", "releases", "the", "Backup", "domain", "reset" ]

[ "'void", "RCC_BackupResetCmd", "(", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "BDCR_BDRST_BB", "=", "(", "uint32_t", ")", "NewState", ";", "}'" ]

[ "Enables", "or", "disables", "the", "RTC", "clock" ]

[ "'void", "RCC_RTCCLKCmd", "(", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "BDCR_RTCEN_BB", "=", "(", "uint32_t", ")", "NewState", ";", "}'" ]

[ "Enables", "or", "disables", "the", "Internal", "Low", "Speed", "oscillator", "(LSI)" ]

[ "'void", "RCC_LSICmd", "(", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "CSR_LSION_BB", "=", "(", "uint32_t", ")", "NewState", ";", "}'" ]

[ "Enables", "or", "disables", "the", "PLLSAI" ]

[ "'void", "RCC_PLLSAICmd", "(", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "CR_PLLSAION_BB", "=", "(", "uint32_t", ")", "NewState", ";", "}'" ]

[ "Enables", "or", "disables", "the", "PLLI2S" ]

[ "'void", "RCC_PLLI2SCmd", "(", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "CR_PLLI2SON_BB", "=", "(", "uint32_t", ")", "NewState", ";", "}'" ]

[ "Enables", "or", "disables", "the", "Clock", "Security", "System" ]

[ "'void", "RCC_ClockSecuritySystemCmd", "(", "FunctionalState", "NewState", ")", "{", "/*", "Check", "the", "parameters", "*/", "assert_param", "(", "IS_FUNCTIONAL_STATE", "(", "NewState", ")", ")", ";", "*", "(", "__IO", "uint32_t", "*", ")", "CR_CSSON_BB", "=", "(", "uint32_t", ")", "NewState", ";", "}'" ]

[ "Forget", "any", "invalid", "pages", "in", "a", "whole", "database" ]

[ "'static", "void", "forget_invalid_pages_db", "(", "Oid", "dbid", ")", "{", "HASH_SEQ_STATUS", "status", ";", "xl_invalid_page", "*", "hentry", ";", "if", "(", "invalid_page_tab", "==", "NULL", ")", "return", ";", "/*", "nothing", "to", "do", "*/", "hash_seq_init", "(", "&", "status", ",", "invalid_page_tab", ")", ";", "while", "(", "(", "hentry", "=", "(", "xl_invalid_page", "*", ")", "hash_seq_search", "(", "&", "status", ")", ")", "!=", "NULL", ")", "{", "if", "(", "hentry", "->", "key", ".", "node", ".", "dbNode", "==", "dbid", ")", "{", "if", "(", "log_min_messages", "<=", "DEBUG2", "||", "client_min_messages", "<=", "DEBUG2", ")", "{", "char", "*", "path", "=", "relpathperm", "(", "hentry", "->", "key", ".", "node", ",", "hentry", "->", "key", ".", "forkno", ")", ";", "elog", "(", "DEBUG2", ",", "\"page", "%u", "of", "relation", "%s", "has", "been", "dropped\"", ",", "hentry", "->", "key", ".", "blkno", ",", "path", ")", ";", "pfree", "(", "path", ")", ";", "}", "if", "(", "hash_search", "(", "invalid_page_tab", ",", "(", "void", "*", ")", "&", "hentry", "->", "key", ",", "HASH_REMOVE", ",", "NULL", ")", "==", "NULL", ")", "elog", "(", "ERROR", ",", "\"hash", "table", "corrupted\"", ")", ";", "}", "}", "}'" ]

[ "Report", "a", "reference", "to", "an", "invalid", "page" ]

[ "'static", "void", "report_invalid_page", "(", "int", "elevel", ",", "RelFileNode", "node", ",", "ForkNumber", "forkno", ",", "BlockNumber", "blkno", ",", "bool", "present", ")", "{", "char", "*", "path", "=", "relpathperm", "(", "node", ",", "forkno", ")", ";", "if", "(", "present", ")", "elog", "(", "elevel", ",", "\"page", "%u", "of", "relation", "%s", "is", "uninitialized\"", ",", "blkno", ",", "path", ")", ";", "else", "elog", "(", "elevel", ",", "\"page", "%u", "of", "relation", "%s", "does", "not", "exist\"", ",", "blkno", ",", "path", ")", ";", "pfree", "(", "path", ")", ";", "}'" ]

[ "Log", "a", "reference", "to", "an", "invalid", "page" ]

[ "'static", "void", "log_invalid_page", "(", "RelFileNode", "node", ",", "ForkNumber", "forkno", ",", "BlockNumber", "blkno", ",", "bool", "present", ")", "{", "xl_invalid_page_key", "key", ";", "xl_invalid_page", "*", "hentry", ";", "bool", "found", ";", "/*", "*", "Once", "recovery", "has", "reached", "a", "consistent", "state,", "the", "invalid-page", "table", "*", "should", "be", "empty", "and", "remain", "so.", "If", "a", "reference", "to", "an", "invalid", "page", "is", "*", "found", "after", "consistency", "is", "reached,", "PANIC", "immediately.", "This", "might", "seem", "*", "aggressive,", "but", "it\\'s", "better", "than", "letting", "the", "invalid", "reference", "linger", "*", "in", "the", "hash", "table", "until", "the", "end", "of", "recovery", "and", "PANIC", "there,", "which", "*", "might", "come", "only", "much", "later", "if", "this", "is", "a", "standby", "server.", "*/", "if", "(", "reachedConsistency", ")", "{", "report_invalid_page", "(", "WARNING", ",", "node", ",", "forkno", ",", "blkno", ",", "present", ")", ";", "elog", "(", "ignore_invalid_pages", "?", "WARNING", ":", "PANIC", ",", "\"WAL", "contains", "references", "to", "invalid", "pages\"", ")", ";", "}", "/*", "*", "Log", "references", "to", "invalid", "pages", "at", "DEBUG1", "level.", "This", "allows", "some", "*", "tracing", "of", "the", "cause", "(note", "the", "elog", "context", "mechanism", "will", "tell", "us", "*", "something", "about", "the", "XLOG", "record", "that", "generated", "the", "reference).", "*/", "if", "(", "log_min_messages", "<=", "DEBUG1", "||", "client_min_messages", "<=", "DEBUG1", ")", "report_invalid_page", "(", "DEBUG1", ",", "node", ",", "forkno", ",", "blkno", ",", "present", ")", ";", "if", "(", "invalid_page_tab", "==", "NULL", ")", "{", "/*", "create", "hash", "table", "when", "first", "needed", "*/", "HASHCTL", "ctl", ";", "memset", "(", "&", "ctl", ",", "0", ",", "sizeof", "(", "ctl", ")", ")", ";", "ctl", ".", "keysize", "=", "sizeof", "(", "xl_invalid_page_key", ")", ";", "ctl", ".", "entrysize", "=", "sizeof", "(", "xl_invalid_page", ")", ";", "invalid_page_tab", "=", "hash_create", "(", "\"XLOG", "invalid-page", "table\"", ",", "100", ",", "&", "ctl", ",", "HASH_ELEM", "|", "HASH_BLOBS", ")", ";", "}", "/*", "we", "currently", "assume", "xl_invalid_page_key", "contains", "no", "padding", "*/", "key", ".", "node", "=", "node", ";", "key", ".", "forkno", "=", "forkno", ";", "key", ".", "blkno", "=", "blkno", ";", "hentry", "=", "(", "xl_invalid_page", "*", ")", "hash_search", "(", "invalid_page_tab", ",", "(", "void", "*", ")", "&", "key", ",", "HASH_ENTER", ",", "&", "found", ")", ";", "if", "(", "!", "found", ")", "{", "/*", "hash_search", "already", "filled", "in", "the", "key", "*/", "hentry", "->", "present", "=", "present", ";", "}", "else", "{", "/*", "repeat", "reference", "...", "leave", "\"present\"", "as", "it", "was", "*/", "}", "}'" ]

[ "XLogReaderRoutine>segment_open", "callback", "for", "local", "pg_wal", "files" ]

[ "'void", "wal_segment_open", "(", "XLogReaderState", "*", "state", ",", "XLogSegNo", "nextSegNo", ",", "TimeLineID", "*", "tli_p", ")", "{", "TimeLineID", "tli", "=", "*", "tli_p", ";", "char", "path", "[", "MAXPGPATH", "]", ";", "XLogFilePath", "(", "path", ",", "tli", ",", "nextSegNo", ",", "state", "->", "segcxt", ".", "ws_segsize", ")", ";", "state", "->", "seg", ".", "ws_file", "=", "BasicOpenFile", "(", "path", ",", "O_RDONLY", "|", "PG_BINARY", ")", ";", "if", "(", "state", "->", "seg", ".", "ws_file", ">=", "0", ")", "return", ";", "if", "(", "errno", "==", "ENOENT", ")", "ereport", "(", "ERROR", ",", "(", "errcode_for_file_access", "()", ",", "errmsg", "(", "\"requested", "WAL", "segment", "%s", "has", "already", "been", "removed\"", ",", "path", ")", ")", ")", ";", "else", "ereport", "(", "ERROR", ",", "(", "errcode_for_file_access", "()", ",", "errmsg", "(", "\"could", "not", "open", "file", "\\\\\"%s\\\\\":", "%m\"", ",", "path", ")", ")", ")", ";", "}'" ]

[ "MPI", "function", "that", "returns", "the", "ref", "of", "whatever", "arg0", "is", "linked", "to", "For", "multilinked", "exits,", "this", "may", "be", "a", "\\r", "delimited", "list" ]

[ "'const", "char", "*", "mfn_links", "(", "MFUNARGS", ")", "{", "char", "buf2", "[", "BUFFER_LEN", "]", ";", "dbref", "obj", ";", "int", "cnt", ";", "obj", "=", "mesg_dbref", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "if", "(", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", "||", "obj", "==", "NOTHING", "||", "obj", "==", "HOME", ")", "ABORT_MPI", "(", "\"LINKS\"", ",", "\"Match", "failed.\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"LINKS\"", ",", "\"Permission", "denied.\"", ")", ";", "switch", "(", "Typeof", "(", "obj", ")", ")", "{", "case", "TYPE_ROOM", ":", "obj", "=", "DBFETCH", "(", "obj", ")", "->", "sp", ".", "room", ".", "dropto", ";", "break;", "case", "TYPE_PLAYER", ":", "obj", "=", "PLAYER_HOME", "(", "obj", ")", ";", "break;", "case", "TYPE_THING", ":", "obj", "=", "THING_HOME", "(", "obj", ")", ";", "break;", "case", "TYPE_EXIT", ":", "/*", "Exits", "may", "have", "multiple", "links", "to", "contend", "with", "*/", "*", "buf", "=", "\\'\\\\0\\'", ";", "cnt", "=", "DBFETCH", "(", "obj", ")", "->", "sp", ".", "exit", ".", "ndest", ";", "if", "(", "cnt", ")", "{", "dbref", "obj2", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "cnt", ";", "i", "++", ")", "{", "obj2", "=", "DBFETCH", "(", "obj", ")", "->", "sp", ".", "exit", ".", "dest", "[", "i", "]", ";", "ref2str", "(", "obj2", ",", "buf2", ",", "sizeof", "(", "buf2", ")", ")", ";", "if", "(", "strlen", "(", "buf", ")", "+", "strlen", "(", "buf2", ")", "+", "2", "<", "BUFFER_LEN", ")", "{", "if", "(", "*", "buf", ")", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "\"\\\\r\"", ")", ";", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "buf2", ")", ";", "}", "}", "return", "buf", ";", "}", "else", "{", "return", "\"#-1\"", ";", "}", "case", "TYPE_PROGRAM", ":", "default:", "return", "\"#-1\"", ";", "}", "return", "ref2str", "(", "obj", ",", "buf", ",", "BUFFER_LEN", ")", ";", "}'" ]

[ "MPI", "function", "that", "counts", "number", "of", "items", "in", "list", "arg0", "arg0", "is", "a", "string", "containing", "a", "delimited", "list" ]

[ "'const", "char", "*", "mfn_count", "(", "MFUNARGS", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "\"\\\\r\"", ")", ";", "if", "(", "argc", ">", "1", ")", "{", "if", "(", "!", "*", "argv", "[", "1", "]", ")", "ABORT_MPI", "(", "\"COUNT\"", ",", "\"Can\\'t", "use", "null", "separator", "string.\"", ")", ";", "strcpyn", "(", "buf", ",", "buflen", ",", "argv", "[", "1", "]", ")", ";", "}", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "countlitems", "(", "argv", "[", "0", "]", ",", "buf", ")", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "a", "random", "item", "from", "list", "arg0", "arg0", "is", "a", "string", "containing", "a", "delimited", "list" ]

[ "'const", "char", "*", "mfn_lrand", "(", "MFUNARGS", ")", "{", "/*", "{lrand:list,sep}", "*/", "char", "sepbuf", "[", "BUFFER_LEN", "]", ";", "int", "count", "=", "1", ";", "int", "which", "=", "0", ";", "strcpyn", "(", "sepbuf", ",", "sizeof", "(", "sepbuf", ")", ",", "\"\\\\r\"", ")", ";", "if", "(", "argc", ">", "1", ")", "{", "if", "(", "!", "*", "argv", "[", "1", "]", ")", "ABORT_MPI", "(", "\"LRAND\"", ",", "\"Can\\'t", "use", "null", "separator", "string.\"", ")", ";", "strcpyn", "(", "sepbuf", ",", "sizeof", "(", "sepbuf", ")", ",", "argv", "[", "1", "]", ")", ";", "}", "count", "=", "countlitems", "(", "argv", "[", "0", "]", ",", "sepbuf", ")", ";", "if", "(", "count", ")", "{", "which", "=", "(", "(", "RANDOM", "()", "/", "256", ")", "%", "count", ")", "+", "1", ";", "getlitem", "(", "buf", ",", "buflen", ",", "argv", "[", "0", "]", ",", "sepbuf", ",", "which", ")", ";", "}", "else", "{", "*", "buf", "=", "\\'\\\\0\\'", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "tests", "the", "lock", "of", "arg1", "against", "arg0", "Returns", "1", "if", "locked,", "0", "if", "not", "locked" ]

[ "'const", "char", "*", "mfn_locked", "(", "MFUNARGS", ")", "{", "dbref", "who", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "dbref", "obj", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "1", "]", ",", "mesgtyp", ")", ";", "if", "(", "who", "==", "AMBIGUOUS", "||", "who", "==", "UNKNOWN", "||", "who", "==", "NOTHING", "||", "who", "==", "HOME", ")", "ABORT_MPI", "(", "\"LOCKED\"", ",", "\"Match", "failed.", "(arg1)\"", ")", ";", "if", "(", "who", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"LOCKED\"", ",", "\"Permission", "denied.", "(arg1)\"", ")", ";", "if", "(", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", "||", "obj", "==", "NOTHING", "||", "obj", "==", "HOME", ")", "ABORT_MPI", "(", "\"LOCKED\"", ",", "\"Match", "failed.", "(arg2)\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"LOCKED\"", ",", "\"Permission", "denied.", "(arg2)\"", ")", ";", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "!", "could_doit", "(", "descr", ",", "who", ",", "obj", ")", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "tests", "a", "lock", "property", "At", "a", "minimum", "needs", "arg0", "to", "be", "an", "object,", "and", "arg1", "to", "be", "a", "lock", "property", "to", "check" ]

[ "'const", "char", "*", "mfn_testlock", "(", "MFUNARGS", ")", "{", "struct", "boolexp", "*", "lok", ";", "dbref", "who", "=", "player", ";", "dbref", "obj", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "if", "(", "argc", ">", "2", ")", "{", "who", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "2", "]", ",", "mesgtyp", ")", ";", "}", "if", "(", "who", "==", "AMBIGUOUS", "||", "who", "==", "UNKNOWN", "||", "who", "==", "NOTHING", "||", "who", "==", "HOME", ")", "ABORT_MPI", "(", "\"TESTLOCK\"", ",", "\"Match", "failed.", "(arg3)\"", ")", ";", "if", "(", "who", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"TESTLOCK\"", ",", "\"Permission", "denied.", "(arg3)\"", ")", ";", "if", "(", "Typeof", "(", "who", ")", "!=", "TYPE_PLAYER", "&&", "Typeof", "(", "who", ")", "!=", "TYPE_THING", ")", "ABORT_MPI", "(", "\"TESTLOCK\"", ",", "\"Invalid", "object", "type.", "(arg3)\"", ")", ";", "if", "(", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", "||", "obj", "==", "NOTHING", "||", "obj", "==", "HOME", ")", "ABORT_MPI", "(", "\"TESTLOCK\"", ",", "\"Match", "failed.", "(arg1)\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"TESTLOCK\"", ",", "\"Permission", "denied.", "(arg1)\"", ")", ";", "if", "(", "Prop_System", "(", "argv", "[", "1", "]", ")", ")", "ABORT_MPI", "(", "\"TESTLOCK\"", ",", "\"Permission", "denied.", "(arg1)\"", ")", ";", "if", "(", "!", "(", "mesgtyp", "&", "MPI_ISBLESSED", ")", ")", "{", "if", "(", "Prop_Hidden", "(", "argv", "[", "1", "]", ")", ")", "ABORT_MPI", "(", "\"TESTLOCK\"", ",", "\"Permission", "denied.", "(arg2)\"", ")", ";", "if", "(", "Prop_Private", "(", "argv", "[", "1", "]", ")", "&&", "OWNER", "(", "perms", ")", "!=", "OWNER", "(", "what", ")", ")", "ABORT_MPI", "(", "\"TESTLOCK\"", ",", "\"Permission", "denied.", "(arg2)\"", ")", ";", "}", "lok", "=", "get_property_lock", "(", "obj", ",", "argv", "[", "1", "]", ")", ";", "if", "(", "argc", ">", "3", "&&", "lok", "==", "TRUE_BOOLEXP", ")", "return", "(", "argv", "[", "3", "]", ")", ";", "if", "(", "eval_boolexp", "(", "descr", ",", "who", ",", "lok", ",", "obj", ")", ")", "{", "return", "\"1\"", ";", "}", "else", "{", "return", "\"0\"", ";", "}", "}'" ]

[ "MPI", "function", "that", "finds", "a", "substring", "arg0", "is", "the", "string", "to", "search", "and", "arg1", "is", "the", "string", "to", "search", "for" ]

[ "'const", "char", "*", "mfn_instr", "(", "MFUNARGS", ")", "{", "char", "*", "ptr", ";", "if", "(", "!", "*", "argv", "[", "1", "]", ")", "ABORT_MPI", "(", "\"INSTR\"", ",", "\"Can\\'t", "search", "for", "a", "null", "string.\"", ")", ";", "for", "(", "ptr", "=", "argv", "[", "0", "]", ";", "*", "ptr", "&&", "!", "string_prefix", "(", "ptr", ",", "argv", "[", "1", "]", ")", ";", "ptr", "++", ")", ";", "if", "(", "!", "*", "ptr", ")", "return", "\"0\"", ";", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "(", "int", ")", "(", "ptr", "-", "argv", "[", "0", "]", "+", "1", ")", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "turns", "a", "list", "into", "a", "comma", "delimited", "string", "arg0", "is", "a", "list" ]

[ "'const", "char", "*", "mfn_commas", "(", "MFUNARGS", ")", "{", "int", "v", ",", "<type", "ref=\"prev\"/>", "count", ",", "<type", "ref=\"prev\"/>", "itemlen", ";", "char", "*", "ptr", ";", "char", "*", "out", ";", "char", "listbuf", "[", "BUFFER_LEN", "]", ";", "char", "sepbuf", "[", "BUFFER_LEN", "]", ";", "char", "buf2", "[", "BUFFER_LEN", "]", ";", "char", "tmp", "[", "BUFFER_LEN", "]", ";", "tmp", "[", "0", "]", "=", "\\'\\\\0\\'", ";", "if", "(", "argc", "==", "3", ")", "ABORT_MPI", "(", "\"COMMAS\"", ",", "\"Takes", "1,", "2,", "or", "4", "arguments.\"", ")", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "listbuf", ",", "sizeof", "(", "listbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"COMMAS\"", ",", "\"arg", "1\"", ")", ";", "count", "=", "countlitems", "(", "listbuf", ",", "\"\\\\r\"", ")", ";", "if", "(", "count", "==", "0", ")", "return", "\"\"", ";", "if", "(", "argc", ">", "1", ")", "{", "ptr", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "sepbuf", ",", "sizeof", "(", "sepbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"COMMAS\"", ",", "\"arg", "2\"", ")", ";", "}", "else", "{", "strcpyn", "(", "sepbuf", ",", "sizeof", "(", "sepbuf", ")", ",", "\"", "and", "\"", ")", ";", "}", "if", "(", "argc", ">", "2", ")", "{", "ptr", "=", "MesgParse", "(", "argv", "[", "2", "]", ",", "buf2", ",", "sizeof", "(", "buf2", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"COMMAS\"", ",", "\"arg", "3\"", ")", ";", "v", "=", "new_mvar", "(", "ptr", ",", "tmp", ")", ";", "if", "(", "v", "==", "1", ")", "ABORT_MPI", "(", "\"COMMAS\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "v", "==", "2", ")", "ABORT_MPI", "(", "\"COMMAS\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "}", "*", "buf", "=", "\\'\\\\0\\'", ";", "out", "=", "buf", ";", "/*", "Iterate", "over", "the", "list", "*/", "for", "(", "int", "i", "=", "1", ";", "i", "<=", "count", ";", "i", "++", ")", "{", "/*", "*", "TODO:", "This", "is", "another", "list", "operation", "with", "a", "hardcoded", "separator.", "*", "*", "Also,", "technically", "getitem", "is", "a", "really", "bad", "way", "to", "do", "this", "*", "since", "it", "will", "re-iterate", "over", "the", "string.", "We", "could", "make", "*", "a", "function", "that", "returns", "an", "array", "of", "string-pointers", "to", "each", "*", "item", "in", "the", "array,", "and", "us", "that", "everywhere,", "as", "something", "*", "\\'nicer\\'", "than", "using", "getitem", "or", "iterating", "over", "the", "string.", "*/", "ptr", "=", "getlitem", "(", "buf2", ",", "sizeof", "(", "buf2", ")", ",", "listbuf", ",", "\"\\\\r\"", ",", "i", ")", ";", "if", "(", "argc", ">", "2", ")", "{", "strcpyn", "(", "tmp", ",", "BUFFER_LEN", ",", "ptr", ")", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "3", "]", ",", "buf2", ",", "sizeof", "(", "buf2", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"COMMAS\"", ",", "\"arg", "3\"", ")", ";", "}", "itemlen", "=", "strlen", "(", "ptr", ")", ";", "if", "(", "(", "out", "-", "buf", ")", "+", "itemlen", ">=", "BUFFER_LEN", ")", "{", "if", "(", "argc", ">", "2", ")", "free_top_mvar", "()", ";", "return", "buf", ";", "}", "strcatn", "(", "out", ",", "BUFFER_LEN", "-", "(", "size_t", ")", "(", "out", "-", "buf", ")", ",", "ptr", ")", ";", "out", "+=", "itemlen", ";", "switch", "(", "count", "-", "i", ")", "{", "case", "0", ":", "/*", "End", "of", "the", "string", "*/", "if", "(", "argc", ">", "2", ")", "free_top_mvar", "()", ";", "return", "buf", ";", "case", "1", ":", "/*", "Last", "item,", "add", "the", "last", "separator", "*/", "itemlen", "=", "strlen", "(", "sepbuf", ")", ";", "if", "(", "(", "out", "-", "buf", ")", "+", "itemlen", ">=", "BUFFER_LEN", ")", "{", "if", "(", "argc", ">", "2", ")", "free_top_mvar", "()", ";", "return", "buf", ";", "}", "strcatn", "(", "out", ",", "BUFFER_LEN", "-", "(", "size_t", ")", "(", "out", "-", "buf", ")", ",", "sepbuf", ")", ";", "out", "+=", "itemlen", ";", "break;", "default:", "/*", "Append", "items", "to", "string", "with", "a", ",", "*/", "if", "(", "(", "out", "-", "buf", ")", "+", "2", ">=", "BUFFER_LEN", ")", "{", "if", "(", "argc", ">", "2", ")", "free_top_mvar", "()", ";", "return", "buf", ";", "}", "strcatn", "(", "out", ",", "BUFFER_LEN", "-", "(", "size_t", ")", "(", "out", "-", "buf", ")", ",", "\",", "\"", ")", ";", "out", "+=", "strlen", "(", "out", ")", ";", "break;", "}", "}", "if", "(", "argc", ">", "2", ")", "free_top_mvar", "()", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "the", "name", "of", "arg0", "Exit", "names", "are", "truncated", "at", "the", "first", "sign", "of", "a", "';'", "so", "that", "it", "looks", "pretty" ]

[ "'const", "char", "*", "mfn_name", "(", "MFUNARGS", ")", "{", "char", "*", "ptr", ";", "dbref", "obj", "=", "mesg_dbref_raw", "(", "descr", ",", "player", ",", "what", ",", "argv", "[", "0", "]", ")", ";", "if", "(", "obj", "==", "UNKNOWN", ")", "ABORT_MPI", "(", "\"NAME\"", ",", "\"Match", "failed.\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"NAME\"", ",", "\"Permission", "denied.\"", ")", ";", "if", "(", "obj", "==", "NOTHING", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "\"#NOTHING#\"", ")", ";", "return", "buf", ";", "}", "if", "(", "obj", "==", "AMBIGUOUS", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "\"#AMBIGUOUS#\"", ")", ";", "return", "buf", ";", "}", "if", "(", "obj", "==", "HOME", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "\"#HOME#\"", ")", ";", "return", "buf", ";", "}", "strcpyn", "(", "buf", ",", "buflen", ",", "NAME", "(", "obj", ")", ")", ";", "if", "(", "Typeof", "(", "obj", ")", "==", "TYPE_EXIT", ")", "{", "ptr", "=", "strchr", "(", "buf", ",", "EXIT_DELIMITER", ")", ";", "if", "(", "ptr", ")", "*", "ptr", "=", "\\'\\\\0\\'", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "forces", "an", "object", "arg0", "is", "the", "object", "to", "force,", "and", "arg1", "is", "the", "command", "to", "run" ]

[ "'const", "char", "*", "mfn_force", "(", "MFUNARGS", ")", "{", "char", "*", "nxt", ",", "<type", "ref=\"prev\">", "*", "ptr", ";", "dbref", "obj", "=", "mesg_dbref_raw", "(", "descr", ",", "player", ",", "what", ",", "argv", "[", "0", "]", ")", ";", "if", "(", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", "||", "obj", "==", "NOTHING", "||", "obj", "==", "HOME", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Failed", "match.", "(arg1)\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Permission", "denied.", "(arg1)\"", ")", ";", "if", "(", "Typeof", "(", "obj", ")", "!=", "TYPE_THING", "&&", "Typeof", "(", "obj", ")", "!=", "TYPE_PLAYER", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Bad", "object", "reference.", "(arg1)\"", ")", ";", "if", "(", "!", "*", "argv", "[", "1", "]", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Null", "command", "string.", "(arg2)\"", ")", ";", "if", "(", "!", "tp_allow_zombies", "&&", "!", "(", "mesgtyp", "&", "MPI_ISBLESSED", ")", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Permission", "Denied.\"", ")", ";", "/*", "*", "@TODO:", "This", "has", "a", "lot", "of", "overlap", "with", "the", "@force", "command", "in", "wiz.c", "*", "Notably,", "wiz.c", "logs", "forces", "whereas", "this", "MPI", "call", "does", "not;", "*", "that", "is", "probably", "sensible", "because", "MPI", "is", "used", "to", "force", "*", "zombies", "and", "that", "would", "be", "double", "log", "spam", "I", "believe.", "*", "*", "The", "smart", "thing", "to", "do", "here,", "I", "think,", "would", "be", "to", "us", "a", "common", "*", "shared", "function", "that", "has", "a", "bitvector", "of", "options.", "If", "the", "*", "call", "is", "blessed,", "for", "instance,", "we", "get", "wiz", "perms.", "If", "the", "*", "call", "comes", "from", "MPI", "don\\'t", "log", "it.", "*", "*", "Then", "this", "function", "can", "just", "iterate", "over", "the", "force", "command", "*", "in", "a", "loop", "in", "order", "to", "continue", "its", "support", "of", "lists", "*/", "if", "(", "!", "(", "mesgtyp", "&", "MPI_ISBLESSED", ")", ")", "{", "ptr", "=", "(", "char", "*", ")", "NAME", "(", "obj", ")", ";", "char", "objname", "[", "BUFFER_LEN", "]", ",", "<type", "ref=\"prev\">", "*", "ptr2", ";", "dbref", "loc", "=", "LOCATION", "(", "obj", ")", ";", "if", "(", "Typeof", "(", "obj", ")", "==", "TYPE_THING", ")", "{", "if", "(", "FLAGS", "(", "obj", ")", "&", "DARK", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Cannot", "force", "a", "dark", "puppet.\"", ")", ";", "if", "(", "(", "FLAGS", "(", "OWNER", "(", "obj", ")", ")", "&", "ZOMBIE", ")", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Permission", "denied.\"", ")", ";", "if", "(", "loc", "!=", "NOTHING", "&&", "(", "FLAGS", "(", "loc", ")", "&", "ZOMBIE", ")", "&&", "Typeof", "(", "loc", ")", "==", "TYPE_ROOM", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Cannot", "force", "a", "Puppet", "in", "a", "no-puppets", "room.\"", ")", ";", "for", "(", "ptr2", "=", "objname", ";", "*", "ptr", "&&", "!", "isspace", "(", "*", "ptr", ")", ";", ")", "*", "(", "ptr2", "++", ")", "=", "*", "(", "ptr", "++", ")", ";", "*", "ptr2", "=", "\\'\\\\0\\'", ";", "if", "(", "lookup_player", "(", "objname", ")", "!=", "NOTHING", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Cannot", "force", "a", "thing", "named", "after", "a", "player.\"", ")", ";", "}", "if", "(", "!", "(", "FLAGS", "(", "obj", ")", "&", "XFORCIBLE", ")", ")", "{", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Permission", "denied:", "forced", "object", "not", "@set", "Xforcible.\"", ")", ";", "}", "if", "(", "!", "test_lock_false_default", "(", "descr", ",", "perms", ",", "obj", ",", "MESGPROP_FLOCK", ")", ")", "{", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Permission", "denied:", "Object", "not", "force-locked", "to", "trigger.\"", ")", ";", "}", "}", "#", "ifdef", "GOD_PRIV", "if", "(", "God", "(", "obj", ")", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Permission", "denied:", "You", "can\\'t", "force", "God.\"", ")", ";", "#", "endif", "if", "(", "force_level", ">", "(", "tp_max_force_level", "-", "1", ")", ")", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Permission", "denied:", "You", "can\\'t", "force", "recursively.\"", ")", ";", "strcpyn", "(", "buf", ",", "buflen", ",", "argv", "[", "1", "]", ")", ";", "ptr", "=", "buf", ";", "/*", "*", "This", "supports", "sending", "a", "list", "of", "commands", "over", "{force}", "*/", "do", "{", "const", "char", "*", "ptr2", "=", "NAME", "(", "obj", ")", ";", "char", "objname", "[", "BUFFER_LEN", "]", ",", "<type", "ref=\"prev\">", "*", "ptr3", ";", "nxt", "=", "strchr", "(", "ptr", ",", "\\'\\\\r\\'", ")", ";", "if", "(", "nxt", ")", "*", "nxt", "++", "=", "\\'\\\\0\\'", ";", "for", "(", "ptr3", "=", "objname", ";", "*", "ptr2", "&&", "!", "isspace", "(", "*", "ptr2", ")", ";", ")", "*", "(", "ptr3", "++", ")", "=", "*", "(", "ptr2", "++", ")", ";", "*", "ptr3", "=", "\\'\\\\0\\'", ";", "if", "(", "lookup_player", "(", "objname", ")", "!=", "NOTHING", "&&", "Typeof", "(", "obj", ")", "!=", "TYPE_PLAYER", ")", "{", "ABORT_MPI", "(", "\"FORCE\"", ",", "\"Cannot", "force", "a", "thing", "named", "after", "a", "player.", "[2]\"", ")", ";", "}", "objnode_push", "(", "&", "forcelist", ",", "player", ")", ";", "if", "(", "player", "!=", "what", ")", "objnode_push", "(", "&", "forcelist", ",", "what", ")", ";", "force_level", "++", ";", "if", "(", "*", "ptr", ")", "process_command", "(", "dbref_first_descr", "(", "obj", ")", ",", "obj", ",", "ptr", ")", ";", "force_level", "--", ";", "objnode_pop", "(", "&", "forcelist", ")", ";", "if", "(", "player", "!=", "what", ")", "objnode_pop", "(", "&", "forcelist", ")", ";", "ptr", "=", "nxt", ";", "}", "while", "(", "ptr", ")", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "return", "\"\"", ";", "}'" ]

[ "Check", "to", "see", "if", "a", "list", "'list'", "contains", "word", "'word'", "'word'", "must", "exactly", "match", "the", "entire", "contents", "of", "the", "list", "item", "it", "is", "an", "exact", "match,", "not", "a", "partial", "match,", "of", "a", "row's", "content" ]

[ "'static", "int", "list_contains", "(", "char", "*", "word", ",", "size_t", "len", ",", "char", "*", "list", ")", "{", "char", "*", "w", ",", "<type", "ref=\"prev\">", "*", "w2", ";", "w", "=", "w2", "=", "list", ";", "do", "{", "for", "(", ";", "*", "w2", "&&", "*", "w2", "!=", "\\'\\\\r\\'", ";", "w2", "++", ")", ";", "if", "(", "w2", "-", "w", "==", "len", "&&", "!", "strncmp", "(", "word", ",", "w", ",", "len", ")", ")", "return", "1", ";", "if", "(", "*", "w2", ")", "w", "=", "++", "w2", ";", "}", "while", "(", "*", "w2", ")", ";", "return", "0", ";", "}'" ]

[ "MPI", "function", "that", "returns", "the", "reference", "of", "arg0", "as", "a", "#dbref", "This", "will", "always", "be", "a", "#dbref", "and", "doesn't", "return", "Playername", "like", "some", "calls", "(such", "as", "contents)" ]

[ "'const", "char", "*", "mfn_ref", "(", "MFUNARGS", ")", "{", "dbref", "obj", ";", "const", "char", "*", "p", "=", "argv", "[", "0", "]", ";", "skip_whitespace", "(", "&", "p", ")", ";", "if", "(", "*", "p", "==", "NUMBER_TOKEN", "&&", "number", "(", "p", "+", "1", ")", ")", "{", "obj", "=", "atoi", "(", "p", "+", "1", ")", ";", "}", "else", "{", "obj", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"REF\"", ",", "\"Permission", "denied.\"", ")", ";", "if", "(", "obj", "==", "UNKNOWN", ")", "obj", "=", "NOTHING", ";", "}", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"#%d\"", ",", "obj", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "filters", "one", "list", "by", "another", "list", "The", "list", "in", "arg0", "has", "any", "rows", "that", "match", "a", "row", "in", "arg1", "removed", "and", "the", "result", "is", "returned" ]

[ "'const", "char", "*", "mfn_lremove", "(", "MFUNARGS", ")", "{", "int", "iter_limit", "=", "MAX_MFUN_LIST_LEN", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ",", "<type", "ref=\"prev\">", "*", "endbuf", ";", "size_t", "len", ";", "int", "firstResult", "=", "1", ";", "ptr", "=", "argv", "[", "0", "]", ";", "/*", "the", "list", "we\\'re", "removing", "from", "*/", "endbuf", "=", "buf", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "/*", "empty", "buf;", "this", "is", "what", "we\\'re", "returning,", "I", "bet", "*/", "while", "(", "*", "ptr", ")", "{", "/*", "while", "more", "of", "the", "first", "list", "*/", "/*", "Find", "the", "next", "word.", "*/", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "*", "ptr2", "!=", "\\'\\\\r\\'", ";", "ptr2", "++", ")", ";", "len", "=", "(", "size_t", ")", "(", "ptr2", "-", "ptr", ")", ";", "/*", "If", "the", "second", "list", "contains", "the", "string,", "continue.", "*/", "if", "(", "!", "list_contains", "(", "ptr", ",", "len", ",", "argv", "[", "1", "]", ")", "&&", "/*", "*", "If", "it\\'s", "the", "first", "result,", "it", "already", "won\\'t", "be", "in", "buf.", "*", "This", "wouldn\\'t", "be", "a", "problem", "except", "buf", "already", "contains", "*", "the", "empty", "string,", "so", "if", "the", "first", "word", "to", "add", "is", "the", "*", "empty", "string,", "it", "won\\'t", "be", "added.", "*/", "(", "firstResult", "||", "!", "list_contains", "(", "ptr", ",", "len", ",", "buf", ")", ")", ")", "{", "if", "(", "firstResult", ")", "firstResult", "=", "0", ";", "else", "*", "(", "endbuf", "++", ")", "=", "\\'\\\\r\\'", ";", "strncpy", "(", "endbuf", ",", "ptr", ",", "len", ")", ";", "endbuf", "+=", "len", ";", "*", "endbuf", "=", "\\'\\\\0\\'", ";", "}", "/*", "Next", "word.", "*/", "if", "(", "*", "ptr2", ")", "ptr2", "++", ";", "ptr", "=", "ptr2", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"LREMOVE\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "escapes", "a", "string", "in", "backtick", "quotes", "This", "surrounds", "arg0", "in", "backticks", "(`)", "and", "escapes", "any", "backticks", "that", "are", "in", "the", "string", "using", "backslash" ]

[ "\"const", "char", "*", "mfn_escape", "(", "MFUNARGS", ")", "{", "/*", "*", "TODO:", "this", "MPI", "call", "is", "not", "documented", "in", "mpi", "escape", "*", "*", "Also,", "to", "be", "honest,", "I'm", "really", "not", "sure", "what", "the", "purpose", "behind", "*", "this", "call", "is.", "I", "mean,", "I", "can't", "fathom", "anything", "that", "just", "uses", "*", "`", "to", "enclose", "a", "string", "and", "needs", "escaping.", "We", "could", "make", "this", "*", "call", "more", "compelling", "by", "adding", "an", "optional", "arg1", "which", "is", "the", "*", "character", "to", "escape.", "(tanabi)", "*/", "char", "*", "out", ";", "const", "char", "*", "in", ";", "int", "done", "=", "0", ";", "in", "=", "argv", "[", "0", "]", ";", "out", "=", "buf", ";", "*", "out", "++", "=", "'`'", ";", "while", "(", "*", "in", "&&", "!", "done", ")", "{", "switch", "(", "*", "in", ")", "{", "case", "'\\\\\\\\'", ":", "case", "'`'", ":", "if", "(", "out", "-", "buf", ">=", "BUFFER_LEN", "-", "2", ")", "{", "done", "=", "1", ";", "break;", "}", "*", "out", "++", "=", "'\\\\\\\\'", ";", "*", "out", "++", "=", "*", "in", "++", ";", "break;", "default:", "if", "(", "out", "-", "buf", ">=", "BUFFER_LEN", "-", "1", ")", "{", "done", "=", "1", ";", "break;", "}", "*", "out", "++", "=", "*", "in", "++", ";", "}", "}", "*", "out", "++", "=", "'`'", ";", "*", "out", "=", "'\\\\0'", ";", "return", "buf", ";", "}\"" ]

[ "MPI", "function", "that", "does", "returns", "connection", "count", "for", "the", "given", "player", "If", "arg0", "isn't", "a", "player,", "this", "returns", "0,", "which", "is", "the", "same", "as", "if", "the", "a", "player", "is", "not", "connected" ]

[ "'const", "char", "*", "mfn_awake", "(", "MFUNARGS", ")", "{", "dbref", "obj", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "if", "(", "obj", "==", "PERMDENIED", "||", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", "||", "obj", "==", "NOTHING", "||", "obj", "==", "HOME", ")", "return", "(", "\"0\"", ")", ";", "if", "(", "Typeof", "(", "obj", ")", "==", "TYPE_THING", "&&", "(", "FLAGS", "(", "obj", ")", "&", "ZOMBIE", ")", ")", "{", "obj", "=", "OWNER", "(", "obj", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "Typeof", "(", "obj", ")", "!=", "TYPE_PLAYER", ")", "{", "return", "(", "\"0\"", ")", ";", "}", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "PLAYER_DESCRCOUNT", "(", "obj", ")", ")", ";", "return", "(", "buf", ")", ";", "}'" ]

[ "MPI", "function", "that", "adds", "ANSI", "attributes", "to", "a", "string", "This", "takes", "a", "variable", "number", "of", "arguments,", "with", "a", "minimum", "of", "two" ]

[ "'const", "char", "*", "mfn_attr", "(", "MFUNARGS", ")", "{", "int", "exlen", ";", "/*", "*", "TODO:", "A", "very", "similar", "statement", "is", "in", "p_strings.c.", "*", "*", "We", "should", "centralize", "this", "logic", "and", "have", "a", "function", "that", "adds", "*", "attributes", "to", "a", "buffer", "so", "this", "isn\\'t", "repeated", "in", "two", "places.", "*/", "buf", "[", "0", "]", "=", "\\'\\\\0\\'", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "argc", "-", "1", ";", "i", "++", ")", "{", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"reset\"", ")", "||", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"normal\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_RESET", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bold\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BOLD", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"dim\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_DIM", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"italic\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_ITALIC", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"uline\"", ")", "||", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"underline\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_UNDERLINE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"flash\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FLASH", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"reverse\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_REVERSE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"ostrike\"", ")", "||", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"overstrike\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_OSTRIKE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"black\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FG_BLACK", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"red\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FG_RED", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"yellow\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FG_YELLOW", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"green\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FG_GREEN", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"cyan\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FG_CYAN", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"blue\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FG_BLUE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"magenta\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FG_MAGENTA", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"white\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_FG_WHITE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bg_black\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BG_BLACK", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bg_red\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BG_RED", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bg_yellow\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BG_YELLOW", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bg_green\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BG_GREEN", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bg_cyan\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BG_CYAN", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bg_blue\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BG_BLUE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bg_magenta\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BG_MAGENTA", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"bg_white\"", ")", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_BG_WHITE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "i", "]", ",", "\"\"", ")", ")", "{", "}", "else", "{", "ABORT_MPI", "(", "\"ATTR\"", ",", "\"Unrecognized", "ansi", "tag.", "Try", "one", "of", "reset,", "bold,", "dim,", "italic,", "underline,", "flash,", "reverse,", "overstrike,", "black,", "red,", "green,", "yellow,", "blue,", "magenta,", "cyan,", "white,", "bg_black,", "bg_red,", "bg_green,", "bg_yellow,", "bg_blue,", "bg_magenta,", "bg_cyan,", "or", "bg_white.\"", ")", ";", "}", "}", "exlen", "=", "strlen", "(", "buf", ")", "+", "strlen", "(", "ANSI_RESET", ")", "+", "1", ";", "strncat", "(", "buf", ",", "argv", "[", "argc", "-", "1", "]", ",", "(", "BUFFER_LEN", "-", "exlen", ")", ")", ";", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ANSI_RESET", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "true", "if", "arg0", "is", "of", "type", "arg1", "arg1", "can", "be", "\"Room\",", "\"Player\",", "\"Exit\",", "\"Thing\",", "\"Program\",", "or", "\"Bad\"", "arg0", "should", "be", "something", "that", "resolves", "into", "an", "object" ]

[ "'const", "char", "*", "mfn_istype", "(", "MFUNARGS", ")", "{", "dbref", "obj", ";", "obj", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "if", "(", "obj", "==", "NOTHING", "||", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", ")", "return", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Bad\"", ")", "?", "\"0\"", ":", "\"1\"", ")", ";", "/*", "*", "TODO", "This", "check", "is", "redundant", "--", "it", "is", "identical", "to", "the", "above", "check", "*", "except", "it", "also", "adds", "perm", "denied.", "Delete", "this", "altogether,", "then", "*", "move", "the", "check", "for", "PERMDENIED", "(the", "next", "if", "statement)", "up", "to", "*", "the", "top", "because", "Bad", "shouldn\\'t", "bypass", "permission", "checks.", "*/", "if", "(", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Bad\"", ")", "==", "0", ")", "&&", "(", "obj", "==", "NOTHING", "||", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", "||", "obj", "==", "PERMDENIED", ")", ")", "return", "\"1\"", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"TYPE\"", ",", "\"Permission", "Denied.\"", ")", ";", "if", "(", "obj", "==", "HOME", ")", "return", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Room\"", ")", "?", "\"0\"", ":", "\"1\"", ")", ";", "switch", "(", "Typeof", "(", "obj", ")", ")", "{", "case", "TYPE_PLAYER", ":", "return", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Player\"", ")", "?", "\"0\"", ":", "\"1\"", ")", ";", "case", "TYPE_ROOM", ":", "return", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Room\"", ")", "?", "\"0\"", ":", "\"1\"", ")", ";", "case", "TYPE_EXIT", ":", "return", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Exit\"", ")", "?", "\"0\"", ":", "\"1\"", ")", ";", "case", "TYPE_THING", ":", "return", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Thing\"", ")", "?", "\"0\"", ":", "\"1\"", ")", ";", "case", "TYPE_PROGRAM", ":", "return", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Program\"", ")", "?", "\"0\"", ":", "\"1\"", ")", ";", "default:", "return", "(", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Bad\"", ")", "?", "\"0\"", ":", "\"1\"", ")", ";", "}", "}'" ]

[ "MPI", "function", "that", "takes", "a", "list,", "and", "evaluates", "a", "an", "expression", "with", "variables", "Arguments", "arg0", "and", "arg1", "are", "variable", "names;", "they", "will", "be", "populated", "with", "the", "first", "two", "items", "of", "the", "list", "provided", "in", "arg3" ]

[ "'const", "char", "*", "mfn_fold", "(", "MFUNARGS", ")", "{", "int", "iter_limit", "=", "MAX_MFUN_LIST_LEN", ";", "char", "varname", "[", "BUFFER_LEN", "]", ";", "char", "sepinbuf", "[", "BUFFER_LEN", "]", ";", "char", "listbuf", "[", "BUFFER_LEN", "]", ";", "char", "tmp", "[", "BUFFER_LEN", "]", ";", "char", "tmp2", "[", "BUFFER_LEN", "]", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ";", "char", "*", "sepin", "=", "argv", "[", "4", "]", ";", "size_t", "seplen", ";", "int", "v", ";", "/*", "*", "All", "of", "this", "is", "argument", "processing.", "*", "*", "Start", "with", "the", "first", "variable", "*/", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "varname", ",", "sizeof", "(", "varname", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FOLD\"", ",", "\"arg", "1\"", ")", ";", "v", "=", "new_mvar", "(", "ptr", ",", "tmp", ")", ";", "if", "(", "v", "==", "1", ")", "ABORT_MPI", "(", "\"FOLD\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "v", "==", "2", ")", "ABORT_MPI", "(", "\"FOLD\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "/*", "*", "Now", "the", "second", "variable.", "*/", "ptr", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "varname", ",", "sizeof", "(", "varname", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FOLD\"", ",", "\"arg", "2\"", ")", ";", "v", "=", "new_mvar", "(", "ptr", ",", "tmp2", ")", ";", "if", "(", "v", "==", "1", ")", "ABORT_MPI", "(", "\"FOLD\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "v", "==", "2", ")", "ABORT_MPI", "(", "\"FOLD\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "if", "(", "argc", ">", "4", ")", "{", "ptr", "=", "MesgParse", "(", "sepin", ",", "sepinbuf", ",", "sizeof", "(", "sepinbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FOLD\"", ",", "\"arg", "5\"", ")", ";", "if", "(", "!", "*", "ptr", ")", "ABORT_MPI", "(", "\"FOLD\"", ",", "\"Can\\'t", "use", "null", "separator", "string\"", ")", ";", "sepin", "=", "sepinbuf", ";", "}", "else", "{", "sepin", "=", "sepinbuf", ";", "strcpyn", "(", "sepin", ",", "sizeof", "(", "sepin", ")", ",", "\"\\\\r\"", ")", ";", "}", "seplen", "=", "strlen", "(", "sepin", ")", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "2", "]", ",", "listbuf", ",", "sizeof", "(", "listbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FOLD\"", ",", "\"arg", "3\"", ")", ";", "/*", "*", "This", "is", "a", "kind", "of", "clunky", "way", "to", "get", "the", "top", "couple", "of", "items.", "*", "*", "It", "feels", "like", "we\\'ve", "done", "this", "in", "a", "few", "places,", "but", "I", "think", "it", "*", "is", "done", "this", "way", "to", "avoid", "looping", "along", "the", "string", "twice", "as", "*", "would", "have", "to", "happen", "with", "a", "more", "generic", "string.", "*", "*", "Maybe", "we", "should", "alter", "the", "string", "get", "list", "item", "call", "to", "return", "*", "arrays", "of", "items?", "*/", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "strncmp", "(", "ptr2", ",", "sepin", ",", "seplen", ")", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", ")", "{", "*", "ptr2", "=", "\\'\\\\0\\'", ";", "ptr2", "+=", "seplen", ";", "}", "strcpyn", "(", "buf", ",", "buflen", ",", "ptr", ")", ";", "ptr", "=", "ptr2", ";", "while", "(", "*", "ptr", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "strncmp", "(", "ptr2", ",", "sepin", ",", "seplen", ")", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", ")", "{", "*", "ptr2", "=", "\\'\\\\0\\'", ";", "ptr2", "+=", "seplen", ";", "}", "strcpyn", "(", "tmp2", ",", "sizeof", "(", "tmp2", ")", ",", "ptr", ")", ";", "strcpyn", "(", "tmp", ",", "sizeof", "(", "tmp", ")", ",", "buf", ")", ";", "MesgParse", "(", "argv", "[", "3", "]", ",", "buf", ",", "buflen", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FOLD\"", ",", "\"arg", "4\"", ")", ";", "ptr", "=", "ptr2", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"FOLD\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "free_top_mvar", "()", ";", "free_top_mvar", "()", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "a", "list", "of", "exits", "associatd", "with", "arg0", "Returns", "the", "exits", "as", "a", "\\r", "delimited", "list", "of", "refs" ]

[ "'const", "char", "*", "mfn_exits", "(", "MFUNARGS", ")", "{", "size_t", "outlen", ",", "<type", "ref=\"prev\"/>", "nextlen", ";", "char", "buf2", "[", "50", "]", ";", "int", "list_limit", "=", "MAX_MFUN_LIST_LEN", ";", "dbref", "obj", "=", "mesg_dbref", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "if", "(", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", "||", "obj", "==", "NOTHING", "||", "obj", "==", "HOME", ")", "ABORT_MPI", "(", "\"EXITS\"", ",", "\"Match", "failed.\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"EXITS\"", ",", "\"Permission", "denied.\"", ")", ";", "switch", "(", "Typeof", "(", "obj", ")", ")", "{", "case", "TYPE_ROOM", ":", "case", "TYPE_THING", ":", "case", "TYPE_PLAYER", ":", "obj", "=", "EXITS", "(", "obj", ")", ";", "break;", "default:", "obj", "=", "NOTHING", ";", "break;", "}", "*", "buf", "=", "\\'\\\\0\\'", ";", "outlen", "=", "0", ";", "while", "(", "obj", "!=", "NOTHING", "&&", "list_limit", ")", "{", "ref2str", "(", "obj", ",", "buf2", ",", "sizeof", "(", "buf2", ")", ")", ";", "nextlen", "=", "strlen", "(", "buf2", ")", ";", "if", "(", "(", "outlen", "+", "nextlen", ")", ">=", "(", "BUFFER_LEN", "-", "3", ")", ")", "break;", "if", "(", "outlen", ")", "{", "strcatn", "(", "buf", "+", "outlen", ",", "BUFFER_LEN", "-", "outlen", ",", "\"\\\\r\"", ")", ";", "outlen", "++", ";", "}", "strcatn", "(", "(", "buf", "+", "outlen", ")", ",", "BUFFER_LEN", "-", "outlen", ",", "buf2", ")", ";", "outlen", "+=", "nextlen", ";", "list_limit", "--", ";", "obj", "=", "NEXTOBJ", "(", "obj", ")", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "times", "(and", "displays", "timing", "of)", "some", "MPI", "code", "When", "arg0", "completes,", "a", "timing", "message", "is", "displayed" ]

[ "'const", "char", "*", "mfn_timing", "(", "MFUNARGS", ")", "{", "/*", "*", "TODO:", "This", "function", "is", "not", "documented", "in", "\\'mpi", "timing\\'", "*/", "char", "*", "ptr", ";", "struct", "timeval", "start_time", ",", "<type", "ref=\"prev\"/>", "end_time", ";", "int", "secs", ";", "int", "usecs", ";", "double", "timelen", ";", "gettimeofday", "(", "&", "start_time", ",", "(", "struct", "timezone", "*", ")", "0", ")", ";", "ptr", "=", "mesg_parse", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "buf", ",", "BUFFER_LEN", ",", "mesgtyp", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"TIMING\"", ",", "\"arg", "1\"", ")", ";", "gettimeofday", "(", "&", "end_time", ",", "(", "struct", "timezone", "*", ")", "0", ")", ";", "secs", "=", "end_time", ".", "tv_sec", "-", "start_time", ".", "tv_sec", ";", "usecs", "=", "end_time", ".", "tv_usec", "-", "start_time", ".", "tv_usec", ";", "if", "(", "usecs", ">", "1000000", ")", "{", "secs", "+=", "1", ";", "usecs", "-=", "1000000", ";", "}", "timelen", "=", "(", "(", "double", ")", "secs", ")", "+", "(", "(", "(", "double", ")", "usecs", ")", "/", "1000000", ")", ";", "notifyf_nolisten", "(", "player", ",", "\"Time", "elapsed:", "%.6f", "seconds\"", ",", "timelen", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "runs", "an", "expression", "against", "every", "item", "in", "a", "list", "This", "operates", "in", "a", "variable", "context", "similar", "to", "{with}", "@see", "mfn_with", "@see", "mfn_foreach", "This", "is", "similar", "to", "{foreach}", "except", "it", "returns", "a", "list", "and", "is", "more", "for", "morphing", "a", "list", "rather", "than", "simply", "iterating", "over", "that", "list" ]

[ "'const", "char", "*", "mfn_parse", "(", "MFUNARGS", ")", "{", "int", "iter_limit", "=", "MAX_MFUN_LIST_LEN", ";", "char", "listbuf", "[", "BUFFER_LEN", "]", ";", "char", "sepinbuf", "[", "BUFFER_LEN", "]", ";", "char", "sepoutbuf", "[", "BUFFER_LEN", "]", ";", "char", "buf2", "[", "BUFFER_LEN", "]", ";", "char", "tmp", "[", "BUFFER_LEN", "]", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ",", "<type", "ref=\"prev\">", "*", "dptr", ";", "char", "*", "sepin", "=", "argv", "[", "3", "]", ";", "char", "*", "sepbuf", "=", "argv", "[", "4", "]", ";", "int", "outcount", "=", "0", ";", "size_t", "seplen", ",", "<type", "ref=\"prev\"/>", "oseplen", ";", "int", "v", ";", "size_t", "outlen", ",", "<type", "ref=\"prev\"/>", "nextlen", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "buf2", ",", "sizeof", "(", "buf2", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"PARSE\"", ",", "\"arg", "1\"", ")", ";", "v", "=", "new_mvar", "(", "ptr", ",", "tmp", ")", ";", "if", "(", "v", "==", "1", ")", "ABORT_MPI", "(", "\"PARSE\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "v", "==", "2", ")", "ABORT_MPI", "(", "\"PARSE\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "listbuf", ",", "sizeof", "(", "listbuf", ")", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"PARSE\"", ",", "\"arg", "2\"", ")", ";", "if", "(", "argc", ">", "3", ")", "{", "ptr", "=", "MesgParse", "(", "sepin", ",", "sepinbuf", ",", "sizeof", "(", "sepinbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"PARSE\"", ",", "\"arg", "4\"", ")", ";", "if", "(", "!", "*", "ptr", ")", "ABORT_MPI", "(", "\"PARSE\"", ",", "\"Can\\'t", "use", "null", "separator", "string\"", ")", ";", "sepin", "=", "sepinbuf", ";", "}", "else", "{", "sepin", "=", "sepinbuf", ";", "strcpyn", "(", "sepin", ",", "sizeof", "(", "sepinbuf", ")", ",", "\"\\\\r\"", ")", ";", "}", "if", "(", "argc", ">", "4", ")", "{", "ptr", "=", "MesgParse", "(", "sepbuf", ",", "sepoutbuf", ",", "sizeof", "(", "sepoutbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"PARSE\"", ",", "\"arg", "5\"", ")", ";", "sepbuf", "=", "sepoutbuf", ";", "}", "else", "{", "sepbuf", "=", "sepoutbuf", ";", "strcpyn", "(", "sepbuf", ",", "sizeof", "(", "sepoutbuf", ")", ",", "sepin", ")", ";", "}", "seplen", "=", "strlen", "(", "sepin", ")", ";", "oseplen", "=", "strlen", "(", "sepbuf", ")", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "outlen", "=", "0", ";", "ptr", "=", "dptr", ";", "while", "(", "*", "ptr", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "strncmp", "(", "ptr2", ",", "sepin", ",", "seplen", ")", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", ")", "{", "*", "ptr2", "=", "\\'\\\\0\\'", ";", "ptr2", "+=", "seplen", ";", "}", "strcpyn", "(", "tmp", ",", "sizeof", "(", "tmp", ")", ",", "ptr", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "2", "]", ",", "buf2", ",", "sizeof", "(", "buf2", ")", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"PARSE\"", ",", "\"arg", "3\"", ")", ";", "nextlen", "=", "strlen", "(", "buf2", ")", ";", "if", "(", "outlen", "+", "nextlen", "+", "oseplen", ">", "BUFFER_LEN", "-", "3", ")", "break;", "if", "(", "outcount", "++", ")", "{", "strcatn", "(", "buf", "+", "outlen", ",", "BUFFER_LEN", "-", "outlen", ",", "sepbuf", ")", ";", "outlen", "+=", "oseplen", ";", "}", "strcatn", "(", "(", "buf", "+", "outlen", ")", ",", "BUFFER_LEN", "-", "outlen", ",", "buf2", ")", ";", "outlen", "+=", "nextlen", ";", "ptr", "=", "ptr2", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"PARSE\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "free_top_mvar", "()", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "an", "optionally", "filtered", "contents", "list", "Returns", "the", "contents", "as", "a", "\\r", "delimited", "list", "of", "refs" ]

[ "'const", "char", "*", "mfn_contents", "(", "MFUNARGS", ")", "{", "char", "buf2", "[", "50", "]", ";", "int", "list_limit", "=", "MAX_MFUN_LIST_LEN", ";", "dbref", "obj", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "int", "typchk", ",", "<type", "ref=\"prev\"/>", "ownroom", ";", "size_t", "outlen", ",", "<type", "ref=\"prev\"/>", "nextlen", ";", "if", "(", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", "||", "obj", "==", "NOTHING", "||", "obj", "==", "HOME", ")", "ABORT_MPI", "(", "\"CONTENTS\"", ",", "\"Match", "failed.\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"CONTENTS\"", ",", "\"Permission", "denied.\"", ")", ";", "typchk", "=", "NOTYPE", ";", "if", "(", "argc", ">", "1", ")", "{", "if", "(", "!", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Room\"", ")", ")", "{", "typchk", "=", "TYPE_ROOM", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Exit\"", ")", ")", "{", "typchk", "=", "TYPE_EXIT", ";", "/*", "won\\'t", "find", "any,", "though", "*/", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Player\"", ")", ")", "{", "typchk", "=", "TYPE_PLAYER", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Program\"", ")", ")", "{", "typchk", "=", "TYPE_PROGRAM", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "!", "strcasecmp", "(", "argv", "[", "1", "]", ",", "\"Thing\"", ")", ")", "{", "typchk", "=", "TYPE_THING", ";", "}", "else", "{", "ABORT_MPI", "(", "\"CONTENTS\"", ",", "\"Type", "must", "be", "\\'player\\',", "\\'room\\',", "\\'thing\\',", "\\'program\\',", "or", "\"", "\"\\'exit\\'.", "(arg2).\"", ")", ";", "}", "}", "strcpyn", "(", "buf", ",", "buflen", ",", "\"\"", ")", ";", "outlen", "=", "0", ";", "ownroom", "=", "controls", "(", "perms", ",", "obj", ")", ";", "obj", "=", "CONTENTS", "(", "obj", ")", ";", "while", "(", "obj", "!=", "NOTHING", "&&", "list_limit", ")", "{", "/*", "*", "This", "if", "statement", "is", "a", "monster,", "but", "it", "does", "all", "the", "type", "*", "checking", "along", "with", "permission", "controls.", "*/", "if", "(", "(", "typchk", "==", "NOTYPE", "||", "Typeof", "(", "obj", ")", "==", "typchk", ")", "&&", "(", "ownroom", "||", "controls", "(", "perms", ",", "obj", ")", "||", "!", "(", "(", "FLAGS", "(", "obj", ")", "&", "DARK", ")", "||", "(", "FLAGS", "(", "LOCATION", "(", "obj", ")", ")", "&", "DARK", ")", "||", "(", "Typeof", "(", "obj", ")", "==", "TYPE_PROGRAM", "&&", "!", "(", "FLAGS", "(", "obj", ")", "&", "VEHICLE", ")", ")", ")", ")", "&&", "!", "(", "Typeof", "(", "obj", ")", "==", "TYPE_ROOM", "&&", "typchk", "!=", "TYPE_ROOM", ")", ")", "{", "ref2str", "(", "obj", ",", "buf2", ",", "sizeof", "(", "buf2", ")", ")", ";", "nextlen", "=", "strlen", "(", "buf2", ")", ";", "if", "(", "(", "outlen", "+", "nextlen", ")", ">=", "(", "BUFFER_LEN", "-", "3", ")", ")", "break;", "if", "(", "outlen", ")", "{", "strcatn", "(", "buf", "+", "outlen", ",", "BUFFER_LEN", "-", "outlen", ",", "\"\\\\r\"", ")", ";", "outlen", "++", ";", "}", "strcatn", "(", "(", "buf", "+", "outlen", ")", ",", "BUFFER_LEN", "-", "outlen", ",", "buf2", ")", ";", "outlen", "+=", "nextlen", ";", "list_limit", "--", ";", "}", "obj", "=", "NEXTOBJ", "(", "obj", ")", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "a", "version", "of", "arg0", "with", "all", "duplicate", "rows", "removed", "This", "will", "iterate", "up", "to", "MAX_MFUN_LIST_LEN", "times" ]

[ "'const", "char", "*", "mfn_lunique", "(", "MFUNARGS", ")", "{", "int", "iter_limit", "=", "MAX_MFUN_LIST_LEN", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ",", "<type", "ref=\"prev\">", "*", "p", ";", "int", "len", ";", "size_t", "outlen", ",", "<type", "ref=\"prev\"/>", "nextlen", ";", "int", "outcount", "=", "0", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "outlen", "=", "0", ";", "ptr", "=", "argv", "[", "0", "]", ";", "while", "(", "*", "ptr", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "*", "ptr2", "!=", "\\'\\\\r\\'", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", ")", "*", "(", "ptr2", "++", ")", "=", "\\'\\\\0\\'", ";", "len", "=", "strlen", "(", "ptr", ")", ";", "p", "=", "buf", ";", "do", "{", "if", "(", "string_prefix", "(", "p", ",", "ptr", ")", "&&", "(", "!", "p", "[", "len", "]", "||", "p", "[", "len", "]", "==", "\\'\\\\r\\'", ")", ")", "break;", "while", "(", "*", "p", "&&", "*", "p", "!=", "\\'\\\\r\\'", ")", "p", "++", ";", "if", "(", "*", "p", ")", "p", "++", ";", "}", "while", "(", "*", "p", ")", ";", "if", "(", "!", "*", "p", ")", "{", "nextlen", "=", "strlen", "(", "ptr", ")", ";", "if", "(", "outcount", "++", ")", "{", "strcatn", "(", "buf", "+", "outlen", ",", "BUFFER_LEN", "-", "outlen", ",", "\"\\\\r\"", ")", ";", "outlen", "++", ";", "}", "strcatn", "(", "(", "buf", "+", "outlen", ")", ",", "BUFFER_LEN", "-", "outlen", ",", "ptr", ")", ";", "outlen", "+=", "nextlen", ";", "}", "ptr", "=", "ptr2", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"LUNIQUE\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "a", "list", "that", "is", "arg0", "and", "arg1", "combined" ]

[ "'const", "char", "*", "mfn_lunion", "(", "MFUNARGS", ")", "{", "int", "iter_limit", "=", "MAX_MFUN_LIST_LEN", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ",", "<type", "ref=\"prev\">", "*", "p", ";", "int", "len", ";", "size_t", "outlen", ",", "<type", "ref=\"prev\"/>", "nextlen", ";", "int", "outcount", "=", "0", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "outlen", "=", "0", ";", "ptr", "=", "argv", "[", "0", "]", ";", "while", "(", "*", "ptr", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "*", "ptr2", "!=", "\\'\\\\r\\'", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", ")", "*", "(", "ptr2", "++", ")", "=", "\\'\\\\0\\'", ";", "len", "=", "strlen", "(", "ptr", ")", ";", "p", "=", "buf", ";", "do", "{", "if", "(", "string_prefix", "(", "p", ",", "ptr", ")", "&&", "(", "!", "p", "[", "len", "]", "||", "p", "[", "len", "]", "==", "\\'\\\\r\\'", ")", ")", "break;", "while", "(", "*", "p", "&&", "*", "p", "!=", "\\'\\\\r\\'", ")", "p", "++", ";", "if", "(", "*", "p", ")", "p", "++", ";", "}", "while", "(", "*", "p", ")", ";", "if", "(", "!", "*", "p", ")", "{", "nextlen", "=", "strlen", "(", "ptr", ")", ";", "if", "(", "outlen", "+", "nextlen", ">", "BUFFER_LEN", "-", "3", ")", "break;", "if", "(", "outcount", "++", ")", "{", "strcatn", "(", "buf", "+", "outlen", ",", "BUFFER_LEN", "-", "outlen", ",", "\"\\\\r\"", ")", ";", "outlen", "++", ";", "}", "strcatn", "(", "(", "buf", "+", "outlen", ")", ",", "BUFFER_LEN", "-", "outlen", ",", "ptr", ")", ";", "outlen", "+=", "nextlen", ";", "}", "ptr", "=", "ptr2", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"LUNION\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "ptr", "=", "argv", "[", "1", "]", ";", "while", "(", "*", "ptr", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "*", "ptr2", "!=", "\\'\\\\r\\'", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", ")", "*", "(", "ptr2", "++", ")", "=", "\\'\\\\0\\'", ";", "len", "=", "strlen", "(", "ptr", ")", ";", "p", "=", "buf", ";", "do", "{", "if", "(", "string_prefix", "(", "p", ",", "ptr", ")", "&&", "(", "!", "p", "[", "len", "]", "||", "p", "[", "len", "]", "==", "\\'\\\\r\\'", ")", ")", "break;", "while", "(", "*", "p", "&&", "*", "p", "!=", "\\'\\\\r\\'", ")", "p", "++", ";", "if", "(", "*", "p", ")", "p", "++", ";", "}", "while", "(", "*", "p", ")", ";", "if", "(", "!", "*", "p", ")", "{", "nextlen", "=", "strlen", "(", "ptr", ")", ";", "if", "(", "outlen", "+", "nextlen", ">", "BUFFER_LEN", "-", "3", ")", "break;", "if", "(", "outcount", "++", ")", "{", "strcatn", "(", "buf", "+", "outlen", ",", "BUFFER_LEN", "-", "outlen", ",", "\"\\\\r\"", ")", ";", "outlen", "++", ";", "}", "strcatn", "(", "(", "buf", "+", "outlen", ")", ",", "BUFFER_LEN", "-", "outlen", ",", "ptr", ")", ";", "outlen", "+=", "nextlen", ";", "}", "ptr", "=", "ptr2", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"LUNION\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "1", "if", "player", "controls", "arg0,", "0", "otherwise", "You", "can", "also", "provide", "arg1", "as", "an", "alternate", "player", "to", "check", "control", "permissions", "for,", "though", "the", "default", "is", "the", "calling", "player" ]

[ "'const", "char", "*", "mfn_controls", "(", "MFUNARGS", ")", "{", "dbref", "obj", ";", "dbref", "obj2", ";", "obj", "=", "mesg_dbref_raw", "(", "descr", ",", "player", ",", "what", ",", "argv", "[", "0", "]", ")", ";", "/*", "*", "TODO:", "I\\'m", "picking", "on", "this", "function,", "but", "many", "MPI", "functions", "have", "*", "a", "similar", "issue.", "There\\'s", "a", "lot", "of", "repeated", "use", "of", "the", "same", "*", "exact", "strings,", "and", "very", "similar", "checks.", "*", "*", "Unfortunately,", "there\\'s", "minor", "variations", "which", "make", "centralizing", "*", "the", "logic", "hard.", "*", "*", "At", "the", "very", "least,", "we", "should", "centralize", "common", "messages", "using", "*", "#define\\'s.", "We", "may", "be", "able", "to", "boil", "some", "of", "these", "if", "statements", "*", "to", "#defines", "as", "well.", "*", "*", "In", "a", "perfect", "world,", "we", "would", "have", "a", "handful", "of", "common", "entrypoint", "*", "functions", "that", "understand", "a", "certain", "specification", "(defined", "by", "*", "a", "string,", "struct,", "or", "bitvector", "flag),", "do", "the", "common", "checks,", "*", "and", "then", "hand", "off", "to", "the", "function", "that", "does", "the", "core", "logic.", "*", "This", "is", "a", "lot", "of", "work,", "though,", "and", "needs", "careful", "design", "to", "be", "*", "done", "right.", "*/", "if", "(", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "NOTHING", "||", "obj", "==", "UNKNOWN", ")", "ABORT_MPI", "(", "\"CONTROLS\"", ",", "\"Match", "failed.", "(arg1)\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"CONTROLS\"", ",", "\"Permission", "denied.", "(arg1)\"", ")", ";", "if", "(", "obj", "==", "HOME", ")", "obj", "=", "PLAYER_HOME", "(", "player", ")", ";", "if", "(", "argc", ">", "1", ")", "{", "obj2", "=", "mesg_dbref_raw", "(", "descr", ",", "player", ",", "what", ",", "argv", "[", "1", "]", ")", ";", "if", "(", "obj2", "==", "AMBIGUOUS", "||", "obj2", "==", "NOTHING", "||", "obj2", "==", "UNKNOWN", ")", "ABORT_MPI", "(", "\"CONTROLS\"", ",", "\"Match", "failed.", "(arg2)\"", ")", ";", "if", "(", "obj2", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"CONTROLS\"", ",", "\"Permission", "denied.", "(arg2)\"", ")", ";", "if", "(", "obj2", "==", "HOME", ")", "obj2", "=", "PLAYER_HOME", "(", "player", ")", ";", "obj2", "=", "OWNER", "(", "obj2", ")", ";", "}", "else", "{", "obj2", "=", "OWNER", "(", "perms", ")", ";", "}", "if", "(", "controls", "(", "obj2", ",", "obj", ")", ")", "{", "return", "\"1\"", ";", "}", "else", "{", "return", "\"0\"", ";", "}", "}'" ]

[ "MPI", "function", "that", "does", "a", "string", "substitution", "Substitutes", "all", "instances", "of", "arg1", "with", "arg2", "in", "arg0", "@see", "string_substitute" ]

[ "'const", "char", "*", "mfn_subst", "(", "MFUNARGS", ")", "{", "return", "string_substitute", "(", "argv", "[", "0", "]", ",", "argv", "[", "1", "]", ",", "argv", "[", "2", "]", ",", "buf", ",", "BUFFER_LEN", ")", ";", "}'" ]

[ "MPI", "function", "that", "returns", "the", "ref", "of", "the", "player", "that", "owns", "arg0" ]

[ "'const", "char", "*", "mfn_owner", "(", "MFUNARGS", ")", "{", "dbref", "obj", ";", "obj", "=", "mesg_dbref_raw", "(", "descr", ",", "player", ",", "what", ",", "argv", "[", "0", "]", ")", ";", "if", "(", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "NOTHING", "||", "obj", "==", "UNKNOWN", ")", "ABORT_MPI", "(", "\"OWNER\"", ",", "\"Failed", "match.\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"OWNER\"", ",", "\"Permission", "denied.\"", ")", ";", "if", "(", "obj", "==", "HOME", ")", "obj", "=", "PLAYER_HOME", "(", "player", ")", ";", "return", "ref2str", "(", "OWNER", "(", "obj", ")", ",", "buf", ",", "BUFFER_LEN", ")", ";", "}'" ]

[ "MPI", "function", "that", "does", "a", "regex", "match", "of", "pattern", "arg1", "against", "string", "arg0", "Just", "a", "thin", "wrapper", "around", "equalstr", "@see", "equalstr" ]

[ "'const", "char", "*", "mfn_smatch", "(", "MFUNARGS", ")", "{", "if", "(", "equalstr", "(", "argv", "[", "1", "]", ",", "argv", "[", "0", "]", ")", ")", "{", "return", "\"1\"", ";", "}", "else", "{", "return", "\"0\"", ";", "}", "}'" ]

[ "MPI", "function", "that", "returns", "the", "name", "of", "arg0", "The", "name", "is", "left", "intact", "in", "case", "of", "exits" ]

[ "'const", "char", "*", "mfn_fullname", "(", "MFUNARGS", ")", "{", "/*", "*", "TODO:", "This", "is", "a", "copy/paste", "of", "mfn_name", "with", "the", "exit", "truncation", "code", "*", "taken", "out.", "Much", "as", "I", "dislike", "thin", "wrappers,", "I", "would", "suggest", "*", "these", "both", "run", "the", "same", "underlying", "code", "and", "be", "thin", "wrappers", "*", "around", "a", "common", "function.", "Since", "we", "need", "function", "pointer", "refs,", "*", "we", "can\\'t", "turn", "these", "into", "#defines.", "*/", "dbref", "obj", "=", "mesg_dbref_raw", "(", "descr", ",", "player", ",", "what", ",", "argv", "[", "0", "]", ")", ";", "if", "(", "obj", "==", "UNKNOWN", ")", "ABORT_MPI", "(", "\"NAME\"", ",", "\"Match", "failed.\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"NAME\"", ",", "\"Permission", "denied.\"", ")", ";", "if", "(", "obj", "==", "NOTHING", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "\"#NOTHING#\"", ")", ";", "return", "buf", ";", "}", "if", "(", "obj", "==", "AMBIGUOUS", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "\"#AMBIGUOUS#\"", ")", ";", "return", "buf", ";", "}", "if", "(", "obj", "==", "HOME", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "\"#HOME#\"", ")", ";", "return", "buf", ";", "}", "strcpyn", "(", "buf", ",", "buflen", ",", "NAME", "(", "obj", ")", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "finds", "an", "item", "in", "a", "list", "arg0", "is", "the", "list", "to", "search,", "arg1", "is", "the", "item", "to", "find" ]

[ "'const", "char", "*", "mfn_lmember", "(", "MFUNARGS", ")", "{", "/*", "{lmember:list,item,delim}", "*/", "int", "i", "=", "1", ";", "char", "*", "ptr", "=", "argv", "[", "0", "]", ";", "char", "*", "delim", "=", "NULL", ";", "int", "len", ";", "int", "len2", "=", "strlen", "(", "argv", "[", "1", "]", ")", ";", "if", "(", "argc", "<", "3", ")", "delim", "=", "\"\\\\r\"", ";", "else", "delim", "=", "argv", "[", "2", "]", ";", "if", "(", "!", "*", "delim", ")", "ABORT_MPI", "(", "\"LMEMBER\"", ",", "\"List", "delimiter", "cannot", "be", "a", "null", "string.\"", ")", ";", "len", "=", "strlen", "(", "delim", ")", ";", "while", "(", "*", "ptr", "&&", "!", "(", "string_prefix", "(", "ptr", ",", "argv", "[", "1", "]", ")", "&&", "(", "!", "ptr", "[", "len2", "]", "||", "string_prefix", "(", "ptr", "+", "len2", ",", "delim", ")", ")", ")", ")", "{", "while", "(", "*", "ptr", "&&", "!", "string_prefix", "(", "ptr", ",", "delim", ")", ")", "ptr", "++", ";", "if", "(", "*", "ptr", ")", "ptr", "+=", "len", ";", "i", "++", ";", "}", "if", "(", "!", "*", "ptr", ")", "return", "\"0\"", ";", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "i", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "uppercases", "arg0" ]

[ "'const", "char", "*", "mfn_toupper", "(", "MFUNARGS", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "argv", "[", "0", "]", ")", ";", "toupper_string", "(", "&", "buf", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "defines", "a", "variable", "context", "MPI", "is", "kind", "of", "weird", "and", "variables", "run", "within", "a", "context", "in", "the", "format", "of:", "{with:var_name,", "var_value,", "code", "to", "run" ]

[ "'const", "char", "*", "mfn_with", "(", "MFUNARGS", ")", "{", "char", "namebuf", "[", "BUFFER_LEN", "]", ";", "char", "cmdbuf", "[", "BUFFER_LEN", "]", ";", "char", "vbuf", "[", "BUFFER_LEN", "]", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "valptr", ";", "int", "v", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "namebuf", ",", "sizeof", "(", "namebuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"WITH\"", ",", "\"arg", "1\"", ")", ";", "valptr", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "vbuf", ",", "sizeof", "(", "vbuf", ")", ")", ";", "CHECKRETURN", "(", "valptr", ",", "\"WITH\"", ",", "\"arg", "2\"", ")", ";", "v", "=", "new_mvar", "(", "ptr", ",", "vbuf", ")", ";", "if", "(", "v", "==", "1", ")", "ABORT_MPI", "(", "\"WITH\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "v", "==", "2", ")", "ABORT_MPI", "(", "\"WITH\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "for", "(", "int", "cnt", "=", "2", ";", "cnt", "<", "argc", ";", "cnt", "++", ")", "{", "ptr", "=", "MesgParse", "(", "argv", "[", "cnt", "]", ",", "cmdbuf", ",", "sizeof", "(", "cmdbuf", ")", ")", ";", "if", "(", "!", "ptr", ")", "{", "notifyf", "(", "player", ",", "\"%s", "%cWITH%c", "(arg", "%d)\"", ",", "get_mvar", "(", "\"how\"", ")", ",", "MFUN_LEADCHAR", ",", "MFUN_ARGEND", ",", "cnt", ")", ";", "return", "NULL", ";", "}", "}", "free_top_mvar", "()", ";", "return", "ptr", ";", "}'" ]

[ "MPI", "function", "that", "runs", "code", "in", "debug", "mode", "if", "the", "conditional", "returns", "true", "arg0", "is", "the", "conditional", "expression" ]

[ "'const", "char", "*", "mfn_debugif", "(", "MFUNARGS", ")", "{", "char", "*", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "buf", ",", "buflen", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"DEBUGIF\"", ",", "\"arg", "1\"", ")", ";", "if", "(", "truestr", "(", "argv", "[", "0", "]", ")", ")", "{", "ptr", "=", "mesg_parse", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "1", "]", ",", "buf", ",", "BUFFER_LEN", ",", "(", "mesgtyp", "|", "MPI_ISDEBUG", ")", ")", ";", "}", "else", "{", "ptr", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "buf", ",", "buflen", ")", ";", "}", "CHECKRETURN", "(", "ptr", ",", "\"DEBUGIF\"", ",", "\"arg", "2\"", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "a", "substring", "Takes", "a", "string", "in", "arg0" ]

[ "'const", "char", "*", "mfn_midstr", "(", "MFUNARGS", ")", "{", "int", "len", "=", "strlen", "(", "argv", "[", "0", "]", ")", ";", "int", "pos1", "=", "atoi", "(", "argv", "[", "1", "]", ")", ";", "int", "pos2", "=", "pos1", ";", "char", "*", "ptr", "=", "buf", ";", "if", "(", "argc", ">", "2", ")", "pos2", "=", "atoi", "(", "argv", "[", "2", "]", ")", ";", "if", "(", "pos1", "==", "0", ")", "return", "\"\"", ";", "if", "(", "pos1", ">", "len", ")", "pos1", "=", "len", ";", "if", "(", "pos1", "<", "0", ")", "pos1", "+=", "len", "+", "1", ";", "if", "(", "pos1", "<", "1", ")", "pos1", "=", "1", ";", "if", "(", "pos2", "==", "0", ")", "return", "\"\"", ";", "if", "(", "pos2", ">", "len", ")", "pos2", "=", "len", ";", "if", "(", "pos2", "<", "0", ")", "pos2", "+=", "len", "+", "1", ";", "if", "(", "pos2", "<", "1", ")", "pos2", "=", "1", ";", "/*", "Are", "we", "going", "backwards", "or", "forwards?", "*/", "if", "(", "pos2", ">=", "pos1", ")", "{", "for", "(", "int", "i", "=", "pos1", ";", "i", "<=", "pos2", ";", "i", "++", ")", "*", "(", "ptr", "++", ")", "=", "argv", "[", "0", "]", "[", "i", "-", "1", "]", ";", "}", "else", "{", "for", "(", "int", "i", "=", "pos1", ";", "i", ">=", "pos2", ";", "i", "--", ")", "*", "(", "ptr", "++", ")", "=", "argv", "[", "0", "]", "[", "i", "-", "1", "]", ";", "}", "*", "ptr", "=", "\\'\\\\0\\'", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "runs", "an", "expression", "against", "every", "item", "in", "a", "list", "and", "filters", "This", "operates", "in", "a", "variable", "context", "similar", "to", "{with}", "@see", "mfn_with", "@see", "mfn_foreach", "This", "is", "similar", "to", "{foreach}", "except", "it", "returns", "a", "list", "and", "is", "more", "for", "morphing", "a", "list", "rather", "than", "simply", "iterating", "over", "that", "list" ]

[ "'const", "char", "*", "mfn_filter", "(", "MFUNARGS", ")", "{", "int", "iter_limit", "=", "MAX_MFUN_LIST_LEN", ";", "char", "scratch", "[", "BUFFER_LEN", "]", ";", "char", "listbuf", "[", "BUFFER_LEN", "]", ";", "char", "sepinbuf", "[", "BUFFER_LEN", "]", ";", "char", "sepoutbuf", "[", "BUFFER_LEN", "]", ";", "char", "buf2", "[", "BUFFER_LEN", "]", ";", "char", "tmp", "[", "BUFFER_LEN", "]", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ",", "<type", "ref=\"prev\">", "*", "dptr", ";", "char", "*", "sepin", "=", "argv", "[", "3", "]", ";", "char", "*", "sepbuf", "=", "argv", "[", "4", "]", ";", "size_t", "seplen", ";", "int", "v", ";", "int", "outcount", "=", "0", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FILTER\"", ",", "\"arg", "1\"", ")", ";", "v", "=", "new_mvar", "(", "ptr", ",", "tmp", ")", ";", "/*", "*", "TODO:", "these", "exact", "variable", "checks", "are", "done", "in", "every", "single", "*", "function", "that", "handles", "variables.", "This", "should", "probably", "*", "just", "be", "a", "#define", "that", "is", "shared", "by", "all", "the", "calls.", "Searching", "*", "for", "new_mvar", "in", "this", "file", "will", "quickly", "find", "all", "the", "places", "*", "where", "this", "shows", "up.", "*", "*", "I", "think", "new_mvar", "is", "used", "in", "a", "few", "other", "files", "as", "well,", "so,", "*", "perhaps", "the", "define", "should", "be", "in", "the", "same", "fiel", "as", "new_mvar", "*", "so", "it", "can", "be", "shared?", "Some", "examination", "should", "be", "done", "to", "see", "*", "what", "makes", "the", "most", "sense,", "but", "this", "code", "duplication", "sucks.", "*/", "if", "(", "v", "==", "1", ")", "ABORT_MPI", "(", "\"FILTER\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "v", "==", "2", ")", "ABORT_MPI", "(", "\"FILTER\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "listbuf", ",", "sizeof", "(", "listbuf", ")", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"FILTER\"", ",", "\"arg", "2\"", ")", ";", "if", "(", "argc", ">", "3", ")", "{", "ptr", "=", "MesgParse", "(", "sepin", ",", "sepinbuf", ",", "sizeof", "(", "sepinbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FILTER\"", ",", "\"arg", "4\"", ")", ";", "if", "(", "!", "*", "ptr", ")", "ABORT_MPI", "(", "\"FILTER\"", ",", "\"Can\\'t", "use", "null", "separator", "string\"", ")", ";", "sepin", "=", "sepinbuf", ";", "}", "else", "{", "sepin", "=", "sepinbuf", ";", "strcpyn", "(", "sepin", ",", "sizeof", "(", "sepinbuf", ")", ",", "\"\\\\r\"", ")", ";", "}", "if", "(", "argc", ">", "4", ")", "{", "ptr", "=", "MesgParse", "(", "sepbuf", ",", "sepoutbuf", ",", "sizeof", "(", "sepoutbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FILTER\"", ",", "\"arg", "5\"", ")", ";", "sepbuf", "=", "sepoutbuf", ";", "}", "else", "{", "sepbuf", "=", "sepoutbuf", ";", "strcpyn", "(", "sepbuf", ",", "sizeof", "(", "sepoutbuf", ")", ",", "sepin", ")", ";", "}", "seplen", "=", "strlen", "(", "sepin", ")", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "ptr", "=", "dptr", ";", "/*", "*", "TODO:", "So", "a", "lot", "of", "these", "iterator", "functions", "use", "this", "kind", "of", "*", "structure.", "It", "would", "be", "cool", "if", "we", "could", "make", "some", "kind", "*", "of", "C", "\\'generator\\'", "function", "that", "would", "just", "return", "list", "items", "*", "so", "we", "could", "do", "like:", "*", "*", "while", "(item", "=", "next_item(input_str,", "&idx_ptr))", "{", "*", "//", "business", "logic", "*", "}", "*", "*", "that", "would", "kill", "most", "of", "the", "duplicate", "code", "and", "the", "funny", "*", "inline", "for", "statements.", "It", "would", "also", "work", "great", "for", "the", "*", "\\'fold\\'", "case.", "*/", "while", "(", "*", "ptr", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "strncmp", "(", "ptr2", ",", "sepin", ",", "seplen", ")", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", ")", "{", "*", "ptr2", "=", "\\'\\\\0\\'", ";", "ptr2", "+=", "seplen", ";", "}", "strcpyn", "(", "tmp", ",", "sizeof", "(", "tmp", ")", ",", "ptr", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "2", "]", ",", "buf2", ",", "sizeof", "(", "buf2", ")", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"FILTER\"", ",", "\"arg", "3\"", ")", ";", "if", "(", "truestr", "(", "buf2", ")", ")", "{", "if", "(", "outcount", "++", ")", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "sepbuf", ")", ";", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ptr", ")", ";", "}", "ptr", "=", "ptr2", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"FILTER\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "free_top_mvar", "()", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "the", "contents", "of", "a", "variable", "arg0" ]

[ "'const", "char", "*", "mfn_v", "(", "MFUNARGS", ")", "{", "char", "*", "ptr", "=", "get_mvar", "(", "argv", "[", "0", "]", ")", ";", "if", "(", "!", "ptr", ")", "ABORT_MPI", "(", "\"V\"", ",", "\"No", "such", "variable", "defined.\"", ")", ";", "return", "ptr", ";", "}'" ]

[ "MPI", "function", "that", "set", "the", "contents", "of", "a", "variable", "arg0", "to", "arg1", "Variable", "must", "be", "defined", "first", "in", "the", "current", "context,", "which", "is", "done", "with", "{with}", "or", "with", "certain", "functions", "that", "support", "variables", "such", "as", "some", "of", "the", "loops" ]

[ "'const", "char", "*", "mfn_set", "(", "MFUNARGS", ")", "{", "char", "*", "ptr", "=", "get_mvar", "(", "argv", "[", "0", "]", ")", ";", "if", "(", "!", "ptr", ")", "ABORT_MPI", "(", "\"SET\"", ",", "\"No", "such", "variable", "currently", "defined.\"", ")", ";", "strcpyn", "(", "ptr", ",", "BUFFER_LEN", ",", "argv", "[", "1", "]", ")", ";", "return", "ptr", ";", "}'" ]

[ "MPI", "function", "that", "does", "a", "foreach", "loop", "This", "operates", "in", "a", "variable", "context", "similar", "to", "{with}", "@see", "mfn_with", "@see", "mfn_for", "This", "iterates", "over", "every", "item", "in", "a", "list,", "storing", "that", "list", "item", "in", "a", "variable", "that", "is", "available", "to", "the", "executed", "code" ]

[ "'const", "char", "*", "mfn_foreach", "(", "MFUNARGS", ")", "{", "int", "iter_limit", "=", "MAX_MFUN_LIST_LEN", ";", "char", "scratch", "[", "BUFFER_LEN", "]", ";", "char", "listbuf", "[", "BUFFER_LEN", "]", ";", "char", "tmp", "[", "BUFFER_LEN", "]", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ",", "<type", "ref=\"prev\">", "*", "dptr", ";", "char", "*", "sepin", ";", "size_t", "seplen", ";", "int", "v", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FOREACH\"", ",", "\"arg", "1\"", ")", ";", "v", "=", "new_mvar", "(", "ptr", ",", "tmp", ")", ";", "if", "(", "v", "==", "1", ")", "ABORT_MPI", "(", "\"FOREACH\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "v", "==", "2", ")", "ABORT_MPI", "(", "\"FOREACH\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "listbuf", ",", "sizeof", "(", "listbuf", ")", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"FOREACH\"", ",", "\"arg", "2\"", ")", ";", "if", "(", "argc", ">", "3", ")", "{", "ptr", "=", "MesgParse", "(", "argv", "[", "3", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FOREACH\"", ",", "\"arg", "4\"", ")", ";", "if", "(", "!", "*", "ptr", ")", "ABORT_MPI", "(", "\"FOREACH\"", ",", "\"Can\\'t", "use", "null", "separator", "string\"", ")", ";", "sepin", "=", "ptr", ";", "}", "else", "{", "sepin", "=", "scratch", ";", "strcpyn", "(", "sepin", ",", "sizeof", "(", "scratch", ")", ",", "\"\\\\r\"", ")", ";", "}", "seplen", "=", "strlen", "(", "sepin", ")", ";", "ptr", "=", "dptr", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "while", "(", "*", "ptr", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "strncmp", "(", "ptr2", ",", "sepin", ",", "seplen", ")", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", ")", "{", "*", "ptr2", "=", "\\'\\\\0\\'", ";", "ptr2", "+=", "seplen", ";", "}", "strcpyn", "(", "tmp", ",", "sizeof", "(", "tmp", ")", ",", "ptr", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "2", "]", ",", "buf", ",", "buflen", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"FOREACH\"", ",", "\"arg", "3\"", ")", ";", "ptr", "=", "ptr2", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"FOREACH\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "free_top_mvar", "()", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "a", "sorted", "version", "of", "arg0", "The", "list", "is", "provided", "in", "arg0" ]

[ "'const", "char", "*", "mfn_lsort", "(", "MFUNARGS", ")", "{", "char", "*", "litem", "[", "MAX_MFUN_LIST_LEN", "]", ";", "char", "listbuf", "[", "BUFFER_LEN", "]", ";", "char", "scratch", "[", "BUFFER_LEN", "]", ";", "char", "vbuf", "[", "BUFFER_LEN", "]", ";", "char", "vbuf2", "[", "BUFFER_LEN", "]", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ",", "<type", "ref=\"prev\">", "*", "tmp", ";", "int", "j", ",", "<type", "ref=\"prev\"/>", "count", ";", "int", "outcount", "=", "0", ";", "if", "(", "argc", ">", "1", "&&", "argc", "<", "4", ")", "ABORT_MPI", "(", "\"LSORT\"", ",", "\"Takes", "1", "or", "4", "arguments.\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "MAX_MFUN_LIST_LEN", ";", "i", "++", ")", "litem", "[", "i", "]", "=", "NULL", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "listbuf", ",", "sizeof", "(", "listbuf", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"LSORT\"", ",", "\"arg", "1\"", ")", ";", "/*", "Process", "custom", "function", "call", "parameters", "*/", "if", "(", "argc", ">", "1", ")", "{", "ptr2", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "ptr2", ",", "\"LSORT\"", ",", "\"arg", "2\"", ")", ";", "j", "=", "new_mvar", "(", "ptr2", ",", "vbuf", ")", ";", "if", "(", "j", "==", "1", ")", "ABORT_MPI", "(", "\"LSORT\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "j", "==", "2", ")", "ABORT_MPI", "(", "\"LSORT\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "ptr2", "=", "MesgParse", "(", "argv", "[", "2", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "ptr2", ",", "\"LSORT\"", ",", "\"arg", "3\"", ")", ";", "j", "=", "new_mvar", "(", "ptr2", ",", "vbuf2", ")", ";", "if", "(", "j", "==", "1", ")", "ABORT_MPI", "(", "\"LSORT\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "j", "==", "2", ")", "ABORT_MPI", "(", "\"LSORT\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "}", "count", "=", "0", ";", "while", "(", "*", "ptr", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "*", "ptr2", "!=", "\\'\\\\r\\'", ";", "ptr2", "++", ")", ";", "if", "(", "*", "ptr2", "==", "\\'\\\\r\\'", ")", "*", "(", "ptr2", "++", ")", "=", "\\'\\\\0\\'", ";", "litem", "[", "count", "++", "]", "=", "ptr", ";", "ptr", "=", "ptr2", ";", "if", "(", "count", ">=", "MAX_MFUN_LIST_LEN", ")", "ABORT_MPI", "(", "\"LSORT\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "/*", "Iteratve", "over", "list", "*/", "for", "(", "int", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "for", "(", "j", "=", "i", "+", "1", ";", "j", "<", "count", ";", "j", "++", ")", "{", "if", "(", "argc", ">", "1", ")", "{", "/*", "Custom", "comparison", "*/", "strcpyn", "(", "vbuf", ",", "sizeof", "(", "vbuf", ")", ",", "litem", "[", "i", "]", ")", ";", "strcpyn", "(", "vbuf2", ",", "sizeof", "(", "vbuf2", ")", ",", "litem", "[", "j", "]", ")", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "3", "]", ",", "buf", ",", "buflen", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"LSORT\"", ",", "\"arg", "4\"", ")", ";", "if", "(", "truestr", "(", "buf", ")", ")", "{", "tmp", "=", "litem", "[", "i", "]", ";", "litem", "[", "i", "]", "=", "litem", "[", "j", "]", ";", "litem", "[", "j", "]", "=", "tmp", ";", "}", "}", "else", "{", "/*", "Default", "comparison", "*/", "if", "(", "alphanum_compare", "(", "litem", "[", "i", "]", ",", "litem", "[", "j", "]", ")", ">", "0", ")", "{", "tmp", "=", "litem", "[", "i", "]", ";", "litem", "[", "i", "]", "=", "litem", "[", "j", "]", ";", "litem", "[", "j", "]", "=", "tmp", ";", "}", "}", "}", "}", "*", "buf", "=", "\\'\\\\0\\'", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "if", "(", "outcount", "++", ")", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "\"\\\\r\"", ")", ";", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "litem", "[", "i", "]", ")", ";", "}", "if", "(", "argc", ">", "1", ")", "{", "free_top_mvar", "()", ";", "free_top_mvar", "()", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "puts", "some", "MPI", "on", "the", "timequeue", "to", "run", "after", "a", "bit", "arg0", "is", "the", "number", "of", "seconds", "to", "wait", "before", "execution" ]

[ "'const", "char", "*", "mfn_delay", "(", "MFUNARGS", ")", "{", "char", "*", "argchr", ",", "<type", "ref=\"prev\">", "*", "cmdchr", ";", "int", "i", "=", "atoi", "(", "argv", "[", "0", "]", ")", ";", "if", "(", "i", "<", "1", ")", "i", "=", "1", ";", "if", "(", "i", ">", "31622400", ")", "ABORT_MPI", "(", "\"DELAY\"", ",", "\"Delaying", "more", "than", "a", "year", "in", "MPI", "is", "just", "silly.\"", ")", ";", "#", "ifdef", "WIZZED_DELAY", "if", "(", "!", "(", "mesgtyp", "&", "MPI_ISBLESSED", ")", ")", "ABORT_MPI", "(", "\"DELAY\"", ",", "\"Permission", "denied.\"", ")", ";", "#", "endif", "cmdchr", "=", "get_mvar", "(", "\"cmd\"", ")", ";", "argchr", "=", "get_mvar", "(", "\"arg\"", ")", ";", "i", "=", "add_mpi_event", "(", "i", ",", "descr", ",", "player", ",", "LOCATION", "(", "player", ")", ",", "perms", ",", "argv", "[", "1", "]", ",", "cmdchr", ",", "argchr", ",", "(", "mesgtyp", "&", "MPI_ISLISTENER", ")", ",", "(", "!", "(", "mesgtyp", "&", "MPI_ISPRIVATE", ")", ")", ",", "(", "mesgtyp", "&", "MPI_ISBLESSED", ")", ")", ";", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "i", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "does", "a", "for", "loop", "This", "operates", "in", "a", "variable", "context", "similar", "to", "{with}", "@see", "mfn_with", "arg0", "is", "the", "variable", "name", "to", "use" ]

[ "'const", "char", "*", "mfn_for", "(", "MFUNARGS", ")", "{", "int", "iter_limit", "=", "MAX_MFUN_LIST_LEN", ";", "char", "scratch", "[", "BUFFER_LEN", "]", ";", "char", "tmp", "[", "BUFFER_LEN", "]", ";", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "dptr", ";", "int", "v", ",", "<type", "ref=\"prev\"/>", "start", ",", "<type", "ref=\"prev\"/>", "end", ",", "<type", "ref=\"prev\"/>", "incr", ";", "ptr", "=", "MesgParse", "(", "argv", "[", "0", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"FOR\"", ",", "\"arg", "1", "(varname)\"", ")", ";", "v", "=", "new_mvar", "(", "ptr", ",", "tmp", ")", ";", "if", "(", "v", "==", "1", ")", "ABORT_MPI", "(", "\"FOR\"", ",", "\"Variable", "name", "too", "long.\"", ")", ";", "if", "(", "v", "==", "2", ")", "ABORT_MPI", "(", "\"FOR\"", ",", "\"Too", "many", "variables", "already", "defined.\"", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "1", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"FOR\"", ",", "\"arg", "2", "(start", "num)\"", ")", ";", "start", "=", "atoi", "(", "dptr", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "2", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"FOR\"", ",", "\"arg", "3", "(end", "num)\"", ")", ";", "end", "=", "atoi", "(", "dptr", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "3", "]", ",", "scratch", ",", "sizeof", "(", "scratch", ")", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"FOR\"", ",", "\"arg", "4", "(increment)\"", ")", ";", "incr", "=", "atoi", "(", "dptr", ")", ";", "*", "buf", "=", "\\'\\\\0\\'", ";", "for", "(", "int", "i", "=", "start", ";", "(", "(", "incr", ">=", "0", "&&", "i", "<=", "end", ")", "||", "(", "incr", "<", "0", "&&", "i", ">=", "end", ")", ")", ";", "i", "+=", "incr", ")", "{", "snprintf", "(", "tmp", ",", "sizeof", "(", "tmp", ")", ",", "\"%d\"", ",", "i", ")", ";", "dptr", "=", "MesgParse", "(", "argv", "[", "4", "]", ",", "buf", ",", "buflen", ")", ";", "CHECKRETURN", "(", "dptr", ",", "\"FOR\"", ",", "\"arg", "5", "(repeated", "command)\"", ")", ";", "if", "(", "!", "(", "--", "iter_limit", ")", ")", "ABORT_MPI", "(", "\"FOR\"", ",", "\"Iteration", "limit", "exceeded\"", ")", ";", "}", "free_top_mvar", "()", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "does", "returns", "a", "text", "description", "of", "the", "object", "arg0", "Returns", "\"Room\",", "\"Player\",", "\"Exit\",", "\"Thing\",", "\"Program\",", "or", "\"Bad\"", "based", "on", "the", "object", "type" ]

[ "'const", "char", "*", "mfn_type", "(", "MFUNARGS", ")", "{", "dbref", "obj", "=", "mesg_dbref_local", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "mesgtyp", ")", ";", "/*", "*", "TODO:", "This", "seems", "like", "its", "duplicated", "in", "a", "number", "of", "places.", "*", "The", "\\'examine\\'", "command", "for", "instance", "does", "something", "very", "*", "similar.", "Can", "we", "centralize", "this", "logic?", "*", "*", "Doing", "a", "grep", "case", "TYPE_", "reveals", "331", "results.", "Not", "all", "of", "them", "*", "are", "this", "exact", "thing,", "but", "some", "are", "close.", "*/", "if", "(", "obj", "==", "NOTHING", "||", "obj", "==", "AMBIGUOUS", "||", "obj", "==", "UNKNOWN", ")", "return", "(", "\"Bad\"", ")", ";", "if", "(", "obj", "==", "HOME", ")", "return", "(", "\"Room\"", ")", ";", "if", "(", "obj", "==", "PERMDENIED", ")", "ABORT_MPI", "(", "\"TYPE\"", ",", "\"Permission", "Denied.\"", ")", ";", "switch", "(", "Typeof", "(", "obj", ")", ")", "{", "case", "TYPE_PLAYER", ":", "return", "\"Player\"", ";", "case", "TYPE_ROOM", ":", "return", "\"Room\"", ";", "case", "TYPE_EXIT", ":", "return", "\"Exit\"", ";", "case", "TYPE_THING", ":", "return", "\"Thing\"", ";", "case", "TYPE_PROGRAM", ":", "return", "\"Program\"", ";", "default:", "return", "\"Bad\"", ";", "}", "}'" ]

[ "Get", "an", "item", "from", "an", "MPI", "stringbased", "list", "The", "resulting", "item", "is", "put", "in", "'buf'", "which", "will", "be", "an", "empty", "string", "if", "nothing", "is", "found" ]

[ "'static", "char", "*", "getlitem", "(", "char", "*", "buf", ",", "size_t", "buflen", ",", "char", "*", "list", ",", "char", "*", "sep", ",", "int", "line", ")", "{", "char", "*", "ptr", ",", "<type", "ref=\"prev\">", "*", "ptr2", ";", "char", "tmpchr", ";", "size_t", "seplen", ";", "seplen", "=", "strlen", "(", "sep", ")", ";", "ptr", "=", "ptr2", "=", "list", ";", "while", "(", "*", "ptr", "&&", "line", "--", ")", "{", "for", "(", "ptr2", "=", "ptr", ";", "*", "ptr2", "&&", "strncmp", "(", "ptr2", ",", "sep", ",", "seplen", ")", ";", "ptr2", "++", ")", ";", "if", "(", "!", "line", ")", "break;", "if", "(", "*", "ptr2", ")", "{", "ptr2", "+=", "seplen", ";", "}", "ptr", "=", "ptr2", ";", "}", "tmpchr", "=", "*", "ptr2", ";", "*", "ptr2", "=", "\\'\\\\0\\'", ";", "strcpyn", "(", "buf", ",", "buflen", ",", "ptr", ")", ";", "*", "ptr2", "=", "tmpchr", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "a", "subset", "of", "list", "arg0", "arg0", "is", "a", "string", "containing", "a", "delimited", "list" ]

[ "'const", "char", "*", "mfn_sublist", "(", "MFUNARGS", ")", "{", "char", "*", "ptr", ";", "char", "sepbuf", "[", "BUFFER_LEN", "]", ";", "char", "buf2", "[", "BUFFER_LEN", "]", ";", "int", "count", "=", "1", ";", "int", "which", ";", "int", "end", ";", "int", "incr", "=", "1", ";", "int", "pflag", ";", "if", "(", "argc", ">", "1", ")", "{", "which", "=", "atoi", "(", "argv", "[", "1", "]", ")", ";", "}", "else", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "argv", "[", "0", "]", ")", ";", "return", "buf", ";", "}", "strcpyn", "(", "sepbuf", ",", "sizeof", "(", "sepbuf", ")", ",", "\"\\\\r\"", ")", ";", "if", "(", "argc", ">", "3", ")", "{", "if", "(", "!", "*", "argv", "[", "3", "]", ")", "ABORT_MPI", "(", "\"SUBLIST\"", ",", "\"Can\\'t", "use", "null", "separator", "string.\"", ")", ";", "strcpyn", "(", "sepbuf", ",", "sizeof", "(", "sepbuf", ")", ",", "argv", "[", "3", "]", ")", ";", "}", "count", "=", "countlitems", "(", "argv", "[", "0", "]", ",", "sepbuf", ")", ";", "/*", "count", "of", "items", "in", "list", "*/", "if", "(", "which", "==", "0", ")", "return", "\"\"", ";", "if", "(", "which", ">", "count", ")", "which", "=", "count", ";", "if", "(", "which", "<", "0", ")", "which", "+=", "count", "+", "1", ";", "if", "(", "which", "<", "1", ")", "which", "=", "1", ";", "end", "=", "which", ";", "if", "(", "argc", ">", "2", ")", "{", "end", "=", "atoi", "(", "argv", "[", "2", "]", ")", ";", "}", "if", "(", "end", "==", "0", ")", "return", "\"\"", ";", "if", "(", "end", ">", "count", ")", "end", "=", "count", ";", "if", "(", "end", "<", "0", ")", "end", "+=", "count", "+", "1", ";", "if", "(", "end", "<", "1", ")", "end", "=", "1", ";", "if", "(", "end", "<", "which", ")", "{", "incr", "=", "-", "1", ";", "}", "*", "buf", "=", "\\'\\\\0\\'", ";", "pflag", "=", "0", ";", "for", "(", "int", "i", "=", "which", ";", "(", "(", "i", "<=", "end", ")", "&&", "(", "incr", "==", "1", ")", ")", "||", "(", "(", "i", ">=", "end", ")", "&&", "(", "incr", "==", "-", "1", ")", ")", ";", "i", "+=", "incr", ")", "{", "if", "(", "pflag", ")", "{", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "sepbuf", ")", ";", "}", "else", "{", "pflag", "++", ";", "}", "ptr", "=", "getlitem", "(", "buf2", ",", "sizeof", "(", "buf2", ")", ",", "argv", "[", "0", "]", ",", "sepbuf", ",", "i", ")", ";", "strcatn", "(", "buf", ",", "BUFFER_LEN", ",", "ptr", ")", ";", "}", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "kills", "a", "process", "on", "the", "timequeue", "arg0", "is", "either", "0", "to", "kill", "all", "processes", "done", "by", "the", "trigger,", "or", "a", "PID", "of", "a", "specific", "process" ]

[ "'const", "char", "*", "mfn_kill", "(", "MFUNARGS", ")", "{", "int", "i", "=", "atoi", "(", "argv", "[", "0", "]", ")", ";", "if", "(", "i", ">", "0", ")", "{", "if", "(", "in_timequeue", "(", "i", ")", ")", "{", "if", "(", "!", "control_process", "(", "perms", ",", "i", ")", ")", "{", "ABORT_MPI", "(", "\"KILL\"", ",", "\"Permission", "denied.\"", ")", ";", "}", "i", "=", "dequeue_process", "(", "i", ")", ";", "}", "else", "{", "i", "=", "0", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "i", "==", "0", ")", "{", "i", "=", "dequeue_prog", "(", "perms", ",", "0", ")", ";", "}", "else", "{", "ABORT_MPI", "(", "\"KILL\"", ",", "\"Invalid", "process", "ID.\"", ")", ";", "}", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "i", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "returns", "the", "length", "of", "string", "arg0", "Just", "a", "thin", "wrapper", "around", "strlen" ]

[ "'const", "char", "*", "mfn_strlen", "(", "MFUNARGS", ")", "{", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "(", "int", ")", "strlen", "(", "argv", "[", "0", "]", ")", ")", ";", "return", "buf", ";", "}'" ]

[ "Count", "the", "number", "of", "items", "in", "an", "MPI", "\"list\"", "(string", "of", "delimited", "items)", "@private" ]

[ "'static", "int", "countlitems", "(", "char", "*", "list", ",", "char", "*", "sep", ")", "{", "char", "*", "ptr", ";", "size_t", "seplen", ";", "int", "count", "=", "1", ";", "if", "(", "!", "list", "||", "!", "*", "list", ")", "return", "0", ";", "seplen", "=", "strlen", "(", "sep", ")", ";", "ptr", "=", "list", ";", "while", "(", "*", "ptr", ")", "{", "while", "(", "*", "ptr", "&&", "strncmp", "(", "ptr", ",", "sep", ",", "seplen", ")", ")", "ptr", "++", ";", "if", "(", "*", "ptr", ")", "{", "ptr", "+=", "seplen", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}'" ]

[ "MPI", "function", "that", "runs", "code", "with", "no", "blessing", "set", "arg0", "will", "be", "run", "\"unblessed\"", "even", "if", "the", "MPI", "is", "currently", "blessed" ]

[ "'const", "char", "*", "mfn_revoke", "(", "MFUNARGS", ")", "{", "char", "*", "ptr", "=", "mesg_parse", "(", "descr", ",", "player", ",", "what", ",", "perms", ",", "argv", "[", "0", "]", ",", "buf", ",", "BUFFER_LEN", ",", "(", "mesgtyp", "&", "~", "MPI_ISBLESSED", ")", ")", ";", "CHECKRETURN", "(", "ptr", ",", "\"REVOKE\"", ",", "\"arg", "1\"", ")", ";", "return", "buf", ";", "}'" ]

[ "MPI", "function", "that", "runs", "a", "MUF", "arg0", "is", "the", "MUF", "to", "run,", "arg1", "is", "what", "will", "be", "put", "on", "the", "stack" ]

[ "'const", "char", "*", "mfn_muf", "(", "MFUNARGS", ")", "{", "char", "*", "ptr", ";", "struct", "inst", "*", "rv", "=", "NULL", ";", "struct", "frame", "*", "tmpfr", ";", "dbref", "obj", "=", "mesg_dbref_raw", "(", "descr", ",", "player", ",", "what", ",", "argv", "[", "0", "]", ")", ";", "/*", "Permission", "checks", "*/", "if", "(", "obj", "==", "UNKNOWN", ")", "ABORT_MPI", "(", "\"MUF\"", ",", "\"Match", "failed.\"", ")", ";", "if", "(", "obj", "<=", "NOTHING", "||", "Typeof", "(", "obj", ")", "!=", "TYPE_PROGRAM", ")", "ABORT_MPI", "(", "\"MUF\"", ",", "\"Bad", "program", "reference.\"", ")", ";", "if", "(", "!", "(", "FLAGS", "(", "obj", ")", "&", "LINK_OK", ")", "&&", "!", "controls", "(", "perms", ",", "obj", ")", ")", "ABORT_MPI", "(", "\"MUF\"", ",", "\"Permission", "denied.\"", ")", ";", "if", "(", "(", "mesgtyp", "&", "(", "MPI_ISLISTENER", "|", "MPI_ISLOCK", ")", ")", "&&", "(", "MLevel", "(", "obj", ")", "<", "3", ")", ")", "ABORT_MPI", "(", "\"MUF\"", ",", "\"Permission", "denied.\"", ")", ";", "if", "(", "++", "mpi_muf_call_levels", ">", "18", ")", "ABORT_MPI", "(", "\"MUF\"", ",", "\"Too", "many", "call", "levels.\"", ")", ";", "strcpyn", "(", "match_args", ",", "sizeof", "(", "match_args", ")", ",", "argv", "[", "1", "]", ")", ";", "ptr", "=", "get_mvar", "(", "\"how\"", ")", ";", "snprintf", "(", "match_cmdname", ",", "sizeof", "(", "match_cmdname", ")", ",", "\"%s(MPI)\"", ",", "ptr", ")", ";", "tmpfr", "=", "interp", "(", "descr", ",", "player", ",", "LOCATION", "(", "player", ")", ",", "obj", ",", "perms", ",", "PREEMPT", ",", "STD_HARDUID", ",", "0", ")", ";", "/*", "Run", "the", "MUF", "*/", "if", "(", "tmpfr", ")", "{", "rv", "=", "interp_loop", "(", "player", ",", "obj", ",", "tmpfr", ",", "1", ")", ";", "}", "mpi_muf_call_levels", "--", ";", "if", "(", "!", "rv", ")", "return", "\"\"", ";", "/*", "Convert", "output", "to", "something", "MPI", "can", "use", "*/", "switch", "(", "rv", "->", "type", ")", "{", "case", "PROG_STRING", ":", "if", "(", "rv", "->", "data", ".", "string", ")", "{", "strcpyn", "(", "buf", ",", "buflen", ",", "rv", "->", "data", ".", "string", "->", "data", ")", ";", "CLEAR", "(", "rv", ")", ";", "return", "buf", ";", "}", "else", "{", "CLEAR", "(", "rv", ")", ";", "return", "\"\"", ";", "}", "case", "PROG_INTEGER", ":", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%d\"", ",", "rv", "->", "data", ".", "number", ")", ";", "CLEAR", "(", "rv", ")", ";", "return", "buf", ";", "case", "PROG_FLOAT", ":", "snprintf", "(", "buf", ",", "BUFFER_LEN", ",", "\"%.15g\"", ",", "rv", "->", "data", ".", "fnumber", ")", ";", "CLEAR", "(", "rv", ")", ";", "return", "buf", ";", "case", "PROG_OBJECT", ":", "ptr", "=", "ref2str", "(", "rv", "->", "data", ".", "objref", ",", "buf", ",", "BUFFER_LEN", ")", ";", "CLEAR", "(", "rv", ")", ";", "return", "ptr", ";", "default:", "CLEAR", "(", "rv", ")", ";", "return", "\"\"", ";", "}", "}'" ]

[ "Combine", "cockatrice", "checks", "into", "single", "functions", "to", "avoid", "repeating", "code" ]

[ "'int", "instapetrify", "(", "const", "char", "*", "str", ")", "{", "if", "(", "resists_ston", "(", "&", "youmonst", ")", ")", "return", "0", ";", "if", "(", "poly_when_stoned", "(", "youmonst", ".", "data", ")", "&&", "polymon", "(", "PM_STONE_GOLEM", ",", "TRUE", ")", ")", "return", "0", ";", "pline", "(", "msgc_fatal_predone", ",", "\"You", "turn", "to", "stone...\"", ")", ";", "done", "(", "STONING", ",", "str", ")", ";", "return", "1", ";", "}'" ]

[ "Instapetrify", "function", "that", "works", "for", "players", "and", "monsters" ]

[ "'int", "uminstapetrify", "(", "struct", "monst", "*", "magr", ",", "struct", "monst", "*", "mdef", ",", "const", "char", "*", "str", ")", "{", "if", "(", "mdef", "==", "&", "youmonst", ")", "return", "instapetrify", "(", "str", ")", ";", "return", "minstapetrify", "(", "magr", ",", "mdef", ")", ";", "}'" ]

[ "removes", "traps", "that", "shoot", "arrows,", "darts,", "etc" ]

[ "'static", "int", "disarm_shooting_trap", "(", "struct", "trap", "*", "ttmp", ",", "int", "otyp", ",", "schar", "dx", ",", "schar", "dy", ")", "{", "int", "fails", "=", "try_disarm", "(", "ttmp", ",", "FALSE", ",", "dx", ",", "dy", ")", ";", "if", "(", "fails", "<", "2", ")", "return", "fails", ";", "pline", "(", "msgc_actionok", ",", "\"You", "disarm", "%s", "trap.\"", ",", "the_your", "[", "ttmp", "->", "madeby_u", "]", ")", ";", "cnv_trap_obj", "(", "level", ",", "otyp", ",", "50", "-", "rnl", "(", "50", ")", ",", "ttmp", ")", ";", "level", "->", "locations", "[", "u", ".", "ux", "+", "dx", "]", "[", "u", ".", "uy", "+", "dy", "]", ".", "mem_trap", "=", "NO_TRAP", ";", "newsym", "(", "u", ".", "ux", "+", "dx", ",", "u", ".", "uy", "+", "dy", ")", ";", "return", "1", ";", "}'" ]

[ "only", "called", "when", "the", "player", "is", "doing", "something", "to", "the", "chest", "directly" ]

[ "'boolean", "chest_trap", "(", "struct", "monst", "*", "mon", ",", "struct", "obj", "*", "obj", ",", "int", "bodypart", ",", "boolean", "disarm", ")", "{", "boolean", "you", "=", "(", "mon", "==", "&", "youmonst", ")", ";", "boolean", "vis", "=", "canseemon", "(", "mon", ")", ";", "int", "mluck", "=", "Luck", ";", "/*", "TODO:", "monster", "luck", "*/", "if", "(", "!", "you", ")", "mluck", "=", "0", ";", "/*", "for", "now", "*/", "struct", "obj", "*", "otmp", "=", "obj", ",", "<type", "ref=\"prev\">", "*", "otmp2", ";", "char", "buf", "[", "80", "]", ";", "const", "char", "*", "msg", ";", "coord", "cc", ";", "boolean", "immune", "=", "!", "!", "m_carrying_artifact", "(", "mon", ",", "ART_MASTER_KEY_OF_THIEVERY", ")", ";", "if", "(", "get_obj_location", "(", "obj", ",", "&", "cc", ".", "x", ",", "&", "cc", ".", "y", ",", "0", ")", ")", "/*", "might", "be", "carried", "*/", "obj", "->", "ox", "=", "cc", ".", "x", ",", "obj", "->", "oy", "=", "cc", ".", "y", ";", "otmp", "->", "otrapped", "=", "0", ";", "/*", "trap", "is", "one-shot;", "clear", "flag", "first", "in", "case", "chest", "kills", "you", "and", "ends", "up", "in", "bones", "file", "*/", "if", "(", "you", "||", "vis", ")", "pline_implied", "(", "msgc_substitute", ",", "disarm", "?", "\"%s", "set%s", "it", "off!\"", ":", "\"%s", "trigger%s", "a", "trap!\"", ",", "you", "?", "\"You\"", ":", "Monnam", "(", "mon", ")", ",", "you", "?", "\"\"", ":", "\"s\"", ")", ";", "win_pause_output", "(", "P_MESSAGE", ")", ";", "if", "(", "immune", "||", "(", "mluck", ">", "-", "13", "&&", "rn2", "(", "13", "+", "mluck", ")", ">", "7", ")", ")", "{", "/*", "saved", "by", "luck", "*/", "/*", "trap", "went", "off,", "but", "good", "luck", "prevents", "damage", "*/", "switch", "(", "rn2", "(", "13", ")", ")", "{", "case", "12", ":", "case", "11", ":", "msg", "=", "\"explosive", "charge", "is", "a", "dud\"", ";", "break;", "case", "10", ":", "case", "9", ":", "msg", "=", "\"electric", "charge", "is", "grounded\"", ";", "break;", "case", "8", ":", "case", "7", ":", "msg", "=", "\"flame", "fizzles", "out\"", ";", "break;", "case", "6", ":", "case", "5", ":", "case", "4", ":", "msg", "=", "\"poisoned", "needle", "misses\"", ";", "break;", "case", "3", ":", "case", "2", ":", "case", "1", ":", "case", "0", ":", "msg", "=", "\"gas", "cloud", "blows", "away\"", ";", "break;", "default:", "impossible", "(", "\"chest", "disarm", "bug\"", ")", ";", "msg", "=", "NULL", ";", "break;", "}", "if", "(", "msg", "&&", "(", "you", "||", "vis", ")", ")", "pline", "(", "you", "?", "msgc_nonmongood", ":", "msgc_monneutral", ",", "\"But", "luckily%s", "the", "%s!\"", ",", "you", "?", "\"\"", ":", "msgcat_many", "(", "\"", "for", "\"", ",", "mon_nam", "(", "mon", ")", ",", "\",\"", ",", "NULL", ")", ",", "msg", ")", ";", "}", "else", "{", "int", "result", ";", "if", "(", "!", "rn2", "(", "20", ")", ")", "result", "=", "rn2", "(", "26", ")", ";", "else", "result", "=", "(", "mluck", ">=", "13", "?", "0", ":", "rn2", "(", "13", "-", "mluck", ")", ")", ";", "/*", "Don\\'t", "allow", "the", "castle", "wand", "chest", "to", "explode", "*/", "if", "(", "result", ">", "20", "&&", "obj", "->", "spe", "==", "3", ")", "result", "=", "rn2", "(", "21", ")", ";", "switch", "(", "result", ")", "{", "case", "25", ":", "case", "24", ":", "case", "23", ":", "case", "22", ":", "case", "21", ":", "{", "struct", "monst", "*", "shkp", "=", "0", ";", "long", "loss", "=", "0L", ";", "boolean", "costly", ",", "<type", "ref=\"prev\"/>", "insider", ";", "xchar", "ox", "=", "obj", "->", "ox", ",", "<type", "ref=\"prev\"/>", "oy", "=", "obj", "->", "oy", ";", "/*", "the", "obj", "location", "need", "not", "be", "that", "of", "player", "*/", "costly", "=", "(", "costly_spot", "(", "ox", ",", "oy", ")", "&&", "you", "&&", "(", "shkp", "=", "shop_keeper", "(", "level", ",", "*", "in_rooms", "(", "level", ",", "ox", ",", "oy", ",", "SHOPBASE", ")", ")", ")", "!=", "NULL", ")", ";", "insider", "=", "(", "*", "u", ".", "ushops", "&&", "inside_shop", "(", "level", ",", "u", ".", "ux", ",", "u", ".", "uy", ")", "&&", "*", "in_rooms", "(", "level", ",", "ox", ",", "oy", ",", "SHOPBASE", ")", "==", "*", "u", ".", "ushops", ")", ";", "if", "(", "you", "||", "vis", ")", "pline", "(", "you", "?", "msgc_nonmonbad", ":", "msgc_monneutral", ",", "\"%s!\"", ",", "Tobjnam", "(", "obj", ",", "\"explode\"", ")", ")", ";", "snprintf", "(", "buf", ",", "SIZE", "(", "buf", ")", ",", "\"exploding", "%s\"", ",", "xname", "(", "obj", ")", ")", ";", "if", "(", "costly", ")", "loss", "+=", "stolen_value", "(", "obj", ",", "ox", ",", "oy", ",", "(", "boolean", ")", "shkp", "->", "mpeaceful", ",", "TRUE", ")", ";", "delete_contents", "(", "obj", ")", ";", "/*", "we\\'re", "about", "to", "delete", "all", "things", "at", "this", "location,", "which", "could", "include", "the", "ball", "&", "chain.", "If", "we", "attempt", "to", "call", "unpunish()", "in", "the", "for-loop", "below", "we", "can", "end", "up", "with", "otmp2", "being", "invalid", "once", "the", "chain", "is", "gone.", "Deal", "with", "ball", "&", "chain", "right", "now", "instead.", "*/", "if", "(", "Punished", "&&", "!", "carried", "(", "uball", ")", "&&", "(", "(", "uchain", "->", "ox", "==", "u", ".", "ux", "&&", "uchain", "->", "oy", "==", "u", ".", "uy", ")", "||", "(", "uball", "->", "ox", "==", "u", ".", "ux", "&&", "uball", "->", "oy", "==", "u", ".", "uy", ")", ")", ")", "unpunish", "()", ";", "for", "(", "otmp", "=", "level", "->", "objects", "[", "u", ".", "ux", "]", "[", "u", ".", "uy", "]", ";", "otmp", ";", "otmp", "=", "otmp2", ")", "{", "otmp2", "=", "otmp", "->", "nexthere", ";", "if", "(", "costly", ")", "loss", "+=", "stolen_value", "(", "otmp", ",", "otmp", "->", "ox", ",", "otmp", "->", "oy", ",", "(", "boolean", ")", "shkp", "->", "mpeaceful", ",", "TRUE", ")", ";", "delobj", "(", "otmp", ")", ";", "}", "if", "(", "you", ")", "/*", "TODO:", "make", "this", "work", "on", "monsters", "*/", "wake_nearby", "(", "FALSE", ")", ";", "if", "(", "you", ")", "losehp", "(", "dice", "(", "6", ",", "6", ")", ",", "killer_msg", "(", "DIED", ",", "an", "(", "buf", ")", ")", ")", ";", "else", "{", "mon", "->", "mhp", "-=", "dice", "(", "6", ",", "6", ")", ";", "if", "(", "mon", "->", "mhp", "<=", "0", ")", "mondied", "(", "mon", ")", ";", "}", "if", "(", "you", ")", "exercise", "(", "A_STR", ",", "FALSE", ")", ";", "if", "(", "costly", "&&", "loss", ")", "{", "if", "(", "insider", ")", "pline", "(", "msgc_unpaid", ",", "\"You", "owe", "%ld", "%s", "for", "objects", "destroyed.\"", ",", "loss", ",", "currency", "(", "loss", ")", ")", ";", "else", "{", "pline", "(", "msgc_npcanger", ",", "\"You", "caused", "%ld", "%s", "worth", "of", "damage!\"", ",", "loss", ",", "currency", "(", "loss", ")", ")", ";", "make_angry_shk", "(", "shkp", ",", "ox", ",", "oy", ")", ";", "}", "}", "return", "TRUE", ";", "}", "case", "20", ":", "case", "19", ":", "case", "18", ":", "case", "17", ":", "if", "(", "you", "||", "vis", ")", "pline", "(", "you", "?", "msgc_nonmonbad", ":", "msgc_monneutral", ",", "\"A", "cloud", "of", "noxious", "gas", "billows", "from", "%s.\"", ",", "the", "(", "xname", "(", "obj", ")", ")", ")", ";", "poisoned", "(", "mon", ",", "\"gas", "cloud\"", ",", "A_STR", ",", "killer_msg", "(", "DIED", ",", "\"a", "cloud", "of", "poison", "gas\"", ")", ",", "15", ")", ";", "break;", "case", "16", ":", "case", "15", ":", "case", "14", ":", "case", "13", ":", "if", "(", "you", ")", "{", "pline", "(", "msgc_nonmonbad", ",", "\"You", "feel", "a", "needle", "prick", "your", "%s.\"", ",", "body_part", "(", "bodypart", ")", ")", ";", "exercise", "(", "A_CON", ",", "FALSE", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "vis", ")", "pline", "(", "msgc_monneutral", ",", "\"You", "see", "a", "needle", "prick", "%s", "%s.\"", ",", "s_suffix", "(", "mon_nam", "(", "mon", ")", ")", ",", "mbodypart", "(", "mon", ",", "bodypart", ")", ")", ";", "poisoned", "(", "mon", ",", "\"needle\"", ",", "A_CON", ",", "killer_msg", "(", "DIED", ",", "\"a", "poisoned", "needle\"", ")", ",", "10", ")", ";", "break;", "case", "12", ":", "case", "11", ":", "case", "10", ":", "case", "9", ":", "dofiretrap", "(", "mon", ",", "obj", ")", ";", "break;", "case", "8", ":", "case", "7", ":", "case", "6", ":", "{", "int", "dmg", ";", "if", "(", "immune_to_elec", "(", "mon", ")", ")", "{", "if", "(", "you", "||", "vis", ")", "{", "shieldeff", "(", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ";", "pline", "(", "combat_msgc", "(", "NULL", ",", "mon", ",", "cr_immune", ")", ",", "\"A", "jolt", "of", "electricity", "harmlessly", "flows", "around", "%s.\"", ",", "you", "?", "\"you\"", ":", "mon_nam", "(", "mon", ")", ")", ";", "}", "dmg", "=", "0", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "resists_elec", "(", "mon", ")", ")", "{", "if", "(", "you", "||", "vis", ")", "pline", "(", "combat_msgc", "(", "NULL", ",", "mon", ",", "cr_resist", ")", ",", "\"%s", "jolted", "by", "a", "surge", "of", "electricity,", "\"", "\"but", "partially", "resists!\"", ",", "M_verbs", "(", "mon", ",", "\"are\"", ")", ")", ";", "dmg", "=", "dice", "(", "2", ",", "4", ")", ";", "}", "else", "{", "if", "(", "you", "||", "vis", ")", "pline", "(", "combat_msgc", "(", "NULL", ",", "mon", ",", "cr_hit", ")", ",", "\"%s", "jolted", "by", "a", "surge", "of", "electricity!\"", ",", "M_verbs", "(", "mon", ",", "\"are\"", ")", ")", ";", "dmg", "=", "dice", "(", "4", ",", "4", ")", ";", "}", "dmg", "+=", "destroy_mitem", "(", "mon", ",", "ALL_CLASSES", ",", "AD_ELEC", ",", "NULL", ")", ";", "if", "(", "dmg", ")", "{", "if", "(", "you", ")", "losehp", "(", "dmg", ",", "killer_msg", "(", "DIED", ",", "\"an", "electric", "shock\"", ")", ")", ";", "else", "{", "mon", "->", "mhp", "-=", "dmg", ";", "if", "(", "mon", "->", "mhp", "<=", "0", ")", "mondied", "(", "mon", ")", ";", "}", "}", "break;", "}", "case", "5", ":", "case", "4", ":", "case", "3", ":", "if", "(", "!", "free_action", "(", "mon", ")", ")", "{", "if", "(", "you", "||", "vis", ")", "pline", "(", "you", "?", "msgc_statusbad", ":", "msgc_monneutral", ",", "\"Suddenly", "%s", "frozen", "in", "place!\"", ",", "m_verbs", "(", "mon", ",", "\"are\"", ")", ")", ";", "if", "(", "you", ")", "{", "helpless", "(", "dice", "(", "5", ",", "6", ")", ",", "hr_paralyzed", ",", "\"frozen", "by", "a", "trap\"", ",", "NULL", ")", ";", "exercise", "(", "A_DEX", ",", "FALSE", ")", ";", "}", "else", "{", "mon", "->", "mcanmove", "=", "0", ";", "mon", "->", "mfrozen", "+=", "dice", "(", "5", ",", "6", ")", ";", "}", "}", "<if", "type=\"elseif\">", "else", "if", "(", "you", "||", "vis", ")", "pline", "(", "combat_msgc", "(", "NULL", ",", "mon", ",", "cr_immune", ")", ",", "\"%s", "momentarily", "stiffen%s.\"", ",", "you", "?", "\"You\"", ":", "Monnam", "(", "mon", ")", ",", "you", "?", "\"\"", ":", "\"s\"", ")", ";", "break;", "case", "2", ":", "case", "1", ":", "case", "0", ":", "if", "(", "you", "||", "vis", ")", "pline_implied", "(", "you", "?", "msgc_statusbad", ":", "msgc_monneutral", ",", "\"A", "cloud", "of", "%s", "gas", "billows", "from", "%s.\"", ",", "Blind", "?", "blindgas", "[", "rn2", "(", "SIZE", "(", "blindgas", ")", ")", "]", ":", "rndcolor", "()", ",", "the", "(", "xname", "(", "obj", ")", ")", ")", ";", "if", "(", "!", "stunned", "(", "mon", ")", ")", "{", "if", "(", "Hallucination", ")", "{", "if", "(", "you", ")", "pline", "(", "msgc_yafm", ",", "\"What", "a", "groovy", "feeling!\"", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "vis", ")", "pline", "(", "msgc_yafm", ",", "\"%s", "looks", "groovy!\"", ",", "Monnam", "(", "mon", ")", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "you", "&&", "blind", "(", "&", "youmonst", ")", ")", "pline", "(", "msgc_statusbad", ",", "\"You", "%s", "and", "get", "dizzy...\"", ",", "stagger", "(", "youmonst", ".", "data", ",", "\"stagger\"", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "you", "||", "(", "vis", "&&", "!", "blind", "(", "&", "youmonst", ")", ")", ")", "{", "if", "(", "you", "&&", "resists_stun", "(", "mon", ")", ")", "pline", "(", "msgc_statusbad", ",", "\"Your", "vision", "blurs...\"", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "you", ")", "pline", "(", "msgc_statusbad", ",", "\"You", "%s", "and", "your", "vision", "blurs...\"", ",", "stagger", "(", "youmonst", ".", "data", ",", "\"stagger\"", ")", ")", ";", "<if", "type=\"elseif\">", "else", "if", "(", "!", "resists_stun", "(", "mon", ")", ")", "pline", "(", "msgc_monneutral", ",", "\"%s", "%s...\"", ",", "Monnam", "(", "mon", ")", ",", "stagger", "(", "mon", "->", "data", ",", "\"stagger\"", ")", ")", ";", "}", "}", "if", "(", "!", "resists_stun", "(", "mon", ")", ")", "inc_timeout", "(", "mon", ",", "STUNNED", ",", "rn1", "(", "7", ",", "16", ")", ",", "TRUE", ")", ";", "inc_timeout", "(", "mon", ",", "you", "?", "HALLUC", ":", "CONFUSION", ",", "rn1", "(", "5", ",", "16", ")", ",", "TRUE", ")", ";", "break;", "default:", "impossible", "(", "\"bad", "chest", "trap\"", ")", ";", "break;", "}", "bot", "()", ";", "/*", "to", "get", "immediate", "botl", "re-display", "*/", "}", "return", "FALSE", ";", "}'" ]

[ "used", "for", "doors", "(also", "tins)" ]

[ "'void", "b_trapped", "(", "const", "char", "*", "item", ",", "int", "bodypart", ")", "{", "int", "lvl", "=", "level_difficulty", "(", "&", "u", ".", "uz", ")", ";", "int", "dmg", "=", "rnd", "(", "5", "+", "(", "lvl", "<", "5", "?", "lvl", ":", "2", "+", "lvl", "/", "2", ")", ")", ";", "pline", "(", "msgc_substitute", ",", "\"KABOOM!!", "%s", "was", "booby-trapped!\"", ",", "The", "(", "item", ")", ")", ";", "wake_nearby", "(", "FALSE", ")", ";", "if", "(", "m_carrying_artifact", "(", "&", "youmonst", ",", "ART_MASTER_KEY_OF_THIEVERY", ")", ")", "{", "pline", "(", "combat_msgc", "(", "NULL", ",", "&", "youmonst", ",", "cr_immune", ")", ",", "\"But", "your", "artifact", "shields", "you.\"", ")", ";", "return", ";", "}", "losehp", "(", "dmg", ",", "killer_msg", "(", "DIED", ",", "\"an", "explosion\"", ")", ")", ";", "exercise", "(", "A_STR", ",", "FALSE", ")", ";", "if", "(", "bodypart", ")", "exercise", "(", "A_CON", ",", "FALSE", ")", ";", "if", "(", "!", "resists_stun", "(", "&", "youmonst", ")", ")", "inc_timeout", "(", "&", "youmonst", ",", "STUNNED", ",", "dmg", ",", "FALSE", ")", ";", "}'" ]

[ "magr", "is", "the", "monster", "youmonst", "that", "made", "this", "happen,", "NULL", "for", "a", "trap" ]

[ "'int", "minstapetrify", "(", "struct", "monst", "*", "magr", ",", "struct", "monst", "*", "mdef", ")", "{", "if", "(", "resists_ston", "(", "mdef", ")", ")", "return", "0", ";", "if", "(", "poly_when_stoned", "(", "mdef", "->", "data", ")", ")", "{", "mon_to_stone", "(", "mdef", ")", ";", "return", "0", ";", "}", "if", "(", "cansee", "(", "mdef", "->", "mx", ",", "mdef", "->", "my", ")", ")", "pline", "(", "combat_msgc", "(", "magr", ",", "mdef", ",", "cr_kill", ")", ",", "\"%s", "turns", "to", "stone.\"", ",", "Monnam", "(", "mdef", ")", ")", ";", "if", "(", "magr", "==", "&", "youmonst", ")", "{", "stoned", "=", "TRUE", ";", "xkilled", "(", "mdef", ",", "0", ")", ";", "}", "else", "monstone", "(", "mdef", ")", ";", "return", "1", ";", "}'" ]

[ "Probability", "of", "disabling", "a", "trap" ]

[ "'static", "int", "untrap_prob", "(", "struct", "trap", "*", "ttmp", ")", "{", "int", "chance", "=", "3", ";", "/*", "Only", "spiders", "know", "how", "to", "deal", "with", "webs", "reliably", "*/", "if", "(", "ttmp", "->", "ttyp", "==", "WEB", "&&", "!", "webmaker", "(", "youmonst", ".", "data", ")", ")", "chance", "=", "30", ";", "if", "(", "Confusion", "||", "Hallucination", ")", "chance", "++", ";", "if", "(", "Blind", ")", "chance", "++", ";", "if", "(", "Stunned", ")", "chance", "+=", "2", ";", "if", "(", "Fumbling", ")", "chance", "*=", "2", ";", "/*", "Your", "own", "traps", "are", "better", "known", "than", "others.", "*/", "if", "(", "ttmp", "->", "madeby_u", ")", "chance", "--", ";", "if", "(", "Role_if", "(", "PM_ROGUE", ")", ")", "{", "if", "(", "rn2", "(", "2", "*", "MAXULEV", ")", "<", "u", ".", "ulevel", ")", "chance", "--", ";", "if", "(", "Uhave_questart", "&&", "chance", ">", "1", ")", "chance", "--", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "Role_if", "(", "PM_RANGER", ")", "&&", "chance", ">", "1", ")", "chance", "--", ";", "return", "rn2", "(", "chance", ")", ";", "}'" ]

[ "Replace", "trap", "with", "object(s)" ]

[ "'void", "cnv_trap_obj", "(", "struct", "level", "*", "lev", ",", "int", "otyp", ",", "int", "cnt", ",", "struct", "trap", "*", "ttmp", ")", "{", "struct", "obj", "*", "otmp", "=", "mksobj", "(", "lev", ",", "otyp", ",", "TRUE", ",", "FALSE", ",", "rng_main", ")", ";", "otmp", "->", "quan", "=", "cnt", ";", "otmp", "->", "owt", "=", "weight", "(", "otmp", ")", ";", "/*", "Only", "dart", "traps", "are", "capable", "of", "being", "poisonous", "*/", "if", "(", "otyp", "!=", "DART", ")", "otmp", "->", "opoisoned", "=", "0", ";", "place_object", "(", "otmp", ",", "lev", ",", "ttmp", "->", "tx", ",", "ttmp", "->", "ty", ")", ";", "/*", "Sell", "your", "own", "traps", "only...", "*/", "if", "(", "ttmp", "->", "madeby_u", ")", "sellobj", "(", "otmp", ",", "ttmp", "->", "tx", ",", "ttmp", "->", "ty", ")", ";", "stackobj", "(", "otmp", ")", ";", "if", "(", "lev", "==", "level", ")", "newsym", "(", "ttmp", "->", "tx", ",", "ttmp", "->", "ty", ")", ";", "deltrap", "(", "lev", ",", "ttmp", ")", ";", "}'" ]

[ "some", "actions", "common", "to", "both", "player", "and", "monsters", "for", "triggered", "landmine" ]

[ "\"void", "blow_up_landmine", "(", "struct", "trap", "*", "trap", ")", "{", "int", "x", "=", "trap", "->", "tx", ";", "int", "y", "=", "trap", "->", "ty", ";", "scatter", "(", "x", ",", "y", ",", "4", ",", "MAY_DESTROY", "|", "MAY_HIT", "|", "MAY_FRACTURE", "|", "VIS_EFFECTS", ",", "NULL", ")", ";", "del_engr_at", "(", "level", ",", "trap", "->", "tx", ",", "trap", "->", "ty", ")", ";", "wake_nearto", "(", "trap", "->", "tx", ",", "trap", "->", "ty", ",", "400", ")", ";", "if", "(", "IS_DOOR", "(", "level", "->", "locations", "[", "trap", "->", "tx", "]", "[", "trap", "->", "ty", "]", ".", "typ", ")", ")", "level", "->", "locations", "[", "trap", "->", "tx", "]", "[", "trap", "->", "ty", "]", ".", "flags", "=", "D_BROKEN", ";", "if", "(", "!", "IS_DRAWBRIDGE", "(", "level", "->", "locations", "[", "trap", "->", "tx", "]", "[", "trap", "->", "ty", "]", ".", "typ", ")", ")", "{", "trap", "->", "ttyp", "=", "PIT", ";", "/*", "explosion", "creates", "a", "pit", "*/", "trap", "->", "madeby_u", "=", "FALSE", ";", "/*", "resulting", "pit", "isn't", "yours", "*/", "seetrap", "(", "trap", ")", ";", "/*", "and", "it", "isn't", "concealed", "*/", "}", "else", "{", "deltrap", "(", "level", ",", "trap", ")", ";", "}", "if", "(", "find_drawbridge", "(", "&", "x", ",", "&", "y", ")", ")", "{", "destroy_drawbridge", "(", "x", ",", "y", ")", ";", "}", "}\"" ]

[ "culprit", "is", "the", "monster", "youmonst", "that", "made", "this", "happen,", "NULL", "for", "a", "trap" ]

[ "'void", "mselftouch", "(", "struct", "monst", "*", "mon", ",", "const", "char", "*", "arg", ",", "struct", "monst", "*", "culprit", ")", "{", "struct", "obj", "*", "mwep", "=", "MON_WEP", "(", "mon", ")", ";", "if", "(", "mwep", "&&", "mwep", "->", "otyp", "==", "CORPSE", "&&", "touch_petrifies", "(", "&", "mons", "[", "mwep", "->", "corpsenm", "]", ")", ")", "{", "if", "(", "cansee", "(", "mon", "->", "mx", ",", "mon", "->", "my", ")", ")", "{", "pline", "(", "combat_msgc", "(", "culprit", ",", "mon", ",", "resists_ston", "(", "mon", ")", "?", "cr_immune", ":", "cr_kill0", ")", ",", "\"%s%s", "touches", "the", "%s", "corpse.\"", ",", "arg", "?", "arg", ":", "\"\"", ",", "arg", "?", "mon_nam", "(", "mon", ")", ":", "Monnam", "(", "mon", ")", ",", "opm_name", "(", "mwep", ")", ")", ";", "}", "minstapetrify", "(", "culprit", ",", "mon", ")", ";", "}", "}'" ]

[ "box:", "null", "for", "floor", "trap" ]

[ "'static", "void", "dofiretrap", "(", "struct", "monst", "*", "mon", ",", "struct", "obj", "*", "box", ")", "{", "boolean", "you", "=", "(", "mon", "==", "&", "youmonst", ")", ";", "boolean", "vis", "=", "canseemon", "(", "mon", ")", ";", "struct", "level", "*", "lev", "=", "box", "?", "box", "->", "olev", ":", "m_dlevel", "(", "mon", ")", ";", "boolean", "see_it", "=", "(", "!", "blind", "(", "&", "youmonst", ")", "&&", "(", "you", "||", "cansee", "(", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ")", ")", ";", "int", "num", ",", "<type", "ref=\"prev\"/>", "alt", ";", "/*", "Bug:", "for", "box", "case,", "the", "equivalent", "of", "burn_floor_paper()", "ought", "to", "be", "done", "upon", "its", "contents.", "*/", "/*", "If", "the", "chest", "or", "trap", "is", "underwater", "*/", "if", "(", "is_pool", "(", "lev", ",", "box", "?", "box", "->", "ox", ":", "m_mx", "(", "mon", ")", ",", "box", "?", "box", "->", "oy", ":", "m_my", "(", "mon", ")", ")", "&&", "(", "!", "box", "||", "!", "(", "you", "?", "carried", "(", "box", ")", ":", "mcarried", "(", "box", ")", ")", "||", "(", "!", "aboveliquid", "(", "mon", ")", "&&", "!", "waterwalks", "(", "mon", ")", ")", ")", ")", "{", "if", "(", "resists_fire", "(", "mon", ")", ")", "{", "if", "(", "you", "||", "vis", ")", "pline", "(", "combat_msgc", "(", "NULL", ",", "mon", ",", "cr_immune", ")", ",", "\"Bubbles", "erupt", "from", "%s,", "but", "the", "steam", "doesn\\'t", "hurt", "%s!\"", ",", "the", "(", "box", "?", "xname", "(", "box", ")", ":", "surface", "(", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ")", ",", "you", "?", "\"you\"", ":", "mon_nam", "(", "mon", ")", ")", ";", "}", "else", "{", "if", "(", "you", "||", "vis", "||", "(", "!", "box", "&&", "see_it", ")", ")", "pline", "(", "combat_msgc", "(", "NULL", ",", "mon", ",", "cr_resist", ")", ",", "\"A", "cascade", "of", "steamy", "bubbles", "erupts", "from", "%s!\"", ",", "the", "(", "box", "?", "xname", "(", "box", ")", ":", "surface", "(", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ")", ")", ";", "if", "(", "you", ")", "losehp", "(", "rnd", "(", "3", ")", ",", "killer_msg", "(", "DIED", ",", "\"boiling", "water\"", ")", ")", ";", "else", "{", "mon", "->", "mhp", "-=", "rnd", "(", "3", ")", ";", "if", "(", "mon", "->", "mhp", "<=", "0", ")", "mondied", "(", "mon", ")", ";", "}", "}", "return", ";", "}", "if", "(", "you", "||", "vis", "||", "see_it", ")", "pline", "(", "combat_msgc", "(", "NULL", ",", "mon", ",", "immune_to_fire", "(", "mon", ")", "?", "cr_immune", ":", "resists_fire", "(", "mon", ")", "?", "cr_resist", ":", "cr_hit", ")", ",", "\"A", "tower", "of", "flame", "%s", "from", "%s!\"", ",", "box", "?", "\"bursts\"", ":", "\"erupts\"", ",", "the", "(", "box", "?", "xname", "(", "box", ")", ":", "surface", "(", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ")", ")", ";", "if", "(", "resists_fire", "(", "mon", ")", ")", "{", "if", "(", "you", "||", "vis", ")", "shieldeff", "(", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ";", "num", "=", "0", ";", "if", "(", "!", "immune_to_fire", "(", "mon", ")", ")", "num", "=", "dice", "(", "1", ",", "4", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "Upolyd", "||", "!", "you", ")", "{", "num", "=", "dice", "(", "2", ",", "4", ")", ";", "alt", "=", "you", "?", "u", ".", "mhmax", ":", "mon", "->", "mhpmax", ";", "switch", "(", "monsndx", "(", "mon", "->", "data", ")", ")", "{", "case", "PM_PAPER_GOLEM", ":", "/*", "keep", "alt", "at", "max", "*/", "break;", "case", "PM_STRAW_GOLEM", ":", "alt", "/=", "2", ";", "break;", "case", "PM_WOOD_GOLEM", ":", "alt", "/=", "4", ";", "break;", "case", "PM_LEATHER_GOLEM", ":", "alt", "/=", "8", ";", "break;", "default:", "alt", "=", "0", ";", "break;", "}", "if", "(", "alt", ">", "num", ")", "num", "=", "alt", ";", "if", "(", "you", ")", "{", "if", "(", "u", ".", "mhmax", ">", "mons", "[", "u", ".", "umonnum", "]", ".", "mlevel", ")", "u", ".", "mhmax", "-=", "rn2", "(", "min", "(", "u", ".", "mhmax", ",", "num", "+", "1", ")", ")", ";", "}", "<if", "type=\"elseif\">", "else", "if", "(", "mon", "->", "mhpmax", ">", "mon", "->", "m_lev", ")", "mon", "->", "mhpmax", "-=", "rn2", "(", "min", "(", "mon", "->", "mhpmax", ",", "num", "+", "1", ")", ")", ";", "}", "else", "{", "/*", "you", "*/", "num", "=", "dice", "(", "2", ",", "4", ")", ";", "if", "(", "u", ".", "uhpmax", ">", "u", ".", "ulevel", ")", "u", ".", "uhpmax", "-=", "rn2", "(", "min", "(", "u", ".", "uhpmax", ",", "num", "+", "1", ")", ")", ";", "}", "if", "(", "!", "num", ")", "{", "if", "(", "you", "||", "vis", ")", "pline_implied", "(", "combat_msgc", "(", "NULL", ",", "mon", ",", "cr_miss", ")", ",", "\"%s", "uninjured.\"", ",", "M_verbs", "(", "mon", ",", "\"are\"", ")", ")", ";", "}", "else", "{", "if", "(", "you", ")", "losehp", "(", "num", ",", "killer_msg", "(", "DIED", ",", "\"a", "tower", "of", "flame\"", ")", ")", ";", "else", "{", "mon", "->", "mhp", "-=", "num", ";", "if", "(", "mon", "->", "mhp", "<=", "0", ")", "{", "mondied", "(", "mon", ")", ";", "if", "(", "DEADMONSTER", "(", "mon", ")", ")", "/*", "unless", "it", "lifesaved,", "bail", "out", "*/", "return", ";", "}", "}", "}", "burn_away_slime", "(", "mon", ")", ";", "if", "(", "burnarmor", "(", "mon", ")", "||", "rn2", "(", "3", ")", ")", "{", "const", "char", "*", "killer", ";", "num", "=", "destroy_mitem", "(", "mon", ",", "ALL_CLASSES", ",", "AD_FIRE", ",", "&", "killer", ")", ";", "if", "(", "you", ")", "losehp", "(", "num", ",", "killer", ")", ";", "else", "{", "mon", "->", "mhp", "-=", "num", ";", "if", "(", "mon", "->", "mhp", "<=", "0", ")", "mondied", "(", "mon", ")", ";", "}", "}", "/*", "smell", "should", "be", "able", "to", "pass", "corners,", "but", "not", "walls,", "but", "that", "requires", "pathfinding...", "*/", "if", "(", "!", "box", "&&", "burn_floor_paper", "(", "level", ",", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ",", "see_it", ",", "TRUE", ")", "&&", "!", "see_it", "&&", "(", "you", "||", "couldsee", "(", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ")", ")", "pline", "(", "msgc_itemloss", ",", "\"You", "smell", "paper", "burning.\"", ")", ";", "if", "(", "is_ice", "(", "lev", ",", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ")", "melt_ice", "(", "lev", ",", "m_mx", "(", "mon", ")", ",", "m_my", "(", "mon", ")", ")", ";", "}'" ]

[ "think", "about", "chronological", "solver", "!" ]

[ "'void", "cloverdetratio_derivative_orig", "(", "const", "int", "no", ",", "hamiltonian_field_t", "*", "const", "hf", ")", "{", "monomial", "*", "mnl", "=", "&", "monomial_list", "[", "no", "]", ";", "double", "atime", ",", "<type", "ref=\"prev\"/>", "etime", ";", "atime", "=", "gettime", "()", ";", "/*", "This", "factor", "2*", "a", "missing", "factor", "2", "in", "trace_lambda", "*/", "mnl", "->", "forcefactor", "=", "1.", ";", "<comment_type=\"block\"", "format=\"doxygen\">", "/*********************************************************************", "*", "*", "this", "is", "being", "run", "in", "case", "there", "is", "even/odd", "preconditioning", "*", "*", "This", "term", "is", "det((Q^2", "+", "\\\\mu_1^2)/(Q^2", "+", "\\\\mu_2^2))", "*", "mu1", "and", "mu2", "are", "set", "according", "to", "the", "monomial", "*", "*********************************************************************/", "/*", "First", "term", "coming", "from", "the", "second", "field", "*/", "/*", "Multiply", "with", "W_+", "*/", "mnl_backup_restore_globals", "(", "TM_BACKUP_GLOBALS", ")", ";", "g_mu", "=", "mnl", "->", "mu", ";", "g_mu3", "=", "mnl", "->", "rho2", ";", "//rho2", "boundary", "(", "mnl", "->", "kappa", ")", ";", "//", "we", "compute", "the", "clover", "term", "(1", "+", "T_ee(oo))", "for", "all", "sites", "x", "sw_term", "(", "(", "const", "su3", "*", "*", ")", "hf", "->", "gaugefield", ",", "mnl", "->", "kappa", ",", "mnl", "->", "c_sw", ")", ";", "//", "we", "invert", "it", "for", "the", "even", "sites", "only", "including", "mu", "sw_invert", "(", "EE", ",", "mnl", "->", "mu", ")", ";", "if", "(", "mnl", "->", "solver", "==", "BICGSTAB", "&&", "g_proc_id", "==", "0", ")", "{", "fprintf", "(", "stderr", ",", "\"Bicgstab", "currently", "not", "implemented,", "using", "CG", "instead!", "(detratio_monomial.c)\\\"", ")", ";", "}", "mnl", "->", "Qp", "(", "mnl", "->", "w_fields", "[", "2", "]", ",", "mnl", "->", "pf", ")", ";", "g_mu3", "=", "mnl", "->", "rho", ";", "//", "rho1", "/*", "Invert", "Q_{+}", "Q_{-}", "*/", "/*", "X_W", "->", "w_fields[1]", "*/", "chrono_guess", "(", "mnl", "->", "w_fields", "[", "1", "]", ",", "mnl", "->", "w_fields", "[", "2", "]", ",", "mnl", "->", "csg_field", ",", "mnl", "->", "csg_index_array", ",", "mnl", "->", "csg_N", ",", "mnl", "->", "csg_n", ",", "VOLUME", "/", "2", ",", "mnl", "->", "Qsq", ")", ";", "mnl", "->", "iter1", "+=", "solve_degenerate", "(", "mnl", "->", "w_fields", "[", "1", "]", ",", "mnl", "->", "w_fields", "[", "2", "]", ",", "mnl", "->", "solver_params", ",", "mnl", "->", "maxiter", ",", "mnl", "->", "forceprec", ",", "g_relative_precision_flag", ",", "VOLUME", "/", "2", ",", "mnl", "->", "Qsq", ",", "mnl", "->", "solver", ")", ";", "chrono_add_solution", "(", "mnl", "->", "w_fields", "[", "1", "]", ",", "mnl", "->", "csg_field", ",", "mnl", "->", "csg_index_array", ",", "mnl", "->", "csg_N", ",", "&", "mnl", "->", "csg_n", ",", "VOLUME", "/", "2", ")", ";", "/*", "Y_W", "->", "w_fields[0]", "*/", "mnl", "->", "Qm", "(", "mnl", "->", "w_fields", "[", "0", "]", ",", "mnl", "->", "w_fields", "[", "1", "]", ")", ";", "/*", "apply", "Hopping", "Matrix", "M_{eo}", "*/", "/*", "to", "get", "the", "even", "sites", "of", "X", "*/", "H_eo_sw_inv_psi", "(", "mnl", "->", "w_fields", "[", "2", "]", ",", "mnl", "->", "w_fields", "[", "1", "]", ",", "EO", ",", "-", "1", ",", "mnl", "->", "mu", ")", ";", "/*", "\\\\delta", "Q", "sandwitched", "by", "Y_o^\\\\dagger", "and", "X_e", "*/", "deriv_Sb", "(", "OE", ",", "mnl", "->", "w_fields", "[", "0", "]", ",", "mnl", "->", "w_fields", "[", "2", "]", ",", "hf", ",", "mnl", "->", "forcefactor", ")", ";", "/*", "to", "get", "the", "even", "sites", "of", "Y", "*/", "H_eo_sw_inv_psi", "(", "mnl", "->", "w_fields", "[", "3", "]", ",", "mnl", "->", "w_fields", "[", "0", "]", ",", "EO", ",", "+", "1", ",", "mnl", "->", "mu", ")", ";", "/*", "\\\\delta", "Q", "sandwitched", "by", "Y_e^\\\\dagger", "and", "X_o", "*/", "deriv_Sb", "(", "EO", ",", "mnl", "->", "w_fields", "[", "3", "]", ",", "mnl", "->", "w_fields", "[", "1", "]", ",", "hf", ",", "mnl", "->", "forcefactor", ")", ";", "//", "here", "comes", "the", "clover", "term...", "//", "computes", "the", "insertion", "matrices", "for", "S_eff", "//", "result", "is", "written", "to", "swp", "and", "swm", "//", "even/even", "sites", "sandwiched", "by", "gamma_5", "Y_e", "and", "gamma_5", "X_e", "sw_spinor_eo", "(", "EE", ",", "mnl", "->", "w_fields", "[", "2", "]", ",", "mnl", "->", "w_fields", "[", "3", "]", ",", "mnl", "->", "forcefactor", ")", ";", "//", "odd/odd", "sites", "sandwiched", "by", "gamma_5", "Y_o", "and", "gamma_5", "X_o", "sw_spinor_eo", "(", "OO", ",", "mnl", "->", "w_fields", "[", "0", "]", ",", "mnl", "->", "w_fields", "[", "1", "]", ",", "mnl", "->", "forcefactor", ")", ";", "g_mu3", "=", "mnl", "->", "rho2", ";", "//", "rho2", "/*", "Second", "term", "coming", "from", "the", "second", "field", "*/", "/*", "The", "sign", "is", "opposite!!", "*/", "mul_r", "(", "mnl", "->", "w_fields", "[", "0", "]", ",", "-", "1.", ",", "mnl", "->", "pf", ",", "VOLUME", "/", "2", ")", ";", "/*", "apply", "Hopping", "Matrix", "M_{eo}", "*/", "/*", "to", "get", "the", "even", "sites", "of", "X", "*/", "H_eo_sw_inv_psi", "(", "mnl", "->", "w_fields", "[", "2", "]", ",", "mnl", "->", "w_fields", "[", "1", "]", ",", "EO", ",", "-", "1", ",", "mnl", "->", "mu", ")", ";", "/*", "\\\\delta", "Q", "sandwitched", "by", "Y_o^\\\\dagger", "and", "X_e", "*/", "deriv_Sb", "(", "OE", ",", "mnl", "->", "w_fields", "[", "0", "]", ",", "mnl", "->", "w_fields", "[", "2", "]", ",", "hf", ",", "mnl", "->", "forcefactor", ")", ";", "/*", "to", "get", "the", "even", "sites", "of", "Y", "*/", "H_eo_sw_inv_psi", "(", "mnl", "->", "w_fields", "[", "3", "]", ",", "mnl", "->", "w_fields", "[", "0", "]", ",", "EO", ",", "+", "1", ",", "mnl", "->", "mu", ")", ";", "/*", "\\\\delta", "Q", "sandwitched", "by", "Y_e^\\\\dagger", "and", "X_o", "*/", "deriv_Sb", "(", "EO", ",", "mnl", "->", "w_fields", "[", "3", "]", ",", "mnl", "->", "w_fields", "[", "1", "]", ",", "hf", ",", "mnl", "->", "forcefactor", ")", ";", "//", "here", "comes", "the", "clover", "term...", "//", "computes", "the", "insertion", "matrices", "for", "S_eff", "//", "result", "is", "written", "to", "swp", "and", "swm", "//", "even/even", "sites", "sandwiched", "by", "gamma_5", "Y_e", "and", "gamma_5", "X_e", "sw_spinor_eo", "(", "EE", ",", "mnl", "->", "w_fields", "[", "2", "]", ",", "mnl", "->", "w_fields", "[", "3", "]", ",", "mnl", "->", "forcefactor", ")", ";", "//", "odd/odd", "sites", "sandwiched", "by", "gamma_5", "Y_o", "and", "gamma_5", "X_o", "sw_spinor_eo", "(", "OO", ",", "mnl", "->", "w_fields", "[", "0", "]", ",", "mnl", "->", "w_fields", "[", "1", "]", ",", "mnl", "->", "forcefactor", ")", ";", "sw_all", "(", "hf", ",", "mnl", "->", "kappa", ",", "mnl", "->", "c_sw", ")", ";", "mnl_backup_restore_globals", "(", "TM_RESTORE_GLOBALS", ")", ";", "etime", "=", "gettime", "()", ";", "if", "(", "g_debug_level", ">", "1", "&&", "g_proc_id", "==", "0", ")", "{", "printf", "(", "\"#", "Time", "for", "%s", "monomial", "derivative:", "%e", "s\\\"", ",", "mnl", "->", "name", ",", "etime", "-", "atime", ")", ";", "}", "return", ";", "}'" ]

[ "Copies", "a", "vds", "file", "prefix", "property", "when", "it's", "set", "for", "a", "property", "list" ]

[ "'static", "herr_t", "H5P__dapl_vds_file_pref_set", "(", "hid_t", "H5_ATTR_UNUSED", "prop_id", ",", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_STATIC_NOERR", "/*", "Sanity", "check", "*/", "HDassert", "(", "value", ")", ";", "/*", "Copy", "the", "prefix", "*/", "*", "(", "char", "*", "*", ")", "value", "=", "H5MM_xstrdup", "(", "*", "(", "const", "char", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Gets", "the", "prefix", "to", "be", "used", "for", "any", "external", "files" ]

[ "'ssize_t", "H5Pget_efile_prefix", "(", "hid_t", "plist_id", ",", "char", "*", "prefix", ",", "size_t", "size", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "char", "*", "my_prefix", ";", "/*", "Library\\'s", "copy", "of", "the", "prefix", "*/", "size_t", "len", ";", "/*", "Length", "of", "prefix", "string", "*/", "ssize_t", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE3", "(", "\"Zs\"", ",", "\"i*sz\"", ",", "plist_id", ",", "prefix", ",", "size", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Get", "the", "current", "prefix", "*/", "if", "(", "H5P_peek", "(", "plist", ",", "H5D_ACS_EFILE_PREFIX_NAME", ",", "&", "my_prefix", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "external", "file", "prefix\"", ")", "/*", "Check", "for", "prefix", "being", "set", "*/", "if", "(", "my_prefix", ")", "{", "/*", "Copy", "to", "user\\'s", "buffer,", "if", "given", "*/", "len", "=", "HDstrlen", "(", "my_prefix", ")", ";", "if", "(", "prefix", ")", "{", "HDstrncpy", "(", "prefix", ",", "my_prefix", ",", "MIN", "(", "len", "+", "1", ",", "size", ")", ")", ";", "if", "(", "len", ">=", "size", ")", "prefix", "[", "size", "-", "1", "]", "=", "\\'\\\\0\\'", ";", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "else", "len", "=", "0", ";", "/*", "Set", "return", "value", "*/", "ret_value", "=", "(", "ssize_t", ")", "len", ";", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Gets", "the", "prefix", "to", "be", "applied", "to", "any", "vds", "file", "traversals", "made", "using", "this", "property", "list" ]

[ "'ssize_t", "H5Pget_virtual_prefix", "(", "hid_t", "plist_id", ",", "char", "*", "prefix", ",", "size_t", "size", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "char", "*", "my_prefix", ";", "/*", "Library\\'s", "copy", "of", "the", "prefix", "*/", "size_t", "len", ";", "/*", "Length", "of", "prefix", "string", "*/", "ssize_t", "ret_value", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE3", "(", "\"Zs\"", ",", "\"i*sz\"", ",", "plist_id", ",", "prefix", ",", "size", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Get", "the", "current", "prefix", "*/", "if", "(", "H5P_peek", "(", "plist", ",", "H5D_ACS_VDS_PREFIX_NAME", ",", "&", "my_prefix", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "vds", "file", "prefix\"", ")", "/*", "Check", "for", "prefix", "being", "set", "*/", "if", "(", "my_prefix", ")", "{", "/*", "Copy", "to", "user\\'s", "buffer,", "if", "given", "*/", "len", "=", "HDstrlen", "(", "my_prefix", ")", ";", "if", "(", "prefix", ")", "{", "HDstrncpy", "(", "prefix", ",", "my_prefix", ",", "MIN", "(", "len", "+", "1", ",", "size", ")", ")", ";", "if", "(", "len", ">=", "size", ")", "prefix", "[", "size", "-", "1", "]", "=", "\\'\\\\0\\'", ";", "}", "/*", "end", "if", "*/", "}", "/*", "end", "if", "*/", "else", "len", "=", "0", ";", "/*", "Set", "return", "value", "*/", "ret_value", "=", "(", "ssize_t", ")", "len", ";", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Creates", "a", "copy", "of", "the", "external", "file", "prefix", "string" ]

[ "'static", "herr_t", "H5P__dapl_efile_pref_copy", "(", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "HDassert", "(", "value", ")", ";", "*", "(", "char", "*", "*", ")", "value", "=", "H5MM_xstrdup", "(", "*", "(", "const", "char", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Set", "a", "prefix", "to", "be", "applied", "to", "the", "path", "of", "any", "vds", "files", "traversed" ]

[ "'herr_t", "H5Pset_virtual_prefix", "(", "hid_t", "plist_id", ",", "const", "char", "*", "prefix", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE2", "(", "\"e\"", ",", "\"i*s\"", ",", "plist_id", ",", "prefix", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Set", "prefix", "*/", "if", "(", "H5P_set", "(", "plist", ",", "H5D_ACS_VDS_PREFIX_NAME", ",", "&", "prefix", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "prefix", "info\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Frees", "memory", "used", "to", "store", "the", "external", "file", "prefix", "string" ]

[ "'static", "herr_t", "H5P__dapl_efile_pref_close", "(", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "HDassert", "(", "value", ")", ";", "H5MM_xfree", "(", "*", "(", "void", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Takes", "the", "access", "property", "list", "for", "the", "virtual", "dataset,", "dapl_id,", "and", "gets", "the", "flag,", "view,", "set", "by", "the", "H5Pset_virtual_view", "call" ]

[ "'herr_t", "H5Pget_virtual_view", "(", "hid_t", "plist_id", ",", "H5D_vds_view_t", "*", "view", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE2", "(", "\"e\"", ",", "\"i*Dv\"", ",", "plist_id", ",", "view", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Get", "value", "from", "property", "list", "*/", "if", "(", "view", ")", "if", "(", "H5P_get", "(", "plist", ",", "H5D_ACS_VDS_VIEW_NAME", ",", "view", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"unable", "to", "get", "value\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Set", "the", "number", "of", "objects", "in", "the", "meta", "data", "cache", "and", "the", "maximum", "number", "of", "chunks", "and", "bytes", "in", "the", "raw", "data", "chunk", "cache" ]

[ "'herr_t", "H5Pset_chunk_cache", "(", "hid_t", "dapl_id", ",", "size_t", "rdcc_nslots", ",", "size_t", "rdcc_nbytes", ",", "double", "rdcc_w0", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE4", "(", "\"e\"", ",", "\"izzd\"", ",", "dapl_id", ",", "rdcc_nslots", ",", "rdcc_nbytes", ",", "rdcc_w0", ")", ";", "/*", "Check", "arguments.", "Note", "that", "we", "allow", "negative", "values", "-", "they", "are", "*", "considered", "to", "\"unset\"", "the", "property.", "*/", "if", "(", "rdcc_w0", ">", "(", "double", ")", "1.0f", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"raw", "data", "cache", "w0", "value", "must", "be", "between", "0.0", "and", "1.0", "inclusive,", "or", "H5D_CHUNK_CACHE_W0_DEFAULT\"", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "dapl_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", ";", "/*", "Set", "sizes", "*/", "if", "(", "H5P_set", "(", "plist", ",", "H5D_ACS_DATA_CACHE_NUM_SLOTS_NAME", ",", "&", "rdcc_nslots", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "data", "cache", "number", "of", "chunks\"", ")", ";", "if", "(", "H5P_set", "(", "plist", ",", "H5D_ACS_DATA_CACHE_BYTE_SIZE_NAME", ",", "&", "rdcc_nbytes", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "data", "cache", "byte", "size\"", ")", ";", "if", "(", "H5P_set", "(", "plist", ",", "H5D_ACS_PREEMPT_READ_CHUNKS_NAME", ",", "&", "rdcc_w0", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "preempt", "read", "chunks\"", ")", ";", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Retrieves", "the", "maximum", "possible", "number", "of", "elements", "in", "the", "meta", "data", "cache", "and", "the", "maximum", "possible", "number", "of", "elements", "and", "bytes", "and", "the", "RDCC_W0", "value", "in", "the", "raw", "data", "chunk", "cache" ]

[ "'herr_t", "H5Pget_chunk_cache", "(", "hid_t", "dapl_id", ",", "size_t", "*", "rdcc_nslots", ",", "size_t", "*", "rdcc_nbytes", ",", "double", "*", "rdcc_w0", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "H5P_genplist_t", "*", "def_plist", ";", "/*", "Default", "file", "access", "property", "list", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE4", "(", "\"e\"", ",", "\"i*z*z*d\"", ",", "dapl_id", ",", "rdcc_nslots", ",", "rdcc_nbytes", ",", "rdcc_w0", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "dapl_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", ";", "/*", "Get", "default", "file", "access", "plist", "*/", "if", "(", "NULL", "==", "(", "def_plist", "=", "(", "H5P_genplist_t", "*", ")", "H5I_object", "(", "H5P_FILE_ACCESS_DEFAULT", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "default", "fapl", "ID\"", ")", ";", "/*", "Get", "the", "properties.", "If", "a", "property", "is", "set", "to", "the", "default", "value,", "the", "value", "*", "from", "the", "default", "fapl", "is", "used.", "*/", "if", "(", "rdcc_nslots", ")", "{", "if", "(", "H5P_get", "(", "plist", ",", "H5D_ACS_DATA_CACHE_NUM_SLOTS_NAME", ",", "rdcc_nslots", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "data", "cache", "number", "of", "slots\"", ")", ";", "if", "(", "*", "rdcc_nslots", "==", "H5D_CHUNK_CACHE_NSLOTS_DEFAULT", ")", "if", "(", "H5P_get", "(", "def_plist", ",", "H5F_ACS_DATA_CACHE_NUM_SLOTS_NAME", ",", "rdcc_nslots", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "default", "data", "cache", "number", "of", "slots\"", ")", ";", "}", "/*", "end", "if", "*/", "if", "(", "rdcc_nbytes", ")", "{", "if", "(", "H5P_get", "(", "plist", ",", "H5D_ACS_DATA_CACHE_BYTE_SIZE_NAME", ",", "rdcc_nbytes", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "data", "cache", "byte", "size\"", ")", ";", "if", "(", "*", "rdcc_nbytes", "==", "H5D_CHUNK_CACHE_NBYTES_DEFAULT", ")", "if", "(", "H5P_get", "(", "def_plist", ",", "H5F_ACS_DATA_CACHE_BYTE_SIZE_NAME", ",", "rdcc_nbytes", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "default", "data", "cache", "byte", "size\"", ")", ";", "}", "/*", "end", "if", "*/", "if", "(", "rdcc_w0", ")", "{", "if", "(", "H5P_get", "(", "plist", ",", "H5D_ACS_PREEMPT_READ_CHUNKS_NAME", ",", "rdcc_w0", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "preempt", "read", "chunks\"", ")", ";", "if", "(", "*", "rdcc_w0", "<", "0", ")", "if", "(", "H5P_get", "(", "def_plist", ",", "H5F_ACS_PREEMPT_READ_CHUNKS_NAME", ",", "rdcc_w0", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTGET", ",", "FAIL", ",", "\"can\\'t", "get", "default", "preempt", "read", "chunks\"", ")", ";", "}", "/*", "end", "if", "*/", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Set", "a", "prefix", "to", "be", "used", "for", "any", "external", "files" ]

[ "'herr_t", "H5Pset_efile_prefix", "(", "hid_t", "plist_id", ",", "const", "char", "*", "prefix", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "Return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE2", "(", "\"e\"", ",", "\"i*s\"", ",", "plist_id", ",", "prefix", ")", ";", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Set", "prefix", "*/", "if", "(", "H5P_set", "(", "plist", ",", "H5D_ACS_EFILE_PREFIX_NAME", ",", "&", "prefix", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"can\\'t", "set", "prefix", "info\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Copies", "an", "external", "file", "prefix", "property", "when", "it's", "retrieved", "from", "a", "property", "list" ]

[ "'static", "herr_t", "H5P__dapl_efile_pref_get", "(", "hid_t", "H5_ATTR_UNUSED", "prop_id", ",", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_STATIC_NOERR", "/*", "Sanity", "check", "*/", "HDassert", "(", "value", ")", ";", "/*", "Copy", "the", "prefix", "*/", "*", "(", "char", "*", "*", ")", "value", "=", "H5MM_xstrdup", "(", "*", "(", "const", "char", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]

[ "Takes", "the", "access", "property", "list", "for", "the", "virtual", "dataset,", "dapl_id,", "and", "the", "flag,", "view,", "and", "sets", "the", "VDS", "view", "according", "to", "the", "flag", "value" ]

[ "'herr_t", "H5Pset_virtual_view", "(", "hid_t", "plist_id", ",", "H5D_vds_view_t", "view", ")", "{", "H5P_genplist_t", "*", "plist", ";", "/*", "Property", "list", "pointer", "*/", "herr_t", "ret_value", "=", "SUCCEED", ";", "/*", "return", "value", "*/", "FUNC_ENTER_API", "(", "FAIL", ")", "H5TRACE2", "(", "\"e\"", ",", "\"iDv\"", ",", "plist_id", ",", "view", ")", ";", "/*", "Check", "argument", "*/", "if", "(", "(", "view", "!=", "H5D_VDS_FIRST_MISSING", ")", "&&", "(", "view", "!=", "H5D_VDS_LAST_AVAILABLE", ")", ")", "HGOTO_ERROR", "(", "H5E_ARGS", ",", "H5E_BADVALUE", ",", "FAIL", ",", "\"not", "a", "valid", "bounds", "option\"", ")", "/*", "Get", "the", "plist", "structure", "*/", "if", "(", "NULL", "==", "(", "plist", "=", "H5P_object_verify", "(", "plist_id", ",", "H5P_DATASET_ACCESS", ")", ")", ")", "HGOTO_ERROR", "(", "H5E_ATOM", ",", "H5E_BADATOM", ",", "FAIL", ",", "\"can\\'t", "find", "object", "for", "ID\"", ")", "/*", "Update", "property", "list", "*/", "if", "(", "H5P_set", "(", "plist", ",", "H5D_ACS_VDS_VIEW_NAME", ",", "&", "view", ")", "<", "0", ")", "HGOTO_ERROR", "(", "H5E_PLIST", ",", "H5E_CANTSET", ",", "FAIL", ",", "\"unable", "to", "set", "value\"", ")", "done", ":", "FUNC_LEAVE_API", "(", "ret_value", ")", "}'" ]

[ "Creates", "a", "copy", "of", "the", "vds", "file", "prefix", "string" ]

[ "'static", "herr_t", "H5P__dapl_vds_file_pref_copy", "(", "const", "char", "H5_ATTR_UNUSED", "*", "name", ",", "size_t", "H5_ATTR_UNUSED", "size", ",", "void", "*", "value", ")", "{", "FUNC_ENTER_NOAPI_NOINIT_NOERR", "HDassert", "(", "value", ")", ";", "*", "(", "char", "*", "*", ")", "value", "=", "H5MM_xstrdup", "(", "*", "(", "const", "char", "*", "*", ")", "value", ")", ";", "FUNC_LEAVE_NOAPI", "(", "SUCCEED", ")", "}'" ]