Changeset 8676

Timestamp:

01/15/06 08:51:18 (3 years ago)

Author:

audreyt

Message:

* Unescaped UTF8 literal support for YAML dump/load, ported

from Perl5's YAML::Syck.

Location:

src

Files:

• Data/Yaml/Syck.hsc (modified) (3 diffs)
• Pugs/CodeGen.hs (modified) (1 diff)
• Pugs/Prim/Yaml.hs (modified) (1 diff)
• syck/emitter.c (modified) (3 diffs)
• syck/syck_st.c (modified) (18 diffs)

src/Data/Yaml/Syck.hsc

@@ -11 +11 @@
 import Data.IORef
 import Data.Word                (Word8)
-import qualified Data.FastPackedString as P
+-- import qualified Data.FastPackedString as P
 import Foreign.Ptr
 import Foreign.StablePtr
@@ -86 +86 @@
         outPtr <- fmap castStablePtrToPtr (newStablePtr out)
         #{poke SyckEmitter, bonus} emitter outPtr
+        #{poke SyckEmitter, style} emitter scalarFold
         syck_output_handler emitter =<< mkOutputCallback outputCallback
         syck_emitter_handler emitter =<< mkEmitterCallback emitterCallback
@@ -99 +100 @@
     out     <- deRefStablePtr (castPtrToStablePtr outPtr)
     str     <- peekCStringLen (buf, fromIntegral len)
+    #{poke SyckEmitter, headless} emitter (1 :: CInt)
     modifyIORef out (++ str)
 

src/Pugs/CodeGen.hs

@@ -77 +77 @@
     case norm s of
         ('!':key) -> do
-            putStrLn $ "*** The backend '" ++ s ++ "' is deprecated."
-            putStrLn $ "    Please use '" ++ key ++ "' instead."
+            hPutStrLn stderr $ "*** The backend '" ++ s ++ "' is deprecated."
+            hPutStrLn stderr $ "    Please use '" ++ key ++ "' instead."
             Map.lookup key generators
         key -> Map.lookup key generators

src/Pugs/Prim/Yaml.hs

@@ -66 +66 @@
     rv   <- liftIO (emitYaml obj)
     either (fail . ("YAML Emit Error: "++))
-           (return . VStr) rv
+           (return . VStr . decodeUTF8) rv
 
 strNode :: String -> YamlNode

src/syck/emitter.c

@@ -412 +412 @@
         else
         {
-            char *an = S_ALLOC_N( char, strlen( anchor_name ) + 2 );
-            sprintf( an, "*%s", anchor_name );
-            syck_emitter_write( e, an, strlen( anchor_name ) + 1 );
+            char *an;
+            if (anchor_name == NULL) {
+                an = S_ALLOC_N( char, x+2 );
+                sprintf(an, "*%d", x);
+            }
+            else {
+                an = S_ALLOC_N( char, strlen( anchor_name ) + 2 );
+                sprintf( an, "*%s", anchor_name );
+            }
+
+            syck_emitter_write( e, an, strlen( an ) );
             free( an );
 
@@ -759 +767 @@
     for( i = 0; i < len; i++ )
     {
-        if( (src[i] < 0x20) || (0x7E < src[i]) )
+        if( (e->style == scalar_fold)
+                ? ((src[i] < 0x20) && (0 < src[i]))
+                : ((src[i] < 0x20) || (0x7E < src[i])) )
         {
             syck_emitter_write( e, "\\", 1 );
@@ -1218 +1228 @@
              */
             st_insert( e->anchors, (st_data_t)oid, (st_data_t)anchor_name );
+
+            /* XXX - Added by Audrey Tang to handle self-recursive structures - XXX */
+            return 0;
         }
     }

src/syck/syck_st.c

@@ -1 +1 @@
 /* This is a public domain general purpose hash table package written by Peter Moore @ UCB. */
 
-/* static   char    sccsid[] = "@(#) st.c 5.1 89/12/14 Crucible"; */
-
-#include "ghcconfig.h"
+/* static       char    sccsid[] = "@(#) st.c 5.1 89/12/14 Crucible"; */
+
+#include "config.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -80 +80 @@
 */
 static long primes[] = {
-    8 + 3,
-    16 + 3,
-    32 + 5,
-    64 + 3,
-    128 + 3,
-    256 + 27,
-    512 + 9,
-    1024 + 9,
-    2048 + 5,
-    4096 + 3,
-    8192 + 27,
-    16384 + 43,
-    32768 + 3,
-    65536 + 45,
-    131072 + 29,
-    262144 + 3,
-    524288 + 21,
-    1048576 + 7,
-    2097152 + 17,
-    4194304 + 15,
-    8388608 + 9,
-    16777216 + 43,
-    33554432 + 35,
-    67108864 + 15,
-    134217728 + 29,
-    268435456 + 3,
-    536870912 + 11,
-    1073741824 + 85,
-    0
+        8 + 3,
+        16 + 3,
+        32 + 5,
+        64 + 3,
+        128 + 3,
+        256 + 27,
+        512 + 9,
+        1024 + 9,
+        2048 + 5,
+        4096 + 3,
+        8192 + 27,
+        16384 + 43,
+        32768 + 3,
+        65536 + 45,
+        131072 + 29,
+        262144 + 3,
+        524288 + 21,
+        1048576 + 7,
+        2097152 + 17,
+        4194304 + 15,
+        8388608 + 9,
+        16777216 + 43,
+        33554432 + 35,
+        67108864 + 15,
+        134217728 + 29,
+        268435456 + 3,
+        536870912 + 11,
+        1073741824 + 85,
+        0
 };
 
@@ -119 +119 @@
 #if 0
     for (i=3; i<31; i++) {
-    if ((1<<i) > size) return 1<<i;
+        if ((1<<i) > size) return 1<<i;
     }
     return -1;
@@ -126 +126 @@
 
     for (i = 0, newsize = MINSIZE;
-     i < sizeof(primes)/sizeof(primes[0]);
-     i++, newsize <<= 1)
+         i < sizeof(primes)/sizeof(primes[0]);
+         i++, newsize <<= 1)
     {
-    if (newsize > size) return primes[i];
+        if (newsize > size) return primes[i];
     }
     /* Ran out of polynomials */
