git.iko.soy/typeable/yaml
on ac9f8c7 help sign in
5f5462d
swap
0 ahead, 403 behind
.github/workflows/tests.ymldeleted−44
since splitsnapshots
unifiedsplit
@@ -1,44 +0,0 @@
1−name: Tests
2−
3−on:
4− pull_request:
5− push:
6− branches:
7− - master
8−
9−jobs:
10− build:
11− name: CI
12− runs-on: ${{ matrix.os }}
13− strategy:
14− fail-fast: false
15− matrix:
16− os: [ubuntu-latest, macos-latest, windows-latest]
17− resolver: [nightly, lts-22, lts-20, lts-17]
18− exclude:
19− - os: windows-latest
20− resolver: lts-15
21− - os: windows-latest
22− resolver: nightly
23−
24− steps:
25− - name: Clone project
26− uses: actions/checkout@v3
27−
28− - name: Cache dependencies
29− if: ${{ runner.os != 'Windows' }}
30− # Andreas Abel, 2023-06-10, switching off caching on Windows since ~/.stack is not the correct path here.
31− uses: actions/cache@v3
32− with:
33− path: ~/.stack
34− #NB: This path is not valid on Windows
35− key: ${{ runner.os }}-${{ matrix.resolver }}-${{ hashFiles('stack.yaml') }}
36− restore-keys: |
37− ${{ runner.os }}-${{ matrix.resolver }}-
38−
39− - name: Build and run tests
40− shell: bash
41− run: |
42− set -ex
43− stack upgrade || curl -sSL https://get.haskellstack.org/ | sh -s - -f
44− stack test --bench --no-run-benchmarks --haddock --no-haddock-deps --no-terminal --resolver=${{ matrix.resolver }}
.gitignore+2−6
@@ -1,11 +1,7 @@
1dist
1dist
2*.swp
2*.swp
3+tmp.yaml
4+tmp2.yaml
3cabal-dev/
5cabal-dev/
4.cabal-sandbox/
6.cabal-sandbox/
5cabal.sandbox.config
7cabal.sandbox.config
6−.stack-work/
7−*~
8−tarballs/
9−.dir-locals.el
10−*#
11−stack.yaml.lock
.gitmodulesdeleted−3
@@ -1,3 +0,0 @@
1−[submodule "vendor/libyaml"]
2− path = libyaml/vendor/libyaml
3− url = https://github.com/snoyberg/libyaml
.travis.ymlnew file+1
@@ -0,0 +1 @@
1+language: haskell
Data/Yaml.hsnew file+371
@@ -0,0 +1,371 @@
1+{-# LANGUAGE FlexibleContexts #-}
2+{-# LANGUAGE FlexibleInstances #-}
3+{-# LANGUAGE CPP #-}
4+{-# LANGUAGE DeriveDataTypeable #-}
5+{-# LANGUAGE MultiParamTypeClasses #-}
6+{-# LANGUAGE PatternGuards #-}
7+{-# LANGUAGE ScopedTypeVariables #-}
8+{-# LANGUAGE OverloadedStrings #-}
9+-- | Provides a high-level interface for processing YAML files.
10+--
11+-- This module reuses most of the infrastructure from the @aeson@ package.
12+-- This means that you can use all of the existing tools for JSON
13+-- processing for processing YAML files. As a result, much of the
14+-- documentation below mentions JSON; do not let that confuse you, it's
15+-- intentional.
16+--
17+-- For the most part, YAML content translates directly into JSON, and
18+-- therefore there is very little data loss. If you need to deal with YAML
19+-- more directly (e.g., directly deal with aliases), you should use the
20+-- "Text.Libyaml" module instead.
21+--
22+-- For documentation on the @aeson@ types, functions, classes, and
23+-- operators, please see the @Data.Aeson@ module of the @aeson@ package.
24+module Data.Yaml
25+ ( -- * Types
26+ Value (..)
27+ , Parser
28+ , Object
29+ , Array
30+ , ParseException(..)
31+ , YamlException (..)
32+ , YamlMark (..)
33+ -- * Constructors and accessors
34+ , object
35+ , array
36+ , (.=)
37+ , (.:)
38+ , (.:?)
39+ , (.!=)
40+ -- * Parsing
41+ , parseMonad
42+ , parseEither
43+ , parseMaybe
44+ -- * Classes
45+ , ToJSON (..)
46+ , FromJSON (..)
47+ -- * Encoding/decoding
48+ , encode
49+ , encodeFile
50+ , decode
51+ , decodeFile
52+ -- ** Better error information
53+ , decodeEither
54+ , decodeEither'
55+ , decodeFileEither
56+ -- ** More control over decoding
57+ , decodeHelper
58+ ) where
59+
60+import qualified Text.Libyaml as Y
61+import Data.Aeson
62+ ( Value (..), ToJSON (..), FromJSON (..), object
63+ , (.=) , (.:) , (.:?) , (.!=)
64+ , Object, Array
65+ )
66+import Data.Aeson.Types (Pair, parseMaybe, parseEither, Parser)
67+import Text.Libyaml hiding (encode, decode, encodeFile, decodeFile)
68+import Data.ByteString (ByteString)
69+import qualified Data.ByteString.Char8 as S8
70+import qualified Data.Map as Map
71+import System.IO.Unsafe (unsafePerformIO)
72+import Control.Exception (try, throwIO, fromException, Exception, SomeException, AsyncException)
73+import Control.Monad.Trans.State
74+import qualified Data.Conduit as C
75+import qualified Data.Conduit.List as CL
76+import Control.Monad.Trans.Class (MonadTrans, lift)
77+import Control.Monad.IO.Class (MonadIO, liftIO)
78+import Control.Monad (liftM)
79+import Data.Char (toUpper)
80+import qualified Data.Vector as V
81+import Data.Text (Text, pack)
82+import qualified Data.Text as T
83+import Data.Text.Encoding (encodeUtf8, decodeUtf8With)
84+import Data.Text.Encoding.Error (lenientDecode)
85+import qualified Data.HashMap.Strict as M
86+import Data.Typeable
87+import qualified Data.HashSet as HashSet
88+import Data.Text.Read
89+#if MIN_VERSION_aeson(0, 7, 0)
90+import Data.Scientific (fromFloatDigits)
91+#else
92+import Data.Attoparsec.Number
93+#endif
94+
95+encode :: ToJSON a => a -> ByteString
96+encode obj = unsafePerformIO $
97+ C.runResourceT $ CL.sourceList (objToEvents $ toJSON obj)
98+ C.$$ Y.encode
99+
100+encodeFile :: ToJSON a => FilePath -> a -> IO ()
101+encodeFile fp obj = C.runResourceT
102+ $ CL.sourceList (objToEvents $ toJSON obj)
103+ C.$$ Y.encodeFile fp
104+
105+objToEvents :: Value -> [Y.Event]
106+objToEvents o = (:) EventStreamStart
107+ . (:) EventDocumentStart
108+ $ objToEvents' o
109+ [ EventDocumentEnd
110+ , EventStreamEnd
111+ ]
112+
113+{- FIXME
114+scalarToEvent :: YamlScalar -> Event
115+scalarToEvent (YamlScalar v t s) = EventScalar v t s Nothing
116+-}
117+
118+objToEvents' :: Value -> [Y.Event] -> [Y.Event]
119+--objToEvents' (Scalar s) rest = scalarToEvent s : rest
120+objToEvents' (Array list) rest =
121+ EventSequenceStart Nothing
122+ : foldr ($) (EventSequenceEnd : rest) (map objToEvents' $ V.toList list)
123+objToEvents' (Object pairs) rest =
124+ EventMappingStart Nothing
125+ : foldr ($) (EventMappingEnd : rest) (map pairToEvents $ M.toList pairs)
126+
127+-- Empty strings need special handling to ensure they get quoted. This avoids:
128+-- https://github.com/snoyberg/yaml/issues/24
129+objToEvents' (String "") rest = EventScalar "" NoTag SingleQuoted Nothing : rest
130+
131+objToEvents' (String s) rest =
132+ event : rest
133+ where
134+ event
135+ -- Make sure that special strings are encoded as strings properly.
136+ -- See: https://github.com/snoyberg/yaml/issues/31
137+ | s `HashSet.member` specialStrings || isNumeric s = EventScalar (encodeUtf8 s) NoTag SingleQuoted Nothing
138+ | otherwise = EventScalar (encodeUtf8 s) StrTag PlainNoTag Nothing
139+objToEvents' Null rest = EventScalar "null" NullTag PlainNoTag Nothing : rest
140+objToEvents' (Bool True) rest = EventScalar "true" BoolTag PlainNoTag Nothing : rest
141+objToEvents' (Bool False) rest = EventScalar "false" BoolTag PlainNoTag Nothing : rest
142+objToEvents' (Number n) rest = EventScalar (S8.pack $ show n) IntTag PlainNoTag Nothing : rest
143+
144+pairToEvents :: Pair -> [Y.Event] -> [Y.Event]
145+pairToEvents (k, v) rest =
146+ EventScalar (encodeUtf8 k) StrTag PlainNoTag Nothing
147+ : objToEvents' v rest
148+
149+-- | Strings which must be escaped so as not to be treated as non-string scalars.
150+specialStrings :: HashSet.HashSet Text
151+specialStrings = HashSet.fromList $ T.words
152+ "y Y yes Yes YES n N no No NO true True TRUE false False FALSE on On ON off Off OFF null Null NULL ~"
153+
154+isNumeric :: Text -> Bool
155+isNumeric =
156+ T.all isNumeric'
157+ where
158+ isNumeric' c = ('0' <= c && c <= '9')
159+ || c == 'e'
160+ || c == 'E'
161+ || c == '.'
162+ || c == '-'
163+
164+-- Parsing
165+
166+data ParseException = NonScalarKey
167+ | UnknownAlias { _anchorName :: Y.AnchorName }
168+ | UnexpectedEvent { _received :: Maybe Event
169+ , _expected :: Maybe Event
170+ }
171+ | InvalidYaml (Maybe YamlException)
172+ | AesonException String
173+ | OtherParseException SomeException
174+ deriving (Show, Typeable)
175+instance Exception ParseException
176+
177+newtype PErrorT m a = PErrorT { runPErrorT :: m (Either ParseException a) }
178+instance Monad m => Monad (PErrorT m) where
179+ return = PErrorT . return . Right
180+ (PErrorT m) >>= f = PErrorT $ do
181+ e <- m
182+ case e of
183+ Left e' -> return $ Left e'
184+ Right a -> runPErrorT $ f a
185+instance MonadTrans PErrorT where
186+ lift = PErrorT . liftM Right
187+instance MonadIO m => MonadIO (PErrorT m) where
188+ liftIO = lift . liftIO
189+
190+type Parse = StateT (Map.Map String Value) (C.ResourceT IO)
191+
192+requireEvent :: Event -> C.Sink Event Parse ()
193+requireEvent e = do
194+ f <- CL.head
195+ if f == Just e
196+ then return ()
197+ else liftIO $ throwIO $ UnexpectedEvent f $ Just e
198+
199+parse :: C.Sink Event Parse Value
200+parse = do
201+ requireEvent EventStreamStart
202+ requireEvent EventDocumentStart
203+ res <- parseO
204+ requireEvent EventDocumentEnd
205+ requireEvent EventStreamEnd
206+ return res
207+
208+parseScalar :: ByteString -> Anchor -> Style -> Tag
209+ -> C.Sink Event Parse Text
210+parseScalar v a style tag = do
211+ let res = decodeUtf8With lenientDecode v
212+ case a of
213+ Nothing -> return res
214+ Just an -> do
215+ lift $ modify (Map.insert an $ textToValue style tag res)
216+ return res
217+
218+textToValue :: Style -> Tag -> Text -> Value
219+textToValue SingleQuoted _ t = String t
220+textToValue DoubleQuoted _ t = String t
221+textToValue _ StrTag t = String t
222+textToValue Folded _ t = String t
223+textToValue _ _ t
224+ | t `elem` ["null", "Null", "NULL", "~", ""] = Null
225+ | any (t `isLike`) ["y", "yes", "on", "true"] = Bool True
226+ | any (t `isLike`) ["n", "no", "off", "false"] = Bool False
227+#if MIN_VERSION_aeson(0, 7, 0)
228+ | Right (x, "") <- signed decimal t = Number $ fromIntegral (x :: Integer)
229+ | Right (x, "") <- double t = Number $ fromFloatDigits x
230+#else
231+ | Right (x, "") <- signed decimal t = Number $ I x
232+ | Right (x, "") <- double t = Number $ D x
233+#endif
234+ | otherwise = String t
235+ where x `isLike` ref = x `elem` [ref, T.toUpper ref, titleCased]
236+ where titleCased = toUpper (T.head ref) `T.cons` T.tail ref
237+
238+
239+parseO :: C.Sink Event Parse Value
240+parseO = do
241+ me <- CL.head
242+ case me of
243+ Just (EventScalar v tag style a) -> fmap (textToValue style tag) $ parseScalar v a style tag
244+ Just (EventSequenceStart a) -> parseS a id
245+ Just (EventMappingStart a) -> parseM a M.empty
246+ Just (EventAlias an) -> do
247+ m <- lift get
248+ case Map.lookup an m of
249+ Nothing -> liftIO $ throwIO $ UnknownAlias an
250+ Just v -> return v
251+ _ -> liftIO $ throwIO $ UnexpectedEvent me Nothing
252+
253+parseS :: Y.Anchor
254+ -> ([Value] -> [Value])
255+ -> C.Sink Event Parse Value
256+parseS a front = do
257+ me <- CL.peek
258+ case me of
259+ Just EventSequenceEnd -> do
260+ CL.drop 1
261+ let res = Array $ V.fromList $ front []
262+ case a of
263+ Nothing -> return res
264+ Just an -> do
265+ lift $ modify $ Map.insert an res
266+ return res
267+ _ -> do
268+ o <- parseO
269+ parseS a $ front . (:) o
270+
271+parseM :: Y.Anchor
272+ -> M.HashMap Text Value
273+ -> C.Sink Event Parse Value
274+parseM a front = do
275+ me <- CL.peek
276+ case me of
277+ Just EventMappingEnd -> do
278+ CL.drop 1
279+ let res = Object front
280+ case a of
281+ Nothing -> return res
282+ Just an -> do
283+ lift $ modify $ Map.insert an res
284+ return res
285+ _ -> do
286+ CL.drop 1
287+ s <- case me of
288+ Just (EventScalar v tag style a') -> parseScalar v a' style tag
289+ _ -> liftIO $ throwIO $ UnexpectedEvent me Nothing
290+ o <- parseO
291+
292+ let al = M.insert s o front
293+ al' = if s == pack "<<"
294+ then case o of
295+ Object l -> M.union front l
296+ Array l -> M.union front $ foldl merge' M.empty $ V.toList l
297+ _ -> al
298+ else al
299+ parseM a al'
300+ where merge' al (Object om) = M.union al om
301+ merge' al _ = al
302+
303+decode :: FromJSON a
304+ => ByteString
305+ -> Maybe a
306+decode bs = unsafePerformIO
307+ $ fmap (either (const Nothing) (either (const Nothing) Just))
308+ $ decodeHelper (Y.decode bs)
309+
310+decodeFile :: FromJSON a
311+ => FilePath
312+ -> IO (Maybe a)
313+decodeFile fp = decodeHelper (Y.decodeFile fp) >>= either throwIO (return . either (const Nothing) id)
314+
315+-- | A version of 'decodeFile' which should not throw runtime exceptions.
316+--
317+-- Since 0.8.4
318+decodeFileEither
319+ :: FromJSON a
320+ => FilePath
321+ -> IO (Either ParseException a)
322+decodeFileEither fp = do
323+ x <- try $ C.runResourceT $ flip evalStateT Map.empty $ Y.decodeFile fp C.$$ parse
324+ case x of
325+ Left e
326+ | Just pe <- fromException e -> return $ Left pe
327+ | Just ye <- fromException e -> return $ Left $ InvalidYaml $ Just (ye :: YamlException)
328+ | shouldBeCaught e -> return $ Left $ OtherParseException e
329+ | otherwise -> throwIO e
330+ Right y ->
331+ return $ case parseEither parseJSON y of
332+ Left s -> Left $ AesonException s
333+ Right v -> Right v
334+ where
335+ -- FIXME this function needs more thought
336+ shouldBeCaught e
337+ | Just (_ :: AsyncException) <- fromException e = False
338+ -- Would be nice... | Just (_ :: Timeout) <- fromException e = False
339+ | otherwise = True
340+
341+decodeEither :: FromJSON a => ByteString -> Either String a
342+decodeEither bs = unsafePerformIO
343+ $ fmap (either (Left . show) id)
344+ $ decodeHelper (Y.decode bs)
345+
346+-- | More helpful version of 'decodeEither' which returns the 'YamlException'.
347+--
348+-- Since 0.8.3
349+decodeEither' :: FromJSON a => ByteString -> Either ParseException a
350+decodeEither' = either Left (either (Left . AesonException) Right)
351+ . unsafePerformIO
352+ . decodeHelper
353+ . Y.decode
354+
355+decodeHelper :: FromJSON a
356+ => C.Source Parse Y.Event
357+ -> IO (Either ParseException (Either String a))
358+decodeHelper src = do
359+ x <- try $ C.runResourceT $ flip evalStateT Map.empty $ src C.$$ parse
360+ case x of
361+ Left e
362+ | Just pe <- fromException e -> return $ Left pe
363+ | Just ye <- fromException e -> return $ Left $ InvalidYaml $ Just (ye :: YamlException)
364+ | otherwise -> throwIO e
365+ Right y -> return $ Right $ parseEither parseJSON y
366+
367+array :: [Value] -> Value
368+array = Array . V.fromList
369+
370+parseMonad :: Monad m => (a -> Parser b) -> a -> m b
371+parseMonad p = either fail return . parseEither p
Data/Yaml/Builder.hsnew file+70
@@ -0,0 +1,70 @@
1+{-# LANGUAGE FlexibleInstances #-}
2+module Data.Yaml.Builder
3+ ( YamlBuilder (..)
4+ , ToYaml (..)
5+ , mapping
6+ , array
7+ , string
8+ , toByteString
9+ , writeYamlFile
10+ , (.=)
11+ ) where
12+
13+import Data.Conduit
14+import Data.ByteString (ByteString)
15+import qualified Data.ByteString.Lazy as L
16+import Text.Libyaml
17+import Data.Text (Text)
18+import Data.Text.Encoding (encodeUtf8)
19+import qualified Data.Conduit.List as CL
20+import System.IO.Unsafe (unsafePerformIO)
21+import Control.Arrow (second)
22+import qualified Data.ByteString.Char8 as S8
23+
24+(.=) :: ToYaml a => Text -> a -> (Text, YamlBuilder)
25+k .= v = (k, toYaml v)
26+
27+newtype YamlBuilder = YamlBuilder { unYamlBuilder :: [Event] -> [Event] }
28+
29+class ToYaml a where
30+ toYaml :: a -> YamlBuilder
31+instance ToYaml YamlBuilder where
32+ toYaml = id
33+instance ToYaml a => ToYaml [(Text, a)] where
34+ toYaml = mapping . map (second toYaml)
35+instance ToYaml a => ToYaml [a] where
36+ toYaml = array . map toYaml
37+instance ToYaml Text where
38+ toYaml = string
39+instance ToYaml Int where
40+ toYaml i = YamlBuilder (EventScalar (S8.pack $ show i) IntTag PlainNoTag Nothing:)
41+
42+mapping :: [(Text, YamlBuilder)] -> YamlBuilder
43+mapping pairs = YamlBuilder $ \rest ->
44+ EventMappingStart Nothing : foldr addPair (EventMappingEnd : rest) pairs
45+ where
46+ addPair (key, YamlBuilder value) after
47+ = EventScalar (encodeUtf8 key) StrTag PlainNoTag Nothing
48+ : value after
49+
50+array :: [YamlBuilder] -> YamlBuilder
51+array bs =
52+ YamlBuilder $ (EventSequenceStart Nothing:) . flip (foldr go) bs . (EventSequenceEnd:)
53+ where
54+ go (YamlBuilder b) rest = b rest
55+
56+string :: Text -> YamlBuilder
57+string t = YamlBuilder (EventScalar (encodeUtf8 t) StrTag PlainNoTag Nothing:)
58+
59+toEvents :: YamlBuilder -> [Event]
60+toEvents (YamlBuilder front) =
61+ EventStreamStart : EventDocumentStart : front [EventDocumentEnd, EventStreamEnd]
62+
63+toSource :: (Monad m, ToYaml a) => a -> Source m Event
64+toSource = mapM_ yield . toEvents . toYaml
65+
66+toByteString :: ToYaml a => a -> ByteString
67+toByteString yb = unsafePerformIO $ runResourceT $ toSource yb $$ encode
68+
69+writeYamlFile :: ToYaml a => FilePath -> a -> IO ()
70+writeYamlFile fp yb = runResourceT $ toSource yb $$ encodeFile fp
yaml/LICENSE → LICENSErenamed

The content is the same.

Makefilenew file+4
@@ -0,0 +1,4 @@
1+libhelper.so : helper.o
2+ gcc -shared -Wl,-soname,libhelper.so -o libhelper.so helper.o
3+helper.o : c/helper.c
4+ gcc -c -fPIC c/helper.c -o helper.o
READMEnew file+1
@@ -0,0 +1 @@
1+Support for serialising Haskell to and from Yaml.
README.mddeleted−23
@@ -1,23 +0,0 @@
1−# YAML Haskell Library
2−
3−[![Build Status](https://dev.azure.com/snoyberg/yaml/_apis/build/status/snoyberg.yaml?branchName=master)](https://dev.azure.com/snoyberg/yaml/_build/latest?definitionId=7&branchName=master)
4−
5−This project contains two haskell packages: `yaml` for higher-level parsing and writing of yaml documents, and `libyaml`
6−for lower-level event-based streaming.
7−
8−## `yaml` Package
9−
10−`yaml` provides a high-level interface based around the JSON datatypes provided by the `aeson` package. This allows
11−using JSON and YAML interchangeably in your code with the `aeson` typeclasses. See the
12−[yaml README](https://github.com/snoyberg/yaml/tree/master/yaml/README.md) for more details.
13−
14−## `libyaml` Package
15−
16−`libyaml` is a wrapper over the libyaml C library (and includes the source so no external library is needed). It is an
17−event-based streaming API. See the [libyaml README](https://github.com/snoyberg/yaml/tree/master/libyaml/README.md) for
18−more details.
19−
20−## License
21−
22−This project is licensed with the BSD 3-Clause license. Copies of the license can be found in both the `yaml` and
23−`libyaml` subdirectories
yaml/Setup.lhs → Setup.lhsrenamed

The content is the same.

libyaml/src/Text/Libyaml.hs → Text/Libyaml.hsrenamed+162−369
@@ -4,48 +4,37 @@
4{-# LANGUAGE FlexibleContexts #-}
4{-# LANGUAGE FlexibleContexts #-}
5{-# LANGUAGE FlexibleInstances #-}
5{-# LANGUAGE FlexibleInstances #-}
6{-# LANGUAGE MultiParamTypeClasses #-}
6{-# LANGUAGE MultiParamTypeClasses #-}
7+{-# LANGUAGE PackageImports #-}
8+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
7{-# LANGUAGE RankNTypes #-}
9{-# LANGUAGE RankNTypes #-}
8{-# LANGUAGE CPP #-}
10{-# LANGUAGE CPP #-}
9{-# LANGUAGE TypeFamilies #-}
11{-# LANGUAGE TypeFamilies #-}
10−{-# LANGUAGE ScopedTypeVariables #-}
11
12
12-- | Low-level, streaming YAML interface. For a higher-level interface, see
13-- | Low-level, streaming YAML interface. For a higher-level interface, see
13-- "Data.Yaml".
14-- "Data.Yaml".
14module Text.Libyaml
15module Text.Libyaml
15 ( -- * The event stream
16 ( -- * The event stream
16− MarkedEvent(..)
17− , Event (..)
17+ Event (..)
18 , Style (..)
18 , Style (..)
19− , SequenceStyle (..)
20− , MappingStyle (..)
21 , Tag (..)
19 , Tag (..)
22 , AnchorName
20 , AnchorName
23 , Anchor
21 , Anchor
24 -- * Encoding and decoding
22 -- * Encoding and decoding
25 , encode
23 , encode
26− , encodeWith
27 , decode
24 , decode
28− , decodeMarked
29 , encodeFile
25 , encodeFile
30 , decodeFile
26 , decodeFile
31− , decodeFileMarked
32− , encodeFileWith
33− , FormatOptions
34− , defaultFormatOptions
35− , setWidth
36− , setTagRendering
37− , renderScalarTags
38− , renderAllTags
39− , renderNoTags
40− , renderUriTags
41 -- * Error handling
27 -- * Error handling
42 , YamlException (..)
28 , YamlException (..)
43 , YamlMark (..)
29 , YamlMark (..)
44 ) where
30 ) where
45
31
46−import Prelude hiding (pi)
32+import qualified Data.ByteString.Internal as B
47−
33+import qualified Data.ByteString.Char8 as B8
48−import Data.Bits ((.|.))
34+import qualified Data.ByteString
35+import qualified Data.ByteString.Unsafe as BU
36+import Data.ByteString (ByteString, packCStringLen)
37+import Control.Monad
49import Foreign.C
38import Foreign.C
50import Foreign.Ptr
39import Foreign.Ptr
51import Foreign.ForeignPtr
40import Foreign.ForeignPtr
@@ -53,27 +42,15 @@ import Foreign.ForeignPtr
53import Foreign.ForeignPtr.Unsafe
42import Foreign.ForeignPtr.Unsafe
54#endif
43#endif
55import Foreign.Marshal.Alloc
44import Foreign.Marshal.Alloc
56−import qualified System.Posix.Internals as Posix
45+import Data.Data
57
46
58−#if !MIN_VERSION_base(4,8,0)
59−import Control.Applicative
60−#endif
61−import Control.Exception (mask_, throwIO, Exception, finally)
62−import Control.Monad
63import Control.Monad.IO.Class
47import Control.Monad.IO.Class
48+
49+import Control.Exception (throwIO, Exception, finally)
50+import Control.Applicative
64import Control.Monad.Trans.Resource
51import Control.Monad.Trans.Resource
65import Data.Conduit hiding (Source, Sink, Conduit)
52import Data.Conduit hiding (Source, Sink, Conduit)
66−import Data.Data
67−
68−import Data.ByteString (ByteString, packCString, packCStringLen)
69−import qualified Data.ByteString.Char8 as B8
70−import qualified Data.ByteString.Internal as B
71−import qualified Data.ByteString.Unsafe as BU
72−
73−#if WINDOWS && __GLASGOW_HASKELL__ >= 806
74−import System.Directory (removeFile)
75−import qualified Control.Exception
53+import Control.Exception (mask_)
76−#endif
77
54
78data Event =
55data Event =
79 EventStreamStart
56 EventStreamStart
@@ -82,23 +59,12 @@ data Event =
82 | EventDocumentEnd
59 | EventDocumentEnd
83 | EventAlias !AnchorName
60 | EventAlias !AnchorName
84 | EventScalar !ByteString !Tag !Style !Anchor
61 | EventScalar !ByteString !Tag !Style !Anchor
85− | EventSequenceStart !Tag !SequenceStyle !Anchor
62+ | EventSequenceStart !Anchor
86 | EventSequenceEnd
63 | EventSequenceEnd
87− | EventMappingStart !Tag !MappingStyle !Anchor
64+ | EventMappingStart !Anchor
88 | EventMappingEnd
65 | EventMappingEnd
89 deriving (Show, Eq)
66 deriving (Show, Eq)
90
67
91−-- | Event with start and end marks.
92−--
93−-- @since 0.10.4.0
94−data MarkedEvent = MarkedEvent
95− { yamlEvent :: Event
96− , yamlStartMark :: YamlMark
97− , yamlEndMark :: YamlMark
98− }
99−
100−-- | Style for scalars - e.g. quoted / folded
101−--
102data Style = Any
68data Style = Any
103 | Plain
69 | Plain
104 | SingleQuoted
70 | SingleQuoted
@@ -108,18 +74,6 @@ data Style = Any
108 | PlainNoTag
74 | PlainNoTag
109 deriving (Show, Read, Eq, Enum, Bounded, Ord, Data, Typeable)
75 deriving (Show, Read, Eq, Enum, Bounded, Ord, Data, Typeable)
110
76
111−-- | Style for sequences - e.g. block or flow
112−--
113−-- @since 0.9.0
114−data SequenceStyle = AnySequence | BlockSequence | FlowSequence
115− deriving (Show, Eq, Enum, Bounded, Ord, Data, Typeable)
116−
117−-- | Style for mappings - e.g. block or flow
118−--
119−-- @since 0.9.0
120−data MappingStyle = AnyMapping | BlockMapping | FlowMapping
121− deriving (Show, Eq, Enum, Bounded, Ord, Data, Typeable)
122−
123data Tag = StrTag
77data Tag = StrTag
124 | FloatTag
78 | FloatTag
125 | NullTag
79 | NullTag
@@ -132,11 +86,6 @@ data Tag = StrTag
132 | NoTag
86 | NoTag
133 deriving (Show, Eq, Read, Data, Typeable)
87 deriving (Show, Eq, Read, Data, Typeable)
134
88
135−tagSuppressed :: Tag -> Bool
136−tagSuppressed (NoTag) = True
137−tagSuppressed (UriTag "") = True
138−tagSuppressed _ = False
139−
140type AnchorName = String
89type AnchorName = String
141type Anchor = Maybe AnchorName
90type Anchor = Maybe AnchorName
142
91
@@ -194,41 +143,20 @@ foreign import ccall unsafe "yaml_parser_set_input_file"
194 -> File
143 -> File
195 -> IO ()
144 -> IO ()
196
145
197−data MarkRawStruct
198−type MarkRaw = Ptr MarkRawStruct
199−
200−foreign import ccall unsafe "get_mark_index"
201− c_get_mark_index :: MarkRaw -> IO CULong
202−
203−foreign import ccall unsafe "get_mark_line"
204− c_get_mark_line :: MarkRaw -> IO CULong
205−
206−foreign import ccall unsafe "get_mark_column"
207− c_get_mark_column :: MarkRaw -> IO CULong
208−
209−getMark :: MarkRaw -> IO YamlMark
210−getMark m = YamlMark
211− <$> (fromIntegral <$> c_get_mark_index m)
212− <*> (fromIntegral <$> c_get_mark_line m)
213− <*> (fromIntegral <$> c_get_mark_column m)
214−
215data FileStruct
146data FileStruct
216type File = Ptr FileStruct
147type File = Ptr FileStruct
217
148
218−#ifdef WINDOWS
219−foreign import ccall unsafe "_fdopen"
149+foreign import ccall unsafe "fopen"
220−#else
150+ c_fopen :: Ptr CChar
221−foreign import ccall unsafe "fdopen"
222−#endif
223− c_fdopen :: CInt
224− -> Ptr CChar
151+ -> Ptr CChar
225− -> IO File
152+ -> IO File
153+
226foreign import ccall unsafe "fclose"
154foreign import ccall unsafe "fclose"
227 c_fclose :: File
155 c_fclose :: File
228− -> IO CInt
156+ -> IO ()
229
157
230foreign import ccall unsafe "fclose_helper"
158foreign import ccall unsafe "fclose_helper"
231− c_fclose_helper :: File -> IO CInt
159+ c_fclose_helper :: File -> IO ()
232
160
233foreign import ccall unsafe "yaml_parser_parse"
161foreign import ccall unsafe "yaml_parser_parse"
234 c_yaml_parser_parse :: Parser -> EventRaw -> IO CInt
162 c_yaml_parser_parse :: Parser -> EventRaw -> IO CInt
@@ -242,8 +170,14 @@ foreign import ccall "get_parser_error_problem"
242foreign import ccall "get_parser_error_context"
170foreign import ccall "get_parser_error_context"
243 c_get_parser_error_context :: Parser -> IO (Ptr CUChar)
171 c_get_parser_error_context :: Parser -> IO (Ptr CUChar)
244
172
245−foreign import ccall unsafe "get_parser_error_mark"
173+foreign import ccall unsafe "get_parser_error_index"
246− c_get_parser_error_mark :: Parser -> IO MarkRaw
174+ c_get_parser_error_index :: Parser -> IO CULong
175+
176+foreign import ccall unsafe "get_parser_error_line"
177+ c_get_parser_error_line :: Parser -> IO CULong
178+
179+foreign import ccall unsafe "get_parser_error_column"
180+ c_get_parser_error_column :: Parser -> IO CULong
247
181
248makeString :: MonadIO m => (a -> m (Ptr CUChar)) -> a -> m String
182makeString :: MonadIO m => (a -> m (Ptr CUChar)) -> a -> m String
249makeString f a = do
183makeString f a = do
@@ -268,12 +202,6 @@ data EventType = YamlNoEvent
268foreign import ccall unsafe "get_event_type"
202foreign import ccall unsafe "get_event_type"
269 c_get_event_type :: EventRaw -> IO CInt
203 c_get_event_type :: EventRaw -> IO CInt
270
204
271−foreign import ccall unsafe "get_start_mark"
272− c_get_start_mark :: EventRaw -> IO MarkRaw
273−
274−foreign import ccall unsafe "get_end_mark"
275− c_get_end_mark :: EventRaw -> IO MarkRaw
276−
277foreign import ccall unsafe "get_scalar_value"
205foreign import ccall unsafe "get_scalar_value"
278 c_get_scalar_value :: EventRaw -> IO (Ptr CUChar)
206 c_get_scalar_value :: EventRaw -> IO (Ptr CUChar)
279
207
@@ -283,6 +211,9 @@ foreign import ccall unsafe "get_scalar_length"
283foreign import ccall unsafe "get_scalar_tag"
211foreign import ccall unsafe "get_scalar_tag"
284 c_get_scalar_tag :: EventRaw -> IO (Ptr CUChar)
212 c_get_scalar_tag :: EventRaw -> IO (Ptr CUChar)
285
213
214+foreign import ccall unsafe "get_scalar_tag_len"
215+ c_get_scalar_tag_len :: EventRaw -> IO CULong
216+
286foreign import ccall unsafe "get_scalar_style"
217foreign import ccall unsafe "get_scalar_style"
287 c_get_scalar_style :: EventRaw -> IO CInt
218 c_get_scalar_style :: EventRaw -> IO CInt
288
219
@@ -292,43 +223,16 @@ foreign import ccall unsafe "get_scalar_anchor"
292foreign import ccall unsafe "get_sequence_start_anchor"
223foreign import ccall unsafe "get_sequence_start_anchor"
293 c_get_sequence_start_anchor :: EventRaw -> IO CString
224 c_get_sequence_start_anchor :: EventRaw -> IO CString
294
225
295−foreign import ccall unsafe "get_sequence_start_style"
296− c_get_sequence_start_style :: EventRaw -> IO CInt
297−
298−foreign import ccall unsafe "get_sequence_start_tag"
299− c_get_sequence_start_tag :: EventRaw -> IO (Ptr CUChar)
300−
301foreign import ccall unsafe "get_mapping_start_anchor"
226foreign import ccall unsafe "get_mapping_start_anchor"
302 c_get_mapping_start_anchor :: EventRaw -> IO CString
227 c_get_mapping_start_anchor :: EventRaw -> IO CString
303
228
304−foreign import ccall unsafe "get_mapping_start_style"
305− c_get_mapping_start_style :: EventRaw -> IO CInt
306−
307−foreign import ccall unsafe "get_mapping_start_tag"
308− c_get_mapping_start_tag :: EventRaw -> IO (Ptr CUChar)
309−
310foreign import ccall unsafe "get_alias_anchor"
229foreign import ccall unsafe "get_alias_anchor"
311 c_get_alias_anchor :: EventRaw -> IO CString
230 c_get_alias_anchor :: EventRaw -> IO CString
312
231
313−readAnchor :: (EventRaw -> IO CString) -> EventRaw -> IO Anchor
314−readAnchor getAnchor er = do
315− yanchor <- getAnchor er
316− if yanchor == nullPtr
317− then return Nothing
318− else Just <$> peekCString yanchor
319−
320−readStyle :: (Enum a) => (EventRaw -> IO CInt) -> EventRaw -> IO a
321−readStyle getStyle er = toEnum . fromEnum <$> getStyle er
322−
323−readTag :: (EventRaw -> IO (Ptr CUChar)) -> EventRaw -> IO Tag
324−readTag getTag er = bsToTag <$> (getTag er >>= packCString . castPtr)
325−
326−getEvent :: EventRaw -> IO (Maybe MarkedEvent)
232+getEvent :: EventRaw -> IO (Maybe Event)
327getEvent er = do
233getEvent er = do
328 et <- c_get_event_type er
234 et <- c_get_event_type er
329− startMark <- c_get_start_mark er >>= getMark
330− endMark <- c_get_end_mark er >>= getMark
331− event <- case toEnum $ fromEnum et of
235+ case toEnum $ fromEnum et of
332 YamlNoEvent -> return Nothing
236 YamlNoEvent -> return Nothing
333 YamlStreamStartEvent -> return $ Just EventStreamStart
237 YamlStreamStartEvent -> return $ Just EventStreamStart
334 YamlStreamEndEvent -> return $ Just EventStreamEnd
238 YamlStreamEndEvent -> return $ Just EventStreamEnd
@@ -343,26 +247,38 @@ getEvent er = do
343 YamlScalarEvent -> do
247 YamlScalarEvent -> do
344 yvalue <- c_get_scalar_value er
248 yvalue <- c_get_scalar_value er
345 ylen <- c_get_scalar_length er
249 ylen <- c_get_scalar_length er
250+ ytag <- c_get_scalar_tag er
251+ ytag_len <- c_get_scalar_tag_len er
252+ ystyle <- c_get_scalar_style er
253+ let ytag_len' = fromEnum ytag_len
346 let yvalue' = castPtr yvalue
254 let yvalue' = castPtr yvalue
255+ let ytag' = castPtr ytag
347 let ylen' = fromEnum ylen
256 let ylen' = fromEnum ylen
348 bs <- packCStringLen (yvalue', ylen')
257 bs <- packCStringLen (yvalue', ylen')
349− tag <- readTag c_get_scalar_tag er
258+ tagbs <-
350− style <- readStyle c_get_scalar_style er
259+ if ytag_len' == 0
260+ then return Data.ByteString.empty
261+ else packCStringLen (ytag', ytag_len')
262+ let style = toEnum $ fromEnum ystyle
351− anchor <- readAnchor c_get_scalar_anchor er
263+ yanchor <- c_get_scalar_anchor er
264+ anchor <- if yanchor == nullPtr
265+ then return Nothing
266+ else fmap Just $ peekCString yanchor
352− return $ Just $ EventScalar bs tag style anchor
267+ return $ Just $ EventScalar bs (bsToTag tagbs) style anchor
353 YamlSequenceStartEvent -> do
268 YamlSequenceStartEvent -> do
354− tag <- readTag c_get_sequence_start_tag er
355− style <- readStyle c_get_sequence_start_style er
356− anchor <- readAnchor c_get_sequence_start_anchor er
269+ yanchor <- c_get_sequence_start_anchor er
270+ anchor <- if yanchor == nullPtr
271+ then return Nothing
272+ else fmap Just $ peekCString yanchor
357− return $ Just $ EventSequenceStart tag style anchor
273+ return $ Just $ EventSequenceStart anchor
358 YamlSequenceEndEvent -> return $ Just EventSequenceEnd
274 YamlSequenceEndEvent -> return $ Just EventSequenceEnd
359 YamlMappingStartEvent -> do
275 YamlMappingStartEvent -> do
360− tag <- readTag c_get_mapping_start_tag er
361− style <- readStyle c_get_mapping_start_style er
362− anchor <- readAnchor c_get_mapping_start_anchor er
276+ yanchor <- c_get_mapping_start_anchor er
277+ anchor <- if yanchor == nullPtr
278+ then return Nothing
279+ else fmap Just $ peekCString yanchor
363− return $ Just $ EventMappingStart tag style anchor
280+ return $ Just $ EventMappingStart anchor
364 YamlMappingEndEvent -> return $ Just EventMappingEnd
281 YamlMappingEndEvent -> return $ Just EventMappingEnd
365− return $ (\e -> MarkedEvent e startMark endMark) <$> event
366
282
367-- Emitter
283-- Emitter
368
284
@@ -394,17 +310,9 @@ foreign import ccall unsafe "get_buffer_used"
394foreign import ccall unsafe "my_emitter_set_output"
310foreign import ccall unsafe "my_emitter_set_output"
395 c_my_emitter_set_output :: Emitter -> Buffer -> IO ()
311 c_my_emitter_set_output :: Emitter -> Buffer -> IO ()
396
312
397−#ifndef __NO_UNICODE__
398−foreign import ccall unsafe "yaml_emitter_set_unicode"
399− c_yaml_emitter_set_unicode :: Emitter -> CInt -> IO ()
400−#endif
401−
402foreign import ccall unsafe "yaml_emitter_set_output_file"
313foreign import ccall unsafe "yaml_emitter_set_output_file"
403 c_yaml_emitter_set_output_file :: Emitter -> File -> IO ()
314 c_yaml_emitter_set_output_file :: Emitter -> File -> IO ()
404
315
405−foreign import ccall unsafe "yaml_emitter_set_width"
406− c_yaml_emitter_set_width :: Emitter -> CInt -> IO ()
407−
408foreign import ccall unsafe "yaml_emitter_emit"
316foreign import ccall unsafe "yaml_emitter_emit"
409 c_yaml_emitter_emit :: Emitter -> EventRaw -> IO CInt
317 c_yaml_emitter_emit :: Emitter -> EventRaw -> IO CInt
410
318
@@ -462,8 +370,8 @@ foreign import ccall unsafe "yaml_alias_event_initialize"
462 -> Ptr CUChar
370 -> Ptr CUChar
463 -> IO CInt
371 -> IO CInt
464
372
465−toEventRaw :: FormatOptions -> Event -> (EventRaw -> IO a) -> IO a
373+toEventRaw :: Event -> (EventRaw -> IO a) -> IO a
466−toEventRaw opts e f = allocaBytes eventSize $ \er -> do
374+toEventRaw e f = allocaBytes eventSize $ \er -> do
467 ret <- case e of
375 ret <- case e of
468 EventStreamStart ->
376 EventStreamStart ->
469 c_yaml_stream_start_event_initialize
377 c_yaml_stream_start_event_initialize
@@ -481,13 +389,13 @@ toEventRaw opts e f = allocaBytes eventSize $ \er -> do
481 len' = fromIntegral len :: CInt
389 len' = fromIntegral len :: CInt
482 let thetag' = tagToString thetag
390 let thetag' = tagToString thetag
483 withCString thetag' $ \tag' -> do
391 withCString thetag' $ \tag' -> do
484− let pi0 = tagsImplicit e
485− (pi, style) =
392+ let (pi, style) =
486− case style0 of
393+ case style0 of
487− PlainNoTag -> (1, Plain)
394+ PlainNoTag -> (1, Plain)
488− x -> (pi0, x)
395+ x -> (0, x)
489 style' = toEnum $ fromEnum style
396 style' = toEnum $ fromEnum style
490 tagP = castPtr tag'
397 tagP = castPtr tag'
398+ qi = if null thetag' then 1 else 0
491 case anchor of
399 case anchor of
492 Nothing ->
400 Nothing ->
493 c_yaml_scalar_event_initialize
401 c_yaml_scalar_event_initialize
@@ -497,7 +405,7 @@ toEventRaw opts e f = allocaBytes eventSize $ \er -> do
497 value' -- value
405 value' -- value
498 len' -- length
406 len' -- length
499 pi -- plain_implicit
407 pi -- plain_implicit
500− pi -- quoted_implicit
408+ qi -- quoted_implicit
501 style' -- style
409 style' -- style
502 Just anchor' ->
410 Just anchor' ->
503 withCString anchor' $ \anchorP' -> do
411 withCString anchor' $ \anchorP' -> do
@@ -509,50 +417,42 @@ toEventRaw opts e f = allocaBytes eventSize $ \er -> do
509 value' -- value
417 value' -- value
510 len' -- length
418 len' -- length
511 0 -- plain_implicit
419 0 -- plain_implicit
512− pi -- quoted_implicit
420+ qi -- quoted_implicit
513 style' -- style
421 style' -- style
514− EventSequenceStart tag style Nothing ->
422+ EventSequenceStart Nothing ->
515− withCString (tagToString tag) $ \tag' -> do
423+ c_yaml_sequence_start_event_initialize
424+ er
425+ nullPtr
426+ nullPtr
427+ 1
428+ 0 -- YAML_ANY_SEQUENCE_STYLE
429+ EventSequenceStart (Just anchor) ->
430+ withCString anchor $ \anchor' -> do
516− let tagP = castPtr tag'
431+ let anchorP = castPtr anchor'
517 c_yaml_sequence_start_event_initialize
432 c_yaml_sequence_start_event_initialize
518− er
433+ er
434+ anchorP
519− nullPtr
435+ nullPtr
520− tagP
436+ 1
521− (tagsImplicit e)
437+ 0 -- YAML_ANY_SEQUENCE_STYLE
522− (toEnum $ fromEnum style)
523− EventSequenceStart tag style (Just anchor) ->
524− withCString (tagToString tag) $ \tag' -> do
525− let tagP = castPtr tag'
526− withCString anchor $ \anchor' -> do
527− let anchorP = castPtr anchor'
528− c_yaml_sequence_start_event_initialize
529− er
530− anchorP
531− tagP
532− (tagsImplicit e)
533− (toEnum $ fromEnum style)
534 EventSequenceEnd ->
438 EventSequenceEnd ->
535 c_yaml_sequence_end_event_initialize er
439 c_yaml_sequence_end_event_initialize er
536− EventMappingStart tag style Nothing ->
440+ EventMappingStart Nothing ->
537− withCString (tagToString tag) $ \tag' -> do
441+ c_yaml_mapping_start_event_initialize
442+ er
443+ nullPtr
444+ nullPtr
445+ 1
446+ 0 -- YAML_ANY_SEQUENCE_STYLE
447+ EventMappingStart (Just anchor) ->
448+ withCString anchor $ \anchor' -> do
538− let tagP = castPtr tag'
449+ let anchorP = castPtr anchor'
539 c_yaml_mapping_start_event_initialize
450 c_yaml_mapping_start_event_initialize
540 er
451 er
452+ anchorP
541 nullPtr
453 nullPtr
542− tagP
454+ 1
543− (tagsImplicit e)
455+ 0 -- YAML_ANY_SEQUENCE_STYLE
544− (toEnum $ fromEnum style)
545− EventMappingStart tag style (Just anchor) ->
546− withCString (tagToString tag) $ \tag' -> do
547− withCString anchor $ \anchor' -> do
548− let tagP = castPtr tag'
549− let anchorP = castPtr anchor'
550− c_yaml_mapping_start_event_initialize
551− er
552− anchorP
553− tagP
554− (tagsImplicit e)
555− (toEnum $ fromEnum style)
556 EventMappingEnd ->
456 EventMappingEnd ->
557 c_yaml_mapping_end_event_initialize er
457 c_yaml_mapping_end_event_initialize er
558 EventAlias anchor ->
458 EventAlias anchor ->
@@ -563,29 +463,19 @@ toEventRaw opts e f = allocaBytes eventSize $ \er -> do
563 anchorP
463 anchorP
564 unless (ret == 1) $ throwIO $ ToEventRawException ret
464 unless (ret == 1) $ throwIO $ ToEventRawException ret
565 f er
465 f er
566− where
567− tagsImplicit (EventScalar _ t _ _) | tagSuppressed t = 1
568− tagsImplicit (EventMappingStart t _ _) | tagSuppressed t = 1
569− tagsImplicit (EventSequenceStart t _ _) | tagSuppressed t = 1
570− tagsImplicit evt = toImplicitParam $ formatOptionsRenderTags opts evt
571
466
572newtype ToEventRawException = ToEventRawException CInt
467newtype ToEventRawException = ToEventRawException CInt
573 deriving (Show, Typeable)
468 deriving (Show, Typeable)
574instance Exception ToEventRawException
469instance Exception ToEventRawException
575
470
576−-- | Create a conduit that yields events from a bytestring.
577−decode :: MonadResource m => B.ByteString -> ConduitM i Event m ()
471+decode :: MonadResource m => B.ByteString
578−decode = mapOutput yamlEvent . decodeMarked
472+#if MIN_VERSION_conduit(1, 0, 0)
579−
473+ -> Producer m Event
580−-- | Create a conduit that yields marked events from a bytestring.
474+#else
581−--
475+ -> GSource m Event
582−-- This conduit will yield identical events to that of "decode", but also
476+#endif
583−-- includes start and end marks for each event.
584−--
585−-- @since 0.10.4.0
586−decodeMarked :: MonadResource m => B.ByteString -> ConduitM i MarkedEvent m ()
587−decodeMarked bs | B8.null bs = return ()
477+decode bs | B8.null bs = return ()
588−decodeMarked bs =
478+decode bs =
589 bracketP alloc cleanup (runParser . fst)
479 bracketP alloc cleanup (runParser . fst)
590 where
480 where
591 alloc = mask_ $ do
481 alloc = mask_ $ do
@@ -607,36 +497,13 @@ decodeMarked bs =
607 c_yaml_parser_delete ptr
497 c_yaml_parser_delete ptr
608 free ptr
498 free ptr
609
499
610−-- XXX copied from GHC.IO.FD
500+decodeFile :: MonadResource m => FilePath
611−std_flags, read_flags, output_flags, write_flags :: CInt
501+#if MIN_VERSION_conduit(1, 0, 0)
612−std_flags = Posix.o_NOCTTY
502+ -> Producer m Event
613−output_flags = std_flags .|. Posix.o_CREAT .|. Posix.o_TRUNC
503+#else
614−read_flags = std_flags .|. Posix.o_RDONLY
504+ -> GSource m Event
615−write_flags = output_flags .|. Posix.o_WRONLY
505+#endif
616−
506+decodeFile file =
617−-- | Open a C FILE* from a file path, using internal GHC API to work correctly
618−-- on all platforms, even on non-ASCII filenames. The opening mode must be
619−-- indicated via both 'rawOpenFlags' and 'openMode'.
620−openFile :: FilePath -> CInt -> String -> IO File
621−openFile file rawOpenFlags openMode = do
622− fd <- liftIO $ Posix.withFilePath file $ \file' ->
623− Posix.c_open file' rawOpenFlags 0o666
624− if fd /= (-1)
625− then withCString openMode $ \openMode' -> c_fdopen fd openMode'
626− else return nullPtr
627−
628−-- | Creata a conduit that yields events from a file.
629−decodeFile :: MonadResource m => FilePath -> ConduitM i Event m ()
630−decodeFile = mapOutput yamlEvent . decodeFileMarked
631−
632−-- | Create a conduit that yields marked events from a file.
633−--
634−-- This conduit will yield identical events to that of "decodeFile", but also
635−-- includes start and end marks for each event.
636−--
637−-- @since 0.10.4.0
638−decodeFileMarked :: MonadResource m => FilePath -> ConduitM i MarkedEvent m ()
639−decodeFileMarked file =
640 bracketP alloc cleanup (runParser . fst)
507 bracketP alloc cleanup (runParser . fst)
641 where
508 where
642 alloc = mask_ $ do
509 alloc = mask_ $ do
@@ -648,9 +515,12 @@ decodeFileMarked file =
648 free ptr
515 free ptr
649 throwIO $ YamlException "Yaml out of memory"
516 throwIO $ YamlException "Yaml out of memory"
650 else do
517 else do
651− file' <- openFile file read_flags "r"
518+ file' <- liftIO
519+ $ withCString file $ \file' -> withCString "r" $ \r' ->
520+ c_fopen file' r'
652 if file' == nullPtr
521 if file' == nullPtr
653 then do
522 then do
523+ c_fclose_helper file'
654 c_yaml_parser_delete ptr
524 c_yaml_parser_delete ptr
655 free ptr
525 free ptr
656 throwIO $ YamlException
526 throwIO $ YamlException
@@ -659,12 +529,16 @@ decodeFileMarked file =
659 c_yaml_parser_set_input_file ptr file'
529 c_yaml_parser_set_input_file ptr file'
660 return (ptr, file')
530 return (ptr, file')
661 cleanup (ptr, file') = do
531 cleanup (ptr, file') = do
662− res <- c_fclose_helper file'
532+ c_fclose_helper file'
663− when (res /= 0) $ throwIO $ YamlException $ "could not close file: " ++ file
664 c_yaml_parser_delete ptr
533 c_yaml_parser_delete ptr
665 free ptr
534 free ptr
666
535
667−runParser :: MonadResource m => Parser -> ConduitM i MarkedEvent m ()
536+runParser :: MonadResource m => Parser
537+#if MIN_VERSION_conduit(1, 0, 0)
538+ -> Producer m Event
539+#else
540+ -> GSource m Event
541+#endif
668runParser parser = do
542runParser parser = do
669 e <- liftIO $ parserParseOne' parser
543 e <- liftIO $ parserParseOne' parser
670 case e of
544 case e of
@@ -673,7 +547,7 @@ runParser parser = do
673 Right (Just ev) -> yield ev >> runParser parser
547 Right (Just ev) -> yield ev >> runParser parser
674
548
675parserParseOne' :: Parser
549parserParseOne' :: Parser
676− -> IO (Either YamlException (Maybe MarkedEvent))
550+ -> IO (Either YamlException (Maybe Event))
677parserParseOne' parser = allocaBytes eventSize $ \er -> do
551parserParseOne' parser = allocaBytes eventSize $ \er -> do
678 res <- liftIO $ c_yaml_parser_parse parser er
552 res <- liftIO $ c_yaml_parser_parse parser er
679 flip finally (c_yaml_event_delete er) $
553 flip finally (c_yaml_event_delete er) $
@@ -681,92 +555,21 @@ parserParseOne' parser = allocaBytes eventSize $ \er -> do
681 then do
555 then do
682 problem <- makeString c_get_parser_error_problem parser
556 problem <- makeString c_get_parser_error_problem parser
683 context <- makeString c_get_parser_error_context parser
557 context <- makeString c_get_parser_error_context parser
684− problemMark <- c_get_parser_error_mark parser >>= getMark
558+ index <- c_get_parser_error_index parser
559+ line <- c_get_parser_error_line parser
560+ column <- c_get_parser_error_column parser
561+ let problemMark = YamlMark (fromIntegral index) (fromIntegral line) (fromIntegral column)
685 return $ Left $ YamlParseException problem context problemMark
562 return $ Left $ YamlParseException problem context problemMark
686 else Right <$> getEvent er
563 else Right <$> getEvent er
687
564
688−-- | Whether a tag should be rendered explicitly in the output or left
565+encode :: MonadResource m
689−-- implicit.
566+#if MIN_VERSION_conduit(1, 0, 0)
690−--
691−-- @since 0.1.1.0
692−data TagRender = Explicit | Implicit
693− deriving (Enum)
694−
695−toImplicitParam :: TagRender -> CInt
696−toImplicitParam Explicit = 0
697−toImplicitParam Implicit = 1
698−
699−-- | A value for 'formatOptionsRenderTags' that renders no
700−-- collection tags but all scalar tags (unless suppressed with styles
701−-- 'NoTag or 'PlainNoTag').
702−--
703−-- @since 0.1.1.0
704−renderScalarTags :: Event -> TagRender
705−renderScalarTags (EventScalar _ _ _ _) = Explicit
706−renderScalarTags (EventSequenceStart _ _ _) = Implicit
707−renderScalarTags (EventMappingStart _ _ _) = Implicit
708−renderScalarTags _ = Implicit
709−
710−-- | A value for 'formatOptionsRenderTags' that renders all
711−-- tags (except 'NoTag' tag and 'PlainNoTag' style).
712−--
713−-- @since 0.1.1.0
714−renderAllTags :: Event -> TagRender
715−renderAllTags _ = Explicit
716−
717−-- | A value for 'formatOptionsRenderTags' that renders no
718−-- tags.
719−--
720−-- @since 0.1.1.0
721−renderNoTags :: Event -> TagRender
722−renderNoTags _ = Implicit
723−
724−-- | A value for 'formatOptionsRenderCollectionTags' that renders tags
725−-- which are instances of 'UriTag'
726−--
727−-- @since 0.1.1.0
728−renderUriTags :: Event -> TagRender
729−renderUriTags (EventScalar _ UriTag{} _ _) = Explicit
730−renderUriTags (EventSequenceStart UriTag{} _ _) = Explicit
731−renderUriTags (EventMappingStart UriTag{} _ _) = Explicit
732−renderUriTags _ = Implicit
733−
734−-- | Contains options relating to the formatting (indendation, width) of the YAML output.
735−--
736−-- @since 0.10.2.0
737−data FormatOptions = FormatOptions
738− { formatOptionsWidth :: Maybe Int
739− , formatOptionsRenderTags :: Event -> TagRender
740− }
741−
742−-- |
743−-- @since 0.10.2.0
744−defaultFormatOptions :: FormatOptions
745−defaultFormatOptions = FormatOptions
746− { formatOptionsWidth = Just 80 -- by default the width is set to 0 in the C code, which gets turned into 80 in yaml_emitter_emit_stream_start
747− , formatOptionsRenderTags = renderScalarTags
748− }
749−
750−-- | Set the maximum number of columns in the YAML output, or 'Nothing' for infinite. By default, the limit is 80 characters.
751−--
752−-- @since 0.10.2.0
753−setWidth :: Maybe Int -> FormatOptions -> FormatOptions
754−setWidth w opts = opts { formatOptionsWidth = w }
755−
756−-- | Control when and whether tags are rendered to output.
757−--
758−-- @since 0.1.1.0
759−setTagRendering :: (Event -> TagRender) -> FormatOptions -> FormatOptions
760−setTagRendering f opts = opts { formatOptionsRenderTags = f }
761−
762−encode :: MonadResource m => ConduitM Event o m ByteString
567+ => Consumer Event m ByteString
763−encode = encodeWith defaultFormatOptions
568+#else
764−
569+ => GSink Event m ByteString
765−-- |
570+#endif
766−-- @since 0.10.2.0
571+encode =
767−encodeWith :: MonadResource m => FormatOptions -> ConduitM Event o m ByteString
768−encodeWith opts =
769− runEmitter opts alloc close
572+ runEmitter alloc close
770 where
573 where
771 alloc emitter = do
574 alloc emitter = do
772 fbuf <- mallocForeignPtrBytes bufferSize
575 fbuf <- mallocForeignPtrBytes bufferSize
@@ -776,59 +579,45 @@ encodeWith opts =
776 close _ fbuf = withForeignPtr fbuf $ \b -> do
579 close _ fbuf = withForeignPtr fbuf $ \b -> do
777 ptr' <- c_get_buffer_buff b
580 ptr' <- c_get_buffer_buff b
778 len <- c_get_buffer_used b
581 len <- c_get_buffer_used b
779− fptr <- newForeignPtr finalizerFree $ castPtr ptr'
582+ fptr <- newForeignPtr_ $ castPtr ptr'
780 return $ B.fromForeignPtr fptr 0 $ fromIntegral len
583 return $ B.fromForeignPtr fptr 0 $ fromIntegral len
781
584
782−
783encodeFile :: MonadResource m
585encodeFile :: MonadResource m
784 => FilePath
586 => FilePath
587+#if MIN_VERSION_conduit(1, 0, 0)
785− -> ConduitM Event o m ()
588+ -> Consumer Event m ()
786−encodeFile = encodeFileWith defaultFormatOptions
589+#else
787−
590+ -> GInfSink Event m
788−-- |
591+#endif
789−-- @since 0.10.2.0
592+encodeFile filePath =
790−encodeFileWith :: MonadResource m
791− => FormatOptions
792− -> FilePath
793− -> ConduitM Event o m ()
794−encodeFileWith opts filePath =
795− bracketP getFile cleanup $ \file -> runEmitter opts (alloc file) (\u _ -> return u)
593+ bracketP getFile c_fclose $ \file -> runEmitter (alloc file) (\u _ -> return u)
796 where
594 where
797− cleanup file = do
798− res <- c_fclose file
799− when (res /= 0) $ throwIO $ YamlException $ "could not close file: " ++ filePath
800−
801 getFile = do
595 getFile = do
802−#if WINDOWS && __GLASGOW_HASKELL__ >= 806
596+ file <- withCString filePath $
803− -- See: https://github.com/snoyberg/yaml/issues/178#issuecomment-550180027
597+ \filePath' -> withCString "w" $
804− removeFile filePath `Control.Exception.catch`
598+ \w' -> c_fopen filePath' w'
805− (\(_ :: Control.Exception.IOException) -> pure ())
806−#endif
807− file <- openFile filePath write_flags "w"
808− if file == nullPtr
599+ if (file == nullPtr)
809 then throwIO $ YamlException $ "could not open file for write: " ++ filePath
600 then throwIO $ YamlException $ "could not open file for write: " ++ filePath
810 else return file
601 else return file
811
602
812 alloc file emitter = c_yaml_emitter_set_output_file emitter file
603 alloc file emitter = c_yaml_emitter_set_output_file emitter file
813
604
814runEmitter :: MonadResource m
605runEmitter :: MonadResource m
815− => FormatOptions
816− -> (Emitter -> IO a) -- ^ alloc
606+ => (Emitter -> IO a) -- ^ alloc
607+#if MIN_VERSION_conduit(1, 0, 0)
817 -> (() -> a -> IO b) -- ^ close
608 -> (() -> a -> IO b) -- ^ close
609+ -> Consumer Event m b
610+#else
611+ -> (u -> a -> IO b) -- ^ close
818− -> ConduitM Event o m b
612+ -> Pipe l Event o u m b
613+#endif
819−runEmitter opts allocI closeI =
614+runEmitter allocI closeI =
820 bracketP alloc cleanup go
615 bracketP alloc cleanup go
821 where
616 where
822 alloc = mask_ $ do
617 alloc = mask_ $ do
823 emitter <- mallocBytes emitterSize
618 emitter <- mallocBytes emitterSize
824 res <- c_yaml_emitter_initialize emitter
619 res <- c_yaml_emitter_initialize emitter
825 when (res == 0) $ throwIO $ YamlException "c_yaml_emitter_initialize failed"
620 when (res == 0) $ throwIO $ YamlException "c_yaml_emitter_initialize failed"
826−#ifndef __NO_UNICODE__
827− c_yaml_emitter_set_unicode emitter 1
828−#endif
829− c_yaml_emitter_set_width emitter $ case formatOptionsWidth opts of
830− Nothing -> -1 --infinite
831− Just width -> fromIntegral width
832 a <- allocI emitter
621 a <- allocI emitter
833 return (emitter, a)
622 return (emitter, a)
834 cleanup (emitter, _) = do
623 cleanup (emitter, _) = do
@@ -838,10 +627,14 @@ runEmitter opts allocI closeI =
838 go (emitter, a) =
627 go (emitter, a) =
839 loop
628 loop
840 where
629 where
630+#if MIN_VERSION_conduit(1, 0, 0)
841 loop = await >>= maybe (close ()) push
631 loop = await >>= maybe (close ()) push
632+#else
633+ loop = awaitE >>= either close push
634+#endif
842
635
843 push e = do
636 push e = do
844− _ <- liftIO $ toEventRaw opts e $ c_yaml_emitter_emit emitter
637+ _ <- liftIO $ toEventRaw e $ c_yaml_emitter_emit emitter
845 loop
638 loop
846 close u = liftIO $ closeI u a
639 close u = liftIO $ closeI u a
847
640
yaml/builder-test.hs → builder-test.hsrenamed−6
@@ -18,10 +18,4 @@ main = do
18 S.putStr $ toByteString
18 S.putStr $ toByteString
19 [ Person "Alice" 57
19 [ Person "Alice" 57
20 , Person "Bob" 23
20 , Person "Bob" 23
21− , Person "12345" 23
22− ]
23− writeYamlFile "/tmp/foo.yaml" $
24− [ Person "Alice" 57
25− , Person "Bob" 23
26− , Person "12345" 23
27 ]
21 ]
libyaml/c/helper.c → c/helper.crenamed+23−58
@@ -13,10 +13,10 @@ int buffer_append(void *ext, unsigned char *str, size_t size)
13{
13{
14 buffer_t *b = ext;
14 buffer_t *b = ext;
15 int new_size, new_used;
15 int new_size, new_used;
16− unsigned char *tmp;
16+ char *tmp;
17
17
18 new_used = b->used + size;
18 new_used = b->used + size;
19− for (new_size = b->size ? b->size : 8; new_size < new_used; new_size *= 2);
19+ for (new_size = b->size || 8; new_size < new_used; new_size *= 2);
20
20
21 if (new_size != b->size) {
21 if (new_size != b->size) {
22 tmp = realloc(b->buff, new_size);
22 tmp = realloc(b->buff, new_size);
@@ -46,22 +46,32 @@ void my_emitter_set_output(yaml_emitter_t *e, buffer_t *b)
46 yaml_emitter_set_output(e, buffer_append, b);
46 yaml_emitter_set_output(e, buffer_append, b);
47}
47}
48
48
49−char const * get_parser_error_problem(yaml_parser_t *p)
49+unsigned char const * get_parser_error_problem(yaml_parser_t *p)
50{
50{
51 return p->problem;
51 return p->problem;
52}
52}
53
53
54−char const * get_parser_error_context(yaml_parser_t *p)
54+unsigned char const * get_parser_error_context(yaml_parser_t *p)
55{
55{
56 return p->context;
56 return p->context;
57}
57}
58
58
59−const yaml_mark_t * get_parser_error_mark(yaml_parser_t *p)
59+unsigned int get_parser_error_index(yaml_parser_t *p)
60{
60{
61− return &p->problem_mark;
61+ return p->problem_mark.index;
62}
62}
63
63
64+unsigned int get_parser_error_line(yaml_parser_t *p)
65+{
66+ return p->problem_mark.line;
67+}
68+
69+unsigned int get_parser_error_column(yaml_parser_t *p)
70+{
71+ return p->problem_mark.column;
72+}
73+
64−char const * get_emitter_error(yaml_emitter_t *e)
74+unsigned char const * get_emitter_error(yaml_emitter_t *e)
65{
75{
66 return e->problem;
76 return e->problem;
67}
77}
@@ -94,10 +104,15 @@ unsigned long get_scalar_length(yaml_event_t *e)
94unsigned char * get_scalar_tag(yaml_event_t *e)
104unsigned char * get_scalar_tag(yaml_event_t *e)
95{
105{
96 unsigned char *s = e->data.scalar.tag;
106 unsigned char *s = e->data.scalar.tag;
97− if (!s) s = (unsigned char *) "";
107+ if (!s) s = "";
98 return s;
108 return s;
99}
109}
100
110
111+unsigned long get_scalar_tag_len(yaml_event_t *e)
112+{
113+ return strlen(get_scalar_tag(e));
114+}
115+
101int get_scalar_style(yaml_event_t *e)
116int get_scalar_style(yaml_event_t *e)
102{
117{
103 return e->data.scalar.style;
118 return e->data.scalar.style;
@@ -113,71 +128,21 @@ unsigned char * get_sequence_start_anchor(yaml_event_t *e)
113 return e->data.sequence_start.anchor;
128 return e->data.sequence_start.anchor;
114}
129}
115
130
116−int get_sequence_start_style(yaml_event_t *e)
117−{
118− return e->data.sequence_start.style;
119−}
120−
121−unsigned char * get_sequence_start_tag(yaml_event_t *e)
122−{
123− unsigned char *s = e->data.sequence_start.tag;
124− if (!s) s = (unsigned char *) "";
125− return s;
126−}
127−
128unsigned char * get_mapping_start_anchor(yaml_event_t *e)
131unsigned char * get_mapping_start_anchor(yaml_event_t *e)
129{
132{
130 return e->data.mapping_start.anchor;
133 return e->data.mapping_start.anchor;
131}
134}
132
135
133−int get_mapping_start_style(yaml_event_t *e)
134−{
135− return e->data.mapping_start.style;
136−}
137−
138−unsigned char * get_mapping_start_tag(yaml_event_t *e)
139−{
140− unsigned char *s = e->data.mapping_start.tag;
141− if (!s) s = (unsigned char *) "";
142− return s;
143−}
144−
145unsigned char * get_alias_anchor(yaml_event_t *e)
136unsigned char * get_alias_anchor(yaml_event_t *e)
146{
137{
147 return e->data.alias.anchor;
138 return e->data.alias.anchor;
148}
139}
149
140
150−const yaml_mark_t * get_start_mark(yaml_event_t *e)
151−{
152− return &e->start_mark;
153−}
154−
155−const yaml_mark_t * get_end_mark(yaml_event_t *e)
156−{
157− return &e->end_mark;
158−}
159−
160−unsigned int get_mark_index(yaml_mark_t *m)
161−{
162− return m->index;
163−}
164−
165−unsigned int get_mark_line(yaml_mark_t *m)
166−{
167− return m->line;
168−}
169−
170−unsigned int get_mark_column(yaml_mark_t *m)
171−{
172− return m->column;
173−}
174−
175int yaml_parser_set_input_filename(yaml_parser_t *parser, const char *filename)
141int yaml_parser_set_input_filename(yaml_parser_t *parser, const char *filename)
176{
142{
177 FILE *in = fopen(filename, "r");
143 FILE *in = fopen(filename, "r");
178 if (!in) return 0;
144 if (!in) return 0;
179 yaml_parser_set_input_file(parser, in);
145 yaml_parser_set_input_file(parser, in);
180− return 1;
181}
146}
182
147
183int fclose_helper(FILE *file)
148int fclose_helper(FILE *file)
libyaml/include/helper.h → c/helper.hrenamed+4−7
@@ -14,11 +14,11 @@ unsigned int get_buffer_used(buffer_t *b);
14
14
15void my_emitter_set_output(yaml_emitter_t *e, buffer_t *b);
15void my_emitter_set_output(yaml_emitter_t *e, buffer_t *b);
16
16
17−char const * get_parser_error_problem(yaml_parser_t *p);
17+unsigned char const * get_parser_error_problem(yaml_parser_t *p);
18−char const * get_parser_error_context(yaml_parser_t *p);
18+unsigned char const * get_parser_error_context(yaml_parser_t *p);
19unsigned int get_parser_error_offset(yaml_parser_t *p);
19unsigned int get_parser_error_offset(yaml_parser_t *p);
20
20
21−char const * get_emitter_error(yaml_emitter_t *e);
21+unsigned char const * get_emitter_error(yaml_emitter_t *e);
22
22
23int simple_document_start(yaml_event_t *e);
23int simple_document_start(yaml_event_t *e);
24
24
@@ -28,12 +28,9 @@ unsigned char * get_scalar_value(yaml_event_t *e);
28unsigned long get_scalar_length(yaml_event_t *e);
28unsigned long get_scalar_length(yaml_event_t *e);
29
29
30unsigned char * get_scalar_tag(yaml_event_t *e);
30unsigned char * get_scalar_tag(yaml_event_t *e);
31−unsigned char * get_sequence_start_tag(yaml_event_t *e);
31+unsigned long get_scalar_tag_len(yaml_event_t *e);
32−unsigned char * get_mapping_start_tag(yaml_event_t *e);
33
32
34int get_scalar_style(yaml_event_t *e);
33int get_scalar_style(yaml_event_t *e);
35−int get_sequence_start_style(yaml_event_t *e);
36−int get_mapping_start_style(yaml_event_t *e);
37
34
38unsigned char * get_scalar_anchor(yaml_event_t *e);
35unsigned char * get_scalar_anchor(yaml_event_t *e);
39unsigned char * get_sequence_start_anchor(yaml_event_t *e);
36unsigned char * get_sequence_start_anchor(yaml_event_t *e);
exe/yaml2json.hsnew file+28
@@ -0,0 +1,28 @@
1+{-# LANGUAGE ScopedTypeVariables #-}
2+
3+import Data.Yaml (decodeFileEither, decodeEither')
4+import System.Environment (getArgs)
5+import System.Exit
6+import Data.Aeson (encode, Value)
7+import Prelude hiding (putStr, getContents)
8+import Data.ByteString.Lazy (putStr)
9+import Data.ByteString (getContents)
10+
11+helpMessage :: IO ()
12+helpMessage = putStrLn "yaml2json FILE\n use - as FILE to indicate stdin" >> exitFailure
13+
14+showJSON ejson =
15+ case ejson of
16+ Left err -> print err >> exitFailure
17+ Right (res :: Value) -> putStr (encode res) >> exitSuccess
18+
19+main :: IO ()
20+main = do
21+ args <- getArgs
22+ case args of
23+ [] -> helpMessage
24+ (f:a:_) -> helpMessage
25+ -- strict getContents will read in all of stdin at once
26+ ("-":[]) -> getContents >>= showJSON . decodeEither'
27+ (f:[]) -> decodeFileEither f >>= showJSON
28+
libyaml/ChangeLog.mddeleted−27
@@ -1,27 +0,0 @@
1−# Changelog for libyaml
2−
3−## 0.1.4
4−
5−* Use libyaml-clib for the cbits
6−* Use pkg-config to link to system yaml
7−
8−## 0.1.3
9−
10−* Correct signature for `fclose`
11−
12−## 0.1.2
13−
14−* Upgrade `libyaml` to 0.2.2
15−
16−## 0.1.1.1
17−
18−* Work around GHC 8.6.5 issue on Windows preventing truncated files. [#178](https://github.com/snoyberg/yaml/issues/178)
19−
20−## 0.1.1.0
21−
22−* Add options to `FormatOptions` to govern when tags rendered explicitly and when they are left implicit. [#165](https://github.com/snoyberg/yaml/issues/165)
23−
24−## 0.1.0.0
25−
26−* Split `libyaml` into a separate package from `yaml`. This split occurred at
27− `yaml` version 0.10.4.0.
libyaml/LICENSE+16−22
@@ -1,25 +1,19 @@
1−The following license covers this documentation, and the source code, except
1+Copyright (c) 2006 Kirill Simonov
2−where otherwise indicated.
3
2
4−Copyright 2008, Michael Snoyman. All rights reserved.
3+Permission is hereby granted, free of charge, to any person obtaining a copy of
4+this software and associated documentation files (the "Software"), to deal in
5+the Software without restriction, including without limitation the rights to
6+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
7+of the Software, and to permit persons to whom the Software is furnished to do
8+so, subject to the following conditions:
5
9
6−Redistribution and use in source and binary forms, with or without
10+The above copyright notice and this permission notice shall be included in all
7−modification, are permitted provided that the following conditions are met:
11+copies or substantial portions of the Software.
8
12
9−* Redistributions of source code must retain the above copyright notice, this
10− list of conditions and the following disclaimer.
11−
12−* Redistributions in binary form must reproduce the above copyright notice,
13− this list of conditions and the following disclaimer in the documentation
14− and/or other materials provided with the distribution.
15−
16−THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS "AS IS" AND ANY EXPRESS OR
13+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17−IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
14+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18−MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
15+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19−EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
16+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20−INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21−NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
22−OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23−LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
17+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24−OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
18+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25−ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
19+SOFTWARE.
libyaml/Makefile+9−4
@@ -1,4 +1,9 @@
1−libhelper.so : helper.o
1+CC = gcc
2+CFLAGS = -shared
3+OBJECTS = api.o dumper.o emitter.o loader.o parser.o reader.o scanner.o writer.o
4+LIB = libyaml.so
2− gcc -shared -Wl,-soname,libhelper.so -o libhelper.so helper.o
5+LFLAGS = -shared -Wl,-soname,libyaml.so
3−helper.o : c/helper.c
6+%.o: %.c
4− gcc -c -fPIC c/helper.c -o helper.o
7+ $(CC) $(CFLAGS) -c -fPIC $<
8+yaml: $(OBJECTS)
9+ $(CC) $(LFLAGS) -o $(LIB) $(OBJECTS)
libyaml/README.mddeleted−3
@@ -1,3 +0,0 @@
1−# libyaml
2−
3−This package provides a haskell wrapper over the [libyaml C library version 0.2.2 by Kirill Simonov](https://github.com/yaml/libyaml). It contains the C source so you don't need to worry about any non-Haskell dependencies.
libyaml/Setup.hsdeleted−2
@@ -1,2 +0,0 @@
1−import Distribution.Simple
2−main = defaultMain
libyaml/api.cnew file+1394
@@ -0,0 +1,1394 @@
1+
2+#include "yaml_private.h"
3+
4+/*
5+ * Get the library version.
6+ */
7+
8+YAML_DECLARE(const char *)
9+yaml_get_version_string(void)
10+{
11+ return YAML_VERSION_STRING;
12+}
13+
14+/*
15+ * Get the library version numbers.
16+ */
17+
18+YAML_DECLARE(void)
19+yaml_get_version(int *major, int *minor, int *patch)
20+{
21+ *major = YAML_VERSION_MAJOR;
22+ *minor = YAML_VERSION_MINOR;
23+ *patch = YAML_VERSION_PATCH;
24+}
25+
26+/*
27+ * Allocate a dynamic memory block.
28+ */
29+
30+YAML_DECLARE(void *)
31+yaml_malloc(size_t size)
32+{
33+ return malloc(size ? size : 1);
34+}
35+
36+/*
37+ * Reallocate a dynamic memory block.
38+ */
39+
40+YAML_DECLARE(void *)
41+yaml_realloc(void *ptr, size_t size)
42+{
43+ return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
44+}
45+
46+/*
47+ * Free a dynamic memory block.
48+ */
49+
50+YAML_DECLARE(void)
51+yaml_free(void *ptr)
52+{
53+ if (ptr) free(ptr);
54+}
55+
56+/*
57+ * Duplicate a string.
58+ */
59+
60+YAML_DECLARE(yaml_char_t *)
61+yaml_strdup(const yaml_char_t *str)
62+{
63+ if (!str)
64+ return NULL;
65+
66+ return (yaml_char_t *)strdup((char *)str);
67+}
68+
69+/*
70+ * Extend a string.
71+ */
72+
73+YAML_DECLARE(int)
74+yaml_string_extend(yaml_char_t **start,
75+ yaml_char_t **pointer, yaml_char_t **end)
76+{
77+ yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);
78+
79+ if (!new_start) return 0;
80+
81+ memset(new_start + (*end - *start), 0, *end - *start);
82+
83+ *pointer = new_start + (*pointer - *start);
84+ *end = new_start + (*end - *start)*2;
85+ *start = new_start;
86+
87+ return 1;
88+}
89+
90+/*
91+ * Append a string B to a string A.
92+ */
93+
94+YAML_DECLARE(int)
95+yaml_string_join(
96+ yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
97+ yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
98+{
99+ if (*b_start == *b_pointer)
100+ return 1;
101+
102+ while (*a_end - *a_pointer <= *b_pointer - *b_start) {
103+ if (!yaml_string_extend(a_start, a_pointer, a_end))
104+ return 0;
105+ }
106+
107+ memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
108+ *a_pointer += *b_pointer - *b_start;
109+
110+ return 1;
111+}
112+
113+/*
114+ * Extend a stack.
115+ */
116+
117+YAML_DECLARE(int)
118+yaml_stack_extend(void **start, void **top, void **end)
119+{
120+ void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);
121+
122+ if (!new_start) return 0;
123+
124+ *top = (char *)new_start + ((char *)*top - (char *)*start);
125+ *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
126+ *start = new_start;
127+
128+ return 1;
129+}
130+
131+/*
132+ * Extend or move a queue.
133+ */
134+
135+YAML_DECLARE(int)
136+yaml_queue_extend(void **start, void **head, void **tail, void **end)
137+{
138+ /* Check if we need to resize the queue. */
139+
140+ if (*start == *head && *tail == *end) {
141+ void *new_start = yaml_realloc(*start,
142+ ((char *)*end - (char *)*start)*2);
143+
144+ if (!new_start) return 0;
145+
146+ *head = (char *)new_start + ((char *)*head - (char *)*start);
147+ *tail = (char *)new_start + ((char *)*tail - (char *)*start);
148+ *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
149+ *start = new_start;
150+ }
151+
152+ /* Check if we need to move the queue at the beginning of the buffer. */
153+
154+ if (*tail == *end) {
155+ if (*head != *tail) {
156+ memmove(*start, *head, (char *)*tail - (char *)*head);
157+ }
158+ *tail = (char *)*tail - (char *)*head + (char *)*start;
159+ *head = *start;
160+ }
161+
162+ return 1;
163+}
164+
165+
166+/*
167+ * Create a new parser object.
168+ */
169+
170+YAML_DECLARE(int)
171+yaml_parser_initialize(yaml_parser_t *parser)
172+{
173+ assert(parser); /* Non-NULL parser object expected. */
174+
175+ memset(parser, 0, sizeof(yaml_parser_t));
176+ if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
177+ goto error;
178+ if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
179+ goto error;
180+ if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
181+ goto error;
182+ if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
183+ goto error;
184+ if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
185+ goto error;
186+ if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
187+ goto error;
188+ if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
189+ goto error;
190+ if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
191+ goto error;
192+
193+ return 1;
194+
195+error:
196+
197+ BUFFER_DEL(parser, parser->raw_buffer);
198+ BUFFER_DEL(parser, parser->buffer);
199+ QUEUE_DEL(parser, parser->tokens);
200+ STACK_DEL(parser, parser->indents);
201+ STACK_DEL(parser, parser->simple_keys);
202+ STACK_DEL(parser, parser->states);
203+ STACK_DEL(parser, parser->marks);
204+ STACK_DEL(parser, parser->tag_directives);
205+
206+ return 0;
207+}
208+
209+/*
210+ * Destroy a parser object.
211+ */
212+
213+YAML_DECLARE(void)
214+yaml_parser_delete(yaml_parser_t *parser)
215+{
216+ assert(parser); /* Non-NULL parser object expected. */
217+
218+ BUFFER_DEL(parser, parser->raw_buffer);
219+ BUFFER_DEL(parser, parser->buffer);
220+ while (!QUEUE_EMPTY(parser, parser->tokens)) {
221+ yaml_token_delete(&DEQUEUE(parser, parser->tokens));
222+ }
223+ QUEUE_DEL(parser, parser->tokens);
224+ STACK_DEL(parser, parser->indents);
225+ STACK_DEL(parser, parser->simple_keys);
226+ STACK_DEL(parser, parser->states);
227+ STACK_DEL(parser, parser->marks);
228+ while (!STACK_EMPTY(parser, parser->tag_directives)) {
229+ yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
230+ yaml_free(tag_directive.handle);
231+ yaml_free(tag_directive.prefix);
232+ }
233+ STACK_DEL(parser, parser->tag_directives);
234+
235+ memset(parser, 0, sizeof(yaml_parser_t));
236+}
237+
238+/*
239+ * String read handler.
240+ */
241+
242+static int
243+yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
244+ size_t *size_read)
245+{
246+ yaml_parser_t *parser = data;
247+
248+ if (parser->input.string.current == parser->input.string.end) {
249+ *size_read = 0;
250+ return 1;
251+ }
252+
253+ if (size > (size_t)(parser->input.string.end
254+ - parser->input.string.current)) {
255+ size = parser->input.string.end - parser->input.string.current;
256+ }
257+
258+ memcpy(buffer, parser->input.string.current, size);
259+ parser->input.string.current += size;
260+ *size_read = size;
261+ return 1;
262+}
263+
264+/*
265+ * File read handler.
266+ */
267+
268+static int
269+yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
270+ size_t *size_read)
271+{
272+ yaml_parser_t *parser = data;
273+
274+ *size_read = fread(buffer, 1, size, parser->input.file);
275+ return !ferror(parser->input.file);
276+}
277+
278+/*
279+ * Set a string input.
280+ */
281+
282+YAML_DECLARE(void)
283+yaml_parser_set_input_string(yaml_parser_t *parser,
284+ const unsigned char *input, size_t size)
285+{
286+ assert(parser); /* Non-NULL parser object expected. */
287+ assert(!parser->read_handler); /* You can set the source only once. */
288+ assert(input); /* Non-NULL input string expected. */
289+
290+ parser->read_handler = yaml_string_read_handler;
291+ parser->read_handler_data = parser;
292+
293+ parser->input.string.start = input;
294+ parser->input.string.current = input;
295+ parser->input.string.end = input+size;
296+}
297+
298+/*
299+ * Set a file input.
300+ */
301+
302+YAML_DECLARE(void)
303+yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
304+{
305+ assert(parser); /* Non-NULL parser object expected. */
306+ assert(!parser->read_handler); /* You can set the source only once. */
307+ assert(file); /* Non-NULL file object expected. */
308+
309+ parser->read_handler = yaml_file_read_handler;
310+ parser->read_handler_data = parser;
311+
312+ parser->input.file = file;
313+}
314+
315+/*
316+ * Set a generic input.
317+ */
318+
319+YAML_DECLARE(void)
320+yaml_parser_set_input(yaml_parser_t *parser,
321+ yaml_read_handler_t *handler, void *data)
322+{
323+ assert(parser); /* Non-NULL parser object expected. */
324+ assert(!parser->read_handler); /* You can set the source only once. */
325+ assert(handler); /* Non-NULL read handler expected. */
326+
327+ parser->read_handler = handler;
328+ parser->read_handler_data = data;
329+}
330+
331+/*
332+ * Set the source encoding.
333+ */
334+
335+YAML_DECLARE(void)
336+yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
337+{
338+ assert(parser); /* Non-NULL parser object expected. */
339+ assert(!parser->encoding); /* Encoding is already set or detected. */
340+
341+ parser->encoding = encoding;
342+}
343+
344+/*
345+ * Create a new emitter object.
346+ */
347+
348+YAML_DECLARE(int)
349+yaml_emitter_initialize(yaml_emitter_t *emitter)
350+{
351+ assert(emitter); /* Non-NULL emitter object expected. */
352+
353+ memset(emitter, 0, sizeof(yaml_emitter_t));
354+ if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
355+ goto error;
356+ if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
357+ goto error;
358+ if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))
359+ goto error;
360+ if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))
361+ goto error;
362+ if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))
363+ goto error;
364+ if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))
365+ goto error;
366+
367+ return 1;
368+
369+error:
370+
371+ BUFFER_DEL(emitter, emitter->buffer);
372+ BUFFER_DEL(emitter, emitter->raw_buffer);
373+ STACK_DEL(emitter, emitter->states);
374+ QUEUE_DEL(emitter, emitter->events);
375+ STACK_DEL(emitter, emitter->indents);
376+ STACK_DEL(emitter, emitter->tag_directives);
377+
378+ return 0;
379+}
380+
381+/*
382+ * Destroy an emitter object.
383+ */
384+
385+YAML_DECLARE(void)
386+yaml_emitter_delete(yaml_emitter_t *emitter)
387+{
388+ assert(emitter); /* Non-NULL emitter object expected. */
389+
390+ BUFFER_DEL(emitter, emitter->buffer);
391+ BUFFER_DEL(emitter, emitter->raw_buffer);
392+ STACK_DEL(emitter, emitter->states);
393+ while (!QUEUE_EMPTY(emitter, emitter->events)) {
394+ yaml_event_delete(&DEQUEUE(emitter, emitter->events));
395+ }
396+ QUEUE_DEL(emitter, emitter->events);
397+ STACK_DEL(emitter, emitter->indents);
398+ while (!STACK_EMPTY(empty, emitter->tag_directives)) {
399+ yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
400+ yaml_free(tag_directive.handle);
401+ yaml_free(tag_directive.prefix);
402+ }
403+ STACK_DEL(emitter, emitter->tag_directives);
404+ yaml_free(emitter->anchors);
405+
406+ memset(emitter, 0, sizeof(yaml_emitter_t));
407+}
408+
409+/*
410+ * String write handler.
411+ */
412+
413+static int
414+yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
415+{
416+ yaml_emitter_t *emitter = data;
417+
418+ if (emitter->output.string.size + *emitter->output.string.size_written
419+ < size) {
420+ memcpy(emitter->output.string.buffer
421+ + *emitter->output.string.size_written,
422+ buffer,
423+ emitter->output.string.size
424+ - *emitter->output.string.size_written);
425+ *emitter->output.string.size_written = emitter->output.string.size;
426+ return 0;
427+ }
428+
429+ memcpy(emitter->output.string.buffer
430+ + *emitter->output.string.size_written, buffer, size);
431+ *emitter->output.string.size_written += size;
432+ return 1;
433+}
434+
435+/*
436+ * File write handler.
437+ */
438+
439+static int
440+yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
441+{
442+ yaml_emitter_t *emitter = data;
443+
444+ return (fwrite(buffer, 1, size, emitter->output.file) == size);
445+}
446+/*
447+ * Set a string output.
448+ */
449+
450+YAML_DECLARE(void)
451+yaml_emitter_set_output_string(yaml_emitter_t *emitter,
452+ unsigned char *output, size_t size, size_t *size_written)
453+{
454+ assert(emitter); /* Non-NULL emitter object expected. */
455+ assert(!emitter->write_handler); /* You can set the output only once. */
456+ assert(output); /* Non-NULL output string expected. */
457+
458+ emitter->write_handler = yaml_string_write_handler;
459+ emitter->write_handler_data = emitter;
460+
461+ emitter->output.string.buffer = output;
462+ emitter->output.string.size = size;
463+ emitter->output.string.size_written = size_written;
464+ *size_written = 0;
465+}
466+
467+/*
468+ * Set a file output.
469+ */
470+
471+YAML_DECLARE(void)
472+yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
473+{
474+ assert(emitter); /* Non-NULL emitter object expected. */
475+ assert(!emitter->write_handler); /* You can set the output only once. */
476+ assert(file); /* Non-NULL file object expected. */
477+
478+ emitter->write_handler = yaml_file_write_handler;
479+ emitter->write_handler_data = emitter;
480+
481+ emitter->output.file = file;
482+}
483+
484+/*
485+ * Set a generic output handler.
486+ */
487+
488+YAML_DECLARE(void)
489+yaml_emitter_set_output(yaml_emitter_t *emitter,
490+ yaml_write_handler_t *handler, void *data)
491+{
492+ assert(emitter); /* Non-NULL emitter object expected. */
493+ assert(!emitter->write_handler); /* You can set the output only once. */
494+ assert(handler); /* Non-NULL handler object expected. */
495+
496+ emitter->write_handler = handler;
497+ emitter->write_handler_data = data;
498+}
499+
500+/*
501+ * Set the output encoding.
502+ */
503+
504+YAML_DECLARE(void)
505+yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
506+{
507+ assert(emitter); /* Non-NULL emitter object expected. */
508+ assert(!emitter->encoding); /* You can set encoding only once. */
509+
510+ emitter->encoding = encoding;
511+}
512+
513+/*
514+ * Set the canonical output style.
515+ */
516+
517+YAML_DECLARE(void)
518+yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
519+{
520+ assert(emitter); /* Non-NULL emitter object expected. */
521+
522+ emitter->canonical = (canonical != 0);
523+}
524+
525+/*
526+ * Set the indentation increment.
527+ */
528+
529+YAML_DECLARE(void)
530+yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
531+{
532+ assert(emitter); /* Non-NULL emitter object expected. */
533+
534+ emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
535+}
536+
537+/*
538+ * Set the preferred line width.
539+ */
540+
541+YAML_DECLARE(void)
542+yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
543+{
544+ assert(emitter); /* Non-NULL emitter object expected. */
545+
546+ emitter->best_width = (width >= 0) ? width : -1;
547+}
548+
549+/*
550+ * Set if unescaped non-ASCII characters are allowed.
551+ */
552+
553+YAML_DECLARE(void)
554+yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
555+{
556+ assert(emitter); /* Non-NULL emitter object expected. */
557+
558+ emitter->unicode = (unicode != 0);
559+}
560+
561+/*
562+ * Set the preferred line break character.
563+ */
564+
565+YAML_DECLARE(void)
566+yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
567+{
568+ assert(emitter); /* Non-NULL emitter object expected. */
569+
570+ emitter->line_break = line_break;
571+}
572+
573+/*
574+ * Destroy a token object.
575+ */
576+
577+YAML_DECLARE(void)
578+yaml_token_delete(yaml_token_t *token)
579+{
580+ assert(token); /* Non-NULL token object expected. */
581+
582+ switch (token->type)
583+ {
584+ case YAML_TAG_DIRECTIVE_TOKEN:
585+ yaml_free(token->data.tag_directive.handle);
586+ yaml_free(token->data.tag_directive.prefix);
587+ break;
588+
589+ case YAML_ALIAS_TOKEN:
590+ yaml_free(token->data.alias.value);
591+ break;
592+
593+ case YAML_ANCHOR_TOKEN:
594+ yaml_free(token->data.anchor.value);
595+ break;
596+
597+ case YAML_TAG_TOKEN:
598+ yaml_free(token->data.tag.handle);
599+ yaml_free(token->data.tag.suffix);
600+ break;
601+
602+ case YAML_SCALAR_TOKEN:
603+ yaml_free(token->data.scalar.value);
604+ break;
605+
606+ default:
607+ break;
608+ }
609+
610+ memset(token, 0, sizeof(yaml_token_t));
611+}
612+
613+/*
614+ * Check if a string is a valid UTF-8 sequence.
615+ *
616+ * Check 'reader.c' for more details on UTF-8 encoding.
617+ */
618+
619+static int
620+yaml_check_utf8(yaml_char_t *start, size_t length)
621+{
622+ yaml_char_t *end = start+length;
623+ yaml_char_t *pointer = start;
624+
625+ while (pointer < end) {
626+ unsigned char octet;
627+ unsigned int width;
628+ unsigned int value;
629+ size_t k;
630+
631+ octet = pointer[0];
632+ width = (octet & 0x80) == 0x00 ? 1 :
633+ (octet & 0xE0) == 0xC0 ? 2 :
634+ (octet & 0xF0) == 0xE0 ? 3 :
635+ (octet & 0xF8) == 0xF0 ? 4 : 0;
636+ value = (octet & 0x80) == 0x00 ? octet & 0x7F :
637+ (octet & 0xE0) == 0xC0 ? octet & 0x1F :
638+ (octet & 0xF0) == 0xE0 ? octet & 0x0F :
639+ (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
640+ if (!width) return 0;
641+ if (pointer+width > end) return 0;
642+ for (k = 1; k < width; k ++) {
643+ octet = pointer[k];
644+ if ((octet & 0xC0) != 0x80) return 0;
645+ value = (value << 6) + (octet & 0x3F);
646+ }
647+ if (!((width == 1) ||
648+ (width == 2 && value >= 0x80) ||
649+ (width == 3 && value >= 0x800) ||
650+ (width == 4 && value >= 0x10000))) return 0;
651+
652+ pointer += width;
653+ }
654+
655+ return 1;
656+}
657+
658+/*
659+ * Create STREAM-START.
660+ */
661+
662+YAML_DECLARE(int)
663+yaml_stream_start_event_initialize(yaml_event_t *event,
664+ yaml_encoding_t encoding)
665+{
666+ yaml_mark_t mark = { 0, 0, 0 };
667+
668+ assert(event); /* Non-NULL event object is expected. */
669+
670+ STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
671+
672+ return 1;
673+}
674+
675+/*
676+ * Create STREAM-END.
677+ */
678+
679+YAML_DECLARE(int)
680+yaml_stream_end_event_initialize(yaml_event_t *event)
681+{
682+ yaml_mark_t mark = { 0, 0, 0 };
683+
684+ assert(event); /* Non-NULL event object is expected. */
685+
686+ STREAM_END_EVENT_INIT(*event, mark, mark);
687+
688+ return 1;
689+}
690+
691+/*
692+ * Create DOCUMENT-START.
693+ */
694+
695+YAML_DECLARE(int)
696+yaml_document_start_event_initialize(yaml_event_t *event,
697+ yaml_version_directive_t *version_directive,
698+ yaml_tag_directive_t *tag_directives_start,
699+ yaml_tag_directive_t *tag_directives_end,
700+ int implicit)
701+{
702+ struct {
703+ yaml_error_type_t error;
704+ } context;
705+ yaml_mark_t mark = { 0, 0, 0 };
706+ yaml_version_directive_t *version_directive_copy = NULL;
707+ struct {
708+ yaml_tag_directive_t *start;
709+ yaml_tag_directive_t *end;
710+ yaml_tag_directive_t *top;
711+ } tag_directives_copy = { NULL, NULL, NULL };
712+ yaml_tag_directive_t value = { NULL, NULL };
713+
714+ assert(event); /* Non-NULL event object is expected. */
715+ assert((tag_directives_start && tag_directives_end) ||
716+ (tag_directives_start == tag_directives_end));
717+ /* Valid tag directives are expected. */
718+
719+ if (version_directive) {
720+ version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
721+ if (!version_directive_copy) goto error;
722+ version_directive_copy->major = version_directive->major;
723+ version_directive_copy->minor = version_directive->minor;
724+ }
725+
726+ if (tag_directives_start != tag_directives_end) {
727+ yaml_tag_directive_t *tag_directive;
728+ if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
729+ goto error;
730+ for (tag_directive = tag_directives_start;
731+ tag_directive != tag_directives_end; tag_directive ++) {
732+ assert(tag_directive->handle);
733+ assert(tag_directive->prefix);
734+ if (!yaml_check_utf8(tag_directive->handle,
735+ strlen((char *)tag_directive->handle)))
736+ goto error;
737+ if (!yaml_check_utf8(tag_directive->prefix,
738+ strlen((char *)tag_directive->prefix)))
739+ goto error;
740+ value.handle = yaml_strdup(tag_directive->handle);
741+ value.prefix = yaml_strdup(tag_directive->prefix);
742+ if (!value.handle || !value.prefix) goto error;
743+ if (!PUSH(&context, tag_directives_copy, value))
744+ goto error;
745+ value.handle = NULL;
746+ value.prefix = NULL;
747+ }
748+ }
749+
750+ DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
751+ tag_directives_copy.start, tag_directives_copy.top,
752+ implicit, mark, mark);
753+
754+ return 1;
755+
756+error:
757+ yaml_free(version_directive_copy);
758+ while (!STACK_EMPTY(context, tag_directives_copy)) {
759+ yaml_tag_directive_t value = POP(context, tag_directives_copy);
760+ yaml_free(value.handle);
761+ yaml_free(value.prefix);
762+ }
763+ STACK_DEL(context, tag_directives_copy);
764+ yaml_free(value.handle);
765+ yaml_free(value.prefix);
766+
767+ return 0;
768+}
769+
770+/*
771+ * Create DOCUMENT-END.
772+ */
773+
774+YAML_DECLARE(int)
775+yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
776+{
777+ yaml_mark_t mark = { 0, 0, 0 };
778+
779+ assert(event); /* Non-NULL emitter object is expected. */
780+
781+ DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
782+
783+ return 1;
784+}
785+
786+/*
787+ * Create ALIAS.
788+ */
789+
790+YAML_DECLARE(int)
791+yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
792+{
793+ yaml_mark_t mark = { 0, 0, 0 };
794+ yaml_char_t *anchor_copy = NULL;
795+
796+ assert(event); /* Non-NULL event object is expected. */
797+ assert(anchor); /* Non-NULL anchor is expected. */
798+
799+ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
800+
801+ anchor_copy = yaml_strdup(anchor);
802+ if (!anchor_copy)
803+ return 0;
804+
805+ ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
806+
807+ return 1;
808+}
809+
810+/*
811+ * Create SCALAR.
812+ */
813+
814+YAML_DECLARE(int)
815+yaml_scalar_event_initialize(yaml_event_t *event,
816+ yaml_char_t *anchor, yaml_char_t *tag,
817+ yaml_char_t *value, int length,
818+ int plain_implicit, int quoted_implicit,
819+ yaml_scalar_style_t style)
820+{
821+ yaml_mark_t mark = { 0, 0, 0 };
822+ yaml_char_t *anchor_copy = NULL;
823+ yaml_char_t *tag_copy = NULL;
824+ yaml_char_t *value_copy = NULL;
825+
826+ assert(event); /* Non-NULL event object is expected. */
827+ /* following line added for Haskell yaml library */
828+ if (!value && !length) value = "";
829+ assert(value); /* Non-NULL anchor is expected. */
830+
831+ if (anchor) {
832+ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
833+ anchor_copy = yaml_strdup(anchor);
834+ if (!anchor_copy) goto error;
835+ }
836+
837+ if (tag) {
838+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
839+ tag_copy = yaml_strdup(tag);
840+ if (!tag_copy) goto error;
841+ }
842+
843+ if (length < 0) {
844+ length = strlen((char *)value);
845+ }
846+
847+ if (!yaml_check_utf8(value, length)) goto error;
848+ value_copy = yaml_malloc(length+1);
849+ if (!value_copy) goto error;
850+ memcpy(value_copy, value, length);
851+ value_copy[length] = '\0';
852+
853+ SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
854+ plain_implicit, quoted_implicit, style, mark, mark);
855+
856+ return 1;
857+
858+error:
859+ yaml_free(anchor_copy);
860+ yaml_free(tag_copy);
861+ yaml_free(value_copy);
862+
863+ return 0;
864+}
865+
866+/*
867+ * Create SEQUENCE-START.
868+ */
869+
870+YAML_DECLARE(int)
871+yaml_sequence_start_event_initialize(yaml_event_t *event,
872+ yaml_char_t *anchor, yaml_char_t *tag, int implicit,
873+ yaml_sequence_style_t style)
874+{
875+ yaml_mark_t mark = { 0, 0, 0 };
876+ yaml_char_t *anchor_copy = NULL;
877+ yaml_char_t *tag_copy = NULL;
878+
879+ assert(event); /* Non-NULL event object is expected. */
880+
881+ if (anchor) {
882+ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
883+ anchor_copy = yaml_strdup(anchor);
884+ if (!anchor_copy) goto error;
885+ }
886+
887+ if (tag) {
888+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
889+ tag_copy = yaml_strdup(tag);
890+ if (!tag_copy) goto error;
891+ }
892+
893+ SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
894+ implicit, style, mark, mark);
895+
896+ return 1;
897+
898+error:
899+ yaml_free(anchor_copy);
900+ yaml_free(tag_copy);
901+
902+ return 0;
903+}
904+
905+/*
906+ * Create SEQUENCE-END.
907+ */
908+
909+YAML_DECLARE(int)
910+yaml_sequence_end_event_initialize(yaml_event_t *event)
911+{
912+ yaml_mark_t mark = { 0, 0, 0 };
913+
914+ assert(event); /* Non-NULL event object is expected. */
915+
916+ SEQUENCE_END_EVENT_INIT(*event, mark, mark);
917+
918+ return 1;
919+}
920+
921+/*
922+ * Create MAPPING-START.
923+ */
924+
925+YAML_DECLARE(int)
926+yaml_mapping_start_event_initialize(yaml_event_t *event,
927+ yaml_char_t *anchor, yaml_char_t *tag, int implicit,
928+ yaml_mapping_style_t style)
929+{
930+ yaml_mark_t mark = { 0, 0, 0 };
931+ yaml_char_t *anchor_copy = NULL;
932+ yaml_char_t *tag_copy = NULL;
933+
934+ assert(event); /* Non-NULL event object is expected. */
935+
936+ if (anchor) {
937+ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
938+ anchor_copy = yaml_strdup(anchor);
939+ if (!anchor_copy) goto error;
940+ }
941+
942+ if (tag) {
943+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
944+ tag_copy = yaml_strdup(tag);
945+ if (!tag_copy) goto error;
946+ }
947+
948+ MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
949+ implicit, style, mark, mark);
950+
951+ return 1;
952+
953+error:
954+ yaml_free(anchor_copy);
955+ yaml_free(tag_copy);
956+
957+ return 0;
958+}
959+
960+/*
961+ * Create MAPPING-END.
962+ */
963+
964+YAML_DECLARE(int)
965+yaml_mapping_end_event_initialize(yaml_event_t *event)
966+{
967+ yaml_mark_t mark = { 0, 0, 0 };
968+
969+ assert(event); /* Non-NULL event object is expected. */
970+
971+ MAPPING_END_EVENT_INIT(*event, mark, mark);
972+
973+ return 1;
974+}
975+
976+/*
977+ * Destroy an event object.
978+ */
979+
980+YAML_DECLARE(void)
981+yaml_event_delete(yaml_event_t *event)
982+{
983+ yaml_tag_directive_t *tag_directive;
984+
985+ assert(event); /* Non-NULL event object expected. */
986+
987+ switch (event->type)
988+ {
989+ case YAML_DOCUMENT_START_EVENT:
990+ yaml_free(event->data.document_start.version_directive);
991+ for (tag_directive = event->data.document_start.tag_directives.start;
992+ tag_directive != event->data.document_start.tag_directives.end;
993+ tag_directive++) {
994+ yaml_free(tag_directive->handle);
995+ yaml_free(tag_directive->prefix);
996+ }
997+ yaml_free(event->data.document_start.tag_directives.start);
998+ break;
999+
1000+ case YAML_ALIAS_EVENT:
1001+ yaml_free(event->data.alias.anchor);
1002+ break;
1003+
1004+ case YAML_SCALAR_EVENT:
1005+ yaml_free(event->data.scalar.anchor);
1006+ yaml_free(event->data.scalar.tag);
1007+ yaml_free(event->data.scalar.value);
1008+ break;
1009+
1010+ case YAML_SEQUENCE_START_EVENT:
1011+ yaml_free(event->data.sequence_start.anchor);
1012+ yaml_free(event->data.sequence_start.tag);
1013+ break;
1014+
1015+ case YAML_MAPPING_START_EVENT:
1016+ yaml_free(event->data.mapping_start.anchor);
1017+ yaml_free(event->data.mapping_start.tag);
1018+ break;
1019+
1020+ default:
1021+ break;
1022+ }
1023+
1024+ memset(event, 0, sizeof(yaml_event_t));
1025+}
1026+
1027+/*
1028+ * Create a document object.
1029+ */
1030+
1031+YAML_DECLARE(int)
1032+yaml_document_initialize(yaml_document_t *document,
1033+ yaml_version_directive_t *version_directive,
1034+ yaml_tag_directive_t *tag_directives_start,
1035+ yaml_tag_directive_t *tag_directives_end,
1036+ int start_implicit, int end_implicit)
1037+{
1038+ struct {
1039+ yaml_error_type_t error;
1040+ } context;
1041+ struct {
1042+ yaml_node_t *start;
1043+ yaml_node_t *end;
1044+ yaml_node_t *top;
1045+ } nodes = { NULL, NULL, NULL };
1046+ yaml_version_directive_t *version_directive_copy = NULL;
1047+ struct {
1048+ yaml_tag_directive_t *start;
1049+ yaml_tag_directive_t *end;
1050+ yaml_tag_directive_t *top;
1051+ } tag_directives_copy = { NULL, NULL, NULL };
1052+ yaml_tag_directive_t value = { NULL, NULL };
1053+ yaml_mark_t mark = { 0, 0, 0 };
1054+
1055+ assert(document); /* Non-NULL document object is expected. */
1056+ assert((tag_directives_start && tag_directives_end) ||
1057+ (tag_directives_start == tag_directives_end));
1058+ /* Valid tag directives are expected. */
1059+
1060+ if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error;
1061+
1062+ if (version_directive) {
1063+ version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
1064+ if (!version_directive_copy) goto error;
1065+ version_directive_copy->major = version_directive->major;
1066+ version_directive_copy->minor = version_directive->minor;
1067+ }
1068+
1069+ if (tag_directives_start != tag_directives_end) {
1070+ yaml_tag_directive_t *tag_directive;
1071+ if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
1072+ goto error;
1073+ for (tag_directive = tag_directives_start;
1074+ tag_directive != tag_directives_end; tag_directive ++) {
1075+ assert(tag_directive->handle);
1076+ assert(tag_directive->prefix);
1077+ if (!yaml_check_utf8(tag_directive->handle,
1078+ strlen((char *)tag_directive->handle)))
1079+ goto error;
1080+ if (!yaml_check_utf8(tag_directive->prefix,
1081+ strlen((char *)tag_directive->prefix)))
1082+ goto error;
1083+ value.handle = yaml_strdup(tag_directive->handle);
1084+ value.prefix = yaml_strdup(tag_directive->prefix);
1085+ if (!value.handle || !value.prefix) goto error;
1086+ if (!PUSH(&context, tag_directives_copy, value))
1087+ goto error;
1088+ value.handle = NULL;
1089+ value.prefix = NULL;
1090+ }
1091+ }
1092+
1093+ DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
1094+ tag_directives_copy.start, tag_directives_copy.top,
1095+ start_implicit, end_implicit, mark, mark);
1096+
1097+ return 1;
1098+
1099+error:
1100+ STACK_DEL(&context, nodes);
1101+ yaml_free(version_directive_copy);
1102+ while (!STACK_EMPTY(&context, tag_directives_copy)) {
1103+ yaml_tag_directive_t value = POP(&context, tag_directives_copy);
1104+ yaml_free(value.handle);
1105+ yaml_free(value.prefix);
1106+ }
1107+ STACK_DEL(&context, tag_directives_copy);
1108+ yaml_free(value.handle);
1109+ yaml_free(value.prefix);
1110+
1111+ return 0;
1112+}
1113+
1114+/*
1115+ * Destroy a document object.
1116+ */
1117+
1118+YAML_DECLARE(void)
1119+yaml_document_delete(yaml_document_t *document)
1120+{
1121+ struct {
1122+ yaml_error_type_t error;
1123+ } context;
1124+ yaml_tag_directive_t *tag_directive;
1125+
1126+ context.error = YAML_NO_ERROR; /* Eliminate a compliler warning. */
1127+
1128+ assert(document); /* Non-NULL document object is expected. */
1129+
1130+ while (!STACK_EMPTY(&context, document->nodes)) {
1131+ yaml_node_t node = POP(&context, document->nodes);
1132+ yaml_free(node.tag);
1133+ switch (node.type) {
1134+ case YAML_SCALAR_NODE:
1135+ yaml_free(node.data.scalar.value);
1136+ break;
1137+ case YAML_SEQUENCE_NODE:
1138+ STACK_DEL(&context, node.data.sequence.items);
1139+ break;
1140+ case YAML_MAPPING_NODE:
1141+ STACK_DEL(&context, node.data.mapping.pairs);
1142+ break;
1143+ default:
1144+ assert(0); /* Should not happen. */
1145+ }
1146+ }
1147+ STACK_DEL(&context, document->nodes);
1148+
1149+ yaml_free(document->version_directive);
1150+ for (tag_directive = document->tag_directives.start;
1151+ tag_directive != document->tag_directives.end;
1152+ tag_directive++) {
1153+ yaml_free(tag_directive->handle);
1154+ yaml_free(tag_directive->prefix);
1155+ }
1156+ yaml_free(document->tag_directives.start);
1157+
1158+ memset(document, 0, sizeof(yaml_document_t));
1159+}
1160+
1161+/**
1162+ * Get a document node.
1163+ */
1164+
1165+YAML_DECLARE(yaml_node_t *)
1166+yaml_document_get_node(yaml_document_t *document, int index)
1167+{
1168+ assert(document); /* Non-NULL document object is expected. */
1169+
1170+ if (index > 0 && document->nodes.start + index <= document->nodes.top) {
1171+ return document->nodes.start + index - 1;
1172+ }
1173+ return NULL;
1174+}
1175+
1176+/**
1177+ * Get the root object.
1178+ */
1179+
1180+YAML_DECLARE(yaml_node_t *)
1181+yaml_document_get_root_node(yaml_document_t *document)
1182+{
1183+ assert(document); /* Non-NULL document object is expected. */
1184+
1185+ if (document->nodes.top != document->nodes.start) {
1186+ return document->nodes.start;
1187+ }
1188+ return NULL;
1189+}
1190+
1191+/*
1192+ * Add a scalar node to a document.
1193+ */
1194+
1195+YAML_DECLARE(int)
1196+yaml_document_add_scalar(yaml_document_t *document,
1197+ yaml_char_t *tag, yaml_char_t *value, int length,
1198+ yaml_scalar_style_t style)
1199+{
1200+ struct {
1201+ yaml_error_type_t error;
1202+ } context;
1203+ yaml_mark_t mark = { 0, 0, 0 };
1204+ yaml_char_t *tag_copy = NULL;
1205+ yaml_char_t *value_copy = NULL;
1206+ yaml_node_t node;
1207+
1208+ assert(document); /* Non-NULL document object is expected. */
1209+ assert(value); /* Non-NULL value is expected. */
1210+
1211+ if (!tag) {
1212+ tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;
1213+ }
1214+
1215+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1216+ tag_copy = yaml_strdup(tag);
1217+ if (!tag_copy) goto error;
1218+
1219+ if (length < 0) {
1220+ length = strlen((char *)value);
1221+ }
1222+
1223+ if (!yaml_check_utf8(value, length)) goto error;
1224+ value_copy = yaml_malloc(length+1);
1225+ if (!value_copy) goto error;
1226+ memcpy(value_copy, value, length);
1227+ value_copy[length] = '\0';
1228+
1229+ SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);
1230+ if (!PUSH(&context, document->nodes, node)) goto error;
1231+
1232+ return document->nodes.top - document->nodes.start;
1233+
1234+error:
1235+ yaml_free(tag_copy);
1236+ yaml_free(value_copy);
1237+
1238+ return 0;
1239+}
1240+
1241+/*
1242+ * Add a sequence node to a document.
1243+ */
1244+
1245+YAML_DECLARE(int)
1246+yaml_document_add_sequence(yaml_document_t *document,
1247+ yaml_char_t *tag, yaml_sequence_style_t style)
1248+{
1249+ struct {
1250+ yaml_error_type_t error;
1251+ } context;
1252+ yaml_mark_t mark = { 0, 0, 0 };
1253+ yaml_char_t *tag_copy = NULL;
1254+ struct {
1255+ yaml_node_item_t *start;
1256+ yaml_node_item_t *end;
1257+ yaml_node_item_t *top;
1258+ } items = { NULL, NULL, NULL };
1259+ yaml_node_t node;
1260+
1261+ assert(document); /* Non-NULL document object is expected. */
1262+
1263+ if (!tag) {
1264+ tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG;
1265+ }
1266+
1267+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1268+ tag_copy = yaml_strdup(tag);
1269+ if (!tag_copy) goto error;
1270+
1271+ if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error;
1272+
1273+ SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
1274+ style, mark, mark);
1275+ if (!PUSH(&context, document->nodes, node)) goto error;
1276+
1277+ return document->nodes.top - document->nodes.start;
1278+
1279+error:
1280+ STACK_DEL(&context, items);
1281+ yaml_free(tag_copy);
1282+
1283+ return 0;
1284+}
1285+
1286+/*
1287+ * Add a mapping node to a document.
1288+ */
1289+
1290+YAML_DECLARE(int)
1291+yaml_document_add_mapping(yaml_document_t *document,
1292+ yaml_char_t *tag, yaml_mapping_style_t style)
1293+{
1294+ struct {
1295+ yaml_error_type_t error;
1296+ } context;
1297+ yaml_mark_t mark = { 0, 0, 0 };
1298+ yaml_char_t *tag_copy = NULL;
1299+ struct {
1300+ yaml_node_pair_t *start;
1301+ yaml_node_pair_t *end;
1302+ yaml_node_pair_t *top;
1303+ } pairs = { NULL, NULL, NULL };
1304+ yaml_node_t node;
1305+
1306+ assert(document); /* Non-NULL document object is expected. */
1307+
1308+ if (!tag) {
1309+ tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
1310+ }
1311+
1312+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1313+ tag_copy = yaml_strdup(tag);
1314+ if (!tag_copy) goto error;
1315+
1316+ if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;
1317+
1318+ MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
1319+ style, mark, mark);
1320+ if (!PUSH(&context, document->nodes, node)) goto error;
1321+
1322+ return document->nodes.top - document->nodes.start;
1323+
1324+error:
1325+ STACK_DEL(&context, pairs);
1326+ yaml_free(tag_copy);
1327+
1328+ return 0;
1329+}
1330+
1331+/*
1332+ * Append an item to a sequence node.
1333+ */
1334+
1335+YAML_DECLARE(int)
1336+yaml_document_append_sequence_item(yaml_document_t *document,
1337+ int sequence, int item)
1338+{
1339+ struct {
1340+ yaml_error_type_t error;
1341+ } context;
1342+
1343+ assert(document); /* Non-NULL document is required. */
1344+ assert(sequence > 0
1345+ && document->nodes.start + sequence <= document->nodes.top);
1346+ /* Valid sequence id is required. */
1347+ assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE);
1348+ /* A sequence node is required. */
1349+ assert(item > 0 && document->nodes.start + item <= document->nodes.top);
1350+ /* Valid item id is required. */
1351+
1352+ if (!PUSH(&context,
1353+ document->nodes.start[sequence-1].data.sequence.items, item))
1354+ return 0;
1355+
1356+ return 1;
1357+}
1358+
1359+/*
1360+ * Append a pair of a key and a value to a mapping node.
1361+ */
1362+
1363+YAML_DECLARE(int)
1364+yaml_document_append_mapping_pair(yaml_document_t *document,
1365+ int mapping, int key, int value)
1366+{
1367+ struct {
1368+ yaml_error_type_t error;
1369+ } context;
1370+
1371+ yaml_node_pair_t pair;
1372+
1373+ assert(document); /* Non-NULL document is required. */
1374+ assert(mapping > 0
1375+ && document->nodes.start + mapping <= document->nodes.top);
1376+ /* Valid mapping id is required. */
1377+ assert(document->nodes.start[mapping-1].type == YAML_MAPPING_NODE);
1378+ /* A mapping node is required. */
1379+ assert(key > 0 && document->nodes.start + key <= document->nodes.top);
1380+ /* Valid key id is required. */
1381+ assert(value > 0 && document->nodes.start + value <= document->nodes.top);
1382+ /* Valid value id is required. */
1383+
1384+ pair.key = key;
1385+ pair.value = value;
1386+
1387+ if (!PUSH(&context,
1388+ document->nodes.start[mapping-1].data.mapping.pairs, pair))
1389+ return 0;
1390+
1391+ return 1;
1392+}
1393+
1394+
libyaml/dumper.cnew file+394
@@ -0,0 +1,394 @@
1+
2+#include "yaml_private.h"
3+
4+/*
5+ * API functions.
6+ */
7+
8+YAML_DECLARE(int)
9+yaml_emitter_open(yaml_emitter_t *emitter);
10+
11+YAML_DECLARE(int)
12+yaml_emitter_close(yaml_emitter_t *emitter);
13+
14+YAML_DECLARE(int)
15+yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
16+
17+/*
18+ * Clean up functions.
19+ */
20+
21+static void
22+yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter);
23+
24+/*
25+ * Anchor functions.
26+ */
27+
28+static void
29+yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index);
30+
31+static yaml_char_t *
32+yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id);
33+
34+
35+/*
36+ * Serialize functions.
37+ */
38+
39+static int
40+yaml_emitter_dump_node(yaml_emitter_t *emitter, int index);
41+
42+static int
43+yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor);
44+
45+static int
46+yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
47+ yaml_char_t *anchor);
48+
49+static int
50+yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
51+ yaml_char_t *anchor);
52+
53+static int
54+yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
55+ yaml_char_t *anchor);
56+
57+/*
58+ * Issue a STREAM-START event.
59+ */
60+
61+YAML_DECLARE(int)
62+yaml_emitter_open(yaml_emitter_t *emitter)
63+{
64+ yaml_event_t event;
65+ yaml_mark_t mark = { 0, 0, 0 };
66+
67+ assert(emitter); /* Non-NULL emitter object is required. */
68+ assert(!emitter->opened); /* Emitter should not be opened yet. */
69+
70+ STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark);
71+
72+ if (!yaml_emitter_emit(emitter, &event)) {
73+ return 0;
74+ }
75+
76+ emitter->opened = 1;
77+
78+ return 1;
79+}
80+
81+/*
82+ * Issue a STREAM-END event.
83+ */
84+
85+YAML_DECLARE(int)
86+yaml_emitter_close(yaml_emitter_t *emitter)
87+{
88+ yaml_event_t event;
89+ yaml_mark_t mark = { 0, 0, 0 };
90+
91+ assert(emitter); /* Non-NULL emitter object is required. */
92+ assert(emitter->opened); /* Emitter should be opened. */
93+
94+ if (emitter->closed) return 1;
95+
96+ STREAM_END_EVENT_INIT(event, mark, mark);
97+
98+ if (!yaml_emitter_emit(emitter, &event)) {
99+ return 0;
100+ }
101+
102+ emitter->closed = 1;
103+
104+ return 1;
105+}
106+
107+/*
108+ * Dump a YAML document.
109+ */
110+
111+YAML_DECLARE(int)
112+yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
113+{
114+ yaml_event_t event;
115+ yaml_mark_t mark = { 0, 0, 0 };
116+
117+ assert(emitter); /* Non-NULL emitter object is required. */
118+ assert(document); /* Non-NULL emitter object is expected. */
119+
120+ emitter->document = document;
121+
122+ if (!emitter->opened) {
123+ if (!yaml_emitter_open(emitter)) goto error;
124+ }
125+
126+ if (STACK_EMPTY(emitter, document->nodes)) {
127+ if (!yaml_emitter_close(emitter)) goto error;
128+ yaml_emitter_delete_document_and_anchors(emitter);
129+ return 1;
130+ }
131+
132+ assert(emitter->opened); /* Emitter should be opened. */
133+
134+ emitter->anchors = yaml_malloc(sizeof(*(emitter->anchors))
135+ * (document->nodes.top - document->nodes.start));
136+ if (!emitter->anchors) goto error;
137+ memset(emitter->anchors, 0, sizeof(*(emitter->anchors))
138+ * (document->nodes.top - document->nodes.start));
139+
140+ DOCUMENT_START_EVENT_INIT(event, document->version_directive,
141+ document->tag_directives.start, document->tag_directives.end,
142+ document->start_implicit, mark, mark);
143+ if (!yaml_emitter_emit(emitter, &event)) goto error;
144+
145+ yaml_emitter_anchor_node(emitter, 1);
146+ if (!yaml_emitter_dump_node(emitter, 1)) goto error;
147+
148+ DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark);
149+ if (!yaml_emitter_emit(emitter, &event)) goto error;
150+
151+ yaml_emitter_delete_document_and_anchors(emitter);
152+
153+ return 1;
154+
155+error:
156+
157+ yaml_emitter_delete_document_and_anchors(emitter);
158+
159+ return 0;
160+}
161+
162+/*
163+ * Clean up the emitter object after a document is dumped.
164+ */
165+
166+static void
167+yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
168+{
169+ int index;
170+
171+ if (!emitter->anchors) {
172+ yaml_document_delete(emitter->document);
173+ emitter->document = NULL;
174+ return;
175+ }
176+
177+ for (index = 0; emitter->document->nodes.start + index
178+ < emitter->document->nodes.top; index ++) {
179+ yaml_node_t node = emitter->document->nodes.start[index];
180+ if (!emitter->anchors[index].serialized) {
181+ yaml_free(node.tag);
182+ if (node.type == YAML_SCALAR_NODE) {
183+ yaml_free(node.data.scalar.value);
184+ }
185+ }
186+ if (node.type == YAML_SEQUENCE_NODE) {
187+ STACK_DEL(emitter, node.data.sequence.items);
188+ }
189+ if (node.type == YAML_MAPPING_NODE) {
190+ STACK_DEL(emitter, node.data.mapping.pairs);
191+ }
192+ }
193+
194+ STACK_DEL(emitter, emitter->document->nodes);
195+ yaml_free(emitter->anchors);
196+
197+ emitter->anchors = NULL;
198+ emitter->last_anchor_id = 0;
199+ emitter->document = NULL;
200+}
201+
202+/*
203+ * Check the references of a node and assign the anchor id if needed.
204+ */
205+
206+static void
207+yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index)
208+{
209+ yaml_node_t *node = emitter->document->nodes.start + index - 1;
210+ yaml_node_item_t *item;
211+ yaml_node_pair_t *pair;
212+
213+ emitter->anchors[index-1].references ++;
214+
215+ if (emitter->anchors[index-1].references == 1) {
216+ switch (node->type) {
217+ case YAML_SEQUENCE_NODE:
218+ for (item = node->data.sequence.items.start;
219+ item < node->data.sequence.items.top; item ++) {
220+ yaml_emitter_anchor_node(emitter, *item);
221+ }
222+ break;
223+ case YAML_MAPPING_NODE:
224+ for (pair = node->data.mapping.pairs.start;
225+ pair < node->data.mapping.pairs.top; pair ++) {
226+ yaml_emitter_anchor_node(emitter, pair->key);
227+ yaml_emitter_anchor_node(emitter, pair->value);
228+ }
229+ break;
230+ default:
231+ break;
232+ }
233+ }
234+
235+ else if (emitter->anchors[index-1].references == 2) {
236+ emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id);
237+ }
238+}
239+
240+/*
241+ * Generate a textual representation for an anchor.
242+ */
243+
244+#define ANCHOR_TEMPLATE "id%03d"
245+#define ANCHOR_TEMPLATE_LENGTH 16
246+
247+static yaml_char_t *
248+yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id)
249+{
250+ yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);
251+
252+ if (!anchor) return NULL;
253+
254+ sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id);
255+
256+ return anchor;
257+}
258+
259+/*
260+ * Serialize a node.
261+ */
262+
263+static int
264+yaml_emitter_dump_node(yaml_emitter_t *emitter, int index)
265+{
266+ yaml_node_t *node = emitter->document->nodes.start + index - 1;
267+ int anchor_id = emitter->anchors[index-1].anchor;
268+ yaml_char_t *anchor = NULL;
269+
270+ if (anchor_id) {
271+ anchor = yaml_emitter_generate_anchor(emitter, anchor_id);
272+ if (!anchor) return 0;
273+ }
274+
275+ if (emitter->anchors[index-1].serialized) {
276+ return yaml_emitter_dump_alias(emitter, anchor);
277+ }
278+
279+ emitter->anchors[index-1].serialized = 1;
280+
281+ switch (node->type) {
282+ case YAML_SCALAR_NODE:
283+ return yaml_emitter_dump_scalar(emitter, node, anchor);
284+ case YAML_SEQUENCE_NODE:
285+ return yaml_emitter_dump_sequence(emitter, node, anchor);
286+ case YAML_MAPPING_NODE:
287+ return yaml_emitter_dump_mapping(emitter, node, anchor);
288+ default:
289+ assert(0); /* Could not happen. */
290+ break;
291+ }
292+
293+ return 0; /* Could not happen. */
294+}
295+
296+/*
297+ * Serialize an alias.
298+ */
299+
300+static int
301+yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor)
302+{
303+ yaml_event_t event;
304+ yaml_mark_t mark = { 0, 0, 0 };
305+
306+ ALIAS_EVENT_INIT(event, anchor, mark, mark);
307+
308+ return yaml_emitter_emit(emitter, &event);
309+}
310+
311+/*
312+ * Serialize a scalar.
313+ */
314+
315+static int
316+yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
317+ yaml_char_t *anchor)
318+{
319+ yaml_event_t event;
320+ yaml_mark_t mark = { 0, 0, 0 };
321+
322+ int plain_implicit = (strcmp((char *)node->tag,
323+ YAML_DEFAULT_SCALAR_TAG) == 0);
324+ int quoted_implicit = (strcmp((char *)node->tag,
325+ YAML_DEFAULT_SCALAR_TAG) == 0);
326+
327+ SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value,
328+ node->data.scalar.length, plain_implicit, quoted_implicit,
329+ node->data.scalar.style, mark, mark);
330+
331+ return yaml_emitter_emit(emitter, &event);
332+}
333+
334+/*
335+ * Serialize a sequence.
336+ */
337+
338+static int
339+yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
340+ yaml_char_t *anchor)
341+{
342+ yaml_event_t event;
343+ yaml_mark_t mark = { 0, 0, 0 };
344+
345+ int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0);
346+
347+ yaml_node_item_t *item;
348+
349+ SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit,
350+ node->data.sequence.style, mark, mark);
351+ if (!yaml_emitter_emit(emitter, &event)) return 0;
352+
353+ for (item = node->data.sequence.items.start;
354+ item < node->data.sequence.items.top; item ++) {
355+ if (!yaml_emitter_dump_node(emitter, *item)) return 0;
356+ }
357+
358+ SEQUENCE_END_EVENT_INIT(event, mark, mark);
359+ if (!yaml_emitter_emit(emitter, &event)) return 0;
360+
361+ return 1;
362+}
363+
364+/*
365+ * Serialize a mapping.
366+ */
367+
368+static int
369+yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
370+ yaml_char_t *anchor)
371+{
372+ yaml_event_t event;
373+ yaml_mark_t mark = { 0, 0, 0 };
374+
375+ int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0);
376+
377+ yaml_node_pair_t *pair;
378+
379+ MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit,
380+ node->data.mapping.style, mark, mark);
381+ if (!yaml_emitter_emit(emitter, &event)) return 0;
382+
383+ for (pair = node->data.mapping.pairs.start;
384+ pair < node->data.mapping.pairs.top; pair ++) {
385+ if (!yaml_emitter_dump_node(emitter, pair->key)) return 0;
386+ if (!yaml_emitter_dump_node(emitter, pair->value)) return 0;
387+ }
388+
389+ MAPPING_END_EVENT_INIT(event, mark, mark);
390+ if (!yaml_emitter_emit(emitter, &event)) return 0;
391+
392+ return 1;
393+}
394+
libyaml/emitter.cnew file+2329
@@ -0,0 +1,2329 @@
1+
2+#include "yaml_private.h"
3+
4+/*
5+ * Flush the buffer if needed.
6+ */
7+
8+#define FLUSH(emitter) \
9+ ((emitter->buffer.pointer+5 < emitter->buffer.end) \
10+ || yaml_emitter_flush(emitter))
11+
12+/*
13+ * Put a character to the output buffer.
14+ */
15+
16+#define PUT(emitter,value) \
17+ (FLUSH(emitter) \
18+ && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \
19+ emitter->column ++, \
20+ 1))
21+
22+/*
23+ * Put a line break to the output buffer.
24+ */
25+
26+#define PUT_BREAK(emitter) \
27+ (FLUSH(emitter) \
28+ && ((emitter->line_break == YAML_CR_BREAK ? \
29+ (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \
30+ emitter->line_break == YAML_LN_BREAK ? \
31+ (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \
32+ emitter->line_break == YAML_CRLN_BREAK ? \
33+ (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \
34+ *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \
35+ emitter->column = 0, \
36+ emitter->line ++, \
37+ 1))
38+
39+/*
40+ * Copy a character from a string into buffer.
41+ */
42+
43+#define WRITE(emitter,string) \
44+ (FLUSH(emitter) \
45+ && (COPY(emitter->buffer,string), \
46+ emitter->column ++, \
47+ 1))
48+
49+/*
50+ * Copy a line break character from a string into buffer.
51+ */
52+
53+#define WRITE_BREAK(emitter,string) \
54+ (FLUSH(emitter) \
55+ && (CHECK(string,'\n') ? \
56+ (PUT_BREAK(emitter), \
57+ string.pointer ++, \
58+ 1) : \
59+ (COPY(emitter->buffer,string), \
60+ emitter->column = 0, \
61+ emitter->line ++, \
62+ 1)))
63+
64+/*
65+ * API functions.
66+ */
67+
68+YAML_DECLARE(int)
69+yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
70+
71+/*
72+ * Utility functions.
73+ */
74+
75+static int
76+yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem);
77+
78+static int
79+yaml_emitter_need_more_events(yaml_emitter_t *emitter);
80+
81+static int
82+yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
83+ yaml_tag_directive_t value, int allow_duplicates);
84+
85+static int
86+yaml_emitter_increase_indent(yaml_emitter_t *emitter,
87+ int flow, int indentless);
88+
89+/*
90+ * State functions.
91+ */
92+
93+static int
94+yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event);
95+
96+static int
97+yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
98+ yaml_event_t *event);
99+
100+static int
101+yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
102+ yaml_event_t *event, int first);
103+
104+static int
105+yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
106+ yaml_event_t *event);
107+
108+static int
109+yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
110+ yaml_event_t *event);
111+
112+static int
113+yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
114+ yaml_event_t *event, int first);
115+
116+static int
117+yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
118+ yaml_event_t *event, int first);
119+
120+static int
121+yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
122+ yaml_event_t *event, int simple);
123+
124+static int
125+yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
126+ yaml_event_t *event, int first);
127+
128+static int
129+yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
130+ yaml_event_t *event, int first);
131+
132+static int
133+yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
134+ yaml_event_t *event, int simple);
135+
136+static int
137+yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
138+ int root, int sequence, int mapping, int simple_key);
139+
140+static int
141+yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event);
142+
143+static int
144+yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event);
145+
146+static int
147+yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event);
148+
149+static int
150+yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event);
151+
152+/*
153+ * Checkers.
154+ */
155+
156+static int
157+yaml_emitter_check_empty_document(yaml_emitter_t *emitter);
158+
159+static int
160+yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
161+
162+static int
163+yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
164+
165+static int
166+yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
167+
168+static int
169+yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event);
170+
171+/*
172+ * Processors.
173+ */
174+
175+static int
176+yaml_emitter_process_anchor(yaml_emitter_t *emitter);
177+
178+static int
179+yaml_emitter_process_tag(yaml_emitter_t *emitter);
180+
181+static int
182+yaml_emitter_process_scalar(yaml_emitter_t *emitter);
183+
184+/*
185+ * Analyzers.
186+ */
187+
188+static int
189+yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
190+ yaml_version_directive_t version_directive);
191+
192+static int
193+yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
194+ yaml_tag_directive_t tag_directive);
195+
196+static int
197+yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
198+ yaml_char_t *anchor, int alias);
199+
200+static int
201+yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
202+ yaml_char_t *tag);
203+
204+static int
205+yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
206+ yaml_char_t *value, size_t length);
207+
208+static int
209+yaml_emitter_analyze_event(yaml_emitter_t *emitter,
210+ yaml_event_t *event);
211+
212+/*
213+ * Writers.
214+ */
215+
216+static int
217+yaml_emitter_write_bom(yaml_emitter_t *emitter);
218+
219+static int
220+yaml_emitter_write_indent(yaml_emitter_t *emitter);
221+
222+static int
223+yaml_emitter_write_indicator(yaml_emitter_t *emitter,
224+ char *indicator, int need_whitespace,
225+ int is_whitespace, int is_indention);
226+
227+static int
228+yaml_emitter_write_anchor(yaml_emitter_t *emitter,
229+ yaml_char_t *value, size_t length);
230+
231+static int
232+yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
233+ yaml_char_t *value, size_t length);
234+
235+static int
236+yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
237+ yaml_char_t *value, size_t length, int need_whitespace);
238+
239+static int
240+yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
241+ yaml_char_t *value, size_t length, int allow_breaks);
242+
243+static int
244+yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
245+ yaml_char_t *value, size_t length, int allow_breaks);
246+
247+static int
248+yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
249+ yaml_char_t *value, size_t length, int allow_breaks);
250+
251+static int
252+yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
253+ yaml_string_t string);
254+
255+static int
256+yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
257+ yaml_char_t *value, size_t length);
258+
259+static int
260+yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
261+ yaml_char_t *value, size_t length);
262+
263+/*
264+ * Set an emitter error and return 0.
265+ */
266+
267+static int
268+yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem)
269+{
270+ emitter->error = YAML_EMITTER_ERROR;
271+ emitter->problem = problem;
272+
273+ return 0;
274+}
275+
276+/*
277+ * Emit an event.
278+ */
279+
280+YAML_DECLARE(int)
281+yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
282+{
283+ if (!ENQUEUE(emitter, emitter->events, *event)) {
284+ yaml_event_delete(event);
285+ return 0;
286+ }
287+
288+ while (!yaml_emitter_need_more_events(emitter)) {
289+ if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
290+ return 0;
291+ if (!yaml_emitter_state_machine(emitter, emitter->events.head))
292+ return 0;
293+ yaml_event_delete(&DEQUEUE(emitter, emitter->events));
294+ }
295+
296+ return 1;
297+}
298+
299+/*
300+ * Check if we need to accumulate more events before emitting.
301+ *
302+ * We accumulate extra
303+ * - 1 event for DOCUMENT-START
304+ * - 2 events for SEQUENCE-START
305+ * - 3 events for MAPPING-START
306+ */
307+
308+static int
309+yaml_emitter_need_more_events(yaml_emitter_t *emitter)
310+{
311+ int level = 0;
312+ int accumulate = 0;
313+ yaml_event_t *event;
314+
315+ if (QUEUE_EMPTY(emitter, emitter->events))
316+ return 1;
317+
318+ switch (emitter->events.head->type) {
319+ case YAML_DOCUMENT_START_EVENT:
320+ accumulate = 1;
321+ break;
322+ case YAML_SEQUENCE_START_EVENT:
323+ accumulate = 2;
324+ break;
325+ case YAML_MAPPING_START_EVENT:
326+ accumulate = 3;
327+ break;
328+ default:
329+ return 0;
330+ }
331+
332+ if (emitter->events.tail - emitter->events.head > accumulate)
333+ return 0;
334+
335+ for (event = emitter->events.head; event != emitter->events.tail; event ++) {
336+ switch (event->type) {
337+ case YAML_STREAM_START_EVENT:
338+ case YAML_DOCUMENT_START_EVENT:
339+ case YAML_SEQUENCE_START_EVENT:
340+ case YAML_MAPPING_START_EVENT:
341+ level += 1;
342+ break;
343+ case YAML_STREAM_END_EVENT:
344+ case YAML_DOCUMENT_END_EVENT:
345+ case YAML_SEQUENCE_END_EVENT:
346+ case YAML_MAPPING_END_EVENT:
347+ level -= 1;
348+ break;
349+ default:
350+ break;
351+ }
352+ if (!level)
353+ return 0;
354+ }
355+
356+ return 1;
357+}
358+
359+/*
360+ * Append a directive to the directives stack.
361+ */
362+
363+static int
364+yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
365+ yaml_tag_directive_t value, int allow_duplicates)
366+{
367+ yaml_tag_directive_t *tag_directive;
368+ yaml_tag_directive_t copy = { NULL, NULL };
369+
370+ for (tag_directive = emitter->tag_directives.start;
371+ tag_directive != emitter->tag_directives.top; tag_directive ++) {
372+ if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
373+ if (allow_duplicates)
374+ return 1;
375+ return yaml_emitter_set_emitter_error(emitter,
376+ "duplicate %TAG directive");
377+ }
378+ }
379+
380+ copy.handle = yaml_strdup(value.handle);
381+ copy.prefix = yaml_strdup(value.prefix);
382+ if (!copy.handle || !copy.prefix) {
383+ emitter->error = YAML_MEMORY_ERROR;
384+ goto error;
385+ }
386+
387+ if (!PUSH(emitter, emitter->tag_directives, copy))
388+ goto error;
389+
390+ return 1;
391+
392+error:
393+ yaml_free(copy.handle);
394+ yaml_free(copy.prefix);
395+ return 0;
396+}
397+
398+/*
399+ * Increase the indentation level.
400+ */
401+
402+static int
403+yaml_emitter_increase_indent(yaml_emitter_t *emitter,
404+ int flow, int indentless)
405+{
406+ if (!PUSH(emitter, emitter->indents, emitter->indent))
407+ return 0;
408+
409+ if (emitter->indent < 0) {
410+ emitter->indent = flow ? emitter->best_indent : 0;
411+ }
412+ else if (!indentless) {
413+ emitter->indent += emitter->best_indent;
414+ }
415+
416+ return 1;
417+}
418+
419+/*
420+ * State dispatcher.
421+ */
422+
423+static int
424+yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event)
425+{
426+ switch (emitter->state)
427+ {
428+ case YAML_EMIT_STREAM_START_STATE:
429+ return yaml_emitter_emit_stream_start(emitter, event);
430+
431+ case YAML_EMIT_FIRST_DOCUMENT_START_STATE:
432+ return yaml_emitter_emit_document_start(emitter, event, 1);
433+
434+ case YAML_EMIT_DOCUMENT_START_STATE:
435+ return yaml_emitter_emit_document_start(emitter, event, 0);
436+
437+ case YAML_EMIT_DOCUMENT_CONTENT_STATE:
438+ return yaml_emitter_emit_document_content(emitter, event);
439+
440+ case YAML_EMIT_DOCUMENT_END_STATE:
441+ return yaml_emitter_emit_document_end(emitter, event);
442+
443+ case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
444+ return yaml_emitter_emit_flow_sequence_item(emitter, event, 1);
445+
446+ case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE:
447+ return yaml_emitter_emit_flow_sequence_item(emitter, event, 0);
448+
449+ case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
450+ return yaml_emitter_emit_flow_mapping_key(emitter, event, 1);
451+
452+ case YAML_EMIT_FLOW_MAPPING_KEY_STATE:
453+ return yaml_emitter_emit_flow_mapping_key(emitter, event, 0);
454+
455+ case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
456+ return yaml_emitter_emit_flow_mapping_value(emitter, event, 1);
457+
458+ case YAML_EMIT_FLOW_MAPPING_VALUE_STATE:
459+ return yaml_emitter_emit_flow_mapping_value(emitter, event, 0);
460+
461+ case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
462+ return yaml_emitter_emit_block_sequence_item(emitter, event, 1);
463+
464+ case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
465+ return yaml_emitter_emit_block_sequence_item(emitter, event, 0);
466+
467+ case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
468+ return yaml_emitter_emit_block_mapping_key(emitter, event, 1);
469+
470+ case YAML_EMIT_BLOCK_MAPPING_KEY_STATE:
471+ return yaml_emitter_emit_block_mapping_key(emitter, event, 0);
472+
473+ case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
474+ return yaml_emitter_emit_block_mapping_value(emitter, event, 1);
475+
476+ case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE:
477+ return yaml_emitter_emit_block_mapping_value(emitter, event, 0);
478+
479+ case YAML_EMIT_END_STATE:
480+ return yaml_emitter_set_emitter_error(emitter,
481+ "expected nothing after STREAM-END");
482+
483+ default:
484+ assert(1); /* Invalid state. */
485+ }
486+
487+ return 0;
488+}
489+
490+/*
491+ * Expect STREAM-START.
492+ */
493+
494+static int
495+yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
496+ yaml_event_t *event)
497+{
498+ if (event->type == YAML_STREAM_START_EVENT)
499+ {
500+ if (!emitter->encoding) {
501+ emitter->encoding = event->data.stream_start.encoding;
502+ }
503+
504+ if (!emitter->encoding) {
505+ emitter->encoding = YAML_UTF8_ENCODING;
506+ }
507+
508+ if (emitter->best_indent < 2 || emitter->best_indent > 9) {
509+ emitter->best_indent = 2;
510+ }
511+
512+ if (emitter->best_width >= 0
513+ && emitter->best_width <= emitter->best_indent*2) {
514+ emitter->best_width = 80;
515+ }
516+
517+ if (emitter->best_width < 0) {
518+ emitter->best_width = INT_MAX;
519+ }
520+
521+ if (!emitter->line_break) {
522+ emitter->line_break = YAML_LN_BREAK;
523+ }
524+
525+ emitter->indent = -1;
526+
527+ emitter->line = 0;
528+ emitter->column = 0;
529+ emitter->whitespace = 1;
530+ emitter->indention = 1;
531+
532+ if (emitter->encoding != YAML_UTF8_ENCODING) {
533+ if (!yaml_emitter_write_bom(emitter))
534+ return 0;
535+ }
536+
537+ emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;
538+
539+ return 1;
540+ }
541+
542+ return yaml_emitter_set_emitter_error(emitter,
543+ "expected STREAM-START");
544+}
545+
546+/*
547+ * Expect DOCUMENT-START or STREAM-END.
548+ */
549+
550+static int
551+yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
552+ yaml_event_t *event, int first)
553+{
554+ if (event->type == YAML_DOCUMENT_START_EVENT)
555+ {
556+ yaml_tag_directive_t default_tag_directives[] = {
557+ {(yaml_char_t *)"!", (yaml_char_t *)"!"},
558+ {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
559+ {NULL, NULL}
560+ };
561+ yaml_tag_directive_t *tag_directive;
562+ int implicit;
563+
564+ if (event->data.document_start.version_directive) {
565+ if (!yaml_emitter_analyze_version_directive(emitter,
566+ *event->data.document_start.version_directive))
567+ return 0;
568+ }
569+
570+ for (tag_directive = event->data.document_start.tag_directives.start;
571+ tag_directive != event->data.document_start.tag_directives.end;
572+ tag_directive ++) {
573+ if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive))
574+ return 0;
575+ if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0))
576+ return 0;
577+ }
578+
579+ for (tag_directive = default_tag_directives;
580+ tag_directive->handle; tag_directive ++) {
581+ if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1))
582+ return 0;
583+ }
584+
585+ implicit = event->data.document_start.implicit;
586+ if (!first || emitter->canonical) {
587+ implicit = 0;
588+ }
589+
590+ if ((event->data.document_start.version_directive ||
591+ (event->data.document_start.tag_directives.start
592+ != event->data.document_start.tag_directives.end)) &&
593+ emitter->open_ended)
594+ {
595+ if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
596+ return 0;
597+ if (!yaml_emitter_write_indent(emitter))
598+ return 0;
599+ }
600+
601+ if (event->data.document_start.version_directive) {
602+ implicit = 0;
603+ if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0))
604+ return 0;
605+ if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0))
606+ return 0;
607+ if (!yaml_emitter_write_indent(emitter))
608+ return 0;
609+ }
610+
611+ if (event->data.document_start.tag_directives.start
612+ != event->data.document_start.tag_directives.end) {
613+ implicit = 0;
614+ for (tag_directive = event->data.document_start.tag_directives.start;
615+ tag_directive != event->data.document_start.tag_directives.end;
616+ tag_directive ++) {
617+ if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0))
618+ return 0;
619+ if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle,
620+ strlen((char *)tag_directive->handle)))
621+ return 0;
622+ if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix,
623+ strlen((char *)tag_directive->prefix), 1))
624+ return 0;
625+ if (!yaml_emitter_write_indent(emitter))
626+ return 0;
627+ }
628+ }
629+
630+ if (yaml_emitter_check_empty_document(emitter)) {
631+ implicit = 0;
632+ }
633+
634+ if (!implicit) {
635+ if (!yaml_emitter_write_indent(emitter))
636+ return 0;
637+ if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0))
638+ return 0;
639+ if (emitter->canonical) {
640+ if (!yaml_emitter_write_indent(emitter))
641+ return 0;
642+ }
643+ }
644+
645+ emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
646+
647+ return 1;
648+ }
649+
650+ else if (event->type == YAML_STREAM_END_EVENT)
651+ {
652+ if (emitter->open_ended)
653+ {
654+ if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
655+ return 0;
656+ if (!yaml_emitter_write_indent(emitter))
657+ return 0;
658+ }
659+
660+ if (!yaml_emitter_flush(emitter))
661+ return 0;
662+
663+ emitter->state = YAML_EMIT_END_STATE;
664+
665+ return 1;
666+ }
667+
668+ return yaml_emitter_set_emitter_error(emitter,
669+ "expected DOCUMENT-START or STREAM-END");
670+}
671+
672+/*
673+ * Expect the root node.
674+ */
675+
676+static int
677+yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
678+ yaml_event_t *event)
679+{
680+ if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE))
681+ return 0;
682+
683+ return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0);
684+}
685+
686+/*
687+ * Expect DOCUMENT-END.
688+ */
689+
690+static int
691+yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
692+ yaml_event_t *event)
693+{
694+ if (event->type == YAML_DOCUMENT_END_EVENT)
695+ {
696+ if (!yaml_emitter_write_indent(emitter))
697+ return 0;
698+ if (!event->data.document_end.implicit) {
699+ if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
700+ return 0;
701+ if (!yaml_emitter_write_indent(emitter))
702+ return 0;
703+ }
704+ if (!yaml_emitter_flush(emitter))
705+ return 0;
706+
707+ emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
708+
709+ while (!STACK_EMPTY(emitter, emitter->tag_directives)) {
710+ yaml_tag_directive_t tag_directive = POP(emitter,
711+ emitter->tag_directives);
712+ yaml_free(tag_directive.handle);
713+ yaml_free(tag_directive.prefix);
714+ }
715+
716+ return 1;
717+ }
718+
719+ return yaml_emitter_set_emitter_error(emitter,
720+ "expected DOCUMENT-END");
721+}
722+
723+/*
724+ *
725+ * Expect a flow item node.
726+ */
727+
728+static int
729+yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
730+ yaml_event_t *event, int first)
731+{
732+ if (first)
733+ {
734+ if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0))
735+ return 0;
736+ if (!yaml_emitter_increase_indent(emitter, 1, 0))
737+ return 0;
738+ emitter->flow_level ++;
739+ }
740+
741+ if (event->type == YAML_SEQUENCE_END_EVENT)
742+ {
743+ emitter->flow_level --;
744+ emitter->indent = POP(emitter, emitter->indents);
745+ if (emitter->canonical && !first) {
746+ if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
747+ return 0;
748+ if (!yaml_emitter_write_indent(emitter))
749+ return 0;
750+ }
751+ if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0))
752+ return 0;
753+ emitter->state = POP(emitter, emitter->states);
754+
755+ return 1;
756+ }
757+
758+ if (!first) {
759+ if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
760+ return 0;
761+ }
762+
763+ if (emitter->canonical || emitter->column > emitter->best_width) {
764+ if (!yaml_emitter_write_indent(emitter))
765+ return 0;
766+ }
767+ if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE))
768+ return 0;
769+
770+ return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
771+}
772+
773+/*
774+ * Expect a flow key node.
775+ */
776+
777+static int
778+yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
779+ yaml_event_t *event, int first)
780+{
781+ if (first)
782+ {
783+ if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0))
784+ return 0;
785+ if (!yaml_emitter_increase_indent(emitter, 1, 0))
786+ return 0;
787+ emitter->flow_level ++;
788+ }
789+
790+ if (event->type == YAML_MAPPING_END_EVENT)
791+ {
792+ emitter->flow_level --;
793+ emitter->indent = POP(emitter, emitter->indents);
794+ if (emitter->canonical && !first) {
795+ if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
796+ return 0;
797+ if (!yaml_emitter_write_indent(emitter))
798+ return 0;
799+ }
800+ if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0))
801+ return 0;
802+ emitter->state = POP(emitter, emitter->states);
803+
804+ return 1;
805+ }
806+
807+ if (!first) {
808+ if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
809+ return 0;
810+ }
811+ if (emitter->canonical || emitter->column > emitter->best_width) {
812+ if (!yaml_emitter_write_indent(emitter))
813+ return 0;
814+ }
815+
816+ if (!emitter->canonical && yaml_emitter_check_simple_key(emitter))
817+ {
818+ if (!PUSH(emitter, emitter->states,
819+ YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE))
820+ return 0;
821+
822+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
823+ }
824+ else
825+ {
826+ if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0))
827+ return 0;
828+ if (!PUSH(emitter, emitter->states,
829+ YAML_EMIT_FLOW_MAPPING_VALUE_STATE))
830+ return 0;
831+
832+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
833+ }
834+}
835+
836+/*
837+ * Expect a flow value node.
838+ */
839+
840+static int
841+yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
842+ yaml_event_t *event, int simple)
843+{
844+ if (simple) {
845+ if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
846+ return 0;
847+ }
848+ else {
849+ if (emitter->canonical || emitter->column > emitter->best_width) {
850+ if (!yaml_emitter_write_indent(emitter))
851+ return 0;
852+ }
853+ if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0))
854+ return 0;
855+ }
856+ if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE))
857+ return 0;
858+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
859+}
860+
861+/*
862+ * Expect a block item node.
863+ */
864+
865+static int
866+yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
867+ yaml_event_t *event, int first)
868+{
869+ if (first)
870+ {
871+ if (!yaml_emitter_increase_indent(emitter, 0,
872+ (emitter->mapping_context && !emitter->indention)))
873+ return 0;
874+ }
875+
876+ if (event->type == YAML_SEQUENCE_END_EVENT)
877+ {
878+ emitter->indent = POP(emitter, emitter->indents);
879+ emitter->state = POP(emitter, emitter->states);
880+
881+ return 1;
882+ }
883+
884+ if (!yaml_emitter_write_indent(emitter))
885+ return 0;
886+ if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1))
887+ return 0;
888+ if (!PUSH(emitter, emitter->states,
889+ YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE))
890+ return 0;
891+
892+ return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
893+}
894+
895+/*
896+ * Expect a block key node.
897+ */
898+
899+static int
900+yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
901+ yaml_event_t *event, int first)
902+{
903+ if (first)
904+ {
905+ if (!yaml_emitter_increase_indent(emitter, 0, 0))
906+ return 0;
907+ }
908+
909+ if (event->type == YAML_MAPPING_END_EVENT)
910+ {
911+ emitter->indent = POP(emitter, emitter->indents);
912+ emitter->state = POP(emitter, emitter->states);
913+
914+ return 1;
915+ }
916+
917+ if (!yaml_emitter_write_indent(emitter))
918+ return 0;
919+
920+ if (yaml_emitter_check_simple_key(emitter))
921+ {
922+ if (!PUSH(emitter, emitter->states,
923+ YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE))
924+ return 0;
925+
926+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
927+ }
928+ else
929+ {
930+ if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1))
931+ return 0;
932+ if (!PUSH(emitter, emitter->states,
933+ YAML_EMIT_BLOCK_MAPPING_VALUE_STATE))
934+ return 0;
935+
936+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
937+ }
938+}
939+
940+/*
941+ * Expect a block value node.
942+ */
943+
944+static int
945+yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
946+ yaml_event_t *event, int simple)
947+{
948+ if (simple) {
949+ if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
950+ return 0;
951+ }
952+ else {
953+ if (!yaml_emitter_write_indent(emitter))
954+ return 0;
955+ if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1))
956+ return 0;
957+ }
958+ if (!PUSH(emitter, emitter->states,
959+ YAML_EMIT_BLOCK_MAPPING_KEY_STATE))
960+ return 0;
961+
962+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
963+}
964+
965+/*
966+ * Expect a node.
967+ */
968+
969+static int
970+yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
971+ int root, int sequence, int mapping, int simple_key)
972+{
973+ emitter->root_context = root;
974+ emitter->sequence_context = sequence;
975+ emitter->mapping_context = mapping;
976+ emitter->simple_key_context = simple_key;
977+
978+ switch (event->type)
979+ {
980+ case YAML_ALIAS_EVENT:
981+ return yaml_emitter_emit_alias(emitter, event);
982+
983+ case YAML_SCALAR_EVENT:
984+ return yaml_emitter_emit_scalar(emitter, event);
985+
986+ case YAML_SEQUENCE_START_EVENT:
987+ return yaml_emitter_emit_sequence_start(emitter, event);
988+
989+ case YAML_MAPPING_START_EVENT:
990+ return yaml_emitter_emit_mapping_start(emitter, event);
991+
992+ default:
993+ return yaml_emitter_set_emitter_error(emitter,
994+ "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
995+ }
996+
997+ return 0;
998+}
999+
1000+/*
1001+ * Expect ALIAS.
1002+ */
1003+
1004+static int
1005+yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event)
1006+{
1007+ if (!yaml_emitter_process_anchor(emitter))
1008+ return 0;
1009+ emitter->state = POP(emitter, emitter->states);
1010+
1011+ return 1;
1012+}
1013+
1014+/*
1015+ * Expect SCALAR.
1016+ */
1017+
1018+static int
1019+yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event)
1020+{
1021+ if (!yaml_emitter_select_scalar_style(emitter, event))
1022+ return 0;
1023+ if (!yaml_emitter_process_anchor(emitter))
1024+ return 0;
1025+ if (!yaml_emitter_process_tag(emitter))
1026+ return 0;
1027+ if (!yaml_emitter_increase_indent(emitter, 1, 0))
1028+ return 0;
1029+ if (!yaml_emitter_process_scalar(emitter))
1030+ return 0;
1031+ emitter->indent = POP(emitter, emitter->indents);
1032+ emitter->state = POP(emitter, emitter->states);
1033+
1034+ return 1;
1035+}
1036+
1037+/*
1038+ * Expect SEQUENCE-START.
1039+ */
1040+
1041+static int
1042+yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event)
1043+{
1044+ if (!yaml_emitter_process_anchor(emitter))
1045+ return 0;
1046+ if (!yaml_emitter_process_tag(emitter))
1047+ return 0;
1048+
1049+ if (emitter->flow_level || emitter->canonical
1050+ || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE
1051+ || yaml_emitter_check_empty_sequence(emitter)) {
1052+ emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
1053+ }
1054+ else {
1055+ emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
1056+ }
1057+
1058+ return 1;
1059+}
1060+
1061+/*
1062+ * Expect MAPPING-START.
1063+ */
1064+
1065+static int
1066+yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
1067+{
1068+ if (!yaml_emitter_process_anchor(emitter))
1069+ return 0;
1070+ if (!yaml_emitter_process_tag(emitter))
1071+ return 0;
1072+
1073+ if (emitter->flow_level || emitter->canonical
1074+ || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE
1075+ || yaml_emitter_check_empty_mapping(emitter)) {
1076+ emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
1077+ }
1078+ else {
1079+ emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
1080+ }
1081+
1082+ return 1;
1083+}
1084+
1085+/*
1086+ * Check if the document content is an empty scalar.
1087+ */
1088+
1089+static int
1090+yaml_emitter_check_empty_document(yaml_emitter_t *emitter)
1091+{
1092+ return 0;
1093+}
1094+
1095+/*
1096+ * Check if the next events represent an empty sequence.
1097+ */
1098+
1099+static int
1100+yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
1101+{
1102+ if (emitter->events.tail - emitter->events.head < 2)
1103+ return 0;
1104+
1105+ return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT
1106+ && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT);
1107+}
1108+
1109+/*
1110+ * Check if the next events represent an empty mapping.
1111+ */
1112+
1113+static int
1114+yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
1115+{
1116+ if (emitter->events.tail - emitter->events.head < 2)
1117+ return 0;
1118+
1119+ return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT
1120+ && emitter->events.head[1].type == YAML_MAPPING_END_EVENT);
1121+}
1122+
1123+/*
1124+ * Check if the next node can be expressed as a simple key.
1125+ */
1126+
1127+static int
1128+yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
1129+{
1130+ yaml_event_t *event = emitter->events.head;
1131+ size_t length = 0;
1132+
1133+ switch (event->type)
1134+ {
1135+ case YAML_ALIAS_EVENT:
1136+ length += emitter->anchor_data.anchor_length;
1137+ break;
1138+
1139+ case YAML_SCALAR_EVENT:
1140+ if (emitter->scalar_data.multiline)
1141+ return 0;
1142+ length += emitter->anchor_data.anchor_length
1143+ + emitter->tag_data.handle_length
1144+ + emitter->tag_data.suffix_length
1145+ + emitter->scalar_data.length;
1146+ break;
1147+
1148+ case YAML_SEQUENCE_START_EVENT:
1149+ if (!yaml_emitter_check_empty_sequence(emitter))
1150+ return 0;
1151+ length += emitter->anchor_data.anchor_length
1152+ + emitter->tag_data.handle_length
1153+ + emitter->tag_data.suffix_length;
1154+ break;
1155+
1156+ case YAML_MAPPING_START_EVENT:
1157+ if (!yaml_emitter_check_empty_mapping(emitter))
1158+ return 0;
1159+ length += emitter->anchor_data.anchor_length
1160+ + emitter->tag_data.handle_length
1161+ + emitter->tag_data.suffix_length;
1162+ break;
1163+
1164+ default:
1165+ return 0;
1166+ }
1167+
1168+ if (length > 128)
1169+ return 0;
1170+
1171+ return 1;
1172+}
1173+
1174+/*
1175+ * Determine an acceptable scalar style.
1176+ */
1177+
1178+static int
1179+yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event)
1180+{
1181+ yaml_scalar_style_t style = event->data.scalar.style;
1182+ int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix);
1183+
1184+ if (no_tag && !event->data.scalar.plain_implicit
1185+ && !event->data.scalar.quoted_implicit) {
1186+ return yaml_emitter_set_emitter_error(emitter,
1187+ "neither tag nor implicit flags are specified");
1188+ }
1189+
1190+ if (style == YAML_ANY_SCALAR_STYLE)
1191+ style = YAML_PLAIN_SCALAR_STYLE;
1192+
1193+ if (emitter->canonical)
1194+ style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1195+
1196+ if (emitter->simple_key_context && emitter->scalar_data.multiline)
1197+ style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1198+
1199+ if (style == YAML_PLAIN_SCALAR_STYLE)
1200+ {
1201+ if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed)
1202+ || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed))
1203+ style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1204+ if (!emitter->scalar_data.length
1205+ && (emitter->flow_level || emitter->simple_key_context))
1206+ style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1207+ if (no_tag && !event->data.scalar.plain_implicit)
1208+ style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1209+ }
1210+
1211+ if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE)
1212+ {
1213+ if (!emitter->scalar_data.single_quoted_allowed)
1214+ style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1215+ }
1216+
1217+ if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE)
1218+ {
1219+ if (!emitter->scalar_data.block_allowed
1220+ || emitter->flow_level || emitter->simple_key_context)
1221+ style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1222+ }
1223+
1224+ if (no_tag && !event->data.scalar.quoted_implicit
1225+ && style != YAML_PLAIN_SCALAR_STYLE)
1226+ {
1227+ emitter->tag_data.handle = (yaml_char_t *)"!";
1228+ emitter->tag_data.handle_length = 1;
1229+ }
1230+
1231+ emitter->scalar_data.style = style;
1232+
1233+ return 1;
1234+}
1235+
1236+/*
1237+ * Write an achor.
1238+ */
1239+
1240+static int
1241+yaml_emitter_process_anchor(yaml_emitter_t *emitter)
1242+{
1243+ if (!emitter->anchor_data.anchor)
1244+ return 1;
1245+
1246+ if (!yaml_emitter_write_indicator(emitter,
1247+ (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0))
1248+ return 0;
1249+
1250+ return yaml_emitter_write_anchor(emitter,
1251+ emitter->anchor_data.anchor, emitter->anchor_data.anchor_length);
1252+}
1253+
1254+/*
1255+ * Write a tag.
1256+ */
1257+
1258+static int
1259+yaml_emitter_process_tag(yaml_emitter_t *emitter)
1260+{
1261+ if (!emitter->tag_data.handle && !emitter->tag_data.suffix)
1262+ return 1;
1263+
1264+ if (emitter->tag_data.handle)
1265+ {
1266+ if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle,
1267+ emitter->tag_data.handle_length))
1268+ return 0;
1269+ if (emitter->tag_data.suffix) {
1270+ if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
1271+ emitter->tag_data.suffix_length, 0))
1272+ return 0;
1273+ }
1274+ }
1275+ else
1276+ {
1277+ if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0))
1278+ return 0;
1279+ if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
1280+ emitter->tag_data.suffix_length, 0))
1281+ return 0;
1282+ if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0))
1283+ return 0;
1284+ }
1285+
1286+ return 1;
1287+}
1288+
1289+/*
1290+ * Write a scalar.
1291+ */
1292+
1293+static int
1294+yaml_emitter_process_scalar(yaml_emitter_t *emitter)
1295+{
1296+ switch (emitter->scalar_data.style)
1297+ {
1298+ case YAML_PLAIN_SCALAR_STYLE:
1299+ return yaml_emitter_write_plain_scalar(emitter,
1300+ emitter->scalar_data.value, emitter->scalar_data.length,
1301+ !emitter->simple_key_context);
1302+
1303+ case YAML_SINGLE_QUOTED_SCALAR_STYLE:
1304+ return yaml_emitter_write_single_quoted_scalar(emitter,
1305+ emitter->scalar_data.value, emitter->scalar_data.length,
1306+ !emitter->simple_key_context);
1307+
1308+ case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
1309+ return yaml_emitter_write_double_quoted_scalar(emitter,
1310+ emitter->scalar_data.value, emitter->scalar_data.length,
1311+ !emitter->simple_key_context);
1312+
1313+ case YAML_LITERAL_SCALAR_STYLE:
1314+ return yaml_emitter_write_literal_scalar(emitter,
1315+ emitter->scalar_data.value, emitter->scalar_data.length);
1316+
1317+ case YAML_FOLDED_SCALAR_STYLE:
1318+ return yaml_emitter_write_folded_scalar(emitter,
1319+ emitter->scalar_data.value, emitter->scalar_data.length);
1320+
1321+ default:
1322+ assert(1); /* Impossible. */
1323+ }
1324+
1325+ return 0;
1326+}
1327+
1328+/*
1329+ * Check if a %YAML directive is valid.
1330+ */
1331+
1332+static int
1333+yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
1334+ yaml_version_directive_t version_directive)
1335+{
1336+ if (version_directive.major != 1 || version_directive.minor != 1) {
1337+ return yaml_emitter_set_emitter_error(emitter,
1338+ "incompatible %YAML directive");
1339+ }
1340+
1341+ return 1;
1342+}
1343+
1344+/*
1345+ * Check if a %TAG directive is valid.
1346+ */
1347+
1348+static int
1349+yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
1350+ yaml_tag_directive_t tag_directive)
1351+{
1352+ yaml_string_t handle;
1353+ yaml_string_t prefix;
1354+ size_t handle_length;
1355+ size_t prefix_length;
1356+
1357+ handle_length = strlen((char *)tag_directive.handle);
1358+ prefix_length = strlen((char *)tag_directive.prefix);
1359+ STRING_ASSIGN(handle, tag_directive.handle, handle_length);
1360+ STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length);
1361+
1362+ if (handle.start == handle.end) {
1363+ return yaml_emitter_set_emitter_error(emitter,
1364+ "tag handle must not be empty");
1365+ }
1366+
1367+ if (handle.start[0] != '!') {
1368+ return yaml_emitter_set_emitter_error(emitter,
1369+ "tag handle must start with '!'");
1370+ }
1371+
1372+ if (handle.end[-1] != '!') {
1373+ return yaml_emitter_set_emitter_error(emitter,
1374+ "tag handle must end with '!'");
1375+ }
1376+
1377+ handle.pointer ++;
1378+
1379+ while (handle.pointer < handle.end-1) {
1380+ if (!IS_ALPHA(handle)) {
1381+ return yaml_emitter_set_emitter_error(emitter,
1382+ "tag handle must contain alphanumerical characters only");
1383+ }
1384+ MOVE(handle);
1385+ }
1386+
1387+ if (prefix.start == prefix.end) {
1388+ return yaml_emitter_set_emitter_error(emitter,
1389+ "tag prefix must not be empty");
1390+ }
1391+
1392+ return 1;
1393+}
1394+
1395+/*
1396+ * Check if an anchor is valid.
1397+ */
1398+
1399+static int
1400+yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
1401+ yaml_char_t *anchor, int alias)
1402+{
1403+ size_t anchor_length;
1404+ yaml_string_t string;
1405+
1406+ anchor_length = strlen((char *)anchor);
1407+ STRING_ASSIGN(string, anchor, anchor_length);
1408+
1409+ if (string.start == string.end) {
1410+ return yaml_emitter_set_emitter_error(emitter, alias ?
1411+ "alias value must not be empty" :
1412+ "anchor value must not be empty");
1413+ }
1414+
1415+ while (string.pointer != string.end) {
1416+ if (!IS_ALPHA(string)) {
1417+ return yaml_emitter_set_emitter_error(emitter, alias ?
1418+ "alias value must contain alphanumerical characters only" :
1419+ "anchor value must contain alphanumerical characters only");
1420+ }
1421+ MOVE(string);
1422+ }
1423+
1424+ emitter->anchor_data.anchor = string.start;
1425+ emitter->anchor_data.anchor_length = string.end - string.start;
1426+ emitter->anchor_data.alias = alias;
1427+
1428+ return 1;
1429+}
1430+
1431+/*
1432+ * Check if a tag is valid.
1433+ */
1434+
1435+static int
1436+yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
1437+ yaml_char_t *tag)
1438+{
1439+ size_t tag_length;
1440+ yaml_string_t string;
1441+ yaml_tag_directive_t *tag_directive;
1442+
1443+ tag_length = strlen((char *)tag);
1444+ STRING_ASSIGN(string, tag, tag_length);
1445+
1446+ if (string.start == string.end) {
1447+ return yaml_emitter_set_emitter_error(emitter,
1448+ "tag value must not be empty");
1449+ }
1450+
1451+ for (tag_directive = emitter->tag_directives.start;
1452+ tag_directive != emitter->tag_directives.top; tag_directive ++) {
1453+ size_t prefix_length = strlen((char *)tag_directive->prefix);
1454+ if (prefix_length < (size_t)(string.end - string.start)
1455+ && strncmp((char *)tag_directive->prefix, (char *)string.start,
1456+ prefix_length) == 0)
1457+ {
1458+ emitter->tag_data.handle = tag_directive->handle;
1459+ emitter->tag_data.handle_length =
1460+ strlen((char *)tag_directive->handle);
1461+ emitter->tag_data.suffix = string.start + prefix_length;
1462+ emitter->tag_data.suffix_length =
1463+ (string.end - string.start) - prefix_length;
1464+ return 1;
1465+ }
1466+ }
1467+
1468+ emitter->tag_data.suffix = string.start;
1469+ emitter->tag_data.suffix_length = string.end - string.start;
1470+
1471+ return 1;
1472+}
1473+
1474+/*
1475+ * Check if a scalar is valid.
1476+ */
1477+
1478+static int
1479+yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
1480+ yaml_char_t *value, size_t length)
1481+{
1482+ yaml_string_t string;
1483+
1484+ int block_indicators = 0;
1485+ int flow_indicators = 0;
1486+ int line_breaks = 0;
1487+ int special_characters = 0;
1488+
1489+ int leading_space = 0;
1490+ int leading_break = 0;
1491+ int trailing_space = 0;
1492+ int trailing_break = 0;
1493+ int break_space = 0;
1494+ int space_break = 0;
1495+
1496+ int preceeded_by_whitespace = 0;
1497+ int followed_by_whitespace = 0;
1498+ int previous_space = 0;
1499+ int previous_break = 0;
1500+
1501+ STRING_ASSIGN(string, value, length);
1502+
1503+ emitter->scalar_data.value = value;
1504+ emitter->scalar_data.length = length;
1505+
1506+ if (string.start == string.end)
1507+ {
1508+ emitter->scalar_data.multiline = 0;
1509+ emitter->scalar_data.flow_plain_allowed = 0;
1510+ emitter->scalar_data.block_plain_allowed = 1;
1511+ emitter->scalar_data.single_quoted_allowed = 1;
1512+ emitter->scalar_data.block_allowed = 0;
1513+
1514+ return 1;
1515+ }
1516+
1517+ if ((CHECK_AT(string, '-', 0)
1518+ && CHECK_AT(string, '-', 1)
1519+ && CHECK_AT(string, '-', 2))
1520+ || (CHECK_AT(string, '.', 0)
1521+ && CHECK_AT(string, '.', 1)
1522+ && CHECK_AT(string, '.', 2))) {
1523+ block_indicators = 1;
1524+ flow_indicators = 1;
1525+ }
1526+
1527+ preceeded_by_whitespace = 1;
1528+ followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
1529+
1530+ while (string.pointer != string.end)
1531+ {
1532+ if (string.start == string.pointer)
1533+ {
1534+ if (CHECK(string, '#') || CHECK(string, ',')
1535+ || CHECK(string, '[') || CHECK(string, ']')
1536+ || CHECK(string, '{') || CHECK(string, '}')
1537+ || CHECK(string, '&') || CHECK(string, '*')
1538+ || CHECK(string, '!') || CHECK(string, '|')
1539+ || CHECK(string, '>') || CHECK(string, '\'')
1540+ || CHECK(string, '"') || CHECK(string, '%')
1541+ || CHECK(string, '@') || CHECK(string, '`')) {
1542+ flow_indicators = 1;
1543+ block_indicators = 1;
1544+ }
1545+
1546+ if (CHECK(string, '?') || CHECK(string, ':')) {
1547+ flow_indicators = 1;
1548+ if (followed_by_whitespace) {
1549+ block_indicators = 1;
1550+ }
1551+ }
1552+
1553+ if (CHECK(string, '-') && followed_by_whitespace) {
1554+ flow_indicators = 1;
1555+ block_indicators = 1;
1556+ }
1557+ }
1558+ else
1559+ {
1560+ if (CHECK(string, ',') || CHECK(string, '?')
1561+ || CHECK(string, '[') || CHECK(string, ']')
1562+ || CHECK(string, '{') || CHECK(string, '}')) {
1563+ flow_indicators = 1;
1564+ }
1565+
1566+ if (CHECK(string, ':')) {
1567+ flow_indicators = 1;
1568+ if (followed_by_whitespace) {
1569+ block_indicators = 1;
1570+ }
1571+ }
1572+
1573+ if (CHECK(string, '#') && preceeded_by_whitespace) {
1574+ flow_indicators = 1;
1575+ block_indicators = 1;
1576+ }
1577+ }
1578+
1579+ if (!IS_PRINTABLE(string)
1580+ || (!IS_ASCII(string) && !emitter->unicode)) {
1581+ special_characters = 1;
1582+ }
1583+
1584+ if (IS_BREAK(string)) {
1585+ line_breaks = 1;
1586+ }
1587+
1588+ if (IS_SPACE(string))
1589+ {
1590+ if (string.start == string.pointer) {
1591+ leading_space = 1;
1592+ }
1593+ if (string.pointer+WIDTH(string) == string.end) {
1594+ trailing_space = 1;
1595+ }
1596+ if (previous_break) {
1597+ break_space = 1;
1598+ }
1599+ previous_space = 1;
1600+ previous_break = 0;
1601+ }
1602+ else if (IS_BREAK(string))
1603+ {
1604+ if (string.start == string.pointer) {
1605+ leading_break = 1;
1606+ }
1607+ if (string.pointer+WIDTH(string) == string.end) {
1608+ trailing_break = 1;
1609+ }
1610+ if (previous_space) {
1611+ space_break = 1;
1612+ }
1613+ previous_space = 0;
1614+ previous_break = 1;
1615+ }
1616+ else
1617+ {
1618+ previous_space = 0;
1619+ previous_break = 0;
1620+ }
1621+
1622+ preceeded_by_whitespace = IS_BLANKZ(string);
1623+ MOVE(string);
1624+ if (string.pointer != string.end) {
1625+ followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
1626+ }
1627+ }
1628+
1629+ emitter->scalar_data.multiline = line_breaks;
1630+
1631+ emitter->scalar_data.flow_plain_allowed = 1;
1632+ emitter->scalar_data.block_plain_allowed = 1;
1633+ emitter->scalar_data.single_quoted_allowed = 1;
1634+ emitter->scalar_data.block_allowed = 1;
1635+
1636+ if (leading_space || leading_break || trailing_space || trailing_break) {
1637+ emitter->scalar_data.flow_plain_allowed = 0;
1638+ emitter->scalar_data.block_plain_allowed = 0;
1639+ }
1640+
1641+ if (trailing_space) {
1642+ emitter->scalar_data.block_allowed = 0;
1643+ }
1644+
1645+ if (break_space) {
1646+ emitter->scalar_data.flow_plain_allowed = 0;
1647+ emitter->scalar_data.block_plain_allowed = 0;
1648+ emitter->scalar_data.single_quoted_allowed = 0;
1649+ }
1650+
1651+ if (space_break || special_characters) {
1652+ emitter->scalar_data.flow_plain_allowed = 0;
1653+ emitter->scalar_data.block_plain_allowed = 0;
1654+ emitter->scalar_data.single_quoted_allowed = 0;
1655+ emitter->scalar_data.block_allowed = 0;
1656+ }
1657+
1658+ if (line_breaks) {
1659+ emitter->scalar_data.flow_plain_allowed = 0;
1660+ emitter->scalar_data.block_plain_allowed = 0;
1661+ }
1662+
1663+ if (flow_indicators) {
1664+ emitter->scalar_data.flow_plain_allowed = 0;
1665+ }
1666+
1667+ if (block_indicators) {
1668+ emitter->scalar_data.block_plain_allowed = 0;
1669+ }
1670+
1671+ return 1;
1672+}
1673+
1674+/*
1675+ * Check if the event data is valid.
1676+ */
1677+
1678+static int
1679+yaml_emitter_analyze_event(yaml_emitter_t *emitter,
1680+ yaml_event_t *event)
1681+{
1682+ emitter->anchor_data.anchor = NULL;
1683+ emitter->anchor_data.anchor_length = 0;
1684+ emitter->tag_data.handle = NULL;
1685+ emitter->tag_data.handle_length = 0;
1686+ emitter->tag_data.suffix = NULL;
1687+ emitter->tag_data.suffix_length = 0;
1688+ emitter->scalar_data.value = NULL;
1689+ emitter->scalar_data.length = 0;
1690+
1691+ switch (event->type)
1692+ {
1693+ case YAML_ALIAS_EVENT:
1694+ if (!yaml_emitter_analyze_anchor(emitter,
1695+ event->data.alias.anchor, 1))
1696+ return 0;
1697+ return 1;
1698+
1699+ case YAML_SCALAR_EVENT:
1700+ if (event->data.scalar.anchor) {
1701+ if (!yaml_emitter_analyze_anchor(emitter,
1702+ event->data.scalar.anchor, 0))
1703+ return 0;
1704+ }
1705+ if (event->data.scalar.tag && (emitter->canonical ||
1706+ (!event->data.scalar.plain_implicit
1707+ && !event->data.scalar.quoted_implicit))) {
1708+ if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag))
1709+ return 0;
1710+ }
1711+ if (!yaml_emitter_analyze_scalar(emitter,
1712+ event->data.scalar.value, event->data.scalar.length))
1713+ return 0;
1714+ return 1;
1715+
1716+ case YAML_SEQUENCE_START_EVENT:
1717+ if (event->data.sequence_start.anchor) {
1718+ if (!yaml_emitter_analyze_anchor(emitter,
1719+ event->data.sequence_start.anchor, 0))
1720+ return 0;
1721+ }
1722+ if (event->data.sequence_start.tag && (emitter->canonical ||
1723+ !event->data.sequence_start.implicit)) {
1724+ if (!yaml_emitter_analyze_tag(emitter,
1725+ event->data.sequence_start.tag))
1726+ return 0;
1727+ }
1728+ return 1;
1729+
1730+ case YAML_MAPPING_START_EVENT:
1731+ if (event->data.mapping_start.anchor) {
1732+ if (!yaml_emitter_analyze_anchor(emitter,
1733+ event->data.mapping_start.anchor, 0))
1734+ return 0;
1735+ }
1736+ if (event->data.mapping_start.tag && (emitter->canonical ||
1737+ !event->data.mapping_start.implicit)) {
1738+ if (!yaml_emitter_analyze_tag(emitter,
1739+ event->data.mapping_start.tag))
1740+ return 0;
1741+ }
1742+ return 1;
1743+
1744+ default:
1745+ return 1;
1746+ }
1747+}
1748+
1749+/*
1750+ * Write the BOM character.
1751+ */
1752+
1753+static int
1754+yaml_emitter_write_bom(yaml_emitter_t *emitter)
1755+{
1756+ if (!FLUSH(emitter)) return 0;
1757+
1758+ *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
1759+ *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
1760+ *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';
1761+
1762+ return 1;
1763+}
1764+
1765+static int
1766+yaml_emitter_write_indent(yaml_emitter_t *emitter)
1767+{
1768+ int indent = (emitter->indent >= 0) ? emitter->indent : 0;
1769+
1770+ if (!emitter->indention || emitter->column > indent
1771+ || (emitter->column == indent && !emitter->whitespace)) {
1772+ if (!PUT_BREAK(emitter)) return 0;
1773+ }
1774+
1775+ while (emitter->column < indent) {
1776+ if (!PUT(emitter, ' ')) return 0;
1777+ }
1778+
1779+ emitter->whitespace = 1;
1780+ emitter->indention = 1;
1781+
1782+ return 1;
1783+}
1784+
1785+static int
1786+yaml_emitter_write_indicator(yaml_emitter_t *emitter,
1787+ char *indicator, int need_whitespace,
1788+ int is_whitespace, int is_indention)
1789+{
1790+ size_t indicator_length;
1791+ yaml_string_t string;
1792+
1793+ indicator_length = strlen(indicator);
1794+ STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length);
1795+
1796+ if (need_whitespace && !emitter->whitespace) {
1797+ if (!PUT(emitter, ' ')) return 0;
1798+ }
1799+
1800+ while (string.pointer != string.end) {
1801+ if (!WRITE(emitter, string)) return 0;
1802+ }
1803+
1804+ emitter->whitespace = is_whitespace;
1805+ emitter->indention = (emitter->indention && is_indention);
1806+ emitter->open_ended = 0;
1807+
1808+ return 1;
1809+}
1810+
1811+static int
1812+yaml_emitter_write_anchor(yaml_emitter_t *emitter,
1813+ yaml_char_t *value, size_t length)
1814+{
1815+ yaml_string_t string;
1816+ STRING_ASSIGN(string, value, length);
1817+
1818+ while (string.pointer != string.end) {
1819+ if (!WRITE(emitter, string)) return 0;
1820+ }
1821+
1822+ emitter->whitespace = 0;
1823+ emitter->indention = 0;
1824+
1825+ return 1;
1826+}
1827+
1828+static int
1829+yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
1830+ yaml_char_t *value, size_t length)
1831+{
1832+ yaml_string_t string;
1833+ STRING_ASSIGN(string, value, length);
1834+
1835+ if (!emitter->whitespace) {
1836+ if (!PUT(emitter, ' ')) return 0;
1837+ }
1838+
1839+ while (string.pointer != string.end) {
1840+ if (!WRITE(emitter, string)) return 0;
1841+ }
1842+
1843+ emitter->whitespace = 0;
1844+ emitter->indention = 0;
1845+
1846+ return 1;
1847+}
1848+
1849+static int
1850+yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
1851+ yaml_char_t *value, size_t length,
1852+ int need_whitespace)
1853+{
1854+ yaml_string_t string;
1855+ STRING_ASSIGN(string, value, length);
1856+
1857+ if (need_whitespace && !emitter->whitespace) {
1858+ if (!PUT(emitter, ' ')) return 0;
1859+ }
1860+
1861+ while (string.pointer != string.end) {
1862+ if (IS_ALPHA(string)
1863+ || CHECK(string, ';') || CHECK(string, '/')
1864+ || CHECK(string, '?') || CHECK(string, ':')
1865+ || CHECK(string, '@') || CHECK(string, '&')
1866+ || CHECK(string, '=') || CHECK(string, '+')
1867+ || CHECK(string, '$') || CHECK(string, ',')
1868+ || CHECK(string, '_') || CHECK(string, '.')
1869+ || CHECK(string, '~') || CHECK(string, '*')
1870+ || CHECK(string, '\'') || CHECK(string, '(')
1871+ || CHECK(string, ')') || CHECK(string, '[')
1872+ || CHECK(string, ']')) {
1873+ if (!WRITE(emitter, string)) return 0;
1874+ }
1875+ else {
1876+ int width = WIDTH(string);
1877+ unsigned int value;
1878+ while (width --) {
1879+ value = *(string.pointer++);
1880+ if (!PUT(emitter, '%')) return 0;
1881+ if (!PUT(emitter, (value >> 4)
1882+ + ((value >> 4) < 10 ? '0' : 'A' - 10)))
1883+ return 0;
1884+ if (!PUT(emitter, (value & 0x0F)
1885+ + ((value & 0x0F) < 10 ? '0' : 'A' - 10)))
1886+ return 0;
1887+ }
1888+ }
1889+ }
1890+
1891+ emitter->whitespace = 0;
1892+ emitter->indention = 0;
1893+
1894+ return 1;
1895+}
1896+
1897+static int
1898+yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
1899+ yaml_char_t *value, size_t length, int allow_breaks)
1900+{
1901+ yaml_string_t string;
1902+ int spaces = 0;
1903+ int breaks = 0;
1904+
1905+ STRING_ASSIGN(string, value, length);
1906+
1907+ if (!emitter->whitespace) {
1908+ if (!PUT(emitter, ' ')) return 0;
1909+ }
1910+
1911+ while (string.pointer != string.end)
1912+ {
1913+ if (IS_SPACE(string))
1914+ {
1915+ if (allow_breaks && !spaces
1916+ && emitter->column > emitter->best_width
1917+ && !IS_SPACE_AT(string, 1)) {
1918+ if (!yaml_emitter_write_indent(emitter)) return 0;
1919+ MOVE(string);
1920+ }
1921+ else {
1922+ if (!WRITE(emitter, string)) return 0;
1923+ }
1924+ spaces = 1;
1925+ }
1926+ else if (IS_BREAK(string))
1927+ {
1928+ if (!breaks && CHECK(string, '\n')) {
1929+ if (!PUT_BREAK(emitter)) return 0;
1930+ }
1931+ if (!WRITE_BREAK(emitter, string)) return 0;
1932+ emitter->indention = 1;
1933+ breaks = 1;
1934+ }
1935+ else
1936+ {
1937+ if (breaks) {
1938+ if (!yaml_emitter_write_indent(emitter)) return 0;
1939+ }
1940+ if (!WRITE(emitter, string)) return 0;
1941+ emitter->indention = 0;
1942+ spaces = 0;
1943+ breaks = 0;
1944+ }
1945+ }
1946+
1947+ emitter->whitespace = 0;
1948+ emitter->indention = 0;
1949+ if (emitter->root_context)
1950+ {
1951+ emitter->open_ended = 1;
1952+ }
1953+
1954+ return 1;
1955+}
1956+
1957+static int
1958+yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
1959+ yaml_char_t *value, size_t length, int allow_breaks)
1960+{
1961+ yaml_string_t string;
1962+ int spaces = 0;
1963+ int breaks = 0;
1964+
1965+ STRING_ASSIGN(string, value, length);
1966+
1967+ if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0))
1968+ return 0;
1969+
1970+ while (string.pointer != string.end)
1971+ {
1972+ if (IS_SPACE(string))
1973+ {
1974+ if (allow_breaks && !spaces
1975+ && emitter->column > emitter->best_width
1976+ && string.pointer != string.start
1977+ && string.pointer != string.end - 1
1978+ && !IS_SPACE_AT(string, 1)) {
1979+ if (!yaml_emitter_write_indent(emitter)) return 0;
1980+ MOVE(string);
1981+ }
1982+ else {
1983+ if (!WRITE(emitter, string)) return 0;
1984+ }
1985+ spaces = 1;
1986+ }
1987+ else if (IS_BREAK(string))
1988+ {
1989+ if (!breaks && CHECK(string, '\n')) {
1990+ if (!PUT_BREAK(emitter)) return 0;
1991+ }
1992+ if (!WRITE_BREAK(emitter, string)) return 0;
1993+ emitter->indention = 1;
1994+ breaks = 1;
1995+ }
1996+ else
1997+ {
1998+ if (breaks) {
1999+ if (!yaml_emitter_write_indent(emitter)) return 0;
2000+ }
2001+ if (CHECK(string, '\'')) {
2002+ if (!PUT(emitter, '\'')) return 0;
2003+ }
2004+ if (!WRITE(emitter, string)) return 0;
2005+ emitter->indention = 0;
2006+ spaces = 0;
2007+ breaks = 0;
2008+ }
2009+ }
2010+
2011+ if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0))
2012+ return 0;
2013+
2014+ emitter->whitespace = 0;
2015+ emitter->indention = 0;
2016+
2017+ return 1;
2018+}
2019+
2020+static int
2021+yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
2022+ yaml_char_t *value, size_t length, int allow_breaks)
2023+{
2024+ yaml_string_t string;
2025+ int spaces = 0;
2026+
2027+ STRING_ASSIGN(string, value, length);
2028+
2029+ if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0))
2030+ return 0;
2031+
2032+ while (string.pointer != string.end)
2033+ {
2034+ if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string))
2035+ || IS_BOM(string) || IS_BREAK(string)
2036+ || CHECK(string, '"') || CHECK(string, '\\'))
2037+ {
2038+ unsigned char octet;
2039+ unsigned int width;
2040+ unsigned int value;
2041+ int k;
2042+
2043+ octet = string.pointer[0];
2044+ width = (octet & 0x80) == 0x00 ? 1 :
2045+ (octet & 0xE0) == 0xC0 ? 2 :
2046+ (octet & 0xF0) == 0xE0 ? 3 :
2047+ (octet & 0xF8) == 0xF0 ? 4 : 0;
2048+ value = (octet & 0x80) == 0x00 ? octet & 0x7F :
2049+ (octet & 0xE0) == 0xC0 ? octet & 0x1F :
2050+ (octet & 0xF0) == 0xE0 ? octet & 0x0F :
2051+ (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
2052+ for (k = 1; k < (int)width; k ++) {
2053+ octet = string.pointer[k];
2054+ value = (value << 6) + (octet & 0x3F);
2055+ }
2056+ string.pointer += width;
2057+
2058+ if (!PUT(emitter, '\\')) return 0;
2059+
2060+ switch (value)
2061+ {
2062+ case 0x00:
2063+ if (!PUT(emitter, '0')) return 0;
2064+ break;
2065+
2066+ case 0x07:
2067+ if (!PUT(emitter, 'a')) return 0;
2068+ break;
2069+
2070+ case 0x08:
2071+ if (!PUT(emitter, 'b')) return 0;
2072+ break;
2073+
2074+ case 0x09:
2075+ if (!PUT(emitter, 't')) return 0;
2076+ break;
2077+
2078+ case 0x0A:
2079+ if (!PUT(emitter, 'n')) return 0;
2080+ break;
2081+
2082+ case 0x0B:
2083+ if (!PUT(emitter, 'v')) return 0;
2084+ break;
2085+
2086+ case 0x0C:
2087+ if (!PUT(emitter, 'f')) return 0;
2088+ break;
2089+
2090+ case 0x0D:
2091+ if (!PUT(emitter, 'r')) return 0;
2092+ break;
2093+
2094+ case 0x1B:
2095+ if (!PUT(emitter, 'e')) return 0;
2096+ break;
2097+
2098+ case 0x22:
2099+ if (!PUT(emitter, '\"')) return 0;
2100+ break;
2101+
2102+ case 0x5C:
2103+ if (!PUT(emitter, '\\')) return 0;
2104+ break;
2105+
2106+ case 0x85:
2107+ if (!PUT(emitter, 'N')) return 0;
2108+ break;
2109+
2110+ case 0xA0:
2111+ if (!PUT(emitter, '_')) return 0;
2112+ break;
2113+
2114+ case 0x2028:
2115+ if (!PUT(emitter, 'L')) return 0;
2116+ break;
2117+
2118+ case 0x2029:
2119+ if (!PUT(emitter, 'P')) return 0;
2120+ break;
2121+
2122+ default:
2123+ if (value <= 0xFF) {
2124+ if (!PUT(emitter, 'x')) return 0;
2125+ width = 2;
2126+ }
2127+ else if (value <= 0xFFFF) {
2128+ if (!PUT(emitter, 'u')) return 0;
2129+ width = 4;
2130+ }
2131+ else {
2132+ if (!PUT(emitter, 'U')) return 0;
2133+ width = 8;
2134+ }
2135+ for (k = (width-1)*4; k >= 0; k -= 4) {
2136+ int digit = (value >> k) & 0x0F;
2137+ if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10)))
2138+ return 0;
2139+ }
2140+ }
2141+ spaces = 0;
2142+ }
2143+ else if (IS_SPACE(string))
2144+ {
2145+ if (allow_breaks && !spaces
2146+ && emitter->column > emitter->best_width
2147+ && string.pointer != string.start
2148+ && string.pointer != string.end - 1) {
2149+ if (!yaml_emitter_write_indent(emitter)) return 0;
2150+ if (IS_SPACE_AT(string, 1)) {
2151+ if (!PUT(emitter, '\\')) return 0;
2152+ }
2153+ MOVE(string);
2154+ }
2155+ else {
2156+ if (!WRITE(emitter, string)) return 0;
2157+ }
2158+ spaces = 1;
2159+ }
2160+ else
2161+ {
2162+ if (!WRITE(emitter, string)) return 0;
2163+ spaces = 0;
2164+ }
2165+ }
2166+
2167+ if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0))
2168+ return 0;
2169+
2170+ emitter->whitespace = 0;
2171+ emitter->indention = 0;
2172+
2173+ return 1;
2174+}
2175+
2176+static int
2177+yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
2178+ yaml_string_t string)
2179+{
2180+ char indent_hint[2];
2181+ char *chomp_hint = NULL;
2182+
2183+ if (IS_SPACE(string) || IS_BREAK(string))
2184+ {
2185+ indent_hint[0] = '0' + (char)emitter->best_indent;
2186+ indent_hint[1] = '\0';
2187+ if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0))
2188+ return 0;
2189+ }
2190+
2191+ emitter->open_ended = 0;
2192+
2193+ string.pointer = string.end;
2194+ if (string.start == string.pointer)
2195+ {
2196+ chomp_hint = "-";
2197+ }
2198+ else
2199+ {
2200+ do {
2201+ string.pointer --;
2202+ } while ((*string.pointer & 0xC0) == 0x80);
2203+ if (!IS_BREAK(string))
2204+ {
2205+ chomp_hint = "-";
2206+ }
2207+ else if (string.start == string.pointer)
2208+ {
2209+ chomp_hint = "+";
2210+ emitter->open_ended = 1;
2211+ }
2212+ else
2213+ {
2214+ do {
2215+ string.pointer --;
2216+ } while ((*string.pointer & 0xC0) == 0x80);
2217+ if (IS_BREAK(string))
2218+ {
2219+ chomp_hint = "+";
2220+ emitter->open_ended = 1;
2221+ }
2222+ }
2223+ }
2224+
2225+ if (chomp_hint)
2226+ {
2227+ if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0))
2228+ return 0;
2229+ }
2230+
2231+ return 1;
2232+}
2233+
2234+static int
2235+yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
2236+ yaml_char_t *value, size_t length)
2237+{
2238+ yaml_string_t string;
2239+ int breaks = 1;
2240+
2241+ STRING_ASSIGN(string, value, length);
2242+
2243+ if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0))
2244+ return 0;
2245+ if (!yaml_emitter_write_block_scalar_hints(emitter, string))
2246+ return 0;
2247+ if (!PUT_BREAK(emitter)) return 0;
2248+ emitter->indention = 1;
2249+ emitter->whitespace = 1;
2250+
2251+ while (string.pointer != string.end)
2252+ {
2253+ if (IS_BREAK(string))
2254+ {
2255+ if (!WRITE_BREAK(emitter, string)) return 0;
2256+ emitter->indention = 1;
2257+ breaks = 1;
2258+ }
2259+ else
2260+ {
2261+ if (breaks) {
2262+ if (!yaml_emitter_write_indent(emitter)) return 0;
2263+ }
2264+ if (!WRITE(emitter, string)) return 0;
2265+ emitter->indention = 0;
2266+ breaks = 0;
2267+ }
2268+ }
2269+
2270+ return 1;
2271+}
2272+
2273+static int
2274+yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
2275+ yaml_char_t *value, size_t length)
2276+{
2277+ yaml_string_t string;
2278+ int breaks = 1;
2279+ int leading_spaces = 1;
2280+
2281+ STRING_ASSIGN(string, value, length);
2282+
2283+ if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0))
2284+ return 0;
2285+ if (!yaml_emitter_write_block_scalar_hints(emitter, string))
2286+ return 0;
2287+ if (!PUT_BREAK(emitter)) return 0;
2288+ emitter->indention = 1;
2289+ emitter->whitespace = 1;
2290+
2291+ while (string.pointer != string.end)
2292+ {
2293+ if (IS_BREAK(string))
2294+ {
2295+ if (!breaks && !leading_spaces && CHECK(string, '\n')) {
2296+ int k = 0;
2297+ while (IS_BREAK_AT(string, k)) {
2298+ k += WIDTH_AT(string, k);
2299+ }
2300+ if (!IS_BLANKZ_AT(string, k)) {
2301+ if (!PUT_BREAK(emitter)) return 0;
2302+ }
2303+ }
2304+ if (!WRITE_BREAK(emitter, string)) return 0;
2305+ emitter->indention = 1;
2306+ breaks = 1;
2307+ }
2308+ else
2309+ {
2310+ if (breaks) {
2311+ if (!yaml_emitter_write_indent(emitter)) return 0;
2312+ leading_spaces = IS_BLANK(string);
2313+ }
2314+ if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1)
2315+ && emitter->column > emitter->best_width) {
2316+ if (!yaml_emitter_write_indent(emitter)) return 0;
2317+ MOVE(string);
2318+ }
2319+ else {
2320+ if (!WRITE(emitter, string)) return 0;
2321+ }
2322+ emitter->indention = 0;
2323+ breaks = 0;
2324+ }
2325+ }
2326+
2327+ return 1;
2328+}
2329+
libyaml/libyaml.cabaldeleted−68
@@ -1,68 +0,0 @@
1−cabal-version: 1.12
2−
3−-- This file has been generated from package.yaml by hpack version 0.36.0.
4−--
5−-- see: https://github.com/sol/hpack
6−
7−name: libyaml
8−version: 0.1.4
9−synopsis: Low-level, streaming YAML interface.
10−description: README and API documentation are available at <https://www.stackage.org/package/libyaml>
11−category: Text
12−stability: stable
13−homepage: https://github.com/snoyberg/yaml#readme
14−bug-reports: https://github.com/snoyberg/yaml/issues
15−author: Michael Snoyman <michael@snoyman.com>, Anton Ageev <antage@gmail.com>,Kirill Simonov
16−maintainer: Michael Snoyman <michael@snoyman.com>
17−license: BSD3
18−license-file: LICENSE
19−build-type: Simple
20−extra-source-files:
21− include/helper.h
22− README.md
23− ChangeLog.md
24−
25−source-repository head
26− type: git
27− location: https://github.com/snoyberg/yaml
28−
29−flag no-unicode
30− description: Don't enable unicode output. Instead, unicode characters will be escaped.
31− manual: False
32− default: False
33−
34−flag system-libyaml
35− description: Use the system-wide libyaml instead of the bundled copy
36− manual: False
37− default: False
38−
39−library
40− exposed-modules:
41− Text.Libyaml
42− other-modules:
43− Paths_libyaml
44− hs-source-dirs:
45− src
46− ghc-options: -Wall
47− include-dirs:
48− include
49− c-sources:
50− c/helper.c
51− build-depends:
52− base >=4.9.1 && <5
53− , bytestring >=0.9.1.4
54− , conduit >=1.2.8 && <1.4
55− , resourcet >=0.3 && <1.4
56− default-language: Haskell2010
57− if flag(no-unicode)
58− cpp-options: -D__NO_UNICODE__
59− if !(flag(system-libyaml))
60− build-depends:
61− libyaml-clib
62− else
63− pkgconfig-depends:
64− yaml-0.1
65− if os(windows)
66− cpp-options: -DWINDOWS
67− build-depends:
68− directory
libyaml/loader.cnew file+432
@@ -0,0 +1,432 @@
1+
2+#include "yaml_private.h"
3+
4+/*
5+ * API functions.
6+ */
7+
8+YAML_DECLARE(int)
9+yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
10+
11+/*
12+ * Error handling.
13+ */
14+
15+static int
16+yaml_parser_set_composer_error(yaml_parser_t *parser,
17+ const char *problem, yaml_mark_t problem_mark);
18+
19+static int
20+yaml_parser_set_composer_error_context(yaml_parser_t *parser,
21+ const char *context, yaml_mark_t context_mark,
22+ const char *problem, yaml_mark_t problem_mark);
23+
24+
25+/*
26+ * Alias handling.
27+ */
28+
29+static int
30+yaml_parser_register_anchor(yaml_parser_t *parser,
31+ int index, yaml_char_t *anchor);
32+
33+/*
34+ * Clean up functions.
35+ */
36+
37+static void
38+yaml_parser_delete_aliases(yaml_parser_t *parser);
39+
40+/*
41+ * Composer functions.
42+ */
43+
44+static int
45+yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event);
46+
47+static int
48+yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event);
49+
50+static int
51+yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event);
52+
53+static int
54+yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event);
55+
56+static int
57+yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event);
58+
59+static int
60+yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event);
61+
62+/*
63+ * Load the next document of the stream.
64+ */
65+
66+YAML_DECLARE(int)
67+yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)
68+{
69+ yaml_event_t event;
70+
71+ assert(parser); /* Non-NULL parser object is expected. */
72+ assert(document); /* Non-NULL document object is expected. */
73+
74+ memset(document, 0, sizeof(yaml_document_t));
75+ if (!STACK_INIT(parser, document->nodes, INITIAL_STACK_SIZE))
76+ goto error;
77+
78+ if (!parser->stream_start_produced) {
79+ if (!yaml_parser_parse(parser, &event)) goto error;
80+ assert(event.type == YAML_STREAM_START_EVENT);
81+ /* STREAM-START is expected. */
82+ }
83+
84+ if (parser->stream_end_produced) {
85+ return 1;
86+ }
87+
88+ if (!yaml_parser_parse(parser, &event)) goto error;
89+ if (event.type == YAML_STREAM_END_EVENT) {
90+ return 1;
91+ }
92+
93+ if (!STACK_INIT(parser, parser->aliases, INITIAL_STACK_SIZE))
94+ goto error;
95+
96+ parser->document = document;
97+
98+ if (!yaml_parser_load_document(parser, &event)) goto error;
99+
100+ yaml_parser_delete_aliases(parser);
101+ parser->document = NULL;
102+
103+ return 1;
104+
105+error:
106+
107+ yaml_parser_delete_aliases(parser);
108+ yaml_document_delete(document);
109+ parser->document = NULL;
110+
111+ return 0;
112+}
113+
114+/*
115+ * Set composer error.
116+ */
117+
118+static int
119+yaml_parser_set_composer_error(yaml_parser_t *parser,
120+ const char *problem, yaml_mark_t problem_mark)
121+{
122+ parser->error = YAML_COMPOSER_ERROR;
123+ parser->problem = problem;
124+ parser->problem_mark = problem_mark;
125+
126+ return 0;
127+}
128+
129+/*
130+ * Set composer error with context.
131+ */
132+
133+static int
134+yaml_parser_set_composer_error_context(yaml_parser_t *parser,
135+ const char *context, yaml_mark_t context_mark,
136+ const char *problem, yaml_mark_t problem_mark)
137+{
138+ parser->error = YAML_COMPOSER_ERROR;
139+ parser->context = context;
140+ parser->context_mark = context_mark;
141+ parser->problem = problem;
142+ parser->problem_mark = problem_mark;
143+
144+ return 0;
145+}
146+
147+/*
148+ * Delete the stack of aliases.
149+ */
150+
151+static void
152+yaml_parser_delete_aliases(yaml_parser_t *parser)
153+{
154+ while (!STACK_EMPTY(parser, parser->aliases)) {
155+ yaml_free(POP(parser, parser->aliases).anchor);
156+ }
157+ STACK_DEL(parser, parser->aliases);
158+}
159+
160+/*
161+ * Compose a document object.
162+ */
163+
164+static int
165+yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event)
166+{
167+ yaml_event_t event;
168+
169+ assert(first_event->type == YAML_DOCUMENT_START_EVENT);
170+ /* DOCUMENT-START is expected. */
171+
172+ parser->document->version_directive
173+ = first_event->data.document_start.version_directive;
174+ parser->document->tag_directives.start
175+ = first_event->data.document_start.tag_directives.start;
176+ parser->document->tag_directives.end
177+ = first_event->data.document_start.tag_directives.end;
178+ parser->document->start_implicit
179+ = first_event->data.document_start.implicit;
180+ parser->document->start_mark = first_event->start_mark;
181+
182+ if (!yaml_parser_parse(parser, &event)) return 0;
183+
184+ if (!yaml_parser_load_node(parser, &event)) return 0;
185+
186+ if (!yaml_parser_parse(parser, &event)) return 0;
187+ assert(event.type == YAML_DOCUMENT_END_EVENT);
188+ /* DOCUMENT-END is expected. */
189+
190+ parser->document->end_implicit = event.data.document_end.implicit;
191+ parser->document->end_mark = event.end_mark;
192+
193+ return 1;
194+}
195+
196+/*
197+ * Compose a node.
198+ */
199+
200+static int
201+yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event)
202+{
203+ switch (first_event->type) {
204+ case YAML_ALIAS_EVENT:
205+ return yaml_parser_load_alias(parser, first_event);
206+ case YAML_SCALAR_EVENT:
207+ return yaml_parser_load_scalar(parser, first_event);
208+ case YAML_SEQUENCE_START_EVENT:
209+ return yaml_parser_load_sequence(parser, first_event);
210+ case YAML_MAPPING_START_EVENT:
211+ return yaml_parser_load_mapping(parser, first_event);
212+ default:
213+ assert(0); /* Could not happen. */
214+ return 0;
215+ }
216+
217+ return 0;
218+}
219+
220+/*
221+ * Add an anchor.
222+ */
223+
224+static int
225+yaml_parser_register_anchor(yaml_parser_t *parser,
226+ int index, yaml_char_t *anchor)
227+{
228+ yaml_alias_data_t data;
229+ yaml_alias_data_t *alias_data;
230+
231+ if (!anchor) return 1;
232+
233+ data.anchor = anchor;
234+ data.index = index;
235+ data.mark = parser->document->nodes.start[index-1].start_mark;
236+
237+ for (alias_data = parser->aliases.start;
238+ alias_data != parser->aliases.top; alias_data ++) {
239+ if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
240+ yaml_free(anchor);
241+ return yaml_parser_set_composer_error_context(parser,
242+ "found duplicate anchor; first occurence",
243+ alias_data->mark, "second occurence", data.mark);
244+ }
245+ }
246+
247+ if (!PUSH(parser, parser->aliases, data)) {
248+ yaml_free(anchor);
249+ return 0;
250+ }
251+
252+ return 1;
253+}
254+
255+/*
256+ * Compose a node corresponding to an alias.
257+ */
258+
259+static int
260+yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event)
261+{
262+ yaml_char_t *anchor = first_event->data.alias.anchor;
263+ yaml_alias_data_t *alias_data;
264+
265+ for (alias_data = parser->aliases.start;
266+ alias_data != parser->aliases.top; alias_data ++) {
267+ if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
268+ yaml_free(anchor);
269+ return alias_data->index;
270+ }
271+ }
272+
273+ yaml_free(anchor);
274+ return yaml_parser_set_composer_error(parser, "found undefined alias",
275+ first_event->start_mark);
276+}
277+
278+/*
279+ * Compose a scalar node.
280+ */
281+
282+static int
283+yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event)
284+{
285+ yaml_node_t node;
286+ int index;
287+ yaml_char_t *tag = first_event->data.scalar.tag;
288+
289+ if (!tag || strcmp((char *)tag, "!") == 0) {
290+ yaml_free(tag);
291+ tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SCALAR_TAG);
292+ if (!tag) goto error;
293+ }
294+
295+ SCALAR_NODE_INIT(node, tag, first_event->data.scalar.value,
296+ first_event->data.scalar.length, first_event->data.scalar.style,
297+ first_event->start_mark, first_event->end_mark);
298+
299+ if (!PUSH(parser, parser->document->nodes, node)) goto error;
300+
301+ index = parser->document->nodes.top - parser->document->nodes.start;
302+
303+ if (!yaml_parser_register_anchor(parser, index,
304+ first_event->data.scalar.anchor)) return 0;
305+
306+ return index;
307+
308+error:
309+ yaml_free(tag);
310+ yaml_free(first_event->data.scalar.anchor);
311+ yaml_free(first_event->data.scalar.value);
312+ return 0;
313+}
314+
315+/*
316+ * Compose a sequence node.
317+ */
318+
319+static int
320+yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event)
321+{
322+ yaml_event_t event;
323+ yaml_node_t node;
324+ struct {
325+ yaml_node_item_t *start;
326+ yaml_node_item_t *end;
327+ yaml_node_item_t *top;
328+ } items = { NULL, NULL, NULL };
329+ int index, item_index;
330+ yaml_char_t *tag = first_event->data.sequence_start.tag;
331+
332+ if (!tag || strcmp((char *)tag, "!") == 0) {
333+ yaml_free(tag);
334+ tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG);
335+ if (!tag) goto error;
336+ }
337+
338+ if (!STACK_INIT(parser, items, INITIAL_STACK_SIZE)) goto error;
339+
340+ SEQUENCE_NODE_INIT(node, tag, items.start, items.end,
341+ first_event->data.sequence_start.style,
342+ first_event->start_mark, first_event->end_mark);
343+
344+ if (!PUSH(parser, parser->document->nodes, node)) goto error;
345+
346+ index = parser->document->nodes.top - parser->document->nodes.start;
347+
348+ if (!yaml_parser_register_anchor(parser, index,
349+ first_event->data.sequence_start.anchor)) return 0;
350+
351+ if (!yaml_parser_parse(parser, &event)) return 0;
352+
353+ while (event.type != YAML_SEQUENCE_END_EVENT) {
354+ item_index = yaml_parser_load_node(parser, &event);
355+ if (!item_index) return 0;
356+ if (!PUSH(parser,
357+ parser->document->nodes.start[index-1].data.sequence.items,
358+ item_index)) return 0;
359+ if (!yaml_parser_parse(parser, &event)) return 0;
360+ }
361+
362+ parser->document->nodes.start[index-1].end_mark = event.end_mark;
363+
364+ return index;
365+
366+error:
367+ yaml_free(tag);
368+ yaml_free(first_event->data.sequence_start.anchor);
369+ return 0;
370+}
371+
372+/*
373+ * Compose a mapping node.
374+ */
375+
376+static int
377+yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event)
378+{
379+ yaml_event_t event;
380+ yaml_node_t node;
381+ struct {
382+ yaml_node_pair_t *start;
383+ yaml_node_pair_t *end;
384+ yaml_node_pair_t *top;
385+ } pairs = { NULL, NULL, NULL };
386+ int index;
387+ yaml_node_pair_t pair;
388+ yaml_char_t *tag = first_event->data.mapping_start.tag;
389+
390+ if (!tag || strcmp((char *)tag, "!") == 0) {
391+ yaml_free(tag);
392+ tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG);
393+ if (!tag) goto error;
394+ }
395+
396+ if (!STACK_INIT(parser, pairs, INITIAL_STACK_SIZE)) goto error;
397+
398+ MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end,
399+ first_event->data.mapping_start.style,
400+ first_event->start_mark, first_event->end_mark);
401+
402+ if (!PUSH(parser, parser->document->nodes, node)) goto error;
403+
404+ index = parser->document->nodes.top - parser->document->nodes.start;
405+
406+ if (!yaml_parser_register_anchor(parser, index,
407+ first_event->data.mapping_start.anchor)) return 0;
408+
409+ if (!yaml_parser_parse(parser, &event)) return 0;
410+
411+ while (event.type != YAML_MAPPING_END_EVENT) {
412+ pair.key = yaml_parser_load_node(parser, &event);
413+ if (!pair.key) return 0;
414+ if (!yaml_parser_parse(parser, &event)) return 0;
415+ pair.value = yaml_parser_load_node(parser, &event);
416+ if (!pair.value) return 0;
417+ if (!PUSH(parser,
418+ parser->document->nodes.start[index-1].data.mapping.pairs,
419+ pair)) return 0;
420+ if (!yaml_parser_parse(parser, &event)) return 0;
421+ }
422+
423+ parser->document->nodes.start[index-1].end_mark = event.end_mark;
424+
425+ return index;
426+
427+error:
428+ yaml_free(tag);
429+ yaml_free(first_event->data.mapping_start.anchor);
430+ return 0;
431+}
432+
libyaml/package.yamldeleted−53
@@ -1,53 +0,0 @@
1−name: libyaml
2−version: 0.1.4
3−synopsis: Low-level, streaming YAML interface.
4−description: README and API documentation are available at <https://www.stackage.org/package/libyaml>
5−category: Text
6−author: Michael Snoyman <michael@snoyman.com>, Anton Ageev <antage@gmail.com>,Kirill Simonov
7−maintainer: Michael Snoyman <michael@snoyman.com>
8−license: BSD3
9−github: snoyberg/yaml
10−stability: stable
11−
12−extra-source-files:
13−- include/helper.h
14−- README.md
15−- ChangeLog.md
16−
17−flags:
18− system-libyaml:
19− description: Use the system-wide libyaml instead of the bundled copy
20− manual: false
21− default: false
22− no-unicode:
23− description: Don't enable unicode output. Instead, unicode characters will be escaped.
24− manual: false
25− default: false
26−
27−dependencies:
28−- base >=4.14 && <5 # GHC 8.10.1 and later
29−- bytestring >=0.9.1.4
30−- conduit >=1.2.8 && <1.4
31−- resourcet >=0.3 && <1.4
32−
33−library:
34− c-sources: c/helper.c
35− ghc-options: -Wall
36− include-dirs:
37− - include
38− source-dirs: src
39− when:
40− - condition: flag(no-unicode)
41− cpp-options: -D__NO_UNICODE__
42− - condition: ! '!(flag(system-libyaml))'
43− then:
44− dependencies:
45− - libyaml-clib
46− else:
47− pkg-config-dependencies:
48− - yaml-0.1
49− - condition: os(windows)
50− cpp-options: -DWINDOWS
51− dependencies:
52− - directory
53−
libyaml/parser.cnew file+1374
@@ -0,0 +1,1374 @@
1+
2+/*
3+ * The parser implements the following grammar:
4+ *
5+ * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
6+ * implicit_document ::= block_node DOCUMENT-END*
7+ * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
8+ * block_node_or_indentless_sequence ::=
9+ * ALIAS
10+ * | properties (block_content | indentless_block_sequence)?
11+ * | block_content
12+ * | indentless_block_sequence
13+ * block_node ::= ALIAS
14+ * | properties block_content?
15+ * | block_content
16+ * flow_node ::= ALIAS
17+ * | properties flow_content?
18+ * | flow_content
19+ * properties ::= TAG ANCHOR? | ANCHOR TAG?
20+ * block_content ::= block_collection | flow_collection | SCALAR
21+ * flow_content ::= flow_collection | SCALAR
22+ * block_collection ::= block_sequence | block_mapping
23+ * flow_collection ::= flow_sequence | flow_mapping
24+ * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
25+ * indentless_sequence ::= (BLOCK-ENTRY block_node?)+
26+ * block_mapping ::= BLOCK-MAPPING_START
27+ * ((KEY block_node_or_indentless_sequence?)?
28+ * (VALUE block_node_or_indentless_sequence?)?)*
29+ * BLOCK-END
30+ * flow_sequence ::= FLOW-SEQUENCE-START
31+ * (flow_sequence_entry FLOW-ENTRY)*
32+ * flow_sequence_entry?
33+ * FLOW-SEQUENCE-END
34+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
35+ * flow_mapping ::= FLOW-MAPPING-START
36+ * (flow_mapping_entry FLOW-ENTRY)*
37+ * flow_mapping_entry?
38+ * FLOW-MAPPING-END
39+ * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
40+ */
41+
42+#include "yaml_private.h"
43+
44+/*
45+ * Peek the next token in the token queue.
46+ */
47+
48+#define PEEK_TOKEN(parser) \
49+ ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \
50+ parser->tokens.head : NULL)
51+
52+/*
53+ * Remove the next token from the queue (must be called after PEEK_TOKEN).
54+ */
55+
56+#define SKIP_TOKEN(parser) \
57+ (parser->token_available = 0, \
58+ parser->tokens_parsed ++, \
59+ parser->stream_end_produced = \
60+ (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \
61+ parser->tokens.head ++)
62+
63+/*
64+ * Public API declarations.
65+ */
66+
67+YAML_DECLARE(int)
68+yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
69+
70+/*
71+ * Error handling.
72+ */
73+
74+static int
75+yaml_parser_set_parser_error(yaml_parser_t *parser,
76+ const char *problem, yaml_mark_t problem_mark);
77+
78+static int
79+yaml_parser_set_parser_error_context(yaml_parser_t *parser,
80+ const char *context, yaml_mark_t context_mark,
81+ const char *problem, yaml_mark_t problem_mark);
82+
83+/*
84+ * State functions.
85+ */
86+
87+static int
88+yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event);
89+
90+static int
91+yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event);
92+
93+static int
94+yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
95+ int implicit);
96+
97+static int
98+yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event);
99+
100+static int
101+yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event);
102+
103+static int
104+yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
105+ int block, int indentless_sequence);
106+
107+static int
108+yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
109+ yaml_event_t *event, int first);
110+
111+static int
112+yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
113+ yaml_event_t *event);
114+
115+static int
116+yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
117+ yaml_event_t *event, int first);
118+
119+static int
120+yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
121+ yaml_event_t *event);
122+
123+static int
124+yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
125+ yaml_event_t *event, int first);
126+
127+static int
128+yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
129+ yaml_event_t *event);
130+
131+static int
132+yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
133+ yaml_event_t *event);
134+
135+static int
136+yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
137+ yaml_event_t *event);
138+
139+static int
140+yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
141+ yaml_event_t *event, int first);
142+
143+static int
144+yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
145+ yaml_event_t *event, int empty);
146+
147+/*
148+ * Utility functions.
149+ */
150+
151+static int
152+yaml_parser_process_empty_scalar(yaml_parser_t *parser,
153+ yaml_event_t *event, yaml_mark_t mark);
154+
155+static int
156+yaml_parser_process_directives(yaml_parser_t *parser,
157+ yaml_version_directive_t **version_directive_ref,
158+ yaml_tag_directive_t **tag_directives_start_ref,
159+ yaml_tag_directive_t **tag_directives_end_ref);
160+
161+static int
162+yaml_parser_append_tag_directive(yaml_parser_t *parser,
163+ yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark);
164+
165+/*
166+ * Get the next event.
167+ */
168+
169+YAML_DECLARE(int)
170+yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event)
171+{
172+ assert(parser); /* Non-NULL parser object is expected. */
173+ assert(event); /* Non-NULL event object is expected. */
174+
175+ /* Erase the event object. */
176+
177+ memset(event, 0, sizeof(yaml_event_t));
178+
179+ /* No events after the end of the stream or error. */
180+
181+ if (parser->stream_end_produced || parser->error ||
182+ parser->state == YAML_PARSE_END_STATE) {
183+ return 1;
184+ }
185+
186+ /* Generate the next event. */
187+
188+ return yaml_parser_state_machine(parser, event);
189+}
190+
191+/*
192+ * Set parser error.
193+ */
194+
195+static int
196+yaml_parser_set_parser_error(yaml_parser_t *parser,
197+ const char *problem, yaml_mark_t problem_mark)
198+{
199+ parser->error = YAML_PARSER_ERROR;
200+ parser->problem = problem;
201+ parser->problem_mark = problem_mark;
202+
203+ return 0;
204+}
205+
206+static int
207+yaml_parser_set_parser_error_context(yaml_parser_t *parser,
208+ const char *context, yaml_mark_t context_mark,
209+ const char *problem, yaml_mark_t problem_mark)
210+{
211+ parser->error = YAML_PARSER_ERROR;
212+ parser->context = context;
213+ parser->context_mark = context_mark;
214+ parser->problem = problem;
215+ parser->problem_mark = problem_mark;
216+
217+ return 0;
218+}
219+
220+
221+/*
222+ * State dispatcher.
223+ */
224+
225+static int
226+yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event)
227+{
228+ switch (parser->state)
229+ {
230+ case YAML_PARSE_STREAM_START_STATE:
231+ return yaml_parser_parse_stream_start(parser, event);
232+
233+ case YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE:
234+ return yaml_parser_parse_document_start(parser, event, 1);
235+
236+ case YAML_PARSE_DOCUMENT_START_STATE:
237+ return yaml_parser_parse_document_start(parser, event, 0);
238+
239+ case YAML_PARSE_DOCUMENT_CONTENT_STATE:
240+ return yaml_parser_parse_document_content(parser, event);
241+
242+ case YAML_PARSE_DOCUMENT_END_STATE:
243+ return yaml_parser_parse_document_end(parser, event);
244+
245+ case YAML_PARSE_BLOCK_NODE_STATE:
246+ return yaml_parser_parse_node(parser, event, 1, 0);
247+
248+ case YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
249+ return yaml_parser_parse_node(parser, event, 1, 1);
250+
251+ case YAML_PARSE_FLOW_NODE_STATE:
252+ return yaml_parser_parse_node(parser, event, 0, 0);
253+
254+ case YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
255+ return yaml_parser_parse_block_sequence_entry(parser, event, 1);
256+
257+ case YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
258+ return yaml_parser_parse_block_sequence_entry(parser, event, 0);
259+
260+ case YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
261+ return yaml_parser_parse_indentless_sequence_entry(parser, event);
262+
263+ case YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
264+ return yaml_parser_parse_block_mapping_key(parser, event, 1);
265+
266+ case YAML_PARSE_BLOCK_MAPPING_KEY_STATE:
267+ return yaml_parser_parse_block_mapping_key(parser, event, 0);
268+
269+ case YAML_PARSE_BLOCK_MAPPING_VALUE_STATE:
270+ return yaml_parser_parse_block_mapping_value(parser, event);
271+
272+ case YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
273+ return yaml_parser_parse_flow_sequence_entry(parser, event, 1);
274+
275+ case YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
276+ return yaml_parser_parse_flow_sequence_entry(parser, event, 0);
277+
278+ case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
279+ return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event);
280+
281+ case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
282+ return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event);
283+
284+ case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
285+ return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event);
286+
287+ case YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
288+ return yaml_parser_parse_flow_mapping_key(parser, event, 1);
289+
290+ case YAML_PARSE_FLOW_MAPPING_KEY_STATE:
291+ return yaml_parser_parse_flow_mapping_key(parser, event, 0);
292+
293+ case YAML_PARSE_FLOW_MAPPING_VALUE_STATE:
294+ return yaml_parser_parse_flow_mapping_value(parser, event, 0);
295+
296+ case YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
297+ return yaml_parser_parse_flow_mapping_value(parser, event, 1);
298+
299+ default:
300+ assert(1); /* Invalid state. */
301+ }
302+
303+ return 0;
304+}
305+
306+/*
307+ * Parse the production:
308+ * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
309+ * ************
310+ */
311+
312+static int
313+yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event)
314+{
315+ yaml_token_t *token;
316+
317+ token = PEEK_TOKEN(parser);
318+ if (!token) return 0;
319+
320+ if (token->type != YAML_STREAM_START_TOKEN) {
321+ return yaml_parser_set_parser_error(parser,
322+ "did not find expected <stream-start>", token->start_mark);
323+ }
324+
325+ parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
326+ STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding,
327+ token->start_mark, token->start_mark);
328+ SKIP_TOKEN(parser);
329+
330+ return 1;
331+}
332+
333+/*
334+ * Parse the productions:
335+ * implicit_document ::= block_node DOCUMENT-END*
336+ * *
337+ * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
338+ * *************************
339+ */
340+
341+static int
342+yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
343+ int implicit)
344+{
345+ yaml_token_t *token;
346+ yaml_version_directive_t *version_directive = NULL;
347+ struct {
348+ yaml_tag_directive_t *start;
349+ yaml_tag_directive_t *end;
350+ } tag_directives = { NULL, NULL };
351+
352+ token = PEEK_TOKEN(parser);
353+ if (!token) return 0;
354+
355+ /* Parse extra document end indicators. */
356+
357+ if (!implicit)
358+ {
359+ while (token->type == YAML_DOCUMENT_END_TOKEN) {
360+ SKIP_TOKEN(parser);
361+ token = PEEK_TOKEN(parser);
362+ if (!token) return 0;
363+ }
364+ }
365+
366+ /* Parse an implicit document. */
367+
368+ if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&
369+ token->type != YAML_TAG_DIRECTIVE_TOKEN &&
370+ token->type != YAML_DOCUMENT_START_TOKEN &&
371+ token->type != YAML_STREAM_END_TOKEN)
372+ {
373+ if (!yaml_parser_process_directives(parser, NULL, NULL, NULL))
374+ return 0;
375+ if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
376+ return 0;
377+ parser->state = YAML_PARSE_BLOCK_NODE_STATE;
378+ DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1,
379+ token->start_mark, token->start_mark);
380+ return 1;
381+ }
382+
383+ /* Parse an explicit document. */
384+
385+ else if (token->type != YAML_STREAM_END_TOKEN)
386+ {
387+ yaml_mark_t start_mark, end_mark;
388+ start_mark = token->start_mark;
389+ if (!yaml_parser_process_directives(parser, &version_directive,
390+ &tag_directives.start, &tag_directives.end))
391+ return 0;
392+ token = PEEK_TOKEN(parser);
393+ if (!token) goto error;
394+ if (token->type != YAML_DOCUMENT_START_TOKEN) {
395+ yaml_parser_set_parser_error(parser,
396+ "did not find expected <document start>", token->start_mark);
397+ goto error;
398+ }
399+ if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
400+ goto error;
401+ parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
402+ end_mark = token->end_mark;
403+ DOCUMENT_START_EVENT_INIT(*event, version_directive,
404+ tag_directives.start, tag_directives.end, 0,
405+ start_mark, end_mark);
406+ SKIP_TOKEN(parser);
407+ version_directive = NULL;
408+ tag_directives.start = tag_directives.end = NULL;
409+ return 1;
410+ }
411+
412+ /* Parse the stream end. */
413+
414+ else
415+ {
416+ parser->state = YAML_PARSE_END_STATE;
417+ STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
418+ SKIP_TOKEN(parser);
419+ return 1;
420+ }
421+
422+error:
423+ yaml_free(version_directive);
424+ while (tag_directives.start != tag_directives.end) {
425+ yaml_free(tag_directives.end[-1].handle);
426+ yaml_free(tag_directives.end[-1].prefix);
427+ tag_directives.end --;
428+ }
429+ yaml_free(tag_directives.start);
430+ return 0;
431+}
432+
433+/*
434+ * Parse the productions:
435+ * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
436+ * ***********
437+ */
438+
439+static int
440+yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event)
441+{
442+ yaml_token_t *token;
443+
444+ token = PEEK_TOKEN(parser);
445+ if (!token) return 0;
446+
447+ if (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
448+ token->type == YAML_TAG_DIRECTIVE_TOKEN ||
449+ token->type == YAML_DOCUMENT_START_TOKEN ||
450+ token->type == YAML_DOCUMENT_END_TOKEN ||
451+ token->type == YAML_STREAM_END_TOKEN) {
452+ parser->state = POP(parser, parser->states);
453+ return yaml_parser_process_empty_scalar(parser, event,
454+ token->start_mark);
455+ }
456+ else {
457+ return yaml_parser_parse_node(parser, event, 1, 0);
458+ }
459+}
460+
461+/*
462+ * Parse the productions:
463+ * implicit_document ::= block_node DOCUMENT-END*
464+ * *************
465+ * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
466+ * *************
467+ */
468+
469+static int
470+yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event)
471+{
472+ yaml_token_t *token;
473+ yaml_mark_t start_mark, end_mark;
474+ int implicit = 1;
475+
476+ token = PEEK_TOKEN(parser);
477+ if (!token) return 0;
478+
479+ start_mark = end_mark = token->start_mark;
480+
481+ if (token->type == YAML_DOCUMENT_END_TOKEN) {
482+ end_mark = token->end_mark;
483+ SKIP_TOKEN(parser);
484+ implicit = 0;
485+ }
486+
487+ while (!STACK_EMPTY(parser, parser->tag_directives)) {
488+ yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
489+ yaml_free(tag_directive.handle);
490+ yaml_free(tag_directive.prefix);
491+ }
492+
493+ parser->state = YAML_PARSE_DOCUMENT_START_STATE;
494+ DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark);
495+
496+ return 1;
497+}
498+
499+/*
500+ * Parse the productions:
501+ * block_node_or_indentless_sequence ::=
502+ * ALIAS
503+ * *****
504+ * | properties (block_content | indentless_block_sequence)?
505+ * ********** *
506+ * | block_content | indentless_block_sequence
507+ * *
508+ * block_node ::= ALIAS
509+ * *****
510+ * | properties block_content?
511+ * ********** *
512+ * | block_content
513+ * *
514+ * flow_node ::= ALIAS
515+ * *****
516+ * | properties flow_content?
517+ * ********** *
518+ * | flow_content
519+ * *
520+ * properties ::= TAG ANCHOR? | ANCHOR TAG?
521+ * *************************
522+ * block_content ::= block_collection | flow_collection | SCALAR
523+ * ******
524+ * flow_content ::= flow_collection | SCALAR
525+ * ******
526+ */
527+
528+static int
529+yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
530+ int block, int indentless_sequence)
531+{
532+ yaml_token_t *token;
533+ yaml_char_t *anchor = NULL;
534+ yaml_char_t *tag_handle = NULL;
535+ yaml_char_t *tag_suffix = NULL;
536+ yaml_char_t *tag = NULL;
537+ yaml_mark_t start_mark, end_mark, tag_mark;
538+ int implicit;
539+
540+ token = PEEK_TOKEN(parser);
541+ if (!token) return 0;
542+
543+ if (token->type == YAML_ALIAS_TOKEN)
544+ {
545+ parser->state = POP(parser, parser->states);
546+ ALIAS_EVENT_INIT(*event, token->data.alias.value,
547+ token->start_mark, token->end_mark);
548+ SKIP_TOKEN(parser);
549+ return 1;
550+ }
551+
552+ else
553+ {
554+ start_mark = end_mark = token->start_mark;
555+
556+ if (token->type == YAML_ANCHOR_TOKEN)
557+ {
558+ anchor = token->data.anchor.value;
559+ start_mark = token->start_mark;
560+ end_mark = token->end_mark;
561+ SKIP_TOKEN(parser);
562+ token = PEEK_TOKEN(parser);
563+ if (!token) goto error;
564+ if (token->type == YAML_TAG_TOKEN)
565+ {
566+ tag_handle = token->data.tag.handle;
567+ tag_suffix = token->data.tag.suffix;
568+ tag_mark = token->start_mark;
569+ end_mark = token->end_mark;
570+ SKIP_TOKEN(parser);
571+ token = PEEK_TOKEN(parser);
572+ if (!token) goto error;
573+ }
574+ }
575+ else if (token->type == YAML_TAG_TOKEN)
576+ {
577+ tag_handle = token->data.tag.handle;
578+ tag_suffix = token->data.tag.suffix;
579+ start_mark = tag_mark = token->start_mark;
580+ end_mark = token->end_mark;
581+ SKIP_TOKEN(parser);
582+ token = PEEK_TOKEN(parser);
583+ if (!token) goto error;
584+ if (token->type == YAML_ANCHOR_TOKEN)
585+ {
586+ anchor = token->data.anchor.value;
587+ end_mark = token->end_mark;
588+ SKIP_TOKEN(parser);
589+ token = PEEK_TOKEN(parser);
590+ if (!token) goto error;
591+ }
592+ }
593+
594+ if (tag_handle) {
595+ if (!*tag_handle) {
596+ tag = tag_suffix;
597+ yaml_free(tag_handle);
598+ tag_handle = tag_suffix = NULL;
599+ }
600+ else {
601+ yaml_tag_directive_t *tag_directive;
602+ for (tag_directive = parser->tag_directives.start;
603+ tag_directive != parser->tag_directives.top;
604+ tag_directive ++) {
605+ if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
606+ size_t prefix_len = strlen((char *)tag_directive->prefix);
607+ size_t suffix_len = strlen((char *)tag_suffix);
608+ tag = yaml_malloc(prefix_len+suffix_len+1);
609+ if (!tag) {
610+ parser->error = YAML_MEMORY_ERROR;
611+ goto error;
612+ }
613+ memcpy(tag, tag_directive->prefix, prefix_len);
614+ memcpy(tag+prefix_len, tag_suffix, suffix_len);
615+ tag[prefix_len+suffix_len] = '\0';
616+ yaml_free(tag_handle);
617+ yaml_free(tag_suffix);
618+ tag_handle = tag_suffix = NULL;
619+ break;
620+ }
621+ }
622+ if (!tag) {
623+ yaml_parser_set_parser_error_context(parser,
624+ "while parsing a node", start_mark,
625+ "found undefined tag handle", tag_mark);
626+ goto error;
627+ }
628+ }
629+ }
630+
631+ implicit = (!tag || !*tag);
632+ if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) {
633+ end_mark = token->end_mark;
634+ parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
635+ SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
636+ YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
637+ return 1;
638+ }
639+ else {
640+ if (token->type == YAML_SCALAR_TOKEN) {
641+ int plain_implicit = 0;
642+ int quoted_implicit = 0;
643+ end_mark = token->end_mark;
644+ if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag)
645+ || (tag && strcmp((char *)tag, "!") == 0)) {
646+ plain_implicit = 1;
647+ }
648+ else if (!tag) {
649+ quoted_implicit = 1;
650+ }
651+ parser->state = POP(parser, parser->states);
652+ SCALAR_EVENT_INIT(*event, anchor, tag,
653+ token->data.scalar.value, token->data.scalar.length,
654+ plain_implicit, quoted_implicit,
655+ token->data.scalar.style, start_mark, end_mark);
656+ SKIP_TOKEN(parser);
657+ return 1;
658+ }
659+ else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) {
660+ end_mark = token->end_mark;
661+ parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
662+ SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
663+ YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark);
664+ return 1;
665+ }
666+ else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) {
667+ end_mark = token->end_mark;
668+ parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
669+ MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
670+ YAML_FLOW_MAPPING_STYLE, start_mark, end_mark);
671+ return 1;
672+ }
673+ else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) {
674+ end_mark = token->end_mark;
675+ parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
676+ SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
677+ YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
678+ return 1;
679+ }
680+ else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) {
681+ end_mark = token->end_mark;
682+ parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
683+ MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
684+ YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark);
685+ return 1;
686+ }
687+ else if (anchor || tag) {
688+ yaml_char_t *value = yaml_malloc(1);
689+ if (!value) {
690+ parser->error = YAML_MEMORY_ERROR;
691+ goto error;
692+ }
693+ value[0] = '\0';
694+ parser->state = POP(parser, parser->states);
695+ SCALAR_EVENT_INIT(*event, anchor, tag, value, 0,
696+ implicit, 0, YAML_PLAIN_SCALAR_STYLE,
697+ start_mark, end_mark);
698+ return 1;
699+ }
700+ else {
701+ yaml_parser_set_parser_error_context(parser,
702+ (block ? "while parsing a block node"
703+ : "while parsing a flow node"), start_mark,
704+ "did not find expected node content", token->start_mark);
705+ goto error;
706+ }
707+ }
708+ }
709+
710+error:
711+ yaml_free(anchor);
712+ yaml_free(tag_handle);
713+ yaml_free(tag_suffix);
714+ yaml_free(tag);
715+
716+ return 0;
717+}
718+
719+/*
720+ * Parse the productions:
721+ * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
722+ * ******************** *********** * *********
723+ */
724+
725+static int
726+yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
727+ yaml_event_t *event, int first)
728+{
729+ yaml_token_t *token;
730+
731+ if (first) {
732+ token = PEEK_TOKEN(parser);
733+ if (!PUSH(parser, parser->marks, token->start_mark))
734+ return 0;
735+ SKIP_TOKEN(parser);
736+ }
737+
738+ token = PEEK_TOKEN(parser);
739+ if (!token) return 0;
740+
741+ if (token->type == YAML_BLOCK_ENTRY_TOKEN)
742+ {
743+ yaml_mark_t mark = token->end_mark;
744+ SKIP_TOKEN(parser);
745+ token = PEEK_TOKEN(parser);
746+ if (!token) return 0;
747+ if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
748+ token->type != YAML_BLOCK_END_TOKEN) {
749+ if (!PUSH(parser, parser->states,
750+ YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE))
751+ return 0;
752+ return yaml_parser_parse_node(parser, event, 1, 0);
753+ }
754+ else {
755+ parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
756+ return yaml_parser_process_empty_scalar(parser, event, mark);
757+ }
758+ }
759+
760+ else if (token->type == YAML_BLOCK_END_TOKEN)
761+ {
762+ yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
763+ parser->state = POP(parser, parser->states);
764+ dummy_mark = POP(parser, parser->marks);
765+ SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
766+ SKIP_TOKEN(parser);
767+ return 1;
768+ }
769+
770+ else
771+ {
772+ return yaml_parser_set_parser_error_context(parser,
773+ "while parsing a block collection", POP(parser, parser->marks),
774+ "did not find expected '-' indicator", token->start_mark);
775+ }
776+}
777+
778+/*
779+ * Parse the productions:
780+ * indentless_sequence ::= (BLOCK-ENTRY block_node?)+
781+ * *********** *
782+ */
783+
784+static int
785+yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
786+ yaml_event_t *event)
787+{
788+ yaml_token_t *token;
789+
790+ token = PEEK_TOKEN(parser);
791+ if (!token) return 0;
792+
793+ if (token->type == YAML_BLOCK_ENTRY_TOKEN)
794+ {
795+ yaml_mark_t mark = token->end_mark;
796+ SKIP_TOKEN(parser);
797+ token = PEEK_TOKEN(parser);
798+ if (!token) return 0;
799+ if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
800+ token->type != YAML_KEY_TOKEN &&
801+ token->type != YAML_VALUE_TOKEN &&
802+ token->type != YAML_BLOCK_END_TOKEN) {
803+ if (!PUSH(parser, parser->states,
804+ YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE))
805+ return 0;
806+ return yaml_parser_parse_node(parser, event, 1, 0);
807+ }
808+ else {
809+ parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
810+ return yaml_parser_process_empty_scalar(parser, event, mark);
811+ }
812+ }
813+
814+ else
815+ {
816+ parser->state = POP(parser, parser->states);
817+ SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
818+ return 1;
819+ }
820+}
821+
822+/*
823+ * Parse the productions:
824+ * block_mapping ::= BLOCK-MAPPING_START
825+ * *******************
826+ * ((KEY block_node_or_indentless_sequence?)?
827+ * *** *
828+ * (VALUE block_node_or_indentless_sequence?)?)*
829+ *
830+ * BLOCK-END
831+ * *********
832+ */
833+
834+static int
835+yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
836+ yaml_event_t *event, int first)
837+{
838+ yaml_token_t *token;
839+
840+ if (first) {
841+ token = PEEK_TOKEN(parser);
842+ if (!PUSH(parser, parser->marks, token->start_mark))
843+ return 0;
844+ SKIP_TOKEN(parser);
845+ }
846+
847+ token = PEEK_TOKEN(parser);
848+ if (!token) return 0;
849+
850+ if (token->type == YAML_KEY_TOKEN)
851+ {
852+ yaml_mark_t mark = token->end_mark;
853+ SKIP_TOKEN(parser);
854+ token = PEEK_TOKEN(parser);
855+ if (!token) return 0;
856+ if (token->type != YAML_KEY_TOKEN &&
857+ token->type != YAML_VALUE_TOKEN &&
858+ token->type != YAML_BLOCK_END_TOKEN) {
859+ if (!PUSH(parser, parser->states,
860+ YAML_PARSE_BLOCK_MAPPING_VALUE_STATE))
861+ return 0;
862+ return yaml_parser_parse_node(parser, event, 1, 1);
863+ }
864+ else {
865+ parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
866+ return yaml_parser_process_empty_scalar(parser, event, mark);
867+ }
868+ }
869+
870+ else if (token->type == YAML_BLOCK_END_TOKEN)
871+ {
872+ yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
873+ parser->state = POP(parser, parser->states);
874+ dummy_mark = POP(parser, parser->marks);
875+ MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
876+ SKIP_TOKEN(parser);
877+ return 1;
878+ }
879+
880+ else
881+ {
882+ return yaml_parser_set_parser_error_context(parser,
883+ "while parsing a block mapping", POP(parser, parser->marks),
884+ "did not find expected key", token->start_mark);
885+ }
886+}
887+
888+/*
889+ * Parse the productions:
890+ * block_mapping ::= BLOCK-MAPPING_START
891+ *
892+ * ((KEY block_node_or_indentless_sequence?)?
893+ *
894+ * (VALUE block_node_or_indentless_sequence?)?)*
895+ * ***** *
896+ * BLOCK-END
897+ *
898+ */
899+
900+static int
901+yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
902+ yaml_event_t *event)
903+{
904+ yaml_token_t *token;
905+
906+ token = PEEK_TOKEN(parser);
907+ if (!token) return 0;
908+
909+ if (token->type == YAML_VALUE_TOKEN)
910+ {
911+ yaml_mark_t mark = token->end_mark;
912+ SKIP_TOKEN(parser);
913+ token = PEEK_TOKEN(parser);
914+ if (!token) return 0;
915+ if (token->type != YAML_KEY_TOKEN &&
916+ token->type != YAML_VALUE_TOKEN &&
917+ token->type != YAML_BLOCK_END_TOKEN) {
918+ if (!PUSH(parser, parser->states,
919+ YAML_PARSE_BLOCK_MAPPING_KEY_STATE))
920+ return 0;
921+ return yaml_parser_parse_node(parser, event, 1, 1);
922+ }
923+ else {
924+ parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
925+ return yaml_parser_process_empty_scalar(parser, event, mark);
926+ }
927+ }
928+
929+ else
930+ {
931+ parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
932+ return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
933+ }
934+}
935+
936+/*
937+ * Parse the productions:
938+ * flow_sequence ::= FLOW-SEQUENCE-START
939+ * *******************
940+ * (flow_sequence_entry FLOW-ENTRY)*
941+ * * **********
942+ * flow_sequence_entry?
943+ * *
944+ * FLOW-SEQUENCE-END
945+ * *****************
946+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
947+ * *
948+ */
949+
950+static int
951+yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
952+ yaml_event_t *event, int first)
953+{
954+ yaml_token_t *token;
955+ yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
956+
957+ if (first) {
958+ token = PEEK_TOKEN(parser);
959+ if (!PUSH(parser, parser->marks, token->start_mark))
960+ return 0;
961+ SKIP_TOKEN(parser);
962+ }
963+
964+ token = PEEK_TOKEN(parser);
965+ if (!token) return 0;
966+
967+ if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN)
968+ {
969+ if (!first) {
970+ if (token->type == YAML_FLOW_ENTRY_TOKEN) {
971+ SKIP_TOKEN(parser);
972+ token = PEEK_TOKEN(parser);
973+ if (!token) return 0;
974+ }
975+ else {
976+ return yaml_parser_set_parser_error_context(parser,
977+ "while parsing a flow sequence", POP(parser, parser->marks),
978+ "did not find expected ',' or ']'", token->start_mark);
979+ }
980+ }
981+
982+ if (token->type == YAML_KEY_TOKEN) {
983+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE;
984+ MAPPING_START_EVENT_INIT(*event, NULL, NULL,
985+ 1, YAML_FLOW_MAPPING_STYLE,
986+ token->start_mark, token->end_mark);
987+ SKIP_TOKEN(parser);
988+ return 1;
989+ }
990+
991+ else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
992+ if (!PUSH(parser, parser->states,
993+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE))
994+ return 0;
995+ return yaml_parser_parse_node(parser, event, 0, 0);
996+ }
997+ }
998+
999+ parser->state = POP(parser, parser->states);
1000+ dummy_mark = POP(parser, parser->marks);
1001+ SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
1002+ SKIP_TOKEN(parser);
1003+ return 1;
1004+}
1005+
1006+/*
1007+ * Parse the productions:
1008+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1009+ * *** *
1010+ */
1011+
1012+static int
1013+yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
1014+ yaml_event_t *event)
1015+{
1016+ yaml_token_t *token;
1017+
1018+ token = PEEK_TOKEN(parser);
1019+ if (!token) return 0;
1020+
1021+ if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN
1022+ && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
1023+ if (!PUSH(parser, parser->states,
1024+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE))
1025+ return 0;
1026+ return yaml_parser_parse_node(parser, event, 0, 0);
1027+ }
1028+ else {
1029+ yaml_mark_t mark = token->end_mark;
1030+ SKIP_TOKEN(parser);
1031+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
1032+ return yaml_parser_process_empty_scalar(parser, event, mark);
1033+ }
1034+}
1035+
1036+/*
1037+ * Parse the productions:
1038+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1039+ * ***** *
1040+ */
1041+
1042+static int
1043+yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
1044+ yaml_event_t *event)
1045+{
1046+ yaml_token_t *token;
1047+
1048+ token = PEEK_TOKEN(parser);
1049+ if (!token) return 0;
1050+
1051+ if (token->type == YAML_VALUE_TOKEN) {
1052+ SKIP_TOKEN(parser);
1053+ token = PEEK_TOKEN(parser);
1054+ if (!token) return 0;
1055+ if (token->type != YAML_FLOW_ENTRY_TOKEN
1056+ && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
1057+ if (!PUSH(parser, parser->states,
1058+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE))
1059+ return 0;
1060+ return yaml_parser_parse_node(parser, event, 0, 0);
1061+ }
1062+ }
1063+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
1064+ return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
1065+}
1066+
1067+/*
1068+ * Parse the productions:
1069+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1070+ * *
1071+ */
1072+
1073+static int
1074+yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
1075+ yaml_event_t *event)
1076+{
1077+ yaml_token_t *token;
1078+
1079+ token = PEEK_TOKEN(parser);
1080+ if (!token) return 0;
1081+
1082+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
1083+
1084+ MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
1085+ return 1;
1086+}
1087+
1088+/*
1089+ * Parse the productions:
1090+ * flow_mapping ::= FLOW-MAPPING-START
1091+ * ******************
1092+ * (flow_mapping_entry FLOW-ENTRY)*
1093+ * * **********
1094+ * flow_mapping_entry?
1095+ * ******************
1096+ * FLOW-MAPPING-END
1097+ * ****************
1098+ * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1099+ * * *** *
1100+ */
1101+
1102+static int
1103+yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
1104+ yaml_event_t *event, int first)
1105+{
1106+ yaml_token_t *token;
1107+ yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
1108+
1109+ if (first) {
1110+ token = PEEK_TOKEN(parser);
1111+ if (!PUSH(parser, parser->marks, token->start_mark))
1112+ return 0;
1113+ SKIP_TOKEN(parser);
1114+ }
1115+
1116+ token = PEEK_TOKEN(parser);
1117+ if (!token) return 0;
1118+
1119+ if (token->type != YAML_FLOW_MAPPING_END_TOKEN)
1120+ {
1121+ if (!first) {
1122+ if (token->type == YAML_FLOW_ENTRY_TOKEN) {
1123+ SKIP_TOKEN(parser);
1124+ token = PEEK_TOKEN(parser);
1125+ if (!token) return 0;
1126+ }
1127+ else {
1128+ return yaml_parser_set_parser_error_context(parser,
1129+ "while parsing a flow mapping", POP(parser, parser->marks),
1130+ "did not find expected ',' or '}'", token->start_mark);
1131+ }
1132+ }
1133+
1134+ if (token->type == YAML_KEY_TOKEN) {
1135+ SKIP_TOKEN(parser);
1136+ token = PEEK_TOKEN(parser);
1137+ if (!token) return 0;
1138+ if (token->type != YAML_VALUE_TOKEN
1139+ && token->type != YAML_FLOW_ENTRY_TOKEN
1140+ && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1141+ if (!PUSH(parser, parser->states,
1142+ YAML_PARSE_FLOW_MAPPING_VALUE_STATE))
1143+ return 0;
1144+ return yaml_parser_parse_node(parser, event, 0, 0);
1145+ }
1146+ else {
1147+ parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
1148+ return yaml_parser_process_empty_scalar(parser, event,
1149+ token->start_mark);
1150+ }
1151+ }
1152+ else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1153+ if (!PUSH(parser, parser->states,
1154+ YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE))
1155+ return 0;
1156+ return yaml_parser_parse_node(parser, event, 0, 0);
1157+ }
1158+ }
1159+
1160+ parser->state = POP(parser, parser->states);
1161+ dummy_mark = POP(parser, parser->marks);
1162+ MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
1163+ SKIP_TOKEN(parser);
1164+ return 1;
1165+}
1166+
1167+/*
1168+ * Parse the productions:
1169+ * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1170+ * * ***** *
1171+ */
1172+
1173+static int
1174+yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
1175+ yaml_event_t *event, int empty)
1176+{
1177+ yaml_token_t *token;
1178+
1179+ token = PEEK_TOKEN(parser);
1180+ if (!token) return 0;
1181+
1182+ if (empty) {
1183+ parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1184+ return yaml_parser_process_empty_scalar(parser, event,
1185+ token->start_mark);
1186+ }
1187+
1188+ if (token->type == YAML_VALUE_TOKEN) {
1189+ SKIP_TOKEN(parser);
1190+ token = PEEK_TOKEN(parser);
1191+ if (!token) return 0;
1192+ if (token->type != YAML_FLOW_ENTRY_TOKEN
1193+ && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1194+ if (!PUSH(parser, parser->states,
1195+ YAML_PARSE_FLOW_MAPPING_KEY_STATE))
1196+ return 0;
1197+ return yaml_parser_parse_node(parser, event, 0, 0);
1198+ }
1199+ }
1200+
1201+ parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1202+ return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
1203+}
1204+
1205+/*
1206+ * Generate an empty scalar event.
1207+ */
1208+
1209+static int
1210+yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event,
1211+ yaml_mark_t mark)
1212+{
1213+ yaml_char_t *value;
1214+
1215+ value = yaml_malloc(1);
1216+ if (!value) {
1217+ parser->error = YAML_MEMORY_ERROR;
1218+ return 0;
1219+ }
1220+ value[0] = '\0';
1221+
1222+ SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0,
1223+ 1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark);
1224+
1225+ return 1;
1226+}
1227+
1228+/*
1229+ * Parse directives.
1230+ */
1231+
1232+static int
1233+yaml_parser_process_directives(yaml_parser_t *parser,
1234+ yaml_version_directive_t **version_directive_ref,
1235+ yaml_tag_directive_t **tag_directives_start_ref,
1236+ yaml_tag_directive_t **tag_directives_end_ref)
1237+{
1238+ yaml_tag_directive_t default_tag_directives[] = {
1239+ {(yaml_char_t *)"!", (yaml_char_t *)"!"},
1240+ {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
1241+ {NULL, NULL}
1242+ };
1243+ yaml_tag_directive_t *default_tag_directive;
1244+ yaml_version_directive_t *version_directive = NULL;
1245+ struct {
1246+ yaml_tag_directive_t *start;
1247+ yaml_tag_directive_t *end;
1248+ yaml_tag_directive_t *top;
1249+ } tag_directives = { NULL, NULL, NULL };
1250+ yaml_token_t *token;
1251+
1252+ if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))
1253+ goto error;
1254+
1255+ token = PEEK_TOKEN(parser);
1256+ if (!token) goto error;
1257+
1258+ while (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
1259+ token->type == YAML_TAG_DIRECTIVE_TOKEN)
1260+ {
1261+ if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) {
1262+ if (version_directive) {
1263+ yaml_parser_set_parser_error(parser,
1264+ "found duplicate %YAML directive", token->start_mark);
1265+ goto error;
1266+ }
1267+ if (token->data.version_directive.major != 1
1268+ || token->data.version_directive.minor != 1) {
1269+ yaml_parser_set_parser_error(parser,
1270+ "found incompatible YAML document", token->start_mark);
1271+ goto error;
1272+ }
1273+ version_directive = yaml_malloc(sizeof(yaml_version_directive_t));
1274+ if (!version_directive) {
1275+ parser->error = YAML_MEMORY_ERROR;
1276+ goto error;
1277+ }
1278+ version_directive->major = token->data.version_directive.major;
1279+ version_directive->minor = token->data.version_directive.minor;
1280+ }
1281+
1282+ else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
1283+ yaml_tag_directive_t value;
1284+ value.handle = token->data.tag_directive.handle;
1285+ value.prefix = token->data.tag_directive.prefix;
1286+
1287+ if (!yaml_parser_append_tag_directive(parser, value, 0,
1288+ token->start_mark))
1289+ goto error;
1290+ if (!PUSH(parser, tag_directives, value))
1291+ goto error;
1292+ }
1293+
1294+ SKIP_TOKEN(parser);
1295+ token = PEEK_TOKEN(parser);
1296+ if (!token) goto error;
1297+ }
1298+
1299+ for (default_tag_directive = default_tag_directives;
1300+ default_tag_directive->handle; default_tag_directive++) {
1301+ if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1,
1302+ token->start_mark))
1303+ goto error;
1304+ }
1305+
1306+ if (version_directive_ref) {
1307+ *version_directive_ref = version_directive;
1308+ }
1309+ if (tag_directives_start_ref) {
1310+ if (STACK_EMPTY(parser, tag_directives)) {
1311+ *tag_directives_start_ref = *tag_directives_end_ref = NULL;
1312+ STACK_DEL(parser, tag_directives);
1313+ }
1314+ else {
1315+ *tag_directives_start_ref = tag_directives.start;
1316+ *tag_directives_end_ref = tag_directives.top;
1317+ }
1318+ }
1319+ else {
1320+ STACK_DEL(parser, tag_directives);
1321+ }
1322+
1323+ return 1;
1324+
1325+error:
1326+ yaml_free(version_directive);
1327+ while (!STACK_EMPTY(parser, tag_directives)) {
1328+ yaml_tag_directive_t tag_directive = POP(parser, tag_directives);
1329+ yaml_free(tag_directive.handle);
1330+ yaml_free(tag_directive.prefix);
1331+ }
1332+ STACK_DEL(parser, tag_directives);
1333+ return 0;
1334+}
1335+
1336+/*
1337+ * Append a tag directive to the directives stack.
1338+ */
1339+
1340+static int
1341+yaml_parser_append_tag_directive(yaml_parser_t *parser,
1342+ yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
1343+{
1344+ yaml_tag_directive_t *tag_directive;
1345+ yaml_tag_directive_t copy = { NULL, NULL };
1346+
1347+ for (tag_directive = parser->tag_directives.start;
1348+ tag_directive != parser->tag_directives.top; tag_directive ++) {
1349+ if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
1350+ if (allow_duplicates)
1351+ return 1;
1352+ return yaml_parser_set_parser_error(parser,
1353+ "found duplicate %TAG directive", mark);
1354+ }
1355+ }
1356+
1357+ copy.handle = yaml_strdup(value.handle);
1358+ copy.prefix = yaml_strdup(value.prefix);
1359+ if (!copy.handle || !copy.prefix) {
1360+ parser->error = YAML_MEMORY_ERROR;
1361+ goto error;
1362+ }
1363+
1364+ if (!PUSH(parser, parser->tag_directives, copy))
1365+ goto error;
1366+
1367+ return 1;
1368+
1369+error:
1370+ yaml_free(copy.handle);
1371+ yaml_free(copy.prefix);
1372+ return 0;
1373+}
1374+
libyaml/reader.cnew file+465
@@ -0,0 +1,465 @@
1+
2+#include "yaml_private.h"
3+
4+/*
5+ * Declarations.
6+ */
7+
8+static int
9+yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem,
10+ size_t offset, int value);
11+
12+static int
13+yaml_parser_update_raw_buffer(yaml_parser_t *parser);
14+
15+static int
16+yaml_parser_determine_encoding(yaml_parser_t *parser);
17+
18+YAML_DECLARE(int)
19+yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
20+
21+/*
22+ * Set the reader error and return 0.
23+ */
24+
25+static int
26+yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem,
27+ size_t offset, int value)
28+{
29+ parser->error = YAML_READER_ERROR;
30+ parser->problem = problem;
31+ parser->problem_offset = offset;
32+ parser->problem_value = value;
33+
34+ return 0;
35+}
36+
37+/*
38+ * Byte order marks.
39+ */
40+
41+#define BOM_UTF8 "\xef\xbb\xbf"
42+#define BOM_UTF16LE "\xff\xfe"
43+#define BOM_UTF16BE "\xfe\xff"
44+
45+/*
46+ * Determine the input stream encoding by checking the BOM symbol. If no BOM is
47+ * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
48+ */
49+
50+static int
51+yaml_parser_determine_encoding(yaml_parser_t *parser)
52+{
53+ /* Ensure that we had enough bytes in the raw buffer. */
54+
55+ while (!parser->eof
56+ && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) {
57+ if (!yaml_parser_update_raw_buffer(parser)) {
58+ return 0;
59+ }
60+ }
61+
62+ /* Determine the encoding. */
63+
64+ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2
65+ && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) {
66+ parser->encoding = YAML_UTF16LE_ENCODING;
67+ parser->raw_buffer.pointer += 2;
68+ parser->offset += 2;
69+ }
70+ else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2
71+ && !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) {
72+ parser->encoding = YAML_UTF16BE_ENCODING;
73+ parser->raw_buffer.pointer += 2;
74+ parser->offset += 2;
75+ }
76+ else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3
77+ && !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) {
78+ parser->encoding = YAML_UTF8_ENCODING;
79+ parser->raw_buffer.pointer += 3;
80+ parser->offset += 3;
81+ }
82+ else {
83+ parser->encoding = YAML_UTF8_ENCODING;
84+ }
85+
86+ return 1;
87+}
88+
89+/*
90+ * Update the raw buffer.
91+ */
92+
93+static int
94+yaml_parser_update_raw_buffer(yaml_parser_t *parser)
95+{
96+ size_t size_read = 0;
97+
98+ /* Return if the raw buffer is full. */
99+
100+ if (parser->raw_buffer.start == parser->raw_buffer.pointer
101+ && parser->raw_buffer.last == parser->raw_buffer.end)
102+ return 1;
103+
104+ /* Return on EOF. */
105+
106+ if (parser->eof) return 1;
107+
108+ /* Move the remaining bytes in the raw buffer to the beginning. */
109+
110+ if (parser->raw_buffer.start < parser->raw_buffer.pointer
111+ && parser->raw_buffer.pointer < parser->raw_buffer.last) {
112+ memmove(parser->raw_buffer.start, parser->raw_buffer.pointer,
113+ parser->raw_buffer.last - parser->raw_buffer.pointer);
114+ }
115+ parser->raw_buffer.last -=
116+ parser->raw_buffer.pointer - parser->raw_buffer.start;
117+ parser->raw_buffer.pointer = parser->raw_buffer.start;
118+
119+ /* Call the read handler to fill the buffer. */
120+
121+ if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last,
122+ parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) {
123+ return yaml_parser_set_reader_error(parser, "input error",
124+ parser->offset, -1);
125+ }
126+ parser->raw_buffer.last += size_read;
127+ if (!size_read) {
128+ parser->eof = 1;
129+ }
130+
131+ return 1;
132+}
133+
134+/*
135+ * Ensure that the buffer contains at least `length` characters.
136+ * Return 1 on success, 0 on failure.
137+ *
138+ * The length is supposed to be significantly less that the buffer size.
139+ */
140+
141+YAML_DECLARE(int)
142+yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
143+{
144+ int first = 1;
145+
146+ assert(parser->read_handler); /* Read handler must be set. */
147+
148+ /* If the EOF flag is set and the raw buffer is empty, do nothing. */
149+
150+ if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last)
151+ return 1;
152+
153+ /* Return if the buffer contains enough characters. */
154+
155+ if (parser->unread >= length)
156+ return 1;
157+
158+ /* Determine the input encoding if it is not known yet. */
159+
160+ if (!parser->encoding) {
161+ if (!yaml_parser_determine_encoding(parser))
162+ return 0;
163+ }
164+
165+ /* Move the unread characters to the beginning of the buffer. */
166+
167+ if (parser->buffer.start < parser->buffer.pointer
168+ && parser->buffer.pointer < parser->buffer.last) {
169+ size_t size = parser->buffer.last - parser->buffer.pointer;
170+ memmove(parser->buffer.start, parser->buffer.pointer, size);
171+ parser->buffer.pointer = parser->buffer.start;
172+ parser->buffer.last = parser->buffer.start + size;
173+ }
174+ else if (parser->buffer.pointer == parser->buffer.last) {
175+ parser->buffer.pointer = parser->buffer.start;
176+ parser->buffer.last = parser->buffer.start;
177+ }
178+
179+ /* Fill the buffer until it has enough characters. */
180+
181+ while (parser->unread < length)
182+ {
183+ /* Fill the raw buffer if necessary. */
184+
185+ if (!first || parser->raw_buffer.pointer == parser->raw_buffer.last) {
186+ if (!yaml_parser_update_raw_buffer(parser)) return 0;
187+ }
188+ first = 0;
189+
190+ /* Decode the raw buffer. */
191+
192+ while (parser->raw_buffer.pointer != parser->raw_buffer.last)
193+ {
194+ unsigned int value = 0, value2 = 0;
195+ int incomplete = 0;
196+ unsigned char octet;
197+ unsigned int width = 0;
198+ int low, high;
199+ size_t k;
200+ size_t raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer;
201+
202+ /* Decode the next character. */
203+
204+ switch (parser->encoding)
205+ {
206+ case YAML_UTF8_ENCODING:
207+
208+ /*
209+ * Decode a UTF-8 character. Check RFC 3629
210+ * (http://www.ietf.org/rfc/rfc3629.txt) for more details.
211+ *
212+ * The following table (taken from the RFC) is used for
213+ * decoding.
214+ *
215+ * Char. number range | UTF-8 octet sequence
216+ * (hexadecimal) | (binary)
217+ * --------------------+------------------------------------
218+ * 0000 0000-0000 007F | 0xxxxxxx
219+ * 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
220+ * 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
221+ * 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
222+ *
223+ * Additionally, the characters in the range 0xD800-0xDFFF
224+ * are prohibited as they are reserved for use with UTF-16
225+ * surrogate pairs.
226+ */
227+
228+ /* Determine the length of the UTF-8 sequence. */
229+
230+ octet = parser->raw_buffer.pointer[0];
231+ width = (octet & 0x80) == 0x00 ? 1 :
232+ (octet & 0xE0) == 0xC0 ? 2 :
233+ (octet & 0xF0) == 0xE0 ? 3 :
234+ (octet & 0xF8) == 0xF0 ? 4 : 0;
235+
236+ /* Check if the leading octet is valid. */
237+
238+ if (!width)
239+ return yaml_parser_set_reader_error(parser,
240+ "invalid leading UTF-8 octet",
241+ parser->offset, octet);
242+
243+ /* Check if the raw buffer contains an incomplete character. */
244+
245+ if (width > raw_unread) {
246+ if (parser->eof) {
247+ return yaml_parser_set_reader_error(parser,
248+ "incomplete UTF-8 octet sequence",
249+ parser->offset, -1);
250+ }
251+ incomplete = 1;
252+ break;
253+ }
254+
255+ /* Decode the leading octet. */
256+
257+ value = (octet & 0x80) == 0x00 ? octet & 0x7F :
258+ (octet & 0xE0) == 0xC0 ? octet & 0x1F :
259+ (octet & 0xF0) == 0xE0 ? octet & 0x0F :
260+ (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
261+
262+ /* Check and decode the trailing octets. */
263+
264+ for (k = 1; k < width; k ++)
265+ {
266+ octet = parser->raw_buffer.pointer[k];
267+
268+ /* Check if the octet is valid. */
269+
270+ if ((octet & 0xC0) != 0x80)
271+ return yaml_parser_set_reader_error(parser,
272+ "invalid trailing UTF-8 octet",
273+ parser->offset+k, octet);
274+
275+ /* Decode the octet. */
276+
277+ value = (value << 6) + (octet & 0x3F);
278+ }
279+
280+ /* Check the length of the sequence against the value. */
281+
282+ if (!((width == 1) ||
283+ (width == 2 && value >= 0x80) ||
284+ (width == 3 && value >= 0x800) ||
285+ (width == 4 && value >= 0x10000)))
286+ return yaml_parser_set_reader_error(parser,
287+ "invalid length of a UTF-8 sequence",
288+ parser->offset, -1);
289+
290+ /* Check the range of the value. */
291+
292+ if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF)
293+ return yaml_parser_set_reader_error(parser,
294+ "invalid Unicode character",
295+ parser->offset, value);
296+
297+ break;
298+
299+ case YAML_UTF16LE_ENCODING:
300+ case YAML_UTF16BE_ENCODING:
301+
302+ low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
303+ high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
304+
305+ /*
306+ * The UTF-16 encoding is not as simple as one might
307+ * naively think. Check RFC 2781
308+ * (http://www.ietf.org/rfc/rfc2781.txt).
309+ *
310+ * Normally, two subsequent bytes describe a Unicode
311+ * character. However a special technique (called a
312+ * surrogate pair) is used for specifying character
313+ * values larger than 0xFFFF.
314+ *
315+ * A surrogate pair consists of two pseudo-characters:
316+ * high surrogate area (0xD800-0xDBFF)
317+ * low surrogate area (0xDC00-0xDFFF)
318+ *
319+ * The following formulas are used for decoding
320+ * and encoding characters using surrogate pairs:
321+ *
322+ * U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
323+ * U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
324+ * W1 = 110110yyyyyyyyyy
325+ * W2 = 110111xxxxxxxxxx
326+ *
327+ * where U is the character value, W1 is the high surrogate
328+ * area, W2 is the low surrogate area.
329+ */
330+
331+ /* Check for incomplete UTF-16 character. */
332+
333+ if (raw_unread < 2) {
334+ if (parser->eof) {
335+ return yaml_parser_set_reader_error(parser,
336+ "incomplete UTF-16 character",
337+ parser->offset, -1);
338+ }
339+ incomplete = 1;
340+ break;
341+ }
342+
343+ /* Get the character. */
344+
345+ value = parser->raw_buffer.pointer[low]
346+ + (parser->raw_buffer.pointer[high] << 8);
347+
348+ /* Check for unexpected low surrogate area. */
349+
350+ if ((value & 0xFC00) == 0xDC00)
351+ return yaml_parser_set_reader_error(parser,
352+ "unexpected low surrogate area",
353+ parser->offset, value);
354+
355+ /* Check for a high surrogate area. */
356+
357+ if ((value & 0xFC00) == 0xD800) {
358+
359+ width = 4;
360+
361+ /* Check for incomplete surrogate pair. */
362+
363+ if (raw_unread < 4) {
364+ if (parser->eof) {
365+ return yaml_parser_set_reader_error(parser,
366+ "incomplete UTF-16 surrogate pair",
367+ parser->offset, -1);
368+ }
369+ incomplete = 1;
370+ break;
371+ }
372+
373+ /* Get the next character. */
374+
375+ value2 = parser->raw_buffer.pointer[low+2]
376+ + (parser->raw_buffer.pointer[high+2] << 8);
377+
378+ /* Check for a low surrogate area. */
379+
380+ if ((value2 & 0xFC00) != 0xDC00)
381+ return yaml_parser_set_reader_error(parser,
382+ "expected low surrogate area",
383+ parser->offset+2, value2);
384+
385+ /* Generate the value of the surrogate pair. */
386+
387+ value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF);
388+ }
389+
390+ else {
391+ width = 2;
392+ }
393+
394+ break;
395+
396+ default:
397+ assert(1); /* Impossible. */
398+ }
399+
400+ /* Check if the raw buffer contains enough bytes to form a character. */
401+
402+ if (incomplete) break;
403+
404+ /*
405+ * Check if the character is in the allowed range:
406+ * #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
407+ * | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
408+ * | [#x10000-#x10FFFF] (32 bit)
409+ */
410+
411+ if (! (value == 0x09 || value == 0x0A || value == 0x0D
412+ || (value >= 0x20 && value <= 0x7E)
413+ || (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF)
414+ || (value >= 0xE000 && value <= 0xFFFD)
415+ || (value >= 0x10000 && value <= 0x10FFFF)))
416+ return yaml_parser_set_reader_error(parser,
417+ "control characters are not allowed",
418+ parser->offset, value);
419+
420+ /* Move the raw pointers. */
421+
422+ parser->raw_buffer.pointer += width;
423+ parser->offset += width;
424+
425+ /* Finally put the character into the buffer. */
426+
427+ /* 0000 0000-0000 007F -> 0xxxxxxx */
428+ if (value <= 0x7F) {
429+ *(parser->buffer.last++) = value;
430+ }
431+ /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */
432+ else if (value <= 0x7FF) {
433+ *(parser->buffer.last++) = 0xC0 + (value >> 6);
434+ *(parser->buffer.last++) = 0x80 + (value & 0x3F);
435+ }
436+ /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */
437+ else if (value <= 0xFFFF) {
438+ *(parser->buffer.last++) = 0xE0 + (value >> 12);
439+ *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F);
440+ *(parser->buffer.last++) = 0x80 + (value & 0x3F);
441+ }
442+ /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
443+ else {
444+ *(parser->buffer.last++) = 0xF0 + (value >> 18);
445+ *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F);
446+ *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F);
447+ *(parser->buffer.last++) = 0x80 + (value & 0x3F);
448+ }
449+
450+ parser->unread ++;
451+ }
452+
453+ /* On EOF, put NUL into the buffer and return. */
454+
455+ if (parser->eof) {
456+ *(parser->buffer.last++) = '\0';
457+ parser->unread ++;
458+ return 1;
459+ }
460+
461+ }
462+
463+ return 1;
464+}
465+
libyaml/scanner.cnew file+3570
@@ -0,0 +1,3570 @@
1+
2+/*
3+ * Introduction
4+ * ************
5+ *
6+ * The following notes assume that you are familiar with the YAML specification
7+ * (http://yaml.org/spec/cvs/current.html). We mostly follow it, although in
8+ * some cases we are less restrictive that it requires.
9+ *
10+ * The process of transforming a YAML stream into a sequence of events is
11+ * divided on two steps: Scanning and Parsing.
12+ *
13+ * The Scanner transforms the input stream into a sequence of tokens, while the
14+ * parser transform the sequence of tokens produced by the Scanner into a
15+ * sequence of parsing events.
16+ *
17+ * The Scanner is rather clever and complicated. The Parser, on the contrary,
18+ * is a straightforward implementation of a recursive-descendant parser (or,
19+ * LL(1) parser, as it is usually called).
20+ *
21+ * Actually there are two issues of Scanning that might be called "clever", the
22+ * rest is quite straightforward. The issues are "block collection start" and
23+ * "simple keys". Both issues are explained below in details.
24+ *
25+ * Here the Scanning step is explained and implemented. We start with the list
26+ * of all the tokens produced by the Scanner together with short descriptions.
27+ *
28+ * Now, tokens:
29+ *
30+ * STREAM-START(encoding) # The stream start.
31+ * STREAM-END # The stream end.
32+ * VERSION-DIRECTIVE(major,minor) # The '%YAML' directive.
33+ * TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive.
34+ * DOCUMENT-START # '---'
35+ * DOCUMENT-END # '...'
36+ * BLOCK-SEQUENCE-START # Indentation increase denoting a block
37+ * BLOCK-MAPPING-START # sequence or a block mapping.
38+ * BLOCK-END # Indentation decrease.
39+ * FLOW-SEQUENCE-START # '['
40+ * FLOW-SEQUENCE-END # ']'
41+ * BLOCK-SEQUENCE-START # '{'
42+ * BLOCK-SEQUENCE-END # '}'
43+ * BLOCK-ENTRY # '-'
44+ * FLOW-ENTRY # ','
45+ * KEY # '?' or nothing (simple keys).
46+ * VALUE # ':'
47+ * ALIAS(anchor) # '*anchor'
48+ * ANCHOR(anchor) # '&anchor'
49+ * TAG(handle,suffix) # '!handle!suffix'
50+ * SCALAR(value,style) # A scalar.
51+ *
52+ * The following two tokens are "virtual" tokens denoting the beginning and the
53+ * end of the stream:
54+ *
55+ * STREAM-START(encoding)
56+ * STREAM-END
57+ *
58+ * We pass the information about the input stream encoding with the
59+ * STREAM-START token.
60+ *
61+ * The next two tokens are responsible for tags:
62+ *
63+ * VERSION-DIRECTIVE(major,minor)
64+ * TAG-DIRECTIVE(handle,prefix)
65+ *
66+ * Example:
67+ *
68+ * %YAML 1.1
69+ * %TAG ! !foo
70+ * %TAG !yaml! tag:yaml.org,2002:
71+ * ---
72+ *
73+ * The correspoding sequence of tokens:
74+ *
75+ * STREAM-START(utf-8)
76+ * VERSION-DIRECTIVE(1,1)
77+ * TAG-DIRECTIVE("!","!foo")
78+ * TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:")
79+ * DOCUMENT-START
80+ * STREAM-END
81+ *
82+ * Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole
83+ * line.
84+ *
85+ * The document start and end indicators are represented by:
86+ *
87+ * DOCUMENT-START
88+ * DOCUMENT-END
89+ *
90+ * Note that if a YAML stream contains an implicit document (without '---'
91+ * and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be
92+ * produced.
93+ *
94+ * In the following examples, we present whole documents together with the
95+ * produced tokens.
96+ *
97+ * 1. An implicit document:
98+ *
99+ * 'a scalar'
100+ *
101+ * Tokens:
102+ *
103+ * STREAM-START(utf-8)
104+ * SCALAR("a scalar",single-quoted)
105+ * STREAM-END
106+ *
107+ * 2. An explicit document:
108+ *
109+ * ---
110+ * 'a scalar'
111+ * ...
112+ *
113+ * Tokens:
114+ *
115+ * STREAM-START(utf-8)
116+ * DOCUMENT-START
117+ * SCALAR("a scalar",single-quoted)
118+ * DOCUMENT-END
119+ * STREAM-END
120+ *
121+ * 3. Several documents in a stream:
122+ *
123+ * 'a scalar'
124+ * ---
125+ * 'another scalar'
126+ * ---
127+ * 'yet another scalar'
128+ *
129+ * Tokens:
130+ *
131+ * STREAM-START(utf-8)
132+ * SCALAR("a scalar",single-quoted)
133+ * DOCUMENT-START
134+ * SCALAR("another scalar",single-quoted)
135+ * DOCUMENT-START
136+ * SCALAR("yet another scalar",single-quoted)
137+ * STREAM-END
138+ *
139+ * We have already introduced the SCALAR token above. The following tokens are
140+ * used to describe aliases, anchors, tag, and scalars:
141+ *
142+ * ALIAS(anchor)
143+ * ANCHOR(anchor)
144+ * TAG(handle,suffix)
145+ * SCALAR(value,style)
146+ *
147+ * The following series of examples illustrate the usage of these tokens:
148+ *
149+ * 1. A recursive sequence:
150+ *
151+ * &A [ *A ]
152+ *
153+ * Tokens:
154+ *
155+ * STREAM-START(utf-8)
156+ * ANCHOR("A")
157+ * FLOW-SEQUENCE-START
158+ * ALIAS("A")
159+ * FLOW-SEQUENCE-END
160+ * STREAM-END
161+ *
162+ * 2. A tagged scalar:
163+ *
164+ * !!float "3.14" # A good approximation.
165+ *
166+ * Tokens:
167+ *
168+ * STREAM-START(utf-8)
169+ * TAG("!!","float")
170+ * SCALAR("3.14",double-quoted)
171+ * STREAM-END
172+ *
173+ * 3. Various scalar styles:
174+ *
175+ * --- # Implicit empty plain scalars do not produce tokens.
176+ * --- a plain scalar
177+ * --- 'a single-quoted scalar'
178+ * --- "a double-quoted scalar"
179+ * --- |-
180+ * a literal scalar
181+ * --- >-
182+ * a folded
183+ * scalar
184+ *
185+ * Tokens:
186+ *
187+ * STREAM-START(utf-8)
188+ * DOCUMENT-START
189+ * DOCUMENT-START
190+ * SCALAR("a plain scalar",plain)
191+ * DOCUMENT-START
192+ * SCALAR("a single-quoted scalar",single-quoted)
193+ * DOCUMENT-START
194+ * SCALAR("a double-quoted scalar",double-quoted)
195+ * DOCUMENT-START
196+ * SCALAR("a literal scalar",literal)
197+ * DOCUMENT-START
198+ * SCALAR("a folded scalar",folded)
199+ * STREAM-END
200+ *
201+ * Now it's time to review collection-related tokens. We will start with
202+ * flow collections:
203+ *
204+ * FLOW-SEQUENCE-START
205+ * FLOW-SEQUENCE-END
206+ * FLOW-MAPPING-START
207+ * FLOW-MAPPING-END
208+ * FLOW-ENTRY
209+ * KEY
210+ * VALUE
211+ *
212+ * The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and
213+ * FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}'
214+ * correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the
215+ * indicators '?' and ':', which are used for denoting mapping keys and values,
216+ * are represented by the KEY and VALUE tokens.
217+ *
218+ * The following examples show flow collections:
219+ *
220+ * 1. A flow sequence:
221+ *
222+ * [item 1, item 2, item 3]
223+ *
224+ * Tokens:
225+ *
226+ * STREAM-START(utf-8)
227+ * FLOW-SEQUENCE-START
228+ * SCALAR("item 1",plain)
229+ * FLOW-ENTRY
230+ * SCALAR("item 2",plain)
231+ * FLOW-ENTRY
232+ * SCALAR("item 3",plain)
233+ * FLOW-SEQUENCE-END
234+ * STREAM-END
235+ *
236+ * 2. A flow mapping:
237+ *
238+ * {
239+ * a simple key: a value, # Note that the KEY token is produced.
240+ * ? a complex key: another value,
241+ * }
242+ *
243+ * Tokens:
244+ *
245+ * STREAM-START(utf-8)
246+ * FLOW-MAPPING-START
247+ * KEY
248+ * SCALAR("a simple key",plain)
249+ * VALUE
250+ * SCALAR("a value",plain)
251+ * FLOW-ENTRY
252+ * KEY
253+ * SCALAR("a complex key",plain)
254+ * VALUE
255+ * SCALAR("another value",plain)
256+ * FLOW-ENTRY
257+ * FLOW-MAPPING-END
258+ * STREAM-END
259+ *
260+ * A simple key is a key which is not denoted by the '?' indicator. Note that
261+ * the Scanner still produce the KEY token whenever it encounters a simple key.
262+ *
263+ * For scanning block collections, the following tokens are used (note that we
264+ * repeat KEY and VALUE here):
265+ *
266+ * BLOCK-SEQUENCE-START
267+ * BLOCK-MAPPING-START
268+ * BLOCK-END
269+ * BLOCK-ENTRY
270+ * KEY
271+ * VALUE
272+ *
273+ * The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation
274+ * increase that precedes a block collection (cf. the INDENT token in Python).
275+ * The token BLOCK-END denote indentation decrease that ends a block collection
276+ * (cf. the DEDENT token in Python). However YAML has some syntax pecularities
277+ * that makes detections of these tokens more complex.
278+ *
279+ * The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators
280+ * '-', '?', and ':' correspondingly.
281+ *
282+ * The following examples show how the tokens BLOCK-SEQUENCE-START,
283+ * BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner:
284+ *
285+ * 1. Block sequences:
286+ *
287+ * - item 1
288+ * - item 2
289+ * -
290+ * - item 3.1
291+ * - item 3.2
292+ * -
293+ * key 1: value 1
294+ * key 2: value 2
295+ *
296+ * Tokens:
297+ *
298+ * STREAM-START(utf-8)
299+ * BLOCK-SEQUENCE-START
300+ * BLOCK-ENTRY
301+ * SCALAR("item 1",plain)
302+ * BLOCK-ENTRY
303+ * SCALAR("item 2",plain)
304+ * BLOCK-ENTRY
305+ * BLOCK-SEQUENCE-START
306+ * BLOCK-ENTRY
307+ * SCALAR("item 3.1",plain)
308+ * BLOCK-ENTRY
309+ * SCALAR("item 3.2",plain)
310+ * BLOCK-END
311+ * BLOCK-ENTRY
312+ * BLOCK-MAPPING-START
313+ * KEY
314+ * SCALAR("key 1",plain)
315+ * VALUE
316+ * SCALAR("value 1",plain)
317+ * KEY
318+ * SCALAR("key 2",plain)
319+ * VALUE
320+ * SCALAR("value 2",plain)
321+ * BLOCK-END
322+ * BLOCK-END
323+ * STREAM-END
324+ *
325+ * 2. Block mappings:
326+ *
327+ * a simple key: a value # The KEY token is produced here.
328+ * ? a complex key
329+ * : another value
330+ * a mapping:
331+ * key 1: value 1
332+ * key 2: value 2
333+ * a sequence:
334+ * - item 1
335+ * - item 2
336+ *
337+ * Tokens:
338+ *
339+ * STREAM-START(utf-8)
340+ * BLOCK-MAPPING-START
341+ * KEY
342+ * SCALAR("a simple key",plain)
343+ * VALUE
344+ * SCALAR("a value",plain)
345+ * KEY
346+ * SCALAR("a complex key",plain)
347+ * VALUE
348+ * SCALAR("another value",plain)
349+ * KEY
350+ * SCALAR("a mapping",plain)
351+ * BLOCK-MAPPING-START
352+ * KEY
353+ * SCALAR("key 1",plain)
354+ * VALUE
355+ * SCALAR("value 1",plain)
356+ * KEY
357+ * SCALAR("key 2",plain)
358+ * VALUE
359+ * SCALAR("value 2",plain)
360+ * BLOCK-END
361+ * KEY
362+ * SCALAR("a sequence",plain)
363+ * VALUE
364+ * BLOCK-SEQUENCE-START
365+ * BLOCK-ENTRY
366+ * SCALAR("item 1",plain)
367+ * BLOCK-ENTRY
368+ * SCALAR("item 2",plain)
369+ * BLOCK-END
370+ * BLOCK-END
371+ * STREAM-END
372+ *
373+ * YAML does not always require to start a new block collection from a new
374+ * line. If the current line contains only '-', '?', and ':' indicators, a new
375+ * block collection may start at the current line. The following examples
376+ * illustrate this case:
377+ *
378+ * 1. Collections in a sequence:
379+ *
380+ * - - item 1
381+ * - item 2
382+ * - key 1: value 1
383+ * key 2: value 2
384+ * - ? complex key
385+ * : complex value
386+ *
387+ * Tokens:
388+ *
389+ * STREAM-START(utf-8)
390+ * BLOCK-SEQUENCE-START
391+ * BLOCK-ENTRY
392+ * BLOCK-SEQUENCE-START
393+ * BLOCK-ENTRY
394+ * SCALAR("item 1",plain)
395+ * BLOCK-ENTRY
396+ * SCALAR("item 2",plain)
397+ * BLOCK-END
398+ * BLOCK-ENTRY
399+ * BLOCK-MAPPING-START
400+ * KEY
401+ * SCALAR("key 1",plain)
402+ * VALUE
403+ * SCALAR("value 1",plain)
404+ * KEY
405+ * SCALAR("key 2",plain)
406+ * VALUE
407+ * SCALAR("value 2",plain)
408+ * BLOCK-END
409+ * BLOCK-ENTRY
410+ * BLOCK-MAPPING-START
411+ * KEY
412+ * SCALAR("complex key")
413+ * VALUE
414+ * SCALAR("complex value")
415+ * BLOCK-END
416+ * BLOCK-END
417+ * STREAM-END
418+ *
419+ * 2. Collections in a mapping:
420+ *
421+ * ? a sequence
422+ * : - item 1
423+ * - item 2
424+ * ? a mapping
425+ * : key 1: value 1
426+ * key 2: value 2
427+ *
428+ * Tokens:
429+ *
430+ * STREAM-START(utf-8)
431+ * BLOCK-MAPPING-START
432+ * KEY
433+ * SCALAR("a sequence",plain)
434+ * VALUE
435+ * BLOCK-SEQUENCE-START
436+ * BLOCK-ENTRY
437+ * SCALAR("item 1",plain)
438+ * BLOCK-ENTRY
439+ * SCALAR("item 2",plain)
440+ * BLOCK-END
441+ * KEY
442+ * SCALAR("a mapping",plain)
443+ * VALUE
444+ * BLOCK-MAPPING-START
445+ * KEY
446+ * SCALAR("key 1",plain)
447+ * VALUE
448+ * SCALAR("value 1",plain)
449+ * KEY
450+ * SCALAR("key 2",plain)
451+ * VALUE
452+ * SCALAR("value 2",plain)
453+ * BLOCK-END
454+ * BLOCK-END
455+ * STREAM-END
456+ *
457+ * YAML also permits non-indented sequences if they are included into a block
458+ * mapping. In this case, the token BLOCK-SEQUENCE-START is not produced:
459+ *
460+ * key:
461+ * - item 1 # BLOCK-SEQUENCE-START is NOT produced here.
462+ * - item 2
463+ *
464+ * Tokens:
465+ *
466+ * STREAM-START(utf-8)
467+ * BLOCK-MAPPING-START
468+ * KEY
469+ * SCALAR("key",plain)
470+ * VALUE
471+ * BLOCK-ENTRY
472+ * SCALAR("item 1",plain)
473+ * BLOCK-ENTRY
474+ * SCALAR("item 2",plain)
475+ * BLOCK-END
476+ */
477+
478+#include "yaml_private.h"
479+
480+/*
481+ * Ensure that the buffer contains the required number of characters.
482+ * Return 1 on success, 0 on failure (reader error or memory error).
483+ */
484+
485+#define CACHE(parser,length) \
486+ (parser->unread >= (length) \
487+ ? 1 \
488+ : yaml_parser_update_buffer(parser, (length)))
489+
490+/*
491+ * Advance the buffer pointer.
492+ */
493+
494+#define SKIP(parser) \
495+ (parser->mark.index ++, \
496+ parser->mark.column ++, \
497+ parser->unread --, \
498+ parser->buffer.pointer += WIDTH(parser->buffer))
499+
500+#define SKIP_LINE(parser) \
501+ (IS_CRLF(parser->buffer) ? \
502+ (parser->mark.index += 2, \
503+ parser->mark.column = 0, \
504+ parser->mark.line ++, \
505+ parser->unread -= 2, \
506+ parser->buffer.pointer += 2) : \
507+ IS_BREAK(parser->buffer) ? \
508+ (parser->mark.index ++, \
509+ parser->mark.column = 0, \
510+ parser->mark.line ++, \
511+ parser->unread --, \
512+ parser->buffer.pointer += WIDTH(parser->buffer)) : 0)
513+
514+/*
515+ * Copy a character to a string buffer and advance pointers.
516+ */
517+
518+#define READ(parser,string) \
519+ (STRING_EXTEND(parser,string) ? \
520+ (COPY(string,parser->buffer), \
521+ parser->mark.index ++, \
522+ parser->mark.column ++, \
523+ parser->unread --, \
524+ 1) : 0)
525+
526+/*
527+ * Copy a line break character to a string buffer and advance pointers.
528+ */
529+
530+#define READ_LINE(parser,string) \
531+ (STRING_EXTEND(parser,string) ? \
532+ (((CHECK_AT(parser->buffer,'\r',0) \
533+ && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \
534+ (*((string).pointer++) = (yaml_char_t) '\n', \
535+ parser->buffer.pointer += 2, \
536+ parser->mark.index += 2, \
537+ parser->mark.column = 0, \
538+ parser->mark.line ++, \
539+ parser->unread -= 2) : \
540+ (CHECK_AT(parser->buffer,'\r',0) \
541+ || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \
542+ (*((string).pointer++) = (yaml_char_t) '\n', \
543+ parser->buffer.pointer ++, \
544+ parser->mark.index ++, \
545+ parser->mark.column = 0, \
546+ parser->mark.line ++, \
547+ parser->unread --) : \
548+ (CHECK_AT(parser->buffer,'\xC2',0) \
549+ && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \
550+ (*((string).pointer++) = (yaml_char_t) '\n', \
551+ parser->buffer.pointer += 2, \
552+ parser->mark.index ++, \
553+ parser->mark.column = 0, \
554+ parser->mark.line ++, \
555+ parser->unread --) : \
556+ (CHECK_AT(parser->buffer,'\xE2',0) && \
557+ CHECK_AT(parser->buffer,'\x80',1) && \
558+ (CHECK_AT(parser->buffer,'\xA8',2) || \
559+ CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \
560+ (*((string).pointer++) = *(parser->buffer.pointer++), \
561+ *((string).pointer++) = *(parser->buffer.pointer++), \
562+ *((string).pointer++) = *(parser->buffer.pointer++), \
563+ parser->mark.index ++, \
564+ parser->mark.column = 0, \
565+ parser->mark.line ++, \
566+ parser->unread --) : 0), \
567+ 1) : 0)
568+
569+/*
570+ * Public API declarations.
571+ */
572+
573+YAML_DECLARE(int)
574+yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);
575+
576+/*
577+ * Error handling.
578+ */
579+
580+static int
581+yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context,
582+ yaml_mark_t context_mark, const char *problem);
583+
584+/*
585+ * High-level token API.
586+ */
587+
588+YAML_DECLARE(int)
589+yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
590+
591+static int
592+yaml_parser_fetch_next_token(yaml_parser_t *parser);
593+
594+/*
595+ * Potential simple keys.
596+ */
597+
598+static int
599+yaml_parser_stale_simple_keys(yaml_parser_t *parser);
600+
601+static int
602+yaml_parser_save_simple_key(yaml_parser_t *parser);
603+
604+static int
605+yaml_parser_remove_simple_key(yaml_parser_t *parser);
606+
607+static int
608+yaml_parser_increase_flow_level(yaml_parser_t *parser);
609+
610+static int
611+yaml_parser_decrease_flow_level(yaml_parser_t *parser);
612+
613+/*
614+ * Indentation treatment.
615+ */
616+
617+static int
618+yaml_parser_roll_indent(yaml_parser_t *parser, int column,
619+ int number, yaml_token_type_t type, yaml_mark_t mark);
620+
621+static int
622+yaml_parser_unroll_indent(yaml_parser_t *parser, int column);
623+
624+/*
625+ * Token fetchers.
626+ */
627+
628+static int
629+yaml_parser_fetch_stream_start(yaml_parser_t *parser);
630+
631+static int
632+yaml_parser_fetch_stream_end(yaml_parser_t *parser);
633+
634+static int
635+yaml_parser_fetch_directive(yaml_parser_t *parser);
636+
637+static int
638+yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
639+ yaml_token_type_t type);
640+
641+static int
642+yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
643+ yaml_token_type_t type);
644+
645+static int
646+yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
647+ yaml_token_type_t type);
648+
649+static int
650+yaml_parser_fetch_flow_entry(yaml_parser_t *parser);
651+
652+static int
653+yaml_parser_fetch_block_entry(yaml_parser_t *parser);
654+
655+static int
656+yaml_parser_fetch_key(yaml_parser_t *parser);
657+
658+static int
659+yaml_parser_fetch_value(yaml_parser_t *parser);
660+
661+static int
662+yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type);
663+
664+static int
665+yaml_parser_fetch_tag(yaml_parser_t *parser);
666+
667+static int
668+yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal);
669+
670+static int
671+yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single);
672+
673+static int
674+yaml_parser_fetch_plain_scalar(yaml_parser_t *parser);
675+
676+/*
677+ * Token scanners.
678+ */
679+
680+static int
681+yaml_parser_scan_to_next_token(yaml_parser_t *parser);
682+
683+static int
684+yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token);
685+
686+static int
687+yaml_parser_scan_directive_name(yaml_parser_t *parser,
688+ yaml_mark_t start_mark, yaml_char_t **name);
689+
690+static int
691+yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
692+ yaml_mark_t start_mark, int *major, int *minor);
693+
694+static int
695+yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
696+ yaml_mark_t start_mark, int *number);
697+
698+static int
699+yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
700+ yaml_mark_t mark, yaml_char_t **handle, yaml_char_t **prefix);
701+
702+static int
703+yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token,
704+ yaml_token_type_t type);
705+
706+static int
707+yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token);
708+
709+static int
710+yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
711+ yaml_mark_t start_mark, yaml_char_t **handle);
712+
713+static int
714+yaml_parser_scan_tag_uri(yaml_parser_t *parser, int directive,
715+ yaml_char_t *head, yaml_mark_t start_mark, yaml_char_t **uri);
716+
717+static int
718+yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
719+ yaml_mark_t start_mark, yaml_string_t *string);
720+
721+static int
722+yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token,
723+ int literal);
724+
725+static int
726+yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
727+ int *indent, yaml_string_t *breaks,
728+ yaml_mark_t start_mark, yaml_mark_t *end_mark);
729+
730+static int
731+yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,
732+ int single);
733+
734+static int
735+yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token);
736+
737+/*
738+ * Get the next token.
739+ */
740+
741+YAML_DECLARE(int)
742+yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token)
743+{
744+ assert(parser); /* Non-NULL parser object is expected. */
745+ assert(token); /* Non-NULL token object is expected. */
746+
747+ /* Erase the token object. */
748+
749+ memset(token, 0, sizeof(yaml_token_t));
750+
751+ /* No tokens after STREAM-END or error. */
752+
753+ if (parser->stream_end_produced || parser->error) {
754+ return 1;
755+ }
756+
757+ /* Ensure that the tokens queue contains enough tokens. */
758+
759+ if (!parser->token_available) {
760+ if (!yaml_parser_fetch_more_tokens(parser))
761+ return 0;
762+ }
763+
764+ /* Fetch the next token from the queue. */
765+
766+ *token = DEQUEUE(parser, parser->tokens);
767+ parser->token_available = 0;
768+ parser->tokens_parsed ++;
769+
770+ if (token->type == YAML_STREAM_END_TOKEN) {
771+ parser->stream_end_produced = 1;
772+ }
773+
774+ return 1;
775+}
776+
777+/*
778+ * Set the scanner error and return 0.
779+ */
780+
781+static int
782+yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context,
783+ yaml_mark_t context_mark, const char *problem)
784+{
785+ parser->error = YAML_SCANNER_ERROR;
786+ parser->context = context;
787+ parser->context_mark = context_mark;
788+ parser->problem = problem;
789+ parser->problem_mark = parser->mark;
790+
791+ return 0;
792+}
793+
794+/*
795+ * Ensure that the tokens queue contains at least one token which can be
796+ * returned to the Parser.
797+ */
798+
799+YAML_DECLARE(int)
800+yaml_parser_fetch_more_tokens(yaml_parser_t *parser)
801+{
802+ int need_more_tokens;
803+
804+ /* While we need more tokens to fetch, do it. */
805+
806+ while (1)
807+ {
808+ /*
809+ * Check if we really need to fetch more tokens.
810+ */
811+
812+ need_more_tokens = 0;
813+
814+ if (parser->tokens.head == parser->tokens.tail)
815+ {
816+ /* Queue is empty. */
817+
818+ need_more_tokens = 1;
819+ }
820+ else
821+ {
822+ yaml_simple_key_t *simple_key;
823+
824+ /* Check if any potential simple key may occupy the head position. */
825+
826+ if (!yaml_parser_stale_simple_keys(parser))
827+ return 0;
828+
829+ for (simple_key = parser->simple_keys.start;
830+ simple_key != parser->simple_keys.top; simple_key++) {
831+ if (simple_key->possible
832+ && simple_key->token_number == parser->tokens_parsed) {
833+ need_more_tokens = 1;
834+ break;
835+ }
836+ }
837+ }
838+
839+ /* We are finished. */
840+
841+ if (!need_more_tokens)
842+ break;
843+
844+ /* Fetch the next token. */
845+
846+ if (!yaml_parser_fetch_next_token(parser))
847+ return 0;
848+ }
849+
850+ parser->token_available = 1;
851+
852+ return 1;
853+}
854+
855+/*
856+ * The dispatcher for token fetchers.
857+ */
858+
859+static int
860+yaml_parser_fetch_next_token(yaml_parser_t *parser)
861+{
862+ /* Ensure that the buffer is initialized. */
863+
864+ if (!CACHE(parser, 1))
865+ return 0;
866+
867+ /* Check if we just started scanning. Fetch STREAM-START then. */
868+
869+ if (!parser->stream_start_produced)
870+ return yaml_parser_fetch_stream_start(parser);
871+
872+ /* Eat whitespaces and comments until we reach the next token. */
873+
874+ if (!yaml_parser_scan_to_next_token(parser))
875+ return 0;
876+
877+ /* Remove obsolete potential simple keys. */
878+
879+ if (!yaml_parser_stale_simple_keys(parser))
880+ return 0;
881+
882+ /* Check the indentation level against the current column. */
883+
884+ if (!yaml_parser_unroll_indent(parser, parser->mark.column))
885+ return 0;
886+
887+ /*
888+ * Ensure that the buffer contains at least 4 characters. 4 is the length
889+ * of the longest indicators ('--- ' and '... ').
890+ */
891+
892+ if (!CACHE(parser, 4))
893+ return 0;
894+
895+ /* Is it the end of the stream? */
896+
897+ if (IS_Z(parser->buffer))
898+ return yaml_parser_fetch_stream_end(parser);
899+
900+ /* Is it a directive? */
901+
902+ if (parser->mark.column == 0 && CHECK(parser->buffer, '%'))
903+ return yaml_parser_fetch_directive(parser);
904+
905+ /* Is it the document start indicator? */
906+
907+ if (parser->mark.column == 0
908+ && CHECK_AT(parser->buffer, '-', 0)
909+ && CHECK_AT(parser->buffer, '-', 1)
910+ && CHECK_AT(parser->buffer, '-', 2)
911+ && IS_BLANKZ_AT(parser->buffer, 3))
912+ return yaml_parser_fetch_document_indicator(parser,
913+ YAML_DOCUMENT_START_TOKEN);
914+
915+ /* Is it the document end indicator? */
916+
917+ if (parser->mark.column == 0
918+ && CHECK_AT(parser->buffer, '.', 0)
919+ && CHECK_AT(parser->buffer, '.', 1)
920+ && CHECK_AT(parser->buffer, '.', 2)
921+ && IS_BLANKZ_AT(parser->buffer, 3))
922+ return yaml_parser_fetch_document_indicator(parser,
923+ YAML_DOCUMENT_END_TOKEN);
924+
925+ /* Is it the flow sequence start indicator? */
926+
927+ if (CHECK(parser->buffer, '['))
928+ return yaml_parser_fetch_flow_collection_start(parser,
929+ YAML_FLOW_SEQUENCE_START_TOKEN);
930+
931+ /* Is it the flow mapping start indicator? */
932+
933+ if (CHECK(parser->buffer, '{'))
934+ return yaml_parser_fetch_flow_collection_start(parser,
935+ YAML_FLOW_MAPPING_START_TOKEN);
936+
937+ /* Is it the flow sequence end indicator? */
938+
939+ if (CHECK(parser->buffer, ']'))
940+ return yaml_parser_fetch_flow_collection_end(parser,
941+ YAML_FLOW_SEQUENCE_END_TOKEN);
942+
943+ /* Is it the flow mapping end indicator? */
944+
945+ if (CHECK(parser->buffer, '}'))
946+ return yaml_parser_fetch_flow_collection_end(parser,
947+ YAML_FLOW_MAPPING_END_TOKEN);
948+
949+ /* Is it the flow entry indicator? */
950+
951+ if (CHECK(parser->buffer, ','))
952+ return yaml_parser_fetch_flow_entry(parser);
953+
954+ /* Is it the block entry indicator? */
955+
956+ if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))
957+ return yaml_parser_fetch_block_entry(parser);
958+
959+ /* Is it the key indicator? */
960+
961+ if (CHECK(parser->buffer, '?')
962+ && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))
963+ return yaml_parser_fetch_key(parser);
964+
965+ /* Is it the value indicator? */
966+
967+ if (CHECK(parser->buffer, ':')
968+ && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))
969+ return yaml_parser_fetch_value(parser);
970+
971+ /* Is it an alias? */
972+
973+ if (CHECK(parser->buffer, '*'))
974+ return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN);
975+
976+ /* Is it an anchor? */
977+
978+ if (CHECK(parser->buffer, '&'))
979+ return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN);
980+
981+ /* Is it a tag? */
982+
983+ if (CHECK(parser->buffer, '!'))
984+ return yaml_parser_fetch_tag(parser);
985+
986+ /* Is it a literal scalar? */
987+
988+ if (CHECK(parser->buffer, '|') && !parser->flow_level)
989+ return yaml_parser_fetch_block_scalar(parser, 1);
990+
991+ /* Is it a folded scalar? */
992+
993+ if (CHECK(parser->buffer, '>') && !parser->flow_level)
994+ return yaml_parser_fetch_block_scalar(parser, 0);
995+
996+ /* Is it a single-quoted scalar? */
997+
998+ if (CHECK(parser->buffer, '\''))
999+ return yaml_parser_fetch_flow_scalar(parser, 1);
1000+
1001+ /* Is it a double-quoted scalar? */
1002+
1003+ if (CHECK(parser->buffer, '"'))
1004+ return yaml_parser_fetch_flow_scalar(parser, 0);
1005+
1006+ /*
1007+ * Is it a plain scalar?
1008+ *
1009+ * A plain scalar may start with any non-blank characters except
1010+ *
1011+ * '-', '?', ':', ',', '[', ']', '{', '}',
1012+ * '#', '&', '*', '!', '|', '>', '\'', '\"',
1013+ * '%', '@', '`'.
1014+ *
1015+ * In the block context (and, for the '-' indicator, in the flow context
1016+ * too), it may also start with the characters
1017+ *
1018+ * '-', '?', ':'
1019+ *
1020+ * if it is followed by a non-space character.
1021+ *
1022+ * The last rule is more restrictive than the specification requires.
1023+ */
1024+
1025+ if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')
1026+ || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')
1027+ || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[')
1028+ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
1029+ || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#')
1030+ || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*')
1031+ || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|')
1032+ || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'')
1033+ || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%')
1034+ || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) ||
1035+ (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) ||
1036+ (!parser->flow_level &&
1037+ (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':'))
1038+ && !IS_BLANKZ_AT(parser->buffer, 1)))
1039+ return yaml_parser_fetch_plain_scalar(parser);
1040+
1041+ /*
1042+ * If we don't determine the token type so far, it is an error.
1043+ */
1044+
1045+ return yaml_parser_set_scanner_error(parser,
1046+ "while scanning for the next token", parser->mark,
1047+ "found character that cannot start any token");
1048+}
1049+
1050+/*
1051+ * Check the list of potential simple keys and remove the positions that
1052+ * cannot contain simple keys anymore.
1053+ */
1054+
1055+static int
1056+yaml_parser_stale_simple_keys(yaml_parser_t *parser)
1057+{
1058+ yaml_simple_key_t *simple_key;
1059+
1060+ /* Check for a potential simple key for each flow level. */
1061+
1062+ for (simple_key = parser->simple_keys.start;
1063+ simple_key != parser->simple_keys.top; simple_key ++)
1064+ {
1065+ /*
1066+ * The specification requires that a simple key
1067+ *
1068+ * - is limited to a single line,
1069+ * - is shorter than 1024 characters.
1070+ */
1071+
1072+ if (simple_key->possible
1073+ && (simple_key->mark.line < parser->mark.line
1074+ || simple_key->mark.index+1024 < parser->mark.index)) {
1075+
1076+ /* Check if the potential simple key to be removed is required. */
1077+
1078+ if (simple_key->required) {
1079+ return yaml_parser_set_scanner_error(parser,
1080+ "while scanning a simple key", simple_key->mark,
1081+ "could not find expected ':'");
1082+ }
1083+
1084+ simple_key->possible = 0;
1085+ }
1086+ }
1087+
1088+ return 1;
1089+}
1090+
1091+/*
1092+ * Check if a simple key may start at the current position and add it if
1093+ * needed.
1094+ */
1095+
1096+static int
1097+yaml_parser_save_simple_key(yaml_parser_t *parser)
1098+{
1099+ /*
1100+ * A simple key is required at the current position if the scanner is in
1101+ * the block context and the current column coincides with the indentation
1102+ * level.
1103+ */
1104+
1105+ int required = (!parser->flow_level
1106+ && parser->indent == (int)parser->mark.column);
1107+
1108+ /*
1109+ * A simple key is required only when it is the first token in the current
1110+ * line. Therefore it is always allowed. But we add a check anyway.
1111+ */
1112+
1113+ assert(parser->simple_key_allowed || !required); /* Impossible. */
1114+
1115+ /*
1116+ * If the current position may start a simple key, save it.
1117+ */
1118+
1119+ if (parser->simple_key_allowed)
1120+ {
1121+ yaml_simple_key_t simple_key;
1122+ simple_key.possible = 1;
1123+ simple_key.required = required;
1124+ simple_key.token_number =
1125+ parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head);
1126+ simple_key.mark = parser->mark;
1127+
1128+ if (!yaml_parser_remove_simple_key(parser)) return 0;
1129+
1130+ *(parser->simple_keys.top-1) = simple_key;
1131+ }
1132+
1133+ return 1;
1134+}
1135+
1136+/*
1137+ * Remove a potential simple key at the current flow level.
1138+ */
1139+
1140+static int
1141+yaml_parser_remove_simple_key(yaml_parser_t *parser)
1142+{
1143+ yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
1144+
1145+ if (simple_key->possible)
1146+ {
1147+ /* If the key is required, it is an error. */
1148+
1149+ if (simple_key->required) {
1150+ return yaml_parser_set_scanner_error(parser,
1151+ "while scanning a simple key", simple_key->mark,
1152+ "could not find expected ':'");
1153+ }
1154+ }
1155+
1156+ /* Remove the key from the stack. */
1157+
1158+ simple_key->possible = 0;
1159+
1160+ return 1;
1161+}
1162+
1163+/*
1164+ * Increase the flow level and resize the simple key list if needed.
1165+ */
1166+
1167+static int
1168+yaml_parser_increase_flow_level(yaml_parser_t *parser)
1169+{
1170+ yaml_simple_key_t empty_simple_key = { 0, 0, 0, { 0, 0, 0 } };
1171+
1172+ /* Reset the simple key on the next level. */
1173+
1174+ if (!PUSH(parser, parser->simple_keys, empty_simple_key))
1175+ return 0;
1176+
1177+ /* Increase the flow level. */
1178+
1179+ parser->flow_level++;
1180+
1181+ return 1;
1182+}
1183+
1184+/*
1185+ * Decrease the flow level.
1186+ */
1187+
1188+static int
1189+yaml_parser_decrease_flow_level(yaml_parser_t *parser)
1190+{
1191+ yaml_simple_key_t dummy_key; /* Used to eliminate a compiler warning. */
1192+
1193+ if (parser->flow_level) {
1194+ parser->flow_level --;
1195+ dummy_key = POP(parser, parser->simple_keys);
1196+ }
1197+
1198+ return 1;
1199+}
1200+
1201+/*
1202+ * Push the current indentation level to the stack and set the new level
1203+ * the current column is greater than the indentation level. In this case,
1204+ * append or insert the specified token into the token queue.
1205+ *
1206+ */
1207+
1208+static int
1209+yaml_parser_roll_indent(yaml_parser_t *parser, int column,
1210+ int number, yaml_token_type_t type, yaml_mark_t mark)
1211+{
1212+ yaml_token_t token;
1213+
1214+ /* In the flow context, do nothing. */
1215+
1216+ if (parser->flow_level)
1217+ return 1;
1218+
1219+ if (parser->indent < column)
1220+ {
1221+ /*
1222+ * Push the current indentation level to the stack and set the new
1223+ * indentation level.
1224+ */
1225+
1226+ if (!PUSH(parser, parser->indents, parser->indent))
1227+ return 0;
1228+
1229+ parser->indent = column;
1230+
1231+ /* Create a token and insert it into the queue. */
1232+
1233+ TOKEN_INIT(token, type, mark, mark);
1234+
1235+ if (number == -1) {
1236+ if (!ENQUEUE(parser, parser->tokens, token))
1237+ return 0;
1238+ }
1239+ else {
1240+ if (!QUEUE_INSERT(parser,
1241+ parser->tokens, number - parser->tokens_parsed, token))
1242+ return 0;
1243+ }
1244+ }
1245+
1246+ return 1;
1247+}
1248+
1249+/*
1250+ * Pop indentation levels from the indents stack until the current level
1251+ * becomes less or equal to the column. For each intendation level, append
1252+ * the BLOCK-END token.
1253+ */
1254+
1255+
1256+static int
1257+yaml_parser_unroll_indent(yaml_parser_t *parser, int column)
1258+{
1259+ yaml_token_t token;
1260+
1261+ /* In the flow context, do nothing. */
1262+
1263+ if (parser->flow_level)
1264+ return 1;
1265+
1266+ /* Loop through the intendation levels in the stack. */
1267+
1268+ while (parser->indent > column)
1269+ {
1270+ /* Create a token and append it to the queue. */
1271+
1272+ TOKEN_INIT(token, YAML_BLOCK_END_TOKEN, parser->mark, parser->mark);
1273+
1274+ if (!ENQUEUE(parser, parser->tokens, token))
1275+ return 0;
1276+
1277+ /* Pop the indentation level. */
1278+
1279+ parser->indent = POP(parser, parser->indents);
1280+ }
1281+
1282+ return 1;
1283+}
1284+
1285+/*
1286+ * Initialize the scanner and produce the STREAM-START token.
1287+ */
1288+
1289+static int
1290+yaml_parser_fetch_stream_start(yaml_parser_t *parser)
1291+{
1292+ yaml_simple_key_t simple_key = { 0, 0, 0, { 0, 0, 0 } };
1293+ yaml_token_t token;
1294+
1295+ /* Set the initial indentation. */
1296+
1297+ parser->indent = -1;
1298+
1299+ /* Initialize the simple key stack. */
1300+
1301+ if (!PUSH(parser, parser->simple_keys, simple_key))
1302+ return 0;
1303+
1304+ /* A simple key is allowed at the beginning of the stream. */
1305+
1306+ parser->simple_key_allowed = 1;
1307+
1308+ /* We have started. */
1309+
1310+ parser->stream_start_produced = 1;
1311+
1312+ /* Create the STREAM-START token and append it to the queue. */
1313+
1314+ STREAM_START_TOKEN_INIT(token, parser->encoding,
1315+ parser->mark, parser->mark);
1316+
1317+ if (!ENQUEUE(parser, parser->tokens, token))
1318+ return 0;
1319+
1320+ return 1;
1321+}
1322+
1323+/*
1324+ * Produce the STREAM-END token and shut down the scanner.
1325+ */
1326+
1327+static int
1328+yaml_parser_fetch_stream_end(yaml_parser_t *parser)
1329+{
1330+ yaml_token_t token;
1331+
1332+ /* Force new line. */
1333+
1334+ if (parser->mark.column != 0) {
1335+ parser->mark.column = 0;
1336+ parser->mark.line ++;
1337+ }
1338+
1339+ /* Reset the indentation level. */
1340+
1341+ if (!yaml_parser_unroll_indent(parser, -1))
1342+ return 0;
1343+
1344+ /* Reset simple keys. */
1345+
1346+ if (!yaml_parser_remove_simple_key(parser))
1347+ return 0;
1348+
1349+ parser->simple_key_allowed = 0;
1350+
1351+ /* Create the STREAM-END token and append it to the queue. */
1352+
1353+ STREAM_END_TOKEN_INIT(token, parser->mark, parser->mark);
1354+
1355+ if (!ENQUEUE(parser, parser->tokens, token))
1356+ return 0;
1357+
1358+ return 1;
1359+}
1360+
1361+/*
1362+ * Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
1363+ */
1364+
1365+static int
1366+yaml_parser_fetch_directive(yaml_parser_t *parser)
1367+{
1368+ yaml_token_t token;
1369+
1370+ /* Reset the indentation level. */
1371+
1372+ if (!yaml_parser_unroll_indent(parser, -1))
1373+ return 0;
1374+
1375+ /* Reset simple keys. */
1376+
1377+ if (!yaml_parser_remove_simple_key(parser))
1378+ return 0;
1379+
1380+ parser->simple_key_allowed = 0;
1381+
1382+ /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */
1383+
1384+ if (!yaml_parser_scan_directive(parser, &token))
1385+ return 0;
1386+
1387+ /* Append the token to the queue. */
1388+
1389+ if (!ENQUEUE(parser, parser->tokens, token)) {
1390+ yaml_token_delete(&token);
1391+ return 0;
1392+ }
1393+
1394+ return 1;
1395+}
1396+
1397+/*
1398+ * Produce the DOCUMENT-START or DOCUMENT-END token.
1399+ */
1400+
1401+static int
1402+yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
1403+ yaml_token_type_t type)
1404+{
1405+ yaml_mark_t start_mark, end_mark;
1406+ yaml_token_t token;
1407+
1408+ /* Reset the indentation level. */
1409+
1410+ if (!yaml_parser_unroll_indent(parser, -1))
1411+ return 0;
1412+
1413+ /* Reset simple keys. */
1414+
1415+ if (!yaml_parser_remove_simple_key(parser))
1416+ return 0;
1417+
1418+ parser->simple_key_allowed = 0;
1419+
1420+ /* Consume the token. */
1421+
1422+ start_mark = parser->mark;
1423+
1424+ SKIP(parser);
1425+ SKIP(parser);
1426+ SKIP(parser);
1427+
1428+ end_mark = parser->mark;
1429+
1430+ /* Create the DOCUMENT-START or DOCUMENT-END token. */
1431+
1432+ TOKEN_INIT(token, type, start_mark, end_mark);
1433+
1434+ /* Append the token to the queue. */
1435+
1436+ if (!ENQUEUE(parser, parser->tokens, token))
1437+ return 0;
1438+
1439+ return 1;
1440+}
1441+
1442+/*
1443+ * Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
1444+ */
1445+
1446+static int
1447+yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
1448+ yaml_token_type_t type)
1449+{
1450+ yaml_mark_t start_mark, end_mark;
1451+ yaml_token_t token;
1452+
1453+ /* The indicators '[' and '{' may start a simple key. */
1454+
1455+ if (!yaml_parser_save_simple_key(parser))
1456+ return 0;
1457+
1458+ /* Increase the flow level. */
1459+
1460+ if (!yaml_parser_increase_flow_level(parser))
1461+ return 0;
1462+
1463+ /* A simple key may follow the indicators '[' and '{'. */
1464+
1465+ parser->simple_key_allowed = 1;
1466+
1467+ /* Consume the token. */
1468+
1469+ start_mark = parser->mark;
1470+ SKIP(parser);
1471+ end_mark = parser->mark;
1472+
1473+ /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */
1474+
1475+ TOKEN_INIT(token, type, start_mark, end_mark);
1476+
1477+ /* Append the token to the queue. */
1478+
1479+ if (!ENQUEUE(parser, parser->tokens, token))
1480+ return 0;
1481+
1482+ return 1;
1483+}
1484+
1485+/*
1486+ * Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token.
1487+ */
1488+
1489+static int
1490+yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
1491+ yaml_token_type_t type)
1492+{
1493+ yaml_mark_t start_mark, end_mark;
1494+ yaml_token_t token;
1495+
1496+ /* Reset any potential simple key on the current flow level. */
1497+
1498+ if (!yaml_parser_remove_simple_key(parser))
1499+ return 0;
1500+
1501+ /* Decrease the flow level. */
1502+
1503+ if (!yaml_parser_decrease_flow_level(parser))
1504+ return 0;
1505+
1506+ /* No simple keys after the indicators ']' and '}'. */
1507+
1508+ parser->simple_key_allowed = 0;
1509+
1510+ /* Consume the token. */
1511+
1512+ start_mark = parser->mark;
1513+ SKIP(parser);
1514+ end_mark = parser->mark;
1515+
1516+ /* Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. */
1517+
1518+ TOKEN_INIT(token, type, start_mark, end_mark);
1519+
1520+ /* Append the token to the queue. */
1521+
1522+ if (!ENQUEUE(parser, parser->tokens, token))
1523+ return 0;
1524+
1525+ return 1;
1526+}
1527+
1528+/*
1529+ * Produce the FLOW-ENTRY token.
1530+ */
1531+
1532+static int
1533+yaml_parser_fetch_flow_entry(yaml_parser_t *parser)
1534+{
1535+ yaml_mark_t start_mark, end_mark;
1536+ yaml_token_t token;
1537+
1538+ /* Reset any potential simple keys on the current flow level. */
1539+
1540+ if (!yaml_parser_remove_simple_key(parser))
1541+ return 0;
1542+
1543+ /* Simple keys are allowed after ','. */
1544+
1545+ parser->simple_key_allowed = 1;
1546+
1547+ /* Consume the token. */
1548+
1549+ start_mark = parser->mark;
1550+ SKIP(parser);
1551+ end_mark = parser->mark;
1552+
1553+ /* Create the FLOW-ENTRY token and append it to the queue. */
1554+
1555+ TOKEN_INIT(token, YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark);
1556+
1557+ if (!ENQUEUE(parser, parser->tokens, token))
1558+ return 0;
1559+
1560+ return 1;
1561+}
1562+
1563+/*
1564+ * Produce the BLOCK-ENTRY token.
1565+ */
1566+
1567+static int
1568+yaml_parser_fetch_block_entry(yaml_parser_t *parser)
1569+{
1570+ yaml_mark_t start_mark, end_mark;
1571+ yaml_token_t token;
1572+
1573+ /* Check if the scanner is in the block context. */
1574+
1575+ if (!parser->flow_level)
1576+ {
1577+ /* Check if we are allowed to start a new entry. */
1578+
1579+ if (!parser->simple_key_allowed) {
1580+ return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
1581+ "block sequence entries are not allowed in this context");
1582+ }
1583+
1584+ /* Add the BLOCK-SEQUENCE-START token if needed. */
1585+
1586+ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
1587+ YAML_BLOCK_SEQUENCE_START_TOKEN, parser->mark))
1588+ return 0;
1589+ }
1590+ else
1591+ {
1592+ /*
1593+ * It is an error for the '-' indicator to occur in the flow context,
1594+ * but we let the Parser detect and report about it because the Parser
1595+ * is able to point to the context.
1596+ */
1597+ }
1598+
1599+ /* Reset any potential simple keys on the current flow level. */
1600+
1601+ if (!yaml_parser_remove_simple_key(parser))
1602+ return 0;
1603+
1604+ /* Simple keys are allowed after '-'. */
1605+
1606+ parser->simple_key_allowed = 1;
1607+
1608+ /* Consume the token. */
1609+
1610+ start_mark = parser->mark;
1611+ SKIP(parser);
1612+ end_mark = parser->mark;
1613+
1614+ /* Create the BLOCK-ENTRY token and append it to the queue. */
1615+
1616+ TOKEN_INIT(token, YAML_BLOCK_ENTRY_TOKEN, start_mark, end_mark);
1617+
1618+ if (!ENQUEUE(parser, parser->tokens, token))
1619+ return 0;
1620+
1621+ return 1;
1622+}
1623+
1624+/*
1625+ * Produce the KEY token.
1626+ */
1627+
1628+static int
1629+yaml_parser_fetch_key(yaml_parser_t *parser)
1630+{
1631+ yaml_mark_t start_mark, end_mark;
1632+ yaml_token_t token;
1633+
1634+ /* In the block context, additional checks are required. */
1635+
1636+ if (!parser->flow_level)
1637+ {
1638+ /* Check if we are allowed to start a new key (not nessesary simple). */
1639+
1640+ if (!parser->simple_key_allowed) {
1641+ return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
1642+ "mapping keys are not allowed in this context");
1643+ }
1644+
1645+ /* Add the BLOCK-MAPPING-START token if needed. */
1646+
1647+ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
1648+ YAML_BLOCK_MAPPING_START_TOKEN, parser->mark))
1649+ return 0;
1650+ }
1651+
1652+ /* Reset any potential simple keys on the current flow level. */
1653+
1654+ if (!yaml_parser_remove_simple_key(parser))
1655+ return 0;
1656+
1657+ /* Simple keys are allowed after '?' in the block context. */
1658+
1659+ parser->simple_key_allowed = (!parser->flow_level);
1660+
1661+ /* Consume the token. */
1662+
1663+ start_mark = parser->mark;
1664+ SKIP(parser);
1665+ end_mark = parser->mark;
1666+
1667+ /* Create the KEY token and append it to the queue. */
1668+
1669+ TOKEN_INIT(token, YAML_KEY_TOKEN, start_mark, end_mark);
1670+
1671+ if (!ENQUEUE(parser, parser->tokens, token))
1672+ return 0;
1673+
1674+ return 1;
1675+}
1676+
1677+/*
1678+ * Produce the VALUE token.
1679+ */
1680+
1681+static int
1682+yaml_parser_fetch_value(yaml_parser_t *parser)
1683+{
1684+ yaml_mark_t start_mark, end_mark;
1685+ yaml_token_t token;
1686+ yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
1687+
1688+ /* Have we found a simple key? */
1689+
1690+ if (simple_key->possible)
1691+ {
1692+
1693+ /* Create the KEY token and insert it into the queue. */
1694+
1695+ TOKEN_INIT(token, YAML_KEY_TOKEN, simple_key->mark, simple_key->mark);
1696+
1697+ if (!QUEUE_INSERT(parser, parser->tokens,
1698+ simple_key->token_number - parser->tokens_parsed, token))
1699+ return 0;
1700+
1701+ /* In the block context, we may need to add the BLOCK-MAPPING-START token. */
1702+
1703+ if (!yaml_parser_roll_indent(parser, simple_key->mark.column,
1704+ simple_key->token_number,
1705+ YAML_BLOCK_MAPPING_START_TOKEN, simple_key->mark))
1706+ return 0;
1707+
1708+ /* Remove the simple key. */
1709+
1710+ simple_key->possible = 0;
1711+
1712+ /* A simple key cannot follow another simple key. */
1713+
1714+ parser->simple_key_allowed = 0;
1715+ }
1716+ else
1717+ {
1718+ /* The ':' indicator follows a complex key. */
1719+
1720+ /* In the block context, extra checks are required. */
1721+
1722+ if (!parser->flow_level)
1723+ {
1724+ /* Check if we are allowed to start a complex value. */
1725+
1726+ if (!parser->simple_key_allowed) {
1727+ return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
1728+ "mapping values are not allowed in this context");
1729+ }
1730+
1731+ /* Add the BLOCK-MAPPING-START token if needed. */
1732+
1733+ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
1734+ YAML_BLOCK_MAPPING_START_TOKEN, parser->mark))
1735+ return 0;
1736+ }
1737+
1738+ /* Simple keys after ':' are allowed in the block context. */
1739+
1740+ parser->simple_key_allowed = (!parser->flow_level);
1741+ }
1742+
1743+ /* Consume the token. */
1744+
1745+ start_mark = parser->mark;
1746+ SKIP(parser);
1747+ end_mark = parser->mark;
1748+
1749+ /* Create the VALUE token and append it to the queue. */
1750+
1751+ TOKEN_INIT(token, YAML_VALUE_TOKEN, start_mark, end_mark);
1752+
1753+ if (!ENQUEUE(parser, parser->tokens, token))
1754+ return 0;
1755+
1756+ return 1;
1757+}
1758+
1759+/*
1760+ * Produce the ALIAS or ANCHOR token.
1761+ */
1762+
1763+static int
1764+yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type)
1765+{
1766+ yaml_token_t token;
1767+
1768+ /* An anchor or an alias could be a simple key. */
1769+
1770+ if (!yaml_parser_save_simple_key(parser))
1771+ return 0;
1772+
1773+ /* A simple key cannot follow an anchor or an alias. */
1774+
1775+ parser->simple_key_allowed = 0;
1776+
1777+ /* Create the ALIAS or ANCHOR token and append it to the queue. */
1778+
1779+ if (!yaml_parser_scan_anchor(parser, &token, type))
1780+ return 0;
1781+
1782+ if (!ENQUEUE(parser, parser->tokens, token)) {
1783+ yaml_token_delete(&token);
1784+ return 0;
1785+ }
1786+ return 1;
1787+}
1788+
1789+/*
1790+ * Produce the TAG token.
1791+ */
1792+
1793+static int
1794+yaml_parser_fetch_tag(yaml_parser_t *parser)
1795+{
1796+ yaml_token_t token;
1797+
1798+ /* A tag could be a simple key. */
1799+
1800+ if (!yaml_parser_save_simple_key(parser))
1801+ return 0;
1802+
1803+ /* A simple key cannot follow a tag. */
1804+
1805+ parser->simple_key_allowed = 0;
1806+
1807+ /* Create the TAG token and append it to the queue. */
1808+
1809+ if (!yaml_parser_scan_tag(parser, &token))
1810+ return 0;
1811+
1812+ if (!ENQUEUE(parser, parser->tokens, token)) {
1813+ yaml_token_delete(&token);
1814+ return 0;
1815+ }
1816+
1817+ return 1;
1818+}
1819+
1820+/*
1821+ * Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens.
1822+ */
1823+
1824+static int
1825+yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal)
1826+{
1827+ yaml_token_t token;
1828+
1829+ /* Remove any potential simple keys. */
1830+
1831+ if (!yaml_parser_remove_simple_key(parser))
1832+ return 0;
1833+
1834+ /* A simple key may follow a block scalar. */
1835+
1836+ parser->simple_key_allowed = 1;
1837+
1838+ /* Create the SCALAR token and append it to the queue. */
1839+
1840+ if (!yaml_parser_scan_block_scalar(parser, &token, literal))
1841+ return 0;
1842+
1843+ if (!ENQUEUE(parser, parser->tokens, token)) {
1844+ yaml_token_delete(&token);
1845+ return 0;
1846+ }
1847+
1848+ return 1;
1849+}
1850+
1851+/*
1852+ * Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens.
1853+ */
1854+
1855+static int
1856+yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single)
1857+{
1858+ yaml_token_t token;
1859+
1860+ /* A plain scalar could be a simple key. */
1861+
1862+ if (!yaml_parser_save_simple_key(parser))
1863+ return 0;
1864+
1865+ /* A simple key cannot follow a flow scalar. */
1866+
1867+ parser->simple_key_allowed = 0;
1868+
1869+ /* Create the SCALAR token and append it to the queue. */
1870+
1871+ if (!yaml_parser_scan_flow_scalar(parser, &token, single))
1872+ return 0;
1873+
1874+ if (!ENQUEUE(parser, parser->tokens, token)) {
1875+ yaml_token_delete(&token);
1876+ return 0;
1877+ }
1878+
1879+ return 1;
1880+}
1881+
1882+/*
1883+ * Produce the SCALAR(...,plain) token.
1884+ */
1885+
1886+static int
1887+yaml_parser_fetch_plain_scalar(yaml_parser_t *parser)
1888+{
1889+ yaml_token_t token;
1890+
1891+ /* A plain scalar could be a simple key. */
1892+
1893+ if (!yaml_parser_save_simple_key(parser))
1894+ return 0;
1895+
1896+ /* A simple key cannot follow a flow scalar. */
1897+
1898+ parser->simple_key_allowed = 0;
1899+
1900+ /* Create the SCALAR token and append it to the queue. */
1901+
1902+ if (!yaml_parser_scan_plain_scalar(parser, &token))
1903+ return 0;
1904+
1905+ if (!ENQUEUE(parser, parser->tokens, token)) {
1906+ yaml_token_delete(&token);
1907+ return 0;
1908+ }
1909+
1910+ return 1;
1911+}
1912+
1913+/*
1914+ * Eat whitespaces and comments until the next token is found.
1915+ */
1916+
1917+static int
1918+yaml_parser_scan_to_next_token(yaml_parser_t *parser)
1919+{
1920+ /* Until the next token is not found. */
1921+
1922+ while (1)
1923+ {
1924+ /* Allow the BOM mark to start a line. */
1925+
1926+ if (!CACHE(parser, 1)) return 0;
1927+
1928+ if (parser->mark.column == 0 && IS_BOM(parser->buffer))
1929+ SKIP(parser);
1930+
1931+ /*
1932+ * Eat whitespaces.
1933+ *
1934+ * Tabs are allowed:
1935+ *
1936+ * - in the flow context;
1937+ * - in the block context, but not at the beginning of the line or
1938+ * after '-', '?', or ':' (complex value).
1939+ */
1940+
1941+ if (!CACHE(parser, 1)) return 0;
1942+
1943+ while (CHECK(parser->buffer,' ') ||
1944+ ((parser->flow_level || !parser->simple_key_allowed) &&
1945+ CHECK(parser->buffer, '\t'))) {
1946+ SKIP(parser);
1947+ if (!CACHE(parser, 1)) return 0;
1948+ }
1949+
1950+ /* Eat a comment until a line break. */
1951+
1952+ if (CHECK(parser->buffer, '#')) {
1953+ while (!IS_BREAKZ(parser->buffer)) {
1954+ SKIP(parser);
1955+ if (!CACHE(parser, 1)) return 0;
1956+ }
1957+ }
1958+
1959+ /* If it is a line break, eat it. */
1960+
1961+ if (IS_BREAK(parser->buffer))
1962+ {
1963+ if (!CACHE(parser, 2)) return 0;
1964+ SKIP_LINE(parser);
1965+
1966+ /* In the block context, a new line may start a simple key. */
1967+
1968+ if (!parser->flow_level) {
1969+ parser->simple_key_allowed = 1;
1970+ }
1971+ }
1972+ else
1973+ {
1974+ /* We have found a token. */
1975+
1976+ break;
1977+ }
1978+ }
1979+
1980+ return 1;
1981+}
1982+
1983+/*
1984+ * Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token.
1985+ *
1986+ * Scope:
1987+ * %YAML 1.1 # a comment \n
1988+ * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1989+ * %TAG !yaml! tag:yaml.org,2002: \n
1990+ * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1991+ */
1992+
1993+int
1994+yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token)
1995+{
1996+ yaml_mark_t start_mark, end_mark;
1997+ yaml_char_t *name = NULL;
1998+ int major, minor;
1999+ yaml_char_t *handle = NULL, *prefix = NULL;
2000+
2001+ /* Eat '%'. */
2002+
2003+ start_mark = parser->mark;
2004+
2005+ SKIP(parser);
2006+
2007+ /* Scan the directive name. */
2008+
2009+ if (!yaml_parser_scan_directive_name(parser, start_mark, &name))
2010+ goto error;
2011+
2012+ /* Is it a YAML directive? */
2013+
2014+ if (strcmp((char *)name, "YAML") == 0)
2015+ {
2016+ /* Scan the VERSION directive value. */
2017+
2018+ if (!yaml_parser_scan_version_directive_value(parser, start_mark,
2019+ &major, &minor))
2020+ goto error;
2021+
2022+ end_mark = parser->mark;
2023+
2024+ /* Create a VERSION-DIRECTIVE token. */
2025+
2026+ VERSION_DIRECTIVE_TOKEN_INIT(*token, major, minor,
2027+ start_mark, end_mark);
2028+ }
2029+
2030+ /* Is it a TAG directive? */
2031+
2032+ else if (strcmp((char *)name, "TAG") == 0)
2033+ {
2034+ /* Scan the TAG directive value. */
2035+
2036+ if (!yaml_parser_scan_tag_directive_value(parser, start_mark,
2037+ &handle, &prefix))
2038+ goto error;
2039+
2040+ end_mark = parser->mark;
2041+
2042+ /* Create a TAG-DIRECTIVE token. */
2043+
2044+ TAG_DIRECTIVE_TOKEN_INIT(*token, handle, prefix,
2045+ start_mark, end_mark);
2046+ }
2047+
2048+ /* Unknown directive. */
2049+
2050+ else
2051+ {
2052+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
2053+ start_mark, "found uknown directive name");
2054+ goto error;
2055+ }
2056+
2057+ /* Eat the rest of the line including any comments. */
2058+
2059+ if (!CACHE(parser, 1)) goto error;
2060+
2061+ while (IS_BLANK(parser->buffer)) {
2062+ SKIP(parser);
2063+ if (!CACHE(parser, 1)) goto error;
2064+ }
2065+
2066+ if (CHECK(parser->buffer, '#')) {
2067+ while (!IS_BREAKZ(parser->buffer)) {
2068+ SKIP(parser);
2069+ if (!CACHE(parser, 1)) goto error;
2070+ }
2071+ }
2072+
2073+ /* Check if we are at the end of the line. */
2074+
2075+ if (!IS_BREAKZ(parser->buffer)) {
2076+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
2077+ start_mark, "did not find expected comment or line break");
2078+ goto error;
2079+ }
2080+
2081+ /* Eat a line break. */
2082+
2083+ if (IS_BREAK(parser->buffer)) {
2084+ if (!CACHE(parser, 2)) goto error;
2085+ SKIP_LINE(parser);
2086+ }
2087+
2088+ yaml_free(name);
2089+
2090+ return 1;
2091+
2092+error:
2093+ yaml_free(prefix);
2094+ yaml_free(handle);
2095+ yaml_free(name);
2096+ return 0;
2097+}
2098+
2099+/*
2100+ * Scan the directive name.
2101+ *
2102+ * Scope:
2103+ * %YAML 1.1 # a comment \n
2104+ * ^^^^
2105+ * %TAG !yaml! tag:yaml.org,2002: \n
2106+ * ^^^
2107+ */
2108+
2109+static int
2110+yaml_parser_scan_directive_name(yaml_parser_t *parser,
2111+ yaml_mark_t start_mark, yaml_char_t **name)
2112+{
2113+ yaml_string_t string = NULL_STRING;
2114+
2115+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2116+
2117+ /* Consume the directive name. */
2118+
2119+ if (!CACHE(parser, 1)) goto error;
2120+
2121+ while (IS_ALPHA(parser->buffer))
2122+ {
2123+ if (!READ(parser, string)) goto error;
2124+ if (!CACHE(parser, 1)) goto error;
2125+ }
2126+
2127+ /* Check if the name is empty. */
2128+
2129+ if (string.start == string.pointer) {
2130+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
2131+ start_mark, "could not find expected directive name");
2132+ goto error;
2133+ }
2134+
2135+ /* Check for an blank character after the name. */
2136+
2137+ if (!IS_BLANKZ(parser->buffer)) {
2138+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
2139+ start_mark, "found unexpected non-alphabetical character");
2140+ goto error;
2141+ }
2142+
2143+ *name = string.start;
2144+
2145+ return 1;
2146+
2147+error:
2148+ STRING_DEL(parser, string);
2149+ return 0;
2150+}
2151+
2152+/*
2153+ * Scan the value of VERSION-DIRECTIVE.
2154+ *
2155+ * Scope:
2156+ * %YAML 1.1 # a comment \n
2157+ * ^^^^^^
2158+ */
2159+
2160+static int
2161+yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
2162+ yaml_mark_t start_mark, int *major, int *minor)
2163+{
2164+ /* Eat whitespaces. */
2165+
2166+ if (!CACHE(parser, 1)) return 0;
2167+
2168+ while (IS_BLANK(parser->buffer)) {
2169+ SKIP(parser);
2170+ if (!CACHE(parser, 1)) return 0;
2171+ }
2172+
2173+ /* Consume the major version number. */
2174+
2175+ if (!yaml_parser_scan_version_directive_number(parser, start_mark, major))
2176+ return 0;
2177+
2178+ /* Eat '.'. */
2179+
2180+ if (!CHECK(parser->buffer, '.')) {
2181+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
2182+ start_mark, "did not find expected digit or '.' character");
2183+ }
2184+
2185+ SKIP(parser);
2186+
2187+ /* Consume the minor version number. */
2188+
2189+ if (!yaml_parser_scan_version_directive_number(parser, start_mark, minor))
2190+ return 0;
2191+
2192+ return 1;
2193+}
2194+
2195+#define MAX_NUMBER_LENGTH 9
2196+
2197+/*
2198+ * Scan the version number of VERSION-DIRECTIVE.
2199+ *
2200+ * Scope:
2201+ * %YAML 1.1 # a comment \n
2202+ * ^
2203+ * %YAML 1.1 # a comment \n
2204+ * ^
2205+ */
2206+
2207+static int
2208+yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
2209+ yaml_mark_t start_mark, int *number)
2210+{
2211+ int value = 0;
2212+ size_t length = 0;
2213+
2214+ /* Repeat while the next character is digit. */
2215+
2216+ if (!CACHE(parser, 1)) return 0;
2217+
2218+ while (IS_DIGIT(parser->buffer))
2219+ {
2220+ /* Check if the number is too long. */
2221+
2222+ if (++length > MAX_NUMBER_LENGTH) {
2223+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
2224+ start_mark, "found extremely long version number");
2225+ }
2226+
2227+ value = value*10 + AS_DIGIT(parser->buffer);
2228+
2229+ SKIP(parser);
2230+
2231+ if (!CACHE(parser, 1)) return 0;
2232+ }
2233+
2234+ /* Check if the number was present. */
2235+
2236+ if (!length) {
2237+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
2238+ start_mark, "did not find expected version number");
2239+ }
2240+
2241+ *number = value;
2242+
2243+ return 1;
2244+}
2245+
2246+/*
2247+ * Scan the value of a TAG-DIRECTIVE token.
2248+ *
2249+ * Scope:
2250+ * %TAG !yaml! tag:yaml.org,2002: \n
2251+ * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2252+ */
2253+
2254+static int
2255+yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
2256+ yaml_mark_t start_mark, yaml_char_t **handle, yaml_char_t **prefix)
2257+{
2258+ yaml_char_t *handle_value = NULL;
2259+ yaml_char_t *prefix_value = NULL;
2260+
2261+ /* Eat whitespaces. */
2262+
2263+ if (!CACHE(parser, 1)) goto error;
2264+
2265+ while (IS_BLANK(parser->buffer)) {
2266+ SKIP(parser);
2267+ if (!CACHE(parser, 1)) goto error;
2268+ }
2269+
2270+ /* Scan a handle. */
2271+
2272+ if (!yaml_parser_scan_tag_handle(parser, 1, start_mark, &handle_value))
2273+ goto error;
2274+
2275+ /* Expect a whitespace. */
2276+
2277+ if (!CACHE(parser, 1)) goto error;
2278+
2279+ if (!IS_BLANK(parser->buffer)) {
2280+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
2281+ start_mark, "did not find expected whitespace");
2282+ goto error;
2283+ }
2284+
2285+ /* Eat whitespaces. */
2286+
2287+ while (IS_BLANK(parser->buffer)) {
2288+ SKIP(parser);
2289+ if (!CACHE(parser, 1)) goto error;
2290+ }
2291+
2292+ /* Scan a prefix. */
2293+
2294+ if (!yaml_parser_scan_tag_uri(parser, 1, NULL, start_mark, &prefix_value))
2295+ goto error;
2296+
2297+ /* Expect a whitespace or line break. */
2298+
2299+ if (!CACHE(parser, 1)) goto error;
2300+
2301+ if (!IS_BLANKZ(parser->buffer)) {
2302+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
2303+ start_mark, "did not find expected whitespace or line break");
2304+ goto error;
2305+ }
2306+
2307+ *handle = handle_value;
2308+ *prefix = prefix_value;
2309+
2310+ return 1;
2311+
2312+error:
2313+ yaml_free(handle_value);
2314+ yaml_free(prefix_value);
2315+ return 0;
2316+}
2317+
2318+static int
2319+yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token,
2320+ yaml_token_type_t type)
2321+{
2322+ int length = 0;
2323+ yaml_mark_t start_mark, end_mark;
2324+ yaml_string_t string = NULL_STRING;
2325+
2326+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2327+
2328+ /* Eat the indicator character. */
2329+
2330+ start_mark = parser->mark;
2331+
2332+ SKIP(parser);
2333+
2334+ /* Consume the value. */
2335+
2336+ if (!CACHE(parser, 1)) goto error;
2337+
2338+ while (IS_ALPHA(parser->buffer)) {
2339+ if (!READ(parser, string)) goto error;
2340+ if (!CACHE(parser, 1)) goto error;
2341+ length ++;
2342+ }
2343+
2344+ end_mark = parser->mark;
2345+
2346+ /*
2347+ * Check if length of the anchor is greater than 0 and it is followed by
2348+ * a whitespace character or one of the indicators:
2349+ *
2350+ * '?', ':', ',', ']', '}', '%', '@', '`'.
2351+ */
2352+
2353+ if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')
2354+ || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',')
2355+ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}')
2356+ || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@')
2357+ || CHECK(parser->buffer, '`'))) {
2358+ yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ?
2359+ "while scanning an anchor" : "while scanning an alias", start_mark,
2360+ "did not find expected alphabetic or numeric character");
2361+ goto error;
2362+ }
2363+
2364+ /* Create a token. */
2365+
2366+ if (type == YAML_ANCHOR_TOKEN) {
2367+ ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark);
2368+ }
2369+ else {
2370+ ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark);
2371+ }
2372+
2373+ return 1;
2374+
2375+error:
2376+ STRING_DEL(parser, string);
2377+ return 0;
2378+}
2379+
2380+/*
2381+ * Scan a TAG token.
2382+ */
2383+
2384+static int
2385+yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
2386+{
2387+ yaml_char_t *handle = NULL;
2388+ yaml_char_t *suffix = NULL;
2389+ yaml_mark_t start_mark, end_mark;
2390+
2391+ start_mark = parser->mark;
2392+
2393+ /* Check if the tag is in the canonical form. */
2394+
2395+ if (!CACHE(parser, 2)) goto error;
2396+
2397+ if (CHECK_AT(parser->buffer, '<', 1))
2398+ {
2399+ /* Set the handle to '' */
2400+
2401+ handle = yaml_malloc(1);
2402+ if (!handle) goto error;
2403+ handle[0] = '\0';
2404+
2405+ /* Eat '!<' */
2406+
2407+ SKIP(parser);
2408+ SKIP(parser);
2409+
2410+ /* Consume the tag value. */
2411+
2412+ if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix))
2413+ goto error;
2414+
2415+ /* Check for '>' and eat it. */
2416+
2417+ if (!CHECK(parser->buffer, '>')) {
2418+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
2419+ start_mark, "did not find the expected '>'");
2420+ goto error;
2421+ }
2422+
2423+ SKIP(parser);
2424+ }
2425+ else
2426+ {
2427+ /* The tag has either the '!suffix' or the '!handle!suffix' form. */
2428+
2429+ /* First, try to scan a handle. */
2430+
2431+ if (!yaml_parser_scan_tag_handle(parser, 0, start_mark, &handle))
2432+ goto error;
2433+
2434+ /* Check if it is, indeed, handle. */
2435+
2436+ if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!')
2437+ {
2438+ /* Scan the suffix now. */
2439+
2440+ if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix))
2441+ goto error;
2442+ }
2443+ else
2444+ {
2445+ /* It wasn't a handle after all. Scan the rest of the tag. */
2446+
2447+ if (!yaml_parser_scan_tag_uri(parser, 0, handle, start_mark, &suffix))
2448+ goto error;
2449+
2450+ /* Set the handle to '!'. */
2451+
2452+ yaml_free(handle);
2453+ handle = yaml_malloc(2);
2454+ if (!handle) goto error;
2455+ handle[0] = '!';
2456+ handle[1] = '\0';
2457+
2458+ /*
2459+ * A special case: the '!' tag. Set the handle to '' and the
2460+ * suffix to '!'.
2461+ */
2462+
2463+ if (suffix[0] == '\0') {
2464+ yaml_char_t *tmp = handle;
2465+ handle = suffix;
2466+ suffix = tmp;
2467+ }
2468+ }
2469+ }
2470+
2471+ /* Check the character which ends the tag. */
2472+
2473+ if (!CACHE(parser, 1)) goto error;
2474+
2475+ if (!IS_BLANKZ(parser->buffer)) {
2476+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
2477+ start_mark, "did not find expected whitespace or line break");
2478+ goto error;
2479+ }
2480+
2481+ end_mark = parser->mark;
2482+
2483+ /* Create a token. */
2484+
2485+ TAG_TOKEN_INIT(*token, handle, suffix, start_mark, end_mark);
2486+
2487+ return 1;
2488+
2489+error:
2490+ yaml_free(handle);
2491+ yaml_free(suffix);
2492+ return 0;
2493+}
2494+
2495+/*
2496+ * Scan a tag handle.
2497+ */
2498+
2499+static int
2500+yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
2501+ yaml_mark_t start_mark, yaml_char_t **handle)
2502+{
2503+ yaml_string_t string = NULL_STRING;
2504+
2505+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2506+
2507+ /* Check the initial '!' character. */
2508+
2509+ if (!CACHE(parser, 1)) goto error;
2510+
2511+ if (!CHECK(parser->buffer, '!')) {
2512+ yaml_parser_set_scanner_error(parser, directive ?
2513+ "while scanning a tag directive" : "while scanning a tag",
2514+ start_mark, "did not find expected '!'");
2515+ goto error;
2516+ }
2517+
2518+ /* Copy the '!' character. */
2519+
2520+ if (!READ(parser, string)) goto error;
2521+
2522+ /* Copy all subsequent alphabetical and numerical characters. */
2523+
2524+ if (!CACHE(parser, 1)) goto error;
2525+
2526+ while (IS_ALPHA(parser->buffer))
2527+ {
2528+ if (!READ(parser, string)) goto error;
2529+ if (!CACHE(parser, 1)) goto error;
2530+ }
2531+
2532+ /* Check if the trailing character is '!' and copy it. */
2533+
2534+ if (CHECK(parser->buffer, '!'))
2535+ {
2536+ if (!READ(parser, string)) goto error;
2537+ }
2538+ else
2539+ {
2540+ /*
2541+ * It's either the '!' tag or not really a tag handle. If it's a %TAG
2542+ * directive, it's an error. If it's a tag token, it must be a part of
2543+ * URI.
2544+ */
2545+
2546+ if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) {
2547+ yaml_parser_set_scanner_error(parser, "while parsing a tag directive",
2548+ start_mark, "did not find expected '!'");
2549+ goto error;
2550+ }
2551+ }
2552+
2553+ *handle = string.start;
2554+
2555+ return 1;
2556+
2557+error:
2558+ STRING_DEL(parser, string);
2559+ return 0;
2560+}
2561+
2562+/*
2563+ * Scan a tag.
2564+ */
2565+
2566+static int
2567+yaml_parser_scan_tag_uri(yaml_parser_t *parser, int directive,
2568+ yaml_char_t *head, yaml_mark_t start_mark, yaml_char_t **uri)
2569+{
2570+ size_t length = head ? strlen((char *)head) : 0;
2571+ yaml_string_t string = NULL_STRING;
2572+
2573+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2574+
2575+ /* Resize the string to include the head. */
2576+
2577+ while (string.end - string.start <= (int)length) {
2578+ if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) {
2579+ parser->error = YAML_MEMORY_ERROR;
2580+ goto error;
2581+ }
2582+ }
2583+
2584+ /*
2585+ * Copy the head if needed.
2586+ *
2587+ * Note that we don't copy the leading '!' character.
2588+ */
2589+
2590+ if (length > 1) {
2591+ memcpy(string.start, head+1, length-1);
2592+ string.pointer += length-1;
2593+ }
2594+
2595+ /* Scan the tag. */
2596+
2597+ if (!CACHE(parser, 1)) goto error;
2598+
2599+ /*
2600+ * The set of characters that may appear in URI is as follows:
2601+ *
2602+ * '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
2603+ * '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
2604+ * '%'.
2605+ */
2606+
2607+ while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')
2608+ || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?')
2609+ || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@')
2610+ || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=')
2611+ || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$')
2612+ || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '.')
2613+ || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~')
2614+ || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'')
2615+ || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')')
2616+ || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']')
2617+ || CHECK(parser->buffer, '%'))
2618+ {
2619+ /* Check if it is a URI-escape sequence. */
2620+
2621+ if (CHECK(parser->buffer, '%')) {
2622+ if (!yaml_parser_scan_uri_escapes(parser,
2623+ directive, start_mark, &string)) goto error;
2624+ }
2625+ else {
2626+ if (!READ(parser, string)) goto error;
2627+ }
2628+
2629+ length ++;
2630+ if (!CACHE(parser, 1)) goto error;
2631+ }
2632+
2633+ /* Check if the tag is non-empty. */
2634+
2635+ if (!length) {
2636+ if (!STRING_EXTEND(parser, string))
2637+ goto error;
2638+
2639+ yaml_parser_set_scanner_error(parser, directive ?
2640+ "while parsing a %TAG directive" : "while parsing a tag",
2641+ start_mark, "did not find expected tag URI");
2642+ goto error;
2643+ }
2644+
2645+ *uri = string.start;
2646+
2647+ return 1;
2648+
2649+error:
2650+ STRING_DEL(parser, string);
2651+ return 0;
2652+}
2653+
2654+/*
2655+ * Decode an URI-escape sequence corresponding to a single UTF-8 character.
2656+ */
2657+
2658+static int
2659+yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
2660+ yaml_mark_t start_mark, yaml_string_t *string)
2661+{
2662+ int width = 0;
2663+
2664+ /* Decode the required number of characters. */
2665+
2666+ do {
2667+
2668+ unsigned char octet = 0;
2669+
2670+ /* Check for a URI-escaped octet. */
2671+
2672+ if (!CACHE(parser, 3)) return 0;
2673+
2674+ if (!(CHECK(parser->buffer, '%')
2675+ && IS_HEX_AT(parser->buffer, 1)
2676+ && IS_HEX_AT(parser->buffer, 2))) {
2677+ return yaml_parser_set_scanner_error(parser, directive ?
2678+ "while parsing a %TAG directive" : "while parsing a tag",
2679+ start_mark, "did not find URI escaped octet");
2680+ }
2681+
2682+ /* Get the octet. */
2683+
2684+ octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);
2685+
2686+ /* If it is the leading octet, determine the length of the UTF-8 sequence. */
2687+
2688+ if (!width)
2689+ {
2690+ width = (octet & 0x80) == 0x00 ? 1 :
2691+ (octet & 0xE0) == 0xC0 ? 2 :
2692+ (octet & 0xF0) == 0xE0 ? 3 :
2693+ (octet & 0xF8) == 0xF0 ? 4 : 0;
2694+ if (!width) {
2695+ return yaml_parser_set_scanner_error(parser, directive ?
2696+ "while parsing a %TAG directive" : "while parsing a tag",
2697+ start_mark, "found an incorrect leading UTF-8 octet");
2698+ }
2699+ }
2700+ else
2701+ {
2702+ /* Check if the trailing octet is correct. */
2703+
2704+ if ((octet & 0xC0) != 0x80) {
2705+ return yaml_parser_set_scanner_error(parser, directive ?
2706+ "while parsing a %TAG directive" : "while parsing a tag",
2707+ start_mark, "found an incorrect trailing UTF-8 octet");
2708+ }
2709+ }
2710+
2711+ /* Copy the octet and move the pointers. */
2712+
2713+ *(string->pointer++) = octet;
2714+ SKIP(parser);
2715+ SKIP(parser);
2716+ SKIP(parser);
2717+
2718+ } while (--width);
2719+
2720+ return 1;
2721+}
2722+
2723+/*
2724+ * Scan a block scalar.
2725+ */
2726+
2727+static int
2728+yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token,
2729+ int literal)
2730+{
2731+ yaml_mark_t start_mark;
2732+ yaml_mark_t end_mark;
2733+ yaml_string_t string = NULL_STRING;
2734+ yaml_string_t leading_break = NULL_STRING;
2735+ yaml_string_t trailing_breaks = NULL_STRING;
2736+ int chomping = 0;
2737+ int increment = 0;
2738+ int indent = 0;
2739+ int leading_blank = 0;
2740+ int trailing_blank = 0;
2741+
2742+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2743+ if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
2744+ if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
2745+
2746+ /* Eat the indicator '|' or '>'. */
2747+
2748+ start_mark = parser->mark;
2749+
2750+ SKIP(parser);
2751+
2752+ /* Scan the additional block scalar indicators. */
2753+
2754+ if (!CACHE(parser, 1)) goto error;
2755+
2756+ /* Check for a chomping indicator. */
2757+
2758+ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-'))
2759+ {
2760+ /* Set the chomping method and eat the indicator. */
2761+
2762+ chomping = CHECK(parser->buffer, '+') ? +1 : -1;
2763+
2764+ SKIP(parser);
2765+
2766+ /* Check for an indentation indicator. */
2767+
2768+ if (!CACHE(parser, 1)) goto error;
2769+
2770+ if (IS_DIGIT(parser->buffer))
2771+ {
2772+ /* Check that the intendation is greater than 0. */
2773+
2774+ if (CHECK(parser->buffer, '0')) {
2775+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
2776+ start_mark, "found an intendation indicator equal to 0");
2777+ goto error;
2778+ }
2779+
2780+ /* Get the intendation level and eat the indicator. */
2781+
2782+ increment = AS_DIGIT(parser->buffer);
2783+
2784+ SKIP(parser);
2785+ }
2786+ }
2787+
2788+ /* Do the same as above, but in the opposite order. */
2789+
2790+ else if (IS_DIGIT(parser->buffer))
2791+ {
2792+ if (CHECK(parser->buffer, '0')) {
2793+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
2794+ start_mark, "found an intendation indicator equal to 0");
2795+ goto error;
2796+ }
2797+
2798+ increment = AS_DIGIT(parser->buffer);
2799+
2800+ SKIP(parser);
2801+
2802+ if (!CACHE(parser, 1)) goto error;
2803+
2804+ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) {
2805+ chomping = CHECK(parser->buffer, '+') ? +1 : -1;
2806+
2807+ SKIP(parser);
2808+ }
2809+ }
2810+
2811+ /* Eat whitespaces and comments to the end of the line. */
2812+
2813+ if (!CACHE(parser, 1)) goto error;
2814+
2815+ while (IS_BLANK(parser->buffer)) {
2816+ SKIP(parser);
2817+ if (!CACHE(parser, 1)) goto error;
2818+ }
2819+
2820+ if (CHECK(parser->buffer, '#')) {
2821+ while (!IS_BREAKZ(parser->buffer)) {
2822+ SKIP(parser);
2823+ if (!CACHE(parser, 1)) goto error;
2824+ }
2825+ }
2826+
2827+ /* Check if we are at the end of the line. */
2828+
2829+ if (!IS_BREAKZ(parser->buffer)) {
2830+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
2831+ start_mark, "did not find expected comment or line break");
2832+ goto error;
2833+ }
2834+
2835+ /* Eat a line break. */
2836+
2837+ if (IS_BREAK(parser->buffer)) {
2838+ if (!CACHE(parser, 2)) goto error;
2839+ SKIP_LINE(parser);
2840+ }
2841+
2842+ end_mark = parser->mark;
2843+
2844+ /* Set the intendation level if it was specified. */
2845+
2846+ if (increment) {
2847+ indent = parser->indent >= 0 ? parser->indent+increment : increment;
2848+ }
2849+
2850+ /* Scan the leading line breaks and determine the indentation level if needed. */
2851+
2852+ if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks,
2853+ start_mark, &end_mark)) goto error;
2854+
2855+ /* Scan the block scalar content. */
2856+
2857+ if (!CACHE(parser, 1)) goto error;
2858+
2859+ while ((int)parser->mark.column == indent && !IS_Z(parser->buffer))
2860+ {
2861+ /*
2862+ * We are at the beginning of a non-empty line.
2863+ */
2864+
2865+ /* Is it a trailing whitespace? */
2866+
2867+ trailing_blank = IS_BLANK(parser->buffer);
2868+
2869+ /* Check if we need to fold the leading line break. */
2870+
2871+ if (!literal && (*leading_break.start == '\n')
2872+ && !leading_blank && !trailing_blank)
2873+ {
2874+ /* Do we need to join the lines by space? */
2875+
2876+ if (*trailing_breaks.start == '\0') {
2877+ if (!STRING_EXTEND(parser, string)) goto error;
2878+ *(string.pointer ++) = ' ';
2879+ }
2880+
2881+ CLEAR(parser, leading_break);
2882+ }
2883+ else {
2884+ if (!JOIN(parser, string, leading_break)) goto error;
2885+ CLEAR(parser, leading_break);
2886+ }
2887+
2888+ /* Append the remaining line breaks. */
2889+
2890+ if (!JOIN(parser, string, trailing_breaks)) goto error;
2891+ CLEAR(parser, trailing_breaks);
2892+
2893+ /* Is it a leading whitespace? */
2894+
2895+ leading_blank = IS_BLANK(parser->buffer);
2896+
2897+ /* Consume the current line. */
2898+
2899+ while (!IS_BREAKZ(parser->buffer)) {
2900+ if (!READ(parser, string)) goto error;
2901+ if (!CACHE(parser, 1)) goto error;
2902+ }
2903+
2904+ /* Consume the line break. */
2905+
2906+ if (!CACHE(parser, 2)) goto error;
2907+
2908+ if (!READ_LINE(parser, leading_break)) goto error;
2909+
2910+ /* Eat the following intendation spaces and line breaks. */
2911+
2912+ if (!yaml_parser_scan_block_scalar_breaks(parser,
2913+ &indent, &trailing_breaks, start_mark, &end_mark)) goto error;
2914+ }
2915+
2916+ /* Chomp the tail. */
2917+
2918+ if (chomping != -1) {
2919+ if (!JOIN(parser, string, leading_break)) goto error;
2920+ }
2921+ if (chomping == 1) {
2922+ if (!JOIN(parser, string, trailing_breaks)) goto error;
2923+ }
2924+
2925+ /* Create a token. */
2926+
2927+ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
2928+ literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE,
2929+ start_mark, end_mark);
2930+
2931+ STRING_DEL(parser, leading_break);
2932+ STRING_DEL(parser, trailing_breaks);
2933+
2934+ return 1;
2935+
2936+error:
2937+ STRING_DEL(parser, string);
2938+ STRING_DEL(parser, leading_break);
2939+ STRING_DEL(parser, trailing_breaks);
2940+
2941+ return 0;
2942+}
2943+
2944+/*
2945+ * Scan intendation spaces and line breaks for a block scalar. Determine the
2946+ * intendation level if needed.
2947+ */
2948+
2949+static int
2950+yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
2951+ int *indent, yaml_string_t *breaks,
2952+ yaml_mark_t start_mark, yaml_mark_t *end_mark)
2953+{
2954+ int max_indent = 0;
2955+
2956+ *end_mark = parser->mark;
2957+
2958+ /* Eat the intendation spaces and line breaks. */
2959+
2960+ while (1)
2961+ {
2962+ /* Eat the intendation spaces. */
2963+
2964+ if (!CACHE(parser, 1)) return 0;
2965+
2966+ while ((!*indent || (int)parser->mark.column < *indent)
2967+ && IS_SPACE(parser->buffer)) {
2968+ SKIP(parser);
2969+ if (!CACHE(parser, 1)) return 0;
2970+ }
2971+
2972+ if ((int)parser->mark.column > max_indent)
2973+ max_indent = (int)parser->mark.column;
2974+
2975+ /* Check for a tab character messing the intendation. */
2976+
2977+ if ((!*indent || (int)parser->mark.column < *indent)
2978+ && IS_TAB(parser->buffer)) {
2979+ return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
2980+ start_mark, "found a tab character where an intendation space is expected");
2981+ }
2982+
2983+ /* Have we found a non-empty line? */
2984+
2985+ if (!IS_BREAK(parser->buffer)) break;
2986+
2987+ /* Consume the line break. */
2988+
2989+ if (!CACHE(parser, 2)) return 0;
2990+ if (!READ_LINE(parser, *breaks)) return 0;
2991+ *end_mark = parser->mark;
2992+ }
2993+
2994+ /* Determine the indentation level if needed. */
2995+
2996+ if (!*indent) {
2997+ *indent = max_indent;
2998+ if (*indent < parser->indent + 1)
2999+ *indent = parser->indent + 1;
3000+ if (*indent < 1)
3001+ *indent = 1;
3002+ }
3003+
3004+ return 1;
3005+}
3006+
3007+/*
3008+ * Scan a quoted scalar.
3009+ */
3010+
3011+static int
3012+yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,
3013+ int single)
3014+{
3015+ yaml_mark_t start_mark;
3016+ yaml_mark_t end_mark;
3017+ yaml_string_t string = NULL_STRING;
3018+ yaml_string_t leading_break = NULL_STRING;
3019+ yaml_string_t trailing_breaks = NULL_STRING;
3020+ yaml_string_t whitespaces = NULL_STRING;
3021+ int leading_blanks;
3022+
3023+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
3024+ if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
3025+ if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
3026+ if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
3027+
3028+ /* Eat the left quote. */
3029+
3030+ start_mark = parser->mark;
3031+
3032+ SKIP(parser);
3033+
3034+ /* Consume the content of the quoted scalar. */
3035+
3036+ while (1)
3037+ {
3038+ /* Check that there are no document indicators at the beginning of the line. */
3039+
3040+ if (!CACHE(parser, 4)) goto error;
3041+
3042+ if (parser->mark.column == 0 &&
3043+ ((CHECK_AT(parser->buffer, '-', 0) &&
3044+ CHECK_AT(parser->buffer, '-', 1) &&
3045+ CHECK_AT(parser->buffer, '-', 2)) ||
3046+ (CHECK_AT(parser->buffer, '.', 0) &&
3047+ CHECK_AT(parser->buffer, '.', 1) &&
3048+ CHECK_AT(parser->buffer, '.', 2))) &&
3049+ IS_BLANKZ_AT(parser->buffer, 3))
3050+ {
3051+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
3052+ start_mark, "found unexpected document indicator");
3053+ goto error;
3054+ }
3055+
3056+ /* Check for EOF. */
3057+
3058+ if (IS_Z(parser->buffer)) {
3059+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
3060+ start_mark, "found unexpected end of stream");
3061+ goto error;
3062+ }
3063+
3064+ /* Consume non-blank characters. */
3065+
3066+ if (!CACHE(parser, 2)) goto error;
3067+
3068+ leading_blanks = 0;
3069+
3070+ while (!IS_BLANKZ(parser->buffer))
3071+ {
3072+ /* Check for an escaped single quote. */
3073+
3074+ if (single && CHECK_AT(parser->buffer, '\'', 0)
3075+ && CHECK_AT(parser->buffer, '\'', 1))
3076+ {
3077+ if (!STRING_EXTEND(parser, string)) goto error;
3078+ *(string.pointer++) = '\'';
3079+ SKIP(parser);
3080+ SKIP(parser);
3081+ }
3082+
3083+ /* Check for the right quote. */
3084+
3085+ else if (CHECK(parser->buffer, single ? '\'' : '"'))
3086+ {
3087+ break;
3088+ }
3089+
3090+ /* Check for an escaped line break. */
3091+
3092+ else if (!single && CHECK(parser->buffer, '\\')
3093+ && IS_BREAK_AT(parser->buffer, 1))
3094+ {
3095+ if (!CACHE(parser, 3)) goto error;
3096+ SKIP(parser);
3097+ SKIP_LINE(parser);
3098+ leading_blanks = 1;
3099+ break;
3100+ }
3101+
3102+ /* Check for an escape sequence. */
3103+
3104+ else if (!single && CHECK(parser->buffer, '\\'))
3105+ {
3106+ size_t code_length = 0;
3107+
3108+ if (!STRING_EXTEND(parser, string)) goto error;
3109+
3110+ /* Check the escape character. */
3111+
3112+ switch (parser->buffer.pointer[1])
3113+ {
3114+ case '0':
3115+ *(string.pointer++) = '\0';
3116+ break;
3117+
3118+ case 'a':
3119+ *(string.pointer++) = '\x07';
3120+ break;
3121+
3122+ case 'b':
3123+ *(string.pointer++) = '\x08';
3124+ break;
3125+
3126+ case 't':
3127+ case '\t':
3128+ *(string.pointer++) = '\x09';
3129+ break;
3130+
3131+ case 'n':
3132+ *(string.pointer++) = '\x0A';
3133+ break;
3134+
3135+ case 'v':
3136+ *(string.pointer++) = '\x0B';
3137+ break;
3138+
3139+ case 'f':
3140+ *(string.pointer++) = '\x0C';
3141+ break;
3142+
3143+ case 'r':
3144+ *(string.pointer++) = '\x0D';
3145+ break;
3146+
3147+ case 'e':
3148+ *(string.pointer++) = '\x1B';
3149+ break;
3150+
3151+ case ' ':
3152+ *(string.pointer++) = '\x20';
3153+ break;
3154+
3155+ case '"':
3156+ *(string.pointer++) = '"';
3157+ break;
3158+
3159+ case '\'':
3160+ *(string.pointer++) = '\'';
3161+ break;
3162+
3163+ case '\\':
3164+ *(string.pointer++) = '\\';
3165+ break;
3166+
3167+ case 'N': /* NEL (#x85) */
3168+ *(string.pointer++) = '\xC2';
3169+ *(string.pointer++) = '\x85';
3170+ break;
3171+
3172+ case '_': /* #xA0 */
3173+ *(string.pointer++) = '\xC2';
3174+ *(string.pointer++) = '\xA0';
3175+ break;
3176+
3177+ case 'L': /* LS (#x2028) */
3178+ *(string.pointer++) = '\xE2';
3179+ *(string.pointer++) = '\x80';
3180+ *(string.pointer++) = '\xA8';
3181+ break;
3182+
3183+ case 'P': /* PS (#x2029) */
3184+ *(string.pointer++) = '\xE2';
3185+ *(string.pointer++) = '\x80';
3186+ *(string.pointer++) = '\xA9';
3187+ break;
3188+
3189+ case 'x':
3190+ code_length = 2;
3191+ break;
3192+
3193+ case 'u':
3194+ code_length = 4;
3195+ break;
3196+
3197+ case 'U':
3198+ code_length = 8;
3199+ break;
3200+
3201+ default:
3202+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
3203+ start_mark, "found unknown escape character");
3204+ goto error;
3205+ }
3206+
3207+ SKIP(parser);
3208+ SKIP(parser);
3209+
3210+ /* Consume an arbitrary escape code. */
3211+
3212+ if (code_length)
3213+ {
3214+ unsigned int value = 0;
3215+ size_t k;
3216+
3217+ /* Scan the character value. */
3218+
3219+ if (!CACHE(parser, code_length)) goto error;
3220+
3221+ for (k = 0; k < code_length; k ++) {
3222+ if (!IS_HEX_AT(parser->buffer, k)) {
3223+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
3224+ start_mark, "did not find expected hexdecimal number");
3225+ goto error;
3226+ }
3227+ value = (value << 4) + AS_HEX_AT(parser->buffer, k);
3228+ }
3229+
3230+ /* Check the value and write the character. */
3231+
3232+ if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {
3233+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
3234+ start_mark, "found invalid Unicode character escape code");
3235+ goto error;
3236+ }
3237+
3238+ if (value <= 0x7F) {
3239+ *(string.pointer++) = value;
3240+ }
3241+ else if (value <= 0x7FF) {
3242+ *(string.pointer++) = 0xC0 + (value >> 6);
3243+ *(string.pointer++) = 0x80 + (value & 0x3F);
3244+ }
3245+ else if (value <= 0xFFFF) {
3246+ *(string.pointer++) = 0xE0 + (value >> 12);
3247+ *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F);
3248+ *(string.pointer++) = 0x80 + (value & 0x3F);
3249+ }
3250+ else {
3251+ *(string.pointer++) = 0xF0 + (value >> 18);
3252+ *(string.pointer++) = 0x80 + ((value >> 12) & 0x3F);
3253+ *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F);
3254+ *(string.pointer++) = 0x80 + (value & 0x3F);
3255+ }
3256+
3257+ /* Advance the pointer. */
3258+
3259+ for (k = 0; k < code_length; k ++) {
3260+ SKIP(parser);
3261+ }
3262+ }
3263+ }
3264+
3265+ else
3266+ {
3267+ /* It is a non-escaped non-blank character. */
3268+
3269+ if (!READ(parser, string)) goto error;
3270+ }
3271+
3272+ if (!CACHE(parser, 2)) goto error;
3273+ }
3274+
3275+ /* Check if we are at the end of the scalar. */
3276+
3277+ if (CHECK(parser->buffer, single ? '\'' : '"'))
3278+ break;
3279+
3280+ /* Consume blank characters. */
3281+
3282+ if (!CACHE(parser, 1)) goto error;
3283+
3284+ while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
3285+ {
3286+ if (IS_BLANK(parser->buffer))
3287+ {
3288+ /* Consume a space or a tab character. */
3289+
3290+ if (!leading_blanks) {
3291+ if (!READ(parser, whitespaces)) goto error;
3292+ }
3293+ else {
3294+ SKIP(parser);
3295+ }
3296+ }
3297+ else
3298+ {
3299+ if (!CACHE(parser, 2)) goto error;
3300+
3301+ /* Check if it is a first line break. */
3302+
3303+ if (!leading_blanks)
3304+ {
3305+ CLEAR(parser, whitespaces);
3306+ if (!READ_LINE(parser, leading_break)) goto error;
3307+ leading_blanks = 1;
3308+ }
3309+ else
3310+ {
3311+ if (!READ_LINE(parser, trailing_breaks)) goto error;
3312+ }
3313+ }
3314+ if (!CACHE(parser, 1)) goto error;
3315+ }
3316+
3317+ /* Join the whitespaces or fold line breaks. */
3318+
3319+ if (leading_blanks)
3320+ {
3321+ /* Do we need to fold line breaks? */
3322+
3323+ if (leading_break.start[0] == '\n') {
3324+ if (trailing_breaks.start[0] == '\0') {
3325+ if (!STRING_EXTEND(parser, string)) goto error;
3326+ *(string.pointer++) = ' ';
3327+ }
3328+ else {
3329+ if (!JOIN(parser, string, trailing_breaks)) goto error;
3330+ CLEAR(parser, trailing_breaks);
3331+ }
3332+ CLEAR(parser, leading_break);
3333+ }
3334+ else {
3335+ if (!JOIN(parser, string, leading_break)) goto error;
3336+ if (!JOIN(parser, string, trailing_breaks)) goto error;
3337+ CLEAR(parser, leading_break);
3338+ CLEAR(parser, trailing_breaks);
3339+ }
3340+ }
3341+ else
3342+ {
3343+ if (!JOIN(parser, string, whitespaces)) goto error;
3344+ CLEAR(parser, whitespaces);
3345+ }
3346+ }
3347+
3348+ /* Eat the right quote. */
3349+
3350+ SKIP(parser);
3351+
3352+ end_mark = parser->mark;
3353+
3354+ /* Create a token. */
3355+
3356+ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
3357+ single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE,
3358+ start_mark, end_mark);
3359+
3360+ STRING_DEL(parser, leading_break);
3361+ STRING_DEL(parser, trailing_breaks);
3362+ STRING_DEL(parser, whitespaces);
3363+
3364+ return 1;
3365+
3366+error:
3367+ STRING_DEL(parser, string);
3368+ STRING_DEL(parser, leading_break);
3369+ STRING_DEL(parser, trailing_breaks);
3370+ STRING_DEL(parser, whitespaces);
3371+
3372+ return 0;
3373+}
3374+
3375+/*
3376+ * Scan a plain scalar.
3377+ */
3378+
3379+static int
3380+yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token)
3381+{
3382+ yaml_mark_t start_mark;
3383+ yaml_mark_t end_mark;
3384+ yaml_string_t string = NULL_STRING;
3385+ yaml_string_t leading_break = NULL_STRING;
3386+ yaml_string_t trailing_breaks = NULL_STRING;
3387+ yaml_string_t whitespaces = NULL_STRING;
3388+ int leading_blanks = 0;
3389+ int indent = parser->indent+1;
3390+
3391+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
3392+ if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
3393+ if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
3394+ if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
3395+
3396+ start_mark = end_mark = parser->mark;
3397+
3398+ /* Consume the content of the plain scalar. */
3399+
3400+ while (1)
3401+ {
3402+ /* Check for a document indicator. */
3403+
3404+ if (!CACHE(parser, 4)) goto error;
3405+
3406+ if (parser->mark.column == 0 &&
3407+ ((CHECK_AT(parser->buffer, '-', 0) &&
3408+ CHECK_AT(parser->buffer, '-', 1) &&
3409+ CHECK_AT(parser->buffer, '-', 2)) ||
3410+ (CHECK_AT(parser->buffer, '.', 0) &&
3411+ CHECK_AT(parser->buffer, '.', 1) &&
3412+ CHECK_AT(parser->buffer, '.', 2))) &&
3413+ IS_BLANKZ_AT(parser->buffer, 3)) break;
3414+
3415+ /* Check for a comment. */
3416+
3417+ if (CHECK(parser->buffer, '#'))
3418+ break;
3419+
3420+ /* Consume non-blank characters. */
3421+
3422+ while (!IS_BLANKZ(parser->buffer))
3423+ {
3424+ /* Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". */
3425+
3426+ if (parser->flow_level
3427+ && CHECK(parser->buffer, ':')
3428+ && !IS_BLANKZ_AT(parser->buffer, 1)) {
3429+ yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
3430+ start_mark, "found unexpected ':'");
3431+ goto error;
3432+ }
3433+
3434+ /* Check for indicators that may end a plain scalar. */
3435+
3436+ if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))
3437+ || (parser->flow_level &&
3438+ (CHECK(parser->buffer, ',') || CHECK(parser->buffer, ':')
3439+ || CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[')
3440+ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
3441+ || CHECK(parser->buffer, '}'))))
3442+ break;
3443+
3444+ /* Check if we need to join whitespaces and breaks. */
3445+
3446+ if (leading_blanks || whitespaces.start != whitespaces.pointer)
3447+ {
3448+ if (leading_blanks)
3449+ {
3450+ /* Do we need to fold line breaks? */
3451+
3452+ if (leading_break.start[0] == '\n') {
3453+ if (trailing_breaks.start[0] == '\0') {
3454+ if (!STRING_EXTEND(parser, string)) goto error;
3455+ *(string.pointer++) = ' ';
3456+ }
3457+ else {
3458+ if (!JOIN(parser, string, trailing_breaks)) goto error;
3459+ CLEAR(parser, trailing_breaks);
3460+ }
3461+ CLEAR(parser, leading_break);
3462+ }
3463+ else {
3464+ if (!JOIN(parser, string, leading_break)) goto error;
3465+ if (!JOIN(parser, string, trailing_breaks)) goto error;
3466+ CLEAR(parser, leading_break);
3467+ CLEAR(parser, trailing_breaks);
3468+ }
3469+
3470+ leading_blanks = 0;
3471+ }
3472+ else
3473+ {
3474+ if (!JOIN(parser, string, whitespaces)) goto error;
3475+ CLEAR(parser, whitespaces);
3476+ }
3477+ }
3478+
3479+ /* Copy the character. */
3480+
3481+ if (!READ(parser, string)) goto error;
3482+
3483+ end_mark = parser->mark;
3484+
3485+ if (!CACHE(parser, 2)) goto error;
3486+ }
3487+
3488+ /* Is it the end? */
3489+
3490+ if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))
3491+ break;
3492+
3493+ /* Consume blank characters. */
3494+
3495+ if (!CACHE(parser, 1)) goto error;
3496+
3497+ while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
3498+ {
3499+ if (IS_BLANK(parser->buffer))
3500+ {
3501+ /* Check for tab character that abuse intendation. */
3502+
3503+ if (leading_blanks && (int)parser->mark.column < indent
3504+ && IS_TAB(parser->buffer)) {
3505+ yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
3506+ start_mark, "found a tab character that violate intendation");
3507+ goto error;
3508+ }
3509+
3510+ /* Consume a space or a tab character. */
3511+
3512+ if (!leading_blanks) {
3513+ if (!READ(parser, whitespaces)) goto error;
3514+ }
3515+ else {
3516+ SKIP(parser);
3517+ }
3518+ }
3519+ else
3520+ {
3521+ if (!CACHE(parser, 2)) goto error;
3522+
3523+ /* Check if it is a first line break. */
3524+
3525+ if (!leading_blanks)
3526+ {
3527+ CLEAR(parser, whitespaces);
3528+ if (!READ_LINE(parser, leading_break)) goto error;
3529+ leading_blanks = 1;
3530+ }
3531+ else
3532+ {
3533+ if (!READ_LINE(parser, trailing_breaks)) goto error;
3534+ }
3535+ }
3536+ if (!CACHE(parser, 1)) goto error;
3537+ }
3538+
3539+ /* Check intendation level. */
3540+
3541+ if (!parser->flow_level && (int)parser->mark.column < indent)
3542+ break;
3543+ }
3544+
3545+ /* Create a token. */
3546+
3547+ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
3548+ YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark);
3549+
3550+ /* Note that we change the 'simple_key_allowed' flag. */
3551+
3552+ if (leading_blanks) {
3553+ parser->simple_key_allowed = 1;
3554+ }
3555+
3556+ STRING_DEL(parser, leading_break);
3557+ STRING_DEL(parser, trailing_breaks);
3558+ STRING_DEL(parser, whitespaces);
3559+
3560+ return 1;
3561+
3562+error:
3563+ STRING_DEL(parser, string);
3564+ STRING_DEL(parser, leading_break);
3565+ STRING_DEL(parser, trailing_breaks);
3566+ STRING_DEL(parser, whitespaces);
3567+
3568+ return 0;
3569+}
3570+
libyaml/writer.cnew file+141
@@ -0,0 +1,141 @@
1+
2+#include "yaml_private.h"
3+
4+/*
5+ * Declarations.
6+ */
7+
8+static int
9+yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem);
10+
11+YAML_DECLARE(int)
12+yaml_emitter_flush(yaml_emitter_t *emitter);
13+
14+/*
15+ * Set the writer error and return 0.
16+ */
17+
18+static int
19+yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem)
20+{
21+ emitter->error = YAML_WRITER_ERROR;
22+ emitter->problem = problem;
23+
24+ return 0;
25+}
26+
27+/*
28+ * Flush the output buffer.
29+ */
30+
31+YAML_DECLARE(int)
32+yaml_emitter_flush(yaml_emitter_t *emitter)
33+{
34+ int low, high;
35+
36+ assert(emitter); /* Non-NULL emitter object is expected. */
37+ assert(emitter->write_handler); /* Write handler must be set. */
38+ assert(emitter->encoding); /* Output encoding must be set. */
39+
40+ emitter->buffer.last = emitter->buffer.pointer;
41+ emitter->buffer.pointer = emitter->buffer.start;
42+
43+ /* Check if the buffer is empty. */
44+
45+ if (emitter->buffer.start == emitter->buffer.last) {
46+ return 1;
47+ }
48+
49+ /* If the output encoding is UTF-8, we don't need to recode the buffer. */
50+
51+ if (emitter->encoding == YAML_UTF8_ENCODING)
52+ {
53+ if (emitter->write_handler(emitter->write_handler_data,
54+ emitter->buffer.start,
55+ emitter->buffer.last - emitter->buffer.start)) {
56+ emitter->buffer.last = emitter->buffer.start;
57+ emitter->buffer.pointer = emitter->buffer.start;
58+ return 1;
59+ }
60+ else {
61+ return yaml_emitter_set_writer_error(emitter, "write error");
62+ }
63+ }
64+
65+ /* Recode the buffer into the raw buffer. */
66+
67+ low = (emitter->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
68+ high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
69+
70+ while (emitter->buffer.pointer != emitter->buffer.last)
71+ {
72+ unsigned char octet;
73+ unsigned int width;
74+ unsigned int value;
75+ size_t k;
76+
77+ /*
78+ * See the "reader.c" code for more details on UTF-8 encoding. Note
79+ * that we assume that the buffer contains a valid UTF-8 sequence.
80+ */
81+
82+ /* Read the next UTF-8 character. */
83+
84+ octet = emitter->buffer.pointer[0];
85+
86+ width = (octet & 0x80) == 0x00 ? 1 :
87+ (octet & 0xE0) == 0xC0 ? 2 :
88+ (octet & 0xF0) == 0xE0 ? 3 :
89+ (octet & 0xF8) == 0xF0 ? 4 : 0;
90+
91+ value = (octet & 0x80) == 0x00 ? octet & 0x7F :
92+ (octet & 0xE0) == 0xC0 ? octet & 0x1F :
93+ (octet & 0xF0) == 0xE0 ? octet & 0x0F :
94+ (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
95+
96+ for (k = 1; k < width; k ++) {
97+ octet = emitter->buffer.pointer[k];
98+ value = (value << 6) + (octet & 0x3F);
99+ }
100+
101+ emitter->buffer.pointer += width;
102+
103+ /* Write the character. */
104+
105+ if (value < 0x10000)
106+ {
107+ emitter->raw_buffer.last[high] = value >> 8;
108+ emitter->raw_buffer.last[low] = value & 0xFF;
109+
110+ emitter->raw_buffer.last += 2;
111+ }
112+ else
113+ {
114+ /* Write the character using a surrogate pair (check "reader.c"). */
115+
116+ value -= 0x10000;
117+ emitter->raw_buffer.last[high] = 0xD8 + (value >> 18);
118+ emitter->raw_buffer.last[low] = (value >> 10) & 0xFF;
119+ emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF);
120+ emitter->raw_buffer.last[low+2] = value & 0xFF;
121+
122+ emitter->raw_buffer.last += 4;
123+ }
124+ }
125+
126+ /* Write the raw buffer. */
127+
128+ if (emitter->write_handler(emitter->write_handler_data,
129+ emitter->raw_buffer.start,
130+ emitter->raw_buffer.last - emitter->raw_buffer.start)) {
131+ emitter->buffer.last = emitter->buffer.start;
132+ emitter->buffer.pointer = emitter->buffer.start;
133+ emitter->raw_buffer.last = emitter->raw_buffer.start;
134+ emitter->raw_buffer.pointer = emitter->raw_buffer.start;
135+ return 1;
136+ }
137+ else {
138+ return yaml_emitter_set_writer_error(emitter, "write error");
139+ }
140+}
141+
libyaml/yaml.hnew file+1973
@@ -0,0 +1,1973 @@
1+/**
2+ * @file yaml.h
3+ * @brief Public interface for libyaml.
4+ *
5+ * Include the header file with the code:
6+ * @code
7+ * #include <yaml.h>
8+ * @endcode
9+ */
10+
11+#ifndef YAML_H
12+#define YAML_H
13+
14+#ifdef __cplusplus
15+extern "C" {
16+#endif
17+
18+#include <stdlib.h>
19+#include <stdio.h>
20+#include <string.h>
21+
22+/**
23+ * @defgroup export Export Definitions
24+ * @{
25+ */
26+
27+/** The public API declaration. */
28+
29+#if defined(__MINGW32__)
30+# define YAML_DECLARE(type) type
31+#elif defined(_WIN32)
32+# if defined(YAML_DECLARE_STATIC)
33+# define YAML_DECLARE(type) type
34+# elif defined(YAML_DECLARE_EXPORT)
35+# define YAML_DECLARE(type) __declspec(dllexport) type
36+# else
37+# define YAML_DECLARE(type) __declspec(dllimport) type
38+# endif
39+#else
40+# define YAML_DECLARE(type) type
41+#endif
42+
43+/** @} */
44+
45+/**
46+ * @defgroup version Version Information
47+ * @{
48+ */
49+
50+/**
51+ * Get the library version as a string.
52+ *
53+ * @returns The function returns the pointer to a static string of the form
54+ * @c "X.Y.Z", where @c X is the major version number, @c Y is a minor version
55+ * number, and @c Z is the patch version number.
56+ */
57+
58+YAML_DECLARE(const char *)
59+yaml_get_version_string(void);
60+
61+/**
62+ * Get the library version numbers.
63+ *
64+ * @param[out] major Major version number.
65+ * @param[out] minor Minor version number.
66+ * @param[out] patch Patch version number.
67+ */
68+
69+YAML_DECLARE(void)
70+yaml_get_version(int *major, int *minor, int *patch);
71+
72+/** @} */
73+
74+/**
75+ * @defgroup basic Basic Types
76+ * @{
77+ */
78+
79+/** The character type (UTF-8 octet). */
80+typedef unsigned char yaml_char_t;
81+
82+/** The version directive data. */
83+typedef struct yaml_version_directive_s {
84+ /** The major version number. */
85+ int major;
86+ /** The minor version number. */
87+ int minor;
88+} yaml_version_directive_t;
89+
90+/** The tag directive data. */
91+typedef struct yaml_tag_directive_s {
92+ /** The tag handle. */
93+ yaml_char_t *handle;
94+ /** The tag prefix. */
95+ yaml_char_t *prefix;
96+} yaml_tag_directive_t;
97+
98+/** The stream encoding. */
99+typedef enum yaml_encoding_e {
100+ /** Let the parser choose the encoding. */
101+ YAML_ANY_ENCODING,
102+ /** The default UTF-8 encoding. */
103+ YAML_UTF8_ENCODING,
104+ /** The UTF-16-LE encoding with BOM. */
105+ YAML_UTF16LE_ENCODING,
106+ /** The UTF-16-BE encoding with BOM. */
107+ YAML_UTF16BE_ENCODING
108+} yaml_encoding_t;
109+
110+/** Line break types. */
111+
112+typedef enum yaml_break_e {
113+ /** Let the parser choose the break type. */
114+ YAML_ANY_BREAK,
115+ /** Use CR for line breaks (Mac style). */
116+ YAML_CR_BREAK,
117+ /** Use LN for line breaks (Unix style). */
118+ YAML_LN_BREAK,
119+ /** Use CR LN for line breaks (DOS style). */
120+ YAML_CRLN_BREAK
121+} yaml_break_t;
122+
123+/** Many bad things could happen with the parser and emitter. */
124+typedef enum yaml_error_type_e {
125+ /** No error is produced. */
126+ YAML_NO_ERROR,
127+
128+ /** Cannot allocate or reallocate a block of memory. */
129+ YAML_MEMORY_ERROR,
130+
131+ /** Cannot read or decode the input stream. */
132+ YAML_READER_ERROR,
133+ /** Cannot scan the input stream. */
134+ YAML_SCANNER_ERROR,
135+ /** Cannot parse the input stream. */
136+ YAML_PARSER_ERROR,
137+ /** Cannot compose a YAML document. */
138+ YAML_COMPOSER_ERROR,
139+
140+ /** Cannot write to the output stream. */
141+ YAML_WRITER_ERROR,
142+ /** Cannot emit a YAML stream. */
143+ YAML_EMITTER_ERROR
144+} yaml_error_type_t;
145+
146+/** The pointer position. */
147+typedef struct yaml_mark_s {
148+ /** The position index. */
149+ size_t index;
150+
151+ /** The position line. */
152+ size_t line;
153+
154+ /** The position column. */
155+ size_t column;
156+} yaml_mark_t;
157+
158+/** @} */
159+
160+/**
161+ * @defgroup styles Node Styles
162+ * @{
163+ */
164+
165+/** Scalar styles. */
166+typedef enum yaml_scalar_style_e {
167+ /** Let the emitter choose the style. */
168+ YAML_ANY_SCALAR_STYLE,
169+
170+ /** The plain scalar style. */
171+ YAML_PLAIN_SCALAR_STYLE,
172+
173+ /** The single-quoted scalar style. */
174+ YAML_SINGLE_QUOTED_SCALAR_STYLE,
175+ /** The double-quoted scalar style. */
176+ YAML_DOUBLE_QUOTED_SCALAR_STYLE,
177+
178+ /** The literal scalar style. */
179+ YAML_LITERAL_SCALAR_STYLE,
180+ /** The folded scalar style. */
181+ YAML_FOLDED_SCALAR_STYLE
182+} yaml_scalar_style_t;
183+
184+/** Sequence styles. */
185+typedef enum yaml_sequence_style_e {
186+ /** Let the emitter choose the style. */
187+ YAML_ANY_SEQUENCE_STYLE,
188+
189+ /** The block sequence style. */
190+ YAML_BLOCK_SEQUENCE_STYLE,
191+ /** The flow sequence style. */
192+ YAML_FLOW_SEQUENCE_STYLE
193+} yaml_sequence_style_t;
194+
195+/** Mapping styles. */
196+typedef enum yaml_mapping_style_e {
197+ /** Let the emitter choose the style. */
198+ YAML_ANY_MAPPING_STYLE,
199+
200+ /** The block mapping style. */
201+ YAML_BLOCK_MAPPING_STYLE,
202+ /** The flow mapping style. */
203+ YAML_FLOW_MAPPING_STYLE
204+/* YAML_FLOW_SET_MAPPING_STYLE */
205+} yaml_mapping_style_t;
206+
207+/** @} */
208+
209+/**
210+ * @defgroup tokens Tokens
211+ * @{
212+ */
213+
214+/** Token types. */
215+typedef enum yaml_token_type_e {
216+ /** An empty token. */
217+ YAML_NO_TOKEN,
218+
219+ /** A STREAM-START token. */
220+ YAML_STREAM_START_TOKEN,
221+ /** A STREAM-END token. */
222+ YAML_STREAM_END_TOKEN,
223+
224+ /** A VERSION-DIRECTIVE token. */
225+ YAML_VERSION_DIRECTIVE_TOKEN,
226+ /** A TAG-DIRECTIVE token. */
227+ YAML_TAG_DIRECTIVE_TOKEN,
228+ /** A DOCUMENT-START token. */
229+ YAML_DOCUMENT_START_TOKEN,
230+ /** A DOCUMENT-END token. */
231+ YAML_DOCUMENT_END_TOKEN,
232+
233+ /** A BLOCK-SEQUENCE-START token. */
234+ YAML_BLOCK_SEQUENCE_START_TOKEN,
235+ /** A BLOCK-SEQUENCE-END token. */
236+ YAML_BLOCK_MAPPING_START_TOKEN,
237+ /** A BLOCK-END token. */
238+ YAML_BLOCK_END_TOKEN,
239+
240+ /** A FLOW-SEQUENCE-START token. */
241+ YAML_FLOW_SEQUENCE_START_TOKEN,
242+ /** A FLOW-SEQUENCE-END token. */
243+ YAML_FLOW_SEQUENCE_END_TOKEN,
244+ /** A FLOW-MAPPING-START token. */
245+ YAML_FLOW_MAPPING_START_TOKEN,
246+ /** A FLOW-MAPPING-END token. */
247+ YAML_FLOW_MAPPING_END_TOKEN,
248+
249+ /** A BLOCK-ENTRY token. */
250+ YAML_BLOCK_ENTRY_TOKEN,
251+ /** A FLOW-ENTRY token. */
252+ YAML_FLOW_ENTRY_TOKEN,
253+ /** A KEY token. */
254+ YAML_KEY_TOKEN,
255+ /** A VALUE token. */
256+ YAML_VALUE_TOKEN,
257+
258+ /** An ALIAS token. */
259+ YAML_ALIAS_TOKEN,
260+ /** An ANCHOR token. */
261+ YAML_ANCHOR_TOKEN,
262+ /** A TAG token. */
263+ YAML_TAG_TOKEN,
264+ /** A SCALAR token. */
265+ YAML_SCALAR_TOKEN
266+} yaml_token_type_t;
267+
268+/** The token structure. */
269+typedef struct yaml_token_s {
270+
271+ /** The token type. */
272+ yaml_token_type_t type;
273+
274+ /** The token data. */
275+ union {
276+
277+ /** The stream start (for @c YAML_STREAM_START_TOKEN). */
278+ struct {
279+ /** The stream encoding. */
280+ yaml_encoding_t encoding;
281+ } stream_start;
282+
283+ /** The alias (for @c YAML_ALIAS_TOKEN). */
284+ struct {
285+ /** The alias value. */
286+ yaml_char_t *value;
287+ } alias;
288+
289+ /** The anchor (for @c YAML_ANCHOR_TOKEN). */
290+ struct {
291+ /** The anchor value. */
292+ yaml_char_t *value;
293+ } anchor;
294+
295+ /** The tag (for @c YAML_TAG_TOKEN). */
296+ struct {
297+ /** The tag handle. */
298+ yaml_char_t *handle;
299+ /** The tag suffix. */
300+ yaml_char_t *suffix;
301+ } tag;
302+
303+ /** The scalar value (for @c YAML_SCALAR_TOKEN). */
304+ struct {
305+ /** The scalar value. */
306+ yaml_char_t *value;
307+ /** The length of the scalar value. */
308+ size_t length;
309+ /** The scalar style. */
310+ yaml_scalar_style_t style;
311+ } scalar;
312+
313+ /** The version directive (for @c YAML_VERSION_DIRECTIVE_TOKEN). */
314+ struct {
315+ /** The major version number. */
316+ int major;
317+ /** The minor version number. */
318+ int minor;
319+ } version_directive;
320+
321+ /** The tag directive (for @c YAML_TAG_DIRECTIVE_TOKEN). */
322+ struct {
323+ /** The tag handle. */
324+ yaml_char_t *handle;
325+ /** The tag prefix. */
326+ yaml_char_t *prefix;
327+ } tag_directive;
328+
329+ } data;
330+
331+ /** The beginning of the token. */
332+ yaml_mark_t start_mark;
333+ /** The end of the token. */
334+ yaml_mark_t end_mark;
335+
336+} yaml_token_t;
337+
338+/**
339+ * Free any memory allocated for a token object.
340+ *
341+ * @param[in,out] token A token object.
342+ */
343+
344+YAML_DECLARE(void)
345+yaml_token_delete(yaml_token_t *token);
346+
347+/** @} */
348+
349+/**
350+ * @defgroup events Events
351+ * @{
352+ */
353+
354+/** Event types. */
355+typedef enum yaml_event_type_e {
356+ /** An empty event. */
357+ YAML_NO_EVENT,
358+
359+ /** A STREAM-START event. */
360+ YAML_STREAM_START_EVENT,
361+ /** A STREAM-END event. */
362+ YAML_STREAM_END_EVENT,
363+
364+ /** A DOCUMENT-START event. */
365+ YAML_DOCUMENT_START_EVENT,
366+ /** A DOCUMENT-END event. */
367+ YAML_DOCUMENT_END_EVENT,
368+
369+ /** An ALIAS event. */
370+ YAML_ALIAS_EVENT,
371+ /** A SCALAR event. */
372+ YAML_SCALAR_EVENT,
373+
374+ /** A SEQUENCE-START event. */
375+ YAML_SEQUENCE_START_EVENT,
376+ /** A SEQUENCE-END event. */
377+ YAML_SEQUENCE_END_EVENT,
378+
379+ /** A MAPPING-START event. */
380+ YAML_MAPPING_START_EVENT,
381+ /** A MAPPING-END event. */
382+ YAML_MAPPING_END_EVENT
383+} yaml_event_type_t;
384+
385+/** The event structure. */
386+typedef struct yaml_event_s {
387+
388+ /** The event type. */
389+ yaml_event_type_t type;
390+
391+ /** The event data. */
392+ union {
393+
394+ /** The stream parameters (for @c YAML_STREAM_START_EVENT). */
395+ struct {
396+ /** The document encoding. */
397+ yaml_encoding_t encoding;
398+ } stream_start;
399+
400+ /** The document parameters (for @c YAML_DOCUMENT_START_EVENT). */
401+ struct {
402+ /** The version directive. */
403+ yaml_version_directive_t *version_directive;
404+
405+ /** The list of tag directives. */
406+ struct {
407+ /** The beginning of the tag directives list. */
408+ yaml_tag_directive_t *start;
409+ /** The end of the tag directives list. */
410+ yaml_tag_directive_t *end;
411+ } tag_directives;
412+
413+ /** Is the document indicator implicit? */
414+ int implicit;
415+ } document_start;
416+
417+ /** The document end parameters (for @c YAML_DOCUMENT_END_EVENT). */
418+ struct {
419+ /** Is the document end indicator implicit? */
420+ int implicit;
421+ } document_end;
422+
423+ /** The alias parameters (for @c YAML_ALIAS_EVENT). */
424+ struct {
425+ /** The anchor. */
426+ yaml_char_t *anchor;
427+ } alias;
428+
429+ /** The scalar parameters (for @c YAML_SCALAR_EVENT). */
430+ struct {
431+ /** The anchor. */
432+ yaml_char_t *anchor;
433+ /** The tag. */
434+ yaml_char_t *tag;
435+ /** The scalar value. */
436+ yaml_char_t *value;
437+ /** The length of the scalar value. */
438+ size_t length;
439+ /** Is the tag optional for the plain style? */
440+ int plain_implicit;
441+ /** Is the tag optional for any non-plain style? */
442+ int quoted_implicit;
443+ /** The scalar style. */
444+ yaml_scalar_style_t style;
445+ } scalar;
446+
447+ /** The sequence parameters (for @c YAML_SEQUENCE_START_EVENT). */
448+ struct {
449+ /** The anchor. */
450+ yaml_char_t *anchor;
451+ /** The tag. */
452+ yaml_char_t *tag;
453+ /** Is the tag optional? */
454+ int implicit;
455+ /** The sequence style. */
456+ yaml_sequence_style_t style;
457+ } sequence_start;
458+
459+ /** The mapping parameters (for @c YAML_MAPPING_START_EVENT). */
460+ struct {
461+ /** The anchor. */
462+ yaml_char_t *anchor;
463+ /** The tag. */
464+ yaml_char_t *tag;
465+ /** Is the tag optional? */
466+ int implicit;
467+ /** The mapping style. */
468+ yaml_mapping_style_t style;
469+ } mapping_start;
470+
471+ } data;
472+
473+ /** The beginning of the event. */
474+ yaml_mark_t start_mark;
475+ /** The end of the event. */
476+ yaml_mark_t end_mark;
477+
478+} yaml_event_t;
479+
480+/**
481+ * Create the STREAM-START event.
482+ *
483+ * @param[out] event An empty event object.
484+ * @param[in] encoding The stream encoding.
485+ *
486+ * @returns @c 1 if the function succeeded, @c 0 on error.
487+ */
488+
489+YAML_DECLARE(int)
490+yaml_stream_start_event_initialize(yaml_event_t *event,
491+ yaml_encoding_t encoding);
492+
493+/**
494+ * Create the STREAM-END event.
495+ *
496+ * @param[out] event An empty event object.
497+ *
498+ * @returns @c 1 if the function succeeded, @c 0 on error.
499+ */
500+
501+YAML_DECLARE(int)
502+yaml_stream_end_event_initialize(yaml_event_t *event);
503+
504+/**
505+ * Create the DOCUMENT-START event.
506+ *
507+ * The @a implicit argument is considered as a stylistic parameter and may be
508+ * ignored by the emitter.
509+ *
510+ * @param[out] event An empty event object.
511+ * @param[in] version_directive The %YAML directive value or
512+ * @c NULL.
513+ * @param[in] tag_directives_start The beginning of the %TAG
514+ * directives list.
515+ * @param[in] tag_directives_end The end of the %TAG directives
516+ * list.
517+ * @param[in] implicit If the document start indicator is
518+ * implicit.
519+ *
520+ * @returns @c 1 if the function succeeded, @c 0 on error.
521+ */
522+
523+YAML_DECLARE(int)
524+yaml_document_start_event_initialize(yaml_event_t *event,
525+ yaml_version_directive_t *version_directive,
526+ yaml_tag_directive_t *tag_directives_start,
527+ yaml_tag_directive_t *tag_directives_end,
528+ int implicit);
529+
530+/**
531+ * Create the DOCUMENT-END event.
532+ *
533+ * The @a implicit argument is considered as a stylistic parameter and may be
534+ * ignored by the emitter.
535+ *
536+ * @param[out] event An empty event object.
537+ * @param[in] implicit If the document end indicator is implicit.
538+ *
539+ * @returns @c 1 if the function succeeded, @c 0 on error.
540+ */
541+
542+YAML_DECLARE(int)
543+yaml_document_end_event_initialize(yaml_event_t *event, int implicit);
544+
545+/**
546+ * Create an ALIAS event.
547+ *
548+ * @param[out] event An empty event object.
549+ * @param[in] anchor The anchor value.
550+ *
551+ * @returns @c 1 if the function succeeded, @c 0 on error.
552+ */
553+
554+YAML_DECLARE(int)
555+yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor);
556+
557+/**
558+ * Create a SCALAR event.
559+ *
560+ * The @a style argument may be ignored by the emitter.
561+ *
562+ * Either the @a tag attribute or one of the @a plain_implicit and
563+ * @a quoted_implicit flags must be set.
564+ *
565+ * @param[out] event An empty event object.
566+ * @param[in] anchor The scalar anchor or @c NULL.
567+ * @param[in] tag The scalar tag or @c NULL.
568+ * @param[in] value The scalar value.
569+ * @param[in] length The length of the scalar value.
570+ * @param[in] plain_implicit If the tag may be omitted for the plain
571+ * style.
572+ * @param[in] quoted_implicit If the tag may be omitted for any
573+ * non-plain style.
574+ * @param[in] style The scalar style.
575+ *
576+ * @returns @c 1 if the function succeeded, @c 0 on error.
577+ */
578+
579+YAML_DECLARE(int)
580+yaml_scalar_event_initialize(yaml_event_t *event,
581+ yaml_char_t *anchor, yaml_char_t *tag,
582+ yaml_char_t *value, int length,
583+ int plain_implicit, int quoted_implicit,
584+ yaml_scalar_style_t style);
585+
586+/**
587+ * Create a SEQUENCE-START event.
588+ *
589+ * The @a style argument may be ignored by the emitter.
590+ *
591+ * Either the @a tag attribute or the @a implicit flag must be set.
592+ *
593+ * @param[out] event An empty event object.
594+ * @param[in] anchor The sequence anchor or @c NULL.
595+ * @param[in] tag The sequence tag or @c NULL.
596+ * @param[in] implicit If the tag may be omitted.
597+ * @param[in] style The sequence style.
598+ *
599+ * @returns @c 1 if the function succeeded, @c 0 on error.
600+ */
601+
602+YAML_DECLARE(int)
603+yaml_sequence_start_event_initialize(yaml_event_t *event,
604+ yaml_char_t *anchor, yaml_char_t *tag, int implicit,
605+ yaml_sequence_style_t style);
606+
607+/**
608+ * Create a SEQUENCE-END event.
609+ *
610+ * @param[out] event An empty event object.
611+ *
612+ * @returns @c 1 if the function succeeded, @c 0 on error.
613+ */
614+
615+YAML_DECLARE(int)
616+yaml_sequence_end_event_initialize(yaml_event_t *event);
617+
618+/**
619+ * Create a MAPPING-START event.
620+ *
621+ * The @a style argument may be ignored by the emitter.
622+ *
623+ * Either the @a tag attribute or the @a implicit flag must be set.
624+ *
625+ * @param[out] event An empty event object.
626+ * @param[in] anchor The mapping anchor or @c NULL.
627+ * @param[in] tag The mapping tag or @c NULL.
628+ * @param[in] implicit If the tag may be omitted.
629+ * @param[in] style The mapping style.
630+ *
631+ * @returns @c 1 if the function succeeded, @c 0 on error.
632+ */
633+
634+YAML_DECLARE(int)
635+yaml_mapping_start_event_initialize(yaml_event_t *event,
636+ yaml_char_t *anchor, yaml_char_t *tag, int implicit,
637+ yaml_mapping_style_t style);
638+
639+/**
640+ * Create a MAPPING-END event.
641+ *
642+ * @param[out] event An empty event object.
643+ *
644+ * @returns @c 1 if the function succeeded, @c 0 on error.
645+ */
646+
647+YAML_DECLARE(int)
648+yaml_mapping_end_event_initialize(yaml_event_t *event);
649+
650+/**
651+ * Free any memory allocated for an event object.
652+ *
653+ * @param[in,out] event An event object.
654+ */
655+
656+YAML_DECLARE(void)
657+yaml_event_delete(yaml_event_t *event);
658+
659+/** @} */
660+
661+/**
662+ * @defgroup nodes Nodes
663+ * @{
664+ */
665+
666+/** The tag @c !!null with the only possible value: @c null. */
667+#define YAML_NULL_TAG "tag:yaml.org,2002:null"
668+/** The tag @c !!bool with the values: @c true and @c falce. */
669+#define YAML_BOOL_TAG "tag:yaml.org,2002:bool"
670+/** The tag @c !!str for string values. */
671+#define YAML_STR_TAG "tag:yaml.org,2002:str"
672+/** The tag @c !!int for integer values. */
673+#define YAML_INT_TAG "tag:yaml.org,2002:int"
674+/** The tag @c !!float for float values. */
675+#define YAML_FLOAT_TAG "tag:yaml.org,2002:float"
676+/** The tag @c !!timestamp for date and time values. */
677+#define YAML_TIMESTAMP_TAG "tag:yaml.org,2002:timestamp"
678+
679+/** The tag @c !!seq is used to denote sequences. */
680+#define YAML_SEQ_TAG "tag:yaml.org,2002:seq"
681+/** The tag @c !!map is used to denote mapping. */
682+#define YAML_MAP_TAG "tag:yaml.org,2002:map"
683+
684+/** The default scalar tag is @c !!str. */
685+#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG
686+/** The default sequence tag is @c !!seq. */
687+#define YAML_DEFAULT_SEQUENCE_TAG YAML_SEQ_TAG
688+/** The default mapping tag is @c !!map. */
689+#define YAML_DEFAULT_MAPPING_TAG YAML_MAP_TAG
690+
691+/** Node types. */
692+typedef enum yaml_node_type_e {
693+ /** An empty node. */
694+ YAML_NO_NODE,
695+
696+ /** A scalar node. */
697+ YAML_SCALAR_NODE,
698+ /** A sequence node. */
699+ YAML_SEQUENCE_NODE,
700+ /** A mapping node. */
701+ YAML_MAPPING_NODE
702+} yaml_node_type_t;
703+
704+/** The forward definition of a document node structure. */
705+typedef struct yaml_node_s yaml_node_t;
706+
707+/** An element of a sequence node. */
708+typedef int yaml_node_item_t;
709+
710+/** An element of a mapping node. */
711+typedef struct yaml_node_pair_s {
712+ /** The key of the element. */
713+ int key;
714+ /** The value of the element. */
715+ int value;
716+} yaml_node_pair_t;
717+
718+/** The node structure. */
719+struct yaml_node_s {
720+
721+ /** The node type. */
722+ yaml_node_type_t type;
723+
724+ /** The node tag. */
725+ yaml_char_t *tag;
726+
727+ /** The node data. */
728+ union {
729+
730+ /** The scalar parameters (for @c YAML_SCALAR_NODE). */
731+ struct {
732+ /** The scalar value. */
733+ yaml_char_t *value;
734+ /** The length of the scalar value. */
735+ size_t length;
736+ /** The scalar style. */
737+ yaml_scalar_style_t style;
738+ } scalar;
739+
740+ /** The sequence parameters (for @c YAML_SEQUENCE_NODE). */
741+ struct {
742+ /** The stack of sequence items. */
743+ struct {
744+ /** The beginning of the stack. */
745+ yaml_node_item_t *start;
746+ /** The end of the stack. */
747+ yaml_node_item_t *end;
748+ /** The top of the stack. */
749+ yaml_node_item_t *top;
750+ } items;
751+ /** The sequence style. */
752+ yaml_sequence_style_t style;
753+ } sequence;
754+
755+ /** The mapping parameters (for @c YAML_MAPPING_NODE). */
756+ struct {
757+ /** The stack of mapping pairs (key, value). */
758+ struct {
759+ /** The beginning of the stack. */
760+ yaml_node_pair_t *start;
761+ /** The end of the stack. */
762+ yaml_node_pair_t *end;
763+ /** The top of the stack. */
764+ yaml_node_pair_t *top;
765+ } pairs;
766+ /** The mapping style. */
767+ yaml_mapping_style_t style;
768+ } mapping;
769+
770+ } data;
771+
772+ /** The beginning of the node. */
773+ yaml_mark_t start_mark;
774+ /** The end of the node. */
775+ yaml_mark_t end_mark;
776+
777+};
778+
779+/** The document structure. */
780+typedef struct yaml_document_s {
781+
782+ /** The document nodes. */
783+ struct {
784+ /** The beginning of the stack. */
785+ yaml_node_t *start;
786+ /** The end of the stack. */
787+ yaml_node_t *end;
788+ /** The top of the stack. */
789+ yaml_node_t *top;
790+ } nodes;
791+
792+ /** The version directive. */
793+ yaml_version_directive_t *version_directive;
794+
795+ /** The list of tag directives. */
796+ struct {
797+ /** The beginning of the tag directives list. */
798+ yaml_tag_directive_t *start;
799+ /** The end of the tag directives list. */
800+ yaml_tag_directive_t *end;
801+ } tag_directives;
802+
803+ /** Is the document start indicator implicit? */
804+ int start_implicit;
805+ /** Is the document end indicator implicit? */
806+ int end_implicit;
807+
808+ /** The beginning of the document. */
809+ yaml_mark_t start_mark;
810+ /** The end of the document. */
811+ yaml_mark_t end_mark;
812+
813+} yaml_document_t;
814+
815+/**
816+ * Create a YAML document.
817+ *
818+ * @param[out] document An empty document object.
819+ * @param[in] version_directive The %YAML directive value or
820+ * @c NULL.
821+ * @param[in] tag_directives_start The beginning of the %TAG
822+ * directives list.
823+ * @param[in] tag_directives_end The end of the %TAG directives
824+ * list.
825+ * @param[in] start_implicit If the document start indicator is
826+ * implicit.
827+ * @param[in] end_implicit If the document end indicator is
828+ * implicit.
829+ *
830+ * @returns @c 1 if the function succeeded, @c 0 on error.
831+ */
832+
833+YAML_DECLARE(int)
834+yaml_document_initialize(yaml_document_t *document,
835+ yaml_version_directive_t *version_directive,
836+ yaml_tag_directive_t *tag_directives_start,
837+ yaml_tag_directive_t *tag_directives_end,
838+ int start_implicit, int end_implicit);
839+
840+/**
841+ * Delete a YAML document and all its nodes.
842+ *
843+ * @param[in,out] document A document object.
844+ */
845+
846+YAML_DECLARE(void)
847+yaml_document_delete(yaml_document_t *document);
848+
849+/**
850+ * Get a node of a YAML document.
851+ *
852+ * The pointer returned by this function is valid until any of the functions
853+ * modifying the documents are called.
854+ *
855+ * @param[in] document A document object.
856+ * @param[in] index The node id.
857+ *
858+ * @returns the node objct or @c NULL if @c node_id is out of range.
859+ */
860+
861+YAML_DECLARE(yaml_node_t *)
862+yaml_document_get_node(yaml_document_t *document, int index);
863+
864+/**
865+ * Get the root of a YAML document node.
866+ *
867+ * The root object is the first object added to the document.
868+ *
869+ * The pointer returned by this function is valid until any of the functions
870+ * modifying the documents are called.
871+ *
872+ * An empty document produced by the parser signifies the end of a YAML
873+ * stream.
874+ *
875+ * @param[in] document A document object.
876+ *
877+ * @returns the node object or @c NULL if the document is empty.
878+ */
879+
880+YAML_DECLARE(yaml_node_t *)
881+yaml_document_get_root_node(yaml_document_t *document);
882+
883+/**
884+ * Create a SCALAR node and attach it to the document.
885+ *
886+ * The @a style argument may be ignored by the emitter.
887+ *
888+ * @param[in,out] document A document object.
889+ * @param[in] tag The scalar tag.
890+ * @param[in] value The scalar value.
891+ * @param[in] length The length of the scalar value.
892+ * @param[in] style The scalar style.
893+ *
894+ * @returns the node id or @c 0 on error.
895+ */
896+
897+YAML_DECLARE(int)
898+yaml_document_add_scalar(yaml_document_t *document,
899+ yaml_char_t *tag, yaml_char_t *value, int length,
900+ yaml_scalar_style_t style);
901+
902+/**
903+ * Create a SEQUENCE node and attach it to the document.
904+ *
905+ * The @a style argument may be ignored by the emitter.
906+ *
907+ * @param[in,out] document A document object.
908+ * @param[in] tag The sequence tag.
909+ * @param[in] style The sequence style.
910+ *
911+ * @returns the node id or @c 0 on error.
912+ */
913+
914+YAML_DECLARE(int)
915+yaml_document_add_sequence(yaml_document_t *document,
916+ yaml_char_t *tag, yaml_sequence_style_t style);
917+
918+/**
919+ * Create a MAPPING node and attach it to the document.
920+ *
921+ * The @a style argument may be ignored by the emitter.
922+ *
923+ * @param[in,out] document A document object.
924+ * @param[in] tag The sequence tag.
925+ * @param[in] style The sequence style.
926+ *
927+ * @returns the node id or @c 0 on error.
928+ */
929+
930+YAML_DECLARE(int)
931+yaml_document_add_mapping(yaml_document_t *document,
932+ yaml_char_t *tag, yaml_mapping_style_t style);
933+
934+/**
935+ * Add an item to a SEQUENCE node.
936+ *
937+ * @param[in,out] document A document object.
938+ * @param[in] sequence The sequence node id.
939+ * @param[in] item The item node id.
940+*
941+ * @returns @c 1 if the function succeeded, @c 0 on error.
942+ */
943+
944+YAML_DECLARE(int)
945+yaml_document_append_sequence_item(yaml_document_t *document,
946+ int sequence, int item);
947+
948+/**
949+ * Add a pair of a key and a value to a MAPPING node.
950+ *
951+ * @param[in,out] document A document object.
952+ * @param[in] mapping The mapping node id.
953+ * @param[in] key The key node id.
954+ * @param[in] value The value node id.
955+*
956+ * @returns @c 1 if the function succeeded, @c 0 on error.
957+ */
958+
959+YAML_DECLARE(int)
960+yaml_document_append_mapping_pair(yaml_document_t *document,
961+ int mapping, int key, int value);
962+
963+/** @} */
964+
965+/**
966+ * @defgroup parser Parser Definitions
967+ * @{
968+ */
969+
970+/**
971+ * The prototype of a read handler.
972+ *
973+ * The read handler is called when the parser needs to read more bytes from the
974+ * source. The handler should write not more than @a size bytes to the @a
975+ * buffer. The number of written bytes should be set to the @a length variable.
976+ *
977+ * @param[in,out] data A pointer to an application data specified by
978+ * yaml_parser_set_input().
979+ * @param[out] buffer The buffer to write the data from the source.
980+ * @param[in] size The size of the buffer.
981+ * @param[out] size_read The actual number of bytes read from the source.
982+ *
983+ * @returns On success, the handler should return @c 1. If the handler failed,
984+ * the returned value should be @c 0. On EOF, the handler should set the
985+ * @a size_read to @c 0 and return @c 1.
986+ */
987+
988+typedef int yaml_read_handler_t(void *data, unsigned char *buffer, size_t size,
989+ size_t *size_read);
990+
991+/**
992+ * This structure holds information about a potential simple key.
993+ */
994+
995+typedef struct yaml_simple_key_s {
996+ /** Is a simple key possible? */
997+ int possible;
998+
999+ /** Is a simple key required? */
1000+ int required;
1001+
1002+ /** The number of the token. */
1003+ size_t token_number;
1004+
1005+ /** The position mark. */
1006+ yaml_mark_t mark;
1007+} yaml_simple_key_t;
1008+
1009+/**
1010+ * The states of the parser.
1011+ */
1012+typedef enum yaml_parser_state_e {
1013+ /** Expect STREAM-START. */
1014+ YAML_PARSE_STREAM_START_STATE,
1015+ /** Expect the beginning of an implicit document. */
1016+ YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
1017+ /** Expect DOCUMENT-START. */
1018+ YAML_PARSE_DOCUMENT_START_STATE,
1019+ /** Expect the content of a document. */
1020+ YAML_PARSE_DOCUMENT_CONTENT_STATE,
1021+ /** Expect DOCUMENT-END. */
1022+ YAML_PARSE_DOCUMENT_END_STATE,
1023+ /** Expect a block node. */
1024+ YAML_PARSE_BLOCK_NODE_STATE,
1025+ /** Expect a block node or indentless sequence. */
1026+ YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
1027+ /** Expect a flow node. */
1028+ YAML_PARSE_FLOW_NODE_STATE,
1029+ /** Expect the first entry of a block sequence. */
1030+ YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE,
1031+ /** Expect an entry of a block sequence. */
1032+ YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,
1033+ /** Expect an entry of an indentless sequence. */
1034+ YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE,
1035+ /** Expect the first key of a block mapping. */
1036+ YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
1037+ /** Expect a block mapping key. */
1038+ YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
1039+ /** Expect a block mapping value. */
1040+ YAML_PARSE_BLOCK_MAPPING_VALUE_STATE,
1041+ /** Expect the first entry of a flow sequence. */
1042+ YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE,
1043+ /** Expect an entry of a flow sequence. */
1044+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
1045+ /** Expect a key of an ordered mapping. */
1046+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
1047+ /** Expect a value of an ordered mapping. */
1048+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE,
1049+ /** Expect the and of an ordered mapping entry. */
1050+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
1051+ /** Expect the first key of a flow mapping. */
1052+ YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
1053+ /** Expect a key of a flow mapping. */
1054+ YAML_PARSE_FLOW_MAPPING_KEY_STATE,
1055+ /** Expect a value of a flow mapping. */
1056+ YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
1057+ /** Expect an empty value of a flow mapping. */
1058+ YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE,
1059+ /** Expect nothing. */
1060+ YAML_PARSE_END_STATE
1061+} yaml_parser_state_t;
1062+
1063+/**
1064+ * This structure holds aliases data.
1065+ */
1066+
1067+typedef struct yaml_alias_data_s {
1068+ /** The anchor. */
1069+ yaml_char_t *anchor;
1070+ /** The node id. */
1071+ int index;
1072+ /** The anchor mark. */
1073+ yaml_mark_t mark;
1074+} yaml_alias_data_t;
1075+
1076+/**
1077+ * The parser structure.
1078+ *
1079+ * All members are internal. Manage the structure using the @c yaml_parser_
1080+ * family of functions.
1081+ */
1082+
1083+typedef struct yaml_parser_s {
1084+
1085+ /**
1086+ * @name Error handling
1087+ * @{
1088+ */
1089+
1090+ /** Error type. */
1091+ yaml_error_type_t error;
1092+ /** Error description. */
1093+ const char *problem;
1094+ /** The byte about which the problem occured. */
1095+ size_t problem_offset;
1096+ /** The problematic value (@c -1 is none). */
1097+ int problem_value;
1098+ /** The problem position. */
1099+ yaml_mark_t problem_mark;
1100+ /** The error context. */
1101+ const char *context;
1102+ /** The context position. */
1103+ yaml_mark_t context_mark;
1104+
1105+ /**
1106+ * @}
1107+ */
1108+
1109+ /**
1110+ * @name Reader stuff
1111+ * @{
1112+ */
1113+
1114+ /** Read handler. */
1115+ yaml_read_handler_t *read_handler;
1116+
1117+ /** A pointer for passing to the read handler. */
1118+ void *read_handler_data;
1119+
1120+ /** Standard (string or file) input data. */
1121+ union {
1122+ /** String input data. */
1123+ struct {
1124+ /** The string start pointer. */
1125+ const unsigned char *start;
1126+ /** The string end pointer. */
1127+ const unsigned char *end;
1128+ /** The string current position. */
1129+ const unsigned char *current;
1130+ } string;
1131+
1132+ /** File input data. */
1133+ FILE *file;
1134+ } input;
1135+
1136+ /** EOF flag */
1137+ int eof;
1138+
1139+ /** The working buffer. */
1140+ struct {
1141+ /** The beginning of the buffer. */
1142+ yaml_char_t *start;
1143+ /** The end of the buffer. */
1144+ yaml_char_t *end;
1145+ /** The current position of the buffer. */
1146+ yaml_char_t *pointer;
1147+ /** The last filled position of the buffer. */
1148+ yaml_char_t *last;
1149+ } buffer;
1150+
1151+ /* The number of unread characters in the buffer. */
1152+ size_t unread;
1153+
1154+ /** The raw buffer. */
1155+ struct {
1156+ /** The beginning of the buffer. */
1157+ unsigned char *start;
1158+ /** The end of the buffer. */
1159+ unsigned char *end;
1160+ /** The current position of the buffer. */
1161+ unsigned char *pointer;
1162+ /** The last filled position of the buffer. */
1163+ unsigned char *last;
1164+ } raw_buffer;
1165+
1166+ /** The input encoding. */
1167+ yaml_encoding_t encoding;
1168+
1169+ /** The offset of the current position (in bytes). */
1170+ size_t offset;
1171+
1172+ /** The mark of the current position. */
1173+ yaml_mark_t mark;
1174+
1175+ /**
1176+ * @}
1177+ */
1178+
1179+ /**
1180+ * @name Scanner stuff
1181+ * @{
1182+ */
1183+
1184+ /** Have we started to scan the input stream? */
1185+ int stream_start_produced;
1186+
1187+ /** Have we reached the end of the input stream? */
1188+ int stream_end_produced;
1189+
1190+ /** The number of unclosed '[' and '{' indicators. */
1191+ int flow_level;
1192+
1193+ /** The tokens queue. */
1194+ struct {
1195+ /** The beginning of the tokens queue. */
1196+ yaml_token_t *start;
1197+ /** The end of the tokens queue. */
1198+ yaml_token_t *end;
1199+ /** The head of the tokens queue. */
1200+ yaml_token_t *head;
1201+ /** The tail of the tokens queue. */
1202+ yaml_token_t *tail;
1203+ } tokens;
1204+
1205+ /** The number of tokens fetched from the queue. */
1206+ size_t tokens_parsed;
1207+
1208+ /* Does the tokens queue contain a token ready for dequeueing. */
1209+ int token_available;
1210+
1211+ /** The indentation levels stack. */
1212+ struct {
1213+ /** The beginning of the stack. */
1214+ int *start;
1215+ /** The end of the stack. */
1216+ int *end;
1217+ /** The top of the stack. */
1218+ int *top;
1219+ } indents;
1220+
1221+ /** The current indentation level. */
1222+ int indent;
1223+
1224+ /** May a simple key occur at the current position? */
1225+ int simple_key_allowed;
1226+
1227+ /** The stack of simple keys. */
1228+ struct {
1229+ /** The beginning of the stack. */
1230+ yaml_simple_key_t *start;
1231+ /** The end of the stack. */
1232+ yaml_simple_key_t *end;
1233+ /** The top of the stack. */
1234+ yaml_simple_key_t *top;
1235+ } simple_keys;
1236+
1237+ /**
1238+ * @}
1239+ */
1240+
1241+ /**
1242+ * @name Parser stuff
1243+ * @{
1244+ */
1245+
1246+ /** The parser states stack. */
1247+ struct {
1248+ /** The beginning of the stack. */
1249+ yaml_parser_state_t *start;
1250+ /** The end of the stack. */
1251+ yaml_parser_state_t *end;
1252+ /** The top of the stack. */
1253+ yaml_parser_state_t *top;
1254+ } states;
1255+
1256+ /** The current parser state. */
1257+ yaml_parser_state_t state;
1258+
1259+ /** The stack of marks. */
1260+ struct {
1261+ /** The beginning of the stack. */
1262+ yaml_mark_t *start;
1263+ /** The end of the stack. */
1264+ yaml_mark_t *end;
1265+ /** The top of the stack. */
1266+ yaml_mark_t *top;
1267+ } marks;
1268+
1269+ /** The list of TAG directives. */
1270+ struct {
1271+ /** The beginning of the list. */
1272+ yaml_tag_directive_t *start;
1273+ /** The end of the list. */
1274+ yaml_tag_directive_t *end;
1275+ /** The top of the list. */
1276+ yaml_tag_directive_t *top;
1277+ } tag_directives;
1278+
1279+ /**
1280+ * @}
1281+ */
1282+
1283+ /**
1284+ * @name Dumper stuff
1285+ * @{
1286+ */
1287+
1288+ /** The alias data. */
1289+ struct {
1290+ /** The beginning of the list. */
1291+ yaml_alias_data_t *start;
1292+ /** The end of the list. */
1293+ yaml_alias_data_t *end;
1294+ /** The top of the list. */
1295+ yaml_alias_data_t *top;
1296+ } aliases;
1297+
1298+ /** The currently parsed document. */
1299+ yaml_document_t *document;
1300+
1301+ /**
1302+ * @}
1303+ */
1304+
1305+} yaml_parser_t;
1306+
1307+/**
1308+ * Initialize a parser.
1309+ *
1310+ * This function creates a new parser object. An application is responsible
1311+ * for destroying the object using the yaml_parser_delete() function.
1312+ *
1313+ * @param[out] parser An empty parser object.
1314+ *
1315+ * @returns @c 1 if the function succeeded, @c 0 on error.
1316+ */
1317+
1318+YAML_DECLARE(int)
1319+yaml_parser_initialize(yaml_parser_t *parser);
1320+
1321+/**
1322+ * Destroy a parser.
1323+ *
1324+ * @param[in,out] parser A parser object.
1325+ */
1326+
1327+YAML_DECLARE(void)
1328+yaml_parser_delete(yaml_parser_t *parser);
1329+
1330+/**
1331+ * Set a string input.
1332+ *
1333+ * Note that the @a input pointer must be valid while the @a parser object
1334+ * exists. The application is responsible for destroing @a input after
1335+ * destroying the @a parser.
1336+ *
1337+ * @param[in,out] parser A parser object.
1338+ * @param[in] input A source data.
1339+ * @param[in] size The length of the source data in bytes.
1340+ */
1341+
1342+YAML_DECLARE(void)
1343+yaml_parser_set_input_string(yaml_parser_t *parser,
1344+ const unsigned char *input, size_t size);
1345+
1346+/**
1347+ * Set a file input.
1348+ *
1349+ * @a file should be a file object open for reading. The application is
1350+ * responsible for closing the @a file.
1351+ *
1352+ * @param[in,out] parser A parser object.
1353+ * @param[in] file An open file.
1354+ */
1355+
1356+YAML_DECLARE(void)
1357+yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file);
1358+
1359+/**
1360+ * Set a generic input handler.
1361+ *
1362+ * @param[in,out] parser A parser object.
1363+ * @param[in] handler A read handler.
1364+ * @param[in] data Any application data for passing to the read
1365+ * handler.
1366+ */
1367+
1368+YAML_DECLARE(void)
1369+yaml_parser_set_input(yaml_parser_t *parser,
1370+ yaml_read_handler_t *handler, void *data);
1371+
1372+/**
1373+ * Set the source encoding.
1374+ *
1375+ * @param[in,out] parser A parser object.
1376+ * @param[in] encoding The source encoding.
1377+ */
1378+
1379+YAML_DECLARE(void)
1380+yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding);
1381+
1382+/**
1383+ * Scan the input stream and produce the next token.
1384+ *
1385+ * Call the function subsequently to produce a sequence of tokens corresponding
1386+ * to the input stream. The initial token has the type
1387+ * @c YAML_STREAM_START_TOKEN while the ending token has the type
1388+ * @c YAML_STREAM_END_TOKEN.
1389+ *
1390+ * An application is responsible for freeing any buffers associated with the
1391+ * produced token object using the @c yaml_token_delete function.
1392+ *
1393+ * An application must not alternate the calls of yaml_parser_scan() with the
1394+ * calls of yaml_parser_parse() or yaml_parser_load(). Doing this will break
1395+ * the parser.
1396+ *
1397+ * @param[in,out] parser A parser object.
1398+ * @param[out] token An empty token object.
1399+ *
1400+ * @returns @c 1 if the function succeeded, @c 0 on error.
1401+ */
1402+
1403+YAML_DECLARE(int)
1404+yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);
1405+
1406+/**
1407+ * Parse the input stream and produce the next parsing event.
1408+ *
1409+ * Call the function subsequently to produce a sequence of events corresponding
1410+ * to the input stream. The initial event has the type
1411+ * @c YAML_STREAM_START_EVENT while the ending event has the type
1412+ * @c YAML_STREAM_END_EVENT.
1413+ *
1414+ * An application is responsible for freeing any buffers associated with the
1415+ * produced event object using the yaml_event_delete() function.
1416+ *
1417+ * An application must not alternate the calls of yaml_parser_parse() with the
1418+ * calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the
1419+ * parser.
1420+ *
1421+ * @param[in,out] parser A parser object.
1422+ * @param[out] event An empty event object.
1423+ *
1424+ * @returns @c 1 if the function succeeded, @c 0 on error.
1425+ */
1426+
1427+YAML_DECLARE(int)
1428+yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
1429+
1430+/**
1431+ * Parse the input stream and produce the next YAML document.
1432+ *
1433+ * Call this function subsequently to produce a sequence of documents
1434+ * constituting the input stream.
1435+ *
1436+ * If the produced document has no root node, it means that the document
1437+ * end has been reached.
1438+ *
1439+ * An application is responsible for freeing any data associated with the
1440+ * produced document object using the yaml_document_delete() function.
1441+ *
1442+ * An application must not alternate the calls of yaml_parser_load() with the
1443+ * calls of yaml_parser_scan() or yaml_parser_parse(). Doing this will break
1444+ * the parser.
1445+ *
1446+ * @param[in,out] parser A parser object.
1447+ * @param[out] document An empty document object.
1448+ *
1449+ * @return @c 1 if the function succeeded, @c 0 on error.
1450+ */
1451+
1452+YAML_DECLARE(int)
1453+yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
1454+
1455+/** @} */
1456+
1457+/**
1458+ * @defgroup emitter Emitter Definitions
1459+ * @{
1460+ */
1461+
1462+/**
1463+ * The prototype of a write handler.
1464+ *
1465+ * The write handler is called when the emitter needs to flush the accumulated
1466+ * characters to the output. The handler should write @a size bytes of the
1467+ * @a buffer to the output.
1468+ *
1469+ * @param[in,out] data A pointer to an application data specified by
1470+ * yaml_emitter_set_output().
1471+ * @param[in] buffer The buffer with bytes to be written.
1472+ * @param[in] size The size of the buffer.
1473+ *
1474+ * @returns On success, the handler should return @c 1. If the handler failed,
1475+ * the returned value should be @c 0.
1476+ */
1477+
1478+typedef int yaml_write_handler_t(void *data, unsigned char *buffer, size_t size);
1479+
1480+/** The emitter states. */
1481+typedef enum yaml_emitter_state_e {
1482+ /** Expect STREAM-START. */
1483+ YAML_EMIT_STREAM_START_STATE,
1484+ /** Expect the first DOCUMENT-START or STREAM-END. */
1485+ YAML_EMIT_FIRST_DOCUMENT_START_STATE,
1486+ /** Expect DOCUMENT-START or STREAM-END. */
1487+ YAML_EMIT_DOCUMENT_START_STATE,
1488+ /** Expect the content of a document. */
1489+ YAML_EMIT_DOCUMENT_CONTENT_STATE,
1490+ /** Expect DOCUMENT-END. */
1491+ YAML_EMIT_DOCUMENT_END_STATE,
1492+ /** Expect the first item of a flow sequence. */
1493+ YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE,
1494+ /** Expect an item of a flow sequence. */
1495+ YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE,
1496+ /** Expect the first key of a flow mapping. */
1497+ YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE,
1498+ /** Expect a key of a flow mapping. */
1499+ YAML_EMIT_FLOW_MAPPING_KEY_STATE,
1500+ /** Expect a value for a simple key of a flow mapping. */
1501+ YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE,
1502+ /** Expect a value of a flow mapping. */
1503+ YAML_EMIT_FLOW_MAPPING_VALUE_STATE,
1504+ /** Expect the first item of a block sequence. */
1505+ YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE,
1506+ /** Expect an item of a block sequence. */
1507+ YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE,
1508+ /** Expect the first key of a block mapping. */
1509+ YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE,
1510+ /** Expect the key of a block mapping. */
1511+ YAML_EMIT_BLOCK_MAPPING_KEY_STATE,
1512+ /** Expect a value for a simple key of a block mapping. */
1513+ YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE,
1514+ /** Expect a value of a block mapping. */
1515+ YAML_EMIT_BLOCK_MAPPING_VALUE_STATE,
1516+ /** Expect nothing. */
1517+ YAML_EMIT_END_STATE
1518+} yaml_emitter_state_t;
1519+
1520+/**
1521+ * The emitter structure.
1522+ *
1523+ * All members are internal. Manage the structure using the @c yaml_emitter_
1524+ * family of functions.
1525+ */
1526+
1527+typedef struct yaml_emitter_s {
1528+
1529+ /**
1530+ * @name Error handling
1531+ * @{
1532+ */
1533+
1534+ /** Error type. */
1535+ yaml_error_type_t error;
1536+ /** Error description. */
1537+ const char *problem;
1538+
1539+ /**
1540+ * @}
1541+ */
1542+
1543+ /**
1544+ * @name Writer stuff
1545+ * @{
1546+ */
1547+
1548+ /** Write handler. */
1549+ yaml_write_handler_t *write_handler;
1550+
1551+ /** A pointer for passing to the white handler. */
1552+ void *write_handler_data;
1553+
1554+ /** Standard (string or file) output data. */
1555+ union {
1556+ /** String output data. */
1557+ struct {
1558+ /** The buffer pointer. */
1559+ unsigned char *buffer;
1560+ /** The buffer size. */
1561+ size_t size;
1562+ /** The number of written bytes. */
1563+ size_t *size_written;
1564+ } string;
1565+
1566+ /** File output data. */
1567+ FILE *file;
1568+ } output;
1569+
1570+ /** The working buffer. */
1571+ struct {
1572+ /** The beginning of the buffer. */
1573+ yaml_char_t *start;
1574+ /** The end of the buffer. */
1575+ yaml_char_t *end;
1576+ /** The current position of the buffer. */
1577+ yaml_char_t *pointer;
1578+ /** The last filled position of the buffer. */
1579+ yaml_char_t *last;
1580+ } buffer;
1581+
1582+ /** The raw buffer. */
1583+ struct {
1584+ /** The beginning of the buffer. */
1585+ unsigned char *start;
1586+ /** The end of the buffer. */
1587+ unsigned char *end;
1588+ /** The current position of the buffer. */
1589+ unsigned char *pointer;
1590+ /** The last filled position of the buffer. */
1591+ unsigned char *last;
1592+ } raw_buffer;
1593+
1594+ /** The stream encoding. */
1595+ yaml_encoding_t encoding;
1596+
1597+ /**
1598+ * @}
1599+ */
1600+
1601+ /**
1602+ * @name Emitter stuff
1603+ * @{
1604+ */
1605+
1606+ /** If the output is in the canonical style? */
1607+ int canonical;
1608+ /** The number of indentation spaces. */
1609+ int best_indent;
1610+ /** The preferred width of the output lines. */
1611+ int best_width;
1612+ /** Allow unescaped non-ASCII characters? */
1613+ int unicode;
1614+ /** The preferred line break. */
1615+ yaml_break_t line_break;
1616+
1617+ /** The stack of states. */
1618+ struct {
1619+ /** The beginning of the stack. */
1620+ yaml_emitter_state_t *start;
1621+ /** The end of the stack. */
1622+ yaml_emitter_state_t *end;
1623+ /** The top of the stack. */
1624+ yaml_emitter_state_t *top;
1625+ } states;
1626+
1627+ /** The current emitter state. */
1628+ yaml_emitter_state_t state;
1629+
1630+ /** The event queue. */
1631+ struct {
1632+ /** The beginning of the event queue. */
1633+ yaml_event_t *start;
1634+ /** The end of the event queue. */
1635+ yaml_event_t *end;
1636+ /** The head of the event queue. */
1637+ yaml_event_t *head;
1638+ /** The tail of the event queue. */
1639+ yaml_event_t *tail;
1640+ } events;
1641+
1642+ /** The stack of indentation levels. */
1643+ struct {
1644+ /** The beginning of the stack. */
1645+ int *start;
1646+ /** The end of the stack. */
1647+ int *end;
1648+ /** The top of the stack. */
1649+ int *top;
1650+ } indents;
1651+
1652+ /** The list of tag directives. */
1653+ struct {
1654+ /** The beginning of the list. */
1655+ yaml_tag_directive_t *start;
1656+ /** The end of the list. */
1657+ yaml_tag_directive_t *end;
1658+ /** The top of the list. */
1659+ yaml_tag_directive_t *top;
1660+ } tag_directives;
1661+
1662+ /** The current indentation level. */
1663+ int indent;
1664+
1665+ /** The current flow level. */
1666+ int flow_level;
1667+
1668+ /** Is it the document root context? */
1669+ int root_context;
1670+ /** Is it a sequence context? */
1671+ int sequence_context;
1672+ /** Is it a mapping context? */
1673+ int mapping_context;
1674+ /** Is it a simple mapping key context? */
1675+ int simple_key_context;
1676+
1677+ /** The current line. */
1678+ int line;
1679+ /** The current column. */
1680+ int column;
1681+ /** If the last character was a whitespace? */
1682+ int whitespace;
1683+ /** If the last character was an indentation character (' ', '-', '?', ':')? */
1684+ int indention;
1685+ /** If an explicit document end is required? */
1686+ int open_ended;
1687+
1688+ /** Anchor analysis. */
1689+ struct {
1690+ /** The anchor value. */
1691+ yaml_char_t *anchor;
1692+ /** The anchor length. */
1693+ size_t anchor_length;
1694+ /** Is it an alias? */
1695+ int alias;
1696+ } anchor_data;
1697+
1698+ /** Tag analysis. */
1699+ struct {
1700+ /** The tag handle. */
1701+ yaml_char_t *handle;
1702+ /** The tag handle length. */
1703+ size_t handle_length;
1704+ /** The tag suffix. */
1705+ yaml_char_t *suffix;
1706+ /** The tag suffix length. */
1707+ size_t suffix_length;
1708+ } tag_data;
1709+
1710+ /** Scalar analysis. */
1711+ struct {
1712+ /** The scalar value. */
1713+ yaml_char_t *value;
1714+ /** The scalar length. */
1715+ size_t length;
1716+ /** Does the scalar contain line breaks? */
1717+ int multiline;
1718+ /** Can the scalar be expessed in the flow plain style? */
1719+ int flow_plain_allowed;
1720+ /** Can the scalar be expressed in the block plain style? */
1721+ int block_plain_allowed;
1722+ /** Can the scalar be expressed in the single quoted style? */
1723+ int single_quoted_allowed;
1724+ /** Can the scalar be expressed in the literal or folded styles? */
1725+ int block_allowed;
1726+ /** The output style. */
1727+ yaml_scalar_style_t style;
1728+ } scalar_data;
1729+
1730+ /**
1731+ * @}
1732+ */
1733+
1734+ /**
1735+ * @name Dumper stuff
1736+ * @{
1737+ */
1738+
1739+ /** If the stream was already opened? */
1740+ int opened;
1741+ /** If the stream was already closed? */
1742+ int closed;
1743+
1744+ /** The information associated with the document nodes. */
1745+ struct {
1746+ /** The number of references. */
1747+ int references;
1748+ /** The anchor id. */
1749+ int anchor;
1750+ /** If the node has been emitted? */
1751+ int serialized;
1752+ } *anchors;
1753+
1754+ /** The last assigned anchor id. */
1755+ int last_anchor_id;
1756+
1757+ /** The currently emitted document. */
1758+ yaml_document_t *document;
1759+
1760+ /**
1761+ * @}
1762+ */
1763+
1764+} yaml_emitter_t;
1765+
1766+/**
1767+ * Initialize an emitter.
1768+ *
1769+ * This function creates a new emitter object. An application is responsible
1770+ * for destroying the object using the yaml_emitter_delete() function.
1771+ *
1772+ * @param[out] emitter An empty parser object.
1773+ *
1774+ * @returns @c 1 if the function succeeded, @c 0 on error.
1775+ */
1776+
1777+YAML_DECLARE(int)
1778+yaml_emitter_initialize(yaml_emitter_t *emitter);
1779+
1780+/**
1781+ * Destroy an emitter.
1782+ *
1783+ * @param[in,out] emitter An emitter object.
1784+ */
1785+
1786+YAML_DECLARE(void)
1787+yaml_emitter_delete(yaml_emitter_t *emitter);
1788+
1789+/**
1790+ * Set a string output.
1791+ *
1792+ * The emitter will write the output characters to the @a output buffer of the
1793+ * size @a size. The emitter will set @a size_written to the number of written
1794+ * bytes. If the buffer is smaller than required, the emitter produces the
1795+ * YAML_WRITE_ERROR error.
1796+ *
1797+ * @param[in,out] emitter An emitter object.
1798+ * @param[in] output An output buffer.
1799+ * @param[in] size The buffer size.
1800+ * @param[in] size_written The pointer to save the number of written
1801+ * bytes.
1802+ */
1803+
1804+YAML_DECLARE(void)
1805+yaml_emitter_set_output_string(yaml_emitter_t *emitter,
1806+ unsigned char *output, size_t size, size_t *size_written);
1807+
1808+/**
1809+ * Set a file output.
1810+ *
1811+ * @a file should be a file object open for writing. The application is
1812+ * responsible for closing the @a file.
1813+ *
1814+ * @param[in,out] emitter An emitter object.
1815+ * @param[in] file An open file.
1816+ */
1817+
1818+YAML_DECLARE(void)
1819+yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file);
1820+
1821+/**
1822+ * Set a generic output handler.
1823+ *
1824+ * @param[in,out] emitter An emitter object.
1825+ * @param[in] handler A write handler.
1826+ * @param[in] data Any application data for passing to the write
1827+ * handler.
1828+ */
1829+
1830+YAML_DECLARE(void)
1831+yaml_emitter_set_output(yaml_emitter_t *emitter,
1832+ yaml_write_handler_t *handler, void *data);
1833+
1834+/**
1835+ * Set the output encoding.
1836+ *
1837+ * @param[in,out] emitter An emitter object.
1838+ * @param[in] encoding The output encoding.
1839+ */
1840+
1841+YAML_DECLARE(void)
1842+yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding);
1843+
1844+/**
1845+ * Set if the output should be in the "canonical" format as in the YAML
1846+ * specification.
1847+ *
1848+ * @param[in,out] emitter An emitter object.
1849+ * @param[in] canonical If the output is canonical.
1850+ */
1851+
1852+YAML_DECLARE(void)
1853+yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical);
1854+
1855+/**
1856+ * Set the intendation increment.
1857+ *
1858+ * @param[in,out] emitter An emitter object.
1859+ * @param[in] indent The indentation increment (1 < . < 10).
1860+ */
1861+
1862+YAML_DECLARE(void)
1863+yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent);
1864+
1865+/**
1866+ * Set the preferred line width. @c -1 means unlimited.
1867+ *
1868+ * @param[in,out] emitter An emitter object.
1869+ * @param[in] width The preferred line width.
1870+ */
1871+
1872+YAML_DECLARE(void)
1873+yaml_emitter_set_width(yaml_emitter_t *emitter, int width);
1874+
1875+/**
1876+ * Set if unescaped non-ASCII characters are allowed.
1877+ *
1878+ * @param[in,out] emitter An emitter object.
1879+ * @param[in] unicode If unescaped Unicode characters are allowed.
1880+ */
1881+
1882+YAML_DECLARE(void)
1883+yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode);
1884+
1885+/**
1886+ * Set the preferred line break.
1887+ *
1888+ * @param[in,out] emitter An emitter object.
1889+ * @param[in] line_break The preferred line break.
1890+ */
1891+
1892+YAML_DECLARE(void)
1893+yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break);
1894+
1895+/**
1896+ * Emit an event.
1897+ *
1898+ * The event object may be generated using the yaml_parser_parse() function.
1899+ * The emitter takes the responsibility for the event object and destroys its
1900+ * content after it is emitted. The event object is destroyed even if the
1901+ * function fails.
1902+ *
1903+ * @param[in,out] emitter An emitter object.
1904+ * @param[in,out] event An event object.
1905+ *
1906+ * @returns @c 1 if the function succeeded, @c 0 on error.
1907+ */
1908+
1909+YAML_DECLARE(int)
1910+yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
1911+
1912+/**
1913+ * Start a YAML stream.
1914+ *
1915+ * This function should be used before yaml_emitter_dump() is called.
1916+ *
1917+ * @param[in,out] emitter An emitter object.
1918+ *
1919+ * @returns @c 1 if the function succeeded, @c 0 on error.
1920+ */
1921+
1922+YAML_DECLARE(int)
1923+yaml_emitter_open(yaml_emitter_t *emitter);
1924+
1925+/**
1926+ * Finish a YAML stream.
1927+ *
1928+ * This function should be used after yaml_emitter_dump() is called.
1929+ *
1930+ * @param[in,out] emitter An emitter object.
1931+ *
1932+ * @returns @c 1 if the function succeeded, @c 0 on error.
1933+ */
1934+
1935+YAML_DECLARE(int)
1936+yaml_emitter_close(yaml_emitter_t *emitter);
1937+
1938+/**
1939+ * Emit a YAML document.
1940+ *
1941+ * The documen object may be generated using the yaml_parser_load() function
1942+ * or the yaml_document_initialize() function. The emitter takes the
1943+ * responsibility for the document object and destoys its content after
1944+ * it is emitted. The document object is destroyedeven if the function fails.
1945+ *
1946+ * @param[in,out] emitter An emitter object.
1947+ * @param[in,out] document A document object.
1948+ *
1949+ * @returns @c 1 if the function succeeded, @c 0 on error.
1950+ */
1951+
1952+YAML_DECLARE(int)
1953+yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
1954+
1955+/**
1956+ * Flush the accumulated characters to the output.
1957+ *
1958+ * @param[in,out] emitter An emitter object.
1959+ *
1960+ * @returns @c 1 if the function succeeded, @c 0 on error.
1961+ */
1962+
1963+YAML_DECLARE(int)
1964+yaml_emitter_flush(yaml_emitter_t *emitter);
1965+
1966+/** @} */
1967+
1968+#ifdef __cplusplus
1969+}
1970+#endif
1971+
1972+#endif /* #ifndef YAML_H */
1973+
libyaml/yaml_private.hnew file+644
@@ -0,0 +1,644 @@
1+
2+#if HAVE_CONFIG_H
3+#include <config.h>
4+#endif
5+
6+#include <yaml.h>
7+
8+#include <assert.h>
9+#include <limits.h>
10+
11+/*
12+ * Memory management.
13+ */
14+
15+YAML_DECLARE(void *)
16+yaml_malloc(size_t size);
17+
18+YAML_DECLARE(void *)
19+yaml_realloc(void *ptr, size_t size);
20+
21+YAML_DECLARE(void)
22+yaml_free(void *ptr);
23+
24+YAML_DECLARE(yaml_char_t *)
25+yaml_strdup(const yaml_char_t *);
26+
27+/*
28+ * Reader: Ensure that the buffer contains at least `length` characters.
29+ */
30+
31+YAML_DECLARE(int)
32+yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
33+
34+/*
35+ * Scanner: Ensure that the token stack contains at least one token ready.
36+ */
37+
38+YAML_DECLARE(int)
39+yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
40+
41+/*
42+ * The size of the input raw buffer.
43+ */
44+
45+#define INPUT_RAW_BUFFER_SIZE 16384
46+
47+/*
48+ * The size of the input buffer.
49+ *
50+ * It should be possible to decode the whole raw buffer.
51+ */
52+
53+#define INPUT_BUFFER_SIZE (INPUT_RAW_BUFFER_SIZE*3)
54+
55+/*
56+ * The size of the output buffer.
57+ */
58+
59+#define OUTPUT_BUFFER_SIZE 16384
60+
61+/*
62+ * The size of the output raw buffer.
63+ *
64+ * It should be possible to encode the whole output buffer.
65+ */
66+
67+#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2)
68+
69+/*
70+ * The size of other stacks and queues.
71+ */
72+
73+#define INITIAL_STACK_SIZE 16
74+#define INITIAL_QUEUE_SIZE 16
75+#define INITIAL_STRING_SIZE 16
76+
77+/*
78+ * Buffer management.
79+ */
80+
81+#define BUFFER_INIT(context,buffer,size) \
82+ (((buffer).start = yaml_malloc(size)) ? \
83+ ((buffer).last = (buffer).pointer = (buffer).start, \
84+ (buffer).end = (buffer).start+(size), \
85+ 1) : \
86+ ((context)->error = YAML_MEMORY_ERROR, \
87+ 0))
88+
89+#define BUFFER_DEL(context,buffer) \
90+ (yaml_free((buffer).start), \
91+ (buffer).start = (buffer).pointer = (buffer).end = 0)
92+
93+/*
94+ * String management.
95+ */
96+
97+typedef struct {
98+ yaml_char_t *start;
99+ yaml_char_t *end;
100+ yaml_char_t *pointer;
101+} yaml_string_t;
102+
103+YAML_DECLARE(int)
104+yaml_string_extend(yaml_char_t **start,
105+ yaml_char_t **pointer, yaml_char_t **end);
106+
107+YAML_DECLARE(int)
108+yaml_string_join(
109+ yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
110+ yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end);
111+
112+#define NULL_STRING { NULL, NULL, NULL }
113+
114+#define STRING(string,length) { (string), (string)+(length), (string) }
115+
116+#define STRING_ASSIGN(value,string,length) \
117+ ((value).start = (string), \
118+ (value).end = (string)+(length), \
119+ (value).pointer = (string))
120+
121+#define STRING_INIT(context,string,size) \
122+ (((string).start = yaml_malloc(size)) ? \
123+ ((string).pointer = (string).start, \
124+ (string).end = (string).start+(size), \
125+ memset((string).start, 0, (size)), \
126+ 1) : \
127+ ((context)->error = YAML_MEMORY_ERROR, \
128+ 0))
129+
130+#define STRING_DEL(context,string) \
131+ (yaml_free((string).start), \
132+ (string).start = (string).pointer = (string).end = 0)
133+
134+#define STRING_EXTEND(context,string) \
135+ (((string).pointer+5 < (string).end) \
136+ || yaml_string_extend(&(string).start, \
137+ &(string).pointer, &(string).end))
138+
139+#define CLEAR(context,string) \
140+ ((string).pointer = (string).start, \
141+ memset((string).start, 0, (string).end-(string).start))
142+
143+#define JOIN(context,string_a,string_b) \
144+ ((yaml_string_join(&(string_a).start, &(string_a).pointer, \
145+ &(string_a).end, &(string_b).start, \
146+ &(string_b).pointer, &(string_b).end)) ? \
147+ ((string_b).pointer = (string_b).start, \
148+ 1) : \
149+ ((context)->error = YAML_MEMORY_ERROR, \
150+ 0))
151+
152+/*
153+ * String check operations.
154+ */
155+
156+/*
157+ * Check the octet at the specified position.
158+ */
159+
160+#define CHECK_AT(string,octet,offset) \
161+ ((string).pointer[offset] == (yaml_char_t)(octet))
162+
163+/*
164+ * Check the current octet in the buffer.
165+ */
166+
167+#define CHECK(string,octet) CHECK_AT((string),(octet),0)
168+
169+/*
170+ * Check if the character at the specified position is an alphabetical
171+ * character, a digit, '_', or '-'.
172+ */
173+
174+#define IS_ALPHA_AT(string,offset) \
175+ (((string).pointer[offset] >= (yaml_char_t) '0' && \
176+ (string).pointer[offset] <= (yaml_char_t) '9') || \
177+ ((string).pointer[offset] >= (yaml_char_t) 'A' && \
178+ (string).pointer[offset] <= (yaml_char_t) 'Z') || \
179+ ((string).pointer[offset] >= (yaml_char_t) 'a' && \
180+ (string).pointer[offset] <= (yaml_char_t) 'z') || \
181+ (string).pointer[offset] == '_' || \
182+ (string).pointer[offset] == '-')
183+
184+#define IS_ALPHA(string) IS_ALPHA_AT((string),0)
185+
186+/*
187+ * Check if the character at the specified position is a digit.
188+ */
189+
190+#define IS_DIGIT_AT(string,offset) \
191+ (((string).pointer[offset] >= (yaml_char_t) '0' && \
192+ (string).pointer[offset] <= (yaml_char_t) '9'))
193+
194+#define IS_DIGIT(string) IS_DIGIT_AT((string),0)
195+
196+/*
197+ * Get the value of a digit.
198+ */
199+
200+#define AS_DIGIT_AT(string,offset) \
201+ ((string).pointer[offset] - (yaml_char_t) '0')
202+
203+#define AS_DIGIT(string) AS_DIGIT_AT((string),0)
204+
205+/*
206+ * Check if the character at the specified position is a hex-digit.
207+ */
208+
209+#define IS_HEX_AT(string,offset) \
210+ (((string).pointer[offset] >= (yaml_char_t) '0' && \
211+ (string).pointer[offset] <= (yaml_char_t) '9') || \
212+ ((string).pointer[offset] >= (yaml_char_t) 'A' && \
213+ (string).pointer[offset] <= (yaml_char_t) 'F') || \
214+ ((string).pointer[offset] >= (yaml_char_t) 'a' && \
215+ (string).pointer[offset] <= (yaml_char_t) 'f'))
216+
217+#define IS_HEX(string) IS_HEX_AT((string),0)
218+
219+/*
220+ * Get the value of a hex-digit.
221+ */
222+
223+#define AS_HEX_AT(string,offset) \
224+ (((string).pointer[offset] >= (yaml_char_t) 'A' && \
225+ (string).pointer[offset] <= (yaml_char_t) 'F') ? \
226+ ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \
227+ ((string).pointer[offset] >= (yaml_char_t) 'a' && \
228+ (string).pointer[offset] <= (yaml_char_t) 'f') ? \
229+ ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \
230+ ((string).pointer[offset] - (yaml_char_t) '0'))
231+
232+#define AS_HEX(string) AS_HEX_AT((string),0)
233+
234+/*
235+ * Check if the character is ASCII.
236+ */
237+
238+#define IS_ASCII_AT(string,offset) \
239+ ((string).pointer[offset] <= (yaml_char_t) '\x7F')
240+
241+#define IS_ASCII(string) IS_ASCII_AT((string),0)
242+
243+/*
244+ * Check if the character can be printed unescaped.
245+ */
246+
247+#define IS_PRINTABLE_AT(string,offset) \
248+ (((string).pointer[offset] == 0x0A) /* . == #x0A */ \
249+ || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \
250+ && (string).pointer[offset] <= 0x7E) \
251+ || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \
252+ && (string).pointer[offset+1] >= 0xA0) \
253+ || ((string).pointer[offset] > 0xC2 \
254+ && (string).pointer[offset] < 0xED) \
255+ || ((string).pointer[offset] == 0xED \
256+ && (string).pointer[offset+1] < 0xA0) \
257+ || ((string).pointer[offset] == 0xEE) \
258+ || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \
259+ && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \
260+ && (string).pointer[offset+2] == 0xBF) \
261+ && !((string).pointer[offset+1] == 0xBF \
262+ && ((string).pointer[offset+2] == 0xBE \
263+ || (string).pointer[offset+2] == 0xBF))))
264+
265+#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0)
266+
267+/*
268+ * Check if the character at the specified position is NUL.
269+ */
270+
271+#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset))
272+
273+#define IS_Z(string) IS_Z_AT((string),0)
274+
275+/*
276+ * Check if the character at the specified position is BOM.
277+ */
278+
279+#define IS_BOM_AT(string,offset) \
280+ (CHECK_AT((string),'\xEF',(offset)) \
281+ && CHECK_AT((string),'\xBB',(offset)+1) \
282+ && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */
283+
284+#define IS_BOM(string) IS_BOM_AT(string,0)
285+
286+/*
287+ * Check if the character at the specified position is space.
288+ */
289+
290+#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset))
291+
292+#define IS_SPACE(string) IS_SPACE_AT((string),0)
293+
294+/*
295+ * Check if the character at the specified position is tab.
296+ */
297+
298+#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset))
299+
300+#define IS_TAB(string) IS_TAB_AT((string),0)
301+
302+/*
303+ * Check if the character at the specified position is blank (space or tab).
304+ */
305+
306+#define IS_BLANK_AT(string,offset) \
307+ (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset)))
308+
309+#define IS_BLANK(string) IS_BLANK_AT((string),0)
310+
311+/*
312+ * Check if the character at the specified position is a line break.
313+ */
314+
315+#define IS_BREAK_AT(string,offset) \
316+ (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \
317+ || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \
318+ || (CHECK_AT((string),'\xC2',(offset)) \
319+ && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \
320+ || (CHECK_AT((string),'\xE2',(offset)) \
321+ && CHECK_AT((string),'\x80',(offset)+1) \
322+ && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \
323+ || (CHECK_AT((string),'\xE2',(offset)) \
324+ && CHECK_AT((string),'\x80',(offset)+1) \
325+ && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */
326+
327+#define IS_BREAK(string) IS_BREAK_AT((string),0)
328+
329+#define IS_CRLF_AT(string,offset) \
330+ (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1))
331+
332+#define IS_CRLF(string) IS_CRLF_AT((string),0)
333+
334+/*
335+ * Check if the character is a line break or NUL.
336+ */
337+
338+#define IS_BREAKZ_AT(string,offset) \
339+ (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset)))
340+
341+#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0)
342+
343+/*
344+ * Check if the character is a line break, space, or NUL.
345+ */
346+
347+#define IS_SPACEZ_AT(string,offset) \
348+ (IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset)))
349+
350+#define IS_SPACEZ(string) IS_SPACEZ_AT((string),0)
351+
352+/*
353+ * Check if the character is a line break, space, tab, or NUL.
354+ */
355+
356+#define IS_BLANKZ_AT(string,offset) \
357+ (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset)))
358+
359+#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0)
360+
361+/*
362+ * Determine the width of the character.
363+ */
364+
365+#define WIDTH_AT(string,offset) \
366+ (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \
367+ ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \
368+ ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \
369+ ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0)
370+
371+#define WIDTH(string) WIDTH_AT((string),0)
372+
373+/*
374+ * Move the string pointer to the next character.
375+ */
376+
377+#define MOVE(string) ((string).pointer += WIDTH((string)))
378+
379+/*
380+ * Copy a character and move the pointers of both strings.
381+ */
382+
383+#define COPY(string_a,string_b) \
384+ ((*(string_b).pointer & 0x80) == 0x00 ? \
385+ (*((string_a).pointer++) = *((string_b).pointer++)) : \
386+ (*(string_b).pointer & 0xE0) == 0xC0 ? \
387+ (*((string_a).pointer++) = *((string_b).pointer++), \
388+ *((string_a).pointer++) = *((string_b).pointer++)) : \
389+ (*(string_b).pointer & 0xF0) == 0xE0 ? \
390+ (*((string_a).pointer++) = *((string_b).pointer++), \
391+ *((string_a).pointer++) = *((string_b).pointer++), \
392+ *((string_a).pointer++) = *((string_b).pointer++)) : \
393+ (*(string_b).pointer & 0xF8) == 0xF0 ? \
394+ (*((string_a).pointer++) = *((string_b).pointer++), \
395+ *((string_a).pointer++) = *((string_b).pointer++), \
396+ *((string_a).pointer++) = *((string_b).pointer++), \
397+ *((string_a).pointer++) = *((string_b).pointer++)) : 0)
398+
399+/*
400+ * Stack and queue management.
401+ */
402+
403+YAML_DECLARE(int)
404+yaml_stack_extend(void **start, void **top, void **end);
405+
406+YAML_DECLARE(int)
407+yaml_queue_extend(void **start, void **head, void **tail, void **end);
408+
409+#define STACK_INIT(context,stack,size) \
410+ (((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ? \
411+ ((stack).top = (stack).start, \
412+ (stack).end = (stack).start+(size), \
413+ 1) : \
414+ ((context)->error = YAML_MEMORY_ERROR, \
415+ 0))
416+
417+#define STACK_DEL(context,stack) \
418+ (yaml_free((stack).start), \
419+ (stack).start = (stack).top = (stack).end = 0)
420+
421+#define STACK_EMPTY(context,stack) \
422+ ((stack).start == (stack).top)
423+
424+#define PUSH(context,stack,value) \
425+ (((stack).top != (stack).end \
426+ || yaml_stack_extend((void **)&(stack).start, \
427+ (void **)&(stack).top, (void **)&(stack).end)) ? \
428+ (*((stack).top++) = value, \
429+ 1) : \
430+ ((context)->error = YAML_MEMORY_ERROR, \
431+ 0))
432+
433+#define POP(context,stack) \
434+ (*(--(stack).top))
435+
436+#define QUEUE_INIT(context,queue,size) \
437+ (((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ? \
438+ ((queue).head = (queue).tail = (queue).start, \
439+ (queue).end = (queue).start+(size), \
440+ 1) : \
441+ ((context)->error = YAML_MEMORY_ERROR, \
442+ 0))
443+
444+#define QUEUE_DEL(context,queue) \
445+ (yaml_free((queue).start), \
446+ (queue).start = (queue).head = (queue).tail = (queue).end = 0)
447+
448+#define QUEUE_EMPTY(context,queue) \
449+ ((queue).head == (queue).tail)
450+
451+#define ENQUEUE(context,queue,value) \
452+ (((queue).tail != (queue).end \
453+ || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \
454+ (void **)&(queue).tail, (void **)&(queue).end)) ? \
455+ (*((queue).tail++) = value, \
456+ 1) : \
457+ ((context)->error = YAML_MEMORY_ERROR, \
458+ 0))
459+
460+#define DEQUEUE(context,queue) \
461+ (*((queue).head++))
462+
463+#define QUEUE_INSERT(context,queue,index,value) \
464+ (((queue).tail != (queue).end \
465+ || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \
466+ (void **)&(queue).tail, (void **)&(queue).end)) ? \
467+ (memmove((queue).head+(index)+1,(queue).head+(index), \
468+ ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \
469+ *((queue).head+(index)) = value, \
470+ (queue).tail++, \
471+ 1) : \
472+ ((context)->error = YAML_MEMORY_ERROR, \
473+ 0))
474+
475+/*
476+ * Token initializers.
477+ */
478+
479+#define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark) \
480+ (memset(&(token), 0, sizeof(yaml_token_t)), \
481+ (token).type = (token_type), \
482+ (token).start_mark = (token_start_mark), \
483+ (token).end_mark = (token_end_mark))
484+
485+#define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark) \
486+ (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)), \
487+ (token).data.stream_start.encoding = (token_encoding))
488+
489+#define STREAM_END_TOKEN_INIT(token,start_mark,end_mark) \
490+ (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark)))
491+
492+#define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark) \
493+ (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)), \
494+ (token).data.alias.value = (token_value))
495+
496+#define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark) \
497+ (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)), \
498+ (token).data.anchor.value = (token_value))
499+
500+#define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark) \
501+ (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)), \
502+ (token).data.tag.handle = (token_handle), \
503+ (token).data.tag.suffix = (token_suffix))
504+
505+#define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark) \
506+ (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \
507+ (token).data.scalar.value = (token_value), \
508+ (token).data.scalar.length = (token_length), \
509+ (token).data.scalar.style = (token_style))
510+
511+#define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark) \
512+ (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \
513+ (token).data.version_directive.major = (token_major), \
514+ (token).data.version_directive.minor = (token_minor))
515+
516+#define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark) \
517+ (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \
518+ (token).data.tag_directive.handle = (token_handle), \
519+ (token).data.tag_directive.prefix = (token_prefix))
520+
521+/*
522+ * Event initializers.
523+ */
524+
525+#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark) \
526+ (memset(&(event), 0, sizeof(yaml_event_t)), \
527+ (event).type = (event_type), \
528+ (event).start_mark = (event_start_mark), \
529+ (event).end_mark = (event_end_mark))
530+
531+#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark) \
532+ (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \
533+ (event).data.stream_start.encoding = (event_encoding))
534+
535+#define STREAM_END_EVENT_INIT(event,start_mark,end_mark) \
536+ (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark)))
537+
538+#define DOCUMENT_START_EVENT_INIT(event,event_version_directive, \
539+ event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \
540+ (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \
541+ (event).data.document_start.version_directive = (event_version_directive), \
542+ (event).data.document_start.tag_directives.start = (event_tag_directives_start), \
543+ (event).data.document_start.tag_directives.end = (event_tag_directives_end), \
544+ (event).data.document_start.implicit = (event_implicit))
545+
546+#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark) \
547+ (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \
548+ (event).data.document_end.implicit = (event_implicit))
549+
550+#define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark) \
551+ (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \
552+ (event).data.alias.anchor = (event_anchor))
553+
554+#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length, \
555+ event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark) \
556+ (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \
557+ (event).data.scalar.anchor = (event_anchor), \
558+ (event).data.scalar.tag = (event_tag), \
559+ (event).data.scalar.value = (event_value), \
560+ (event).data.scalar.length = (event_length), \
561+ (event).data.scalar.plain_implicit = (event_plain_implicit), \
562+ (event).data.scalar.quoted_implicit = (event_quoted_implicit), \
563+ (event).data.scalar.style = (event_style))
564+
565+#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \
566+ event_implicit,event_style,start_mark,end_mark) \
567+ (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \
568+ (event).data.sequence_start.anchor = (event_anchor), \
569+ (event).data.sequence_start.tag = (event_tag), \
570+ (event).data.sequence_start.implicit = (event_implicit), \
571+ (event).data.sequence_start.style = (event_style))
572+
573+#define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark) \
574+ (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark)))
575+
576+#define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag, \
577+ event_implicit,event_style,start_mark,end_mark) \
578+ (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \
579+ (event).data.mapping_start.anchor = (event_anchor), \
580+ (event).data.mapping_start.tag = (event_tag), \
581+ (event).data.mapping_start.implicit = (event_implicit), \
582+ (event).data.mapping_start.style = (event_style))
583+
584+#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \
585+ (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark)))
586+
587+/*
588+ * Document initializer.
589+ */
590+
591+#define DOCUMENT_INIT(document,document_nodes_start,document_nodes_end, \
592+ document_version_directive,document_tag_directives_start, \
593+ document_tag_directives_end,document_start_implicit, \
594+ document_end_implicit,document_start_mark,document_end_mark) \
595+ (memset(&(document), 0, sizeof(yaml_document_t)), \
596+ (document).nodes.start = (document_nodes_start), \
597+ (document).nodes.end = (document_nodes_end), \
598+ (document).nodes.top = (document_nodes_start), \
599+ (document).version_directive = (document_version_directive), \
600+ (document).tag_directives.start = (document_tag_directives_start), \
601+ (document).tag_directives.end = (document_tag_directives_end), \
602+ (document).start_implicit = (document_start_implicit), \
603+ (document).end_implicit = (document_end_implicit), \
604+ (document).start_mark = (document_start_mark), \
605+ (document).end_mark = (document_end_mark))
606+
607+/*
608+ * Node initializers.
609+ */
610+
611+#define NODE_INIT(node,node_type,node_tag,node_start_mark,node_end_mark) \
612+ (memset(&(node), 0, sizeof(yaml_node_t)), \
613+ (node).type = (node_type), \
614+ (node).tag = (node_tag), \
615+ (node).start_mark = (node_start_mark), \
616+ (node).end_mark = (node_end_mark))
617+
618+#define SCALAR_NODE_INIT(node,node_tag,node_value,node_length, \
619+ node_style,start_mark,end_mark) \
620+ (NODE_INIT((node),YAML_SCALAR_NODE,(node_tag),(start_mark),(end_mark)), \
621+ (node).data.scalar.value = (node_value), \
622+ (node).data.scalar.length = (node_length), \
623+ (node).data.scalar.style = (node_style))
624+
625+#define SEQUENCE_NODE_INIT(node,node_tag,node_items_start,node_items_end, \
626+ node_style,start_mark,end_mark) \
627+ (NODE_INIT((node),YAML_SEQUENCE_NODE,(node_tag),(start_mark),(end_mark)), \
628+ (node).data.sequence.items.start = (node_items_start), \
629+ (node).data.sequence.items.end = (node_items_end), \
630+ (node).data.sequence.items.top = (node_items_start), \
631+ (node).data.sequence.style = (node_style))
632+
633+#define MAPPING_NODE_INIT(node,node_tag,node_pairs_start,node_pairs_end, \
634+ node_style,start_mark,end_mark) \
635+ (NODE_INIT((node),YAML_MAPPING_NODE,(node_tag),(start_mark),(end_mark)), \
636+ (node).data.mapping.pairs.start = (node_pairs_start), \
637+ (node).data.mapping.pairs.end = (node_pairs_end), \
638+ (node).data.mapping.pairs.top = (node_pairs_start), \
639+ (node).data.mapping.style = (node_style))
640+
641+#define YAML_VERSION_STRING "0.1.4"
642+#define YAML_VERSION_MAJOR 0
643+#define YAML_VERSION_MINOR 1
644+#define YAML_VERSION_PATCH 4
stack.yamldeleted−12
@@ -1,12 +0,0 @@
1−resolver: lts-22.13
2−
3−flags:
4− yaml:
5− no-examples: false
6−
7−packages:
8− - yaml
9− - libyaml
10−
11−extra-deps:
12− - libyaml-clib-0.2.5
yaml/test/json.yaml → test/json.yamlrenamed

The content is the same.

yaml/test/largest-string.yaml → test/largest-string.yamlrenamed

The content is the same.

test/main.hsnew file+429
@@ -0,0 +1,429 @@
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE PackageImports #-}
3+{-# LANGUAGE ScopedTypeVariables #-}
4+{-# LANGUAGE OverloadedStrings #-}
5+{-# LANGUAGE TemplateHaskell #-}
6+
7+import qualified Text.Libyaml as Y
8+import qualified Data.ByteString.Char8 as B8
9+
10+import Test.HUnit hiding (Test, path)
11+
12+import qualified Data.Conduit as C
13+import qualified Data.Conduit.List as CL
14+
15+import System.Directory
16+import Control.Monad
17+import Control.Exception (try, SomeException)
18+import Test.Hspec
19+
20+import qualified Data.Yaml as D
21+import Data.Yaml (object, array, (.=))
22+import Data.Maybe
23+import qualified Data.HashMap.Strict as M
24+import qualified Data.Text as T
25+import Data.Aeson.TH
26+import Data.Text (Text)
27+import Data.Vector (Vector)
28+import qualified Data.Vector as V
29+import Data.HashMap.Strict (HashMap)
30+import qualified Data.HashMap.Strict as HM
31+
32+data TestJSON = TestJSON
33+ { string :: Text
34+ , number :: Int
35+ , anArray :: Vector Text
36+ , hash :: HashMap Text Text
37+ , extrastring :: Text
38+ } deriving (Show, Eq)
39+
40+deriveJSON defaultOptions ''TestJSON
41+
42+main :: IO ()
43+main = hspec $ do
44+ describe "streaming" $ do
45+ it "count scalars with anchor" caseCountScalarsWithAnchor
46+ it "count sequences with anchor" caseCountSequencesWithAnchor
47+ it "count mappings with anchor" caseCountMappingsWithAnchor
48+ it "count aliases" caseCountAliases
49+ it "count scalars" caseCountScalars
50+ it "largest string" caseLargestString
51+ it "encode/decode" caseEncodeDecode
52+ it "encode/decode file" caseEncodeDecodeFile
53+ it "interleaved encode/decode" caseInterleave
54+ it "decode invalid document (without segfault)" caseDecodeInvalidDocument
55+ describe "Data.Yaml" $ do
56+ it "encode/decode" caseEncodeDecodeData
57+ it "encode/decode file" caseEncodeDecodeFileData
58+ it "encode/decode strings" caseEncodeDecodeStrings
59+ it "decode invalid file" caseDecodeInvalid
60+ it "processes datatypes" caseDataTypes
61+ describe "Data.Yaml aliases" $ do
62+ it "simple scalar alias" caseSimpleScalarAlias
63+ it "simple sequence alias" caseSimpleSequenceAlias
64+ it "simple mapping alias" caseSimpleMappingAlias
65+ it "mapping alias before anchor" caseMappingAliasBeforeAnchor
66+ it "mapping alias inside anchor" caseMappingAliasInsideAnchor
67+ it "scalar alias overriding" caseScalarAliasOverriding
68+ describe "Data.Yaml merge keys" $ do
69+ it "test uniqueness of keys" caseAllKeysShouldBeUnique
70+ it "test mapping merge" caseSimpleMappingMerge
71+ it "test sequence of mappings merging" caseMergeSequence
72+ describe "numbers" $ do
73+ it "parses as string when quoted" caseQuotedNumber
74+ it "parses as number when unquoted" caseUnquotedNumber
75+ it "parses as number !!str is present" caseAttribNumber
76+ describe "booleans" $ do
77+ it "parses when all lowercase" caseLowercaseBool
78+ it "parses when all uppercase" caseUppercaseBool
79+ it "parses when titlecase" caseTitlecaseBool
80+ describe "empty input" $ do
81+ it "doesn't crash" caseEmptyInput
82+ describe "alias stripping" $ do
83+ it "works" caseStripAlias
84+ describe "nulls" $ do
85+ checkNull "null"
86+ checkNull "Null"
87+ checkNull "NULL"
88+ checkNull "~"
89+ checkNull ""
90+
91+ describe "pretty output" $ do
92+ it "simple nulls" $ D.encode (object ["foo" .= D.Null]) `shouldBe` "foo: null\n"
93+ it "simple numbers" $ D.encode (object ["foo" .= (4 :: Int)]) `shouldBe`
94+#if MIN_VERSION_aeson(0, 7, 0)
95+ "foo: 4.0\n" -- FIXME should this be reported as a bug upstream to aeson?
96+#else
97+ "foo: 4\n"
98+#endif
99+ it "True" $ D.encode (object ["foo" .= True]) `shouldBe` "foo: true\n"
100+ it "False" $ D.encode (object ["foo" .= False]) `shouldBe` "foo: false\n"
101+ it "simple string" $ D.encode (object ["foo" .= ("bar" :: T.Text)]) `shouldBe` "foo: bar\n"
102+
103+ describe "special keys" $ do
104+ let tester key = it (T.unpack key) $
105+ let value = object [key .= True]
106+ in D.decode (D.encode value) `shouldBe` Just value
107+ mapM_ tester specialStrings
108+
109+ describe "special values" $ do
110+ let tester value = it (T.unpack value) $
111+ let value' = object ["foo" .= value]
112+ in D.decode (D.encode value') `shouldBe` Just value'
113+ mapM_ tester specialStrings
114+
115+ describe "yamlFileJSONparse" $
116+ it "loads YAML through JSON into Haskell data" $ do
117+ tj <- either (error . show) id `fmap` D.decodeFileEither "test/json.yaml"
118+ tj `shouldBe` TestJSON
119+ { string = "str"
120+ , number = 2
121+ , anArray = V.fromList ["a", "b"]
122+ , hash = HM.fromList [("key1", "value1"), ("key2", "value2")]
123+ , extrastring = "1234-foo"
124+ }
125+
126+ describe "round-tripping of special scalars" $ do
127+ let special = words "y Y On ON false 12345 12345.0 12345a 12e3"
128+ forM_ special $ \w -> it w $
129+ let v = object ["word" .= w]
130+ in D.decode (D.encode v) `shouldBe` Just v
131+ it "no tags" $ D.encode (object ["word" .= ("true" :: String)]) `shouldBe` "word: 'true'\n"
132+
133+
134+specialStrings :: [T.Text]
135+specialStrings =
136+ [ "fo\"o"
137+ , "fo\'o"
138+ , "fo\\'o"
139+ , "fo: o"
140+ , "foo\nbar\nbaz\n"
141+ ]
142+
143+counter :: Monad m => (Y.Event -> Bool) -> C.Sink Y.Event m Int
144+counter pred' =
145+ CL.fold (\cnt e -> (if pred' e then 1 else 0) + cnt) 0
146+
147+caseHelper :: String
148+ -> (Y.Event -> Bool)
149+ -> Int
150+ -> Assertion
151+caseHelper yamlString pred' expRes = do
152+ res <- C.runResourceT $ Y.decode (B8.pack yamlString) C.$$ counter pred'
153+ res @?= expRes
154+
155+caseCountScalarsWithAnchor :: Assertion
156+caseCountScalarsWithAnchor =
157+ caseHelper yamlString isScalarA 1
158+ where
159+ yamlString = "foo:\n - &anchor bin1\n - bin2\n - bin3"
160+ isScalarA (Y.EventScalar _ _ _ (Just _)) = True
161+ isScalarA _ = False
162+
163+caseCountSequencesWithAnchor :: Assertion
164+caseCountSequencesWithAnchor =
165+ caseHelper yamlString isSequenceStartA 1
166+ where
167+ yamlString = "foo: &anchor\n - bin1\n - bin2\n - bin3"
168+ isSequenceStartA (Y.EventSequenceStart (Just _)) = True
169+ isSequenceStartA _ = False
170+
171+caseCountMappingsWithAnchor :: Assertion
172+caseCountMappingsWithAnchor =
173+ caseHelper yamlString isMappingA 1
174+ where
175+ yamlString = "foo: &anchor\n key1: bin1\n key2: bin2\n key3: bin3"
176+ isMappingA (Y.EventMappingStart (Just _)) = True
177+ isMappingA _ = False
178+
179+caseCountAliases :: Assertion
180+caseCountAliases =
181+ caseHelper yamlString isAlias 1
182+ where
183+ yamlString = "foo: &anchor\n key1: bin1\n key2: bin2\n key3: bin3\nboo: *anchor"
184+ isAlias Y.EventAlias{} = True
185+ isAlias _ = False
186+
187+caseCountScalars :: Assertion
188+caseCountScalars = do
189+ res <- C.runResourceT $ Y.decode yamlBS C.$$ CL.fold adder accum
190+ res @?= (7, 1, 2)
191+ where
192+ yamlString = "foo:\n baz: [bin1, bin2, bin3]\nbaz: bazval"
193+ yamlBS = B8.pack yamlString
194+ adder (s, l, m) (Y.EventScalar{}) = (s + 1, l, m)
195+ adder (s, l, m) (Y.EventSequenceStart{}) = (s, l + 1, m)
196+ adder (s, l, m) (Y.EventMappingStart{}) = (s, l, m + 1)
197+ adder a _ = a
198+ accum = (0, 0, 0) :: (Int, Int, Int)
199+
200+caseLargestString :: Assertion
201+caseLargestString = do
202+ res <- C.runResourceT $ Y.decodeFile filePath C.$$ CL.fold adder accum
203+ res @?= (length expected, expected)
204+ where
205+ expected = "this one is just a little bit bigger than the others"
206+ filePath = "test/largest-string.yaml"
207+ adder (i, s) (Y.EventScalar bs _ _ _) =
208+ let s' = B8.unpack bs
209+ i' = length s'
210+ in if i' > i then (i', s') else (i, s)
211+ adder acc _ = acc
212+ accum = (0, "no strings found")
213+
214+newtype MyEvent = MyEvent Y.Event deriving Show
215+instance Eq MyEvent where
216+ (MyEvent (Y.EventScalar s t _ _)) == (MyEvent (Y.EventScalar s' t' _ _)) =
217+ s == s' && t == t'
218+ MyEvent e1 == MyEvent e2 = e1 == e2
219+
220+caseEncodeDecode :: Assertion
221+caseEncodeDecode = do
222+ eList <- C.runResourceT $ Y.decode yamlBS C.$$ CL.consume
223+ bs <- C.runResourceT $ CL.sourceList eList C.$$ Y.encode
224+ eList2 <- C.runResourceT $ Y.decode bs C.$$ CL.consume
225+ map MyEvent eList @=? map MyEvent eList2
226+ where
227+ yamlString = "foo: bar\nbaz:\n - bin1\n - bin2\n"
228+ yamlBS = B8.pack yamlString
229+
230+removeFile' :: FilePath -> IO ()
231+removeFile' fp = do
232+ x <- doesFileExist fp
233+ when x $ removeFile fp
234+
235+caseEncodeDecodeFile :: Assertion
236+caseEncodeDecodeFile = do
237+ removeFile' tmpPath
238+ eList <- C.runResourceT $ Y.decodeFile filePath C.$$ CL.consume
239+ C.runResourceT $ CL.sourceList eList C.$$ Y.encodeFile tmpPath
240+ eList2 <- C.runResourceT $ Y.decodeFile filePath C.$$ CL.consume
241+ map MyEvent eList @=? map MyEvent eList2
242+ where
243+ filePath = "test/largest-string.yaml"
244+ tmpPath = "tmp.yaml"
245+
246+caseInterleave :: Assertion
247+caseInterleave = do
248+ removeFile' tmpPath
249+ removeFile' tmpPath2
250+ () <- C.runResourceT $ Y.decodeFile filePath C.$$ Y.encodeFile tmpPath
251+ () <- C.runResourceT $ Y.decodeFile tmpPath C.$$ Y.encodeFile tmpPath2
252+ f1 <- readFile tmpPath
253+ f2 <- readFile tmpPath2
254+ f1 @=? f2
255+ where
256+ filePath = "test/largest-string.yaml"
257+ tmpPath = "tmp.yaml"
258+ tmpPath2 = "tmp2.yaml"
259+
260+caseDecodeInvalidDocument :: Assertion
261+caseDecodeInvalidDocument = do
262+ x <- try $ C.runResourceT $ Y.decode yamlBS C.$$ CL.sinkNull
263+ case x of
264+ Left (_ :: SomeException) -> return ()
265+ Right y -> do
266+ putStrLn $ "bad return value: " ++ show y
267+ assertFailure "expected parsing exception, but got no errors"
268+ where
269+ yamlString = " - foo\n - baz\nbuz"
270+ yamlBS = B8.pack yamlString
271+
272+mkScalar :: String -> D.Value
273+mkScalar = mkStrScalar
274+
275+mkStrScalar :: String -> D.Value
276+mkStrScalar = D.String . T.pack
277+
278+mappingKey :: D.Value-> String -> D.Value
279+mappingKey (D.Object m) k = (fromJust . M.lookup (T.pack k) $ m)
280+mappingKey _ _ = error "expected Object"
281+
282+decodeYaml :: String -> Maybe D.Value
283+decodeYaml s = D.decode $ B8.pack s
284+
285+sample :: D.Value
286+sample = array
287+ [ D.String "foo"
288+ , object
289+ [ ("bar1", D.String "bar2")
290+ , ("bar3", D.String "")
291+ ]
292+ , D.String ""
293+ ]
294+
295+caseEncodeDecodeData :: Assertion
296+caseEncodeDecodeData = do
297+ let out = D.decode $ D.encode sample
298+ out @?= Just sample
299+
300+caseEncodeDecodeFileData :: Assertion
301+caseEncodeDecodeFileData = do
302+ let fp = "tmp.yaml"
303+ D.encodeFile fp sample
304+ out <- D.decodeFile fp
305+ out @?= Just sample
306+
307+caseEncodeDecodeStrings :: Assertion
308+caseEncodeDecodeStrings = do
309+ let out = D.decode $ D.encode sample
310+ out @?= Just sample
311+
312+caseDecodeInvalid :: Assertion
313+caseDecodeInvalid = do
314+ let invalid = B8.pack "\tthis is 'not' valid :-)"
315+ Nothing @=? (D.decode invalid :: Maybe D.Value)
316+
317+caseSimpleScalarAlias :: Assertion
318+caseSimpleScalarAlias = do
319+ let maybeRes = decodeYaml "- &anch foo\n- baz\n- *anch"
320+ isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing"
321+ let res = fromJust maybeRes
322+ res @?= array [(mkScalar "foo"), (mkScalar "baz"), (mkScalar "foo")]
323+
324+caseSimpleSequenceAlias :: Assertion
325+caseSimpleSequenceAlias = do
326+ let maybeRes = decodeYaml "seq: &anch\n - foo\n - baz\nseq2: *anch"
327+ isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing"
328+ let res = fromJust maybeRes
329+ res @?= object [("seq", array [(mkScalar "foo"), (mkScalar "baz")]), ("seq2", array [(mkScalar "foo"), (mkScalar "baz")])]
330+
331+caseSimpleMappingAlias :: Assertion
332+caseSimpleMappingAlias = do
333+ let maybeRes = decodeYaml "map: &anch\n key1: foo\n key2: baz\nmap2: *anch"
334+ isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing"
335+ let res = fromJust maybeRes
336+ res @?= object [(T.pack "map", object [("key1", mkScalar "foo"), ("key2", (mkScalar "baz"))]), (T.pack "map2", object [("key1", (mkScalar "foo")), ("key2", mkScalar "baz")])]
337+
338+caseMappingAliasBeforeAnchor :: Assertion
339+caseMappingAliasBeforeAnchor = do
340+ let res = decodeYaml "map: *anch\nmap2: &anch\n key1: foo\n key2: baz"
341+ isNothing res @? "decode should return Nothing due to unknown alias"
342+
343+caseMappingAliasInsideAnchor :: Assertion
344+caseMappingAliasInsideAnchor = do
345+ let res = decodeYaml "map: &anch\n key1: foo\n key2: *anch"
346+ isNothing res @? "decode should return Nothing due to unknown alias"
347+
348+caseScalarAliasOverriding :: Assertion
349+caseScalarAliasOverriding = do
350+ let maybeRes = decodeYaml "- &anch foo\n- baz\n- *anch\n- &anch boo\n- buz\n- *anch"
351+ isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing"
352+ let res = fromJust maybeRes
353+ res @?= array [(mkScalar "foo"), (mkScalar "baz"), (mkScalar "foo"), (mkScalar "boo"), (mkScalar "buz"), (mkScalar "boo")]
354+
355+caseAllKeysShouldBeUnique :: Assertion
356+caseAllKeysShouldBeUnique = do
357+ let maybeRes = decodeYaml "foo1: foo\nfoo2: baz\nfoo1: buz"
358+ isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing"
359+ let res = fromJust maybeRes
360+ mappingKey res "foo1" @?= (mkScalar "buz")
361+
362+caseSimpleMappingMerge :: Assertion
363+caseSimpleMappingMerge = do
364+ let maybeRes = decodeYaml "foo1: foo\nfoo2: baz\n<<:\n foo1: buz\n foo3: fuz"
365+ isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing"
366+ let res = fromJust maybeRes
367+ mappingKey res "foo1" @?= (mkScalar "foo")
368+ mappingKey res "foo3" @?= (mkScalar "fuz")
369+
370+caseMergeSequence :: Assertion
371+caseMergeSequence = do
372+ let maybeRes = decodeYaml "m1: &m1\n k1: !!str 1\n k2: !!str 2\nm2: &m2\n k1: !!str 3\n k3: !!str 4\nfoo1: foo\n<<: [ *m1, *m2 ]"
373+ isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing"
374+ let res = fromJust maybeRes
375+ mappingKey res "foo1" @?= (mkScalar "foo")
376+ mappingKey res "k1" @?= (D.String "1")
377+ mappingKey res "k2" @?= (D.String "2")
378+ mappingKey res "k3" @?= (D.String "4")
379+
380+caseDataTypes :: Assertion
381+caseDataTypes =
382+ D.decode (D.encode val) @?= Just val
383+ where
384+ val = object
385+ [ ("string", D.String "foo")
386+ , ("int", D.Number 5)
387+ , ("float", D.Number 4.3)
388+ , ("true", D.Bool True)
389+ , ("false", D.Bool False)
390+ , ("null", D.Null)
391+ ]
392+
393+caseQuotedNumber, caseUnquotedNumber, caseAttribNumber :: Assertion
394+caseQuotedNumber = D.decode "foo: \"1234\"" @?= Just (object [("foo", D.String "1234")])
395+caseUnquotedNumber = D.decode "foo: 1234" @?= Just (object [("foo", D.Number 1234)])
396+caseAttribNumber = D.decode "foo: !!str 1234" @?= Just (object [("foo", D.String "1234")])
397+
398+obj :: Maybe D.Value
399+obj = Just (object [("foo", D.Bool False), ("bar", D.Bool True), ("baz", D.Bool True)])
400+
401+caseLowercaseBool, caseUppercaseBool, caseTitlecaseBool :: Assertion
402+caseLowercaseBool = D.decode "foo: off\nbar: y\nbaz: true" @?= obj
403+caseUppercaseBool = D.decode "foo: FALSE\nbar: Y\nbaz: ON" @?= obj
404+caseTitlecaseBool = D.decode "foo: No\nbar: Yes\nbaz: True" @?= obj
405+
406+caseEmptyInput :: Assertion
407+caseEmptyInput = D.decode B8.empty @?= (Nothing :: Maybe D.Value)
408+
409+checkNull :: T.Text -> Spec
410+checkNull x =
411+ it ("null recognized: " ++ show x) assertion
412+ where
413+ assertion = Just (object [("foo", D.Null)]) @=? D.decode (B8.pack $ "foo: " ++ T.unpack x)
414+
415+caseStripAlias :: Assertion
416+caseStripAlias =
417+ D.decode src @?= Just (object
418+ [ "Default" .= object
419+ [ "foo" .= (1 :: Int)
420+ , "bar" .= (2 :: Int)
421+ ]
422+ , "Obj" .= object
423+ [ "foo" .= (1 :: Int)
424+ , "bar" .= (2 :: Int)
425+ , "key" .= (3 :: Int)
426+ ]
427+ ])
428+ where
429+ src = "Default: &def\n foo: 1\n bar: 2\nObj:\n <<: *def\n key: 3\n"
yaml.cabalnew file+106
@@ -0,0 +1,106 @@
1+name: yaml
2+version: 0.8.6.2
3+license: BSD3
4+license-file: LICENSE
5+author: Michael Snoyman <michael@snoyman.com>, Anton Ageev <antage@gmail.com>,Kirill Simonov
6+maintainer: Michael Snoyman <michael@snoyman.com>
7+synopsis: Support for parsing and rendering YAML documents.
8+description: Provides support for parsing and emitting Yaml documents.
9+ .
10+ This package includes the full libyaml C library version 0.1.2 by Kirill
11+ Simonov (<http://pyyaml.org/wiki/LibYAML>) in the package so you
12+ don't need to worry about any non-Haskell dependencies.
13+ .
14+ The package is broken down into two modules.
15+ "Data.Yaml" provides a high-level interface based
16+ around the JSON datatypes provided by the @aeson@
17+ package. "Text.Libyaml" provides a lower-level,
18+ streaming interface. For most users, "Data.Yaml" is recommended.
19+category: Web
20+stability: stable
21+cabal-version: >= 1.8
22+build-type: Simple
23+homepage: http://github.com/snoyberg/yaml/
24+extra-source-files: c/helper.h,
25+ libyaml/yaml_private.h,
26+ libyaml/yaml.h,
27+ libyaml/LICENSE
28+ test/main.hs
29+ test/largest-string.yaml
30+ test/json.yaml
31+
32+flag no-exe
33+ description: don't install the yaml2json executable
34+ default: False
35+
36+flag system-libyaml
37+ description: Use the system-wide libyaml instead of the bundled copy
38+ default: False
39+
40+library
41+ build-depends: base >= 4 && < 5
42+ , transformers >= 0.1 && < 0.4
43+ , bytestring >= 0.9.1.4
44+ , conduit >= 0.5 && < 1.1
45+ , resourcet >= 0.3 && < 0.5
46+ , aeson >= 0.5
47+ , containers
48+ , unordered-containers
49+ , vector
50+ , text
51+ , attoparsec
52+ , scientific
53+ exposed-modules: Text.Libyaml
54+ Data.Yaml
55+ ghc-options: -Wall
56+ c-sources: c/helper.c
57+ include-dirs: c
58+ if flag(system-libyaml)
59+ pkgconfig-depends: yaml-0.1
60+ else
61+ c-sources: libyaml/api.c,
62+ libyaml/dumper.c,
63+ libyaml/emitter.c,
64+ libyaml/loader.c,
65+ libyaml/parser.c,
66+ libyaml/reader.c,
67+ libyaml/scanner.c,
68+ libyaml/writer.c
69+ include-dirs: libyaml
70+
71+executable yaml2json
72+ if flag(no-exe)
73+ Buildable: False
74+ else
75+ Buildable: True
76+
77+ hs-source-dirs: exe
78+ main-is: yaml2json.hs
79+ build-depends: base >= 4 && < 5
80+ , yaml
81+ , bytestring >= 0.9.1.4
82+ , aeson >= 0.5
83+
84+
85+test-suite test
86+ type: exitcode-stdio-1.0
87+ hs-source-dirs: test
88+ main-is: main.hs
89+ cpp-options: -DTEST
90+ build-depends: hspec >= 1.3
91+ , HUnit
92+ , directory
93+ , base >= 4 && < 5
94+ , transformers >= 0.1 && < 0.4
95+ , bytestring >= 0.9.1.4
96+ , conduit
97+ , yaml
98+ , text
99+ , aeson
100+ , unordered-containers
101+ , vector
102+ ghc-options: -Wall
103+
104+source-repository head
105+ type: git
106+ location: https://github.com/snoyberg/yaml
yaml/ChangeLog.mddeleted−303
@@ -1,303 +0,0 @@
1−# ChangeLog for yaml
2−
3−## 0.11.11.2
4−
5−* Compat with aeson 2.2
6−
7−## 0.11.11.1
8−
9−* For optparse-applicative-0.18: use `pretty` instead of `text` [#216](https://github.com/snoyberg/yaml/pull/216)
10−
11−## 0.11.11.0
12−
13−* Fix ambiguous occurrence `AesonException`
14−
15−## 0.11.10.0
16−
17−* Undo previous change (breakage with aeson 2)
18−
19−## 0.11.9.0
20−
21−* Data.Yaml.Pretty: provide key-sorting function with path to parent object [#206](https://github.com/snoyberg/yaml/pull/206)
22−
23−## 0.11.8.0
24−
25−* Export `Parse` and `StringStyle` [#204](https://github.com/snoyberg/yaml/pull/204)
26−
27−## 0.11.7.0
28−
29−* Support `aeson` 2 [#202](https://github.com/snoyberg/yaml/pull/202)
30−
31−## 0.11.6.0
32−
33−* `yaml2json`: add `--help` and `--version` options [#197](https://github.com/snoyberg/yaml/pull/197)
34−* `json2yaml`: add `--help` and `--version` options [#198](https://github.com/snoyberg/yaml/pull/198)
35−* Add the `-o` options to both `yaml2json` and `json2yaml` [#200](https://github.com/snoyberg/yaml/pull/200)
36−
37−## 0.11.5.0
38−
39−* New functions capable of parsing YAML streams containing multiple documents into a list of results:
40− * `decodeAllEither'`
41− * `decodeAllFileEither`
42− * `decodeAllFileWithWarnings`
43− * `decodeAllThrow`
44− * `decodeAllFileThrow`
45−
46−## 0.11.4.0
47−
48−* add `ToYaml` instance for `String` [#186](https://github.com/snoyberg/yaml/pull/186)
49−
50−## 0.11.3.0
51−
52−* Don't wrap up async exceptions [#185](https://github.com/snoyberg/yaml/issues/185)
53−
54−## 0.11.2.0
55−
56−* Reduces some of the code duplication between the `encode` and `encodePretty` functions
57−* The output of `encodePretty` has been improved:
58− - Multiline strings now use `Literal` style instead of `SingleQuoted`
59− - Special keys are now quoted in mappings [#179](https://github.com/snoyberg/yaml/issues/179)
60−* Support for complex keys in mappings: [#182](https://github.com/snoyberg/yaml/issues/182)
61− - Adds `complexMapping` function to `Data.Yaml.Builder`
62− - Decode functions now return a `NonStringKey` error when attempting to decode a mapping with a complex key as it is not possible to decode these to an Aeson `Value`
63−* Adds missing `ToYaml` instances
64−
65−## 0.11.1.2
66−
67−* Compiles with GHC 8.8.1 (`MonadFail` split)
68−
69−## 0.11.1.1
70−
71−* Use the appropriate `Scientific` rendering function to avoid a memory overflow when rendering. The previously used function from `aeson` would not use scientific notation, and could use large amounts of memory for values such as `1e9999999999999`.
72−
73−## 0.11.1.0
74−
75−* Better error messages in the `Data.Yaml.Config` module [#168](https://github.com/snoyberg/yaml/issues/168)
76−* Add `LoadSettingsException` exception and remove error printing from `loadYamlSettings` [#172](https://github.com/snoyberg/yaml/pull/172)
77−
78−## 0.11.0.0
79−
80−* Split out the `libyaml` and `Text.Libyaml` code into its own package. [#145](https://github.com/snoyberg/yaml/issues/145)
81−
82−## 0.10.4.0
83−
84−* Add `decodeMarked` and `decodeFileMarked` functions to `Text.Libyaml`, and
85− extend native bindings to extract mark information. [#157](https://github.com/snoyberg/yaml/issues/157)
86−
87−## 0.10.3.0
88−
89−* Add support for anchors and aliases to Data.Yaml.Builder [#155](https://github.com/snoyberg/yaml/pull/155)
90−* Fix test suite for 32 bit machines [#158](https://github.com/snoyberg/yaml/issues/158)
91−
92−## 0.10.2.0
93−
94−* Add `EncodeOptions` and `FormatOptions` to control the style of the encoded YAML. [#153](https://github.com/snoyberg/yaml/pull/153)
95−* Default to using literal style for multiline strings [#152](https://github.com/snoyberg/yaml/issues/152)
96−
97−## 0.10.1.1
98−
99−* Correctly declare libyaml dependency on system-libyaml flag [#151](https://github.com/snoyberg/yaml/pull/151)
100−
101−## 0.10.1
102−
103−* Avoid incurring a `semigroups` dependency on recent GHCs.
104−* Fix a space leak that was introduced with `0.10.0` [#147](https://github.com/snoyberg/yaml/issues/147)
105−
106−## 0.10.0
107−
108−* Add `decodeFileWithWarnings` which returns warnings for duplicate fields
109−
110−## 0.9.0
111−
112−* Expose style and tags on mappings and sequences in Text.Libyaml [#141](https://github.com/snoyberg/yaml/pull/141)
113−
114−## 0.8.32
115−
116−* Escape keys as necessary [#137](https://github.com/snoyberg/yaml/issues/137)
117−* Support hexadecimal and octal number values [#135](https://github.com/snoyberg/yaml/issues/135)
118−* More resilient `isNumeric` (should reduce cases of unneeded quoting)
119−* hpackify
120−* src subdir
121−
122−## 0.8.31.1
123−
124−* Add a workaround for a cabal bug [haskell-infra/hackage-trustees#165](https://github.com/haskell-infra/hackage-trustees/issues/165)
125−
126−## 0.8.31
127−
128−* Add `decodeThrow` and `decodeFileThrow` convenience functions.
129−* Upgrade libyaml versions
130−* Deprecate `decode` and `decodeEither`
131−
132−## 0.8.30
133−
134−* Removed `AppSettings` mentioned in `loadYamlSettings` error message.
135−
136−## 0.8.29
137−
138−* Deprecated `decodeFile` [#129](https://github.com/snoyberg/yaml/issues/129)
139−* Turn off executables by default [#103](https://github.com/snoyberg/yaml/issues/103)
140−
141−## 0.8.28
142−
143−* Add `Data.Yaml.TH.yamlQQ`
144−
145−## 0.8.27
146−
147−* Support conduit 1.3
148−
149−## 0.8.26
150−
151−* Add `Semigroup` instance [#123](https://github.com/snoyberg/yaml/pull/123)
152−
153−## 0.8.25.2
154−
155−* Use `throwM` instead of `monadThrow`
156−
157−## 0.8.25.1
158−
159−* Drop aeson-qq dep (incompatible with Stackage Nightly)
160−
161−## 0.8.25
162−
163−* Tweaks to the executable `yaml2json` [#119](https://github.com/snoyberg/yaml/pull/119):
164− - Add command-line option `-h` and `--help` to show help message
165− - Error messages are now written to `stderr` instead of `stdout`
166−
167−## 0.8.24
168−
169−* New encodePretty option `setConfDropNull` to drop null values from objects [#116](https://github.com/snoyberg/yaml/issues/116)
170−
171−## 0.8.23.3
172−
173−* Avoid over-escaping `*` [#113](https://github.com/snoyberg/yaml/issues/113)
174−
175−## 0.8.23.2
176−
177−* Update libyaml [#110](https://github.com/snoyberg/yaml/issues/110)
178−
179−## 0.8.23.1
180−
181−* Update CPP `MIN_VERSION_*` checks [#109](https://github.com/snoyberg/yaml/pull/109)
182−
183−## 0.8.23
184−
185−* Re-export the with helpers from aeson
186−
187−## 0.8.22.1
188−
189−* Make numeric string detection slightly smarter so, e.g., `.` does
190− not get quoted
191−
192−## 0.8.22
193−
194−* Update to libyaml hosted on Github [#105](https://github.com/snoyberg/yaml/issues/105)
195−
196−## 0.8.21.2
197−
198−* Fix wrong file not found exception in `Data.Yaml.Include` with pre-1.2.3.0 `directory` [#104](https://github.com/snoyberg/yaml/pull/104)
199−
200−## 0.8.21.1
201−
202−* Add missing test files [#102](https://github.com/snoyberg/yaml/pull/102)
203−
204−## 0.8.21
205−
206−* Decode empty inputs as Null [#101](https://github.com/snoyberg/yaml/pull/101)
207−
208−## 0.8.20
209−
210−* Upgrade to libyaml 0.1.7
211−
212−## 0.8.19.0
213−
214−* Add `Data.Yaml.TH` module
215−
216−## 0.8.18.7
217−
218−* Add `O_TRUNC` when opening files
219−
220−## 0.8.18.6
221−
222−* s/fdopen/_fdopen on Windows [#96](https://github.com/snoyberg/yaml/issues/96)
223−
224−## 0.8.18.5
225−
226−* Properly fix previous bug (fixes #94)
227−
228−## 0.8.18.4
229−
230−* Remove file with non-ASCII name due to Stack/cabal-install/Hackage
231− restrictions (see [#92](https://github.com/snoyberg/yaml/issues/92))
232−
233−## 0.8.18.2
234−
235−* Handle non-ASCII filenames correctly on Windows [#91](https://github.com/snoyberg/yaml/pull/91)
236−
237−## 0.8.18.1
238−
239−* Improve prettyPrintParseException when context is empty [#89](https://github.com/snoyberg/yaml/pull/89)
240−
241−## 0.8.18
242−
243−* Switched yaml decode function for config file readers in `Data.Yaml.Config` to
244− the one from `Data.Yaml.Include` that supports `!include` syntax.
245−
246−## 0.8.17.2
247−
248−* Fix pretty-printing order of UnexpectedEvent's fields (fixes [#84](https://github.com/snoyberg/yaml/issues/84)) [#85](https://github.com/snoyberg/yaml/pull/85)
249−
250−## 0.8.17.1
251−
252−* Avoid bug in Cabal [#83](https://github.com/snoyberg/yaml/pull/83)
253−
254−## 0.8.17
255−
256−* `loadYamlSettingsArgs`
257−
258−## 0.8.16.1
259−
260−* Slight doc improvement
261−
262−## 0.8.16
263−
264−Add env variable parsing. `loadYamlSettings` can read config values from the environment with Yaml that specifies an env var.
265−The syntax is
266−
267−`var: _env:ENV_VAR:default`
268−
269−## 0.8.15.3
270−
271−* Give a warning when compiling with GHCJS
272−
273−## 0.8.15.2
274−
275−* Canonicalise Monad instances [#76](https://github.com/snoyberg/yaml/pull/76)
276−
277−## 0.8.15.1
278−
279−* Compile with aeson below 0.7 [#70](https://github.com/snoyberg/yaml/pull/70)
280−
281−## 0.8.15
282−
283−* Parse `Scientific` directly, avoiding loss in precision. [#68](https://github.com/snoyberg/yaml/pull/68)
284−
285−## 0.8.14
286−
287−* Pretty print improvements for exceptions [#67](https://github.com/snoyberg/yaml/pull/67)
288−
289−## 0.8.13
290−
291−* Pretty module [#66](https://github.com/snoyberg/yaml/pull/66)
292−
293−## 0.8.12
294−
295−* Proper handling of `String "+123"` [#64](https://github.com/snoyberg/yaml/issues/64)
296−
297−## 0.8.11
298−
299−* Function to print prettier parse exceptions [#59](https://github.com/snoyberg/yaml/pull/59)
300−
301−## 0.8.10
302−
303−Add the Data.Yaml.Include module
yaml/README.mddeleted−26
@@ -1,26 +0,0 @@
1−## yaml
2−
3−[![GitHub build and test status](https://github.com/snoyberg/yaml/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/snoyberg/yaml/actions/workflows/tests.yml)
4−[![Appveyor build status](https://ci.appveyor.com/api/projects/status/hqy2jketp8m502so/branch/master?svg=true)](https://ci.appveyor.com/project/snoyberg/yaml/branch/master)
5−
6−Provides support for parsing and emitting Yaml documents.
7−
8−`Data.Yaml` provides a high-level interface based around the JSON datatypes provided by the `aeson` package. It uses `Text.Libyaml` from `libyaml` in its implementation of the low-level yaml encoder/decoder.
9−
10−### Examples
11−
12−Usage examples can be found in the `Data.Yaml` documentation or in the [examples](https://github.com/snoyberg/yaml/tree/master/yaml/examples) directory.
13−
14−### Additional `yaml` modules
15−
16−* `Data.Yaml.Include` supports adding `!include` directives to your YAML files.
17−* `Data.Yaml.Builder` and `Data.Yaml.Parser` allow more fine-grained control of parsing an rendering, as opposed to just using the aeson typeclass and datatype system for parsing and rendering.
18−* `Data.Yaml.Aeson` is currently a re-export of `Data.Yaml` to explicitly choose to use the aeson-compatible API.
19−
20−### Executables
21−
22−Converters `json2yaml` and `yaml2json` can be built by disabling flag `no-exe`, e.g., one of:
23−```
24−cabal install yaml -f-no-exe
25−stack install yaml --flag yaml:-no-exe
26−```
yaml/examples/Config.hsdeleted−55
@@ -1,55 +0,0 @@
1−{-# LANGUAGE OverloadedStrings #-}
2−{-# LANGUAGE QuasiQuotes #-}
3−
4−module Config where
5−
6−import Data.Text (Text)
7−import qualified Data.Yaml as Y
8−import Data.Yaml (FromJSON(..), (.:))
9−import Text.RawString.QQ
10−import Data.ByteString (ByteString)
11−import Control.Applicative
12−import Prelude -- Ensure Applicative is in scope and we have no warnings, before/after AMP.
13−
14−configYaml :: ByteString
15−configYaml = [r|
16−resolver: lts-3.7
17−packages:
18− - ./yesod-core
19− - ./yesod-static
20− - ./yesod-persistent
21− - ./yesod-newsfeed
22− - ./yesod-form
23− - ./yesod-auth
24− - ./yesod-auth-oauth
25− - ./yesod-sitemap
26− - ./yesod-test
27− - ./yesod-bin
28− - ./yesod
29− - ./yesod-eventsource
30− - ./yesod-websockets
31−
32−# Needed for LTS 2
33−extra-deps:
34−- wai-app-static-3.1.4.1
35−|]
36−
37−data Config =
38− Config {
39− resolver :: Text
40− , packages :: [FilePath]
41− , extraDeps :: [Text]
42− } deriving (Eq, Show)
43−
44−instance FromJSON Config where
45− parseJSON (Y.Object v) =
46− Config <$>
47− v .: "resolver" <*>
48− v .: "packages" <*>
49− v .: "extra-deps"
50− parseJSON _ = fail "Expected Object for Config value"
51−
52−main :: IO ()
53−main = do
54− config <- Y.decodeThrow configYaml
55− print (config :: Config)
yaml/examples/Main.hsdeleted−10
@@ -1,10 +0,0 @@
1−module Main where
2−
3−import qualified Config
4−import qualified Simple
5−
6−main :: IO ()
7−main = do
8− Simple.main
9− Config.main
10−
yaml/examples/Simple.hsdeleted−14
@@ -1,14 +0,0 @@
1−{-# LANGUAGE OverloadedStrings #-}
2−
3−module Simple where
4−
5−import qualified Data.Yaml as Y
6−
7−main :: IO ()
8−main = do
9− res <- Y.decodeThrow "[1,2,3]"
10− print (res :: [Integer])
11−
12−-- You can go one step further and decode into a custom type by implementing
13−-- 'FromJSON' for that type. This is also appropriate where extra
14−-- normalization, formatting or manipulation of the YAML is required on decode.
yaml/exe/Common.hsdeleted−68
@@ -1,68 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE LambdaCase #-}
3−
4−-- | Code shared between @yaml2json@ and @json2yaml@.
5−
6−module Common where
7−
8−import Data.List ( intercalate )
9−#if !MIN_VERSION_base(4,11,0)
10−import Data.Semigroup ( Semigroup(..) )
11−#endif
12−import Data.Version ( Version(versionBranch) )
13−
14−import Options.Applicative ( Parser, help, hidden, infoOption, long, short )
15−
16−import qualified Paths_yaml as Paths
17−
18−-- * Version info and option
19−---------------------------------------------------------------------------
20−
21−-- | Homepage for @yaml2json@ and @json2yaml@.
22−
23−homepage :: String
24−homepage = "https://github.com/snoyberg/yaml/"
25−
26−-- | Version in @x.y.z@ format.
27−
28−version :: String
29−version = intercalate "." $ map show $ versionBranch Paths.version
30−
31−-- | The version header including given program name and 'homepage'.
32−
33−versionText :: String -> String
34−versionText self = unwords
35− [ self
36− , "version"
37− , version
38− , homepage -- concat [ "<", homepage, ">" ]
39− ]
40−
41−-- | Option @--numeric-version@.
42−
43−numericVersionOption :: Parser (a -> a)
44−numericVersionOption =
45− infoOption version
46− $ long "numeric-version"
47− <> hidden
48− <> help "Show just version number."
49−
50−-- | Option @--version@.
51−
52−versionOption :: String -> Parser (a -> a)
53−versionOption self =
54− infoOption (versionText self)
55− $ long "version"
56− <> short 'V'
57− <> hidden
58− <> help "Show version info."
59−
60−-- * Misc
61−---------------------------------------------------------------------------
62−
63−-- | @Just@ unless argument is @"-"@ (denoting @stdin@ or @stdout@).
64−
65−dashToNothing :: FilePath -> Maybe FilePath
66−dashToNothing = \case
67− "-" -> Nothing
68− file -> Just file
yaml/exe/json2yaml.hsdeleted−106
@@ -1,106 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE NamedFieldPuns #-}
3−
4−import qualified Data.Aeson as J
5−import qualified Data.ByteString as S
6−import qualified Data.ByteString.Lazy as L
7−import qualified Data.Yaml as Y
8−#if !MIN_VERSION_base(4,11,0)
9−import Data.Semigroup ( Semigroup(..) )
10−#endif
11−
12−import Options.Applicative
13− ( Parser, (<|>)
14− , action, execParser, footerDoc, headerDoc, help, helper, hidden, info
15− , long, metavar, short, strArgument, strOption, value
16− )
17−import Options.Applicative.Help.Pretty
18− ( vcat, pretty )
19−
20−import System.Exit ( die )
21−
22−import Common ( dashToNothing, versionText, versionOption, numericVersionOption )
23−
24−data Options = Options
25− { optInput :: Maybe FilePath
26− -- ^ 'Nothing' means @stdin@.
27− , optOutput :: Maybe FilePath
28− -- ^ 'Nothing' means @stdout@.
29− }
30−
31−-- | Name of the executable.
32−
33−self :: String
34−self = "json2yaml"
35−
36−-- | Parse options; handle parse errors, @--help@, @--version@.
37−
38−options :: IO Options
39−options =
40− execParser $
41− info (helper <*> versionOption self <*> numericVersionOption <*> programOptions)
42− $ headerDoc hdoc
43− <> footerDoc fdoc
44−
45− where
46− hdoc = Just $ vcat $ map pretty
47− [ versionText self
48− , "Convert JSON to YAML."
49− ]
50− fdoc = Just $ pretty $ concat
51− [ "The old call pattern '"
52− , self
53− , " IN OUT' is also accepted, but deprecated."
54− ]
55−
56− programOptions :: Parser Options
57− programOptions = Options <$> oInput <*> oOutput
58−
59− oInput :: Parser (Maybe FilePath)
60− oInput = dashToNothing <$> do
61− strArgument
62− $ metavar "IN"
63− <> value "-"
64− <> action "file"
65− <> help "The input file containing the JSON document; use '-' for stdin (default)."
66−
67− oOutput :: Parser (Maybe FilePath)
68− oOutput = dashToNothing <$> do
69− oOutputExplicit <|> oOutputImplicit
70−
71− oOutputExplicit :: Parser FilePath
72− oOutputExplicit =
73− strOption
74− $ long "output"
75− <> short 'o'
76− <> metavar "OUT"
77− <> action "file"
78− -- <> help "The file to hold the produced YAML document; use '-' for stdout (default)."
79−
80− oOutputImplicit :: Parser FilePath
81− oOutputImplicit =
82− strArgument
83− $ metavar "OUT"
84− <> value "-"
85− <> action "file"
86− <> hidden
87− <> help "The file to hold the produced YAML document; use '-' for stdout (default)."
88−
89−-- | Exit with 'self'-stamped error message.
90−
91−abort :: String -> IO a
92−abort msg = die $ concat [ self, ": ", msg ]
93−
94−main :: IO ()
95−main = do
96− Options{ optInput, optOutput } <- options
97−
98− -- Read JSON.
99− mval <- J.decode <$> maybe L.getContents L.readFile optInput
100−
101− -- Write YAML.
102− case mval of
103− Nothing -> abort "Invalid input JSON"
104− Just val -> case optOutput of
105− Nothing -> S.putStr $ Y.encode (val :: Y.Value)
106− Just f -> Y.encodeFile f val
yaml/exe/yaml2json.hsdeleted−87
@@ -1,87 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE LambdaCase #-}
3−{-# LANGUAGE NamedFieldPuns #-}
4−
5−import Data.Aeson (encode, Value)
6−import qualified Data.ByteString as S (getContents)
7−import qualified Data.ByteString.Lazy as L (putStr, writeFile)
8−#if !MIN_VERSION_base(4,11,0)
9−import Data.Semigroup (Semigroup(..))
10−#endif
11−import Data.Yaml (decodeFileEither, decodeEither')
12−import System.Exit (die)
13−
14−import Options.Applicative
15− ( Parser
16− , action, execParser, headerDoc, help, helper, info
17− , long, metavar, short, strArgument, strOption, value
18− )
19−import Options.Applicative.Help.Pretty
20− ( vcat, pretty )
21−
22−import Common
23− ( versionText, versionOption, numericVersionOption, dashToNothing )
24−
25−data Options = Options
26− { optInput :: Maybe FilePath
27− -- ^ 'Nothing' means @stdin@.
28− , optOutput :: Maybe FilePath
29− -- ^ 'Nothing' means @stdout@.
30− }
31−
32−-- | Name of the executable.
33−
34−self :: String
35−self = "yaml2json"
36−
37−-- | Parse options; handle parse errors, @--help@, @--version@.
38−
39−options :: IO Options
40−options =
41− execParser $
42− info (helper <*> versionOption self <*> numericVersionOption <*> programOptions)
43− (headerDoc hdoc)
44−
45− where
46− hdoc = Just $ vcat $ map pretty
47− [ versionText self
48− , "Convert YAML to JSON."
49− ]
50−
51− programOptions = Options <$> oInput <*> oOutput
52−
53− oInput :: Parser (Maybe FilePath)
54− oInput = dashToNothing <$> do
55− strArgument
56− $ metavar "IN"
57− <> value "-"
58− <> action "file"
59− <> help "The input file containing the YAML document; use '-' for stdin (default)."
60−
61− oOutput :: Parser (Maybe FilePath)
62− oOutput = dashToNothing <$> do
63− strOption
64− $ long "output"
65− <> short 'o'
66− <> value "-"
67− <> metavar "OUT"
68− <> action "file"
69− <> help "The file to hold the produced JSON document; use '-' for stdout (default)."
70−
71−
72−main :: IO ()
73−main = do
74− Options{ optInput, optOutput } <- options
75−
76− -- Input YAML.
77− result <- case optInput of
78− -- strict getContents will read in all of stdin at once
79− Nothing -> decodeEither' <$> S.getContents
80− Just f -> decodeFileEither f
81−
82− -- Output JSON.
83− case result of
84− Left err -> die $ show err
85− Right val -> do
86− let json = encode (val :: Value)
87− maybe L.putStr L.writeFile optOutput json
yaml/package.yamldeleted−113
@@ -1,113 +0,0 @@
1−name: yaml
2−version: 0.11.11.2
3−synopsis: Support for parsing and rendering YAML documents.
4−description: README and API documentation are available at <https://www.stackage.org/package/yaml>
5−category: Data
6−author: Michael Snoyman <michael@snoyman.com>, Anton Ageev <antage@gmail.com>,Kirill Simonov
7−maintainer: Michael Snoyman <michael@snoyman.com>
8−license: BSD3
9−github: snoyberg/yaml
10−stability: stable
11−
12−extra-source-files:
13−- test/largest-string.yaml
14−- test/json.yaml
15−- test/resources/foo.yaml
16−- test/resources/bar.yaml
17−- test/resources/baz.yaml
18−- test/resources/accent/foo.yaml
19−- test/resources/loop/foo.yaml
20−- test/resources/loop/bar.yaml
21−- test/resources/empty.yaml
22−- test/resources/empty2.yaml
23−- README.md
24−- ChangeLog.md
25−
26−flags:
27− no-exe:
28− description: don't install the yaml2json or json2yaml executables
29− manual: false
30− default: true
31− no-examples:
32− description: don't build the examples
33− manual: false
34− default: true
35−
36−dependencies:
37−- base >=4.14 && <5 # GHC 8.10.1 and later
38−- bytestring >=0.9.1.4
39−- transformers >=0.1
40−- mtl
41−- conduit >=1.2.8 && <1.4
42−- resourcet >=0.3 && <1.4
43−- aeson >=0.11
44−- containers
45−- unordered-containers
46−- vector
47−- text
48−- attoparsec >=0.11.3.0
49−- scientific >= 0.3 # for Data.ByteString.Builder.Scientific
50−- filepath
51−- directory
52−- template-haskell
53−- libyaml >=0.1 && <0.2
54−
55−ghc-options: -Wall -Wcompat
56−
57−library:
58− other-extensions:
59− - LambdaCase
60− source-dirs: src
61−
62−executables:
63− json2yaml:
64− main: json2yaml.hs
65− source-dirs: exe
66− dependencies:
67− - optparse-applicative
68− - yaml
69− when:
70− - condition: flag(no-exe)
71− buildable: false
72− yaml2json:
73− main: yaml2json.hs
74− source-dirs: exe
75− dependencies:
76− - optparse-applicative
77− - yaml
78− when:
79− - condition: flag(no-exe)
80− buildable: false
81− other-extensions:
82− - CPP
83− - LambdaCase
84− - NamedFieldPuns
85− examples:
86− main: Main.hs
87− source-dirs: examples
88− when:
89− - condition: flag(no-examples)
90− then:
91− buildable: false
92− else:
93− dependencies:
94− - raw-strings-qq
95− - yaml
96−
97−tests:
98− spec:
99− main: Spec.hs
100− source-dirs: test
101− ghc-options: "-with-rtsopts=-K1K"
102− cpp-options: -DTEST
103− dependencies:
104− - hspec >=1.3
105− - HUnit
106− - yaml
107− - directory
108− - mockery
109− - base-compat
110− - temporary
111− - raw-strings-qq
112− build-tools:
113− - hspec-discover
yaml/parser-test.hsdeleted−22
@@ -1,22 +0,0 @@
1−{-# LANGUAGE OverloadedStrings #-}
2−import Data.Yaml.Parser
3−import Data.Conduit
4−import Text.Libyaml
5−import Control.Applicative
6−import Data.Text (Text)
7−
8−data Person = Person
9− { name :: !Text
10− , age :: !Int
11− }
12− deriving (Show)
13−
14−instance FromYaml Person where
15− fromYaml = withMapping "Person" $ \o -> Person
16− <$> o .: "name"
17− <*> o .: "age"
18−
19−main :: IO ()
20−main = do
21− persons <- readYamlFile "/tmp/foo.yaml"
22− mapM_ print (persons :: [Person])
yaml/src/Data/Yaml.hsdeleted−292
@@ -1,292 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE ScopedTypeVariables #-}
3−{-# LANGUAGE OverloadedStrings #-}
4−
5−-- | Provides a high-level interface for processing YAML files.
6−--
7−-- This module reuses most of the infrastructure from the @aeson@ package.
8−-- This means that you can use all of the existing tools for JSON
9−-- processing for processing YAML files. As a result, much of the
10−-- documentation below mentions JSON; do not let that confuse you, it's
11−-- intentional.
12−--
13−-- For the most part, YAML content translates directly into JSON, and
14−-- therefore there is very little data loss. If you need to deal with YAML
15−-- more directly (e.g., directly deal with aliases), you should use the
16−-- "Text.Libyaml" module instead.
17−--
18−-- For documentation on the @aeson@ types, functions, classes, and
19−-- operators, please see the @Data.Aeson@ module of the @aeson@ package.
20−--
21−-- Look in the examples directory of the source repository for some initial
22−-- pointers on how to use this library.
23−
24−#if (defined (ghcjs_HOST_OS))
25−module Data.Yaml {-# WARNING "GHCJS is not supported yet (will break at runtime once called)." #-}
26−#else
27−module Data.Yaml
28−#endif
29− ( -- * Encoding
30− encode
31− , encodeWith
32− , encodeFile
33− , encodeFileWith
34− -- * Decoding
35− , decodeEither'
36− , decodeFileEither
37− , decodeFileWithWarnings
38− , decodeThrow
39− , decodeFileThrow
40− -- ** Decoding multiple documents
41− --
42− -- | For situations where we need to be able to parse multiple documents
43− -- separated by `---` in a YAML stream, these functions decode a list of
44− -- values rather than a single value.
45− , decodeAllEither'
46− , decodeAllFileEither
47− , decodeAllFileWithWarnings
48− , decodeAllThrow
49− , decodeAllFileThrow
50− -- ** More control over decoding
51− , decodeHelper
52− -- * Types
53− , Value (..)
54− , Parser
55− , Object
56− , Array
57− , ParseException(..)
58− , prettyPrintParseException
59− , YamlException (..)
60− , YamlMark (..)
61− -- * Constructors and accessors
62− , object
63− , array
64− , (.=)
65− , (.:)
66− , (.:?)
67− , (.!=)
68− -- ** With helpers (since 0.8.23)
69− , withObject
70− , withText
71− , withArray
72− , withScientific
73− , withBool
74− -- * Parsing
75− , parseMonad
76− , parseEither
77− , parseMaybe
78− -- * Classes
79− , ToJSON (..)
80− , FromJSON (..)
81− -- * Custom encoding
82− , isSpecialString
83− , EncodeOptions
84− , defaultEncodeOptions
85− , defaultStringStyle
86− , setStringStyle
87− , setFormat
88− , FormatOptions
89− , defaultFormatOptions
90− , setWidth
91− -- * Deprecated
92− , decode
93− , decodeFile
94− , decodeEither
95− ) where
96−#if !MIN_VERSION_base(4,8,0)
97−import Control.Applicative((<$>))
98−#endif
99−import Control.Exception
100−import Control.Monad.IO.Class (MonadIO, liftIO)
101−import Control.Monad.Trans.Resource (MonadThrow, throwM)
102−import Data.Aeson
103− ( Value (..), ToJSON (..), FromJSON (..), object
104− , (.=) , (.:) , (.:?) , (.!=)
105− , Object, Array
106− , withObject, withText, withArray, withScientific, withBool
107− )
108−import Data.Aeson.Types (parseMaybe, parseEither, Parser)
109−import Data.ByteString (ByteString)
110−import Data.Conduit ((.|), runConduitRes)
111−import qualified Data.Conduit.List as CL
112−import qualified Data.Vector as V
113−import System.IO.Unsafe (unsafePerformIO)
114−import Data.Text (Text)
115−
116−import Data.Yaml.Internal
117−import Text.Libyaml hiding (encode, decode, encodeFile, decodeFile, encodeWith, encodeFileWith)
118−import qualified Text.Libyaml as Y
119−
120−-- | Set the string style in the encoded YAML. This is a function that decides
121−-- for each string the type of YAML string to output.
122−--
123−-- __WARNING__: You must ensure that special strings (like @"yes"@\/@"no"@\/@"null"@\/@"1234"@) are not encoded with the 'Plain' style, because
124−-- then they will be decoded as boolean, null or numeric values. You can use 'isSpecialString' to detect them.
125−--
126−-- By default, strings are encoded as follows:
127−--
128−-- * Any string containing a newline character uses the 'Literal' style
129−--
130−-- * Otherwise, any special string (see 'isSpecialString') uses 'SingleQuoted'
131−--
132−-- * Otherwise, use 'Plain'
133−--
134−-- @since 0.10.2.0
135−setStringStyle :: (Text -> ( Tag, Style )) -> EncodeOptions -> EncodeOptions
136−setStringStyle s opts = opts { encodeOptionsStringStyle = s }
137−
138−-- | Set the encoding formatting for the encoded YAML. By default, this is `defaultFormatOptions`.
139−--
140−-- @since 0.10.2.0
141−setFormat :: FormatOptions -> EncodeOptions -> EncodeOptions
142−setFormat f opts = opts { encodeOptionsFormat = f }
143−
144−-- |
145−-- @since 0.10.2.0
146−data EncodeOptions = EncodeOptions
147− { encodeOptionsStringStyle :: Text -> ( Tag, Style )
148− , encodeOptionsFormat :: FormatOptions
149− }
150−
151−-- |
152−-- @since 0.10.2.0
153−defaultEncodeOptions :: EncodeOptions
154−defaultEncodeOptions = EncodeOptions
155− { encodeOptionsStringStyle = defaultStringStyle
156− , encodeOptionsFormat = defaultFormatOptions
157− }
158−
159−-- | Encode a value into its YAML representation.
160−encode :: ToJSON a => a -> ByteString
161−encode = encodeWith defaultEncodeOptions
162−
163−-- | Encode a value into its YAML representation with custom styling.
164−--
165−-- @since 0.10.2.0
166−encodeWith :: ToJSON a => EncodeOptions -> a -> ByteString
167−encodeWith opts obj = unsafePerformIO $ runConduitRes
168− $ CL.sourceList (objToStream (encodeOptionsStringStyle opts) $ toJSON obj)
169− .| Y.encodeWith (encodeOptionsFormat opts)
170−
171−-- | Encode a value into its YAML representation and save to the given file.
172−encodeFile :: ToJSON a => FilePath -> a -> IO ()
173−encodeFile = encodeFileWith defaultEncodeOptions
174−
175−-- | Encode a value into its YAML representation with custom styling and save to the given file.
176−--
177−-- @since 0.10.2.0
178−encodeFileWith :: ToJSON a => EncodeOptions -> FilePath -> a -> IO ()
179−encodeFileWith opts fp obj = runConduitRes
180− $ CL.sourceList (objToStream (encodeOptionsStringStyle opts) $ toJSON obj)
181− .| Y.encodeFileWith (encodeOptionsFormat opts) fp
182−
183−decode :: FromJSON a
184− => ByteString
185− -> Maybe a
186−decode bs = unsafePerformIO
187− $ either (const Nothing) snd
188− <$> decodeHelper_ (Y.decode bs)
189−{-# DEPRECATED decode "Please use decodeEither or decodeThrow, which provide information on how the decode failed" #-}
190−
191−decodeFile :: FromJSON a
192− => FilePath
193− -> IO (Maybe a)
194−decodeFile fp = (fmap snd <$> decodeHelper (Y.decodeFile fp)) >>= either throwIO (return . either (const Nothing) id)
195−{-# DEPRECATED decodeFile "Please use decodeFileEither, which does not confused type-directed and runtime exceptions." #-}
196−
197−-- | A version of 'decodeFile' which should not throw runtime exceptions.
198−--
199−-- @since 0.8.4
200−decodeFileEither
201− :: FromJSON a
202− => FilePath
203− -> IO (Either ParseException a)
204−decodeFileEither = fmap (fmap snd) . decodeFileWithWarnings
205−
206−-- | Like `decodeFileEither`, but decode multiple documents.
207−--
208−-- @since 0.11.5.0
209−decodeAllFileEither
210− :: FromJSON a
211− => FilePath
212− -> IO (Either ParseException [a])
213−decodeAllFileEither = fmap (fmap snd) . decodeAllFileWithWarnings
214−
215−-- | A version of `decodeFileEither` that returns warnings along with the parse
216−-- result.
217−--
218−-- @since 0.10.0
219−decodeFileWithWarnings
220− :: FromJSON a
221− => FilePath
222− -> IO (Either ParseException ([Warning], a))
223−decodeFileWithWarnings = decodeHelper_ . Y.decodeFile
224−
225−-- | Like `decodeFileWithWarnings`, but decode multiple documents.
226−--
227−-- @since 0.11.5.0
228−decodeAllFileWithWarnings
229− :: FromJSON a
230− => FilePath
231− -> IO (Either ParseException ([Warning], [a]))
232−decodeAllFileWithWarnings = decodeAllHelper_ . Y.decodeFile
233−
234−decodeEither :: FromJSON a => ByteString -> Either String a
235−decodeEither bs = unsafePerformIO
236− $ either (Left . prettyPrintParseException) id
237− <$> (fmap snd <$> decodeHelper (Y.decode bs))
238−{-# DEPRECATED decodeEither "Please use decodeEither' or decodeThrow, which provide more useful failures" #-}
239−
240−-- | More helpful version of 'decodeEither' which returns the 'YamlException'.
241−--
242−-- @since 0.8.3
243−decodeEither' :: FromJSON a => ByteString -> Either ParseException a
244−decodeEither' = either Left (either (Left . AesonException) Right)
245− . unsafePerformIO
246− . fmap (fmap snd) . decodeHelper
247− . Y.decode
248−
249−-- | Like 'decodeEither'', but decode multiple documents.
250−--
251−-- @since 0.11.5.0
252−decodeAllEither' :: FromJSON a => ByteString -> Either ParseException [a]
253−decodeAllEither' = either Left (either (Left . AesonException) Right)
254− . unsafePerformIO
255− . fmap (fmap snd) . decodeAllHelper
256− . Y.decode
257−
258−-- | A version of 'decodeEither'' lifted to MonadThrow
259−--
260−-- @since 0.8.31
261−decodeThrow :: (MonadThrow m, FromJSON a) => ByteString -> m a
262−decodeThrow = either throwM return . decodeEither'
263−
264−-- | Like `decodeThrow`, but decode multiple documents.
265−--
266−-- @since 0.11.5.0
267−decodeAllThrow :: (MonadThrow m, FromJSON a) => ByteString -> m [a]
268−decodeAllThrow = either throwM return . decodeAllEither'
269−
270−-- | A version of 'decodeFileEither' lifted to MonadIO
271−--
272−-- @since 0.8.31
273−decodeFileThrow :: (MonadIO m, FromJSON a) => FilePath -> m a
274−decodeFileThrow f = liftIO $ decodeFileEither f >>= either throwIO return
275−
276−-- | Like `decodeFileThrow`, but decode multiple documents.
277−--
278−-- @since 0.11.5.0
279−decodeAllFileThrow :: (MonadIO m, FromJSON a) => FilePath -> m [a]
280−decodeAllFileThrow f = liftIO $ decodeAllFileEither f >>= either throwIO return
281−
282−-- | Construct a new 'Value' from a list of 'Value's.
283−array :: [Value] -> Value
284−array = Array . V.fromList
285−
286−#if MIN_VERSION_base(4, 13, 0)
287−parseMonad :: MonadFail m => (a -> Parser b) -> a -> m b
288−#else
289−parseMonad :: Monad m => (a -> Parser b) -> a -> m b
290−#endif
291−parseMonad p = either fail return . parseEither p
292−{-# DEPRECATED parseMonad "With the MonadFail split, this function is going to be removed in the future. Please migrate to parseEither." #-}
yaml/src/Data/Yaml/Aeson.hsdeleted−7
@@ -1,7 +0,0 @@
1−-- | Just a re-export of @Data.Yaml@. In the future, this will be the canonical
2−-- name for that module\'s contents.
3−module Data.Yaml.Aeson
4− ( module Data.Yaml
5− ) where
6−
7−import Data.Yaml
yaml/src/Data/Yaml/Builder.hsdeleted−240
@@ -1,240 +0,0 @@
1−{-# LANGUAGE FlexibleInstances #-}
2−{-# LANGUAGE OverloadedStrings #-}
3−{-# LANGUAGE CPP #-}
4−-- | NOTE: This module is a highly experimental preview release. It may change
5−-- drastically, or be entirely removed, in a future release.
6−module Data.Yaml.Builder
7− ( YamlBuilder (..)
8− , ToYaml (..)
9− , mapping
10− , namedMapping
11− , maybeNamedMapping
12− , mappingComplex
13− , namedMappingComplex
14− , maybeNamedMappingComplex
15− , array
16− , namedArray
17− , maybeNamedArray
18− , string
19− , namedString
20− , maybeNamedString
21− , bool
22− , namedBool
23− , maybeNamedBool
24− , null
25− , namedNull
26− , maybeNamedNull
27− , scientific
28− , namedScientific
29− , maybeNamedScientific
30− , alias
31− , number
32− , toByteString
33− , toByteStringWith
34− , writeYamlFile
35− , writeYamlFileWith
36− , (.=)
37− , FormatOptions
38− , setWidth
39− ) where
40−
41−import Prelude hiding (null)
42−
43−#if MIN_VERSION_aeson(1,0,0)
44−import Data.Aeson.Text (encodeToTextBuilder)
45−#else
46−import Data.Aeson.Encode (encodeToTextBuilder)
47−#endif
48−import Data.Aeson.Types (Value(..))
49−import Data.ByteString (ByteString)
50−import qualified Data.ByteString.Char8 as S8
51−import Data.Conduit
52−import Data.Scientific (Scientific)
53−import Data.Text (Text, unpack)
54−import qualified Data.Text as T
55−import qualified Data.Text.Encoding as TE
56−import qualified Data.Text.Lazy as TL
57−import Data.Text.Lazy.Builder (toLazyText)
58−import System.IO.Unsafe (unsafePerformIO)
59−
60−import Data.Yaml.Internal
61−import Text.Libyaml
62−
63−(.=) :: ToYaml a => Text -> a -> (Text, YamlBuilder)
64−k .= v = (k, toYaml v)
65−
66−newtype YamlBuilder = YamlBuilder { unYamlBuilder :: [Event] -> [Event] }
67−
68−class ToYaml a where
69− toYaml :: a -> YamlBuilder
70−instance ToYaml YamlBuilder where
71− toYaml = id
72−instance (ToYaml a, ToYaml b) => ToYaml [(a, b)] where
73− toYaml = mappingComplex . map (\(k, v) -> (toYaml k, toYaml v))
74−instance ToYaml a => ToYaml [a] where
75− toYaml = array . map toYaml
76−instance ToYaml Text where
77− toYaml = string
78−instance {-# OVERLAPPING #-} ToYaml String where
79− toYaml = string . T.pack
80−instance ToYaml Int where
81− toYaml i = YamlBuilder (EventScalar (S8.pack $ show i) NoTag PlainNoTag Nothing:)
82−instance ToYaml Double where
83− toYaml i = YamlBuilder (EventScalar (S8.pack $ show i) NoTag PlainNoTag Nothing:)
84−instance ToYaml Scientific where
85− toYaml = scientific
86−instance ToYaml Bool where
87− toYaml = bool
88−instance ToYaml a => ToYaml (Maybe a) where
89− toYaml = maybe null toYaml
90−
91−-- |
92−-- @since 0.10.3.0
93−maybeNamedMapping :: Maybe Text -> [(Text, YamlBuilder)] -> YamlBuilder
94−maybeNamedMapping anchor pairs = maybeNamedMappingComplex anchor complexPairs
95− where
96− complexPairs = map (\(k, v) -> (string k, v)) pairs
97−
98−-- |
99−-- @since 0.8.7
100−mapping :: [(Text, YamlBuilder)] -> YamlBuilder
101−mapping = maybeNamedMapping Nothing
102−
103−-- |
104−-- @since 0.10.3.0
105−namedMapping :: Text -> [(Text, YamlBuilder)] -> YamlBuilder
106−namedMapping name = maybeNamedMapping $ Just name
107−
108−-- |
109−-- @since 0.11.2.0
110−maybeNamedMappingComplex :: Maybe Text -> [(YamlBuilder, YamlBuilder)] -> YamlBuilder
111−maybeNamedMappingComplex anchor pairs = YamlBuilder $ \rest ->
112− EventMappingStart NoTag AnyMapping (unpack <$> anchor) : foldr addPair (EventMappingEnd : rest) pairs
113− where
114− addPair (YamlBuilder key, YamlBuilder value) after = key $ value after
115−
116−-- |
117−-- @since 0.11.2.0
118−mappingComplex :: [(YamlBuilder, YamlBuilder)] -> YamlBuilder
119−mappingComplex = maybeNamedMappingComplex Nothing
120−
121−-- |
122−-- @since 0.11.2.0
123−namedMappingComplex :: Text -> [(YamlBuilder, YamlBuilder)] -> YamlBuilder
124−namedMappingComplex name = maybeNamedMappingComplex $ Just name
125−
126−-- |
127−-- @since 0.10.3.0
128−maybeNamedArray :: Maybe Text -> [YamlBuilder] -> YamlBuilder
129−maybeNamedArray anchor bs =
130− YamlBuilder $ (EventSequenceStart NoTag AnySequence (unpack <$> anchor):) . flip (foldr go) bs . (EventSequenceEnd:)
131− where
132− go (YamlBuilder b) = b
133−
134−-- |
135−-- @since 0.8.7
136−array :: [YamlBuilder] -> YamlBuilder
137−array = maybeNamedArray Nothing
138−
139−-- |
140−-- @since 0.10.3.0
141−namedArray :: Text -> [YamlBuilder] -> YamlBuilder
142−namedArray name = maybeNamedArray $ Just name
143−
144−-- |
145−-- @since 0.10.3.0
146−maybeNamedString :: Maybe Text -> Text -> YamlBuilder
147−maybeNamedString anchor s = YamlBuilder (stringScalar defaultStringStyle anchor s :)
148−
149−-- |
150−-- @since 0.8.7
151−string :: Text -> YamlBuilder
152−string = maybeNamedString Nothing
153−
154−-- |
155−-- @since 0.10.3.0
156−namedString :: Text -> Text -> YamlBuilder
157−namedString name = maybeNamedString $ Just name
158−
159−-- Use aeson's implementation which gets rid of annoying decimal points
160−-- |
161−-- @since 0.10.3.0
162−maybeNamedScientific :: Maybe Text -> Scientific -> YamlBuilder
163−maybeNamedScientific anchor n = YamlBuilder (EventScalar (TE.encodeUtf8 $ TL.toStrict $ toLazyText $ encodeToTextBuilder (Number n)) NoTag PlainNoTag (unpack <$> anchor) :)
164−
165−-- |
166−-- @since 0.8.13
167−scientific :: Scientific -> YamlBuilder
168−scientific = maybeNamedScientific Nothing
169−
170−-- |
171−-- @since 0.10.3.0
172−namedScientific :: Text -> Scientific -> YamlBuilder
173−namedScientific name = maybeNamedScientific $ Just name
174−
175−-- |
176−-- @since 0.8.13
177−{-# DEPRECATED number "Use scientific" #-}
178−number :: Scientific -> YamlBuilder
179−number = scientific
180−
181−-- |
182−-- @since 0.10.3.0
183−maybeNamedBool :: Maybe Text -> Bool -> YamlBuilder
184−maybeNamedBool anchor True = YamlBuilder (EventScalar "true" NoTag PlainNoTag (unpack <$> anchor) :)
185−maybeNamedBool anchor False = YamlBuilder (EventScalar "false" NoTag PlainNoTag (unpack <$> anchor) :)
186−
187−-- |
188−-- @since 0.8.13
189−bool :: Bool -> YamlBuilder
190−bool = maybeNamedBool Nothing
191−
192−-- |
193−-- @since 0.10.3.0
194−namedBool :: Text -> Bool -> YamlBuilder
195−namedBool name = maybeNamedBool $ Just name
196−
197−-- |
198−-- @since 0.10.3.0
199−maybeNamedNull :: Maybe Text -> YamlBuilder
200−maybeNamedNull anchor = YamlBuilder (EventScalar "null" NoTag PlainNoTag (unpack <$> anchor) :)
201−
202−-- |
203−-- @since 0.8.13
204−null :: YamlBuilder
205−null = maybeNamedNull Nothing
206−
207−-- |
208−-- @since 0.10.3.0
209−namedNull :: Text -> YamlBuilder
210−namedNull name = maybeNamedNull $ Just name
211−
212−-- |
213−-- @since 0.10.3.0
214−alias :: Text -> YamlBuilder
215−alias anchor = YamlBuilder (EventAlias (unpack anchor) :)
216−
217−toEvents :: YamlBuilder -> [Event]
218−toEvents (YamlBuilder front) =
219− EventStreamStart : EventDocumentStart : front [EventDocumentEnd, EventStreamEnd]
220−
221−toSource :: (Monad m, ToYaml a) => a -> ConduitM i Event m ()
222−toSource = mapM_ yield . toEvents . toYaml
223−
224−-- |
225−-- @since 0.8.7
226−toByteString :: ToYaml a => a -> ByteString
227−toByteString = toByteStringWith defaultFormatOptions
228−
229−-- |
230−-- @since 0.10.2.0
231−toByteStringWith :: ToYaml a => FormatOptions -> a -> ByteString
232−toByteStringWith opts yb = unsafePerformIO $ runConduitRes $ toSource yb .| encodeWith opts
233−
234−writeYamlFile :: ToYaml a => FilePath -> a -> IO ()
235−writeYamlFile = writeYamlFileWith defaultFormatOptions
236−
237−-- |
238−-- @since 0.10.2.0
239−writeYamlFileWith :: ToYaml a => FormatOptions -> FilePath -> a -> IO ()
240−writeYamlFileWith opts fp yb = runConduitRes $ toSource yb .| encodeFileWith opts fp
yaml/src/Data/Yaml/Config.hsdeleted−234
@@ -1,234 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE OverloadedStrings #-}
3−-- | Functionality for using YAML as configuration files
4−--
5−-- In particular, merging environment variables with yaml values
6−--
7−-- 'loadYamlSettings' is a high-level API for loading YAML and merging environment variables.
8−-- A yaml value of @_env:ENV_VAR:default@ or just @_env:ENV_VAR@ will lookup the environment variable @ENV_VAR@.
9−--
10−-- On a historical note, this code was taken directly from the yesod web framework's configuration module.
11−module Data.Yaml.Config
12− ( -- * High-level
13− loadYamlSettings
14− , loadYamlSettingsArgs
15− -- ** EnvUsage
16− , EnvUsage
17− , ignoreEnv
18− , useEnv
19− , requireEnv
20− , useCustomEnv
21− , requireCustomEnv
22− -- * Lower level
23− , applyCurrentEnv
24− , getCurrentEnv
25− , applyEnvValue
26− ) where
27−
28−
29−#if __GLASGOW_HASKELL__ < 710
30−import Control.Applicative ((<$>))
31−import Data.Monoid
32−#endif
33−import Data.Semigroup
34−import Data.List.NonEmpty (nonEmpty)
35−import Data.Aeson
36−#if MIN_VERSION_aeson(2,0,0)
37−import qualified Data.Aeson.Key as K
38−import qualified Data.Aeson.KeyMap as H
39−import Data.Aeson.KeyMap (KeyMap)
40−#else
41−import qualified Data.HashMap.Strict as H
42−#endif
43−import Data.Text (Text, pack)
44−import System.Environment (getArgs, getEnvironment)
45−import Control.Arrow ((***))
46−import Control.Monad (forM)
47−import Control.Exception (throwIO)
48−import Data.Text.Encoding (encodeUtf8)
49−import qualified Data.Yaml as Y
50−import qualified Data.Yaml.Include as YI
51−import Data.Maybe (fromMaybe)
52−import qualified Data.Text as T
53−
54−#if MIN_VERSION_aeson(2,0,0)
55−fromText :: T.Text -> Key
56−fromText = K.fromText
57−#else
58−fromText :: T.Text -> T.Text
59−fromText = id
60−
61−type KeyMap a = H.HashMap T.Text a
62−#endif
63−
64−newtype MergedValue = MergedValue { getMergedValue :: Value }
65−
66−instance Semigroup MergedValue where
67− MergedValue x <> MergedValue y = MergedValue $ mergeValues x y
68−
69−-- | Left biased
70−mergeValues :: Value -> Value -> Value
71−mergeValues (Object x) (Object y) = Object $ H.unionWith mergeValues x y
72−mergeValues x _ = x
73−
74−-- | Override environment variable placeholders in the given @Value@ with
75−-- values from the environment.
76−--
77−-- If the first argument is @True@, then all placeholders _must_ be provided by
78−-- the actual environment. Otherwise, default values from the @Value@ will be
79−-- used.
80−--
81−-- @since 0.8.16
82−applyEnvValue :: Bool -- ^ require an environment variable to be present?
83− -> KeyMap Text -> Value -> Value
84−applyEnvValue requireEnv' env =
85− goV
86− where
87− goV (Object o) = Object $ goV <$> o
88− goV (Array a) = Array (goV <$> a)
89− goV (String t1) = fromMaybe (String t1) $ do
90− t2 <- T.stripPrefix "_env:" t1
91− let (name, t3) = T.break (== ':') t2
92− mdef = fmap parseValue $ T.stripPrefix ":" t3
93− Just $ case H.lookup (fromText name) env of
94− Just val ->
95− -- If the default value parses as a String, we treat the
96− -- environment variable as a raw value and do not parse it.
97− -- This means that things like numeric passwords just work.
98− -- However, for originally numerical or boolean values (e.g.,
99− -- port numbers), we still perform a normal YAML parse.
100− --
101− -- For details, see:
102− -- https://github.com/yesodweb/yesod/issues/1061
103− case mdef of
104− Just (String _) -> String val
105− _ -> parseValue val
106− Nothing ->
107− case mdef of
108− Just val | not requireEnv' -> val
109− _ -> Null
110− goV v = v
111−
112− parseValue val = either
113− (const (String val))
114− id
115− (Y.decodeThrow $ encodeUtf8 val)
116−
117−-- | Get the actual environment as a @HashMap@ from @Text@ to @Text@.
118−--
119−-- @since 0.8.16
120−getCurrentEnv :: IO (KeyMap Text)
121−getCurrentEnv = fmap (H.fromList . map (fromText . pack *** pack)) getEnvironment
122−
123−-- | A convenience wrapper around 'applyEnvValue' and 'getCurrentEnv'
124−--
125−-- @since 0.8.16
126−applyCurrentEnv :: Bool -- ^ require an environment variable to be present?
127− -> Value -> IO Value
128−applyCurrentEnv requireEnv' orig = flip (applyEnvValue requireEnv') orig <$> getCurrentEnv
129−
130−-- | Defines how we want to use the environment variables when loading a config
131−-- file. Use the smart constructors provided by this module.
132−--
133−-- @since 0.8.16
134−data EnvUsage = IgnoreEnv
135− | UseEnv
136− | RequireEnv
137− | UseCustomEnv (KeyMap Text)
138− | RequireCustomEnv (KeyMap Text)
139−
140−-- | Do not use any environment variables, instead relying on defaults values
141−-- in the config file.
142−--
143−-- @since 0.8.16
144−ignoreEnv :: EnvUsage
145−ignoreEnv = IgnoreEnv
146−
147−-- | Use environment variables when available, otherwise use defaults.
148−--
149−-- @since 0.8.16
150−useEnv :: EnvUsage
151−useEnv = UseEnv
152−
153−-- | Do not use default values from the config file, but instead take all
154−-- overrides from the environment. If a value is missing, loading the file will
155−-- throw an exception.
156−--
157−-- @since 0.8.16
158−requireEnv :: EnvUsage
159−requireEnv = RequireEnv
160−
161−-- | Same as 'useEnv', but instead of the actual environment, use the provided
162−-- @HashMap@ as the environment.
163−--
164−-- @since 0.8.16
165−useCustomEnv :: KeyMap Text -> EnvUsage
166−useCustomEnv = UseCustomEnv
167−
168−-- | Same as 'requireEnv', but instead of the actual environment, use the
169−-- provided @HashMap@ as the environment.
170−--
171−-- @since 0.8.16
172−requireCustomEnv :: KeyMap Text -> EnvUsage
173−requireCustomEnv = RequireCustomEnv
174−
175−-- | Load the settings from the following three sources:
176−--
177−-- * Run time config files
178−--
179−-- * Run time environment variables
180−--
181−-- * The default compile time config file
182−--
183−-- For example, to load up settings from @config/foo.yaml@ and allow overriding
184−-- from the actual environment, you can use:
185−--
186−-- > loadYamlSettings ["config/foo.yaml"] [] useEnv
187−--
188−-- Alternatively you can configure settings through the Yaml @Value@ directly in Haskell.
189−-- For example, to load up settings from only from environment variables, you can use:
190−--
191−-- > loadYamlSettings [] [object ["connectionString" .= ("_env:DATABASE_URL" :: String)]] requireEnv
192−--
193−-- @since 0.8.16
194−loadYamlSettings
195− :: FromJSON settings
196− => [FilePath] -- ^ run time config files to use, earlier files have precedence
197− -> [Value] -- ^ any other values to use, usually from compile time config. overridden by files
198− -> EnvUsage
199− -> IO settings
200−loadYamlSettings runTimeFiles compileValues envUsage = do
201− runValues <- forM runTimeFiles $ \fp -> do
202− eres <- YI.decodeFileEither fp
203− case eres of
204− Left e -> throwIO (Y.LoadSettingsException fp e)
205− Right value -> return value
206−
207− value' <-
208− case nonEmpty $ map MergedValue $ runValues ++ compileValues of
209− Nothing -> error "loadYamlSettings: No configuration provided"
210− Just ne -> return $ getMergedValue $ sconcat ne
211− value <-
212− case envUsage of
213− IgnoreEnv -> return $ applyEnvValue False mempty value'
214− UseEnv -> applyCurrentEnv False value'
215− RequireEnv -> applyCurrentEnv True value'
216− UseCustomEnv env -> return $ applyEnvValue False env value'
217− RequireCustomEnv env -> return $ applyEnvValue True env value'
218−
219− case Y.parseEither parseJSON value of
220− Left s -> error $ "Could not convert to expected type: " ++ s
221− Right settings -> return settings
222−
223−-- | Same as @loadYamlSettings@, but get the list of runtime config files from
224−-- the command line arguments.
225−--
226−-- @since 0.8.17
227−loadYamlSettingsArgs
228− :: FromJSON settings
229− => [Value] -- ^ any other values to use, usually from compile time config. overridden by files
230− -> EnvUsage -- ^ use environment variables
231− -> IO settings
232−loadYamlSettingsArgs values env = do
233− args <- getArgs
234− loadYamlSettings args values env
yaml/src/Data/Yaml/Include.hsdeleted−94
@@ -1,94 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE RankNTypes #-}
3−module Data.Yaml.Include (
4− decodeFile
5−, decodeFileEither
6−, decodeFileWithWarnings
7−) where
8−
9−#if !MIN_VERSION_directory(1, 2, 3)
10−import Control.Exception (handleJust)
11−import Control.Monad (guard)
12−import System.IO.Error (ioeGetFileName, ioeGetLocation, isDoesNotExistError)
13−#endif
14−
15−import Control.Exception (throwIO)
16−import Control.Monad (when)
17−import Control.Monad.IO.Class (liftIO)
18−import Control.Monad.Trans.Resource (MonadResource)
19−import Data.Aeson (FromJSON)
20−import Data.Conduit
21−import qualified Data.Conduit.List as CL
22−import Data.Text (unpack)
23−import Data.Text.Encoding (decodeUtf8)
24−import System.Directory
25−import System.FilePath
26−
27−import Data.Yaml.Internal (ParseException(..), Warning(..), decodeHelper_, decodeHelper)
28−import Text.Libyaml hiding (decodeFile)
29−import qualified Text.Libyaml as Y
30−
31−eventsFromFile
32− :: MonadResource m
33− => FilePath
34− -> ConduitM i Event m ()
35−eventsFromFile = go []
36− where
37− go :: MonadResource m => [FilePath] -> FilePath -> ConduitM i Event m ()
38− go seen fp = do
39− cfp <- liftIO $ handleNotFound $ canonicalizePath fp
40− when (cfp `elem` seen) $ do
41− liftIO $ throwIO CyclicIncludes
42− Y.decodeFile cfp .| do
43− awaitForever $ \event -> case event of
44− EventScalar f (UriTag "!include") _ _ -> do
45− let includeFile = takeDirectory cfp </> unpack (decodeUtf8 f)
46− go (cfp : seen) includeFile .| CL.filter (`notElem` irrelevantEvents)
47− _ -> yield event
48−
49− irrelevantEvents = [EventStreamStart, EventDocumentStart, EventDocumentEnd, EventStreamEnd]
50−
51−#if !MIN_VERSION_directory(1, 2, 3)
52− handleNotFound = handleJust
53− (\e -> do
54− guard (isDoesNotExistError e)
55− guard (ioeGetLocation e == "canonicalizePath")
56− ioeGetFileName e)
57− (throwIO . YamlException . ("Yaml file not found: " ++))
58−#else
59− handleNotFound = id
60−#endif
61−
62−-- | Like `Data.Yaml.decodeFile` but with support for relative and absolute
63−-- includes.
64−--
65−-- The syntax for includes follows the form:
66−--
67−-- > somekey: !include ./somefile.yaml
68−decodeFile
69− :: FromJSON a
70− => FilePath
71− -> IO (Maybe a)
72−decodeFile fp = (fmap snd <$> decodeHelper (eventsFromFile fp)) >>= either throwIO (return . either (const Nothing) id)
73−
74−-- | Like `Data.Yaml.decodeFileEither` but with support for relative and
75−-- absolute includes.
76−--
77−-- The syntax for includes follows the form:
78−--
79−-- > somekey: !include ./somefile.yaml
80−decodeFileEither
81− :: FromJSON a
82− => FilePath
83− -> IO (Either ParseException a)
84−decodeFileEither = fmap (fmap snd) . decodeFileWithWarnings
85−
86−-- | A version of `decodeFileEither` that returns warnings along with the parse
87−-- result.
88−--
89−-- @since 0.10.0
90−decodeFileWithWarnings
91− :: FromJSON a
92− => FilePath
93− -> IO (Either ParseException ([Warning], a))
94−decodeFileWithWarnings = decodeHelper_ . eventsFromFile
yaml/src/Data/Yaml/Internal.hsdeleted−469
@@ -1,469 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE DeriveDataTypeable #-}
3−{-# LANGUAGE PatternGuards #-}
4−{-# LANGUAGE OverloadedStrings #-}
5−{-# LANGUAGE BangPatterns #-}
6−module Data.Yaml.Internal
7− (
8− ParseException(..)
9− , prettyPrintParseException
10− , Warning(..)
11− , parse
12− , Parse
13− , decodeHelper
14− , decodeHelper_
15− , decodeAllHelper
16− , decodeAllHelper_
17− , textToScientific
18− , stringScalar
19− , StringStyle
20− , defaultStringStyle
21− , isSpecialString
22− , specialStrings
23− , isNumeric
24− , objToStream
25− , objToEvents
26− ) where
27−
28−#if !MIN_VERSION_base(4,8,0)
29−import Control.Applicative ((<$>), Applicative(..))
30−#endif
31−import Control.Applicative ((<|>))
32−import Control.Exception
33−import Control.Monad (when, unless)
34−import Control.Monad.Trans.Resource (ResourceT, runResourceT)
35−import Control.Monad.State.Strict
36−import Control.Monad.Reader
37−#if MIN_VERSION_aeson(2,1,2)
38−import Data.Aeson hiding (AesonException)
39−#else
40−import Data.Aeson
41−#endif
42−#if MIN_VERSION_aeson(2,0,0)
43−import qualified Data.Aeson.Key as K
44−import qualified Data.Aeson.KeyMap as M
45−import Data.Aeson.KeyMap (KeyMap)
46−#else
47−import qualified Data.HashMap.Strict as M
48−#endif
49−#if MIN_VERSION_aeson(2,2,0)
50−import Data.Aeson.Types hiding (AesonException, parse)
51−#else
52−import Data.Aeson.Types hiding (parse)
53−import Data.Aeson.Internal (JSONPath, JSONPathElement(..), formatError)
54−#endif
55−import qualified Data.Attoparsec.Text as Atto
56−import Data.Bits (shiftL, (.|.))
57−import Data.ByteString (ByteString)
58−import qualified Data.ByteString.Builder as BB
59−import qualified Data.ByteString.Lazy as BL
60−import Data.ByteString.Builder.Scientific (scientificBuilder)
61−import Data.Char (toUpper, ord)
62−import qualified Data.List as List
63−import Data.Conduit ((.|), ConduitM, runConduit)
64−import qualified Data.Conduit.List as CL
65−import qualified Data.HashSet as HashSet
66−import Data.Map (Map)
67−import qualified Data.Map as Map
68−import Data.Set (Set)
69−import qualified Data.Set as Set
70−import Data.Scientific (Scientific, base10Exponent, coefficient)
71−import Data.Text (Text)
72−import qualified Data.Text as T
73−import Data.Text.Encoding (decodeUtf8With, encodeUtf8)
74−import Data.Text.Encoding.Error (lenientDecode)
75−import Data.Typeable
76−import qualified Data.Vector as V
77−import Data.Void (Void)
78−
79−import qualified Text.Libyaml as Y
80−import Text.Libyaml hiding (encode, decode, encodeFile, decodeFile)
81−
82−#if MIN_VERSION_aeson(2,0,0)
83−fromText :: T.Text -> K.Key
84−fromText = K.fromText
85−
86−toText :: K.Key -> T.Text
87−toText = K.toText
88−#else
89−fromText :: T.Text -> T.Text
90−fromText = id
91−
92−toText :: Key -> T.Text
93−toText = id
94−
95−type KeyMap a = M.HashMap Text a
96−type Key = Text
97−#endif
98−
99−data ParseException = NonScalarKey
100− | UnknownAlias { _anchorName :: Y.AnchorName }
101− | UnexpectedEvent { _received :: Maybe Event
102− , _expected :: Maybe Event
103− }
104− | InvalidYaml (Maybe YamlException)
105− | MultipleDocuments
106− | AesonException String
107− | OtherParseException SomeException
108− | NonStringKey JSONPath
109− | NonStringKeyAlias Y.AnchorName Value
110− | CyclicIncludes
111− | LoadSettingsException FilePath ParseException
112− deriving (Show, Typeable)
113−
114−instance Exception ParseException where
115−#if MIN_VERSION_base(4, 8, 0)
116− displayException = prettyPrintParseException
117−#endif
118−
119−-- | Alternative to 'show' to display a 'ParseException' on the screen.
120−-- Instead of displaying the data constructors applied to their arguments,
121−-- a more textual output is returned. For example, instead of printing:
122−--
123−-- > InvalidYaml (Just (YamlParseException {yamlProblem = "did not find expected ',' or '}'", yamlContext = "while parsing a flow mapping", yamlProblemMark = YamlMark {yamlIndex = 42, yamlLine = 2, yamlColumn = 12}})))
124−--
125−-- It looks more pleasant to print:
126−--
127−-- > YAML parse exception at line 2, column 12,
128−-- > while parsing a flow mapping:
129−-- > did not find expected ',' or '}'
130−--
131−-- Since 0.8.11
132−prettyPrintParseException :: ParseException -> String
133−prettyPrintParseException pe = case pe of
134− NonScalarKey -> "Non scalar key"
135− UnknownAlias anchor -> "Unknown alias `" ++ anchor ++ "`"
136− UnexpectedEvent { _expected = mbExpected, _received = mbUnexpected } -> unlines
137− [ "Unexpected event: expected"
138− , " " ++ show mbExpected
139− , "but received"
140− , " " ++ show mbUnexpected
141− ]
142− InvalidYaml mbYamlError -> case mbYamlError of
143− Nothing -> "Unspecified YAML error"
144− Just yamlError -> case yamlError of
145− YamlException s -> "YAML exception:\n" ++ s
146− YamlParseException problem context mark -> concat
147− [ "YAML parse exception at line " ++ show (yamlLine mark) ++
148− ", column " ++ show (yamlColumn mark)
149− , case context of
150− "" -> ":\n"
151− -- The context seems to include a leading "while" or similar.
152− _ -> ",\n" ++ context ++ ":\n"
153− , problem
154− ]
155− MultipleDocuments -> "Multiple YAML documents encountered"
156− AesonException s -> "Aeson exception:\n" ++ s
157− OtherParseException exc -> "Generic parse exception:\n" ++ show exc
158− NonStringKey path -> formatError path "Non-string keys are not supported"
159− NonStringKeyAlias anchor value -> unlines
160− [ "Non-string key alias:"
161− , " Anchor name: " ++ anchor
162− , " Value: " ++ show value
163− ]
164− CyclicIncludes -> "Cyclic includes"
165− LoadSettingsException fp exc -> "Could not parse file as YAML: " ++ fp ++ "\n" ++ prettyPrintParseException exc
166−
167−defineAnchor :: Value -> String -> ReaderT JSONPath (ConduitM e o Parse) ()
168−defineAnchor value name = modify (modifyAnchors $ Map.insert name value)
169− where
170− modifyAnchors :: (Map String Value -> Map String Value) -> ParseState -> ParseState
171− modifyAnchors f st = st {parseStateAnchors = f (parseStateAnchors st)}
172−
173−lookupAnchor :: String -> ReaderT JSONPath (ConduitM e o Parse) (Maybe Value)
174−lookupAnchor name = gets (Map.lookup name . parseStateAnchors)
175−
176−data Warning = DuplicateKey JSONPath
177− deriving (Eq, Show)
178−
179−addWarning :: Warning -> ReaderT JSONPath (ConduitM e o Parse) ()
180−addWarning w = modify (modifyWarnings (w :))
181− where
182− modifyWarnings :: ([Warning] -> [Warning]) -> ParseState -> ParseState
183− modifyWarnings f st = st {parseStateWarnings = f (parseStateWarnings st)}
184−
185−data ParseState = ParseState {
186− parseStateAnchors :: Map String Value
187−, parseStateWarnings :: [Warning]
188−}
189−
190−type Parse = StateT ParseState (ResourceT IO)
191−
192−requireEvent :: Event -> ReaderT JSONPath (ConduitM Event o Parse) ()
193−requireEvent e = do
194− f <- lift CL.head
195− unless (f == Just e) $ liftIO $ throwIO $ UnexpectedEvent f $ Just e
196−
197−parse :: ReaderT JSONPath (ConduitM Event o Parse) Value
198−parse = do
199− docs <- parseAll
200− case docs of
201− [] -> return Null
202− [doc] -> return doc
203− _ -> liftIO $ throwIO MultipleDocuments
204−
205−parseAll :: ReaderT JSONPath (ConduitM Event o Parse) [Value]
206−parseAll = do
207− streamStart <- lift CL.head
208− case streamStart of
209− Nothing ->
210− -- empty string input
211− return []
212− Just EventStreamStart ->
213− -- empty file input, comment only string/file input
214− parseDocs
215− _ -> missed streamStart
216− where
217− parseDocs = do
218− documentStart <- lift CL.head
219− case documentStart of
220− Just EventStreamEnd -> return []
221− Just EventDocumentStart -> do
222− res <- parseO
223− requireEvent EventDocumentEnd
224− (res :) <$> parseDocs
225− _ -> missed documentStart
226− missed event = liftIO $ throwIO $ UnexpectedEvent event Nothing
227−
228−parseScalar :: ByteString -> Anchor -> Style -> Tag
229− -> ReaderT JSONPath (ConduitM Event o Parse) Text
230−parseScalar v a style tag = do
231− let res = decodeUtf8With lenientDecode v
232− mapM_ (defineAnchor (textToValue style tag res)) a
233− return res
234−
235−textToValue :: Style -> Tag -> Text -> Value
236−textToValue SingleQuoted _ t = String t
237−textToValue DoubleQuoted _ t = String t
238−textToValue _ StrTag t = String t
239−textToValue Folded _ t = String t
240−textToValue _ _ t
241− | t `elem` ["null", "Null", "NULL", "~", ""] = Null
242− | any (t `isLike`) ["y", "yes", "on", "true"] = Bool True
243− | any (t `isLike`) ["n", "no", "off", "false"] = Bool False
244− | Right x <- textToScientific t = Number x
245− | otherwise = String t
246− where x `isLike` ref = x `elem` [ref, T.toUpper ref, titleCased]
247− where titleCased = toUpper (T.head ref) `T.cons` T.tail ref
248−
249−textToScientific :: Text -> Either String Scientific
250−textToScientific = Atto.parseOnly (num <* Atto.endOfInput)
251− where
252− num = (fromInteger <$> ("0x" *> Atto.hexadecimal))
253− <|> (fromInteger <$> ("0o" *> octal))
254− <|> Atto.scientific
255−
256− octal = T.foldl' step 0 <$> Atto.takeWhile1 isOctalDigit
257− where
258− isOctalDigit c = (c >= '0' && c <= '7')
259− step a c = (a `shiftL` 3) .|. fromIntegral (ord c - 48)
260−
261−parseO :: ReaderT JSONPath (ConduitM Event o Parse) Value
262−parseO = do
263− me <- lift CL.head
264− case me of
265− Just (EventScalar v tag style a) -> textToValue style tag <$> parseScalar v a style tag
266− Just (EventSequenceStart _ _ a) -> parseS 0 a id
267− Just (EventMappingStart _ _ a) -> parseM mempty a M.empty
268− Just (EventAlias an) -> do
269− m <- lookupAnchor an
270− case m of
271− Nothing -> liftIO $ throwIO $ UnknownAlias an
272− Just v -> return v
273− _ -> liftIO $ throwIO $ UnexpectedEvent me Nothing
274−
275−parseS :: Int
276− -> Y.Anchor
277− -> ([Value] -> [Value])
278− -> ReaderT JSONPath (ConduitM Event o Parse) Value
279−parseS !n a front = do
280− me <- lift CL.peek
281− case me of
282− Just EventSequenceEnd -> do
283− lift $ CL.drop 1
284− let res = Array $ V.fromList $ front []
285− mapM_ (defineAnchor res) a
286− return res
287− _ -> do
288− o <- local (Index n :) parseO
289− parseS (succ n) a $ front . (:) o
290−
291−parseM :: Set Key
292− -> Y.Anchor
293− -> KeyMap Value
294− -> ReaderT JSONPath (ConduitM Event o Parse) Value
295−parseM mergedKeys a front = do
296− me <- lift CL.head
297− case me of
298− Just EventMappingEnd -> do
299− let res = Object front
300− mapM_ (defineAnchor res) a
301− return res
302− _ -> do
303− s <- case me of
304− Just (EventScalar v tag style a') -> fromText <$> parseScalar v a' style tag
305− Just (EventAlias an) -> do
306− m <- lookupAnchor an
307− case m of
308− Nothing -> liftIO $ throwIO $ UnknownAlias an
309− Just (String t) -> return $ fromText t
310− Just v -> liftIO $ throwIO $ NonStringKeyAlias an v
311− _ -> do
312− path <- ask
313− liftIO $ throwIO $ NonStringKey path
314−
315− (mergedKeys', al') <- local (Key s :) $ do
316− o <- parseO
317− let al = do
318− when (M.member s front && Set.notMember s mergedKeys) $ do
319− path <- reverse <$> ask
320− addWarning (DuplicateKey path)
321− return (Set.delete s mergedKeys, M.insert s o front)
322− if s == "<<"
323− then case o of
324− Object l -> return (merge l)
325− Array l -> return $ merge $ List.foldl' mergeObjects M.empty $ V.toList l
326− _ -> al
327− else al
328− parseM mergedKeys' a al'
329− where mergeObjects al (Object om) = M.union al om
330− mergeObjects al _ = al
331−
332− merge xs = (Set.fromList (M.keys xs List.\\ M.keys front), M.union front xs)
333−
334−parseSrc :: ReaderT JSONPath (ConduitM Event Void Parse) val
335− -> ConduitM () Event Parse ()
336− -> IO (val, ParseState)
337−parseSrc eventParser src = runResourceT $ runStateT
338− (runConduit $ src .| runReaderT eventParser [])
339− (ParseState Map.empty [])
340−
341−mkHelper :: ReaderT JSONPath (ConduitM Event Void Parse) val -- ^ parse libyaml events as Value or [Value]
342− -> (SomeException -> IO (Either ParseException a)) -- ^ what to do with unhandled exceptions
343− -> ((val, ParseState) -> Either ParseException a) -- ^ further transform and parse results
344− -> ConduitM () Event Parse () -- ^ the libyaml event (string/file) source
345− -> IO (Either ParseException a)
346−mkHelper eventParser onOtherExc extractResults src = catches
347− (extractResults <$> parseSrc eventParser src)
348− [ Handler $ \pe -> return $ Left (pe :: ParseException)
349− , Handler $ \ye -> return $ Left $ InvalidYaml $ Just (ye :: YamlException)
350− , Handler $ \sae -> throwIO (sae :: SomeAsyncException)
351− , Handler onOtherExc
352− ]
353−
354−decodeHelper :: FromJSON a
355− => ConduitM () Y.Event Parse ()
356− -> IO (Either ParseException ([Warning], Either String a))
357−decodeHelper = mkHelper parse throwIO $ \(v, st) ->
358− Right (parseStateWarnings st, parseEither parseJSON v)
359−
360−decodeAllHelper :: FromJSON a
361− => ConduitM () Event Parse ()
362− -> IO (Either ParseException ([Warning], Either String [a]))
363−decodeAllHelper = mkHelper parseAll throwIO $ \(vs, st) ->
364− Right (parseStateWarnings st, mapM (parseEither parseJSON) vs)
365−
366−catchLeft :: SomeException -> IO (Either ParseException a)
367−catchLeft = return . Left . OtherParseException
368−
369−decodeHelper_ :: FromJSON a
370− => ConduitM () Event Parse ()
371− -> IO (Either ParseException ([Warning], a))
372−decodeHelper_ = mkHelper parse catchLeft $ \(v, st) ->
373− case parseEither parseJSON v of
374− Left e -> Left $ AesonException e
375− Right x -> Right (parseStateWarnings st, x)
376−
377−decodeAllHelper_ :: FromJSON a
378− => ConduitM () Event Parse ()
379− -> IO (Either ParseException ([Warning], [a]))
380−decodeAllHelper_ = mkHelper parseAll catchLeft $ \(vs, st) ->
381− case mapM (parseEither parseJSON) vs of
382− Left e -> Left $ AesonException e
383− Right xs -> Right (parseStateWarnings st, xs)
384−
385−type StringStyle = Text -> ( Tag, Style )
386−
387−-- | Encodes a string with the supplied style. This function handles the empty
388−-- string case properly to avoid https://github.com/snoyberg/yaml/issues/24
389−--
390−-- @since 0.11.2.0
391−stringScalar :: StringStyle -> Maybe Text -> Text -> Event
392−stringScalar _ anchor "" = EventScalar "" NoTag SingleQuoted (T.unpack <$> anchor)
393−stringScalar stringStyle anchor s = EventScalar (encodeUtf8 s) tag style (T.unpack <$> anchor)
394− where
395− ( tag, style ) = stringStyle s
396−
397−-- |
398−-- @since 0.11.2.0
399−defaultStringStyle :: StringStyle
400−defaultStringStyle = \s ->
401− case () of
402− ()
403− | "\n" `T.isInfixOf` s -> ( NoTag, Literal )
404− | isSpecialString s -> ( NoTag, SingleQuoted )
405− | otherwise -> ( NoTag, PlainNoTag )
406−
407−-- | Determine whether a string must be quoted in YAML and can't appear as plain text.
408−-- Useful if you want to use 'setStringStyle'.
409−--
410−-- @since 0.10.2.0
411−isSpecialString :: Text -> Bool
412−isSpecialString s = s `HashSet.member` specialStrings || isNumeric s
413−
414−-- | Strings which must be escaped so as not to be treated as non-string scalars.
415−--
416−-- @since 0.8.32
417−specialStrings :: HashSet.HashSet Text
418−specialStrings = HashSet.fromList $ T.words
419− "y Y yes Yes YES n N no No NO true True TRUE false False FALSE on On ON off Off OFF null Null NULL ~ *"
420−
421−-- |
422−-- @since 0.8.32
423−isNumeric :: Text -> Bool
424−isNumeric = either (const False) (const True) . textToScientific
425−
426−-- | Encode a value as a YAML document stream.
427−--
428−-- @since 0.11.2.0
429−objToStream :: ToJSON a => StringStyle -> a -> [Y.Event]
430−objToStream stringStyle o =
431− (:) EventStreamStart
432− . (:) EventDocumentStart
433− $ objToEvents stringStyle o
434− [ EventDocumentEnd
435− , EventStreamEnd
436− ]
437−
438−-- | Encode a value as a list of 'Event's.
439−--
440−-- @since 0.11.2.0
441−objToEvents :: ToJSON a => StringStyle -> a -> [Y.Event] -> [Y.Event]
442−objToEvents stringStyle = objToEvents' . toJSON
443− where
444− objToEvents' (Array list) rest =
445− EventSequenceStart NoTag AnySequence Nothing
446− : foldr objToEvents' (EventSequenceEnd : rest) (V.toList list)
447−
448− objToEvents' (Object o) rest =
449− EventMappingStart NoTag AnyMapping Nothing
450− : foldr pairToEvents (EventMappingEnd : rest) (M.toList o)
451− where
452− pairToEvents :: Pair -> [Y.Event] -> [Y.Event]
453− pairToEvents (k, v) = objToEvents' (String $ toText k) . objToEvents' v
454−
455− objToEvents' (String s) rest = stringScalar stringStyle Nothing s : rest
456−
457− objToEvents' Null rest = EventScalar "null" NullTag PlainNoTag Nothing : rest
458−
459− objToEvents' (Bool True) rest = EventScalar "true" BoolTag PlainNoTag Nothing : rest
460− objToEvents' (Bool False) rest = EventScalar "false" BoolTag PlainNoTag Nothing : rest
461−
462− objToEvents' (Number s) rest =
463− let builder
464− -- Special case the 0 exponent to remove the trailing .0
465− | base10Exponent s == 0 = BB.integerDec $ coefficient s
466− | otherwise = scientificBuilder s
467− lbs = BB.toLazyByteString builder
468− bs = BL.toStrict lbs
469− in EventScalar bs IntTag PlainNoTag Nothing : rest
yaml/src/Data/Yaml/Parser.hsdeleted−204
@@ -1,204 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE DeriveDataTypeable #-}
3−{-# LANGUAGE OverloadedStrings #-}
4−-- | NOTE: This module is a highly experimental preview release. It may change
5−-- drastically, or be entirely removed, in a future release.
6−module Data.Yaml.Parser where
7−
8−import Control.Applicative
9−import Control.Exception (Exception)
10−import Control.Monad (MonadPlus (..), liftM, ap)
11−import Control.Monad.Trans.Class (lift)
12−import Control.Monad.Trans.Resource (MonadThrow, throwM)
13−import Control.Monad.Trans.Writer.Strict (tell, WriterT)
14−import Data.ByteString (ByteString)
15−import Data.Conduit
16−import Data.Conduit.Lift (runWriterC)
17−import qualified Data.Map as Map
18−#if !MIN_VERSION_base(4,8,0)
19−import Data.Monoid (Monoid (..))
20−#endif
21−#if !MIN_VERSION_base(4,11,0)
22−import Data.Semigroup (Semigroup(..))
23−#endif
24−import Data.Text (Text, pack, unpack)
25−import Data.Text.Encoding (decodeUtf8)
26−import Data.Text.Read (signed, decimal)
27−import Data.Typeable (Typeable)
28−
29−import Text.Libyaml
30−
31−newtype YamlParser a = YamlParser
32− { unYamlParser :: AnchorMap -> Either Text a
33− }
34−instance Functor YamlParser where
35− fmap = liftM
36−instance Applicative YamlParser where
37− pure = YamlParser . const . Right
38− (<*>) = ap
39−instance Alternative YamlParser where
40− empty = fail "empty"
41− (<|>) = mplus
42−instance Semigroup (YamlParser a) where
43− (<>) = mplus
44−instance Monoid (YamlParser a) where
45− mempty = fail "mempty"
46−#if !MIN_VERSION_base(4,11,0)
47− mappend = (<>)
48−#endif
49−instance Monad YamlParser where
50− return = pure
51− YamlParser f >>= g = YamlParser $ \am ->
52− case f am of
53− Left t -> Left t
54− Right x -> unYamlParser (g x) am
55−#if MIN_VERSION_base(4,13,0)
56−instance MonadFail YamlParser where
57−#endif
58− fail = YamlParser . const . Left . pack
59−instance MonadPlus YamlParser where
60− mzero = fail "mzero"
61− mplus a b = YamlParser $ \am ->
62− case unYamlParser a am of
63− Left _ -> unYamlParser b am
64− x -> x
65−
66−lookupAnchor :: AnchorName -> YamlParser (Maybe YamlValue)
67−lookupAnchor name = YamlParser $ Right . Map.lookup name
68−
69−withAnchor :: AnchorName -> Text -> (YamlValue -> YamlParser a) -> YamlParser a
70−withAnchor name expected f = do
71− mv <- lookupAnchor name
72− case mv of
73− Nothing -> fail $ unpack expected ++ ": unknown alias " ++ name
74− Just v -> f v
75−
76−withMapping :: Text -> ([(Text, YamlValue)] -> YamlParser a) -> YamlValue -> YamlParser a
77−withMapping _ f (Mapping m _) = f m
78−withMapping expected f (Alias an) = withAnchor an expected $ withMapping expected f
79−withMapping expected _ v = typeMismatch expected v
80−
81−withSequence :: Text -> ([YamlValue] -> YamlParser a) -> YamlValue -> YamlParser a
82−withSequence _ f (Sequence s _) = f s
83−withSequence expected f (Alias an) = withAnchor an expected $ withSequence expected f
84−withSequence expected _ v = typeMismatch expected v
85−
86−withText :: Text -> (Text -> YamlParser a) -> YamlValue -> YamlParser a
87−withText _ f (Scalar s _ _ _) = f $ decodeUtf8 s
88−withText expected f (Alias an) = withAnchor an expected $ withText expected f
89−withText expected _ v = typeMismatch expected v
90−
91−typeMismatch :: Text -> YamlValue -> YamlParser a
92−typeMismatch expected v =
93− fail $ concat
94− [ "Expected "
95− , unpack expected
96− , ", but got: "
97− , t
98− ]
99− where
100− t = case v of
101− Mapping _ _ -> "mapping"
102− Sequence _ _ -> "sequence"
103− Scalar _ _ _ _ -> "scalar"
104− Alias _ -> "alias"
105−
106−class FromYaml a where
107− fromYaml :: YamlValue -> YamlParser a
108−instance FromYaml YamlValue where
109− fromYaml = return
110−instance FromYaml a => FromYaml [a] where
111− fromYaml = withSequence "[a]" (mapM fromYaml)
112−instance FromYaml Text where
113− fromYaml = withText "Text" return
114−instance FromYaml Int where
115− fromYaml =
116− withText "Int" go
117− where
118− go t =
119− case signed decimal t of
120− Right (i, "") -> return i
121− _ -> fail $ "Invalid Int: " ++ unpack t
122−
123−data YamlValue
124− = Mapping [(Text, YamlValue)] Anchor
125− | Sequence [YamlValue] Anchor
126− | Scalar ByteString Tag Style Anchor
127− | Alias AnchorName
128− deriving Show
129−
130−type AnchorMap = Map.Map AnchorName YamlValue
131−data RawDoc = RawDoc YamlValue AnchorMap
132− deriving Show
133−
134−parseRawDoc :: (FromYaml a, MonadThrow m) => RawDoc -> m a
135−parseRawDoc (RawDoc val am) =
136− case unYamlParser (fromYaml val) am of
137− Left t -> throwM $ FromYamlException t
138− Right x -> return x
139−
140−(.:) :: FromYaml a => [(Text, YamlValue)] -> Text -> YamlParser a
141−o .: k =
142− case lookup k o of
143− Nothing -> fail $ "Key not found: " ++ unpack k
144− Just v -> fromYaml v
145−
146−data YamlParseException
147− = UnexpectedEndOfEvents
148− | UnexpectedEvent Event
149− | FromYamlException Text
150− deriving (Show, Typeable)
151−instance Exception YamlParseException
152−
153−sinkValue :: MonadThrow m => ConduitM Event o (WriterT AnchorMap m) YamlValue
154−sinkValue =
155− start
156− where
157− start = await >>= maybe (throwM UnexpectedEndOfEvents) go
158−
159− tell' Nothing val = return val
160− tell' (Just name) val = do
161− lift $ tell $ Map.singleton name val
162− return val
163−
164− go EventStreamStart = start
165− go EventDocumentStart = start
166− go (EventAlias a) = return $ Alias a
167− go (EventScalar a b c d) = tell' d $ Scalar a b c d
168− go (EventSequenceStart _tag _style mname) = do
169− vals <- goS id
170− let val = Sequence vals mname
171− tell' mname val
172− go (EventMappingStart _tag _style mname) = do
173− pairs <- goM id
174− let val = Mapping pairs mname
175− tell' mname val
176−
177− go e = throwM $ UnexpectedEvent e
178−
179− goS front = do
180− me <- await
181− case me of
182− Nothing -> throwM UnexpectedEndOfEvents
183− Just EventSequenceEnd -> return $ front []
184− Just e -> do
185− val <- go e
186− goS (front . (val:))
187−
188− goM front = do
189− mk <- await
190− case mk of
191− Nothing -> throwM UnexpectedEndOfEvents
192− Just EventMappingEnd -> return $ front []
193− Just (EventScalar a b c d) -> do
194− _ <- tell' d $ Scalar a b c d
195− let k = decodeUtf8 a
196− v <- start
197− goM (front . ((k, v):))
198− Just e -> throwM $ UnexpectedEvent e
199−
200−sinkRawDoc :: MonadThrow m => ConduitM Event o m RawDoc
201−sinkRawDoc = uncurry RawDoc <$> runWriterC sinkValue
202−
203−readYamlFile :: FromYaml a => FilePath -> IO a
204−readYamlFile fp = runConduitRes (decodeFile fp .| sinkRawDoc) >>= parseRawDoc
yaml/src/Data/Yaml/Pretty.hsdeleted−102
@@ -1,102 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−-- | Prettier YAML encoding.
3−--
4−-- @since 0.8.13
5−module Data.Yaml.Pretty
6− ( encodePretty
7− , Config
8− , getConfCompare
9− , setConfCompare
10− , getConfDropNull
11− , setConfDropNull
12− , defConfig
13− , pretty
14− ) where
15−
16−import Prelude hiding (null)
17−
18−#if !MIN_VERSION_base(4,8,0)
19−import Control.Applicative ((<$>))
20−#endif
21−import Data.Bifunctor (first)
22−#if MIN_VERSION_aeson(2,0,0)
23−import qualified Data.Aeson.Key as K
24−import qualified Data.Aeson.KeyMap as HM
25−#else
26−import qualified Data.HashMap.Strict as HM
27−#endif
28−import Data.Aeson.Types
29−import Data.ByteString (ByteString)
30−import Data.Function (on)
31−import Data.List (sortBy)
32−#if !MIN_VERSION_base(4,8,0)
33−import Data.Monoid
34−#endif
35−import Data.Text (Text)
36−import qualified Data.Vector as V
37−
38−import Data.Yaml.Builder
39−
40−#if MIN_VERSION_aeson(2,0,0)
41−toText :: Key -> Text
42−toText = K.toText
43−#else
44−toText :: Key -> Text
45−toText = id
46−
47−type Key = Text
48−#endif
49−
50−-- |
51−-- @since 0.8.13
52−data Config = Config
53− { confCompare :: Text -> Text -> Ordering -- ^ Function used to sort keys in objects
54− , confDropNull :: Bool -- ^ Drop null values from objects
55− }
56−
57−-- | The default configuration: do not sort objects or drop keys
58−--
59−-- @since 0.8.13
60−defConfig :: Config
61−defConfig = Config mempty False
62−
63−-- |
64−-- @since 0.8.13
65−getConfCompare :: Config -> Text -> Text -> Ordering
66−getConfCompare = confCompare
67−
68−-- | Sets ordering for object keys
69−--
70−-- @since 0.8.13
71−setConfCompare :: (Text -> Text -> Ordering) -> Config -> Config
72−setConfCompare cmp c = c { confCompare = cmp }
73−
74−-- |
75−-- @since 0.8.24
76−getConfDropNull :: Config -> Bool
77−getConfDropNull = confDropNull
78−
79−-- | Drop entries with `Null` value from objects, if set to `True`
80−--
81−-- @since 0.8.24
82−setConfDropNull :: Bool -> Config -> Config
83−setConfDropNull m c = c { confDropNull = m }
84−
85−pretty :: Config -> Value -> YamlBuilder
86−pretty cfg = go
87− where go (Object o) = let sort = sortBy (confCompare cfg `on` fst)
88− select
89− | confDropNull cfg = HM.filter (/= Null)
90− | otherwise = id
91− in mapping (sort $ fmap (first toText) $ HM.toList $ HM.map go $ select o)
92− go (Array a) = array (go <$> V.toList a)
93− go Null = null
94− go (String s) = string s
95− go (Number n) = scientific n
96− go (Bool b) = bool b
97−
98−-- | Configurable 'encode'.
99−--
100−-- @since 0.8.13
101−encodePretty :: ToJSON a => Config -> a -> ByteString
102−encodePretty cfg = toByteString . pretty cfg . toJSON
yaml/src/Data/Yaml/TH.hsdeleted−80
@@ -1,80 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE LambdaCase #-}
3−{-# LANGUAGE ScopedTypeVariables #-}
4−
5−module Data.Yaml.TH
6− ( -- * Decoding
7− yamlQQ
8−#if MIN_VERSION_template_haskell(2,9,0)
9− , decodeFile
10−#endif
11− -- * Re-exports from "Data.Yaml"
12− , Value (..)
13− , Parser
14− , Object
15− , Array
16− , object
17− , array
18− , (.=)
19− , (.:)
20− , (.:?)
21− , (.!=)
22− , FromJSON (..)
23− ) where
24−
25−import Data.Text.Encoding
26−import qualified Data.Text as T
27−import Language.Haskell.TH
28−import Language.Haskell.TH.Syntax
29−import Language.Haskell.TH.Quote
30−
31−import Data.Yaml hiding (decodeFile)
32−
33−-- | Decode a YAML file at compile time. Only available on GHC version @7.8.1@
34−-- or higher.
35−--
36−-- @since 0.8.19.0
37−--
38−-- ==== __Examples__
39−--
40−-- @
41−-- {-\# LANGUAGE TemplateHaskell \#-}
42−--
43−-- config :: Config
44−-- config = $$('decodeFile' "config.yaml")
45−-- @
46−decodeFile :: forall a. (Lift a, FromJSON a) => FilePath -> Q (TExp a)
47−decodeFile path = do
48− addDependentFile path
49− x <- runIO $ decodeFileThrow path
50− fmap TExp (lift (x :: a))
51−
52−yamlExp :: String -> Q Exp
53−yamlExp input = do
54− val <- runIO $ decodeThrow $ encodeUtf8 $ T.pack input
55− lift (val :: Value)
56−
57−-- | A @QuasiQuoter@ for YAML.
58−--
59−-- @since 0.8.28.0
60−--
61−-- ==== __Examples__
62−--
63−-- @
64−-- {-\# LANGUAGE QuasiQuotes \#-}
65−-- import Data.Yaml.TH
66−--
67−-- value :: Value
68−-- value = [yamlQQ|
69−-- name: John Doe
70−-- age: 23
71−-- |]
72−-- @
73−yamlQQ :: QuasiQuoter
74−yamlQQ = QuasiQuoter {
75− quoteExp = yamlExp
76−, quotePat = notDefined "quotePat"
77−, quoteType = notDefined "quoteType"
78−, quoteDec = notDefined "quoteDec"
79−} where
80− notDefined name _ = fail (name ++ " is not defined for yamlQQ")
yaml/test/Data/Yaml/IncludeSpec.hsdeleted−139
@@ -1,139 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE QuasiQuotes #-}
3−{-# LANGUAGE OverloadedStrings #-}
4−module Data.Yaml.IncludeSpec (main, spec) where
5−
6−import Test.Hspec
7−import Data.List (isPrefixOf)
8−import qualified Data.ByteString.Lazy as LB
9−import Data.Aeson
10−#if MIN_VERSION_aeson(2,2,0)
11−import Data.Aeson.Types (JSONPathElement(..))
12−#else
13−import Data.Aeson.Internal (JSONPathElement(..))
14−#endif
15−import Data.Yaml (ParseException(InvalidYaml))
16−import Data.Yaml.Include
17−import Data.Yaml.Internal
18−import Text.Libyaml (YamlException(YamlException))
19−import Test.Mockery.Directory
20−import Text.RawString.QQ
21−import Data.Yaml.TH (yamlQQ)
22−
23−main :: IO ()
24−main = hspec spec
25−
26−asInt :: Int -> Int
27−asInt = id
28−
29−spec :: Spec
30−spec = do
31− describe "decodeFile" $ do
32− it "supports includes" $ do
33− decodeFile "test/resources/foo.yaml" `shouldReturn` Just (object
34− [ "foo" .= asInt 23
35− , "bar" .= object
36− [ "one" .= asInt 1
37− , "two" .= asInt 2
38− ]
39− , "baz" .= asInt 42
40− ])
41−
42− it "supports recursive includes" $ do
43− decodeFile "test/resources/baz.yaml" `shouldReturn` Just (object
44− [ "foo" .= object
45− [ "foo" .= asInt 23
46− , "bar" .= object
47− [ "one" .= asInt 1
48− , "two" .= asInt 2
49− ]
50− , "baz" .= asInt 42
51− ]
52− ])
53−
54− it "aborts on cyclic includes" $ do
55− (decodeFile "test/resources/loop/foo.yaml" :: IO (Maybe Value)) `shouldThrow` anyException
56−
57− context "when file does not exist" $ do
58− it "throws Left (InvalidYaml (Just (YamlException \"Yaml file not found: ...\")))" $ do
59− (decodeFile "./does_not_exist.yaml" :: IO (Maybe Value)) `shouldThrow` isYamlFileNotFoundException
60−
61− context "with a 1K stack size limit" $ around_ inTempDirectory $ do
62− context "with a large list" $ do
63− it "succeeds" $ do
64− let
65− xs :: [Value]
66− xs = replicate 5000 (Number 23)
67− LB.writeFile "foo.yaml" (encode xs)
68− decodeFile "foo.yaml" `shouldReturn` Just xs
69−
70− describe "decodeFileEither" $ do
71− context "when file does not exist" $ do
72− it "returns Left (InvalidYaml (Just (YamlException \"Yaml file not found: ...\")))" $ do
73− (decodeFileEither "./does_not_exist.yaml" :: IO (Either ParseException Value)) >>=
74− (`shouldSatisfy` either isYamlFileNotFoundException (const False))
75−
76− describe "decodeFileWithWarnings" $ around_ inTempDirectory $ do
77− it "warns on duplicate keys" $ do
78− writeFile "foo.yaml" [r|
79− foo: 23
80− foo: bar
81− |]
82− Right result <- decodeFileWithWarnings "foo.yaml"
83− result `shouldBe` ([DuplicateKey [Key "foo"]], [yamlQQ|
84− foo: bar
85− |])
86−
87− it "warns on nested duplicate keys" $ do
88− writeFile "foo.yaml" [r|
89− foo:
90− - 42
91− - bar: 23
92− bar: baz
93− |]
94− Right result <- decodeFileWithWarnings "foo.yaml"
95− result `shouldBe` ([DuplicateKey [Key "foo", Index 1, Key "bar"]], [yamlQQ|
96− foo:
97− - 42
98− - bar: baz
99− |])
100−
101− context "when overriding a merged key" $ do
102− it "does not warn" $ do
103− writeFile "foo.yaml" [r|
104− foo-1: &my-ref
105− bar: 23
106− foo-2:
107− <<: *my-ref
108− bar: 42
109− |]
110− Right result <- decodeFileWithWarnings "foo.yaml"
111− result `shouldBe` ([], [yamlQQ|
112− foo-1:
113− bar: 23
114− foo-2:
115− bar: 42
116− |])
117−
118− context "when overriding twice" $ do
119− it "warns" $ do
120− writeFile "foo.yaml" [r|
121− foo-1: &my-ref
122− bar: 23
123− foo-2:
124− <<: *my-ref
125− bar: 42
126− bar: 65
127− |]
128− Right result <- decodeFileWithWarnings "foo.yaml"
129− result `shouldBe` ([DuplicateKey [Key "foo-2", Key "bar"]], [yamlQQ|
130− foo-1:
131− bar: 23
132− foo-2:
133− bar: 65
134− |])
135−
136−isYamlFileNotFoundException :: ParseException -> Bool
137−isYamlFileNotFoundException (InvalidYaml (Just (YamlException msg)))
138− | "Yaml file not found: " `isPrefixOf` msg = True
139−isYamlFileNotFoundException _ = False
yaml/test/Data/Yaml/THSpec.hsdeleted−17
@@ -1,17 +0,0 @@
1−{-# LANGUAGE OverloadedStrings #-}
2−{-# LANGUAGE QuasiQuotes #-}
3−module Data.Yaml.THSpec (spec) where
4−
5−import Test.Hspec
6−import Data.Aeson
7−
8−import Data.Yaml.TH
9−
10−spec :: Spec
11−spec = do
12− describe "yamlQQ" $ do
13− it "parses yaml" $ do
14− [yamlQQ|
15− name: John Doe
16− age: 23
17− |] `shouldBe` object ["name" .= String "John Doe", "age" .= Number 23]
yaml/test/Data/YamlSpec.hsdeleted−899
@@ -1,899 +0,0 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE PackageImports #-}
3−{-# LANGUAGE ScopedTypeVariables #-}
4−{-# LANGUAGE OverloadedStrings #-}
5−{-# LANGUAGE TemplateHaskell #-}
6−{-# LANGUAGE TupleSections #-}
7−
8−module Data.YamlSpec (main, spec) where
9−
10−import qualified Text.Libyaml as Y
11−import qualified Data.ByteString as BS
12−import qualified Data.ByteString.Char8 as B8
13−import Data.Int (Int64)
14−import qualified Data.Scientific as S
15−
16−import Test.HUnit hiding (Test, path)
17−
18−import Data.Conduit (runConduitRes, (.|), ConduitM)
19−import qualified Data.Conduit.List as CL
20−
21−import Control.Monad
22−import Control.Exception (try, SomeException)
23−import Test.Hspec
24−import Test.Hspec.QuickCheck
25−import Data.Either.Compat
26−import System.Directory (createDirectory, createDirectoryIfMissing)
27−import Test.Mockery.Directory
28−
29−import qualified Data.Yaml as D
30−import qualified Data.Yaml.Builder as B
31−import qualified Data.Yaml.Internal as Internal
32−import qualified Data.Yaml.Pretty as Pretty
33−import Data.Yaml (object, array, (.=))
34−import Data.Maybe
35−import qualified Data.HashMap.Strict as HM
36−#if MIN_VERSION_aeson(2,0,0)
37−import qualified Data.Aeson.KeyMap as M
38−import qualified Data.Aeson.Key as K
39−import Data.Aeson.KeyMap (KeyMap)
40−#else
41−import qualified Data.HashMap.Strict as M
42−#endif
43−import qualified Data.Text as T
44−import Data.Aeson.TH
45−import Data.Scientific (Scientific)
46−import Data.String (fromString)
47−import Data.Text (Text)
48−import Data.Text.Encoding (decodeUtf8, encodeUtf8)
49−import Data.Vector (Vector)
50−import qualified Data.Vector as V
51−import Data.HashMap.Strict (HashMap)
52−import qualified Data.HashMap.Strict as HM
53−import System.IO (hClose)
54−import System.IO.Temp (withSystemTempFile)
55−
56−#if MIN_VERSION_aeson(2,0,0)
57−fromText :: T.Text -> K.Key
58−fromText = K.fromText
59−
60−toText :: K.Key -> T.Text
61−toText = K.toText
62−#else
63−fromText :: T.Text -> T.Text
64−fromText = id
65−
66−toText :: Key -> T.Text
67−toText = id
68−
69−type KeyMap a = M.HashMap Text a
70−type Key = Text
71−#endif
72−
73−data TestJSON = TestJSON
74− { string :: Text
75− , number :: Int
76− , anArray :: Vector Text
77− , hash :: HashMap Text Text
78− , extrastring :: Text
79− } deriving (Show, Eq)
80−
81−deriveJSON defaultOptions ''TestJSON
82−
83−testJSON :: TestJSON
84−testJSON = TestJSON
85− { string = "str"
86− , number = 2
87− , anArray = V.fromList ["a", "b"]
88− , hash = HM.fromList [("key1", "value1"), ("key2", "value2")]
89− , extrastring = "1234-foo"
90− }
91−
92−shouldDecode :: (Show a, D.FromJSON a, Eq a) => B8.ByteString -> a -> IO ()
93−shouldDecode bs expected = do
94− actual <- D.decodeThrow bs
95− actual `shouldBe` expected
96−
97−shouldDecodeAll :: (Show a, D.FromJSON a, Eq a) => B8.ByteString -> [a] -> IO ()
98−shouldDecodeAll bs expected = do
99− actual <- D.decodeAllThrow bs
100− actual `shouldBe` expected
101−
102−shouldDecodeEvents :: B8.ByteString -> [Y.Event] -> IO ()
103−shouldDecodeEvents bs expected = do
104− actual <- runConduitRes $ Y.decode bs .| CL.consume
105− map anyStyle actual `shouldBe` map anyStyle expected
106−
107−anyStyle :: Y.Event -> Y.Event
108−anyStyle (Y.EventScalar bs tag _ anchor) = Y.EventScalar bs tag Y.Any anchor
109−anyStyle (Y.EventSequenceStart tag _ anchor) = Y.EventSequenceStart tag Y.AnySequence anchor
110−anyStyle (Y.EventMappingStart tag _ anchor) = Y.EventMappingStart tag Y.AnyMapping anchor
111−anyStyle event = event
112−
113−testEncodeWith :: Y.FormatOptions -> [Y.Event] -> IO BS.ByteString
114−testEncodeWith opts es = runConduitRes $ CL.sourceList (eventStream es) .| Y.encodeWith opts
115−
116−eventStream :: [Y.Event] -> [Y.Event]
117−eventStream events =
118− [Y.EventStreamStart, Y.EventDocumentStart]
119− ++ events
120− ++ [Y.EventDocumentEnd, Y.EventStreamEnd]
121−
122−main :: IO ()
123−main = hspec spec
124−
125−spec :: Spec
126−spec = do
127− describe "streaming" $ do
128− it "count scalars with anchor" caseCountScalarsWithAnchor
129− it "count sequences with anchor" caseCountSequencesWithAnchor
130− it "count mappings with anchor" caseCountMappingsWithAnchor
131− it "count sequences with custom tag" caseCountSequenceTags
132− it "count mappings with custom tag" caseCountMappingTags
133− it "count count sequences with ! tag" caseCountEmptySequenceTags
134− it "count count mappings with ! tag" caseCountEmptyMappingTags
135− it "count block style sequences" caseCountBlockStyleSequences
136− it "count flow style sequences" caseCountFlowStyleSequences
137− it "count block style mappings" caseCountBlockStyleMappings
138− it "count flow style mappings" caseCountFlowStyleMappings
139− it "count aliases" caseCountAliases
140− it "count scalars" caseCountScalars
141− it "largest string" caseLargestString
142− it "encode/decode" caseEncodeDecode
143− it "encode/decode events" caseEncodeDecodeEvents
144− it "encode/decode file" caseEncodeDecodeFile
145− it "interleaved encode/decode" caseInterleave
146− it "decode invalid document (without segfault)" caseDecodeInvalidDocument
147− describe "Data.Yaml" $ do
148− it "encode/decode" caseEncodeDecodeData
149− it "encode/decode file" caseEncodeDecodeFileData
150− it "encode/decode files with non-ASCII names" caseEncodeDecodeNonAsciiFileData
151− it "encode/decode strings" caseEncodeDecodeStrings
152− it "decode invalid file" caseDecodeInvalid
153− it "processes datatypes" caseDataTypes
154− it "encode invalid numbers" caseEncodeInvalidNumbers
155− describe "Data.Yaml.Pretty" $ do
156− it "encode/decode" caseEncodeDecodeDataPretty
157− it "encode/decode strings" caseEncodeDecodeStringsPretty
158− it "processes datatypes" caseDataTypesPretty
159− describe "Data.Yaml.Builder" $ do
160− it "encode/decode" caseEncodeDecodeDataBuilder
161− it "encode/decode complex mapping" caseEncodeDecodeComplexMappingBuilder
162− describe "Data.Yaml aliases" $ do
163− it "simple scalar alias" caseSimpleScalarAlias
164− it "simple sequence alias" caseSimpleSequenceAlias
165− it "simple mapping alias" caseSimpleMappingAlias
166− it "mapping alias before anchor" caseMappingAliasBeforeAnchor
167− it "mapping alias inside anchor" caseMappingAliasInsideAnchor
168− it "scalar alias overriding" caseScalarAliasOverriding
169− describe "Data.Yaml merge keys" $ do
170− it "test uniqueness of keys" caseAllKeysShouldBeUnique
171− it "test mapping merge" caseSimpleMappingMerge
172− it "test sequence of mappings merging" caseMergeSequence
173− describe "numbers" $ do
174− it "parses as string when quoted" caseQuotedNumber
175− it "parses as number when unquoted" caseUnquotedNumber
176− it "parses as number !!str is present" caseAttribNumber
177− it "integers have no decimals" caseIntegerDecimals
178− describe "booleans" $ do
179− it "parses when all lowercase" caseLowercaseBool
180− it "parses when all uppercase" caseUppercaseBool
181− it "parses when titlecase" caseTitlecaseBool
182− describe "empty input" $ do
183− it "parses as Null" caseEmptyInput
184− it "parses as Null from file" caseEmptyInputFile
185− describe "comment only input" $ do
186− it "parses as Null" caseCommentOnlyInput
187− it "parses as Null from file" caseCommentOnlyInputFile
188− describe "alias stripping" $ do
189− it "works" caseStripAlias
190− describe "nulls" $ do
191− checkNull "null"
192− checkNull "Null"
193− checkNull "NULL"
194− checkNull "~"
195− checkNull ""
196−
197− describe "pretty output" $ do
198− it "simple nulls" $ D.encode (object ["foo" .= D.Null]) `shouldBe` "foo: null\n"
199− it "simple numbers" $ D.encode (object ["foo" .= (4 :: Int)]) `shouldBe` "foo: 4\n"
200− it "True" $ D.encode (object ["foo" .= True]) `shouldBe` "foo: true\n"
201− it "False" $ D.encode (object ["foo" .= False]) `shouldBe` "foo: false\n"
202− it "simple string" $ D.encode (object ["foo" .= ("bar" :: T.Text)]) `shouldBe` "foo: bar\n"
203− it "*" $ D.encode (object ["foo" .= ("*" :: T.Text)]) `shouldBe` "foo: '*'\n"
204−
205− describe "special keys" $ do
206− let tester key = it (T.unpack key) $
207− let value = object [fromText key .= True]
208− in D.encode value `shouldDecode` value
209− mapM_ tester specialStrings
210−
211− describe "special values" $ do
212− let tester value = it (T.unpack value) $
213− let value' = object ["foo" .= value]
214− in D.encode value' `shouldDecode` value'
215− mapM_ tester specialStrings
216−
217− describe "decodeFileEither" $ do
218− it "loads YAML through JSON into Haskell data" $ do
219− tj <- either (error . show) id `fmap` D.decodeFileEither "test/json.yaml"
220− tj `shouldBe` testJSON
221−
222− context "when file does not exist" $ do
223− it "returns Left" $ do
224− (D.decodeFileEither "./does_not_exist.yaml" :: IO (Either D.ParseException D.Value)) >>= (`shouldSatisfy` isLeft)
225−
226− describe "multiple document support" $ do
227− it "decodes zero-length input" $
228− "" `shouldDecodeAll` ([] :: [D.Value])
229− it "decodes comment-only input" $
230− "# foo\n# bar" `shouldDecodeAll` ([] :: [D.Value])
231− it "decodes a single document stream" $
232− "foo: true" `shouldDecodeAll` [object ["foo" .= True]]
233− it "decodes multiple documents" $
234− "--- 1\n--- 2" `shouldDecodeAll` [D.Number 1, D.Number 2]
235−
236− describe "round-tripping of special scalars" $ do
237− let special = words "y Y On ON false 12345 12345.0 12345a 12e3"
238− forM_ special $ \w -> it w $
239− let v = object ["word" .= w]
240− in D.encode v `shouldDecode` v
241− it "no tags" $ D.encode (object ["word" .= ("true" :: String)]) `shouldBe` "word: 'true'\n"
242−
243− it "aliases in keys #49" caseIssue49
244−
245− it "serialization of +123 #64" $ do
246− D.encode ("+123" :: String) `shouldDecode` ("+123" :: String)
247−
248− it "preserves Scientific precision" casePreservesScientificPrecision
249−
250− it "truncates files" caseTruncatesFiles
251−
252− it "encode quotes special keys #137" $ caseSpecialKeys D.encode
253−
254− it "encodePretty quotes special keys #179" $ caseSpecialKeys (Pretty.encodePretty Pretty.defConfig)
255−
256− describe "non-decimal numbers #135" $ do
257− let go str val = it str $ encodeUtf8 (T.pack str) `shouldDecode` val
258− go "12345" (12345 :: Int)
259− go "+12345" (12345 :: Int)
260− go "0o14" (12 :: Int)
261− go "0o123" (83 :: Int)
262− go "0xC" (12 :: Int)
263− go "0xc" (12 :: Int)
264− go "0xdeadBEEF" (3735928559 :: Int64)
265− go "0xDEADBEEF" (3735928559 :: Int64)
266− go "1.23015e+3" (1230.15 :: Scientific)
267− go "12.3015e+02" (1230.15 :: Scientific)
268− go "1230.15" (1230.15 :: Scientific)
269−
270− describe "Text.Libyaml with default tag rendering" $ do
271− let enc = testEncodeWith Y.defaultFormatOptions
272− it "elides custom sequence tags" $
273− enc taggedSequence `shouldReturn` "[]\n"
274− it "elides custom mapping tags" $
275− enc taggedMapping `shouldReturn` "{}\n"
276− it "elides default sequence tags" $
277− enc defaultTaggedSequence `shouldReturn` "[]\n"
278− it "elides default mapping tags" $
279− enc defaultTaggedMapping `shouldReturn` "{}\n"
280− it "handles NoTag on sequences" $
281− enc untaggedSequence `shouldReturn` "[]\n"
282− it "handles NoTag on mappings" $
283− enc untaggedMapping `shouldReturn` "{}\n"
284− it "handles mixed tag usages but elides all mapping and sequence tags" $
285− enc mixedTagSampleA `shouldReturn` "- {}\n"
286− it "in combination of tags, anchors and styles, outputs only the scalar tags" $
287− enc mixedTagSampleB `shouldReturn` "&a\n&b !<bar> foo: &c [&d !!null '']\n"
288− it "outputs tags when double quoted" $
289− enc [Y.EventScalar "foo" Y.StrTag Y.DoubleQuoted Nothing] `shouldReturn` "!!str \"foo\"\n"
290− it "outputs tags when single quoted" $
291− enc [Y.EventScalar "foo" Y.StrTag Y.SingleQuoted Nothing] `shouldReturn` "!!str 'foo'\n"
292− it "outputs tags on literal text" $
293− enc [Y.EventScalar "foo" Y.StrTag Y.Literal Nothing] `shouldReturn` "!!str |-\n foo\n"
294− it "outputs tags on folded text" $
295− enc [Y.EventScalar "foo" Y.StrTag Y.Folded Nothing] `shouldReturn` "!!str >-\n foo\n"
296− describe "Text.Libyaml with all tags on" $ do
297− let enc = testEncodeWith $ Y.setTagRendering Y.renderAllTags Y.defaultFormatOptions
298− it "will output custom sequence tags" $
299− enc taggedSequence `shouldReturn` "!foo []\n"
300− it "will output custom mapping tags" $
301− enc taggedMapping `shouldReturn` "!foo {}\n"
302− it "will output default sequence tags" $
303− enc defaultTaggedSequence `shouldReturn` "!!seq []\n"
304− it "will output default mapping tags" $
305− enc defaultTaggedMapping `shouldReturn` "!!map {}\n"
306− it "handles NoTag on sequences" $
307− enc untaggedSequence `shouldReturn` "[]\n"
308− it "handles NoTag on mappings" $
309− enc untaggedMapping `shouldReturn` "{}\n"
310− it "handles mixed tag usages outputting all mapping and sequence tags" $
311− enc mixedTagSampleA `shouldReturn` "- !foo {}\n"
312− it "in combination of tags, anchors and styles, outputs all the tags" $
313− enc mixedTagSampleB `shouldReturn` "&a\n&b !<bar> foo: &c !baz [&d !!null '']\n"
314− it "outputs plain tags" $
315− enc [Y.EventScalar "foo" Y.StrTag Y.Plain Nothing] `shouldReturn` "!!str foo\n"
316− it "respects PlainNoTag tags" $
317− enc [Y.EventScalar "foo" Y.StrTag Y.PlainNoTag Nothing] `shouldReturn` "foo\n"
318− describe "Text.Libyaml with uri tags on" $ do
319− let enc = testEncodeWith $ Y.setTagRendering Y.renderUriTags Y.defaultFormatOptions
320− it "will output custom sequence tags" $
321− enc taggedSequence `shouldReturn` "!foo []\n"
322− it "will output custom mapping tags" $
323− enc taggedMapping `shouldReturn` "!foo {}\n"
324− it "will output default sequence tags" $
325− enc defaultTaggedSequence `shouldReturn` "[]\n"
326− it "will output default mapping tags" $
327− enc defaultTaggedMapping `shouldReturn` "{}\n"
328− it "handles NoTag on sequences" $
329− enc untaggedSequence `shouldReturn` "[]\n"
330− it "handles NoTag on mappings" $
331− enc untaggedMapping `shouldReturn` "{}\n"
332− it "handles mixed tag usages outputting all mapping and sequence tags" $
333− enc mixedTagSampleA `shouldReturn` "- !foo {}\n"
334− it "in combination of tags, anchors and styles, outputs all the tags" $
335− enc mixedTagSampleB `shouldReturn` "&a\n&b !<bar> foo: &c !baz [&d '']\n"
336− describe "Text.Libyaml with tags off" $ do
337− let enc = testEncodeWith $ Y.setTagRendering Y.renderNoTags Y.defaultFormatOptions
338− it "outputs plain tags" $
339− enc [Y.EventScalar "foo" Y.StrTag Y.Plain Nothing] `shouldReturn` "foo\n"
340− it "respects PlainNoTag tags" $
341− enc [Y.EventScalar "foo" Y.StrTag Y.PlainNoTag Nothing] `shouldReturn` "foo\n"
342− it "elides tags when double quoted" $
343− enc [Y.EventScalar "foo" Y.StrTag Y.DoubleQuoted Nothing] `shouldReturn` "\"foo\"\n"
344− it "elides tags when single quoted" $
345− enc [Y.EventScalar "foo" Y.StrTag Y.SingleQuoted Nothing] `shouldReturn` "'foo'\n"
346− it "elides tags on literal text" $
347− enc [Y.EventScalar "foo" Y.StrTag Y.Literal Nothing] `shouldReturn` "|-\n foo\n"
348− it "elides tags on folded text" $
349− enc [Y.EventScalar "foo" Y.StrTag Y.Folded Nothing] `shouldReturn` ">-\n foo\n"
350− describe "Text.Libyaml with only UriTags set to render " $ do
351− let enc =
352− testEncodeWith $
353− Y.setTagRendering Y.renderUriTags $ Y.defaultFormatOptions
354− it "outputs only UriTags" $
355− enc
356− [ Y.EventSequenceStart Y.NoTag Y.FlowSequence Nothing
357− , Y.EventScalar "foo" Y.StrTag Y.DoubleQuoted Nothing
358− , Y.EventScalar "99" Y.IntTag Y.Plain Nothing
359− , Y.EventScalar "99.99" Y.FloatTag Y.Plain Nothing
360− , Y.EventScalar "bar" Y.NoTag Y.Plain Nothing
361− , Y.EventScalar "foo" (Y.UriTag "!foo") Y.DoubleQuoted Nothing
362− , Y.EventScalar "foo" (Y.UriTag "!foo") Y.Plain Nothing
363− , Y.EventSequenceEnd
364− ] `shouldReturn`
365− "[\"foo\", 99, 99.99, bar, !foo \"foo\", !foo foo]\n"
366−
367− prop "Scientific values round-trip" $ \coeff expon -> do
368− let val = D.Number $ S.scientific coeff expon
369− let rendered = D.encode val
370− case D.decodeEither' rendered of
371− Left e -> error $ show (coeff, expon, e)
372− Right val' -> val' `shouldBe` val
373−
374−specialStrings :: [T.Text]
375−specialStrings =
376− [ "fo\"o"
377− , "fo\'o"
378− , "fo\\'o"
379− , "fo: o"
380− , "foo\nbar\nbaz\n"
381− ]
382−
383−counter :: Monad m => (Y.Event -> Bool) -> ConduitM Y.Event o m Int
384−counter pred' =
385− CL.fold (\cnt e -> (if pred' e then 1 else 0) + cnt) 0
386−
387−caseHelper :: String
388− -> (Y.Event -> Bool)
389− -> Int
390− -> Assertion
391−caseHelper yamlString pred' expRes = do
392− res <- runConduitRes $ Y.decode (B8.pack yamlString) .| counter pred'
393− res @?= expRes
394−
395−caseCountScalarsWithAnchor :: Assertion
396−caseCountScalarsWithAnchor =
397− caseHelper yamlString isScalarA 1
398− where
399− yamlString = "foo:\n - &anchor bin1\n - bin2\n - bin3"
400− isScalarA (Y.EventScalar _ _ _ (Just _)) = True
401− isScalarA _ = False
402−
403−caseCountSequencesWithAnchor :: Assertion
404−caseCountSequencesWithAnchor =
405− caseHelper yamlString isSequenceStartA 1
406− where
407− yamlString = "foo: &anchor\n - bin1\n - bin2\n - bin3"
408− isSequenceStartA (Y.EventSequenceStart Y.NoTag _ (Just _)) = True
409− isSequenceStartA _ = False
410−
411−caseCountMappingsWithAnchor :: Assertion
412−caseCountMappingsWithAnchor =
413− caseHelper yamlString isMappingA 1
414− where
415− yamlString = "foo: &anchor\n key1: bin1\n key2: bin2\n key3: bin3"
416− isMappingA (Y.EventMappingStart _ _ (Just _)) = True
417− isMappingA _ = False
418−
419−caseCountAliases :: Assertion
420−caseCountAliases =
421− caseHelper yamlString isAlias 1
422− where
423− yamlString = "foo: &anchor\n key1: bin1\n key2: bin2\n key3: bin3\nboo: *anchor"
424− isAlias Y.EventAlias{} = True
425− isAlias _ = False
426−
427−caseCountMappingTags :: Assertion
428−caseCountMappingTags =
429− caseHelper yamlString isCustomTaggedMapping 1
430− where
431− yamlString = "foo: !bar\n k: v\n k2: v2"
432− isCustomTaggedMapping (Y.EventMappingStart (Y.UriTag "!bar") _ _) = True
433− isCustomTaggedMapping _ = False
434−
435−caseCountEmptyMappingTags :: Assertion
436−caseCountEmptyMappingTags =
437− caseHelper yamlString isCustomTaggedMapping 1
438− where
439− yamlString = "foo: !\n k: v\n k2: v2"
440− isCustomTaggedMapping (Y.EventMappingStart (Y.UriTag "!") _ _) = True
441− isCustomTaggedMapping _ = False
442−
443−caseCountSequenceTags :: Assertion
444−caseCountSequenceTags =
445− caseHelper yamlString isCustomTaggedSequence 1
446− where
447− yamlString = "foo: !bar [x, y, z]"
448− isCustomTaggedSequence (Y.EventSequenceStart (Y.UriTag "!bar") _ _) = True
449− isCustomTaggedSequence _ = False
450−
451−caseCountEmptySequenceTags :: Assertion
452−caseCountEmptySequenceTags =
453− caseHelper yamlString isCustomTaggedSequence 1
454− where
455− yamlString = "foo: ! [x, y, z]"
456− isCustomTaggedSequence (Y.EventSequenceStart (Y.UriTag "!") _ _) = True
457− isCustomTaggedSequence _ = False
458−
459−caseCountFlowStyleSequences :: Assertion
460−caseCountFlowStyleSequences =
461− caseHelper yamlString isFlowStyleSequence 1
462− where
463− yamlString = "foo: [x, y, z]"
464− isFlowStyleSequence (Y.EventSequenceStart _ Y.FlowSequence _) = True
465− isFlowStyleSequence _ = False
466−
467−caseCountBlockStyleSequences :: Assertion
468−caseCountBlockStyleSequences =
469− caseHelper yamlString isBlockStyleSequence 1
470− where
471− yamlString = "foo:\n- x\n- y\n- z\n"
472− isBlockStyleSequence (Y.EventSequenceStart _ Y.BlockSequence _) = True
473− isBlockStyleSequence _ = False
474−
475−caseCountFlowStyleMappings :: Assertion
476−caseCountFlowStyleMappings =
477− caseHelper yamlString isFlowStyleMapping 1
478− where
479− yamlString = "foo: { bar: 1, baz: 2 }"
480− isFlowStyleMapping (Y.EventMappingStart _ Y.FlowMapping _) = True
481− isFlowStyleMapping _ = False
482−
483−caseCountBlockStyleMappings :: Assertion
484−caseCountBlockStyleMappings =
485− caseHelper yamlString isBlockStyleMapping 1
486− where
487− yamlString = "foo: bar\nbaz: quux"
488− isBlockStyleMapping (Y.EventMappingStart _ Y.BlockMapping _) = True
489− isBlockStyleMapping _ = False
490−
491−caseCountScalars :: Assertion
492−caseCountScalars = do
493− res <- runConduitRes $ Y.decode yamlBS .| CL.fold adder accum
494− res @?= (7, 1, 2)
495− where
496− yamlString = "foo:\n baz: [bin1, bin2, bin3]\nbaz: bazval"
497− yamlBS = B8.pack yamlString
498− adder (s, l, m) (Y.EventScalar{}) = (s + 1, l, m)
499− adder (s, l, m) (Y.EventSequenceStart{}) = (s, l + 1, m)
500− adder (s, l, m) (Y.EventMappingStart{}) = (s, l, m + 1)
501− adder a _ = a
502− accum = (0, 0, 0) :: (Int, Int, Int)
503−
504−caseLargestString :: Assertion
505−caseLargestString = do
506− res <- runConduitRes $ Y.decodeFile filePath .| CL.fold adder accum
507− res @?= (length expected, expected)
508− where
509− expected = "this one is just a little bit bigger than the others"
510− filePath = "test/largest-string.yaml"
511− adder (i, s) (Y.EventScalar bs _ _ _) =
512− let s' = B8.unpack bs
513− i' = length s'
514− in if i' > i then (i', s') else (i, s)
515− adder acc _ = acc
516− accum = (0, "no strings found")
517−
518−newtype MyEvent = MyEvent Y.Event deriving Show
519−instance Eq MyEvent where
520− (MyEvent (Y.EventScalar s t _ _)) == (MyEvent (Y.EventScalar s' t' _ _)) =
521− s == s' && t == t'
522− MyEvent e1 == MyEvent e2 = e1 == e2
523−
524−caseEncodeDecode :: Assertion
525−caseEncodeDecode = do
526− eList <- runConduitRes $ Y.decode yamlBS .| CL.consume
527− bs <- runConduitRes $ CL.sourceList eList .| Y.encode
528− eList2 <- runConduitRes $ Y.decode bs .| CL.consume
529− map MyEvent eList @=? map MyEvent eList2
530− where
531− yamlString = "foo: bar\nbaz:\n - bin1\n - bin2\n"
532− yamlBS = B8.pack yamlString
533−
534−caseEncodeDecodeEvents :: Assertion
535−caseEncodeDecodeEvents = do
536− let events = Internal.objToEvents D.defaultStringStyle testJSON []
537− result <- Internal.decodeHelper_ . CL.sourceList $ eventStream events
538− let (_, value) = either (error . show) id result
539− value @?= testJSON
540−
541−caseEncodeDecodeFile :: Assertion
542−caseEncodeDecodeFile = withFile "" $ \tmpPath -> do
543− eList <- runConduitRes $ Y.decodeFile filePath .| CL.consume
544− runConduitRes $ CL.sourceList eList .| Y.encodeFile tmpPath
545− eList2 <- runConduitRes $ Y.decodeFile filePath .| CL.consume
546− map MyEvent eList @=? map MyEvent eList2
547− where
548− filePath = "test/largest-string.yaml"
549−
550−caseInterleave :: Assertion
551−caseInterleave = withFile "" $ \tmpPath -> withFile "" $ \tmpPath2 -> do
552− () <- runConduitRes $ Y.decodeFile filePath .| Y.encodeFile tmpPath
553− () <- runConduitRes $ Y.decodeFile tmpPath .| Y.encodeFile tmpPath2
554− f1 <- readFile tmpPath
555− f2 <- readFile tmpPath2
556− f1 @=? f2
557− where
558− filePath = "test/largest-string.yaml"
559−
560−caseDecodeInvalidDocument :: Assertion
561−caseDecodeInvalidDocument = do
562− x <- try $ runConduitRes $ Y.decode yamlBS .| CL.sinkNull
563− case x of
564− Left (_ :: SomeException) -> return ()
565− Right y -> do
566− putStrLn $ "bad return value: " ++ show y
567− assertFailure "expected parsing exception, but got no errors"
568− where
569− yamlString = " - foo\n - baz\nbuz"
570− yamlBS = B8.pack yamlString
571−
572−mkScalar :: String -> D.Value
573−mkScalar = mkStrScalar
574−
575−mkStrScalar :: String -> D.Value
576−mkStrScalar = D.String . T.pack
577−
578−mappingKey :: D.Value-> String -> D.Value
579−mappingKey (D.Object m) k = (fromJust . M.lookup (fromText $ T.pack k) $ m)
580−mappingKey _ _ = error "expected Object"
581−
582−sample :: D.Value
583−sample = array
584− [ D.String "foo"
585− , object
586− [ ("bar1", D.String "bar2")
587− , ("bar3", D.String "")
588− ]
589− , D.String ""
590− , D.Number 1
591− , D.Number 0.1
592− , D.Bool True
593− , D.Null
594− ]
595−
596−sampleBuilder :: B.YamlBuilder
597−sampleBuilder = B.array
598− [ B.string "foo"
599− , B.mapping
600− [ ("bar1", B.string "bar2")
601− , ("bar3", B.string "")
602− ]
603− , B.string ""
604− , B.scientific 1
605− , B.scientific 0.1
606− , B.bool True
607− , B.null
608− ]
609−
610−caseEncodeDecodeData :: Assertion
611−caseEncodeDecodeData = D.encode sample `shouldDecode` sample
612−
613−caseEncodeDecodeDataPretty :: Assertion
614−caseEncodeDecodeDataPretty =
615− Pretty.encodePretty Pretty.defConfig sample `shouldDecode` sample
616−
617−caseEncodeDecodeDataBuilder :: Assertion
618−caseEncodeDecodeDataBuilder = do
619− let events = B.unYamlBuilder sampleBuilder []
620− bs <- testEncodeWith Y.defaultFormatOptions events
621− bs `shouldDecodeEvents` eventStream events
622−
623−caseEncodeDecodeComplexMappingBuilder :: Assertion
624−caseEncodeDecodeComplexMappingBuilder = do
625− let events = B.unYamlBuilder builder []
626− bs <- testEncodeWith Y.defaultFormatOptions events
627− bs `shouldDecodeEvents` eventStream events
628− where
629− builder :: B.YamlBuilder
630− builder = B.mappingComplex
631− [ ( B.mapping
632− [ ("foo", B.scientific 1)
633− , ("bar", B.scientific 2)
634− ]
635− , B.bool True
636− )
637− ]
638−
639−caseEncodeDecodeFileData :: Assertion
640−caseEncodeDecodeFileData = withFile "" $ \fp -> do
641− D.encodeFile fp sample
642− out <- D.decodeFileThrow fp
643− out @?= sample
644−
645−caseEncodeDecodeNonAsciiFileData :: Assertion
646−caseEncodeDecodeNonAsciiFileData = do
647− let mySample = (object ["foo" .= True])
648− inTempDirectory $ do
649− createDirectory "accenté"
650− D.encodeFile "accenté/bar.yaml" mySample
651− out1 <- D.decodeFileThrow "accenté/bar.yaml"
652− out1 @?= mySample
653−
654− c <- readFile "test/resources/accent/foo.yaml"
655− inTempDirectory $ do
656− createDirectoryIfMissing True "test/resources/unicode/accenté/"
657− writeFile "test/resources/unicode/accenté/foo.yaml" c
658− out2 <- D.decodeFileThrow "test/resources/unicode/accenté/foo.yaml"
659− out2 @?= mySample
660−
661−caseEncodeDecodeStrings :: Assertion
662−caseEncodeDecodeStrings = D.encode sample `shouldDecode` sample
663−
664−caseEncodeDecodeStringsPretty :: Assertion
665−caseEncodeDecodeStringsPretty =
666− Pretty.encodePretty Pretty.defConfig sample `shouldDecode` sample
667−
668−caseDecodeInvalid :: Assertion
669−caseDecodeInvalid =
670− D.decodeThrow "\tthis is 'not' valid :-)" `shouldBe`
671− (Nothing :: Maybe D.Value)
672−
673−caseSimpleScalarAlias :: Assertion
674−caseSimpleScalarAlias =
675− "- &anch foo\n- baz\n- *anch" `shouldDecode`
676− array [(mkScalar "foo"), (mkScalar "baz"), (mkScalar "foo")]
677−
678−caseSimpleSequenceAlias :: Assertion
679−caseSimpleSequenceAlias =
680− "seq: &anch\n - foo\n - baz\nseq2: *anch" `shouldDecode`
681− object [("seq", array [(mkScalar "foo"), (mkScalar "baz")]), ("seq2", array [(mkScalar "foo"), (mkScalar "baz")])]
682−
683−caseSimpleMappingAlias :: Assertion
684−caseSimpleMappingAlias =
685− "map: &anch\n key1: foo\n key2: baz\nmap2: *anch" `shouldDecode`
686− object [(packStr "map", object [("key1", mkScalar "foo"), ("key2", (mkScalar "baz"))]), (packStr "map2", object [("key1", (mkScalar "foo")), ("key2", mkScalar "baz")])]
687− where
688− packStr = fromText . T.pack
689−
690−caseMappingAliasBeforeAnchor :: Assertion
691−caseMappingAliasBeforeAnchor =
692− case D.decodeThrow "map: *anch\nmap2: &anch\n key1: foo\n key2: baz" of
693− Nothing -> pure ()
694− Just (_ :: D.Value) -> error "decode should return Nothing due to unknown alias"
695−
696−caseMappingAliasInsideAnchor :: Assertion
697−caseMappingAliasInsideAnchor = do
698− case D.decodeThrow "map: &anch\n key1: foo\n key2: *anch" of
699− Nothing -> pure ()
700− Just (_ :: D.Value) -> error "decode should return Nothing due to unknown alias"
701−
702−caseScalarAliasOverriding :: Assertion
703−caseScalarAliasOverriding =
704− "- &anch foo\n- baz\n- *anch\n- &anch boo\n- buz\n- *anch" `shouldDecode`
705− array [(mkScalar "foo"), (mkScalar "baz"), (mkScalar "foo"), (mkScalar "boo"), (mkScalar "buz"), (mkScalar "boo")]
706−
707−caseAllKeysShouldBeUnique :: Assertion
708−caseAllKeysShouldBeUnique = do
709− res <- D.decodeThrow "foo1: foo\nfoo2: baz\nfoo1: buz"
710− mappingKey res "foo1" `shouldBe` mkScalar "buz"
711−
712−caseSimpleMappingMerge :: Assertion
713−caseSimpleMappingMerge = do
714− res <- D.decodeThrow "foo1: foo\nfoo2: baz\n<<:\n foo1: buz\n foo3: fuz"
715− mappingKey res "foo1" `shouldBe` mkScalar "foo"
716− mappingKey res "foo3" `shouldBe` mkScalar "fuz"
717−
718−caseMergeSequence :: Assertion
719−caseMergeSequence = do
720− res <- D.decodeThrow "m1: &m1\n k1: !!str 1\n k2: !!str 2\nm2: &m2\n k1: !!str 3\n k3: !!str 4\nfoo1: foo\n<<: [ *m1, *m2 ]"
721− mappingKey res "foo1" @?= (mkScalar "foo")
722− mappingKey res "k1" @?= (D.String "1")
723− mappingKey res "k2" @?= (D.String "2")
724− mappingKey res "k3" @?= (D.String "4")
725−
726−caseDataTypes :: Assertion
727−caseDataTypes =
728− D.encode val `shouldDecode` val
729− where
730− val = object
731− [ ("string", D.String "foo")
732− , ("int", D.Number 5)
733− , ("float", D.Number 4.3)
734− , ("true", D.Bool True)
735− , ("false", D.Bool False)
736− , ("null", D.Null)
737− ]
738−
739−caseEncodeInvalidNumbers :: Assertion
740−caseEncodeInvalidNumbers =
741− D.encode (D.String ".") `shouldBe` ".\n"
742−
743−caseDataTypesPretty :: Assertion
744−caseDataTypesPretty =
745− Pretty.encodePretty Pretty.defConfig val `shouldDecode` val
746− where
747− val = object
748− [ ("string", D.String "foo")
749− , ("int", D.Number 5)
750− , ("float", D.Number 4.3)
751− , ("true", D.Bool True)
752− , ("false", D.Bool False)
753− , ("null", D.Null)
754− ]
755−caseQuotedNumber, caseUnquotedNumber, caseAttribNumber, caseIntegerDecimals :: Assertion
756−caseQuotedNumber = "foo: \"1234\"" `shouldDecode` object [("foo", D.String "1234")]
757−caseUnquotedNumber = "foo: 1234" `shouldDecode` object [("foo", D.Number 1234)]
758−caseAttribNumber = "foo: !!str 1234" `shouldDecode` object [("foo", D.String "1234")]
759−caseIntegerDecimals = "1\n" `shouldDecode` (1 :: Int)
760−
761−obj :: D.Value
762−obj = object [("foo", D.Bool False), ("bar", D.Bool True), ("baz", D.Bool True)]
763−
764−caseLowercaseBool, caseUppercaseBool, caseTitlecaseBool :: Assertion
765−caseLowercaseBool = "foo: off\nbar: y\nbaz: true" `shouldDecode` obj
766−caseUppercaseBool = "foo: FALSE\nbar: Y\nbaz: ON" `shouldDecode` obj
767−caseTitlecaseBool = "foo: No\nbar: Yes\nbaz: True" `shouldDecode` obj
768−
769−caseEmptyInput :: Assertion
770−caseEmptyInput = B8.empty `shouldDecode` D.Null
771−
772−caseEmptyInputFile :: Assertion
773−caseEmptyInputFile = do
774− out <- D.decodeFileEither "test/resources/empty.yaml"
775− either (Left . D.prettyPrintParseException) Right out @?= Right D.Null
776−
777−caseCommentOnlyInput :: Assertion
778−caseCommentOnlyInput = "# comment\n" `shouldDecode` D.Null
779−
780−caseCommentOnlyInputFile :: Assertion
781−caseCommentOnlyInputFile = do
782− out <- D.decodeFileEither "test/resources/empty2.yaml"
783− either (Left . D.prettyPrintParseException) Right out @?= Right D.Null
784−
785−checkNull :: T.Text -> Spec
786−checkNull x =
787− it ("null recognized: " ++ show x) $
788− B8.pack ("foo: " ++ T.unpack x) `shouldDecode` object [("foo", D.Null)]
789−
790−caseStripAlias :: Assertion
791−caseStripAlias =
792− src `shouldDecode` object
793− [ "Default" .= object
794− [ "foo" .= (1 :: Int)
795− , "bar" .= (2 :: Int)
796− ]
797− , "Obj" .= object
798− [ "foo" .= (1 :: Int)
799− , "bar" .= (2 :: Int)
800− , "key" .= (3 :: Int)
801− ]
802− ]
803− where
804− src = "Default: &def\n foo: 1\n bar: 2\nObj:\n <<: *def\n key: 3\n"
805−
806−caseIssue49 :: Assertion
807−caseIssue49 =
808− src `shouldDecode` object
809− [ "a" .= object [ "value" .= (1.0 :: Double) ]
810− , "b" .= object [ "value" .= (1.2 :: Double) ]
811− ]
812− where
813− src = "---\na:\n &id5 value: 1.0\nb:\n *id5: 1.2"
814−
815−-- | We cannot guarantee this before aeson started using 'Scientific'.
816−casePreservesScientificPrecision :: Assertion
817−casePreservesScientificPrecision = do
818− "x: 1e-100000" `shouldDecode` object
819− [ "x" .= D.Number (read "1e-100000") ]
820− -- Note that this ought to work also without 'Scientific', given
821− -- that @read (show "9.78159610558926e-5") == 9.78159610558926e-5@.
822− -- However, it didn't work (and still doesn't work with aeson < 0.7)
823− -- for two reasons:
824− --
825− -- - We use 'Data.Text.Read.double', which is not as accurate as it
826− -- can be;
827− -- - Even if we used 'Data.Text.Read.rational' we would not get good
828− -- results, because of <https://github.com/bos/text/issues/34>.
829− "x: 9.78159610558926e-5" `shouldDecode` object
830− [ "x" .= D.Number (read "9.78159610558926e-5") ]
831−
832−caseTruncatesFiles :: Assertion
833−caseTruncatesFiles = withSystemTempFile "truncate.yaml" $ \fp h -> do
834− replicateM_ 500 $ B8.hPut h "HELLO WORLD!!!!!\n"
835− hClose h
836− let val = object ["hello" .= ("world" :: String)]
837− D.encodeFile fp val
838− res <- D.decodeFileEither fp
839− either (Left . show) Right res `shouldBe` Right val
840−
841−caseSpecialKeys :: (KeyMap () -> B8.ByteString) -> Assertion
842−caseSpecialKeys encoder = do
843− let keys = T.words "true false NO YES 1.2 1e5 null"
844− bs = encoder $ M.fromList $ map (, ()) $ fmap fromText keys
845− text = decodeUtf8 bs
846− forM_ keys $ \key -> do
847− let quoted = T.concat ["'", key, "'"]
848− unless (quoted `T.isInfixOf` text) $ error $ concat
849− [ "Could not find quoted key: "
850− , T.unpack quoted
851− , "\n\n"
852− , T.unpack text
853− ] :: IO ()
854−
855−taggedSequence :: [Y.Event]
856−taggedSequence =
857− [ Y.EventSequenceStart (Y.UriTag "!foo") Y.FlowSequence Nothing
858− , Y.EventSequenceEnd
859− ]
860−
861−taggedMapping :: [Y.Event]
862−taggedMapping =
863− [ Y.EventMappingStart (Y.UriTag "!foo") Y.FlowMapping Nothing
864− , Y.EventMappingEnd
865− ]
866−
867−defaultTaggedSequence :: [Y.Event]
868−defaultTaggedSequence =
869− [Y.EventSequenceStart Y.SeqTag Y.FlowSequence Nothing, Y.EventSequenceEnd]
870−
871−defaultTaggedMapping :: [Y.Event]
872−defaultTaggedMapping =
873− [Y.EventMappingStart Y.MapTag Y.FlowMapping Nothing, Y.EventMappingEnd]
874−
875−untaggedSequence :: [Y.Event]
876−untaggedSequence =
877− [Y.EventSequenceStart Y.NoTag Y.FlowSequence Nothing, Y.EventSequenceEnd]
878−
879−untaggedMapping :: [Y.Event]
880−untaggedMapping =
881− [Y.EventMappingStart Y.NoTag Y.FlowMapping Nothing, Y.EventMappingEnd]
882−
883−mixedTagSampleA :: [Y.Event]
884−mixedTagSampleA =
885− [ Y.EventSequenceStart Y.NoTag Y.BlockSequence Nothing
886− , Y.EventMappingStart (Y.UriTag "!foo") Y.FlowMapping Nothing
887− , Y.EventMappingEnd
888− , Y.EventSequenceEnd
889− ]
890−
891−mixedTagSampleB :: [Y.Event]
892−mixedTagSampleB =
893− [ Y.EventMappingStart Y.NoTag Y.BlockMapping (Just "a")
894− , Y.EventScalar "foo" (Y.UriTag "bar") Y.Plain (Just "b")
895− , Y.EventSequenceStart (Y.UriTag "!baz") Y.FlowSequence (Just "c")
896− , Y.EventScalar "" Y.NullTag Y.Plain (Just "d")
897− , Y.EventSequenceEnd
898− , Y.EventMappingEnd
899− ]
yaml/test/Spec.hsdeleted−1
@@ -1 +0,0 @@
1−{-# OPTIONS_GHC -F -pgmF hspec-discover #-}
yaml/test/resources/accent/foo.yamldeleted−1
@@ -1 +0,0 @@
1−foo: true
yaml/test/resources/bar.yamldeleted−2
@@ -1,2 +0,0 @@
1−one: 1
2−two: 2
yaml/test/resources/baz.yamldeleted−1
@@ -1 +0,0 @@
1−foo: !include foo.yaml
yaml/test/resources/empty.yamldeleted

No changes to the content.

yaml/test/resources/empty2.yamldeleted−1
@@ -1 +0,0 @@
1−# comment
yaml/test/resources/foo.yamldeleted−3
@@ -1,3 +0,0 @@
1−foo: 23
2−bar: !include bar.yaml
3−baz: 42
yaml/test/resources/loop/bar.yamldeleted−2
@@ -1,2 +0,0 @@
1−one: 1
2−two: !include foo.yaml
yaml/test/resources/loop/foo.yamldeleted−3
@@ -1,3 +0,0 @@
1−foo: 23
2−bar: !include bar.yaml
3−baz: 42
yaml/yaml.cabaldeleted−228
@@ -1,228 +0,0 @@
1−cabal-version: 1.12
2−
3−-- This file has been generated from package.yaml by hpack version 0.35.1.
4−--
5−-- see: https://github.com/sol/hpack
6−
7−name: yaml
8−version: 0.11.11.2
9−synopsis: Support for parsing and rendering YAML documents.
10−description: README and API documentation are available at <https://www.stackage.org/package/yaml>
11−category: Data
12−stability: stable
13−homepage: https://github.com/snoyberg/yaml#readme
14−bug-reports: https://github.com/snoyberg/yaml/issues
15−author: Michael Snoyman <michael@snoyman.com>, Anton Ageev <antage@gmail.com>,Kirill Simonov
16−maintainer: Michael Snoyman <michael@snoyman.com>
17−license: BSD3
18−license-file: LICENSE
19−build-type: Simple
20−extra-source-files:
21− test/largest-string.yaml
22− test/json.yaml
23− test/resources/foo.yaml
24− test/resources/bar.yaml
25− test/resources/baz.yaml
26− test/resources/accent/foo.yaml
27− test/resources/loop/foo.yaml
28− test/resources/loop/bar.yaml
29− test/resources/empty.yaml
30− test/resources/empty2.yaml
31− README.md
32− ChangeLog.md
33−
34−source-repository head
35− type: git
36− location: https://github.com/snoyberg/yaml
37−
38−flag no-examples
39− description: don't build the examples
40− manual: False
41− default: True
42−
43−flag no-exe
44− description: don't install the yaml2json or json2yaml executables
45− manual: False
46− default: True
47−
48−library
49− exposed-modules:
50− Data.Yaml
51− Data.Yaml.Aeson
52− Data.Yaml.Builder
53− Data.Yaml.Config
54− Data.Yaml.Include
55− Data.Yaml.Internal
56− Data.Yaml.Parser
57− Data.Yaml.Pretty
58− Data.Yaml.TH
59− other-modules:
60− Paths_yaml
61− hs-source-dirs:
62− src
63− other-extensions:
64− LambdaCase
65− ghc-options: -Wall -Wcompat
66− build-depends:
67− aeson >=0.11
68− , attoparsec >=0.11.3.0
69− , base >=4.9.1 && <5
70− , bytestring >=0.9.1.4
71− , conduit >=1.2.8 && <1.4
72− , containers
73− , directory
74− , filepath
75− , libyaml ==0.1.*
76− , mtl
77− , resourcet >=0.3 && <1.4
78− , scientific >=0.3
79− , template-haskell
80− , text
81− , transformers >=0.1
82− , unordered-containers
83− , vector
84− default-language: Haskell2010
85−
86−executable examples
87− main-is: Main.hs
88− other-modules:
89− Config
90− Simple
91− Paths_yaml
92− hs-source-dirs:
93− examples
94− ghc-options: -Wall -Wcompat
95− build-depends:
96− aeson >=0.11
97− , attoparsec >=0.11.3.0
98− , base >=4.9.1 && <5
99− , bytestring >=0.9.1.4
100− , conduit >=1.2.8 && <1.4
101− , containers
102− , directory
103− , filepath
104− , libyaml ==0.1.*
105− , mtl
106− , resourcet >=0.3 && <1.4
107− , scientific >=0.3
108− , template-haskell
109− , text
110− , transformers >=0.1
111− , unordered-containers
112− , vector
113− default-language: Haskell2010
114− if flag(no-examples)
115− buildable: False
116− else
117− build-depends:
118− raw-strings-qq
119− , yaml
120−
121−executable json2yaml
122− main-is: json2yaml.hs
123− other-modules:
124− Common
125− Paths_yaml
126− hs-source-dirs:
127− exe
128− ghc-options: -Wall -Wcompat
129− build-depends:
130− aeson >=0.11
131− , attoparsec >=0.11.3.0
132− , base >=4.9.1 && <5
133− , bytestring >=0.9.1.4
134− , conduit >=1.2.8 && <1.4
135− , containers
136− , directory
137− , filepath
138− , libyaml ==0.1.*
139− , mtl
140− , optparse-applicative
141− , resourcet >=0.3 && <1.4
142− , scientific >=0.3
143− , template-haskell
144− , text
145− , transformers >=0.1
146− , unordered-containers
147− , vector
148− , yaml
149− default-language: Haskell2010
150− if flag(no-exe)
151− buildable: False
152−
153−executable yaml2json
154− main-is: yaml2json.hs
155− other-modules:
156− Common
157− Paths_yaml
158− hs-source-dirs:
159− exe
160− other-extensions:
161− CPP
162− LambdaCase
163− NamedFieldPuns
164− ghc-options: -Wall -Wcompat
165− build-depends:
166− aeson >=0.11
167− , attoparsec >=0.11.3.0
168− , base >=4.9.1 && <5
169− , bytestring >=0.9.1.4
170− , conduit >=1.2.8 && <1.4
171− , containers
172− , directory
173− , filepath
174− , libyaml ==0.1.*
175− , mtl
176− , optparse-applicative
177− , resourcet >=0.3 && <1.4
178− , scientific >=0.3
179− , template-haskell
180− , text
181− , transformers >=0.1
182− , unordered-containers
183− , vector
184− , yaml
185− default-language: Haskell2010
186− if flag(no-exe)
187− buildable: False
188−
189−test-suite spec
190− type: exitcode-stdio-1.0
191− main-is: Spec.hs
192− other-modules:
193− Data.Yaml.IncludeSpec
194− Data.Yaml.THSpec
195− Data.YamlSpec
196− Paths_yaml
197− hs-source-dirs:
198− test
199− ghc-options: -Wall -Wcompat -with-rtsopts=-K1K
200− cpp-options: -DTEST
201− build-tool-depends:
202− hspec-discover:hspec-discover
203− build-depends:
204− HUnit
205− , aeson >=0.11
206− , attoparsec >=0.11.3.0
207− , base >=4.9.1 && <5
208− , base-compat
209− , bytestring >=0.9.1.4
210− , conduit >=1.2.8 && <1.4
211− , containers
212− , directory
213− , filepath
214− , hspec >=1.3
215− , libyaml ==0.1.*
216− , mockery
217− , mtl
218− , raw-strings-qq
219− , resourcet >=0.3 && <1.4
220− , scientific >=0.3
221− , template-haskell
222− , temporary
223− , text
224− , transformers >=0.1
225− , unordered-containers
226− , vector
227− , yaml
228− default-language: Haskell2010