1 /*****************************************************************************/
5 /* Type string handling for the cc65 C compiler */
9 /* (C) 1998-2002 Ullrich von Bassewitz */
11 /* D-70597 Stuttgart */
12 /* EMail: uz@musoftware.de */
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. */
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: */
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 */
32 /*****************************************************************************/
53 /*****************************************************************************/
55 /*****************************************************************************/
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 };
70 /*****************************************************************************/
72 /*****************************************************************************/
76 unsigned TypeLen (const type* T)
77 /* Return the length of the type string */
79 const type* Start = T;
88 type* TypeCpy (type* Dest, const type* Src)
89 /* Copy a type string */
102 type* TypeCat (type* Dest, const type* Src)
105 TypeCpy (Dest + TypeLen (Dest), Src);
111 type* TypeDup (const type* T)
112 /* Create a copy of the given type on the heap */
114 unsigned Len = (TypeLen (T) + 1) * sizeof (type);
115 return (type*) memcpy (xmalloc (Len), T, Len);
120 type* TypeAlloc (unsigned Len)
121 /* Allocate memory for a type string of length Len. Len *must* include the
125 return (type*) xmalloc (Len * sizeof (type));
130 void TypeFree (type* T)
131 /* Free a type string */
138 int SignExtendChar (int C)
139 /* Do correct sign extension of a character */
141 if (SignedChars && (C & 0x80) != 0) {
150 type GetDefaultChar (void)
151 /* Return the default char type (signed/unsigned) depending on the settings */
153 return SignedChars? T_SCHAR : T_UCHAR;
158 type* GetCharArrayType (unsigned Len)
159 /* Return the type for a char array of the given length */
161 /* Allocate memory for the type string */
162 type* T = TypeAlloc (1 + DECODE_SIZE + 2);
164 /* Fill the type string */
166 T [DECODE_SIZE+1] = GetDefaultChar();
167 T [DECODE_SIZE+2] = T_END;
169 /* Encode the length in the type string */
172 /* Return the new type */
178 type* GetImplicitFuncType (void)
179 /* Return a type string for an inplicitly declared function */
181 /* Get a new function descriptor */
182 FuncDesc* F = NewFuncDesc ();
184 /* Allocate memory for the type string */
185 type* T = TypeAlloc (1 + DECODE_SIZE + 2);
187 /* Prepare the function descriptor */
188 F->Flags = FD_IMPLICIT | FD_EMPTY | FD_VARIADIC;
189 F->SymTab = &EmptySymTab;
190 F->TagTab = &EmptySymTab;
192 /* Fill the type string */
194 T [DECODE_SIZE+1] = T_INT;
195 T [DECODE_SIZE+2] = T_END;
197 /* Encode the function descriptor into the type string */
200 /* Return the new type */
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.
211 /* Get the size of the type string including the terminator */
212 unsigned Size = TypeLen (T) + 1;
214 /* Allocate the new type string */
215 type* P = TypeAlloc (Size + 1);
217 /* Create the return type... */
219 memcpy (P+1, T, Size * sizeof (type));
221 /* ...and return it */
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.
232 if ((T & Mask) == Mask) {
233 fprintf (F, "%s ", Name);
241 void PrintType (FILE* F, const type* Type)
242 /* Output translation of type array. */
247 /* Walk over the complete string */
248 while ((T = *Type++) != T_END) {
250 /* Print any qualifiers */
251 T = PrintTypeComp (F, T, T_QUAL_CONST, "const");
252 T = PrintTypeComp (F, T, T_QUAL_VOLATILE, "volatile");
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");
258 T = PrintTypeComp (F, T, T_SIGN_UNSIGNED, "unsigned");
260 /* Now check the real type */
261 switch (T & T_MASK_TYPE) {
266 fprintf (F, "short");
274 case T_TYPE_LONGLONG:
275 fprintf (F, "long long");
278 fprintf (F, "float");
281 fprintf (F, "double");
287 fprintf (F, "struct %s", ((SymEntry*) DecodePtr (Type))->Name);
291 fprintf (F, "union %s", ((SymEntry*) DecodePtr (Type))->Name);
296 PrintType (F, Type + DECODE_SIZE);
297 Size = Decode (Type);
301 fprintf (F, "[%lu]", Size);
310 fprintf (F, "function returning ");
314 fprintf (F, "unknown type: %04X", T);
322 void PrintFuncSig (FILE* F, const char* Name, type* Type)
323 /* Print a function signature. */
325 /* Get the function descriptor */
326 const FuncDesc* D = GetFuncDesc (Type);
328 /* Print a comment with the function signature */
329 PrintType (F, GetFuncReturn (Type));
330 if (D->Flags & FD_FASTCALL) {
331 fprintf (F, " __fastcall__");
333 fprintf (F, " %s (", Name);
336 if (D->Flags & FD_VOID_PARAM) {
340 SymEntry* E = D->SymTab->SymHead;
341 for (I = 0; I < D->ParamCount; ++I) {
345 if (SymIsRegVar (E)) {
346 fprintf (F, "register ");
348 PrintType (F, E->Type);
353 /* End of parameter list */
359 void PrintRawType (FILE* F, const type* Type)
360 /* Print a type string in raw format (for debugging) */
362 while (*Type != T_END) {
363 fprintf (F, "%04X ", *Type++);
370 void Encode (type* Type, unsigned long Val)
371 /* Encode p[0] and p[1] so that neither p[0] nore p[1] is zero */
374 for (I = 0; I < DECODE_SIZE; ++I) {
375 *Type++ = ((type) Val) | 0x8000;
382 void EncodePtr (type* Type, void* P)
383 /* Encode a pointer into a type array */
385 Encode (Type, (unsigned long) P);
390 unsigned long Decode (const type* Type)
394 unsigned long Val = 0;
395 for (I = DECODE_SIZE-1; I >= 0; I--) {
397 Val |= (Type[I] & 0x7FFF);
404 void* DecodePtr (const type* Type)
405 /* Decode a pointer from a type array */
407 return (void*) Decode (Type);
412 int HasEncode (const type* Type)
413 /* Return true if the given type has encoded data */
415 return IsClassStruct (Type) || IsTypeArray (Type) || IsTypeFunc (Type);
420 void CopyEncode (const type* Source, type* Target)
421 /* Copy encoded data from Source to Target */
423 memcpy (Target, Source, DECODE_SIZE * sizeof (type));
428 unsigned SizeOf (const type* T)
429 /* Compute size of object represented by type array. */
433 switch (UnqualifiedType (T[0])) {
436 return 0; /* Assume voids have size zero */
451 case T_FUNC: /* Maybe pointer to function */
460 return SIZEOF_LONGLONG;
469 return SIZEOF_DOUBLE;
473 Entry = (SymEntry*) DecodePtr (T+1);
474 return Entry->V.S.Size;
477 return (Decode (T+ 1) * SizeOf (T + DECODE_SIZE + 1));
480 Internal ("Unknown type in SizeOf: %04X", *T);
488 unsigned PSizeOf (const type* T)
489 /* Compute size of pointer object. */
491 /* We are expecting a pointer expression */
492 CHECK ((T[0] & T_MASK_CLASS) == T_CLASS_PTR);
494 /* Skip the pointer or array token itself */
495 if (IsTypeArray (T)) {
496 return SizeOf (T + DECODE_SIZE + 1);
498 return SizeOf (T + 1);
504 unsigned CheckedSizeOf (const type* T)
505 /* Return the size of a data type. If the size is zero, emit an error and
506 * return some valid size instead (so the rest of the compiler doesn't have
507 * to work with invalid sizes).
510 unsigned Size = SizeOf (T);
512 Error ("Size of data type is unknown");
513 Size = SIZEOF_CHAR; /* Don't return zero */
520 unsigned CheckedPSizeOf (const type* T)
521 /* Return the size of a data type that is pointed to by a pointer. If the
522 * size is zero, emit an error and return some valid size instead (so the
523 * rest of the compiler doesn't have to work with invalid sizes).
526 unsigned Size = PSizeOf (T);
528 Error ("Size of data type is unknown");
529 Size = SIZEOF_CHAR; /* Don't return zero */
536 unsigned TypeOf (const type* T)
537 /* Get the code generator base type of the object */
541 switch (UnqualifiedType (T[0])) {
547 return CF_CHAR | CF_UNSIGNED;
558 return CF_INT | CF_UNSIGNED;
564 return CF_LONG | CF_UNSIGNED;
567 F = (FuncDesc*) DecodePtr (T+1);
568 return (F->Flags & FD_VARIADIC)? 0 : CF_FIXARGC;
573 return CF_INT | CF_UNSIGNED;
576 Error ("Illegal type");
583 type* Indirect (type* T)
584 /* Do one indirection for the given type, that is, return the type where the
585 * given type points to.
588 /* We are expecting a pointer expression */
589 CHECK ((T[0] & T_MASK_CLASS) == T_CLASS_PTR);
591 /* Skip the pointer or array token itself */
592 if (IsTypeArray (T)) {
593 return T + DECODE_SIZE + 1;
601 int IsClassInt (const type* T)
602 /* Return true if this is an integer type */
604 return (T[0] & T_MASK_CLASS) == T_CLASS_INT;
609 int IsClassFloat (const type* T)
610 /* Return true if this is a float type */
612 return (T[0] & T_MASK_CLASS) == T_CLASS_FLOAT;
617 int IsClassPtr (const type* T)
618 /* Return true if this is a pointer type */
620 return (T[0] & T_MASK_CLASS) == T_CLASS_PTR;
625 int IsClassStruct (const type* T)
626 /* Return true if this is a struct type */
628 return (T[0] & T_MASK_CLASS) == T_CLASS_STRUCT;
633 int IsSignUnsigned (const type* T)
634 /* Return true if this is an unsigned type */
636 return (T[0] & T_MASK_SIGN) == T_SIGN_UNSIGNED;
641 int IsQualConst (const type* T)
642 /* Return true if the given type has a const memory image */
644 return (GetQualifier (T) & T_QUAL_CONST) != 0;
649 int IsQualVolatile (const type* T)
650 /* Return true if the given type has a volatile type qualifier */
652 return (GetQualifier (T) & T_QUAL_VOLATILE) != 0;
657 int IsFastCallFunc (const type* T)
658 /* Return true if this is a function type or pointer to function with
659 * __fastcall__ calling conventions
662 FuncDesc* F = GetFuncDesc (T);
663 return (F->Flags & FD_FASTCALL) != 0;
668 int IsVariadicFunc (const type* T)
669 /* Return true if this is a function type or pointer to function type with
670 * variable parameter list
673 FuncDesc* F = GetFuncDesc (T);
674 return (F->Flags & FD_VARIADIC) != 0;
679 type GetQualifier (const type* T)
680 /* Get the qualifier from the given type string */
682 /* If this is an array, look at the element type, otherwise look at the
685 if (IsTypeArray (T)) {
686 T += DECODE_SIZE + 1;
688 return (T[0] & T_QUAL_CONST);
693 FuncDesc* GetFuncDesc (const type* T)
694 /* Get the FuncDesc pointer from a function or pointer-to-function type */
696 if (UnqualifiedType (T[0]) == T_PTR) {
697 /* Pointer to function */
701 /* Be sure it's a function type */
702 CHECK (T[0] == T_FUNC);
704 /* Decode the function descriptor and return it */
705 return (FuncDesc*) DecodePtr (T+1);
710 type* GetFuncReturn (type* T)
711 /* Return a pointer to the return type of a function or pointer-to-function type */
713 if (UnqualifiedType (T[0]) == T_PTR) {
714 /* Pointer to function */
718 /* Be sure it's a function type */
719 CHECK (T[0] == T_FUNC);
721 /* Return a pointer to the return type */
722 return T + 1 + DECODE_SIZE;