License	BSD3
Maintainer	cabal-devel@haskell.org
Portability	portable
Safe Haskell	None
Language	Haskell2010

Distribution.Parsec.Parser

Contents

Types
Grammar and parsing

Description

Synopsis

data Field ann
- = Field !(Name ann) [FieldLine ann]
- | Section !(Name ann) [SectionArg ann] [Field ann]
data Name ann = Name !ann !FieldName
data FieldLine ann = FieldLine !ann !ByteString
data SectionArg ann
- = SecArgName !ann !ByteString
- | SecArgStr !ann !ByteString
- | SecArgOther !ann !ByteString
readFields :: ByteString -> Either ParseError [Field Position]
readFields' :: ByteString -> Either ParseError ([Field Position], [LexWarning])

Types

data Field ann #

A Cabal-like file consists of a series of fields (foo: bar) and sections (library ...).

Constructors

Field !(Name ann) [FieldLine ann]
Section !(Name ann) [SectionArg ann] [Field ann]

Instances

Functor Field #
Instance details Methods fmap :: (a -> b) -> Field a -> Field b # (<$) :: a -> Field b -> Field a #
Eq ann => Eq (Field ann) #
Instance details Methods (==) :: Field ann -> Field ann -> Bool # (/=) :: Field ann -> Field ann -> Bool #
Show ann => Show (Field ann) #
Instance details Methods showsPrec :: Int -> Field ann -> ShowS # show :: Field ann -> String # showList :: [Field ann] -> ShowS #

data Name ann #

A field name.

Invariant: ByteString is lower-case ASCII.

Constructors

Name !ann !FieldName

Instances

Functor Name #
Instance details Methods fmap :: (a -> b) -> Name a -> Name b # (<$) :: a -> Name b -> Name a #
Eq ann => Eq (Name ann) #
Instance details Methods (==) :: Name ann -> Name ann -> Bool # (/=) :: Name ann -> Name ann -> Bool #
Show ann => Show (Name ann) #
Instance details Methods showsPrec :: Int -> Name ann -> ShowS # show :: Name ann -> String # showList :: [Name ann] -> ShowS #

data FieldLine ann #

A line of text representing the value of a field from a Cabal file. A field may contain multiple lines.

Invariant: ByteString has no newlines.

Constructors

FieldLine !ann !ByteString

Instances

Functor FieldLine #
Instance details Methods fmap :: (a -> b) -> FieldLine a -> FieldLine b # (<$) :: a -> FieldLine b -> FieldLine a #
Eq ann => Eq (FieldLine ann) #
Instance details Methods (==) :: FieldLine ann -> FieldLine ann -> Bool # (/=) :: FieldLine ann -> FieldLine ann -> Bool #
Show ann => Show (FieldLine ann) #
Instance details Methods showsPrec :: Int -> FieldLine ann -> ShowS # show :: FieldLine ann -> String # showList :: [FieldLine ann] -> ShowS #

data SectionArg ann #

Section arguments, e.g. name of the library

Constructors

SecArgName !ann !ByteString	identifier, or omething which loos like number. Also many dot numbers, i.e. "7.6.3"
SecArgStr !ann !ByteString	quoted string
SecArgOther !ann !ByteString	everything else, mm. operators (e.g. in if-section conditionals)

Instances

Functor SectionArg #
Instance details Methods fmap :: (a -> b) -> SectionArg a -> SectionArg b # (<$) :: a -> SectionArg b -> SectionArg a #
Eq ann => Eq (SectionArg ann) #
Instance details Methods (==) :: SectionArg ann -> SectionArg ann -> Bool # (/=) :: SectionArg ann -> SectionArg ann -> Bool #
Show ann => Show (SectionArg ann) #
Instance details Methods showsPrec :: Int -> SectionArg ann -> ShowS # show :: SectionArg ann -> String # showList :: [SectionArg ann] -> ShowS #

Grammar and parsing

CabalStyleFile ::= SecElems

SecElems       ::= SecElem* '\n'?
SecElem        ::= '\n' SecElemLayout | SecElemBraces
SecElemLayout  ::= FieldLayout | FieldBraces | SectionLayout | SectionBraces
SecElemBraces  ::= FieldInline | FieldBraces |                 SectionBraces
FieldLayout    ::= name : line? ('\n' line)*
FieldBraces    ::= name : '\n'? '{' content '}'
FieldInline    ::= name : content
SectionLayout  ::= name arg* SecElems
SectionBraces  ::= name arg* '\n'? '{' SecElems '}'

and the same thing but left factored...

SecElems              ::= SecElem*
SecElem               ::= '\n' name SecElemLayout
                        |      name SecElemBraces
SecElemLayout         ::= :   FieldLayoutOrBraces
                        | arg*  SectionLayoutOrBraces
FieldLayoutOrBraces   ::= '\n'? '{' content '}'
                        | line? ('\n' line)*
SectionLayoutOrBraces ::= '\n'? '{' SecElems '\n'? '}'
                        | SecElems
SecElemBraces         ::= : FieldInlineOrBraces
                        | arg* '\n'? '{' SecElems '\n'? '}'
FieldInlineOrBraces   ::= '\n'? '{' content '}'
                        | content

Note how we have several productions with the sequence:

'\n'? '{'

That is, an optional newline (and indent) followed by a { token. In the SectionLayoutOrBraces case you can see that this makes it not fully left factored (because SecElems can start with a n). Fully left factoring here would be ugly, and though we could use a lookahead of two tokens to resolve the alternatives, we can't conveniently use Parsec's try here to get a lookahead of only two. So instead we deal with this case in the lexer by making a line where the first non-space is { lex as just the { token, without the usual indent token. Then in the parser we can resolve everything with just one token of lookahead and so without using try.

readFields :: ByteString -> Either ParseError [Field Position] #

Parse cabal style ByteString into list of Fields, i.e. the cabal AST.

readFields' :: ByteString -> Either ParseError ([Field Position], [LexWarning]) #

Like readFields but also return lexer warnings