Uncrustify did a reasonable job and only needed minor fixups.
#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;
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;
}
{
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);
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);
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;
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
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,
int y,
int width,
int height)
-{
-}
+{}
void
on_erase (ply_boot_splash_plugin_t *plugin,
int y,
int width,
int height)
-{
-}
+{}
static void
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
ply_event_loop_watch_signal (plugin->loop,
SIGINT,
- (ply_event_handler_t)
+ (ply_event_handler_t)
on_interrupt, plugin);
ply_trace ("setting graphics mode");
ply_trace ("starting boot animation");
return start_animation (plugin);
-
}
void
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
{
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);
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
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
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
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;
}
+/* plugin.h - boot script plugin
+ *
+ * Copyright (C) 2007, 2008 Red Hat, Inc.
+ * 2008, 2009 Charlie Brej <cbrej@cs.man.ac.uk>
+ *
+ * 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 <cbrej@cs.man.ac.uk>
+ * Ray Strode <rstrode@redhat.com>
+ */
#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; i<scan->tokencount; 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);
}
-
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;
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 */
#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;
}
-
-
#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 */
#include "script-object.h"
#include "script-parse.h"
#include "script-execute.h"
-#include "script-lib-image.h"
+#include "script-lib-image.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#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);
}
-
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 */
#include "script-parse.h"
#include "script-execute.h"
#include "script-object.h"
-#include "script-lib-math.h"
+#include "script-lib-math.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#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);
}
+
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 */
#include "script-parse.h"
#include "script-execute.h"
#include "script-object.h"
-#include "script-lib-plymouth.h"
+#include "script-lib-plymouth.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#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);
}
}
-
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 */
#include <stdlib.h>
#include <math.h>
-
#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);
+}
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 */
#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 ();
}
+
#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 */
#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;
+}
#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 */
-/* script.c - scripting system
+/* script.c - scripting system
*
* Copyright (C) 2009 Charlie Brej <cbrej@cs.man.ac.uk>
*
#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);
}
-
-
-
#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 */
--- /dev/null
+/* script-lib-plymouth.c - script library for interacting with plymouth
+ *
+ * Copyright (C) 2009 Charlie Brej <cbrej@cs.man.ac.uk>
+ *
+ * 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 <cbrej@cs.man.ac.uk>
+ */
+#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 <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#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);
+ }
+}
projects / thirdparty / plymouth.git / commitdiff
