git.gag.com Git - fw/sdcc/blob - src/pic16/device.c

   1 /*-------------------------------------------------------------------------
   2
   3   device.c - Accomodates subtle variations in PIC16 devices
   4
   5    Written By -  Scott Dattalo scott@dattalo.com
   6    Ported to PIC16 By -  Martin Dubuc m.dubuc@rogers.com
   7
   8    This program is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 2, or (at your option) any
  11    later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21 -------------------------------------------------------------------------*/
  22
  23
  24 /*
  25         VR - Began writing code to make PIC16 C source files independent from
  26         the header file (created by the inc2h.pl)
  27
  28         - adding maximum RAM memory into PIC_Device structure
  29
  30 */
  31
  32 #include <stdio.h>
  33
  34 #include "common.h"   // Include everything in the SDCC src directory
  35 #include "newalloc.h"
  36
  37
  38 #include "main.h"
  39 #include "pcode.h"
  40 #include "ralloc.h"
  41 #include "device.h"
  42
  43 stats_t statistics = { 0, 0, 0, 0 };
  44
  45 #define DEVICE_FILE_NAME    "pic16devices.txt"
  46
  47 static PIC16_device default_device = {
  48     { "p18f452", "18f452", "pic18f452", "f452" },
  49     0x600,
  50     0x80,
  51     { /* configuration words */
  52       0x300001, 0x30000d,
  53       { { 0x27, 0, 0xff } /* 1 */ , { 0x0f, 0, 0xff } /* 2 */ ,
  54         { 0x0f, 0, 0xff } /* 3 */ , {  -1 , 0, 0xff } /* 4 */ ,
  55         { 0x01, 0, 0xff } /* 5 */ , { 0x85, 0, 0xff } /* 6 */ ,
  56         {  -1 , 0, 0xff } /* 7 */ , { 0x0f, 0, 0xff } /* 8 */ ,
  57         { 0xc0, 0, 0xff } /* 9 */ , { 0x0f, 0, 0xff } /* a */ ,
  58         { 0xe0, 0, 0xff } /* b */ , { 0x0f, 0, 0xff } /* c */ ,
  59         { 0x40, 0, 0xff } /* d */ }
  60     },
  61     { /* ID locations */
  62       0x200000, 0x200007,
  63       { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
  64         { 0, 0 }, { 0, 0 }, { 0, 0 } }
  65     },
  66     NULL
  67 };
  68
  69 PIC16_device *pic16 = &default_device;
  70 static PIC16_device *devices = NULL;
  71
  72 extern set *includeDirsSet;
  73 extern set *userIncDirsSet;
  74
  75 extern char *iComments2;
  76
  77 void pic16_dump_equates(FILE *of, set *equs)
  78 {
  79   regs *r;
  80
  81         r = setFirstItem(equs);
  82         if(!r)return;
  83
  84         fprintf(of, "%s", iComments2);
  85         fprintf(of, ";\tEquates to used internal registers\n");
  86         fprintf(of, "%s", iComments2);
  87
  88         for(; r; r = setNextItem(equs)) {
  89                 fprintf(of, "%s\tequ\t0x%02x\n", r->name, r->address);
  90         }
  91 }
  92
  93
  94 void pic16_dump_access(FILE *of, set *section)
  95 {
  96   regs *r;
  97
  98         r = setFirstItem(section);
  99         if(!r)return;
 100
 101         fprintf(of, "%s", iComments2);
 102         fprintf(of, ";\tAccess bank symbols\n");
 103         fprintf(of, "%s", iComments2);
 104
 105         fprintf(of, "\tudata_acs\n");
 106         for(; r; r = setNextItem(section)) {
 107                 fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 108                 statistics.adsize += r->size;
 109         }
 110 }
 111
 112
 113 int regCompare(const void *a, const void *b)
 114 {
 115   const regs *const *i = a;
 116   const regs *const *j = b;
 117
 118         /* sort primarily by the address */
 119         if( (*i)->address > (*j)->address)return 1;
 120         if( (*i)->address < (*j)->address)return -1;
 121
 122         /* and secondarily by size */
 123         /* register size sorting may have strange results use with care */
 124         if( (*i)->size > (*j)->size)return 1;
 125         if( (*i)->size < (*j)->size)return -1;
 126
 127         /* finally if in same address and same size sort by name */
 128         return (strcmp( (*i)->name, (*j)->name));
 129
 130   return 0;
 131 }
 132
 133 int symCompare(const void *a, const void *b)
 134 {
 135   const symbol *const *i = a;
 136   const symbol *const *j = b;
 137
 138         /* sort primarily by the address */
 139         if( SPEC_ADDR((*i)->etype) > SPEC_ADDR((*j)->etype))return 1;
 140         if( SPEC_ADDR((*i)->etype) < SPEC_ADDR((*j)->etype))return -1;
 141
 142         /* and secondarily by size */
 143         /* register size sorting may have strange results use with care */
 144         if( getSize((*i)->etype) > getSize((*j)->etype))return 1;
 145         if( getSize((*i)->etype) < getSize((*j)->etype))return -1;
 146
 147         /* finally if in same address and same size sort by name */
 148         return (strcmp( (*i)->rname, (*j)->rname));
 149
 150   return 0;
 151 }
 152
 153 void pic16_dump_usection(FILE *of, set *section, int fix)
 154 {
 155   static int abs_usection_no=0;
 156   static unsigned int usection_no=0;
 157   regs *r, *rprev;
 158   unsigned int init_addr, i;
 159   regs **rlist;
 160   regs *r1;
 161
 162         /* put all symbols in an array */
 163         if (!elementsInSet(section)) return;
 164         rlist = Safe_calloc(elementsInSet(section), sizeof(regs *));
 165         r = rlist[0]; i = 0;
 166         for(rprev = setFirstItem(section); rprev; rprev = setNextItem(section)) {
 167                 rlist[i] = rprev; i++;
 168         }
 169
 170         if(!i) {
 171                 if(rlist)Safe_free(rlist);
 172           return;
 173         }
 174
 175         /* sort symbols according to their address */
 176         qsort(rlist, i  /*elementsInSet(section)*/, sizeof(regs *), regCompare);
 177
 178         if(!fix) {
 179
 180 #define EMIT_SINGLE_UDATA_SECTION       0
 181 #if EMIT_SINGLE_UDATA_SECTION
 182                 fprintf(of, "\n\n\tudata\n");
 183                 for(r = setFirstItem(section); r; r = setNextItem(section)) {
 184                         fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 185                         statistics.udsize += r->size;
 186                 }
 187 #else
 188                 for(r = setFirstItem(section); r; r = setNextItem(section)) {
 189                         //fprintf(of, "\nudata_%s_%s\tudata\n", moduleName, r->name);
 190                         fprintf(of, "\nudata_%s_%u\tudata\n", moduleName, usection_no++);
 191                         fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 192                         statistics.udsize += r->size;
 193                 }
 194 #endif
 195         } else {
 196           unsigned int j=0;
 197           int deb_addr=0;
 198
 199                 rprev = NULL;
 200                 init_addr = rlist[j]->address;
 201                 deb_addr = init_addr;
 202                 fprintf(of, "\n\nustat_%s_%02d\tudata\t0X%04X\n", moduleName, abs_usection_no++, init_addr);
 203
 204                 for(j=0;j<i;j++) {
 205                         r = rlist[j];
 206                         if(j < i-1)r1 = rlist[j+1]; else r1 = NULL;
 207
 208                         init_addr = r->address;
 209                         deb_addr = init_addr;
 210
 211                         if((rprev && (init_addr > (rprev->address + rprev->size)))) {
 212                                 fprintf(of, "\n\nustat_%s_%02d\tudata\t0X%04X\n", moduleName, abs_usection_no++, init_addr);
 213                         }
 214
 215                         if(r1 && (init_addr == r1->address)) {
 216                                 fprintf(of, "\n%s\tres\t0\n", r->name);
 217                         } else {
 218                                 fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 219                                 deb_addr += r->size;
 220                                 statistics.udsize += r->size;
 221                         }
 222
 223                         rprev = r;
 224                 }
 225         }
 226         Safe_free(rlist);
 227 }
 228
 229 void pic16_dump_gsection(FILE *of, set *sections)
 230 {
 231   regs *r;
 232   sectName *sname;
 233
 234         for(sname = setFirstItem(sections); sname; sname = setNextItem(sections)) {
 235                 if(!strcmp(sname->name, "access"))continue;
 236                 fprintf(of, "\n\n%s\tudata\n", sname->name);
 237
 238                 for(r=setFirstItem(sname->regsSet); r; r=setNextItem(sname->regsSet)) {
 239 #if 0
 240                         fprintf(stderr, "%s:%d emitting variable %s for section %s (%p)\n", __FILE__, __LINE__,
 241                                 r->name, sname->name, sname);
 242 #endif
 243                         fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 244                         statistics.udsize += r->size;
 245                 }
 246         }
 247 }
 248
 249
 250 /* forward declaration */
 251 void pic16_printIval(symbol * sym, sym_link * type, initList * ilist, char ptype, void *p);
 252 extern void pic16_pCodeConstString(char *name, char *value);
 253
 254 void pic16_dump_isection(FILE *of, set *section, int fix)
 255 {
 256   static int abs_isection_no=0;
 257   symbol *s, *sprev;
 258   unsigned int init_addr, i;
 259   symbol **slist;
 260
 261         /* put all symbols in an array */
 262         if (!elementsInSet(section)) return;
 263         slist = Safe_calloc(elementsInSet(section), sizeof(symbol *));
 264         s = slist[0]; i = 0;
 265         for(sprev = setFirstItem(section); sprev; sprev = setNextItem(section)) {
 266                 slist[i] = sprev; i++;
 267         }
 268
 269         if(!i) {
 270                 if(slist)Safe_free(slist);
 271           return;
 272         }
 273
 274         /* sort symbols according to their address */
 275         qsort(slist, i, sizeof(symbol *), symCompare);
 276
 277         pic16_initDB();
 278
 279         if(!fix) {
 280                 fprintf(of, "\n\n\tidata\n");
 281                 for(s = setFirstItem(section); s; s = setNextItem(section)) {
 282
 283                         if(s->ival) {
 284                                 fprintf(of, "%s", s->rname);
 285                                 pic16_printIval(s, s->type, s->ival, 'f', (void *)of);
 286                                 pic16_flushDB('f', (void *)of);
 287                         } else {
 288                                 if (IS_ARRAY (s->type) && IS_CHAR (s->type->next)
 289                                         && SPEC_CVAL (s->etype).v_char) {
 290
 291 //                                      fprintf(stderr, "%s:%d printing code string from %s\n", __FILE__, __LINE__, s->rname);
 292                                         pic16_pCodeConstString(s->rname , SPEC_CVAL (s->etype).v_char);
 293                                 } else {
 294                                         assert(0);
 295                                 }
 296                         }
 297
 298                 }
 299         } else {
 300           unsigned int j=0;
 301           symbol *s1;
 302
 303                 sprev = NULL;
 304                 init_addr = SPEC_ADDR(slist[j]->etype);
 305                 fprintf(of, "\n\nistat_%s_%02d\tidata\t0X%04X\n", moduleName, abs_isection_no++, init_addr);
 306
 307                 for(j=0;j<i;j++) {
 308                         s = slist[j];
 309                         if(j < i-1)s1 = slist[j+1]; else s1 = NULL;
 310
 311                         init_addr = SPEC_ADDR(s->etype);
 312
 313                         if(sprev && (init_addr > (SPEC_ADDR(sprev->etype) + getSize(sprev->etype)))) {
 314                                 fprintf(of, "\nistat_%s_%02d\tidata\t0X%04X\n", moduleName, abs_isection_no++, init_addr);
 315                         }
 316
 317                         if(s->ival) {
 318                                 fprintf(of, "%s", s->rname);
 319                                 pic16_printIval(s, s->type, s->ival, 'f', (void *)of);
 320                                 pic16_flushDB('f', (void *)of);
 321                         } else {
 322                                 if (IS_ARRAY (s->type) && IS_CHAR (s->type->next)
 323                                         && SPEC_CVAL (s->etype).v_char) {
 324
 325 //                                      fprintf(stderr, "%s:%d printing code string from %s\n", __FILE__, __LINE__, s->rname);
 326                                         pic16_pCodeConstString(s->rname , SPEC_CVAL (s->etype).v_char);
 327                                 } else {
 328                                         assert(0);
 329                                 }
 330                         }
 331
 332
 333                         sprev = s;
 334                 }
 335         }
 336         Safe_free(slist);
 337 }
 338
 339
 340 void pic16_dump_int_registers(FILE *of, set *section)
 341 {
 342   regs *r, *rprev;
 343   int i;
 344   regs **rlist;
 345
 346         /* put all symbols in an array */
 347         if (!elementsInSet(section)) return;
 348         rlist = Safe_calloc(elementsInSet(section), sizeof(regs *));
 349         r = rlist[0]; i = 0;
 350         for(rprev = setFirstItem(section); rprev; rprev = setNextItem(section)) {
 351                 rlist[i] = rprev; i++;
 352         }
 353
 354         /* sort symbols according to their address */
 355         qsort(rlist, elementsInSet(section), sizeof(regs *), regCompare);
 356
 357         if(!i) {
 358                 if(rlist)Safe_free(rlist);
 359           return;
 360         }
 361
 362         fprintf(of, "\n\n; Internal registers\n");
 363
 364         fprintf(of, "%s\tudata_ovr\t0x0000\n", ".registers");
 365         for(r = setFirstItem(section); r; r = setNextItem(section)) {
 366                 fprintf(of, "%s\tres\t%d\n", r->name, r->size);
 367                 statistics.intsize += r->size;
 368         }
 369
 370         Safe_free(rlist);
 371 }
 372
 373 /**
 374  * Find the device structure for the named device.
 375  * Consider usind pic16_find_device() instead!
 376  *
 377  * @param   name
 378  *      a name for the desired device
 379  * @param   head
 380  *      a pointer to the head of the list of devices
 381  * @return
 382  *      a pointer to the structure for the desired
 383  *      device, or NULL
 384  */
 385 static PIC16_device *
 386 find_in_list(const char *name, PIC16_device *head)
 387 {
 388     int i;
 389
 390     while (head) {
 391         for (i = 0; i < 4; i++) {
 392             if (0 == strcmp(head->name[i], name)) {
 393                 return (head);
 394             } // if
 395         } // for
 396
 397         head = head->next;
 398     } // while
 399
 400     return (NULL);
 401 }
 402
 403 /**
 404  * Print a list of supported devices.
 405  * If --verbose was given, also emit key characteristics (memory size,
 406  * access bank split point, address range of SFRs and config words).
 407  *
 408  * @param   head
 409  *      a pointer to the head of the list of devices
 410  */
 411 static void
 412 pic16_list_devices(PIC16_device *head)
 413 {
 414     int i = 0;
 415
 416     if (options.verbose) {
 417         printf("device        RAM  split       config words\n");
 418     } // if
 419     while (head) {
 420         printf("%-10s  ", head->name[0]);
 421         if (options.verbose) {
 422             printf("%5d   0x%02x    0x%06x..0x%06x\n",
 423                     head->RAMsize,
 424                     head->acsSplitOfs,
 425                     head->cwInfo.confAddrStart,
 426                     head->cwInfo.confAddrEnd);
 427         } else {
 428             i++;
 429             if (0 == (i % 6)) {
 430                 printf("\n");
 431             } // if
 432         } // if
 433         head = head->next;
 434     } // while
 435     printf("\n");
 436 }
 437
 438 /**
 439  * Read a single line from the given file.
 440  * The caller should free() the returned value!
 441  *
 442  * @param   file
 443  *      a pointer to the open file to read
 444  * @return
 445  *      a pointer to a malloc'ed copy of the (next) line, or NULL
 446  */
 447 static char *
 448 get_line (FILE *file)
 449 {
 450     char *line = NULL;
 451     size_t len = 129;
 452     size_t done = 0;
 453     size_t got = 0;
 454
 455     while (!feof(file)) {
 456         line = (char *) Safe_realloc(line, len);
 457         got += fread(&line[done], 1, 128, file);
 458         line[got] = 0;
 459
 460         /* find EOL */
 461         while (done < got) {
 462             if (('\r' == line[done]) || ('\n' == line[done])) {
 463                 line[done] = 0;
 464                 fseek(file, done + 1 - got, SEEK_CUR);
 465                 return (line);
 466             } // if
 467             done++;
 468         } // while
 469
 470         len += 128;
 471     } // while
 472
 473     return (line);
 474 }
 475
 476 /**
 477  * Truncate the given string in place (!) at the first '#' character (if any).
 478  *
 479  * @param   line
 480  *      a pointer to the string to truncate
 481  * @return
 482  *      a pointer to the truncated string (i.e., line)
 483  */
 484 static char *
 485 strip_comment (char *line)
 486 {
 487     char *l = line;
 488     char c;
 489
 490     if (!line) {
 491         return (line);
 492     } // if
 493
 494     while (0 != (c = *l)) {
 495         if ('#' == c) {
 496             *l = 0;
 497             return (line);
 498         } // if
 499         l++;
 500     } // while
 501
 502     return (line);
 503 }
 504
 505 /**
 506  * Report errors in the device specification.
 507  *
 508  * @param   msg
 509  *      a pointer to the detailed message
 510  */
 511 #define SYNTAX(msg) do {                                \
 512     fprintf(stderr, "%s:%d: Syntax error: %s\n",        \
 513             DEVICE_FILE_NAME, lineno, msg);             \
 514 } while (0)
 515
 516 /**
 517  * Locate and read in the device specification (if required) and
 518  * return the device structure for the named device.
 519  *
 520  * @param   name
 521  *      a pointer to the name of the desired device
 522  * @return
 523  *      a pointer to the device structure, or NULL
 524  */
 525 static PIC16_device *
 526 pic16_find_device(const char *name)
 527 {
 528     const char *path;
 529     char buffer[PATH_MAX];
 530     char *line, *key;
 531     const char *sep = " \t\n\r";
 532     FILE *f = NULL;
 533     PIC16_device *d = NULL, *template;
 534     PIC16_device *head = NULL, *tail = NULL;
 535     set *_sets[] = { userIncDirsSet, includeDirsSet };
 536     set **sets = &_sets[0];
 537     int lineno = 0;
 538     int res, i;
 539     int val[3];
 540
 541     if (!devices) {
 542         //printf("%s: searching %s\n", __func__, DEVICE_FILE_NAME);
 543
 544         // locate the specification file in the include search paths
 545         for (i = 0; (NULL == f) && (i < 2); i++) {
 546             for (path = setFirstItem(sets[i]);
 547                     (NULL == f) && path;
 548                     path = setNextItem(sets[i]))
 549             {
 550                 SNPRINTF(&buffer[0], PATH_MAX, "%s%s%s",
 551                         path, DIR_SEPARATOR_STRING, DEVICE_FILE_NAME);
 552                 //printf("%s: checking %s\n", __func__, &buffer[0]);
 553                 f = fopen(&buffer[0], "r");
 554             } // for
 555         } // while
 556     } // if
 557
 558     if (devices) {
 559         // list already set up, nothing to do
 560     } else if (NULL == f) {
 561         fprintf(stderr, "ERROR: device list %s not found, specify its path via -I<path>\n", DEVICE_FILE_NAME);
 562         d = &default_device;
 563     } else {
 564         // parse the specification file and construct a linked list of
 565         // supported devices
 566         d = NULL;
 567         while (NULL != (line = get_line(f))) {
 568             strip_comment(line);
 569             //printf("%s: read %s\n", __func__, line);
 570             lineno++;
 571             key = strtok(line, sep);
 572             if (!key) {
 573                 // empty line---ignore
 574             } else if (0 == strcmp(key, "name")) {
 575                 // name %<name>s
 576                 if (d) {
 577                     if (tail) {
 578                         tail->next = d;
 579                     } else {
 580                         head = d;
 581                     } // if
 582                     tail = d;
 583                     d = NULL;
 584                 } // if
 585
 586                 res = sscanf(&line[1+strlen(key)], " %16s", &buffer[3]);
 587                 if ((1 < res) || (3 > strlen(&buffer[3]))) {
 588                     SYNTAX("<name> (e.g., 18f452) expected.");
 589                 } else {
 590                     d = Safe_calloc(1, sizeof(PIC16_device));
 591
 592                     // { "p18f452", "18f452", "pic18f452", "f452" }
 593                     buffer[0] = 'p';
 594                     buffer[1] = 'i';
 595                     buffer[2] = 'c';
 596                     d->name[3] = Safe_strdup(&buffer[5]);
 597                     d->name[2] = Safe_strdup(&buffer[0]);
 598                     d->name[1] = Safe_strdup(&buffer[3]);
 599                     buffer[2] = 'p';
 600                     d->name[0] = Safe_strdup(&buffer[2]);
 601                 } // if
 602             } else if (0 == strcmp(key, "using")) {
 603                 // using %<name>s
 604                 res = sscanf(&line[1+strlen(key)], " %16s", &buffer[0]);
 605                 if ((1 < res) || (3 > strlen(&buffer[3]))) {
 606                     SYNTAX("<name> (e.g., 18f452) expected.");
 607                 } else {
 608                     template = find_in_list(&buffer[0], head);
 609                     if (!template) {
 610                         SYNTAX("<name> (e.g., 18f452) expected.");
 611                     } else {
 612                         memcpy(&d->RAMsize, &template->RAMsize,
 613                                 ((char *)&d->next) - ((char *)&d->RAMsize));
 614                     } // if
 615                 } // if
 616             } else if (0 == strcmp(key, "ramsize")) {
 617                 // ramsize %<bytes>i
 618                 res = sscanf(&line[1+strlen(key)], " %i", &val[0]);
 619                 if (res < 1) {
 620                     SYNTAX("<bytes> (e.g., 256) expected.");
 621                 } else {
 622                     d->RAMsize = val[0];
 623                 } // if
 624             } else if (0 == strcmp(key, "split")) {
 625                 // split %<offset>i
 626                 res = sscanf(&line[1+strlen(key)], " %i", &val[0]);
 627                 if (res < 1) {
 628                     SYNTAX("<offset> (e.g., 0x80) expected.");
 629                 } else {
 630                     d->acsSplitOfs = val[0];
 631                 } // if
 632             } else if (0 == strcmp(key, "configrange")) {
 633                 // configrange %<first>i %<last>i
 634                 res = sscanf(&line[1+strlen(key)], " %i %i",
 635                         &val[0], &val[1]);
 636                 if (res < 2) {
 637                     SYNTAX("<first> <last> (e.g., 0xf60 0xfff) expected.");
 638                 } else {
 639                     d->cwInfo.confAddrStart = val[0];
 640                     d->cwInfo.confAddrEnd = val[1];
 641                 } // if
 642             } else if (0 == strcmp(key, "configword")) {
 643                 // configword %<address>i %<mask>i %<value>i
 644                 res = sscanf(&line[1+strlen(key)], " %i %i %i",
 645                         &val[0], &val[1], &val[2]);
 646                 if (res < 3) {
 647                     SYNTAX("<address> <mask> <value> (e.g., 0x200001 0x0f 0x07) expected.");
 648                 } else {
 649                     val[0] -= d->cwInfo.confAddrStart;
 650                     if ((val[0] < 0)
 651                             || (val[0] > (d->cwInfo.confAddrEnd - d->cwInfo.confAddrStart))
 652                             || (val[0] >= CONFIGURATION_WORDS))
 653                     {
 654                         SYNTAX("address out of bounds.");
 655                     } else {
 656                         d->cwInfo.crInfo[val[0]].mask = val[1];
 657                         d->cwInfo.crInfo[val[0]].value = val[2];
 658                     } // if
 659                 } // if
 660             } else if (0 == strcmp(key, "idlocrange")) {
 661                 // idlocrange %<first>i %<last>i
 662                 res = sscanf(&line[1+strlen(key)], " %i %i",
 663                         &val[0], &val[1]);
 664                 if (res < 2) {
 665                     SYNTAX("<first> <last> (e.g., 0xf60 0xfff) expected.");
 666                 } else {
 667                     d->idInfo.idAddrStart = val[0];
 668                     d->idInfo.idAddrEnd = val[1];
 669                 } // if
 670             } else if (0 == strcmp(key, "idword")) {
 671                 // idword %<address>i %<value>i
 672                 res = sscanf(&line[1+strlen(key)], " %i %i",
 673                         &val[0], &val[1]);
 674                 if (res < 2) {
 675                     SYNTAX("<address> <value> (e.g., 0x3fffff 0x00) expected.");
 676                 } else {
 677                     val[0] -= d->idInfo.idAddrStart;
 678                     if ((val[0] < 0)
 679                             || (val[0] > (d->idInfo.idAddrEnd - d->idInfo.idAddrStart))
 680                             || (val[0] >= IDLOCATION_BYTES))
 681                     {
 682                         SYNTAX("address out of bounds.");
 683                     } else {
 684                         d->idInfo.irInfo[val[0]].value = val[1];
 685                     } // if
 686                 } // if
 687             } else {
 688                 printf("%s: Invalid keyword in %s ignored: %s\n",
 689                         __func__, DEVICE_FILE_NAME, key);
 690             } // if
 691             free(line);
 692         } // while
 693
 694         if (d) {
 695             if (tail) {
 696                 tail->next = d;
 697             } else {
 698                 head = d;
 699             } // if
 700             tail = d;
 701             d = NULL;
 702         } // if
 703
 704         devices = head;
 705
 706         fclose(f);
 707     } // if
 708
 709     d = find_in_list(name, devices);
 710     if (!d) {
 711         d = &default_device;
 712     } // if
 713
 714     return (d);
 715 }
 716
 717 /*-----------------------------------------------------------------*
 718  *
 719  *-----------------------------------------------------------------*/
 720 void pic16_init_pic(const char *pic_type)
 721 {
 722     pic16 = pic16_find_device(pic_type);
 723
 724     if (&default_device == pic16) {
 725         if (pic_type) {
 726             fprintf(stderr, "'%s' was not found.\n", pic_type);
 727         } else {
 728             fprintf(stderr, "No processor has been specified (use -pPROCESSOR_NAME)\n");
 729         } // if
 730
 731         if (devices) {
 732             fprintf(stderr,"Valid devices are (use --verbose for more details):\n");
 733             pic16_list_devices(devices);
 734         } // if
 735         exit(EXIT_FAILURE);
 736     } // if
 737 }
 738
 739 /*-----------------------------------------------------------------*
 740  *  char *pic16_processor_base_name(void) - Include file is derived from this.
 741  *-----------------------------------------------------------------*/
 742 char *pic16_processor_base_name(void)
 743 {
 744
 745   if(!pic16)
 746     return NULL;
 747
 748   return pic16->name[0];
 749 }
 750
 751 #define DEBUG_CHECK     0
 752
 753 /*
 754  * return 1 if register wasn't found and added, 0 otherwise
 755  */
 756 int checkAddReg(set **set, regs *reg)
 757 {
 758   regs *tmp;
 759
 760
 761         if(!reg)return 0;
 762 #if DEBUG_CHECK
 763         fprintf(stderr, "%s: about to insert REGister: %s ... ", __FUNCTION__, reg->name);
 764 #endif
 765
 766         for(tmp = setFirstItem(*set); tmp; tmp = setNextItem(*set)) {
 767                 if(!strcmp(tmp->name, reg->name))break;
 768         }
 769
 770         if(!tmp) {
 771                 addSet(set, reg);
 772 #if DEBUG_CHECK
 773                 fprintf(stderr, "added\n");
 774 #endif
 775                 return 1;
 776         }
 777
 778 #if DEBUG_CHECK
 779         fprintf(stderr, "already added\n");
 780 #endif
 781   return 0;
 782 }
 783
 784 int checkAddSym(set **set, symbol *sym)
 785 {
 786   symbol *tmp;
 787
 788         if(!sym)return 0;
 789 #if DEBUG_CHECK
 790         fprintf(stderr, "%s: about to add SYMbol: %s ... ", __FUNCTION__, sym->name);
 791 #endif
 792
 793         for(tmp = setFirstItem( *set ); tmp; tmp = setNextItem(*set)) {
 794                 if(!strcmp(tmp->name, sym->name))break;
 795         }
 796
 797         if(!tmp) {
 798                 addSet(set, sym);
 799 #if DEBUG_CHECK
 800                 fprintf(stderr, "added\n");
 801 #endif
 802                 return 1;
 803         }
 804
 805 #if DEBUG_CHECK
 806         fprintf(stderr, "already added\n");
 807 #endif
 808
 809   return 0;
 810 }
 811
 812 int checkSym(set *set, symbol *sym)
 813 {
 814   symbol *tmp;
 815
 816         if(!sym)return 0;
 817
 818 #if DEUG_CHECK
 819         fprintf(stderr, "%s: about to search for SYMbol: %s ... ", __FUNCTION__, sym->name);
 820 #endif
 821
 822         for(tmp = setFirstItem( set ); tmp; tmp = setNextItem( set )) {
 823                 if(!strcmp(tmp->name, sym->name))break;
 824         }
 825
 826         if(!tmp) {
 827 #if DEBUG_CHECK
 828                 fprintf(stderr, "not found\n");
 829 #endif
 830                 return 0;
 831         }
 832
 833 #if DEBUG_CHECK
 834         fprintf(stderr, "found\n");
 835 #endif
 836
 837   return 1;
 838 }
 839
 840 /*-----------------------------------------------------------------*
 841  * void pic16_groupRegistersInSection - add each register to its   *
 842  *      corresponding section                                      *
 843  *-----------------------------------------------------------------*/
 844 void pic16_groupRegistersInSection(set *regset)
 845 {
 846   regs *reg;
 847   sectSym *ssym;
 848   int docontinue=0;
 849
 850         for(reg=setFirstItem(regset); reg; reg = setNextItem(regset)) {
 851
 852 #if 0
 853                 fprintf(stderr, "%s:%d group registers in section, reg: %s (used: %d, %p)\n",
 854                         __FILE__, __LINE__, reg->name, reg->wasUsed, reg);
 855 #endif
 856                 if((reg->wasUsed
 857                         && !(reg->regop && SPEC_EXTR(OP_SYM_ETYPE(reg->regop))))
 858                   ) {
 859
 860                         /* avoid grouping registers that have an initial value,
 861                          * they will be added later in idataSymSet */
 862                         if(reg->regop && (OP_SYMBOL(reg->regop)->ival && !OP_SYMBOL(reg->regop)->level))
 863                                 continue;
 864
 865 #if 0
 866                         fprintf(stderr, "%s:%d register %s alias:%d fix:%d ival=%i level=%i code=%i\n",
 867                                 __FILE__, __LINE__, reg->name, reg->alias, reg->isFixed,
 868                                         (reg->regop?(OP_SYMBOL(reg->regop)->ival?1:0):-1),
 869                                         (reg->regop?(OP_SYMBOL(reg->regop)->level):-1),
 870                                         (reg->regop?(IS_CODE(OP_SYM_ETYPE(reg->regop))):-1) );
 871 #endif
 872
 873                         docontinue=0;
 874                         for(ssym=setFirstItem(sectSyms);ssym;ssym=setNextItem(sectSyms)) {
 875                                 if(!strcmp(ssym->name, reg->name)) {
 876 //                                      fprintf(stderr, "%s:%d section found %s (%p) with var %s\n",
 877 //                                                      __FILE__, __LINE__, ssym->section->name, ssym->section, ssym->name);
 878                                         if(strcmp(ssym->section->name, "access")) {
 879                                                 addSet(&ssym->section->regsSet, reg);
 880                                                 docontinue=1;
 881                                                 break;
 882                                         } else {
 883                                                 docontinue=0;
 884                                                 reg->accessBank = 1;
 885                                                 break;
 886                                         }
 887                                 }
 888                         }
 889
 890                         if(docontinue)continue;
 891
 892 //                      fprintf(stderr, "%s:%d reg: %s\n", __FILE__, __LINE__, reg->name);
 893
 894                         if(reg->alias == 0x80) {
 895                                 checkAddReg(&pic16_equ_data, reg);
 896                         } else
 897                         if(reg->isFixed) {
 898                                 checkAddReg(&pic16_fix_udata, reg);
 899                         } else
 900                         if(!reg->isFixed) {
 901                                 if(reg->pc_type == PO_GPR_TEMP)
 902                                         checkAddReg(&pic16_int_regs, reg);
 903                                 else {
 904                                         if(reg->accessBank) {
 905                                                 if(reg->alias != 0x40)
 906                                                         checkAddReg(&pic16_acs_udata, reg);
 907                                         } else
 908                                                 checkAddReg(&pic16_rel_udata, reg);
 909                                 }
 910                         }
 911                 }
 912         }
 913 }
 914
 915
 916
 917
 918
 919 /*-----------------------------------------------------------------*
 920  *  void pic16_assignConfigWordValue(int address, int value)
 921  *
 922  * All high performance RISC CPU PICs have seven config word starting
 923  * at address 0x300000.
 924  * This routine will assign a value to that address.
 925  *
 926  *-----------------------------------------------------------------*/
 927 void pic16_assignConfigWordValue(int address, unsigned int value)
 928 {
 929   int i;
 930
 931         for(i=0;i<pic16->cwInfo.confAddrEnd-pic16->cwInfo.confAddrStart+1;i++) {
 932                 if((address == pic16->cwInfo.confAddrStart+i)
 933                   && (pic16->cwInfo.crInfo[i].mask != -1)
 934                   && (pic16->cwInfo.crInfo[i].mask != 0)) {
 935
 936 #if 0
 937                         fprintf(stderr, "setting location 0x%X to value 0x%x\tmask: 0x%x\ttest: 0x%x\n",
 938                                 /*address*/ pic16->cwInfo.confAddrStart+i, (~value)&0xff,
 939                                         pic16->cwInfo.crInfo[i].mask,
 940                                         (pic16->cwInfo.crInfo[i].mask) & (~value));
 941 #endif
 942
 943 #if 0
 944                         if((((pic16->cwInfo.crInfo[i].mask) & (~value))&0xff) != ((~value)&0xff)) {
 945                                 fprintf(stderr, "%s:%d a wrong value has been given for configuration register 0x%x\n",
 946                                         __FILE__, __LINE__, address);
 947                                         return;
 948                         }
 949 #endif
 950
 951                         pic16->cwInfo.crInfo[i].value = value;
 952                         pic16->cwInfo.crInfo[i].emit = 1;
 953                         return;
 954                 }
 955         }
 956 }
 957
 958 void pic16_assignIdByteValue(int address, char value)
 959 {
 960   int i;
 961
 962         for(i=0;i<pic16->idInfo.idAddrEnd-pic16->idInfo.idAddrStart+1;i++) {
 963                 if(address == pic16->idInfo.idAddrStart+i) {
 964                         pic16->idInfo.irInfo[i].value = value;
 965                         pic16->idInfo.irInfo[i].emit = 1;
 966                 }
 967         }
 968 }