#ifndef ASFIX_ACCESS_H
#define ASFIX_ACCESS_H

ATermList AFTgetEqs(ATerm mod);
ATerm AFTgetEquLhs(ATerm equation);
ATermList AFTgetSections(ATerm mod);
ATermList AFTgetSorts(ATerm mod);
ATermList AFTgetLexFunctions(ATerm mod);
ATermList AFTgetCFFunctions(ATerm mod);
ATerm AFTgetProdRhs(ATerm prod);
ATerm AFTmakeCallerProd(ATerm prod);
ATerm AFTflattenSdf2Prod(ATerm modname, ATerm prod);

/* Some sanity checking macros */
#define AFTcheckAppl(t,prod) (asfix_is_appl(t) && \
			      AFTcheck(ATgetArgument((ATermAppl)t, 0), prod))
#define AFTcheck(t,prod)  (ATisEqual(t,prod))
#define AFgetApplArg(t,nr) (AFTarg(t,nr))
#define AFTarg(t,nr)      (ATelementAt((ATermList)ATgetArgument((ATermAppl)t, 2), nr))

/* Checking macros */
#define AFTisWS(ws)                     (ATgetAFun((ATermAppl)ws) == symbol_w)
#define AFTisEquSection(section)	(AFTcheckAppl(section, af_prod_equ_section))
#define AFTisSimpleCondEqu(equ)		(AFTcheckAppl(equ, af_prod_simple_cond_equ))
#define AFTisImpliesCondEqu(equ)	(AFTcheckAppl(equ, af_prod_implies_cond_equ))
#define AFTisWhenCondEqu(equ)		(AFTcheckAppl(equ, af_prod_when_cond_equ))
#define AFTisModule(module)	        (AFTcheckAppl(module, af_prod_module))
#define AFTisSections(sections)	        (AFTcheckAppl(sections, af_prod_sections))
#define AFTisExportsSection(section)	(AFTcheckAppl(section, af_prod_exports_section))
#define AFTisHiddensSection(section)	(AFTcheckAppl(section, af_prod_hiddens_section))
#define AFTisGrammars(grammar)    	(AFTcheckAppl(grammar, af_prod_grammars))
#define AFTisSortsGrammar(grammar)    	(AFTcheckAppl(grammar, af_prod_sorts_grammar))
#define AFTisSymbols(symbol)    	(AFTcheckAppl(symbol, af_prod_symbols))
#define AFTisLexicalFuncsGrammar(grammar) (AFTcheckAppl(grammar, \
                                           af_prod_lexfuncs_grammar))
#define AFTisContextFreeFuncsGrammar(grammar) (AFTcheckAppl(grammar, \
                                               af_prod_cffuncs_grammar))
#define AFTisProds(prod)    	       (AFTcheckAppl(prod, af_prod_prods))
#define AFTisProd(prod)    	       (AFTcheckAppl(prod, af_prod_prod))
#define AFTisSortSymbol(symbol)        (AFTcheckAppl(symbol, \
                                        af_prod_sort_symbol))
#define AFTisLiteralSymbol(symbol)     (AFTcheckAppl(symbol, \
                                        af_prod_literal_symbol))
#define AFTisUQLiteralSymbol(symbol)     (AFTcheckAppl(symbol, \
                                          af_prod_uqliteral_symbol))
#define AFTisStarListSymbol(symbol)    (AFTcheckAppl(symbol, \
                                        af_prod_star_list_symbol))
#define AFTisStarSepListSymbol(symbol) (AFTcheckAppl(symbol, \
                                        af_prod_star_sep_list_symbol))
#define AFTisPlusListSymbol(symbol)    (AFTcheckAppl(symbol, \
                                        af_prod_plus_list_symbol))
#define AFTisPlusSepListSymbol(symbol) (AFTcheckAppl(symbol, \
                                        af_prod_plus_sep_list_symbol))
#define AFTisEmptyAttrs(attr)       (AFTcheckAppl(attr, af_prod_empty_attrs))
#define AFTisAttrs(attr)            (AFTcheckAppl(attr, af_prod_attrs))
#define AFTisAssocAttr(attr)        (AFTcheckAppl(attr, af_prod_assoc_attr))
#define AFTisLeftAssoc(attr)        (AFTcheckAppl(attr, af_prod_left_assoc))
#define AFTisRightAssoc(attr)       (AFTcheckAppl(attr, af_prod_right_assoc))
#define AFTisAssocAssoc(attr)       (AFTcheckAppl(attr, af_prod_assoc_assoc))
#define AFTisNonAssocAssoc(attr)    (AFTcheckAppl(attr, \
                                                  af_prod_nonassoc_assoc))
