mkrf 0.1.0

data/test/sample_files/syck-0.55/lib/yaml2byte.c

@@ -0,0 +1,250 @@
+/*
+ * yaml2byte.c
+ *
+ * $Author: why $
+ * $Date: 2004/08/02 17:32:35 $
+ *
+ * Copyright (C) 2003 why the lucky stiff, clark evans
+ *
+ *   WARNING WARNING WARNING  --- THIS IS *NOT JUST* PLAYING
+ *   ANYMORE! -- WHY HAS EMBRACED THIS AS THE REAL THING!
+ */ 
+#include <syck.h>
+#include <assert.h>
+#define YAMLBYTE_UTF8
+#include "yamlbyte.h"
+
+#include <stdio.h>
+#define TRACE0(a)  \
+    do { printf(a); printf("\n"); fflush(stdout); } while(0)
+#define TRACE1(a,b) \
+    do { printf(a,b); printf("\n"); fflush(stdout); } while(0)
+#define TRACE2(a,b,c) \
+    do { printf(a,b,c); printf("\n"); fflush(stdout); } while(0)
+#define TRACE3(a,b,c,d) \
+    do { printf(a,b,c,d); printf("\n"); fflush(stdout); } while(0)
+
+/* Reinvent the wheel... */
+#define CHUNKSIZE 64
+#define HASH ((long)0xCAFECAFE)
+typedef struct {
+   long hash;
+   char *buffer;
+   long length;
+   long remaining;
+   int  printed;
+} bytestring_t;
+bytestring_t *bytestring_alloc() {
+    bytestring_t *ret; 
+    /*TRACE0("bytestring_alloc()");*/
+    ret = S_ALLOC(bytestring_t);
+    ret->hash   = HASH;
+    ret->length = CHUNKSIZE;
+    ret->remaining = ret->length;
+    ret->buffer = S_ALLOC_N(char, ret->length + 1 );
+    ret->buffer[0] = 0;
+    ret->printed = 0;
+    return ret;
+}
+void bytestring_append(bytestring_t *str, char code, 
+                       char *start, char *finish) 
+{
+    long grow;
+    long length = 2;   /* CODE + LF */
+    char *curr;
+    assert(str && HASH == str->hash);
+    /*TRACE0("bytestring_append()");*/
+    if(start) {
+        if(!finish)
+            finish = start + strlen(start);
+        length += (finish-start);
+    }
+    if(length > str->remaining) {
+        grow = (length - str->remaining) + CHUNKSIZE;
+        str->remaining += grow;
+        str->length    += grow; 
+        str->buffer = S_REALLOC_N( str->buffer, char, str->length + 1 );
+        assert(str->buffer);
+    }
+    curr = str->buffer + (str->length - str->remaining);
+    *curr = code;
+    curr += 1;
+    if(start) 
+        while(start < finish)
+            *curr ++ = *start ++;
+    *curr = '\n';
+    curr += 1;
+    *curr = 0;
+    str->remaining = str->remaining - length;
+    assert( (str->buffer + str->length) - str->remaining );
+}
+void bytestring_extend(bytestring_t *str, bytestring_t *ext)
+{
+    char *from;
+    char *curr;
+    char *stop;
+    long grow;
+    long length;
+    assert(str && HASH == str->hash);
+    assert(ext && HASH == ext->hash);
+    if(ext->printed) {
+        assert(ext->buffer[0] ==YAMLBYTE_ANCHOR);
+        curr = ext->buffer;
+        while( '\n' != *curr)
+            curr++;
+        bytestring_append(str, YAMLBYTE_ALIAS, ext->buffer + 1, curr);
+    } else {
+        ext->printed = 1;
+        length  = (ext->length - ext->remaining);
+        if(length > str->remaining) {
+            grow = (length - str->remaining) + CHUNKSIZE;
+            str->remaining += grow;
+            str->length    += grow; 
+            str->buffer = S_REALLOC_N( str->buffer, char, str->length + 1 );
+        }
+        curr = str->buffer + (str->length - str->remaining);
+        from = ext->buffer;
+        stop = ext->buffer + length;
+        while( from < stop )
+            *curr ++ = *from ++;
+        *curr = 0;
+        str->remaining = str->remaining - length;
+        assert( (str->buffer + str->length) - str->remaining );
+    }
+}
+
+/* convert SyckNode into yamlbyte_buffer_t objects */
+SYMID
+syck_yaml2byte_handler(p, n)
+    SyckParser *p;
+    SyckNode *n;
+{
+    SYMID oid;
+    long i;
+    char ch;
+    char nextcode;
+    char *start;
+    char *current;
+    char *finish;
+    bytestring_t *val = NULL;
+    bytestring_t *sav = NULL;
+    /*TRACE0("syck_yaml2byte_handler()");*/
+    val = bytestring_alloc();
+    if(n->anchor) bytestring_append(val,YAMLBYTE_ANCHOR, n->anchor, NULL);
+    if ( n->type_id )
+    {
+        if ( p->taguri_expansion )
+        {
+            bytestring_append(val,YAMLBYTE_TRANSFER, n->type_id, NULL);
+        }
+        else
+        {
+            char *type_tag = S_ALLOC_N( char, strlen( n->type_id ) + 1 );
+            type_tag[0] = '\0';
+            strcat( type_tag, "!" );
+            strcat( type_tag, n->type_id );
+            bytestring_append( val, YAMLBYTE_TRANSFER, type_tag, NULL);
+        }
+    }
+    switch (n->kind)
+    {
+        case syck_str_kind:
+            nextcode = YAMLBYTE_SCALAR;
+            start  = n->data.str->ptr;
+            finish = start + n->data.str->len - 1;
+            current = start;
+            /*TRACE2("SCALAR: %s %d", start, n->data.str->len); */
+            while(1) {
+                ch = *current;
+                if('\n' == ch || 0 == ch || current > finish) {
+                    if(current >= start) {
+                        bytestring_append(val, nextcode, start, current);
+                        nextcode = YAMLBYTE_CONTINUE;
+                    }
+                    start = current + 1;
+                    if(current > finish)
+                    {
+                        break;
+                    }
+                    else if('\n' == ch )
+                    {
+                        bytestring_append(val,YAMLBYTE_NEWLINE,NULL,NULL);
+                    }
+                    else if(0 == ch)
+                    {
+                        bytestring_append(val,YAMLBYTE_NULLCHAR,NULL,NULL);
+                    }
+                    else 
+                    {
+                        assert("oops");
+                    }
+                }
+                current += 1;
+            }
+        break;
+        case syck_seq_kind:
+            bytestring_append(val,YAMLBYTE_SEQUENCE,NULL,NULL);
+            for ( i = 0; i < n->data.list->idx; i++ )
+            {
+                oid = syck_seq_read( n, i );
+                syck_lookup_sym( p, oid, (char **)&sav );
+                bytestring_extend(val, sav);
+            }
+            bytestring_append(val,YAMLBYTE_END_BRANCH,NULL,NULL);
+        break;
+        case syck_map_kind:
+            bytestring_append(val,YAMLBYTE_MAPPING,NULL,NULL);
+            for ( i = 0; i < n->data.pairs->idx; i++ )
+            {
+                oid = syck_map_read( n, map_key, i );
+                syck_lookup_sym( p, oid, (char **)&sav );
+                bytestring_extend(val, sav);
+                oid = syck_map_read( n, map_value, i );
+                syck_lookup_sym( p, oid, (char **)&sav );
+                bytestring_extend(val, sav);
+            }
+            bytestring_append(val,YAMLBYTE_END_BRANCH,NULL,NULL);
+        break;
+    }
+    oid = syck_add_sym( p, (char *) val );
+    /*TRACE1("Saving: %s", val->buffer );*/
+    return oid;
+}
+
+char *
+syck_yaml2byte(char *yamlstr)
+{
+    SYMID oid;
+    char *ret;
+    bytestring_t *sav; 
+
+    SyckParser *parser = syck_new_parser();
+    syck_parser_str_auto( parser, yamlstr, NULL );
+    syck_parser_handler( parser, syck_yaml2byte_handler );
+    syck_parser_error_handler( parser, NULL );
+    syck_parser_implicit_typing( parser, 1 );
+    syck_parser_taguri_expansion( parser, 1 );
+    oid = syck_parse( parser );
+    syck_lookup_sym( parser, oid, (char **)&sav );
+
+    ret = S_ALLOC_N( char, strlen( sav->buffer ) + 3 );
+    ret[0] = '\0';
+    strcat( ret, "D\n" );
+    strcat( ret, sav->buffer );
+
+    syck_free_parser( parser );
+    return ret;
+}
+
+#ifdef TEST_YBEXT
+#include <stdio.h>
+int main() {
+   char *yaml = "test: 1\nand: \"with new\\nline\\n\"\nalso: &3 three\nmore: *3";
+   printf("--- # YAML \n");
+   printf(yaml);
+   printf("\n...\n");
+   printf(syck_yaml2byte(yaml));
+   return 0;
+}
+#endif
+