-    return -1;          /* should raise exception */
+    return -1;                  /* should raise exception */
 #endif
 }
@@ -158 +158 @@
 #ifdef HASH_LOG
     if (init_st == 0) {
-    init_st = 1;
-    atexit(stat_col);
-    }
-#endif
-
-    size = new_size(size);  /* round up to prime number */
+        init_st = 1;
+        atexit(stat_col);
+    }
+#endif
+
+    size = new_size(size);      /* round up to prime number */
 
     tbl = alloc(st_table);
@@ -215 +215 @@
 
     for(i = 0; i < table->num_bins; i++) {
-    ptr = table->bins[i];
-    while (ptr != 0) {
-        next = ptr->next;
-        free(ptr);
-        ptr = next;
-    }
+        ptr = table->bins[i];
+        while (ptr != 0) {
+            next = ptr->next;
+            free(ptr);
+            ptr = next;
+        }
     }
     free(table->bins);
@@ -239 +239 @@
     ptr = (table)->bins[bin_pos];\
     if (PTR_NOT_EQUAL(table, ptr, hash_val, key)) {\
-    COLLISION;\
-    while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\
-        ptr = ptr->next;\
-    }\
-    ptr = ptr->next;\
+        COLLISION;\
+        while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\
+            ptr = ptr->next;\
+        }\
+        ptr = ptr->next;\
     }\
 } while (0)
@@ -260 +260 @@
 
     if (ptr == 0) {
-    return 0;
+        return 0;
     }
     else {
-    if (value != 0)  *value = ptr->record;
-    return 1;
+        if (value != 0)  *value = ptr->record;
+        return 1;
     }
 }
@@ -272 +272 @@
     st_table_entry *entry;\
     if (table->num_entries/(table->num_bins) > ST_DEFAULT_MAX_DENSITY) {\
-    rehash(table);\
+        rehash(table);\
         bin_pos = hash_val % table->num_bins;\
     }\
@@ -299 +299 @@
 
     if (ptr == 0) {
-    ADD_DIRECT(table, key, value, hash_val, bin_pos);
-    return 0;
+        ADD_DIRECT(table, key, value, hash_val, bin_pos);
+        return 0;
     }
     else {
-    ptr->record = value;
-    return 1;
+        ptr->record = value;
+        return 1;
     }
 }
@@ -333 +333 @@
 
     for(i = 0; i < old_num_bins; i++) {
-    ptr = table->bins[i];
-    while (ptr != 0) {
-        next = ptr->next;
-        hash_val = ptr->hash % new_num_bins;
-        ptr->next = new_bins[hash_val];
-        new_bins[hash_val] = ptr;
-        ptr = next;
-    }
+        ptr = table->bins[i];
+        while (ptr != 0) {
+            next = ptr->next;
+            hash_val = ptr->hash % new_num_bins;
+            ptr->next = new_bins[hash_val];
+            new_bins[hash_val] = ptr;
+            ptr = next;
+        }
     }
     free(table->bins);
@@ -357 +357 @@
     new_table = alloc(st_table);
     if (new_table == 0) {
-    return 0;
+        return 0;
     }
 
     *new_table = *old_table;
     new_table->bins = (st_table_entry**)