#define AFTisBracketAssoc(attr)     (AFTcheckAppl(attr, \
                                                  af_prod_bracket_assoc))
#define AFTisConstructorAssoc(attr) (AFTcheckAppl(attr, \
                                                  af_prod_constructor_assoc)) 
#define AFTisMemoAssoc(attr)        (AFTcheckAppl(attr, af_prod_memo_assoc)) 
#define AFTisRejectAssoc(attr)      (AFTcheckAppl(attr, af_prod_reject_assoc))

#define AFTisList(list)		(ATgetAFun((ATermAppl)list) == af_symbol_list)

#define AFTisSimpleEqu(equ)	(asfix_is_appl(equ))
#define AFTisCond(cond)	        (asfix_is_appl(cond))
#define AFTisEqualityCond(cond) (ATisEqual(AFTarg((cond),2), \
                                 pattern_asfix_equal_symbol))
#define AFTisConds(conds)       (AFTcheckAppl((conds), (af_prod_conds)))

#define AFTisLexConstructor(t) (asfix_is_appl(t) && \
                                ATmatchTerm(ATgetArgument((ATermAppl)(t),0), \
                                pattern_asfix_lex_cons, NULL, NULL))

extern ATbool AFTisDefaultTag(ATerm tag);

/* Access functions */
extern ATerm AFTgetEquLhs(ATerm equ);

/* Access macros */
#define AFTgetEquSectionLit(s)        (AFTarg((s), 0))
#define AFTgetEquSectionWS(s)	      (AFTarg((s), 1))
#define AFTgetEquSectionEqList(s)     (AFTarg((s), 2))

#define AFTgetSimpleCondEquTag(equ)		(AFTarg((equ), 0))
#define AFTgetSimpleCondEquWS(equ)		(AFTarg((equ), 1))
#define AFTgetSimpleCondEquEqu(equ)		(AFTarg((equ), 2))

#define AFTgetImpliesCondEquTag(equ)	(AFTarg((equ), 0))
#define AFTgetImpliesCondEquWS0(equ)	(AFTarg((equ), 1))
#define AFTgetImpliesCondEquConds(equ)	(AFTarg((equ), 2))
#define AFTgetImpliesCondEquWS1(equ)	(AFTarg((equ), 3))
#define AFTgetImpliesCondEquBarLex(equ)	(AFTarg((equ), 4))
#define AFTgetImpliesCondEquWS2(equ)	(AFTarg((equ), 5))
#define AFTgetImpliesCondEquEqu(equ)	(AFTarg((equ), 6))

#define AFTgetWhenCondEquTag(equ)		(AFTarg((equ), 0))
#define AFTgetWhenCondEquWS0(equ)		(AFTarg((equ), 1))
#define AFTgetWhenCondEquEqu(equ)		(AFTarg((equ), 2))
#define AFTgetWhenCondEquWS1(equ)		(AFTarg((equ), 3))
#define AFTgetWhenCondEquLit(equ)		(AFTarg((equ), 4))
#define AFTgetWhenCondEquWS2(equ)		(AFTarg((equ), 5))
#define AFTgetWhenCondEquConds(equ)		(AFTarg((equ), 6))

#define AFTgetSimpleEquProd(equ)    (ATgetArgument((equ), 0))
#define AFTgetSimpleEquLHS(equ)	    (AFTarg((equ), 0))
#define AFTgetSimpleEquWS0(equ)	    (AFTarg((equ), 1))
#define AFTgetSimpleEquLit(equ)	    (AFTarg((equ), 2))
#define AFTgetSimpleEquWS1(equ)	    (AFTarg((equ), 3))
#define AFTgetSimpleEquRHS(equ)	    (AFTarg((equ), 4))

#define AFTgetListIter(l)	 (ATgetArgument((l), 0))
#define AFTgetListWS(l)		 (ATgetArgument((l), 1))
#define AFTgetListElements(l)	 ((ATermList)ATgetArgument((l), 2))

#define AFTgetCondsCondList(conds)  (AFTarg((conds), 0))

#define AFTgetCondProd(cond)      (ATgetArgument((cond), 0))
#define AFTgetCondLHS(cond)	  (AFTarg((cond), 0))
#define AFTgetCondWS0(cond)	  (AFTarg((cond), 1))
#define AFTgetCondLit(cond)	  (AFTarg((cond), 2))
#define AFTgetCondWS1(cond)	  (AFTarg((cond), 3))
#define AFTgetCondRHS(cond)	  (AFTarg((cond), 4))

