# HG changeset patch

# Parent 00b93fdbb1de8e77b6992cf799715c1da3e61746

[work-in-progress] Use templates for statusbars

diff -r 00b93fdbb1de mcabber/CMakeLists.txt

--- a/mcabber/CMakeLists.txt	Thu Aug 09 00:54:37 2012 +0300

+++ b/mcabber/CMakeLists.txt	Tue Aug 28 20:37:28 2012 +0300

@@ -154,8 +154,8 @@

 ## Define targets

 set ( mcabber_SUBSYSTEMS

-	caps commands compl events hbuf help histolog hooks

-	modules nohtml otr pgp roster screen settings utf8 utils

+	caps commands compl events hbuf help histolog hooks modules

+	nohtml otr parser pgp roster screen settings templates utf8 utils

 	xmpp xmpp_helper xmpp_iq xmpp_iqrequest xmpp_muc xmpp_s10n )

 if ( NOT MODULES_ENABLE )

 	list ( APPEND mcabber_SUBSYSTEMS extcmd fifo )

diff -r 00b93fdbb1de mcabber/mcabber/hooks.c

--- a/mcabber/mcabber/hooks.c	Thu Aug 09 00:54:37 2012 +0300

+++ b/mcabber/mcabber/hooks.c	Tue Aug 28 20:37:28 2012 +0300

@@ -612,6 +612,10 @@

     ns[0] = imstatus2char[new_status];

     hk_run_handlers(HOOK_MY_STATUS_CHANGE, args);

+

+    // FIXME not when modules_enable, but when templates_enable

+    settings_set(SETTINGS_TYPE_OPTION, "my_status", ns);

+    settings_tmpl_set("my_message", msg);

   }

 #endif

diff -r 00b93fdbb1de mcabber/mcabber/parser.c

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000

+++ b/mcabber/mcabber/parser.c	Tue Aug 28 20:37:28 2012 +0300

@@ -0,0 +1,1116 @@

+

+/* Copyright 2012 Myhailo Danylenko

+ *

+ * This file is part of mcabber

+ *

+ * mcabber 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, see <http://www.gnu.org/licenses/>. */

+

+#include <glib.h>

+

+#include <ctype.h>   // is*

+#include <stdlib.h>  // strtol

+#include <string.h>  // strchr

+

+#include "parser.h"

+

+#include "config.h"

+

+//

+//  Common

+//

+

+// XXX one for all 'mcabber' quark? to utils?

+GQuark tmpl_gerror_quark ( void )

+{

+	return g_quark_from_static_string ( "tmpl_gerror_quark" );

+}

+

+//

+//  Globs

+//

+

+// match tmpl_glob ( string, pattern, greedy, right-to-left )

+// Performs matching of given pattern against given string,

+// returns first substring in input, that matched. In pattern,

+// there are currently two tokens recognized: '*' and '?'.

+const gchar *tmpl_glob ( const char *str, gsize length, const char *pat, gsize patlen, gboolean rtl, gsize *ret_len )

