git.sur5r.net Git - cc65/blob - src/ca65/symtab.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 symtab.c                                  */
   4 /*                                                                           */
   5 /*                 Symbol table for the ca65 macroassembler                  */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 1998-2004 Ullrich von Bassewitz                                       */
  10 /*               Römerstraße 52                                              */
  11 /*               D-70794 Filderstadt                                         */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <string.h>
  37
  38 /* common */
  39 #include "addrsize.h"
  40 #include "check.h"
  41 #include "hashstr.h"
  42 #include "mmodel.h"
  43 #include "symdefs.h"
  44 #include "xmalloc.h"
  45
  46 /* ca65 */
  47 #include "global.h"
  48 #include "error.h"
  49 #include "expr.h"
  50 #include "objfile.h"
  51 #include "scanner.h"
  52 #include "segment.h"
  53 #include "sizeof.h"
  54 #include "spool.h"
  55 #include "studyexpr.h"
  56 #include "symtab.h"
  57
  58
  59
  60 /*****************************************************************************/
  61 /*                                   Data                                    */
  62 /*****************************************************************************/
  63
  64
  65
  66 /* Combined symbol entry flags used within this module */
  67 #define SF_UNDEFMASK    (SF_REFERENCED | SF_DEFINED | SF_IMPORT)
  68 #define SF_UNDEFVAL     (SF_REFERENCED)
  69 #define SF_DBGINFOMASK  (SF_UNUSED | SF_DEFINED | SF_IMPORT)
  70 #define SF_DBGINFOVAL   (SF_DEFINED)
  71
  72 /* Symbol tables */
  73 SymTable*       CurrentScope = 0;       /* Pointer to current symbol table */
  74 SymTable*       RootScope    = 0;       /* Root symbol table */
  75
  76 /* Symbol table variables */
  77 static unsigned ImportCount = 0;        /* Counter for import symbols */
  78 static unsigned ExportCount = 0;        /* Counter for export symbols */
  79
  80
  81
  82 /*****************************************************************************/
  83 /*                         Internally used functions                         */
  84 /*****************************************************************************/
  85
  86
  87
  88 static unsigned ScopeTableSize (unsigned Level)
  89 /* Get the size of a table for the given lexical level */
  90 {
  91     switch (Level) {
  92         case 0:         return 213;
  93         case 1:         return  53;
  94         default:        return  29;
  95     }
  96 }
  97
  98
  99
 100 static SymTable* NewSymTable (SymTable* Parent, const char* Name)
 101 /* Allocate a symbol table on the heap and return it */
 102 {
 103     /* Determine the lexical level and the number of table slots */
 104     unsigned Level = Parent? Parent->Level + 1 : 0;
 105     unsigned Slots = ScopeTableSize (Level);
 106
 107     /* Allocate memory */
 108     SymTable* S = xmalloc (sizeof (SymTable) + (Slots-1) * sizeof (SymEntry*));
 109
 110     /* Set variables and clear hash table entries */
 111     S->Left         = 0;
 112     S->Right        = 0;
 113     S->Childs       = 0;
 114     S->SegRanges    = AUTO_COLLECTION_INITIALIZER;
 115     S->Flags        = ST_NONE;
 116     S->AddrSize     = ADDR_SIZE_DEFAULT;
 117     S->Type         = ST_UNDEF;
 118     S->Level        = Level;
 119     S->TableSlots   = Slots;
 120     S->TableEntries = 0;
 121     S->Parent       = Parent;
 122     S->Name         = GetStringId (Name);
 123     while (Slots--) {
 124         S->Table[Slots] = 0;
 125     }
 126
 127     /* Insert the symbol table into the child tree of the parent */
 128     if (Parent) {
 129         SymTable* T = Parent->Childs;
 130         if (T == 0) {
 131             /* First entry */
 132             Parent->Childs = S;
 133         } else {
 134             while (1) {
 135                 /* Choose next entry */
 136                 int Cmp = strcmp (Name, GetString (T->Name));
 137                 if (Cmp < 0) {
 138                     if (T->Left) {
 139                         T = T->Left;
 140                     } else {
 141                         T->Left = S;
 142                         break;
 143                     }
 144                 } else if (Cmp > 0) {
 145                     if (T->Right) {
 146                         T = T->Right;
 147                     } else {
 148                         T->Right = S;
 149                         break;
 150                     }
 151                 } else {
 152                     /* Duplicate scope name */
 153                     Internal ("Duplicate scope name: `%s'", Name);
 154                 }
 155             }
 156         }
 157     }
 158
 159     /* Return the prepared struct */
 160     return S;
 161 }
 162
 163
 164
 165 /*****************************************************************************/
 166 /*                                   Code                                    */
 167 /*****************************************************************************/
 168
 169
 170
 171 void SymEnterLevel (const char* ScopeName, unsigned char Type, unsigned char AddrSize)
 172 /* Enter a new lexical level */
 173 {
 174     /* Map a default address size to something real */
 175     if (AddrSize == ADDR_SIZE_DEFAULT) {
 176         /* Use the segment address size */
 177         AddrSize = GetCurrentSegAddrSize ();
 178     }
 179
 180     /* If we have a current scope, search for the given name and create a
 181      * new one if it doesn't exist. If this is the root scope, just create it.
 182      */
 183     if (CurrentScope) {
 184
 185         /* Search for the scope, create a new one */
 186         CurrentScope = SymFindScope (CurrentScope, ScopeName, SYM_ALLOC_NEW);
 187
 188         /* Check if the scope has been defined before */
 189         if (CurrentScope->Flags & ST_DEFINED) {
 190             Error ("Duplicate scope `%s'", ScopeName);
 191         }
 192
 193     } else {
 194         CurrentScope = RootScope = NewSymTable (0, ScopeName);
 195     }
 196
 197     /* Mark the scope as defined and set type and address size */
 198     CurrentScope->Flags    |= ST_DEFINED;
 199     CurrentScope->AddrSize = AddrSize;
 200     CurrentScope->Type     = Type;
 201
 202     /* If this is a scope that allows to emit data into segments, add segment
 203      * ranges for all currently existing segments. Doing this for just a few
 204      * scope types is not really necessary but an optimization, because it
 205      * does not allocate memory for useless data (unhandled types here don't
 206      * occupy space in any segment).
 207      */
 208     if (CurrentScope->Type <= ST_SCOPE_HAS_DATA) {
 209         AddSegRanges (&CurrentScope->SegRanges);
 210     }
 211 }
 212
 213
 214
 215 void SymLeaveLevel (void)
 216 /* Leave the current lexical level */
 217 {
 218     /* Close the segment ranges. We don't care about the scope type here,
 219      * since types without segment ranges will just have an empty list.
 220      */
 221     CloseSegRanges (&CurrentScope->SegRanges);
 222
 223     /* If we have segment ranges, the first one is the segment that was
 224      * active, when the scope was opened. Set the size of the scope to the
 225      * number of data bytes emitted into this segment.
 226      */
 227     if (CollCount (&CurrentScope->SegRanges) > 0) {
 228         const SegRange* R = CollAtUnchecked (&CurrentScope->SegRanges, 0);
 229         DefSizeOfScope (CurrentScope, GetSegRangeSize (R));
 230     }
 231
 232     /* Leave the scope */
 233     CurrentScope = CurrentScope->Parent;
 234 }
 235
 236
 237
 238 SymTable* SymFindScope (SymTable* Parent, const char* Name, int AllocNew)
 239 /* Find a scope in the given enclosing scope */
 240 {
 241     SymTable** T = &Parent->Childs;
 242     while (*T) {
 243         int Cmp = strcmp (Name, GetString ((*T)->Name));
 244         if (Cmp < 0) {
 245             T = &(*T)->Left;
 246         } else if (Cmp > 0) {
 247             T = &(*T)->Right;
 248         } else {
 249             /* Found the scope */
 250             return *T;
 251         }
 252     }
 253
 254     /* Create a new scope if requested and we didn't find one */
 255     if (*T == 0 && AllocNew) {
 256         *T = NewSymTable (Parent, Name);
 257     }
 258
 259     /* Return the scope */
 260     return *T;
 261 }
 262
 263
 264
 265 SymTable* SymFindAnyScope (SymTable* Parent, const char* Name)
 266 /* Find a scope in the given or any of its parent scopes. The function will
 267  * never create a new symbol, since this can only be done in one specific
 268  * scope.
 269  */
 270 {
 271     SymTable* Scope;
 272     do {
 273         /* Search in the current table */
 274         Scope = SymFindScope (Parent, Name, SYM_FIND_EXISTING);
 275         if (Scope == 0) {
 276             /* Not found, search in the parent scope, if we have one */
 277             Parent = Parent->Parent;
 278         }
 279     } while (Scope == 0 && Parent != 0);
 280
 281     return Scope;
 282 }
 283
 284
 285
 286 SymEntry* SymFindLocal (SymEntry* Parent, const char* Name, int AllocNew)
 287 /* Find a cheap local symbol. If AllocNew is given and the entry is not
 288  * found, create a new one. Return the entry found, or the new entry created,
 289  * or - in case AllocNew is zero - return 0.
 290  */
 291 {
 292     SymEntry* S;
 293     int Cmp;
 294
 295     /* Local symbol, get the table */
 296     if (!Parent) {
 297         /* No last global, so there's no local table */
 298         Error ("No preceeding global symbol");
 299         if (AllocNew) {
 300             return NewSymEntry (Name, SF_LOCAL);
 301         } else {
 302             return 0;
 303         }
 304     }
 305
 306     /* Search for the symbol if we have a table */
 307     Cmp = SymSearchTree (Parent->Locals, Name, &S);
 308
 309     /* If we found an entry, return it */
 310     if (Cmp == 0) {
 311         return S;
 312     }
 313
 314     if (AllocNew) {
 315
 316         /* Otherwise create a new entry, insert and return it */
 317         SymEntry* N = NewSymEntry (Name, SF_LOCAL);
 318         if (S == 0) {
 319             Parent->Locals = N;
 320         } else if (Cmp < 0) {
 321             S->Left = N;
 322         } else {
 323             S->Right = N;
 324         }
 325         return N;
 326     }
 327
 328     /* We did not find the entry and AllocNew is false. */
 329     return 0;
 330 }
 331
 332
 333
 334 SymEntry* SymFind (SymTable* Scope, const char* Name, int AllocNew)
 335 /* Find a new symbol table entry in the given table. If AllocNew is given and
 336  * the entry is not found, create a new one. Return the entry found, or the
 337  * new entry created, or - in case AllocNew is zero - return 0.
 338  */
 339 {
 340     SymEntry* S;
 341
 342     /* Global symbol: Get the hash value for the name */
 343     unsigned Hash = HashStr (Name) % Scope->TableSlots;
 344
 345     /* Search for the entry */
 346     int Cmp = SymSearchTree (Scope->Table[Hash], Name, &S);
 347
 348     /* If we found an entry, return it */
 349     if (Cmp == 0) {
 350         return S;
 351     }
 352
 353     if (AllocNew) {
 354
 355         /* Otherwise create a new entry, insert and return it */
 356         SymEntry* N = NewSymEntry (Name, SF_NONE);
 357         if (S == 0) {
 358             Scope->Table[Hash] = N;
 359         } else if (Cmp < 0) {
 360             S->Left = N;
 361         } else {
 362             S->Right = N;
 363         }
 364         N->SymTab = Scope;
 365         ++Scope->TableEntries;
 366         return N;
 367
 368     }
 369
 370     /* We did not find the entry and AllocNew is false. */
 371     return 0;
 372 }
 373
 374
 375
 376 SymEntry* SymFindAny (SymTable* Scope, const char* Name)
 377 /* Find a symbol in the given or any of its parent scopes. The function will
 378  * never create a new symbol, since this can only be done in one specific
 379  * scope.
 380  */
 381 {
 382     SymEntry* Sym;
 383     do {
 384         /* Search in the current table */
 385         Sym = SymFind (Scope, Name, SYM_FIND_EXISTING);
 386         if (Sym) {
 387             /* Found, return it */
 388             break;
 389         }
 390
 391         /* Not found, search in the parent scope, if we have one */
 392         Scope = Scope->Parent;
 393
 394     } while (Sym == 0 && Scope != 0);
 395
 396     /* Return the result */
 397     return Sym;
 398 }
 399
 400
 401
 402 unsigned char GetCurrentSymTabType ()
 403 /* Return the type of the current symbol table */
 404 {
 405     CHECK (CurrentScope != 0);
 406     return CurrentScope->Type;
 407 }
 408
 409
 410
 411 static void SymCheckUndefined (SymEntry* S)
 412 /* Handle an undefined symbol */
 413 {
 414     /* Undefined symbol. It may be...
 415      *
 416      *   - An undefined symbol in a nested lexical level. In this
 417      *     case, search for the symbol in the higher levels and
 418      *     make the entry a trampoline entry if we find one.
 419      *
 420      *   - If the symbol is not found, it is a real undefined symbol.
 421      *     If the AutoImport flag is set, make it an import. If the
 422      *     AutoImport flag is not set, it's an error.
 423      */
 424     SymEntry* Sym = 0;
 425     SymTable* Tab = GetSymParentScope (S);
 426     while (Tab) {
 427         Sym = SymFind (Tab, GetString (S->Name), SYM_FIND_EXISTING);
 428         if (Sym && (Sym->Flags & (SF_DEFINED | SF_IMPORT)) != 0) {
 429             /* We've found a symbol in a higher level that is
 430              * either defined in the source, or an import.
 431              */
 432              break;
 433         }
 434         /* No matching symbol found in this level. Look further */
 435         Tab = Tab->Parent;
 436     }
 437
 438     if (Sym) {
 439
 440         /* We found the symbol in a higher level. Transfer the flags and
 441          * address size from the local symbol to that in the higher level
 442          * and check for problems.
 443          */
 444         if (S->Flags & SF_EXPORT) {
 445             if (Sym->Flags & SF_IMPORT) {
 446                 /* The symbol is already marked as import */
 447                 PError (&S->Pos, "Symbol `%s' is already an import",
 448                         GetString (Sym->Name));
 449             }
 450             if (Sym->Flags & SF_EXPORT) {
 451                 /* The symbol is already marked as an export. */
 452                 if (Sym->AddrSize > S->ExportSize) {
 453                     /* We're exporting a symbol smaller than it actually is */
 454                     PWarning (&S->Pos, 1, "Symbol `%s' is %s but exported %s",
 455                               GetSymName (Sym), AddrSizeToStr (Sym->AddrSize),
 456                               AddrSizeToStr (S->ExportSize));
 457                 }
 458             } else {
 459                 /* Mark the symbol as an export */
 460                 Sym->Flags |= SF_EXPORT;
 461                 Sym->ExportSize = S->ExportSize;
 462                 if (Sym->ExportSize == ADDR_SIZE_DEFAULT) {
 463                     /* Use the actual size of the symbol */
 464                     Sym->ExportSize = Sym->AddrSize;
 465                 }
 466                 if (Sym->AddrSize > Sym->ExportSize) {
 467                     /* We're exporting a symbol smaller than it actually is */
 468                     PWarning (&S->Pos, 1, "Symbol `%s' is %s but exported %s",
 469                               GetSymName (Sym), AddrSizeToStr (Sym->AddrSize),
 470                               AddrSizeToStr (Sym->ExportSize));
 471                 }
 472             }
 473         }
 474         Sym->Flags |= (S->Flags & SF_REFERENCED);
 475
 476         /* Transfer all expression references */
 477         SymTransferExprRefs (S, Sym);
 478
 479         /* Mark the symbol as unused removing all other flags */
 480         S->Flags = SF_UNUSED;
 481
 482     } else {
 483         /* The symbol is definitely undefined */
 484         if (S->Flags & SF_EXPORT) {
 485             /* We will not auto-import an export */
 486             PError (&S->Pos, "Exported symbol `%s' was never defined",
 487                     GetString (S->Name));
 488         } else {
 489             if (AutoImport) {
 490                 /* Mark as import, will be indexed later */
 491                 S->Flags |= SF_IMPORT;
 492                 /* Use the address size for code */
 493                 S->AddrSize = CodeAddrSize;
 494             } else {
 495                 /* Error */
 496                 PError (&S->Pos, "Symbol `%s' is undefined", GetString (S->Name));
 497             }
 498         }
 499     }
 500 }
 501
 502
 503
 504 void SymCheck (void)
 505 /* Run through all symbols and check for anomalies and errors */
 506 {
 507     SymEntry* S;
 508
 509     /* Check for open scopes */
 510     if (CurrentScope->Parent != 0) {
 511         Error ("Local scope was not closed");
 512     }
 513
 514     /* First pass: Walk through all symbols, checking for undefined's and
 515      * changing them to trampoline symbols or make them imports.
 516      */
 517     S = SymList;
 518     while (S) {
 519         /* If the symbol is marked as global, mark it as export, if it is
 520          * already defined, otherwise mark it as import.
 521          */
 522         if (S->Flags & SF_GLOBAL) {
 523             if (S->Flags & SF_DEFINED) {
 524                 SymExportFromGlobal (S);
 525             } else {
 526                 SymImportFromGlobal (S);
 527             }
 528         }
 529
 530         /* Handle undefined symbols */
 531         if ((S->Flags & SF_UNDEFMASK) == SF_UNDEFVAL) {
 532             /* This is an undefined symbol. Handle it. */
 533             SymCheckUndefined (S);
 534         }
 535
 536         /* Next symbol */
 537         S = S->List;
 538     }
 539
 540     /* Second pass: Walk again through the symbols. Count exports and imports
 541      * and set address sizes where this has not happened before. Ignore
 542      * undefined's, since we handled them in the last pass, and ignore unused
 543      * symbols, since we handled them in the last pass, too.
 544      */
 545     S = SymList;
 546     while (S) {
 547         if ((S->Flags & SF_UNUSED) == 0 &&
 548             (S->Flags & SF_UNDEFMASK) != SF_UNDEFVAL) {
 549
 550             /* Check for defined symbols that were never referenced */
 551             if ((S->Flags & SF_DEFINED) != 0 && (S->Flags & SF_REFERENCED) == 0) {
 552                 PWarning (&S->Pos, 2,
 553                           "Symbol `%s' is defined but never used",
 554                           GetString (S->Name));
 555             }
 556
 557             /* Assign an index to all imports */
 558             if (S->Flags & SF_IMPORT) {
 559                 if ((S->Flags & (SF_REFERENCED | SF_FORCED)) == SF_NONE) {
 560                     /* Imported symbol is not referenced */
 561                     PWarning (&S->Pos, 2,
 562                               "Symbol `%s' is imported but never used",
 563                               GetString (S->Name));
 564                 } else {
 565                     /* Give the import an index, count imports */
 566                     S->Index = ImportCount++;
 567                     S->Flags |= SF_INDEXED;
 568                 }
 569             }
 570
 571             /* Assign an index to all exports */
 572             if (S->Flags & SF_EXPORT) {
 573                 /* Give the export an index, count exports */
 574                 S->Index = ExportCount++;
 575                 S->Flags |= SF_INDEXED;
 576             }
 577
 578             /* If the symbol is defined but has an unknown address size,
 579              * recalculate it.
 580              */
 581             if (SymHasExpr (S) && S->AddrSize == ADDR_SIZE_DEFAULT) {
 582                 ExprDesc ED;
 583                 ED_Init (&ED);
 584                 StudyExpr (S->Expr, &ED);
 585                 S->AddrSize = ED.AddrSize;
 586                 if (SymIsExport (S)) {
 587                     if (S->ExportSize == ADDR_SIZE_DEFAULT) {
 588                         /* Use the real export size */
 589                         S->ExportSize = S->AddrSize;
 590                     } else if (S->AddrSize > S->ExportSize) {
 591                         /* We're exporting a symbol smaller than it actually is */
 592                         PWarning (&S->Pos, 1,
 593                                   "Symbol `%s' is %s but exported %s",
 594                                   GetSymName (S), AddrSizeToStr (S->AddrSize),
 595                                   AddrSizeToStr (S->ExportSize));
 596                     }
 597                 }
 598                 ED_Done (&ED);
 599             }
 600         }
 601
 602         /* Next symbol */
 603         S = S->List;
 604     }
 605 }
 606
 607
 608
 609 void SymDump (FILE* F)
 610 /* Dump the symbol table */
 611 {
 612     SymEntry* S = SymList;
 613
 614     while (S) {
 615         /* Ignore unused symbols */
 616         if ((S->Flags & SF_UNUSED) != 0) {
 617             fprintf (F,
 618                      "%-24s %s %s %s %s %s\n",
 619                      GetString (S->Name),
 620                      (S->Flags & SF_DEFINED)? "DEF" : "---",
 621                      (S->Flags & SF_REFERENCED)? "REF" : "---",
 622                      (S->Flags & SF_IMPORT)? "IMP" : "---",
 623                      (S->Flags & SF_EXPORT)? "EXP" : "---",
 624                      AddrSizeToStr (S->AddrSize));
 625         }
 626         /* Next symbol */
 627         S = S->List;
 628     }
 629 }
 630
 631
 632
 633 void WriteImports (void)
 634 /* Write the imports list to the object file */
 635 {
 636     SymEntry* S;
 637
 638     /* Tell the object file module that we're about to start the imports */
 639     ObjStartImports ();
 640
 641     /* Write the import count to the list */
 642     ObjWriteVar (ImportCount);
 643
 644     /* Walk throught list and write all valid imports to the file. An import
 645      * is considered valid, if it is either referenced, or the forced bit is
 646      * set. Otherwise, the import is ignored (no need to link in something
 647      * that isn't used).
 648      */
 649     S = SymList;
 650     while (S) {
 651         if ((S->Flags & (SF_UNUSED | SF_IMPORT)) == SF_IMPORT &&
 652             (S->Flags & (SF_REFERENCED | SF_FORCED)) != 0) {
 653
 654             ObjWrite8 (S->AddrSize);
 655             ObjWriteVar (S->Name);
 656             ObjWritePos (&S->Pos);
 657         }
 658         S = S->List;
 659     }
 660
 661     /* Done writing imports */
 662     ObjEndImports ();
 663 }
 664
 665
 666
 667 void WriteExports (void)
 668 /* Write the exports list to the object file */
 669 {
 670     SymEntry* S;
 671     unsigned Type;
 672
 673     /* Tell the object file module that we're about to start the exports */
 674     ObjStartExports ();
 675
 676     /* Write the export count to the list */
 677     ObjWriteVar (ExportCount);
 678
 679     /* Walk throught list and write all exports to the file */
 680     S = SymList;
 681     while (S) {
 682         if ((S->Flags & (SF_UNUSED | SF_EXPORT)) == SF_EXPORT) {
 683
 684             long ConstVal;
 685
 686             /* Get the expression bits */
 687             unsigned char ExprMask = SymIsConst (S, &ConstVal)? EXP_CONST : EXP_EXPR;
 688             ExprMask |= (S->Flags & SF_LABEL)? EXP_LABEL : EXP_EQUATE;
 689
 690             /* Count the number of ConDes types */
 691             for (Type = 0; Type < CD_TYPE_COUNT; ++Type) {
 692                 if (S->ConDesPrio[Type] != CD_PRIO_NONE) {
 693                     INC_EXP_CONDES_COUNT (ExprMask);
 694                 }
 695             }
 696
 697             /* Write the type and the export size */
 698             ObjWrite8 (ExprMask);
 699             ObjWrite8 (S->ExportSize);
 700
 701             /* Write any ConDes declarations */
 702             if (GET_EXP_CONDES_COUNT (ExprMask) > 0) {
 703                 for (Type = 0; Type < CD_TYPE_COUNT; ++Type) {
 704                     unsigned char Prio = S->ConDesPrio[Type];
 705                     if (Prio != CD_PRIO_NONE) {
 706                         ObjWrite8 (CD_BUILD (Type, Prio));
 707                     }
 708                 }
 709             }
 710
 711             /* Write the name */
 712             ObjWriteVar (S->Name);
 713
 714             /* Write the value */
 715             if ((ExprMask & EXP_MASK_VAL) == EXP_CONST) {
 716                 /* Constant value */
 717                 ObjWrite32 (ConstVal);
 718             } else {
 719                 /* Expression involved */
 720                 WriteExpr (S->Expr);
 721             }
 722
 723             /* Write the source file position */
 724             ObjWritePos (&S->Pos);
 725         }
 726         S = S->List;
 727     }
 728
 729     /* Done writing exports */
 730     ObjEndExports ();
 731 }
 732
 733
 734
 735 void WriteDbgSyms (void)
 736 /* Write a list of all symbols to the object file */
 737 {
 738     unsigned Count;
 739     SymEntry* S;
 740
 741     /* Tell the object file module that we're about to start the debug info */
 742     ObjStartDbgSyms ();
 743
 744     /* Check if debug info is requested */
 745     if (DbgSyms) {
 746
 747         /* Walk through the list and count the symbols */
 748         Count = 0;
 749         S = SymList;
 750         while (S) {
 751             if ((S->Flags & SF_DBGINFOMASK) == SF_DBGINFOVAL) {
 752                 ++Count;
 753             }
 754             S = S->List;
 755         }
 756
 757         /* Write the symbol count to the list */
 758         ObjWriteVar (Count);
 759
 760         /* Walk through list and write all symbols to the file */
 761         S = SymList;
 762         while (S) {
 763             if ((S->Flags & SF_DBGINFOMASK) == SF_DBGINFOVAL) {
 764
 765                 long ConstVal;
 766
 767                 /* Get the expression bits */
 768                 unsigned char ExprMask = (SymIsConst (S, &ConstVal))? EXP_CONST : EXP_EXPR;
 769                 ExprMask |= (S->Flags & SF_LABEL)? EXP_LABEL : EXP_EQUATE;
 770
 771                 /* Write the type */
 772                 ObjWrite8 (ExprMask);
 773
 774                 /* Write the address size */
 775                 ObjWrite8 (S->AddrSize);
 776
 777                 /* Write the name */
 778                 ObjWriteVar (S->Name);
 779
 780                 /* Write the value */
 781                 if ((ExprMask & EXP_MASK_VAL) == EXP_CONST) {
 782                     /* Constant value */
 783                     ObjWrite32 (ConstVal);
 784                 } else {
 785                     /* Expression involved */
 786                     WriteExpr (S->Expr);
 787                 }
 788
 789                 /* Write the source file position */
 790                 ObjWritePos (&S->Pos);
 791             }
 792             S = S->List;
 793         }
 794
 795     } else {
 796
 797         /* No debug symbols */
 798         ObjWriteVar (0);
 799
 800     }
 801
 802     /* Done writing debug symbols */
 803     ObjEndDbgSyms ();
 804 }
 805
 806
 807
 808 void WriteScopes (void)
 809 /* Write the scope table to the object file */
 810 {
 811     /* Tell the object file module that we're about to start the scopes */
 812     ObjStartScopes ();
 813
 814     /* For now ...*/
 815     ObjWriteVar (0);
 816
 817     /* Done writing the scopes */
 818     ObjEndScopes ();
 819 }
 820
 821
 822