/* parser.c * * Copyright 2026 Eva M * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * SPDX-License-Identifier: GPL-3.0-or-later */ #define G_LOG_DOMAIN "BGE::WDGT-PARSE" #include #include #include "../bge-wdgt-spec-private.h" #include "../util/marshal.h" #include "bge-marshalers.h" #include "parser.h" #include "util.h" #define IS_EOF(_p) ((_p) == NULL || *(_p) == '\0') #define SINGLE_CHAR_TOKENS "{}()=:;," #define EVAL_SINGLE_CHAR_TOKENS "#(),+-*/^%" #define STR_DEFARRAY "defarray" #define STR_DEFWIDGET "defwidget" #define STR_FOREACH "%FOREACH" #define STR_VARIABLE "var" #define STR_REFERENCE "reference" #define STR_INIT "init" #define STR_STATE "state" #define STR_DEFAULT_STATE "state-default" #define STR_SET "set" #define STR_TRANSITION "transition" #define STR_TRANSITION_SPRING "transition-spring" #define STR_ALLOCATE "allocate" #define STR_MEASURE "measure" #define STR_SNAPSHOT "snapshot" typedef enum { TOKEN_PARSE_DEFAULT = 0, TOKEN_PARSE_QUOTED = 1 << 0, } TokenParseFlags; typedef enum { ARGS_PARSE_PARENS = 0, ARGS_PARSE_LEFT_ASSIGN, ARGS_PARSE_RIGHT_ASSIGN, } ArgsParseKind; typedef enum { OPERATOR_ADD = 0, OPERATOR_SUBTRACT, OPERATOR_MULTIPLY, OPERATOR_DIVIDE, OPERATOR_MODULUS, OPERATOR_POWER, } Operator; static const int operator_precedence[] = { [OPERATOR_ADD] = 0, [OPERATOR_SUBTRACT] = 0, [OPERATOR_MULTIPLY] = 1, [OPERATOR_DIVIDE] = 1, [OPERATOR_MODULUS] = 1, [OPERATOR_POWER] = 2, }; typedef struct { Operator op; guint pos; } EvalOperator; BGE_DEFINE_DATA ( eval_closure, EvalClosure, { GArray *ops; gdouble *workbuf0; gdouble *workbuf1; }, BGE_RELEASE_DATA (ops, g_array_unref); BGE_RELEASE_DATA (workbuf0, g_free); BGE_RELEASE_DATA (workbuf1, g_free)); static BgeWdgtSpec * parse_string_inner (const char *string, guint *line, guint *column, GError **error); static const char * parse_widget_block (const char *p, BgeWdgtSpec *spec, GHashTable *macro_arrays, GHashTable *macro_replacements, guint *n_anon_vals, GHashTable *type_hints, guint *line, guint *column, GError **error); static const char * parse_snapshot_block (const char *p, BgeWdgtSpec *spec, const char *state, GHashTable *macro_replacements, guint *n_anon_vals, GHashTable *type_hints, guint *line, guint *column, GError **error); static const char * parse_eval (const char *p, BgeWdgtSpec *spec, const char *state, GHashTable *macro_replacements, guint *n_anon_vals, GHashTable *type_hints, guint *line, guint *column, char **value_out, GError **error); static const char * parse_args (const char *p, BgeWdgtSpec *spec, const char *state, const char *enclosing_object, GHashTable *macro_replacements, guint *n_anon_vals, GHashTable *type_hints, guint *line, guint *column, const char *const *destinations, GType destinations_types[], guint n_destinations, char ***values_out, GType **types_out, guint *n_out, ArgsParseKind parse_kind, GError **error); static char * parse_token_fundamental (const char *token, BgeWdgtSpec *spec, guint *n_anon_vals, guint *line, guint *column, GError **error); static char * consume_token (const char **pp, const char *single_chars, TokenParseFlags flags, gboolean *was_quoted, GHashTable *macro_replacements, guint *line, guint *column, GError **error); static char * consume_token_inner (const char **pp, const char *single_chars, TokenParseFlags flags, gboolean *was_quoted, guint *line, guint *column, GError **error); static gdouble eval_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data); static char * make_object_property_name (const char *object, const char *property, guint n); static char * make_widget_allocation_name (const char *widget, guint n); static char * make_widget_measurement_name (guint n); static char * make_anon_name (guint n); static gint cmp_operator (EvalOperator *a, EvalOperator *b); BgeWdgtSpec * bge_wdgt_parse_string (const char *string, GError **error) { g_autoptr (GError) local_error = NULL; guint line = 0; guint column = 0; g_autoptr (BgeWdgtSpec) spec = NULL; g_return_val_if_fail (string != NULL, FALSE); spec = parse_string_inner (string, &line, &column, &local_error); if (spec == NULL) { g_set_error ( error, local_error->domain, local_error->code, "wdgt parser error in string input " "at line:%u, offset:%u : %s", line, column, local_error->message); return NULL; } return g_steal_pointer (&spec); } static BgeWdgtSpec * parse_string_inner (const char *string, guint *line, guint *column, GError **error) { g_autoptr (GError) local_error = NULL; gboolean result = FALSE; g_autoptr (BgeWdgtSpec) spec = NULL; g_autoptr (GHashTable) macro_arrays = NULL; g_autoptr (GHashTable) macro_replacements = NULL; guint n_anon_vals = 0; g_autoptr (GHashTable) type_hints = NULL; spec = bge_wdgt_spec_new (); macro_arrays = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_ptr_array_unref); macro_replacements = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, g_free); type_hints = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, NULL); #define RETURN_ERROR_UNLESS(_cond) \ G_STMT_START \ { \ if (!(_cond)) \ { \ g_set_error ( \ error, \ G_IO_ERROR, \ G_IO_ERROR_UNKNOWN, \ "%s", \ local_error != NULL \ ? local_error->message \ : "???"); \ return NULL; \ } \ } \ G_STMT_END #define EXPECT_TOKEN(_string, _token) \ G_STMT_START \ { \ if (g_strcmp0 ((_string), (_token)) != 0) \ { \ g_set_error ( \ error, \ G_IO_ERROR, \ G_IO_ERROR_UNKNOWN, \ "expected token \"%s\", got \"%s\"", \ (_token), (_string)); \ return NULL; \ } \ } \ G_STMT_END #define UNEXPECTED_TOKEN(_token) \ G_STMT_START \ { \ g_set_error ( \ error, \ G_IO_ERROR, \ G_IO_ERROR_UNKNOWN, \ "unexpected token \"%s\"", (_token)); \ return NULL; \ } \ G_STMT_END result = bge_wdgt_spec_add_measure_for_size_source_value ( spec, "%for-size%", &local_error); RETURN_ERROR_UNLESS (result); g_hash_table_replace ( type_hints, g_strdup ("%for-size%"), GSIZE_TO_POINTER (G_TYPE_INT)); result = bge_wdgt_spec_add_widget_width_source_value ( spec, "%width%", &local_error); RETURN_ERROR_UNLESS (result); g_hash_table_replace ( type_hints, g_strdup ("%width%"), GSIZE_TO_POINTER (G_TYPE_INT)); result = bge_wdgt_spec_add_widget_height_source_value ( spec, "%height%", &local_error); RETURN_ERROR_UNLESS (result); g_hash_table_replace ( type_hints, g_strdup ("%height%"), GSIZE_TO_POINTER (G_TYPE_INT)); result = bge_wdgt_spec_add_tick_time_source_value ( spec, "%tick%", &local_error); RETURN_ERROR_UNLESS (result); g_hash_table_replace ( type_hints, g_strdup ("%tick%"), GSIZE_TO_POINTER (G_TYPE_DOUBLE)); for (const char *p = string; !IS_EOF (p);) { g_autofree char *token = NULL; token = consume_token ( &p, SINGLE_CHAR_TOKENS, TOKEN_PARSE_DEFAULT, NULL, NULL, line, column, NULL); if (token == NULL) break; #define GET_TOKEN_FULL(_token_out, _flags, _single_chars, _was_quoted) \ G_STMT_START \ { \ g_clear_pointer ((_token_out), g_free); \ *(_token_out) = consume_token ( \ &p, \ (_single_chars), \ (_flags), \ (_was_quoted), \ macro_replacements, \ line, column, \ &local_error); \ RETURN_ERROR_UNLESS (*(_token_out) != NULL); \ } \ G_STMT_END #define GET_TOKEN(_token_out, _flags) \ GET_TOKEN_FULL (_token_out, _flags, SINGLE_CHAR_TOKENS, NULL) #define GET_TOKEN_EXPECT(_token_out, _flags, _expect) \ G_STMT_START \ { \ GET_TOKEN ((_token_out), (_flags)); \ EXPECT_TOKEN (*(_token_out), (_expect)); \ } \ G_STMT_END if (g_strcmp0 (token, STR_DEFWIDGET) == 0) { g_autofree char *widget_name = NULL; GET_TOKEN (&widget_name, TOKEN_PARSE_QUOTED); bge_wdgt_spec_set_name (spec, widget_name); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "{"); p = parse_widget_block ( p, spec, macro_arrays, macro_replacements, &n_anon_vals, type_hints, line, column, &local_error); RETURN_ERROR_UNLESS (p != NULL); } else if (g_strcmp0 (token, STR_DEFARRAY) == 0) { g_autofree char *array_name = NULL; guint n_elements = 0; g_auto (GStrv) elements = NULL; g_autoptr (GPtrArray) array = NULL; GET_TOKEN (&array_name, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, NULL, NULL, macro_replacements, &n_anon_vals, type_hints, line, column, NULL, NULL, 0, &elements, NULL, &n_elements, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); array = g_ptr_array_new_take_null_terminated ( (gpointer *) g_steal_pointer (&elements), g_free); g_hash_table_replace ( macro_arrays, g_steal_pointer (&array_name), g_steal_pointer (&array)); } else UNEXPECTED_TOKEN (token); } return g_steal_pointer (&spec); } static const char * parse_widget_block (const char *p, BgeWdgtSpec *spec, GHashTable *macro_arrays, GHashTable *macro_replacements, guint *n_anon_vals, GHashTable *type_hints, guint *line, guint *column, GError **error) { g_autoptr (GError) local_error = NULL; gboolean result = FALSE; g_autofree char *token = NULL; for (;;) { GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (token, "}") == 0) return p; else if (g_strcmp0 (token, STR_FOREACH) == 0) { g_autofree char *var_name = NULL; g_autofree char *iterator_name = NULL; g_autofree char *iterator_paste_name = NULL; g_autofree char *array_name = NULL; GPtrArray *array = NULL; const char *fixed_p = NULL; GET_TOKEN (&var_name, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ","); GET_TOKEN (&iterator_name, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ","); GET_TOKEN (&iterator_paste_name, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "IN"); GET_TOKEN (&array_name, TOKEN_PARSE_DEFAULT); array = g_hash_table_lookup (macro_arrays, array_name); if (array == NULL) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "macro array \"%s\" is undefined", array_name); return NULL; } GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "{"); fixed_p = p; for (guint i = 0; i < array->len; i++) { const char *element = NULL; g_autofree char *iterator = NULL; g_autofree char *iterator_paste = NULL; GValue iter_value = G_VALUE_INIT; element = g_ptr_array_index (array, i); g_hash_table_replace ( macro_replacements, g_strdup (var_name), g_strdup (element)); iterator = make_anon_name ((*n_anon_vals)++); g_value_set_uint (g_value_init (&iter_value, G_TYPE_UINT), i); result = bge_wdgt_spec_add_constant_source_value ( spec, iterator, &iter_value, &local_error); g_value_unset (&iter_value); RETURN_ERROR_UNLESS (result); g_hash_table_replace ( macro_replacements, g_strdup (iterator_name), g_steal_pointer (&iterator)); iterator_paste = g_strdup_printf ("%u", i); g_hash_table_replace ( macro_replacements, g_strdup (iterator_paste_name), g_steal_pointer (&iterator_paste)); p = parse_widget_block ( fixed_p, spec, macro_arrays, macro_replacements, n_anon_vals, type_hints, line, column, &local_error); RETURN_ERROR_UNLESS (p != NULL); } g_hash_table_remove (macro_replacements, var_name); g_hash_table_remove (macro_replacements, iterator_name); g_hash_table_remove (macro_replacements, iterator_paste_name); } else if (g_strcmp0 (token, STR_VARIABLE) == 0) { g_autofree char *name = NULL; g_autofree char *type_string = NULL; GType type = 0; GET_TOKEN (&name, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ":"); GET_TOKEN (&type_string, TOKEN_PARSE_QUOTED); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ";"); type = g_type_from_name (type_string); result = bge_wdgt_spec_add_variable_value ( spec, type, name, &local_error); RETURN_ERROR_UNLESS (result); g_hash_table_replace (type_hints, g_steal_pointer (&name), GSIZE_TO_POINTER (type)); } else if (g_strcmp0 (token, STR_REFERENCE) == 0) { g_autofree char *name = NULL; g_autofree char *type_string = NULL; GType type = 0; GET_TOKEN (&name, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ":"); GET_TOKEN (&type_string, TOKEN_PARSE_QUOTED); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ";"); type = g_type_from_name (type_string); result = bge_wdgt_spec_add_reference_object_value ( spec, type, name, &local_error); RETURN_ERROR_UNLESS (result); g_hash_table_replace (type_hints, g_steal_pointer (&name), GSIZE_TO_POINTER (type)); } else if (g_strcmp0 (token, STR_INIT) == 0 || g_strcmp0 (token, STR_STATE) == 0 || g_strcmp0 (token, STR_DEFAULT_STATE) == 0) { g_autofree char *state_name = NULL; if (g_strcmp0 (token, STR_INIT) != 0) { GET_TOKEN (&state_name, TOKEN_PARSE_QUOTED); result = bge_wdgt_spec_add_state ( spec, state_name, g_strcmp0 (token, STR_DEFAULT_STATE) == 0, &local_error); /* TODO: allow states to be redefined for macros, so they are just concatenated */ g_clear_error (&local_error); // RETURN_ERROR_UNLESS (result); } GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "{"); for (;;) { GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (token, "}") == 0) break; else if (g_strcmp0 (token, STR_SNAPSHOT) == 0) { GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "{"); p = parse_snapshot_block (p, spec, state_name, macro_replacements, n_anon_vals, type_hints, line, column, &local_error); RETURN_ERROR_UNLESS (p != NULL); } else if (g_strcmp0 (token, STR_SET) == 0) { guint n_dest_values = 0; g_auto (GStrv) dest_values = NULL; g_autofree GType *dest_types = NULL; guint n_src_values = 0; g_auto (GStrv) src_values = NULL; p = parse_args (p, spec, state_name, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, NULL, 0, &dest_values, &dest_types, &n_dest_values, ARGS_PARSE_LEFT_ASSIGN, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_dest_values == 0) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Left assignment needs at least one argument"); return NULL; } p = parse_args (p, spec, state_name, NULL, macro_replacements, n_anon_vals, type_hints, line, column, (const char *const *) dest_values, dest_types, n_dest_values, &src_values, NULL, &n_src_values, ARGS_PARSE_RIGHT_ASSIGN, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_src_values != n_dest_values) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Right assignment needs %d argument(s) " "to match the left side", n_dest_values); return NULL; } for (guint i = 0; i < n_dest_values; i++) { result = bge_wdgt_spec_set_value ( spec, state_name, dest_values[i], src_values[i], &local_error); RETURN_ERROR_UNLESS (result); } } else if (g_strcmp0 (token, STR_TRANSITION) == 0) { g_autofree char *transition_value = NULL; guint n_spec_values = 0; g_auto (GStrv) spec_values = NULL; GET_TOKEN (&transition_value, TOKEN_PARSE_DEFAULT); p = parse_args (p, spec, state_name, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ G_TYPE_DOUBLE, BGE_TYPE_EASING }, 2, &spec_values, NULL, &n_spec_values, ARGS_PARSE_RIGHT_ASSIGN, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_spec_values != 2) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "transition spec needs 2 arguments " "(animation length in seconds, easing type), got %u", n_spec_values); return NULL; } result = bge_wdgt_spec_transition_value ( spec, state_name, transition_value, spec_values[0], spec_values[1], &local_error); RETURN_ERROR_UNLESS (result); } else if (g_strcmp0 (token, STR_TRANSITION_SPRING) == 0) { g_autofree char *transition_value = NULL; guint n_spec_values = 0; g_auto (GStrv) spec_values = NULL; GET_TOKEN (&transition_value, TOKEN_PARSE_DEFAULT); p = parse_args (p, spec, state_name, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE }, 3, &spec_values, NULL, &n_spec_values, ARGS_PARSE_RIGHT_ASSIGN, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_spec_values != 3) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "spring transition spec needs 3 arguments " "(damping-ratio, mass, stiffness), got %u", n_spec_values); return NULL; } result = bge_wdgt_spec_transition_value_spring ( spec, state_name, transition_value, spec_values[0], spec_values[1], spec_values[2], &local_error); RETURN_ERROR_UNLESS (result); } else if (g_strcmp0 (token, STR_ALLOCATE) == 0) { g_autofree char *child_value = NULL; guint n_allocation_values = 0; g_auto (GStrv) allocation_values = NULL; GET_TOKEN (&child_value, TOKEN_PARSE_DEFAULT); p = parse_args (p, spec, state_name, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ G_TYPE_INT, G_TYPE_INT, GSK_TYPE_TRANSFORM }, 3, &allocation_values, NULL, &n_allocation_values, ARGS_PARSE_RIGHT_ASSIGN, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_allocation_values != 2 && n_allocation_values != 3) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "allocation needs 2 or 3 values, a width " "and height and one transform, got %u", n_allocation_values); return NULL; } for (guint i = 0; i < n_allocation_values; i++) { g_autofree char *allocation_key = NULL; allocation_key = make_widget_allocation_name (child_value, (*n_anon_vals)++); switch (i) { case 0: result = bge_wdgt_spec_add_allocation_width_value ( spec, allocation_key, child_value, &local_error); break; case 1: result = bge_wdgt_spec_add_allocation_height_value ( spec, allocation_key, child_value, &local_error); break; case 2: result = bge_wdgt_spec_add_allocation_transform_value ( spec, allocation_key, child_value, &local_error); break; default: g_assert_not_reached (); } RETURN_ERROR_UNLESS (result); result = bge_wdgt_spec_set_value ( spec, state_name, allocation_key, allocation_values[i], &local_error); RETURN_ERROR_UNLESS (result); } } else if (g_strcmp0 (token, STR_MEASURE) == 0) { guint n_measurement_values = 0; g_auto (GStrv) measurement_values = NULL; p = parse_args (p, spec, state_name, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT }, 4, &measurement_values, NULL, &n_measurement_values, ARGS_PARSE_RIGHT_ASSIGN, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_measurement_values != 4) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "measurement needs 4 values, a " "minimum width, " "natural width, " "minimum height, " "and " "natural height, " "got %u", n_measurement_values); return NULL; } for (guint i = 0; i < n_measurement_values; i++) { g_autofree char *measurement_key = NULL; measurement_key = make_widget_measurement_name ((*n_anon_vals)++); switch (i) { case 0: result = bge_wdgt_spec_add_measure_value ( spec, measurement_key, BGE_WDGT_MEASURE_MINIMUM_WIDTH, &local_error); break; case 1: result = bge_wdgt_spec_add_measure_value ( spec, measurement_key, BGE_WDGT_MEASURE_NATURAL_WIDTH, &local_error); break; case 2: result = bge_wdgt_spec_add_measure_value ( spec, measurement_key, BGE_WDGT_MEASURE_MINIMUM_HEIGHT, &local_error); break; case 3: result = bge_wdgt_spec_add_measure_value ( spec, measurement_key, BGE_WDGT_MEASURE_NATURAL_HEIGHT, &local_error); break; default: g_assert_not_reached (); } RETURN_ERROR_UNLESS (result); result = bge_wdgt_spec_set_value ( spec, state_name, measurement_key, measurement_values[i], &local_error); RETURN_ERROR_UNLESS (result); } } else UNEXPECTED_TOKEN (token); } } else UNEXPECTED_TOKEN (token); } return p; } static const char * parse_snapshot_block (const char *p, BgeWdgtSpec *spec, const char *state, GHashTable *macro_replacements, guint *n_anon_vals, GHashTable *type_hints, guint *line, guint *column, GError **error) { g_autoptr (GError) local_error = NULL; gboolean result = FALSE; g_autofree char *token = NULL; for (;;) { g_autofree char *action = NULL; BgeWdgtSnapshotInstrKind kind = 0; g_autofree char *instr = NULL; guint n_args = 0; g_auto (GStrv) args = NULL; guint n_pops = 0; GET_TOKEN (&action, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (action, "}") == 0) break; else if (g_strcmp0 (action, "foreach") == 0) { g_autofree char *var = NULL; g_autofree char *element_type_string = NULL; g_autofree char *idx_var = NULL; g_autofree char *model = NULL; GType element_type = G_TYPE_INVALID; GET_TOKEN (&var, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ":"); GET_TOKEN (&element_type_string, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ","); GET_TOKEN (&idx_var, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "in"); GET_TOKEN (&model, TOKEN_PARSE_DEFAULT); element_type = g_type_from_name (element_type_string); result = bge_wdgt_spec_push_foreach ( spec, model, var, idx_var, element_type, &local_error); RETURN_ERROR_UNLESS (result); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "{"); p = parse_snapshot_block (p, spec, state, macro_replacements, n_anon_vals, type_hints, line, column, &local_error); RETURN_ERROR_UNLESS (p != NULL); bge_wdgt_spec_pop_foreach (spec); continue; } else if (g_strcmp0 (action, "save") == 0) kind = BGE_WDGT_SNAPSHOT_INSTR_SAVE; else if (g_strcmp0 (action, "with") == 0) kind = BGE_WDGT_SNAPSHOT_INSTR_PUSH; else if (g_strcmp0 (action, "add") == 0) kind = BGE_WDGT_SNAPSHOT_INSTR_APPEND; else if (g_strcmp0 (action, "move") == 0) kind = BGE_WDGT_SNAPSHOT_INSTR_TRANSFORM; else if (g_strcmp0 (action, "do-child") == 0) kind = BGE_WDGT_SNAPSHOT_INSTR_SNAPSHOT_CHILD; else UNEXPECTED_TOKEN (action); if (kind == BGE_WDGT_SNAPSHOT_INSTR_SAVE) { result = bge_wdgt_spec_append_snapshot_instr ( spec, state, BGE_WDGT_SNAPSHOT_INSTR_SAVE, "save", NULL, 0, NULL, &local_error); RETURN_ERROR_UNLESS (result); } else if (kind == BGE_WDGT_SNAPSHOT_INSTR_SNAPSHOT_CHILD) { p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, NULL, 0, &args, NULL, &n_args, ARGS_PARSE_RIGHT_ASSIGN, &local_error); RETURN_ERROR_UNLESS (p != NULL); result = bge_wdgt_spec_append_snapshot_instr ( spec, state, BGE_WDGT_SNAPSHOT_INSTR_SNAPSHOT_CHILD, "do-child", (const char *const *) args, n_args, NULL, &local_error); RETURN_ERROR_UNLESS (result); } else { GET_TOKEN (&instr, TOKEN_PARSE_DEFAULT); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, NULL, 0, &args, NULL, &n_args, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); result = bge_wdgt_spec_append_snapshot_instr ( spec, state, kind, instr, (const char *const *) args, n_args, &n_pops, &local_error); RETURN_ERROR_UNLESS (result); } if (kind == BGE_WDGT_SNAPSHOT_INSTR_APPEND || kind == BGE_WDGT_SNAPSHOT_INSTR_TRANSFORM) GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ";"); else if (kind == BGE_WDGT_SNAPSHOT_INSTR_PUSH) { for (guint i = 0; i < n_pops; i++) { if (i > 0) GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "then"); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "{"); p = parse_snapshot_block (p, spec, state, macro_replacements, n_anon_vals, type_hints, line, column, &local_error); RETURN_ERROR_UNLESS (p != NULL); result = bge_wdgt_spec_append_snapshot_instr ( spec, state, BGE_WDGT_SNAPSHOT_INSTR_POP, "pop", NULL, 0, NULL, &local_error); RETURN_ERROR_UNLESS (result); } } else if (kind == BGE_WDGT_SNAPSHOT_INSTR_SAVE) { GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "{"); p = parse_snapshot_block (p, spec, state, macro_replacements, n_anon_vals, type_hints, line, column, &local_error); RETURN_ERROR_UNLESS (p != NULL); result = bge_wdgt_spec_append_snapshot_instr ( spec, state, BGE_WDGT_SNAPSHOT_INSTR_RESTORE, "restore", NULL, 0, NULL, &local_error); RETURN_ERROR_UNLESS (result); } } return p; } static gdouble floor_closure (gpointer this, gdouble x, gpointer data) { return floor (x); } static gdouble ceil_closure (gpointer this, gdouble x, gpointer data) { return ceil (x); } static gdouble sin_closure (gpointer this, gdouble x, gpointer data) { return sin (x); } static gdouble cos_closure (gpointer this, gdouble x, gpointer data) { return cos (x); } static const char * parse_eval (const char *p, BgeWdgtSpec *spec, const char *state, GHashTable *macro_replacements, guint *n_anon_vals, GHashTable *type_hints, guint *line, guint *column, char **value_out, GError **error) { g_autoptr (GError) local_error = NULL; gboolean result = FALSE; g_autofree char *token = NULL; g_autoptr (GPtrArray) values = NULL; g_autoptr (GArray) ops = NULL; g_autoptr (GArray) value_types = NULL; g_autofree char *key = NULL; g_autoptr (EvalClosureData) data = NULL; values = g_ptr_array_new_with_free_func (g_free); ops = g_array_new (FALSE, FALSE, sizeof (EvalOperator)); value_types = g_array_new (FALSE, FALSE, sizeof (GType)); #define GET_TOKEN_EVAL(_token_out, _flags) \ GET_TOKEN_FULL (_token_out, _flags, EVAL_SINGLE_CHAR_TOKENS, NULL) #define GET_TOKEN_EVAL_EXPECT(_token_out, _flags, _expect) \ G_STMT_START \ { \ GET_TOKEN_EVAL ((_token_out), (_flags)); \ EXPECT_TOKEN (*(_token_out), (_expect)); \ } \ G_STMT_END for (gboolean apply_negative = FALSE;;) { g_autofree char *value = NULL; Operator op = -1; gboolean expected_value = FALSE; GET_TOKEN_EVAL (&token, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (token, ")") == 0) break; else if (g_strcmp0 (token, "(") == 0) { p = parse_eval (p, spec, state, macro_replacements, n_anon_vals, type_hints, line, column, &value, &local_error); RETURN_ERROR_UNLESS (p != NULL); } else if (g_strcmp0 (token, "#") == 0) { g_auto (GStrv) escape_args = NULL; guint n_escape_args = 0; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ G_TYPE_DOUBLE }, 1, &escape_args, NULL, &n_escape_args, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_escape_args != 1) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "evaluation escape " "needs a single argument"); return NULL; } value = g_strdup (escape_args[0]); } else if (g_strcmp0 (token, "ceil") == 0 || g_strcmp0 (token, "floor") == 0 || g_strcmp0 (token, "sin") == 0 || g_strcmp0 (token, "cos") == 0) { GCallback cb = NULL; g_autofree char *arg = NULL; g_autofree char *math_func_key = NULL; if (g_strcmp0 (token, "ceil") == 0) cb = G_CALLBACK (ceil_closure); else if (g_strcmp0 (token, "floor") == 0) cb = G_CALLBACK (floor_closure); else if (g_strcmp0 (token, "sin") == 0) cb = G_CALLBACK (sin_closure); else if (g_strcmp0 (token, "cos") == 0) cb = G_CALLBACK (cos_closure); GET_TOKEN_EVAL_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_eval (p, spec, state, macro_replacements, n_anon_vals, type_hints, line, column, &arg, &local_error); RETURN_ERROR_UNLESS (p != NULL); math_func_key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_cclosure_source_value ( spec, math_func_key, G_TYPE_DOUBLE, bge_marshal_DOUBLE__DOUBLE, cb, (const char *const[]){ arg }, (GType[]){ G_TYPE_DOUBLE }, 1, NULL, NULL, &local_error); RETURN_ERROR_UNLESS (result); value = g_steal_pointer (&math_func_key); } else if (g_strcmp0 (token, "+") == 0) op = OPERATOR_ADD; else if (g_strcmp0 (token, "-") == 0) op = OPERATOR_SUBTRACT; else if (g_strcmp0 (token, "*") == 0) op = OPERATOR_MULTIPLY; else if (g_strcmp0 (token, "/") == 0) op = OPERATOR_DIVIDE; else if (g_strcmp0 (token, "%") == 0) op = OPERATOR_MODULUS; else if (g_strcmp0 (token, "^") == 0) op = OPERATOR_POWER; else { value = parse_token_fundamental ( token, spec, n_anon_vals, line, column, &local_error); RETURN_ERROR_UNLESS (value != NULL); } expected_value = values->len == ops->len; if (value != NULL) { GType type_double = G_TYPE_DOUBLE; if (!expected_value) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Expected operator, got \"%s\"", token); return NULL; } if (apply_negative) { GValue gvalue = G_VALUE_INIT; g_autofree char *negative_key = NULL; EvalOperator append = { 0 }; g_value_set_double (g_value_init (&gvalue, G_TYPE_DOUBLE), -1.0); negative_key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_constant_source_value ( spec, negative_key, &gvalue, &local_error); g_value_unset (&gvalue); RETURN_ERROR_UNLESS (result); g_ptr_array_add (values, g_steal_pointer (&negative_key)); g_array_append_val (value_types, type_double); append.op = OPERATOR_MULTIPLY; append.pos = ops->len; g_array_append_val (ops, append); apply_negative = FALSE; } g_ptr_array_add (values, g_steal_pointer (&value)); g_array_append_val (value_types, type_double); } else if (op >= 0) { EvalOperator append = { 0 }; if (expected_value) { if (op == OPERATOR_SUBTRACT) apply_negative = !apply_negative; else if (op != OPERATOR_ADD) /* Allow adding `+` in front of numbers for alignment with negatives etc */ { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Expected value, got \"%s\"", token); return NULL; } } else { append.op = op; append.pos = ops->len; g_array_append_val (ops, append); } } } if (values->len == 0) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Empty evaluation block"); return NULL; } if (ops->len != values->len - 1) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Invalid syntax in evaluation block"); return NULL; } if (values->len == 1) { *value_out = g_ptr_array_steal_index (values, 0); return p; } g_array_sort (ops, (GCompareFunc) cmp_operator); data = eval_closure_data_new (); data->ops = g_array_ref (ops); data->workbuf0 = g_malloc0_n (values->len, sizeof (gdouble)); data->workbuf1 = g_malloc0_n (values->len, sizeof (gdouble)); key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_cclosure_source_value ( spec, key, G_TYPE_DOUBLE, _marshal_DOUBLE__ARGS_DIRECT, G_CALLBACK (eval_closure), (const char *const *) values->pdata, (const GType *) (void *) value_types->data, values->len, eval_closure_data_ref (data), eval_closure_data_unref, &local_error); RETURN_ERROR_UNLESS (result); *value_out = g_steal_pointer (&key); return p; } static gboolean not_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { for (guint i = 0; i < n_param_values; i++) { if (!g_value_get_boolean (¶m_values[i])) return TRUE; } return FALSE; } static gboolean and_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { for (guint i = 0; i < n_param_values; i++) { if (!g_value_get_boolean (¶m_values[i])) return FALSE; } return TRUE; } static gboolean or_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { for (guint i = 0; i < n_param_values; i++) { if (g_value_get_boolean (¶m_values[i])) return TRUE; } return FALSE; } static gboolean lt_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { gdouble cmp_with = 0.0; cmp_with = g_value_get_double (param_values); for (guint i = 1; i < n_param_values; i++) { if (!(cmp_with < g_value_get_double (¶m_values[i]))) return FALSE; } return TRUE; } static gboolean gt_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { gdouble cmp_with = 0.0; cmp_with = g_value_get_double (param_values); for (guint i = 1; i < n_param_values; i++) { if (!(cmp_with > g_value_get_double (¶m_values[i]))) return FALSE; } return TRUE; } static gboolean lte_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { gdouble cmp_with = 0.0; cmp_with = g_value_get_double (param_values); for (guint i = 1; i < n_param_values; i++) { if (!(cmp_with <= g_value_get_double (¶m_values[i]))) return FALSE; } return TRUE; } static gboolean gte_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { gdouble cmp_with = 0.0; cmp_with = g_value_get_double (param_values); for (guint i = 1; i < n_param_values; i++) { if (!(cmp_with >= g_value_get_double (¶m_values[i]))) return FALSE; } return TRUE; } static gboolean eq_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { gdouble cmp_with = 0.0; cmp_with = g_value_get_double (param_values); for (guint i = 1; i < n_param_values; i++) { if (!(cmp_with == g_value_get_double (¶m_values[i]))) return FALSE; } return TRUE; } static gboolean neq_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { gdouble cmp_with = 0.0; cmp_with = g_value_get_double (param_values); for (guint i = 1; i < n_param_values; i++) { if (!(cmp_with != g_value_get_double (¶m_values[i]))) return FALSE; } return TRUE; } static gboolean aeq_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { gdouble cmp_with = 0.0; cmp_with = g_value_get_double (param_values); for (guint i = 1; i < n_param_values; i++) { if (!(G_APPROX_VALUE (cmp_with, g_value_get_double (¶m_values[i]), 0.00001))) return FALSE; } return TRUE; } static gboolean aneq_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { gdouble cmp_with = 0.0; cmp_with = g_value_get_double (param_values); for (guint i = 1; i < n_param_values; i++) { if (!(!G_APPROX_VALUE (cmp_with, g_value_get_double (¶m_values[i]), 0.00001))) return FALSE; } return TRUE; } static void ifelse_closure (gpointer this, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer dest_type_ptr) { if (g_value_get_boolean (param_values)) g_value_copy (¶m_values[1], return_value); else g_value_copy (¶m_values[2], return_value); } static void measure_path_closure (gpointer this, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer dest_type_ptr) { GskPathMeasure *measure = NULL; measure = gsk_path_measure_new ( g_value_get_boxed (param_values)); g_value_take_boxed (return_value, measure); } static void path_length_closure (gpointer this, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer dest_type_ptr) { gdouble length = 0.0; length = gsk_path_measure_get_length ( g_value_get_boxed (param_values)); g_value_set_double (return_value, length); } static void path_point_closure (gpointer this, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer dest_type_ptr) { gboolean result = FALSE; GskPathPoint point = { 0 }; result = gsk_path_measure_get_point ( g_value_get_boxed (¶m_values[0]), g_value_get_double (¶m_values[1]), &point); if (!result) return; g_value_set_boxed (return_value, &point); } static const char * parse_args (const char *p, BgeWdgtSpec *spec, const char *state, const char *enclosing_object, GHashTable *macro_replacements, guint *n_anon_vals, GHashTable *type_hints, guint *line, guint *column, const char *const *destinations, GType destinations_types[], guint n_destinations, char ***values_out, GType **types_out, guint *n_out, ArgsParseKind parse_kind, GError **error) { g_autoptr (GError) local_error = NULL; gboolean result = FALSE; g_autofree char *token = NULL; guint n_args = 0; g_autoptr (GStrvBuilder) builder = NULL; g_autoptr (GArray) types_array = NULL; builder = g_strv_builder_new (); types_array = g_array_new (FALSE, TRUE, sizeof (GType)); for (gboolean need_comma = FALSE, get_token = TRUE, was_quoted = FALSE; ;) { if (get_token) GET_TOKEN_FULL (&token, TOKEN_PARSE_DEFAULT, SINGLE_CHAR_TOKENS, &was_quoted); get_token = TRUE; if (was_quoted) { g_autofree char *tmp_token = NULL; g_autofree char *key = NULL; GValue value = { 0 }; g_value_set_string (g_value_init (&value, G_TYPE_STRING), token); key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_constant_source_value ( spec, key, &value, &local_error); g_value_unset (&value); RETURN_ERROR_UNLESS (result); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else if ((parse_kind == ARGS_PARSE_LEFT_ASSIGN && g_strcmp0 (token, "=") == 0) || (parse_kind == ARGS_PARSE_RIGHT_ASSIGN && g_strcmp0 (token, ";") == 0) || (parse_kind == ARGS_PARSE_PARENS && g_strcmp0 (token, ")") == 0)) break; else if (need_comma) { if (g_strcmp0 (token, ",") == 0) { need_comma = FALSE; continue; } else { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Arguments must be comma-separated"); return NULL; } } else if (g_strcmp0 (token, "_") == 0 || g_strcmp0 (token, "C_") == 0) /* gettext translations */ { gboolean have_context = FALSE; g_autofree char *context_text = NULL; g_autofree char *source_text = NULL; GValue value = G_VALUE_INIT; g_autofree char *key = NULL; have_context = g_strcmp0 (token, "C_") == 0; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); if (have_context) { GET_TOKEN (&context_text, TOKEN_PARSE_QUOTED); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ","); } GET_TOKEN (&source_text, TOKEN_PARSE_QUOTED); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ")"); g_value_init (&value, G_TYPE_STRING); if (have_context) { g_autofree char *query = NULL; query = g_strdup_printf ("%s\004%s", context_text, source_text); g_value_set_string (&value, g_dpgettext (NULL, query, strlen (context_text) + 1)); } else g_value_set_string (&value, gettext (source_text)); key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_constant_source_value ( spec, key, &value, &local_error); g_value_unset (&value); RETURN_ERROR_UNLESS (result); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else if (g_strcmp0 (token, "#eval") == 0) { g_autofree char *key = NULL; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_eval (p, spec, state, macro_replacements, n_anon_vals, type_hints, line, column, &key, &local_error); RETURN_ERROR_UNLESS (p != NULL); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else if (g_strcmp0 (token, "#not") == 0 || g_strcmp0 (token, "#!") == 0 || g_strcmp0 (token, "#and") == 0 || g_strcmp0 (token, "#or") == 0 || g_strcmp0 (token, "#<") == 0 || g_strcmp0 (token, "#>") == 0 || g_strcmp0 (token, "#eq") == 0 || g_strcmp0 (token, "#eq") == 0 || g_strcmp0 (token, "#neq") == 0 || g_strcmp0 (token, "#~eq") == 0 || g_strcmp0 (token, "#~neq") == 0) { g_autofree char *key = NULL; GCallback cb = NULL; GType all_type = G_TYPE_INVALID; guint require_n_cmp_values = 0; guint n_cmp_values = 0; g_auto (GStrv) cmp_values = NULL; g_autofree GType *all_types = NULL; if (g_strcmp0 (token, "#not") == 0 || g_strcmp0 (token, "#!") == 0) { cb = G_CALLBACK (not_closure); all_type = G_TYPE_BOOLEAN; require_n_cmp_values = 1; } else if (g_strcmp0 (token, "#and") == 0) { cb = G_CALLBACK (and_closure); all_type = G_TYPE_BOOLEAN; require_n_cmp_values = 2; } else if (g_strcmp0 (token, "#or") == 0) { cb = G_CALLBACK (or_closure); all_type = G_TYPE_BOOLEAN; require_n_cmp_values = 2; } else if (g_strcmp0 (token, "#<") == 0) { cb = G_CALLBACK (lt_closure); all_type = G_TYPE_DOUBLE; require_n_cmp_values = 2; } else if (g_strcmp0 (token, "#>") == 0) { cb = G_CALLBACK (gt_closure); all_type = G_TYPE_DOUBLE; require_n_cmp_values = 2; } else if (g_strcmp0 (token, "#eq") == 0) { cb = G_CALLBACK (gte_closure); all_type = G_TYPE_DOUBLE; require_n_cmp_values = 2; } else if (g_strcmp0 (token, "#eq") == 0) { cb = G_CALLBACK (eq_closure); all_type = G_TYPE_DOUBLE; require_n_cmp_values = 2; } else if (g_strcmp0 (token, "#neq") == 0) { cb = G_CALLBACK (neq_closure); all_type = G_TYPE_DOUBLE; require_n_cmp_values = 2; } else if (g_strcmp0 (token, "#~eq") == 0) { cb = G_CALLBACK (aeq_closure); all_type = G_TYPE_DOUBLE; require_n_cmp_values = 2; } else if (g_strcmp0 (token, "#~neq") == 0) { cb = G_CALLBACK (aneq_closure); all_type = G_TYPE_DOUBLE; require_n_cmp_values = 2; } else g_assert_not_reached (); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, NULL, 0, &cmp_values, NULL, &n_cmp_values, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_cmp_values < require_n_cmp_values) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "%s() needs at least %u argument(s), " "got %u", token, require_n_cmp_values, n_cmp_values); return NULL; } all_types = g_new (GType, n_cmp_values); for (guint i = 0; i < n_cmp_values; i++) { all_types[i] = all_type; } key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_cclosure_source_value ( spec, key, G_TYPE_BOOLEAN, _marshal_BOOL__ARGS_DIRECT, cb, (const char *const *) cmp_values, all_types, n_cmp_values, NULL, NULL, &local_error); RETURN_ERROR_UNLESS (result); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else if (g_strcmp0 (token, "#ifelse") == 0) { g_autofree char *key = NULL; GType type_hint = G_TYPE_INVALID; guint n_expr_values = 0; g_auto (GStrv) expr_values = NULL; g_autofree GType *expr_types = NULL; if (n_args < n_destinations) { if (destinations != NULL) type_hint = GPOINTER_TO_SIZE (g_hash_table_lookup ( type_hints, destinations[n_args])); if (type_hint == G_TYPE_INVALID && destinations_types != NULL) type_hint = destinations_types[n_args]; } GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ G_TYPE_BOOLEAN }, 1, &expr_values, &expr_types, &n_expr_values, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_expr_values != 3) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#ifelse() needs exactly 3 argument(s), " "got %u", n_expr_values); return NULL; } if (type_hint == G_TYPE_INVALID) /* Use the return type of the TRUE value and coerce the FALSE value to this if necessary */ type_hint = expr_types[1]; key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_cclosure_source_value ( spec, key, type_hint, _marshal_DIRECT__ARGS_DIRECT, G_CALLBACK (ifelse_closure), (const char *const *) expr_values, (GType[]){ G_TYPE_BOOLEAN, type_hint, type_hint }, n_expr_values, NULL, NULL, &local_error); RETURN_ERROR_UNLESS (result); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else if (g_strcmp0 (token, "#measure-path") == 0) { g_autofree char *key = NULL; guint n_expr_values = 0; g_auto (GStrv) expr_values = NULL; g_autofree GType *expr_types = NULL; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ GSK_TYPE_PATH }, 1, &expr_values, &expr_types, &n_expr_values, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_expr_values != 1) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#measure-path() needs exactly 1 argument of type %s," "got %u", g_type_name (GSK_TYPE_PATH), n_expr_values); return NULL; } key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_cclosure_source_value ( spec, key, GSK_TYPE_PATH_MEASURE, _marshal_DIRECT__ARGS_DIRECT, G_CALLBACK (measure_path_closure), (const char *const *) expr_values, (GType[]){ GSK_TYPE_PATH }, n_expr_values, NULL, NULL, &local_error); RETURN_ERROR_UNLESS (result); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else if (g_strcmp0 (token, "#path-length") == 0) { g_autofree char *key = NULL; guint n_expr_values = 0; g_auto (GStrv) expr_values = NULL; g_autofree GType *expr_types = NULL; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ GSK_TYPE_PATH_MEASURE }, 1, &expr_values, &expr_types, &n_expr_values, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_expr_values != 1) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#path-length() needs exactly 1 argument of type %s," "got %u", g_type_name (GSK_TYPE_PATH_MEASURE), n_expr_values); return NULL; } key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_cclosure_source_value ( spec, key, G_TYPE_DOUBLE, _marshal_DIRECT__ARGS_DIRECT, G_CALLBACK (path_length_closure), (const char *const *) expr_values, (GType[]){ GSK_TYPE_PATH_MEASURE }, n_expr_values, NULL, NULL, &local_error); RETURN_ERROR_UNLESS (result); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else if (g_strcmp0 (token, "#path-point") == 0) { g_autofree char *key = NULL; guint n_expr_values = 0; g_auto (GStrv) expr_values = NULL; g_autofree GType *expr_types = NULL; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ GSK_TYPE_PATH_MEASURE, G_TYPE_DOUBLE }, 2, &expr_values, &expr_types, &n_expr_values, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_expr_values != 2) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#path-point() needs exactly 2 arguments " "of types %s and %s," "got %u", g_type_name (GSK_TYPE_PATH_MEASURE), g_type_name (G_TYPE_DOUBLE), n_expr_values); return NULL; } key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_cclosure_source_value ( spec, key, GSK_TYPE_PATH_POINT, _marshal_DIRECT__ARGS_DIRECT, G_CALLBACK (path_point_closure), (const char *const *) expr_values, (GType[]){ GSK_TYPE_PATH_MEASURE, G_TYPE_DOUBLE }, n_expr_values, NULL, NULL, &local_error); RETURN_ERROR_UNLESS (result); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else if (g_strcmp0 (token, "#transition") == 0) { g_autofree char *key = NULL; guint n_spec_values = 0; g_auto (GStrv) spec_values = NULL; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, NULL, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE }, 4, &spec_values, NULL, &n_spec_values, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_spec_values != 4) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#transition() needs 4 arguments " "(variable, damping-ratio, mass, stiffness), " "got %u", n_spec_values); return NULL; } key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_track_transition_source_value ( spec, key, spec_values[0], spec_values[1], spec_values[2], spec_values[3], &local_error); RETURN_ERROR_UNLESS (result); g_strv_builder_take (builder, g_steal_pointer (&key)); n_args++; need_comma = TRUE; } else { g_autofree char *key = NULL; GType type = G_TYPE_INVALID; if (g_hash_table_contains (type_hints, token) || /* A macro placed this here */ g_utf8_strchr (token, -1, '@') != NULL) key = g_steal_pointer (&token); else { GType type_hint = G_TYPE_INVALID; gboolean expect_closing_paren = FALSE; gboolean is_child = FALSE; gboolean constant = FALSE; GValue value = G_VALUE_INIT; if (n_args < n_destinations) { if (destinations != NULL) type_hint = GPOINTER_TO_SIZE (g_hash_table_lookup ( type_hints, destinations[n_args])); if (type_hint == G_TYPE_INVALID && destinations_types != NULL) type_hint = destinations_types[n_args]; } if (g_str_has_prefix (token, "#")) { const char *type_name = token + 1; if (g_str_has_prefix (type_name, "child/")) { is_child = TRUE; type_name += strlen ("child/"); } if (*type_name == '\0') { if (type_hint == G_TYPE_INVALID) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Unable to guess type for value"); return NULL; } type = type_hint; } else { type = g_type_from_name (type_name); if (type == G_TYPE_INVALID) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Unknown type name \"%s\"", type_name); return NULL; } } GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); expect_closing_paren = TRUE; } else type = type_hint; if (is_child && !g_type_is_a (type, GTK_TYPE_WIDGET)) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Children must be a widget type"); return NULL; } if (type == G_TYPE_INVALID) { if (expect_closing_paren) GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); key = parse_token_fundamental (token, spec, n_anon_vals, line, column, &local_error); RETURN_ERROR_UNLESS (key != NULL); } else if (type == G_TYPE_STRING) { if (expect_closing_paren) GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); g_value_set_string (g_value_init (&value, G_TYPE_STRING), token); constant = TRUE; if (expect_closing_paren) GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ")"); } else if (type == G_TYPE_BOOLEAN) { if (expect_closing_paren) GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (token, "true") == 0) g_value_set_boolean (g_value_init (&value, G_TYPE_BOOLEAN), TRUE); else if (g_strcmp0 (token, "false") == 0) g_value_set_boolean (g_value_init (&value, G_TYPE_BOOLEAN), FALSE); else { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "a boolean value must be 'true' " "or 'false', got \"%s\"", token); return NULL; } constant = TRUE; if (expect_closing_paren) GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ")"); } else if (type == G_TYPE_INT || type == G_TYPE_INT64 || type == G_TYPE_UINT || type == G_TYPE_UINT64 || type == G_TYPE_FLOAT || type == G_TYPE_DOUBLE) { const GVariantType *variant_type = NULL; g_autoptr (GVariant) variant = NULL; if (type == G_TYPE_INT) variant_type = G_VARIANT_TYPE_INT32; else if (type == G_TYPE_INT64) variant_type = G_VARIANT_TYPE_INT64; else if (type == G_TYPE_UINT) variant_type = G_VARIANT_TYPE_UINT32; else if (type == G_TYPE_UINT64) variant_type = G_VARIANT_TYPE_UINT64; else if (type == G_TYPE_FLOAT || type == G_TYPE_DOUBLE) variant_type = G_VARIANT_TYPE_DOUBLE; if (expect_closing_paren) GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); variant = g_variant_parse (variant_type, token, NULL, NULL, &local_error); RETURN_ERROR_UNLESS (variant != NULL); if (type == G_TYPE_INT) g_value_set_int (g_value_init (&value, G_TYPE_INT), g_variant_get_int32 (variant)); else if (type == G_TYPE_INT64) g_value_set_int64 (g_value_init (&value, G_TYPE_INT64), g_variant_get_int64 (variant)); else if (type == G_TYPE_UINT) g_value_set_uint (g_value_init (&value, G_TYPE_UINT), g_variant_get_uint32 (variant)); else if (type == G_TYPE_UINT64) g_value_set_uint64 (g_value_init (&value, G_TYPE_UINT64), g_variant_get_uint64 (variant)); else if (type == G_TYPE_FLOAT) g_value_set_float (g_value_init (&value, G_TYPE_FLOAT), g_variant_get_double (variant)); else if (type == G_TYPE_DOUBLE) g_value_set_double (g_value_init (&value, G_TYPE_DOUBLE), g_variant_get_double (variant)); constant = TRUE; if (expect_closing_paren) GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ")"); } else if (g_type_is_a (type, G_TYPE_ENUM)) { g_autoptr (GEnumClass) enum_class = NULL; GEnumValue *enum_value = NULL; if (expect_closing_paren) GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); enum_class = g_type_class_ref (type); enum_value = g_enum_get_value_by_nick (enum_class, token); if (enum_value == NULL) enum_value = g_enum_get_value_by_name (enum_class, token); if (enum_value == NULL) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "\"%s\" not found in enum type %s", token, g_type_name (type)); return NULL; } g_value_set_enum (g_value_init (&value, type), enum_value->value); constant = TRUE; if (expect_closing_paren) GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ")"); } else if (type == GDK_TYPE_RGBA) { GdkRGBA rgba = { 0 }; if (expect_closing_paren) GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); result = gdk_rgba_parse (&rgba, token); if (!result) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#color() specifier failed to " "parse color from string"); return NULL; } g_value_set_boxed (g_value_init (&value, GDK_TYPE_RGBA), &rgba); constant = TRUE; if (expect_closing_paren) GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ")"); } else if (type == GRAPHENE_TYPE_POINT || type == GRAPHENE_TYPE_SIZE || type == GRAPHENE_TYPE_RECT) { g_auto (GStrv) component_args = NULL; guint n_component_args = 0; GType component_type = 0; if (!expect_closing_paren) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "type %s must be wrapped in #(...)", g_type_name (type)); return NULL; } p = parse_args (p, spec, state, enclosing_object, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE }, 4, &component_args, NULL, &n_component_args, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (type == GRAPHENE_TYPE_POINT) { switch (n_component_args) { case 2: component_type = GRAPHENE_TYPE_POINT; break; case 3: component_type = GRAPHENE_TYPE_POINT3D; break; default: g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#point() specifier can have 2 or 3 arguments, got %u", n_component_args); return NULL; } } else if (type == GRAPHENE_TYPE_SIZE) { switch (n_component_args) { case 2: component_type = GRAPHENE_TYPE_SIZE; break; default: g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#size() specifier can have 2 arguments, got %u", n_component_args); return NULL; } } else if (type == GRAPHENE_TYPE_RECT) { switch (n_component_args) { case 4: component_type = GRAPHENE_TYPE_RECT; break; default: g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "#rect() specifier can have 4 arguments, got %u", n_component_args); return NULL; } } key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_component_source_value ( spec, key, component_type, (const char *const *) component_args, n_component_args, &local_error); RETURN_ERROR_UNLESS (result); } else if (g_type_is_a (type, G_TYPE_OBJECT)) { if (!expect_closing_paren) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "type %s must be wrapped in #(...)", g_type_name (type)); return NULL; } key = make_anon_name ((*n_anon_vals)++); if (is_child) { g_autofree char *builder_type = NULL; g_autoptr (GPtrArray) css_classes = NULL; GET_TOKEN (&builder_type, TOKEN_PARSE_QUOTED); if (*builder_type == '\0') g_clear_pointer (&builder_type, g_free); css_classes = g_ptr_array_new_with_free_func (g_free); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); for (;;) { GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (token, ")") == 0) break; g_ptr_array_add (css_classes, g_steal_pointer (&token)); } result = bge_wdgt_spec_add_child_source_value ( spec, key, type, enclosing_object, builder_type, (const char *const *) css_classes->pdata, css_classes->len, &local_error); RETURN_ERROR_UNLESS (result); } else { result = bge_wdgt_spec_add_instance_source_value ( spec, key, type, &local_error); RETURN_ERROR_UNLESS (result); } for (;;) { g_autofree char *property_name = NULL; g_autofree char *set_key = NULL; GType prop_type = G_TYPE_INVALID; g_auto (GStrv) value_args = NULL; guint n_value_args = 0; GET_TOKEN (&property_name, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (property_name, ")") == 0) break; else if (g_strcmp0 (property_name, "%set") == 0) { GET_TOKEN (&set_key, TOKEN_PARSE_DEFAULT); prop_type = GPOINTER_TO_SIZE (g_hash_table_lookup (type_hints, set_key)); } else if (g_strcmp0 (property_name, "_") != 0) { set_key = make_object_property_name (key, property_name, (*n_anon_vals)++); result = bge_wdgt_spec_add_property_value ( spec, set_key, key, property_name, &prop_type, &local_error); RETURN_ERROR_UNLESS (result); } GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "="); p = parse_args (p, spec, state, key, macro_replacements, n_anon_vals, type_hints, line, column, NULL, (GType[]){ prop_type }, 1, &value_args, NULL, &n_value_args, ARGS_PARSE_RIGHT_ASSIGN, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_value_args != 1) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "property/child assignment " "needs a single argument, got %u", n_value_args); return NULL; } if (set_key != NULL) { result = bge_wdgt_spec_set_value (spec, state, set_key, value_args[0], &local_error); RETURN_ERROR_UNLESS (result); } } } else if (type == GSK_TYPE_TRANSFORM) { g_autofree char *last_key = NULL; if (!expect_closing_paren) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "type %s must be wrapped in #(...)", g_type_name (type)); return NULL; } last_key = make_anon_name ((*n_anon_vals)++); g_value_take_boxed (g_value_init (&value, GSK_TYPE_TRANSFORM), gsk_transform_new ()); result = bge_wdgt_spec_add_constant_source_value ( spec, last_key, &value, error); g_value_unset (&value); if (!result) return NULL; for (;;) { g_autofree char *instr = NULL; g_auto (GStrv) value_args = NULL; guint n_value_args = 0; g_autofree char *tmp_key = NULL; GET_TOKEN (&instr, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (instr, ")") == 0) break; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, enclosing_object, macro_replacements, n_anon_vals, type_hints, line, column, NULL, NULL, 0, &value_args, NULL, &n_value_args, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ";"); tmp_key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_transform_source_value ( spec, tmp_key, last_key, instr, (const char *const *) value_args, n_value_args, &local_error); RETURN_ERROR_UNLESS (result); g_clear_pointer (&last_key, g_free); last_key = g_steal_pointer (&tmp_key); } key = g_steal_pointer (&last_key); } else if (type == GSK_TYPE_PATH) { g_autoptr (GPtrArray) instrs = NULL; g_autoptr (GPtrArray) argss = NULL; g_autoptr (GArray) n_argss = NULL; instrs = g_ptr_array_new_with_free_func (g_free); argss = g_ptr_array_new_with_free_func ((GDestroyNotify) g_strfreev); n_argss = g_array_new (FALSE, FALSE, sizeof (guint)); if (!expect_closing_paren) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "type %s must be wrapped in #(...)", g_type_name (type)); return NULL; } for (;;) { g_autofree char *instr = NULL; g_auto (GStrv) call_args = NULL; guint n_call_args = 0; GET_TOKEN (&instr, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (instr, ")") == 0) break; GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, "("); p = parse_args (p, spec, state, enclosing_object, macro_replacements, n_anon_vals, type_hints, line, column, NULL, NULL, 0, &call_args, NULL, &n_call_args, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); GET_TOKEN_EXPECT (&token, TOKEN_PARSE_DEFAULT, ";"); g_ptr_array_add (instrs, g_steal_pointer (&instr)); g_ptr_array_add (argss, g_steal_pointer (&call_args)); g_array_append_val (n_argss, n_call_args); } if (instrs->len == 0) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "not enough path builder instructions"); return NULL; } key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_path_source_value ( spec, key, (const char *const *) instrs->pdata, (const char *const *const *) argss->pdata, (const guint *) (void *) n_argss->data, instrs->len, &local_error); RETURN_ERROR_UNLESS (result); } else if (type == GSK_TYPE_STROKE) { g_auto (GStrv) component_args = NULL; guint n_component_args = 0; GType types[] = { G_TYPE_DOUBLE, /* line width */ GSK_TYPE_LINE_CAP, GSK_TYPE_LINE_JOIN, G_TYPE_DOUBLE, /* miter limit */ }; if (!expect_closing_paren) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "type %s must be wrapped in #(...)", g_type_name (type)); return NULL; } p = parse_args (p, spec, state, enclosing_object, macro_replacements, n_anon_vals, type_hints, line, column, NULL, types, G_N_ELEMENTS (types), &component_args, NULL, &n_component_args, ARGS_PARSE_PARENS, &local_error); RETURN_ERROR_UNLESS (p != NULL); if (n_component_args != G_N_ELEMENTS (types)) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "%s type initializer can have %d arguments, got %u", g_type_name (GSK_TYPE_STROKE), (int) G_N_ELEMENTS (types), n_component_args); return NULL; } key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_component_source_value ( spec, key, GSK_TYPE_STROKE, (const char *const *) component_args, n_component_args, &local_error); RETURN_ERROR_UNLESS (result); } else { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Can't parse type %s", g_type_name (type)); return NULL; } if (constant) { key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_constant_source_value ( spec, key, &value, &local_error); g_value_unset (&value); RETURN_ERROR_UNLESS (result); } } for (;;) { GET_TOKEN (&token, TOKEN_PARSE_DEFAULT); if (g_strcmp0 (token, ":") == 0) { g_autofree char *property = NULL; g_autofree char *name = NULL; GET_TOKEN (&property, TOKEN_PARSE_DEFAULT); name = make_object_property_name (key, property, (*n_anon_vals)++); result = bge_wdgt_spec_add_property_value ( spec, name, key, property, &type, &local_error); RETURN_ERROR_UNLESS (result); g_clear_pointer (&key, g_free); key = g_steal_pointer (&name); } else break; } get_token = FALSE; g_strv_builder_add (builder, key); g_array_append_val (types_array, type); n_args++; need_comma = TRUE; } } if (n_out != NULL) *n_out = n_args; if (values_out != NULL) *values_out = g_strv_builder_end (builder); if (types_out != NULL) *types_out = g_array_steal (types_array, NULL); return p; } static char * parse_token_fundamental (const char *token, BgeWdgtSpec *spec, guint *n_anon_vals, guint *line, guint *column, GError **error) { g_autoptr (GError) local_error = NULL; gboolean result = FALSE; gunichar ch = 0; GValue value = { 0 }; g_autofree char *key = NULL; ch = g_utf8_get_char (token); if (ch == '-' || g_unichar_isdigit (ch)) { gboolean is_double = FALSE; g_autoptr (GVariant) variant = NULL; is_double = g_utf8_strchr (token, -1, '.') != NULL; if (is_double) variant = g_variant_parse (G_VARIANT_TYPE_DOUBLE, token, NULL, NULL, &local_error); else variant = g_variant_parse (G_VARIANT_TYPE_INT32, token, NULL, NULL, &local_error); if (variant == NULL) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Unable to parse number value '%s': %s", token, local_error->message); return NULL; } if (is_double) g_value_set_double (g_value_init (&value, G_TYPE_DOUBLE), g_variant_get_double (variant)); else g_value_set_int (g_value_init (&value, G_TYPE_INT), g_variant_get_int32 (variant)); } else if (g_strcmp0 (token, "true") == 0) g_value_set_boolean (g_value_init (&value, G_TYPE_BOOLEAN), TRUE); else if (g_strcmp0 (token, "false") == 0) g_value_set_boolean (g_value_init (&value, G_TYPE_BOOLEAN), FALSE); else return g_strdup (token); if (key == NULL) key = make_anon_name ((*n_anon_vals)++); result = bge_wdgt_spec_add_constant_source_value ( spec, key, &value, error); g_value_unset (&value); if (!result) return NULL; return g_steal_pointer (&key); } static char * consume_token (const char **pp, const char *single_chars, TokenParseFlags flags, gboolean *was_quoted, GHashTable *macro_replacements, guint *line, guint *column, GError **error) { g_autofree char *token = NULL; token = consume_token_inner (pp, single_chars, flags, was_quoted, line, column, error); if (token == NULL) return NULL; if (macro_replacements != NULL) { const char *replacement = NULL; replacement = g_hash_table_lookup (macro_replacements, token); if (replacement != NULL) return g_strdup (replacement); else { const char *replace_start = NULL; replace_start = g_utf8_strchr (token, -1, '@'); if (replace_start != NULL) { const char *last_end = token; g_autoptr (GString) string = NULL; string = g_string_new (NULL); for (;;) { g_autofree char *replace = NULL; const char *with = NULL; if (replace_start - last_end > 0) g_string_append_len (string, last_end, replace_start - last_end); replace_start++; last_end = g_utf8_strchr (replace_start, -1, '@'); if (last_end == NULL) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "error in macro expansion: " "unterminated replacement"); return NULL; } replace = g_strndup (replace_start, last_end - replace_start); with = g_hash_table_lookup (macro_replacements, replace); if (with == NULL) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "error in macro expansion: " "undefined string \"%s\"", replace); return NULL; } g_string_append (string, with); last_end++; replace_start = g_utf8_strchr (last_end, '@', -1); if (replace_start == NULL) break; } if (*last_end != '\0') g_string_append (string, last_end); return g_string_free_and_steal (g_steal_pointer (&string)); } } } return g_steal_pointer (&token); } static char * consume_token_inner (const char **pp, const char *single_chars, TokenParseFlags flags, gboolean *was_quoted, guint *line, guint *column, GError **error) { const char *p = *pp; gboolean hit_non_space = FALSE; if (was_quoted != NULL) *was_quoted = FALSE; #define UNEXPECTED_EOF \ G_STMT_START \ { \ g_set_error ( \ error, \ G_IO_ERROR, \ G_IO_ERROR_UNKNOWN, \ "Unexpected EOF"); \ return NULL; \ } \ G_STMT_END #define RETURN_TOKEN \ G_STMT_START \ { \ g_autofree char *_ret = NULL; \ \ _ret = g_strndup (*pp, p - *pp); \ *pp = p; \ return g_steal_pointer (&_ret); \ } \ G_STMT_END #define RETURN_TOKEN_ADJUST_NEXT_CHAR \ G_STMT_START \ { \ g_autofree char *_ret = NULL; \ \ _ret = g_strndup (*pp, p - *pp); \ *pp = g_utf8_next_char (p); \ return g_steal_pointer (&_ret); \ } \ G_STMT_END if (IS_EOF (p)) UNEXPECTED_EOF; for (; !IS_EOF (p); p = g_utf8_next_char (p)) { gunichar ch = 0; gboolean is_whitespace = FALSE; gboolean is_quotes = FALSE; ch = g_utf8_get_char (p); if (ch == '\n') { (*line)++; *column = 0; } else (*column)++; is_whitespace = ch == '\n' || g_unichar_isspace (ch); is_quotes = ch == '"'; if (is_whitespace) { if (!(flags & TOKEN_PARSE_QUOTED) && hit_non_space) RETURN_TOKEN; } else { if (is_quotes) { if (hit_non_space) { if (was_quoted != NULL) *was_quoted = TRUE; if (flags & TOKEN_PARSE_QUOTED) RETURN_TOKEN_ADJUST_NEXT_CHAR; else RETURN_TOKEN; } else { flags |= TOKEN_PARSE_QUOTED; *pp = g_utf8_next_char (p); if (IS_EOF (*pp)) UNEXPECTED_EOF; hit_non_space = TRUE; } } else if (flags & TOKEN_PARSE_QUOTED) { if (!hit_non_space) { g_set_error ( error, G_IO_ERROR, G_IO_ERROR_UNKNOWN, "Expected quote"); return NULL; } } else if (single_chars != NULL && g_utf8_strchr (single_chars, -1, ch) != NULL) { if (hit_non_space) RETURN_TOKEN; else { char buf[16] = { 0 }; g_unichar_to_utf8 (ch, buf); *pp = g_utf8_next_char (p); return g_strdup (buf); } } if (!hit_non_space) { *pp = p; hit_non_space = TRUE; } } } if (!(flags & TOKEN_PARSE_QUOTED) && hit_non_space) RETURN_TOKEN; UNEXPECTED_EOF; #undef RETURN_TOKEN_ADJUST_NEXT_CHAR #undef RETURN_TOKEN #undef UNEXPECTED_EOF } static gdouble eval_closure (gpointer this, guint n_param_values, const GValue *param_values, EvalClosureData *data) { GArray *ops = data->ops; gdouble *workbuf0 = data->workbuf0; gdouble *workbuf1 = data->workbuf1; gdouble result = 0.0; for (guint i = 0; i < n_param_values; i++) { workbuf0[i] = g_value_get_double (¶m_values[i]); workbuf1[i] = 1.0; } for (guint i = 0; i < ops->len; i++) { EvalOperator *op = NULL; guint left_idx = 0; guint right_idx = 0; gdouble left = 0.0; gdouble right = 0.0; op = &g_array_index (ops, EvalOperator, i); left_idx = op->pos; while (workbuf1[left_idx] < 0.0) { left_idx--; } right_idx = op->pos + 1; while (workbuf1[right_idx] < 0.0) { right_idx++; } left = workbuf0[left_idx]; right = workbuf0[right_idx]; switch (op->op) { case OPERATOR_ADD: result = left + right; break; case OPERATOR_SUBTRACT: result = left - right; break; case OPERATOR_MULTIPLY: result = left * right; break; case OPERATOR_DIVIDE: result = left / right; break; case OPERATOR_MODULUS: result = fmod (left, right); break; case OPERATOR_POWER: result = pow (left, right); break; default: g_assert_not_reached (); } workbuf0[left_idx] = result; workbuf1[left_idx] = 1.0; workbuf1[right_idx] = -1.0; } return result; } static char * make_object_property_name (const char *object, const char *property, guint n) { return g_strdup_printf ("prop@%u(%s).%s", n, object, property); } static char * make_widget_allocation_name (const char *widget, guint n) { return g_strdup_printf ("allocation@%u(%s)", n, widget); } static char * make_widget_measurement_name (guint n) { return g_strdup_printf ("measurement@%u", n); } static char * make_anon_name (guint n) { return g_strdup_printf ("anon@%u", n); } static gint cmp_operator (EvalOperator *a, EvalOperator *b) { int a_prec = 0; int b_prec = 0; a_prec = operator_precedence[a->op]; b_prec = operator_precedence[b->op]; return a_prec > b_prec ? -1 : 1; }