tagmanager/asm.c

   1 /*
   2 *   Copyright (c) 2000-2003, Darren Hiebert
   3 *
   4 *   This source code is released for free distribution under the terms of the
   5 *   GNU General Public License.
   6 *
   7 *   This module contains functions for generating tags for assembly language
   8 *   files.
   9 */
  10
  11 /*
  12 *   INCLUDE FILES
  13 */
  14 #include "general.h"  /* must always come first */
  15
  16 #include <string.h>
  17
  18 #include "keyword.h"
  19 #include "parse.h"
  20 #include "read.h"
  21 #include "main.h"
  22 #include "vstring.h"
  23
  24 /*
  25 *   DATA DECLARATIONS
  26 */
  27 typedef enum {
  28         K_NONE = -1, K_DEFINE, K_LABEL, K_MACRO, K_TYPE
  29 } AsmKind;
  30
  31 typedef enum {
  32         OP_UNDEFINED = -1,
  33         OP_ALIGN,
  34         OP_COLON_EQUAL,
  35         OP_END,
  36         OP_ENDM,
  37         OP_ENDMACRO,
  38         OP_ENDP,
  39         OP_ENDS,
  40         OP_EQU,
  41         OP_EQUAL,
  42         OP_LABEL,
  43         OP_MACRO,
  44         OP_PROC,
  45         OP_RECORD,
  46         OP_SECTIONS,
  47         OP_SET,
  48         OP_STRUCT,
  49         OP_LAST
  50 } opKeyword;
  51
  52 typedef struct {
  53         const char *operator;
  54         opKeyword keyword;
  55 } asmKeyword;
  56
  57 typedef struct {
  58         opKeyword keyword;
  59         AsmKind kind;
  60 } opKind;
  61
  62 /*
  63 *   DATA DEFINITIONS
  64 */
  65 static langType Lang_asm;
  66
  67 static kindOption AsmKinds [] = {
  68         { TRUE, 'd', "macro", "defines" },
  69         { TRUE, 'l', "namespace",  "labels"  },
  70         { TRUE, 'm', "function",  "macros"  },
  71         { TRUE, 't', "struct",   "types (structs and records)"   }
  72 };
  73
  74 static const asmKeyword AsmKeywords [] = {
  75         { "align",    OP_ALIGN       },
  76         { "endmacro", OP_ENDMACRO    },
  77         { "endm",     OP_ENDM        },
  78         { "end",      OP_END         },
  79         { "endp",     OP_ENDP        },
  80         { "ends",     OP_ENDS        },
  81         { "equ",      OP_EQU         },
  82         { "label",    OP_LABEL       },
  83         { "macro",    OP_MACRO       },
  84         { ":=",       OP_COLON_EQUAL },
  85         { "=",        OP_EQUAL       },
  86         { "proc",     OP_PROC        },
  87         { "record",   OP_RECORD      },
  88         { "sections", OP_SECTIONS    },
  89         { "set",      OP_SET         },
  90         { "struct",   OP_STRUCT      }
  91 };
  92
  93 static const opKind OpKinds [] = {
  94         /* must be ordered same as opKeyword enumeration */
  95         { OP_ALIGN,       K_NONE   },
  96         { OP_COLON_EQUAL, K_DEFINE },
  97         { OP_END,         K_NONE   },
  98         { OP_ENDM,        K_NONE   },
  99         { OP_ENDMACRO,    K_NONE   },
 100         { OP_ENDP,        K_NONE   },
 101         { OP_ENDS,        K_NONE   },
 102         { OP_EQU,         K_DEFINE },
 103         { OP_EQUAL,       K_DEFINE },
 104         { OP_LABEL,       K_LABEL  },
 105         { OP_MACRO,       K_MACRO  },
 106         { OP_PROC,        K_LABEL  },
 107         { OP_RECORD,      K_TYPE   },
 108         { OP_SECTIONS,    K_NONE   },
 109         { OP_SET,         K_DEFINE },
 110         { OP_STRUCT,      K_TYPE   }
 111 };
 112
 113 /*
 114 *   FUNCTION DEFINITIONS
 115 */
 116 static void buildAsmKeywordHash (void)
 117 {
 118         const size_t count = sizeof (AsmKeywords) / sizeof (AsmKeywords [0]);
 119         size_t i;
 120         for (i = 0  ;  i < count  ;  ++i)
 121         {
 122                 const asmKeyword* const p = AsmKeywords + i;
 123                 addKeyword (p->operator, Lang_asm, (int) p->keyword);
 124         }
 125 }
 126
 127 static opKeyword analyzeOperator (const vString *const op)
 128 {
 129         vString *keyword = vStringNew ();
 130         opKeyword result;
 131
 132         vStringCopyToLower (keyword, op);
 133         result = (opKeyword) lookupKeyword (vStringValue (keyword), Lang_asm);
 134         vStringDelete (keyword);
 135         return result;
 136 }
 137
 138 static boolean isInitialSymbolCharacter (int c)
 139 {
 140         return (boolean) (c != '\0' && (isalpha (c) || strchr ("_$", c) != NULL));
 141 }
 142
 143 static boolean isSymbolCharacter (int c)
 144 {
 145         /* '?' character is allowed in AMD 29K family */
 146         return (boolean) (c != '\0' && (isalnum (c) || strchr ("_$?", c) != NULL));
 147 }
 148
 149 static boolean readPreProc (const unsigned char *const line)
 150 {
 151         boolean result;
 152         const unsigned char *cp = line;
 153         vString *name = vStringNew ();
 154         while (isSymbolCharacter ((int) *cp))
 155         {
 156                 vStringPut (name, *cp);
 157                 ++cp;
 158         }
 159         vStringTerminate (name);
 160         result = (boolean) (strcmp (vStringValue (name), "define") == 0);
 161         if (result)
 162         {
 163                 while (isspace ((int) *cp))
 164                         ++cp;
 165                 vStringClear (name);
 166                 while (isSymbolCharacter ((int) *cp))
 167                 {
 168                         vStringPut (name, *cp);
 169                         ++cp;
 170                 }
 171                 vStringTerminate (name);
 172                 makeSimpleTag (name, AsmKinds, K_DEFINE);
 173         }
 174         vStringDelete (name);
 175         return result;
 176 }
 177
 178 static AsmKind operatorKind (
 179                 const vString *const operator,
 180                 boolean *const found)
 181 {
 182         AsmKind result = K_NONE;
 183         const opKeyword kw = analyzeOperator (operator);
 184         *found = (boolean) (kw != OP_UNDEFINED);
 185         if (*found)
 186         {
 187                 result = OpKinds [kw].kind;
 188                 Assert (OpKinds [kw].keyword == kw);
 189         }
 190         return result;
 191 }
 192
 193 /*  We must check for "DB", "DB.L", "DCB.W" (68000)
 194  */
 195 static boolean isDefineOperator (const vString *const operator)
 196 {
 197         const unsigned char *const op =
 198                 (unsigned char*) vStringValue (operator);
 199         const size_t length = vStringLength (operator);
 200         const boolean result = (boolean) (length > 0  &&
 201                 toupper ((int) *op) == 'D'  &&
 202                 (length == 2 ||
 203                  (length == 4  &&  (int) op [2] == '.') ||
 204                  (length == 5  &&  (int) op [3] == '.')));
 205         return result;
 206 }
 207
 208 static void makeAsmTag (
 209                 const vString *const name,
 210                 const vString *const operator,
 211                 const boolean labelCandidate,
 212                 const boolean nameFollows)
 213 {
 214         if (vStringLength (name) > 0)
 215         {
 216                 boolean found;
 217                 const AsmKind kind = operatorKind (operator, &found);
 218                 if (found)
 219                 {
 220                         if (kind != K_NONE)
 221                                 makeSimpleTag (name, AsmKinds, kind);
 222                 }
 223                 else if (isDefineOperator (operator))
 224                 {
 225                         if (! nameFollows)
 226                                 makeSimpleTag (name, AsmKinds, K_DEFINE);
 227                 }
 228                 else if (labelCandidate)
 229                 {
 230                         operatorKind (name, &found);
 231                         if (! found)
 232                                 makeSimpleTag (name, AsmKinds, K_LABEL);
 233                 }
 234         }
 235 }
 236
 237 static const unsigned char *readSymbol (
 238                 const unsigned char *const start,
 239                 vString *const sym)
 240 {
 241         const unsigned char *cp = start;
 242         vStringClear (sym);
 243         if (isInitialSymbolCharacter ((int) *cp))
 244         {
 245                 while (isSymbolCharacter ((int) *cp))
 246                 {
 247                         vStringPut (sym, *cp);
 248                         ++cp;
 249                 }
 250                 vStringTerminate (sym);
 251         }
 252         return cp;
 253 }
 254
 255 static const unsigned char *readOperator (
 256                 const unsigned char *const start,
 257                 vString *const operator)
 258 {
 259         const unsigned char *cp = start;
 260         vStringClear (operator);
 261         while (*cp != '\0'  &&  ! isspace ((int) *cp))
 262         {
 263                 vStringPut (operator, *cp);
 264                 ++cp;
 265         }
 266         vStringTerminate (operator);
 267         return cp;
 268 }
 269
 270 static void findAsmTags (void)
 271 {
 272         vString *name = vStringNew ();
 273         vString *operator = vStringNew ();
 274         const unsigned char *line;
 275         boolean inCComment = FALSE;
 276
 277         while ((line = fileReadLine ()) != NULL)
 278         {
 279                 const unsigned char *cp = line;
 280                 boolean labelCandidate = (boolean) (! isspace ((int) *cp));
 281                 boolean nameFollows = FALSE;
 282                 const boolean isComment = (boolean)
 283                                 (*cp != '\0' && strchr (";*@", *cp) != NULL);
 284
 285                 /* skip comments */
 286                 if (strncmp ((const char*) cp, "/*", (size_t) 2) == 0)
 287                 {
 288                         inCComment = TRUE;
 289                         cp += 2;
 290                 }
 291                 if (inCComment)
 292                 {
 293                         do
 294                         {
 295                                 if (strncmp ((const char*) cp, "*/", (size_t) 2) == 0)
 296                                 {
 297                                         inCComment = FALSE;
 298                                         cp += 2;
 299                                         break;
 300                                 }
 301                                 ++cp;
 302                         } while (*cp != '\0');
 303                 }
 304                 if (isComment || inCComment)
 305                         continue;
 306
 307                 /* read preprocessor defines */
 308                 if (*cp == '#')
 309                 {
 310                         ++cp;
 311                         readPreProc (cp);
 312                         continue;
 313                 }
 314
 315                 /* skip white space */
 316                 while (isspace ((int) *cp))
 317                         ++cp;
 318
 319                 /* read symbol */
 320                 cp = readSymbol (cp, name);
 321                 if (vStringLength (name) > 0  &&  *cp == ':')
 322                 {
 323                         labelCandidate = TRUE;
 324                         ++cp;
 325                 }
 326
 327                 if (! isspace ((int) *cp)  &&  *cp != '\0')
 328                         continue;
 329
 330                 /* skip white space */
 331                 while (isspace ((int) *cp))
 332                         ++cp;
 333
 334                 /* skip leading dot */
 335 #if 0
 336                 if (*cp == '.')
 337                         ++cp;
 338 #endif
 339
 340                 cp = readOperator (cp, operator);
 341
 342                 /* attempt second read of symbol */
 343                 if (vStringLength (name) == 0)
 344                 {
 345                         while (isspace ((int) *cp))
 346                                 ++cp;
 347                         cp = readSymbol (cp, name);
 348                         nameFollows = TRUE;
 349                 }
 350                 makeAsmTag (name, operator, labelCandidate, nameFollows);
 351         }
 352         vStringDelete (name);
 353         vStringDelete (operator);
 354 }
 355
 356 static void initialize (const langType language)
 357 {
 358         Lang_asm = language;
 359         buildAsmKeywordHash ();
 360 }
 361
 362 extern parserDefinition* AsmParser (void)
 363 {
 364         static const char *const extensions [] = {
 365                 "asm", "ASM", "s", "S", NULL
 366         };
 367         static const char *const patterns [] = {
 368                 "*.A51",
 369                 "*.29[kK]",
 370                 "*.[68][68][kKsSxX]",
 371                 "*.[xX][68][68]",
 372                 NULL
 373         };
 374         parserDefinition* def = parserNew ("Asm");
 375         def->kinds      = AsmKinds;
 376         def->kindCount  = KIND_COUNT (AsmKinds);
 377         def->extensions = extensions;
 378         def->patterns   = patterns;
 379         def->parser     = findAsmTags;
 380         def->initialize = initialize;
 381         return def;
 382 }
 383
 384 /* vi:set tabstop=4 shiftwidth=4: */