hexpr.parse.C File Reference

#include <hobbes/lang/module.H>
#include <hobbes/lang/expr.H>
#include <hobbes/lang/pat/pattern.H>
#include <hobbes/lang/type.H>
#include <hobbes/lang/typepreds.H>
#include <hobbes/db/bindings.H>
#include <hobbes/util/autorelease.H>
#include <hobbes/util/str.H>
#include <hobbes/util/array.H>
#include <hobbes/parse/grammar.H>
#include <hobbes/parse/lalr.H>
#include <hobbes/read/pgen/hexpr.parse.H>
#include <string>
#include <stdexcept>
#include <vector>
#include <stdio.h>
#include <stddef.h>

Include dependency graph for hexpr.parse.C:

Classes
struct	YYLTYPE
union	YYSTYPE
union	yyalloc

Namespaces
	hobbes

Macros
#define	YYBISON   1
#define	YYBISON_VERSION   "3.0.2"
#define	YYSKELETON_NAME   "yacc.c"
#define	YYPURE   0
#define	YYPUSH   0
#define	YYPULL   1
#define	YYLTYPE_IS_DECLARED   1
#define	YYLLOC_DEFAULT(L, R, N)
#define	TAPP0(fn, la)   new App(fn, list<ExprPtr>(), la)
#define	TAPP1(fn, x0, la)   new App(fn, list(ExprPtr(x0)), la)
#define	TAPP2(fn, x0, x1, la)   new App(fn, list(ExprPtr(x0),ExprPtr(x1)), la)
#define	TAPP3(fn, x0, x1, x2, la)   new App(fn, list(ExprPtr(x0),ExprPtr(x1),ExprPtr(x2)), la)
#define	YY_NULLPTR   0
#define	YYERROR_VERBOSE   1
#define	YY_YY_HEXPR_PARSE_H_INCLUDED
#define	YYDEBUG   0
#define	YYTOKENTYPE
#define	YYSTYPE_IS_TRIVIAL   1
#define	YYSTYPE_IS_DECLARED   1
#define	YYSIZE_T   size_t
#define	YYSIZE_MAXIMUM   ((YYSIZE_T) -1)
#define	YY_(Msgid)   Msgid
#define	YY_ATTRIBUTE(Spec)   /* empty */
#define	YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
#define	YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))
#define	_Noreturn   YY_ATTRIBUTE ((__noreturn__))
#define	YYUSE(E)   ((void) (E))
#define	YY_INITIAL_VALUE(Value)   Value
#define	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define	YY_IGNORE_MAYBE_UNINITIALIZED_END
#define	YYSTACK_ALLOC   YYMALLOC
#define	YYSTACK_FREE   YYFREE
#define	YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
#define	YYMALLOC   malloc
#define	YYFREE   free
#define	YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)
#define	YYSTACK_BYTES(N)
#define	YYCOPY_NEEDED   1
#define	YYSTACK_RELOCATE(Stack_alloc, Stack)
#define	YYCOPY(Dst, Src, Count)
#define	YYFINAL   67
#define	YYLAST   2800
#define	YYNTOKENS   91
#define	YYNNTS   76
#define	YYNRULES   333
#define	YYNSTATES   741
#define	YYUNDEFTOK   2
#define	YYMAXUTOK   345
#define	YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
#define	YYPACT_NINF   -560
#define	yypact_value_is_default(Yystate)   (!!((Yystate) == (-560)))
#define	YYTABLE_NINF   -333
#define	yytable_value_is_error(Yytable_value)   0
#define	yyerrok   (yyerrstatus = 0)
#define	yyclearin   (yychar = YYEMPTY)
#define	YYEMPTY   (-2)
#define	YYEOF   0
#define	YYACCEPT   goto yyacceptlab
#define	YYABORT   goto yyabortlab
#define	YYERROR   goto yyerrorlab
#define	YYRECOVERING()   (!!yyerrstatus)
#define	YYBACKUP(Token, Value)
#define	YYTERROR   1
#define	YYERRCODE   256
#define	YYRHSLOC(Rhs, K)   ((Rhs)[K])
#define	YYDPRINTF(Args)
#define	YY_SYMBOL_PRINT(Title, Type, Value, Location)
#define	YY_STACK_PRINT(Bottom, Top)
#define	YY_REDUCE_PRINT(Rule)
#define	YYINITDEPTH   200
#define	YYMAXDEPTH   10000
#define	YYCASE_(N, S)
#define	YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
#define	YYSYNTAX_ERROR

