git.sur5r.net Git - cc65/blob - src/dbginfo/dbginfo.h

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 dbginfo.h                                 */
   4 /*                                                                           */
   5 /*                         cc65 debug info handling                          */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2010-2011, Ullrich von Bassewitz                                      */
  10 /*                Roemerstrasse 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 #ifndef DBGINFO_H
  37 #define DBGINFO_H
  38
  39
  40
  41 /* Allow usage from C++ */
  42 #ifdef __cplusplus
  43 extern "C" {
  44 #endif
  45
  46
  47
  48 /*****************************************************************************/
  49 /*                                   Data                                    */
  50 /*****************************************************************************/
  51
  52
  53
  54 /* Data types used for addresses, sizes and line numbers. Change to "unsigned
  55  * long" if you ever want to run the code on a 16-bit machine.
  56  */
  57 typedef unsigned cc65_line;             /* Used to store line numbers */
  58 typedef unsigned cc65_addr;             /* Used to store (65xx) addresses */
  59 typedef unsigned cc65_size;             /* Used to store (65xx) sizes */
  60
  61 /* A value that is used to mark invalid ids */
  62 #define CC65_INV_ID     (~0U)
  63
  64
  65
  66 /*****************************************************************************/
  67 /*                             Debug info files                              */
  68 /*****************************************************************************/
  69
  70
  71
  72 /* Severity for cc65_parseerror */
  73 typedef enum {
  74     CC65_WARNING,
  75     CC65_ERROR,
  76 } cc65_error_severity;
  77
  78 /* Warnings/errors in cc65_read_dbginfo are passed via this struct */
  79 typedef struct cc65_parseerror cc65_parseerror;
  80 struct cc65_parseerror {
  81     cc65_error_severity type;           /* Type of error */
  82     const char*         name;           /* Name of input file */
  83     cc65_line           line;           /* Error line */
  84     unsigned            column;         /* Error column */
  85     char                errormsg[1];    /* Error message */
  86 };
  87
  88 /* Function that is called in case of parse errors */
  89 typedef void (*cc65_errorfunc) (const cc65_parseerror*);
  90
  91 /* Pointer to an opaque data structure containing information from the debug
  92  * info file. Actually a handle to the data in the file.
  93  */
  94 typedef const void* cc65_dbginfo;
  95
  96
  97
  98 cc65_dbginfo cc65_read_dbginfo (const char* filename, cc65_errorfunc errorfunc);
  99 /* Parse the debug info file with the given name. On success, the function
 100  * will return a pointer to an opaque cc65_dbginfo structure, that must be
 101  * passed to the other functions in this module to retrieve information.
 102  * errorfunc is called in case of warnings and errors. If the file cannot be
 103  * read successfully, NULL is returned.
 104  */
 105
 106 void cc65_free_dbginfo (cc65_dbginfo Handle);
 107 /* Free debug information read from a file */
 108
 109
 110
 111 /*****************************************************************************/
 112 /*                                 C Symbols                                 */
 113 /*****************************************************************************/
 114
 115
 116
 117 /* C symbol kinds */
 118 typedef enum {
 119     CC65_CSYM_FUNC,
 120     CC65_CSYM_VAR
 121 } cc65_csym_kind;
 122
 123 /* C object storage classes */
 124 typedef enum {
 125     CC65_CSYM_AUTO,             /* Auto = on stack */
 126     CC65_CSYM_REG,              /* Register = in register bank */
 127     CC65_CSYM_STATIC,           /* Static = static storage */
 128     CC65_CSYM_EXTERN            /* Extern = static storage + external visibility */
 129 } cc65_csym_sc;
 130
 131 /* C symbol information */
 132 typedef struct cc65_csymdata cc65_csymdata;
 133 struct cc65_csymdata {
 134     unsigned            csym_id;        /* The internal c symbol id */
 135     unsigned char       csym_kind;      /* Kind of c symbol */
 136     unsigned char       csym_sc;        /* Storage class of c symbol */
 137     int                 csym_offs;      /* Offset for auto and register */
 138     unsigned            symbol_id;      /* Attached asm symbol if any */
 139     unsigned            scope_id;       /* Scope of c symbol */
 140     const char*         csym_name;      /* Name of the symbol */
 141 };
 142
 143 typedef struct cc65_csyminfo cc65_csyminfo;
 144 struct cc65_csyminfo {
 145     unsigned            count;          /* Number of data sets that follow */
 146     cc65_csymdata       data[1];        /* Data sets, number is dynamic */
 147 };
 148
 149
 150
 151 const cc65_csyminfo* cc65_get_csymlist (cc65_dbginfo handle);
 152 /* Return a list of all c symbols */
 153
 154 const cc65_csyminfo* cc65_csym_byid (cc65_dbginfo handle, unsigned id);
 155 /* Return information about a c symbol with a specific id. The function
 156  * returns NULL if the id is invalid (no such c symbol) and otherwise a
 157  * cc65_csyminfo structure with one entry that contains the requested
 158  * symbol information.
 159  */
 160
 161 const cc65_csyminfo* cc65_cfunc_bymodule (cc65_dbginfo handle, unsigned module_id);
 162 /* Return the list of C functions (not symbols!) for a specific module. If
 163  * the module id is invalid, the function will return NULL, otherwise a
 164  * (possibly empty) c symbol list.
 165  */
 166
 167 const cc65_csyminfo* cc65_cfunc_byname (cc65_dbginfo handle, const char* name);
 168 /* Return a list of all C functions with the given name that have a
 169  * definition.
 170  */
 171
 172 const cc65_csyminfo* cc65_csym_byscope (cc65_dbginfo handle, unsigned scope_id);
 173 /* Return all C symbols for a scope. The function will return NULL if the
 174  * given id is invalid.
 175  */
 176
 177 void cc65_free_csyminfo (cc65_dbginfo handle, const cc65_csyminfo* info);
 178 /* Free a c symbol info record */
 179
 180
 181
 182 /*****************************************************************************/
 183 /*                                 Libraries                                 */
 184 /*****************************************************************************/
 185
 186
 187
 188 /* Library information */
 189 typedef struct cc65_librarydata cc65_librarydata;
 190 struct cc65_librarydata {
 191     unsigned            library_id;     /* The internal library id */
 192     const char*         library_name;   /* Name of the library */
 193 };
 194
 195 typedef struct cc65_libraryinfo cc65_libraryinfo;
 196 struct cc65_libraryinfo {
 197     unsigned            count;          /* Number of data sets that follow */
 198     cc65_librarydata    data[1];        /* Data sets, number is dynamic */
 199 };
 200
 201
 202
 203 const cc65_libraryinfo* cc65_get_librarylist (cc65_dbginfo handle);
 204 /* Return a list of all libraries */
 205
 206 const cc65_libraryinfo* cc65_library_byid (cc65_dbginfo handle, unsigned id);
 207 /* Return information about a library with a specific id. The function
 208  * returns NULL if the id is invalid (no such library) and otherwise a
 209  * cc65_libraryinfo structure with one entry that contains the requested
 210  * library information.
 211  */
 212
 213 void cc65_free_libraryinfo (cc65_dbginfo handle, const cc65_libraryinfo* info);
 214 /* Free a library info record */
 215
 216
 217
 218 /*****************************************************************************/
 219 /*                                 Line info                                 */
 220 /*****************************************************************************/
 221
 222
 223
 224 /* Type of line */
 225 typedef enum {
 226     CC65_LINE_ASM,                      /* Assembler source */
 227     CC65_LINE_EXT,                      /* Externally supplied (= C) */
 228     CC65_LINE_MACRO,                    /* Macro expansion */
 229 } cc65_line_type;
 230
 231 /* Line information */
 232 typedef struct cc65_linedata cc65_linedata;
 233 struct cc65_linedata {
 234     unsigned            line_id;        /* Internal id of this record */
 235     unsigned            source_id;      /* Id of the source file */
 236     cc65_line           source_line;    /* Line number */
 237     cc65_line_type      line_type;      /* Type of line */
 238     unsigned            count;          /* Nesting counter for macros */
 239 };
 240
 241 typedef struct cc65_lineinfo cc65_lineinfo;
 242 struct cc65_lineinfo {
 243     unsigned            count;          /* Number of data sets that follow */
 244     cc65_linedata       data[1];        /* Data sets, number is dynamic */
 245 };
 246
 247
 248
 249 const cc65_lineinfo* cc65_line_byid (cc65_dbginfo handle, unsigned id);
 250 /* Return information about a line with a specific id. The function
 251  * returns NULL if the id is invalid (no such line) and otherwise a
 252  * cc65_lineinfo structure with one entry that contains the requested
 253  * module information.
 254  */
 255
 256 const cc65_lineinfo* cc65_line_bynumber (cc65_dbginfo handle,
 257                                          unsigned source_id,
 258                                          cc65_line line);
 259 /* Return line information for a source file/line number combination. The
 260  * function returns NULL if no line information was found.
 261  */
 262
 263 const cc65_lineinfo* cc65_line_bysource (cc65_dbginfo Handle, unsigned source_id);
 264 /* Return line information for a source file. The function returns NULL if the
 265  * file id is invalid.
 266  */
 267
 268 const cc65_lineinfo* cc65_line_bysymdef (cc65_dbginfo handle, unsigned symbol_id);
 269 /* Return line information for the definition of a symbol. The function
 270  * returns NULL if the symbol id is invalid, otherwise a list of line infos.
 271  */
 272
 273 const cc65_lineinfo* cc65_line_bysymref (cc65_dbginfo handle, unsigned symbol_id);
 274 /* Return line information for all references of a symbol. The function
 275  * returns NULL if the symbol id is invalid, otherwise a list of line infos.
 276  */
 277
 278 const cc65_lineinfo* cc65_line_byspan (cc65_dbginfo handle, unsigned span_id);
 279 /* Return line information for a a span. The function returns NULL if the
 280  * span id is invalid, otherwise a list of line infos.
 281  */
 282
 283 void cc65_free_lineinfo (cc65_dbginfo handle, const cc65_lineinfo* info);
 284 /* Free line info returned by one of the other functions */
 285
 286
 287
 288 /*****************************************************************************/
 289 /*                                  Modules                                  */
 290 /*****************************************************************************/
 291
 292
 293
 294 /* Module information
 295  * Notes:
 296  *   - scope_id contains CC65_INV_ID if the module was compiled without
 297  *     debug information.
 298  */
 299 typedef struct cc65_moduledata cc65_moduledata;
 300 struct cc65_moduledata {
 301     unsigned            module_id;      /* The internal module id */
 302     const char*         module_name;    /* Name of the module */
 303     unsigned            source_id;      /* Id of the module main file */
 304     unsigned            library_id;     /* Id of the library if any */
 305     unsigned            scope_id;       /* Id of the main scope */
 306 };
 307
 308 typedef struct cc65_moduleinfo cc65_moduleinfo;
 309 struct cc65_moduleinfo {
 310     unsigned            count;          /* Number of data sets that follow */
 311     cc65_moduledata     data[1];        /* Data sets, number is dynamic */
 312 };
 313
 314
 315
 316 const cc65_moduleinfo* cc65_get_modulelist (cc65_dbginfo handle);
 317 /* Return a list of all modules */
 318
 319 const cc65_moduleinfo* cc65_module_byid (cc65_dbginfo handle, unsigned id);
 320 /* Return information about a module with a specific id. The function
 321  * returns NULL if the id is invalid (no such module) and otherwise a
 322  * cc65_moduleinfo structure with one entry that contains the requested
 323  * module information.
 324  */
 325
 326 void cc65_free_moduleinfo (cc65_dbginfo handle, const cc65_moduleinfo* info);
 327 /* Free a module info record */
 328
 329
 330
 331 /*****************************************************************************/
 332 /*                                   Spans                                   */
 333 /*****************************************************************************/
 334
 335
 336
 337 /* Span information */
 338 typedef struct cc65_spandata cc65_spandata;
 339 struct cc65_spandata {
 340     unsigned            span_id;        /* The internal span id */
 341     cc65_addr           span_start;     /* Start of the span */
 342     cc65_addr           span_end;       /* End of the span (inclusive!) */
 343     unsigned            segment_id;     /* Id of the segment */
 344     unsigned            type_id;        /* Id of the type of this span */
 345     unsigned            line_count;     /* Number of lines attached */
 346     unsigned            scope_count;    /* Number of scopes attached */
 347 };
 348
 349 typedef struct cc65_spaninfo cc65_spaninfo;
 350 struct cc65_spaninfo {
 351     unsigned            count;          /* Number of data sets that follow */
 352     cc65_spandata       data[1];        /* Data sets, number is dynamic */
 353 };
 354
 355
 356
 357 const cc65_spaninfo* cc65_get_spanlist (cc65_dbginfo handle);
 358 /* Return a list of all spans. BEWARE: Large! */
 359
 360 const cc65_spaninfo* cc65_span_byid (cc65_dbginfo handle, unsigned id);
 361 /* Return information about a span with a specific id. The function
 362  * returns NULL if the id is invalid (no such span) and otherwise a
 363  * cc65_spaninfo structure with one entry that contains the requested
 364  * span information.
 365  */
 366
 367 const cc65_spaninfo* cc65_span_byaddr (cc65_dbginfo handle,
 368                                        unsigned long addr);
 369 /* Return span information for the given address. The function returns NULL
 370  * if no spans were found for this address.
 371  */
 372
 373 const cc65_spaninfo* cc65_span_byline (cc65_dbginfo handle, unsigned line_id);
 374 /* Return span information for the given source line. The function returns NULL
 375  * if the line id is invalid, otherwise the spans for this line (possibly zero).
 376  */
 377
 378 const cc65_spaninfo* cc65_span_byscope (cc65_dbginfo handle, unsigned scope_id);
 379 /* Return span information for the given scope. The function returns NULL if
 380  * the scope id is invalid, otherwise the spans for this scope (possibly zero).
 381  */
 382
 383 void cc65_free_spaninfo (cc65_dbginfo handle, const cc65_spaninfo* info);
 384 /* Free a span info record */
 385
 386
 387
 388 /*****************************************************************************/
 389 /*                               Source files                                */
 390 /*****************************************************************************/
 391
 392
 393
 394 /* Source file information */
 395 typedef struct cc65_sourcedata cc65_sourcedata;
 396 struct cc65_sourcedata {
 397     unsigned            source_id;      /* The internal file id */
 398     const char*         source_name;    /* Name of the file */
 399     unsigned long       source_size;    /* Size of file */
 400     unsigned long       source_mtime;   /* Modification time */
 401 };
 402
 403 typedef struct cc65_sourceinfo cc65_sourceinfo;
 404 struct cc65_sourceinfo {
 405     unsigned            count;          /* Number of data sets that follow */
 406     cc65_sourcedata     data[1];        /* Data sets, number is dynamic */
 407 };
 408
 409
 410
 411 const cc65_sourceinfo* cc65_get_sourcelist (cc65_dbginfo handle);
 412 /* Return a list of all source files */
 413
 414 const cc65_sourceinfo* cc65_source_byid (cc65_dbginfo handle, unsigned id);
 415 /* Return information about a source file with a specific id. The function
 416  * returns NULL if the id is invalid (no such source file) and otherwise a
 417  * cc65_sourceinfo structure with one entry that contains the requested
 418  * source file information.
 419  */
 420
 421 const cc65_sourceinfo* cc65_source_bymodule (cc65_dbginfo handle,
 422                                              unsigned module_id);
 423 /* Return information about the source files used to build a module. The
 424  * function returns NULL if the module id is invalid (no such module) and
 425  * otherwise a cc65_sourceinfo structure with one entry per source file.
 426  */
 427
 428 void cc65_free_sourceinfo (cc65_dbginfo handle, const cc65_sourceinfo* info);
 429 /* Free a source info record */
 430
 431
 432
 433 /*****************************************************************************/
 434 /*                                  Scopes                                   */
 435 /*****************************************************************************/
 436
 437
 438
 439 /* Scope information */
 440 typedef enum {
 441     CC65_SCOPE_GLOBAL,                  /* Global scope */
 442     CC65_SCOPE_MODULE,                  /* Module scope */
 443     CC65_SCOPE_SCOPE,                   /* .PROC/.SCOPE */
 444     CC65_SCOPE_STRUCT,                  /* .STRUCT */
 445     CC65_SCOPE_ENUM,                    /* .ENUM */
 446 } cc65_scope_type;
 447
 448 typedef struct cc65_scopedata cc65_scopedata;
 449 struct cc65_scopedata {
 450     unsigned            scope_id;       /* Id of scope */
 451     const char*         scope_name;     /* Name of scope */
 452     cc65_scope_type     scope_type;     /* Type of scope */
 453     cc65_size           scope_size;     /* Size of scope, 0 if unknown */
 454     unsigned            parent_id;      /* Id of parent scope */
 455     unsigned            symbol_id;      /* Id of scope symbol if any */
 456     unsigned            module_id;      /* Id of the module */
 457 };
 458
 459 typedef struct cc65_scopeinfo cc65_scopeinfo;
 460 struct cc65_scopeinfo {
 461     unsigned            count;          /* Number of data sets that follow */
 462     cc65_scopedata      data[1];        /* Data sets, number is dynamic */
 463 };
 464
 465
 466
 467 const cc65_scopeinfo* cc65_get_scopelist (cc65_dbginfo handle);
 468 /* Return a list of all scopes in the debug information */
 469
 470 const cc65_scopeinfo* cc65_scope_byid (cc65_dbginfo handle, unsigned id);
 471 /* Return the scope with a given id. The function returns NULL if no scope
 472  * with this id was found.
 473  */
 474
 475 const cc65_scopeinfo* cc65_scope_bymodule (cc65_dbginfo handle, unsigned module_id);
 476 /* Return the list of scopes for one module. The function returns NULL if no
 477  * scope with the given id was found.
 478  */
 479
 480 const cc65_scopeinfo* cc65_scope_byname (cc65_dbginfo handle, const char* name);
 481 /* Return the list of scopes with a given name. Returns NULL if no scope with
 482  * the given name was found, otherwise a non empty scope list.
 483  */
 484
 485 const cc65_scopeinfo* cc65_scope_byspan (cc65_dbginfo handle, unsigned span_id);
 486 /* Return scope information for a a span. The function returns NULL if the
 487  * span id is invalid, otherwise a list of line scopes.
 488  */
 489
 490 const cc65_scopeinfo* cc65_childscopes_byid (cc65_dbginfo handle, unsigned id);
 491 /* Return the direct child scopes of a scope with a given id. The function
 492  * returns NULL if no scope with this id was found, otherwise a list of the
 493  * direct childs.
 494  */
 495
 496 void cc65_free_scopeinfo (cc65_dbginfo Handle, const cc65_scopeinfo* Info);
 497 /* Free a scope info record */
 498
 499
 500
 501 /*****************************************************************************/
 502 /*                                 Segments                                  */
 503 /*****************************************************************************/
 504
 505
 506
 507 /* Segment information.
 508  * Notes:
 509  *   - output_name may be NULL if the data wasn't written to the output file
 510  *     (example: bss segment)
 511  *   - output_offs is invalid if there is no output_name, and may not be of
 512  *     much use in case of a relocatable output file
 513  */
 514 typedef struct cc65_segmentdata cc65_segmentdata;
 515 struct cc65_segmentdata {
 516     unsigned            segment_id;     /* The internal segment id */
 517     const char*         segment_name;   /* Name of the segment */
 518     cc65_addr           segment_start;  /* Start address of segment */
 519     cc65_size           segment_size;   /* Size of segment */
 520     const char*         output_name;    /* Output file this seg was written to */
 521     unsigned long       output_offs;    /* Offset of this seg in output file */
 522 };
 523
 524 typedef struct cc65_segmentinfo cc65_segmentinfo;
 525 struct cc65_segmentinfo {
 526     unsigned            count;          /* Number of data sets that follow */
 527     cc65_segmentdata    data[1];        /* Data sets, number is dynamic */
 528 };
 529
 530
 531
 532 const cc65_segmentinfo* cc65_get_segmentlist (cc65_dbginfo handle);
 533 /* Return a list of all segments referenced in the debug information */
 534
 535 const cc65_segmentinfo* cc65_segment_byid (cc65_dbginfo handle, unsigned id);
 536 /* Return information about a segment with a specific id. The function returns
 537  * NULL if the id is invalid (no such segment) and otherwise a cc65_segmentinfo
 538  * structure with one entry that contains the requested segment information.
 539  */
 540
 541 const cc65_segmentinfo* cc65_segment_byname (cc65_dbginfo handle,
 542                                              const char* name);
 543 /* Return information about a segment with a specific name. The function
 544  * returns NULL if no segment with this name exists and otherwise a
 545  * cc65_segmentinfo structure with one entry that contains the requested
 546  * information.
 547  */
 548
 549 void cc65_free_segmentinfo (cc65_dbginfo handle, const cc65_segmentinfo* info);
 550 /* Free a segment info record */
 551
 552
 553
 554 /*****************************************************************************/
 555 /*                                  Symbols                                  */
 556 /*****************************************************************************/
 557
 558
 559
 560 /* Symbol information */
 561 typedef enum {
 562     CC65_SYM_EQUATE,
 563     CC65_SYM_LABEL,                     /* Some sort of address */
 564     CC65_SYM_IMPORT,                    /* An import */
 565 } cc65_symbol_type;
 566
 567 /* Notes:
 568  *  - If the symbol is segment relative, the segment id gives segment
 569  *    information, otherwise it contains CC65_INV_ID.
 570  *  - If the type is CC65_SYM_IMPORT, export_id may contain the id of the
 571  *    export. This is not the case if the module contaiing the export doesn't
 572  *    have debug information.
 573  *  - For an import, the fields symbol_value and segment_id are taken from
 574  *    the export, if it is available, since imports have no value or segments
 575  *    by itself.
 576  *  - For an import symbol_size doesn't have a meaning.
 577  *  - For normal symbols (not cheap locals) parent_id contains CC65_INV_ID,
 578  *    for cheap locals it contains the symbol id of the parent symbol.
 579  */
 580 typedef struct cc65_symboldata cc65_symboldata;
 581 struct cc65_symboldata {
 582     unsigned            symbol_id;      /* Id of symbol */
 583     const char*         symbol_name;    /* Name of symbol */
 584     cc65_symbol_type    symbol_type;    /* Type of symbol */
 585     cc65_size           symbol_size;    /* Size of symbol, 0 if unknown */
 586     long                symbol_value;   /* Value of symbol */
 587     unsigned            export_id;      /* For imports: Matching export */
 588     unsigned            segment_id;     /* Id of segment if any */
 589     unsigned            scope_id;       /* The scope this symbol is in */
 590     unsigned            parent_id;      /* Parent symbol for cheap locals */
 591 };
 592
 593 typedef struct cc65_symbolinfo cc65_symbolinfo;
 594 struct cc65_symbolinfo {
 595     unsigned            count;          /* Number of data sets that follow */
 596     cc65_symboldata     data[1];        /* Data sets, number is dynamic */
 597 };
 598
 599
 600
 601 const cc65_symbolinfo* cc65_symbol_byid (cc65_dbginfo handle, unsigned id);
 602 /* Return the symbol with a given id. The function returns NULL if no symbol
 603  * with this id was found.
 604  */
 605
 606 const cc65_symbolinfo* cc65_symbol_byname (cc65_dbginfo handle, const char* name);
 607 /* Return a list of symbols with a given name. The function returns NULL if
 608  * no symbol with this name was found.
 609  */
 610
 611 const cc65_symbolinfo* cc65_symbol_byscope (cc65_dbginfo handle,
 612                                             unsigned scope_id);
 613 /* Return a list of symbols in the given scope. This includes cheap local
 614  * symbols, but not symbols in subscopes. The function returns NULL if the
 615  * scope id is invalid (no such scope) and otherwise a - possibly empty -
 616  * symbol list.
 617  */
 618
 619 const cc65_symbolinfo* cc65_symbol_inrange (cc65_dbginfo handle,
 620                                             cc65_addr start, cc65_addr end);
 621 /* Return a list of labels in the given range. end is inclusive. The function
 622  * return NULL if no symbols within the given range are found. Non label
 623  * symbols are ignored and not returned.
 624  */
 625
 626 void cc65_free_symbolinfo (cc65_dbginfo handle, const cc65_symbolinfo* info);
 627 /* Free a symbol info record */
 628
 629
 630
 631 /*****************************************************************************/
 632 /*                                   Types                                   */
 633 /*****************************************************************************/
 634
 635
 636
 637 /* Type information */
 638 typedef enum {
 639     CC65_TYPE_VOID,
 640     CC65_TYPE_BYTE,
 641     CC65_TYPE_WORD,
 642     CC65_TYPE_DBYTE,
 643     CC65_TYPE_DWORD,
 644     CC65_TYPE_PTR,
 645     CC65_TYPE_FARPTR,
 646     CC65_TYPE_ARRAY,
 647
 648     /* The following ones are currently unavailable: */
 649     CC65_TYPE_UNION,
 650     CC65_TYPE_STRUCT,
 651     CC65_TYPE_FUNC,
 652 } cc65_typetoken;
 653
 654
 655 /* A type is a linked list of typedata structures. In case of arrays, the
 656  * structure will contain an element count and the element type. In case of
 657  * pointers, the structure will contain the type of the data, the pointer
 658  * points to (currently, there are only VOID pointers).
 659  * The next pointer points to the next entry in the list. It is NULL if the
 660  * end of the list is reached.
 661  */
 662 typedef struct cc65_typedata cc65_typedata;
 663 struct cc65_typedata {
 664     cc65_typedata*                next;         /* Pointer to next entry */
 665     cc65_typetoken                what;         /* What kind of type is it? */
 666     cc65_size                     size;         /* The size of the data */
 667
 668     /* Depending on "what", one of the members of this union follows */
 669     union {
 670
 671         /* In case of CC65_TYPE_PTR or CC65_TYPE_FARPTR */
 672         struct {
 673             const cc65_typedata*  ind_type;     /* Type the pointer points to */
 674         } ptr;
 675
 676         /* In case of CC65_TYPE_ARRAY */
 677         struct {
 678             cc65_size             ele_count;    /* Element count */
 679             const cc65_typedata*  ele_type;     /* Element type */
 680         } array;
 681
 682     } data;
 683 };
 684
 685
 686
 687 const cc65_typedata* cc65_type_byid (cc65_dbginfo handle, unsigned id);
 688 /* Return the data for the type with the given id. The function returns NULL
 689  * if no type with this id was found.
 690  */
 691
 692 void cc65_free_typedata (cc65_dbginfo Handle, const cc65_typedata* data);
 693 /* Free a symbol info record */
 694
 695
 696
 697 /* Allow usage from C++ */
 698 #ifdef __cplusplus
 699 }
 700 #endif
 701
 702
 703
 704 /* End of dbginfo.h */
 705 #endif
 706
 707
 708