From: Charlie Brej Date: Fri, 3 Jul 2009 16:07:10 +0000 (+0100) Subject: [script] Corrected indentation and formatting to match the rest of the project X-Git-Tag: 0.7.0~108 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e50ef7aacc27cc205d6a5d4a4e1ea5552ecf887d;p=thirdparty%2Fplymouth.git [script] Corrected indentation and formatting to match the rest of the project Uncrustify did a reasonable job and only needed minor fixups. --- diff --git a/src/plugins/splash/script/plugin.c b/src/plugins/splash/script/plugin.c index 37748e9f..ab43ca89 100644 --- a/src/plugins/splash/script/plugin.c +++ b/src/plugins/splash/script/plugin.c @@ -70,17 +70,16 @@ #define FRAMES_PER_SECOND 50 #endif - struct _ply_boot_splash_plugin { ply_event_loop_t *loop; ply_boot_splash_mode_t mode; ply_frame_buffer_t *frame_buffer; ply_window_t *window; - + char *script_filename; char *image_dir; - + script_state *script_state; script_op *script_main_op; script_lib_sprite_data_t *script_sprite_lib; @@ -98,18 +97,15 @@ static void detach_from_event_loop (ply_boot_splash_plugin_t *plugin); static void stop_animation (ply_boot_splash_plugin_t *plugin); ply_boot_splash_plugin_t *create_plugin (ply_key_file_t *key_file); - ply_boot_splash_plugin_t * create_plugin (ply_key_file_t *key_file) { ply_boot_splash_plugin_t *plugin; - srand ((int) ply_get_timestamp ()); - plugin = calloc (1, sizeof (ply_boot_splash_plugin_t)); - plugin->image_dir = ply_key_file_get_value (key_file, "script", "ImageDir"); - plugin->script_filename = ply_key_file_get_value (key_file, "script", "ScriptFile"); - + plugin->script_filename = ply_key_file_get_value (key_file, + "script", + "ScriptFile"); return plugin; } @@ -118,18 +114,17 @@ destroy_plugin (ply_boot_splash_plugin_t *plugin) { if (plugin == NULL) return; - remove_handlers (plugin); if (plugin->loop != NULL) { stop_animation (plugin); - ply_event_loop_stop_watching_for_exit (plugin->loop, (ply_event_loop_exit_handler_t) + ply_event_loop_stop_watching_for_exit (plugin->loop, + (ply_event_loop_exit_handler_t) detach_from_event_loop, plugin); detach_from_event_loop (plugin); } - free (plugin->script_filename); free (plugin->image_dir); free (plugin); @@ -139,12 +134,13 @@ static void on_timeout (ply_boot_splash_plugin_t *plugin) { double sleep_time; - - script_lib_plymouth_on_refresh(plugin->script_state, plugin->script_plymouth_lib); - script_lib_sprite_refresh(plugin->script_sprite_lib); - + + script_lib_plymouth_on_refresh (plugin->script_state, + plugin->script_plymouth_lib); + script_lib_sprite_refresh (plugin->script_sprite_lib); + sleep_time = 1.0 / FRAMES_PER_SECOND; - ply_event_loop_watch_for_timeout (plugin->loop, + ply_event_loop_watch_for_timeout (plugin->loop, sleep_time, (ply_event_loop_timeout_handler_t) on_timeout, plugin); @@ -155,33 +151,38 @@ on_boot_progress (ply_boot_splash_plugin_t *plugin, double duration, double percent_done) { - script_lib_plymouth_on_boot_progress(plugin->script_state, plugin->script_plymouth_lib, duration, percent_done); + script_lib_plymouth_on_boot_progress (plugin->script_state, + plugin->script_plymouth_lib, + duration, + percent_done); } - static bool start_animation (ply_boot_splash_plugin_t *plugin) { ply_frame_buffer_area_t area; + assert (plugin != NULL); assert (plugin->loop != NULL); if (plugin->is_animating) - return true; - + return true; ply_frame_buffer_get_size (plugin->frame_buffer, &area); ply_trace ("parsing script file"); plugin->script_main_op = script_parse_file (plugin->script_filename); - plugin->script_state = script_state_new(plugin); - plugin->script_image_lib = script_lib_image_setup(plugin->script_state,plugin->image_dir); - plugin->script_sprite_lib = script_lib_sprite_setup(plugin->script_state, plugin->window); - plugin->script_plymouth_lib = script_lib_plymouth_setup(plugin->script_state); - plugin->script_math_lib = script_lib_math_setup(plugin->script_state); + plugin->script_state = script_state_new (plugin); + plugin->script_image_lib = script_lib_image_setup (plugin->script_state, + plugin->image_dir); + plugin->script_sprite_lib = script_lib_sprite_setup (plugin->script_state, + plugin->window); + plugin->script_plymouth_lib = script_lib_plymouth_setup (plugin->script_state); + plugin->script_math_lib = script_lib_math_setup (plugin->script_state); ply_trace ("executing script file"); - script_return ret = script_execute(plugin->script_state, plugin->script_main_op); - script_obj_unref(ret.object); + script_return ret = script_execute (plugin->script_state, + plugin->script_main_op); + script_obj_unref (ret.object); on_timeout (plugin); plugin->is_animating = true; @@ -195,21 +196,18 @@ stop_animation (ply_boot_splash_plugin_t *plugin) assert (plugin->loop != NULL); if (!plugin->is_animating) - return; - + return; plugin->is_animating = false; if (plugin->loop != NULL) - { - ply_event_loop_stop_watching_for_timeout (plugin->loop, - (ply_event_loop_timeout_handler_t) - on_timeout, plugin); - } - script_state_destroy(plugin->script_state); - script_lib_sprite_destroy(plugin->script_sprite_lib); - script_lib_image_destroy(plugin->script_image_lib); - script_lib_plymouth_destroy(plugin->script_plymouth_lib); - script_lib_math_destroy(plugin->script_math_lib); - script_parse_op_free (plugin->script_main_op); + ply_event_loop_stop_watching_for_timeout (plugin->loop, + (ply_event_loop_timeout_handler_t) + on_timeout, plugin); + script_state_destroy (plugin->script_state); + script_lib_sprite_destroy (plugin->script_sprite_lib); + script_lib_image_destroy (plugin->script_image_lib); + script_lib_plymouth_destroy (plugin->script_plymouth_lib); + script_lib_math_destroy (plugin->script_math_lib); + script_parse_op_free (plugin->script_main_op); } static void @@ -231,24 +229,24 @@ on_keyboard_input (ply_boot_splash_plugin_t *plugin, const char *keyboard_input, size_t character_size) { - char keyboard_string[character_size+1]; - memcpy(keyboard_string, keyboard_input, character_size); - keyboard_string[character_size]='\0'; - - script_lib_plymouth_on_keyboard_input(plugin->script_state, plugin->script_plymouth_lib, keyboard_string); + char keyboard_string[character_size + 1]; + + memcpy (keyboard_string, keyboard_input, character_size); + keyboard_string[character_size] = '\0'; + + script_lib_plymouth_on_keyboard_input (plugin->script_state, + plugin->script_plymouth_lib, + keyboard_string); } void on_backspace (ply_boot_splash_plugin_t *plugin) -{ -} +{} void on_enter (ply_boot_splash_plugin_t *plugin, const char *text) -{ -} - +{} void on_draw (ply_boot_splash_plugin_t *plugin, @@ -256,8 +254,7 @@ on_draw (ply_boot_splash_plugin_t *plugin, int y, int width, int height) -{ -} +{} void on_erase (ply_boot_splash_plugin_t *plugin, @@ -265,8 +262,7 @@ on_erase (ply_boot_splash_plugin_t *plugin, int y, int width, int height) -{ -} +{} static void add_handlers (ply_boot_splash_plugin_t *plugin) @@ -284,19 +280,16 @@ add_handlers (ply_boot_splash_plugin_t *plugin) (ply_window_draw_handler_t) on_draw, plugin); ply_window_set_erase_handler (plugin->window, - (ply_window_erase_handler_t) - on_erase, plugin); + (ply_window_erase_handler_t) + on_erase, plugin); } static void remove_handlers (ply_boot_splash_plugin_t *plugin) { - ply_window_remove_keyboard_input_handler (plugin->window, (ply_window_keyboard_input_handler_t) on_keyboard_input); ply_window_remove_backspace_handler (plugin->window, (ply_window_backspace_handler_t) on_backspace); ply_window_remove_enter_handler (plugin->window, (ply_window_enter_handler_t) on_enter); - ply_window_set_draw_handler (plugin->window, NULL, NULL); - ply_window_set_erase_handler (plugin->window, NULL, NULL); } void @@ -334,7 +327,7 @@ show_splash_screen (ply_boot_splash_plugin_t *plugin, ply_event_loop_watch_signal (plugin->loop, SIGINT, - (ply_event_handler_t) + (ply_event_handler_t) on_interrupt, plugin); ply_trace ("setting graphics mode"); @@ -345,7 +338,6 @@ show_splash_screen (ply_boot_splash_plugin_t *plugin, ply_trace ("starting boot animation"); return start_animation (plugin); - } void @@ -353,7 +345,9 @@ update_status (ply_boot_splash_plugin_t *plugin, const char *status) { assert (plugin != NULL); - script_lib_plymouth_on_update_status(plugin->script_state, plugin->script_plymouth_lib, status); + script_lib_plymouth_on_update_status (plugin->script_state, + plugin->script_plymouth_lib, + status); } void @@ -368,12 +362,12 @@ hide_splash_screen (ply_boot_splash_plugin_t *plugin, { stop_animation (plugin); - ply_event_loop_stop_watching_for_exit (plugin->loop, (ply_event_loop_exit_handler_t) + ply_event_loop_stop_watching_for_exit (plugin->loop, + (ply_event_loop_exit_handler_t) detach_from_event_loop, plugin); detach_from_event_loop (plugin); } - plugin->frame_buffer = NULL; ply_window_set_mode (plugin->window, PLY_WINDOW_MODE_TEXT); @@ -382,7 +376,8 @@ hide_splash_screen (ply_boot_splash_plugin_t *plugin, void on_root_mounted (ply_boot_splash_plugin_t *plugin) { - script_lib_plymouth_on_root_mounted(plugin->script_state, plugin->script_plymouth_lib); + script_lib_plymouth_on_root_mounted (plugin->script_state, + plugin->script_plymouth_lib); } void @@ -392,11 +387,10 @@ become_idle (ply_boot_splash_plugin_t *plugin, ply_trigger_pull (idle_trigger, NULL); } - - void display_normal (ply_boot_splash_plugin_t *plugin) { - script_lib_plymouth_on_display_normal(plugin->script_state, plugin->script_plymouth_lib); + script_lib_plymouth_on_display_normal (plugin->script_state, + plugin->script_plymouth_lib); } void @@ -404,7 +398,10 @@ display_password (ply_boot_splash_plugin_t *plugin, const char *prompt, int bullets) { - script_lib_plymouth_on_display_password(plugin->script_state, plugin->script_plymouth_lib, prompt, bullets); + script_lib_plymouth_on_display_password (plugin->script_state, + plugin->script_plymouth_lib, + prompt, + bullets); } void @@ -412,28 +409,31 @@ display_question (ply_boot_splash_plugin_t *plugin, const char *prompt, const char *entry_text) { - script_lib_plymouth_on_display_question(plugin->script_state, plugin->script_plymouth_lib, prompt, entry_text); + script_lib_plymouth_on_display_question (plugin->script_state, + plugin->script_plymouth_lib, + prompt, + entry_text); } ply_boot_splash_plugin_interface_t * ply_boot_splash_plugin_get_interface (void) { static ply_boot_splash_plugin_interface_t plugin_interface = - { - .create_plugin = create_plugin, - .destroy_plugin = destroy_plugin, - .add_window = add_window, - .remove_window = remove_window, - .show_splash_screen = show_splash_screen, - .update_status = update_status, - .on_boot_progress = on_boot_progress, - .hide_splash_screen = hide_splash_screen, - .on_root_mounted = on_root_mounted, - .become_idle = become_idle, - .display_normal = display_normal, - .display_password = display_password, - .display_question = display_question, - }; + { + .create_plugin = create_plugin, + .destroy_plugin = destroy_plugin, + .add_window = add_window, + .remove_window = remove_window, + .show_splash_screen = show_splash_screen, + .update_status = update_status, + .on_boot_progress = on_boot_progress, + .hide_splash_screen = hide_splash_screen, + .on_root_mounted = on_root_mounted, + .become_idle = become_idle, + .display_normal = display_normal, + .display_password = display_password, + .display_question = display_question, + }; return &plugin_interface; } diff --git a/src/plugins/splash/script/plugin.h b/src/plugins/splash/script/plugin.h index e69de29b..67f10b50 100644 --- a/src/plugins/splash/script/plugin.h +++ b/src/plugins/splash/script/plugin.h @@ -0,0 +1,23 @@ +/* plugin.h - boot script plugin + * + * Copyright (C) 2007, 2008 Red Hat, Inc. + * 2008, 2009 Charlie Brej + * + * 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 2, 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Written by: Charlie Brej + * Ray Strode + */ diff --git a/src/plugins/splash/script/ply-scan.c b/src/plugins/splash/script/ply-scan.c index 4c63b6a5..1460f61f 100644 --- a/src/plugins/splash/script/ply-scan.c +++ b/src/plugins/splash/script/ply-scan.c @@ -30,343 +30,378 @@ #define COLUMN_START_INDEX 0 -static ply_scan_t* ply_scan_new(void) +static ply_scan_t *ply_scan_new (void) { - unsigned char* chars; - ply_scan_t* scan = calloc(1, sizeof(ply_scan_t)); - scan->tokens = NULL; - scan->tokencount = 0; - scan->cur_char = '\0'; - scan->line_index = 1; // According to Nedit the first line is 1 but first column is 0 - scan->column_index = COLUMN_START_INDEX; - - scan->identifier_1st_char = ply_bitarray_new(256); - scan->identifier_nth_char = ply_bitarray_new(256); - - for (chars = (unsigned char*) "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"; *chars; chars++){ - ply_bitarray_set(scan->identifier_1st_char, *chars); - } - for (chars = (unsigned char*) "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_0123456789"; *chars; chars++){ - ply_bitarray_set(scan->identifier_nth_char, *chars); - } - return scan; + unsigned char *chars; + ply_scan_t *scan = calloc (1, sizeof (ply_scan_t)); + + scan->tokens = NULL; + scan->tokencount = 0; + scan->cur_char = '\0'; + scan->line_index = 1; /* According to Nedit the first line is 1 but first column is 0 */ + scan->column_index = COLUMN_START_INDEX; + + scan->identifier_1st_char = ply_bitarray_new (256); + scan->identifier_nth_char = ply_bitarray_new (256); + + for (chars = + (unsigned char *) "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"; + *chars; + chars++) + ply_bitarray_set (scan->identifier_1st_char, *chars); + for (chars = + (unsigned char *) "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_0123456789"; + *chars; + chars++) + ply_bitarray_set (scan->identifier_nth_char, *chars); + return scan; } -ply_scan_t* ply_scan_file(const char* filename) +ply_scan_t *ply_scan_file (const char *filename) { - int fd = open(filename, O_RDONLY); - if (fd<0) return NULL; - ply_scan_t* scan = ply_scan_new(); - scan->source.fd = fd; - scan->source_is_file = true; - ply_scan_get_next_char(scan); - return scan; + int fd = open (filename, O_RDONLY); + if (fd < 0) return NULL; + ply_scan_t *scan = ply_scan_new (); + scan->source.fd = fd; + scan->source_is_file = true; + ply_scan_get_next_char (scan); + return scan; } -ply_scan_t* ply_scan_string(const char* string) +ply_scan_t *ply_scan_string (const char *string) { - ply_scan_t* scan = ply_scan_new(); - scan->source.string = string; - scan->source_is_file = false; - ply_scan_get_next_char(scan); - return scan; + ply_scan_t *scan = ply_scan_new (); + scan->source.string = string; + scan->source_is_file = false; + ply_scan_get_next_char (scan); + return scan; } -void ply_scan_token_clean(ply_scan_token_t* token) +void ply_scan_token_clean (ply_scan_token_t *token) { - switch (token->type){ - case PLY_SCAN_TOKEN_TYPE_EMPTY: - case PLY_SCAN_TOKEN_TYPE_EOF: - case PLY_SCAN_TOKEN_TYPE_INTEGER: - case PLY_SCAN_TOKEN_TYPE_FLOAT: - case PLY_SCAN_TOKEN_TYPE_SYMBOL: - case PLY_SCAN_TOKEN_TYPE_ERROR: + switch (token->type) + { + case PLY_SCAN_TOKEN_TYPE_EMPTY: + case PLY_SCAN_TOKEN_TYPE_EOF: + case PLY_SCAN_TOKEN_TYPE_INTEGER: + case PLY_SCAN_TOKEN_TYPE_FLOAT: + case PLY_SCAN_TOKEN_TYPE_SYMBOL: + case PLY_SCAN_TOKEN_TYPE_ERROR: break; - case PLY_SCAN_TOKEN_TYPE_IDENTIFIER: - case PLY_SCAN_TOKEN_TYPE_STRING: - case PLY_SCAN_TOKEN_TYPE_COMMENT: - free(token->data.string); + case PLY_SCAN_TOKEN_TYPE_IDENTIFIER: + case PLY_SCAN_TOKEN_TYPE_STRING: + case PLY_SCAN_TOKEN_TYPE_COMMENT: + free (token->data.string); break; } - token->type = PLY_SCAN_TOKEN_TYPE_EMPTY; - token->whitespace = 0; + token->type = PLY_SCAN_TOKEN_TYPE_EMPTY; + token->whitespace = 0; } -void ply_scan_free(ply_scan_t* scan) +void ply_scan_free (ply_scan_t *scan) { - int i; - if (scan->source_is_file) close(scan->source.fd); - for (i=0; itokencount; i++){ - ply_scan_token_clean(scan->tokens[i]); - free(scan->tokens[i]); + int i; + if (scan->source_is_file) close (scan->source.fd); + for (i = 0; i < scan->tokencount; i++) + { + ply_scan_token_clean (scan->tokens[i]); + free (scan->tokens[i]); } - ply_bitarray_free(scan->identifier_1st_char); - ply_bitarray_free(scan->identifier_nth_char); - free(scan->tokens); - free(scan); + ply_bitarray_free (scan->identifier_1st_char); + ply_bitarray_free (scan->identifier_nth_char); + free (scan->tokens); + free (scan); } -unsigned char ply_scan_get_current_char(ply_scan_t* scan) +unsigned char ply_scan_get_current_char (ply_scan_t *scan) { - return scan->cur_char; + return scan->cur_char; } -unsigned char ply_scan_get_next_char(ply_scan_t* scan) +unsigned char ply_scan_get_next_char (ply_scan_t *scan) { - if (scan->cur_char == '\n') { - scan->line_index++; - scan->column_index = COLUMN_START_INDEX; + if (scan->cur_char == '\n') + { + scan->line_index++; + scan->column_index = COLUMN_START_INDEX; } - else if (scan->cur_char != '\0') + else if (scan->cur_char != '\0') scan->column_index++; - - if (scan->source_is_file) { - int got = read (scan->source.fd, &scan->cur_char, 1); - if (!got) scan->cur_char = 0; // FIXME a better way of doing EOF etc + if (scan->source_is_file) + { + int got = read (scan->source.fd, &scan->cur_char, 1); + if (!got) scan->cur_char = 0; /* FIXME a better way of doing EOF etc */ } - else { - scan->cur_char = *scan->source.string; - if (scan->cur_char) scan->source.string++; + else + { + scan->cur_char = *scan->source.string; + if (scan->cur_char) scan->source.string++; } - return scan->cur_char; + return scan->cur_char; } -void ply_scan_read_next_token(ply_scan_t* scan, ply_scan_token_t* token) +void ply_scan_read_next_token (ply_scan_t *scan, + ply_scan_token_t *token) { - unsigned char curchar = ply_scan_get_current_char(scan); // FIXME Double check these unsigned chars are ok - unsigned char nextchar; - - token->whitespace = 0; - while(true){ - if (curchar == ' ') {curchar = ply_scan_get_next_char(scan); token->whitespace++; continue;} //FIXME restrcuture - if (curchar == '\n') {curchar = ply_scan_get_next_char(scan); token->whitespace++; continue;} - if (curchar == '\t') {curchar = ply_scan_get_next_char(scan); token->whitespace++; continue;} - break; + unsigned char curchar = ply_scan_get_current_char (scan); /* FIXME Double check these unsigned chars are ok */ + unsigned char nextchar; + + token->whitespace = 0; + while (true) + { + if (curchar == ' ') + { + curchar = ply_scan_get_next_char (scan); + token->whitespace++; + continue; + } /* FIXME restrcuture */ + if (curchar == '\n') + { + curchar = ply_scan_get_next_char (scan); + token->whitespace++; + continue; + } + if (curchar == '\t') + { + curchar = ply_scan_get_next_char (scan); + token->whitespace++; + continue; + } + break; } - token->line_index = scan->line_index; - token->column_index = scan->column_index; - nextchar = ply_scan_get_next_char(scan); - - if (ply_bitarray_lookup(scan->identifier_1st_char, curchar)){ - token->type = PLY_SCAN_TOKEN_TYPE_IDENTIFIER; - int index = 1; - token->data.string = malloc(2*sizeof(char)); - token->data.string[0] = curchar; - token->data.string[1] = '\0'; - curchar = nextchar; - while (ply_bitarray_lookup(scan->identifier_nth_char, curchar)){ - token->data.string = realloc(token->data.string, (index+2)*sizeof(char)); - token->data.string[index] = curchar; - token->data.string[index+1] = '\0'; - index++; - curchar = ply_scan_get_next_char(scan); + token->line_index = scan->line_index; + token->column_index = scan->column_index; + nextchar = ply_scan_get_next_char (scan); + + if (ply_bitarray_lookup (scan->identifier_1st_char, curchar)) + { + int index = 1; + token->type = PLY_SCAN_TOKEN_TYPE_IDENTIFIER; + token->data.string = malloc (2 * sizeof (char)); + token->data.string[0] = curchar; + token->data.string[1] = '\0'; + curchar = nextchar; + while (ply_bitarray_lookup (scan->identifier_nth_char, curchar)) + { + token->data.string = realloc (token->data.string, + (index + 2) * sizeof (char)); + token->data.string[index] = curchar; + token->data.string[index + 1] = '\0'; + index++; + curchar = ply_scan_get_next_char (scan); } - return; + return; } - - - if (curchar >= '0' && curchar <= '9'){ - long long int int_value = curchar - '0'; - curchar = nextchar; - while (curchar >= '0' && curchar <= '9') { - int_value *= 10; - int_value += curchar - '0'; - curchar = ply_scan_get_next_char(scan); + if ((curchar >= '0') && (curchar <= '9')) + { + long long int int_value = curchar - '0'; + curchar = nextchar; + while (curchar >= '0' && curchar <= '9') + { + int_value *= 10; + int_value += curchar - '0'; + curchar = ply_scan_get_next_char (scan); } - - if (curchar == '.'){ - double floatpoint = int_value; - double scalar = 1; - - curchar = ply_scan_get_next_char(scan); - while (curchar >= '0' && curchar <= '9'){ - scalar /= 10; - floatpoint += scalar * (curchar - '0'); - curchar = ply_scan_get_next_char(scan); + + if (curchar == '.') + { + double floatpoint = int_value; + double scalar = 1; + + curchar = ply_scan_get_next_char (scan); + while (curchar >= '0' && curchar <= '9') + { + scalar /= 10; + floatpoint += scalar * (curchar - '0'); + curchar = ply_scan_get_next_char (scan); } - token->type = PLY_SCAN_TOKEN_TYPE_FLOAT; - token->data.floatpoint = floatpoint; + token->type = PLY_SCAN_TOKEN_TYPE_FLOAT; + token->data.floatpoint = floatpoint; } - else { - token->type = PLY_SCAN_TOKEN_TYPE_INTEGER; - token->data.integer = int_value; + else + { + token->type = PLY_SCAN_TOKEN_TYPE_INTEGER; + token->data.integer = int_value; } - return; + return; } - - if (!curchar) { - token->type = PLY_SCAN_TOKEN_TYPE_EOF; - return; + if (!curchar) + { + token->type = PLY_SCAN_TOKEN_TYPE_EOF; + return; } - - if (curchar == '\"') { - token->type = PLY_SCAN_TOKEN_TYPE_STRING; - int index = 0; - token->data.string = malloc(sizeof(char)); - token->data.string[0] = '\0'; - curchar = nextchar; + if (curchar == '\"') + { + token->type = PLY_SCAN_TOKEN_TYPE_STRING; + int index = 0; + token->data.string = malloc (sizeof (char)); + token->data.string[0] = '\0'; + curchar = nextchar; - while (curchar != '\"'){ - if (curchar == '\0') { - token->data.string = "End of file before end of string"; - token->type = PLY_SCAN_TOKEN_TYPE_ERROR; - return; + while (curchar != '\"') + { + if (curchar == '\0') + { + token->data.string = "End of file before end of string"; + token->type = PLY_SCAN_TOKEN_TYPE_ERROR; + return; } - if (curchar == '\n') { - token->data.string = "Line terminator before end of string"; - token->type = PLY_SCAN_TOKEN_TYPE_ERROR; - return; + if (curchar == '\n') + { + token->data.string = "Line terminator before end of string"; + token->type = PLY_SCAN_TOKEN_TYPE_ERROR; + return; } - if (curchar == '\\') { - curchar = ply_scan_get_next_char(scan); - switch (curchar){ - case 'n': + if (curchar == '\\') + { + curchar = ply_scan_get_next_char (scan); + switch (curchar) + { + case 'n': curchar = '\n'; break; - case '0': + + case '0': curchar = '\0'; break; - case '"': + + case '"': curchar = '\"'; break; - default: + + default: break; } } - token->data.string = realloc(token->data.string, (index+2)*sizeof(char)); - token->data.string[index] = curchar; - token->data.string[index+1] = '\0'; - index++; - curchar = ply_scan_get_next_char(scan); + token->data.string = realloc (token->data.string, + (index + 2) * sizeof (char)); + token->data.string[index] = curchar; + token->data.string[index + 1] = '\0'; + index++; + curchar = ply_scan_get_next_char (scan); } - ply_scan_get_next_char(scan); - return; + ply_scan_get_next_char (scan); + return; } - - { + { bool linecomment = false; if (curchar == '#') linecomment = true; - if (curchar == '/' && nextchar == '/'){ + if ((curchar == '/') && (nextchar == '/')) + { linecomment = true; - nextchar = ply_scan_get_next_char(scan); - } - if (linecomment){ + nextchar = ply_scan_get_next_char (scan); + } + if (linecomment) + { int index = 0; - token->data.string = malloc(sizeof(char)); + token->data.string = malloc (sizeof (char)); token->data.string[0] = '\0'; curchar = nextchar; - for (curchar = nextchar; curchar != '\n' && curchar != '\0'; curchar = ply_scan_get_next_char(scan)){ - token->data.string = realloc(token->data.string, (index+2)*sizeof(char)); + for (curchar = nextchar; + curchar != '\n' && curchar != '\0'; + curchar = ply_scan_get_next_char (scan)) + { + token->data.string = realloc (token->data.string, + (index + 2) * sizeof (char)); token->data.string[index] = curchar; - token->data.string[index+1] = '\0'; + token->data.string[index + 1] = '\0'; index++; - } + } token->type = PLY_SCAN_TOKEN_TYPE_COMMENT; return; - } - } + } + } - if (curchar == '/' && nextchar == '*'){ - int index = 0; - int depth = 1; - token->data.string = malloc(sizeof(char)); - token->data.string[0] = '\0'; - curchar = ply_scan_get_next_char(scan); - nextchar = ply_scan_get_next_char(scan); - - while (true){ - if (nextchar == '\0') { - free(token->data.string); - token->data.string = "End of file before end of comment"; - token->type = PLY_SCAN_TOKEN_TYPE_ERROR; - return; - } + if ((curchar == '/') && (nextchar == '*')) + { + int index = 0; + int depth = 1; + token->data.string = malloc (sizeof (char)); + token->data.string[0] = '\0'; + curchar = ply_scan_get_next_char (scan); + nextchar = ply_scan_get_next_char (scan); - if (curchar == '/' && nextchar == '*') { - depth++; + while (true) + { + if (nextchar == '\0') + { + free (token->data.string); + token->data.string = "End of file before end of comment"; + token->type = PLY_SCAN_TOKEN_TYPE_ERROR; + return; } - if (curchar == '*' && nextchar == '/') { - depth--; - if (!depth) break; + if ((curchar == '/') && (nextchar == '*')) + depth++; + if ((curchar == '*') && (nextchar == '/')) + { + depth--; + if (!depth) break; } - - token->data.string = realloc(token->data.string, (index+2)*sizeof(char)); - token->data.string[index] = curchar; - token->data.string[index+1] = '\0'; - index++; - curchar = nextchar; - nextchar = ply_scan_get_next_char(scan); + token->data.string = realloc (token->data.string, + (index + 2) * sizeof (char)); + token->data.string[index] = curchar; + token->data.string[index + 1] = '\0'; + index++; + curchar = nextchar; + nextchar = ply_scan_get_next_char (scan); } - ply_scan_get_next_char(scan); - token->type = PLY_SCAN_TOKEN_TYPE_COMMENT; - return; + ply_scan_get_next_char (scan); + token->type = PLY_SCAN_TOKEN_TYPE_COMMENT; + return; } - - // all other - token->type = PLY_SCAN_TOKEN_TYPE_SYMBOL; - token->data.symbol = curchar; - return; + /* all other */ + token->type = PLY_SCAN_TOKEN_TYPE_SYMBOL; + token->data.symbol = curchar; + return; } - -static ply_scan_token_t* ply_scan_peek_token(ply_scan_t* scan, int n) +static ply_scan_token_t *ply_scan_peek_token (ply_scan_t *scan, + int n) { - int i; - if (scan->tokencount <= n){ - scan->tokens = realloc(scan->tokens, (n+1)*sizeof(ply_scan_token_t*)); - for (i = scan->tokencount; i<=n; i++){ // FIXME warning about possibely inifnite loop - scan->tokens[i] = malloc(sizeof(ply_scan_token_t)); - scan->tokens[i]->type = PLY_SCAN_TOKEN_TYPE_EMPTY; + int i; + + if (scan->tokencount <= n) + { + scan->tokens = + realloc (scan->tokens, (n + 1) * sizeof (ply_scan_token_t *)); + for (i = scan->tokencount; i <= n; i++) /* FIXME warning about possibely inifnite loop */ + { + scan->tokens[i] = malloc (sizeof (ply_scan_token_t)); + scan->tokens[i]->type = PLY_SCAN_TOKEN_TYPE_EMPTY; } - scan->tokencount = n+1; + scan->tokencount = n + 1; } - - if (scan->tokens[n]->type == PLY_SCAN_TOKEN_TYPE_EMPTY){ - if (n > 0 && scan->tokens[n-1]->type == PLY_SCAN_TOKEN_TYPE_EMPTY) - ply_scan_peek_token(scan, n-1); - do { - ply_scan_token_clean(scan->tokens[n]); - ply_scan_read_next_token(scan, scan->tokens[n]); // FIXME if skipping comments, add whitespace to next token + if (scan->tokens[n]->type == PLY_SCAN_TOKEN_TYPE_EMPTY) + { + if ((n > 0) && (scan->tokens[n - 1]->type == PLY_SCAN_TOKEN_TYPE_EMPTY)) + ply_scan_peek_token (scan, n - 1); + do + { + ply_scan_token_clean (scan->tokens[n]); + ply_scan_read_next_token (scan, scan->tokens[n]); /* FIXME if skipping comments, add whitespace to next token */ } - while (scan->tokens[n]->type == PLY_SCAN_TOKEN_TYPE_COMMENT); // FIXME optionally pass comments back -// printf("%d:", n); -// switch (scan->tokens[n]->type){ -// case PLY_SCAN_TOKEN_TYPE_STRING: -// printf("\"%s\"\n", scan->tokens[n]->data.string); -// break; -// case PLY_SCAN_TOKEN_TYPE_IDENTIFIER: -// printf("%s\n", scan->tokens[n]->data.string); -// break; -// case PLY_SCAN_TOKEN_TYPE_SYMBOL: -// printf("'%c'\n", scan->tokens[n]->data.symbol); -// break; -// case PLY_SCAN_TOKEN_TYPE_INTEGER: -// printf("%d\n", (int)scan->tokens[n]->data.integer); -// break; -// } + while (scan->tokens[n]->type == PLY_SCAN_TOKEN_TYPE_COMMENT); /* FIXME optionally pass comments back */ } - return scan->tokens[n]; + return scan->tokens[n]; } -ply_scan_token_t* ply_scan_get_next_token(ply_scan_t* scan) +ply_scan_token_t *ply_scan_get_next_token (ply_scan_t *scan) { - int i; - ply_scan_token_clean(scan->tokens[0]); - for (i=0; i<(scan->tokencount-1); i++){ - *scan->tokens[i] = *scan->tokens[i+1]; - } - scan->tokens[(scan->tokencount-1)]->type = PLY_SCAN_TOKEN_TYPE_EMPTY; - return ply_scan_peek_token(scan, 0); + int i; + ply_scan_token_clean (scan->tokens[0]); + for (i = 0; i < (scan->tokencount - 1); i++) + *scan->tokens[i] = *scan->tokens[i + 1]; + scan->tokens[(scan->tokencount - 1)]->type = PLY_SCAN_TOKEN_TYPE_EMPTY; + return ply_scan_peek_token (scan, 0); } -ply_scan_token_t* ply_scan_get_current_token(ply_scan_t* scan) +ply_scan_token_t *ply_scan_get_current_token (ply_scan_t *scan) { - return ply_scan_peek_token(scan, 0); + return ply_scan_peek_token (scan, 0); } -ply_scan_token_t* ply_scan_peek_next_token(ply_scan_t* scan) +ply_scan_token_t *ply_scan_peek_next_token (ply_scan_t *scan) { - return ply_scan_peek_token(scan, 1); + return ply_scan_peek_token (scan, 1); } - diff --git a/src/plugins/splash/script/ply-scan.h b/src/plugins/splash/script/ply-scan.h index 345d3112..e9c6d563 100644 --- a/src/plugins/splash/script/ply-scan.h +++ b/src/plugins/splash/script/ply-scan.h @@ -27,39 +27,39 @@ typedef enum { - PLY_SCAN_TOKEN_TYPE_EMPTY, - PLY_SCAN_TOKEN_TYPE_EOF, - PLY_SCAN_TOKEN_TYPE_INTEGER, - PLY_SCAN_TOKEN_TYPE_FLOAT, - PLY_SCAN_TOKEN_TYPE_IDENTIFIER, - PLY_SCAN_TOKEN_TYPE_STRING, - PLY_SCAN_TOKEN_TYPE_SYMBOL, - PLY_SCAN_TOKEN_TYPE_COMMENT, - PLY_SCAN_TOKEN_TYPE_ERROR, + PLY_SCAN_TOKEN_TYPE_EMPTY, + PLY_SCAN_TOKEN_TYPE_EOF, + PLY_SCAN_TOKEN_TYPE_INTEGER, + PLY_SCAN_TOKEN_TYPE_FLOAT, + PLY_SCAN_TOKEN_TYPE_IDENTIFIER, + PLY_SCAN_TOKEN_TYPE_STRING, + PLY_SCAN_TOKEN_TYPE_SYMBOL, + PLY_SCAN_TOKEN_TYPE_COMMENT, + PLY_SCAN_TOKEN_TYPE_ERROR, } ply_scan_token_type_t; typedef struct { - ply_scan_token_type_t type; - union - { - char* string; + ply_scan_token_type_t type; + union + { + char *string; char symbol; long long int integer; double floatpoint; - } data; - int whitespace; - int line_index; - int column_index; + } data; + int whitespace; + int line_index; + int column_index; } ply_scan_token_t; typedef struct { - union - { - int fd; - const char* string; - } source; + union + { + int fd; + const char *string; + } source; unsigned char cur_char; ply_bitarray_t *identifier_1st_char; ply_bitarray_t *identifier_nth_char; @@ -70,15 +70,16 @@ typedef struct bool source_is_file; } ply_scan_t; -ply_scan_t* ply_scan_file(const char* filename); -ply_scan_t* ply_scan_string(const char* string); -void ply_scan_token_clean(ply_scan_token_t* token); -void ply_scan_free(ply_scan_t* scan); -unsigned char ply_scan_get_current_char(ply_scan_t* scan); -unsigned char ply_scan_get_next_char(ply_scan_t* scan); -ply_scan_token_t* ply_scan_get_current_token(ply_scan_t* scan); -ply_scan_token_t* ply_scan_get_next_token(ply_scan_t* scan); -ply_scan_token_t* ply_scan_peek_next_token(ply_scan_t* scan); -void ply_scan_read_next_token(ply_scan_t* scan, ply_scan_token_t* token); +ply_scan_t *ply_scan_file (const char *filename); +ply_scan_t *ply_scan_string (const char *string); +void ply_scan_token_clean (ply_scan_token_t *token); +void ply_scan_free (ply_scan_t *scan); +unsigned char ply_scan_get_current_char (ply_scan_t *scan); +unsigned char ply_scan_get_next_char (ply_scan_t *scan); +ply_scan_token_t *ply_scan_get_current_token (ply_scan_t *scan); +ply_scan_token_t *ply_scan_get_next_token (ply_scan_t *scan); +ply_scan_token_t *ply_scan_peek_next_token (ply_scan_t *scan); +void ply_scan_read_next_token (ply_scan_t *scan, + ply_scan_token_t *token); #endif /* PLY_SCAN_H */ diff --git a/src/plugins/splash/script/script-execute.c b/src/plugins/splash/script/script-execute.c index bce45d57..940e1510 100644 --- a/src/plugins/splash/script/script-execute.c +++ b/src/plugins/splash/script/script-execute.c @@ -37,661 +37,784 @@ #include "script-execute.h" #include "script-object.h" -static script_obj* script_evaluate (script_state* state, script_exp* exp); -static script_return script_execute_function_with_parlist (script_state* state, script_function* function, ply_list_t* parameter_data); +static script_obj *script_evaluate (script_state *state, + script_exp *exp); +static script_return script_execute_function_with_parlist (script_state *state, + script_function *function, + ply_list_t *parameter_data); -static script_obj* script_evaluate_apply_function (script_state* state, script_exp* exp, script_obj* (*function) (script_obj*, script_obj*)) +static script_obj *script_evaluate_apply_function (script_state *state, + script_exp *exp, + script_obj *(*function)(script_obj *, script_obj *)) { - script_obj* script_obj_a = script_evaluate (state, exp->data.dual.sub_a); - script_obj* script_obj_b = script_evaluate (state, exp->data.dual.sub_b); - script_obj* obj = function (script_obj_a, script_obj_b); - script_obj_unref (script_obj_a); - script_obj_unref (script_obj_b); - return obj; + script_obj *script_obj_a = script_evaluate (state, exp->data.dual.sub_a); + script_obj *script_obj_b = script_evaluate (state, exp->data.dual.sub_b); + script_obj *obj = function (script_obj_a, script_obj_b); + + script_obj_unref (script_obj_a); + script_obj_unref (script_obj_b); + return obj; } -static script_obj* script_evaluate_apply_function_and_assign (script_state* state, script_exp* exp, script_obj* (*function) (script_obj*, script_obj*)) +static script_obj *script_evaluate_apply_function_and_assign (script_state *state, + script_exp *exp, + script_obj *(*function)(script_obj *, script_obj *)) { - script_obj* script_obj_a = script_evaluate (state, exp->data.dual.sub_a); - script_obj* script_obj_b = script_evaluate (state, exp->data.dual.sub_b); - script_obj* obj = function (script_obj_a, script_obj_b); - script_obj_assign (script_obj_a, obj); - script_obj_unref (script_obj_a); - script_obj_unref (script_obj_b); - return obj; + script_obj *script_obj_a = script_evaluate (state, exp->data.dual.sub_a); + script_obj *script_obj_b = script_evaluate (state, exp->data.dual.sub_b); + script_obj *obj = function (script_obj_a, script_obj_b); + + script_obj_assign (script_obj_a, obj); + script_obj_unref (script_obj_a); + script_obj_unref (script_obj_b); + return obj; } -static script_obj* script_evaluate_hash (script_state* state, script_exp* exp) +static script_obj *script_evaluate_hash (script_state *state, + script_exp *exp) { - script_obj* hash = script_evaluate (state, exp->data.dual.sub_a); - script_obj* key = script_evaluate (state, exp->data.dual.sub_b); - script_obj* hash_dereffed = script_obj_deref_direct(hash); - script_obj* obj; - script_obj_deref (&key); - - if (hash_dereffed->type == SCRIPT_OBJ_TYPE_HASH){ - script_obj_deref (&hash); - } - else { - script_obj_reset (hash); - script_obj* newhash = script_obj_new_hash (); - hash->type = SCRIPT_OBJ_TYPE_REF; - hash->data.obj = newhash; + script_obj *hash = script_evaluate (state, exp->data.dual.sub_a); + script_obj *key = script_evaluate (state, exp->data.dual.sub_b); + script_obj *hash_dereffed = script_obj_deref_direct (hash); + script_obj *obj; + + script_obj_deref (&key); + + if (hash_dereffed->type == SCRIPT_OBJ_TYPE_HASH) script_obj_deref (&hash); + else + { + script_obj_reset (hash); + script_obj *newhash = script_obj_new_hash (); + hash->type = SCRIPT_OBJ_TYPE_REF; + hash->data.obj = newhash; + script_obj_deref (&hash); } - - - char* name = script_obj_as_string(key); - script_vareable* vareable = ply_hashtable_lookup (hash->data.hash, name); - - if (vareable) { - obj = vareable->object; - free(name); + char *name = script_obj_as_string (key); + script_vareable *vareable = ply_hashtable_lookup (hash->data.hash, name); + + if (vareable) + { + obj = vareable->object; + free (name); } - else { - obj = script_obj_new_null (); - vareable = malloc(sizeof(script_vareable)); - vareable->name = name; - vareable->object = obj; - ply_hashtable_insert (hash->data.hash, vareable->name, vareable); + else + { + obj = script_obj_new_null (); + vareable = malloc (sizeof (script_vareable)); + vareable->name = name; + vareable->object = obj; + ply_hashtable_insert (hash->data.hash, vareable->name, vareable); } - - script_obj_ref (obj); - script_obj_unref (hash); - script_obj_unref (key); - return obj; + script_obj_ref (obj); + script_obj_unref (hash); + script_obj_unref (key); + return obj; } - -static script_obj* script_evaluate_var (script_state* state, script_exp* exp) +static script_obj *script_evaluate_var (script_state *state, + script_exp *exp) { - char* name = exp->data.string; - script_obj* obj; - script_obj_deref(&state->global); - script_obj_deref(&state->local); - assert (state->global->type == SCRIPT_OBJ_TYPE_HASH); - assert (state->local->type == SCRIPT_OBJ_TYPE_HASH); - - script_vareable* vareable = ply_hashtable_lookup (state->local->data.hash, name); - if (!vareable) + char *name = exp->data.string; + script_obj *obj; + + script_obj_deref (&state->global); + script_obj_deref (&state->local); + assert (state->global->type == SCRIPT_OBJ_TYPE_HASH); + assert (state->local->type == SCRIPT_OBJ_TYPE_HASH); + + script_vareable *vareable = ply_hashtable_lookup (state->local->data.hash, + name); + if (!vareable) vareable = ply_hashtable_lookup (state->global->data.hash, name); - if (vareable) { - obj = vareable->object; - script_obj_ref (obj); - return obj; + if (vareable) + { + obj = vareable->object; + script_obj_ref (obj); + return obj; } - obj = script_obj_new_null (); + obj = script_obj_new_null (); - vareable = malloc(sizeof(script_vareable)); - vareable->name = strdup(name); - vareable->object = obj; + vareable = malloc (sizeof (script_vareable)); + vareable->name = strdup (name); + vareable->object = obj; - ply_hashtable_insert (state->local->data.hash, vareable->name, vareable); - script_obj_ref (obj); - return obj; + ply_hashtable_insert (state->local->data.hash, vareable->name, vareable); + script_obj_ref (obj); + return obj; } - -static script_obj* script_evaluate_assign (script_state* state, script_exp* exp) +static script_obj *script_evaluate_assign (script_state *state, + script_exp *exp) { - script_obj* script_obj_a = script_evaluate (state, exp->data.dual.sub_a); - script_obj* script_obj_b = script_evaluate (state, exp->data.dual.sub_b); - script_obj_deref (&script_obj_b); - script_obj_assign (script_obj_a, script_obj_b); - - script_obj_unref(script_obj_b); - return script_obj_a; + script_obj *script_obj_a = script_evaluate (state, exp->data.dual.sub_a); + script_obj *script_obj_b = script_evaluate (state, exp->data.dual.sub_b); + + script_obj_deref (&script_obj_b); + script_obj_assign (script_obj_a, script_obj_b); + + script_obj_unref (script_obj_b); + return script_obj_a; } -static script_obj* script_evaluate_cmp (script_state* state, script_exp* exp) +static script_obj *script_evaluate_cmp (script_state *state, + script_exp *exp) { - script_obj* script_obj_a = script_evaluate (state, exp->data.dual.sub_a); - script_obj* script_obj_b = script_evaluate (state, exp->data.dual.sub_b); - - script_obj_deref (&script_obj_a); - script_obj_deref (&script_obj_b); - - int gt=0; - int lt=0; - int eq=0; - int ne=0; - - float val; - int valset=0; - - switch (script_obj_a->type){ - case SCRIPT_OBJ_TYPE_INT: - { - switch (script_obj_b->type){ - case SCRIPT_OBJ_TYPE_INT: + script_obj *script_obj_a = script_evaluate (state, exp->data.dual.sub_a); + script_obj *script_obj_b = script_evaluate (state, exp->data.dual.sub_b); + + script_obj_deref (&script_obj_a); + script_obj_deref (&script_obj_b); + + int gt = 0; + int lt = 0; + int eq = 0; + int ne = 0; + + float val; + int valset = 0; + + switch (script_obj_a->type) + { + case SCRIPT_OBJ_TYPE_INT: + { + switch (script_obj_b->type) + { + case SCRIPT_OBJ_TYPE_INT: val = script_obj_a->data.integer - script_obj_b->data.integer; - valset=1; + valset = 1; break; - case SCRIPT_OBJ_TYPE_FLOAT: - val = script_obj_a->data.integer - script_obj_b->data.floatpoint; - valset=1; + + case SCRIPT_OBJ_TYPE_FLOAT: + val = script_obj_a->data.integer - + script_obj_b->data.floatpoint; + valset = 1; break; - default: + + default: ne = 1; break; } - break; + break; } - case SCRIPT_OBJ_TYPE_FLOAT: - { - switch (script_obj_b->type){ - case SCRIPT_OBJ_TYPE_INT: - val = script_obj_a->data.floatpoint - script_obj_b->data.integer; - valset=1; + + case SCRIPT_OBJ_TYPE_FLOAT: + { + switch (script_obj_b->type) + { + case SCRIPT_OBJ_TYPE_INT: + val = script_obj_a->data.floatpoint - + script_obj_b->data.integer; + valset = 1; break; - case SCRIPT_OBJ_TYPE_FLOAT: - val = script_obj_a->data.floatpoint - script_obj_b->data.floatpoint; - valset=1; + + case SCRIPT_OBJ_TYPE_FLOAT: + val = script_obj_a->data.floatpoint - + script_obj_b->data.floatpoint; + valset = 1; break; - default: + + default: ne = 1; break; } - break; + break; } - case SCRIPT_OBJ_TYPE_STRING: - { - switch (script_obj_b->type){ - case SCRIPT_OBJ_TYPE_STRING: - val = strcmp(script_obj_a->data.string, script_obj_b->data.string); - valset=1; + + case SCRIPT_OBJ_TYPE_STRING: + { + switch (script_obj_b->type) + { + case SCRIPT_OBJ_TYPE_STRING: + val = strcmp (script_obj_a->data.string, + script_obj_b->data.string); + valset = 1; break; - default: + + default: ne = 1; break; } - break; + break; } - case SCRIPT_OBJ_TYPE_HASH: + + case SCRIPT_OBJ_TYPE_HASH: { - switch (script_obj_b->type){ - case SCRIPT_OBJ_TYPE_HASH: + switch (script_obj_b->type) + { + case SCRIPT_OBJ_TYPE_HASH: if (script_obj_a == script_obj_b) eq = 1; else ne = 1; break; - default: + + default: ne = 1; break; } - break; + break; } - case SCRIPT_OBJ_TYPE_FUNCTION: + + case SCRIPT_OBJ_TYPE_FUNCTION: { - switch (script_obj_b->type){ - case SCRIPT_OBJ_TYPE_FUNCTION: + switch (script_obj_b->type) + { + case SCRIPT_OBJ_TYPE_FUNCTION: if (script_obj_a == script_obj_b) eq = 1; else ne = 1; break; - default: + + default: ne = 1; break; } - break; + break; } - case SCRIPT_OBJ_TYPE_NULL: + + case SCRIPT_OBJ_TYPE_NULL: { - switch (script_obj_b->type){ - case SCRIPT_OBJ_TYPE_NULL: + switch (script_obj_b->type) + { + case SCRIPT_OBJ_TYPE_NULL: eq = 1; break; - default: + + default: ne = 1; break; } - break; + break; } - case SCRIPT_OBJ_TYPE_NATIVE: - { - switch (script_obj_b->type){ - case SCRIPT_OBJ_TYPE_NATIVE: - if (script_obj_a->data.native.object_data == script_obj_b->data.native.object_data) - eq = 1; + + case SCRIPT_OBJ_TYPE_NATIVE: + { + switch (script_obj_b->type) + { + case SCRIPT_OBJ_TYPE_NATIVE: + if (script_obj_a->data.native.object_data == + script_obj_b->data.native.object_data) + eq = 1; else ne = 1; break; - default: + + default: ne = 1; break; } - break; + break; } - case SCRIPT_OBJ_TYPE_REF: + + case SCRIPT_OBJ_TYPE_REF: { - assert(0); + assert (0); } } - if(valset){ - if (val < 0) {lt = 1; ne = 1;} - if (fabsf(val) == 0) eq = 1; - if (val > 0) {gt = 1; ne = 1;} + if (valset) + { + if (val < 0) + { + lt = 1; + ne = 1; + } + if (fabsf (val) == 0) eq = 1; + if (val > 0) + { + gt = 1; + ne = 1; + } } - - int reply = 0; - - switch (exp->type){ - case SCRIPT_EXP_TYPE_EQ: - if (eq) reply=1; + int reply = 0; + + switch (exp->type) + { + case SCRIPT_EXP_TYPE_EQ: + if (eq) reply = 1; break; - case SCRIPT_EXP_TYPE_NE: - if (ne) reply=1; + + case SCRIPT_EXP_TYPE_NE: + if (ne) reply = 1; break; - case SCRIPT_EXP_TYPE_GT: - if (gt) reply=1; + + case SCRIPT_EXP_TYPE_GT: + if (gt) reply = 1; break; - case SCRIPT_EXP_TYPE_GE: - if (gt || eq) reply=1; + + case SCRIPT_EXP_TYPE_GE: + if (gt || eq) reply = 1; break; - case SCRIPT_EXP_TYPE_LT: - if (lt) reply=1; + + case SCRIPT_EXP_TYPE_LT: + if (lt) reply = 1; break; - case SCRIPT_EXP_TYPE_LE: - if (lt || eq) reply=1; // CHECKME Errr so "(NULL <= NULL) is true" makes sense? + + case SCRIPT_EXP_TYPE_LE: + if (lt || eq) reply = 1; /* CHECKME Errr so "(NULL <= NULL) is true" makes sense? */ break; - default: - assert(0); + + default: + assert (0); } - - script_obj_unref (script_obj_a); - script_obj_unref (script_obj_b); - - return script_obj_new_int (reply); + + script_obj_unref (script_obj_a); + script_obj_unref (script_obj_b); + + return script_obj_new_int (reply); } -static script_obj* script_evaluate_logic (script_state* state, script_exp* exp) +static script_obj *script_evaluate_logic (script_state *state, + script_exp *exp) { - script_obj* obj = script_evaluate (state, exp->data.dual.sub_a); - if (exp->type == SCRIPT_EXP_TYPE_AND && !script_obj_as_bool(obj)) + script_obj *obj = script_evaluate (state, exp->data.dual.sub_a); + + if ((exp->type == SCRIPT_EXP_TYPE_AND) && !script_obj_as_bool (obj)) return obj; - else if (exp->type == SCRIPT_EXP_TYPE_OR &&script_obj_as_bool(obj)) + else if (exp->type == SCRIPT_EXP_TYPE_OR && script_obj_as_bool (obj)) return obj; - script_obj_unref (obj); - obj = script_evaluate (state, exp->data.dual.sub_b); - return obj; + script_obj_unref (obj); + obj = script_evaluate (state, exp->data.dual.sub_b); + return obj; } -static script_obj* script_evaluate_unary (script_state* state, script_exp* exp) +static script_obj *script_evaluate_unary (script_state *state, + script_exp *exp) { - script_obj* obj = script_evaluate (state, exp->data.sub); - script_obj* new_obj; - script_obj_deref (&obj); - if (exp->type == SCRIPT_EXP_TYPE_NOT){ - int reply = !script_obj_as_bool(obj); - script_obj_unref (obj); - return script_obj_new_int (reply); - } - if (exp->type == SCRIPT_EXP_TYPE_POS){ // FIXME what should happen on non number operands? - return obj; // Does nothing, maybe just remove at parse stage + script_obj *obj = script_evaluate (state, exp->data.sub); + script_obj *new_obj; + + script_obj_deref (&obj); + if (exp->type == SCRIPT_EXP_TYPE_NOT) + { + int reply = !script_obj_as_bool (obj); + script_obj_unref (obj); + return script_obj_new_int (reply); } - if (exp->type == SCRIPT_EXP_TYPE_NEG){ - if (obj->type == SCRIPT_OBJ_TYPE_INT){ + if (exp->type == SCRIPT_EXP_TYPE_POS) /* FIXME what should happen on non number operands? */ + return obj; /* Does nothing, maybe just remove at parse stage */ + if (exp->type == SCRIPT_EXP_TYPE_NEG) + { + if (obj->type == SCRIPT_OBJ_TYPE_INT) new_obj = script_obj_new_int (-obj->data.integer); - } - else if (obj->type == SCRIPT_OBJ_TYPE_FLOAT){ + else if (obj->type == SCRIPT_OBJ_TYPE_FLOAT) new_obj = script_obj_new_float (-obj->data.floatpoint); - } - else new_obj = script_obj_new_null (); - script_obj_unref (obj); - return new_obj; + else new_obj = script_obj_new_null (); + script_obj_unref (obj); + return new_obj; } - - - int change_pre = 0; - int change_post; - - if (exp->type == SCRIPT_EXP_TYPE_PRE_INC || SCRIPT_EXP_TYPE_POST_INC) + int change_pre = 0; + int change_post; + + if ((exp->type == SCRIPT_EXP_TYPE_PRE_INC) || SCRIPT_EXP_TYPE_POST_INC) change_post = 1; - else + else change_post = -1; - - if (exp->type == SCRIPT_EXP_TYPE_PRE_INC) + if (exp->type == SCRIPT_EXP_TYPE_PRE_INC) change_pre = 1; - else if (exp->type == SCRIPT_EXP_TYPE_PRE_DEC) + else if (exp->type == SCRIPT_EXP_TYPE_PRE_DEC) change_pre = -1; - - if (obj->type == SCRIPT_OBJ_TYPE_INT){ - new_obj = script_obj_new_int (obj->data.integer + change_pre); - obj->data.integer += change_post; + if (obj->type == SCRIPT_OBJ_TYPE_INT) + { + new_obj = script_obj_new_int (obj->data.integer + change_pre); + obj->data.integer += change_post; } - else if (obj->type == SCRIPT_OBJ_TYPE_FLOAT){ - new_obj = script_obj_new_float (obj->data.floatpoint + change_pre); - obj->data.floatpoint += change_post; + else if (obj->type == SCRIPT_OBJ_TYPE_FLOAT) + { + new_obj = script_obj_new_float (obj->data.floatpoint + change_pre); + obj->data.floatpoint += change_post; } - else { - new_obj = script_obj_new_null (); // If performeing something like a=hash++; a and hash become NULL - script_obj_reset (obj); + else + { + new_obj = script_obj_new_null (); /* If performeing something like a=hash++; a and hash become NULL */ + script_obj_reset (obj); } - - script_obj_unref (obj); - return new_obj; + script_obj_unref (obj); + return new_obj; } -static script_obj* script_evaluate_func (script_state* state, script_exp* exp) +static script_obj *script_evaluate_func (script_state *state, + script_exp *exp) { - script_obj* func = script_evaluate (state, exp->data.function.name); - script_obj* obj = NULL; - script_obj_deref (&func); - - if (func->type != SCRIPT_OBJ_TYPE_FUNCTION) + script_obj *func = script_evaluate (state, exp->data.function.name); + script_obj *obj = NULL; + + script_obj_deref (&func); + + if (func->type != SCRIPT_OBJ_TYPE_FUNCTION) return script_obj_new_null (); - - ply_list_t* parameter_expressions = exp->data.function.parameters; - ply_list_t* parameter_data = ply_list_new(); - - ply_list_node_t *node_expression = ply_list_get_first_node (parameter_expressions); - while (node_expression){ - script_exp* data_exp = ply_list_node_get_data (node_expression); - script_obj* data_obj = script_evaluate (state, data_exp); - ply_list_append_data (parameter_data, data_obj); - node_expression = ply_list_get_next_node (parameter_expressions, node_expression); + ply_list_t *parameter_expressions = exp->data.function.parameters; + ply_list_t *parameter_data = ply_list_new (); + + ply_list_node_t *node_expression = ply_list_get_first_node ( + parameter_expressions); + while (node_expression) + { + script_exp *data_exp = ply_list_node_get_data (node_expression); + script_obj *data_obj = script_evaluate (state, data_exp); + ply_list_append_data (parameter_data, data_obj); + node_expression = ply_list_get_next_node (parameter_expressions, + node_expression); } - - script_return reply = script_execute_function_with_parlist (state, func->data.function, parameter_data); - if (reply.type == SCRIPT_RETURN_TYPE_RETURN) + + script_return reply = script_execute_function_with_parlist ( + state, + func->data. + function, + parameter_data); + if (reply.type == SCRIPT_RETURN_TYPE_RETURN) obj = reply.object; - else - obj = script_obj_new_null(); - - ply_list_node_t *node_data = ply_list_get_first_node (parameter_data); - while (node_data){ - script_obj* data_obj = ply_list_node_get_data (node_data); - script_obj_unref (data_obj); - node_data = ply_list_get_next_node (parameter_data, node_data); + else + obj = script_obj_new_null (); + ply_list_node_t *node_data = ply_list_get_first_node (parameter_data); + while (node_data) + { + script_obj *data_obj = ply_list_node_get_data (node_data); + script_obj_unref (data_obj); + node_data = ply_list_get_next_node (parameter_data, node_data); } - ply_list_free(parameter_data); - - script_obj_unref (func); - - return obj; -} + ply_list_free (parameter_data); + script_obj_unref (func); -static script_obj* script_evaluate (script_state* state, script_exp* exp) + return obj; +} + +static script_obj *script_evaluate (script_state *state, + script_exp *exp) { - switch (exp->type){ - case SCRIPT_EXP_TYPE_PLUS: + switch (exp->type) + { + case SCRIPT_EXP_TYPE_PLUS: { - return script_evaluate_apply_function (state, exp, script_obj_plus); + return script_evaluate_apply_function (state, exp, script_obj_plus); } - case SCRIPT_EXP_TYPE_MINUS: + + case SCRIPT_EXP_TYPE_MINUS: { - return script_evaluate_apply_function (state, exp, script_obj_minus); + return script_evaluate_apply_function (state, exp, script_obj_minus); } - case SCRIPT_EXP_TYPE_MUL: + + case SCRIPT_EXP_TYPE_MUL: { - return script_evaluate_apply_function (state, exp, script_obj_mul); + return script_evaluate_apply_function (state, exp, script_obj_mul); } - case SCRIPT_EXP_TYPE_DIV: + + case SCRIPT_EXP_TYPE_DIV: { - return script_evaluate_apply_function (state, exp, script_obj_div); + return script_evaluate_apply_function (state, exp, script_obj_div); } - case SCRIPT_EXP_TYPE_MOD: + + case SCRIPT_EXP_TYPE_MOD: { - return script_evaluate_apply_function (state, exp, script_obj_mod); + return script_evaluate_apply_function (state, exp, script_obj_mod); } - case SCRIPT_EXP_TYPE_EQ: - case SCRIPT_EXP_TYPE_NE: - case SCRIPT_EXP_TYPE_GT: - case SCRIPT_EXP_TYPE_GE: - case SCRIPT_EXP_TYPE_LT: - case SCRIPT_EXP_TYPE_LE: + + case SCRIPT_EXP_TYPE_EQ: + case SCRIPT_EXP_TYPE_NE: + case SCRIPT_EXP_TYPE_GT: + case SCRIPT_EXP_TYPE_GE: + case SCRIPT_EXP_TYPE_LT: + case SCRIPT_EXP_TYPE_LE: { - return script_evaluate_cmp (state, exp); + return script_evaluate_cmp (state, exp); } - case SCRIPT_EXP_TYPE_AND: - case SCRIPT_EXP_TYPE_OR: + + case SCRIPT_EXP_TYPE_AND: + case SCRIPT_EXP_TYPE_OR: { - return script_evaluate_logic (state, exp); + return script_evaluate_logic (state, exp); } - case SCRIPT_EXP_TYPE_NOT: - case SCRIPT_EXP_TYPE_POS: - case SCRIPT_EXP_TYPE_NEG: - case SCRIPT_EXP_TYPE_PRE_INC: - case SCRIPT_EXP_TYPE_PRE_DEC: - case SCRIPT_EXP_TYPE_POST_INC: - case SCRIPT_EXP_TYPE_POST_DEC: + + case SCRIPT_EXP_TYPE_NOT: + case SCRIPT_EXP_TYPE_POS: + case SCRIPT_EXP_TYPE_NEG: + case SCRIPT_EXP_TYPE_PRE_INC: + case SCRIPT_EXP_TYPE_PRE_DEC: + case SCRIPT_EXP_TYPE_POST_INC: + case SCRIPT_EXP_TYPE_POST_DEC: { - return script_evaluate_unary (state, exp); + return script_evaluate_unary (state, exp); } - case SCRIPT_EXP_TYPE_TERM_INT: + + case SCRIPT_EXP_TYPE_TERM_INT: { - return script_obj_new_int (exp->data.integer); + return script_obj_new_int (exp->data.integer); } - case SCRIPT_EXP_TYPE_TERM_FLOAT: + + case SCRIPT_EXP_TYPE_TERM_FLOAT: { - return script_obj_new_float (exp->data.floatpoint); + return script_obj_new_float (exp->data.floatpoint); } - case SCRIPT_EXP_TYPE_TERM_STRING: + + case SCRIPT_EXP_TYPE_TERM_STRING: { - return script_obj_new_string (exp->data.string); + return script_obj_new_string (exp->data.string); } - case SCRIPT_EXP_TYPE_TERM_NULL: + + case SCRIPT_EXP_TYPE_TERM_NULL: { - return script_obj_new_null(); + return script_obj_new_null (); } - case SCRIPT_EXP_TYPE_TERM_LOCAL: + + case SCRIPT_EXP_TYPE_TERM_LOCAL: { - script_obj_ref(state->local); - return state->local; + script_obj_ref (state->local); + return state->local; } - case SCRIPT_EXP_TYPE_TERM_GLOBAL: + + case SCRIPT_EXP_TYPE_TERM_GLOBAL: { - script_obj_ref(state->global); - return state->global; + script_obj_ref (state->global); + return state->global; } - case SCRIPT_EXP_TYPE_TERM_VAR: + + case SCRIPT_EXP_TYPE_TERM_VAR: { - return script_evaluate_var (state, exp); + return script_evaluate_var (state, exp); } - case SCRIPT_EXP_TYPE_ASSIGN: + + case SCRIPT_EXP_TYPE_ASSIGN: { - return script_evaluate_assign (state, exp); + return script_evaluate_assign (state, exp); } - case SCRIPT_EXP_TYPE_ASSIGN_PLUS: + + case SCRIPT_EXP_TYPE_ASSIGN_PLUS: { - return script_evaluate_apply_function_and_assign (state, exp, script_obj_plus); + return script_evaluate_apply_function_and_assign (state, + exp, + script_obj_plus); } - case SCRIPT_EXP_TYPE_ASSIGN_MINUS: + + case SCRIPT_EXP_TYPE_ASSIGN_MINUS: { - return script_evaluate_apply_function_and_assign (state, exp, script_obj_minus); + return script_evaluate_apply_function_and_assign (state, + exp, + script_obj_minus); } - case SCRIPT_EXP_TYPE_ASSIGN_MUL: + + case SCRIPT_EXP_TYPE_ASSIGN_MUL: { - return script_evaluate_apply_function_and_assign (state, exp, script_obj_mul); + return script_evaluate_apply_function_and_assign (state, + exp, + script_obj_mul); } - case SCRIPT_EXP_TYPE_ASSIGN_DIV: + + case SCRIPT_EXP_TYPE_ASSIGN_DIV: { - return script_evaluate_apply_function_and_assign (state, exp, script_obj_div); + return script_evaluate_apply_function_and_assign (state, + exp, + script_obj_div); } - case SCRIPT_EXP_TYPE_ASSIGN_MOD: + + case SCRIPT_EXP_TYPE_ASSIGN_MOD: { - return script_evaluate_apply_function_and_assign (state, exp, script_obj_mod); + return script_evaluate_apply_function_and_assign (state, + exp, + script_obj_mod); } - case SCRIPT_EXP_TYPE_HASH: + + case SCRIPT_EXP_TYPE_HASH: { - return script_evaluate_hash (state, exp); + return script_evaluate_hash (state, exp); } - case SCRIPT_EXP_TYPE_FUNCTION: + + case SCRIPT_EXP_TYPE_FUNCTION: { - return script_evaluate_func (state, exp); + return script_evaluate_func (state, exp); } -// default: -// printf("unhandeled operation type %d\n", exp->type); -// assert(0); } - assert(0); + assert (0); } -static script_return script_execute_list (script_state* state, ply_list_t* op_list) // FIXME script_execute returns the return obj +static script_return script_execute_list (script_state *state, + ply_list_t *op_list) /* FIXME script_execute returns the return obj */ { - script_return reply = {SCRIPT_RETURN_TYPE_NORMAL, NULL}; - ply_list_node_t *node = ply_list_get_first_node (op_list); - for (node = ply_list_get_first_node (op_list); node; node = ply_list_get_next_node (op_list, node)){ - script_op* op = ply_list_node_get_data (node); - reply = script_execute(state, op); - switch (reply.type) { - case SCRIPT_RETURN_TYPE_NORMAL: + script_return reply = {SCRIPT_RETURN_TYPE_NORMAL, NULL}; + ply_list_node_t *node = ply_list_get_first_node (op_list); + + for (node = ply_list_get_first_node (op_list); + node; + node = ply_list_get_next_node (op_list, node)) + { + script_op *op = ply_list_node_get_data (node); + reply = script_execute (state, op); + switch (reply.type) + { + case SCRIPT_RETURN_TYPE_NORMAL: break; - case SCRIPT_RETURN_TYPE_RETURN: - case SCRIPT_RETURN_TYPE_BREAK: - case SCRIPT_RETURN_TYPE_CONTINUE: + + case SCRIPT_RETURN_TYPE_RETURN: + case SCRIPT_RETURN_TYPE_BREAK: + case SCRIPT_RETURN_TYPE_CONTINUE: return reply; } } - return reply; + return reply; } - // parameter_data list should be freed by caller -static script_return script_execute_function_with_parlist (script_state* state, script_function* function, ply_list_t* parameter_data) +/* parameter_data list should be freed by caller */ +static script_return script_execute_function_with_parlist (script_state *state, + script_function *function, + ply_list_t *parameter_data) { - script_state* sub_state = script_state_init_sub(state); - - ply_list_t* parameter_names = function->parameters; - - ply_list_node_t *node_name = ply_list_get_first_node (parameter_names); - ply_list_node_t *node_data = ply_list_get_first_node (parameter_data); - while (node_name && node_data){ - script_obj* data_obj = ply_list_node_get_data (node_data); - char* name = ply_list_node_get_data (node_name); - - script_obj_hash_add_element (sub_state->local, data_obj, name); - - node_name = ply_list_get_next_node (parameter_names, node_name); - node_data = ply_list_get_next_node (parameter_data, node_data); + script_state *sub_state = script_state_init_sub (state); + ply_list_t *parameter_names = function->parameters; + ply_list_node_t *node_name = ply_list_get_first_node (parameter_names); + ply_list_node_t *node_data = ply_list_get_first_node (parameter_data); + + while (node_name && node_data) + { + script_obj *data_obj = ply_list_node_get_data (node_data); + char *name = ply_list_node_get_data (node_name); + + script_obj_hash_add_element (sub_state->local, data_obj, name); + node_name = ply_list_get_next_node (parameter_names, node_name); + node_data = ply_list_get_next_node (parameter_data, node_data); } - - script_return reply; - switch (function->type){ - case SCRIPT_FUNCTION_TYPE_SCRIPT: + + script_return reply; + switch (function->type) + { + case SCRIPT_FUNCTION_TYPE_SCRIPT: { - script_op* op = function->data.script; - reply = script_execute (sub_state, op); - break; + script_op *op = function->data.script; + reply = script_execute (sub_state, op); + break; } - case SCRIPT_FUNCTION_TYPE_NATIVE: + + case SCRIPT_FUNCTION_TYPE_NATIVE: { - reply = function->data.native (sub_state, function->user_data); - break; + reply = function->data.native (sub_state, function->user_data); + break; } } - - script_state_destroy(sub_state); - return reply; -} + script_state_destroy (sub_state); + return reply; +} -script_return script_execute_function (script_state* state, script_function* function, script_obj* first_arg, ...) +script_return script_execute_function (script_state *state, + script_function *function, + script_obj *first_arg, + ...) { - script_return reply; - va_list args; - script_obj* arg; - ply_list_t *parameter_data = ply_list_new(); - - arg = first_arg; - va_start (args, first_arg); - while (arg){ - ply_list_append_data (parameter_data, arg); - arg = va_arg (args, script_obj*); + script_return reply; + va_list args; + script_obj *arg; + ply_list_t *parameter_data = ply_list_new (); + + arg = first_arg; + va_start (args, first_arg); + while (arg) + { + ply_list_append_data (parameter_data, arg); + arg = va_arg (args, script_obj *); } - va_end (args); - - reply = script_execute_function_with_parlist (state, function, parameter_data); - ply_list_free(parameter_data); - - return reply; -} + va_end (args); + + reply = script_execute_function_with_parlist (state, function, parameter_data); + ply_list_free (parameter_data); + return reply; +} -script_return script_execute (script_state* state, script_op* op) +script_return script_execute (script_state *state, + script_op *op) { - script_return reply = {SCRIPT_RETURN_TYPE_NORMAL, NULL}; - if (!op) return reply; - switch (op->type){ - case SCRIPT_OP_TYPE_EXPRESSION: + script_return reply = {SCRIPT_RETURN_TYPE_NORMAL, NULL}; + + if (!op) return reply; + switch (op->type) + { + case SCRIPT_OP_TYPE_EXPRESSION: { - script_obj* obj = script_evaluate (state, op->data.exp); - script_obj_unref(obj); // there is always a reply from all expressions (even assigns) which we chuck away - break; + script_obj *obj = script_evaluate (state, op->data.exp); + script_obj_unref (obj); /* there is always a reply from all expressions (even assigns) which we chuck away */ + break; } - case SCRIPT_OP_TYPE_OP_BLOCK: + + case SCRIPT_OP_TYPE_OP_BLOCK: { - reply = script_execute_list (state, op->data.list); - // FIXME blocks should normall reply a NULL , but if they replied something else then that was a return - break; + reply = script_execute_list (state, op->data.list); + /* FIXME blocks should normall reply a NULL , but if they replied something else then that was a return */ + break; } - case SCRIPT_OP_TYPE_IF: + + case SCRIPT_OP_TYPE_IF: { - script_obj* obj = script_evaluate (state, op->data.cond_op.cond); - if (script_obj_as_bool(obj)){ + script_obj *obj = script_evaluate (state, op->data.cond_op.cond); + if (script_obj_as_bool (obj)) reply = script_execute (state, op->data.cond_op.op1); - } - else { + else reply = script_execute (state, op->data.cond_op.op2); - } - script_obj_unref(obj); - break; + script_obj_unref (obj); + break; } - case SCRIPT_OP_TYPE_WHILE: - case SCRIPT_OP_TYPE_FOR: - { - script_obj* obj; - while (1){ - obj = script_evaluate (state, op->data.cond_op.cond); - if (script_obj_as_bool(obj)){ - reply = script_execute (state, op->data.cond_op.op1); - script_obj_unref(obj); - switch (reply.type) { - case SCRIPT_RETURN_TYPE_NORMAL: + + case SCRIPT_OP_TYPE_WHILE: + case SCRIPT_OP_TYPE_FOR: + { + script_obj *obj; + while (1) + { + obj = script_evaluate (state, op->data.cond_op.cond); + if (script_obj_as_bool (obj)) + { + reply = script_execute (state, op->data.cond_op.op1); + script_obj_unref (obj); + switch (reply.type) + { + case SCRIPT_RETURN_TYPE_NORMAL: break; - case SCRIPT_RETURN_TYPE_RETURN: + + case SCRIPT_RETURN_TYPE_RETURN: return reply; - case SCRIPT_RETURN_TYPE_BREAK: - return (script_return){SCRIPT_RETURN_TYPE_NORMAL, NULL}; - case SCRIPT_RETURN_TYPE_CONTINUE: + + case SCRIPT_RETURN_TYPE_BREAK: + return (script_return) {SCRIPT_RETURN_TYPE_NORMAL, NULL}; + + case SCRIPT_RETURN_TYPE_CONTINUE: break; } - script_execute (state, op->data.cond_op.op2); + script_execute (state, op->data.cond_op.op2); } - else { - script_obj_unref(obj); - break; + else + { + script_obj_unref (obj); + break; } } - break; + break; } - case SCRIPT_OP_TYPE_FUNCTION_DEF: + + case SCRIPT_OP_TYPE_FUNCTION_DEF: { - script_obj* obj = script_evaluate(state, op->data.function_def.name); - script_obj_reset (obj); - obj->type = SCRIPT_OBJ_TYPE_FUNCTION; - obj->data.function = op->data.function_def.function; - script_obj_unref(obj); - break; + script_obj *obj = script_evaluate (state, op->data.function_def.name); + script_obj_reset (obj); + obj->type = SCRIPT_OBJ_TYPE_FUNCTION; + obj->data.function = op->data.function_def.function; + script_obj_unref (obj); + break; } - case SCRIPT_OP_TYPE_RETURN: + + case SCRIPT_OP_TYPE_RETURN: { - script_obj* obj; - if (op->data.exp) obj = script_evaluate (state, op->data.exp); - else obj = script_obj_new_null(); - reply = (script_return){SCRIPT_RETURN_TYPE_RETURN, obj}; - break; + script_obj *obj; + if (op->data.exp) obj = script_evaluate (state, op->data.exp); + else obj = script_obj_new_null (); + reply = (script_return) {SCRIPT_RETURN_TYPE_RETURN, obj}; + break; } - case SCRIPT_OP_TYPE_BREAK: + + case SCRIPT_OP_TYPE_BREAK: { - reply = (script_return){SCRIPT_RETURN_TYPE_BREAK, NULL}; - break; + reply = (script_return) {SCRIPT_RETURN_TYPE_BREAK, NULL}; + break; } - case SCRIPT_OP_TYPE_CONTINUE: + + case SCRIPT_OP_TYPE_CONTINUE: { - reply = (script_return){SCRIPT_RETURN_TYPE_CONTINUE, NULL}; - break; + reply = (script_return) {SCRIPT_RETURN_TYPE_CONTINUE, NULL}; + break; } } - return reply; + return reply; } - - diff --git a/src/plugins/splash/script/script-execute.h b/src/plugins/splash/script/script-execute.h index 855bb524..393efd32 100644 --- a/src/plugins/splash/script/script-execute.h +++ b/src/plugins/splash/script/script-execute.h @@ -24,7 +24,11 @@ #include "script.h" -script_return script_execute (script_state* state, script_op* op); -script_return script_execute_function (script_state* state, script_function* function, script_obj* first_arg, ...); +script_return script_execute (script_state *state, + script_op *op); +script_return script_execute_function (script_state *state, + script_function *function, + script_obj *first_arg, + ...); #endif /* SCRIPT_EXECUTE_H */ diff --git a/src/plugins/splash/script/script-lib-image.c b/src/plugins/splash/script/script-lib-image.c index 8993117c..3e30d57e 100644 --- a/src/plugins/splash/script/script-lib-image.c +++ b/src/plugins/splash/script/script-lib-image.c @@ -27,7 +27,7 @@ #include "script-object.h" #include "script-parse.h" #include "script-execute.h" -#include "script-lib-image.h" +#include "script-lib-image.h" #include #include #include @@ -38,120 +38,180 @@ #define STRINGIFY_VAR script_lib_image_string #include "script-lib-image.string" - -static void image_free (script_obj* obj) +static void image_free (script_obj *obj) { - ply_image_t *image = obj->data.native.object_data; - ply_image_free (image); + ply_image_t *image = obj->data.native.object_data; + + ply_image_free (image); } -static script_return image_new (script_state* state, void* user_data) +static script_return image_new (script_state *state, + void *user_data) { - script_lib_image_data_t* data = user_data; - script_obj* reply; - char* path_filename; - char* filename = script_obj_hash_get_string (state->local, "filename"); - char* test_string = filename; - char* prefix_string = "special://"; - while (*test_string && *prefix_string && *test_string == *prefix_string){ - test_string++; - prefix_string++; + script_lib_image_data_t *data = user_data; + script_obj *reply; + char *path_filename; + char *filename = script_obj_hash_get_string (state->local, "filename"); + char *test_string = filename; + char *prefix_string = "special://"; + + while (*test_string && *prefix_string && *test_string == *prefix_string) + { + test_string++; + prefix_string++; } - if (!*prefix_string) { - if (strcmp(test_string, "logo") == 0) + if (!*prefix_string) + { + if (strcmp (test_string, "logo") == 0) path_filename = strdup (PLYMOUTH_LOGO_FILE); - else + else path_filename = strdup (""); } - else - asprintf(&path_filename, "%s/%s", data->image_dir, filename); - - - ply_image_t *image = ply_image_new (path_filename); - if (ply_image_load (image)){ + else + asprintf (&path_filename, "%s/%s", data->image_dir, filename); + ply_image_t *image = ply_image_new (path_filename); + if (ply_image_load (image)) reply = script_obj_new_native (image, data->class); + else + { + ply_image_free (image); + reply = script_obj_new_null (); } - else { - ply_image_free (image); - reply = script_obj_new_null (); - } - free(filename); - free(path_filename); - return (script_return){SCRIPT_RETURN_TYPE_RETURN, reply}; + free (filename); + free (path_filename); + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, reply}; } -static script_return image_get_width (script_state* state, void* user_data) +static script_return image_get_width (script_state *state, + void *user_data) { - script_lib_image_data_t* data = user_data; - ply_image_t *image = script_obj_hash_get_native_of_class (state->local, "image", data->class); - if (image) - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_int (ply_image_get_width (image))}; - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + script_lib_image_data_t *data = user_data; + ply_image_t *image = script_obj_hash_get_native_of_class (state->local, + "image", + data->class); + + if (image) + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_int (ply_image_get_width (image))}; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -static script_return image_get_height (script_state* state, void* user_data) +static script_return image_get_height (script_state *state, + void *user_data) { - script_lib_image_data_t* data = user_data; - ply_image_t *image = script_obj_hash_get_native_of_class (state->local, "image", data->class); - if (image) - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_int (ply_image_get_height (image))}; - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + script_lib_image_data_t *data = user_data; + ply_image_t *image = script_obj_hash_get_native_of_class (state->local, + "image", + data->class); + + if (image) + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_int (ply_image_get_height (image))}; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -static script_return image_rotate (script_state* state, void* user_data) +static script_return image_rotate (script_state *state, + void *user_data) { - script_lib_image_data_t* data = user_data; - ply_image_t *image = script_obj_hash_get_native_of_class (state->local, "image", data->class); - float angle = script_obj_hash_get_float (state->local, "angle"); - if (image){ - ply_image_t *new_image = ply_image_rotate (image, - ply_image_get_width (image) / 2, - ply_image_get_height (image) / 2, - angle); - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_native (new_image, data->class)}; + script_lib_image_data_t *data = user_data; + ply_image_t *image = script_obj_hash_get_native_of_class (state->local, + "image", + data->class); + float angle = script_obj_hash_get_float (state->local, "angle"); + + if (image) + { + ply_image_t *new_image = ply_image_rotate (image, + ply_image_get_width ( + image) / 2, + ply_image_get_height ( + image) / 2, + angle); + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_native (new_image, + data->class)}; } - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -static script_return image_scale (script_state* state, void* user_data) +static script_return image_scale (script_state *state, + void *user_data) { - script_lib_image_data_t* data = user_data; - ply_image_t *image = script_obj_hash_get_native_of_class (state->local, "image", data->class); - int width = script_obj_hash_get_int (state->local, "width"); - int height = script_obj_hash_get_int (state->local, "height"); - if (image){ - ply_image_t *new_image = ply_image_resize (image, width, height); - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_native (new_image, data->class)}; + script_lib_image_data_t *data = user_data; + ply_image_t *image = script_obj_hash_get_native_of_class (state->local, + "image", + data->class); + int width = script_obj_hash_get_int (state->local, "width"); + int height = script_obj_hash_get_int (state->local, "height"); + + if (image) + { + ply_image_t *new_image = ply_image_resize (image, width, height); + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_native (new_image, + data->class)}; } - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -script_lib_image_data_t* script_lib_image_setup(script_state *state, char* image_dir) +script_lib_image_data_t *script_lib_image_setup (script_state *state, + char *image_dir) { - script_lib_image_data_t* data = malloc(sizeof(script_lib_image_data_t)); - data->class = script_obj_native_class_new(image_free, "image", data); - data->image_dir = strdup(image_dir); - - script_add_native_function (state->global, "ImageNew", image_new, data, "filename", NULL); - script_add_native_function (state->global, "ImageRotate", image_rotate, data, "image", "angle", NULL); - script_add_native_function (state->global, "ImageScale", image_scale, data, "image", "width", "height", NULL); - script_add_native_function (state->global, "ImageGetWidth", image_get_width, data, "image", NULL); - script_add_native_function (state->global, "ImageGetHeight", image_get_height, data, "image", NULL); - - data->script_main_op = script_parse_string (script_lib_image_string); - script_return ret = script_execute(state, data->script_main_op); - script_obj_unref(ret.object); - - return data; -} + script_lib_image_data_t *data = malloc (sizeof (script_lib_image_data_t)); + + data->class = script_obj_native_class_new (image_free, "image", data); + data->image_dir = strdup (image_dir); + script_add_native_function (state->global, + "ImageNew", + image_new, + data, + "filename", + NULL); + script_add_native_function (state->global, + "ImageRotate", + image_rotate, + data, + "image", + "angle", + NULL); + script_add_native_function (state->global, + "ImageScale", + image_scale, + data, + "image", + "width", + "height", + NULL); + script_add_native_function (state->global, + "ImageGetWidth", + image_get_width, + data, + "image", + NULL); + script_add_native_function (state->global, + "ImageGetHeight", + image_get_height, + data, + "image", + NULL); + + data->script_main_op = script_parse_string (script_lib_image_string); + script_return ret = script_execute (state, data->script_main_op); + script_obj_unref (ret.object); + + return data; +} -void script_lib_image_destroy(script_lib_image_data_t* data) +void script_lib_image_destroy (script_lib_image_data_t *data) { - script_obj_native_class_destroy(data->class); - free(data->image_dir); - script_parse_op_free (data->script_main_op); - free(data); + script_obj_native_class_destroy (data->class); + free (data->image_dir); + script_parse_op_free (data->script_main_op); + free (data); } - diff --git a/src/plugins/splash/script/script-lib-image.h b/src/plugins/splash/script/script-lib-image.h index fc8cf319..3d8e6182 100644 --- a/src/plugins/splash/script/script-lib-image.h +++ b/src/plugins/splash/script/script-lib-image.h @@ -26,13 +26,13 @@ typedef struct { - script_obj_native_class* class; + script_obj_native_class *class; script_op *script_main_op; - char* image_dir; + char *image_dir; } script_lib_image_data_t; - -script_lib_image_data_t* script_lib_image_setup(script_state *state, char* image_dir); -void script_lib_image_destroy(script_lib_image_data_t* data); +script_lib_image_data_t *script_lib_image_setup (script_state *state, + char *image_dir); +void script_lib_image_destroy (script_lib_image_data_t *data); #endif /* SCRIPT_LIB_IMAGE */ diff --git a/src/plugins/splash/script/script-lib-math.c b/src/plugins/splash/script/script-lib-math.c index d749d451..36ab76ca 100644 --- a/src/plugins/splash/script/script-lib-math.c +++ b/src/plugins/splash/script/script-lib-math.c @@ -25,7 +25,7 @@ #include "script-parse.h" #include "script-execute.h" #include "script-object.h" -#include "script-lib-math.h" +#include "script-lib-math.h" #include #include #include @@ -38,47 +38,78 @@ #include "script-lib-math.string" - -static script_return script_lib_math_float_from_float_function (script_state* state, void* user_data) +static script_return script_lib_math_float_from_float_function (script_state *state, + void *user_data) { - float (*function) (float) = user_data; - float value = script_obj_hash_get_float (state->local, "value"); - float reply_float = function(value); - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_float (reply_float)}; + float (*function)(float) = user_data; + float value = script_obj_hash_get_float (state->local, "value"); + float reply_float = function (value); + return (script_return) { + SCRIPT_RETURN_TYPE_RETURN, script_obj_new_float (reply_float) + }; } -static script_return script_lib_math_int_from_float_function (script_state* state, void* user_data) +static script_return script_lib_math_int_from_float_function (script_state *state, + void *user_data) { - int (*function) (float) = user_data; - float value = script_obj_hash_get_float (state->local, "value"); - int reply_int = function(value); - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_int (reply_int)}; + int (*function)(float) = user_data; + float value = script_obj_hash_get_float (state->local, "value"); + int reply_int = function (value); + return (script_return) { + SCRIPT_RETURN_TYPE_RETURN, script_obj_new_int (reply_int) + }; } static int float_to_int (float value) { - return (int) value; + return (int) value; } -script_lib_math_data_t* script_lib_math_setup(script_state *state) +script_lib_math_data_t *script_lib_math_setup (script_state *state) { - script_lib_math_data_t* data = malloc(sizeof(script_lib_math_data_t)); - - script_add_native_function (state->global, "MathCos", script_lib_math_float_from_float_function, cosf, "value", NULL); - script_add_native_function (state->global, "MathSin", script_lib_math_float_from_float_function, sinf, "value", NULL); - script_add_native_function (state->global, "MathTan", script_lib_math_float_from_float_function, tanf, "value", NULL); - script_add_native_function (state->global, "MathSqrt",script_lib_math_float_from_float_function, sqrtf, "value", NULL); - script_add_native_function (state->global, "MathInt", script_lib_math_int_from_float_function, float_to_int, "value", NULL); - - data->script_main_op = script_parse_string (script_lib_math_string); - script_return ret = script_execute(state, data->script_main_op); - script_obj_unref(ret.object); + script_lib_math_data_t *data = malloc (sizeof (script_lib_math_data_t)); + + script_add_native_function (state->global, + "MathCos", + script_lib_math_float_from_float_function, + cosf, + "value", + NULL); + script_add_native_function (state->global, + "MathSin", + script_lib_math_float_from_float_function, + sinf, + "value", + NULL); + script_add_native_function (state->global, + "MathTan", + script_lib_math_float_from_float_function, + tanf, + "value", + NULL); + script_add_native_function (state->global, + "MathSqrt", + script_lib_math_float_from_float_function, + sqrtf, + "value", + NULL); + script_add_native_function (state->global, + "MathInt", + script_lib_math_int_from_float_function, + float_to_int, + "value", + NULL); - return data; + data->script_main_op = script_parse_string (script_lib_math_string); + script_return ret = script_execute (state, data->script_main_op); + script_obj_unref (ret.object); + + return data; } -void script_lib_math_destroy(script_lib_math_data_t* data) +void script_lib_math_destroy (script_lib_math_data_t *data) { - script_parse_op_free (data->script_main_op); - free(data); + script_parse_op_free (data->script_main_op); + free (data); } + diff --git a/src/plugins/splash/script/script-lib-math.h b/src/plugins/splash/script/script-lib-math.h index 0b460cea..34223997 100644 --- a/src/plugins/splash/script/script-lib-math.h +++ b/src/plugins/splash/script/script-lib-math.h @@ -29,8 +29,7 @@ typedef struct script_op *script_main_op; } script_lib_math_data_t; - -script_lib_math_data_t* script_lib_math_setup(script_state *state); -void script_lib_math_destroy(script_lib_math_data_t* data); +script_lib_math_data_t *script_lib_math_setup (script_state *state); +void script_lib_math_destroy (script_lib_math_data_t *data); #endif /* SCRIPT_LIB_MATH */ diff --git a/src/plugins/splash/script/script-lib-plymouth.c b/src/plugins/splash/script/script-lib-plymouth.c index 83ca5087..af1aa5ad 100644 --- a/src/plugins/splash/script/script-lib-plymouth.c +++ b/src/plugins/splash/script/script-lib-plymouth.c @@ -25,7 +25,7 @@ #include "script-parse.h" #include "script-execute.h" #include "script-object.h" -#include "script-lib-plymouth.h" +#include "script-lib-plymouth.h" #include #include #include @@ -37,157 +37,257 @@ #include "script-lib-plymouth.string" - -static script_return plymouth_set_function (script_state* state, void* user_data) +static script_return plymouth_set_function (script_state *state, + void *user_data) { - script_obj** script_func = user_data; - script_obj* obj = script_obj_hash_get_element (state->local, "function"); - script_obj_deref(&obj); - script_obj_unref(*script_func); - - if (obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ + script_obj **script_func = user_data; + script_obj *obj = script_obj_hash_get_element (state->local, "function"); + + script_obj_deref (&obj); + script_obj_unref (*script_func); + + if (obj->type == SCRIPT_OBJ_TYPE_FUNCTION) *script_func = obj; + else + { + *script_func = NULL; + script_obj_unref (obj); } - else { - *script_func = NULL; - script_obj_unref(obj); - } - - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + return (script_return) { + SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null () + }; } - -script_lib_plymouth_data_t* script_lib_plymouth_setup(script_state *state) +script_lib_plymouth_data_t *script_lib_plymouth_setup (script_state *state) { - script_lib_plymouth_data_t* data = malloc(sizeof(script_lib_plymouth_data_t)); - - data->script_refresh_func = NULL; - data->script_boot_progress_func = NULL; - data->script_root_mounted_func = NULL; - data->script_keyboard_input_func = NULL; - data->script_update_status_func = NULL; - data->script_display_normal_func = NULL; - data->script_display_password_func = NULL; - data->script_display_question_func = NULL; - - script_add_native_function (state->global, "PlymouthSetRefreshFunction", plymouth_set_function, &data->script_refresh_func, "function", NULL); - script_add_native_function (state->global, "PlymouthSetBootProgressFunction", plymouth_set_function, &data->script_boot_progress_func, "function", NULL); - script_add_native_function (state->global, "PlymouthSetRootMountedFunction", plymouth_set_function, &data->script_root_mounted_func, "function", NULL); - script_add_native_function (state->global, "PlymouthSetKeyboardInputFunction", plymouth_set_function, &data->script_keyboard_input_func, "function", NULL); - script_add_native_function (state->global, "PlymouthSetUpdateStatusFunction", plymouth_set_function, &data->script_update_status_func, "function", NULL); - script_add_native_function (state->global, "PlymouthSetDisplayNormalFunction", plymouth_set_function, &data->script_display_normal_func, "function", NULL); - script_add_native_function (state->global, "PlymouthSetDisplayPasswordFunction", plymouth_set_function, &data->script_display_password_func, "function", NULL); - script_add_native_function (state->global, "PlymouthSetDisplayQuestionFunction", plymouth_set_function, &data->script_display_question_func, "function", NULL); - data->script_main_op = script_parse_string (script_lib_plymouth_string); - script_return ret = script_execute(state, data->script_main_op); - script_obj_unref(ret.object); // Throw anything sent back away - - return data; -} + script_lib_plymouth_data_t *data = malloc (sizeof (script_lib_plymouth_data_t)); + + data->script_refresh_func = NULL; + data->script_boot_progress_func = NULL; + data->script_root_mounted_func = NULL; + data->script_keyboard_input_func = NULL; + data->script_update_status_func = NULL; + data->script_display_normal_func = NULL; + data->script_display_password_func = NULL; + data->script_display_question_func = NULL; + script_add_native_function (state->global, + "PlymouthSetRefreshFunction", + plymouth_set_function, + &data->script_refresh_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetBootProgressFunction", + plymouth_set_function, + &data->script_boot_progress_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetRootMountedFunction", + plymouth_set_function, + &data->script_root_mounted_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetKeyboardInputFunction", + plymouth_set_function, + &data->script_keyboard_input_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetUpdateStatusFunction", + plymouth_set_function, + &data->script_update_status_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetDisplayNormalFunction", + plymouth_set_function, + &data->script_display_normal_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetDisplayPasswordFunction", + plymouth_set_function, + &data->script_display_password_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetDisplayQuestionFunction", + plymouth_set_function, + &data->script_display_question_func, + "function", + NULL); + data->script_main_op = script_parse_string (script_lib_plymouth_string); + script_return ret = script_execute (state, data->script_main_op); + script_obj_unref (ret.object); /* Throw anything sent back away */ -void script_lib_plymouth_destroy(script_lib_plymouth_data_t* data) + return data; +} + +void script_lib_plymouth_destroy (script_lib_plymouth_data_t *data) { - script_parse_op_free (data->script_main_op); - script_obj_unref(data->script_refresh_func); - script_obj_unref(data->script_boot_progress_func); - script_obj_unref(data->script_root_mounted_func); - script_obj_unref(data->script_keyboard_input_func); - script_obj_unref(data->script_update_status_func); - script_obj_unref(data->script_display_normal_func); - script_obj_unref(data->script_display_password_func); - script_obj_unref(data->script_display_question_func); - free(data); + script_parse_op_free (data->script_main_op); + script_obj_unref (data->script_refresh_func); + script_obj_unref (data->script_boot_progress_func); + script_obj_unref (data->script_root_mounted_func); + script_obj_unref (data->script_keyboard_input_func); + script_obj_unref (data->script_update_status_func); + script_obj_unref (data->script_display_normal_func); + script_obj_unref (data->script_display_password_func); + script_obj_unref (data->script_display_question_func); + free (data); } -void script_lib_plymouth_on_refresh(script_state* state, script_lib_plymouth_data_t* data) +void script_lib_plymouth_on_refresh (script_state *state, + script_lib_plymouth_data_t *data) { - script_obj* refresh_func_obj = data->script_refresh_func; - if (refresh_func_obj && refresh_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ - script_return ret = script_execute_function (state, refresh_func_obj->data.function, NULL); - script_obj_unref(ret.object); + script_obj *refresh_func_obj = data->script_refresh_func; + + if (refresh_func_obj + && (refresh_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_return ret = script_execute_function (state, + refresh_func_obj->data.function, + NULL); + script_obj_unref (ret.object); } } -void script_lib_plymouth_on_boot_progress(script_state* state, script_lib_plymouth_data_t* data, float duration, float progress) +void script_lib_plymouth_on_boot_progress (script_state *state, + script_lib_plymouth_data_t *data, + float duration, + float progress) { - script_obj* boot_progress_func_obj = data->script_boot_progress_func; - if (boot_progress_func_obj && boot_progress_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ - script_obj* duration_obj = script_obj_new_float (duration); - script_obj* progress_obj = script_obj_new_float (progress); - script_return ret = script_execute_function (state, boot_progress_func_obj->data.function, duration_obj, progress_obj, NULL); - script_obj_unref(ret.object); - script_obj_unref(duration_obj); - script_obj_unref(progress_obj); + script_obj *boot_progress_func_obj = data->script_boot_progress_func; + + if (boot_progress_func_obj + && (boot_progress_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *duration_obj = script_obj_new_float (duration); + script_obj *progress_obj = script_obj_new_float (progress); + script_return ret = script_execute_function (state, + boot_progress_func_obj->data.function, + duration_obj, + progress_obj, + NULL); + script_obj_unref (ret.object); + script_obj_unref (duration_obj); + script_obj_unref (progress_obj); } } -void script_lib_plymouth_on_root_mounted(script_state* state, script_lib_plymouth_data_t* data) +void script_lib_plymouth_on_root_mounted (script_state *state, + script_lib_plymouth_data_t *data) { - script_obj* root_mounted_func_obj = data->script_root_mounted_func; - if (root_mounted_func_obj && root_mounted_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ - script_return ret = script_execute_function (state, root_mounted_func_obj->data.function, NULL); - script_obj_unref(ret.object); + script_obj *root_mounted_func_obj = data->script_root_mounted_func; + + if (root_mounted_func_obj + && (root_mounted_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_return ret = script_execute_function (state, + root_mounted_func_obj->data.function, + NULL); + script_obj_unref (ret.object); } } -void script_lib_plymouth_on_keyboard_input(script_state* state, script_lib_plymouth_data_t* data, const char* keyboard_input) +void script_lib_plymouth_on_keyboard_input (script_state *state, + script_lib_plymouth_data_t *data, + const char *keyboard_input) { - script_obj* keyboard_input_func_obj = data->script_keyboard_input_func; - if (keyboard_input_func_obj && keyboard_input_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ - script_obj* keyboard_input_obj = script_obj_new_string (keyboard_input); - script_return ret = script_execute_function (state, keyboard_input_func_obj->data.function, keyboard_input_obj, NULL); - script_obj_unref(keyboard_input_obj); - script_obj_unref(ret.object); + script_obj *keyboard_input_func_obj = data->script_keyboard_input_func; + + if (keyboard_input_func_obj + && (keyboard_input_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *keyboard_input_obj = script_obj_new_string (keyboard_input); + script_return ret = script_execute_function (state, + keyboard_input_func_obj->data.function, + keyboard_input_obj, + NULL); + script_obj_unref (keyboard_input_obj); + script_obj_unref (ret.object); } } - -void script_lib_plymouth_on_update_status(script_state* state, script_lib_plymouth_data_t* data, const char* new_status) +void script_lib_plymouth_on_update_status (script_state *state, + script_lib_plymouth_data_t *data, + const char *new_status) { - script_obj* update_status_func_obj = data->script_update_status_func; - if (update_status_func_obj && update_status_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ - script_obj* new_status_obj = script_obj_new_string (new_status); - script_return ret = script_execute_function (state, update_status_func_obj->data.function, new_status_obj, NULL); - script_obj_unref(new_status_obj); - script_obj_unref(ret.object); + script_obj *update_status_func_obj = data->script_update_status_func; + + if (update_status_func_obj + && (update_status_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *new_status_obj = script_obj_new_string (new_status); + script_return ret = script_execute_function (state, + update_status_func_obj->data.function, + new_status_obj, + NULL); + script_obj_unref (new_status_obj); + script_obj_unref (ret.object); } } - -void script_lib_plymouth_on_display_normal(script_state* state, script_lib_plymouth_data_t* data) +void script_lib_plymouth_on_display_normal (script_state *state, + script_lib_plymouth_data_t *data) { - script_obj* display_normal_func_obj = data->script_display_normal_func; - if (display_normal_func_obj && display_normal_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ - script_return ret = script_execute_function (state, display_normal_func_obj->data.function, NULL); - script_obj_unref(ret.object); + script_obj *display_normal_func_obj = data->script_display_normal_func; + + if (display_normal_func_obj + && (display_normal_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_return ret = script_execute_function (state, + display_normal_func_obj->data.function, + NULL); + script_obj_unref (ret.object); } } - -void script_lib_plymouth_on_display_password(script_state* state, script_lib_plymouth_data_t* data, const char *prompt, int bullets) +void script_lib_plymouth_on_display_password (script_state *state, + script_lib_plymouth_data_t *data, + const char *prompt, + int bullets) { - script_obj* display_password_func_obj = data->script_display_password_func; - if (display_password_func_obj && display_password_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ - script_obj* prompt_obj = script_obj_new_string (prompt); - script_obj* bullets_obj = script_obj_new_int (bullets); - script_return ret = script_execute_function (state, display_password_func_obj->data.function, prompt_obj, bullets_obj, NULL); - script_obj_unref(prompt_obj); - script_obj_unref(bullets_obj); - script_obj_unref(ret.object); + script_obj *display_password_func_obj = data->script_display_password_func; + + if (display_password_func_obj + && (display_password_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *prompt_obj = script_obj_new_string (prompt); + script_obj *bullets_obj = script_obj_new_int (bullets); + script_return ret = script_execute_function (state, + display_password_func_obj->data.function, + prompt_obj, + bullets_obj, + NULL); + script_obj_unref (prompt_obj); + script_obj_unref (bullets_obj); + script_obj_unref (ret.object); } } -void script_lib_plymouth_on_display_question(script_state* state, script_lib_plymouth_data_t* data, const char *prompt, const char *entry_text) +void script_lib_plymouth_on_display_question (script_state *state, + script_lib_plymouth_data_t *data, + const char *prompt, + const char *entry_text) { - script_obj* display_question_func_obj = data->script_display_question_func; - if (display_question_func_obj && display_question_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION){ - script_obj* prompt_obj = script_obj_new_string (prompt); - script_obj* entry_text_obj = script_obj_new_string (entry_text); - script_return ret = script_execute_function (state, display_question_func_obj->data.function, prompt_obj, entry_text_obj, NULL); - script_obj_unref(prompt_obj); - script_obj_unref(entry_text_obj); - script_obj_unref(ret.object); + script_obj *display_question_func_obj = data->script_display_question_func; + + if (display_question_func_obj + && (display_question_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *prompt_obj = script_obj_new_string (prompt); + script_obj *entry_text_obj = script_obj_new_string (entry_text); + script_return ret = script_execute_function (state, + display_question_func_obj->data.function, + prompt_obj, + entry_text_obj, + NULL); + script_obj_unref (prompt_obj); + script_obj_unref (entry_text_obj); + script_obj_unref (ret.object); } } - diff --git a/src/plugins/splash/script/script-lib-plymouth.h b/src/plugins/splash/script/script-lib-plymouth.h index 6badac66..19c0e9cf 100644 --- a/src/plugins/splash/script/script-lib-plymouth.h +++ b/src/plugins/splash/script/script-lib-plymouth.h @@ -35,20 +35,34 @@ typedef struct script_obj *script_display_normal_func; script_obj *script_display_password_func; script_obj *script_display_question_func; - } script_lib_plymouth_data_t; +script_lib_plymouth_data_t *script_lib_plymouth_setup (script_state *state); +void script_lib_plymouth_destroy (script_lib_plymouth_data_t *data); -script_lib_plymouth_data_t* script_lib_plymouth_setup(script_state *state); -void script_lib_plymouth_destroy(script_lib_plymouth_data_t* data); - -void script_lib_plymouth_on_refresh(script_state* state, script_lib_plymouth_data_t* data); -void script_lib_plymouth_on_boot_progress(script_state* state, script_lib_plymouth_data_t* data, float duration, float progress); -void script_lib_plymouth_on_root_mounted(script_state* state, script_lib_plymouth_data_t* data); -void script_lib_plymouth_on_keyboard_input(script_state* state, script_lib_plymouth_data_t* data, const char* keyboard_input); -void script_lib_plymouth_on_update_status(script_state* state, script_lib_plymouth_data_t* data, const char* new_status); -void script_lib_plymouth_on_display_normal(script_state* state, script_lib_plymouth_data_t* data); -void script_lib_plymouth_on_display_password(script_state* state, script_lib_plymouth_data_t* data, const char *prompt, int bullets); -void script_lib_plymouth_on_display_question(script_state* state, script_lib_plymouth_data_t* data, const char *prompt, const char *entry_text); +void script_lib_plymouth_on_refresh (script_state *state, + script_lib_plymouth_data_t *data); +void script_lib_plymouth_on_boot_progress (script_state *state, + script_lib_plymouth_data_t *data, + float duration, + float progress); +void script_lib_plymouth_on_root_mounted (script_state *state, + script_lib_plymouth_data_t *data); +void script_lib_plymouth_on_keyboard_input (script_state *state, + script_lib_plymouth_data_t *data, + const char *keyboard_input); +void script_lib_plymouth_on_update_status (script_state *state, + script_lib_plymouth_data_t *data, + const char *new_status); +void script_lib_plymouth_on_display_normal (script_state *state, + script_lib_plymouth_data_t *data); +void script_lib_plymouth_on_display_password (script_state *state, + script_lib_plymouth_data_t *data, + const char *prompt, + int bullets); +void script_lib_plymouth_on_display_question (script_state *state, + script_lib_plymouth_data_t *data, + const char *prompt, + const char *entry_text); #endif /* SCRIPT_LIB_PLYMOUTH */ diff --git a/src/plugins/splash/script/script-lib-sprite.c b/src/plugins/splash/script/script-lib-sprite.c index 770f6bfd..f0953635 100644 --- a/src/plugins/splash/script/script-lib-sprite.c +++ b/src/plugins/splash/script/script-lib-sprite.c @@ -35,305 +35,414 @@ #include #include - #define STRINGIFY_VAR script_lib_sprite_string #include "script-lib-sprite.string" +static void draw_area (script_lib_sprite_data_t *data, + int x, + int y, + int width, + int height); - -static void draw_area (script_lib_sprite_data_t* data, int x, int y, int width, int height); - - -static void sprite_free (script_obj* obj) +static void sprite_free (script_obj *obj) { - sprite_t *sprite = obj->data.native.object_data; - sprite->remove_me = true; + sprite_t *sprite = obj->data.native.object_data; + sprite->remove_me = true; } -static script_return sprite_new (script_state* state, void* user_data) +static script_return sprite_new (script_state *state, + void *user_data) { - script_lib_sprite_data_t* data = user_data; - script_obj* reply; - - sprite_t *sprite = calloc(1, sizeof(sprite_t)); - sprite->x = 0; - sprite->y = 0; - sprite->z = 0; - sprite->opacity = 1.0; - sprite->old_x = 0; - sprite->old_y = 0; - sprite->old_z = 0; - sprite->old_opacity = 1.0; - sprite->refresh_me = false; - sprite->remove_me = false; - sprite->image = NULL; - sprite->image_obj = NULL; - ply_list_append_data (data->sprite_list, sprite); - - reply = script_obj_new_native (sprite, data->class); - return (script_return){SCRIPT_RETURN_TYPE_RETURN, reply}; + script_lib_sprite_data_t *data = user_data; + script_obj *reply; + + sprite_t *sprite = calloc (1, sizeof (sprite_t)); + + sprite->x = 0; + sprite->y = 0; + sprite->z = 0; + sprite->opacity = 1.0; + sprite->old_x = 0; + sprite->old_y = 0; + sprite->old_z = 0; + sprite->old_opacity = 1.0; + sprite->refresh_me = false; + sprite->remove_me = false; + sprite->image = NULL; + sprite->image_obj = NULL; + ply_list_append_data (data->sprite_list, sprite); + + reply = script_obj_new_native (sprite, data->class); + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, reply}; } - -static script_return sprite_set_image (script_state* state, void* user_data) +static script_return sprite_set_image (script_state *state, + void *user_data) { - script_lib_sprite_data_t* data = user_data; - sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, "sprite", data->class); - script_obj* script_obj_image = script_obj_hash_get_element (state->local, "image"); - script_obj_deref(&script_obj_image); - ply_image_t *image = script_obj_as_native_of_class_name (script_obj_image, "image"); - - - if (image && sprite){ - script_obj_unref(sprite->image_obj); - script_obj_ref(script_obj_image); - sprite->image = image; - sprite->image_obj = script_obj_image; - sprite->refresh_me = true; + script_lib_sprite_data_t *data = user_data; + sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, + "sprite", + data->class); + script_obj *script_obj_image = script_obj_hash_get_element (state->local, + "image"); + + script_obj_deref (&script_obj_image); + ply_image_t *image = script_obj_as_native_of_class_name (script_obj_image, + "image"); + + if (image && sprite) + { + script_obj_unref (sprite->image_obj); + script_obj_ref (script_obj_image); + sprite->image = image; + sprite->image_obj = script_obj_image; + sprite->refresh_me = true; } - script_obj_unref(script_obj_image); - - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + script_obj_unref (script_obj_image); + + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -static script_return sprite_set_x (script_state* state, void* user_data) +static script_return sprite_set_x (script_state *state, + void *user_data) { - script_lib_sprite_data_t* data = user_data; - sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, "sprite", data->class); - - if (sprite) + script_lib_sprite_data_t *data = user_data; + sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, + "sprite", + data->class); + + if (sprite) sprite->x = script_obj_hash_get_int (state->local, "value"); - - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -static script_return sprite_set_y (script_state* state, void* user_data) +static script_return sprite_set_y (script_state *state, + void *user_data) { - script_lib_sprite_data_t* data = user_data; - sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, "sprite", data->class); - - if (sprite) + script_lib_sprite_data_t *data = user_data; + sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, + "sprite", + data->class); + + if (sprite) sprite->y = script_obj_hash_get_int (state->local, "value"); - - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -static script_return sprite_set_z (script_state* state, void* user_data) +static script_return sprite_set_z (script_state *state, + void *user_data) { - script_lib_sprite_data_t* data = user_data; - sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, "sprite", data->class); - - if (sprite) + script_lib_sprite_data_t *data = user_data; + sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, + "sprite", + data->class); + + if (sprite) sprite->z = script_obj_hash_get_int (state->local, "value"); - - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -static script_return sprite_set_opacity (script_state* state, void* user_data) +static script_return sprite_set_opacity (script_state *state, + void *user_data) { - script_lib_sprite_data_t* data = user_data; - sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, "sprite", data->class); - - if (sprite) + script_lib_sprite_data_t *data = user_data; + sprite_t *sprite = script_obj_hash_get_native_of_class (state->local, + "sprite", + data->class); + + if (sprite) sprite->opacity = script_obj_hash_get_float (state->local, "value"); - - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; } -static script_return sprite_window_get_width (script_state* state, void* user_data) +static script_return sprite_window_get_width (script_state *state, + void *user_data) { - script_lib_sprite_data_t* data = user_data; - ply_frame_buffer_t *frame_buffer = ply_window_get_frame_buffer (data->window); - ply_frame_buffer_area_t area; - ply_frame_buffer_get_size (frame_buffer, &area); - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_int (area.width)}; -} + script_lib_sprite_data_t *data = user_data; + ply_frame_buffer_t *frame_buffer = ply_window_get_frame_buffer (data->window); + ply_frame_buffer_area_t area; -static script_return sprite_window_get_height (script_state* state, void* user_data) -{ - script_lib_sprite_data_t* data = user_data; - ply_frame_buffer_t *frame_buffer = ply_window_get_frame_buffer (data->window); - ply_frame_buffer_area_t area; - ply_frame_buffer_get_size (frame_buffer, &area); - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_int (area.height)}; + ply_frame_buffer_get_size (frame_buffer, &area); + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_int (area.width)}; } -static uint32_t extract_rgb_color (script_state* state) +static script_return sprite_window_get_height (script_state *state, + void *user_data) { - uint8_t red = CLAMP(255 * script_obj_hash_get_float (state->local, "red"), 0, 255); - uint8_t green = CLAMP(255 * script_obj_hash_get_float (state->local, "green"), 0, 255); - uint8_t blue = CLAMP(255 * script_obj_hash_get_float (state->local, "blue"), 0, 255); - return (uint32_t) red<<16 | green<<8 | blue; + script_lib_sprite_data_t *data = user_data; + ply_frame_buffer_t *frame_buffer = ply_window_get_frame_buffer (data->window); + ply_frame_buffer_area_t area; + + ply_frame_buffer_get_size (frame_buffer, &area); + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_int (area.height)}; } -static script_return sprite_window_set_background_top_color (script_state* state, void* user_data) + +static uint32_t extract_rgb_color (script_state *state) { - script_lib_sprite_data_t* data = user_data; - data->background_color_start = extract_rgb_color (state); - data->full_refresh = true; - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; + uint8_t red = CLAMP (255 * script_obj_hash_get_float (state->local, "red"), 0, 255); + uint8_t green = CLAMP (255 * script_obj_hash_get_float (state->local, "green"), 0, 255); + uint8_t blue = CLAMP (255 * script_obj_hash_get_float (state->local, "blue"), 0, 255); + + return (uint32_t) red << 16 | green << 8 | blue; } -static script_return sprite_window_set_background_bottom_color (script_state* state, void* user_data) +static script_return sprite_window_set_background_top_color (script_state *state, + void *user_data) { - script_lib_sprite_data_t* data = user_data; - data->background_color_end = extract_rgb_color (state); - data->full_refresh = true; - return (script_return){SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null ()}; -} + script_lib_sprite_data_t *data = user_data; + data->background_color_start = extract_rgb_color (state); + data->full_refresh = true; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; +} +static script_return sprite_window_set_background_bottom_color (script_state *state, + void *user_data) +{ + script_lib_sprite_data_t *data = user_data; + data->background_color_end = extract_rgb_color (state); + data->full_refresh = true; + return (script_return) {SCRIPT_RETURN_TYPE_RETURN, + script_obj_new_null ()}; +} static void -draw_area (script_lib_sprite_data_t* data, +draw_area (script_lib_sprite_data_t *data, int x, int y, int width, int height) { ply_frame_buffer_area_t clip_area; + clip_area.x = x; clip_area.y = y; clip_area.width = width; clip_area.height = height; ply_frame_buffer_t *frame_buffer = ply_window_get_frame_buffer (data->window); - - ply_frame_buffer_pause_updates (frame_buffer); + ply_frame_buffer_pause_updates (frame_buffer); - if (data->background_color_start == data->background_color_end) - ply_frame_buffer_fill_with_hex_color (frame_buffer, &clip_area, data->background_color_start); + if (data->background_color_start == data->background_color_end) + ply_frame_buffer_fill_with_hex_color (frame_buffer, + &clip_area, + data->background_color_start); else - ply_frame_buffer_fill_with_gradient (frame_buffer, &clip_area, data->background_color_start, data->background_color_end); + ply_frame_buffer_fill_with_gradient (frame_buffer, + &clip_area, + data->background_color_start, + data->background_color_end); ply_list_node_t *node; - for (node = ply_list_get_first_node (data->sprite_list); node; node = ply_list_get_next_node (data->sprite_list, node)) + for (node = ply_list_get_first_node (data->sprite_list); + node; + node = ply_list_get_next_node (data->sprite_list, node)) { - sprite_t* sprite = ply_list_node_get_data (node); + sprite_t *sprite = ply_list_node_get_data (node); ply_frame_buffer_area_t sprite_area; if (!sprite->image) continue; - if (sprite->remove_me) continue; - if (sprite->opacity<0.011) continue; - + if (sprite->opacity < 0.011) continue; sprite_area.x = sprite->x; sprite_area.y = sprite->y; - if (sprite_area.x>=(x+width)) continue; - if (sprite_area.y>=(y+height)) continue; - + if (sprite_area.x >= (x + width)) continue; + if (sprite_area.y >= (y + height)) continue; sprite_area.width = ply_image_get_width (sprite->image); sprite_area.height = ply_image_get_height (sprite->image); - if ((sprite_area.x+(int)sprite_area.width) <= x) continue; - if ((sprite_area.y+(int)sprite_area.height) <= y) continue; - + if ((sprite_area.x + (int) sprite_area.width) <= x) continue; + if ((sprite_area.y + (int) sprite_area.height) <= y) continue; ply_frame_buffer_fill_with_argb32_data_at_opacity_with_clip (frame_buffer, - &sprite_area, &clip_area, 0, 0, - ply_image_get_data (sprite->image), sprite->opacity); + &sprite_area, + &clip_area, + 0, 0, + ply_image_get_data (sprite->image), + sprite->opacity); } ply_frame_buffer_unpause_updates (frame_buffer); } - -script_lib_sprite_data_t* script_lib_sprite_setup(script_state *state, ply_window_t *window) +script_lib_sprite_data_t *script_lib_sprite_setup (script_state *state, + ply_window_t *window) { - script_lib_sprite_data_t* data = malloc(sizeof(script_lib_sprite_data_t)); - data->class = script_obj_native_class_new(sprite_free, "sprite", data); - data->sprite_list = ply_list_new(); - data->window = window; - - script_add_native_function (state->global, "SpriteNew", sprite_new, data, NULL); - script_add_native_function (state->global, "SpriteSetImage", sprite_set_image, data, "sprite", "image", NULL); - script_add_native_function (state->global, "SpriteSetX", sprite_set_x, data, "sprite", "value", NULL); - script_add_native_function (state->global, "SpriteSetY", sprite_set_y, data, "sprite", "value", NULL); - script_add_native_function (state->global, "SpriteSetZ", sprite_set_z, data, "sprite", "value", NULL); - script_add_native_function (state->global, "SpriteSetOpacity", sprite_set_opacity, data, "sprite", "value", NULL); - script_add_native_function (state->global, "SpriteWindowGetWidth", sprite_window_get_width, data, NULL); - script_add_native_function (state->global, "SpriteWindowGetHeight", sprite_window_get_height, data, NULL); - script_add_native_function (state->global, "SpriteWindowSetBackgroundTopColor", sprite_window_set_background_top_color, data, "red", "green", "blue", NULL); - script_add_native_function (state->global, "SpriteWindowSetBackgroundBottomColor", sprite_window_set_background_bottom_color, data, "red", "green", "blue", NULL); - - data->script_main_op = script_parse_string (script_lib_sprite_string); - data->background_color_start = 0x000000; - data->background_color_end = 0x000000; - data->full_refresh = true; - script_return ret = script_execute(state, data->script_main_op); - script_obj_unref(ret.object); - return data; + script_lib_sprite_data_t *data = malloc (sizeof (script_lib_sprite_data_t)); + + data->class = script_obj_native_class_new (sprite_free, "sprite", data); + data->sprite_list = ply_list_new (); + data->window = window; + + script_add_native_function (state->global, + "SpriteNew", + sprite_new, + data, + NULL); + script_add_native_function (state->global, + "SpriteSetImage", + sprite_set_image, + data, + "sprite", + "image", + NULL); + script_add_native_function (state->global, + "SpriteSetX", + sprite_set_x, + data, + "sprite", + "value", + NULL); + script_add_native_function (state->global, + "SpriteSetY", + sprite_set_y, + data, + "sprite", + "value", + NULL); + script_add_native_function (state->global, + "SpriteSetZ", + sprite_set_z, + data, + "sprite", + "value", + NULL); + script_add_native_function (state->global, + "SpriteSetOpacity", + sprite_set_opacity, + data, + "sprite", + "value", + NULL); + script_add_native_function (state->global, + "SpriteWindowGetWidth", + sprite_window_get_width, + data, + NULL); + script_add_native_function (state->global, + "SpriteWindowGetHeight", + sprite_window_get_height, + data, + NULL); + script_add_native_function (state->global, + "SpriteWindowSetBackgroundTopColor", + sprite_window_set_background_top_color, + data, + "red", + "green", + "blue", + NULL); + script_add_native_function (state->global, + "SpriteWindowSetBackgroundBottomColor", + sprite_window_set_background_bottom_color, + data, + "red", + "green", + "blue", + NULL); + + data->script_main_op = script_parse_string (script_lib_sprite_string); + data->background_color_start = 0x000000; + data->background_color_end = 0x000000; + data->full_refresh = true; + script_return ret = script_execute (state, data->script_main_op); + script_obj_unref (ret.object); + return data; } - -void script_lib_sprite_refresh(script_lib_sprite_data_t* data) +void script_lib_sprite_refresh (script_lib_sprite_data_t *data) { - ply_list_node_t *node; - - node = ply_list_get_first_node (data->sprite_list); - - if (data->full_refresh){ - ply_frame_buffer_area_t screen_area; - ply_frame_buffer_t *frame_buffer = ply_window_get_frame_buffer (data->window); - ply_frame_buffer_get_size (frame_buffer, &screen_area); - draw_area (data, screen_area.x, screen_area.y, screen_area.width, screen_area.height); - data->full_refresh = false; - } + ply_list_node_t *node; - while (node){ - sprite_t* sprite = ply_list_node_get_data (node); - ply_list_node_t *next_node = ply_list_get_next_node (data->sprite_list, node); - if (sprite->remove_me) { - if (sprite->image) { - draw_area (data, sprite->old_x, sprite->old_y, sprite->old_width, sprite->old_height); - } - ply_list_remove_node (data->sprite_list, node); - script_obj_unref(sprite->image_obj); - free(sprite); + node = ply_list_get_first_node (data->sprite_list); + + if (data->full_refresh) + { + ply_frame_buffer_area_t screen_area; + ply_frame_buffer_t *frame_buffer = ply_window_get_frame_buffer (data->window); + ply_frame_buffer_get_size (frame_buffer, &screen_area); + draw_area (data, + screen_area.x, + screen_area.y, + screen_area.width, + screen_area.height); + data->full_refresh = false; + } + while (node) + { + sprite_t *sprite = ply_list_node_get_data (node); + ply_list_node_t *next_node = ply_list_get_next_node (data->sprite_list, + node); + if (sprite->remove_me) + { + if (sprite->image) + draw_area (data, + sprite->old_x, + sprite->old_y, + sprite->old_width, + sprite->old_height); + ply_list_remove_node (data->sprite_list, node); + script_obj_unref (sprite->image_obj); + free (sprite); } - node = next_node; + node = next_node; } - - for(node = ply_list_get_first_node (data->sprite_list); node; node = ply_list_get_next_node (data->sprite_list, node)){ - sprite_t* sprite = ply_list_node_get_data (node); - if (!sprite->image) continue; - if ( sprite->x != sprite->old_x || - sprite->y != sprite->old_y || - sprite->z != sprite->old_z || - fabs(sprite->old_opacity - sprite->opacity) > 0.01 || // People can't see the difference between - sprite->refresh_me ){ - int width = ply_image_get_width (sprite->image); - int height= ply_image_get_height (sprite->image); - draw_area (data, sprite->x, sprite->y, width, height); - draw_area (data, sprite->old_x, sprite->old_y, sprite->old_width, sprite->old_height); - sprite->old_x = sprite->x; - sprite->old_y = sprite->y; - sprite->old_z = sprite->z; - sprite->old_width = width; - sprite->old_height = height; - sprite->old_opacity = sprite->opacity; - sprite->refresh_me = false; + + for (node = ply_list_get_first_node (data->sprite_list); + node; + node = ply_list_get_next_node (data->sprite_list, node)) + { + sprite_t *sprite = ply_list_node_get_data (node); + if (!sprite->image) continue; + if ((sprite->x != sprite->old_x) + || (sprite->y != sprite->old_y) + || (sprite->z != sprite->old_z) + || (fabs (sprite->old_opacity - sprite->opacity) > 0.01) /* People can't see the difference between */ + || sprite->refresh_me) + { + int width = ply_image_get_width (sprite->image); + int height = ply_image_get_height (sprite->image); + draw_area (data, sprite->x, sprite->y, width, height); + draw_area (data, + sprite->old_x, + sprite->old_y, + sprite->old_width, + sprite->old_height); + sprite->old_x = sprite->x; + sprite->old_y = sprite->y; + sprite->old_z = sprite->z; + sprite->old_width = width; + sprite->old_height = height; + sprite->old_opacity = sprite->opacity; + sprite->refresh_me = false; } } } - - - -void script_lib_sprite_destroy(script_lib_sprite_data_t* data) +void script_lib_sprite_destroy (script_lib_sprite_data_t *data) { - ply_list_node_t *node = ply_list_get_first_node (data->sprite_list); - while (node){ - sprite_t* sprite = ply_list_node_get_data (node); - ply_list_node_t *next_node = ply_list_get_next_node (data->sprite_list, node); - ply_list_remove_node (data->sprite_list, node); - script_obj_unref(sprite->image_obj); - free(sprite); - node = next_node; - } - - ply_list_free(data->sprite_list); - script_parse_op_free (data->script_main_op); - script_obj_native_class_destroy(data->class); - free(data); -} + ply_list_node_t *node = ply_list_get_first_node (data->sprite_list); + while (node) + { + sprite_t *sprite = ply_list_node_get_data (node); + ply_list_node_t *next_node = ply_list_get_next_node (data->sprite_list, + node); + ply_list_remove_node (data->sprite_list, node); + script_obj_unref (sprite->image_obj); + free (sprite); + node = next_node; + } + ply_list_free (data->sprite_list); + script_parse_op_free (data->script_main_op); + script_obj_native_class_destroy (data->class); + free (data); +} diff --git a/src/plugins/splash/script/script-lib-sprite.h b/src/plugins/splash/script/script-lib-sprite.h index c9c5af1d..9c399ec8 100644 --- a/src/plugins/splash/script/script-lib-sprite.h +++ b/src/plugins/splash/script/script-lib-sprite.h @@ -26,37 +26,36 @@ typedef struct { - ply_window_t *window; - ply_list_t *sprite_list; - script_obj_native_class* class; - script_op *script_main_op; - uint32_t background_color_start; - uint32_t background_color_end; - bool full_refresh; + ply_window_t *window; + ply_list_t *sprite_list; + script_obj_native_class *class; + script_op *script_main_op; + uint32_t background_color_start; + uint32_t background_color_end; + bool full_refresh; } script_lib_sprite_data_t; - typedef struct { - int x; - int y; - int z; - float opacity; - int old_x; - int old_y; - int old_z; - int old_width; - int old_height; - float old_opacity; - bool refresh_me; - bool remove_me; + int x; + int y; + int z; + float opacity; + int old_x; + int old_y; + int old_z; + int old_width; + int old_height; + float old_opacity; + bool refresh_me; + bool remove_me; ply_image_t *image; - script_obj *image_obj; + script_obj *image_obj; } sprite_t; - -script_lib_sprite_data_t* script_lib_sprite_setup(script_state *state, ply_window_t *window); -void script_lib_sprite_refresh(script_lib_sprite_data_t* data); -void script_lib_sprite_destroy(script_lib_sprite_data_t* data); +script_lib_sprite_data_t *script_lib_sprite_setup (script_state *state, + ply_window_t *window); +void script_lib_sprite_refresh (script_lib_sprite_data_t *data); +void script_lib_sprite_destroy (script_lib_sprite_data_t *data); #endif /* SCRIPT_LIB_SPRITE */ diff --git a/src/plugins/splash/script/script-object.c b/src/plugins/splash/script/script-object.c index 1a4d0816..b3cad679 100644 --- a/src/plugins/splash/script/script-object.c +++ b/src/plugins/splash/script/script-object.c @@ -35,646 +35,727 @@ #include "script.h" #include "script-object.h" - -char* script_obj_print (script_obj* obj); -void script_obj_reset (script_obj* obj); +char *script_obj_print (script_obj *obj); +void script_obj_reset (script_obj *obj); - -void script_obj_free (script_obj* obj) +void script_obj_free (script_obj *obj) { - assert(!obj->refcount); - script_obj_reset (obj); - free(obj); + assert (!obj->refcount); + script_obj_reset (obj); + free (obj); } - -void script_obj_ref (script_obj* obj) +void script_obj_ref (script_obj *obj) { - obj->refcount++; + obj->refcount++; } -void script_obj_unref (script_obj* obj) +void script_obj_unref (script_obj *obj) { - if (!obj) return; - assert(obj->refcount>0); - obj->refcount--; - if (obj->refcount<=0){ + if (!obj) return; + assert (obj->refcount > 0); + obj->refcount--; + if (obj->refcount <= 0) script_obj_free (obj); - } } static void foreach_free_vareable (void *key, void *data, void *user_data) { - script_vareable* vareable = data; - script_obj_unref(vareable->object); - free(vareable->name); - free(vareable); -} - + script_vareable *vareable = data; + script_obj_unref (vareable->object); + free (vareable->name); + free (vareable); +} -void script_obj_reset (script_obj* obj) +void script_obj_reset (script_obj *obj) { - switch (obj->type){ - case SCRIPT_OBJ_TYPE_REF: + switch (obj->type) + { + case SCRIPT_OBJ_TYPE_REF: script_obj_unref (obj->data.obj); break; - case SCRIPT_OBJ_TYPE_INT: + + case SCRIPT_OBJ_TYPE_INT: break; - case SCRIPT_OBJ_TYPE_FLOAT: + + case SCRIPT_OBJ_TYPE_FLOAT: break; - case SCRIPT_OBJ_TYPE_STRING: - free(obj->data.string); + + case SCRIPT_OBJ_TYPE_STRING: + free (obj->data.string); break; - case SCRIPT_OBJ_TYPE_HASH: // FIXME nightmare + + case SCRIPT_OBJ_TYPE_HASH: /* FIXME nightmare */ ply_hashtable_foreach (obj->data.hash, foreach_free_vareable, NULL); - ply_hashtable_free(obj->data.hash); + ply_hashtable_free (obj->data.hash); break; - case SCRIPT_OBJ_TYPE_FUNCTION: + + case SCRIPT_OBJ_TYPE_FUNCTION: { - if (obj->data.function->freeable){ - ply_list_node_t *node; - for (node = ply_list_get_first_node (obj->data.function->parameters); - node; - node = ply_list_get_next_node (obj->data.function->parameters, node)){ - char* operand = ply_list_node_get_data (node); - free(operand); + if (obj->data.function->freeable) + { + ply_list_node_t *node; + for (node = + ply_list_get_first_node (obj->data.function->parameters); + node; + node = + ply_list_get_next_node (obj->data.function->parameters, + node)) + { + char *operand = ply_list_node_get_data (node); + free (operand); } - ply_list_free(obj->data.function->parameters); - free(obj->data.function); + ply_list_free (obj->data.function->parameters); + free (obj->data.function); } } break; - case SCRIPT_OBJ_TYPE_NATIVE: + + case SCRIPT_OBJ_TYPE_NATIVE: if (obj->data.native.class->free_func) - obj->data.native.class->free_func(obj); - + obj->data.native.class->free_func (obj); break; - case SCRIPT_OBJ_TYPE_NULL: + + case SCRIPT_OBJ_TYPE_NULL: break; } - obj->type = SCRIPT_OBJ_TYPE_NULL; + obj->type = SCRIPT_OBJ_TYPE_NULL; } -script_obj* script_obj_deref_direct (script_obj* obj) +script_obj *script_obj_deref_direct (script_obj *obj) { - while (obj->type == SCRIPT_OBJ_TYPE_REF){ + while (obj->type == SCRIPT_OBJ_TYPE_REF) obj = obj->data.obj; - } - return obj; + return obj; } -void script_obj_deref (script_obj** obj_ptr) +void script_obj_deref (script_obj **obj_ptr) { - script_obj* obj = *obj_ptr; - obj = script_obj_deref_direct(obj); - script_obj_ref (obj); - script_obj_unref (*obj_ptr); - *obj_ptr = obj; -} + script_obj *obj = *obj_ptr; + obj = script_obj_deref_direct (obj); + script_obj_ref (obj); + script_obj_unref (*obj_ptr); + *obj_ptr = obj; +} static void foreach_print_vareable (void *key, void *data, void *user_data) { - script_vareable* vareable = data; - char* string = script_obj_print (vareable->object); - char* reply; - char* prev = *(char**)user_data; - if (!prev) prev = strdup(""); - asprintf(&reply, "%s%s = %s\n", prev, vareable->name, string); - free(string); - free(prev); - *(char**)user_data = reply; -} + script_vareable *vareable = data; + char *string = script_obj_print (vareable->object); + char *reply; + char *prev = *(char **) user_data; + if (!prev) prev = strdup (""); + asprintf (&reply, "%s%s = %s\n", prev, vareable->name, string); + free (string); + free (prev); + *(char **) user_data = reply; +} -char* script_obj_print (script_obj* obj) +char *script_obj_print (script_obj *obj) { - char* reply; - switch (obj->type){ - case SCRIPT_OBJ_TYPE_REF: + char *reply; + + switch (obj->type) + { + case SCRIPT_OBJ_TYPE_REF: { - char* subobj = script_obj_print (obj->data.obj); - asprintf(&reply, "->[%d]%s", obj->refcount, subobj); - free(subobj); - return reply; + char *subobj = script_obj_print (obj->data.obj); + asprintf (&reply, "->[%d]%s", obj->refcount, subobj); + free (subobj); + return reply; } - - case SCRIPT_OBJ_TYPE_INT: + + case SCRIPT_OBJ_TYPE_INT: { - asprintf(&reply, "%d[%d]", obj->data.integer, obj->refcount); - return reply; + asprintf (&reply, "%d[%d]", obj->data.integer, obj->refcount); + return reply; } - case SCRIPT_OBJ_TYPE_FLOAT: + + case SCRIPT_OBJ_TYPE_FLOAT: { - asprintf(&reply, "%f[%d]", obj->data.floatpoint, obj->refcount); - return reply; + asprintf (&reply, "%f[%d]", obj->data.floatpoint, obj->refcount); + return reply; } - case SCRIPT_OBJ_TYPE_STRING: + + case SCRIPT_OBJ_TYPE_STRING: { - asprintf(&reply, "\"%s\"[%d]", obj->data.string, obj->refcount); - return reply; + asprintf (&reply, "\"%s\"[%d]", obj->data.string, obj->refcount); + return reply; } - case SCRIPT_OBJ_TYPE_NULL: + + case SCRIPT_OBJ_TYPE_NULL: { - asprintf(&reply, "NULL[%d]", obj->refcount); - return reply; + asprintf (&reply, "NULL[%d]", obj->refcount); + return reply; } - case SCRIPT_OBJ_TYPE_HASH: + + case SCRIPT_OBJ_TYPE_HASH: { - char* sub = NULL; - ply_hashtable_foreach (obj->data.hash, foreach_print_vareable, &sub); - asprintf(&reply, "HASH{\n%s}[%d]", sub, obj->refcount); - free(sub); - return reply; + char *sub = NULL; + ply_hashtable_foreach (obj->data.hash, foreach_print_vareable, &sub); + asprintf (&reply, "HASH{\n%s}[%d]", sub, obj->refcount); + free (sub); + return reply; } - case SCRIPT_OBJ_TYPE_FUNCTION: + + case SCRIPT_OBJ_TYPE_FUNCTION: { - asprintf(&reply, "function()[%d]", obj->refcount); - return reply; + asprintf (&reply, "function()[%d]", obj->refcount); + return reply; } - case SCRIPT_OBJ_TYPE_NATIVE: + + case SCRIPT_OBJ_TYPE_NATIVE: { - asprintf(&reply, "(%s)[%d]", obj->data.native.class->name, obj->refcount); - return reply; + asprintf (&reply, + "(%s)[%d]", + obj->data.native.class->name, + obj->refcount); + return reply; } - - default: - printf("unhandeled object type %d\n", obj->type); - assert(0); + + default: + printf ("unhandeled object type %d\n", obj->type); + assert (0); } - return NULL; + return NULL; } - -script_obj* script_obj_new_null (void) +script_obj *script_obj_new_null (void) { - script_obj* obj = malloc(sizeof(script_obj)); - obj->type = SCRIPT_OBJ_TYPE_NULL; - obj->refcount = 1; - return obj; + script_obj *obj = malloc (sizeof (script_obj)); + + obj->type = SCRIPT_OBJ_TYPE_NULL; + obj->refcount = 1; + return obj; } -script_obj* script_obj_new_int (int number) +script_obj *script_obj_new_int (int number) { - script_obj* obj = malloc(sizeof(script_obj)); - obj->type = SCRIPT_OBJ_TYPE_INT; - obj->refcount = 1; - obj->data.integer = number; - return obj; + script_obj *obj = malloc (sizeof (script_obj)); + + obj->type = SCRIPT_OBJ_TYPE_INT; + obj->refcount = 1; + obj->data.integer = number; + return obj; } -script_obj* script_obj_new_float (float number) +script_obj *script_obj_new_float (float number) { - if (isnan(number)) return script_obj_new_null (); - script_obj* obj = malloc(sizeof(script_obj)); - obj->type = SCRIPT_OBJ_TYPE_FLOAT; - obj->refcount = 1; - obj->data.floatpoint = number; - return obj; + if (isnan (number)) return script_obj_new_null (); + script_obj *obj = malloc (sizeof (script_obj)); + obj->type = SCRIPT_OBJ_TYPE_FLOAT; + obj->refcount = 1; + obj->data.floatpoint = number; + return obj; } -script_obj* script_obj_new_string (const char* string) +script_obj *script_obj_new_string (const char *string) { - if (!string) return script_obj_new_null (); - script_obj* obj = malloc(sizeof(script_obj)); - obj->type = SCRIPT_OBJ_TYPE_STRING; - obj->refcount = 1; - obj->data.string = strdup(string); - return obj; + if (!string) return script_obj_new_null (); + script_obj *obj = malloc (sizeof (script_obj)); + obj->type = SCRIPT_OBJ_TYPE_STRING; + obj->refcount = 1; + obj->data.string = strdup (string); + return obj; } -script_obj* script_obj_new_hash (void) +script_obj *script_obj_new_hash (void) { - script_obj* obj = malloc(sizeof(script_obj)); - obj->type = SCRIPT_OBJ_TYPE_HASH; - obj->data.hash = ply_hashtable_new (ply_hashtable_string_hash, ply_hashtable_string_compare); - obj->refcount = 1; - return obj; + script_obj *obj = malloc (sizeof (script_obj)); + + obj->type = SCRIPT_OBJ_TYPE_HASH; + obj->data.hash = ply_hashtable_new (ply_hashtable_string_hash, + ply_hashtable_string_compare); + obj->refcount = 1; + return obj; } -script_obj* script_obj_new_function (script_function* function) +script_obj *script_obj_new_function (script_function *function) { - script_obj* obj = malloc(sizeof(script_obj)); - obj->type = SCRIPT_OBJ_TYPE_FUNCTION; - obj->data.function = function; - obj->refcount = 1; - return obj; + script_obj *obj = malloc (sizeof (script_obj)); + + obj->type = SCRIPT_OBJ_TYPE_FUNCTION; + obj->data.function = function; + obj->refcount = 1; + return obj; } -script_obj* script_obj_new_ref (script_obj* sub_obj) +script_obj *script_obj_new_ref (script_obj *sub_obj) { - script_obj* obj = malloc(sizeof(script_obj)); - obj->type = SCRIPT_OBJ_TYPE_REF; - obj->data.obj = sub_obj; - obj->refcount = 1; - return obj; -} + script_obj *obj = malloc (sizeof (script_obj)); + obj->type = SCRIPT_OBJ_TYPE_REF; + obj->data.obj = sub_obj; + obj->refcount = 1; + return obj; +} -script_obj* script_obj_new_native (void* object_data, script_obj_native_class* class) +script_obj *script_obj_new_native (void *object_data, + script_obj_native_class *class) { - if (!object_data) return script_obj_new_null (); - script_obj* obj = malloc(sizeof(script_obj)); - obj->type = SCRIPT_OBJ_TYPE_NATIVE; - obj->data.native.class = class; - obj->data.native.object_data = object_data; - obj->refcount = 1; - return obj; + if (!object_data) return script_obj_new_null (); + script_obj *obj = malloc (sizeof (script_obj)); + obj->type = SCRIPT_OBJ_TYPE_NATIVE; + obj->data.native.class = class; + obj->data.native.object_data = object_data; + obj->refcount = 1; + return obj; } -int script_obj_as_int (script_obj* obj) -{ // If in then reply contents, otherwise reply 0 - obj = script_obj_deref_direct(obj); - switch (obj->type){ - case SCRIPT_OBJ_TYPE_INT: +int script_obj_as_int (script_obj *obj) +{ /* If in then reply contents, otherwise reply 0 */ + obj = script_obj_deref_direct (obj); + switch (obj->type) + { + case SCRIPT_OBJ_TYPE_INT: return obj->data.integer; - case SCRIPT_OBJ_TYPE_FLOAT: + + case SCRIPT_OBJ_TYPE_FLOAT: return (int) obj->data.floatpoint; - case SCRIPT_OBJ_TYPE_NULL: + + case SCRIPT_OBJ_TYPE_NULL: return 0; - case SCRIPT_OBJ_TYPE_REF: // should have been de-reffed already - assert(0); - case SCRIPT_OBJ_TYPE_HASH: - case SCRIPT_OBJ_TYPE_FUNCTION: - case SCRIPT_OBJ_TYPE_NATIVE: + + case SCRIPT_OBJ_TYPE_REF: /* should have been de-reffed already */ + assert (0); + + case SCRIPT_OBJ_TYPE_HASH: + case SCRIPT_OBJ_TYPE_FUNCTION: + case SCRIPT_OBJ_TYPE_NATIVE: return 0; - case SCRIPT_OBJ_TYPE_STRING: + + case SCRIPT_OBJ_TYPE_STRING: return 0; } - - assert(0); // Abort on uncaught - return false; + + assert (0); /* Abort on uncaught */ + return 0; } -float script_obj_as_float (script_obj* obj) -{ // If in then reply contents, otherwise reply 0 - obj = script_obj_deref_direct(obj); - switch (obj->type){ - case SCRIPT_OBJ_TYPE_INT: +float script_obj_as_float (script_obj *obj) +{ /* If in then reply contents, otherwise reply 0 */ + obj = script_obj_deref_direct (obj); + switch (obj->type) + { + case SCRIPT_OBJ_TYPE_INT: return (float) obj->data.integer; - case SCRIPT_OBJ_TYPE_FLOAT: + + case SCRIPT_OBJ_TYPE_FLOAT: return obj->data.floatpoint; - case SCRIPT_OBJ_TYPE_NULL: + + case SCRIPT_OBJ_TYPE_NULL: return NAN; - case SCRIPT_OBJ_TYPE_REF: // should have been de-reffed already - assert(0); - case SCRIPT_OBJ_TYPE_HASH: - case SCRIPT_OBJ_TYPE_FUNCTION: - case SCRIPT_OBJ_TYPE_NATIVE: + + case SCRIPT_OBJ_TYPE_REF: /* should have been de-reffed already */ + assert (0); + + case SCRIPT_OBJ_TYPE_HASH: + case SCRIPT_OBJ_TYPE_FUNCTION: + case SCRIPT_OBJ_TYPE_NATIVE: return NAN; - case SCRIPT_OBJ_TYPE_STRING: + + case SCRIPT_OBJ_TYPE_STRING: return NAN; } - - assert(0); // Abort on uncaught - return false; + + assert (0); /* Abort on uncaught */ + return NAN; } -bool script_obj_as_bool (script_obj* obj) -{ // False objects are NULL, 0, "" - obj = script_obj_deref_direct(obj); - switch (obj->type){ - case SCRIPT_OBJ_TYPE_INT: +bool script_obj_as_bool (script_obj *obj) +{ /* False objects are NULL, 0, "" */ + obj = script_obj_deref_direct (obj); + switch (obj->type) + { + case SCRIPT_OBJ_TYPE_INT: if (obj->data.integer) return true; return false; - case SCRIPT_OBJ_TYPE_FLOAT: + + case SCRIPT_OBJ_TYPE_FLOAT: if (obj->data.floatpoint) return true; return false; - case SCRIPT_OBJ_TYPE_NULL: + + case SCRIPT_OBJ_TYPE_NULL: return false; - case SCRIPT_OBJ_TYPE_REF: // should have been de-reffed already - assert(0); - case SCRIPT_OBJ_TYPE_HASH: - case SCRIPT_OBJ_TYPE_FUNCTION: - case SCRIPT_OBJ_TYPE_NATIVE: + + case SCRIPT_OBJ_TYPE_REF: /* should have been de-reffed already */ + assert (0); + + case SCRIPT_OBJ_TYPE_HASH: + case SCRIPT_OBJ_TYPE_FUNCTION: + case SCRIPT_OBJ_TYPE_NATIVE: return true; - case SCRIPT_OBJ_TYPE_STRING: + + case SCRIPT_OBJ_TYPE_STRING: if (*obj->data.string) return true; return false; } - - assert(0); // Abort on uncaught - return false; + + assert (0); /* Abort on uncaught */ + return false; } -char* script_obj_as_string (script_obj* obj) // reply is strdupped and may be NULL +char *script_obj_as_string (script_obj *obj) /* reply is strdupped and may be NULL */ { - obj = script_obj_deref_direct(obj); - char* reply; - - switch (obj->type){ - case SCRIPT_OBJ_TYPE_INT: - asprintf(&reply, "%d", obj->data.integer); + obj = script_obj_deref_direct (obj); + char *reply; + + switch (obj->type) + { + case SCRIPT_OBJ_TYPE_INT: + asprintf (&reply, "%d", obj->data.integer); return reply; - case SCRIPT_OBJ_TYPE_FLOAT: - asprintf(&reply, "%f", obj->data.floatpoint); + + case SCRIPT_OBJ_TYPE_FLOAT: + asprintf (&reply, "%f", obj->data.floatpoint); return reply; - case SCRIPT_OBJ_TYPE_NULL: + + case SCRIPT_OBJ_TYPE_NULL: return NULL; - case SCRIPT_OBJ_TYPE_REF: // should have been de-reffed already - assert(0); - case SCRIPT_OBJ_TYPE_HASH: + + case SCRIPT_OBJ_TYPE_REF: /* should have been de-reffed already */ + assert (0); + + case SCRIPT_OBJ_TYPE_HASH: return NULL; - case SCRIPT_OBJ_TYPE_FUNCTION: + + case SCRIPT_OBJ_TYPE_FUNCTION: return NULL; - case SCRIPT_OBJ_TYPE_STRING: - return strdup(obj->data.string); - case SCRIPT_OBJ_TYPE_NATIVE: + + case SCRIPT_OBJ_TYPE_STRING: + return strdup (obj->data.string); + + case SCRIPT_OBJ_TYPE_NATIVE: return NULL; } - - assert(0); // Abort on uncaught - return false; + + assert (0); /* Abort on uncaught */ + return false; } -void* script_obj_as_native_of_class (script_obj* obj, script_obj_native_class* class) +void *script_obj_as_native_of_class (script_obj *obj, + script_obj_native_class *class) { - obj = script_obj_deref_direct(obj); - if (script_obj_is_native_of_class (obj, class)) + obj = script_obj_deref_direct (obj); + if (script_obj_is_native_of_class (obj, class)) return obj->data.native.object_data; - return NULL; + return NULL; } - -void* script_obj_as_native_of_class_name (script_obj* obj, const char* class_name) +void *script_obj_as_native_of_class_name (script_obj *obj, + const char *class_name) { - obj = script_obj_deref_direct(obj); - if (script_obj_is_native_of_class_name (obj, class_name)) + obj = script_obj_deref_direct (obj); + if (script_obj_is_native_of_class_name (obj, class_name)) return obj->data.native.object_data; - return NULL; + return NULL; } - -bool script_obj_is_null (script_obj* obj) +bool script_obj_is_null (script_obj *obj) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_NULL); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_NULL; } -bool script_obj_is_int (script_obj* obj) +bool script_obj_is_int (script_obj *obj) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_INT); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_INT; } -bool script_obj_is_float (script_obj* obj) +bool script_obj_is_float (script_obj *obj) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_FLOAT); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_FLOAT; } -bool script_obj_is_number (script_obj* obj) // Float or Int +bool script_obj_is_number (script_obj *obj) /* Float or Int */ { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_INT || obj->type == SCRIPT_OBJ_TYPE_FLOAT); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_INT || obj->type == SCRIPT_OBJ_TYPE_FLOAT; } -bool script_obj_is_string (script_obj* obj) +bool script_obj_is_string (script_obj *obj) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_STRING); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_STRING; } -bool script_obj_is_hash (script_obj* obj) +bool script_obj_is_hash (script_obj *obj) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_HASH); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_HASH; } -bool script_obj_is_function (script_obj* obj) +bool script_obj_is_function (script_obj *obj) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_FUNCTION); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_FUNCTION; } - -bool script_obj_is_native (script_obj* obj) +bool script_obj_is_native (script_obj *obj) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_NATIVE); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_NATIVE; } - -bool script_obj_is_native_of_class (script_obj* obj, script_obj_native_class* class) +bool script_obj_is_native_of_class (script_obj *obj, + script_obj_native_class *class) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_NATIVE && obj->data.native.class == class); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_NATIVE && obj->data.native.class == class; } -bool script_obj_is_native_of_class_name (script_obj* obj, const char* class_name) +bool script_obj_is_native_of_class_name (script_obj *obj, + const char *class_name) { - obj = script_obj_deref_direct(obj); - return (obj->type == SCRIPT_OBJ_TYPE_NATIVE && !strcmp(obj->data.native.class->name, class_name)); + obj = script_obj_deref_direct (obj); + return obj->type == SCRIPT_OBJ_TYPE_NATIVE && !strcmp ( + obj->data.native.class->name, + class_name); } - - - -void script_obj_assign (script_obj* obj_a, script_obj* obj_b) +void script_obj_assign (script_obj *obj_a, + script_obj *obj_b) { - obj_b = script_obj_deref_direct (obj_b); - if (obj_a == obj_b) return; // FIXME triple check this - script_obj_reset (obj_a); - - switch (obj_b->type){ - case SCRIPT_OBJ_TYPE_NULL: + obj_b = script_obj_deref_direct (obj_b); + if (obj_a == obj_b) return; /* FIXME triple check this */ + script_obj_reset (obj_a); + + switch (obj_b->type) + { + case SCRIPT_OBJ_TYPE_NULL: obj_a->type = SCRIPT_OBJ_TYPE_NULL; break; - case SCRIPT_OBJ_TYPE_INT: + + case SCRIPT_OBJ_TYPE_INT: obj_a->type = SCRIPT_OBJ_TYPE_INT; obj_a->data.integer = obj_b->data.integer; break; - case SCRIPT_OBJ_TYPE_FLOAT: + + case SCRIPT_OBJ_TYPE_FLOAT: obj_a->type = SCRIPT_OBJ_TYPE_FLOAT; obj_a->data.floatpoint = obj_b->data.floatpoint; break; - case SCRIPT_OBJ_TYPE_STRING: + + case SCRIPT_OBJ_TYPE_STRING: obj_a->type = SCRIPT_OBJ_TYPE_STRING; - obj_a->data.string = strdup(obj_b->data.string); + obj_a->data.string = strdup (obj_b->data.string); break; - case SCRIPT_OBJ_TYPE_REF: // should have been de-reffed already - assert(0); - case SCRIPT_OBJ_TYPE_HASH: - case SCRIPT_OBJ_TYPE_FUNCTION: - case SCRIPT_OBJ_TYPE_NATIVE: + + case SCRIPT_OBJ_TYPE_REF: /* should have been de-reffed already */ + assert (0); + + case SCRIPT_OBJ_TYPE_HASH: + case SCRIPT_OBJ_TYPE_FUNCTION: + case SCRIPT_OBJ_TYPE_NATIVE: obj_a->type = SCRIPT_OBJ_TYPE_REF; obj_a->data.obj = obj_b; - script_obj_ref(obj_b); + script_obj_ref (obj_b); break; } } -script_obj* script_obj_hash_get_element (script_obj* hash, const char* name) +script_obj *script_obj_hash_get_element (script_obj *hash, + const char *name) { - assert(hash->type == SCRIPT_OBJ_TYPE_HASH); - script_vareable* vareable = ply_hashtable_lookup (hash->data.hash, (void*)name); - script_obj* obj; - - if (vareable) { + assert (hash->type == SCRIPT_OBJ_TYPE_HASH); + script_vareable *vareable = ply_hashtable_lookup (hash->data.hash, + (void *) name); + script_obj *obj; + + if (vareable) obj = vareable->object; + else + { + obj = script_obj_new_null (); + vareable = malloc (sizeof (script_vareable)); + vareable->name = strdup (name); + vareable->object = obj; + ply_hashtable_insert (hash->data.hash, vareable->name, vareable); } - else { - obj = script_obj_new_null (); - vareable = malloc(sizeof(script_vareable)); - vareable->name = strdup(name); - vareable->object = obj; - ply_hashtable_insert (hash->data.hash, vareable->name, vareable); - } - script_obj_ref (obj); - return obj; + script_obj_ref (obj); + return obj; } -int script_obj_hash_get_int (script_obj* hash, const char* name) +int script_obj_hash_get_int (script_obj *hash, + const char *name) { - script_obj* obj = script_obj_hash_get_element (hash, name); - int reply = script_obj_as_int (obj); - script_obj_unref (obj); - return reply; + script_obj *obj = script_obj_hash_get_element (hash, name); + int reply = script_obj_as_int (obj); + + script_obj_unref (obj); + return reply; } -float script_obj_hash_get_float (script_obj* hash, const char* name) +float script_obj_hash_get_float (script_obj *hash, + const char *name) { - script_obj* obj = script_obj_hash_get_element (hash, name); - float reply = script_obj_as_float (obj); - script_obj_unref (obj); - return reply; + script_obj *obj = script_obj_hash_get_element (hash, name); + float reply = script_obj_as_float (obj); + + script_obj_unref (obj); + return reply; } -bool script_obj_hash_get_bool (script_obj* hash, const char* name) +bool script_obj_hash_get_bool (script_obj *hash, + const char *name) { - script_obj* obj = script_obj_hash_get_element (hash, name); - bool reply = script_obj_as_bool (obj); - script_obj_unref (obj); - return reply; + script_obj *obj = script_obj_hash_get_element (hash, name); + bool reply = script_obj_as_bool (obj); + + script_obj_unref (obj); + return reply; } -char* script_obj_hash_get_string (script_obj* hash, const char* name) +char *script_obj_hash_get_string (script_obj *hash, + const char *name) { - script_obj* obj = script_obj_hash_get_element (hash, name); - char* reply = script_obj_as_string (obj); - script_obj_unref (obj); - return reply; + script_obj *obj = script_obj_hash_get_element (hash, name); + char *reply = script_obj_as_string (obj); + + script_obj_unref (obj); + return reply; } -void* script_obj_hash_get_native_of_class (script_obj* hash, const char* name, script_obj_native_class* class) +void *script_obj_hash_get_native_of_class (script_obj *hash, + const char *name, + script_obj_native_class *class) { - script_obj* obj = script_obj_hash_get_element (hash, name); - void* reply = script_obj_as_native_of_class (obj, class); - script_obj_unref (obj); - return reply; + script_obj *obj = script_obj_hash_get_element (hash, name); + void *reply = script_obj_as_native_of_class (obj, class); + + script_obj_unref (obj); + return reply; } -void* script_obj_hash_get_native_of_class_name (script_obj* hash, const char* name, const char* class_name) +void *script_obj_hash_get_native_of_class_name (script_obj *hash, + const char *name, + const char *class_name) { - script_obj* obj = script_obj_hash_get_element (hash, name); - void* reply = script_obj_as_native_of_class_name (obj, class_name); - script_obj_unref (obj); - return reply; + script_obj *obj = script_obj_hash_get_element (hash, name); + void *reply = script_obj_as_native_of_class_name (obj, class_name); + + script_obj_unref (obj); + return reply; } -void script_obj_hash_add_element (script_obj* hash, script_obj* element, const char* name) +void script_obj_hash_add_element (script_obj *hash, + script_obj *element, + const char *name) { - assert(hash->type == SCRIPT_OBJ_TYPE_HASH); - script_obj* obj = script_obj_hash_get_element (hash, name); - script_obj_assign (obj, element); - script_obj_unref (obj); + assert (hash->type == SCRIPT_OBJ_TYPE_HASH); + script_obj *obj = script_obj_hash_get_element (hash, name); + script_obj_assign (obj, element); + script_obj_unref (obj); } - -script_obj* script_obj_plus (script_obj* script_obj_a, script_obj* script_obj_b) +script_obj *script_obj_plus (script_obj *script_obj_a, + script_obj *script_obj_b) { - if (script_obj_is_string(script_obj_a) || script_obj_is_string(script_obj_b)){ - script_obj* obj; - char* string_a = script_obj_as_string(script_obj_a); - char* string_b = script_obj_as_string(script_obj_b); - if (string_a && string_b){ - char* newstring; - asprintf(&newstring, "%s%s", string_a, string_b); - obj = script_obj_new_string (newstring); - free(newstring); + if (script_obj_is_string (script_obj_a) || script_obj_is_string (script_obj_b)) + { + script_obj *obj; + char *string_a = script_obj_as_string (script_obj_a); + char *string_b = script_obj_as_string (script_obj_b); + if (string_a && string_b) + { + char *newstring; + asprintf (&newstring, "%s%s", string_a, string_b); + obj = script_obj_new_string (newstring); + free (newstring); } - else { + else obj = script_obj_new_null (); - } - free(string_a); - free(string_b); - return obj; + free (string_a); + free (string_b); + return obj; } - - if (script_obj_is_number(script_obj_a) && script_obj_is_number(script_obj_b)){ - if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)){ - int value = script_obj_as_int (script_obj_a) + script_obj_as_int (script_obj_b); - return script_obj_new_int (value); + if (script_obj_is_number (script_obj_a) && script_obj_is_number (script_obj_b)) + { + if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)) + { + int value = script_obj_as_int (script_obj_a) + script_obj_as_int (script_obj_b); + return script_obj_new_int (value); } - float value = script_obj_as_float (script_obj_a) + script_obj_as_float (script_obj_b); - return script_obj_new_float (value); + float value = script_obj_as_float (script_obj_a) + script_obj_as_float (script_obj_b); + return script_obj_new_float (value); } - - return script_obj_new_null (); + return script_obj_new_null (); } - -script_obj* script_obj_minus (script_obj* script_obj_a, script_obj* script_obj_b) +script_obj *script_obj_minus (script_obj *script_obj_a, + script_obj *script_obj_b) { - if (script_obj_is_number(script_obj_a) && script_obj_is_number(script_obj_b)){ - if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)){ - int value = script_obj_as_int (script_obj_a) - script_obj_as_int (script_obj_b); - return script_obj_new_int (value); + if (script_obj_is_number (script_obj_a) && script_obj_is_number (script_obj_b)) + { + if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)) + { + int value = script_obj_as_int (script_obj_a) - script_obj_as_int (script_obj_b); + return script_obj_new_int (value); } - float value = script_obj_as_float (script_obj_a) - script_obj_as_float (script_obj_b); - return script_obj_new_float (value); + float value = script_obj_as_float (script_obj_a) - script_obj_as_float (script_obj_b); + return script_obj_new_float (value); } - - return script_obj_new_null (); + return script_obj_new_null (); } - -script_obj* script_obj_mul (script_obj* script_obj_a, script_obj* script_obj_b) +script_obj *script_obj_mul (script_obj *script_obj_a, + script_obj *script_obj_b) { - if (script_obj_is_number(script_obj_a) && script_obj_is_number(script_obj_b)){ - if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)){ - int value = script_obj_as_int (script_obj_a) * script_obj_as_int (script_obj_b); - return script_obj_new_int (value); + if (script_obj_is_number (script_obj_a) && script_obj_is_number (script_obj_b)) + { + if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)) + { + int value = script_obj_as_int (script_obj_a) * script_obj_as_int (script_obj_b); + return script_obj_new_int (value); } - float value = script_obj_as_float (script_obj_a) * script_obj_as_float (script_obj_b); - return script_obj_new_float (value); + float value = script_obj_as_float (script_obj_a) * script_obj_as_float (script_obj_b); + return script_obj_new_float (value); } - return script_obj_new_null (); + return script_obj_new_null (); } - -script_obj* script_obj_div (script_obj* script_obj_a, script_obj* script_obj_b) +script_obj *script_obj_div (script_obj *script_obj_a, + script_obj *script_obj_b) { - if (script_obj_is_number(script_obj_a) && script_obj_is_number(script_obj_b)){ - if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)){ - if (script_obj_as_int (script_obj_a) % script_obj_as_int (script_obj_b) == 0){ + if (script_obj_is_number (script_obj_a) && script_obj_is_number (script_obj_b)) + { + if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)) + if (script_obj_as_int (script_obj_a) % + script_obj_as_int (script_obj_b) == 0) + { int value = script_obj_as_int (script_obj_a) / script_obj_as_int (script_obj_b); return script_obj_new_int (value); - } - } - float value = script_obj_as_float (script_obj_a) / script_obj_as_float (script_obj_b); - return script_obj_new_float (value); + } + float value = script_obj_as_float (script_obj_a) / script_obj_as_float (script_obj_b); + return script_obj_new_float (value); } - return script_obj_new_null (); + return script_obj_new_null (); } - - -script_obj* script_obj_mod (script_obj* script_obj_a, script_obj* script_obj_b) +script_obj *script_obj_mod (script_obj *script_obj_a, + script_obj *script_obj_b) { - if (script_obj_is_number(script_obj_a) && script_obj_is_number(script_obj_b)){ - if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)){ - int value = script_obj_as_int (script_obj_a) % script_obj_as_int (script_obj_b); - return script_obj_new_int (value); + if (script_obj_is_number (script_obj_a) && script_obj_is_number (script_obj_b)) + { + if (script_obj_is_int (script_obj_a) && script_obj_is_int (script_obj_b)) + { + int value = script_obj_as_int (script_obj_a) % script_obj_as_int (script_obj_b); + return script_obj_new_int (value); } - float value = fmodf(script_obj_as_float (script_obj_a), script_obj_as_float (script_obj_b)); - return script_obj_new_float (value); + float value = fmodf (script_obj_as_float ( + script_obj_a), script_obj_as_float (script_obj_b)); + return script_obj_new_float (value); } - return script_obj_new_null (); + return script_obj_new_null (); } + diff --git a/src/plugins/splash/script/script-object.h b/src/plugins/splash/script/script-object.h index e41c5b1c..df4cd100 100644 --- a/src/plugins/splash/script/script-object.h +++ b/src/plugins/splash/script/script-object.h @@ -24,50 +24,75 @@ #include "script.h" -void script_obj_free (script_obj* obj); -void script_obj_ref (script_obj* obj); -void script_obj_unref (script_obj* obj); -void script_obj_reset (script_obj* obj); -script_obj* script_obj_deref_direct (script_obj* obj); -void script_obj_deref (script_obj** obj_ptr); -char* script_obj_print (script_obj* obj); -script_obj* script_obj_new_int (int number); -script_obj* script_obj_new_float (float number); -script_obj* script_obj_new_string (const char* string); -script_obj* script_obj_new_null (void); -script_obj* script_obj_new_hash (void); -script_obj* script_obj_new_function (script_function* function); -script_obj* script_obj_new_ref (script_obj* sub_obj); -script_obj* script_obj_new_native (void* object_data, script_obj_native_class* class); -int script_obj_as_int (script_obj* obj); -float script_obj_as_float (script_obj* obj); -bool script_obj_as_bool (script_obj* obj); -char* script_obj_as_string (script_obj* obj); -void* script_obj_as_native_of_class (script_obj* obj, script_obj_native_class* class); -void* script_obj_as_native_of_class_name (script_obj* obj, const char* class_name); -bool script_obj_is_null (script_obj* obj); -bool script_obj_is_int (script_obj* obj); -bool script_obj_is_float (script_obj* obj); -bool script_obj_is_string (script_obj* obj); -bool script_obj_is_hash (script_obj* obj); -bool script_obj_is_function (script_obj* obj); -bool script_obj_is_native (script_obj* obj); -bool script_obj_is_native_of_class (script_obj* obj, script_obj_native_class* class); -bool script_obj_is_native_of_class_name (script_obj* obj, const char* class_name); -void script_obj_assign (script_obj* obj_a, script_obj* obj_b); -script_obj* script_obj_hash_get_element (script_obj* hash, const char* name); -int script_obj_hash_get_int (script_obj* hash, const char* name); -float script_obj_hash_get_float (script_obj* hash, const char* name); -bool script_obj_hash_get_bool (script_obj* hash, const char* name); -char* script_obj_hash_get_string (script_obj* hash, const char* name); -void* script_obj_hash_get_native_of_class (script_obj* hash, const char* name, script_obj_native_class* class); -void* script_obj_hash_get_native_of_class_name (script_obj* hash, const char* name, const char* class_name); -void script_obj_hash_add_element (script_obj* hash, script_obj* element, const char* name); -script_obj* script_obj_plus (script_obj* script_obj_a_in, script_obj* script_obj_b_in); -script_obj* script_obj_minus (script_obj* script_obj_a_in, script_obj* script_obj_b_in); -script_obj* script_obj_mul (script_obj* script_obj_a_in, script_obj* script_obj_b_in); -script_obj* script_obj_div (script_obj* script_obj_a_in, script_obj* script_obj_b_in); -script_obj* script_obj_mod (script_obj* script_obj_a_in, script_obj* script_obj_b_in); +void script_obj_free (script_obj *obj); +void script_obj_ref (script_obj *obj); +void script_obj_unref (script_obj *obj); +void script_obj_reset (script_obj *obj); +script_obj *script_obj_deref_direct (script_obj *obj); +void script_obj_deref (script_obj **obj_ptr); +char *script_obj_print (script_obj *obj); +script_obj *script_obj_new_int (int number); +script_obj *script_obj_new_float (float number); +script_obj *script_obj_new_string (const char *string); +script_obj *script_obj_new_null (void); +script_obj *script_obj_new_hash (void); +script_obj *script_obj_new_function (script_function *function); +script_obj *script_obj_new_ref (script_obj *sub_obj); +script_obj *script_obj_new_native (void *object_data, + script_obj_native_class * class ); +int script_obj_as_int (script_obj *obj); +float script_obj_as_float (script_obj *obj); +bool script_obj_as_bool (script_obj *obj); +char *script_obj_as_string (script_obj *obj); + +void *script_obj_as_native_of_class (script_obj * obj, + script_obj_native_class * class ); +void *script_obj_as_native_of_class_name (script_obj *obj, + const char *class_name); +bool script_obj_is_null (script_obj *obj); +bool script_obj_is_int (script_obj *obj); +bool script_obj_is_float (script_obj *obj); +bool script_obj_is_string (script_obj *obj); +bool script_obj_is_hash (script_obj *obj); +bool script_obj_is_function (script_obj *obj); +bool script_obj_is_native (script_obj *obj); + +bool script_obj_is_native_of_class (script_obj * obj, + script_obj_native_class * class ); +bool script_obj_is_native_of_class_name (script_obj *obj, + const char *class_name); +void script_obj_assign (script_obj *obj_a, + script_obj *obj_b); +script_obj *script_obj_hash_get_element (script_obj *hash, + const char *name); +int script_obj_hash_get_int (script_obj *hash, + const char *name); +float script_obj_hash_get_float (script_obj *hash, + const char *name); +bool script_obj_hash_get_bool (script_obj *hash, + const char *name); +char *script_obj_hash_get_string (script_obj *hash, + const char *name); + +void *script_obj_hash_get_native_of_class (script_obj * hash, + const char *name, + script_obj_native_class * class ); +void *script_obj_hash_get_native_of_class_name (script_obj *hash, + const char *name, + const char *class_name); +void script_obj_hash_add_element (script_obj *hash, + script_obj *element, + const char *name); +script_obj *script_obj_plus (script_obj *script_obj_a_in, + script_obj *script_obj_b_in); +script_obj *script_obj_minus (script_obj *script_obj_a_in, + script_obj *script_obj_b_in); +script_obj *script_obj_mul (script_obj *script_obj_a_in, + script_obj *script_obj_b_in); +script_obj *script_obj_div (script_obj *script_obj_a_in, + script_obj *script_obj_b_in); +script_obj *script_obj_mod (script_obj *script_obj_a_in, + script_obj *script_obj_b_in); #endif /* SCRIPT_OBJECT */ diff --git a/src/plugins/splash/script/script-parse.c b/src/plugins/splash/script/script-parse.c index 7076870f..99d7cf92 100644 --- a/src/plugins/splash/script/script-parse.c +++ b/src/plugins/splash/script/script-parse.c @@ -36,1022 +36,1073 @@ #include "script.h" #include "script-parse.h" - #define WITH_SEMIES +static script_op *script_parse_op (ply_scan_t *scan); +static script_exp *script_parse_exp (ply_scan_t *scan); +static ply_list_t *script_parse_op_list (ply_scan_t *scan); +static void script_parse_op_list_free (ply_list_t *op_list); - - -/* done todo -int var (exp) tm = -f() f[] f.a pi = -pre: ! ++ -- + - pr = -post: ++ -- po = -* / % md = -+ - pm = -< <= > >= gt = -== != eq = -&& an = -|| or = -= as = += -= *= %= /= - -*/ - - -static script_op* script_parse_op (ply_scan_t* scan); -static script_exp* script_parse_exp (ply_scan_t* scan); -static ply_list_t* script_parse_op_list (ply_scan_t* scan); -static void script_parse_op_list_free (ply_list_t* op_list); - -static void script_parse_error (ply_scan_token_t* token, char* expected) +static void script_parse_error (ply_scan_token_t *token, + char *expected) { - ply_error ("Parser error L:%d C:%d : %s\n", token->line_index, token->column_index, expected); + ply_error ("Parser error L:%d C:%d : %s\n", + token->line_index, + token->column_index, + expected); } -static script_exp* script_parse_exp_tm (ply_scan_t* scan) +static script_exp *script_parse_exp_tm (ply_scan_t *scan) { - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - script_exp* exp = NULL; - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_INTEGER){ - exp = malloc(sizeof(script_exp)); - exp->type = SCRIPT_EXP_TYPE_TERM_INT; - exp->data.integer = curtoken->data.integer; - ply_scan_get_next_token(scan); - return exp; + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + script_exp *exp = NULL; + + if (curtoken->type == PLY_SCAN_TOKEN_TYPE_INTEGER) + { + exp = malloc (sizeof (script_exp)); + exp->type = SCRIPT_EXP_TYPE_TERM_INT; + exp->data.integer = curtoken->data.integer; + ply_scan_get_next_token (scan); + return exp; } - - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_FLOAT){ - exp = malloc(sizeof(script_exp)); - exp->type = SCRIPT_EXP_TYPE_TERM_FLOAT; - exp->data.floatpoint = curtoken->data.floatpoint; - ply_scan_get_next_token(scan); - return exp; + if (curtoken->type == PLY_SCAN_TOKEN_TYPE_FLOAT) + { + exp = malloc (sizeof (script_exp)); + exp->type = SCRIPT_EXP_TYPE_TERM_FLOAT; + exp->data.floatpoint = curtoken->data.floatpoint; + ply_scan_get_next_token (scan); + return exp; } - - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_IDENTIFIER){ - exp = malloc(sizeof(script_exp)); - if (!strcmp(curtoken->data.string, "NULL")){ + if (curtoken->type == PLY_SCAN_TOKEN_TYPE_IDENTIFIER) + { + exp = malloc (sizeof (script_exp)); + if (!strcmp (curtoken->data.string, "NULL")) exp->type = SCRIPT_EXP_TYPE_TERM_NULL; - } - else if (!strcmp(curtoken->data.string, "global")){ + else if (!strcmp (curtoken->data.string, "global")) exp->type = SCRIPT_EXP_TYPE_TERM_GLOBAL; - } - else if (!strcmp(curtoken->data.string, "local")){ + else if (!strcmp (curtoken->data.string, "local")) exp->type = SCRIPT_EXP_TYPE_TERM_LOCAL; + else + { + exp->type = SCRIPT_EXP_TYPE_TERM_VAR; + exp->data.string = strdup (curtoken->data.string); } - else { - exp->type = SCRIPT_EXP_TYPE_TERM_VAR; - exp->data.string = strdup(curtoken->data.string); - } - curtoken = ply_scan_get_next_token(scan); - return exp; + curtoken = ply_scan_get_next_token (scan); + return exp; } - - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_STRING){ - exp = malloc(sizeof(script_exp)); - exp->type = SCRIPT_EXP_TYPE_TERM_STRING; - exp->data.string = strdup(curtoken->data.string); - ply_scan_get_next_token(scan); - return exp; + if (curtoken->type == PLY_SCAN_TOKEN_TYPE_STRING) + { + exp = malloc (sizeof (script_exp)); + exp->type = SCRIPT_EXP_TYPE_TERM_STRING; + exp->data.string = strdup (curtoken->data.string); + ply_scan_get_next_token (scan); + return exp; } - - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && curtoken->data.symbol == '('){ - ply_scan_get_next_token(scan); - exp = script_parse_exp (scan); - curtoken = ply_scan_get_current_token(scan); - if (!exp){ - script_parse_error (curtoken, "Expected valid contents of bracketed expression"); - return NULL; + if ((curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL) + && (curtoken->data.symbol == '(')) + { + ply_scan_get_next_token (scan); + exp = script_parse_exp (scan); + curtoken = ply_scan_get_current_token (scan); + if (!exp) + { + script_parse_error (curtoken, + "Expected valid contents of bracketed expression"); + return NULL; } - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != ')'){ - script_parse_error (curtoken, "Expected bracketed block to be terminated with a ')'"); - return NULL; + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != ')')) + { + script_parse_error (curtoken, + "Expected bracketed block to be terminated with a ')'"); + return NULL; } - ply_scan_get_next_token(scan); - return exp; + ply_scan_get_next_token (scan); + return exp; } - return exp; + return exp; } -static script_exp* script_parse_exp_pi (ply_scan_t* scan) +static script_exp *script_parse_exp_pi (ply_scan_t *scan) { - script_exp* exp = script_parse_exp_tm (scan); - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - while (true){ - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - if (curtoken->data.symbol == '('){ - script_exp* func = malloc(sizeof(script_exp)); - ply_list_t* parameters = ply_list_new(); - ply_scan_get_next_token(scan); - while (true){ - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && curtoken->data.symbol == ')') break; - - script_exp* parameter = script_parse_exp (scan); - - ply_list_append_data (parameters, parameter); - - curtoken = ply_scan_get_current_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL){ - script_parse_error (curtoken, "Function parameters should be separated with a ',' and terminated with a ')'"); - return NULL; + script_exp *exp = script_parse_exp_tm (scan); + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + + while (true) + { + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if (curtoken->data.symbol == '(') + { + script_exp *func = malloc (sizeof (script_exp)); + ply_list_t *parameters = ply_list_new (); + ply_scan_get_next_token (scan); + while (true) + { + if ((curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL) + && (curtoken->data.symbol == ')')) break; + script_exp *parameter = script_parse_exp (scan); + + ply_list_append_data (parameters, parameter); + + curtoken = ply_scan_get_current_token (scan); + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + { + script_parse_error (curtoken, + "Function parameters should be separated with a ',' and terminated with a ')'"); + return NULL; } - if (curtoken->data.symbol == ')') break; - if (curtoken->data.symbol != ','){ - script_parse_error (curtoken, "Function parameters should be separated with a ',' and terminated with a ')'"); - return NULL; + if (curtoken->data.symbol == ')') break; + if (curtoken->data.symbol != ',') + { + script_parse_error (curtoken, + "Function parameters should be separated with a ',' and terminated with a ')'"); + return NULL; } - curtoken = ply_scan_get_next_token(scan); + curtoken = ply_scan_get_next_token (scan); } - ply_scan_get_next_token(scan); - func->data.function.name = exp; - exp = func; - exp->type = SCRIPT_EXP_TYPE_FUNCTION; - exp->data.function.parameters = parameters; - continue; + ply_scan_get_next_token (scan); + func->data.function.name = exp; + exp = func; + exp->type = SCRIPT_EXP_TYPE_FUNCTION; + exp->data.function.parameters = parameters; + continue; } + script_exp *key; - script_exp* key; - - if (curtoken->data.symbol == '.'){ - ply_scan_get_next_token(scan); - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_IDENTIFIER){ - key = malloc(sizeof(script_exp)); - key->type = SCRIPT_EXP_TYPE_TERM_STRING; - key->data.string = strdup(curtoken->data.string); + if (curtoken->data.symbol == '.') + { + ply_scan_get_next_token (scan); + if (curtoken->type == PLY_SCAN_TOKEN_TYPE_IDENTIFIER) + { + key = malloc (sizeof (script_exp)); + key->type = SCRIPT_EXP_TYPE_TERM_STRING; + key->data.string = strdup (curtoken->data.string); } - else if (curtoken->type == PLY_SCAN_TOKEN_TYPE_INTEGER){ // errrr, integer keys without being [] bracketed - key = malloc(sizeof(script_exp)); // This is broken with floats as obj.10.6 is obj[10.6] and not obj[10][6] - key->type = SCRIPT_EXP_TYPE_TERM_INT; - key->data.integer = curtoken->data.integer; + else if (curtoken->type == PLY_SCAN_TOKEN_TYPE_INTEGER) /* errrr, integer keys without being [] bracketed */ + { + key = malloc (sizeof (script_exp)); /* This is broken with floats as obj.10.6 is obj[10.6] and not obj[10][6] */ + key->type = SCRIPT_EXP_TYPE_TERM_INT; + key->data.integer = curtoken->data.integer; } - else { - script_parse_error (curtoken, "A dot based hash index must be an identifier (or a integer)"); - return NULL; + else + { + script_parse_error (curtoken, + "A dot based hash index must be an identifier (or a integer)"); + return NULL; } - - curtoken = ply_scan_get_next_token(scan); + curtoken = ply_scan_get_next_token (scan); } - else if (curtoken->data.symbol == '['){ - ply_scan_get_next_token(scan); - key = script_parse_exp (scan); - curtoken = ply_scan_get_current_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != ']'){ - script_parse_error (curtoken, "Expected a ']' to terminate the index expression"); - return NULL; + else if (curtoken->data.symbol == '[') + { + ply_scan_get_next_token (scan); + key = script_parse_exp (scan); + curtoken = ply_scan_get_current_token (scan); + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != ']')) + { + script_parse_error (curtoken, + "Expected a ']' to terminate the index expression"); + return NULL; } - curtoken = ply_scan_get_next_token(scan); + curtoken = ply_scan_get_next_token (scan); } - else break; - script_exp* hash = malloc(sizeof(script_exp)); - hash->type = SCRIPT_EXP_TYPE_HASH; - hash->data.dual.sub_a = exp; - hash->data.dual.sub_b = key; - exp = hash; // common hash lookup bit; - - + else break; + script_exp *hash = malloc (sizeof (script_exp)); + hash->type = SCRIPT_EXP_TYPE_HASH; + hash->data.dual.sub_a = exp; + hash->data.dual.sub_b = key; + exp = hash; /* common hash lookup bit; */ } - return exp; + return exp; } - -static script_exp* script_parse_exp_pr (ply_scan_t* scan) +static script_exp *script_parse_exp_pr (ply_scan_t *scan) { - script_exp_type type; - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL){ - if (curtoken->data.symbol == '+'){ - if (peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && peektoken->data.symbol == '+' && !peektoken->whitespace){ - ply_scan_get_next_token(scan); - ply_scan_get_next_token(scan); - type = SCRIPT_EXP_TYPE_PRE_INC; + script_exp_type type; + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + + if (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL) + { + if (curtoken->data.symbol == '+') + { + if ((peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL) + && (peektoken->data.symbol == '+') && !peektoken->whitespace) + { + ply_scan_get_next_token (scan); + ply_scan_get_next_token (scan); + type = SCRIPT_EXP_TYPE_PRE_INC; } - else { - ply_scan_get_next_token(scan); - type = SCRIPT_EXP_TYPE_POS; + else + { + ply_scan_get_next_token (scan); + type = SCRIPT_EXP_TYPE_POS; } } - else if (curtoken->data.symbol == '-'){ - if (peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && peektoken->data.symbol == '-' && !peektoken->whitespace){ - ply_scan_get_next_token(scan); - ply_scan_get_next_token(scan); - type = SCRIPT_EXP_TYPE_PRE_DEC; + else if (curtoken->data.symbol == '-') + { + if ((peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL) + && (peektoken->data.symbol == '-') && !peektoken->whitespace) + { + ply_scan_get_next_token (scan); + ply_scan_get_next_token (scan); + type = SCRIPT_EXP_TYPE_PRE_DEC; } - else { - ply_scan_get_next_token(scan); - type = SCRIPT_EXP_TYPE_NEG; + else + { + ply_scan_get_next_token (scan); + type = SCRIPT_EXP_TYPE_NEG; } } - else if (curtoken->data.symbol == '!'){ - ply_scan_get_next_token(scan); - type = SCRIPT_EXP_TYPE_NOT; + else if (curtoken->data.symbol == '!') + { + ply_scan_get_next_token (scan); + type = SCRIPT_EXP_TYPE_NOT; } - else { + else return script_parse_exp_pi (scan); - } - script_exp* exp = malloc(sizeof(script_exp)); - exp->type = type; - exp->data.sub = script_parse_exp_pr (scan); - return exp; + script_exp *exp = malloc (sizeof (script_exp)); + exp->type = type; + exp->data.sub = script_parse_exp_pr (scan); + return exp; } - return script_parse_exp_pi (scan); + return script_parse_exp_pi (scan); } - - -static script_exp* script_parse_exp_po (ply_scan_t* scan) +static script_exp *script_parse_exp_po (ply_scan_t *scan) { - script_exp* exp = script_parse_exp_pr (scan); - - while (true){ - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - if (peektoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - if (curtoken->data.symbol == '+' && peektoken->data.symbol == '+' && !peektoken->whitespace) { - ply_scan_get_next_token(scan); - ply_scan_get_next_token(scan); - script_exp* new_exp = malloc(sizeof(script_exp)); - new_exp->type = SCRIPT_EXP_TYPE_POST_INC; - new_exp->data.sub = exp; - exp = new_exp; + script_exp *exp = script_parse_exp_pr (scan); + + while (true) + { + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if (peektoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if ((curtoken->data.symbol == '+') && (peektoken->data.symbol == '+') + && !peektoken->whitespace) + { + ply_scan_get_next_token (scan); + ply_scan_get_next_token (scan); + script_exp *new_exp = malloc (sizeof (script_exp)); + new_exp->type = SCRIPT_EXP_TYPE_POST_INC; + new_exp->data.sub = exp; + exp = new_exp; } - else if (curtoken->data.symbol == '-' && peektoken->data.symbol == '-' && !peektoken->whitespace) { - ply_scan_get_next_token(scan); - ply_scan_get_next_token(scan); - script_exp* new_exp = malloc(sizeof(script_exp)); - new_exp->type = SCRIPT_EXP_TYPE_POST_DEC; - new_exp->data.sub = exp; - exp = new_exp; + else if (curtoken->data.symbol == '-' && peektoken->data.symbol == '-' + && !peektoken->whitespace) + { + ply_scan_get_next_token (scan); + ply_scan_get_next_token (scan); + script_exp *new_exp = malloc (sizeof (script_exp)); + new_exp->type = SCRIPT_EXP_TYPE_POST_DEC; + new_exp->data.sub = exp; + exp = new_exp; } - else break; + else break; } - - return exp; -} - + return exp; +} -static script_exp* script_parse_exp_md (ply_scan_t* scan) +static script_exp *script_parse_exp_md (ply_scan_t *scan) { - script_exp* sub_a = script_parse_exp_po (scan); - if (!sub_a) return NULL; - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - while (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && - (curtoken->data.symbol == '*' || - curtoken->data.symbol == '/' || - curtoken->data.symbol == '%' ) && - !(peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && - peektoken->data.symbol == '=' )){ - script_exp* exp = malloc(sizeof(script_exp)); - if (curtoken->data.symbol == '*') exp->type = SCRIPT_EXP_TYPE_MUL; - else if (curtoken->data.symbol == '/') exp->type = SCRIPT_EXP_TYPE_DIV; - else exp->type = SCRIPT_EXP_TYPE_MOD; - exp->data.dual.sub_a = sub_a; - ply_scan_get_next_token(scan); - sub_a = exp; - exp->data.dual.sub_b = script_parse_exp_po (scan); - curtoken = ply_scan_get_current_token(scan); - peektoken = ply_scan_peek_next_token(scan); - if (!exp->data.dual.sub_b){ - script_parse_error (curtoken, "An invalid RHS of an expression"); - return NULL; + script_exp *sub_a = script_parse_exp_po (scan); + + if (!sub_a) return NULL; + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + while (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL + && (curtoken->data.symbol == '*' + || curtoken->data.symbol == '/' + || curtoken->data.symbol == '%') + && !(peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL + && peektoken->data.symbol == '=')) + { + script_exp *exp = malloc (sizeof (script_exp)); + if (curtoken->data.symbol == '*') exp->type = SCRIPT_EXP_TYPE_MUL; + else if (curtoken->data.symbol == '/') exp->type = SCRIPT_EXP_TYPE_DIV; + else exp->type = SCRIPT_EXP_TYPE_MOD; + exp->data.dual.sub_a = sub_a; + ply_scan_get_next_token (scan); + sub_a = exp; + exp->data.dual.sub_b = script_parse_exp_po (scan); + curtoken = ply_scan_get_current_token (scan); + peektoken = ply_scan_peek_next_token (scan); + if (!exp->data.dual.sub_b) + { + script_parse_error (curtoken, "An invalid RHS of an expression"); + return NULL; } } - - return sub_a; + + return sub_a; } -static script_exp* script_parse_exp_pm (ply_scan_t* scan) +static script_exp *script_parse_exp_pm (ply_scan_t *scan) { - script_exp* sub_a = script_parse_exp_md (scan); - if (!sub_a) return NULL; - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - while (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && - (curtoken->data.symbol == '+' || - curtoken->data.symbol == '-' ) && - !(peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && - peektoken->data.symbol == '=' )){ - script_exp* exp = malloc(sizeof(script_exp)); - if (curtoken->data.symbol == '+') exp->type = SCRIPT_EXP_TYPE_PLUS; - else exp->type = SCRIPT_EXP_TYPE_MINUS; - exp->data.dual.sub_a = sub_a; - ply_scan_get_next_token(scan); - exp->data.dual.sub_b = script_parse_exp_md (scan); - sub_a = exp; - curtoken = ply_scan_get_current_token(scan); - peektoken = ply_scan_peek_next_token(scan); - if (!exp->data.dual.sub_b){ - script_parse_error (curtoken, "An invalid RHS of an expression"); - return NULL; + script_exp *sub_a = script_parse_exp_md (scan); + + if (!sub_a) return NULL; + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + while (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL + && (curtoken->data.symbol == '+' + || curtoken->data.symbol == '-') + && !(peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL + && peektoken->data.symbol == '=')) + { + script_exp *exp = malloc (sizeof (script_exp)); + if (curtoken->data.symbol == '+') exp->type = SCRIPT_EXP_TYPE_PLUS; + else exp->type = SCRIPT_EXP_TYPE_MINUS; + exp->data.dual.sub_a = sub_a; + ply_scan_get_next_token (scan); + exp->data.dual.sub_b = script_parse_exp_md (scan); + sub_a = exp; + curtoken = ply_scan_get_current_token (scan); + peektoken = ply_scan_peek_next_token (scan); + if (!exp->data.dual.sub_b) + { + script_parse_error (curtoken, "An invalid RHS of an expression"); + return NULL; } } - - return sub_a; + + return sub_a; } -static script_exp* script_parse_exp_gt (ply_scan_t* scan) +static script_exp *script_parse_exp_gt (ply_scan_t *scan) { - script_exp* sub_a = script_parse_exp_pm (scan); - if (!sub_a) return NULL; - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - while (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && - (curtoken->data.symbol == '<' || - curtoken->data.symbol == '>' )){ // FIXME make sure we dont consume <<= or >>= - int gt = (curtoken->data.symbol == '>'); - int eq = 0; - curtoken = ply_scan_get_next_token(scan); - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && - curtoken->data.symbol == '=' && - !curtoken->whitespace){ - eq = 1; - curtoken = ply_scan_get_next_token(scan); + script_exp *sub_a = script_parse_exp_pm (scan); + + if (!sub_a) return NULL; + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + while (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL + && (curtoken->data.symbol == '<' + || curtoken->data.symbol == '>')) /* FIXME make sure we dont consume <<= or >>= */ + { + int gt = (curtoken->data.symbol == '>'); + int eq = 0; + curtoken = ply_scan_get_next_token (scan); + if ((curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL) + && (curtoken->data.symbol == '=') + && !curtoken->whitespace) + { + eq = 1; + curtoken = ply_scan_get_next_token (scan); } - script_exp* exp = malloc(sizeof(script_exp)); - if ( gt && eq) exp->type = SCRIPT_EXP_TYPE_GE; - else if ( gt && !eq) exp->type = SCRIPT_EXP_TYPE_GT; - else if (!gt && eq) exp->type = SCRIPT_EXP_TYPE_LE; - else exp->type = SCRIPT_EXP_TYPE_LT; - - exp->data.dual.sub_a = sub_a; - exp->data.dual.sub_b = script_parse_exp_pm (scan); - sub_a = exp; - curtoken = ply_scan_get_current_token(scan); - peektoken = ply_scan_peek_next_token(scan); - if (!exp->data.dual.sub_b){ - script_parse_error (curtoken, "An invalid RHS of an expression"); - return NULL; + script_exp *exp = malloc (sizeof (script_exp)); + if (gt && eq) exp->type = SCRIPT_EXP_TYPE_GE; + else if (gt && !eq) exp->type = SCRIPT_EXP_TYPE_GT; + else if (!gt && eq) exp->type = SCRIPT_EXP_TYPE_LE; + else exp->type = SCRIPT_EXP_TYPE_LT; + exp->data.dual.sub_a = sub_a; + exp->data.dual.sub_b = script_parse_exp_pm (scan); + sub_a = exp; + curtoken = ply_scan_get_current_token (scan); + peektoken = ply_scan_peek_next_token (scan); + if (!exp->data.dual.sub_b) + { + script_parse_error (curtoken, "An invalid RHS of an expression"); + return NULL; } } - - return sub_a; + + return sub_a; } -static script_exp* script_parse_exp_eq (ply_scan_t* scan) +static script_exp *script_parse_exp_eq (ply_scan_t *scan) { - script_exp* sub_a = script_parse_exp_gt (scan); - if (!sub_a) return NULL; - while (1){ - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - if (peektoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - - if (peektoken->data.symbol != '=') break; - if (peektoken->whitespace) break; - if ((curtoken->data.symbol != '=') && (curtoken->data.symbol != '!')) break; - int ne = (curtoken->data.symbol == '!'); - ply_scan_get_next_token(scan); - ply_scan_get_next_token(scan); - - script_exp* exp = malloc(sizeof(script_exp)); - if (ne) exp->type = SCRIPT_EXP_TYPE_NE; - else exp->type = SCRIPT_EXP_TYPE_EQ; - exp->data.dual.sub_a = sub_a; - exp->data.dual.sub_b = script_parse_exp_gt (scan); - sub_a = exp; - if (!exp->data.dual.sub_b){ - script_parse_error (ply_scan_get_current_token(scan), "An invalid RHS of an expression"); - return NULL; + script_exp *sub_a = script_parse_exp_gt (scan); + + if (!sub_a) return NULL; + while (1) + { + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if (peektoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if (peektoken->data.symbol != '=') break; + if (peektoken->whitespace) break; + if ((curtoken->data.symbol != '=') + && (curtoken->data.symbol != '!')) break; + int ne = (curtoken->data.symbol == '!'); + ply_scan_get_next_token (scan); + ply_scan_get_next_token (scan); + + script_exp *exp = malloc (sizeof (script_exp)); + if (ne) exp->type = SCRIPT_EXP_TYPE_NE; + else exp->type = SCRIPT_EXP_TYPE_EQ; + exp->data.dual.sub_a = sub_a; + exp->data.dual.sub_b = script_parse_exp_gt (scan); + sub_a = exp; + if (!exp->data.dual.sub_b) + { + script_parse_error (ply_scan_get_current_token (scan), + "An invalid RHS of an expression"); + return NULL; } } - - return sub_a; -} + return sub_a; +} -static script_exp* script_parse_exp_an (ply_scan_t* scan) +static script_exp *script_parse_exp_an (ply_scan_t *scan) { - script_exp* sub_a = script_parse_exp_eq (scan); - if (!sub_a) return NULL; - while (1){ - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - if (peektoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - - if (curtoken->data.symbol != '&') break; - if (peektoken->data.symbol != '&') break; - if (peektoken->whitespace) break; - ply_scan_get_next_token(scan); - ply_scan_get_next_token(scan); - - script_exp* exp = malloc(sizeof(script_exp)); - exp->type = SCRIPT_EXP_TYPE_AND; - exp->data.dual.sub_a = sub_a; - exp->data.dual.sub_b = script_parse_exp_eq (scan); - sub_a = exp; - if (!exp->data.dual.sub_b){ - script_parse_error (ply_scan_get_current_token(scan), "An invalid RHS of an expression"); - return NULL; + script_exp *sub_a = script_parse_exp_eq (scan); + + if (!sub_a) return NULL; + while (1) + { + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if (peektoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if (curtoken->data.symbol != '&') break; + if (peektoken->data.symbol != '&') break; + if (peektoken->whitespace) break; + ply_scan_get_next_token (scan); + ply_scan_get_next_token (scan); + + script_exp *exp = malloc (sizeof (script_exp)); + exp->type = SCRIPT_EXP_TYPE_AND; + exp->data.dual.sub_a = sub_a; + exp->data.dual.sub_b = script_parse_exp_eq (scan); + sub_a = exp; + if (!exp->data.dual.sub_b) + { + script_parse_error (ply_scan_get_current_token (scan), + "An invalid RHS of an expression"); + return NULL; } } - - return sub_a; -} + return sub_a; +} -static script_exp* script_parse_exp_or (ply_scan_t* scan) +static script_exp *script_parse_exp_or (ply_scan_t *scan) { - script_exp* sub_a = script_parse_exp_an (scan); - if (!sub_a) return NULL; - while (1){ - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - if (peektoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; - - if (peektoken->data.symbol != '|') break; - if (curtoken->data.symbol != '|') break; - if (peektoken->whitespace) break; - ply_scan_get_next_token(scan); - ply_scan_get_next_token(scan); - - script_exp* exp = malloc(sizeof(script_exp)); - exp->type = SCRIPT_EXP_TYPE_OR; - exp->data.dual.sub_a = sub_a; - exp->data.dual.sub_b = script_parse_exp_an (scan); - sub_a = exp; - if (!exp->data.dual.sub_b){ - script_parse_error (ply_scan_get_current_token(scan), "An invalid RHS of an expression"); - return NULL; + script_exp *sub_a = script_parse_exp_an (scan); + + if (!sub_a) return NULL; + while (1) + { + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if (peektoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) break; + if (peektoken->data.symbol != '|') break; + if (curtoken->data.symbol != '|') break; + if (peektoken->whitespace) break; + ply_scan_get_next_token (scan); + ply_scan_get_next_token (scan); + + script_exp *exp = malloc (sizeof (script_exp)); + exp->type = SCRIPT_EXP_TYPE_OR; + exp->data.dual.sub_a = sub_a; + exp->data.dual.sub_b = script_parse_exp_an (scan); + sub_a = exp; + if (!exp->data.dual.sub_b) + { + script_parse_error (ply_scan_get_current_token (scan), + "An invalid RHS of an expression"); + return NULL; } } - - return sub_a; -} + return sub_a; +} -static script_exp* script_parse_exp_as (ply_scan_t* scan) +static script_exp *script_parse_exp_as (ply_scan_t *scan) { - script_exp* lhs = script_parse_exp_or (scan); - if (!lhs) return NULL; - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - ply_scan_token_t* peektoken = ply_scan_peek_next_token(scan); - bool modify_assign; - - modify_assign = !peektoken->whitespace && - curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && - peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && - peektoken->data.symbol == '='; - - if (modify_assign || (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && curtoken->data.symbol == '=')){ - script_exp_type type; - if (modify_assign) { - switch (curtoken->data.symbol){ - case '+': + script_exp *lhs = script_parse_exp_or (scan); + + if (!lhs) return NULL; + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan); + bool modify_assign; + + modify_assign = !peektoken->whitespace + && curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL + && peektoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL + && peektoken->data.symbol == '='; + + if (modify_assign + || ((curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL) + && (curtoken->data.symbol == '='))) + { + script_exp_type type; + if (modify_assign) + { + switch (curtoken->data.symbol) + { + case '+': type = SCRIPT_EXP_TYPE_ASSIGN_PLUS; break; - case '-': + + case '-': type = SCRIPT_EXP_TYPE_ASSIGN_MINUS; break; - case '*': + + case '*': type = SCRIPT_EXP_TYPE_ASSIGN_MUL; break; - case '/': + + case '/': type = SCRIPT_EXP_TYPE_ASSIGN_DIV; break; - case '%': + + case '%': type = SCRIPT_EXP_TYPE_ASSIGN_MOD; break; - default: - script_parse_error (ply_scan_get_current_token(scan), "An invalid modify assign character"); + + default: + script_parse_error (ply_scan_get_current_token (scan), + "An invalid modify assign character"); return NULL; } - ply_scan_get_next_token(scan); + ply_scan_get_next_token (scan); } - else + else type = SCRIPT_EXP_TYPE_ASSIGN; - - ply_scan_get_next_token(scan); - script_exp* rhs = script_parse_exp_as(scan); - if (!rhs){ - script_parse_error (ply_scan_get_current_token(scan), "An invalid RHS of an expression"); - return NULL; + ply_scan_get_next_token (scan); + script_exp *rhs = script_parse_exp_as (scan); + if (!rhs) + { + script_parse_error (ply_scan_get_current_token (scan), + "An invalid RHS of an expression"); + return NULL; } - script_exp* exp = malloc(sizeof(script_exp)); - exp->type = type; - exp->data.dual.sub_a = lhs; - exp->data.dual.sub_b = rhs; - return exp; + script_exp *exp = malloc (sizeof (script_exp)); + exp->type = type; + exp->data.dual.sub_a = lhs; + exp->data.dual.sub_b = rhs; + return exp; } - return lhs; + return lhs; } -static script_exp* script_parse_exp (ply_scan_t* scan) +static script_exp *script_parse_exp (ply_scan_t *scan) { - return script_parse_exp_as (scan); - + return script_parse_exp_as (scan); } -static script_op* script_parse_op_block (ply_scan_t* scan) +static script_op *script_parse_op_block (ply_scan_t *scan) { - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != '{' ) - return NULL; - - ply_scan_get_next_token(scan); - ply_list_t* sublist = script_parse_op_list (scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != '}'){ - script_parse_error (ply_scan_get_current_token(scan), "Expected a '}' to terminate the operation block"); + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != '{')) return NULL; + ply_scan_get_next_token (scan); + ply_list_t *sublist = script_parse_op_list (scan); + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != '}')) + { + script_parse_error (ply_scan_get_current_token (scan), + "Expected a '}' to terminate the operation block"); + return NULL; } - curtoken = ply_scan_get_next_token(scan); + curtoken = ply_scan_get_next_token (scan); - script_op* op = malloc(sizeof(script_op)); - op->type = SCRIPT_OP_TYPE_OP_BLOCK; - op->data.list = sublist; - return op; + script_op *op = malloc (sizeof (script_op)); + op->type = SCRIPT_OP_TYPE_OP_BLOCK; + op->data.list = sublist; + return op; } -static script_op* script_parse_if_while (ply_scan_t* scan) +static script_op *script_parse_if_while (ply_scan_t *scan) { - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - script_op_type type; - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) - return NULL; - if (!strcmp(curtoken->data.string, "if")) type = SCRIPT_OP_TYPE_IF; - else if (!strcmp(curtoken->data.string, "while")) type = SCRIPT_OP_TYPE_WHILE; - else return NULL; - - curtoken = ply_scan_get_next_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != '('){ - script_parse_error (curtoken, "Expected a '(' at the start of a condition block"); + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + script_op_type type; + + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) return NULL; + if (!strcmp (curtoken->data.string, "if")) type = SCRIPT_OP_TYPE_IF; + else if (!strcmp (curtoken->data.string, + "while")) type = SCRIPT_OP_TYPE_WHILE; + else return NULL; + curtoken = ply_scan_get_next_token (scan); + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != '(')) + { + script_parse_error (curtoken, + "Expected a '(' at the start of a condition block"); + return NULL; } - curtoken = ply_scan_get_next_token(scan); - - script_exp* cond = script_parse_exp (scan); - curtoken = ply_scan_get_current_token(scan); - if (!cond){ - script_parse_error (curtoken, "Expected a valid condition expression"); - return NULL; + curtoken = ply_scan_get_next_token (scan); + + script_exp *cond = script_parse_exp (scan); + curtoken = ply_scan_get_current_token (scan); + if (!cond) + { + script_parse_error (curtoken, "Expected a valid condition expression"); + return NULL; } - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != ')'){ - script_parse_error (curtoken, "Expected a ')' at the end of a condition block"); - return NULL; + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != ')')) + { + script_parse_error (curtoken, + "Expected a ')' at the end of a condition block"); + return NULL; } - - ply_scan_get_next_token(scan); - script_op* cond_op = script_parse_op(scan); - script_op* else_op = NULL; - - curtoken = ply_scan_get_current_token(scan); - if (type == SCRIPT_OP_TYPE_IF && - curtoken->type == PLY_SCAN_TOKEN_TYPE_IDENTIFIER && - !strcmp(curtoken->data.string, "else")){ - ply_scan_get_next_token(scan); - else_op = script_parse_op(scan); + ply_scan_get_next_token (scan); + script_op *cond_op = script_parse_op (scan); + script_op *else_op = NULL; + + curtoken = ply_scan_get_current_token (scan); + if ((type == SCRIPT_OP_TYPE_IF) + && (curtoken->type == PLY_SCAN_TOKEN_TYPE_IDENTIFIER) + && !strcmp (curtoken->data.string, "else")) + { + ply_scan_get_next_token (scan); + else_op = script_parse_op (scan); } - - - script_op* op = malloc(sizeof(script_op)); - op->type = type; - op->data.cond_op.cond = cond; - op->data.cond_op.op1 = cond_op; - op->data.cond_op.op2 = else_op; - return op; + script_op *op = malloc (sizeof (script_op)); + op->type = type; + op->data.cond_op.cond = cond; + op->data.cond_op.op1 = cond_op; + op->data.cond_op.op2 = else_op; + return op; } - -static script_op* script_parse_for (ply_scan_t* scan) +static script_op *script_parse_for (ply_scan_t *scan) { - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) - return NULL; - if (strcmp(curtoken->data.string, "for")) return NULL; - - curtoken = ply_scan_get_next_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != '('){ - script_parse_error (curtoken, "Expected a '(' at the start of a condition block"); + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) return NULL; + if (strcmp (curtoken->data.string, "for")) return NULL; + curtoken = ply_scan_get_next_token (scan); + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != '(')) + { + script_parse_error (curtoken, + "Expected a '(' at the start of a condition block"); + return NULL; } - curtoken = ply_scan_get_next_token(scan); - - script_exp* first = script_parse_exp (scan); - if (!first){ - script_parse_error (curtoken, "Expected a valid first expression"); - return NULL; + curtoken = ply_scan_get_next_token (scan); + + script_exp *first = script_parse_exp (scan); + if (!first) + { + script_parse_error (curtoken, "Expected a valid first expression"); + return NULL; } - - curtoken = ply_scan_get_current_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != ';'){ - script_parse_error (curtoken, "Expected a ';' after the first 'for' expression"); - return NULL; + curtoken = ply_scan_get_current_token (scan); + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != ';')) + { + script_parse_error (curtoken, + "Expected a ';' after the first 'for' expression"); + return NULL; } - ply_scan_get_next_token(scan); - - script_exp* cond = script_parse_exp (scan); - if (!cond){ - script_parse_error (curtoken, "Expected a valid condition expression"); - return NULL; + ply_scan_get_next_token (scan); + + script_exp *cond = script_parse_exp (scan); + if (!cond) + { + script_parse_error (curtoken, "Expected a valid condition expression"); + return NULL; } - - curtoken = ply_scan_get_current_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != ';'){ - script_parse_error (curtoken, "Expected a ';' after the 'for' condition"); - return NULL; + curtoken = ply_scan_get_current_token (scan); + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != ';')) + { + script_parse_error (curtoken, "Expected a ';' after the 'for' condition"); + return NULL; } - ply_scan_get_next_token(scan); - - script_exp* last = script_parse_exp (scan); - if (!last){ - script_parse_error (curtoken, "Expected a valid last expression"); - return NULL; + ply_scan_get_next_token (scan); + + script_exp *last = script_parse_exp (scan); + if (!last) + { + script_parse_error (curtoken, "Expected a valid last expression"); + return NULL; } - - curtoken = ply_scan_get_current_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != ')'){ - script_parse_error (curtoken, "Expected a ')' at the end of a for block"); - return NULL; + curtoken = ply_scan_get_current_token (scan); + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != ')')) + { + script_parse_error (curtoken, "Expected a ')' at the end of a for block"); + return NULL; } - ply_scan_get_next_token(scan); - script_op* op_body = script_parse_op(scan); - - - script_op* op_first = malloc(sizeof(script_op)); - op_first->type = SCRIPT_OP_TYPE_EXPRESSION; - op_first->data.exp = first; - - script_op* op_last = malloc(sizeof(script_op)); - op_last->type = SCRIPT_OP_TYPE_EXPRESSION; - op_last->data.exp = last; - - script_op* op_for = malloc(sizeof(script_op)); - op_for->type = SCRIPT_OP_TYPE_FOR; - op_for->data.cond_op.cond = cond; - op_for->data.cond_op.op1 = op_body; - op_for->data.cond_op.op2 = op_last; - - - script_op* op_block = malloc(sizeof(script_op)); - op_block->type = SCRIPT_OP_TYPE_OP_BLOCK; - op_block->data.list = ply_list_new(); - ply_list_append_data(op_block->data.list, op_first); - ply_list_append_data(op_block->data.list, op_for); - - return op_block; + ply_scan_get_next_token (scan); + script_op *op_body = script_parse_op (scan); + + script_op *op_first = malloc (sizeof (script_op)); + op_first->type = SCRIPT_OP_TYPE_EXPRESSION; + op_first->data.exp = first; + + script_op *op_last = malloc (sizeof (script_op)); + op_last->type = SCRIPT_OP_TYPE_EXPRESSION; + op_last->data.exp = last; + + script_op *op_for = malloc (sizeof (script_op)); + op_for->type = SCRIPT_OP_TYPE_FOR; + op_for->data.cond_op.cond = cond; + op_for->data.cond_op.op1 = op_body; + op_for->data.cond_op.op2 = op_last; + + script_op *op_block = malloc (sizeof (script_op)); + op_block->type = SCRIPT_OP_TYPE_OP_BLOCK; + op_block->data.list = ply_list_new (); + ply_list_append_data (op_block->data.list, op_first); + ply_list_append_data (op_block->data.list, op_for); + + return op_block; } +static script_op *script_parse_function (ply_scan_t *scan) +{ + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + ply_list_t *parameter_list; - - - -static script_op* script_parse_function (ply_scan_t* scan) -{ - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - - ply_list_t *parameter_list; - - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) - return NULL; - if (strcmp(curtoken->data.string, "fun")) return NULL; - - curtoken = ply_scan_get_next_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER){ - script_parse_error (curtoken, "A function declaration requires a valid name"); + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) return NULL; + if (strcmp (curtoken->data.string, "fun")) return NULL; + curtoken = ply_scan_get_next_token (scan); + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) + { + script_parse_error (curtoken, + "A function declaration requires a valid name"); + return NULL; } - - script_exp* name = malloc(sizeof(script_exp)); - name->type = SCRIPT_EXP_TYPE_TERM_VAR; - name->data.string = strdup(curtoken->data.string); - - curtoken = ply_scan_get_next_token(scan); - - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != '('){ - script_parse_error (curtoken, "Function declaration requires parameters to be declared within '(' brackets"); - return NULL; + script_exp *name = malloc (sizeof (script_exp)); + name->type = SCRIPT_EXP_TYPE_TERM_VAR; + name->data.string = strdup (curtoken->data.string); + + curtoken = ply_scan_get_next_token (scan); + + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != '(')) + { + script_parse_error (curtoken, + "Function declaration requires parameters to be declared within '(' brackets"); + return NULL; } - - curtoken = ply_scan_get_next_token(scan); - parameter_list = ply_list_new(); - - - while (true){ - if (curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL && curtoken->data.symbol == ')') break; - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER){ - script_parse_error (curtoken, "Function declaration parameters must be valid identifiers"); - return NULL; - } - char* parameter = strdup(curtoken->data.string); - ply_list_append_data (parameter_list, parameter); - - curtoken = ply_scan_get_next_token(scan); - - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL){ - script_parse_error (curtoken, "Function declaration parameters must separated with ',' and terminated with a ')'"); - return NULL; - } - if (curtoken->data.symbol == ')') break; - if (curtoken->data.symbol != ','){ - script_parse_error (curtoken, "Function declaration parameters must separated with ',' and terminated with a ')'"); - return NULL; - } - curtoken = ply_scan_get_next_token(scan); + curtoken = ply_scan_get_next_token (scan); + parameter_list = ply_list_new (); + + while (true) + { + if ((curtoken->type == PLY_SCAN_TOKEN_TYPE_SYMBOL) + && (curtoken->data.symbol == ')')) break; + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) + { + script_parse_error (curtoken, + "Function declaration parameters must be valid identifiers"); + return NULL; + } + char *parameter = strdup (curtoken->data.string); + ply_list_append_data (parameter_list, parameter); + + curtoken = ply_scan_get_next_token (scan); + + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + { + script_parse_error (curtoken, + "Function declaration parameters must separated with ',' and terminated with a ')'"); + return NULL; + } + if (curtoken->data.symbol == ')') break; + if (curtoken->data.symbol != ',') + { + script_parse_error (curtoken, + "Function declaration parameters must separated with ',' and terminated with a ')'"); + return NULL; + } + curtoken = ply_scan_get_next_token (scan); } - - curtoken = ply_scan_get_next_token(scan); - - script_op* func_op = script_parse_op(scan); - - - - script_op* op = malloc(sizeof(script_op)); - op->type = SCRIPT_OP_TYPE_FUNCTION_DEF; - op->data.function_def.name = name; - op->data.function_def.function = script_function_script_new(func_op, NULL, parameter_list); - return op; -} + curtoken = ply_scan_get_next_token (scan); + script_op *func_op = script_parse_op (scan); + script_op *op = malloc (sizeof (script_op)); + op->type = SCRIPT_OP_TYPE_FUNCTION_DEF; + op->data.function_def.name = name; + op->data.function_def.function = script_function_script_new (func_op, + NULL, + parameter_list); + return op; +} -static script_op* script_parse_return (ply_scan_t* scan) +static script_op *script_parse_return (ply_scan_t *scan) { - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_IDENTIFIER) return NULL; - script_op_type type; - if (!strcmp(curtoken->data.string, "return")) type = SCRIPT_OP_TYPE_RETURN; - else if (!strcmp(curtoken->data.string, "break")) type = SCRIPT_OP_TYPE_BREAK; - else if (!strcmp(curtoken->data.string, "continue")) type = SCRIPT_OP_TYPE_CONTINUE; - else return NULL; - - curtoken = ply_scan_get_next_token(scan); - - script_op* op = malloc(sizeof(script_op)); - if (type == SCRIPT_OP_TYPE_RETURN){ - op->data.exp = script_parse_exp (scan); // May be NULL - curtoken = ply_scan_get_current_token(scan); + script_op_type type; + if (!strcmp (curtoken->data.string, "return")) type = SCRIPT_OP_TYPE_RETURN; + else if (!strcmp (curtoken->data.string, "break")) type = SCRIPT_OP_TYPE_BREAK; + else if (!strcmp (curtoken->data.string, "continue")) type = SCRIPT_OP_TYPE_CONTINUE; + else return NULL; + curtoken = ply_scan_get_next_token (scan); + + script_op *op = malloc (sizeof (script_op)); + if (type == SCRIPT_OP_TYPE_RETURN) + { + op->data.exp = script_parse_exp (scan); /* May be NULL */ + curtoken = ply_scan_get_current_token (scan); } - #ifdef WITH_SEMIES - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != ';'){ - script_parse_error (curtoken, "Expected ';' after an expression"); - return NULL; + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != ';')) + { + script_parse_error (curtoken, "Expected ';' after an expression"); + return NULL; } - curtoken = ply_scan_get_next_token(scan); + curtoken = ply_scan_get_next_token (scan); #endif - op->type = type; - return op; + op->type = type; + return op; } - - - - - - - -static script_op* script_parse_op (ply_scan_t* scan) +static script_op *script_parse_op (ply_scan_t *scan) { - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - script_op* reply = NULL; - - - reply = script_parse_op_block (scan); - if (reply) return reply; - - reply = script_parse_if_while (scan); - if (reply) return reply; - - reply = script_parse_for (scan); - if (reply) return reply; - - reply = script_parse_return (scan); - if (reply) return reply; - - reply = script_parse_function (scan); - if (reply) return reply; - -// if curtoken->data.string == "if/for/while... - - -// default is expression - { - script_exp* exp = script_parse_exp(scan); + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + script_op *reply = NULL; + + reply = script_parse_op_block (scan); + if (reply) return reply; + reply = script_parse_if_while (scan); + if (reply) return reply; + reply = script_parse_for (scan); + if (reply) return reply; + reply = script_parse_return (scan); + if (reply) return reply; + reply = script_parse_function (scan); + if (reply) return reply; +/* if curtoken->data.string == "if/for/while... */ + +/* default is expression */ + { + script_exp *exp = script_parse_exp (scan); if (!exp) return NULL; - curtoken = ply_scan_get_current_token(scan); + curtoken = ply_scan_get_current_token (scan); #ifdef WITH_SEMIES - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL || curtoken->data.symbol != ';'){ + if ((curtoken->type != PLY_SCAN_TOKEN_TYPE_SYMBOL) + || (curtoken->data.symbol != ';')) + { script_parse_error (curtoken, "Expected ';' after an expression"); return NULL; - } - curtoken = ply_scan_get_next_token(scan); + } + curtoken = ply_scan_get_next_token (scan); #endif - script_op* op = malloc(sizeof(script_op)); + script_op *op = malloc (sizeof (script_op)); op->type = SCRIPT_OP_TYPE_EXPRESSION; op->data.exp = exp; return op; - } - return NULL; + } + return NULL; } -static ply_list_t* script_parse_op_list (ply_scan_t* scan) +static ply_list_t *script_parse_op_list (ply_scan_t *scan) { - ply_list_t *op_list = ply_list_new(); - - while(1){ - script_op* op = script_parse_op (scan); - if (!op) break; - ply_list_append_data (op_list, op); + ply_list_t *op_list = ply_list_new (); + + while (1) + { + script_op *op = script_parse_op (scan); + if (!op) break; + ply_list_append_data (op_list, op); } - - return op_list; + + return op_list; } -static void script_parse_exp_free (script_exp* exp) +static void script_parse_exp_free (script_exp *exp) { - if (!exp) return; - switch (exp->type){ - case SCRIPT_EXP_TYPE_PLUS: - case SCRIPT_EXP_TYPE_MINUS: - case SCRIPT_EXP_TYPE_MUL: - case SCRIPT_EXP_TYPE_DIV: - case SCRIPT_EXP_TYPE_MOD: - case SCRIPT_EXP_TYPE_EQ: - case SCRIPT_EXP_TYPE_NE: - case SCRIPT_EXP_TYPE_GT: - case SCRIPT_EXP_TYPE_GE: - case SCRIPT_EXP_TYPE_LT: - case SCRIPT_EXP_TYPE_LE: - case SCRIPT_EXP_TYPE_AND: - case SCRIPT_EXP_TYPE_OR: - case SCRIPT_EXP_TYPE_ASSIGN: - case SCRIPT_EXP_TYPE_ASSIGN_PLUS: - case SCRIPT_EXP_TYPE_ASSIGN_MINUS: - case SCRIPT_EXP_TYPE_ASSIGN_MUL: - case SCRIPT_EXP_TYPE_ASSIGN_DIV: - case SCRIPT_EXP_TYPE_ASSIGN_MOD: - case SCRIPT_EXP_TYPE_HASH: + if (!exp) return; + switch (exp->type) + { + case SCRIPT_EXP_TYPE_PLUS: + case SCRIPT_EXP_TYPE_MINUS: + case SCRIPT_EXP_TYPE_MUL: + case SCRIPT_EXP_TYPE_DIV: + case SCRIPT_EXP_TYPE_MOD: + case SCRIPT_EXP_TYPE_EQ: + case SCRIPT_EXP_TYPE_NE: + case SCRIPT_EXP_TYPE_GT: + case SCRIPT_EXP_TYPE_GE: + case SCRIPT_EXP_TYPE_LT: + case SCRIPT_EXP_TYPE_LE: + case SCRIPT_EXP_TYPE_AND: + case SCRIPT_EXP_TYPE_OR: + case SCRIPT_EXP_TYPE_ASSIGN: + case SCRIPT_EXP_TYPE_ASSIGN_PLUS: + case SCRIPT_EXP_TYPE_ASSIGN_MINUS: + case SCRIPT_EXP_TYPE_ASSIGN_MUL: + case SCRIPT_EXP_TYPE_ASSIGN_DIV: + case SCRIPT_EXP_TYPE_ASSIGN_MOD: + case SCRIPT_EXP_TYPE_HASH: script_parse_exp_free (exp->data.dual.sub_a); script_parse_exp_free (exp->data.dual.sub_b); break; - case SCRIPT_EXP_TYPE_NOT: - case SCRIPT_EXP_TYPE_POS: - case SCRIPT_EXP_TYPE_NEG: - case SCRIPT_EXP_TYPE_PRE_INC: - case SCRIPT_EXP_TYPE_PRE_DEC: - case SCRIPT_EXP_TYPE_POST_INC: - case SCRIPT_EXP_TYPE_POST_DEC: + + case SCRIPT_EXP_TYPE_NOT: + case SCRIPT_EXP_TYPE_POS: + case SCRIPT_EXP_TYPE_NEG: + case SCRIPT_EXP_TYPE_PRE_INC: + case SCRIPT_EXP_TYPE_PRE_DEC: + case SCRIPT_EXP_TYPE_POST_INC: + case SCRIPT_EXP_TYPE_POST_DEC: script_parse_exp_free (exp->data.sub); break; - case SCRIPT_EXP_TYPE_TERM_INT: - case SCRIPT_EXP_TYPE_TERM_FLOAT: - case SCRIPT_EXP_TYPE_TERM_NULL: - case SCRIPT_EXP_TYPE_TERM_LOCAL: - case SCRIPT_EXP_TYPE_TERM_GLOBAL: + + case SCRIPT_EXP_TYPE_TERM_INT: + case SCRIPT_EXP_TYPE_TERM_FLOAT: + case SCRIPT_EXP_TYPE_TERM_NULL: + case SCRIPT_EXP_TYPE_TERM_LOCAL: + case SCRIPT_EXP_TYPE_TERM_GLOBAL: break; - case SCRIPT_EXP_TYPE_FUNCTION: + + case SCRIPT_EXP_TYPE_FUNCTION: { - ply_list_node_t *node; - for (node = ply_list_get_first_node (exp->data.function.parameters); - node; - node = ply_list_get_next_node (exp->data.function.parameters, node)){ - script_exp* sub = ply_list_node_get_data (node); - script_parse_exp_free (sub); + ply_list_node_t *node; + for (node = ply_list_get_first_node (exp->data.function.parameters); + node; + node = ply_list_get_next_node (exp->data.function.parameters, node)) + { + script_exp *sub = ply_list_node_get_data (node); + script_parse_exp_free (sub); } - ply_list_free(exp->data.function.parameters); - script_parse_exp_free (exp->data.function.name); - break; + ply_list_free (exp->data.function.parameters); + script_parse_exp_free (exp->data.function.name); + break; } - case SCRIPT_EXP_TYPE_TERM_STRING: - case SCRIPT_EXP_TYPE_TERM_VAR: + + case SCRIPT_EXP_TYPE_TERM_STRING: + case SCRIPT_EXP_TYPE_TERM_VAR: free (exp->data.string); break; } - free(exp); + free (exp); } - - -void script_parse_op_free (script_op* op) +void script_parse_op_free (script_op *op) { - if (!op) return; - switch (op->type){ - case SCRIPT_OP_TYPE_EXPRESSION: + if (!op) return; + switch (op->type) + { + case SCRIPT_OP_TYPE_EXPRESSION: { - script_parse_exp_free (op->data.exp); - break; + script_parse_exp_free (op->data.exp); + break; } - case SCRIPT_OP_TYPE_OP_BLOCK: + + case SCRIPT_OP_TYPE_OP_BLOCK: { - script_parse_op_list_free (op->data.list); - break; + script_parse_op_list_free (op->data.list); + break; } - case SCRIPT_OP_TYPE_IF: - case SCRIPT_OP_TYPE_WHILE: - case SCRIPT_OP_TYPE_FOR: + + case SCRIPT_OP_TYPE_IF: + case SCRIPT_OP_TYPE_WHILE: + case SCRIPT_OP_TYPE_FOR: { - script_parse_exp_free (op->data.cond_op.cond); - script_parse_op_free (op->data.cond_op.op1); - script_parse_op_free (op->data.cond_op.op2); - break; + script_parse_exp_free (op->data.cond_op.cond); + script_parse_op_free (op->data.cond_op.op1); + script_parse_op_free (op->data.cond_op.op2); + break; } { - break; + break; } - case SCRIPT_OP_TYPE_FUNCTION_DEF: + + case SCRIPT_OP_TYPE_FUNCTION_DEF: { - if (op->data.function_def.function->type == SCRIPT_FUNCTION_TYPE_SCRIPT){ + if (op->data.function_def.function->type == + SCRIPT_FUNCTION_TYPE_SCRIPT) script_parse_op_free (op->data.function_def.function->data.script); + ply_list_node_t *node; + for (node = ply_list_get_first_node (op->data.function_def.function->parameters); + node; + node = ply_list_get_next_node (op->data.function_def.function->parameters, node)) + { + char *arg = ply_list_node_get_data (node); + free (arg); } - ply_list_node_t *node; - for (node = ply_list_get_first_node (op->data.function_def.function->parameters); - node; - node = ply_list_get_next_node (op->data.function_def.function->parameters, node)){ - char* arg = ply_list_node_get_data (node); - free(arg); - } - ply_list_free(op->data.function_def.function->parameters); - script_parse_exp_free(op->data.function_def.name); - free(op->data.function_def.function); - break; + ply_list_free (op->data.function_def.function->parameters); + script_parse_exp_free (op->data.function_def.name); + free (op->data.function_def.function); + break; } - case SCRIPT_OP_TYPE_RETURN: + + case SCRIPT_OP_TYPE_RETURN: { - if (op->data.exp) script_parse_exp_free (op->data.exp); - break; + if (op->data.exp) script_parse_exp_free (op->data.exp); + break; } - case SCRIPT_OP_TYPE_BREAK: - case SCRIPT_OP_TYPE_CONTINUE: + + case SCRIPT_OP_TYPE_BREAK: + case SCRIPT_OP_TYPE_CONTINUE: { - break; + break; } } - free(op); + free (op); } - -static void script_parse_op_list_free (ply_list_t* op_list) +static void script_parse_op_list_free (ply_list_t *op_list) { - ply_list_node_t *node; - for (node = ply_list_get_first_node (op_list); node; node = ply_list_get_next_node (op_list, node)){ - script_op* op = ply_list_node_get_data (node); - script_parse_op_free(op); + ply_list_node_t *node; + + for (node = ply_list_get_first_node (op_list); + node; + node = ply_list_get_next_node (op_list, node)) + { + script_op *op = ply_list_node_get_data (node); + script_parse_op_free (op); } - ply_list_free(op_list); - return; + ply_list_free (op_list); + return; } +script_op *script_parse_file (const char *filename) +{ + ply_scan_t *scan = ply_scan_file (filename); + if (!scan) + { + ply_error ("Parser error : Error opening file %s\n", filename); + return NULL; + } + ply_list_t *list = script_parse_op_list (scan); - -script_op* script_parse_file (const char* filename) -{ - ply_scan_t* scan = ply_scan_file (filename); - if (!scan){ - ply_error ("Parser error : Error opening file %s\n", filename); - return NULL; - } - ply_list_t* list = script_parse_op_list (scan); - - ply_scan_token_t* curtoken = ply_scan_get_current_token(scan); - if (curtoken->type != PLY_SCAN_TOKEN_TYPE_EOF){ - script_parse_error (curtoken, "Unparsed characters at end of file"); - return NULL; + ply_scan_token_t *curtoken = ply_scan_get_current_token (scan); + if (curtoken->type != PLY_SCAN_TOKEN_TYPE_EOF) + { + script_parse_error (curtoken, "Unparsed characters at end of file"); + return NULL; } - - ply_scan_free(scan); - script_op* op = malloc(sizeof(script_op)); - op->type = SCRIPT_OP_TYPE_OP_BLOCK; - op->data.list = list; - return op; + ply_scan_free (scan); + script_op *op = malloc (sizeof (script_op)); + op->type = SCRIPT_OP_TYPE_OP_BLOCK; + op->data.list = list; + return op; } - - - - - - -script_op* script_parse_string (const char* string) +script_op *script_parse_string (const char *string) { - ply_scan_t* scan = ply_scan_string (string); - if (!scan){ - ply_error ("Parser error : Error creating a parser with a string"); - return NULL; - } - ply_list_t* list = script_parse_op_list (scan); - ply_scan_free(scan); - script_op* op = malloc(sizeof(script_op)); - op->type = SCRIPT_OP_TYPE_OP_BLOCK; - op->data.list = list; - return op; -} - - - - - + ply_scan_t *scan = ply_scan_string (string); + if (!scan) + { + ply_error ("Parser error : Error creating a parser with a string"); + return NULL; + } + ply_list_t *list = script_parse_op_list (scan); + ply_scan_free (scan); + script_op *op = malloc (sizeof (script_op)); + op->type = SCRIPT_OP_TYPE_OP_BLOCK; + op->data.list = list; + return op; +} diff --git a/src/plugins/splash/script/script-parse.h b/src/plugins/splash/script/script-parse.h index 94041dc9..6ab623cf 100644 --- a/src/plugins/splash/script/script-parse.h +++ b/src/plugins/splash/script/script-parse.h @@ -24,10 +24,8 @@ #include "script.h" -script_op* script_parse_file (const char* filename); -script_op* script_parse_string (const char* string); -void script_parse_op_free (script_op* op); - - +script_op *script_parse_file (const char *filename); +script_op *script_parse_string (const char *string); +void script_parse_op_free (script_op *op); #endif /* SCRIPT_PARSE */ diff --git a/src/plugins/splash/script/script.c b/src/plugins/splash/script/script.c index 9aef592b..e5487aaa 100644 --- a/src/plugins/splash/script/script.c +++ b/src/plugins/splash/script/script.c @@ -1,4 +1,4 @@ -/* script.c - scripting system +/* script.c - scripting system * * Copyright (C) 2009 Charlie Brej * @@ -37,97 +37,109 @@ #include "script-parse.h" #include "script-object.h" - - - -script_function* script_function_script_new(script_op* script, void* user_data, ply_list_t* parameter_list) +script_function *script_function_script_new (script_op *script, + void *user_data, + ply_list_t *parameter_list) { - script_function* function = malloc(sizeof(script_function)); - function->type = SCRIPT_FUNCTION_TYPE_SCRIPT; - function->parameters = parameter_list; - function->data.script = script; - function->freeable = false; - function->user_data = user_data; - return function; + script_function *function = malloc (sizeof (script_function)); + + function->type = SCRIPT_FUNCTION_TYPE_SCRIPT; + function->parameters = parameter_list; + function->data.script = script; + function->freeable = false; + function->user_data = user_data; + return function; } -script_function* script_function_native_new(script_native_function native_function, void* user_data, ply_list_t* parameter_list) +script_function *script_function_native_new ( + script_native_function native_function, + void *user_data, + ply_list_t * + parameter_list) { - script_function* function = malloc(sizeof(script_function)); - function->type = SCRIPT_FUNCTION_TYPE_NATIVE; - function->parameters = parameter_list; - function->data.native = native_function; - function->freeable = true; - function->user_data = user_data; - return function; + script_function *function = malloc (sizeof (script_function)); + + function->type = SCRIPT_FUNCTION_TYPE_NATIVE; + function->parameters = parameter_list; + function->data.native = native_function; + function->freeable = true; + function->user_data = user_data; + return function; } -void script_add_native_function (script_obj *hash, const char* name, script_native_function native_function, void* user_data, const char* first_arg, ...) +void script_add_native_function (script_obj *hash, + const char *name, + script_native_function native_function, + void *user_data, + const char *first_arg, + ...) { - va_list args; - const char* arg; - ply_list_t *parameter_list = ply_list_new(); - - arg = first_arg; - va_start (args, first_arg); - while (arg){ - ply_list_append_data (parameter_list, strdup(arg)); - arg = va_arg (args, const char*); + va_list args; + const char *arg; + ply_list_t *parameter_list = ply_list_new (); + + arg = first_arg; + va_start (args, first_arg); + while (arg) + { + ply_list_append_data (parameter_list, strdup (arg)); + arg = va_arg (args, const char *); } - va_end (args); - - script_function* function = script_function_native_new(native_function, user_data, parameter_list); - script_obj* obj = script_obj_new_function (function); - script_obj_hash_add_element (hash, obj, name); - script_obj_unref(obj); + va_end (args); + + script_function *function = script_function_native_new (native_function, + user_data, + parameter_list); + script_obj *obj = script_obj_new_function (function); + script_obj_hash_add_element (hash, obj, name); + script_obj_unref (obj); } - -script_obj_native_class* script_obj_native_class_new(script_obj_function free_func, const char* name, void* user_data) +script_obj_native_class *script_obj_native_class_new (script_obj_function free_func, + const char *name, + void *user_data) { - script_obj_native_class* class = malloc(sizeof(script_obj_native_class)); - class->free_func = free_func; - class->name = strdup(name); - class->user_data = user_data; - return class; -} - + script_obj_native_class *class = malloc (sizeof (script_obj_native_class)); + class->free_func = free_func; + class->name = strdup (name); + class->user_data = user_data; + return class; +} -void script_obj_native_class_destroy(script_obj_native_class* class) +void script_obj_native_class_destroy (script_obj_native_class *class) { - free(class->name); - free(class); - return; + free (class->name); + free (class); + return; } -script_state* script_state_new(void* user_data) +script_state *script_state_new (void *user_data) { - script_state* state = malloc(sizeof(script_state)); - state->global = script_obj_new_hash(); - script_obj_ref(state->global); - state->local = state->global; - state->user_data = user_data; - return state; + script_state *state = malloc (sizeof (script_state)); + + state->global = script_obj_new_hash (); + script_obj_ref (state->global); + state->local = state->global; + state->user_data = user_data; + return state; } -script_state* script_state_init_sub(script_state* oldstate) +script_state *script_state_init_sub (script_state *oldstate) { - script_state* newstate = malloc(sizeof(script_state)); - newstate->global = oldstate->global; - script_obj_ref(newstate->global); - newstate->local = script_obj_new_hash(); - newstate->user_data = oldstate->user_data; - return newstate; + script_state *newstate = malloc (sizeof (script_state)); + + newstate->global = oldstate->global; + script_obj_ref (newstate->global); + newstate->local = script_obj_new_hash (); + newstate->user_data = oldstate->user_data; + return newstate; } -void script_state_destroy(script_state* state) +void script_state_destroy (script_state *state) { - script_obj_unref(state->global); - script_obj_unref(state->local); - free(state); + script_obj_unref (state->global); + script_obj_unref (state->local); + free (state); } - - - diff --git a/src/plugins/splash/script/script.h b/src/plugins/splash/script/script.h index f6826700..f7a76c2b 100644 --- a/src/plugins/splash/script/script.h +++ b/src/plugins/splash/script/script.h @@ -22,212 +22,221 @@ #ifndef SCRIPT_H #define SCRIPT_H - #include "ply-hashtable.h" #include "ply-list.h" #include "ply-scan.h" - -typedef enum // FIXME add _t to all types +typedef enum /* FIXME add _t to all types */ { - SCRIPT_RETURN_TYPE_NORMAL, - SCRIPT_RETURN_TYPE_RETURN, - SCRIPT_RETURN_TYPE_BREAK, - SCRIPT_RETURN_TYPE_CONTINUE, + SCRIPT_RETURN_TYPE_NORMAL, + SCRIPT_RETURN_TYPE_RETURN, + SCRIPT_RETURN_TYPE_BREAK, + SCRIPT_RETURN_TYPE_CONTINUE, } script_return_type; struct script_obj; -typedef struct +typedef struct { - script_return_type type; - struct script_obj* object; + script_return_type type; + struct script_obj *object; } script_return; -typedef struct +typedef struct { - void* user_data; - struct script_obj* global; - struct script_obj* local; + void *user_data; + struct script_obj *global; + struct script_obj *local; } script_state; - typedef enum { - SCRIPT_FUNCTION_TYPE_SCRIPT, - SCRIPT_FUNCTION_TYPE_NATIVE, + SCRIPT_FUNCTION_TYPE_SCRIPT, + SCRIPT_FUNCTION_TYPE_NATIVE, } script_function_type; - -typedef script_return (*script_native_function) (script_state*, void*); +typedef script_return (*script_native_function)(script_state *, void *); typedef struct script_function { - script_function_type type; - ply_list_t* parameters; // list of char* typedef names - void * user_data; - union - { + script_function_type type; + ply_list_t *parameters; /* list of char* typedef names */ + void *user_data; + union + { script_native_function native; - struct script_op* script; - }data; - bool freeable; + struct script_op *script; + } data; + bool freeable; } script_function; -typedef void (*script_obj_function) (struct script_obj*); +typedef void (*script_obj_function)(struct script_obj *); typedef struct { - script_obj_function free_func; - char* name; - void* user_data; + script_obj_function free_func; + char *name; + void *user_data; } script_obj_native_class; typedef struct { - void* object_data; - script_obj_native_class* class; + void *object_data; + script_obj_native_class *class; } script_obj_native; typedef enum { - SCRIPT_OBJ_TYPE_NULL, - SCRIPT_OBJ_TYPE_REF, - SCRIPT_OBJ_TYPE_INT, - SCRIPT_OBJ_TYPE_FLOAT, - SCRIPT_OBJ_TYPE_STRING, - SCRIPT_OBJ_TYPE_HASH, - SCRIPT_OBJ_TYPE_FUNCTION, - SCRIPT_OBJ_TYPE_NATIVE, + SCRIPT_OBJ_TYPE_NULL, + SCRIPT_OBJ_TYPE_REF, + SCRIPT_OBJ_TYPE_INT, + SCRIPT_OBJ_TYPE_FLOAT, + SCRIPT_OBJ_TYPE_STRING, + SCRIPT_OBJ_TYPE_HASH, + SCRIPT_OBJ_TYPE_FUNCTION, + SCRIPT_OBJ_TYPE_NATIVE, } script_obj_type; typedef struct script_obj { - script_obj_type type; - int refcount; - union - { + script_obj_type type; + int refcount; + union + { int integer; float floatpoint; - char* string; - struct script_obj* obj; - script_function* function; - ply_hashtable_t* hash; + char *string; + struct script_obj *obj; + script_function *function; + ply_hashtable_t *hash; script_obj_native native; - } data; + } data; } script_obj; - - typedef enum { - SCRIPT_EXP_TYPE_TERM_NULL, - SCRIPT_EXP_TYPE_TERM_INT, - SCRIPT_EXP_TYPE_TERM_FLOAT, - SCRIPT_EXP_TYPE_TERM_STRING, - SCRIPT_EXP_TYPE_TERM_VAR, - SCRIPT_EXP_TYPE_TERM_LOCAL, - SCRIPT_EXP_TYPE_TERM_GLOBAL, - SCRIPT_EXP_TYPE_PLUS, - SCRIPT_EXP_TYPE_MINUS, - SCRIPT_EXP_TYPE_MUL, - SCRIPT_EXP_TYPE_DIV, - SCRIPT_EXP_TYPE_MOD, - SCRIPT_EXP_TYPE_GT, - SCRIPT_EXP_TYPE_GE, - SCRIPT_EXP_TYPE_LT, - SCRIPT_EXP_TYPE_LE, - SCRIPT_EXP_TYPE_EQ, - SCRIPT_EXP_TYPE_NE, - SCRIPT_EXP_TYPE_AND, - SCRIPT_EXP_TYPE_OR, - SCRIPT_EXP_TYPE_NOT, - SCRIPT_EXP_TYPE_POS, - SCRIPT_EXP_TYPE_NEG, - SCRIPT_EXP_TYPE_PRE_INC, - SCRIPT_EXP_TYPE_PRE_DEC, - SCRIPT_EXP_TYPE_POST_INC, - SCRIPT_EXP_TYPE_POST_DEC, - SCRIPT_EXP_TYPE_HASH, - SCRIPT_EXP_TYPE_FUNCTION, - SCRIPT_EXP_TYPE_ASSIGN, - SCRIPT_EXP_TYPE_ASSIGN_PLUS, - SCRIPT_EXP_TYPE_ASSIGN_MINUS, - SCRIPT_EXP_TYPE_ASSIGN_MUL, - SCRIPT_EXP_TYPE_ASSIGN_DIV, - SCRIPT_EXP_TYPE_ASSIGN_MOD, + SCRIPT_EXP_TYPE_TERM_NULL, + SCRIPT_EXP_TYPE_TERM_INT, + SCRIPT_EXP_TYPE_TERM_FLOAT, + SCRIPT_EXP_TYPE_TERM_STRING, + SCRIPT_EXP_TYPE_TERM_VAR, + SCRIPT_EXP_TYPE_TERM_LOCAL, + SCRIPT_EXP_TYPE_TERM_GLOBAL, + SCRIPT_EXP_TYPE_PLUS, + SCRIPT_EXP_TYPE_MINUS, + SCRIPT_EXP_TYPE_MUL, + SCRIPT_EXP_TYPE_DIV, + SCRIPT_EXP_TYPE_MOD, + SCRIPT_EXP_TYPE_GT, + SCRIPT_EXP_TYPE_GE, + SCRIPT_EXP_TYPE_LT, + SCRIPT_EXP_TYPE_LE, + SCRIPT_EXP_TYPE_EQ, + SCRIPT_EXP_TYPE_NE, + SCRIPT_EXP_TYPE_AND, + SCRIPT_EXP_TYPE_OR, + SCRIPT_EXP_TYPE_NOT, + SCRIPT_EXP_TYPE_POS, + SCRIPT_EXP_TYPE_NEG, + SCRIPT_EXP_TYPE_PRE_INC, + SCRIPT_EXP_TYPE_PRE_DEC, + SCRIPT_EXP_TYPE_POST_INC, + SCRIPT_EXP_TYPE_POST_DEC, + SCRIPT_EXP_TYPE_HASH, + SCRIPT_EXP_TYPE_FUNCTION, + SCRIPT_EXP_TYPE_ASSIGN, + SCRIPT_EXP_TYPE_ASSIGN_PLUS, + SCRIPT_EXP_TYPE_ASSIGN_MINUS, + SCRIPT_EXP_TYPE_ASSIGN_MUL, + SCRIPT_EXP_TYPE_ASSIGN_DIV, + SCRIPT_EXP_TYPE_ASSIGN_MOD, } script_exp_type; - typedef struct script_exp { - script_exp_type type; - union - { - struct { - struct script_exp* sub_a; - struct script_exp* sub_b; - } dual; + script_exp_type type; + union + { + struct + { + struct script_exp *sub_a; + struct script_exp *sub_b; + } dual; struct script_exp *sub; - char* string; - int integer; + char *string; + int integer; float floatpoint; - struct { - struct script_exp* name; - ply_list_t* parameters; - } function; - } data; + struct + { + struct script_exp *name; + ply_list_t *parameters; + } function; + } data; } script_exp; - - - typedef enum { - SCRIPT_OP_TYPE_EXPRESSION, - SCRIPT_OP_TYPE_OP_BLOCK, - SCRIPT_OP_TYPE_IF, - SCRIPT_OP_TYPE_WHILE, - SCRIPT_OP_TYPE_FOR, - SCRIPT_OP_TYPE_FUNCTION_DEF, - SCRIPT_OP_TYPE_RETURN, - SCRIPT_OP_TYPE_BREAK, - SCRIPT_OP_TYPE_CONTINUE, + SCRIPT_OP_TYPE_EXPRESSION, + SCRIPT_OP_TYPE_OP_BLOCK, + SCRIPT_OP_TYPE_IF, + SCRIPT_OP_TYPE_WHILE, + SCRIPT_OP_TYPE_FOR, + SCRIPT_OP_TYPE_FUNCTION_DEF, + SCRIPT_OP_TYPE_RETURN, + SCRIPT_OP_TYPE_BREAK, + SCRIPT_OP_TYPE_CONTINUE, } script_op_type; typedef struct script_op { - script_op_type type; - union - { - script_exp* exp; - ply_list_t* list; - struct { - script_exp* cond; - struct script_op* op1; - struct script_op* op2; - } cond_op; - struct { - script_exp* name; - script_function* function; - } function_def; - } data; + script_op_type type; + union + { + script_exp *exp; + ply_list_t *list; + struct + { + script_exp *cond; + struct script_op *op1; + struct script_op *op2; + } cond_op; + struct + { + script_exp *name; + script_function *function; + } function_def; + } data; } script_op; - -typedef struct +typedef struct { - char* name; - script_obj* object; + char *name; + script_obj *object; } script_vareable; -script_function* script_function_script_new(script_op* script, void* user_data, ply_list_t* parameter_list); -script_function* script_function_native_new(script_native_function native_function, void* user_data, ply_list_t* parameter_list); -void script_add_native_function (script_obj *hash, const char* name, script_native_function native_function, void* user_data, const char* first_arg, ...); -script_obj_native_class* script_obj_native_class_new(script_obj_function free_func, const char* name, void* user_data); -void script_obj_native_class_destroy(script_obj_native_class* class); -script_state* script_state_new(void* user_data); -script_state* script_state_init_sub(script_state* oldstate); -void script_state_destroy(script_state* state); +script_function *script_function_script_new (script_op *script, + void *user_data, + ply_list_t *parameter_list); +script_function *script_function_native_new ( + script_native_function native_function, + void *user_data, + ply_list_t * + parameter_list); +void script_add_native_function (script_obj *hash, + const char *name, + script_native_function native_function, + void *user_data, + const char *first_arg, + ...); +script_obj_native_class *script_obj_native_class_new ( + script_obj_function free_func, + const char *name, + void * + user_data); + +void script_obj_native_class_destroy (script_obj_native_class * class ); +script_state *script_state_new (void *user_data); +script_state *script_state_init_sub (script_state *oldstate); +void script_state_destroy (script_state *state); #endif /* SCRIPT_H */ diff --git a/src/plugins/splash/script/~script-lib-plymouth.c b/src/plugins/splash/script/~script-lib-plymouth.c new file mode 100644 index 00000000..512b140b --- /dev/null +++ b/src/plugins/splash/script/~script-lib-plymouth.c @@ -0,0 +1,293 @@ +/* script-lib-plymouth.c - script library for interacting with plymouth + * + * Copyright (C) 2009 Charlie Brej + * + * 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 2, 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Written by: Charlie Brej + */ +#define _GNU_SOURCE +#include "ply-utils.h" +#include "script.h" +#include "script-parse.h" +#include "script-execute.h" +#include "script-object.h" +#include "script-lib-plymouth.h" +#include +#include +#include +#include + +#include "config.h" + +#define STRINGIFY_VAR script_lib_plymouth_string + +#include "script-lib-plymouth.string" + +static script_return plymouth_set_function (script_state *state, + void *user_data) +{ + script_obj **script_func = user_data; + script_obj *obj = script_obj_hash_get_element (state->local, "function"); + + script_obj_deref (&obj); + script_obj_unref (*script_func); + + if (obj->type == SCRIPT_OBJ_TYPE_FUNCTION) + *script_func = obj; + else + { + *script_func = NULL; + script_obj_unref (obj); + } + return (script_return) { + SCRIPT_RETURN_TYPE_RETURN, script_obj_new_null () + }; +} + +script_lib_plymouth_data_t *script_lib_plymouth_setup (script_state *state) +{ + script_lib_plymouth_data_t *data = malloc (sizeof (script_lib_plymouth_data_t)); + + data->script_refresh_func = NULL; + data->script_boot_progress_func = NULL; + data->script_root_mounted_func = NULL; + data->script_keyboard_input_func = NULL; + data->script_update_status_func = NULL; + data->script_display_normal_func = NULL; + data->script_display_password_func = NULL; + data->script_display_question_func = NULL; + + script_add_native_function (state->global, + "PlymouthSetRefreshFunction", + plymouth_set_function, + &data->script_refresh_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetBootProgressFunction", + plymouth_set_function, + &data->script_boot_progress_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetRootMountedFunction", + plymouth_set_function, + &data->script_root_mounted_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetKeyboardInputFunction", + plymouth_set_function, + &data->script_keyboard_input_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetUpdateStatusFunction", + plymouth_set_function, + &data->script_update_status_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetDisplayNormalFunction", + plymouth_set_function, + &data->script_display_normal_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetDisplayPasswordFunction", + plymouth_set_function, + &data->script_display_password_func, + "function", + NULL); + script_add_native_function (state->global, + "PlymouthSetDisplayQuestionFunction", + plymouth_set_function, + &data->script_display_question_func, + "function", + NULL); + data->script_main_op = script_parse_string (script_lib_plymouth_string); + script_return ret = script_execute (state, data->script_main_op); + script_obj_unref (ret.object); /* Throw anything sent back away */ + + return data; +} + +void script_lib_plymouth_destroy (script_lib_plymouth_data_t *data) +{ + script_parse_op_free (data->script_main_op); + script_obj_unref (data->script_refresh_func); + script_obj_unref (data->script_boot_progress_func); + script_obj_unref (data->script_root_mounted_func); + script_obj_unref (data->script_keyboard_input_func); + script_obj_unref (data->script_update_status_func); + script_obj_unref (data->script_display_normal_func); + script_obj_unref (data->script_display_password_func); + script_obj_unref (data->script_display_question_func); + free (data); +} + +void script_lib_plymouth_on_refresh (script_state *state, + script_lib_plymouth_data_t *data) +{ + script_obj *refresh_func_obj = data->script_refresh_func; + + if (refresh_func_obj + && (refresh_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_return ret = script_execute_function (state, + refresh_func_obj->data.function, + NULL); + script_obj_unref (ret.object); + } +} + +void script_lib_plymouth_on_boot_progress (script_state *state, + script_lib_plymouth_data_t *data, + float duration, + float progress) +{ + script_obj *boot_progress_func_obj = data->script_boot_progress_func; + + if (boot_progress_func_obj + && (boot_progress_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *duration_obj = script_obj_new_float (duration); + script_obj *progress_obj = script_obj_new_float (progress); + script_return ret = script_execute_function (state, + boot_progress_func_obj->data.function, + duration_obj, + progress_obj, + NULL); + script_obj_unref (ret.object); + script_obj_unref (duration_obj); + script_obj_unref (progress_obj); + } +} + +void script_lib_plymouth_on_root_mounted (script_state *state, + script_lib_plymouth_data_t *data) +{ + script_obj *root_mounted_func_obj = data->script_root_mounted_func; + + if (root_mounted_func_obj + && (root_mounted_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_return ret = script_execute_function (state, + root_mounted_func_obj->data.function, + NULL); + script_obj_unref (ret.object); + } +} + +void script_lib_plymouth_on_keyboard_input (script_state *state, + script_lib_plymouth_data_t *data, + const char *keyboard_input) +{ + script_obj *keyboard_input_func_obj = data->script_keyboard_input_func; + + if (keyboard_input_func_obj + && (keyboard_input_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *keyboard_input_obj = script_obj_new_string (keyboard_input); + script_return ret = script_execute_function (state, + keyboard_input_func_obj->data.function, + keyboard_input_obj, + NULL); + script_obj_unref (keyboard_input_obj); + script_obj_unref (ret.object); + } +} + +void script_lib_plymouth_on_update_status (script_state *state, + script_lib_plymouth_data_t *data, + const char *new_status) +{ + script_obj *update_status_func_obj = data->script_update_status_func; + + if (update_status_func_obj + && (update_status_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *new_status_obj = script_obj_new_string (new_status); + script_return ret = script_execute_function (state, + update_status_func_obj->data.function, + new_status_obj, + NULL); + script_obj_unref (new_status_obj); + script_obj_unref (ret.object); + } +} + +void script_lib_plymouth_on_display_normal (script_state *state, + script_lib_plymouth_data_t *data) +{ + script_obj *display_normal_func_obj = data->script_display_normal_func; + + if (display_normal_func_obj + && (display_normal_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_return ret = script_execute_function (state, + display_normal_func_obj->data.function, + NULL); + script_obj_unref (ret.object); + } +} + +void script_lib_plymouth_on_display_password (script_state *state, + script_lib_plymouth_data_t *data, + const char *prompt, + int bullets) +{ + script_obj *display_password_func_obj = data->script_display_password_func; + + if (display_password_func_obj + && (display_password_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *prompt_obj = script_obj_new_string (prompt); + script_obj *bullets_obj = script_obj_new_int (bullets); + script_return ret = script_execute_function (state, + display_password_func_obj->data.function, + prompt_obj, + bullets_obj, + NULL); + script_obj_unref (prompt_obj); + script_obj_unref (bullets_obj); + script_obj_unref (ret.object); + } +} + +void script_lib_plymouth_on_display_question (script_state *state, + script_lib_plymouth_data_t *data, + const char *prompt, + const char *entry_text) +{ + script_obj *display_question_func_obj = data->script_display_question_func; + + if (display_question_func_obj + && (display_question_func_obj->type == SCRIPT_OBJ_TYPE_FUNCTION)) + { + script_obj *prompt_obj = script_obj_new_string (prompt); + script_obj *entry_text_obj = script_obj_new_string (entry_text); + script_return ret = script_execute_function (state, + display_question_func_obj->data.function, + prompt_obj, + entry_text_obj, + NULL); + script_obj_unref (prompt_obj); + script_obj_unref (entry_text_obj); + script_obj_unref (ret.object); + } +}