#define AFTgetModuleLit(m)        (AFTarg((m), 0))
#define AFTgetModuleWS0(m)	  (AFTarg((m), 1))
#define AFTgetModuleName(m)       (AFTarg((m), 2))
#define AFTgetModuleWS1(m)	  (AFTarg((m), 3))
#define AFTgetModuleImportList(m) (AFTarg((m), 4))
#define AFTgetModuleWS2(m)	  (AFTarg((m), 5))
#define AFTgetModuleSections(m)   (AFTarg((m), 6))

#define AFTgetSectionsList(s)     (AFTarg((s), 0))

#define AFTgetSectionLit(s)     (AFTarg((s), 0))
#define AFTgetSectionWS(s)      (AFTarg((s), 1))
#define AFTgetSectionGrammar(s) (AFTarg((s), 2))

#define AFTgetGrammarSection1(g)  (AFTarg((g), 0))
#define AFTgetGrammarWS(g)        (AFTarg((g), 1))
#define AFTgetGrammarSection2(g)  (AFTarg((g), 2))

#define AFTgetSymbolsList(s)     (AFTarg((s), 0))

#define AFTgetSortsLit(s)     (AFTarg((s), 0))
#define AFTgetSortsWS(s)      (AFTarg((s), 1))
#define AFTgetSortsSymbols(s) (AFTarg((s), 2))

#define AFTgetProdsList(s)     (AFTarg((s), 0))

#define AFTgetLexicalFuncsLit0(s)     (AFTarg((s), 0))
#define AFTgetLexicalFuncsWS0(s)      (AFTarg((s), 1))
#define AFTgetLexicalFuncsLit1(s)     (AFTarg((s), 2))
#define AFTgetLexicalFuncsWS1(s)      (AFTarg((s), 3))
#define AFTgetLexicalFuncsProds(s)    (AFTarg((s), 4))

#define AFTgetContextFreeFuncsLit0(s)     (AFTarg((s), 0))
#define AFTgetContextFreeFuncsWS0(s)      (AFTarg((s), 1))
#define AFTgetContextFreeFuncsLit1(s)     (AFTarg((s), 2))
#define AFTgetContextFreeFuncsWS1(s)      (AFTarg((s), 3))
#define AFTgetContextFreeFuncsProds(s)    (AFTarg((s), 4))

#define AFTgetProdSymbols(p) (AFTarg((p), 0))
#define AFTgetProdWS0(p)     (AFTarg((p), 1))
#define AFTgetProdLit(p)     (AFTarg((p), 2))
#define AFTgetProdWS1(p)     (AFTarg((p), 3))
#define AFTgetProdSymbol(p)  (AFTarg((p), 4))
#define AFTgetProdWS2(p)     (AFTarg((p), 5))
#define AFTgetProdAttrs(p)   (AFTarg((p), 6))

#define AFTgetAttrsLit0(p) (AFTarg((p), 0))
#define AFTgetAttrsWS0(p)  (AFTarg((p), 1))
#define AFTgetAttrsList(p) (AFTarg((p), 2))
#define AFTgetAttrsWS1(p)  (AFTarg((p), 3))
#define AFTgetAttrsLit1(p) (AFTarg((p), 4))

#define AFTgetAssocAttr(a) (AFTarg((a), 0))
#define AFTgetArgAssoc(a) (AFTarg((a), 0))

#define AFTgetSortSymbol(p) (AFTarg((p), 0))
#define AFTgetLiteralSymbol(p) (AFTarg((p), 0))
#define AFTgetUQLiteralLiteral(p) (AFTarg((p), 0))
 
#define AFTgetStarListSort(s) (AFTarg((s), 0))
#define AFTgetStarListWS0(s)  (AFTarg((s), 1)) 
#define AFTgetStarListStar(s) (AFTarg((s), 2))

#define AFTgetStarSepListLit0(s) (AFTarg((s), 0))
#define AFTgetStarSepListWS0(s)  (AFTarg((s), 1))
#define AFTgetStarSepListSort(s) (AFTarg((s), 2))
#define AFTgetStarSepListWS1(s)  (AFTarg((s), 3))
#define AFTgetStarSepListSep(s)  (AFTarg((s), 4))
#define AFTgetStarSepListWS2(s)  (AFTarg((s), 5))
#define AFTgetStarSepListLit1(s) (AFTarg((s), 6))
#define AFTgetStarSepListWS3(s)  (AFTarg((s), 7))
#define AFTgetStarSepListStar(s) (AFTarg((s), 8))
 
#define AFTgetPlusListSort(s) (AFTarg((s), 0))
#define AFTgetPlusListWS0(s)  (AFTarg((s), 1)) 
#define AFTgetPlusListStar(s) (AFTarg((s), 2))

