* Written by: Charlie Brej <cbrej@cs.man.ac.uk>
*/
#define _GNU_SOURCE
-#include "ply-scan.h"
#include "ply-hashtable.h"
#include "ply-list.h"
#include "ply-bitarray.h"
#include <stdbool.h>
#include "script.h"
+#include "script-scan.h"
#include "script-parse.h"
#define WITH_SEMIES
int presedence;
}script_parse_operator_table_entry_t;
-static script_op_t *script_parse_op (ply_scan_t *scan);
-static script_exp_t *script_parse_exp (ply_scan_t *scan);
-static ply_list_t *script_parse_op_list (ply_scan_t *scan);
+static script_op_t *script_parse_op (script_scan_t *scan);
+static script_exp_t *script_parse_exp (script_scan_t *scan);
+static ply_list_t *script_parse_op_list (script_scan_t *scan);
static void script_parse_op_list_free (ply_list_t *op_list);
static script_exp_t *script_parse_new_exp_single (script_exp_type_t type,
return exp;
}
-static void script_parse_error (ply_scan_token_t *token,
+static void script_parse_error (script_scan_token_t *token,
const char *expected)
{
ply_error ("Parser error L:%d C:%d : %s\n",
}
static const script_parse_operator_table_entry_t* /* Only allows 1 or 2 character symbols */
-script_parse_operator_table_entry_lookup (ply_scan_t *scan,
+script_parse_operator_table_entry_lookup (script_scan_t *scan,
const script_parse_operator_table_entry_t *table)
{
int entry_index;
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
- ply_scan_token_t *peektoken = ply_scan_peek_next_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
+ script_scan_token_t *peektoken = script_scan_peek_next_token (scan);
for (entry_index = 0; table[entry_index].symbol; entry_index++)
{
- if (!ply_scan_token_is_symbol (curtoken)) continue;
+ if (!script_scan_token_is_symbol (curtoken)) continue;
if (curtoken->data.symbol != table[entry_index].symbol[0]) continue;
if (table[entry_index].symbol[1])
{
- if (!ply_scan_token_is_symbol (peektoken)) continue;
+ if (!script_scan_token_is_symbol (peektoken)) continue;
if (peektoken->data.symbol != table[entry_index].symbol[1]) continue;
if (peektoken->whitespace) continue;
}
return &table[entry_index];
}
-static void script_parse_advance_scan_by_string (ply_scan_t *scan,
+static void script_parse_advance_scan_by_string (script_scan_t *scan,
const char *string)
{
while (*string)
{
- ply_scan_get_next_token(scan);
+ script_scan_get_next_token(scan);
string++;
}
}
-static script_function_t *script_parse_function_def (ply_scan_t *scan)
+static script_function_t *script_parse_function_def (script_scan_t *scan)
{
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
ply_list_t *parameter_list;
- if (!ply_scan_token_is_symbol_of_value (curtoken, '('))
+ if (!script_scan_token_is_symbol_of_value (curtoken, '('))
{
script_parse_error (curtoken,
"Function declaration requires parameters to be declared within '(' brackets");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
parameter_list = ply_list_new ();
while (true)
{
- if (ply_scan_token_is_symbol_of_value (curtoken, ')')) break;
- if (!ply_scan_token_is_identifier (curtoken))
+ if (script_scan_token_is_symbol_of_value (curtoken, ')')) break;
+ if (!script_scan_token_is_identifier (curtoken))
{
script_parse_error (curtoken,
"Function declaration parameters must be valid identifiers");
char *parameter = strdup (curtoken->data.string);
ply_list_append_data (parameter_list, parameter);
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
- if (ply_scan_token_is_symbol_of_value (curtoken, ')')) break;
- if (!ply_scan_token_is_symbol_of_value (curtoken, ','))
+ if (script_scan_token_is_symbol_of_value (curtoken, ')')) break;
+ if (!script_scan_token_is_symbol_of_value (curtoken, ','))
{
script_parse_error (curtoken,
"Function declaration parameters must separated with ',' and terminated with a ')'");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
script_op_t *func_op = script_parse_op (scan);
return function;
}
-static script_exp_t *script_parse_exp_tm (ply_scan_t *scan)
+static script_exp_t *script_parse_exp_tm (script_scan_t *scan)
{
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
script_exp_t *exp = NULL;
- if (ply_scan_token_is_integer (curtoken))
+ if (script_scan_token_is_integer (curtoken))
{
exp = malloc (sizeof (script_exp_t));
exp->type = SCRIPT_EXP_TYPE_TERM_INT;
exp->data.integer = curtoken->data.integer;
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
return exp;
}
- if (ply_scan_token_is_float (curtoken))
+ if (script_scan_token_is_float (curtoken))
{
exp = malloc (sizeof (script_exp_t));
exp->type = SCRIPT_EXP_TYPE_TERM_FLOAT;
exp->data.floatpoint = curtoken->data.floatpoint;
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
return exp;
}
- if (ply_scan_token_is_identifier (curtoken))
+ if (script_scan_token_is_identifier (curtoken))
{
exp = malloc (sizeof (script_exp_t));
- if (ply_scan_token_is_identifier_of_value (curtoken, "NULL"))
+ if (script_scan_token_is_identifier_of_value (curtoken, "NULL"))
exp->type = SCRIPT_EXP_TYPE_TERM_NULL;
- else if (ply_scan_token_is_identifier_of_value (curtoken, "global"))
+ else if (script_scan_token_is_identifier_of_value (curtoken, "global"))
exp->type = SCRIPT_EXP_TYPE_TERM_GLOBAL;
- else if (ply_scan_token_is_identifier_of_value (curtoken, "local"))
+ else if (script_scan_token_is_identifier_of_value (curtoken, "local"))
exp->type = SCRIPT_EXP_TYPE_TERM_LOCAL;
- else if (ply_scan_token_is_identifier_of_value (curtoken, "fun"))
+ else if (script_scan_token_is_identifier_of_value (curtoken, "fun"))
{
exp->type = SCRIPT_EXP_TYPE_FUNCTION_DEF;
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
exp->data.function_def = script_parse_function_def (scan);
return exp;
}
exp->type = SCRIPT_EXP_TYPE_TERM_VAR;
exp->data.string = strdup (curtoken->data.string);
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
return exp;
}
- if (ply_scan_token_is_string (curtoken))
+ if (script_scan_token_is_string (curtoken))
{
exp = malloc (sizeof (script_exp_t));
exp->type = SCRIPT_EXP_TYPE_TERM_STRING;
exp->data.string = strdup (curtoken->data.string);
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
return exp;
}
- if (ply_scan_token_is_symbol_of_value (curtoken, '('))
+ if (script_scan_token_is_symbol_of_value (curtoken, '('))
{
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
exp = script_parse_exp (scan);
- curtoken = ply_scan_get_current_token (scan);
+ curtoken = script_scan_get_current_token (scan);
if (!exp)
{
script_parse_error (curtoken,
"Expected valid contents of bracketed expression");
return NULL;
}
- if (!ply_scan_token_is_symbol_of_value (curtoken, ')'))
+ if (!script_scan_token_is_symbol_of_value (curtoken, ')'))
{
script_parse_error (curtoken,
"Expected bracketed block to be terminated with a ')'");
return NULL;
}
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
return exp;
}
return NULL;
}
-static script_exp_t *script_parse_exp_pi (ply_scan_t *scan)
+static script_exp_t *script_parse_exp_pi (script_scan_t *scan)
{
script_exp_t *exp = script_parse_exp_tm (scan);
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
while (true)
{
- if (!ply_scan_token_is_symbol (curtoken)) break;
- if (ply_scan_token_is_symbol_of_value (curtoken, '('))
+ if (!script_scan_token_is_symbol (curtoken)) break;
+ if (script_scan_token_is_symbol_of_value (curtoken, '('))
{
script_exp_t *func = malloc (sizeof (script_exp_t));
ply_list_t *parameters = ply_list_new ();
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
while (true)
{
- if (ply_scan_token_is_symbol_of_value (curtoken, ')')) break;
+ if (script_scan_token_is_symbol_of_value (curtoken, ')')) break;
script_exp_t *parameter = script_parse_exp (scan);
ply_list_append_data (parameters, parameter);
- curtoken = ply_scan_get_current_token (scan);
- if (ply_scan_token_is_symbol_of_value (curtoken, ')')) break;
- if (!ply_scan_token_is_symbol_of_value (curtoken, ','))
+ curtoken = script_scan_get_current_token (scan);
+ if (script_scan_token_is_symbol_of_value (curtoken, ')')) break;
+ if (!script_scan_token_is_symbol_of_value (curtoken, ','))
{
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 = script_scan_get_next_token (scan);
}
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
func->data.function_exe.name = exp;
exp = func;
exp->type = SCRIPT_EXP_TYPE_FUNCTION_EXE;
}
script_exp_t *key;
- if (ply_scan_token_is_symbol_of_value (curtoken, '.'))
+ if (script_scan_token_is_symbol_of_value (curtoken, '.'))
{
- ply_scan_get_next_token (scan);
- if (ply_scan_token_is_identifier (curtoken))
+ script_scan_get_next_token (scan);
+ if (script_scan_token_is_identifier (curtoken))
{
key = malloc (sizeof (script_exp_t));
key->type = SCRIPT_EXP_TYPE_TERM_STRING;
key->data.string = strdup (curtoken->data.string);
}
- else if (ply_scan_token_is_integer (curtoken)) /* errrr, integer keys without being [] bracketed */
+ else if (script_scan_token_is_integer (curtoken)) /* errrr, integer keys without being [] bracketed */
{
key = malloc (sizeof (script_exp_t)); /* 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;
"A dot based hash index must be an identifier (or a integer)");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
}
- else if (ply_scan_token_is_symbol_of_value (curtoken, '['))
+ else if (script_scan_token_is_symbol_of_value (curtoken, '['))
{
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
key = script_parse_exp (scan);
- curtoken = ply_scan_get_current_token (scan);
- if (!ply_scan_token_is_symbol_of_value (curtoken, ']'))
+ curtoken = script_scan_get_current_token (scan);
+ if (!script_scan_token_is_symbol_of_value (curtoken, ']'))
{
script_parse_error (curtoken,
"Expected a ']' to terminate the index expression");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
}
else break;
exp = script_parse_new_exp_dual (SCRIPT_EXP_TYPE_HASH, exp, key);
return exp;
}
-static script_exp_t *script_parse_exp_pr (ply_scan_t *scan)
+static script_exp_t *script_parse_exp_pr (script_scan_t *scan)
{
static const script_parse_operator_table_entry_t operator_table[] =
{
return script_parse_new_exp_single(entry->exp_type, script_parse_exp_pr (scan));
}
-static script_exp_t *script_parse_exp_po (ply_scan_t *scan)
+static script_exp_t *script_parse_exp_po (script_scan_t *scan)
{
static const script_parse_operator_table_entry_t operator_table[] =
{
return exp;
}
-static script_exp_t *script_parse_exp_ltr (ply_scan_t *scan, int presedence)
+static script_exp_t *script_parse_exp_ltr (script_scan_t *scan, int presedence)
{
static const script_parse_operator_table_entry_t operator_table[] =
{
exp = script_parse_new_exp_dual(entry->exp_type, exp, script_parse_exp_ltr (scan, presedence + 1));
if (!exp->data.dual.sub_b)
{
- script_parse_error (ply_scan_get_current_token (scan),
+ script_parse_error (script_scan_get_current_token (scan),
"An invalid RHS of an expression");
return NULL;
}
return exp;
}
-static script_exp_t *script_parse_exp_as (ply_scan_t *scan)
+static script_exp_t *script_parse_exp_as (script_scan_t *scan)
{
static const script_parse_operator_table_entry_t operator_table[] =
{
script_exp_t *rhs = script_parse_exp_as (scan);
if (!rhs)
{
- script_parse_error (ply_scan_get_current_token (scan),
+ script_parse_error (script_scan_get_current_token (scan),
"An invalid RHS of an expression");
return NULL;
}
return script_parse_new_exp_dual (entry->exp_type, lhs, rhs);
}
-static script_exp_t *script_parse_exp (ply_scan_t *scan)
+static script_exp_t *script_parse_exp (script_scan_t *scan)
{
return script_parse_exp_as (scan);
}
-static script_op_t *script_parse_op_block (ply_scan_t *scan)
+static script_op_t *script_parse_op_block (script_scan_t *scan)
{
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
- if (!ply_scan_token_is_symbol_of_value (curtoken, '{'))
+ if (!script_scan_token_is_symbol_of_value (curtoken, '{'))
return NULL;
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
ply_list_t *sublist = script_parse_op_list (scan);
- if (!ply_scan_token_is_symbol_of_value (curtoken, '}'))
+ if (!script_scan_token_is_symbol_of_value (curtoken, '}'))
{
- script_parse_error (ply_scan_get_current_token (scan),
+ script_parse_error (script_scan_get_current_token (scan),
"Expected a '}' to terminate the operation block");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
script_op_t *op = malloc (sizeof (script_op_t));
op->type = SCRIPT_OP_TYPE_OP_BLOCK;
return op;
}
-static script_op_t *script_parse_if_while (ply_scan_t *scan)
+static script_op_t *script_parse_if_while (script_scan_t *scan)
{
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
script_op_type_t type;
- if (ply_scan_token_is_identifier_of_value (curtoken, "if"))
+ if (script_scan_token_is_identifier_of_value (curtoken, "if"))
type = SCRIPT_OP_TYPE_IF;
- else if (ply_scan_token_is_identifier_of_value (curtoken, "while"))
+ else if (script_scan_token_is_identifier_of_value (curtoken, "while"))
type = SCRIPT_OP_TYPE_WHILE;
else return NULL;
- curtoken = ply_scan_get_next_token (scan);
- if (!ply_scan_token_is_symbol_of_value (curtoken, '('))
+ curtoken = script_scan_get_next_token (scan);
+ if (!script_scan_token_is_symbol_of_value (curtoken, '('))
{
script_parse_error (curtoken,
"Expected a '(' at the start of a condition block");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
script_exp_t *cond = script_parse_exp (scan);
- curtoken = ply_scan_get_current_token (scan);
+ curtoken = script_scan_get_current_token (scan);
if (!cond)
{
script_parse_error (curtoken, "Expected a valid condition expression");
return NULL;
}
- if (!ply_scan_token_is_symbol_of_value (curtoken, ')'))
+ if (!script_scan_token_is_symbol_of_value (curtoken, ')'))
{
script_parse_error (curtoken,
"Expected a ')' at the end of a condition block");
return NULL;
}
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
script_op_t *cond_op = script_parse_op (scan);
script_op_t *else_op = NULL;
- curtoken = ply_scan_get_current_token (scan);
+ curtoken = script_scan_get_current_token (scan);
if ((type == SCRIPT_OP_TYPE_IF)
- && (ply_scan_token_is_identifier_of_value (curtoken, "else")))
+ && (script_scan_token_is_identifier_of_value (curtoken, "else")))
{
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
else_op = script_parse_op (scan);
}
script_op_t *op = malloc (sizeof (script_op_t));
return op;
}
-static script_op_t *script_parse_for (ply_scan_t *scan)
+static script_op_t *script_parse_for (script_scan_t *scan)
{
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
- if (!ply_scan_token_is_identifier_of_value (curtoken, "for")) return NULL;
- curtoken = ply_scan_get_next_token (scan);
- if (!ply_scan_token_is_symbol_of_value (curtoken, '('))
+ if (!script_scan_token_is_identifier_of_value (curtoken, "for")) return NULL;
+ curtoken = script_scan_get_next_token (scan);
+ if (!script_scan_token_is_symbol_of_value (curtoken, '('))
{
script_parse_error (curtoken,
"Expected a '(' at the start of a condition block");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
script_exp_t *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 (!ply_scan_token_is_symbol_of_value (curtoken, ';'))
+ curtoken = script_scan_get_current_token (scan);
+ if (!script_scan_token_is_symbol_of_value (curtoken, ';'))
{
script_parse_error (curtoken,
"Expected a ';' after the first 'for' expression");
return NULL;
}
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
script_exp_t *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 (!ply_scan_token_is_symbol_of_value (curtoken, ';'))
+ curtoken = script_scan_get_current_token (scan);
+ if (!script_scan_token_is_symbol_of_value (curtoken, ';'))
{
script_parse_error (curtoken, "Expected a ';' after the 'for' condition");
return NULL;
}
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
script_exp_t *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 (!ply_scan_token_is_symbol_of_value (curtoken, ')'))
+ curtoken = script_scan_get_current_token (scan);
+ if (!script_scan_token_is_symbol_of_value (curtoken, ')'))
{
script_parse_error (curtoken, "Expected a ')' at the end of a for block");
return NULL;
}
- ply_scan_get_next_token (scan);
+ script_scan_get_next_token (scan);
script_op_t *op_body = script_parse_op (scan);
script_op_t *op_first = malloc (sizeof (script_op_t));
return op_block;
}
-static script_op_t *script_parse_function (ply_scan_t *scan)
+static script_op_t *script_parse_function (script_scan_t *scan)
{
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
- if (!ply_scan_token_is_identifier_of_value (curtoken, "fun")) return NULL;
- curtoken = ply_scan_get_next_token (scan);
- if (!ply_scan_token_is_identifier (curtoken))
+ if (!script_scan_token_is_identifier_of_value (curtoken, "fun")) return NULL;
+ curtoken = script_scan_get_next_token (scan);
+ if (!script_scan_token_is_identifier (curtoken))
{
script_parse_error (curtoken,
"A function declaration requires a valid name");
name->type = SCRIPT_EXP_TYPE_TERM_VAR;
name->data.string = strdup (curtoken->data.string);
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
script_function_t *function = script_parse_function_def (scan);
if (!function) return NULL;
return op;
}
-static script_op_t *script_parse_return (ply_scan_t *scan)
+static script_op_t *script_parse_return (script_scan_t *scan)
{
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
script_op_type_t type;
- if (ply_scan_token_is_identifier_of_value (curtoken, "return"))
+ if (script_scan_token_is_identifier_of_value (curtoken, "return"))
type = SCRIPT_OP_TYPE_RETURN;
- else if (ply_scan_token_is_identifier_of_value (curtoken, "break"))
+ else if (script_scan_token_is_identifier_of_value (curtoken, "break"))
type = SCRIPT_OP_TYPE_BREAK;
- else if (ply_scan_token_is_identifier_of_value (curtoken, "continue"))
+ else if (script_scan_token_is_identifier_of_value (curtoken, "continue"))
type = SCRIPT_OP_TYPE_CONTINUE;
else return NULL;
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
script_op_t *op = malloc (sizeof (script_op_t));
if (type == SCRIPT_OP_TYPE_RETURN)
{
op->data.exp = script_parse_exp (scan); /* May be NULL */
- curtoken = ply_scan_get_current_token (scan);
+ curtoken = script_scan_get_current_token (scan);
}
#ifdef WITH_SEMIES
- if (!ply_scan_token_is_symbol_of_value (curtoken, ';'))
+ if (!script_scan_token_is_symbol_of_value (curtoken, ';'))
{
script_parse_error (curtoken, "Expected ';' after an expression");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
#endif
op->type = type;
return op;
}
-static script_op_t *script_parse_op (ply_scan_t *scan)
+static script_op_t *script_parse_op (script_scan_t *scan)
{
- ply_scan_token_t *curtoken = ply_scan_get_current_token (scan);
+ script_scan_token_t *curtoken = script_scan_get_current_token (scan);
script_op_t *reply = NULL;
reply = script_parse_op_block (scan);
{
script_exp_t *exp = script_parse_exp (scan);
if (!exp) return NULL;
- curtoken = ply_scan_get_current_token (scan);
+ curtoken = script_scan_get_current_token (scan);
#ifdef WITH_SEMIES
- if (!ply_scan_token_is_symbol_of_value (curtoken, ';'))
+ if (!script_scan_token_is_symbol_of_value (curtoken, ';'))
{
script_parse_error (curtoken, "Expected ';' after an expression");
return NULL;
}
- curtoken = ply_scan_get_next_token (scan);
+ curtoken = script_scan_get_next_token (scan);
#endif
script_op_t *op = malloc (sizeof (script_op_t));
return NULL;
}
-static ply_list_t *script_parse_op_list (ply_scan_t *scan)
+static ply_list_t *script_parse_op_list (script_scan_t *scan)
{
ply_list_t *op_list = ply_list_new ();
script_op_t *script_parse_file (const char *filename)
{
- ply_scan_t *scan = ply_scan_file (filename);
+ script_scan_t *scan = script_scan_file (filename);
if (!scan)
{
}
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_scan_token_t *curtoken = script_scan_get_current_token (scan);
+ if (curtoken->type != script_scan_TOKEN_TYPE_EOF)
{
script_parse_error (curtoken, "Unparsed characters at end of file");
return NULL;
}
- ply_scan_free (scan);
+ script_scan_free (scan);
script_op_t *op = malloc (sizeof (script_op_t));
op->type = SCRIPT_OP_TYPE_OP_BLOCK;
op->data.list = list;
script_op_t *script_parse_string (const char *string)
{
- ply_scan_t *scan = ply_scan_string (string);
+ script_scan_t *scan = script_scan_string (string);
if (!scan)
{
return NULL;
}
ply_list_t *list = script_parse_op_list (scan);
- ply_scan_free (scan);
+ script_scan_free (scan);
script_op_t *op = malloc (sizeof (script_op_t));
op->type = SCRIPT_OP_TYPE_OP_BLOCK;
op->data.list = list;
*
* Written by: Charlie Brej <cbrej@cs.man.ac.uk>
*/
-#include "ply-bitarray.h"
-#include "ply-scan.h"
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
+#include "ply-bitarray.h"
+#include "script-scan.h"
+
#define COLUMN_START_INDEX 0
-static ply_scan_t *ply_scan_new (void)
+static script_scan_t *script_scan_new (void)
{
unsigned char *chars;
- ply_scan_t *scan = calloc (1, sizeof (ply_scan_t));
+ script_scan_t *scan = calloc (1, sizeof (script_scan_t));
scan->tokens = NULL;
scan->tokencount = 0;
return scan;
}
-ply_scan_t *ply_scan_file (const char *filename)
+script_scan_t *script_scan_file (const char *filename)
{
int fd = open (filename, O_RDONLY);
if (fd < 0) return NULL;
- ply_scan_t *scan = ply_scan_new ();
+ script_scan_t *scan = script_scan_new ();
scan->source.fd = fd;
scan->source_is_file = true;
- ply_scan_get_next_char (scan);
+ script_scan_get_next_char (scan);
return scan;
}
-ply_scan_t *ply_scan_string (const char *string)
+script_scan_t *script_scan_string (const char *string)
{
- ply_scan_t *scan = ply_scan_new ();
+ script_scan_t *scan = script_scan_new ();
scan->source.string = string;
scan->source_is_file = false;
- ply_scan_get_next_char (scan);
+ script_scan_get_next_char (scan);
return scan;
}
-void ply_scan_token_clean (ply_scan_token_t *token)
+void script_scan_token_clean (script_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 script_scan_TOKEN_TYPE_EMPTY:
+ case script_scan_TOKEN_TYPE_EOF:
+ case script_scan_TOKEN_TYPE_INTEGER:
+ case script_scan_TOKEN_TYPE_FLOAT:
+ case script_scan_TOKEN_TYPE_SYMBOL:
break;
- case PLY_SCAN_TOKEN_TYPE_IDENTIFIER:
- case PLY_SCAN_TOKEN_TYPE_STRING:
- case PLY_SCAN_TOKEN_TYPE_COMMENT:
- case PLY_SCAN_TOKEN_TYPE_ERROR:
+ case script_scan_TOKEN_TYPE_IDENTIFIER:
+ case script_scan_TOKEN_TYPE_STRING:
+ case script_scan_TOKEN_TYPE_COMMENT:
+ case script_scan_TOKEN_TYPE_ERROR:
free (token->data.string);
break;
}
- token->type = PLY_SCAN_TOKEN_TYPE_EMPTY;
+ token->type = script_scan_TOKEN_TYPE_EMPTY;
token->whitespace = 0;
}
-void ply_scan_free (ply_scan_t *scan)
+void script_scan_free (script_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]);
+ script_scan_token_clean (scan->tokens[i]);
free (scan->tokens[i]);
}
ply_bitarray_free (scan->identifier_1st_char);
free (scan);
}
-unsigned char ply_scan_get_current_char (ply_scan_t *scan)
+unsigned char script_scan_get_current_char (script_scan_t *scan)
{
return scan->cur_char;
}
-unsigned char ply_scan_get_next_char (ply_scan_t *scan)
+unsigned char script_scan_get_next_char (script_scan_t *scan)
{
if (scan->cur_char == '\n')
{
return scan->cur_char;
}
-void ply_scan_read_next_token (ply_scan_t *scan,
- ply_scan_token_t *token)
+void script_scan_read_next_token (script_scan_t *scan,
+ script_scan_token_t *token)
{
- unsigned char curchar = ply_scan_get_current_char (scan); /* FIXME Double check these unsigned chars are ok */
+ unsigned char curchar = script_scan_get_current_char (scan); /* FIXME Double check these unsigned chars are ok */
unsigned char nextchar;
token->whitespace = 0;
{
if (curchar == ' ')
{
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
token->whitespace++;
continue;
} /* FIXME restrcuture */
if (curchar == '\n')
{
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
token->whitespace++;
continue;
}
if (curchar == '\t')
{
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
token->whitespace++;
continue;
}
}
token->line_index = scan->line_index;
token->column_index = scan->column_index;
- nextchar = ply_scan_get_next_char (scan);
+ nextchar = script_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->type = script_scan_TOKEN_TYPE_IDENTIFIER;
token->data.string = malloc (2 * sizeof (char));
token->data.string[0] = curchar;
token->data.string[1] = '\0';
token->data.string[index] = curchar;
token->data.string[index + 1] = '\0';
index++;
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
}
return;
}
{
int_value *= 10;
int_value += curchar - '0';
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
}
if (curchar == '.')
double floatpoint = int_value;
double scalar = 1;
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
while (curchar >= '0' && curchar <= '9')
{
scalar /= 10;
floatpoint += scalar * (curchar - '0');
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
}
- token->type = PLY_SCAN_TOKEN_TYPE_FLOAT;
+ token->type = script_scan_TOKEN_TYPE_FLOAT;
token->data.floatpoint = floatpoint;
}
else
{
- token->type = PLY_SCAN_TOKEN_TYPE_INTEGER;
+ token->type = script_scan_TOKEN_TYPE_INTEGER;
token->data.integer = int_value;
}
return;
}
if (!curchar)
{
- token->type = PLY_SCAN_TOKEN_TYPE_EOF;
+ token->type = script_scan_TOKEN_TYPE_EOF;
return;
}
if (curchar == '\"')
{
- token->type = PLY_SCAN_TOKEN_TYPE_STRING;
+ token->type = script_scan_TOKEN_TYPE_STRING;
int index = 0;
token->data.string = malloc (sizeof (char));
token->data.string[0] = '\0';
if (curchar == '\0')
{
token->data.string = strdup("End of file before end of string");
- token->type = PLY_SCAN_TOKEN_TYPE_ERROR;
+ token->type = script_scan_TOKEN_TYPE_ERROR;
return;
}
if (curchar == '\n')
{
token->data.string = strdup("Line terminator before end of string");
- token->type = PLY_SCAN_TOKEN_TYPE_ERROR;
+ token->type = script_scan_TOKEN_TYPE_ERROR;
return;
}
if (curchar == '\\')
{
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
switch (curchar)
{
case 'n':
token->data.string[index] = curchar;
token->data.string[index + 1] = '\0';
index++;
- curchar = ply_scan_get_next_char (scan);
+ curchar = script_scan_get_next_char (scan);
}
- ply_scan_get_next_char (scan);
+ script_scan_get_next_char (scan);
return;
}
{
if ((curchar == '/') && (nextchar == '/'))
{
linecomment = true;
- nextchar = ply_scan_get_next_char (scan);
+ nextchar = script_scan_get_next_char (scan);
}
if (linecomment)
{
curchar = nextchar;
for (curchar = nextchar;
curchar != '\n' && curchar != '\0';
- curchar = ply_scan_get_next_char (scan))
+ curchar = script_scan_get_next_char (scan))
{
token->data.string = realloc (token->data.string,
(index + 2) * sizeof (char));
token->data.string[index + 1] = '\0';
index++;
}
- token->type = PLY_SCAN_TOKEN_TYPE_COMMENT;
+ token->type = script_scan_TOKEN_TYPE_COMMENT;
return;
}
}
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);
+ curchar = script_scan_get_next_char (scan);
+ nextchar = script_scan_get_next_char (scan);
while (true)
{
{
free (token->data.string);
token->data.string = strdup("End of file before end of comment");
- token->type = PLY_SCAN_TOKEN_TYPE_ERROR;
+ token->type = script_scan_TOKEN_TYPE_ERROR;
return;
}
if ((curchar == '/') && (nextchar == '*'))
token->data.string[index + 1] = '\0';
index++;
curchar = nextchar;
- nextchar = ply_scan_get_next_char (scan);
+ nextchar = script_scan_get_next_char (scan);
}
- ply_scan_get_next_char (scan);
- token->type = PLY_SCAN_TOKEN_TYPE_COMMENT;
+ script_scan_get_next_char (scan);
+ token->type = script_scan_TOKEN_TYPE_COMMENT;
return;
}
/* all other */
- token->type = PLY_SCAN_TOKEN_TYPE_SYMBOL;
+ token->type = script_scan_TOKEN_TYPE_SYMBOL;
token->data.symbol = curchar;
return;
}
-static ply_scan_token_t *ply_scan_peek_token (ply_scan_t *scan,
+static script_scan_token_t *script_scan_peek_token (script_scan_t *scan,
int n)
{
int i;
if (scan->tokencount <= n)
{
scan->tokens =
- realloc (scan->tokens, (n + 1) * sizeof (ply_scan_token_t *));
+ realloc (scan->tokens, (n + 1) * sizeof (script_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->tokens[i] = malloc (sizeof (script_scan_token_t));
+ scan->tokens[i]->type = script_scan_TOKEN_TYPE_EMPTY;
}
scan->tokencount = n + 1;
}
- if (scan->tokens[n]->type == PLY_SCAN_TOKEN_TYPE_EMPTY)
+ if (scan->tokens[n]->type == script_scan_TOKEN_TYPE_EMPTY)
{
- if ((n > 0) && (scan->tokens[n - 1]->type == PLY_SCAN_TOKEN_TYPE_EMPTY))
- ply_scan_peek_token (scan, n - 1);
+ if ((n > 0) && (scan->tokens[n - 1]->type == script_scan_TOKEN_TYPE_EMPTY))
+ script_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 */
+ script_scan_token_clean (scan->tokens[n]);
+ script_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 */
+ while (scan->tokens[n]->type == script_scan_TOKEN_TYPE_COMMENT); /* FIXME optionally pass comments back */
}
return scan->tokens[n];
}
-ply_scan_token_t *ply_scan_get_next_token (ply_scan_t *scan)
+script_scan_token_t *script_scan_get_next_token (script_scan_t *scan)
{
int i;
- ply_scan_token_clean (scan->tokens[0]);
+ script_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);
+ scan->tokens[(scan->tokencount - 1)]->type = script_scan_TOKEN_TYPE_EMPTY;
+ return script_scan_peek_token (scan, 0);
}
-ply_scan_token_t *ply_scan_get_current_token (ply_scan_t *scan)
+script_scan_token_t *script_scan_get_current_token (script_scan_t *scan)
{
- return ply_scan_peek_token (scan, 0);
+ return script_scan_peek_token (scan, 0);
}
-ply_scan_token_t *ply_scan_peek_next_token (ply_scan_t *scan)
+script_scan_token_t *script_scan_peek_next_token (script_scan_t *scan)
{
- return ply_scan_peek_token (scan, 1);
+ return script_scan_peek_token (scan, 1);
}
projects / thirdparty / plymouth.git / commitdiff
