#include <stdio.h>
#include <stdbool.h>
#include <unistd.h>
#include <getopt.h>
#include <string.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include "xml-utils.h"
#include "languages.h"

#define PROG_NAME "xml-highlight"
#define VERSION "1.4.0"

#define PRE_KEYWORD_DELIM BAD_CAST " (\n"
#define POST_KEYWORD_DELIM BAD_CAST " .,);\n"

#define ELEM_XPATH "//*[processing-instruction('language')='%s']/text()"

static xmlNodePtr first_xpath_node(xmlDocPtr doc, xmlNodePtr node, const xmlChar *expr)
{
       xmlXPathContextPtr ctx;
       xmlXPathObjectPtr obj;
       xmlNodePtr first;

       ctx = xmlXPathNewContext(doc ? doc : node->doc);
       ctx->node = node;

       obj = xmlXPathEvalExpression(expr, ctx);

       first = xmlXPathNodeSetIsEmpty(obj->nodesetval) ? NULL : obj->nodesetval->nodeTab[0];

       xmlXPathFreeObject(obj);
       xmlXPathFreeContext(ctx);

       return first;
}

static bool is_keyword(xmlChar *content, int content_len, int i, const xmlChar *keyword, int keyword_len, bool ignorecase)
{
       bool is;
       xmlChar s, e;
       int (*cmp)(const xmlChar *, const xmlChar *, int);

       cmp = ignorecase ? xmlStrncasecmp : xmlStrncmp;

       s = i == 0 ? ' ' : content[i - 1];
       e = i + keyword_len >= content_len - 1 ? ' ' : content[i + keyword_len];

       is = xmlStrchr(PRE_KEYWORD_DELIM, s) &&
            cmp(content + i, keyword, keyword_len) == 0 &&
            xmlStrchr(POST_KEYWORD_DELIM, e);

       return is;
}

static void highlight_keyword_in_node(xmlNodePtr node, const xmlChar *keyword, xmlNodePtr tag, bool ignorecase)
{
       xmlChar *content;
       int keyword_len, content_len;
       int i;

       content = xmlNodeGetContent(node);
       content_len = xmlStrlen(content);

       keyword_len = xmlStrlen(keyword);

       i = 0;
       while (i + keyword_len <= content_len) {
               if (is_keyword(content, content_len, i, keyword, keyword_len, ignorecase)) {
                       xmlChar *s1 = xmlStrndup(content, i);
                       xmlChar *s2 = xmlStrsub(content, i + keyword_len, content_len - (i + keyword_len));
                       xmlChar *s3 = xmlStrsub(content, i, keyword_len);
                       xmlNodePtr elem;

                       xmlFree(content);

                       xmlNodeSetContent(node, s1);
                       xmlFree(s1);

                       elem = xmlAddNextSibling(node, xmlCopyNode(tag, 1));
                       xmlNodeSetContent(elem, s3);
                       xmlFree(s3);

                       node = xmlAddNextSibling(elem, xmlNewText(s2));

                       content = s2;
                       content_len = xmlStrlen(s2);
                       i = 0;
               } else {
                       ++i;
               }
       }

       xmlFree(content);
}

static void highlight_area_in_node(xmlNodePtr node, const xmlChar *start, const xmlChar *end, xmlNodePtr tag, bool ignorecase)
{
       xmlChar *content;
       int i, slen, elen;
       int (*cmp)(const xmlChar *, const xmlChar *, int);
       const xmlChar *(*sub)(const xmlChar *, const xmlChar *);

       content = xmlNodeGetContent(node);
       slen = xmlStrlen(start);
       elen = xmlStrlen(end);

       cmp = ignorecase ? xmlStrncasecmp : xmlStrncmp;
       sub = ignorecase ? xmlStrcasestr : xmlStrstr;

       for (i = 0; content[i]; ++i) {
               if (cmp(content + i, start, slen) == 0) {
                       const xmlChar *e;
                       int len;
                       xmlChar *s1, *s2, *s3;
                       xmlNodePtr elem;

                       e = sub(content + i + 1, end);
                       if (!e) {
                               e = content + (xmlStrlen(content) - 1);
                       }

                       len = e - (content + i) + elen;

                       s1 = xmlStrndup(content, i);
                       s2 = xmlStrndup(content + i, len);
                       s3 = xmlStrdup(content + i + len);

                       xmlFree(content);

                       xmlNodeSetContent(node, s1);
                       xmlFree(s1);

                       elem = xmlAddNextSibling(node, xmlCopyNode(tag, 1));
                       xmlNodeSetContent(elem, s2);
                       xmlFree(s2);

                       node = xmlAddNextSibling(elem, xmlNewText(s3));

                       content = s3;

                       i = 0;
               }
       }

       xmlFree(content);
}