data/test/sample_files/syck-0.55/lib/yamlbyte.h

@@ -0,0 +1,170 @@
+/*  yamlbyte.h
+ *
+ *  The YAML bytecode "C" interface header file.   See the YAML bytecode
+ *  reference for bytecode sequence rules and for the meaning of each
+ *  bytecode.
+ */
+
+#ifndef YAMLBYTE_H
+#define YAMLBYTE_H
+#include <stddef.h>
+
+/* define what a character is */
+typedef unsigned char yamlbyte_utf8_t;
+typedef unsigned short yamlbyte_utf16_t;
+#ifdef YAMLBYTE_UTF8
+  #ifdef YAMLBYTE_UTF16
+    #error Must only define YAMLBYTE_UTF8 or YAMLBYTE_UTF16
+  #endif
+  typedef yamlbyte_utf8_t yamlbyte_char_t;
+#else
+  #ifdef YAMLBYTE_UTF16
+    typedef yamlbyte_utf16_t yamlbyte_char_t;
+  #else
+    #error Must define YAMLBYTE_UTF8 or YAMLBYTE_UTF16
+  #endif
+#endif
+
+/* specify list of bytecodes */
+#define YAMLBYTE_FINISH          ((yamlbyte_char_t) 0)
+#define YAMLBYTE_DOCUMENT        ((yamlbyte_char_t)'D')
+#define YAMLBYTE_DIRECTIVE       ((yamlbyte_char_t)'V')
+#define YAMLBYTE_PAUSE           ((yamlbyte_char_t)'P')
+#define YAMLBYTE_MAPPING         ((yamlbyte_char_t)'M')
+#define YAMLBYTE_SEQUENCE        ((yamlbyte_char_t)'Q')
+#define YAMLBYTE_END_BRANCH      ((yamlbyte_char_t)'E')
+#define YAMLBYTE_SCALAR          ((yamlbyte_char_t)'S')
+#define YAMLBYTE_CONTINUE        ((yamlbyte_char_t)'C')
+#define YAMLBYTE_NEWLINE         ((yamlbyte_char_t)'N')
+#define YAMLBYTE_NULLCHAR        ((yamlbyte_char_t)'Z')
+#define YAMLBYTE_ANCHOR          ((yamlbyte_char_t)'A')
+#define YAMLBYTE_ALIAS           ((yamlbyte_char_t)'R')
+#define YAMLBYTE_TRANSFER        ((yamlbyte_char_t)'T')
+/* formatting bytecodes */
+#define YAMLBYTE_COMMENT         ((yamlbyte_char_t)'c')
+#define YAMLBYTE_INDENT          ((yamlbyte_char_t)'i')
+#define YAMLBYTE_STYLE           ((yamlbyte_char_t)'s')
+/* other bytecodes */
+#define YAMLBYTE_LINE_NUMBER     ((yamlbyte_char_t)'#')
+#define YAMLBYTE_WHOLE_SCALAR    ((yamlbyte_char_t)'<')
+#define YAMLBYTE_NOTICE          ((yamlbyte_char_t)'!')
+#define YAMLBYTE_SPAN            ((yamlbyte_char_t)')')
+#define YAMLBYTE_ALLOC           ((yamlbyte_char_t)'@')
+
+/* second level style bytecodes, ie "s>" */
+#define YAMLBYTE_FLOW            ((yamlbyte_char_t)'>')
+#define YAMLBYTE_LITERAL         ((yamlbyte_char_t)'|')
+#define YAMLBYTE_BLOCK           ((yamlbyte_char_t)'b')
+#define YAMLBYTE_PLAIN           ((yamlbyte_char_t)'p')
+#define YAMLBYTE_INLINE_MAPPING  ((yamlbyte_char_t)'{')
+#define YAMLBYTE_INLINE_SEQUENCE ((yamlbyte_char_t)'[')
+#define YAMLBYTE_SINGLE_QUOTED   ((yamlbyte_char_t)39)
+#define YAMLBYTE_DOUBLE_QUOTED   ((yamlbyte_char_t)'"')
+
+/*
+ * The "C" API has two variants, one based on instructions,
+ * with events delivered via pointers; and the other one
+ * is character based where one or more instructions are
+ * serialized into a buffer.
+ *
+ * Note: In the instruction based API, WHOLE_SCALAR does
+ *       not have the '<here' marshalling stuff.
+ */
+
+typedef void * yamlbyte_consumer_t;
+typedef void * yamlbyte_producer_t;
+
+/* push and pull APIs need a way to communicate results */
+typedef enum {
+    YAMLBYTE_OK          = 0,     /* proceed                        */
+    YAMLBYTE_E_MEMORY    = 'M',   /* could not allocate memory      */
+    YAMLBYTE_E_READ      = 'R',   /* input stream read error        */
+    YAMLBYTE_E_WRITE     = 'W',   /* output stream write error      */
+    YAMLBYTE_E_OTHER     = '?',   /* some other error condition     */
+    YAMLBYTE_E_PARSE     = 'P',   /* parse error, check bytecodes   */
+} yamlbyte_result_t;
+ 
+typedef const yamlbyte_char_t *yamlbyte_buff_t; 
+
+/* 
+ *  The "Instruction" API 
+ */
+
+typedef struct yaml_instruction {
+    yamlbyte_char_t bytecode;
+    yamlbyte_buff_t start;
+    yamlbyte_buff_t finish;  /* open range, *finish is _not_ part */
+} *yamlbyte_inst_t;
+
+/* producer pushes the instruction with one bytecode event to the 
+ * consumer; if the consumer's result is not YAMLBYTE_OK, then
+ * the producer should stop */
+typedef
+  yamlbyte_result_t
+   (*yamlbyte_push_t)(
+     yamlbyte_consumer_t self,
+     yamlbyte_inst_t  inst
+   );
+
+/* consumer pulls a bytecode instruction from the producer; in this
+ * case the instruction (and is buffer) are owned by the producer and
+ * will remain valid till the pull function is called once again;
+ * if the instruction is NULL, then there are no more results; and
+ * it is important to call the pull function till it returns NULL so 
+ * that the producer can clean up its memory allocations */
+typedef 
+   yamlbyte_result_t
+    (*yamlbyte_pull_t)(
+      yamlbyte_producer_t self,
+      yamlbyte_inst_t *inst   /* to be filled in by the producer */
+    ); 
+
+/*
+ *  Buffer based API
+ */
+
+/* producer pushes a null terminated buffer filled with one or more
+ * bytecode events to the consumer; if the consumer's result is not
+ * YAMLBYTE_OK, then the producer should stop */
+typedef
+  yamlbyte_result_t
+   (*yamlbyte_pushbuff_t)(
+     yamlbyte_consumer_t self,
+     yamlbyte_buff_t  buff
+   );
+
+/* consumer pulls bytecode events from the producer; in this case
+ * the buffer is owned by the producer, and will remain valid till
+ * the pull function is called once again; if the buffer pointer
+ * is set to NULL, then there are no more results; it is important
+ * to call the pull function till it returns NULL so that the
+ * producer can clean up its memory allocations */
+typedef 
+   yamlbyte_result_t
+    (*yamlbyte_pullbuff_t)(
+      yamlbyte_producer_t self,
+      yamlbyte_buff_t *buff   /* to be filled in by the producer */
+    ); 
+
+/* convert a pull interface to a push interface; the reverse process
+ * requires threads and thus is language dependent */
+#define YAMLBYTE_PULL2PUSH(pull,producer,push,consumer,result)       \
+    do {                                                         \
+        yamlbyte_pullbuff_t _pull = (pull);                              \
+        yamlbyte_pushbuff_t _push = (push);                              \
+        yamlbyte_result_t _result = YAMLBYTE_OK;                         \
+        yamlbyte_producer_t _producer = (producer);                  \
+        yamlbyte_consumer_t _consumer = (consumer);                  \
+        while(1) {                                               \
+            yamlbyte_buff_t buff = NULL;                           \
+            _result = _pull(_producer,&buff);                    \
+            if(YAMLBYTE_OK != result || NULL == buff)                \
+                break;                                           \
+            _result = _push(_consumer,buff);                     \
+            if(YAMLBYTE_OK != result)                                \
+                break;                                           \
+        }                                                        \
+        (result) = _result;                                      \
+    } while(0)
+
+#endif

