RCS/astnode.h,v

   1 head    1.14;
   2 access;
   3 symbols;
   4 locks; strict;
   5 comment @ * @;
   6
   7
   8 1.14
   9 date    2007.08.12.18.59.10;    author khansen; state Exp;
  10 branches;
  11 next    1.13;
  12
  13 1.13
  14 date    2007.08.09.22.06.00;    author khansen; state Exp;
  15 branches;
  16 next    1.12;
  17
  18 1.12
  19 date    2007.08.07.21.12.16;    author khansen; state Exp;
  20 branches;
  21 next    1.11;
  22
  23 1.11
  24 date    2007.07.22.13.35.20;    author khansen; state Exp;
  25 branches;
  26 next    1.10;
  27
  28 1.10
  29 date    2004.12.29.21.44.23;    author kenth;   state Exp;
  30 branches;
  31 next    1.9;
  32
  33 1.9
  34 date    2004.12.19.20.46.49;    author kenth;   state Exp;
  35 branches;
  36 next    1.8;
  37
  38 1.8
  39 date    2004.12.19.09.53.56;    author kenth;   state Exp;
  40 branches;
  41 next    1.7;
  42
  43 1.7
  44 date    2004.12.18.16.56.55;    author kenth;   state Exp;
  45 branches;
  46 next    1.6;
  47
  48 1.6
  49 date    2004.12.16.13.19.28;    author kenth;   state Exp;
  50 branches;
  51 next    1.5;
  52
  53 1.5
  54 date    2004.12.14.01.51.22;    author kenth;   state Exp;
  55 branches;
  56 next    1.4;
  57
  58 1.4
  59 date    2004.12.11.02.01.44;    author kenth;   state Exp;
  60 branches;
  61 next    1.3;
  62
  63 1.3
  64 date    2004.12.09.11.17.41;    author kenth;   state Exp;
  65 branches;
  66 next    1.2;
  67
  68 1.2
  69 date    2004.12.06.04.54.00;    author kenth;   state Exp;
  70 branches;
  71 next    1.1;
  72
  73 1.1
  74 date    2004.06.30.07.56.09;    author kenth;   state Exp;
  75 branches;
  76 next    ;
  77
  78
  79 desc
  80 @@
  81
  82
  83 1.14
  84 log
  85 @ability to generate pure 6502 binary
  86 @
  87 text
  88 @/*
  89  * $Id: astnode.h,v 1.13 2007/08/09 22:06:00 khansen Exp khansen $
  90  * $Log: astnode.h,v $
  91  * Revision 1.13  2007/08/09 22:06:00  khansen
  92  * general-purpose flags
  93  *
  94  * Revision 1.12  2007/08/07 21:12:16  khansen
  95  * const
  96  *
  97  * Revision 1.11  2007/07/22 13:35:20  khansen
  98  * convert tabs to whitespaces
  99  *
 100  * Revision 1.10  2004/12/29 21:44:23  kenth
 101  * xorcyst 1.4.2
 102  * added create_index()
 103  *
 104  * Revision 1.9  2004/12/19 20:46:49  kenth
 105  * xorcyst 1.4.0
 106  *
 107  * Revision 1.8  2004/12/19 09:53:56  kenth
 108  * added create_align()
 109  *
 110  * Revision 1.7  2004/12/18 16:56:55  kenth
 111  * create_extrn() takes unit id
 112  *
 113  * Revision 1.6  2004/12/16 13:19:28  kenth
 114  * changed astnode_create_label() signature
 115  *
 116  * Revision 1.5  2004/12/14 01:51:22  kenth
 117  * xorcyst 1.3.0
 118  *
 119  * Revision 1.4  2004/12/11 02:01:44  kenth
 120  * added forward/backward branching
 121  *
 122  * Revision 1.3  2004/12/09 11:17:41  kenth
 123  * added: warning, error nodes
 124  *
 125  * Revision 1.2  2004/12/06 04:54:00  kenth
 126  * xorcyst 1.1.0
 127  *
 128  * Revision 1.1  2004/06/30 07:56:09  kenth
 129  * Initial revision
 130  *
 131  */
 132
 133 /**
 134  *    (C) 2004 Kent Hansen
 135  *
 136  *    The XORcyst is free software; you can redistribute it and/or modify
 137  *    it under the terms of the GNU General Public License as published by
 138  *    the Free Software Foundation; either version 2 of the License, or
 139  *    (at your option) any later version.
 140  *
 141  *    The XORcyst is distributed in the hope that it will be useful,
 142  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 143  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 144  *    GNU General Public License for more details.
 145  *
 146  *    You should have received a copy of the GNU General Public License
 147  *    along with The XORcyst; if not, write to the Free Software
 148  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 149  */
 150
 151 /**
 152  * Header file with definitions for Abstract Syntax Tree (AST) nodes.
 153  */
 154 #ifndef ASTNODE_H
 155 #define ASTNODE_H
 156
 157 #include "loc.h"
 158
 159 #define LHS(e) astnode_get_child(e, 0)
 160 #define RHS(e) astnode_get_child(e, 1)
 161
 162 /**
 163  * The possible addressing modes for a parsed instruction.
 164  * Note that there is not a 1:1 correspondence between these and
 165  * the "real" 6502 addressing modes. Specifically, the parser doesn't
 166  * distinguish between absolute and relative mode, or between
 167  * 8-bit (zeropage) absolute addressing and 16-bit addressing.
 168  * That's for the code generator to figure out.
 169  */
 170 enum tag_addressing_mode {
 171     IMPLIED_MODE=0,
 172     ACCUMULATOR_MODE,
 173     IMMEDIATE_MODE,
 174     ZEROPAGE_MODE,
 175     ZEROPAGE_X_MODE,
 176     ZEROPAGE_Y_MODE,
 177     ABSOLUTE_MODE,
 178     ABSOLUTE_X_MODE,
 179     ABSOLUTE_Y_MODE,
 180     PREINDEXED_INDIRECT_MODE,
 181     POSTINDEXED_INDIRECT_MODE,
 182     INDIRECT_MODE,
 183     RELATIVE_MODE
 184 };
 185
 186 typedef enum tag_addressing_mode addressing_mode;
 187
 188 /**
 189  * The possible instruction mnemonics.
 190  */
 191 enum tag_instr_mnemonic {
 192     ADC_MNEMONIC=0,
 193     AND_MNEMONIC,
 194     ASL_MNEMONIC,
 195     BCC_MNEMONIC,
 196     BCS_MNEMONIC,
 197     BEQ_MNEMONIC,
 198     BIT_MNEMONIC,
 199     BMI_MNEMONIC,
 200     BNE_MNEMONIC,
 201     BPL_MNEMONIC,
 202     BRK_MNEMONIC,
 203     BVC_MNEMONIC,
 204     BVS_MNEMONIC,
 205     CLC_MNEMONIC,
 206     CLD_MNEMONIC,
 207     CLI_MNEMONIC,
 208     CLV_MNEMONIC,
 209     CMP_MNEMONIC,
 210     CPX_MNEMONIC,
 211     CPY_MNEMONIC,
 212     DEC_MNEMONIC,
 213     DEX_MNEMONIC,
 214     DEY_MNEMONIC,
 215     EOR_MNEMONIC,
 216     INC_MNEMONIC,
 217     INX_MNEMONIC,
 218     INY_MNEMONIC,
 219     JMP_MNEMONIC,
 220     JSR_MNEMONIC,
 221     LDA_MNEMONIC,
 222     LDX_MNEMONIC,
 223     LDY_MNEMONIC,
 224     LSR_MNEMONIC,
 225     NOP_MNEMONIC,
 226     ORA_MNEMONIC,
 227     PHA_MNEMONIC,
 228     PHP_MNEMONIC,
 229     PLA_MNEMONIC,
 230     PLP_MNEMONIC,
 231     ROL_MNEMONIC,
 232     ROR_MNEMONIC,
 233     RTI_MNEMONIC,
 234     RTS_MNEMONIC,
 235     SBC_MNEMONIC,
 236     SEC_MNEMONIC,
 237     SED_MNEMONIC,
 238     SEI_MNEMONIC,
 239     STA_MNEMONIC,
 240     STX_MNEMONIC,
 241     STY_MNEMONIC,
 242     TAX_MNEMONIC,
 243     TAY_MNEMONIC,
 244     TSX_MNEMONIC,
 245     TXA_MNEMONIC,
 246     TXS_MNEMONIC,
 247     TYA_MNEMONIC
 248 };
 249
 250 typedef enum tag_instr_mnemonic instr_mnemonic;
 251
 252 /**
 253  * The possible types of a node in the abstract syntax tree.
 254  */
 255 enum tag_astnode_type {
 256     NULL_NODE=0,
 257     INTEGER_NODE,
 258     STRING_NODE,
 259     IDENTIFIER_NODE,
 260     DATA_NODE,
 261     STORAGE_NODE,
 262     MACRO_DECL_NODE,
 263     MACRO_NODE,
 264     ARITHMETIC_NODE,
 265     IF_NODE,
 266     CASE_NODE,
 267     DEFAULT_NODE,
 268     IFDEF_NODE,
 269     IFNDEF_NODE,
 270     INCSRC_NODE,
 271     INCBIN_NODE,
 272     EQU_NODE,
 273     ASSIGN_NODE,
 274     ALIGN_NODE,
 275     INSTRUCTION_NODE,
 276     FILE_PATH_NODE,
 277     CURRENT_PC_NODE,
 278     LIST_NODE,
 279     LABEL_NODE,
 280     LOCAL_LABEL_NODE,
 281     LOCAL_ID_NODE,
 282     BINARY_NODE,
 283     PUBLIC_NODE,
 284     EXTRN_NODE,
 285     DATASEG_NODE,
 286     CODESEG_NODE,
 287     CHARMAP_NODE,
 288     STRUC_NODE,
 289     STRUC_DECL_NODE,
 290     UNION_DECL_NODE,
 291     ENUM_DECL_NODE,
 292     RECORD_DECL_NODE,
 293     BITFIELD_DECL_NODE,
 294     DOT_NODE,
 295     SIZEOF_NODE,
 296     DATATYPE_NODE,
 297     VAR_DECL_NODE,
 298     SCOPE_NODE,
 299     PROC_NODE,
 300     REPT_NODE,
 301     WHILE_NODE,
 302     MESSAGE_NODE,
 303     WARNING_NODE,
 304     ERROR_NODE,
 305     FORWARD_BRANCH_DECL_NODE,
 306     BACKWARD_BRANCH_DECL_NODE,
 307     FORWARD_BRANCH_NODE,
 308     BACKWARD_BRANCH_NODE,
 309     MASK_NODE,
 310     INDEX_NODE,
 311     ORG_NODE,
 312     TOMBSTONE_NODE
 313 };
 314
 315 typedef enum tag_astnode_type astnode_type;
 316
 317 /**
 318  * The possible data types.
 319  */
 320 enum tag_datatype {
 321     BYTE_DATATYPE = 0,
 322     CHAR_DATATYPE,
 323     WORD_DATATYPE,
 324     DWORD_DATATYPE,
 325     USER_DATATYPE   /* i.e. structure, union, enumeration, ... */
 326 };
 327
 328 typedef enum tag_datatype datatype;
 329
 330 /**
 331  * The possible types of operators for an ARITHMETIC_NODE.
 332  */
 333 enum tag_arithmetic_operator {
 334     PLUS_OPERATOR=0,
 335     MINUS_OPERATOR,
 336     MUL_OPERATOR,
 337     DIV_OPERATOR,
 338     MOD_OPERATOR,
 339     AND_OPERATOR,
 340     OR_OPERATOR,
 341     XOR_OPERATOR,
 342     SHL_OPERATOR,
 343     SHR_OPERATOR,
 344     LT_OPERATOR,
 345     GT_OPERATOR,
 346     EQ_OPERATOR,
 347     NE_OPERATOR,
 348     LE_OPERATOR,
 349     GE_OPERATOR,
 350     NEG_OPERATOR,
 351     NOT_OPERATOR,
 352     LO_OPERATOR,
 353     HI_OPERATOR,
 354     UMINUS_OPERATOR,
 355     BANK_OPERATOR
 356 };
 357
 358 typedef enum tag_arithmetic_operator arithmetic_operator;
 359
 360 /**
 361  * Instruction attributes.
 362  */
 363 struct tag_instruction_attribs {
 364     int mnemonic;
 365     addressing_mode mode;
 366     unsigned char opcode;
 367 };
 368
 369 typedef struct tag_instruction_attribs instruction_attribs;
 370
 371 /**
 372  * Binary (byte buffer) attributes.
 373  */
 374 struct tag_binary_attribs {
 375     unsigned char *data;
 376     int size;
 377 };
 378
 379 typedef struct tag_binary_attribs binary_attribs;
 380
 381 /**
 382  * Structure that defines content of a node in the abstract syntax tree.
 383  */
 384 struct tag_astnode {
 385     astnode_type type;
 386     union {
 387         int integer;    /* type == INTEGER_NODE */
 388         char *string;   /* type == STRING_NODE */
 389         char *ident;    /* type == IDENTIFIER_NODE */
 390         char *label;    /* type == LABEL_NODE */
 391         char *file_path;    /* type == FILE_PATH_NODE */
 392         binary_attribs binary;  /* type == BINARY_NODE */
 393         instruction_attribs instr;  /* type == INSTRUCTION_NODE */
 394         arithmetic_operator oper;   /* type == ARITHMETIC_NODE */
 395         datatype datatype;  /* type == DATATYPE_NODE */
 396         int modifiers;  /* type == DATASEG_NODE, VAR_DECL_NODE */
 397     /* The other node types have attributes stored as children,
 398     or can use this general-purpose field: */
 399         long param;
 400     };
 401     int flags;
 402     location loc;   /* File location where node was parsed */
 403     struct tag_astnode *prev_sibling;
 404     struct tag_astnode *next_sibling;
 405     struct tag_astnode *first_child;
 406     struct tag_astnode *parent;
 407 };
 408
 409 typedef struct tag_astnode astnode;
 410
 411 /**
 412  * Function prototypes.
 413  */
 414 astnode *astnode_create(astnode_type, location);
 415 void astnode_finalize(astnode *);
 416 void astnode_replace(astnode *, astnode *);
 417 void astnode_remove(astnode *);
 418 void astnode_insert_child(astnode *, astnode *, int);
 419 int astnode_remove_child(astnode *, astnode *);
 420 astnode *astnode_remove_child_at(astnode *, int);
 421 astnode *astnode_remove_children(astnode *);
 422 void astnode_add_sibling(astnode *, astnode *);
 423 void astnode_add_child(astnode *, astnode *);
 424 void astnode_add_children(astnode *, int, ...);
 425 astnode *astnode_get_child(const astnode *, int);
 426 astnode *astnode_get_first_child(const astnode *);
 427 int astnode_get_child_count(const astnode *);
 428 astnode *astnode_get_parent(const astnode *);
 429 astnode *astnode_get_ancestor(const astnode *, int);
 430 int astnode_has_ancestor_of_type(const astnode *, astnode_type);
 431 int astnode_get_child_index(const astnode *, const astnode *);
 432 astnode *astnode_get_last_sibling(const astnode *);
 433 astnode_type astnode_get_type(const astnode *);
 434 astnode *astnode_get_next_sibling(const astnode *);
 435 astnode *astnode_get_prev_sibling(const astnode *);
 436 void astnode_print(const astnode *, int);
 437 astnode *astnode_clone(const astnode *, location);
 438 //void astnode_serialize(astnode *, FILE *);
 439 //astnode *astnode_deserialize(FILE *);
 440 int astnode_equal(const astnode *, const astnode *);
 441 int astnode_is_literal(const astnode *);
 442 const char *astnode_type_to_string(astnode_type);
 443 #define astnode_is_type(n, t) (astnode_get_type(n) == (t))
 444
 445 astnode *astnode_create_null(location);
 446 astnode *astnode_create_instruction(int, addressing_mode, astnode *, location);
 447 astnode *astnode_create_identifier(const char *, location);
 448 astnode *astnode_create_integer(int, location);
 449 astnode *astnode_create_string(const char *, location);
 450 astnode *astnode_create_file_path(const char *, location);
 451 astnode *astnode_create_arithmetic(arithmetic_operator, astnode *, astnode *, location);
 452 astnode *astnode_create_if(astnode *, astnode *, astnode *, astnode *, location);
 453 astnode *astnode_create_case(astnode *, astnode *, location);
 454 astnode *astnode_create_default(astnode *, location);
 455 astnode *astnode_create_ifdef(astnode *, astnode *, astnode *, location);
 456 astnode *astnode_create_ifndef(astnode *, astnode *, astnode *, location);
 457 astnode *astnode_create_macro_decl(astnode *, astnode *, astnode *, location);
 458 astnode *astnode_create_macro(astnode *, astnode *, location);
 459 astnode *astnode_create_equ(astnode *, astnode *, location);
 460 astnode *astnode_create_assign(astnode *, astnode *, location);
 461 astnode *astnode_create_incsrc(astnode *, location);
 462 astnode *astnode_create_incbin(astnode *, location);
 463 astnode *astnode_create_public(astnode *, location);
 464 astnode *astnode_create_extrn(astnode *, astnode *, astnode *, location);
 465 astnode *astnode_create_charmap(astnode *, location);
 466 astnode *astnode_create_struc(astnode *, location);
 467 astnode *astnode_create_struc_decl(astnode *, astnode *, location);
 468 astnode *astnode_create_union_decl(astnode *, astnode *, location);
 469 astnode *astnode_create_enum_decl(astnode *, astnode *, location);
 470 astnode *astnode_create_record_decl(astnode *, astnode *, location);
 471 astnode *astnode_create_bitfield_decl(astnode *, astnode *, location);
 472 astnode *astnode_create_dot(astnode *, astnode *, location);
 473 astnode *astnode_create_data(astnode *, astnode *, location);
 474 astnode *astnode_create_storage(astnode *, astnode *, location);
 475 astnode *astnode_create_dataseg(int, location);
 476 astnode *astnode_create_codeseg(location);
 477 astnode *astnode_create_pc(location);
 478 astnode *astnode_create_label(const char *, astnode *, astnode *, location);
 479 astnode *astnode_create_local_label(const char *, location);
 480 astnode *astnode_create_local_id(const char *, location);
 481 astnode *astnode_create_binary(unsigned char *, int, location);
 482 astnode *astnode_create_list(astnode *);
 483 astnode *astnode_create_sizeof(astnode *, location);
 484 astnode *astnode_create_datatype(datatype, astnode *, location);
 485 astnode *astnode_create_var_decl(int, astnode *, astnode *, location);
 486 astnode *astnode_create_scope(astnode *, astnode *, location);
 487 astnode *astnode_create_proc(astnode *, astnode *, location);
 488 astnode *astnode_create_rept(astnode *, astnode *, location);
 489 astnode *astnode_create_while(astnode *, astnode *, location);
 490 astnode *astnode_create_message(astnode *, location);
 491 astnode *astnode_create_warning(astnode *, location);
 492 astnode *astnode_create_error(astnode *, location);
 493 astnode *astnode_create_forward_branch_decl(const char *, location);
 494 astnode *astnode_create_backward_branch_decl(const char *, location);
 495 astnode *astnode_create_forward_branch(const char *, location);
 496 astnode *astnode_create_backward_branch(const char *, location);
 497 astnode *astnode_create_mask(astnode *, location);
 498 astnode *astnode_create_align(astnode *, astnode *, location);
 499 astnode *astnode_create_index(astnode *, astnode *, location);
 500 astnode *astnode_create_org(astnode *, location);
 501 astnode *astnode_create_tombstone(astnode_type type, location);
 502
 503 #endif  /* !ASTNODE_H */
 504 @
 505
 506
 507 1.13
 508 log
 509 @general-purpose flags
 510 @
 511 text
 512 @d2 1
 513 a2 1
 514  * $Id: astnode.h,v 1.12 2007/08/07 21:12:16 khansen Exp khansen $
 515 d4 3
 516 d224 1
 517 d413 1
 518 @
 519
 520
 521 1.12
 522 log
 523 @const
 524 @
 525 text
 526 @d2 1
 527 a2 1
 528  * $Id: astnode.h,v 1.11 2007/07/22 13:35:20 khansen Exp khansen $
 529 d4 3
 530 d310 1
 531 @
 532
 533
 534 1.11
 535 log
 536 @convert tabs to whitespaces
 537 @
 538 text
 539 @d2 1
 540 a2 1
 541  * $Id: astnode.h,v 1.10 2004/12/29 21:44:23 kenth Exp khansen $
 542 d4 3
 543 d330 13
 544 a342 13
 545 astnode *astnode_get_child(astnode *, int);
 546 astnode *astnode_get_first_child(astnode *);
 547 int astnode_get_child_count(astnode *);
 548 astnode *astnode_get_parent(astnode *);
 549 astnode *astnode_get_ancestor(astnode *, int);
 550 int astnode_has_ancestor_of_type(astnode *, astnode_type);
 551 int astnode_get_child_index(astnode *, astnode *);
 552 astnode *astnode_get_last_sibling(astnode *);
 553 astnode_type astnode_get_type(astnode *);
 554 astnode *astnode_get_next_sibling(astnode *);
 555 astnode *astnode_get_prev_sibling(astnode *);
 556 void astnode_print(astnode *, int);
 557 astnode *astnode_clone(astnode *, location);
 558 d345 2
 559 a346 2
 560 int astnode_equal(astnode *, astnode *);
 561 int astnode_is_literal(astnode *);
 562 d352 1
 563 a352 1
 564 astnode *astnode_create_identifier(char *, location);
 565 d354 2
 566 a355 2
 567 astnode *astnode_create_string(char *, location);
 568 astnode *astnode_create_file_path(char *, location);
 569 d383 3
 570 a385 3
 571 astnode *astnode_create_label(char *, astnode *, astnode *, location);
 572 astnode *astnode_create_local_label(char *, location);
 573 astnode *astnode_create_local_id(char *, location);
 574 d398 4
 575 a401 4
 576 astnode *astnode_create_forward_branch_decl(char *, location);
 577 astnode *astnode_create_backward_branch_decl(char *, location);
 578 astnode *astnode_create_forward_branch(char *, location);
 579 astnode *astnode_create_backward_branch(char *, location);
 580 @
 581
 582
 583 1.10
 584 log
 585 @xorcyst 1.4.2
 586 added create_index()
 587 @
 588 text
 589 @d2 1
 590 a2 1
 591  * $Id: astnode.h,v 1.9 2004/12/19 20:46:49 kenth Exp kenth $
 592 d4 4
 593 d75 13
 594 a87 13
 595         IMPLIED_MODE=0,
 596         ACCUMULATOR_MODE,
 597         IMMEDIATE_MODE,
 598         ZEROPAGE_MODE,
 599         ZEROPAGE_X_MODE,
 600         ZEROPAGE_Y_MODE,
 601         ABSOLUTE_MODE,
 602         ABSOLUTE_X_MODE,
 603         ABSOLUTE_Y_MODE,
 604         PREINDEXED_INDIRECT_MODE,
 605         POSTINDEXED_INDIRECT_MODE,
 606         INDIRECT_MODE,
 607         RELATIVE_MODE
 608 d96 56
 609 a151 56
 610         ADC_MNEMONIC=0,
 611         AND_MNEMONIC,
 612         ASL_MNEMONIC,
 613         BCC_MNEMONIC,
 614         BCS_MNEMONIC,
 615         BEQ_MNEMONIC,
 616         BIT_MNEMONIC,
 617         BMI_MNEMONIC,
 618         BNE_MNEMONIC,
 619         BPL_MNEMONIC,
 620         BRK_MNEMONIC,
 621         BVC_MNEMONIC,
 622         BVS_MNEMONIC,
 623         CLC_MNEMONIC,
 624         CLD_MNEMONIC,
 625         CLI_MNEMONIC,
 626         CLV_MNEMONIC,
 627         CMP_MNEMONIC,
 628         CPX_MNEMONIC,
 629         CPY_MNEMONIC,
 630         DEC_MNEMONIC,
 631         DEX_MNEMONIC,
 632         DEY_MNEMONIC,
 633         EOR_MNEMONIC,
 634         INC_MNEMONIC,
 635         INX_MNEMONIC,
 636         INY_MNEMONIC,
 637         JMP_MNEMONIC,
 638         JSR_MNEMONIC,
 639         LDA_MNEMONIC,
 640         LDX_MNEMONIC,
 641         LDY_MNEMONIC,
 642         LSR_MNEMONIC,
 643         NOP_MNEMONIC,
 644         ORA_MNEMONIC,
 645         PHA_MNEMONIC,
 646         PHP_MNEMONIC,
 647         PLA_MNEMONIC,
 648         PLP_MNEMONIC,
 649         ROL_MNEMONIC,
 650         ROR_MNEMONIC,
 651         RTI_MNEMONIC,
 652         RTS_MNEMONIC,
 653         SBC_MNEMONIC,
 654         SEC_MNEMONIC,
 655         SED_MNEMONIC,
 656         SEI_MNEMONIC,
 657         STA_MNEMONIC,
 658         STX_MNEMONIC,
 659         STY_MNEMONIC,
 660         TAX_MNEMONIC,
 661         TAY_MNEMONIC,
 662         TSX_MNEMONIC,
 663         TXA_MNEMONIC,
 664         TXS_MNEMONIC,
 665         TYA_MNEMONIC
 666 d160 56
 667 a215 56
 668         NULL_NODE=0,
 669         INTEGER_NODE,
 670         STRING_NODE,
 671         IDENTIFIER_NODE,
 672         DATA_NODE,
 673         STORAGE_NODE,
 674         MACRO_DECL_NODE,
 675         MACRO_NODE,
 676         ARITHMETIC_NODE,
 677         IF_NODE,
 678         CASE_NODE,
 679         DEFAULT_NODE,
 680         IFDEF_NODE,
 681         IFNDEF_NODE,
 682         INCSRC_NODE,
 683         INCBIN_NODE,
 684         EQU_NODE,
 685         ASSIGN_NODE,
 686         ALIGN_NODE,
 687         INSTRUCTION_NODE,
 688         FILE_PATH_NODE,
 689         CURRENT_PC_NODE,
 690         LIST_NODE,
 691         LABEL_NODE,
 692         LOCAL_LABEL_NODE,
 693         LOCAL_ID_NODE,
 694         BINARY_NODE,
 695         PUBLIC_NODE,
 696         EXTRN_NODE,
 697         DATASEG_NODE,
 698         CODESEG_NODE,
 699         CHARMAP_NODE,
 700         STRUC_NODE,
 701         STRUC_DECL_NODE,
 702         UNION_DECL_NODE,
 703         ENUM_DECL_NODE,
 704         RECORD_DECL_NODE,
 705         BITFIELD_DECL_NODE,
 706         DOT_NODE,
 707         SIZEOF_NODE,
 708         DATATYPE_NODE,
 709         VAR_DECL_NODE,
 710         SCOPE_NODE,
 711         PROC_NODE,
 712         REPT_NODE,
 713         WHILE_NODE,
 714         MESSAGE_NODE,
 715         WARNING_NODE,
 716         ERROR_NODE,
 717         FORWARD_BRANCH_DECL_NODE,
 718         BACKWARD_BRANCH_DECL_NODE,
 719         FORWARD_BRANCH_NODE,
 720         BACKWARD_BRANCH_NODE,
 721         MASK_NODE,
 722         INDEX_NODE,
 723         TOMBSTONE_NODE
 724 d224 5
 725 a228 5
 726         BYTE_DATATYPE = 0,
 727         CHAR_DATATYPE,
 728         WORD_DATATYPE,
 729         DWORD_DATATYPE,
 730         USER_DATATYPE   /* i.e. structure, union, enumeration, ... */
 731 d237 22
 732 a258 22
 733         PLUS_OPERATOR=0,
 734         MINUS_OPERATOR,
 735         MUL_OPERATOR,
 736         DIV_OPERATOR,
 737         MOD_OPERATOR,
 738         AND_OPERATOR,
 739         OR_OPERATOR,
 740         XOR_OPERATOR,
 741         SHL_OPERATOR,
 742         SHR_OPERATOR,
 743         LT_OPERATOR,
 744         GT_OPERATOR,
 745         EQ_OPERATOR,
 746         NE_OPERATOR,
 747         LE_OPERATOR,
 748         GE_OPERATOR,
 749         NEG_OPERATOR,
 750         NOT_OPERATOR,
 751         LO_OPERATOR,
 752         HI_OPERATOR,
 753         UMINUS_OPERATOR,
 754         BANK_OPERATOR
 755 d267 3
 756 a269 3
 757         int mnemonic;
 758         addressing_mode mode;
 759         unsigned char opcode;
 760 d278 2
 761 a279 2
 762         unsigned char *data;
 763         int size;
 764 d288 21
 765 a308 21
 766         astnode_type type;
 767         union {
 768                 int integer;    /* type == INTEGER_NODE */
 769                 char *string;   /* type == STRING_NODE */
 770                 char *ident;    /* type == IDENTIFIER_NODE */
 771                 char *label;    /* type == LABEL_NODE */
 772                 char *file_path;        /* type == FILE_PATH_NODE */
 773                 binary_attribs binary;  /* type == BINARY_NODE */
 774                 instruction_attribs instr;      /* type == INSTRUCTION_NODE */
 775                 arithmetic_operator oper;       /* type == ARITHMETIC_NODE */
 776                 datatype datatype;      /* type == DATATYPE_NODE */
 777                 int modifiers;  /* type == DATASEG_NODE, VAR_DECL_NODE */
 778         /* The other node types have attributes stored as children,
 779         or can use this general-purpose field: */
 780                 long param;
 781         };
 782         location loc;   /* File location where node was parsed */
 783         struct tag_astnode *prev_sibling;
 784         struct tag_astnode *next_sibling;
 785         struct tag_astnode *first_child;
 786         struct tag_astnode *parent;
 787 d404 1
 788 a404 1
 789 #endif  /* !ASTNODE_H */
 790 @
 791
 792
 793 1.9
 794 log
 795 @xorcyst 1.4.0
 796 @
 797 text
 798 @d2 1
 799 a2 1
 800  * $Id: astnode.h,v 1.8 2004/12/19 09:53:56 kenth Exp kenth $
 801 d4 3
 802 d210 1
 803 d397 1
 804 @
 805
 806
 807 1.8
 808 log
 809 @added create_align()
 810 @
 811 text
 812 @d2 1
 813 a2 1
 814  * $Id: astnode.h,v 1.7 2004/12/18 16:56:55 kenth Exp kenth $
 815 d4 3
 816 d291 1
 817 d369 1
 818 a369 1
 819 astnode *astnode_create_dataseg(location);
 820 d372 1
 821 a372 1
 822 astnode *astnode_create_label(char *, astnode *, location);
 823 d379 1
 824 a379 1
 825 astnode *astnode_create_var_decl(astnode *, astnode *, location);
 826 d392 1
 827 a392 1
 828 astnode *astnode_create_align(astnode *, location);
 829 @
 830
 831
 832 1.7
 833 log
 834 @create_extrn() takes unit id
 835 @
 836 text
 837 @d2 1
 838 a2 1
 839  * $Id: astnode.h,v 1.6 2004/12/16 13:19:28 kenth Exp kenth $
 840 d4 3
 841 d388 1
 842 @
 843
 844
 845 1.6
 846 log
 847 @changed astnode_create_label() signature
 848 @
 849 text
 850 @d2 1
 851 a2 1
 852  * $Id: astnode.h,v 1.5 2004/12/14 01:51:22 kenth Exp kenth $
 853 d4 3
 854 d351 1
 855 a351 1
 856 astnode *astnode_create_extrn(astnode *, astnode *, location);
 857 @
 858
 859
 860 1.5
 861 log
 862 @xorcyst 1.3.0
 863 @
 864 text
 865 @d2 1
 866 a2 1
 867  * $Id: astnode.h,v 1.4 2004/12/11 02:01:44 kenth Exp kenth $
 868 d4 3
 869 d362 1
 870 a362 1
 871 astnode *astnode_create_label(char *, location);
 872 @
 873
 874
 875 1.4
 876 log
 877 @added forward/backward branching
 878 @
 879 text
 880 @d2 1
 881 a2 1
 882  * $Id: astnode.h,v 1.3 2004/12/09 11:17:41 kenth Exp kenth $
 883 d4 3
 884 d151 2
 885 a152 1
 886         ELIF_NODE,
 887 d177 2
 888 d186 1
 889 d194 1
 890 d334 2
 891 a335 1
 892 astnode *astnode_create_elif(astnode *, astnode *, location);
 893 d351 2
 894 d370 1
 895 d378 1
 896 @
 897
 898
 899 1.3
 900 log
 901 @added: warning, error nodes
 902 @
 903 text
 904 @d2 1
 905 a2 1
 906  * $Id: astnode.h,v 1.2 2004/12/06 04:54:00 kenth Exp kenth $
 907 d4 3
 908 d183 4
 909 d362 4
 910 @
 911
 912
 913 1.2
 914 log
 915 @xorcyst 1.1.0
 916 @
 917 text
 918 @d2 1
 919 a2 1
 920  * $Id: astnode.h,v 1.1 2004/06/30 07:56:09 kenth Exp kenth $
 921 d4 3
 922 d178 2
 923 d353 2
 924 @
 925
 926
 927 1.1
 928 log
 929 @Initial revision
 930 @
 931 text
 932 @d2 5
 933 a6 2
 934  * $Id$
 935  * $Log$
 936 d35 3
 937 d163 13
 938 a175 1
 939         TOMBSTONE_NODE,
 940 d181 1
 941 a181 1
 942  * The possible types for a data node.
 943 d188 1
 944 a188 1
 945         QWORD_DATATYPE
 946 d258 1
 947 a258 1
 948                 int datatype;   /* type == DATA_NODE */
 949 d263 1
 950 a263 1
 951         location loc;
 952 d291 1
 953 d299 2
 954 a300 2
 955 void astnode_serialize(astnode *, FILE *);
 956 astnode *astnode_deserialize(FILE *);
 957 d303 2
 958 d306 1
 959 d324 1
 960 a324 1
 961 astnode *astnode_create_extrn(astnode *, location);
 962 d326 7
 963 a332 2
 964 astnode *astnode_create_data(int, astnode *, location);
 965 astnode *astnode_create_storage(int, astnode *, location);
 966 d341 7
 967 @