/*
* yaubil.c -- Yet Another Useless Built-In Language
*
* Copyrigth (C) 2009 Myhailo Danylenko <isbear@ukrpost.net>
*
* 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 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*/
#include <glib.h>
#include <gmodule.h>
#include <string.h>
#include "commands.h"
#include "compl.h"
#include "logprint.h"
#include "settings.h"
static gboolean ifresult = TRUE;
#define MSGPREFIX "yaubil: "
#define TYPE_UNDEF ( 0 )
#define TYPE_STR ( 1 )
#define TYPE_INT ( 2 )
#define STATE_LVALUE ( 1 )
#define STATE_OP ( 2 )
#define STATE_RVALUE ( 3 )
typedef struct {
int type;
int int_value;
char *str_value;
} value_t;
typedef struct {
char op;
gboolean (*handler) (value_t *l, value_t *r);
} op_t;
static int check_value_type (const char *value)
{
if (value) {
const char *e;
gboolean integer = (*value == '-') ? FALSE : (g_ascii_isdigit (*value) ? TRUE : FALSE);
if (integer) {
for (e = value + 1; *e; ++e) {
if (g_ascii_isdigit (*e))
integer = TRUE;
else {
integer = FALSE;
break;
}
}
}
if (integer)
return TYPE_INT;
else
return TYPE_STR;
} else
return TYPE_UNDEF;
}
static gboolean op_concat (value_t *l, value_t *r)
{
GString *res = g_string_new (NULL);;
if (l->type == TYPE_INT)
g_string_append_printf (res, "%d", l->int_value);
else if (l->type == TYPE_STR)
g_string_append (res, l->str_value);
if (r->type == TYPE_INT)
g_string_append_printf (res, "%d", r->int_value);
else if (r->type == TYPE_STR)
g_string_append (res, r->str_value);
l->type = TYPE_STR;
g_free (l->str_value);
l->str_value = g_string_free (res, FALSE);
return TRUE;
}
static gboolean op_plus (value_t *l, value_t *r)
{
if (l->type == TYPE_UNDEF) {
l->type = TYPE_INT;
l->int_value = 0;
}
if (r->type == TYPE_UNDEF) {
r->type = TYPE_INT;
r->int_value = 0;
}
if (l->type == TYPE_STR && check_value_type (l->str_value) == TYPE_INT) {
l->type = TYPE_INT;
l->int_value = atoi (l->str_value);
// not free value here
}
if (r->type == TYPE_STR && check_value_type (r->str_value) == TYPE_INT) {
r->type = TYPE_INT;
r->int_value = atoi (r->str_value);
// not free value here
}
if (l->type == TYPE_INT && r->type == TYPE_INT) {
// integer
l->int_value += r->int_value;
g_free (l->str_value);
l->str_value = NULL;
g_free (r->str_value);
r->str_value = NULL;
} else {
// convert both to strings
if (l->type == TYPE_INT) {
l->type = TYPE_STR;
if (!l->str_value)
l->str_value = g_strdup_printf ("%d", l->int_value);
}
if (r->type == TYPE_INT) {
r->type = TYPE_STR;
if (!r->str_value)
r->str_value = g_strdup_printf ("%d", r->int_value);
}
{
char *tmp = l->str_value;
l->str_value = g_strdup_printf ("%s%s", tmp, r->str_value);
g_free (tmp);
}
}
return TRUE;
}
static gboolean op_minus (value_t *l, value_t *r)
{
if (l->type == TYPE_UNDEF) {
l->type = TYPE_INT;
l->int_value = 0;
}
if (r->type == TYPE_UNDEF) {
r->type = TYPE_INT;
r->int_value = 0;
}
if (l->type == TYPE_STR && check_value_type (l->str_value) == TYPE_INT) {
l->type = TYPE_INT;
l->int_value = atoi (l->str_value);
g_free (l->str_value);
l->str_value = NULL;
}
if (r->type == TYPE_STR && check_value_type (r->str_value) == TYPE_INT) {
r->type = TYPE_INT;
r->int_value = atoi (r->str_value);
g_free (r->str_value);
r->str_value = NULL;
}
if (l->type == TYPE_INT && r->type == TYPE_INT)
l->int_value -= r->int_value;
else
return FALSE;
return TRUE;
}
static gboolean op_multiply (value_t *l, value_t *r)
{
if (l->type == TYPE_UNDEF) {
l->type = TYPE_INT;
l->int_value = 0;
}
if (r->type == TYPE_UNDEF) {
r->type = TYPE_INT;
r->int_value = 0;
}
if (l->type == TYPE_STR && check_value_type (l->str_value) == TYPE_INT) {
l->type = TYPE_INT;
l->int_value = atoi (l->str_value);
// not free value here
}
if (r->type == TYPE_STR && check_value_type (r->str_value) == TYPE_INT) {
r->type = TYPE_INT;
r->int_value = atoi (r->str_value);
g_free (r->str_value);
r->str_value = NULL;
}
if (l->type == TYPE_INT && r->type == TYPE_INT) {
l->int_value *= r->int_value;
g_free (l->str_value);
l->str_value = NULL;
} else if (r->type == TYPE_INT) {
GString *res = g_string_new (NULL);
int i;
for (i = r->int_value; i; --i)
g_string_append (res, l->str_value);
g_free (l->str_value);
l->str_value = g_string_free (res, FALSE);
} else
return FALSE;
return TRUE;
}
static gboolean op_divide (value_t *l, value_t *r)
{
if (l->type == TYPE_UNDEF) {
l->type = TYPE_INT;
l->int_value = 0;
}
if (r->type == TYPE_UNDEF) {
r->type = TYPE_INT;
r->int_value = 0;
}
if (l->type == TYPE_STR && check_value_type (l->str_value) == TYPE_INT) {
l->type = TYPE_INT;
l->int_value = atoi (l->str_value);
g_free (l->str_value);
l->str_value = NULL;
}
if (r->type == TYPE_STR && check_value_type (r->str_value) == TYPE_INT) {
r->type = TYPE_INT;
r->int_value = atoi (r->str_value);
g_free (r->str_value);
r->str_value = NULL;
}
if (l->type == TYPE_INT && r->type == TYPE_INT) {
if (r->int_value == 0) {
scr_LogPrint (LPRINT_NORMAL, MSGPREFIX "/: Error: division by zero.");
return FALSE;
}
l->int_value /= r->int_value;
} else
return FALSE;
return TRUE;
}
static gboolean op_remain (value_t *l, value_t *r)
{
if (l->type == TYPE_UNDEF) {
l->type = TYPE_INT;
l->int_value = 0;
}
if (r->type == TYPE_UNDEF) {
r->type = TYPE_INT;
r->int_value = 0;
}
if (l->type == TYPE_STR && check_value_type (l->str_value) == TYPE_INT) {
l->type = TYPE_INT;
l->int_value = atoi (l->str_value);
g_free (l->str_value);
l->str_value = NULL;
}
if (r->type == TYPE_STR && check_value_type (r->str_value) == TYPE_INT) {
r->type = TYPE_INT;
r->int_value = atoi (r->str_value);
g_free (r->str_value);
r->str_value = NULL;
}
if (l->type == TYPE_INT && r->type == TYPE_INT) {
if (r->int_value == 0) {
scr_LogPrint (LPRINT_NORMAL, MSGPREFIX "%%: Error: division by zero.");
return FALSE;
}
l->int_value %= r->int_value;
} else
return FALSE;
return TRUE;
}
static gboolean op_equal (value_t *l, value_t *r)
{
if (l->type == TYPE_UNDEF) {
l->type = TYPE_INT;
l->int_value = 0;
}
if (r->type == TYPE_UNDEF) {
r->type = TYPE_INT;
r->int_value = 0;
}
if (l->type == TYPE_STR && check_value_type (l->str_value) == TYPE_INT) {
l->type = TYPE_INT;
l->int_value = atoi (l->str_value);
// not free value here
}
if (r->type == TYPE_STR && check_value_type (r->str_value) == TYPE_INT) {
r->type = TYPE_INT;
r->int_value = atoi (r->str_value);
// not free value here
}
if (l->type == TYPE_INT && r->type == TYPE_INT) {
// integer
l->int_value = (l->int_value == r->int_value) ? 1 : 0;
g_free (l->str_value);
l->str_value = NULL;
g_free (r->str_value);
r->str_value = NULL;
} else {
// convert both to strings
if (l->type == TYPE_INT) {
l->type = TYPE_STR;
if (!l->str_value)
l->str_value = g_strdup_printf ("%d", l->int_value);
}
if (r->type == TYPE_INT) {
r->type = TYPE_STR;
if (!r->str_value)
r->str_value = g_strdup_printf ("%d", r->int_value);
}
{
char *tmp = l->str_value;
l->type = TYPE_INT;
l->int_value = (g_strcmp0 (l->str_value, r->str_value) == 0) ? 1 : 0;
g_free (tmp);
}
}
return TRUE;
}
static gboolean op_lt (value_t *l, value_t *r)
{
if (l->type == TYPE_UNDEF) {
l->type = TYPE_INT;
l->int_value = 0;
}
if (r->type == TYPE_UNDEF) {
r->type = TYPE_INT;
r->int_value = 0;
}
if (l->type == TYPE_STR && check_value_type (l->str_value) == TYPE_INT) {
l->type = TYPE_INT;
l->int_value = atoi (l->str_value);
// not free value here
}
if (r->type == TYPE_STR && check_value_type (r->str_value) == TYPE_INT) {
r->type = TYPE_INT;
r->int_value = atoi (r->str_value);
// not free value here
}
if (l->type == TYPE_INT && r->type == TYPE_INT) {
// integer
l->int_value = (l->int_value < r->int_value) ? 1 : 0;
g_free (l->str_value);
l->str_value = NULL;
g_free (r->str_value);
r->str_value = NULL;
} else {
// convert both to strings
if (l->type == TYPE_INT) {
l->type = TYPE_STR;
if (!l->str_value)
l->str_value = g_strdup_printf ("%d", l->int_value);
}
if (r->type == TYPE_INT) {
r->type = TYPE_STR;
if (!r->str_value)
r->str_value = g_strdup_printf ("%d", r->int_value);
}
{
char *tmp = l->str_value;
l->type = TYPE_INT;
l->int_value = (g_strcmp0 (l->str_value, r->str_value) < 0) ? 1 : 0;
g_free (tmp);
}
}
return TRUE;
}
static gboolean op_gt (value_t *l, value_t *r)
{
if (l->type == TYPE_UNDEF) {
l->type = TYPE_INT;
l->int_value = 0;
}
if (r->type == TYPE_UNDEF) {
r->type = TYPE_INT;
r->int_value = 0;
}
if (l->type == TYPE_STR && check_value_type (l->str_value) == TYPE_INT) {
l->type = TYPE_INT;
l->int_value = atoi (l->str_value);
// not free value here
}
if (r->type == TYPE_STR && check_value_type (r->str_value) == TYPE_INT) {
r->type = TYPE_INT;
r->int_value = atoi (r->str_value);
// not free value here
}
if (l->type == TYPE_INT && r->type == TYPE_INT) {
// integer
l->int_value = (l->int_value > r->int_value) ? 1 : 0;
g_free (l->str_value);
l->str_value = NULL;
g_free (r->str_value);
r->str_value = NULL;
} else {
// convert both to strings
if (l->type == TYPE_INT) {
l->type = TYPE_STR;
if (!l->str_value)
l->str_value = g_strdup_printf ("%d", l->int_value);
}
if (r->type == TYPE_INT) {
r->type = TYPE_STR;
if (!r->str_value)
r->str_value = g_strdup_printf ("%d", r->int_value);
}
{
char *tmp = l->str_value;
l->type = TYPE_INT;
l->int_value = (g_strcmp0 (l->str_value, r->str_value) > 0) ? 1 : 0;
g_free (tmp);
}
}
return TRUE;
}
static op_t operators[] = {
{ '.', op_concat },
{ '+', op_plus },
{ '-', op_minus },
{ '*', op_multiply },
{ '/', op_divide },
{ '%', op_remain },
{ '=', op_equal },
{ '<', op_lt },
{ '>', op_gt },
{ 0, NULL },
};
static void destroy_value (value_t *value)
{
if (value->str_value)
g_free (value->str_value);
g_free (value);
}
static value_t *process_expression (const char *str, gsize len)
{
const char *strend = str + len;
const char *p;
op_t *op = NULL;
int state = STATE_LVALUE;
value_t val = {
.type = TYPE_UNDEF,
.int_value = 0,
.str_value = NULL,
};
for (p = str; *p && p < strend; ++p) {
switch (state) {
case STATE_LVALUE:
case STATE_RVALUE:
if (*p == ' ')
break;
{
value_t rval = {
.type = TYPE_UNDEF,
.int_value = 0,
.str_value = NULL,
};
if (g_ascii_isdigit (*p) || *p == '-') { // integer // XXX: no unary operators for now...
const char *e;
rval.type = TYPE_INT;
for (e = p + 1; g_ascii_isdigit (*e) && e < strend; ++e); // TODO: does atoi handle 0x etc? then also allow this?
{
char *v = g_strndup (p, e - p);
rval.int_value = atoi (v);
g_free (v);
}
p = e - 1;
} else if (*p == '"') { // string
const char *e;
rval.type = TYPE_STR;
{
gboolean finished = FALSE;
gboolean escape = FALSE;
GString *v = g_string_new (NULL);
for (e = p + 1; *e && e < strend; ++e) {
switch (*e) {
case '\\':
if (!escape)
escape = TRUE;
else
escape = FALSE;
break;
case '"':
if (!escape) {
finished = TRUE;
break;
} else
escape = FALSE;
break;
default:
escape = FALSE;
break;
}
if (finished)
break;
if (!escape)
g_string_append_c (v, *e);
};
if (!finished) {
scr_LogPrint (LPRINT_NORMAL, MSGPREFIX "Error: Unmatched quote.");
g_string_free (v, TRUE);
g_free (val.str_value);
return NULL;
}
rval.str_value = g_string_free (v, FALSE);
}
p = e;
} else if (g_ascii_isalpha (*p)) { // variable (MUST start from alpha)
const char *e;
for (e = p + 1; (g_ascii_isalnum (*e) || *e == '-' || *e == '_') && e < strend; ++e);
char *name = g_strndup (p, e - p);
const char *value = settings_opt_get (name);
g_free (name);
rval.type = check_value_type (value);
if (rval.type == TYPE_INT)
rval.int_value = atoi (value);
else if (rval.type == TYPE_STR)
rval.str_value = g_strdup (value);
p = e - 1;
} else if (*p == '(') {
const char *e;
{
int l = 0;
gboolean finished = FALSE;
// XXX maybe we should just pass end of line and let it return real length...
for (e = p + 1; e < strend; ++e) {
if (*e == '(')
++l;
else if (*e == ')') {
--l;
if (l < 0) {
finished = TRUE;
break;
}
}
}
if (!finished) {
scr_LogPrint (LPRINT_NORMAL, MSGPREFIX "Error: Unmatched parenthesis.");
g_free (val.str_value);
return NULL;
}
}
{
value_t *n = process_expression (p + 1, e - p - 1);
if (!n) {
scr_LogPrint (LPRINT_NORMAL, MSGPREFIX "Error: Error in subexpression.");
g_free (val.str_value);
return NULL;
}
rval.type = n->type;
rval.int_value = n->int_value;
rval.str_value = g_strdup (n->str_value);
destroy_value (n);
}
p = e;
} else {
scr_LogPrint (LPRINT_NORMAL, MSGPREFIX "Error: unrecognized symbols.");
g_free (val.str_value);
return NULL;
}
if (state == STATE_RVALUE) {
if (op->handler) {
if (!op->handler (&val, &rval)) {
scr_LogPrint (LPRINT_NORMAL, MSGPREFIX "Error: operand argument types mismatch.");
g_free (val.str_value);
g_free (rval.str_value);
return NULL;
}
}
g_free (rval.str_value);
} else {
val.type = rval.type;
val.int_value = rval.int_value;
val.str_value = rval.str_value;
}
state = STATE_OP;
}
break;
case STATE_OP:
if (*p == ' ')
break;
{
op_t *operator;
gboolean found = FALSE;
for (operator = operators; operator->op; ++operator) {
if (operator->op == *p) {
op = operator;
found = TRUE;
break;
}
}
if (!found) {
scr_LogPrint (LPRINT_NORMAL, MSGPREFIX "Error: unknown operator.");
g_free (val.str_value);
}
}
state = STATE_RVALUE;
break;
default:
break;
}
}
{ // return value
value_t *rval = g_new (value_t, 1);
rval->type = val.type;
rval->int_value = val.int_value;
rval->str_value = val.str_value;
return rval;
}
}
static void do_eval (char *arg)
{
value_t *val = process_expression (arg, strlen (arg));
if (!val) {
scr_LogPrint (LPRINT_NORMAL, "eval: Evaluation error.");
return;
}
if (val->type == TYPE_STR)
process_command (val->str_value, TRUE);
else
scr_LogPrint (LPRINT_NORMAL, "eval: Expression does not result in string.");
destroy_value (val);
}
static void do_let (char *arg)
{
char *varname;
value_t *value;
int namelen;
char *val = strchr (arg, '=');
if (!val) {
scr_LogPrint (LPRINT_NORMAL, "let: Syntax error: no equal sign in line.");
return;
}
{
char *p = val;
for (p = val - 1; p >= arg && *p == ' '; --p);
if (p < arg) {
scr_LogPrint (LPRINT_NORMAL, "let: Syntax error: no destination variable name specified.");
return;
}
namelen = p + 1 - arg;
}
// evaluate expression
value = process_expression (val + 1, strlen (val + 1));
if (!value) {
scr_LogPrint (LPRINT_NORMAL, "let: Evaluation error.");
return;
}
if (value->type == TYPE_INT) {
value->type = TYPE_STR;
value->str_value = g_strdup_printf ("%d", value->int_value);
}
{ // assign value
char *varname = g_strndup (arg, namelen);
if (value->str_value)
settings_set (SETTINGS_TYPE_OPTION, varname, value->str_value);
else
settings_del (SETTINGS_TYPE_OPTION, varname);
g_free (varname);
}
destroy_value (value);
}
static void do_if (char *arg)
{
value_t *val = process_expression (arg, strlen (arg));
if (!val) {
scr_LogPrint (LPRINT_NORMAL, "if: Evaluation error.");
return;
}
if (val->type == TYPE_UNDEF) {
val->type = TYPE_INT;
val->int_value = 0;
}
if (val->type == TYPE_STR && check_value_type (val->str_value) == TYPE_INT) {
val->type = TYPE_INT;
val->int_value = atoi (val->str_value);
g_free (val->str_value);
val->str_value = NULL;
}
if (val->type == TYPE_INT)
ifresult = val->int_value ? TRUE : FALSE;
else if (val->str_value)
ifresult = TRUE;
else
ifresult = FALSE;
destroy_value (val);
}
static void do_then (char *arg)
{
if (ifresult)
process_command (arg, TRUE);
}
static void do_else (char *arg)
{
if (!ifresult)
process_command (arg, TRUE);
}
static void do_multi (char *arg)
{
char *end;
char *start = arg;
for (end = strchr (start, ';'); end; end = strchr (start, ';')) {
// execute command
char *command = g_strndup (start, end - start);
process_command (command, TRUE);
g_free (command);
// skip leading spaces
for (start = end + 1; *start == ' '; ++start);
}
if (*start)
process_command (start, TRUE);
}
const gchar *g_module_check_init (GModule *module)
{
cmd_add ("multi", "", COMPL_CMD, COMPL_CMD, do_multi, NULL);
cmd_add ("if", "", 0, 0, do_if, NULL);
cmd_add ("then", "", COMPL_CMD, COMPL_CMD, do_then, NULL);
cmd_add ("else", "", COMPL_CMD, COMPL_CMD, do_else, NULL);
cmd_add ("eval", "", 0, 0, do_eval, NULL);
cmd_add ("let", "", 0, 0, do_let, NULL);
return NULL;
}
void g_module_unload (GModule *module)
{
cmd_del ("multi");
cmd_del ("if");
cmd_del ("then");
cmd_del ("else");
cmd_del ("eval");
cmd_del ("let");
}
/* The End */