+{

+	*ret_len = 0;

+	if ( rtl ) { // rtl

+		const char *p           = pat + patlen - 1;

+		const char *s           = str + length - 1;

+		const char *matchend    = NULL;

+		const char *patrollback = p;

+		const char *strrollback = s;

+		while ( p >= pat && s >= str ) {

+			if ( *p == '*' ) {

+				if ( matchend == NULL && patrollback != NULL )

+					matchend = strrollback;

+				patrollback = NULL;

+				strrollback = NULL;

+				p --;

+			} else if ( *p == '?' || *p == *s ) {

+				if ( patrollback == NULL ) {

+					patrollback = p;

+					strrollback = s;

+				}

+				p --;

+				s --;

+			} else if ( patrollback != NULL ) {

+				p =    patrollback;

+				s = -- strrollback;

+			} else {

+				s --;

+			}

+		}

+		// now s, p or both have finished run

+		if ( s >= str && patrollback == NULL ) // s remains and final star

+			s = str - 1; // value at the end of loop

+		if ( p >= pat ) { // p remains

+			while ( *p == '*' && p >= pat ) // ignore empty stars

+				p --;

+			if ( p >= pat ) // symbols remain in pattern, no match

+				return NULL;

+		}

+		if ( matchend == NULL && patrollback != NULL ) // no stars

+			matchend = strrollback;

+		if ( matchend != NULL ) {

+			*ret_len = matchend - s;

+			return s + 1;

+		} else

+			return NULL;

+	} else { // ltr

+		const char * const  pe          = pat + patlen;

+		const char * const  se          = str + length;

+		const char         *p           = pat;

+		const char         *s           = str;

+		const char         *matchstart  = NULL;

+		const char         *patrollback = p;

+		const char         *strrollback = s;

+		while ( p < pe && s < se ) {

+			if ( *p == '*' ) {

+				if ( matchstart == NULL && patrollback != NULL )

+					matchstart = strrollback;

+				patrollback = NULL;

+				strrollback = NULL;

+				p ++;

+			} else if ( *p == '?' || *p == *s ) {

+				if ( patrollback == NULL ) {

+					patrollback = p;

+					strrollback = s;

+				}

+				p ++;

+				s ++;

+			} else if ( patrollback != NULL ) { // start/nomatch-recovery eat

+				p =    patrollback;

+				s = ++ strrollback;

+			} else { // star-eat

+				s ++;

+			}

+		}

+		// now s, p or both have finished run

+		if ( s < se && patrollback == NULL ) // s remains and final star

+				s = se;

+		if ( p < pe ) { // p remains

+			while ( *p == '*' && p < pe ) // ignore empty stars

+				p ++;

+			if ( p < pe ) // symbols remain in pattern, no match

+				return NULL;

+		}

+		if ( matchstart == NULL && patrollback != NULL ) // no stars

+			matchstart = strrollback;

+		if ( matchstart != NULL )

+			*ret_len = s - matchstart;

+		return matchstart;

+	}

+}

+

+// match tmpl_greedy_glob ( string, pattern, right-to-left )

+// The same as above, but greedy.

+const gchar *tmpl_greedy_glob ( const char *str, gsize length, const char *pat, gsize patlen, gboolean rtl, gsize *ret_len )

+{

+	const char * const  pe = pat + patlen;

+	const char         *p  = pat;

+	while ( p < pe ) {

+		if ( *p == '*' ) {

+			gsize       llen = 0;

+			const char *left = tmpl_glob ( str, length, pat, p - pat, FALSE, &llen );

+			if ( left != NULL ) {

+				gsize       rlen  = 0;

+				const char *right = tmpl_glob ( left + llen, str + length - ( left + llen ), p + 1, pe - p - 1, TRUE, &rlen );

+				if ( right != NULL ) {

+					*ret_len = right + rlen - left;

+					return left;

+				}

+			}

+			return NULL;

+		}

+		p ++;

+	}

+	return tmpl_glob ( str, length, pat, patlen, rtl, ret_len );

+}

+

+//

+//  Simple math expressions with variables

+//

+

+typedef enum {

+	no_op,

+	noempty_op,

+	paren_op,

+	plus_op,

+	minus_op,

+	remainder_op,

+	division_op,

+	multiplication_op,

+} math_operator_t;

+

+typedef enum {

+	in_preargument,

+	in_hexoctzero,

+	in_number,

+	in_variable,

+	in_postparen,

+	in_op,

+} math_parser_state_t;

+

+// - + * / % ( )

+static gssize tmpl_math_expand_internal ( const char *str, gsize length, tmpl_variable_callback_t get_val, gpointer udata, GError **error, math_operator_t bound, gsize *proc_len )

