HsSyck (empty) → 0.2
raw patch · 14 files changed
+12784/−0 lines, 14 filesdep +basebuild-type:Customsetup-changed
Dependencies added: base
Files
- Data/Yaml/Syck.hsc +438/−0
- HsSyck.cabal +18/−0
- LICENSE +18/−0
- Setup.hs +3/−0
- syck/bytecode.c +1168/−0
- syck/emitter.c +1285/−0
- syck/gram.c +1894/−0
- syck/handler.c +173/−0
- syck/implicit.c +3199/−0
- syck/node.c +414/−0
- syck/syck.c +504/−0
- syck/syck_st.c +577/−0
- syck/token.c +2838/−0
- syck/yaml2byte.c +255/−0
+ Data/Yaml/Syck.hsc view
@@ -0,0 +1,438 @@+#include "syck.h"++module Data.Yaml.Syck (+ parseYaml, emitYaml,+ parseYamlFile, emitYamlFile,+ parseYamlBytes, emitYamlBytes,+ YamlNode(..), YamlElem(..), YamlAnchor(..),+ tagNode, nilNode, mkNode, mkTagNode, mkTagStrNode, SYMID,+ packBuf, unpackBuf,+) where++import Control.Exception (bracket)+import Data.IORef+import Data.Generics+import Foreign.Ptr+import Foreign.StablePtr+import Foreign.C.Types+import Foreign.C.String+import Foreign.Marshal.Alloc+import Foreign.Marshal.Utils+import Foreign.Storable+import GHC.Ptr (Ptr(..))+import qualified Data.HashTable as Hash+import qualified Data.ByteString.Char8 as Buf+import Data.ByteString.Char8 (copyCStringLen, useAsCStringLen, useAsCString, copyCString)++type Buf = Buf.ByteString+type YamlTag = Maybe Buf+data YamlAnchor+ = AAnchor !Int+ | AReference !Int+ | ASingleton+ deriving (Show, Ord, Eq, Typeable, Data)++type SYMID = CULong++instance Data SYMID where+ toConstr x = mkIntConstr (mkIntType "Foreign.C.Types.CULong") (fromIntegral x)+ gunfold _ z c = case constrRep c of+ (IntConstr x) -> z (fromIntegral x)+ _ -> error "gunfold"+ dataTypeOf _ = mkIntType "Foreign.C.Types.CULong"++data YamlNode = MkNode+ { n_id :: !SYMID+ , n_elem :: !YamlElem+ , n_tag :: !YamlTag+ , n_anchor :: !YamlAnchor+ }+ deriving (Show, Ord, Eq, Typeable, Data)++data YamlElem+ = EMap [(YamlNode, YamlNode)]+ | ESeq [YamlNode]+ | EStr !Buf+ | ENil+ deriving (Show, Ord, Eq, Typeable, Data)++type SyckNode = Ptr ()+type SyckParser = Ptr ()+type SyckNodeHandler = SyckParser -> SyckNode -> IO SYMID+type SyckErrorHandler = SyckParser -> CString -> IO ()+type SyckBadAnchorHandler = SyckParser -> CString -> IO SyckNode+type SyckNodePtr = Ptr CString+type SyckEmitter = Ptr () +type SyckEmitterHandler = SyckEmitter -> Ptr () -> IO ()+type SyckOutputHandler = SyckEmitter -> CString -> CLong -> IO ()+data SyckKind = SyckMap | SyckSeq | SyckStr+ deriving (Show, Ord, Eq, Enum)++nilNode :: YamlNode+nilNode = MkNode 0 ENil Nothing ASingleton++{-# INLINE unpackBuf #-}+unpackBuf :: Buf -> String+unpackBuf = Buf.unpack++{-# INLINE packBuf #-}+packBuf :: String -> Buf+packBuf = Buf.pack++tagNode :: YamlTag -> YamlNode -> YamlNode+tagNode _ MkNode{n_tag=Just x} = error $ "can't add tag: already tagged with" ++ unpackBuf x+tagNode tag node = node{n_tag = tag}++mkNode :: YamlElem -> YamlNode+mkNode x = MkNode 0 x Nothing ASingleton++mkTagNode :: String -> YamlElem -> YamlNode+mkTagNode tag e = MkNode 0 e (Just $! packBuf tag) ASingleton++mkTagStrNode :: String -> String -> YamlNode+mkTagStrNode tag str = mkTagNode tag (EStr $! packBuf str)++-- the extra commas here are not a bug+#enum CInt, , scalar_none, scalar_1quote, scalar_2quote, scalar_fold, scalar_literal, scalar_plain+#enum CInt, , seq_none, seq_inline+#enum CInt, , map_none, map_inline++{-+#def typedef void* EmitterExtras;+type EmitterExtras = Ptr ()+-}++emitYamlBytes :: YamlNode -> IO Buf+emitYamlBytes node = do+ bracket syck_new_emitter syck_free_emitter $ \emitter -> do+ -- set up output port+ out <- newIORef []+ #{poke SyckEmitter, style} emitter scalarFold+ -- #{poke SyckEmitter, sort_keys} emitter (1 :: CInt)+ #{poke SyckEmitter, anchor_format} emitter (Ptr "%d"## :: CString)++ marks <- Hash.new (==) (Hash.hashInt)++ let freeze = freezeNode marks+ syck_emitter_handler emitter =<< mkEmitterCallback (emitterCallback freeze)+ syck_output_handler emitter =<< mkOutputCallback (outputCallbackPS out)++ markYamlNode freeze emitter node++ nodePtr <- freeze node+ let nodePtr' = fromIntegral $ nodePtr `minusPtr` nullPtr+ syck_emit emitter nodePtr'+ syck_emitter_flush emitter 0+ fmap (Buf.concat . reverse) (readIORef out)++emitYamlFile :: FilePath -> YamlNode -> IO ()+emitYamlFile file node = do+ buf <- emitYamlBytes node+ Buf.writeFile file buf++emitYaml :: YamlNode -> IO String+emitYaml node = fmap unpackBuf (emitYamlBytes node)++markYamlNode :: (YamlNode -> IO SyckNodePtr) -> SyckEmitter -> YamlNode -> IO ()+{-+markYamlNode marks emitter MkNode{ anchor = AReference n } = do+ Just nodePtr <- Hash.lookup marks n+ syck_emitter_mark_node emitter nodePtr+ return ()+-}+markYamlNode freeze emitter node = do+ nodePtr <- freeze node+ rv <- syck_emitter_mark_node emitter nodePtr+ if rv == 0 then return () else do+ case n_elem node of+ EMap xs -> sequence_ [ mark x >> mark y | (x, y) <- xs ]+ ESeq xs -> mapM_ mark xs+ _ -> return ()+ where+ mark = markYamlNode freeze emitter++outputCallbackPS :: IORef [Buf] -> SyckEmitter -> CString -> CLong -> IO ()+outputCallbackPS out emitter buf len = do+ str <- copyCStringLen (buf, fromEnum len)+ str `seq` modifyIORef out (str:)++outputCallback :: SyckEmitter -> CString -> CLong -> IO ()+outputCallback emitter buf len = do+ outPtr <- #{peek SyckEmitter, bonus} emitter+ out <- deRefStablePtr (castPtrToStablePtr outPtr)+ str <- peekCStringLen (buf, fromIntegral len)+ modifyIORef out (++ str)++emitterCallback :: (YamlNode -> IO SyckNodePtr) -> SyckEmitter -> Ptr () -> IO ()+emitterCallback f e vp = emitNode f e =<< thawNode vp++emitNode :: (YamlNode -> IO SyckNodePtr) -> SyckEmitter -> YamlNode -> IO ()+emitNode _ e n | n_elem n == ENil = do+ withTag n (Ptr "string"##) $ \tag ->+ syck_emit_scalar e tag scalarNone 0 0 0 (Ptr "~"##) 1++emitNode _ e n | EStr s <- n_elem n, Buf.length s == 1, Buf.head s == '~' = do+ withTag n (Ptr "string"##) $ \tag ->+ syck_emit_scalar e tag scalar1quote 0 0 0 (Ptr "~"##) 1++emitNode _ e n | EStr s <- n_elem n = do+ withTag n (Ptr "string"##) $ \tag ->+ useAsCStringLen s $ \(cs, l) -> + syck_emit_scalar e tag scalarFold 0 0 0 cs (toEnum l)++emitNode freeze e n | ESeq sq <- n_elem n = do+ withTag n (Ptr "array"##) $ \tag ->+ syck_emit_seq e tag seqNone+ mapM_ (syck_emit_item e) =<< mapM freeze sq+ syck_emit_end e++emitNode freeze e n | EMap m <- n_elem n = do+ withTag n (Ptr "map"##) $ \tag ->+ syck_emit_map e tag mapNone+ flip mapM_ m (\(k,v) -> do+ syck_emit_item e =<< freeze k+ syck_emit_item e =<< freeze v)+ syck_emit_end e++withTag :: YamlNode -> CString -> (CString -> IO a) -> IO a+withTag node def f = maybe (f def) (`useAsCString` f) (n_tag node)++parseYaml :: String -> IO YamlNode+parseYaml = (`withCString` parseYamlCStr)++parseYamlFile :: String -> IO YamlNode+parseYamlFile file = parseYamlBytes =<< Buf.readFile file++parseYamlBytes :: Buf -> IO YamlNode+parseYamlBytes = (`useAsCString` parseYamlCStr)++parseYamlCStr :: CString -> IO YamlNode+parseYamlCStr cstr = do+ bracket syck_new_parser syck_free_parser $ \parser -> do+ err <- newIORef Nothing+ syck_parser_str_auto parser cstr nullFunPtr+ syck_parser_handler parser =<< mkNodeCallback nodeCallback+ syck_parser_error_handler parser =<< mkErrorCallback (errorCallback err)+ syck_parser_bad_anchor_handler parser =<< mkBadHandlerCallback badAnchorHandlerCallback+ syck_parser_implicit_typing parser 0+ syck_parser_taguri_expansion parser 0+ symId <- syck_parse parser+ if symId /= 0 then readNode parser symId else do+ rv <- readIORef err+ case rv of+ Nothing -> return nilNode+ Just e -> fail e++nodeCallback :: SyckParser -> SyckNode -> IO SYMID+nodeCallback parser syckNode = do+ kind <- syckNodeKind syckNode+ len <- syckNodeLength kind syckNode+ node <- parseNode kind parser syckNode len+ nodePtr <- writeNode node+ symId <- syck_add_sym parser nodePtr+ return (fromIntegral symId)++badAnchorHandlerCallback :: SyckBadAnchorHandler+badAnchorHandlerCallback _parser _cstr = do+ fail "moose!"++errorCallback :: IORef (Maybe String) -> SyckErrorHandler+errorCallback err parser cstr = do+ msg <- peekCString cstr+ lineptr <- #{peek SyckParser, lineptr} parser :: IO CChar+ cursor <- #{peek SyckParser, cursor} parser :: IO CChar+ linect <- #{peek SyckParser, linect} parser :: IO CChar+ writeIORef err . Just $ concat+ [ msg+ , ": line ", show (1 + fromEnum linect)+ , ", column ", show (cursor - lineptr)+ ]++freezeNode :: Hash.HashTable Int (Ptr a) -> YamlNode -> IO (Ptr a)+freezeNode nodes MkNode{ n_anchor = AReference n } = do+ Just ptr <- Hash.lookup nodes n+ return ptr+freezeNode nodes node = do+ ptr <- newStablePtr node+ case n_anchor node of+ AAnchor n -> do+ rv <- Hash.lookup nodes n+ case rv of+ Just ptr -> return ptr+ _ -> do+ ptr <- newStablePtr node+ let ptr' = castPtr (castStablePtrToPtr ptr)+ Hash.insert nodes n ptr'+ return $! ptr'+ _ -> do+ ptr <- newStablePtr node+ return $! castPtr (castStablePtrToPtr ptr)++thawNode :: Ptr () -> IO YamlNode+thawNode nodePtr = deRefStablePtr (castPtrToStablePtr nodePtr)++writeNode :: YamlNode -> IO SyckNodePtr+writeNode node = do+ ptr <- newStablePtr node+ new (castPtr $ castStablePtrToPtr ptr)++readNode :: SyckParser -> SYMID -> IO YamlNode+readNode parser symId = alloca $ \nodePtr -> do+ syck_lookup_sym parser symId nodePtr+ ptr <- peek . castPtr =<< peek nodePtr+ deRefStablePtr (castPtrToStablePtr ptr)++{-# NOINLINE _tagLiteral #-}+{-# NOINLINE _colonLiteral #-}+_tagLiteral, _colonLiteral :: Buf+_tagLiteral = packBuf "tag:"+_colonLiteral = packBuf ":"++syckNodeTag :: SyckNode -> IO (Maybe Buf)+syckNodeTag syckNode = do+ tag <- #{peek SyckNode, type_id} syckNode+ if (tag == nullPtr) then (return Nothing) else do+ p <- copyCString tag+ return $! case Buf.elemIndex '/' p of+ Just n -> let { pre = Buf.take n p; post = Buf.drop (n+1) p } in+ Just $ Buf.concat [_tagLiteral, pre, _colonLiteral, post]+ Nothing -> Nothing++syckNodeKind :: SyckNode -> IO SyckKind+syckNodeKind syckNode = do+ kind <- #{peek SyckNode, kind} syckNode+ return $ toEnum (kind `mod` 4)++syckNodeLength :: SyckKind -> SyckNode -> IO CLong+syckNodeLength SyckMap = (#{peek struct SyckMap, idx} =<<) . #{peek SyckNode, data}+syckNodeLength SyckSeq = (#{peek struct SyckSeq, idx} =<<) . #{peek SyckNode, data}+syckNodeLength SyckStr = (#{peek struct SyckStr, len} =<<) . #{peek SyckNode, data}++parseNode :: SyckKind -> SyckParser -> SyckNode -> CLong -> IO YamlNode+parseNode SyckMap parser syckNode len = do+ tag <- syckNodeTag syckNode+ pairs <- (`mapM` [0..len-1]) $ \idx -> do+ keyId <- syck_map_read syckNode 0 idx+ key <- readNode parser keyId+ valId <- syck_map_read syckNode 1 idx+ val <- readNode parser valId+ return (key, val)+ return $ nilNode{ n_elem = EMap pairs, n_tag = tag}++parseNode SyckSeq parser syckNode len = do+ tag <- syckNodeTag syckNode+ nodes <- (`mapM` [0..len-1]) $ \idx -> do+ symId <- syck_seq_read syckNode idx+ readNode parser symId+ return $ nilNode{ n_elem = ESeq nodes, n_tag = tag }++parseNode SyckStr _ syckNode len = do+ tag <- syckNodeTag syckNode+ cstr <- syck_str_read syckNode+ buf <- copyCStringLen (cstr, fromEnum len)+ let node = nilNode{ n_elem = EStr buf, n_tag = tag }+ if tag == Nothing && Buf.length buf == 1 && Buf.index buf 0 == '~'+ then do+ style <- syck_str_style syckNode+ if style == scalarPlain+ then return nilNode+ else return node+ else return node++foreign import ccall "wrapper" + mkNodeCallback :: SyckNodeHandler -> IO (FunPtr SyckNodeHandler)++foreign import ccall "wrapper" + mkErrorCallback :: SyckErrorHandler -> IO (FunPtr SyckErrorHandler)++foreign import ccall "wrapper" + mkBadHandlerCallback :: SyckBadAnchorHandler -> IO (FunPtr SyckBadAnchorHandler)++foreign import ccall "wrapper"+ mkOutputCallback :: SyckOutputHandler -> IO (FunPtr SyckOutputHandler)++foreign import ccall "wrapper"+ mkEmitterCallback :: SyckEmitterHandler -> IO (FunPtr SyckEmitterHandler)++foreign import ccall+ syck_new_parser :: IO SyckParser++foreign import ccall+ syck_parser_str_auto :: SyckParser -> CString -> FunPtr () -> IO ()++foreign import ccall+ syck_parser_error_handler :: SyckParser -> FunPtr SyckErrorHandler -> IO ()++foreign import ccall+ syck_parser_bad_anchor_handler :: SyckParser -> FunPtr SyckBadAnchorHandler -> IO ()++foreign import ccall+ syck_parser_implicit_typing :: SyckParser -> CInt -> IO ()++foreign import ccall+ syck_parser_taguri_expansion :: SyckParser -> CInt -> IO ()++foreign import ccall+ syck_parser_handler :: SyckParser -> FunPtr SyckNodeHandler -> IO ()++foreign import ccall+ syck_add_sym :: SyckParser -> SyckNodePtr -> IO CInt++foreign import ccall+ syck_parse :: SyckParser -> IO SYMID++foreign import ccall+ syck_free_parser :: SyckParser -> IO ()++foreign import ccall+ syck_lookup_sym :: SyckParser -> SYMID -> Ptr SyckNodePtr -> IO CInt++foreign import ccall+ syck_str_read :: SyckNode -> IO CString++foreign import ccall+ syck_str_style :: SyckNode -> IO CInt++foreign import ccall+ syck_seq_read :: SyckNode -> CLong -> IO SYMID++foreign import ccall+ syck_map_read :: SyckNode -> CInt -> CLong -> IO SYMID++foreign import ccall+ syck_new_emitter :: IO SyckEmitter++foreign import ccall+ syck_free_emitter :: SyckEmitter -> IO ()++foreign import ccall+ syck_emitter_handler :: SyckEmitter -> FunPtr SyckEmitterHandler -> IO ()++foreign import ccall+ syck_output_handler :: SyckEmitter -> FunPtr SyckOutputHandler -> IO ()++foreign import ccall+ syck_emit :: SyckEmitter -> CLong -> IO ()++foreign import ccall+ syck_emitter_flush :: SyckEmitter -> CLong -> IO ()++foreign import ccall+ syck_emitter_mark_node :: SyckEmitter -> SyckNodePtr -> IO SYMID++foreign import ccall+ syck_emit_scalar :: SyckEmitter -> CString -> CInt -> CInt -> CInt -> CInt -> CString -> CInt -> IO ()++foreign import ccall+ syck_emit_seq :: SyckEmitter -> CString -> CInt -> IO ()++foreign import ccall+ syck_emit_item :: SyckEmitter -> SyckNodePtr -> IO ()++foreign import ccall+ syck_emit_end :: SyckEmitter -> IO ()++foreign import ccall+ syck_emit_map :: SyckEmitter -> CString -> CInt -> IO ()++-- vim: syntax=haskell :
+ HsSyck.cabal view
@@ -0,0 +1,18 @@+Name: HsSyck+Version: 0.2+Category: Data+Synopsis: Fast, lightweight YAML loader and dumper+Description: Fast, lightweight YAML loader and dumper+-- License is really "MIT", but Cabal allows no such field+License: BSD3+License-file: LICENSE+Author: Audrey Tang+Maintainer: audreyt@audreyt.org+Build-Depends: base >= 0.2+Exposed-modules: Data.Yaml.Syck+extensions: ForeignFunctionInterface+ghc-options: -fglasgow-exts -O2 -optc-w -funbox-strict-fields -fno-warn-orphans+c-sources: syck/bytecode.c syck/emitter.c syck/gram.c syck/handler.c+ syck/implicit.c syck/node.c syck/syck.c syck/syck_st.c syck/token.c+ syck/yaml2byte.c +include-dirs: syck
+ LICENSE view
@@ -0,0 +1,18 @@+Copyright 2005, 2006 by Audrey Tang, Gaal Yahas++Permission is hereby granted, free of charge, to any person obtaining a copy+of this software and associated documentation files (the "Software"), to+deal in the Software without restriction, including without limitation the+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or+sell copies of the Software, and to permit persons to whom the Software is+furnished to do so, subject to the following conditions:+ +The above copyright notice and this permission notice shall be included in+all copies or substantial portions of the Software.+ +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ Setup.hs view
@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+import Distribution.Simple+main = defaultMainWithHooks defaultUserHooks
+ syck/bytecode.c view
@@ -0,0 +1,1168 @@+/* Generated by re2c 0.10.1 on Mon May 8 21:26:42 2006 */+#line 1 "bytecode.re"+/*+ * bytecode.re+ *+ * $Author: why $+ * $Date: 2005-09-20 13:21:06 +0800 (二, 20 9 2005) $+ *+ * Copyright (C) 2003 why the lucky stiff+ */+#include "syck.h"+#include "gram.h"++#define QUOTELEN 128++/*+ * They do my bidding...+ */+#define YYCTYPE char+#define YYCURSOR parser->cursor+#define YYMARKER parser->marker+#define YYLIMIT parser->limit+#define YYTOKEN parser->token+#define YYTOKTMP parser->toktmp+#define YYLINEPTR parser->lineptr+#define YYLINECTPTR parser->linectptr+#define YYLINE parser->linect+#define YYFILL(n) syck_parser_read(parser)++extern SyckParser *syck_parser_ptr;++char *get_inline( SyckParser *parser );++/*+ * Repositions the cursor at `n' offset from the token start.+ * Only works in `Header' and `Document' sections.+ */+#define YYPOS(n) YYCURSOR = YYTOKEN + n++/*+ * Track line numbers+ */+#define CHK_NL(ptr) if ( *( ptr - 1 ) == '\n' && ptr > YYLINECTPTR ) { YYLINEPTR = ptr; YYLINE++; YYLINECTPTR = YYLINEPTR; }++/*+ * I like seeing the level operations as macros...+ */+#define ADD_LEVEL(len, status) syck_parser_add_level( parser, len, status )+#define POP_LEVEL() syck_parser_pop_level( parser )+#define CURRENT_LEVEL() syck_parser_current_level( parser )++/*+ * Force a token next time around sycklex()+ */+#define FORCE_NEXT_TOKEN(tok) parser->force_token = tok;++/*+ * Adding levels in bytecode requires us to make sure+ * we've got all our tokens worked out.+ */+#define ADD_BYTE_LEVEL(lvl, len, s ) \+ switch ( lvl->status ) \+ { \+ case syck_lvl_seq: \+ lvl->ncount++; \+ ADD_LEVEL(len, syck_lvl_open); \+ YYPOS(0); \+ return '-'; \+ \+ case syck_lvl_map: \+ lvl->ncount++; \+ ADD_LEVEL(len, s); \+ break; \+ \+ case syck_lvl_open: \+ lvl->status = s; \+ break; \+ \+ default: \+ ADD_LEVEL(len, s); \+ break; \+ }++/*+ * Nice little macro to ensure we're YAML_IOPENed to the current level.+ * * Only use this macro in the "Document" section *+ */+#define ENSURE_YAML_IOPEN(last_lvl, lvl_type, to_len, reset) \+ if ( last_lvl->spaces < to_len ) \+ { \+ if ( last_lvl->status == syck_lvl_iseq || last_lvl->status == syck_lvl_imap ) \+ { \+ goto Document; \+ } \+ else \+ { \+ ADD_LEVEL( to_len, lvl_type ); \+ if ( reset == 1 ) YYPOS(0); \+ return YAML_IOPEN; \+ } \+ } ++/*+ * Nice little macro to ensure closure of levels.+ * * Only use this macro in the "Document" section *+ */+#define ENSURE_YAML_IEND(last_lvl, to_len) \+ if ( last_lvl->spaces > to_len ) \+ { \+ syck_parser_pop_level( parser ); \+ YYPOS(0); \+ return YAML_IEND; \+ }++/*+ * Concatenates string items and manages allocation+ * to the string+ */+#define CAT(s, c, i, l) \+ { \+ if ( i + 1 >= c ) \+ { \+ c += QUOTELEN; \+ S_REALLOC_N( s, char, c ); \+ } \+ s[i++] = l; \+ s[i] = '\0'; \+ }++/*+ * Parser for standard YAML Bytecode [UTF-8]+ */+int+sycklex_bytecode_utf8( YYSTYPE *sycklval, SyckParser *parser )+{+ SyckLevel *lvl;+ syck_parser_ptr = parser;+ if ( YYCURSOR == NULL ) + {+ syck_parser_read( parser );+ }++ if ( parser->force_token != 0 )+ {+ int t = parser->force_token;+ parser->force_token = 0;+ return t;+ }++#line 172 "bytecode.re"+++ lvl = CURRENT_LEVEL();+ if ( lvl->status == syck_lvl_doc )+ {+ goto Document;+ }++/* Header: */++ YYTOKEN = YYCURSOR;+++#line 165 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;++ if((YYLIMIT - YYCURSOR) < 3) YYFILL(3);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy2;+ case 'D': goto yy3;+ default: goto yy5;+ }+yy2:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy4;+ }+yy3:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x0A: goto yy6;+ case 0x0D: goto yy8;+ default: goto yy4;+ }+yy4:+#line 199 "bytecode.re"+ { YYPOS(0);+ goto Document;+ }+#line 195 "<stdout>"+yy5:+ yych = *++YYCURSOR;+ goto yy4;+yy6:+ ++YYCURSOR;+#line 186 "bytecode.re"+ { if ( lvl->status == syck_lvl_header )+ {+ CHK_NL(YYCURSOR);+ goto Directive;+ }+ else+ {+ ENSURE_YAML_IEND(lvl, -1);+ YYPOS(0);+ return 0;+ }+ }+#line 214 "<stdout>"+yy8:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy6;+ default: goto yy2;+ }+}+#line 203 "bytecode.re"+++Document:+ {+ lvl = CURRENT_LEVEL();+ if ( lvl->status == syck_lvl_header )+ {+ lvl->status = syck_lvl_doc;+ }++ YYTOKEN = YYCURSOR;+++#line 236 "<stdout>"+{+ YYCTYPE yych;+ if((YYLIMIT - YYCURSOR) < 3) YYFILL(3);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy30;+ case 0x0A: goto yy27;+ case 0x0D: goto yy29;+ case 'A': goto yy19;+ case 'D': goto yy12;+ case 'E': goto yy16;+ case 'M': goto yy14;+ case 'P': goto yy13;+ case 'Q': goto yy15;+ case 'R': goto yy21;+ case 'S': goto yy17;+ case 'T': goto yy23;+ case 'c': goto yy25;+ default: goto yy11;+ }+yy11:+yy12:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy41;+ case 0x0D: goto yy44;+ default: goto yy11;+ }+yy13:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy41;+ case 0x0D: goto yy43;+ default: goto yy11;+ }+yy14:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy38;+ case 0x0D: goto yy40;+ default: goto yy11;+ }+yy15:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy35;+ case 0x0D: goto yy37;+ default: goto yy11;+ }+yy16:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy32;+ case 0x0D: goto yy34;+ default: goto yy11;+ }+yy17:+ ++YYCURSOR;+#line 288 "bytecode.re"+ { ADD_BYTE_LEVEL(lvl, lvl->spaces + 1, syck_lvl_str); + goto Scalar;+ }+#line 299 "<stdout>"+yy19:+ ++YYCURSOR;+#line 292 "bytecode.re"+ { ADD_BYTE_LEVEL(lvl, lvl->spaces + 1, syck_lvl_open);+ sycklval->name = get_inline( parser );+ syck_hdlr_remove_anchor( parser, sycklval->name );+ CHK_NL(YYCURSOR);+ return YAML_ANCHOR;+ }+#line 309 "<stdout>"+yy21:+ ++YYCURSOR;+#line 299 "bytecode.re"+ { ADD_BYTE_LEVEL(lvl, lvl->spaces + 1, syck_lvl_str);+ sycklval->name = get_inline( parser );+ POP_LEVEL();+ if ( *( YYCURSOR - 1 ) == '\n' ) YYCURSOR--;+ return YAML_ALIAS;+ }+#line 319 "<stdout>"+yy23:+ ++YYCURSOR;+#line 306 "bytecode.re"+ { char *qstr;+ ADD_BYTE_LEVEL(lvl, lvl->spaces + 1, syck_lvl_open);+ qstr = get_inline( parser );+ CHK_NL(YYCURSOR);+ if ( qstr[0] == '!' )+ {+ int qidx = strlen( qstr );+ if ( qstr[1] == '\0' )+ {+ free( qstr );+ return YAML_ITRANSFER;+ }++ lvl = CURRENT_LEVEL();++ /*+ * URL Prefixing+ */+ if ( qstr[1] == '^' )+ {+ sycklval->name = S_ALLOC_N( char, qidx + strlen( lvl->domain ) );+ sycklval->name[0] = '\0';+ strcat( sycklval->name, lvl->domain );+ strncat( sycklval->name, qstr + 2, qidx - 2 );+ free( qstr );+ }+ else+ {+ char *carat = qstr + 1;+ char *qend = qstr + qidx;+ while ( (++carat) < qend )+ {+ if ( *carat == '^' )+ break;+ }++ if ( carat < qend )+ {+ free( lvl->domain );+ lvl->domain = syck_strndup( qstr + 1, carat - ( qstr + 1 ) );+ sycklval->name = S_ALLOC_N( char, ( qend - carat ) + strlen( lvl->domain ) );+ sycklval->name[0] = '\0';+ strcat( sycklval->name, lvl->domain );+ strncat( sycklval->name, carat + 1, ( qend - carat ) - 1 );+ free( qstr );+ }+ else+ {+ sycklval->name = S_ALLOC_N( char, strlen( qstr ) );+ sycklval->name[0] = '\0';+ S_MEMCPY( sycklval->name, qstr + 1, char, strlen( qstr ) );+ free( qstr );+ }+ }+ return YAML_TRANSFER;+ }+ sycklval->name = qstr;+ return YAML_TAGURI;+ }+#line 382 "<stdout>"+yy25:+ ++YYCURSOR;+#line 366 "bytecode.re"+ { goto Comment; }+#line 387 "<stdout>"+yy27:+ ++YYCURSOR;+#line 368 "bytecode.re"+ { CHK_NL(YYCURSOR);+ if ( lvl->status == syck_lvl_seq )+ {+ return YAML_INDENT; + }+ else if ( lvl->status == syck_lvl_map )+ {+ if ( lvl->ncount % 2 == 1 ) return ':';+ else return YAML_INDENT;+ }+ goto Document;+ }+#line 403 "<stdout>"+yy29:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy27;+ default: goto yy11;+ }+yy30:+ ++YYCURSOR;+#line 381 "bytecode.re"+ { ENSURE_YAML_IEND(lvl, -1);+ YYPOS(0);+ return 0;+ }+#line 417 "<stdout>"+yy32:+ ++YYCURSOR;+#line 252 "bytecode.re"+ { if ( lvl->status == syck_lvl_seq && lvl->ncount == 0 )+ {+ lvl->ncount++;+ YYPOS(0);+ FORCE_NEXT_TOKEN( ']' );+ return '[';+ }+ else if ( lvl->status == syck_lvl_map && lvl->ncount == 0 )+ {+ lvl->ncount++;+ YYPOS(0);+ FORCE_NEXT_TOKEN( '}' );+ return '{';+ }+ + POP_LEVEL();+ lvl = CURRENT_LEVEL();+ if ( lvl->status == syck_lvl_seq )+ {+ FORCE_NEXT_TOKEN(YAML_INDENT); + }+ else if ( lvl->status == syck_lvl_map )+ {+ if ( lvl->ncount % 2 == 1 )+ {+ FORCE_NEXT_TOKEN(':');+ }+ else+ {+ FORCE_NEXT_TOKEN(YAML_INDENT);+ }+ }+ CHK_NL(YYCURSOR);+ return YAML_IEND;+ }+#line 456 "<stdout>"+yy34:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy32;+ default: goto yy11;+ }+yy35:+ ++YYCURSOR;+#line 237 "bytecode.re"+ { int complex = 0;+ if ( lvl->ncount % 2 == 0 && ( lvl->status == syck_lvl_map || lvl->status == syck_lvl_seq ) )+ {+ complex = 1;+ }+ ADD_BYTE_LEVEL(lvl, lvl->spaces + 1, syck_lvl_seq);+ CHK_NL(YYCURSOR);+ if ( complex )+ {+ FORCE_NEXT_TOKEN( YAML_IOPEN );+ return '?';+ }+ return YAML_IOPEN;+ }+#line 480 "<stdout>"+yy37:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy35;+ default: goto yy11;+ }+yy38:+ ++YYCURSOR;+#line 222 "bytecode.re"+ { int complex = 0;+ if ( lvl->ncount % 2 == 0 && ( lvl->status == syck_lvl_map || lvl->status == syck_lvl_seq ) )+ {+ complex = 1;+ }+ ADD_BYTE_LEVEL(lvl, lvl->spaces + 1, syck_lvl_map); + CHK_NL(YYCURSOR);+ if ( complex )+ {+ FORCE_NEXT_TOKEN( YAML_IOPEN );+ return '?';+ }+ return YAML_IOPEN;+ }+#line 504 "<stdout>"+yy40:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy38;+ default: goto yy11;+ }+yy41:+ ++YYCURSOR;+#line 217 "bytecode.re"+ { ENSURE_YAML_IEND(lvl, -1);+ YYPOS(0);+ return 0;+ }+#line 518 "<stdout>"+yy43:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy41;+ default: goto yy11;+ }+yy44:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy41;+ default: goto yy11;+ }+}+#line 386 "bytecode.re"+++ }++Directive:+ {+ YYTOKEN = YYCURSOR;+++#line 542 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy47;+ case 'V': goto yy48;+ default: goto yy50;+ }+yy47:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy49;+ }+yy48:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case ':':+ case ';':+ case '<':+ case '=':+ case '>':+ case '?':+ case '@':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '[':+ case '\\':+ case ']':+ case '^':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy51;+ default: goto yy49;+ }+yy49:+#line 399 "bytecode.re"+ { YYCURSOR = YYTOKEN;+ return YAML_DOCSEP;+ }+#line 645 "<stdout>"+yy50:+ yych = *++YYCURSOR;+ goto yy49;+yy51:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case ';':+ case '<':+ case '=':+ case '>':+ case '?':+ case '@':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '[':+ case '\\':+ case ']':+ case '^':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy51;+ case ':': goto yy53;+ default: goto yy47;+ }+yy53:+ yych = *++YYCURSOR;+ switch(yych){+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case ':':+ case ';':+ case '<':+ case '=':+ case '>':+ case '?':+ case '@':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '[':+ case '\\':+ case ']':+ case '^':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy54;+ default: goto yy47;+ }+yy54:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy56;+ case 0x0D: goto yy58;+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case ':':+ case ';':+ case '<':+ case '=':+ case '>':+ case '?':+ case '@':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '[':+ case '\\':+ case ']':+ case '^':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy54;+ default: goto yy47;+ }+yy56:+ ++YYCURSOR;+#line 396 "bytecode.re"+ { CHK_NL(YYCURSOR);+ goto Directive; }+#line 903 "<stdout>"+yy58:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy56;+ default: goto yy47;+ }+}+#line 402 "bytecode.re"+++ }++Comment:+ {+ YYTOKEN = YYCURSOR;+++#line 921 "<stdout>"+{+ YYCTYPE yych;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy61;+ case 0x0A: goto yy62;+ case 0x0D: goto yy64;+ default: goto yy66;+ }+yy61:+yy62:+ ++YYCURSOR;+yy63:+#line 412 "bytecode.re"+ { CHK_NL(YYCURSOR);+ goto Document; }+#line 939 "<stdout>"+yy64:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy67;+ default: goto yy65;+ }+yy65:+#line 415 "bytecode.re"+ { goto Comment; }+#line 949 "<stdout>"+yy66:+ yych = *++YYCURSOR;+ goto yy65;+yy67:+ ++YYCURSOR;+ yych = *YYCURSOR;+ goto yy63;+}+#line 417 "bytecode.re"+++ }++Scalar:+ {+ int idx = 0;+ int cap = 100;+ char *str = S_ALLOC_N( char, cap );+ char *tok;++ str[0] = '\0';++Scalar2:+ tok = YYCURSOR;+++#line 976 "<stdout>"+{+ YYCTYPE yych;+ if((YYLIMIT - YYCURSOR) < 3) YYFILL(3);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy74;+ case 0x0A: goto yy70;+ case 0x0D: goto yy72;+ default: goto yy76;+ }+yy70:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 'C': goto yy78;+ case 'N': goto yy80;+ case 'Z': goto yy83;+ default: goto yy71;+ }+yy71:+#line 461 "bytecode.re"+ { YYCURSOR = tok;+ goto ScalarEnd; + }+#line 1000 "<stdout>"+yy72:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy77;+ default: goto yy73;+ }+yy73:+#line 469 "bytecode.re"+ { CAT(str, cap, idx, tok[0]);+ goto Scalar2; + }+#line 1012 "<stdout>"+yy74:+ ++YYCURSOR;+#line 465 "bytecode.re"+ { YYCURSOR = tok;+ goto ScalarEnd;+ }+#line 1019 "<stdout>"+yy76:+ yych = *++YYCURSOR;+ goto yy73;+yy77:+ yych = *++YYCURSOR;+ switch(yych){+ case 'C': goto yy78;+ case 'N': goto yy80;+ case 'Z': goto yy83;+ default: goto yy71;+ }+yy78:+ ++YYCURSOR;+#line 435 "bytecode.re"+ { CHK_NL(tok+1);+ goto Scalar2; }+#line 1036 "<stdout>"+yy80:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy80;+ default: goto yy82;+ }+yy82:+#line 438 "bytecode.re"+ { CHK_NL(tok+1);+ if ( tok + 2 < YYCURSOR )+ {+ char *count = tok + 2;+ int total = strtod( count, NULL );+ int i;+ for ( i = 0; i < total; i++ )+ {+ CAT(str, cap, idx, '\n');+ }+ }+ else+ {+ CAT(str, cap, idx, '\n');+ }+ goto Scalar2;+ }+#line 1073 "<stdout>"+yy83:+ ++YYCURSOR;+#line 456 "bytecode.re"+ { CHK_NL(tok+1);+ CAT(str, cap, idx, '\0');+ goto Scalar2; + }+#line 1081 "<stdout>"+}+#line 473 "bytecode.re"+++ScalarEnd:+ {+ SyckNode *n = syck_alloc_str();+ n->data.str->ptr = str;+ n->data.str->len = idx;+ sycklval->nodeData = n;+ POP_LEVEL();+ if ( parser->implicit_typing == 1 )+ {+ try_tag_implicit( sycklval->nodeData, parser->taguri_expansion );+ }+ return YAML_PLAIN;+ }+ }++}++char *+get_inline( SyckParser *parser )+{+ int idx = 0;+ int cap = 100;+ char *str = S_ALLOC_N( char, cap );+ char *tok;++ str[0] = '\0';++Inline:+ {+ tok = YYCURSOR;+++#line 1118 "<stdout>"+{+ YYCTYPE yych;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy91;+ case 0x0A: goto yy87;+ case 0x0D: goto yy89;+ default: goto yy93;+ }+yy87:+ ++YYCURSOR;+yy88:+#line 508 "bytecode.re"+ { CHK_NL(YYCURSOR);+ return str; }+#line 1135 "<stdout>"+yy89:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy94;+ default: goto yy90;+ }+yy90:+#line 515 "bytecode.re"+ { CAT(str, cap, idx, tok[0]);+ goto Inline; + }+#line 1147 "<stdout>"+yy91:+ ++YYCURSOR;+#line 511 "bytecode.re"+ { YYCURSOR = tok;+ return str;+ }+#line 1154 "<stdout>"+yy93:+ yych = *++YYCURSOR;+ goto yy90;+yy94:+ ++YYCURSOR;+ yych = *YYCURSOR;+ goto yy88;+}+#line 519 "bytecode.re"+++ }++}+
+ syck/emitter.c view
@@ -0,0 +1,1285 @@+/*+ * emitter.c+ *+ * $Author: why $+ * $Date: 2006-05-09 12:03:50 +0800 (二, 09 5 2006) $+ *+ * Copyright (C) 2003 why the lucky stiff+ * + * All Base64 code from Ruby's pack.c.+ * Ruby is Copyright (C) 1993-2003 Yukihiro Matsumoto + */+#include <stdio.h>+#include <string.h>++#include "syck.h"++#define DEFAULT_ANCHOR_FORMAT "id%03d"++const char hex_table[] = +"0123456789ABCDEF";+static char b64_table[] =+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";++/*+ * Built-in base64 (from Ruby's pack.c)+ */+char *+syck_base64enc( char *s, long len )+{+ long i = 0;+ int padding = '=';+ char *buff = S_ALLOC_N(char, len * 4 / 3 + 6);++ while (len >= 3) {+ buff[i++] = b64_table[077 & (*s >> 2)];+ buff[i++] = b64_table[077 & (((*s << 4) & 060) | ((s[1] >> 4) & 017))];+ buff[i++] = b64_table[077 & (((s[1] << 2) & 074) | ((s[2] >> 6) & 03))];+ buff[i++] = b64_table[077 & s[2]];+ s += 3;+ len -= 3;+ }+ if (len == 2) {+ buff[i++] = b64_table[077 & (*s >> 2)];+ buff[i++] = b64_table[077 & (((*s << 4) & 060) | ((s[1] >> 4) & 017))];+ buff[i++] = b64_table[077 & (((s[1] << 2) & 074) | (('\0' >> 6) & 03))];+ buff[i++] = padding;+ }+ else if (len == 1) {+ buff[i++] = b64_table[077 & (*s >> 2)];+ buff[i++] = b64_table[077 & (((*s << 4) & 060) | (('\0' >> 4) & 017))];+ buff[i++] = padding;+ buff[i++] = padding;+ }++ /* XXX - Changed by Audrey Tang to terminate the string instead of adding an useless \n */+ buff[i++] = '\0';+ return buff;+}++/* XXX - Changed by Audrey Tang to deal with \0 in decoded base64 buffers */+char *+syck_base64dec( char *s, long len, long *out_len )+{+ int a = -1,b = -1,c = 0,d;+ static int first = 1;+ static int b64_xtable[256];+ char *ptr = syck_strndup( s, len );+ char *end = ptr;+ char *send = s + len;++ if (first) {+ int i;+ first = 0;++ for (i = 0; i < 256; i++) {+ b64_xtable[i] = -1;+ }+ for (i = 0; i < 64; i++) {+ b64_xtable[(int)b64_table[i]] = i;+ }+ }+ while (s < send) {+ while (s[0] == '\r' || s[0] == '\n') { s++; }+ if ((a = b64_xtable[(int)s[0]]) == -1) break;+ if ((b = b64_xtable[(int)s[1]]) == -1) break;+ if ((c = b64_xtable[(int)s[2]]) == -1) break;+ if ((d = b64_xtable[(int)s[3]]) == -1) break;+ *end++ = a << 2 | b >> 4;+ *end++ = b << 4 | c >> 2;+ *end++ = c << 6 | d;+ s += 4;+ }+ if (a != -1 && b != -1) {+ if (s + 2 < send && s[2] == '=')+ *end++ = a << 2 | b >> 4;+ if (c != -1 && s + 3 < send && s[3] == '=') {+ *end++ = a << 2 | b >> 4;+ *end++ = b << 4 | c >> 2;+ }+ }+ *end = '\0';+ /*RSTRING(buf)->len = ptr - RSTRING(buf)->ptr;*/++ *out_len = end - ptr;+ return ptr;+}++/*+ * Allocate an emitter+ */+SyckEmitter *+syck_new_emitter()+{+ SyckEmitter *e;+ e = S_ALLOC( SyckEmitter );+ e->headless = 0;+ e->use_header = 0;+ e->use_version = 0;+ e->sort_keys = 0;+ e->anchor_format = NULL;+ e->explicit_typing = 0;+ e->best_width = 80;+ e->style = scalar_none;+ e->stage = doc_open;+ e->indent = 2;+ e->level = -1;+ e->anchors = NULL;+ e->markers = NULL;+ e->anchored = NULL;+ e->bufsize = SYCK_BUFFERSIZE;+ e->buffer = NULL;+ e->marker = NULL;+ e->bufpos = 0;+ e->emitter_handler = NULL;+ e->output_handler = NULL;+ e->lvl_idx = 0;+ e->lvl_capa = ALLOC_CT;+ e->levels = S_ALLOC_N( SyckLevel, e->lvl_capa ); + syck_emitter_reset_levels( e );+ e->bonus = NULL;+ return e;+}++int+syck_st_free_anchors( char *key, char *name, char *arg )+{+ S_FREE( name );+ return ST_CONTINUE;+}++void+syck_emitter_st_free( SyckEmitter *e )+{+ /*+ * Free the anchor tables+ */+ if ( e->anchors != NULL )+ {+ st_foreach( e->anchors, syck_st_free_anchors, 0 );+ st_free_table( e->anchors );+ e->anchors = NULL;+ }++ if ( e->anchored != NULL )+ {+ st_free_table( e->anchored );+ e->anchored = NULL;+ }++ /*+ * Free the markers tables+ */+ if ( e->markers != NULL )+ {+ st_free_table( e->markers );+ e->markers = NULL;+ }+}++SyckLevel *+syck_emitter_current_level( SyckEmitter *e )+{+ return &e->levels[e->lvl_idx-1];+}++SyckLevel *+syck_emitter_parent_level( SyckEmitter *e )+{+ return &e->levels[e->lvl_idx-2];+}++void+syck_emitter_pop_level( SyckEmitter *e )+{+ ASSERT( e != NULL );++ /* The root level should never be popped */+ if ( e->lvl_idx <= 1 ) return;++ e->lvl_idx -= 1;+ free( e->levels[e->lvl_idx].domain );+}++void +syck_emitter_add_level( SyckEmitter *e, int len, enum syck_level_status status )+{+ ASSERT( e != NULL );+ if ( e->lvl_idx + 1 > e->lvl_capa )+ {+ e->lvl_capa += ALLOC_CT;+ S_REALLOC_N( e->levels, SyckLevel, e->lvl_capa );+ }++ ASSERT( len > e->levels[e->lvl_idx-1].spaces );+ e->levels[e->lvl_idx].spaces = len;+ e->levels[e->lvl_idx].ncount = 0;+ e->levels[e->lvl_idx].domain = syck_strndup( e->levels[e->lvl_idx-1].domain, strlen( e->levels[e->lvl_idx-1].domain ) );+ e->levels[e->lvl_idx].status = status;+ e->levels[e->lvl_idx].anctag = 0;+ e->lvl_idx += 1;+}++void+syck_emitter_reset_levels( SyckEmitter *e )+{+ while ( e->lvl_idx > 1 )+ {+ syck_emitter_pop_level( e );+ }++ if ( e->lvl_idx < 1 )+ {+ e->lvl_idx = 1;+ e->levels[0].spaces = -1;+ e->levels[0].ncount = 0;+ e->levels[0].domain = syck_strndup( "", 0 );+ e->levels[0].anctag = 0;+ }+ e->levels[0].status = syck_lvl_header;+}++void+syck_emitter_handler( SyckEmitter *e, SyckEmitterHandler hdlr )+{+ e->emitter_handler = hdlr;+}++void+syck_output_handler( SyckEmitter *e, SyckOutputHandler hdlr )+{+ e->output_handler = hdlr;+}++void+syck_free_emitter( SyckEmitter *e )+{+ /*+ * Free tables+ */+ syck_emitter_st_free( e );+ syck_emitter_reset_levels( e );+ S_FREE( e->levels[0].domain );+ S_FREE( e->levels );+ if ( e->buffer != NULL )+ {+ S_FREE( e->buffer );+ }+ S_FREE( e );+}++void+syck_emitter_clear( SyckEmitter *e )+{+ if ( e->buffer == NULL )+ {+ e->buffer = S_ALLOC_N( char, e->bufsize );+ S_MEMZERO( e->buffer, char, e->bufsize );+ }+ e->buffer[0] = '\0';+ e->marker = e->buffer;+ e->bufpos = 0;+}++/*+ * Raw write to the emitter buffer.+ */+void+syck_emitter_write( SyckEmitter *e, char *str, long len )+{+ long at;+ ASSERT( str != NULL )+ if ( e->buffer == NULL )+ {+ syck_emitter_clear( e );+ }+ + /*+ * Flush if at end of buffer+ */+ at = e->marker - e->buffer;+ if ( len + at >= e->bufsize )+ {+ syck_emitter_flush( e, 0 );+ for (;;) {+ long rest = e->bufsize - (e->marker - e->buffer);+ if (len <= rest) break;+ S_MEMCPY( e->marker, str, char, rest );+ e->marker += rest;+ str += rest;+ len -= rest;+ syck_emitter_flush( e, 0 );+ }+ }++ /*+ * Write to buffer+ */+ S_MEMCPY( e->marker, str, char, len );+ e->marker += len;+}++/*+ * Write a chunk of data out.+ */+void+syck_emitter_flush( SyckEmitter *e, long check_room )+{+ /*+ * Check for enough space in the buffer for check_room length.+ */+ if ( check_room > 0 )+ {+ if ( e->bufsize > ( e->marker - e->buffer ) + check_room )+ {+ return;+ }+ }+ else+ {+ check_room = e->bufsize;+ }++ /*+ * Commit buffer.+ */+ if ( check_room > e->marker - e->buffer )+ {+ check_room = e->marker - e->buffer;+ }+ (e->output_handler)( e, e->buffer, check_room );+ e->bufpos += check_room;+ e->marker -= check_room;+}++/*+ * Start emitting from the given node, check for anchoring and then+ * issue the callback to the emitter handler.+ */+void+syck_emit( SyckEmitter *e, st_data_t n )+{+ SYMID oid;+ char *anchor_name = NULL;+ int indent = 0;+ long x = 0;+ SyckLevel *parent;+ SyckLevel *lvl = syck_emitter_current_level( e );+ + /*+ * Determine headers.+ */+ if ( e->stage == doc_open && ( e->headless == 0 || e->use_header == 1 ) )+ {+ if ( e->use_version == 1 )+ {+ char *header = S_ALLOC_N( char, 64 );+ S_MEMZERO( header, char, 64 );+ sprintf( header, "--- %%YAML:%d.%d ", SYCK_YAML_MAJOR, SYCK_YAML_MINOR );+ syck_emitter_write( e, header, strlen( header ) );+ S_FREE( header );+ }+ else+ {+ syck_emitter_write( e, "--- ", 4 );+ }+ e->stage = doc_processing;+ }++ /* Add new level */+ if ( lvl->spaces >= 0 ) {+ indent = lvl->spaces + e->indent;+ }+ syck_emitter_add_level( e, indent, syck_lvl_open );+ parent = lvl;+ lvl = syck_emitter_current_level( e );++ /* Look for anchor */+ if ( e->anchors != NULL &&+ st_lookup( e->markers, n, (st_data_t *)&oid ) &&+ st_lookup( e->anchors, (st_data_t)oid, (st_data_t *)&anchor_name ) )+ {+ if ( e->anchored == NULL )+ {+ e->anchored = st_init_numtable();+ }++ if ( ! st_lookup( e->anchored, (st_data_t)anchor_name, (st_data_t *)&x ) )+ {+ char *an = S_ALLOC_N( char, strlen( anchor_name ) + 3 );+ sprintf( an, "&%s ", anchor_name );++ /* Complex key */+ if ( parent->status == syck_lvl_map && parent->ncount % 2 == 1) {+ syck_emitter_write( e, "? ", 2 );+ parent->status = syck_lvl_mapx;+ }++ syck_emitter_write( e, an, strlen( anchor_name ) + 2 );+ free( an );++ x = 1;+ st_insert( e->anchored, (st_data_t)anchor_name, (st_data_t)x );+ lvl->anctag = 1;+ }+ 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 );+ free( an );++ goto end_emit;+ }+ }++ (e->emitter_handler)( e, n );++ /* Pop the level */+end_emit:+ syck_emitter_pop_level( e );+ if ( e->lvl_idx == 1 ) {+ syck_emitter_write( e, "\n", 1 );+ e->headless = 0;+ e->stage = doc_open;+ }+}++/*+ * Determine what tag needs to be written, based on the taguri of the node+ * and the implicit tag which would be assigned to this node. If a tag is+ * required, write the tag.+ */+void syck_emit_tag( SyckEmitter *e, char *tag, char *ignore )+{+ SyckLevel *lvl;+ if ( tag == NULL ) return;+ if ( ignore != NULL && syck_tagcmp( tag, ignore ) == 0 && e->explicit_typing == 0 ) return;+ lvl = syck_emitter_current_level( e );++ /* implicit */+ if ( strlen( tag ) == 0 ) {+ syck_emitter_write( e, "! ", 2 );++ /* global types */+ } else if ( strncmp( tag, "tag:", 4 ) == 0 ) {+ int taglen = strlen( tag );+ syck_emitter_write( e, "!", 1 );+ if ( strncmp( tag + 4, YAML_DOMAIN, strlen( YAML_DOMAIN ) ) == 0 ) {+ int skip = 4 + strlen( YAML_DOMAIN ) + 1;+ syck_emitter_write( e, tag + skip, taglen - skip );+ } else {+ char *subd = tag + 4;+ while ( *subd != ':' && *subd != '\0' ) subd++;+ if ( *subd == ':' ) {+ if ( subd - tag > ( strlen( YAML_DOMAIN ) + 5 ) &&+ strncmp( subd - strlen( YAML_DOMAIN ), YAML_DOMAIN, strlen( YAML_DOMAIN ) ) == 0 ) {+ syck_emitter_write( e, tag + 4, subd - strlen( YAML_DOMAIN ) - ( tag + 4 ) - 1 );+ syck_emitter_write( e, "/", 1 );+ syck_emitter_write( e, subd + 1, ( tag + taglen ) - ( subd + 1 ) );+ } else {+ syck_emitter_write( e, tag + 4, subd - ( tag + 4 ) );+ syck_emitter_write( e, "/", 1 );+ syck_emitter_write( e, subd + 1, ( tag + taglen ) - ( subd + 1 ) );+ }+ } else {+ /* TODO: Invalid tag (no colon after domain) */+ return;+ }+ }+ syck_emitter_write( e, " ", 1 );++ /* private types */+ } else if ( strncmp( tag, "x-private:", 10 ) == 0 ) {+ syck_emitter_write( e, "!!", 2 );+ syck_emitter_write( e, tag + 10, strlen( tag ) - 10 );+ syck_emitter_write( e, " ", 1 );+ }+ lvl->anctag = 1;+}++/* + * Emit a newline and an appropriately spaced indent.+ */+void syck_emit_indent( SyckEmitter *e )+{+ int i;+ SyckLevel *lvl = syck_emitter_current_level( e );+ if ( e->bufpos == 0 && ( e->marker - e->buffer ) == 0 ) return;+ if ( lvl->spaces >= 0 ) {+ char *spcs = S_ALLOC_N( char, lvl->spaces + 2 );++ spcs[0] = '\n'; spcs[lvl->spaces + 1] = '\0';+ for ( i = 0; i < lvl->spaces; i++ ) spcs[i+1] = ' ';+ syck_emitter_write( e, spcs, lvl->spaces + 1 );+ free( spcs );+ }+}++/* Clear the scan */+#define SCAN_NONE 0+/* All printable characters? */+#define SCAN_NONPRINT 1+/* Any indented lines? */+#define SCAN_INDENTED 2+/* Larger than the requested width? */+#define SCAN_WIDE 4+/* Opens or closes with whitespace? */+#define SCAN_WHITEEDGE 8+/* Contains a newline */+#define SCAN_NEWLINE 16+/* Contains a single quote */+#define SCAN_SINGLEQ 32+/* Contains a double quote */+#define SCAN_DOUBLEQ 64+/* Starts with a token */+#define SCAN_INDIC_S 128+/* Contains a flow indicator */+#define SCAN_INDIC_C 256+/* Ends without newlines */+#define SCAN_NONL_E 512+/* Ends with many newlines */+#define SCAN_MANYNL_E 1024+/* Contains flow map indicators */+#define SCAN_FLOWMAP 2048+/* Contains flow seq indicators */+#define SCAN_FLOWSEQ 4096+/* Contains a valid doc separator */+#define SCAN_DOCSEP 8192++/*+ * Basic printable test for LATIN-1 characters.+ */+int+syck_scan_scalar( int req_width, char *cursor, long len )+{+ long i = 0, start = 0;+ int flags = SCAN_NONE;++ if ( len < 1 ) return flags;++ /* c-indicators from the spec */+ if ( cursor[0] == '[' || cursor[0] == ']' ||+ cursor[0] == '{' || cursor[0] == '}' ||+ cursor[0] == '!' || cursor[0] == '*' ||+ cursor[0] == '&' || cursor[0] == '|' ||+ cursor[0] == '>' || cursor[0] == '\'' ||+ cursor[0] == '"' || cursor[0] == '#' ||+ cursor[0] == '%' || cursor[0] == '@' ||+ cursor[0] == '&' || cursor[0] == '^' ) {+ flags |= SCAN_INDIC_S;+ }+ if ( ( cursor[0] == '-' || cursor[0] == ':' ||+ cursor[0] == '?' || cursor[0] == ',' ) &&+ ( cursor[1] == ' ' || cursor[1] == '\n' || len == 1 ) )+ {+ flags |= SCAN_INDIC_S;+ }++ /* whitespace edges */+ if ( cursor[len-1] != '\n' ) {+ flags |= SCAN_NONL_E;+ } else if ( len > 1 && cursor[len-2] == '\n' ) {+ flags |= SCAN_MANYNL_E;+ }+ if ( + ( len > 0 && ( cursor[0] == ' ' || cursor[0] == '\t' ) ) ||+ ( len > 1 && ( cursor[len-1] == ' ' || cursor[len-1] == '\t' ) )+ ) {+ flags |= SCAN_WHITEEDGE;+ }++ /* opening doc sep */+ if ( len >= 3 && strncmp( cursor, "---", 3 ) == 0 )+ flags |= SCAN_DOCSEP;++ /* scan string */+ for ( i = 0; i < len; i++ ) {++ if ( ! ( cursor[i] == 0x9 ||+ cursor[i] == 0xA ||+ cursor[i] == 0xD ||+ ( cursor[i] >= 0x20 && cursor[i] <= 0x7E ) )+ ) {+ flags |= SCAN_NONPRINT;+ }+ else if ( cursor[i] == '\n' ) {+ flags |= SCAN_NEWLINE;+ if ( len - i >= 3 && strncmp( &cursor[i+1], "---", 3 ) == 0 )+ flags |= SCAN_DOCSEP;+ if ( cursor[i+1] == ' ' || cursor[i+1] == '\t' ) + flags |= SCAN_INDENTED;+ if ( req_width > 0 && i - start > req_width )+ flags |= SCAN_WIDE;+ start = i;+ }+ else if ( cursor[i] == '\'' )+ {+ flags |= SCAN_SINGLEQ;+ }+ else if ( cursor[i] == '"' )+ {+ flags |= SCAN_DOUBLEQ;+ }+ else if ( cursor[i] == ']' )+ {+ flags |= SCAN_FLOWSEQ;+ }+ else if ( cursor[i] == '}' )+ {+ flags |= SCAN_FLOWMAP;+ }+ /* remember, if plain collections get implemented, to add nb-plain-flow-char */+ else if ( ( cursor[i] == ' ' && cursor[i+1] == '#' ) ||+ ( cursor[i] == ':' && + ( cursor[i+1] == ' ' || cursor[i+1] == '\n' || i == len - 1 ) ) )+ {+ flags |= SCAN_INDIC_C;+ }+ else if ( cursor[i] == ',' && + ( cursor[i+1] == ' ' || cursor[i+1] == '\n' || i == len - 1 ) )+ {+ flags |= SCAN_FLOWMAP;+ flags |= SCAN_FLOWSEQ;+ }+ }++ /* printf( "---STR---\n%s\nFLAGS: %d\n", cursor, flags ); */+ return flags;+}+/*+ * All scalars should be emitted through this function, which determines an appropriate style,+ * tag and indent.+ */+void syck_emit_scalar( SyckEmitter *e, char *tag, enum scalar_style force_style, int force_indent, int force_width,+ char keep_nl, char *str, long len )+{+ enum scalar_style favor_style = scalar_literal;+ SyckLevel *parent = syck_emitter_parent_level( e );+ SyckLevel *lvl = syck_emitter_current_level( e );+ int scan = 0;+ char *implicit;+ + if ( str == NULL ) str = "";++ /* No empty nulls as map keys */+ if ( len == 0 && ( parent->status == syck_lvl_map || parent->status == syck_lvl_imap ) && + parent->ncount % 2 == 1 && syck_tagcmp( tag, "tag:yaml.org,2002:null" ) == 0 ) + {+ str = "~";+ len = 1;+ }++ scan = syck_scan_scalar( force_width, str, len );+ implicit = syck_match_implicit( str, len );++ /* quote strings which default to implicits */+ implicit = syck_taguri( YAML_DOMAIN, implicit, strlen( implicit ) );+ if ( syck_tagcmp( tag, implicit ) != 0 && syck_tagcmp( tag, "tag:yaml.org,2002:str" ) == 0 ) {+ force_style = scalar_2quote;+ } else {+ /* complex key */+ if ( parent->status == syck_lvl_map && parent->ncount % 2 == 1 &&+ ( !( tag == NULL || + ( implicit != NULL && syck_tagcmp( tag, implicit ) == 0 && e->explicit_typing == 0 ) ) ) ) + {+ syck_emitter_write( e, "? ", 2 );+ parent->status = syck_lvl_mapx;+ }+ syck_emit_tag( e, tag, implicit );+ }+ S_FREE( implicit );++ /* if still arbitrary, sniff a good block style. */+ if ( force_style == scalar_none ) {+ if ( scan & SCAN_NEWLINE ) {+ force_style = scalar_literal;+ } else {+ force_style = scalar_plain;+ }+ }++ if ( e->style == scalar_fold ) {+ favor_style = scalar_fold;+ }++ /* Determine block style */+ if ( (scan & SCAN_NONPRINT) && (e->style != scalar_fold) ) {+ force_style = scalar_2quote;+ } else if ( force_style != scalar_1quote && ( scan & SCAN_WHITEEDGE ) ) {+ force_style = scalar_2quote;+ } else if ( force_style != scalar_fold && ( scan & SCAN_INDENTED ) ) {+ force_style = scalar_literal;+ } else if ( force_style == scalar_plain && ( scan & SCAN_NEWLINE ) ) {+ force_style = favor_style;+ } else if ( force_style == scalar_plain && parent->status == syck_lvl_iseq && ( scan & SCAN_FLOWSEQ ) ) {+ force_style = scalar_2quote;+ } else if ( force_style == scalar_plain && parent->status == syck_lvl_imap && ( scan & SCAN_FLOWMAP ) ) {+ force_style = scalar_2quote;+ /* } else if ( force_style == scalar_fold && ( ! ( scan & SCAN_WIDE ) ) ) {+ force_style = scalar_literal; */+ } else if ( force_style == scalar_plain && ( scan & SCAN_INDIC_S || scan & SCAN_INDIC_C ) ) {+ if ( scan & SCAN_NEWLINE ) {+ force_style = favor_style;+ } else {+ force_style = scalar_2quote;+ }+ }++ if ( force_indent > 0 ) {+ lvl->spaces = parent->spaces + force_indent;+ } else if ( scan & SCAN_DOCSEP ) {+ lvl->spaces = parent->spaces + e->indent;+ }++ /* For now, all ambiguous keys are going to be double-quoted */+ if ( ( parent->status == syck_lvl_map || parent->status == syck_lvl_mapx ) && parent->ncount % 2 == 1 ) {+ if ( force_style != scalar_plain ) {+ force_style = scalar_2quote;+ }+ }++ /* If the parent is an inline, double quote anything complex */+ if ( parent->status == syck_lvl_imap || parent->status == syck_lvl_iseq ) {+ if ( force_style != scalar_plain && force_style != scalar_1quote ) {+ force_style = scalar_2quote;+ }+ }++ /* Fix the ending newlines */+ if ( scan & SCAN_NONL_E ) {+ keep_nl = NL_CHOMP;+ } else if ( scan & SCAN_MANYNL_E ) {+ keep_nl = NL_KEEP;+ }++ /* Write the text node */+ switch ( force_style )+ {+ case scalar_1quote:+ syck_emit_1quoted( e, force_width, str, len );+ break;++ case scalar_none:+ case scalar_2quote:+ syck_emit_2quoted( e, force_width, str, len );+ break;++ case scalar_fold:+ syck_emit_folded( e, force_width, keep_nl, str, len );+ break;++ case scalar_literal:+ /* syck_emit_literal( e, keep_nl, str, len ); */+ syck_emit_2quoted( e, force_width, str, len );+ break;++ case scalar_plain:+ syck_emitter_write( e, str, len );+ break;+ }++ if ( parent->status == syck_lvl_mapx )+ {+ syck_emitter_write( e, "\n", 1 );+ }+}++void+syck_emitter_escape( SyckEmitter *e, char *src, long len )+{+ int i;+ for( i = 0; i < len; i++ )+ {+ /* XXX - scalar_fold overloaded to mean utf8 from Audrey Tang */+ if( (e->style == scalar_fold)+ ? ((src[i] < 0x20) && (0 < src[i]))+ : ((src[i] < 0x20) || (0x7E < src[i])) )+ {+ syck_emitter_write( e, "\\", 1 );+ if( '\0' == src[i] )+ syck_emitter_write( e, "0", 1 );+ else+ {+ syck_emitter_write( e, "x", 1 );+ syck_emitter_write( e, (char *)hex_table + ((src[i] & 0xF0) >> 4), 1 );+ syck_emitter_write( e, (char *)hex_table + (src[i] & 0x0F), 1 );+ }+ }+ else+ {+ syck_emitter_write( e, src + i, 1 );+ if( '\\' == src[i] )+ syck_emitter_write( e, "\\", 1 );+ }+ }+}++/*+ * Outputs a single-quoted block.+ */+void syck_emit_1quoted( SyckEmitter *e, int width, char *str, long len )+{+ char do_indent = 0;+ char *mark = str;+ char *start = str;+ char *end = str;+ syck_emitter_write( e, "'", 1 );+ while ( mark < str + len ) {+ if ( do_indent ) {+ syck_emit_indent( e );+ do_indent = 0;+ }+ switch ( *mark ) {+ case '\'': syck_emitter_write( e, "\\'", 2 ); break;++ case '\n':+ end = mark + 1;+ if ( *start != ' ' && *start != '\n' && *end != '\n' && *end != ' ' ) {+ syck_emitter_write( e, "\n\n", 2 );+ } else {+ syck_emitter_write( e, "\n", 1 );+ }+ do_indent = 1;+ start = mark + 1;+ break;++ case ' ':+ if ( width > 0 && *start != ' ' && mark - end > width ) {+ do_indent = 1;+ end = mark + 1;+ } else {+ syck_emitter_write( e, " ", 1 );+ }+ break;++ default:+ syck_emitter_write( e, mark, 1 );+ break;+ }+ mark++;+ }+ syck_emitter_write( e, "'", 1 );+}++/*+ * Outputs a double-quoted block.+ */+void syck_emit_2quoted( SyckEmitter *e, int width, char *str, long len )+{+ char do_indent = 0;+ char *mark = str;+ char *start = str;+ char *end = str;+ syck_emitter_write( e, "\"", 1 );+ while ( mark < str + len ) {+ if ( do_indent > 0 ) {+ if ( do_indent == 2 ) {+ syck_emitter_write( e, "\\", 1 );+ }+ syck_emit_indent( e );+ do_indent = 0;+ }+ switch ( *mark ) {++ /* Escape sequences allowed within double quotes. */+ case '"': syck_emitter_write( e, "\\\"", 2 ); break;+ case '\\': syck_emitter_write( e, "\\\\", 2 ); break;+ case '\0': syck_emitter_write( e, "\\0", 2 ); break;+ case '\a': syck_emitter_write( e, "\\a", 2 ); break;+ case '\b': syck_emitter_write( e, "\\b", 2 ); break;+ case '\f': syck_emitter_write( e, "\\f", 2 ); break;+ case '\r': syck_emitter_write( e, "\\r", 2 ); break;+ case '\t': syck_emitter_write( e, "\\t", 2 ); break;+ case '\v': syck_emitter_write( e, "\\v", 2 ); break;+ case 0x1b: syck_emitter_write( e, "\\e", 2 ); break;+ case '\n': syck_emitter_write( e, "\\n", 2 ); break;++ /* XXX - Disabled by Audrey Tang for YAML.pm compat+ case '\n':+ end = mark + 1;+ syck_emitter_write( e, "\\n", 2 );+ do_indent = e->indent;+ start = mark + 1;+ if ( start < str + len && ( *start == ' ' || *start == '\n' ) ) {+ do_indent = 0;+ }+ break;+ */++ case ' ':+ if ( width > 0 && *start != ' ' && mark - end > width ) {+ do_indent = 1;+ end = mark + 1;+ } else {+ syck_emitter_write( e, " ", 1 );+ }+ break;++ default:+ syck_emitter_escape( e, mark, 1 );+ break;+ }+ mark++;+ }+ syck_emitter_write( e, "\"", 1 );+}++/*+ * Outputs a literal block.+ */+void syck_emit_literal( SyckEmitter *e, char keep_nl, char *str, long len )+{+ char *mark = str;+ char *start = str;+ char *end = str;+ syck_emitter_write( e, "|", 1 );+ if ( keep_nl == NL_CHOMP ) {+ syck_emitter_write( e, "-", 1 );+ } else if ( keep_nl == NL_KEEP ) {+ syck_emitter_write( e, "+", 1 );+ }+ syck_emit_indent( e );+ while ( mark < str + len ) {+ if ( *mark == '\n' ) {+ end = mark;+ if ( *start != ' ' && *start != '\n' && *end != '\n' && *end != ' ' ) end += 1;+ syck_emitter_write( e, start, end - start );+ if ( mark + 1 == str + len ) {+ if ( keep_nl != NL_KEEP ) syck_emitter_write( e, "\n", 1 );+ } else {+ syck_emit_indent( e );+ }+ start = mark + 1;+ }+ mark++;+ }+ end = str + len;+ if ( start < end ) {+ syck_emitter_write( e, start, end - start );+ }+}++/*+ * Outputs a folded block.+ */+void syck_emit_folded( SyckEmitter *e, int width, char keep_nl, char *str, long len )+{+ char *mark = str;+ char *start = str;+ char *end = str;+ syck_emitter_write( e, ">", 1 );+ if ( keep_nl == NL_CHOMP ) {+ syck_emitter_write( e, "-", 1 );+ } else if ( keep_nl == NL_KEEP ) {+ syck_emitter_write( e, "+", 1 );+ }+ syck_emit_indent( e );+ if ( width <= 0 ) width = e->best_width;+ while ( mark < str + len ) {+ switch ( *mark ) {+ case '\n':+ syck_emitter_write( e, end, mark - end );+ end = mark + 1;+ if ( *start != ' ' && *start != '\n' && *end != '\n' && *end != ' ' ) {+ syck_emitter_write( e, "\n", 1 );+ }+ if ( mark + 1 == str + len ) {+ if ( keep_nl != NL_KEEP ) syck_emitter_write( e, "\n", 1 );+ } else {+ syck_emit_indent( e );+ }+ start = mark + 1;+ break;++ case ' ':+ if ( *start != ' ' ) {+ if ( mark - end > width ) {+ syck_emitter_write( e, end, mark - end );+ syck_emit_indent( e );+ end = mark + 1;+ }+ }+ break;+ }+ mark++;+ }+ if ( end < mark ) {+ syck_emitter_write( e, end, mark - end );+ }+}++/*+ * Begins emission of a sequence.+ */+void syck_emit_seq( SyckEmitter *e, char *tag, enum seq_style style )+{+ SyckLevel *parent = syck_emitter_parent_level( e );+ SyckLevel *lvl = syck_emitter_current_level( e );++ /* complex key+ * There should also be the check "&& style == seq_none",+ * but unfortunately syck cannot parse flow collections as simple keys+ * now, so we will make a complex key.+ * Add the check when syck is able to parse "[]: foo" */+ if ( parent->status == syck_lvl_map && parent->ncount % 2 == 1 ) {+ syck_emitter_write( e, "? ", 2 );+ parent->status = syck_lvl_mapx;+ }++ syck_emit_tag( e, tag, "tag:yaml.org,2002:seq" );+ if ( style == seq_inline || ( parent->status == syck_lvl_imap || parent->status == syck_lvl_iseq ) ) {+ syck_emitter_write( e, "[", 1 );+ lvl->status = syck_lvl_iseq;+ } else {+ lvl->status = syck_lvl_seq;+ }+}++/*+ * Begins emission of a mapping.+ */+void syck_emit_map( SyckEmitter *e, char *tag, enum map_style style )+{+ SyckLevel *parent = syck_emitter_parent_level( e );+ SyckLevel *lvl = syck_emitter_current_level( e );++ /* complex key+ * There should also be the check "&& style == map_none",+ * but unfortunately syck cannot parse flow collections as simple keys+ * now, so we will make a complex key.+ * Add the check when syck is able to parse "{}: foo". */+ if ( parent->status == syck_lvl_map && parent->ncount % 2 == 1 ) {+ syck_emitter_write( e, "? ", 2 );+ parent->status = syck_lvl_mapx;+ }++ syck_emit_tag( e, tag, "tag:yaml.org,2002:map" );+ if ( style == map_inline || ( parent->status == syck_lvl_imap || parent->status == syck_lvl_iseq ) ) {+ syck_emitter_write( e, "{", 1 );+ lvl->status = syck_lvl_imap;+ } else {+ lvl->status = syck_lvl_map;+ }+}++/*+ * Handles emitting of a collection item (for both+ * sequences and maps)+ */+void syck_emit_item( SyckEmitter *e, st_data_t n )+{+ SyckLevel *lvl = syck_emitter_current_level( e );+ switch ( lvl->status )+ {+ case syck_lvl_seq:+ {+ SyckLevel *parent = syck_emitter_parent_level( e );++ /* seq-in-map shortcut */+ if ( parent->status == syck_lvl_mapx && lvl->ncount == 0 ) {+ /* shortcut -- the lvl->anctag check should be unneccesary but+ * there is a nasty shift/reduce in the parser on this point and+ * i'm not ready to tickle it. */+ if ( parent->ncount % 2 == 0 && lvl->anctag == 0 ) {+ lvl->spaces = parent->spaces;+ }+ }++ /* seq-in-seq shortcut */+ else if ( lvl->anctag == 0 && parent->status == syck_lvl_seq && lvl->ncount == 0 ) {+ int spcs = ( lvl->spaces - parent->spaces ) - 2;+ if ( spcs >= 0 ) {+ int i = 0;+ for ( i = 0; i < spcs; i++ ) {+ syck_emitter_write( e, " ", 1 );+ }+ syck_emitter_write( e, "- ", 2 );+ break;+ }+ }++ syck_emit_indent( e );+ syck_emitter_write( e, "- ", 2 );+ }+ break;++ case syck_lvl_iseq:+ {+ if ( lvl->ncount > 0 ) {+ syck_emitter_write( e, ", ", 2 );+ }+ }+ break;++ case syck_lvl_map:+ {+ SyckLevel *parent = syck_emitter_parent_level( e );++ /* map-in-seq shortcut */+ if ( lvl->anctag == 0 && parent->status == syck_lvl_seq && lvl->ncount == 0 ) {+ int spcs = ( lvl->spaces - parent->spaces ) - 2;+ if ( spcs >= 0 ) {+ int i = 0;+ for ( i = 0; i < spcs; i++ ) {+ syck_emitter_write( e, " ", 1 );+ }+ break;+ }+ }++ if ( lvl->ncount % 2 == 0 ) {+ syck_emit_indent( e );+ } else {+ syck_emitter_write( e, ": ", 2 );+ }+ }+ break;++ case syck_lvl_mapx:+ {+ if ( lvl->ncount % 2 == 0 ) {+ syck_emit_indent( e );+ lvl->status = syck_lvl_map;+ } else {+ int i;+ if ( lvl->spaces > 0 ) {+ char *spcs = S_ALLOC_N( char, lvl->spaces + 1 );++ spcs[lvl->spaces] = '\0';+ for ( i = 0; i < lvl->spaces; i++ ) spcs[i] = ' ';+ syck_emitter_write( e, spcs, lvl->spaces );+ S_FREE( spcs );+ }+ syck_emitter_write( e, ": ", 2 );+ }+ }+ break;++ case syck_lvl_imap:+ {+ if ( lvl->ncount > 0 ) {+ if ( lvl->ncount % 2 == 0 ) {+ syck_emitter_write( e, ", ", 2 );+ } else {+ syck_emitter_write( e, ": ", 2 );+ }+ }+ }+ break;++ default: break;+ }+ lvl->ncount++;++ syck_emit( e, n );+}++/*+ * Closes emission of a collection.+ */+void syck_emit_end( SyckEmitter *e )+{+ SyckLevel *lvl = syck_emitter_current_level( e );+ SyckLevel *parent = syck_emitter_parent_level( e );+ switch ( lvl->status )+ {+ case syck_lvl_seq:+ if ( lvl->ncount == 0 ) {+ syck_emitter_write( e, "[]\n", 3 );+ } else if ( parent->status == syck_lvl_mapx ) {+ syck_emitter_write( e, "\n", 1 );+ }+ break;++ case syck_lvl_iseq:+ syck_emitter_write( e, "]", 1 );+ if ( parent->status == syck_lvl_mapx ) {+ syck_emitter_write( e, "\n", 1 );+ }+ break;++ case syck_lvl_map:+ if ( lvl->ncount == 0 ) {+ syck_emitter_write( e, "{}\n", 3 );+ } else if ( lvl->ncount % 2 == 1 ) {+ syck_emitter_write( e, ":", 1 );+ } else if ( parent->status == syck_lvl_mapx ) {+ syck_emitter_write( e, "\n", 1 );+ }+ break;++ case syck_lvl_imap:+ syck_emitter_write( e, "}", 1 );+ if ( parent->status == syck_lvl_mapx ) {+ syck_emitter_write( e, "\n", 1 );+ }+ break;++ default: break;+ }+}++/*+ * Fill markers table with emitter nodes in the+ * soon-to-be-emitted tree.+ */+SYMID+syck_emitter_mark_node( SyckEmitter *e, st_data_t n )+{+ SYMID oid = 0;+ char *anchor_name = NULL;++ /*+ * Ensure markers table is initialized.+ */+ if ( e->markers == NULL )+ {+ e->markers = st_init_numtable();+ }++ /*+ * Markers table initially marks the string position of the+ * object. Doesn't yet create an anchor, simply notes the+ * position.+ */+ if ( ! st_lookup( e->markers, n, (st_data_t *)&oid ) )+ {+ /*+ * Store all markers+ */+ oid = e->markers->num_entries + 1;+ st_insert( e->markers, n, (st_data_t)oid );+ }+ else+ {+ if ( e->anchors == NULL )+ {+ e->anchors = st_init_numtable();+ }++ if ( ! st_lookup( e->anchors, (st_data_t)oid, (st_data_t *)&anchor_name ) )+ {+ int idx = 0;+ char *anc = ( e->anchor_format == NULL ? DEFAULT_ANCHOR_FORMAT : e->anchor_format );++ /*+ * Second time hitting this object, let's give it an anchor+ */+ idx = e->anchors->num_entries + 1;+ anchor_name = S_ALLOC_N( char, strlen( anc ) + 10 );+ S_MEMZERO( anchor_name, char, strlen( anc ) + 10 );+ sprintf( anchor_name, anc, idx );++ /*+ * Insert into anchors table+ */+ 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;+ }+ return oid;+}+
+ syck/gram.c view
@@ -0,0 +1,1894 @@+/* A Bison parser, made by GNU Bison 1.875d. */++/* Skeleton parser for Yacc-like parsing with Bison,+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.++ This program is free software; you can redistribute it and/or modify+ it under the terms of the GNU General Public License as published by+ the Free Software Foundation; either version 2, or (at your option)+ any later version.++ This program is distributed in the hope that it will be useful,+ but WITHOUT ANY WARRANTY; without even the implied warranty of+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+ GNU General Public License for more details.++ You should have received a copy of the GNU General Public License+ along with this program; if not, write to the Free Software+ Foundation, Inc., 59 Temple Place - Suite 330,+ Boston, MA 02111-1307, USA. */++/* As a special exception, when this file is copied by Bison into a+ Bison output file, you may use that output file without restriction.+ This special exception was added by the Free Software Foundation+ in version 1.24 of Bison. */++/* Written by Richard Stallman by simplifying the original so called+ ``semantic'' parser. */++/* All symbols defined below should begin with yy or YY, to avoid+ infringing on user name space. This should be done even for local+ variables, as they might otherwise be expanded by user macros.+ There are some unavoidable exceptions within include files to+ define necessary library symbols; they are noted "INFRINGES ON+ USER NAME SPACE" below. */++/* Identify Bison output. */+#define YYBISON 1++/* Skeleton name. */+#define YYSKELETON_NAME "yacc.c"++/* Pure parsers. */+#define YYPURE 1++/* Using locations. */+#define YYLSP_NEEDED 0++/* If NAME_PREFIX is specified substitute the variables and functions+ names. */+#define yyparse syckparse+#define yylex sycklex+#define yyerror syckerror+#define yylval sycklval+#define yychar syckchar+#define yydebug syckdebug+#define yynerrs sycknerrs+++/* Tokens. */+#ifndef YYTOKENTYPE+# define YYTOKENTYPE+ /* Put the tokens into the symbol table, so that GDB and other debuggers+ know about them. */+ enum yytokentype {+ YAML_ANCHOR = 258,+ YAML_ALIAS = 259,+ YAML_TRANSFER = 260,+ YAML_TAGURI = 261,+ YAML_ITRANSFER = 262,+ YAML_WORD = 263,+ YAML_PLAIN = 264,+ YAML_BLOCK = 265,+ YAML_DOCSEP = 266,+ YAML_IOPEN = 267,+ YAML_INDENT = 268,+ YAML_IEND = 269+ };+#endif+#define YAML_ANCHOR 258+#define YAML_ALIAS 259+#define YAML_TRANSFER 260+#define YAML_TAGURI 261+#define YAML_ITRANSFER 262+#define YAML_WORD 263+#define YAML_PLAIN 264+#define YAML_BLOCK 265+#define YAML_DOCSEP 266+#define YAML_IOPEN 267+#define YAML_INDENT 268+#define YAML_IEND 269+++++/* Copy the first part of user declarations. */+#line 14 "gram.y"+++#include "syck.h"++void apply_seq_in_map( SyckParser *parser, SyckNode *n );++#define YYPARSE_PARAM parser+#define YYLEX_PARAM parser++#define NULL_NODE(parser, node) \+ SyckNode *node = syck_new_str( "", scalar_plain ); \+ if ( ((SyckParser *)parser)->taguri_expansion == 1 ) \+ { \+ node->type_id = syck_taguri( YAML_DOMAIN, "null", 4 ); \+ } \+ else \+ { \+ node->type_id = syck_strndup( "null", 4 ); \+ }+++/* Enabling traces. */+#ifndef YYDEBUG+# define YYDEBUG 1+#endif++/* Enabling verbose error messages. */+#ifdef YYERROR_VERBOSE+# undef YYERROR_VERBOSE+# define YYERROR_VERBOSE 1+#else+# define YYERROR_VERBOSE 0+#endif++#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)+#line 35 "gram.y"+typedef union YYSTYPE {+ SYMID nodeId;+ SyckNode *nodeData;+ char *name;+} YYSTYPE;+/* Line 191 of yacc.c. */+#line 140 "gram.c"+# define yystype YYSTYPE /* obsolescent; will be withdrawn */+# define YYSTYPE_IS_DECLARED 1+# define YYSTYPE_IS_TRIVIAL 1+#endif++++/* Copy the second part of user declarations. */+++/* Line 214 of yacc.c. */+#line 152 "gram.c"++#if ! defined (yyoverflow) || YYERROR_VERBOSE++# ifndef YYFREE+# define YYFREE free+# endif+# ifndef YYMALLOC+# define YYMALLOC malloc+# endif++/* The parser invokes alloca or malloc; define the necessary symbols. */++# ifdef YYSTACK_USE_ALLOCA+# if YYSTACK_USE_ALLOCA+# define YYSTACK_ALLOC alloca+# endif+# else+# if defined (alloca) || defined (_ALLOCA_H)+# define YYSTACK_ALLOC alloca+# else+# ifdef __GNUC__+# define YYSTACK_ALLOC __builtin_alloca+# endif+# endif+# endif++# ifdef YYSTACK_ALLOC+ /* Pacify GCC's `empty if-body' warning. */+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)+# else+# if defined (__STDC__) || defined (__cplusplus)+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */+# define YYSIZE_T size_t+# endif+# define YYSTACK_ALLOC YYMALLOC+# define YYSTACK_FREE YYFREE+# endif+#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */+++#if (! defined (yyoverflow) \+ && (! defined (__cplusplus) \+ || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))++/* A type that is properly aligned for any stack member. */+union yyalloc+{+ short int yyss;+ YYSTYPE yyvs;+ };++/* The size of the maximum gap between one aligned stack and the next. */+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)++/* The size of an array large to enough to hold all stacks, each with+ N elements. */+# define YYSTACK_BYTES(N) \+ ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \+ + YYSTACK_GAP_MAXIMUM)++/* Copy COUNT objects from FROM to TO. The source and destination do+ not overlap. */+# ifndef YYCOPY+# if defined (__GNUC__) && 1 < __GNUC__+# define YYCOPY(To, From, Count) \+ __builtin_memcpy (To, From, (Count) * sizeof (*(From)))+# else+# define YYCOPY(To, From, Count) \+ do \+ { \+ register YYSIZE_T yyi; \+ for (yyi = 0; yyi < (Count); yyi++) \+ (To)[yyi] = (From)[yyi]; \+ } \+ while (0)+# endif+# endif++/* Relocate STACK from its old location to the new one. The+ local variables YYSIZE and YYSTACKSIZE give the old and new number of+ elements in the stack, and YYPTR gives the new location of the+ stack. Advance YYPTR to a properly aligned location for the next+ stack. */+# define YYSTACK_RELOCATE(Stack) \+ do \+ { \+ YYSIZE_T yynewbytes; \+ YYCOPY (&yyptr->Stack, Stack, yysize); \+ Stack = &yyptr->Stack; \+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \+ yyptr += yynewbytes / sizeof (*yyptr); \+ } \+ while (0)++#endif++#if defined (__STDC__) || defined (__cplusplus)+ typedef signed char yysigned_char;+#else+ typedef short int yysigned_char;+#endif++/* YYFINAL -- State number of the termination state. */+#define YYFINAL 52+/* YYLAST -- Last index in YYTABLE. */+#define YYLAST 396++/* YYNTOKENS -- Number of terminals. */+#define YYNTOKENS 23+/* YYNNTS -- Number of nonterminals. */+#define YYNNTS 29+/* YYNRULES -- Number of rules. */+#define YYNRULES 79+/* YYNRULES -- Number of states. */+#define YYNSTATES 128++/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */+#define YYUNDEFTOK 2+#define YYMAXUTOK 269++#define YYTRANSLATE(YYX) \+ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)++/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */+static const unsigned char yytranslate[] =+{+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 21, 15, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 16, 2,+ 2, 2, 2, 22, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 17, 2, 18, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 19, 2, 20, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,+ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14+};++#if YYDEBUG+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in+ YYRHS. */+static const unsigned char yyprhs[] =+{+ 0, 0, 3, 5, 8, 9, 11, 13, 15, 18,+ 21, 24, 28, 30, 32, 36, 37, 40, 43, 46,+ 49, 51, 54, 56, 58, 60, 63, 66, 69, 72,+ 75, 77, 79, 81, 85, 87, 89, 91, 93, 95,+ 99, 103, 106, 110, 113, 117, 120, 124, 127, 129,+ 133, 136, 140, 143, 145, 149, 151, 153, 157, 161,+ 165, 168, 172, 175, 179, 182, 184, 188, 190, 194,+ 196, 200, 204, 207, 211, 215, 218, 220, 224, 226+};++/* YYRHS -- A `-1'-separated list of the rules' RHS. */+static const yysigned_char yyrhs[] =+{+ 24, 0, -1, 25, -1, 11, 27, -1, -1, 33,+ -1, 26, -1, 34, -1, 5, 26, -1, 6, 26,+ -1, 3, 26, -1, 29, 26, 32, -1, 25, -1,+ 28, -1, 29, 28, 30, -1, -1, 7, 28, -1,+ 5, 28, -1, 6, 28, -1, 3, 28, -1, 12,+ -1, 29, 13, -1, 14, -1, 13, -1, 14, -1,+ 31, 32, -1, 5, 33, -1, 6, 33, -1, 7,+ 33, -1, 3, 33, -1, 4, -1, 8, -1, 9,+ -1, 29, 33, 32, -1, 10, -1, 35, -1, 39,+ -1, 42, -1, 49, -1, 29, 37, 30, -1, 29,+ 38, 30, -1, 15, 27, -1, 5, 31, 38, -1,+ 5, 37, -1, 6, 31, 38, -1, 6, 37, -1,+ 3, 31, 38, -1, 3, 37, -1, 36, -1, 38,+ 31, 36, -1, 38, 31, -1, 17, 40, 18, -1,+ 17, 18, -1, 41, -1, 40, 21, 41, -1, 25,+ -1, 48, -1, 29, 43, 30, -1, 29, 47, 30,+ -1, 5, 31, 47, -1, 5, 43, -1, 6, 31,+ 47, -1, 6, 43, -1, 3, 31, 47, -1, 3,+ 43, -1, 33, -1, 22, 25, 31, -1, 27, -1,+ 44, 16, 45, -1, 46, -1, 47, 31, 36, -1,+ 47, 31, 46, -1, 47, 31, -1, 25, 16, 27,+ -1, 19, 50, 20, -1, 19, 20, -1, 51, -1,+ 50, 21, 51, -1, 25, -1, 48, -1+};++/* YYRLINE[YYN] -- source line where rule number YYN was defined. */+static const unsigned short int yyrline[] =+{+ 0, 56, 56, 60, 65, 70, 71, 74, 75, 80,+ 85, 94, 100, 101, 104, 109, 113, 121, 126, 131,+ 145, 146, 149, 152, 155, 156, 164, 169, 174, 182,+ 186, 194, 207, 208, 218, 219, 220, 221, 222, 228,+ 232, 238, 244, 249, 254, 259, 264, 268, 274, 278,+ 283, 292, 296, 302, 306, 313, 314, 320, 325, 332,+ 337, 342, 347, 352, 356, 362, 363, 369, 379, 396,+ 397, 409, 417, 426, 434, 438, 444, 445, 454, 461+};+#endif++#if YYDEBUG || YYERROR_VERBOSE+/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */+static const char *const yytname[] =+{+ "$end", "error", "$undefined", "YAML_ANCHOR", "YAML_ALIAS",+ "YAML_TRANSFER", "YAML_TAGURI", "YAML_ITRANSFER", "YAML_WORD",+ "YAML_PLAIN", "YAML_BLOCK", "YAML_DOCSEP", "YAML_IOPEN", "YAML_INDENT",+ "YAML_IEND", "'-'", "':'", "'['", "']'", "'{'", "'}'", "','", "'?'",+ "$accept", "doc", "atom", "ind_rep", "atom_or_empty", "empty",+ "indent_open", "indent_end", "indent_sep", "indent_flex_end", "word_rep",+ "struct_rep", "implicit_seq", "basic_seq", "top_imp_seq",+ "in_implicit_seq", "inline_seq", "in_inline_seq", "inline_seq_atom",+ "implicit_map", "top_imp_map", "complex_key", "complex_value",+ "complex_mapping", "in_implicit_map", "basic_mapping", "inline_map",+ "in_inline_map", "inline_map_atom", 0+};+#endif++# ifdef YYPRINT+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to+ token YYLEX-NUM. */+static const unsigned short int yytoknum[] =+{+ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,+ 265, 266, 267, 268, 269, 45, 58, 91, 93, 123,+ 125, 44, 63+};+# endif++/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */+static const unsigned char yyr1[] =+{+ 0, 23, 24, 24, 24, 25, 25, 26, 26, 26,+ 26, 26, 27, 27, 28, 28, 28, 28, 28, 28,+ 29, 29, 30, 31, 32, 32, 33, 33, 33, 33,+ 33, 33, 33, 33, 34, 34, 34, 34, 34, 35,+ 35, 36, 37, 37, 37, 37, 37, 37, 38, 38,+ 38, 39, 39, 40, 40, 41, 41, 42, 42, 43,+ 43, 43, 43, 43, 43, 44, 44, 45, 46, 47,+ 47, 47, 47, 48, 49, 49, 50, 50, 51, 51+};++/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */+static const unsigned char yyr2[] =+{+ 0, 2, 1, 2, 0, 1, 1, 1, 2, 2,+ 2, 3, 1, 1, 3, 0, 2, 2, 2, 2,+ 1, 2, 1, 1, 1, 2, 2, 2, 2, 2,+ 1, 1, 1, 3, 1, 1, 1, 1, 1, 3,+ 3, 2, 3, 2, 3, 2, 3, 2, 1, 3,+ 2, 3, 2, 1, 3, 1, 1, 3, 3, 3,+ 2, 3, 2, 3, 2, 1, 3, 1, 3, 1,+ 3, 3, 2, 3, 3, 2, 1, 3, 1, 1+};++/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state+ STATE-NUM when YYTABLE doesn't specify something else to do. Zero+ means the default is an error. */+static const unsigned char yydefact[] =+{+ 4, 0, 30, 0, 0, 0, 31, 32, 34, 15,+ 20, 0, 0, 0, 2, 6, 0, 5, 7, 35,+ 36, 37, 38, 10, 29, 8, 26, 9, 27, 0,+ 0, 0, 0, 28, 15, 15, 15, 15, 12, 3,+ 13, 15, 52, 55, 0, 53, 56, 75, 78, 79,+ 0, 76, 1, 0, 0, 0, 21, 15, 0, 0,+ 65, 48, 0, 0, 0, 0, 69, 0, 0, 19,+ 17, 18, 15, 15, 15, 16, 15, 15, 15, 15,+ 0, 15, 51, 0, 74, 0, 23, 0, 47, 64,+ 0, 43, 60, 0, 45, 62, 41, 0, 24, 0,+ 11, 33, 22, 39, 40, 50, 57, 15, 58, 72,+ 14, 73, 54, 77, 65, 46, 63, 42, 59, 44,+ 61, 66, 25, 49, 67, 68, 70, 71+};++/* YYDEFGOTO[NTERM-NUM]. */+static const yysigned_char yydefgoto[] =+{+ -1, 13, 38, 15, 39, 40, 16, 103, 99, 101,+ 17, 18, 19, 61, 62, 63, 20, 44, 45, 21,+ 64, 65, 125, 66, 67, 46, 22, 50, 51+};++/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing+ STATE-NUM. */+#define YYPACT_NINF -97+static const short int yypact[] =+{+ 250, 318, -97, 318, 318, 374, -97, -97, -97, 335,+ -97, 267, 232, 7, -97, -97, 192, -97, -97, -97,+ -97, -97, -97, -97, -97, -97, -97, -97, -97, 374,+ 374, 374, 352, -97, 335, 335, 335, 384, -97, -97,+ -97, 212, -97, 10, 0, -97, -97, -97, 10, -97,+ -4, -97, -97, 284, 284, 284, -97, 335, 318, 30,+ 30, -97, -2, 36, -2, 16, -97, 36, 30, -97,+ -97, -97, 384, 384, 384, -97, 363, 301, 301, 301,+ -2, 335, -97, 318, -97, 318, -97, 158, -97, -97,+ 158, -97, -97, 158, -97, -97, -97, 24, -97, 30,+ -97, -97, -97, -97, -97, 26, -97, 335, -97, 158,+ -97, -97, -97, -97, -97, 24, 24, 24, 24, 24,+ 24, -97, -97, -97, -97, -97, -97, -97+};++/* YYPGOTO[NTERM-NUM]. */+static const yysigned_char yypgoto[] =+{+ -97, -97, 8, 81, -56, 109, 33, -53, 74, -54,+ -1, -97, -97, -96, -31, -32, -97, -97, -44, -97,+ 77, -97, -97, -52, 9, -6, -97, -97, -29+};++/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If+ positive, shift that token. If negative, reduce the rule which+ number is the opposite. If zero, do what YYDEFACT says.+ If YYTABLE_NINF, syntax error. */+#define YYTABLE_NINF -1+static const unsigned char yytable[] =+{+ 24, 96, 26, 28, 33, 100, 49, 52, 14, 123,+ 104, 106, 102, 126, 108, 60, 84, 85, 82, 43,+ 48, 83, 88, 91, 94, 111, 81, 110, 24, 26,+ 28, 68, 107, 24, 26, 28, 33, 86, 32, 112,+ 60, 57, 41, 86, 98, 122, 88, 91, 94, 86,+ 102, 124, 24, 26, 28, 115, 113, 127, 117, 0,+ 0, 119, 32, 32, 32, 32, 97, 41, 41, 41,+ 76, 24, 26, 28, 41, 68, 24, 26, 28, 49,+ 0, 0, 23, 0, 25, 27, 114, 0, 0, 114,+ 41, 43, 114, 48, 0, 0, 116, 59, 0, 118,+ 0, 0, 120, 0, 0, 76, 76, 76, 114, 76,+ 41, 41, 41, 0, 41, 23, 25, 27, 0, 0,+ 32, 0, 59, 32, 0, 0, 32, 87, 90, 93,+ 89, 92, 95, 0, 23, 25, 27, 105, 0, 0,+ 41, 109, 32, 69, 70, 71, 75, 0, 0, 0,+ 80, 87, 90, 93, 89, 92, 95, 0, 23, 25,+ 27, 29, 2, 30, 31, 5, 6, 7, 0, 0,+ 10, 121, 0, 57, 0, 0, 0, 0, 0, 0,+ 58, 69, 70, 71, 0, 80, 69, 70, 71, 105,+ 109, 105, 109, 105, 109, 53, 2, 54, 55, 5,+ 6, 7, 8, 0, 10, 56, 0, 57, 0, 11,+ 0, 12, 0, 0, 58, 77, 2, 78, 79, 37,+ 6, 7, 8, 0, 10, 56, 0, 57, 0, 11,+ 0, 12, 0, 0, 58, 1, 2, 3, 4, 5,+ 6, 7, 8, 0, 10, 0, 0, 0, 0, 11,+ 0, 12, 47, 1, 2, 3, 4, 5, 6, 7,+ 8, 9, 10, 0, 0, 0, 0, 11, 0, 12,+ 1, 2, 3, 4, 5, 6, 7, 8, 0, 10,+ 0, 0, 0, 0, 11, 42, 12, 53, 2, 54,+ 55, 5, 6, 7, 8, 0, 10, 86, 0, 0,+ 0, 11, 0, 12, 77, 2, 78, 79, 37, 6,+ 7, 8, 0, 10, 86, 0, 0, 0, 11, 0,+ 12, 1, 2, 3, 4, 5, 6, 7, 8, 0,+ 10, 0, 0, 0, 0, 11, 0, 12, 34, 2,+ 35, 36, 37, 6, 7, 8, 0, 10, 0, 0,+ 0, 0, 11, 0, 12, 29, 2, 30, 31, 5,+ 6, 7, 0, 0, 10, 56, 72, 2, 73, 74,+ 37, 6, 7, 0, 0, 10, 56, 29, 2, 30,+ 31, 5, 6, 7, 0, 0, 10, 72, 2, 73,+ 74, 37, 6, 7, 0, 0, 10+};++static const yysigned_char yycheck[] =+{+ 1, 57, 3, 4, 5, 59, 12, 0, 0, 105,+ 63, 64, 14, 109, 67, 16, 20, 21, 18, 11,+ 12, 21, 53, 54, 55, 81, 16, 80, 29, 30,+ 31, 32, 16, 34, 35, 36, 37, 13, 5, 83,+ 41, 15, 9, 13, 14, 99, 77, 78, 79, 13,+ 14, 107, 53, 54, 55, 87, 85, 109, 90, -1,+ -1, 93, 29, 30, 31, 32, 58, 34, 35, 36,+ 37, 72, 73, 74, 41, 76, 77, 78, 79, 85,+ -1, -1, 1, -1, 3, 4, 87, -1, -1, 90,+ 57, 83, 93, 85, -1, -1, 87, 16, -1, 90,+ -1, -1, 93, -1, -1, 72, 73, 74, 109, 76,+ 77, 78, 79, -1, 81, 34, 35, 36, -1, -1,+ 87, -1, 41, 90, -1, -1, 93, 53, 54, 55,+ 53, 54, 55, -1, 53, 54, 55, 63, -1, -1,+ 107, 67, 109, 34, 35, 36, 37, -1, -1, -1,+ 41, 77, 78, 79, 77, 78, 79, -1, 77, 78,+ 79, 3, 4, 5, 6, 7, 8, 9, -1, -1,+ 12, 97, -1, 15, -1, -1, -1, -1, -1, -1,+ 22, 72, 73, 74, -1, 76, 77, 78, 79, 115,+ 116, 117, 118, 119, 120, 3, 4, 5, 6, 7,+ 8, 9, 10, -1, 12, 13, -1, 15, -1, 17,+ -1, 19, -1, -1, 22, 3, 4, 5, 6, 7,+ 8, 9, 10, -1, 12, 13, -1, 15, -1, 17,+ -1, 19, -1, -1, 22, 3, 4, 5, 6, 7,+ 8, 9, 10, -1, 12, -1, -1, -1, -1, 17,+ -1, 19, 20, 3, 4, 5, 6, 7, 8, 9,+ 10, 11, 12, -1, -1, -1, -1, 17, -1, 19,+ 3, 4, 5, 6, 7, 8, 9, 10, -1, 12,+ -1, -1, -1, -1, 17, 18, 19, 3, 4, 5,+ 6, 7, 8, 9, 10, -1, 12, 13, -1, -1,+ -1, 17, -1, 19, 3, 4, 5, 6, 7, 8,+ 9, 10, -1, 12, 13, -1, -1, -1, 17, -1,+ 19, 3, 4, 5, 6, 7, 8, 9, 10, -1,+ 12, -1, -1, -1, -1, 17, -1, 19, 3, 4,+ 5, 6, 7, 8, 9, 10, -1, 12, -1, -1,+ -1, -1, 17, -1, 19, 3, 4, 5, 6, 7,+ 8, 9, -1, -1, 12, 13, 3, 4, 5, 6,+ 7, 8, 9, -1, -1, 12, 13, 3, 4, 5,+ 6, 7, 8, 9, -1, -1, 12, 3, 4, 5,+ 6, 7, 8, 9, -1, -1, 12+};++/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing+ symbol of state STATE-NUM. */+static const unsigned char yystos[] =+{+ 0, 3, 4, 5, 6, 7, 8, 9, 10, 11,+ 12, 17, 19, 24, 25, 26, 29, 33, 34, 35,+ 39, 42, 49, 26, 33, 26, 33, 26, 33, 3,+ 5, 6, 29, 33, 3, 5, 6, 7, 25, 27,+ 28, 29, 18, 25, 40, 41, 48, 20, 25, 48,+ 50, 51, 0, 3, 5, 6, 13, 15, 22, 26,+ 33, 36, 37, 38, 43, 44, 46, 47, 33, 28,+ 28, 28, 3, 5, 6, 28, 29, 3, 5, 6,+ 28, 16, 18, 21, 20, 21, 13, 31, 37, 43,+ 31, 37, 43, 31, 37, 43, 27, 25, 14, 31,+ 32, 32, 14, 30, 30, 31, 30, 16, 30, 31,+ 30, 27, 41, 51, 33, 38, 47, 38, 47, 38,+ 47, 31, 32, 36, 27, 45, 36, 46+};++#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)+# define YYSIZE_T __SIZE_TYPE__+#endif+#if ! defined (YYSIZE_T) && defined (size_t)+# define YYSIZE_T size_t+#endif+#if ! defined (YYSIZE_T)+# if defined (__STDC__) || defined (__cplusplus)+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */+# define YYSIZE_T size_t+# endif+#endif+#if ! defined (YYSIZE_T)+# define YYSIZE_T unsigned int+#endif++#define yyerrok (yyerrstatus = 0)+#define yyclearin (yychar = YYEMPTY)+#define YYEMPTY (-2)+#define YYEOF 0++#define YYACCEPT goto yyacceptlab+#define YYABORT goto yyabortlab+#define YYERROR goto yyerrorlab+++/* Like YYERROR except do call yyerror. This remains here temporarily+ to ease the transition to the new meaning of YYERROR, for GCC.+ Once GCC version 2 has supplanted version 1, this can go. */++#define YYFAIL goto yyerrlab++#define YYRECOVERING() (!!yyerrstatus)++#define YYBACKUP(Token, Value) \+do \+ if (yychar == YYEMPTY && yylen == 1) \+ { \+ yychar = (Token); \+ yylval = (Value); \+ yytoken = YYTRANSLATE (yychar); \+ YYPOPSTACK; \+ goto yybackup; \+ } \+ else \+ { \+ yyerror ("syntax error: cannot back up");\+ YYERROR; \+ } \+while (0)++#define YYTERROR 1+#define YYERRCODE 256++/* YYLLOC_DEFAULT -- Compute the default location (before the actions+ are run). */++#ifndef YYLLOC_DEFAULT+# define YYLLOC_DEFAULT(Current, Rhs, N) \+ ((Current).first_line = (Rhs)[1].first_line, \+ (Current).first_column = (Rhs)[1].first_column, \+ (Current).last_line = (Rhs)[N].last_line, \+ (Current).last_column = (Rhs)[N].last_column)+#endif++/* YYLEX -- calling `yylex' with the right arguments. */++#ifdef YYLEX_PARAM+# define YYLEX yylex (&yylval, YYLEX_PARAM)+#else+# define YYLEX yylex (&yylval)+#endif++/* Enable debugging if requested. */+#if YYDEBUG++# ifndef YYFPRINTF+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */+# define YYFPRINTF fprintf+# endif++# define YYDPRINTF(Args) \+do { \+ if (yydebug) \+ YYFPRINTF Args; \+} while (0)++# define YYDSYMPRINT(Args) \+do { \+ if (yydebug) \+ yysymprint Args; \+} while (0)++# define YYDSYMPRINTF(Title, Token, Value, Location) \+do { \+ if (yydebug) \+ { \+ YYFPRINTF (stderr, "%s ", Title); \+ yysymprint (stderr, \+ Token, Value); \+ YYFPRINTF (stderr, "\n"); \+ } \+} while (0)++/*------------------------------------------------------------------.+| yy_stack_print -- Print the state stack from its BOTTOM up to its |+| TOP (included). |+`------------------------------------------------------------------*/++#if defined (__STDC__) || defined (__cplusplus)+static void+yy_stack_print (short int *bottom, short int *top)+#else+static void+yy_stack_print (bottom, top)+ short int *bottom;+ short int *top;+#endif+{+ YYFPRINTF (stderr, "Stack now");+ for (/* Nothing. */; bottom <= top; ++bottom)+ YYFPRINTF (stderr, " %d", *bottom);+ YYFPRINTF (stderr, "\n");+}++# define YY_STACK_PRINT(Bottom, Top) \+do { \+ if (yydebug) \+ yy_stack_print ((Bottom), (Top)); \+} while (0)+++/*------------------------------------------------.+| Report that the YYRULE is going to be reduced. |+`------------------------------------------------*/++#if defined (__STDC__) || defined (__cplusplus)+static void+yy_reduce_print (int yyrule)+#else+static void+yy_reduce_print (yyrule)+ int yyrule;+#endif+{+ int yyi;+ unsigned int yylno = yyrline[yyrule];+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",+ yyrule - 1, yylno);+ /* Print the symbols being reduced, and their result. */+ for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)+ YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);+ YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);+}++# define YY_REDUCE_PRINT(Rule) \+do { \+ if (yydebug) \+ yy_reduce_print (Rule); \+} while (0)++/* Nonzero means print parse trace. It is left uninitialized so that+ multiple parsers can coexist. */+int yydebug;+#else /* !YYDEBUG */+# define YYDPRINTF(Args)+# define YYDSYMPRINT(Args)+# define YYDSYMPRINTF(Title, Token, Value, Location)+# define YY_STACK_PRINT(Bottom, Top)+# define YY_REDUCE_PRINT(Rule)+#endif /* !YYDEBUG */+++/* YYINITDEPTH -- initial size of the parser's stacks. */+#ifndef YYINITDEPTH+# define YYINITDEPTH 200+#endif++/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only+ if the built-in stack extension method is used).++ Do not make this value too large; the results are undefined if+ SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)+ evaluated with infinite-precision integer arithmetic. */++#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0+# undef YYMAXDEPTH+#endif++#ifndef YYMAXDEPTH+# define YYMAXDEPTH 10000+#endif++++#if YYERROR_VERBOSE++# ifndef yystrlen+# if defined (__GLIBC__) && defined (_STRING_H)+# define yystrlen strlen+# else+/* Return the length of YYSTR. */+static YYSIZE_T+# if defined (__STDC__) || defined (__cplusplus)+yystrlen (const char *yystr)+# else+yystrlen (yystr)+ const char *yystr;+# endif+{+ register const char *yys = yystr;++ while (*yys++ != '\0')+ continue;++ return yys - yystr - 1;+}+# endif+# endif++# ifndef yystpcpy+# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)+# define yystpcpy stpcpy+# else+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in+ YYDEST. */+static char *+# if defined (__STDC__) || defined (__cplusplus)+yystpcpy (char *yydest, const char *yysrc)+# else+yystpcpy (yydest, yysrc)+ char *yydest;+ const char *yysrc;+# endif+{+ register char *yyd = yydest;+ register const char *yys = yysrc;++ while ((*yyd++ = *yys++) != '\0')+ continue;++ return yyd - 1;+}+# endif+# endif++#endif /* !YYERROR_VERBOSE */++++#if YYDEBUG+/*--------------------------------.+| Print this symbol on YYOUTPUT. |+`--------------------------------*/++#if defined (__STDC__) || defined (__cplusplus)+static void+yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)+#else+static void+yysymprint (yyoutput, yytype, yyvaluep)+ FILE *yyoutput;+ int yytype;+ YYSTYPE *yyvaluep;+#endif+{+ /* Pacify ``unused variable'' warnings. */+ (void) yyvaluep;++ if (yytype < YYNTOKENS)+ {+ YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);+# ifdef YYPRINT+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);+# endif+ }+ else+ YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);++ switch (yytype)+ {+ default:+ break;+ }+ YYFPRINTF (yyoutput, ")");+}++#endif /* ! YYDEBUG */+/*-----------------------------------------------.+| Release the memory associated to this symbol. |+`-----------------------------------------------*/++#if defined (__STDC__) || defined (__cplusplus)+static void+yydestruct (int yytype, YYSTYPE *yyvaluep)+#else+static void+yydestruct (yytype, yyvaluep)+ int yytype;+ YYSTYPE *yyvaluep;+#endif+{+ /* Pacify ``unused variable'' warnings. */+ (void) yyvaluep;++ switch (yytype)+ {++ default:+ break;+ }+}+++/* Prevent warnings from -Wmissing-prototypes. */++#ifdef YYPARSE_PARAM+# if defined (__STDC__) || defined (__cplusplus)+int yyparse (void *YYPARSE_PARAM);+# else+int yyparse ();+# endif+#else /* ! YYPARSE_PARAM */+#if defined (__STDC__) || defined (__cplusplus)+int yyparse (void);+#else+int yyparse ();+#endif+#endif /* ! YYPARSE_PARAM */+++++++/*----------.+| yyparse. |+`----------*/++#ifdef YYPARSE_PARAM+# if defined (__STDC__) || defined (__cplusplus)+int yyparse (void *YYPARSE_PARAM)+# else+int yyparse (YYPARSE_PARAM)+ void *YYPARSE_PARAM;+# endif+#else /* ! YYPARSE_PARAM */+#if defined (__STDC__) || defined (__cplusplus)+int+yyparse (void)+#else+int+yyparse ()++#endif+#endif+{+ /* The lookahead symbol. */+int yychar;++/* The semantic value of the lookahead symbol. */+YYSTYPE yylval;++/* Number of syntax errors so far. */+int yynerrs;++ register int yystate;+ register int yyn;+ int yyresult;+ /* Number of tokens to shift before error messages enabled. */+ int yyerrstatus;+ /* Lookahead token as an internal (translated) token number. */+ int yytoken = 0;++ /* Three stacks and their tools:+ `yyss': related to states,+ `yyvs': related to semantic values,+ `yyls': related to locations.++ Refer to the stacks thru separate pointers, to allow yyoverflow+ to reallocate them elsewhere. */++ /* The state stack. */+ short int yyssa[YYINITDEPTH];+ short int *yyss = yyssa;+ register short int *yyssp;++ /* The semantic value stack. */+ YYSTYPE yyvsa[YYINITDEPTH];+ YYSTYPE *yyvs = yyvsa;+ register YYSTYPE *yyvsp;++++#define YYPOPSTACK (yyvsp--, yyssp--)++ YYSIZE_T yystacksize = YYINITDEPTH;++ /* The variables used to return semantic value and location from the+ action routines. */+ YYSTYPE yyval;+++ /* When reducing, the number of symbols on the RHS of the reduced+ rule. */+ int yylen;++ YYDPRINTF ((stderr, "Starting parse\n"));++ yystate = 0;+ yyerrstatus = 0;+ yynerrs = 0;+ yychar = YYEMPTY; /* Cause a token to be read. */++ /* Initialize stack pointers.+ Waste one element of value and location stack+ so that they stay on the same level as the state stack.+ The wasted elements are never initialized. */++ yyssp = yyss;+ yyvsp = yyvs;+++ goto yysetstate;++/*------------------------------------------------------------.+| yynewstate -- Push a new state, which is found in yystate. |+`------------------------------------------------------------*/+ yynewstate:+ /* In all cases, when you get here, the value and location stacks+ have just been pushed. so pushing a state here evens the stacks.+ */+ yyssp++;++ yysetstate:+ *yyssp = yystate;++ if (yyss + yystacksize - 1 <= yyssp)+ {+ /* Get the current used size of the three stacks, in elements. */+ YYSIZE_T yysize = yyssp - yyss + 1;++#ifdef yyoverflow+ {+ /* Give user a chance to reallocate the stack. Use copies of+ these so that the &'s don't force the real ones into+ memory. */+ YYSTYPE *yyvs1 = yyvs;+ short int *yyss1 = yyss;+++ /* Each stack pointer address is followed by the size of the+ data in use in that stack, in bytes. This used to be a+ conditional around just the two extra args, but that might+ be undefined if yyoverflow is a macro. */+ yyoverflow ("parser stack overflow",+ &yyss1, yysize * sizeof (*yyssp),+ &yyvs1, yysize * sizeof (*yyvsp),++ &yystacksize);++ yyss = yyss1;+ yyvs = yyvs1;+ }+#else /* no yyoverflow */+# ifndef YYSTACK_RELOCATE+ goto yyoverflowlab;+# else+ /* Extend the stack our own way. */+ if (YYMAXDEPTH <= yystacksize)+ goto yyoverflowlab;+ yystacksize *= 2;+ if (YYMAXDEPTH < yystacksize)+ yystacksize = YYMAXDEPTH;++ {+ short int *yyss1 = yyss;+ union yyalloc *yyptr =+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));+ if (! yyptr)+ goto yyoverflowlab;+ YYSTACK_RELOCATE (yyss);+ YYSTACK_RELOCATE (yyvs);++# undef YYSTACK_RELOCATE+ if (yyss1 != yyssa)+ YYSTACK_FREE (yyss1);+ }+# endif+#endif /* no yyoverflow */++ yyssp = yyss + yysize - 1;+ yyvsp = yyvs + yysize - 1;+++ YYDPRINTF ((stderr, "Stack size increased to %lu\n",+ (unsigned long int) yystacksize));++ if (yyss + yystacksize - 1 <= yyssp)+ YYABORT;+ }++ YYDPRINTF ((stderr, "Entering state %d\n", yystate));++ goto yybackup;++/*-----------.+| yybackup. |+`-----------*/+yybackup:++/* Do appropriate processing given the current state. */+/* Read a lookahead token if we need one and don't already have one. */+/* yyresume: */++ /* First try to decide what to do without reference to lookahead token. */++ yyn = yypact[yystate];+ if (yyn == YYPACT_NINF)+ goto yydefault;++ /* Not known => get a lookahead token if don't already have one. */++ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */+ if (yychar == YYEMPTY)+ {+ YYDPRINTF ((stderr, "Reading a token: "));+ yychar = YYLEX;+ }++ if (yychar <= YYEOF)+ {+ yychar = yytoken = YYEOF;+ YYDPRINTF ((stderr, "Now at end of input.\n"));+ }+ else+ {+ yytoken = YYTRANSLATE (yychar);+ YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);+ }++ /* If the proper action on seeing token YYTOKEN is to reduce or to+ detect an error, take that action. */+ yyn += yytoken;+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)+ goto yydefault;+ yyn = yytable[yyn];+ if (yyn <= 0)+ {+ if (yyn == 0 || yyn == YYTABLE_NINF)+ goto yyerrlab;+ yyn = -yyn;+ goto yyreduce;+ }++ if (yyn == YYFINAL)+ YYACCEPT;++ /* Shift the lookahead token. */+ YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));++ /* Discard the token being shifted unless it is eof. */+ if (yychar != YYEOF)+ yychar = YYEMPTY;++ *++yyvsp = yylval;+++ /* Count tokens shifted since error; after three, turn off error+ status. */+ if (yyerrstatus)+ yyerrstatus--;++ yystate = yyn;+ goto yynewstate;+++/*-----------------------------------------------------------.+| yydefault -- do the default action for the current state. |+`-----------------------------------------------------------*/+yydefault:+ yyn = yydefact[yystate];+ if (yyn == 0)+ goto yyerrlab;+ goto yyreduce;+++/*-----------------------------.+| yyreduce -- Do a reduction. |+`-----------------------------*/+yyreduce:+ /* yyn is the number of a rule to reduce with. */+ yylen = yyr2[yyn];++ /* If YYLEN is nonzero, implement the default value of the action:+ `$$ = $1'.++ Otherwise, the following line sets YYVAL to garbage.+ This behavior is undocumented and Bison+ users should not rely upon it. Assigning to YYVAL+ unconditionally makes the parser a bit smaller, and it avoids a+ GCC warning that YYVAL may be used uninitialized. */+ yyval = yyvsp[1-yylen];+++ YY_REDUCE_PRINT (yyn);+ switch (yyn)+ {+ case 2:+#line 57 "gram.y"+ {+ ((SyckParser *)parser)->root = syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData );+ }+ break;++ case 3:+#line 61 "gram.y"+ {+ ((SyckParser *)parser)->root = syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData );+ }+ break;++ case 4:+#line 65 "gram.y"+ {+ ((SyckParser *)parser)->eof = 1;+ }+ break;++ case 8:+#line 76 "gram.y"+ { + syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 9:+#line 81 "gram.y"+ {+ syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 10:+#line 86 "gram.y"+ { + /*+ * _Anchors_: The language binding must keep a separate symbol table+ * for anchors. The actual ID in the symbol table is returned to the+ * higher nodes, though.+ */+ yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );+ }+ break;++ case 11:+#line 95 "gram.y"+ {+ yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 14:+#line 105 "gram.y"+ {+ yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 15:+#line 109 "gram.y"+ {+ NULL_NODE( parser, n );+ yyval.nodeData = n;+ }+ break;++ case 16:+#line 114 "gram.y"+ { + if ( ((SyckParser *)parser)->implicit_typing == 1 )+ {+ try_tag_implicit( yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ }+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 17:+#line 122 "gram.y"+ { + syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 18:+#line 127 "gram.y"+ {+ syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 19:+#line 132 "gram.y"+ { + /*+ * _Anchors_: The language binding must keep a separate symbol table+ * for anchors. The actual ID in the symbol table is returned to the+ * higher nodes, though.+ */+ yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );+ }+ break;++ case 26:+#line 165 "gram.y"+ { + syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 27:+#line 170 "gram.y"+ { + syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 28:+#line 175 "gram.y"+ { + if ( ((SyckParser *)parser)->implicit_typing == 1 )+ {+ try_tag_implicit( yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ }+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 29:+#line 183 "gram.y"+ { + yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );+ }+ break;++ case 30:+#line 187 "gram.y"+ {+ /*+ * _Aliases_: The anchor symbol table is scanned for the anchor name.+ * The anchor's ID in the language's symbol table is returned.+ */+ yyval.nodeData = syck_hdlr_get_anchor( (SyckParser *)parser, yyvsp[0].name );+ }+ break;++ case 31:+#line 195 "gram.y"+ { + SyckNode *n = yyvsp[0].nodeData;+ if ( ((SyckParser *)parser)->taguri_expansion == 1 )+ {+ n->type_id = syck_taguri( YAML_DOMAIN, "str", 3 );+ }+ else+ {+ n->type_id = syck_strndup( "str", 3 );+ }+ yyval.nodeData = n;+ }+ break;++ case 33:+#line 209 "gram.y"+ {+ yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 39:+#line 229 "gram.y"+ { + yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 40:+#line 233 "gram.y"+ { + yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 41:+#line 239 "gram.y"+ { + yyval.nodeId = syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData );+ }+ break;++ case 42:+#line 245 "gram.y"+ { + syck_add_transfer( yyvsp[-2].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 43:+#line 250 "gram.y"+ { + syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 44:+#line 255 "gram.y"+ { + syck_add_transfer( yyvsp[-2].name, yyvsp[0].nodeData, 0 );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 45:+#line 260 "gram.y"+ { + syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 46:+#line 265 "gram.y"+ { + yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-2].name, yyvsp[0].nodeData );+ }+ break;++ case 47:+#line 269 "gram.y"+ { + yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );+ }+ break;++ case 48:+#line 275 "gram.y"+ {+ yyval.nodeData = syck_new_seq( yyvsp[0].nodeId );+ }+ break;++ case 49:+#line 279 "gram.y"+ { + syck_seq_add( yyvsp[-2].nodeData, yyvsp[0].nodeId );+ yyval.nodeData = yyvsp[-2].nodeData;+ }+ break;++ case 50:+#line 284 "gram.y"+ { + yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 51:+#line 293 "gram.y"+ { + yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 52:+#line 297 "gram.y"+ { + yyval.nodeData = syck_alloc_seq();+ }+ break;++ case 53:+#line 303 "gram.y"+ {+ yyval.nodeData = syck_new_seq( syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ) );+ }+ break;++ case 54:+#line 307 "gram.y"+ { + syck_seq_add( yyvsp[-2].nodeData, syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ) );+ yyval.nodeData = yyvsp[-2].nodeData;+ }+ break;++ case 57:+#line 321 "gram.y"+ { + apply_seq_in_map( (SyckParser *)parser, yyvsp[-1].nodeData );+ yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 58:+#line 326 "gram.y"+ { + apply_seq_in_map( (SyckParser *)parser, yyvsp[-1].nodeData );+ yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 59:+#line 333 "gram.y"+ { + syck_add_transfer( yyvsp[-2].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 60:+#line 338 "gram.y"+ { + syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 61:+#line 343 "gram.y"+ { + syck_add_transfer( yyvsp[-2].name, yyvsp[0].nodeData, 0 );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 62:+#line 348 "gram.y"+ { + syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );+ yyval.nodeData = yyvsp[0].nodeData;+ }+ break;++ case 63:+#line 353 "gram.y"+ { + yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-2].name, yyvsp[0].nodeData );+ }+ break;++ case 64:+#line 357 "gram.y"+ { + yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );+ }+ break;++ case 66:+#line 364 "gram.y"+ {+ yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 68:+#line 380 "gram.y"+ {+ yyval.nodeData = syck_new_map( + syck_hdlr_add_node( (SyckParser *)parser, yyvsp[-2].nodeData ), + syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ) );+ }+ break;++ case 70:+#line 398 "gram.y"+ {+ if ( yyvsp[-2].nodeData->shortcut == NULL )+ {+ yyvsp[-2].nodeData->shortcut = syck_new_seq( yyvsp[0].nodeId );+ }+ else+ {+ syck_seq_add( yyvsp[-2].nodeData->shortcut, yyvsp[0].nodeId );+ }+ yyval.nodeData = yyvsp[-2].nodeData;+ }+ break;++ case 71:+#line 410 "gram.y"+ {+ apply_seq_in_map( (SyckParser *)parser, yyvsp[-2].nodeData );+ syck_map_update( yyvsp[-2].nodeData, yyvsp[0].nodeData );+ syck_free_node( yyvsp[0].nodeData );+ yyvsp[0].nodeData = NULL;+ yyval.nodeData = yyvsp[-2].nodeData;+ }+ break;++ case 72:+#line 418 "gram.y"+ {+ yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 73:+#line 427 "gram.y"+ {+ yyval.nodeData = syck_new_map( + syck_hdlr_add_node( (SyckParser *)parser, yyvsp[-2].nodeData ), + syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ) );+ }+ break;++ case 74:+#line 435 "gram.y"+ {+ yyval.nodeData = yyvsp[-1].nodeData;+ }+ break;++ case 75:+#line 439 "gram.y"+ {+ yyval.nodeData = syck_alloc_map();+ }+ break;++ case 77:+#line 446 "gram.y"+ {+ syck_map_update( yyvsp[-2].nodeData, yyvsp[0].nodeData );+ syck_free_node( yyvsp[0].nodeData );+ yyvsp[0].nodeData = NULL;+ yyval.nodeData = yyvsp[-2].nodeData;+ }+ break;++ case 78:+#line 455 "gram.y"+ {+ NULL_NODE( parser, n );+ yyval.nodeData = syck_new_map( + syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ), + syck_hdlr_add_node( (SyckParser *)parser, n ) );+ }+ break;+++ }++/* Line 1010 of yacc.c. */+#line 1651 "gram.c"++ yyvsp -= yylen;+ yyssp -= yylen;+++ YY_STACK_PRINT (yyss, yyssp);++ *++yyvsp = yyval;+++ /* Now `shift' the result of the reduction. Determine what state+ that goes to, based on the state we popped back to and the rule+ number reduced by. */++ yyn = yyr1[yyn];++ yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;+ if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)+ yystate = yytable[yystate];+ else+ yystate = yydefgoto[yyn - YYNTOKENS];++ goto yynewstate;+++/*------------------------------------.+| yyerrlab -- here on detecting error |+`------------------------------------*/+yyerrlab:+ /* If not already recovering from an error, report this error. */+ if (!yyerrstatus)+ {+ ++yynerrs;+#if YYERROR_VERBOSE+ yyn = yypact[yystate];++ if (YYPACT_NINF < yyn && yyn < YYLAST)+ {+ YYSIZE_T yysize = 0;+ int yytype = YYTRANSLATE (yychar);+ const char* yyprefix;+ char *yymsg;+ int yyx;++ /* Start YYX at -YYN if negative to avoid negative indexes in+ YYCHECK. */+ int yyxbegin = yyn < 0 ? -yyn : 0;++ /* Stay within bounds of both yycheck and yytname. */+ int yychecklim = YYLAST - yyn;+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;+ int yycount = 0;++ yyprefix = ", expecting ";+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)+ {+ yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);+ yycount += 1;+ if (yycount == 5)+ {+ yysize = 0;+ break;+ }+ }+ yysize += (sizeof ("syntax error, unexpected ")+ + yystrlen (yytname[yytype]));+ yymsg = (char *) YYSTACK_ALLOC (yysize);+ if (yymsg != 0)+ {+ char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");+ yyp = yystpcpy (yyp, yytname[yytype]);++ if (yycount < 5)+ {+ yyprefix = ", expecting ";+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)+ {+ yyp = yystpcpy (yyp, yyprefix);+ yyp = yystpcpy (yyp, yytname[yyx]);+ yyprefix = " or ";+ }+ }+ yyerror (yymsg);+ YYSTACK_FREE (yymsg);+ }+ else+ yyerror ("syntax error; also virtual memory exhausted");+ }+ else+#endif /* YYERROR_VERBOSE */+ yyerror ("syntax error");+ }++++ if (yyerrstatus == 3)+ {+ /* If just tried and failed to reuse lookahead token after an+ error, discard it. */++ if (yychar <= YYEOF)+ {+ /* If at end of input, pop the error token,+ then the rest of the stack, then return failure. */+ if (yychar == YYEOF)+ for (;;)+ {+ YYPOPSTACK;+ if (yyssp == yyss)+ YYABORT;+ YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);+ yydestruct (yystos[*yyssp], yyvsp);+ }+ }+ else+ {+ YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);+ yydestruct (yytoken, &yylval);+ yychar = YYEMPTY;++ }+ }++ /* Else will try to reuse lookahead token after shifting the error+ token. */+ goto yyerrlab1;+++/*---------------------------------------------------.+| yyerrorlab -- error raised explicitly by YYERROR. |+`---------------------------------------------------*/+yyerrorlab:++#ifdef __GNUC__+ /* Pacify GCC when the user code never invokes YYERROR and the label+ yyerrorlab therefore never appears in user code. */+ if (0)+ goto yyerrorlab;+#endif++ yyvsp -= yylen;+ yyssp -= yylen;+ yystate = *yyssp;+ goto yyerrlab1;+++/*-------------------------------------------------------------.+| yyerrlab1 -- common code for both syntax error and YYERROR. |+`-------------------------------------------------------------*/+yyerrlab1:+ yyerrstatus = 3; /* Each real token shifted decrements this. */++ for (;;)+ {+ yyn = yypact[yystate];+ if (yyn != YYPACT_NINF)+ {+ yyn += YYTERROR;+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)+ {+ yyn = yytable[yyn];+ if (0 < yyn)+ break;+ }+ }++ /* Pop the current state because it cannot handle the error token. */+ if (yyssp == yyss)+ YYABORT;++ YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);+ yydestruct (yystos[yystate], yyvsp);+ YYPOPSTACK;+ yystate = *yyssp;+ YY_STACK_PRINT (yyss, yyssp);+ }++ if (yyn == YYFINAL)+ YYACCEPT;++ YYDPRINTF ((stderr, "Shifting error token, "));++ *++yyvsp = yylval;+++ yystate = yyn;+ goto yynewstate;+++/*-------------------------------------.+| yyacceptlab -- YYACCEPT comes here. |+`-------------------------------------*/+yyacceptlab:+ yyresult = 0;+ goto yyreturn;++/*-----------------------------------.+| yyabortlab -- YYABORT comes here. |+`-----------------------------------*/+yyabortlab:+ yyresult = 1;+ goto yyreturn;++#ifndef yyoverflow+/*----------------------------------------------.+| yyoverflowlab -- parser overflow comes here. |+`----------------------------------------------*/+yyoverflowlab:+ yyerror ("parser stack overflow");+ yyresult = 2;+ /* Fall through. */+#endif++yyreturn:+#ifndef yyoverflow+ if (yyss != yyssa)+ YYSTACK_FREE (yyss);+#endif+ return yyresult;+}+++#line 464 "gram.y"+++void+apply_seq_in_map( SyckParser *parser, SyckNode *n )+{+ long map_len;+ if ( n->shortcut == NULL )+ {+ return;+ }++ map_len = syck_map_count( n );+ syck_map_assign( n, map_value, map_len - 1,+ syck_hdlr_add_node( parser, n->shortcut ) );++ n->shortcut = NULL;+}++
+ syck/handler.c view
@@ -0,0 +1,173 @@+/*+ * handler.c+ *+ * $Author: why $+ * $Date: 2005-09-20 13:21:06 +0800 (二, 20 9 2005) $+ *+ * Copyright (C) 2003 why the lucky stiff+ */++#include "syck.h"++SYMID +syck_hdlr_add_node( SyckParser *p, SyckNode *n )+{+ SYMID id;++ if ( ! n->id ) + {+ n->id = (p->handler)( p, n );+ }+ id = n->id;++ if ( n->anchor == NULL )+ {+ syck_free_node( n );+ }+ return id;+}++SyckNode *+syck_hdlr_add_anchor( SyckParser *p, char *a, SyckNode *n )+{+ SyckNode *ntmp = NULL;++ n->anchor = a;+ if ( p->bad_anchors != NULL )+ {+ SyckNode *bad;+ if ( st_lookup( p->bad_anchors, (st_data_t)a, (st_data_t *)&bad ) )+ {+ if ( n->kind != syck_str_kind )+ {+ n->id = bad->id;+ (p->handler)( p, n );+ }+ }+ }+ if ( p->anchors == NULL )+ {+ p->anchors = st_init_strtable();+ }+ if ( st_lookup( p->anchors, (st_data_t)a, (st_data_t *)&ntmp ) )+ {+ if ( ntmp != (void *)1 )+ {+ syck_free_node( ntmp );+ }+ }+ st_insert( p->anchors, (st_data_t)a, (st_data_t)n );+ return n;+}++void+syck_hdlr_remove_anchor( SyckParser *p, char *a )+{+ char *atmp = a;+ SyckNode *ntmp;+ if ( p->anchors == NULL )+ {+ p->anchors = st_init_strtable();+ }+ if ( st_delete( p->anchors, (st_data_t *)&atmp, (st_data_t *)&ntmp ) )+ {+ if ( ntmp != (void *)1 )+ {+ syck_free_node( ntmp );+ }+ }+ st_insert( p->anchors, (st_data_t)a, (st_data_t)1 );+}++SyckNode *+syck_hdlr_get_anchor( SyckParser *p, char *a )+{+ SyckNode *n = NULL;++ if ( p->anchors != NULL )+ {+ if ( st_lookup( p->anchors, (st_data_t)a, (st_data_t *)&n ) )+ {+ if ( n != (void *)1 )+ { + S_FREE( a );+ return n;+ }+ else+ {+ if ( p->bad_anchors == NULL )+ {+ p->bad_anchors = st_init_strtable();+ }+ if ( ! st_lookup( p->bad_anchors, (st_data_t)a, (st_data_t *)&n ) )+ {+ n = (p->bad_anchor_handler)( p, a );+ st_insert( p->bad_anchors, (st_data_t)a, (st_data_t)n );+ }+ }+ }+ }++ if ( n == NULL )+ {+ n = (p->bad_anchor_handler)( p, a );+ }++ if ( n->anchor )+ {+ S_FREE( a );+ } + else+ {+ n->anchor = a;+ }++ return n;+}++void+syck_add_transfer( char *uri, SyckNode *n, int taguri )+{+ if ( n->type_id != NULL )+ {+ S_FREE( n->type_id );+ }++ if ( taguri == 0 )+ {+ n->type_id = uri;+ return;+ }++ n->type_id = syck_type_id_to_uri( uri );+ S_FREE( uri );+}++char *+syck_xprivate( char *type_id, int type_len )+{+ char *uri = S_ALLOC_N( char, type_len + 14 );+ uri[0] = '\0';+ strcat( uri, "x-private:" );+ strncat( uri, type_id, type_len );+ return uri;+}++char *+syck_taguri( char *domain, char *type_id, int type_len )+{+ char *uri = S_ALLOC_N( char, strlen( domain ) + type_len + 14 );+ uri[0] = '\0';+ strcat( uri, "tag:" );+ strcat( uri, domain );+ strcat( uri, ":" );+ strncat( uri, type_id, type_len );+ return uri;+}++int +syck_try_implicit( SyckNode *n )+{+ return 1;+}+
+ syck/implicit.c view
@@ -0,0 +1,3199 @@+/* Generated by re2c 0.10.1 on Mon May 8 21:26:46 2006 */+#line 1 "implicit.re"+/*+ * implicit.re+ *+ * $Author: why $+ * $Date: 2005-11-14 07:43:56 +0800 (一, 14 11 2005) $+ *+ * Copyright (C) 2003 why the lucky stiff+ */++#include "syck.h"++#define YYCTYPE char+#define YYCURSOR cursor+#define YYMARKER marker+#define YYLIMIT limit+#define YYFILL(n)++void+try_tag_implicit( SyckNode *n, int taguri )+{+ char *tid = "";+ switch ( n->kind )+ {+ case syck_str_kind:+ tid = syck_match_implicit( n->data.str->ptr, n->data.str->len );+ break;++ case syck_seq_kind:+ tid = "seq";+ break;++ case syck_map_kind:+ tid = "map";+ break;+ }+ if ( n->type_id != NULL ) S_FREE( n->type_id );+ if ( taguri == 1 )+ {+ n->type_id = syck_taguri( YAML_DOMAIN, tid, strlen( tid ) );+ } else {+ n->type_id = syck_strndup( tid, strlen( tid ) );+ }+}++char *syck_match_implicit( char *str, size_t len )+{+ char *cursor, *limit, *marker;+ cursor = str;+ limit = str + len;+++#line 55 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;++ if((YYLIMIT - YYCURSOR) < 26) YYFILL(26);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy6;+ case '+': goto yy16;+ case '-': goto yy17;+ case '.': goto yy20;+ case '0': goto yy18;+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy19;+ case '<': goto yy22;+ case '=': goto yy21;+ case 'F': goto yy15;+ case 'N': goto yy5;+ case 'O': goto yy13;+ case 'T': goto yy11;+ case 'Y': goto yy9;+ case 'f': goto yy14;+ case 'n': goto yy4;+ case 'o': goto yy12;+ case 't': goto yy10;+ case 'y': goto yy8;+ case '~': goto yy2;+ default: goto yy23;+ }+yy2:+ ++YYCURSOR;+ if((yych = *YYCURSOR) <= 0x00) goto yy6;+yy3:+#line 123 "implicit.re"+ { return "str"; }+#line 98 "<stdout>"+yy4:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'o': goto yy172;+ case 'u': goto yy200;+ default: goto yy3;+ }+yy5:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'O':+ case 'o': goto yy172;+ case 'U': goto yy195;+ case 'u': goto yy196;+ default: goto yy3;+ }+yy6:+ ++YYCURSOR;+#line 85 "implicit.re"+ { return "null"; }+#line 121 "<stdout>"+yy8:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'e': goto yy194;+ default: goto yy3;+ }+yy9:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'E': goto yy192;+ case 'e': goto yy193;+ default: goto yy3;+ }+yy10:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'r': goto yy190;+ default: goto yy3;+ }+yy11:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'R': goto yy186;+ case 'r': goto yy187;+ default: goto yy3;+ }+yy12:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'f': goto yy185;+ case 'n': goto yy182;+ default: goto yy3;+ }+yy13:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'F': goto yy180;+ case 'N':+ case 'n': goto yy182;+ case 'f': goto yy181;+ default: goto yy3;+ }+yy14:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'a': goto yy177;+ default: goto yy3;+ }+yy15:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'A': goto yy168;+ case 'a': goto yy169;+ default: goto yy3;+ }+yy16:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '.': goto yy167;+ case '0': goto yy158;+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy47;+ default: goto yy3;+ }+yy17:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '.': goto yy157;+ case '0': goto yy158;+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy47;+ default: goto yy3;+ }+yy18:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x00: goto yy52;+ case ',': goto yy142;+ case '.': goto yy50;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7': goto yy140;+ case '8':+ case '9': goto yy141;+ case ':': goto yy49;+ case 'x': goto yy144;+ default: goto yy3;+ }+yy19:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x00: goto yy52;+ case ',': goto yy47;+ case '.': goto yy50;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy46;+ case ':': goto yy49;+ default: goto yy3;+ }+yy20:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 'I': goto yy33;+ case 'N': goto yy31;+ case 'i': goto yy32;+ case 'n': goto yy30;+ default: goto yy3;+ }+yy21:+ yych = *++YYCURSOR;+ if(yych <= 0x00) goto yy28;+ goto yy3;+yy22:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '<': goto yy24;+ default: goto yy3;+ }+yy23:+ yych = *++YYCURSOR;+ goto yy3;+yy24:+ yych = *++YYCURSOR;+ if(yych <= 0x00) goto yy26;+yy25:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy3;+ }+yy26:+ ++YYCURSOR;+#line 121 "implicit.re"+ { return "merge"; }+#line 296 "<stdout>"+yy28:+ ++YYCURSOR;+#line 119 "implicit.re"+ { return "default"; }+#line 301 "<stdout>"+yy30:+ yych = *++YYCURSOR;+ switch(yych){+ case 'a': goto yy45;+ default: goto yy25;+ }+yy31:+ yych = *++YYCURSOR;+ switch(yych){+ case 'A': goto yy40;+ case 'a': goto yy41;+ default: goto yy25;+ }+yy32:+ yych = *++YYCURSOR;+ switch(yych){+ case 'n': goto yy39;+ default: goto yy25;+ }+yy33:+ yych = *++YYCURSOR;+ switch(yych){+ case 'N': goto yy34;+ case 'n': goto yy35;+ default: goto yy25;+ }+yy34:+ yych = *++YYCURSOR;+ switch(yych){+ case 'F': goto yy36;+ default: goto yy25;+ }+yy35:+ yych = *++YYCURSOR;+ switch(yych){+ case 'f': goto yy36;+ default: goto yy25;+ }+yy36:+ yych = *++YYCURSOR;+ if(yych >= 0x01) goto yy25;+ ++YYCURSOR;+#line 105 "implicit.re"+ { return "float#inf"; }+#line 346 "<stdout>"+yy39:+ yych = *++YYCURSOR;+ switch(yych){+ case 'f': goto yy36;+ default: goto yy25;+ }+yy40:+ yych = *++YYCURSOR;+ switch(yych){+ case 'N': goto yy42;+ default: goto yy25;+ }+yy41:+ yych = *++YYCURSOR;+ switch(yych){+ case 'N': goto yy42;+ default: goto yy25;+ }+yy42:+ yych = *++YYCURSOR;+ if(yych >= 0x01) goto yy25;+ ++YYCURSOR;+#line 109 "implicit.re"+ { return "float#nan"; }+#line 371 "<stdout>"+yy45:+ yych = *++YYCURSOR;+ switch(yych){+ case 'n': goto yy42;+ default: goto yy25;+ }+yy46:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy74;+ default: goto yy48;+ }+yy47:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy48:+ switch(yych){+ case 0x00: goto yy52;+ case ',':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy47;+ case '.': goto yy50;+ case ':': goto yy49;+ default: goto yy25;+ }+yy49:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5': goto yy66;+ case '6':+ case '7':+ case '8':+ case '9': goto yy67;+ default: goto yy25;+ }+yy50:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 3) YYFILL(3);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy56;+ case ',': goto yy54;+ case '.': goto yy58;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy50;+ case 'E':+ case 'e': goto yy60;+ default: goto yy25;+ }+yy52:+ ++YYCURSOR;+#line 97 "implicit.re"+ { return "int"; }+#line 458 "<stdout>"+yy54:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy56;+ case ',':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy54;+ default: goto yy25;+ }+yy56:+ ++YYCURSOR;+#line 99 "implicit.re"+ { return "float#fix"; }+#line 482 "<stdout>"+yy58:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 3) YYFILL(3);+ yych = *YYCURSOR;+ switch(yych){+ case '.':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy58;+ case 'E':+ case 'e': goto yy60;+ default: goto yy25;+ }+yy60:+ yych = *++YYCURSOR;+ switch(yych){+ case '+':+ case '-': goto yy61;+ default: goto yy25;+ }+yy61:+ yych = *++YYCURSOR;+ if(yych <= 0x00) goto yy25;+ goto yy63;+yy62:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy63:+ switch(yych){+ case 0x00: goto yy64;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy62;+ default: goto yy25;+ }+yy64:+ ++YYCURSOR;+#line 101 "implicit.re"+ { return "float#exp"; }+#line 537 "<stdout>"+yy66:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy70;+ case '.': goto yy68;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy67;+ case ':': goto yy49;+ default: goto yy25;+ }+yy67:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy70;+ case '.': goto yy68;+ case ':': goto yy49;+ default: goto yy25;+ }+yy68:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy72;+ case ',':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy68;+ default: goto yy25;+ }+yy70:+ ++YYCURSOR;+#line 95 "implicit.re"+ { return "int#base60"; }+#line 591 "<stdout>"+yy72:+ ++YYCURSOR;+#line 103 "implicit.re"+ { return "float#base60"; }+#line 596 "<stdout>"+yy74:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy75;+ default: goto yy48;+ }+yy75:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy76;+ default: goto yy48;+ }+yy76:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy77;+ default: goto yy25;+ }+yy77:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy78;+ default: goto yy25;+ }+yy78:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy79;+ default: goto yy25;+ }+yy79:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy80;+ default: goto yy25;+ }+yy80:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy81;+ default: goto yy25;+ }+yy81:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x00: goto yy82;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy25;+ case 'T': goto yy84;+ case 't': goto yy85;+ default: goto yy87;+ }+yy82:+ ++YYCURSOR;+#line 111 "implicit.re"+ { return "timestamp#ymd"; }+#line 706 "<stdout>"+yy84:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy126;+ default: goto yy25;+ }+yy85:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy108;+ default: goto yy25;+ }+yy86:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 9) YYFILL(9);+ yych = *YYCURSOR;+yy87:+ switch(yych){+ case 0x09:+ case ' ': goto yy86;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy88;+ default: goto yy25;+ }+yy88:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy89;+ default: goto yy25;+ }+yy89:+ yych = *++YYCURSOR;+ switch(yych){+ case ':': goto yy90;+ default: goto yy25;+ }+yy90:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy91;+ default: goto yy25;+ }+yy91:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy92;+ default: goto yy25;+ }+yy92:+ yych = *++YYCURSOR;+ switch(yych){+ case ':': goto yy93;+ default: goto yy25;+ }+yy93:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy94;+ default: goto yy25;+ }+yy94:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy95;+ default: goto yy25;+ }+yy95:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x09:+ case ' ': goto yy98;+ case '.': goto yy96;+ default: goto yy25;+ }+yy96:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x09:+ case ' ': goto yy98;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy96;+ default: goto yy25;+ }+yy98:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 7) YYFILL(7);+ yych = *YYCURSOR;+ switch(yych){+ case 0x09:+ case ' ': goto yy98;+ case '+':+ case '-': goto yy101;+ case 'Z': goto yy100;+ default: goto yy25;+ }+yy100:+ yych = *++YYCURSOR;+ if(yych <= 0x00) goto yy105;+ goto yy25;+yy101:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy102;+ default: goto yy25;+ }+yy102:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy103;+ default: goto yy25;+ }+yy103:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x00: goto yy105;+ case ':': goto yy104;+ default: goto yy25;+ }+yy104:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy107;+ default: goto yy25;+ }+yy105:+ ++YYCURSOR;+#line 115 "implicit.re"+ { return "timestamp#spaced"; }+#line 943 "<stdout>"+yy107:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy100;+ default: goto yy25;+ }+yy108:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy109;+ default: goto yy25;+ }+yy109:+ yych = *++YYCURSOR;+ switch(yych){+ case ':': goto yy110;+ default: goto yy25;+ }+yy110:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy111;+ default: goto yy25;+ }+yy111:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy112;+ default: goto yy25;+ }+yy112:+ yych = *++YYCURSOR;+ switch(yych){+ case ':': goto yy113;+ default: goto yy25;+ }+yy113:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy114;+ default: goto yy25;+ }+yy114:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy115;+ default: goto yy25;+ }+yy115:+ yych = *++YYCURSOR;+ switch(yych){+ case '.': goto yy116;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy25;+ default: goto yy117;+ }+yy116:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 7) YYFILL(7);+ yych = *YYCURSOR;+yy117:+ switch(yych){+ case '+':+ case '-': goto yy119;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy116;+ case 'Z': goto yy118;+ default: goto yy25;+ }+yy118:+ yych = *++YYCURSOR;+ if(yych <= 0x00) goto yy123;+ goto yy25;+yy119:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy120;+ default: goto yy25;+ }+yy120:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy121;+ default: goto yy25;+ }+yy121:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x00: goto yy123;+ case ':': goto yy122;+ default: goto yy25;+ }+yy122:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy125;+ default: goto yy25;+ }+yy123:+ ++YYCURSOR;+yy124:+#line 113 "implicit.re"+ { return "timestamp#iso8601"; }+#line 1144 "<stdout>"+yy125:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy118;+ default: goto yy25;+ }+yy126:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy127;+ default: goto yy25;+ }+yy127:+ yych = *++YYCURSOR;+ switch(yych){+ case ':': goto yy128;+ default: goto yy25;+ }+yy128:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy129;+ default: goto yy25;+ }+yy129:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy130;+ default: goto yy25;+ }+yy130:+ yych = *++YYCURSOR;+ switch(yych){+ case ':': goto yy131;+ default: goto yy25;+ }+yy131:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy132;+ default: goto yy25;+ }+yy132:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy133;+ default: goto yy25;+ }+yy133:+ yych = *++YYCURSOR;+ switch(yych){+ case '.': goto yy134;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy25;+ case 'Z': goto yy136;+ default: goto yy135;+ }+yy134:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 7) YYFILL(7);+ yych = *YYCURSOR;+yy135:+ switch(yych){+ case '+':+ case '-': goto yy119;+ case '0': goto yy134;+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy138;+ case 'Z': goto yy118;+ default: goto yy25;+ }+yy136:+ yych = *++YYCURSOR;+ if(yych >= 0x01) goto yy25;+ yych = *++YYCURSOR;+ goto yy124;+yy138:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 7) YYFILL(7);+ yych = *YYCURSOR;+ switch(yych){+ case '+':+ case '-': goto yy119;+ case '0': goto yy134;+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy138;+ case 'Z': goto yy136;+ default: goto yy25;+ }+yy140:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7': goto yy155;+ case '8':+ case '9': goto yy153;+ default: goto yy143;+ }+yy141:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy153;+ default: goto yy152;+ }+yy142:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy143:+ switch(yych){+ case 0x00: goto yy149;+ case ',':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7': goto yy142;+ case '.': goto yy50;+ case '8':+ case '9': goto yy151;+ case ':': goto yy49;+ default: goto yy25;+ }+yy144:+ yych = *++YYCURSOR;+ if(yych <= 0x00) goto yy25;+ goto yy146;+yy145:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy146:+ switch(yych){+ case 0x00: goto yy147;+ case ',':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f': goto yy145;+ default: goto yy25;+ }+yy147:+ ++YYCURSOR;+#line 91 "implicit.re"+ { return "int#hex"; }+#line 1402 "<stdout>"+yy149:+ ++YYCURSOR;+#line 93 "implicit.re"+ { return "int#oct"; }+#line 1407 "<stdout>"+yy151:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy152:+ switch(yych){+ case ',':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy151;+ case '.': goto yy50;+ case ':': goto yy49;+ default: goto yy25;+ }+yy153:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy154;+ default: goto yy152;+ }+yy154:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy76;+ default: goto yy152;+ }+yy155:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7': goto yy156;+ case '8':+ case '9': goto yy154;+ default: goto yy143;+ }+yy156:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy76;+ default: goto yy143;+ }+yy157:+ yych = *++YYCURSOR;+ switch(yych){+ case 'I': goto yy160;+ case 'i': goto yy159;+ default: goto yy25;+ }+yy158:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x00: goto yy52;+ case 'x': goto yy144;+ default: goto yy143;+ }+yy159:+ yych = *++YYCURSOR;+ switch(yych){+ case 'n': goto yy166;+ default: goto yy25;+ }+yy160:+ yych = *++YYCURSOR;+ switch(yych){+ case 'N': goto yy161;+ case 'n': goto yy162;+ default: goto yy25;+ }+yy161:+ yych = *++YYCURSOR;+ switch(yych){+ case 'F': goto yy163;+ default: goto yy25;+ }+yy162:+ yych = *++YYCURSOR;+ switch(yych){+ case 'f': goto yy163;+ default: goto yy25;+ }+yy163:+ yych = *++YYCURSOR;+ if(yych >= 0x01) goto yy25;+ ++YYCURSOR;+#line 107 "implicit.re"+ { return "float#neginf"; }+#line 1516 "<stdout>"+yy166:+ yych = *++YYCURSOR;+ switch(yych){+ case 'f': goto yy163;+ default: goto yy25;+ }+yy167:+ yych = *++YYCURSOR;+ switch(yych){+ case 'I': goto yy33;+ case 'i': goto yy32;+ default: goto yy25;+ }+yy168:+ yych = *++YYCURSOR;+ switch(yych){+ case 'L': goto yy175;+ default: goto yy25;+ }+yy169:+ yych = *++YYCURSOR;+ switch(yych){+ case 'l': goto yy170;+ default: goto yy25;+ }+yy170:+ yych = *++YYCURSOR;+ switch(yych){+ case 's': goto yy171;+ default: goto yy25;+ }+yy171:+ yych = *++YYCURSOR;+ switch(yych){+ case 'e': goto yy172;+ default: goto yy25;+ }+yy172:+ yych = *++YYCURSOR;+ if(yych >= 0x01) goto yy25;+ ++YYCURSOR;+#line 89 "implicit.re"+ { return "bool#no"; }+#line 1560 "<stdout>"+yy175:+ yych = *++YYCURSOR;+ switch(yych){+ case 'S': goto yy176;+ default: goto yy25;+ }+yy176:+ yych = *++YYCURSOR;+ switch(yych){+ case 'E': goto yy172;+ default: goto yy25;+ }+yy177:+ yych = *++YYCURSOR;+ switch(yych){+ case 'l': goto yy178;+ default: goto yy25;+ }+yy178:+ yych = *++YYCURSOR;+ switch(yych){+ case 's': goto yy179;+ default: goto yy25;+ }+yy179:+ yych = *++YYCURSOR;+ switch(yych){+ case 'e': goto yy172;+ default: goto yy25;+ }+yy180:+ yych = *++YYCURSOR;+ switch(yych){+ case 'F': goto yy172;+ default: goto yy25;+ }+yy181:+ yych = *++YYCURSOR;+ switch(yych){+ case 'f': goto yy172;+ default: goto yy25;+ }+yy182:+ yych = *++YYCURSOR;+ if(yych >= 0x01) goto yy25;+ ++YYCURSOR;+#line 87 "implicit.re"+ { return "bool#yes"; }+#line 1609 "<stdout>"+yy185:+ yych = *++YYCURSOR;+ switch(yych){+ case 'f': goto yy172;+ default: goto yy25;+ }+yy186:+ yych = *++YYCURSOR;+ switch(yych){+ case 'U': goto yy189;+ default: goto yy25;+ }+yy187:+ yych = *++YYCURSOR;+ switch(yych){+ case 'u': goto yy188;+ default: goto yy25;+ }+yy188:+ yych = *++YYCURSOR;+ switch(yych){+ case 'e': goto yy182;+ default: goto yy25;+ }+yy189:+ yych = *++YYCURSOR;+ switch(yych){+ case 'E': goto yy182;+ default: goto yy25;+ }+yy190:+ yych = *++YYCURSOR;+ switch(yych){+ case 'u': goto yy191;+ default: goto yy25;+ }+yy191:+ yych = *++YYCURSOR;+ switch(yych){+ case 'e': goto yy182;+ default: goto yy25;+ }+yy192:+ yych = *++YYCURSOR;+ switch(yych){+ case 'S': goto yy182;+ default: goto yy25;+ }+yy193:+ yych = *++YYCURSOR;+ switch(yych){+ case 's': goto yy182;+ default: goto yy25;+ }+yy194:+ yych = *++YYCURSOR;+ switch(yych){+ case 's': goto yy182;+ default: goto yy25;+ }+yy195:+ yych = *++YYCURSOR;+ switch(yych){+ case 'L': goto yy199;+ default: goto yy25;+ }+yy196:+ yych = *++YYCURSOR;+ switch(yych){+ case 'l': goto yy197;+ default: goto yy25;+ }+yy197:+ yych = *++YYCURSOR;+ switch(yych){+ case 'l': goto yy198;+ default: goto yy25;+ }+yy198:+ yych = *++YYCURSOR;+ if(yych <= 0x00) goto yy6;+ goto yy25;+yy199:+ yych = *++YYCURSOR;+ switch(yych){+ case 'L': goto yy198;+ default: goto yy25;+ }+yy200:+ yych = *++YYCURSOR;+ switch(yych){+ case 'l': goto yy201;+ default: goto yy25;+ }+yy201:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 'l': goto yy198;+ default: goto yy25;+ }+}+#line 125 "implicit.re"+++}++/* Remove ending fragment and compare types */+int+syck_tagcmp( char *tag1, char *tag2 )+{+ if ( tag1 == tag2 ) return 1;+ if ( tag1 == NULL || tag2 == NULL ) return 0;+ else {+ int i;+ char *othorpe;+ char *tmp1 = syck_strndup( tag1, strlen( tag1 ) );+ char *tmp2 = syck_strndup( tag2, strlen( tag2 ) );+ othorpe = strstr( tmp1, "#" );+ if ( othorpe != NULL ) {+ othorpe[0] = '\0';+ }+ othorpe = strstr( tmp2, "#" );+ if ( othorpe != NULL ) {+ othorpe[0] = '\0';+ }+ i = strcmp( tmp1, tmp2 );+ S_FREE( tmp1 ); S_FREE( tmp2 );+ return i;+ }+}++char *+syck_type_id_to_uri( char *type_id )+{+ char *cursor, *limit, *marker;++ cursor = type_id;+ limit = type_id + strlen( type_id );+++#line 1750 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 21) YYFILL(21);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy204;+ case '!': goto yy208;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 'u':+ case 'v':+ case 'w':+ case 'y':+ case 'z': goto yy210;+ case 't': goto yy205;+ case 'x': goto yy207;+ default: goto yy211;+ }+yy204:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy206;+ }+yy205:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case ',': goto yy216;+ case '-': goto yy212;+ case '.': goto yy217;+ case '/': goto yy218;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy214;+ case 'a': goto yy246;+ default: goto yy206;+ }+yy206:+#line 202 "implicit.re"+ { return syck_taguri( YAML_DOMAIN, type_id, strlen( type_id ) ); }+#line 1905 "<stdout>"+yy207:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case ',':+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy215;+ case '-': goto yy236;+ default: goto yy206;+ }+yy208:+ ++YYCURSOR;+#line 176 "implicit.re"+ { return syck_xprivate( type_id + 1, strlen( type_id ) - 1 ); }+#line 1983 "<stdout>"+yy210:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case ',': goto yy216;+ case '-': goto yy212;+ case '.': goto yy217;+ case '/': goto yy218;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy214;+ default: goto yy206;+ }+yy211:+ yych = *++YYCURSOR;+ goto yy206;+yy212:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy213:+ switch(yych){+ case '-': goto yy212;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy214;+ default: goto yy204;+ }+yy214:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 12) YYFILL(12);+ yych = *YYCURSOR;+yy215:+ switch(yych){+ case ',': goto yy216;+ case '-': goto yy212;+ case '.': goto yy217;+ case '/': goto yy218;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy214;+ default: goto yy204;+ }+yy216:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy224;+ default: goto yy204;+ }+yy217:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy220;+ default: goto yy204;+ }+yy218:+ ++YYCURSOR;+#line 178 "implicit.re"+ { char *domain = S_ALLOC_N( char, ( YYCURSOR - type_id ) + 15 );+ char *uri;++ domain[0] = '\0';+ strncat( domain, type_id, ( YYCURSOR - type_id ) - 1 );+ strcat( domain, "." );+ strcat( domain, YAML_DOMAIN );+ uri = syck_taguri( domain, YYCURSOR, YYLIMIT - YYCURSOR );++ S_FREE( domain );+ return uri;+ }+#line 2307 "<stdout>"+yy220:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 12) YYFILL(12);+ yych = *YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '-': goto yy222;+ case '.': goto yy217;+ case '/': goto yy218;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy220;+ default: goto yy204;+ }+yy222:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '-': goto yy222;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy220;+ default: goto yy204;+ }+yy224:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy225;+ default: goto yy204;+ }+yy225:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy226;+ default: goto yy204;+ }+yy226:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy227;+ default: goto yy204;+ }+yy227:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy228;+ case '/': goto yy229;+ default: goto yy204;+ }+yy228:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy231;+ default: goto yy204;+ }+yy229:+ ++YYCURSOR;+#line 191 "implicit.re"+ { char *domain = S_ALLOC_N( char, YYCURSOR - type_id );+ char *uri;++ domain[0] = '\0';+ strncat( domain, type_id, ( YYCURSOR - type_id ) - 1 );+ uri = syck_taguri( domain, YYCURSOR, YYLIMIT - YYCURSOR );++ S_FREE( domain );+ return uri;+ }+#line 2533 "<stdout>"+yy231:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy232;+ default: goto yy204;+ }+yy232:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy233;+ case '/': goto yy229;+ default: goto yy204;+ }+yy233:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy234;+ default: goto yy204;+ }+yy234:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy235;+ default: goto yy204;+ }+yy235:+ yych = *++YYCURSOR;+ switch(yych){+ case '/': goto yy229;+ default: goto yy204;+ }+yy236:+ yych = *++YYCURSOR;+ switch(yych){+ case 'p': goto yy237;+ default: goto yy213;+ }+yy237:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case 'r': goto yy238;+ default: goto yy213;+ }+yy238:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case 'i': goto yy239;+ default: goto yy213;+ }+yy239:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case 'v': goto yy240;+ default: goto yy213;+ }+yy240:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case 'a': goto yy241;+ default: goto yy213;+ }+yy241:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case 't': goto yy242;+ default: goto yy213;+ }+yy242:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case 'e': goto yy243;+ default: goto yy213;+ }+yy243:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case ':': goto yy244;+ default: goto yy213;+ }+yy244:+ ++YYCURSOR;+#line 174 "implicit.re"+ { return syck_strndup( type_id, strlen( type_id ) ); }+#line 2665 "<stdout>"+yy246:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case 'g': goto yy247;+ default: goto yy213;+ }+yy247:+ yych = *++YYCURSOR;+ switch(yych){+ case ',': goto yy216;+ case '.': goto yy217;+ case '/': goto yy218;+ case ':': goto yy248;+ default: goto yy213;+ }+yy248:+ yych = *++YYCURSOR;+ switch(yych){+ case ',':+ case '-':+ case '.': goto yy204;+ default: goto yy250;+ }+yy249:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 12) YYFILL(12);+ yych = *YYCURSOR;+yy250:+ switch(yych){+ case ',': goto yy253;+ case '-': goto yy251;+ case '.': goto yy254;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy249;+ default: goto yy204;+ }+yy251:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '-': goto yy251;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy249;+ default: goto yy204;+ }+yy253:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy259;+ default: goto yy204;+ }+yy254:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy255;+ default: goto yy204;+ }+yy255:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 12) YYFILL(12);+ yych = *YYCURSOR;+ switch(yych){+ case ',': goto yy253;+ case '-': goto yy257;+ case '.': goto yy254;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy255;+ default: goto yy204;+ }+yy257:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '-': goto yy257;+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy255;+ default: goto yy204;+ }+yy259:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy260;+ default: goto yy204;+ }+yy260:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy261;+ default: goto yy204;+ }+yy261:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy262;+ default: goto yy204;+ }+yy262:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy263;+ case ':': goto yy264;+ default: goto yy204;+ }+yy263:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy266;+ default: goto yy204;+ }+yy264:+ ++YYCURSOR;+#line 172 "implicit.re"+ { return syck_strndup( type_id, strlen( type_id ) ); }+#line 3137 "<stdout>"+yy266:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy267;+ default: goto yy204;+ }+yy267:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy268;+ case ':': goto yy264;+ default: goto yy204;+ }+yy268:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy269;+ default: goto yy204;+ }+yy269:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy270;+ default: goto yy204;+ }+yy270:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case ':': goto yy264;+ default: goto yy204;+ }+}+#line 204 "implicit.re"+++}
+ syck/node.c view
@@ -0,0 +1,414 @@+/*+ * node.c+ *+ * $Author: why $+ * $Date: 2005-09-17 02:59:53 +0800 (六, 17 9 2005) $+ *+ * Copyright (C) 2003 why the lucky stiff+ */++#include "syck.h"++/*+ * Node allocation functions+ */+SyckNode *+syck_alloc_node( enum syck_kind_tag type )+{+ SyckNode *s;++ s = S_ALLOC( SyckNode );+ s->kind = type;+ s->id = 0;+ s->type_id = NULL;+ s->anchor = NULL;+ s->shortcut = NULL;++ return s;+}++void+syck_free_node( SyckNode *n )+{+ syck_free_members( n );+ if ( n->type_id != NULL )+ {+ S_FREE( n->type_id );+ n->type_id = NULL;+ }+ if ( n->anchor != NULL )+ {+ S_FREE( n->anchor );+ n->anchor = NULL;+ }+ S_FREE( n );+}++SyckNode *+syck_alloc_map()+{+ SyckNode *n;+ struct SyckMap *m;++ m = S_ALLOC( struct SyckMap );+ m->style = map_none;+ m->idx = 0;+ m->capa = ALLOC_CT;+ m->keys = S_ALLOC_N( SYMID, m->capa );+ m->values = S_ALLOC_N( SYMID, m->capa );++ n = syck_alloc_node( syck_map_kind );+ n->data.pairs = m;+ + return n;+}++SyckNode *+syck_alloc_seq()+{+ SyckNode *n;+ struct SyckSeq *s;++ s = S_ALLOC( struct SyckSeq );+ s->style = seq_none;+ s->idx = 0;+ s->capa = ALLOC_CT;+ s->items = S_ALLOC_N( SYMID, s->capa );++ n = syck_alloc_node( syck_seq_kind );+ n->data.list = s;++ return n;+}++SyckNode *+syck_alloc_str()+{+ SyckNode *n;+ struct SyckStr *s;++ s = S_ALLOC( struct SyckStr );+ s->len = 0;+ s->ptr = NULL;+ s->style = scalar_none;++ n = syck_alloc_node( syck_str_kind );+ n->data.str = s;+ + return n;+}++SyckNode *+syck_new_str( char *str, enum scalar_style style )+{+ return syck_new_str2( str, strlen( str ), style );+}++SyckNode *+syck_new_str2( char *str, long len, enum scalar_style style )+{+ SyckNode *n;++ n = syck_alloc_str();+ n->data.str->ptr = S_ALLOC_N( char, len + 1 );+ n->data.str->len = len;+ n->data.str->style = style;+ memcpy( n->data.str->ptr, str, len );+ n->data.str->ptr[len] = '\0';++ return n;+}++void+syck_replace_str( SyckNode *n, char *str, enum scalar_style style )+{+ syck_replace_str2( n, str, strlen( str ), style );+}++void+syck_replace_str2( SyckNode *n, char *str, long len, enum scalar_style style )+{+ if ( n->data.str != NULL ) + {+ S_FREE( n->data.str->ptr );+ n->data.str->ptr = NULL;+ n->data.str->len = 0;+ }+ n->data.str->ptr = S_ALLOC_N( char, len + 1 );+ n->data.str->len = len;+ n->data.str->style = style;+ memcpy( n->data.str->ptr, str, len );+ n->data.str->ptr[len] = '\0';+}++void+syck_str_blow_away_commas( SyckNode *n )+{+ char *go, *end;++ go = n->data.str->ptr;+ end = go + n->data.str->len;+ while ( *(++go) != '\0' )+ {+ if ( *go == ',' )+ {+ n->data.str->len -= 1;+ memmove( go, go + 1, end - go );+ end -= 1;+ }+ }+}++char *+syck_str_read( SyckNode *n )+{+ ASSERT( n != NULL );+ return n->data.str->ptr;+}++int+syck_str_style( SyckNode *n )+{+ ASSERT( n != NULL );+ return n->data.str->style;+}++SyckNode *+syck_new_map( SYMID key, SYMID value )+{+ SyckNode *n;++ n = syck_alloc_map();+ syck_map_add( n, key, value );++ return n;+}++void+syck_map_empty( SyckNode *n )+{+ struct SyckMap *m;+ ASSERT( n != NULL );+ ASSERT( n->data.list != NULL );++ S_FREE( n->data.pairs->keys );+ S_FREE( n->data.pairs->values );+ m = n->data.pairs;+ m->idx = 0;+ m->capa = ALLOC_CT;+ m->keys = S_ALLOC_N( SYMID, m->capa );+ m->values = S_ALLOC_N( SYMID, m->capa );+}++void+syck_map_add( SyckNode *map, SYMID key, SYMID value )+{+ struct SyckMap *m;+ long idx;++ ASSERT( map != NULL );+ ASSERT( map->data.pairs != NULL );+ + m = map->data.pairs;+ idx = m->idx;+ m->idx += 1;+ if ( m->idx > m->capa )+ {+ m->capa += ALLOC_CT;+ S_REALLOC_N( m->keys, SYMID, m->capa );+ S_REALLOC_N( m->values, SYMID, m->capa );+ }+ m->keys[idx] = key;+ m->values[idx] = value;+}++void+syck_map_update( SyckNode *map1, SyckNode *map2 )+{+ struct SyckMap *m1, *m2;+ long new_idx, new_capa;+ ASSERT( map1 != NULL );+ ASSERT( map2 != NULL );++ m1 = map1->data.pairs;+ m2 = map2->data.pairs;+ if ( m2->idx < 1 ) return;+ + new_idx = m1->idx;+ new_idx += m2->idx;+ new_capa = m1->capa;+ while ( new_idx > new_capa )+ {+ new_capa += ALLOC_CT;+ }+ if ( new_capa > m1->capa )+ {+ m1->capa = new_capa;+ S_REALLOC_N( m1->keys, SYMID, m1->capa );+ S_REALLOC_N( m1->values, SYMID, m1->capa );+ }+ for ( new_idx = 0; new_idx < m2->idx; m1->idx++, new_idx++ )+ {+ m1->keys[m1->idx] = m2->keys[new_idx]; + m1->values[m1->idx] = m2->values[new_idx]; + }+}++long+syck_map_count( SyckNode *map )+{+ ASSERT( map != NULL );+ ASSERT( map->data.pairs != NULL );+ return map->data.pairs->idx;+}++void+syck_map_assign( SyckNode *map, enum map_part p, long idx, SYMID id )+{+ struct SyckMap *m;++ ASSERT( map != NULL );+ m = map->data.pairs;+ ASSERT( m != NULL );+ if ( p == map_key )+ {+ m->keys[idx] = id;+ }+ else+ {+ m->values[idx] = id;+ }+}++SYMID+syck_map_read( SyckNode *map, enum map_part p, long idx )+{+ struct SyckMap *m;++ ASSERT( map != NULL );+ m = map->data.pairs;+ ASSERT( m != NULL );+ if ( p == map_key )+ {+ return m->keys[idx];+ }+ else+ {+ return m->values[idx];+ }+}++SyckNode *+syck_new_seq( SYMID value )+{+ SyckNode *n;++ n = syck_alloc_seq();+ syck_seq_add( n, value );++ return n;+}++void+syck_seq_empty( SyckNode *n )+{+ struct SyckSeq *s;+ ASSERT( n != NULL );+ ASSERT( n->data.list != NULL );++ S_FREE( n->data.list->items );+ s = n->data.list;+ s->idx = 0;+ s->capa = ALLOC_CT;+ s->items = S_ALLOC_N( SYMID, s->capa );+}++void+syck_seq_add( SyckNode *arr, SYMID value )+{+ struct SyckSeq *s;+ long idx;++ ASSERT( arr != NULL );+ ASSERT( arr->data.list != NULL );+ + s = arr->data.list;+ idx = s->idx;+ s->idx += 1;+ if ( s->idx > s->capa )+ {+ s->capa += ALLOC_CT;+ S_REALLOC_N( s->items, SYMID, s->capa );+ }+ s->items[idx] = value;+}++long+syck_seq_count( SyckNode *seq )+{+ ASSERT( seq != NULL );+ ASSERT( seq->data.list != NULL );+ return seq->data.list->idx;+}++void+syck_seq_assign( SyckNode *seq, long idx, SYMID id )+{+ struct SyckSeq *s;++ ASSERT( map != NULL );+ s = seq->data.list;+ ASSERT( m != NULL );+ s->items[idx] = id;+}++SYMID+syck_seq_read( SyckNode *seq, long idx )+{+ struct SyckSeq *s;++ ASSERT( seq != NULL );+ s = seq->data.list;+ ASSERT( s != NULL );+ return s->items[idx];+}++void+syck_free_members( SyckNode *n )+{+ if ( n == NULL ) return;++ switch ( n->kind )+ {+ case syck_str_kind:+ if ( n->data.str != NULL ) + {+ S_FREE( n->data.str->ptr );+ n->data.str->ptr = NULL;+ n->data.str->len = 0;+ S_FREE( n->data.str );+ n->data.str = NULL;+ }+ break;++ case syck_seq_kind:+ if ( n->data.list != NULL )+ {+ S_FREE( n->data.list->items );+ S_FREE( n->data.list );+ n->data.list = NULL;+ }+ break;++ case syck_map_kind:+ if ( n->data.pairs != NULL )+ {+ S_FREE( n->data.pairs->keys );+ S_FREE( n->data.pairs->values );+ S_FREE( n->data.pairs );+ n->data.pairs = NULL;+ }+ break;+ }+}+
+ syck/syck.c view
@@ -0,0 +1,504 @@+/*+ * syck.c+ *+ * $Author: why $+ * $Date: 2005-01-01 10:06:25 +0800 (六, 01 1 2005) $+ *+ * Copyright (C) 2003 why the lucky stiff+ */+#include <stdio.h>+#include <string.h>++#include "syck.h"++void syck_parser_pop_level( SyckParser * );++/*+ * Custom assert+ */+void +syck_assert( char *file_name, unsigned line_num )+{+ fflush( NULL );+ fprintf( stderr, "\nAssertion failed: %s, line %u\n",+ file_name, line_num );+ fflush( stderr );+ abort();+}++/*+ * Allocates and copies a string+ */+char *+syck_strndup( char *buf, long len )+{+ char *new = S_ALLOC_N( char, len + 1 );+ S_MEMZERO( new, char, len + 1 );+ S_MEMCPY( new, buf, char, len );+ return new;+}++/*+ * Default FILE IO function+ */+long+syck_io_file_read( char *buf, SyckIoFile *file, long max_size, long skip )+{+ long len = 0;++ ASSERT( file != NULL );++ max_size -= skip;+ len = fread( buf + skip, sizeof( char ), max_size, file->ptr );+ len += skip;+ buf[len] = '\0';++ return len;+}++/*+ * Default string IO function+ */+long+syck_io_str_read( char *buf, SyckIoStr *str, long max_size, long skip )+{+ char *beg;+ long len = 0;++ ASSERT( str != NULL );+ beg = str->ptr;+ if ( max_size >= 0 )+ {+ max_size -= skip;+ if ( max_size <= 0 ) max_size = 0;+ else str->ptr += max_size;++ if ( str->ptr > str->end )+ {+ str->ptr = str->end;+ }+ }+ else+ {+ /* Use exact string length */+ while ( str->ptr < str->end ) {+ if (*(str->ptr++) == '\n') break;+ }+ }+ if ( beg < str->ptr )+ {+ len = ( str->ptr - beg );+ S_MEMCPY( buf + skip, beg, char, len );+ }+ len += skip;+ buf[len] = '\0';++ return len;+}++void+syck_parser_reset_levels( SyckParser *p )+{+ while ( p->lvl_idx > 1 )+ {+ syck_parser_pop_level( p );+ }++ if ( p->lvl_idx < 1 )+ {+ p->lvl_idx = 1;+ p->levels[0].spaces = -1;+ p->levels[0].ncount = 0;+ p->levels[0].domain = syck_strndup( "", 0 );+ }+ p->levels[0].status = syck_lvl_header;+}++void+syck_parser_reset_cursor( SyckParser *p )+{+ if ( p->buffer == NULL )+ {+ p->buffer = S_ALLOC_N( char, p->bufsize );+ S_MEMZERO( p->buffer, char, p->bufsize );+ }+ p->buffer[0] = '\0';++ p->cursor = NULL;+ p->lineptr = NULL;+ p->linectptr = NULL;+ p->token = NULL;+ p->toktmp = NULL;+ p->marker = NULL;+ p->limit = NULL;++ p->root = 0;+ p->root_on_error = 0;+ p->linect = 0;+ p->eof = 0;+ p->last_token = 0;+ p->force_token = 0;+}++/*+ * Value to return on a parse error+ */+void+syck_parser_set_root_on_error( SyckParser *p, SYMID roer )+{+ p->root_on_error = roer;+}++/*+ * Allocate the parser+ */+SyckParser *+syck_new_parser()+{+ SyckParser *p;+ p = S_ALLOC( SyckParser );+ S_MEMZERO( p, SyckParser, 1 );+ p->lvl_capa = ALLOC_CT;+ p->levels = S_ALLOC_N( SyckLevel, p->lvl_capa ); + p->input_type = syck_yaml_utf8;+ p->io_type = syck_io_str;+ p->io.str = NULL;+ p->syms = NULL;+ p->anchors = NULL;+ p->bad_anchors = NULL;+ p->implicit_typing = 1;+ p->taguri_expansion = 0;+ p->bufsize = SYCK_BUFFERSIZE;+ p->buffer = NULL;+ p->lvl_idx = 0;+ syck_parser_reset_levels( p );+ return p;+}++int+syck_add_sym( SyckParser *p, char *data )+{+ SYMID id = 0;+ if ( p->syms == NULL )+ {+ p->syms = st_init_numtable();+ }+ id = p->syms->num_entries + 1;+ st_insert( p->syms, id, (st_data_t)data );+ return id;+}++int+syck_lookup_sym( SyckParser *p, SYMID id, char **data )+{+ if ( p->syms == NULL ) return 0;+ return st_lookup( p->syms, id, (st_data_t *)data );+}++int+syck_st_free_nodes( char *key, SyckNode *n, char *arg )+{+ if ( n != (void *)1 ) syck_free_node( n );+ n = NULL;+ return ST_CONTINUE;+}++void+syck_st_free( SyckParser *p )+{+ /*+ * Free the anchor tables+ */+ if ( p->anchors != NULL )+ {+ st_foreach( p->anchors, syck_st_free_nodes, 0 );+ st_free_table( p->anchors );+ p->anchors = NULL;+ }++ if ( p->bad_anchors != NULL )+ {+ st_foreach( p->bad_anchors, syck_st_free_nodes, 0 );+ st_free_table( p->bad_anchors );+ p->bad_anchors = NULL;+ }+}++void+syck_free_parser( SyckParser *p )+{+ /*+ * Free the adhoc symbol table+ */+ if ( p->syms != NULL )+ {+ st_free_table( p->syms );+ p->syms = NULL;+ }++ /*+ * Free tables, levels+ */+ syck_st_free( p );+ syck_parser_reset_levels( p );+ S_FREE( p->levels[0].domain );+ S_FREE( p->levels );++ if ( p->buffer != NULL )+ {+ S_FREE( p->buffer );+ }+ free_any_io( p );+ S_FREE( p );+}++void+syck_parser_handler( SyckParser *p, SyckNodeHandler hdlr )+{+ ASSERT( p != NULL );+ p->handler = hdlr;+}++void+syck_parser_implicit_typing( SyckParser *p, int flag )+{+ p->implicit_typing = ( flag == 0 ? 0 : 1 );+}++void+syck_parser_taguri_expansion( SyckParser *p, int flag )+{+ p->taguri_expansion = ( flag == 0 ? 0 : 1 );+}++void+syck_parser_error_handler( SyckParser *p, SyckErrorHandler hdlr )+{+ ASSERT( p != NULL );+ p->error_handler = hdlr;+}++void+syck_parser_bad_anchor_handler( SyckParser *p, SyckBadAnchorHandler hdlr )+{+ ASSERT( p != NULL );+ p->bad_anchor_handler = hdlr;+}++void+syck_parser_set_input_type( SyckParser *p, enum syck_parser_input input_type )+{+ ASSERT( p != NULL );+ p->input_type = input_type;+}++void+syck_parser_file( SyckParser *p, FILE *fp, SyckIoFileRead read )+{+ ASSERT( p != NULL );+ free_any_io( p );+ syck_parser_reset_cursor( p );+ p->io_type = syck_io_file;+ p->io.file = S_ALLOC( SyckIoFile );+ p->io.file->ptr = fp;+ if ( read != NULL )+ {+ p->io.file->read = read;+ }+ else+ {+ p->io.file->read = syck_io_file_read;+ }+}++void+syck_parser_str( SyckParser *p, char *ptr, long len, SyckIoStrRead read )+{+ ASSERT( p != NULL );+ free_any_io( p );+ syck_parser_reset_cursor( p );+ p->io_type = syck_io_str;+ p->io.str = S_ALLOC( SyckIoStr );+ p->io.str->beg = ptr;+ p->io.str->ptr = ptr;+ p->io.str->end = ptr + len;+ if ( read != NULL )+ {+ p->io.str->read = read;+ }+ else+ {+ p->io.str->read = syck_io_str_read;+ }+}++void+syck_parser_str_auto( SyckParser *p, char *ptr, SyckIoStrRead read )+{+ syck_parser_str( p, ptr, strlen( ptr ), read );+}++SyckLevel *+syck_parser_current_level( SyckParser *p )+{+ return &p->levels[p->lvl_idx-1];+}++void+syck_parser_pop_level( SyckParser *p )+{+ ASSERT( p != NULL );++ /* The root level should never be popped */+ if ( p->lvl_idx <= 1 ) return;++ p->lvl_idx -= 1;+ free( p->levels[p->lvl_idx].domain );+}++void +syck_parser_add_level( SyckParser *p, int len, enum syck_level_status status )+{+ ASSERT( p != NULL );+ if ( p->lvl_idx + 1 > p->lvl_capa )+ {+ p->lvl_capa += ALLOC_CT;+ S_REALLOC_N( p->levels, SyckLevel, p->lvl_capa );+ }++ ASSERT( len > p->levels[p->lvl_idx-1].spaces );+ p->levels[p->lvl_idx].spaces = len;+ p->levels[p->lvl_idx].ncount = 0;+ p->levels[p->lvl_idx].domain = syck_strndup( p->levels[p->lvl_idx-1].domain, strlen( p->levels[p->lvl_idx-1].domain ) );+ p->levels[p->lvl_idx].status = status;+ p->lvl_idx += 1;+}++void+free_any_io( SyckParser *p )+{+ ASSERT( p != NULL );+ switch ( p->io_type )+ {+ case syck_io_str:+ if ( p->io.str != NULL ) + {+ S_FREE( p->io.str );+ p->io.str = NULL;+ }+ break;++ case syck_io_file:+ if ( p->io.file != NULL ) + {+ S_FREE( p->io.file );+ p->io.file = NULL;+ }+ break;+ }+}++long+syck_move_tokens( SyckParser *p )+{+ long count, skip;+ ASSERT( p->buffer != NULL );++ if ( p->token == NULL )+ return 0;++ skip = p->limit - p->token;+ if ( skip < 0 )+ return 0;++ if ( ( count = p->token - p->buffer ) )+ {+ S_MEMMOVE( p->buffer, p->token, char, skip );+ p->token = p->buffer;+ p->marker -= count;+ p->cursor -= count;+ p->toktmp -= count;+ p->limit -= count;+ p->lineptr -= count;+ p->linectptr -= count;+ }+ return skip;+}++void+syck_check_limit( SyckParser *p, long len )+{+ if ( p->cursor == NULL )+ {+ p->cursor = p->buffer;+ p->lineptr = p->buffer;+ p->linectptr = p->buffer;+ p->marker = p->buffer;+ }+ p->limit = p->buffer + len;+}++long+syck_parser_read( SyckParser *p )+{+ long len = 0;+ long skip = 0;+ ASSERT( p != NULL );+ switch ( p->io_type )+ {+ case syck_io_str:+ skip = syck_move_tokens( p );+ len = (p->io.str->read)( p->buffer, p->io.str, SYCK_BUFFERSIZE - 1, skip );+ break;++ case syck_io_file:+ skip = syck_move_tokens( p );+ len = (p->io.file->read)( p->buffer, p->io.file, SYCK_BUFFERSIZE - 1, skip );+ break;+ }+ syck_check_limit( p, len );+ return len;+}++long+syck_parser_readlen( SyckParser *p, long max_size )+{+ long len = 0;+ long skip = 0;+ ASSERT( p != NULL );+ switch ( p->io_type )+ {+ case syck_io_str:+ skip = syck_move_tokens( p );+ len = (p->io.str->read)( p->buffer, p->io.str, max_size, skip );+ break;++ case syck_io_file:+ skip = syck_move_tokens( p );+ len = (p->io.file->read)( p->buffer, p->io.file, max_size, skip );+ break;+ }+ syck_check_limit( p, len );+ return len;+}++SYMID+syck_parse( SyckParser *p )+{+ ASSERT( p != NULL );++ syck_st_free( p );+ syck_parser_reset_levels( p );+ syckparse( p );+ return p->root;+}++void+syck_default_error_handler( SyckParser *p, char *msg )+{+ printf( "Error at [Line %d, Col %d]: %s\n", + p->linect,+ p->cursor - p->lineptr,+ msg );+}+
+ syck/syck_st.c view
@@ -0,0 +1,577 @@+/* 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 "config.h"+#include <stdio.h>+#include <stdlib.h>+#include "syck_st.h"++#ifdef NT+#include <malloc.h>+#endif++#define SIZE32 4+#if SIZEOF_LONG == SIZE32+typedef long I32;+typedef unsigned long U32;+#define NUM2I32(x) NUM2LONG(x)+#define NUM2U32(x) NUM2ULONG(x)+#elif SIZEOF_INT == SIZE32+typedef int I32;+typedef unsigned int U32;+#define NUM2I32(x) NUM2INT(x)+#define NUM2U32(x) NUM2UINT(x)+#endif++typedef struct st_table_entry st_table_entry;++struct st_table_entry {+ unsigned int hash;+ char *key;+ char *record;+ st_table_entry *next;+};++#define ST_DEFAULT_MAX_DENSITY 5+#define ST_DEFAULT_INIT_TABLE_SIZE 11++ /*+ * DEFAULT_MAX_DENSITY is the default for the largest we allow the+ * average number of items per bin before increasing the number of+ * bins+ *+ * DEFAULT_INIT_TABLE_SIZE is the default for the number of bins+ * allocated initially+ *+ */+static int numcmp();+static int numhash();+static struct st_hash_type type_numhash = {+ numcmp,+ numhash,+};++extern int strcmp();+static int strhash();+static struct st_hash_type type_strhash = {+ strcmp,+ strhash,+};++static void rehash();++#define alloc(type) (type*)malloc((unsigned)sizeof(type))+#define Calloc(n,s) (char*)calloc((n),(s))++#define EQUAL(table,x,y) ((x)==(y) || (*table->type->compare)((x),(y)) == 0)++#define do_hash(key,table) (unsigned int)(*(table)->type->hash)((key))+#define do_hash_bin(key,table) (do_hash(key, table)%(table)->num_bins)++/*+ * MINSIZE is the minimum size of a dictionary.+ */++#define MINSIZE 8++/*+Table of prime numbers 2^n+a, 2<=n<=30.+*/+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+};++static int+new_size(size)+ int size;+{+ int i;++#if 0+ for (i=3; i<31; i++) {+ if ((1<<i) > size) return 1<<i;+ }+ return -1;+#else+ int newsize;++ for (i = 0, newsize = MINSIZE;+ i < sizeof(primes)/sizeof(primes[0]);+ i++, newsize <<= 1)+ {+ if (newsize > size) return primes[i];+ }+ /* Ran out of polynomials */+ return -1; /* should raise exception */+#endif+}++#ifdef HASH_LOG+static int collision = 0;+static int init_st = 0;++static void+stat_col()+{+ FILE *f = fopen("/tmp/col", "w");+ fprintf(f, "collision: %d\n", collision);+ fclose(f);+}+#endif++st_table*+st_init_table_with_size(type, size)+ struct st_hash_type *type;+ int size;+{+ st_table *tbl;++#ifdef HASH_LOG+ if (init_st == 0) {+ init_st = 1;+ atexit(stat_col);+ }+#endif++ size = new_size(size); /* round up to prime number */++ tbl = alloc(st_table);+ tbl->type = type;+ tbl->num_entries = 0;+ tbl->num_bins = size;+ tbl->bins = (st_table_entry **)Calloc(size, sizeof(st_table_entry*));++ return tbl;+}++st_table*+st_init_table(type)+ struct st_hash_type *type;+{+ return st_init_table_with_size(type, 0);+}++st_table*+st_init_numtable()+{+ return st_init_table(&type_numhash);+}++st_table*+st_init_numtable_with_size(size)+ int size;+{+ return st_init_table_with_size(&type_numhash, size);+}++st_table*+st_init_strtable()+{+ return st_init_table(&type_strhash);+}++st_table*+st_init_strtable_with_size(size)+ int size;+{+ return st_init_table_with_size(&type_strhash, size);+}++void+st_free_table(table)+ st_table *table;+{+ register st_table_entry *ptr, *next;+ int i;++ for(i = 0; i < table->num_bins; i++) {+ ptr = table->bins[i];+ while (ptr != 0) {+ next = ptr->next;+ free(ptr);+ ptr = next;+ }+ }+ free(table->bins);+ free(table);+}++#define PTR_NOT_EQUAL(table, ptr, hash_val, key) \+((ptr) != 0 && (ptr->hash != (hash_val) || !EQUAL((table), (key), (ptr)->key)))++#ifdef HASH_LOG+#define COLLISION collision+++#else+#define COLLISION+#endif++#define FIND_ENTRY(table, ptr, hash_val, bin_pos) do {\+ bin_pos = hash_val%(table)->num_bins;\+ 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;\+ }\+} while (0)++int+st_lookup(table, key, value)+ st_table *table;+ register char *key;+ char **value;+{+ unsigned int hash_val, bin_pos;+ register st_table_entry *ptr;++ hash_val = do_hash(key, table);+ FIND_ENTRY(table, ptr, hash_val, bin_pos);++ if (ptr == 0) {+ return 0;+ }+ else {+ if (value != 0) *value = ptr->record;+ return 1;+ }+}++#define ADD_DIRECT(table, key, value, hash_val, bin_pos)\+do {\+ st_table_entry *entry;\+ if (table->num_entries/(table->num_bins) > ST_DEFAULT_MAX_DENSITY) {\+ rehash(table);\+ bin_pos = hash_val % table->num_bins;\+ }\+ \+ entry = alloc(st_table_entry);\+ \+ entry->hash = hash_val;\+ entry->key = key;\+ entry->record = value;\+ entry->next = table->bins[bin_pos];\+ table->bins[bin_pos] = entry;\+ table->num_entries++;\+} while (0)++int+st_insert(table, key, value)+ register st_table *table;+ register char *key;+ char *value;+{+ unsigned int hash_val, bin_pos;+ register st_table_entry *ptr;++ hash_val = do_hash(key, table);+ FIND_ENTRY(table, ptr, hash_val, bin_pos);++ if (ptr == 0) {+ ADD_DIRECT(table, key, value, hash_val, bin_pos);+ return 0;+ }+ else {+ ptr->record = value;+ return 1;+ }+}++void+st_add_direct(table, key, value)+ st_table *table;+ char *key;+ char *value;+{+ unsigned int hash_val, bin_pos;++ hash_val = do_hash(key, table);+ bin_pos = hash_val % table->num_bins;+ ADD_DIRECT(table, key, value, hash_val, bin_pos);+}++static void+rehash(table)+ register st_table *table;+{+ register st_table_entry *ptr, *next, **new_bins;+ int i, old_num_bins = table->num_bins, new_num_bins;+ unsigned int hash_val;++ new_num_bins = new_size(old_num_bins+1);+ new_bins = (st_table_entry**)Calloc(new_num_bins, sizeof(st_table_entry*));++ 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;+ }+ }+ free(table->bins);+ table->num_bins = new_num_bins;+ table->bins = new_bins;+}++st_table*+st_copy(old_table)+ st_table *old_table;+{+ st_table *new_table;+ st_table_entry *ptr, *entry;+ int i, num_bins = old_table->num_bins;++ new_table = alloc(st_table);+ if (new_table == 0) {+ return 0;+ }++ *new_table = *old_table;+ new_table->bins = (st_table_entry**)+ Calloc((unsigned)num_bins, sizeof(st_table_entry*));++ if (new_table->bins == 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;+ }+ }+ return new_table;+}++int+st_delete(table, key, value)+ register st_table *table;+ register char **key;+ char **value;+{+ unsigned int hash_val;+ st_table_entry *tmp;+ register st_table_entry *ptr;++ hash_val = do_hash_bin(*key, table);+ ptr = table->bins[hash_val];++ if (ptr == 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;+ }++ 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;+ }+ }++ return 0;+}++int+st_delete_safe(table, key, value, never)+ register st_table *table;+ register char **key;+ char **value;+ char *never;+{+ unsigned int hash_val;+ register st_table_entry *ptr;++ hash_val = do_hash_bin(*key, table);+ ptr = table->bins[hash_val];++ if (ptr == 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;+ }+ }++ return 0;+}++static int+delete_never(key, value, never)+ char *key, *value, *never;+{+ if (value == never) return ST_DELETE;+ return ST_CONTINUE;+}++void+st_cleanup_safe(table, never)+ st_table *table;+ char *never;+{+ int num_entries = table->num_entries;++ st_foreach(table, (enum st_retval (*)())delete_never, never);+ table->num_entries = num_entries;+}++void+st_foreach(table, func, arg)+ st_table *table;+ enum st_retval (*func)();+ char *arg;+{+ st_table_entry *ptr, *last, *tmp;+ enum st_retval retval;+ int i;++ 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--;+ }+ }+ }+}++static int+strhash(string)+ register char *string;+{+ register int c;++#ifdef HASH_ELFHASH+ register unsigned int h = 0, g;++ while ((c = *string++) != '\0') {+ h = ( h << 4 ) + c;+ if ( g = h & 0xF0000000 )+ h ^= g >> 24;+ h &= ~g;+ }+ return h;+#elif HASH_PERL+ register int val = 0;++ while ((c = *string++) != '\0') {+ val = val*33 + c;+ }++ return val + (val>>5);+#elif HASH_JENKINS+ register const unsigned char *s_PeRlHaSh = (const unsigned char *)string;+ register U32 hash_PeRlHaSh = 0;+ while ((c = *s_PeRlHaSh++) != '\0') {+ hash_PeRlHaSh += c;+ hash_PeRlHaSh += (hash_PeRlHaSh << 10);+ hash_PeRlHaSh ^= (hash_PeRlHaSh >> 6);+ }+ hash_PeRlHaSh += (hash_PeRlHaSh << 3);+ hash_PeRlHaSh ^= (hash_PeRlHaSh >> 11);+ return (hash_PeRlHaSh + (hash_PeRlHaSh << 15));+#else+ register int val = 0;++ while ((c = *string++) != '\0') {+ val = val*997 + c;+ }++ return val + (val>>5);+#endif+}++static int+numcmp(x, y)+ long x, y;+{+ return x != y;+}++static int+numhash(n)+ long n;+{+ return n;+}
+ syck/token.c view
@@ -0,0 +1,2838 @@+/* Generated by re2c 0.10.1 on Mon May 8 21:26:43 2006 */+#line 1 "token.re"+/*+ * token.re+ *+ * $Author: why $+ * $Date: 2005-09-21 07:42:51 +0800 (三, 21 9 2005) $+ *+ * Copyright (C) 2003 why the lucky stiff+ */+#include "syck.h"+#include "gram.h"++/*+ * Allocate quoted strings in chunks+ */+#define QUOTELEN 1024++/*+ * They do my bidding...+ */+#define YYCTYPE char+#define YYCURSOR parser->cursor+#define YYMARKER parser->marker+#define YYLIMIT parser->limit+#define YYTOKEN parser->token+#define YYTOKTMP parser->toktmp+#define YYLINEPTR parser->lineptr+#define YYLINECTPTR parser->linectptr+#define YYLINE parser->linect+#define YYFILL(n) syck_parser_read(parser)++/*+ * Repositions the cursor at `n' offset from the token start.+ * Only works in `Header' and `Document' sections.+ */+#define YYPOS(n) YYCURSOR = YYTOKEN + n++/*+ * Track line numbers+ */+#define NEWLINE(ptr) YYLINEPTR = ptr + newline_len(ptr); if ( YYLINEPTR > YYLINECTPTR ) { YYLINE++; YYLINECTPTR = YYLINEPTR; }++/*+ * I like seeing the level operations as macros...+ */+#define ADD_LEVEL(len, status) syck_parser_add_level( parser, len, status )+#define POP_LEVEL() syck_parser_pop_level( parser )+#define CURRENT_LEVEL() syck_parser_current_level( parser )++/*+ * Force a token next time around sycklex()+ */+#define FORCE_NEXT_TOKEN(tok) parser->force_token = tok;++/*+ * Nice little macro to ensure we're YAML_IOPENed to the current level.+ * * Only use this macro in the "Document" section *+ */+#define ENSURE_YAML_IOPEN(last_lvl, to_len, reset) \+ if ( last_lvl->spaces < to_len ) \+ { \+ if ( last_lvl->status == syck_lvl_iseq || last_lvl->status == syck_lvl_imap ) \+ { \+ goto Document; \+ } \+ else \+ { \+ ADD_LEVEL( to_len, syck_lvl_doc ); \+ if ( reset == 1 ) YYPOS(0); \+ return YAML_IOPEN; \+ } \+ } ++/*+ * Nice little macro to ensure closure of levels.+ * * Only use this macro in the "Document" section *+ */+#define ENSURE_YAML_IEND(last_lvl, to_len) \+ if ( last_lvl->spaces > to_len ) \+ { \+ syck_parser_pop_level( parser ); \+ YYPOS(0); \+ return YAML_IEND; \+ }++/*+ * Concatenates quoted string items and manages allocation+ * to the quoted string+ */+#define QUOTECAT(s, c, i, l) \+ { \+ if ( i + 1 >= c ) \+ { \+ c += QUOTELEN; \+ S_REALLOC_N( s, char, c ); \+ } \+ s[i++] = l; \+ s[i] = '\0'; \+ }++#define QUOTECATS(s, c, i, cs, cl) \+ { \+ while ( i + cl >= c ) \+ { \+ c += QUOTELEN; \+ S_REALLOC_N( s, char, c ); \+ } \+ S_MEMCPY( s + i, cs, char, cl ); \+ i += cl; \+ s[i] = '\0'; \+ }++/*+ * Tags a plain scalar with a transfer method+ * * Use only in "Plain" section *+ */+#define RETURN_IMPLICIT() \+ { \+ SyckNode *n = syck_alloc_str(); \+ YYCURSOR = YYTOKEN; \+ n->data.str->ptr = qstr; \+ n->data.str->len = qidx; \+ n->data.str->style = scalar_plain; \+ sycklval->nodeData = n; \+ if ( parser->implicit_typing == 1 ) \+ { \+ try_tag_implicit( sycklval->nodeData, parser->taguri_expansion ); \+ } \+ return YAML_PLAIN; \+ }++/* concat the inline characters to the plain scalar */+#define PLAIN_NOT_INL() \+ if ( *(YYCURSOR - 1) == ' ' || is_newline( YYCURSOR - 1 ) ) \+ { \+ YYCURSOR--; \+ } \+ QUOTECATS(qstr, qcapa, qidx, YYTOKEN, YYCURSOR - YYTOKEN); \+ goto Plain2;++/* trim spaces off the end in case of indent */+#define PLAIN_IS_INL() \+ char *walker = qstr + qidx - 1; \+ while ( walker > qstr && ( *walker == '\n' || *walker == ' ' || *walker == '\t' ) ) \+ { \+ qidx--; \+ walker[0] = '\0'; \+ walker--; \+ }++/*+ * Keep or chomp block?+ * * Use only in "ScalarBlock" section *+ */+#define RETURN_YAML_BLOCK() \+ { \+ SyckNode *n = syck_alloc_str(); \+ if ( ((SyckParser *)parser)->taguri_expansion == 1 ) \+ { \+ n->type_id = syck_taguri( YAML_DOMAIN, "str", 3 ); \+ } \+ else \+ { \+ n->type_id = syck_strndup( "str", 3 ); \+ } \+ n->data.str->ptr = qstr; \+ n->data.str->len = qidx; \+ if ( blockType == BLOCK_LIT ) { \+ n->data.str->style = scalar_literal; \+ } else { \+ n->data.str->style = scalar_fold; \+ } \+ if ( qidx > 0 ) \+ { \+ if ( nlDoWhat != NL_KEEP ) \+ { \+ char *fc = n->data.str->ptr + n->data.str->len - 1; \+ while ( is_newline( fc ) ) fc--; \+ if ( nlDoWhat != NL_CHOMP && fc < n->data.str->ptr + n->data.str->len - 1 ) \+ fc += 1; \+ n->data.str->len = fc - n->data.str->ptr + 1; \+ } \+ } \+ sycklval->nodeData = n; \+ return YAML_BLOCK; \+ }++/*+ * Handles newlines, calculates indent+ */+#define GOBBLE_UP_YAML_INDENT( ict, start ) \+ char *indent = start; \+ NEWLINE(indent); \+ while ( indent < YYCURSOR ) \+ { \+ if ( is_newline( ++indent ) ) \+ { \+ NEWLINE(indent); \+ } \+ } \+ ict = 0; \+ if ( *YYCURSOR == '\0' ) \+ { \+ ict = -1; \+ start = YYCURSOR - 1; \+ } \+ else if ( *YYLINEPTR == ' ' ) \+ { \+ ict = YYCURSOR - YYLINEPTR; \+ }++/*+ * If an indent exists at the current level, back up.+ */+#define GET_TRUE_YAML_INDENT(indt_len) \+ { \+ SyckLevel *lvl_deep = CURRENT_LEVEL(); \+ indt_len = lvl_deep->spaces; \+ if ( lvl_deep->status == syck_lvl_seq || ( indt_len == YYCURSOR - YYLINEPTR && lvl_deep->status != syck_lvl_map ) ) \+ { \+ SyckLevel *lvl_over; \+ parser->lvl_idx--; \+ lvl_over = CURRENT_LEVEL(); \+ indt_len = lvl_over->spaces; \+ parser->lvl_idx++; \+ } \+ }++/*+ * Argjh! I hate globals! Here for syckerror() only!+ */+SyckParser *syck_parser_ptr = NULL;++/*+ * Accessory funcs later in this file.+ */+void eat_comments( SyckParser * );+char escape_seq( char );+int is_newline( char *ptr );+int newline_len( char *ptr );+int sycklex_yaml_utf8( YYSTYPE *, SyckParser * );+int sycklex_bytecode_utf8( YYSTYPE *, SyckParser * );+int syckwrap();++/*+ * My own re-entrant sycklex() using re2c.+ * You really get used to the limited regexp.+ * It's really nice to not rely on backtracking and such.+ */+int+sycklex( YYSTYPE *sycklval, SyckParser *parser )+{+ switch ( parser->input_type )+ {+ case syck_yaml_utf8:+ return sycklex_yaml_utf8( sycklval, parser );++ case syck_yaml_utf16:+ syckerror( "UTF-16 is not currently supported in Syck.\nPlease contribute code to help this happen!" );+ break;++ case syck_yaml_utf32:+ syckerror( "UTF-32 is not currently supported in Syck.\nPlease contribute code to help this happen!" );+ break;++ case syck_bytecode_utf8:+ return sycklex_bytecode_utf8( sycklval, parser );+ }+ return YAML_DOCSEP;+}++/*+ * Parser for standard YAML [UTF-8]+ */+int+sycklex_yaml_utf8( YYSTYPE *sycklval, SyckParser *parser )+{+ int doc_level = 0;+ syck_parser_ptr = parser;+ if ( YYCURSOR == NULL ) + {+ syck_parser_read( parser );+ }++ if ( parser->force_token != 0 )+ {+ int t = parser->force_token;+ parser->force_token = 0;+ return t;+ }++#line 315 "token.re"+++ if ( YYLINEPTR != YYCURSOR )+ {+ goto Document;+ }++Header:++ YYTOKEN = YYCURSOR;+++#line 307 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;++ if((YYLIMIT - YYCURSOR) < 5) YYFILL(5);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy7;+ case 0x09:+ case ' ': goto yy12;+ case 0x0A: goto yy9;+ case 0x0D: goto yy11;+ case '#': goto yy5;+ case '-': goto yy2;+ case '.': goto yy4;+ default: goto yy14;+ }+yy2:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '-': goto yy28;+ default: goto yy3;+ }+yy3:+#line 374 "token.re"+ { YYPOS(0);+ goto Document; + }+#line 337 "<stdout>"+yy4:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '.': goto yy21;+ default: goto yy3;+ }+yy5:+ ++YYCURSOR;+#line 356 "token.re"+ { eat_comments( parser ); + goto Header;+ }+#line 351 "<stdout>"+yy7:+ ++YYCURSOR;+#line 360 "token.re"+ { SyckLevel *lvl = CURRENT_LEVEL();+ ENSURE_YAML_IEND(lvl, -1);+ YYPOS(0);+ return 0; + }+#line 360 "<stdout>"+yy9:+ yyaccept = 1;+ yych = *(YYMARKER = ++YYCURSOR);+ goto yy18;+yy10:+#line 366 "token.re"+ { GOBBLE_UP_YAML_INDENT( doc_level, YYTOKEN );+ goto Header; + }+#line 370 "<stdout>"+yy11:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy17;+ default: goto yy3;+ }+yy12:+ ++YYCURSOR;+ yych = *YYCURSOR;+ goto yy16;+yy13:+#line 370 "token.re"+ { doc_level = YYCURSOR - YYLINEPTR;+ goto Header;+ }+#line 386 "<stdout>"+yy14:+ yych = *++YYCURSOR;+ goto yy3;+yy15:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy16:+ switch(yych){+ case 0x09:+ case ' ': goto yy15;+ default: goto yy13;+ }+yy17:+ yyaccept = 1;+ YYMARKER = ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy18:+ switch(yych){+ case 0x0A:+ case ' ': goto yy17;+ case 0x0D: goto yy19;+ default: goto yy10;+ }+yy19:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy17;+ default: goto yy20;+ }+yy20:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 1: goto yy10;+ case 0: goto yy3;+ }+yy21:+ yych = *++YYCURSOR;+ switch(yych){+ case '.': goto yy22;+ default: goto yy20;+ }+yy22:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy23;+ case 0x0D: goto yy27;+ case ' ': goto yy25;+ default: goto yy20;+ }+yy23:+ ++YYCURSOR;+yy24:+#line 342 "token.re"+ { SyckLevel *lvl = CURRENT_LEVEL();+ if ( lvl->status == syck_lvl_header )+ {+ goto Header; + }+ else+ {+ ENSURE_YAML_IEND(lvl, -1);+ YYPOS(0);+ return 0; + }+ return 0; + }+#line 457 "<stdout>"+yy25:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case ' ': goto yy25;+ default: goto yy24;+ }+yy27:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy23;+ default: goto yy20;+ }+yy28:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy29;+ default: goto yy20;+ }+yy29:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy30;+ case 0x0D: goto yy34;+ case ' ': goto yy32;+ default: goto yy20;+ }+yy30:+ ++YYCURSOR;+yy31:+#line 328 "token.re"+ { SyckLevel *lvl = CURRENT_LEVEL();+ if ( lvl->status == syck_lvl_header )+ {+ YYPOS(3);+ goto Directive; + }+ else+ {+ ENSURE_YAML_IEND(lvl, -1);+ YYPOS(0);+ return 0; + }+ }+#line 503 "<stdout>"+yy32:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case ' ': goto yy32;+ default: goto yy31;+ }+yy34:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy30;+ default: goto yy20;+ }+}+#line 378 "token.re"+++Document:+ {+ SyckLevel *lvl = CURRENT_LEVEL();+ if ( lvl->status == syck_lvl_header )+ {+ lvl->status = syck_lvl_doc;+ }++ YYTOKEN = YYCURSOR;+++#line 533 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 3) YYFILL(3);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy62;+ case 0x09:+ case ' ': goto yy60;+ case 0x0A: goto yy37;+ case 0x0D: goto yy39;+ case '!': goto yy51;+ case '"': goto yy55;+ case '#': goto yy58;+ case '&': goto yy49;+ case '\'': goto yy53;+ case '*': goto yy50;+ case ',':+ case ':': goto yy47;+ case '-':+ case '?': goto yy48;+ case '>':+ case '|': goto yy57;+ case '[': goto yy41;+ case ']':+ case '}': goto yy45;+ case '{': goto yy43;+ default: goto yy64;+ }+yy37:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ goto yy92;+yy38:+#line 392 "token.re"+ { /* Isolate spaces */+ int indt_len;+ GOBBLE_UP_YAML_INDENT( indt_len, YYTOKEN );+ lvl = CURRENT_LEVEL();+ doc_level = 0;++ /* XXX: Comment lookahead */+ if ( *YYCURSOR == '#' )+ {+ goto Document;+ }++ /* Ignore indentation inside inlines */+ if ( lvl->status == syck_lvl_iseq || lvl->status == syck_lvl_imap )+ {+ goto Document;+ }++ /* Check for open indent */+ ENSURE_YAML_IEND(lvl, indt_len);+ ENSURE_YAML_IOPEN(lvl, indt_len, 0);+ if ( indt_len == -1 )+ {+ return 0;+ }+ return YAML_INDENT;+ }+#line 596 "<stdout>"+yy39:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy91;+ default: goto yy40;+ }+yy40:+#line 500 "token.re"+ { ENSURE_YAML_IOPEN(lvl, doc_level, 1);+ goto Plain; + }+#line 608 "<stdout>"+yy41:+ ++YYCURSOR;+#line 420 "token.re"+ { ENSURE_YAML_IOPEN(lvl, doc_level, 1);+ lvl = CURRENT_LEVEL();+ ADD_LEVEL(lvl->spaces + 1, syck_lvl_iseq);+ return YYTOKEN[0]; + }+#line 617 "<stdout>"+yy43:+ ++YYCURSOR;+#line 426 "token.re"+ { ENSURE_YAML_IOPEN(lvl, doc_level, 1);+ lvl = CURRENT_LEVEL();+ ADD_LEVEL(lvl->spaces + 1, syck_lvl_imap);+ return YYTOKEN[0]; + }+#line 626 "<stdout>"+yy45:+ ++YYCURSOR;+#line 432 "token.re"+ { POP_LEVEL();+ return YYTOKEN[0]; + }+#line 633 "<stdout>"+yy47:+ yyaccept = 1;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x0A: goto yy86;+ case 0x0D: goto yy90;+ case ' ': goto yy88;+ default: goto yy40;+ }+yy48:+ yyaccept = 1;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x0A: goto yy81;+ case 0x0D: goto yy85;+ case ' ': goto yy83;+ default: goto yy40;+ }+yy49:+ yych = *++YYCURSOR;+ switch(yych){+ case '-':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy78;+ default: goto yy40;+ }+yy50:+ yych = *++YYCURSOR;+ switch(yych){+ case '-':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy75;+ default: goto yy40;+ }+yy51:+ ++YYCURSOR;+#line 474 "token.re"+ { goto TransferMethod; }+#line 794 "<stdout>"+yy53:+ ++YYCURSOR;+#line 476 "token.re"+ { ENSURE_YAML_IOPEN(lvl, doc_level, 1);+ goto SingleQuote; }+#line 800 "<stdout>"+yy55:+ ++YYCURSOR;+#line 479 "token.re"+ { ENSURE_YAML_IOPEN(lvl, doc_level, 1);+ goto DoubleQuote; }+#line 806 "<stdout>"+yy57:+ yyaccept = 1;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x0A: goto yy70;+ case 0x0D: goto yy74;+ case ' ': goto yy72;+ case '+':+ case '-':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy67;+ default: goto yy40;+ }+yy58:+ ++YYCURSOR;+#line 489 "token.re"+ { eat_comments( parser ); + goto Document;+ }+#line 834 "<stdout>"+yy60:+ ++YYCURSOR;+ yych = *YYCURSOR;+ goto yy66;+yy61:+#line 493 "token.re"+ { goto Document; }+#line 842 "<stdout>"+yy62:+ ++YYCURSOR;+#line 495 "token.re"+ { ENSURE_YAML_IEND(lvl, -1);+ YYPOS(0);+ return 0; + }+#line 850 "<stdout>"+yy64:+ yych = *++YYCURSOR;+ goto yy40;+yy65:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy66:+ switch(yych){+ case 0x09:+ case ' ': goto yy65;+ default: goto yy61;+ }+yy67:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy70;+ case 0x0D: goto yy74;+ case ' ': goto yy72;+ case '+':+ case '-':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9': goto yy67;+ default: goto yy69;+ }+yy69:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy38;+ case 1: goto yy40;+ }+yy70:+ ++YYCURSOR;+yy71:+#line 482 "token.re"+ { if ( is_newline( YYCURSOR - 1 ) ) + {+ YYCURSOR--;+ }+ goto ScalarBlock; + }+#line 902 "<stdout>"+yy72:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case ' ': goto yy72;+ default: goto yy71;+ }+yy74:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy70;+ default: goto yy69;+ }+yy75:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '-':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy75;+ default: goto yy77;+ }+yy77:+#line 469 "token.re"+ { ENSURE_YAML_IOPEN(lvl, doc_level, 1);+ sycklval->name = syck_strndup( YYTOKEN + 1, YYCURSOR - YYTOKEN - 1 );+ return YAML_ALIAS;+ }+#line 994 "<stdout>"+yy78:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '-':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy78;+ default: goto yy80;+ }+yy80:+#line 458 "token.re"+ { sycklval->name = syck_strndup( YYTOKEN + 1, YYCURSOR - YYTOKEN - 1 );++ /*+ * Remove previous anchors of the same name. Since the parser will likely+ * construct deeper nodes first, we want those nodes to be placed in the+ * queue for matching at a higher level of indentation.+ */+ syck_hdlr_remove_anchor(parser, sycklval->name);+ return YAML_ANCHOR;+ }+#line 1078 "<stdout>"+yy81:+ ++YYCURSOR;+yy82:+#line 444 "token.re"+ { ENSURE_YAML_IOPEN(lvl, YYTOKEN - YYLINEPTR, 1);+ FORCE_NEXT_TOKEN(YAML_IOPEN);+ if ( *YYCURSOR == '#' || is_newline( YYCURSOR ) || is_newline( YYCURSOR - 1 ) )+ {+ YYCURSOR--; + ADD_LEVEL((YYTOKEN + 1) - YYLINEPTR, syck_lvl_seq);+ }+ else /* spaces followed by content uses the space as indentation */+ {+ ADD_LEVEL(YYCURSOR - YYLINEPTR, syck_lvl_seq);+ }+ return YYTOKEN[0]; + }+#line 1096 "<stdout>"+yy83:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case ' ': goto yy83;+ default: goto yy82;+ }+yy85:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy81;+ default: goto yy69;+ }+yy86:+ ++YYCURSOR;+yy87:+#line 436 "token.re"+ { if ( *YYTOKEN == ':' && lvl->status != syck_lvl_imap && lvl->status != syck_lvl_iseq )+ {+ lvl->status = syck_lvl_map;+ }+ YYPOS(1); + return YYTOKEN[0]; + }+#line 1122 "<stdout>"+yy88:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case ' ': goto yy88;+ default: goto yy87;+ }+yy90:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy86;+ default: goto yy69;+ }+yy91:+ yyaccept = 0;+ YYMARKER = ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy92:+ switch(yych){+ case 0x0A:+ case ' ': goto yy91;+ case 0x0D: goto yy93;+ default: goto yy38;+ }+yy93:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy91;+ default: goto yy69;+ }+}+#line 504 "token.re"++ }++Directive:+ {+ YYTOKTMP = YYCURSOR;+++#line 1167 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy96;+ case 0x09:+ case ' ': goto yy99;+ case '%': goto yy97;+ default: goto yy101;+ }+yy96:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy98;+ }+yy97:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case ':':+ case ';':+ case '<':+ case '=':+ case '>':+ case '?':+ case '@':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '[':+ case '\\':+ case ']':+ case '^':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy104;+ default: goto yy98;+ }+yy98:+#line 517 "token.re"+ { YYCURSOR = YYTOKTMP;+ return YAML_DOCSEP;+ }+#line 1272 "<stdout>"+yy99:+ ++YYCURSOR;+ yych = *YYCURSOR;+ goto yy103;+yy100:+#line 515 "token.re"+ { goto Directive; }+#line 1280 "<stdout>"+yy101:+ yych = *++YYCURSOR;+ goto yy98;+yy102:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy103:+ switch(yych){+ case 0x09:+ case ' ': goto yy102;+ default: goto yy100;+ }+yy104:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case ';':+ case '<':+ case '=':+ case '>':+ case '?':+ case '@':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '[':+ case '\\':+ case ']':+ case '^':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy104;+ case ':': goto yy106;+ default: goto yy96;+ }+yy106:+ yych = *++YYCURSOR;+ switch(yych){+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case ':':+ case ';':+ case '<':+ case '=':+ case '>':+ case '?':+ case '@':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '[':+ case '\\':+ case ']':+ case '^':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy107;+ default: goto yy96;+ }+yy107:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case '.':+ case '/':+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case ':':+ case ';':+ case '<':+ case '=':+ case '>':+ case '?':+ case '@':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'G':+ case 'H':+ case 'I':+ case 'J':+ case 'K':+ case 'L':+ case 'M':+ case 'N':+ case 'O':+ case 'P':+ case 'Q':+ case 'R':+ case 'S':+ case 'T':+ case 'U':+ case 'V':+ case 'W':+ case 'X':+ case 'Y':+ case 'Z':+ case '[':+ case '\\':+ case ']':+ case '^':+ case '_':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f':+ case 'g':+ case 'h':+ case 'i':+ case 'j':+ case 'k':+ case 'l':+ case 'm':+ case 'n':+ case 'o':+ case 'p':+ case 'q':+ case 'r':+ case 's':+ case 't':+ case 'u':+ case 'v':+ case 'w':+ case 'x':+ case 'y':+ case 'z': goto yy107;+ default: goto yy109;+ }+yy109:+#line 513 "token.re"+ { goto Directive; }+#line 1544 "<stdout>"+}+#line 520 "token.re"+++ }++Plain:+ {+ int qidx = 0;+ int qcapa = 100;+ char *qstr = S_ALLOC_N( char, qcapa );+ SyckLevel *plvl;+ int parentIndent;++ YYCURSOR = YYTOKEN;+ plvl = CURRENT_LEVEL();+ GET_TRUE_YAML_INDENT(parentIndent);++Plain2: + YYTOKEN = YYCURSOR;++Plain3:+++#line 1569 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 3) YYFILL(3);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy124;+ case 0x09: goto yy126;+ case 0x0A: goto yy112;+ case 0x0D: goto yy114;+ case ' ': goto yy122;+ case ',': goto yy117;+ case ':': goto yy116;+ case ']': goto yy120;+ case '}': goto yy118;+ default: goto yy127;+ }+yy112:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ goto yy142;+yy113:+#line 543 "token.re"+ { int indt_len, nl_count = 0;+ SyckLevel *lvl;+ char *tok = YYTOKEN;+ GOBBLE_UP_YAML_INDENT( indt_len, tok );+ lvl = CURRENT_LEVEL();++ if ( indt_len <= parentIndent )+ {+ RETURN_IMPLICIT();+ }++ while ( YYTOKEN < YYCURSOR )+ {+ int nl_len = newline_len( YYTOKEN++ );+ if ( nl_len )+ {+ nl_count++;+ YYTOKEN += nl_len - 1;+ }+ }+ if ( nl_count <= 1 )+ {+ QUOTECAT(qstr, qcapa, qidx, ' ');+ }+ else+ {+ int i;+ for ( i = 0; i < nl_count - 1; i++ )+ {+ QUOTECAT(qstr, qcapa, qidx, '\n');+ }+ }++ goto Plain2; + }+#line 1628 "<stdout>"+yy114:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy141;+ default: goto yy115;+ }+yy115:+#line 630 "token.re"+ { QUOTECATS(qstr, qcapa, qidx, YYTOKEN, YYCURSOR - YYTOKEN);+ goto Plain2;+ }+#line 1640 "<stdout>"+yy116:+ yyaccept = 1;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x0A: goto yy136;+ case 0x0D: goto yy140;+ case ' ': goto yy138;+ default: goto yy115;+ }+yy117:+ yyaccept = 1;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x0A: goto yy130;+ case 0x0D: goto yy134;+ case ' ': goto yy132;+ default: goto yy115;+ }+yy118:+ ++YYCURSOR;+#line 592 "token.re"+ { if ( plvl->status != syck_lvl_imap )+ {+ PLAIN_NOT_INL();+ }+ else+ {+ PLAIN_IS_INL();+ }+ RETURN_IMPLICIT();+ }+#line 1672 "<stdout>"+yy120:+ ++YYCURSOR;+#line 603 "token.re"+ { if ( plvl->status != syck_lvl_iseq )+ {+ PLAIN_NOT_INL();+ }+ else+ {+ PLAIN_IS_INL();+ }+ RETURN_IMPLICIT();+ }+#line 1686 "<stdout>"+yy122:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case '#': goto yy128;+ default: goto yy123;+ }+yy123:+#line 620 "token.re"+ { if ( qidx == 0 ) + {+ goto Plain2;+ }+ else+ {+ goto Plain3; + }+ }+#line 1704 "<stdout>"+yy124:+ ++YYCURSOR;+#line 618 "token.re"+ { RETURN_IMPLICIT(); }+#line 1709 "<stdout>"+yy126:+ yych = *++YYCURSOR;+ goto yy123;+yy127:+ yych = *++YYCURSOR;+ goto yy115;+yy128:+ ++YYCURSOR;+#line 614 "token.re"+ { eat_comments( parser ); + RETURN_IMPLICIT();+ }+#line 1722 "<stdout>"+yy130:+ ++YYCURSOR;+yy131:+#line 581 "token.re"+ { if ( plvl->status != syck_lvl_iseq && plvl->status != syck_lvl_imap )+ {+ PLAIN_NOT_INL();+ }+ else+ {+ PLAIN_IS_INL();+ }+ RETURN_IMPLICIT();+ }+#line 1737 "<stdout>"+yy132:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case ' ': goto yy132;+ default: goto yy131;+ }+yy134:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy130;+ default: goto yy135;+ }+yy135:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy113;+ case 1: goto yy115;+ }+yy136:+ ++YYCURSOR;+yy137:+#line 579 "token.re"+ { RETURN_IMPLICIT(); }+#line 1763 "<stdout>"+yy138:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case ' ': goto yy138;+ default: goto yy137;+ }+yy140:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy136;+ default: goto yy135;+ }+yy141:+ yyaccept = 0;+ YYMARKER = ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy142:+ switch(yych){+ case 0x0A:+ case ' ': goto yy141;+ case 0x0D: goto yy143;+ default: goto yy113;+ }+yy143:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy141;+ default: goto yy135;+ }+}+#line 634 "token.re"++ }++SingleQuote:+ {+ int qidx = 0;+ int qcapa = 100;+ char *qstr = S_ALLOC_N( char, qcapa );++SingleQuote2:+ YYTOKEN = YYCURSOR;+++#line 1813 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy152;+ case 0x0A: goto yy146;+ case 0x0D: goto yy148;+ case '\'': goto yy150;+ default: goto yy153;+ }+yy146:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ goto yy157;+yy147:+#line 648 "token.re"+ { int indt_len;+ int nl_count = 0;+ SyckLevel *lvl;+ GOBBLE_UP_YAML_INDENT( indt_len, YYTOKEN );+ lvl = CURRENT_LEVEL();++ if ( lvl->status != syck_lvl_str )+ {+ ADD_LEVEL( indt_len, syck_lvl_str );+ }+ else if ( indt_len < lvl->spaces )+ {+ /* Error! */+ }++ while ( YYTOKEN < YYCURSOR )+ {+ int nl_len = newline_len( YYTOKEN++ );+ if ( nl_len )+ {+ nl_count++;+ YYTOKEN += nl_len - 1;+ }+ }+ if ( nl_count <= 1 )+ {+ QUOTECAT(qstr, qcapa, qidx, ' ');+ }+ else+ {+ int i;+ for ( i = 0; i < nl_count - 1; i++ )+ {+ QUOTECAT(qstr, qcapa, qidx, '\n');+ }+ }++ goto SingleQuote2; + }+#line 1871 "<stdout>"+yy148:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy156;+ default: goto yy149;+ }+yy149:+#line 715 "token.re"+ { QUOTECAT(qstr, qcapa, qidx, *(YYCURSOR - 1)); + goto SingleQuote2; + }+#line 1883 "<stdout>"+yy150:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case '\'': goto yy154;+ default: goto yy151;+ }+yy151:+#line 692 "token.re"+ { SyckLevel *lvl;+ SyckNode *n = syck_alloc_str();+ lvl = CURRENT_LEVEL();++ if ( lvl->status == syck_lvl_str )+ {+ POP_LEVEL();+ }+ if ( ((SyckParser *)parser)->taguri_expansion == 1 )+ {+ n->type_id = syck_taguri( YAML_DOMAIN, "str", 3 );+ }+ else+ {+ n->type_id = syck_strndup( "str", 3 );+ }+ n->data.str->ptr = qstr;+ n->data.str->len = qidx;+ n->data.str->style = scalar_1quote;+ sycklval->nodeData = n;+ return YAML_PLAIN; + }+#line 1914 "<stdout>"+yy152:+ yych = *++YYCURSOR;+ goto yy151;+yy153:+ yych = *++YYCURSOR;+ goto yy149;+yy154:+ ++YYCURSOR;+#line 688 "token.re"+ { QUOTECAT(qstr, qcapa, qidx, '\'');+ goto SingleQuote2; + }+#line 1927 "<stdout>"+yy156:+ yyaccept = 0;+ YYMARKER = ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy157:+ switch(yych){+ case 0x0A:+ case ' ': goto yy156;+ case 0x0D: goto yy158;+ default: goto yy147;+ }+yy158:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy156;+ default: goto yy159;+ }+yy159:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy147;+ }+}+#line 719 "token.re"+++ }+++DoubleQuote:+ {+ int keep_nl = 1;+ int qidx = 0;+ int qcapa = 100;+ char *qstr = S_ALLOC_N( char, qcapa );++DoubleQuote2:+ YYTOKEN = YYCURSOR;++++#line 1972 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 4) YYFILL(4);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy167;+ case 0x0A: goto yy162;+ case 0x0D: goto yy164;+ case '"': goto yy169;+ case '\\': goto yy166;+ default: goto yy170;+ }+yy162:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ goto yy184;+yy163:+#line 737 "token.re"+ { int indt_len;+ int nl_count = 0;+ SyckLevel *lvl;+ GOBBLE_UP_YAML_INDENT( indt_len, YYTOKEN );+ lvl = CURRENT_LEVEL();++ if ( lvl->status != syck_lvl_str )+ {+ ADD_LEVEL( indt_len, syck_lvl_str );+ }+ else if ( indt_len < lvl->spaces )+ {+ /* FIXME */+ }++ if ( keep_nl == 1 )+ {+ while ( YYTOKEN < YYCURSOR )+ {+ int nl_len = newline_len( YYTOKEN++ );+ if ( nl_len )+ {+ nl_count++;+ YYTOKEN += nl_len - 1;+ }+ }+ if ( nl_count <= 1 )+ {+ QUOTECAT(qstr, qcapa, qidx, ' ');+ }+ else+ {+ int i;+ for ( i = 0; i < nl_count - 1; i++ )+ {+ QUOTECAT(qstr, qcapa, qidx, '\n');+ }+ }+ }++ keep_nl = 1;+ goto DoubleQuote2; + }+#line 2035 "<stdout>"+yy164:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy183;+ default: goto yy165;+ }+yy165:+#line 823 "token.re"+ { QUOTECAT(qstr, qcapa, qidx, *(YYCURSOR - 1)); + goto DoubleQuote2; + }+#line 2047 "<stdout>"+yy166:+ yyaccept = 1;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case 0x0A: goto yy174;+ case 0x0D: goto yy176;+ case ' ': goto yy171;+ case '"':+ case '0':+ case '\\':+ case 'a':+ case 'b':+ case 'e':+ case 'f':+ case 'n':+ case 'r':+ case 't':+ case 'v': goto yy178;+ case 'x': goto yy177;+ default: goto yy165;+ }+yy167:+ ++YYCURSOR;+yy168:+#line 800 "token.re"+ { SyckLevel *lvl;+ SyckNode *n = syck_alloc_str();+ lvl = CURRENT_LEVEL();++ if ( lvl->status == syck_lvl_str )+ {+ POP_LEVEL();+ }+ if ( ((SyckParser *)parser)->taguri_expansion == 1 )+ {+ n->type_id = syck_taguri( YAML_DOMAIN, "str", 3 );+ }+ else+ {+ n->type_id = syck_strndup( "str", 3 );+ }+ n->data.str->ptr = qstr;+ n->data.str->len = qidx;+ n->data.str->style = scalar_2quote;+ sycklval->nodeData = n;+ return YAML_PLAIN; + }+#line 2095 "<stdout>"+yy169:+ yych = *++YYCURSOR;+ goto yy168;+yy170:+ yych = *++YYCURSOR;+ goto yy165;+yy171:+ ++YYCURSOR;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy174;+ case 0x0D: goto yy176;+ case ' ': goto yy171;+ default: goto yy173;+ }+yy173:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy163;+ case 1: goto yy165;+ }+yy174:+ ++YYCURSOR;+#line 795 "token.re"+ { keep_nl = 0;+ YYCURSOR--;+ goto DoubleQuote2; + }+#line 2125 "<stdout>"+yy176:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy174;+ default: goto yy173;+ }+yy177:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f': goto yy180;+ default: goto yy173;+ }+yy178:+ ++YYCURSOR;+#line 781 "token.re"+ { char ch = *( YYCURSOR - 1 );+ QUOTECAT(qstr, qcapa, qidx, escape_seq( ch ));+ goto DoubleQuote2; + }+#line 2166 "<stdout>"+yy180:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f': goto yy181;+ default: goto yy173;+ }+yy181:+ ++YYCURSOR;+#line 786 "token.re"+ { long ch;+ char *chr_text = syck_strndup( YYTOKEN, 4 );+ chr_text[0] = '0';+ ch = strtol( chr_text, NULL, 16 );+ free( chr_text );+ QUOTECAT(qstr, qcapa, qidx, ch);+ goto DoubleQuote2; + }+#line 2205 "<stdout>"+yy183:+ yyaccept = 0;+ YYMARKER = ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy184:+ switch(yych){+ case 0x0A:+ case ' ': goto yy183;+ case 0x0D: goto yy185;+ default: goto yy163;+ }+yy185:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy183;+ default: goto yy173;+ }+}+#line 827 "token.re"++ }++TransferMethod:+ {+ int qidx = 0;+ int qcapa = 100;+ char *qstr = S_ALLOC_N( char, qcapa );++TransferMethod2:+ YYTOKTMP = YYCURSOR;+++#line 2241 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 4) YYFILL(4);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy188;+ case 0x0A: goto yy190;+ case 0x0D: goto yy192;+ case ' ': goto yy191;+ case '\\': goto yy194;+ default: goto yy195;+ }+yy188:+ ++YYCURSOR;+yy189:+#line 841 "token.re"+ { SyckLevel *lvl;+ YYCURSOR = YYTOKTMP;+ if ( YYCURSOR == YYTOKEN + 1 )+ {+ free( qstr );+ return YAML_ITRANSFER;+ }++ lvl = CURRENT_LEVEL();++ /*+ * URL Prefixing+ */+ if ( *qstr == '^' )+ {+ sycklval->name = S_ALLOC_N( char, qidx + strlen( lvl->domain ) );+ sycklval->name[0] = '\0';+ strcat( sycklval->name, lvl->domain );+ strncat( sycklval->name, qstr + 1, qidx - 1 );+ free( qstr );+ }+ else+ {+ char *carat = qstr;+ char *qend = qstr + qidx;+ while ( (++carat) < qend )+ {+ if ( *carat == '^' )+ break;+ }++ if ( carat < qend )+ {+ free( lvl->domain );+ lvl->domain = syck_strndup( qstr, carat - qstr );+ sycklval->name = S_ALLOC_N( char, ( qend - carat ) + strlen( lvl->domain ) );+ sycklval->name[0] = '\0';+ strcat( sycklval->name, lvl->domain );+ strncat( sycklval->name, carat + 1, ( qend - carat ) - 1 );+ free( qstr );+ }+ else+ {+ sycklval->name = qstr;+ }+ }++ return YAML_TRANSFER; + }+#line 2308 "<stdout>"+yy190:+ yych = *++YYCURSOR;+ goto yy189;+yy191:+ yych = *++YYCURSOR;+ goto yy204;+yy192:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy188;+ default: goto yy193;+ }+yy193:+#line 908 "token.re"+ { QUOTECAT(qstr, qcapa, qidx, *(YYCURSOR - 1)); + goto TransferMethod2;+ }+#line 2326 "<stdout>"+yy194:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '"':+ case '0':+ case '\\':+ case 'a':+ case 'b':+ case 'e':+ case 'f':+ case 'n':+ case 'r':+ case 't':+ case 'v': goto yy198;+ case 'x': goto yy196;+ default: goto yy193;+ }+yy195:+ yych = *++YYCURSOR;+ goto yy193;+yy196:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f': goto yy200;+ default: goto yy197;+ }+yy197:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy193;+ }+yy198:+ ++YYCURSOR;+#line 894 "token.re"+ { char ch = *( YYCURSOR - 1 );+ QUOTECAT(qstr, qcapa, qidx, escape_seq( ch ));+ goto TransferMethod2;+ }+#line 2387 "<stdout>"+yy200:+ yych = *++YYCURSOR;+ switch(yych){+ case '0':+ case '1':+ case '2':+ case '3':+ case '4':+ case '5':+ case '6':+ case '7':+ case '8':+ case '9':+ case 'A':+ case 'B':+ case 'C':+ case 'D':+ case 'E':+ case 'F':+ case 'a':+ case 'b':+ case 'c':+ case 'd':+ case 'e':+ case 'f': goto yy201;+ default: goto yy197;+ }+yy201:+ ++YYCURSOR;+#line 899 "token.re"+ { long ch;+ char *chr_text = syck_strndup( YYTOKTMP, 4 );+ chr_text[0] = '0';+ ch = strtol( chr_text, NULL, 16 );+ free( chr_text );+ QUOTECAT(qstr, qcapa, qidx, ch);+ goto TransferMethod2;+ }+#line 2426 "<stdout>"+yy203:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy204:+ switch(yych){+ case ' ': goto yy203;+ default: goto yy189;+ }+}+#line 913 "token.re"++ }++ScalarBlock:+ {+ int qidx = 0;+ int qcapa = 100;+ char *qstr = S_ALLOC_N( char, qcapa );+ int blockType = 0;+ int nlDoWhat = 0;+ int lastIndent = 0;+ int forceIndent = -1;+ char *yyt = YYTOKEN;+ SyckLevel *lvl = CURRENT_LEVEL();+ int parentIndent = -1;++ switch ( *yyt )+ {+ case '|': blockType = BLOCK_LIT; break;+ case '>': blockType = BLOCK_FOLD; break;+ }++ while ( ++yyt <= YYCURSOR )+ {+ if ( *yyt == '-' )+ {+ nlDoWhat = NL_CHOMP;+ }+ else if ( *yyt == '+' )+ {+ nlDoWhat = NL_KEEP;+ }+ else if ( isdigit( *yyt ) )+ {+ forceIndent = strtol( yyt, NULL, 10 );+ }+ }++ qstr[0] = '\0';+ YYTOKEN = YYCURSOR;++ScalarBlock2:+ YYTOKEN = YYCURSOR;+++#line 2483 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 5) YYFILL(5);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy213;+ case 0x0A: goto yy207;+ case 0x0D: goto yy209;+ case '#': goto yy211;+ case '-': goto yy215;+ default: goto yy216;+ }+yy207:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ goto yy226;+yy208:+#line 959 "token.re"+ { char *pacer;+ char *tok = YYTOKEN;+ int indt_len = 0, nl_count = 0, fold_nl = 0, nl_begin = 0;+ GOBBLE_UP_YAML_INDENT( indt_len, tok );+ lvl = CURRENT_LEVEL();++ if ( lvl->status != syck_lvl_block )+ {+ GET_TRUE_YAML_INDENT(parentIndent);+ if ( forceIndent > 0 ) forceIndent += parentIndent;+ if ( indt_len > parentIndent )+ {+ int new_spaces = forceIndent > 0 ? forceIndent : indt_len;+ ADD_LEVEL( new_spaces, syck_lvl_block );+ lastIndent = indt_len - new_spaces;+ nl_begin = 1;+ lvl = CURRENT_LEVEL();+ }+ else+ {+ YYCURSOR = YYTOKEN;+ RETURN_YAML_BLOCK();+ }+ }++ /*+ * Fold only in the event of two lines being on the leftmost+ * indentation.+ */+ if ( blockType == BLOCK_FOLD && lastIndent == 0 && ( indt_len - lvl->spaces ) == 0 )+ {+ fold_nl = 1;+ }++ pacer = YYTOKEN;+ while ( pacer < YYCURSOR )+ {+ int nl_len = newline_len( pacer++ );+ if ( nl_len )+ {+ nl_count++;+ pacer += nl_len - 1;+ }+ }++ if ( fold_nl == 1 || nl_begin == 1 )+ {+ nl_count--;+ }++ if ( nl_count < 1 && nl_begin == 0 )+ {+ QUOTECAT(qstr, qcapa, qidx, ' ');+ }+ else+ {+ int i;+ for ( i = 0; i < nl_count; i++ )+ {+ QUOTECAT(qstr, qcapa, qidx, '\n');+ }+ }++ lastIndent = indt_len - lvl->spaces;+ YYCURSOR -= lastIndent;++ if ( indt_len < lvl->spaces )+ {+ POP_LEVEL();+ YYCURSOR = YYTOKEN;+ RETURN_YAML_BLOCK();+ }+ goto ScalarBlock2;+ }+#line 2577 "<stdout>"+yy209:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy225;+ default: goto yy210;+ }+yy210:+#line 1073 "token.re"+ { QUOTECAT(qstr, qcapa, qidx, *YYTOKEN);+ goto ScalarBlock2;+ }+#line 2589 "<stdout>"+yy211:+ ++YYCURSOR;+#line 1035 "token.re"+ { lvl = CURRENT_LEVEL();+ if ( lvl->status != syck_lvl_block )+ {+ eat_comments( parser );+ YYTOKEN = YYCURSOR;+ }+ else+ {+ QUOTECAT(qstr, qcapa, qidx, *YYTOKEN);+ }+ goto ScalarBlock2;+ }+#line 2605 "<stdout>"+yy213:+ ++YYCURSOR;+#line 1049 "token.re"+ { YYCURSOR--;+ POP_LEVEL();+ RETURN_YAML_BLOCK(); + }+#line 2613 "<stdout>"+yy215:+ yyaccept = 1;+ yych = *(YYMARKER = ++YYCURSOR);+ switch(yych){+ case '-': goto yy217;+ default: goto yy210;+ }+yy216:+ yych = *++YYCURSOR;+ goto yy210;+yy217:+ yych = *++YYCURSOR;+ switch(yych){+ case '-': goto yy219;+ default: goto yy218;+ }+yy218:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy208;+ case 1: goto yy210;+ }+yy219:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy220;+ case 0x0D: goto yy224;+ case ' ': goto yy222;+ default: goto yy218;+ }+yy220:+ ++YYCURSOR;+yy221:+#line 1054 "token.re"+ { if ( YYTOKEN == YYLINEPTR )+ {+ if ( blockType == BLOCK_FOLD && qidx > 0 )+ {+ qidx -= 1;+ }+ QUOTECAT(qstr, qcapa, qidx, '\n');+ POP_LEVEL();+ YYCURSOR = YYTOKEN;+ RETURN_YAML_BLOCK();+ }+ else+ {+ QUOTECAT(qstr, qcapa, qidx, *YYTOKEN);+ YYCURSOR = YYTOKEN + 1;+ goto ScalarBlock2;+ }+ }+#line 2666 "<stdout>"+yy222:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case ' ': goto yy222;+ default: goto yy221;+ }+yy224:+ yych = *++YYCURSOR;+ switch(yych){+ case 0x0A: goto yy220;+ default: goto yy218;+ }+yy225:+ yyaccept = 0;+ YYMARKER = ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy226:+ switch(yych){+ case 0x0A:+ case ' ': goto yy225;+ case 0x0D: goto yy227;+ default: goto yy208;+ }+yy227:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy225;+ default: goto yy218;+ }+}+#line 1078 "token.re"++ }++ return 0;++}++void+eat_comments( SyckParser *parser )+{+Comment:+ {+ YYTOKEN = YYCURSOR;+++#line 2718 "<stdout>"+{+ YYCTYPE yych;+ unsigned int yyaccept = 0;+ if((YYLIMIT - YYCURSOR) < 2) YYFILL(2);+ yych = *YYCURSOR;+ switch(yych){+ case 0x00: goto yy230;+ case 0x0A: goto yy232;+ case 0x0D: goto yy233;+ default: goto yy235;+ }+yy230:+ ++YYCURSOR;+yy231:+#line 1094 "token.re"+ { YYCURSOR = YYTOKEN;+ return;+ }+#line 2737 "<stdout>"+yy232:+ yyaccept = 0;+ yych = *(YYMARKER = ++YYCURSOR);+ goto yy237;+yy233:+ ++YYCURSOR;+ switch((yych = *YYCURSOR)) {+ case 0x0A: goto yy236;+ default: goto yy234;+ }+yy234:+#line 1098 "token.re"+ { goto Comment; + }+#line 2752 "<stdout>"+yy235:+ yych = *++YYCURSOR;+ goto yy234;+yy236:+ yyaccept = 0;+ YYMARKER = ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+yy237:+ switch(yych){+ case 0x0A: goto yy236;+ case 0x0D: goto yy238;+ default: goto yy231;+ }+yy238:+ ++YYCURSOR;+ if(YYLIMIT == YYCURSOR) YYFILL(1);+ yych = *YYCURSOR;+ switch(yych){+ case 0x0A: goto yy236;+ default: goto yy239;+ }+yy239:+ YYCURSOR = YYMARKER;+ switch(yyaccept){+ case 0: goto yy231;+ }+}+#line 1101 "token.re"+++ }++}++char+escape_seq( char ch )+{+ switch ( ch )+ {+ case '0': return '\0';+ case 'a': return 7;+ case 'b': return '\010';+ case 'e': return '\033';+ case 'f': return '\014';+ case 'n': return '\n';+ case 'r': return '\015';+ case 't': return '\t';+ case 'v': return '\013';+ default: return ch;+ }+}++int+is_newline( char *ptr )+{+ return newline_len( ptr );+}++int+newline_len( char *ptr )+{+ if ( *ptr == '\n' )+ return 1;+ + if ( *ptr == '\r' && *( ptr + 1 ) == '\n' )+ return 2;++ return 0;+}++int +syckwrap()+{+ return 1;+}++void +syckerror( char *msg )+{+ if ( syck_parser_ptr->error_handler == NULL )+ syck_parser_ptr->error_handler = syck_default_error_handler;++ syck_parser_ptr->root = syck_parser_ptr->root_on_error;+ (syck_parser_ptr->error_handler)(syck_parser_ptr, msg);+}+
+ syck/yaml2byte.c view
@@ -0,0 +1,255 @@+/*+ * yaml2byte.c+ *+ * $Author: why $+ * $Date: 2005-09-19 14:12:54 +0800 (一, 19 9 2005) $+ *+ * 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 );++ if ( syck_lookup_sym( parser, oid, (char **)&sav ) == 1 ) {+ ret = S_ALLOC_N( char, strlen( sav->buffer ) + 3 );+ ret[0] = '\0';+ strcat( ret, "D\n" );+ strcat( ret, sav->buffer );+ }+ else+ {+ ret = NULL;+ }++ 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+