nyje
/
medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
medit/moo/mooedit/moolang-parser.c

2458 lines
67 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4; coding: utf-8 -*-
*
* moolang-parser.c
*
* Copyright (C) 2004-2006 by Yevgen Muntyan <muntyan@math.tamu.edu>
*
* 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.
*
* See COPYING file that comes with this distribution.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define MOOEDIT_COMPILATION
#include "mooedit/moolang-parser.h"
#include "mooedit/moolang-strings.h"
#include "mooedit/moolangmgr.h"
#include "mooutils/moomarkup.h"
#include <string.h>
#ifdef MOO_USE_XML
#include <libxml/tree.h>
#include <libxml/parser.h>
#endif
#ifdef MOO_USE_XML
static LangXML *lang_xml_parse (xmlNode *node);
static GeneralXML *general_xml_parse (xmlNode *node);
static SyntaxXML *syntax_xml_parse (LangXML *lang_xml,
xmlNode *node);
static KeywordXML *keyword_xml_parse (xmlNode *node);
static ContextXML *context_xml_parse (LangXML *lang_xml,
xmlNode *node);
static StyleListXML *style_list_xml_parse (LangXML *lang_xml,
xmlNode *node);
static StyleXML *style_xml_parse (xmlNode *node);
static RuleXML *rule_xml_parse (LangXML *xml,
xmlNode *node);
static void general_xml_free (GeneralXML *xml);
static void syntax_xml_free (SyntaxXML *xml);
static void keyword_xml_free (KeywordXML *xml);
static void context_xml_free (ContextXML *xml);
static void style_xml_free (StyleXML *xml);
static void style_list_xml_free (StyleListXML *xml);
static void rule_xml_free (RuleXML *xml);
static CrossRef *cross_ref_new (const char *lang,
const char *name);
static void cross_ref_free (CrossRef *ref);
static void ctx_switch_info_destroy(CtxSwitchInfo *switch_info);
static void lang_xml_add_cross_ref (LangXML *xml,
const char *lang,
const char *name);
static void lang_xml_add_keyword_ref (LangXML *xml,
const xmlChar *keyword);
static void lang_xml_add_style_ref (LangXML *xml,
const char *style);
static gboolean lang_xml_check_internal_refs (LangXML *xml);
#endif /* MOO_USE_XML */
LangXML*
moo_lang_parse_file (const char *file)
{
#ifdef MOO_USE_XML
xmlDoc *doc;
xmlNode *root;
LangXML *xml;
g_return_val_if_fail (file != NULL, NULL);
doc = xmlReadFile (file, "UTF8",
XML_PARSE_NOENT | XML_PARSE_NOBLANKS |
XML_PARSE_NONET);
g_return_val_if_fail (doc != NULL, NULL);
root = xmlDocGetRootElement (doc);
xml = lang_xml_parse (root);
xmlFreeDoc (doc);
xmlCleanupParser ();
return xml;
#else
g_return_val_if_fail (file != NULL, NULL);
return NULL;
#endif
}
LangXML*
moo_lang_parse_memory (const char *buffer,
int size)
{
#ifdef MOO_USE_XML
xmlDoc *doc;
xmlNode *root;
LangXML *xml;
g_return_val_if_fail (buffer != NULL, NULL);
if (size < 0)
size = strlen (buffer);
doc = xmlReadMemory (buffer, size, NULL, "UTF8",
XML_PARSE_NOENT | XML_PARSE_NOBLANKS);
g_return_val_if_fail (doc != NULL, NULL);
root = xmlDocGetRootElement (doc);
xml = lang_xml_parse (root);
xmlFreeDoc (doc);
xmlCleanupParser ();
return xml;
#else
g_return_val_if_fail (buffer != NULL, NULL);
g_return_val_if_fail (size != 0, NULL);
return NULL;
#endif
}
#ifndef MOO_USE_XML
/* Stubs for functions used elsewhere */
void
moo_lang_xml_free (G_GNUC_UNUSED LangXML *xml)
{
g_return_if_reached ();
}
MooRule*
moo_rule_new_from_xml (G_GNUC_UNUSED RuleXML *xml,
G_GNUC_UNUSED LangXML *lang_xml,
G_GNUC_UNUSED MooLang *lang)
{
g_return_val_if_reached (NULL);
}
#else /* MOO_USE_XML */
/****************************************************************************/
/* Auxiliary stuff
*/
#define ELM_FOREACH(node__,var__) \
G_STMT_START { \
xmlNode *var__; \
for (var__ = node__->children; var__ != NULL; var__ = var__->next) \
if (var__->type == XML_ELEMENT_NODE) \
#define ELM_FOREACH_END \
} G_STMT_END
#if 0
#define GET_PROP(node__,prop__) GET_PROP (node__, (xmlChar*) prop__)
#define STRING_FREE(s__) if (s__) xmlFree (s__)
#define STRDUP(s__) g_strdup ((char*) s__)
#else
inline static xmlChar *GET_PROP (xmlNode *node, const char *prop_name)
{
return xmlGetProp (node, (xmlChar*) prop_name);
}
inline static char *STRDUP (const xmlChar *s)
{
return g_strdup ((char*) s);
}
inline static void STRING_FREE (xmlChar *s)
{
if (s) xmlFree (s);
}
#endif
#define IS_ELEMENT_NODE(node_) (node_ != NULL && node_->type == XML_ELEMENT_NODE)
#define NODE_NAME_IS_(node_, name_) (node_->name && !strcmp ((char*)node_->name, name_))
#define IS_LANGUAGE_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, LANGUAGE_ELM))
#define IS_KEYWORD_LIST_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, KEYWORD_LIST_ELM))
#define IS_KEYWORD_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, KEYWORD_ELM))
#define IS_CONTEXT_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, CONTEXT_ELM))
#define IS_SYNTAX_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, SYNTAX_ELM))
#define IS_STYLE_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, STYLE_ELM))
#define IS_STYLE_LIST_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, STYLE_LIST_ELM))
#define IS_GENERAL_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, GENERAL_ELM))
#define IS_BRACKETS_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, BRACKETS_ELM))
#define IS_COMMENTS_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, COMMENTS_ELM))
#define IS_SINGLE_LINE_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, SINGLE_LINE_ELM))
#define IS_MULTI_LINE_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, MULTI_LINE_ELM))
#define IS_SCHEME_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, SCHEME_ELM))
#define IS_DEFAULT_STYLE_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, DEFAULT_STYLE_ELM))
#define IS_BRACKET_MATCH_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, BRACKET_MATCH_ELM))
#define IS_BRACKET_MISMATCH_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, BRACKET_MISMATCH_ELM))
#define IS_SAMPLE_CODE_NODE(node_) (IS_ELEMENT_NODE(node_) && NODE_NAME_IS_(node_, SAMPLE_CODE_ELM))
#if VERBOSE
#define DEBUG_PRINT(x) (x)
#else
#define DEBUG_PRINT(x)
#endif
static gboolean
parse_bool (const xmlChar *string,
gboolean default_val)
{
if (!string)
return default_val;
if (!g_ascii_strcasecmp ((const char*) string, "true") ||
!strcmp ((const char*) string, "1") ||
!g_ascii_strcasecmp ((const char*) string, "yes"))
{
return TRUE;
}
else if (!g_ascii_strcasecmp ((const char*) string, "false") ||
!strcmp ((const char*) string, "0") ||
!g_ascii_strcasecmp ((const char*) string, "no"))
{
return FALSE;
}
else
{
g_warning ("%s: invalid string '%s' for boolean value",
G_STRLOC, string);
return default_val;
}
}
static gboolean
prop_equal (const xmlChar *str1, const char *str2)
{
while (*str1 && *str2)
{
if (*str1 == '-' || *str1 == '_')
{
if (*str2 != '-' && *str2 != '_')
return FALSE;
}
else if (*str1 != *str2)
{
return FALSE;
}
str1++;
str2++;
}
return !*str1 && !*str2;
}
static CrossRef*
cross_ref_new (const char *lang,
const char *name)
{
CrossRef *ref;
g_return_val_if_fail (name != NULL, NULL);
ref = g_new (CrossRef, 1);
ref->lang = g_strdup (lang);
ref->name = g_strdup (name);
return ref;
}
static void
cross_ref_free (CrossRef *ref)
{
if (ref)
{
g_free (ref->name);
g_free (ref->lang);
g_free (ref);
}
}
static void
ctx_switch_info_destroy (CtxSwitchInfo *switch_info)
{
g_return_if_fail (switch_info != NULL);
switch (switch_info->type)
{
case MOO_CONTEXT_SWITCH:
#if 0
case MOO_CONTEXT_JUMP:
#endif
g_free (switch_info->ref.name);
g_free (switch_info->ref.lang);
break;
case MOO_CONTEXT_STAY:
case MOO_CONTEXT_POP:
break;
}
}
#define LANG_REF_SEP "##"
#define LANG_REF_SEP_LEN 2
static gboolean
parse_name_ref (const xmlChar *string,
char **lang_p,
char **name_p)
{
const char *s;
char *lang, *name;
g_return_val_if_fail (string && string[0], FALSE);
if (strncmp ((char*) string, LANG_REF_SEP, LANG_REF_SEP_LEN))
{
if (lang_p)
*lang_p = NULL;
if (name_p)
*name_p = STRDUP (string);
return TRUE;
}
if (!string[LANG_REF_SEP_LEN])
return FALSE;
s = strstr ((char*) string + LANG_REF_SEP_LEN, LANG_REF_SEP);
if (s == (char*) string + LANG_REF_SEP_LEN)
return FALSE;
if (s && !s[LANG_REF_SEP_LEN])
return FALSE;
if (!s)
return FALSE;
lang = g_strndup ((char*) string + LANG_REF_SEP_LEN, (s - (char*) string) - LANG_REF_SEP_LEN);
name = g_strdup (s + LANG_REF_SEP_LEN);
if (lang_p)
*lang_p = lang;
else
g_free (lang);
if (name_p)
*name_p = name;
else
g_free (name);
return TRUE;
}
static gboolean
parse_context_ref (const xmlChar *string,
CtxSwitchInfo *switch_info)
{
g_return_val_if_fail (switch_info != NULL, FALSE);
g_return_val_if_fail (!string || string[0], FALSE);
if (!string || !strcmp ((char*) string, CONTEXT_STAY))
{
switch_info->type = MOO_CONTEXT_STAY;
switch_info->num = 0;
}
else if (!strncmp ((char*) string, CONTEXT_POP, strlen (CONTEXT_POP)))
{
guint n;
for (n = 1, string += strlen (CONTEXT_POP);
*string; ++n, string += strlen (CONTEXT_POP))
{
if (strncmp ((char*) string, CONTEXT_POP, strlen (CONTEXT_POP)))
return FALSE;
}
switch_info->type = MOO_CONTEXT_POP;
switch_info->num = n;
}
else
{
char *name = NULL, *lang = NULL;
if (!parse_name_ref (string, &lang, &name))
return FALSE;
switch_info->type = MOO_CONTEXT_SWITCH;
switch_info->ref.lang = lang;
switch_info->ref.name = name;
}
return TRUE;
}
/****************************************************************************/
/* language node
*/
static LangXML*
lang_xml_parse (xmlNode *node)
{
LangXML *xml = NULL;
xmlChar *name = NULL, *version = NULL, *author = NULL, *section = NULL;
xmlChar *mimetypes = NULL, *extensions = NULL, *hidden = NULL;
g_return_val_if_fail (IS_LANGUAGE_NODE (node), NULL);
name = GET_PROP (node, LANG_NAME_PROP);
version = GET_PROP (node, LANG_VERSION_PROP);
section = GET_PROP (node, LANG_SECTION_PROP);
mimetypes = GET_PROP (node, LANG_MIME_TYPES_PROP);
extensions = GET_PROP (node, LANG_EXTENSIONS_PROP);
author = GET_PROP (node, LANG_AUTHOR_PROP);
hidden = GET_PROP (node, LANG_HIDDEN_PROP);
if (!name || !name[0])
{
g_warning ("%s: no name in language node", G_STRLOC);
goto error;
}
xml = g_new0 (LangXML, 1);
xml->name = STRDUP (name);
xml->section = STRDUP (section);
xml->version = STRDUP (version);
xml->mimetypes = STRDUP (mimetypes);
xml->extensions = STRDUP (extensions);
xml->author = STRDUP (author);
xml->hidden = parse_bool (hidden, FALSE);
xml->context_names = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
xml->style_names = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
xml->keyword_names = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
xml->style_refs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
DEBUG_PRINT ({
g_print ("language: %s\n", name);
if (section) g_print (" section: %s\n", section);
if (version) g_print (" version: %s\n", version);
if (author) g_print (" author: %s\n", author);
if (mimetypes) g_print (" mimetypes: %s\n", mimetypes);
if (extensions) g_print (" extensions: %s\n", extensions);
g_print ("\n");
});
ELM_FOREACH (node, child)
{
if (IS_SYNTAX_NODE (child))
{
if (xml->syntax)
{
g_warning ("%s: duplicated '" SYNTAX_ELM "' tag", G_STRLOC);
goto error;
}
xml->syntax = syntax_xml_parse (xml, child);
if (!xml->syntax)
goto error;
}
else if (IS_STYLE_LIST_NODE (child))
{
if (xml->style_list)
{
g_warning ("%s: duplicated '" STYLE_LIST_ELM "' tag", G_STRLOC);
goto error;
}
xml->style_list = style_list_xml_parse (xml, child);
if (!xml->style_list)
goto error;
}
else if (IS_GENERAL_NODE (child))
{
if (xml->general)
{
g_warning ("%s: duplicated '" GENERAL_ELM "' tag", G_STRLOC);
goto error;
}
xml->general = general_xml_parse (child);
if (!xml->general)
goto error;
}
else if (IS_SAMPLE_CODE_NODE (child))
{
xmlChar *content;
if (xml->sample)
{
g_warning ("%s: duplicated '" SAMPLE_CODE_ELM "' element", G_STRLOC);
goto error;
}
content = xmlNodeGetContent (child);
xml->sample = STRDUP (content);
STRING_FREE (content);
}
else
{
g_warning ("%s: unknown tag '%s'", G_STRLOC, child->name);
goto error;
}
}
ELM_FOREACH_END;
if (!xml->syntax)
{
g_warning ("%s: no contexts defined in lang '%s'", G_STRLOC, xml->name);
goto error;
}
if (!lang_xml_check_internal_refs (xml))
goto error;
STRING_FREE (name);
STRING_FREE (version);
STRING_FREE (section);
STRING_FREE (mimetypes);
STRING_FREE (extensions);
STRING_FREE (author);
STRING_FREE (hidden);
return xml;
error:
STRING_FREE (name);
STRING_FREE (version);
STRING_FREE (section);
STRING_FREE (mimetypes);
STRING_FREE (extensions);
STRING_FREE (author);
STRING_FREE (hidden);
moo_lang_xml_free (xml);
return NULL;
}
void
moo_lang_xml_free (LangXML *xml)
{
if (xml)
{
g_free (xml->name);
g_free (xml->section);
g_free (xml->version);
g_free (xml->mimetypes);
g_free (xml->extensions);
g_free (xml->author);
g_free (xml->sample);
general_xml_free (xml->general);
syntax_xml_free (xml->syntax);
style_list_xml_free (xml->style_list);
if (xml->context_names)
g_hash_table_destroy (xml->context_names);
if (xml->style_names)
g_hash_table_destroy (xml->style_names);
if (xml->keyword_names)
g_hash_table_destroy (xml->keyword_names);
g_slist_foreach (xml->internal_refs, (GFunc) cross_ref_free, NULL);
g_slist_free (xml->internal_refs);
g_slist_foreach (xml->external_refs, (GFunc) cross_ref_free, NULL);
g_slist_free (xml->external_refs);
g_slist_foreach (xml->keyword_refs, (GFunc) g_free, NULL);
g_slist_free (xml->keyword_refs);
g_hash_table_destroy (xml->style_refs);
g_free (xml);
}
}
static void
lang_xml_add_cross_ref (LangXML *xml,
const char *lang,
const char *name)
{
CrossRef *ref;
g_return_if_fail (xml != NULL && name != NULL);
g_return_if_fail (!lang || lang[0]);
if (!lang || !strcmp (lang, xml->name))
{
ref = cross_ref_new (NULL, name);
xml->internal_refs = g_slist_prepend (xml->internal_refs, ref);
}
else
{
ref = cross_ref_new (lang, name);
xml->external_refs = g_slist_prepend (xml->external_refs, ref);
}
}
static void
lang_xml_add_keyword_ref (LangXML *xml,
const xmlChar *keyword)
{
g_return_if_fail (xml != NULL && keyword != NULL);
xml->keyword_refs = g_slist_prepend (xml->keyword_refs, STRDUP (keyword));
}
static void
lang_xml_add_style_ref (LangXML *xml,
const char *style)
{
if (style)
g_hash_table_insert (xml->style_refs, g_strdup (style), NULL);
}
static void
check_style (const char *style_name,
G_GNUC_UNUSED gpointer ptr,
gpointer user_data)
{
struct {
LangXML *xml;
gboolean valid;
} *data = user_data;
if (!g_hash_table_lookup (data->xml->style_names, style_name))
{
g_warning ("%s: invalid style '%s'", G_STRLOC, style_name);
data->valid = FALSE;
}
}
static gboolean
lang_xml_check_internal_refs (LangXML *xml)
{
GSList *l;
struct {
LangXML *xml;
gboolean valid;
} data;
for (l = xml->internal_refs; l != NULL; l = l->next)
{
CrossRef *ref = l->data;
g_assert (ref->lang == NULL);
if (!g_hash_table_lookup (xml->context_names, ref->name))
{
g_warning ("%s: invalid context '%s'", G_STRLOC, ref->name);
return FALSE;
}
}
for (l = xml->keyword_refs; l != NULL; l = l->next)
{
char *kw = l->data;
if (!g_hash_table_lookup (xml->keyword_names, kw))
{
g_warning ("%s: invalid keyword list '%s'", G_STRLOC, kw);
return FALSE;
}
}
data.xml = xml;
data.valid = TRUE;
g_hash_table_foreach (xml->style_refs, (GHFunc) check_style, &data);
if (!data.valid)
return FALSE;
return TRUE;
}
/****************************************************************************/
/* general node
*/
static GeneralXML*
general_xml_parse (xmlNode *node)
{
GeneralXML *xml = NULL;
g_assert (IS_GENERAL_NODE (node));
xml = g_new0 (GeneralXML, 1);
g_assert (IS_GENERAL_NODE (node));
ELM_FOREACH (node, child)
{
if (IS_BRACKETS_NODE (child))
{
xmlChar *content;
if (xml->brackets)
{
g_warning ("%s: duplicated '" BRACKETS_ELM "' element", G_STRLOC);
goto error;
}
content = xmlNodeGetContent (node);
xml->brackets = STRDUP (content);
STRING_FREE (content);
}
else if (IS_COMMENTS_NODE (child))
{
ELM_FOREACH (child, comm_node)
{
if (IS_SINGLE_LINE_NODE (comm_node))
{
xmlChar *start;
if (xml->single_line_start)
{
g_warning ("%s: duplicated '" SINGLE_LINE_ELM "' element", G_STRLOC);
goto error;
}
start = GET_PROP (comm_node, COMMENT_START_PROP);
if (!start)
{
g_warning ("%s: '" COMMENT_START_PROP "' attribute missing in '"
SINGLE_LINE_ELM "' element", G_STRLOC);
goto error;
}
xml->single_line_start = STRDUP (start);
STRING_FREE (start);
}
else if (IS_MULTI_LINE_NODE (comm_node))
{
xmlChar *start = NULL;
xmlChar *end = NULL;
if (xml->multi_line_start)
{
g_warning ("%s: duplicated '" MULTI_LINE_ELM "' element", G_STRLOC);
goto error;
}
start = GET_PROP (comm_node, COMMENT_START_PROP);
end = GET_PROP (comm_node, COMMENT_END_PROP);
if (!start)
{
g_warning ("%s: '" COMMENT_START_PROP "' attribute missing in '"
MULTI_LINE_ELM "' element", G_STRLOC);
STRING_FREE (end);
goto error;
}
else if (!end)
{
g_warning ("%s: '" COMMENT_END_PROP "' attribute missing in '"
MULTI_LINE_ELM "' element", G_STRLOC);
STRING_FREE (start);
goto error;
}
xml->multi_line_start = STRDUP (start);
xml->multi_line_end = STRDUP (end);
STRING_FREE (start);
STRING_FREE (end);
}
else
{
g_warning ("%s: invalid node '%s' in '" COMMENTS_ELM "' node",
G_STRLOC, comm_node->name);
goto error;
}
}
ELM_FOREACH_END;
}
else
{
g_warning ("%s: invalid node '%s' in '" GENERAL_ELM "' node",
G_STRLOC, child->name);
goto error;
}
}
ELM_FOREACH_END;
return xml;
error:
general_xml_free (xml);
return NULL;
}
static void
general_xml_free (GeneralXML *xml)
{
if (xml)
{
g_free (xml->brackets);
g_free (xml->single_line_start);
g_free (xml->multi_line_start);
g_free (xml->multi_line_end);
g_free (xml);
}
}
/****************************************************************************/
/* syntax node
*/
static SyntaxXML*
syntax_xml_parse (LangXML *lang_xml,
xmlNode *node)
{
SyntaxXML *xml = NULL;
g_assert (IS_SYNTAX_NODE (node));
xml = g_new0 (SyntaxXML, 1);
DEBUG_PRINT ({
g_print ("syntax\n");
g_print ("\n");
});
ELM_FOREACH (node, child)
{
if (IS_KEYWORD_LIST_NODE (child))
{
KeywordXML *kw = keyword_xml_parse (child);
if (!kw)
goto error;
if (g_hash_table_lookup (lang_xml->keyword_names, kw->name))
{
g_warning ("%s: duplicated keyword list '%s'",
G_STRLOC, kw->name);
keyword_xml_free (kw);
goto error;
}
g_hash_table_insert (lang_xml->keyword_names,
g_strdup (kw->name), kw);
xml->keywords = g_slist_prepend (xml->keywords, kw);
xml->n_keywords++;
}
else if (IS_CONTEXT_NODE (child))
{
ContextXML *ctx = context_xml_parse (lang_xml, child);
if (!ctx)
goto error;
if (g_hash_table_lookup (lang_xml->context_names, ctx->name))
{
g_warning ("%s: duplicated context '%s'",
G_STRLOC, ctx->name);
context_xml_free (ctx);
goto error;
}
g_hash_table_insert (lang_xml->context_names,
g_strdup (ctx->name), ctx);
xml->contexts = g_slist_prepend (xml->contexts, ctx);
xml->n_contexts++;
}
else
{
g_warning ("%s: invalid tag '%s' inside of '" SYNTAX_ELM "' tag",
G_STRLOC, child->name);
goto error;
}
}
ELM_FOREACH_END;
if (!xml->contexts)
{
g_warning ("%s: no contexts defined in lang '%s'",
G_STRLOC, lang_xml->name);
}
xml->contexts = g_slist_reverse (xml->contexts);
xml->keywords = g_slist_reverse (xml->keywords);
return xml;
error:
syntax_xml_free (xml);
return NULL;
}
static void
syntax_xml_free (SyntaxXML *xml)
{
if (xml)
{
g_slist_foreach (xml->keywords, (GFunc) keyword_xml_free, NULL);
g_slist_foreach (xml->contexts, (GFunc) context_xml_free, NULL);
g_slist_free (xml->keywords);
g_slist_free (xml->contexts);
g_free (xml);
}
}
/****************************************************************************/
/* keyword-list node
*/
static KeywordXML*
keyword_xml_parse (xmlNode *node)
{
KeywordXML *xml = NULL;
xmlChar *name = NULL, *case_sensitive = NULL;
g_assert (IS_KEYWORD_LIST_NODE (node));
name = GET_PROP (node, KEYWORD_NAME_PROP);
if (!name || !name[0])
{
g_warning ("%s: no " KEYWORD_NAME_PROP " attribute in "
KEYWORD_LIST_ELM " node", G_STRLOC);
goto error;
}
xml = g_new0 (KeywordXML, 1);
xml->name = STRDUP (name);
DEBUG_PRINT ({
g_print ("keyword-list: %s\n", name);
g_print (" case sensitive: %s\n", xml->case_sensitive ? "TRUE" : "FALSE");
g_print ("\n");
});
ELM_FOREACH (node, child)
{
if (IS_KEYWORD_NODE (child))
{
xmlChar *content = xmlNodeGetContent (child);
if (!content || !content[0])
{
g_warning ("%s: empty " KEYWORD_ELM " tag", G_STRLOC);
STRING_FREE (content);
goto error;
}
DEBUG_PRINT ({
g_print (" %s\n", content);
});
xml->words = g_slist_prepend (xml->words, STRDUP (content));
xml->n_words++;
STRING_FREE (content);
}
else
{
g_warning ("%s: invalid tag '%s' inside of " KEYWORD_LIST_ELM " tag",
G_STRLOC, child->name);
goto error;
}
}
ELM_FOREACH_END;
DEBUG_PRINT ({
g_print ("\n");
});
xml->words = g_slist_reverse (xml->words);
STRING_FREE (name);
STRING_FREE (case_sensitive);
return xml;
error:
STRING_FREE (name);
STRING_FREE (case_sensitive);
keyword_xml_free (xml);
return NULL;
}
static void
keyword_xml_free (KeywordXML *xml)
{
if (xml)
{
g_slist_foreach (xml->words, (GFunc) g_free, NULL);
g_slist_free (xml->words);
g_free (xml->name);
g_free (xml);
}
}
/****************************************************************************/
/* context node
*/
static ContextXML*
context_xml_parse (LangXML *lang_xml,
xmlNode *node)
{
ContextXML *xml = NULL;
xmlChar *name = NULL, *eol_context = NULL, *style = NULL;
g_assert (IS_CONTEXT_NODE (node));
name = GET_PROP (node, CONTEXT_NAME_PROP);
eol_context = GET_PROP (node, CONTEXT_EOL_CTX_PROP);
style = GET_PROP (node, CONTEXT_STYLE_PROP);
if (!name || !name[0])
{
g_warning ("%s: no name attribute in " CONTEXT_ELM " node", G_STRLOC);
goto error;
}
xml = g_new0 (ContextXML, 1);
xml->name = STRDUP (name);
xml->eol_context = STRDUP (eol_context);
xml->style = STRDUP (style);
if (!parse_context_ref (eol_context, &xml->eol_switch_info))
{
g_warning ("%s: invalid '" CONTEXT_EOL_CTX_PROP "' '%s' in " CONTEXT_ELM " node",
G_STRLOC, xml->eol_context ? xml->eol_context : "(null)");
goto error;
}
switch (xml->eol_switch_info.type)
{
case MOO_CONTEXT_SWITCH:
#if 0
case MOO_CONTEXT_JUMP:
#endif
lang_xml_add_cross_ref (lang_xml,
xml->eol_switch_info.ref.lang,
xml->eol_switch_info.ref.name);
break;
case MOO_CONTEXT_STAY:
case MOO_CONTEXT_POP:
break;
}
DEBUG_PRINT ({
g_print ("context: %s\n", name);
if (eol_context) g_print (" eol_context: %s\n", eol_context);
if (style) g_print (" style: %s\n", style);
g_print ("\n");
});
ELM_FOREACH (node, child)
{
RuleXML *rule = rule_xml_parse (lang_xml, child);
if (!rule)
goto error;
xml->rules = g_slist_prepend (xml->rules, rule);
xml->n_rules++;
}
ELM_FOREACH_END;
xml->rules = g_slist_reverse (xml->rules);
lang_xml_add_style_ref (lang_xml, xml->style);
STRING_FREE (name);
STRING_FREE (eol_context);
STRING_FREE (style);
return xml;
error:
STRING_FREE (name);
STRING_FREE (eol_context);
STRING_FREE (style);
context_xml_free (xml);
return NULL;
}
static void
context_xml_free (ContextXML *xml)
{
if (xml)
{
g_free (xml->name);
g_free (xml->eol_context);
g_free (xml->style);
g_slist_foreach (xml->rules, (GFunc) rule_xml_free, NULL);
g_slist_free (xml->rules);
g_free (xml);
}
}
/****************************************************************************/
/* Styles nodes
*/
static StyleListXML*
style_list_xml_parse (LangXML *lang_xml,
xmlNode *node)
{
StyleListXML *xml = NULL;
g_assert (IS_STYLE_LIST_NODE (node));
xml = g_new0 (StyleListXML, 1);
ELM_FOREACH (node, child)
{
if (IS_STYLE_NODE (child))
{
StyleXML *style = style_xml_parse (child);
if (!style)
goto error;
if (g_hash_table_lookup (lang_xml->style_names, style->name))
{
g_warning ("%s: duplicated style '%s'", G_STRLOC, style->name);
style_xml_free (style);
goto error;
}
g_hash_table_insert (lang_xml->style_names,
g_strdup (style->name), style);
xml->styles = g_slist_prepend (xml->styles, style);
xml->n_styles++;
}
else
{
g_warning ("%s: unknown tag '%s'", G_STRLOC, child->name);
goto error;
}
}
ELM_FOREACH_END;
xml->styles = g_slist_reverse (xml->styles);
return xml;
error:
style_list_xml_free (xml);
return NULL;
}
static StyleXML*
style_xml_parse (xmlNode *node)
{
StyleXML *xml = NULL;
xmlChar *name = NULL, *default_style = NULL;
xmlChar *bold = NULL, *italic = NULL, *underline = NULL, *strikethrough = NULL;
xmlChar *foreground = NULL, *background = NULL;
g_assert (IS_STYLE_NODE (node));
name = GET_PROP (node, STYLE_NAME_PROP);
default_style = GET_PROP (node, STYLE_DEF_STYLE_PROP);
bold = GET_PROP (node, STYLE_BOLD_PROP);
italic = GET_PROP (node, STYLE_ITALIC_PROP);
underline = GET_PROP (node, STYLE_UNDERLINE_PROP);
strikethrough = GET_PROP (node, STYLE_STRIKETHROUGH_PROP);
foreground = GET_PROP (node, STYLE_FOREGROUND_PROP);
background = GET_PROP (node, STYLE_BACKGROUND_PROP);
if (!name || !name[0])
{
g_warning ("%s: no name in style node", G_STRLOC);
goto error;
}
xml = g_new0 (StyleXML, 1);
xml->name = STRDUP (name);
xml->default_style = STRDUP (default_style);
xml->bold = STRDUP (bold);
xml->italic = STRDUP (italic);
xml->underline = STRDUP (underline);
xml->strikethrough = STRDUP (strikethrough);
xml->foreground = STRDUP (foreground);
xml->background = STRDUP (background);
DEBUG_PRINT ({
g_print ("style: %s\n", name);
if (default_style) g_print (" default_style: %s\n", default_style);
if (bold) g_print (" bold: %s\n", bold);
if (italic) g_print (" italic: %s\n", italic);
if (underline) g_print (" underline: %s\n", underline);
if (strikethrough) g_print (" strikethrough: %s\n", strikethrough);
if (foreground) g_print (" foreground: %s\n", foreground);
if (background) g_print (" background: %s\n", background);
});
STRING_FREE (name);
STRING_FREE (default_style);
STRING_FREE (bold);
STRING_FREE (italic);
STRING_FREE (underline);
STRING_FREE (strikethrough);
STRING_FREE (foreground);
STRING_FREE (background);
return xml;
error:
STRING_FREE (name);
STRING_FREE (default_style);
STRING_FREE (bold);
STRING_FREE (italic);
STRING_FREE (underline);
STRING_FREE (strikethrough);
STRING_FREE (foreground);
STRING_FREE (background);
style_xml_free (xml);
return NULL;
}
static void
style_xml_free (StyleXML *xml)
{
if (xml)
{
g_free (xml->name);
g_free (xml->default_style);
g_free (xml->bold);
g_free (xml->italic);
g_free (xml->underline);
g_free (xml->strikethrough);
g_free (xml->foreground);
g_free (xml->background);
g_free (xml);
}
}
static void
style_list_xml_free (StyleListXML *xml)
{
if (xml)
{
g_slist_foreach (xml->styles, (GFunc) style_xml_free, NULL);
g_slist_free (xml->styles);
g_free (xml);
}
}
/****************************************************************************/
/* Rules
*/
static RuleXML *rule_string_xml_parse (xmlNode *node);
static RuleXML *rule_regex_xml_parse (xmlNode *node);
static RuleXML *rule_char_xml_parse (xmlNode *node);
static RuleXML *rule_2char_xml_parse (xmlNode *node);
static RuleXML *rule_any_char_xml_parse (xmlNode *node);
static RuleXML *rule_special_xml_parse (xmlNode *node);
static RuleXML *rule_keywords_xml_parse (LangXML *lang_xml,
xmlNode *node);
static RuleXML *rule_include_xml_parse (LangXML *lang_xml,
xmlNode *node);
static void rule_string_xml_free (RuleStringXML *xml);
static void rule_regex_xml_free (RuleRegexXML *xml);
static void rule_any_char_xml_free (RuleAnyCharXML *xml);
static void rule_keywords_xml_free (RuleKeywordsXML *xml);
static void rule_include_xml_free (RuleIncludeXML *xml);
static MooRule *rule_string_xml_create_rule (RuleStringXML *xml);
static MooRule *rule_regex_xml_create_rule (RuleRegexXML *xml);
static MooRule *rule_any_char_xml_create_rule (RuleAnyCharXML *xml);
static MooRule *rule_keywords_xml_create_rule (RuleKeywordsXML *xml,
LangXML *lang_xml);
static MooRule *rule_include_xml_create_rule (RuleIncludeXML *xml,
MooLang *lang);
static MooRule *rule_char_xml_create_rule (RuleCharXML *xml);
static MooRule *rule_2char_xml_create_rule (Rule2CharXML *xml);
static MooRule *rule_special_xml_create_rule (RuleXML *xml);
#define rule_char_xml_free g_free
#define rule_2char_xml_free g_free
#define rule_special_xml_free g_free
#define RULE_IS__(node__,name__) (!g_ascii_strcasecmp ((char*)node__->name, name__))
#define RULE_IS_STRING_NODE(node__) (RULE_IS__(node__, RULE_ASCII_STRING_ELM))
#define RULE_IS_REGEX_NODE(node__) (RULE_IS__(node__, RULE_REGEX_ELM))
#define RULE_IS_CHAR_NODE(node__) (RULE_IS__(node__, RULE_ASCII_CHAR_ELM))
#define RULE_IS_2CHAR_NODE(node__) (RULE_IS__(node__, RULE_ASCII_2CHAR_ELM))
#define RULE_IS_ANY_CHAR_NODE(node__) (RULE_IS__(node__, RULE_ASCII_ANY_CHAR_ELM))
#define RULE_IS_KEYWORDS_NODE(node__) (RULE_IS__(node__, RULE_KEYWORDS_ELM))
#define RULE_IS_INCLUDE_NODE(node__) (RULE_IS__(node__, RULE_INCLUDE_RULES_ELM))
#define RULE_IS_INT_NODE(node__) (RULE_IS__(node__, RULE_INT_ELM))
#define RULE_IS_HEX_NODE(node__) (RULE_IS__(node__, RULE_HEX_ELM))
#define RULE_IS_OCTAL_NODE(node__) (RULE_IS__(node__, RULE_OCTAL_ELM))
#define RULE_IS_FLOAT_NODE(node__) (RULE_IS__(node__, RULE_FLOAT_ELM))
#define RULE_IS_C_CHAR_NODE(node__) (RULE_IS__(node__, RULE_C_CHAR_ELM))
#define RULE_IS_ESCAPED_CHAR_NODE(node__) (RULE_IS__(node__, RULE_ESCAPED_CHAR_ELM))
#define RULE_IS_WHITESPACE_NODE(node__) (RULE_IS__(node__, RULE_WHITESPACE_ELM))
#define RULE_IS_IDENTIFIER_NODE(node__) (RULE_IS__(node__, RULE_IDENTIFIER_ELM))
#define RULE_IS_LINE_CONTINUE_NODE(node__) (RULE_IS__(node__, RULE_LINE_CONTINUE_ELM))
static RuleXML*
rule_xml_parse (LangXML *lang_xml,
xmlNode *node)
{
RuleXML *xml = NULL;
xmlAttr *attr;
g_assert (IS_ELEMENT_NODE (node));
if (!node->name || !node->name[0])
{
g_warning ("%s: no name in rule node", G_STRLOC);
goto error;
}
if (RULE_IS_STRING_NODE (node))
{
xml = rule_string_xml_parse (node);
if (xml) xml->type = RULE_STRING;
}
else if (RULE_IS_REGEX_NODE (node))
{
xml = rule_regex_xml_parse (node);
if (xml) xml->type = RULE_REGEX;
}
else if (RULE_IS_CHAR_NODE (node))
{
xml = rule_char_xml_parse (node);
if (xml) xml->type = RULE_CHAR;
}
else if (RULE_IS_2CHAR_NODE (node))
{
xml = rule_2char_xml_parse (node);
if (xml) xml->type = RULE_2CHAR;
}
else if (RULE_IS_ANY_CHAR_NODE (node))
{
xml = rule_any_char_xml_parse (node);
if (xml) xml->type = RULE_ANY_CHAR;
}
else if (RULE_IS_KEYWORDS_NODE (node))
{
xml = rule_keywords_xml_parse (lang_xml, node);
if (xml) xml->type = RULE_KEYWORDS;
}
else if (RULE_IS_INCLUDE_NODE (node))
{
xml = rule_include_xml_parse (lang_xml, node);
if (xml) xml->type = RULE_INCLUDE;
}
else if (RULE_IS_INT_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_INT;
}
else if (RULE_IS_FLOAT_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_FLOAT;
}
else if (RULE_IS_OCTAL_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_OCTAL;
}
else if (RULE_IS_HEX_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_HEX;
}
else if (RULE_IS_C_CHAR_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_C_CHAR;
}
else if (RULE_IS_ESCAPED_CHAR_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_ESCAPED_CHAR;
}
else if (RULE_IS_WHITESPACE_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_WHITESPACE;
}
else if (RULE_IS_IDENTIFIER_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_IDENTIFIER;
}
else if (RULE_IS_LINE_CONTINUE_NODE (node))
{
xml = rule_special_xml_parse (node);
if (xml) xml->type = RULE_LINE_CONTINUE;
}
else
{
g_warning ("%s: invalid rule type '%s'", G_STRLOC, node->name);
goto error;
}
if (!xml)
goto error;
for (attr = node->properties; attr != NULL; attr = attr->next)
{
xmlChar *val;
val = xmlGetProp (node, attr->name);
if (!val)
{
g_warning ("%s: oops", G_STRLOC);
goto error;
}
if (prop_equal (attr->name, RULE_STYLE_PROP))
{
if (!val[0])
{
g_warning ("%s: empty style name in rule '%s'", G_STRLOC, node->name);
xmlFree (val);
goto error;
}
else if (xml->style)
{
g_warning ("%s: duplicated style tag in rule '%s'", G_STRLOC, node->name);
xmlFree (val);
goto error;
}
else
{
xml->style = STRDUP (val);
lang_xml_add_style_ref (lang_xml, xml->style);
}
}
else if (prop_equal (attr->name, RULE_CTX_PROP))
{
if (!val[0])
{
g_warning ("%s: empty context name in rule '%s'", G_STRLOC, node->name);
xmlFree (val);
goto error;
}
else if (xml->context)
{
g_warning ("%s: duplicated context tag in rule '%s'", G_STRLOC, node->name);
xmlFree (val);
goto error;
}
else
{
if (!parse_context_ref (val, &xml->end_switch_info))
{
g_warning ("%s: invalid context value in rule '%s'", G_STRLOC, node->name);
xmlFree (val);
goto error;
}
switch (xml->end_switch_info.type)
{
case MOO_CONTEXT_SWITCH:
#if 0
case MOO_CONTEXT_JUMP:
#endif
lang_xml_add_cross_ref (lang_xml,
xml->end_switch_info.ref.lang,
xml->end_switch_info.ref.name);
break;
case MOO_CONTEXT_STAY:
case MOO_CONTEXT_POP:
break;
}
}
}
else if (prop_equal (attr->name, RULE_INCLUDE_EOL_PROP))
{
xml->include_eol = parse_bool (val, TRUE);
}
else if (prop_equal (attr->name, RULE_INCLUDE_PROP))
{
xml->includes_into_next = parse_bool (val, FALSE);
}
else if (prop_equal (attr->name, RULE_BOL_PROP))
{
xml->bol_only = parse_bool (val, FALSE);
}
else if (prop_equal (attr->name, RULE_FIRST_NON_BLANK_PROP))
{
xml->first_non_blank_only = parse_bool (val, FALSE);
}
else if (prop_equal (attr->name, RULE_FIRST_LINE_PROP))
{
xml->first_line_only = parse_bool (val, FALSE);
}
else if (prop_equal (attr->name, RULE_CASELESS_PROP))
{
xml->caseless = parse_bool (val, FALSE);
}
xmlFree (val);
}
DEBUG_PRINT ({
g_print ("rule: %s\n", node->name);
});
ELM_FOREACH (node, child)
{
RuleXML *child_rule = rule_xml_parse (lang_xml, child);
if (!child_rule)
goto error;
xml->child_rules = g_slist_prepend (xml->child_rules, child_rule);
}
ELM_FOREACH_END;
xml->child_rules = g_slist_reverse (xml->child_rules);
return xml;
error:
rule_xml_free (xml);
return NULL;
}
inline static MooRuleFlags
rule_xml_get_flags (gpointer xmlptr)
{
RuleXML *xml = xmlptr;
MooRuleFlags flags = 0;
if (xml->includes_into_next)
flags |= MOO_RULE_INCLUDE_INTO_NEXT;
if (xml->bol_only)
flags |= MOO_RULE_MATCH_FIRST_CHAR;
if (xml->first_non_blank_only)
flags |= MOO_RULE_MATCH_FIRST_NON_EMPTY_CHAR;
if (xml->first_line_only)
flags |= MOO_RULE_MATCH_FIRST_LINE;
if (xml->caseless)
flags |= MOO_RULE_MATCH_CASELESS;
return flags;
}
inline static const char*
rule_xml_get_style (gpointer xmlptr)
{
return ((RuleXML*)xmlptr)->style;
}
MooRule*
moo_rule_new_from_xml (RuleXML *xml,
LangXML *lang_xml,
MooLang *lang)
{
MooRule *rule = NULL;
MooContext *switch_to;
g_return_val_if_fail (xml != NULL && lang != NULL, NULL);
switch (xml->type)
{
case RULE_STRING:
rule = rule_string_xml_create_rule ((RuleStringXML*) xml);
break;
case RULE_REGEX:
rule = rule_regex_xml_create_rule ((RuleRegexXML*) xml);
break;
case RULE_CHAR:
rule = rule_char_xml_create_rule ((RuleCharXML*) xml);
break;
case RULE_2CHAR:
rule = rule_2char_xml_create_rule ((Rule2CharXML*) xml);
break;
case RULE_ANY_CHAR:
rule = rule_any_char_xml_create_rule ((RuleAnyCharXML*) xml);
break;
case RULE_KEYWORDS:
rule = rule_keywords_xml_create_rule ((RuleKeywordsXML*) xml, lang_xml);
break;
case RULE_INCLUDE:
rule = rule_include_xml_create_rule ((RuleIncludeXML*) xml, lang);
break;
case RULE_INT:
case RULE_FLOAT:
case RULE_HEX:
case RULE_OCTAL:
case RULE_ESCAPED_CHAR:
case RULE_C_CHAR:
case RULE_WHITESPACE:
case RULE_IDENTIFIER:
case RULE_LINE_CONTINUE:
rule = rule_special_xml_create_rule (xml);
break;
}
if (!rule)
return NULL;
switch (xml->end_switch_info.type)
{
case MOO_CONTEXT_STAY:
moo_rule_set_end_stay (rule);
break;
case MOO_CONTEXT_POP:
moo_rule_set_end_pop (rule, xml->end_switch_info.num);
break;
case MOO_CONTEXT_SWITCH:
#if 0
case MOO_CONTEXT_JUMP:
#endif
if (xml->end_switch_info.ref.lang)
switch_to = moo_lang_mgr_get_context (lang->mgr,
xml->end_switch_info.ref.lang,
xml->end_switch_info.ref.name);
else
switch_to = moo_lang_get_context (lang, xml->end_switch_info.ref.name);
if (!switch_to)
{
g_critical ("%s: oops", G_STRLOC);
moo_rule_free (rule);
return NULL;
}
else
{
#if 0
if (xml->end_switch_info.type == MOO_CONTEXT_SWITCH)
#endif
moo_rule_set_end_switch (rule, switch_to);
#if 0
else
moo_rule_set_end_jump (rule, switch_to);
#endif
}
break;
}
if (xml->include_eol)
rule->include_eol = TRUE;
return rule;
}
static void
rule_xml_free (RuleXML *xml)
{
if (xml)
{
g_free (xml->style);
g_free (xml->context);
g_slist_foreach (xml->child_rules, (GFunc) rule_xml_free, NULL);
g_slist_free (xml->child_rules);
ctx_switch_info_destroy (&xml->end_switch_info);
switch (xml->type)
{
case RULE_STRING:
rule_string_xml_free ((RuleStringXML*) xml);
break;
case RULE_REGEX:
rule_regex_xml_free ((RuleRegexXML*) xml);
break;
case RULE_CHAR:
rule_char_xml_free ((RuleCharXML*) xml);
break;
case RULE_2CHAR:
rule_2char_xml_free ((Rule2CharXML*) xml);
break;
case RULE_ANY_CHAR:
rule_any_char_xml_free ((RuleAnyCharXML*) xml);
break;
case RULE_KEYWORDS:
rule_keywords_xml_free ((RuleKeywordsXML*) xml);
break;
case RULE_INCLUDE:
rule_include_xml_free ((RuleIncludeXML*) xml);
break;
case RULE_INT:
case RULE_FLOAT:
case RULE_HEX:
case RULE_OCTAL:
case RULE_ESCAPED_CHAR:
case RULE_C_CHAR:
case RULE_WHITESPACE:
case RULE_IDENTIFIER:
case RULE_LINE_CONTINUE:
rule_special_xml_free (xml);
break;
}
}
}
static RuleXML*
rule_string_xml_parse (xmlNode *node)
{
RuleStringXML *xml;
xmlChar *string;
g_assert (RULE_IS_STRING_NODE (node));
string = GET_PROP (node, RULE_STRING_STRING_PROP);
if (!string)
{
g_warning ("%s: '" RULE_STRING_STRING_PROP "' attribute missing in rule %s",
G_STRLOC, node->name);
return NULL;
}
xml = g_new0 (RuleStringXML, 1);
xml->string = STRDUP (string);
xmlFree (string);
return (RuleXML*) xml;
}
static MooRule*
rule_string_xml_create_rule (RuleStringXML *xml)
{
return moo_rule_string_new (xml->string,
rule_xml_get_flags (xml),
rule_xml_get_style (xml));
}
static void
rule_string_xml_free (RuleStringXML *xml)
{
g_free (xml->string);
g_free (xml);
}
static RuleXML*
rule_regex_xml_parse (xmlNode *node)
{
RuleRegexXML *xml;
xmlChar *pattern, *non_empty;
g_assert (RULE_IS_REGEX_NODE (node));
pattern = GET_PROP (node, RULE_REGEX_PATTERN_PROP);
non_empty = GET_PROP (node, RULE_REGEX_NON_EMPTY_PROP);
if (!pattern)
{
g_warning ("%s: '" RULE_REGEX_PATTERN_PROP "' attribute missing in rule %s",
G_STRLOC, node->name);
STRING_FREE (non_empty);
return NULL;
}
xml = g_new0 (RuleRegexXML, 1);
xml->pattern = STRDUP (pattern);
xml->non_empty = parse_bool (non_empty, TRUE);
STRING_FREE (pattern);
STRING_FREE (non_empty);
return (RuleXML*) xml;
}
static MooRule*
rule_regex_xml_create_rule (RuleRegexXML *xml)
{
return moo_rule_regex_new (xml->pattern, xml->non_empty,
0, 0,
rule_xml_get_flags (xml),
rule_xml_get_style (xml));
}
static void
rule_regex_xml_free (RuleRegexXML *xml)
{
g_free (xml->pattern);
g_free (xml);
}
static RuleXML*
rule_char_xml_parse (xmlNode *node)
{
RuleCharXML *xml;
xmlChar *ch;
g_assert (RULE_IS_CHAR_NODE (node));
ch = GET_PROP (node, RULE_CHAR_CHAR_PROP);
if (!ch || !ch[0])
{
g_warning ("%s: '" RULE_CHAR_CHAR_PROP "' attribute missing in rule %s",
G_STRLOC, node->name);
return NULL;
}
if (ch[1] != 0)
{
g_warning ("%s: invalid '" RULE_CHAR_CHAR_PROP "' attribute '%s' in rule %s",
G_STRLOC, ch, node->name);
goto error;
}
xml = g_new0 (RuleCharXML, 1);
xml->ch = ch[0];
xmlFree (ch);
return (RuleXML*) xml;
error:
STRING_FREE (ch);
return NULL;
}
static MooRule*
rule_char_xml_create_rule (RuleCharXML *xml)
{
return moo_rule_char_new (xml->ch,
rule_xml_get_flags (xml),
rule_xml_get_style (xml));
}
static RuleXML*
rule_special_xml_parse (G_GNUC_UNUSED xmlNode *node)
{
return g_new0 (RuleXML, 1);
}
static MooRule*
rule_special_xml_create_rule (RuleXML *xml)
{
MooRuleFlags flags = rule_xml_get_flags (xml);
const char *style = rule_xml_get_style (xml);
switch (xml->type)
{
case RULE_INT:
return moo_rule_int_new (flags, style);
case RULE_WHITESPACE:
return moo_rule_whitespace_new (flags, style);
case RULE_IDENTIFIER:
return moo_rule_identifier_new (flags, style);
case RULE_FLOAT:
return moo_rule_float_new (flags, style);
case RULE_HEX:
return moo_rule_hex_new (flags, style);
case RULE_OCTAL:
return moo_rule_octal_new (flags, style);
case RULE_ESCAPED_CHAR:
return moo_rule_escaped_char_new (flags, style);
case RULE_C_CHAR:
return moo_rule_c_char_new (flags, style);
case RULE_LINE_CONTINUE:
return moo_rule_line_continue_new (flags, style);
default:
g_return_val_if_reached (NULL);
}
}
static RuleXML*
rule_2char_xml_parse (xmlNode *node)
{
Rule2CharXML *xml;
xmlChar *ch1, *ch2;
g_assert (RULE_IS_2CHAR_NODE (node));
ch1 = GET_PROP (node, RULE_2CHAR_CHAR1_PROP);
ch2 = GET_PROP (node, RULE_2CHAR_CHAR2_PROP);
if (!ch1 || !ch1[0])
{
g_warning ("%s: '" RULE_2CHAR_CHAR1_PROP "' attribute missing in rule %s",
G_STRLOC, node->name);
goto error;
}
if (!ch2 || !ch2[0])
{
g_warning ("%s: '" RULE_2CHAR_CHAR2_PROP "' attribute missing in rule %s",
G_STRLOC, node->name);
goto error;
}
if (ch1[1] != 0)
{
g_warning ("%s: invalid '" RULE_2CHAR_CHAR1_PROP "' attribute '%s' in rule %s",
G_STRLOC, ch1, node->name);
goto error;
}
if (ch2[1] != 0)
{
g_warning ("%s: invalid '" RULE_2CHAR_CHAR2_PROP "' attribute '%s' in rule %s",
G_STRLOC, ch2, node->name);
goto error;
}
xml = g_new0 (Rule2CharXML, 1);
xml->chars[0] = ch1[0];
xml->chars[1] = ch2[0];
xmlFree (ch1);
xmlFree (ch2);
return (RuleXML*) xml;
error:
STRING_FREE (ch1);
STRING_FREE (ch2);
return NULL;
}
static MooRule*
rule_2char_xml_create_rule (Rule2CharXML *xml)
{
return moo_rule_2char_new (xml->chars[0], xml->chars[1],
rule_xml_get_flags (xml),
rule_xml_get_style (xml));
}
static RuleXML*
rule_any_char_xml_parse (xmlNode *node)
{
RuleAnyCharXML *xml;
xmlChar *range;
g_assert (RULE_IS_ANY_CHAR_NODE (node));
range = GET_PROP (node, RULE_ANY_CHAR_CHARS_PROP);
if (!range)
{
g_warning ("%s: '" RULE_ANY_CHAR_CHARS_PROP "' attribute missing in rule %s",
G_STRLOC, node->name);
return NULL;
}
xml = g_new0 (RuleAnyCharXML, 1);
xml->range = STRDUP (range);
xmlFree (range);
return (RuleXML*) xml;
}
static MooRule*
rule_any_char_xml_create_rule (RuleAnyCharXML *xml)
{
return moo_rule_any_char_new (xml->range,
rule_xml_get_flags (xml),
rule_xml_get_style (xml));
}
static void
rule_any_char_xml_free (RuleAnyCharXML *xml)
{
g_free (xml->range);
g_free (xml);
}
static RuleXML*
rule_keywords_xml_parse (LangXML *lang_xml,
xmlNode *node)
{
RuleKeywordsXML *xml;
xmlChar *keyword;
g_assert (RULE_IS_KEYWORDS_NODE (node));
keyword = GET_PROP (node, RULE_KEYWORDS_KEYWORD_PROP);
if (!keyword)
{
g_warning ("%s: '" RULE_KEYWORDS_KEYWORD_PROP "' attribute missing in rule %s",
G_STRLOC, node->name);
return NULL;
}
xml = g_new0 (RuleKeywordsXML, 1);
xml->keywords = STRDUP (keyword);
lang_xml_add_keyword_ref (lang_xml, keyword);
xmlFree (keyword);
return (RuleXML*) xml;
}
static MooRule*
rule_keywords_xml_create_rule (RuleKeywordsXML *xml,
LangXML *lang_xml)
{
KeywordXML *kw_xml;
kw_xml = g_hash_table_lookup (lang_xml->keyword_names, xml->keywords);
g_return_val_if_fail (kw_xml != NULL, NULL);
return moo_rule_keywords_new (kw_xml->words,
rule_xml_get_flags (xml),
rule_xml_get_style (xml));
}
static void
rule_keywords_xml_free (RuleKeywordsXML *xml)
{
g_free (xml->keywords);
g_free (xml);
}
static RuleXML*
rule_include_xml_parse (LangXML *lang_xml,
xmlNode *node)
{
RuleIncludeXML *xml;
xmlChar *from = NULL;
char *lang = NULL, *name = NULL;
g_assert (RULE_IS_INCLUDE_NODE (node));
from = GET_PROP (node, RULE_INCLUDE_FROM_PROP);
if (!from || !from[0])
{
g_warning ("%s: '" RULE_INCLUDE_FROM_PROP "' attribute missing in rule %s",
G_STRLOC, node->name);
goto error;
}
if (!parse_name_ref (from, &lang, &name))
{
g_warning ("%s: invalid value '%s' of attribute '" RULE_INCLUDE_FROM_PROP "' in rule %s",
G_STRLOC, from, node->name);
goto error;
}
xml = g_new0 (RuleIncludeXML, 1);
xml->from_context = name;
xml->from_lang = lang;
lang_xml_add_cross_ref (lang_xml, lang, name);
xmlFree (from);
return (RuleXML*) xml;
error:
STRING_FREE (from);
g_free (lang);
g_free (name);
return NULL;
}
static MooRule*
rule_include_xml_create_rule (RuleIncludeXML *xml,
MooLang *lang)
{
MooContext *ctx;
if (xml->from_lang)
ctx = moo_lang_mgr_get_context (lang->mgr, xml->from_lang, xml->from_context);
else
ctx = moo_lang_get_context (lang, xml->from_context);
g_return_val_if_fail (ctx != NULL, NULL);
return moo_rule_include_new (ctx);
}
static void
rule_include_xml_free (RuleIncludeXML *xml)
{
g_free (xml->from_lang);
g_free (xml->from_context);
g_free (xml);
}
#endif /* MOO_USE_XML */
/****************************************************************************/
/* Style schemes
* Style schemes are stored in simplish XML files without fancy entities or
* something, so GMarkup will do fine
*/
static gboolean
parse_bool_check (const char *string,
gboolean *val)
{
g_return_val_if_fail (string != NULL && val != NULL, FALSE);
if (!g_ascii_strcasecmp (string, "true") ||
!g_ascii_strcasecmp (string, "yes") ||
!strcmp (string, "1"))
{
*val = TRUE;
return TRUE;
}
else if (!g_ascii_strcasecmp (string, "false") ||
!g_ascii_strcasecmp (string, "no") ||
!strcmp (string, "0"))
{
*val = FALSE;
return TRUE;
}
else
{
g_warning ("%s: could not get boolean value from '%s'",
G_STRLOC, string);
return FALSE;
}
}
static gboolean
parse_color_check (const char *string,
GdkColor *val)
{
g_return_val_if_fail (string != NULL && val != NULL, FALSE);
if (gdk_color_parse (string, val))
return TRUE;
g_warning ("%s: could not get color value from '%s'",
G_STRLOC, string);
return FALSE;
}
static MooTextStyle*
style_from_xml (MooMarkupNode *node)
{
const char *default_style_prop = NULL;
const char *bold_prop = NULL, *italic_prop = NULL;
const char *underline_prop = NULL, *strikethrough_prop = NULL;
const char *foreground_prop = NULL, *background_prop = NULL;
GdkColor foreground, background;
gboolean bold, italic, underline, strikethrough;
MooTextStyleMask mask = 0;
g_return_val_if_fail (node != NULL, NULL);
default_style_prop = moo_markup_get_prop (node, STYLE_DEF_STYLE_PROP);
bold_prop = moo_markup_get_prop (node, STYLE_BOLD_PROP);
italic_prop = moo_markup_get_prop (node, STYLE_ITALIC_PROP);
underline_prop = moo_markup_get_prop (node, STYLE_UNDERLINE_PROP);
strikethrough_prop = moo_markup_get_prop (node, STYLE_STRIKETHROUGH_PROP);
foreground_prop = moo_markup_get_prop (node, STYLE_FOREGROUND_PROP);
background_prop = moo_markup_get_prop (node, STYLE_BACKGROUND_PROP);
if (bold_prop && parse_bool_check (bold_prop, &bold))
mask |= MOO_TEXT_STYLE_BOLD;
if (italic_prop && parse_bool_check (italic_prop, &italic))
mask |= MOO_TEXT_STYLE_ITALIC;
if (underline_prop && parse_bool_check (underline_prop, &underline))
mask |= MOO_TEXT_STYLE_UNDERLINE;
if (strikethrough_prop && parse_bool_check (strikethrough_prop, &strikethrough))
mask |= MOO_TEXT_STYLE_STRIKETHROUGH;
if (foreground_prop && parse_color_check (foreground_prop, &foreground))
mask |= MOO_TEXT_STYLE_FOREGROUND;
if (background_prop && parse_color_check (background_prop, &background))
mask |= MOO_TEXT_STYLE_BACKGROUND;
return moo_text_style_new (default_style_prop,
&foreground, &background,
bold, italic, underline,
strikethrough, mask, FALSE);
}
#define M_NODE_NAME_IS_(node_, name_) (node_->name && !strcmp (node_->name, name_))
#define M_IS_LANGUAGE_NODE(node_) (MOO_MARKUP_IS_ELEMENT(node_) && M_NODE_NAME_IS_(node_, LANGUAGE_ELM))
#define M_IS_STYLE_NODE(node_) (MOO_MARKUP_IS_ELEMENT(node_) && M_NODE_NAME_IS_(node_, STYLE_ELM))
#define M_IS_SCHEME_NODE(node_) (MOO_MARKUP_IS_ELEMENT(node_) && M_NODE_NAME_IS_(node_, SCHEME_ELM))
#define M_IS_DEFAULT_STYLE_NODE(node_) (MOO_MARKUP_IS_ELEMENT(node_) && M_NODE_NAME_IS_(node_, DEFAULT_STYLE_ELM))
#define M_IS_BRACKET_MATCH_NODE(node_) (MOO_MARKUP_IS_ELEMENT(node_) && M_NODE_NAME_IS_(node_, BRACKET_MATCH_ELM))
#define M_IS_BRACKET_MISMATCH_NODE(node_) (MOO_MARKUP_IS_ELEMENT(node_) && M_NODE_NAME_IS_(node_, BRACKET_MISMATCH_ELM))
static gboolean
style_scheme_xml_parse_lang (MooTextStyleScheme *scheme,
MooMarkupNode *node)
{
const char *lang_name = NULL;
MooMarkupNode *child;
g_return_val_if_fail (M_IS_LANGUAGE_NODE (node), FALSE);
lang_name = moo_markup_get_prop (node, LANG_NAME_PROP);
if (!lang_name || !lang_name[0])
{
g_warning ("%s: no name in '" LANGUAGE_ELM "' node", G_STRLOC);
goto error;
}
for (child = node->children; child != NULL; child = child->next)
{
if (!MOO_MARKUP_IS_ELEMENT (child))
continue;
if (M_IS_STYLE_NODE (child))
{
const char *style_name = moo_markup_get_prop (child, STYLE_NAME_PROP);
MooTextStyle *style;
if (!style_name)
{
g_warning ("%s: style name absent in '" STYLE_ELM "' node",
G_STRLOC);
goto error;
}
style = style_from_xml (child);
if (!style)
goto error;
moo_text_style_scheme_set (scheme, lang_name, style_name, style);
moo_text_style_free (style);
}
else
{
g_warning ("%s: unknown tag '%s'", G_STRLOC, child->name);
goto error;
}
}
return TRUE;
error:
return FALSE;
}
static MooTextStyleScheme*
style_scheme_xml_parse (MooMarkupNode *node,
char **base_scheme)
{
MooTextStyleScheme *scheme = NULL;
MooMarkupNode *child;
const char *name = NULL, *foreground = NULL, *background = NULL, *base = NULL;
const char *selected_foreground = NULL, *selected_background = NULL, *current_line = NULL;
g_return_val_if_fail (M_IS_SCHEME_NODE (node), NULL);
name = moo_markup_get_prop (node, SCHEME_NAME_PROP);
foreground = moo_markup_get_prop (node, SCHEME_FOREGROUND_PROP);
background = moo_markup_get_prop (node, SCHEME_BACKGROUND_PROP);
selected_foreground = moo_markup_get_prop (node, SCHEME_SEL_FOREGROUND_PROP);
selected_background = moo_markup_get_prop (node, SCHEME_SEL_BACKGROUND_PROP);
current_line = moo_markup_get_prop (node, SCHEME_CURRENT_LINE_PROP);
base = moo_markup_get_prop (node, SCHEME_BASE_SCHEME_PROP);
if (!name || !name[0])
{
g_warning ("%s: no name in '" SCHEME_ELM "' node", G_STRLOC);
goto error;
}
scheme = moo_text_style_scheme_new_empty (name, NULL);
scheme->text_colors[MOO_TEXT_COLOR_FG] = g_strdup (foreground);
scheme->text_colors[MOO_TEXT_COLOR_BG] = g_strdup (background);
scheme->text_colors[MOO_TEXT_COLOR_SEL_FG] = g_strdup (selected_foreground);
scheme->text_colors[MOO_TEXT_COLOR_SEL_BG] = g_strdup (selected_background);
scheme->text_colors[MOO_TEXT_COLOR_CUR_LINE] = g_strdup (current_line);
for (child = node->children; child != NULL; child = child->next)
{
if (!MOO_MARKUP_IS_ELEMENT (child))
continue;
if (M_IS_DEFAULT_STYLE_NODE (child))
{
const char *style_name = moo_markup_get_prop (child, STYLE_NAME_PROP);
MooTextStyle *style;
if (!style_name)
{
g_warning ("%s: style name absent in '" DEFAULT_STYLE_ELM "' node",
G_STRLOC);
goto error;
}
style = style_from_xml (child);
if (!style)
goto error;
moo_text_style_scheme_set (scheme, NULL, style_name, style);
moo_text_style_free (style);
}
else if (M_IS_LANGUAGE_NODE (child))
{
if (!style_scheme_xml_parse_lang (scheme, child))
goto error;
}
else if (M_IS_BRACKET_MATCH_NODE (child))
{
if (scheme->bracket_match)
{
g_warning ("%s: duplicated '" BRACKET_MATCH_ELM "'", G_STRLOC);
goto error;
}
scheme->bracket_match = style_from_xml (child);
if (!scheme->bracket_match)
goto error;
}
else if (M_IS_BRACKET_MISMATCH_NODE (child))
{
if (scheme->bracket_mismatch)
{
g_warning ("%s: duplicated '" BRACKET_MISMATCH_ELM "'", G_STRLOC);
goto error;
}
scheme->bracket_mismatch = style_from_xml (child);
if (!scheme->bracket_mismatch)
goto error;
}
else
{
g_warning ("%s: unknown tag '%s'", G_STRLOC, child->name);
goto error;
}
}
if (base_scheme)
*base_scheme = g_strdup (base);
return scheme;
error:
if (scheme)
g_object_unref (scheme);
return NULL;
}
MooTextStyleScheme*
moo_text_style_scheme_parse_file (const char *file,
char **base_scheme)
{
MooMarkupDoc *doc;
MooMarkupNode *root;
MooTextStyleScheme *scheme;
GError *error = NULL;
g_return_val_if_fail (file != NULL, NULL);
doc = moo_markup_parse_file (file, &error);
if (!doc)
{
g_warning ("%s: could not parse file '%s'", G_STRLOC, file);
if (error)
{
g_warning ("%s: %s", G_STRLOC, error->message);
g_error_free (error);
}
return NULL;
}
root = moo_markup_get_root_element (doc, NULL);
scheme = style_scheme_xml_parse (root, base_scheme);
moo_markup_doc_unref (doc);
return scheme;
}
MooTextStyleScheme*
moo_text_style_scheme_parse_memory (const char *buffer,
int size,
char **base_scheme)
{
MooMarkupDoc *doc;
MooMarkupNode *root;
MooTextStyleScheme *scheme;
GError *error = NULL;
g_return_val_if_fail (buffer != NULL, NULL);
if (size < 0)
size = strlen (buffer);
doc = moo_markup_parse_memory (buffer, size, &error);
if (!doc)
{
g_warning ("%s: could not parse string", G_STRLOC);
if (error)
{
g_warning ("%s: %s", G_STRLOC, error->message);
g_error_free (error);
}
return NULL;
}
root = moo_markup_get_root_element (doc, NULL);
scheme = style_scheme_xml_parse (root, base_scheme);
moo_markup_doc_unref (doc);
return scheme;
}
Reference in New Issue View Git Blame Copy Permalink