89 lines
2.4 KiB
Go
89 lines
2.4 KiB
Go
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
|
|
}
|