Typedefs
typedef struct YYLTYPE	YYLTYPE
typedef std::pair< PatternPtr, ExprPtr >	LetBinding
typedef std::vector< LetBinding >	LetBindings
typedef union YYSTYPE	YYSTYPE
typedef unsigned char	yytype_uint8
typedef signed char	yytype_int8
typedef unsigned short int	yytype_uint16
typedef short int	yytype_int16

Enumerations
enum	yytokentype {   TPARSEMODULE = 258, TPARSEDEFN = 259, TPARSEEXPR = 260, TMODULE = 261,   TWHERE = 262, TIMPORT = 263, TTYPE = 264, TDATA = 265,   TCLASS = 266, TINST = 267, TINDENT = 268, TBOOL = 269,   TCHAR = 270, TBYTE = 271, TBYTES = 272, TSHORT = 273,   TINT = 274, TLONG = 275, TFLOAT = 276, TDOUBLE = 277,   TIDENT = 278, TSTRING = 279, TREGEX = 280, TTIMEINTERVAL = 281,   TTIME = 282, TDATETIME = 283, TTUPSECTION = 284, TCSTARROW = 285,   TARROW = 286, TCOLON = 287, TEXISTS = 288, TASSIGN = 289,   TPARROW = 290, TEQUALS = 291, TASSUMP = 292, TAPPEND = 293,   TPLUS = 294, TMINUS = 295, TTIMES = 296, TDIVIDE = 297,   TREM = 298, TDOT = 299, TEQUIV = 300, TEQ = 301,   TCIEQ = 302, TNEQ = 303, TLT = 304, TLTE = 305,   TGT = 306, TGTE = 307, TNOT = 308, TLET = 309,   TCASE = 310, TDEFAULT = 311, TMATCH = 312, TMATCHES = 313,   TPARSE = 314, TWITH = 315, TOF = 316, TAND = 317,   TOR = 318, TIF = 319, TTHEN = 320, TELSE = 321,   TIN = 322, TPACK = 323, TUNPACK = 324, TDO = 325,   TRETURN = 326, TLPAREN = 327, TRPAREN = 328, TLBRACKET = 329,   TRBRACKET = 330, TLBRACE = 331, TRBRACE = 332, TBAR = 333,   TCOMMA = 334, TSEMICOLON = 335, TFN = 336, TCOMPOSE = 337,   TUPTO = 338, TCARET = 339, TAT = 340, TDOLLAR = 341,   TQUESTION = 342, TSQUOTE = 343, TEQUOTE = 344, TPARSEMODULE = 258,   TPARSEDEFN = 259, TPARSEEXPR = 260, TMODULE = 261, TWHERE = 262,   TIMPORT = 263, TTYPE = 264, TDATA = 265, TCLASS = 266,   TINST = 267, TINDENT = 268, TBOOL = 269, TCHAR = 270,   TBYTE = 271, TBYTES = 272, TSHORT = 273, TINT = 274,   TLONG = 275, TFLOAT = 276, TDOUBLE = 277, TIDENT = 278,   TSTRING = 279, TREGEX = 280, TTIMEINTERVAL = 281, TTIME = 282,   TDATETIME = 283, TTUPSECTION = 284, TCSTARROW = 285, TARROW = 286,   TCOLON = 287, TEXISTS = 288, TASSIGN = 289, TPARROW = 290,   TEQUALS = 291, TASSUMP = 292, TAPPEND = 293, TPLUS = 294,   TMINUS = 295, TTIMES = 296, TDIVIDE = 297, TREM = 298,   TDOT = 299, TEQUIV = 300, TEQ = 301, TCIEQ = 302,   TNEQ = 303, TLT = 304, TLTE = 305, TGT = 306,   TGTE = 307, TNOT = 308, TLET = 309, TCASE = 310,   TDEFAULT = 311, TMATCH = 312, TMATCHES = 313, TPARSE = 314,   TWITH = 315, TOF = 316, TAND = 317, TOR = 318,   TIF = 319, TTHEN = 320, TELSE = 321, TIN = 322,   TPACK = 323, TUNPACK = 324, TDO = 325, TRETURN = 326,   TLPAREN = 327, TRPAREN = 328, TLBRACKET = 329, TRBRACKET = 330,   TLBRACE = 331, TRBRACE = 332, TBAR = 333, TCOMMA = 334,   TSEMICOLON = 335, TFN = 336, TCOMPOSE = 337, TUPTO = 338,   TCARET = 339, TAT = 340, TDOLLAR = 341, TQUESTION = 342,   TSQUOTE = 343, TEQUOTE = 344 }