-    Calloc((unsigned)num_bins, sizeof(st_table_entry*));
+        Calloc((unsigned)num_bins, sizeof(st_table_entry*));
 
     if (new_table->bins == 0) {
-    free(new_table);
-    return 0;
+        free(new_table);
+        return 0;
     }
 
     for(i = 0; i < num_bins; i++) {
-    new_table->bins[i] = 0;
-    ptr = old_table->bins[i];
-    while (ptr != 0) {
-        entry = alloc(st_table_entry);
-        if (entry == 0) {
-        free(new_table->bins);
-        free(new_table);
-        return 0;
-        }
-        *entry = *ptr;
-        entry->next = new_table->bins[i];
-        new_table->bins[i] = entry;
-        ptr = ptr->next;
-    }
+        new_table->bins[i] = 0;
+        ptr = old_table->bins[i];
+        while (ptr != 0) {
+            entry = alloc(st_table_entry);
+            if (entry == 0) {
+                free(new_table->bins);
+                free(new_table);
+                return 0;
+            }
+            *entry = *ptr;
+            entry->next = new_table->bins[i];
+            new_table->bins[i] = entry;
+            ptr = ptr->next;
+        }
     }
     return new_table;
@@ -402 +402 @@
 
     if (ptr == 0) {
-    if (value != 0) *value = 0;
-    return 0;
+        if (value != 0) *value = 0;
+        return 0;
     }
 
     if (EQUAL(table, *key, ptr->key)) {
-    table->bins[hash_val] = ptr->next;
-    table->num_entries--;
-    if (value != 0) *value = ptr->record;
-    *key = ptr->key;
-    free(ptr);
-    return 1;
+        table->bins[hash_val] = ptr->next;
+        table->num_entries--;
+        if (value != 0) *value = ptr->record;
+        *key = ptr->key;
+        free(ptr);
+        return 1;
     }
 
     for(; ptr->next != 0; ptr = ptr->next) {
-    if (EQUAL(table, ptr->next->key, *key)) {
-        tmp = ptr->next;
-        ptr->next = ptr->next->next;
-        table->num_entries--;
-        if (value != 0) *value = tmp->record;
-        *key = tmp->key;
-        free(tmp);
-        return 1;
-    }
+        if (EQUAL(table, ptr->next->key, *key)) {
+            tmp = ptr->next;
+            ptr->next = ptr->next->next;
+            table->num_entries--;
+            if (value != 0) *value = tmp->record;
+            *key = tmp->key;
+            free(tmp);
+            return 1;
+        }
     }
 
@@ -444 +444 @@
 
     if (ptr == 0) {
-    if (value != 0) *value = 0;
-    return 0;
+        if (value != 0) *value = 0;
+        return 0;
     }
 
     for(; ptr != 0; ptr = ptr->next) {
-    if ((ptr->key != never) && EQUAL(table, ptr->key, *key)) {
-        table->num_entries--;
-        *key = ptr->key;
-        if (value != 0) *value = ptr->record;
-        ptr->key = ptr->record = never;
-        return 1;
-    }
+        if ((ptr->key != never) && EQUAL(table, ptr->key, *key)) {
+            table->num_entries--;
+            *key = ptr->key;
+            if (value != 0) *value = ptr->record;
+            ptr->key = ptr->record = never;
+            return 1;
+        }
     }
 
@@ -491 +491 @@
 
     for(i = 0; i < table->num_bins; i++) {
-    last = 0;
-    for(ptr = table->bins[i]; ptr != 0;) {
-        retval = (*func)(ptr->key, ptr->record, arg);
-        switch (retval) {
-        case ST_CONTINUE:
-        last = ptr;
-        ptr = ptr->next;
-        break;
-        case ST_STOP:
-        return;
-        case ST_DELETE:
-        tmp = ptr;
-        if (last == 0) {
-            table->bins[i] = ptr->next;
-        }
-        else {
-            last->next = ptr->next;
-        }
-        ptr = ptr->next;
-        free(tmp);
-        table->num_entries--;
-        }
-    }
+        last = 0;
+        for(ptr = table->bins[i]; ptr != 0;) {
+            retval = (*func)(ptr->key, ptr->record, arg);
+            switch (retval) {
+            case ST_CONTINUE:
+                last = ptr;
+                ptr = ptr->next;
+                break;
+            case ST_STOP:
+                return;
+            case ST_DELETE:
+                tmp = ptr;
+                if (last == 0) {
+                    table->bins[i] = ptr->next;
+                }
+                else {
+                    last->next = ptr->next;
+                }
+                ptr = ptr->next;
+                free(tmp);
+                table->num_entries--;
+            }
+        }
     }
 }
@@ -527 +527 @@
 
     while ((c = *string++) != '\0') {
-    h = ( h << 4 ) + c;
-    if ( g = h & 0xF0000000 )
-        h ^= g >> 24;
-    h &= ~g;
+        h = ( h << 4 ) + c;
+        if ( g = h & 0xF0000000 )
+            h ^= g >> 24;
+        h &= ~g;
     }
     return h;
@@ -537 +537 @@
 
     while ((c = *string++) != '\0') {
-    val = val*33 + c;
+        val = val*33 + c;
     }
 
@@ -556 +556 @@
 
     while ((c = *string++) != '\0') {
-    val = val*997 + c;
+        val = val*997 + c;
     }