HAPPY(1)						      Happy Parser Generator							  HAPPY(1)

NAME

       happy - the parser generator for Haskell

SYNOPSIS

       happy [OPTION]... file [OPTION]...

DESCRIPTION

       This manual page documents briefly the happy command.

       This  manual  page was written for the Debian GNU/Linux distribution because the original program does not have a manual page.  Instead, it
       has documentation in various other formats, including DVI, Info and HTML; see below.

       Happy is a parser generator system for Haskell.	`HAPPY' is a dyslexic acronym for `A Yacc-like Haskell Parser generator'.

       There are two types of grammar files, file.y and file.ly, with the latter observing the reverse comment bird track convention  (i.e.   each
       code line must begin with `>').	The examples distributed with Happy are all of the .ly form.

       Caveat:	When  using  hbc (Chalmers Haskell) the command argument structure is slightly different.  This is because the hbc run time system
       takes some flags as its own (for setting things like the heap size, etc).  This problem can be circumvented by adding a single  dash  (`-')
       to your command line.  So when using a hbc generated version of Happy, the argument structure is:

       happy - [OPTION]... file [OPTION]...

OPTIONS

       The programs follow the usual GNU command line syntax, with long options starting with two dashes (`--').  A summary of options is included
       below.  For a complete description, see the other documentation.

       -h, --help
	      Show summary of options.

       -v, --version
	      Print version information on standard output then exit successfully.

       -a, --array
	      Instructs Happy to generate a parser using an array-based shift reduce parser.  When used in conjunction with -g, the arrays will be
	      encoded as strings, resulting in faster parsers.	Without -g, standard Haskell arrays will be used.

       -g, --ghc
	      Instructs Happy to generate a parser that uses GHC-specific extensions to obtain faster code.

       -c, --coerce
	      Use  GHC's  unsafeCoerce#  extension to generate smaller faster parsers.	One drawback is that some type safety is lost, which means
	      that a parser generated with -c may compile fine but crash at run-time.  Be sure to compile your grammar without -c first to  ensure
	      it is type-correct.

	      This  option has quite a significant effect on the performance of the resulting parser, but remember that parsers generated this way
	      can only be compiled by GHC 3.02 and above.

	      This option may only be used in conjuction with -g.

       -d, --debug
	      Generate a parser that will print debugging information to stderr at run-time, including all the shifts, reductions,  state  transi-
	      tions and token inputs performed by the parser.

	      This option may only be used in conjuction with -a.

       -i [FILE], --info[=FILE]
	      Directs  Happy  to  produce  an info file containing detailed information about the grammar, parser states, parser actions, and con-
	      flicts.  Info files are vital during the debugging of grammars.

	      The filename argument is optional, and if omitted the info file will be written to FILE.info (where FILE is the input file name with
	      any extension removed).

       -o FILE, --outfile=FILE
	      Specifies  the destination of the generated parser module.  If omitted, the parser will be placed in FILE.hs, where FILE is the name
	      of the input file with any extension removed.  If FILE is - the generated parser is sent to the standard output.

       -m NAME, --magic-name=NAME
	      Happy prefixes all the symbols it uses internally with either happy or Happy.  To use a different string, for example if the use	of
	      happy is conflicting with one of your own functions, specify the prefix using the -m option.

       -t DIR, --template=DIR
	      Instructs  Happy	to  use this directory when looking for template files: these files contain the static code that Happy includes in
	      every generated parser.  You shouldn't need to use this option if Happy is properly configured for your computer.

       -l, --glr
	      Instructs Happy to output a GLR parser instead of an LALR(1) parser.

       -k, --decode
	      Causes the GLR parser to generate code for decoding the parse forest to a list of semantic results (requires --ghc).

       -f, --filter
	      Causes the GLR parser to filter out nodes which aren't required for the semantic results	(an  experimental  optimisation,  requires
	      --ghc).

FILES

       /usr/share/happy-1.18.9

SEE ALSO

       /usr/share/doc/happy, the Happy homepage (http://haskell.org/happy/) <http://haskell.org/happy/>

COPYRIGHT

       Happy Version 1.18.9

       Copyright (c) 1993-1996 Andy Gill, Simon Marlow; (c) 1997-2001 Simon Marlow

AUTHOR

       This manual page was written by Michael Weber <michaelw@debian.org>, for the Debian GNU/Linux system (but may be used by others).

Glasgow FP Suite						    2000-12-23								  HAPPY(1)