#define AFTgetPlusSepListLit0(s) (AFTarg((s), 0))
#define AFTgetPlusSepListWS0(s)  (AFTarg((s), 1))
#define AFTgetPlusSepListSort(s) (AFTarg((s), 2))
#define AFTgetPlusSepListWS1(s)  (AFTarg((s), 3))
#define AFTgetPlusSepListSep(s)  (AFTarg((s), 4))
#define AFTgetPlusSepListWS2(s)  (AFTarg((s), 5))
#define AFTgetPlusSepListLit1(s) (AFTarg((s), 6))
#define AFTgetPlusSepListWS3(s)  (AFTarg((s), 7))
#define AFTgetPlusSepListPlus(s) (AFTarg((s), 8))


/* Construction macro's */
#define AFTbuildEquSection(lit,ws,equlist) \
	(AFmakeAppl(af_prod_equ_section, ATmakeList3((lit), (ws), (equlist))))
#define AFTbuildList(iter,ws,elems) \
	((ATerm)ATmakeAppl3(af_symbol_list, (iter), (ws), (ATerm)(elems)))

#define AFTbuildSimpleCondEqu(tag,w,equ) \
	(AFmakeAppl(af_prod_simple_cond_equ,ATmakeList3((tag), (w), (equ))))
#define AFTbuildImpliesCondEqu(tag,w0,conds,w1,lit,w2,equ) \
	(AFmakeAppl(af_prod_implies_cond_equ, \
		ATmakeList(7,(tag),(w0),(conds),(w1),(lit),(w2),(equ))))
#define AFTbuildWhenCondEqu(tag,w0,equ,w1,lit,w2,conds) \
	(AFmakeAppl(af_prod_when_cond_equ, \
		ATmakeList(7,(tag),(w0),(equ),(w1),(lit),(w2),(conds))))
#define AFTbuildSimpleEqu(prod,lhs,w0,lit,w1,rhs) \
	(AFmakeAppl((prod), ATmakeList5((lhs),(w0),(lit),(w1),(rhs))))
#define AFTbuildConds(condlist) \
  (AFmakeAppl(af_prod_conds, ATmakeList1((condlist))))
#define AFTbuildCond(prod,lhs,w0,lit,w1,rhs) \
	(AFmakeAppl(prod, ATmakeList5((lhs),(w0),(lit),(w1),(rhs))))

/* Well-known symbols */
extern AFun af_symbol_list;

/* Well-known prods */
extern ATerm pattern_asfix_sort;
extern ATerm pattern_asfix_iter_star;
extern ATerm pattern_asfix_iter_plus;
extern ATerm pattern_asfix_itersep_star;
extern ATerm pattern_asfix_itersep_plus;
extern ATerm pattern_asfix_l;
extern ATerm pattern_asfix_ql;
extern ATerm pattern_asfix_lexcaller;
extern ATerm pattern_asfix_appl;
extern ATerm pattern_asfix_lex_cons;

extern ATerm af_prod_equ_section;
extern ATerm af_prod_simple_cond_equ;
extern ATerm af_prod_implies_cond_equ;
extern ATerm af_prod_when_cond_equ;
extern ATerm af_prod_conds;
extern ATerm af_prod_tag;
extern ATerm af_prod_module;
extern ATerm af_prod_sections;
extern ATerm af_prod_exports_section;
extern ATerm af_prod_hiddens_section;
extern ATerm af_prod_grammars;
extern ATerm af_prod_sorts_grammar;
extern ATerm af_prod_symbols;
extern ATerm af_prod_lexfuncs_grammar;
extern ATerm af_prod_cffuncs_grammar;
extern ATerm af_prod_prods;
extern ATerm af_prod_prod;
extern ATerm af_prod_sort_symbol;
extern ATerm af_prod_literal_symbol;
extern ATerm af_prod_uqliteral_symbol;
extern ATerm af_prod_star_list_symbol;
extern ATerm af_prod_star_sep_list_symbol;
extern ATerm af_prod_plus_list_symbol;
extern ATerm af_prod_plus_sep_list_symbol;
extern ATerm af_prod_empty_attrs;
extern ATerm af_prod_attrs;
extern ATerm af_prod_assoc_attr;
extern ATerm af_prod_left_assoc;
extern ATerm af_prod_right_assoc;
extern ATerm af_prod_assoc_assoc;
extern ATerm af_prod_nonassoc_assoc;
extern ATerm af_prod_bracket_assoc;
extern ATerm af_prod_constructor_assoc;
extern ATerm af_prod_memo_assoc;
extern ATerm af_prod_reject_assoc;

/* Some other useful terms */
extern ATerm af_iter_eqlist;
extern ATerm pattern_asfix_equal_symbol;

#endif