// -*- mode: java; c-basic-offset: 4 -*-
//
// Copyright 2001-2002 by the Regents of the University of California.
// All rights reserved.
//
// HARMONIA: C language module type checking
//
// RCS Info: $Revision: 1.1 $ on $Date: 2003/05/12 01:49:33 $
// $Source: /home/cs/harmonia/cvsroot/www/harmonia/projects/langs/c/c-typecheck.def,v $
//
// Not usable yet, alas:
// -*- mode: harmonia-astdef2; c-basic-offset: 4 -*-
import "Node.def";
import "ParentNode.def";
import "ListNode.def";
import "AmbigNode.def";
import "GLRStateMixin.def";
include "common/stl.h"
include "common/PooledString.h"
include "lk/node/UltraRoot.h"
include "c.h"
phylum trans_unit {
public virtual method void check_types(TypecheckContext *ctx) {
}
}
// trans_unit -> SeqR0E0star:ext_decls
operator TranslationUnit extends trans_unit {
public virtual method void check_types(TypecheckContext *ctx) {
for (ext_decls_iterator i = get_ext_decls(); i; ++i)
i.get_ext_decl()->check_types(ctx);
}
}
operator no_trans_unit extends trans_unit {
}
operator trans_unit_sym extends trans_unit {
public virtual method void check_types(TypecheckContext *ctx) {
trans_unit::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum ext_decl {
public virtual method void check_types(TypecheckContext *ctx) {
}
}
// ext_decl -> SeqR1E0star:specs declr:declr SeqR1E2star:decls comp_stmt:body
operator FunctionDefinition extends ext_decl {
public virtual method void check_types(TypecheckContext *ctx) {
decl::TypeInfo base_type_info;
for (specs_iterator i = get_specs(); i; ++i)
i.get_spec()->check_types(ctx);
for (specs_iterator i = get_specs(); i; ++i)
i.get_spec()->specify(ctx, &base_type_info);
CType *base_type = decl::assemble_base_type(ctx, this,
&base_type_info);
CType *maybe_func_type = get_declr()->build_type(ctx, base_type);
if (!maybe_func_type->is_function()) {
set_semant_error(this, "Function definition must have "
"function type, not %s",
maybe_func_type->name().c_str());
return;
}
FunctionType *func_type = (FunctionType *)maybe_func_type;
CType *ret_type = func_type->return_type;
Localizer<CType *> save(&ctx->return_type);
ctx->return_type = ret_type;
get_body()->check_types(ctx);
}
}
// ext_decl -> decl:decl
operator OtherExtDeclaration extends ext_decl {
public virtual method void check_types(TypecheckContext *ctx) {
get_decl()->check_types(ctx);
}
}
operator no_ext_decl extends ext_decl {
}
operator ext_decl_sym extends ext_decl {
public virtual method void check_types(TypecheckContext *ctx) {
ext_decl::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum decl_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {}
public virtual method void check_types(TypecheckContext *ctx) {}
}
// decl_spec -> stor_class_spec:spec
operator StorageDeclSpec extends decl_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
get_spec()->specify(ctx, base_info);
}
}
// decl_spec -> type_spec:spec
operator TypeSpecDeclSpec extends decl_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
get_spec()->specify(ctx, base_info);
}
public virtual method void check_types(TypecheckContext *ctx) {
get_spec()->check_types(ctx);
}
}
// decl_spec -> type_qual:qual
operator TypeQualDeclSpec extends decl_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
get_qual()->specify(base_info);
}
}
// decl_spec -> INLINE:qual
operator FunctionQualDeclSpec extends decl_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
// base_info->is_inline = true;
}
}
operator no_decl_spec extends decl_spec {
}
operator decl_spec_sym extends decl_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
decl_spec::phylum_cast(primary_alternative())->specify(ctx, base_info);
}
public virtual method void check_types(TypecheckContext *ctx) {
decl_spec::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return base_type;
}
}
// declr -> OptR46E0:ptr direct_declr:direct
operator Declarator extends declr {
public slot CType *c_type;
versioned Semantics attribute type_name
= TypedVal(c_type ? strdup(c_type->name().c_str()) : "null");
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
CType *type = base_type;
if (has_ptr())
type = get_ptr_ptr()->point_to(ctx, type);
type = get_direct()->build_type(ctx, type);
Declarator *link = (Declarator *)linkage_link.value();
if (link) {
CType *comp = CType::composite_type(link->c_type, type);
if (!comp)
set_semant_error(this, "Identifier redefined with "
"incompatible type %s (was %s)",
type->name().c_str(),
link->c_type->name().c_str());
else
type = comp;
} else if (decl_context == KnR_PARAM || decl_context == DEF_PARAM
|| decl_context == DECL_PARAM) {
type = type->param_adjust();
}
c_type = type;
return type;
}
}
operator no_declr extends declr {
}
operator declr_sym extends declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return declr::phylum_cast(primary_alternative())
->build_type(ctx, base_type);
}
}
phylum decl {
public enum TypeBits {
VOID = 1,
CHAR = 2,
SHORT = 4,
INT = 8,
LONG = 16,
LONG_LONG = 32,
FLOAT = 64,
DOUBLE = 128,
SIGNED = 256,
UNSIGNED = 512,
_BOOL = 1024,
_COMPLEX = 2048,
_IMAGINARY = 4096,
STRUCT_UNION_ENUM = 8192,
TYPEDEF_NAME = 16384,
TYPEDEF_TYPEDEF = 32768
};
public enum AggrDeclType {
NO_AGGREGATE,
AGGREGATE_REF,
AGGREGATE_DEF
};
public struct TypeInfo : public Collectable {
StorageClass storage;
int spec_bits;
AggrDeclType aggregate;
unsigned int /* Qualifiers */ quals;
CType *specified_type;
TypeInfo() : storage(NO_STORAGE), spec_bits(0),
aggregate(NO_AGGREGATE), quals(0), specified_type(0) {}
}
public virtual method void check_types(TypecheckContext *ctx) {
}
public static method CType *assemble_base_type(TypecheckContext *ctx,
Node *node,
TypeInfo *info) {
CType *base_type;
if (info->spec_bits & (_COMPLEX|_IMAGINARY) &&
!(info->spec_bits & (FLOAT|DOUBLE)))
set_semant_error(node, "Only floating-point types can be "
"'_Complex' or '_Imaginary'");
if (info->spec_bits & VOID) {
base_type = &ctx->the_VoidType;
} else if (info->spec_bits & CHAR) {
if (info->spec_bits & SIGNED)
base_type = &ctx->the_SignedCharType;
else if (info->spec_bits & UNSIGNED)
base_type = &ctx->the_UnsignedCharType;
else
base_type = &ctx->the_PlainCharType;
} else if (info->spec_bits & SHORT) {
if (info->spec_bits & UNSIGNED)
base_type = &ctx->the_UnsignedShortType;
else
base_type = &ctx->the_ShortIntType;
} else if (info->spec_bits & FLOAT) {
if (info->spec_bits & _COMPLEX)
base_type = &ctx->the_ComplexFloatType;
else if (info->spec_bits & _IMAGINARY)
base_type = &ctx->the_ImaginaryFloatType;
else
base_type = &ctx->the_FloatType;
} else if (info->spec_bits & DOUBLE) {
if (info->spec_bits & LONG) {
if (info->spec_bits & _COMPLEX)
base_type = &ctx->the_ComplexLongDoubleType;
else if (info->spec_bits & _IMAGINARY)
base_type = &ctx->the_ImaginaryLongDoubleType;
else
base_type = &ctx->the_LongDoubleType;
} else {
if (info->spec_bits & _COMPLEX)
base_type = &ctx->the_ComplexDoubleType;
else if (info->spec_bits & _IMAGINARY)
base_type = &ctx->the_ImaginaryDoubleType;
else
base_type = &ctx->the_DoubleType;
}
} else if (info->spec_bits & LONG_LONG) {
if (info->spec_bits & UNSIGNED)
base_type = &ctx->the_UnsignedLongLongType;
else
base_type = &ctx->the_LongLongIntType;
} else if (info->spec_bits & LONG) {
if (info->spec_bits & UNSIGNED)
base_type = &ctx->the_UnsignedLongType;
else
base_type = &ctx->the_LongIntType;
} else if (info->spec_bits & INT) {
if (info->spec_bits & UNSIGNED)
base_type = &ctx->the_UnsignedIntType;
else
base_type = &ctx->the_SignedIntType; // XXX bitfields
} else if (info->spec_bits & _BOOL) {
base_type = &ctx->the_BoolType;
} else if (info->spec_bits & UNSIGNED) {
base_type = &ctx->the_UnsignedIntType;
} else if (info->spec_bits & SIGNED) {
base_type = &ctx->the_SignedIntType;
} else if (info->spec_bits & TYPEDEF_NAME) {
if (info->specified_type)
base_type = info->specified_type;
else {
set_semant_error(node, "Undefined typename");
base_type = &ctx->the_UnimplementedType;
}
} else if (info->spec_bits & STRUCT_UNION_ENUM) {
if (info->specified_type)
base_type = info->specified_type;
else {
base_type = &ctx->the_UnimplementedType;
}
} else if (info->spec_bits) {
base_type = &ctx->the_UnimplementedType;
} else {
set_semant_error(node, "C99 forbids a declaration with no type");
base_type = &ctx->the_SignedIntType;
}
base_type = base_type->qualified_by(info->quals);
return base_type;
}
}
// decl -> SeqR1E0star:specs SeqR7E1star:declrs SEMI
operator Declaration extends decl {
public virtual method void check_types(TypecheckContext *ctx) {
TypeInfo base_type_info;
for (specs_iterator i = get_specs(); i; ++i)
i.get_spec()->check_types(ctx);
for (specs_iterator i = get_specs(); i; ++i)
i.get_spec()->specify(ctx, &base_type_info);
CType *base_type = assemble_base_type(ctx, this, &base_type_info);
//string msg = "Base type: " + base_type->name();
//set_string_prop(MOUSE_OVER_MSG, msg.c_str());
//compute_synth_attrs(true);
bool has_declrs = get_declrs();
if (base_type_info.aggregate == NO_AGGREGATE && !has_declrs)
set_semant_error(this, "Declaration declares neither an aggregate"
" nor any declarators");
for (declrs_iterator i = get_declrs(); i; ++i)
i.get_declr()->check_types(ctx, base_type);
}
}
operator no_decl extends decl {
}
operator decl_sym extends decl {
public virtual method void check_types(TypecheckContext *ctx) {
decl::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum comp_stmt {
public virtual method void check_types(TypecheckContext *ctx) {
}
}
// comp_stmt -> LBRACE SeqR87E1star:items RBRACE
operator BlockStatement extends comp_stmt {
public virtual method void check_types(TypecheckContext *ctx) {
for (items_iterator i = get_items(); i; ++i)
i.get_item_()->check_types(ctx);
}
}
operator no_comp_stmt extends comp_stmt {
}
operator comp_stmt_sym extends comp_stmt {
public virtual method void check_types(TypecheckContext *ctx) {
comp_stmt::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum stor_class_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
}
}
// stor_class_spec -> AUTO
operator AutoStrClassSpec extends stor_class_spec {
}
// stor_class_spec -> REGISTER
operator RegisterStrClassSpec extends stor_class_spec {
}
// stor_class_spec -> STATIC
operator StaticStrClassSpec extends stor_class_spec {
}
// stor_class_spec -> EXTERN
operator ExternStrClassSpec extends stor_class_spec {
}
// stor_class_spec -> TYPEDEF
operator TypedefStrClassSpec extends stor_class_spec {
}
operator no_stor_class_spec extends stor_class_spec {
}
operator stor_class_spec_sym extends stor_class_spec {
}
phylum type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
error("Unexpected call to type_spec::specify\n");
}
public virtual method void check_types(TypecheckContext *ctx) {}
public virtual method StructUnionType *get_struct_union_type() {
error("Unexpected call to type_spec::get_struct_union_type\n");
return 0;
}
}
// type_spec -> VOID
operator VoidTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else
base_info->spec_bits |= decl::VOID;
}
}
// type_spec -> CHAR
operator CharTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::CHAR)
set_semant_error(this, "Too many 'char's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::INT)
set_semant_error(this, "'char' and 'int' are mutually exclusive");
else if (base_info->spec_bits & decl::FLOAT)
set_semant_error(this, "'char' and 'float' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::DOUBLE)
set_semant_error(this, "'char' and 'double' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::SHORT)
set_semant_error(this, "'char's can't be 'short'");
else if (base_info->spec_bits & decl::LONG)
set_semant_error(this, "'char's can't be 'long'");
else if (base_info->spec_bits & decl::_COMPLEX)
set_semant_error(this, "Only floating-point types "
"can be '_Complex'");
else if (base_info->spec_bits & decl::_IMAGINARY)
set_semant_error(this, "Only floating-point types "
"can be '_Imaginary'");
else
base_info->spec_bits |= decl::CHAR;
}
}
// type_spec -> SHORT
operator ShortTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::SHORT)
set_semant_error(this, "Too many 'short's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::LONG)
set_semant_error(this, "'short' and 'long' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::CHAR)
set_semant_error(this, "'char's can't be 'short'");
else if (base_info->spec_bits & decl::_COMPLEX)
set_semant_error(this, "Only floating-point types "
"can be '_Complex'");
else if (base_info->spec_bits & decl::_IMAGINARY)
set_semant_error(this, "Only floating-point types "
"can be '_Imaginary'");
else
base_info->spec_bits |= decl::SHORT;
}
}
// type_spec -> INT
operator IntTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::INT)
set_semant_error(this, "Too many 'int's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::CHAR)
set_semant_error(this, "'char' and 'int' are mutually exclusive");
else if (base_info->spec_bits & decl::FLOAT)
set_semant_error(this, "'float' and 'int' are mutually exclusive");
else if (base_info->spec_bits & decl::DOUBLE)
set_semant_error(this, "'double' and 'int' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::_COMPLEX)
set_semant_error(this, "Only floating-point types "
"can be '_Complex'");
else if (base_info->spec_bits & decl::_IMAGINARY)
set_semant_error(this, "Only floating-point types "
"can be '_Imaginary'");
else
base_info->spec_bits |= decl::INT;
}
}
// type_spec -> LONG
operator LongTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::LONG_LONG)
set_semant_error(this, "Too many 'longs's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::SHORT)
set_semant_error(this, "'short' and 'long' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::CHAR)
set_semant_error(this, "'char's can't be 'long'");
else if (base_info->spec_bits & decl::FLOAT)
set_semant_error(this, "'float's can't be 'long'");
else if (base_info->spec_bits &
(decl::DOUBLE|decl::_COMPLEX|decl::_IMAGINARY) &&
base_info->spec_bits & decl::LONG)
set_semant_error(this, "Only integers can be 'long long'");
else {
if (base_info->spec_bits & decl::LONG)
base_info->spec_bits |= decl::LONG_LONG;
else
base_info->spec_bits |= decl::LONG;
}
}
}
// type_spec -> FLOAT
operator FloatTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::FLOAT)
set_semant_error(this, "Too many 'float's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::CHAR)
set_semant_error(this, "'char' and 'float' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::INT)
set_semant_error(this, "'float' and 'int' are mutually exclusive");
else if (base_info->spec_bits & decl::DOUBLE)
set_semant_error(this, "'float' and 'double' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::SHORT)
set_semant_error(this, "'float's can't be 'short'");
else if (base_info->spec_bits & decl::LONG)
set_semant_error(this, "'float's can't be 'long'");
else if (base_info->spec_bits & decl::SIGNED)
set_semant_error(this, "Floating point types can't be "
"declared 'signed'");
else if (base_info->spec_bits & decl::UNSIGNED)
set_semant_error(this, "Floating point types can't be 'unsigned'");
else
base_info->spec_bits |= decl::FLOAT;
}
}
// type_spec -> DOUBLE
operator DoubleTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::DOUBLE)
set_semant_error(this, "Too many 'double's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::CHAR)
set_semant_error(this, "'char' and 'double' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::INT)
set_semant_error(this, "'double' and 'int' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::FLOAT)
set_semant_error(this, "'float' and 'double' are "
"mutually exclusive");
else if (base_info->spec_bits & decl::SHORT)
set_semant_error(this, "'double's can't be 'short'");
else if (base_info->spec_bits & decl::SIGNED)
set_semant_error(this, "Floating point types can't be "
"declared 'signed'");
else if (base_info->spec_bits & decl::UNSIGNED)
set_semant_error(this, "Floating point types can't be 'unsigned'");
else if (base_info->spec_bits & decl::LONG_LONG)
set_semant_error(this, "Only integers can be 'long long'");
else
base_info->spec_bits |= decl::DOUBLE;
}
}
// type_spec -> SIGNED
operator SignedTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::SIGNED)
set_semant_error(this, "Too many 'signed's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::UNSIGNED)
set_semant_error(this, "'signed' and 'unsigned' are mutually "
"exclusive");
else if (base_info->spec_bits & (decl::FLOAT|decl::DOUBLE))
set_semant_error(this, "Floating point types can't be "
"declared 'signed'");
else
base_info->spec_bits |= decl::SIGNED;
}
}
// type_spec -> UNSIGNED
operator UnsignedTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::UNSIGNED)
set_semant_error(this, "Too many 'unsigned's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::SIGNED)
set_semant_error(this, "'signed' and 'unsigned' are mutually "
"exclusive");
else if (base_info->spec_bits & (decl::FLOAT|decl::DOUBLE))
set_semant_error(this, "Floating point types can't be 'unsigned'");
else
base_info->spec_bits |= decl::UNSIGNED;
}
}
// type_spec -> _BOOL
operator BooleanTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else
base_info->spec_bits |= decl::_BOOL;
}
}
// type_spec -> _COMPLEX
operator ComplexTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::_COMPLEX)
set_semant_error(this, "Too many '_Complex'es in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_IMAGINARY)
set_semant_error(this, "'_Complex' and '_Imaginary' are "
"mutually exclusive");
else if (base_info->spec_bits & (decl::CHAR|decl::INT|decl::SHORT))
set_semant_error(this, "Only floating-point types "
"can be '_Complex'");
else if (base_info->spec_bits & decl::SIGNED)
set_semant_error(this, "Floating point types can't be "
"declared 'signed'");
else if (base_info->spec_bits & decl::UNSIGNED)
set_semant_error(this, "Floating point types can't be 'unsigned'");
else if (base_info->spec_bits & decl::LONG_LONG)
set_semant_error(this, "Only integers can be 'long long'");
else
base_info->spec_bits |= decl::_COMPLEX;
}
}
// type_spec -> _IMAGINARY
operator ImaginaryTypeSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::_IMAGINARY)
set_semant_error(this, "Too many '_Imaginary's in type");
else if (base_info->spec_bits & decl::STRUCT_UNION_ENUM)
set_semant_error(this, "A struct, union, or enum specifier is not"
" allowed with any other type specifier");
else if (base_info->spec_bits & decl::VOID)
set_semant_error(this, "'void' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_BOOL)
set_semant_error(this, "'_Bool' is not allowed with "
"any other type specifier");
else if (base_info->spec_bits & decl::_COMPLEX)
set_semant_error(this, "'_Complex' and '_Imaginary' are "
"mutually exclusive");
else if (base_info->spec_bits & (decl::CHAR|decl::INT|decl::SHORT))
set_semant_error(this, "Only floating-point types "
"can be '_Imaginary'");
else if (base_info->spec_bits & decl::SIGNED)
set_semant_error(this, "Floating point types can't be "
"declared 'signed'");
else if (base_info->spec_bits & decl::UNSIGNED)
set_semant_error(this, "Floating point types can't be 'unsigned'");
else if (base_info->spec_bits & decl::LONG_LONG)
set_semant_error(this, "Only integers can be 'long long'");
else
base_info->spec_bits |= decl::_IMAGINARY;
}
}
// type_spec -> STRUCT OptR28E1:name LBRACE SeqR28E3star:decls RBRACE
operator StructDefinitionSpec extends type_spec {
public slot CompleteStructUnionType struct_type;
public virtual method StructUnionType *get_struct_union_type() {
return &struct_type;
}
public virtual method void check_types(TypecheckContext *ctx) {
if (has_name())
struct_type.tag = get_name_name()->pooled_string();
else
struct_type.tag = "(unnamed)";
struct_type.is_union = false;
for (decls_iterator i = get_decls(); i; ++i)
i.get_decl()->check_member(ctx, &struct_type);
}
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits)
set_semant_error(this, "A struct specifier is not allowed "
"with any other type specifier");
else {
base_info->spec_bits |= decl::STRUCT_UNION_ENUM;
assert(base_info->aggregate == decl::NO_AGGREGATE);
base_info->aggregate = decl::AGGREGATE_DEF;
base_info->specified_type = &struct_type;
}
}
}
// type_spec -> UNION OptR28E1:name LBRACE SeqR28E3star:decls RBRACE
operator UnionDefinitionSpec extends type_spec {
public slot CompleteStructUnionType union_type;
public virtual method StructUnionType *get_struct_union_type() {
return &union_type;
}
public virtual method void check_types(TypecheckContext *ctx) {
if (has_name())
union_type.tag = get_name_name()->pooled_string();
else
union_type.tag = "(unnamed)";
union_type.is_union = true;
for (decls_iterator i = get_decls(); i; ++i)
i.get_decl()->check_member(ctx, &union_type);
}
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits)
set_semant_error(this, "A union specifier is not allowed "
"with any other type specifier");
else {
base_info->spec_bits |= decl::STRUCT_UNION_ENUM;
assert(base_info->aggregate == decl::NO_AGGREGATE);
base_info->aggregate = decl::AGGREGATE_DEF;
base_info->specified_type = &union_type;
}
}
}
// type_spec -> STRUCT IDSYM:name
operator StructReferenceSpec extends type_spec {
public slot StructUnionType *struct_type;
public virtual method StructUnionType *get_struct_union_type() {
return struct_type;
}
public virtual method void check_types(TypecheckContext *ctx) {
Node *def = (Node *)definition.value();
if (def)
struct_type = ((StructDefinitionSpec*)def)
->get_struct_union_type();
else {
CompleteStructUnionType *complete_type = 0;
if (completion.value()) {
complete_type = (CompleteStructUnionType *)
(((StructDefinitionSpec *)completion.value())
->get_struct_union_type());
}
struct_type = new
IncompleteStructUnionType(get_name()->pooled_string(), false,
complete_type);
}
}
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits)
set_semant_error(this, "A struct specifier is not allowed "
"with any other type specifier");
else {
base_info->spec_bits |= decl::STRUCT_UNION_ENUM;
assert(base_info->aggregate == decl::NO_AGGREGATE);
base_info->aggregate = decl::AGGREGATE_REF;
base_info->specified_type = struct_type;
}
}
}
// type_spec -> UNION IDSYM:name
operator UnionReferenceSpec extends type_spec {
public slot StructUnionType *union_type;
public virtual method StructUnionType *get_struct_union_type() {
return union_type;
}
public virtual method void check_types(TypecheckContext *ctx) {
Node *def = (Node *)definition.value();
if (def)
union_type = ((StructDefinitionSpec*)def)
->get_struct_union_type();
else {
CompleteStructUnionType *complete_type = 0;
if (completion.value()) {
complete_type = (CompleteStructUnionType *)
(((UnionDefinitionSpec *)completion.value())
->get_struct_union_type());
}
union_type = new
IncompleteStructUnionType(get_name()->pooled_string(), true,
complete_type);
}
}
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits)
set_semant_error(this, "A union specifier is not allowed "
"with any other type specifier");
else {
base_info->spec_bits |= decl::STRUCT_UNION_ENUM;
assert(base_info->aggregate == decl::NO_AGGREGATE);
base_info->aggregate = decl::AGGREGATE_REF;
base_info->specified_type = union_type;
}
}
}
// type_spec -> ENUM OptR28E1:name LBRACE SeqR32E3star:enums OptR32E4 RBRACE
operator DefinedEnumSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits)
set_semant_error(this, "An enum specifier is not allowed "
"with any other type specifier");
else {
base_info->spec_bits |= decl::STRUCT_UNION_ENUM;
assert(base_info->aggregate == decl::NO_AGGREGATE);
base_info->aggregate = decl::AGGREGATE_DEF;
base_info->specified_type = &ctx->the_SignedIntType;
}
}
}
// type_spec -> ENUM IDSYM:name
operator ReferencedEnumSpec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits)
set_semant_error(this, "An enum specifier is not allowed "
"with any other type specifier");
else {
base_info->spec_bits |= decl::STRUCT_UNION_ENUM;
assert(base_info->aggregate == decl::NO_AGGREGATE);
base_info->aggregate = decl::AGGREGATE_REF;
base_info->specified_type = &ctx->the_SignedIntType;
}
}
}
// type_spec -> IDSYM:type_name
operator TypedefTypeSpec extends type_spec depends on Declarator {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
if (base_info->spec_bits & decl::TYPEDEF_NAME)
base_info->spec_bits |= decl::TYPEDEF_TYPEDEF;
else
base_info->spec_bits |= decl::TYPEDEF_NAME;
Declarator *def = (Declarator *)definition.value();
if (def)
base_info->specified_type = def->c_type;
}
}
operator no_type_spec extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
}
}
operator type_spec_sym extends type_spec {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
type_spec::phylum_cast(primary_alternative())->specify(ctx, base_info);
}
public virtual method void check_types(TypecheckContext *ctx) {
type_spec::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum type_qual {
public virtual method void specify(decl::TypeInfo *base_info) {}
}
// type_qual -> CONST
operator ConstTypeQualifier extends type_qual {
public virtual method void specify(decl::TypeInfo *base_info) {
base_info->quals |= CONST_QUAL;
}
}
// type_qual -> VOLATILE
operator VolatileTypeQualifier extends type_qual {
public virtual method void specify(decl::TypeInfo *base_info) {
base_info->quals |= VOLATILE_QUAL;
}
}
// type_qual -> RESTRICT
operator RestrictTypeQualifier extends type_qual {
public virtual method void specify(decl::TypeInfo *base_info) {
base_info->quals |= RESTRICT_QUAL;
}
}
operator no_type_qual extends type_qual {
}
operator type_qual_sym extends type_qual {
public virtual method void specify(decl::TypeInfo *base_info) {
type_qual::phylum_cast(primary_alternative())->specify(base_info);
}
}
phylum init_declr {
public virtual method void check_types(TypecheckContext *ctx,
CType *base_type) {
}
}
// init_declr -> declr:declr OptR38E1:init
operator InitDeclr extends init_declr {
public virtual method void check_types(TypecheckContext *ctx,
CType *base_type) {
CType *type = get_declr()->build_type(ctx, base_type);
if (has_init())
get_init_init()->check_type(ctx, type);
}
}
operator no_init_declr extends init_declr {
}
operator init_declr_sym extends init_declr {
public virtual method void check_types(TypecheckContext *ctx,
CType *base_type) {
init_declr::phylum_cast(primary_alternative())
->check_types(ctx, base_type);
}
}
phylum type_name {
public virtual method CType *get_type(TypecheckContext *ctx) {
return &ctx->the_UnimplementedType;
}
}
// type_name -> SeqR13E0star:spec_quals OptR13E1:declr
operator TypeName extends type_name depends on decl {
public virtual method CType *get_type(TypecheckContext *ctx) {
decl::TypeInfo base_info;
for (spec_quals_iterator i = get_spec_quals(); i; ++i)
i.get_spec_qual()->specify(ctx, &base_info);
CType *base_type = decl::assemble_base_type(ctx, this, &base_info);
if (has_declr())
return get_declr_declr()->build_type(ctx, base_type);
else
return base_type;
}
}
operator no_type_name extends type_name {
}
operator type_name_sym extends type_name {
public virtual method CType *get_type(TypecheckContext *ctx) {
return type_name::phylum_cast(primary_alternative())->get_type(ctx);
}
}
phylum type_spec_qual {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {}
public virtual method void check_types(TypecheckContext *ctx) {}
}
// type_spec_qual -> type_spec:spec
operator TypeSpecifier extends type_spec_qual {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
get_spec()->specify(ctx, base_info);
}
public virtual method void check_types(TypecheckContext *ctx) {
get_spec()->check_types(ctx);
}
}
// type_spec_qual -> type_qual:qual
operator TypeQualifier extends type_spec_qual {
}
operator no_type_spec_qual extends type_spec_qual {
}
operator type_spec_qual_sym extends type_spec_qual {
public virtual method void specify(TypecheckContext *ctx,
decl::TypeInfo *base_info) {
type_spec_qual::phylum_cast(primary_alternative())
->specify(ctx, base_info);
}
public virtual method void check_types(TypecheckContext *ctx) {
type_spec_qual::phylum_cast(primary_alternative())
->check_types(ctx);
}
}
phylum abst_declr {
public slot CType *c_type;
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return base_type;
}
}
// abst_declr -> pointer:ptr
operator PointerAbstDecl extends abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
CType *type = base_type;
type = get_ptr()->point_to(ctx, type);
c_type = type;
return type;
}
}
// abst_declr -> OptR46E0:ptr direct_abst_declr:direct
operator DirectAbstDecl extends abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
CType *type = base_type;
if (has_ptr())
type = get_ptr_ptr()->point_to(ctx, type);
type = get_direct()->build_type(ctx, type);
c_type = type;
return type;
}
}
operator no_abst_declr extends abst_declr {
}
operator abst_declr_sym extends abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return abst_declr::phylum_cast(primary_alternative())
->build_type(ctx, base_type);
}
}
phylum struct_decl {
public virtual method void check_member(TypecheckContext *ctx,
CompleteStructUnionType *members) {
}
}
// struct_decl -> SeqR13E0star:spec_quals SeqR61E1star:declrs SEMI
operator StructDecl extends struct_decl {
public virtual method void check_member(TypecheckContext *ctx,
CompleteStructUnionType *members) {
decl::TypeInfo base_type_info;
for (spec_quals_iterator i = get_spec_quals(); i; ++i)
i.get_spec_qual()->check_types(ctx);
for (spec_quals_iterator i = get_spec_quals(); i; ++i)
i.get_spec_qual()->specify(ctx, &base_type_info);
CType *base_type =
decl::assemble_base_type(ctx, this, &base_type_info);
//string msg = "Base type: " + base_type->name();
//set_string_prop(MOUSE_OVER_MSG, msg.c_str());
//compute_synth_attrs(true);
bool has_declrs = get_declrs();
if (base_type_info.aggregate == decl::NO_AGGREGATE && !has_declrs)
set_semant_error(this, "Declaration declares neither an aggregate"
" nor any declarators");
for (declrs_iterator i = get_declrs(); i; ++i)
i.get_declr()->check_member(ctx, members, base_type);
}
}
operator no_struct_decl extends struct_decl {
}
operator struct_decl_sym extends struct_decl {
public virtual method void check_member(TypecheckContext *ctx,
CompleteStructUnionType *members) {
struct_decl::phylum_cast(primary_alternative())
->check_member(ctx, members);
}
}
phylum enum_ {
}
// enum_ -> IDSYM:name OptR45E1:init
operator EnumerationItem extends enum_ {
}
operator no_enum_ extends enum_ {
}
operator enum__sym extends enum_ {
}
phylum init_ {
public virtual method void check_type(TypecheckContext *ctx,
CType *declared_type) {
}
}
// init_ -> assign_expr:expr
operator ExprInit extends init_ {
public virtual method void check_type(TypecheckContext *ctx,
CType *declared_type) {
ExprType analyzed_type = get_expr()->determine_type(ctx);
if (!analyzed_type)
return;
analyzed_type = analyzed_type.to_rvalue();
if (!analyzed_type)
set_semant_error(this, "Can't initialize with non-rvalue %s",
analyzed_type.name().c_str());
else
// This will set its own error messages
ExprType::assign_compat(declared_type->unqualified(),
analyzed_type, "initialization", this);
}
}
// init_ -> LBRACE SeqR44E1star:inits OptR32E4 RBRACE
operator BlockInit extends init_ {
}
operator no_init_ extends init_ {
}
operator init__sym extends init_ {
public virtual method void check_type(TypecheckContext *ctx,
CType *declared_type) {
init_::phylum_cast(primary_alternative())
->check_type(ctx, declared_type);
}
}
phylum designator {
}
// designator -> LBRACK expr:idx RBRACK
operator ArrayElemDesignator extends designator {
}
// designator -> DOT IDSYM:field
operator FieldDesignator extends designator {
}
operator no_designator extends designator {
}
operator designator_sym extends designator {
}
phylum expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return ExprType(ERROR_CLASS, 0);
}
public virtual method bool int_const_expr(TypecheckContext *ctx,
bignum_t *value) {
return false;
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return false;
}
public virtual method ExprType determine_type_logical(
TypecheckContext *ctx, Node *node,
expr *left_expr, expr *right_expr,
const char *op_sym, const char *op_name) {
ExprType left, right, tmp;
if (!(left = left_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = right_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_rvalue())) {
left = tmp;
} else {
set_semant_error(node, "Can't use %s as left arg to `%s'",
left.name().c_str(), op_sym);
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(node, "Can't use %s as right arg to `%s'",
right.name().c_str(), op_sym);
}
if (!left.ty->is_scalar()) {
set_semant_error(node, "Left arg of `%s' must have scalar type,"
" not %s", op_sym, left.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
if (!right.ty->is_scalar()) {
set_semant_error(node, "Right arg of `%s' must have scalar type,"
" not %s", op_sym, right.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
ExpressionClass result_cl;
ExprType result;
if (left.is_int_const() && right.is_int_const())
result.cl = INTEGER_CONST;
else if (left.is_arith_const() && right.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
result.ty = &ctx->the_SignedIntType;
string msg = string(op_name) + " has type " + result.ty->name();
node->set_string_prop(MOUSE_OVER_MSG, msg.c_str());
node->compute_synth_attrs(true);
return result;
}
public virtual method ExprType determine_type_integer(
TypecheckContext *ctx, Node *node,
expr *left_expr, expr *right_expr,
const char *op_sym, const char *op_name) {
ExprType left, right, tmp;
if (!(left = left_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = right_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_rvalue())) {
left = tmp;
} else {
set_semant_error(node, "Can't use %s as left arg to `%s'",
left.name().c_str(), op_sym);
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(node, "Can't use %s as right arg to `%s'",
right.name().c_str(), op_sym);
}
IntegerType *left_int, *right_int;
if (left.ty->is_integer())
left_int = (IntegerType *)left.ty;
else {
set_semant_error(node, "Left arg of `%s' must have integer type,"
" not %s", op_sym, left.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
if (right.ty->is_integer())
right_int = (IntegerType *)right.ty;
else {
set_semant_error(node, "Right arg of `%s' must have integer type,"
" not %s", op_sym, right.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
ExpressionClass result_cl;
ExprType result;
if (left.is_int_const() && right.is_int_const())
result.cl = INTEGER_CONST;
else if (left.is_arith_const() && right.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
result.ty = IntegerType::usual_conv(left_int, right_int);
string msg = string(op_name) + " has type " + result.ty->name();
node->set_string_prop(MOUSE_OVER_MSG, msg.c_str());
node->compute_synth_attrs(true);
return result;
}
public static method ExprType determine_type_equality(
TypecheckContext *ctx, Node *node,
expr *left_expr, expr *right_expr,
const char *op_sym, const char *op_name) {
ExprType left, right, tmp;
if (!(left = left_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = right_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_rvalue())) {
left = tmp;
} else {
set_semant_error(node, "Can't use %s as left arg to `%s'",
left.name().c_str(), op_sym);
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(node, "Can't use %s as right arg to `%s'",
right.name().c_str(), op_sym);
}
ExprType result;
if (left.ty->is_arithmetic() && right.ty->is_arithmetic()) {
ArithmeticType *left_a = (ArithmeticType*)left.ty;
ArithmeticType *right_a = (ArithmeticType*)right.ty;
CType *common =
ArithmeticType::usual_conv(&left_a, &right_a);
if (left.is_int_const() && right.is_int_const())
result.cl = INTEGER_CONST;
else if (left.is_arith_const() && right.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
} else if (left.ty->is_pointer() && right.ty->is_pointer()) {
CType *left_ref_uq = ((PointerType*)left.ty)->referent_type
->unqualified();
CType *right_ref_uq = ((PointerType*)right.ty)->referent_type
->unqualified();
if (CType::composite_type(left_ref_uq, right_ref_uq)) {
// Pointers to possibly qualified compatible types -- okay
} else if (left_ref_uq->is_void() || right_ref_uq->is_void()) {
CType *non_void = (left_ref_uq->is_void()) ?
right_ref_uq : left_ref_uq;
if (non_void->is_function())
set_semant_error(node, "Can't compare function pointer "
"and void pointer in %s %s %s",
left.ty->name().c_str(), op_sym,
right.ty->name().c_str());
// Otherwise, you can compare void to anything
} else {
set_semant_error(node, "Incompatible pointer types in "
"comparison %s %s %s",
left.ty->name().c_str(), op_sym,
right.ty->name().c_str());
}
result.cl = RVALUE;
} else if (left.ty->is_pointer() && right.is_null_const() ||
right.ty->is_pointer() && left.is_null_const()) {
// Any pointer can be compared to null
result.cl = RVALUE;
} else {
set_semant_error(node, "Wrong types to `%s': %s %s %s",
op_sym, left.ty->name().c_str(),
op_sym, right.ty->name().c_str());
result.cl = RVALUE;
}
result.ty = &ctx->the_SignedIntType;
string msg = string(op_name) + " has type " + result.ty->name();
node->set_string_prop(MOUSE_OVER_MSG, msg.c_str());
node->compute_synth_attrs(true);
return result;
}
public static method ExprType determine_type_relational(
TypecheckContext *ctx, Node *node,
expr *left_expr, expr *right_expr,
const char *op_sym, const char *op_name) {
ExprType left, right, tmp;
if (!(left = left_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = right_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_rvalue())) {
left = tmp;
} else {
set_semant_error(node, "Can't use %s as left arg to `%s'",
left.name().c_str(), op_sym);
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(node, "Can't use %s as right arg to `%s'",
right.name().c_str(), op_sym);
}
ExprType result;
if (left.ty->is_arithmetic() && right.ty->is_arithmetic()) {
ArithmeticType *left_a = (ArithmeticType*)left.ty;
ArithmeticType *right_a = (ArithmeticType*)right.ty;
if (left_a->domain() != REAL_DOMAIN)
set_semant_error(node, "Left arg to `%s' must have real type,"
" not %s", op_sym, left_a->name().c_str());
if (right_a->domain() != REAL_DOMAIN)
set_semant_error(node, "Right arg to `%s' must have real type,"
" not %s", op_sym, right_a->name().c_str());
CType *common =
ArithmeticType::usual_conv(&left_a, &right_a);
if (left.is_int_const() && right.is_int_const())
result.cl = INTEGER_CONST;
else if (left.is_arith_const() && right.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
} else if (left.ty->is_pointer() && right.ty->is_pointer()) {
CType *left_ref_uq = ((PointerType*)left.ty)->referent_type
->unqualified();
CType *right_ref_uq = ((PointerType*)right.ty)->referent_type
->unqualified();
if (left_ref_uq->is_function() || right_ref_uq->is_function())
set_semant_error(node, "Can't compare function pointers for "
"order in %s %s %s", left.ty->name().c_str(),
op_sym, right.ty->name().c_str());
else if (left_ref_uq->is_complete() != right_ref_uq->is_complete())
set_semant_error(node, "Can't compare complete and incomplete"
" types in %s %s %s", left.ty->name().c_str(),
op_sym, right.ty->name().c_str());
else if (!CType::composite_type(left_ref_uq, right_ref_uq))
set_semant_error(node, "Incompatible types in comparison "
"%s %s %s", left.ty->name().c_str(),
op_sym, right.ty->name().c_str());
result.cl = RVALUE;
} else {
set_semant_error(node, "Wrong types to `%s': %s %s %s",
op_sym, left.ty->name().c_str(),
op_sym, right.ty->name().c_str());
result.cl = RVALUE;
}
result.ty = &ctx->the_SignedIntType;
string msg = string(op_name) + " has type " + result.ty->name();
node->set_string_prop(MOUSE_OVER_MSG, msg.c_str());
node->compute_synth_attrs(true);
return result;
}
public virtual method ExprType determine_type_shift(
TypecheckContext *ctx, Node *node,
expr *left_expr, expr *right_expr,
const char *op_sym, const char *op_name) {
ExprType left, right, tmp;
if (!(left = left_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = right_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_rvalue())) {
left = tmp;
} else {
set_semant_error(node, "Can't use %s as left arg to `%s'",
left.name().c_str(), op_sym);
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(node, "Can't use %s as right arg to `%s'",
right.name().c_str(), op_sym);
}
IntegerType *left_int, *right_int;
if (left.ty->is_integer())
left_int = (IntegerType *)left.ty;
else {
set_semant_error(node, "Left arg of shift must have integer type,"
" not %s", left.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
if (right.ty->is_integer())
right_int = (IntegerType *)right.ty;
else {
set_semant_error(node, "Shift amount must have integer type,"
" not %s", right.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
ExpressionClass result_cl;
if (left.is_int_const() && right.is_int_const())
result_cl = INTEGER_CONST;
else if (left.is_arith_const() && right.is_arith_const())
result_cl = ARITH_CONST;
else
result_cl = RVALUE;
IntegerType *result = left_int->promote();
string msg = string(op_name) + " has type " + result->name();
node->set_string_prop(MOUSE_OVER_MSG, msg.c_str());
node->compute_synth_attrs(true);
return ExprType(result_cl, result);
}
public virtual method ExprType determine_type_arithmetic(
TypecheckContext *ctx, Node *node,
expr *left_expr, expr *right_expr,
const char *op_sym, const char *op_name) {
ExprType left, right, tmp;
if (!(left = left_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = right_expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_rvalue())) {
left = tmp;
} else {
set_semant_error(node, "Can't use %s as left arg to `%s'",
left.name().c_str(), op_sym);
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(node, "Can't use %s as right arg to `%s'",
right.name().c_str(), op_sym);
}
ArithmeticType *left_a, *right_a;
if (left.ty->is_arithmetic())
left_a = (ArithmeticType *)left.ty;
else {
set_semant_error(node, "Left arg of `%s' must have arithemtic "
"type, not %s", op_sym, left.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
if (right.ty->is_arithmetic())
right_a = (ArithmeticType *)right.ty;
else {
set_semant_error(node, "Right arg of `%s' must have arithemtic "
"type, not %s", op_sym, right.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
ExprType result;
if (left.is_int_const() && right.is_int_const())
result.cl = INTEGER_CONST;
else if (left.is_arith_const() && right.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
result.ty = ArithmeticType::usual_conv(&left_a, &right_a);
string msg = string(op_name) + " has type " + result.ty->name();
node->set_string_prop(MOUSE_OVER_MSG, msg.c_str());
node->compute_synth_attrs(true);
return result;
}
public virtual method ExprType determine_type_unary(
TypecheckContext *ctx, Node *node,
expr *expr, const char *op_sym,
const char *op_name) {
ExprType type, tmp;
if (!(type = expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = type.to_rvalue())) {
type = tmp;
} else {
set_semant_error(node, "Can't use %s as arg to `%s'",
type.name().c_str(), op_sym);
}
ArithmeticType *type_a;
if (type.ty->is_arithmetic())
type_a = (ArithmeticType *)type.ty;
else {
set_semant_error(node, "Arg of `%s' must have arithmetic "
"type, not %s", op_sym, type.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
ExprType result;
if (type.is_int_const())
result.cl = INTEGER_CONST;
else if (type.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
if (type_a->is_integer())
type_a = ((IntegerType *)type_a)->promote();
result.ty = type_a;
string msg = string(op_name) + " has type " + result.ty->name();
node->set_string_prop(MOUSE_OVER_MSG, msg.c_str());
node->compute_synth_attrs(true);
return result;
}
public virtual method ExprType determine_type_crement(
TypecheckContext *ctx, Node *node,
expr *expr, const char *op_sym,
const char *op_name) {
ExprType type, tmp;
if (!(type = expr->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = type.to_mod_lvalue())) {
type = tmp;
} else {
set_semant_error(node, "Can't use %s as arg to `%s'",
type.name().c_str(), op_sym);
}
if (!(type.ty->is_arithmetic() &&
((ArithmeticType *)type.ty)->domain() == REAL_DOMAIN) &&
!type.ty->is_pointer()) {
set_semant_error(node, "Arg of `%s' must have pointer or real "
"arithemtic type, not %s", op_sym,
type.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
ExprType result;
result.cl = RVALUE;
if (type.ty->is_integer())
type.ty = ((IntegerType *)type.ty)->promote();
result.ty = type.ty;
string msg = string(op_name) + " has type " + result.ty->name();
node->set_string_prop(MOUSE_OVER_MSG, msg.c_str());
node->compute_synth_attrs(true);
return result;
}
}
// expr -> expr:pred QUESTION Opt(exprs):texpr COLON expr:fexpr
operator TernaryOp extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType pred, middle, right, tmp;
if (!(pred = get_pred()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (has_texpr()) {
if (!(middle = get_texpr_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
} else {
middle = pred; /* a GCC extension */
}
if (!(right = get_fexpr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = pred.to_rvalue())) {
pred = tmp;
} else {
set_semant_error(this, "Can't use %s as predicate in `?:'",
pred.name().c_str());
}
if ((tmp = middle.to_rvalue())) {
middle = tmp;
} else {
set_semant_error(this, "Can't use %s as middle arg of `?:'",
middle.name().c_str());
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(this, "Can't use %s as right arg of `?:'",
right.name().c_str());
}
if (!pred.ty->is_scalar())
set_semant_error(this, "Predicate of ternary op must have scalar "
"type, not %s", pred.ty->name().c_str());
ExprType result;
if (middle.ty->is_arithmetic() && right.ty->is_arithmetic()) {
ArithmeticType *middle_converted = (ArithmeticType*)middle.ty;
ArithmeticType *right_converted = (ArithmeticType*)right.ty;
result.ty = ArithmeticType::usual_conv(&middle_converted,
&right_converted);
if (pred.is_int_const() && middle.is_int_const() &&
right.is_int_const())
result.cl = INTEGER_CONST;
else if (pred.is_int_const() && middle.is_arith_const() &&
right.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
} else if (middle.ty->is_struct_union() &&
right.ty->is_struct_union()) {
StructUnionType *middle_su = (StructUnionType *)middle.ty;
StructUnionType *right_su = (StructUnionType *)right.ty;
StructUnionType *common =
StructUnionType::are_same(middle_su, right_su);
if (common) {
result.ty = common;
result.cl = RVALUE;
} else {
set_semant_error(this, "Different struct/union types in `?:':"
" %s vs. %s", middle_su->name().c_str(),
right_su->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
} else if (middle.ty->is_void() && right.ty->is_void()) {
result.cl = RVALUE;
result.ty = &ctx->the_VoidType;
} else if ((middle.ty->is_pointer() || middle.is_null_const()) &&
(right.ty->is_pointer() || right.is_null_const())) {
if (!middle.ty->is_pointer()) {
// Middle must be an arithmetic 0
result.ty = right.ty;
} else if (!right.ty->is_pointer()) {
// Right must be an arithmetic 0
result.ty = middle.ty;
} else {
CType *middle_ref = ((PointerType *)middle.ty)->referent_type;
CType *right_ref = ((PointerType *)right.ty)->referent_type;
unsigned quals = middle_ref->qualifiers() |
right_ref->qualifiers();
CType *middle_ref_uq = middle_ref->unqualified();
CType *right_ref_uq = right_ref->unqualified();
CType *comp = CType::composite_type(middle_ref_uq,
right_ref_uq);
if (comp) {
result.ty = comp->qualified_by(quals)->pointer_to();
} else if (middle_ref_uq->is_void() ||
right_ref_uq->is_void()) {
result.ty = ctx->the_VoidType.qualified_by(quals)
->pointer_to();
} else {
set_semant_error(this, "Incompatible pointer types %s "
"and %s in conditional operator",
middle.ty->name().c_str(),
right.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
}
result.cl = RVALUE;
} else {
set_semant_error(this, "Incompatible types in conditional: "
"? %s : %s", middle.ty->name().c_str(),
right.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
string msg = "Conditional op has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
// expr -> expr:left LOR expr:right
operator LogicalOr extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_logical(ctx, this, get_left(), get_right(),
"||", "Logical OR");
}
}
// expr -> expr:left LAND expr:right
operator LogicalAnd extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_logical(ctx, this, get_left(), get_right(),
"&&", "Logical AND");
}
}
// expr -> expr:left BOR expr:right
operator BitwiseOr extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_integer(ctx, this, get_left(), get_right(),
"|", "Bitwise OR");
}
}
// expr -> expr:left BXOR expr:right
operator BitwiseXor extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_integer(ctx, this, get_left(), get_right(),
"^", "Bitwise XOR");
}
}
// expr -> expr:left BAND expr:right
operator BitwiseAnd extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_integer(ctx, this, get_left(), get_right(),
"&", "Bitwise AND");
}
}
// expr -> expr:left EQ expr:right
operator Equals extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_equality(ctx, this, get_left(),
get_right(), "==", "Equals");
}
}
// expr -> expr:left NE expr:right
operator NotEquals extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_equality(ctx, this, get_left(),
get_right(), "!=", "Not-equals");
}
}
// expr -> expr:left LT expr:right
operator LessThan extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_relational(ctx, this, get_left(),
get_right(), "<", "Less-than");
}
}
// expr -> expr:left GT expr:right
operator GreaterThan extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_relational(ctx, this, get_left(),
get_right(), ">",
"Greater-than");
}
}
// expr -> expr:left LE expr:right
operator LessThanEquals extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_relational(ctx, this, get_left(),
get_right(), "<=",
"Less-than-or-equals");
}
}
// expr -> expr:left GE expr:right
operator GreaterThanEquals extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_relational(ctx, this, get_left(),
get_right(), ">=",
"Greater-than-or-equals");
}
}
// expr -> expr:left LSHIFT expr:right
operator LeftShift extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_shift(ctx, this, get_left(), get_right(),
"<<", "Left shift");
}
}
// expr -> expr:left RSHIFT expr:right
operator RightShift extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_shift(ctx, this, get_left(), get_right(),
">>", "Right shift");
}
}
// expr -> expr:left PLUS expr:right
operator Add extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType left, right, tmp;
if (!(left = get_left()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = get_right()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_rvalue())) {
left = tmp;
} else {
set_semant_error(this, "Can't use %s as left arg to `+'",
left.name().c_str());
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(this, "Can't use %s as right arg to `+'",
right.name().c_str());
}
ExprType result;
if (left.ty->is_arithmetic() && right.ty->is_arithmetic()) {
ArithmeticType *left_converted = (ArithmeticType*)left.ty;
ArithmeticType *right_converted = (ArithmeticType*)right.ty;
result.ty =
ArithmeticType::usual_conv(&left_converted, &right_converted);
if (left.is_int_const() && right.is_int_const())
result.cl = INTEGER_CONST;
else if (left.is_arith_const() && right.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
} else if (left.ty->is_integer() && right.ty->is_ptr_to_object() ||
right.ty->is_integer() && left.ty->is_ptr_to_object()) {
ExprType int_type;
ExprType pointer_type;
if (left.ty->is_integer()) {
int_type = left;
pointer_type = right;
} else {
pointer_type = left;
int_type = right;
}
result.ty = pointer_type.ty;
if (int_type.is_int_const() && pointer_type.is_addr_const())
result.cl = CONSTANT;
else
result.cl = RVALUE;
} else {
set_semant_error(this, "Wrong types to `+': %s + %s",
left.ty->name().c_str(),
right.ty->name().c_str());
result.ty = 0;
result.cl = ERROR_CLASS;
return result;
}
string msg = "Sum has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
public virtual method bool int_const_expr(TypecheckContext *ctx,
bignum_t *value) {
bignum_t left, right;
if (!get_left()->int_const_expr(ctx, &left))
return false;
if (!get_right()->int_const_expr(ctx, &right))
return false;
*value = left + right;
return true;
}
}
// expr -> expr:left MINUS expr:right
operator Subtract extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType left, right, tmp;
if (!(left = get_left()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = get_right()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_rvalue())) {
left = tmp;
} else {
set_semant_error(this, "Can't use %s as left arg to `-'",
left.name().c_str());
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(this, "Can't use %s as right arg to `-'",
right.name().c_str());
}
ExprType result;
if (left.ty->is_arithmetic() && right.ty->is_arithmetic()) {
ArithmeticType *left_converted = (ArithmeticType*)left.ty;
ArithmeticType *right_converted = (ArithmeticType*)right.ty;
result.ty =
ArithmeticType::usual_conv(&left_converted, &right_converted);
if (left.is_int_const() && right.is_int_const())
result.cl = INTEGER_CONST;
else if (left.is_arith_const() && right.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
} else if (right.ty->is_integer() && left.ty->is_ptr_to_object()) {
result.ty = left.ty;
if (right.is_int_const() && left.is_addr_const())
result.cl = CONSTANT;
else
result.cl = RVALUE;
} else if (left.ty->is_pointer() && right.ty->is_pointer()) {
CType *left_ref_uq = ((PointerType *)left.ty)->referent_type
->unqualified();
CType *right_ref_uq = ((PointerType *)right.ty)->referent_type
->unqualified();
if (!CType::composite_type(left_ref_uq, right_ref_uq))
set_semant_error(this, "Incompatible pointer types in "
"difference: %s - %s",
left.ty->name().c_str(),
right.ty->name().c_str());
result.ty = ctx->the_PtrdiffType;
result.cl = RVALUE;
} else {
set_semant_error(this, "Wrong types to `-': %s - %s",
left.ty->name().c_str(),
right.ty->name().c_str());
result.ty = 0;
result.cl = ERROR_CLASS;
return result;
}
string msg = "Difference has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
// expr -> expr:left TIMES expr:right
operator Multiply extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_arithmetic(ctx, this, get_left(),
get_right(), "*", "Multiply");
}
}
// expr -> expr:left DIV expr:right
operator Divide extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_arithmetic(ctx, this, get_left(),
get_right(), "/", "Divide");
}
}
// expr -> expr:left MOD expr:right
operator Modulo extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_integer(ctx, this, get_left(), get_right(),
"%", "Modulus");
}
}
// expr -> LPAREN type_name:name RPAREN expr:expr
operator TypeCast extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType expr_type;
if (!(expr_type = get_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
CType *type = get_name()->get_type(ctx);
if (type->unqualified()->is_void()) {
return ExprType(VOID_EXPR, type);
} else {
if (!expr_type.ty->is_scalar())
set_semant_error(this, "Can't cast value of non-scalar type "
"%s", expr_type.ty->name().c_str());
if (!type->unqualified()->is_scalar())
set_semant_error(this, "Can't cast to non-scalar type %s",
type->name().c_str());
ExprType result;
result.ty = type;
if (expr_type.is_arith_const() && type->is_integer())
result.cl = INTEGER_CONST;
else if (expr_type.is_null_const() && type->is_pointer())
result.cl = NULL_CONST;
else if (expr_type.is_int_const() && !type->is_integer())
result.cl = ARITH_CONST;
else
/* GCC would have "result.cl = expr_type.cl" to allow
lvalues */
result = result.to_rvalue();
string msg = "Cast has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
}
// expr -> BAND expr:expr
operator AddressOf extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType type, tmp;
if (!(type = get_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = type.to_lvalue())) {
type = tmp;
} else if (type.cl == FUNC_DESIG || get_expr()->has_addr(ctx)) {
// okay
} else {
set_semant_error(this, "Can't use %s as arg to `&'",
type.name().c_str());
}
if (type.ty->is_bitfield())
set_semant_error(this, "Can't take pointer to bitfield type %s",
type.ty->name().c_str());
ExprType result;
result.ty = type.ty->pointer_to();
result.cl = RVALUE; // XXX sometimes should be ADDR_CONST
string msg = "Address-of has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
// expr -> PLUS expr:expr
operator Positive extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_unary(ctx, this, get_expr(), "+",
"Unary plus");
}
}
// expr -> MINUS expr:expr
operator Negate extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_unary(ctx, this, get_expr(), "-",
"Unary minus");
}
}
// expr -> BNOT expr:expr
operator BitwiseNegate extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType type, tmp;
if (!(type = get_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = type.to_rvalue())) {
type = tmp;
} else {
set_semant_error(this, "Can't use %s as arg to `~'",
type.name().c_str());
}
IntegerType *type_int;
if (type.ty->is_integer())
type_int = (IntegerType *)type.ty;
else {
set_semant_error(this, "Arg of `~' must have arithemtic "
"type, not %s", type.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
ExprType result;
if (type.is_int_const())
result.cl = INTEGER_CONST;
else if (type.is_arith_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
type_int = type_int->promote();
result.ty = type_int;
string msg = "Bitwise complement has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
// expr -> NOT expr:expr
operator LogicalNot extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType type, tmp;
if (!(type = get_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = type.to_rvalue())) {
type = tmp;
} else {
set_semant_error(this, "Can't use %s as arg to `!'",
type.name().c_str());
}
if (!type.ty->is_scalar()) {
set_semant_error(this, "Arg of `!' must have scalar "
"type, not %s", type.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
ExprType result;
if (type.is_int_const())
result.cl = INTEGER_CONST;
else if (type.is_const())
result.cl = ARITH_CONST;
else
result.cl = RVALUE;
result.ty = &ctx->the_SignedIntType;
string msg = "Logical not has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
// expr -> expr:func LPAREN SeqR127E2star:exprs RPAREN
operator FunctionCall extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType type, tmp;
if (!(type = get_func()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = type.to_rvalue())) {
type = tmp;
} else {
set_semant_error(this, "Can't use %s as function in function call",
type.name().c_str());
}
FunctionType *func_type = NULL;
if (type.ty->is_pointer()) {
PointerType *ptr_type = (PointerType *)type.ty;
CType *ref_t = ptr_type->referent_type->unqualified();
if (ref_t->is_function())
func_type = (FunctionType *)ref_t;
}
if (!func_type) {
set_semant_error(this, "Function in function call must have "
"pointer to function type, not %s",
type.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
int proto_args = 0;
if (!(func_type->flags & UNKNOWN_ARGS))
proto_args = (int)func_type->parameters.size();
int argnum = 0;
for (exprs_iterator i = get_exprs(); i; ++i, argnum++) {
ExprType tmp, arg_type = i.get_expr()->determine_type(ctx);
if (!arg_type)
continue;
if (!(tmp = arg_type.to_rvalue())) {
set_semant_error(i.get_expr()->cast_to_Node(),
"Can't use %s as argument in function call",
arg_type.name().c_str());
} else {
arg_type = tmp;
}
if (argnum < proto_args) {
CType *param_type = func_type->parameters[argnum];
ExprType::assign_compat(param_type, arg_type,
"function call",
i.get_expr()->cast_to_Node());
} else if (!(func_type->flags & (UNKNOWN_ARGS|ELLIPTICAL))) {
set_semant_error(this, "Too many args (%d vs. %d) in "
"call to %s", argnum + 1, proto_args,
func_type->name().c_str());
} else {
CType *promoted = arg_type.ty->arg_promote();
// Can we do anythin with this? I think the rules about
// argument promotion can only be enforced dynamically
}
}
if (argnum < proto_args) {
set_semant_error(this, "Too few args (%d vs. %d) in call to %s",
argnum, proto_args,
func_type->name().c_str());
}
ExprType result;
result.ty = func_type->return_type;
if (result.ty->is_void())
result.cl = VOID_EXPR;
else
result.cl = RVALUE;
string msg = "Function call has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
// expr -> INC expr:expr
operator PreIncrement extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_crement(ctx, this, get_expr(), "++",
"Prefix increment");
}
}
// expr -> DEC expr:expr
operator PreDecrement extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_crement(ctx, this, get_expr(), "--",
"Prefix decrement");
}
}
// expr -> expr:expr INC
operator PostIncrement extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_crement(ctx, this, get_expr(), "++",
"Postfix increment");
}
}
// expr -> expr:expr DEC
operator PostDecrement extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::determine_type_crement(ctx, this, get_expr(), "--",
"Postfix decrement");
}
}
// expr -> SIZEOF expr:expr
operator VarSizeof extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType expr_type = get_expr()->determine_type(ctx);
CType *type = expr_type.ty;
ExprType result;
if (type && type->is_array() &&
((ArrayType *)type)->qualifiers & VARIABLE_LEN_QUAL)
result.cl = RVALUE; /* C99 runtime sizeof! */
else
result.cl = INTEGER_CONST;
result.ty = ctx->the_SizeType;
return result;
}
}
// expr -> SIZEOF LPAREN type_name:type RPAREN
operator TypeSizeof extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
CType *type = get_type()->get_type(ctx);
ExprType result;
if (type->is_array() &&
((ArrayType *)type)->qualifiers & VARIABLE_LEN_QUAL)
result.cl = RVALUE; /* C99 runtime sizeof! */
else
result.cl = INTEGER_CONST;
result.ty = ctx->the_SizeType;
return result;
}
}
// expr -> LPAREN exprs:expr RPAREN
operator ParenthExpr extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return get_expr()->determine_type(ctx);
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return get_expr()->has_addr(ctx);
}
}
// expr -> int_const:val
operator IntegerConstant extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType type;
type.ty = get_val()->determine_type(ctx);
bool unused;
bignum_t value = get_val()->get_value(ctx, &unused);
if (value)
type.cl = INTEGER_CONST;
else
type.cl = NULL_CONST;
string msg = "Integer constant has type " + type.name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return type;
}
public virtual method bool int_const_expr(TypecheckContext *ctx,
bignum_t *value) {
bool unused;
*value = get_val()->get_value(ctx, &unused);
return true;
}
}
// expr -> char_const:val
operator CharacterConstant extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
CType *type = get_val()->determine_type(ctx);
string msg = "Character constant has type " + type->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return ExprType(INTEGER_CONST, type);
}
}
// expr -> float_const:val
operator FloatingConstant extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
CType *type = get_val()->determine_type(ctx);
string msg = "Floating point constant has type " + type->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return ExprType(ARITH_CONST, type);
}
}
// expr -> str_const:val
operator StringConstant extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
CType *type = get_val()->determine_type(ctx);
string msg = "String constant has type " + type->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return ExprType(ARRAY_LVALUE, type);
}
}
// expr -> LPAREN type_name:type RPAREN LBRACE SeqR44E1star:inits OptR32E4 RBRACE
operator CompoundLiteral extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
CType *type = get_type()->get_type(ctx);
if (type->is_function() || !type->is_complete() && !type->is_array()) {
set_semant_error(this, "Compound literal must specify object or "
"incomplete array type, not %s",
type->name().c_str());
return ExprType(ERROR_CLASS, 0);
} else {
if (type->is_array()) {
ArrayType *array_type = (ArrayType *)type;
if (array_type->qualifiers & VARIABLE_LEN_QUAL)
set_semant_error(this, "Compound literal may not have "
"variable length array type %s",
array_type->name().c_str());
}
ExprType result;
result.ty = type;
if (result.ty->is_array())
result.cl = ARRAY_LVALUE;
else
result.cl = ACCESS_LVALUE;
string msg = "Compound literal has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
}
// expr -> IDSYM:name
operator VariableExpr extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
Declarator *def = (Declarator *)declarator.value();
if (def && def->c_type) {
CType *type = def->c_type;
string msg = "`" + string(get_name()->pooled_string().chars()) +
"' has type " + type->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
if (type->is_function())
return ExprType(FUNC_DESIG, type);
else if (type->is_array())
return ExprType(ARRAY_LVALUE, type);
else
return ExprType(MOD_LVALUE, type);
} else {
return ExprType(ERROR_CLASS, 0);
}
}
}
// expr -> expr:expr DOT IDSYM:field
operator StructAccess extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType orig_arg, arg;
if (!(orig_arg = get_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(arg = orig_arg.to_rvalue())) {
set_semant_error(this, "Can't use %s as argument to . operator",
arg.name().c_str());
}
if (arg.ty->unqualified()->is_pointer()) {
CType *ref = ((PointerType *)arg.ty->unqualified())->referent_type;
if (ref->unqualified()->is_struct_union()) {
bool union_p = ((StructUnionType*)ref->unqualified())
->is_union;
set_semant_error(this, "`.' on pointer to %s should be `->'",
union_p ? "union" : "structure");
return ExprType(ERROR_CLASS, 0);
}
} else if (!arg.ty->unqualified()->is_struct_union()) {
set_semant_error(this, "Left arg to '.' must have structure or"
" union type, not %s", arg.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
} else if (!arg.ty->unqualified()->completion()->is_complete()) {
set_semant_error(this, "Can't dereference incomplete %s type %s",
((StructUnionType *)arg.ty)->is_union
? "union" : "struct", arg.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
unsigned quals = arg.ty->qualifiers();
CompleteStructUnionType *obj = (CompleteStructUnionType *)
(arg.ty->unqualified()->completion());
PooledString field = get_field()->pooled_string();
CType *val = obj->table.resolve(field);
if (!val) {
set_semant_error(this, "%s has no member %s",
obj->name().c_str(), field.chars());
return ExprType(ERROR_CLASS, 0);
}
ExprType result;
if (val->is_array())
result.cl = orig_arg.is_lvalue() ? ARRAY_LVALUE : ARRAY_RVALUE;
else if (orig_arg.is_lvalue()) {
if (quals & CONST_QUAL || val->qualifiers() & CONST_QUAL)
result.cl = ACCESS_LVALUE;
else
result.cl = MOD_LVALUE;
} else
result.cl = RVALUE;
result.ty = val->qualified_by(quals);
string msg = string(obj->is_union ? "Union" : "Structure") +
" member has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
// expr -> expr:expr PTR IDSYM:field
operator PointerAccess extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType arg, orig_arg;
if (!(orig_arg = get_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(arg = orig_arg.to_rvalue())) {
set_semant_error(this, "Can't use %s as argument to -> operator",
arg.name().c_str());
}
if (arg.ty->unqualified()->is_struct_union()) {
bool union_p = ((StructUnionType *)arg.ty->unqualified())
->is_union;
set_semant_error(this, "`->' on %s should be `.'",
union_p ? "union" : "structure");
return ExprType(ERROR_CLASS, 0);
} else if (!arg.ty->unqualified()->is_pointer()) {
set_semant_error(this, "Left arg to '->' must have pointer to"
" structure or union type, not %s",
arg.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
CType *ref = ((PointerType *)arg.ty->unqualified())->referent_type;
unsigned quals = ref->qualifiers();
CType *ref_uq = ref->unqualified();
if (!ref_uq->is_struct_union()) {
set_semant_error(this, "Left arg to '->' must be pointer to"
" structure or union, not to %s",
ref->name().c_str());
return ExprType(ERROR_CLASS, 0);
} else if (!ref_uq->completion()->is_complete()) {
set_semant_error(this, "Can't dereference incomplete %s type %s",
((StructUnionType *)ref_uq)->is_union
? "union" : "struct", ref->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
CompleteStructUnionType *obj
= (CompleteStructUnionType *)(ref_uq->completion());
PooledString field = get_field()->pooled_string();
CType *val = obj->table.resolve(field);
if (!val) {
set_semant_error(this, "%s has no member %s",
obj->name().c_str(), field.chars());
return ExprType(ERROR_CLASS, 0);
}
ExprType result;
if (val->is_array())
result.cl = orig_arg.is_lvalue() ? ARRAY_LVALUE : ARRAY_RVALUE;
else if (orig_arg.is_lvalue()) {
if (quals & CONST_QUAL || val->qualifiers() & CONST_QUAL)
result.cl = ACCESS_LVALUE;
else
result.cl = MOD_LVALUE;
} else
result.cl = RVALUE;
result.ty = val->qualified_by(quals);
string msg = "Indirect " +
string(obj->is_union ? "union" : "structure") +
" member has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
}
// expr -> expr:expr LBRACK exprs:index RBRACK
operator ArrayAccess extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType outside, inside, tmp;
if (!(outside = get_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = outside.to_rvalue())) {
outside = tmp;
} else {
set_semant_error(this, "Can't use %s as object of subscript"
" operator",
outside.name().c_str());
}
if (!(inside = get_index()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = inside.to_rvalue())) {
inside = tmp;
} else {
set_semant_error(this, "Can't use %s as inside of subscript"
" operator",
inside.name().c_str());
}
if (inside.ty->is_pointer() + outside.ty->is_pointer() != 1) {
set_semant_error(this, "Exactly one arg to array subscript "
"operator must be a pointer in %s[%s]",
outside.ty->name().c_str(),
inside.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
PointerType *ptr_type;
CType *other_type;
if (outside.ty->is_pointer()) {
ptr_type = (PointerType*)outside.ty;
other_type = inside.ty;
} else {
ptr_type = (PointerType*)inside.ty;
other_type = outside.ty;
}
if (!other_type->is_integer()) {
set_semant_error(this, "Array index must have integer type, not "
"%s", other_type->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
IntegerType *idx_type = (IntegerType *)other_type;
ExprType result;
result.ty = ptr_type->referent_type;
if (result.ty->is_array())
result.cl = ARRAY_LVALUE;
else if (result.ty->qualifiers() & CONST_QUAL)
result.cl = ACCESS_LVALUE;
else
result.cl = MOD_LVALUE;
string msg = "Array index has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return true;
}
}
// expr -> TIMES expr:expr
operator PointerDereference extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType type, tmp;
if (!(type = get_expr()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = type.to_rvalue())) {
type = tmp;
} else {
set_semant_error(this, "Can't use %s as arg to `*'",
type.name().c_str());
}
PointerType *type_p;
if (type.ty->is_pointer())
type_p = (PointerType *)type.ty;
else {
set_semant_error(this, "Arg of `*' must have pointer "
"type, not %s", type.ty->name().c_str());
return ExprType(ERROR_CLASS, 0);
}
CType *referent = type_p->referent_type;
ExprType result;
if (referent->unqualified()->is_function())
result.cl = FUNC_DESIG;
else if (referent->unqualified()->is_object()) {
if (referent->qualifiers() & CONST_QUAL)
result.cl = ACCESS_LVALUE;
else
result.cl = MOD_LVALUE;
} else if (referent->unqualified()->is_void())
result.cl = VOID_EXPR;
else
result.cl = RVALUE;
result.ty = referent;
string msg = "Pointer dereference has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return true;
}
}
operator no_expr extends expr {
}
operator expr_sym extends expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return expr::phylum_cast(primary_alternative())
->determine_type(ctx);
}
public virtual method bool int_const_expr(TypecheckContext *ctx,
bignum_t *value) {
return expr::phylum_cast(primary_alternative())
->int_const_expr(ctx, value);
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return expr::phylum_cast(primary_alternative())->has_addr(ctx);
}
}
phylum arg_expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return ExprType(ERROR_CLASS, 0);
}
}
operator ExpressionArgument extends arg_expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return get_expr()->determine_type(ctx);
}
}
operator arg_expr_sym extends arg_expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return arg_expr::phylum_cast(primary_alternative())
->determine_type(ctx);
}
}
phylum designation {
}
// designation -> SeqR41E0star:desigs ASSIGN
operator Designation extends designation {
}
operator no_designation extends designation {
}
operator designation_sym extends designation {
}
phylum inner_init {
}
// inner_init -> OptR42E0:desig init_:init
operator InnerInitializer extends inner_init {
}
operator no_inner_init extends inner_init {
}
operator inner_init_sym extends inner_init {
}
phylum assign_expr depends on expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return ExprType(ERROR_CLASS, 0);
}
public virtual method bool int_const_expr(TypecheckContext *ctx,
bignum_t *value) {
return false;
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return false;
}
}
// assign_expr -> expr:left ASSIGN assign_expr:right
operator NormalAssign extends assign_expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType left, right, tmp;
if (!(left = get_left()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if (!(right = get_right()->determine_type(ctx)))
return ExprType(ERROR_CLASS, 0);
if ((tmp = left.to_mod_lvalue())) {
left = tmp;
} else {
set_semant_error(this, "Can't assign to %s", left.name().c_str());
}
if ((tmp = right.to_rvalue())) {
right = tmp;
} else {
set_semant_error(this, "Can't use %s as right arg to `='",
right.name().c_str());
}
CType *left_uq = left.ty->unqualified();
if (ExprType::assign_compat(left_uq, right, "assigment", this)) {
ExprType result;
result.ty = left_uq;
result.cl = RVALUE;
string msg = "Assignment has type " + result.ty->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return result;
} else {
return ExprType(ERROR_CLASS, 0);
}
}
}
// assign_expr -> expr:left MULASSIGN assign_expr:right
operator MultiplyAssign extends assign_expr {
}
// assign_expr -> expr:left DIVASSIGN assign_expr:right
operator DivideAssign extends assign_expr {
}
// assign_expr -> expr:left MODASSIGN assign_expr:right
operator ModAssign extends assign_expr {
}
// assign_expr -> expr:left ADDASSIGN assign_expr:right
operator AddAssign extends assign_expr {
}
// assign_expr -> expr:left SUBASSIGN assign_expr:right
operator SubtractAssign extends assign_expr {
}
// assign_expr -> expr:left SHLASSIGN assign_expr:right
operator ShiftLeftAssign extends assign_expr {
}
// assign_expr -> expr:left SHRASSIGN assign_expr:right
operator ShiftRightAssign extends assign_expr {
}
// assign_expr -> expr:left ANDASSIGN assign_expr:right
operator AndAssign extends assign_expr {
}
// assign_expr -> expr:left XORASSIGN assign_expr:right
operator XorAssign extends assign_expr {
}
// assign_expr -> expr:left ORASSIGN assign_expr:right
operator OrAssign extends assign_expr {
}
// assign_expr -> expr:expr
operator SimpleExpression extends assign_expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
ExprType type = get_expr()->determine_type(ctx);
// string msg = "Simple expression has type " + type->name();
// set_string_prop(MOUSE_OVER_MSG, msg.c_str());
// compute_synth_attrs(true);
return type;
}
public virtual method bool int_const_expr(TypecheckContext *ctx,
bignum_t *value) {
return get_expr()->int_const_expr(ctx, value);
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return get_expr()->has_addr(ctx);
}
}
operator no_assign_expr extends assign_expr {
}
operator assign_expr_sym extends assign_expr {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return assign_expr::phylum_cast(primary_alternative())
->determine_type(ctx);
}
public virtual method bool int_const_expr(TypecheckContext *ctx,
bignum_t *value) {
return assign_expr::phylum_cast(primary_alternative())
->int_const_expr(ctx, value);
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return assign_expr::phylum_cast(primary_alternative())->has_addr(ctx);
}
}
phylum pointer {
public virtual method CType *point_to(TypecheckContext *ctx,
CType *base_type) {
return base_type;
}
}
// pointer -> TIMES SeqR51E2star:quals OptR46E0:ptr
operator Pointer extends pointer depends on decl {
public virtual method CType *point_to(TypecheckContext *ctx,
CType *base_type) {
decl::TypeInfo quals_info;
CType *type = base_type->pointer_to();
for (quals_iterator i = get_quals(); i; ++i)
i.get_qual()->specify(&quals_info);
type = type->qualified_by(quals_info.quals);
if (has_ptr())
return get_ptr_ptr()->point_to(ctx, type);
else
return type;
}
}
operator no_pointer extends pointer {
}
operator pointer_sym extends pointer {
public virtual method CType *point_to(TypecheckContext *ctx,
CType *base_type) {
return pointer::phylum_cast(primary_alternative())
->point_to(ctx, base_type);
}
}
phylum direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return base_type;
}
}
// direct_declr -> IDSYM:name
operator DeclarNameDirDeclr extends direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *type) {
string name = get_name()->pooled_string().chars();
// if (!type->is_complete())
// set_semant_error(this, "Can't declare variable `%s' with "
// "incomplete type %s", name.c_str(),
// type->name().c_str());
string msg = name + " has type " + type->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
return type;
}
}
// direct_declr -> LPAREN OptR46E0:ptr direct_declr:direct RPAREN
operator ParenNameDirDeclr extends direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
CType *type = base_type;
if (has_ptr())
type = get_ptr_ptr()->point_to(ctx, type);
type = get_direct()->build_type(ctx, type);
return type;
}
}
// direct_declr -> direct_declr:declr LBRACK SeqR51E2star:quals OptR51E3:expr RBRACK
operator BasicArrayDirDeclr extends direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this,
"Array elements may not have function type");
if (!base_type->is_complete())
set_semant_error(this,
"Array elements may not have incomplete type");
decl::TypeInfo decl_info;
for (quals_iterator i = get_quals(); i; ++i)
i.get_qual()->specify(&decl_info);
unsigned quals = decl_info.quals;
CType *type;
if (has_expr()) {
ExprType size_type = get_expr_expr()->determine_type(ctx);
bignum_t size;
if (size_type.is_int_const()) {
get_expr_expr()->int_const_expr(ctx, &size);
} else if (size_type && size_type.ty->is_integer()) {
quals |= VARIABLE_LEN_QUAL;
} else {
set_semant_error(this, "Array size expression must have "
"integer type");
size = 1;
}
type = base_type->array_of(size, quals);
} else {
type = base_type->array_of(0, quals|INCOMPLETE_QUAL);
}
return get_declr()->build_type(ctx, type);
}
}
// direct_declr -> direct_declr:declr LBRACK SeqR51E2star:quals1 STATIC SeqR51E2star:quals2 assign_expr:expr RBRACK
operator StaticArrayDirDeclr extends direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this,
"Array elements may not have function type");
if (!base_type->is_complete())
set_semant_error(this,
"Array elements may not have incomplete type");
decl::TypeInfo decl_info;
for (quals1_iterator i = get_quals1(); i; ++i)
i.get_qual()->specify(&decl_info);
for (quals2_iterator i = get_quals2(); i; ++i)
i.get_qual()->specify(&decl_info);
unsigned quals = decl_info.quals;
ExprType size_type = get_expr()->determine_type(ctx);
bignum_t size;
if (size_type.is_int_const()) {
get_expr()->int_const_expr(ctx, &size);
} else if (size_type && size_type.ty->is_integer()) {
quals |= VARIABLE_LEN_QUAL;
} else {
set_semant_error(this, "Array size expression must have "
"integer type");
size = 1;
}
CType *type = base_type->array_of(size, quals|STATIC_QUAL);
return get_declr()->build_type(ctx, type);
}
}
// direct_declr -> direct_declr:declr LBRACK SeqR51E2star:quals TIMES RBRACK
operator VariableArrayDirDeclr extends direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this,
"Array elements may not have function type");
if (!base_type->is_complete())
set_semant_error(this,
"Array elements may not have incomplete type");
decl::TypeInfo decl_info;
for (quals_iterator i = get_quals(); i; ++i)
i.get_qual()->specify(&decl_info);
unsigned quals = decl_info.quals;
CType *type = base_type->array_of(0, quals|VARIABLE_LEN_QUAL);
return get_declr()->build_type(ctx, type);
}
}
// direct_declr -> direct_declr:declr LPAREN param_type_list:params RPAREN
operator TypeFuncListDirDeclr extends direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this, "Function may not return function type");
if (base_type->is_array())
set_semant_error(this, "Function may not return array type");
CType *type = get_params()->build_type(ctx, base_type);
return get_declr()->build_type(ctx, type);
}
}
// direct_declr -> direct_declr:declr LPAREN SeqR55E2star:idents RPAREN
operator IDFuncListDirDeclr extends direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this, "Function may not return function type");
if (base_type->is_array())
set_semant_error(this, "Function may not return array type");
type_vector no_params;
CType *type = base_type->function_taking(UNKNOWN_ARGS, no_params);
return get_declr()->build_type(ctx, type);
}
}
operator no_direct_declr extends direct_declr {
}
operator direct_declr_sym extends direct_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return direct_declr::phylum_cast(primary_alternative())
->build_type(ctx, base_type);
}
}
phylum direct_abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return base_type;
}
}
// direct_abst_declr -> LPAREN abst_declr:declr RPAREN
operator ParenAbstDecl extends direct_abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return get_declr()->build_type(ctx, base_type);
}
}
// direct_abst_declr -> OptR57E0:declr LBRACK OptR51E3:expr RBRACK
operator ArrayAbstDecl extends direct_abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this,
"Array elements may not have function type");
if (!base_type->is_complete())
set_semant_error(this,
"Array elements may not have incomplete type");
unsigned quals = 0;
CType *type;
if (has_expr()) {
ExprType size_type = get_expr_expr()->determine_type(ctx);
bignum_t size;
if (size_type.is_int_const()) {
get_expr_expr()->int_const_expr(ctx, &size);
} else if (size_type && size_type.ty->is_integer()) {
quals |= VARIABLE_LEN_QUAL;
} else {
set_semant_error(this, "Array size expression must have "
"integer type");
size = 1;
}
type = base_type->array_of(size, quals);
} else {
type = base_type->array_of(0, quals|INCOMPLETE_QUAL);
}
if (has_declr())
return get_declr_declr()->build_type(ctx, type);
else
return type;
}
}
// direct_abst_declr -> OptR57E0:declr LBRACK TIMES RBRACK
operator VariableAbstDecl extends direct_abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this,
"Array elements may not have function type");
if (!base_type->is_complete())
set_semant_error(this,
"Array elements may not have incomplete type");
CType *type = base_type->array_of(0, VARIABLE_LEN_QUAL);
if (has_declr())
return get_declr_declr()->build_type(ctx, type);
else
return type;
}
}
// direct_abst_declr -> direct_abst_declr:declr LPAREN OptR59E2:params RPAREN
operator NestedFuncAbstDecl extends direct_abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this, "Function may not return function type");
if (base_type->is_array())
set_semant_error(this, "Function may not return array type");
CType *type;
if (has_params()) {
type = get_params_params()->build_type(ctx, base_type);
} else {
type_vector no_params;
type = base_type->function_taking(UNKNOWN_ARGS, no_params);
}
return get_declr()->build_type(ctx, type);
}
}
// direct_abst_declr -> LPAREN OptR59E2:params RPAREN
operator FuncAbstDecl extends direct_abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
if (base_type->is_function())
set_semant_error(this, "Function may not return function type");
if (base_type->is_array())
set_semant_error(this, "Function may not return array type");
CType *type;
if (has_params()) {
type = get_params_params()->build_type(ctx, base_type);
} else {
type_vector no_params;
type = base_type->function_taking(UNKNOWN_ARGS, no_params);
}
return type;
}
}
operator no_direct_abst_declr extends direct_abst_declr {
}
operator direct_abst_declr_sym extends direct_abst_declr {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return direct_abst_declr::phylum_cast(primary_alternative())
->build_type(ctx, base_type);
}
}
phylum param_type_list {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return base_type;
}
}
// param_type_list -> SeqR67E0star:decls OptR67E1:dotdotdot
operator ParameterTypeList extends param_type_list {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
unsigned flags = 0;
type_vector params;
if (has_dotdotdot())
flags |= ELLIPTICAL;
for (decls_iterator i = get_decls(); i; ++i)
params.push_back(i.get_decl()->get_type(ctx));
if (params.size() == 1 && params[0]->is_void()) {
params = type_vector();
} else {
for (type_vector::iterator i = params.begin();
i != params.end(); i++) {
if (!(*i)->is_complete()) {
set_semant_error(this, "Function declared with incomplete "
"argument type %s", (*i)->name().c_str());
}
}
}
return base_type->function_taking(flags, params);
}
}
operator no_param_type_list extends param_type_list {
}
operator param_type_list_sym extends param_type_list {
public virtual method CType *build_type(TypecheckContext *ctx,
CType *base_type) {
return param_type_list::phylum_cast(primary_alternative())
->build_type(ctx, base_type);
}
}
phylum struct_declr {
public virtual method void check_member(TypecheckContext *ctx,
CompleteStructUnionType *members,
CType *base_type) {
}
}
// struct_declr -> declr:declr
operator StructDeclr extends struct_declr {
public virtual method void check_member(TypecheckContext *ctx,
CompleteStructUnionType *members,
CType *base_type) {
CType *type = get_declr()->build_type(ctx, base_type);
IDSYM *name_node = get_declr()->find_name();
PooledString ident = name_node->pooled_string();
members->table.add(ident, type);
}
}
// struct_declr -> OptR63E0:declr COLON expr:expr
operator BitfieldDeclr extends struct_declr {
public virtual method void check_member(TypecheckContext *ctx,
CompleteStructUnionType *members,
CType *base_type) {
if (!base_type->unqualified()->is_integer()) {
set_semant_error(this, "Bitfield must have integer type, not %s",
base_type->name().c_str());
return;
}
unsigned quals = base_type->qualifiers();
IntegerType *int_type = (IntegerType *)base_type->unqualified();
if (!int_type->bitfield_okay()) {
set_semant_error(this, "Bitfield must have _Bool, int, or "
"unsigned int type, not %s",
int_type->name().c_str());
return;
}
ExprType width_type = get_expr()->determine_type(ctx);
bignum_t width;
if (width_type.is_int_const()) {
get_expr()->int_const_expr(ctx, &width);
} else {
set_semant_error(this, "Bitfield width expression must be "
"an integer constant");
width = 1;
}
if (width > int_type->bitfield_width()) {
set_semant_error(this, "Bitfield width cannot be larger than "
"width (%d bit%s) of %s",
int_type->bitfield_width(),
(int_type->bitfield_width() > 1 ? "s" : ""),
int_type->name().c_str());
width = 1;
}
base_type = int_type->bitfield_of(width)->qualified_by(quals);
if (has_declr()) {
CType *type = get_declr_declr()->build_type(ctx, base_type);
IDSYM *name_node = get_declr_declr()->find_name();
PooledString ident = name_node->pooled_string();
members->table.add(ident, type);
}
}
}
operator no_struct_declr extends struct_declr {
}
operator struct_declr_sym extends struct_declr {
public virtual method void check_member(TypecheckContext *ctx,
CompleteStructUnionType *members,
CType *base_type) {
struct_declr::phylum_cast(primary_alternative())
->check_member(ctx, members, base_type);
}
}
phylum param_decl {
public virtual method CType *get_type(TypecheckContext *ctx) {
return &ctx->the_UnimplementedType;
}
}
// param_decl -> SeqR1E0star:specs declr:declr
operator NamedParamDecl extends param_decl {
public virtual method CType *get_type(TypecheckContext *ctx) {
decl::TypeInfo base_info;
for (specs_iterator i = get_specs(); i; ++i)
i.get_spec()->specify(ctx, &base_info);
CType *base_type = decl::assemble_base_type(ctx, this, &base_info);
return get_declr()->build_type(ctx, base_type);
}
}
// param_decl -> SeqR1E0star:specs OptR13E1:declr
operator UnnamedParamDecl extends param_decl {
public virtual method CType *get_type(TypecheckContext *ctx) {
decl::TypeInfo base_info;
for (specs_iterator i = get_specs(); i; ++i)
i.get_spec()->specify(ctx, &base_info);
CType *base_type = decl::assemble_base_type(ctx, this, &base_info);
if (has_declr())
return get_declr_declr()->build_type(ctx, base_type);
else
return base_type;
}
// if (ctx->decl_cx == DEF_PARAM &&
// base_type.spec_bits != decl::VOID)
// set_semant_error(this, "Unnamed params not allowed in "
// "function definition");
}
operator no_param_decl extends param_decl {
}
operator param_decl_sym extends param_decl {
public virtual method CType *get_type(TypecheckContext *ctx) {
return param_decl::phylum_cast(primary_alternative())->get_type(ctx);
}
}
phylum for_init {
public virtual method void check_types(TypecheckContext *ctx) {
}
}
// for_init -> OptR68E0:expr SEMI
operator ExpressionInit extends for_init {
public virtual method void check_types(TypecheckContext *ctx) {
if (has_expr()) {
ExprType type = get_expr_expr()->determine_type(ctx);
}
}
}
// for_init -> decl:decl
operator DeclarationInit extends for_init {
public virtual method void check_types(TypecheckContext *ctx) {
get_decl()->check_types(ctx);
}
}
operator no_for_init extends for_init {
}
operator for_init_sym extends for_init {
public virtual method void check_types(TypecheckContext *ctx) {
for_init::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum exprs {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return ExprType(ERROR_CLASS, 0);
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return false;
}
}
// exprs -> exprs:left COMMA assign_expr:right
operator CommaList extends exprs {
}
// exprs -> assign_expr:expr
operator SingleExpr extends exprs {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return get_expr()->determine_type(ctx);
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return get_expr()->has_addr(ctx);
}
}
operator no_exprs extends exprs {
}
operator exprs_sym extends exprs {
public virtual method ExprType determine_type(TypecheckContext *ctx) {
return exprs::phylum_cast(primary_alternative())->determine_type(ctx);
}
public virtual method bool has_addr(TypecheckContext *ctx) {
return exprs::phylum_cast(primary_alternative())->has_addr(ctx);
}
}
phylum stmt {
public virtual method void check_types(TypecheckContext *ctx) {
}
}
// stmt -> IDSYM:label COLON stmt:stmt
operator LabeledStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
get_stmt()->check_types(ctx);
}
}
// stmt -> CASE expr:expr COLON stmt:stmt
operator CaseLabelStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
ExprType type = get_expr()->determine_type(ctx);
if (type && !type.is_int_const())
set_semant_error(this, "Case label expression must be integer "
"constant expression");
get_stmt()->check_types(ctx);
}
}
// stmt -> DEFAULT COLON stmt:stmt
operator DefaultLabelStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
get_stmt()->check_types(ctx);
}
}
// stmt -> OptR68E0:expr SEMI
operator ExprStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
if (has_expr()) {
ExprType type = get_expr_expr()->determine_type(ctx);
}
}
}
// stmt -> comp_stmt:stmt
operator CompoundStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
get_stmt()->check_types(ctx);
}
}
// stmt -> IF LPAREN exprs:pred RPAREN stmt:t_stmt
operator IfNoElseStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
ExprType type = get_pred()->determine_type(ctx);
if (type && !type.ty->is_scalar())
set_semant_error(this, "Predicate in `if' statement must have "
"scalar type, not %s", type.ty->name().c_str());
get_t_stmt()->check_types(ctx);
}
}
// stmt -> IF LPAREN exprs:pred RPAREN stmt:t_stmt ELSE stmt:f_stmt
operator IfElseStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
ExprType type = get_pred()->determine_type(ctx);
if (type && !type.ty->is_scalar())
set_semant_error(this, "Predicate in `if' statement must have "
"scalar type, not %s", type.ty->name().c_str());
get_t_stmt()->check_types(ctx);
get_f_stmt()->check_types(ctx);
}
}
// stmt -> SWITCH LPAREN exprs:val RPAREN stmt:stmt
operator SwitchStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
ExprType type = get_val()->determine_type(ctx);
if (type && !type.ty->is_integer())
set_semant_error(this, "Expression in `switch' statement must have"
" integer type, not %s",
type.ty->name().c_str());
get_stmt()->check_types(ctx);
}
}
// stmt -> WHILE LPAREN exprs:val RPAREN stmt:stmt
operator WhileStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
ExprType type = get_val()->determine_type(ctx);
if (type && !type.ty->is_scalar())
set_semant_error(this, "Predicate in `while' statement must have "
"scalar type, not %s", type.ty->name().c_str());
get_stmt()->check_types(ctx);
}
}
// stmt -> DO stmt:stmt WHILE LPAREN exprs:val RPAREN SEMI
operator DoWhileStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
ExprType type = get_val()->determine_type(ctx);
if (type && !type.ty->is_scalar())
set_semant_error(this, "Predicate in do-while statement must have "
"scalar type, not %s", type.ty->name().c_str());
get_stmt()->check_types(ctx);
}
}
// stmt -> FOR LPAREN for_init:init OptR80E3:pred SEMI OptR80E5:inc RPAREN stmt:stmt
operator ForStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
get_init()->check_types(ctx);
if (has_pred()) {
ExprType type = get_pred_expr()->determine_type(ctx);
if (type && !type.ty->is_scalar())
set_semant_error(this, "Predicate in `for' statement must"
" have scalar type, not %s",
type.ty->name().c_str());
}
if (has_inc()) {
ExprType type = get_inc_expr()->determine_type(ctx);
}
get_stmt()->check_types(ctx);
}
}
// stmt -> GOTO IDSYM:label SEMI
operator GotoStatement extends stmt {
}
// stmt -> CONTINUE SEMI
operator ContinueStatement extends stmt {
}
// stmt -> BREAK SEMI
operator BreakStatement extends stmt {
}
// stmt -> RETURN OptR84E1:ret SEMI
operator ReturnStatement extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
if (has_ret()) {
ExprType tmp, type = get_ret_expr()->determine_type(ctx);
if (!type)
return;
if ((tmp = type.to_rvalue())) {
type = tmp;
} else {
set_semant_error(this, "Can't use %s as arg to return",
type.name().c_str());
}
if (ctx->return_type->is_void()) {
set_semant_error(this, "Attempt to return a value of type %s "
"from a function declared to return void",
type.ty->name().c_str());
} else {
// This sets its own error messages
ExprType::assign_compat(ctx->return_type->unqualified(), type,
"return", this);
}
} else {
if (!ctx->return_type->is_void()) {
set_semant_error(this, "Return of no value from a function "
"declared to return %s",
ctx->return_type->name().c_str());
return;
}
}
string msg = "Return type declared to be " + ctx->return_type->name();
set_string_prop(MOUSE_OVER_MSG, msg.c_str());
compute_synth_attrs(true);
}
}
operator no_stmt extends stmt {
}
operator stmt_sym extends stmt {
public virtual method void check_types(TypecheckContext *ctx) {
stmt::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum block_item {
public virtual method void check_types(TypecheckContext *ctx) {
}
}
// block_item -> decl:decl
operator DeclarationItem extends block_item {
public virtual method void check_types(TypecheckContext *ctx) {
get_decl()->check_types(ctx);
}
}
// block_item -> stmt:stmt
operator StatementItem extends block_item {
public virtual method void check_types(TypecheckContext *ctx) {
get_stmt()->check_types(ctx);
}
}
operator no_block_item extends block_item {
}
operator block_item_sym extends block_item {
public virtual method void check_types(TypecheckContext *ctx) {
block_item::phylum_cast(primary_alternative())->check_types(ctx);
}
}
phylum int_const {
public virtual method bignum_t get_value(TypecheckContext *ctx,
bool *decimal) {
return 0;
}
public virtual method CType *determine_type(TypecheckContext *ctx) {
return &ctx->the_UnimplementedType;
}
public static method bignum_t parse_int(const char *s, bool *decimal) {
bignum_t value;
if (s[0] == '0') {
if (!s[1] || s[1] == 'u' || s[1] == 'U' ||
s[1] == 'l' || s[1] == 'L') {
*decimal = true;
return 0;
} else if (s[1] == 'x' || s[1] == 'X') {
*decimal = false;
sscanf(&s[2], "%llx", &value);
return value;
} else if (s[1] >= '1' && s[1] <= '9') {
*decimal = false;
sscanf(&s[1], "%llo", &value);
return value;
} else {
// error("Unexpected character after '0' in integer\n");
return 0;
}
} else {
// assert(s[0] >= '1' && s[0] <= '9');
*decimal = true;
sscanf(s, "%lld", &value);
return value;
}
}
}
// int_const -> INT_CONST:it
operator PlainIntegerConstant extends int_const {
public virtual method bignum_t get_value(TypecheckContext *ctx,
bool *decimal) {
const char *s = get_it()->pooled_string().chars();
return int_const::parse_int(s, decimal);
}
public virtual method CType *determine_type(TypecheckContext *ctx) {
bool decimal;
bignum_t value = get_value(ctx, &decimal);
if (decimal) {
if (value <= ctx->the_SignedIntType.max_val())
return &ctx->the_SignedIntType;
else if (value <= ctx->the_LongIntType.max_val())
return &ctx->the_LongIntType;
else if (value <= ctx->the_LongLongIntType.max_val())
return &ctx->the_LongLongIntType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_LongLongIntType;
}
} else {
if (value <= ctx->the_SignedIntType.max_val())
return &ctx->the_SignedIntType;
else if (value <= ctx->the_UnsignedIntType.max_val())
return &ctx->the_UnsignedIntType;
else if (value <= ctx->the_LongIntType.max_val())
return &ctx->the_LongIntType;
else if (value <= ctx->the_UnsignedLongType.max_val())
return &ctx->the_UnsignedLongType;
else if (value <= ctx->the_LongLongIntType.max_val())
return &ctx->the_LongLongIntType;
else if (value <= ctx->the_UnsignedLongLongType.max_val())
return &ctx->the_UnsignedLongLongType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_UnsignedLongLongType;
}
}
}
}
// int_const -> INT_CONST_U:it
operator UnsignedIntegerConstant extends int_const {
public virtual method bignum_t get_value(TypecheckContext *ctx,
bool *decimal) {
const char *s = get_it()->pooled_string().chars();
return int_const::parse_int(s, decimal);
}
public virtual method CType *determine_type(TypecheckContext *ctx) {
bool decimal;
bignum_t value = get_value(ctx, &decimal);
if (value <= ctx->the_UnsignedIntType.max_val())
return &ctx->the_UnsignedIntType;
else if (value <= ctx->the_UnsignedLongType.max_val())
return &ctx->the_UnsignedLongType;
else if (value <= ctx->the_UnsignedLongLongType.max_val())
return &ctx->the_UnsignedLongLongType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_UnsignedLongLongType;
}
}
}
// int_const -> INT_CONST_L:it
operator LongIntegerConstant extends int_const {
public virtual method bignum_t get_value(TypecheckContext *ctx,
bool *decimal) {
const char *s = get_it()->pooled_string().chars();
return int_const::parse_int(s, decimal);
}
public virtual method CType *determine_type(TypecheckContext *ctx) {
bool decimal;
bignum_t value = get_value(ctx, &decimal);
if (decimal) {
if (value <= ctx->the_LongIntType.max_val())
return &ctx->the_LongIntType;
else if (value <= ctx->the_LongLongIntType.max_val())
return &ctx->the_LongLongIntType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_LongLongIntType;
}
} else {
if (value <= ctx->the_LongIntType.max_val())
return &ctx->the_LongIntType;
else if (value <= ctx->the_UnsignedLongType.max_val())
return &ctx->the_UnsignedLongType;
else if (value <= ctx->the_LongLongIntType.max_val())
return &ctx->the_LongLongIntType;
else if (value <= ctx->the_UnsignedLongLongType.max_val())
return &ctx->the_UnsignedLongLongType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_UnsignedLongLongType;
}
}
}
}
// int_const -> INT_CONST_UL:it
operator UnsignedLongIntegerConstant extends int_const {
public virtual method bignum_t get_value(TypecheckContext *ctx,
bool *decimal) {
const char *s = get_it()->pooled_string().chars();
return int_const::parse_int(s, decimal);
}
public virtual method CType *determine_type(TypecheckContext *ctx) {
bool decimal;
bignum_t value = get_value(ctx, &decimal);
if (value <= ctx->the_UnsignedLongType.max_val())
return &ctx->the_UnsignedLongType;
else if (value <= ctx->the_UnsignedLongLongType.max_val())
return &ctx->the_UnsignedLongLongType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_UnsignedLongLongType;
}
}
}
// int_const -> INT_CONST_LL:it
operator LongLongIntegerConstant extends int_const {
public virtual method bignum_t get_value(TypecheckContext *ctx,
bool *decimal) {
const char *s = get_it()->pooled_string().chars();
return int_const::parse_int(s, decimal);
}
public virtual method CType *determine_type(TypecheckContext *ctx) {
bool decimal;
bignum_t value = get_value(ctx, &decimal);
if (decimal) {
if (value <= ctx->the_LongLongIntType.max_val())
return &ctx->the_LongLongIntType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_LongLongIntType;
}
} else {
if (value <= ctx->the_LongLongIntType.max_val())
return &ctx->the_LongLongIntType;
else if (value <= ctx->the_UnsignedLongLongType.max_val())
return &ctx->the_UnsignedLongLongType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_UnsignedLongLongType;
}
}
}
}
// int_const -> INT_CONST_ULL:it
operator UnsignedLongLongIntegerConstant extends int_const {
public virtual method bignum_t get_value(TypecheckContext *ctx,
bool *decimal) {
const char *s = get_it()->pooled_string().chars();
return int_const::parse_int(s, decimal);
}
public virtual method CType *determine_type(TypecheckContext *ctx) {
bool decimal;
bignum_t value = get_value(ctx, &decimal);
if (value <= ctx->the_UnsignedLongLongType.max_val())
return &ctx->the_UnsignedLongLongType;
else {
set_semant_error(this, "Integer constant too big");
return &ctx->the_UnsignedLongLongType;
}
}
}
operator no_int_const extends int_const {
}
operator int_const_sym extends int_const {
public virtual method bignum_t get_value(TypecheckContext *ctx,
bool *decimal) {
return int_const::phylum_cast(primary_alternative())
->get_value(ctx, decimal);
}
public virtual method CType *determine_type(TypecheckContext *ctx) {
return int_const::phylum_cast(primary_alternative())
->determine_type(ctx);
}
}
phylum char_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return &ctx->the_UnimplementedType;
}
}
// char_const -> CHAR_CONST:it
operator PlainCharacterConstant extends char_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return &ctx->the_SignedIntType;
}
}
// char_const -> WIDE_CHAR_CONST:it
operator WideCharacterConstant extends char_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return ctx->the_WideCharType;
}
}
operator no_char_const extends char_const {
}
operator char_const_sym extends char_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return char_const::phylum_cast(primary_alternative())
->determine_type(ctx);
}
}
phylum float_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return &ctx->the_UnimplementedType;
}
}
// float_const -> FLOAT_CONST:it
operator FloatConstant extends float_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return &ctx->the_FloatType;
}
}
// float_const -> DOUBLE_CONST:it
operator DoubleConstant extends float_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return &ctx->the_DoubleType;
}
}
// float_const -> LONGDOUBLE_CONST:it
operator LongDoubleConstant extends float_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return &ctx->the_LongDoubleType;
}
}
operator no_float_const extends float_const {
}
operator float_const_sym extends float_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return float_const::phylum_cast(primary_alternative())
->determine_type(ctx);
}
}
phylum str_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return &ctx->the_UnimplementedType;
}
public static method string unquote(PooledString ps) {
string s = ps.chars();
s = s.substr(1, s.length() - 2);
return s;
}
public static method int real_length(const char *s) {
const char *p = s;
int len;
for (len = 0; *p; len++) {
if (*p == '\\') {
p++;
switch (*p) {
case 'u': p += 4+1; break;
case 'U': p += 8+1; break;
case 'x':
p++;
while (isxdigit(*p))
p++;
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
p++;
if (*p >= '0' && *p < '8')
p++;
if (*p >= '0' && *p < '8')
p++;
break;
default:
p++;
}
} else {
p++;
}
}
return len;
}
}
// str_const -> SeqR151E0star:strs
operator PlainStringConstant extends str_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
int len = 0;
for (strs_iterator i = get_strs(); i; ++i)
len += real_length(unquote(i.get_str()->pooled_string()).c_str());
return ctx->the_PlainCharType.array_of(len + 1);
}
}
// str_const -> SeqR152E0star:strs
operator WideStringConstant extends str_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
int len = 0;
for (strs_iterator i = get_strs(); i; ++i)
len += real_length(unquote(i.get_str()->pooled_string()).c_str());
return ctx->the_WideCharType->array_of(len + 1);
}
}
operator no_str_const extends str_const {
}
operator str_const_sym extends str_const {
public virtual method CType *determine_type(TypecheckContext *ctx) {
return str_const::phylum_cast(primary_alternative())
->determine_type(ctx);
}
}