static void highlight_keyword_in_nodes(xmlNodeSetPtr nodes, const xmlChar *keyword, xmlNodePtr tag, bool ignorecase)
{
       int i;
       for (i = 0; i < nodes->nodeNr; ++i) {
               highlight_keyword_in_node(nodes->nodeTab[i], keyword, tag, ignorecase);
       }
}

static void highlight_area_in_nodes(xmlNodeSetPtr nodes, const xmlChar *start, const xmlChar *end, xmlNodePtr tag, bool ignorecase)
{
       int i;
       for (i = 0; i < nodes->nodeNr; ++i) {
               highlight_area_in_node(nodes->nodeTab[i], start, end, tag, ignorecase);
       }
}

static void highlight_keyword_in_doc(xmlDocPtr doc, const xmlChar *lang, const xmlChar *keyword, xmlNodePtr tag, bool ignorecase)
{
       xmlXPathContextPtr ctx;
       xmlXPathObjectPtr obj;

       xmlChar xpath[256];

       xmlStrPrintf(xpath, 256, ELEM_XPATH, lang);

       ctx = xmlXPathNewContext(doc);
       obj = xmlXPathEvalExpression(xpath, ctx);

       if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
               highlight_keyword_in_nodes(obj->nodesetval, keyword, tag, ignorecase);
       }

       xmlXPathFreeObject(obj);
       xmlXPathFreeContext(ctx);
}

static void highlight_area_in_doc(xmlDocPtr doc, const xmlChar *lang, const xmlChar *start, const xmlChar *end, xmlNodePtr tag, bool ignorecase)
{
       xmlXPathContextPtr ctx;
       xmlXPathObjectPtr obj;

       xmlChar xpath[256];

       xmlStrPrintf(xpath, 256, ELEM_XPATH, lang);

       ctx = xmlXPathNewContext(doc);
       obj = xmlXPathEvalExpression(xpath, ctx);

       if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
               highlight_area_in_nodes(obj->nodesetval, start, end, tag, ignorecase);
       }

       xmlXPathFreeObject(obj);
       xmlXPathFreeContext(ctx);
}

static xmlNodePtr get_class(const xmlChar *class, xmlDocPtr classes, xmlDocPtr syntax)
{
       xmlNodePtr node;
       xmlChar xpath[256];

       xmlStrPrintf(xpath, 256, "//class[@id='%s']", class);

       node = first_xpath_node(classes, NULL, xpath);

       if (!node) {
               node = first_xpath_node(syntax, NULL, xpath);
       }

       return node;
}

static void highlight_keyword_node_in_doc(xmlDocPtr doc, xmlDocPtr syntax, xmlDocPtr classes, const xmlChar *lang, xmlNodePtr node, bool ignorecase)
{
       xmlChar *keyword, *class;
       xmlNodePtr tag;

       keyword = xmlGetProp(node, BAD_CAST "match");
       class   = xmlGetProp(node, BAD_CAST "class");

       if (class) {
               tag = xmlFirstElementChild(get_class(class, classes, syntax));
       } else {
               tag = xmlFirstElementChild(node);
       }

       if (tag) {
               highlight_keyword_in_doc(doc, lang, keyword, tag, ignorecase);
       }

       xmlFree(keyword);
       xmlFree(class);
}

static void highlight_area_node_in_doc(xmlDocPtr doc, xmlDocPtr syntax, xmlDocPtr classes, const xmlChar *lang, xmlNodePtr node, bool ignorecase)
{
       xmlChar *start, *end, *class;
       xmlNodePtr tag;

       start = xmlGetProp(node, BAD_CAST "start");
       end   = xmlGetProp(node, BAD_CAST "end");
       class = xmlGetProp(node, BAD_CAST "class");

       if (class) {
               tag = xmlFirstElementChild(get_class(class, classes, syntax));
       } else {
               tag = xmlFirstElementChild(node);
       }

       if (tag) {
               highlight_area_in_doc(doc, lang, start, end, tag, ignorecase);
       }

       xmlFree(start);
       xmlFree(end);
       xmlFree(class);
}

