Hulk did something

[bytom/vapor.git] / vendor / gopkg.in / yaml.v2 / writerc.go

diff --git a/vendor/gopkg.in/yaml.v2/writerc.go b/vendor/gopkg.in/yaml.v2/writerc.go
new file mode 100644 (file)
index 0000000..190362f
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/writerc.go
@@ -0,0 +1,89 @@
+package yaml
+
+// Set the writer error and return false.
+func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
+       emitter.error = yaml_WRITER_ERROR
+       emitter.problem = problem
+       return false
+}
+
+// Flush the output buffer.
+func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
+       if emitter.write_handler == nil {
+               panic("write handler not set")
+       }
+
+       // Check if the buffer is empty.
+       if emitter.buffer_pos == 0 {
+               return true
+       }
+
+       // If the output encoding is UTF-8, we don't need to recode the buffer.
+       if emitter.encoding == yaml_UTF8_ENCODING {
+               if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
+                       return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
+               }
+               emitter.buffer_pos = 0
+               return true
+       }
+
+       // Recode the buffer into the raw buffer.
+       var low, high int
+       if emitter.encoding == yaml_UTF16LE_ENCODING {
+               low, high = 0, 1
+       } else {
+               high, low = 1, 0
+       }
+
+       pos := 0
+       for pos < emitter.buffer_pos {
+               // See the "reader.c" code for more details on UTF-8 encoding.  Note
+               // that we assume that the buffer contains a valid UTF-8 sequence.
+
+               // Read the next UTF-8 character.
+               octet := emitter.buffer[pos]
+
+               var w int
+               var value rune
+               switch {
+               case octet&0x80 == 0x00:
+                       w, value = 1, rune(octet&0x7F)
+               case octet&0xE0 == 0xC0:
+                       w, value = 2, rune(octet&0x1F)
+               case octet&0xF0 == 0xE0:
+                       w, value = 3, rune(octet&0x0F)
+               case octet&0xF8 == 0xF0:
+                       w, value = 4, rune(octet&0x07)
+               }
+               for k := 1; k < w; k++ {
+                       octet = emitter.buffer[pos+k]
+                       value = (value << 6) + (rune(octet) & 0x3F)
+               }
+               pos += w
+
+               // Write the character.
+               if value < 0x10000 {
+                       var b [2]byte
+                       b[high] = byte(value >> 8)
+                       b[low] = byte(value & 0xFF)
+                       emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1])
+               } else {
+                       // Write the character using a surrogate pair (check "reader.c").
+                       var b [4]byte
+                       value -= 0x10000
+                       b[high] = byte(0xD8 + (value >> 18))
+                       b[low] = byte((value >> 10) & 0xFF)
+                       b[high+2] = byte(0xDC + ((value >> 8) & 0xFF))
+                       b[low+2] = byte(value & 0xFF)
+                       emitter.raw_buffer = append(emitter.raw_buffer, b[0], b[1], b[2], b[3])
+               }
+       }
+
+       // Write the raw buffer.
+       if err := emitter.write_handler(emitter, emitter.raw_buffer); err != nil {
+               return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
+       }
+       emitter.buffer_pos = 0
+       emitter.raw_buffer = emitter.raw_buffer[:0]
+       return true
+}