note
description: "[
Generator for custom attributes (CA) in CIL code generation.
It follows the description of the ECMA standard for CLI Partition II-23.3.
There is a difference between fixed argument, i.e. argument set because the
CA's constructor needs them, and named argument which corresponds to public
field or property with a setter.
]"
legal: "See notice at end of class."
status: "See notice at end of class."
eweasel: "dotnet018"
date: "$Date$"
revision: "$Revision$"
class
CUSTOM_ATTRIBUTE_GENERATOR
inherit
BYTE_NODE_NULL_VISITOR
redefine
process_array_const_b,
process_bool_const_b,
process_char_const_b,
process_constant_b,
process_external_b,
process_integer_constant,
process_null_conversion_b,
process_paran_b,
process_real_const_b,
process_string_b,
process_type_expr_b,
process_void_b
end
SHARED_WORKBENCH
export
{NONE} all
end
REFACTORING_HELPER
export
{NONE} all
end
COMPILER_EXPORTER
export
{NONE} all
end
INTERNAL_COMPILER_STRING_EXPORTER
export
{NONE} all
end
feature -- Code generation
generate (a_ca: CUSTOM_ATTRIBUTE_B; a_owner_token: INTEGER; a_code_generator: CIL_CODE_GENERATOR)
-- Generate `a_ca'.
require
a_ca_not_void: a_ca /= Void
a_owner_token_valid: a_owner_token /= 0
a_code_generator_not_void: a_code_generator /= Void
local
cb: CREATION_EXPR_B
l_extension: IL_EXTENSION_I
count: INTEGER
param: BYTE_LIST [EXPR_B]
l_tuple_const: ARRAYED_LIST [TUPLE [STRING_B, EXPR_B]]
l_ctor_token: INTEGER
l_creation_class: CLASS_C
do
cil_generator := a_code_generator
cb := a_ca.creation_expr
if
cb /= Void and then
attached {CL_TYPE_A} cb.type as l_cb_type
then
l_creation_class := l_cb_type.base_class
l_tuple_const := a_ca.named_arguments
param := cb.call.parameters
if param /= Void then
count := param.count
else
count := 0
end
if cb.type.is_external then
if
attached {EXTERNAL_B} cb.call as l_creation_external and then
attached {IL_EXTENSION_I} l_creation_external.extension as ext
then
l_extension := ext
l_ctor_token := l_extension.token
else
l_extension := Void
end
end
if l_extension = Void then
if attached {CL_TYPE_A} cb.type as l_type then
if count = 0 then
-- Use default constructor
l_ctor_token := cil_generator.constructor_token (l_type.associated_class_type (a_code_generator.current_class_type.type).implementation_id)
else
l_ctor_token := cil_generator.inherited_constructor_token (l_type.associated_class_type (a_code_generator.current_class_type.type).implementation_id, cb.call.feature_id)
end
else
check is_cl_type_a: False end
end
end
-- Start initialization of custom attribute.
create ca_blob.make
-- Generate value of arguments if any.
if count > 0 then
from
param.start
until
param.after
loop
if
attached {PARAMETER_B} param.item as param_b and then
attached {CL_TYPE_A} param_b.attachment_type as l_param_type
then
set_target_type (l_param_type)
param_b.expression.process (Current)
else
check is_param_b_with_type_a: False end
end
param.forth
end
end
-- Generate name argument
if l_tuple_const /= Void then
ca_blob.put_integer_16 (l_tuple_const.count.to_integer_16)
from
l_tuple_const.start
until
l_tuple_const.after
loop
add_named_argument (l_creation_class, l_tuple_const.item)
l_tuple_const.forth
end
else
ca_blob.put_integer_16 (0)
end
-- Assign `ca_blob' to `a_owner_token'.
cil_generator.define_custom_attribute (a_owner_token, l_ctor_token, ca_blob)
else
-- FIXME: should not occur
check has_creation: False end
end
-- Reset current
cil_generator := Void
target_type := Void
ca_blob := Void
end
feature {NONE} -- Access
target_type: TYPE_A
-- Actual expected type of custom attribute argument or optional argument.
cil_generator: CIL_CODE_GENERATOR
-- Back-end of custom attribute code generator.
ca_blob: MD_CUSTOM_ATTRIBUTE
-- Blob used for storing custom attribute.
feature {NONE} -- Setting
set_target_type (a_type: like target_type)
-- Set `a_type' to `target_type'.
do
target_type := a_type
ensure
target_type_set: target_type = a_type
end
feature {BYTE_NODE} -- Visitors
process_array_const_b (a_node: ARRAY_CONST_B)
-- Process `a_node'.
local
l_expressions: BYTE_LIST [BYTE_NODE]
l_old_target_type: like target_type
l_type: TYPE_A
do
check is_constant_expression: a_node.is_constant_expression end
l_expressions := a_node.expressions
check not a_node.type.generics.is_empty end
l_type := a_node.type.generics [1]
if is_target_object then
-- Mark the fact it is an array when not a fixed argument
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_szarray)
-- Mark the type of elements.
insert_field_or_prop_type (l_type)
end
-- Put number of elements in array.
ca_blob.put_natural_32 (l_expressions.count.to_natural_32)
-- Process elements.
from
-- Store context.
l_old_target_type := target_type
-- All elements have the same target type.
set_target_type (l_type)
l_expressions.start
until
l_expressions.after
loop
if attached {EXPR_B} l_expressions.item as l_expr then
l_expr.process (Current)
else
check is_expr_b: False end
end
l_expressions.forth
end
-- Restore context
set_target_type (l_old_target_type)
end
process_bool_const_b (a_node: BOOL_CONST_B)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
if is_target_object then
ca_blob.put_integer_8 (a_node.type.element_type)
end
ca_blob.put_boolean (a_node.value)
end
process_char_const_b (a_node: CHAR_CONST_B)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
if is_target_object then
ca_blob.put_integer_8 (a_node.type.element_type)
end
if a_node.is_character_32 then
ca_blob.put_natural_32 (a_node.value.natural_32_code)
else
ca_blob.put_character (a_node.value.to_character_8)
end
end
process_constant_b (a_node: CONSTANT_B)
-- Process `a_node'.
local
l_value: VALUE_I
l_type: TYPE_A
do
check is_constant_expression: a_node.is_constant_expression end
l_type := a_node.type
if is_target_object and l_type.is_basic then
ca_blob.put_integer_8 (l_type.element_type)
end
l_value := a_node.value
if l_value.is_integer then
if attached {INTEGER_CONSTANT} l_value as l_int then
insert_integer_constant (l_int)
else
check is_integer: False end
end
elseif l_value.is_string then
if attached {STRING_VALUE_I} l_value as l_string then
ca_blob.put_string (l_string.string_value_32)
else
check is_string: False end
end
elseif l_value.is_boolean then
if attached {BOOL_VALUE_I} l_value as l_bool then
ca_blob.put_boolean (l_bool.boolean_value)
else
check is_boolean: False end
end
elseif l_value.is_character then
if
attached {CHAR_VALUE_I} l_value as l_char and
attached {CHARACTER_A} target_type as l_char_type
then
if l_char_type.is_character_32 then
ca_blob.put_natural_32 (l_char.character_value.natural_32_code)
else
ca_blob.put_character (l_char.character_value.to_character_8)
end
else
check
is_character: False
is_target_of_char_type: False
end
end
elseif l_value.is_real then
if attached {REAL_VALUE_I} l_value as l_real then
if target_type.is_real_32 then
ca_blob.put_real_32 (l_real.real_32_value)
elseif target_type.is_real_64 then
ca_blob.put_real_64 (l_real.real_64_value)
else
-- Case where target is System.object.
check is_target_object end
if l_value.is_real_32 then
ca_blob.put_real_32 (l_real.real_32_value)
else
ca_blob.put_real_64 (l_real.real_64_value)
end
end
else
check is_real: False end
end
else
check not_supported: False end
end
end
process_external_b (a_node: EXTERNAL_B)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
if attached {IL_ENUM_EXTENSION_I} a_node.extension as l_il_enum then
if is_target_object then
if attached {CL_TYPE_A} a_node.type as l_cl_type then
insert_enum_type (l_cl_type)
else
check is_cl_type_a: False end
end
end
insert_integer_constant (l_il_enum.value)
else
check not_supported: False end
end
end
process_integer_constant (a_node: INTEGER_CONSTANT)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
if is_target_object then
ca_blob.put_integer_8 (a_node.type.element_type)
end
insert_integer_constant (a_node)
end
process_null_conversion_b (a_node: NULL_CONVERSION_B)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
a_node.expr.process (Current)
end
process_paran_b (a_node: PARAN_B)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
a_node.expr.process (Current)
end
process_real_const_b (a_node: REAL_CONST_B)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
if is_target_object then
ca_blob.put_integer_8 (a_node.type.element_type)
end
if target_type.is_real_32 then
ca_blob.put_real_32 (a_node.value.to_real)
elseif target_type.is_real_64 then
ca_blob.put_real_64 (a_node.value.to_double)
else
check is_target_object end
if a_node.type.is_real_32 then
ca_blob.put_real_32 (a_node.value.to_real)
else
ca_blob.put_real_64 (a_node.value.to_double)
end
end
end
process_string_b (a_node: STRING_B)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
if is_target_object then
-- Force the type to be a .NET SYSTEM_STRING as `a_node' is
-- still considered as being an Eiffel string.
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_string)
end
ca_blob.put_string (a_node.value_32)
end
process_type_expr_b (a_node: TYPE_EXPR_B)
-- Process `a_node'.
local
l_class_type: CLASS_TYPE
l_type_name: STRING_32
do
check is_constant_expression: a_node.is_constant_expression end
if is_target_object then
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_type)
end
if a_node.is_dotnet_type then
l_class_type := a_node.type.associated_class_type (cil_generator.current_class_type.type)
elseif attached {GEN_TYPE_A} a_node.type as l_gen_type and then l_gen_type.generics.count > 0 then
if attached {CL_TYPE_A} l_gen_type.generics[1] as l_actual_type then
l_class_type := l_actual_type.associated_class_type (cil_generator.current_class_type.type)
end
else
check
a_node_type_with_non_empty_generics: False
end
end
if l_class_type /= Void then
create l_type_name.make_from_string_general (l_class_type.full_il_type_name)
if l_class_type.is_precompiled and then not l_class_type.is_external then
l_type_name.append_character (',')
l_type_name.append_character (' ')
l_type_name.append_string_general (l_class_type.assembly_info.full_name)
else
if attached {EXTERNAL_CLASS_C} l_class_type.associated_class as l_ext_class then
l_type_name.append_character (',')
l_type_name.append_character (' ')
l_type_name.append (l_ext_class.assembly.full_name)
end
end
ca_blob.put_string (l_type_name)
end
end
process_void_b (a_node: VOID_B)
-- Process `a_node'.
do
check is_constant_expression: a_node.is_constant_expression end
if
attached {CL_TYPE_A} target_type as l_cl_type and then
l_cl_type.base_class = system.native_array_class.compiled_class
then
-- We insert the value 0xFFFFFFFF to show that it is a Void array.
ca_blob.put_integer_32 (0xFFFFFFFF)
else
check not_supported: False end
end
end
feature {NONE} -- Implemention
is_target_object: BOOLEAN
-- Is `a_type' of type System.Object?
require
target_type_not_void: target_type /= Void
do
if attached {CL_TYPE_A} target_type as l_cl_type then
Result := l_cl_type.class_id = system.system_object_id or
l_cl_type.class_id = system.any_id
end
end
add_named_argument (a_class: CLASS_C; a_tuple: TUPLE [str: STRING_B; exp: EXPR_B])
-- Lookup named argument in `a_tuple' and insert it in `ca_blob'.
require
blob_not_void: ca_blob /= Void
tuple_not_void: a_tuple /= Void
tuple_valid: a_tuple.str /= Void and then a_tuple.exp /= Void
local
l_expr_b: EXPR_B
l_feat: FEATURE_I
l_string_b: STRING_B
l_feat_name: STRING
l_type: TYPE_A
do
l_string_b := a_tuple.str
l_expr_b := a_tuple.exp
check
has_string: l_string_b /= Void
has_expression: l_expr_b /= Void
end
l_feat_name := l_string_b.value.as_lower
l_feat := a_class.feature_table.item (l_feat_name)
-- Not Void because it must have passed the type checking.
check has_feature: l_feat /= Void end
-- First mark if it is an attribute or a property.
if l_feat.is_attribute then
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_field)
else
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_property)
end
l_type := l_feat.type
insert_field_or_prop_type (l_type)
-- Put name of attribute or property.
if
l_feat.written_class.is_external and then
attached {IL_EXTENSION_I} l_feat.extension as l_extension
then
l_feat_name := l_extension.alias_name
if not l_feat.is_attribute then
l_feat_name := l_feat_name.twin
check
l_feat_valid_count: l_feat_name.count > 4
has_setter: l_feat_name.substring (1, 4).is_equal ("get_")
end
l_feat_name.remove_head (4)
end
end
ca_blob.put_string (l_feat_name)
-- Finally generate value.
set_target_type (l_type)
l_expr_b.process (Current)
end
insert_integer_constant (a_int: INTEGER_CONSTANT)
-- Simply insert `a_int' into `ca_blob'. Depending on `target_type'
-- it might requires to actually put any of the NATURAL_XX/INTEGER_XX
-- compatible value, or a REAL_32/REAL_64 value.
local
l_element_type: INTEGER_8
l_feature_table: FEATURE_TABLE
l_feature_i: FEATURE_I
l_underlying_type: TYPE_A
do
if is_target_object then
-- We simply assume that we will put the INTEGER as is.
l_element_type := a_int.type.element_type
else
l_element_type := target_type.element_type
if
attached {CL_TYPE_A} target_type as l_cl_type_i and then
l_cl_type_i.base_class.is_enum
then
-- Use underlying integer type.
check
l_cl_type_i_not_void: l_cl_type_i /= Void
end
from
l_feature_table := l_cl_type_i.base_class.feature_table
l_feature_table.start
until
l_feature_table.after or else l_underlying_type /= Void
loop
l_feature_i := l_feature_table.item_for_iteration
if
attached {IL_EXTENSION_I} l_feature_i.extension as l_il_extension_i and then
l_il_extension_i.type = {SHARED_IL_CONSTANTS}.field_type
then
l_underlying_type := l_feature_i.type
end
l_feature_table.forth
end
if l_underlying_type /= Void then
l_element_type := l_underlying_type.element_type
end
end
end
inspect l_element_type
when {MD_SIGNATURE_CONSTANTS}.element_type_i1 then
ca_blob.put_integer_8 (a_int.integer_8_value)
when {MD_SIGNATURE_CONSTANTS}.element_type_i2 then
ca_blob.put_integer_16 (a_int.integer_16_value)
when {MD_SIGNATURE_CONSTANTS}.element_type_i4 then
ca_blob.put_integer_32 (a_int.integer_32_value)
when {MD_SIGNATURE_CONSTANTS}.element_type_i8 then
ca_blob.put_integer_64 (a_int.integer_64_value)
when {MD_SIGNATURE_CONSTANTS}.element_type_u1 then
ca_blob.put_natural_8 (a_int.natural_8_value)
when {MD_SIGNATURE_CONSTANTS}.element_type_u2 then
ca_blob.put_natural_16 (a_int.natural_16_value)
when {MD_SIGNATURE_CONSTANTS}.element_type_u4 then
ca_blob.put_natural_32 (a_int.natural_32_value)
when {MD_SIGNATURE_CONSTANTS}.element_type_u8 then
ca_blob.put_natural_64 (a_int.natural_64_value)
when {MD_SIGNATURE_CONSTANTS}.element_type_r4 then
inspect a_int.il_element_type
when
{MD_SIGNATURE_CONSTANTS}.element_type_i1,
{MD_SIGNATURE_CONSTANTS}.element_type_i2,
{MD_SIGNATURE_CONSTANTS}.element_type_i4,
{MD_SIGNATURE_CONSTANTS}.element_type_i8
then
ca_blob.put_real_32 (a_int.integer_64_value.to_real)
when
{MD_SIGNATURE_CONSTANTS}.element_type_u1,
{MD_SIGNATURE_CONSTANTS}.element_type_u2,
{MD_SIGNATURE_CONSTANTS}.element_type_u4,
{MD_SIGNATURE_CONSTANTS}.element_type_u8
then
ca_blob.put_real_32 (a_int.natural_64_value.to_real_32)
end
when {MD_SIGNATURE_CONSTANTS}.element_type_r8 then
inspect a_int.il_element_type
when
{MD_SIGNATURE_CONSTANTS}.element_type_i1,
{MD_SIGNATURE_CONSTANTS}.element_type_i2,
{MD_SIGNATURE_CONSTANTS}.element_type_i4,
{MD_SIGNATURE_CONSTANTS}.element_type_i8
then
ca_blob.put_real_64 (a_int.integer_64_value.to_double)
when
{MD_SIGNATURE_CONSTANTS}.element_type_u1,
{MD_SIGNATURE_CONSTANTS}.element_type_u2,
{MD_SIGNATURE_CONSTANTS}.element_type_u4,
{MD_SIGNATURE_CONSTANTS}.element_type_u8
then
ca_blob.put_real_64 (a_int.natural_64_value.to_real_64)
end
else
check not_reached: False end
end
end
insert_field_or_prop_type (a_type: TYPE_A)
-- Fill `FieldOrPropType' in `ca_blob'.
require
a_type_not_void: a_type /= Void
do
if not attached {CL_TYPE_A} a_type as l_cl_type then
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_boxed)
elseif l_cl_type.is_enum then
insert_enum_type (l_cl_type)
elseif l_cl_type.is_basic then
ca_blob.put_integer_8 (l_cl_type.element_type)
elseif l_cl_type.class_id = system.system_string_id then
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_string)
elseif l_cl_type.class_id = system.system_type_id then
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_type)
elseif l_cl_type.class_id = system.native_array_id then
-- Mark the fact it is an array
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_szarray)
check
has_generics: l_cl_type.generics /= Void and then
l_cl_type.generics.count = 1
end
-- Mark the type of elements.
insert_field_or_prop_type (l_cl_type.generics.first)
else
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_boxed)
end
end
insert_enum_type (a_cl_type: CL_TYPE_A)
-- Insert enum specification in `ca_blob'.
require
a_cl_type_not_void: a_cl_type /= Void
local
l_type_name: STRING_32
do
ca_blob.put_integer_8 ({MD_SIGNATURE_CONSTANTS}.element_type_enum)
create l_type_name.make_from_string_general (a_cl_type.il_type_name (Void, cil_generator.current_class_type.type))
l_type_name.append_character (',')
l_type_name.append_character (' ')
if attached {EXTERNAL_CLASS_C} a_cl_type.base_class as l_ext_class then
l_type_name.append (l_ext_class.assembly.full_name)
else
check is_ext_class: False end
end
ca_blob.put_string (l_type_name)
end
invariant
is_dotnet_compilation: system.il_generation
note
copyright: "Copyright (c) 1984-2023, Eiffel Software"
license: "GPL version 2 (see http://www.eiffel.com/licensing/gpl.txt)"
licensing_options: "http://www.eiffel.com/licensing"
copying: "[
This file is part of Eiffel Software's Eiffel Development Environment.
Eiffel Software's Eiffel Development Environment is free
software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published
by the Free Software Foundation, version 2 of the License
(available at the URL listed under "license" above).
Eiffel Software's Eiffel Development Environment is
distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public
License along with Eiffel Software's Eiffel Development
Environment; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
]"
source: "[
Eiffel Software
5949 Hollister Ave., Goleta, CA 93117 USA
Telephone 805-685-1006, Fax 805-685-6869
Website http://www.eiffel.com
Customer support http://support.eiffel.com
]"
end