sdcc/sdas/asxxsrc/assubr.c

   1 /* assubr.c */
   2
   3 /*
   4  *  Copyright (C) 1989-2021  Alan R. Baldwin
   5  *
   6  *  This program is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  *
  20  * Alan R. Baldwin
  21  * 721 Berkeley St.
  22  * Kent, Ohio  44240
  23  */
  24
  25 #include "sdas.h"
  26 #include "asxxxx.h"
  27
  28 /*)Module       assubr.c
  29  *
  30  *      The module assubr.c contains the error
  31  *      processing routines.
  32  *
  33  *      assubr.c contains the following functions:
  34  *              VOID    aerr()
  35  *              VOID    diag()
  36  *              VOID    err()
  37  *              VOID    qerr()
  38  *              VOID    rerr()
  39  *              char *  geterr()
  40  *              VOID    xerr()
  41  *
  42  *      assubr.c contains the local array of *error[]
  43  */
  44
  45 /*)Function     VOID    err(c)
  46  *
  47  *              int     c               error type character
  48  *
  49  *      The legacy function err() reports errors using
  50  *      the default error descriptions by calling xerr()
  51  *      with a NULL string.
  52   *
  53  *      functions called:
  54  *              VOID    xerr()          assubr.c
  55  *
  56  *      side effects:
  57  *              The error code may be inserted into the
  58  *              error code array eb[].
  59  */
  60
  61 VOID
  62 err(int c)
  63 {
  64         xerr(c, NULL);
  65 }
  66
  67 /*)Function     VOID    xerr(c, str)
  68  *
  69  *              int     c               error type character
  70  *              char *  str             the error message string
  71  *
  72  *      The function xerr() logs the error code character
  73  *      suppressing duplicate errors.  If the error code
  74  *      is 'q' then the parse of the current assembler-source
  75  *      text line is terminated.
  76  *
  77  *      local variables:
  78  *              char *  p               pointer to the error array
  79  *
  80  *      global variables:
  81  *              int     aserr           error counter
  82  *              char    eb[]            array of generated error codes
  83  *              char *  ex[]            array of error string pointers
  84  *
  85  *      functions called:
  86  *              VOID    longjmp()       c_library
  87  *
  88  *      side effects:
  89  *              The error code may be inserted into the
  90  *              error code array eb[], a pointer to the
  91  *              optional error message inserted into the
  92  *              array ex[], or the parse terminated.
  93  */
  94
  95 VOID
  96 xerr(int c, char *str)
  97 {
  98         char *p;
  99
 100         aserr++;
 101         p = eb;
 102         while (p < ep)
 103                 if (*p++ == c)
 104                         return;
 105         if (p < &eb[NERR]) {
 106                 ex[(int) (p-eb)] = str;
 107                 *p++ = c;
 108                 ep = p;
 109         }
 110         if (c == 'q')
 111                 longjmp(jump_env, -1);
 112 }
 113
 114 /*)Function     VOID    diag()
 115  *
 116  *      The function diag() prints any error codes and
 117  *      the source line number to the stderr output device.
 118  *
 119  *      local variables:
 120  *              char *  p               pointer to error code array eb[]
 121  *
 122  *      global variables:
 123  *              char    eb[]            array of generated error codes
 124  *              char *  ep              pointer into error list
 125  *              int     incline         include file line number
 126  *              char    afn[]           afile() constructed filespec
 127  *              FILE *  stderr          c_library
 128  *
 129  *      functions called:
 130  *              int     fprintf()       c_library
 131  *              char *  geterr()        assubr.c
 132  *              int     getlnm()        assubr.c
 133  *
 134  *      side effects:
 135  *              Error strings output to stderr.
 136  */
 137
 138 VOID
 139 diag(void)
 140 {
 141         char *p,*errstr;
 142         FILE *fp;
 143
 144         fp = stderr;
 145         if (eb != ep) {
 146                 p = eb;
 147                 if (!is_sdas()) {
 148                         fprintf(fp, "?ASxxxx-Error-<");
 149                         while (p < ep) {
 150                                 fprintf(fp, "%c", *p);
 151                                 p++;
 152                         }
 153                         fprintf(fp, "> in line ");
 154                         fprintf(fp, "%d", getlnm());
 155                         fprintf(fp, " of %s\n", afn);
 156                 }
 157                 p = eb;
 158                 while (p < ep) {
 159                         if ((ex[(int) (p-eb)] != NULL) && (*ex[(int) (p-eb)] != 0)) {
 160                                 if (!is_sdas()) {
 161                                         fprintf(fp, "              <%c> %s\n", *p, ex[(int) (p-eb)]);
 162                                 } else {
 163                                         /* Modified to conform to gcc error standard, basxto, 24 Mar '22. */
 164                                         fprintf(stderr, "%s:", afn);
 165                                         fprintf(stderr, "%d: Error:", getlnm());
 166                                         fprintf(stderr, " <%c> %s\n", *p, ex[(int) (p-eb)]);
 167                                 }
 168                         } else
 169                         if ((errstr = geterr(*p)) != NULL) {
 170                                 if (!is_sdas()) {
 171                                         fprintf(fp, "              %s\n", errstr);
 172                                 } else {
 173                                         /* Modified to conform to gcc error standard, M. Hope, 7 Feb 98. */
 174                                         fprintf(stderr, "%s:", afn);
 175                                         fprintf(stderr, "%d: Error:", getlnm());
 176                                         fprintf(stderr, " %s\n", errstr);
 177                                 }
 178                         }
 179                         p++;
 180                 }
 181         }
 182 }
 183
 184
 185 /* sdas specific */
 186 /*)Function     VOID    warnBanner()
 187  *
 188  *      The function warnBanner() prints a generic warning message
 189  *      header (including the current source file/line) and positions
 190  *      the output for a more specific warning message.
 191  *
 192  *      It is assumed that the call to warnBanner will be followed with
 193  *      a fprintf to stderr (or equivalent) with the specific warning
 194  *      text.
 195  *
 196  *      local variables:
 197  *              none
 198  *
 199  *      global variables:
 200  *              char    afn[]           afile() constructed filespec
 201  *              FILE *  stderr          c_library
 202  *
 203  *      functions called:
 204  *              int     fprintf()       c_library
 205  *              int     getlnm()        assubr.c
 206  *
 207  *      side effects:
 208  *              none
 209  */
 210 VOID
 211 warnBanner(void)
 212 {
 213         fprintf(stderr, "?ASxxxx-Warning in line ");
 214         fprintf(stderr, "%d", getlnm());
 215         fprintf(stderr, " of %s\n", afn);
 216         fprintf(stderr, "               ");
 217 }
 218 /* end sdas specific */
 219
 220 /*)Functions:   VOID    aerr()
 221  *              VOID    qerr()
 222  *              VOID    rerr()
 223  *
 224  *      The functions aerr(), qerr(), and rerr() report their
 225  *      respective error type.  These are included only for
 226  *      convenience.
 227  *
 228  *      local variables:
 229  *              none
 230  *
 231  *      global variables:
 232  *              none
 233  *
 234  *      functions called:
 235  *              VOID    err()           assubr.c
 236  *
 237  *      side effects:
 238  *              The appropriate error code is inserted into the
 239  *              error array and the parse may be terminated.
 240  */
 241
 242 /*
 243  * Note an 'r' error.
 244  */
 245 VOID
 246 rerr(void)
 247 {
 248         err('r');
 249 }
 250
 251 /*
 252  * Note an 'a' error.
 253  */
 254 VOID
 255 aerr(void)
 256 {
 257         err('a');
 258 }
 259
 260 /*
 261  * Note a 'q' error.
 262  */
 263 VOID
 264 qerr(void)
 265 {
 266         err('q');
 267 }
 268
 269 /*
 270  * Default ASxxxx assembler errors
 271  */
 272 char *errors[] = {
 273         "<.> use \". = . + <arg>\" not \". = <arg>\"",
 274         "<a> machine specific addressing or addressing mode error",
 275         "<b> address / direct page boundary error",
 276         "<c> .bndry offset error",
 277         "<d> direct page addressing error",
 278         "<e> .error/.assume programmed error",
 279         "<i> .include/.incbin file error or an .if/.endif mismatch",
 280         "<k> numerical conversion error",
 281         "<m> multiple definitions error or macro recursion error",
 282         "<n> .endm, .mexit, or .narg outside of a macro",
 283         "<o> .org in REL area or directive / mnemonic error",
 284         "<p> phase error: label location changing between passes 2 and 3",
 285         "<q> missing or improper operators, terminators, or delimiters",
 286         "<r> relocation error",
 287         "<s> string substitution / recursion error",
 288         "<u> undefined symbol encountered during assembly",
 289         "<v> out of range signed / unsigned value",
 290         "<z> divide by zero or mod of zero error",
 291         NULL
 292 };
 293
 294 /*)Function:    char    *geterr(c)
 295  *
 296  *              int     c               the error code character
 297  *
 298  *      The function geterr() scans the list of errors returning the
 299  *      error string corresponding to the input error character.
 300  *
 301  *      local variables:
 302  *              int     i               error index counter
 303  *
 304  *      global variables:
 305  *              char    *errors[]       array of pointers to the
 306  *                                      error strings
 307  *              char    erb[]           Error string buffer
 308  *
 309  *      functions called:
 310  *              none
 311  *
 312  *      side effects:
 313  *              A pointer to the appropriate
 314  *              error code string is returned.
 315  */
 316 char *
 317 geterr(int c)
 318 {
 319         int i;
 320
 321         for (i=0; errors[i]!=NULL; i++) {
 322                 if (c == errors[i][1]) {
 323                         return(errors[i]);
 324                 }
 325         }
 326         sprintf(erb, "<e> %.*s", (int) (sizeof(erb)-5), ib);
 327         return(erb);
 328 }
 329
 330