* Defines storage datatypes: Text, Name, Module, Tycon, Cell, List, Pair,
* Triple, ...
*
- * Hugs 98 is Copyright (c) Mark P Jones, Alastair Reid and the Yale
- * Haskell Group 1994-99, and is distributed as Open Source software
- * under the Artistic License; see the file "Artistic" that is included
- * in the distribution for details.
+ * The Hugs 98 system is Copyright (c) Mark P Jones, Alastair Reid, the
+ * Yale Haskell Group, and the Oregon Graduate Institute of Science and
+ * Technology, 1994-1999, All rights reserved. It is distributed as
+ * free software under the license in the file "License", which is
+ * included in the distribution.
*
* $RCSfile: storage.h,v $
- * $Revision: 1.3 $
- * $Date: 1999/02/03 17:08:41 $
+ * $Revision: 1.14 $
+ * $Date: 1999/11/29 18:59:34 $
* ------------------------------------------------------------------------*/
/* --------------------------------------------------------------------------
* names, string literals, character constants etc...
* ------------------------------------------------------------------------*/
-extern String textToStr Args((Text));
-extern Text findText Args((String));
-extern Text inventText Args((Void));
-extern Text inventDictText Args((Void));
-extern Bool inventedText Args((Text));
+extern String textToStr Args((Text));
+extern Text findText Args((String));
+extern Text inventText Args((Void));
+extern Text inventDictText Args((Void));
+extern Bool inventedText Args((Text));
+extern Text enZcodeThenFindText Args((String));
+extern Text unZcodeThenFindText Args((String));
/* Variants of textToStr and syntaxOf which work for idents, ops whether
* qualified or unqualified.
*/
extern String identToStr Args((Cell));
+extern Text fixLitText Args((Text));
extern Syntax identSyntax Args((Cell));
extern Syntax defaultSyntax Args((Text));
#define fst(c) heapTopFst[c]
#define snd(c) heapTopSnd[c]
-#if PROFILING
-extern Heap heapThd, heapTopThd;
-#define thd(c) heapTopThd[c]
-extern Name producer;
-extern Bool profiling;
-extern Int profInterval;
-extern Void profilerLog Args((String));
-#endif
extern Pair pair Args((Cell,Cell));
extern Void garbageCollect Args((Void));
* ------------------------------------------------------------------------*/
#define TAGMIN 1 /* Box and constructor cell tag values */
-#define BCSTAG 20 /* Box=TAGMIN..BCSTAG-1 */
+#define BCSTAG 30 /* Box=TAGMIN..BCSTAG-1 */
#define isTag(c) (TAGMIN<=(c) && (c)<SPECMIN) /* Tag cell values */
#define isBoxTag(c) (TAGMIN<=(c) && (c)<BCSTAG) /* Box cell tag values */
#define isConTag(c) (BCSTAG<=(c) && (c)<SPECMIN) /* Constr cell tag values*/
#define BIGCELL 16 /* Integer literal: snd :: Text */
#if PTR_ON_HEAP
#define PTRCELL 17 /* C Heap Pointer snd :: Ptr */
+#if IPARAM
+#define IPCELL 19 /* Imp Param Cell: snd :: Text */
+#define IPVAR 20 /* ?x: snd :: Text */
+#endif
+#define CPTRCELL 21 /* Native code pointer snd :: Ptr */
#endif
#if TREX
-#define EXTCOPY 18 /* Copy of an Ext: snd :: Text */
+#define EXTCOPY 22 /* Copy of an Ext: snd :: Text */
+#endif
+
+//#define textOf(c) ((Text)(snd(c))) /* c :: (VAR|CON)(ID|OP) */
+
+#if 1
+static Text textOf( Cell c )
+{
+ Bool ok =
+ (whatIs(c)==VARIDCELL
+ || whatIs(c)==CONIDCELL
+ || whatIs(c)==VAROPCELL
+ || whatIs(c)==CONOPCELL
+ || whatIs(c)==STRCELL
+ || whatIs(c)==DICTVAR
+ );
+ if (!ok) {
+fprintf(stderr, "\ntextOf -- tag %d\n",whatIs(c) );
+ assert(ok);
+ }
+ return snd(c);
+}
#endif
-#define textOf(c) ((Text)(snd(c))) /* c :: (VAR|CON)(ID|OP) */
#define qmodOf(c) (textOf(fst(snd(c)))) /* c :: QUALIDENT */
#define qtextOf(c) (textOf(snd(snd(c)))) /* c :: QUALIDENT */
#define mkVar(t) ap(VARIDCELL,t)
#define mkDictVar(t) ap(DICTVAR,t)
#define inventDictVar() mkDictVar(inventDictText())
#define mkStr(t) ap(STRCELL,t)
+#if IPARAM
+#define mkIParam(c) ap(IPCELL,snd(c))
+#define isIP(p) (whatIs(p) == IPCELL)
+#define ipMatch(pi, t) (isIP(fun(pi)) && textOf(fun(pi)) == t)
+#define ipVar(pi) textOf(fun(pi))
+#else
+#define isIP(p) FALSE
+#endif
extern Bool isVar Args((Cell));
extern Bool isCon Args((Cell));
extern Bool isQVar Args((Cell));
extern Bool isQualIdent Args((Cell));
extern Bool isIdent Args((Cell));
-#if 0
-Originally ...
-#define isFloat(c) (isPair(c) && fst(c)==FLOATCELL)
-extern Cell mkFloat Args((FloatPro));
-extern FloatPro floatOf Args((Cell));
-extern String floatToString Args((FloatPro));
-extern FloatPro stringToFloat Args((String));
-#else
-#define isFloat(c) (isPair(c) && fst(c)==FLOATCELL)
-#define stringToFloat(s) pair(FLOATCELL,findText(s))
-#define floatToString(f) textToStr(snd(f))
-#define floatEq(f1,f2) (snd(f1) == snd(f2))
-#define floatNegate(f) stringToFloat(stringNegate(floatToString(f)))
-#define floatOf(f) atof(floatToString(f))
-#endif
-
-
-
+extern String stringNegate Args((String));
#define isFloat(c) (isPair(c) && fst(c)==FLOATCELL)
#define stringToFloat(s) pair(FLOATCELL,findText(s))
#define floatToString(f) textToStr(snd(f))
-#define floatEq(f1,f2) (snd(f1) == snd(f2))
-#define floatNegate(f) stringToFloat(stringNegate(floatToString(f)))
#define floatOf(f) atof(floatToString(f))
#define mkFloat(f) (f) /* ToDo: is this right? */
+#define floatNegate(f) stringToFloat(stringNegate(floatToString(f)))
+#define stringToBignum(s) pair(BIGCELL,findText(s))
#define bignumToString(b) textToStr(snd(b))
#define isPtr(c) (isPair(c) && fst(c)==PTRCELL)
extern Cell mkPtr Args((Ptr));
extern Ptr ptrOf Args((Cell));
+#define isCPtr(c) (isPair(c) && fst(c)==CPTRCELL)
+extern Cell mkCPtr Args((Ptr));
+extern Ptr cptrOf Args((Cell));
#endif
/* --------------------------------------------------------------------------
* element is a special cell will be treated as an application node.
* ------------------------------------------------------------------------*/
-#define LETREC 20 /* LETREC snd :: ([Decl],Exp) */
-#define COND 21 /* COND snd :: (Exp,Exp,Exp) */
-#define LAMBDA 22 /* LAMBDA snd :: Alt */
-#define FINLIST 23 /* FINLIST snd :: [Exp] */
-#define DOCOMP 24 /* DOCOMP snd :: (Exp,[Qual]) */
-#define BANG 25 /* BANG snd :: Type */
-#define COMP 26 /* COMP snd :: (Exp,[Qual]) */
-#define ASPAT 27 /* ASPAT snd :: (Var,Exp) */
-#define ESIGN 28 /* ESIGN snd :: (Exp,Type) */
-#define RSIGN 29 /* RSIGN snd :: (Rhs,Type) */
-#define CASE 30 /* CASE snd :: (Exp,[Alt]) */
-#define NUMCASE 31 /* NUMCASE snd :: (Exp,Disc,Rhs) */
-#define FATBAR 32 /* FATBAR snd :: (Exp,Exp) */
-#define LAZYPAT 33 /* LAZYPAT snd :: Exp */
-#define DERIVE 35 /* DERIVE snd :: Cell */
+#define LETREC 30 /* LETREC snd :: ([Decl],Exp) */
+#define COND 31 /* COND snd :: (Exp,Exp,Exp) */
+#define LAMBDA 32 /* LAMBDA snd :: Alt */
+#define FINLIST 33 /* FINLIST snd :: [Exp] */
+#define DOCOMP 34 /* DOCOMP snd :: (Exp,[Qual]) */
+#define BANG 35 /* BANG snd :: Type */
+#define COMP 36 /* COMP snd :: (Exp,[Qual]) */
+#define ASPAT 37 /* ASPAT snd :: (Var,Exp) */
+#define ESIGN 38 /* ESIGN snd :: (Exp,Type) */
+#define RSIGN 39 /* RSIGN snd :: (Rhs,Type) */
+#define CASE 40 /* CASE snd :: (Exp,[Alt]) */
+#define NUMCASE 41 /* NUMCASE snd :: (Exp,Disc,Rhs) */
+#define FATBAR 42 /* FATBAR snd :: (Exp,Exp) */
+#define LAZYPAT 43 /* LAZYPAT snd :: Exp */
+#define DERIVE 45 /* DERIVE snd :: Cell */
#if BREAK_FLOATS
-#define FLOATCELL 36 /* FLOATCELL snd :: (Int,Int) */
-#endif
-
-#if BIGNUMS
-#define POSNUM 37 /* POSNUM snd :: [Int] */
-#define NEGNUM 38 /* NEGNUM snd :: [Int] */
+#define FLOATCELL 46 /* FLOATCELL snd :: (Int,Int) */
#endif
-#define BOOLQUAL 39 /* BOOLQUAL snd :: Exp */
-#define QWHERE 40 /* QWHERE snd :: [Decl] */
-#define FROMQUAL 41 /* FROMQUAL snd :: (Exp,Exp) */
-#define DOQUAL 42 /* DOQUAL snd :: Exp */
-#define MONADCOMP 43 /* MONADCOMP snd :: ((m,m0),(Exp,[Qual])*/
+#define BOOLQUAL 49 /* BOOLQUAL snd :: Exp */
+#define QWHERE 50 /* QWHERE snd :: [Decl] */
+#define FROMQUAL 51 /* FROMQUAL snd :: (Exp,Exp) */
+#define DOQUAL 52 /* DOQUAL snd :: Exp */
+#define MONADCOMP 53 /* MONADCOMP snd :: ((m,m0),(Exp,[Qual])*/
-#define GUARDED 44 /* GUARDED snd :: [guarded exprs] */
+#define GUARDED 54 /* GUARDED snd :: [guarded exprs] */
-#define ARRAY 45 /* Array snd :: (Bounds,[Values]) */
-#define MUTVAR 46 /* Mutvar snd :: Cell */
+#define ARRAY 55 /* Array snd :: (Bounds,[Values]) */
+#define MUTVAR 56 /* Mutvar snd :: Cell */
#if INTERNAL_PRIMS
-#define HUGSOBJECT 47 /* HUGSOBJECT snd :: Cell */
+#define HUGSOBJECT 57 /* HUGSOBJECT snd :: Cell */
#endif
-#define POLYTYPE 50 /* POLYTYPE snd :: (Kind,Type) */
-#define QUAL 51 /* QUAL snd :: ([Classes],Type) */
-#define RANK2 52 /* RANK2 snd :: (Int,Type) */
-#define EXIST 53 /* EXIST snd :: (Int,Type) */
-#define POLYREC 54 /* POLYREC snd :: (Int,Type) */
-#define BIGLAM 55 /* BIGLAM snd :: (vars,patterns) */
-#define CDICTS 56 /* CDICTS snd :: ([Pred],Type) */
-
-#define LABC 60 /* LABC snd :: (con,[(Vars,Type)]) */
-#define CONFLDS 61 /* CONFLDS snd :: (con,[Field]) */
-#define UPDFLDS 62 /* UPDFLDS snd :: (Exp,[con],[Field]) */
+#if IPARAM
+#define WITHEXP 58 /* WITHEXP snd :: [(Var,Exp)] */
+#endif
+
+
+#define POLYTYPE 60 /* POLYTYPE snd :: (Kind,Type) */
+#define QUAL 61 /* QUAL snd :: ([Classes],Type) */
+#define RANK2 62 /* RANK2 snd :: (Int,Type) */
+#define EXIST 63 /* EXIST snd :: (Int,Type) */
+#define POLYREC 64 /* POLYREC snd :: (Int,Type) */
+#define BIGLAM 65 /* BIGLAM snd :: (vars,patterns) */
+#define CDICTS 66 /* CDICTS snd :: ([Pred],Type) */
+
+#define LABC 67 /* LABC snd :: (con,[(Vars,Type)]) */
+#define CONFLDS 68 /* CONFLDS snd :: (con,[Field]) */
+#define UPDFLDS 69 /* UPDFLDS snd :: (Exp,[con],[Field]) */
#if TREX
-#define RECORD 63 /* RECORD snd :: [Val] */
-#define EXTCASE 64 /* EXTCASE snd :: (Exp,Disc,Rhs) */
-#define RECSEL 65 /* RECSEL snd :: Ext */
+#define RECORD 70 /* RECORD snd :: [Val] */
+#define EXTCASE 71 /* EXTCASE snd :: (Exp,Disc,Rhs) */
+#define RECSEL 72 /* RECSEL snd :: Ext */
#endif
-#define IMPDEPS 68 /* IMPDEPS snd :: [Binding] */
+#define IMPDEPS 73 /* IMPDEPS snd :: [Binding] */
+
+#define QUALIDENT 74 /* Qualified identifier snd :: (Id,Id) */
+#define HIDDEN 75 /* hiding import list snd :: [Entity] */
+#define MODULEENT 76 /* module in export list snd :: con */
-#define QUALIDENT 70 /* Qualified identifier snd :: (Id,Id) */
-#define HIDDEN 71 /* hiding import list snd :: [Entity] */
-#define MODULEENT 72 /* module in export list snd :: con */
+#define INFIX 77 /* INFIX snd :: (see tidyInfix) */
+#define ONLY 78 /* ONLY snd :: Exp */
+#define NEG 79 /* NEG snd :: Exp */
-#define INFIX 80 /* INFIX snd :: (see tidyInfix) */
-#define ONLY 81 /* ONLY snd :: Exp */
-#define NEG 82 /* NEG snd :: Exp */
+/* Used when parsing GHC interface files */
+#define DICTAP 80 /* DICTTYPE snd :: (QClassId,[Type]) */
#if SIZEOF_INTP != SIZEOF_INT
-#define PTRCELL 90 /* C Heap Pointer snd :: (Int,Int) */
+#define PTRCELL 81 /* C Heap Pointer snd :: (Int,Int) */
#endif
#define STGVAR 92 /* STGVAR snd :: (StgRhs,info) */
#define STGPRIM 94 /* STGPRIM snd :: (PrimOp,[Arg]) */
#define STGCON 95 /* STGCON snd :: (StgCon,[Arg]) */
#define PRIMCASE 96 /* PRIMCASE snd :: (Expr,[PrimAlt]) */
-
+#define DEEFALT 97 /* DEEFALT snd :: (Var,Expr) */
+#define CASEALT 98 /* CASEALT snd :: (Con,[Var],Expr) */
+#define PRIMALT 99 /* PRIMALT snd :: ([Var],Expr) */
/* Last constructor tag must be less than SPECMIN */
/* --------------------------------------------------------------------------
#define DOTDOT 106 /* ".." in import/export list */
-#if BIGNUMS
-#define ZERONUM 108 /* The zero bignum (see POSNUM, NEGNUM) */
-#endif
-
#define NAME 110 /* whatIs code for isName */
#define TYCON 111 /* whatIs code for isTycon */
#define CLASS 112 /* whatIs code for isClass */
#endif
#define mkTuple(n) (TUPMIN+(n))
#define tupleOf(n) ((Int)((n)-TUPMIN))
+extern Text ghcTupleText Args((Tycon));
+
+
#if TREX
#define EXTMIN (TUPMIN+NUM_TUPLES)
#define mkOffset(o) (OFFMIN+(o))
/* --------------------------------------------------------------------------
+ * Object symbols:
+ * ------------------------------------------------------------------------*/
+
+/* An entry in a very crude object symbol table */
+typedef struct { char* nm; void* ad; }
+ OSym;
+
+/* Indication of section kinds for loaded objects. Needed by
+ the GC for deciding whether or not a pointer on the stack
+ is a code pointer.
+*/
+typedef enum { HUGS_DL_SECTION_CODE_OR_RODATA,
+ HUGS_DL_SECTION_RWDATA,
+ HUGS_DL_SECTION_OTHER }
+ DLSect;
+
+typedef struct { void* start; void* end; DLSect sect; }
+ DLTabEnt;
+
+/* --------------------------------------------------------------------------
* Modules:
* ------------------------------------------------------------------------*/
#define MODMIN (OFFMIN+NUM_OFFSETS)
-#if IGNORE_MODULES
-#define setCurrModule(m) doNothing()
-#else /* !IGNORE_MODULES */
#define isModule(c) (MODMIN<=(c) && (c)<TYCMIN)
#define mkModule(n) (MODMIN+(n))
#define module(n) tabModule[(n)-MODMIN]
* evaluating an expression in the context of the current module.
*/
List qualImports;
- ObjectFile objectFile; /* usually unused */
+
+ /* ptr to malloc'd lump of memory holding the obj file */
+ void* oImage;
+
+ /* ptr to object symbol table; lives in mallocville.
+ Dynamically expands. */
+ OSym* oTab;
+ Int sizeoTab;
+ Int usedoTab;
+
+ /* The section-kind entries for this object module. Dynamically expands. */
+ DLTabEnt* dlTab;
+ Int sizedlTab;
+ Int useddlTab;
};
extern Module currentModule; /* Module currently being processed */
extern Module findModid Args((Cell));
extern Void setCurrModule Args((Module));
+extern void addOTabName Args((Module,char*,void*));
+extern void* lookupOTabName Args((Module,char*));
+extern char* nameFromOPtr Args((void*));
+
+extern void addDLSect Args((Module,void*,void*,DLSect));
+extern DLSect lookupDLSect Args((void*));
+
+
#define isPrelude(m) (m==modulePrelude)
-#endif /* !IGNORE_MODULES */
/* --------------------------------------------------------------------------
* Type constructor names:
#define tycon(n) tabTycon[(n)-TYCMIN]
struct strTycon {
- Text text;
- Int line;
-#if !IGNORE_MODULES
+ Text text;
+ Int line;
Module mod; /* module that defines it */
-#endif
- Int arity;
- Kind kind; /* kind (includes arity) of Tycon */
- Cell what; /* DATATYPE/SYNONYM/RESTRICTSYN... */
- Cell defn;
- Tycon nextTyconHash;
+ Int arity;
+ Kind kind; /* kind (includes arity) of Tycon */
+ Cell what; /* DATATYPE/SYNONYM/RESTRICTSYN... */
+ Cell defn;
+ Name conToTag; /* used in derived code */
+ Name tagToCon;
+ Tycon nextTyconHash;
};
extern struct strTycon DECTABLE(tabTycon);
extern Tycon addPrimTycon Args((Text,Kind,Int,Cell,Cell));
#define isSynonym(h) (isTycon(h) && tycon(h).what==SYNONYM)
+#define isQualType(t) (isPair(t) && fst(t)==QUAL)
#define mkPolyType(n,t) pair(POLYTYPE,pair(n,t))
#define isPolyType(t) (isPair(t) && fst(t)==POLYTYPE)
+#define isPolyOrQualType(t) (isPair(t) && (fst(t)==POLYTYPE || fst(t)==QUAL))
#define polySigOf(t) fst(snd(t))
#define monotypeOf(t) snd(snd(t))
Cell type;
Cell defn;
Cell stgVar; /* really StgVar */
- const void* primop; /* really StgPrim* */
+ Text callconv; /* for foreign import/export */
+ void* primop; /* really StgPrim* */
Name nextNameHash;
};
#define mfunOf(n) ((-1)-name(n).number)
#define mfunNo(i) ((-1)-(i))
-extern Name newName Args((Text,Cell));
-extern Name findName Args((Text));
-extern Name addName Args((Name));
-extern Name findQualName Args((Cell));
-extern Name addPrimCfun Args((Text,Int,Int,Int));
-extern Int sfunPos Args((Name,Name));
+extern Name newName Args((Text,Cell));
+extern Name findName Args((Text));
+extern Name addName Args((Name));
+extern Name findQualName Args((Cell));
+extern Name addPrimCfun Args((Text,Int,Int,Cell));
+extern Name addPrimCfunREP Args((Text,Int,Int,Int));
+extern Int sfunPos Args((Name,Name));
+extern Name nameFromStgVar Args((Cell));
+extern Name jrsFindQualName Args((Text,Text));
/* --------------------------------------------------------------------------
* Type class values:
#define inst(in) tabInst[(in)-INSTMIN]
struct strInst {
- Class c; /* class C */
- Int line;
+ Class c; /* class C */
+ Int line;
Module mod; /* module that defines it */
- Kinds kinds; /* Kinds of variables in head */
- Cell head; /* :: Pred */
- List specifics; /* :: [Pred] */
- Int numSpecifics; /* length(specifics) */
- List implements;
- Name builder; /* Dictionary constructor function */
+ Kinds kinds; /* Kinds of variables in head */
+ Cell head; /* :: Pred */
+ List specifics; /* :: [Pred] */
+ Int numSpecifics; /* length(specifics) */
+ List implements;
+ Name builder; /* Dictionary constructor function */
};
/* a predicate (an element :: Pred) is an application of a Class to one or
struct strClass {
Text text; /* Name of class */
Int line; /* Line where declaration begins */
-#if !IGNORE_MODULES
Module mod; /* module that declares it */
-#endif
Int level; /* Level in class hierarchy */
Int arity; /* Number of arguments */
Kinds kinds; /* Kinds of constructors in class */
+ List fds; /* Functional Dependencies */
+ List xfds; /* Xpanded Functional Dependencies */
Cell head; /* Head of class */
Name dcon; /* Dictionary constructor function */
List supers; /* :: [Pred] */
List dsels; /* Superclass dictionary selectors */
List members; /* :: [Name] */
Int numMembers; /* length(members) */
- Name dbuild; /* Default dictionary builder */
List defaults; /* :: [Name] */
List instances; /* :: [Inst] */
};
#define MAXCHARVAL (NUM_CHARS-1)
#define isChar(c) (CHARMIN<=(c) && (c)<INTMIN)
#define charOf(c) ((Char)(c-CHARMIN))
-#define mkChar(c) ((Cell)(CHARMIN+((unsigned)((c)%NUM_CHARS))))
+#define mkChar(c) ((Cell)(CHARMIN+(((unsigned)(c))%NUM_CHARS)))
/* --------------------------------------------------------------------------
* Small Integer values:
extern Bool isInt Args((Cell));
extern Int intOf Args((Cell));
extern Cell mkInt Args((Int));
-#if BIGNUMS
-extern Bool isBignum Args((Cell));
-#endif
/* --------------------------------------------------------------------------
* Implementation of triples:
extern List dupList Args((List));
extern List revOnto Args((List, List)); /* destructive */
#define rev(xs) revOnto((xs),NIL) /* destructive */
+#define reverse(xs) revOnto(dupList(xs),NIL) /* non-destructive */
extern Cell cellIsMember Args((Cell,List));
extern Cell cellAssoc Args((Cell,List));
extern Cell cellRevAssoc Args((Cell,List));
extern List splitAt Args((Int,List)); /* non-destructive */
extern Cell nth Args((Int,List));
extern List removeCell Args((Cell,List)); /* destructive */
+extern List dupListOnto Args((List,List)); /* non-destructive */
+extern List nubList Args((List)); /* non-destructive */
/* The following macros provide `inline expansion' of some common ways of
* traversing, using and modifying lists:
chkStack(1); \
onto(c); \
} while (0)
-#define onto(c) stack(++sp)=(c)
+#define onto(c) stack(++sp)=(c);
#define pop() stack(sp--)
#define drop() sp--
#define top() stack(sp)
extern Void hugsStackOverflow Args((Void));
+#if SYMANTEC_C
+#include <Memory.h>
+#define STACK_HEADROOM 16384
+#define STACK_CHECK if (StackSpace() <= STACK_HEADROOM) \
+ internal("Macintosh function parameter stack overflow.");
+#else
+#define STACK_CHECK
+#endif
+
/* --------------------------------------------------------------------------
* Script file control:
* The implementation of script file storage is hidden.
extern String fileOfModule Args((Module));
extern Void dropScriptsFrom Args((Script));
-/* --------------------------------------------------------------------------
- * I/O Handles:
- * ------------------------------------------------------------------------*/
-
-#if IO_HANDLES
-#define HSTDIN 0 /* Numbers for standard handles */
-#define HSTDOUT 1
-#define HSTDERR 2
-
-struct strHandle { /* Handle description and status flags */
- Cell hcell; /* Heap representation of handle (or NIL) */
- FILE *hfp; /* Corresponding file pointer */
- Int hmode; /* Current mode: see below */
-};
-
-#define HCLOSED 0000 /* no I/O permitted */
-#define HSEMICLOSED 0001 /* semiclosed reads only */
-#define HREAD 0002 /* set to enable reads from handle */
-#define HWRITE 0004 /* set to enable writes to handle */
-#define HAPPEND 0010 /* opened in append mode */
-
-extern Cell openHandle Args((String,Int,Bool));
-extern struct strHandle DECTABLE(handles);
-#endif
-
-/* --------------------------------------------------------------------------
- * Malloc Pointers
- * ------------------------------------------------------------------------*/
-
-#if GC_MALLOCPTRS
-struct strMallocPtr { /* Malloc Ptr description */
- Cell mpcell; /* Back pointer to MPCELL */
- Void *ptr; /* Pointer into C world */
- Int refCount; /* Reference count */
- Void (*cleanup) Args((Void *)); /* Code to free the C pointer */
-};
-
-extern struct strMallocPtr mallocPtrs[];
-extern Cell mkMallocPtr Args((Void *, Void (*)(Void *)));
-extern Void freeMallocPtr Args((Cell));
-extern Void incMallocPtrRefCnt Args((Int, Int));
-
-#define mpOf(c) snd(c)
-#define derefMP(c) (mallocPtrs[(Int)mpOf(c)].ptr)
-#endif /* GC_MALLOCPTRS */
-
-/* --------------------------------------------------------------------------
- * Weak Pointers
- * ------------------------------------------------------------------------*/
-
-#if GC_WEAKPTRS
-#define mkWeakPtr(c) pair(WEAKCELL,pair(c,NIL))
-#define derefWeakPtr(c) fst(snd(c))
-#define nextWeakPtr(c) snd(snd(c))
-
-extern List finalizers;
-extern List liveWeakPtrs;
-
-#endif /* GC_WEAKPTRS */
-
-/* --------------------------------------------------------------------------
- * Stable pointers
- * ------------------------------------------------------------------------*/
-
-#if GC_STABLEPTRS
-extern Int mkStablePtr Args((Cell));
-extern Cell derefStablePtr Args((Int));
-extern Void freeStablePtr Args((Int));
-#endif /* GC_STABLEPTRS */
/* --------------------------------------------------------------------------
* Plugins
projects / ghc-hetmet.git / blobdiff