Filewatcher File Search File Search
Content Search
» » » » » haxml_1.22.5-2+b2_s390x.deb » Content »
pkg://haxml_1.22.5-2+b2_s390x.deb:13509940/usr/share/man/man1/  info  control  downloads

haxml - utilities for using XML documents with Haskell…  more info»


DtdToHaskell(1)             User Commands            DtdToHaskell(1)

       DtdToHaskell - a XML DTD to Haskell translator

       DtdToHaskell [ dtdfile [ outfile ]]

       Missing  file arguments or dashes (-) indicate standard input
       or output respectively.

       DtdToHaskell is a tool for translating any valid XML DTD into
       equivalent Haskell types.  This allows you to generate, edit,
       and transform documents as normal typed values  in  programs,
       and  to  read and write them as human-readable XML documents.
       It uses the Text.XML.HaXml.XmlContent class  as  a  framework
       for printing and parsing.

       DtdToHaskell  reads  and parses a DTD from dtdfile (which may
       be either just a DTD, or a full XML  document  containing  an
       internal  DTD).   It  generates into outfile a Haskell module
       containing a collection of type definitions plus  some  class
       instance declarations for I/O.

       In  order to use the resulting module, you need to import it,
       and also to import Text.XML.HaXml.XmlContent.   To  read  and
       write  XML files as values of the declared types, use some of
       the convenience functions from XmlContent.

       You will need to study the automatically-generated type  dec‐
       larations to write your own code using them - but most things
       have pretty obvious parallels to the DTD structure.

       The generated  Haskell  contains  references  to  types  like
       OneOf3  where  there  is  a choice between n (in this case 3)
       different tags.  Currently, the module  Text.XML.HaXml.OneOfN
       defines  these types up to n=20.  If your DTD requires larger
       choices, then use the tool MkOneOf to generate the extra size
       or range of sizes you need.

       We  mangle  tag names and attribute names to ensure that they
       have the correct lexical form in Haskell, but this means that
       (for  instance) we can't distinguish Myname and myname, which
       are different names in XML but translate to overlapping types
       in Haskell (and hence probably won't compile).

       Attribute  names  translate  into  named  fields: but because
       Haskell doesn't allow different types to have the same  named
       field,  this means your XML document which uses the same name
       for similar attributes on  different  tags  would  crash  and
       burn.   We  have fixed this by incorporating the tagname into
       the named field in  addition  to  the  attribute  name,  e.g.
       tagAttr instead of just attr.  Uglier, but more portable.

       XML  namespaces.   Currently,  we  just  mangle the namespace
       identifier into any tag name which  uses  it.   Probably  the
       right  way  to do it is to regard the namespace as a separate
       imported module, and hence  translate  the  namespace  prefix
       into  a  module qualifier.  Does this sound about right?  (It
       isn't implemented yet.)

       External subset.  Since HaXml release 1.00,  we  support  the
       XML  DTD external subset.  This means we can read and parse a
       whole bunch of files as part of the same DTD, and we  respect
       INCLUDE  and  IGNORE conditional sections.  The sub-DTD files
       must be available locally - we don't go looking for  them  on
       the web.

       There  are  some  fringe parts of the DTD we are not entirely
       sure about, such as Tokenised Types and Notation  Types.   In
       particular,  there  is no validity checking of these external
       references.  If you find a problem, mail us:

       The HaXml library and tools were written by and are copyright
              Copyright  ©  1998 – 2006    Malcolm Wallace and Colin

       The  library  incorporates  the  module   Text.ParserCombina‐
              Copyright © 1996           Graham Hutton and Erik Mei‐

       with modifications
              Copyright © 1998 – 2000    Malcolm Wallace

       and  may  also  use  or  incorporate  the  module  Text.Pret‐
              Copyright  © 1996 – 1997    John Hughes and Simon Pey‐
              ton Jones

       The HaXml library is licensed under  the  terms  of  the  GNU
       Lesser General Public Licence (LGPL), with the following spe‐
       cial exception:

              As a relaxation of clause 6 of the LGPL, the copyright
              holders  of this library give permission to use, copy,
              link, modify, and distribute, binary-only  object-code
              versions  of  an  executable  linked with the Library,
              without requiring the supply of any mechanism to  mod‐
              ify or replace the Library and relink (clauses 6a, 6b,
              6c, 6d, 6e), provided that  all  the  other  terms  of
              clause 6 are complied with.

       The  HaXml tools Xtract, Validate, DtdToHaskell, and MkOneOf,
       are licensed under  the  terms  of  the  GNU  General  Public
       Licence (GPL).

       This  library  and toolset is distributed in the hope that it
       will be useful, but WITHOUT ANY WARRANTY;  without  even  the
       implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICU‐
       LAR PURPOSE.  See the GNU Licences for more details.

       MkOneOf(1), Validate(1)

       This contents of this manual page was copied  from  the  HTML
       documentation   and   slightly   edited   by   Arjan  Oosting
       <> for the Debian system (but may be used  by

DtdToHaskell, version 1.17  October 2007             DtdToHaskell(1)
Results 1 - 1 of 1
Help - FTP Sites List - Software Dir.
Search over 15 billion files
© 1997-2017