# HG changeset patch

# Parent 456d832740146c5c9a0428c9ca0a1a0c431481b0

[work-in-progress] Use templates for statusbars

diff -r 456d83274014 mcabber/CMakeLists.txt

--- a/mcabber/CMakeLists.txt	Fri Jul 20 17:29:53 2012 +0300

+++ b/mcabber/CMakeLists.txt	Fri Jul 20 17:30:20 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 456d83274014 mcabber/mcabber/parser.c

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

+++ b/mcabber/mcabber/parser.c	Fri Jul 20 17:30:20 2012 +0300

@@ -0,0 +1,853 @@

+

+/* 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"

+

+//

+//  Private types

+//

+

+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,

+	nostate,

+} tmpl_parser_state_t;

+

+const static char * const tmpl_statenames [ ] = {

+	"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",

+	"wrong state",

+};

+

+typedef enum {

+	no_eol         =  0x0,

+	brace_eol      =  0x1,

+	slash_eol      =  0x2,

+	colon_eol      =  0x4,

+	paren_eol      =  0x8,

+	dblparen_eol   = 0x10,

+	balance_parens = 0x20,

+} tmpl_parser_flags_t;

+

+typedef enum {

+	no_operation,

+	expand_var,

+	value_length,

+} tmpl_var_operation_t;

+

+typedef enum {

+	no_op,

+	noempty_op,

+	paren_op,

+	plus_op,

+	minus_op,

+	remainder_op,

+	division_op,

+	multiplication_op,

+} tmpl_math_op_t;

+

+typedef enum {

+	in_preargument,

+	in_hexoctzero,

+	in_number,

+	in_variable,

+	in_postparen,

+	in_op,

+} tmpl_math_state_t;

+

+//

+//  Code

+//

+

+GQuark tmpl_gerror_quark ( void )

+{

+	return g_quark_from_static_string ( "tmpl_gerror_quark" );

+}

+

+// 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 );

+}

+

+// - + * / % ( )

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

+{

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

+

+	gssize             result   = 0;

+	const char *       p        = str;

+	const char * const e        = str + length;

+	tmpl_math_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 ) {