+{

+	g_assert ( error != NULL && *error == NULL );

+

+	gssize             result   = 0;

+	const char *       p        = str;

+	const char * const e        = str + length;

+	math_parser_state_t   state    = in_preargument;

+	const char *       varname  = NULL;  // variable name start

+	gsize              base     = 10;    // number base

+	gboolean           invert   = FALSE; // number change sign

+	gboolean           errstate = bound >= noempty_op; // indicates erroneous state

+

+	// process first argument

+	while ( p < e && *error == NULL ) {

+		if ( state == in_preargument ) { // initial space-skipping state

+			if ( isspace ( *p ) )

+				p ++;

+			else if ( *p == '-' ) {

+				invert = ! invert;

+				errstate = TRUE;

+				p ++;

+			} else if ( *p == '+' ) {

+				errstate = TRUE;

+				p ++;

+			} else if ( *p == '(' ) {

+				gsize processed = 0;

+				p ++;

+				result = tmpl_math_expand_internal ( p, e - p, get_val, udata, error, paren_op, &processed );

+				if ( *error == NULL )

+					state = in_postparen;

+				errstate  = TRUE;

+				p        += processed;

+			} else if ( *p == '0' ) {

+				result   = 0;

+				errstate = FALSE;

+				state    = in_hexoctzero;

+				p ++;

+			} else if ( isdigit ( *p ) ) {

+				result   = 0;

+				base     = 10;

+				state    = in_number;

+			} else if ( isalpha ( *p ) || *p == '_' ) {

+				state    = in_variable;

+				errstate = FALSE;

+				varname  = p;

+				p ++;

+			} else

+				g_set_error ( error, TMPL_GERROR_QUARK, TMPL_EMATHWRONGARG, "Wrong symbol in math argument" );

+		} else if ( state == in_hexoctzero ) {

+			if ( *p == 'x' ) {

+				errstate = TRUE;

+				base     = 16;

+				p ++;

+			} else

+				base = 8;

+			state  = in_number;

+		} else if ( state == in_number ) {

+			short d = -1;

+			if ( *p == '0' )

+				d = 0;

+			else if ( *p == '1' )

+				d = 1;

+			else if ( *p == '2' )

+				d = 2;

+			else if ( *p == '3' )

+				d = 3;

+			else if ( *p == '4' )

+				d = 4;

+			else if ( *p == '5' )

+				d = 5;

+			else if ( *p == '6' )

+				d = 6;

+			else if ( *p == '7' )

+				d = 7;

+			else if ( base <= 8 )

+				;

+			else if ( *p == '8' )

+				d = 8;

+			else if ( *p == '9' )

+				d = 9;

+			else if ( base <= 10 )

+				;

+			else if ( *p == 'a' || *p == 'A' )

+				d = 10;

+			else if ( *p == 'b' || *p == 'B' )

+				d = 11;

+			else if ( *p == 'c' || *p == 'C' )

+				d = 12;

+			else if ( *p == 'd' || *p == 'D' )

+				d = 13;

+			else if ( *p == 'e' || *p == 'E' )

+				d = 14;

+			else if ( *p == 'f' || *p == 'F' )

+				d = 15;

+			if ( d >= 0 ) {

+				errstate = FALSE;

+				result   = result * base + d;

+				p ++;

+			} else if ( ! errstate )

+				state = in_op;

+			else

+				g_set_error ( error, TMPL_GERROR_QUARK, TMPL_EMATHWRONGNUMBER, "Too short math number" );

+		} else if ( state == in_variable ) {

+			if ( ! ( isalnum ( *p ) || *p == '_' ) ) { // XXX vars with '-' have to be expanded earlier

+				gsize        vlen  = 0;

+				const char * value = get_val ( varname, p - varname, udata, &vlen );

+				// TODO control recursion level

+				result = tmpl_math_expand_internal ( value, vlen, get_val, udata, error, no_op, NULL );

+				if ( *error == NULL )

+					state = in_op;

+			} else

+				p ++;

+		} else if ( state == in_postparen ) {

+			if ( *p == ')' ) {

+				errstate = FALSE;

+				p ++;

+				state    = in_op;

+			} else

+				g_assert_not_reached ();

+		} else if ( state == in_op )

+			break;

+		else

+			g_assert_not_reached ();

+	}

+

+	if ( *error == NULL ) {

+		// in_preargument - empty argument, possibly +-+- - 0 / errstate

+		// in_hexoctzero  - 0                             - 0

+		// in_number      - 0, 0x, 01, 0x1, 1             - failure at 0x (errstate), invert

+		// in_variable    - varname                       - get var, invert

+		// in_postparen   - eof                           - failure (errstate)

+		// in_op          - ok                            - invert, continue parsing

+		if ( errstate )

+			g_set_error ( error, TMPL_GERROR_QUARK, TMPL_EMATHWRONGSTATE, "Wrong state at the end of first math argument parsing" );

+		else {

+			if ( state == in_op ) {

+				if ( invert )

+					result = - result;

+			

+				// process operator+second argument pairs

+				while ( p < e && *error == NULL ) {

+					math_operator_t op = no_op;

+					if ( isspace ( *p ) )

+						p ++;

+					else if ( *p == '+' ) // set op

+						op = plus_op;

+					else if ( *p == '-' )

+						op = minus_op;

+					else if ( *p == '/' )

+						op = division_op;

+					else if ( *p == '*' )

+						op = multiplication_op;

+					else if ( *p == '%' )

+						op = remainder_op;

+					else if ( *p == ')' ) {

+						if ( bound < paren_op )

+							g_set_error ( error, TMPL_GERROR_QUARK, TMPL_EMATHUNBALPAREN, "Unbalanced parens in math expression" );

+						else

+							break;

+					} else

+						g_set_error ( error, TMPL_GERROR_QUARK, TMPL_EMATHWRONGOP, "Wrong math operator '%c'", *p );

+

+					if ( op != no_op ) {

+						// lower priority operator, returning result

+						if ( op < bound )

+							break;

+

+						p ++;

+						gsize  processed = 0;

+						gssize arg       = tmpl_math_expand_internal ( p, e - p, get_val, udata, error, op, &processed );

+						if ( *error == NULL ) {

+							if ( op == plus_op )

+								result += arg;

+							else if ( op == minus_op )

+								result -= arg;

+							else if ( op == division_op )

+								result /= arg;

+							else if ( op == multiplication_op )

+								result *= arg;

+							else if ( op == remainder_op )

+								result %= arg;

+							else

+								g_assert_not_reached ();

+						}

+						p += processed;

+					}

+				}

+			} else if ( state == in_variable ) {

+				gsize        vlen  = 0;

+				const char * value = get_val ( varname, p - varname, udata, &vlen );

+				result = tmpl_math_expand_internal ( value, vlen, get_val, udata, error, no_op, NULL );

+				if ( *error == NULL && invert )

+					result = - result;

+			} else if ( invert )

+				result = - result;

+			// XXX may add long conditional with g_assert here, but I'm lazy

+		}

+	}

+

+	// return result

+	if ( proc_len != NULL )

+		*proc_len = p - str;

+	return result;

+}

