SF.net SVN: geany-plugins:[1254] trunk/geany-plugins/pretty-printer/src
ctabin at users.sourceforge.net
ctabin at xxxxx
Mon Apr 19 14:06:13 UTC 2010
Revision: 1254
http://geany-plugins.svn.sourceforge.net/geany-plugins/?rev=1254&view=rev
Author: ctabin
Date: 2010-04-19 14:06:13 +0000 (Mon, 19 Apr 2010)
Log Message:
-----------
keybindings added in xml pretty-printer (thx Frank)
Modified Paths:
--------------
trunk/geany-plugins/pretty-printer/src/ConfigUI.c
trunk/geany-plugins/pretty-printer/src/PluginEntry.c
trunk/geany-plugins/pretty-printer/src/PluginEntry.h
trunk/geany-plugins/pretty-printer/src/PrettyPrinter.c
trunk/geany-plugins/pretty-printer/src/PrettyPrinter.h
Modified: trunk/geany-plugins/pretty-printer/src/ConfigUI.c
===================================================================
--- trunk/geany-plugins/pretty-printer/src/ConfigUI.c 2010-04-18 09:45:35 UTC (rev 1253)
+++ trunk/geany-plugins/pretty-printer/src/ConfigUI.c 2010-04-19 14:06:13 UTC (rev 1254)
@@ -23,60 +23,60 @@
GtkWidget* createPrettyPrinterConfigUI(GtkDialog* dialog)
{
- //default printing options
- if (prettyPrintingOptions == NULL) { prettyPrintingOptions = createDefaultPrettyPrintingOptions(); }
-
- //TODO create configuration widget
-
- return NULL;
+ //default printing options
+ if (prettyPrintingOptions == NULL) { prettyPrintingOptions = createDefaultPrettyPrintingOptions(); }
+
+ //TODO create configuration widget
+
+ return NULL;
}
void saveSettings()
{
- //TODO save settings into a file
+ //TODO save settings into a file
}
-/*
-GtkWidget* plugin_configure(GtkDialog * dialog)
+//Will never be used, just here for example
+/*GtkWidget* plugin_configure(GtkDialog * dialog)
{
- //default printing options
- if (prettyPrintingOptions == NULL) { prettyPrintingOptions = createDefaultPrettyPrintingOptions(); }
-
- GtkWidget* globalBox = gtk_hbox_new(TRUE, 4);
- GtkWidget* rightBox = gtk_vbox_new(FALSE, 6);
- GtkWidget* centerBox = gtk_vbox_new(FALSE, 6);
- GtkWidget* leftBox = gtk_vbox_new(FALSE, 6);
-
- GtkWidget* textLabel = gtk_label_new("Text nodes");
- GtkWidget* textOneLine = gtk_check_button_new_with_label("One line");
- GtkWidget* textInline = gtk_check_button_new_with_label("Inline");
-
- GtkWidget* cdataLabel = gtk_label_new("CDATA nodes");
- GtkWidget* cdataOneLine = gtk_check_button_new_with_label("One line");
- GtkWidget* cdataInline = gtk_check_button_new_with_label("Inline");
-
- GtkWidget* commentLabel = gtk_label_new("Comments");
- GtkWidget* commentOneLine = gtk_check_button_new_with_label("One line");
- GtkWidget* commentInline = gtk_check_button_new_with_label("Inline");
-
- gtk_box_pack_start(GTK_BOX(globalBox), leftBox, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(globalBox), centerBox, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(globalBox), rightBox, FALSE, FALSE, 3);
+ //default printing options
+ if (prettyPrintingOptions == NULL) { prettyPrintingOptions = createDefaultPrettyPrintingOptions(); }
+
+ GtkWidget* globalBox = gtk_hbox_new(TRUE, 4);
+ GtkWidget* rightBox = gtk_vbox_new(FALSE, 6);
+ GtkWidget* centerBox = gtk_vbox_new(FALSE, 6);
+ GtkWidget* leftBox = gtk_vbox_new(FALSE, 6);
+
+ GtkWidget* textLabel = gtk_label_new("Text nodes");
+ GtkWidget* textOneLine = gtk_check_button_new_with_label("One line");
+ GtkWidget* textInline = gtk_check_button_new_with_label("Inline");
+
+ GtkWidget* cdataLabel = gtk_label_new("CDATA nodes");
+ GtkWidget* cdataOneLine = gtk_check_button_new_with_label("One line");
+ GtkWidget* cdataInline = gtk_check_button_new_with_label("Inline");
+
+ GtkWidget* commentLabel = gtk_label_new("Comments");
+ GtkWidget* commentOneLine = gtk_check_button_new_with_label("One line");
+ GtkWidget* commentInline = gtk_check_button_new_with_label("Inline");
+
+ gtk_box_pack_start(GTK_BOX(globalBox), leftBox, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(globalBox), centerBox, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(globalBox), rightBox, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(leftBox), textLabel, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(centerBox), textOneLine, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(rightBox), textInline, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(leftBox), textLabel, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(centerBox), textOneLine, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(rightBox), textInline, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(leftBox), cdataLabel, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(centerBox), cdataOneLine, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(rightBox), cdataInline, FALSE, FALSE, 3);
-
- gtk_box_pack_start(GTK_BOX(leftBox), commentLabel, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(centerBox), commentOneLine, FALSE, FALSE, 3);
- gtk_box_pack_start(GTK_BOX(rightBox), commentInline, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(leftBox), cdataLabel, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(centerBox), cdataOneLine, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(rightBox), cdataInline, FALSE, FALSE, 3);
+
+ gtk_box_pack_start(GTK_BOX(leftBox), commentLabel, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(centerBox), commentOneLine, FALSE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(rightBox), commentInline, FALSE, FALSE, 3);
- gtk_widget_show_all(globalBox);
- return globalBox;
+ gtk_widget_show_all(globalBox);
+ return globalBox;
}
*/
Modified: trunk/geany-plugins/pretty-printer/src/PluginEntry.c
===================================================================
--- trunk/geany-plugins/pretty-printer/src/PluginEntry.c 2010-04-18 09:45:35 UTC (rev 1253)
+++ trunk/geany-plugins/pretty-printer/src/PluginEntry.c 2010-04-19 14:06:13 UTC (rev 1254)
@@ -25,9 +25,10 @@
//========================================== PLUGIN INFORMATION ==========================================================
-PLUGIN_VERSION_CHECK(130)
-PLUGIN_SET_INFO("XML PrettyPrinter", "Formats an XML and makes it readable for human.",
- "1.1", "Cédric Tabin - http://www.astorm.ch");
+PLUGIN_VERSION_CHECK(130);
+PLUGIN_SET_INFO("XML PrettyPrinter", "Formats an XML and makes it human-readable.",
+ "1.11", "Cédric Tabin - http://www.astorm.ch");
+PLUGIN_KEY_GROUP(prettyprinter, 1);
//========================================== DECLARATIONS ================================================================
@@ -39,7 +40,7 @@
//declaration of the functions
static void xml_format(GtkMenuItem *menuitem, gpointer gdata);
-//static void config_closed(GtkWidget* configWidget, gint response, gpointer data);
+static void kb_run_xml_pretty_print(G_GNUC_UNUSED guint key_id);
void plugin_init(GeanyData *data);
void plugin_cleanup(void);
@@ -57,6 +58,11 @@
gtk_widget_show(main_menu_item);
gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), main_menu_item);
+ //init keybindings
+ keybindings_set_item(plugin_key_group, 0, kb_run_xml_pretty_print,
+ 0, 0, "run_pretty_printer_xml", "Run the PrettyPrinter XML",
+ main_menu_item);
+
//add activation callback
g_signal_connect(main_menu_item, "activate", G_CALLBACK(xml_format), NULL);
}
@@ -67,76 +73,85 @@
gtk_widget_destroy(main_menu_item);
}
-//TODO uncomment when configuration widget ready
-/*GtkWidget* plugin_configure(GtkDialog * dialog)
-{
- //creates the configuration widget
- GtkWidget* widget = createPrettyPrinterConfigUI(dialog);
- g_signal_connect(dialog, "response", G_CALLBACK(config_closed), NULL);
- return widget;
-}*/
+#ifdef PLUGIN_XMLPP_GUI
+ static void config_closed(GtkWidget* configWidget, gint response, gpointer data);
+ GtkWidget* plugin_configure(GtkDialog * dialog)
+ {
+ //creates the configuration widget
+ GtkWidget* widget = createPrettyPrinterConfigUI(dialog);
+ g_signal_connect(dialog, "response", G_CALLBACK(config_closed), NULL);
+ return widget;
+ }
+
//========================================== LISTENERS ===================================================================
-//TODO uncomment when configuration widget ready
-/*void config_closed(GtkWidget* configWidget, gint response, gpointer gdata)
+ void config_closed(GtkWidget* configWidget, gint response, gpointer gdata)
+ {
+ //if the user clicked OK or APPLY, then save the settings
+ if (response == GTK_RESPONSE_OK ||
+ response == GTK_RESPONSE_APPLY)
+ {
+ saveSettings();
+ }
+ }
+#endif
+
+static void kb_run_xml_pretty_print(G_GNUC_UNUSED guint key_id)
{
- //if the user clicked OK or APPLY, then save the settings
- if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY)
- {
- saveSettings();
- }
-}*/
+ xml_format(NULL, NULL);
+}
-void xml_format(GtkMenuItem* menuitem, gpointer gdata)
+static void xml_format(GtkMenuItem* menuitem, gpointer gdata)
{
- //retrieves the current document
- GeanyDocument* doc = document_get_current();
- GeanyEditor* editor = doc->editor;
- ScintillaObject* sco = editor->sci;
+ //retrieves the current document
+ GeanyDocument* doc = document_get_current();
+ g_return_if_fail(doc != NULL);
+
+ GeanyEditor* editor = doc->editor;
+ ScintillaObject* sco = editor->sci;
- g_return_if_fail(doc != NULL);
+ //default printing options
+ if (prettyPrintingOptions == NULL) { prettyPrintingOptions = createDefaultPrettyPrintingOptions(); }
- //default printing options
- if (prettyPrintingOptions == NULL) { prettyPrintingOptions = createDefaultPrettyPrintingOptions(); }
+ //prepare the buffer that will contain the text
+ //from the scintilla object
+ int length = sci_get_length(sco)+1;
+ char* buffer = (char*)malloc(length*sizeof(char));
+ if (buffer == NULL) { exit(-1); } //malloc error
- //prepare the buffer that will contain the text
- //from the scintilla object
- int length = sci_get_length(sco)+1;
- char* buffer = (char*)malloc(length*sizeof(char));
- if (buffer == NULL) { exit(-1); } //malloc error
+ //retrieves the text
+ sci_get_text(sco, length, buffer);
- //retrieves the text
- sci_get_text(sco, length, buffer);
+ //checks if the data is an XML format
+ xmlDoc* xmlDoc = xmlParseDoc((unsigned char*)buffer);
- //checks if the data is an XML format
- xmlDoc* xmlDoc = xmlParseDoc((unsigned char*)buffer);
+ //this is not a valid xml => exit with an error message
+ if(xmlDoc == NULL)
+ {
+ dialogs_show_msgbox(GTK_MESSAGE_ERROR, "Unable to parse the content as XML.");
+ return;
+ }
- if(xmlDoc == NULL) //this is not a valid xml
- {
- dialogs_show_msgbox(GTK_MESSAGE_ERROR, "Unable to parse the content as XML.");
- return;
- }
+ //process pretty-printing
+ int result = processXMLPrettyPrinting(&buffer, &length, prettyPrintingOptions);
+ if (result != PRETTY_PRINTING_SUCCESS)
+ {
+ dialogs_show_msgbox(GTK_MESSAGE_ERROR, "Unable to process PrettyPrinting on the specified XML because some features are not supported.\n\nSee Help > Debug messages for more details...");
+ return;
+ }
- //process pretty-printing
- int result = processXMLPrettyPrinting(&buffer, &length, prettyPrintingOptions);
- if (result != 0)
- {
- dialogs_show_msgbox(GTK_MESSAGE_ERROR, "Unable to process PrettyPrinting on the specified XML because some features are not supported.\n\nSee Help > Debug messages for more details...");
- return;
- }
+ //updates the document
+ sci_set_text(sco, buffer);
- //updates the document
- sci_set_text(sco, buffer);
+ //set the line
+ int xOffset = scintilla_send_message(sco, SCI_GETXOFFSET, 0, 0);
+ scintilla_send_message(sco, SCI_LINESCROLL, -xOffset, 0); //TODO update with the right function-call for geany-0.19
- //set the line
- int xOffset = scintilla_send_message(sco, SCI_GETXOFFSET, 0, 0);
- scintilla_send_message(sco, SCI_LINESCROLL, -xOffset, 0); //TODO update with the right function-call for geany-0.19
+ //sets the type
+ GeanyFiletype* fileType = filetypes_index(GEANY_FILETYPES_XML);
+ document_set_filetype(doc, fileType);
- //sets the type
- GeanyFiletype* fileType = filetypes_index(GEANY_FILETYPES_XML);
- document_set_filetype(doc, fileType);
-
- //free all
- xmlFreeDoc(xmlDoc);
+ //free all
+ xmlFreeDoc(xmlDoc);
}
Modified: trunk/geany-plugins/pretty-printer/src/PluginEntry.h
===================================================================
--- trunk/geany-plugins/pretty-printer/src/PluginEntry.h 2010-04-18 09:45:35 UTC (rev 1253)
+++ trunk/geany-plugins/pretty-printer/src/PluginEntry.h 2010-04-19 14:06:13 UTC (rev 1254)
@@ -16,10 +16,12 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-//TODO is this header really useful ?
#ifndef PLUGIN_ENTRY_H
#define PLUGIN_ENTRY_H
+// This constants will be enabled once the preferences GUI will be finished :)
+//#define PLUGIN_XMLPP_GUI
+
//========================================== INCLUDES ==========================================================
#include <stdlib.h>
Modified: trunk/geany-plugins/pretty-printer/src/PrettyPrinter.c
===================================================================
--- trunk/geany-plugins/pretty-printer/src/PrettyPrinter.c 2010-04-18 09:45:35 UTC (rev 1253)
+++ trunk/geany-plugins/pretty-printer/src/PrettyPrinter.c 2010-04-19 14:06:13 UTC (rev 1254)
@@ -21,320 +21,320 @@
//======================= FUNCTIONS ====================================================================
//xml pretty printing functions
-static void putCharInBuffer(char charToAdd); //put a char into the new char buffer
-static void putCharsInBuffer(char* charsToAdd); //put the chars into the new char buffer
-static void putNextCharsInBuffer(int nbChars); //put the next nbChars of the input buffer into the new buffer
-static int readWhites(); //read the next whites into the input buffer
-static char readNextChar(); //read the next char into the input buffer;
-static char getNextChar(); //returns the next char but do not increase the input buffer index (use readNextChar for that)
-static char getPreviousInsertedChar(); //returns the last inserted char into the new buffer
-static gboolean isWhite(char c); //check if the specified char is a white
-static gboolean isLineBreak(char c); //check if the specified char is a new line
-static gboolean isQuote(char c); //check if the specified char is a quote (simple or double)
-static int putNewLine(); //put a new line into the new char buffer with the correct number of whites (indentation)
-static gboolean isInlineNodeAllowed(); //check if it is possible to have an inline node
-static void resetBackwardIndentation(gboolean resetLineBreak); //reset the indentation for the current depth (just reset the index in fact)
+static void putCharInBuffer(char charToAdd); //put a char into the new char buffer
+static void putCharsInBuffer(char* charsToAdd); //put the chars into the new char buffer
+static void putNextCharsInBuffer(int nbChars); //put the next nbChars of the input buffer into the new buffer
+static int readWhites(); //read the next whites into the input buffer
+static char readNextChar(); //read the next char into the input buffer;
+static char getNextChar(); //returns the next char but do not increase the input buffer index (use readNextChar for that)
+static char getPreviousInsertedChar(); //returns the last inserted char into the new buffer
+static gboolean isWhite(char c); //check if the specified char is a white
+static gboolean isLineBreak(char c); //check if the specified char is a new line
+static gboolean isQuote(char c); //check if the specified char is a quote (simple or double)
+static int putNewLine(); //put a new line into the new char buffer with the correct number of whites (indentation)
+static gboolean isInlineNodeAllowed(); //check if it is possible to have an inline node
+static void resetBackwardIndentation(gboolean resetLineBreak); //reset the indentation for the current depth (just reset the index in fact)
//specific parsing functions
-static int processElements(); //returns the number of elements processed
-static void processElementAttribute(); //process on attribute of a node
-static void processElementAttributes(); //process all the attributes of a node
-static void processHeader(); //process the header <?xml version="..." ?>
-static void processNode(); //process an XML node
-static void processTextNode(); //process a text node
-static void processComment(); //process a comment
-static void processCDATA(); //process a CDATA node
-static void processDoctype(); //process a DOCTYPE node
-static void processDoctypeElement(); //process a DOCTYPE ELEMENT node
+static int processElements(); //returns the number of elements processed
+static void processElementAttribute(); //process on attribute of a node
+static void processElementAttributes(); //process all the attributes of a node
+static void processHeader(); //process the header <?xml version="..." ?>
+static void processNode(); //process an XML node
+static void processTextNode(); //process a text node
+static void processComment(); //process a comment
+static void processCDATA(); //process a CDATA node
+static void processDoctype(); //process a DOCTYPE node
+static void processDoctypeElement(); //process a DOCTYPE ELEMENT node
//debug function
-static void printError(char *msg, ...); //just print a message like the printf method
-static void printDebugStatus(); //just print some variables into the console for debugging
+static void printError(char *msg, ...); //just print a message like the printf method
+static void printDebugStatus(); //just print some variables into the console for debugging
//============================================ PRIVATE PROPERTIES ======================================
//those are variables that are shared by the functions and
//shouldn't be altered.
-static int result; //result of the pretty printing
-static char* xmlPrettyPrinted; //new buffer for the formatted XML
-static int xmlPrettyPrintedLength; //buffer size
-static int xmlPrettyPrintedIndex; //buffer index (position of the next char to insert)
-static char* inputBuffer; //input buffer
-static int inputBufferLength; //input buffer size
-static int inputBufferIndex; //input buffer index (position of the next char to read into the input string)
-static int currentDepth; //current depth (for indentation)
-static char* currentNodeName; //current node name
-static gboolean appendIndentation; //if the indentation must be added (with a line break before)
-static gboolean lastNodeOpen; //defines if the last action was a not opening or not
-static PrettyPrintingOptions* options; //options of PrettyPrinting
+static int result; //result of the pretty printing
+static char* xmlPrettyPrinted; //new buffer for the formatted XML
+static int xmlPrettyPrintedLength; //buffer size
+static int xmlPrettyPrintedIndex; //buffer index (position of the next char to insert)
+static char* inputBuffer; //input buffer
+static int inputBufferLength; //input buffer size
+static int inputBufferIndex; //input buffer index (position of the next char to read into the input string)
+static int currentDepth; //current depth (for indentation)
+static char* currentNodeName; //current node name
+static gboolean appendIndentation; //if the indentation must be added (with a line break before)
+static gboolean lastNodeOpen; //defines if the last action was a not opening or not
+static PrettyPrintingOptions* options; //options of PrettyPrinting
//============================================ GENERAL FUNCTIONS =======================================
int processXMLPrettyPrinting(char** buffer, int* length, PrettyPrintingOptions* ppOptions)
{
- //empty buffer, nothing to process
- if (*length == 0) { return PRETTY_PRINTING_EMPTY_XML; }
- if (buffer == NULL || *buffer == NULL) { return PRETTY_PRINTING_EMPTY_XML; }
-
- //initialize the variables
- result = PRETTY_PRINTING_SUCCESS;
- gboolean freeOptions = FALSE;
- if (ppOptions == NULL) { ppOptions = createDefaultPrettyPrintingOptions(); freeOptions = TRUE; }
- options = ppOptions;
-
- currentNodeName = NULL;
- appendIndentation = FALSE;
- lastNodeOpen = FALSE;
- xmlPrettyPrintedIndex = 0;
- inputBufferIndex = 0;
- currentDepth = -1;
-
- inputBuffer = *buffer;
- inputBufferLength = *length;
-
- xmlPrettyPrintedLength = *length;
- xmlPrettyPrinted = (char*)malloc(sizeof(char)*(*length));
- if (xmlPrettyPrinted == NULL) { g_error("Allocation error"); }
-
- //go to the first char
- readWhites();
+ //empty buffer, nothing to process
+ if (*length == 0) { return PRETTY_PRINTING_EMPTY_XML; }
+ if (buffer == NULL || *buffer == NULL) { return PRETTY_PRINTING_EMPTY_XML; }
+
+ //initialize the variables
+ result = PRETTY_PRINTING_SUCCESS;
+ gboolean freeOptions = FALSE;
+ if (ppOptions == NULL) { ppOptions = createDefaultPrettyPrintingOptions(); freeOptions = TRUE; }
+ options = ppOptions;
+
+ currentNodeName = NULL;
+ appendIndentation = FALSE;
+ lastNodeOpen = FALSE;
+ xmlPrettyPrintedIndex = 0;
+ inputBufferIndex = 0;
+ currentDepth = -1;
+
+ inputBuffer = *buffer;
+ inputBufferLength = *length;
+
+ xmlPrettyPrintedLength = *length;
+ xmlPrettyPrinted = (char*)malloc(sizeof(char)*(*length));
+ if (xmlPrettyPrinted == NULL) { g_error("Allocation error"); }
+
+ //go to the first char
+ readWhites();
- //process the pretty-printing
- processElements();
-
- //close the buffer
- putCharInBuffer('\0');
-
- //adjust the final size
- xmlPrettyPrinted = realloc(xmlPrettyPrinted, xmlPrettyPrintedIndex);
- if (xmlPrettyPrinted == NULL) { g_error("Allocation error"); }
-
- //freeing the unused values
- if (freeOptions) { free(options); }
-
- //if success, then update the values
- if (result == PRETTY_PRINTING_SUCCESS)
- {
- free(*buffer);
- *buffer = xmlPrettyPrinted;
- *length = xmlPrettyPrintedIndex-2; //the '\0' is not in the length
- }
- //else clean the other values
- else
- {
- free(xmlPrettyPrinted);
- }
-
- //updating the pointers for the using into the caller function
- xmlPrettyPrinted = NULL; //avoid reference
- inputBuffer = NULL; //avoid reference
- currentNodeName = NULL; //avoid reference
- options = NULL; //avoid reference
-
- //and finally the result
- return result;
+ //process the pretty-printing
+ processElements();
+
+ //close the buffer
+ putCharInBuffer('\0');
+
+ //adjust the final size
+ xmlPrettyPrinted = realloc(xmlPrettyPrinted, xmlPrettyPrintedIndex);
+ if (xmlPrettyPrinted == NULL) { g_error("Allocation error"); }
+
+ //freeing the unused values
+ if (freeOptions) { free(options); }
+
+ //if success, then update the values
+ if (result == PRETTY_PRINTING_SUCCESS)
+ {
+ free(*buffer);
+ *buffer = xmlPrettyPrinted;
+ *length = xmlPrettyPrintedIndex-2; //the '\0' is not in the length
+ }
+ //else clean the other values
+ else
+ {
+ free(xmlPrettyPrinted);
+ }
+
+ //updating the pointers for the using into the caller function
+ xmlPrettyPrinted = NULL; //avoid reference
+ inputBuffer = NULL; //avoid reference
+ currentNodeName = NULL; //avoid reference
+ options = NULL; //avoid reference
+
+ //and finally the result
+ return result;
}
PrettyPrintingOptions* createDefaultPrettyPrintingOptions()
{
- PrettyPrintingOptions* options = (PrettyPrintingOptions*)malloc(sizeof(PrettyPrintingOptions));
- if (options == NULL)
- {
- g_error("Unable to allocate memory for PrettyPrintingOptions");
- return NULL;
- }
-
- options->newLineChars = "\r\n";
- options->indentChar = ' ';
- options->indentLength = 2;
- options->oneLineText = TRUE;
- options->inlineText = TRUE;
- options->oneLineComment = TRUE;
- options->inlineComment = TRUE;
- options->oneLineCdata = TRUE;
- options->inlineCdata = TRUE;
- options->emptyNodeStripping = TRUE;
- options->emptyNodeStrippingSpace = TRUE;
- options->forceEmptyNodeSplit = FALSE;
- options->trimLeadingWhites = TRUE;
- options->trimTrailingWhites = TRUE;
-
- return options;
+ PrettyPrintingOptions* options = (PrettyPrintingOptions*)malloc(sizeof(PrettyPrintingOptions));
+ if (options == NULL)
+ {
+ g_error("Unable to allocate memory for PrettyPrintingOptions");
+ return NULL;
+ }
+
+ options->newLineChars = "\r\n";
+ options->indentChar = ' ';
+ options->indentLength = 2;
+ options->oneLineText = TRUE;
+ options->inlineText = TRUE;
+ options->oneLineComment = TRUE;
+ options->inlineComment = TRUE;
+ options->oneLineCdata = TRUE;
+ options->inlineCdata = TRUE;
+ options->emptyNodeStripping = TRUE;
+ options->emptyNodeStrippingSpace = TRUE;
+ options->forceEmptyNodeSplit = FALSE;
+ options->trimLeadingWhites = TRUE;
+ options->trimTrailingWhites = TRUE;
+
+ return options;
}
void putNextCharsInBuffer(int nbChars)
{
- int i;
- for (i=0 ; i<nbChars ; ++i)
- {
- char c = readNextChar();
- putCharInBuffer(c);
- }
+ int i;
+ for (i=0 ; i<nbChars ; ++i)
+ {
+ char c = readNextChar();
+ putCharInBuffer(c);
+ }
}
void putCharInBuffer(char charToAdd)
{
- //check if the buffer is full and reallocation if needed
- if (xmlPrettyPrintedIndex >= xmlPrettyPrintedLength)
- {
- if (charToAdd == '\0') { ++xmlPrettyPrintedLength; }
- else { xmlPrettyPrintedLength += inputBufferLength; }
- xmlPrettyPrinted = (char*)realloc(xmlPrettyPrinted, xmlPrettyPrintedLength);
- if (xmlPrettyPrinted == NULL) { g_error("Allocation error"); }
- }
-
- //putting the char and increase the index for the next one
- xmlPrettyPrinted[xmlPrettyPrintedIndex] = charToAdd;
- ++xmlPrettyPrintedIndex;
+ //check if the buffer is full and reallocation if needed
+ if (xmlPrettyPrintedIndex >= xmlPrettyPrintedLength)
+ {
+ if (charToAdd == '\0') { ++xmlPrettyPrintedLength; }
+ else { xmlPrettyPrintedLength += inputBufferLength; }
+ xmlPrettyPrinted = (char*)realloc(xmlPrettyPrinted, xmlPrettyPrintedLength);
+ if (xmlPrettyPrinted == NULL) { g_error("Allocation error"); }
+ }
+
+ //putting the char and increase the index for the next one
+ xmlPrettyPrinted[xmlPrettyPrintedIndex] = charToAdd;
+ ++xmlPrettyPrintedIndex;
}
void putCharsInBuffer(char* charsToAdd)
{
- int index = 0;
- while (charsToAdd[index] != '\0')
- {
- putCharInBuffer(charsToAdd[index]);
- ++index;
- }
+ int index = 0;
+ while (charsToAdd[index] != '\0')
+ {
+ putCharInBuffer(charsToAdd[index]);
+ ++index;
+ }
}
char getPreviousInsertedChar()
{
- return xmlPrettyPrinted[xmlPrettyPrintedIndex-1];
+ return xmlPrettyPrinted[xmlPrettyPrintedIndex-1];
}
int putNewLine()
{
- putCharsInBuffer(options->newLineChars);
- int spaces = currentDepth*options->indentLength;
- int i;
- for(i=0 ; i<spaces ; ++i)
- {
- putCharInBuffer(options->indentChar);
- }
-
- return spaces;
+ putCharsInBuffer(options->newLineChars);
+ int spaces = currentDepth*options->indentLength;
+ int i;
+ for(i=0 ; i<spaces ; ++i)
+ {
+ putCharInBuffer(options->indentChar);
+ }
+
+ return spaces;
}
char getNextChar()
{
- return inputBuffer[inputBufferIndex];
+ return inputBuffer[inputBufferIndex];
}
char readNextChar()
-{
- return inputBuffer[inputBufferIndex++];
+{
+ return inputBuffer[inputBufferIndex++];
}
int readWhites()
{
- int counter = 0;
- while(isWhite(inputBuffer[inputBufferIndex]))
- {
- ++counter;
- ++inputBufferIndex;
- }
-
- return counter;
+ int counter = 0;
+ while(isWhite(inputBuffer[inputBufferIndex]))
+ {
+ ++counter;
+ ++inputBufferIndex;
+ }
+
+ return counter;
}
gboolean isQuote(char c)
{
- if (c == '\'') return TRUE;
- if (c == '"') return TRUE;
-
- return FALSE;
+ if (c == '\'') return TRUE;
+ if (c == '"') return TRUE;
+
+ return FALSE;
}
gboolean isWhite(char c)
{
- if (c == ' ') return TRUE;
- if (c == '\t') return TRUE;
- if (c == '\r') return TRUE;
- if (c == '\n') return TRUE;
+ if (c == ' ') return TRUE;
+ if (c == '\t') return TRUE;
+ if (c == '\r') return TRUE;
+ if (c == '\n') return TRUE;
- return FALSE;
+ return FALSE;
}
gboolean isLineBreak(char c)
{
- if (c == '\n') return TRUE;
- if (c == '\r') return TRUE;
-
- return FALSE;
+ if (c == '\n') return TRUE;
+ if (c == '\r') return TRUE;
+
+ return FALSE;
}
gboolean isInlineNodeAllowed()
{
- //the last action was not an opening => inline not allowed
- if (!lastNodeOpen) { return FALSE; }
-
- int firstChar = getNextChar(); //should be '<' or we are in a text node
- int secondChar = inputBuffer[inputBufferIndex+1]; //should be '!'
- int thirdChar = inputBuffer[inputBufferIndex+2]; //should be '-' or '['
-
- int index = inputBufferIndex+1;
- if (firstChar == '<')
- {
- //another node is being open ==> no inline !
- if (secondChar != '!') { return FALSE; }
-
- //okay we are in a comment node, so read until it is closed
-
- //select the closing char
- char closingComment = '-';
- if (thirdChar == '[') { closingComment = ']'; }
-
- //read until closing
- char oldChar = ' ';
- index += 3; //that by pass meanless chars
- gboolean loop = TRUE;
- while (loop)
- {
- char current = inputBuffer[index];
- if (current == closingComment && oldChar == closingComment) { loop = FALSE; } //end of comment
- oldChar = current;
- ++index;
- }
-
- //okay now avoid blanks
- // inputBuffer[index] is now '>'
- ++index;
- while (isWhite(inputBuffer[index])) { ++index; }
- }
- else
- {
- //this is a text node. Simply loop to the next '<'
- while (inputBuffer[index] != '<') { ++index; }
- }
-
- //check what do we have now
- char currentChar = inputBuffer[index];
- if (currentChar == '<')
- {
- //check if that is a closing node
- currentChar = inputBuffer[index+1];
- if (currentChar == '/')
- {
- //as we are in a correct XML (so far...), if the node is
- //being directly close, the inline is allowed !!!
- return TRUE;
- }
- }
-
- //inline not allowed...
- return FALSE;
+ //the last action was not an opening => inline not allowed
+ if (!lastNodeOpen) { return FALSE; }
+
+ int firstChar = getNextChar(); //should be '<' or we are in a text node
+ int secondChar = inputBuffer[inputBufferIndex+1]; //should be '!'
+ int thirdChar = inputBuffer[inputBufferIndex+2]; //should be '-' or '['
+
+ int index = inputBufferIndex+1;
+ if (firstChar == '<')
+ {
+ //another node is being open ==> no inline !
+ if (secondChar != '!') { return FALSE; }
+
+ //okay we are in a comment node, so read until it is closed
+
+ //select the closing char
+ char closingComment = '-';
+ if (thirdChar == '[') { closingComment = ']'; }
+
+ //read until closing
+ char oldChar = ' ';
+ index += 3; //that by pass meanless chars
+ gboolean loop = TRUE;
+ while (loop)
+ {
+ char current = inputBuffer[index];
+ if (current == closingComment && oldChar == closingComment) { loop = FALSE; } //end of comment
+ oldChar = current;
+ ++index;
+ }
+
+ //okay now avoid blanks
+ // inputBuffer[index] is now '>'
+ ++index;
+ while (isWhite(inputBuffer[index])) { ++index; }
+ }
+ else
+ {
+ //this is a text node. Simply loop to the next '<'
+ while (inputBuffer[index] != '<') { ++index; }
+ }
+
+ //check what do we have now
+ char currentChar = inputBuffer[index];
+ if (currentChar == '<')
+ {
+ //check if that is a closing node
+ currentChar = inputBuffer[index+1];
+ if (currentChar == '/')
+ {
+ //as we are in a correct XML (so far...), if the node is
+ //being directly close, the inline is allowed !!!
+ return TRUE;
+ }
+ }
+
+ //inline not allowed...
+ return FALSE;
}
void resetBackwardIndentation(gboolean resetLineBreak)
{
- xmlPrettyPrintedIndex -= (currentDepth*options->indentLength);
- if (resetLineBreak)
- {
- int len = strlen(options->newLineChars);
- xmlPrettyPrintedIndex -= len;
- }
+ xmlPrettyPrintedIndex -= (currentDepth*options->indentLength);
+ if (resetLineBreak)
+ {
+ int len = strlen(options->newLineChars);
+ xmlPrettyPrintedIndex -= len;
+ }
}
//#########################################################################################################################################
@@ -349,567 +349,567 @@
int processElements()
{
- int counter = 0;
- ++currentDepth;
- gboolean loop = TRUE;
- while (loop && result == PRETTY_PRINTING_SUCCESS)
- {
- //strip unused whites
- readWhites();
-
- char nextChar = getNextChar();
- if (nextChar == '\0') { return 0; } //no more data to read
-
- //put a new line with indentation
- if (appendIndentation) { putNewLine(); }
-
- //always append indentation (but need to store the state)
- gboolean indentBackward = appendIndentation;
- appendIndentation = TRUE;
-
- //okay what do we have now ?
- if (nextChar != '<')
- {
- //a simple text node
- processTextNode();
- ++counter;
- }
- else //some more check are needed
- {
- nextChar = inputBuffer[inputBufferIndex+1];
- if (nextChar == '!')
- {
- char oneMore = inputBuffer[inputBufferIndex+2];
- if (oneMore == '-') { processComment(); ++counter; } //a comment
- else if (oneMore == '[') { processCDATA(); ++counter; } //cdata
- else if (oneMore == 'D') { processDoctype(); ++counter; } //doctype <!DOCTYPE ... >
- else if (oneMore == 'E') { processDoctypeElement(); ++counter; } //doctype element <!ELEMENT ... >
- else
- {
- printError("processElements : Invalid char '%c' afer '<!'", oneMore);
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
- }
- }
- else if (nextChar == '/')
- {
- //close a node => stop the loop !!
- loop = FALSE;
- if (indentBackward)
- {
- //INDEX HACKING
- xmlPrettyPrintedIndex -= options->indentLength;
- }
- }
- else if (nextChar == '?')
- {
- //this is a header
- processHeader();
- }
- else
- {
- //a new node is open
- processNode();
- ++counter;
- }
- }
- }
-
- --currentDepth;
- return counter;
+ int counter = 0;
+ ++currentDepth;
+ gboolean loop = TRUE;
+ while (loop && result == PRETTY_PRINTING_SUCCESS)
+ {
+ //strip unused whites
+ readWhites();
+
+ char nextChar = getNextChar();
+ if (nextChar == '\0') { return 0; } //no more data to read
+
+ //put a new line with indentation
+ if (appendIndentation) { putNewLine(); }
+
+ //always append indentation (but need to store the state)
+ gboolean indentBackward = appendIndentation;
+ appendIndentation = TRUE;
+
+ //okay what do we have now ?
+ if (nextChar != '<')
+ {
+ //a simple text node
+ processTextNode();
+ ++counter;
+ }
+ else //some more check are needed
+ {
+ nextChar = inputBuffer[inputBufferIndex+1];
+ if (nextChar == '!')
+ {
+ char oneMore = inputBuffer[inputBufferIndex+2];
+ if (oneMore == '-') { processComment(); ++counter; } //a comment
+ else if (oneMore == '[') { processCDATA(); ++counter; } //cdata
+ else if (oneMore == 'D') { processDoctype(); ++counter; } //doctype <!DOCTYPE ... >
+ else if (oneMore == 'E') { processDoctypeElement(); ++counter; } //doctype element <!ELEMENT ... >
+ else
+ {
+ printError("processElements : Invalid char '%c' afer '<!'", oneMore);
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
+ }
+ }
+ else if (nextChar == '/')
+ {
+ //close a node => stop the loop !!
+ loop = FALSE;
+ if (indentBackward)
+ {
+ //INDEX HACKING
+ xmlPrettyPrintedIndex -= options->indentLength;
+ }
+ }
+ else if (nextChar == '?')
+ {
+ //this is a header
+ processHeader();
+ }
+ else
+ {
+ //a new node is open
+ processNode();
+ ++counter;
+ }
+ }
+ }
+
+ --currentDepth;
+ return counter;
}
void processElementAttribute()
{
- //process the attribute name
- char nextChar = readNextChar();
- while (nextChar != '=')
- {
- putCharInBuffer(nextChar);
- nextChar = readNextChar();
- }
-
- putCharInBuffer(nextChar); //that's the '='
-
- //read the simple quote or double quote and put it into the buffer
- char quote = readNextChar();
- putCharInBuffer(quote);
-
- //process until the last quote
- char value = readNextChar();
- while(value != quote)
- {
- putCharInBuffer(value);
- value = readNextChar();
- }
-
- //simply add the last quote
- putCharInBuffer(quote);
+ //process the attribute name
+ char nextChar = readNextChar();
+ while (nextChar != '=')
+ {
+ putCharInBuffer(nextChar);
+ nextChar = readNextChar();
+ }
+
+ putCharInBuffer(nextChar); //that's the '='
+
+ //read the simple quote or double quote and put it into the buffer
+ char quote = readNextChar();
+ putCharInBuffer(quote);
+
+ //process until the last quote
+ char value = readNextChar();
+ while(value != quote)
+ {
+ putCharInBuffer(value);
+ value = readNextChar();
+ }
+
+ //simply add the last quote
+ putCharInBuffer(quote);
}
void processElementAttributes()
{
- char current = getNextChar(); //should not be a white
- if (isWhite(current))
- {
- printError("processElementAttributes : first char shouldn't be a white");
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
- return;
- }
-
- gboolean loop = TRUE;
- while (loop)
- {
- readWhites(); //strip the whites
-
- char next = getNextChar(); //don't read the last char (processed afterwards)
- if (next == '/') { loop = FALSE; } /* end of node */
- else if (next == '>') { loop = FALSE; } /* end of tag */
- else if (next == '?') { loop = FALSE; } /* end of header */
- else
- {
- putCharInBuffer(' '); //put only one space to separate attributes
- processElementAttribute();
- }
- }
+ char current = getNextChar(); //should not be a white
+ if (isWhite(current))
+ {
+ printError("processElementAttributes : first char shouldn't be a white");
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
+ return;
+ }
+
+ gboolean loop = TRUE;
+ while (loop)
+ {
+ readWhites(); //strip the whites
+
+ char next = getNextChar(); //don't read the last char (processed afterwards)
+ if (next == '/') { loop = FALSE; } /* end of node */
+ else if (next == '>') { loop = FALSE; } /* end of tag */
+ else if (next == '?') { loop = FALSE; } /* end of header */
+ else
+ {
+ putCharInBuffer(' '); //put only one space to separate attributes
+ processElementAttribute();
+ }
+ }
}
void processHeader()
{
- int firstChar = inputBuffer[inputBufferIndex]; //should be '<'
- int secondChar = inputBuffer[inputBufferIndex+1]; //must be '?'
-
- if (firstChar != '<')
- {
- /* what ?????? invalid xml !!! */
- printError("processHeader : first char should be '<' (not '%c')", firstChar);
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR; return;
- }
-
- if (secondChar == '?')
- {
- //puts the '<' and '?' chars into the new buffer
- putNextCharsInBuffer(2);
-
- while(!isWhite(getNextChar())) { putNextCharsInBuffer(1); }
-
- readWhites();
- processElementAttributes();
-
- //puts the '?' and '>' chars into the new buffer
- putNextCharsInBuffer(2);
- }
+ int firstChar = inputBuffer[inputBufferIndex]; //should be '<'
+ int secondChar = inputBuffer[inputBufferIndex+1]; //must be '?'
+
+ if (firstChar != '<')
+ {
+ /* what ?????? invalid xml !!! */
+ printError("processHeader : first char should be '<' (not '%c')", firstChar);
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR; return;
+ }
+
+ if (secondChar == '?')
+ {
+ //puts the '<' and '?' chars into the new buffer
+ putNextCharsInBuffer(2);
+
+ while(!isWhite(getNextChar())) { putNextCharsInBuffer(1); }
+
+ readWhites();
+ processElementAttributes();
+
+ //puts the '?' and '>' chars into the new buffer
+ putNextCharsInBuffer(2);
+ }
}
void processNode()
{
- int opening = readNextChar();
- if (opening != '<')
- {
- printError("processNode : The first char should be '<' (not '%c')", opening);
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
- return;
- }
-
- putCharInBuffer(opening);
-
- //read the node name
- int nodeNameLength = 0;
- while (!isWhite(getNextChar()) &&
- getNextChar() != '>' && //end of the tag
- getNextChar() != '/') //tag is being closed
- {
- putNextCharsInBuffer(1);
- ++nodeNameLength;
- }
+ int opening = readNextChar();
+ if (opening != '<')
+ {
+ printError("processNode : The first char should be '<' (not '%c')", opening);
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
+ return;
+ }
+
+ putCharInBuffer(opening);
+
+ //read the node name
+ int nodeNameLength = 0;
+ while (!isWhite(getNextChar()) &&
+ getNextChar() != '>' && //end of the tag
+ getNextChar() != '/') //tag is being closed
+ {
+ putNextCharsInBuffer(1);
+ ++nodeNameLength;
+ }
- //store the name
- char* nodeName = (char*)malloc(sizeof(char)*nodeNameLength+1);
- if (nodeName == NULL) { g_error("Allocation error"); }
- nodeName[nodeNameLength] = '\0';
- int i;
- for (i=0 ; i<nodeNameLength ; ++i)
- {
- int index = xmlPrettyPrintedIndex-nodeNameLength+i;
- nodeName[i] = xmlPrettyPrinted[index];
- }
-
- currentNodeName = nodeName; //set the name for using in other methods
- lastNodeOpen = TRUE;
+ //store the name
+ char* nodeName = (char*)malloc(sizeof(char)*nodeNameLength+1);
+ if (nodeName == NULL) { g_error("Allocation error"); }
+ nodeName[nodeNameLength] = '\0';
+ int i;
+ for (i=0 ; i<nodeNameLength ; ++i)
+ {
+ int index = xmlPrettyPrintedIndex-nodeNameLength+i;
+ nodeName[i] = xmlPrettyPrinted[index];
+ }
+
+ currentNodeName = nodeName; //set the name for using in other methods
+ lastNodeOpen = TRUE;
- //process the attributes
- readWhites();
- processElementAttributes();
-
- //process the end of the tag
- int subElementsProcessed = 0;
- char nextChar = getNextChar(); //should be either '/' or '>'
- if (nextChar == '/') //the node is being closed immediatly
- {
- //closing node directly
- if (options->emptyNodeStripping || !options->forceEmptyNodeSplit)
- {
- if (options->emptyNodeStrippingSpace) { putCharInBuffer(' '); }
- putNextCharsInBuffer(2);
- }
- //split the closing nodes
- else
- {
- readNextChar(); //removing '/'
- readNextChar(); //removing '>'
-
- putCharInBuffer('>');
- if (!options->inlineText)
- {
- //no inline text => new line !
- putNewLine();
- }
-
- putCharsInBuffer("</");
- putCharsInBuffer(currentNodeName);
- putCharInBuffer('>');
- }
-
- lastNodeOpen=FALSE;
- return;
- }
- else if (nextChar == '>')
- {
- //the tag is just closed (maybe some content)
- putNextCharsInBuffer(1);
- subElementsProcessed = processElements(TRUE);
- }
- else
- {
- printError("processNode : Invalid character '%c'", nextChar);
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
- return;
- }
-
- //if the code reaches this area, then the processElements has been called and we must
- //close the opening tag
- char closeChar = getNextChar();
- if (closeChar != '<')
- {
- printError("processNode : Invalid character '%c' for closing tag (should be '<')", closeChar);
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
- return;
- }
-
- do
- {
- closeChar = readNextChar();
- putCharInBuffer(closeChar);
- }
- while(closeChar != '>');
-
- //there is no elements
- if (subElementsProcessed == 0)
- {
- //the node will be stripped
- if (options->emptyNodeStripping)
- {
- //because we have '<nodeName ...></nodeName>'
- xmlPrettyPrintedIndex -= nodeNameLength+4;
- resetBackwardIndentation(TRUE);
-
- if (options->emptyNodeStrippingSpace) { putCharInBuffer(' '); }
- putCharsInBuffer("/>");
- }
- //the closing tag will be put on the same line
- else if (options->inlineText)
- {
- //correct the index because we have '</nodeName>'
- xmlPrettyPrintedIndex -= nodeNameLength+3;
- resetBackwardIndentation(TRUE);
-
- //rewrite the node name
- putCharsInBuffer("</");
- putCharsInBuffer(currentNodeName);
- putCharInBuffer('>');
- }
- }
-
- //the node is closed
- lastNodeOpen = FALSE;
-
- //freeeeeeee !!!
- free(nodeName);
- nodeName = NULL;
- currentNodeName = NULL;
+ //process the attributes
+ readWhites();
+ processElementAttributes();
+
+ //process the end of the tag
+ int subElementsProcessed = 0;
+ char nextChar = getNextChar(); //should be either '/' or '>'
+ if (nextChar == '/') //the node is being closed immediatly
+ {
+ //closing node directly
+ if (options->emptyNodeStripping || !options->forceEmptyNodeSplit)
+ {
+ if (options->emptyNodeStrippingSpace) { putCharInBuffer(' '); }
+ putNextCharsInBuffer(2);
+ }
+ //split the closing nodes
+ else
+ {
+ readNextChar(); //removing '/'
+ readNextChar(); //removing '>'
+
+ putCharInBuffer('>');
+ if (!options->inlineText)
+ {
+ //no inline text => new line !
+ putNewLine();
+ }
+
+ putCharsInBuffer("</");
+ putCharsInBuffer(currentNodeName);
+ putCharInBuffer('>');
+ }
+
+ lastNodeOpen=FALSE;
+ return;
+ }
+ else if (nextChar == '>')
+ {
+ //the tag is just closed (maybe some content)
+ putNextCharsInBuffer(1);
+ subElementsProcessed = processElements(TRUE);
+ }
+ else
+ {
+ printError("processNode : Invalid character '%c'", nextChar);
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
+ return;
+ }
+
+ //if the code reaches this area, then the processElements has been called and we must
+ //close the opening tag
+ char closeChar = getNextChar();
+ if (closeChar != '<')
+ {
+ printError("processNode : Invalid character '%c' for closing tag (should be '<')", closeChar);
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
+ return;
+ }
+
+ do
+ {
+ closeChar = readNextChar();
+ putCharInBuffer(closeChar);
+ }
+ while(closeChar != '>');
+
+ //there is no elements
+ if (subElementsProcessed == 0)
+ {
+ //the node will be stripped
+ if (options->emptyNodeStripping)
+ {
+ //because we have '<nodeName ...></nodeName>'
+ xmlPrettyPrintedIndex -= nodeNameLength+4;
+ resetBackwardIndentation(TRUE);
+
+ if (options->emptyNodeStrippingSpace) { putCharInBuffer(' '); }
+ putCharsInBuffer("/>");
+ }
+ //the closing tag will be put on the same line
+ else if (options->inlineText)
+ {
+ //correct the index because we have '</nodeName>'
+ xmlPrettyPrintedIndex -= nodeNameLength+3;
+ resetBackwardIndentation(TRUE);
+
+ //rewrite the node name
+ putCharsInBuffer("</");
+ putCharsInBuffer(currentNodeName);
+ putCharInBuffer('>');
+ }
+ }
+
+ //the node is closed
+ lastNodeOpen = FALSE;
+
+ //freeeeeeee !!!
+ free(nodeName);
+ nodeName = NULL;
+ currentNodeName = NULL;
}
void processComment()
{
- gboolean inlineAllowed = FALSE;
- if (options->inlineComment) { inlineAllowed = isInlineNodeAllowed(); }
- if (inlineAllowed) { resetBackwardIndentation(TRUE); }
-
- putNextCharsInBuffer(4); //add the chars '<!--'
-
- char oldChar = '-';
- gboolean loop = TRUE;
- while (loop)
- {
- char nextChar = readNextChar();
- if (oldChar == '-' && nextChar == '-') //comment is being closed
- {
- loop = FALSE;
- }
-
- if (!isLineBreak(nextChar)) //the comment simply continues
- {
- putCharInBuffer(nextChar);
- oldChar = nextChar;
- }
- else if (!options->oneLineComment) //oh ! there is a line break
- {
- readWhites(); //strip the whites and new line
- putNewLine(); //put a new indentation line
- oldChar = ' '; //and update the last char
-
- //TODO manage relative spacing
- }
- else //the comments must be inlined
- {
- readWhites(); //strip the whites and add a space if needed
- if (getPreviousInsertedChar() != ' ')
- {
- putCharInBuffer(' ');
- }
- }
- }
-
- char lastChar = readNextChar(); //should be '>'
- if (lastChar != '>')
- {
- printError("processComment : last char must be '>' (not '%c')", lastChar);
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
- return;
- }
- putCharInBuffer(lastChar);
-
- if (inlineAllowed) { appendIndentation = FALSE; }
-
- //there vas no node open
- lastNodeOpen = FALSE;
+ gboolean inlineAllowed = FALSE;
+ if (options->inlineComment) { inlineAllowed = isInlineNodeAllowed(); }
+ if (inlineAllowed) { resetBackwardIndentation(TRUE); }
+
+ putNextCharsInBuffer(4); //add the chars '<!--'
+
+ char oldChar = '-';
+ gboolean loop = TRUE;
+ while (loop)
+ {
+ char nextChar = readNextChar();
+ if (oldChar == '-' && nextChar == '-') //comment is being closed
+ {
+ loop = FALSE;
+ }
+
+ if (!isLineBreak(nextChar)) //the comment simply continues
+ {
+ putCharInBuffer(nextChar);
+ oldChar = nextChar;
+ }
+ else if (!options->oneLineComment) //oh ! there is a line break
+ {
+ readWhites(); //strip the whites and new line
+ putNewLine(); //put a new indentation line
+ oldChar = ' '; //and update the last char
+
+ //TODO manage relative spacing
+ }
+ else //the comments must be inlined
+ {
+ readWhites(); //strip the whites and add a space if needed
+ if (getPreviousInsertedChar() != ' ')
+ {
+ putCharInBuffer(' ');
+ }
+ }
+ }
+
+ char lastChar = readNextChar(); //should be '>'
+ if (lastChar != '>')
+ {
+ printError("processComment : last char must be '>' (not '%c')", lastChar);
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
+ return;
+ }
+ putCharInBuffer(lastChar);
+
+ if (inlineAllowed) { appendIndentation = FALSE; }
+
+ //there vas no node open
+ lastNodeOpen = FALSE;
}
void processTextNode()
{
- //checks if inline is allowed
- gboolean inlineTextAllowed = FALSE;
- if (options->inlineText) { inlineTextAllowed = isInlineNodeAllowed(); }
- if (inlineTextAllowed) { resetBackwardIndentation(TRUE); } //remove previous indentation
-
- //the leading whites are automatically stripped. So we re-add it
- if (!options->trimLeadingWhites)
- {
- int backwardIndex = inputBufferIndex-1;
- while (inputBuffer[backwardIndex] == ' ' ||
- inputBuffer[backwardIndex] == '\t')
- {
- --backwardIndex; //backward rolling
- }
-
- //now the input[backwardIndex] IS NOT a white. So we go to
- //the next char...
- ++backwardIndex;
-
- //and then re-add the whites
- while (inputBuffer[backwardIndex] == ' ' ||
- inputBuffer[backwardIndex] == '\t')
- {
- putCharInBuffer(inputBuffer[backwardIndex]);
- ++backwardIndex;
- }
- }
-
- //process the text into the node
- while(getNextChar() != '<')
- {
- char nextChar = readNextChar();
- if (isLineBreak(nextChar))
- {
- readWhites();
- if (options->oneLineText)
- {
- //as we can put text on one line, remove the line break
- //and replace it by a space but only if the previous
- //char wasn't a space
- if (getPreviousInsertedChar() != ' ')
- {
- putCharInBuffer(' ');
- }
- }
- else
- {
- //put a new line only if the closing tag is not reached
- if (getNextChar() != '<')
- {
- putNewLine();
- }
- }
- }
- else
- {
- putCharInBuffer(nextChar);
- }
- }
-
- //strip the trailing whites
- if (options->trimTrailingWhites)
- {
- while(getPreviousInsertedChar() == ' ' ||
- getPreviousInsertedChar() == '\t')
- {
- --xmlPrettyPrintedIndex;
- }
- }
-
- //remove the indentation for the closing tag
- if (inlineTextAllowed) { appendIndentation = FALSE; }
-
- //there vas no node open
- lastNodeOpen = FALSE;
+ //checks if inline is allowed
+ gboolean inlineTextAllowed = FALSE;
+ if (options->inlineText) { inlineTextAllowed = isInlineNodeAllowed(); }
+ if (inlineTextAllowed) { resetBackwardIndentation(TRUE); } //remove previous indentation
+
+ //the leading whites are automatically stripped. So we re-add it
+ if (!options->trimLeadingWhites)
+ {
+ int backwardIndex = inputBufferIndex-1;
+ while (inputBuffer[backwardIndex] == ' ' ||
+ inputBuffer[backwardIndex] == '\t')
+ {
+ --backwardIndex; //backward rolling
+ }
+
+ //now the input[backwardIndex] IS NOT a white. So we go to
+ //the next char...
+ ++backwardIndex;
+
+ //and then re-add the whites
+ while (inputBuffer[backwardIndex] == ' ' ||
+ inputBuffer[backwardIndex] == '\t')
+ {
+ putCharInBuffer(inputBuffer[backwardIndex]);
+ ++backwardIndex;
+ }
+ }
+
+ //process the text into the node
+ while(getNextChar() != '<')
+ {
+ char nextChar = readNextChar();
+ if (isLineBreak(nextChar))
+ {
+ readWhites();
+ if (options->oneLineText)
+ {
+ //as we can put text on one line, remove the line break
+ //and replace it by a space but only if the previous
+ //char wasn't a space
+ if (getPreviousInsertedChar() != ' ')
+ {
+ putCharInBuffer(' ');
+ }
+ }
+ else
+ {
+ //put a new line only if the closing tag is not reached
+ if (getNextChar() != '<')
+ {
+ putNewLine();
+ }
+ }
+ }
+ else
+ {
+ putCharInBuffer(nextChar);
+ }
+ }
+
+ //strip the trailing whites
+ if (options->trimTrailingWhites)
+ {
+ while(getPreviousInsertedChar() == ' ' ||
+ getPreviousInsertedChar() == '\t')
+ {
+ --xmlPrettyPrintedIndex;
+ }
+ }
+
+ //remove the indentation for the closing tag
+ if (inlineTextAllowed) { appendIndentation = FALSE; }
+
+ //there vas no node open
+ lastNodeOpen = FALSE;
}
void processCDATA()
{
- gboolean inlineAllowed = FALSE;
- if (options->inlineCdata) { inlineAllowed = isInlineNodeAllowed(); }
- if (inlineAllowed) { resetBackwardIndentation(TRUE); }
-
- putNextCharsInBuffer(9); //putting the '<![CDATA[' into the buffer
-
- gboolean loop = TRUE;
- char oldChar = '[';
- while(loop)
- {
- char nextChar = readNextChar();
- char nextChar2 = getNextChar();
- if (oldChar == ']' && nextChar == ']' && nextChar2 == '>') { loop = FALSE; } //end of cdata
-
- if (!isLineBreak(nextChar)) //the cdata simply continues
- {
- putCharInBuffer(nextChar);
- oldChar = nextChar;
- }
- else if (!options->oneLineCdata)
- {
- readWhites(); //strip the whites and new line
- putNewLine(); //put a new indentation line
- oldChar = ' '; //and update the last char
-
- //TODO manage relative spacing
- }
- else //cdata are inlined
- {
- readWhites(); //strip the whites and add a space if necessary
- if(getPreviousInsertedChar() != ' ') { putCharInBuffer(' '); }
- }
- }
-
- char lastChar = readNextChar(); //should be '>'
- if (lastChar != '>')
- {
- printError("processCDATA : last char must be '>' (not '%c')", lastChar);
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
- return;
- }
-
- putCharInBuffer(lastChar);
-
- if (inlineAllowed) { appendIndentation = FALSE; }
-
- //there vas no node open
- lastNodeOpen = FALSE;
+ gboolean inlineAllowed = FALSE;
+ if (options->inlineCdata) { inlineAllowed = isInlineNodeAllowed(); }
+ if (inlineAllowed) { resetBackwardIndentation(TRUE); }
+
+ putNextCharsInBuffer(9); //putting the '<![CDATA[' into the buffer
+
+ gboolean loop = TRUE;
+ char oldChar = '[';
+ while(loop)
+ {
+ char nextChar = readNextChar();
+ char nextChar2 = getNextChar();
+ if (oldChar == ']' && nextChar == ']' && nextChar2 == '>') { loop = FALSE; } //end of cdata
+
+ if (!isLineBreak(nextChar)) //the cdata simply continues
+ {
+ putCharInBuffer(nextChar);
+ oldChar = nextChar;
+ }
+ else if (!options->oneLineCdata)
+ {
+ readWhites(); //strip the whites and new line
+ putNewLine(); //put a new indentation line
+ oldChar = ' '; //and update the last char
+
+ //TODO manage relative spacing
+ }
+ else //cdata are inlined
+ {
+ readWhites(); //strip the whites and add a space if necessary
+ if(getPreviousInsertedChar() != ' ') { putCharInBuffer(' '); }
+ }
+ }
+
+ char lastChar = readNextChar(); //should be '>'
+ if (lastChar != '>')
+ {
+ printError("processCDATA : last char must be '>' (not '%c')", lastChar);
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
+ return;
+ }
+
+ putCharInBuffer(lastChar);
+
+ if (inlineAllowed) { appendIndentation = FALSE; }
+
+ //there vas no node open
+ lastNodeOpen = FALSE;
}
-void processDoctype()
+void processDoctype()
{
- putNextCharsInBuffer(9); //put the '<!DOCTYPE' into the buffer
-
- gboolean loop = TRUE;
- while(loop)
- {
- readWhites();
- putCharInBuffer(' '); //only one space for the attributes
-
- int nextChar = readNextChar();
- while(!isWhite(nextChar) &&
- !isQuote(nextChar) && //begins a quoted text
- nextChar != '=' && //begins an attribute
- nextChar != '>' && //end of doctype
- nextChar != '[') //inner <!ELEMENT> types
- {
- putCharInBuffer(nextChar);
- nextChar = readNextChar();
- }
-
- if (isWhite(nextChar)) {} //do nothing, just let the next loop do the job
- else if (isQuote(nextChar) || nextChar == '=')
- {
- if (nextChar == '=')
- {
- putCharInBuffer(nextChar);
- nextChar = readNextChar(); //now we should have a quote
-
- if (!isQuote(nextChar))
- {
- printError("processDoctype : the next char should be a quote (not '%c')", nextChar);
- result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
- return;
- }
- }
-
- //simply process the content
- char quote = nextChar;
- do
- {
- putCharInBuffer(nextChar);
- nextChar = readNextChar();
- }
- while (nextChar != quote);
- putCharInBuffer(nextChar); //now the last char is the last quote
- }
- else if (nextChar == '>') //end of doctype
- {
- putCharInBuffer(nextChar);
- loop = FALSE;
- }
- else //the char is a '[' => not supported yet
- {
- printError("DOCTYPE inner ELEMENT is currently not supported by PrettyPrinter\n");
- result = PRETTY_PRINTING_NOT_SUPPORTED_YET;
- loop = FALSE;
- }
- }
+ putNextCharsInBuffer(9); //put the '<!DOCTYPE' into the buffer
+
+ gboolean loop = TRUE;
+ while(loop)
+ {
+ readWhites();
+ putCharInBuffer(' '); //only one space for the attributes
+
+ int nextChar = readNextChar();
+ while(!isWhite(nextChar) &&
+ !isQuote(nextChar) && //begins a quoted text
+ nextChar != '=' && //begins an attribute
+ nextChar != '>' && //end of doctype
+ nextChar != '[') //inner <!ELEMENT> types
+ {
+ putCharInBuffer(nextChar);
+ nextChar = readNextChar();
+ }
+
+ if (isWhite(nextChar)) {} //do nothing, just let the next loop do the job
+ else if (isQuote(nextChar) || nextChar == '=')
+ {
+ if (nextChar == '=')
+ {
+ putCharInBuffer(nextChar);
+ nextChar = readNextChar(); //now we should have a quote
+
+ if (!isQuote(nextChar))
+ {
+ printError("processDoctype : the next char should be a quote (not '%c')", nextChar);
+ result = PRETTY_PRINTING_INVALID_CHAR_ERROR;
+ return;
+ }
+ }
+
+ //simply process the content
+ char quote = nextChar;
+ do
+ {
+ putCharInBuffer(nextChar);
+ nextChar = readNextChar();
+ }
+ while (nextChar != quote);
+ putCharInBuffer(nextChar); //now the last char is the last quote
+ }
+ else if (nextChar == '>') //end of doctype
+ {
+ putCharInBuffer(nextChar);
+ loop = FALSE;
+ }
+ else //the char is a '[' => not supported yet
+ {
+ printError("DOCTYPE inner ELEMENT is currently not supported by PrettyPrinter\n");
+ result = PRETTY_PRINTING_NOT_SUPPORTED_YET;
+ loop = FALSE;
+ }
+ }
}
void processDoctypeElement()
{
- printError("ELEMENT is currently not supported by PrettyPrinter\n");
- result = PRETTY_PRINTING_NOT_SUPPORTED_YET;
+ printError("ELEMENT is currently not supported by PrettyPrinter\n");
+ result = PRETTY_PRINTING_NOT_SUPPORTED_YET;
}
void printError(char *msg, ...)
{
- va_list va;
- va_start(va, msg);
- g_warning(msg, va);
- va_end(va);
-
- //TODO also do a fprintf on stderr ?
-
- printDebugStatus();
+ va_list va;
+ va_start(va, msg);
+ g_warning(msg, va);
+ va_end(va);
+
+ //TODO also do a fprintf on stderr ?
+
+ printDebugStatus();
}
void printDebugStatus()
{
- g_debug("\n===== INPUT =====\n%s\n=================\ninputLength = %d\ninputIndex = %d\noutputLength = %d\noutputIndex = %d\n",
- inputBuffer,
- inputBufferLength,
- inputBufferIndex,
- xmlPrettyPrintedLength,
- xmlPrettyPrintedIndex);
+ g_debug("\n===== INPUT =====\n%s\n=================\ninputLength = %d\ninputIndex = %d\noutputLength = %d\noutputIndex = %d\n",
+ inputBuffer,
+ inputBufferLength,
+ inputBufferIndex,
+ xmlPrettyPrintedLength,
+ xmlPrettyPrintedIndex);
}
Modified: trunk/geany-plugins/pretty-printer/src/PrettyPrinter.h
===================================================================
--- trunk/geany-plugins/pretty-printer/src/PrettyPrinter.h 2010-04-18 09:45:35 UTC (rev 1253)
+++ trunk/geany-plugins/pretty-printer/src/PrettyPrinter.h 2010-04-19 14:06:13 UTC (rev 1254)
@@ -43,25 +43,26 @@
*/
typedef struct
{
- char* newLineChars; //char used to generate a new line (generally \r\n)
- char indentChar; //char used for indentation
- int indentLength; //number of char to use for indentation (by default 2 spaces)
- gboolean oneLineText; //text is put on one line
- gboolean inlineText; //if possible text are inline (no return after the opening node and before closing node)
- gboolean oneLineComment; //comments are put on one line
- gboolean inlineComment; //if possible comments are inline (no return after the opening node and before closing node)
- gboolean oneLineCdata; //cdata are put on one line
- gboolean inlineCdata; //if possible cdata are inline (no return after the opening node and before closing node)
- gboolean emptyNodeStripping; //the empty nodes such <node></node> are set to <node/>
- gboolean emptyNodeStrippingSpace; //put a space before the '/>' when a node is stripped
- gboolean forceEmptyNodeSplit; //force an empty node to be splitted : <node /> becomes <node></node> (only if emptyNodeStripping = false)
- gboolean trimLeadingWhites; //trim the leading whites in a text node
- gboolean trimTrailingWhites; //trim the trailing whites in a text node
-} PrettyPrintingOptions;
+ char* newLineChars; //char used to generate a new line (generally \r\n)
+ char indentChar; //char used for indentation
+ int indentLength; //number of char to use for indentation (by default 2 spaces)
+ gboolean oneLineText; //text is put on one line
+ gboolean inlineText; //if possible text are inline (no return after the opening node and before closing node)
+ gboolean oneLineComment; //comments are put on one line
+ gboolean inlineComment; //if possible comments are inline (no return after the opening node and before closing node)
+ gboolean oneLineCdata; //cdata are put on one line
+ gboolean inlineCdata; //if possible cdata are inline (no return after the opening node and before closing node)
+ gboolean emptyNodeStripping; //the empty nodes such <node></node> are set to <node/>
+ gboolean emptyNodeStrippingSpace; //put a space before the '/>' when a node is stripped
+ gboolean forceEmptyNodeSplit; //force an empty node to be splitted : <node /> becomes <node></node> (only if emptyNodeStripping = false)
+ gboolean trimLeadingWhites; //trim the leading whites in a text node
+ gboolean trimTrailingWhites; //trim the trailing whites in a text node
+}
+PrettyPrintingOptions;
//========================================== FUNCTIONS =========================================================
-int processXMLPrettyPrinting(char** xml, int* length, PrettyPrintingOptions* ppOptions); //process the pretty-printing on a valid xml string (no check done !!!). The ppOptions ARE NOT FREE-ED after processing. The method returns 0 if the pretty-printing has been done.
-PrettyPrintingOptions* createDefaultPrettyPrintingOptions(); //creates a default PrettyPrintingOptions object
+int processXMLPrettyPrinting(char** xml, int* length, PrettyPrintingOptions* ppOptions); //process the pretty-printing on a valid xml string (no check done !!!). The ppOptions ARE NOT FREE-ED after processing. The method returns 0 if the pretty-printing has been done.
+PrettyPrintingOptions* createDefaultPrettyPrintingOptions(); //creates a default PrettyPrintingOptions object
#endif
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Plugins-Commits
mailing list