Changeset 211


Ignore:
Timestamp:
07/23/06 07:57:36 (8 years ago)
Author:
xi
Message:

Add Emitter definitions and implement the Writer.

Location:
libyaml/trunk
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/include/yaml.h

    r208 r211  
    101101    YAML_UTF16BE_ENCODING 
    102102} yaml_encoding_t; 
     103 
     104/** Line break types. */ 
     105 
     106typedef enum { 
     107    YAML_ANY_BREAK, 
     108    YAML_CR_BREAK, 
     109    YAML_LN_BREAK, 
     110    YAML_CRLN_BREAK 
     111} yaml_break_t; 
    103112 
    104113/** Many bad things could happen with the parser and emitter. */ 
     
    436445 * @returns On success, the handler should return @c 1.  If the handler failed, 
    437446 * the returned value should be @c 0.  On EOF, the handler should set the 
    438  * @a length to @c 0 and return @c 1. 
     447 * @a size_read to @c 0 and return @c 1. 
    439448 */ 
    440449 
     
    555564    /** The working buffer. */ 
    556565    struct { 
    557         /* The beginning of the buffer. */ 
     566        /** The beginning of the buffer. */ 
    558567        yaml_char_t *start; 
    559         /* The end of the buffer. */ 
     568        /** The end of the buffer. */ 
    560569        yaml_char_t *end; 
    561         /* The current position of the buffer. */ 
     570        /** The current position of the buffer. */ 
    562571        yaml_char_t *pointer; 
    563         /* The last filled position of the buffer. */ 
     572        /** The last filled position of the buffer. */ 
    564573        yaml_char_t *last; 
    565574    } buffer; 
     
    707716 * @param[in]   parser  An empty parser object. 
    708717 * 
    709  * @returns #c 1 if the function succeeded, @c 0 on error. 
     718 * @returns @c 1 if the function succeeded, @c 0 on error. 
    710719 */ 
    711720 
     
    737746yaml_parser_set_input_string(yaml_parser_t *parser, 
    738747        unsigned char *input, size_t size); 
    739  
    740748 
    741749/** 
     
    822830/** @} */ 
    823831 
    824 /* 
     832/** 
     833 * @defgroup emitter Emitter Definitions 
     834 * @{ 
     835 */ 
     836 
     837/** 
     838 * The prototype of a write handler. 
     839 * 
     840 * The write handler is called when the emitter needs to flush the accumulated 
     841 * characters to the output.  The handler should write @a size bytes of the 
     842 * @a buffer to the output. 
     843 * 
     844 * @param[in]   data        A pointer to an application data specified by 
     845 *                          @c yaml_emitter_set_write_handler. 
     846 * @param[out]  buffer      The buffer with bytes to be written. 
     847 * @param[in]   size        The size of the buffer. 
     848 * 
     849 * @returns On success, the handler should return @c 1.  If the handler failed, 
     850 * the returned value should be @c 0. 
     851 */ 
     852 
     853typedef int yaml_write_handler_t(void *data, unsigned char *buffer, size_t size); 
     854 
     855/** The emitter states. */ 
     856typedef enum { 
     857    YAML_EMIT_STREAM_START_STATE, 
     858    YAML_EMIT_FIRST_DOCUMENT_START_STATE, 
     859    YAML_EMIT_DOCUMENT_START_STATE, 
     860    YAML_EMIT_DOCUMENT_CONTENT_STATE, 
     861    YAML_EMIT_DOCUMENT_END_STATE, 
     862    YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE, 
     863    YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE, 
     864    YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE, 
     865    YAML_EMIT_FLOW_MAPPING_KEY_STATE, 
     866    YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE, 
     867    YAML_EMIT_FLOW_MAPPING_VALUE_STATE, 
     868    YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE, 
     869    YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE, 
     870    YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE, 
     871    YAML_EMIT_BLOCK_MAPPING_KEY_STATE, 
     872    YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE, 
     873    YAML_EMIT_BLOCK_MAPPING_VALUE_STATE 
     874} yaml_emitter_state_t; 
     875 
     876/** 
     877 * The emitter structure. 
     878 * 
     879 * All members are internal.  Manage the structure using the @c yaml_emitter_ 
     880 * family of functions. 
     881 */ 
     882 
    825883typedef struct { 
     884 
     885    /** 
     886     * @name Error handling 
     887     * @{ 
     888     */ 
     889 
     890    /** Error type. */ 
     891    yaml_error_type_t error; 
     892    /** Error description. */ 
     893    const char *problem; 
     894 
     895    /** 
     896     * @} 
     897     */ 
     898 
     899    /** 
     900     * @name Writer stuff 
     901     * @{ 
     902     */ 
     903 
     904    /** Write handler. */ 
     905    yaml_write_handler_t *write_handler; 
     906 
     907    /** A pointer for passing to the white handler. */ 
     908    void *write_handler_data; 
     909 
     910    /** Standard (string or file) output data. */ 
     911    union { 
     912        /** String output data. */ 
     913        struct { 
     914            /** The buffer pointer. */ 
     915            unsigned char *buffer; 
     916            /** The buffer size. */ 
     917            size_t size; 
     918            /** The number of written bytes. */ 
     919            size_t *size_written; 
     920        } string; 
     921 
     922        /** File output data. */ 
     923        FILE *file; 
     924    } output; 
     925 
     926    /** The working buffer. */ 
     927    struct { 
     928        /** The beginning of the buffer. */ 
     929        yaml_char_t *start; 
     930        /** The end of the buffer. */ 
     931        yaml_char_t *end; 
     932        /** The current position of the buffer. */ 
     933        yaml_char_t *pointer; 
     934        /** The last filled position of the buffer. */ 
     935        yaml_char_t *last; 
     936    } buffer; 
     937 
     938    /** The raw buffer. */ 
     939    struct { 
     940        /** The beginning of the buffer. */ 
     941        unsigned char *start; 
     942        /** The end of the buffer. */ 
     943        unsigned char *end; 
     944        /** The current position of the buffer. */ 
     945        unsigned char *pointer; 
     946        /** The last filled position of the buffer. */ 
     947        unsigned char *last; 
     948    } raw_buffer; 
     949 
     950    /** The stream encoding. */ 
     951    yaml_encoding_t encoding; 
     952 
     953    /** 
     954     * @} 
     955     */ 
     956 
     957    /** 
     958     * @name Emitter stuff 
     959     * @{ 
     960     */ 
     961 
     962    /** If the output is in the canonical style? */ 
     963    int canonical; 
     964    /** The number of indentation spaces. */ 
     965    int best_indent; 
     966    /** The preferred width of the output lines. */ 
     967    int best_width; 
     968    /** Allow unescaped non-ASCII characters? */ 
     969    int unicode; 
     970    /** The preferred line break. */ 
     971    yaml_break_t line_break; 
     972 
     973    /** The stack of states. */ 
     974    struct { 
     975        /** The beginning of the stack. */ 
     976        yaml_emitter_state_t *start; 
     977        /** The end of the stack. */ 
     978        yaml_emitter_state_t *end; 
     979        /** The top of the stack. */ 
     980        yaml_emitter_state_t *top; 
     981    } states; 
     982 
     983    /** The current emitter state. */ 
     984    yaml_emitter_state_t state; 
     985 
     986    /** The event queue. */ 
     987    struct { 
     988        /** The beginning of the event queue. */ 
     989        yaml_event_t *start; 
     990        /** The end of the event queue. */ 
     991        yaml_event_t *end; 
     992        /** The head of the event queue. */ 
     993        yaml_event_t *head; 
     994        /** The tail of the event queue. */ 
     995        yaml_event_t *tail; 
     996    } events; 
     997 
     998    /** The current event. */ 
     999    yaml_event_t event; 
     1000 
     1001    /** The stack of indentation levels. */ 
     1002    struct { 
     1003        /** The beginning of the stack. */ 
     1004        int *start; 
     1005        /** The end of the stack. */ 
     1006        int *end; 
     1007        /** The top of the stack. */ 
     1008        int *top; 
     1009    } indents; 
     1010 
     1011    /** The list of tag directives. */ 
     1012    struct { 
     1013        /** The beginning of the list. */ 
     1014        yaml_tag_directive_t *start; 
     1015        /** The end of the list. */ 
     1016        yaml_tag_directive_t *end; 
     1017        /** The top of the list. */ 
     1018        yaml_tag_directive_t *top; 
     1019    } tag_directives; 
     1020 
     1021    /** The current indentation level. */ 
     1022    int indent; 
     1023 
     1024    /** The current flow level. */ 
     1025    int flow_level; 
     1026 
     1027    /** Is it the document root context? */ 
     1028    int root_context; 
     1029    /** Is it a sequence context? */ 
     1030    int sequence_context; 
     1031    /** Is it a mapping context? */ 
     1032    int mapping_context; 
     1033    /** Is it a simple mapping key context? */ 
     1034    int simple_key_context; 
     1035 
     1036    /** The current line. */ 
     1037    int line; 
     1038    /** The current column. */ 
     1039    int column; 
     1040    /** If the last character was a whitespace? */ 
     1041    int whitespace; 
     1042    /** If the last character was an indentation character (' ', '-', '?', ':')? */ 
     1043    int indention; 
     1044 
     1045    /** 
     1046     * @} 
     1047     */ 
     1048 
    8261049} yaml_emitter_t; 
    8271050 
     1051/** 
     1052 * Initialize an emitter. 
     1053 * 
     1054 * This function creates a new emitter object.  An application is responsible 
     1055 * for destroying the object using the @c yaml_emitter_delete function. 
     1056 * 
     1057 * @param[in]   emitter An empty parser object. 
     1058 * 
     1059 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1060 */ 
     1061 
     1062YAML_DECLARE(int) 
     1063yaml_emitter_initialize(yaml_emitter_t *emitter); 
     1064 
     1065/** 
     1066 * Destroy an emitter. 
     1067 * 
     1068 * @param[in]   emitter An emitter object. 
     1069 */ 
     1070 
     1071YAML_DECLARE(void) 
     1072yaml_emitter_delete(yaml_emitter_t *emitter); 
     1073 
     1074/** 
     1075 * Set a string output. 
     1076 * 
     1077 * The emitter will write the output characters to the @a output buffer of the 
     1078 * size @a size.  The emitter will set @a size_written to the number of written 
     1079 * bytes.  If the buffer is smaller than required, the emitter produces the 
     1080 * YAML_WRITE_ERROR error. 
     1081 * 
     1082 * @param[in]   emitter         An emitter object. 
     1083 * @param[in]   output          An output buffer. 
     1084 * @param[in]   size            The buffer size. 
     1085 * @param[in]   size_written    The pointer to save the number of written bytes. 
     1086 */ 
     1087 
     1088YAML_DECLARE(void) 
     1089yaml_emitter_set_output_string(yaml_emitter_t *emitter, 
     1090        unsigned char *output, size_t size, size_t *size_written); 
     1091 
     1092/** 
     1093 * Set a file output. 
     1094 * 
     1095 * @a file should be a file object open for writing.  The application is 
     1096 * responsible for closing the @a file. 
     1097 * 
     1098 * @param[in]   emitter An emitter object. 
     1099 * @param[in]   file    An open file. 
     1100 */ 
     1101 
     1102YAML_DECLARE(void) 
     1103yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file); 
     1104 
     1105/** 
     1106 * Set a generic output handler. 
     1107 * 
     1108 * @param[in]   emitter An emitter object. 
     1109 * @param[in]   handler A write handler. 
     1110 * @param[in]   data    Any application data for passing to the write handler. 
     1111 */ 
     1112 
     1113YAML_DECLARE(void) 
     1114yaml_emitter_set_output(yaml_emitter_t *emitter, 
     1115        yaml_write_handler_t *handler, void *data); 
     1116 
     1117/** 
     1118 * Set the output encoding. 
     1119 * 
     1120 * @param[in]   emitter     An emitter object. 
     1121 * @param[in]   encoding    The output encoding. 
     1122 */ 
     1123 
     1124YAML_DECLARE(void) 
     1125yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding); 
     1126 
     1127/** 
     1128 * Set if the output should be in the "canonical" format as in the YAML 
     1129 * specification. 
     1130 * 
     1131 * @param[in]   emitter     An emitter object. 
     1132 * @param[in]   canonical   If the output is canonical. 
     1133 */ 
     1134 
     1135YAML_DECLARE(void) 
     1136yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical); 
     1137 
     1138/** 
     1139 * Set the intendation increment. 
     1140 * 
     1141 * @param[in]   emitter     An emitter object. 
     1142 * @param[in]   indent      The indentation increment (> 1). 
     1143 */ 
     1144 
     1145YAML_DECLARE(void) 
     1146yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent); 
     1147 
     1148/** 
     1149 * Set the preferred line width. @c 0 means unlimited. 
     1150 * 
     1151 * @param[in]   emitter     An emitter object. 
     1152 * @param[in]   width       The preferred line width. 
     1153 */ 
     1154 
     1155YAML_DECLARE(void) 
     1156yaml_emitter_set_width(yaml_emitter_t *emitter, int width); 
     1157 
     1158/** 
     1159 * Set if unescaped non-ASCII characters are allowed. 
     1160 * 
     1161 * @param[in]   emitter     An emitter object. 
     1162 * @param[in]   unicode     If unescaped Unicode characters are allowed. 
     1163 */ 
     1164 
     1165YAML_DECLARE(void) 
     1166yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode); 
     1167 
     1168/** 
     1169 * Set the preferred line break. 
     1170 * 
     1171 * @param[in]   emitter     An emitter object. 
     1172 * @param[in]   line_break  The preferred line break. 
     1173 */ 
     1174 
     1175YAML_DECLARE(void) 
     1176yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break); 
     1177 
     1178/** 
     1179 * Emit an event. 
     1180 * 
     1181 * The event object may be generated using the @c yaml_parser_parse function. 
     1182 * The emitter will destroy the event object if the function succeeds.  If the 
     1183 * function fails, the application is responsible for destroing the event 
     1184 * object. 
     1185 * 
     1186 * @param[in]   emitter     An emitter object. 
     1187 * @param[in]   event       An event object. 
     1188 * 
     1189 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1190 */ 
     1191 
    8281192YAML_DECLARE(int) 
    8291193yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); 
     1194 
     1195/** 
     1196 * Emit the STREAM-START event. 
     1197 * 
     1198 * @param[in]   emitter     An emitter object. 
     1199 * @param[in]   encoding    The stream encoding. 
     1200 * 
     1201 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1202 */ 
    8301203 
    8311204YAML_DECLARE(int) 
     
    8331206        yaml_encoding_t encoding); 
    8341207 
    835 */ 
     1208/** 
     1209 * Emit the STREAM-END event. 
     1210 * 
     1211 * @param[in]   emitter     An emitter object. 
     1212 * 
     1213 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1214 */ 
     1215 
     1216YAML_DECLARE(int) 
     1217yaml_emitter_emit_stream_end(yaml_emitter_t *emitter); 
     1218 
     1219/** 
     1220 * Emit the DOCUMENT-START event. 
     1221 * 
     1222 * The @a implicit argument is considered as a stylistic parameter and may be 
     1223 * ignored by the emitter. 
     1224 * 
     1225 * @param[in]   emitter                 An emitter object. 
     1226 * @param[in]   version_directive       The %YAML directive value or @c NULL. 
     1227 * @param[in]   tag_directives_start    The beginning of the %TAG directives list. 
     1228 * @param[in]   tag_directives_end      The end of the %TAG directives list. 
     1229 * @param[in]   implicit                If the document start indicator is implicit. 
     1230 * 
     1231 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1232 */ 
     1233 
     1234YAML_DECLARE(int) 
     1235yaml_emitter_emit_document_start(yaml_emitter_t *emitter, 
     1236        yaml_version_directive_t *version_directive, 
     1237        yaml_tag_directive_t *tag_directives_start, 
     1238        yaml_tag_directive_t *tag_directives_end, 
     1239        int implicit); 
     1240 
     1241/** 
     1242 * Emit the DOCUMENT-END event. 
     1243 * 
     1244 * The @a implicit argument is considered as a stylistic parameter and may be 
     1245 * ignored by the emitter. 
     1246 * 
     1247 * @param[in]   emitter     An emitter object. 
     1248 * @param[in]   implicit    If the document end indicator is implicit. 
     1249 * 
     1250 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1251 */ 
     1252 
     1253YAML_DECLARE(int) 
     1254yaml_emitter_emit_document_end(yaml_emitter_t *emitter, int implicit); 
     1255 
     1256/** 
     1257 * Emit an ALIAS event. 
     1258 * 
     1259 * @param[in]   emitter     An emitter object. 
     1260 * @param[in]   anchor      The anchor value. 
     1261 * 
     1262 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1263 */ 
     1264 
     1265YAML_DECLARE(int) 
     1266yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_char_t *anchor); 
     1267 
     1268/** 
     1269 * Emit a SCALAR event. 
     1270 * 
     1271 * The @a style argument may be ignored by the emitter. 
     1272 * 
     1273 * Either the @a tag attribute or one of the @a plain_implicit and 
     1274 * @a quoted_implicit flags must be set. 
     1275 * 
     1276 * @param[in]   emitter         An emitter object. 
     1277 * @param[in]   anchor          The scalar anchor or @c NULL. 
     1278 * @param[in]   tag             The scalar tag or @c NULL. 
     1279 * @param[in]   value           The scalar value. 
     1280 * @param[in]   length          The length of the scalar value. 
     1281 * @param[in]   plain_implicit  If the tag may be omitted for the plain style. 
     1282 * @param[in]   quoted_implicit If the tag may be omitted for any non-plain style. 
     1283 * @param[in]   style           The scalar style. 
     1284 * 
     1285 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1286 */ 
     1287 
     1288YAML_DECLARE(int) 
     1289yaml_emitter_emit_scalar(yaml_emitter_t *emitter, 
     1290        yaml_char_t *anchor, yaml_char_t *tag, 
     1291        yaml_char_t *value, size_t length, 
     1292        int plain_implicit, int quoted_implicit, 
     1293        yaml_scalar_style_t style); 
     1294 
     1295/** 
     1296 * Emit a SEQUENCE-START event. 
     1297 * 
     1298 * The @a style argument may be ignored by the emitter. 
     1299 * 
     1300 * Either the @a tag attribute or the @a implicit flag must be set. 
     1301 * 
     1302 * @param[in]   emitter     An emitter object. 
     1303 * @param[in]   anchor      The sequence anchor or @c NULL. 
     1304 * @param[in]   tag         The sequence tag or @c NULL. 
     1305 * @param[in]   implicit    If the tag may be omitted. 
     1306 * @param[in]   style       The sequence style. 
     1307 * 
     1308 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1309 */ 
     1310 
     1311YAML_DECLARE(int) 
     1312yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, 
     1313        yaml_char_t *anchor, yaml_char_t *tag, int implicit, 
     1314        yaml_sequence_style_t style); 
     1315 
     1316/** 
     1317 * Emit a SEQUENCE-END event. 
     1318 * 
     1319 * @param[in]   emitter     An emitter object. 
     1320 * 
     1321 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1322 */ 
     1323 
     1324YAML_DECLARE(int) 
     1325yaml_emitter_emit_sequence_end(yaml_emitter_t *emitter); 
     1326 
     1327/** 
     1328 * Emit a MAPPING-START event. 
     1329 * 
     1330 * The @a style argument may be ignored by the emitter. 
     1331 * 
     1332 * Either the @a tag attribute or the @a implicit flag must be set. 
     1333 * 
     1334 * @param[in]   emitter     An emitter object. 
     1335 * @param[in]   anchor      The mapping anchor or @c NULL. 
     1336 * @param[in]   tag         The mapping tag or @c NULL. 
     1337 * @param[in]   implicit    If the tag may be omitted. 
     1338 * @param[in]   style       The mapping style. 
     1339 * 
     1340 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1341 */ 
     1342 
     1343YAML_DECLARE(int) 
     1344yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, 
     1345        yaml_char_t *anchor, yaml_char_t *tag, int implicit, 
     1346        yaml_mapping_style_t style); 
     1347 
     1348/** 
     1349 * Emit a MAPPING-END event. 
     1350 * 
     1351 * @param[in]   emitter     An emitter object. 
     1352 * 
     1353 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1354 */ 
     1355 
     1356YAML_DECLARE(int) 
     1357yaml_emitter_emit_mapping_end(yaml_emitter_t *emitter); 
     1358 
     1359/** 
     1360 * Flush the accumulated characters to the output. 
     1361 * 
     1362 * @param[in]   emitter     An emitter object. 
     1363 * 
     1364 * @returns @c 1 if the function succeeded, @c 0 on error. 
     1365 */ 
     1366 
     1367YAML_DECLARE(int) 
     1368yaml_emitter_flush(yaml_emitter_t *emitter); 
     1369 
     1370/** @} */ 
    8361371 
    8371372#ifdef __cplusplus 
  • libyaml/trunk/src/Makefile.am

    r201 r211  
    11AM_CPPFLAGS = -I$(top_srcdir)/include 
    22lib_LTLIBRARIES = libyaml.la 
    3 libyaml_la_SOURCES = api.c reader.c scanner.c parser.c 
     3libyaml_la_SOURCES = api.c reader.c scanner.c parser.c writer.c 
    44libyaml_la_LDFLAGS = -release $(YAML_LT_RELEASE) -version-info $(YAML_LT_CURRENT):$(YAML_LT_REVISION):$(YAML_LT_AGE) 
  • libyaml/trunk/src/api.c

    r210 r211  
    170170 
    171171    memset(parser, 0, sizeof(yaml_parser_t)); 
    172     if (!BUFFER_INIT(parser, parser->raw_buffer, RAW_BUFFER_SIZE)) 
    173         goto error; 
    174     if (!BUFFER_INIT(parser, parser->buffer, BUFFER_SIZE)) 
     172    if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE)) 
     173        goto error; 
     174    if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE)) 
    175175        goto error; 
    176176    if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE)) 
     
    335335 
    336336    parser->encoding = encoding; 
     337} 
     338 
     339/* 
     340 * Create a new emitter object. 
     341 */ 
     342 
     343YAML_DECLARE(int) 
     344yaml_emitter_initialize(yaml_emitter_t *emitter) 
     345{ 
     346    assert(emitter);    /* Non-NULL emitter object expected. */ 
     347 
     348    memset(emitter, 0, sizeof(yaml_emitter_t)); 
     349    if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE)) 
     350        goto error; 
     351    if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE)) 
     352        goto error; 
     353    if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE)) 
     354        goto error; 
     355    if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE)) 
     356        goto error; 
     357    if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE)) 
     358        goto error; 
     359    if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE)) 
     360        goto error; 
     361 
     362    return 1; 
     363 
     364error: 
     365 
     366    BUFFER_DEL(emitter, emitter->buffer); 
     367    BUFFER_DEL(emitter, emitter->raw_buffer); 
     368    STACK_DEL(emitter, emitter->states); 
     369    QUEUE_DEL(emitter, emitter->events); 
     370    STACK_DEL(emitter, emitter->indents); 
     371    STACK_DEL(emitter, emitter->tag_directives); 
     372 
     373    return 0; 
     374} 
     375 
     376/* 
     377 * Destroy an emitter object. 
     378 */ 
     379 
     380YAML_DECLARE(void) 
     381yaml_emitter_delete(yaml_emitter_t *emitter) 
     382{ 
     383    assert(emitter);    /* Non-NULL emitter object expected. */ 
     384 
     385    BUFFER_DEL(emitter, emitter->buffer); 
     386    BUFFER_DEL(emitter, emitter->raw_buffer); 
     387    STACK_DEL(emitter, emitter->states); 
     388    while (!QUEUE_EMPTY(emitter, emitter->events)) { 
     389        yaml_event_delete(&DEQUEUE(emitter, emitter->events)); 
     390    } 
     391    STACK_DEL(emitter, emitter->indents); 
     392    while (!STACK_EMPTY(empty, emitter->tag_directives)) { 
     393        yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives); 
     394        yaml_free(tag_directive.handle); 
     395        yaml_free(tag_directive.prefix); 
     396    } 
     397    STACK_DEL(emitter, emitter->tag_directives); 
     398 
     399    memset(emitter, 0, sizeof(yaml_emitter_t)); 
     400} 
     401 
     402/* 
     403 * String write handler. 
     404 */ 
     405 
     406static int 
     407yaml_string_write_handler(void *data, unsigned char *buffer, size_t size) 
     408{ 
     409    yaml_emitter_t *emitter = data; 
     410 
     411    if (emitter->output.string.size + *emitter->output.string.size_written 
     412            < size) { 
     413        memcpy(emitter->output.string.buffer 
     414                + *emitter->output.string.size_written, 
     415                buffer, 
     416                emitter->output.string.size 
     417                - *emitter->output.string.size_written); 
     418        *emitter->output.string.size_written = emitter->output.string.size; 
     419        return 0; 
     420    } 
     421 
     422    memcpy(emitter->output.string.buffer 
     423            + *emitter->output.string.size_written, buffer, size); 
     424    *emitter->output.string.size_written += size; 
     425    return 1; 
     426} 
     427 
     428/* 
     429 * File write handler. 
     430 */ 
     431 
     432static int 
     433yaml_file_write_handler(void *data, unsigned char *buffer, size_t size) 
     434{ 
     435    yaml_emitter_t *emitter = data; 
     436 
     437    return (fwrite(buffer, 1, size, emitter->output.file) == size); 
     438} 
     439/* 
     440 * Set a string output. 
     441 */ 
     442 
     443YAML_DECLARE(void) 
     444yaml_emitter_set_output_string(yaml_emitter_t *emitter, 
     445        unsigned char *output, size_t size, size_t *size_written) 
     446{ 
     447    assert(emitter);    /* Non-NULL emitter object expected. */ 
     448    assert(!emitter->write_handler);    /* You can set the output only once. */ 
     449    assert(output);     /* Non-NULL output string expected. */ 
     450 
     451    emitter->write_handler = yaml_string_write_handler; 
     452    emitter->write_handler_data = emitter; 
     453 
     454    emitter->output.string.buffer = output; 
     455    emitter->output.string.size = size; 
     456    emitter->output.string.size_written = size_written; 
     457    *size_written = 0; 
     458} 
     459 
     460/* 
     461 * Set a file output. 
     462 */ 
     463 
     464YAML_DECLARE(void) 
     465yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file) 
     466{ 
     467    assert(emitter);    /* Non-NULL emitter object expected. */ 
     468    assert(!emitter->write_handler);    /* You can set the output only once. */ 
     469    assert(file);       /* Non-NULL file object expected. */ 
     470 
     471    emitter->write_handler = yaml_file_write_handler; 
     472    emitter->write_handler_data = emitter; 
     473 
     474    emitter->output.file = file; 
     475} 
     476 
     477/* 
     478 * Set a generic output handler. 
     479 */ 
     480 
     481YAML_DECLARE(void) 
     482yaml_emitter_set_output(yaml_emitter_t *emitter, 
     483        yaml_write_handler_t *handler, void *data) 
     484{ 
     485    assert(emitter);    /* Non-NULL emitter object expected. */ 
     486    assert(!emitter->write_handler);    /* You can set the output only once. */ 
     487    assert(handler);    /* Non-NULL handler object expected. */ 
     488 
     489    emitter->write_handler = handler; 
     490    emitter->write_handler_data = data; 
     491} 
     492 
     493/* 
     494 * Set the output encoding. 
     495 */ 
     496 
     497YAML_DECLARE(void) 
     498yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding) 
     499{ 
     500    assert(emitter);    /* Non-NULL emitter object expected. */ 
     501    assert(!emitter->encoding);     /* You can set encoding only once. */ 
     502 
     503    emitter->encoding = encoding; 
     504} 
     505 
     506/* 
     507 * Set the canonical output style. 
     508 */ 
     509 
     510YAML_DECLARE(void) 
     511yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical) 
     512{ 
     513    assert(emitter);    /* Non-NULL emitter object expected. */ 
     514 
     515    emitter->canonical = (canonical != 0); 
     516} 
     517 
     518/* 
     519 * Set the indentation increment. 
     520 */ 
     521 
     522YAML_DECLARE(void) 
     523yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent) 
     524{ 
     525    assert(emitter);    /* Non-NULL emitter object expected. */ 
     526 
     527    emitter->best_indent = (1 < indent && indent < 10) ? indent : 2; 
     528} 
     529 
     530/* 
     531 * Set the preferred line width. 
     532 */ 
     533 
     534YAML_DECLARE(void) 
     535yaml_emitter_set_width(yaml_emitter_t *emitter, int width) 
     536{ 
     537    assert(emitter);    /* Non-NULL emitter object expected. */ 
     538 
     539    emitter->best_width = (width > 0) ? width : 0; 
     540} 
     541 
     542/* 
     543 * Set if unescaped non-ASCII characters are allowed. 
     544 */ 
     545 
     546YAML_DECLARE(void) 
     547yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode) 
     548{ 
     549    assert(emitter);    /* Non-NULL emitter object expected. */ 
     550 
     551    emitter->unicode = (unicode != 0); 
     552} 
     553 
     554/* 
     555 * Set the preferred line break character. 
     556 */ 
     557 
     558YAML_DECLARE(void) 
     559yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break) 
     560{ 
     561    assert(emitter);    /* Non-NULL emitter object expected. */ 
     562 
     563    emitter->line_break = line_break; 
    337564} 
    338565 
  • libyaml/trunk/src/parser.c

    r210 r211  
    4343 
    4444/* 
    45  * Event initializers. 
    46  */ 
    47  
    48 #define EVENT_INIT(event,event_type,event_start_mark,event_end_mark)            \ 
    49     (memset(&(event), 0, sizeof(yaml_event_t)),                                 \ 
    50      (event).type = (event_type),                                               \ 
    51      (event).start_mark = (event_start_mark),                                   \ 
    52      (event).end_mark = (event_end_mark)) 
    53  
    54 #define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark)       \ 
    55     (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)),       \ 
    56      (event).data.stream_start.encoding = (event_encoding)) 
    57  
    58 #define STREAM_END_EVENT_INIT(event,start_mark,end_mark)                        \ 
    59     (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) 
    60  
    61 #define DOCUMENT_START_EVENT_INIT(event,event_version_directive,                \ 
    62         event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \ 
    63     (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)),     \ 
    64      (event).data.document_start.version_directive = (event_version_directive), \ 
    65      (event).data.document_start.tag_directives.start = (event_tag_directives_start),   \ 
    66      (event).data.document_start.tag_directives.end = (event_tag_directives_end),   \ 
    67      (event).data.document_start.implicit = (event_implicit)) 
    68  
    69 #define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark)       \ 
    70     (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)),       \ 
    71      (event).data.document_end.implicit = (event_implicit)) 
    72  
    73 #define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark)                \ 
    74     (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)),              \ 
    75      (event).data.alias.anchor = (event_anchor)) 
    76  
    77 #define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length,    \ 
    78         event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark)    \ 
    79     (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)),             \ 
    80      (event).data.scalar.anchor = (event_anchor),                               \ 
    81      (event).data.scalar.tag = (event_tag),                                     \ 
    82      (event).data.scalar.value = (event_value),                                 \ 
    83      (event).data.scalar.length = (event_length),                               \ 
    84      (event).data.scalar.plain_implicit = (event_plain_implicit),               \ 
    85      (event).data.scalar.quoted_implicit = (event_quoted_implicit),             \ 
    86      (event).data.scalar.style = (event_style)) 
    87  
    88 #define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag,                 \ 
    89         event_implicit,event_style,start_mark,end_mark)                         \ 
    90     (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)),     \ 
    91      (event).data.sequence_start.anchor = (event_anchor),                       \ 
    92      (event).data.sequence_start.tag = (event_tag),                             \ 
    93      (event).data.sequence_start.implicit = (event_implicit),                   \ 
    94      (event).data.sequence_start.style = (event_style)) 
    95  
    96 #define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark)                      \ 
    97     (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) 
    98  
    99 #define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag,                  \ 
    100         event_implicit,event_style,start_mark,end_mark)                         \ 
    101     (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)),      \ 
    102      (event).data.mapping_start.anchor = (event_anchor),                        \ 
    103      (event).data.mapping_start.tag = (event_tag),                              \ 
    104      (event).data.mapping_start.implicit = (event_implicit),                    \ 
    105      (event).data.mapping_start.style = (event_style)) 
    106  
    107 #define MAPPING_END_EVENT_INIT(event,start_mark,end_mark)                       \ 
    108     (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) 
    109  
    110 /* 
    11145 * Peek the next token in the token queue. 
    11246 */ 
  • libyaml/trunk/src/scanner.c

    r210 r211  
    762762 
    763763/* 
    764  * Token initializers. 
    765  */ 
    766  
    767 #define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark)            \ 
    768     (memset(&(token), 0, sizeof(yaml_token_t)),                                 \ 
    769      (token).type = (token_type),                                               \ 
    770      (token).start_mark = (token_start_mark),                                   \ 
    771      (token).end_mark = (token_end_mark)) 
    772  
    773 #define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark)       \ 
    774     (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)),       \ 
    775      (token).data.stream_start.encoding = (token_encoding)) 
    776  
    777 #define STREAM_END_TOKEN_INIT(token,start_mark,end_mark)                        \ 
    778     (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark))) 
    779  
    780 #define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark)                 \ 
    781     (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)),              \ 
    782      (token).data.alias.value = (token_value)) 
    783  
    784 #define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark)                \ 
    785     (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)),             \ 
    786      (token).data.anchor.value = (token_value)) 
    787  
    788 #define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark)     \ 
    789     (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)),                \ 
    790      (token).data.tag.handle = (token_handle),                                  \ 
    791      (token).data.tag.suffix = (token_suffix)) 
    792  
    793 #define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark)   \ 
    794     (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)),             \ 
    795      (token).data.scalar.value = (token_value),                                 \ 
    796      (token).data.scalar.length = (token_length),                               \ 
    797      (token).data.scalar.style = (token_style)) 
    798  
    799 #define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark)     \ 
    800     (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)),  \ 
    801      (token).data.version_directive.major = (token_major),                      \ 
    802      (token).data.version_directive.minor = (token_minor)) 
    803  
    804 #define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark)       \ 
    805     (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)),      \ 
    806      (token).data.tag_directive.handle = (token_handle),                        \ 
    807      (token).data.tag_directive.prefix = (token_prefix)) 
    808  
    809 /* 
    810764 * Public API declarations. 
    811765 */ 
  • libyaml/trunk/src/yaml_private.h

    r208 r211  
    3939 
    4040/* 
    41  * The size of the raw buffer. 
    42  */ 
    43  
    44 #define RAW_BUFFER_SIZE 16384 
    45  
    46 /* 
    47  * The size of the buffer. 
     41 * The size of the input raw buffer. 
     42 */ 
     43 
     44#define INPUT_RAW_BUFFER_SIZE  16384 
     45 
     46/* 
     47 * The size of the input buffer. 
    4848 * 
    4949 * It should be possible to decode the whole raw buffer. 
    5050 */ 
    5151 
    52 #define BUFFER_SIZE     (RAW_BUFFER_SIZE*3) 
     52#define INPUT_BUFFER_SIZE       (INPUT_RAW_BUFFER_SIZE*3) 
     53 
     54/* 
     55 * The size of the output buffer. 
     56 */ 
     57 
     58#define OUTPUT_BUFFER_SIZE      16384 
     59 
     60/* 
     61 * The size of the output raw buffer. 
     62 * 
     63 * It should be possible to encode the whole output buffer. 
     64 */ 
     65 
     66#define OUTPUT_RAW_BUFFER_SIZE  (OUTPUT_BUFFER_SIZE*2+2) 
    5367 
    5468/* 
     
    204218         0)) 
    205219 
     220/* 
     221 * Token initializers. 
     222 */ 
     223 
     224#define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark)            \ 
     225    (memset(&(token), 0, sizeof(yaml_token_t)),                                 \ 
     226     (token).type = (token_type),                                               \ 
     227     (token).start_mark = (token_start_mark),                                   \ 
     228     (token).end_mark = (token_end_mark)) 
     229 
     230#define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark)       \ 
     231    (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)),       \ 
     232     (token).data.stream_start.encoding = (token_encoding)) 
     233 
     234#define STREAM_END_TOKEN_INIT(token,start_mark,end_mark)                        \ 
     235    (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark))) 
     236 
     237#define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark)                 \ 
     238    (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)),              \ 
     239     (token).data.alias.value = (token_value)) 
     240 
     241#define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark)                \ 
     242    (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)),             \ 
     243     (token).data.anchor.value = (token_value)) 
     244 
     245#define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark)     \ 
     246    (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)),                \ 
     247     (token).data.tag.handle = (token_handle),                                  \ 
     248     (token).data.tag.suffix = (token_suffix)) 
     249 
     250#define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark)   \ 
     251    (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)),             \ 
     252     (token).data.scalar.value = (token_value),                                 \ 
     253     (token).data.scalar.length = (token_length),                               \ 
     254     (token).data.scalar.style = (token_style)) 
     255 
     256#define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark)     \ 
     257    (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)),  \ 
     258     (token).data.version_directive.major = (token_major),                      \ 
     259     (token).data.version_directive.minor = (token_minor)) 
     260 
     261#define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark)       \ 
     262    (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)),      \ 
     263     (token).data.tag_directive.handle = (token_handle),                        \ 
     264     (token).data.tag_directive.prefix = (token_prefix)) 
     265 
     266/* 
     267 * Event initializers. 
     268 */ 
     269 
     270#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark)            \ 
     271    (memset(&(event), 0, sizeof(yaml_event_t)),                                 \ 
     272     (event).type = (event_type),                                               \ 
     273     (event).start_mark = (event_start_mark),                                   \ 
     274     (event).end_mark = (event_end_mark)) 
     275 
     276#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark)       \ 
     277    (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)),       \ 
     278     (event).data.stream_start.encoding = (event_encoding)) 
     279 
     280#define STREAM_END_EVENT_INIT(event,start_mark,end_mark)                        \ 
     281    (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) 
     282 
     283#define DOCUMENT_START_EVENT_INIT(event,event_version_directive,                \ 
     284        event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \ 
     285    (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)),     \ 
     286     (event).data.document_start.version_directive = (event_version_directive), \ 
     287     (event).data.document_start.tag_directives.start = (event_tag_directives_start),   \ 
     288     (event).data.document_start.tag_directives.end = (event_tag_directives_end),   \ 
     289     (event).data.document_start.implicit = (event_implicit)) 
     290 
     291#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark)       \ 
     292    (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)),       \ 
     293     (event).data.document_end.implicit = (event_implicit)) 
     294 
     295#define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark)                \ 
     296    (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)),              \ 
     297     (event).data.alias.anchor = (event_anchor)) 
     298 
     299#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length,    \ 
     300        event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark)    \ 
     301    (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)),             \ 
     302     (event).data.scalar.anchor = (event_anchor),                               \ 
     303     (event).data.scalar.tag = (event_tag),                                     \ 
     304     (event).data.scalar.value = (event_value),                                 \ 
     305     (event).data.scalar.length = (event_length),                               \ 
     306     (event).data.scalar.plain_implicit = (event_plain_implicit),               \ 
     307     (event).data.scalar.quoted_implicit = (event_quoted_implicit),             \ 
     308     (event).data.scalar.style = (event_style)) 
     309 
     310#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag,                 \ 
     311        event_implicit,event_style,start_mark,end_mark)                         \ 
     312    (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)),     \ 
     313     (event).data.sequence_start.anchor = (event_anchor),                       \ 
     314     (event).data.sequence_start.tag = (event_tag),                             \ 
     315     (event).data.sequence_start.implicit = (event_implicit),                   \ 
     316     (event).data.sequence_start.style = (event_style)) 
     317 
     318#define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark)                      \ 
     319    (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) 
     320 
     321#define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag,                  \ 
     322        event_implicit,event_style,start_mark,end_mark)                         \ 
     323    (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)),      \ 
     324     (event).data.mapping_start.anchor = (event_anchor),                        \ 
     325     (event).data.mapping_start.tag = (event_tag),                              \ 
     326     (event).data.mapping_start.implicit = (event_implicit),                    \ 
     327     (event).data.mapping_start.style = (event_style)) 
     328 
     329#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark)                       \ 
     330    (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) 
     331 
Note: See TracChangeset for help on using the changeset viewer.