* included in the distribution.
*
* $RCSfile: link.c,v $
- * $Revision: 1.37 $
- * $Date: 2000/01/12 14:52:53 $
+ * $Revision: 1.50 $
+ * $Date: 2000/03/13 11:37:16 $
* ------------------------------------------------------------------------*/
#include "prelude.h"
#include "storage.h"
-#include "backend.h"
#include "connect.h"
#include "errors.h"
#include "Assembler.h" /* for asmPrimOps and AsmReps */
-#include "link.h"
Type typeArrow; /* Function spaces */
Name nameOtherwise;
Name nameUndefined; /* generic undefined value */
-#if NPLUSK
Name namePmSub;
-#endif
Name namePMFail;
Name nameEqChar;
Name namePmInt;
*
* ------------------------------------------------------------------------*/
-/* In standalone mode, linkPreludeTC, linkPreludeCM and linkPreludeNames
+/* In standalone mode, linkPreludeTC, linkPreludeCM and linkPrimNames
are called, in that order, during static analysis of Prelude.hs.
In combined mode such an analysis does not happen. Instead these
calls will be made as a result of a call link(POSTPREL).
classFloating = linkClass("Floating");
classNum = linkClass("Num");
classMonad = linkClass("Monad");
-assert(nonNull(typeDouble));
-assert(nonNull(typeInteger));
+
stdDefaults = NIL;
stdDefaults = cons(typeDouble,stdDefaults);
-# if DEFAULT_BIGNUM
stdDefaults = cons(typeInteger,stdDefaults);
-# else
- stdDefaults = cons(typeInt,stdDefaults);
-# endif
predNum = ap(classNum,aVar);
predFractional = ap(classFractional,aVar);
nameEq = linkName("==");
nameFromInt = linkName("fromInt");
nameFromInteger = linkName("fromInteger");
- nameFromDouble = linkName("fromDouble");
nameReturn = linkName("return");
nameBind = linkName(">>=");
+ nameMFail = linkName("fail");
nameLe = linkName("<=");
nameGt = linkName(">");
nameShowsPrec = linkName("showsPrec");
}
}
-Void linkPreludeNames(void) { /* Hook to names defined in Prelude */
+Void linkPrimNames ( void ) { /* Hook to names defined in Prelude */
static Bool initialised = FALSE;
+
if (!initialised) {
- Int i;
initialised = TRUE;
setCurrModule(modulePrelude);
nameMkIO = linkName("hugsprimMkIO");
if (!combined) {
- for (i=0; asmPrimOps[i].name; ++i) {
- Text t = findText(asmPrimOps[i].name);
- Name n = findName(t);
- if (isNull(n)) {
- n = newName(t,NIL);
- }
- name(n).line = 0;
- name(n).defn = NIL;
- name(n).type = primType(asmPrimOps[i].monad,
- asmPrimOps[i].args,
- asmPrimOps[i].results);
- name(n).arity = strlen(asmPrimOps[i].args);
- name(n).primop = &(asmPrimOps[i]);
- implementPrim(n);
- }
+ Int i;
+ for (i=0; asmPrimOps[i].name; ++i) {
+ Text t = findText(asmPrimOps[i].name);
+ Name n = findName(t);
+ if (isNull(n)) {
+ n = newName(t,NIL);
+ name(n).line = 0;
+ name(n).defn = NIL;
+ name(n).type = primType(asmPrimOps[i].monad,
+ asmPrimOps[i].args,
+ asmPrimOps[i].results);
+ name(n).arity = strlen(asmPrimOps[i].args);
+ name(n).primop = &(asmPrimOps[i]);
+ implementPrim(n);
+ } else {
+ ERRMSG(0) "Link Error in Prelude, surplus definition of \"%s\"",
+ asmPrimOps[i].name
+ EEND;
+ // Name already defined!
+ }
+ }
}
+
/* static(tidyInfix) */
nameNegate = linkName("negate");
/* user interface */
nameOtherwise = linkName("otherwise");
nameUndefined = linkName("undefined");
/* pmc */
-# if NPLUSK
namePmSub = linkName("hugsprimPmSub");
-# endif
/* translator */
nameEqChar = linkName("hugsprimEqChar");
nameCreateAdjThunk = linkName("hugsprimCreateAdjThunk");
namePmInt = linkName("hugsprimPmInt");
namePmInteger = linkName("hugsprimPmInteger");
namePmDouble = linkName("hugsprimPmDouble");
-
+
+ nameFromDouble = linkName("fromDouble");
namePmFromInteger = linkName("hugsprimPmFromInteger");
+
namePmSubtract = linkName("hugsprimPmSubtract");
namePmLe = linkName("hugsprimPmLe");
- implementCfun ( nameCons, NIL );
- implementCfun ( nameNil, NIL );
- implementCfun ( nameUnit, NIL );
+ if (!combined) {
+ implementCfun ( nameCons, NIL );
+ implementCfun ( nameNil, NIL );
+ implementCfun ( nameUnit, NIL );
+ }
}
}
Int what; {
Int i;
switch (what) {
+ //case EXIT : fooble();break;
case RESET :
case MARK :
break;
case POSTPREL: {
+ Name nm;
Module modulePrelBase = findModule(findText("PrelBase"));
assert(nonNull(modulePrelBase));
-#if 1
fprintf(stderr, "linkControl(POSTPREL)\n");
-#if 1
setCurrModule(modulePrelude);
linkPreludeTC();
linkPreludeCM();
- linkPreludeNames();
- name(nameNil).stgVar
- = mkCPtr(lookupOTabName(modulePrelBase, "PrelBase_ZMZN_static_closure"));
- name(nameCons).stgVar
- = mkCPtr(lookupOTabName(modulePrelBase, "PrelBase_ZC_closure"));
+ linkPrimNames();
+
nameUnpackString = linkName("hugsprimUnpackString");
-#endif
-#endif
+ namePMFail = linkName("hugsprimPmFail");
+assert(nonNull(namePMFail));
+#define xyzzy(aaa,bbb) aaa = linkName(bbb)
+
+
+ /* pmc */
+ pFun(nameSel, "_SEL");
+
+ /* strict constructors */
+ xyzzy(nameFlip, "flip" );
+
+ /* parser */
+ xyzzy(nameFromTo, "enumFromTo");
+ xyzzy(nameFromThenTo, "enumFromThenTo");
+ xyzzy(nameFrom, "enumFrom");
+ xyzzy(nameFromThen, "enumFromThen");
+
+ /* deriving */
+ xyzzy(nameApp, "++");
+ xyzzy(nameReadField, "hugsprimReadField");
+ xyzzy(nameReadParen, "readParen");
+ xyzzy(nameShowField, "hugsprimShowField");
+ xyzzy(nameShowParen, "showParen");
+ xyzzy(nameLex, "lex");
+ xyzzy(nameComp, ".");
+ xyzzy(nameAnd, "&&");
+ xyzzy(nameCompAux, "hugsprimCompAux");
+ xyzzy(nameMap, "map");
+
+ /* implementTagToCon */
+ xyzzy(nameError, "hugsprimError");
+
+ typeStable = linkTycon("Stable");
+ typeRef = linkTycon("IORef");
+ // {Prim,PrimByte,PrimMutable,PrimMutableByte}Array ?
+
+ ifLinkConstrItbl ( nameFalse );
+ ifLinkConstrItbl ( nameTrue );
+ ifLinkConstrItbl ( nameNil );
+ ifLinkConstrItbl ( nameCons );
+
+ /* PrelErr.hi doesn't give a type for error, alas.
+ So error never appears in any symbol table.
+ So we fake it by copying the table entry for
+ hugsprimError -- which is just a call to error.
+ Although we put it on the Prelude export list, we
+ have to claim internally that it lives in PrelErr,
+ so that the correct symbol (PrelErr_error_closure)
+ is referred to.
+ Big Big Sigh.
+ */
+ nm = newName ( findText("error"), NIL );
+ name(nm) = name(nameError);
+ name(nm).mod = findModule(findText("PrelErr"));
+ name(nm).text = findText("error");
+ setCurrModule(modulePrelude);
+ module(modulePrelude).exports
+ = cons ( nm, module(modulePrelude).exports );
+
+ /* The GHC prelude doesn't seem to export Addr. Add it to the
+ export list for the sake of compatibility with standalone mode.
+ */
+ module(modulePrelude).exports
+ = cons ( pair(typeAddr,DOTDOT),
+ module(modulePrelude).exports );
+ addTycon(typeAddr);
+
+ /* Make nameListMonad be the builder fn for instance Monad [].
+ Standalone hugs does this with a disgusting hack in
+ checkInstDefn() in static.c. We have a slightly different
+ disgusting hack for the combined case.
+ */
+ {
+ Class cm; /* :: Class */
+ List is; /* :: [Inst] */
+ cm = findClassInAnyModule(findText("Monad"));
+ assert(nonNull(cm));
+ is = cclass(cm).instances;
+ assert(nonNull(is));
+ while (nonNull(is) && snd(inst(hd(is)).head) != typeList)
+ is = tl(is);
+ assert(nonNull(is));
+ nameListMonad = inst(hd(is)).builder;
+ assert(nonNull(nameListMonad));
+ }
+
break;
}
case PREPREL :
if (combined) {
+ Module modulePrelBase;
modulePrelude = findFakeModule(textPrelude);
module(modulePrelude).objectExtraNames
pair(STAR,pair(STAR,STAR)),
2,DATATYPE,NIL);
- pFun(nameInd, "_indirect");
+ /* desugaring */
+ pFun(nameInd, "_indirect");
name(nameInd).number = DFUNNAME;
+ /* newtype and USE_NEWTYPE_FOR_DICTS */
+ /* make a name entry for PrelBase.id _before_ loading Prelude
+ since ifSetClassDefaultsAndDCon() may need to refer to
+ nameId.
+ */
+ modulePrelBase = findModule(findText("PrelBase"));
+ setCurrModule(modulePrelBase);
+ pFun(nameId, "id");
+ setCurrModule(modulePrelude);
+
} else {
modulePrelude = newModule(textPrelude);
/* deriving */
pFun(nameApp, "++");
- pFun(nameReadField, "readField");
+ pFun(nameReadField, "hugsprimReadField");
pFun(nameReadParen, "readParen");
- pFun(nameShowField, "showField");
+ pFun(nameShowField, "hugsprimShowField");
pFun(nameShowParen, "showParen");
pFun(nameLex, "lex");
pFun(nameComp, ".");
pFun(nameAnd, "&&");
- pFun(nameCompAux, "primCompAux");
+ pFun(nameCompAux, "hugsprimCompAux");
pFun(nameMap, "map");
/* implementTagToCon */
- pFun(namePMFail, "primPmFail");
+ pFun(namePMFail, "hugsprimPmFail");
pFun(nameError, "error");
pFun(nameUnpackString, "hugsprimUnpackString");
}
#undef pFun
-
+//#include "fooble.c"
/*-------------------------------------------------------------------------*/