Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. /* asmdef.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* global benutzte Variablen                                                 */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12.  
  13. #include <errno.h>
  14. #include <string.h>
  15.  
  16. #include "strutil.h"
  17. #include "stringlists.h"
  18. #include "chunks.h"
  19.  
  20. #include "asmdef.h"
  21. #include "asmsub.h"
  22. #include "errmsg.h"
  23.  
  24. char SrcSuffix[] = ".asm";             /* Standardendungen: Hauptdatei */
  25. char IncSuffix[] = ".inc";             /* Includedatei */
  26. char PrgSuffix[] = ".p";               /* Programmdatei */
  27. char LstSuffix[] = ".lst";             /* Listingdatei */
  28. char MacSuffix[] = ".mac";             /* Makroausgabe */
  29. char PreSuffix[] = ".i";               /* Ausgabe Makroprozessor */
  30. char LogSuffix[] = ".log";             /* Fehlerdatei */
  31. char MapSuffix[] = ".map";             /* Debug-Info/Map-Format */
  32. char OBJSuffix[] = ".obj";
  33.  
  34. const char *EnvName = "ASCMD";         /* Environment-Variable fuer Default-
  35.                                           Parameter */
  36.  
  37. StringPtr SourceFile;                    /* Hauptquelldatei */
  38.  
  39. StringPtr CursUp;                           /*   "     "  Cursor hoch */
  40.  
  41. LargeWord *PCs;                          /* Programmzaehler */
  42. Boolean RelSegs;                         /* relokatibles Segment ? */
  43. LargeWord StartAdr;                      /* Programmstartadresse */
  44. Boolean StartAdrPresent;                 /*          "           definiert? */
  45. LargeWord AfterBSRAddr;                  /* address right behind last BSR */
  46. LargeWord *Phases;                       /* Verschiebungen */
  47. Word Grans[SegCountPlusStruct];          /* Groesse der Adressierungselemente */
  48. Word ListGrans[SegCountPlusStruct];      /* Wortgroesse im Listing */
  49. ChunkList SegChunks[SegCountPlusStruct]; /* Belegungen */
  50. as_addrspace_t ActPC;                    /* gewaehlter Programmzaehler */
  51. Boolean PCsUsed[SegCountPlusStruct];     /* PCs bereits initialisiert ? */
  52. LargeWord *SegInits;                     /* Segmentstartwerte */
  53. LargeWord *SegLimits;                    /* Segmentgrenzwerte */
  54. LongInt ValidSegs;                       /* erlaubte Segmente */
  55. Boolean ENDOccured;                      /* END-Statement aufgetreten ? */
  56. Boolean Retracted;                       /* Codes zurueckgenommen ? */
  57. Boolean ListToStdout, ListToNull;        /* Listing auf Konsole/Nulldevice ? */
  58.  
  59. unsigned ASSUMERecCnt;
  60. const ASSUMERec *pASSUMERecs;
  61. void (*pASSUMEOverride)(void);
  62.  
  63. Integer PassNo;                          /* Durchlaufsnummer */
  64. Integer JmpErrors;                       /* Anzahl fraglicher Sprungfehler */
  65. Boolean ThrowErrors;                     /* Fehler verwerfen bei Repass ? */
  66. LongWord MaxErrors;                      /* terminate upon n errors? */
  67. Boolean Repass;                                /* noch ein Durchlauf erforderlich */
  68. Byte MaxSymPass;                               /* Pass, nach dem Symbole definiert sein muessen */
  69. Byte ShareMode;                          /* 0=kein SHARED,1=Pascal-,2=C-Datei, 3=ASM-Datei */
  70. DebugType DebugMode;                     /* Ausgabeformat Debug-Datei */
  71. Word NoICEMask;                          /* which symbols to use in NoICE dbg file */
  72. Byte ListMode;                           /* 0=kein Listing,1=Konsole,2=auf Datei */
  73. Byte ListOn;                                       /* Listing erzeugen ? */
  74. Integer MaxIncludeLevel;                 /* maximum include nesting level */
  75. Boolean MakeUseList;                     /* Belegungsliste ? */
  76. Boolean MakeCrossList;                   /* Querverweisliste ? */
  77. Boolean MakeSectionList;                 /* Sektionsliste ? */
  78. Boolean MakeIncludeList;                 /* Includeliste ? */
  79. Boolean DefRelaxedMode;                  /* alle Integer-Syntaxen zulassen ? */
  80. Word ListMask;                           /* Listingmaske */
  81. ShortInt ExtendErrors;                   /* erweiterte Fehlermeldungen */
  82. Integer EnumSegment;                     /* ENUM state & config */
  83. LongInt EnumIncrement, EnumCurrentValue;
  84. Boolean NumericErrors;                   /* Fehlermeldungen mit Nummer */
  85. Boolean CodeOutput;                          /* Code erzeugen */
  86. Boolean MacProOutput;                    /* Makroprozessorausgabe schreiben */
  87. Boolean MacroOutput;                     /* gelesene Makros schreiben */
  88. Boolean HardRanges;                      /* Bereichsfehler echte Fehler ? */
  89. const char *DivideChars;                 /* Trennzeichen fuer Parameter. Inhalt Read Only! */
  90. Boolean HasAttrs;                        /* Opcode hat Attribut */
  91. const char *AttrChars;                   /* Zeichen, mit denen Attribut abgetrennt wird */
  92. Boolean MsgIfRepass;                     /* Meldungen, falls neuer Pass erforderlich */
  93. Integer PassNoForMessage;                /* falls ja: ab welchem Pass ? */
  94. Boolean CaseSensitive;                   /* Gross/Kleinschreibung unterscheiden ? */
  95. LongInt NestMax;                         /* max. nesting level of a macro */
  96. Boolean GNUErrors;                       /* GNU-error-style messages ? */
  97.  
  98. FILE *PrgFile = NULL;                    /* Codedatei */
  99.  
  100. StringPtr ErrorPath, ErrorName;          /* Ausgabedatei Fehlermeldungen */
  101. StringPtr OutName;                       /* Name Code-Datei */
  102. Integer CurrIncludeLevel;                /* current include nesting level */
  103. StringPtr CurrFileName;                  /* mom. bearbeitete Datei */
  104. LongInt CurrLine;                        /* virtuelle Position */
  105. LongInt LineSum;                         /* Gesamtzahl Quellzeilen */
  106. LongInt MacLineSum;                      /* inkl. Makroexpansion */
  107.  
  108. LongInt NOPCode;                         /* Maschinenbefehl NOP zum Stopfen */
  109. Boolean TurnWords;                       /* TRUE  = Motorola-Wortformat */
  110.                                          /* FALSE = Intel-Wortformat */
  111. Byte HeaderID;                           /* Kennbyte des Codeheaders */
  112. const char *PCSymbol;                      /* Symbol, womit Programmzaehler erreicht wird. Inhalt Read Only! */
  113. Boolean (*SetIsOccupiedFnc)(void),       /* TRUE: SET instr, to be parsed by code generator */
  114.         (*SaveIsOccupiedFnc)(void),      /* ditto for SAVE */
  115.         (*RestoreIsOccupiedFnc)(void);   /* ditto for RESTORE */
  116. Boolean SwitchIsOccupied,                /* TRUE: SWITCH/PAGE/SHIFT ist Prozessorbefehl */
  117.         PageIsOccupied,
  118.         ShiftIsOccupied;
  119. Boolean multi_char_le;
  120. #ifdef __PROTOS__
  121. Boolean (*DecodeAttrPart)(void);         /* dissect attribute of instruction */
  122. void (*MakeCode)(void);                  /* Codeerzeugungsprozedur */
  123. Boolean (*ChkPC)(LargeWord Addr);        /* ueberprueft Codelaengenueberschreitungen */
  124. Boolean (*IsDef)(void);                  /* ist Label nicht als solches zu werten ? */
  125. void (*SwitchFrom)(void) = NULL;         /* bevor von einer CPU weggeschaltet wird */
  126. void (*InternSymbol)(char *Asc, TempResult *Erg); /* vordefinierte Symbole ? */
  127. #else
  128. Boolean (*DecodeAttrPart)();
  129. void (*MakeCode)();
  130. Boolean (*ChkPC)();
  131. Boolean (*IsDef)();
  132. void (*SwitchFrom)();
  133. void (*InternSymbol)();
  134. #endif
  135. DissectBitProc DissectBit;
  136. DissectRegProc DissectReg;
  137. tQualifyQuoteFnc QualifyQuote;
  138.  
  139. StringPtr IncludeList;                  /* Suchpfade fuer Includedateien */
  140. Integer IncDepth, NextIncDepth,         /* Verschachtelungstiefe INCLUDEs */
  141.         MaxIncDepth;
  142. FILE *ErrorFile = NULL;                 /* Fehlerausgabe */
  143. FILE *LstFile = NULL;                   /* Listdatei */
  144. FILE *ShareFile = NULL;                 /* Sharefile */
  145. FILE *MacProFile = NULL;                /* Makroprozessorausgabe */
  146. FILE *MacroFile = NULL;                 /* Ausgabedatei Makroliste */
  147. Boolean InMacroFlag;                    /* momentan wird Makro expandiert */
  148. StringPtr LstName;                      /* Name der Listdatei */
  149. StringPtr MacroName, MacProName;
  150. tLstMacroExp DoLst, NextDoLst;          /* Listing an */
  151. StringPtr ShareName;                    /* Name des Sharefiles */
  152.  
  153. CPUVar MomCPU, MomVirtCPU;              /* definierter/vorgegaukelter Prozessortyp */
  154. StringPtr MomCPUArgs;                   /* Arguments for Current Processor Type */
  155. char DefCPU[20];                        /* per Kommandozeile vorgegebene CPU */
  156. char MomCPUIdent[20],                   /* dessen Name in ASCII */
  157.      MomFPUIdent[20],                   /* ditto FPU */
  158.      MomPMMUIdent[20];                  /* ditto PMMU */
  159.  
  160. int OutRadixBase;                       /* dito fuer Ausgabe */
  161. int ListRadixBase;                      /* ditto for listing */
  162. Boolean ListPCZeroPad;                  /* PC with leading zeros? */
  163. const char *pCommentLeadIn;             /* list of comment lead-in sequences */
  164.  
  165. tStrComp *ArgStr;                       /* Komponenten der Zeile */
  166. tStrComp LabPart, CommPart, ArgPart, OpPart, AttrPart;
  167. char AttrSplit;
  168. Boolean oppart_leading_dot;
  169. int ArgCnt;                             /* Argumentzahl */
  170. int AllocArgCnt;
  171. as_dynstr_t OneLine;                    /* eingelesene Zeile */
  172. #ifdef PROFILE_MEMO
  173. unsigned NumMemo;
  174. unsigned long NumMemoCnt, NumMemoSum;
  175. #endif
  176.  
  177. Byte LstCounter;                        /* Zeilenzaehler fuer automatischen Umbruch */
  178. Word PageCounter[ChapMax + 1];          /* hierarchische Seitenzaehler */
  179. Byte ChapDepth;                         /* momentane Kapitelverschachtelung */
  180. StringPtr ListLine;                     /* alternative Ausgabe vor Listing fuer EQU */
  181. Byte PageLength, PageWidth;             /* Seitenlaenge/breite in Zeilen/Spalten */
  182. tLstMacroExpMod LstMacroExpModOverride, /* Override macro expansion ? */
  183.                 LstMacroExpModDefault;
  184. Boolean DottedStructs;                  /* structure elements with dots */
  185. StringPtr PrtInitString;                /* Druckerinitialisierungsstring */
  186. StringPtr PrtExitString;                /* Druckerdeinitialisierungsstring */
  187. StringPtr PrtTitleString;               /* Titelzeile */
  188.  
  189. LongInt MomSectionHandle;               /* mom. Namensraum */
  190. PSaveSection SectionStack;              /* gespeicherte Sektionshandles */
  191. tSavePhase *pPhaseStacks[SegCount];     /* saves nested PHASE values */
  192.  
  193. tSymbolSize AttrPartOpSize[2];          /* instruction operand size(s) deduced from insn attribute */
  194. LongWord MaxCodeLen = 0;                /* max. length of generated code */
  195. LongInt CodeLen;                        /* Laenge des erzeugten Befehls */
  196. LongWord *DAsmCode;                     /* Zwischenspeicher erzeugter Code */
  197. Word *WAsmCode;
  198. Byte *BAsmCode;
  199.  
  200. Boolean DontPrint;                      /* Flag:PC veraendert, aber keinen Code erzeugt */
  201. Word ActListGran;                       /* uebersteuerte List-Granularitaet */
  202.  
  203. Byte StopfZahl;                         /* Anzahl der im 2.Pass festgestellten
  204.                                            ueberfluessigen Worte, die mit NOP ge-
  205.                                            fuellt werden muessen */
  206.  
  207. Boolean SuppWarns;
  208.  
  209. PTransTable TransTables,                /* Liste mit Codepages */
  210.             CurrTransTable;             /* aktuelle Codepage */
  211.  
  212. PDefinement FirstDefine;                /* Liste von Praeprozessor-Defines */
  213.  
  214. PSaveState FirstSaveState;              /* gesicherte Zustaende */
  215.  
  216. Boolean MakeDebug;                      /* Debugginghilfe */
  217. FILE *Debug;
  218.  
  219. Boolean WasIF, WasMACRO;
  220.  
  221. void AsmDefInit(void)
  222. {
  223.   LongInt z;
  224.  
  225.   DoLst = eLstMacroExpAll;
  226.   PassNo = 1;
  227.   MaxSymPass = 1;
  228.  
  229.   LineSum = 0;
  230.  
  231.   for (z = 0; z <= ChapMax; PageCounter[z++] = 0);
  232.   LstCounter = 0;
  233.   ChapDepth = 0;
  234.  
  235.   PrtInitString[0] = '\0';
  236.   PrtExitString[0] = '\0';
  237.   PrtTitleString[0] = '\0';
  238.  
  239.   CurrFileName[0] = '\0';
  240.  
  241.   FirstDefine = NULL;
  242.   FirstSaveState = NULL;
  243. }
  244.  
  245. void NullProc(void)
  246. {
  247. }
  248.  
  249. void Default_InternSymbol(char *Asc, TempResult *Erg)
  250. {
  251.   UNUSED(Asc);
  252.  
  253.   Erg->Typ = TempNone;
  254. }
  255.  
  256. void Default_DissectBit(char *pDest, size_t DestSize, LargeWord BitSpec)
  257. {
  258.   HexString(pDest, DestSize, BitSpec, 0);
  259. }
  260.  
  261. static char *GetString(void)
  262. {
  263.   return (char*)malloc(STRINGSIZE * sizeof(char));
  264. }
  265.  
  266. int SetMaxCodeLen(LongWord NewMaxCodeLen)
  267. {
  268.   if (NewMaxCodeLen > MaxCodeLen_Max)
  269.     return ENOMEM;
  270.   if (NewMaxCodeLen > MaxCodeLen)
  271.   {
  272.     void *pNewMem;
  273.  
  274.     if (!MaxCodeLen)
  275.       pNewMem = (LongWord *) malloc(NewMaxCodeLen);
  276.     else
  277.       pNewMem = (LongWord *) realloc(DAsmCode, NewMaxCodeLen);
  278.     if (!pNewMem)
  279.       return ENOMEM;
  280.  
  281.     DAsmCode = (LongWord *)pNewMem;
  282.     WAsmCode = (Word *) DAsmCode;
  283.     BAsmCode = (Byte *) DAsmCode;
  284.     MaxCodeLen = NewMaxCodeLen;
  285.   }
  286.   return 0;
  287. }
  288.  
  289. /*!------------------------------------------------------------------------
  290.  * \fn     AppendArg(size_t ReqSize)
  291.  * \brief  extend list of arguments by one more at the end
  292.  * \param  ReqSize length of argument to store (excluding NUL at end)
  293.  * ------------------------------------------------------------------------ */
  294.  
  295. /* NOTICE: Due to port from Pascal sources, ArgStr[] is still indexed starting at
  296.    one instead of zero:
  297.  
  298.    - ArgStr[0] is unused.
  299.    - If ArgCnt == n, ArgStr[1] to ArgStr[n] are used.  */
  300.  
  301. void AppendArg(size_t ReqSize)
  302. {
  303.   if (ArgCnt >= ArgCntMax)
  304.     WrXError(ErrNum_InternalError, "MaxArgCnt");
  305.   ++ArgCnt;
  306.  
  307.   if (ArgCnt >= AllocArgCnt)
  308.   {
  309.     size_t NewArgStrSize = sizeof(*ArgStr) * (ArgCnt + 1); /* one more, [0] is unused */
  310.     int z;
  311.  
  312.     ArgStr = ArgStr ? (tStrComp*)realloc(ArgStr, NewArgStrSize) : (tStrComp*)malloc(NewArgStrSize);
  313.     for (z = AllocArgCnt; z <= ArgCnt; z++)
  314.       StrCompAlloc(&ArgStr[z], STRINGSIZE);
  315.     AllocArgCnt = ArgCnt + 1;
  316.   }
  317.  
  318.   if (ArgStr[ArgCnt].str.capacity <= ReqSize)
  319.   {
  320.     if (as_dynstr_realloc(&ArgStr[ArgCnt].str, as_dynstr_roundup_len(ReqSize)))
  321.       WrXError(ErrNum_InternalError, "out of memory");
  322.   }
  323. }
  324.  
  325. /*!------------------------------------------------------------------------
  326.  * \fn     InsertArg(unsigned Index, size_t ReqSize)
  327.  * \brief  insert one more arg @ given position
  328.  * \param  Index insertion position
  329.  * \param  ReqSize requested size of new arg
  330.  * ------------------------------------------------------------------------ */
  331.  
  332. void InsertArg(int Index, size_t ReqSize)
  333. {
  334.   int z;
  335.  
  336.   /* 0 should never be passed... */
  337.  
  338.   if (Index < 1)
  339.     Index = 1;
  340.  
  341.   /* Insertion beyond end means appending */
  342.  
  343.   if (Index > ArgCnt)
  344.   {
  345.     AppendArg(ReqSize);
  346.     return;
  347.   }
  348.  
  349.   /* current last arg dictates length of new last arg */
  350.  
  351.   AppendArg(strlen(ArgStr[ArgCnt].str.p_str));
  352.   for (z = ArgCnt; z > Index; z--)
  353.   {
  354.     as_dynstr_copy(&ArgStr[z].str, &ArgStr[z - 1].str);
  355.     ArgStr[z].Pos = ArgStr[z - 1].Pos;
  356.   }
  357.   if (ArgStr[Index].str.capacity < ReqSize + 1)
  358.   {
  359.     if (as_dynstr_realloc(&ArgStr[Index].str, as_dynstr_roundup_len(ReqSize)))
  360.       WrXError(ErrNum_InternalError, "out of memory");
  361.   }
  362. }
  363.  
  364. /*!------------------------------------------------------------------------
  365.  * \fn     memo_set_pseudo(void)
  366.  * \brief  is the current instruction SET, and the pseudo instruction of that name?
  367.  * \return True if yes
  368.  * ------------------------------------------------------------------------ */
  369.  
  370. Boolean memo_set_pseudo(void)
  371. {
  372.   return Memo("SET") && is_set_pseudo();
  373. }
  374.  
  375. /*!------------------------------------------------------------------------
  376.  * \fn     is_set_pseudo(void)
  377.  * \brief  is the current (SET) instruction the pseudo instruction of that name?
  378.  * \return True if yes
  379.  * ------------------------------------------------------------------------ */
  380.  
  381. Boolean is_set_pseudo(void)
  382. {
  383.   return (oppart_leading_dot
  384.        || (!SetIsOccupiedFnc || !SetIsOccupiedFnc()));
  385. }
  386.  
  387. /*!------------------------------------------------------------------------
  388.  * \fn     is_save_pseudo(void)
  389.  * \brief  is the current (SAVE) instruction the pseudo instruction of that name?
  390.  * \return True if yes
  391.  * ------------------------------------------------------------------------ */
  392.  
  393. Boolean is_save_pseudo(void)
  394. {
  395.   return (oppart_leading_dot
  396.        || (!SaveIsOccupiedFnc || !SaveIsOccupiedFnc()));
  397. }
  398.  
  399. /*!------------------------------------------------------------------------
  400.  * \fn     is_restore_pseudo(void)
  401.  * \brief  is the current (RESTORE) instruction the pseudo instruction of that name?
  402.  * \return True if yes
  403.  * ------------------------------------------------------------------------ */
  404.  
  405. Boolean is_restore_pseudo(void)
  406. {
  407.   return (oppart_leading_dot
  408.        || (!RestoreIsOccupiedFnc || !RestoreIsOccupiedFnc()));
  409. }
  410.  
  411. /*!------------------------------------------------------------------------
  412.  * \fn     memo_switch_pseudo(void)
  413.  * \brief  is the current instruction SWITCh, and the pseudo instruction of that name?
  414.  * \return True if yes
  415.  * ------------------------------------------------------------------------ */
  416.  
  417. Boolean memo_switch_pseudo(void)
  418. {
  419.   return Memo("SWITCH")
  420.       && (oppart_leading_dot || !SwitchIsOccupied);
  421. }
  422.  
  423. /*!------------------------------------------------------------------------
  424.  * \fn     memo_shift_pseudo(void)
  425.  * \brief  is the current instruction SHIFT, and the pseudo instruction of that name?
  426.  * \return True if yes
  427.  * ------------------------------------------------------------------------ */
  428.  
  429. Boolean memo_shift_pseudo(void)
  430. {
  431.   return Memo("SHIFT")
  432.       && (oppart_leading_dot || !ShiftIsOccupied);
  433. }
  434.  
  435. /*!------------------------------------------------------------------------
  436.  * \fn     is_page_pseudo(void)
  437.  * \brief  is the current PAGE instruction the pseudo instruction of that name?
  438.  * \return True if yes
  439.  * ------------------------------------------------------------------------ */
  440.  
  441. Boolean is_page_pseudo(void)
  442. {
  443.   return oppart_leading_dot || !PageIsOccupied;
  444. }
  445.  
  446. /*!------------------------------------------------------------------------
  447.  * \fn     free_forward_symbol(PForwardSymbol p_symbol)
  448.  * \brief  free entry from forward symbol list
  449.  * \param  p_symbol entry to free
  450.  * ------------------------------------------------------------------------ */
  451.  
  452. void free_forward_symbol(PForwardSymbol p_symbol)
  453. {
  454.   free(p_symbol->Name); p_symbol->Name = NULL;
  455.   free(p_symbol->pErrorPos); p_symbol->pErrorPos = NULL;
  456.   free(p_symbol);
  457. }
  458.  
  459. void asmdef_init(void)
  460. {
  461.   SwitchFrom = NullProc;
  462.   InternSymbol = Default_InternSymbol;
  463.   DissectBit = Default_DissectBit;
  464.   DissectReg = NULL;
  465.   QualifyQuote = NULL;
  466.  
  467.   SetMaxCodeLen(MaxCodeLen_Ini);
  468.  
  469.   /* auf diese Weise wird PCSymbol defaultmaessig nicht erreichbar
  470.      da das schon von den Konstantenparsern im Formelparser abgefangen
  471.      wuerde */
  472.  
  473.   PCSymbol = "--PC--SYMBOL--";
  474.   *DefCPU = '\0';
  475.  
  476.   ArgStr = NULL;
  477.   AllocArgCnt = 0;
  478.   SourceFile = GetString();
  479.   CursUp = GetString();
  480.   ErrorPath = GetString();
  481.   ErrorName = GetString();
  482.   OutName = GetString();
  483.   CurrFileName = GetString();
  484.   IncludeList = GetString();
  485.   LstName = GetString();
  486.   MacroName = GetString();
  487.   MacProName = GetString();
  488.   ShareName = GetString();
  489.   StrCompAlloc(&LabPart, STRINGSIZE);
  490.   StrCompAlloc(&OpPart, STRINGSIZE);
  491.   StrCompAlloc(&AttrPart, STRINGSIZE);
  492.   StrCompAlloc(&ArgPart, STRINGSIZE);
  493.   StrCompAlloc(&CommPart, STRINGSIZE);
  494.   as_dynstr_ini(&OneLine, STRINGSIZE);
  495.   ListLine = GetString();
  496.   PrtInitString = GetString();
  497.   PrtExitString = GetString();
  498.   PrtTitleString = GetString();
  499.   MomCPUArgs = GetString();
  500.  
  501.   SegInits = (LargeWord*)calloc(SegCount, sizeof(*SegInits));
  502.   SegLimits = (LargeWord*)calloc(SegCount, sizeof(*SegLimits));
  503.   Phases = (LargeWord*)calloc(SegCountPlusStruct, sizeof(*Phases));
  504.   PCs = (LargeWord*)calloc(SegCountPlusStruct, sizeof(*PCs));
  505. }
  506.