data/test/sample_files/syck-0.55/stamp-h1

@@ -0,0 +1 @@
+timestamp for config.h

data/test/sample_files/syck-0.55/tests/Basic.c

@@ -0,0 +1,141 @@
+//
+// Basic.c
+//
+// $Author: why $
+// $Date: 2004/05/15 02:31:52 $
+//
+// Copyright (C) 2003 why the lucky stiff
+//
+
+#include "syck.h"
+#include "CuTest.h"
+
+//
+// Test allocating a single node of kind 'str'.
+//
+void 
+TestSyckNodeAlloc( CuTest *tc )
+{
+    SyckNode* n;
+
+    n = syck_new_str( "YAML", scalar_plain );
+
+    CuAssert( tc, "Allocated 'str' node reporting as 'seq'.", n->kind != syck_seq_kind );
+    CuAssert( tc, "Allocated 'str' node reporting as 'map'.", n->kind != syck_map_kind );
+    CuAssert( tc, "Allocated 'str' not reporting as 'str'.", n->kind == syck_str_kind );
+    CuAssertStrEquals( tc, "YAML", syck_str_read( n ) );
+
+    syck_free_node( n );
+}
+
+//
+// Test building a simple sequence
+//
+void
+TestSyckSeqAlloc( CuTest *tc )
+{
+    SyckNode *n;
+    SYMID id;
+
+    n = syck_new_seq( 1 );
+    for ( id = 11001; id < 23000; id += 24 )
+    {
+        syck_seq_add( n, id );
+    }
+
+    CuAssert( tc, "Invalid value at '0'", 1 == syck_seq_read( n, 0 ) );
+    CuAssert( tc, "Invalid value at '1'", 11001 == syck_seq_read( n, 1 ) );
+    CuAssert( tc, "Invalid value at '200'", 15801 == syck_seq_read( n, 201 ) );
+
+    syck_free_node( n );
+}
+
+//
+// Test building a simple map
+//
+void
+TestSyckMapAlloc( CuTest *tc )
+{
+    SyckNode *n;
+
+    n = syck_new_map( 24556, 24557 );
+    syck_map_add( n, 24558, 24559 );
+    syck_map_add( n, 24658, 24659 );
+    syck_map_add( n, 24758, 24759 );
+    syck_map_add( n, 24858, 24859 );
+    syck_map_add( n, 24958, 24959 );
+    syck_map_add( n, 24058, 24059 );
+    syck_map_add( n, 24158, 24159 );
+
+    CuAssert( tc, "Invalid key at '0'.", 24556 == syck_map_read( n, map_key, 0 ) );
+    CuAssert( tc, "Invalid key at '1'.", 24558 == syck_map_read( n, map_key, 1 ) );
+    CuAssert( tc, "Invalid key at '2'.", 24658 == syck_map_read( n, map_key, 2 ) );
+    CuAssert( tc, "Invalid key at '3'.", 24758 == syck_map_read( n, map_key, 3 ) );
+    CuAssert( tc, "Invalid key at '4'.", 24858 == syck_map_read( n, map_key, 4 ) );
+    CuAssert( tc, "Invalid key at '5'.", 24958 == syck_map_read( n, map_key, 5 ) );
+    CuAssert( tc, "Invalid key at '6'.", 24058 == syck_map_read( n, map_key, 6 ) );
+    CuAssert( tc, "Invalid key at '7'.", 24158 == syck_map_read( n, map_key, 7 ) );
+    CuAssert( tc, "Invalid value at '0'", 24557 == syck_map_read( n, map_value, 0 ) );
+    CuAssert( tc, "Invalid value at '1'", 24559 == syck_map_read( n, map_value, 1 ) );
+    CuAssert( tc, "Invalid value at '2'", 24659 == syck_map_read( n, map_value, 2 ) );
+    CuAssert( tc, "Invalid value at '3'", 24759 == syck_map_read( n, map_value, 3 ) );
+    CuAssert( tc, "Invalid value at '4'", 24859 == syck_map_read( n, map_value, 4 ) );
+    CuAssert( tc, "Invalid value at '5'", 24959 == syck_map_read( n, map_value, 5 ) );
+    CuAssert( tc, "Invalid value at '6'", 24059 == syck_map_read( n, map_value, 6 ) );
+    CuAssert( tc, "Invalid value at '7'", 24159 == syck_map_read( n, map_value, 7 ) );
+
+    syck_free_node( n );
+}
+
+//
+// Test building a simple map
+//
+void
+TestSyckMapUpdate( CuTest *tc )
+{
+    SyckNode *n1, *n2;
+
+    n1 = syck_new_map( 51116, 51117 );
+    syck_map_add( n1, 51118, 51119 );
+    n2 = syck_new_map( 51126, 51127 );
+    syck_map_add( n2, 51128, 51129 );
+
+    syck_map_update( n1, n2 );
+    CuAssert( tc, "Invalid key at '2'", 51126 == syck_map_read( n1, map_key, 2 ) );
+    CuAssert( tc, "Invalid key at '3'", 51128 == syck_map_read( n1, map_key, 3 ) );
+    CuAssert( tc, "Invalid value at '2'", 51127 == syck_map_read( n1, map_value, 2 ) );
+    CuAssert( tc, "Invalid value at '3'", 51129 == syck_map_read( n1, map_value, 3 ) );
+
+    syck_free_node( n2 );
+    syck_free_node( n1 );
+}
+
+CuSuite *
+SyckGetSuite()
+{
+    CuSuite *suite = CuSuiteNew();
+    SUITE_ADD_TEST( suite, TestSyckNodeAlloc );
+    SUITE_ADD_TEST( suite, TestSyckSeqAlloc );
+    SUITE_ADD_TEST( suite, TestSyckMapAlloc );
+    SUITE_ADD_TEST( suite, TestSyckMapUpdate );
+    return suite;
+}
+
+int main(void)
+{
+	CuString *output = CuStringNew();
+	CuSuite* suite = SyckGetSuite();
+    int count;
+	
+	CuSuiteRun(suite);
+	CuSuiteSummary(suite, output);
+	CuSuiteDetails(suite, output);
+
+	printf("%s\n", output->buffer);
+    count = suite->failCount;
+
+    CuStringFree( output );
+    CuSuiteFree( suite );
+
+    return count;
+}