Functions
void	wantIndent (bool f)
int	yylex ()
void	yyerror (const char *s)
LexicalAnnotation	m (const YYLTYPE &p)
LexicalAnnotation	m (const YYLTYPE &p0, const YYLTYPE &p1)
MonoTypePtr	forceMonotype (const QualTypePtr &qt, const LexicalAnnotation &la)
Expr *	pickNestedExp (Exprs *exprs, const LexicalAnnotation &la)
Pattern *	pickNestedPat (Patterns *pats, const LexicalAnnotation &la)
PatternRows	normPatternRules (PatternRows rs, const LexicalAnnotation &la)
Expr *	compileNestedLetMatch (const LetBindings &bs, const ExprPtr &e, const LexicalAnnotation &la)
ExprPtr	irpatFunc (const PatternPtr &pat, const ExprPtr &body, const LexicalAnnotation &la)
ExprPtr	rpatFunc (const PatternPtr &pat, const ExprPtr &cond, const ExprPtr &body, const LexicalAnnotation &la)
Expr *	compileArrayComprehension (const ExprPtr &body, const PatternPtr &pat, const ExprPtr &arr, const LexicalAnnotation &la)
Expr *	compileArrayComprehension (const ExprPtr &body, const PatternPtr &pat, const ExprPtr &arr, const ExprPtr &cond, const LexicalAnnotation &la)
Expr *	makeRefutablePatternFn (const Patterns &ps, const ExprPtr &e, const LexicalAnnotation &la)
Expr *	makeIrrefutablePatternFn (const Patterns &ps, const ExprPtr &e, const LexicalAnnotation &la)
Expr *	makePatternFn (const Patterns &ps, const ExprPtr &e, const LexicalAnnotation &la)
Expr *	makeProjSeq (Expr *rec, const str::seq &fields, const LexicalAnnotation &la)
MonoTypePtr	monoTypeByName (const std::string &tn)
MonoTypePtr	accumTApp (const MonoTypes &ts)
MonoTypePtr	makeTupleType (const MonoTypes &mts)
MonoTypePtr	makeSumType (const MonoTypes &mts)
MonoTypePtr	makeRecType (const Record::Members &tms)
MonoTypePtr	makeVarType (const Variant::Members &vms)
str::seq	tupSectionFields (const std::string &x)
int	yyparse (void)
void *	malloc (YYSIZE_T)
void	free (void *)
static YYSIZE_T	yystrlen (const char *yystr)
static char *	yystpcpy (char *yydest, const char *yysrc)
static YYSIZE_T	yytnamerr (char *yyres, const char *yystr)
static int	yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
static void	yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)

Variables
cc *	yyParseCC
Module *	yyParsedModule = 0
std::string	yyParsedVar
Expr *	yyParsedExpr = 0
std::string	yyMatchDiagram
std::string	yyModulePath
YYLTYPE	yyErrPos
std::string	yyVexpLexError
YYSTYPE	yylval
YYLTYPE	yylloc
static const yytype_uint8	yytranslate []
static const char *const	yytname []
static const yytype_int16	yypact []
static const yytype_uint16	yydefact []
static const yytype_int16	yypgoto []
static const yytype_int16	yydefgoto []
static const yytype_int16	yytable []
static const yytype_int16	yycheck []
static const yytype_uint8	yystos []
static const yytype_uint8	yyr1 []
static const yytype_uint8	yyr2 []
int	yychar
int	yynerrs

