Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * This file is part of libdom test suite.
  3.  * Licensed under the MIT License,
  4.  *                http://www.opensource.org/licenses/mit-license.php
  5.  * Copyright 2009 Bo Yang <struggleyb.nku@gmail.com>
  6.  */
  7.  
  8. #include <stdarg.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11.  
  12. #include <sys/types.h>
  13. #include <sys/uio.h>
  14. #include <unistd.h>
  15. #include <fcntl.h>
  16.  
  17. #include <libwapcaplet/libwapcaplet.h>
  18.  
  19. // For parsers
  20. #include <dom/dom.h>
  21. #include <xmlparser.h>
  22. #include <parser.h>
  23. #include <errors.h>
  24.  
  25. #include "utils.h"
  26. #include "domts.h"
  27.  
  28. /**
  29.  * Load the file as it is a XML file
  30.  *
  31.  * \param file          The file path
  32.  * \param willBeModified        Whether this file will be modified, not used
  33.  */
  34. dom_document *load_xml(const char *file, bool willBeModified)
  35. {
  36.         dom_xml_parser *parser = NULL;
  37.         int handle;
  38.         int readed;
  39.         dom_xml_error error;
  40.         dom_document *ret;
  41.         uint8_t buffer[1024];
  42.  
  43.         UNUSED(willBeModified);
  44.  
  45.         parser = dom_xml_parser_create(NULL, NULL, mymsg, NULL, &ret);
  46.         if (parser == NULL) {
  47.                 fprintf(stderr, "Can't create XMLParser\n");
  48.                 return NULL;
  49.         }
  50.  
  51.         handle = open(file, O_RDONLY);
  52.         if (handle == -1) {
  53.                 dom_node_unref(ret);
  54.                 dom_xml_parser_destroy(parser);
  55.                 fprintf(stderr, "Can't open test input file: %s\n", file);
  56.                 return NULL;
  57.         }
  58.  
  59.         readed = read(handle, buffer, 1024);
  60.         error = dom_xml_parser_parse_chunk(parser, buffer, readed);
  61.         if (error != DOM_XML_OK) {
  62.                 dom_node_unref(ret);
  63.                 dom_xml_parser_destroy(parser);
  64.                 fprintf(stderr, "Parsing errors occur\n");
  65.                 return NULL;
  66.         }
  67.  
  68.         while(readed == 1024) {
  69.                 readed = read(handle, buffer, 1024);
  70.                 error = dom_xml_parser_parse_chunk(parser, buffer, readed);
  71.                 if (error != DOM_XML_OK) {
  72.                         dom_node_unref(ret);
  73.                         dom_xml_parser_destroy(parser);
  74.                         fprintf(stderr, "Parsing errors occur\n");
  75.                         return NULL;
  76.                 }
  77.         }
  78.  
  79.         error = dom_xml_parser_completed(parser);
  80.         if (error != DOM_XML_OK) {
  81.                 dom_node_unref(ret);
  82.                 dom_xml_parser_destroy(parser);
  83.                 fprintf(stderr, "Parsing error when construct DOM\n");
  84.                 return NULL;
  85.         }
  86.  
  87.         dom_xml_parser_destroy(parser);
  88.  
  89.         return ret;
  90. }
  91.  
  92. /**
  93.  * Load the file as it is a HTML file
  94.  *
  95.  * \param file          The file path
  96.  * \param willBeModified        Whether this file will be modified, not used
  97.  */
  98. dom_document *load_html(const char *file, bool willBeModified)
  99. {
  100.         dom_hubbub_parser *parser = NULL;
  101.         int handle;
  102.         int readed;
  103.         dom_hubbub_error error;
  104.         dom_document *ret;
  105.         uint8_t buffer[1024];
  106.         dom_hubbub_parser_params params;
  107.  
  108.         UNUSED(willBeModified);
  109.  
  110.         params.enc = NULL;
  111.         params.fix_enc = true;
  112.         params.enable_script = false;
  113.         params.msg = mymsg;
  114.         params.script = NULL;
  115.         params.ctx = NULL;
  116.         params.daf = NULL;
  117.  
  118.         error = dom_hubbub_parser_create(&params, &parser, &ret);
  119.         if (error != DOM_HUBBUB_OK) {
  120.                 fprintf(stderr, "Can't create Hubbub Parser\n");
  121.                 return NULL;
  122.         }
  123.  
  124.         handle = open(file, O_RDONLY);
  125.         if (handle == -1) {
  126.                 dom_hubbub_parser_destroy(parser);
  127.                 /* fprintf(stderr, "Can't open test input file: %s\n", file); */
  128.                 return NULL;
  129.         }
  130.  
  131.         readed = read(handle, buffer, 1024);
  132.         error = dom_hubbub_parser_parse_chunk(parser, buffer, readed);
  133.         if (error != DOM_HUBBUB_OK) {
  134.                 dom_hubbub_parser_destroy(parser);
  135.                 fprintf(stderr, "Parsing errors occur\n");
  136.                 return NULL;
  137.         }
  138.  
  139.         while(readed == 1024) {
  140.                 readed = read(handle, buffer, 1024);
  141.                 error = dom_hubbub_parser_parse_chunk(parser, buffer, readed);
  142.                 if (error != DOM_HUBBUB_OK) {
  143.                         dom_hubbub_parser_destroy(parser);
  144.                         fprintf(stderr, "Parsing errors occur\n");
  145.                         return NULL;
  146.                 }
  147.         }
  148.  
  149.         error = dom_hubbub_parser_completed(parser);
  150.         if (error != DOM_HUBBUB_OK) {
  151.                 dom_hubbub_parser_destroy(parser);
  152.                 fprintf(stderr, "Parsing error when construct DOM\n");
  153.                 return NULL;
  154.         }
  155.  
  156.         dom_hubbub_parser_destroy(parser);
  157.  
  158.         return ret;
  159. }
  160.