static void highlight_language_in_doc(xmlDocPtr doc, xmlDocPtr syntax,
       xmlDocPtr classes, xmlNodePtr language)
{
       xmlXPathContextPtr ctx;
       xmlXPathObjectPtr obj;
       xmlChar *lang, *case_insen;
       bool ignorecase = false;

       lang = xmlGetProp(language, BAD_CAST "name");
       case_insen = xmlGetProp(language, BAD_CAST "caseInsensitive");

       if (case_insen) {
               ignorecase = xmlStrcmp(case_insen, BAD_CAST "yes") == 0;
       }

       xmlFree(case_insen);

       ctx = xmlXPathNewContext(syntax);
       ctx->node = language;

       obj = xmlXPathEvalExpression(BAD_CAST "area", ctx);

       if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
               int i;
               for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
                       highlight_area_node_in_doc(doc, syntax, classes, lang, obj->nodesetval->nodeTab[i], ignorecase);
               }
       }

       xmlXPathFreeObject(obj);

       obj = xmlXPathEvalExpression(BAD_CAST "keyword", ctx);

       if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
               int i;
               for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
                       highlight_keyword_node_in_doc(doc, syntax, classes, lang, obj->nodesetval->nodeTab[i], ignorecase);
               }
       }

       xmlFree(lang);

       xmlXPathFreeObject(obj);
       xmlXPathFreeContext(ctx);
}

static void highlight_syntax_in_doc(xmlDocPtr doc, xmlDocPtr syntax, xmlDocPtr classes)
{
       xmlXPathContextPtr ctx;
       xmlXPathObjectPtr obj;

       ctx = xmlXPathNewContext(syntax);
       obj = xmlXPathEvalExpression(BAD_CAST "//language", ctx);

       if (!xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
               int i;
               for (i = 0; i < obj->nodesetval->nodeNr; ++i) {
                       highlight_language_in_doc(doc, syntax, classes,
                               obj->nodesetval->nodeTab[i]);
               }
       }

       xmlXPathFreeObject(obj);
       xmlXPathFreeContext(ctx);
}

static void highlight_syntax_in_file(const char *fname, const char *syntax, const char *classes, bool overwrite)
{
       xmlDocPtr doc;
       xmlDocPtr syndoc;
       xmlDocPtr classdoc;

       if (syntax) {
               syndoc = read_xml_doc(syntax);
       } else {
               syndoc = read_xml_mem((const char *) syntax_xml, syntax_xml_len);
       }

       if (classes) {
               classdoc = read_xml_doc(classes);
       } else {
               classdoc = read_xml_mem((const char *) classes_xml, classes_xml_len);
       }

       doc = read_xml_doc(fname);

       highlight_syntax_in_doc(doc, syndoc, classdoc);

       if (overwrite) {
               save_xml_doc(doc, fname);
       } else {
               save_xml_doc(doc, "-");
       }

       xmlFreeDoc(doc);
       xmlFreeDoc(syndoc);
       xmlFreeDoc(classdoc);
}

static void show_help(void)
{
       puts("Usage: " PROG_NAME " [options] [<document>...]");
       puts("");
       puts("Options:");
       puts("  -c, --classes <XML>  Use a custom classes XML file.");
       puts("  -f, --overwrite      Overwrite input documents.");
       puts("  -h, -?, --help       Show usage message.");
       puts("  -s, --syntax <XML>   Use a custom syntax definitions XML file.");
       puts("  --version            Show version information.");
       LIBXML2_PARSE_LONGOPT_HELP
}

static void show_version(void)
{
       printf("%s (xml-utils) %s\n", PROG_NAME, VERSION);
       printf("Using libxml %s\n", xmlParserVersion);
}

int main(int argc, char **argv)
{
       int i;
       bool overwrite = false;
       char *syntax = NULL;
       char *classes = NULL;

       const char *sopts = "c:fs:h?";
       struct option lopts[] = {
               {"version"  , no_argument      , 0, 0},
               {"help"     , no_argument      , 0, 'h'},
               {"classes"  , required_argument, 0, 'c'},
               {"overwrite", no_argument      , 0, 'f'},
               {"syntax"   , required_argument, 0, 's'},
               LIBXML2_PARSE_LONGOPT_DEFS
               {0, 0, 0, 0}
       };
       int loptind = 0;

       while ((i = getopt_long(argc, argv, sopts, lopts, &loptind)) != -1) {
               switch (i) {
                       case 0:
                               if (strcmp(lopts[loptind].name, "version") == 0) {
                                       show_version();
                                       return 0;
                               }
                               LIBXML2_PARSE_LONGOPT_HANDLE(lopts, loptind, optarg)
                               break;
                       case 'c':
                               if (!classes)
                                       classes = strdup(optarg);
                               break;
                       case 'f':
                               overwrite = true;
                               break;
                       case 's':
                               if (!syntax)
                                       syntax = strdup(optarg);
                               break;
                       case 'h':
                       case '?':
                               show_help();
                               return 0;
               }
       }

       if (optind >= argc) {
               highlight_syntax_in_file("-", syntax, classes, false);
       } else {
               for (i = optind; i < argc; ++i) {
                       highlight_syntax_in_file(argv[i], syntax, classes, overwrite);
               }
       }

       free(syntax);
       free(classes);

       xmlCleanupParser();

       return 0;
}

You are viewing proxied material from khzae.net. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.