Macro Definition Documentation

_Noreturn

#define _Noreturn   YY_ATTRIBUTE ((__noreturn__))

TAPP0

#define TAPP0	(		fn,
			la
	)		new App(fn, list<ExprPtr>(), la)

TAPP1

#define TAPP1	(		fn,
			x0,
			la
	)		new App(fn, list(ExprPtr(x0)), la)

TAPP2

#define TAPP2	(		fn,
			x0,
			x1,
			la
	)		new App(fn, list(ExprPtr(x0),ExprPtr(x1)), la)

TAPP3

#define TAPP3	(		fn,
			x0,
			x1,
			x2,
			la
	)		new App(fn, list(ExprPtr(x0),ExprPtr(x1),ExprPtr(x2)), la)

YY_

#define YY_

(

Msgid

)

Msgid

YY_ATTRIBUTE

#define YY_ATTRIBUTE

(

Spec

)

/* empty */

YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))

YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))

YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

YY_INITIAL_VALUE

#define YY_INITIAL_VALUE

(

Value

)

Value

YY_NULLPTR

#define YY_NULLPTR   0

YY_REDUCE_PRINT

#define YY_REDUCE_PRINT

(

Rule

)

YY_STACK_PRINT

#define YY_STACK_PRINT	(		Bottom,
			Top
	)

YY_SYMBOL_PRINT

#define YY_SYMBOL_PRINT	(		Title,
			Type,
			Value,
			Location
	)

YY_YY_HEXPR_PARSE_H_INCLUDED

#define YY_YY_HEXPR_PARSE_H_INCLUDED

YYABORT

#define YYABORT   goto yyabortlab

YYACCEPT

#define YYACCEPT   goto yyacceptlab

YYBACKUP

#define YYBACKUP	(		Token,
			Value
	)

Value:

do                                                              \
  if (yychar == YYEMPTY)                                        \
    {                                                           \
      yychar = (Token);                                         \
      yylval = (Value);                                         \
      YYPOPSTACK (yylen);                                       \
      yystate = *yyssp;                                         \
      goto yybackup;                                            \
    }                                                           \
  else                                                          \
    {                                                           \
      yyerror (YY_("syntax error: cannot back up")); \
      YYERROR;                                                  \
    }                                                           \
while (0)

YYBISON

#define YYBISON   1

YYBISON_VERSION

#define YYBISON_VERSION   "3.0.2"

YYCASE_

#define YYCASE_	(		N,
			S
	)

Value:

case N:                               \
        yyformat = S;                       \
      break

yyclearin

#define yyclearin   (yychar = YYEMPTY)

YYCOPY

#define YYCOPY	(		Dst,
			Src,
			Count
	)

Value:

do                                        \
        {                                       \
          YYSIZE_T yyi;                         \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (0)

YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

YYDEBUG

#define YYDEBUG   0

YYDPRINTF

#define YYDPRINTF

(

Args

)

YYEMPTY

#define YYEMPTY   (-2)

YYEOF

#define YYEOF   0

YYERRCODE

#define YYERRCODE   256

yyerrok

#define yyerrok   (yyerrstatus = 0)

YYERROR

#define YYERROR   goto yyerrorlab

YYERROR_VERBOSE

#define YYERROR_VERBOSE   1

YYFINAL

#define YYFINAL   67

YYFREE

#define YYFREE   free

YYINITDEPTH

#define YYINITDEPTH   200

YYLAST

#define YYLAST   2800

YYLLOC_DEFAULT

#define YYLLOC_DEFAULT	(		L,
			R,
			N
	)

Value:

if (N) { \
    (L).first_line   = YYRHSLOC(R, 1).first_line; \
    (L).first_column = YYRHSLOC(R, 1).first_column; \
    (L).last_line    = YYRHSLOC(R, N).last_line; \
    (L).last_column  = YYRHSLOC(R, N).last_column; \
  } else { \
    (L).first_line = (L).last_line = YYRHSLOC(R, 0).last_line; \
    (L).first_column = (L).last_column = YYRHSLOC(R, 0).last_column; \
  }