+

+// result tmpl_math_expand ( plainexpanded string, callback )

+// Performs mathematical expansion on given string.

+// Note, that it does not perform variable/quote/etc expansion,

+// if you want it, you should do that first.

+gssize tmpl_math_expand ( const char *str, gsize length, tmpl_variable_callback_t get_val, gpointer udata, GError **ret_err )

+{

+	g_return_val_if_fail ( ret_err == NULL || *ret_err == NULL, -1 ); // XXX

+

+	GError * error  = NULL;

+	gssize   result = tmpl_math_expand_internal ( str, length, get_val, udata, &error, no_op, NULL );

+	if ( error != NULL )

+		g_propagate_error ( ret_err, error );

+	return result;

+}

+

+//

+//  Shell-like variable substitution

+//

+

+typedef enum {

+	in_string,

+	in_escape,

+	in_var,

+	in_plainvarstart,

+	in_plainvar,

+	in_prevarname,

+	in_varnamestart,

+	in_varname,

+	in_varchop,

+	in_varstrip,

+	in_varstripchop,

+	in_varslash,

+	in_varmatch,

+	in_varpresubst,

+	in_varsubst,

+	in_varcolon,

+	in_varminus,

+	in_varplus,

+	in_varpos,

+	in_postvarpos,

+	in_varlen,

+	in_varsubstring,

+	in_varend,

+	in_evalstart,

+	in_mathexpand,

+	in_dblparen_eol,

+	in_varif,

+	in_postvarif,

+	in_varelse,

+	nostate,

+} var_parser_state_t;

+

+const static char * const var_parser_statenames [ ] = {

+	"in string",

+	"in escape",

+	"in var",

+	"in plainvarstart",