static VALUE
rb_yaml_emitter_document(VALUE self, SEL sel, int argc, VALUE *argv)
{
yaml_emitter_t *emitter = &RYAMLEmitter(self)->emitter;
VALUE impl_beg = Qnil, impl_end = Qnil;
rb_scan_args(argc, argv, "02", &impl_beg, &impl_end);
if (NIL_P(impl_beg)) {
impl_beg = Qfalse;
}
if (NIL_P(impl_end)) {
impl_end = Qtrue;
}
yaml_event_t ev;
yaml_document_start_event_initialize(&ev, NULL, NULL, NULL, 0);
yaml_emitter_emit(emitter, &ev);
rb_yield(self);
yaml_document_end_event_initialize(&ev, 1);
yaml_emitter_emit(emitter, &ev);
yaml_emitter_flush(emitter);
return self;
}
static int
yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
yaml_char_t *anchor)
{
yaml_event_t event;
yaml_mark_t mark = { 0, 0, 0 };
int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0);
yaml_node_pair_t *pair;
MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit,
node->data.mapping.style, mark, mark);
if (!yaml_emitter_emit(emitter, &event)) return 0;
for (pair = node->data.mapping.pairs.start;
pair < node->data.mapping.pairs.top; pair ++) {
if (!yaml_emitter_dump_node(emitter, pair->key)) return 0;
if (!yaml_emitter_dump_node(emitter, pair->value)) return 0;
}
MAPPING_END_EVENT_INIT(event, mark, mark);
if (!yaml_emitter_emit(emitter, &event)) return 0;
return 1;
}
static bool emit_mapping(node *mapping, void *context)
{
log_trace(component, "emitting mapping");
yaml_emitter_t *emitter = (yaml_emitter_t *)context;
yaml_event_t event;
log_trace(component, "mapping start");
uint8_t *name = node_name(mapping);
yaml_char_t *tag = NULL == name ? (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG : (yaml_char_t *)name;
yaml_mapping_start_event_initialize(&event, NULL, tag, NULL == name, YAML_BLOCK_MAPPING_STYLE);
if (!yaml_emitter_emit(emitter, &event))
return false;
if(!mapping_iterate(mapping, emit_mapping_item, context))
{
return false;
}
log_trace(component, "mapping end");
yaml_mapping_end_event_initialize(&event);
if (!yaml_emitter_emit(emitter, &event))
return false;
return true;
}
static int
yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
yaml_char_t *anchor)
{
yaml_event_t event;
yaml_mark_t mark = { 0, 0, 0 };
int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0);
yaml_node_item_t *item;
SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit,
node->data.sequence.style, mark, mark);
if (!yaml_emitter_emit(emitter, &event)) return 0;
for (item = node->data.sequence.items.start;
item < node->data.sequence.items.top; item ++) {
if (!yaml_emitter_dump_node(emitter, *item)) return 0;
}
SEQUENCE_END_EVENT_INIT(event, mark, mark);
if (!yaml_emitter_emit(emitter, &event)) return 0;
return 1;
}
static bool emit_sequence(node *sequence, void *context)
{
log_trace(component, "emitting seqence");
yaml_emitter_t *emitter = (yaml_emitter_t *)context;
yaml_event_t event;
log_trace(component, "seqence start");
uint8_t *name = node_name(sequence);
yaml_char_t *tag = NULL == name ? (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG : (yaml_char_t *)name;
yaml_sequence_start_event_initialize(&event, NULL, tag, NULL == name, YAML_BLOCK_SEQUENCE_STYLE);
if (!yaml_emitter_emit(emitter, &event))
return false;
if(!sequence_iterate(sequence, emit_sequence_item, context))
{
return false;
}
log_trace(component, "seqence end");
yaml_sequence_end_event_initialize(&event);
if (!yaml_emitter_emit(emitter, &event))
return false;
return true;
}
int MapObject::yamlDocEpilog(yaml_emitter_t *emitter, yaml_event_t *event) {
yaml_document_end_event_initialize(event, true);
yaml_emitter_emit(emitter, event);
yaml_stream_end_event_initialize(event);
yaml_emitter_emit(emitter, event);
return 1;
}
int MapObject::yamlDocProlog(yaml_emitter_t *emitter, yaml_event_t *event) {
yaml_stream_start_event_initialize(event, YAML_UTF8_ENCODING);
if (!yaml_emitter_emit(emitter, event)) {
yaml_emitter_delete(emitter);
return 0;
}
yaml_document_start_event_initialize(event, NULL, NULL, NULL, true);
yaml_emitter_emit(emitter, event);
return 1;
}
void emit_yaml(const nodelist *list, const struct settings *settings)
{
log_debug(component, "emitting...");
yaml_emitter_t emitter;
yaml_event_t event;
yaml_emitter_initialize(&emitter);
yaml_emitter_set_output_file(&emitter, stdout);
yaml_emitter_set_unicode(&emitter, 1);
log_trace(component, "stream start");
yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING);
if (!yaml_emitter_emit(&emitter, &event))
goto error;
log_trace(component, "document start");
yaml_document_start_event_initialize(&event, &(yaml_version_directive_t){1, 1}, NULL, NULL, 0);
if (!yaml_emitter_emit(&emitter, &event))
goto error;
if(1 == nodelist_length(list))
{
if(!emit_node(nodelist_get(list, 0), &emitter))
{
fprintf(stderr, "%s: %s\n", settings->program_name, emitter.problem);
goto error;
}
}
else
{
if(!emit_nodelist(list, &emitter))
{
fprintf(stderr, "%s: %s\n", settings->program_name, emitter.problem);
goto error;
}
}
log_trace(component, "document end");
yaml_document_end_event_initialize(&event, 1);
if (!yaml_emitter_emit(&emitter, &event))
goto error;
log_trace(component, "stream end");
yaml_stream_end_event_initialize(&event);
if (!yaml_emitter_emit(&emitter, &event))
goto error;
error:
yaml_emitter_delete(&emitter);
fflush(stdout);
}
yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
{
yaml_event_t event;
yaml_mark_t mark = { 0, 0, 0 };
assert(emitter); /* Non-NULL emitter object is required. */
assert(document); /* Non-NULL emitter object is expected. */
emitter->document = document;
if (!emitter->opened) {
if (!yaml_emitter_open(emitter)) goto error;
}
if (STACK_EMPTY(emitter, document->nodes)) {
if (!yaml_emitter_close(emitter)) goto error;
yaml_emitter_delete_document_and_anchors(emitter);
return 1;
}
assert(emitter->opened); /* Emitter should be opened. */
emitter->anchors = yaml_malloc(sizeof(*(emitter->anchors))
* (document->nodes.top - document->nodes.start));
if (!emitter->anchors) goto error;
memset(emitter->anchors, 0, sizeof(*(emitter->anchors))
* (document->nodes.top - document->nodes.start));
DOCUMENT_START_EVENT_INIT(event, document->version_directive,
document->tag_directives.start, document->tag_directives.end,
document->start_implicit, mark, mark);
if (!yaml_emitter_emit(emitter, &event)) goto error;
yaml_emitter_anchor_node(emitter, 1);
if (!yaml_emitter_dump_node(emitter, 1)) goto error;
DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark);
if (!yaml_emitter_emit(emitter, &event)) goto error;
yaml_emitter_delete_document_and_anchors(emitter);
return 1;
error:
yaml_emitter_delete_document_and_anchors(emitter);
return 0;
}
/* Emit a SEQUENCE_START event. */
static int
emit_SEQUENCE_START (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
yaml_sequence_style_t yaml_style;
yaml_char_t *anchor = NULL, *tag = NULL;
int implicit = 1;
const char *style = NULL;
RAWGET_STRDUP (style); lua_pop (L, 1);
#define MENTRY(_s) (STREQ (style, #_s)) { yaml_style = YAML_##_s##_SEQUENCE_STYLE; }
if (style == NULL) { yaml_style = YAML_ANY_SEQUENCE_STYLE; } else
if MENTRY( BLOCK ) else
if MENTRY( FLOW ) else
{
emitter->error++;
lua_pushfstring (L, "invalid sequence style '%s'", style);
lua_insert (L, -2);
}
#undef MENTRY
RAWGET_YAML_CHARP (anchor); lua_pop (L, 1);
RAWGET_YAML_CHARP (tag); lua_pop (L, 1);
RAWGET_BOOLEAN (implicit); lua_pop (L, 1);
yaml_sequence_start_event_initialize (&event, anchor, tag, implicit, yaml_style);
return yaml_emitter_emit (&emitter->emitter, &event);
}
std::string MapObject::exportYaml() {
yaml_emitter_t emitter;
yaml_event_t event;
std::string exportValue = "";
yaml_emitter_initialize(&emitter);
yaml_emitter_set_output(&emitter, write_handler, &exportValue);
yaml_emitter_set_encoding(&emitter, YAML_UTF8_ENCODING);
if (! yamlDocProlog(&emitter, &event))
return "";
if (this->mapPtr->map.size()) yamlMap(&emitter, &event, this->mapPtr);
else if (this->mapObjects.size()) yamlSequence(&emitter, &event, &this->mapObjects);
else {
yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t*) (this->value.c_str()), (int) this->value.length(), 1, 1, YAML_ANY_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
}
yamlDocEpilog(&emitter, &event);
yaml_event_delete(&event);
yaml_emitter_delete(&emitter);
return exportValue;
}
static VALUE
rb_yaml_emitter_scalar(VALUE self, SEL sel, VALUE taguri, VALUE val,
VALUE style)
{
yaml_event_t ev;
yaml_emitter_t *emitter = &RYAMLEmitter(self)->emitter;
yaml_char_t *output = (yaml_char_t *)RSTRING_PTR(val);
const size_t length = strlen((const char *)output);
int can_omit_tag = 0;
int string_tag = 0;
yaml_char_t *tag = rb_yaml_tag_or_null(taguri, &can_omit_tag, &string_tag);
yaml_scalar_style_t sstyl = rb_symbol_to_scalar_style(style);
if (string_tag
&& (sstyl==YAML_ANY_SCALAR_STYLE || sstyl==YAML_PLAIN_SCALAR_STYLE)
&& (detect_scalar_type((const char *)output, length) != NULL)) {
// Quote so this is read back as a string, no matter what type it
// looks like.
sstyl = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
}
yaml_scalar_event_initialize(&ev, NULL, tag, output, length,
can_omit_tag, can_omit_tag, sstyl);
yaml_emitter_emit(emitter, &ev);
return self;
}
void MapObject::exportYaml(std::wstring fileName) {
yaml_emitter_t emitter;
yaml_event_t event;
FILE *file;
_wfopen_s(&file, fileName.c_str(), _T("wb"));
yaml_emitter_initialize(&emitter);
yaml_emitter_set_output_file(&emitter, file);
yaml_emitter_set_encoding(&emitter, YAML_UTF8_ENCODING);
if (! yamlDocProlog(&emitter, &event))
return;
if (this->mapPtr->map.size()) yamlMap(&emitter, &event, this->mapPtr);
else if (this->mapObjects.size()) yamlSequence(&emitter, &event, &this->mapObjects, (this->flow == true ? 1 : 0));
else {
yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t*) (this->value.c_str()), (int) this->value.length(), 1, 1, YAML_ANY_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
}
yamlDocEpilog(&emitter, &event);
yaml_emitter_flush(&emitter);
fclose(file);
yaml_event_delete(&event);
yaml_emitter_delete(&emitter);
}
/* Emit a MAPPING_END event. */
static int
emit_MAPPING_END (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
yaml_mapping_end_event_initialize (&event);
return yaml_emitter_emit (&emitter->emitter, &event);
}
/* Emit a SEQUENCE_END event. */
static int
emit_SEQUENCE_END (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
yaml_sequence_end_event_initialize (&event);
return yaml_emitter_emit (&emitter->emitter, &event);
}
/* Emit a SCALAR event. */
static int
emit_SCALAR (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
yaml_scalar_style_t yaml_style;
yaml_char_t *anchor = NULL, *tag = NULL, *value;
int length = 0, plain_implicit = 1, quoted_implicit = 1;
const char *style = NULL;
RAWGET_STRDUP (style); lua_pop (L, 1);
#define MENTRY(_s) (STREQ (style, #_s)) { yaml_style = YAML_##_s##_SCALAR_STYLE; }
if (style == NULL) { yaml_style = YAML_ANY_SCALAR_STYLE; } else
if MENTRY( PLAIN ) else
if MENTRY( SINGLE_QUOTED ) else
if MENTRY( DOUBLE_QUOTED ) else
if MENTRY( LITERAL ) else
if MENTRY( FOLDED ) else
{
emitter->error++;
lua_pushfstring (L, "invalid scalar style '%s'", style);
lua_insert (L, -2);
}
#undef MENTRY
RAWGET_YAML_CHARP (anchor); lua_pop (L, 1);
RAWGET_YAML_CHARP (tag); lua_pop (L, 1);
RAWGET_YAML_CHARP (value); length = lua_objlen (L, -1); lua_pop (L, 1);
yaml_scalar_event_initialize (&event, anchor, tag, value, length,
plain_implicit, quoted_implicit, yaml_style);
return yaml_emitter_emit (&emitter->emitter, &event);
}
/* Emit a STREAM_START event. */
static int
emit_STREAM_START (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
yaml_encoding_t yaml_encoding;
const char *encoding = NULL;
RAWGET_STRDUP (encoding); lua_pop (L, 1);
#define MENTRY(_s) (STREQ (encoding, #_s)) { yaml_encoding = YAML_##_s##_ENCODING; }
if (encoding == NULL) { yaml_encoding = YAML_ANY_ENCODING; } else
if MENTRY( UTF8 ) else
if MENTRY( UTF16LE ) else
if MENTRY( UTF16BE ) else
{
emitter->error++;
lua_pushfstring (L, "invalid stream encoding '%s'", encoding);
lua_insert (L, -2);
}
#undef MENTRY
if (encoding) free ((void *) encoding);
if (emitter->error != 0)
return 0;
yaml_stream_start_event_initialize (&event, yaml_encoding);
return yaml_emitter_emit (&emitter->emitter, &event);
}
/* Emit a STREAM_END event. */
static int
emit_STREAM_END (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
yaml_stream_end_event_initialize (&event);
return yaml_emitter_emit (&emitter->emitter, &event);
}
int print_config_to_emitter(yaml_emitter_t emitter,
const config_t conf){
yaml_event_t event;
int r = CONF_OK;
yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING);
r = yaml_emitter_emit(&emitter, &event);
if(r){
r = emit(&emitter, conf);
}
if(r){
yaml_stream_end_event_initialize(&event);
r = yaml_emitter_emit(&emitter, &event);
}
return r;
}
void yamlTryEmit(yaml_emitter_t *emitter,
yaml_event_t *event)
{
if (!yaml_emitter_emit(emitter, event))
{
throw YamlException();
}
}
/* Emit a DOCUMENT_START event. */
static int
emit_DOCUMENT_START (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
yaml_version_directive_t version_directive, *Pversion_directive = NULL;
yaml_tag_directive_t *tag_directives_start = NULL, *tag_directives_end = NULL;
int implicit = 0;
RAWGET_PUSHTABLE ("version_directive");
if (lua_type (L, -1) == LUA_TTABLE)
{
RAWGETS_INTEGER (version_directive.major, "major");
ERROR_IFNIL ("version_directive missing key 'major'");
if (emitter->error == 0)
{
RAWGETS_INTEGER (version_directive.minor, "minor");
ERROR_IFNIL ("version_directive missing key 'minor'");
}
Pversion_directive = &version_directive;
}
lua_pop (L, 1); /* pop version_directive rawget */
RAWGET_PUSHTABLE ("tag_directives");
if (lua_type (L, -1) == LUA_TTABLE)
{
size_t bytes = lua_objlen (L, -1) * sizeof (yaml_tag_directive_t);
tag_directives_start = (yaml_tag_directive_t *) malloc (bytes);
tag_directives_end = tag_directives_start;
lua_pushnil (L); /* first key */
while (lua_next (L, -2) != 0)
{
RAWGETS_STRDUP (tag_directives_end->handle, "handle");
ERROR_IFNIL ("tag_directives item missing key 'handle'");
lua_pop (L, 1); /* pop handle */
RAWGETS_STRDUP (tag_directives_end->prefix, "prefix");
ERROR_IFNIL ("tag_directives item missing key 'prefix'");
lua_pop (L, 1); /* pop prefix */
tag_directives_end += 1;
/* pop tag_directives list elewent, leave key for next iteration */
lua_pop (L, 1);
}
}
lua_pop (L, 1); /* pop lua_rawget "tag_directives" result */
RAWGET_BOOLEAN (implicit); lua_pop (L, 1);
if (emitter->error != 0)
return 0;
yaml_document_start_event_initialize (&event, Pversion_directive,
tag_directives_start, tag_directives_end, implicit);
return yaml_emitter_emit (&emitter->emitter, &event);
}
static int
yaml_emitter_dump_alias (yaml_emitter_t* emitter, yaml_char_t* anchor) {
yaml_event_t event;
yaml_mark_t mark = { 0, 0, 0 };
ALIAS_EVENT_INIT (event, anchor, mark, mark);
return yaml_emitter_emit (emitter, &event);
}
result_t CYamlEmitter::SaveStreamEnd ( yaml_emitter_t& _emitter ) const
{
result_t result_t = eResult_OK;
yaml_event_t event;
yaml_stream_end_event_initialize ( &event );
yaml_emitter_emit ( &_emitter, &event ) || yaml_emitter_flush ( &_emitter );
return eResult;
}
int emit(yaml_emitter_t *emitter, const config_t conf) {
int r = CONF_OK;
yaml_event_t evt;
//doc start
yaml_document_start_event_initialize(&evt,
NULL,
NULL,
NULL,
CONF_F);
yaml_emitter_emit(emitter, &evt);
// log_yml_event(evt);
yaml_mapping_start_event_initialize(&evt,
NULL,
NULL,
CONF_F,
YAML_BLOCK_MAPPING_STYLE);
yaml_emitter_emit(emitter, &evt);
// log_yml_event(evt);
entry_t iter = conf->map[0];
int i = 0;
while(i < conf->size) {
if(iter){
emit_entry(iter, emitter);
}
iter = conf->map[++i];
}
//mapping end
yaml_mapping_end_event_initialize(&evt);
yaml_emitter_emit(emitter, &evt);
//log_yml_event(evt);
//doc end
yaml_document_end_event_initialize(&evt,CONF_F);
yaml_emitter_emit(emitter, &evt);
//log_yml_event(evt);
yaml_event_delete(&evt);
return r;
}
result_t CYamlEmitter::SaveStreamStart ( yaml_emitter_t& _emitter ) const
{
result_t result_t = eResult_OK;
yaml_event_t event;
yaml_stream_start_event_initialize ( &event, GetEncoding(m_Encoding) );
yaml_emitter_emit ( &_emitter, &event ) || yaml_emitter_flush ( &_emitter );
return eResult;
}
static VALUE
rb_yaml_emitter_stream(VALUE self, SEL sel)
{
yaml_event_t ev;
yaml_emitter_t *emitter = &RYAMLEmitter(self)->emitter;
// RADAR: allow the encoding to be configurable
yaml_stream_start_event_initialize(&ev, YAML_UTF8_ENCODING);
yaml_emitter_emit(emitter, &ev);
rb_yield(self);
yaml_stream_end_event_initialize(&ev);
yaml_emitter_emit(emitter, &ev);
yaml_emitter_flush(emitter);
yaml_emitter_delete(emitter);
// XXX: more cleanup here...
return RYAMLEmitter(self)->output;
}
static VALUE
rb_yaml_emitter_mapping(VALUE self, SEL sel, VALUE taguri, VALUE style)
{
yaml_event_t ev;
yaml_emitter_t *emitter = &RYAMLEmitter(self)->emitter;
int can_omit_tag = 0;
int string_tag = 0;
yaml_char_t *tag = rb_yaml_tag_or_null(taguri, &can_omit_tag, &string_tag);
yaml_mapping_start_event_initialize(&ev, NULL, tag, can_omit_tag,
rb_symbol_to_mapping_style(style));
yaml_emitter_emit(emitter, &ev);
rb_yield(self);
yaml_mapping_end_event_initialize(&ev);
yaml_emitter_emit(emitter, &ev);
return self;
}
/* Emit an ALIAS event. */
static int
emit_ALIAS (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
yaml_char_t *anchor;
RAWGET_YAML_CHARP (anchor);
yaml_alias_event_initialize (&event, anchor);
return yaml_emitter_emit (&emitter->emitter, &event);
}
/* Emit a DOCUMENT_END event. */
static int
emit_DOCUMENT_END (lua_State *L, lyaml_emitter *emitter)
{
yaml_event_t event;
int implicit = 0;
RAWGET_BOOLEAN (implicit);
yaml_document_end_event_initialize (&event, implicit);
return yaml_emitter_emit (&emitter->emitter, &event);
}
int MapObject::yamlSequence(yaml_emitter_t *emitter, yaml_event_t *event, std::vector<MapObject>* mapObjects, int flow_style) {
if (mapObjects->size()) {
yaml_sequence_start_event_initialize(event, NULL, NULL, true, (flow_style == false ? YAML_BLOCK_SEQUENCE_STYLE : YAML_FLOW_SEQUENCE_STYLE));
yaml_emitter_emit(emitter, event);
for (auto it = mapObjects->begin(); it != mapObjects->end(); it++) {
if (it->mapPtr->map.size())
yamlMap(emitter, event, it->mapPtr);
else if (it->mapObjects.size())
yamlSequence(emitter, event, &it->mapObjects, (it->flow == true ? 1 : 0));
else if (! it->value.empty()) {
yaml_scalar_event_initialize(event, NULL, NULL, (yaml_char_t*) it->value.c_str(), (int) it->value.length(), 1, 1, YAML_ANY_SCALAR_STYLE);
yaml_emitter_emit(emitter, event);
}
}
yaml_sequence_end_event_initialize(event);
yaml_emitter_emit(emitter, event);
}
return 1;
}