YYLTYPE_IS_DECLARED

#define YYLTYPE_IS_DECLARED   1

YYMALLOC

#define YYMALLOC   malloc

YYMAXDEPTH

#define YYMAXDEPTH   10000

YYMAXUTOK

#define YYMAXUTOK   345

YYNNTS

#define YYNNTS   76

YYNRULES

#define YYNRULES   333

YYNSTATES

#define YYNSTATES   741

YYNTOKENS

#define YYNTOKENS   91

YYPACT_NINF

#define YYPACT_NINF   -560

yypact_value_is_default

#define yypact_value_is_default

(

Yystate

)

(!!((Yystate) == (-560)))

YYPOPSTACK

#define YYPOPSTACK

(

N

)

(yyvsp -= (N), yyssp -= (N), yylsp -= (N))

YYPULL

#define YYPULL   1

YYPURE

#define YYPURE   0

YYPUSH

#define YYPUSH   0

YYRECOVERING

#define YYRECOVERING

(

)

(!!yyerrstatus)

YYRHSLOC

#define YYRHSLOC	(		Rhs,
			K
	)		((Rhs)[K])

YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

YYSIZE_T

#define YYSIZE_T   size_t

YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

YYSTACK_BYTES

#define YYSTACK_BYTES

(

N

)

Value:

((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
      + 2 * YYSTACK_GAP_MAXIMUM)

YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

YYSTACK_GAP_MAXIMUM

#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)

YYSTACK_RELOCATE

#define YYSTACK_RELOCATE	(		Stack_alloc,
			Stack
	)

Value:

do                                                                  \
      {                                                                 \
        YYSIZE_T yynewbytes;                                            \
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / sizeof (*yyptr);                          \
      }                                                                 \
    while (0)

YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED   1

YYSTYPE_IS_TRIVIAL

#define YYSTYPE_IS_TRIVIAL   1

YYSYNTAX_ERROR

#define YYSYNTAX_ERROR

Value:

yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)

YYTABLE_NINF

#define YYTABLE_NINF   -333

yytable_value_is_error

#define yytable_value_is_error

(

Yytable_value

)

0

YYTERROR

#define YYTERROR   1

YYTOKENTYPE

#define YYTOKENTYPE

YYTRANSLATE

#define YYTRANSLATE

(

YYX

)

