Author: peter
Date: 2007-12-27 13:11:55 +0000 (Thu, 27 Dec 2007)
New Revision: 26509
Modified:
squeeze/trunk/libsqueeze/archive-iter.h
squeeze/trunk/libsqueeze/parser-context.c
squeeze/trunk/libsqueeze/parser-context.h
squeeze/trunk/libsqueeze/parser.c
squeeze/trunk/libsqueeze/parser.h
squeeze/trunk/libsqueeze/scanf-parser.c
squeeze/trunk/libsqueeze/scanf-parser.h
squeeze/trunk/src/main_window.c
Log:
scanf parser update
Modified: squeeze/trunk/libsqueeze/archive-iter.h
===================================================================
--- squeeze/trunk/libsqueeze/archive-iter.h 2007-12-27 00:49:02 UTC (rev
26508)
+++ squeeze/trunk/libsqueeze/archive-iter.h 2007-12-27 13:11:55 UTC (rev
26509)
@@ -45,6 +45,7 @@
LSQArchiveIter *lsq_archive_iter_ref(LSQArchiveIter *iter);
void lsq_archive_iter_unref(LSQArchiveIter *iter);
+LSQArchiveIter *lsq_archive_add_file(LSQArchive *archive, const gchar *path);
G_END_DECLS
Modified: squeeze/trunk/libsqueeze/parser-context.c
===================================================================
--- squeeze/trunk/libsqueeze/parser-context.c 2007-12-27 00:49:02 UTC (rev
26508)
+++ squeeze/trunk/libsqueeze/parser-context.c 2007-12-27 13:11:55 UTC (rev
26509)
@@ -84,7 +84,7 @@
g_return_val_if_fail(LSQ_IS_ARCHIVE(archive), NULL);
- ctx = g_object_new(LSQ_PARSER_CONTEXT_TYPE, "archive", archive);
+ ctx = g_object_new(LSQ_TYPE_PARSER_CONTEXT, "archive", archive);
return ctx;
}
Modified: squeeze/trunk/libsqueeze/parser-context.h
===================================================================
--- squeeze/trunk/libsqueeze/parser-context.h 2007-12-27 00:49:02 UTC (rev
26508)
+++ squeeze/trunk/libsqueeze/parser-context.h 2007-12-27 13:11:55 UTC (rev
26509)
@@ -18,25 +18,25 @@
G_BEGIN_DECLS
-#define LSQ_PARSER_CONTEXT_TYPE lsq_parser_context_get_type()
+#define LSQ_TYPE_PARSER_CONTEXT lsq_parser_context_get_type()
#define LSQ_PARSER_CONTEXT(obj) ( \
G_TYPE_CHECK_INSTANCE_CAST ((obj), \
- LSQ_PARSER_CONTEXT_TYPE,
\
+ LSQ_TYPE_PARSER_CONTEXT,
\
LSQParserContext))
#define LSQ_IS_PARSER_CONTEXT(obj) ( \
G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
- LSQ_PARSER_CONTEXT_TYPE))
+ LSQ_TYPE_PARSER_CONTEXT))
#define LSQ_PARSER_CONTEXT_CLASS(class) ( \
G_TYPE_CHECK_CLASS_CAST ((class), \
- LSQ_PARSER_CONTEXT_TYPE,
\
+ LSQ_TYPE_PARSER_CONTEXT,
\
LSQParserContextClass))
#define LSQ_IS_PARSER_CONTEXT_CLASS(class) ( \
G_TYPE_CHECK_CLASS_TYPE ((class), \
- LSQ_PARSER_CONTEXT_TYPE))
+ LSQ_TYPE_PARSER_CONTEXT))
typedef struct _LSQParserContext LSQParserContext;
Modified: squeeze/trunk/libsqueeze/parser.c
===================================================================
--- squeeze/trunk/libsqueeze/parser.c 2007-12-27 00:49:02 UTC (rev 26508)
+++ squeeze/trunk/libsqueeze/parser.c 2007-12-27 13:11:55 UTC (rev 26509)
@@ -48,3 +48,13 @@
return klass->get_context(self, archive);
}
+void
+lsq_parser_parse(LSQParser *self, LSQParserContext *ctx)
+{
+ LSQParserClass *klass = LSQ_PARSER_GET_CLASS(self);
+
+ g_return_if_fail(klass->parse);
+
+ klass->parse(self, ctx);
+}
+
Modified: squeeze/trunk/libsqueeze/parser.h
===================================================================
--- squeeze/trunk/libsqueeze/parser.h 2007-12-27 00:49:02 UTC (rev 26508)
+++ squeeze/trunk/libsqueeze/parser.h 2007-12-27 13:11:55 UTC (rev 26509)
@@ -59,6 +59,7 @@
GObjectClass parent;
LSQParserContext*(*get_context)(LSQParser *, LSQArchive *);
+ void(*parse)(LSQParser *, LSQParserContext *);
};
@@ -66,6 +67,8 @@
LSQParserContext* lsq_parser_get_context(LSQParser *, LSQArchive *);
+void lsq_parser_parse(LSQParser *, LSQParserContext *);
+
G_END_DECLS
#endif /* __LIBSQUEEZE_PARSER_H__ */
Modified: squeeze/trunk/libsqueeze/scanf-parser.c
===================================================================
--- squeeze/trunk/libsqueeze/scanf-parser.c 2007-12-27 00:49:02 UTC (rev
26508)
+++ squeeze/trunk/libsqueeze/scanf-parser.c 2007-12-27 13:11:55 UTC (rev
26509)
@@ -30,316 +30,399 @@
typedef struct _parse_part parse_part;
typedef struct _LSQScanfParserContext LSQScanfParserContext;
+typedef struct _LSQScanfParserContextClass LSQScanfParserContextClass;
typedef guint (*LSQParseFunc)(gchar*, guint, parse_part*,
LSQScanfParserContext*);
struct _parse_part
{
- gchar *delimiter;
- LSQParseFunc function;
- guint index;
- guint width;
+ parse_part *next;
+ gchar *delimiter;
+ LSQParseFunc function;
+ guint index;
+ guint width;
};
struct _LSQScanfParserContext
{
+ LSQParserContext parent;
gchar *filename;
- LSQParserContext parser;
- union {
- gchar c;
- gint i;
- guint u;
- glong l;
- gulong ul;
- gint64 ll;
- guint64 ull;
- gfloat f;
- gdouble d;
+ union _data_store {
+ gchar c;
+ gint i;
+ guint u;
+ glong l;
+ gulong ul;
+ gint64 ll;
+ guint64 ull;
+ gfloat f;
+ gdouble d;
} *data_store;
gpointer *props_store;
+ parse_part *parse_loc;
+ guint parse_line;
};
+struct _LSQScanfParserContextClass
+{
+ LSQParserContextClass parent;
+};
+
+struct _LSQScanfParser
+{
+ LSQParser parent;
+
+ guint num_props;
+ gchar **prop_names;
+ GType *prop_types;
+ parse_part *parser;
+
+};
+
+struct _LSQScanfParserClass
+{
+ LSQParserClass parent;
+};
+
+G_DEFINE_TYPE(LSQScanfParserContext, lsq_scanf_parser_context,
LSQ_TYPE_PARSER_CONTEXT);
+
+static void
+lsq_scanf_parser_context_init(LSQScanfParserContext *self)
+{
+}
+
+static void
+lsq_scanf_parser_context_class_init(LSQScanfParserContextClass *klass)
+{
+}
+
+static LSQParserContext *lsq_scanf_parser_context_new(LSQScanfParser *parser,
LSQArchive *archive)
+{
+ LSQScanfParserContext *ctx;
+
+ ctx = g_object_new(lsq_scanf_parser_context_get_type(), "archive",
archive);
+
+ ctx->data_store = g_new0(union _data_store, parser->num_props);
+ ctx->props_store = g_new0(gpointer, parser->num_props);
+
+ lsq_archive_set_properties(archive, parser->num_props, parser->prop_names,
parser->prop_types);
+
+ return LSQ_PARSER_CONTEXT(ctx);
+}
+
+static void build_parser(LSQScanfParser *, const gchar *, const gchar *);
+
+static void lsq_scanf_parser_parse(LSQScanfParser *, LSQScanfParserContext *);
+
+static LSQParserContext *lsq_scanf_parser_get_context(LSQScanfParser *,
LSQArchive *);
+
+G_DEFINE_TYPE(LSQScanfParser, lsq_scanf_parser, LSQ_TYPE_PARSER);
+
+static void
+lsq_scanf_parser_init(LSQScanfParser *self)
+{
+}
+
+static void
+lsq_scanf_parser_class_init(LSQScanfParserClass *klass)
+{
+ LSQParserClass *parser_class = LSQ_PARSER_CLASS(klass);
+ parser_class->get_context =
(LSQParserContext*(*)(LSQParser*,LSQArchive*))lsq_scanf_parser_context_new;
+ parser_class->parse =
(void(*)(LSQParser*,LSQParserContext*))lsq_scanf_parser_parse;
+}
+
+LSQParser *lsq_scanf_parser_new(const gchar *names_string, const gchar
*parser_string)
+{
+ LSQScanfParser *parser;
+
+ parser = g_object_new(LSQ_TYPE_SCANF_PARSER, NULL);
+
+ build_parser(parser, names_string, parser_string);
+
+ return LSQ_PARSER(parser);
+}
+
/*{{{ skip functions*/
guint skip_byte(gchar *str, guint lng, parse_part *part, LSQScanfParserContext
*ctx)
{
- if(lng < 1)
- return 0;
-
- return 1;
+ if(lng < 1)
+ return 0;
+
+ return 1;
}
guint skip_word(gchar *str, guint lng, parse_part *part, LSQScanfParserContext
*ctx)
{
- if(lng < 2)
- return 0;
-
- return 2;
+ if(lng < 2)
+ return 0;
+
+ return 2;
}
guint skip_dword(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- if(lng < 4)
- return 0;
-
- return 4;
+ if(lng < 4)
+ return 0;
+
+ return 4;
}
guint skip_qword(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- if(lng < 8)
- return 0;
-
- return 8;
+ if(lng < 8)
+ return 0;
+
+ return 8;
}
guint skip_char(gchar *str, guint lng, parse_part *part, LSQScanfParserContext
*ctx)
{
- const gchar *ptr;
+ const gchar *ptr;
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- return 1;
+ if(!part->delimiter[0])
+ return 1;
- //for(ptr = str; g_ascii_isspace(*ptr); ptr++);
+ //for(ptr = str; g_ascii_isspace(*ptr); ptr++);
- ptr = g_strstr_len(str, lng, part->delimiter);
-
- return ptr - str;
+ ptr = g_strstr_len(str, lng, part->delimiter);
+
+ return ptr - str;
}
guint skip_decimal(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- gchar *ptr;
+ gchar *ptr;
#ifdef DO_EXSTENSIVE_CHECKING
- gchar *ptr2;
+ gchar *ptr2;
#endif
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- {
- g_ascii_strtoll(str, &ptr, 10);
- return ptr - str;
- }
+ if(!part->delimiter[0])
+ {
+ g_ascii_strtoll(str, &ptr, 10);
+ return ptr - str;
+ }
- for(ptr = str; g_ascii_isspace(*ptr); ptr++);
+ for(ptr = str; g_ascii_isspace(*ptr); ptr++);
- ptr = g_strstr_len(ptr, lng, part->delimiter);
+ ptr = g_strstr_len(ptr, lng, part->delimiter);
#ifdef DO_EXSTENSIVE_CHECKING
- g_ascii_strtoll(str, &ptr2, 10);
- if(ptr > ptr2)
- return 0;
+ g_ascii_strtoll(str, &ptr2, 10);
+ if(ptr > ptr2)
+ return 0;
#endif
-
- return ptr - str;
+
+ return ptr - str;
}
guint skip_floatingpoint(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- gchar *ptr;
+ gchar *ptr;
#ifdef DO_EXSTENSIVE_CHECKING
- gchar *ptr2;
+ gchar *ptr2;
#endif
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- {
- g_ascii_strtod(str, &ptr);
- return ptr - str;
- }
+ if(!part->delimiter[0])
+ {
+ g_ascii_strtod(str, &ptr);
+ return ptr - str;
+ }
- for(ptr = str; g_ascii_isspace(*ptr); ptr++);
+ for(ptr = str; g_ascii_isspace(*ptr); ptr++);
- ptr = g_strstr_len(ptr, lng, part->delimiter);
+ ptr = g_strstr_len(ptr, lng, part->delimiter);
#ifdef DO_EXSTENSIVE_CHECKING
- g_ascii_strtod(str, &ptr2);
- if(ptr > ptr2)
- return 0;
+ g_ascii_strtod(str, &ptr2);
+ if(ptr > ptr2)
+ return 0;
#endif
-
- return ptr - str;
+
+ return ptr - str;
}
guint skip_octal(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- gchar *ptr;
+ gchar *ptr;
#ifdef DO_EXSTENSIVE_CHECKING
- gchar *ptr2;
+ gchar *ptr2;
#endif
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- {
- g_ascii_strtoll(str, &ptr, 010);
- return ptr - str;
- }
+ if(!part->delimiter[0])
+ {
+ g_ascii_strtoll(str, &ptr, 010);
+ return ptr - str;
+ }
- for(ptr = str; g_ascii_isspace(*ptr); ptr++);
+ for(ptr = str; g_ascii_isspace(*ptr); ptr++);
- ptr = g_strstr_len(ptr, lng, part->delimiter);
+ ptr = g_strstr_len(ptr, lng, part->delimiter);
#ifdef DO_EXSTENSIVE_CHECKING
- g_ascii_strtoll(str, &ptr2, 010);
- if(ptr > ptr2)
- return 0;
+ g_ascii_strtoll(str, &ptr2, 010);
+ if(ptr > ptr2)
+ return 0;
#endif
-
- return ptr - str;
+
+ return ptr - str;
}
guint skip_string(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- gchar *ptr;
+ gchar *ptr;
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- return 0;
+ if(!part->delimiter[0])
+ return 0;
- for(ptr = str; g_ascii_isspace(*ptr); ptr++);
+ for(ptr = str; g_ascii_isspace(*ptr); ptr++);
- ptr = g_strstr_len(ptr, lng, part->delimiter);
-
- return ptr - str;
+ ptr = g_strstr_len(ptr, lng, part->delimiter);
+
+ return ptr - str;
}
guint skip_unsigned(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- gchar *ptr;
+ gchar *ptr;
#ifdef DO_EXSTENSIVE_CHECKING
- gchar *ptr2;
+ gchar *ptr2;
#endif
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- {
- g_ascii_strtoull(str, &ptr, 10);
- return ptr - str;
- }
+ if(!part->delimiter[0])
+ {
+ g_ascii_strtoull(str, &ptr, 10);
+ return ptr - str;
+ }
- ptr = g_strstr_len(str, lng, part->delimiter);
+ ptr = g_strstr_len(str, lng, part->delimiter);
#ifdef DO_EXSTENSIVE_CHECKING
- g_ascii_strtoull(str, &ptr2, 10);
- if(ptr > ptr2)
- return 0;
+ g_ascii_strtoull(str, &ptr2, 10);
+ if(ptr > ptr2)
+ return 0;
#endif
-
- return ptr - str;
+
+ return ptr - str;
}
guint skip_hexadecimal(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- gchar *ptr;
+ gchar *ptr;
#ifdef DO_EXSTENSIVE_CHECKING
- gchar *ptr2;
+ gchar *ptr2;
#endif
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- {
- g_ascii_strtoll(str, &ptr, 0x10);
- return ptr - str;
- }
+ if(!part->delimiter[0])
+ {
+ g_ascii_strtoll(str, &ptr, 0x10);
+ return ptr - str;
+ }
- ptr = g_strstr_len(str, lng, part->delimiter);
+ ptr = g_strstr_len(str, lng, part->delimiter);
#ifdef DO_EXSTENSIVE_CHECKING
- g_ascii_strtoll(str, &ptr2, 0x10);
- if(ptr > ptr2)
- return 0;
+ g_ascii_strtoll(str, &ptr2, 0x10);
+ if(ptr > ptr2)
+ return 0;
#endif
-
- return ptr - str;
+
+ return ptr - str;
}
/*}}}*/
/*{{{ parse functions*/
#define DEF_PARSE_BIN(func, bytes, type, ptype, pname) \
guint parse_##func(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx) { \
- type val; \
+ type val; \
ptype *pval; \
- if(lng < bytes) return 0; \
+ if(lng < bytes) return 0; \
val = *((type*)str); \
- pval = &ctx->data_store[part->index].pname; \
+ pval = &ctx->data_store[part->index].pname; \
*pval = val; \
ctx->props_store[part->index] = pval; \
- return bytes; \
+ return bytes; \
}
#define DEF_PARSE_NUM(func, base, type, ptype, pname) \
guint parse_##func(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx) { \
- gchar *ptr; \
- gchar *ptr2; \
- type val; \
+ gchar *ptr; \
+ gchar *ptr2; \
+ type val; \
ptype *pval; \
- if(!lng) return 0; \
- pval = &ctx->data_store[part->index].pname; \
+ if(!lng) return 0; \
+ pval = &ctx->data_store[part->index].pname; \
ctx->props_store[part->index] = pval; \
- if(!part->delimiter[0]) { \
- val = g_ascii_strtoll(str, &ptr, base); \
- *pval = val; \
- return ptr - str; \
- } \
- for(ptr = str; g_ascii_isspace(*ptr); ptr++); \
- ptr = g_strstr_len(ptr, lng, part->delimiter); \
+ if(!part->delimiter[0]) { \
+ val = g_ascii_strtoll(str, &ptr, base); \
+ *pval = val; \
+ return ptr - str; \
+ } \
+ for(ptr = str; g_ascii_isspace(*ptr); ptr++); \
+ ptr = g_strstr_len(ptr, lng, part->delimiter); \
val = g_ascii_strtoll(str, &ptr2, base); \
*pval = val; \
- if(ptr > ptr2) return 0; \
- return ptr - str; \
+ if(ptr > ptr2) return 0; \
+ return ptr - str; \
}
#define DEF_PARSE_FLOAT(func, type, pname) \
guint parse_##func(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx) { \
- gchar *ptr; \
- gchar *ptr2; \
- type val; \
+ gchar *ptr; \
+ gchar *ptr2; \
+ type val; \
type *pval; \
- if(!lng) return 0; \
- pval = &ctx->data_store[part->index].pname; \
+ if(!lng) return 0; \
+ pval = &ctx->data_store[part->index].pname; \
ctx->props_store[part->index] = pval; \
- if(!part->delimiter[0]) { \
- val = g_ascii_strtod(str, &ptr); \
- *pval = val; \
- return ptr - str; \
- } \
- for(ptr = str; g_ascii_isspace(*ptr); ptr++); \
- ptr = g_strstr_len(ptr, lng, part->delimiter); \
+ if(!part->delimiter[0]) { \
+ val = g_ascii_strtod(str, &ptr); \
+ *pval = val; \
+ return ptr - str; \
+ } \
+ for(ptr = str; g_ascii_isspace(*ptr); ptr++); \
+ ptr = g_strstr_len(ptr, lng, part->delimiter); \
val = g_ascii_strtod(str, &ptr2); \
*pval = val; \
- if(ptr > ptr2) return 0; \
- return ptr - str; \
+ if(ptr > ptr2) return 0; \
+ return ptr - str; \
}
#define DEF_PARSE_UNS(func, base, type, ptype, pname) \
guint parse_##func(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx) { \
- gchar *ptr; \
- gchar *ptr2; \
- type val; \
+ gchar *ptr; \
+ gchar *ptr2; \
+ type val; \
ptype *pval; \
- if(!lng) return 0; \
- pval = &ctx->data_store[part->index].pname; \
+ if(!lng) return 0; \
+ pval = &ctx->data_store[part->index].pname; \
ctx->props_store[part->index] = pval; \
- if(!part->delimiter[0]) { \
- val = g_ascii_strtoull(str, &ptr, base); \
- *pval = val; \
- return ptr - str; \
- } \
- for(ptr = str; g_ascii_isspace(*ptr); ptr++); \
- ptr = g_strstr_len(ptr, lng, part->delimiter); \
+ if(!part->delimiter[0]) { \
+ val = g_ascii_strtoull(str, &ptr, base); \
+ *pval = val; \
+ return ptr - str; \
+ } \
+ for(ptr = str; g_ascii_isspace(*ptr); ptr++); \
+ ptr = g_strstr_len(ptr, lng, part->delimiter); \
val = g_ascii_strtoull(str, &ptr2, base); \
*pval = val; \
- if(ptr > ptr2) return 0; \
- return ptr - str; \
+ if(ptr > ptr2) return 0; \
+ return ptr - str; \
}
DEF_PARSE_BIN(byte, 1, gchar, guint, u)
@@ -349,32 +432,32 @@
guint parse_char(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- const gchar *ptr;
+ const gchar *ptr;
gchar val;
gchar *pval;
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- pval = &ctx->data_store[part->index].c;
+ pval = &ctx->data_store[part->index].c;
ctx->props_store[part->index] = pval;
- if(!part->delimiter[0])
+ if(!part->delimiter[0])
{
- val = *str;
- *pval = val;
- return 1;
+ val = *str;
+ *pval = val;
+ return 1;
}
- //for(ptr = str; g_ascii_isspace(*ptr); ptr++);
+ //for(ptr = str; g_ascii_isspace(*ptr); ptr++);
- ptr = g_strstr_len(str, lng, part->delimiter);
+ ptr = g_strstr_len(str, lng, part->delimiter);
//FIXME?
val = *(ptr-1);
*pval = val;
-
- return ptr - str;
+
+ return ptr - str;
}
DEF_PARSE_NUM(decimal, 10, gint, gint, i)
@@ -392,22 +475,22 @@
guint parse_string(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- gchar *ptr;
- gchar *cur;
+ gchar *ptr;
+ gchar *cur;
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- return 0;
+ if(!part->delimiter[0])
+ return 0;
- for(cur = str; g_ascii_isspace(*cur); cur++);
+ for(cur = str; g_ascii_isspace(*cur); cur++);
- ptr = g_strstr_len(cur, lng, part->delimiter);
+ ptr = g_strstr_len(cur, lng, part->delimiter);
ctx->props_store[part->index] = g_strndup(cur, ptr-cur);
- return ptr - str;
+ return ptr - str;
}
DEF_PARSE_UNS(unsigned, 10, guint, guint, u)
@@ -422,540 +505,634 @@
guint parse_filename(gchar *str, guint lng, parse_part *part,
LSQScanfParserContext *ctx)
{
- gchar *ptr;
+ gchar *ptr;
- if(!lng)
- return 0;
+ if(!lng)
+ return 0;
- if(!part->delimiter[0])
- return 0;
+ if(!part->delimiter[0])
+ return 0;
- ptr = g_strstr_len(str, lng, part->delimiter);
+ ptr = g_strstr_len(str, lng, part->delimiter);
ctx->filename = g_strndup(str, ptr-str);
- return ptr - str;
+ return ptr - str;
}
/*}}}*/
gchar* strdup_escaped(const gchar *str, guint lng)/*{{{*/
{
- guint i;
- gchar *new_str;
- gchar ch;
- guint size = 0;
+ guint i;
+ gchar *new_str;
+ gchar ch;
+ guint size = 0;
- for(i = 0; i < lng; i++)
- {
- switch(str[i])
- {
- case '%':
- i++;
- break;
- case '\\':
- i++;
- switch(str[i])
- {
- case 'x':
- if(g_ascii_isxdigit(str[i+1]))
- {
- i++;
-
if(g_ascii_isxdigit(str[i+1]))
- {
- i++;
- }
- }
- break;
- default:
- ch = str[i+1];
- if(ch>='0' && ch < '8')
- {
- i++;
- ch = str[i+1];
- if(ch>='0' && ch < '8')
- {
- ch = str[i];
- i++;
- if(ch < '4')
- {
- ch =
str[i+1];
-
if(str[i+1]>='0' && str[i+1] < '8')
- {
-
i++;
- }
- }
- }
- }
- break;
- }
- break;
- }
- size++;
- }
+ for(i = 0; i < lng; i++)
+ {
+ switch(str[i])
+ {
+ case '%':
+ i++;
+ break;
+ case '\\':
+ i++;
+ switch(str[i])
+ {
+ case 'x':
+ if(g_ascii_isxdigit(str[i+1]))
+ {
+ i++;
+ if(g_ascii_isxdigit(str[i+1]))
+ {
+ i++;
+ }
+ }
+ break;
+ default:
+ ch = str[i+1];
+ if(ch>='0' && ch < '8')
+ {
+ i++;
+ ch = str[i+1];
+ if(ch>='0' && ch < '8')
+ {
+ ch = str[i];
+ i++;
+ if(ch < '4')
+ {
+ ch = str[i+1];
+ if(str[i+1]>='0' && str[i+1] < '8')
+ {
+ i++;
+ }
+ }
+ }
+ }
+ break;
+ }
+ break;
+ }
+ size++;
+ }
- new_str = g_new(gchar, size+1);
- new_str[size] = '\0';
+ new_str = g_new(gchar, size+1);
+ new_str[size] = '\0';
- size = 0;
- for(i = 0; i < lng; i++)
- {
- switch(ch = str[i])
- {
- case '%':
- i++;
- ch = str[i];
- break;
- case '\\':
- i++;
- switch(ch = str[i])
- {
- case 'a':
- ch = '\a';
- break;
- case 'b':
- ch = '\b';
- break;
- case 'f':
- ch = '\f';
- break;
- case 'n':
- ch = '\n';
- break;
- case 'r':
- ch = '\r';
- break;
- case 't':
- ch = '\t';
- break;
- case 'v':
- ch = '\v';
- break;
- case 'x':
- if(g_ascii_isxdigit(str[i+1]))
- {
- i++;
- ch =
g_ascii_xdigit_value(str[i]);
-
if(g_ascii_isxdigit(str[i+1]))
- {
- i++;
- ch = (ch*0x10)
+ g_ascii_xdigit_value(str[i]);
- }
- }
- break;
- default:
- if(str[i+1]>='0' && str[i+1] <
'8')
- {
- i++;
- ch = str[i]-'0';
- if(str[i+1]>='0' &&
str[i+1] < '8')
- {
- i++;
- if((ch =
(ch*010) + (str[i]-'0')) < 040)
- {
-
if(str[i+1]>='0' && str[i+1] < '8')
- {
-
i++;
-
ch = (ch*010) + (str[i]-'0');
- }
- }
- }
- }
- break;
- }
- break;
- }
- new_str[size++] = ch;
- }
+ size = 0;
+ for(i = 0; i < lng; i++)
+ {
+ switch(ch = str[i])
+ {
+ case '%':
+ i++;
+ ch = str[i];
+ break;
+ case '\\':
+ i++;
+ switch(ch = str[i])
+ {
+ case 'a':
+ ch = '\a';
+ break;
+ case 'b':
+ ch = '\b';
+ break;
+ case 'f':
+ ch = '\f';
+ break;
+ case 'n':
+ ch = '\n';
+ break;
+ case 'r':
+ ch = '\r';
+ break;
+ case 't':
+ ch = '\t';
+ break;
+ case 'v':
+ ch = '\v';
+ break;
+ case 'x':
+ if(g_ascii_isxdigit(str[i+1]))
+ {
+ i++;
+ ch = g_ascii_xdigit_value(str[i]);
+ if(g_ascii_isxdigit(str[i+1]))
+ {
+ i++;
+ ch = (ch*0x10) + g_ascii_xdigit_value(str[i]);
+ }
+ }
+ break;
+ default:
+ if(str[i+1]>='0' && str[i+1] < '8')
+ {
+ i++;
+ ch = str[i]-'0';
+ if(str[i+1]>='0' && str[i+1] < '8')
+ {
+ i++;
+ if((ch = (ch*010) + (str[i]-'0')) < 040)
+ {
+ if(str[i+1]>='0' && str[i+1] < '8')
+ {
+ i++;
+ ch = (ch*010) + (str[i]-'0');
+ }
+ }
+ }
+ }
+ break;
+ }
+ break;
+ }
+ new_str[size++] = ch;
+ }
- return new_str;
+ return new_str;
}/*}}}*/
-void build_parser(LSQArchive *archive, const gchar *parser_string)
+static void build_parser(LSQScanfParser *parser, const gchar *names_string,
const gchar *parser_string)
{
- const gchar *ptr;
- const gchar *cur;
- gchar *pos;
- gchar ch;
- enum {
- SIZE_NORMAL = FALSE,
- SIZE_SHORT,
- SIZE_LONG,
- SIZE_LONGLONG
- } size_flag;
- gboolean skip_flag;
- guint width_flag;
- guint index_flag;
- guint index;
+ const gchar *ptr;
+ const gchar *cur;
+ gchar *pos;
+ gchar ch;
+ enum {
+ SIZE_NORMAL = FALSE,
+ SIZE_SHORT,
+ SIZE_LONG,
+ SIZE_LONGLONG
+ } size_flag;
+ gboolean skip_flag;
+ guint width_flag;
+ guint index_flag;
+ guint index;
- parse_part *part = g_new0(parse_part, 1);
- GSList *parts = g_slist_prepend(NULL, part);
- guint part_count = 0;
+ gchar **names = g_strsplit(names_string, "|", -1);
+ g_return_if_fail(names);
+ guint num_props = g_strv_length(names);
+ GType *prop_types = g_new0(GType, num_props);
- cur = ptr = parser_string;
+ parse_part *part = g_new0(parse_part, 1);
+ parse_part *parts = part;
+ guint part_count = 0;
- while((ch = *ptr++))
- {
- if(ch == '\\' && *ptr == 'n')
- {
- part->delimiter = strdup_escaped(cur, ptr-cur);
- part = g_new0(parse_part, 1);
- parts = g_slist_prepend(parts, part);
- cur = ++ptr;
- continue;
- }
- if(ch == '%')
- {
- skip_flag = FALSE;
- size_flag = SIZE_NORMAL;
- width_flag = 0;
- index = part_count;
+ cur = ptr = parser_string;
- if(!(ch = *ptr++))
- break;
+ while((ch = *ptr++))
+ {
+ if(ch == '\\' && *ptr == 'n')
+ {
+ part->delimiter = strdup_escaped(cur, ptr-cur);
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ cur = ++ptr;
+ continue;
+ }
+ if(ch == '%')
+ {
+ skip_flag = FALSE;
+ size_flag = SIZE_NORMAL;
+ width_flag = 0;
+ index = part_count;
- if(ch == '%')
- continue;
+ if(!(ch = *ptr++))
+ break;
- part->delimiter = strdup_escaped(cur, ptr-cur-1);
+ if(ch == '%')
+ continue;
- /*{{{ check differend index %.$*/
- if(g_ascii_isdigit(ch))
- {
- index_flag = g_ascii_strtoull(ptr-1, &pos, 10);
- if(*pos == '$')
- {
- ptr = pos+1;
- index = index_flag-1;
- if(!(ch = *ptr++))
- break;
- }
- }
- /*}}}*/
+ part->delimiter = strdup_escaped(cur, ptr-cur-1);
- /*{{{ check skip flag %*.*/
- if(ch == '*')
- {
- skip_flag = TRUE;
- if(!(ch = *ptr++))
- break;
- }
- /*}}}*/
+ /*{{{ check differend index %.$*/
+ if(g_ascii_isdigit(ch))
+ {
+ index_flag = g_ascii_strtoull(ptr-1, &pos, 10);
+ if(*pos == '$')
+ {
+ ptr = pos+1;
+ index = index_flag-1;
+ if(!(ch = *ptr++))
+ break;
+ }
+ }
+ /*}}}*/
- /*{{{ check max characters %.*/
- //ignored for now
- if(g_ascii_isdigit(ch))
- {
- width_flag = g_ascii_strtoull(ptr-1, (gchar
**)&ptr, 10);
- if(!(ch = *ptr++))
- break;
- }
- /*}}}*/
+ //FIXME: should be done neat
+ g_return_if_fail(index < num_props);
- /*{{{ check size flag %[hlL].*/
- switch(ch)
- {
- case 'h':
- size_flag = SIZE_SHORT;
- ch = *ptr++;
- break;
- case 'l':
- size_flag = SIZE_LONG;
- ch = *ptr++;
- if(ch != 'l')
- break;
- case 'L':
- size_flag = SIZE_LONGLONG;
- ch = *ptr++;
- break;
- }
- if(!ch)
- break;
- /*}}}*/
+ /*{{{ check skip flag %*.*/
+ if(ch == '*')
+ {
+ skip_flag = TRUE;
+ if(!(ch = *ptr++))
+ break;
+ }
+ /*}}}*/
- switch(ch)
- {
- /*{{{ byte %b*/
- case 'b':
- if(width_flag)
- return;
- part = g_new0(parse_part, 1);
- if(skip_flag)
- {
- switch(size_flag)
- {
- case SIZE_NORMAL:
- part->function
= skip_byte;
- break;
- case SIZE_SHORT:
- part->function
= skip_word;
- break;
- case SIZE_LONG:
- part->function
= skip_dword;
- break;
- case SIZE_LONGLONG:
- part->function
= skip_qword;
- break;
- }
- }
- else
- {
- part_count++;
- part->index = index;
- switch(size_flag)
- {
- case SIZE_NORMAL:
- part->function
= parse_byte;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT);
- break;
- case SIZE_SHORT:
- part->function
= parse_word;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT);
- break;
- case SIZE_LONG:
- part->function
= parse_dword;
-
lsq_archive_set_property_type(archive, index, G_TYPE_ULONG);
- break;
- case SIZE_LONGLONG:
- part->function
= parse_qword;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT64);
- break;
- }
- }
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- /*{{{ character %c*/
- case 'c':
- if(size_flag || width_flag)
- return;
- part = g_new0(parse_part, 1);
- if(skip_flag)
- {
- part->function = skip_char;
- }
- else
- {
- part_count++;
- part->index = index;
- part->function = parse_char;
-
lsq_archive_set_property_type(archive, index, G_TYPE_CHAR);
- }
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- /*{{{ decimal %d*/
- case 'd':
- //case 'i':
- part = g_new0(parse_part, 1);
- part->width = width_flag;
- if(skip_flag)
- {
- part->function = skip_decimal;
- }
- else
- {
- part_count++;
- part->index = index;
- switch(size_flag)
- {
- case SIZE_NORMAL:
- part->function
= parse_decimal;
-
lsq_archive_set_property_type(archive, index, G_TYPE_INT);
- break;
- case SIZE_SHORT:
- part->function
= parse_decimal16;
-
lsq_archive_set_property_type(archive, index, G_TYPE_INT);
- break;
- case SIZE_LONG:
- part->function
= parse_decimal32;
-
lsq_archive_set_property_type(archive, index, G_TYPE_LONG);
- break;
- case SIZE_LONGLONG:
- part->function
= parse_decimal64;
-
lsq_archive_set_property_type(archive, index, G_TYPE_INT64);
- break;
- }
- }
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- /*{{{ floating point %d*/
- case 'f':
- if(size_flag && size_flag !=
SIZE_LONGLONG)
- return;
- part = g_new0(parse_part, 1);
- part->width = width_flag;
- if(skip_flag)
- {
- part->function =
skip_floatingpoint;
- }
- else
- {
- part_count++;
- part->index = index;
- switch(size_flag)
- {
- case SIZE_NORMAL:
- part->function
= parse_floatingpoint;
-
lsq_archive_set_property_type(archive, index, G_TYPE_FLOAT);
- break;
- case SIZE_LONGLONG:
- part->function
= parse_double;
-
lsq_archive_set_property_type(archive, index, G_TYPE_DOUBLE);
- break;
- default:
- break;
- }
- }
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- /*{{{ octal %o*/
- case 'o':
- part = g_new0(parse_part, 1);
- part->width = width_flag;
- if(skip_flag)
- {
- part->function = skip_octal;
- }
- else
- {
- part_count++;
- part->index = index;
- switch(size_flag)
- {
- case SIZE_NORMAL:
- part->function
= parse_octal;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT);
- break;
- case SIZE_SHORT:
- part->function
= parse_octal16;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT);
- break;
- case SIZE_LONG:
- part->function
= parse_octal32;
-
lsq_archive_set_property_type(archive, index, G_TYPE_ULONG);
- break;
- case SIZE_LONGLONG:
- part->function
= parse_octal64;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT64);
- break;
- }
- }
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- /*{{{ string %s*/
- case 's':
- if(size_flag)
- return;
- part = g_new0(parse_part, 1);
- part->width = width_flag;
- if(skip_flag)
- {
- part->function = skip_string;
- }
- else
- {
- part_count++;
- part->index = index;
- part->function = parse_string;
-
lsq_archive_set_property_type(archive, index, G_TYPE_STRING);
- }
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- /*{{{ unsigned decimal %u*/
- case 'u':
- part = g_new0(parse_part, 1);
- part->width = width_flag;
- if(skip_flag)
- {
- part->function = skip_unsigned;
- }
- else
- {
- part_count++;
- part->index = index;
- switch(size_flag)
- {
- case SIZE_NORMAL:
- part->function
= parse_unsigned;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT);
- break;
- case SIZE_SHORT:
- part->function
= parse_unsigned16;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT);
- break;
- case SIZE_LONG:
- part->function
= parse_unsigned32;
-
lsq_archive_set_property_type(archive, index, G_TYPE_ULONG);
- break;
- case SIZE_LONGLONG:
- part->function
= parse_unsigned64;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT64);
- break;
- }
- }
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- /*{{{ hexadecimal %x %X*/
- case 'x':
- case 'X':
- part = g_new0(parse_part, 1);
- part->width = width_flag;
- if(skip_flag)
- {
- part->function =
skip_hexadecimal;
- }
- else
- {
- part_count++;
- part->index = index;
- switch(size_flag)
- {
- case SIZE_NORMAL:
- part->function
= parse_hexadecimal;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT);
- break;
- case SIZE_SHORT:
- part->function
= parse_hexadecimal16;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT);
- break;
- case SIZE_LONG:
- part->function
= parse_hexadecimal32;
-
lsq_archive_set_property_type(archive, index, G_TYPE_ULONG);
- break;
- case SIZE_LONGLONG:
- part->function
= parse_hexadecimal64;
-
lsq_archive_set_property_type(archive, index, G_TYPE_UINT64);
- break;
- }
- }
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- /*{{{ filename %F*/
- case 'F':
- if(skip_flag || size_flag || width_flag)
- return;
- part = g_new0(parse_part, 1);
- part->function = parse_filename;
- parts = g_slist_prepend(parts, part);
- break;
- /*}}}*/
- default:
- return;
- }
- cur = ptr;
- }
- }
+ /*{{{ check max characters %.*/
+ //ignored for now
+ if(g_ascii_isdigit(ch))
+ {
+ width_flag = g_ascii_strtoull(ptr-1, (gchar **)&ptr, 10);
+ if(!(ch = *ptr++))
+ break;
+ }
+ /*}}}*/
+ /*{{{ check size flag %[hlL].*/
+ switch(ch)
+ {
+ case 'h':
+ size_flag = SIZE_SHORT;
+ ch = *ptr++;
+ break;
+ case 'l':
+ size_flag = SIZE_LONG;
+ ch = *ptr++;
+ if(ch != 'l')
+ break;
+ case 'L':
+ size_flag = SIZE_LONGLONG;
+ ch = *ptr++;
+ break;
+ }
+ if(!ch)
+ break;
+ /*}}}*/
+
+ switch(ch)
+ {
+ /*{{{ byte %b*/
+ case 'b':
+ if(width_flag)
+ return;
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ if(skip_flag)
+ {
+ switch(size_flag)
+ {
+ case SIZE_NORMAL:
+ part->function = skip_byte;
+ break;
+ case SIZE_SHORT:
+ part->function = skip_word;
+ break;
+ case SIZE_LONG:
+ part->function = skip_dword;
+ break;
+ case SIZE_LONGLONG:
+ part->function = skip_qword;
+ break;
+ }
+ }
+ else
+ {
+ part_count++;
+ part->index = index;
+ switch(size_flag)
+ {
+ case SIZE_NORMAL:
+ part->function = parse_byte;
+ prop_types[index] = G_TYPE_UINT;
+ break;
+ case SIZE_SHORT:
+ part->function = parse_word;
+ prop_types[index] = G_TYPE_UINT;
+ break;
+ case SIZE_LONG:
+ part->function = parse_dword;
+ prop_types[index] = G_TYPE_ULONG;
+ break;
+ case SIZE_LONGLONG:
+ part->function = parse_qword;
+ prop_types[index] = G_TYPE_UINT64;
+ break;
+ }
+ }
+ break;
+ /*}}}*/
+ /*{{{ character %c*/
+ case 'c':
+ if(size_flag || width_flag)
+ return;
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ if(skip_flag)
+ {
+ part->function = skip_char;
+ }
+ else
+ {
+ part_count++;
+ part->index = index;
+ part->function = parse_char;
+ prop_types[index] = G_TYPE_CHAR;
+ }
+ break;
+ /*}}}*/
+ /*{{{ decimal %d*/
+ case 'd':
+ //case 'i':
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ part->width = width_flag;
+ if(skip_flag)
+ {
+ part->function = skip_decimal;
+ }
+ else
+ {
+ part_count++;
+ part->index = index;
+ switch(size_flag)
+ {
+ case SIZE_NORMAL:
+ part->function = parse_decimal;
+ prop_types[index] = G_TYPE_INT;
+ break;
+ case SIZE_SHORT:
+ part->function = parse_decimal16;
+ prop_types[index] = G_TYPE_INT;
+ break;
+ case SIZE_LONG:
+ part->function = parse_decimal32;
+ prop_types[index] = G_TYPE_LONG;
+ break;
+ case SIZE_LONGLONG:
+ part->function = parse_decimal64;
+ prop_types[index] = G_TYPE_INT64;
+ break;
+ }
+ }
+ break;
+ /*}}}*/
+ /*{{{ floating point %d*/
+ case 'f':
+ if(size_flag && size_flag != SIZE_LONGLONG)
+ return;
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ part->width = width_flag;
+ if(skip_flag)
+ {
+ part->function = skip_floatingpoint;
+ }
+ else
+ {
+ part_count++;
+ part->index = index;
+ switch(size_flag)
+ {
+ case SIZE_NORMAL:
+ part->function = parse_floatingpoint;
+ prop_types[index] = G_TYPE_FLOAT;
+ break;
+ case SIZE_LONGLONG:
+ part->function = parse_double;
+ prop_types[index] = G_TYPE_DOUBLE;
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ /*}}}*/
+ /*{{{ octal %o*/
+ case 'o':
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ part->width = width_flag;
+ if(skip_flag)
+ {
+ part->function = skip_octal;
+ }
+ else
+ {
+ part_count++;
+ part->index = index;
+ switch(size_flag)
+ {
+ case SIZE_NORMAL:
+ part->function = parse_octal;
+ prop_types[index] = G_TYPE_UINT;
+ break;
+ case SIZE_SHORT:
+ part->function = parse_octal16;
+ prop_types[index] = G_TYPE_UINT;
+ break;
+ case SIZE_LONG:
+ part->function = parse_octal32;
+ prop_types[index] = G_TYPE_ULONG;
+ break;
+ case SIZE_LONGLONG:
+ part->function = parse_octal64;
+ prop_types[index] = G_TYPE_UINT64;
+ break;
+ }
+ }
+ break;
+ /*}}}*/
+ /*{{{ string %s*/
+ case 's':
+ if(size_flag)
+ return;
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ part->width = width_flag;
+ if(skip_flag)
+ {
+ part->function = skip_string;
+ }
+ else
+ {
+ part_count++;
+ part->index = index;
+ part->function = parse_string;
+ prop_types[index] = G_TYPE_STRING;
+ }
+ break;
+ /*}}}*/
+ /*{{{ unsigned decimal %u*/
+ case 'u':
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ part->width = width_flag;
+ if(skip_flag)
+ {
+ part->function = skip_unsigned;
+ }
+ else
+ {
+ part_count++;
+ part->index = index;
+ switch(size_flag)
+ {
+ case SIZE_NORMAL:
+ part->function = parse_unsigned;
+ prop_types[index] = G_TYPE_UINT;
+ break;
+ case SIZE_SHORT:
+ part->function = parse_unsigned16;
+ prop_types[index] = G_TYPE_UINT;
+ break;
+ case SIZE_LONG:
+ part->function = parse_unsigned32;
+ prop_types[index] = G_TYPE_ULONG;
+ break;
+ case SIZE_LONGLONG:
+ part->function = parse_unsigned64;
+ prop_types[index] = G_TYPE_UINT64;
+ break;
+ }
+ }
+ break;
+ /*}}}*/
+ /*{{{ hexadecimal %x %X*/
+ case 'x':
+ case 'X':
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ part->width = width_flag;
+ if(skip_flag)
+ {
+ part->function = skip_hexadecimal;
+ }
+ else
+ {
+ part_count++;
+ part->index = index;
+ switch(size_flag)
+ {
+ case SIZE_NORMAL:
+ part->function = parse_hexadecimal;
+ prop_types[index] = G_TYPE_UINT;
+ break;
+ case SIZE_SHORT:
+ part->function = parse_hexadecimal16;
+ prop_types[index] = G_TYPE_UINT;
+ break;
+ case SIZE_LONG:
+ part->function = parse_hexadecimal32;
+ prop_types[index] = G_TYPE_ULONG;
+ break;
+ case SIZE_LONGLONG:
+ part->function = parse_hexadecimal64;
+ prop_types[index] = G_TYPE_UINT64;
+ break;
+ }
+ }
+ break;
+ /*}}}*/
+ /*{{{ filename %F*/
+ case 'F':
+ if(skip_flag || size_flag || width_flag)
+ return;
+ part->next = g_new0(parse_part, 1);
+ part = part->next;
+ part->function = parse_filename;
+ break;
+ /*}}}*/
+ default:
+ return;
+ }
+ cur = ptr;
+ }
+ }
+
+ //FIXME: should be done neat
+ g_return_if_fail(part_count == num_props);
+
+ parser->parser = parts;
+ parser->num_props = num_props;
+ parser->prop_names = names;
+ parser->prop_types = prop_types;
}
-void parse()
+static void lsq_scanf_parser_parse(LSQScanfParser *parser,
LSQScanfParserContext *ctx)
{
+ gchar *line, *ptr;
+ gsize line_length, lng;
+ guint size, line_nr;
+ if(!lsq_parser_context_get_line(LSQ_PARSER_CONTEXT(ctx), &line,
&line_length))
+ return;
+ ptr = line;
+ lng = line_length;
+ line_nr = ctx->parse_line;
+
+ parse_part *part = ctx->parse_loc;
+ while(part)
+ {
+ //parse
+ if(part->function)
+ {
+ size = part->function(ptr, lng, part, ctx);
+ if(!size)
+ {
+ //no match
+ if(line_nr)
+ {
+ ptr = line;
+ lng = line_length;
+ part = parser->parser;
+ line_nr = 0;
+ continue;
+ }
+ ctx->parse_loc = parser->parser;
+ ctx->parse_line = 0;
+ g_free(line);
+ return;
+ }
+ ptr += size;
+ lng -= size;
+ }
+
+ if(!g_str_has_prefix(ptr, part->delimiter))
+ {
+ //no match
+ if(line_nr)
+ {
+ ptr = line;
+ lng = line_length;
+ part = parser->parser;
+ line_nr = 0;
+ continue;
+ }
+ ctx->parse_loc = parser->parser;
+ ctx->parse_line = 0;
+ g_free(line);
+ return;
+ }
+
+ if(g_str_has_suffix(part->delimiter, "\n"))
+ {
+ //next line
+ if(part->next)
+ {
+ ctx->parse_loc = part->next;
+ ctx->parse_line = line_nr+1;
+ g_free(line);
+ return;
+ }
+ }
+
+ part = part->next;
+ }
+
+ g_free(line);
+
+ if(!part)
+ {
+ LSQArchiveIter *iter =
lsq_archive_add_file(LSQ_PARSER_CONTEXT(ctx)->archive, ctx->filename);
+ lsq_archive_iter_set_propsv(iter, ctx->props_store);
+ lsq_archive_iter_unref(iter);
+
+ ctx->parse_loc = parser->parser;
+ ctx->parse_line = 0;
+ }
}
Modified: squeeze/trunk/libsqueeze/scanf-parser.h
===================================================================
--- squeeze/trunk/libsqueeze/scanf-parser.h 2007-12-27 00:49:02 UTC (rev
26508)
+++ squeeze/trunk/libsqueeze/scanf-parser.h 2007-12-27 13:11:55 UTC (rev
26509)
@@ -18,8 +18,40 @@
G_BEGIN_DECLS
+#define LSQ_TYPE_SCANF_PARSER lsq_scanf_parser_get_type()
+#define LSQ_SCANF_PARSER(obj) ( \
+ G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ LSQ_TYPE_SCANF_PARSER, \
+ LSQScanfParser))
+#define LSQ_IS_SCANF_PARSER(obj) ( \
+ G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+ LSQ_TYPE_SCANF_PARSER))
+
+#define LSQ_SCANF_PARSER_CLASS(class) ( \
+ G_TYPE_CHECK_CLASS_CAST ((class), \
+ LSQ_TYPE_SCANF_PARSER, \
+ LSQScanfParserClass))
+
+#define LSQ_IS_SCANF_PARSER_CLASS(class) ( \
+ G_TYPE_CHECK_CLASS_TYPE ((class), \
+ LSQ_TYPE_SCANF_PARSER))
+
+#define LSQ_SCANF_PARSER_GET_CLASS(obj) ( \
+ G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ LSQ_TYPE_SCANF_PARSER, \
+ LSQScanfParserClass))
+
+
+typedef struct _LSQScanfParser LSQScanfParser;
+
+typedef struct _LSQScanfParserClass LSQScanfParserClass;
+
+GType lsq_scanf_parser_get_type(void);
+
+LSQParser *lsq_scanf_parser_new(const gchar *, const gchar *);
+
G_END_DECLS
#endif /* __LIBSQUEEZE_SCANF_PARSER_H__ */
Modified: squeeze/trunk/src/main_window.c
===================================================================
--- squeeze/trunk/src/main_window.c 2007-12-27 00:49:02 UTC (rev 26508)
+++ squeeze/trunk/src/main_window.c 2007-12-27 13:11:55 UTC (rev 26509)
@@ -117,6 +117,7 @@
sq_main_window_navigation_style_get_type()
{
static GType nav_style_type = 0;
+ guint i = 0;
if(!nav_style_type)
{
@@ -131,8 +132,12 @@
{0, NULL, NULL}
};
style_types[0].value_nick = _("Internal Style");
- style_types[1].value_nick = _("Tool Bar Style");
- style_types[2].value_nick = _("Path Bar Style");
+#ifdef ENABLE_TOOLBAR
+ style_types[++i].value_nick = _("Tool Bar Style");
+#endif
+#ifdef ENABLE_PATHBAR
+ style_types[++i].value_nick = _("Path Bar Style");
+#endif
nav_style_type =
g_enum_register_static("SQMainWindowNavigationStyle", style_types);
}
_______________________________________________
Xfce4-commits mailing list
Xfce4-commits@xfce.org
http://foo-projects.org/mailman/listinfo/xfce4-commits
