home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / smalltalk-1.1.1 / mstsave.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-12  |  20.7 KB  |  893 lines
  1. /***********************************************************************
  2.  *
  3.  *    Binary image save/restore.
  4.  *
  5.  ***********************************************************************/
  6.  
  7. /***********************************************************************
  8.  *
  9.  * Copyright (C) 1990, 1991 Free Software Foundation, Inc.
  10.  * Written by Steve Byrne.
  11.  *
  12.  * This file is part of GNU Smalltalk.
  13.  *
  14.  * GNU Smalltalk is free software; you can redistribute it and/or modify it
  15.  * under the terms of the GNU General Public License as published by the Free
  16.  * Software Foundation; either version 1, or (at your option) any later 
  17.  * version.
  18.  * 
  19.  * GNU Smalltalk is distributed in the hope that it will be useful, but WITHOUT
  20.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
  21.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  22.  * more details.
  23.  * 
  24.  * You should have received a copy of the GNU General Public License along with
  25.  * GNU Smalltalk; see the file COPYING.  If not, write to the Free Software
  26.  * Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  
  27.  *
  28.  ***********************************************************************/
  29.  
  30.  
  31. /*
  32.  *    Change Log
  33.  * ============================================================================
  34.  * Author      Date       Change 
  35.  * sbyrne    17 Apr 90      Fixing binary save to save only to the maximum used
  36.  *              OOP slot, instead of saving the entire OOP table.
  37.  *              This should improve load time and decrease disk
  38.  *              storage requirements.
  39.  *
  40.  * sbyrne    11 Feb 90      Changed the header to record the size of the oop
  41.  *              table, since trying to load back into a system with a
  42.  *              different sized oop table loses bigtime.
  43.  *
  44.  * sbyrne     5 Apr 89      modified to reflect change in classes: now their name
  45.  *              is a Smalltalk string; before, it was a C string that
  46.  *              had to be saved specially.
  47.  *
  48.  * sbyrne     4 Mar 89      Created.
  49.  *
  50.  */
  51.  
  52.  
  53. #include <stdio.h>
  54. #include "mst.h"
  55. #include "mstsave.h"
  56. #include "mstcomp.h"
  57. #include "mstinterp.h"
  58. #include "mstdict.h"
  59. #include "mstsym.h"
  60. #include "mstoop.h"        /* indirectly defines oopAt for sym tab prof */
  61. #include "mstmain.h"
  62. #ifdef HAS_ALLOCA_H
  63. #include <alloca.h>
  64. #endif
  65. #include <stdio.h>
  66.  
  67. #ifndef MAXPATHLEN
  68. #define MAXPATHLEN        1024 /* max length of a file and path */
  69. #endif
  70.  
  71. #define fromBeginning        0 /* symbolic name for file offset modifier */
  72.  
  73. /* convert to a relative offset from start of OOP table */
  74. #define toRelative(obj) \
  75.   ( (OOP)((long)(obj) - (long)oopTable) )
  76.  
  77. /* convert from relative offset to actual oop table address */
  78. #define fromRelative(obj) \
  79.   ( (OOP)((long)(obj) + (long)oopTable) )
  80.  
  81. /* round "x" up to the next 4 byte boundary */
  82. #define roundUpWord(x) \
  83.   ( ((x) + 3) & ~3 )
  84.  
  85. /*
  86.  * The binary image file has the following format:
  87.  *
  88.  *    header
  89.  *    complete oop table
  90.  *    global oop variable data
  91.  *    objects and non-oop object data
  92.  *    char object data
  93.  *    nil object
  94.  *    boolean objects
  95.  */
  96.  
  97.  
  98. typedef struct SaveFileHeaderStruct {
  99.   long        version;    /* the Smalltalk version that made this dump */
  100.   long        objectDataSize;    /* size of object data section in bytes */
  101.   long        oopTableSize;    /* size of the oop table at dump */
  102. } SaveFileHeader;
  103.  
  104. typedef struct OOPVectorStruct {
  105.   Object    base;        /* base of the storage */
  106.   Object    ptr;        /* the current object */
  107. } OOPVector;
  108.  
  109.  
  110. OOP        *globalOOPs[] = {
  111.   &andColonSymbol,
  112.   &atColonPutColonSymbol,
  113.   &atColonSymbol,
  114.   &atEndSymbol,
  115.   &bitAndColonSymbol,
  116.   &bitOrColonSymbol,
  117.   &bitShiftColonSymbol,
  118.   &blockCopyColonSymbol,
  119.   &classSymbol,
  120.   ÷Symbol,
  121.   &doColonSymbol,
  122.   &equalSymbol,
  123.   &greaterEqualSymbol,
  124.   &greaterThanSymbol,
  125.   &ifFalseColonIfTrueColonSymbol,
  126.   &ifFalseColonSymbol,
  127.   &ifTrueColonIfFalseColonSymbol,
  128.   &ifTrueColonSymbol,
  129.   &integerDivideSymbol,
  130.   &lessEqualSymbol,
  131.   &lessThanSymbol,
  132.   &minusSymbol,
  133.   &newColonSymbol,
  134.   &newSymbol,
  135.   &nextPutColonSymbol,
  136.   &nextSymbol,
  137.   ¬EqualSymbol,
  138.   ¬SameObjectSymbol,
  139.   &orColonSymbol,
  140.   &plusSymbol,
  141.   &remainderSymbol,
  142.   &sameObjectSymbol,
  143.   &sizeSymbol,
  144.   &thisContextSymbol,
  145.   ×Symbol,
  146.   &valueColonSymbol,
  147.   &valueColonValueColonSymbol,
  148.   &valueColonValueColonValueColonSymbol,
  149.   &valueWithArgumentsColonSymbol,
  150.   &valueSymbol,
  151.   &whileFalseColonSymbol,
  152.   &whileTrueColonSymbol,
  153.   &orSymbol,
  154.   &andSymbol,
  155.   &superSymbol,
  156.   &nilSymbol,
  157.   &trueSymbol,
  158.   &falseSymbol,
  159.   &selfSymbol,
  160.   &doesNotUnderstandColonSymbol,
  161.   &unknownSymbol,
  162.   &charSymbol,
  163.   &stringSymbol,
  164.   &stringOutSymbol, 
  165.   &symbolSymbol,
  166.   &intSymbol,
  167.   &longSymbol,
  168.   &doubleSymbol,
  169.   &voidSymbol,
  170.   &variadicSymbol,
  171.   &cObjectSymbol,
  172.   &smalltalkSymbol,
  173.   &byteArraySymbol,
  174.   &objectClass,
  175.   &magnitudeClass,
  176.   &charClass,
  177.   &timeClass,
  178.   &numberClass,
  179.   &floatClass,
  180.   &integerClass,
  181.   &lookupKeyClass,
  182.   &associationClass,
  183.   &linkClass,
  184.   &processClass,
  185.   &symLinkClass,
  186.   &collectionClass,
  187.   &sequenceableCollectionClass,
  188.   &linkedListClass,
  189.   &semaphoreClass,
  190.   &arrayedCollectionClass,
  191.   &arrayClass,
  192.   &stringClass,
  193.   &symbolClass,
  194.   &byteArrayClass,
  195.   &compiledMethodClass,
  196.   &intervalClass,
  197.   &orderedCollectionClass,
  198.   &sortedCollectionClass,
  199.   &bagClass,
  200.   &mappedCollectionClass,
  201.   &setClass,
  202.   &dictionaryClass,
  203.   &identityDictionaryClass,
  204.   &systemDictionaryClass,
  205.   &undefinedObjectClass,
  206.   &booleanClass,
  207.   &falseClass,
  208.   &trueClass,
  209.   &processorSchedulerClass,
  210.   &delayClass,
  211.   &sharedQueueClass,
  212.   &behaviorClass,
  213.   &classDescriptionClass,
  214.   &classClass,
  215.   &metaclassClass,
  216.   &smalltalkDictionary,
  217.   &messageClass,
  218.   &methodContextClass,
  219.   &blockContextClass,
  220.   &streamClass,
  221.   &positionableStreamClass,
  222.   &readStreamClass,
  223.   &writeStreamClass,
  224.   &readWriteStreamClass,
  225.   &cObjectClass,
  226.   &fileStreamClass,
  227.   &memoryClass,
  228.   &byteMemoryClass,
  229.   &wordMemoryClass,
  230.   &randomClass,
  231.   &cFuncDescriptorClass,
  232.   &tokenStreamClass,
  233.   &methodInfoClass,
  234.   &fileSegmentClass,
  235.   &nilOOP,
  236.   &trueOOP,
  237.   &falseOOP,
  238.   &processorOOP,
  239.   &symbolTable,
  240.   nil
  241. };
  242.  
  243.  
  244. static void    skipOverHeader(), saveObject(), fixupObject(),
  245.         fixupMethodObject(), restoreObject(), restoreMethodObject(),
  246.         saveOOPTable(), fixupAllOOPs(), fixupOOP(),
  247.         /* fixupFreeOOP(), */restoreAllOOPs(), restoreOOP(), 
  248.         /*restoreFreeOOP(), */loadOOPTable(), loadNormalOOPs(),
  249.         loadCharOOPs(), loadSpecialOOPs(), saveGlobalOOPs(),
  250.         loadGlobalOOPs(), fixupClassObject(), restoreInstanceVars(),
  251.         restoreClassObject(), saveFileVersion(),
  252.         loadFileVersion(), fixupInstanceVars(), fixupOOPInstanceVars();
  253.  
  254. static int    saveNormalOOPs(), saveAllObjects();
  255.  
  256.  
  257. /* This variable contains the OOP slot index of the highest non-free OOP,
  258.  * excluding the built-in ones (i.e., it will always be < OOP_TABLE_SIZE).
  259.  * This is used for optimizing the size of the saved image, and minimizing
  260.  * the load time when restoring the system. */
  261. static int    maxUsedOOPSlot = 0;
  262.  
  263.  
  264. Boolean saveToFile(fileName)
  265. char    *fileName;
  266. {
  267.   FILE        *imageFile;
  268.   long        objectDataSize;
  269.   Boolean    oldGCState;
  270.  
  271.   fullGC();            /* make sure that the world is compact if
  272.                    possible */
  273.  
  274.   oldGCState = gcOff();
  275.  
  276. #ifdef BINARY_MODE_NEEDED
  277.   imageFile = fopen(fileName, "wb");
  278. #else
  279.   imageFile = fopen(fileName, "w");
  280. #endif
  281.   if (imageFile == NULL) {
  282.     errorf("Couldn't open file %s", fileName);
  283.     return (false);
  284.   }
  285.  
  286.   skipOverHeader(imageFile);
  287.   saveOOPTable(imageFile);
  288.  
  289. #ifdef OOP_TABLE_TRACE
  290. printf("After saving oopt table: %d\n", ftell(imageFile));
  291. #endif /* OOP_TABLE_TRACE */
  292.  
  293.   saveGlobalOOPs(imageFile);
  294.  
  295. #ifdef OOP_TABLE_TRACE
  296. printf("After global oop table: %d\n", ftell(imageFile));
  297. #endif /* OOP_TABLE_TRACE */
  298.  
  299.   objectDataSize = saveAllObjects(imageFile);
  300.  
  301. #ifdef OOP_TABLE_TRACE
  302. printf("After saving all objects table: %d\n", ftell(imageFile));
  303. #endif /* OOP_TABLE_TRACE */
  304.  
  305.   skipToHeader(imageFile);
  306.   saveFileVersion(imageFile, objectDataSize);
  307.  
  308.   fclose(imageFile);
  309.  
  310.   setGCState(oldGCState);
  311.   return (true);
  312. } 
  313.  
  314.  
  315. static void skipOverHeader(imageFile)
  316. FILE    *imageFile;
  317. {
  318.   unsigned long    pos;
  319.  
  320.   fseek(imageFile, sizeof(SaveFileHeader), fromBeginning);
  321. }
  322.  
  323. /*
  324.  *    static void saveOOPTable(imageFile)
  325.  *
  326.  * Description
  327.  *
  328.  *    Writes the OOP table out to the image file.  We need to make all
  329.  *    of the object pointers relative, including free OOP table slots, and
  330.  *    we use a parallel vector containing file offsets for the objects that
  331.  *    we developed during saving of the objects themselves as the fixup
  332.  *    table.
  333.  *
  334.  * Inputs
  335.  *
  336.  *    imageFile: 
  337.  *        A stdio FILE to be written to.  It must be positioned
  338.  *        correctly before this routine is called.
  339.  *
  340.  */
  341. static void saveOOPTable(imageFile)
  342. FILE    *imageFile;
  343. {
  344.   fixupAllOOPs();
  345.  
  346. #ifdef OOP_TABLE_TRACE
  347. printf("there are %d free oops out of %d oops, leaving %d\n",
  348.        numFreeOOPs, OOP_TABLE_SIZE, OOP_TABLE_SIZE - numFreeOOPs);
  349. printf("max used is %d\n", maxUsedOOPSlot);
  350. #endif /* OOP_TABLE_TRACE */
  351.  
  352.   /* save up to the max oop slot in use */
  353.   fwrite(oopTable, sizeof(struct OOPStruct), maxUsedOOPSlot + 1, imageFile);
  354.  
  355.   /* then save the constant ones at the end */
  356.   fwrite(&oopTable[OOP_TABLE_SIZE], sizeof(struct OOPStruct),
  357.      TOTAL_OOP_TABLE_SLOTS - OOP_TABLE_SIZE, imageFile);
  358.  
  359.   restoreAllOOPs();
  360. }
  361.  
  362.  
  363. static void fixupAllOOPs()
  364. {
  365.   int        i;
  366.  
  367.   maxUsedOOPSlot = 0;
  368.  
  369.   for (i = 0; i < TOTAL_OOP_TABLE_SLOTS; i++) {
  370.     fixupOOP(i);
  371.   }
  372. }
  373.  
  374. static void fixupOOP(i)
  375. int    i;
  376. {
  377.   OOP        oop;
  378.  
  379.   oop = oopAt(i);
  380. #ifdef old_code /* Tue Apr 17 22:48:45 1990 */
  381. /**/  if (oop->isFree) {
  382. /**/    fixupFreeOOP(oop);
  383. /**/  } else {
  384. #endif /* old_code Tue Apr 17 22:48:45 1990 */
  385.   if (!oop->isFree) {
  386.     if (i < OOP_TABLE_SIZE) {
  387.       maxUsedOOPSlot = i;
  388.     }
  389.     oop->object = (Object)toRelative(oop->object);
  390.   }
  391. }
  392.  
  393. #ifdef old_code /* Tue Apr 17 22:49:42 1990 */
  394. /**/
  395. /**/static void fixupFreeOOP(oop)
  396. /**/OOP    oop;
  397. /**/{
  398. /**/  if (oop->object == nil) {
  399. /**/    oop->object = (Object)-1L;
  400. /**/  } else {
  401. /**/    oop->object = (Object)toRelative(oop->object);
  402. /**/  }
  403. /**/
  404. /**/  oop->isFree = 0;
  405. /**/  if (oop->prevFree == (long)nil) {
  406. /**/    oop->prevFree = -1L;
  407. /**/  } else {
  408. /**/    oop->prevFree = (long)toRelative(oop->prevFree);
  409. /**/  }
  410. /**/
  411. /**/  oop->isFree = 1;
  412. /**/}
  413. #endif /* old_code Tue Apr 17 22:49:42 1990 */
  414.  
  415.  
  416. static void restoreAllOOPs()
  417. {
  418.   int        i;
  419.  
  420.   for (i = 0; i < TOTAL_OOP_TABLE_SLOTS; i++) {
  421.     restoreOOP(i);
  422.   }
  423. }
  424.  
  425.  
  426.  
  427. static void restoreOOP(i)
  428. int    i;
  429. {
  430.   OOP        oop;
  431.  
  432.   oop = oopAt(i);
  433. #ifdef old_code /* Tue Apr 17 22:50:19 1990 */
  434. /**/  if (oop->isFree) {
  435. /**/    restoreFreeOOP(oop);
  436. /**/  } else {
  437. #endif /* old_code Tue Apr 17 22:50:19 1990 */
  438.   if (!oop->isFree) {
  439.     oop->object = (Object)fromRelative(oop->object);
  440.   }
  441. }
  442.  
  443. #ifdef old_code /* Tue Apr 17 22:50:39 1990 */
  444. /**/static void restoreFreeOOP(oop)
  445. /**/OOP    oop;
  446. /**/{
  447. /**/  if (oop->object == (Object)-1L) {
  448. /**/    oop->object = nil;
  449. /**/  } else {
  450. /**/    oop->object = (Object)fromRelative(oop->object);
  451. /**/  }
  452. /**/
  453. /**/  if (oop->prevFree == -1L) {
  454. /**/    oop->prevFree = (long)nil;
  455. /**/  } else {
  456. /**/    oop->isFree = 0;
  457. /**/    oop->prevFree = (long)fromRelative(oop->prevFree);
  458. /**/  }
  459. /**/
  460. /**/  oop->isFree = 1;
  461. /**/}
  462. #endif /* old_code Tue Apr 17 22:50:39 1990 */
  463.  
  464.  
  465. static void saveGlobalOOPs(imageFile)
  466. FILE    *imageFile;
  467. {
  468.   OOP        **oopPtr, oop;
  469.  
  470.   for (oopPtr = globalOOPs; *oopPtr; oopPtr++) {
  471.     oop = toRelative(**oopPtr);
  472.     fwrite(&oop, sizeof(OOP), 1, imageFile);
  473.   }
  474. }
  475.  
  476.  
  477. static int saveAllObjects(imageFile)
  478. FILE    *imageFile;
  479. {
  480.   long        objectStart, objectEnd;
  481.   int        i;
  482.   OOP        oop;
  483.  
  484.   objectStart = ftell(imageFile);
  485.   for (i = 0; i < OOP_TABLE_SIZE; i++) {
  486.     oop = oopAt(i);
  487.     if (oopValid(oop)) {
  488.       saveObject(imageFile, oop);
  489.     }
  490.   }
  491.  
  492.   objectEnd = ftell(imageFile);
  493.  
  494.   /* dump out the character objects, nil, true, and false */
  495.   for (i = OOP_TABLE_SIZE; i < TOTAL_OOP_TABLE_SLOTS; i++) {
  496.     saveObject(imageFile, oopAt(i));
  497.   }
  498.  
  499.   return (objectEnd - objectStart);
  500. }
  501.  
  502. static void saveObject(imageFile, oop)
  503. FILE    *imageFile;
  504. OOP    oop;
  505. {
  506.   Object    object;
  507.   int        numFixed, numIndexed;
  508.   Boolean    hasPointers;
  509.  
  510.   object = oopToObj(oop);
  511.   hasPointers = isPointers(oop);
  512.   numFixed = oopFixedFields(oop);
  513.   numIndexed = numIndexableFields(oop);
  514.  
  515.   fixupObject(oop, hasPointers, numFixed, numIndexed);
  516.   fwrite(object, sizeof(OOP), object->objSize, imageFile);
  517.   restoreObject(oop, hasPointers, numFixed, numIndexed);
  518. }
  519.  
  520. static void fixupObject(oop, hasPointers, numFixed, numIndexed)
  521. OOP    oop;
  522. Boolean    hasPointers;
  523. int    numFixed, numIndexed;
  524. {
  525.   int        i;
  526.   Object    object;
  527.   OOP        instOOP, classOOP;
  528.  
  529.   classOOP = oopClass(oop);
  530.  
  531.   if (classOOP == compiledMethodClass) {
  532.     fixupMethodObject(oop);
  533.   } else {
  534.     if (hasPointers) {
  535.       for (i = 1; i <= numFixed + numIndexed; i++) {
  536.     instOOP = instVarAt(oop, i);
  537.     if (!isInt(instOOP)) {
  538.       instVarAtPut(oop, i, toRelative(instOOP));
  539.     }
  540.       }
  541.     }
  542.   }
  543.  
  544.   object = oopToObj(oop);
  545.   object->objClass = toRelative(object->objClass);
  546. }
  547.  
  548. static void fixupMethodObject(oop)
  549. OOP    oop;
  550. {
  551.   MethodHeader    header;
  552.   int        i;
  553.   OOP        literalOOP, descriptorOOP;
  554.  
  555.   descriptorOOP = getMethodDescriptor(oop);
  556.   if (!isInt(descriptorOOP)) {
  557.     setMethodDescriptor(oop, toRelative(descriptorOOP));
  558.   }
  559.   header = getMethodHeaderExt(oop);
  560.   if (header.headerFlag == 1 || header.headerFlag == 2) {
  561.     /* these have no method literals to fix up, so we ignore them */
  562.     return;
  563.   }
  564.  
  565.   for (i = 0; i < header.numLiterals; i++) {
  566.     literalOOP = methodLiteralExt(oop, i);
  567.     if (!isInt(literalOOP)) {
  568.       storeMethodLiteralNoGC(oop, i, toRelative(literalOOP));
  569.     }
  570.   }
  571. }
  572.  
  573. static void restoreObject(oop, hasPointers, numFixed, numIndexed)
  574. OOP    oop;
  575. Boolean    hasPointers;
  576. int    numFixed, numIndexed;
  577. {
  578.   Object    object;
  579.  
  580.   object = oopToObj(oop);
  581.  
  582.   object->objClass = fromRelative(object->objClass);
  583.  
  584.   restoreInstanceVars(oop, hasPointers, numFixed, numIndexed);
  585. }
  586.  
  587. static void restoreInstanceVars(oop, hasPointers, numFixed, numIndexed)
  588. OOP    oop;
  589. Boolean    hasPointers;
  590. int    numFixed, numIndexed;
  591. {
  592.   register int    i;
  593.   OOP        instOOP, classOOP;
  594.  
  595.   classOOP = oopClass(oop);
  596.   if (classOOP == compiledMethodClass) {
  597.     restoreMethodObject(oop);
  598.   } else {
  599.     if (hasPointers) {
  600.       for (i = 1; i <= numFixed + numIndexed; i++) {
  601.     instOOP = instVarAt(oop, i);
  602.     if (!isInt(instOOP)) {
  603.       instVarAtPut(oop, i, fromRelative(instOOP));
  604.     }
  605.       }
  606.       if (classOOP == cFuncDescriptorClass) {
  607.     restoreCFuncDescriptor(oop); /* in mstcint.c */
  608.       }
  609.     }
  610.   }
  611. }
  612.  
  613. static void restoreMethodObject(oop)
  614. OOP    oop;
  615. {
  616.   MethodHeader    header;
  617.   int        i;
  618.   OOP        literalOOP, descriptorOOP;
  619.  
  620.   descriptorOOP = getMethodDescriptor(oop);
  621.   if (!isInt(descriptorOOP)) {
  622.     setMethodDescriptor(oop, fromRelative(descriptorOOP));
  623.   }
  624.  
  625.   header = getMethodHeaderExt(oop);
  626.   if (header.headerFlag == 1 || header.headerFlag == 2) {
  627.     /* these have no method literals to fix up, so we ignore them */
  628.     return;
  629.   }
  630.  
  631.   for (i = 0; i < header.numLiterals; i++) {
  632.     literalOOP = methodLiteralExt(oop, i);
  633.     if (!isInt(literalOOP)) {
  634.       storeMethodLiteralNoGC(oop, i, fromRelative(literalOOP));
  635.     }
  636.   }
  637. }
  638.  
  639.  
  640. skipToHeader(imageFile)
  641. FILE    *imageFile;
  642. {
  643.   rewind(imageFile);
  644. }
  645.  
  646. static void saveFileVersion(imageFile, objectDataSize)
  647. FILE    *imageFile;
  648. long    objectDataSize;
  649. {
  650.   SaveFileHeader header;
  651.  
  652.   header.version = sysVersMajor * 1000000 + sysVersMinor * 1000 + sysVersEdit;
  653.   header.objectDataSize = objectDataSize;
  654.   header.oopTableSize = maxUsedOOPSlot + 1; /* n slots, numbered 0..n-1 */
  655.  
  656.   fwrite(&header, sizeof(SaveFileHeader), 1, imageFile);
  657. }
  658.  
  659. static void skipToOOPTable(imageFile)
  660. FILE    *imageFile;
  661. {
  662.   rewind(imageFile);
  663. }
  664.  
  665.  
  666. /***********************************************************************
  667.  *
  668.  *    Binary loading routines.
  669.  *
  670.  ***********************************************************************/
  671.  
  672.  
  673. Boolean loadFromFile(fileName)
  674. char    *fileName;
  675. {
  676.   FILE        *imageFile;
  677.   SaveFileHeader header;
  678.   OOPVector    ov;
  679.   Boolean    oldGCState;
  680.   char        fullImageName[MAXPATHLEN];
  681.  
  682.   oldGCState = gcOff();
  683.  
  684.   findImageFile(fileName, fullImageName);
  685. #ifdef BINARY_MODE_NEEDED
  686.   imageFile = fopen(fullImageName, "rb");
  687. #else
  688.   imageFile = fopen(fullImageName, "r");
  689. #endif
  690.   if (imageFile == NULL) {
  691.     return (false);
  692.   }
  693.  
  694.   loadFileVersion(imageFile, &header);
  695.   if (header.version != (sysVersMajor * 1000000 + sysVersMinor * 1000
  696.              + sysVersEdit)) {
  697.     /* version mismatch; this image file is invalid */
  698.     return (false);
  699.   }
  700.   
  701. #ifdef old_code /* Tue Apr 17 22:25:33 1990 */
  702. /**/  if (header.oopTableSize != OOP_TABLE_SIZE) {
  703. /**/    return (false);
  704. /**/  }
  705. #endif /* old_code Tue Apr 17 22:25:33 1990 */
  706.  
  707.   loadOOPTable(imageFile, header.oopTableSize);
  708.  
  709.   loadGlobalOOPs(imageFile);
  710.  
  711.   loadNormalOOPs(imageFile, header.objectDataSize, &ov);
  712.   loadCharOOPs(imageFile);
  713.   loadSpecialOOPs(imageFile);
  714.  
  715.   fixupInstanceVars(&ov);
  716.  
  717.   fclose(imageFile);
  718.  
  719.   setGCState(oldGCState);
  720.  
  721.   return (true);
  722. }
  723.  
  724. static void loadFileVersion(imageFile, headerp)
  725. FILE    *imageFile;
  726. SaveFileHeader *headerp;
  727. {
  728.   fread(headerp, sizeof(SaveFileHeader), 1, imageFile);
  729. }
  730.  
  731. static void loadOOPTable(imageFile, oldSlotsUsed)
  732. FILE    *imageFile;
  733. long     oldSlotsUsed;
  734. {
  735.   long        i;
  736.   OOP        oop;
  737.  
  738. /*  fread(oopTable, sizeof(struct OOPStruct), TOTAL_OOP_TABLE_SLOTS, imageFile);*/
  739.  
  740.   /* load in the valid OOP slots from previous dump */
  741.   fread(oopTable, sizeof(struct OOPStruct), oldSlotsUsed, imageFile);
  742.   
  743.   /* mark the remaining ones as available */
  744.   for (i = oldSlotsUsed; i < OOP_TABLE_SIZE; i++) {
  745.     oop = oopAt(i);
  746.     oop->isFree = true;
  747.   }
  748.  
  749.  
  750.   /* read in the constant stuff at the end */
  751.   fread(&oopTable[OOP_TABLE_SIZE], sizeof(struct OOPStruct),
  752.     TOTAL_OOP_TABLE_SLOTS - OOP_TABLE_SIZE, imageFile);
  753.  
  754.   /* the fixup gets handled by load normal oops */
  755. }
  756.  
  757.  
  758. static void loadGlobalOOPs(imageFile)
  759. FILE    *imageFile;
  760. {
  761.   OOP        **oopPtr, oop, *oopVec;
  762.   long        numGlobalOOPs;
  763.  
  764.   for (numGlobalOOPs = 0, oopPtr = globalOOPs; *oopPtr;
  765.        oopPtr++, numGlobalOOPs++);
  766.  
  767.   oopVec = (OOP *)alloca(numGlobalOOPs * sizeof(OOP));
  768.   fread(oopVec, sizeof(OOP), numGlobalOOPs, imageFile);
  769.  
  770.   for (oopPtr = globalOOPs; *oopPtr; oopPtr++, oopVec++) {
  771.     **oopPtr = fromRelative(*oopVec);
  772.   }
  773. #ifdef old_code /* Wed Apr 26 21:15:38 1989 */ /* <<<== what dedication...3 days before my wedding -- SBB */
  774. /**/  /* ??? this could be sped up by using alloca, doing one fread, and then
  775. /**/     iterating through the array */
  776. /**/  for (oopPtr = globalOOPs; *oopPtr; oopPtr++) {
  777. /**/    fread(&oop, sizeof(OOP), 1, imageFile);
  778. /**/    **oopPtr = fromRelative(oop);
  779. /**/  }
  780. #endif /* old_code Wed Apr 26 21:15:38 1989 */
  781. }
  782.  
  783. static void loadNormalOOPs(imageFile, objectDataSize, ovp) 
  784. FILE    *imageFile;
  785. long    objectDataSize;
  786. OOPVector *ovp;
  787. {
  788.   register long    i;
  789.   OOP        oop, prevFreeOOP;
  790.   Object    object, objPtr;
  791.  
  792.   objPtr = curSpaceAddr();
  793.  
  794.   ovp->base = objPtr;
  795.  
  796.   prevFreeOOP = nil;
  797.  
  798.   fread(objPtr, 1, objectDataSize, imageFile);
  799.  
  800.   freeOOPs = nil;
  801.   numFreeOOPs = 0;
  802.   for (i = 0; i < OOP_TABLE_SIZE; i++) {
  803.     oop = oopAt(i);
  804.     if (oopValid(oop)) {
  805.       object = objPtr;
  806.       oop->object = object;
  807.       /* ### should probably make this setting symbolic/abstracted */
  808.       oop->inSpace = toSpace;
  809.       oop->oddMark = toSpace;
  810.       oop->evenMark = !toSpace;
  811.       object->objClass = fromRelative(object->objClass);
  812.       objPtr = (Object)((long *)object + object->objSize);
  813.     } else if (oop->isFree) {    /* ignore non-free but non-valid...they'll get handled
  814.                    naturally in due time. */
  815.       numFreeOOPs++;
  816.       if (prevFreeOOP) {    /* forward chain the oop free list */
  817.     prevFreeOOP->object = (Object)oop;
  818.       }
  819.       if (freeOOPs == nil) {    /* free list points at first free oop in
  820.                    OOP table */
  821.     freeOOPs = oop;
  822.       }
  823.       prevFreeOOP = oop;
  824.     }
  825.   }
  826.  
  827.   if (prevFreeOOP) {
  828.     prevFreeOOP->object = nil;    /* terminate the free list nicely */
  829.   }
  830.  
  831.   setSpaceInfo(objectDataSize);
  832.   ovp->ptr = objPtr;
  833. }
  834.  
  835. static void loadCharOOPs(imageFile)
  836. FILE    *imageFile;
  837. {
  838.   int        i;
  839.  
  840.   fread(charObjectTable, sizeof(CharObject), NUM_CHAR_OBJECTS, imageFile);
  841.  
  842.   for (i = 0; i < NUM_CHAR_OBJECTS; i++) {
  843.     oopTable[i + CHAR_OBJECT_BASE].object = (Object)&charObjectTable[i];
  844.     oopTable[i + CHAR_OBJECT_BASE].inSpace = toSpace;
  845.     charObjectTable[i].objClass = fromRelative(charObjectTable[i].objClass);
  846.   }
  847. }
  848.  
  849. static void loadSpecialOOPs(imageFile)
  850. FILE    *imageFile;
  851. {
  852.   fread(&nilObject, sizeof(struct NilObjectStruct), 1, imageFile);
  853.   nilOOP->object = (Object)&nilObject;
  854.   nilOOP->object->objClass = fromRelative(nilOOP->object->objClass);
  855.   nilOOP->inSpace = toSpace;
  856.  
  857.   fread(booleanObjects, sizeof(struct BooleanObjectStruct), 2, imageFile);
  858.   trueOOP->object = (Object)&booleanObjects[0];
  859.   falseOOP->object = (Object)&booleanObjects[1];
  860.   trueOOP->object->objClass = fromRelative(trueOOP->object->objClass);
  861.   falseOOP->object->objClass = fromRelative(falseOOP->object->objClass);
  862.   trueOOP->inSpace = falseOOP->inSpace = toSpace;
  863. }
  864.  
  865. static void fixupInstanceVars(ovp)
  866. OOPVector *ovp;
  867. {
  868.   int        i;
  869.   OOP        oop;
  870.  
  871.   for (i = 0; i < TOTAL_OOP_TABLE_SLOTS; i++) {
  872.     oop = oopAt(i);
  873.     if (oopValid(oop)) {
  874.       fixupOOPInstanceVars(oop, ovp);
  875.     }
  876.   }
  877. }
  878.  
  879. static void fixupOOPInstanceVars(oop, ovp)
  880. OOP    oop;
  881. OOPVector *ovp;
  882. {
  883.   int        numFixed, numIndexed;
  884.   Boolean    hasPointers;
  885.  
  886.   hasPointers = isPointers(oop);
  887.   numFixed = oopFixedFields(oop);
  888.   numIndexed = numIndexableFields(oop);
  889.   restoreInstanceVars(oop, hasPointers, numFixed, numIndexed);
  890. }
  891.  
  892.  
  893.