static void
print_element (scew_element *element, unsigned int indent)
{
XML_Char const *contents = NULL;
scew_list *list = NULL;
if (element == NULL)
{
return;
}
/* Prints the starting element tag with its attributes. */
print_indent (indent);
scew_printf (_XT("<%s"), scew_element_name (element));
print_attributes (element);
scew_printf (_XT(">"));
contents = scew_element_contents (element);
if (contents == NULL)
{
scew_printf (_XT("\n"));
}
/**
* Call print_element function again for each child of the current
* element.
*/
list = scew_element_children (element);
while (list != NULL)
{
scew_element *child = scew_list_data (list);
print_element (child, indent + 1);
list = scew_list_next (list);
}
/* Prints element's content. */
if (contents != NULL)
{
scew_printf (_XT("%s"), contents);
}
else
{
print_indent (indent);
}
/* Prints the closing element tag. */
scew_printf (_XT("</%s>\n"), scew_element_name (element));
}
END_TEST
/* Miscellaneous */
START_TEST (test_misc)
{
enum { MAX_BUFFER_SIZE = 512 };
XML_Char buffer[MAX_BUFFER_SIZE] = _XT("");
scew_writer *writer = scew_writer_buffer_create (buffer, MAX_BUFFER_SIZE);
CHECK_PTR (writer, "Unable to create buffer writer");
CHECK_BOOL (scew_writer_end (writer), SCEW_FALSE,
"Writer should be at the beginning");
CHECK_BOOL (scew_writer_error (writer), SCEW_FALSE,
"Writer should have no error (nothing done yet)");
/* Close writer */
scew_writer_close (writer);
CHECK_BOOL (scew_writer_end (writer), SCEW_TRUE,
"Writer is closed, thus at the end");
scew_writer_free (writer);
}
/* set the preamble of current xml tree*/
void expat_tree::set_preamble( XML_String const preamble)
{
if( preamble == _XT(""))
return;
m_preamble = preamble;
}
/* set the encoding of current xml tree*/
void
expat_tree::set_encoding( XML_String const pencoding)
{
if( pencoding == _XT(""))
return;
m_encoding = pencoding;
}
void
expat_tree::set_version( XML_String const pvsersion)
{
if( pvsersion == _XT(""))
return;
m_version = pvsersion;
}
END_TEST
/* Write */
START_TEST (test_write)
{
enum { MAX_BUFFER_SIZE = 512 };
static XML_Char const *BUFFER = _XT("This is a buffer for the reader");
XML_Char write_buffer[MAX_BUFFER_SIZE] = _XT("");
scew_writer *writer = scew_writer_buffer_create (write_buffer,
scew_strlen (BUFFER) + 1);
CHECK_PTR (writer, "Unable to create buffer writer");
unsigned int i = 0;
while (i < scew_strlen (BUFFER))
{
CHECK_U_INT (scew_writer_write (writer, BUFFER + i, 1), 1,
"Invalid number of written bytes");
i += 1;
}
CHECK_STR (write_buffer, BUFFER, "Buffers do not match");
CHECK_BOOL (scew_writer_end (writer), SCEW_FALSE,
"Writer buffer is bigger than read buffer (no end yet)");
scew_writer_free (writer);
/* Try to writer full buffer */
writer = scew_writer_buffer_create (write_buffer, scew_strlen (BUFFER) + 1);
scew_writer_write (writer, write_buffer, scew_strlen (BUFFER) + 1);
CHECK_STR (write_buffer, BUFFER, "Buffers do not match");
CHECK_BOOL (scew_writer_end (writer), SCEW_FALSE,
"Writer buffer is bigger than read buffer (no end yet)");
scew_writer_free (writer);
}
void
attribute_print(scew_attribute const* attribute, FILE* out)
{
if (attribute == NULL)
{
return;
}
scew_fprintf(out, _XT(" %s=\"%s\""), attribute->name, attribute->value);
}
void
indent_print(FILE* out, unsigned int indent)
{
unsigned int i = 0;
for (i = 0; i < indent * indent_size; i++)
{
scew_fprintf(out, _XT(" "));
}
}
static void
print_indent (unsigned int indent)
{
/* Indentation size (in whitespaces). */
static unsigned int const INDENT_SIZE = 4;
if (indent > 0)
{
scew_printf (_XT("%*s"), indent * INDENT_SIZE, " ");
}
}
expat_element* expat_tree::add_root( XML_String const name)
{
if( name == _XT(""))
return NULL;
expat_element* root = new expat_element();
m_root = root;
root->set_element_name( name);
return m_root;
}
void
scew_strtrim (XML_Char *src)
{
size_t start = 0;
size_t end = 0;
size_t total = 0;
assert (src != NULL);
end = scew_strlen (src);
/* Strip trailing whitespace. */
while ((end > 0) && scew_isspace (src[end - 1]))
{
src[--end] = _XT('\0');
}
/* Strip leading whitespace. */
start = scew_strspn (src, _XT(" \n\r\t\v"));
total = end - start;
scew_memmove (src, &src[start], total);
src[total] = _XT('\0');
}
void
element_print(scew_element const* element, FILE* out, unsigned int indent)
{
unsigned int closed = 0;
XML_Char const* contents;
scew_element* child = NULL;
scew_attribute* attribute = NULL;
if (element == NULL)
{
return;
}
indent_print(out, indent);
scew_fprintf(out, _XT("<%s"), scew_element_name(element));
attribute = NULL;
while ((attribute = scew_attribute_next(element, attribute)) != NULL)
{
attribute_print(attribute, out);
}
contents = scew_element_contents(element);
if ((contents == NULL) && (element->child == NULL)
&& (element->parent != NULL))
{
scew_fprintf(out, _XT("/>\n"));
closed = 1;
}
else
{
scew_fprintf(out, _XT(">"));
if (contents == NULL)
{
scew_fprintf(out, _XT("\n"));
}
}
child = NULL;
while ((child = scew_element_next(element, child)) != NULL)
{
element_print(child, out, indent + 1);
}
if (contents != NULL)
{
scew_fprintf(out, _XT("%s"), contents);
}
else if (!closed)
{
indent_print(out, indent);
}
if (!closed)
{
scew_fprintf(out, _XT("</%s>\n"), scew_element_name(element));
}
}
scew_bool
scew_isempty (XML_Char const *src)
{
scew_bool empty = SCEW_TRUE;
XML_Char *p = (XML_Char *) src;
assert (src != NULL);
while (empty && (*p != _XT('\0')))
{
empty = (scew_isspace (*p) != 0);
p += 1;
}
return empty;
}
size_t
file_read_ (scew_reader *reader, XML_Char *buffer, size_t char_no)
{
size_t read_no = 0;
scew_reader_fp *fp_reader = NULL;
assert (reader != NULL);
assert (buffer != NULL);
fp_reader = scew_reader_data (reader);
read_no = fread (buffer, sizeof (XML_Char), char_no, fp_reader->file);
buffer[read_no] = _XT('\0');
return read_no;
}
static void
print_attributes (scew_element *element)
{
if (element != NULL)
{
/**
* Iterates through the element's attribute list, printing the
* pair name-value.
*/
scew_list *list = scew_element_attributes (element);
while (list != NULL)
{
scew_attribute *attribute = scew_list_data (list);
scew_printf (_XT(" %s=\"%s\""),
scew_attribute_name (attribute),
scew_attribute_value (attribute));
list = scew_list_next (list);
}
}
}
void
tree_print(scew_tree const* tree, FILE* out)
{
static XML_Char const* version = _XT("1.0");
#ifdef XML_UNICODE_WCHAR_T
static XML_Char const* encoding = _XT("UTF-16");
#else
static XML_Char const* encoding = _XT("UTF-8");
#endif /* XML_UNICODE_WCHAR_T */
scew_fprintf(
out,
_XT("<?xml version=\"%s\" encoding=\"%s\" standalone=\"%s\"?>\n\n"),
(tree->version == NULL ? version : tree->version),
(tree->encoding == NULL ? encoding : tree->encoding),
(tree->standalone > 0 ? _XT("yes") : _XT("no")));
element_print(tree->root, out, 0);
}
void
scew_parser_ignore_whitespaces (scew_parser *parser, scew_bool ignore)
{
assert (parser != NULL);
parser->ignore_whitespaces = ignore;
}
/* Private */
scew_parser*
parser_create_ (scew_bool namespace, XML_Char separator)
{
#ifdef XML_UNICODE_WCHAR_T
static XML_Char *encoding = _XT("UTF-16");
#else
static XML_Char *encoding = NULL;
#endif /* XML_UNICODE_WCHAR_T */
scew_parser *parser = calloc (1, sizeof (scew_parser));
if (NULL == parser)
{
scew_error_set_last_error_ (scew_error_no_memory);
return NULL;
}
/* Create Expat parser. */
parser->parser = namespace
? XML_ParserCreateNS (encoding, separator)
: XML_ParserCreate (encoding);
expat_tree::expat_tree(void)
{
m_encoding = _XT("utf-8");
m_version = _XT("2.0");
m_root = NULL;
}
/**
* @brief Save data from member variables to path-file.
* @param [in] path Path to project file.
* @param [out] sError Error string if error happened.
* @return TRUE if saving succeeded, FALSE if error happened.
*/
BOOL ProjectFile::Save(LPCTSTR path, String *sError)
{
BOOL success = TRUE;
scew_tree* tree = NULL;
scew_element* root = NULL;
scew_element* paths = NULL;
tree = scew_tree_create();
root = scew_tree_set_root(tree, Root_element_name);
if (root != NULL)
{
paths = AddPathsElement(root);
}
else
success = FALSE;
if (paths != NULL)
{
AddPathsContent(paths);
}
else
success = FALSE;
scew_tree_set_xml_encoding(tree, "UTF-8");
scew_writer *writer = NULL;
scew_printer *printer = NULL;
FILE * fp = _tfopen(path, _T("w"));
if (fp)
{
writer = scew_writer_fp_create(fp);
if (writer)
{
printer = scew_printer_create(writer);
if (!scew_printer_print_tree(printer, tree) ||
!scew_printf(_XT("\n")))
{
success = FALSE;
*sError = LoadResString(IDS_FILEWRITE_ERROR);
}
}
else
{
success = FALSE;
*sError = LoadResString(IDS_FILEWRITE_ERROR);
}
fclose(fp);
}
else
{
success = FALSE;
}
/* Frees the SCEW tree */
scew_tree_free(tree);
scew_writer_free(writer);
scew_printer_free(printer);
if (success == FALSE)
{
*sError = LoadResString(IDS_FILEWRITE_ERROR);
}
return success;
}
int
main (int argc, char *argv[])
{
scew_reader *reader = NULL;
scew_parser *parser = NULL;
scew_tree *tree = NULL;
scew_writer *writer = NULL;
scew_printer *printer = NULL;
#if defined(_MSC_VER) && defined(XML_UNICODE_WCHAR_T)
/* Change stdout to Unicode before writing anything. */
_setmode(_fileno(stdout), _O_U16TEXT);
#endif /* _MSC_VER && XML_UNICODE_WCHAR_T */
if (argc < 2)
{
scew_printf (_XT("Usage: scew_print file.xml\n"));
return EXIT_FAILURE;
}
/* Creates an SCEW parser. This is the first function to call. */
parser = scew_parser_create ();
scew_parser_ignore_whitespaces (parser, SCEW_TRUE);
/* Loads an XML file. */
reader = scew_reader_file_create (argv[1]);
if (reader == NULL)
{
scew_error code = scew_error_code ();
scew_printf (_XT("Unable to load file (error #%d: %s)\n"),
code, scew_error_string (code));
return EXIT_FAILURE;
}
tree = scew_parser_load (parser, reader);
if (tree == NULL)
{
scew_error code = scew_error_code ();
scew_printf (_XT("Unable to parse file (error #%d: %s)\n"),
code, scew_error_string (code));
if (code == scew_error_expat)
{
enum XML_Error expat_code = scew_error_expat_code (parser);
scew_printf (_XT("Expat error #%d (line %d, column %d): %s\n"),
expat_code,
scew_error_expat_line (parser),
scew_error_expat_column (parser),
scew_error_expat_string (expat_code));
}
/* Frees the SCEW parser and reader. */
scew_reader_free (reader);
scew_parser_free (parser);
return EXIT_FAILURE;
}
/* Prints full tree. */
scew_printf (_XT("\n*** Manual print:\n\n"));
print_element (scew_tree_root (tree), 0);
/* Prints full tree using SCEW writer. */
scew_printf (_XT("\n\n*** SCEW writer (stdout) print:\n\n"));
writer = scew_writer_fp_create (stdout);
printer = scew_printer_create (writer);
scew_printer_print_tree (printer, tree);
scew_printf (_XT("\n"));
/* Remember to free tree (scew_parser_free does not free it). */
scew_tree_free (tree);
/* Also free the printer and writer. */
scew_writer_free (writer);
scew_printer_free (printer);
/* Frees the SCEW parser and reader. */
scew_reader_free (reader);
scew_parser_free (parser);
return 0;
}
XML_Char*
scew_strescape (XML_Char const *src)
{
XML_Char *p = (XML_Char *) src;
XML_Char *escaped = NULL;
unsigned int len = 0;
assert (src != NULL);
/* We first need to calculate the size of the new escaped string. */
while (*p != _XT('\0'))
{
switch (*p)
{
case CHR_LT_:
len += LT_SIZE_;
break;
case CHR_GT_:
len += GT_SIZE_;
break;
case CHR_AMP_:
len += AMP_SIZE_;
break;
case CHR_APOS_:
len += APOS_SIZE_;
break;
case CHR_QUOT_:
len += QUOT_SIZE_;
break;
default:
len += 1;
break;
}
p += 1;
}
/* Allocate new string (if necessary). */
escaped = calloc (len + 1, sizeof (XML_Char));
/* Append characters to new string, escaping the needed ones. */
p = (XML_Char *) src;
len = 0;
while (*p != _XT('\0'))
{
switch (*p)
{
case CHR_LT_:
scew_memcpy (&escaped[len], XML_LT_, LT_SIZE_);
len += LT_SIZE_;
break;
case CHR_GT_:
scew_memcpy (&escaped[len], XML_GT_, GT_SIZE_);
len += GT_SIZE_;
break;
case CHR_AMP_:
scew_memcpy (&escaped[len], XML_AMP_, AMP_SIZE_);
len += AMP_SIZE_;
break;
case CHR_APOS_:
scew_memcpy (&escaped[len], XML_APOS_, APOS_SIZE_);
len += APOS_SIZE_;
break;
case CHR_QUOT_:
scew_memcpy (&escaped[len], XML_QUOT_, QUOT_SIZE_);
len += QUOT_SIZE_;
break;
default:
escaped[len] = *p;
len += 1;
break;
}
p += 1;
}
return escaped;
}
