libxml-ruby 3.0.0-x64-mingw32 → 3.2.2-x64-mingw32

data/ext/libxml/ruby_xml_writer.c

@@ -19,57 +19,29 @@ static VALUE sEncoding, sStandalone;
 #include <libxml/xmlwriter.h>
 
 
-typedef enum {
+typedef enum
+{
     RXMLW_OUTPUT_NONE,
     RXMLW_OUTPUT_IO,
     RXMLW_OUTPUT_DOC,
     RXMLW_OUTPUT_STRING
 } rxmlw_output_type;
 
-typedef struct {
+typedef struct
+{
     VALUE output;
-#ifdef HAVE_RUBY_ENCODING_H
-    rb_encoding *encoding;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rb_encoding* encoding;
     xmlBufferPtr buffer;
     xmlTextWriterPtr writer;
     rxmlw_output_type output_type;
     int closed;
 } rxml_writer_object;
 
-#ifdef HAVE_RUBY_ENCODING_H
-
-#define /*VALUE*/ rxml_writer_c_to_ruby_string(/*const xmlChar **/ string, /*long*/ string_len) \
-    rb_external_str_new_with_enc(string, string_len, rb_utf8_encoding())
-
-#define /*VALUE*/ rxml_writer_ruby_string_to_utf8(/*VALUE*/ string) \
-    rb_str_conv_enc(string, rb_enc_get(string), rb_utf8_encoding())
-// rb_str_export_to_enc(string, rb_utf8_encoding())
-
-#define /*void*/ rxml_writer_free_utf8_string(/*VALUE*/ orig, /*VALUE*/ utf8) \
-    do {                       \
-        if (orig != utf8) {    \
-            rb_str_free(utf8); \
-        }                      \
-    } while (0);
-
-#else
-
-#define /*VALUE*/ rxml_writer_c_to_ruby_string(/*const xmlChar **/ string, /*long*/ string_len) \
-    rb_str_new(string, string_len)
-
-#define /*VALUE*/ rxml_writer_ruby_string_to_utf8(/*VALUE*/ string) \
-    string
-
-#define /*void*/ rxml_writer_free_utf8_string(/*VALUE*/ orig, /*VALUE*/ utf8) \
-    /* NOP */
-
-#endif /* HAVE_RUBY_ENCODING_H */
-
-static void rxml_writer_free(rxml_writer_object *rwo)
+static void rxml_writer_free(rxml_writer_object* rwo)
 {
 #if 0 /* seems to be done by xmlFreeTextWriter */
-    if (NULL != rwo->buffer) {
+    if (NULL != rwo->buffer)
+    {
         xmlBufferFree(rwo->buffer);
     }
 #endif
@@ -79,36 +51,40 @@ static void rxml_writer_free(rxml_writer_object *rwo)
     xfree(rwo);
 }
 
-static void rxml_writer_mark(rxml_writer_object *rwo)
+static void rxml_writer_mark(rxml_writer_object* rwo)
 {
-    if (!NIL_P(rwo->output)) {
+    if (!NIL_P(rwo->output))
+    {
         rb_gc_mark(rwo->output);
     }
 }
 
-static VALUE rxml_writer_wrap(rxml_writer_object *rwo)
+static VALUE rxml_writer_wrap(rxml_writer_object* rwo)
 {
     return Data_Wrap_Struct(cXMLWriter, rxml_writer_mark, rxml_writer_free, rwo);
 }
 
-static rxml_writer_object *rxml_textwriter_get(VALUE obj)
+static rxml_writer_object* rxml_textwriter_get(VALUE obj)
 {
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     Data_Get_Struct(obj, rxml_writer_object, rwo);
 
     return rwo;
 }
 
-int rxml_writer_write_callback(void *context, const char *buffer, int len)
+int rxml_writer_write_callback(void* context, const char* buffer, int len)
 {
-  rxml_writer_object *rwo = context;
+    rxml_writer_object* rwo = context;
 
-  if(rwo->closed){
-    return 0;
-  }else{
-    return rxml_write_callback((void *)rwo->output, buffer, len);
-  }
+    if (rwo->closed)
+    {
+        return 0;
+    }
+    else
+    {
+        return rxml_write_callback(rwo->output, buffer, len);
+    }
 }
 
 /* ===== public class methods ===== */
@@ -120,31 +96,26 @@ int rxml_writer_write_callback(void *context, const char *buffer, int len)
  */
 static VALUE rxml_writer_io(VALUE klass, VALUE io)
 {
-#if 0
-typedef int (*xmlOutputCloseCallback)(void * context);
-typedef int (*xmlOutputWriteCallback)(void * context, const char * buffer, int len);
-
-ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size);
-
-xmlOutputBufferPtr xmlOutputBufferCreateIO(xmlOutputWriteCallback iowrite, xmlOutputCloseCallback ioclose, void * ioctx, xmlCharEncodingHandlerPtr encoder)
-
-xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char * name);
-#endif
     xmlOutputBufferPtr out;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->output = io;
     rwo->buffer = NULL;
     rwo->closed = 0;
-#ifdef HAVE_RUBY_ENCODING_H
-    rwo->encoding = NULL;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rwo->encoding = rb_enc_get(io);
+    if (!rwo->encoding)
+        rwo->encoding = rb_utf8_encoding();
+
     rwo->output_type = RXMLW_OUTPUT_IO;
-    if (NULL == (out = xmlOutputBufferCreateIO(rxml_writer_write_callback, NULL, (void *) rwo, NULL))) {
+
+    xmlCharEncodingHandlerPtr encodingHdlr = xmlFindCharEncodingHandler(rwo->encoding->name);
+    if (NULL == (out = xmlOutputBufferCreateIO(rxml_writer_write_callback, NULL, (void*)rwo, encodingHdlr)))
+    {
         rxml_raise(&xmlLastError);
     }
-    if (NULL == (rwo->writer = xmlNewTextWriter(out))) {
+    if (NULL == (rwo->writer = xmlNewTextWriter(out)))
+    {
         rxml_raise(&xmlLastError);
     }
 
@@ -160,17 +131,16 @@ xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char * name);
  */
 static VALUE rxml_writer_file(VALUE klass, VALUE filename)
 {
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->output = Qnil;
     rwo->buffer = NULL;
     rwo->closed = 0;
-#ifdef HAVE_RUBY_ENCODING_H
-    rwo->encoding = NULL;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rwo->encoding = rb_utf8_encoding();
     rwo->output_type = RXMLW_OUTPUT_NONE;
-    if (NULL == (rwo->writer = xmlNewTextWriterFilename(StringValueCStr(filename), 0))) {
+    if (NULL == (rwo->writer = xmlNewTextWriterFilename(StringValueCStr(filename), 0)))
+    {
         rxml_raise(&xmlLastError);
     }
 
@@ -184,19 +154,19 @@ static VALUE rxml_writer_file(VALUE klass, VALUE filename)
  */
 static VALUE rxml_writer_string(VALUE klass)
 {
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->output = Qnil;
     rwo->closed = 0;
-#ifdef HAVE_RUBY_ENCODING_H
-    rwo->encoding = NULL;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rwo->encoding = rb_utf8_encoding();
     rwo->output_type = RXMLW_OUTPUT_STRING;
-    if (NULL == (rwo->buffer = xmlBufferCreate())) {
+    if (NULL == (rwo->buffer = xmlBufferCreate()))
+    {
         rxml_raise(&xmlLastError);
     }
-    if (NULL == (rwo->writer = xmlNewTextWriterMemory(rwo->buffer, 0))) {
+    if (NULL == (rwo->writer = xmlNewTextWriterMemory(rwo->buffer, 0)))
+    {
         xmlBufferFree(rwo->buffer);
         rxml_raise(&xmlLastError);
     }
@@ -212,17 +182,16 @@ static VALUE rxml_writer_string(VALUE klass)
 static VALUE rxml_writer_doc(VALUE klass)
 {
     xmlDocPtr doc;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->buffer = NULL;
     rwo->output = Qnil;
     rwo->closed = 0;
-#ifdef HAVE_RUBY_ENCODING_H
-    rwo->encoding = NULL;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rwo->encoding = rb_utf8_encoding();
     rwo->output_type = RXMLW_OUTPUT_DOC;
-    if (NULL == (rwo->writer = xmlNewTextWriterDoc(&doc, 0))) {
+    if (NULL == (rwo->writer = xmlNewTextWriterDoc(&doc, 0)))
+    {
         rxml_raise(&xmlLastError);
     }
     rwo->output = rxml_document_wrap(doc);
@@ -240,33 +209,34 @@ static VALUE rxml_writer_doc(VALUE klass)
  * If +empty?+ is +true+, and for a in memory XML::Writer, this internel
  * buffer is empty.
  */
-static VALUE rxml_writer_flush(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_flush(int argc, VALUE* argv, VALUE self)
 {
     int ret;
     VALUE empty;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rb_scan_args(argc, argv, "01", &empty);
 
     rwo = rxml_textwriter_get(self);
-    if (-1 == (ret = xmlTextWriterFlush(rwo->writer))) {
+    if (-1 == (ret = xmlTextWriterFlush(rwo->writer)))
+    {
         rxml_raise(&xmlLastError);
     }
 
-    if (NULL != rwo->buffer) {
+    if (NULL != rwo->buffer)
+    {
         VALUE content;
 
-#ifdef HAVE_RUBY_ENCODING_H
         content = rb_external_str_new_with_enc((const char*)rwo->buffer->content, rwo->buffer->use, rwo->encoding);
-#else
-        content = rb_str_new(rwo->buffer->content, rwo->buffer->use);
-#endif /* HAVE_RUBY_ENCODING_H */
-        if (NIL_P(empty) || RTEST(empty)) { /* nil = default value = true */
+        if (NIL_P(empty) || RTEST(empty))
+        { /* nil = default value = true */
             xmlBufferEmpty(rwo->buffer);
         }
 
         return content;
-    } else {
+    }
+    else
+    {
         return INT2NUM(ret);
     }
 }
@@ -281,26 +251,28 @@ static VALUE rxml_writer_flush(int argc, VALUE *argv, VALUE self)
 static VALUE rxml_writer_result(VALUE self)
 {
     VALUE ret = Qnil;
-    rxml_writer_object *rwo = rxml_textwriter_get(self);
+    rxml_writer_object* rwo = rxml_textwriter_get(self);
     int bytesWritten = xmlTextWriterFlush(rwo->writer);
 
-    if (bytesWritten == -1) {
+    if (bytesWritten == -1)
+    {
         rxml_raise(&xmlLastError);
     }
 
-    switch (rwo->output_type) {
-        case RXMLW_OUTPUT_DOC:
-            ret = rwo->output;
-            break;
-        case RXMLW_OUTPUT_STRING:
-            ret = rxml_writer_c_to_ruby_string((const char*)rwo->buffer->content, rwo->buffer->use);
-            break;
-        case RXMLW_OUTPUT_IO:
-        case RXMLW_OUTPUT_NONE:
-            break;
-        default:
-            rb_bug("unexpected output");
-            break;
+    switch (rwo->output_type)
+    {
+    case RXMLW_OUTPUT_DOC:
+        ret = rwo->output;
+        break;
+    case RXMLW_OUTPUT_STRING:
+        ret = rb_external_str_new_with_enc((const char*)rwo->buffer->content, rwo->buffer->use, rwo->encoding);
+        break;
+    case RXMLW_OUTPUT_IO:
+    case RXMLW_OUTPUT_NONE:
+        break;
+    default:
+        rb_bug("unexpected output");
+        break;
     }
 
     return ret;
@@ -311,7 +283,7 @@ static VALUE rxml_writer_result(VALUE self)
 static VALUE numeric_rxml_writer_void(VALUE obj, int (*fn)(xmlTextWriterPtr))
 {
     int ret;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = rxml_textwriter_get(obj);
     ret = fn(rwo->writer);
@@ -335,88 +307,102 @@ static VALUE numeric_rxml_writer_va_strings(VALUE obj, VALUE pe, size_t strings_
 {
     va_list ap;
     size_t argc;
-	int ret = -1;
-    rxml_writer_object *rwo;
-    const xmlChar *argv[XMLWRITER_MAX_STRING_ARGS];
+    int ret = -1;
+    rxml_writer_object* rwo;
+    const xmlChar* argv[XMLWRITER_MAX_STRING_ARGS];
     VALUE utf8[XMLWRITER_MAX_STRING_ARGS], orig[XMLWRITER_MAX_STRING_ARGS];
 
-    if (strings_count > XMLWRITER_MAX_STRING_ARGS) {
+    if (strings_count > XMLWRITER_MAX_STRING_ARGS)
+    {
         rb_bug("more arguments than expected");
     }
     va_start(ap, fn);
     rwo = rxml_textwriter_get(obj);
-    for (argc = 0; argc < strings_count; argc++) {
+    for (argc = 0; argc < strings_count; argc++)
+    {
         VALUE arg;
 
         arg = va_arg(ap, VALUE);
         orig[argc] = arg;
-        if (NIL_P(arg)) {
+        if (NIL_P(arg))
+        {
             utf8[argc] = Qnil;
             argv[argc] = NULL;
-        } else {
-            utf8[argc] = rxml_writer_ruby_string_to_utf8(orig[argc]);
+        }
+        else
+        {
+            utf8[argc] = rb_str_conv_enc(orig[argc], rb_enc_get(orig[argc]), rwo->encoding);
             argv[argc] = BAD_CAST StringValueCStr(utf8[argc]);
         }
     }
     va_end(ap);
 
-    if (Qundef == pe) {
-        switch (strings_count) {
-            case 0:
-                ret = fn(rwo->writer);
-                break;
-            case 1:
-                ret = fn(rwo->writer, argv[0]);
-                break;
-            case 2:
-                ret = fn(rwo->writer, argv[0], argv[1]);
-                break;
-            case 3:
-                ret = fn(rwo->writer, argv[0], argv[1], argv[2]);
-                break;
-            case 4:
-                ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3]);
-                break;
-            case 5:
-                ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3], argv[4]);
-                break;
-            default:
-                break;
+    if (Qundef == pe)
+    {
+        switch (strings_count)
+        {
+        case 0:
+            ret = fn(rwo->writer);
+            break;
+        case 1:
+            ret = fn(rwo->writer, argv[0]);
+            break;
+        case 2:
+            ret = fn(rwo->writer, argv[0], argv[1]);
+            break;
+        case 3:
+            ret = fn(rwo->writer, argv[0], argv[1], argv[2]);
+            break;
+        case 4:
+            ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3]);
+            break;
+        case 5:
+            ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3], argv[4]);
+            break;
+        default:
+            break;
         }
-    } else {
+    }
+    else
+    {
         int xpe;
 
         xpe = RTEST(pe);
-        switch (strings_count) { /* strings_count doesn't include pe */
-            case 0:
-                ret = fn(rwo->writer, xpe);
-                break;
-            case 1:
-                ret = fn(rwo->writer, xpe, argv[0]);
-                break;
-            case 2:
-                ret = fn(rwo->writer, xpe, argv[0], argv[1]);
-                break;
-            case 3:
-                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2]);
-                break;
-            case 4:
-                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3]);
-                break;
-            case 5:
-                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3], argv[4]);
-                break;
-            default:
-                break;
+        switch (strings_count)
+        { /* strings_count doesn't include pe */
+        case 0:
+            ret = fn(rwo->writer, xpe);
+            break;
+        case 1:
+            ret = fn(rwo->writer, xpe, argv[0]);
+            break;
+        case 2:
+            ret = fn(rwo->writer, xpe, argv[0], argv[1]);
+            break;
+        case 3:
+            ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2]);
+            break;
+        case 4:
+            ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3]);
+            break;
+        case 5:
+            ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3], argv[4]);
+            break;
+        default:
+            break;
         }
     }
-#ifdef HAVE_RUBY_ENCODING_H
-    while (--strings_count > 0) {
-        if (!NIL_P(orig[strings_count])) {
-            rxml_writer_free_utf8_string(orig[strings_count], utf8[strings_count]);
+
+    while (--strings_count > 0)
+    {
+        if (!NIL_P(orig[strings_count]))
+        {
+            if (orig[strings_count] != utf8[strings_count])
+            {
+                rb_str_free(utf8[strings_count]);
+            }
         }
     }
-#endif /* HAVE_RUBY_ENCODING_H */
 
     return (-1 == ret ? Qfalse : Qtrue);
 }
@@ -434,7 +420,7 @@ static VALUE numeric_rxml_writer_va_strings(VALUE obj, VALUE pe, size_t strings_
 static VALUE rxml_writer_set_indent(VALUE self, VALUE indentation)
 {
     int ret;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = rxml_textwriter_get(self);
     ret = xmlTextWriterSetIndent(rwo->writer, RTEST(indentation));
@@ -484,7 +470,7 @@ static VALUE rxml_writer_write_cdata(VALUE self, VALUE content)
 }
 
 static VALUE rxml_writer_start_element(VALUE, VALUE);
-static VALUE rxml_writer_start_element_ns(int, VALUE *, VALUE);
+static VALUE rxml_writer_start_element_ns(int, VALUE*, VALUE);
 static VALUE rxml_writer_end_element(VALUE);
 
 /* call-seq:
@@ -494,17 +480,21 @@ static VALUE rxml_writer_end_element(VALUE);
  * This is equivalent to start_element(name) + write_string(content) +
  * end_element.
  */
-static VALUE rxml_writer_write_element(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_write_element(int argc, VALUE* argv, VALUE self)
 {
     VALUE name, content;
 
     rb_scan_args(argc, argv, "11", &name, &content);
-    if (Qnil == content) {
-        if (Qfalse == rxml_writer_start_element(self, name)) {
+    if (Qnil == content)
+    {
+        if (Qfalse == rxml_writer_start_element(self, name))
+        {
             return Qfalse;
         }
         return rxml_writer_end_element(self);
-    } else {
+    }
+    else
+    {
         return numeric_rxml_writer_va_strings(self, Qundef, 2, xmlTextWriterWriteElement, name, content);
     }
 }
@@ -526,19 +516,23 @@ static VALUE rxml_writer_write_element(int argc, VALUE *argv, VALUE self)
  * earlier.
  * - +content+ can be omitted for an empty tag
  */
-static VALUE rxml_writer_write_element_ns(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_write_element_ns(int argc, VALUE* argv, VALUE self)
 {
     VALUE prefix, name, namespaceURI, content;
 
     rb_scan_args(argc, argv, "22", &prefix, &name, &namespaceURI, &content);
-    if (Qnil == content) {
+    if (Qnil == content)
+    {
         VALUE argv[3] = { prefix, name, namespaceURI };
 
-        if (Qfalse == rxml_writer_start_element_ns(ARRAY_SIZE(argv), argv, self)) {
+        if (Qfalse == rxml_writer_start_element_ns(ARRAY_SIZE(argv), argv, self))
+        {
             return Qfalse;
         }
         return rxml_writer_end_element(self);
-    } else {
+    }
+    else
+    {
         return numeric_rxml_writer_va_strings(self, Qundef, 4, xmlTextWriterWriteElementNS, prefix, name, namespaceURI, content);
     }
 }
@@ -568,7 +562,7 @@ static VALUE rxml_writer_write_attribute(VALUE self, VALUE name, VALUE content)
  * earlier.
  * - +content+ can be omitted too for an empty attribute
  */
-static VALUE rxml_writer_write_attribute_ns(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_write_attribute_ns(int argc, VALUE* argv, VALUE self)
 {
     VALUE prefix, name, namespaceURI, content;
 
@@ -634,7 +628,7 @@ static VALUE rxml_writer_start_attribute(VALUE self, VALUE name)
  * +namespaceURI+ to nil or omit it. Don't forget to declare the namespace
  * prefix somewhere earlier.
  */
-static VALUE rxml_writer_start_attribute_ns(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_attribute_ns(int argc, VALUE* argv, VALUE self)
 {
     VALUE prefix, name, namespaceURI;
 
@@ -697,7 +691,7 @@ static VALUE rxml_writer_start_element(VALUE self, VALUE name)
  * +namespaceURI+ to nil or omit it. Don't forget to declare the namespace
  * prefix somewhere earlier.
  */
-static VALUE rxml_writer_start_element_ns(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_element_ns(int argc, VALUE* argv, VALUE self)
 {
     VALUE prefix, name, namespaceURI;
 
@@ -762,16 +756,17 @@ static VALUE rxml_writer_end_cdata(VALUE self)
  * - standalone: nil (default) or a boolean to indicate if the document is
  * standalone or not
  */
-static VALUE rxml_writer_start_document(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_document(int argc, VALUE* argv, VALUE self)
 {
     int ret;
     VALUE options = Qnil;
-    rxml_writer_object *rwo;
-    const xmlChar *xencoding = NULL;
-    const char *xstandalone = NULL;
+    rxml_writer_object* rwo;
+    const xmlChar* xencoding = NULL;
+    const char* xstandalone = NULL;
 
     rb_scan_args(argc, argv, "01", &options);
-    if (!NIL_P(options)) {
+    if (!NIL_P(options))
+    {
         VALUE encoding, standalone;
 
         encoding = standalone = Qnil;
@@ -779,16 +774,17 @@ static VALUE rxml_writer_start_document(int argc, VALUE *argv, VALUE self)
         encoding = rb_hash_aref(options, sEncoding);
         xencoding = NIL_P(encoding) ? NULL : (const xmlChar*)xmlGetCharEncodingName(NUM2INT(encoding));
         standalone = rb_hash_aref(options, sStandalone);
-        if (NIL_P(standalone)) {
+        if (NIL_P(standalone))
+        {
             xstandalone = NULL;
-        } else {
+        }
+        else
+        {
             xstandalone = RTEST(standalone) ? "yes" : "no";
         }
     }
     rwo = rxml_textwriter_get(self);
-#ifdef HAVE_RUBY_ENCODING_H
     rwo->encoding = rxml_figure_encoding(xencoding);
-#endif /* !HAVE_RUBY_ENCODING_H */
     ret = xmlTextWriterStartDocument(rwo->writer, NULL, (const char*)xencoding, xstandalone);
 
     return (-1 == ret ? Qfalse : Qtrue);
@@ -829,7 +825,7 @@ static VALUE rxml_writer_end_pi(VALUE self)
  *
  * Starts a DTD. Returns +false+ on failure.
  */
-static VALUE rxml_writer_start_dtd(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_dtd(int argc, VALUE* argv, VALUE self)
 {
     VALUE name, pubid, sysid;
 
@@ -853,12 +849,13 @@ static VALUE rxml_writer_start_dtd_element(VALUE self, VALUE name)
  *
  * Starts a DTD entity (<!ENTITY ... >). Returns +false+ on failure.
  */
-static VALUE rxml_writer_start_dtd_entity(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_dtd_entity(int argc, VALUE* argv, VALUE self)
 {
     VALUE name, pe;
 
     rb_scan_args(argc, argv, "11", &name, &pe);
-    if (NIL_P(pe)) {
+    if (NIL_P(pe))
+    {
         pe = Qfalse;
     }
 
@@ -934,7 +931,7 @@ static VALUE rxml_writer_end_dtd_element(VALUE self)
  *   writer.write_dtd 'person', nil, nil, '<!ELEMENT person (firstname,lastname)><!ELEMENT firstname (#PCDATA)><!ELEMENT lastname (#PCDATA)>'
  *     #=> <!DOCTYPE person [<!ELEMENT person (firstname,lastname)><!ELEMENT firstname (#PCDATA)><!ELEMENT lastname (#PCDATA)>]>
  */
-static VALUE rxml_writer_write_dtd(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_write_dtd(int argc, VALUE* argv, VALUE self)
 {
     VALUE name, pubid, sysid, subset;
 
@@ -1043,12 +1040,12 @@ static VALUE rxml_writer_write_dtd_notation(VALUE self, VALUE name, VALUE pubid,
 static VALUE rxml_writer_set_quote_char(VALUE self, VALUE quotechar)
 {
     int ret;
-    const char *xquotechar;
-    rxml_writer_object *rwo;
+    const char* xquotechar;
+    rxml_writer_object* rwo;
 
     rwo = rxml_textwriter_get(self);
     xquotechar = StringValueCStr(quotechar);
-    ret = xmlTextWriterSetQuoteChar(rwo->writer, (xmlChar) xquotechar[0]);
+    ret = xmlTextWriterSetQuoteChar(rwo->writer, (xmlChar)xquotechar[0]);
 
     return (-1 == ret ? Qfalse : Qtrue);
 }