* included in the distribution.
*
* $RCSfile: link.c,v $
- * $Revision: 1.40 $
- * $Date: 2000/02/08 15:32:30 $
+ * $Revision: 1.53 $
+ * $Date: 2000/03/22 18:14:22 $
* ------------------------------------------------------------------------*/
#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"
+#include "Assembler.h" /* for asmPrimOps and AsmReps */
+#include "Rts.h" /* to make Prelude.h palatable */
+#include "Prelude.h" /* for fixupRTStoPreludeRefs */
Type typeArrow; /* Function spaces */
Name nameOtherwise;
Name nameUndefined; /* generic undefined value */
-#if NPLUSK
Name namePmSub;
-#endif
Name namePMFail;
Name nameEqChar;
Name namePmInt;
Name nameFromThenTo;
Name nameNegate;
+Name nameAssert;
+Name nameAssertError;
+Name nameTangleMessage;
+Name nameIrrefutPatError;
+Name nameNoMethodBindingError;
+Name nameNonExhaustiveGuardsError;
+Name namePatError;
+Name nameRecSelError;
+Name nameRecConError;
+Name nameRecUpdError;
+
/* these names are required before we've had a chance to do the right thing */
Name nameSel;
Name nameUnsafeUnpackCString;
*
* ------------------------------------------------------------------------*/
-/* 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).
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);
nameMkPrimMVar = addPrimCfunREP(findText("MVar#"),1,0,0);
nameMkInteger = addPrimCfunREP(findText("Integer#"),1,0,0);
- name(namePrimSeq).type = primType(MONAD_Id, "ab", "b");
- name(namePrimCatch).type = primType(MONAD_Id, "aH", "a");
- name(namePrimRaise).type = primType(MONAD_Id, "E", "a");
-
- /* This is a lie. For a more accurate type of primTakeMVar
- see ghc/interpreter/lib/Prelude.hs.
- */
- name(namePrimTakeMVar).type = primType(MONAD_Id, "rbc", "d");
+ if (!combined) {
+ name(namePrimSeq).type = primType(MONAD_Id, "ab", "b");
+ name(namePrimCatch).type = primType(MONAD_Id, "aH", "a");
+ name(namePrimRaise).type = primType(MONAD_Id, "E", "a");
+
+ /* This is a lie. For a more accurate type of primTakeMVar
+ see ghc/interpreter/lib/Prelude.hs.
+ */
+ name(namePrimTakeMVar).type = primType(MONAD_Id, "rbc", "d");
+ }
if (!combined) {
for (i=2; i<=NUM_DTUPLES; i++) {/* Add derived instances of tuples */
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");
break;
case POSTPREL: {
+ Name nm;
Module modulePrelBase = findModule(findText("PrelBase"));
assert(nonNull(modulePrelBase));
- fprintf(stderr, "linkControl(POSTPREL)\n");
+ /* fprintf(stderr, "linkControl(POSTPREL)\n"); */
setCurrModule(modulePrelude);
linkPreludeTC();
linkPreludeCM();
- linkPreludeNames();
+ linkPrimNames();
+ fixupRTStoPreludeRefs ( lookupObjName );
nameUnpackString = linkName("hugsprimUnpackString");
namePMFail = linkName("hugsprimPmFail");
/* pmc */
- xyzzy(nameSel, "_SEL");
+ pFun(nameSel, "_SEL");
/* strict constructors */
xyzzy(nameFlip, "flip" );
/* deriving */
xyzzy(nameApp, "++");
- xyzzy(nameReadField, "readField");
+ xyzzy(nameReadField, "hugsprimReadField");
xyzzy(nameReadParen, "readParen");
- xyzzy(nameShowField, "showField");
+ xyzzy(nameShowField, "hugsprimShowField");
xyzzy(nameShowParen, "showParen");
xyzzy(nameLex, "lex");
xyzzy(nameComp, ".");
/* implementTagToCon */
xyzzy(nameError, "hugsprimError");
+
typeStable = linkTycon("Stable");
typeRef = linkTycon("IORef");
// {Prim,PrimByte,PrimMutable,PrimMutableByte}Array ?
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 :
Module modulePrelBase;
modulePrelude = findFakeModule(textPrelude);
- module(modulePrelude).objectExtraNames
- = singleton(findText("libHS_cbits"));
- nameMkC = addWiredInBoxingTycon("PrelBase", "Char", "C#",CHAR_REP, STAR );
- nameMkI = addWiredInBoxingTycon("PrelBase", "Int", "I#",INT_REP, STAR );
- nameMkW = addWiredInBoxingTycon("PrelAddr", "Word", "W#",WORD_REP, STAR );
- nameMkA = addWiredInBoxingTycon("PrelAddr", "Addr", "A#",ADDR_REP, STAR );
- nameMkF = addWiredInBoxingTycon("PrelFloat","Float", "F#",FLOAT_REP, STAR );
- nameMkD = addWiredInBoxingTycon("PrelFloat","Double","D#",DOUBLE_REP, STAR );
+ nameMkC = addWiredInBoxingTycon("PrelBase", "Char", "C#",
+ CHAR_REP, STAR );
+ nameMkI = addWiredInBoxingTycon("PrelBase", "Int", "I#",
+ INT_REP, STAR );
+ nameMkW = addWiredInBoxingTycon("PrelAddr", "Word", "W#",
+ WORD_REP, STAR );
+ nameMkA = addWiredInBoxingTycon("PrelAddr", "Addr", "A#",
+ ADDR_REP, STAR );
+ nameMkF = addWiredInBoxingTycon("PrelFloat","Float", "F#",
+ FLOAT_REP, STAR );
+ nameMkD = addWiredInBoxingTycon("PrelFloat","Double","D#",
+ DOUBLE_REP, STAR );
nameMkInteger
- = addWiredInBoxingTycon("PrelNum","Integer","Integer#",0 ,STAR );
+ = addWiredInBoxingTycon("PrelNum","Integer","Integer#",
+ 0 ,STAR );
nameMkPrimByteArray
- = addWiredInBoxingTycon("PrelGHC","ByteArray","PrimByteArray#",0 ,STAR );
+ = addWiredInBoxingTycon("PrelGHC","ByteArray",
+ "PrimByteArray#",0 ,STAR );
for (i=0; i<NUM_TUPLES; ++i) {
if (i != 1) addTupleTycon(i);
}
addWiredInEnumTycon("PrelBase","Bool",
- doubleton(findText("False"),findText("True")));
+ doubleton(findText("False"),
+ findText("True")));
//nameMkThreadId
- // = addWiredInBoxingTycon("PrelConc","ThreadId","ThreadId#"
- // ,1,0,THREADID_REP);
+ // = addWiredInBoxingTycon("PrelConc","ThreadId","ThreadId#"
+ // ,1,0,THREADID_REP);
setCurrModule(modulePrelude);
nameId.
*/
modulePrelBase = findModule(findText("PrelBase"));
+ module(modulePrelBase).objectExtraNames
+ = singleton(findText("libHS_cbits"));
+
setCurrModule(modulePrelBase);
pFun(nameId, "id");
setCurrModule(modulePrelude);
} else {
+ fixupRTStoPreludeRefs(NULL);
- modulePrelude = newModule(textPrelude);
+ modulePrelude = //newModule(textPrelude);
+ findFakeModule(textPrelude);
setCurrModule(modulePrelude);
for (i=0; i<NUM_TUPLES; ++i) {
/* 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(nameError, "error");
pFun(nameUnpackString, "hugsprimUnpackString");
+ /* assertion and exception issues */
+ pFun(nameAssert, "assert");
+ pFun(nameAssertError, "assertError");
+ pFun(nameTangleMessage, "tangleMessager");
+ pFun(nameIrrefutPatError,
+ "irrefutPatError");
+ pFun(nameNoMethodBindingError,
+ "noMethodBindingError");
+ pFun(nameNonExhaustiveGuardsError,
+ "nonExhaustiveGuardsError");
+ pFun(namePatError, "patError");
+ pFun(nameRecSelError, "recSelError");
+ pFun(nameRecConError, "recConError");
+ pFun(nameRecUpdError, "recUpdError");
+
/* hooks for handwritten bytecode */
pFun(namePrimSeq, "primSeq");
pFun(namePrimCatch, "primCatch");
}
#undef pFun
-#include "fooble.c"
+//#include "fooble.c"
/*-------------------------------------------------------------------------*/
projects / ghc-hetmet.git / blobdiff