type.c

一个编译器修改的例子

#include "error.h"
#include "salloc.h"
#include "type.h"
#include <string.h>
#include <assert.h>
#include "statement.h"


Type *new_simple_type(Type_subtype subtype)
{
    Type *type		= safe_malloc(sizeof(Type));

    type->subtype	= subtype;
    type->ref_count	= 1;
    type->call_by_ref	= false;

    return type;
}


Type *new_array_type(Type *base_type)
{
    Type *type			= safe_malloc(sizeof(Type));

    type->subtype		= array_type;
    type->ref_count		= 1;
    type->call_by_ref		= false;
    ARRAY_TYPE(type).base_type	= base_type;

    return type;
}


Type *new_null_type(Type *base_type)
{
    Type *type			= safe_malloc(sizeof(Type));

    type->subtype		= null_type;
    type->ref_count		= 1;
    type->call_by_ref		= false;

    return type;
}


Type *new_subprog_type(Declaration *decl)
{
    Type *type			= safe_malloc(sizeof(Type));

    type->subtype		= subprog_type;
    type->ref_count		= 1;
    type->call_by_ref		= false;
    SUBPROG_TYPE(type).decl	= decl;

    return type;
}

Type *new_record_type(Declaration *decl)
{
    Type *type			= safe_malloc(sizeof(Type));
	
    type->subtype		= record_type;
    type->ref_count		= 1;
    type->call_by_ref		= false;
    RECORD_TYPE(type).decl	= decl;
	
    return type;
}

void inc_ref_count(Type *type, int n)
{
    if (type != 0)
	type->ref_count += n;
}


void delete_type(Type *type)
{
    if (type != 0 && -- type->ref_count == 0)
    {
	switch (type->subtype)
	{
	    case array_type:
		delete_type(ARRAY_TYPE(type).base_type);
		break;

	    default:
		break;
	}

	free(type);
    }
}


Bool types_compatible(const Type *t1, const Type *t2)
{
    if (t1 == 0 || t2 == 0)
	return t1 == t2;

    switch (t1->subtype)
    {
	case array_type:
	     return t2->subtype == null_type ||
		    (t2->subtype == array_type && types_compatible(
		    ARRAY_TYPE(t1).base_type, ARRAY_TYPE(t2).base_type));

	case null_type:
	     return (t2->subtype & reference_type) != 0;

	case subprog_type:
		#ifdef DEBUG
		printf(" were in a subprog_type now\n");
		#endif
		if (t2->subtype == record_type)
		{
			printf("%s:%d a function call is not an lvalue\n",RECORD_TYPE(t2).decl->token->file_name,RECORD_TYPE(t2).decl->token->line_number);
			return false;
		}
			
		
	/* edited ERICK */
	case record_type:
#ifdef DEBUG
		printf("  (t2->subtype == record_type) = %d	 strcmp != %d\n",(t2->subtype == record_type),(strcmp(RECORD_TYPE(t2).decl->token->name,RECORD_TYPE(t1).decl->token->name) ==0) );
#endif
		return (t2->subtype == record_type) && (strcmp(RECORD_TYPE(t2).decl->token->name,RECORD_TYPE(t1).decl->token->name) == 0);
		
		
	default:
	     return t1->subtype == t2->subtype;
    }
}


void generate_type(FILE *file, Type *type)
{
	Declaration *declTemp;
	Type *tempType;
    switch (type->subtype)
    {
		case record_type:
			
			declTemp= (Declaration *)(RECORD_TYPE(type).decl);
			tempType = (Type *)(RECORD_DECL(declTemp).type);
			fprintf(file,"record_%s",declTemp->token->name);
			#ifdef DEBUG
			printf("record_%s",declTemp->token->name);
			#endif
			break;
			
		case char_type:
			fprintf(file, "char");
			#ifdef DEBUG
			printf("char");
			#endif
			break;

		case bool_type:
		case int_type:
			fprintf(file, "int"); 
			#ifdef DEBUG
			printf("int");
			#endif
			break;

		case real_type:
			fprintf(file, "double"); 
			#ifdef DEBUG
			printf("double");
			#endif
			break;

		case array_type:
			fprintf(file, "array");
			#ifdef DEBUG
			printf("array");
			#endif
			break;

		case void_type:
			fprintf(file, "void");
			#ifdef DEBUG
			printf("void");
			#endif
			break;

		default:
			assert(false);
    }

    if (type->call_by_ref)
	{
		putc('*', file);
		#ifdef DEBUG
		printf("*");
		#endif
	}
}