parse.c

   1 #include <ctype.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdio.h>
   5
   6 #include "asm.h"
   7 #include "parse.h"
   8 #include "error.h"
   9 #include "symbol.h"
  10
  11 FILE *pInfile;
  12
  13 char InBuff[MAXINBUFF];
  14
  15 char FilenameBuff[80];
  16
  17 char *current_command = InBuff;
  18 int current_command_type;
  19
  20 int k = 0;
  21
  22 void dump_buffer()
  23 {
  24         int i = 0;
  25         while(InBuff[i] != '\0')
  26         {
  27                 printf("%c", InBuff[i++]);
  28         }
  29         printf("\n");
  30 }
  31
  32 void reset_buffer()
  33 {
  34         current_command = InBuff;
  35 }
  36
  37 int find_line_num()
  38 {
  39         int i = 1;
  40         char *k = InBuff;
  41         while(current_command != k)
  42         {
  43                 if(*k == '\n') { ++i; }
  44                 ++k;
  45         }
  46         return i;
  47 }
  48
  49 int search_command(const char *current_command, const char term)
  50 {
  51         int i = 0;
  52         int found = 0;
  53         while(*(current_command+i) != '\r' && *(current_command+i) != '\n' && *(current_command+i) != '\0')
  54         {
  55                 if(*(current_command+i) == term) { ++found; }
  56                 ++i;
  57         }
  58         return found;
  59 }
  60
  61 void print_current_command()
  62 {
  63         int i = 0;
  64         while(*(current_command+i) != '\r' && *(current_command+i) != '\n' && *(current_command+i) != '\0' && i <= 20)
  65         {
  66                 printf("%c", *(current_command+i));
  67                 ++i;
  68         }
  69         if(settings.code != 0 || settings.comments != 0) { printf("\n"); }
  70 }
  71
  72 void init_parser(char *FilenameBuff)
  73 {
  74         if((pInfile = fopen(FilenameBuff, "rb")) == NULL)
  75                 exit_error(3, "Cannot Open Input (Source) File");
  76
  77         k = -1;
  78         while(!feof(pInfile) && k < MAXINBUFF)
  79         {
  80                 InBuff[++k] = fgetc(pInfile);
  81         }
  82         InBuff[k] = '\0';
  83
  84         if(k < MAXINBUFF)
  85         {
  86                 /* printf("Input Buffer Loaded\n"); */
  87         } else {
  88                 exit_error(4, "Input Too Large for Input Buffer");
  89         }
  90 }
  91
  92 int has_more_commands()
  93 {
  94         int i = 0;
  95         while(isprint(*(current_command+i))) { ++i; }
  96         if(*(current_command+i) == '\0') { return 0; }
  97         if(isspace(*(current_command+i)))
  98         {
  99                 do {
 100                         ++i;
 101                 } while (isspace(*(current_command+i)));
 102                 if(*(current_command+i) == '\0') { return 0; }
 103         }
 104
 105         return 1;
 106 }
 107
 108 void advance()
 109 {
 110         do {
 111                 ++current_command;
 112         } while(*current_command != '\n' && *current_command != '\0');
 113         while(isspace(*current_command)) { ++current_command; }
 114         if(*(current_command+1) == '/')
 115         {
 116                 ++current_command;
 117                 advance();
 118         }
 119 }
 120
 121 int command_type()
 122 {
 123         if(*current_command == '@')
 124         {
 125                 current_command_type = A_COMMAND;
 126                 return A_COMMAND;
 127         } else if(search_command(current_command, '(') > 0 || search_command(current_command, ')') > 0) {
 128                 current_command_type = L_COMMAND;
 129                 return L_COMMAND;
 130         } else if(!isdigit(*current_command)){
 131                 current_command_type = C_COMMAND;
 132                 return C_COMMAND;
 133         } else if(isdigit(*current_command)){
 134                 current_command_type = C_COMMAND;
 135                 return C_COMMAND;
 136         } else {
 137                 int i = find_line_num();
 138                 line_notification(i);
 139                 exit_error(7, "Incorrect Command Type");
 140                 return -1;
 141         }
 142 }
 143
 144 int symbol()
 145 {
 146         int convert = 0, i = 0;
 147         int address = 0;
 148         char sym[MAXSYMBOL];
 149
 150         /* determine if this is a symbol or an address */
 151         convert = isdigit(*(current_command+1));
 152
 153         if(current_command_type == A_COMMAND)
 154         {
 155                 if(convert == 0) /* text (symbolic) entries */
 156                 {
 157                         i = 0;
 158                         while(!isspace(*(current_command+i+1)))
 159                         {
 160                                 sym[i] = *(current_command+i+1);
 161                                 ++i;
 162                         }
 163                         sym[i++] = '\0';
 164                         address = get_address(sym);
 165                         if(address == 0)
 166                         {
 167                                 address = get_ram_address();
 168                                 add_entry(sym,-1);
 169                         }
 170                         return address;
 171
 172                 } else { /* numeric entries */
 173                         i = 0;
 174                         while(!isspace(*(current_command+i+1)))
 175                         {
 176                                 sym[i] = *(current_command+i+1);
 177                                 ++i;
 178                         }
 179                         sym[i++] = '\0';
 180                         /* value looks like a string of chars must be converted */
 181                         address = (int)strtol(sym, (char **) NULL, 10);
 182                         return address;
 183                 }
 184         }
 185
 186         /* TODO:  THIS MUST BE CHANGED TO LOOK IN HASH FOR THIS SYMBOL
 187                 BY NOW IT HAS ALREADY BEEN ADDED TO THE HASH TABLE
 188         */
 189         if(current_command_type == L_COMMAND)
 190         {
 191                 if(convert == 0)
 192                 {
 193                         /* lookup this symbol in hash table and get it's address */
 194                         i = 0;
 195                         while(!isspace(*(current_command+i+1)) && *(current_command+i+1) != ')')
 196                         {
 197                                 sym[i] = *(current_command+i+1);
 198                                 ++i;
 199                         }
 200                         sym[i++] = '\0';
 201                         return get_address(sym);
 202                 } else {
 203                         /* convert numbers into integer and return current symbol as integer */
 204                         i = 0;
 205                         while(!isspace(*(current_command+i+1)) && *(current_command+i+1) != ')')
 206                         {
 207                                 sym[i] = *(current_command+i+1);
 208                                 ++i;
 209                         }
 210                         sym[i++] = '\0';
 211                         return (int)strtol(sym, (char **) NULL, 10);
 212                 }
 213         }
 214         exit_error(8, "Symbol Function Called on Incorrect Command Type.");
 215         return 0;
 216 }
 217
 218 int symbol_load()
 219 {
 220         char sym[MAXCOMMAND];
 221         int i = 0;
 222         while(!isspace(*(current_command+i+1)) && *(current_command+i+1) != ')')
 223         {
 224                 sym[i] = *(current_command+i+1);
 225                 ++i;
 226         }
 227         sym[i++] = '\0';
 228         add_entry(sym, get_rom_address());
 229         return 0;
 230 }
 231
 232 int dest(char dest[])
 233 {
 234         int i = 0;
 235         int dest_exist = 0;
 236
 237         if(current_command_type == C_COMMAND)
 238         {
 239                 while(*(current_command+i) != '\n' && *(current_command+i) != '\0')
 240                 {
 241                         if(*(current_command+i) == '=') { ++dest_exist; }
 242                         ++i;
 243                 }
 244                 if(dest_exist == 0) /* no dest in command */
 245                 {
 246                         dest[0] = '\0';
 247                         return 1;
 248                 }
 249                 i = 0;
 250                 while(*(current_command+i) != '=')
 251                 {
 252                         dest[i] = *(current_command+i);
 253                         i++;
 254                 }
 255                 dest[i] = '\0';
 256                 return 1;
 257         }
 258         i = find_line_num();
 259         line_notification(i);
 260         exit_error(8, "Symbol Function Called on Incorrect Command Type.");
 261         return 0;
 262 }
 263
 264 int comp(char comp[])
 265 {
 266         int i = 0;
 267         int eq_exist = 0;
 268         int semi_exist = 0;
 269         char *delimiter = NULL;
 270
 271         while(*(current_command+i) != '\n' && *(current_command+i) != '\0')
 272         {
 273                 if(*(current_command+i) == '=') { ++eq_exist; delimiter = current_command+i; }
 274                 if(*(current_command+i) == ';') { ++semi_exist; }
 275                 ++i;
 276         }
 277
 278         if(!semi_exist && !eq_exist)
 279         {
 280                 line_notification(i);
 281                 exit_error(9, "Command Does Not Contain Proper Delimiter.");
 282                 return 0;
 283         }
 284
 285         if(current_command_type == C_COMMAND)
 286         {
 287                 if(eq_exist) /* found '=' in command -- skip to char after equal and copy till new line */
 288                 {
 289                         i = 0;
 290                         ++delimiter;
 291                         while(*(delimiter+i) != ';' && !isspace(*(delimiter+i)) && *(delimiter+i) != '\0')
 292                         {
 293                                 comp[i] = *(delimiter+i);
 294                                 i++;
 295                         }
 296                 } else { /* no '=' in command -- copy until semicolon found */
 297                         i = 0;
 298                         while(*(current_command+i) != ';')
 299                         {
 300                                 comp[i] = *(current_command+i);
 301                                 i++;
 302                         }
 303                 }
 304                 comp[i] = '\0';
 305                 return 1;
 306         }
 307         i = find_line_num();
 308         line_notification(i);
 309         exit_error(8, "Symbol Function Called on Incorrect Command Type.");
 310         return 0;
 311 }
 312
 313 int jump(char jump[])
 314 {
 315         int i = 0;
 316         char *delimiter = NULL;
 317         int valid_command = 0;
 318         if(current_command_type == C_COMMAND)
 319         {
 320                 /* Test for semicolon before newline char */
 321                 i = 0;
 322                 while(*(current_command+i) != '\n' && *(current_command+i) != '\0')
 323                 {
 324                         if(*(current_command+i) == ';') { ++valid_command; }
 325                         ++i;
 326                 }
 327                 if(valid_command == 0)
 328                 {
 329                         jump[0] = '\0';
 330                         return 1;
 331                 } /* no jump in command */
 332                 delimiter = strchr(current_command, ';');
 333                 ++delimiter;
 334                 i = 0;
 335                 while(!isspace(*(delimiter+i)) && *(delimiter+i) != '\0')
 336                 {
 337                         jump[i] = *(delimiter+i);
 338                         ++i;
 339                 }
 340                 jump[i] = '\0';
 341                 return 1;
 342         }
 343         i = find_line_num();
 344         line_notification(i);
 345         exit_error(8, "Symbol Function Called on Incorrect Command Type.");
 346         return 0;
 347 }