static void
get_type_str(char *dst, size_t dstsize, int type)
{
static struct flag_definition defs[] = {
DEFINE_FLAG(SOCK_CLOEXEC),
DEFINE_FLAG(SOCK_NONBLOCK)
};
static const char *types[] = {
UNKNOWN,
"SOCK_STREAM",
"SOCK_DGRAM",
"SOCK_RAW",
"SOCK_RDM",
"SOCK_SEQPACKET"
};
static int ntypes = array_sizeof(types);
int flags = SOCK_CLOEXEC | SOCK_NONBLOCK;
const char *fmt, *s;
char t[256];
s = get_array_element(types, ntypes, ~flags & type);
fmaster_chain_flags(t, sizeof(t), flags & type, defs,
array_sizeof(defs));
fmt = t[0] == '\0' ? "%s" : "%s|%s";
snprintf(dst, dstsize, fmt, s, t);
}
int
sys_fmaster_recvmsg(struct thread *td, struct fmaster_recvmsg_args *uap)
{
struct flag_definition defs[] = {
DEFINE_FLAG(MSG_OOB),
DEFINE_FLAG(MSG_PEEK),
DEFINE_FLAG(MSG_WAITALL),
DEFINE_FLAG(MSG_DONTWAIT),
DEFINE_FLAG(MSG_CMSG_CLOEXEC)
};
struct timeval time_start;
int error, flags;
char flagsstr[256];
flags = uap->flags;
fmaster_chain_flags(flagsstr, sizeof(flagsstr), flags, defs,
array_sizeof(defs));
fmaster_log(td, LOG_DEBUG,
"%s: started: s=%d, msg=%p, flags=0x%x (%s)",
sysname, uap->s, uap->msg, flags, flagsstr);
microtime(&time_start);
error = fmaster_recvmsg_main(td, uap);
fmaster_log_syscall_end(td, sysname, &time_start, error);
return (error);
}
void
rb_grn_init_query_logger (VALUE mGrn)
{
id_new = rb_intern("new");
id_parse = rb_intern("parse");
id_log = rb_intern("log");
id_reopen = rb_intern("reopen");
id_fin = rb_intern("fin");
rb_grn_query_logger.log = rb_grn_query_logger_log;
rb_grn_query_logger.reopen = rb_grn_query_logger_reopen;
rb_grn_query_logger.fin = rb_grn_query_logger_fin;
rb_grn_query_logger.user_data = (void *)Qnil;
cGrnQueryLogger = rb_define_class_under(mGrn, "QueryLogger", rb_cObject);
rb_cv_set(cGrnQueryLogger, "@@current_logger", Qnil);
rb_define_singleton_method(cGrnQueryLogger, "log",
rb_grn_query_logger_s_log, -1);
rb_define_singleton_method(cGrnQueryLogger, "register",
rb_grn_query_logger_s_register, -1);
rb_define_singleton_method(cGrnQueryLogger, "unregister",
rb_grn_query_logger_s_unregister, 0);
rb_define_singleton_method(cGrnQueryLogger, "reopen",
rb_grn_query_logger_s_reopen, 0);
rb_define_singleton_method(cGrnQueryLogger, "path",
rb_grn_query_logger_s_get_path, 0);
rb_define_singleton_method(cGrnQueryLogger, "path=",
rb_grn_query_logger_s_set_path, 1);
rb_define_singleton_method(cGrnQueryLogger, "rotate_threshold_size",
rb_grn_query_logger_s_get_rotate_threshold_size,
0);
rb_define_singleton_method(cGrnQueryLogger, "rotate_threshold_size=",
rb_grn_query_logger_s_set_rotate_threshold_size,
1);
mGrnQueryLoggerFlags = rb_define_module_under(cGrnQueryLogger, "Flags");
#define DEFINE_FLAG(NAME) \
rb_define_const(mGrnQueryLoggerFlags, \
#NAME, UINT2NUM(GRN_QUERY_LOG_ ## NAME))
DEFINE_FLAG(NONE);
DEFINE_FLAG(COMMAND);
DEFINE_FLAG(RESULT_CODE);
DEFINE_FLAG(DESTINATION);
DEFINE_FLAG(CACHE);
DEFINE_FLAG(SIZE);
DEFINE_FLAG(SCORE);
DEFINE_FLAG(ALL);
DEFINE_FLAG(DEFAULT);
#undef DEFINE_FLAG
cGrnCallbackQueryLogger =
rb_define_class_under(mGrn, "CallbackQueryLogger", cGrnQueryLogger);
}
//==========================================================================
//
// List of all flags
//
//==========================================================================
// [RH] Keep GCC quiet by not using offsetof on Actor types.
#define DEFINE_FLAG(prefix, name, type, variable) { (unsigned int)prefix##_##name, #name, (int)(size_t)&((type*)1)->variable - 1, sizeof(((type *)0)->variable) }
#define DEFINE_FLAG2(symbol, name, type, variable) { (unsigned int)symbol, #name, (int)(size_t)&((type*)1)->variable - 1, sizeof(((type *)0)->variable) }
#define DEFINE_DEPRECATED_FLAG(name) { DEPF_##name, #name, -1, 0 }
#define DEFINE_DUMMY_FLAG(name) { DEPF_UNUSED, #name, -1, 0 }
static FFlagDef ActorFlagDefs[]=
{
DEFINE_FLAG(MF, PICKUP, APlayerPawn, flags),
DEFINE_FLAG(MF, SPECIAL, APlayerPawn, flags),
DEFINE_FLAG(MF, SOLID, AActor, flags),
DEFINE_FLAG(MF, SHOOTABLE, AActor, flags),
DEFINE_FLAG(MF, NOSECTOR, AActor, flags),
DEFINE_FLAG(MF, NOBLOCKMAP, AActor, flags),
DEFINE_FLAG(MF, AMBUSH, AActor, flags),
DEFINE_FLAG(MF, JUSTHIT, AActor, flags),
DEFINE_FLAG(MF, JUSTATTACKED, AActor, flags),
DEFINE_FLAG(MF, SPAWNCEILING, AActor, flags),
DEFINE_FLAG(MF, NOGRAVITY, AActor, flags),
DEFINE_FLAG(MF, DROPOFF, AActor, flags),
DEFINE_FLAG(MF, NOCLIP, AActor, flags),
DEFINE_FLAG(MF, FLOAT, AActor, flags),
DEFINE_FLAG(MF, TELEPORT, AActor, flags),
DEFINE_FLAG(MF, MISSILE, AActor, flags),
fd = td->td_retval[0];
snprintf(desc, sizeof(desc), "%s(s=%d)", sysname, s);
error = fmaster_return_fd(td, DTYPE_SOCKET, place, fd, desc);
if (error != 0)
return (error);
/* fmaster_return_fd() overwrote td->td_retval[0] with the virtual fd */
error = fmaster_set_close_on_exec(td, td->td_retval[0],
(SOCK_CLOEXEC & flags) != 0);
if (error != 0)
return (error);
return (0);
}
static struct flag_definition flag_defs[] = {
DEFINE_FLAG(SOCK_CLOEXEC),
DEFINE_FLAG(SOCK_NONBLOCK)
};
int
sys_fmaster_accept4(struct thread *td, struct fmaster_accept4_args *uap)
{
struct sockaddr *name;
struct timeval time_start;
socklen_t *anamelen;
int error, flags, s;
const char *fmt = "%s: started: s=%d, name=%p, anamelen=%p, flags=0x%x "
"(%s)";
char buf[256];
s = uap->s;
void
rb_grn_init_logger (VALUE mGrn)
{
id_caller_locations = rb_intern("caller_locations");
id_path = rb_intern("path");
id_lineno = rb_intern("lineno");
id_label = rb_intern("label");
id_new = rb_intern("new");
id_parse = rb_intern("parse");
id_log = rb_intern("log");
id_reopen = rb_intern("reopen");
id_fin = rb_intern("fin");
rb_grn_logger.log = rb_grn_logger_log;
rb_grn_logger.reopen = rb_grn_logger_reopen;
rb_grn_logger.fin = rb_grn_logger_fin;
rb_grn_logger.user_data = (void *)Qnil;
rb_cGrnLogger = rb_define_class_under(mGrn, "Logger", rb_cObject);
rb_cv_set(rb_cGrnLogger, "@@current_logger", Qnil);
rb_define_singleton_method(rb_cGrnLogger, "log",
rb_grn_logger_s_log, -1);
rb_define_singleton_method(rb_cGrnLogger, "register",
rb_grn_logger_s_register, -1);
rb_define_singleton_method(rb_cGrnLogger, "unregister",
rb_grn_logger_s_unregister, 0);
rb_define_singleton_method(rb_cGrnLogger, "reopen",
rb_grn_logger_s_reopen, 0);
rb_define_singleton_method(rb_cGrnLogger, "max_level",
rb_grn_logger_s_get_max_level, 0);
rb_define_singleton_method(rb_cGrnLogger, "max_level=",
rb_grn_logger_s_set_max_level, 1);
rb_define_singleton_method(rb_cGrnLogger, "path",
rb_grn_logger_s_get_path, 0);
rb_define_singleton_method(rb_cGrnLogger, "path=",
rb_grn_logger_s_set_path, 1);
rb_define_singleton_method(rb_cGrnLogger, "flags",
rb_grn_logger_s_get_flags, 0);
rb_define_singleton_method(rb_cGrnLogger, "flags=",
rb_grn_logger_s_set_flags, 1);
rb_define_singleton_method(rb_cGrnLogger, "rotate_threshold_size",
rb_grn_logger_s_get_rotate_threshold_size, 0);
rb_define_singleton_method(rb_cGrnLogger, "rotate_threshold_size=",
rb_grn_logger_s_set_rotate_threshold_size, 1);
rb_set_end_proc(rb_grn_logger_reset, rb_cGrnLogger);
rb_mGrnLoggerFlags = rb_define_module_under(rb_cGrnLogger, "Flags");
#define DEFINE_FLAG(NAME) \
rb_define_const(rb_mGrnLoggerFlags, \
#NAME, INT2NUM(GRN_LOG_ ## NAME))
DEFINE_FLAG(TIME);
DEFINE_FLAG(TITLE);
DEFINE_FLAG(MESSAGE);
DEFINE_FLAG(LOCATION);
DEFINE_FLAG(PID);
#undef DEFINE_FLAG
rb_cGrnCallbackLogger =
rb_define_class_under(mGrn, "CallbackLogger", rb_cGrnLogger);
}
//==========================================================================
//
// List of all flags
//
//==========================================================================
// [RH] Keep GCC quiet by not using offsetof on Actor types.
#define DEFINE_FLAG(prefix, name, type, variable) { prefix##_##name, #name, (int)(size_t)&((type*)1)->variable - 1 }
#define DEFINE_FLAG2(symbol, name, type, variable) { symbol, #name, (int)(size_t)&((type*)1)->variable - 1 }
#define DEFINE_DEPRECATED_FLAG(name) { DEPF_##name, #name, -1 }
#define DEFINE_DUMMY_FLAG(name) { DEPF_UNUSED, #name, -1 }
static FFlagDef ActorFlags[]=
{
DEFINE_FLAG(MF, PICKUP, APlayerPawn, flags),
DEFINE_FLAG(MF, SPECIAL, APlayerPawn, flags),
DEFINE_FLAG(MF, SOLID, AActor, flags),
DEFINE_FLAG(MF, SHOOTABLE, AActor, flags),
DEFINE_FLAG(MF, NOSECTOR, AActor, flags),
DEFINE_FLAG(MF, NOBLOCKMAP, AActor, flags),
DEFINE_FLAG(MF, AMBUSH, AActor, flags),
DEFINE_FLAG(MF, JUSTHIT, AActor, flags),
DEFINE_FLAG(MF, JUSTATTACKED, AActor, flags),
DEFINE_FLAG(MF, SPAWNCEILING, AActor, flags),
DEFINE_FLAG(MF, NOGRAVITY, AActor, flags),
DEFINE_FLAG(MF, DROPOFF, AActor, flags),
DEFINE_FLAG(MF, NOCLIP, AActor, flags),
DEFINE_FLAG(MF, FLOAT, AActor, flags),
DEFINE_FLAG(MF, TELEPORT, AActor, flags),
DEFINE_FLAG(MF, MISSILE, AActor, flags),
void
grn_mrb_expr_init(grn_ctx *ctx)
{
mrb_state *mrb = ctx->impl->mrb.state;
struct RClass *module = ctx->impl->mrb.module;
struct RClass *object_class = ctx->impl->mrb.object_class;
struct RClass *klass;
klass = mrb_define_class_under(mrb, module, "ScanInfo", mrb->object_class);
MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
mrb_define_method(mrb, klass, "initialize",
mrb_grn_scan_info_initialize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "put_index",
mrb_grn_scan_info_put_index, MRB_ARGS_REQ(6));
mrb_define_method(mrb, klass, "op",
mrb_grn_scan_info_get_op, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "op=",
mrb_grn_scan_info_set_op, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "end=",
mrb_grn_scan_info_set_end, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "query=",
mrb_grn_scan_info_set_query, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "flags",
mrb_grn_scan_info_get_flags, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "flags=",
mrb_grn_scan_info_set_flags, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "logical_op",
mrb_grn_scan_info_get_logical_op, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "logical_op=",
mrb_grn_scan_info_set_logical_op, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "max_interval",
mrb_grn_scan_info_get_max_interval, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "max_interval=",
mrb_grn_scan_info_set_max_interval, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "similarity_threshold",
mrb_grn_scan_info_get_similarity_threshold, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "similarity_threshold=",
mrb_grn_scan_info_set_similarity_threshold, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "get_arg",
mrb_grn_scan_info_get_arg, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "push_arg",
mrb_grn_scan_info_push_arg, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "start_position",
mrb_grn_scan_info_get_start_position, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "start_position=",
mrb_grn_scan_info_set_start_position, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "reset_position",
mrb_grn_scan_info_reset_position, MRB_ARGS_NONE());
klass = mrb_define_class_under(mrb, module,
"ExpressionCode", mrb->object_class);
MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
mrb_define_method(mrb, klass, "initialize",
mrb_grn_expr_code_initialize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "inspect",
mrb_grn_expr_code_inspect, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "weight",
mrb_grn_expr_code_get_weight, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "value",
mrb_grn_expr_code_get_value, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "n_args",
mrb_grn_expr_code_get_n_args, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "op",
mrb_grn_expr_code_get_op, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "flags",
mrb_grn_expr_code_get_flags, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "modify",
mrb_grn_expr_code_get_modify, MRB_ARGS_NONE());
{
struct RClass *expression_code_class = klass;
struct RClass *flags_module;
flags_module = mrb_define_module_under(mrb, expression_code_class, "Flags");
mrb_define_const(mrb, flags_module, "RELATIONAL_EXPRESSION",
mrb_fixnum_value(GRN_EXPR_CODE_RELATIONAL_EXPRESSION));
}
klass = mrb_define_class_under(mrb, module, "Expression", object_class);
MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA);
#define DEFINE_FLAG(name) \
mrb_define_const(mrb, klass, \
#name, \
mrb_fixnum_value(GRN_EXPR_ ## name))
DEFINE_FLAG(SYNTAX_QUERY);
DEFINE_FLAG(SYNTAX_SCRIPT);
DEFINE_FLAG(SYNTAX_OUTPUT_COLUMNS);
DEFINE_FLAG(ALLOW_PRAGMA);
DEFINE_FLAG(ALLOW_COLUMN);
DEFINE_FLAG(ALLOW_UPDATE);
DEFINE_FLAG(ALLOW_LEADING_NOT);
#undef DEFINE_FLAG
mrb_define_class_method(mrb, klass, "create",
mrb_grn_expression_class_create,
MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "initialize",
mrb_grn_expression_initialize, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "empty?",
mrb_grn_expression_is_empty, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "codes",
mrb_grn_expression_codes, MRB_ARGS_NONE());
mrb_define_method(mrb, klass, "[]",
mrb_grn_expression_array_reference, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "condition=",
mrb_grn_expression_set_condition, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "take_object",
mrb_grn_expression_take_object, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "allocate_constant",
mrb_grn_expression_allocate_constant, MRB_ARGS_REQ(1));
mrb_define_method(mrb, klass, "parse",
mrb_grn_expression_parse, MRB_ARGS_ARG(1, 1));
mrb_define_method(mrb, klass, "append_object",
mrb_grn_expression_append_object, MRB_ARGS_REQ(2));
mrb_define_method(mrb, klass, "append_constant",
mrb_grn_expression_append_constant, MRB_ARGS_REQ(3));
mrb_define_method(mrb, klass, "append_operator",
mrb_grn_expression_append_operator, MRB_ARGS_REQ(2));
}
