[geany/geany-plugins] b38189: PrettyPrinter: Don't use C++-style comments

Colomban Wendling git-noreply at xxxxx
Sun Jul 8 21:10:53 UTC 2012


Branch:      refs/heads/1.22_release
Author:      Colomban Wendling <ban at herbesfolles.org>
Committer:   Colomban Wendling <ban at herbesfolles.org>
Date:        Sun, 08 Jul 2012 21:10:53
Commit:      b38189f5380a84cc2ae437254dd78ec4dae839ba
             https://github.com/geany/geany-plugins/commit/b38189f5380a84cc2ae437254dd78ec4dae839ba

Log Message:
-----------
PrettyPrinter: Don't use C++-style comments


Modified Paths:
--------------
    pretty-printer/src/ConfigUI.c
    pretty-printer/src/ConfigUI.h
    pretty-printer/src/PluginEntry.c
    pretty-printer/src/PluginEntry.h
    pretty-printer/src/PrettyPrinter.c
    pretty-printer/src/PrettyPrinter.h

Modified: pretty-printer/src/ConfigUI.c
16 files changed, 8 insertions(+), 8 deletions(-)
===================================================================
@@ -18,15 +18,15 @@
 
 #include "ConfigUI.h"
 
-//======================= FUNCTIONS ====================================================================
+/*======================= FUNCTIONS ====================================================================*/
 
-//static GtkWidget* createTwoOptionsBox(const char* label, const char* checkBox1, const char* checkBox2, gboolean cb1Active, gboolean cb2Active, GtkWidget** option1, GtkWidget** option2);
+/*static GtkWidget* createTwoOptionsBox(const char* label, const char* checkBox1, const char* checkBox2, gboolean cb1Active, gboolean cb2Active, GtkWidget** option1, GtkWidget** option2);*/
 static GtkWidget* createThreeOptionsBox(const char* label, const char* checkBox1, const char* checkBox2, const char* checkBox3, gboolean cb1Active, gboolean cb2Active, gboolean cb3Active, GtkWidget** option1, GtkWidget** option2, GtkWidget** option3);
 static GtkWidget* createEmptyTextOptions(gboolean emptyNodeStripping, gboolean emptyNodeStrippingSpace, gboolean forceEmptyNodeSplit);
 static GtkWidget* createIndentationOptions(char indentation, int count);
 static GtkWidget* createLineReturnOptions(const char* lineReturn);
 
-//============================================ PRIVATE PROPERTIES ======================================
+/*============================================ PRIVATE PROPERTIES ======================================*/
 
 static GtkWidget* commentOneLine;
 static GtkWidget* commentInline;
@@ -44,15 +44,15 @@
 static GtkWidget* indentationCount;
 static GtkWidget* lineBreak;
 
-//============================================= PUBLIC FUNCTIONS ========================================
+/*============================================= PUBLIC FUNCTIONS ========================================*/
 
-//redeclaration of extern variable
+/* redeclaration of extern variable */
 PrettyPrintingOptions* prettyPrintingOptions;
 
-//Will never be used, just here for example
+/* Will never be used, just here for example */
 GtkWidget* createPrettyPrinterConfigUI(GtkDialog * dialog)     
 {
-    //default printing options
+    /* default printing options */
     if (prettyPrintingOptions == NULL) { prettyPrintingOptions = createDefaultPrettyPrintingOptions(); }
     PrettyPrintingOptions* ppo = prettyPrintingOptions;
 
@@ -111,7 +111,7 @@ void saveSettings(void)
     else ppo->newLineChars = "\r\n";
 }
 
-//============================================= PRIVATE FUNCTIONS =======================================
+/*============================================= PRIVATE FUNCTIONS =======================================*/
 
 /*GtkWidget* createTwoOptionsBox(const char* label, 
                                const char* checkBox1, 


Modified: pretty-printer/src/ConfigUI.h
6 files changed, 3 insertions(+), 3 deletions(-)
===================================================================
@@ -19,7 +19,7 @@
 #ifndef PP_CONFIG_UI_H
 #define PP_CONFIG_UI_H
 
-//========================================== INCLUDES =========================================================
+/*========================================== INCLUDES =========================================================*/
 
 #include <gtk/gtk.h>
 
@@ -30,11 +30,11 @@
 
 #include "PrettyPrinter.h"
 
-//========================================== VARIABLES ========================================================
+/*========================================== VARIABLES ========================================================*/
 
 extern PrettyPrintingOptions* prettyPrintingOptions;
 
-//========================================== FUNCTIONS ========================================================
+/*========================================== FUNCTIONS ========================================================*/
 
 GtkWidget* createPrettyPrinterConfigUI(GtkDialog* dialog);
 void saveSettings(void);


Modified: pretty-printer/src/PluginEntry.c
56 files changed, 28 insertions(+), 28 deletions(-)
===================================================================
@@ -28,7 +28,7 @@
 GeanyData*             geany_data;
 GeanyFunctions*        geany_functions;
 
-//========================================== PLUGIN INFORMATION ==========================================================
+/*========================================== PLUGIN INFORMATION ==========================================================*/
 
 PLUGIN_VERSION_CHECK(130)
 PLUGIN_SET_TRANSLATABLE_INFO(
@@ -39,11 +39,11 @@
     PRETTY_PRINTER_VERSION, "Cédric Tabin - http://www.astorm.ch")
 PLUGIN_KEY_GROUP(prettyprinter, 1)
 
-//========================================== DECLARATIONS ================================================================
+/*========================================== DECLARATIONS ================================================================*/
 
-static GtkWidget* main_menu_item = NULL; //the main menu of the plugin
+static GtkWidget* main_menu_item = NULL; /*the main menu of the plugin*/
 
-//declaration of the functions
+/* declaration of the functions */
 static void xml_format(GtkMenuItem *menuitem, gpointer gdata);
 static void kb_run_xml_pretty_print(G_GNUC_UNUSED guint key_id);
 static void config_closed(GtkWidget* configWidget, gint response, gpointer data);
@@ -52,51 +52,51 @@
 void plugin_cleanup(void);
 GtkWidget* plugin_configure(GtkDialog * dialog);
 
-//========================================== FUNCTIONS ===================================================================
+/*========================================== FUNCTIONS ===================================================================*/
 
 void plugin_init(GeanyData *data)
 {
-    //initializes the libxml2
+    /* initializes the libxml2 */
     LIBXML_TEST_VERSION
 
-    //mutilanguage support
+    /* mutilanguage support */
     main_locale_init(LOCALEDIR, GETTEXT_PACKAGE);
 
-    //put the menu into the Tools
+    /* put the menu into the Tools */
     main_menu_item = gtk_menu_item_new_with_mnemonic(_("PrettyPrinter XML"));
     ui_add_document_sensitive(main_menu_item);
 
     gtk_widget_show(main_menu_item);
     gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), main_menu_item);
 
