int does_filter_use_ra (filter_t *filter) { internal_t *r_internal, *a_internal; g_assert(filter->kind == FILTER_MATHMAP); r_internal = lookup_internal(filter->v.mathmap.internals, "r", 1); a_internal = lookup_internal(filter->v.mathmap.internals, "a", 1); g_assert(r_internal != NULL && a_internal != NULL); return r_internal->is_used || a_internal->is_used; }
exprtree* make_var (scanner_ident_t *name_ident) { char *name = name_ident->str; scanner_region_t region = name_ident->region; tuple_info_t info; exprtree *tree = 0; if (lookup_internal(the_mathmap->current_filter->v.mathmap.internals, name, 0) != 0) { tree = alloc_exprtree(); tree->type = EXPR_INTERNAL; tree->val.internal = lookup_internal(the_mathmap->current_filter->v.mathmap.internals, name, 0); tree->result = make_tuple_info(nil_tag_number, 1); tree->region = region; } else if (lookup_variable_macro(name, &info) != 0) { macro_function_t function = lookup_variable_macro(name, &info); tree = function(0); tree->region = name_ident->region; } else if (lookup_userval(the_mathmap->current_filter->userval_infos, name) != 0) { userval_info_t *info = lookup_userval(the_mathmap->current_filter->userval_infos, name); tree = make_userval(info, 0, region); } else if (lookup_variable(the_mathmap->current_filter->v.mathmap.variables, name, &info) != 0) { variable_t *var = lookup_variable(the_mathmap->current_filter->v.mathmap.variables, name, &info); return make_var_exprtree(var, info, region); } else { sprintf(error_string, _("Undefined variable %s."), name); error_region = region; JUMP(1); } return tree; }
int does_filter_use_t (filter_t *filter) { internal_t *t_internal; g_assert(filter->kind == FILTER_MATHMAP); t_internal = lookup_internal(filter->v.mathmap.internals, "t", 1); g_assert(t_internal != NULL); return t_internal->is_used; }
void register_args_as_uservals (filter_t *filter, arg_decl_t *arg_decls) { arg_decl_t *decl; for (decl = arg_decls; decl != NULL; decl = decl->next) if (lookup_internal(filter->v.mathmap.internals, decl->name, TRUE) != NULL || lookup_variable_macro(decl->name, NULL) != NULL) { sprintf(error_string, _("Argument `%s' has the same name as an internal variable."), decl->name); error_region = decl->region; JUMP(1); } g_assert(filter->userval_infos == NULL && filter->num_uservals == 0); filter->userval_infos = arg_decls_to_uservals(filter, arg_decls); filter->num_uservals = count_userval_infos(filter->userval_infos); }
exprtree* make_assignment (scanner_ident_t *name_ident, exprtree *value) { char *name = name_ident->str; scanner_region_t region = name_ident->region; exprtree *tree = alloc_exprtree(); variable_t *var = lookup_variable(the_mathmap->current_filter->v.mathmap.variables, name, &tree->result); if (var == NULL) { if (lookup_internal(the_mathmap->current_filter->v.mathmap.internals, name, TRUE) != NULL || lookup_variable_macro(name, NULL) != NULL) { sprintf(error_string, _("Cannot assign to internal variable `%s'."), name); error_region = region; JUMP(1); } if (lookup_userval(the_mathmap->current_filter->userval_infos, name) != NULL) { sprintf(error_string, _("Cannot assign to filter argument `%s'."), name); error_region = region; JUMP(1); } var = register_variable(&the_mathmap->current_filter->v.mathmap.variables, name, value->result); tree->result = value->result; } if (tree->result.number != value->result.number || tree->result.length != value->result.length) { sprintf(error_string, _("Variable %s is being assigned two different types."), name); error_region = region; JUMP(1); } tree->type = EXPR_ASSIGNMENT; tree->val.assignment.var = var; tree->val.assignment.value = value; tree->region = region; return tree; }
GSocketConnectable * cockpit_channel_parse_connectable (CockpitChannel *self, gchar **possible_name, gboolean *local_address) { const gchar *problem = "protocol-error"; GSocketConnectable *connectable = NULL; const gchar *unix_path; const gchar *internal; const gchar *address; JsonObject *options; gboolean local = FALSE; GError *error = NULL; const gchar *host; gint64 port; options = self->priv->open_options; if (!cockpit_json_get_string (options, "unix", NULL, &unix_path)) { g_warning ("invalid \"unix\" option in channel"); goto out; } if (!cockpit_json_get_int (options, "port", G_MAXINT64, &port)) { g_warning ("invalid \"port\" option in channel"); goto out; } if (!cockpit_json_get_string (options, "internal", NULL, &internal)) { g_warning ("invalid \"internal\" option in channel"); goto out; } if (!cockpit_json_get_string (options, "address", NULL, &address)) { g_warning ("invalid \"address\" option in channel"); goto out; } if (port != G_MAXINT64 && unix_path) { g_warning ("cannot specify both \"port\" and \"unix\" options"); goto out; } else if (port != G_MAXINT64) { if (port <= 0 || port > 65535) { g_warning ("received invalid \"port\" option"); goto out; } if (address) { connectable = g_network_address_new (address, port); host = address; /* This isn't perfect, but matches the use case. Specify address => non-local */ local = FALSE; } else if (cockpit_bridge_local_address) { connectable = g_network_address_parse (cockpit_bridge_local_address, port, &error); host = cockpit_bridge_local_address; local = TRUE; } else { connectable = cockpit_loopback_new (port); host = "localhost"; local = TRUE; } if (error != NULL) { g_warning ("couldn't parse local address: %s: %s", host, error->message); problem = "internal-error"; goto out; } else { if (possible_name) *possible_name = g_strdup_printf ("%s:%d", host, (gint)port); } } else if (unix_path) { if (possible_name) *possible_name = g_strdup (unix_path); connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new (unix_path)); local = FALSE; } else if (internal) { gboolean reg = lookup_internal (internal, &connectable); if (!connectable) { if (!reg) g_warning ("couldn't find internal address: %s", internal); problem = "not-found"; goto out; } if (possible_name) *possible_name = g_strdup (internal); connectable = g_object_ref (connectable); local = FALSE; } else { g_warning ("no \"port\" or \"unix\" or other address option for channel"); goto out; } problem = NULL; out: g_clear_error (&error); if (problem) { cockpit_channel_close (self, problem); if (connectable) g_object_unref (connectable); connectable = NULL; } else { if (local_address) *local_address = local; } return connectable; }