xasm.c

   1 /*
   2  * $Id: xasm.c,v 1.22 2007/11/11 22:35:22 khansen Exp $
   3  * $Log: xasm.c,v $
   4  * Revision 1.22  2007/11/11 22:35:22  khansen
   5  * compile on mac
   6  *
   7  * Revision 1.21  2007/08/19 11:18:56  khansen
   8  * --case-insensitive option
   9  *
  10  * Revision 1.20  2007/08/12 18:58:12  khansen
  11  * ability to generate pure 6502 binary (--pure-binary switch)
  12  *
  13  * Revision 1.19  2007/08/11 01:24:36  khansen
  14  * includepaths support (-I option)
  15  *
  16  * Revision 1.18  2007/08/10 20:21:02  khansen
  17  * *** empty log message ***
  18  *
  19  * Revision 1.17  2007/08/07 22:42:53  khansen
  20  * version
  21  *
  22  * Revision 1.16  2007/07/22 14:49:40  khansen
  23  * don't crash in change_extension()
  24  *
  25  * Revision 1.15  2007/07/22 13:33:26  khansen
  26  * convert tabs to whitespaces
  27  *
  28  * Revision 1.14  2005/01/09 11:19:23  kenth
  29  * xorcyst 1.4.5
  30  *
  31  * Revision 1.13  2005/01/05 09:37:32  kenth
  32  * xorcyst 1.4.4
  33  *
  34  * Revision 1.12  2005/01/05 01:52:13  kenth
  35  * xorcyst 1.4.3
  36  *
  37  * Revision 1.11  2005/01/04 21:35:10  kenth
  38  * return error code from main() when error count > 0
  39  *
  40  * Revision 1.10  2004/12/29 21:43:50  kenth
  41  * xorcyst 1.4.2
  42  *
  43  * Revision 1.9  2004/12/25 02:23:19  kenth
  44  * xorcyst 1.4.1
  45  *
  46  * Revision 1.8  2004/12/19 19:58:46  kenth
  47  * xorcyst 1.4.0
  48  *
  49  * Revision 1.7  2004/12/18 17:01:21  kenth
  50  * --debug switch, multiple verbose levels
  51  *
  52  * Revision 1.6  2004/12/16 13:20:35  kenth
  53  * xorcyst 1.3.5
  54  *
  55  * Revision 1.5  2004/12/14 01:50:12  kenth
  56  * xorcyst 1.3.0
  57  *
  58  * Revision 1.4  2004/12/11 02:06:27  kenth
  59  * xorcyst 1.2.0
  60  *
  61  * Revision 1.3  2004/12/06 04:53:02  kenth
  62  * xorcyst 1.1.0
  63  *
  64  * Revision 1.2  2004/06/30 23:37:54  kenth
  65  * replaced argp with something else
  66  *
  67  * Revision 1.1  2004/06/30 07:56:02  kenth
  68  * Initial revision
  69  *
  70  */
  71
  72 /**
  73  *    (C) 2004 Kent Hansen
  74  *
  75  *    The XORcyst is free software; you can redistribute it and/or modify
  76  *    it under the terms of the GNU General Public License as published by
  77  *    the Free Software Foundation; either version 2 of the License, or
  78  *    (at your option) any later version.
  79  *
  80  *    The XORcyst is distributed in the hope that it will be useful,
  81  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  82  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  83  *    GNU General Public License for more details.
  84  *
  85  *    You should have received a copy of the GNU General Public License
  86  *    along with The XORcyst; if not, write to the Free Software
  87  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  88  */
  89
  90 /**
  91  * The main program.
  92  */
  93
  94 #include <stdlib.h>
  95 #include <stdio.h>
  96 #include <string.h>
  97 #include "getopt.h"
  98 #include "astnode.h"
  99 #include "astproc.h"
 100 #include "symtab.h"
 101 #include "codegen.h"
 102 #include "xasm.h"
 103
 104 /*---------------------------------------------------------------------------*/
 105
 106 /* Parser stuff we need. */
 107 int yyparse(void);
 108 extern int yydebug;
 109 extern int yynerrs;
 110
 111 /* Scanner stuff we need. */
 112 int yybegin(const char *, int, int);
 113
 114 /* Other. */
 115 astnode *root_node;
 116 static symtab *symbol_table;
 117
 118 /*---------------------------------------------------------------------------*/
 119 /* Argument parsing stuff. */
 120
 121 static char program_version[] = "xasm 1.5.0";
 122
 123 /* Argument variables set by arg parser. */
 124 xasm_arguments xasm_args;
 125
 126 /* Long options for getopt_long(). */
 127 static struct option long_options[] = {
 128   { "define",   required_argument, 0, 'D' },
 129   { "include-path", required_argument, 0, 'I' },
 130   { "output",   required_argument, 0, 'o' },
 131   { "quiet",    no_argument, 0, 'q' },
 132   { "silent",   no_argument, 0, 's' },
 133   { "verbose",  no_argument, 0, 'v' },
 134   { "debug",    no_argument, 0, 'g' },
 135   { "help", no_argument, 0, 0 },
 136   { "usage",    no_argument, 0, 0 },
 137   { "version",  no_argument, 0, 'V' },
 138   { "swap-parens", no_argument, 0, 0 },
 139   { "pure-binary", no_argument, 0, 0 },
 140   { "case-insensitive", no_argument, 0, 0 },
 141   { "no-warn",  no_argument, 0, 0 },
 142   { 0 }
 143 };
 144
 145 /* Prints usage message and exits. */
 146 static void usage()
 147 {
 148     printf("\
 149 Usage: xasm [-gqsvV] [-D IDENT[=VALUE]] [--define=IDENT]\n\
 150             [-o FILE] [--output=FILE] [--pure-binary]\n\
 151             [--include-path=DIR] [-I DIR] [--swap-parens]\n\
 152             [--case-insensitive]\n\
 153             [--no-warn] [--verbose] [--quiet] [--silent] \n\
 154             [--debug] [--help] [--usage] [--version]\n\
 155             FILE\n\
 156 ");
 157     exit(0);
 158 }
 159
 160 /* Prints help message and exits. */
 161 static void help()
 162 {
 163     printf("\
 164 Usage: xasm [OPTION...] FILE\n\
 165 The XORcyst Assembler -- it kicks the 6502's ass\n\
 166 \n\
 167 -D, --define=IDENT[=VALUE] Define IDENT\n\
 168 -I, --include-path=DIR     Specify a search path for include files\n\
 169 -o, --output=FILE          Output to FILE instead of standard output\n\
 170     --pure-binary          Output pure 6502 binary\n\
 171     --swap-parens          Use ( ) instead of [ ] for indirection\n\
 172     --case-insensitive     Case-insensitive identifiers\n\
 173     --no-warn              Suppress warnings\n\
 174 -q, -s, --quiet, --silent  Don't produce any output\n\
 175 -v, --verbose              Produce verbose output\n\
 176 -g, --debug                Retain file locations\n\
 177     --help                 Give this help list\n\
 178     --usage                Give a short usage message\n\
 179 -V, --version              Print program version\n\
 180 \n\
 181 Mandatory or optional arguments to long options are also mandatory or optional\n\
 182 for any corresponding short options.\n\
 183 \n\
 184 Report bugs to <dev@null>.\n\
 185 ");
 186     exit(0);
 187 }
 188
 189 /* Prints version and exits. */
 190 static void version()
 191 {
 192     printf("%s\n", program_version);
 193     exit(0);
 194 }
 195
 196 /**
 197  * Checks if a character is alpha (a-z, A-Z).
 198  */
 199 static int __isalpha(char c)
 200 {
 201     return ( ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) );
 202 }
 203
 204 /**
 205  * Checks if a character is alpha (a-z, A-Z) or numeric (0-9).
 206  */
 207 static int __isalnum(char c)
 208 {
 209     return ( __isalpha(c) || ((c >= '0') && (c <= '9')) );
 210 }
 211
 212 /**
 213  * Checks that an identifier matches the regexp [a-zA-Z_][a-zA-Z0-9_]*
 214  * @param id Identifier to validate
 215  * @return 1 if OK, 0 otherwise
 216  */
 217 static int validate_ident(char *id)
 218 {
 219     int i;
 220     char c;
 221     c = id[0];
 222     if ( !__isalpha(c) && (c != '_') ) {
 223         return 0;
 224     }
 225     for (i=1; i<strlen(id); i++) {
 226         c = id[i];
 227         if ( !__isalnum(c) && (c != '_') ) {
 228             return 0;
 229         }
 230     }
 231     return 1;   /* OK */
 232 }
 233
 234 /* Parses program arguments. */
 235 static void
 236 parse_arguments (int argc, char **argv)
 237 {
 238     int key;
 239     char *id;
 240     char *str;
 241     astnode *val;
 242     symtab_entry *e;
 243     /* Dummy location for --define */
 244     static location loc = { 0, 0, 0, 0, NULL };
 245     /* getopt_long stores the option index here. */
 246     int index = 0;
 247
 248     /* Set default values. */
 249     xasm_args.debug = 0;
 250     xasm_args.silent = 0;
 251     xasm_args.verbose = 0;
 252     xasm_args.swap_parens = 0;
 253     xasm_args.pure_binary = 0;
 254     xasm_args.case_insensitive = 0;
 255     xasm_args.input_file = NULL;
 256     xasm_args.output_file = NULL;
 257     xasm_args.include_paths = NULL;
 258     xasm_args.include_path_count = 0;
 259
 260     /* Parse options. */
 261     while ((key = getopt_long(argc, argv, "D:I:o:qsvV", long_options, &index)) != -1) {
 262         switch (key) {
 263             case 'g':
 264             xasm_args.debug = 1;
 265             break;
 266
 267             case 'q': case 's':
 268             xasm_args.silent = 1;
 269             break;
 270
 271             case 'v':
 272             xasm_args.verbose++;
 273             break;
 274
 275             case 'o':
 276             xasm_args.output_file = optarg;
 277             break;
 278
 279             case 'D':
 280             if (strchr(optarg, '=') != NULL) {
 281                 /* IDENT=VALUE */
 282                 id = strtok(optarg, "=");
 283                 str = strtok(NULL, "\0");
 284                 /* Parse the value */
 285                 if (str[0] == '\"') {
 286                     /* Assume string */
 287                     str = strtok(&str[1], "\"");
 288                     val = astnode_create_string(str, loc);
 289                 } else {
 290                     /* Assume integer */
 291                     val = astnode_create_integer(strtol(str, NULL, 0), loc);
 292                 }
 293             } else {
 294                 id = optarg;
 295                 val = astnode_create_integer(0, loc);
 296             }
 297             if (validate_ident(id)) {
 298                 e = symtab_lookup(id);
 299                 if (e == NULL) {
 300                     symtab_enter(id, CONSTANT_SYMBOL, val, 0);
 301                 } else {
 302                     /* Error, redefinition */
 303                     fprintf(stderr, "--ident: `%s' already defined\n", id);
 304                 }
 305             } else {
 306                 /* Error, bad identifier */
 307                 fprintf(stderr, "--ident: `%s' is not a valid identifier\n", id);
 308             }
 309             break;
 310
 311             case 'I': {
 312                 char *p;
 313                 int count = xasm_args.include_path_count + 1;
 314                 xasm_args.include_paths = (char **)realloc(
 315                     xasm_args.include_paths, sizeof(const char *) * count);
 316                 p = (char *)malloc(strlen(optarg) + 1);
 317                 strcpy(p, optarg);
 318                 xasm_args.include_paths[count-1] = p;
 319                 xasm_args.include_path_count = count;
 320             }
 321             break;
 322
 323             case 0:
 324             /* Use index to differentiate between options */
 325             if (strcmp(long_options[index].name, "usage") == 0) {
 326                 usage();
 327             } else if (strcmp(long_options[index].name, "help") == 0) {
 328                 help();
 329             } else if (strcmp(long_options[index].name, "swap-parens") == 0) {
 330                 xasm_args.swap_parens = 1;
 331             } else if (strcmp(long_options[index].name, "pure-binary") == 0) {
 332                 xasm_args.pure_binary = 1;
 333             } else if (strcmp(long_options[index].name, "case-insensitive") == 0) {
 334                 xasm_args.case_insensitive = 1;
 335             } else if (strcmp(long_options[index].name, "no-warn") == 0) {
 336                 xasm_args.no_warn = 1;
 337             }
 338             break;
 339
 340             case 'V':
 341             version();
 342             break;
 343
 344             case '?':
 345             /* Error message has been printed by getopt_long */
 346             exit(1);
 347             break;
 348
 349             default:
 350             /* Forgot to handle a short option, most likely */
 351             exit(1);
 352             break;
 353         }
 354     }
 355
 356     /* Must be one additional argument, which is the input file. */
 357     if (argc-1 != optind) {
 358         printf("Usage: xasm [OPTION...] FILE\nTry `xasm --help' or `xasm --usage' for more information.\n");
 359         exit(1);
 360     }
 361     else {
 362         xasm_args.input_file = argv[optind];
 363     }
 364 }
 365
 366 /*---------------------------------------------------------------------------*/
 367
 368 /**
 369  * Changes the extension of a filename.
 370  * @param infile Filename whose extension to change
 371  * @param ext New extension
 372  * @param outfile Destination filename
 373  */
 374 static void change_extension(const char *infile, const char *ext, char *outfile)
 375 {
 376     char *p;
 377     /* Find the last dot. */
 378     p = strrchr(infile, '.');
 379     if (p == NULL) {
 380         /* There is no dot, simply concatenate extension. */
 381         sprintf(outfile, "%s.%s", infile, ext);
 382     }
 383     else {
 384         /* Copy the name up to and including the last dot */
 385         strncpy(outfile, infile, p - infile + 1);
 386         outfile[p - infile + 1] = '\0';
 387         /* Then concatenate the extension. */
 388         strcat(outfile, ext);
 389     }
 390 }
 391
 392 /*---------------------------------------------------------------------------*/
 393
 394 /**
 395  * Prints message only if --verbose option was given to assembler.
 396  */
 397 static void verbose(const char *s)
 398 {
 399     if (xasm_args.verbose) {
 400         printf("%s\n", s);
 401     }
 402 }
 403
 404 /**
 405  * Gets total number of errors (parsing + semantics).
 406  */
 407 static int total_errors()
 408 {
 409     return yynerrs + astproc_err_count();
 410 }
 411
 412 /**
 413  * Program entrypoint.
 414  */
 415 int main(int argc, char *argv[]) {
 416     char *default_outfile = 0;
 417
 418     /* Create global symbol table (auto-pushed on stack) */
 419     symbol_table = symtab_create();
 420
 421     /* Parse our arguments. */
 422     parse_arguments (argc, argv);
 423
 424     /* Open input for scanning */
 425     if (!yybegin(xasm_args.input_file,
 426                  xasm_args.swap_parens,
 427                  xasm_args.case_insensitive)) {
 428         printf("error: could not open `%s' for reading\n", xasm_args.input_file);
 429         symtab_finalize(symbol_table);
 430         return(1);
 431     }
 432
 433  /* Parse it into a syntax tree */
 434     //yydebug = -1;
 435     verbose("Parsing input...");
 436     yyparse();
 437
 438     if (root_node == NULL) {
 439         symtab_finalize(symbol_table);
 440         return(0);
 441     }
 442
 443     /* First pass does a lot of stuff. */
 444     verbose("First pass...");
 445     astproc_first_pass(root_node);
 446
 447     /* Second pass does more stuff. */
 448     verbose("Second pass...");
 449     astproc_second_pass(root_node);
 450
 451     /* Third pass is fun. */
 452     verbose("Third pass...");
 453     astproc_third_pass(root_node);
 454
 455     if (xasm_args.pure_binary) {
 456         /* Do another pass to prepare for writing pure 6502 */
 457         verbose("Fourth pass...");
 458         astproc_fourth_pass(root_node);
 459     }
 460
 461     /* Print the final AST (debugging) */
 462 //    astnode_print(root_node, 0);
 463
 464     /* If no errors, proceed with code generation. */
 465     if (total_errors() == 0) {
 466         if (xasm_args.output_file == NULL) {
 467             /* Create default name of output */
 468             const char *default_ext = "o";
 469             int default_outfile_len = strlen(xasm_args.input_file)
 470                                     + /*dot*/1 + strlen(default_ext) + 1;
 471             default_outfile = (char *)malloc(default_outfile_len);
 472             change_extension(xasm_args.input_file, default_ext, default_outfile);
 473             xasm_args.output_file = default_outfile;
 474         }
 475         /* Write it! */
 476         verbose("Generating final output...");
 477         if (xasm_args.pure_binary) {
 478             astproc_fifth_pass(root_node);
 479         } else {
 480             codegen_write(root_node, xasm_args.output_file);
 481         }
 482     }
 483
 484     /* Cleanup */
 485     verbose("cleaning up...");
 486     symtab_pop();
 487     symtab_finalize(symbol_table);
 488     astnode_finalize(root_node);
 489
 490     if (default_outfile)
 491         free(default_outfile);
 492
 493     if (xasm_args.include_path_count > 0) {
 494         int i;
 495         for (i = 0; i < xasm_args.include_path_count; ++i)
 496             free(xasm_args.include_paths[i]);
 497         free(xasm_args.include_paths);
 498     }
 499
 500     return (total_errors() == 0) ? 0 : 1;
 501 }