-    //init keybindings
+    /* 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
+    /* add activation callback */
     g_signal_connect(main_menu_item, "activate", G_CALLBACK(xml_format), NULL);
 }
 
 void plugin_cleanup(void)
 {
-    //destroys the plugin
+    /* destroys the plugin */
     gtk_widget_destroy(main_menu_item);
 }
 
 GtkWidget* plugin_configure(GtkDialog * dialog)
 {
-    //creates the configuration widget
+    /* creates the configuration widget */
     GtkWidget* widget = createPrettyPrinterConfigUI(dialog);
     g_signal_connect(dialog, "response", G_CALLBACK(config_closed), NULL);
     return widget;
 }
 
-//========================================== LISTENERS ===================================================================
+/*========================================== LISTENERS ===================================================================*/
 
 void config_closed(GtkWidget* configWidget, gint response, gpointer gdata)
 {
-    //if the user clicked OK or APPLY, then save the settings
+    /* if the user clicked OK or APPLY, then save the settings */
     if (response == GTK_RESPONSE_OK ||
         response == GTK_RESPONSE_APPLY)
     {
@@ -111,39 +111,39 @@ void kb_run_xml_pretty_print(G_GNUC_UNUSED guint key_id)
 
 void xml_format(GtkMenuItem* menuitem, gpointer gdata)
 {
-    //retrieves the current document
+    /* retrieves the current document */
     GeanyDocument* doc = document_get_current();
     g_return_if_fail(doc != NULL);
 
     GeanyEditor* editor = doc->editor;
     ScintillaObject* sco = editor->sci;
 
-    //default printing options
+    /* default printing options */
     if (prettyPrintingOptions == NULL) { prettyPrintingOptions = createDefaultPrettyPrintingOptions(); }
 
-    //prepare the buffer that will contain the text
-    //from the scintilla object
+    /* 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
+    if (buffer == NULL) { exit(-1); } /* malloc error */
 
-    //retrieves the text
+    /* retrieves the text */
     sci_get_text(sco, length, buffer);
 
-    //checks if the data is an XML format
+    /* checks if the data is an XML format */
     xmlDoc* parsedDocument = xmlParseDoc((unsigned char*)buffer);
 
-    //this is not a valid xml => exit with an error message
+    /* this is not a valid xml => exit with an error message */
     if(parsedDocument == NULL)
     {
         dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Unable to parse the content as XML."));
         return;
     }
 
-    //free all
+    /* free all */
     xmlFreeDoc(parsedDocument);
 
-    //process pretty-printing
+    /* process pretty-printing */
     int result = processXMLPrettyPrinting(&buffer, &length, prettyPrintingOptions);
     if (result != PRETTY_PRINTING_SUCCESS)
     {
@@ -151,14 +151,14 @@ void xml_format(GtkMenuItem* menuitem, gpointer gdata)
         return;
     }
 
-    //updates the document
+    /* updates the document */
     sci_set_text(sco, buffer);
 
-    //set the line
+    /* 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
+    scintilla_send_message(sco, SCI_LINESCROLL, -xOffset, 0); /* TODO update with the right function-call for geany-0.19 */
 
-    //sets the type
+    /* sets the type */
     GeanyFiletype* fileType = filetypes_index(GEANY_FILETYPES_XML);
     document_set_filetype(doc, fileType);
 }


Modified: pretty-printer/src/PluginEntry.h
6 files changed, 3 insertions(+), 3 deletions(-)
===================================================================
@@ -19,7 +19,7 @@
 #ifndef PLUGIN_ENTRY_H
 #define PLUGIN_ENTRY_H
 
-//========================================== INCLUDES ==========================================================
+/*========================================== INCLUDES ==========================================================*/
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -34,8 +34,8 @@
 #include "PrettyPrinter.h"
 #include "ConfigUI.h"
 
-//========================================== PROPERTIES ========================================================
+/*========================================== PROPERTIES ========================================================*/
 
-//========================================== FUNCTIONS =========================================================
+/*========================================== FUNCTIONS =========================================================*/
 
 #endif


Modified: pretty-printer/src/PrettyPrinter.c
458 files changed, 229 insertions(+), 229 deletions(-)
===================================================================
@@ -18,63 +18,63 @@
 
 #include "PrettyPrinter.h"
 
-//======================= FUNCTIONS ====================================================================
+/*======================= FUNCTIONS ====================================================================*/
 
-//error reporting functions
-static void PP_ERROR(const char* fmt, ...) G_GNUC_PRINTF(1,2);  //prints an error message
+/* error reporting functions */
+static void PP_ERROR(const char* fmt, ...) G_GNUC_PRINTF(1,2);  /* prints an error message */
 
-//xml pretty printing functions
-static void putCharInBuffer(char charToAdd);                     //put a char into the new char buffer
-static void putCharsInBuffer(const 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(bool considerLineBreakAsWhite);            //read the next whites into the input buffer
-static char readNextChar(void);                                  //read the next char into the input buffer;
-static char getNextChar(void);                                   //returns the next char but do not increase the input buffer index (use readNextChar for that)
-static char getPreviousInsertedChar(void);                       //returns the last inserted char into the new buffer
-static bool isWhite(char c);                                     //check if the specified char is a white
-static bool isSpace(char c);                                     //check if the specified char is a space
-static bool isLineBreak(char c);                                 //check if the specified char is a new line
-static bool isQuote(char c);                                     //check if the specified char is a quote (simple or double)
-static int putNewLine(void);                                     //put a new line into the new char buffer with the correct number of whites (indentation)
-static bool isInlineNodeAllowed(void);                           //check if it is possible to have an inline node
-static bool isOnSingleLine(int skip, char stop1, char stop2);    //check if the current node data is on one line (for inlining)
-static void resetBackwardIndentation(bool resetLineBreak);       //reset the indentation for the current depth (just reset the index in fact)
+/* xml pretty printing functions */
+static void putCharInBuffer(char charToAdd);                     /* put a char into the new char buffer */
+static void putCharsInBuffer(const 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(bool considerLineBreakAsWhite);            /* read the next whites into the input buffer */
+static char readNextChar(void);                                  /* read the next char into the input buffer; */
+static char getNextChar(void);                                   /* returns the next char but do not increase the input buffer index (use readNextChar for that) */
+static char getPreviousInsertedChar(void);                       /* returns the last inserted char into the new buffer */
+static bool isWhite(char c);                                     /* check if the specified char is a white */
+static bool isSpace(char c);                                     /* check if the specified char is a space */
+static bool isLineBreak(char c);                                 /* check if the specified char is a new line */
+static bool isQuote(char c);                                     /* check if the specified char is a quote (simple or double) */
+static int putNewLine(void);                                     /* put a new line into the new char buffer with the correct number of whites (indentation) */
+static bool isInlineNodeAllowed(void);                           /* check if it is possible to have an inline node */
+static bool isOnSingleLine(int skip, char stop1, char stop2);    /* check if the current node data is on one line (for inlining) */
+static void resetBackwardIndentation(bool resetLineBreak);       /* reset the indentation for the current depth (just reset the index in fact) */
                                                              
-//specific parsing functions                                 
-static int processElements(void);                                //returns the number of elements processed
-static void processElementAttribute(void);                       //process on attribute of a node
-static void processElementAttributes(void);                      //process all the attributes of a node
-static void processHeader(void);                                 //process the header <?xml version="..." ?>
-static void processNode(void);                                   //process an XML node
-static void processTextNode(void);                               //process a text node
-static void processComment(void);                                //process a comment
-static void processCDATA(void);                                  //process a CDATA node
-static void processDoctype(void);                                //process a DOCTYPE node
-static void processDoctypeElement(void);                         //process a DOCTYPE ELEMENT node
+/* specific parsing functions */
+static int processElements(void);                                /* returns the number of elements processed */
+static void processElementAttribute(void);                       /* process on attribute of a node */
+static void processElementAttributes(void);                      /* process all the attributes of a node */
+static void processHeader(void);                                 /* process the header <?xml version="..." ?> */
+static void processNode(void);                                   /* process an XML node */
+static void processTextNode(void);                               /* process a text node */
+static void processComment(void);                                /* process a comment */
+static void processCDATA(void);                                  /* process a CDATA node */
+static void processDoctype(void);                                /* process a DOCTYPE node */
+static void processDoctypeElement(void);                         /* process a DOCTYPE ELEMENT node */
 
-//debug function                                             
-static void printError(const char *msg, ...) G_GNUC_PRINTF(1,2); //just print a message like the printf method
-static void printDebugStatus(void);                              //just print some variables into the console for debugging
+/* debug function */
+static void printError(const char *msg, ...) G_GNUC_PRINTF(1,2); /* just print a message like the printf method */
+static void printDebugStatus(void);                              /* just print some variables into the console for debugging */
 
-//============================================ PRIVATE PROPERTIES ======================================
+/*============================================ PRIVATE PROPERTIES ======================================*/
 
-//those are variables that are shared by the functions and
-//shouldn't be altered.
+/* 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 bool appendIndentation;                                //if the indentation must be added (with a line break before)
-static bool 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 bool appendIndentation;                                /* if the indentation must be added (with a line break before) */
+static bool lastNodeOpen;                                     /* defines if the last action was a not opening or not */
+static PrettyPrintingOptions* options;                            /* options of PrettyPrinting */
 
-//============================================ GENERAL FUNCTIONS =======================================
+/*============================================ GENERAL FUNCTIONS =======================================*/
 
 static void PP_ERROR(const char* fmt, ...)
 {
@@ -88,11 +88,11 @@ static void PP_ERROR(const char* fmt, ...)
 
 int processXMLPrettyPrinting(char** buffer, int* length, PrettyPrintingOptions* ppOptions)
 {
-    //empty buffer, nothing to process
+    /* 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
+    /* initialize the variables */
     result = PRETTY_PRINTING_SUCCESS;
     bool freeOptions = FALSE;
     if (ppOptions == NULL) 
@@ -116,43 +116,43 @@ int processXMLPrettyPrinting(char** buffer, int* length, PrettyPrintingOptions*
     xmlPrettyPrinted = (char*)malloc(sizeof(char)*(*length));
     if (xmlPrettyPrinted == NULL) { PP_ERROR("Allocation error (initialisation)"); return PRETTY_PRINTING_SYSTEM_ERROR; }
     
-    //go to the first char
+    /* go to the first char */
     readWhites(TRUE);
 
-    //process the pretty-printing
+    /* process the pretty-printing */
     processElements();
     
-    //close the buffer
+    /* close the buffer */
     putCharInBuffer('\0');
     
-    //adjust the final size
+    /* adjust the final size */
     char* reallocated = (char*)realloc(xmlPrettyPrinted, xmlPrettyPrintedIndex); 
     if (reallocated == NULL) { PP_ERROR("Allocation error (reallocation size is %d)", xmlPrettyPrintedIndex); return PRETTY_PRINTING_SYSTEM_ERROR; }
     xmlPrettyPrinted = reallocated;
     
-    //freeing the unused values
+    /* freeing the unused values */
     if (freeOptions) { free(options); }
     
-    //if success, then update the values
+    /* 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
+        *length = xmlPrettyPrintedIndex-2; /* the '\0' is not in the length */
     }
-    //else clean the other values
+    /* 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
+    /* 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
+    /* and finally the result */
     return result;
 }
 
@@ -198,7 +198,7 @@ void putNextCharsInBuffer(int nbChars)
 
 void putCharInBuffer(char charToAdd)
 {
-    //check if the buffer is full and reallocation if needed
+    /* check if the buffer is full and reallocation if needed */
     if (xmlPrettyPrintedIndex >= xmlPrettyPrintedLength)
     {
         if (charToAdd == '\0') { ++xmlPrettyPrintedLength; }
@@ -208,7 +208,7 @@ void putCharInBuffer(char charToAdd)
         xmlPrettyPrinted = reallocated;
     }
     
-    //putting the char and increase the index for the next one
+    /* putting the char and increase the index for the next one */
     xmlPrettyPrinted[xmlPrettyPrintedIndex] = charToAdd;
     ++xmlPrettyPrintedIndex;
 }
@@ -291,70 +291,70 @@ bool isLineBreak(char c)
 
 bool isInlineNodeAllowed(void)
 {
-    //the last action was not an opening => inline not allowed
+    /* 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 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 '[' */
     
-    //loop through the content up to the next opening/closing node
-    int currentIndex = inputBufferIndex+1;
+    /* loop through the content up to the next opening/closing node */
+    currentIndex = inputBufferIndex+1;
     if (firstChar == '<')
     {
-        //another node is being open ==> no inline !
+        /* another node is being open ==> no inline ! */
         if (secondChar != '!') { return FALSE; }
         
-        //okay we are in a comment/cdata node, so read until it is closed
+        /* okay we are in a comment/cdata node, so read until it is closed */
         
-        //select the closing char
+        /* select the closing char */
         char closingComment = '-';
         if (thirdChar == '[') { closingComment = ']'; }
         
-        //read until closing
+        /* read until closing */
         char oldChar = ' ';
-        currentIndex += 3; //that bypass meanless chars
+        currentIndex += 3; /* that bypass meanless chars */
         bool loop = TRUE;
         while (loop)
         {
             char current = inputBuffer[currentIndex];
-            if (current == closingComment && oldChar == closingComment) { loop = FALSE; } //end of comment/cdata
+            if (current == closingComment && oldChar == closingComment) { loop = FALSE; } /* end of comment/cdata */
             oldChar = current;
             ++currentIndex;
         }
         
-        //okay now avoid blanks
-        // inputBuffer[index] is now '>'
+        /* okay now avoid blanks */
+        /*  inputBuffer[index] is now '>' */
         ++currentIndex;
         while (isWhite(inputBuffer[currentIndex])) { ++currentIndex; }
     }
     else
     {
-        //this is a text node. Simply loop to the next '<'
+        /* this is a text node. Simply loop to the next '<' */
         while (inputBuffer[currentIndex] != '<') { ++currentIndex; }
     }
     
-    //check what do we have now
-    char currentChar = inputBuffer[currentIndex];
+    /* check what do we have now */
+    currentChar = inputBuffer[currentIndex];
     if (currentChar == '<')
     {
-        //check if that is a closing node
+        /* check if that is a closing node */
         currentChar = inputBuffer[currentIndex+1];
         if (currentChar == '/')
         {
-            //as we are in a correct XML (so far...), if the node is 
-            //being directly closed, the inline is allowed !!!
+            /* as we are in a correct XML (so far...), if the node is  */
+            /* being directly closed, the inline is allowed !!! */
             return TRUE;
         }
     }
     
-    //inline not allowed...
+    /* inline not allowed... */
     return FALSE;
 }
 
 bool isOnSingleLine(int skip, char stop1, char stop2)
 {
-    int currentIndex = inputBufferIndex+skip; //skip the n first chars (in comment <!--)
+    int currentIndex = inputBufferIndex+skip; /* skip the n first chars (in comment <!--) */
     bool onSingleLine = TRUE;
     
     char oldChar = inputBuffer[currentIndex];
@@ -377,7 +377,7 @@ bool isOnSingleLine(int skip, char stop1, char stop2)
         {
             while(oldChar != stop1 && currentChar != stop2)
             {
-                //okay there is something else => this is not on one line
+                /* okay there is something else => this is not on one line */
                 if (!isWhite(oldChar)) return FALSE;
               
                 ++currentIndex;
@@ -385,8 +385,8 @@ bool isOnSingleLine(int skip, char stop1, char stop2)
                 currentChar = inputBuffer[currentIndex+1];
             }
             
-            //the end of the node has been reached with only whites. Then
-            //the node can be considered being one single line
+            /* the end of the node has been reached with only whites. Then
+             * the node can be considered being one single line */
             return TRUE;
         }
     }
@@ -404,15 +404,15 @@ void resetBackwardIndentation(bool resetLineBreak)
     }
 }
 
-//#########################################################################################################################################
-//-----------------------------------------------------------------------------------------------------------------------------------------
+/*#########################################################################################################################################*/
+/*-----------------------------------------------------------------------------------------------------------------------------------------*/
                                                                                                 
-//-----------------------------------------------------------------------------------------------------------------------------------------
-//=============================================================== NODE FUNCTIONS ==========================================================
-//-----------------------------------------------------------------------------------------------------------------------------------------
+/*-----------------------------------------------------------------------------------------------------------------------------------------*/
+/*=============================================================== NODE FUNCTIONS ==========================================================*/
+/*-----------------------------------------------------------------------------------------------------------------------------------------*/
                                                                                                 
-//-----------------------------------------------------------------------------------------------------------------------------------------
-//#########################################################################################################################################
+/*-----------------------------------------------------------------------------------------------------------------------------------------*/
+/*#########################################################################################################################################*/
 
 int processElements(void)
 {
@@ -421,36 +421,36 @@ int processElements(void)
     bool loop = TRUE;
     while (loop && result == PRETTY_PRINTING_SUCCESS)
     {
-        //strip unused whites
+        /* strip unused whites */
         readWhites(TRUE);
         
         char nextChar = getNextChar();
-        if (nextChar == '\0') { return 0; } //no more data to read
+        if (nextChar == '\0') { return 0; } /* no more data to read */
         
-        //put a new line with indentation
+        /* put a new line with indentation */
         if (appendIndentation) { putNewLine(); }
         
-        //always append indentation (but need to store the state)
+        /* always append indentation (but need to store the state) */
         bool indentBackward = appendIndentation;
         appendIndentation = TRUE; 
         
-        //okay what do we have now ?
+        /* okay what do we have now ? */
         if (nextChar != '<')
         { 
-            //a simple text node
+            /* a simple text node */
             processTextNode(); 
             ++counter; 
         } 
-        else //some more check are needed
+        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 ... >
+                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); 
@@ -459,22 +459,22 @@ int processElements(void)
             } 
             else if (nextChar == '/')
             { 
-                //close a node => stop the loop !!
+                /* close a node => stop the loop !! */
                 loop = FALSE; 
                 if (indentBackward) 
                 { 
-                    //INDEX HACKING
+                    /* INDEX HACKING */
                     xmlPrettyPrintedIndex -= options->indentLength; 
                 } 
             }
             else if (nextChar == '?')
             {
-                //this is a header
+                /* this is a header */
                 processHeader();
             }
             else 
             {
-                //a new node is open
+                /* a new node is open */
                 processNode();
                 ++counter;
             } 
@@ -487,7 +487,7 @@ int processElements(void)
 
 void processElementAttribute(void)
 {
-    //process the attribute name
+    /* process the attribute name */
     char nextChar = readNextChar();
     while (nextChar != '=')
     {
@@ -495,13 +495,13 @@ void processElementAttribute(void)
         nextChar = readNextChar();
     }
     
-    putCharInBuffer(nextChar); //that's the '='
+    putCharInBuffer(nextChar); /* that's the '=' */
     
-    //read the simple quote or double quote and put it into the buffer
+    /* read the simple quote or double quote and put it into the buffer */
     char quote = readNextChar();
     putCharInBuffer(quote); 
     
-    //process until the last quote
+    /* process until the last quote */
     char value = readNextChar();
     while(value != quote)
     {
@@ -509,13 +509,13 @@ void processElementAttribute(void)
         value = readNextChar();
     }
     
-    //simply add the last quote
+    /* simply add the last quote */
     putCharInBuffer(quote);
 }
 
 void processElementAttributes(void)
 {
-    char current = getNextChar(); //should not be a white
+    char current = getNextChar(); /* should not be a white */
     if (isWhite(current)) 
     { 
         printError("processElementAttributes : first char shouldn't be a white"); 
@@ -526,15 +526,15 @@ void processElementAttributes(void)
     bool loop = TRUE;
     while (loop)
     {
-        readWhites(TRUE); //strip the whites
+        readWhites(TRUE); /* strip the whites */
         
-        char next = getNextChar(); //don't read the last char (processed afterwards)
+        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
+            putCharInBuffer(' '); /* put only one space to separate attributes */
             processElementAttribute(); 
         }
     }
@@ -542,8 +542,8 @@ void processElementAttributes(void)
 
 void processHeader(void)
 {
-    int firstChar = inputBuffer[inputBufferIndex]; //should be '<'
-    int secondChar = inputBuffer[inputBufferIndex+1]; //must be '?'
+    int firstChar = inputBuffer[inputBufferIndex]; /* should be '<' */
+    int secondChar = inputBuffer[inputBufferIndex+1]; /* must be '?' */
     
     if (firstChar != '<') 
     { 
@@ -554,7 +554,7 @@ void processHeader(void)
     
     if (secondChar == '?')
     { 
-        //puts the '<' and '?' chars into the new buffer
+        /* puts the '<' and '?' chars into the new buffer */
         putNextCharsInBuffer(2); 
         
         while(!isWhite(getNextChar())) { putNextCharsInBuffer(1); }
@@ -562,7 +562,7 @@ void processHeader(void)
         readWhites(TRUE);
         processElementAttributes(); 
         
-        //puts the '?' and '>' chars into the new buffer
+        /* puts the '?' and '>' chars into the new buffer */
         putNextCharsInBuffer(2); 
     }
 }
@@ -579,17 +579,17 @@ void processNode(void)
     
     putCharInBuffer(opening);
     
-    //read the node name
+    /* read the node name */
     int nodeNameLength = 0;
     while (!isWhite(getNextChar()) && 
-           getNextChar() != '>' &&  //end of the tag
-           getNextChar() != '/') //tag is being closed
+           getNextChar() != '>' &&  /* end of the tag */
+           getNextChar() != '/') /* tag is being closed */
     {
         putNextCharsInBuffer(1);
         ++nodeNameLength;
     }
 
-    //store the name
+    /* store the name */
     char* nodeName = (char*)malloc(sizeof(char)*nodeNameLength+1);
     if (nodeName == NULL) { PP_ERROR("Allocation error (node name length is %d)", nodeNameLength); return ; }
     nodeName[nodeNameLength] = '\0';
@@ -600,34 +600,34 @@ void processNode(void)
         nodeName[i] = xmlPrettyPrinted[tempIndex];
     }
     
-    currentNodeName = nodeName; //set the name for using in other methods
+    currentNodeName = nodeName; /* set the name for using in other methods */
     lastNodeOpen = TRUE;
 
-    //process the attributes    
+    /* process the attributes     */
     readWhites(TRUE);
     processElementAttributes();
     
-    //process the end of the tag
+    /* process the end of the tag */
     int subElementsProcessed = 0;
-    char nextChar = getNextChar(); //should be either '/' or '>'
-    if (nextChar == '/') //the node is being closed immediatly
+    char nextChar = getNextChar(); /* should be either '/' or '>' */
+    if (nextChar == '/') /* the node is being closed immediatly */
     { 
-        //closing node directly
+        /* closing node directly */
         if (options->emptyNodeStripping || !options->forceEmptyNodeSplit)
         {
             if (options->emptyNodeStrippingSpace) { putCharInBuffer(' '); }
             putNextCharsInBuffer(2); 
         }
-        //split the closing nodes
+        /* split the closing nodes */
         else
         {
-            readNextChar(); //removing '/'
-            readNextChar(); //removing '>'
+            readNextChar(); /* removing '/' */
+            readNextChar(); /* removing '>' */
             
             putCharInBuffer('>');
             if (!options->inlineText) 
             {
-                //no inline text => new line !
+                /* no inline text => new line ! */
                 putNewLine(); 
             } 
             
@@ -641,7 +641,7 @@ void processNode(void)
     }
     else if (nextChar == '>') 
     { 
-        //the tag is just closed (maybe some content)
+        /* the tag is just closed (maybe some content) */
         putNextCharsInBuffer(1); 
         subElementsProcessed = processElements();
     } 
@@ -652,8 +652,8 @@ void processNode(void)
         return; 
     }
     
-    //if the code reaches this area, then the processElements has been called and we must
-    //close the opening tag
+    /* if the code reaches this area, then the processElements has been called and we must
+     * close the opening tag */
     char closeChar = getNextChar();
     if (closeChar != '<') 
     { 
@@ -669,37 +669,37 @@ void processNode(void)
     }
     while(closeChar != '>');
     
-    //there is no elements
+    /* there is no elements */
     if (subElementsProcessed == 0)
     {
-        //the node will be stripped
+        /* the node will be stripped */
         if (options->emptyNodeStripping)
         {
-            //because we have '<nodeName ...></nodeName>'
+            /* 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
+        /* the closing tag will be put on the same line */
         else if (options->inlineText)
         {
-            //correct the index because we have '</nodeName>'
+            /* correct the index because we have '</nodeName>' */
             xmlPrettyPrintedIndex -= nodeNameLength+3; 
             resetBackwardIndentation(TRUE);
             
-            //rewrite the node name
+            /* rewrite the node name */
             putCharsInBuffer("</");
             putCharsInBuffer(currentNodeName);
             putCharInBuffer('>');
         }
     }
     
-    //the node is closed
+    /* the node is closed */
     lastNodeOpen = FALSE;
     
-    //freeeeeeee !!!
+    /* freeeeeeee !!! */
     free(nodeName);
     nodeName = NULL;
     currentNodeName = NULL;
@@ -712,23 +712,23 @@ void processComment(void)
     if (inlineAllowed && !options->oneLineComment) { inlineAllowed = isOnSingleLine(4, '-', '-'); }
     if (inlineAllowed) { resetBackwardIndentation(TRUE); }
     
-    putNextCharsInBuffer(4); //add the chars '<!--'
+    putNextCharsInBuffer(4); /* add the chars '<!--' */
     
     char oldChar = '-';
     bool loop = TRUE;
     while (loop)
     {
         char nextChar = readNextChar();
-        if (oldChar == '-' && nextChar == '-') //comment is being closed
+        if (oldChar == '-' && nextChar == '-') /* comment is being closed */
         {
             loop = FALSE;
         }
         
-        if (!isLineBreak(nextChar)) //the comment simply continues
+        if (!isLineBreak(nextChar)) /* the comment simply continues */
         {
             if (options->oneLineComment && isSpace(nextChar))
             {
-                //removes all the unecessary spaces
+                /* removes all the unecessary spaces */
                 while(isSpace(getNextChar()))
                 {
                     nextChar = readNextChar();
@@ -738,44 +738,44 @@ void processComment(void)
             }
             else
             {
-                //comment is left untouched
+                /* comment is left untouched */
                 putCharInBuffer(nextChar);
                 oldChar = nextChar;
             }
             
-            if (!loop && options->alignComment) //end of comment
+            if (!loop && options->alignComment) /* end of comment */
             {
-                //ensures the chars preceding the first '-' are all spaces (there are at least
-                //5 spaces in front of the '-->' for the alignment with '<!--')
+                /* ensures the chars preceding the first '-' are all spaces (there are at least
+                 * 5 spaces in front of the '-->' for the alignment with '<!--') */
                 bool onlySpaces = xmlPrettyPrinted[xmlPrettyPrintedIndex-3] == ' ' &&
                                   xmlPrettyPrinted[xmlPrettyPrintedIndex-4] == ' ' &&
                                   xmlPrettyPrinted[xmlPrettyPrintedIndex-5] == ' ' &&
                                   xmlPrettyPrinted[xmlPrettyPrintedIndex-6] == ' ' &&
                                   xmlPrettyPrinted[xmlPrettyPrintedIndex-7] == ' ';
                 
-                //if all the preceding chars are white, then go for replacement
+                /* if all the preceding chars are white, then go for replacement */
                 if (onlySpaces)
                 {
-                    xmlPrettyPrintedIndex -= 7; //remove indentation spaces
-                    putCharsInBuffer("--"); //reset the first chars of '-->'
+                    xmlPrettyPrintedIndex -= 7; /* remove indentation spaces */
+                    putCharsInBuffer("--"); /* reset the first chars of '-->' */
                 }
             }
         }
-        else if (!options->oneLineComment && !inlineAllowed) //oh ! there is a line break
+        else if (!options->oneLineComment && !inlineAllowed) /* oh ! there is a line break */
         {
-            //if the comments need to be aligned, just add 5 spaces
+            /* if the comments need to be aligned, just add 5 spaces */
             if (options->alignComment) 
             {
-                int read = readWhites(FALSE); //strip the whites and new line
-                if (nextChar == '\r' && read == 0 && getNextChar() == '\n') //handles the \r\n return line
+                int read = readWhites(FALSE); /* strip the whites and new line */
+                if (nextChar == '\r' && read == 0 && getNextChar() == '\n') /* handles the \r\n return line */
                 {
                     readNextChar(); 
                     readWhites(FALSE);
                 }
               
-                putNewLine(); //put a new indentation line
-                putCharsInBuffer("     "); //align with <!-- 
-                oldChar = ' '; //and update the last char
+                putNewLine(); /* put a new indentation line */
+                putCharsInBuffer("     "); /* align with <!--  */
+                oldChar = ' '; /* and update the last char */
             }
             else
             {
@@ -783,11 +783,11 @@ void processComment(void)
                 oldChar = nextChar;
             }
         }
-        else //the comments must be inlined
+        else /* the comments must be inlined */
         {
-            readWhites(TRUE); //strip the whites and add a space if needed
+            readWhites(TRUE); /* strip the whites and add a space if needed */
             if (getPreviousInsertedChar() != ' ' &&
-                strncmp(xmlPrettyPrinted+xmlPrettyPrintedIndex-4, "<!--", 4) != 0) //prevents adding a space at the beginning 
+                strncmp(xmlPrettyPrinted+xmlPrettyPrintedIndex-4, "<!--", 4) != 0) /* prevents adding a space at the beginning  */
             { 
                 putCharInBuffer(' '); 
                 oldChar = ' ';
@@ -795,7 +795,7 @@ void processComment(void)
         }
     }
     
-    char lastChar = readNextChar(); //should be '>'
+    char lastChar = readNextChar(); /* should be '>' */
     if (lastChar != '>') 
     { 
         printError("processComment : last char must be '>' (not '%c')", lastChar); 
@@ -806,36 +806,36 @@ void processComment(void)
     
     if (inlineAllowed) { appendIndentation = FALSE; }
     
-    //there vas no node open
+    /* there vas no node open */
     lastNodeOpen = FALSE;
 }
 
 void processTextNode(void)
 {
-    //checks if inline is allowed
+    /* checks if inline is allowed */
     bool inlineTextAllowed = FALSE;
     if (options->inlineText) { inlineTextAllowed = isInlineNodeAllowed(); }
     if (inlineTextAllowed && !options->oneLineText) { inlineTextAllowed = isOnSingleLine(0, '<', '/'); }
     if (inlineTextAllowed || !options->alignText) 
     { 
-        resetBackwardIndentation(TRUE); //remove previous indentation
+        resetBackwardIndentation(TRUE); /* remove previous indentation */
         if (!inlineTextAllowed) { putNewLine(); }
     } 
    
-    //the leading whites are automatically stripped. So we re-add it
+    /* the leading whites are automatically stripped. So we re-add it */
     if (!options->trimLeadingWhites)
     {
         int backwardIndex = inputBufferIndex-1;
         while (isSpace(inputBuffer[backwardIndex])) 
         { 
-            --backwardIndex; //backward rolling
+            --backwardIndex; /* backward rolling */
         } 
         
-        //now the input[backwardIndex] IS NOT a white. So we go to 
-        //the next char...
+        /* now the input[backwardIndex] IS NOT a white. So we go to
+         * the next char... */
         ++backwardIndex;
         
-        //and then re-add the whites
+        /* and then re-add the whites */
         while (inputBuffer[backwardIndex] == ' ' || 
                inputBuffer[backwardIndex] == '\t') 
         {
@@ -844,7 +844,7 @@ void processTextNode(void)
         }
     }
     
-    //process the text into the node
+    /* process the text into the node */
     while(getNextChar() != '<')
     {
         char nextChar = readNextChar();
@@ -854,21 +854,21 @@ void processTextNode(void)
             { 
                 readWhites(TRUE);
               
-                //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
+                /* 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 if (options->alignText)
             {
                 int read = readWhites(FALSE);
-                if (nextChar == '\r' && read == 0 && getNextChar() == '\n') //handles the '\r\n'
+                if (nextChar == '\r' && read == 0 && getNextChar() == '\n') /* handles the '\r\n' */
                 {
                    nextChar = readNextChar();
                    readWhites(FALSE);
                 }
               
-                //put a new line only if the closing tag is not reached
+                /* put a new line only if the closing tag is not reached */
                 if (getNextChar() != '<') 
                 {   
                     putNewLine(); 
@@ -885,7 +885,7 @@ void processTextNode(void)
         }
     }
     
-    //strip the trailing whites
+    /* strip the trailing whites */
     if (options->trimTrailingWhites)
     {
         while(getPreviousInsertedChar() == ' ' || 
@@ -895,10 +895,10 @@ void processTextNode(void)
         }
     }
     
-    //remove the indentation for the closing tag
+    /* remove the indentation for the closing tag */
     if (inlineTextAllowed) { appendIndentation = FALSE; }
     
-    //there vas no node open
+    /* there vas no node open */
     lastNodeOpen = FALSE;
 }
 
@@ -909,7 +909,7 @@ void processCDATA(void)
     if (inlineAllowed && !options->oneLineCdata) { inlineAllowed = isOnSingleLine(9, ']', ']'); }
     if (inlineAllowed) { resetBackwardIndentation(TRUE); }
     
-    putNextCharsInBuffer(9); //putting the '<![CDATA[' into the buffer
+    putNextCharsInBuffer(9); /* putting the '<![CDATA[' into the buffer */
     
     bool loop = TRUE;
     char oldChar = '[';
@@ -917,13 +917,13 @@ void processCDATA(void)
     {
         char nextChar = readNextChar();
         char nextChar2 = getNextChar();
-        if (oldChar == ']' && nextChar == ']' && nextChar2 == '>') { loop = FALSE; } //end of cdata
+        if (oldChar == ']' && nextChar == ']' && nextChar2 == '>') { loop = FALSE; } /* end of cdata */
         
-        if (!isLineBreak(nextChar)) //the cdata simply continues
+        if (!isLineBreak(nextChar)) /* the cdata simply continues */
         {
             if (options->oneLineCdata && isSpace(nextChar))
             {
-                //removes all the unecessary spaces
+                /* removes all the unecessary spaces */
                 while(isSpace(nextChar2))
                 {
                     nextChar = readNextChar();
@@ -935,15 +935,15 @@ void processCDATA(void)
             }
             else
             {
-                //comment is left untouched
+                /* comment is left untouched */
                 putCharInBuffer(nextChar);
                 oldChar = nextChar;
             }
             
-            if (!loop && options->alignCdata) //end of cdata
+            if (!loop && options->alignCdata) /* end of cdata */
             {
-                //ensures the chars preceding the first '-' are all spaces (there are at least
-                //10 spaces in front of the ']]>' for the alignment with '<![CDATA[')
+                /* ensures the chars preceding the first '-' are all spaces (there are at least
+                 * 10 spaces in front of the ']]>' for the alignment with '<![CDATA[') */
                 bool onlySpaces = xmlPrettyPrinted[xmlPrettyPrintedIndex-3] == ' ' &&
                                   xmlPrettyPrinted[xmlPrettyPrintedIndex-4] == ' ' &&
                                   xmlPrettyPrinted[xmlPrettyPrintedIndex-5] == ' ' &&
@@ -954,29 +954,29 @@ void processCDATA(void)
                                   xmlPrettyPrinted[xmlPrettyPrintedIndex-10] == ' ' &&
                                   xmlPrettyPrinted[xmlPrettyPrintedIndex-11] == ' ';
                 
-                //if all the preceding chars are white, then go for replacement
+                /* if all the preceding chars are white, then go for replacement */
                 if (onlySpaces)
                 {
-                    xmlPrettyPrintedIndex -= 11; //remove indentation spaces
-                    putCharsInBuffer("]]"); //reset the first chars of '-->'
+                    xmlPrettyPrintedIndex -= 11; /* remove indentation spaces */
+                    putCharsInBuffer("]]"); /* reset the first chars of '-->' */
                 }
             }
         }
-        else if (!options->oneLineCdata && !inlineAllowed) //line break
+        else if (!options->oneLineCdata && !inlineAllowed) /* line break */
         {
-            //if the cdata need to be aligned, just add 9 spaces
+            /* if the cdata need to be aligned, just add 9 spaces */
             if (options->alignCdata) 
             {
-                int read = readWhites(FALSE); //strip the whites and new line
-                if (nextChar == '\r' && read == 0 && getNextChar() == '\n') //handles the \r\n return line
+                int read = readWhites(FALSE); /* strip the whites and new line */
+                if (nextChar == '\r' && read == 0 && getNextChar() == '\n') /* handles the \r\n return line */
                 {
                     readNextChar(); 
                     readWhites(FALSE);
                 }
               
-                putNewLine(); //put a new indentation line
-                putCharsInBuffer("         "); //align with <![CDATA[
-                oldChar = ' '; //and update the last char
+                putNewLine(); /* put a new indentation line */
+                putCharsInBuffer("         "); /* align with <![CDATA[ */
+                oldChar = ' '; /* and update the last char */
             }
             else
             {
@@ -984,11 +984,11 @@ void processCDATA(void)
                 oldChar = nextChar;
             }
         }
-        else //cdata are inlined
+        else /* cdata are inlined */
         {
-            readWhites(TRUE); //strip the whites and add a space if necessary
+            readWhites(TRUE); /* strip the whites and add a space if necessary */
             if(getPreviousInsertedChar() != ' ' &&
-               strncmp(xmlPrettyPrinted+xmlPrettyPrintedIndex-9, "<![CDATA[", 9) != 0) //prevents adding a space at the beginning 
+               strncmp(xmlPrettyPrinted+xmlPrettyPrintedIndex-9, "<![CDATA[", 9) != 0) /* prevents adding a space at the beginning  */
             { 
                 putCharInBuffer(' '); 
                 oldChar = ' ';
@@ -996,10 +996,10 @@ void processCDATA(void)
         }
     }
     
-    //if the cdata is inline, then all the trailing spaces are removed
+    /* if the cdata is inline, then all the trailing spaces are removed */
     if (options->oneLineCdata)
     {
-        xmlPrettyPrintedIndex -= 2; //because of the last ']]' inserted
+        xmlPrettyPrintedIndex -= 2; /* because of the last ']]' inserted */
         while(isWhite(xmlPrettyPrinted[xmlPrettyPrintedIndex-1]))
         {
             --xmlPrettyPrintedIndex;
@@ -1007,8 +1007,8 @@ void processCDATA(void)
         putCharsInBuffer("]]");
     }
     
-    //finalize the cdata
-    char lastChar = readNextChar(); //should be '>'
+    /* finalize the cdata */
+    lastChar = readNextChar(); /* should be '>' */
     if (lastChar != '>') 
     { 
         printError("processCDATA : last char must be '>' (not '%c')", lastChar); 
@@ -1020,38 +1020,38 @@ void processCDATA(void)
     
     if (inlineAllowed) { appendIndentation = FALSE; }
     
-    //there was no node open
+    /* there was no node open */
     lastNodeOpen = FALSE;
 }
 
 void processDoctype(void)
 {
-    putNextCharsInBuffer(9); //put the '<!DOCTYPE' into the buffer
+    putNextCharsInBuffer(9); /* put the '<!DOCTYPE' into the buffer */
     
     bool loop = TRUE;
     while(loop)
     {
         readWhites(TRUE);
-        putCharInBuffer(' '); //only one space for the attributes
+        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
+              !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
+        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
+                nextChar = readNextChar(); /* now we should have a quote */
                 
                 if (!isQuote(nextChar)) 
                 { 
@@ -1061,7 +1061,7 @@ void processDoctype(void)
                 }
             }
             
-            //simply process the content
+            /* simply process the content */
             char quote = nextChar;
             do
             {
@@ -1069,14 +1069,14 @@ void processDoctype(void)
                 nextChar = readNextChar();
             }
             while (nextChar != quote);
-            putCharInBuffer(nextChar); //now the last char is the last quote
+            putCharInBuffer(nextChar); /* now the last char is the last quote */
         }
-        else if (nextChar == '>') //end of doctype
+        else if (nextChar == '>') /* end of doctype */
         {
             putCharInBuffer(nextChar);
             loop = FALSE;
         }
-        else //the char is a '[' => not supported yet
+        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;


Modified: pretty-printer/src/PrettyPrinter.h
46 files changed, 23 insertions(+), 23 deletions(-)
===================================================================
@@ -19,7 +19,7 @@
 #ifndef PRETTY_PRINTER_H
 #define PRETTY_PRINTER_H
 
-//========================================== INCLUDES ==========================================================
+/*========================================== INCLUDES ==========================================================*/
 
 #ifdef HAVE_CONFIG_H
 # include "config.h"
@@ -34,7 +34,7 @@
 #include <glib.h>
 #endif
 
-//========================================== DEFINES ===========================================================
+/*========================================== DEFINES ===========================================================*/
 
 #define PRETTY_PRINTER_VERSION "1.3"
 
@@ -54,7 +54,7 @@
 
 typedef unsigned int bool;
 
-//========================================== STRUCTURES =======================================================
+/*========================================== STRUCTURES =======================================================*/
 
 /**
  * The PrettyPrintingOptions struct allows the programmer to tell the
@@ -62,29 +62,29 @@
  */
 typedef struct 
 {
-      const 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)
-      bool oneLineText;                                                                     //text is put on one line  
-      bool inlineText;                                                                      //if possible text are inline (no return after the opening node and before closing node)
-      bool oneLineComment;                                                                  //comments are put on one line
-      bool inlineComment;                                                                   //if possible comments are inline (no return after the opening node and before closing node)
-      bool oneLineCdata;                                                                    //cdata are put on one line
-      bool inlineCdata;                                                                     //if possible cdata are inline (no return after the opening node and before closing node)
-      bool emptyNodeStripping;                                                              //the empty nodes such <node></node> are set to <node/>
-      bool emptyNodeStrippingSpace;                                                         //put a space before the '/>' when a node is stripped
-      bool forceEmptyNodeSplit;                                                             //force an empty node to be splitted : <node /> becomes <node></node> (only if emptyNodeStripping = false)
-      bool trimLeadingWhites;                                                               //trim the leading whites in a text node
-      bool trimTrailingWhites;                                                              //trim the trailing whites in a text node
-      bool alignComment;                                                                    //align the comments. If false, comments are untouched (only if oneLineComment = false)
-      bool alignText;                                                                       //align the text in a node. If false, text is untouched (only if oneLineText = false)
-      bool alignCdata;                                                                      //align the cdata. If false, cdata is untouched (only if oneLineCdata = false)
+      const 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) */
+      bool oneLineText;                                                                     /* text is put on one line   */
+      bool inlineText;                                                                      /* if possible text are inline (no return after the opening node and before closing node) */
+      bool oneLineComment;                                                                  /* comments are put on one line */
+      bool inlineComment;                                                                   /* if possible comments are inline (no return after the opening node and before closing node) */
+      bool oneLineCdata;                                                                    /* cdata are put on one line */
+      bool inlineCdata;                                                                     /* if possible cdata are inline (no return after the opening node and before closing node) */
+      bool emptyNodeStripping;                                                              /* the empty nodes such <node></node> are set to <node/> */
+      bool emptyNodeStrippingSpace;                                                         /* put a space before the '/>' when a node is stripped */
+      bool forceEmptyNodeSplit;                                                             /* force an empty node to be splitted : <node /> becomes <node></node> (only if emptyNodeStripping = false) */
+      bool trimLeadingWhites;                                                               /* trim the leading whites in a text node */
+      bool trimTrailingWhites;                                                              /* trim the trailing whites in a text node */
+      bool alignComment;                                                                    /* align the comments. If false, comments are untouched (only if oneLineComment = false) */
+      bool alignText;                                                                       /* align the text in a node. If false, text is untouched (only if oneLineText = false) */
+      bool alignCdata;                                                                      /* align the cdata. If false, cdata is untouched (only if oneLineCdata = false) */
 }
 PrettyPrintingOptions;
 
-//========================================== FUNCTIONS =========================================================
+/*========================================== 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(void);                            //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(void);                            /* creates a default PrettyPrintingOptions object */
 
 #endif


@@ Diff output truncated at 100000 characters. @@


--------------
This E-Mail was brought to you by github_commit_mail.py (Source: TBD).



More information about the Plugins-Commits mailing list