git.sur5r.net Git - cc65/blob - src/cc65/datatype.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                datatype.c                                 */
   4 /*                                                                           */
   5 /*               Type string handling for the cc65 C compiler                */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 1998-2004 Ullrich von Bassewitz                                       */
  10 /*               Römerstraße 52                                              */
  11 /*               D-70794 Filderstadt                                         */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <string.h>
  37
  38 /* common */
  39 #include "check.h"
  40 #include "xmalloc.h"
  41
  42 /* cc65 */
  43 #include "codegen.h"
  44 #include "datatype.h"
  45 #include "error.h"
  46 #include "funcdesc.h"
  47 #include "global.h"
  48 #include "util.h"
  49 #include "symtab.h"
  50
  51
  52
  53 /*****************************************************************************/
  54 /*                                   Data                                    */
  55 /*****************************************************************************/
  56
  57
  58
  59 /* Predefined type strings */
  60 type type_uchar []      = { T_UCHAR,    T_END };
  61 type type_int []        = { T_INT,      T_END };
  62 type type_uint []       = { T_UINT,     T_END };
  63 type type_long []       = { T_LONG,     T_END };
  64 type type_ulong []      = { T_ULONG,    T_END };
  65 type type_void []       = { T_VOID,     T_END };
  66 type type_size_t []     = { T_UINT,     T_END };
  67
  68
  69
  70 /*****************************************************************************/
  71 /*                                   Code                                    */
  72 /*****************************************************************************/
  73
  74
  75
  76 unsigned TypeLen (const type* T)
  77 /* Return the length of the type string */
  78 {
  79     const type* Start = T;
  80     while (*T != T_END) {
  81         ++T;
  82     }
  83     return T - Start;
  84 }
  85
  86
  87
  88 type* TypeCpy (type* Dest, const type* Src)
  89 /* Copy a type string */
  90 {
  91     type T;
  92     type* Orig = Dest;
  93     do {
  94         T = *Src++;
  95         *Dest++ = T;
  96     } while (T);
  97     return Orig;
  98 }
  99
 100
 101
 102 type* TypeCat (type* Dest, const type* Src)
 103 /* Append Src */
 104 {
 105     TypeCpy (Dest + TypeLen (Dest), Src);
 106     return Dest;
 107 }
 108
 109
 110
 111 type* TypeDup (const type* T)
 112 /* Create a copy of the given type on the heap */
 113 {
 114     unsigned Len = (TypeLen (T) + 1) * sizeof (type);
 115     return (type*) memcpy (xmalloc (Len), T, Len);
 116 }
 117
 118
 119
 120 type* TypeAlloc (unsigned Len)
 121 /* Allocate memory for a type string of length Len. Len *must* include the
 122  * trailing T_END.
 123  */
 124 {
 125     return (type*) xmalloc (Len * sizeof (type));
 126 }
 127
 128
 129
 130 void TypeFree (type* T)
 131 /* Free a type string */
 132 {
 133     xfree (T);
 134 }
 135
 136
 137
 138 int SignExtendChar (int C)
 139 /* Do correct sign extension of a character */
 140 {
 141     if (IS_Get (&SignedChars) && (C & 0x80) != 0) {
 142         return C | ~0xFF;
 143     } else {
 144         return C & 0xFF;
 145     }
 146 }
 147
 148
 149
 150 type GetDefaultChar (void)
 151 /* Return the default char type (signed/unsigned) depending on the settings */
 152 {
 153     return IS_Get (&SignedChars)? T_SCHAR : T_UCHAR;
 154 }
 155
 156
 157
 158 type* GetCharArrayType (unsigned Len)
 159 /* Return the type for a char array of the given length */
 160 {
 161     /* Allocate memory for the type string */
 162     type* T = TypeAlloc (1 + DECODE_SIZE + 2);
 163
 164     /* Fill the type string */
 165     T [0]             = T_ARRAY;
 166     T [DECODE_SIZE+1] = GetDefaultChar();
 167     T [DECODE_SIZE+2] = T_END;
 168
 169     /* Encode the length in the type string */
 170     Encode (T+1, Len);
 171
 172     /* Return the new type */
 173     return T;
 174 }
 175
 176
 177
 178 type* GetImplicitFuncType (void)
 179 /* Return a type string for an inplicitly declared function */
 180 {
 181     /* Get a new function descriptor */
 182     FuncDesc* F = NewFuncDesc ();
 183
 184     /* Allocate memory for the type string */
 185     type* T = TypeAlloc (1 + DECODE_SIZE + 2);
 186
 187     /* Prepare the function descriptor */
 188     F->Flags  = FD_IMPLICIT | FD_EMPTY | FD_VARIADIC;
 189     F->SymTab = &EmptySymTab;
 190     F->TagTab = &EmptySymTab;
 191
 192     /* Fill the type string */
 193     T [0]             = T_FUNC;
 194     T [DECODE_SIZE+1] = T_INT;
 195     T [DECODE_SIZE+2] = T_END;
 196
 197     /* Encode the function descriptor into the type string */
 198     EncodePtr (T+1, F);
 199
 200     /* Return the new type */
 201     return T;
 202 }
 203
 204
 205
 206 type* PointerTo (const type* T)
 207 /* Return a type string that is "pointer to T". The type string is allocated
 208  * on the heap and may be freed after use.
 209  */
 210 {
 211     /* Get the size of the type string including the terminator */
 212     unsigned Size = TypeLen (T) + 1;
 213
 214     /* Allocate the new type string */
 215     type* P = TypeAlloc (Size + 1);
 216
 217     /* Create the return type... */
 218     P[0] = T_PTR;
 219     memcpy (P+1, T, Size * sizeof (type));
 220
 221     /* ...and return it */
 222     return P;
 223 }
 224
 225
 226
 227 static type PrintTypeComp (FILE* F, type T, type Mask, const char* Name)
 228 /* Check for a specific component of the type. If it is there, print the
 229  * name and remove it. Return the type with the component removed.
 230  */
 231 {
 232     if ((T & Mask) == Mask) {
 233         fprintf (F, "%s ", Name);
 234         T &= ~Mask;
 235     }
 236     return T;
 237 }
 238
 239
 240
 241 void PrintType (FILE* F, const type* Type)
 242 /* Output translation of type array. */
 243 {
 244     type T;
 245     unsigned long Size;
 246
 247     /* Walk over the complete string */
 248     while ((T = *Type++) != T_END) {
 249
 250         /* Print any qualifiers */
 251         T = PrintTypeComp (F, T, T_QUAL_CONST, "const");
 252         T = PrintTypeComp (F, T, T_QUAL_VOLATILE, "volatile");
 253
 254         /* Signedness. Omit the signedness specifier for long and int */
 255         if ((T & T_MASK_TYPE) != T_TYPE_INT && (T & T_MASK_TYPE) != T_TYPE_LONG) {
 256             T = PrintTypeComp (F, T, T_SIGN_SIGNED, "signed");
 257         }
 258         T = PrintTypeComp (F, T, T_SIGN_UNSIGNED, "unsigned");
 259
 260         /* Now check the real type */
 261         switch (T & T_MASK_TYPE) {
 262             case T_TYPE_CHAR:
 263                 fprintf (F, "char");
 264                 break;
 265             case T_TYPE_SHORT:
 266                 fprintf (F, "short");
 267                 break;
 268             case T_TYPE_INT:
 269                 fprintf (F, "int");
 270                 break;
 271             case T_TYPE_LONG:
 272                 fprintf (F, "long");
 273                 break;
 274             case T_TYPE_LONGLONG:
 275                 fprintf (F, "long long");
 276                 break;
 277             case T_TYPE_FLOAT:
 278                 fprintf (F, "float");
 279                 break;
 280             case T_TYPE_DOUBLE:
 281                 fprintf (F, "double");
 282                 break;
 283             case T_TYPE_VOID:
 284                 fprintf (F, "void");
 285                 break;
 286             case T_TYPE_STRUCT:
 287                 fprintf (F, "struct %s", ((SymEntry*) DecodePtr (Type))->Name);
 288                 Type += DECODE_SIZE;
 289                 break;
 290             case T_TYPE_UNION:
 291                 fprintf (F, "union %s", ((SymEntry*) DecodePtr (Type))->Name);
 292                 Type += DECODE_SIZE;
 293                 break;
 294             case T_TYPE_ARRAY:
 295                 /* Recursive call */
 296                 PrintType (F, Type + DECODE_SIZE);
 297                 Size = Decode (Type);
 298                 if (Size == 0) {
 299                     fprintf (F, "[]");
 300                 } else {
 301                     fprintf (F, "[%lu]", Size);
 302                 }
 303                 return;
 304             case T_TYPE_PTR:
 305                 /* Recursive call */
 306                 PrintType (F, Type);
 307                 fprintf (F, "*");
 308                 return;
 309             case T_TYPE_FUNC:
 310                 fprintf (F, "function returning ");
 311                 Type += DECODE_SIZE;
 312                 break;
 313             default:
 314                 fprintf (F, "unknown type: %04X", T);
 315         }
 316
 317     }
 318 }
 319
 320
 321
 322 void PrintFuncSig (FILE* F, const char* Name, type* Type)
 323 /* Print a function signature. */
 324 {
 325     /* Get the function descriptor */
 326     const FuncDesc* D = GetFuncDesc (Type);
 327
 328     /* Print a comment with the function signature */
 329     PrintType (F, GetFuncReturn (Type));
 330     if (D->Flags & FD_NEAR) {
 331         fprintf (F, " __near__");
 332     }
 333     if (D->Flags & FD_FAR) {
 334         fprintf (F, " __far__");
 335     }
 336     if (D->Flags & FD_FASTCALL) {
 337         fprintf (F, " __fastcall__");
 338     }
 339     fprintf (F, " %s (", Name);
 340
 341     /* Parameters */
 342     if (D->Flags & FD_VOID_PARAM) {
 343         fprintf (F, "void");
 344     } else {
 345         unsigned I;
 346         SymEntry* E = D->SymTab->SymHead;
 347         for (I = 0; I < D->ParamCount; ++I) {
 348             if (I > 0) {
 349                 fprintf (F, ", ");
 350             }
 351             if (SymIsRegVar (E)) {
 352                 fprintf (F, "register ");
 353             }
 354             PrintType (F, E->Type);
 355             E = E->NextSym;
 356         }
 357     }
 358
 359     /* End of parameter list */
 360     fprintf (F, ")");
 361 }
 362
 363
 364
 365 void PrintRawType (FILE* F, const type* Type)
 366 /* Print a type string in raw format (for debugging) */
 367 {
 368     while (*Type != T_END) {
 369         fprintf (F, "%04X ", *Type++);
 370     }
 371     fprintf (F, "\n");
 372 }
 373
 374
 375
 376 void Encode (type* Type, unsigned long Val)
 377 /* Encode Val into the given type string */
 378 {
 379     int I;
 380     for (I = 0; I < DECODE_SIZE; ++I) {
 381         *Type++ = ((type) Val) | 0x8000;
 382         Val >>= 15;
 383     }
 384 }
 385
 386
 387
 388 void EncodePtr (type* Type, void* P)
 389 /* Encode a pointer into a type array */
 390 {
 391     Encode (Type, (unsigned long) P);
 392 }
 393
 394
 395
 396 unsigned long Decode (const type* Type)
 397 /* Decode */
 398 {
 399     int I;
 400     unsigned long Val = 0;
 401     for (I = DECODE_SIZE-1; I >= 0; I--) {
 402         Val <<= 15;
 403         Val |= (Type[I] & 0x7FFF);
 404     }
 405     return Val;
 406 }
 407
 408
 409
 410 void* DecodePtr (const type* Type)
 411 /* Decode a pointer from a type array */
 412 {
 413     return (void*) Decode (Type);
 414 }
 415
 416
 417
 418 int HasEncode (const type* Type)
 419 /* Return true if the given type has encoded data */
 420 {
 421     return IsClassStruct (Type) || IsTypeArray (Type) || IsTypeFunc (Type);
 422 }
 423
 424
 425
 426 void CopyEncode (const type* Source, type* Target)
 427 /* Copy encoded data from Source to Target */
 428 {
 429     memcpy (Target, Source, DECODE_SIZE * sizeof (type));
 430 }
 431
 432
 433
 434 unsigned SizeOf (const type* T)
 435 /* Compute size of object represented by type array. */
 436 {
 437     SymEntry* Entry;
 438     long      ElementCount;
 439
 440     switch (UnqualifiedType (T[0])) {
 441
 442         case T_VOID:
 443             return 0;   /* Assume voids have size zero */
 444
 445         case T_SCHAR:
 446         case T_UCHAR:
 447             return SIZEOF_CHAR;
 448
 449         case T_SHORT:
 450         case T_USHORT:
 451             return SIZEOF_SHORT;
 452
 453         case T_INT:
 454         case T_UINT:
 455             return SIZEOF_INT;
 456
 457         case T_PTR:
 458         case T_FUNC:    /* Maybe pointer to function */
 459             return SIZEOF_PTR;
 460
 461         case T_LONG:
 462         case T_ULONG:
 463             return SIZEOF_LONG;
 464
 465         case T_LONGLONG:
 466         case T_ULONGLONG:
 467             return SIZEOF_LONGLONG;
 468
 469         case T_ENUM:
 470             return SIZEOF_INT;
 471
 472         case T_FLOAT:
 473             return SIZEOF_FLOAT;
 474
 475         case T_DOUBLE:
 476             return SIZEOF_DOUBLE;
 477
 478         case T_STRUCT:
 479         case T_UNION:
 480             Entry = DecodePtr (T+1);
 481             return Entry->V.S.Size;
 482
 483         case T_ARRAY:
 484             ElementCount = GetElementCount (T);
 485             if (ElementCount < 0) {
 486                 /* Array with unspecified size */
 487                 return 0;
 488             } else {
 489                 return ElementCount * SizeOf (T + DECODE_SIZE + 1);
 490             }
 491
 492         default:
 493             Internal ("Unknown type in SizeOf: %04X", *T);
 494             return 0;
 495
 496     }
 497 }
 498
 499
 500
 501 unsigned PSizeOf (const type* T)
 502 /* Compute size of pointer object. */
 503 {
 504     /* We are expecting a pointer expression */
 505     CHECK ((T[0] & T_MASK_CLASS) == T_CLASS_PTR);
 506
 507     /* Skip the pointer or array token itself */
 508     if (IsTypeArray (T)) {
 509         return SizeOf (T + DECODE_SIZE + 1);
 510     } else {
 511         return SizeOf (T + 1);
 512     }
 513 }
 514
 515
 516
 517 unsigned CheckedSizeOf (const type* T)
 518 /* Return the size of a data type. If the size is zero, emit an error and
 519  * return some valid size instead (so the rest of the compiler doesn't have
 520  * to work with invalid sizes).
 521  */
 522 {
 523     unsigned Size = SizeOf (T);
 524     if (Size == 0) {
 525         Error ("Size of data type is unknown");
 526         Size = SIZEOF_CHAR;     /* Don't return zero */
 527     }
 528     return Size;
 529 }
 530
 531
 532
 533 unsigned CheckedPSizeOf (const type* T)
 534 /* Return the size of a data type that is pointed to by a pointer. If the
 535  * size is zero, emit an error and return some valid size instead (so the
 536  * rest of the compiler doesn't have to work with invalid sizes).
 537  */
 538 {
 539     unsigned Size = PSizeOf (T);
 540     if (Size == 0) {
 541         Error ("Size of data type is unknown");
 542         Size = SIZEOF_CHAR;     /* Don't return zero */
 543     }
 544     return Size;
 545 }
 546
 547
 548
 549 unsigned TypeOf (const type* T)
 550 /* Get the code generator base type of the object */
 551 {
 552     FuncDesc* F;
 553
 554     switch (UnqualifiedType (T[0])) {
 555
 556         case T_SCHAR:
 557             return CF_CHAR;
 558
 559         case T_UCHAR:
 560             return CF_CHAR | CF_UNSIGNED;
 561
 562         case T_SHORT:
 563         case T_INT:
 564         case T_ENUM:
 565             return CF_INT;
 566
 567         case T_USHORT:
 568         case T_UINT:
 569         case T_PTR:
 570         case T_ARRAY:
 571             return CF_INT | CF_UNSIGNED;
 572
 573         case T_LONG:
 574             return CF_LONG;
 575
 576         case T_ULONG:
 577             return CF_LONG | CF_UNSIGNED;
 578
 579         case T_FLOAT:
 580         case T_DOUBLE:
 581             /* These two are identical in the backend */
 582             return CF_FLOAT;
 583
 584         case T_FUNC:
 585             F = DecodePtr (T+1);
 586             return (F->Flags & FD_VARIADIC)? 0 : CF_FIXARGC;
 587
 588         case T_STRUCT:
 589         case T_UNION:
 590             /* Address of ... */
 591             return CF_INT | CF_UNSIGNED;
 592
 593         default:
 594             Error ("Illegal type");
 595             return CF_INT;
 596     }
 597 }
 598
 599
 600
 601 type* Indirect (type* T)
 602 /* Do one indirection for the given type, that is, return the type where the
 603  * given type points to.
 604  */
 605 {
 606     /* We are expecting a pointer expression */
 607     CHECK ((T[0] & T_MASK_CLASS) == T_CLASS_PTR);
 608
 609     /* Skip the pointer or array token itself */
 610     if (IsTypeArray (T)) {
 611         return T + DECODE_SIZE + 1;
 612     } else {
 613         return T + 1;
 614     }
 615 }
 616
 617
 618
 619 type* ArrayToPtr (const type* T)
 620 /* Convert an array to a pointer to it's first element */
 621 {
 622     /* Function must only be called for an array */
 623     CHECK ((T[0] & T_MASK_TYPE) == T_TYPE_ARRAY);
 624
 625     /* Return pointer to first element */
 626     return PointerTo (T + DECODE_SIZE + 1);
 627 }
 628
 629
 630
 631 int IsClassInt (const type* T)
 632 /* Return true if this is an integer type */
 633 {
 634     return (T[0] & T_MASK_CLASS) == T_CLASS_INT;
 635 }
 636
 637
 638
 639 int IsClassFloat (const type* T)
 640 /* Return true if this is a float type */
 641 {
 642     return (T[0] & T_MASK_CLASS) == T_CLASS_FLOAT;
 643 }
 644
 645
 646
 647 int IsClassPtr (const type* T)
 648 /* Return true if this is a pointer type */
 649 {
 650     return (T[0] & T_MASK_CLASS) == T_CLASS_PTR;
 651 }
 652
 653
 654
 655 int IsClassStruct (const type* T)
 656 /* Return true if this is a struct type */
 657 {
 658     return (T[0] & T_MASK_CLASS) == T_CLASS_STRUCT;
 659 }
 660
 661
 662
 663 int IsSignUnsigned (const type* T)
 664 /* Return true if this is an unsigned type */
 665 {
 666     return (T[0] & T_MASK_SIGN) == T_SIGN_UNSIGNED;
 667 }
 668
 669
 670
 671 int IsQualConst (const type* T)
 672 /* Return true if the given type has a const memory image */
 673 {
 674     return (GetQualifier (T) & T_QUAL_CONST) != 0;
 675 }
 676
 677
 678
 679 int IsQualVolatile (const type* T)
 680 /* Return true if the given type has a volatile type qualifier */
 681 {
 682     return (GetQualifier (T) & T_QUAL_VOLATILE) != 0;
 683 }
 684
 685
 686
 687 int IsFastCallFunc (const type* T)
 688 /* Return true if this is a function type or pointer to function with
 689  * __fastcall__ calling conventions
 690  */
 691 {
 692     FuncDesc* F = GetFuncDesc (T);
 693     return (F->Flags & FD_FASTCALL) != 0;
 694 }
 695
 696
 697
 698 int IsVariadicFunc (const type* T)
 699 /* Return true if this is a function type or pointer to function type with
 700  * variable parameter list
 701  */
 702 {
 703     FuncDesc* F = GetFuncDesc (T);
 704     return (F->Flags & FD_VARIADIC) != 0;
 705 }
 706
 707
 708
 709 type GetQualifier (const type* T)
 710 /* Get the qualifier from the given type string */
 711 {
 712     /* If this is an array, look at the element type, otherwise look at the
 713      * type itself.
 714      */
 715     if (IsTypeArray (T)) {
 716         T += DECODE_SIZE + 1;
 717     }
 718     return (T[0] & T_QUAL_CONST);
 719 }
 720
 721
 722
 723 FuncDesc* GetFuncDesc (const type* T)
 724 /* Get the FuncDesc pointer from a function or pointer-to-function type */
 725 {
 726     if (UnqualifiedType (T[0]) == T_PTR) {
 727         /* Pointer to function */
 728         ++T;
 729     }
 730
 731     /* Be sure it's a function type */
 732     CHECK (T[0] == T_FUNC);
 733
 734     /* Decode the function descriptor and return it */
 735     return DecodePtr (T+1);
 736 }
 737
 738
 739
 740 type* GetFuncReturn (type* T)
 741 /* Return a pointer to the return type of a function or pointer-to-function type */
 742 {
 743     if (UnqualifiedType (T[0]) == T_PTR) {
 744         /* Pointer to function */
 745         ++T;
 746     }
 747
 748     /* Be sure it's a function type */
 749     CHECK (T[0] == T_FUNC);
 750
 751     /* Return a pointer to the return type */
 752     return T + 1 + DECODE_SIZE;
 753
 754 }
 755
 756
 757
 758 long GetElementCount (const type* T)
 759 /* Get the element count of the array specified in T (which must be of
 760  * array type).
 761  */
 762 {
 763     CHECK (IsTypeArray (T));
 764     return (unsigned) Decode (T+1);
 765 }
 766
 767
 768
 769 type* GetElementType (type* T)
 770 /* Return the element type of the given array type. */
 771 {
 772     CHECK (IsTypeArray (T));
 773     return T + DECODE_SIZE + 1;
 774 }
 775
 776
 777