diff --git a/Data/Yaml/Syck.hsc b/Data/Yaml/Syck.hsc new file mode 100644 --- /dev/null +++ b/Data/Yaml/Syck.hsc @@ -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 : diff --git a/HsSyck.cabal b/HsSyck.cabal new file mode 100644 --- /dev/null +++ b/HsSyck.cabal @@ -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 diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -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. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,3 @@ +#!/usr/bin/env runhaskell +import Distribution.Simple +main = defaultMainWithHooks defaultUserHooks diff --git a/syck/bytecode.c b/syck/bytecode.c new file mode 100644 --- /dev/null +++ b/syck/bytecode.c @@ -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 "" +{ + 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 "" +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 "" +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 "" +{ + 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 "" +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 "" +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 "" +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 "" +yy25: + ++YYCURSOR; +#line 366 "bytecode.re" + { goto Comment; } +#line 387 "" +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 "" +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 "" +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 "" +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 "" +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 "" +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 "" +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 "" +{ + 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 "" +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 "" +yy58: + ++YYCURSOR; + switch((yych = *YYCURSOR)) { + case 0x0A: goto yy56; + default: goto yy47; + } +} +#line 402 "bytecode.re" + + + } + +Comment: + { + YYTOKEN = YYCURSOR; + + +#line 921 "" +{ + 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 "" +yy64: + ++YYCURSOR; + switch((yych = *YYCURSOR)) { + case 0x0A: goto yy67; + default: goto yy65; + } +yy65: +#line 415 "bytecode.re" + { goto Comment; } +#line 949 "" +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 "" +{ + 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 "" +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 "" +yy74: + ++YYCURSOR; +#line 465 "bytecode.re" + { YYCURSOR = tok; + goto ScalarEnd; + } +#line 1019 "" +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 "" +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 "" +yy83: + ++YYCURSOR; +#line 456 "bytecode.re" + { CHK_NL(tok+1); + CAT(str, cap, idx, '\0'); + goto Scalar2; + } +#line 1081 "" +} +#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 "" +{ + 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 "" +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 "" +yy91: + ++YYCURSOR; +#line 511 "bytecode.re" + { YYCURSOR = tok; + return str; + } +#line 1154 "" +yy93: + yych = *++YYCURSOR; + goto yy90; +yy94: + ++YYCURSOR; + yych = *YYCURSOR; + goto yy88; +} +#line 519 "bytecode.re" + + + } + +} + diff --git a/syck/emitter.c b/syck/emitter.c new file mode 100644 --- /dev/null +++ b/syck/emitter.c @@ -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 +#include + +#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; +} + diff --git a/syck/gram.c b/syck/gram.c new file mode 100644 --- /dev/null +++ b/syck/gram.c @@ -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 /* 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 /* 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 /* 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; +} + + diff --git a/syck/handler.c b/syck/handler.c new file mode 100644 --- /dev/null +++ b/syck/handler.c @@ -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; +} + diff --git a/syck/implicit.c b/syck/implicit.c new file mode 100644 --- /dev/null +++ b/syck/implicit.c @@ -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 "" +{ + 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 "" +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 "" +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 "" +yy28: + ++YYCURSOR; +#line 119 "implicit.re" + { return "default"; } +#line 301 "" +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 "" +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 "" +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 "" +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 "" +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 "" +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 "" +yy72: + ++YYCURSOR; +#line 103 "implicit.re" + { return "float#base60"; } +#line 596 "" +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 "" +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 "" +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 "" +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 "" +yy149: + ++YYCURSOR; +#line 93 "implicit.re" + { return "int#oct"; } +#line 1407 "" +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 "" +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 "" +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 "" +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 "" +{ + 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 "" +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 "" +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 "" +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 "" +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 "" +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 "" +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" + + +} diff --git a/syck/node.c b/syck/node.c new file mode 100644 --- /dev/null +++ b/syck/node.c @@ -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; + } +} + diff --git a/syck/syck.c b/syck/syck.c new file mode 100644 --- /dev/null +++ b/syck/syck.c @@ -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 +#include + +#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 ); +} + diff --git a/syck/syck_st.c b/syck/syck_st.c new file mode 100644 --- /dev/null +++ b/syck/syck_st.c @@ -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 +#include +#include "syck_st.h" + +#ifdef NT +#include +#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< size) return 1< 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; +} diff --git a/syck/token.c b/syck/token.c new file mode 100644 --- /dev/null +++ b/syck/token.c @@ -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 "" +{ + 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 "" +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 "" +yy7: + ++YYCURSOR; +#line 360 "token.re" + { SyckLevel *lvl = CURRENT_LEVEL(); + ENSURE_YAML_IEND(lvl, -1); + YYPOS(0); + return 0; + } +#line 360 "" +yy9: + yyaccept = 1; + yych = *(YYMARKER = ++YYCURSOR); + goto yy18; +yy10: +#line 366 "token.re" + { GOBBLE_UP_YAML_INDENT( doc_level, YYTOKEN ); + goto Header; + } +#line 370 "" +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 "" +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 "" +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 "" +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 "" +{ + 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 "" +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 "" +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 "" +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 "" +yy45: + ++YYCURSOR; +#line 432 "token.re" + { POP_LEVEL(); + return YYTOKEN[0]; + } +#line 633 "" +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 "" +yy53: + ++YYCURSOR; +#line 476 "token.re" + { ENSURE_YAML_IOPEN(lvl, doc_level, 1); + goto SingleQuote; } +#line 800 "" +yy55: + ++YYCURSOR; +#line 479 "token.re" + { ENSURE_YAML_IOPEN(lvl, doc_level, 1); + goto DoubleQuote; } +#line 806 "" +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 "" +yy60: + ++YYCURSOR; + yych = *YYCURSOR; + goto yy66; +yy61: +#line 493 "token.re" + { goto Document; } +#line 842 "" +yy62: + ++YYCURSOR; +#line 495 "token.re" + { ENSURE_YAML_IEND(lvl, -1); + YYPOS(0); + return 0; + } +#line 850 "" +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 "" +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 "" +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 "" +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 "" +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 "" +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 "" +{ + 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 "" +yy99: + ++YYCURSOR; + yych = *YYCURSOR; + goto yy103; +yy100: +#line 515 "token.re" + { goto Directive; } +#line 1280 "" +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 "" +} +#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 "" +{ + 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 "" +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 "" +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 "" +yy120: + ++YYCURSOR; +#line 603 "token.re" + { if ( plvl->status != syck_lvl_iseq ) + { + PLAIN_NOT_INL(); + } + else + { + PLAIN_IS_INL(); + } + RETURN_IMPLICIT(); + } +#line 1686 "" +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 "" +yy124: + ++YYCURSOR; +#line 618 "token.re" + { RETURN_IMPLICIT(); } +#line 1709 "" +yy126: + yych = *++YYCURSOR; + goto yy123; +yy127: + yych = *++YYCURSOR; + goto yy115; +yy128: + ++YYCURSOR; +#line 614 "token.re" + { eat_comments( parser ); + RETURN_IMPLICIT(); + } +#line 1722 "" +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 "" +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 "" +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 "" +{ + 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 "" +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 "" +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 "" +yy152: + yych = *++YYCURSOR; + goto yy151; +yy153: + yych = *++YYCURSOR; + goto yy149; +yy154: + ++YYCURSOR; +#line 688 "token.re" + { QUOTECAT(qstr, qcapa, qidx, '\''); + goto SingleQuote2; + } +#line 1927 "" +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 "" +{ + 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 "" +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 "" +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 "" +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 "" +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 "" +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 "" +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 "" +{ + 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 "" +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 "" +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 "" +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 "" +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 "" +{ + 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 "" +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 "" +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 "" +yy213: + ++YYCURSOR; +#line 1049 "token.re" + { YYCURSOR--; + POP_LEVEL(); + RETURN_YAML_BLOCK(); + } +#line 2613 "" +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 "" +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 "" +{ + 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 "" +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 "" +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); +} + diff --git a/syck/yaml2byte.c b/syck/yaml2byte.c new file mode 100644 --- /dev/null +++ b/syck/yaml2byte.c @@ -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 +#include +#define YAMLBYTE_UTF8 +#include "yamlbyte.h" + +#include +#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 +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 +