((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

YYUNDEFTOK

#define YYUNDEFTOK   2

YYUSE

#define YYUSE

(

E

)

((void) (E))

Typedef Documentation

LetBinding

typedef std::pair<PatternPtr, ExprPtr> LetBinding

LetBindings

typedef std::vector<LetBinding> LetBindings

YYLTYPE

typedef struct YYLTYPE YYLTYPE

YYSTYPE

typedef union YYSTYPE YYSTYPE

yytype_int16

typedef short int yytype_int16

yytype_int8

typedef signed char yytype_int8

yytype_uint16

typedef unsigned short int yytype_uint16

yytype_uint8

typedef unsigned char yytype_uint8

Enumeration Type Documentation

yytokentype

enum yytokentype

Enumerator
TPARSEMODULE
TPARSEDEFN
TPARSEEXPR
TMODULE
TWHERE
TIMPORT
TTYPE
TDATA
TCLASS
TINST
TINDENT
TBOOL
TCHAR
TBYTE
TBYTES
TSHORT
TINT
TLONG
TFLOAT
TDOUBLE
TIDENT
TSTRING
TREGEX
TTIMEINTERVAL
TTIME
TDATETIME
TTUPSECTION
TCSTARROW
TARROW
TCOLON
TEXISTS
TASSIGN
TPARROW
TEQUALS
TASSUMP
TAPPEND
TPLUS
TMINUS
TTIMES
TDIVIDE
TREM
TDOT
TEQUIV
TEQ
TCIEQ
TNEQ
TLT
TLTE
TGT
TGTE
TNOT
TLET
TCASE
TDEFAULT
TMATCH
TMATCHES
TPARSE
TWITH
TOF
TAND
TOR
TIF
TTHEN
TELSE
TIN
TPACK
TUNPACK
TDO
TRETURN
TLPAREN
TRPAREN
TLBRACKET
TRBRACKET
TLBRACE
TRBRACE
TBAR
TCOMMA
TSEMICOLON
TFN
TCOMPOSE
TUPTO
TCARET
TAT
TDOLLAR
TQUESTION
TSQUOTE
TEQUOTE
TPARSEMODULE
TPARSEDEFN
TPARSEEXPR
TMODULE
TWHERE
TIMPORT
TTYPE
TDATA
TCLASS
TINST
TINDENT
TBOOL
TCHAR
TBYTE
TBYTES
TSHORT
TINT
TLONG
TFLOAT
TDOUBLE
TIDENT
TSTRING
TREGEX
TTIMEINTERVAL
TTIME
TDATETIME
TTUPSECTION
TCSTARROW
TARROW
TCOLON
TEXISTS
TASSIGN
TPARROW
TEQUALS
TASSUMP
TAPPEND
TPLUS
TMINUS
TTIMES
TDIVIDE
TREM
TDOT
TEQUIV
TEQ
TCIEQ
TNEQ
TLT
TLTE
TGT
TGTE
TNOT
TLET
TCASE
TDEFAULT
TMATCH
TMATCHES
TPARSE
TWITH
TOF
TAND
TOR
TIF
TTHEN
TELSE
TIN
TPACK
TUNPACK
TDO
TRETURN
TLPAREN
TRPAREN
TLBRACKET
TRBRACKET
TLBRACE
TRBRACE
TBAR
TCOMMA
TSEMICOLON
TFN
TCOMPOSE
TUPTO
TCARET
TAT
TDOLLAR
TQUESTION
TSQUOTE
TEQUOTE

Function Documentation

accumTApp()

MonoTypePtr accumTApp

(

const MonoTypes &

ts

)

compileArrayComprehension() [1/2]

Expr* compileArrayComprehension	(	const ExprPtr &	body,
		const PatternPtr &	pat,
		const ExprPtr &	arr,
		const LexicalAnnotation &	la
	)

compileArrayComprehension() [2/2]

Expr* compileArrayComprehension	(	const ExprPtr &	body,
		const PatternPtr &	pat,
		const ExprPtr &	arr,
		const ExprPtr &	cond,
		const LexicalAnnotation &	la
	)

compileNestedLetMatch()

Expr* compileNestedLetMatch	(	const LetBindings &	bs,
		const ExprPtr &	e,
		const LexicalAnnotation &	la
	)

forceMonotype()

MonoTypePtr forceMonotype	(	const QualTypePtr &	qt,
		const LexicalAnnotation &	la
	)

free()

void free

(

void *

)

irpatFunc()

ExprPtr irpatFunc	(	const PatternPtr &	pat,
		const ExprPtr &	body,
		const LexicalAnnotation &	la
	)

m() [1/2]

LexicalAnnotation m

(

const YYLTYPE &

p

)

m() [2/2]

LexicalAnnotation m	(	const YYLTYPE &	p0,
		const YYLTYPE &	p1
	)

makeIrrefutablePatternFn()

Expr* makeIrrefutablePatternFn	(	const Patterns &	ps,
		const ExprPtr &	e,
		const LexicalAnnotation &	la
	)

makePatternFn()

Expr* makePatternFn	(	const Patterns &	ps,
		const ExprPtr &	e,
		const LexicalAnnotation &	la
	)

makeProjSeq()

Expr* makeProjSeq	(	Expr *	rec,
		const str::seq &	fields,
		const LexicalAnnotation &	la
	)

makeRecType()

MonoTypePtr makeRecType

(

const Record::Members &

tms

)

makeRefutablePatternFn()

Expr* makeRefutablePatternFn	(	const Patterns &	ps,
		const ExprPtr &	e,
		const LexicalAnnotation &	la
	)

makeSumType()

MonoTypePtr makeSumType

(

const MonoTypes &

mts

)

makeTupleType()

MonoTypePtr makeTupleType

(

const MonoTypes &

mts

)

makeVarType()

MonoTypePtr makeVarType

(

const Variant::Members &

vms

)

malloc()

void* malloc

(

YYSIZE_T

)

monoTypeByName()

MonoTypePtr monoTypeByName

(

const std::string &

tn

)

normPatternRules()

PatternRows normPatternRules	(	PatternRows	rs,
		const LexicalAnnotation &	la
	)

pickNestedExp()

Expr* pickNestedExp	(	Exprs *	exprs,
		const LexicalAnnotation &	la
	)

pickNestedPat()

Pattern* pickNestedPat	(	Patterns *	pats,
		const LexicalAnnotation &	la
	)

rpatFunc()

ExprPtr rpatFunc	(	const PatternPtr &	pat,
		const ExprPtr &	cond,
		const ExprPtr &	body,
		const LexicalAnnotation &	la
	)

tupSectionFields()

str::seq tupSectionFields

(

const std::string &

x

)

wantIndent()

void wantIndent

(

bool

f

)

yydestruct()

static void yydestruct ( const char *  yymsg, int  yytype, YYSTYPE *  yyvaluep, YYLTYPE *  yylocationp  )

static

yyerror()

void yyerror

(

const char *

s

)

yylex()

int yylex

(

)

yyparse()

int yyparse

(

void

)

yystpcpy()

static char* yystpcpy ( char *  yydest, const char *  yysrc  )

static

yystrlen()

static YYSIZE_T yystrlen ( const char *  yystr )

static

yysyntax_error()

static int yysyntax_error ( YYSIZE_T *  yymsg_alloc, char **  yymsg, yytype_int16 *  yyssp, int  yytoken  )

static

yytnamerr()

static YYSIZE_T yytnamerr ( char *  yyres, const char *  yystr  )

static

Variable Documentation

yychar

int yychar

yycheck

const yytype_int16 yycheck[]

static

yydefact

const yytype_uint16 yydefact[]

static

yydefgoto

const yytype_int16 yydefgoto[]

static

Initial value:

=
{
      -1,     4,    35,    36,    37,    38,    39,    40,   593,    41,
     509,   510,   507,   508,    42,   519,   520,   249,   250,    43,
     119,   511,   256,   120,    59,    60,    61,    62,   144,   145,
     326,   327,    63,    45,   319,   320,   548,   549,   550,   614,
     615,    46,   149,   437,   438,   186,   187,   146,   308,   309,
     310,   311,   312,   124,   125,    47,   526,   527,   121,   297,
     298,   244,   245,   391,   366,   299,   258,   627,    69,   259,
     591,   260,   261,   374,   377,    66
}

yyErrPos

YYLTYPE yyErrPos

yylloc

YYLTYPE yylloc

yylval

YYSTYPE yylval

yyMatchDiagram

std::string yyMatchDiagram

yyModulePath

std::string yyModulePath

yynerrs

int yynerrs

yypact

const yytype_int16 yypact[]

static

yyParseCC

cc* yyParseCC

yyParsedExpr

Expr* yyParsedExpr = 0

yyParsedModule

Module* yyParsedModule = 0

yyParsedVar

std::string yyParsedVar

yypgoto

const yytype_int16 yypgoto[]

static

Initial value:

=
{
    -560,  -560,  -560,   517,   -29,  -560,  -560,   224,  -560,  -560,
     147,   149,  -559,  -495,  -560,   150,  -504,  -374,   595,     1,
     487,   153,   344,    -2,     0,   -32,   394,   -52,  -560,   434,
    -560,   420,     4,   -17,  -560,   429,  -560,   140,  -560,  -560,
      81,   -41,  -560,  -560,   317,   319,  -560,  -134,   -43,  -161,
    -560,  -170,   323,  -560,   -22,   -42,  -560,   158,   -21,    41,
     610,  -560,   375,  -560,   520,   -74,   859,  -560,   521,  -560,
    -560,  -560,  -560,  -560,  -560,   561
}

yyr1

const yytype_uint8 yyr1[]

static

yyr2

const yytype_uint8 yyr2[]

static

yystos

const yytype_uint8 yystos[]

static

yytable

const yytype_int16 yytable[]

static

yytname

const char* const yytname[]

static

yytranslate

const yytype_uint8 yytranslate[]

static

yyVexpLexError

std::string yyVexpLexError